bump tmtc

Reviewed-on: #890

.gitignore

@@ -22,3 +22,7 @@ __pycache__
 !/.idea/cmake.xml
 
 generators/*.db
+
+# Clangd LSP
+/compile_commands.json
+/.cache

.idea/cmake.xml

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

CHANGELOG.md

@@ -16,11 +16,615 @@ will consitute of a breaking change warranting a new major release:
 
 # [unreleased]
 
-# [v6.0.0] to be released
+# [v7.8.0] 2024-04-10
 
+## Changed
+
+- Reverted lower OP limit of `PLOC` to -10°C.
+- All pointing laws are now allowed to use the `MEKF` per default.
+- Changed limits in `PWR Controller`.
+- PUS time service: Now dumps the time before and after relative timeshift or setting absolute time
+- The `GPS Controller` does not set itself to `OFF` anymore, if it has not detected a valid fix for 
+  some time. Instead it attempts to reset both GNSS devices once.
+- The maximum time to reach a fix is shortened from 30min to 15min.
+- The time the reset pin of the GNSS devices is pulled is prolonged from 5ms to 10s.
+- A `GPS FIX HAS CHANGED` is now only triggered if no fix change has been detected within the past
+  2min. This means, this event might be thrown with a 2min delay. It is instantly thrown, if the mode
+  of the controller is changed. As arguments it now displays the new fix and the numer of fix changes
+  missed.
+- The number of satellites seen and used is reset to 0, in case they are set to invalid.
+- Altitude, latitude and longitude messages are not checked anymore, in case the mode message was 
+  already invalid.
+
+## Added
+
+- PUS timeservice relative timeshift.
+
+## Fixed
+
+- Fixed wrong order in quaternion multiplication for computation of the error quaternion.
+- Re-worked some FDIR logic in the FSFW. The former logic prevented events with a severity
+  higher than INFO if the device was in EXTERNAL CONTROL. The new logic will allow to trigger
+  events but still inhibit FDIR reactions if the device is in EXTERNAL CONTROL.
+
+# [v7.7.4] 2024-03-21
+
+## Changed
+
+- Rotational rate limit for the GS target pointing is now seperated from controller limit. It
+  is also reduced to 0.75°/s now.
+
+## Fixed
+
+- Fixed wrong sign in calculation of total current within the `PWR Controller`.
+
+# [v7.7.3] 2024-03-18
+
+- Bumped `eive-fsfw`
+
+## Added
+
+- Added parameter to disable STR input for MEKF.
+
+## Changed
+
+- If a primary heater is set to `EXTERNAL CONTROL` and `ON`, the `TCS Controller` will no
+  try to control the temperature of that object.
+- Set lower OP limit of `PLOC` to -5°C.
+
+## Fixed
+
+- Added prevention of sign jump for target quaternion of GS pointing, which would reduce the
+  performance of the controller.
+- Heaters set to `EXTERNAL CONTROL` no longer can be switched off by the `TCS Controller`, if
+  they violate the maximum burn duration of the controller.
+
+# [v7.7.2] 2024-03-06
+
+## Fixed
+
+- Camera and E-band antenna now point towards the target instead of away from the target for the
+  pointing target mode.
+
+# [v7.7.1] 2024-03-06
+
+- Bumped `eive-tmtc` to v6.1.1
+- Bumped `eive-fsfw`
+
+## Added
+
+- The `CoreController` now sets the leap seconds on initalization. They are stored in a persistent
+  file. If the file does yet not exist, it will be created. The leap seconds can be updated using an
+  action command. This will also update the file.
+
+## Fixed
+
+- Fixed wrong dimension of a matrix within the `MEKF`, which would lead to a seg fault, if the
+  star tracker was available.
+- Fixed case in which control values within the `AcsController` could become NaN.
+
+# [v7.7.0] 2024-02-29
+
+- Bumped `eive-tmtc` to v6.1.0
+- Bumped `eive-fsfw`
+
+## Fixed
+
+- PLOC SUPV sets: Added missing `PoolReadGuard` instantiations when reading boot status report
+  and latchup status report.
+- PLOC SUPV latchup report could not be handled previously.
+- Bugfix in PLOC SUPV latchup report parsing.
+- Bugfix in PLOC MPSoC HK set: Set and variables were not set valid.
+- The `PTG_CTRL_NO_ATTITUDE_INFORMATION` will now actually trigger a fallback into safe mode
+  and is triggered by the `AcsController` now.
+- Fixed a corner case, in which an invalid speed command could be sent to the `RwHandler`.
+- Fixed calculation of desaturation torque for faulty RWs.
+- Fixed bugs within the `MEKF` and simplified the code.
+
+## Changed
+
+- `FusedRotationRate` now only uses rotation rate from QUEST and STR in higher modes
+- QUEST and STR rates are now allowed per default
+- Changed PTG Strat priorities to favor STR before MEKF.
+- Increased message queue depth and maximum number of handled messages per cycle for
+  `PusServiceBase` based classes (especially PUS scheduler).
+- `MathOperations` functions were moved to their appropriate classes within the `eive-fsfw`
+- Changed pointing strategy for target groundstation mode to prevent blinding of the STR. This
+  also limits the rotation for the reference target quaternion to prevent spikes in required
+  rotation rates.
+- Updated QUEST and Sun Vector Params to new values.
+- Removed the satellites's angular momentum from desaturation calculation.
+- Bumped internal `sagittactl` library to v11.11.
+
+## Added
+
+- Updated STR handler to unlock and allow using the secondary firmware slot.
+- STR handling for new BlobStats TM set.
+- Added new action command to update the standard deviations within the `MEKF` from the
+  `AcsParameters`.
+
+# [v7.6.1] 2024-02-05
+
+## Changed
+
+- Guidance now uses the coordinate functions from the FSFW.
+- Idle should now point the STR away from the earth
+
+## Fixed
+
+- Fixed bugs in `Guidance::comparePtg` and corrected overloading
+- Detumbling State Machine is now robust to commanded mode changes.
+
+# [v7.6.0] 2024-01-30
+
+- Bumped `eive-tmtc` to v5.13.0
+- Bumped `eive-fsfw`
+
+## Added
+
+- Added new parameter for MPSoC which allows to skip SUPV commanding.
+
+## Changed
+
+- Increased allowed mode transition time for PLOC SUPV.
+- Detumbling can now be triggered from all modes of the `AcsController`. In case the
+  current mode is a higher pointing mode, the STR will be set to faulty, to trigger a
+  transition to safe first. Then, in a second step, a transition to detumble is triggered.
+
+## Fixed
+
+- If the PCDU handler fails reading data from the IPC store, it will
+  not try to do a deserialization anymore.
+- All action commands sent by the PLOC SUPV to itself will have no sender now.
+- RW speed commands get reset to 0 RPM, if the `AcsController` has changed its mode
+  to Safe
+- Antistiction for RWs will set commanded speed to 0 RPM, if a wheel is detected as not
+  working
+- Removed parameter to disable antistiction, as deactivating it would result in the
+  `AcsController` being allowed sending invalid speed commands to the RW Handler, which
+  would then trigger FDIR and turning off the functioning device
+- `RwHandler` returnvalues would use the `INTERFACE_ID` of the `DeviceHandlerBase`
+- The `AcsController` will reset its stored guidance values on mode change and lost
+  orientation.
+- The nullspace controller will only be used if all RWs are available.
+- Calculation of required rotation rate in pointing modes has been fixed to actual
+  calculation of rotation rate from two quaternions.
+- Fixed alignment matrix and pseudo inverses of RWs, to match the wrong definition of
+  positive rotation.
+
+# [v7.5.5] 2024-01-22
+
+## Fixed
+
+- Calculation of error quaternion was done with inverse of the required target quaternion.
+
+# [v7.5.4] 2024-01-16
+
+## Fixed
+
+- Pointing strategy now actually uses fused rotation rate source instead of its valid flag.
+- All datasets now get updated during pointing mode, even if the strategy is a fault one.
+
+# [v7.5.3] 2023-12-19
+
+## Fixed
+
+- Set STR quaternions to invalid in device handler if the solution is not trustworthy.
+
+# [v7.5.2] 2023-12-14
+
+## Fixed
+
+- Fixed faulty scaling within the QUEST algorithm.
+
+# [v7.5.1] 2023-12-13
+
+- `eive-tmtc` v5.12.1
+
+## Changed
+
+- Increased the maximum number of scheduled telecommands from 500 to 4000. Merry Christmas!
+
+## Fixed
+
+- Faulty mapping of input values for QUEST algorithm.
+- Fixed validity check for QUEST algorithm.
+
+# [v7.5.0] 2023-12-06
+
+- `eive-tmtc` v5.12.0
+
+## Changed
+
+- ACS-Board default side changed to B-Side
+- The TLE uploaded now gets stored in a file on the filesystem. It will always be stored on
+  the current active SD Card. After a reboot, the TLE will be read from the filesystem.
+  A filesystem change via `prefSD` on bootup, can lead to the TLE not being read, even
+  though it is there.
+- Added action cmd to read the currently stored TLE.
+- Both the `AcsController` and the `PwrController` now use the monotonic clock to calculate
+  the time difference.
+- `ACS Controller` now has the function `performAttitudeControl` which is called prior to passing
+  on to the relevant mode functions. It handles all telemetry relevant functions, which were
+  always called, regardless of the mode.
+ 
+## Added
+
+- Higher ACS modes can now be entered without a running `MEKF`. Higher modes will collect their
+  quaternion and rotational rate depending on the available sources.
+- `QUEST` attitude estimation was added to the `AcsController`.
+- The fused rotational rate can now be estimated from `QUEST` and the `STR`.
+
+# [v7.4.1] 2023-12-06
+
+## Fixed
+
+- Schedule SCEX again. Scheduling was removed accidentaly when Payload Task was converted to a PST.
+- SCEX transition was previously 0 seconds.. which did not lead to bugs? In any case it is 5
+  seconds now.
+
+# [v7.4.0] 2023-11-30
+
+- `eive-tmtc` v5.11.0
+
+## Changed
+
+- Rewrote the PLOC Supervisor Handler, which is now based on a new device handler base class.
+  Added ADC and Logging Counters telemetry set support.
+
+## Fixed
+
+- Increase allowed time for PTME writers to finish partial transfers. A duration of 200 ms was
+  not sufficient for cases where 3 writers write concurrently.
+- Fixed state issue for PTME writer object where the writer was not reset properly after a timeout
+  of a partial transfer. This was a major bug blocking the whole VC if it occured.
+- STR config path was previously hardcoded to `/mnt/sd0/startracker/flight-config.json`.
+  A new abstraction was introduces which now uses the active SD card to build the correct
+  config path when initializing the star tracker.
+
+## Added
+
+- PL PCDU: Add command to enable and disable channel order checks.
+- Added new PUS 15 subservice `DELETE_BY_TIME_RANGE` which allows to also specify a deletion
+  start time when deleting packets from the persistent TM store.
+- Introduced a new `RELOAD_JSON_CFG_FILE` command for the STR to reload the JSON configuration
+  data based on the current output of the config file path getter function. A reboot of the
+  device is still necessary to load the configuration to the STR.
+
+# [v7.3.0] 2023-11-07
+
+## Changed
+
+- Changed PDEC addresses depending on which firmware version is used. It is suspected that
+  the previous addresses were invalid and not properly covered by the Linux memory protection.
+  The OBSW will use the old addresses for older FW versions.
+- Reverted some STR ComIF behaviour back to an older software version.
+
+## Added
+
+- Always add PLOC MPSoC and PLOC SUPV components for the EM as well.
+
+# [v7.2.0] 2023-10-27
+
+- `eive-tmtc` v5.10.1
+
+## Added
+
+- STR: Added new TM sets: Blob, Blobs, MatchedCentroids, Contrast, AutoBlob, Centroid, Centroids
+- STR: Added new mechanism where the secondary TM which is polled can now be a set instead of
+  being temperature only. An API is exposed which allows to add a data set to that set of secondary
+  telemetry, reset it back to temperature only, and read the whole set. This allows more debugging
+  capability.
+- CFDP source handler, which allows file downlink using the standardized
+  CFDP interface.
+- Proper back pressure handling for the CFDP handler, where the `LiveTmTask` is able to throttle
+  the CFDP handler.
+- Added CFDP fault handler events.
+- The EIVE system will command the payload OFF explicitely again when receiving the
+  `power::POWER_LEVEL_CRITICAL` event.
+
+## Fixed
+
+- If the PTME is driven in a way where it fills faster than it can be emptied, the interface
+  can become full during the process of a regular packet write. The interface of the PAPB VC
+  was adapted to be stateful now. Packet generation is started with a `write` call while
+  write transfers are advanced and completed with the `advanceWrite` call if they can not be
+  completed immediately.
+- CFDP Space Packets SSC is now generated properly, was always 0 before.
+- Host build fixes
+- PL Enable set of the power controller is now set to invalid properly if the power controller
+  is not in normal mode.
+- MPSoC debug mode.
+- Possible bugfix for PL PCDU parameter JSON handling which might not have been initialized
+  properly from the JSON file.
+
+## Changed
+
+- Swapped RTD 9 (PLOC HPA Sensor) and RTD 11 (PLOC MPA Sensor) chip select definitions. It is
+  strongly suspected the cables for those devices were swapped during integration. This is probably
+  the easiest way to fix the issue without the need to tweak ground or other OBSW or controller
+  code.
+- Added a 3 second delay in the EIVE system between commanding all PL components except the SUPV,
+  and the SUPV itself OFF when the power level becomes low or critical.
+- SUS FDIR should now trigger less events. The finish event is now only triggered once the
+  SUS has been working properly for a minute again. It will then display the number of periods
+  during which the SUS was not working as well as the maximum amount of invalid messages.
+- Updated battery internal resistance to new value
+
+# [v7.1.0] 2023-10-11
+
+- Bumped `eive-tmtc` to v5.8.0.
+- Activate Xiphos WDT with a timeout period of 80 seconds using the `libxiphos` API. The WDT
+  calls are done by the new `XiphosWdtHandler` object.
+
+# [v7.0.0] 2023-10-11
+
+- Bumped `eive-tmtc` to v5.7.1.
+- Bumped `eive-fsfw`
+
+## Added
+
+- EPS Subsystem has been added to EIVE System Tree
+- Power Controller for calculating the State of Charge and FDIR regarding low SoC has been
+  introduced.
+
+## Changed
+
+- Changed internals for MPSoC boot process to make the code more understandable and some
+  parameters better configurable. This should not affect the behaviour of the OBSW, but might
+  make it more reliable and fix some corner cases.
+
+## Fixed
+
+- Missing `nullptr` checks for PLOC Supervisor handler, which could lead to crashes.
+- SCEX bugfix for normal and transition commanding.
+
+# [v6.6.0] 2023-09-18
+
+## Changed
+
+- Changed the memory initialized for the PDEC Config Memory and the PDEC RAM by using `mmap`
+  directly and ignoring UIO. This makes the OBSW compatible to a device tree update, where those
+  memory segments are marked reserved and are thus not properly accessible through the UIO API
+  anymore. This change should be downwards compatible to older device trees.
+
+# [v6.5.1] 2023-09-12
+
+- Bumped `eive-tmtc` to v5.5.0.
+
+# [v6.5.0] 2023-09-12
+
+## Changed
+
+- Relaxed SUS FDIR. The devices have shown to be glitchy in orbit, but still seem to deliver
+  sensible raw values most of the time. Some further testing is necessary, but some changes in the
+  code should cause the SUS devices to remain healthy for now.
+- The primary and the secondary temperature sensors for the PLOC mission boards are exchanged.
+- ACS parameters for the SUSMGM (FLP) safe mode have been adjusted. This safe mode is now the
+  default one.
+- MGM3100 Startup Configuration: Ignore bit 1 of the CMM reply, which is sometimes set to
+  1 in the reply for some reason.
+
+# [v6.4.1] 2023-08-21
+
+## Fixed
+
+- `PDEC_CONFIG_CORRUPTED` event now actually contains the readback instead of the expected
+  config
+- Magnetic field vector was not calculated if only MGM4 was available, but still written to
+  the dataset. This would result in a NaN vector. Allowance for usage of MGM4 is now checked
+  before entering calculation.
+
+# [v6.4.0] 2023-08-16
+
+- `eive-tmtc`: v5.4.3
+
+## Fixed
+
+- The handling function of the GPS data is only called once per GPS read. This should remove
+  the fake fix-has-changed events.
+- Fix for PLOC SUPV HK set parsing.
+- The timestamp for the `POSSIBLE_FILE_CORRUPTION` event will be generated properly now.
+
+## Changed
+
+- PDEC FDIR rework: A full PDEC reboot will now only be performed after a regular PDEC reset has
+  failed 10 times. The mechanism will reset after no PDEC reset has happended for 2 minutes.
+  The PDEC reset will be performed when counting 4 dirty frame events 10 seconds after the count
+  was incremented initially.
+- GPS Fix has changed event is no longer triggered for the EM
+- MGM and SUS rates now will only be calculated, if 2 valid consecutive datapoints are available.
+  The stored value of the last timestep will now be reset, if no actual value is available.
+
+## Added
+
+- The PLOC SUPV HK set is requested and downlinked periodically if the SUPV is on now.
+- SGP4 Propagator is now used for propagating the position of EIVE. It will only work once
+  a TLE has been uploaded with the newly added action command for the ACS Controller. In
+  return the actual GPS data will be ignored once SPG4 is running. However, by setting the
+  according parameter, the ACS Controller can be directed to ignore the SGP4 solution.
+- Skyview dataset for more GPS TM has been added
+- `PDEC_CONFIG_CORRUPTED` event which is triggered when the PDEC configuration does not match the
+  expected configuration. P1 will contain the readback of the first word and P2 will contain the
+  readback of the second word.
+- The MGM and SUS vectors being too close together does not prevent the usage of the safe
+  mode controller anymore.
+- Parameter to disable usage of MGM4, which is part of the MTQ and therefore cannot be
+  disabled without disabling the MTQ itself.
+
+# [v6.3.0] 2023-08-03
+
+## Fixed
+
+- Small SCEX fix: The temperatur check option was not passed
+  on for commands with a user data size larger than 1.
+- SCEX: Properly check whether filesystem is usable for filesystem checks.
+- ACS Controller strategy is now actually written to the dataset for detumbling.
+- During detumble the fused rotation rate is now calculated.
+- Detumbling is now exited when its exit value is undercut and not its entry value.
+- Rotation rate of last cycle is now stored in all cases for the fused rotational rate
+  calculation.
+- Fused rotation rate estimation during eclipse can be disabled. This will also prevent
+  detumbling during eclipse, as no relevant rotational rate is available for now.
+- `EiveSystem`: Add a small delay between triggering an event for FDIR reboots and sending the
+  command to the core controller.
+- PL PDU: Fixed bounds checking logic. Bound checks will only be performed for modules which are
+  enabled.
+
+## Changed
+
+- SCEX: Only perform filesystem checks when not in OFF mode.
+- The `EiveSystem` now only sends reboot commands targetting the same image.
+- Added 200 ms delay between switching HPA/MPA/TX/X8 and DRO GPIO pin OFF.
+- PL PCDU ADC set is now automatically enabled for `NORMAL` mode transitions. It is automatically
+  disabled for `OFF` mode transitions.
+
+## Added
+
+- PL PCDU for EM build.
+- SCEX: Add warning event if filesystem is unusable.
+
+# [v6.2.0] 2023-07-26
+
+- `eive-tmtc`: v5.3.1
+
+## Changed
+
+- STR missed reply handling is now moved to DHB rather than the COM interface. The COM IF will
+  still trigger an event if a reply is taking too long, and FDIR should still work via reply
+  timeouts.
+- Re-ordered some functions of the core controller in the initialize function.
+- Rad sensor is now only polled every 30 minutes instead of every device cycle to reduce wear of
+  the RADFET electronics.
+- The SD cards will still be switched OFF on a reboot, but this is done in a non-blocking manner
+  now with a timeout of 10 seconds where the reboot will be performed in any case.
+- ACS Controller now includes the safe mode from FLP, which will calculate its rotational rate
+  from SUS and MGM measurements. To accommodate these changes, low-pass filters for SUS
+  measurements and rates as well as MGM measurements and rates are included. Usage of the new
+  controller as well as settings of the low-pass filters can be handled via parameter commands.
+- Simplify and fix the chip and copy protection functions in the core controller. This mechanism
+  now is always performed for the target chip and target copy in the reboot handlers.
+- Improvement in FSFW: HK generation is now countdown based.
+
+## Added
+
+- 5 ms delay after pulling RADFET enable pin high before starting
+  the ADC conversion.
+- Set STR time in configuration sequence to firmware mode.
+- The STR `AutoThreshold` parameters are now set from the configuration JSON file at STR
+  startup.
+- The STR handler can now handle the COM error reply and triggers an low severity event accordingly.
+- Add SCEX handler for EM.
+- Radiation sensor handler dummy for the EM.
+- Added event for SD card information in core controller initialize function. This event will also
+  be triggered after the SD state machine has run, so the event will generally be triggered twice
+  at system boot, and once after commanding SD card switches.
+
+## Fixed
+
+- General bugs in the SD card state machine. This might fix some other known bugs for certain
+  combinations of switching ON and OFF SD cards and also makes the whole state machine a lot more
+  robust against hanging up.
+- SUS dummy handler went to `MODE_NORMAL` for ON commands.
+- PL PCDU dummy went to `MODE_NORMAL` for ON commands.
+
+# [v6.1.0] 2023-07-13
+
+- `eive-tmtc`: v5.2.0
+
+## Changed
+
+- TCS: Remove OBC IF board thermal module, which is exactly identical to OBC module and therefore
+  obsolete.
+- Swapped PL and PS I2C, BPX battery and MGT are connected to PS I2C now for firmware versions
+  equal or above v4. However, this software version is compatible to both v3 and v4 of the firmware.
+- The firmware version variables are global statics inititalized early during the program
+  runtime now. This makes it possible to check the firmware version earlier.
+- The TCS controller will now always command heaters OFF when being blind for thermal
+  components (no sensors available), irrespective of current switch state.
+- Make OBSW compatible to prospective FW version v5.0.0, where the Q7 I2C devices were
+  moved to a PL I2C block and the TMP sensor devices were moved to the PS I2C0.
+- Made `Xadc` code a little bit more robust against errors.
+
+## Fixed
+
+- TMP1075: Set dataset invalid on shutdown explicitely
+- Small fixes for TMP1075 FDIR: Use strange and missed reply counters.
+- TCS controller: Last heater (S-band heater) was skipped for transition completion
+  checks.
+- TCS controller: A helper member to track the elapsed heater control cycles was not reset
+  properly, which could lead to switch transitions being completed immediately. This can
+  lead to weird bugs like heaters being commanded ON twice and can potentially lead to
+  other bugs.
+- TMP1075: Devices did not go to OFF mode when being set faulty.
+- Update PL PCDU 1 in TCS mode tree on the EM.
+- TMP1075: Possibly ignored health commands.
+- Bugfix in FSFW where certain packet types could only be sent with source data fields with a
+  maximum size of 255 bytes.
+- TCS CTRL: Limit number of heater handler messages sent in case there are not sensors available
+  anymore.
+- Fix to allow adding real STR device for EM.
+
+# Added
+
+- Two events for heaters being commanded ON and OFF by the TCS controller
+- Upper limit for burn time of TCS heaters. Currently set to 1 hour for each heater.
+  This mechanism will only track the burn time for heaters which were commanded by the
+  TCS controller.
+- TCS controller is now observable by introducing a new HK dataset which exposes some internal
+  fields related to TCS control.
+
+# [v6.0.0] 2023-07-02
+
+- `q7s-package` version v3.2.0
 - Important bugfixes for PTME. See `q7s-package` CHANGELOG.
 
-# [v5.1.0] to be released
+## Changed
+
+- Added back PTME busy bit polling. This is necessary due to changes to the AXI APB interface
+  to the PTME core.
+
+## Fixed
+
+- For the live channel (VC0), telemetry was still only dumped if the transmitter is active.
+  Please note that this fix will lead to crashes for FW versions below v3.2.
+  However, it might not be an issue for the oldest firmware on the satellite (v2.5.1).
+
+# [v5.2.0] 2023-07-02
+
+## Fixed
+
+- The firmware information event was not triggered even when possible because of an ordering
+  bug in the initializer function.
+- Empty dumps (no TM in time range) will now correctly be completed immediately
+
+## Changed
+
+- PTME was always reset on submode changes. The reset will now only be performed if the actual data
+  rate changes.
+- Add back ACS board code for the EM. Now that the radiation sensor was removed, the image switching
+  issue has disappeared and adding back the ACS board is worth it for the GPS timekeeping.
+
+# [v5.1.0] 2023-06-28
+
+- `eive-tmtc` version v5.1.0
+
+## Changed
+
+- Persistent TM store dumps are now performed in chronological order.
+- Increase Syrlinks RX HK rate to 5.0 seconds during a pass.
+- Various robustness improvements for the heater handler. The heater handler will now only
+  process the command queue if it is not busy with switch commanding which reduces the amount
+  of possible bugs.
+- The heater handler is only able to process messages stricly sequentially now but is scheduled
+  twice in a 0.5 second slot so something like a consecutive heater ON or OFF command can still
+  be handled relatively quickly.
+
+## Added
+
+- Sequence counters for PUS and CFDP packets are now stored persistently across graceful reboots.
+- The PUS packet message type counter will now be incremented properly for each PUS service.
+- Internal error reporter set is now enabled by default and generated every 120 seconds.
 
 # [v5.0.0] 2023-06-26
 
@@ -368,7 +972,7 @@ This is the version which will fly on the satellite for the initial launch phase
   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 TCS controller pauses operations related to the TCS board assembly (reading sensors and
   the primary control loop) while a TCS board recovery is on-going.
 - Allow specifying custom OBSW update filename. This allowed keeping a cleaner file structure
   where each update has a name including the version
@@ -1433,8 +2037,8 @@ Syrlinks PR: PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/353
 - Syrlinks Handler: Read RX frequency shift as 24 bit signed number now. Also include
   validity handling for datasets.
   PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/350
-- `GyroADIS1650XHandler`: Changed calculation of angular rate to be sensitivity based instead of 
-  max. range based, as previous fix still left an margin of error between ADIS16505 sensors 
+- `GyroADIS1650XHandler`: Changed calculation of angular rate to be sensitivity based instead of
+  max. range based, as previous fix still left an margin of error between ADIS16505 sensors
   and L3GD20 sensors.
   PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/346
 

CMakeLists.txt

@@ -9,8 +9,8 @@
 # ##############################################################################
 cmake_minimum_required(VERSION 3.13)
 
-set(OBSW_VERSION_MAJOR 5)
-set(OBSW_VERSION_MINOR 0)
+set(OBSW_VERSION_MAJOR 7)
+set(OBSW_VERSION_MINOR 8)
 set(OBSW_VERSION_REVISION 0)
 
 # set(CMAKE_VERBOSE TRUE)
@@ -64,7 +64,7 @@ include(EiveHelpers)
 option(EIVE_ADD_ETL_LIB "Add ETL library" ON)
 option(EIVE_ADD_JSON_LIB "Add JSON library" ON)
 
-set(OBSW_MAX_SCHEDULED_TCS 500)
+set(OBSW_MAX_SCHEDULED_TCS 4000)
 
 if(EIVE_Q7S_EM)
   set(OBSW_Q7S_EM
@@ -93,7 +93,7 @@ set(OBSW_ADD_BPX_BATTERY_HANDLER
     1
     CACHE STRING "Add BPX battery module")
 set(OBSW_ADD_STAR_TRACKER
-    ${INIT_VAL}
+    1
     CACHE STRING "Add Startracker module")
 set(OBSW_ADD_SUN_SENSORS
     ${INIT_VAL}
@@ -105,7 +105,7 @@ set(OBSW_ADD_THERMAL_TEMP_INSERTER
     ${OBSW_Q7S_EM}
     CACHE STRING "Add thermal sensor temperature inserter")
 set(OBSW_ADD_ACS_BOARD
-    ${INIT_VAL}
+    1
     CACHE STRING "Add ACS board module")
 set(OBSW_ADD_GPS_CTRL
     ${INIT_VAL}
@@ -126,13 +126,13 @@ set(OBSW_ADD_HEATERS
     1
     CACHE STRING "Add TCS heaters")
 set(OBSW_ADD_PLOC_SUPERVISOR
-    ${INIT_VAL}
+    1
     CACHE STRING "Add PLOC supervisor handler")
 set(OBSW_ADD_SA_DEPL
     ${INIT_VAL}
     CACHE STRING "Add SA deployment handler")
 set(OBSW_ADD_PLOC_MPSOC
-    ${INIT_VAL}
+    1
     CACHE STRING "Add MPSoC handler")
 set(OBSW_ADD_ACS_CTRL
     ${INIT_VAL}
@@ -144,13 +144,13 @@ set(OBSW_ADD_RAD_SENSORS
     ${INIT_VAL}
     CACHE STRING "Add Rad Sensor module")
 set(OBSW_ADD_PL_PCDU
-    ${INIT_VAL}
+    1
     CACHE STRING "Add Payload PCDU modukle")
 set(OBSW_ADD_SYRLINKS
     1
     CACHE STRING "Add Syrlinks module")
 set(OBSW_ADD_TMP_DEVICES
-    ${INIT_VAL}
+    1
     CACHE STRING "Add TMP devices")
 set(OBSW_ADD_GOMSPACE_PCDU
     1
@@ -162,7 +162,7 @@ set(OBSW_ADD_RW
     ${INIT_VAL}
     CACHE STRING "Add RW modules")
 set(OBSW_ADD_SCEX_DEVICE
-    ${INIT_VAL}
+    1
     CACHE STRING "Add Solar Cell Experiment module")
 set(OBSW_SYRLINKS_SIMULATED
     0
@@ -240,6 +240,9 @@ set(FSFW_WARNING_SHADOW_LOCAL_GCC OFF)
 set(EIVE_ADD_LINUX_FILES OFF)
 set(FSFW_ADD_TMSTORAGE ON)
 
+set(FSFW_ADD_COORDINATES ON)
+set(FSFW_ADD_SGP4_PROPAGATOR ON)
+
 # Analyse different OS and architecture/target options, determine BSP_PATH,
 # display information about compiler etc.
 pre_source_hw_os_config()

README.md

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

archive/PlocSupervisorHandler.cpp

@@ -27,7 +27,7 @@ PlocSupervisorHandler::PlocSupervisorHandler(object_id_t objectId, CookieIF* com
       hkset(this),
       bootStatusReport(this),
       latchupStatusReport(this),
-      loggingReport(this),
+      countersReport(this),
       adcReport(this),
       powerSwitch(powerSwitch),
       uartManager(supvHelper) {
@@ -59,6 +59,19 @@ ReturnValue_t PlocSupervisorHandler::initialize() {
 }
 
 void PlocSupervisorHandler::performOperationHook() {
+  if (normalCommandIsPending and normalCmdCd.hasTimedOut()) {
+    // Event, FDIR, printout? Leads to spam though and normally should not happen..
+    normalCommandIsPending = false;
+  }
+  if (commandIsPending and cmdCd.hasTimedOut()) {
+    // Event, FDIR, printout? Leads to spam though and normally should not happen..
+    commandIsPending = false;
+
+    //    if(iter->second.sendReplyTo != NO_COMMANDER) {
+    //      actionHelper.finish(true, iter->second.sendReplyTo, iter->first, returnvalue::OK);
+    //    }
+    disableAllReplies();
+  }
   EventMessage event;
   for (ReturnValue_t result = eventQueue->receiveMessage(&event); result == returnvalue::OK;
        result = eventQueue->receiveMessage(&event)) {
@@ -155,21 +168,33 @@ void PlocSupervisorHandler::doStartUp() {
     startupState = StartupState::ON;
   }
   if (startupState == StartupState::ON) {
+    hkset.setReportingEnabled(true);
+    supv::SUPV_ON = true;
     setMode(_MODE_TO_ON);
   }
 }
 
 void PlocSupervisorHandler::doShutDown() {
   setMode(_MODE_POWER_DOWN);
+  hkset.setReportingEnabled(false);
+  hkset.setValidity(false, true);
   shutdownCmdSent = false;
   packetInBuffer = false;
   nextReplyId = supv::NONE;
   uartManager.stop();
   uartIsolatorSwitch.pullLow();
+  disableAllReplies();
+  supv::SUPV_ON = false;
   startupState = StartupState::OFF;
 }
 
 ReturnValue_t PlocSupervisorHandler::buildNormalDeviceCommand(DeviceCommandId_t* id) {
+  if (not normalCommandIsPending) {
+    *id = GET_HK_REPORT;
+    normalCommandIsPending = true;
+    normalCmdCd.resetTimer();
+    return buildCommandFromCommand(*id, nullptr, 0);
+  }
   return NOTHING_TO_SEND;
 }
 
@@ -195,11 +220,13 @@ ReturnValue_t PlocSupervisorHandler::buildCommandFromCommand(DeviceCommandId_t d
       break;
     }
     case START_MPSOC: {
+      sif::info << "PLOC SUPV: Starting MPSoC" << std::endl;
       prepareEmptyCmd(Apid::BOOT_MAN, static_cast<uint8_t>(tc::BootManId::START_MPSOC));
       result = returnvalue::OK;
       break;
     }
     case SHUTDOWN_MPSOC: {
+      sif::info << "PLOC SUPV: Shutting down MPSoC" << std::endl;
       prepareEmptyCmd(Apid::BOOT_MAN, static_cast<uint8_t>(tc::BootManId::SHUTDOWN_MPSOC));
       result = returnvalue::OK;
       break;
@@ -210,6 +237,7 @@ ReturnValue_t PlocSupervisorHandler::buildCommandFromCommand(DeviceCommandId_t d
       break;
     }
     case RESET_MPSOC: {
+      sif::info << "PLOC SUPV: Resetting MPSoC" << std::endl;
       prepareEmptyCmd(Apid::BOOT_MAN, static_cast<uint8_t>(tc::BootManId::RESET_MPSOC));
       result = returnvalue::OK;
       break;
@@ -260,8 +288,7 @@ ReturnValue_t PlocSupervisorHandler::buildCommandFromCommand(DeviceCommandId_t d
       break;
     }
     case SET_GPIO: {
-      prepareSetGpioCmd(commandData);
-      result = returnvalue::OK;
+      result = prepareSetGpioCmd(commandData, commandDataLen);
       break;
     }
     case FACTORY_RESET: {
@@ -269,8 +296,7 @@ ReturnValue_t PlocSupervisorHandler::buildCommandFromCommand(DeviceCommandId_t d
       break;
     }
     case READ_GPIO: {
-      prepareReadGpioCmd(commandData);
-      result = returnvalue::OK;
+      result = prepareReadGpioCmd(commandData, commandDataLen);
       break;
     }
     case SET_SHUTDOWN_TIMEOUT: {
@@ -307,91 +333,25 @@ ReturnValue_t PlocSupervisorHandler::buildCommandFromCommand(DeviceCommandId_t d
       result = prepareWipeMramCmd(commandData);
       break;
     }
-      //    case ENABLE_NVMS: {
-      //      result = prepareEnableNvmsCommand(commandData);
-      //      break;
-      //    }
-      //    case RESTART_SUPERVISOR: {
-      //      prepareEmptyCmd(APID_RESTART_SUPERVISOR);
-      //      result = returnvalue::OK;
-      //      break;
-      //    }
-      // Removed command
-      //    case START_MPSOC_QUIET: {
-      //      prepareEmptyCmd(APID_START_MPSOC_QUIET);
-      //      result = returnvalue::OK;
-      //      break;
-      //    }
-      //    case ENABLE_AUTO_TM: {
-      //      EnableAutoTm packet(spParams);
-      //      result = packet.buildPacket();
-      //      if (result != returnvalue::OK) {
-      //        break;
-      //      }
-      //      finishTcPrep(packet.getFullPacketLen());
-      //      break;
-      //    }
-      //    case DISABLE_AUTO_TM: {
-      //      DisableAutoTm packet(spParams);
-      //      result = packet.buildPacket();
-      //      if (result != returnvalue::OK) {
-      //        break;
-      //      }
-      //      finishTcPrep(packet.getFullPacketLen());
-      //      break;
-      //    }
-      //    case LOGGING_REQUEST_COUNTERS: {
-      //      RequestLoggingData packet(spParams);
-      //      result = packet.buildPacket(RequestLoggingData::Sa::REQUEST_COUNTERS);
-      //      if (result != returnvalue::OK) {
-      //        break;
-      //      }
-      //      finishTcPrep(packet.getFullPacketLen());
-      //      break;
-      //    }
-      //    case LOGGING_CLEAR_COUNTERS: {
-      //      RequestLoggingData packet(spParams);
-      //      result = packet.buildPacket(RequestLoggingData::Sa::CLEAR_COUNTERS);
-      //      if (result != returnvalue::OK) {
-      //        break;
-      //      }
-      //      finishTcPrep(packet.getFullPacketLen());
-      //      break;
-      //    }
-      //    case LOGGING_SET_TOPIC: {
-      //      if (commandData == nullptr or commandDataLen == 0) {
-      //        return HasActionsIF::INVALID_PARAMETERS;
-      //      }
-      //      uint8_t tpc = *(commandData);
-      //      RequestLoggingData packet(spParams);
-      //      result = packet.buildPacket(RequestLoggingData::Sa::SET_LOGGING_TOPIC, tpc);
-      //      if (result != returnvalue::OK) {
-      //        break;
-      //      }
-      //      finishTcPrep(packet.getFullPacketLen());
-      //      break;
-      //    }
-      // I think this is disabled right now according to the TC excel table
-      //    case COPY_ADC_DATA_TO_MRAM: {
-      //      prepareEmptyCmd(APID_COPY_ADC_DATA_TO_MRAM);
-      //      result = returnvalue::OK;
-      //      break;
-      //    }
-      //    case REQUEST_ADC_REPORT: {
-      //      prepareEmptyCmd(APID_REQUEST_ADC_REPORT);
-      //      result = returnvalue::OK;
-      //      break;
-      //    }
-      //    case FIRST_MRAM_DUMP:
-      //    case CONSECUTIVE_MRAM_DUMP:
-      //      result = prepareDumpMramCmd(commandData);
-      //      break;
+    case REQUEST_ADC_REPORT: {
+      prepareEmptyCmd(Apid::ADC_MON, static_cast<uint8_t>(tc::AdcMonId::REQUEST_ADC_SAMPLE));
+      result = returnvalue::OK;
+      break;
+    }
+    case REQUEST_LOGGING_COUNTERS: {
+      prepareEmptyCmd(Apid::DATA_LOGGER,
+                      static_cast<uint8_t>(tc::DataLoggerServiceId::REQUEST_COUNTERS));
+      result = returnvalue::OK;
+      break;
+    }
     default:
       sif::debug << "PlocSupervisorHandler::buildCommandFromCommand: Command not implemented"
                  << std::endl;
       result = DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
       break;
   }
+  commandIsPending = true;
+  cmdCd.resetTimer();
   return result;
 }
 
@@ -423,6 +383,8 @@ void PlocSupervisorHandler::fillCommandAndReplyMap() {
   insertInCommandMap(SET_ADC_THRESHOLD);
   insertInCommandMap(SET_ADC_WINDOW_AND_STRIDE);
   insertInCommandMap(RESET_PL);
+  insertInCommandMap(REQUEST_ADC_REPORT);
+  insertInCommandMap(REQUEST_LOGGING_COUNTERS);
 
   // ACK replies, use countdown for them
   insertInReplyMap(ACK_REPORT, 0, nullptr, SIZE_ACK_REPORT, false, &acknowledgementReportTimeout);
@@ -430,10 +392,10 @@ void PlocSupervisorHandler::fillCommandAndReplyMap() {
   insertInReplyMap(MEMORY_CHECK, 5, nullptr, 0, false);
 
   // TM replies
-  insertInReplyMap(HK_REPORT, 3, &hkset, SIZE_HK_REPORT);
+  insertInReplyMap(HK_REPORT, 3, &hkset);
   insertInReplyMap(BOOT_STATUS_REPORT, 3, &bootStatusReport, SIZE_BOOT_STATUS_REPORT);
   insertInReplyMap(LATCHUP_REPORT, 3, &latchupStatusReport, SIZE_LATCHUP_STATUS_REPORT);
-  insertInReplyMap(LOGGING_REPORT, 3, &loggingReport, SIZE_LOGGING_REPORT);
+  insertInReplyMap(COUNTERS_REPORT, 3, &countersReport, SIZE_COUNTERS_REPORT);
   insertInReplyMap(ADC_REPORT, 3, &adcReport, SIZE_ADC_REPORT);
 }
 
@@ -475,13 +437,13 @@ ReturnValue_t PlocSupervisorHandler::enableReplyInReplyMap(DeviceCommandMap::ite
       }
       break;
     }
-    case LOGGING_REQUEST_COUNTERS: {
+    case REQUEST_LOGGING_COUNTERS: {
       enabledReplies = 3;
       result =
-          DeviceHandlerBase::enableReplyInReplyMap(command, enabledReplies, true, LOGGING_REPORT);
+          DeviceHandlerBase::enableReplyInReplyMap(command, enabledReplies, true, COUNTERS_REPORT);
       if (result != returnvalue::OK) {
         sif::debug << "PlocSupervisorHandler::enableReplyInReplyMap: Reply with id "
-                   << LOGGING_REPORT << " not in replyMap" << std::endl;
+                   << COUNTERS_REPORT << " not in replyMap" << std::endl;
       }
       break;
     }
@@ -537,23 +499,17 @@ ReturnValue_t PlocSupervisorHandler::enableReplyInReplyMap(DeviceCommandMap::ite
     case SET_ADC_ENABLED_CHANNELS:
     case SET_ADC_WINDOW_AND_STRIDE:
     case SET_ADC_THRESHOLD:
-    // case COPY_ADC_DATA_TO_MRAM:
     case RUN_AUTO_EM_TESTS:
     case WIPE_MRAM:
     case SET_GPIO:
     case FACTORY_RESET:
     case READ_GPIO:
-    // case RESTART_SUPERVISOR:
     case DISABLE_PERIOIC_HK_TRANSMISSION:
-    // case START_MPSOC_QUIET:
     case SET_SHUTDOWN_TIMEOUT:
     case FACTORY_FLASH:
     case ENABLE_AUTO_TM:
     case DISABLE_AUTO_TM:
-    // case LOGGING_CLEAR_COUNTERS:
-    // case LOGGING_SET_TOPIC:
     case RESET_PL:
-      // case ENABLE_NVMS:
       enabledReplies = 2;
       break;
     default:
@@ -585,19 +541,12 @@ ReturnValue_t PlocSupervisorHandler::enableReplyInReplyMap(DeviceCommandMap::ite
 ReturnValue_t PlocSupervisorHandler::scanForReply(const uint8_t* start, size_t remainingSize,
                                                   DeviceCommandId_t* foundId, size_t* foundLen) {
   using namespace supv;
-  // TODO: Is this still required?
-  //  if (nextReplyId == FIRST_MRAM_DUMP) {
-  //    *foundId = FIRST_MRAM_DUMP;
-  //    return parseMramPackets(start, remainingSize, foundLen);
-  //  } else if (nextReplyId == CONSECUTIVE_MRAM_DUMP) {
-  //    *foundId = CONSECUTIVE_MRAM_DUMP;
-  //    return parseMramPackets(start, remainingSize, foundLen);
-  //  }
 
   tmReader.setData(start, remainingSize);
-  // sif::debug << "PlocSupervisorHandler::scanForReply: Received Packet" << std::endl;
-  // arrayprinter::print(start, remainingSize);
   uint16_t apid = tmReader.getModuleApid();
+  if (DEBUG_PLOC_SUPV) {
+    handlePacketPrint();
+  }
 
   switch (apid) {
     case (Apid::TMTC_MAN): {
@@ -619,6 +568,9 @@ ReturnValue_t PlocSupervisorHandler::scanForReply(const uint8_t* start, size_t r
     }
     case (Apid::HK): {
       if (tmReader.getServiceId() == static_cast<uint8_t>(supv::tm::HkId::REPORT)) {
+        normalCommandIsPending = false;
+        // Yeah apparently this is needed??
+        disableCommand(GET_HK_REPORT);
         *foundLen = tmReader.getFullPacketLen();
         *foundId = ReplyId::HK_REPORT;
         return OK;
@@ -637,6 +589,14 @@ ReturnValue_t PlocSupervisorHandler::scanForReply(const uint8_t* start, size_t r
       }
       break;
     }
+    case (Apid::ADC_MON): {
+      if (tmReader.getServiceId() == static_cast<uint8_t>(supv::tm::AdcMonId::ADC_REPORT)) {
+        *foundLen = tmReader.getFullPacketLen();
+        *foundId = ReplyId::ADC_REPORT;
+        return OK;
+      }
+      break;
+    }
     case (Apid::MEM_MAN): {
       if (tmReader.getServiceId() ==
           static_cast<uint8_t>(supv::tm::MemManId::UPDATE_STATUS_REPORT)) {
@@ -644,6 +604,15 @@ ReturnValue_t PlocSupervisorHandler::scanForReply(const uint8_t* start, size_t r
         *foundId = ReplyId::UPDATE_STATUS_REPORT;
         return OK;
       }
+      break;
+    }
+    case (Apid::DATA_LOGGER): {
+      if (tmReader.getServiceId() ==
+          static_cast<uint8_t>(supv::tm::DataLoggerId::COUNTERS_REPORT)) {
+        *foundLen = tmReader.getFullPacketLen();
+        *foundId = ReplyId::COUNTERS_REPORT;
+        return OK;
+      }
     }
   }
   handleBadApidServiceCombination(SUPV_UNKNOWN_TM, apid, tmReader.getServiceId());
@@ -651,6 +620,58 @@ ReturnValue_t PlocSupervisorHandler::scanForReply(const uint8_t* start, size_t r
   return INVALID_DATA;
 }
 
+void PlocSupervisorHandler::handlePacketPrint() {
+  if (tmReader.getModuleApid() == Apid::TMTC_MAN) {
+    if ((tmReader.getServiceId() == static_cast<uint8_t>(supv::tm::TmtcId::ACK)) or
+        (tmReader.getServiceId() == static_cast<uint8_t>(supv::tm::TmtcId::NAK))) {
+      AcknowledgmentReport ack(tmReader);
+      ReturnValue_t result = ack.parse();
+      if (result != returnvalue::OK) {
+        sif::warning << "PlocSupervisorHandler: Parsing ACK failed" << std::endl;
+      }
+      if (REDUCE_NORMAL_MODE_PRINTOUT and ack.getRefModuleApid() == (uint8_t)supv::Apid::HK and
+          ack.getRefServiceId() == (uint8_t)supv::tc::HkId::GET_REPORT) {
+        return;
+      }
+      const char* printStr = "???";
+      if (tmReader.getServiceId() == static_cast<uint8_t>(supv::tm::TmtcId::ACK)) {
+        printStr = "ACK";
+
+      } else if (tmReader.getServiceId() == static_cast<uint8_t>(supv::tm::TmtcId::NAK)) {
+        printStr = "NAK";
+      }
+      sif::debug << "PlocSupervisorHandler: RECV " << printStr << " for APID Module ID "
+                 << (int)ack.getRefModuleApid() << " Service ID " << (int)ack.getRefServiceId()
+                 << " Seq Count " << ack.getRefSequenceCount() << std::endl;
+      return;
+    } else if ((tmReader.getServiceId() == static_cast<uint8_t>(supv::tm::TmtcId::EXEC_ACK)) or
+               (tmReader.getServiceId() == static_cast<uint8_t>(supv::tm::TmtcId::EXEC_NAK))) {
+      ExecutionReport exe(tmReader);
+      ReturnValue_t result = exe.parse();
+      if (result != returnvalue::OK) {
+        sif::warning << "PlocSupervisorHandler: Parsing EXE failed" << std::endl;
+      }
+      const char* printStr = "???";
+      if (REDUCE_NORMAL_MODE_PRINTOUT and exe.getRefModuleApid() == (uint8_t)supv::Apid::HK and
+          exe.getRefServiceId() == (uint8_t)supv::tc::HkId::GET_REPORT) {
+        return;
+      }
+      if (tmReader.getServiceId() == static_cast<uint8_t>(supv::tm::TmtcId::EXEC_ACK)) {
+        printStr = "ACK EXE";
+
+      } else if (tmReader.getServiceId() == static_cast<uint8_t>(supv::tm::TmtcId::EXEC_NAK)) {
+        printStr = "NAK EXE";
+      }
+      sif::debug << "PlocSupervisorHandler: RECV " << printStr << " for APID Module ID "
+                 << (int)exe.getRefModuleApid() << " Service ID " << (int)exe.getRefServiceId()
+                 << " Seq Count " << exe.getRefSequenceCount() << std::endl;
+      return;
+    }
+  }
+  sif::debug << "PlocSupervisorHandler: RECV PACKET Size " << tmReader.getFullPacketLen()
+             << " Module APID " << (int)tmReader.getModuleApid() << " Service ID "
+             << (int)tmReader.getServiceId() << std::endl;
+}
 ReturnValue_t PlocSupervisorHandler::interpretDeviceReply(DeviceCommandId_t id,
                                                           const uint8_t* packet) {
   using namespace supv;
@@ -669,12 +690,22 @@ ReturnValue_t PlocSupervisorHandler::interpretDeviceReply(DeviceCommandId_t id,
       result = handleBootStatusReport(packet);
       break;
     }
+    case (COUNTERS_REPORT): {
+      result = genericHandleTm("COUNTERS", packet, countersReport);
+#if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_PLOC_SUPERVISOR == 1
+      countersReport.printSet();
+#endif
+      break;
+    }
     case (LATCHUP_REPORT): {
       result = handleLatchupStatusReport(packet);
       break;
     }
     case (ADC_REPORT): {
-      result = handleAdcReport(packet);
+      result = genericHandleTm("ADC", packet, adcReport);
+#if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_PLOC_SUPERVISOR == 1
+      adcReport.printSet();
+#endif
       break;
     }
     case (EXE_REPORT): {
@@ -739,13 +770,8 @@ ReturnValue_t PlocSupervisorHandler::initializeLocalDataPool(localpool::DataPool
   localDataPoolMap.emplace(supv::LATCHUP_RPT_TIME_YEAR, new PoolEntry<uint8_t>({0}));
   localDataPoolMap.emplace(supv::LATCHUP_RPT_IS_SET, new PoolEntry<uint8_t>({0}));
 
-  localDataPoolMap.emplace(supv::LATCHUP_HAPPENED_CNT_0, new PoolEntry<uint32_t>({0}));
-  localDataPoolMap.emplace(supv::LATCHUP_HAPPENED_CNT_1, new PoolEntry<uint32_t>({0}));
-  localDataPoolMap.emplace(supv::LATCHUP_HAPPENED_CNT_2, new PoolEntry<uint32_t>({0}));
-  localDataPoolMap.emplace(supv::LATCHUP_HAPPENED_CNT_3, new PoolEntry<uint32_t>({0}));
-  localDataPoolMap.emplace(supv::LATCHUP_HAPPENED_CNT_4, new PoolEntry<uint32_t>({0}));
-  localDataPoolMap.emplace(supv::LATCHUP_HAPPENED_CNT_5, new PoolEntry<uint32_t>({0}));
-  localDataPoolMap.emplace(supv::LATCHUP_HAPPENED_CNT_6, new PoolEntry<uint32_t>({0}));
+  localDataPoolMap.emplace(supv::SIGNATURE, new PoolEntry<uint32_t>());
+  localDataPoolMap.emplace(supv::LATCHUP_HAPPENED_CNTS, &latchupCounters);
   localDataPoolMap.emplace(supv::ADC_DEVIATION_TRIGGERS_CNT, new PoolEntry<uint32_t>({0}));
   localDataPoolMap.emplace(supv::TC_RECEIVED_CNT, new PoolEntry<uint32_t>({0}));
   localDataPoolMap.emplace(supv::TM_AVAILABLE_CNT, new PoolEntry<uint32_t>({0}));
@@ -754,42 +780,25 @@ ReturnValue_t PlocSupervisorHandler::initializeLocalDataPool(localpool::DataPool
   localDataPoolMap.emplace(supv::MPSOC_BOOT_FAILED_ATTEMPTS, new PoolEntry<uint32_t>({0}));
   localDataPoolMap.emplace(supv::MPSOC_POWER_UP, new PoolEntry<uint32_t>({0}));
   localDataPoolMap.emplace(supv::MPSOC_UPDATES, new PoolEntry<uint32_t>({0}));
-  localDataPoolMap.emplace(supv::LAST_RECVD_TC, new PoolEntry<uint32_t>({0}));
+  localDataPoolMap.emplace(supv::MPSOC_HEARTBEAT_RESETS, new PoolEntry<uint32_t>({0}));
+  localDataPoolMap.emplace(supv::CPU_WDT_RESETS, new PoolEntry<uint32_t>({0}));
+  localDataPoolMap.emplace(supv::PS_HEARTBEATS_LOST, new PoolEntry<uint32_t>({0}));
+  localDataPoolMap.emplace(supv::PL_HEARTBEATS_LOST, new PoolEntry<uint32_t>({0}));
+  localDataPoolMap.emplace(supv::EB_TASK_LOST, new PoolEntry<uint32_t>({0}));
+  localDataPoolMap.emplace(supv::BM_TASK_LOST, new PoolEntry<uint32_t>({0}));
+  localDataPoolMap.emplace(supv::LM_TASK_LOST, new PoolEntry<uint32_t>({0}));
+  localDataPoolMap.emplace(supv::AM_TASK_LOST, new PoolEntry<uint32_t>({0}));
+  localDataPoolMap.emplace(supv::TCTMM_TASK_LOST, new PoolEntry<uint32_t>({0}));
+  localDataPoolMap.emplace(supv::MM_TASK_LOST, new PoolEntry<uint32_t>({0}));
+  localDataPoolMap.emplace(supv::HK_TASK_LOST, new PoolEntry<uint32_t>({0}));
+  localDataPoolMap.emplace(supv::DL_TASK_LOST, new PoolEntry<uint32_t>({0}));
+  localDataPoolMap.emplace(supv::RWS_TASKS_LOST, new PoolEntry<uint32_t>(3));
 
-  localDataPoolMap.emplace(supv::ADC_RAW_0, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(supv::ADC_RAW_1, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(supv::ADC_RAW_2, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(supv::ADC_RAW_3, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(supv::ADC_RAW_4, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(supv::ADC_RAW_5, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(supv::ADC_RAW_6, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(supv::ADC_RAW_7, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(supv::ADC_RAW_8, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(supv::ADC_RAW_9, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(supv::ADC_RAW_10, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(supv::ADC_RAW_11, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(supv::ADC_RAW_12, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(supv::ADC_RAW_13, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(supv::ADC_RAW_14, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(supv::ADC_RAW_15, new PoolEntry<uint16_t>({0}));
-
-  localDataPoolMap.emplace(supv::ADC_ENG_0, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(supv::ADC_ENG_1, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(supv::ADC_ENG_2, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(supv::ADC_ENG_3, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(supv::ADC_ENG_4, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(supv::ADC_ENG_5, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(supv::ADC_ENG_6, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(supv::ADC_ENG_7, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(supv::ADC_ENG_8, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(supv::ADC_ENG_9, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(supv::ADC_ENG_10, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(supv::ADC_ENG_11, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(supv::ADC_ENG_12, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(supv::ADC_ENG_13, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(supv::ADC_ENG_14, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(supv::ADC_ENG_15, new PoolEntry<uint16_t>({0}));
+  localDataPoolMap.emplace(supv::ADC_RAW, &adcRawEntry);
+  localDataPoolMap.emplace(supv::ADC_ENG, &adcEngEntry);
 
+  poolManager.subscribeForRegularPeriodicPacket(
+      subdp::RegularHkPeriodicParams(hkset.getSid(), false, 10.0));
   return returnvalue::OK;
 }
 
@@ -911,6 +920,7 @@ ReturnValue_t PlocSupervisorHandler::handleExecutionReport(const uint8_t* data)
   } else if (tmReader.getServiceId() == static_cast<uint8_t>(supv::tm::TmtcId::EXEC_NAK)) {
     handleExecutionFailureReport(report);
   }
+  commandIsPending = false;
   nextReplyId = supv::NONE;
   return result;
 }
@@ -918,7 +928,7 @@ ReturnValue_t PlocSupervisorHandler::handleExecutionReport(const uint8_t* data)
 ReturnValue_t PlocSupervisorHandler::handleHkReport(const uint8_t* data) {
   ReturnValue_t result = returnvalue::OK;
 
-  result = verifyPacket(data, supv::SIZE_HK_REPORT);
+  result = verifyPacket(data, tmReader.getFullPacketLen());
 
   if (result == result::CRC_FAILURE) {
     sif::error << "PlocSupervisorHandler::handleHkReport: Hk report has invalid crc" << std::endl;
@@ -1145,37 +1155,31 @@ ReturnValue_t PlocSupervisorHandler::handleLatchupStatusReport(const uint8_t* da
   return result;
 }
 
-ReturnValue_t PlocSupervisorHandler::handleAdcReport(const uint8_t* data) {
+ReturnValue_t PlocSupervisorHandler::genericHandleTm(const char* contextString, const uint8_t* data,
+                                                     LocalPoolDataSetBase& set) {
   ReturnValue_t result = returnvalue::OK;
 
-  result = verifyPacket(data, supv::SIZE_ADC_REPORT);
+  result = verifyPacket(data, tmReader.getFullPacketLen());
 
   if (result == result::CRC_FAILURE) {
-    sif::error << "PlocSupervisorHandler::handleAdcReport: ADC report has "
-               << "invalid crc" << std::endl;
+    sif::warning << "PlocSupervisorHandler: " << contextString << " report has "
+                 << "invalid CRC" << std::endl;
     return result;
   }
 
   const uint8_t* dataField = data + supv::PAYLOAD_OFFSET;
-  result = adcReport.read();
-  if (result != returnvalue::OK) {
+  PoolReadGuard pg(&set);
+  if (pg.getReadResult() != returnvalue::OK) {
     return result;
   }
-  adcReport.setValidityBufferGeneration(false);
-  size_t size = adcReport.getSerializedSize();
-  result = adcReport.deSerialize(&dataField, &size, SerializeIF::Endianness::BIG);
+  set.setValidityBufferGeneration(false);
+  size_t size = set.getSerializedSize();
+  result = set.deSerialize(&dataField, &size, SerializeIF::Endianness::BIG);
   if (result != returnvalue::OK) {
-    sif::warning << "PlocSupervisorHandler::handleAdcReport: Deserialization failed" << std::endl;
+    sif::warning << "PlocSupervisorHandler: Deserialization failed" << std::endl;
   }
-  adcReport.setValidityBufferGeneration(true);
-  adcReport.setValidity(true, true);
-  result = adcReport.commit();
-  if (result != returnvalue::OK) {
-    return result;
-  }
-#if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_PLOC_SUPERVISOR == 1
-  adcReport.printSet();
-#endif
+  set.setValidityBufferGeneration(true);
+  set.setValidity(true, true);
   nextReplyId = supv::EXE_REPORT;
   return result;
 }
@@ -1197,8 +1201,8 @@ void PlocSupervisorHandler::setNextReplyId() {
     case supv::CONSECUTIVE_MRAM_DUMP:
       nextReplyId = supv::CONSECUTIVE_MRAM_DUMP;
       break;
-    case supv::LOGGING_REQUEST_COUNTERS:
-      nextReplyId = supv::LOGGING_REPORT;
+    case supv::REQUEST_LOGGING_COUNTERS:
+      nextReplyId = supv::COUNTERS_REPORT;
       break;
     case supv::REQUEST_ADC_REPORT:
       nextReplyId = supv::ADC_REPORT;
@@ -1277,7 +1281,7 @@ ReturnValue_t PlocSupervisorHandler::prepareEmptyCmd(uint16_t apid, uint8_t serv
   if (result != returnvalue::OK) {
     return result;
   }
-  finishTcPrep(packet.getFullPacketLen());
+  finishTcPrep(packet);
   return returnvalue::OK;
 }
 
@@ -1288,7 +1292,7 @@ ReturnValue_t PlocSupervisorHandler::prepareSelBootImageCmd(const uint8_t* comma
   if (result != returnvalue::OK) {
     return result;
   }
-  finishTcPrep(packet.getFullPacketLen());
+  finishTcPrep(packet);
   return returnvalue::OK;
 }
 
@@ -1305,7 +1309,7 @@ ReturnValue_t PlocSupervisorHandler::prepareSetTimeRefCmd() {
   if (result != returnvalue::OK) {
     return result;
   }
-  finishTcPrep(packet.getFullPacketLen());
+  finishTcPrep(packet);
   return returnvalue::OK;
 }
 
@@ -1315,7 +1319,7 @@ ReturnValue_t PlocSupervisorHandler::prepareDisableHk() {
   if (result != returnvalue::OK) {
     return result;
   }
-  finishTcPrep(packet.getFullPacketLen());
+  finishTcPrep(packet);
   return returnvalue::OK;
 }
 
@@ -1327,7 +1331,7 @@ ReturnValue_t PlocSupervisorHandler::prepareSetBootTimeoutCmd(const uint8_t* com
   if (result != returnvalue::OK) {
     return result;
   }
-  finishTcPrep(packet.getFullPacketLen());
+  finishTcPrep(packet);
   return returnvalue::OK;
 }
 
@@ -1338,7 +1342,7 @@ ReturnValue_t PlocSupervisorHandler::prepareRestartTriesCmd(const uint8_t* comma
   if (result != returnvalue::OK) {
     return result;
   }
-  finishTcPrep(packet.getFullPacketLen());
+  finishTcPrep(packet);
   return returnvalue::OK;
 }
 
@@ -1356,7 +1360,7 @@ ReturnValue_t PlocSupervisorHandler::prepareLatchupConfigCmd(const uint8_t* comm
       if (result != returnvalue::OK) {
         return result;
       }
-      finishTcPrep(packet.getFullPacketLen());
+      finishTcPrep(packet);
       break;
     }
     case (supv::DISABLE_LATCHUP_ALERT): {
@@ -1365,7 +1369,7 @@ ReturnValue_t PlocSupervisorHandler::prepareLatchupConfigCmd(const uint8_t* comm
       if (result != returnvalue::OK) {
         return result;
       }
-      finishTcPrep(packet.getFullPacketLen());
+      finishTcPrep(packet);
       break;
     }
     default: {
@@ -1392,7 +1396,7 @@ ReturnValue_t PlocSupervisorHandler::prepareSetAlertLimitCmd(const uint8_t* comm
   if (result != returnvalue::OK) {
     return result;
   }
-  finishTcPrep(packet.getFullPacketLen());
+  finishTcPrep(packet);
   return returnvalue::OK;
 }
 
@@ -1403,7 +1407,7 @@ ReturnValue_t PlocSupervisorHandler::prepareSetAdcEnabledChannelsCmd(const uint8
   if (result != returnvalue::OK) {
     return result;
   }
-  finishTcPrep(packet.getFullPacketLen());
+  finishTcPrep(packet);
   return returnvalue::OK;
 }
 
@@ -1417,7 +1421,7 @@ ReturnValue_t PlocSupervisorHandler::prepareSetAdcWindowAndStrideCmd(const uint8
   if (result != returnvalue::OK) {
     return result;
   }
-  finishTcPrep(packet.getFullPacketLen());
+  finishTcPrep(packet);
   return returnvalue::OK;
 }
 
@@ -1429,7 +1433,7 @@ ReturnValue_t PlocSupervisorHandler::prepareSetAdcThresholdCmd(const uint8_t* co
   if (result != returnvalue::OK) {
     return result;
   }
-  finishTcPrep(packet.getFullPacketLen());
+  finishTcPrep(packet);
   return returnvalue::OK;
 }
 
@@ -1443,11 +1447,15 @@ ReturnValue_t PlocSupervisorHandler::prepareRunAutoEmTest(const uint8_t* command
   if (result != returnvalue::OK) {
     return result;
   }
-  finishTcPrep(packet.getFullPacketLen());
+  finishTcPrep(packet);
   return returnvalue::OK;
 }
 
-ReturnValue_t PlocSupervisorHandler::prepareSetGpioCmd(const uint8_t* commandData) {
+ReturnValue_t PlocSupervisorHandler::prepareSetGpioCmd(const uint8_t* commandData,
+                                                       size_t commandDataLen) {
+  if (commandDataLen < 3) {
+    return HasActionsIF::INVALID_PARAMETERS;
+  }
   uint8_t port = *commandData;
   uint8_t pin = *(commandData + 1);
   uint8_t val = *(commandData + 2);
@@ -1456,11 +1464,15 @@ ReturnValue_t PlocSupervisorHandler::prepareSetGpioCmd(const uint8_t* commandDat
   if (result != returnvalue::OK) {
     return result;
   }
-  finishTcPrep(packet.getFullPacketLen());
+  finishTcPrep(packet);
   return returnvalue::OK;
 }
 
-ReturnValue_t PlocSupervisorHandler::prepareReadGpioCmd(const uint8_t* commandData) {
+ReturnValue_t PlocSupervisorHandler::prepareReadGpioCmd(const uint8_t* commandData,
+                                                        size_t commandDataLen) {
+  if (commandDataLen < 2) {
+    return HasActionsIF::INVALID_PARAMETERS;
+  }
   uint8_t port = *commandData;
   uint8_t pin = *(commandData + 1);
   supv::ReadGpio packet(spParams);
@@ -1468,7 +1480,7 @@ ReturnValue_t PlocSupervisorHandler::prepareReadGpioCmd(const uint8_t* commandDa
   if (result != returnvalue::OK) {
     return result;
   }
-  finishTcPrep(packet.getFullPacketLen());
+  finishTcPrep(packet);
   return returnvalue::OK;
 }
 
@@ -1482,14 +1494,18 @@ ReturnValue_t PlocSupervisorHandler::prepareFactoryResetCmd(const uint8_t* comma
   if (result != returnvalue::OK) {
     return result;
   }
-  finishTcPrep(resetCmd.getFullPacketLen());
+  finishTcPrep(resetCmd);
   return returnvalue::OK;
 }
 
-void PlocSupervisorHandler::finishTcPrep(size_t packetLen) {
+void PlocSupervisorHandler::finishTcPrep(TcBase& tc) {
   nextReplyId = supv::ACK_REPORT;
   rawPacket = commandBuffer;
-  rawPacketLen = packetLen;
+  rawPacketLen = tc.getFullPacketLen();
+  if (DEBUG_PLOC_SUPV) {
+    sif::debug << "PLOC SUPV: SEND PACKET Size " << tc.getFullPacketLen() << " Module APID "
+               << (int)tc.getModuleApid() << " Service ID " << (int)tc.getServiceId() << std::endl;
+  }
 }
 
 ReturnValue_t PlocSupervisorHandler::prepareSetShutdownTimeoutCmd(const uint8_t* commandData) {
@@ -1502,13 +1518,14 @@ ReturnValue_t PlocSupervisorHandler::prepareSetShutdownTimeoutCmd(const uint8_t*
     sif::warning
         << "PlocSupervisorHandler::prepareSetShutdownTimeoutCmd: Failed to deserialize timeout"
         << std::endl;
+    return result;
   }
   supv::SetShutdownTimeout packet(spParams);
   result = packet.buildPacket(timeout);
   if (result != returnvalue::OK) {
     return result;
   }
-  finishTcPrep(packet.getFullPacketLen());
+  finishTcPrep(packet);
   return returnvalue::OK;
 }
 
@@ -1518,7 +1535,13 @@ void PlocSupervisorHandler::disableAllReplies() {
 
   /* Disable ack reply */
   iter = deviceReplyMap.find(ACK_REPORT);
+  if (iter == deviceReplyMap.end()) {
+    return;
+  }
   DeviceReplyInfo* info = &(iter->second);
+  if (info == nullptr) {
+    return;
+  }
   info->delayCycles = 0;
   info->command = deviceCommandMap.end();
 
@@ -1547,8 +1570,8 @@ void PlocSupervisorHandler::disableAllReplies() {
       disableReply(LATCHUP_REPORT);
       break;
     }
-    case LOGGING_REQUEST_COUNTERS: {
-      disableReply(LOGGING_REPORT);
+    case REQUEST_LOGGING_COUNTERS: {
+      disableReply(COUNTERS_REPORT);
       break;
     }
     default: {
@@ -1562,6 +1585,9 @@ void PlocSupervisorHandler::disableAllReplies() {
 
 void PlocSupervisorHandler::disableReply(DeviceCommandId_t replyId) {
   DeviceReplyMap::iterator iter = deviceReplyMap.find(replyId);
+  if (iter == deviceReplyMap.end()) {
+    return;
+  }
   DeviceReplyInfo* info = &(iter->second);
   info->delayCycles = 0;
   info->active = false;
@@ -1592,6 +1618,9 @@ void PlocSupervisorHandler::sendFailureReport(DeviceCommandId_t replyId, ReturnV
 
 void PlocSupervisorHandler::disableExeReportReply() {
   DeviceReplyIter iter = deviceReplyMap.find(supv::EXE_REPORT);
+  if (iter == deviceReplyMap.end()) {
+    return;
+  }
   DeviceReplyInfo* info = &(iter->second);
   info->delayCycles = 0;
   info->command = deviceCommandMap.end();
@@ -1614,7 +1643,9 @@ ReturnValue_t PlocSupervisorHandler::handleMramDumpPacket(DeviceCommandId_t id)
     result = handleMramDumpFile(id);
     if (result != returnvalue::OK) {
       DeviceCommandMap::iterator iter = deviceCommandMap.find(id);
-      actionHelper.finish(false, iter->second.sendReplyTo, id, result);
+      if (iter != deviceCommandMap.end()) {
+        actionHelper.finish(false, iter->second.sendReplyTo, id, result);
+      }
       disableAllReplies();
       nextReplyId = supv::NONE;
       return result;
@@ -1719,7 +1750,7 @@ ReturnValue_t PlocSupervisorHandler::prepareWipeMramCmd(const uint8_t* commandDa
   if (result != returnvalue::OK) {
     return result;
   }
-  finishTcPrep(packet.getFullPacketLen());
+  finishTcPrep(packet);
   return returnvalue::OK;
 }
 
@@ -1881,7 +1912,12 @@ ReturnValue_t PlocSupervisorHandler::eventSubscription() {
 
 ReturnValue_t PlocSupervisorHandler::handleExecutionSuccessReport(ExecutionReport& report) {
   DeviceCommandId_t commandId = getPendingCommand();
-  ReturnValue_t result = OK;
+  DeviceCommandMap::iterator iter = deviceCommandMap.find(commandId);
+  if (iter != deviceCommandMap.end() and iter->second.sendReplyTo != NO_COMMANDER) {
+    actionHelper.finish(true, iter->second.sendReplyTo, iter->first, returnvalue::OK);
+    iter->second.isExecuting = false;
+  }
+  commandIsPending = false;
   switch (commandId) {
     case supv::READ_GPIO: {
       // TODO: Fix
@@ -1889,14 +1925,13 @@ ReturnValue_t PlocSupervisorHandler::handleExecutionSuccessReport(ExecutionRepor
 #if OBSW_DEBUG_PLOC_SUPERVISOR == 1
       sif::info << "PlocSupervisorHandler: Read GPIO TM, State: " << gpioState << std::endl;
 #endif /* OBSW_DEBUG_PLOC_SUPERVISOR == 1 */
-      DeviceCommandMap::iterator iter = deviceCommandMap.find(commandId);
-      if (iter->second.sendReplyTo == NO_COMMAND_ID) {
+      if (iter != deviceCommandMap.end() and iter->second.sendReplyTo == NO_COMMAND_ID) {
         return returnvalue::OK;
       }
       uint8_t data[sizeof(gpioState)];
       size_t size = 0;
-      result = SerializeAdapter::serialize(&gpioState, data, &size, sizeof(gpioState),
-                                           SerializeIF::Endianness::BIG);
+      ReturnValue_t result = SerializeAdapter::serialize(&gpioState, data, &size, sizeof(gpioState),
+                                                         SerializeIF::Endianness::BIG);
       if (result != returnvalue::OK) {
         sif::debug << "PlocSupervisorHandler: Failed to deserialize GPIO state" << std::endl;
       }
@@ -1972,133 +2007,21 @@ uint32_t PlocSupervisorHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t mod
   return 7000;
 }
 
-// ReturnValue_t PlocSupervisorHandler::checkMramPacketApid() {
-//   uint16_t apid = (spacePacketBuffer[0] << 8 | spacePacketBuffer[1]) & supv::APID_MASK;
-//  TODO: Fix
-//  if (apid != supv::APID_MRAM_DUMP_TM) {
-//    return result::NO_MRAM_PACKET;
-//  }
-// return APERIODIC_REPLY;
-//}
+void PlocSupervisorHandler::disableCommand(DeviceCommandId_t cmd) {
+  auto commandIter = deviceCommandMap.find(GET_HK_REPORT);
+  commandIter->second.isExecuting = false;
+}
 
-// ReturnValue_t PlocSupervisorHandler::parseMramPackets(const uint8_t* packet, size_t
-// remainingSize,
-//                                                       size_t* foundLen) {
-//   ReturnValue_t result = IGNORE_FULL_PACKET;
-//   uint16_t packetLen = 0;
-//   *foundLen = 0;
-//
-//   for (size_t idx = 0; idx < remainingSize; idx++) {
-//     std::memcpy(spacePacketBuffer + bufferTop, packet + idx, 1);
-//     bufferTop += 1;
-//     *foundLen += 1;
-//     if (bufferTop >= ccsds::HEADER_LEN) {
-//       packetLen = readSpacePacketLength(spacePacketBuffer);
-//     }
-//
-//     if (bufferTop == ccsds::HEADER_LEN + packetLen + 1) {
-//       packetInBuffer = true;
-//       bufferTop = 0;
-//       return checkMramPacketApid();
-//     }
-//
-//     if (bufferTop == supv::MAX_PACKET_SIZE) {
-//       *foundLen = remainingSize;
-//       disableAllReplies();
-//       bufferTop = 0;
-//       sif::info << "PlocSupervisorHandler::parseMramPackets: Can not find MRAM packet in space "
-//                    "packet buffer"
-//                 << std::endl;
-//       return result::MRAM_PACKET_PARSING_FAILURE;
-//     }
-//   }
-//
-//   return result;
-// }
-
-// ReturnValue_t PlocSupervisorHandler::prepareDumpMramCmd(const uint8_t* commandData) {
-//   uint32_t start = 0;
-//   uint32_t stop = 0;
-//   size_t size = sizeof(start) + sizeof(stop);
-//   SerializeAdapter::deSerialize(&start, &commandData, &size, SerializeIF::Endianness::BIG);
-//   SerializeAdapter::deSerialize(&stop, &commandData, &size, SerializeIF::Endianness::BIG);
-//   if ((stop - start) <= 0) {
-//     return SupvReturnValuesIF::INVALID_MRAM_ADDRESSES;
-//   }
-//   supv::MramCmd packet(spParams);
-//   ReturnValue_t result = packet.buildPacket(start, stop, supv::MramCmd::MramAction::DUMP);
-//   if (result != returnvalue::OK) {
-//     return result;
-//   }
-//   expectedMramDumpPackets = (stop - start) / supv::MAX_DATA_CAPACITY;
-//   if ((stop - start) % supv::MAX_DATA_CAPACITY) {
-//     expectedMramDumpPackets++;
-//   }
-//   receivedMramDumpPackets = 0;
-//
-//   finishTcPrep(packet.getFullPacketLen());
-//   return returnvalue::OK;
-// }
-
-// ReturnValue_t PlocSupervisorHandler::prepareLoggingRequest(const uint8_t* commandData,
-//                                                            size_t commandDataLen) {
-//   using namespace supv;
-//   RequestLoggingData::Sa sa = static_cast<RequestLoggingData::Sa>(*commandData);
-//   uint8_t tpc = *(commandData + 1);
-//   RequestLoggingData packet(spParams);
-//   ReturnValue_t result = packet.buildPacket(sa, tpc);
-//   if (result != returnvalue::OK) {
-//     return result;
-//   }
-//   finishTcPrep(packet.getFullPacketLen());
-//   return returnvalue::OK;
-// }
-
-// ReturnValue_t PlocSupervisorHandler::prepareEnableNvmsCommand(const uint8_t* commandData) {
-//   using namespace supv;
-//   uint8_t nvm01 = *(commandData);
-//   uint8_t nvm3 = *(commandData + 1);
-//   EnableNvms packet(spParams);
-//   ReturnValue_t result = packet.buildPacket(nvm01, nvm3);
-//   if (result != returnvalue::OK) {
-//     return result;
-//   }
-//   finishTcPrep(packet.getFullPacketLen());
-//   return returnvalue::OK;
-// }
-
-// ReturnValue_t PlocSupervisorHandler::handleLoggingReport(const uint8_t* data) {
-//   ReturnValue_t result = returnvalue::OK;
-//
-//   result = verifyPacket(data, supv::SIZE_LOGGING_REPORT);
-//
-//   if (result == SupvReturnValuesIF::CRC_FAILURE) {
-//     sif::warning << "PlocSupervisorHandler::handleLoggingReport: Logging report has "
-//                  << "invalid crc" << std::endl;
-//     return result;
-//   }
-//
-//   const uint8_t* dataField = data + supv::PAYLOAD_OFFSET + sizeof(supv::RequestLoggingData::Sa);
-//   result = loggingReport.read();
-//   if (result != returnvalue::OK) {
-//     return result;
-//   }
-//   loggingReport.setValidityBufferGeneration(false);
-//   size_t size = loggingReport.getSerializedSize();
-//   result = loggingReport.deSerialize(&dataField, &size, SerializeIF::Endianness::BIG);
-//   if (result != returnvalue::OK) {
-//     sif::warning << "PlocSupervisorHandler::handleLoggingReport: Deserialization failed"
-//                  << std::endl;
-//   }
-//   loggingReport.setValidityBufferGeneration(true);
-//   loggingReport.setValidity(true, true);
-//   result = loggingReport.commit();
-//   if (result != returnvalue::OK) {
-//     return result;
-//   }
-//#if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_PLOC_SUPERVISOR == 1
-//   loggingReport.printSet();
-//#endif
-//   nextReplyId = supv::EXE_REPORT;
-//   return result;
-// }
+ReturnValue_t PlocSupervisorHandler::checkModeCommand(Mode_t commandedMode,
+                                                      Submode_t commandedSubmode,
+                                                      uint32_t* msToReachTheMode) {
+  if (commandedMode != MODE_OFF) {
+    PoolReadGuard pg(&enablePl);
+    if (pg.getReadResult() == returnvalue::OK) {
+      if (enablePl.plUseAllowed.isValid() and not enablePl.plUseAllowed.value) {
+        return NON_OP_STATE_OF_CHARGE;
+      }
+    }
+  }
+  return DeviceHandlerBase::checkModeCommand(commandedMode, commandedSubmode, msToReachTheMode);
+}

archive/PlocSupervisorHandler.h

@@ -3,6 +3,7 @@
 
 #include <linux/payload/PlocSupvUartMan.h>
 #include <linux/payload/plocSupvDefs.h>
+#include <mission/controller/controllerdefinitions/PowerCtrlDefinitions.h>
 
 #include "OBSWConfig.h"
 #include "devices/powerSwitcherList.h"
@@ -17,6 +18,10 @@
 #endif
 
 using supv::ExecutionReport;
+using supv::TcBase;
+
+static constexpr bool DEBUG_PLOC_SUPV = true;
+static constexpr bool REDUCE_NORMAL_MODE_PRINTOUT = true;
 
 /**
  * @brief	This is the device handler for the supervisor of the PLOC which is programmed by
@@ -63,26 +68,6 @@ class PlocSupervisorHandler : public DeviceHandlerBase {
   void doOffActivity() override;
 
  private:
-  static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PLOC_SUPERVISOR_HANDLER;
-
-  //! [EXPORT] : [COMMENT] PLOC supervisor crc failure in telemetry packet
-  static const Event SUPV_MEMORY_READ_RPT_CRC_FAILURE = MAKE_EVENT(1, severity::LOW);
-  //! [EXPORT] : [COMMENT] Unhandled event. P1: APID, P2: Service ID
-  static constexpr Event SUPV_UNKNOWN_TM = MAKE_EVENT(2, severity::LOW);
-  static constexpr Event SUPV_UNINIMPLEMENTED_TM = MAKE_EVENT(3, severity::LOW);
-  //! [EXPORT] : [COMMENT] PLOC supervisor received acknowledgment failure report
-  static const Event SUPV_ACK_FAILURE = MAKE_EVENT(4, severity::LOW);
-  //! [EXPORT] : [COMMENT] PLOC received execution failure report
-  //! P1: ID of command for which the execution failed
-  //! P2: Status code sent by the supervisor handler
-  static const Event SUPV_EXE_FAILURE = MAKE_EVENT(5, severity::LOW);
-  //! [EXPORT] : [COMMENT] PLOC supervisor reply has invalid crc
-  static const Event SUPV_CRC_FAILURE_EVENT = MAKE_EVENT(6, severity::LOW);
-  //! [EXPORT] : [COMMENT] Supervisor helper currently executing a command
-  static const Event SUPV_HELPER_EXECUTING = MAKE_EVENT(7, severity::LOW);
-  //! [EXPORT] : [COMMENT] Failed to build the command to shutdown the MPSoC
-  static const Event SUPV_MPSOC_SHUTDOWN_BUILD_FAILED = MAKE_EVENT(8, severity::LOW);
-
   static const uint16_t APID_MASK = 0x7FF;
   static const uint16_t PACKET_SEQUENCE_COUNT_MASK = 0x3FFF;
   static const uint8_t EXE_STATUS_OFFSET = 10;
@@ -90,15 +75,14 @@ class PlocSupervisorHandler : public DeviceHandlerBase {
   // 5 s
   static const uint32_t EXECUTION_DEFAULT_TIMEOUT = 5000;
   // 70 S
-  static const uint32_t ACKNOWLEDGE_DEFAULT_TIMEOUT = 70000;
+  static const uint32_t ACKNOWLEDGE_DEFAULT_TIMEOUT = 5000;
   // 60 s
   static const uint32_t MRAM_DUMP_EXECUTION_TIMEOUT = 60000;
   // 70 s
   static const uint32_t COPY_ADC_TO_MRAM_TIMEOUT = 70000;
   // 60 s
   static const uint32_t MRAM_DUMP_TIMEOUT = 60000;
-  // 4 s
-  static const uint32_t BOOT_TIMEOUT = 4000;
+
   enum class StartupState : uint8_t {
     OFF,
     BOOTING,
@@ -127,11 +111,18 @@ class PlocSupervisorHandler : public DeviceHandlerBase {
   LinuxLibgpioIF* gpioComIF = nullptr;
   Gpio uartIsolatorSwitch;
   bool shutdownCmdSent = false;
+  // Yeah, I am using an extra variable because I once again don't know
+  // what the hell the base class is doing and I don't care anymore.
+  bool normalCommandIsPending = false;
+  // True men implement their reply timeout handling themselves!
+  Countdown normalCmdCd = Countdown(2000);
+  bool commandIsPending = false;
+  Countdown cmdCd = Countdown(2000);
 
   supv::HkSet hkset;
   supv::BootStatusReport bootStatusReport;
   supv::LatchupStatusReport latchupStatusReport;
-  supv::LoggingReport loggingReport;
+  supv::CountersReport countersReport;
   supv::AdcReport adcReport;
 
   const power::Switch_t powerSwitch = power::NO_SWITCH;
@@ -160,9 +151,12 @@ class PlocSupervisorHandler : public DeviceHandlerBase {
   Countdown executionReportTimeout = Countdown(EXECUTION_DEFAULT_TIMEOUT, false);
   Countdown acknowledgementReportTimeout = Countdown(ACKNOWLEDGE_DEFAULT_TIMEOUT, false);
   // Vorago nees some time to boot properly
-  Countdown bootTimeout = Countdown(BOOT_TIMEOUT);
+  Countdown bootTimeout = Countdown(supv::BOOT_TIMEOUT_MS);
   Countdown mramDumpTimeout = Countdown(MRAM_DUMP_TIMEOUT);
 
+  PoolEntry<uint16_t> adcRawEntry = PoolEntry<uint16_t>(16);
+  PoolEntry<uint16_t> adcEngEntry = PoolEntry<uint16_t>(16);
+  PoolEntry<uint32_t> latchupCounters = PoolEntry<uint32_t>(7);
   PoolEntry<uint8_t> fmcStateEntry = PoolEntry<uint8_t>(1);
   PoolEntry<uint8_t> bootStateEntry = PoolEntry<uint8_t>(1);
   PoolEntry<uint8_t> bootCyclesEntry = PoolEntry<uint8_t>(1);
@@ -173,6 +167,8 @@ class PlocSupervisorHandler : public DeviceHandlerBase {
    */
   void setExecutionTimeout(DeviceCommandId_t command);
 
+  void handlePacketPrint();
+
   /**
    * @brief   Handles event messages received from the supervisor helper
    */
@@ -225,9 +221,13 @@ class PlocSupervisorHandler : public DeviceHandlerBase {
   ReturnValue_t handleBootStatusReport(const uint8_t* data);
 
   ReturnValue_t handleLatchupStatusReport(const uint8_t* data);
+  ReturnValue_t handleCounterReport(const uint8_t* data);
   void handleBadApidServiceCombination(Event result, unsigned int apid, unsigned int serviceId);
-  // ReturnValue_t handleLoggingReport(const uint8_t* data);
   ReturnValue_t handleAdcReport(const uint8_t* data);
+  ReturnValue_t genericHandleTm(const char* contextString, const uint8_t* data,
+                                LocalPoolDataSetBase& set);
+
+  void disableCommand(DeviceCommandId_t cmd);
 
   /**
    * @brief   Depending on the current active command, this function sets the reply id of the
@@ -296,16 +296,13 @@ class PlocSupervisorHandler : public DeviceHandlerBase {
   ReturnValue_t prepareSetAdcThresholdCmd(const uint8_t* commandData);
   ReturnValue_t prepareRunAutoEmTest(const uint8_t* commandData);
   ReturnValue_t prepareWipeMramCmd(const uint8_t* commandData);
-  // ReturnValue_t prepareDumpMramCmd(const uint8_t* commandData);
-  ReturnValue_t prepareSetGpioCmd(const uint8_t* commandData);
-  ReturnValue_t prepareReadGpioCmd(const uint8_t* commandData);
-  // ReturnValue_t prepareLoggingRequest(const uint8_t* commandData, size_t commandDataLen);
-  //  ReturnValue_t prepareEnableNvmsCommand(const uint8_t* commandData);
+  ReturnValue_t prepareSetGpioCmd(const uint8_t* commandData, size_t commandDataLen);
+  ReturnValue_t prepareReadGpioCmd(const uint8_t* commandData, size_t commandDataLen);
 
   /**
    * @brief   Copies the content of a space packet to the command buffer.
    */
-  void finishTcPrep(size_t packetLen);
+  void finishTcPrep(TcBase& tc);
 
   /**
    * @brief   In case an acknowledgment failure reply has been received this function disables
@@ -331,12 +328,6 @@ class PlocSupervisorHandler : public DeviceHandlerBase {
    */
   void disableExeReportReply();
 
-  /**
-   * @brief   Function is called in scanForReply and fills the spacePacketBuffer with the read
-   *          data until a full packet has been received.
-   */
-  // ReturnValue_t parseMramPackets(const uint8_t* packet, size_t remainingSize, size_t* foundlen);
-
   /**
    * @brief   This function generates the Service 8 packets for the MRAM dump data.
    */
@@ -349,12 +340,6 @@ class PlocSupervisorHandler : public DeviceHandlerBase {
    */
   void increaseExpectedMramReplies(DeviceCommandId_t id);
 
-  /**
-   * @brief   Function checks if the packet written to the space packet buffer is really a
-   *          MRAM dump packet.
-   */
-  // ReturnValue_t checkMramPacketApid();
-
   /**
    * @brief   Writes the data of the MRAM dump to a file. The file will be created when receiving
    *          the first packet.
@@ -395,6 +380,10 @@ class PlocSupervisorHandler : public DeviceHandlerBase {
   void handleExecutionFailureReport(ExecutionReport& report);
 
   void printAckFailureInfo(uint16_t statusCode, DeviceCommandId_t commandId);
+
+  pwrctrl::EnablePl enablePl = pwrctrl::EnablePl(objects::POWER_CONTROLLER);
+  ReturnValue_t checkModeCommand(Mode_t commandedMode, Submode_t commandedSubmode,
+                                 uint32_t* msToReachTheMode) override;
 };
 
 #endif /* MISSION_DEVICES_PLOCSUPERVISORHANDLER_H_ */

bsp_hosted/CMakeLists.txt

@@ -1,4 +1,4 @@
-target_sources(${OBSW_NAME} PUBLIC scheduling.cpp main.cpp ObjectFactory.cpp)
+target_sources(${OBSW_NAME} PUBLIC scheduling.cpp main.cpp objectFactory.cpp)
 
 add_subdirectory(fsfwconfig)
 add_subdirectory(boardconfig)

bsp_hosted/OBSWConfig.h.in

@@ -48,6 +48,7 @@
 #define OBSW_SWITCH_TO_NORMAL_MODE_AFTER_STARTUP    1
 #define OBSW_PRINT_MISSED_DEADLINES                 1
 
+#define OBSW_MPSOC_JTAG_BOOT                        0
 #define OBSW_SYRLINKS_SIMULATED                     1
 #define OBSW_ADD_TEST_CODE                          0
 #define OBSW_ADD_TEST_TASK                          0
@@ -101,7 +102,7 @@
 /** CMake Defines                                                  */
 /*******************************************************************/
 
-#define OBSW_ADD_TMTC_UDP_SERVER            1
+#define OBSW_ADD_TMTC_UDP_SERVER            0
 #define OBSW_ADD_TMTC_TCP_SERVER            1
 
 #cmakedefine EIVE_BUILD_GPSD_GPS_HANDLER

bsp_hosted/fsfwconfig/events/translateEvents.cpp

@@ -1,7 +1,7 @@
 /**
- * @brief    Auto-generated event translation file. Contains 296 translations.
+ * @brief    Auto-generated event translation file. Contains 324 translations.
  * @details
- * Generated on: 2023-06-21 19:01:02
+ * Generated on: 2024-04-10 11:49:35
  */
 #include "translateEvents.h"
 
@@ -82,8 +82,11 @@ const char *BIT_LOCK_STRING = "BIT_LOCK";
 const char *BIT_LOCK_LOST_STRING = "BIT_LOCK_LOST";
 const char *FRAME_PROCESSING_FAILED_STRING = "FRAME_PROCESSING_FAILED";
 const char *CLOCK_SET_STRING = "CLOCK_SET";
-const char *CLOCK_DUMP_STRING = "CLOCK_DUMP";
+const char *CLOCK_DUMP_LEGACY_STRING = "CLOCK_DUMP_LEGACY";
 const char *CLOCK_SET_FAILURE_STRING = "CLOCK_SET_FAILURE";
+const char *CLOCK_DUMP_STRING = "CLOCK_DUMP";
+const char *CLOCK_DUMP_BEFORE_SETTING_TIME_STRING = "CLOCK_DUMP_BEFORE_SETTING_TIME";
+const char *CLOCK_DUMP_AFTER_SETTING_TIME_STRING = "CLOCK_DUMP_AFTER_SETTING_TIME";
 const char *TC_DELETION_FAILED_STRING = "TC_DELETION_FAILED";
 const char *TEST_STRING = "TEST";
 const char *CHANGE_OF_SETUP_PARAMETER_STRING = "CHANGE_OF_SETUP_PARAMETER";
@@ -92,18 +95,28 @@ const char *MSG_QUEUE_ERROR_STRING = "MSG_QUEUE_ERROR";
 const char *SERIALIZATION_ERROR_STRING = "SERIALIZATION_ERROR";
 const char *FILESTORE_ERROR_STRING = "FILESTORE_ERROR";
 const char *FILENAME_TOO_LARGE_ERROR_STRING = "FILENAME_TOO_LARGE_ERROR";
+const char *HANDLING_CFDP_REQUEST_FAILED_STRING = "HANDLING_CFDP_REQUEST_FAILED";
 const char *SAFE_RATE_VIOLATION_STRING = "SAFE_RATE_VIOLATION";
-const char *SAFE_RATE_RECOVERY_STRING = "SAFE_RATE_RECOVERY";
+const char *RATE_RECOVERY_STRING = "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 *PTG_CTRL_NO_ATTITUDE_INFORMATION_STRING = "PTG_CTRL_NO_ATTITUDE_INFORMATION";
 const char *SAFE_MODE_CONTROLLER_FAILURE_STRING = "SAFE_MODE_CONTROLLER_FAILURE";
+const char *TLE_TOO_OLD_STRING = "TLE_TOO_OLD";
+const char *TLE_FILE_READ_FAILED_STRING = "TLE_FILE_READ_FAILED";
+const char *PTG_RATE_VIOLATION_STRING = "PTG_RATE_VIOLATION";
+const char *DETUMBLE_TRANSITION_FAILED_STRING = "DETUMBLE_TRANSITION_FAILED";
 const char *SWITCH_CMD_SENT_STRING = "SWITCH_CMD_SENT";
 const char *SWITCH_HAS_CHANGED_STRING = "SWITCH_HAS_CHANGED";
 const char *SWITCHING_Q7S_DENIED_STRING = "SWITCHING_Q7S_DENIED";
 const char *FDIR_REACTION_IGNORED_STRING = "FDIR_REACTION_IGNORED";
+const char *DATASET_READ_FAILED_STRING = "DATASET_READ_FAILED";
+const char *VOLTAGE_OUT_OF_BOUNDS_STRING = "VOLTAGE_OUT_OF_BOUNDS";
+const char *TIMEDELTA_OUT_OF_BOUNDS_STRING = "TIMEDELTA_OUT_OF_BOUNDS";
+const char *POWER_LEVEL_LOW_STRING = "POWER_LEVEL_LOW";
+const char *POWER_LEVEL_CRITICAL_STRING = "POWER_LEVEL_CRITICAL";
 const char *GPIO_PULL_HIGH_FAILED_STRING = "GPIO_PULL_HIGH_FAILED";
 const char *GPIO_PULL_LOW_FAILED_STRING = "GPIO_PULL_LOW_FAILED";
 const char *HEATER_WENT_ON_STRING = "HEATER_WENT_ON";
@@ -127,6 +140,8 @@ const char *EXE_FAILURE_STRING = "EXE_FAILURE";
 const char *MPSOC_HANDLER_CRC_FAILURE_STRING = "MPSOC_HANDLER_CRC_FAILURE";
 const char *MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH_STRING = "MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH";
 const char *MPSOC_SHUTDOWN_FAILED_STRING = "MPSOC_SHUTDOWN_FAILED";
+const char *SUPV_NOT_ON_STRING = "SUPV_NOT_ON";
+const char *SUPV_REPLY_TIMEOUT_STRING = "SUPV_REPLY_TIMEOUT";
 const char *SELF_TEST_I2C_FAILURE_STRING = "SELF_TEST_I2C_FAILURE";
 const char *SELF_TEST_SPI_FAILURE_STRING = "SELF_TEST_SPI_FAILURE";
 const char *SELF_TEST_ADC_FAILURE_STRING = "SELF_TEST_ADC_FAILURE";
@@ -139,6 +154,7 @@ const char *ERROR_STATE_STRING = "ERROR_STATE";
 const char *RESET_OCCURED_STRING = "RESET_OCCURED";
 const char *BOOTING_FIRMWARE_FAILED_EVENT_STRING = "BOOTING_FIRMWARE_FAILED_EVENT";
 const char *BOOTING_BOOTLOADER_FAILED_EVENT_STRING = "BOOTING_BOOTLOADER_FAILED_EVENT";
+const char *COM_ERROR_REPLY_RECEIVED_STRING = "COM_ERROR_REPLY_RECEIVED";
 const char *SUPV_MEMORY_READ_RPT_CRC_FAILURE_STRING = "SUPV_MEMORY_READ_RPT_CRC_FAILURE";
 const char *SUPV_UNKNOWN_TM_STRING = "SUPV_UNKNOWN_TM";
 const char *SUPV_UNINIMPLEMENTED_TM_STRING = "SUPV_UNINIMPLEMENTED_TM";
@@ -147,6 +163,8 @@ const char *SUPV_EXE_FAILURE_STRING = "SUPV_EXE_FAILURE";
 const char *SUPV_CRC_FAILURE_EVENT_STRING = "SUPV_CRC_FAILURE_EVENT";
 const char *SUPV_HELPER_EXECUTING_STRING = "SUPV_HELPER_EXECUTING";
 const char *SUPV_MPSOC_SHUTDOWN_BUILD_FAILED_STRING = "SUPV_MPSOC_SHUTDOWN_BUILD_FAILED";
+const char *SUPV_ACK_UNKNOWN_COMMAND_STRING = "SUPV_ACK_UNKNOWN_COMMAND";
+const char *SUPV_EXE_ACK_UNKNOWN_COMMAND_STRING = "SUPV_EXE_ACK_UNKNOWN_COMMAND";
 const char *SANITIZATION_FAILED_STRING = "SANITIZATION_FAILED";
 const char *MOUNTED_SD_CARD_STRING = "MOUNTED_SD_CARD";
 const char *SEND_MRAM_DUMP_FAILED_STRING = "SEND_MRAM_DUMP_FAILED";
@@ -166,6 +184,7 @@ const char *PDEC_TRYING_RESET_NO_INIT_STRING = "PDEC_TRYING_RESET_NO_INIT";
 const char *PDEC_RESET_FAILED_STRING = "PDEC_RESET_FAILED";
 const char *OPEN_IRQ_FILE_FAILED_STRING = "OPEN_IRQ_FILE_FAILED";
 const char *PDEC_INIT_FAILED_STRING = "PDEC_INIT_FAILED";
+const char *PDEC_CONFIG_CORRUPTED_STRING = "PDEC_CONFIG_CORRUPTED";
 const char *IMAGE_UPLOAD_FAILED_STRING = "IMAGE_UPLOAD_FAILED";
 const char *IMAGE_DOWNLOAD_FAILED_STRING = "IMAGE_DOWNLOAD_FAILED";
 const char *IMAGE_UPLOAD_SUCCESSFUL_STRING = "IMAGE_UPLOAD_SUCCESSFUL";
@@ -225,6 +244,7 @@ const char *SIDE_SWITCH_TRANSITION_NOT_ALLOWED_12903_STRING = "SIDE_SWITCH_TRANS
 const char *CHILDREN_LOST_MODE_STRING = "CHILDREN_LOST_MODE";
 const char *GPS_FIX_CHANGE_STRING = "GPS_FIX_CHANGE";
 const char *CANT_GET_FIX_STRING = "CANT_GET_FIX";
+const char *RESET_FAIL_STRING = "RESET_FAIL";
 const char *P60_BOOT_COUNT_STRING = "P60_BOOT_COUNT";
 const char *BATT_MODE_STRING = "BATT_MODE";
 const char *BATT_MODE_CHANGED_STRING = "BATT_MODE_CHANGED";
@@ -260,6 +280,7 @@ const char *TX_OFF_STRING = "TX_OFF";
 const char *MISSING_PACKET_STRING = "MISSING_PACKET";
 const char *EXPERIMENT_TIMEDOUT_STRING = "EXPERIMENT_TIMEDOUT";
 const char *MULTI_PACKET_COMMAND_DONE_STRING = "MULTI_PACKET_COMMAND_DONE";
+const char *FS_UNUSABLE_STRING = "FS_UNUSABLE";
 const char *SET_CONFIGFILEVALUE_FAILED_STRING = "SET_CONFIGFILEVALUE_FAILED";
 const char *GET_CONFIGFILEVALUE_FAILED_STRING = "GET_CONFIGFILEVALUE_FAILED";
 const char *INSERT_CONFIGFILEVALUE_FAILED_STRING = "INSERT_CONFIGFILEVALUE_FAILED";
@@ -278,6 +299,7 @@ const char *TRYING_I2C_RECOVERY_STRING = "TRYING_I2C_RECOVERY";
 const char *I2C_REBOOT_STRING = "I2C_REBOOT";
 const char *PDEC_REBOOT_STRING = "PDEC_REBOOT";
 const char *FIRMWARE_INFO_STRING = "FIRMWARE_INFO";
+const char *ACTIVE_SD_INFO_STRING = "ACTIVE_SD_INFO";
 const char *NO_VALID_SENSOR_TEMPERATURE_STRING = "NO_VALID_SENSOR_TEMPERATURE";
 const char *NO_HEALTHY_HEATER_AVAILABLE_STRING = "NO_HEALTHY_HEATER_AVAILABLE";
 const char *SYRLINKS_OVERHEATING_STRING = "SYRLINKS_OVERHEATING";
@@ -286,6 +308,9 @@ const char *CAMERA_OVERHEATING_STRING = "CAMERA_OVERHEATING";
 const char *PCDU_SYSTEM_OVERHEATING_STRING = "PCDU_SYSTEM_OVERHEATING";
 const char *HEATER_NOT_OFF_FOR_OFF_MODE_STRING = "HEATER_NOT_OFF_FOR_OFF_MODE";
 const char *MGT_OVERHEATING_STRING = "MGT_OVERHEATING";
+const char *TCS_SWITCHING_HEATER_ON_STRING = "TCS_SWITCHING_HEATER_ON";
+const char *TCS_SWITCHING_HEATER_OFF_STRING = "TCS_SWITCHING_HEATER_OFF";
+const char *TCS_HEATER_MAX_BURN_TIME_REACHED_STRING = "TCS_HEATER_MAX_BURN_TIME_REACHED";
 const char *TX_TIMER_EXPIRED_STRING = "TX_TIMER_EXPIRED";
 const char *BIT_LOCK_TX_ON_STRING = "BIT_LOCK_TX_ON";
 const char *POSSIBLE_FILE_CORRUPTION_STRING = "POSSIBLE_FILE_CORRUPTION";
@@ -301,6 +326,9 @@ const char *DUMP_NOK_CANCELLED_STRING = "DUMP_NOK_CANCELLED";
 const char *DUMP_MISC_CANCELLED_STRING = "DUMP_MISC_CANCELLED";
 const char *DUMP_HK_CANCELLED_STRING = "DUMP_HK_CANCELLED";
 const char *DUMP_CFDP_CANCELLED_STRING = "DUMP_CFDP_CANCELLED";
+const char *TEMPERATURE_ALL_ONES_START_STRING = "TEMPERATURE_ALL_ONES_START";
+const char *TEMPERATURE_ALL_ONES_RECOVERY_STRING = "TEMPERATURE_ALL_ONES_RECOVERY";
+const char *FAULT_HANDLER_TRIGGERED_STRING = "FAULT_HANDLER_TRIGGERED";
 
 const char *translateEvents(Event event) {
   switch ((event & 0xFFFF)) {
@@ -459,9 +487,15 @@ const char *translateEvents(Event event) {
     case (8900):
       return CLOCK_SET_STRING;
     case (8901):
-      return CLOCK_DUMP_STRING;
+      return CLOCK_DUMP_LEGACY_STRING;
     case (8902):
       return CLOCK_SET_FAILURE_STRING;
+    case (8903):
+      return CLOCK_DUMP_STRING;
+    case (8904):
+      return CLOCK_DUMP_BEFORE_SETTING_TIME_STRING;
+    case (8905):
+      return CLOCK_DUMP_AFTER_SETTING_TIME_STRING;
     case (9100):
       return TC_DELETION_FAILED_STRING;
     case (9700):
@@ -478,10 +512,12 @@ const char *translateEvents(Event event) {
       return FILESTORE_ERROR_STRING;
     case (10804):
       return FILENAME_TOO_LARGE_ERROR_STRING;
+    case (10805):
+      return HANDLING_CFDP_REQUEST_FAILED_STRING;
     case (11200):
       return SAFE_RATE_VIOLATION_STRING;
     case (11201):
-      return SAFE_RATE_RECOVERY_STRING;
+      return RATE_RECOVERY_STRING;
     case (11202):
       return MULTIPLE_RW_INVALID_STRING;
     case (11203):
@@ -491,9 +527,17 @@ const char *translateEvents(Event event) {
     case (11205):
       return MEKF_AUTOMATIC_RESET_STRING;
     case (11206):
-      return MEKF_INVALID_MODE_VIOLATION_STRING;
+      return PTG_CTRL_NO_ATTITUDE_INFORMATION_STRING;
     case (11207):
       return SAFE_MODE_CONTROLLER_FAILURE_STRING;
+    case (11208):
+      return TLE_TOO_OLD_STRING;
+    case (11209):
+      return TLE_FILE_READ_FAILED_STRING;
+    case (11210):
+      return PTG_RATE_VIOLATION_STRING;
+    case (11211):
+      return DETUMBLE_TRANSITION_FAILED_STRING;
     case (11300):
       return SWITCH_CMD_SENT_STRING;
     case (11301):
@@ -502,6 +546,16 @@ const char *translateEvents(Event event) {
       return SWITCHING_Q7S_DENIED_STRING;
     case (11303):
       return FDIR_REACTION_IGNORED_STRING;
+    case (11304):
+      return DATASET_READ_FAILED_STRING;
+    case (11305):
+      return VOLTAGE_OUT_OF_BOUNDS_STRING;
+    case (11306):
+      return TIMEDELTA_OUT_OF_BOUNDS_STRING;
+    case (11307):
+      return POWER_LEVEL_LOW_STRING;
+    case (11308):
+      return POWER_LEVEL_CRITICAL_STRING;
     case (11400):
       return GPIO_PULL_HIGH_FAILED_STRING;
     case (11401):
@@ -548,6 +602,10 @@ const char *translateEvents(Event event) {
       return MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH_STRING;
     case (11606):
       return MPSOC_SHUTDOWN_FAILED_STRING;
+    case (11607):
+      return SUPV_NOT_ON_STRING;
+    case (11608):
+      return SUPV_REPLY_TIMEOUT_STRING;
     case (11701):
       return SELF_TEST_I2C_FAILURE_STRING;
     case (11702):
@@ -572,6 +630,8 @@ const char *translateEvents(Event event) {
       return BOOTING_FIRMWARE_FAILED_EVENT_STRING;
     case (11902):
       return BOOTING_BOOTLOADER_FAILED_EVENT_STRING;
+    case (11903):
+      return COM_ERROR_REPLY_RECEIVED_STRING;
     case (12001):
       return SUPV_MEMORY_READ_RPT_CRC_FAILURE_STRING;
     case (12002):
@@ -588,6 +648,10 @@ const char *translateEvents(Event event) {
       return SUPV_HELPER_EXECUTING_STRING;
     case (12008):
       return SUPV_MPSOC_SHUTDOWN_BUILD_FAILED_STRING;
+    case (12009):
+      return SUPV_ACK_UNKNOWN_COMMAND_STRING;
+    case (12010):
+      return SUPV_EXE_ACK_UNKNOWN_COMMAND_STRING;
     case (12100):
       return SANITIZATION_FAILED_STRING;
     case (12101):
@@ -626,6 +690,8 @@ const char *translateEvents(Event event) {
       return OPEN_IRQ_FILE_FAILED_STRING;
     case (12414):
       return PDEC_INIT_FAILED_STRING;
+    case (12415):
+      return PDEC_CONFIG_CORRUPTED_STRING;
     case (12500):
       return IMAGE_UPLOAD_FAILED_STRING;
     case (12501):
@@ -744,6 +810,8 @@ const char *translateEvents(Event event) {
       return GPS_FIX_CHANGE_STRING;
     case (13101):
       return CANT_GET_FIX_STRING;
+    case (13102):
+      return RESET_FAIL_STRING;
     case (13200):
       return P60_BOOT_COUNT_STRING;
     case (13201):
@@ -814,6 +882,8 @@ const char *translateEvents(Event event) {
       return EXPERIMENT_TIMEDOUT_STRING;
     case (13802):
       return MULTI_PACKET_COMMAND_DONE_STRING;
+    case (13803):
+      return FS_UNUSABLE_STRING;
     case (13901):
       return SET_CONFIGFILEVALUE_FAILED_STRING;
     case (13902):
@@ -850,6 +920,8 @@ const char *translateEvents(Event event) {
       return PDEC_REBOOT_STRING;
     case (14013):
       return FIRMWARE_INFO_STRING;
+    case (14014):
+      return ACTIVE_SD_INFO_STRING;
     case (14100):
       return NO_VALID_SENSOR_TEMPERATURE_STRING;
     case (14101):
@@ -866,6 +938,12 @@ const char *translateEvents(Event event) {
       return HEATER_NOT_OFF_FOR_OFF_MODE_STRING;
     case (14108):
       return MGT_OVERHEATING_STRING;
+    case (14109):
+      return TCS_SWITCHING_HEATER_ON_STRING;
+    case (14110):
+      return TCS_SWITCHING_HEATER_OFF_STRING;
+    case (14111):
+      return TCS_HEATER_MAX_BURN_TIME_REACHED_STRING;
     case (14201):
       return TX_TIMER_EXPIRED_STRING;
     case (14202):
@@ -896,6 +974,12 @@ const char *translateEvents(Event event) {
       return DUMP_HK_CANCELLED_STRING;
     case (14314):
       return DUMP_CFDP_CANCELLED_STRING;
+    case (14500):
+      return TEMPERATURE_ALL_ONES_START_STRING;
+    case (14501):
+      return TEMPERATURE_ALL_ONES_RECOVERY_STRING;
+    case (14600):
+      return FAULT_HANDLER_TRIGGERED_STRING;
     default:
       return "UNKNOWN_EVENT";
   }

bsp_hosted/fsfwconfig/objects/translateObjects.cpp

@@ -1,15 +1,17 @@
 /**
  * @brief  Auto-generated object translation file.
  * @details
- * Contains 171 translations.
- * Generated on: 2023-06-21 19:01:02
+ * Contains 175 translations.
+ * Generated on: 2024-04-10 11:49:35
  */
 #include "translateObjects.h"
 
 const char *TEST_TASK_STRING = "TEST_TASK";
 const char *ACS_CONTROLLER_STRING = "ACS_CONTROLLER";
 const char *CORE_CONTROLLER_STRING = "CORE_CONTROLLER";
+const char *POWER_CONTROLLER_STRING = "POWER_CONTROLLER";
 const char *GLOBAL_JSON_CFG_STRING = "GLOBAL_JSON_CFG";
+const char *XIPHOS_WDT_STRING = "XIPHOS_WDT";
 const char *THERMAL_CONTROLLER_STRING = "THERMAL_CONTROLLER";
 const char *DUMMY_HANDLER_STRING = "DUMMY_HANDLER";
 const char *MGM_0_LIS3_HANDLER_STRING = "MGM_0_LIS3_HANDLER";
@@ -159,11 +161,13 @@ const char *PUS_TM_FUNNEL_STRING = "PUS_TM_FUNNEL";
 const char *CFDP_TM_FUNNEL_STRING = "CFDP_TM_FUNNEL";
 const char *CFDP_HANDLER_STRING = "CFDP_HANDLER";
 const char *CFDP_DISTRIBUTOR_STRING = "CFDP_DISTRIBUTOR";
+const char *CFDP_FAULT_HANDLER_STRING = "CFDP_FAULT_HANDLER";
 const char *EIVE_SYSTEM_STRING = "EIVE_SYSTEM";
 const char *ACS_SUBSYSTEM_STRING = "ACS_SUBSYSTEM";
 const char *PL_SUBSYSTEM_STRING = "PL_SUBSYSTEM";
 const char *TCS_SUBSYSTEM_STRING = "TCS_SUBSYSTEM";
 const char *COM_SUBSYSTEM_STRING = "COM_SUBSYSTEM";
+const char *EPS_SUBSYSTEM_STRING = "EPS_SUBSYSTEM";
 const char *MISC_TM_STORE_STRING = "MISC_TM_STORE";
 const char *OK_TM_STORE_STRING = "OK_TM_STORE";
 const char *NOT_OK_TM_STORE_STRING = "NOT_OK_TM_STORE";
@@ -186,8 +190,12 @@ const char *translateObject(object_id_t object) {
       return ACS_CONTROLLER_STRING;
     case 0x43000003:
       return CORE_CONTROLLER_STRING;
+    case 0x43000004:
+      return POWER_CONTROLLER_STRING;
     case 0x43000006:
       return GLOBAL_JSON_CFG_STRING;
+    case 0x43000007:
+      return XIPHOS_WDT_STRING;
     case 0x43400001:
       return THERMAL_CONTROLLER_STRING;
     case 0x44000001:
@@ -486,6 +494,8 @@ const char *translateObject(object_id_t object) {
       return CFDP_HANDLER_STRING;
     case 0x73000206:
       return CFDP_DISTRIBUTOR_STRING;
+    case 0x73000207:
+      return CFDP_FAULT_HANDLER_STRING;
     case 0x73010000:
       return EIVE_SYSTEM_STRING;
     case 0x73010001:
@@ -496,6 +506,8 @@ const char *translateObject(object_id_t object) {
       return TCS_SUBSYSTEM_STRING;
     case 0x73010004:
       return COM_SUBSYSTEM_STRING;
+    case 0x73010005:
+      return EPS_SUBSYSTEM_STRING;
     case 0x73020001:
       return MISC_TM_STORE_STRING;
     case 0x73020002:

bsp_hosted/objectFactory.cpp

@@ -1,4 +1,4 @@
-#include "ObjectFactory.h"
+#include "objectFactory.h"
 
 #include <fsfw/power/DummyPowerSwitcher.h>
 #include <fsfw/tmtcservices/CommandingServiceBase.h>
@@ -38,9 +38,9 @@
 
 #include "devices/gpioIds.h"
 #include "fsfw_hal/linux/gpio/Gpio.h"
+#include "linux/payload/FreshSupvHandler.h"
 #include "linux/payload/PlocMpsocHandler.h"
 #include "linux/payload/PlocMpsocSpecialComHelper.h"
-#include "linux/payload/PlocSupervisorHandler.h"
 #include "linux/payload/PlocSupvUartMan.h"
 #include "test/gpio/DummyGpioIF.h"
 #endif
@@ -61,14 +61,14 @@ void ObjectFactory::produce(void* args) {
   CfdpTmFunnel* cfdpFunnel;
   StorageManagerIF* tmStore;
   StorageManagerIF* ipcStore;
-  PersistentTmStores persistentStores;
+  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, 120);
+                                       &tmStore, persistentStores, 120, enableHkSets, false);
 
   new TmFunnelHandler(objects::LIVE_TM_TASK, *pusFunnel, *cfdpFunnel);
   auto* dummyGpioIF = new DummyGpioIF();
@@ -97,14 +97,17 @@ void ObjectFactory::produce(void* args) {
       new SerialCookie(objects::PLOC_SUPERVISOR_HANDLER, plocSupvString, uart::PLOC_SUPV_BAUD,
                        supv::MAX_PACKET_SIZE * 20, UartModes::NON_CANONICAL);
   supervisorCookie->setNoFixedSizeReply();
-  auto supvHelper = new PlocSupvUartManager(objects::PLOC_SUPERVISOR_HELPER);
-  new PlocSupervisorHandler(objects::PLOC_SUPERVISOR_HANDLER, supervisorCookie,
-                            Gpio(gpioIds::ENABLE_SUPV_UART, dummyGpioIF), pcdu::PDU1_CH6_PLOC_12V,
-                            *supvHelper);
+  new PlocSupvUartManager(objects::PLOC_SUPERVISOR_HELPER);
+  DhbConfig dhbConf(objects::PLOC_SUPERVISOR_HANDLER);
+  auto* supvHandler =
+      new FreshSupvHandler(dhbConf, supervisorCookie, Gpio(gpioIds::ENABLE_SUPV_UART, dummyGpioIF),
+                           dummySwitcher, power::PDU1_CH6_PLOC_12V);
 #endif /* OBSW_ADD_PLOC_SUPERVISOR == 1 */
 #endif
 
   dummy::DummyCfg cfg;
+  cfg.addPlPcduDummy = true;
+  cfg.addCamSwitcherDummy = true;
   dummy::createDummies(cfg, *dummySwitcher, dummyGpioIF, enableHkSets);
 
   HeaterHandler* heaterHandler = nullptr;
@@ -113,7 +116,7 @@ void ObjectFactory::produce(void* args) {
   if (heaterHandler == nullptr) {
     sif::error << "HeaterHandler could not be created" << std::endl;
   } else {
-    ObjectFactory::createThermalController(*heaterHandler);
+    ObjectFactory::createThermalController(*heaterHandler, true);
   }
   new TestTask(objects::TEST_TASK);
 }

bsp_hosted/scheduling.cpp

@@ -13,8 +13,8 @@
 #include <iostream>
 
 #include "OBSWConfig.h"
-#include "ObjectFactory.h"
 #include "mission/scheduling.h"
+#include "objectFactory.h"
 #include "scheduling.h"
 
 #ifdef LINUX
@@ -69,21 +69,25 @@ void scheduling::initTasks() {
   if (result != returnvalue::OK) {
     sif::error << "Adding CFDP distributor failed" << std::endl;
   }
+#if OBSW_ADD_TMTC_UDP_SERVER == 1
   result = tmtcDistributor->addComponent(objects::UDP_TMTC_SERVER);
   if (result != returnvalue::OK) {
     sif::error << "adding UDP server failed" << std::endl;
   }
+#endif
   result = tmtcDistributor->addComponent(objects::TCP_TMTC_SERVER);
   if (result != returnvalue::OK) {
     sif::error << "adding TCP server failed" << std::endl;
   }
 
+#if OBSW_ADD_TMTC_UDP_SERVER == 1
   PeriodicTaskIF* udpPollingTask = factory->createPeriodicTask(
       "UDP_POLLING", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
   result = udpPollingTask->addComponent(objects::UDP_TMTC_POLLING_TASK);
   if (result != returnvalue::OK) {
     sif::error << "Add component UDP Polling failed" << std::endl;
   }
+#endif
   PeriodicTaskIF* tcpPollingTask = factory->createPeriodicTask(
       "TCP_POLLING", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
   result = tcpPollingTask->addComponent(objects::TCP_TMTC_POLLING_TASK);
@@ -92,7 +96,7 @@ void scheduling::initTasks() {
   }
 
   PeriodicTaskIF* liveTmTask = factory->createPeriodicTask(
-      "LIVE_TM", 55, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.4, nullptr, &RR_SCHEDULING);
+      "LIVE_TM", 55, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, nullptr, &RR_SCHEDULING);
   result = liveTmTask->addComponent(objects::LIVE_TM_TASK);
   if (result != returnvalue::OK) {
     scheduling::printAddObjectError("LIVE_TM", objects::LIVE_TM_TASK);
@@ -179,6 +183,28 @@ void scheduling::initTasks() {
   }
 #endif
 
+  // If those are added at a later stage..
+  /*
+  PeriodicTaskIF* logTmTask = factory->createPeriodicTask(
+      "LOG_PSTORE", 0, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, nullptr);
+  result = logTmTask->addComponent(objects::LOG_STORE_AND_TM_TASK);
+  if (result != returnvalue::OK) {
+    scheduling::printAddObjectError("LOG_STORE_AND_TM", objects::LOG_STORE_AND_TM_TASK);
+  }
+  PeriodicTaskIF* hkTmTask =
+      factory->createPeriodicTask("HK_PSTORE", 0, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, nullptr);
+  result = hkTmTask->addComponent(objects::HK_STORE_AND_TM_TASK);
+  if (result != returnvalue::OK) {
+    scheduling::printAddObjectError("HK_STORE_AND_TM", objects::HK_STORE_AND_TM_TASK);
+  }
+  PeriodicTaskIF* cfdpTmTask = factory->createPeriodicTask(
+      "CFDP_PSTORE", 0, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, nullptr);
+  result = cfdpTmTask->addComponent(objects::CFDP_STORE_AND_TM_TASK);
+  if (result != returnvalue::OK) {
+    scheduling::printAddObjectError("CFDP_STORE_AND_TM", objects::CFDP_STORE_AND_TM_TASK);
+  }
+   */
+
 #if OBSW_ADD_PLOC_SUPERVISOR == 1
   PeriodicTaskIF* supvHelperTask = factory->createPeriodicTask(
       "PLOC_SUPV_HELPER", 20, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, missedDeadlineFunc);
@@ -201,7 +227,7 @@ void scheduling::initTasks() {
   PeriodicTaskIF* dummyTask = factory->createPeriodicTask(
       "DUMMY_TASK", 35, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.8, missedDeadlineFunc);
   dummyTask->addComponent(objects::THERMAL_TEMP_INSERTER);
-  scheduling::scheduleTmpTempSensors(dummyTask);
+  scheduling::scheduleTmpTempSensors(dummyTask, true);
   scheduling::scheduleRtdSensors(dummyTask);
   dummyTask->addComponent(objects::SUS_0_N_LOC_XFYFZM_PT_XF);
   dummyTask->addComponent(objects::SUS_1_N_LOC_XBYFZM_PT_XB);
@@ -218,7 +244,9 @@ void scheduling::initTasks() {
 
   sif::info << "Starting tasks.." << std::endl;
   tmtcDistributor->startTask();
+#if OBSW_ADD_TMTC_UDP_SERVER == 1
   udpPollingTask->startTask();
+#endif
   tcpPollingTask->startTask();
   liveTmTask->startTask();
 
@@ -228,6 +256,12 @@ void scheduling::initTasks() {
   pstTask->startTask();
   thermalTask->startTask();
   dummyTask->startTask();
+
+  // If those are added at a later stage..
+  // logTmTask->startTask();
+  // cfdpTmTask->startTask();
+  // hkTmTask->startTask();
+
 #if OBSW_ADD_PLOC_SUPERVISOR == 1
   supvHelperTask->startTask();
 #endif

bsp_q7s/CMakeLists.txt

@@ -7,7 +7,8 @@ target_link_libraries(${SIMPLE_OBSW_NAME} PUBLIC ${LIB_FSFW_NAME})
 target_compile_definitions(${SIMPLE_OBSW_NAME} PRIVATE "Q7S_SIMPLE_MODE")
 add_subdirectory(simple)
 
-target_sources(${OBSW_NAME} PUBLIC main.cpp obsw.cpp)
+target_sources(${OBSW_NAME} PUBLIC main.cpp obsw.cpp scheduling.cpp
+                                   objectFactory.cpp)
 
 add_subdirectory(boardtest)
 
@@ -24,3 +25,4 @@ add_subdirectory(memory)
 add_subdirectory(callbacks)
 add_subdirectory(xadc)
 add_subdirectory(fs)
+add_subdirectory(acs)

bsp_q7s/acs/CMakeLists.txt

@@ -0,0 +1 @@
+# target_sources(${OBSW_NAME} PUBLIC <Source File List>)

bsp_q7s/acs/StrConfigPathGetter.h

@@ -0,0 +1,23 @@
+#include <optional>
+
+#include "bsp_q7s/fs/SdCardManager.h"
+#include "mission/acs/str/strHelpers.h"
+
+class StrConfigPathGetter : public startracker::SdCardConfigPathGetter {
+ public:
+  StrConfigPathGetter(SdCardManager& sdcMan) : sdcMan(sdcMan) {}
+
+  std::optional<std::string> getCfgPath() override {
+    if (!sdcMan.isSdCardUsable(std::nullopt)) {
+      return std::nullopt;
+    }
+    if (sdcMan.getActiveSdCard() == sd::SdCard::SLOT_1) {
+      return std::string("/mnt/sd1/startracker/flight-config.json");
+    } else {
+      return std::string("/mnt/sd0/startracker/flight-config.json");
+    }
+  }
+
+ private:
+  SdCardManager& sdcMan;
+};

bsp_q7s/boardconfig/busConf.h

@@ -12,10 +12,14 @@ static constexpr char SPI_RW_DEV[] = "/dev/spi_rw";
 static constexpr char I2C_PL_EIVE[] = "/dev/i2c_pl";
 //! I2C bus using the I2C peripheral of the ARM processing system (PS)
 static constexpr char I2C_PS_EIVE[] = "/dev/i2c_ps";
+//! I2C bus using the first I2C peripheral of the ARM processing system (PS).
+//! Named like this because it is used by default for the Q7 devices.
+static constexpr char I2C_Q7_EIVE[] = "/dev/i2c_q7";
 
 static constexpr char UART_GNSS_DEV[] = "/dev/gps0";
 static constexpr char UART_PLOC_MPSOC_DEV[] = "/dev/ul_plmpsoc";
-static constexpr char UART_PLOC_SUPERVSIOR_DEV[] = "/dev/ploc_supv";
+static constexpr char UART_PLOC_SUPERVISOR_DEV_FALLBACK[] = "/dev/ttyUL4";
+static constexpr char UART_PLOC_SUPERVISOR_DEV[] = "/dev/ploc_supv";
 static constexpr char UART_SYRLINKS_DEV[] = "/dev/ul_syrlinks";
 static constexpr char UART_STAR_TRACKER_DEV[] = "/dev/ul_str";
 static constexpr char UART_SCEX_DEV[] = "/dev/scex";
@@ -85,13 +89,9 @@ static constexpr char EN_RW_4[] = "enable_rw_4";
 static constexpr char RAD_SENSOR_CHIP_SELECT[] = "rad_sensor_chip_select";
 static constexpr char ENABLE_RADFET[] = "enable_radfet";
 
-static constexpr char PAPB_BUSY_SIGNAL_VC0[] = "papb_busy_signal_vc0";
 static constexpr char PAPB_EMPTY_SIGNAL_VC0[] = "papb_empty_signal_vc0";
-static constexpr char PAPB_BUSY_SIGNAL_VC1[] = "papb_busy_signal_vc1";
 static constexpr char PAPB_EMPTY_SIGNAL_VC1[] = "papb_empty_signal_vc1";
-static constexpr char PAPB_BUSY_SIGNAL_VC2[] = "papb_busy_signal_vc2";
 static constexpr char PAPB_EMPTY_SIGNAL_VC2[] = "papb_empty_signal_vc2";
-static constexpr char PAPB_BUSY_SIGNAL_VC3[] = "papb_busy_signal_vc3";
 static constexpr char PAPB_EMPTY_SIGNAL_VC3[] = "papb_empty_signal_vc3";
 
 static constexpr char PTME_RESETN[] = "ptme_resetn";

bsp_q7s/boardtest/Q7STestTask.cpp

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

bsp_q7s/core/CMakeLists.txt

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

bsp_q7s/core/CoreController.cpp

@@ -156,23 +156,12 @@ ReturnValue_t CoreController::initialize() {
   if (result != returnvalue::OK) {
     sif::warning << "CoreController::initialize: Base init failed" << std::endl;
   }
-  result = scratch::writeNumber(scratch::ALLOC_FAILURE_COUNT, 0);
-  if (result != returnvalue::OK) {
-    sif::warning << "CoreController::initialize: Setting up alloc failure "
-                    "count failed"
-                 << std::endl;
-  }
 
   result = paramHelper.initialize();
   if (result != returnvalue::OK) {
     return result;
   }
 
-  sdStateMachine();
-
-  triggerEvent(core::REBOOT_SW, CURRENT_CHIP, CURRENT_COPY);
-  announceCurrentImageInfo();
-  announceVersionInfo();
   EventManagerIF *eventManager =
       ObjectManager::instance()->get<EventManagerIF>(objects::EVENT_MANAGER);
   if (eventManager == nullptr or eventQueue == nullptr) {
@@ -189,17 +178,20 @@ ReturnValue_t CoreController::initialize() {
   if (result != returnvalue::OK) {
     sif::warning << "Subscribing for GPS GPS_FIX_CHANGE event failed" << std::endl;
   }
-
-  if (common::OBSW_VERSION_MAJOR >= 6 or common::OBSW_VERSION_MAJOR == 4) {
-    UioMapper sysRomMapper(q7s::UIO_SYS_ROM);
-    result = sysRomMapper.getMappedAdress(&mappedSysRomAddr, UioMapper::Permissions::READ_ONLY);
-    if (result != returnvalue::OK) {
-      // TODO: This might be a reason to switch to another image..
-      sif::error << "Getting mapped SYS ROM UIO address failed" << std::endl;
-      return ObjectManager::CHILD_INIT_FAILED;
-    }
+  triggerEvent(core::REBOOT_SW, CURRENT_CHIP, CURRENT_COPY);
+  announceCurrentImageInfo();
+  announceVersionInfo();
+  SdCardManager::SdStatePair sdStates;
+  sdcMan->getSdCardsStatus(sdStates);
+  announceSdInfo(sdStates);
+  sdStateMachine();
+  result = scratch::writeNumber(scratch::ALLOC_FAILURE_COUNT, 0);
+  if (result != returnvalue::OK) {
+    sif::warning << "CoreController::initialize: Setting up alloc failure "
+                    "count failed"
+                 << std::endl;
   }
-  return returnvalue::OK;
+  return result;
 }
 
 ReturnValue_t CoreController::initializeAfterTaskCreation() {
@@ -488,6 +480,16 @@ ReturnValue_t CoreController::executeAction(ActionId_t actionId, MessageQueueId_
       successRecipient = commandedBy;
       return returnvalue::OK;
     }
+    case (UPDATE_LEAP_SECONDS): {
+      if (size != sizeof(uint16_t)) {
+        return HasActionsIF::INVALID_PARAMETERS;
+      }
+      ReturnValue_t result = actionUpdateLeapSeconds(data);
+      if (result != returnvalue::OK) {
+        return result;
+      }
+      return HasActionsIF::EXECUTION_FINISHED;
+    }
     default: {
       return HasActionsIF::INVALID_ACTION_ID;
     }
@@ -562,21 +564,24 @@ ReturnValue_t CoreController::sdStateMachine() {
   }
 
   // This lambda checks the non-blocking operation of the SD card manager and assigns the new
-  // state on success. It returns true for an operation success and false otherwise
+  // state on success. It returns 0 for an operation success, -1 for failed operations, and 1
+  // for pending operations
   auto nonBlockingSdcOpChecking = [&](SdStates newStateOnSuccess, uint16_t maxCycleCount,
                                       std::string opPrintout) {
     SdCardManager::OpStatus status = sdcMan->checkCurrentOp(operation);
-    if (status == SdCardManager::OpStatus::SUCCESS) {
+    if (status == SdCardManager::OpStatus::SUCCESS or sdInfo.cycleCount > maxCycleCount) {
       sdFsmState = newStateOnSuccess;
       sdInfo.commandPending = false;
+      if (sdInfo.cycleCount > maxCycleCount) {
+        sif::warning << "CoreController::sdStateMachine: " << opPrintout << " takes too long"
+                     << std::endl;
+        sdInfo.cycleCount = 0;
+        return -1;
+      }
       sdInfo.cycleCount = 0;
-      return true;
-    } else if (sdInfo.cycleCount > 4) {
-      sif::warning << "CoreController::sdStateMachine: " << opPrintout << " takes too long"
-                   << std::endl;
-      return false;
-    }
-    return false;
+      return 0;
+    };
+    return 1;
   };
 
   if (sdFsmState == SdStates::UPDATE_SD_INFO_START) {
@@ -652,7 +657,7 @@ ReturnValue_t CoreController::sdStateMachine() {
         sdFsmState = tgtState;
       }
     } else {
-      if (nonBlockingSdcOpChecking(SdStates::MOUNT_SELF, 10, "Setting SDC state")) {
+      if (nonBlockingSdcOpChecking(SdStates::MOUNT_SELF, 10, "Setting SDC state") <= 0) {
         sdInfo.activeState = sd::SdState::ON;
         currentStateSetter(sdInfo.active, sd::SdState::ON);
         // Skip the two cycles now.
@@ -680,7 +685,7 @@ ReturnValue_t CoreController::sdStateMachine() {
       result = sdCardSetup(sdInfo.active, sd::SdState::MOUNTED, sdInfo.activeChar);
       sdInfo.commandPending = true;
     } else {
-      if (nonBlockingSdcOpChecking(SdStates::DETERMINE_OTHER, 5, "Mounting SD card")) {
+      if (nonBlockingSdcOpChecking(SdStates::DETERMINE_OTHER, 5, "Mounting SD card") <= 0) {
         sdcMan->setActiveSdCard(sdInfo.active);
         currMntPrefix = sdcMan->getCurrentMountPrefix();
         sdInfo.activeState = sd::SdState::MOUNTED;
@@ -722,12 +727,7 @@ ReturnValue_t CoreController::sdStateMachine() {
         sdInfo.commandPending = true;
       } else {
         if (nonBlockingSdcOpChecking(SdStates::SKIP_CYCLE_BEFORE_INFO_UPDATE, 10,
-                                     "Switching off other SD card")) {
-          sdInfo.otherState = sd::SdState::OFF;
-          currentStateSetter(sdInfo.other, sd::SdState::OFF);
-        } else {
-          // Continue.. avoid being stuck here..
-          sdFsmState = SdStates::SKIP_CYCLE_BEFORE_INFO_UPDATE;
+                                     "Switching off other SD card") <= 0) {
           sdInfo.otherState = sd::SdState::OFF;
           currentStateSetter(sdInfo.other, sd::SdState::OFF);
         }
@@ -738,12 +738,7 @@ ReturnValue_t CoreController::sdStateMachine() {
         sdInfo.commandPending = true;
       } else {
         if (nonBlockingSdcOpChecking(SdStates::MOUNT_UNMOUNT_OTHER, 10,
-                                     "Switching on other SD card")) {
-          sdInfo.otherState = sd::SdState::ON;
-          currentStateSetter(sdInfo.other, sd::SdState::ON);
-        } else {
-          // Contnue.. avoid being stuck here.
-          sdFsmState = SdStates::MOUNT_UNMOUNT_OTHER;
+                                     "Switching on other SD card") <= 0) {
           sdInfo.otherState = sd::SdState::ON;
           currentStateSetter(sdInfo.other, sd::SdState::ON);
         }
@@ -758,7 +753,8 @@ ReturnValue_t CoreController::sdStateMachine() {
         result = sdCardSetup(sdInfo.other, sd::SdState::ON, sdInfo.otherChar);
         sdInfo.commandPending = true;
       } else {
-        if (nonBlockingSdcOpChecking(SdStates::SET_STATE_OTHER, 10, "Unmounting other SD card")) {
+        if (nonBlockingSdcOpChecking(SdStates::SET_STATE_OTHER, 10, "Unmounting other SD card") <=
+            0) {
           sdInfo.otherState = sd::SdState::ON;
           currentStateSetter(sdInfo.other, sd::SdState::ON);
         } else {
@@ -772,7 +768,8 @@ ReturnValue_t CoreController::sdStateMachine() {
         result = sdCardSetup(sdInfo.other, sd::SdState::MOUNTED, sdInfo.otherChar);
         sdInfo.commandPending = true;
       } else {
-        if (nonBlockingSdcOpChecking(SdStates::UPDATE_SD_INFO_END, 4, "Mounting other SD card")) {
+        if (nonBlockingSdcOpChecking(SdStates::UPDATE_SD_INFO_END, 4, "Mounting other SD card") <=
+            0) {
           sdInfo.otherState = sd::SdState::MOUNTED;
           currentStateSetter(sdInfo.other, sd::SdState::MOUNTED);
         }
@@ -809,6 +806,7 @@ ReturnValue_t CoreController::sdStateMachine() {
     }
     sif::info << "SD card update into " << modeStr
               << " mode finished. Active SD: " << sdInfo.activeChar << std::endl;
+    announceSdInfo(sdInfo.currentState);
     if (not sdInfo.initFinished) {
       updateInternalSdInfo();
       sdInfo.initFinished = true;
@@ -847,7 +845,7 @@ ReturnValue_t CoreController::sdCardSetup(sd::SdCard sdCard, sd::SdState targetS
   if (state == sd::SdState::MOUNTED) {
     if (targetState == sd::SdState::OFF) {
       sif::info << "Switching off SD card " << sdChar << std::endl;
-      return sdcMan->switchOffSdCard(sdCard, true, &sdInfo.currentState);
+      return sdcMan->switchOffSdCard(sdCard, sdInfo.currentState, true);
     } else if (targetState == sd::SdState::ON) {
       sif::info << "Unmounting SD card " << sdChar << std::endl;
       return sdcMan->unmountSdCard(sdCard);
@@ -881,7 +879,7 @@ ReturnValue_t CoreController::sdCardSetup(sd::SdCard sdCard, sd::SdState targetS
       return sdcMan->mountSdCard(sdCard);
     } else if (targetState == sd::SdState::OFF) {
       sif::info << "Switching off SD card " << sdChar << std::endl;
-      return sdcMan->switchOffSdCard(sdCard, false, &sdInfo.currentState);
+      return sdcMan->switchOffSdCard(sdCard, sdInfo.currentState, false);
     }
   } else {
     sif::warning << "CoreController::sdCardSetup: Invalid state for this call" << std::endl;
@@ -905,8 +903,7 @@ ReturnValue_t CoreController::sdColdRedundantBlockingInit() {
     sif::info << "Switching off secondary SD card " << sdInfo.otherChar << std::endl;
     // Switch off other SD card in cold redundant mode if setting up preferred one worked
     // without issues
-    ReturnValue_t result2 =
-        sdcMan->switchOffSdCard(sdInfo.other, sdInfo.otherState, &sdInfo.currentState);
+    ReturnValue_t result2 = sdcMan->switchOffSdCard(sdInfo.other, sdInfo.currentState, true);
     if (result2 != returnvalue::OK and result2 != SdCardManager::ALREADY_OFF) {
       sif::warning << "Switching off secondary SD card " << sdInfo.otherChar
                    << " in cold redundant mode failed" << std::endl;
@@ -1224,6 +1221,10 @@ ReturnValue_t CoreController::actionReboot(const uint8_t *data, size_t size) {
 
 ReturnValue_t CoreController::gracefulShutdownTasks(xsc::Chip chip, xsc::Copy copy,
                                                     bool &protOpPerformed) {
+  // Store both sequence counters persistently.
+  core::SAVE_CFDP_SEQUENCE_COUNT = true;
+  core::SAVE_PUS_SEQUENCE_COUNT = true;
+
   sdcMan->setBlocking(true);
   sdcMan->markUnusable();
   // Wait two seconds to ensure no one uses the SD cards
@@ -1232,18 +1233,25 @@ ReturnValue_t CoreController::gracefulShutdownTasks(xsc::Chip chip, xsc::Copy co
   // Ensure that all writes/reads do finish.
   sync();
 
-  // Attempt graceful shutdown by unmounting and switching off SD cards
-  sdcMan->switchOffSdCard(sd::SdCard::SLOT_0);
-  sdcMan->switchOffSdCard(sd::SdCard::SLOT_1);
-  // If any boot copies are unprotected.
-  // Actually this function only ensures that reboots to the own image are protected..
-  ReturnValue_t result = setBootCopyProtection(xsc::Chip::SELF_CHIP, xsc::Copy::SELF_COPY, true,
-                                               protOpPerformed, false);
-  if (result == returnvalue::OK and protOpPerformed) {
+  // Unmount and switch off SD cards. This could possibly fix issues with the SD card and is
+  // the more graceful way to reboot the system. This function takes around 400 ms.
+  ReturnValue_t result = handleSwitchingSdCardsOffNonBlocking();
+  if (result != returnvalue::OK) {
+    sif::error
+        << "CoreController::gracefulShutdownTasks: Issues unmounting or switching SD cards off"
+        << std::endl;
+  }
+
+  // Ensure that the target chip is writeprotected in any case.
+  bool wasProtected = handleBootCopyProt(chip, copy, true);
+  if (wasProtected) {
     // TODO: Would be nice to notify operator. But we can't use the filesystem anymore
     // and a reboot is imminent. Use scratch buffer?
     sif::info << "Running slot was writeprotected before reboot" << std::endl;
   }
+  sif::info << "Graceful shutdown handling done" << std::endl;
+  // Ensure that all diagnostic prinouts arrive.
+  TaskFactory::delayTask(50);
   return result;
 }
 
@@ -1277,144 +1285,50 @@ ReturnValue_t CoreController::generateChipStateFile() {
   return returnvalue::OK;
 }
 
-ReturnValue_t CoreController::setBootCopyProtection(xsc::Chip targetChip, xsc::Copy targetCopy,
-                                                    bool protect, bool &protOperationPerformed,
-                                                    bool updateProtFile) {
-  bool allChips = false;
-  bool allCopies = false;
-  bool selfChip = false;
-  bool selfCopy = false;
-  protOperationPerformed = false;
-
-  switch (targetChip) {
-    case (xsc::Chip::ALL_CHIP): {
-      allChips = true;
-      break;
-    }
-    case (xsc::Chip::NO_CHIP): {
-      return returnvalue::OK;
-    }
-    case (xsc::Chip::SELF_CHIP): {
-      selfChip = true;
-      targetChip = CURRENT_CHIP;
-      break;
-    }
-    default: {
-      break;
-    }
-  }
-  switch (targetCopy) {
-    case (xsc::Copy::ALL_COPY): {
-      allCopies = true;
-      break;
-    }
-    case (xsc::Copy::NO_COPY): {
-      return returnvalue::OK;
-    }
-    case (xsc::Copy::SELF_COPY): {
-      selfCopy = true;
-      targetCopy = CURRENT_COPY;
-      break;
-    }
-    default: {
-      break;
-    }
+ReturnValue_t CoreController::setBootCopyProtectionAndUpdateFile(xsc::Chip targetChip,
+                                                                 xsc::Copy targetCopy,
+                                                                 bool protect) {
+  if (targetChip == xsc::Chip::ALL_CHIP or targetCopy == xsc::Copy::ALL_COPY) {
+    return returnvalue::FAILED;
   }
 
-  for (uint8_t arrIdx = 0; arrIdx < protArray.size(); arrIdx++) {
-    int result = handleBootCopyProtAtIndex(targetChip, targetCopy, protect, protOperationPerformed,
-                                           selfChip, selfCopy, allChips, allCopies, arrIdx);
-    if (result != 0) {
-      break;
-    }
-  }
-  if (protOperationPerformed and updateProtFile) {
+  bool protOperationPerformed = handleBootCopyProt(targetChip, targetCopy, protect);
+  if (protOperationPerformed) {
     updateProtInfo();
   }
   return returnvalue::OK;
 }
 
-int CoreController::handleBootCopyProtAtIndex(xsc::Chip targetChip, xsc::Copy targetCopy,
-                                              bool protect, bool &protOperationPerformed,
-                                              bool selfChip, bool selfCopy, bool allChips,
-                                              bool allCopies, uint8_t arrIdx) {
-  bool currentProt = protArray[arrIdx];
+bool CoreController::handleBootCopyProt(xsc::Chip targetChip, xsc::Copy targetCopy, bool protect) {
   std::ostringstream oss;
-  bool performOp = false;
-  if (protect == currentProt) {
-    return 0;
-  }
-  if (protOperationPerformed) {
-    if ((selfChip and selfCopy) or (not allCopies and not allChips)) {
-      // No need to continue, only one operation was requested
-      return 1;
-    }
-  }
-  xsc::Chip currentChip;
-  xsc::Copy currentCopy;
   oss << "writeprotect ";
-  if (arrIdx == 0 or arrIdx == 1) {
-    oss << "0 ";
-    currentChip = xsc::Chip::CHIP_0;
-  } else {
-    oss << "1 ";
-    currentChip = xsc::Chip::CHIP_1;
+  if (targetChip == xsc::Chip::SELF_CHIP) {
+    targetChip = CURRENT_CHIP;
   }
-  if (arrIdx == 0 or arrIdx == 2) {
+  if (targetCopy == xsc::Copy::SELF_COPY) {
+    targetCopy = CURRENT_COPY;
+  }
+  if (targetChip == xsc::Chip::CHIP_0) {
     oss << "0 ";
-    currentCopy = xsc::Copy::COPY_0;
-  } else {
+  } else if (targetChip == xsc::Chip::CHIP_1) {
+    oss << "1 ";
+  }
+  if (targetCopy == xsc::Copy::COPY_0) {
+    oss << "0 ";
+  } else if (targetCopy == xsc::Copy::COPY_1) {
     oss << "1 ";
-    currentCopy = xsc::Copy::COPY_1;
   }
   if (protect) {
     oss << "1";
   } else {
     oss << "0";
   }
-
-  int result = 0;
-  if (allChips and allCopies) {
-    performOp = true;
-  } else if (allChips) {
-    if ((selfCopy and CURRENT_COPY == targetCopy) or (currentCopy == targetCopy)) {
-      performOp = true;
-    }
-  } else if (allCopies) {
-    if ((selfChip and CURRENT_COPY == targetCopy) or (currentChip == targetChip)) {
-      performOp = true;
-    }
-  } else if (selfChip and (currentChip == targetChip)) {
-    if (selfCopy) {
-      if (currentCopy == targetCopy) {
-        performOp = true;
-      }
-    } else {
-      performOp = true;
-    }
-
-  } else if (selfCopy and (currentCopy == targetCopy)) {
-    if (selfChip) {
-      if (currentChip == targetChip) {
-        performOp = true;
-      }
-    } else {
-      performOp = true;
-    }
-  } else if ((targetChip == currentChip) and (targetCopy == currentCopy)) {
-    performOp = true;
+  sif::info << "Executing command: " << oss.str() << std::endl;
+  int result = std::system(oss.str().c_str());
+  if (result == 0) {
+    return true;
   }
-  if (result != 0) {
-    utility::handleSystemError(result, "CoreController::checkAndSetBootCopyProtection");
-  }
-  if (performOp) {
-    // TODO: Lock operation take a long time. Use command executor? That would require a
-    // new state machine..
-    protOperationPerformed = true;
-    sif::info << "Executing command: " << oss.str() << std::endl;
-    result = std::system(oss.str().c_str());
-  }
-  return 0;
+  return false;
 }
 
 ReturnValue_t CoreController::updateProtInfo(bool regenerateChipStateFile) {
@@ -1459,7 +1373,6 @@ ReturnValue_t CoreController::handleProtInfoUpdateLine(std::string nextLine) {
   using namespace std;
   string word;
   uint8_t wordIdx = 0;
-  uint8_t arrayIdx = 0;
   istringstream iss(nextLine);
   xsc::Chip currentChip = xsc::Chip::CHIP_0;
   xsc::Copy currentCopy = xsc::Copy::COPY_0;
@@ -1471,28 +1384,11 @@ ReturnValue_t CoreController::handleProtInfoUpdateLine(std::string nextLine) {
       currentCopy = static_cast<xsc::Copy>(stoi(word));
     }
 
-    if (wordIdx == 3) {
-      if (currentChip == xsc::Chip::CHIP_0) {
-        if (currentCopy == xsc::Copy::COPY_0) {
-          arrayIdx = 0;
-        } else if (currentCopy == xsc::Copy::COPY_1) {
-          arrayIdx = 1;
-        }
-      }
-
-      else if (currentChip == xsc::Chip::CHIP_1) {
-        if (currentCopy == xsc::Copy::COPY_0) {
-          arrayIdx = 2;
-        } else if (currentCopy == xsc::Copy::COPY_1) {
-          arrayIdx = 3;
-        }
-      }
-    }
     if (wordIdx == 5) {
       if (word == "unlocked.") {
-        protArray[arrayIdx] = false;
+        protArray[currentChip][currentCopy] = false;
       } else {
-        protArray[arrayIdx] = true;
+        protArray[currentChip][currentCopy] = true;
       }
     }
     wordIdx++;
@@ -1525,6 +1421,9 @@ void CoreController::performMountedSdCardOperations() {
       if (not timeFileInitDone) {
         initClockFromTimeFile();
       }
+      if (not leapSecondsInitDone) {
+        initLeapSeconds();
+      }
       performRebootWatchdogHandling(false);
       performRebootCountersHandling(false);
     }
@@ -2180,14 +2079,78 @@ ReturnValue_t CoreController::backupTimeFileHandler() {
   return returnvalue::OK;
 }
 
+void CoreController::initLeapSeconds() {
+  ReturnValue_t result = initLeapSecondsFromFile();
+  if (result != returnvalue::OK) {
+    Clock::setLeapSeconds(config::LEAP_SECONDS);
+    writeLeapSecondsToFile(config::LEAP_SECONDS);
+  }
+  leapSecondsInitDone = true;
+}
+
+ReturnValue_t CoreController::initLeapSecondsFromFile() {
+  std::string fileName = currMntPrefix + LEAP_SECONDS_FILE;
+  std::error_code e;
+  if (sdcMan->isSdCardUsable(std::nullopt) and std::filesystem::exists(fileName, e)) {
+    std::ifstream leapSecondsFile(fileName);
+    std::string nextWord;
+    std::getline(leapSecondsFile, nextWord);
+    std::istringstream iss(nextWord);
+    iss >> nextWord;
+    if (iss.bad() or nextWord != "LEAP") {
+      return returnvalue::FAILED;
+    }
+    iss >> nextWord;
+    if (iss.bad() or nextWord != "SECONDS:") {
+      return returnvalue::FAILED;
+    }
+    iss >> nextWord;
+    uint16_t leapSeconds = 0;
+    leapSeconds = std::stoi(nextWord.c_str());
+    if (iss.bad()) {
+      return returnvalue::FAILED;
+    }
+    Clock::setLeapSeconds(leapSeconds);
+    return returnvalue::OK;
+  }
+  sif::error
+      << "CoreController::leapSecondsFileHandler: Initalization of leap seconds from file failed"
+      << std::endl;
+  return returnvalue::FAILED;
+};
+
+ReturnValue_t CoreController::writeLeapSecondsToFile(const uint16_t leapSeconds) {
+  std::string fileName = currMntPrefix + LEAP_SECONDS_FILE;
+  if (not sdcMan->isSdCardUsable(std::nullopt)) {
+    return returnvalue::FAILED;
+  }
+  std::ofstream leapSecondsFile(fileName.c_str(), std::ofstream::out | std::ofstream::trunc);
+  if (not leapSecondsFile.good()) {
+    sif::error << "CoreController::leapSecondsFileHandler: Error opening leap seconds file: "
+               << strerror(errno) << std::endl;
+    return returnvalue::FAILED;
+  }
+  leapSecondsFile << "LEAP SECONDS: " << leapSeconds << std::endl;
+  return returnvalue::OK;
+};
+
+ReturnValue_t CoreController::actionUpdateLeapSeconds(const uint8_t *data) {
+  uint16_t leapSeconds = data[1] | (data[0] << 8);
+  ReturnValue_t result = writeLeapSecondsToFile(leapSeconds);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  Clock::setLeapSeconds(leapSeconds);
+  return returnvalue::OK;
+}
+
 ReturnValue_t CoreController::initClockFromTimeFile() {
   using namespace GpsHyperion;
   using namespace std;
   std::string fileName = currMntPrefix + BACKUP_TIME_FILE;
   std::error_code e;
   if (sdcMan->isSdCardUsable(std::nullopt) and std::filesystem::exists(fileName, e) and
-      ((gpsFix == FixMode::UNKNOWN or gpsFix == FixMode::NOT_SEEN) or
-       not utility::timeSanityCheck())) {
+      ((gpsFix == FixMode::NOT_SEEN) or not utility::timeSanityCheck())) {
     ifstream timeFile(fileName);
     string nextWord;
     getline(timeFile, nextWord);
@@ -2520,14 +2483,10 @@ void CoreController::announceVersionInfo() {
   }
 
   triggerEvent(VERSION_INFO, p1, p2);
-
-  if (common::OBSW_VERSION_MAJOR >= 6 or common::OBSW_VERSION_MAJOR == 4) {
-    if (mappedSysRomAddr != nullptr) {
-      uint32_t p1Firmware = *(reinterpret_cast<uint32_t *>(mappedSysRomAddr));
-      uint32_t p2Firmware = *(reinterpret_cast<uint32_t *>(mappedSysRomAddr) + 1);
-      triggerEvent(FIRMWARE_INFO, p1Firmware, p2Firmware);
-    }
-  }
+  p1 = (core::FW_VERSION_MAJOR << 24) | (core::FW_VERSION_MINOR << 16) |
+       (core::FW_VERSION_REVISION << 8) | (core::FW_VERSION_HAS_SHA);
+  std::memcpy(&p2, core::FW_VERSION_GIT_SHA, 4);
+  triggerEvent(FIRMWARE_INFO, p1, p2);
 }
 
 void CoreController::announceCurrentImageInfo() {
@@ -2579,6 +2538,68 @@ ReturnValue_t CoreController::performGracefulShutdown(xsc::Chip tgtChip, xsc::Co
   return returnvalue::OK;
 }
 
+void CoreController::announceSdInfo(SdCardManager::SdStatePair sdStates) {
+  auto activeSdCard = sdcMan->getActiveSdCard();
+  uint32_t p1 = sd::SdCard::NONE;
+  if (activeSdCard.has_value()) {
+    p1 = static_cast<uint32_t>(activeSdCard.value());
+  }
+  uint32_t p2 =
+      (static_cast<uint32_t>(sdStates.first) << 16) | static_cast<uint32_t>(sdStates.second);
+  triggerEvent(core::ACTIVE_SD_INFO, p1, p2);
+}
+
+ReturnValue_t CoreController::handleSwitchingSdCardsOffNonBlocking() {
+  sdcMan->setBlocking(false);
+  SdCardManager::Operations op;
+  std::pair<sd::SdState, sd::SdState> sdStatus;
+  ReturnValue_t result = sdcMan->getSdCardsStatus(sdStatus);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  Countdown maxWaitTimeCd(10000);
+  // Stopwatch watch;
+  auto waitingForFinish = [&]() {
+    auto currentState = sdcMan->checkCurrentOp(op);
+    if (currentState == SdCardManager::OpStatus::IDLE) {
+      return returnvalue::OK;
+    }
+    while (currentState == SdCardManager::OpStatus::ONGOING) {
+      if (maxWaitTimeCd.hasTimedOut()) {
+        return returnvalue::FAILED;
+      }
+      TaskFactory::delayTask(50);
+      currentState = sdcMan->checkCurrentOp(op);
+    }
+    return returnvalue::OK;
+  };
+  if (sdStatus.first != sd::SdState::OFF) {
+    sdcMan->unmountSdCard(sd::SdCard::SLOT_0);
+    result = waitingForFinish();
+    if (result != returnvalue::OK) {
+      return result;
+    }
+    sdcMan->switchOffSdCard(sd::SdCard::SLOT_0, sdStatus, false);
+    result = waitingForFinish();
+    if (result != returnvalue::OK) {
+      return result;
+    }
+  }
+  if (sdStatus.second != sd::SdState::OFF) {
+    sdcMan->unmountSdCard(sd::SdCard::SLOT_1);
+    result = waitingForFinish();
+    if (result != returnvalue::OK) {
+      return result;
+    }
+    sdcMan->switchOffSdCard(sd::SdCard::SLOT_1, sdStatus, false);
+    result = waitingForFinish();
+    if (result != returnvalue::OK) {
+      return result;
+    }
+  }
+  return result;
+}
+
 bool CoreController::isNumber(const std::string &s) {
   return !s.empty() && std::find_if(s.begin(), s.end(),
                                     [](unsigned char c) { return !std::isdigit(c); }) == s.end();

bsp_q7s/core/CoreController.h

@@ -1,6 +1,7 @@
 #ifndef BSP_Q7S_CORE_CORECONTROLLER_H_
 #define BSP_Q7S_CORE_CORECONTROLLER_H_
 
+#include <bsp_q7s/core/defs.h>
 #include <fsfw/container/DynamicFIFO.h>
 #include <fsfw/container/SimpleRingBuffer.h>
 #include <fsfw/globalfunctions/PeriodicOperationDivider.h>
@@ -8,13 +9,12 @@
 #include <fsfw/parameters/ReceivesParameterMessagesIF.h>
 #include <fsfw_hal/linux/uio/UioMapper.h>
 #include <libxiphos.h>
-#include <mission/acs/archive/GPSDefinitions.h>
+#include <linux/acs/GPSDefinitions.h>
 #include <mission/utility/trace.h>
 
 #include <atomic>
 #include <cstddef>
 
-#include "CoreDefinitions.h"
 #include "OBSWConfig.h"
 #include "bsp_q7s/fs/SdCardManager.h"
 #include "events/subsystemIdRanges.h"
@@ -150,6 +150,8 @@ class CoreController : public ExtendedControllerBase, public ReceivesParameterMe
       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 LEAP_SECONDS_FILE =
+      "/" + std::string(core::CONF_FOLDER) + "/" + std::string(core::LEAP_SECONDS_FILE_NAME);
   const std::string BACKUP_TIME_FILE =
       "/" + std::string(core::CONF_FOLDER) + "/" + std::string(core::TIME_FILE_NAME);
   const std::string REBOOT_COUNTERS_FILE =
@@ -199,8 +201,8 @@ class CoreController : public ExtendedControllerBase, public ReceivesParameterMe
    * @param updateProtFile Specify whether the protection info file is updated
    * @return
    */
-  ReturnValue_t setBootCopyProtection(xsc::Chip targetChip, xsc::Copy targetCopy, bool protect,
-                                      bool& protOperationPerformed, bool updateProtFile = true);
+  ReturnValue_t setBootCopyProtectionAndUpdateFile(xsc::Chip targetChip, xsc::Copy targetCopy,
+                                                   bool protect);
 
   bool sdInitFinished() const;
 
@@ -209,7 +211,7 @@ class CoreController : public ExtendedControllerBase, public ReceivesParameterMe
   static constexpr MutexIF::TimeoutType TIMEOUT_TYPE = MutexIF::TimeoutType::WAITING;
   static constexpr uint32_t MUTEX_TIMEOUT = 20;
   bool enableHkSet = false;
-  GpsHyperion::FixMode gpsFix = GpsHyperion::FixMode::UNKNOWN;
+  GpsHyperion::FixMode gpsFix = GpsHyperion::FixMode::NOT_SEEN;
 
   // States for SD state machine, which is used in non-blocking mode
   enum class SdStates {
@@ -296,6 +298,7 @@ class CoreController : public ExtendedControllerBase, public ReceivesParameterMe
 
   std::string currMntPrefix;
   bool timeFileInitDone = false;
+  bool leapSecondsInitDone = false;
   bool performOneShotSdCardOpsSwitch = false;
   uint8_t shortSdCardCdCounter = 0;
 #if OBSW_THREAD_TRACING == 1
@@ -304,12 +307,10 @@ class CoreController : public ExtendedControllerBase, public ReceivesParameterMe
   Countdown sdCardCheckCd = Countdown(INIT_SD_CARD_CHECK_TIMEOUT);
 
   /**
-   * Index 0: Chip 0 Copy 0
-   * Index 1: Chip 0 Copy 1
-   * Index 2: Chip 1 Copy 0
-   * Index 3: Chip 1 Copy 1
+   * First index: Chip.
+   * Second index: Copy.
    */
-  std::array<bool, 4> protArray;
+  bool protArray[2][2]{};
   PeriodicOperationDivider opDivider5;
   PeriodicOperationDivider opDivider10;
 
@@ -337,7 +338,11 @@ class CoreController : public ExtendedControllerBase, public ReceivesParameterMe
   void performMountedSdCardOperations();
   ReturnValue_t initVersionFile();
 
+  void initLeapSeconds();
+  ReturnValue_t initLeapSecondsFromFile();
   ReturnValue_t initClockFromTimeFile();
+  ReturnValue_t actionUpdateLeapSeconds(const uint8_t* data);
+  ReturnValue_t writeLeapSecondsToFile(const uint16_t leapSeconds);
   ReturnValue_t performSdCardCheck();
   ReturnValue_t backupTimeFileHandler();
   ReturnValue_t initBootCopyFile();
@@ -374,9 +379,8 @@ class CoreController : public ExtendedControllerBase, public ReceivesParameterMe
   ReturnValue_t gracefulShutdownTasks(xsc::Chip chip, xsc::Copy copy, bool& protOpPerformed);
 
   ReturnValue_t handleProtInfoUpdateLine(std::string nextLine);
-  int handleBootCopyProtAtIndex(xsc::Chip targetChip, xsc::Copy targetCopy, bool protect,
-                                bool& protOperationPerformed, bool selfChip, bool selfCopy,
-                                bool allChips, bool allCopies, uint8_t arrIdx);
+  ReturnValue_t handleSwitchingSdCardsOffNonBlocking();
+  bool handleBootCopyProt(xsc::Chip targetChip, xsc::Copy targetCopy, bool protect);
   void rebootWatchdogAlgorithm(RebootWatchdogFile& rf, bool& needsReboot, xsc::Chip& tgtChip,
                                xsc::Copy& tgtCopy);
   void resetRebootWatchdogCounters(xsc::Chip tgtChip, xsc::Copy tgtCopy);
@@ -388,6 +392,7 @@ class CoreController : public ExtendedControllerBase, public ReceivesParameterMe
   void announceBootCounts();
   void announceVersionInfo();
   void announceCurrentImageInfo();
+  void announceSdInfo(SdCardManager::SdStatePair sdStates);
   void readHkData();
   void dirListingDumpHandler();
   bool isNumber(const std::string& s);

bsp_q7s/core/XiphosWdtHandler.cpp

@@ -0,0 +1,122 @@
+#include "XiphosWdtHandler.h"
+
+#include "fsfw/ipc/QueueFactory.h"
+
+XiphosWdtHandler::XiphosWdtHandler(object_id_t objectId)
+    : SystemObject(objectId),
+      requestQueue(QueueFactory::instance()->createMessageQueue()),
+      actionHelper(this, requestQueue) {}
+
+ReturnValue_t XiphosWdtHandler::initialize() {
+  ReturnValue_t result = actionHelper.initialize();
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  int retval = xsc_watchdog_init(&wdtHandle);
+  if (retval != 0) {
+    sif::error << "XiphosWdtHandler: Initiating watchdog failed with code " << retval << ": "
+               << strerror(retval) << std::endl;
+    return ObjectManagerIF::CHILD_INIT_FAILED;
+  }
+  if (wdtHandle == nullptr) {
+    sif::error << "XiphosWdtHandler: WDT handle is nullptr!" << std::endl;
+    return ObjectManagerIF::CHILD_INIT_FAILED;
+  }
+  retval = xsc_watchdog_set_timeout(wdtHandle, timeoutSeconds);
+  if (retval != 0) {
+    // This propably means that the default timeout is used. Still continue with task init.
+    sif::warning << "XiphosWdtHandler: Setting WDT timeout of " << timeoutSeconds
+                 << " seconds failed with code " << result << ": " << strerror(retval) << std::endl;
+  }
+  return enableWdt();
+}
+
+ReturnValue_t XiphosWdtHandler::performOperation(uint8_t opCode) {
+  CommandMessage command;
+  ReturnValue_t result;
+  for (result = requestQueue->receiveMessage(&command); result == returnvalue::OK;
+       result = requestQueue->receiveMessage(&command)) {
+    result = actionHelper.handleActionMessage(&command);
+    if (result == returnvalue::OK) {
+      continue;
+    }
+    sif::warning << "Can not handle message with message type " << command.getMessageType()
+                 << std::endl;
+  }
+  if (enabled) {
+    int retval = xsc_watchdog_keepalive(wdtHandle);
+    if (retval != 0) {
+      sif::warning << "XiphosWdtHandler: Feeding WDT failed with code " << retval << ": "
+                   << strerror(retval) << std::endl;
+      return returnvalue::FAILED;
+    }
+  }
+  return returnvalue::OK;
+}
+
+ReturnValue_t XiphosWdtHandler::executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
+                                              const uint8_t *data, size_t size) {
+  switch (actionId) {
+    case (ActionId::ENABLE): {
+      ReturnValue_t result = enableWdt();
+      if (result != returnvalue::OK) {
+        return result;
+      }
+      return EXECUTION_FINISHED;
+    }
+    case (ActionId::DISABLE): {
+      ReturnValue_t result = disableWdt();
+      if (result != returnvalue::OK) {
+        return result;
+      }
+      return EXECUTION_FINISHED;
+    }
+  }
+  return HasActionsIF::INVALID_ACTION_ID;
+}
+
+ReturnValue_t XiphosWdtHandler::enableWdt() {
+  int nowayout = 0;
+  int status = 0;
+  int retval = xsc_watchdog_get_status(&nowayout, &status);
+  // If this fails for whatever reason, just try enabling in any case.
+  if (retval != 0) {
+    sif::warning << "XiphosWdtHandler: Getting WDT status failed" << std::endl;
+  }
+  // Of course the enable API will fail if the device is already on, just perfect, love me some
+  // good C API... :)))
+  if (retval != 0 or status == 0) {
+    retval = xsc_watchdog_enable(wdtHandle);
+    if (retval != 0) {
+      sif::error << "XiphosWdtHandler: Enabling WDT failed with code " << retval << ": "
+                 << strerror(retval) << std::endl;
+      return returnvalue::FAILED;
+    }
+  }
+  enabled = true;
+  return returnvalue::OK;
+}
+
+ReturnValue_t XiphosWdtHandler::disableWdt() {
+  int nowayout = 0;
+  int status = 0;
+  int retval = xsc_watchdog_get_status(&nowayout, &status);
+  // If this fails for whatever reason, just try disabling in any case.
+  if (retval != 0) {
+    sif::warning << "XiphosWdtHandler: Getting WDT status failed" << std::endl;
+  }
+  // Of course the disable API will fail if the device is already off, just perfect, love me some
+  // good C API... :)))
+  if (retval != 0 or status == 1) {
+    retval = xsc_watchdog_disable(wdtHandle);
+    if (retval != 0) {
+      sif::error << "XiphosWdtHandler: Disabling WDT failed with code " << retval << ": "
+                 << strerror(retval) << std::endl;
+      return returnvalue::FAILED;
+    }
+  }
+  enabled = false;
+  return returnvalue::OK;
+}
+
+MessageQueueId_t XiphosWdtHandler::getCommandQueue() const { return requestQueue->getId(); }

bsp_q7s/core/XiphosWdtHandler.h

@@ -0,0 +1,36 @@
+#ifndef BSP_Q7S_CORE_XIPHOSWDTHANDLER_H_
+#define BSP_Q7S_CORE_XIPHOSWDTHANDLER_H_
+
+#include <fsfw/action/HasActionsIF.h>
+#include <fsfw/objectmanager/SystemObject.h>
+#include <fsfw/tasks/ExecutableObjectIF.h>
+#include <libxiphos.h>
+
+class XiphosWdtHandler : public SystemObject, public ExecutableObjectIF, public HasActionsIF {
+ public:
+  enum ActionId { ENABLE = 0, DISABLE = 1 };
+
+  XiphosWdtHandler(object_id_t objectId);
+  ReturnValue_t performOperation(uint8_t opCode) override;
+  ReturnValue_t initialize() override;
+
+  ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
+                              const uint8_t* data, size_t size) override;
+  [[nodiscard]] virtual MessageQueueId_t getCommandQueue() const override;
+
+ private:
+  // Wrappers to ensure idempotency of trash C API.
+  ReturnValue_t enableWdt();
+  ReturnValue_t disableWdt();
+  // Timeout duration range specified by Xiphos: 0.001 seconds to 171 seconds. The libxiphos API
+  // expects an int, so I guess this translates to 1 to 171 seconds.
+  // WARNING: DO NOT SET THIS HIGHER THAN 80 SECONDS!
+  // Possible bug in Xiphos/Xilinx kernel driver for watchdog, related to overflow.
+  int timeoutSeconds = 80;
+  bool enabled = false;
+  struct watchdog_s* wdtHandle = nullptr;
+  MessageQueueIF* requestQueue = nullptr;
+  ActionHelper actionHelper;
+};
+
+#endif /* BSP_Q7S_CORE_XIPHOSWDTHANDLER_H_ */

bsp_q7s/core/defs.h

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

bsp_q7s/em/emObjectFactory.cpp

@@ -1,4 +1,6 @@
 #include <bsp_q7s/callbacks/q7sGpioCallbacks.h>
+#include <bsp_q7s/core/XiphosWdtHandler.h>
+#include <bsp_q7s/objectFactory.h>
 #include <dummies/ComCookieDummy.h>
 #include <dummies/PcduHandlerDummy.h>
 #include <fsfw/health/HealthTableIF.h>
@@ -10,8 +12,8 @@
 
 #include "OBSWConfig.h"
 #include "bsp_q7s/core/CoreController.h"
-#include "bsp_q7s/core/ObjectFactory.h"
 #include "busConf.h"
+#include "common/config/devices/addresses.h"
 #include "devConf.h"
 #include "dummies/helperFactory.h"
 #include "eive/objects.h"
@@ -35,16 +37,18 @@ void ObjectFactory::produce(void* args) {
 #endif
 
   PersistentTmStores stores;
+  readFirmwareVersion();
+  new XiphosWdtHandler(objects::XIPHOS_WDT);
   ObjectFactory::produceGenericObjects(&healthTable, &pusFunnel, &cfdpFunnel,
-                                       *SdCardManager::instance(), &ipcStore, &tmStore, stores,
-                                       200);
+                                       *SdCardManager::instance(), &ipcStore, &tmStore, stores, 200,
+                                       enableHkSets, true);
 
   LinuxLibgpioIF* gpioComIF = nullptr;
   SerialComIF* uartComIF = nullptr;
   SpiComIF* spiMainComIF = nullptr;
   I2cComIF* i2cComIF = nullptr;
   createCommunicationInterfaces(&gpioComIF, &uartComIF, &spiMainComIF, &i2cComIF);
-  /* Adding gpios for chip select decoding to the gpioComIf */
+  // Adding GPIOs for chip select decoding and initializing them.
   q7s::gpioCallbacks::initSpiCsDecoder(gpioComIF);
   gpioCallbacks::disableAllDecoder(gpioComIF);
   createPlI2cResetGpio(gpioComIF);
@@ -60,17 +64,41 @@ void ObjectFactory::produce(void* args) {
 #if OBSW_ADD_PLOC_SUPERVISOR == 1 || OBSW_ADD_PLOC_MPSOC == 1
   dummyCfg.addPlocDummies = false;
 #endif
+#if OBSW_ADD_TMP_DEVICES == 1
+  std::vector<std::pair<object_id_t, address_t>> tmpDevsToAdd = {{
+      {objects::TMP1075_HANDLER_PLPCDU_0, addresses::TMP1075_PLPCDU_0},
+      {objects::TMP1075_HANDLER_PLPCDU_1, addresses::TMP1075_PLPCDU_1},
+      {objects::TMP1075_HANDLER_IF_BOARD, addresses::TMP1075_IF_BOARD},
+  }};
+  createTmpComponents(tmpDevsToAdd);
+  dummy::Tmp1075Cfg tmpCfg{};
+  tmpCfg.addTcsBrd0 = true;
+  tmpCfg.addTcsBrd1 = true;
+  tmpCfg.addPlPcdu0 = false;
+  tmpCfg.addPlPcdu1 = false;
+  tmpCfg.addIfBrd = false;
+  dummyCfg.tmp1075Cfg = tmpCfg;
+#endif
 #if OBSW_ADD_GOMSPACE_PCDU == 1
   dummyCfg.addPowerDummies = false;
   // The ACU broke.
   dummyCfg.addOnlyAcuDummy = true;
 #endif
+#if OBSW_ADD_STAR_TRACKER == 1
+  dummyCfg.addStrDummy = false;
+#endif
+#if OBSW_ADD_SCEX_DEVICE == 0
+  dummyCfg.addScexDummy = true;
+#endif
 #if OBSW_ADD_BPX_BATTERY_HANDLER == 1
   dummyCfg.addBpxBattDummy = false;
 #endif
 #if OBSW_ADD_ACS_BOARD == 1
   dummyCfg.addAcsBoardDummies = false;
 #endif
+#if OBSW_ADD_PL_PCDU == 0
+  dummyCfg.addPlPcduDummy = true;
+#endif
 
   PowerSwitchIF* pwrSwitcher = nullptr;
 #if OBSW_ADD_GOMSPACE_PCDU == 0
@@ -80,13 +108,28 @@ void ObjectFactory::produce(void* args) {
 #endif
   satsystem::EIVE_SYSTEM.setI2cRecoveryParams(pwrSwitcher);
 
+  const char* battAndImtqI2cDev = q7s::I2C_PL_EIVE;
+  if (core::FW_VERSION_MAJOR >= 4) {
+    battAndImtqI2cDev = q7s::I2C_PS_EIVE;
+  }
+  static_cast<void>(battAndImtqI2cDev);
+
+#if OBSW_ADD_BPX_BATTERY_HANDLER == 1
+  createBpxBatteryComponent(enableHkSets, battAndImtqI2cDev);
+#endif
+  createPowerController(true, enableHkSets);
+
   dummy::createDummies(dummyCfg, *pwrSwitcher, gpioComIF, enableHkSets);
 
   new CoreController(objects::CORE_CONTROLLER, enableHkSets);
 
-#if OBSW_ADD_ACS_BOARD == 1
-  // Still initialize chip select to avoid SPI bus issues.
+  auto* stackHandler = new Stack5VHandler(*pwrSwitcher);
+  static_cast<void>(stackHandler);
+
+  // Initialize chip select to avoid SPI bus issues.
   createRadSensorChipSelect(gpioComIF);
+
+#if OBSW_ADD_ACS_BOARD == 1
   createAcsBoardComponents(*spiMainComIF, gpioComIF, uartComIF, *pwrSwitcher, true,
                            adis1650x::Type::ADIS16507);
 #else
@@ -97,7 +140,7 @@ void ObjectFactory::produce(void* args) {
 #endif
 
 #if OBSW_ADD_MGT == 1
-  createImtqComponents(pwrSwitcher, enableHkSets);
+  createImtqComponents(pwrSwitcher, enableHkSets, battAndImtqI2cDev);
 #endif
 
 #if OBSW_ADD_SYRLINKS == 1
@@ -108,28 +151,22 @@ void ObjectFactory::produce(void* args) {
   createReactionWheelComponents(gpioComIF, pwrSwitcher);
 #endif
 
-#if OBSW_ADD_BPX_BATTERY_HANDLER == 1
-  createBpxBatteryComponent(enableHkSets);
-#endif
-
 #if OBSW_ADD_STAR_TRACKER == 1
-  createStrComponents(pwrSwitcher);
+  createStrComponents(pwrSwitcher, *SdCardManager::instance());
 #endif /* OBSW_ADD_STAR_TRACKER == 1 */
 
+#if OBSW_ADD_PL_PCDU == 1
+  createPlPcduComponents(gpioComIF, spiMainComIF, pwrSwitcher, *stackHandler);
+#endif
   createPayloadComponents(gpioComIF, *pwrSwitcher);
 
 #if OBSW_ADD_CCSDS_IP_CORES == 1
   CcsdsIpCoreHandler* ipCoreHandler = nullptr;
   CcsdsComponentArgs ccsdsArgs(*gpioComIF, *ipcStore, *tmStore, stores, *pusFunnel, *cfdpFunnel,
-                               &ipCoreHandler);
-  createCcsdsComponents(ccsdsArgs);
-#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
+                               &ipCoreHandler, 0, 0);
+  createCcsdsIpComponentsWrapper(ccsdsArgs);
 #endif /* OBSW_ADD_CCSDS_IP_CORES == 1 */
+
   /* Test Task */
 #if OBSW_ADD_TEST_CODE == 1
   createTestComponents(gpioComIF);
@@ -138,9 +175,9 @@ void ObjectFactory::produce(void* args) {
   createScexComponents(q7s::UART_SCEX_DEV, pwrSwitcher, *SdCardManager::instance(), false,
                        power::Switches::PDU1_CH5_SOLAR_CELL_EXP_5V);
 #endif
-  createAcsController(true, enableHkSets);
+  createAcsController(true, enableHkSets, *SdCardManager::instance());
   HeaterHandler* heaterHandler;
   createHeaterComponents(gpioComIF, pwrSwitcher, healthTable, heaterHandler);
-  createThermalController(*heaterHandler);
-  satsystem::init();
+  createThermalController(*heaterHandler, true);
+  satsystem::init(true);
 }

bsp_q7s/fmObjectFactory.cpp

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

bsp_q7s/fs/SdCardManager.cpp

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

bsp_q7s/fs/SdCardManager.h

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

bsp_q7s/objectFactory.cpp

@@ -1,8 +1,9 @@
-#include "ObjectFactory.h"
+#include "objectFactory.h"
 
 #include <fsfw/devicehandlers/HealthDevice.h>
 #include <fsfw/subsystem/Subsystem.h>
 #include <fsfw/tasks/TaskFactory.h>
+#include <fsfw_hal/linux/uio/UioMapper.h>
 #include <linux/acs/AcsBoardPolling.h>
 #include <linux/acs/GpsHyperionLinuxController.h>
 #include <linux/acs/ImtqPollingTask.h>
@@ -12,7 +13,6 @@
 #include <linux/payload/PlocMemoryDumper.h>
 #include <linux/payload/PlocMpsocHandler.h>
 #include <linux/payload/PlocMpsocSpecialComHelper.h>
-#include <linux/payload/PlocSupervisorHandler.h>
 #include <linux/payload/ScexUartReader.h>
 #include <linux/payload/plocMpsocHelpers.h>
 #include <linux/power/CspComIF.h>
@@ -32,12 +32,14 @@
 #include <mission/system/objects/CamSwitcher.h>
 #include <mission/system/tcs/TmpDevFdir.h>
 
+#include <cstdint>
+#include <cstring>
+
 #include "OBSWConfig.h"
+#include "bsp_q7s/acs/StrConfigPathGetter.h"
 #include "bsp_q7s/boardtest/Q7STestTask.h"
 #include "bsp_q7s/callbacks/gnssCallback.h"
-#include "bsp_q7s/callbacks/pcduSwitchCb.h"
 #include "bsp_q7s/callbacks/q7sGpioCallbacks.h"
-#include "bsp_q7s/callbacks/rwSpiCallback.h"
 #include "busConf.h"
 #include "ccsdsConfig.h"
 #include "devConf.h"
@@ -56,6 +58,7 @@
 #include "linux/ipcore/PdecHandler.h"
 #include "linux/ipcore/Ptme.h"
 #include "linux/ipcore/PtmeConfig.h"
+#include "linux/payload/FreshSupvHandler.h"
 #include "mission/config/configfile.h"
 #include "mission/system/acs/AcsBoardFdir.h"
 #include "mission/system/acs/AcsSubsystem.h"
@@ -64,11 +67,11 @@
 #include "mission/system/acs/acsModeTree.h"
 #include "mission/system/com/SyrlinksFdir.h"
 #include "mission/system/com/comModeTree.h"
+#include "mission/system/payloadModeTree.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/tmtc/tmFilters.h"
 #include "mission/utility/GlobalConfigHandler.h"
 #include "tmtc/pusIds.h"
@@ -100,6 +103,7 @@
 
 #include <sstream>
 
+#include "bsp_q7s/core/defs.h"
 #include "fsfw/datapoollocal/LocalDataPoolManager.h"
 #include "fsfw/tmtcpacket/pus/tm.h"
 #include "fsfw/tmtcservices/CommandingServiceBase.h"
@@ -129,7 +133,12 @@ using gpio::Levels;
 ResetArgs RESET_ARGS_GNSS;
 std::atomic_bool LINK_STATE = CcsdsIpCoreHandler::LINK_DOWN;
 std::atomic_bool PTME_LOCKED = false;
-std::atomic_uint16_t I2C_FATAL_ERRORS = 0;
+std::atomic_uint16_t signals::I2C_FATAL_ERRORS = 0;
+uint8_t core::FW_VERSION_MAJOR = 0;
+uint8_t core::FW_VERSION_MINOR = 0;
+uint8_t core::FW_VERSION_REVISION = 0;
+bool core::FW_VERSION_HAS_SHA = false;
+char core::FW_VERSION_GIT_SHA[4] = {};
 
 void Factory::setStaticFrameworkObjectIds() {
   PusServiceBase::PUS_DISTRIBUTOR = objects::PUS_PACKET_DISTRIBUTOR;
@@ -151,28 +160,23 @@ void Factory::setStaticFrameworkObjectIds() {
 
 void ObjectFactory::setStatics() { Factory::setStaticFrameworkObjectIds(); }
 
-void ObjectFactory::createTmpComponents() {
-  std::vector<std::pair<object_id_t, address_t>> tmpDevIds = {{
-      {objects::TMP1075_HANDLER_TCS_0, addresses::TMP1075_TCS_0},
-      {objects::TMP1075_HANDLER_TCS_1, addresses::TMP1075_TCS_1},
-      {objects::TMP1075_HANDLER_PLPCDU_0, addresses::TMP1075_PLPCDU_0},
-      // damaged
-      // {objects::TMP1075_HANDLER_PLPCDU_1, addresses::TMP1075_PLPCDU_1},
-      {objects::TMP1075_HANDLER_IF_BOARD, addresses::TMP1075_IF_BOARD},
-  }};
+void ObjectFactory::createTmpComponents(
+    std::vector<std::pair<object_id_t, address_t>> tmpDevsToAdd) {
+  const char* tmpI2cDev = q7s::I2C_PS_EIVE;
+  if (core::FW_VERSION_MAJOR == 4) {
+    tmpI2cDev = q7s::I2C_PL_EIVE;
+  } else if (core::FW_VERSION_MAJOR >= 5) {
+    tmpI2cDev = q7s::I2C_Q7_EIVE;
+  }
   std::vector<I2cCookie*> tmpDevCookies;
 
-  for (size_t idx = 0; idx < tmpDevIds.size(); idx++) {
+  for (size_t idx = 0; idx < tmpDevsToAdd.size(); idx++) {
     tmpDevCookies.push_back(
-        new I2cCookie(tmpDevIds[idx].second, TMP1075::MAX_REPLY_LENGTH, q7s::I2C_PS_EIVE));
+        new I2cCookie(tmpDevsToAdd[idx].second, TMP1075::MAX_REPLY_LENGTH, tmpI2cDev));
     auto* tmpDevHandler =
-        new Tmp1075Handler(tmpDevIds[idx].first, objects::I2C_COM_IF, tmpDevCookies[idx]);
-    tmpDevHandler->setCustomFdir(new TmpDevFdir(tmpDevIds[idx].first));
+        new Tmp1075Handler(tmpDevsToAdd[idx].first, objects::I2C_COM_IF, tmpDevCookies[idx]);
+    tmpDevHandler->setCustomFdir(new TmpDevFdir(tmpDevsToAdd[idx].first));
     tmpDevHandler->connectModeTreeParent(satsystem::tcs::SUBSYSTEM);
-    // TODO: Remove this after TCS subsystem was added
-    // These devices are connected to the 3V3 stack and should be powered permanently. Therefore,
-    // we set them to normal mode immediately here.
-    tmpDevHandler->setModeNormal();
   }
 }
 
@@ -244,7 +248,7 @@ ReturnValue_t ObjectFactory::createRadSensorComponent(LinuxLibgpioIF* gpioComIF,
   createRadSensorChipSelect(gpioComIF);
 
   SpiCookie* spiCookieRadSensor =
-      new SpiCookie(addresses::RAD_SENSOR, gpioIds::CS_RAD_SENSOR, RAD_SENSOR::READ_SIZE,
+      new SpiCookie(addresses::RAD_SENSOR, gpioIds::CS_RAD_SENSOR, radSens::READ_SIZE,
                     spi::DEFAULT_MAX_1227_MODE, spi::DEFAULT_MAX_1227_SPEED);
   spiCookieRadSensor->setMutexParams(MutexIF::TimeoutType::WAITING, spi::RAD_SENSOR_CS_TIMEOUT);
   auto radSensor = new RadiationSensorHandler(objects::RAD_SENSOR, objects::SPI_MAIN_COM_IF,
@@ -506,7 +510,7 @@ void ObjectFactory::createAcsBoardComponents(SpiComIF& spiComIF, LinuxLibgpioIF*
   debugGps = true;
 #endif
   RESET_ARGS_GNSS.gpioComIF = gpioComIF;
-  RESET_ARGS_GNSS.waitPeriodMs = 5;
+  RESET_ARGS_GNSS.waitPeriodMs = 10 * 1e3;
   auto gpsCtrl = new GpsHyperionLinuxController(objects::GPS_CONTROLLER, objects::NO_OBJECT,
                                                 enableHkSets, debugGps);
   gpsCtrl->setResetPinTriggerFunction(gps::triggerGpioResetPin, &RESET_ARGS_GNSS);
@@ -607,11 +611,11 @@ void ObjectFactory::createSyrlinksComponents(PowerSwitchIF* pwrSwitcher) {
 #endif
 }
 
-void ObjectFactory::createPayloadComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchIF& pwrSwitch) {
+void ObjectFactory::createPayloadComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchIF& pwrSwitcher) {
   using namespace gpio;
   std::stringstream consumer;
   auto* camSwitcher =
-      new CamSwitcher(objects::CAM_SWITCHER, pwrSwitch, power::PDU2_CH8_PAYLOAD_CAMERA);
+      new CamSwitcher(objects::CAM_SWITCHER, pwrSwitcher, power::PDU2_CH8_PAYLOAD_CAMERA);
   camSwitcher->connectModeTreeParent(satsystem::payload::SUBSYSTEM);
 #if OBSW_ADD_PLOC_MPSOC == 1
   consumer << "0x" << std::hex << objects::PLOC_MPSOC_HANDLER;
@@ -637,15 +641,19 @@ void ObjectFactory::createPayloadComponents(LinuxLibgpioIF* gpioComIF, PowerSwit
   auto supvGpioCookie = new GpioCookie;
   supvGpioCookie->addGpio(gpioIds::ENABLE_SUPV_UART, gpioConfigSupv);
   gpioComIF->addGpios(supvGpioCookie);
-  auto supervisorCookie = new SerialCookie(objects::PLOC_SUPERVISOR_HANDLER,
-                                           q7s::UART_PLOC_SUPERVSIOR_DEV, serial::PLOC_SUPV_BAUD,
-                                           supv::MAX_PACKET_SIZE * 20, UartModes::NON_CANONICAL);
+  const char* plocSupvDev = q7s::UART_PLOC_SUPERVISOR_DEV;
+  if (not std::filesystem::exists(plocSupvDev)) {
+    plocSupvDev = q7s::UART_PLOC_SUPERVISOR_DEV_FALLBACK;
+  }
+  auto supervisorCookie =
+      new SerialCookie(objects::PLOC_SUPERVISOR_HANDLER, plocSupvDev, serial::PLOC_SUPV_BAUD,
+                       supv::MAX_PACKET_SIZE * 20, UartModes::NON_CANONICAL);
   supervisorCookie->setNoFixedSizeReply();
-  auto supvHelper = new PlocSupvUartManager(objects::PLOC_SUPERVISOR_HELPER);
-  auto* supvHandler = new PlocSupervisorHandler(objects::PLOC_SUPERVISOR_HANDLER, supervisorCookie,
-                                                Gpio(gpioIds::ENABLE_SUPV_UART, gpioComIF),
-                                                power::PDU1_CH6_PLOC_12V, *supvHelper);
-  supvHandler->setPowerSwitcher(&pwrSwitch);
+  new PlocSupvUartManager(objects::PLOC_SUPERVISOR_HELPER);
+  DhbConfig dhbConf(objects::PLOC_SUPERVISOR_HANDLER);
+  auto* supvHandler =
+      new FreshSupvHandler(dhbConf, supervisorCookie, Gpio(gpioIds::ENABLE_SUPV_UART, gpioComIF),
+                           pwrSwitcher, power::PDU1_CH6_PLOC_12V);
   supvHandler->connectModeTreeParent(satsystem::payload::SUBSYSTEM);
 #endif /* OBSW_ADD_PLOC_SUPERVISOR == 1 */
   static_cast<void>(consumer);
@@ -731,20 +739,12 @@ ReturnValue_t ObjectFactory::createCcsdsComponents(CcsdsComponentArgs& args) {
   // GPIO definitions of signals connected to the virtual channel interfaces of the PTME IP Core
   GpioCookie* gpioCookiePtmeIp = new GpioCookie;
   GpiodRegularByLineName* gpio = nullptr;
-  gpio = new GpiodRegularByLineName(q7s::gpioNames::PAPB_BUSY_SIGNAL_VC0, "PAPB VC0");
-  gpioCookiePtmeIp->addGpio(gpioIds::VC0_PAPB_BUSY, gpio);
   gpio = new GpiodRegularByLineName(q7s::gpioNames::PAPB_EMPTY_SIGNAL_VC0, "PAPB VC0");
   gpioCookiePtmeIp->addGpio(gpioIds::VC0_PAPB_EMPTY, gpio);
-  gpio = new GpiodRegularByLineName(q7s::gpioNames::PAPB_BUSY_SIGNAL_VC1, "PAPB VC1");
-  gpioCookiePtmeIp->addGpio(gpioIds::VC1_PAPB_BUSY, gpio);
   gpio = new GpiodRegularByLineName(q7s::gpioNames::PAPB_EMPTY_SIGNAL_VC1, "PAPB VC1");
   gpioCookiePtmeIp->addGpio(gpioIds::VC1_PAPB_EMPTY, gpio);
-  gpio = new GpiodRegularByLineName(q7s::gpioNames::PAPB_BUSY_SIGNAL_VC2, "PAPB VC2");
-  gpioCookiePtmeIp->addGpio(gpioIds::VC2_PAPB_BUSY, gpio);
   gpio = new GpiodRegularByLineName(q7s::gpioNames::PAPB_EMPTY_SIGNAL_VC2, "PAPB VC2");
   gpioCookiePtmeIp->addGpio(gpioIds::VC2_PAPB_EMPTY, gpio);
-  gpio = new GpiodRegularByLineName(q7s::gpioNames::PAPB_BUSY_SIGNAL_VC3, "PAPB VC3");
-  gpioCookiePtmeIp->addGpio(gpioIds::VC3_PAPB_BUSY, gpio);
   gpio = new GpiodRegularByLineName(q7s::gpioNames::PAPB_EMPTY_SIGNAL_VC3, "PAPB VC3");
   gpioCookiePtmeIp->addGpio(gpioIds::VC3_PAPB_EMPTY, gpio);
   gpio = new GpiodRegularByLineName(q7s::gpioNames::PTME_RESETN, "PTME RESETN",
@@ -754,18 +754,17 @@ ReturnValue_t ObjectFactory::createCcsdsComponents(CcsdsComponentArgs& args) {
 
   // Creating virtual channel interfaces
   VirtualChannelIF* vc0 =
-      new PapbVcInterface(&args.gpioComIF, gpioIds::VC0_PAPB_BUSY, gpioIds::VC0_PAPB_EMPTY,
-                          q7s::UIO_PTME, q7s::uiomapids::PTME_VC0);
+      new PapbVcInterface(&args.gpioComIF, gpioIds::VC0_PAPB_EMPTY, q7s::UIO_PTME,
+                          q7s::uiomapids::PTME_VC0, config::MAX_SPACEPACKET_TC_SIZE);
   VirtualChannelIF* vc1 =
-      new PapbVcInterface(&args.gpioComIF, gpioIds::VC1_PAPB_BUSY, gpioIds::VC1_PAPB_EMPTY,
-                          q7s::UIO_PTME, q7s::uiomapids::PTME_VC1);
+      new PapbVcInterface(&args.gpioComIF, gpioIds::VC1_PAPB_EMPTY, q7s::UIO_PTME,
+                          q7s::uiomapids::PTME_VC1, config::MAX_SPACEPACKET_TC_SIZE);
   VirtualChannelIF* vc2 =
-      new PapbVcInterface(&args.gpioComIF, gpioIds::VC2_PAPB_BUSY, gpioIds::VC2_PAPB_EMPTY,
-                          q7s::UIO_PTME, q7s::uiomapids::PTME_VC2);
+      new PapbVcInterface(&args.gpioComIF, gpioIds::VC2_PAPB_EMPTY, q7s::UIO_PTME,
+                          q7s::uiomapids::PTME_VC2, config::MAX_SPACEPACKET_TC_SIZE);
   VirtualChannelIF* vc3 =
-      new PapbVcInterface(&args.gpioComIF, gpioIds::VC3_PAPB_BUSY, gpioIds::VC3_PAPB_EMPTY,
-                          q7s::UIO_PTME, q7s::uiomapids::PTME_VC3);
-
+      new PapbVcInterface(&args.gpioComIF, gpioIds::VC3_PAPB_EMPTY, q7s::UIO_PTME,
+                          q7s::uiomapids::PTME_VC3, config::MAX_SPACEPACKET_TC_SIZE);
   // Creating ptme object and adding virtual channel interfaces
   Ptme* ptme = new Ptme(objects::PTME);
   ptme->addVcInterface(ccsds::VC0, vc0);
@@ -785,12 +784,13 @@ ReturnValue_t ObjectFactory::createCcsdsComponents(CcsdsComponentArgs& args) {
       new CcsdsIpCoreHandler(objects::CCSDS_HANDLER, objects::CCSDS_PACKET_DISTRIBUTOR, *ptmeConfig,
                              LINK_STATE, &args.gpioComIF, gpios, PTME_LOCKED);
   // This VC will receive all live TM
-  auto* vcWithQueue =
-      new VirtualChannelWithQueue(objects::PTME_VC0_LIVE_TM, ccsds::VC0, "PTME VC0 LIVE TM", *ptme,
-                                  LINK_STATE, args.tmStore, 500);
-  args.liveDestination = vcWithQueue;
+  auto* vcWithQueue = new VirtualChannel(objects::PTME_VC0_LIVE_TM, ccsds::VC0, "PTME VC0 LIVE TM",
+                                         *ptme, LINK_STATE);
   auto* liveTask = new LiveTmTask(objects::LIVE_TM_TASK, args.pusFunnel, args.cfdpFunnel,
-                                  *vcWithQueue, PTME_LOCKED);
+                                  *vcWithQueue, PTME_LOCKED, config::LIVE_CHANNEL_NORMAL_QUEUE_SIZE,
+                                  config::LIVE_CHANNEL_CFDP_QUEUE_SIZE);
+  args.normalLiveTmDest = liveTask->getNormalLiveQueueId();
+  args.cfdpLiveTmDest = liveTask->getCfdpLiveQueueId();
   liveTask->connectModeTreeParent(satsystem::com::SUBSYSTEM);
 
   // Set up log store.
@@ -839,7 +839,7 @@ ReturnValue_t ObjectFactory::createCcsdsComponents(CcsdsComponentArgs& args) {
   uioNames.registers = q7s::UIO_PDEC_REGISTERS;
   uioNames.irq = q7s::UIO_PDEC_IRQ;
   new PdecHandler(objects::PDEC_HANDLER, objects::CCSDS_HANDLER, &args.gpioComIF,
-                  gpioIds::PDEC_RESET, uioNames);
+                  gpioIds::PDEC_RESET, uioNames, args.pdecCfgMemBaseAddr, args.pdecRamBaseAddr);
   GpioCookie* gpioRS485Chip = new GpioCookie;
   gpio = new GpiodRegularByLineName(q7s::gpioNames::RS485_EN_TX_CLOCK, "RS485 Transceiver",
                                     Direction::OUT, Levels::LOW);
@@ -910,8 +910,6 @@ void ObjectFactory::createPlPcduComponents(LinuxLibgpioIF* gpioComIF, SpiComIF*
       new PayloadPcduHandler(objects::PLPCDU_HANDLER, objects::SPI_MAIN_COM_IF, spiCookie,
                              gpioComIF, SdCardManager::instance(), stackHandler, false);
   spiCookie->setCallbackMode(PayloadPcduHandler::extConvAsTwoCallback, plPcduHandler);
-//  plPcduHandler->enablePeriodicPrintout(true, 5);
-//  static_cast<void>(plPcduHandler);
 #if OBSW_TEST_PL_PCDU == 1
   plPcduHandler->setStartUpImmediately();
 #endif
@@ -936,7 +934,7 @@ void ObjectFactory::createTestComponents(LinuxLibgpioIF* gpioComIF) {
 #endif
 }
 
-void ObjectFactory::createStrComponents(PowerSwitchIF* pwrSwitcher) {
+void ObjectFactory::createStrComponents(PowerSwitchIF* pwrSwitcher, SdCardManager& sdcMan) {
   auto* strAssy = new StrAssembly(objects::STR_ASSY);
   strAssy->connectModeTreeParent(satsystem::acs::ACS_SUBSYSTEM);
   auto* starTrackerCookie =
@@ -945,34 +943,27 @@ void ObjectFactory::createStrComponents(PowerSwitchIF* pwrSwitcher) {
   starTrackerCookie->setNoFixedSizeReply();
   StrComHandler* strComIF = new StrComHandler(objects::STR_COM_IF);
 
-  const char* paramJsonFile = nullptr;
-#ifdef EGSE
-  paramJsonFile = "/home/pi/arcsec/json/flight-config.json";
-#else
-#if OBSW_STAR_TRACKER_GROUND_CONFIG == 1
-  paramJsonFile = "/mnt/sd0/startracker/ground-config.json";
-#else
-  paramJsonFile = "/mnt/sd0/startracker/flight-config.json";
-#endif
-#endif
+  const char* paramJsonFile = "/mnt/sd0/startracker/flight-config.json";
   if (paramJsonFile == nullptr) {
     sif::error << "No valid Star Tracker parameter JSON file" << std::endl;
   }
   auto strFdir = new StrFdir(objects::STAR_TRACKER);
+  auto cfgGetter = new StrConfigPathGetter(sdcMan);
   auto starTracker =
       new StarTrackerHandler(objects::STAR_TRACKER, objects::STR_COM_IF, starTrackerCookie,
-                             paramJsonFile, strComIF, power::PDU1_CH2_STAR_TRACKER_5V);
+                             strComIF, power::PDU1_CH2_STAR_TRACKER_5V, *cfgGetter, sdcMan);
   starTracker->setPowerSwitcher(pwrSwitcher);
   starTracker->connectModeTreeParent(*strAssy);
   starTracker->setCustomFdir(strFdir);
 }
 
-void ObjectFactory::createImtqComponents(PowerSwitchIF* pwrSwitcher, bool enableHkSets) {
+void ObjectFactory::createImtqComponents(PowerSwitchIF* pwrSwitcher, bool enableHkSets,
+                                         const char* i2cDev) {
   auto* imtqAssy = new ImtqAssembly(objects::IMTQ_ASSY);
   imtqAssy->connectModeTreeParent(satsystem::acs::ACS_SUBSYSTEM);
 
-  new ImtqPollingTask(objects::IMTQ_POLLING, I2C_FATAL_ERRORS);
-  I2cCookie* imtqI2cCookie = new I2cCookie(addresses::IMTQ, imtq::MAX_REPLY_SIZE, q7s::I2C_PL_EIVE);
+  new ImtqPollingTask(objects::IMTQ_POLLING, signals::I2C_FATAL_ERRORS);
+  I2cCookie* imtqI2cCookie = new I2cCookie(addresses::IMTQ, imtq::MAX_REPLY_SIZE, i2cDev);
   auto imtqHandler = new ImtqHandler(objects::IMTQ_HANDLER, objects::IMTQ_POLLING, imtqI2cCookie,
                                      power::Switches::PDU1_CH3_MGT_5V, enableHkSets);
   imtqHandler->enableThermalModule(ThermalStateCfg());
@@ -988,8 +979,8 @@ void ObjectFactory::createImtqComponents(PowerSwitchIF* pwrSwitcher, bool enable
 #endif
 }
 
-void ObjectFactory::createBpxBatteryComponent(bool enableHkSets) {
-  I2cCookie* bpxI2cCookie = new I2cCookie(addresses::BPX_BATTERY, 100, q7s::I2C_PL_EIVE);
+void ObjectFactory::createBpxBatteryComponent(bool enableHkSets, const char* i2cDev) {
+  I2cCookie* bpxI2cCookie = new I2cCookie(addresses::BPX_BATTERY, 100, i2cDev);
   BpxBatteryHandler* bpxHandler = new BpxBatteryHandler(
       objects::BPX_BATT_HANDLER, objects::I2C_COM_IF, bpxI2cCookie, enableHkSets);
   bpxHandler->setStartUpImmediately();
@@ -1045,3 +1036,52 @@ void ObjectFactory::createPlI2cResetGpio(LinuxLibgpioIF* gpioIF) {
     gpioIF->pullHigh(gpioIds::PL_I2C_ARESETN);
   }
 }
+
+ReturnValue_t ObjectFactory::readFirmwareVersion() {
+  uint32_t* mappedSysRomAddr = nullptr;
+  // The SYS ROM FPGA block is only available in those versions.
+  if (not(common::OBSW_VERSION_MAJOR >= 6) or (common::OBSW_VERSION_MAJOR == 4)) {
+    return returnvalue::OK;
+  }
+  // This has to come before the version announce because it might be required for retrieving
+  // the firmware version.
+  UioMapper sysRomMapper(q7s::UIO_SYS_ROM);
+  ReturnValue_t result =
+      sysRomMapper.getMappedAdress(&mappedSysRomAddr, UioMapper::Permissions::READ_ONLY);
+  if (result != returnvalue::OK) {
+    sif::error << "Getting mapped SYS ROM UIO address failed" << std::endl;
+    return returnvalue::FAILED;
+  }
+  if (mappedSysRomAddr != nullptr) {
+    uint32_t firstEntry = *(reinterpret_cast<uint32_t*>(mappedSysRomAddr));
+    uint32_t secondEntry = *(reinterpret_cast<uint32_t*>(mappedSysRomAddr) + 1);
+    core::FW_VERSION_MAJOR = (firstEntry >> 24) & 0xff;
+    core::FW_VERSION_MINOR = (firstEntry >> 16) & 0xff;
+    core::FW_VERSION_REVISION = (firstEntry >> 8) & 0xff;
+    bool hasGitSha = (firstEntry & 0x0b1);
+    if (hasGitSha) {
+      std::memcpy(core::FW_VERSION_GIT_SHA, &secondEntry, 4);
+    }
+  }
+  return returnvalue::OK;
+}
+
+ReturnValue_t ObjectFactory::createCcsdsIpComponentsWrapper(CcsdsComponentArgs& ccsdsArgs) {
+  ccsdsArgs.pdecCfgMemBaseAddr = config::pdec::PDEC_CONFIG_BASE_ADDR;
+  ccsdsArgs.pdecRamBaseAddr = config::pdec::PDEC_RAM_ADDR;
+  if (core::FW_VERSION_MAJOR < 6) {
+    ccsdsArgs.pdecCfgMemBaseAddr = config::pdec::PDEC_CONFIG_BASE_ADDR_LEGACY;
+    ccsdsArgs.pdecRamBaseAddr = config::pdec::PDEC_RAM_ADDR_LEGACY;
+  }
+  ReturnValue_t result = createCcsdsComponents(ccsdsArgs);
+#if OBSW_TM_TO_PTME == 1
+  if (ccsdsArgs.normalLiveTmDest != MessageQueueIF::NO_QUEUE) {
+    ccsdsArgs.pusFunnel.addLiveDestinationByRawId("VC0 NORMAL LIVE TM", ccsdsArgs.normalLiveTmDest,
+                                                  0);
+  }
+  if (ccsdsArgs.cfdpLiveTmDest != MessageQueueIF::NO_QUEUE) {
+    ccsdsArgs.cfdpFunnel.addLiveDestinationByRawId("VC0 CFDP LIVE TM", ccsdsArgs.cfdpLiveTmDest, 0);
+  }
+#endif
+  return result;
+}

bsp_q7s/objectFactory.h

@@ -15,6 +15,8 @@
 #include <atomic>
 #include <string>
 
+#include "bsp_q7s/fs/SdCardManager.h"
+
 class LinuxLibgpioIF;
 class SerialComIF;
 class SpiComIF;
@@ -31,14 +33,17 @@ namespace ObjectFactory {
 struct CcsdsComponentArgs {
   CcsdsComponentArgs(LinuxLibgpioIF& gpioIF, StorageManagerIF& ipcStore, StorageManagerIF& tmStore,
                      PersistentTmStores& stores, PusTmFunnel& pusFunnel, CfdpTmFunnel& cfdpFunnel,
-                     CcsdsIpCoreHandler** ipCoreHandler)
+                     CcsdsIpCoreHandler** ipCoreHandler, uint32_t pdecCfgMemBaseAddr,
+                     uint32_t pdecRamBaseAddr)
       : gpioComIF(gpioIF),
         ipcStore(ipcStore),
         tmStore(tmStore),
         stores(stores),
         pusFunnel(pusFunnel),
         cfdpFunnel(cfdpFunnel),
-        ipCoreHandler(ipCoreHandler) {}
+        ipCoreHandler(ipCoreHandler),
+        pdecCfgMemBaseAddr(pdecCfgMemBaseAddr),
+        pdecRamBaseAddr(pdecRamBaseAddr) {}
   LinuxLibgpioIF& gpioComIF;
   StorageManagerIF& ipcStore;
   StorageManagerIF& tmStore;
@@ -46,7 +51,10 @@ struct CcsdsComponentArgs {
   PusTmFunnel& pusFunnel;
   CfdpTmFunnel& cfdpFunnel;
   CcsdsIpCoreHandler** ipCoreHandler;
-  AcceptsTelemetryIF* liveDestination = nullptr;
+  uint32_t pdecCfgMemBaseAddr;
+  uint32_t pdecRamBaseAddr;
+  MessageQueueId_t normalLiveTmDest = MessageQueueIF::NO_QUEUE;
+  MessageQueueId_t cfdpLiveTmDest = MessageQueueIF::NO_QUEUE;
 };
 
 void setStatics();
@@ -58,7 +66,7 @@ void createPcduComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchIF** pwrSwitcher
                           bool enableHkSets);
 void createPlPcduComponents(LinuxLibgpioIF* gpioComIF, SpiComIF* spiComIF,
                             PowerSwitchIF* pwrSwitcher, Stack5VHandler& stackHandler);
-void createTmpComponents();
+void createTmpComponents(std::vector<std::pair<object_id_t, address_t>> tmpDevsToAdd);
 void createRadSensorChipSelect(LinuxLibgpioIF* gpioIF);
 ReturnValue_t createRadSensorComponent(LinuxLibgpioIF* gpioComIF, Stack5VHandler& handler);
 void createAcsBoardGpios(GpioCookie& cookie);
@@ -67,14 +75,16 @@ void createAcsBoardComponents(SpiComIF& spiComIF, LinuxLibgpioIF* gpioComIF, Ser
                               adis1650x::Type adisType);
 void createHeaterComponents(GpioIF* gpioIF, PowerSwitchIF* pwrSwitcher, HealthTableIF* healthTable,
                             HeaterHandler*& heaterHandler);
-void createImtqComponents(PowerSwitchIF* pwrSwitcher, bool enableHkSets);
-void createBpxBatteryComponent(bool enableHkSets);
-void createStrComponents(PowerSwitchIF* pwrSwitcher);
+void createImtqComponents(PowerSwitchIF* pwrSwitcher, bool enableHkSets, const char* i2cDev);
+void createBpxBatteryComponent(bool enableHkSets, const char* i2cDev);
+void createStrComponents(PowerSwitchIF* pwrSwitcher, SdCardManager& sdcMan);
 void createSolarArrayDeploymentComponents(PowerSwitchIF& pwrSwitcher, GpioIF& gpioIF);
 void createSyrlinksComponents(PowerSwitchIF* pwrSwitcher);
 void createPayloadComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchIF& pwrSwitcher);
 void createReactionWheelComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchIF* pwrSwitcher);
+ReturnValue_t createCcsdsIpComponentsWrapper(CcsdsComponentArgs& args);
 ReturnValue_t createCcsdsComponents(CcsdsComponentArgs& args);
+ReturnValue_t readFirmwareVersion();
 void createMiscComponents();
 
 void createTestComponents(LinuxLibgpioIF* gpioComIF);

bsp_q7s/obsw.cpp

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

bsp_q7s/scheduling.cpp

@@ -9,7 +9,6 @@
 #include <vector>
 
 #include "OBSWConfig.h"
-#include "bsp_q7s/core/ObjectFactory.h"
 #include "fsfw/objectmanager/ObjectManager.h"
 #include "fsfw/objectmanager/ObjectManagerIF.h"
 #include "fsfw/platform.h"
@@ -21,6 +20,8 @@
 #include "mission/pollingSeqTables.h"
 #include "mission/scheduling.h"
 #include "mission/utility/InitMission.h"
+#include "objectFactory.h"
+#include "q7sConfig.h"
 
 /* This is configured for linux without CR */
 #ifdef PLATFORM_UNIX
@@ -81,6 +82,16 @@ void scheduling::initTasks() {
   }
 #endif
 
+  // Medium priority, higher than something like payload, but not the highest priority to also
+  // detect tasks which choke other tasks.
+  PeriodicTaskIF* xiphosWdtTask =
+      factory->createPeriodicTask("XIPHOS_WDT", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.4,
+                                  missedDeadlineFunc, &RR_SCHEDULING);
+  result = xiphosWdtTask->addComponent(objects::XIPHOS_WDT);
+  if (result != returnvalue::OK) {
+    scheduling::printAddObjectError("XIPHOS_WDT", objects::XIPHOS_WDT);
+  }
+
   PeriodicTaskIF* coreCtrlTask = factory->createPeriodicTask(
       "CORE_CTRL", 55, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.4, missedDeadlineFunc, &RR_SCHEDULING);
   result = coreCtrlTask->addComponent(objects::CORE_CONTROLLER);
@@ -156,6 +167,10 @@ void scheduling::initTasks() {
   if (result != returnvalue::OK) {
     scheduling::printAddObjectError("PL_SUBSYSTEM", objects::PL_SUBSYSTEM);
   }
+  result = genericSysTask->addComponent(objects::EPS_SUBSYSTEM);
+  if (result != returnvalue::OK) {
+    scheduling::printAddObjectError("EPS_SUBSYSTEM", objects::EPS_SUBSYSTEM);
+  }
   result = genericSysTask->addComponent(objects::INTERNAL_ERROR_REPORTER);
   if (result != returnvalue::OK) {
     scheduling::printAddObjectError("ERROR_REPORTER", objects::INTERNAL_ERROR_REPORTER);
@@ -324,6 +339,10 @@ void scheduling::initTasks() {
   if (result != returnvalue::OK) {
     scheduling::printAddObjectError("HEATER_HANDLER", objects::HEATER_HANDLER);
   }
+  result = tcsSystemTask->addComponent(objects::HEATER_HANDLER);
+  if (result != returnvalue::OK) {
+    scheduling::printAddObjectError("HEATER_HANDLER", objects::HEATER_HANDLER);
+  }
 
 #if OBSW_ADD_SYRLINKS == 1
   PeriodicTaskIF* syrlinksCom = factory->createPeriodicTask(
@@ -364,11 +383,9 @@ void scheduling::initTasks() {
   }
 #endif /* OBSW_ADD_PLOC_SUPERVISOR */
 
-  PeriodicTaskIF* plTask = factory->createPeriodicTask(
-      "PL_TASK", 25, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.5, missedDeadlineFunc, &RR_SCHEDULING);
-  plTask->addComponent(objects::CAM_SWITCHER);
-  scheduling::addMpsocSupvHandlers(plTask);
-  scheduling::scheduleScexDev(plTask);
+  FixedTimeslotTaskIF* plTask = factory->createFixedTimeslotTask(
+      "PL_TASK", 25, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.5, missedDeadlineFunc);
+  pst::pstPayload(plTask);
 
 #if OBSW_ADD_SCEX_DEVICE == 1
   PeriodicTaskIF* scexReaderTask;
@@ -405,6 +422,7 @@ void scheduling::initTasks() {
   };
 
   sif::info << "Starting tasks.." << std::endl;
+  xiphosWdtTask->startTask();
   tmTcDistributor->startTask();
 
 #if OBSW_ADD_TCPIP_SERVERS == 1
@@ -527,7 +545,15 @@ void scheduling::createPstTasks(TaskFactory& factory, TaskDeadlineMissedFunction
   FixedTimeslotTaskIF* i2cPst =
       factory.createFixedTimeslotTask("I2C_PS_PST", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 0.6,
                                       missedDeadlineFunc, &RR_SCHEDULING);
-  result = pst::pstI2cProcessingSystem(i2cPst);
+  pst::TmpSchedConfig tmpSchedConf;
+#if OBSW_Q7S_EM == 1
+  tmpSchedConf.scheduleTmpDev0 = true;
+  tmpSchedConf.scheduleTmpDev1 = true;
+  tmpSchedConf.schedulePlPcduDev0 = true;
+  tmpSchedConf.schedulePlPcduDev1 = true;
+  tmpSchedConf.scheduleIfBoardDev = true;
+#endif
+  result = pst::pstI2c(tmpSchedConf, i2cPst);
   if (result != returnvalue::OK) {
     if (result == FixedTimeslotTaskIF::SLOT_LIST_EMPTY) {
       sif::warning << "scheduling::initTasks: I2C PST is empty" << std::endl;

bsp_q7s/xadc/Xadc.cpp

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

cmake/scripts/q7s/q7s-make-debug.sh

@@ -24,6 +24,8 @@ if [ ! -z "${EIVE_Q7S_EM}" ]; then
     build_defs="EIVE_Q7S_EM=ON"
 fi
 
+build_defs="${build_defs} CMAKE_EXPORT_COMPILE_COMMANDS=ON" 
+
 os_fsfw="linux"
 tgt_bsp="arm/q7s"
 build_dir="cmake-build-debug-q7s"

cmake/scripts/q7s/q7s-make-release.sh

@@ -24,6 +24,8 @@ if [ ! -z "${EIVE_Q7S_EM}" ]; then
     build_defs="EIVE_Q7S_EM=ON"
 fi
 
+build_defs="${build_defs} CMAKE_EXPORT_COMPILE_COMMANDS=ON" 
+
 os_fsfw="linux"
 tgt_bsp="arm/q7s"
 build_dir="cmake-build-release-q7s"

common/config/devices/addresses.h

@@ -54,6 +54,9 @@ enum I2cAddress : address_t {
 };
 
 enum spiAddresses : address_t {
+  RTD_IC_0,
+  RTD_IC_1,
+  RTD_IC_2,
   RTD_IC_3,
   RTD_IC_4,
   RTD_IC_5,
@@ -67,9 +70,6 @@ enum spiAddresses : address_t {
   RTD_IC_13,
   RTD_IC_14,
   RTD_IC_15,
-  RTD_IC_16,
-  RTD_IC_17,
-  RTD_IC_18,
   RW1,
   RW2,
   RW3,

common/config/devices/gpioIds.h

@@ -37,6 +37,9 @@ enum gpioId_t {
   TEST_ID_0,
   TEST_ID_1,
 
+  RTD_IC_0,
+  RTD_IC_1,
+  RTD_IC_2,
   RTD_IC_3,
   RTD_IC_4,
   RTD_IC_5,
@@ -50,9 +53,6 @@ enum gpioId_t {
   RTD_IC_13,
   RTD_IC_14,
   RTD_IC_15,
-  RTD_IC_16,
-  RTD_IC_17,
-  RTD_IC_18,
 
   CS_SUS_0,
   CS_SUS_1,
@@ -96,13 +96,9 @@ enum gpioId_t {
 
   SPI_MUX,
   VC0_PAPB_EMPTY,
-  VC0_PAPB_BUSY,
   VC1_PAPB_EMPTY,
-  VC1_PAPB_BUSY,
   VC2_PAPB_EMPTY,
-  VC2_PAPB_BUSY,
   VC3_PAPB_EMPTY,
-  VC3_PAPB_BUSY,
   PTME_RESETN,
 
   PDEC_RESET,

common/config/eive/definitions.h

@@ -11,6 +11,8 @@ static constexpr char SD_1_MOUNT_POINT[] = "/mnt/sd1";
 static constexpr char OBSW_UPDATE_ARCHIVE_FILE_NAME[] = "eive-sw-update.tar.xz";
 static constexpr char STRIPPED_OBSW_BINARY_FILE_NAME[] = "eive-obsw-stripped";
 static constexpr char OBSW_VERSION_FILE_NAME[] = "obsw_version.txt";
+static constexpr char PUS_SEQUENCE_COUNT_FILE[] = "pus-sequence-count.txt";
+static constexpr char CFDP_SEQUENCE_COUNT_FILE[] = "cfdp-sequence-count.txt";
 
 static constexpr char OBSW_PATH[] = "/usr/bin/eive-obsw";
 static constexpr char OBSW_VERSION_FILE_PATH[] = "/usr/share/eive-obsw/obsw_version.txt";
@@ -18,6 +20,9 @@ static constexpr char OBSW_VERSION_FILE_PATH[] = "/usr/share/eive-obsw/obsw_vers
 // ISO8601 timestamp.
 static constexpr char FILE_DATE_FORMAT[] = "%FT%H%M%SZ";
 
+// Leap Seconds as of 2024-03-04
+static constexpr uint16_t LEAP_SECONDS = 37;
+
 static constexpr uint16_t EIVE_PUS_APID = 0x65;
 static constexpr uint16_t EIVE_CFDP_APID = 0x66;
 static constexpr uint16_t EIVE_LOCAL_CFDP_ENTITY_ID = EIVE_CFDP_APID;
@@ -33,6 +38,8 @@ static constexpr uint32_t STR_IMG_HELPER_QUEUE_SIZE = 50;
 
 static constexpr uint8_t LIVE_TM = 0;
 
+static constexpr size_t MAX_SPACEPACKET_TC_SIZE = 2048;
+
 /* Limits for filename and path checks */
 static constexpr uint32_t MAX_PATH_SIZE = 200;
 static constexpr uint32_t MAX_FILENAME_SIZE = 100;
@@ -46,6 +53,8 @@ static constexpr uint32_t LEGACY_SA_DEPL_CHANNEL_ALTERNATION_INTERVAL_SECS = 5;
 // Maximum allowed burn time allowed by the software.
 static constexpr uint32_t SA_DEPL_MAX_BURN_TIME = 180;
 
+static constexpr size_t CFDP_MAX_FILE_SEGMENT_LEN = 900;
+
 static constexpr uint32_t CCSDS_HANDLER_QUEUE_SIZE = 50;
 static constexpr uint8_t NUMBER_OF_VIRTUAL_CHANNELS = 4;
 static constexpr uint32_t VC0_LIVE_TM_QUEUE_SIZE = 300;
@@ -56,14 +65,25 @@ static constexpr uint32_t NOK_STORE_QUEUE_SIZE = 350;
 static constexpr uint32_t HK_STORE_QUEUE_SIZE = 300;
 static constexpr uint32_t CFDP_STORE_QUEUE_SIZE = 300;
 
+static constexpr uint32_t LIVE_CHANNEL_NORMAL_QUEUE_SIZE = 250;
+static constexpr uint32_t LIVE_CHANNEL_CFDP_QUEUE_SIZE = 350;
+
+static constexpr uint32_t CFDP_MAX_FSM_CALL_COUNT_SRC_HANDLER = 10;
+static constexpr uint32_t CFDP_MAX_FSM_CALL_COUNT_DEST_HANDLER = 300;
+static constexpr uint32_t CFDP_SHORT_DELAY_MS = 40;
+static constexpr uint32_t CFDP_REGULAR_DELAY_MS = 200;
+
 static constexpr uint32_t MAX_PUS_FUNNEL_QUEUE_DEPTH = 100;
-static constexpr uint32_t MAX_CFDP_FUNNEL_QUEUE_DEPTH = 80;
+static constexpr uint32_t MAX_CFDP_FUNNEL_QUEUE_DEPTH = LIVE_CHANNEL_CFDP_QUEUE_SIZE;
 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;
+static constexpr uint32_t UDP_MAX_STORED_CMDS = 200;
+static constexpr uint32_t UDP_MSG_QUEUE_DEPTH = UDP_MAX_STORED_CMDS;
+static constexpr uint32_t TCP_MAX_STORED_CMDS = 350;
+static constexpr uint32_t TCP_MSG_QUEUE_DEPTH = TCP_MAX_STORED_CMDS;
+static constexpr uint32_t TCP_MAX_NUMBER_TMS_SENT_PER_CYCLE = TCP_MSG_QUEUE_DEPTH;
 
 namespace spiSched {
 
@@ -77,6 +97,7 @@ static constexpr uint32_t SCHED_BLOCK_RTD = 150;
 static constexpr uint32_t SCHED_BLOCK_7_RW_READ_MS = 300;
 static constexpr uint32_t SCHED_BLOCK_8_PLPCDU_MS = 320;
 static constexpr uint32_t SCHED_BLOCK_9_RAD_SENS_MS = 340;
+static constexpr uint32_t SCHED_BLOCK_10_PWR_CTRL_MS = 350;
 
 // 15 ms for FM
 static constexpr float SCHED_BLOCK_1_PERIOD = static_cast<float>(SCHED_BLOCK_1_SUS_READ_MS) / 400.0;
@@ -92,9 +113,23 @@ static constexpr float SCHED_BLOCK_RTD_PERIOD = static_cast<float>(SCHED_BLOCK_R
 static constexpr float SCHED_BLOCK_7_PERIOD = static_cast<float>(SCHED_BLOCK_7_RW_READ_MS) / 400.0;
 static constexpr float SCHED_BLOCK_8_PERIOD = static_cast<float>(SCHED_BLOCK_8_PLPCDU_MS) / 400.0;
 static constexpr float SCHED_BLOCK_9_PERIOD = static_cast<float>(SCHED_BLOCK_9_RAD_SENS_MS) / 400.0;
+static constexpr float SCHED_BLOCK_10_PERIOD =
+    static_cast<float>(SCHED_BLOCK_10_PWR_CTRL_MS) / 400.0;
 
 }  // namespace spiSched
 
+namespace pdec {
+
+// Pre FW v6.0.0
+static constexpr uint32_t PDEC_CONFIG_BASE_ADDR_LEGACY = 0x24000000;
+static constexpr uint32_t PDEC_RAM_ADDR_LEGACY = 0x26000000;
+
+// Post FW v6.0.0
+static constexpr uint32_t PDEC_CONFIG_BASE_ADDR = 0x4000000;
+static constexpr uint32_t PDEC_RAM_ADDR = 0x7000000;
+
+}  // namespace pdec
+
 }  // namespace config
 
 #endif /* COMMON_CONFIG_DEFINITIONS_H_ */

common/config/eive/eventSubsystemIds.h

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

common/config/eive/objects.h

@@ -26,7 +26,9 @@ enum commonObjects : uint32_t {
   THERMAL_CONTROLLER = 0x43400001,
   ACS_CONTROLLER = 0x43000002,
   CORE_CONTROLLER = 0x43000003,
+  POWER_CONTROLLER = 0x43000004,
   GLOBAL_JSON_CFG = 0x43000006,
+  XIPHOS_WDT = 0x43000007,
 
   /* 0x44 ('D') for device handlers */
   MGM_0_LIS3_HANDLER = 0x44120006,
@@ -157,12 +159,14 @@ enum commonObjects : uint32_t {
   PL_SUBSYSTEM = 0x73010002,
   TCS_SUBSYSTEM = 0x73010003,
   COM_SUBSYSTEM = 0x73010004,
+  EPS_SUBSYSTEM = 0x73010005,
 
   TM_FUNNEL = 0x73000100,
   PUS_TM_FUNNEL = 0x73000101,
   CFDP_TM_FUNNEL = 0x73000102,
   CFDP_HANDLER = 0x73000205,
   CFDP_DISTRIBUTOR = 0x73000206,
+  CFDP_FAULT_HANDLER = 0x73000207,
   MISC_TM_STORE = 0x73020001,
   OK_TM_STORE = 0x73020002,
   NOT_OK_TM_STORE = 0x73020003,

common/config/eive/resultClassIds.h

@@ -41,6 +41,7 @@ enum commonClassIds : uint8_t {
   LOCAL_PARAM_HANDLER,      // LPH
   PERSISTENT_TM_STORE,      // PTM
   TM_SINK,                  // TMS
+  VIRTUAL_CHANNEL,          // VCS
   COMMON_CLASS_ID_END       // [EXPORT] : [END]
 };
 }

dummies/CMakeLists.txt

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

dummies/CoreControllerDummy.cpp

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

dummies/GpsCtrlDummy.h

@@ -2,7 +2,7 @@
 #define DUMMIES_GPSCTRLDUMMY_H_
 
 #include <fsfw/controller/ExtendedControllerBase.h>
-#include <mission/acs/archive/GPSDefinitions.h>
+#include <linux/acs/GPSDefinitions.h>
 
 class GpsCtrlDummy : public ExtendedControllerBase {
  public:

dummies/GpsDhbDummy.cpp

@@ -1,5 +1,5 @@
 #include <dummies/GpsDhbDummy.h>
-#include <mission/acs/archive/GPSDefinitions.h>
+#include <linux/acs/GPSDefinitions.h>
 
 GpsDhbDummy::GpsDhbDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
     : DeviceHandlerBase(objectId, comif, comCookie) {}

dummies/Max31865Dummy.cpp

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

dummies/PlPcduDummy.cpp

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

dummies/PlPcduDummy.h

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

dummies/PlocMpsocDummy.cpp

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

dummies/PlocMpsocDummy.h

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

dummies/PlocSupervisorDummy.cpp

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

dummies/PlocSupervisorDummy.h

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

dummies/RadSensorDummy.cpp

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

dummies/RadSensorDummy.h

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

dummies/RwDummy.cpp

@@ -93,3 +93,21 @@ ReturnValue_t RwDummy::initializeLocalDataPool(localpool::DataPool &localDataPoo
       subdp::RegularHkPeriodicParams(lastResetStatusSet.getSid(), false, 30.0));
   return returnvalue::OK;
 }
+
+LocalPoolDataSetBase *RwDummy::getDataSetHandle(sid_t sid) {
+  switch (sid.ownerSetId) {
+    case (rws::SetIds::STATUS_SET_ID): {
+      return &statusSet;
+    }
+    case (rws::SetIds::LAST_RESET_ID): {
+      return &lastResetStatusSet;
+    }
+    case (rws::SetIds::SPEED_CMD_SET): {
+      return &rwSpeedActuationSet;
+    }
+    case (rws::SetIds::TM_SET_ID): {
+      return &tmDataset;
+    }
+  }
+  return nullptr;
+}

dummies/RwDummy.h

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

dummies/SusDummy.cpp

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

dummies/TemperatureSensorInserter.cpp

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

dummies/TemperatureSensorInserter.h

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

dummies/Tmp1075Dummy.cpp

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

dummies/Tmp1075Dummy.h

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

dummies/helperFactory.cpp

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

dummies/helperFactory.h

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

generators/bsp_hosted_events.csv

@@ -75,9 +75,12 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 7902;0x1ede;BIT_LOCK;INFO;A Bit Lock signal. Was detected. P1: raw BLO state, P2: 0;fsfw/src/fsfw/datalinklayer/DataLinkLayer.h
 7903;0x1edf;BIT_LOCK_LOST;INFO;A previously found Bit Lock signal was lost. P1: raw BLO state, P2: 0;fsfw/src/fsfw/datalinklayer/DataLinkLayer.h
 7905;0x1ee1;FRAME_PROCESSING_FAILED;LOW;The CCSDS Board could not interpret a TC;fsfw/src/fsfw/datalinklayer/DataLinkLayer.h
-8900;0x22c4;CLOCK_SET;INFO;No description;fsfw/src/fsfw/pus/Service9TimeManagement.h
-8901;0x22c5;CLOCK_DUMP;INFO;No description;fsfw/src/fsfw/pus/Service9TimeManagement.h
-8902;0x22c6;CLOCK_SET_FAILURE;LOW;No description;fsfw/src/fsfw/pus/Service9TimeManagement.h
+8900;0x22c4;CLOCK_SET;INFO;Clock has been set. P1: old timeval seconds. P2: new timeval seconds.;fsfw/src/fsfw/pus/Service9TimeManagement.h
+8901;0x22c5;CLOCK_DUMP_LEGACY;INFO;Clock dump event. P1: timeval seconds P2: timeval milliseconds.;fsfw/src/fsfw/pus/Service9TimeManagement.h
+8902;0x22c6;CLOCK_SET_FAILURE;LOW;Clock could not be set. P1: Returncode.;fsfw/src/fsfw/pus/Service9TimeManagement.h
+8903;0x22c7;CLOCK_DUMP;INFO;Clock dump event. P1: timeval seconds P2: timeval microseconds.;fsfw/src/fsfw/pus/Service9TimeManagement.h
+8904;0x22c8;CLOCK_DUMP_BEFORE_SETTING_TIME;INFO;No description;fsfw/src/fsfw/pus/Service9TimeManagement.h
+8905;0x22c9;CLOCK_DUMP_AFTER_SETTING_TIME;INFO;No description;fsfw/src/fsfw/pus/Service9TimeManagement.h
 9100;0x238c;TC_DELETION_FAILED;MEDIUM;Deletion of a TC from the map failed. P1: First 32 bit of request ID, P2. Last 32 bit of Request ID;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
 9700;0x25e4;TEST;INFO;No description;fsfw/src/fsfw/pus/Service17Test.h
 10600;0x2968;CHANGE_OF_SETUP_PARAMETER;LOW;No description;fsfw/src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.h
@@ -86,18 +89,28 @@ 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
+10805;0x2a35;HANDLING_CFDP_REQUEST_FAILED;LOW;CFDP request handling failed. P2: Returncode.;fsfw/src/fsfw/cfdp/handler/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
+11201;0x2bc1;RATE_RECOVERY;MEDIUM;The system has recovered from a 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
+11206;0x2bc6;PTG_CTRL_NO_ATTITUDE_INFORMATION;HIGH;For a prolonged time, no attitude information was available for the Pointing Controller. Falling back to Safe Mode.;mission/acs/defs.h
 11207;0x2bc7;SAFE_MODE_CONTROLLER_FAILURE;HIGH;The ACS safe mode controller was not able to compute a solution and has failed. P1: Missing information about magnetic field, P2: Missing information about rotational rate;mission/acs/defs.h
+11208;0x2bc8;TLE_TOO_OLD;INFO;The TLE for the SGP4 Propagator has become too old.;mission/acs/defs.h
+11209;0x2bc9;TLE_FILE_READ_FAILED;LOW;The TLE could not be read from the filesystem.;mission/acs/defs.h
+11210;0x2bca;PTG_RATE_VIOLATION;MEDIUM;The limits for the rotation in pointing mode were violated.;mission/acs/defs.h
+11211;0x2bcb;DETUMBLE_TRANSITION_FAILED;HIGH;The detumble transition has failed. //! P1: Last detumble state before failure.;mission/acs/defs.h
 11300;0x2c24;SWITCH_CMD_SENT;INFO;Indicates that a FSFW object requested setting a switch P1: 1 if on was requested, 0 for off | P2: Switch Index;mission/power/defs.h
 11301;0x2c25;SWITCH_HAS_CHANGED;INFO;Indicated that a switch state has changed P1: New switch state, 1 for on, 0 for off | P2: Switch Index;mission/power/defs.h
 11302;0x2c26;SWITCHING_Q7S_DENIED;MEDIUM;No description;mission/power/defs.h
 11303;0x2c27;FDIR_REACTION_IGNORED;MEDIUM;No description;mission/power/defs.h
+11304;0x2c28;DATASET_READ_FAILED;INFO;The dataset read for the inputs of the Power Controller has failed.;mission/power/defs.h
+11305;0x2c29;VOLTAGE_OUT_OF_BOUNDS;HIGH;No description;mission/power/defs.h
+11306;0x2c2a;TIMEDELTA_OUT_OF_BOUNDS;LOW;Time difference for Coulomb Counter was too large. P1: time in s * 10;mission/power/defs.h
+11307;0x2c2b;POWER_LEVEL_LOW;HIGH;The State of Charge is below the limit for payload use. Setting Payload to faulty.;mission/power/defs.h
+11308;0x2c2c;POWER_LEVEL_CRITICAL;HIGH;The State of Charge is below the limit for higher modes. Setting Reaction Wheels to faulty.;mission/power/defs.h
 11400;0x2c88;GPIO_PULL_HIGH_FAILED;LOW;No description;mission/tcs/HeaterHandler.h
 11401;0x2c89;GPIO_PULL_LOW_FAILED;LOW;No description;mission/tcs/HeaterHandler.h
 11402;0x2c8a;HEATER_WENT_ON;INFO;No description;mission/tcs/HeaterHandler.h
@@ -121,6 +134,8 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 11604;0x2d54;MPSOC_HANDLER_CRC_FAILURE;LOW;PLOC reply has invalid crc;linux/payload/PlocMpsocHandler.h
 11605;0x2d55;MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH;LOW;Packet sequence count in received space packet does not match expected count P1: Expected sequence count P2: Received sequence count;linux/payload/PlocMpsocHandler.h
 11606;0x2d56;MPSOC_SHUTDOWN_FAILED;HIGH;Supervisor fails to shutdown MPSoC. Requires to power off the PLOC and thus also to shutdown the supervisor.;linux/payload/PlocMpsocHandler.h
+11607;0x2d57;SUPV_NOT_ON;LOW;SUPV not on for boot or shutdown process. P1: 0 for OFF transition, 1 for ON transition.;linux/payload/PlocMpsocHandler.h
+11608;0x2d58;SUPV_REPLY_TIMEOUT;LOW;No description;linux/payload/PlocMpsocHandler.h
 11701;0x2db5;SELF_TEST_I2C_FAILURE;LOW;Get self test result returns I2C failure P1: Indicates on which axis the failure occurred. 0 -> INIT, 1 -> +X, 2 -> -X, 3 -> +Y, 4 -> -Y, 5 -> +Z, 6 -> -Z, 7 -> FINA;mission/acs/ImtqHandler.h
 11702;0x2db6;SELF_TEST_SPI_FAILURE;LOW;Get self test result returns SPI failure. This concerns the MTM connectivity. P1: Indicates on which axis the failure occurred. 0 -> INIT, 1 -> +X, 2 -> -X, 3 -> +Y, 4 -> -Y, 5 -> +Z, 6 -> -Z, 7 -> FINA;mission/acs/ImtqHandler.h
 11703;0x2db7;SELF_TEST_ADC_FAILURE;LOW;Get self test result returns failure in measurement of current and temperature. P1: Indicates on which axis the failure occurred. 0 -> INIT, 1 -> +X, 2 -> -X, 3 -> +Y, 4 -> -Y, 5 -> +Z, 6 -> -Z, 7 -> FINA;mission/acs/ImtqHandler.h
@@ -133,14 +148,17 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 11802;0x2e1a;RESET_OCCURED;LOW;No description;mission/acs/rwHelpers.h
 11901;0x2e7d;BOOTING_FIRMWARE_FAILED_EVENT;LOW;Failed to boot firmware;mission/acs/str/StarTrackerHandler.h
 11902;0x2e7e;BOOTING_BOOTLOADER_FAILED_EVENT;LOW;Failed to boot star tracker into bootloader mode;mission/acs/str/StarTrackerHandler.h
-12001;0x2ee1;SUPV_MEMORY_READ_RPT_CRC_FAILURE;LOW;PLOC supervisor crc failure in telemetry packet;linux/payload/PlocSupervisorHandler.h
-12002;0x2ee2;SUPV_UNKNOWN_TM;LOW;Unhandled event. P1: APID, P2: Service ID;linux/payload/PlocSupervisorHandler.h
-12003;0x2ee3;SUPV_UNINIMPLEMENTED_TM;LOW;No description;linux/payload/PlocSupervisorHandler.h
-12004;0x2ee4;SUPV_ACK_FAILURE;LOW;PLOC supervisor received acknowledgment failure report;linux/payload/PlocSupervisorHandler.h
-12005;0x2ee5;SUPV_EXE_FAILURE;LOW;PLOC received execution failure report P1: ID of command for which the execution failed P2: Status code sent by the supervisor handler;linux/payload/PlocSupervisorHandler.h
-12006;0x2ee6;SUPV_CRC_FAILURE_EVENT;LOW;PLOC supervisor reply has invalid crc;linux/payload/PlocSupervisorHandler.h
-12007;0x2ee7;SUPV_HELPER_EXECUTING;LOW;Supervisor helper currently executing a command;linux/payload/PlocSupervisorHandler.h
-12008;0x2ee8;SUPV_MPSOC_SHUTDOWN_BUILD_FAILED;LOW;Failed to build the command to shutdown the MPSoC;linux/payload/PlocSupervisorHandler.h
+11903;0x2e7f;COM_ERROR_REPLY_RECEIVED;LOW;Received COM error. P1:  Communication Error ID (datasheet p32);mission/acs/str/StarTrackerHandler.h
+12001;0x2ee1;SUPV_MEMORY_READ_RPT_CRC_FAILURE;LOW;PLOC supervisor crc failure in telemetry packet;linux/payload/plocSupvDefs.h
+12002;0x2ee2;SUPV_UNKNOWN_TM;LOW;Unhandled event. P1: APID, P2: Service ID;linux/payload/plocSupvDefs.h
+12003;0x2ee3;SUPV_UNINIMPLEMENTED_TM;LOW;No description;linux/payload/plocSupvDefs.h
+12004;0x2ee4;SUPV_ACK_FAILURE;LOW;PLOC supervisor received acknowledgment failure report;linux/payload/plocSupvDefs.h
+12005;0x2ee5;SUPV_EXE_FAILURE;LOW;PLOC received execution failure report P1: ID of command for which the execution failed P2: Status code sent by the supervisor handler;linux/payload/plocSupvDefs.h
+12006;0x2ee6;SUPV_CRC_FAILURE_EVENT;LOW;PLOC supervisor reply has invalid crc;linux/payload/plocSupvDefs.h
+12007;0x2ee7;SUPV_HELPER_EXECUTING;LOW;Supervisor helper currently executing a command;linux/payload/plocSupvDefs.h
+12008;0x2ee8;SUPV_MPSOC_SHUTDOWN_BUILD_FAILED;LOW;Failed to build the command to shutdown the MPSoC;linux/payload/plocSupvDefs.h
+12009;0x2ee9;SUPV_ACK_UNKNOWN_COMMAND;LOW;Received ACK, but no related command is unknown or has not been sent  by this software instance. P1: Module APID. P2: Service ID.;linux/payload/plocSupvDefs.h
+12010;0x2eea;SUPV_EXE_ACK_UNKNOWN_COMMAND;LOW;Received ACK EXE, but no related command is unknown or has not been sent  by this software instance. P1: Module APID. P2: Service ID.;linux/payload/plocSupvDefs.h
 12100;0x2f44;SANITIZATION_FAILED;LOW;No description;bsp_q7s/fs/SdCardManager.h
 12101;0x2f45;MOUNTED_SD_CARD;INFO;No description;bsp_q7s/fs/SdCardManager.h
 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
@@ -160,6 +178,7 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 12412;0x307c;PDEC_RESET_FAILED;HIGH;Failed to pull PDEC reset to low;linux/ipcore/pdec.h
 12413;0x307d;OPEN_IRQ_FILE_FAILED;HIGH;Failed to open the IRQ uio file;linux/ipcore/pdec.h
 12414;0x307e;PDEC_INIT_FAILED;HIGH;PDEC initialization failed. This might also be due to the persistent confiuration never becoming available, for example due to SD card issues.;linux/ipcore/pdec.h
+12415;0x307f;PDEC_CONFIG_CORRUPTED;HIGH;The PDEC configuration area has been corrupted P1: The first configuration word P2: The second configuration word;linux/ipcore/pdec.h
 12500;0x30d4;IMAGE_UPLOAD_FAILED;LOW;Image upload failed;linux/acs/StrComHandler.h
 12501;0x30d5;IMAGE_DOWNLOAD_FAILED;LOW;Image download failed;linux/acs/StrComHandler.h
 12502;0x30d6;IMAGE_UPLOAD_SUCCESSFUL;LOW;Uploading image to star tracker was successfulop;linux/acs/StrComHandler.h
@@ -217,8 +236,9 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 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/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
+13100;0x332c;GPS_FIX_CHANGE;INFO;Fix has changed. P1: New fix. P2: Missed fix changes 0: Not seen, 1: No Fix, 2: 2D-Fix, 3: 3D-Fix;linux/acs/GPSDefinitions.h
+13101;0x332d;CANT_GET_FIX;MEDIUM;Could not get fix in maximum allowed time. Trying to reset both GNSS devices. P1: Maximum allowed time to get a fix after the GPS was switched on.;linux/acs/GPSDefinitions.h
+13102;0x332e;RESET_FAIL;HIGH;Failed to reset an GNNS Device. P1: Board-Side.;linux/acs/GPSDefinitions.h
 13200;0x3390;P60_BOOT_COUNT;INFO;P60 boot count is broadcasted once at SW startup. P1: Boot count;mission/power/P60DockHandler.h
 13201;0x3391;BATT_MODE;INFO;Battery mode is broadcasted at startup. P1: Mode;mission/power/P60DockHandler.h
 13202;0x3392;BATT_MODE_CHANGED;MEDIUM;Battery mode has changed. P1: Old mode. P2: New mode;mission/power/P60DockHandler.h
@@ -254,6 +274,7 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 13800;0x35e8;MISSING_PACKET;LOW;No description;mission/payload/scexHelpers.h
 13801;0x35e9;EXPERIMENT_TIMEDOUT;LOW;No description;mission/payload/scexHelpers.h
 13802;0x35ea;MULTI_PACKET_COMMAND_DONE;INFO;No description;mission/payload/scexHelpers.h
+13803;0x35eb;FS_UNUSABLE;LOW;No description;mission/payload/scexHelpers.h
 13901;0x364d;SET_CONFIGFILEVALUE_FAILED;MEDIUM;No description;mission/utility/GlobalConfigHandler.h
 13902;0x364e;GET_CONFIGFILEVALUE_FAILED;MEDIUM;No description;mission/utility/GlobalConfigHandler.h
 13903;0x364f;INSERT_CONFIGFILEVALUE_FAILED;MEDIUM;No description;mission/utility/GlobalConfigHandler.h
@@ -272,6 +293,7 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 14011;0x36bb;I2C_REBOOT;HIGH;I2C is unavailable. Recovery did not work, performing full reboot.;mission/sysDefs.h
 14012;0x36bc;PDEC_REBOOT;HIGH;PDEC recovery through reset was not possible, performing full reboot.;mission/sysDefs.h
 14013;0x36bd;FIRMWARE_INFO;INFO;Version information of the firmware (not OBSW). P1: Byte 0: Major, Byte 1: Minor, Byte 2: Patch, Byte 3: Has Git Hash P2: First four letters of Git SHA is the last byte of P1 is set.;mission/sysDefs.h
+14014;0x36be;ACTIVE_SD_INFO;INFO;Active SD card info. SD States: 0: OFF, 1: ON, 2: MOUNTED. P1: Active SD Card Index, 0 if none is active P2: First two bytes: SD state of SD card 0, last two bytes SD state of SD card 1;mission/sysDefs.h
 14100;0x3714;NO_VALID_SENSOR_TEMPERATURE;MEDIUM;No description;mission/controller/tcsDefs.h
 14101;0x3715;NO_HEALTHY_HEATER_AVAILABLE;MEDIUM;No description;mission/controller/tcsDefs.h
 14102;0x3716;SYRLINKS_OVERHEATING;HIGH;No description;mission/controller/tcsDefs.h
@@ -280,6 +302,9 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 14106;0x371a;PCDU_SYSTEM_OVERHEATING;HIGH;No description;mission/controller/tcsDefs.h
 14107;0x371b;HEATER_NOT_OFF_FOR_OFF_MODE;MEDIUM;No description;mission/controller/tcsDefs.h
 14108;0x371c;MGT_OVERHEATING;HIGH;No description;mission/controller/tcsDefs.h
+14109;0x371d;TCS_SWITCHING_HEATER_ON;INFO;P1: Module index. P2: Heater index;mission/controller/tcsDefs.h
+14110;0x371e;TCS_SWITCHING_HEATER_OFF;INFO;P1: Module index. P2: Heater index;mission/controller/tcsDefs.h
+14111;0x371f;TCS_HEATER_MAX_BURN_TIME_REACHED;MEDIUM;P1: Heater index. P2: Maximum burn time for heater.;mission/controller/tcsDefs.h
 14201;0x3779;TX_TIMER_EXPIRED;INFO;The transmit timer to protect the Syrlinks expired P1: The current timer value;mission/system/com/ComSubsystem.h
 14202;0x377a;BIT_LOCK_TX_ON;INFO;Transmitter will be turned on due to detection of bitlock;mission/system/com/ComSubsystem.h
 14300;0x37dc;POSSIBLE_FILE_CORRUPTION;LOW;P1: Result code of TM packet parser. P2: Timestamp of possibly corrupt file as a unix timestamp.;mission/persistentTmStoreDefs.h
@@ -295,3 +320,6 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 14312;0x37e8;DUMP_MISC_CANCELLED;LOW;P1: Number of dumped packets. P2: Total dumped bytes.;mission/persistentTmStoreDefs.h
 14313;0x37e9;DUMP_HK_CANCELLED;LOW;P1: Number of dumped packets. P2: Total dumped bytes.;mission/persistentTmStoreDefs.h
 14314;0x37ea;DUMP_CFDP_CANCELLED;LOW;P1: Number of dumped packets. P2: Total dumped bytes.;mission/persistentTmStoreDefs.h
+14500;0x38a4;TEMPERATURE_ALL_ONES_START;MEDIUM;Detected invalid values, starting invalid message counting;mission/acs/SusHandler.h
+14501;0x38a5;TEMPERATURE_ALL_ONES_RECOVERY;INFO;Detected valid values for a prolonged time again, resetting all counters. P1: Number of periods with invalid messages. P2: Maximum invalid message counter.;mission/acs/SusHandler.h
+14600;0x3908;FAULT_HANDLER_TRIGGERED;LOW;P1: CFDP fault handler code. P2: CFDP condition code.;mission/cfdp/defs.h

generators/bsp_hosted_objects.csv

@@ -1,7 +1,9 @@
 0x42694269;TEST_TASK
 0x43000002;ACS_CONTROLLER
 0x43000003;CORE_CONTROLLER
+0x43000004;POWER_CONTROLLER
 0x43000006;GLOBAL_JSON_CFG
+0x43000007;XIPHOS_WDT
 0x43400001;THERMAL_CONTROLLER
 0x44000001;DUMMY_HANDLER
 0x44120006;MGM_0_LIS3_HANDLER
@@ -151,11 +153,13 @@
 0x73000102;CFDP_TM_FUNNEL
 0x73000205;CFDP_HANDLER
 0x73000206;CFDP_DISTRIBUTOR
+0x73000207;CFDP_FAULT_HANDLER
 0x73010000;EIVE_SYSTEM
 0x73010001;ACS_SUBSYSTEM
 0x73010002;PL_SUBSYSTEM
 0x73010003;TCS_SUBSYSTEM
 0x73010004;COM_SUBSYSTEM
+0x73010005;EPS_SUBSYSTEM
 0x73020001;MISC_TM_STORE
 0x73020002;OK_TM_STORE
 0x73020003;NOT_OK_TM_STORE

generators/bsp_hosted_returnvalues.csv

@@ -210,6 +210,7 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x27a8;DHI_NoReplyExpected;No description;168;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
 0x27a9;DHI_NonOpTemperature;No description;169;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
 0x27aa;DHI_CommandNotImplemented;No description;170;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
+0x27ab;DHI_NonOpStateOfCharge;No description;171;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
 0x27b0;DHI_ChecksumError;No description;176;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
 0x27b1;DHI_LengthMissmatch;No description;177;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
 0x27b2;DHI_InvalidData;No description;178;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
@@ -322,193 +323,211 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x3405;DC_NotActive;No description;5;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
 0x3406;DC_TooMuchData;No description;6;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
 0x3407;DC_Busy;No description;7;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
-0x3601;CFDP_InvalidTlvType;No description;1;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3602;CFDP_InvalidDirectiveField;No description;2;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3603;CFDP_InvalidPduDatafieldLen;No description;3;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3604;CFDP_InvalidAckDirectiveFields;No description;4;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3605;CFDP_MetadataCantParseOptions;No description;5;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3606;CFDP_NakCantParseOptions;No description;6;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3607;CFDP_FinishedCantParseFsResponses;No description;7;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3608;CFDP_FilestoreRequiresSecondFile;No description;8;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3609;CFDP_FilestoreResponseCantParseFsMessage;No description;9;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x360a;CFDP_InvalidPduFormat;No description;10;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3701;TSI_BadTimestamp;No description;1;TIME_STAMPER_IF;fsfw/src/fsfw/timemanager/TimeStampIF.h
-0x38a1;SGP4_InvalidEccentricity;No description;161;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x38a2;SGP4_InvalidMeanMotion;No description;162;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x38a3;SGP4_InvalidPerturbationElements;No description;163;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x38a4;SGP4_InvalidSemiLatusRectum;No description;164;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x38a5;SGP4_InvalidEpochElements;No description;165;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x38a6;SGP4_SatelliteHasDecayed;No description;166;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x38b1;SGP4_TleTooOld;No description;177;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x38b2;SGP4_TleNotInitialized;No description;178;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x3901;MUX_NotEnoughResources;No description;1;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3902;MUX_InsufficientMemory;No description;2;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3903;MUX_NoPrivilege;No description;3;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3904;MUX_WrongAttributeSetting;No description;4;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3905;MUX_MutexAlreadyLocked;No description;5;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3906;MUX_MutexNotFound;No description;6;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3907;MUX_MutexMaxLocks;No description;7;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3908;MUX_CurrThreadAlreadyOwnsMutex;No description;8;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3909;MUX_CurrThreadDoesNotOwnMutex;No description;9;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x390a;MUX_MutexTimeout;No description;10;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x390b;MUX_MutexInvalidId;No description;11;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x390c;MUX_MutexDestroyedWhileWaiting;No description;12;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3a01;MQI_Empty;No description;1;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
-0x3a02;MQI_Full;No space left for more messages;2;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
-0x3a03;MQI_NoReplyPartner;Returned if a reply method was called without partner;3;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
-0x3a04;MQI_DestinationInvalid;Returned if the target destination is invalid.;4;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
-0x3b00;SPH_ConnBroken;No description;0;SEMAPHORE_IF;fsfw/src/fsfw/osal/common/TcpTmTcServer.h
-0x3b01;SPH_SemaphoreTimeout;No description;1;SEMAPHORE_IF;fsfw/src/fsfw/tasks/SemaphoreIF.h
-0x3b02;SPH_SemaphoreNotOwned;No description;2;SEMAPHORE_IF;fsfw/src/fsfw/tasks/SemaphoreIF.h
-0x3b03;SPH_SemaphoreInvalid;No description;3;SEMAPHORE_IF;fsfw/src/fsfw/tasks/SemaphoreIF.h
-0x3c00;LPIF_PoolEntryNotFound;No description;0;LOCAL_POOL_OWNER_IF;fsfw/src/fsfw/datapoollocal/localPoolDefinitions.h
-0x3c01;LPIF_PoolEntryTypeConflict;No description;1;LOCAL_POOL_OWNER_IF;fsfw/src/fsfw/datapoollocal/localPoolDefinitions.h
-0x3da0;PVA_InvalidReadWriteMode;No description;160;POOL_VARIABLE_IF;fsfw/src/fsfw/datapool/PoolVariableIF.h
-0x3da1;PVA_InvalidPoolEntry;No description;161;POOL_VARIABLE_IF;fsfw/src/fsfw/datapool/PoolVariableIF.h
-0x3e00;HKM_QueueOrDestinationInvalid;No description;0;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
-0x3e01;HKM_WrongHkPacketType;No description;1;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
-0x3e02;HKM_ReportingStatusUnchanged;No description;2;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
-0x3e03;HKM_PeriodicHelperInvalid;No description;3;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
-0x3e04;HKM_PoolobjectNotFound;No description;4;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
-0x3e05;HKM_DatasetNotFound;No description;5;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
-0x3f01;DLEE_StreamTooShort;No description;1;DLE_ENCODER;fsfw/src/fsfw/globalfunctions/DleEncoder.h
-0x3f02;DLEE_DecodingError;No description;2;DLE_ENCODER;fsfw/src/fsfw/globalfunctions/DleEncoder.h
-0x4201;PUS11_InvalidTypeTimeWindow;No description;1;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
-0x4202;PUS11_InvalidTimeWindow;No description;2;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
-0x4203;PUS11_TimeshiftingNotPossible;No description;3;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
-0x4204;PUS11_InvalidRelativeTime;No description;4;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
-0x4205;PUS11_ContainedTcTooSmall;No description;5;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
-0x4206;PUS11_ContainedTcCrcMissmatch;No description;6;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
-0x4300;FILS_GenericFileError;No description;0;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4301;FILS_GenericDirError;No description;1;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4302;FILS_FilesystemInactive;No description;2;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4303;FILS_GenericRenameError;No description;3;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4304;FILS_IsBusy;No description;4;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4305;FILS_InvalidParameters;No description;5;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x430a;FILS_FileDoesNotExist;No description;10;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x430b;FILS_FileAlreadyExists;No description;11;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x430c;FILS_NotAFile;No description;12;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x430d;FILS_FileLocked;No description;13;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x430e;FILS_PermissionDenied;No description;14;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4315;FILS_DirectoryDoesNotExist;No description;21;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4316;FILS_DirectoryAlreadyExists;No description;22;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4317;FILS_NotADirectory;No description;23;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4318;FILS_DirectoryNotEmpty;No description;24;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x431e;FILS_SequencePacketMissingWrite;No description;30;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x431f;FILS_SequencePacketMissingRead;No description;31;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4400;UXOS_ExecutionFinished;Execution of the current command has finished;0;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
-0x4401;UXOS_CommandPending;Command is pending. This will also be returned if the user tries to load another command but a command is still pending;1;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
-0x4402;UXOS_BytesRead;Some bytes have been read from the executing process;2;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
-0x4403;UXOS_CommandError;Command execution failed;3;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
-0x4404;UXOS_NoCommandLoadedOrPending;;4;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
-0x4406;UXOS_PcloseCallError;No description;6;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
-0x4500;HSPI_OpeningFileFailed;No description;0;HAL_SPI;fsfw/src/fsfw_hal/common/spi/spiCommon.h
-0x4501;HSPI_FullDuplexTransferFailed;No description;1;HAL_SPI;fsfw/src/fsfw_hal/common/spi/spiCommon.h
-0x4502;HSPI_HalfDuplexTransferFailed;No description;2;HAL_SPI;fsfw/src/fsfw_hal/common/spi/spiCommon.h
-0x4503;HSPI_Timeout;No description;3;HAL_SPI;fsfw/src/fsfw_hal/common/spi/spiCommon.h
-0x4504;HSPI_Busy;No description;4;HAL_SPI;fsfw/src/fsfw_hal/common/spi/spiCommon.h
-0x4505;HSPI_GenericError;No description;5;HAL_SPI;fsfw/src/fsfw_hal/common/spi/spiCommon.h
-0x4601;HURT_UartReadFailure;No description;1;HAL_UART;fsfw/src/fsfw_hal/linux/serial/SerialComIF.h
-0x4602;HURT_UartReadSizeMissmatch;No description;2;HAL_UART;fsfw/src/fsfw_hal/linux/serial/SerialComIF.h
-0x4603;HURT_UartRxBufferTooSmall;No description;3;HAL_UART;fsfw/src/fsfw_hal/linux/serial/SerialComIF.h
-0x4801;HGIO_UnknownGpioId;No description;1;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x4802;HGIO_DriveGpioFailure;No description;2;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x4803;HGIO_GpioTypeFailure;No description;3;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x4804;HGIO_GpioInvalidInstance;No description;4;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x4805;HGIO_GpioDuplicateDetected;No description;5;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x4806;HGIO_GpioInitFailed;No description;6;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x4807;HGIO_GpioGetValueFailed;No description;7;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x4c00;SPPA_NoPacketFound;No description;0;SPACE_PACKET_PARSER;fsfw/src/fsfw/tmtcservices/SpacePacketParser.h
-0x4c01;SPPA_SplitPacket;No description;1;SPACE_PACKET_PARSER;fsfw/src/fsfw/tmtcservices/SpacePacketParser.h
-0x4fa1;HEATER_CommandNotSupported;No description;161;HEATER_HANDLER;mission/tcs/HeaterHandler.h
-0x4fa2;HEATER_InitFailed;No description;162;HEATER_HANDLER;mission/tcs/HeaterHandler.h
-0x4fa3;HEATER_InvalidSwitchNr;No description;163;HEATER_HANDLER;mission/tcs/HeaterHandler.h
-0x4fa4;HEATER_MainSwitchSetTimeout;No description;164;HEATER_HANDLER;mission/tcs/HeaterHandler.h
-0x4fa5;HEATER_CommandAlreadyWaiting;No description;165;HEATER_HANDLER;mission/tcs/HeaterHandler.h
-0x50a0;SYRLINKS_CrcFailure;No description;160;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
-0x50a1;SYRLINKS_UartFraminOrParityErrorAck;No description;161;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
-0x50a2;SYRLINKS_BadCharacterAck;No description;162;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
-0x50a3;SYRLINKS_BadParameterValueAck;No description;163;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
-0x50a4;SYRLINKS_BadEndOfFrameAck;No description;164;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
-0x50a5;SYRLINKS_UnknownCommandIdAck;No description;165;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
-0x50a6;SYRLINKS_BadCrcAck;No description;166;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
-0x50a7;SYRLINKS_ReplyWrongSize;No description;167;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
-0x50a8;SYRLINKS_MissingStartFrameCharacter;No description;168;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
-0x5100;IMTQ_InvalidCommandCode;No description;0;IMTQ_HANDLER;mission/acs/imtqHelpers.h
-0x5101;IMTQ_MgmMeasurementLowLevelError;No description;1;IMTQ_HANDLER;mission/acs/imtqHelpers.h
-0x5102;IMTQ_ActuateCmdLowLevelError;No description;2;IMTQ_HANDLER;mission/acs/imtqHelpers.h
-0x5103;IMTQ_ParameterMissing;No description;3;IMTQ_HANDLER;mission/acs/imtqHelpers.h
-0x5104;IMTQ_ParameterInvalid;No description;4;IMTQ_HANDLER;mission/acs/imtqHelpers.h
-0x5105;IMTQ_CcUnavailable;No description;5;IMTQ_HANDLER;mission/acs/imtqHelpers.h
-0x5106;IMTQ_InternalProcessingError;No description;6;IMTQ_HANDLER;mission/acs/imtqHelpers.h
-0x5107;IMTQ_RejectedWithoutReason;No description;7;IMTQ_HANDLER;mission/acs/imtqHelpers.h
-0x5108;IMTQ_CmdErrUnknown;No description;8;IMTQ_HANDLER;mission/acs/imtqHelpers.h
-0x5109;IMTQ_StartupCfgError;No description;9;IMTQ_HANDLER;mission/acs/imtqHelpers.h
-0x510a;IMTQ_UnexpectedSelfTestReply;The status reply to a self test command was received but no self test command has been sent. This should normally never happen.;10;IMTQ_HANDLER;mission/acs/imtqHelpers.h
-0x52b0;RWHA_SpiWriteFailure;No description;176;RW_HANDLER;mission/acs/rwHelpers.h
-0x52b1;RWHA_SpiReadFailure;Used by the spi send function to tell a failing read call;177;RW_HANDLER;mission/acs/rwHelpers.h
-0x52b2;RWHA_MissingStartSign;Can be used by the HDLC decoding mechanism to inform about a missing start sign 0x7E;178;RW_HANDLER;mission/acs/rwHelpers.h
-0x52b3;RWHA_InvalidSubstitute;Can be used by the HDLC decoding mechanism to inform about an invalid substitution combination;179;RW_HANDLER;mission/acs/rwHelpers.h
-0x52b4;RWHA_MissingEndSign;HDLC decoding mechanism never receives the end sign 0x7E;180;RW_HANDLER;mission/acs/rwHelpers.h
-0x52b5;RWHA_NoReply;Reaction wheel only responds with empty frames.;181;RW_HANDLER;mission/acs/rwHelpers.h
-0x52b6;RWHA_NoStartMarker;Expected a start marker as first byte;182;RW_HANDLER;mission/acs/rwHelpers.h
-0x52b7;RWHA_SpiReadTimeout;Timeout when reading reply;183;RW_HANDLER;mission/acs/rwHelpers.h
-0x53a0;STRH_TemperatureReqFailed;Status in temperature reply signals error;160;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53a1;STRH_PingFailed;Ping command failed;161;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53a2;STRH_VersionReqFailed;Status in version reply signals error;162;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53a3;STRH_InterfaceReqFailed;Status in interface reply signals error;163;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53a4;STRH_PowerReqFailed;Status in power reply signals error;164;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53a5;STRH_SetParamFailed;Status of reply to parameter set command signals error;165;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53a6;STRH_ActionFailed;Status of reply to action command signals error;166;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53a7;STRH_FilePathTooLong;Received invalid path string. Exceeds allowed length;167;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53a8;STRH_FilenameTooLong;Name of file received with command is too long;168;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53a9;STRH_InvalidProgram;Received version reply with invalid program ID;169;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53aa;STRH_ReplyError;Status field reply signals error;170;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53ab;STRH_CommandTooShort;Received command which is too short (some data is missing for proper execution);171;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53ac;STRH_InvalidLength;Received command with invalid length (too few or too many parameters);172;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53ad;STRH_RegionMismatch;Region mismatch between send and received data;173;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53ae;STRH_AddressMismatch;Address mismatch between send and received data;174;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53af;STRH_LengthMismatch;Length field mismatch between send and received data;175;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53b0;STRH_FileNotExists;Specified file does not exist;176;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53b1;STRH_InvalidType;Download blob pixel command has invalid type field;177;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53b2;STRH_InvalidId;Received FPGA action command with invalid ID;178;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53b3;STRH_ReplyTooShort;Received reply is too short;179;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53b4;STRH_CrcFailure;Received reply with invalid CRC;180;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53b5;STRH_StrHelperExecuting;Star tracker handler currently executing a command and using the communication interface;181;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-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
-0x58a0;SUSS_InvalidSpeed;Action Message with invalid speed was received. Valid speeds must be in the range of [-65000, 1000] or [1000, 65000];160;SUS_HANDLER;mission/acs/RwHandler.h
-0x58a1;SUSS_InvalidRampTime;Action Message with invalid ramp time was received.;161;SUS_HANDLER;mission/acs/RwHandler.h
-0x58a2;SUSS_SetSpeedCommandInvalidLength;Received set speed command has invalid length. Should be 6.;162;SUS_HANDLER;mission/acs/RwHandler.h
-0x58a3;SUSS_ExecutionFailed;Command execution failed;163;SUS_HANDLER;mission/acs/RwHandler.h
-0x58a4;SUSS_CrcError;Reaction wheel reply has invalid crc;164;SUS_HANDLER;mission/acs/RwHandler.h
-0x58a5;SUSS_ValueNotRead;No description;165;SUS_HANDLER;mission/acs/RwHandler.h
-0x5d00;GOMS_PacketTooLong;No description;0;GOM_SPACE_HANDLER;mission/power/GomspaceDeviceHandler.h
-0x5d01;GOMS_InvalidTableId;No description;1;GOM_SPACE_HANDLER;mission/power/GomspaceDeviceHandler.h
-0x5d02;GOMS_InvalidAddress;No description;2;GOM_SPACE_HANDLER;mission/power/GomspaceDeviceHandler.h
-0x5d03;GOMS_InvalidParamSize;No description;3;GOM_SPACE_HANDLER;mission/power/GomspaceDeviceHandler.h
-0x5d04;GOMS_InvalidPayloadSize;No description;4;GOM_SPACE_HANDLER;mission/power/GomspaceDeviceHandler.h
-0x5d05;GOMS_UnknownReplyId;No description;5;GOM_SPACE_HANDLER;mission/power/GomspaceDeviceHandler.h
-0x60a0;CCSDS_CommandNotImplemented;Received action message with unknown action id;160;CCSDS_HANDLER;mission/com/CcsdsIpCoreHandler.h
-0x6201;JSONBASE_JsonFileNotExists;Specified json file does not exist;1;ARCSEC_JSON_BASE;mission/acs/str/ArcsecJsonParamBase.h
-0x6202;JSONBASE_SetNotExists;Requested set does not exist in json file;2;ARCSEC_JSON_BASE;mission/acs/str/ArcsecJsonParamBase.h
-0x6203;JSONBASE_ParamNotExists;Requested parameter does not exist in json file;3;ARCSEC_JSON_BASE;mission/acs/str/ArcsecJsonParamBase.h
-0x63a0;NVMB_KeyNotExists;Specified key does not exist in json file;160;NVM_PARAM_BASE;mission/memory/NvmParameterBase.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
-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;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
-0x6a05;ACSMEKF_MekfNoSusMgmStrData;No description;5;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
-0x6a06;ACSMEKF_MekfCovarianceInversionFailed;No description;6;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
-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
-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
+0x3601;CFDP_InvalidTlvType;No description;1;CFDP_BASE;fsfw/src/fsfw/cfdp/definitions.h
+0x3602;CFDP_InvalidDirectiveField;No description;2;CFDP_BASE;fsfw/src/fsfw/cfdp/definitions.h
+0x3603;CFDP_InvalidPduDatafieldLen;No description;3;CFDP_BASE;fsfw/src/fsfw/cfdp/definitions.h
+0x3604;CFDP_InvalidAckDirectiveFields;No description;4;CFDP_BASE;fsfw/src/fsfw/cfdp/definitions.h
+0x3605;CFDP_MetadataCantParseOptions;No description;5;CFDP_BASE;fsfw/src/fsfw/cfdp/definitions.h
+0x3606;CFDP_NakCantParseOptions;No description;6;CFDP_BASE;fsfw/src/fsfw/cfdp/definitions.h
+0x3607;CFDP_FinishedCantParseFsResponses;No description;7;CFDP_BASE;fsfw/src/fsfw/cfdp/definitions.h
+0x3608;CFDP_FilestoreRequiresSecondFile;No description;8;CFDP_BASE;fsfw/src/fsfw/cfdp/definitions.h
+0x3609;CFDP_FilestoreResponseCantParseFsMessage;No description;9;CFDP_BASE;fsfw/src/fsfw/cfdp/definitions.h
+0x360a;CFDP_InvalidPduFormat;No description;10;CFDP_BASE;fsfw/src/fsfw/cfdp/definitions.h
+0x3700;CFDP_SourceTransactionPending;No description;0;CFDP_HANDLER;fsfw/src/fsfw/cfdp/handler/defs.h
+0x3701;CFDP_FileDoesNotExist;No description;1;CFDP_HANDLER;fsfw/src/fsfw/cfdp/handler/defs.h
+0x3702;CFDP_FileSegmentLenInvalid;No description;2;CFDP_HANDLER;fsfw/src/fsfw/cfdp/handler/defs.h
+0x3703;CFDP_SourceNameEmpty;No description;3;CFDP_HANDLER;fsfw/src/fsfw/cfdp/handler/defs.h
+0x3704;CFDP_DestNameEmpty;No description;4;CFDP_HANDLER;fsfw/src/fsfw/cfdp/handler/defs.h
+0x3705;CFDP_WrongRemoteCfgEntityId;No description;5;CFDP_HANDLER;fsfw/src/fsfw/cfdp/handler/defs.h
+0x3706;CFDP_TargetMsgQueueFull;No description;6;CFDP_HANDLER;fsfw/src/fsfw/cfdp/handler/defs.h
+0x3707;CFDP_TmStoreFull;No description;7;CFDP_HANDLER;fsfw/src/fsfw/cfdp/handler/defs.h
+0x3801;TSI_BadTimestamp;No description;1;TIME_STAMPER_IF;fsfw/src/fsfw/timemanager/TimeStampIF.h
+0x39a1;SGP4_InvalidEccentricity;No description;161;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x39a2;SGP4_InvalidMeanMotion;No description;162;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x39a3;SGP4_InvalidPerturbationElements;No description;163;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x39a4;SGP4_InvalidSemiLatusRectum;No description;164;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x39a5;SGP4_InvalidEpochElements;No description;165;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x39a6;SGP4_SatelliteHasDecayed;No description;166;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x39b1;SGP4_TleTooOld;No description;177;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x39b2;SGP4_TleNotInitialized;No description;178;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x3a01;MUX_NotEnoughResources;No description;1;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3a02;MUX_InsufficientMemory;No description;2;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3a03;MUX_NoPrivilege;No description;3;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3a04;MUX_WrongAttributeSetting;No description;4;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3a05;MUX_MutexAlreadyLocked;No description;5;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3a06;MUX_MutexNotFound;No description;6;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3a07;MUX_MutexMaxLocks;No description;7;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3a08;MUX_CurrThreadAlreadyOwnsMutex;No description;8;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3a09;MUX_CurrThreadDoesNotOwnMutex;No description;9;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3a0a;MUX_MutexTimeout;No description;10;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3a0b;MUX_MutexInvalidId;No description;11;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3a0c;MUX_MutexDestroyedWhileWaiting;No description;12;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3b01;MQI_Empty;No description;1;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
+0x3b02;MQI_Full;No space left for more messages;2;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
+0x3b03;MQI_NoReplyPartner;Returned if a reply method was called without partner;3;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
+0x3b04;MQI_DestinationInvalid;Returned if the target destination is invalid.;4;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
+0x3c01;SPH_SemaphoreTimeout;No description;1;SEMAPHORE_IF;fsfw/src/fsfw/tasks/SemaphoreIF.h
+0x3c02;SPH_SemaphoreNotOwned;No description;2;SEMAPHORE_IF;fsfw/src/fsfw/tasks/SemaphoreIF.h
+0x3c03;SPH_SemaphoreInvalid;No description;3;SEMAPHORE_IF;fsfw/src/fsfw/tasks/SemaphoreIF.h
+0x3d00;LPIF_PoolEntryNotFound;No description;0;LOCAL_POOL_OWNER_IF;fsfw/src/fsfw/datapoollocal/localPoolDefinitions.h
+0x3d01;LPIF_PoolEntryTypeConflict;No description;1;LOCAL_POOL_OWNER_IF;fsfw/src/fsfw/datapoollocal/localPoolDefinitions.h
+0x3ea0;PVA_InvalidReadWriteMode;No description;160;POOL_VARIABLE_IF;fsfw/src/fsfw/datapool/PoolVariableIF.h
+0x3ea1;PVA_InvalidPoolEntry;No description;161;POOL_VARIABLE_IF;fsfw/src/fsfw/datapool/PoolVariableIF.h
+0x3f00;HKM_QueueOrDestinationInvalid;No description;0;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
+0x3f01;HKM_WrongHkPacketType;No description;1;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
+0x3f02;HKM_ReportingStatusUnchanged;No description;2;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
+0x3f03;HKM_PeriodicHelperInvalid;No description;3;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
+0x3f04;HKM_PoolobjectNotFound;No description;4;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
+0x3f05;HKM_DatasetNotFound;No description;5;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
+0x4001;DLEE_StreamTooShort;No description;1;DLE_ENCODER;fsfw/src/fsfw/globalfunctions/DleEncoder.h
+0x4002;DLEE_DecodingError;No description;2;DLE_ENCODER;fsfw/src/fsfw/globalfunctions/DleEncoder.h
+0x4301;PUS11_InvalidTypeTimeWindow;No description;1;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
+0x4302;PUS11_InvalidTimeWindow;No description;2;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
+0x4303;PUS11_TimeshiftingNotPossible;No description;3;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
+0x4304;PUS11_InvalidRelativeTime;No description;4;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
+0x4305;PUS11_ContainedTcTooSmall;No description;5;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
+0x4306;PUS11_ContainedTcCrcMissmatch;No description;6;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
+0x4307;PUS11_MapIsFull;No description;7;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
+0x4400;FILS_GenericFileError;No description;0;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4401;FILS_GenericDirError;No description;1;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4402;FILS_FilesystemInactive;No description;2;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4403;FILS_GenericRenameError;No description;3;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4404;FILS_IsBusy;No description;4;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4405;FILS_InvalidParameters;No description;5;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x440a;FILS_FileDoesNotExist;No description;10;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x440b;FILS_FileAlreadyExists;No description;11;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x440c;FILS_NotAFile;No description;12;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x440d;FILS_FileLocked;No description;13;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x440e;FILS_PermissionDenied;No description;14;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4415;FILS_DirectoryDoesNotExist;No description;21;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4416;FILS_DirectoryAlreadyExists;No description;22;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4417;FILS_NotADirectory;No description;23;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4418;FILS_DirectoryNotEmpty;No description;24;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x441e;FILS_SequencePacketMissingWrite;No description;30;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x441f;FILS_SequencePacketMissingRead;No description;31;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4500;UXOS_ExecutionFinished;Execution of the current command has finished;0;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
+0x4501;UXOS_CommandPending;Command is pending. This will also be returned if the user tries to load another command but a command is still pending;1;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
+0x4502;UXOS_BytesRead;Some bytes have been read from the executing process;2;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
+0x4503;UXOS_CommandError;Command execution failed;3;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
+0x4504;UXOS_NoCommandLoadedOrPending;;4;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
+0x4506;UXOS_PcloseCallError;No description;6;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
+0x4600;HSPI_OpeningFileFailed;No description;0;HAL_SPI;fsfw/src/fsfw_hal/common/spi/spiCommon.h
+0x4601;HSPI_FullDuplexTransferFailed;No description;1;HAL_SPI;fsfw/src/fsfw_hal/common/spi/spiCommon.h
+0x4602;HSPI_HalfDuplexTransferFailed;No description;2;HAL_SPI;fsfw/src/fsfw_hal/common/spi/spiCommon.h
+0x4603;HSPI_Timeout;No description;3;HAL_SPI;fsfw/src/fsfw_hal/common/spi/spiCommon.h
+0x4604;HSPI_Busy;No description;4;HAL_SPI;fsfw/src/fsfw_hal/common/spi/spiCommon.h
+0x4605;HSPI_GenericError;No description;5;HAL_SPI;fsfw/src/fsfw_hal/common/spi/spiCommon.h
+0x4701;HURT_UartReadFailure;No description;1;HAL_UART;fsfw/src/fsfw_hal/linux/serial/SerialComIF.h
+0x4702;HURT_UartReadSizeMissmatch;No description;2;HAL_UART;fsfw/src/fsfw_hal/linux/serial/SerialComIF.h
+0x4703;HURT_UartRxBufferTooSmall;No description;3;HAL_UART;fsfw/src/fsfw_hal/linux/serial/SerialComIF.h
+0x4901;HGIO_UnknownGpioId;No description;1;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+0x4902;HGIO_DriveGpioFailure;No description;2;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+0x4903;HGIO_GpioTypeFailure;No description;3;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+0x4904;HGIO_GpioInvalidInstance;No description;4;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+0x4905;HGIO_GpioDuplicateDetected;No description;5;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+0x4906;HGIO_GpioInitFailed;No description;6;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+0x4907;HGIO_GpioGetValueFailed;No description;7;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+0x4d00;SPPA_NoPacketFound;No description;0;SPACE_PACKET_PARSER;fsfw/src/fsfw/tmtcservices/SpacePacketParser.h
+0x4d01;SPPA_SplitPacket;No description;1;SPACE_PACKET_PARSER;fsfw/src/fsfw/tmtcservices/SpacePacketParser.h
+0x50a1;HEATER_CommandNotSupported;No description;161;HEATER_HANDLER;mission/tcs/HeaterHandler.h
+0x50a2;HEATER_InitFailed;No description;162;HEATER_HANDLER;mission/tcs/HeaterHandler.h
+0x50a3;HEATER_InvalidSwitchNr;No description;163;HEATER_HANDLER;mission/tcs/HeaterHandler.h
+0x50a4;HEATER_MainSwitchSetTimeout;No description;164;HEATER_HANDLER;mission/tcs/HeaterHandler.h
+0x50a5;HEATER_CommandAlreadyWaiting;No description;165;HEATER_HANDLER;mission/tcs/HeaterHandler.h
+0x51a0;SYRLINKS_CrcFailure;No description;160;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
+0x51a1;SYRLINKS_UartFraminOrParityErrorAck;No description;161;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
+0x51a2;SYRLINKS_BadCharacterAck;No description;162;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
+0x51a3;SYRLINKS_BadParameterValueAck;No description;163;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
+0x51a4;SYRLINKS_BadEndOfFrameAck;No description;164;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
+0x51a5;SYRLINKS_UnknownCommandIdAck;No description;165;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
+0x51a6;SYRLINKS_BadCrcAck;No description;166;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
+0x51a7;SYRLINKS_ReplyWrongSize;No description;167;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
+0x51a8;SYRLINKS_MissingStartFrameCharacter;No description;168;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
+0x5200;IMTQ_InvalidCommandCode;No description;0;IMTQ_HANDLER;mission/acs/imtqHelpers.h
+0x5201;IMTQ_MgmMeasurementLowLevelError;No description;1;IMTQ_HANDLER;mission/acs/imtqHelpers.h
+0x5202;IMTQ_ActuateCmdLowLevelError;No description;2;IMTQ_HANDLER;mission/acs/imtqHelpers.h
+0x5203;IMTQ_ParameterMissing;No description;3;IMTQ_HANDLER;mission/acs/imtqHelpers.h
+0x5204;IMTQ_ParameterInvalid;No description;4;IMTQ_HANDLER;mission/acs/imtqHelpers.h
+0x5205;IMTQ_CcUnavailable;No description;5;IMTQ_HANDLER;mission/acs/imtqHelpers.h
+0x5206;IMTQ_InternalProcessingError;No description;6;IMTQ_HANDLER;mission/acs/imtqHelpers.h
+0x5207;IMTQ_RejectedWithoutReason;No description;7;IMTQ_HANDLER;mission/acs/imtqHelpers.h
+0x5208;IMTQ_CmdErrUnknown;No description;8;IMTQ_HANDLER;mission/acs/imtqHelpers.h
+0x5209;IMTQ_StartupCfgError;No description;9;IMTQ_HANDLER;mission/acs/imtqHelpers.h
+0x520a;IMTQ_UnexpectedSelfTestReply;The status reply to a self test command was received but no self test command has been sent. This should normally never happen.;10;IMTQ_HANDLER;mission/acs/imtqHelpers.h
+0x53a0;RWHA_InvalidSpeed;Action Message with invalid speed was received. Valid speeds must be in the range of [-65000, 1000] or [1000, 65000];160;RW_HANDLER;mission/acs/RwHandler.h
+0x53a1;RWHA_InvalidRampTime;Action Message with invalid ramp time was received.;161;RW_HANDLER;mission/acs/RwHandler.h
+0x53a2;RWHA_SetSpeedCommandInvalidLength;Received set speed command has invalid length. Should be 6.;162;RW_HANDLER;mission/acs/RwHandler.h
+0x53a3;RWHA_ExecutionFailed;Command execution failed;163;RW_HANDLER;mission/acs/RwHandler.h
+0x53a4;RWHA_CrcError;Reaction wheel reply has invalid crc;164;RW_HANDLER;mission/acs/RwHandler.h
+0x53a5;RWHA_ValueNotRead;No description;165;RW_HANDLER;mission/acs/RwHandler.h
+0x53b0;RWHA_SpiWriteFailure;No description;176;RW_HANDLER;mission/acs/rwHelpers.h
+0x53b1;RWHA_SpiReadFailure;Used by the spi send function to tell a failing read call;177;RW_HANDLER;mission/acs/rwHelpers.h
+0x53b2;RWHA_MissingStartSign;Can be used by the HDLC decoding mechanism to inform about a missing start sign 0x7E;178;RW_HANDLER;mission/acs/rwHelpers.h
+0x53b3;RWHA_InvalidSubstitute;Can be used by the HDLC decoding mechanism to inform about an invalid substitution combination;179;RW_HANDLER;mission/acs/rwHelpers.h
+0x53b4;RWHA_MissingEndSign;HDLC decoding mechanism never receives the end sign 0x7E;180;RW_HANDLER;mission/acs/rwHelpers.h
+0x53b5;RWHA_NoReply;Reaction wheel only responds with empty frames.;181;RW_HANDLER;mission/acs/rwHelpers.h
+0x53b6;RWHA_NoStartMarker;Expected a start marker as first byte;182;RW_HANDLER;mission/acs/rwHelpers.h
+0x53b7;RWHA_SpiReadTimeout;Timeout when reading reply;183;RW_HANDLER;mission/acs/rwHelpers.h
+0x54a0;STRH_TemperatureReqFailed;Status in temperature reply signals error;160;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x54a1;STRH_PingFailed;Ping command failed;161;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x54a2;STRH_VersionReqFailed;Status in version reply signals error;162;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x54a3;STRH_InterfaceReqFailed;Status in interface reply signals error;163;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x54a4;STRH_PowerReqFailed;Status in power reply signals error;164;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x54a5;STRH_SetParamFailed;Status of reply to parameter set command signals error;165;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x54a6;STRH_ActionFailed;Status of reply to action command signals error;166;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x54a7;STRH_FilePathTooLong;Received invalid path string. Exceeds allowed length;167;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x54a8;STRH_FilenameTooLong;Name of file received with command is too long;168;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x54a9;STRH_InvalidProgram;Received version reply with invalid program ID;169;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x54aa;STRH_ReplyError;Status field reply signals error;170;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x54ab;STRH_CommandTooShort;Received command which is too short (some data is missing for proper execution);171;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x54ac;STRH_InvalidLength;Received command with invalid length (too few or too many parameters);172;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x54ad;STRH_RegionMismatch;Region mismatch between send and received data;173;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x54ae;STRH_AddressMismatch;Address mismatch between send and received data;174;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x54af;STRH_LengthMismatch;Length field mismatch between send and received data;175;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x54b0;STRH_FileNotExists;Specified file does not exist;176;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x54b1;STRH_InvalidType;Download blob pixel command has invalid type field;177;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x54b2;STRH_InvalidId;Received FPGA action command with invalid ID;178;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x54b3;STRH_ReplyTooShort;Received reply is too short;179;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x54b4;STRH_CrcFailure;Received reply with invalid CRC;180;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x54b5;STRH_StrHelperExecuting;Star tracker handler currently executing a command and using the communication interface;181;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x54b6;STRH_StartrackerAlreadyBooted;Star tracker is already in firmware mode;182;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x54b7;STRH_StartrackerNotRunningFirmware;Star tracker must be in firmware mode to run this command;183;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x54b8;STRH_StartrackerNotRunningBootloader;Star tracker must be in bootloader mode to run this command;184;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x59a0;SUSS_ErrorUnlockMutex;No description;160;SUS_HANDLER;mission/acs/archive/LegacySusHandler.h
+0x59a1;SUSS_ErrorLockMutex;No description;161;SUS_HANDLER;mission/acs/archive/LegacySusHandler.h
+0x5e00;GOMS_PacketTooLong;No description;0;GOM_SPACE_HANDLER;mission/power/GomspaceDeviceHandler.h
+0x5e01;GOMS_InvalidTableId;No description;1;GOM_SPACE_HANDLER;mission/power/GomspaceDeviceHandler.h
+0x5e02;GOMS_InvalidAddress;No description;2;GOM_SPACE_HANDLER;mission/power/GomspaceDeviceHandler.h
+0x5e03;GOMS_InvalidParamSize;No description;3;GOM_SPACE_HANDLER;mission/power/GomspaceDeviceHandler.h
+0x5e04;GOMS_InvalidPayloadSize;No description;4;GOM_SPACE_HANDLER;mission/power/GomspaceDeviceHandler.h
+0x5e05;GOMS_UnknownReplyId;No description;5;GOM_SPACE_HANDLER;mission/power/GomspaceDeviceHandler.h
+0x61a0;CCSDS_CommandNotImplemented;Received action message with unknown action id;160;CCSDS_HANDLER;mission/com/CcsdsIpCoreHandler.h
+0x6301;JSONBASE_JsonFileNotExists;Specified json file does not exist;1;ARCSEC_JSON_BASE;mission/acs/str/ArcsecJsonParamBase.h
+0x6302;JSONBASE_SetNotExists;Requested set does not exist in json file;2;ARCSEC_JSON_BASE;mission/acs/str/ArcsecJsonParamBase.h
+0x6303;JSONBASE_ParamNotExists;Requested parameter does not exist in json file;3;ARCSEC_JSON_BASE;mission/acs/str/ArcsecJsonParamBase.h
+0x64a0;NVMB_KeyNotExists;Specified key does not exist in json file;160;NVM_PARAM_BASE;mission/memory/NvmParameterBase.h
+0x67a0;SADPL_CommandNotSupported;No description;160;SA_DEPL_HANDLER;mission/SolarArrayDeploymentHandler.h
+0x67a1;SADPL_DeploymentAlreadyExecuting;No description;161;SA_DEPL_HANDLER;mission/SolarArrayDeploymentHandler.h
+0x67a2;SADPL_MainSwitchTimeoutFailure;No description;162;SA_DEPL_HANDLER;mission/SolarArrayDeploymentHandler.h
+0x67a3;SADPL_SwitchingDeplSa1Failed;No description;163;SA_DEPL_HANDLER;mission/SolarArrayDeploymentHandler.h
+0x67a4;SADPL_SwitchingDeplSa2Failed;No description;164;SA_DEPL_HANDLER;mission/SolarArrayDeploymentHandler.h
+0x6aa0;ACSCTRL_FileDeletionFailed;File deletion failed and at least one file is still existent.;160;ACS_CTRL;mission/controller/controllerdefinitions/AcsCtrlDefinitions.h
+0x6aa1;ACSCTRL_WriteFileFailed;Writing the TLE to the file has failed.;161;ACS_CTRL;mission/controller/controllerdefinitions/AcsCtrlDefinitions.h
+0x6aa2;ACSCTRL_ReadFileFailed;Reading the TLE to the file has failed.;162;ACS_CTRL;mission/controller/controllerdefinitions/AcsCtrlDefinitions.h
+0x6aa3;ACSCTRL_SingleRwUnavailable;A single RW has failed.;163;ACS_CTRL;mission/controller/controllerdefinitions/AcsCtrlDefinitions.h
+0x6aa4;ACSCTRL_MultipleRwUnavailable;Multiple RWs have failed.;164;ACS_CTRL;mission/controller/controllerdefinitions/AcsCtrlDefinitions.h
+0x6b02;ACSMEKF_MekfUninitialized;No description;2;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
+0x6b03;ACSMEKF_MekfNoGyrData;No description;3;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
+0x6b04;ACSMEKF_MekfNoModelVectors;No description;4;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
+0x6b05;ACSMEKF_MekfNoSusMgmStrData;No description;5;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
+0x6b06;ACSMEKF_MekfCovarianceInversionFailed;No description;6;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
+0x6b07;ACSMEKF_MekfNotFinite;No description;7;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
+0x6b08;ACSMEKF_MekfInitialized;No description;8;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
+0x6b09;ACSMEKF_MekfRunning;No description;9;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
+0x6e00;PTM_DumpDone;No description;0;PERSISTENT_TM_STORE;mission/tmtc/PersistentTmStore.h
+0x6e01;PTM_BusyDumping;No description;1;PERSISTENT_TM_STORE;mission/tmtc/PersistentTmStore.h
+0x6f00;TMS_IsBusy;No description;0;TM_SINK;mission/tmtc/DirectTmSinkIF.h
+0x6f01;TMS_PartiallyWritten;No description;1;TM_SINK;mission/tmtc/DirectTmSinkIF.h
+0x6f02;TMS_NoWriteActive;No description;2;TM_SINK;mission/tmtc/DirectTmSinkIF.h
+0x6f03;TMS_Timeout;No description;3;TM_SINK;mission/tmtc/DirectTmSinkIF.h
+0x7000;VCS_ChannelDoesNotExist;No description;0;VIRTUAL_CHANNEL;mission/com/VirtualChannel.h

generators/bsp_hosted_subsystems.csv

@@ -60,3 +60,5 @@
 142;COM_SUBSYSTEM
 143;PERSISTENT_TM_STORE
 144;SYRLINKS_COM
+145;SUS_HANDLER
+146;CFDP_APP

generators/bsp_q7s_events.csv

@@ -75,9 +75,12 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 7902;0x1ede;BIT_LOCK;INFO;A Bit Lock signal. Was detected. P1: raw BLO state, P2: 0;fsfw/src/fsfw/datalinklayer/DataLinkLayer.h
 7903;0x1edf;BIT_LOCK_LOST;INFO;A previously found Bit Lock signal was lost. P1: raw BLO state, P2: 0;fsfw/src/fsfw/datalinklayer/DataLinkLayer.h
 7905;0x1ee1;FRAME_PROCESSING_FAILED;LOW;The CCSDS Board could not interpret a TC;fsfw/src/fsfw/datalinklayer/DataLinkLayer.h
-8900;0x22c4;CLOCK_SET;INFO;No description;fsfw/src/fsfw/pus/Service9TimeManagement.h
-8901;0x22c5;CLOCK_DUMP;INFO;No description;fsfw/src/fsfw/pus/Service9TimeManagement.h
-8902;0x22c6;CLOCK_SET_FAILURE;LOW;No description;fsfw/src/fsfw/pus/Service9TimeManagement.h
+8900;0x22c4;CLOCK_SET;INFO;Clock has been set. P1: old timeval seconds. P2: new timeval seconds.;fsfw/src/fsfw/pus/Service9TimeManagement.h
+8901;0x22c5;CLOCK_DUMP_LEGACY;INFO;Clock dump event. P1: timeval seconds P2: timeval milliseconds.;fsfw/src/fsfw/pus/Service9TimeManagement.h
+8902;0x22c6;CLOCK_SET_FAILURE;LOW;Clock could not be set. P1: Returncode.;fsfw/src/fsfw/pus/Service9TimeManagement.h
+8903;0x22c7;CLOCK_DUMP;INFO;Clock dump event. P1: timeval seconds P2: timeval microseconds.;fsfw/src/fsfw/pus/Service9TimeManagement.h
+8904;0x22c8;CLOCK_DUMP_BEFORE_SETTING_TIME;INFO;No description;fsfw/src/fsfw/pus/Service9TimeManagement.h
+8905;0x22c9;CLOCK_DUMP_AFTER_SETTING_TIME;INFO;No description;fsfw/src/fsfw/pus/Service9TimeManagement.h
 9100;0x238c;TC_DELETION_FAILED;MEDIUM;Deletion of a TC from the map failed. P1: First 32 bit of request ID, P2. Last 32 bit of Request ID;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
 9700;0x25e4;TEST;INFO;No description;fsfw/src/fsfw/pus/Service17Test.h
 10600;0x2968;CHANGE_OF_SETUP_PARAMETER;LOW;No description;fsfw/src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.h
@@ -86,18 +89,28 @@ 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
+10805;0x2a35;HANDLING_CFDP_REQUEST_FAILED;LOW;CFDP request handling failed. P2: Returncode.;fsfw/src/fsfw/cfdp/handler/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
+11201;0x2bc1;RATE_RECOVERY;MEDIUM;The system has recovered from a 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
+11206;0x2bc6;PTG_CTRL_NO_ATTITUDE_INFORMATION;HIGH;For a prolonged time, no attitude information was available for the Pointing Controller. Falling back to Safe Mode.;mission/acs/defs.h
 11207;0x2bc7;SAFE_MODE_CONTROLLER_FAILURE;HIGH;The ACS safe mode controller was not able to compute a solution and has failed. P1: Missing information about magnetic field, P2: Missing information about rotational rate;mission/acs/defs.h
+11208;0x2bc8;TLE_TOO_OLD;INFO;The TLE for the SGP4 Propagator has become too old.;mission/acs/defs.h
+11209;0x2bc9;TLE_FILE_READ_FAILED;LOW;The TLE could not be read from the filesystem.;mission/acs/defs.h
+11210;0x2bca;PTG_RATE_VIOLATION;MEDIUM;The limits for the rotation in pointing mode were violated.;mission/acs/defs.h
+11211;0x2bcb;DETUMBLE_TRANSITION_FAILED;HIGH;The detumble transition has failed. //! P1: Last detumble state before failure.;mission/acs/defs.h
 11300;0x2c24;SWITCH_CMD_SENT;INFO;Indicates that a FSFW object requested setting a switch P1: 1 if on was requested, 0 for off | P2: Switch Index;mission/power/defs.h
 11301;0x2c25;SWITCH_HAS_CHANGED;INFO;Indicated that a switch state has changed P1: New switch state, 1 for on, 0 for off | P2: Switch Index;mission/power/defs.h
 11302;0x2c26;SWITCHING_Q7S_DENIED;MEDIUM;No description;mission/power/defs.h
 11303;0x2c27;FDIR_REACTION_IGNORED;MEDIUM;No description;mission/power/defs.h
+11304;0x2c28;DATASET_READ_FAILED;INFO;The dataset read for the inputs of the Power Controller has failed.;mission/power/defs.h
+11305;0x2c29;VOLTAGE_OUT_OF_BOUNDS;HIGH;No description;mission/power/defs.h
+11306;0x2c2a;TIMEDELTA_OUT_OF_BOUNDS;LOW;Time difference for Coulomb Counter was too large. P1: time in s * 10;mission/power/defs.h
+11307;0x2c2b;POWER_LEVEL_LOW;HIGH;The State of Charge is below the limit for payload use. Setting Payload to faulty.;mission/power/defs.h
+11308;0x2c2c;POWER_LEVEL_CRITICAL;HIGH;The State of Charge is below the limit for higher modes. Setting Reaction Wheels to faulty.;mission/power/defs.h
 11400;0x2c88;GPIO_PULL_HIGH_FAILED;LOW;No description;mission/tcs/HeaterHandler.h
 11401;0x2c89;GPIO_PULL_LOW_FAILED;LOW;No description;mission/tcs/HeaterHandler.h
 11402;0x2c8a;HEATER_WENT_ON;INFO;No description;mission/tcs/HeaterHandler.h
@@ -121,6 +134,8 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 11604;0x2d54;MPSOC_HANDLER_CRC_FAILURE;LOW;PLOC reply has invalid crc;linux/payload/PlocMpsocHandler.h
 11605;0x2d55;MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH;LOW;Packet sequence count in received space packet does not match expected count P1: Expected sequence count P2: Received sequence count;linux/payload/PlocMpsocHandler.h
 11606;0x2d56;MPSOC_SHUTDOWN_FAILED;HIGH;Supervisor fails to shutdown MPSoC. Requires to power off the PLOC and thus also to shutdown the supervisor.;linux/payload/PlocMpsocHandler.h
+11607;0x2d57;SUPV_NOT_ON;LOW;SUPV not on for boot or shutdown process. P1: 0 for OFF transition, 1 for ON transition.;linux/payload/PlocMpsocHandler.h
+11608;0x2d58;SUPV_REPLY_TIMEOUT;LOW;No description;linux/payload/PlocMpsocHandler.h
 11701;0x2db5;SELF_TEST_I2C_FAILURE;LOW;Get self test result returns I2C failure P1: Indicates on which axis the failure occurred. 0 -> INIT, 1 -> +X, 2 -> -X, 3 -> +Y, 4 -> -Y, 5 -> +Z, 6 -> -Z, 7 -> FINA;mission/acs/ImtqHandler.h
 11702;0x2db6;SELF_TEST_SPI_FAILURE;LOW;Get self test result returns SPI failure. This concerns the MTM connectivity. P1: Indicates on which axis the failure occurred. 0 -> INIT, 1 -> +X, 2 -> -X, 3 -> +Y, 4 -> -Y, 5 -> +Z, 6 -> -Z, 7 -> FINA;mission/acs/ImtqHandler.h
 11703;0x2db7;SELF_TEST_ADC_FAILURE;LOW;Get self test result returns failure in measurement of current and temperature. P1: Indicates on which axis the failure occurred. 0 -> INIT, 1 -> +X, 2 -> -X, 3 -> +Y, 4 -> -Y, 5 -> +Z, 6 -> -Z, 7 -> FINA;mission/acs/ImtqHandler.h
@@ -133,14 +148,17 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 11802;0x2e1a;RESET_OCCURED;LOW;No description;mission/acs/rwHelpers.h
 11901;0x2e7d;BOOTING_FIRMWARE_FAILED_EVENT;LOW;Failed to boot firmware;mission/acs/str/StarTrackerHandler.h
 11902;0x2e7e;BOOTING_BOOTLOADER_FAILED_EVENT;LOW;Failed to boot star tracker into bootloader mode;mission/acs/str/StarTrackerHandler.h
-12001;0x2ee1;SUPV_MEMORY_READ_RPT_CRC_FAILURE;LOW;PLOC supervisor crc failure in telemetry packet;linux/payload/PlocSupervisorHandler.h
-12002;0x2ee2;SUPV_UNKNOWN_TM;LOW;Unhandled event. P1: APID, P2: Service ID;linux/payload/PlocSupervisorHandler.h
-12003;0x2ee3;SUPV_UNINIMPLEMENTED_TM;LOW;No description;linux/payload/PlocSupervisorHandler.h
-12004;0x2ee4;SUPV_ACK_FAILURE;LOW;PLOC supervisor received acknowledgment failure report;linux/payload/PlocSupervisorHandler.h
-12005;0x2ee5;SUPV_EXE_FAILURE;LOW;PLOC received execution failure report P1: ID of command for which the execution failed P2: Status code sent by the supervisor handler;linux/payload/PlocSupervisorHandler.h
-12006;0x2ee6;SUPV_CRC_FAILURE_EVENT;LOW;PLOC supervisor reply has invalid crc;linux/payload/PlocSupervisorHandler.h
-12007;0x2ee7;SUPV_HELPER_EXECUTING;LOW;Supervisor helper currently executing a command;linux/payload/PlocSupervisorHandler.h
-12008;0x2ee8;SUPV_MPSOC_SHUTDOWN_BUILD_FAILED;LOW;Failed to build the command to shutdown the MPSoC;linux/payload/PlocSupervisorHandler.h
+11903;0x2e7f;COM_ERROR_REPLY_RECEIVED;LOW;Received COM error. P1:  Communication Error ID (datasheet p32);mission/acs/str/StarTrackerHandler.h
+12001;0x2ee1;SUPV_MEMORY_READ_RPT_CRC_FAILURE;LOW;PLOC supervisor crc failure in telemetry packet;linux/payload/plocSupvDefs.h
+12002;0x2ee2;SUPV_UNKNOWN_TM;LOW;Unhandled event. P1: APID, P2: Service ID;linux/payload/plocSupvDefs.h
+12003;0x2ee3;SUPV_UNINIMPLEMENTED_TM;LOW;No description;linux/payload/plocSupvDefs.h
+12004;0x2ee4;SUPV_ACK_FAILURE;LOW;PLOC supervisor received acknowledgment failure report;linux/payload/plocSupvDefs.h
+12005;0x2ee5;SUPV_EXE_FAILURE;LOW;PLOC received execution failure report P1: ID of command for which the execution failed P2: Status code sent by the supervisor handler;linux/payload/plocSupvDefs.h
+12006;0x2ee6;SUPV_CRC_FAILURE_EVENT;LOW;PLOC supervisor reply has invalid crc;linux/payload/plocSupvDefs.h
+12007;0x2ee7;SUPV_HELPER_EXECUTING;LOW;Supervisor helper currently executing a command;linux/payload/plocSupvDefs.h
+12008;0x2ee8;SUPV_MPSOC_SHUTDOWN_BUILD_FAILED;LOW;Failed to build the command to shutdown the MPSoC;linux/payload/plocSupvDefs.h
+12009;0x2ee9;SUPV_ACK_UNKNOWN_COMMAND;LOW;Received ACK, but no related command is unknown or has not been sent  by this software instance. P1: Module APID. P2: Service ID.;linux/payload/plocSupvDefs.h
+12010;0x2eea;SUPV_EXE_ACK_UNKNOWN_COMMAND;LOW;Received ACK EXE, but no related command is unknown or has not been sent  by this software instance. P1: Module APID. P2: Service ID.;linux/payload/plocSupvDefs.h
 12100;0x2f44;SANITIZATION_FAILED;LOW;No description;bsp_q7s/fs/SdCardManager.h
 12101;0x2f45;MOUNTED_SD_CARD;INFO;No description;bsp_q7s/fs/SdCardManager.h
 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
@@ -160,6 +178,7 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 12412;0x307c;PDEC_RESET_FAILED;HIGH;Failed to pull PDEC reset to low;linux/ipcore/pdec.h
 12413;0x307d;OPEN_IRQ_FILE_FAILED;HIGH;Failed to open the IRQ uio file;linux/ipcore/pdec.h
 12414;0x307e;PDEC_INIT_FAILED;HIGH;PDEC initialization failed. This might also be due to the persistent confiuration never becoming available, for example due to SD card issues.;linux/ipcore/pdec.h
+12415;0x307f;PDEC_CONFIG_CORRUPTED;HIGH;The PDEC configuration area has been corrupted P1: The first configuration word P2: The second configuration word;linux/ipcore/pdec.h
 12500;0x30d4;IMAGE_UPLOAD_FAILED;LOW;Image upload failed;linux/acs/StrComHandler.h
 12501;0x30d5;IMAGE_DOWNLOAD_FAILED;LOW;Image download failed;linux/acs/StrComHandler.h
 12502;0x30d6;IMAGE_UPLOAD_SUCCESSFUL;LOW;Uploading image to star tracker was successfulop;linux/acs/StrComHandler.h
@@ -217,8 +236,9 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 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/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
+13100;0x332c;GPS_FIX_CHANGE;INFO;Fix has changed. P1: New fix. P2: Missed fix changes 0: Not seen, 1: No Fix, 2: 2D-Fix, 3: 3D-Fix;linux/acs/GPSDefinitions.h
+13101;0x332d;CANT_GET_FIX;MEDIUM;Could not get fix in maximum allowed time. Trying to reset both GNSS devices. P1: Maximum allowed time to get a fix after the GPS was switched on.;linux/acs/GPSDefinitions.h
+13102;0x332e;RESET_FAIL;HIGH;Failed to reset an GNNS Device. P1: Board-Side.;linux/acs/GPSDefinitions.h
 13200;0x3390;P60_BOOT_COUNT;INFO;P60 boot count is broadcasted once at SW startup. P1: Boot count;mission/power/P60DockHandler.h
 13201;0x3391;BATT_MODE;INFO;Battery mode is broadcasted at startup. P1: Mode;mission/power/P60DockHandler.h
 13202;0x3392;BATT_MODE_CHANGED;MEDIUM;Battery mode has changed. P1: Old mode. P2: New mode;mission/power/P60DockHandler.h
@@ -254,6 +274,7 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 13800;0x35e8;MISSING_PACKET;LOW;No description;mission/payload/scexHelpers.h
 13801;0x35e9;EXPERIMENT_TIMEDOUT;LOW;No description;mission/payload/scexHelpers.h
 13802;0x35ea;MULTI_PACKET_COMMAND_DONE;INFO;No description;mission/payload/scexHelpers.h
+13803;0x35eb;FS_UNUSABLE;LOW;No description;mission/payload/scexHelpers.h
 13901;0x364d;SET_CONFIGFILEVALUE_FAILED;MEDIUM;No description;mission/utility/GlobalConfigHandler.h
 13902;0x364e;GET_CONFIGFILEVALUE_FAILED;MEDIUM;No description;mission/utility/GlobalConfigHandler.h
 13903;0x364f;INSERT_CONFIGFILEVALUE_FAILED;MEDIUM;No description;mission/utility/GlobalConfigHandler.h
@@ -272,6 +293,7 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 14011;0x36bb;I2C_REBOOT;HIGH;I2C is unavailable. Recovery did not work, performing full reboot.;mission/sysDefs.h
 14012;0x36bc;PDEC_REBOOT;HIGH;PDEC recovery through reset was not possible, performing full reboot.;mission/sysDefs.h
 14013;0x36bd;FIRMWARE_INFO;INFO;Version information of the firmware (not OBSW). P1: Byte 0: Major, Byte 1: Minor, Byte 2: Patch, Byte 3: Has Git Hash P2: First four letters of Git SHA is the last byte of P1 is set.;mission/sysDefs.h
+14014;0x36be;ACTIVE_SD_INFO;INFO;Active SD card info. SD States: 0: OFF, 1: ON, 2: MOUNTED. P1: Active SD Card Index, 0 if none is active P2: First two bytes: SD state of SD card 0, last two bytes SD state of SD card 1;mission/sysDefs.h
 14100;0x3714;NO_VALID_SENSOR_TEMPERATURE;MEDIUM;No description;mission/controller/tcsDefs.h
 14101;0x3715;NO_HEALTHY_HEATER_AVAILABLE;MEDIUM;No description;mission/controller/tcsDefs.h
 14102;0x3716;SYRLINKS_OVERHEATING;HIGH;No description;mission/controller/tcsDefs.h
@@ -280,6 +302,9 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 14106;0x371a;PCDU_SYSTEM_OVERHEATING;HIGH;No description;mission/controller/tcsDefs.h
 14107;0x371b;HEATER_NOT_OFF_FOR_OFF_MODE;MEDIUM;No description;mission/controller/tcsDefs.h
 14108;0x371c;MGT_OVERHEATING;HIGH;No description;mission/controller/tcsDefs.h
+14109;0x371d;TCS_SWITCHING_HEATER_ON;INFO;P1: Module index. P2: Heater index;mission/controller/tcsDefs.h
+14110;0x371e;TCS_SWITCHING_HEATER_OFF;INFO;P1: Module index. P2: Heater index;mission/controller/tcsDefs.h
+14111;0x371f;TCS_HEATER_MAX_BURN_TIME_REACHED;MEDIUM;P1: Heater index. P2: Maximum burn time for heater.;mission/controller/tcsDefs.h
 14201;0x3779;TX_TIMER_EXPIRED;INFO;The transmit timer to protect the Syrlinks expired P1: The current timer value;mission/system/com/ComSubsystem.h
 14202;0x377a;BIT_LOCK_TX_ON;INFO;Transmitter will be turned on due to detection of bitlock;mission/system/com/ComSubsystem.h
 14300;0x37dc;POSSIBLE_FILE_CORRUPTION;LOW;P1: Result code of TM packet parser. P2: Timestamp of possibly corrupt file as a unix timestamp.;mission/persistentTmStoreDefs.h
@@ -295,3 +320,6 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 14312;0x37e8;DUMP_MISC_CANCELLED;LOW;P1: Number of dumped packets. P2: Total dumped bytes.;mission/persistentTmStoreDefs.h
 14313;0x37e9;DUMP_HK_CANCELLED;LOW;P1: Number of dumped packets. P2: Total dumped bytes.;mission/persistentTmStoreDefs.h
 14314;0x37ea;DUMP_CFDP_CANCELLED;LOW;P1: Number of dumped packets. P2: Total dumped bytes.;mission/persistentTmStoreDefs.h
+14500;0x38a4;TEMPERATURE_ALL_ONES_START;MEDIUM;Detected invalid values, starting invalid message counting;mission/acs/SusHandler.h
+14501;0x38a5;TEMPERATURE_ALL_ONES_RECOVERY;INFO;Detected valid values for a prolonged time again, resetting all counters. P1: Number of periods with invalid messages. P2: Maximum invalid message counter.;mission/acs/SusHandler.h
+14600;0x3908;FAULT_HANDLER_TRIGGERED;LOW;P1: CFDP fault handler code. P2: CFDP condition code.;mission/cfdp/defs.h

generators/bsp_q7s_objects.csv

@@ -1,7 +1,9 @@
 0x00005060;P60DOCK_TEST_TASK
 0x43000002;ACS_CONTROLLER
 0x43000003;CORE_CONTROLLER
+0x43000004;POWER_CONTROLLER
 0x43000006;GLOBAL_JSON_CFG
+0x43000007;XIPHOS_WDT
 0x43400001;THERMAL_CONTROLLER
 0x44120006;MGM_0_LIS3_HANDLER
 0x44120010;GYRO_0_ADIS_HANDLER
@@ -156,11 +158,13 @@
 0x73000102;CFDP_TM_FUNNEL
 0x73000205;CFDP_HANDLER
 0x73000206;CFDP_DISTRIBUTOR
+0x73000207;CFDP_FAULT_HANDLER
 0x73010000;EIVE_SYSTEM
 0x73010001;ACS_SUBSYSTEM
 0x73010002;PL_SUBSYSTEM
 0x73010003;TCS_SUBSYSTEM
 0x73010004;COM_SUBSYSTEM
+0x73010005;EPS_SUBSYSTEM
 0x73020001;MISC_TM_STORE
 0x73020002;OK_TM_STORE
 0x73020003;NOT_OK_TM_STORE

generators/bsp_q7s_returnvalues.csv

@@ -210,6 +210,7 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x27a8;DHI_NoReplyExpected;No description;168;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
 0x27a9;DHI_NonOpTemperature;No description;169;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
 0x27aa;DHI_CommandNotImplemented;No description;170;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
+0x27ab;DHI_NonOpStateOfCharge;No description;171;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
 0x27b0;DHI_ChecksumError;No description;176;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
 0x27b1;DHI_LengthMissmatch;No description;177;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
 0x27b2;DHI_InvalidData;No description;178;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
@@ -322,289 +323,307 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x3405;DC_NotActive;No description;5;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
 0x3406;DC_TooMuchData;No description;6;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
 0x3407;DC_Busy;No description;7;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
-0x3601;CFDP_InvalidTlvType;No description;1;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3602;CFDP_InvalidDirectiveField;No description;2;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3603;CFDP_InvalidPduDatafieldLen;No description;3;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3604;CFDP_InvalidAckDirectiveFields;No description;4;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3605;CFDP_MetadataCantParseOptions;No description;5;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3606;CFDP_NakCantParseOptions;No description;6;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3607;CFDP_FinishedCantParseFsResponses;No description;7;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3608;CFDP_FilestoreRequiresSecondFile;No description;8;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3609;CFDP_FilestoreResponseCantParseFsMessage;No description;9;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x360a;CFDP_InvalidPduFormat;No description;10;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3701;TSI_BadTimestamp;No description;1;TIME_STAMPER_IF;fsfw/src/fsfw/timemanager/TimeStampIF.h
-0x38a1;SGP4_InvalidEccentricity;No description;161;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x38a2;SGP4_InvalidMeanMotion;No description;162;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x38a3;SGP4_InvalidPerturbationElements;No description;163;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x38a4;SGP4_InvalidSemiLatusRectum;No description;164;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x38a5;SGP4_InvalidEpochElements;No description;165;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x38a6;SGP4_SatelliteHasDecayed;No description;166;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x38b1;SGP4_TleTooOld;No description;177;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x38b2;SGP4_TleNotInitialized;No description;178;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x3901;MUX_NotEnoughResources;No description;1;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3902;MUX_InsufficientMemory;No description;2;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3903;MUX_NoPrivilege;No description;3;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3904;MUX_WrongAttributeSetting;No description;4;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3905;MUX_MutexAlreadyLocked;No description;5;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3906;MUX_MutexNotFound;No description;6;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3907;MUX_MutexMaxLocks;No description;7;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3908;MUX_CurrThreadAlreadyOwnsMutex;No description;8;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3909;MUX_CurrThreadDoesNotOwnMutex;No description;9;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x390a;MUX_MutexTimeout;No description;10;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x390b;MUX_MutexInvalidId;No description;11;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x390c;MUX_MutexDestroyedWhileWaiting;No description;12;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3a01;MQI_Empty;No description;1;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
-0x3a02;MQI_Full;No space left for more messages;2;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
-0x3a03;MQI_NoReplyPartner;Returned if a reply method was called without partner;3;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
-0x3a04;MQI_DestinationInvalid;Returned if the target destination is invalid.;4;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
-0x3b00;SPH_ConnBroken;No description;0;SEMAPHORE_IF;fsfw/src/fsfw/osal/common/TcpTmTcServer.h
-0x3b01;SPH_SemaphoreTimeout;No description;1;SEMAPHORE_IF;fsfw/src/fsfw/tasks/SemaphoreIF.h
-0x3b02;SPH_SemaphoreNotOwned;No description;2;SEMAPHORE_IF;fsfw/src/fsfw/tasks/SemaphoreIF.h
-0x3b03;SPH_SemaphoreInvalid;No description;3;SEMAPHORE_IF;fsfw/src/fsfw/tasks/SemaphoreIF.h
-0x3c00;LPIF_PoolEntryNotFound;No description;0;LOCAL_POOL_OWNER_IF;fsfw/src/fsfw/datapoollocal/localPoolDefinitions.h
-0x3c01;LPIF_PoolEntryTypeConflict;No description;1;LOCAL_POOL_OWNER_IF;fsfw/src/fsfw/datapoollocal/localPoolDefinitions.h
-0x3da0;PVA_InvalidReadWriteMode;No description;160;POOL_VARIABLE_IF;fsfw/src/fsfw/datapool/PoolVariableIF.h
-0x3da1;PVA_InvalidPoolEntry;No description;161;POOL_VARIABLE_IF;fsfw/src/fsfw/datapool/PoolVariableIF.h
-0x3e00;HKM_QueueOrDestinationInvalid;No description;0;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
-0x3e01;HKM_WrongHkPacketType;No description;1;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
-0x3e02;HKM_ReportingStatusUnchanged;No description;2;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
-0x3e03;HKM_PeriodicHelperInvalid;No description;3;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
-0x3e04;HKM_PoolobjectNotFound;No description;4;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
-0x3e05;HKM_DatasetNotFound;No description;5;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
-0x3f01;DLEE_StreamTooShort;No description;1;DLE_ENCODER;fsfw/src/fsfw/globalfunctions/DleEncoder.h
-0x3f02;DLEE_DecodingError;No description;2;DLE_ENCODER;fsfw/src/fsfw/globalfunctions/DleEncoder.h
-0x4201;PUS11_InvalidTypeTimeWindow;No description;1;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
-0x4202;PUS11_InvalidTimeWindow;No description;2;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
-0x4203;PUS11_TimeshiftingNotPossible;No description;3;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
-0x4204;PUS11_InvalidRelativeTime;No description;4;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
-0x4205;PUS11_ContainedTcTooSmall;No description;5;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
-0x4206;PUS11_ContainedTcCrcMissmatch;No description;6;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
-0x4300;FILS_GenericFileError;No description;0;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4301;FILS_GenericDirError;No description;1;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4302;FILS_FilesystemInactive;No description;2;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4303;FILS_GenericRenameError;No description;3;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4304;FILS_IsBusy;No description;4;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4305;FILS_InvalidParameters;No description;5;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x430a;FILS_FileDoesNotExist;No description;10;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x430b;FILS_FileAlreadyExists;No description;11;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x430c;FILS_NotAFile;No description;12;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x430d;FILS_FileLocked;No description;13;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x430e;FILS_PermissionDenied;No description;14;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4315;FILS_DirectoryDoesNotExist;No description;21;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4316;FILS_DirectoryAlreadyExists;No description;22;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4317;FILS_NotADirectory;No description;23;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4318;FILS_DirectoryNotEmpty;No description;24;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x431e;FILS_SequencePacketMissingWrite;No description;30;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x431f;FILS_SequencePacketMissingRead;No description;31;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4400;UXOS_ExecutionFinished;Execution of the current command has finished;0;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
-0x4401;UXOS_CommandPending;Command is pending. This will also be returned if the user tries to load another command but a command is still pending;1;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
-0x4402;UXOS_BytesRead;Some bytes have been read from the executing process;2;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
-0x4403;UXOS_CommandError;Command execution failed;3;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
-0x4404;UXOS_NoCommandLoadedOrPending;;4;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
-0x4406;UXOS_PcloseCallError;No description;6;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
-0x4500;HSPI_OpeningFileFailed;No description;0;HAL_SPI;fsfw/src/fsfw_hal/common/spi/spiCommon.h
-0x4501;HSPI_FullDuplexTransferFailed;No description;1;HAL_SPI;fsfw/src/fsfw_hal/common/spi/spiCommon.h
-0x4502;HSPI_HalfDuplexTransferFailed;No description;2;HAL_SPI;fsfw/src/fsfw_hal/common/spi/spiCommon.h
-0x4503;HSPI_Timeout;No description;3;HAL_SPI;fsfw/src/fsfw_hal/common/spi/spiCommon.h
-0x4504;HSPI_Busy;No description;4;HAL_SPI;fsfw/src/fsfw_hal/common/spi/spiCommon.h
-0x4505;HSPI_GenericError;No description;5;HAL_SPI;fsfw/src/fsfw_hal/common/spi/spiCommon.h
-0x4601;HURT_UartReadFailure;No description;1;HAL_UART;fsfw/src/fsfw_hal/linux/serial/SerialComIF.h
-0x4602;HURT_UartReadSizeMissmatch;No description;2;HAL_UART;fsfw/src/fsfw_hal/linux/serial/SerialComIF.h
-0x4603;HURT_UartRxBufferTooSmall;No description;3;HAL_UART;fsfw/src/fsfw_hal/linux/serial/SerialComIF.h
-0x4801;HGIO_UnknownGpioId;No description;1;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x4802;HGIO_DriveGpioFailure;No description;2;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x4803;HGIO_GpioTypeFailure;No description;3;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x4804;HGIO_GpioInvalidInstance;No description;4;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x4805;HGIO_GpioDuplicateDetected;No description;5;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x4806;HGIO_GpioInitFailed;No description;6;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x4807;HGIO_GpioGetValueFailed;No description;7;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x4c00;SPPA_NoPacketFound;No description;0;SPACE_PACKET_PARSER;fsfw/src/fsfw/tmtcservices/SpacePacketParser.h
-0x4c01;SPPA_SplitPacket;No description;1;SPACE_PACKET_PARSER;fsfw/src/fsfw/tmtcservices/SpacePacketParser.h
-0x4fa1;HEATER_CommandNotSupported;No description;161;HEATER_HANDLER;mission/tcs/HeaterHandler.h
-0x4fa2;HEATER_InitFailed;No description;162;HEATER_HANDLER;mission/tcs/HeaterHandler.h
-0x4fa3;HEATER_InvalidSwitchNr;No description;163;HEATER_HANDLER;mission/tcs/HeaterHandler.h
-0x4fa4;HEATER_MainSwitchSetTimeout;No description;164;HEATER_HANDLER;mission/tcs/HeaterHandler.h
-0x4fa5;HEATER_CommandAlreadyWaiting;No description;165;HEATER_HANDLER;mission/tcs/HeaterHandler.h
-0x50a0;SYRLINKS_CrcFailure;No description;160;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
-0x50a1;SYRLINKS_UartFraminOrParityErrorAck;No description;161;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
-0x50a2;SYRLINKS_BadCharacterAck;No description;162;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
-0x50a3;SYRLINKS_BadParameterValueAck;No description;163;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
-0x50a4;SYRLINKS_BadEndOfFrameAck;No description;164;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
-0x50a5;SYRLINKS_UnknownCommandIdAck;No description;165;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
-0x50a6;SYRLINKS_BadCrcAck;No description;166;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
-0x50a7;SYRLINKS_ReplyWrongSize;No description;167;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
-0x50a8;SYRLINKS_MissingStartFrameCharacter;No description;168;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
-0x5100;IMTQ_InvalidCommandCode;No description;0;IMTQ_HANDLER;mission/acs/imtqHelpers.h
-0x5101;IMTQ_MgmMeasurementLowLevelError;No description;1;IMTQ_HANDLER;mission/acs/imtqHelpers.h
-0x5102;IMTQ_ActuateCmdLowLevelError;No description;2;IMTQ_HANDLER;mission/acs/imtqHelpers.h
-0x5103;IMTQ_ParameterMissing;No description;3;IMTQ_HANDLER;mission/acs/imtqHelpers.h
-0x5104;IMTQ_ParameterInvalid;No description;4;IMTQ_HANDLER;mission/acs/imtqHelpers.h
-0x5105;IMTQ_CcUnavailable;No description;5;IMTQ_HANDLER;mission/acs/imtqHelpers.h
-0x5106;IMTQ_InternalProcessingError;No description;6;IMTQ_HANDLER;mission/acs/imtqHelpers.h
-0x5107;IMTQ_RejectedWithoutReason;No description;7;IMTQ_HANDLER;mission/acs/imtqHelpers.h
-0x5108;IMTQ_CmdErrUnknown;No description;8;IMTQ_HANDLER;mission/acs/imtqHelpers.h
-0x5109;IMTQ_StartupCfgError;No description;9;IMTQ_HANDLER;mission/acs/imtqHelpers.h
-0x510a;IMTQ_UnexpectedSelfTestReply;The status reply to a self test command was received but no self test command has been sent. This should normally never happen.;10;IMTQ_HANDLER;mission/acs/imtqHelpers.h
-0x52b0;RWHA_SpiWriteFailure;No description;176;RW_HANDLER;mission/acs/rwHelpers.h
-0x52b1;RWHA_SpiReadFailure;Used by the spi send function to tell a failing read call;177;RW_HANDLER;mission/acs/rwHelpers.h
-0x52b2;RWHA_MissingStartSign;Can be used by the HDLC decoding mechanism to inform about a missing start sign 0x7E;178;RW_HANDLER;mission/acs/rwHelpers.h
-0x52b3;RWHA_InvalidSubstitute;Can be used by the HDLC decoding mechanism to inform about an invalid substitution combination;179;RW_HANDLER;mission/acs/rwHelpers.h
-0x52b4;RWHA_MissingEndSign;HDLC decoding mechanism never receives the end sign 0x7E;180;RW_HANDLER;mission/acs/rwHelpers.h
-0x52b5;RWHA_NoReply;Reaction wheel only responds with empty frames.;181;RW_HANDLER;mission/acs/rwHelpers.h
-0x52b6;RWHA_NoStartMarker;Expected a start marker as first byte;182;RW_HANDLER;mission/acs/rwHelpers.h
-0x52b7;RWHA_SpiReadTimeout;Timeout when reading reply;183;RW_HANDLER;mission/acs/rwHelpers.h
-0x53a0;STRH_TemperatureReqFailed;Status in temperature reply signals error;160;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53a1;STRH_PingFailed;Ping command failed;161;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53a2;STRH_VersionReqFailed;Status in version reply signals error;162;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53a3;STRH_InterfaceReqFailed;Status in interface reply signals error;163;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53a4;STRH_PowerReqFailed;Status in power reply signals error;164;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53a5;STRH_SetParamFailed;Status of reply to parameter set command signals error;165;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53a6;STRH_ActionFailed;Status of reply to action command signals error;166;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53a7;STRH_FilePathTooLong;Received invalid path string. Exceeds allowed length;167;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53a8;STRH_FilenameTooLong;Name of file received with command is too long;168;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53a9;STRH_InvalidProgram;Received version reply with invalid program ID;169;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53aa;STRH_ReplyError;Status field reply signals error;170;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53ab;STRH_CommandTooShort;Received command which is too short (some data is missing for proper execution);171;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53ac;STRH_InvalidLength;Received command with invalid length (too few or too many parameters);172;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53ad;STRH_RegionMismatch;Region mismatch between send and received data;173;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53ae;STRH_AddressMismatch;Address mismatch between send and received data;174;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53af;STRH_LengthMismatch;Length field mismatch between send and received data;175;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53b0;STRH_FileNotExists;Specified file does not exist;176;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53b1;STRH_InvalidType;Download blob pixel command has invalid type field;177;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53b2;STRH_InvalidId;Received FPGA action command with invalid ID;178;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53b3;STRH_ReplyTooShort;Received reply is too short;179;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53b4;STRH_CrcFailure;Received reply with invalid CRC;180;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53b5;STRH_StrHelperExecuting;Star tracker handler currently executing a command and using the communication interface;181;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-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/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
-0x5703;PLSPVhLP_PossiblePacketLossConsecutiveStart;No description;3;PLOC_SUPV_HELPER;linux/payload/PlocSupvUartMan.h
-0x5704;PLSPVhLP_PossiblePacketLossConsecutiveEnd;No description;4;PLOC_SUPV_HELPER;linux/payload/PlocSupvUartMan.h
-0x5705;PLSPVhLP_HdlcError;No description;5;PLOC_SUPV_HELPER;linux/payload/PlocSupvUartMan.h
-0x57a0;PLSPVhLP_FileClosedAccidentally;File accidentally close;160;PLOC_SUPV_HELPER;linux/payload/PlocSupvUartMan.h
-0x57a1;PLSPVhLP_ProcessTerminated;Process has been terminated by command;161;PLOC_SUPV_HELPER;linux/payload/PlocSupvUartMan.h
-0x57a2;PLSPVhLP_PathNotExists;Received command with invalid pathname;162;PLOC_SUPV_HELPER;linux/payload/PlocSupvUartMan.h
-0x57a3;PLSPVhLP_EventBufferReplyInvalidApid;Expected event buffer TM but received space packet with other APID;163;PLOC_SUPV_HELPER;linux/payload/PlocSupvUartMan.h
-0x58a0;SUSS_InvalidSpeed;Action Message with invalid speed was received. Valid speeds must be in the range of [-65000, 1000] or [1000, 65000];160;SUS_HANDLER;mission/acs/RwHandler.h
-0x58a1;SUSS_InvalidRampTime;Action Message with invalid ramp time was received.;161;SUS_HANDLER;mission/acs/RwHandler.h
-0x58a2;SUSS_SetSpeedCommandInvalidLength;Received set speed command has invalid length. Should be 6.;162;SUS_HANDLER;mission/acs/RwHandler.h
-0x58a3;SUSS_ExecutionFailed;Command execution failed;163;SUS_HANDLER;mission/acs/RwHandler.h
-0x58a4;SUSS_CrcError;Reaction wheel reply has invalid crc;164;SUS_HANDLER;mission/acs/RwHandler.h
-0x58a5;SUSS_ValueNotRead;No description;165;SUS_HANDLER;mission/acs/RwHandler.h
-0x59a0;IPCI_PapbBusy;No description;160;CCSDS_IP_CORE_BRIDGE;linux/ipcore/PapbVcInterface.h
-0x5aa0;PTME_UnknownVcId;No description;160;PTME;linux/ipcore/Ptme.h
-0x5c01;STRHLP_SdNotMounted;SD card specified in path string not mounted;1;STR_HELPER;linux/acs/StrComHandler.h
-0x5c02;STRHLP_FileNotExists;Specified file does not exist on filesystem;2;STR_HELPER;linux/acs/StrComHandler.h
-0x5c03;STRHLP_PathNotExists;Specified path does not exist;3;STR_HELPER;linux/acs/StrComHandler.h
-0x5c04;STRHLP_FileCreationFailed;Failed to create download image or read flash file;4;STR_HELPER;linux/acs/StrComHandler.h
-0x5c05;STRHLP_RegionMismatch;Region in flash write/read reply does not match expected region;5;STR_HELPER;linux/acs/StrComHandler.h
-0x5c06;STRHLP_AddressMismatch;Address in flash write/read reply does not match expected address;6;STR_HELPER;linux/acs/StrComHandler.h
-0x5c07;STRHLP_LengthMismatch;Length in flash write/read reply does not match expected length;7;STR_HELPER;linux/acs/StrComHandler.h
-0x5c08;STRHLP_StatusError;Status field in reply signals error;8;STR_HELPER;linux/acs/StrComHandler.h
-0x5c09;STRHLP_InvalidTypeId;Reply has invalid type ID (should be of action reply type);9;STR_HELPER;linux/acs/StrComHandler.h
-0x5c0a;STRHLP_ReceptionTimeout;No description;10;STR_HELPER;linux/acs/StrComHandler.h
-0x5c0b;STRHLP_DecodingError;No description;11;STR_HELPER;linux/acs/StrComHandler.h
-0x5d00;GOMS_PacketTooLong;No description;0;GOM_SPACE_HANDLER;mission/power/GomspaceDeviceHandler.h
-0x5d01;GOMS_InvalidTableId;No description;1;GOM_SPACE_HANDLER;mission/power/GomspaceDeviceHandler.h
-0x5d02;GOMS_InvalidAddress;No description;2;GOM_SPACE_HANDLER;mission/power/GomspaceDeviceHandler.h
-0x5d03;GOMS_InvalidParamSize;No description;3;GOM_SPACE_HANDLER;mission/power/GomspaceDeviceHandler.h
-0x5d04;GOMS_InvalidPayloadSize;No description;4;GOM_SPACE_HANDLER;mission/power/GomspaceDeviceHandler.h
-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/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
-0x61a2;RS_ClkInversionFailed;Failed to invert clock and thus change the time the data is updated with respect to the tx clock;162;RATE_SETTER;linux/ipcore/PtmeConfig.h
-0x61a3;RS_TxManipulatorConfigFailed;Failed to change configuration bit of tx clock manipulator;163;RATE_SETTER;linux/ipcore/PtmeConfig.h
-0x6201;JSONBASE_JsonFileNotExists;Specified json file does not exist;1;ARCSEC_JSON_BASE;mission/acs/str/ArcsecJsonParamBase.h
-0x6202;JSONBASE_SetNotExists;Requested set does not exist in json file;2;ARCSEC_JSON_BASE;mission/acs/str/ArcsecJsonParamBase.h
-0x6203;JSONBASE_ParamNotExists;Requested parameter does not exist in json file;3;ARCSEC_JSON_BASE;mission/acs/str/ArcsecJsonParamBase.h
-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_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
-0x66a3;SADPL_SwitchingDeplSa1Failed;No description;163;SA_DEPL_HANDLER;mission/SolarArrayDeploymentHandler.h
-0x66a4;SADPL_SwitchingDeplSa2Failed;No description;164;SA_DEPL_HANDLER;mission/SolarArrayDeploymentHandler.h
-0x67a0;MPSOCRTVIF_CrcFailure;Space Packet received from PLOC has invalid CRC;160;MPSOC_RETURN_VALUES_IF;linux/payload/mpsocRetvals.h
-0x67a1;MPSOCRTVIF_ReceivedAckFailure;Received ACK failure reply from PLOC;161;MPSOC_RETURN_VALUES_IF;linux/payload/mpsocRetvals.h
-0x67a2;MPSOCRTVIF_ReceivedExeFailure;Received execution failure reply from PLOC;162;MPSOC_RETURN_VALUES_IF;linux/payload/mpsocRetvals.h
-0x67a3;MPSOCRTVIF_InvalidApid;Received space packet with invalid APID from PLOC;163;MPSOC_RETURN_VALUES_IF;linux/payload/mpsocRetvals.h
-0x67a4;MPSOCRTVIF_InvalidLength;Received command with invalid length;164;MPSOC_RETURN_VALUES_IF;linux/payload/mpsocRetvals.h
-0x67a5;MPSOCRTVIF_FilenameTooLong;Filename of file in OBC filesystem is too long;165;MPSOC_RETURN_VALUES_IF;linux/payload/mpsocRetvals.h
-0x67a6;MPSOCRTVIF_MpsocHelperExecuting;MPSoC helper is currently executing a command;166;MPSOC_RETURN_VALUES_IF;linux/payload/mpsocRetvals.h
-0x67a7;MPSOCRTVIF_MpsocFilenameTooLong;Filename of MPSoC file is to long (max. 256 bytes);167;MPSOC_RETURN_VALUES_IF;linux/payload/mpsocRetvals.h
-0x67a8;MPSOCRTVIF_InvalidParameter;Command has invalid parameter;168;MPSOC_RETURN_VALUES_IF;linux/payload/mpsocRetvals.h
-0x67a9;MPSOCRTVIF_NameTooLong;Received command has file string with invalid length;169;MPSOC_RETURN_VALUES_IF;linux/payload/mpsocRetvals.h
-0x68a0;SPVRTVIF_CrcFailure;Space Packet received from PLOC supervisor has invalid CRC;160;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
-0x68a1;SPVRTVIF_InvalidServiceId;No description;161;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
-0x68a2;SPVRTVIF_ReceivedAckFailure;Received ACK failure reply from PLOC supervisor;162;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
-0x68a3;SPVRTVIF_ReceivedExeFailure;Received execution failure reply from PLOC supervisor;163;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
-0x68a4;SPVRTVIF_InvalidApid;Received space packet with invalid APID from PLOC supervisor;164;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
-0x68a5;SPVRTVIF_GetTimeFailure;Failed to read current system time;165;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
-0x68a6;SPVRTVIF_InvalidWatchdog;Received command with invalid watchdog parameter. Valid watchdogs are 0 for PS, 1 for PL and 2 for INT;166;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
-0x68a7;SPVRTVIF_InvalidWatchdogTimeout;Received watchdog timeout config command with invalid timeout. Valid timeouts must be in the range between 1000 and 360000 ms.;167;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
-0x68a8;SPVRTVIF_InvalidLatchupId;Received latchup config command with invalid latchup ID;168;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
-0x68a9;SPVRTVIF_SweepPeriodTooSmall;Received set adc sweep period command with invalid sweep period. Must be larger than 21.;169;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
-0x68aa;SPVRTVIF_InvalidTestParam;Receive auto EM test command with invalid test param. Valid params are 1 and 2.;170;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
-0x68ab;SPVRTVIF_MramPacketParsingFailure;Returned when scanning for MRAM dump packets failed.;171;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
-0x68ac;SPVRTVIF_InvalidMramAddresses;Returned when the start and stop addresses of the MRAM dump or MRAM  wipe commands are invalid (e.g. start address bigger than stop address);172;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
-0x68ad;SPVRTVIF_NoMramPacket;Expect reception of an MRAM dump packet but received space packet with other apid.;173;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
-0x68ae;SPVRTVIF_PathDoesNotExist;Path to PLOC directory on SD card does not exist;174;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
-0x68af;SPVRTVIF_MramFileNotExists;MRAM dump file does not exists. The file should actually already have been created with the reception of the first dump packet.;175;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
-0x68b0;SPVRTVIF_InvalidReplyLength;No description;176;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
-0x68b1;SPVRTVIF_InvalidLength;Received action command has invalid length;177;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
-0x68b2;SPVRTVIF_FilenameTooLong;Filename too long;178;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
-0x68b3;SPVRTVIF_UpdateStatusReportInvalidLength;Received update status report with invalid packet length field;179;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
-0x68b4;SPVRTVIF_UpdateCrcFailure;Update status report does not contain expected CRC. There might be a bit flip in the update memory region.;180;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
-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;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
-0x6a05;ACSMEKF_MekfNoSusMgmStrData;No description;5;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
-0x6a06;ACSMEKF_MekfCovarianceInversionFailed;No description;6;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
-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
-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
+0x3601;CFDP_InvalidTlvType;No description;1;CFDP_BASE;fsfw/src/fsfw/cfdp/definitions.h
+0x3602;CFDP_InvalidDirectiveField;No description;2;CFDP_BASE;fsfw/src/fsfw/cfdp/definitions.h
+0x3603;CFDP_InvalidPduDatafieldLen;No description;3;CFDP_BASE;fsfw/src/fsfw/cfdp/definitions.h
+0x3604;CFDP_InvalidAckDirectiveFields;No description;4;CFDP_BASE;fsfw/src/fsfw/cfdp/definitions.h
+0x3605;CFDP_MetadataCantParseOptions;No description;5;CFDP_BASE;fsfw/src/fsfw/cfdp/definitions.h
+0x3606;CFDP_NakCantParseOptions;No description;6;CFDP_BASE;fsfw/src/fsfw/cfdp/definitions.h
+0x3607;CFDP_FinishedCantParseFsResponses;No description;7;CFDP_BASE;fsfw/src/fsfw/cfdp/definitions.h
+0x3608;CFDP_FilestoreRequiresSecondFile;No description;8;CFDP_BASE;fsfw/src/fsfw/cfdp/definitions.h
+0x3609;CFDP_FilestoreResponseCantParseFsMessage;No description;9;CFDP_BASE;fsfw/src/fsfw/cfdp/definitions.h
+0x360a;CFDP_InvalidPduFormat;No description;10;CFDP_BASE;fsfw/src/fsfw/cfdp/definitions.h
+0x3700;CFDP_SourceTransactionPending;No description;0;CFDP_HANDLER;fsfw/src/fsfw/cfdp/handler/defs.h
+0x3701;CFDP_FileDoesNotExist;No description;1;CFDP_HANDLER;fsfw/src/fsfw/cfdp/handler/defs.h
+0x3702;CFDP_FileSegmentLenInvalid;No description;2;CFDP_HANDLER;fsfw/src/fsfw/cfdp/handler/defs.h
+0x3703;CFDP_SourceNameEmpty;No description;3;CFDP_HANDLER;fsfw/src/fsfw/cfdp/handler/defs.h
+0x3704;CFDP_DestNameEmpty;No description;4;CFDP_HANDLER;fsfw/src/fsfw/cfdp/handler/defs.h
+0x3705;CFDP_WrongRemoteCfgEntityId;No description;5;CFDP_HANDLER;fsfw/src/fsfw/cfdp/handler/defs.h
+0x3706;CFDP_TargetMsgQueueFull;No description;6;CFDP_HANDLER;fsfw/src/fsfw/cfdp/handler/defs.h
+0x3707;CFDP_TmStoreFull;No description;7;CFDP_HANDLER;fsfw/src/fsfw/cfdp/handler/defs.h
+0x3801;TSI_BadTimestamp;No description;1;TIME_STAMPER_IF;fsfw/src/fsfw/timemanager/TimeStampIF.h
+0x39a1;SGP4_InvalidEccentricity;No description;161;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x39a2;SGP4_InvalidMeanMotion;No description;162;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x39a3;SGP4_InvalidPerturbationElements;No description;163;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x39a4;SGP4_InvalidSemiLatusRectum;No description;164;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x39a5;SGP4_InvalidEpochElements;No description;165;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x39a6;SGP4_SatelliteHasDecayed;No description;166;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x39b1;SGP4_TleTooOld;No description;177;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x39b2;SGP4_TleNotInitialized;No description;178;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x3a01;MUX_NotEnoughResources;No description;1;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3a02;MUX_InsufficientMemory;No description;2;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3a03;MUX_NoPrivilege;No description;3;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3a04;MUX_WrongAttributeSetting;No description;4;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3a05;MUX_MutexAlreadyLocked;No description;5;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3a06;MUX_MutexNotFound;No description;6;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3a07;MUX_MutexMaxLocks;No description;7;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3a08;MUX_CurrThreadAlreadyOwnsMutex;No description;8;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3a09;MUX_CurrThreadDoesNotOwnMutex;No description;9;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3a0a;MUX_MutexTimeout;No description;10;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3a0b;MUX_MutexInvalidId;No description;11;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3a0c;MUX_MutexDestroyedWhileWaiting;No description;12;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3b01;MQI_Empty;No description;1;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
+0x3b02;MQI_Full;No space left for more messages;2;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
+0x3b03;MQI_NoReplyPartner;Returned if a reply method was called without partner;3;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
+0x3b04;MQI_DestinationInvalid;Returned if the target destination is invalid.;4;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
+0x3c01;SPH_SemaphoreTimeout;No description;1;SEMAPHORE_IF;fsfw/src/fsfw/tasks/SemaphoreIF.h
+0x3c02;SPH_SemaphoreNotOwned;No description;2;SEMAPHORE_IF;fsfw/src/fsfw/tasks/SemaphoreIF.h
+0x3c03;SPH_SemaphoreInvalid;No description;3;SEMAPHORE_IF;fsfw/src/fsfw/tasks/SemaphoreIF.h
+0x3d00;LPIF_PoolEntryNotFound;No description;0;LOCAL_POOL_OWNER_IF;fsfw/src/fsfw/datapoollocal/localPoolDefinitions.h
+0x3d01;LPIF_PoolEntryTypeConflict;No description;1;LOCAL_POOL_OWNER_IF;fsfw/src/fsfw/datapoollocal/localPoolDefinitions.h
+0x3ea0;PVA_InvalidReadWriteMode;No description;160;POOL_VARIABLE_IF;fsfw/src/fsfw/datapool/PoolVariableIF.h
+0x3ea1;PVA_InvalidPoolEntry;No description;161;POOL_VARIABLE_IF;fsfw/src/fsfw/datapool/PoolVariableIF.h
+0x3f00;HKM_QueueOrDestinationInvalid;No description;0;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
+0x3f01;HKM_WrongHkPacketType;No description;1;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
+0x3f02;HKM_ReportingStatusUnchanged;No description;2;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
+0x3f03;HKM_PeriodicHelperInvalid;No description;3;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
+0x3f04;HKM_PoolobjectNotFound;No description;4;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
+0x3f05;HKM_DatasetNotFound;No description;5;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
+0x4001;DLEE_StreamTooShort;No description;1;DLE_ENCODER;fsfw/src/fsfw/globalfunctions/DleEncoder.h
+0x4002;DLEE_DecodingError;No description;2;DLE_ENCODER;fsfw/src/fsfw/globalfunctions/DleEncoder.h
+0x4301;PUS11_InvalidTypeTimeWindow;No description;1;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
+0x4302;PUS11_InvalidTimeWindow;No description;2;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
+0x4303;PUS11_TimeshiftingNotPossible;No description;3;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
+0x4304;PUS11_InvalidRelativeTime;No description;4;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
+0x4305;PUS11_ContainedTcTooSmall;No description;5;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
+0x4306;PUS11_ContainedTcCrcMissmatch;No description;6;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
+0x4307;PUS11_MapIsFull;No description;7;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
+0x4400;FILS_GenericFileError;No description;0;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4401;FILS_GenericDirError;No description;1;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4402;FILS_FilesystemInactive;No description;2;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4403;FILS_GenericRenameError;No description;3;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4404;FILS_IsBusy;No description;4;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4405;FILS_InvalidParameters;No description;5;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x440a;FILS_FileDoesNotExist;No description;10;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x440b;FILS_FileAlreadyExists;No description;11;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x440c;FILS_NotAFile;No description;12;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x440d;FILS_FileLocked;No description;13;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x440e;FILS_PermissionDenied;No description;14;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4415;FILS_DirectoryDoesNotExist;No description;21;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4416;FILS_DirectoryAlreadyExists;No description;22;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4417;FILS_NotADirectory;No description;23;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4418;FILS_DirectoryNotEmpty;No description;24;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x441e;FILS_SequencePacketMissingWrite;No description;30;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x441f;FILS_SequencePacketMissingRead;No description;31;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4500;UXOS_ExecutionFinished;Execution of the current command has finished;0;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
+0x4501;UXOS_CommandPending;Command is pending. This will also be returned if the user tries to load another command but a command is still pending;1;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
+0x4502;UXOS_BytesRead;Some bytes have been read from the executing process;2;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
+0x4503;UXOS_CommandError;Command execution failed;3;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
+0x4504;UXOS_NoCommandLoadedOrPending;;4;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
+0x4506;UXOS_PcloseCallError;No description;6;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
+0x4600;HSPI_OpeningFileFailed;No description;0;HAL_SPI;fsfw/src/fsfw_hal/common/spi/spiCommon.h
+0x4601;HSPI_FullDuplexTransferFailed;No description;1;HAL_SPI;fsfw/src/fsfw_hal/common/spi/spiCommon.h
+0x4602;HSPI_HalfDuplexTransferFailed;No description;2;HAL_SPI;fsfw/src/fsfw_hal/common/spi/spiCommon.h
+0x4603;HSPI_Timeout;No description;3;HAL_SPI;fsfw/src/fsfw_hal/common/spi/spiCommon.h
+0x4604;HSPI_Busy;No description;4;HAL_SPI;fsfw/src/fsfw_hal/common/spi/spiCommon.h
+0x4605;HSPI_GenericError;No description;5;HAL_SPI;fsfw/src/fsfw_hal/common/spi/spiCommon.h
+0x4701;HURT_UartReadFailure;No description;1;HAL_UART;fsfw/src/fsfw_hal/linux/serial/SerialComIF.h
+0x4702;HURT_UartReadSizeMissmatch;No description;2;HAL_UART;fsfw/src/fsfw_hal/linux/serial/SerialComIF.h
+0x4703;HURT_UartRxBufferTooSmall;No description;3;HAL_UART;fsfw/src/fsfw_hal/linux/serial/SerialComIF.h
+0x4901;HGIO_UnknownGpioId;No description;1;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+0x4902;HGIO_DriveGpioFailure;No description;2;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+0x4903;HGIO_GpioTypeFailure;No description;3;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+0x4904;HGIO_GpioInvalidInstance;No description;4;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+0x4905;HGIO_GpioDuplicateDetected;No description;5;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+0x4906;HGIO_GpioInitFailed;No description;6;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+0x4907;HGIO_GpioGetValueFailed;No description;7;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+0x4d00;SPPA_NoPacketFound;No description;0;SPACE_PACKET_PARSER;fsfw/src/fsfw/tmtcservices/SpacePacketParser.h
+0x4d01;SPPA_SplitPacket;No description;1;SPACE_PACKET_PARSER;fsfw/src/fsfw/tmtcservices/SpacePacketParser.h
+0x50a1;HEATER_CommandNotSupported;No description;161;HEATER_HANDLER;mission/tcs/HeaterHandler.h
+0x50a2;HEATER_InitFailed;No description;162;HEATER_HANDLER;mission/tcs/HeaterHandler.h
+0x50a3;HEATER_InvalidSwitchNr;No description;163;HEATER_HANDLER;mission/tcs/HeaterHandler.h
+0x50a4;HEATER_MainSwitchSetTimeout;No description;164;HEATER_HANDLER;mission/tcs/HeaterHandler.h
+0x50a5;HEATER_CommandAlreadyWaiting;No description;165;HEATER_HANDLER;mission/tcs/HeaterHandler.h
+0x51a0;SYRLINKS_CrcFailure;No description;160;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
+0x51a1;SYRLINKS_UartFraminOrParityErrorAck;No description;161;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
+0x51a2;SYRLINKS_BadCharacterAck;No description;162;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
+0x51a3;SYRLINKS_BadParameterValueAck;No description;163;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
+0x51a4;SYRLINKS_BadEndOfFrameAck;No description;164;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
+0x51a5;SYRLINKS_UnknownCommandIdAck;No description;165;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
+0x51a6;SYRLINKS_BadCrcAck;No description;166;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
+0x51a7;SYRLINKS_ReplyWrongSize;No description;167;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
+0x51a8;SYRLINKS_MissingStartFrameCharacter;No description;168;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
+0x5200;IMTQ_InvalidCommandCode;No description;0;IMTQ_HANDLER;mission/acs/imtqHelpers.h
+0x5201;IMTQ_MgmMeasurementLowLevelError;No description;1;IMTQ_HANDLER;mission/acs/imtqHelpers.h
+0x5202;IMTQ_ActuateCmdLowLevelError;No description;2;IMTQ_HANDLER;mission/acs/imtqHelpers.h
+0x5203;IMTQ_ParameterMissing;No description;3;IMTQ_HANDLER;mission/acs/imtqHelpers.h
+0x5204;IMTQ_ParameterInvalid;No description;4;IMTQ_HANDLER;mission/acs/imtqHelpers.h
+0x5205;IMTQ_CcUnavailable;No description;5;IMTQ_HANDLER;mission/acs/imtqHelpers.h
+0x5206;IMTQ_InternalProcessingError;No description;6;IMTQ_HANDLER;mission/acs/imtqHelpers.h
+0x5207;IMTQ_RejectedWithoutReason;No description;7;IMTQ_HANDLER;mission/acs/imtqHelpers.h
+0x5208;IMTQ_CmdErrUnknown;No description;8;IMTQ_HANDLER;mission/acs/imtqHelpers.h
+0x5209;IMTQ_StartupCfgError;No description;9;IMTQ_HANDLER;mission/acs/imtqHelpers.h
+0x520a;IMTQ_UnexpectedSelfTestReply;The status reply to a self test command was received but no self test command has been sent. This should normally never happen.;10;IMTQ_HANDLER;mission/acs/imtqHelpers.h
+0x53a0;RWHA_InvalidSpeed;Action Message with invalid speed was received. Valid speeds must be in the range of [-65000, 1000] or [1000, 65000];160;RW_HANDLER;mission/acs/RwHandler.h
+0x53a1;RWHA_InvalidRampTime;Action Message with invalid ramp time was received.;161;RW_HANDLER;mission/acs/RwHandler.h
+0x53a2;RWHA_SetSpeedCommandInvalidLength;Received set speed command has invalid length. Should be 6.;162;RW_HANDLER;mission/acs/RwHandler.h
+0x53a3;RWHA_ExecutionFailed;Command execution failed;163;RW_HANDLER;mission/acs/RwHandler.h
+0x53a4;RWHA_CrcError;Reaction wheel reply has invalid crc;164;RW_HANDLER;mission/acs/RwHandler.h
+0x53a5;RWHA_ValueNotRead;No description;165;RW_HANDLER;mission/acs/RwHandler.h
+0x53b0;RWHA_SpiWriteFailure;No description;176;RW_HANDLER;mission/acs/rwHelpers.h
+0x53b1;RWHA_SpiReadFailure;Used by the spi send function to tell a failing read call;177;RW_HANDLER;mission/acs/rwHelpers.h
+0x53b2;RWHA_MissingStartSign;Can be used by the HDLC decoding mechanism to inform about a missing start sign 0x7E;178;RW_HANDLER;mission/acs/rwHelpers.h
+0x53b3;RWHA_InvalidSubstitute;Can be used by the HDLC decoding mechanism to inform about an invalid substitution combination;179;RW_HANDLER;mission/acs/rwHelpers.h
+0x53b4;RWHA_MissingEndSign;HDLC decoding mechanism never receives the end sign 0x7E;180;RW_HANDLER;mission/acs/rwHelpers.h
+0x53b5;RWHA_NoReply;Reaction wheel only responds with empty frames.;181;RW_HANDLER;mission/acs/rwHelpers.h
+0x53b6;RWHA_NoStartMarker;Expected a start marker as first byte;182;RW_HANDLER;mission/acs/rwHelpers.h
+0x53b7;RWHA_SpiReadTimeout;Timeout when reading reply;183;RW_HANDLER;mission/acs/rwHelpers.h
+0x54a0;STRH_TemperatureReqFailed;Status in temperature reply signals error;160;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x54a1;STRH_PingFailed;Ping command failed;161;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x54a2;STRH_VersionReqFailed;Status in version reply signals error;162;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x54a3;STRH_InterfaceReqFailed;Status in interface reply signals error;163;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x54a4;STRH_PowerReqFailed;Status in power reply signals error;164;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x54a5;STRH_SetParamFailed;Status of reply to parameter set command signals error;165;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x54a6;STRH_ActionFailed;Status of reply to action command signals error;166;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x54a7;STRH_FilePathTooLong;Received invalid path string. Exceeds allowed length;167;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x54a8;STRH_FilenameTooLong;Name of file received with command is too long;168;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x54a9;STRH_InvalidProgram;Received version reply with invalid program ID;169;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x54aa;STRH_ReplyError;Status field reply signals error;170;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x54ab;STRH_CommandTooShort;Received command which is too short (some data is missing for proper execution);171;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x54ac;STRH_InvalidLength;Received command with invalid length (too few or too many parameters);172;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x54ad;STRH_RegionMismatch;Region mismatch between send and received data;173;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x54ae;STRH_AddressMismatch;Address mismatch between send and received data;174;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x54af;STRH_LengthMismatch;Length field mismatch between send and received data;175;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x54b0;STRH_FileNotExists;Specified file does not exist;176;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x54b1;STRH_InvalidType;Download blob pixel command has invalid type field;177;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x54b2;STRH_InvalidId;Received FPGA action command with invalid ID;178;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x54b3;STRH_ReplyTooShort;Received reply is too short;179;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x54b4;STRH_CrcFailure;Received reply with invalid CRC;180;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x54b5;STRH_StrHelperExecuting;Star tracker handler currently executing a command and using the communication interface;181;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x54b6;STRH_StartrackerAlreadyBooted;Star tracker is already in firmware mode;182;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x54b7;STRH_StartrackerNotRunningFirmware;Star tracker must be in firmware mode to run this command;183;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x54b8;STRH_StartrackerNotRunningBootloader;Star tracker must be in bootloader mode to run this command;184;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x55e0;DWLPWRON_InvalidMode;Received command has invalid JESD mode (valid modes are 0 - 5);224;DWLPWRON_CMD;linux/payload/plocMpsocHelpers.h
+0x55e1;DWLPWRON_InvalidLaneRate;Received command has invalid lane rate (valid lane rate are 0 - 9);225;DWLPWRON_CMD;linux/payload/plocMpsocHelpers.h
+0x5800;PLSPVhLP_RequestDone;No description;0;PLOC_SUPV_HELPER;linux/payload/PlocSupvUartMan.h
+0x5801;PLSPVhLP_NoPacketFound;No description;1;PLOC_SUPV_HELPER;linux/payload/PlocSupvUartMan.h
+0x5802;PLSPVhLP_DecodeBufTooSmall;No description;2;PLOC_SUPV_HELPER;linux/payload/PlocSupvUartMan.h
+0x5803;PLSPVhLP_PossiblePacketLossConsecutiveStart;No description;3;PLOC_SUPV_HELPER;linux/payload/PlocSupvUartMan.h
+0x5804;PLSPVhLP_PossiblePacketLossConsecutiveEnd;No description;4;PLOC_SUPV_HELPER;linux/payload/PlocSupvUartMan.h
+0x5805;PLSPVhLP_HdlcError;No description;5;PLOC_SUPV_HELPER;linux/payload/PlocSupvUartMan.h
+0x58a0;PLSPVhLP_FileClosedAccidentally;File accidentally close;160;PLOC_SUPV_HELPER;linux/payload/PlocSupvUartMan.h
+0x58a1;PLSPVhLP_ProcessTerminated;Process has been terminated by command;161;PLOC_SUPV_HELPER;linux/payload/PlocSupvUartMan.h
+0x58a2;PLSPVhLP_PathNotExists;Received command with invalid pathname;162;PLOC_SUPV_HELPER;linux/payload/PlocSupvUartMan.h
+0x58a3;PLSPVhLP_EventBufferReplyInvalidApid;Expected event buffer TM but received space packet with other APID;163;PLOC_SUPV_HELPER;linux/payload/PlocSupvUartMan.h
+0x59a0;SUSS_ErrorUnlockMutex;No description;160;SUS_HANDLER;mission/acs/archive/LegacySusHandler.h
+0x59a1;SUSS_ErrorLockMutex;No description;161;SUS_HANDLER;mission/acs/archive/LegacySusHandler.h
+0x5aa0;IPCI_PapbBusy;No description;160;CCSDS_IP_CORE_BRIDGE;linux/ipcore/PapbVcInterface.h
+0x5ba0;PTME_UnknownVcId;No description;160;PTME;linux/ipcore/Ptme.h
+0x5d01;STRHLP_SdNotMounted;SD card specified in path string not mounted;1;STR_HELPER;linux/acs/StrComHandler.h
+0x5d02;STRHLP_FileNotExists;Specified file does not exist on filesystem;2;STR_HELPER;linux/acs/StrComHandler.h
+0x5d03;STRHLP_PathNotExists;Specified path does not exist;3;STR_HELPER;linux/acs/StrComHandler.h
+0x5d04;STRHLP_FileCreationFailed;Failed to create download image or read flash file;4;STR_HELPER;linux/acs/StrComHandler.h
+0x5d05;STRHLP_RegionMismatch;Region in flash write/read reply does not match expected region;5;STR_HELPER;linux/acs/StrComHandler.h
+0x5d06;STRHLP_AddressMismatch;Address in flash write/read reply does not match expected address;6;STR_HELPER;linux/acs/StrComHandler.h
+0x5d07;STRHLP_LengthMismatch;Length in flash write/read reply does not match expected length;7;STR_HELPER;linux/acs/StrComHandler.h
+0x5d08;STRHLP_StatusError;Status field in reply signals error;8;STR_HELPER;linux/acs/StrComHandler.h
+0x5d09;STRHLP_InvalidTypeId;Reply has invalid type ID (should be of action reply type);9;STR_HELPER;linux/acs/StrComHandler.h
+0x5d0a;STRHLP_ReceptionTimeout;No description;10;STR_HELPER;linux/acs/StrComHandler.h
+0x5d0b;STRHLP_DecodingError;No description;11;STR_HELPER;linux/acs/StrComHandler.h
+0x5e00;GOMS_PacketTooLong;No description;0;GOM_SPACE_HANDLER;mission/power/GomspaceDeviceHandler.h
+0x5e01;GOMS_InvalidTableId;No description;1;GOM_SPACE_HANDLER;mission/power/GomspaceDeviceHandler.h
+0x5e02;GOMS_InvalidAddress;No description;2;GOM_SPACE_HANDLER;mission/power/GomspaceDeviceHandler.h
+0x5e03;GOMS_InvalidParamSize;No description;3;GOM_SPACE_HANDLER;mission/power/GomspaceDeviceHandler.h
+0x5e04;GOMS_InvalidPayloadSize;No description;4;GOM_SPACE_HANDLER;mission/power/GomspaceDeviceHandler.h
+0x5e05;GOMS_UnknownReplyId;No description;5;GOM_SPACE_HANDLER;mission/power/GomspaceDeviceHandler.h
+0x5fa0;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
+0x5fa1;PLMEMDUMP_MramInvalidAddressCombination;The specified end address is lower than the start address;161;PLOC_MEMORY_DUMPER;linux/payload/PlocMemoryDumper.h
+0x60a0;PDEC_AbandonedCltuRetval;No description;160;PDEC_HANDLER;linux/ipcore/pdec.h
+0x60a1;PDEC_FrameDirtyRetval;No description;161;PDEC_HANDLER;linux/ipcore/pdec.h
+0x60a2;PDEC_FrameIllegalMultipleReasons;No description;162;PDEC_HANDLER;linux/ipcore/pdec.h
+0x60a3;PDEC_AdDiscardedLockoutRetval;No description;163;PDEC_HANDLER;linux/ipcore/pdec.h
+0x60a4;PDEC_AdDiscardedWaitRetval;No description;164;PDEC_HANDLER;linux/ipcore/pdec.h
+0x60a5;PDEC_AdDiscardedNsVs;No description;165;PDEC_HANDLER;linux/ipcore/pdec.h
+0x60a6;PDEC_NoReportRetval;No description;166;PDEC_HANDLER;linux/ipcore/pdec.h
+0x60a7;PDEC_ErrorVersionNumberRetval;No description;167;PDEC_HANDLER;linux/ipcore/pdec.h
+0x60a8;PDEC_IllegalCombinationRetval;No description;168;PDEC_HANDLER;linux/ipcore/pdec.h
+0x60a9;PDEC_InvalidScIdRetval;No description;169;PDEC_HANDLER;linux/ipcore/pdec.h
+0x60aa;PDEC_InvalidVcIdMsbRetval;No description;170;PDEC_HANDLER;linux/ipcore/pdec.h
+0x60ab;PDEC_InvalidVcIdLsbRetval;No description;171;PDEC_HANDLER;linux/ipcore/pdec.h
+0x60ac;PDEC_NsNotZeroRetval;No description;172;PDEC_HANDLER;linux/ipcore/pdec.h
+0x60ae;PDEC_InvalidBcCc;No description;174;PDEC_HANDLER;linux/ipcore/pdec.h
+0x60b0;PDEC_CommandNotImplemented;Received action message with unknown action id;176;PDEC_HANDLER;linux/ipcore/pdec.h
+0x61a0;CCSDS_CommandNotImplemented;Received action message with unknown action id;160;CCSDS_HANDLER;mission/com/CcsdsIpCoreHandler.h
+0x62a0;RS_RateNotSupported;The commanded rate is not supported by the current FPGA design;160;RATE_SETTER;linux/ipcore/PtmeConfig.h
+0x62a1;RS_BadBitRate;Bad bitrate has been commanded (e.g. 0);161;RATE_SETTER;linux/ipcore/PtmeConfig.h
+0x62a2;RS_ClkInversionFailed;Failed to invert clock and thus change the time the data is updated with respect to the tx clock;162;RATE_SETTER;linux/ipcore/PtmeConfig.h
+0x62a3;RS_TxManipulatorConfigFailed;Failed to change configuration bit of tx clock manipulator;163;RATE_SETTER;linux/ipcore/PtmeConfig.h
+0x6301;JSONBASE_JsonFileNotExists;Specified json file does not exist;1;ARCSEC_JSON_BASE;mission/acs/str/ArcsecJsonParamBase.h
+0x6302;JSONBASE_SetNotExists;Requested set does not exist in json file;2;ARCSEC_JSON_BASE;mission/acs/str/ArcsecJsonParamBase.h
+0x6303;JSONBASE_ParamNotExists;Requested parameter does not exist in json file;3;ARCSEC_JSON_BASE;mission/acs/str/ArcsecJsonParamBase.h
+0x64a0;NVMB_KeyNotExists;Specified key does not exist in json file;160;NVM_PARAM_BASE;mission/memory/NvmParameterBase.h
+0x65a0;FSHLP_SdNotMounted;SD card specified with path string not mounted;160;FILE_SYSTEM_HELPER;bsp_q7s/fs/FilesystemHelper.h
+0x65a1;FSHLP_FileNotExists;Specified file does not exist on filesystem;161;FILE_SYSTEM_HELPER;bsp_q7s/fs/FilesystemHelper.h
+0x66a0;PLMPHLP_FileWriteError;File error occured for file transfers from OBC to the MPSoC.;160;PLOC_MPSOC_HELPER;linux/payload/PlocMpsocSpecialComHelper.h
+0x66a1;PLMPHLP_FileReadError;File error occured for file transfers from MPSoC to OBC.;161;PLOC_MPSOC_HELPER;linux/payload/PlocMpsocSpecialComHelper.h
+0x67a0;SADPL_CommandNotSupported;No description;160;SA_DEPL_HANDLER;mission/SolarArrayDeploymentHandler.h
+0x67a1;SADPL_DeploymentAlreadyExecuting;No description;161;SA_DEPL_HANDLER;mission/SolarArrayDeploymentHandler.h
+0x67a2;SADPL_MainSwitchTimeoutFailure;No description;162;SA_DEPL_HANDLER;mission/SolarArrayDeploymentHandler.h
+0x67a3;SADPL_SwitchingDeplSa1Failed;No description;163;SA_DEPL_HANDLER;mission/SolarArrayDeploymentHandler.h
+0x67a4;SADPL_SwitchingDeplSa2Failed;No description;164;SA_DEPL_HANDLER;mission/SolarArrayDeploymentHandler.h
+0x68a0;MPSOCRTVIF_CrcFailure;Space Packet received from PLOC has invalid CRC;160;MPSOC_RETURN_VALUES_IF;linux/payload/mpsocRetvals.h
+0x68a1;MPSOCRTVIF_ReceivedAckFailure;Received ACK failure reply from PLOC;161;MPSOC_RETURN_VALUES_IF;linux/payload/mpsocRetvals.h
+0x68a2;MPSOCRTVIF_ReceivedExeFailure;Received execution failure reply from PLOC;162;MPSOC_RETURN_VALUES_IF;linux/payload/mpsocRetvals.h
+0x68a3;MPSOCRTVIF_InvalidApid;Received space packet with invalid APID from PLOC;163;MPSOC_RETURN_VALUES_IF;linux/payload/mpsocRetvals.h
+0x68a4;MPSOCRTVIF_InvalidLength;Received command with invalid length;164;MPSOC_RETURN_VALUES_IF;linux/payload/mpsocRetvals.h
+0x68a5;MPSOCRTVIF_FilenameTooLong;Filename of file in OBC filesystem is too long;165;MPSOC_RETURN_VALUES_IF;linux/payload/mpsocRetvals.h
+0x68a6;MPSOCRTVIF_MpsocHelperExecuting;MPSoC helper is currently executing a command;166;MPSOC_RETURN_VALUES_IF;linux/payload/mpsocRetvals.h
+0x68a7;MPSOCRTVIF_MpsocFilenameTooLong;Filename of MPSoC file is to long (max. 256 bytes);167;MPSOC_RETURN_VALUES_IF;linux/payload/mpsocRetvals.h
+0x68a8;MPSOCRTVIF_InvalidParameter;Command has invalid parameter;168;MPSOC_RETURN_VALUES_IF;linux/payload/mpsocRetvals.h
+0x68a9;MPSOCRTVIF_NameTooLong;Received command has file string with invalid length;169;MPSOC_RETURN_VALUES_IF;linux/payload/mpsocRetvals.h
+0x69a0;SPVRTVIF_CrcFailure;Space Packet received from PLOC supervisor has invalid CRC;160;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
+0x69a1;SPVRTVIF_InvalidServiceId;No description;161;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
+0x69a2;SPVRTVIF_ReceivedAckFailure;Received ACK failure reply from PLOC supervisor;162;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
+0x69a3;SPVRTVIF_ReceivedExeFailure;Received execution failure reply from PLOC supervisor;163;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
+0x69a4;SPVRTVIF_InvalidApid;Received space packet with invalid APID from PLOC supervisor;164;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
+0x69a5;SPVRTVIF_GetTimeFailure;Failed to read current system time;165;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
+0x69a6;SPVRTVIF_InvalidWatchdog;Received command with invalid watchdog parameter. Valid watchdogs are 0 for PS, 1 for PL and 2 for INT;166;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
+0x69a7;SPVRTVIF_InvalidWatchdogTimeout;Received watchdog timeout config command with invalid timeout. Valid timeouts must be in the range between 1000 and 360000 ms.;167;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
+0x69a8;SPVRTVIF_InvalidLatchupId;Received latchup config command with invalid latchup ID;168;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
+0x69a9;SPVRTVIF_SweepPeriodTooSmall;Received set adc sweep period command with invalid sweep period. Must be larger than 21.;169;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
+0x69aa;SPVRTVIF_InvalidTestParam;Receive auto EM test command with invalid test param. Valid params are 1 and 2.;170;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
+0x69ab;SPVRTVIF_MramPacketParsingFailure;Returned when scanning for MRAM dump packets failed.;171;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
+0x69ac;SPVRTVIF_InvalidMramAddresses;Returned when the start and stop addresses of the MRAM dump or MRAM  wipe commands are invalid (e.g. start address bigger than stop address);172;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
+0x69ad;SPVRTVIF_NoMramPacket;Expect reception of an MRAM dump packet but received space packet with other apid.;173;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
+0x69ae;SPVRTVIF_PathDoesNotExist;Path to PLOC directory on SD card does not exist;174;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
+0x69af;SPVRTVIF_MramFileNotExists;MRAM dump file does not exists. The file should actually already have been created with the reception of the first dump packet.;175;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
+0x69b0;SPVRTVIF_InvalidReplyLength;No description;176;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
+0x69b1;SPVRTVIF_InvalidLength;Received action command has invalid length;177;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
+0x69b2;SPVRTVIF_FilenameTooLong;Filename too long;178;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
+0x69b3;SPVRTVIF_UpdateStatusReportInvalidLength;Received update status report with invalid packet length field;179;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
+0x69b4;SPVRTVIF_UpdateCrcFailure;Update status report does not contain expected CRC. There might be a bit flip in the update memory region.;180;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
+0x69b5;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
+0x69c0;SPVRTVIF_BufTooSmall;No description;192;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
+0x69c1;SPVRTVIF_NoReplyTimeout;No description;193;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
+0x6aa0;ACSCTRL_FileDeletionFailed;File deletion failed and at least one file is still existent.;160;ACS_CTRL;mission/controller/controllerdefinitions/AcsCtrlDefinitions.h
+0x6aa1;ACSCTRL_WriteFileFailed;Writing the TLE to the file has failed.;161;ACS_CTRL;mission/controller/controllerdefinitions/AcsCtrlDefinitions.h
+0x6aa2;ACSCTRL_ReadFileFailed;Reading the TLE to the file has failed.;162;ACS_CTRL;mission/controller/controllerdefinitions/AcsCtrlDefinitions.h
+0x6aa3;ACSCTRL_SingleRwUnavailable;A single RW has failed.;163;ACS_CTRL;mission/controller/controllerdefinitions/AcsCtrlDefinitions.h
+0x6aa4;ACSCTRL_MultipleRwUnavailable;Multiple RWs have failed.;164;ACS_CTRL;mission/controller/controllerdefinitions/AcsCtrlDefinitions.h
+0x6b02;ACSMEKF_MekfUninitialized;No description;2;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
+0x6b03;ACSMEKF_MekfNoGyrData;No description;3;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
+0x6b04;ACSMEKF_MekfNoModelVectors;No description;4;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
+0x6b05;ACSMEKF_MekfNoSusMgmStrData;No description;5;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
+0x6b06;ACSMEKF_MekfCovarianceInversionFailed;No description;6;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
+0x6b07;ACSMEKF_MekfNotFinite;No description;7;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
+0x6b08;ACSMEKF_MekfInitialized;No description;8;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
+0x6b09;ACSMEKF_MekfRunning;No description;9;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
+0x6c00;SDMA_OpOngoing;No description;0;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
+0x6c01;SDMA_AlreadyOn;No description;1;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
+0x6c02;SDMA_AlreadyMounted;No description;2;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
+0x6c03;SDMA_AlreadyOff;No description;3;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
+0x6c0a;SDMA_StatusFileNexists;No description;10;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
+0x6c0b;SDMA_StatusFileFormatInvalid;No description;11;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
+0x6c0c;SDMA_MountError;No description;12;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
+0x6c0d;SDMA_UnmountError;No description;13;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
+0x6c0e;SDMA_SystemCallError;No description;14;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
+0x6c0f;SDMA_PopenCallError;No description;15;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
+0x6d00;LPH_SdNotReady;No description;0;LOCAL_PARAM_HANDLER;bsp_q7s/memory/LocalParameterHandler.h
+0x6e00;PTM_DumpDone;No description;0;PERSISTENT_TM_STORE;mission/tmtc/PersistentTmStore.h
+0x6e01;PTM_BusyDumping;No description;1;PERSISTENT_TM_STORE;mission/tmtc/PersistentTmStore.h
+0x6f00;TMS_IsBusy;No description;0;TM_SINK;mission/tmtc/DirectTmSinkIF.h
+0x6f01;TMS_PartiallyWritten;No description;1;TM_SINK;mission/tmtc/DirectTmSinkIF.h
+0x6f02;TMS_NoWriteActive;No description;2;TM_SINK;mission/tmtc/DirectTmSinkIF.h
+0x6f03;TMS_Timeout;No description;3;TM_SINK;mission/tmtc/DirectTmSinkIF.h
+0x7000;VCS_ChannelDoesNotExist;No description;0;VIRTUAL_CHANNEL;mission/com/VirtualChannel.h
+0x7200;SCBU_KeyNotFound;No description;0;SCRATCH_BUFFER;bsp_q7s/memory/scratchApi.h

generators/bsp_q7s_subsystems.csv

@@ -60,3 +60,5 @@
 142;COM_SUBSYSTEM
 143;PERSISTENT_TM_STORE
 144;SYRLINKS_COM
+145;SUS_HANDLER
+146;CFDP_APP

generators/events/event_parser.py

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

generators/events/translateEvents.cpp

@@ -1,7 +1,7 @@
 /**
- * @brief    Auto-generated event translation file. Contains 296 translations.
+ * @brief    Auto-generated event translation file. Contains 324 translations.
  * @details
- * Generated on: 2023-06-21 19:01:02
+ * Generated on: 2024-04-10 11:49:35
  */
 #include "translateEvents.h"
 
@@ -82,8 +82,11 @@ const char *BIT_LOCK_STRING = "BIT_LOCK";
 const char *BIT_LOCK_LOST_STRING = "BIT_LOCK_LOST";
 const char *FRAME_PROCESSING_FAILED_STRING = "FRAME_PROCESSING_FAILED";
 const char *CLOCK_SET_STRING = "CLOCK_SET";
-const char *CLOCK_DUMP_STRING = "CLOCK_DUMP";
+const char *CLOCK_DUMP_LEGACY_STRING = "CLOCK_DUMP_LEGACY";
 const char *CLOCK_SET_FAILURE_STRING = "CLOCK_SET_FAILURE";
+const char *CLOCK_DUMP_STRING = "CLOCK_DUMP";
+const char *CLOCK_DUMP_BEFORE_SETTING_TIME_STRING = "CLOCK_DUMP_BEFORE_SETTING_TIME";
+const char *CLOCK_DUMP_AFTER_SETTING_TIME_STRING = "CLOCK_DUMP_AFTER_SETTING_TIME";
 const char *TC_DELETION_FAILED_STRING = "TC_DELETION_FAILED";
 const char *TEST_STRING = "TEST";
 const char *CHANGE_OF_SETUP_PARAMETER_STRING = "CHANGE_OF_SETUP_PARAMETER";
@@ -92,18 +95,28 @@ const char *MSG_QUEUE_ERROR_STRING = "MSG_QUEUE_ERROR";
 const char *SERIALIZATION_ERROR_STRING = "SERIALIZATION_ERROR";
 const char *FILESTORE_ERROR_STRING = "FILESTORE_ERROR";
 const char *FILENAME_TOO_LARGE_ERROR_STRING = "FILENAME_TOO_LARGE_ERROR";
+const char *HANDLING_CFDP_REQUEST_FAILED_STRING = "HANDLING_CFDP_REQUEST_FAILED";
 const char *SAFE_RATE_VIOLATION_STRING = "SAFE_RATE_VIOLATION";
-const char *SAFE_RATE_RECOVERY_STRING = "SAFE_RATE_RECOVERY";
+const char *RATE_RECOVERY_STRING = "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 *PTG_CTRL_NO_ATTITUDE_INFORMATION_STRING = "PTG_CTRL_NO_ATTITUDE_INFORMATION";
 const char *SAFE_MODE_CONTROLLER_FAILURE_STRING = "SAFE_MODE_CONTROLLER_FAILURE";
+const char *TLE_TOO_OLD_STRING = "TLE_TOO_OLD";
+const char *TLE_FILE_READ_FAILED_STRING = "TLE_FILE_READ_FAILED";
+const char *PTG_RATE_VIOLATION_STRING = "PTG_RATE_VIOLATION";
+const char *DETUMBLE_TRANSITION_FAILED_STRING = "DETUMBLE_TRANSITION_FAILED";
 const char *SWITCH_CMD_SENT_STRING = "SWITCH_CMD_SENT";
 const char *SWITCH_HAS_CHANGED_STRING = "SWITCH_HAS_CHANGED";
 const char *SWITCHING_Q7S_DENIED_STRING = "SWITCHING_Q7S_DENIED";
 const char *FDIR_REACTION_IGNORED_STRING = "FDIR_REACTION_IGNORED";
+const char *DATASET_READ_FAILED_STRING = "DATASET_READ_FAILED";
+const char *VOLTAGE_OUT_OF_BOUNDS_STRING = "VOLTAGE_OUT_OF_BOUNDS";
+const char *TIMEDELTA_OUT_OF_BOUNDS_STRING = "TIMEDELTA_OUT_OF_BOUNDS";
+const char *POWER_LEVEL_LOW_STRING = "POWER_LEVEL_LOW";
+const char *POWER_LEVEL_CRITICAL_STRING = "POWER_LEVEL_CRITICAL";
 const char *GPIO_PULL_HIGH_FAILED_STRING = "GPIO_PULL_HIGH_FAILED";
 const char *GPIO_PULL_LOW_FAILED_STRING = "GPIO_PULL_LOW_FAILED";
 const char *HEATER_WENT_ON_STRING = "HEATER_WENT_ON";
@@ -127,6 +140,8 @@ const char *EXE_FAILURE_STRING = "EXE_FAILURE";
 const char *MPSOC_HANDLER_CRC_FAILURE_STRING = "MPSOC_HANDLER_CRC_FAILURE";
 const char *MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH_STRING = "MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH";
 const char *MPSOC_SHUTDOWN_FAILED_STRING = "MPSOC_SHUTDOWN_FAILED";
+const char *SUPV_NOT_ON_STRING = "SUPV_NOT_ON";
+const char *SUPV_REPLY_TIMEOUT_STRING = "SUPV_REPLY_TIMEOUT";
 const char *SELF_TEST_I2C_FAILURE_STRING = "SELF_TEST_I2C_FAILURE";
 const char *SELF_TEST_SPI_FAILURE_STRING = "SELF_TEST_SPI_FAILURE";
 const char *SELF_TEST_ADC_FAILURE_STRING = "SELF_TEST_ADC_FAILURE";
@@ -139,6 +154,7 @@ const char *ERROR_STATE_STRING = "ERROR_STATE";
 const char *RESET_OCCURED_STRING = "RESET_OCCURED";
 const char *BOOTING_FIRMWARE_FAILED_EVENT_STRING = "BOOTING_FIRMWARE_FAILED_EVENT";
 const char *BOOTING_BOOTLOADER_FAILED_EVENT_STRING = "BOOTING_BOOTLOADER_FAILED_EVENT";
+const char *COM_ERROR_REPLY_RECEIVED_STRING = "COM_ERROR_REPLY_RECEIVED";
 const char *SUPV_MEMORY_READ_RPT_CRC_FAILURE_STRING = "SUPV_MEMORY_READ_RPT_CRC_FAILURE";
 const char *SUPV_UNKNOWN_TM_STRING = "SUPV_UNKNOWN_TM";
 const char *SUPV_UNINIMPLEMENTED_TM_STRING = "SUPV_UNINIMPLEMENTED_TM";
@@ -147,6 +163,8 @@ const char *SUPV_EXE_FAILURE_STRING = "SUPV_EXE_FAILURE";
 const char *SUPV_CRC_FAILURE_EVENT_STRING = "SUPV_CRC_FAILURE_EVENT";
 const char *SUPV_HELPER_EXECUTING_STRING = "SUPV_HELPER_EXECUTING";
 const char *SUPV_MPSOC_SHUTDOWN_BUILD_FAILED_STRING = "SUPV_MPSOC_SHUTDOWN_BUILD_FAILED";
+const char *SUPV_ACK_UNKNOWN_COMMAND_STRING = "SUPV_ACK_UNKNOWN_COMMAND";
+const char *SUPV_EXE_ACK_UNKNOWN_COMMAND_STRING = "SUPV_EXE_ACK_UNKNOWN_COMMAND";
 const char *SANITIZATION_FAILED_STRING = "SANITIZATION_FAILED";
 const char *MOUNTED_SD_CARD_STRING = "MOUNTED_SD_CARD";
 const char *SEND_MRAM_DUMP_FAILED_STRING = "SEND_MRAM_DUMP_FAILED";
@@ -166,6 +184,7 @@ const char *PDEC_TRYING_RESET_NO_INIT_STRING = "PDEC_TRYING_RESET_NO_INIT";
 const char *PDEC_RESET_FAILED_STRING = "PDEC_RESET_FAILED";
 const char *OPEN_IRQ_FILE_FAILED_STRING = "OPEN_IRQ_FILE_FAILED";
 const char *PDEC_INIT_FAILED_STRING = "PDEC_INIT_FAILED";
+const char *PDEC_CONFIG_CORRUPTED_STRING = "PDEC_CONFIG_CORRUPTED";
 const char *IMAGE_UPLOAD_FAILED_STRING = "IMAGE_UPLOAD_FAILED";
 const char *IMAGE_DOWNLOAD_FAILED_STRING = "IMAGE_DOWNLOAD_FAILED";
 const char *IMAGE_UPLOAD_SUCCESSFUL_STRING = "IMAGE_UPLOAD_SUCCESSFUL";
@@ -225,6 +244,7 @@ const char *SIDE_SWITCH_TRANSITION_NOT_ALLOWED_12903_STRING = "SIDE_SWITCH_TRANS
 const char *CHILDREN_LOST_MODE_STRING = "CHILDREN_LOST_MODE";
 const char *GPS_FIX_CHANGE_STRING = "GPS_FIX_CHANGE";
 const char *CANT_GET_FIX_STRING = "CANT_GET_FIX";
+const char *RESET_FAIL_STRING = "RESET_FAIL";
 const char *P60_BOOT_COUNT_STRING = "P60_BOOT_COUNT";
 const char *BATT_MODE_STRING = "BATT_MODE";
 const char *BATT_MODE_CHANGED_STRING = "BATT_MODE_CHANGED";
@@ -260,6 +280,7 @@ const char *TX_OFF_STRING = "TX_OFF";
 const char *MISSING_PACKET_STRING = "MISSING_PACKET";
 const char *EXPERIMENT_TIMEDOUT_STRING = "EXPERIMENT_TIMEDOUT";
 const char *MULTI_PACKET_COMMAND_DONE_STRING = "MULTI_PACKET_COMMAND_DONE";
+const char *FS_UNUSABLE_STRING = "FS_UNUSABLE";
 const char *SET_CONFIGFILEVALUE_FAILED_STRING = "SET_CONFIGFILEVALUE_FAILED";
 const char *GET_CONFIGFILEVALUE_FAILED_STRING = "GET_CONFIGFILEVALUE_FAILED";
 const char *INSERT_CONFIGFILEVALUE_FAILED_STRING = "INSERT_CONFIGFILEVALUE_FAILED";
@@ -278,6 +299,7 @@ const char *TRYING_I2C_RECOVERY_STRING = "TRYING_I2C_RECOVERY";
 const char *I2C_REBOOT_STRING = "I2C_REBOOT";
 const char *PDEC_REBOOT_STRING = "PDEC_REBOOT";
 const char *FIRMWARE_INFO_STRING = "FIRMWARE_INFO";
+const char *ACTIVE_SD_INFO_STRING = "ACTIVE_SD_INFO";
 const char *NO_VALID_SENSOR_TEMPERATURE_STRING = "NO_VALID_SENSOR_TEMPERATURE";
 const char *NO_HEALTHY_HEATER_AVAILABLE_STRING = "NO_HEALTHY_HEATER_AVAILABLE";
 const char *SYRLINKS_OVERHEATING_STRING = "SYRLINKS_OVERHEATING";
@@ -286,6 +308,9 @@ const char *CAMERA_OVERHEATING_STRING = "CAMERA_OVERHEATING";
 const char *PCDU_SYSTEM_OVERHEATING_STRING = "PCDU_SYSTEM_OVERHEATING";
 const char *HEATER_NOT_OFF_FOR_OFF_MODE_STRING = "HEATER_NOT_OFF_FOR_OFF_MODE";
 const char *MGT_OVERHEATING_STRING = "MGT_OVERHEATING";
+const char *TCS_SWITCHING_HEATER_ON_STRING = "TCS_SWITCHING_HEATER_ON";
+const char *TCS_SWITCHING_HEATER_OFF_STRING = "TCS_SWITCHING_HEATER_OFF";
+const char *TCS_HEATER_MAX_BURN_TIME_REACHED_STRING = "TCS_HEATER_MAX_BURN_TIME_REACHED";
 const char *TX_TIMER_EXPIRED_STRING = "TX_TIMER_EXPIRED";
 const char *BIT_LOCK_TX_ON_STRING = "BIT_LOCK_TX_ON";
 const char *POSSIBLE_FILE_CORRUPTION_STRING = "POSSIBLE_FILE_CORRUPTION";
@@ -301,6 +326,9 @@ const char *DUMP_NOK_CANCELLED_STRING = "DUMP_NOK_CANCELLED";
 const char *DUMP_MISC_CANCELLED_STRING = "DUMP_MISC_CANCELLED";
 const char *DUMP_HK_CANCELLED_STRING = "DUMP_HK_CANCELLED";
 const char *DUMP_CFDP_CANCELLED_STRING = "DUMP_CFDP_CANCELLED";
+const char *TEMPERATURE_ALL_ONES_START_STRING = "TEMPERATURE_ALL_ONES_START";
+const char *TEMPERATURE_ALL_ONES_RECOVERY_STRING = "TEMPERATURE_ALL_ONES_RECOVERY";
+const char *FAULT_HANDLER_TRIGGERED_STRING = "FAULT_HANDLER_TRIGGERED";
 
 const char *translateEvents(Event event) {
   switch ((event & 0xFFFF)) {
@@ -459,9 +487,15 @@ const char *translateEvents(Event event) {
     case (8900):
       return CLOCK_SET_STRING;
     case (8901):
-      return CLOCK_DUMP_STRING;
+      return CLOCK_DUMP_LEGACY_STRING;
     case (8902):
       return CLOCK_SET_FAILURE_STRING;
+    case (8903):
+      return CLOCK_DUMP_STRING;
+    case (8904):
+      return CLOCK_DUMP_BEFORE_SETTING_TIME_STRING;
+    case (8905):
+      return CLOCK_DUMP_AFTER_SETTING_TIME_STRING;
     case (9100):
       return TC_DELETION_FAILED_STRING;
     case (9700):
@@ -478,10 +512,12 @@ const char *translateEvents(Event event) {
       return FILESTORE_ERROR_STRING;
     case (10804):
       return FILENAME_TOO_LARGE_ERROR_STRING;
+    case (10805):
+      return HANDLING_CFDP_REQUEST_FAILED_STRING;
     case (11200):
       return SAFE_RATE_VIOLATION_STRING;
     case (11201):
-      return SAFE_RATE_RECOVERY_STRING;
+      return RATE_RECOVERY_STRING;
     case (11202):
       return MULTIPLE_RW_INVALID_STRING;
     case (11203):
@@ -491,9 +527,17 @@ const char *translateEvents(Event event) {
     case (11205):
       return MEKF_AUTOMATIC_RESET_STRING;
     case (11206):
-      return MEKF_INVALID_MODE_VIOLATION_STRING;
+      return PTG_CTRL_NO_ATTITUDE_INFORMATION_STRING;
     case (11207):
       return SAFE_MODE_CONTROLLER_FAILURE_STRING;
+    case (11208):
+      return TLE_TOO_OLD_STRING;
+    case (11209):
+      return TLE_FILE_READ_FAILED_STRING;
+    case (11210):
+      return PTG_RATE_VIOLATION_STRING;
+    case (11211):
+      return DETUMBLE_TRANSITION_FAILED_STRING;
     case (11300):
       return SWITCH_CMD_SENT_STRING;
     case (11301):
@@ -502,6 +546,16 @@ const char *translateEvents(Event event) {
       return SWITCHING_Q7S_DENIED_STRING;
     case (11303):
       return FDIR_REACTION_IGNORED_STRING;
+    case (11304):
+      return DATASET_READ_FAILED_STRING;
+    case (11305):
+      return VOLTAGE_OUT_OF_BOUNDS_STRING;
+    case (11306):
+      return TIMEDELTA_OUT_OF_BOUNDS_STRING;
+    case (11307):
+      return POWER_LEVEL_LOW_STRING;
+    case (11308):
+      return POWER_LEVEL_CRITICAL_STRING;
     case (11400):
       return GPIO_PULL_HIGH_FAILED_STRING;
     case (11401):
@@ -548,6 +602,10 @@ const char *translateEvents(Event event) {
       return MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH_STRING;
     case (11606):
       return MPSOC_SHUTDOWN_FAILED_STRING;
+    case (11607):
+      return SUPV_NOT_ON_STRING;
+    case (11608):
+      return SUPV_REPLY_TIMEOUT_STRING;
     case (11701):
       return SELF_TEST_I2C_FAILURE_STRING;
     case (11702):
@@ -572,6 +630,8 @@ const char *translateEvents(Event event) {
       return BOOTING_FIRMWARE_FAILED_EVENT_STRING;
     case (11902):
       return BOOTING_BOOTLOADER_FAILED_EVENT_STRING;
+    case (11903):
+      return COM_ERROR_REPLY_RECEIVED_STRING;
     case (12001):
       return SUPV_MEMORY_READ_RPT_CRC_FAILURE_STRING;
     case (12002):
@@ -588,6 +648,10 @@ const char *translateEvents(Event event) {
       return SUPV_HELPER_EXECUTING_STRING;
     case (12008):
       return SUPV_MPSOC_SHUTDOWN_BUILD_FAILED_STRING;
+    case (12009):
+      return SUPV_ACK_UNKNOWN_COMMAND_STRING;
+    case (12010):
+      return SUPV_EXE_ACK_UNKNOWN_COMMAND_STRING;
     case (12100):
       return SANITIZATION_FAILED_STRING;
     case (12101):
@@ -626,6 +690,8 @@ const char *translateEvents(Event event) {
       return OPEN_IRQ_FILE_FAILED_STRING;
     case (12414):
       return PDEC_INIT_FAILED_STRING;
+    case (12415):
+      return PDEC_CONFIG_CORRUPTED_STRING;
     case (12500):
       return IMAGE_UPLOAD_FAILED_STRING;
     case (12501):
@@ -744,6 +810,8 @@ const char *translateEvents(Event event) {
       return GPS_FIX_CHANGE_STRING;
     case (13101):
       return CANT_GET_FIX_STRING;
+    case (13102):
+      return RESET_FAIL_STRING;
     case (13200):
       return P60_BOOT_COUNT_STRING;
     case (13201):
@@ -814,6 +882,8 @@ const char *translateEvents(Event event) {
       return EXPERIMENT_TIMEDOUT_STRING;
     case (13802):
       return MULTI_PACKET_COMMAND_DONE_STRING;
+    case (13803):
+      return FS_UNUSABLE_STRING;
     case (13901):
       return SET_CONFIGFILEVALUE_FAILED_STRING;
     case (13902):
@@ -850,6 +920,8 @@ const char *translateEvents(Event event) {
       return PDEC_REBOOT_STRING;
     case (14013):
       return FIRMWARE_INFO_STRING;
+    case (14014):
+      return ACTIVE_SD_INFO_STRING;
     case (14100):
       return NO_VALID_SENSOR_TEMPERATURE_STRING;
     case (14101):
@@ -866,6 +938,12 @@ const char *translateEvents(Event event) {
       return HEATER_NOT_OFF_FOR_OFF_MODE_STRING;
     case (14108):
       return MGT_OVERHEATING_STRING;
+    case (14109):
+      return TCS_SWITCHING_HEATER_ON_STRING;
+    case (14110):
+      return TCS_SWITCHING_HEATER_OFF_STRING;
+    case (14111):
+      return TCS_HEATER_MAX_BURN_TIME_REACHED_STRING;
     case (14201):
       return TX_TIMER_EXPIRED_STRING;
     case (14202):
@@ -896,6 +974,12 @@ const char *translateEvents(Event event) {
       return DUMP_HK_CANCELLED_STRING;
     case (14314):
       return DUMP_CFDP_CANCELLED_STRING;
+    case (14500):
+      return TEMPERATURE_ALL_ONES_START_STRING;
+    case (14501):
+      return TEMPERATURE_ALL_ONES_RECOVERY_STRING;
+    case (14600):
+      return FAULT_HANDLER_TRIGGERED_STRING;
     default:
       return "UNKNOWN_EVENT";
   }

generators/objects/translateObjects.cpp

@@ -1,15 +1,17 @@
 /**
  * @brief  Auto-generated object translation file.
  * @details
- * Contains 175 translations.
- * Generated on: 2023-06-21 19:01:02
+ * Contains 179 translations.
+ * Generated on: 2024-04-10 11:49:35
  */
 #include "translateObjects.h"
 
 const char *P60DOCK_TEST_TASK_STRING = "P60DOCK_TEST_TASK";
 const char *ACS_CONTROLLER_STRING = "ACS_CONTROLLER";
 const char *CORE_CONTROLLER_STRING = "CORE_CONTROLLER";
+const char *POWER_CONTROLLER_STRING = "POWER_CONTROLLER";
 const char *GLOBAL_JSON_CFG_STRING = "GLOBAL_JSON_CFG";
+const char *XIPHOS_WDT_STRING = "XIPHOS_WDT";
 const char *THERMAL_CONTROLLER_STRING = "THERMAL_CONTROLLER";
 const char *MGM_0_LIS3_HANDLER_STRING = "MGM_0_LIS3_HANDLER";
 const char *GYRO_0_ADIS_HANDLER_STRING = "GYRO_0_ADIS_HANDLER";
@@ -164,11 +166,13 @@ const char *PUS_TM_FUNNEL_STRING = "PUS_TM_FUNNEL";
 const char *CFDP_TM_FUNNEL_STRING = "CFDP_TM_FUNNEL";
 const char *CFDP_HANDLER_STRING = "CFDP_HANDLER";
 const char *CFDP_DISTRIBUTOR_STRING = "CFDP_DISTRIBUTOR";
+const char *CFDP_FAULT_HANDLER_STRING = "CFDP_FAULT_HANDLER";
 const char *EIVE_SYSTEM_STRING = "EIVE_SYSTEM";
 const char *ACS_SUBSYSTEM_STRING = "ACS_SUBSYSTEM";
 const char *PL_SUBSYSTEM_STRING = "PL_SUBSYSTEM";
 const char *TCS_SUBSYSTEM_STRING = "TCS_SUBSYSTEM";
 const char *COM_SUBSYSTEM_STRING = "COM_SUBSYSTEM";
+const char *EPS_SUBSYSTEM_STRING = "EPS_SUBSYSTEM";
 const char *MISC_TM_STORE_STRING = "MISC_TM_STORE";
 const char *OK_TM_STORE_STRING = "OK_TM_STORE";
 const char *NOT_OK_TM_STORE_STRING = "NOT_OK_TM_STORE";
@@ -190,8 +194,12 @@ const char *translateObject(object_id_t object) {
       return ACS_CONTROLLER_STRING;
     case 0x43000003:
       return CORE_CONTROLLER_STRING;
+    case 0x43000004:
+      return POWER_CONTROLLER_STRING;
     case 0x43000006:
       return GLOBAL_JSON_CFG_STRING;
+    case 0x43000007:
+      return XIPHOS_WDT_STRING;
     case 0x43400001:
       return THERMAL_CONTROLLER_STRING;
     case 0x44120006:
@@ -500,6 +508,8 @@ const char *translateObject(object_id_t object) {
       return CFDP_HANDLER_STRING;
     case 0x73000206:
       return CFDP_DISTRIBUTOR_STRING;
+    case 0x73000207:
+      return CFDP_FAULT_HANDLER_STRING;
     case 0x73010000:
       return EIVE_SYSTEM_STRING;
     case 0x73010001:
@@ -510,6 +520,8 @@ const char *translateObject(object_id_t object) {
       return TCS_SUBSYSTEM_STRING;
     case 0x73010004:
       return COM_SUBSYSTEM_STRING;
+    case 0x73010005:
+      return EPS_SUBSYSTEM_STRING;
     case 0x73020001:
       return MISC_TM_STORE_STRING;
     case 0x73020002:

linux/ObjectFactory.cpp

@@ -13,6 +13,7 @@
 #include <linux/tcs/Max31865RtdPolling.h>
 #include <mission/acs/SusHandler.h>
 #include <mission/controller/AcsController.h>
+#include <mission/controller/PowerController.h>
 #include <mission/genericFactory.h>
 #include <mission/payload/ScexDeviceHandler.h>
 #include <mission/system/acs/SusAssembly.h>
@@ -23,13 +24,10 @@
 
 #include "OBSWConfig.h"
 #include "devConf.h"
-#include "devices/addresses.h"
 #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/tcs/defs.h"
+#include "mission/system/payloadModeTree.h"
+#include "mission/system/power/epsModeTree.h"
 
 void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiComIF,
                                               PowerSwitchIF& pwrSwitcher, std::string spiDev,
@@ -204,74 +202,78 @@ void ObjectFactory::createRtdComponents(std::string spiDev, GpioIF* gpioComIF,
 
   GpioCallback* gpioRtdIc0 = new GpioCallback("Chip select RTD IC0", Direction::OUT, Levels::HIGH,
                                               &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_3, gpioRtdIc0);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_0, gpioRtdIc0);
   GpioCallback* gpioRtdIc1 = new GpioCallback("Chip select RTD IC1", Direction::OUT, Levels::HIGH,
                                               &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_4, gpioRtdIc1);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_1, gpioRtdIc1);
   GpioCallback* gpioRtdIc2 = new GpioCallback("Chip select RTD IC2", Direction::OUT, Levels::HIGH,
                                               &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_5, gpioRtdIc2);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_2, gpioRtdIc2);
   GpioCallback* gpioRtdIc3 = new GpioCallback("Chip select RTD IC3", Direction::OUT, Levels::HIGH,
                                               &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_6, gpioRtdIc3);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_3, gpioRtdIc3);
   GpioCallback* gpioRtdIc4 = new GpioCallback("Chip select RTD IC4", Direction::OUT, Levels::HIGH,
                                               &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_7, gpioRtdIc4);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_4, gpioRtdIc4);
   GpioCallback* gpioRtdIc5 = new GpioCallback("Chip select RTD IC5", Direction::OUT, Levels::HIGH,
                                               &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_8, gpioRtdIc5);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_5, gpioRtdIc5);
   GpioCallback* gpioRtdIc6 = new GpioCallback("Chip select RTD IC6", Direction::OUT, Levels::HIGH,
                                               &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_9, gpioRtdIc6);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_6, gpioRtdIc6);
   GpioCallback* gpioRtdIc7 = new GpioCallback("Chip select RTD IC7", Direction::OUT, Levels::HIGH,
                                               &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_10, gpioRtdIc7);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_7, gpioRtdIc7);
   GpioCallback* gpioRtdIc8 = new GpioCallback("Chip select RTD IC8", Direction::OUT, Levels::HIGH,
                                               &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_11, gpioRtdIc8);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_8, gpioRtdIc8);
   GpioCallback* gpioRtdIc9 = new GpioCallback("Chip select RTD IC9", Direction::OUT, Levels::HIGH,
                                               &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_12, gpioRtdIc9);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_9, gpioRtdIc9);
   GpioCallback* gpioRtdIc10 = new GpioCallback("Chip select RTD IC10", Direction::OUT, Levels::HIGH,
                                                &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_13, gpioRtdIc10);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_10, gpioRtdIc10);
   GpioCallback* gpioRtdIc11 = new GpioCallback("Chip select RTD IC11", Direction::OUT, Levels::HIGH,
                                                &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_14, gpioRtdIc11);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_11, gpioRtdIc11);
   GpioCallback* gpioRtdIc12 = new GpioCallback("Chip select RTD IC12", Direction::OUT, Levels::HIGH,
                                                &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_15, gpioRtdIc12);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_12, gpioRtdIc12);
   GpioCallback* gpioRtdIc13 = new GpioCallback("Chip select RTD IC13", Direction::OUT, Levels::HIGH,
                                                &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_16, gpioRtdIc13);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_13, gpioRtdIc13);
   GpioCallback* gpioRtdIc14 = new GpioCallback("Chip select RTD IC14", Direction::OUT, Levels::HIGH,
                                                &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_17, gpioRtdIc14);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_14, gpioRtdIc14);
   GpioCallback* gpioRtdIc15 = new GpioCallback("Chip select RTD IC15", Direction::OUT, Levels::HIGH,
                                                &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_18, gpioRtdIc15);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_15, gpioRtdIc15);
 
   gpioChecker(gpioComIF->addGpios(rtdGpioCookie), "RTDs");
 
 #if OBSW_ADD_RTD_DEVICES == 1
   using namespace EiveMax31855;
+  // ! NOTE !
+  // The chip selects for device 9 and 11 are swapped here. It is strongly suspected the cables
+  // for those devices were swapped during integration. This is probably the easiest way to
+  // fix the issue.
   std::array<std::pair<address_t, gpioId_t>, NUM_RTDS> cookieArgs = {{
+      {addresses::RTD_IC_0, gpioIds::RTD_IC_0},
+      {addresses::RTD_IC_1, gpioIds::RTD_IC_1},
+      {addresses::RTD_IC_2, gpioIds::RTD_IC_2},
       {addresses::RTD_IC_3, gpioIds::RTD_IC_3},
       {addresses::RTD_IC_4, gpioIds::RTD_IC_4},
       {addresses::RTD_IC_5, gpioIds::RTD_IC_5},
       {addresses::RTD_IC_6, gpioIds::RTD_IC_6},
       {addresses::RTD_IC_7, gpioIds::RTD_IC_7},
       {addresses::RTD_IC_8, gpioIds::RTD_IC_8},
-      {addresses::RTD_IC_9, gpioIds::RTD_IC_9},
-      {addresses::RTD_IC_10, gpioIds::RTD_IC_10},
       {addresses::RTD_IC_11, gpioIds::RTD_IC_11},
+      {addresses::RTD_IC_10, gpioIds::RTD_IC_10},
+      {addresses::RTD_IC_9, gpioIds::RTD_IC_9},
       {addresses::RTD_IC_12, gpioIds::RTD_IC_12},
       {addresses::RTD_IC_13, gpioIds::RTD_IC_13},
       {addresses::RTD_IC_14, gpioIds::RTD_IC_14},
       {addresses::RTD_IC_15, gpioIds::RTD_IC_15},
-      {addresses::RTD_IC_16, gpioIds::RTD_IC_16},
-      {addresses::RTD_IC_17, gpioIds::RTD_IC_17},
-      {addresses::RTD_IC_18, gpioIds::RTD_IC_18},
   }};
   // HSPD: Heatspreader
 
@@ -329,14 +331,23 @@ void ObjectFactory::createScexComponents(std::string uartDev, PowerSwitchIF* pwr
   scexHandler->connectModeTreeParent(satsystem::payload::SUBSYSTEM);
 }
 
-AcsController* ObjectFactory::createAcsController(bool connectSubsystem, bool enableHkSets) {
-  auto acsCtrl = new AcsController(objects::ACS_CONTROLLER, enableHkSets);
+AcsController* ObjectFactory::createAcsController(bool connectSubsystem, bool enableHkSets,
+                                                  SdCardMountedIF& mountedIF) {
+  auto acsCtrl = new AcsController(objects::ACS_CONTROLLER, enableHkSets, mountedIF);
   if (connectSubsystem) {
     acsCtrl->connectModeTreeParent(satsystem::acs::ACS_SUBSYSTEM);
   }
   return acsCtrl;
 }
 
+PowerController* ObjectFactory::createPowerController(bool connectSubsystem, bool enableHkSets) {
+  auto pwrCtrl = new PowerController(objects::POWER_CONTROLLER, enableHkSets);
+  if (connectSubsystem) {
+    pwrCtrl->connectModeTreeParent(satsystem::eps::EPS_SUBSYSTEM);
+  }
+  return pwrCtrl;
+}
+
 void ObjectFactory::gpioChecker(ReturnValue_t result, std::string output) {
   if (result != returnvalue::OK) {
     sif::error << "ObjectFactory: Adding GPIOs failed for " << output << std::endl;

linux/ObjectFactory.h

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

linux/acs/AcsBoardPolling.cpp

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

linux/acs/GPSDefinitions.h

@@ -0,0 +1,119 @@
+#ifndef MISSION_ACS_ARCHIVE_GPSDEFINITIONS_H_
+#define MISSION_ACS_ARCHIVE_GPSDEFINITIONS_H_
+
+#include "eive/eventSubsystemIds.h"
+#include "fsfw/datapoollocal/StaticLocalDataSet.h"
+#include "fsfw/devicehandlers/DeviceHandlerIF.h"
+
+namespace GpsHyperion {
+
+enum FixMode : uint8_t { NOT_SEEN = 0, NO_FIX = 1, FIX_2D = 2, FIX_3D = 3 };
+
+enum GnssChip : uint8_t { A_SIDE = 0, B_SIDE = 1 };
+
+static constexpr uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::GPS_HANDLER;
+//! [EXPORT] : [COMMENT] Fix has changed. P1: New fix. P2: Missed fix changes
+//! 0: Not seen, 1: No Fix, 2: 2D-Fix, 3: 3D-Fix
+static constexpr Event GPS_FIX_CHANGE = event::makeEvent(SUBSYSTEM_ID, 0, severity::INFO);
+//! [EXPORT] : [COMMENT] Could not get fix in maximum allowed time. Trying to reset both GNSS
+//! devices. P1: Maximum allowed time to get a fix after the GPS was switched on.
+static constexpr Event CANT_GET_FIX = event::makeEvent(SUBSYSTEM_ID, 1, severity::MEDIUM);
+//! [EXPORT] : [COMMENT] Failed to reset an GNNS Device. P1: Board-Side.
+static constexpr Event RESET_FAIL = event::makeEvent(SUBSYSTEM_ID, 2, severity::HIGH);
+
+static constexpr DeviceCommandId_t GPS_REPLY = 0;
+static constexpr DeviceCommandId_t TRIGGER_RESET_PIN_GNSS = 5;
+
+enum SetIds : uint32_t {
+  CORE_DATASET,
+  SKYVIEW_DATASET,
+};
+
+enum GpsPoolIds : lp_id_t {
+  LATITUDE,
+  LONGITUDE,
+  ALTITUDE,
+  SPEED,
+  FIX_MODE,
+  SATS_IN_USE,
+  SATS_IN_VIEW,
+  UNIX_SECONDS,
+  YEAR,
+  MONTH,
+  DAY,
+  HOURS,
+  MINUTES,
+  SECONDS,
+  SKYVIEW_UNIX_SECONDS,
+  PRN_ID,
+  AZIMUTH,
+  ELEVATION,
+  SIGNAL2NOISE,
+  USED,
+};
+
+static constexpr uint8_t CORE_DATASET_ENTRIES = 14;
+static constexpr uint8_t SKYVIEW_ENTRIES = 6;
+
+static constexpr uint8_t MAX_SATELLITES = 30;
+
+}  // namespace GpsHyperion
+
+class GpsPrimaryDataset : public StaticLocalDataSet<GpsHyperion::CORE_DATASET_ENTRIES> {
+ public:
+  GpsPrimaryDataset(object_id_t gpsId)
+      : StaticLocalDataSet(sid_t(gpsId, GpsHyperion::CORE_DATASET)) {
+    setAllVariablesReadOnly();
+  }
+
+  lp_var_t<double> latitude = lp_var_t<double>(sid.objectId, GpsHyperion::LATITUDE, this);
+  lp_var_t<double> longitude = lp_var_t<double>(sid.objectId, GpsHyperion::LONGITUDE, this);
+  lp_var_t<double> altitude = lp_var_t<double>(sid.objectId, GpsHyperion::ALTITUDE, this);
+  lp_var_t<double> speed = lp_var_t<double>(sid.objectId, GpsHyperion::SPEED, this);
+  lp_var_t<uint8_t> fixMode = lp_var_t<uint8_t>(sid.objectId, GpsHyperion::FIX_MODE, this);
+  lp_var_t<uint8_t> satInUse = lp_var_t<uint8_t>(sid.objectId, GpsHyperion::SATS_IN_USE, this);
+  lp_var_t<uint8_t> satInView = lp_var_t<uint8_t>(sid.objectId, GpsHyperion::SATS_IN_VIEW, this);
+  lp_var_t<uint16_t> year = lp_var_t<uint16_t>(sid.objectId, GpsHyperion::YEAR, this);
+  lp_var_t<uint8_t> month = lp_var_t<uint8_t>(sid.objectId, GpsHyperion::MONTH, this);
+  lp_var_t<uint8_t> day = lp_var_t<uint8_t>(sid.objectId, GpsHyperion::DAY, this);
+  lp_var_t<uint8_t> hours = lp_var_t<uint8_t>(sid.objectId, GpsHyperion::HOURS, this);
+  lp_var_t<uint8_t> minutes = lp_var_t<uint8_t>(sid.objectId, GpsHyperion::MINUTES, this);
+  lp_var_t<uint8_t> seconds = lp_var_t<uint8_t>(sid.objectId, GpsHyperion::SECONDS, this);
+  lp_var_t<uint32_t> unixSeconds =
+      lp_var_t<uint32_t>(sid.objectId, GpsHyperion::UNIX_SECONDS, this);
+
+ private:
+  friend class GpsHyperionLinuxController;
+  friend class GpsCtrlDummy;
+  GpsPrimaryDataset(HasLocalDataPoolIF* hkOwner)
+      : StaticLocalDataSet(hkOwner, GpsHyperion::CORE_DATASET) {}
+};
+
+class SkyviewDataset : public StaticLocalDataSet<GpsHyperion::SKYVIEW_ENTRIES> {
+ public:
+  SkyviewDataset(object_id_t gpsId)
+      : StaticLocalDataSet(sid_t(gpsId, GpsHyperion::SKYVIEW_DATASET)) {
+    setAllVariablesReadOnly();
+  }
+
+  lp_var_t<double> unixSeconds =
+      lp_var_t<double>(sid.objectId, GpsHyperion::SKYVIEW_UNIX_SECONDS, this);
+  lp_vec_t<int16_t, GpsHyperion::MAX_SATELLITES> prn_id =
+      lp_vec_t<int16_t, GpsHyperion::MAX_SATELLITES>(sid.objectId, GpsHyperion::PRN_ID, this);
+  lp_vec_t<int16_t, GpsHyperion::MAX_SATELLITES> azimuth =
+      lp_vec_t<int16_t, GpsHyperion::MAX_SATELLITES>(sid.objectId, GpsHyperion::AZIMUTH, this);
+  lp_vec_t<int16_t, GpsHyperion::MAX_SATELLITES> elevation =
+      lp_vec_t<int16_t, GpsHyperion::MAX_SATELLITES>(sid.objectId, GpsHyperion::ELEVATION, this);
+  lp_vec_t<double, GpsHyperion::MAX_SATELLITES> signal2noise =
+      lp_vec_t<double, GpsHyperion::MAX_SATELLITES>(sid.objectId, GpsHyperion::SIGNAL2NOISE, this);
+  lp_vec_t<uint8_t, GpsHyperion::MAX_SATELLITES> used =
+      lp_vec_t<uint8_t, GpsHyperion::MAX_SATELLITES>(sid.objectId, GpsHyperion::USED, this);
+
+ private:
+  friend class GpsHyperionLinuxController;
+  friend class GpsCtrlDummy;
+  SkyviewDataset(HasLocalDataPoolIF* hkOwner)
+      : StaticLocalDataSet(hkOwner, GpsHyperion::SKYVIEW_DATASET) {}
+};
+
+#endif /* MISSION_ACS_ARCHIVE_GPSDEFINITIONS_H_ */

linux/acs/GpsHyperionLinuxController.cpp

@@ -21,6 +21,7 @@ GpsHyperionLinuxController::GpsHyperionLinuxController(object_id_t objectId, obj
                                                        bool enableHkSets, bool debugHyperionGps)
     : ExtendedControllerBase(objectId),
       gpsSet(this),
+      skyviewSet(this),
       enableHkSets(enableHkSets),
       debugHyperionGps(debugHyperionGps) {}
 
@@ -29,28 +30,35 @@ GpsHyperionLinuxController::~GpsHyperionLinuxController() {
   gps_close(&gps);
 }
 
-LocalPoolDataSetBase *GpsHyperionLinuxController::getDataSetHandle(sid_t sid) { return &gpsSet; }
+LocalPoolDataSetBase *GpsHyperionLinuxController::getDataSetHandle(sid_t sid) {
+  switch (sid.ownerSetId) {
+    case GpsHyperion::CORE_DATASET:
+      return &gpsSet;
+    case GpsHyperion::SKYVIEW_DATASET:
+      return &skyviewSet;
+    default:
+      return nullptr;
+  }
+  return nullptr;
+}
 
 ReturnValue_t GpsHyperionLinuxController::checkModeCommand(Mode_t mode, Submode_t submode,
                                                            uint32_t *msToReachTheMode) {
-  if (not modeCommanded) {
-    if (mode == MODE_ON or mode == MODE_OFF) {
-      // 5h time to reach fix
-      *msToReachTheMode = MAX_SECONDS_TO_REACH_FIX;
-      maxTimeToReachFix.resetTimer();
-      modeCommanded = true;
-    } else if (mode == MODE_NORMAL) {
-      return HasModesIF::INVALID_MODE;
-    }
+  if (mode == MODE_ON) {
+    maxTimeToReachFix.resetTimer();
+    gainedNewFix.timeOut();
+  } else if (mode == MODE_NORMAL) {
+    return HasModesIF::INVALID_MODE;
   }
   if (mode == MODE_OFF) {
+    maxTimeToReachFix.timeOut();
+    gainedNewFix.timeOut();
     PoolReadGuard pg(&gpsSet);
     gpsSet.setValidity(false, true);
-    // There can't be a fix with a device that is off.
-    triggerEvent(GpsHyperion::GPS_FIX_CHANGE, gpsSet.fixMode.value, 0);
-    gpsSet.fixMode.value = 0;
+    // The ctrl is off, so it cannot detect the data from the devices.
+    handleFixChangedEvent(GpsHyperion::FixMode::NOT_SEEN);
+    gpsSet.fixMode.value = GpsHyperion::FixMode::NOT_SEEN;
     oneShotSwitches.reset();
-    modeCommanded = false;
   }
   return returnvalue::OK;
 }
@@ -64,13 +72,16 @@ ReturnValue_t GpsHyperionLinuxController::executeAction(ActionId_t actionId,
         PoolReadGuard pg(&gpsSet);
         // Set HK entries invalid
         gpsSet.setValidity(false, true);
-        resetCallback(data, size, resetCallbackArgs);
+        ReturnValue_t result = resetCallback(data, size, resetCallbackArgs);
+        if (result != returnvalue::OK) {
+          return result;
+        }
         return HasActionsIF::EXECUTION_FINISHED;
       }
       return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
     }
   }
-  return returnvalue::OK;
+  return HasActionsIF::INVALID_ACTION_ID;
 }
 
 ReturnValue_t GpsHyperionLinuxController::initializeLocalDataPool(
@@ -90,6 +101,13 @@ ReturnValue_t GpsHyperionLinuxController::initializeLocalDataPool(
   localDataPoolMap.emplace(GpsHyperion::SATS_IN_VIEW, new PoolEntry<uint8_t>());
   localDataPoolMap.emplace(GpsHyperion::FIX_MODE, new PoolEntry<uint8_t>());
   poolManager.subscribeForRegularPeriodicPacket({gpsSet.getSid(), enableHkSets, 30.0});
+  localDataPoolMap.emplace(GpsHyperion::SKYVIEW_UNIX_SECONDS, new PoolEntry<double>());
+  localDataPoolMap.emplace(GpsHyperion::PRN_ID, new PoolEntry<int16_t>());
+  localDataPoolMap.emplace(GpsHyperion::AZIMUTH, new PoolEntry<int16_t>());
+  localDataPoolMap.emplace(GpsHyperion::ELEVATION, new PoolEntry<int16_t>());
+  localDataPoolMap.emplace(GpsHyperion::SIGNAL2NOISE, new PoolEntry<double>());
+  localDataPoolMap.emplace(GpsHyperion::USED, new PoolEntry<uint8_t>());
+  poolManager.subscribeForRegularPeriodicPacket({skyviewSet.getSid(), false, 120.0});
   return returnvalue::OK;
 }
 
@@ -166,49 +184,53 @@ bool GpsHyperionLinuxController::readGpsDataFromGpsd() {
   if (mode == MODE_OFF) {
     return false;
   }
+  unsigned int readIdx = 0;
   if (readMode == ReadModes::SOCKET) {
     // Poll the GPS.
-    if (gps_waiting(&gps, 0)) {
-      if (-1 == gps_read(&gps)) {
+    while (gps_waiting(&gps, 0)) {
+      int retval = gps_read(&gps);
+      if (retval < 0) {
         readError();
         return false;
       }
-      oneShotSwitches.gpsReadFailedSwitch = true;
-      ReturnValue_t result = handleGpsReadData();
-      if (result == returnvalue::OK) {
-        return true;
-      } else {
-        return false;
+      readIdx++;
+      if (readIdx >= 40) {
+        sif::warning << "GpsHyperionLinuxController: Received " << readIdx
+                     << " GPSD message consecutively" << std::endl;
+        break;
       }
-      noModeSetCntr = 0;
-    } else {
-      return false;
+    }
+    if (readIdx > 0) {
+      oneShotSwitches.gpsReadFailedSwitch = true;
+      handleGpsReadData();
     }
   } else if (readMode == ReadModes::SHM) {
     sif::error << "GpsHyperionLinuxController::readGpsDataFromGpsdPermanentLoop: "
                   "SHM read not implemented"
                << std::endl;
   }
-  return true;
+  return false;
 }
 
 ReturnValue_t GpsHyperionLinuxController::handleGpsReadData() {
   bool modeIsSet = true;
   if (MODE_SET != (MODE_SET & gps.set)) {
     if (mode != MODE_OFF) {
-      if (maxTimeToReachFix.hasTimedOut() and oneShotSwitches.cantGetFixSwitch) {
-        sif::warning << "GpsHyperionLinuxController: No mode could be set in allowed "
-                     << maxTimeToReachFix.getTimeoutMs() / 1000 << " seconds" << std::endl;
-        triggerEvent(GpsHyperion::CANT_GET_FIX, maxTimeToReachFix.getTimeoutMs());
-        oneShotSwitches.cantGetFixSwitch = false;
-      }
       modeIsSet = false;
     } else {
-      // GPS device is off anyway, so do other handling
+      // GPS ctrl is off anyway, so do other handling
       return returnvalue::FAILED;
     }
   }
+  ReturnValue_t result = handleCoreTelemetry(modeIsSet);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = handleSkyviewTelemetry();
+  return result;
+}
 
+ReturnValue_t GpsHyperionLinuxController::handleCoreTelemetry(bool modeIsSet) {
   PoolReadGuard pg(&gpsSet);
   if (pg.getReadResult() != returnvalue::OK) {
 #if FSFW_VERBOSE_LEVEL >= 1
@@ -221,25 +243,44 @@ ReturnValue_t GpsHyperionLinuxController::handleGpsReadData() {
   uint8_t newFix = 0;
   if (modeIsSet) {
     // 0: Not seen, 1: No fix, 2: 2D-Fix, 3: 3D-Fix
-    if (gps.fix.mode == 2 or gps.fix.mode == 3) {
+    if (gps.fix.mode == GpsHyperion::FixMode::FIX_2D or
+        gps.fix.mode == GpsHyperion::FixMode::FIX_3D) {
       validFix = true;
+      maxTimeToReachFix.resetTimer();
     }
     newFix = gps.fix.mode;
-    if (newFix == 0 or newFix == 1) {
-      if (modeCommanded and maxTimeToReachFix.hasTimedOut()) {
-        // We are supposed to be on and functioning, but no fix was found
-        if (mode == MODE_ON or mode == MODE_NORMAL) {
-          mode = MODE_OFF;
-        }
-        modeCommanded = false;
-      }
-    }
   }
   if (gpsSet.fixMode.value != newFix) {
-    triggerEvent(GpsHyperion::GPS_FIX_CHANGE, gpsSet.fixMode.value, newFix);
+    handleFixChangedEvent(newFix);
   }
   gpsSet.fixMode = newFix;
   gpsSet.fixMode.setValid(modeIsSet);
+  // We are supposed to be on and functioning, but no fix was found
+  if (not validFix) {
+    if (maxTimeToReachFix.hasTimedOut()) {
+      // Set HK entries invalid
+      gpsSet.setValidity(false, true);
+      if (oneShotSwitches.cantGetFixSwitch) {
+        sif::warning << "GpsHyperionLinuxController: No fix detected in allowed "
+                     << maxTimeToReachFix.getTimeoutMs() / 1000 << " seconds" << std::endl;
+        triggerEvent(GpsHyperion::CANT_GET_FIX, maxTimeToReachFix.getTimeoutMs());
+        oneShotSwitches.cantGetFixSwitch = false;
+        // Try resetting the devices
+        if (resetCallback != nullptr) {
+          uint8_t chip = GpsHyperion::GnssChip::A_SIDE;
+          ReturnValue_t result = resetCallback(&chip, 1, resetCallbackArgs);
+          if (result != returnvalue::OK) {
+            triggerEvent(GpsHyperion::RESET_FAIL, chip);
+          }
+          chip = GpsHyperion::GnssChip::B_SIDE;
+          result = resetCallback(&chip, 1, resetCallbackArgs);
+          if (result != returnvalue::OK) {
+            triggerEvent(GpsHyperion::RESET_FAIL, chip);
+          }
+        }
+      }
+    }
+  }
 
   // Only set on specific messages, so only set a valid flag to invalid
   // if not set for more than a full message set (10 messages here)
@@ -252,9 +293,12 @@ ReturnValue_t GpsHyperionLinuxController::handleGpsReadData() {
     }
     satNotSetCounter = 0;
   } else {
-    satNotSetCounter++;
-    if (gpsSet.satInUse.isValid() and satNotSetCounter >= 10) {
+    if (satNotSetCounter < 10) {
+      satNotSetCounter++;
+    } else {
+      gpsSet.satInUse.value = 0;
       gpsSet.satInUse.setValid(false);
+      gpsSet.satInView.value = 0;
       gpsSet.satInView.setValid(false);
     }
   }
@@ -262,22 +306,24 @@ ReturnValue_t GpsHyperionLinuxController::handleGpsReadData() {
   // LATLON is set for every message, no need for a counter
   bool latValid = false;
   bool longValid = false;
-  if (LATLON_SET == (LATLON_SET & gps.set)) {
-    if (std::isfinite(gps.fix.latitude)) {
-      // Negative latitude -> South direction
-      gpsSet.latitude.value = gps.fix.latitude;
-      // As specified in gps.h: Only valid if mode >= 2
-      if (gps.fix.mode >= 2) {
-        latValid = true;
+  if (modeIsSet) {
+    if (LATLON_SET == (LATLON_SET & gps.set)) {
+      if (std::isfinite(gps.fix.latitude)) {
+        // Negative latitude -> South direction
+        gpsSet.latitude.value = gps.fix.latitude;
+        // As specified in gps.h: Only valid if mode >= 2
+        if (gps.fix.mode >= GpsHyperion::FixMode::FIX_2D) {
+          latValid = true;
+        }
       }
-    }
 
-    if (std::isfinite(gps.fix.longitude)) {
-      // Negative longitude -> West direction
-      gpsSet.longitude.value = gps.fix.longitude;
-      // As specified in gps.h: Only valid if mode >= 2
-      if (gps.fix.mode >= 2) {
-        longValid = true;
+      if (std::isfinite(gps.fix.longitude)) {
+        // Negative longitude -> West direction
+        gpsSet.longitude.value = gps.fix.longitude;
+        // As specified in gps.h: Only valid if mode >= 2
+        if (gps.fix.mode >= GpsHyperion::FixMode::FIX_2D) {
+          longValid = true;
+        }
       }
     }
   }
@@ -286,20 +332,24 @@ ReturnValue_t GpsHyperionLinuxController::handleGpsReadData() {
 
   // ALTITUDE is set for every message, no need for a counter
   bool altitudeValid = false;
-  if (ALTITUDE_SET == (ALTITUDE_SET & gps.set) && std::isfinite(gps.fix.altitude)) {
-    gpsSet.altitude.value = gps.fix.altitude;
-    // As specified in gps.h: Only valid if mode == 3
-    if (gps.fix.mode == 3) {
-      altitudeValid = true;
+  if (modeIsSet) {
+    if (ALTITUDE_SET == (ALTITUDE_SET & gps.set) && std::isfinite(gps.fix.altitude)) {
+      gpsSet.altitude.value = gps.fix.altitude;
+      // As specified in gps.h: Only valid if mode == 3
+      if (gps.fix.mode == GpsHyperion::FixMode::FIX_3D) {
+        altitudeValid = true;
+      }
     }
   }
   gpsSet.altitude.setValid(altitudeValid);
 
   // SPEED is set for every message, no need for a counter
   bool speedValid = false;
-  if (SPEED_SET == (SPEED_SET & gps.set) && std::isfinite(gps.fix.speed)) {
-    gpsSet.speed.value = gps.fix.speed;
-    speedValid = true;
+  if (modeIsSet) {
+    if (SPEED_SET == (SPEED_SET & gps.set) && std::isfinite(gps.fix.speed)) {
+      gpsSet.speed.value = gps.fix.speed;
+      speedValid = true;
+    }
   }
   gpsSet.speed.setValid(speedValid);
 
@@ -369,6 +419,22 @@ ReturnValue_t GpsHyperionLinuxController::handleGpsReadData() {
   return returnvalue::OK;
 }
 
+ReturnValue_t GpsHyperionLinuxController::handleSkyviewTelemetry() {
+  PoolReadGuard pg(&skyviewSet);
+  if (pg.getReadResult() != returnvalue::OK) {
+    return returnvalue::FAILED;
+  }
+  skyviewSet.unixSeconds.value = gps.skyview_time;
+  for (int sat = 0; sat < GpsHyperion::MAX_SATELLITES; sat++) {
+    skyviewSet.prn_id.value[sat] = gps.skyview[sat].PRN;
+    skyviewSet.azimuth.value[sat] = gps.skyview[sat].azimuth;
+    skyviewSet.elevation.value[sat] = gps.skyview[sat].elevation;
+    skyviewSet.signal2noise.value[sat] = gps.skyview[sat].ss;
+    skyviewSet.used.value[sat] = gps.skyview[sat].used;
+  }
+  return returnvalue::OK;
+}
+
 void GpsHyperionLinuxController::overwriteTimeIfNotSane(timeval time, bool validFix) {
   if (not timeInit and validFix) {
     if (not utility::timeSanityCheck()) {
@@ -384,3 +450,14 @@ void GpsHyperionLinuxController::overwriteTimeIfNotSane(timeval time, bool valid
     timeInit = true;
   }
 }
+
+void GpsHyperionLinuxController::handleFixChangedEvent(uint8_t newFix) {
+  if (gainedNewFix.hasTimedOut()) {
+    triggerEvent(GpsHyperion::GPS_FIX_CHANGE, newFix, fixChangeCounter);
+    fixChangeCounter = 0;
+    gainedNewFix.resetTimer();
+    return;
+  }
+  fixChangeCounter++;
+  gainedNewFix.resetTimer();
+}

linux/acs/GpsHyperionLinuxController.h

@@ -1,14 +1,13 @@
 #ifndef MISSION_DEVICES_GPSHYPERIONHANDLER_H_
 #define MISSION_DEVICES_GPSHYPERIONHANDLER_H_
 
-#include <mission/acs/archive/GPSDefinitions.h>
+#include <common/config/eive/eventSubsystemIds.h>
+#include <fsfw/FSFW.h>
+#include <fsfw/controller/ExtendedControllerBase.h>
+#include <fsfw/devicehandlers/DeviceHandlerBase.h>
+#include <linux/acs/GPSDefinitions.h>
 #include <mission/utility/trace.h>
 
-#include "eive/eventSubsystemIds.h"
-#include "fsfw/FSFW.h"
-#include "fsfw/controller/ExtendedControllerBase.h"
-#include "fsfw/devicehandlers/DeviceHandlerBase.h"
-
 #ifdef FSFW_OSAL_LINUX
 #include <gps.h>
 #include <libgpsmm.h>
@@ -24,8 +23,8 @@
  */
 class GpsHyperionLinuxController : public ExtendedControllerBase {
  public:
-  // 30 minutes
-  static constexpr uint32_t MAX_SECONDS_TO_REACH_FIX = 60 * 30;
+  // 15 minutes
+  static constexpr uint32_t MAX_SECONDS_TO_REACH_FIX = 60 * 15;
 
   enum ReadModes { SHM = 0, SOCKET = 1 };
 
@@ -54,15 +53,19 @@ class GpsHyperionLinuxController : public ExtendedControllerBase {
                                         LocalDataPoolManager& poolManager) override;
 
   ReturnValue_t handleGpsReadData();
+  ReturnValue_t handleCoreTelemetry(bool modeIsSet);
+  ReturnValue_t handleSkyviewTelemetry();
 
  private:
   GpsPrimaryDataset gpsSet;
+  SkyviewDataset skyviewSet;
   gps_data_t gps = {};
   bool enableHkSets = false;
   const char* currentClientBuf = nullptr;
   ReadModes readMode = ReadModes::SOCKET;
   Countdown maxTimeToReachFix = Countdown(MAX_SECONDS_TO_REACH_FIX * 1000);
-  bool modeCommanded = false;
+  Countdown gainedNewFix = Countdown(60 * 2 * 1000);
+  uint32_t fixChangeCounter = 0;
   bool timeInit = false;
   uint8_t satNotSetCounter = 0;
 
@@ -81,7 +84,6 @@ class GpsHyperionLinuxController : public ExtendedControllerBase {
   } oneShotSwitches;
 
   bool debugHyperionGps = false;
-  int32_t noModeSetCntr = 0;
 
   // Returns true if the function should be called again or false if other
   // controller handling can be done.
@@ -90,6 +92,8 @@ class GpsHyperionLinuxController : public ExtendedControllerBase {
   // we set it with the roughly valid time from the GPS. For some reason, NTP might only work
   // if the time difference between sys time and current time is not too large
   void overwriteTimeIfNotSane(timeval time, bool validFix);
+
+  void handleFixChangedEvent(uint8_t newFix);
 };
 
 #endif /* MISSION_DEVICES_GPSHYPERIONHANDLER_H_ */

linux/acs/StrComHandler.cpp

@@ -2,6 +2,7 @@
 
 #include <fcntl.h>
 #include <fsfw/filesystem/HasFileSystemIF.h>
+#include <fsfw/globalfunctions/arrayprinter.h>
 #include <fsfw/tasks/TaskFactory.h>
 #include <fsfw/timemanager/Stopwatch.h>
 #include <mission/acs/str/strHelpers.h>
@@ -23,6 +24,8 @@ extern "C" {
 
 using namespace returnvalue;
 
+static constexpr bool PACKET_WIRETAPPING = false;
+
 StrComHandler::StrComHandler(object_id_t objectId) : SystemObject(objectId) {
   lock = MutexFactory::instance()->createMutex();
   semaphore.acquire();
@@ -51,8 +54,8 @@ ReturnValue_t StrComHandler::performOperation(uint8_t operationCode) {
     switch (state) {
       case InternalState::POLL_ONE_REPLY: {
         // Stopwatch watch;
-        replyTimeout.setTimeout(200);
-        replyResult = readOneReply(static_cast<uint32_t>(state));
+        replyTimeout.setTimeout(400);
+        readOneReply(static_cast<uint32_t>(state));
         {
           MutexGuard mg(lock);
           replyWasReceived = true;
@@ -172,7 +175,8 @@ void StrComHandler::setDownloadImageName(std::string filename) {
 
 void StrComHandler::setFlashReadFilename(std::string filename) { flashRead.filename = filename; }
 
-ReturnValue_t StrComHandler::startFirmwareUpdate(std::string fullname) {
+ReturnValue_t StrComHandler::startFirmwareUpdate(std::string fullname,
+                                                 startracker::FirmwareTarget target) {
   {
     MutexGuard mg(lock);
     if (state != InternalState::SLEEPING) {
@@ -189,8 +193,13 @@ ReturnValue_t StrComHandler::startFirmwareUpdate(std::string fullname) {
   if (not std::filesystem::exists(flashWrite.fullname)) {
     return FILE_NOT_EXISTS;
   }
-  flashWrite.firstRegion = static_cast<uint8_t>(startracker::FirmwareRegions::FIRST);
-  flashWrite.lastRegion = static_cast<uint8_t>(startracker::FirmwareRegions::LAST);
+  if (target == startracker::FirmwareTarget::MAIN) {
+    flashWrite.firstRegion = static_cast<uint8_t>(startracker::FirmwareRegions::FIRST_MAIN);
+    flashWrite.lastRegion = static_cast<uint8_t>(startracker::FirmwareRegions::LAST_MAIN);
+  } else if (target == startracker::FirmwareTarget::BACKUP) {
+    flashWrite.firstRegion = static_cast<uint8_t>(startracker::FirmwareRegions::FIRST_BACKUP);
+    flashWrite.lastRegion = static_cast<uint8_t>(startracker::FirmwareRegions::LAST_BACKUP);
+  }
   {
     MutexGuard mg(lock);
     replyWasReceived = false;
@@ -261,7 +270,7 @@ ReturnValue_t StrComHandler::performImageDownload() {
       file.close();
       return returnvalue::OK;
     }
-    arc_pack_download_action_req(&downloadReq, cmdBuf.data(), &size);
+    prv_arc_pack_download_action_req(&downloadReq, cmdBuf.data(), &size);
     result = sendAndRead(size, downloadReq.position);
     if (result != returnvalue::OK) {
       if (retries < CONFIG_MAX_DOWNLOAD_RETRIES) {
@@ -272,7 +281,7 @@ ReturnValue_t StrComHandler::performImageDownload() {
       file.close();
       return result;
     }
-    result = checkActionReply(replySize);
+    result = checkActionReply(replySize, "downloading image");
     if (result != returnvalue::OK) {
       if (retries < CONFIG_MAX_DOWNLOAD_RETRIES) {
         serial::flushRxBuf(serialPort);
@@ -340,12 +349,12 @@ ReturnValue_t StrComHandler::performImageUpload() {
     }
     file.seekg(uploadReq.position * SIZE_IMAGE_PART, file.beg);
     file.read(reinterpret_cast<char*>(uploadReq.data), SIZE_IMAGE_PART);
-    arc_pack_upload_action_req(&uploadReq, cmdBuf.data(), &size);
+    prv_arc_pack_upload_action_req(&uploadReq, cmdBuf.data(), &size);
     result = sendAndRead(size, uploadReq.position);
     if (result != returnvalue::OK) {
       return returnvalue::FAILED;
     }
-    result = checkActionReply(replyLen);
+    result = checkActionReply(replyLen, "sky image upload");
     if (result != returnvalue::OK) {
       return result;
     }
@@ -366,12 +375,12 @@ ReturnValue_t StrComHandler::performImageUpload() {
     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);
+    prv_arc_pack_upload_action_req(&uploadReq, cmdBuf.data(), &size);
     result = sendAndRead(size, uploadReq.position);
     if (result != returnvalue::OK) {
       return returnvalue::FAILED;
     }
-    result = checkActionReply(replyLen);
+    result = checkActionReply(replyLen, "sky image upload");
     if (result != returnvalue::OK) {
       return result;
     }
@@ -385,8 +394,7 @@ ReturnValue_t StrComHandler::performImageUpload() {
 ReturnValue_t StrComHandler::performFirmwareUpdate() {
   using namespace startracker;
   ReturnValue_t result = returnvalue::OK;
-  result = unlockAndEraseRegions(static_cast<uint32_t>(startracker::FirmwareRegions::FIRST),
-                                 static_cast<uint32_t>(startracker::FirmwareRegions::LAST));
+  result = unlockAndEraseRegions(flashWrite.firstRegion, flashWrite.lastRegion);
   if (result != returnvalue::OK) {
     return result;
   }
@@ -437,12 +445,12 @@ ReturnValue_t StrComHandler::performFlashWrite() {
       bytesWrittenInRegion = 0;
     }
     req.address = bytesWrittenInRegion;
-    arc_pack_write_action_req(&req, cmdBuf.data(), &size);
+    prv_arc_pack_write_action_req(&req, cmdBuf.data(), &size);
     result = sendAndRead(size, req.address);
     if (result != returnvalue::OK) {
       return result;
     }
-    result = checkActionReply(replyLen);
+    result = checkActionReply(replyLen, "firmware image upload");
     if (result != returnvalue::OK) {
       return result;
     }
@@ -480,12 +488,12 @@ ReturnValue_t StrComHandler::performFlashWrite() {
     req.length = remainingBytes;
     totalBytesWritten += CHUNK_SIZE;
     bytesWrittenInRegion += remainingBytes;
-    arc_pack_write_action_req(&req, cmdBuf.data(), &size);
+    prv_arc_pack_write_action_req(&req, cmdBuf.data(), &size);
     result = sendAndRead(size, req.address);
     if (result != returnvalue::OK) {
       return result;
     }
-    result = checkActionReply(replyLen);
+    result = checkActionReply(replyLen, "flash write");
     if (result != returnvalue::OK) {
       return result;
     }
@@ -528,7 +536,7 @@ ReturnValue_t StrComHandler::performFlashRead() {
     } else {
       req.length = CHUNK_SIZE;
     }
-    arc_pack_read_action_req(&req, cmdBuf.data(), &size);
+    prv_arc_pack_read_action_req(&req, cmdBuf.data(), &size);
     result = sendAndRead(size, req.address);
     if (result != returnvalue::OK) {
       if (retries < CONFIG_MAX_DOWNLOAD_RETRIES) {
@@ -539,7 +547,7 @@ ReturnValue_t StrComHandler::performFlashRead() {
       file.close();
       return result;
     }
-    result = checkActionReply(replyLen);
+    result = checkActionReply(replyLen, "flash read");
     if (result != returnvalue::OK) {
       if (retries < CONFIG_MAX_DOWNLOAD_RETRIES) {
         serial::flushRxBuf(serialPort);
@@ -581,7 +589,7 @@ ReturnValue_t StrComHandler::sendAndRead(size_t size, uint32_t failParameter) {
   return readOneReply(failParameter);
 }
 
-ReturnValue_t StrComHandler::checkActionReply(size_t replySize) {
+ReturnValue_t StrComHandler::checkActionReply(size_t replySize, const char* context) {
   uint8_t type = startracker::getReplyFrameType(replyPtr);
   if (type != TMTC_ACTIONREPLY) {
     sif::warning << "StrHelper::checkActionReply: Received reply with invalid type ID" << std::endl;
@@ -589,7 +597,7 @@ ReturnValue_t StrComHandler::checkActionReply(size_t replySize) {
   }
   uint8_t status = startracker::getStatusField(replyPtr);
   if (status != ArcsecDatalinkLayer::STATUS_OK) {
-    sif::warning << "StrHelper::checkActionReply: Status failure: "
+    sif::warning << "StrHelper::checkActionReply: Status failure for " << context << ": "
                  << static_cast<unsigned int>(status) << std::endl;
     return STATUS_ERROR;
   }
@@ -680,6 +688,10 @@ ReturnValue_t StrComHandler::sendMessage(CookieIF* cookie, const uint8_t* sendDa
   const uint8_t* txFrame;
   size_t frameLen;
   datalinkLayer.encodeFrame(sendData, sendLen, &txFrame, frameLen);
+  if (PACKET_WIRETAPPING) {
+    sif::debug << "Sending STR frame" << std::endl;
+    arrayprinter::print(txFrame, frameLen);
+  }
   ssize_t bytesWritten = write(serialPort, txFrame, frameLen);
   if (bytesWritten != static_cast<ssize_t>(frameLen)) {
     sif::warning << "StrComHandler: Sending packet failed" << std::endl;
@@ -709,8 +721,6 @@ ReturnValue_t StrComHandler::requestReceiveMessage(CookieIF* cookie, size_t requ
 }
 
 ReturnValue_t StrComHandler::readReceivedMessage(CookieIF* cookie, uint8_t** buffer, size_t* size) {
-  // Consider it a configuration error if the task is not done with a command -> reply cycle
-  // in time.
   bool replyWasReceived = false;
   {
     MutexGuard mg(lock);
@@ -739,23 +749,26 @@ ReturnValue_t StrComHandler::unlockAndEraseRegions(uint32_t from, uint32_t to) {
   struct UnlockActionRequest unlockReq;
   struct EraseActionRequest eraseReq;
   uint32_t size = 0;
-  for (uint32_t idx = from; idx <= to; idx++) {
+  for (uint32_t idx = from; idx < to; idx++) {
     unlockReq.region = idx;
-    unlockReq.code = startracker::region_secrets::secret[idx];
-    arc_pack_unlock_action_req(&unlockReq, cmdBuf.data(), &size);
+    unlockReq.code = startracker::region_secrets::SECRETS[idx];
+    prv_arc_pack_unlock_action_req(&unlockReq, cmdBuf.data(), &size);
     result = sendAndRead(size, unlockReq.region);
     if (result != returnvalue::OK) {
       return result;
     }
-    result = checkActionReply(replyLen);
+    result = checkActionReply(replyLen, "unlocking region");
     if (result != returnvalue::OK) {
       sif::warning << "StrHelper::unlockAndEraseRegions: Failed to unlock region with id "
                    << static_cast<unsigned int>(unlockReq.region) << std::endl;
       return result;
     }
     eraseReq.region = idx;
-    arc_pack_erase_action_req(&eraseReq, cmdBuf.data(), &size);
+    prv_arc_pack_erase_action_req(&eraseReq, cmdBuf.data(), &size);
     result = sendAndRead(size, eraseReq.region);
+    if (result != returnvalue::OK) {
+    }
+    result = checkActionReply(replyLen, "erasing region");
     if (result != returnvalue::OK) {
       sif::warning << "StrHelper::unlockAndEraseRegions: Failed to erase region with id "
                    << static_cast<unsigned int>(eraseReq.region) << std::endl;
@@ -782,8 +795,10 @@ ReturnValue_t StrComHandler::handleSerialReception() {
                << std::endl;
     return FAILED;
   } else if (bytesRead > 0) {
-    // sif::info << "Received " << bytesRead << " bytes from the STR" << std::endl;
-    // arrayprinter::print(recBuf.data(), bytesRead);
+    if (PACKET_WIRETAPPING) {
+      sif::info << "Received " << bytesRead << " bytes from the STR" << std::endl;
+      arrayprinter::print(recBuf.data(), bytesRead);
+    }
     datalinkLayer.feedData(recBuf.data(), bytesRead);
   }
   return OK;
@@ -797,6 +812,10 @@ ReturnValue_t StrComHandler::readOneReply(uint32_t failParameter) {
     handleSerialReception();
     result = datalinkLayer.checkRingBufForFrame(&replyPtr, replyLen);
     if (result == returnvalue::OK) {
+      if (PACKET_WIRETAPPING) {
+        sif::debug << "Received STR reply frame" << std::endl;
+        arrayprinter::print(replyPtr, replyLen);
+      }
       return returnvalue::OK;
     } else if (result != ArcsecDatalinkLayer::DEC_IN_PROGRESS) {
       triggerEvent(STR_HELPER_DEC_ERROR, result, failParameter);

linux/acs/StrComHandler.h

@@ -6,6 +6,7 @@
 #include <string>
 
 #include "OBSWConfig.h"
+#include "mission/acs/str/strHelpers.h"
 
 #ifdef XIPHOS_Q7S
 #include "bsp_q7s/fs/SdCardManager.h"
@@ -127,7 +128,7 @@ class StrComHandler : public SystemObject, public DeviceCommunicationIF, public
    * @param fullname    Full name including absolute path of file containing firmware
    *                    update.
    */
-  ReturnValue_t startFirmwareUpdate(std::string fullname);
+  ReturnValue_t startFirmwareUpdate(std::string fullname, startracker::FirmwareTarget target);
 
   /**
    * @brief   Starts the flash read procedure
@@ -334,7 +335,7 @@ class StrComHandler : public SystemObject, public DeviceCommunicationIF, public
    *
    * @return  returnvalue::OK if reply confirms success of packet transfer, otherwise REUTRN_FAILED
    */
-  ReturnValue_t checkActionReply(size_t replySize);
+  ReturnValue_t checkActionReply(size_t replySize, const char *context);
 
   /**
    * @brief   Checks the position field in a star tracker upload/download reply.

linux/acs/SusPolling.cpp

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

linux/boardtest/UartTestClass.h

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

linux/callbacks/gpioCallbacks.cpp

@@ -21,6 +21,18 @@ void gpioCallbacks::spiCsDecoderCallback(gpioId_t gpioId, gpio::GpioOperation gp
 
   if (value == gpio::Levels::HIGH) {
     switch (gpioId) {
+      case (gpioIds::RTD_IC_0): {
+        disableDecoderTcsIc1(gpioIF);
+        break;
+      }
+      case (gpioIds::RTD_IC_1): {
+        disableDecoderTcsIc1(gpioIF);
+        break;
+      }
+      case (gpioIds::RTD_IC_2): {
+        disableDecoderTcsIc1(gpioIF);
+        break;
+      }
       case (gpioIds::RTD_IC_3): {
         disableDecoderTcsIc1(gpioIF);
         break;
@@ -42,15 +54,15 @@ void gpioCallbacks::spiCsDecoderCallback(gpioId_t gpioId, gpio::GpioOperation gp
         break;
       }
       case (gpioIds::RTD_IC_8): {
-        disableDecoderTcsIc1(gpioIF);
+        disableDecoderTcsIc2(gpioIF);
         break;
       }
       case (gpioIds::RTD_IC_9): {
-        disableDecoderTcsIc1(gpioIF);
+        disableDecoderTcsIc2(gpioIF);
         break;
       }
       case (gpioIds::RTD_IC_10): {
-        disableDecoderTcsIc1(gpioIF);
+        disableDecoderTcsIc2(gpioIF);
         break;
       }
       case (gpioIds::RTD_IC_11): {
@@ -73,18 +85,6 @@ void gpioCallbacks::spiCsDecoderCallback(gpioId_t gpioId, gpio::GpioOperation gp
         disableDecoderTcsIc2(gpioIF);
         break;
       }
-      case (gpioIds::RTD_IC_16): {
-        disableDecoderTcsIc2(gpioIF);
-        break;
-      }
-      case (gpioIds::RTD_IC_17): {
-        disableDecoderTcsIc2(gpioIF);
-        break;
-      }
-      case (gpioIds::RTD_IC_18): {
-        disableDecoderTcsIc2(gpioIF);
-        break;
-      }
       case (gpioIds::CS_SUS_0): {
         disableDecoderInterfaceBoardIc1(gpioIF);
         break;
@@ -154,82 +154,82 @@ void gpioCallbacks::spiCsDecoderCallback(gpioId_t gpioId, gpio::GpioOperation gp
     }
   } else if (value == gpio::Levels::LOW) {
     switch (gpioId) {
-      case (gpioIds::RTD_IC_3): {
+      case (gpioIds::RTD_IC_0): {
         selectY7(gpioIF);
         enableDecoderTcsIc1(gpioIF);
         break;
       }
+      case (gpioIds::RTD_IC_1): {
+        selectY6(gpioIF);
+        enableDecoderTcsIc1(gpioIF);
+        break;
+      }
+      case (gpioIds::RTD_IC_2): {
+        selectY5(gpioIF);
+        enableDecoderTcsIc1(gpioIF);
+        break;
+      }
+      case (gpioIds::RTD_IC_3): {
+        selectY4(gpioIF);
+        enableDecoderTcsIc1(gpioIF);
+        break;
+      }
       case (gpioIds::RTD_IC_4): {
-        selectY6(gpioIF);
+        selectY3(gpioIF);
         enableDecoderTcsIc1(gpioIF);
         break;
       }
       case (gpioIds::RTD_IC_5): {
-        selectY5(gpioIF);
+        selectY2(gpioIF);
         enableDecoderTcsIc1(gpioIF);
         break;
       }
       case (gpioIds::RTD_IC_6): {
-        selectY4(gpioIF);
+        selectY1(gpioIF);
         enableDecoderTcsIc1(gpioIF);
         break;
       }
       case (gpioIds::RTD_IC_7): {
-        selectY3(gpioIF);
-        enableDecoderTcsIc1(gpioIF);
-        break;
-      }
-      case (gpioIds::RTD_IC_8): {
-        selectY2(gpioIF);
-        enableDecoderTcsIc1(gpioIF);
-        break;
-      }
-      case (gpioIds::RTD_IC_9): {
-        selectY1(gpioIF);
-        enableDecoderTcsIc1(gpioIF);
-        break;
-      }
-      case (gpioIds::RTD_IC_10): {
         selectY0(gpioIF);
         enableDecoderTcsIc1(gpioIF);
         break;
       }
-      case (gpioIds::RTD_IC_11): {
+      case (gpioIds::RTD_IC_8): {
         selectY7(gpioIF);
         enableDecoderTcsIc2(gpioIF);
         break;
       }
-      case (gpioIds::RTD_IC_12): {
+      case (gpioIds::RTD_IC_9): {
         selectY6(gpioIF);
         enableDecoderTcsIc2(gpioIF);
         break;
       }
-      case (gpioIds::RTD_IC_13): {
+      case (gpioIds::RTD_IC_10): {
         selectY5(gpioIF);
         enableDecoderTcsIc2(gpioIF);
         break;
       }
-      case (gpioIds::RTD_IC_14): {
+      case (gpioIds::RTD_IC_11): {
         selectY4(gpioIF);
         enableDecoderTcsIc2(gpioIF);
         break;
       }
-      case (gpioIds::RTD_IC_15): {
+      case (gpioIds::RTD_IC_12): {
         selectY3(gpioIF);
         enableDecoderTcsIc2(gpioIF);
         break;
       }
-      case (gpioIds::RTD_IC_16): {
+      case (gpioIds::RTD_IC_13): {
         selectY2(gpioIF);
         enableDecoderTcsIc2(gpioIF);
         break;
       }
-      case (gpioIds::RTD_IC_17): {
+      case (gpioIds::RTD_IC_14): {
         selectY1(gpioIF);
         enableDecoderTcsIc2(gpioIF);
         break;
       }
-      case (gpioIds::RTD_IC_18): {
+      case (gpioIds::RTD_IC_15): {
         selectY0(gpioIF);
         enableDecoderTcsIc2(gpioIF);
         break;

linux/fsfwconfig/events/translateEvents.cpp

@@ -1,7 +1,7 @@
 /**
- * @brief    Auto-generated event translation file. Contains 296 translations.
+ * @brief    Auto-generated event translation file. Contains 324 translations.
  * @details
- * Generated on: 2023-06-21 19:01:02
+ * Generated on: 2024-04-10 11:49:35
  */
 #include "translateEvents.h"
 
@@ -82,8 +82,11 @@ const char *BIT_LOCK_STRING = "BIT_LOCK";
 const char *BIT_LOCK_LOST_STRING = "BIT_LOCK_LOST";
 const char *FRAME_PROCESSING_FAILED_STRING = "FRAME_PROCESSING_FAILED";
 const char *CLOCK_SET_STRING = "CLOCK_SET";
-const char *CLOCK_DUMP_STRING = "CLOCK_DUMP";
+const char *CLOCK_DUMP_LEGACY_STRING = "CLOCK_DUMP_LEGACY";
 const char *CLOCK_SET_FAILURE_STRING = "CLOCK_SET_FAILURE";
+const char *CLOCK_DUMP_STRING = "CLOCK_DUMP";
+const char *CLOCK_DUMP_BEFORE_SETTING_TIME_STRING = "CLOCK_DUMP_BEFORE_SETTING_TIME";
+const char *CLOCK_DUMP_AFTER_SETTING_TIME_STRING = "CLOCK_DUMP_AFTER_SETTING_TIME";
 const char *TC_DELETION_FAILED_STRING = "TC_DELETION_FAILED";
 const char *TEST_STRING = "TEST";
 const char *CHANGE_OF_SETUP_PARAMETER_STRING = "CHANGE_OF_SETUP_PARAMETER";
@@ -92,18 +95,28 @@ const char *MSG_QUEUE_ERROR_STRING = "MSG_QUEUE_ERROR";
 const char *SERIALIZATION_ERROR_STRING = "SERIALIZATION_ERROR";
 const char *FILESTORE_ERROR_STRING = "FILESTORE_ERROR";
 const char *FILENAME_TOO_LARGE_ERROR_STRING = "FILENAME_TOO_LARGE_ERROR";
+const char *HANDLING_CFDP_REQUEST_FAILED_STRING = "HANDLING_CFDP_REQUEST_FAILED";
 const char *SAFE_RATE_VIOLATION_STRING = "SAFE_RATE_VIOLATION";
-const char *SAFE_RATE_RECOVERY_STRING = "SAFE_RATE_RECOVERY";
+const char *RATE_RECOVERY_STRING = "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 *PTG_CTRL_NO_ATTITUDE_INFORMATION_STRING = "PTG_CTRL_NO_ATTITUDE_INFORMATION";
 const char *SAFE_MODE_CONTROLLER_FAILURE_STRING = "SAFE_MODE_CONTROLLER_FAILURE";
+const char *TLE_TOO_OLD_STRING = "TLE_TOO_OLD";
+const char *TLE_FILE_READ_FAILED_STRING = "TLE_FILE_READ_FAILED";
+const char *PTG_RATE_VIOLATION_STRING = "PTG_RATE_VIOLATION";
+const char *DETUMBLE_TRANSITION_FAILED_STRING = "DETUMBLE_TRANSITION_FAILED";
 const char *SWITCH_CMD_SENT_STRING = "SWITCH_CMD_SENT";
 const char *SWITCH_HAS_CHANGED_STRING = "SWITCH_HAS_CHANGED";
 const char *SWITCHING_Q7S_DENIED_STRING = "SWITCHING_Q7S_DENIED";
 const char *FDIR_REACTION_IGNORED_STRING = "FDIR_REACTION_IGNORED";
+const char *DATASET_READ_FAILED_STRING = "DATASET_READ_FAILED";
+const char *VOLTAGE_OUT_OF_BOUNDS_STRING = "VOLTAGE_OUT_OF_BOUNDS";
+const char *TIMEDELTA_OUT_OF_BOUNDS_STRING = "TIMEDELTA_OUT_OF_BOUNDS";
+const char *POWER_LEVEL_LOW_STRING = "POWER_LEVEL_LOW";
+const char *POWER_LEVEL_CRITICAL_STRING = "POWER_LEVEL_CRITICAL";
 const char *GPIO_PULL_HIGH_FAILED_STRING = "GPIO_PULL_HIGH_FAILED";
 const char *GPIO_PULL_LOW_FAILED_STRING = "GPIO_PULL_LOW_FAILED";
 const char *HEATER_WENT_ON_STRING = "HEATER_WENT_ON";
@@ -127,6 +140,8 @@ const char *EXE_FAILURE_STRING = "EXE_FAILURE";
 const char *MPSOC_HANDLER_CRC_FAILURE_STRING = "MPSOC_HANDLER_CRC_FAILURE";
 const char *MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH_STRING = "MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH";
 const char *MPSOC_SHUTDOWN_FAILED_STRING = "MPSOC_SHUTDOWN_FAILED";
+const char *SUPV_NOT_ON_STRING = "SUPV_NOT_ON";
+const char *SUPV_REPLY_TIMEOUT_STRING = "SUPV_REPLY_TIMEOUT";
 const char *SELF_TEST_I2C_FAILURE_STRING = "SELF_TEST_I2C_FAILURE";
 const char *SELF_TEST_SPI_FAILURE_STRING = "SELF_TEST_SPI_FAILURE";
 const char *SELF_TEST_ADC_FAILURE_STRING = "SELF_TEST_ADC_FAILURE";
@@ -139,6 +154,7 @@ const char *ERROR_STATE_STRING = "ERROR_STATE";
 const char *RESET_OCCURED_STRING = "RESET_OCCURED";
 const char *BOOTING_FIRMWARE_FAILED_EVENT_STRING = "BOOTING_FIRMWARE_FAILED_EVENT";
 const char *BOOTING_BOOTLOADER_FAILED_EVENT_STRING = "BOOTING_BOOTLOADER_FAILED_EVENT";
+const char *COM_ERROR_REPLY_RECEIVED_STRING = "COM_ERROR_REPLY_RECEIVED";
 const char *SUPV_MEMORY_READ_RPT_CRC_FAILURE_STRING = "SUPV_MEMORY_READ_RPT_CRC_FAILURE";
 const char *SUPV_UNKNOWN_TM_STRING = "SUPV_UNKNOWN_TM";
 const char *SUPV_UNINIMPLEMENTED_TM_STRING = "SUPV_UNINIMPLEMENTED_TM";
@@ -147,6 +163,8 @@ const char *SUPV_EXE_FAILURE_STRING = "SUPV_EXE_FAILURE";
 const char *SUPV_CRC_FAILURE_EVENT_STRING = "SUPV_CRC_FAILURE_EVENT";
 const char *SUPV_HELPER_EXECUTING_STRING = "SUPV_HELPER_EXECUTING";
 const char *SUPV_MPSOC_SHUTDOWN_BUILD_FAILED_STRING = "SUPV_MPSOC_SHUTDOWN_BUILD_FAILED";
+const char *SUPV_ACK_UNKNOWN_COMMAND_STRING = "SUPV_ACK_UNKNOWN_COMMAND";
+const char *SUPV_EXE_ACK_UNKNOWN_COMMAND_STRING = "SUPV_EXE_ACK_UNKNOWN_COMMAND";
 const char *SANITIZATION_FAILED_STRING = "SANITIZATION_FAILED";
 const char *MOUNTED_SD_CARD_STRING = "MOUNTED_SD_CARD";
 const char *SEND_MRAM_DUMP_FAILED_STRING = "SEND_MRAM_DUMP_FAILED";
@@ -166,6 +184,7 @@ const char *PDEC_TRYING_RESET_NO_INIT_STRING = "PDEC_TRYING_RESET_NO_INIT";
 const char *PDEC_RESET_FAILED_STRING = "PDEC_RESET_FAILED";
 const char *OPEN_IRQ_FILE_FAILED_STRING = "OPEN_IRQ_FILE_FAILED";
 const char *PDEC_INIT_FAILED_STRING = "PDEC_INIT_FAILED";
+const char *PDEC_CONFIG_CORRUPTED_STRING = "PDEC_CONFIG_CORRUPTED";
 const char *IMAGE_UPLOAD_FAILED_STRING = "IMAGE_UPLOAD_FAILED";
 const char *IMAGE_DOWNLOAD_FAILED_STRING = "IMAGE_DOWNLOAD_FAILED";
 const char *IMAGE_UPLOAD_SUCCESSFUL_STRING = "IMAGE_UPLOAD_SUCCESSFUL";
@@ -225,6 +244,7 @@ const char *SIDE_SWITCH_TRANSITION_NOT_ALLOWED_12903_STRING = "SIDE_SWITCH_TRANS
 const char *CHILDREN_LOST_MODE_STRING = "CHILDREN_LOST_MODE";
 const char *GPS_FIX_CHANGE_STRING = "GPS_FIX_CHANGE";
 const char *CANT_GET_FIX_STRING = "CANT_GET_FIX";
+const char *RESET_FAIL_STRING = "RESET_FAIL";
 const char *P60_BOOT_COUNT_STRING = "P60_BOOT_COUNT";
 const char *BATT_MODE_STRING = "BATT_MODE";
 const char *BATT_MODE_CHANGED_STRING = "BATT_MODE_CHANGED";
@@ -260,6 +280,7 @@ const char *TX_OFF_STRING = "TX_OFF";
 const char *MISSING_PACKET_STRING = "MISSING_PACKET";
 const char *EXPERIMENT_TIMEDOUT_STRING = "EXPERIMENT_TIMEDOUT";
 const char *MULTI_PACKET_COMMAND_DONE_STRING = "MULTI_PACKET_COMMAND_DONE";
+const char *FS_UNUSABLE_STRING = "FS_UNUSABLE";
 const char *SET_CONFIGFILEVALUE_FAILED_STRING = "SET_CONFIGFILEVALUE_FAILED";
 const char *GET_CONFIGFILEVALUE_FAILED_STRING = "GET_CONFIGFILEVALUE_FAILED";
 const char *INSERT_CONFIGFILEVALUE_FAILED_STRING = "INSERT_CONFIGFILEVALUE_FAILED";
@@ -278,6 +299,7 @@ const char *TRYING_I2C_RECOVERY_STRING = "TRYING_I2C_RECOVERY";
 const char *I2C_REBOOT_STRING = "I2C_REBOOT";
 const char *PDEC_REBOOT_STRING = "PDEC_REBOOT";
 const char *FIRMWARE_INFO_STRING = "FIRMWARE_INFO";
+const char *ACTIVE_SD_INFO_STRING = "ACTIVE_SD_INFO";
 const char *NO_VALID_SENSOR_TEMPERATURE_STRING = "NO_VALID_SENSOR_TEMPERATURE";
 const char *NO_HEALTHY_HEATER_AVAILABLE_STRING = "NO_HEALTHY_HEATER_AVAILABLE";
 const char *SYRLINKS_OVERHEATING_STRING = "SYRLINKS_OVERHEATING";
@@ -286,6 +308,9 @@ const char *CAMERA_OVERHEATING_STRING = "CAMERA_OVERHEATING";
 const char *PCDU_SYSTEM_OVERHEATING_STRING = "PCDU_SYSTEM_OVERHEATING";
 const char *HEATER_NOT_OFF_FOR_OFF_MODE_STRING = "HEATER_NOT_OFF_FOR_OFF_MODE";
 const char *MGT_OVERHEATING_STRING = "MGT_OVERHEATING";
+const char *TCS_SWITCHING_HEATER_ON_STRING = "TCS_SWITCHING_HEATER_ON";
+const char *TCS_SWITCHING_HEATER_OFF_STRING = "TCS_SWITCHING_HEATER_OFF";
+const char *TCS_HEATER_MAX_BURN_TIME_REACHED_STRING = "TCS_HEATER_MAX_BURN_TIME_REACHED";
 const char *TX_TIMER_EXPIRED_STRING = "TX_TIMER_EXPIRED";
 const char *BIT_LOCK_TX_ON_STRING = "BIT_LOCK_TX_ON";
 const char *POSSIBLE_FILE_CORRUPTION_STRING = "POSSIBLE_FILE_CORRUPTION";
@@ -301,6 +326,9 @@ const char *DUMP_NOK_CANCELLED_STRING = "DUMP_NOK_CANCELLED";
 const char *DUMP_MISC_CANCELLED_STRING = "DUMP_MISC_CANCELLED";
 const char *DUMP_HK_CANCELLED_STRING = "DUMP_HK_CANCELLED";
 const char *DUMP_CFDP_CANCELLED_STRING = "DUMP_CFDP_CANCELLED";
+const char *TEMPERATURE_ALL_ONES_START_STRING = "TEMPERATURE_ALL_ONES_START";
+const char *TEMPERATURE_ALL_ONES_RECOVERY_STRING = "TEMPERATURE_ALL_ONES_RECOVERY";
+const char *FAULT_HANDLER_TRIGGERED_STRING = "FAULT_HANDLER_TRIGGERED";
 
 const char *translateEvents(Event event) {
   switch ((event & 0xFFFF)) {
@@ -459,9 +487,15 @@ const char *translateEvents(Event event) {
     case (8900):
       return CLOCK_SET_STRING;
     case (8901):
-      return CLOCK_DUMP_STRING;
+      return CLOCK_DUMP_LEGACY_STRING;
     case (8902):
       return CLOCK_SET_FAILURE_STRING;
+    case (8903):
+      return CLOCK_DUMP_STRING;
+    case (8904):
+      return CLOCK_DUMP_BEFORE_SETTING_TIME_STRING;
+    case (8905):
+      return CLOCK_DUMP_AFTER_SETTING_TIME_STRING;
     case (9100):
       return TC_DELETION_FAILED_STRING;
     case (9700):
@@ -478,10 +512,12 @@ const char *translateEvents(Event event) {
       return FILESTORE_ERROR_STRING;
     case (10804):
       return FILENAME_TOO_LARGE_ERROR_STRING;
+    case (10805):
+      return HANDLING_CFDP_REQUEST_FAILED_STRING;
     case (11200):
       return SAFE_RATE_VIOLATION_STRING;
     case (11201):
-      return SAFE_RATE_RECOVERY_STRING;
+      return RATE_RECOVERY_STRING;
     case (11202):
       return MULTIPLE_RW_INVALID_STRING;
     case (11203):
@@ -491,9 +527,17 @@ const char *translateEvents(Event event) {
     case (11205):
       return MEKF_AUTOMATIC_RESET_STRING;
     case (11206):
-      return MEKF_INVALID_MODE_VIOLATION_STRING;
+      return PTG_CTRL_NO_ATTITUDE_INFORMATION_STRING;
     case (11207):
       return SAFE_MODE_CONTROLLER_FAILURE_STRING;
+    case (11208):
+      return TLE_TOO_OLD_STRING;
+    case (11209):
+      return TLE_FILE_READ_FAILED_STRING;
+    case (11210):
+      return PTG_RATE_VIOLATION_STRING;
+    case (11211):
+      return DETUMBLE_TRANSITION_FAILED_STRING;
     case (11300):
       return SWITCH_CMD_SENT_STRING;
     case (11301):
@@ -502,6 +546,16 @@ const char *translateEvents(Event event) {
       return SWITCHING_Q7S_DENIED_STRING;
     case (11303):
       return FDIR_REACTION_IGNORED_STRING;
+    case (11304):
+      return DATASET_READ_FAILED_STRING;
+    case (11305):
+      return VOLTAGE_OUT_OF_BOUNDS_STRING;
+    case (11306):
+      return TIMEDELTA_OUT_OF_BOUNDS_STRING;
+    case (11307):
+      return POWER_LEVEL_LOW_STRING;
+    case (11308):
+      return POWER_LEVEL_CRITICAL_STRING;
     case (11400):
       return GPIO_PULL_HIGH_FAILED_STRING;
     case (11401):
@@ -548,6 +602,10 @@ const char *translateEvents(Event event) {
       return MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH_STRING;
     case (11606):
       return MPSOC_SHUTDOWN_FAILED_STRING;
+    case (11607):
+      return SUPV_NOT_ON_STRING;
+    case (11608):
+      return SUPV_REPLY_TIMEOUT_STRING;
     case (11701):
       return SELF_TEST_I2C_FAILURE_STRING;
     case (11702):
@@ -572,6 +630,8 @@ const char *translateEvents(Event event) {
       return BOOTING_FIRMWARE_FAILED_EVENT_STRING;
     case (11902):
       return BOOTING_BOOTLOADER_FAILED_EVENT_STRING;
+    case (11903):
+      return COM_ERROR_REPLY_RECEIVED_STRING;
     case (12001):
       return SUPV_MEMORY_READ_RPT_CRC_FAILURE_STRING;
     case (12002):
@@ -588,6 +648,10 @@ const char *translateEvents(Event event) {
       return SUPV_HELPER_EXECUTING_STRING;
     case (12008):
       return SUPV_MPSOC_SHUTDOWN_BUILD_FAILED_STRING;
+    case (12009):
+      return SUPV_ACK_UNKNOWN_COMMAND_STRING;
+    case (12010):
+      return SUPV_EXE_ACK_UNKNOWN_COMMAND_STRING;
     case (12100):
       return SANITIZATION_FAILED_STRING;
     case (12101):
@@ -626,6 +690,8 @@ const char *translateEvents(Event event) {
       return OPEN_IRQ_FILE_FAILED_STRING;
     case (12414):
       return PDEC_INIT_FAILED_STRING;
+    case (12415):
+      return PDEC_CONFIG_CORRUPTED_STRING;
     case (12500):
       return IMAGE_UPLOAD_FAILED_STRING;
     case (12501):
@@ -744,6 +810,8 @@ const char *translateEvents(Event event) {
       return GPS_FIX_CHANGE_STRING;
     case (13101):
       return CANT_GET_FIX_STRING;
+    case (13102):
+      return RESET_FAIL_STRING;
     case (13200):
       return P60_BOOT_COUNT_STRING;
     case (13201):
@@ -814,6 +882,8 @@ const char *translateEvents(Event event) {
       return EXPERIMENT_TIMEDOUT_STRING;
     case (13802):
       return MULTI_PACKET_COMMAND_DONE_STRING;
+    case (13803):
+      return FS_UNUSABLE_STRING;
     case (13901):
       return SET_CONFIGFILEVALUE_FAILED_STRING;
     case (13902):
@@ -850,6 +920,8 @@ const char *translateEvents(Event event) {
       return PDEC_REBOOT_STRING;
     case (14013):
       return FIRMWARE_INFO_STRING;
+    case (14014):
+      return ACTIVE_SD_INFO_STRING;
     case (14100):
       return NO_VALID_SENSOR_TEMPERATURE_STRING;
     case (14101):
@@ -866,6 +938,12 @@ const char *translateEvents(Event event) {
       return HEATER_NOT_OFF_FOR_OFF_MODE_STRING;
     case (14108):
       return MGT_OVERHEATING_STRING;
+    case (14109):
+      return TCS_SWITCHING_HEATER_ON_STRING;
+    case (14110):
+      return TCS_SWITCHING_HEATER_OFF_STRING;
+    case (14111):
+      return TCS_HEATER_MAX_BURN_TIME_REACHED_STRING;
     case (14201):
       return TX_TIMER_EXPIRED_STRING;
     case (14202):
@@ -896,6 +974,12 @@ const char *translateEvents(Event event) {
       return DUMP_HK_CANCELLED_STRING;
     case (14314):
       return DUMP_CFDP_CANCELLED_STRING;
+    case (14500):
+      return TEMPERATURE_ALL_ONES_START_STRING;
+    case (14501):
+      return TEMPERATURE_ALL_ONES_RECOVERY_STRING;
+    case (14600):
+      return FAULT_HANDLER_TRIGGERED_STRING;
     default:
       return "UNKNOWN_EVENT";
   }

linux/fsfwconfig/objects/translateObjects.cpp

@@ -1,15 +1,17 @@
 /**
  * @brief  Auto-generated object translation file.
  * @details
- * Contains 175 translations.
- * Generated on: 2023-06-21 19:01:02
+ * Contains 179 translations.
+ * Generated on: 2024-04-10 11:49:35
  */
 #include "translateObjects.h"
 
 const char *P60DOCK_TEST_TASK_STRING = "P60DOCK_TEST_TASK";
 const char *ACS_CONTROLLER_STRING = "ACS_CONTROLLER";
 const char *CORE_CONTROLLER_STRING = "CORE_CONTROLLER";
+const char *POWER_CONTROLLER_STRING = "POWER_CONTROLLER";
 const char *GLOBAL_JSON_CFG_STRING = "GLOBAL_JSON_CFG";
+const char *XIPHOS_WDT_STRING = "XIPHOS_WDT";
 const char *THERMAL_CONTROLLER_STRING = "THERMAL_CONTROLLER";
 const char *MGM_0_LIS3_HANDLER_STRING = "MGM_0_LIS3_HANDLER";
 const char *GYRO_0_ADIS_HANDLER_STRING = "GYRO_0_ADIS_HANDLER";
@@ -164,11 +166,13 @@ const char *PUS_TM_FUNNEL_STRING = "PUS_TM_FUNNEL";
 const char *CFDP_TM_FUNNEL_STRING = "CFDP_TM_FUNNEL";
 const char *CFDP_HANDLER_STRING = "CFDP_HANDLER";
 const char *CFDP_DISTRIBUTOR_STRING = "CFDP_DISTRIBUTOR";
+const char *CFDP_FAULT_HANDLER_STRING = "CFDP_FAULT_HANDLER";
 const char *EIVE_SYSTEM_STRING = "EIVE_SYSTEM";
 const char *ACS_SUBSYSTEM_STRING = "ACS_SUBSYSTEM";
 const char *PL_SUBSYSTEM_STRING = "PL_SUBSYSTEM";
 const char *TCS_SUBSYSTEM_STRING = "TCS_SUBSYSTEM";
 const char *COM_SUBSYSTEM_STRING = "COM_SUBSYSTEM";
+const char *EPS_SUBSYSTEM_STRING = "EPS_SUBSYSTEM";
 const char *MISC_TM_STORE_STRING = "MISC_TM_STORE";
 const char *OK_TM_STORE_STRING = "OK_TM_STORE";
 const char *NOT_OK_TM_STORE_STRING = "NOT_OK_TM_STORE";
@@ -190,8 +194,12 @@ const char *translateObject(object_id_t object) {
       return ACS_CONTROLLER_STRING;
     case 0x43000003:
       return CORE_CONTROLLER_STRING;
+    case 0x43000004:
+      return POWER_CONTROLLER_STRING;
     case 0x43000006:
       return GLOBAL_JSON_CFG_STRING;
+    case 0x43000007:
+      return XIPHOS_WDT_STRING;
     case 0x43400001:
       return THERMAL_CONTROLLER_STRING;
     case 0x44120006:
@@ -500,6 +508,8 @@ const char *translateObject(object_id_t object) {
       return CFDP_HANDLER_STRING;
     case 0x73000206:
       return CFDP_DISTRIBUTOR_STRING;
+    case 0x73000207:
+      return CFDP_FAULT_HANDLER_STRING;
     case 0x73010000:
       return EIVE_SYSTEM_STRING;
     case 0x73010001:
@@ -510,6 +520,8 @@ const char *translateObject(object_id_t object) {
       return TCS_SUBSYSTEM_STRING;
     case 0x73010004:
       return COM_SUBSYSTEM_STRING;
+    case 0x73010005:
+      return EPS_SUBSYSTEM_STRING;
     case 0x73020001:
       return MISC_TM_STORE_STRING;
     case 0x73020002:

linux/ipcore/AxiPtmeConfig.cpp

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

linux/ipcore/AxiPtmeConfig.h

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

linux/ipcore/PapbVcInterface.cpp

@@ -7,11 +7,11 @@
 
 #include "fsfw/serviceinterface/ServiceInterface.h"
 
-PapbVcInterface::PapbVcInterface(LinuxLibgpioIF* gpioComIF, gpioId_t papbBusyId,
-                                 gpioId_t papbEmptyId, std::string uioFile, int mapNum)
+PapbVcInterface::PapbVcInterface(LinuxLibgpioIF* gpioComIF, gpioId_t papbEmptyId,
+                                 std::string uioFile, int mapNum, size_t maxPacketSize)
     : gpioComIF(gpioComIF),
-      papbBusyId(papbBusyId),
       papbEmptyId(papbEmptyId),
+      packetBuf(maxPacketSize),
       uioFile(std::move(uioFile)),
       mapNum(mapNum) {}
 
@@ -20,156 +20,128 @@ PapbVcInterface::~PapbVcInterface() {}
 ReturnValue_t PapbVcInterface::initialize() {
   UioMapper uioMapper(uioFile, mapNum);
   ReturnValue_t result = uioMapper.getMappedAdress(const_cast<uint32_t**>(&vcBaseReg),
-                                                   UioMapper::Permissions::WRITE_ONLY);
+                                                   UioMapper::Permissions::READ_WRITE);
   if (result != returnvalue::OK) {
     return result;
   }
   return returnvalue::OK;
 }
 
-ReturnValue_t PapbVcInterface::write(const uint8_t* data, size_t size) {
+ReturnValue_t PapbVcInterface::write(const uint8_t* data, size_t size, size_t& writtenSize) {
   // There are no packets smaller than 4, this is considered a configuration error.
   if (size < 4) {
+    sif::warning << "PapbVcInterface::write: Passed packet smaller than 4 bytes" << std::endl;
     return returnvalue::FAILED;
   }
-  if (pollInterfaceReadiness(0, true) == returnvalue::OK) {
+  // The user must call advance until completion before starting a new packet transfer.
+  if (writeActiveStatus) {
+    return IS_BUSY;
+  }
+  if (size > packetBuf.capacity()) {
+    sif::error << "PapbVcInterface: Packet with size " << size << " larger than maximum configured"
+               << " byte size " << packetBuf.capacity() << std::endl;
+    return returnvalue::FAILED;
+  }
+  std::memcpy(packetBuf.data(), data, size);
+  currentPacketSize = size;
+  currentPacketIndex = 0;
+  if (pollReadyForPacket()) {
     startPacketTransfer(ByteWidthCfg::ONE);
   } else {
     return DirectTmSinkIF::IS_BUSY;
   }
-  // TODO: This should work but does not.. :(
-  //  size_t idx = 0;
-  //  while (idx < size) {
-  //
-  //    nanosleep(&BETWEEN_POLL_DELAY, &remDelay);
-  //    if ((size - idx) < 4) {
-  //      *vcBaseReg = CONFIG_DATA_INPUT | (size - idx - 1);
-  //      usleep(1);
-  //    }
-  //    if (pollPapbBusySignal(2) == returnvalue::OK) {
-  //      //      vcBaseReg + DATA_REG_OFFSET + 3 = static_cast<uint8_t>(data + idx);
-  //      //      vcBaseReg + DATA_REG_OFFSET + 2 = static_cast<uint8_t>(data + idx + 1);
-  //      //      vcBaseReg + DATA_REG_OFFSET + 1 = static_cast<uint8_t>(data + idx + 2);
-  //      //      vcBaseReg + DATA_REG_OFFSET = static_cast<uint8_t>(data + idx + 3);
-  //
-  //      // std::memcpy((vcBaseReg + DATA_REG_OFFSET), data + idx , nextWriteSize);
-  //      *(vcBaseReg + DATA_REG_OFFSET) = *reinterpret_cast<const uint32_t*>(data + idx);
-  //      //uint8_t* byteReg = reinterpret_cast<uint8_t*>(vcBaseReg + DATA_REG_OFFSET);
-  //
-  //      //byteReg[0] = data[idx];
-  //      //byteReg[1] = data[idx];
-  //    } else {
-  //      abortPacketTransfer();
-  //      return returnvalue::FAILED;
-  //    }
-  //    // TODO: Change this after the bugfix. Right now, the PAPB ignores the content of the byte
-  //    // width configuration.5
-  //    // It's okay to increment by a larger amount for the last segment here, loop will be over
-  //    // in any case.
-  //    idx += 4;
-  //  }
-  for (size_t idx = 0; idx < size; idx++) {
-    // This delay is super-important, DO NOT REMOVE!
-    // Polling the GPIO or the config register too often messes up the scheduler.
-    // TODO: Maybe this should not be done like this. It would be better if there was a custom
-    // FPGA module which can accept packets and then takes care of dumping that packet into
-    // the PTME. DMA would be an ideal solution for this.
-    nanosleep(&BETWEEN_POLL_DELAY, &remDelay);
-    if (pollInterfaceReadiness(2, false) == returnvalue::OK) {
-      *(vcBaseReg + DATA_REG_OFFSET) = static_cast<uint32_t>(data[idx]);
-    } else {
-      abortPacketTransfer();
-      return returnvalue::FAILED;
-    }
-  }
-  nanosleep(&BETWEEN_POLL_DELAY, &remDelay);
-  if (pollInterfaceReadiness(2, false) == returnvalue::OK) {
-    completePacketTransfer();
-  } else {
-    abortPacketTransfer();
-    return returnvalue::FAILED;
-  }
-  return returnvalue::OK;
+  return advanceWrite(writtenSize);
 }
 
 void PapbVcInterface::startPacketTransfer(ByteWidthCfg initWidth) {
   *vcBaseReg = CONFIG_DATA_INPUT | initWidth;
+  writeActiveStatus = true;
 }
 
-void PapbVcInterface::completePacketTransfer() { *vcBaseReg = CONFIG_END; }
+bool PapbVcInterface::pollReadyForPacket() const {
+  //  Check if PAPB interface is ready to receive data. Use the configuration register for this.
+  //  Bit 5, see PTME ptme_001_01-0-7-r2 Table 31.
+  uint32_t reg = *vcBaseReg;
+  return (reg >> 6) & 0b1;
+}
 
-ReturnValue_t PapbVcInterface::pollInterfaceReadiness(uint32_t maxPollRetries,
-                                                      bool checkReadyState) const {
-  uint32_t busyIdx = 0;
-  nextDelay.tv_nsec = FIRST_DELAY_PAPB_POLLING_NS;
-
-  while (true) {
-    // Check if PAPB interface is ready to receive data. Use the configuration register for this.
-    // Bit 5, see PTME ptme_001_01-0-7-r2 Table 31.
-    uint32_t reg = *vcBaseReg;
-    bool busy = (reg >> 5) & 0b1;
-    bool ready = (reg >> 6) & 0b1;
-    if (not busy) {
-      return returnvalue::OK;
-    }
-    if (checkReadyState and not ready) {
-      return PAPB_BUSY;
-    }
-
-    busyIdx++;
-    if (busyIdx >= maxPollRetries) {
-      return PAPB_BUSY;
-    }
-
-    // Ignore signal handling here for now.
-    nanosleep(&nextDelay, &remDelay);
-    // Adaptive delay.
-    if (nextDelay.tv_nsec * 2 <= MAX_DELAY_PAPB_POLLING_NS) {
-      nextDelay.tv_nsec *= 2;
-    }
+ReturnValue_t PapbVcInterface::advanceWrite(size_t& writtenSize) {
+  if (!writeActiveStatus) {
+    return NO_WRITE_ACTIVE;
   }
+  if (not pollReadyForPacket()) {
+    return IS_BUSY;
+  }
+  while (currentPacketIndex < currentPacketSize) {
+    if (not pollReadyForOctet(MAX_BUSY_POLLS)) {
+      if (not pollReadyForPacket()) {
+        return PARTIALLY_WRITTEN;
+      }
+      abortPacketTransfer();
+      return returnvalue::FAILED;
+    }
+    *(vcBaseReg + DATA_REG_OFFSET) = static_cast<uint32_t>(packetBuf[currentPacketIndex++]);
+    writtenSize++;
+  }
+  if (not pollReadyForOctet(MAX_BUSY_POLLS)) {
+    if (not pollReadyForPacket()) {
+      return PARTIALLY_WRITTEN;
+    }
+    abortPacketTransfer();
+    return returnvalue::FAILED;
+  }
+  completePacketTransfer();
   return returnvalue::OK;
 }
 
-void PapbVcInterface::isVcInterfaceBufferEmpty() {
+bool PapbVcInterface::writeActive() const { return writeActiveStatus; }
+
+bool PapbVcInterface::isVcInterfaceBufferEmpty() {
   ReturnValue_t result = returnvalue::OK;
   gpio::Levels papbEmptyState = gpio::Levels::HIGH;
 
   result = gpioComIF->readGpio(papbEmptyId, papbEmptyState);
 
   if (result != returnvalue::OK) {
-    sif::warning << "PapbVcInterface::isVcInterfaceBufferEmpty: Failed to read papb empty signal"
-                 << std::endl;
-    return;
+    sif::error << "PapbVcInterface::isVcInterfaceBufferEmpty: Failed to read papb empty signal"
+               << std::endl;
+    return true;
   }
 
   if (papbEmptyState == gpio::Levels::HIGH) {
-    sif::debug << "PapbVcInterface::isVcInterfaceBufferEmpty: Buffer is empty" << std::endl;
-  } else {
-    sif::debug << "PapbVcInterface::isVcInterfaceBufferEmpty: Buffer is not empty" << std::endl;
+    return true;
   }
-  return;
+  return false;
 }
 
-bool PapbVcInterface::isBusy() const { return pollInterfaceReadiness(0, true) == PAPB_BUSY; }
+bool PapbVcInterface::isBusy() const { return not pollReadyForPacket(); }
 
 void PapbVcInterface::cancelTransfer() { abortPacketTransfer(); }
 
-ReturnValue_t PapbVcInterface::sendTestFrame() {
-  /** Size of one complete transfer frame data field amounts to 1105 bytes */
-  uint8_t testPacket[1105];
-
-  /** Fill one test packet */
-  for (int idx = 0; idx < 1105; idx++) {
-    testPacket[idx] = static_cast<uint8_t>(idx & 0xFF);
+inline bool PapbVcInterface::pollReadyForOctet(uint32_t maxCycles) const {
+  uint32_t reg;
+  uint32_t idx = 0;
+  while (idx < maxCycles) {
+    reg = *vcBaseReg;
+    // Busy bit.
+    if (not((reg >> 5) & 0b1)) {
+      return true;
+    }
+    idx++;
   }
-
-  ReturnValue_t result = write(testPacket, 1105);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-
-  return returnvalue::OK;
+  return false;
 }
 
-void PapbVcInterface::abortPacketTransfer() { *vcBaseReg = CONFIG_ABORT; }
+void PapbVcInterface::abortPacketTransfer() {
+  *vcBaseReg = CONFIG_ABORT;
+  writeActiveStatus = false;
+  currentPacketIndex = 0;
+  currentPacketSize = 0;
+}
+
+void PapbVcInterface::completePacketTransfer() {
+  *vcBaseReg = CONFIG_END;
+  writeActiveStatus = false;
+  currentPacketIndex = 0;
+  currentPacketSize = 0;
+}

linux/ipcore/PapbVcInterface.h

@@ -6,6 +6,7 @@
 #include <linux/ipcore/VirtualChannelIF.h>
 
 #include <atomic>
+#include <vector>
 
 #include "OBSWConfig.h"
 #include "fsfw/returnvalues/returnvalue.h"
@@ -30,21 +31,22 @@ class PapbVcInterface : public VirtualChannelIF {
    * @param uioFile       UIO file providing access to the PAPB bus
    * @param mapNum        Map number of UIO map associated with this virtual channel
    */
-  PapbVcInterface(LinuxLibgpioIF* gpioComIF, gpioId_t papbBusyId, gpioId_t papbEmptyId,
-                  std::string uioFile, int mapNum);
+  PapbVcInterface(LinuxLibgpioIF* gpioComIF, gpioId_t papbEmptyId, std::string uioFile, int mapNum,
+                  size_t maxPacketSize);
   virtual ~PapbVcInterface();
 
+  // See interface function documentation for docs on these functions.
+
   bool isBusy() const override;
-  /**
-   *
-   * @param data
-   * @param size
-   * @return returnvalue::OK on successfull write, PAPB_BUSY if PAPB is busy.
-   */
-  ReturnValue_t write(const uint8_t* data, size_t size) override;
+
+  ReturnValue_t write(const uint8_t* data, size_t size, size_t& writtenSize) override;
+
+  ReturnValue_t advanceWrite(size_t& remainingSize) override;
 
   void cancelTransfer() override;
 
+  bool writeActive() const override;
+
   ReturnValue_t initialize() override;
 
  private:
@@ -81,19 +83,20 @@ class PapbVcInterface : public VirtualChannelIF {
 
   static constexpr long int FIRST_DELAY_PAPB_POLLING_NS = 10;
   static constexpr long int MAX_DELAY_PAPB_POLLING_NS = 40;
+  static constexpr uint32_t MAX_BUSY_POLLS = 1000;
 
   LinuxLibgpioIF* gpioComIF = nullptr;
-
-  /** Pulled to low when virtual channel not ready to receive data */
-  gpioId_t papbBusyId = gpio::NO_GPIO;
   /** High when external buffer memory of virtual channel is empty */
   gpioId_t papbEmptyId = gpio::NO_GPIO;
 
+  std::vector<uint8_t> packetBuf;
   std::string uioFile;
   int mapNum = 0;
+  bool writeActiveStatus = false;
+  size_t currentPacketIndex = 0;
+  size_t currentPacketSize = 0;
   mutable struct timespec nextDelay = {.tv_sec = 0, .tv_nsec = 0};
   const struct timespec BETWEEN_POLL_DELAY = {.tv_sec = 0, .tv_nsec = 10};
-  mutable struct timespec remDelay;
 
   volatile uint32_t* vcBaseReg = nullptr;
 
@@ -120,19 +123,15 @@ class PapbVcInterface : public VirtualChannelIF {
    *
    * @return  returnvalue::OK when ready to receive data else PAPB_BUSY.
    */
-  inline ReturnValue_t pollInterfaceReadiness(uint32_t maxPollRetries, bool checkReadyState) const;
+  inline bool pollReadyForPacket() const;
+
+  inline bool pollReadyForOctet(uint32_t maxCycles) const;
 
   /**
    * @brief   This function can be used for debugging to check whether there are packets in
    *          the packet buffer of the virtual channel or not.
    */
-  void isVcInterfaceBufferEmpty();
-
-  /**
-   * @brief   This function sends a complete telemetry transfer frame data field (1105 bytes)
-   *          to the papb interface of the PTME IP Core. Can be used to test the implementation.
-   */
-  ReturnValue_t sendTestFrame();
+  bool isVcInterfaceBufferEmpty();
 };
 
 #endif /* LINUX_OBC_PAPBVCINTERFACE_H_ */

linux/ipcore/PdecConfig.cpp

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

linux/ipcore/PdecConfig.h

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

linux/ipcore/PdecHandler.cpp

@@ -24,12 +24,15 @@ using namespace pdec;
 uint32_t PdecHandler::CURRENT_FAR = 0;
 
 PdecHandler::PdecHandler(object_id_t objectId, object_id_t tcDestinationId,
-                         LinuxLibgpioIF* gpioComIF, gpioId_t pdecReset, UioNames names)
+                         LinuxLibgpioIF* gpioComIF, gpioId_t pdecReset, UioNames names,
+                         uint32_t cfgMemPhyAddr, uint32_t pdecRamPhyAddr)
     : SystemObject(objectId),
       tcDestinationId(tcDestinationId),
       gpioComIF(gpioComIF),
       pdecReset(pdecReset),
       actionHelper(this, nullptr),
+      cfgMemBaseAddr(cfgMemPhyAddr),
+      pdecRamBaseAddr(pdecRamPhyAddr),
       uioNames(names),
       paramHelper(this) {
   auto mqArgs = MqArgs(objectId, static_cast<void*>(this));
@@ -53,23 +56,30 @@ ReturnValue_t PdecHandler::initialize() {
     return ObjectManagerIF::CHILD_INIT_FAILED;
   }
 
-  ReturnValue_t result = returnvalue::OK;
-
   UioMapper regMapper(uioNames.registers);
-  result = regMapper.getMappedAdress(&registerBaseAddress, UioMapper::Permissions::READ_WRITE);
+  ReturnValue_t result =
+      regMapper.getMappedAdress(&registerBaseAddress, UioMapper::Permissions::READ_WRITE);
   if (result != returnvalue::OK) {
     return ObjectManagerIF::CHILD_INIT_FAILED;
   }
-  UioMapper configMemMapper(uioNames.configMemory);
-  result = configMemMapper.getMappedAdress(&memoryBaseAddress, UioMapper::Permissions::READ_WRITE);
-  if (result != returnvalue::OK) {
+
+  int fd = 0;
+  if ((fd = open("/dev/mem", O_RDWR | O_SYNC)) == -1) {
+    sif::error << "PdecHandler::initialize: Opening /dev/mem failed" << std::endl;
+    return ObjectManagerIF::CHILD_INIT_FAILED;
+  };
+  memoryBaseAddress = static_cast<uint32_t*>(
+      mmap(0, PDEC_CFG_MEM_SIZE, static_cast<int>(UioMapper::Permissions::READ_WRITE), MAP_SHARED,
+           fd, cfgMemBaseAddr));
+  if (memoryBaseAddress == nullptr) {
     return ObjectManagerIF::CHILD_INIT_FAILED;
-  } else {
-    pdecConfig.setMemoryBaseAddress(memoryBaseAddress);
   }
-  UioMapper ramMapper(uioNames.ramMemory);
-  result = ramMapper.getMappedAdress(&ramBaseAddress, UioMapper::Permissions::READ_WRITE);
-  if (result != returnvalue::OK) {
+  pdecConfig.setMemoryBaseAddress(memoryBaseAddress);
+
+  ramBaseAddress = static_cast<uint32_t*>(mmap(0, PDEC_RAM_SIZE,
+                                               static_cast<int>(UioMapper::Permissions::READ_WRITE),
+                                               MAP_SHARED, fd, pdecRamBaseAddr));
+  if (ramBaseAddress == nullptr) {
     return ObjectManagerIF::CHILD_INIT_FAILED;
   }
 
@@ -458,14 +468,7 @@ bool PdecHandler::newTcReceived() {
   return true;
 }
 
-void PdecHandler::doPeriodicWork() {
-  // scuffed test code
-  //  if(testCntr < 30) {
-  //    triggerEvent(pdec::INVALID_TC_FRAME, FRAME_DIRTY_RETVAL);
-  //    testCntr++;
-  //  }
-  checkLocks();
-}
+void PdecHandler::doPeriodicWork() { checkLocks(); }
 
 bool PdecHandler::checkFrameAna(uint32_t pdecFar) {
   bool frameValid = false;
@@ -478,6 +481,7 @@ bool PdecHandler::checkFrameAna(uint32_t pdecFar) {
     }
     case (FrameAna_t::FRAME_DIRTY): {
       triggerEvent(INVALID_TC_FRAME, FRAME_DIRTY_RETVAL);
+      checkConfig();
       sif::warning << "PdecHandler::checkFrameAna: Frame dirty" << std::endl;
       break;
     }
@@ -577,6 +581,30 @@ void PdecHandler::handleIReason(uint32_t pdecFar, ReturnValue_t parameter1) {
   }
 }
 
+void PdecHandler::checkConfig() {
+  uint32_t firstWord = 0;
+  ReturnValue_t result = pdecConfig.createFirstWord(&firstWord);
+  if (result != returnvalue::OK) {
+    // This should normally never happen during runtime. So here is just
+    // output a warning
+    sif::warning << "PdecHandler::checkConfig: Failed to create first word" << std::endl;
+    return;
+  }
+  uint32_t secondWord = 0;
+  result = pdecConfig.createSecondWord(&secondWord);
+  if (result != returnvalue::OK) {
+    // This should normally never happen during runtime. So here is just
+    // output a warning
+    sif::warning << "PdecHandler::checkConfig: Failed to create second word" << std::endl;
+    return;
+  }
+  uint32_t readbackFirstWord = pdecConfig.readbackFirstWord();
+  uint32_t readbackSecondWord = pdecConfig.readbackSecondWord();
+  if (firstWord != readbackFirstWord or secondWord != readbackSecondWord) {
+    triggerEvent(PDEC_CONFIG_CORRUPTED, readbackFirstWord, readbackSecondWord);
+  }
+}
+
 void PdecHandler::handleNewTc() {
   ReturnValue_t result = returnvalue::OK;
 
@@ -613,7 +641,7 @@ void PdecHandler::handleNewTc() {
 }
 
 ReturnValue_t PdecHandler::readTc(uint32_t& tcLength) {
-  uint32_t tcOffset = (*(registerBaseAddress + PDEC_BPTR_OFFSET) - PHYSICAL_RAM_BASE_ADDRESS) / 4;
+  uint32_t tcOffset = (*(registerBaseAddress + PDEC_BPTR_OFFSET) - pdecRamBaseAddr) / 4;
 
 #if OBSW_DEBUG_PDEC_HANDLER == 1
   sif::debug << "PdecHandler::readTc: TC offset: 0x" << std::hex << tcOffset << std::endl;

linux/ipcore/PdecHandler.h

@@ -51,6 +51,8 @@ class PdecHandler : public SystemObject,
                     public ReceivesParameterMessagesIF {
  public:
   static constexpr dur_millis_t IRQ_TIMEOUT_MS = 500;
+  static constexpr uint32_t PDEC_CFG_MEM_SIZE = 0x1000;
+  static constexpr uint32_t PDEC_RAM_SIZE = 0x10000;
 
   enum class Modes { POLLED, IRQ };
 
@@ -64,7 +66,7 @@ class PdecHandler : public SystemObject,
    * @param uioregsiters  String of uio device file same mapped to the PDEC register space
    */
   PdecHandler(object_id_t objectId, object_id_t tcDestinationId, LinuxLibgpioIF* gpioComIF,
-              gpioId_t pdecReset, UioNames names);
+              gpioId_t pdecReset, UioNames names, uint32_t cfgMemPhyAddr, uint32_t pdecRamPhyAddr);
 
   virtual ~PdecHandler();
 
@@ -99,12 +101,6 @@ class PdecHandler : public SystemObject,
   static const size_t MAX_TC_SEGMENT_SIZE = 1017;
   static const uint8_t MAP_ID_MASK = 0x3F;
 
-#ifdef TE0720_1CFA
-  static const uint32_t PHYSICAL_RAM_BASE_ADDRESS = 0x32000000;
-#else
-  static const uint32_t PHYSICAL_RAM_BASE_ADDRESS = 0x26000000;
-#endif
-
   // Expected value stored in FAR register after reset
   static const uint32_t FAR_RESET = 0x7FE0;
 
@@ -191,6 +187,9 @@ class PdecHandler : public SystemObject,
   MessageQueueId_t commandedBy = MessageQueueIF::NO_QUEUE;
   bool ptmeResetWithReinitializationPending = false;
 
+  uint32_t cfgMemBaseAddr;
+  uint32_t pdecRamBaseAddr;
+
   UioNames uioNames;
 
   ParameterHelper paramHelper;
@@ -282,6 +281,11 @@ class PdecHandler : public SystemObject,
    */
   void handleIReason(uint32_t pdecFar, ReturnValue_t parameter1);
 
+  /**
+   * @brief	Checks if PDEC configuration is still correct
+   */
+  void checkConfig();
+
   /**
    * @brief   Handles the reception of new TCs. Reads the pointer to the storage location of the
    *          new TC segment, extracts the PUS packet and forwards the data to the object

linux/ipcore/Ptme.cpp

@@ -19,15 +19,12 @@ ReturnValue_t Ptme::initialize() {
   return returnvalue::OK;
 }
 
-ReturnValue_t Ptme::writeToVc(uint8_t vcId, const uint8_t* data, size_t size) {
-  VcInterfaceMapIter vcInterfaceMapIter = vcInterfaceMap.find(vcId);
-  if (vcInterfaceMapIter == vcInterfaceMap.end()) {
-    sif::warning << "Ptme::writeToVc: No virtual channel interface found for the virtual "
-                    "channel with id "
-                 << static_cast<unsigned int>(vcId) << std::endl;
-    return UNKNOWN_VC_ID;
+bool Ptme::containsVc(uint8_t vcId) const {
+  auto channelIter = vcInterfaceMap.find(vcId);
+  if (channelIter == vcInterfaceMap.end()) {
+    return false;
   }
-  return vcInterfaceMapIter->second->write(data, size);
+  return true;
 }
 
 void Ptme::addVcInterface(VcId_t vcId, VirtualChannelIF* vc) {
@@ -50,21 +47,10 @@ void Ptme::addVcInterface(VcId_t vcId, VirtualChannelIF* vc) {
   }
 }
 
-bool Ptme::isBusy(uint8_t vcId) const {
-  const auto& vcInterfaceMapIter = vcInterfaceMap.find(vcId);
-  if (vcInterfaceMapIter == vcInterfaceMap.end()) {
-    sif::warning << "Ptme::writeToVc: No virtual channel interface found for the virtual "
-                    "channel with id "
-                 << static_cast<unsigned int>(vcId) << std::endl;
-    return UNKNOWN_VC_ID;
+VirtualChannelIF* Ptme::getVirtChannel(uint8_t vcId) {
+  auto channelIter = vcInterfaceMap.find(vcId);
+  if (channelIter == vcInterfaceMap.end()) {
+    return nullptr;
   }
-  return vcInterfaceMapIter->second->isBusy();
-}
-
-void Ptme::cancelTransfer(uint8_t vcId) {
-  VcInterfaceMapIter vcInterfaceMapIter = vcInterfaceMap.find(vcId);
-  if (vcInterfaceMapIter == vcInterfaceMap.end()) {
-    return;
-  }
-  return vcInterfaceMapIter->second->cancelTransfer();
+  return channelIter->second;
 }

linux/ipcore/Ptme.h

@@ -34,9 +34,8 @@ class Ptme : public PtmeIF, public SystemObject {
   virtual ~Ptme();
 
   ReturnValue_t initialize() override;
-  ReturnValue_t writeToVc(uint8_t vcId, const uint8_t* data, size_t size) override;
-  bool isBusy(uint8_t vcId) const override;
-  void cancelTransfer(uint8_t vcId) override;
+  bool containsVc(uint8_t vcId) const override;
+  VirtualChannelIF* getVirtChannel(uint8_t vcId) override;
 
   /**
    * @brief   This function adds the reference to a virtual channel interface to the vcInterface