new fsfw

This reverts commit 2800484f6b.

.gitignore

@@ -12,13 +12,8 @@
 #vscode
 /.vscode
 
-# IntelliJ
-/.idea/*
-
 # Python
 __pycache__
-
-# CLion
-!/.idea/cmake.xml
+.idea
 
 generators/*.db

.gitmodules

@@ -10,6 +10,9 @@
 [submodule "thirdparty/lwgps"]
 	path = thirdparty/lwgps
 	url = https://github.com/rmspacefish/lwgps.git
+[submodule "generators/fsfwgen"]
+	path = generators/deps/fsfwgen
+	url = https://egit.irs.uni-stuttgart.de/fsfw/fsfw-gen.git
 [submodule "thirdparty/arcsec_star_tracker"]
 	path = thirdparty/arcsec_star_tracker
 	url = https://egit.irs.uni-stuttgart.de/eive/arcsec_star_tracker.git
@@ -19,6 +22,3 @@
 [submodule "thirdparty/rapidcsv"]
 	path = thirdparty/rapidcsv
 	url = https://github.com/d99kris/rapidcsv.git
-[submodule "thirdparty/gomspace-sw"]
-	path = thirdparty/gomspace-sw
-	url = https://egit.irs.uni-stuttgart.de/eive/gomspace-sw.git

.idea/cmake.xml

@@ -1,16 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="CMakeSharedSettings">
-    <configurations>
-      <configuration PROFILE_NAME="Debug" ENABLED="true" CONFIG_NAME="Debug" NO_GENERATOR="true" />
-      <configuration PROFILE_NAME="Debug Q7S" ENABLED="true" CONFIG_NAME="Debug" TOOLCHAIN_NAME="Q7S" GENERATION_OPTIONS="-DTGT_BSP=&quot;arm/q7s&quot;" NO_GENERATOR="true">
-        <ADDITIONAL_GENERATION_ENVIRONMENT>
-          <envs>
-            <env name="ZYNQ_7020_ROOTFS" value="/opt/xiphos/sdk/ark/sysroots/cortexa9hf-neon-xiphos-linux-gnueabi" />
-            <env name="CROSS_COMPILE" value="/opt/q7s-gcc/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin/arm-linux-gnueabihf" />
-          </envs>
-        </ADDITIONAL_GENERATION_ENVIRONMENT>
-      </configuration>
-    </configurations>
-  </component>
-</project>

.run/Q7S FM.run.xml

@@ -1,10 +0,0 @@
-<component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="Q7S FM" type="com.jetbrains.cidr.remote.gdbserver.type" factoryName="com.jetbrains.cidr.remote.gdbserver.factory" REDIRECT_INPUT="false" ELEVATE="false" USE_EXTERNAL_CONSOLE="false" PASS_PARENT_ENVS_2="true" PROJECT_NAME="eive-obsw" TARGET_NAME="eive-obsw" CONFIG_NAME="Debug" version="1" RUN_TARGET_PROJECT_NAME="eive-obsw" RUN_TARGET_NAME="eive-obsw">
-    <custom-gdb-server version="1" gdb-connect="localhost:1234" executable="" warmup-ms="0" download-type="NONE" sshConfigName="Q7S FM" uploadFile="/tmp/eive-obsw" defaultGdbServerArgs=":1234 /tmp/eive-obsw">
-      <debugger kind="GDB" isBundled="true" />
-    </custom-gdb-server>
-    <method v="2">
-      <option name="CLION.COMPOUND.BUILD" enabled="true" />
-    </method>
-  </configuration>
-</component>

CHANGELOG.md

@@ -8,895 +8,11 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 The [milestone](https://egit.irs.uni-stuttgart.de/eive/eive-obsw/milestones)
 list yields a list of all related PRs for each release.
 
-Starting at v2.0.0, this project will adhere to semantic versioning and the the following changes
-will consitute of a breaking change warranting a new major release:
-
-- The TMTC interface changes in any shape of form.
-- The behaviour of the OBSW changes in a major shape or form relevant for operations
-
 # [unreleased]
 
-# [v1.37.1] 2023-03-14
-
-This version works on the EM as well.
-
-eive-tmtc: v2.19.1
-
-## Added
-
-- Added `EXECUTE_SHELL_CMD` action command for `CoreController` to execute arbitrary Linux commands.
-- Add `PcduHandlerDummy` component.
-- Added parameter for timeout until `MEKF_INVALID_MODE_VIOLATION` event is triggered.
-
-## Fixed
-
-- Pointing control of the `AcsController` was still expecting submodes instead of modes.
-- Limitation of RW speeds was done before converting them to the correct unit scale.
-- The Syrlinks task now has a proper name instead of `MAIN_SPI`.
-- Make whole EIVE system initial transition work for the EM. This was also made possible by
-  always scheduling most EIVE components instead of tying the scheduling to preprocessor defines.
-- Store more TCP und UDP packets.
-- Bump fsfw for small tweak in local datapool manager: Re-enable or re-disabling dataset
-  generation will not fail anymore.
-- Bump FSFW to simplify HK helpers: Was previously buggy and did not allow to use
-  minmum sampling frequency. Now both diagnostics and HK can use minimum
-  sampling frequency for requesting HK
-- Bump FSFW to allow the TC/TM/IPC pools to spill to higher pools/pool pages.
-
-## Changed
-
-- Set `OBSW_ADD_TCS_CTRL` to 1. Always add TCS controller now for both EM and FM.
-- generators module: Bump `fsfwgen` dependency to v0.3.1. The returnvalue CSV files are now sorted.
-- generators module: Always generate subsystem ID CSV files now.
-
-# [v1.37.0] 2023-03-11
-
-eive-tmtc: v2.18.1
-
-## Added
-
-- `SensorProcessing` now includes an FDIR for GPS altitude. If the measured GPS altitude is out
-  of bounds of the range defined in the `AcsParameters`, the altitude defaults to an altitude
-  set in the `AcsParameters`.
-- `AcsController` will now never command a RW speed larger than the maximum allowed speed.
-
-## Fixed
-
-- `PAPB_EMPTY_SIGNAL_VC1` GPIO was not set up properly.
-- Fix for heater names: HPA heater (index 7) is now the Syrlinks heater.
-- `AcsParameters` setter were previously all for scalar parameters. Now vector and matrix
-  parameters use their respective setters.
-- Several `AcsController` components had their own implementation of `AcsParameters`. This resulted
-  in those parameters not being updated, while the actual ones were updated. All instances of
-  `AcsParameters` not belonging to `AcsController` are eiter removed or replaced by pointer
-  instances.
-- Instead of updating the `gsTargetModeControllerParameters`, the `targetModeControllerParameters`
-  were updated.
-- Instead of updating the `idleModeControllerParameters`, the `targetModeControllerParameters`
-  were updated.
-- Fixed Idle Mode Controller never calling `ptgLaw` and therefore never calculating control
-  values.
-- Fixed wrong check on wether file used for persistant boolean flag on successful still existed.
-- Scaling of MTQ Cmds now scales the current values to command with the current values and not
-  the values of the last step, which would result in undefined behaviour.
-- Solved naming collision between file used for solar array deployment and confirmation for
-  ACS for solar array deployment.
-- Fixed that scaling of RW torque would result in a zero vector unless the maximum value was exceeded.
-- Bias for the GYR data was substracted within the wrong rf (sensor rf vs body rf).
-
-## Changed
-
-- Refactored TM pipeline to optimize usage of the PTME and communication downlink bandwidth.
-  This was done by moving the dumping of TMs to the VCs into separate threads with permanent loops.
-  These threads are then able to process high TM loads on demand. The PUS TM funnel will route
-  PUS packets to the approrpiate persisten TM stores and then demultiplex the TM to all registered
-  TM destinations as before.
-- Service 5 now handles 40 events per cycle instead of 15
-- Remove periodic SD card check. The file system is not mounted read-only anymore when using an
-  ext4 filesystem
-- The `detumbleCounter` now does not get hard reset anymore, if the critical rate does not get
-  violated anymore. Instead it is incrementally reset.
-- The RW antistiction now only takes the RW speeds in account.
-- ACS CTRL transition to DETUBMLE is now done in CTRL internally. No
-  system level handling necessary anymore.
-- More fixes and improvements for SD card handling. Extend SD card setup in core controller to
-  create full initial state for SD card manager are core controller as early as possible, turn
-  execution of setup file update blocking. This might solve the issue with the SD card manager
-  sometimes blocking for a long time.
-- Request raw MTM measurement twice for IMTQ, might reduce number of times measurement could not
-  be retrieved.
-- Event manager and event service have larger queues now: 45 -> 120 for Service 5, 80 -> 120 for
-  event manager
-- ACS mode changes: The ACS CTRL submodes are now modes. DETUBMLE is now submode of SAFE mode.
-- EIVE system now tracks the mode of the ACS subsyste in SAFE mode.
-
-# [v1.36.0] 2023-03-08
-
-eive-tmtc: v2.17.2
-
-## Added
-
-- Star Tracker Assembly
-- New `REBOOT_COUNTER` and `INDIVIDUAL_BOOT_COUNTS` events. The first contains the total boot count
-  as a u64, the second one contains the individual boot counts as 4 u16. Add new core controller
-  action command `ANNOUNCE_BOOT_COUNTS` with action ID 3 which triggers both events. These events
-  will also be triggered on each reboot.
-
-## Changed
-
-- Persistent TM stores will now create new files on each reboot.
-- Fast ACS subsystem commanding: Command SUS board consecutively with other devices now
-- Star Tracker: Use ground confguration for EM and flight config for FM by default.
-
-## Fixed
-
-- Command TCS controller off first for TCS subsystem transition to off.
-- Health handling for TCS board assembly
-- Mode fallback from IDLE mode to SAFE mode due to ACS errors/events now works properly for
-  the ACS subsystem
-- Bugfix in IDLE transition for system.
-- `std::filesystem` API usages: Avoid exceptions by using variants which return an error code
-  instead of throwing exceptions.
-- GPS fix loss was not reported if mode is unset.
-- Star Tracker: OFF to NORMAL transition now posssible. Requires FSFW bump which sets
-  transition source modes properly for those transitions.
-  FSFW PR: https://egit.irs.uni-stuttgart.de/eive/fsfw/pulls/131
-- Star Tracker JSON initialization is now done during object initization instead of redoing it
-  when building a command. This avoids missed deadlines issues in the ACS PST.
-- Allow arbitrary submodes for dual lane boards to avoid FDIR reactions of subsystem components.
-  Bump FSFW to allow this.
-- PUS 15 was not scheduled
-- Transmitter timeout set to 2 minutes instead of 15 minutes. This will prevent to discharge the
-  battery in case the syrlinks starts transmitting due to detection of unintentional bitlock. This
-  happened e.g. on ground when the uplink to the flying latop was established.
-- ACS system components are now always scheduled (EM specific)
-
-# [v1.35.1] 2023-03-04
-
-## Fixed
-
-- ACS Board Assembly FDIR: Prevent permanent SAFE mode fallbacks by introducing special health
-  handling.
-  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/418/files
-- Watchdog fixes
-- IMTQ timing fixes
-
-## Added
-
-- Add IMTQ assembly
-
-# [v1.35.0] 2023-03-04
-
-eive-tmtc: v2.16.4
-
-## Added
-
-- Improved the OBSW watchdog by adding a watch functionality. The watch functionality is optional
-  and has to be enabled specifically by the application being watched by the watchdog when
-  starting the watchdog. If the watch functionality is enabled and the OBSW has not pinged
-  the watchdog via the FIFO for 2 minutes, the watchdog will restart the OBSW service via systemd.
-  The primary OBSW will only activate the watch functionality if it is the OBSW inside the
-  `/usr/bin` directory. This allows debugging the system by leaving flashed or manually copied
-  debugging images 2 minutes to start the watchdog without the watch functionality.
-
-## Fixed
-
-- Bumped FSFW: `Countdown` and `Stopwatch` use new monotonic clock API now.
-- IMTQ: Various fixes, most notably missing buffer time after starting MGM measurement
-  and corrections for actuator commanding.
-  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/430
-
-# [v1.34.0] 2023-03-03
-
-eive-tmtc: v2.16.3
-
-This might include the fix for the race condition where CPU usage jumped to 200 %. The race
-condition was traced to the `Countdown` class, more specifically to the `getUptime` function where
-the `/proc/uptime` file is read.
-
-## Changed
-
-- The SD card prefix is now set earlier inside the `CoreController` constructor
-- The watchdog handling was moved outside the `CoreController` into the main loop.
-- Moved polling of all SPI parts to the same PST.
-- Allow quicker transition for the EIVE system component by allowing consecutive TCS and ACS
-  component commanding again.
-- Changed a lot of lock guards to use timeouts
-- Queue sizes of TCP/UDP servers increased from 20 to 50
-- Significantly simplified and improved lock guard handling in TCS and ACS board polling
-  tasks.
-
-## Fixed
-
-- IMTQ: Sets were filled with wrong data, e.g. Raw MTM was filled with calibrated MTM measurements.
-- Set RM3100 dataset to valid.
-- Fixed units in calculation of ACS control laws safe and detumble.
-- Bump FSFW for change in Countdown: Use system clock instead of reading uptime from file
-  to prevent possible race condition.
-- GPS: No fix considered a fault now after 30 minutes instead of 5 hours.
-- SUS Assembly FDIR: Prevent permanent SAFE mode fallbacks by introducing special health
-  handling.
-  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/418/files
-
-## Added
-
-- Added Syrlinks Assembly object to allow recovery handling and to fix faulty FDIR behaviour.
-
-# [v1.33.0] 2023-03-01
-
-eive-tmtc: v2.16.2
-
-## Changed
-
-- Move ACS board polling to separate worker thread.
-- Move SUS board polling to separate worker thread.
-
-## Fixed
-
-- Linux GPS handler now checks the individual `*_SET` flags when analysing the `gpsd` struct.
-  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/400
-
-# [v1.32.0] 2023-02-24
-
-eive-tmtc: v2.16.1
-
-## Fixed
-
-- ADIS1650X: Added missing MDL_RANG pool entry for configuration set
-- Bumped FSFW for bugfix in health service: No execution complete for targeted health announce
-  command.
-- Removed matrix determinant calculation as part of the `MEKF`, which would take about
-  300ms of runtime
-- Resetting the `MEKF` now also actually resets its stored state
-- Bumped FSFW for bugfix in destination handler: Better error handling and able to process
-  destination folder path.
-
-## Changed
-
-- Added basic persistent TM store for PUS telemetry and basic interface to dump and delete
-  telemetry. Implementation is based on a timed rotating files, with the addition that files
-  might be generated more often if the maximum file size of 8192 bytes is exceeded.
-  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/320/files
-- Commented out commanding of actuators as part of the `AcsController`
-- Collection sets of the `AcsController` now get updated before running the actual ACS
-  algorithm
-- `GpsController` now always gets scheduled
-- The `CoreController` now initializes the initial clock from the time file as early as possible
-  (in the constructor) if possible, which should usually be the case.
-
-## Added
-
-- Added basic persistent TM store for PUS telemetry and basic interface to dump and delete
-  telemetry.
-  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/320/files
-- `ExecutableComIfDummy` class to have a dummy for classes like the RTD polling class.
-- Added `AcsController` action command to confirm solar array deployment, which then deletes
-  two files
-- Added `AcsController` action command to reset `MEKF`
-- `GpsCtrlDummy` now initializes the `gpsSet`
-- `RwDummy` now initializes with a non faulty state
-
-
-# [v1.31.1] 2023-02-23
-
-## Fixed
-
-- ADIS1650X configuration set was empty because the local pool variables were not registered.
-  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/402
-- ACS Controller: Correction for size of MEKF dataset and some optimization and fixes
-  for actuator control which lead to a crash.
-  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/403
-
-# [v1.31.0] 2023-02-23
-
-eive-tmtc: v2.16.0
-
-## Fixed
-
-- Usage of floats as iterators and using them to calculate a uint8_t index in `SusConverter`
-- Removed unused variables in the `AcsController`
-- Remove shadowing variables inside ACS assembly classes.
-  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/issues/385
-
-## Changed
-
-COM PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/364
-
-* Moved transmitter timer and handling of carrier and bitlock event from CCSDS handler to COM
-  subsystem
-* Added parameter command to be able to change the transmitter timeout
-* Solves [#362](https://egit.irs.uni-stuttgart.de/eive/eive-obsw/issues/362)
-* Solves [#360](https://egit.irs.uni-stuttgart.de/eive/eive-obsw/issues/360)
-* Solves [#361](https://egit.irs.uni-stuttgart.de/eive/eive-obsw/issues/361)
-* Solves [#386](https://egit.irs.uni-stuttgart.de/eive/eive-obsw/issues/386)
-- All `targetQuat` functions in `Guidance` now return the target quaternion (target
-  in ECI frame), which is passed on to `CtrlValData`.
-- Moved polling sequence table definitions and source code to `mission/core` folder.
-  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/395
-
-## Added
-
-- `MEKF` now returns an unique returnvalue depending on why the function terminates. These
-  returnvalues are used in the `AcsController` to determine on how to procede with its
-  perform functions. In case the `MEKF` did terminate before estimating the quaternion
-  and rotational rate, an info event will be triggered. Another info event can only be
-  triggered after the `MEKF` has run successfully again. If the `AcsController` tries to
-  perform any pointing mode and the `MEKF` fails, the `performPointingCtrl` function will
-  set the RWs to the last RW speeds and set a zero dipole vector. If the `MEKF` does not
-  recover within 5 cycles (2 mins) the `AcsController` triggers another event, resulting in
-  the `AcsSubsystem` being commanded to `SAFE`.
-- `MekfData` now includes `mekfStatus`
-- `CtrlValData` now includes `tgtRotRate`
-
-# [v1.30.0] 2023-02-22
-
-eive-tmtc: v2.14.0
-
-Event IDs for PDEC handler have changed in a breaking manner.
-
-## Added and Fixed
-
-- PDEC: Added basic FDIR to limit the number of allowed TC interrupts and to allow complete task
-  lockups in the case an IRQ is immediately re-raised by the PDEC module. This is done by only
-  allowing a certain number of handled IRQs (whether they yield a valid TC or not) during
-  time windows of one second. Right now, 800 IRQs/TCs are allowed per time window.
-  This time window is reset if a TC reception timeout after 500ms occurs. TBD whether the maximum
-  allowed number will be a configurable parameter. If the number of occured IRQs is exceeded,
-  an event is triggered and the task is delayed for 400 ms.
-  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/393
-
-# [v1.29.1] 2023-02-21
-
-## Fixed
-
-- Limit number of handled messages for core TM handlers:
-  - https://egit.irs.uni-stuttgart.de/eive/eive-obsw/issues/391
-  - https://egit.irs.uni-stuttgart.de/eive/eive-obsw/issues/390
-  - https://egit.irs.uni-stuttgart.de/eive/eive-obsw/issues/389
-- HeaterHandler better handling for faulty message reception
-  Issue: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/issues/388
-- Disable stopwatch in MAX31865 polling task
-
-# [v1.29.0] 2023-02-21
-
-eive-tmtc: v2.13.0
-
-## Changed
-
-- Refactored IMTQ handlers to also perform low level I2C communication tasks in separate thread.
-  This avoids the various delays needed for I2C communication with that device inside the ACS PST.
-  (e.g. 1 ms delay between each transfer, or 10 ms integration delay for MGM measurements).
-
-## Added
-
-- Added new heater info set for the TCS controller. This set contains the heater switch states
-  and the current draw.
-  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/351
-- The HeaterHandler now exposes a mode which reflects whether the heater power
-  is on or off. It also triggers mode events for its heater children objects
-  which show whether the specific heaters are on or off. The heater handler
-  will be part of the TCS tree.
-  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/351
-
-# [v1.28.1] 2023-02-21
-
-## Fixed
-
-- Patch version which compiles for EM
-- CFDP Funnel bugfix: CCSDS wrapping was buggy and works properly now.
-- PDEC: Some adaptions to prevent task lockups on invalid FAR states.
-  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/393
-- CMakeLists.txt fix which broke CI/CD builds when server could not retrieve full git SHA.
-- Possible regression in the MAX31865 polling task: Using a `ManualCsLockGuard` for reconfiguring
-  and then polling the sensor is problematic, invalid sensor values will be read.
-  CS probably needs to be de-asserted or some other HW/SPI specific issue. Letting the SPI ComIF
-  do the locking does the job.
-
-## Changed
-
-- Add `-Wshadow=local` shadowing warnings and fixed all of them
-- Updated generated CSV files: Support for skip directive and explicit
-  "No description" info string
-- The polling threads for actuator polling now have a slightly higher priority than the ACS PST
-  to ensure timing requirements are met.
-
-## Added
-
-- git post checkout hook which initializes and updates the submodules
-  automatically.
-
-# [v1.28.0] 2023-02-17
-
-eive-tmtc: v2.12.7
-
-## Added
-
-- In case the ACS Controller does recognize more than one RW to be invalid and therefore not
-  available, it does not perform pointing control but aborts shortly after `sensorProcessing`. If the
-  problem persits for 5 ACS cycles, the `MULTIPLE_RW_INVALID` event is triggered, which invokes the
-  transition of the `AcsSubsystem` to safe mode.
-
-## Changed
-
-- Igrf13 model vector now outputs as uT instead of nT
-- Changed timings for `AcsPst`, more time for sun sensors.
-- Added values for MGM sensor fusion
-- Refactored RW Software: Polling runs in separate thread, all RWs are now polled in under 60 ms.
-  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/381
-- Bumped FSFW to allow initializing child modes in `SubsystemBase` derived objects.
-
-## Fixed
-
-- Fixed values for GYR sensor fusion
-- Fixed speed types for `rwHandlingParameter`
-- Pseudo inverse used for allocating torque to RWs and RW antistiction now actually consider the
-  state of the RWs
-
-# [v1.27.2] 2023-02-14
-
-Reaction Wheel handling was determined to be (quasi) broken and needs to be fixed in future release
-to be usable by ACS controller.
-
-eive-tmtc: v2.12.6
-
-## Added
-
-- Function for the ACS controller to command MTQ and RWs called by all subroutines
-- RwHandler now handles commanding of RW speeds via RwSpeedActuationSet
-- Tracing supports which allows checking whether threads are running as usual.
-
-## Changed
-
-- Remove 2 TCS threads.
-- Move low level polling into ACS PST, move high level device handlers into TCS system task.
-- ActCmds now returns command vectors as integers as required by the actuators
-  and scales them to the appropriate range
-- All RwHandler are now polled five times per ACS cycle
-- Remove 2 TCS threads. Move low level polling into ACS PST, move high level device handlers into
-  TCS system task.
-- Further reduce number of threads:
-  1. Remove PUS low priority task, move assigned threads to the generic system task
-  2. Group events and verification tasks into PUS high priority task
-  3. Group all other components into PUS medium priority task
-  4. Add SCEX device handler to PL task, remove dedicated thread
-
-## Removed
-
-- lwgps dependency not compiled anymore, is not used
-
-# [v1.27.1] 2023-02-13
-
-## Fixed
-
-- Fix for SPI ComIF: Set transfer size to 0 for failed transfers
-- Fix shadowing issue with locks in MAX31865 low level handler
-
-# [v1.27.0] 2023-02-13
-
-eive-tmtc: v2.12.5
-
-Added EIVE system top mode component. Currently, only SAFE and IDLE mode are
-implemented, and the system does not do more than commanding TCS and ACS
-into the correct modes. It does not have a lot of mode tracking capabilities
-yet because the ACS controller might alternate between SAFE and DETUMBLE.
-It takes around 5-10 seconds for the EIVE system to reach the SAFE mode.
-
-The new system is used at software boot to command the satellite into safe mode
-on each reboot. This behaviour can be disabled with the
-`OBSW_SWITCH_TO_NORMAL_MODE_AFTER_STARTUP` flag.
-
-## Added
-
-- New EIVE system component like explained above.
-
-## Changed
-
-- The satellite now commands itself into SAFE mode on each reboot, which
-  triggers a lot of events on each SW reboot. The TCS subsystem will commanded
-  to NORMAL mode immediately while the ACS subsystem will be commanded to
-  SAFE mode. The payload subsystem will be commanded OFF.
-- `RELEASE_BUILD` flag moved to `commonConfig.h`
-- The ACS subsystem transitions are now staggered: The SUS board assembly
-  is commanded as a separate transition. This reduces the risk of long bus lockups.
-- No INFO mode event translations for release builds to reduce number of
-  printouts.
-- More granular locking inside the MAX31865 low level read handler.
-
-## Fixed
-
-- More DHB thermal module fixes.
-- ACS PST frequency extended to 0.8 seconds in debug builds to avoid SPI
-  bus lockups.
-- Local datapool fixes for the `PlocSupervisorHandler`
-
-# [v1.26.4] 2023-02-10
-
-eive-tmtc: v2.12.3
-
-## Fixed
-
-- `SdCardManager.cpp` `isSdCardUsable`: Use `ext4` instead of `vfat` to check read-only state.
-
-# [v1.26.3] 2023-02-09
-
-eive-tmtc: v2.12.2
-
-## Added
-
-- First version of a TCS controller heater control loop, but
-  the loop is disabled for now.
-
-## Changed
-
-- Reworked dummy handling for the TCS controller.
-  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/325
-- Generator scripts now generate files for hosted and for Q7S build.
-
-## Fixed
-
-- GPS Controller: Set fix value to 0 when switching off to allow
-  `GPS_FIX_CHANGE` to work when switching the GPS back on.
-
-# [v1.26.2] 2023-02-08
-
-## Changed
-
-- ACS Controller scheduling is now configurable via the `eive/definitions.h` file. Also ensured
-  that scheduling is done in big blocks to reduce risk of missed deadlines.
-- Replaced chained locks for polling new sensor data to the `AcsController`.
-- Made TM store even larger.
-
-## Fixed
-
-- Bugfix for PDEC handler which causes the PIR register of the PDEC to never
-  be cleared on release builds. The dummy variable used to read the register
-  needs to be declared volatile to avoid compiler optimizations.
-  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/374
-- Bumped FSFW for fix of possible memory leaks in TCP/IP TMTC bridge
-  inside the FSFW.
-
-## Added
-
-- Create TCS controller for EM build.
-
-# [v1.26.1] 2023-02-08
-
-- Initialize parameter helper in ACS controller.
-
-# [v1.26.0] 2023-02-08
-
-eive-tmtc v2.12.1
-
-## Changed
-
-### ACS
-
-- Readded calibration matrices for MGM calibration.
-- Added calculation of satellite velocity vector from GPS position data
-- Added detumble mode using GYR values
-- Added inertial pointing mode
-- Added nadir pointing mode
-- Added ground station target mode
-- Added antistiction for RWs
-- Added `sunTargetSafe` differentiation for LEOP
-- Added check for existance of `SD_0_SKEWED_PTG_FILE` and `SD_1_SKEWED_PTG_FILE` to determine
-  which `sunTargetSafe` to use
-- Added `gpsVelocity` and `gpsPosition` to `gpsProcessed`
-- Removed deprecated `OutputValues`
-- Added `HasParametersIF` to `AcsParameters`
-- Added `ReceivesParameterMessagesIF` and `ParameterHelper` to `AcsController`
-- Updated `AcsParameters` with actual values and changed structure
-- Sun vector model and magnetic field vector model calculations are always executed now
-- `domainId` is now used as identifier for parameter structs
-- Changed onboard GYR value handling from deg/s to rad/s
-
-## Fixed
-
-- Single sourcing the version information into `CMakeLists.txt`. The `git describe` functionality
-  is only used to retrieve the git SHA hash now. Also removed `OBSWVersion.h` accordingly.
-- Build system: Fixed small bug, where the version itself was
-  stored as the git SHA hash in `commonConfig.h`. This will be
-  an empty string now for regular versions.
-- Bump FSFW for important fix in PUS mode service.
-
-### ACS
-
-- Bugfixes in 'SensorProcessing' where previously MGM values would be calibrated before being
-  transformed in body RF. However, the calibration values are in the body RF. Also fixed the
-  validity flag of 'mgmVecTotDerivative'.
-- Fixed calculation of model sun vector
-- Fixed calculation of model magnetic field vector
-- Fixed MEKF algorithm
-- Fixed several variable initializations
-- Fixed several variable types
-- Fixed use of `sunMagAngleMin` for safe mode
-- Fixed MEKF not using correct `sampleTime`
-- Fixed assignment of `SUS0` and `SUS6` calibration matrices due to wiring being mixed up
-- Various smaller bugfixes
-
-# [v1.25.0] 2023-02-06
-
-eive-tmtc version: v2.12.0
-
-## Changed
-
-- Updated Subsystem mode IDs to avoid clashes with regular device handler modes.
-
-## Fixed
-
-- `GpsHyperionLinuxController`: Fix `gpsd` polling by continuously calling `gps_read` in one cycle
-  until it does not have any data left anymore. Also, the data is now polled in a permanent loop,
-  where controller handling is done on 0.2 second timeouts.
-  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/368
-
-# [v1.24.0] 2023-02-03
-
-- eive-tmtc v2.10.0
-- `AcsSubsystem`: OFF, SAFE and DETUMBLE mode were tested. Auto-transitions SAFE <-> DETUMBLE tested
-  as well. Other modes still need to be tested.
-
-## Fixed
-
-- `AcsController`: Parameter fix in `DetumbleParameter`.
-- Set GPS set entries to invalid on MODE_OFF command.
-- Bump FSFW for bugfix in `setNormalDatapoolEntriesInvalid` where the validity was not set to false
-  properly
-- Fixed usage of uint instead of int for commanding MTQ. Also fixed the range in which the ACS Ctrl
-  commands the MTQ to match the actual commanding range.
-  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/363
-- Regression: Revert swap of SUS0 and SUS6. Those devices are on separate power lines. In a
-  future fix, the calibration matrices of SUS0 and SUS6 will be swapped.
-
-## Changed
-
-- Update ACS scheduling to represent the actual ACS design. There is one ACS PST now for all
-  timing sensitive ACS operations. In the debug builds, the new ACS polling sequence table
-  will have a period of 0.6 seconds, but will remain 0.4 seconds for the release build.
-  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/365
-- `ACS::SensorValues` is now an ACS controller member to reduce the risk of stack overflow.
-- ACS Subsystem Sequence Mode IDs updated.
-  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/365
-  TMTC PR: https://egit.irs.uni-stuttgart.de/eive/eive-tmtc/pulls/130
-- Update and tweak ACS subsystem to represent the actual ACS design
-- Event handling in the ACS subsystem for events triggered by the ACS controller.
-  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/365
-
-# [v1.23.1] 2023-02-02
-
-TMTC rev: 15adb9bf2ec68304a4f87b8dd418c1a8353283a3
-
-## Fixed
-
-- Bugfix in FSFW where the sequence flags of the PUS packets were set to continuation segment (0b00)
-  instead of unsegmented (0b11).
-- Bugfix in FSFW where the MGM RM3100 value Z axis data was parse incorrectly.
-  PR: https://egit.irs.uni-stuttgart.de/eive/fsfw/pulls/123
-
-# [v1.23.0] 2023-02-01
-
-TMTC version: v2.9.0
-
-## Changed
-
-- Bumped FSFW to include improvements and bugfix for Health Service. The health service now
-  supports the announce all health info command.
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/725
-
-## Fixed
-
-- Bumped FSFW to include fixes in the time service.
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/726
-- The CCSDS handler starts the transmitter timer each time it is commanded to MODE_ON and times
-  out the timer when the handler is commanded to MODE_OFF
-- If the timer is timed out the CCSDS handler will disable the TX clock which will cause the
-  syrlinks to got to standby mode
-- PDEC handler now parses the FAR register also in interrupt mode
-
-
-# [v1.22.1] 2023-01-30
-
-## Changed
-
-- Updated FSFW to include addition where the `SO_REUSEADDR` option is set
-  on the TCP server, which should improve its ergonomics.
-
-# [v1.22.0] 2023-01-28
-
-TMTC version: v2.6.1
-
-## Added
-
-- First COM subsystem implementation. It mirrors the Syrlinks mode/submodes but also takes
-  care of commanding the CCSDS handler. It expects the Syrlinks submodes as mode commands.
-  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/358
-- The CCSDS handler has has a new submode (3) to configure the default datarate.
-- Default datarate parameter commanding moved to COM subsystem.
-  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/358
-
-# [v1.21.0] 2023-01-26
-
-TMTC version: v2.5.0
-Syrlinks PR: PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/353
-
-## Fixed
-
-- The `OBSW_SYRLINKS_SIMULATED` flag is set to 0 for for both EM and FM.
-- MGM4 handling in ACS sensor processing: Bugfix in `mulScalar` operation
-  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/354
-- Subsystem ID clash: CORE subsystem ID was the same as Syrlinks subsystem ID.
-
-## Changed
-
-- Startracker temperature set and PCDU switcher set are diagnostic now
-- `SyrlinksHkHandler` renamed to `SyrlinksHandler` to better reflect that it does more than
-  just HK and is also responsible for setting the TX mode of the device.
-- `SyrlinksHandler`: Go to startup immediately because the Syrlinks device should always be on
-  by default.
-- `SyrlinksHandler`: Go to normal mode at startup.
-
-## Added
-
-- The Syrlinks handler has submodes for the TX mode now: RX Only (0), RX and TX default
-  datarate (1), RX and TX Low Rate (2), RX and TX High Rate (3) and TX Carrier Wave (4).
-  The submodes apply for both ON and NORMAL mode. The default datarate can be updated using
-  a parameter command (domain ID 0 and unique ID 0) with value 0 for low rate and 1 for high rate.
-- The Syrlinks handler always sets TX to standby when switching off
-- The Syrlinks handler triggers a new TX_ON event when the transmitter was switched on successfully
-  and a TX_OFF event when it was switched off successfully.
-- Startracker temperature set and PCDU switcher set are diagnostic now
-- The CCSDS handler can accept mode commands now. It accepts ON and OFF commands. Furthermore
-  it has a submode for low datarate (1) and high datarate (2) for the ON command.
-  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/352
-
-# [v1.20.0] 2023-01-24
-
-## Added
-
-- The Q7S SW now checks for a file named `boot_delay_secs.txt` in the home directory.
-  If it exists and the file is empty, it will delay for 6 seconds before continuing
-  with the regular boot. It can also try to read delay seconds from the file.
-  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/340.
-- Basic TCS Subsystem component.
-  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/319
-- Expose base set of STR periodic housekeeping packets
-
-## Changed
-
-- Moved some PDEC/PTME configuration to `common/config/eive/definitions.h`
-  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/319
-- The ACS Controller Gyro Sets (raw and processed) and the MEKF dataset are diagnostics now.
-- Bumped FSFW for Service 11 improvement which includes size and CRC check for contained TC
-- Syrlinks module now always included for both EM and FM
-- SA Deployment: Allow specifying the switch interval and the initial channel. This allows testing
-  the new deployment procedure where each channel is burned for half of the whole burn duration.
-  It also allows burning only one channel for the whole burn duration. The autonomous mechanism
-  was adapted to burn each channel for half of the burn time by default.
-  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/347
-  TMTC PR: https://egit.irs.uni-stuttgart.de/eive/eive-tmtc/pulls/127
-- `Max31865RtdLowlevelHandler.cpp`: For each RTD device, the config is now re-written before
-  every read. This seems to fix some issue with invalid temperature sensor readings.
-  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/345
-
-## Fixed
-
-- `GyroADIS1650XHandler`: Updated handler to determine correct dynamic range from `RANG_MDL`
-  register readout. This is because ADIS16505-3BMLZ devices are used on the ACS board and the
-  previous range setting was wrong. Also fixed a small error properly set internal state
-  on shut-down.
-  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/342
-- 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 
-  and L3GD20 sensors.
-  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/346
-
-# [v1.19.0] 2023-01-10
-
-## Changed
-
-- 5V stack is now off by default
-
-## Fixed
-
-- PLOC SUPV: Minor adaptions and important bugfix for UART manager
-- Allow cloning and building the hosted OBSW version without proprietary libraries,
-  which also avoids the need to have a Gitea account.
-  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/337
-
-## Added
-
-- First version of ACS controller
-  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/329
-- Allow commanding the 5V stack internally in software
-  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/334
-- Add automatic 5V stack commanding for all connected devices
-  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/335
-
-# [v1.18.0] 2022-12-01
-
-## Changed
-
-- PLOC Supervisor: Changes baudrate to 921600
-- Renamed `/dev/ul-plsv` to `/dev/ploc_supv`, is not a UART lite anymore
-- Renamed `/dev/i2c_eive` to `/dev/i2c_pl` and `/dev/i2c-2` to `/dev/i2c_ps`.
-  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/328
-
-# [v1.17.0] 2022-11-28
-
-## Added
-
-- PLOC Supervisor Update: Update SW to use newest PLOC SUPV version by TAS
-  PR 1: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/316
-  PR 2: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/324
-  PR 3: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/326
-
-# [v1.16.0] 2022-11-18
-
-- It is now possible to compile Linux components for the hosted build conditionally
-  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/322
-- ACS Subsystem. PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/231
-- Payload Subsystem. PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/231
-- Add IRQ mode for PDEC handler. PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/310
-- Extended TM funnels to allow multiple TM recipients.
-  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/312
-- DHB: Transitions to normal mode now possible directly, which simplifies subsystem implementations
-  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/313
-- MAX3185 Low Level Handler and Device Handler: Simplifications and bugfixes to allow switching
-  off without triggering unrequested replies
-  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/313
-- Add remaining missing TMP1075 device handlers.
-  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/318
-
-# [v1.15.0] 2022-10-27
-
-- Consistent device file naming
-- Remove rad sensor from EM build, lead to weird bugs on EM which
-  prevented `xsc_boot_copy` from working properly
-- CFDP closure handling is now working
-  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/307
-- Safety mechanism for SD card handling on graceful reboots
-  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/308
-- Solar Array Deployment handler update
-  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/305
-- IMTQ updates as preparation for ACS controller expansion
-  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/306
-- P60 Module: Reduce number of set IDs, use same set IDs for core, auxiliary
-  and config HK set across the three PCDU modules
-
-# [v1.14.1] 11.10.2022
-
-- Various bugfixes and regression fixes
-- General file handling at program initialization now works properly again
-- Scratch buffer preferred SD card handling works again
-- Use scoped locks in TCS controller to avoid deadlocks
-
-# [v1.14.0] 10.10.2022
-
-- Provide full SW update capability for the OBSW.
-  This includes very basic CFDP integration, a software update
-  procedure specified in detail in the README and some high level
-  commands to make this easier for operators.
-  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/302
-- Update for FSFW: `HasReturnvaluesIF` class replaced by namespace `returnvalue`
-- Add some GomSpace clients as a submodule dependency. Use this dependency to deserialize the
-  GomSpace TM tables
-- Add API to retrieve GomSpace device parameter tables
-  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/287
-- Add API to save and load GomSpace config tables
-  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/293
-- Increase number of allowed consescutive action commands from 3 to 16
-  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/294
-- Fix for EM SW: Always create ACS Task
-- Added Scex device handler and Scex uart reader
-  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/303
-- ACS Subsystem. PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/228
-
-# [v1.13.0] 24.08.2022
+# [v1.13.0]
 
 - Added first version of ACS Controller with gathers MGM data in a set
-- Some tweaks for IMTQ handler
 
 # [v1.12.1] 05.07.2022
 

CMakeLists.txt

@@ -9,12 +9,13 @@
 # ##############################################################################
 cmake_minimum_required(VERSION 3.13)
 
-set(OBSW_VERSION_MAJOR 1)
-set(OBSW_VERSION_MINOR 37)
-set(OBSW_VERSION_REVISION 1)
+set(OBSW_VERSION_MAJOR_IF_GIT_FAILS 0)
+set(OBSW_VERSION_MINOR_IF_GIT_FAILS 0)
+set(OBSW_VERSION_REVISION_IF_GIT_FAILS 0)
 
 # set(CMAKE_VERBOSE TRUE)
 
+
 option(
   EIVE_HARDCODED_TOOLCHAIN_FILE
   "\
@@ -71,13 +72,11 @@ if(EIVE_Q7S_EM)
       1
       CACHE STRING "Q7S EM configuration")
   set(INIT_VAL 0)
-  set(OBSW_STAR_TRACKER_GROUND_CONFIG 1)
 else()
   set(OBSW_Q7S_EM
       0
       CACHE STRING "Q7S EM configuration")
   set(INIT_VAL 1)
-  set(OBSW_STAR_TRACKER_GROUND_CONFIG 0)
 endif()
 set(OBSW_ADD_MGT
     ${INIT_VAL}
@@ -97,36 +96,9 @@ set(OBSW_ADD_SUS_BOARD_ASS
 set(OBSW_ADD_ACS_BOARD
     ${INIT_VAL}
     CACHE STRING "Add ACS board module")
-set(OBSW_ADD_GPS_CTRL
+set(OBSW_ADD_ACS_HANDLERS
     ${INIT_VAL}
-    CACHE STRING "Add GPS controllers")
-set(OBSW_ADD_CCSDS_IP_CORES
-    1
-    CACHE STRING "Add CCSDS IP cores")
-set(OBSW_TM_TO_PTME
-    1
-    CACHE STRING "Send telemetry to PTME IP core")
-set(OBSW_TC_FROM_PDEC
-    1
-    CACHE STRING "Poll telecommand from PDEC IP core")
-set(OBSW_ADD_TCS_CTRL
-    1
-    CACHE STRING "Add TCS controllers")
-set(OBSW_ADD_HEATERS
-    ${INIT_VAL}
-    CACHE STRING "Add TCS heaters")
-set(OBSW_ADD_PLOC_SUPERVISOR
-    ${INIT_VAL}
-    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}
-    CACHE STRING "Add MPSoC handler")
-set(OBSW_ADD_ACS_CTRL
-    ${INIT_VAL}
-    CACHE STRING "Add ACS controller")
+    CACHE STRING "Add ACS handlers")
 set(OBSW_ADD_RTD_DEVICES
     ${INIT_VAL}
     CACHE STRING "Add RTD devices")
@@ -137,7 +109,7 @@ set(OBSW_ADD_PL_PCDU
     ${INIT_VAL}
     CACHE STRING "Add Payload PCDU modukle")
 set(OBSW_ADD_SYRLINKS
-    1
+    ${INIT_VAL}
     CACHE STRING "Add Syrlinks module")
 set(OBSW_ADD_TMP_DEVICES
     ${INIT_VAL}
@@ -148,12 +120,6 @@ set(OBSW_ADD_GOMSPACE_PCDU
 set(OBSW_ADD_RW
     ${INIT_VAL}
     CACHE STRING "Add RW modules")
-set(OBSW_ADD_SCEX_DEVICE
-    ${INIT_VAL}
-    CACHE STRING "Add Solar Cell Experiment module")
-set(OBSW_SYRLINKS_SIMULATED
-    0
-    CACHE STRING "Syrlinks is simulated")
 
 # ##############################################################################
 # Pre-Sources preparation
@@ -170,21 +136,32 @@ if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/.git)
     set(GIT_INFO
         ${GIT_INFO}
         CACHE STRING "Version information retrieved with git describe")
-    # CMakeLists.txt is now single source of information. list(GET GIT_INFO 1
-    # OBSW_VERSION_MAJOR) list(GET GIT_INFO 2 OBSW_VERSION_MINOR) list(GET
-    # GIT_INFO 3 OBSW_VERSION_REVISION)
-    list(LENGTH GIT_INFO LIST_LEN)
-    if(LIST_LEN GREATER 4)
-      list(GET GIT_INFO 4 OBSW_VERSION_CST_GIT_SHA1)
+    list(GET GIT_INFO 1 OBSW_VERSION_MAJOR)
+    list(GET GIT_INFO 2 OBSW_VERSION_MINOR)
+    list(GET GIT_INFO 3 OBSW_VERSION_REVISION)
+    list(GET GIT_INFO 4 OBSW_VERSION_CST_GIT_SHA1)
+    if(NOT OBSW_VERSION_MAJOR)
+      set(OBSW_VERSION_MAJOR ${OBSW_VERSION_MAJOR_IF_GIT_FAILS})
+    endif()
+    if(NOT OBSW_VERSION_MINOR)
+      set(FSFW_SUBVERSION ${OBSW_VERSION_MINOR_IF_GIT_FAILS})
+    endif()
+    if(NOT OBSW_VERSION_REVISION)
+      set(FSFW_REVISION ${OBSW_VERSION_REVISION_IF_GIT_FAILS})
     endif()
     set(GIT_VER_HANDLING_OK TRUE)
   else()
     set(GIT_VER_HANDLING_OK FALSE)
   endif()
 endif()
+if(NOT GIT_VER_HANDLING_OK)
+  set(OBSW_VERSION_MAJOR ${OBSW_VERSION_MAJOR_IF_GIT_FAILS})
+  set(OBSW_VERSION_MINOR ${OBSW_VERSION_MINOR_IF_GIT_FAILS})
+  set(OBSW_VERSION_REVISION ${OBSW_VERSION_REVISION_IF_GIT_FAILS})
+endif()
 
 # Set names and variables
-set(OBSW_NAME ${CMAKE_PROJECT_NAME})
+set(OBSW_NAME ${PROJECT_NAME})
 set(WATCHDOG_NAME eive-watchdog)
 set(SIMPLE_OBSW_NAME eive-simple)
 set(UNITTEST_NAME eive-unittest)
@@ -194,9 +171,6 @@ set(LIB_ETL_TARGET etl::etl)
 set(LIB_CSP_NAME libcsp)
 set(LIB_LWGPS_NAME lwgps)
 set(LIB_ARCSEC wire)
-set(LIB_GOMSPACE_CLIENTS gs_clients)
-set(LIB_GOMSPACE_CSP gs_csp)
-
 set(THIRD_PARTY_FOLDER thirdparty)
 set(LIB_CXX_FS -lstdc++fs)
 set(LIB_CATCH2 Catch2)
@@ -209,14 +183,14 @@ set(FSFW_PATH fsfw)
 set(TEST_PATH test)
 set(UNITTEST_PATH unittest)
 set(LINUX_PATH linux)
-set(LIB_GOMSPACE_PATH ${THIRD_PARTY_FOLDER}/gomspace-sw)
-set(COMMON_PATH common)
+set(COMMON_PATH ${CMAKE_CURRENT_SOURCE_DIR}/common)
 set(DUMMY_PATH dummies)
 set(WATCHDOG_PATH watchdog)
 set(COMMON_CONFIG_PATH ${COMMON_PATH}/config)
 set(UNITTEST_CFG_PATH ${UNITTEST_PATH}/testcfg)
 
 set(LIB_EIVE_MISSION_PATH mission)
+set(LIB_CSP_PATH ${THIRD_PARTY_FOLDER}/libcsp)
 set(LIB_ETL_PATH ${THIRD_PARTY_FOLDER}/etl)
 set(LIB_CATCH2_PATH ${THIRD_PARTY_FOLDER}/Catch2)
 set(LIB_LWGPS_PATH ${THIRD_PARTY_FOLDER}/lwgps)
@@ -224,8 +198,7 @@ set(LIB_ARCSEC_PATH ${THIRD_PARTY_FOLDER}/arcsec_star_tracker)
 set(LIB_JSON_PATH ${THIRD_PARTY_FOLDER}/json)
 
 set(FSFW_WARNING_SHADOW_LOCAL_GCC OFF)
-set(EIVE_ADD_LINUX_FILES OFF)
-set(FSFW_ADD_TMSTORAGE ON)
+set(EIVE_ADD_LINUX_FILES False)
 
 # Analyse different OS and architecture/target options, determine BSP_PATH,
 # display information about compiler etc.
@@ -233,6 +206,7 @@ pre_source_hw_os_config()
 
 if(TGT_BSP)
   set(LIBGPS_VERSION_MAJOR 3)
+
   # I assume a newer version than 3.17 will be installed on other Linux board
   # than the Q7S
   set(LIBGPS_VERSION_MINOR 20)
@@ -242,18 +216,15 @@ if(TGT_BSP)
      OR TGT_BSP MATCHES "arm/egse"
      OR TGT_BSP MATCHES "arm/te0720-1cfa")
     find_library(${LIB_GPS} gps)
-    set(FSFW_CONFIG_PATH "linux/fsfwconfig")
+    set(FSFW_CONFIG_PATH ${CMAKE_CURRENT_SOURCE_DIR}/linux/fsfwconfig)
+
     if(NOT BUILD_Q7S_SIMPLE_MODE)
       set(EIVE_ADD_LINUX_FILES TRUE)
-      set(EIVE_ADD_LINUX_FSFWCONFIG TRUE)
-      set(ADD_GOMSPACE_CSP TRUE)
-      set(ADD_GOMSPACE_CLIENTS TRUE)
+      set(ADD_CSP_LIB TRUE)
       set(FSFW_HAL_ADD_LINUX ON)
       set(FSFW_HAL_LINUX_ADD_LIBGPIOD ON)
       set(FSFW_HAL_LINUX_ADD_PERIPHERAL_DRIVERS ON)
     endif()
-  elseif(UNIX)
-    set(EIVE_ADD_LINUX_FILES ON)
   endif()
 
   if(TGT_BSP MATCHES "arm/raspberrypi")
@@ -288,19 +259,6 @@ if(TGT_BSP)
 else()
   # Required by FSFW library
   set(FSFW_CONFIG_PATH "${BSP_PATH}/fsfwconfig")
-  if(UNIX)
-    set(EIVE_ADD_LINUX_FILES ON)
-  endif()
-endif()
-
-include(BuildType)
-set_build_type()
-
-set(FSFW_DEBUG_INFO 0)
-set(Q7S_CHECK_FOR_ALREADY_RUNNING_IMG 0)
-if(RELEASE_BUILD MATCHES 0)
-  set(FSFW_DEBUG_INFO 1)
-  set(Q7S_CHECK_FOR_ALREADY_RUNNING_IMG 1)
 endif()
 
 # Configuration files
@@ -316,8 +274,9 @@ endif()
 configure_file(${WATCHDOG_PATH}/watchdogConf.h.in watchdogConf.h)
 
 # Set common config path for FSFW
-set(FSFW_ADDITIONAL_INC_PATHS "${COMMON_PATH}/config"
-                              ${CMAKE_CURRENT_BINARY_DIR})
+set(FSFW_ADDITIONAL_INC_PATHS "${COMMON_PATH}"
+  ${COMMON_CONFIG_PATH}
+  ${CMAKE_CURRENT_BINARY_DIR})
 
 # ##############################################################################
 # Executable and Sources
@@ -325,6 +284,31 @@ set(FSFW_ADDITIONAL_INC_PATHS "${COMMON_PATH}/config"
 
 # global compiler options need to be set before adding executables
 if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+  add_compile_options(
+    "-Wall"
+    "-Wextra"
+    "-Wimplicit-fallthrough=1"
+    "-Wno-unused-parameter"
+    "-Wno-psabi"
+    "-Wduplicated-cond" # check for duplicate conditions
+    "-Wduplicated-branches" # check for duplicate branches
+    "-Wlogical-op" # Search for bitwise operations instead of logical
+    "-Wnull-dereference" # Search for NULL dereference
+    "-Wundef" # Warn if undefind marcos are used
+    "-Wformat=2" # Format string problem detection
+    "-Wformat-overflow=2" # Formatting issues in printf
+    "-Wformat-truncation=2" # Formatting issues in printf
+    "-Wformat-security" # Search for dangerous printf operations
+    "-Wstrict-overflow=3" # Warn if integer overflows might happen
+    "-Warray-bounds=2" # Some array bounds violations will be found
+    "-Wshift-overflow=2" # Search for bit left shift overflows (<c++14)
+    "-Wcast-qual" # Warn if the constness is cast away
+    "-Wstringop-overflow=4"
+    # -Wstack-protector # Emits a few false positives for low level access
+    # -Wconversion # Creates many false positives -Warith-conversion # Use with
+    # Wconversion to find more implicit conversions -fanalyzer # Should be used
+    # to look through problems
+  )
   # Remove unused sections.
   add_compile_options("-ffunction-sections" "-fdata-sections")
 
@@ -340,39 +324,7 @@ add_library(${LIB_DUMMIES})
 
 # Add main executable
 add_executable(${OBSW_NAME})
-set(OBSW_BIN_NAME ${CMAKE_PROJECT_NAME})
-
-if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-  set(WARNING_FLAGS
-      "-Wall"
-      "-Wextra"
-      "-Wimplicit-fallthrough=1"
-      "-Wno-unused-parameter"
-      "-Wno-psabi"
-      "-Wshadow=local"
-      "-Wduplicated-cond" # check for duplicate conditions
-      "-Wduplicated-branches" # check for duplicate branches
-      "-Wlogical-op" # Search for bitwise operations instead of logical
-      "-Wnull-dereference" # Search for NULL dereference
-      "-Wundef" # Warn if undefind marcos are used
-      "-Wformat=2" # Format string problem detection
-      "-Wformat-overflow=2" # Formatting issues in printf
-      "-Wformat-truncation=2" # Formatting issues in printf
-      "-Wformat-security" # Search for dangerous printf operations
-      "-Wstrict-overflow=3" # Warn if integer overflows might happen
-      "-Warray-bounds=2" # Some array bounds violations will be found
-      "-Wshift-overflow=2" # Search for bit left shift overflows (<c++14)
-      "-Wcast-qual" # Warn if the constness is cast away
-      "-Wstringop-overflow=4"
-      # -Wstack-protector # Emits a few false positives for low level access
-      # -Wconversion # Creates many false positives -Warith-conversion # Use
-      # with Wconversion to find more implicit conversions -fanalyzer # Should
-      # be used to look through problems
-  )
-  target_compile_options(${OBSW_NAME} PRIVATE ${WARNING_FLAGS})
-  target_compile_options(${LIB_EIVE_MISSION} PRIVATE ${WARNING_FLAGS})
-  target_compile_options(${LIB_DUMMIES} PRIVATE ${WARNING_FLAGS})
-endif()
+set(OBSW_BIN_NAME ${PROJECT_NAME})
 
 set_target_properties(${OBSW_NAME} PROPERTIES OUTPUT_NAME ${OBSW_BIN_NAME})
 
@@ -402,20 +354,24 @@ if(EIVE_ADD_JSON_LIB)
   add_subdirectory(${LIB_JSON_PATH})
 endif()
 
-add_subdirectory(thirdparty)
+add_subdirectory(thirdparty/rapidcsv)
 
 if(EIVE_ADD_LINUX_FILES)
-  if(TGT_BSP MATCHES "arm/q7s")
-    add_subdirectory(${LIB_GOMSPACE_PATH})
-    add_subdirectory(${LIB_ARCSEC_PATH})
-  endif()
+  add_subdirectory(${LIB_ARCSEC_PATH})
   add_subdirectory(${LINUX_PATH})
 endif()
+
 add_subdirectory(${BSP_PATH})
 
+
+if(ADD_CSP_LIB)
+  add_subdirectory(${LIB_CSP_PATH})
+endif()
+
 add_subdirectory(${COMMON_PATH})
 add_subdirectory(${DUMMY_PATH})
 
+add_subdirectory(${LIB_LWGPS_PATH})
 add_subdirectory(${FSFW_PATH})
 add_subdirectory(${LIB_EIVE_MISSION_PATH})
 add_subdirectory(${TEST_PATH})
@@ -423,19 +379,21 @@ add_subdirectory(${TEST_PATH})
 add_subdirectory(${UNITTEST_PATH})
 
 # This should have already been downloaded by the FSFW Still include it to be
-# safe find_package(etl ${FSFW_ETL_LIB_MAJOR_VERSION} CONFIG QUIET) Not
-# installed, so use FetchContent to download and provide etl if(NOT etl_FOUND)
-message(
-  STATUS
-    "No ETL installation was found with find_package. Installing and providing "
-    "etl with FindPackage")
-include(FetchContent)
-FetchContent_Declare(
-  etl
-  GIT_REPOSITORY https://github.com/ETLCPP/etl
-  GIT_TAG ${FSFW_ETL_LIB_VERSION})
-list(APPEND FSFW_FETCH_CONTENT_TARGETS etl)
-# endif()
+# safe
+find_package(etl ${FSFW_ETL_LIB_MAJOR_VERSION} CONFIG QUIET)
+# Not installed, so use FetchContent to download and provide etl
+if(NOT etl_FOUND)
+  message(
+    STATUS
+      "No ETL installation was found with find_package. Installing and providing "
+      "etl with FindPackage")
+  include(FetchContent)
+  FetchContent_Declare(
+    etl
+    GIT_REPOSITORY https://github.com/ETLCPP/etl
+    GIT_TAG ${FSFW_ETL_LIB_VERSION})
+  list(APPEND FSFW_FETCH_CONTENT_TARGETS etl)
+endif()
 
 # Use same Catch2 version as framework
 if(NOT (TGT_BSP MATCHES "arm/te0720-1cfa")
@@ -482,16 +440,15 @@ endif()
 # ##############################################################################
 
 # Add libraries
-target_link_libraries(${LIB_EIVE_MISSION} PUBLIC ${LIB_FSFW_NAME}
-                                                 ${LIB_OS_NAME})
+target_link_libraries(${LIB_EIVE_MISSION}
+                      PUBLIC ${LIB_FSFW_NAME} ${LIB_LWGPS_NAME} ${LIB_OS_NAME})
 
 target_link_libraries(${LIB_DUMMIES} PUBLIC ${LIB_FSFW_NAME} ${LIB_JSON_NAME})
 
 target_link_libraries(${OBSW_NAME} PRIVATE ${LIB_EIVE_MISSION} ${LIB_DUMMIES})
 
 if(TGT_BSP MATCHES "arm/q7s")
-  target_link_libraries(${LIB_EIVE_MISSION} PUBLIC ${LIB_GPS} ${LIB_ARCSEC}
-                                                   ${LIB_GOMSPACE_CLIENTS})
+  target_link_libraries(${LIB_EIVE_MISSION} PUBLIC ${LIB_GPS} ${LIB_ARCSEC})
 endif()
 
 target_link_libraries(${UNITTEST_NAME} PRIVATE Catch2 ${LIB_EIVE_MISSION}
@@ -501,6 +458,10 @@ if(TGT_BSP MATCHES "arm/egse")
   target_link_libraries(${OBSW_NAME} PRIVATE ${LIB_ARCSEC})
 endif()
 
+if(ADD_CSP_LIB)
+  target_link_libraries(${OBSW_NAME} PRIVATE ${LIB_CSP_NAME})
+endif()
+
 if(EIVE_ADD_ETL_LIB)
   target_link_libraries(${LIB_EIVE_MISSION} PUBLIC ${LIB_ETL_TARGET})
 endif()
@@ -561,3 +522,6 @@ add_custom_command(
   POST_BUILD
   COMMAND ${CMAKE_SIZE} ${OBSW_BIN_NAME}${FILE_SUFFIX}
   COMMENT ${POST_BUILD_COMMENT})
+
+include(BuildType)
+set_build_type()

README.md

@@ -18,7 +18,6 @@
 11. [Q7S OBC](#q7s)
 12. [Static Code Analysis](#static-code-analysis)
 13. [Eclipse](#eclipse)
-14. [CLion](#clion)
 14. [Running the OBSW on a Raspberry Pi](#rpi)
 15. [Running OBSW on EGSE](#egse)
 16. [Manually preparing sysroots to compile gpsd](#gpsd)
@@ -96,7 +95,9 @@ When using Windows, run theses steps in MSYS2.
 2. Update all the submodules
 
    ```sh
-   git submodule update --init
+   git submodule init
+   git submodule sync
+   git submodule update
    ```
 
 3. Ensure that the cross-compiler is working with `arm-linux-gnueabihf-gcc --version` and that
@@ -151,78 +152,6 @@ When using Windows, run theses steps in MSYS2.
    cmake --build . -j
    ```
 
-## Preparing and executing an OBSW update
-
-A OBSW update consists of a `xz` compressed file `eive-sw-update.tar.xz`
-which contains the following two files:
-
-1. Stripped OBSW binary `eive-obsw-stripped`
-2. OBSW version text file with the name `obsw_version.txt`
-
-These files can be created manually:
-
-1. Build the release image inside `cmake-build-release-q7s`
-2. Switch into the build directory
-3. Run the following command to create the version file
-
-   ```sh
-   git describe --tags --always --exclude docker_* > obsw_version.txt
-   ```
-
-   You can also use the `create-version-file.sh` helper shell script
-   located in the `scripts` folder to do this.
-
-4. Set the Q7S user as the file owner for both files
-
-   ```sh
-   sudo chown root:root eive-obsw-stripped
-   sudo chown root:root obsw_version.txt
-   ```
-
-5. Run the following command to create the compressed archive
-
-   ```sh
-   tar -cJvf eive-sw-update.tar.xz eive-obsw-stripped obsw_version.txt
-   ```
-
-You can also use the helper script `create-sw-update.sh` inside the build folder
-after sourcing the `q7s-env.sh` helper script to perform all steps including
-a rebuild.
-
-After creating these files, they need to be transferred onto the Q7S
-to either the `/mnt/sd0/bin` or `/mnt/sd1/bin` folder if the OBSW update
-is performed from the SD card. It can also be transferred to the `/tmp` folder
-to perform the update from a temporary directory, which does not rely on any
-of the SD cards being on and mounted. However, all files in the temporary
-directory will be deleted if the Linux OS is rebooted for any reason.
-
-After both files are in place (this is checked by the OBSW), the example command
-sequence is used by the OBSW to write the OBSW update to the QSPI chip 0 and
-slot 0 using SD card 0:
-
-```sh
-tar -xJvf eive-update.tar.xz
-xsc_mount_copy 0 0
-cp eive-obsw-stripped /tmp/mntupdate-xdi-qspi0-nom-rootfs/usr/bin/eive-obsw
-cp obsw_update.txt /tmp/mntupdate-xdi-qspi0-nom-rootfs/usr/share/obsw_update.txt
-writeprotect 0 0 1
-```
-
-Some context information about the used commands:
-
-1. It mounts the target chip and copy combination into the `/tmp` folder
-   using the `xsc_mount_copy <chip> <copy>` utility. This also unlocks the
-   writeprotection for the chip. The mount point name inside `/tmp` depends
-   on which chip and copy is used
-
-   - Chip 0 Copy 0: `/tmp/mntupdate-xdi-qspi0-nom-rootfs`
-   - Chip 0 Copy 1: `/tmp/mntupdate-xdi-qspi0-gold-rootfs`
-   - Slot 1 Copy 0: `/tmp/mntupdate-xdi-qspi1-nom-rootfs`
-   - Slot 1 Copy 1: `/tmp/mntupdate-xdi-qspi1-gold-rootfs`
-
-2. Writing the file with a regular `cp <source> <target>` command
-3. Enabling the writeprotection using the `writeprotect <chip> <copy> 1` utility.
-
 ## Build for the Q7S target root filesystem with `yocto`
 
 The EIVE root filesystem will contain the EIVE OBSW and the Watchdog component.
@@ -289,7 +218,7 @@ helper scripts as well.
 4. Run build command by double clicking the created target or by right clicking
    the project folder and selecting Build Project.
 
-# <a id="host-commands"></a> Useful and Common Commands
+# <a id="host-commands"></a> Useful and Common Commands (Host)
 
 ## Build generation
 
@@ -318,11 +247,14 @@ cmake -DTGT_BSP=arm/q7s -DCMAKE_BUILD_TYPE=Release ..
 cmake --build . -j
 ```
 
-### Hosted OBSW
+### Q7S Watchdog
+
+The watchdog will be built along side the primary OBSW binary.
+
+### Hosted
 
 You can also use the FSFW OSAL `host` to build on Windows or for generic OSes.
-You can use the `clone-submodules-no-privlibs.sh` script to only clone the required (non-private)
-submodules required to build the hosted OBSW.
+Note: Currently this is not supported.
 
 ```sh
 mkdir cmake-build-debug && cd cmake-build-debug
@@ -330,21 +262,6 @@ cmake -DFSFW_OSAL=host -DCMAKE_BUILD_TYPE=Debug ..
 cmake --build . -j
 ```
 
-You can also use the `linux` OSAL:
-
-```sh
-mkdir cmake-build-debug && cd cmake-build-debug
-cmake -DFSFW_OSAL=linux -DCMAKE_BUILD_TYPE=Debug ..
-cmake --build . -j
-```
-
-Please note that some additional Linux setup might be necessary.
-You can find more information in the [Linux section of the FSFW example](https://egit.irs.uni-stuttgart.de/fsfw/fsfw-example-linux-mcu/src/branch/mueller/master/doc/README-linux.md#raising-message-queue-size-limit)
-
-### Q7S Watchdog
-
-The watchdog will be built along side the primary OBSW binary.
-
 ### Unittests
 
 To build the unittests, the corresponding target must be specified in the build command.
@@ -1066,29 +983,6 @@ Get fill count:
 xsc_scratch read | wc -c
 ```
 
-## Custom device names in Linux with the `udev` module
-
-You can assign custom device names using the Linux `udev` system.
-This works by specifying a rules file inside the `/etc/udev/rules.d` folder
-which creates a SYMLINK if certain device properties are true.
-
-Each rule is a new line inside a rules file.
-For example, the rule
-
-```txt
-SUBSYSTEM=="tty", ATTRS{interface}=="Dual RS232-HS", ATTRS{bInterfaceNumber}=="01", SYMLINK+="ploc_supv
-```
-
-Will create a symlink `/dev/ploc_supv` if a connected USB device has the
-same `interface` and `bInterfaceNumber` properties as shown above.
-
-You can list the properties for a given connected device using `udevadm`.
-For example, you can do this for a connected example device `/dev/ttyUSB0`
-by using
-
-```txt
-udevadm info -a /dev/ttyUSB0
-```
 
 ## Using `system` when debugging
 
@@ -1142,19 +1036,11 @@ cat /proc/tty/driver
 
 ## I2C
 
-Getting information about some I2C device
-
-```sh
+Getting information about I2C device
+````
 ls /sys/class/i2c-dev/i2c-0/device/device/driver
-```
-This shows the memory mapping of `/dev/i2c-0`.
-
-You can use the `i2cdetect` utility to scan for I2C devices.
-For example, to do this for bus 0 (`/dev/i2c-0`), you can use
-
-```sh
-i2cdetect -r -y 0
-```
+````
+This shows the memory mapping of /dev/i2c-0
 
 ## CAN
 
@@ -1230,22 +1116,6 @@ Finally, you can convert the generated `.xml` file to HTML with the following co
 cppcheck-htmlreport --file=report.xml --report-dir=cppcheck --source-dir=..
 ```
 
-# <a id="CLion"></a> CLion
-
-CLion is the recommended IDE for the development of the hosted version of EIVE.
-You can also set up CLion for cross-compilation of the primary OBSW.
-
-There is a shared `.idea/cmake.xml` file to get started with this.
-To make cross-compilation work, two special environment variables
-need to be set:
-
-- `ZYNQ_7020_ROOTFS` pointing to the root filesystem
-- `CROSS_COMPILE` pointing to the the full path of the cross-compiler
-  without the specific tool suffix. For example, if the the cross-compiler
-  tools are located at `/opt/q7s-gcc/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin`,
-  this variable would be set
-  to `/opt/q7s-gcc/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin/arm-linux-gnueabihf`
-
 # <a id="eclipse"></a> Eclipse
 
 When using Eclipse, there are two special build variables in the project properties

bsp_egse/InitMission.cpp

@@ -2,7 +2,7 @@
 
 #include <fsfw/objectmanager/ObjectManager.h>
 #include <fsfw/objectmanager/ObjectManagerIF.h>
-#include <fsfw/returnvalues/returnvalue.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
 #include <fsfw/serviceinterface/ServiceInterface.h>
 #include <fsfw/tasks/FixedTimeslotTaskIF.h>
 #include <fsfw/tasks/PeriodicTaskIF.h>
@@ -40,7 +40,7 @@ void initmission::initMission() {
 
 void initmission::initTasks() {
   TaskFactory* factory = TaskFactory::instance();
-  ReturnValue_t result = returnvalue::OK;
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
   if (factory == nullptr) {
     /* Should never happen ! */
     return;
@@ -55,28 +55,28 @@ void initmission::initTasks() {
   PeriodicTaskIF* tmtcDistributor = factory->createPeriodicTask(
       "DIST", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
   result = tmtcDistributor->addComponent(objects::CCSDS_PACKET_DISTRIBUTOR);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::error << "Object add component failed" << std::endl;
   }
   result = tmtcDistributor->addComponent(objects::PUS_PACKET_DISTRIBUTOR);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::error << "Object add component failed" << std::endl;
   }
   result = tmtcDistributor->addComponent(objects::TM_FUNNEL);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::error << "Object add component failed" << std::endl;
   }
 
   PeriodicTaskIF* tmtcBridgeTask = factory->createPeriodicTask(
       "TMTC_BRIDGE", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
   result = tmtcBridgeTask->addComponent(objects::TMTC_BRIDGE);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::error << "Add component TMTC Bridge failed" << std::endl;
   }
   PeriodicTaskIF* tmtcPollingTask = factory->createPeriodicTask(
       "TMTC_POLLING", 80, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
   result = tmtcPollingTask->addComponent(objects::TMTC_POLLING_TASK);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::error << "Add component TMTC Polling failed" << std::endl;
   }
 
@@ -88,7 +88,7 @@ void initmission::initTasks() {
   FixedTimeslotTaskIF* pst = factory->createFixedTimeslotTask(
       "STAR_TRACKER_PST", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 0.5, missedDeadlineFunc);
   result = pst::pstUart(pst);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::error << "InitMission::initTasks: Creating PST failed!" << std::endl;
   }
   pstTasks.push_back(pst);
@@ -96,7 +96,7 @@ void initmission::initTasks() {
   PeriodicTaskIF* strHelperTask = factory->createPeriodicTask(
       "STR_HELPER", 20, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
   result = strHelperTask->addComponent(objects::STR_HELPER);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("STR_HELPER", objects::STR_HELPER);
   }
   pstTasks.push_back(strHelperTask);
@@ -125,11 +125,11 @@ void initmission::initTasks() {
 void initmission::createPusTasks(TaskFactory& factory,
                                  TaskDeadlineMissedFunction missedDeadlineFunc,
                                  std::vector<PeriodicTaskIF*>& taskVec) {
-  ReturnValue_t result = returnvalue::OK;
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
   PeriodicTaskIF* pusVerification = factory.createPeriodicTask(
       "PUS_VERIF", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
   result = pusVerification->addComponent(objects::PUS_SERVICE_1_VERIFICATION);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::error << "Object add component failed" << std::endl;
   }
   taskVec.push_back(pusVerification);
@@ -137,11 +137,11 @@ void initmission::createPusTasks(TaskFactory& factory,
   PeriodicTaskIF* pusEvents = factory.createPeriodicTask(
       "PUS_EVENTS", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
   result = pusEvents->addComponent(objects::PUS_SERVICE_5_EVENT_REPORTING);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("PUS_EVENTS", objects::PUS_SERVICE_5_EVENT_REPORTING);
   }
   result = pusEvents->addComponent(objects::EVENT_MANAGER);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("PUS_MGMT", objects::EVENT_MANAGER);
   }
   taskVec.push_back(pusEvents);
@@ -149,11 +149,11 @@ void initmission::createPusTasks(TaskFactory& factory,
   PeriodicTaskIF* pusHighPrio = factory.createPeriodicTask(
       "PUS_HIGH_PRIO", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
   result = pusHighPrio->addComponent(objects::PUS_SERVICE_2_DEVICE_ACCESS);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("PUS2", objects::PUS_SERVICE_2_DEVICE_ACCESS);
   }
   result = pusHighPrio->addComponent(objects::PUS_SERVICE_9_TIME_MGMT);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("PUS9", objects::PUS_SERVICE_9_TIME_MGMT);
   }
   taskVec.push_back(pusHighPrio);
@@ -161,19 +161,19 @@ void initmission::createPusTasks(TaskFactory& factory,
   PeriodicTaskIF* pusMedPrio = factory.createPeriodicTask(
       "PUS_MED_PRIO", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.8, missedDeadlineFunc);
   result = pusMedPrio->addComponent(objects::PUS_SERVICE_8_FUNCTION_MGMT);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("PUS8", objects::PUS_SERVICE_8_FUNCTION_MGMT);
   }
   result = pusMedPrio->addComponent(objects::PUS_SERVICE_200_MODE_MGMT);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("PUS200", objects::PUS_SERVICE_200_MODE_MGMT);
   }
   result = pusMedPrio->addComponent(objects::PUS_SERVICE_20_PARAMETERS);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("PUS20", objects::PUS_SERVICE_20_PARAMETERS);
   }
   result = pusMedPrio->addComponent(objects::PUS_SERVICE_3_HOUSEKEEPING);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("PUS3", objects::PUS_SERVICE_3_HOUSEKEEPING);
   }
   taskVec.push_back(pusMedPrio);
@@ -181,11 +181,11 @@ void initmission::createPusTasks(TaskFactory& factory,
   PeriodicTaskIF* pusLowPrio = factory.createPeriodicTask(
       "PUS_LOW_PRIO", 30, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.6, missedDeadlineFunc);
   result = pusLowPrio->addComponent(objects::PUS_SERVICE_17_TEST);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("PUS17", objects::PUS_SERVICE_17_TEST);
   }
   result = pusLowPrio->addComponent(objects::INTERNAL_ERROR_REPORTER);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("INT_ERR_RPRT", objects::INTERNAL_ERROR_REPORTER);
   }
   taskVec.push_back(pusLowPrio);

bsp_egse/ObjectFactory.cpp

@@ -1,8 +1,8 @@
 #include "ObjectFactory.h"
 
 #include <devConf.h>
-#include <fsfw_hal/linux/serial/SerialComIF.h>
-#include <fsfw_hal/linux/serial/SerialCookie.h>
+#include <fsfw_hal/linux/uart/UartComIF.h>
+#include <fsfw_hal/linux/uart/UartCookie.h>
 
 #include "OBSWConfig.h"
 #include "busConf.h"
@@ -39,7 +39,7 @@ void ObjectFactory::produce(void* args) {
   UartCookie* starTrackerCookie =
       new UartCookie(objects::STAR_TRACKER, egse::STAR_TRACKER_UART, UartModes::NON_CANONICAL,
                      uart::STAR_TRACKER_BAUD, startracker::MAX_FRAME_SIZE * 2 + 2);
-  newSerialComIF(objects::UART_COM_IF);
+  new UartComIF(objects::UART_COM_IF);
   starTrackerCookie->setNoFixedSizeReply();
   StrHelper* strHelper = new StrHelper(objects::STR_HELPER);
   StarTrackerHandler* starTrackerHandler = new StarTrackerHandler(

bsp_hosted/CMakeLists.txt

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

bsp_hosted/Dockerfile

@@ -14,7 +14,7 @@ RUN set -ex; \
     rm -rf build-hosted; \
     mkdir build-hosted; \
     cd build-hosted; \
-    cmake -DCMAKE_BUILD_TYPE=Release -DOSAL_FSFW=host ..;
+    cmake -DCMAKE_BUILD_TYPE=Release -DOS_FSFW=linux ..;
 
 ENTRYPOINT ["cmake", "--build", "build-hosted"]
 CMD ["-j"]

bsp_hosted/InitMission.cpp

@@ -0,0 +1,195 @@
+#include "InitMission.h"
+
+#include <OBSWConfig.h>
+#include <bsp_hosted/fsfwconfig/pollingsequence/DummyPst.h>
+#include <fsfw/objectmanager/ObjectManager.h>
+#include <fsfw/objectmanager/ObjectManagerIF.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include <fsfw/serviceinterface/ServiceInterfaceStream.h>
+#include <fsfw/tasks/FixedTimeslotTaskIF.h>
+#include <fsfw/tasks/PeriodicTaskIF.h>
+#include <fsfw/tasks/TaskFactory.h>
+#include <mission/utility/InitMission.h>
+
+#include <iostream>
+
+#include "ObjectFactory.h"
+
+#ifdef LINUX
+ServiceInterfaceStream sif::debug("DEBUG");
+ServiceInterfaceStream sif::info("INFO");
+ServiceInterfaceStream sif::warning("WARNING");
+ServiceInterfaceStream sif::error("ERROR", false, false, true);
+#else
+ServiceInterfaceStream sif::debug("DEBUG", true);
+ServiceInterfaceStream sif::info("INFO", true);
+ServiceInterfaceStream sif::warning("WARNING", true);
+ServiceInterfaceStream sif::error("ERROR", true, false, true);
+#endif
+
+ObjectManagerIF* objectManager = nullptr;
+
+void initmission::initMission() {
+  sif::info << "Building global objects.." << std::endl;
+  /* Instantiate global object manager and also create all objects */
+  ObjectManager::instance()->setObjectFactoryFunction(ObjectFactory::produce, nullptr);
+  sif::info << "Initializing all objects.." << std::endl;
+  ObjectManager::instance()->initialize();
+
+  /* This function creates and starts all tasks */
+  initTasks();
+}
+
+void initmission::initTasks() {
+  TaskFactory* factory = TaskFactory::instance();
+  if (factory == nullptr) {
+    /* Should never happen ! */
+    return;
+  }
+#if OBSW_PRINT_MISSED_DEADLINES == 1
+  void (*missedDeadlineFunc)(void) = TaskFactory::printMissedDeadline;
+#else
+  void (*missedDeadlineFunc)(void) = nullptr;
+#endif
+
+  /* TMTC Distribution */
+  PeriodicTaskIF* tmTcDistributor = factory->createPeriodicTask(
+      "DIST", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
+  ReturnValue_t result = tmTcDistributor->addComponent(objects::CCSDS_PACKET_DISTRIBUTOR);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    sif::error << "Object add component failed" << std::endl;
+  }
+  result = tmTcDistributor->addComponent(objects::PUS_PACKET_DISTRIBUTOR);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    sif::error << "Object add component failed" << std::endl;
+  }
+  result = tmTcDistributor->addComponent(objects::TM_FUNNEL);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    sif::error << "Object add component failed" << std::endl;
+  }
+
+  /* UDP bridge */
+  PeriodicTaskIF* tmtcBridgeTask = factory->createPeriodicTask(
+      "TMTC_UNIX_BRIDGE", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
+  result = tmtcBridgeTask->addComponent(objects::TMTC_BRIDGE);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    sif::error << "Add component UDP Unix Bridge failed" << std::endl;
+  }
+  PeriodicTaskIF* tmtcPollingTask = factory->createPeriodicTask(
+      "UDP_POLLING", 80, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
+  result = tmtcPollingTask->addComponent(objects::TMTC_POLLING_TASK);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    sif::error << "Add component UDP Polling failed" << std::endl;
+  }
+
+  /* PUS Services */
+  PeriodicTaskIF* pusVerification = factory->createPeriodicTask(
+      "PUS_VERIF", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
+  result = pusVerification->addComponent(objects::PUS_SERVICE_1_VERIFICATION);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    sif::error << "Object add component failed" << std::endl;
+  }
+
+  PeriodicTaskIF* eventHandling = factory->createPeriodicTask(
+      "EVENTS", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
+  result = eventHandling->addComponent(objects::EVENT_MANAGER);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("EVENT_MNGR", objects::EVENT_MANAGER);
+  }
+  result = eventHandling->addComponent(objects::PUS_SERVICE_5_EVENT_REPORTING);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("PUS5", objects::PUS_SERVICE_5_EVENT_REPORTING);
+  }
+
+  PeriodicTaskIF* pusHighPrio = factory->createPeriodicTask(
+      "PUS_HIGH_PRIO", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
+  result = pusHighPrio->addComponent(objects::PUS_SERVICE_2_DEVICE_ACCESS);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("PUS2", objects::PUS_SERVICE_2_DEVICE_ACCESS);
+  }
+  result = pusHighPrio->addComponent(objects::PUS_SERVICE_9_TIME_MGMT);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("PUS9", objects::PUS_SERVICE_9_TIME_MGMT);
+  }
+  result = pusHighPrio->addComponent(objects::PUS_SERVICE_3_HOUSEKEEPING);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("PUS3", objects::PUS_SERVICE_3_HOUSEKEEPING);
+  }
+
+  PeriodicTaskIF* pusMedPrio = factory->createPeriodicTask(
+      "PUS_MED_PRIO", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.8, missedDeadlineFunc);
+  result = pusMedPrio->addComponent(objects::PUS_SERVICE_8_FUNCTION_MGMT);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("PUS8", objects::PUS_SERVICE_8_FUNCTION_MGMT);
+  }
+  result = pusMedPrio->addComponent(objects::PUS_SERVICE_200_MODE_MGMT);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("PUS200", objects::PUS_SERVICE_200_MODE_MGMT);
+  }
+  result = pusMedPrio->addComponent(objects::PUS_SERVICE_20_PARAMETERS);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("PUS20", objects::PUS_SERVICE_20_PARAMETERS);
+  }
+
+  PeriodicTaskIF* pusLowPrio = factory->createPeriodicTask(
+      "PUS_LOW_PRIO", 30, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.6, missedDeadlineFunc);
+  result = pusLowPrio->addComponent(objects::PUS_SERVICE_17_TEST);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("PUS17", objects::PUS_SERVICE_17_TEST);
+  }
+
+  PeriodicTaskIF* thermalTask = factory->createPeriodicTask(
+      "THERMAL_CTL_TASK", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, missedDeadlineFunc);
+  result = thermalTask->addComponent(objects::RTD_0_IC3_PLOC_HEATSPREADER);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("RTD_0_dummy", objects::RTD_0_IC3_PLOC_HEATSPREADER);
+  }
+  result = thermalTask->addComponent(objects::SUS_0_N_LOC_XFYFZM_PT_XF);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("SUS_0_dummy", objects::SUS_0_N_LOC_XFYFZM_PT_XF);
+  }
+
+  result = thermalTask->addComponent(objects::CORE_CONTROLLER);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("Core controller dummy", objects::CORE_CONTROLLER);
+  }
+
+  result = thermalTask->addComponent(objects::THERMAL_CONTROLLER);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("THERMAL_CONTROLLER", objects::THERMAL_CONTROLLER);
+  }
+
+  FixedTimeslotTaskIF* pstTask = factory->createFixedTimeslotTask(
+      "DUMMY_PST", 75, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 0.5, missedDeadlineFunc);
+  result = dummy_pst::pst(pstTask);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    sif::error << "Failed to add dummy pst to fixed timeslot task" << std::endl;
+  }
+
+#if OBSW_ADD_TEST_CODE == 1
+  result = testTask->addComponent(objects::TEST_TASK);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("TEST_TASK", objects::TEST_TASK);
+  }
+#endif /* OBSW_ADD_TEST_CODE == 1 */
+
+  sif::info << "Starting tasks.." << std::endl;
+  tmTcDistributor->startTask();
+  tmtcBridgeTask->startTask();
+  tmtcPollingTask->startTask();
+
+  pusVerification->startTask();
+  eventHandling->startTask();
+  pusHighPrio->startTask();
+  pusMedPrio->startTask();
+  pusLowPrio->startTask();
+
+  pstTask->startTask();
+  thermalTask->startTask();
+
+#if OBSW_ADD_TEST_CODE == 1
+  testTask->startTask();
+#endif /* OBSW_ADD_TEST_CODE == 1 */
+
+  sif::info << "Tasks started.." << std::endl;
+}

bsp_hosted/InitMission.h

@@ -0,0 +1,9 @@
+#ifndef BSP_LINUX_INITMISSION_H_
+#define BSP_LINUX_INITMISSION_H_
+
+namespace initmission {
+void initMission();
+void initTasks();
+};  // namespace initmission
+
+#endif /* BSP_LINUX_INITMISSION_H_ */

bsp_hosted/OBSWConfig.h.in

@@ -7,6 +7,7 @@
 #define FSFWCONFIG_OBSWCONFIG_H_
 
 #include "commonConfig.h"
+#include "OBSWVersion.h"
     
 /*******************************************************************/
 /** All of the following flags should be enabled for mission code  */
@@ -23,7 +24,6 @@
 #define OBSW_ADD_GPS_0                              0
 #define OBSW_ADD_GPS_1                              0
 #define OBSW_ADD_RW                                 0
-#define OBSW_DEBUG_TMP1075                          0
 #define OBSW_ADD_BPX_BATTERY_HANDLER                0
 #define OBSW_ADD_RTD_DEVICES                        0
 #define OBSW_ADD_PL_PCDU                            0
@@ -100,10 +100,6 @@
 /*******************************************************************/
 /** CMake Defines                                                  */
 /*******************************************************************/
-
-#define OBSW_ADD_TMTC_UDP_SERVER            1
-#define OBSW_ADD_TMTC_TCP_SERVER            1
-
 #cmakedefine EIVE_BUILD_GPSD_GPS_HANDLER
 
 #cmakedefine LIBGPS_VERSION_MAJOR @LIBGPS_VERSION_MAJOR@

bsp_hosted/ObjectFactory.cpp

@@ -1,107 +1,93 @@
 #include "ObjectFactory.h"
 
-#include <fsfw/power/DummyPowerSwitcher.h>
 #include <fsfw/tmtcservices/CommandingServiceBase.h>
 #include <fsfw/tmtcservices/PusServiceBase.h>
 #include <mission/controller/ThermalController.h>
 #include <mission/core/GenericFactory.h>
-#include <mission/tmtc/TmFunnelHandler.h>
+#include <mission/tmtc/TmFunnel.h>
 #include <objects/systemObjectList.h>
+#include <tmtc/apid.h>
+#include <tmtc/pusIds.h>
 
-#include "../mission/utility/DummySdCardManager.h"
 #include "OBSWConfig.h"
-#include "fsfw/platform.h"
 #include "fsfw_tests/integration/task/TestTask.h"
 
-#if OBSW_ADD_TMTC_UDP_SERVER == 1
+#if OBSW_USE_TMTC_TCP_BRIDGE == 0
 #include "fsfw/osal/common/UdpTcPollingTask.h"
 #include "fsfw/osal/common/UdpTmTcBridge.h"
-#endif
-#if OBSW_ADD_TMTC_TCP_SERVER == 1
+#else
 #include "fsfw/osal/common/TcpTmTcBridge.h"
 #include "fsfw/osal/common/TcpTmTcServer.h"
 #endif
 
+#include <fsfw/tmtcpacket/pus/tm.h>
+
 #if OBSW_ADD_TEST_CODE == 1
 #include <test/testtasks/TestTask.h>
 #endif
 
 #include <dummies/AcuDummy.h>
+#include <dummies/BpxDummy.h>
+#include <dummies/ComCookieDummy.h>
+#include <dummies/ComIFDummy.h>
 #include <dummies/CoreControllerDummy.h>
-
-#include "dummies/helpers.h"
-
-#ifdef PLATFORM_UNIX
-#include <fsfw_hal/linux/serial/SerialComIF.h>
-#include <fsfw_hal/linux/serial/SerialCookie.h>
-
-#include "devices/gpioIds.h"
-#include "fsfw_hal/linux/gpio/Gpio.h"
-#include "linux/devices/ploc/PlocMPSoCHandler.h"
-#include "linux/devices/ploc/PlocMPSoCHelper.h"
-#include "linux/devices/ploc/PlocSupervisorHandler.h"
-#include "linux/devices/ploc/PlocSupvUartMan.h"
-#include "test/gpio/DummyGpioIF.h"
-#endif
+#include <dummies/GyroAdisDummy.h>
+#include <dummies/GyroL3GD20Dummy.h>
+#include <dummies/ImtqDummy.h>
+#include <dummies/MgmLIS3MDLDummy.h>
+#include <dummies/P60DockDummy.h>
+#include <dummies/PduDummy.h>
+#include <dummies/PlPcduDummy.h>
+#include <dummies/RwDummy.h>
+#include <dummies/StarTrackerDummy.h>
+#include <dummies/SusDummy.h>
+#include <dummies/SyrlinksDummy.h>
+#include <dummies/TemperatureSensorsDummy.h>
 
 void Factory::setStaticFrameworkObjectIds() {
-  PusServiceBase::PUS_DISTRIBUTOR = objects::PUS_PACKET_DISTRIBUTOR;
-  PusServiceBase::PACKET_DESTINATION = objects::PUS_TM_FUNNEL;
+  PusServiceBase::packetSource = objects::PUS_PACKET_DISTRIBUTOR;
+  PusServiceBase::packetDestination = objects::TM_FUNNEL;
 
   CommandingServiceBase::defaultPacketSource = objects::PUS_PACKET_DISTRIBUTOR;
-  CommandingServiceBase::defaultPacketDestination = objects::PUS_TM_FUNNEL;
+  CommandingServiceBase::defaultPacketDestination = objects::TM_FUNNEL;
 
-  VerificationReporter::DEFAULT_RECEIVER = objects::PUS_SERVICE_1_VERIFICATION;
+  TmFunnel::downlinkDestination = objects::TMTC_BRIDGE;
+  // No storage object for now.
+  TmFunnel::storageDestination = objects::NO_OBJECT;
+
+  VerificationReporter::messageReceiver = objects::PUS_SERVICE_1_VERIFICATION;
+  TmPacketBase::timeStamperId = objects::TIME_STAMPER;
 }
 
 void ObjectFactory::produce(void* args) {
   Factory::setStaticFrameworkObjectIds();
-  PusTmFunnel* pusFunnel;
-  CfdpTmFunnel* cfdpFunnel;
-  StorageManagerIF* tmStore;
-  StorageManagerIF* ipcStore;
-  PersistentTmStores persistentStores;
-  auto sdcMan = new DummySdCardManager("/tmp");
-  ObjectFactory::produceGenericObjects(nullptr, &pusFunnel, &cfdpFunnel, *sdcMan, &ipcStore,
-                                       &tmStore, persistentStores);
+  ObjectFactory::produceGenericObjects();
 
-  auto* dummyGpioIF = new DummyGpioIF();
-  auto* dummySwitcher = new DummyPowerSwitcher(objects::PCDU_HANDLER, 18, 0);
-#ifdef PLATFORM_UNIX
-  new SerialComIF(objects::UART_COM_IF);
-#if OBSW_ADD_PLOC_MPSOC == 1
-  std::string mpscoDev = "";
-  auto mpsocCookie = new UartCookie(objects::PLOC_MPSOC_HANDLER, mpscoDev, uart::PLOC_MPSOC_BAUD,
-                                    mpsoc::MAX_REPLY_SIZE, UartModes::NON_CANONICAL);
-  mpsocCookie->setNoFixedSizeReply();
-  auto plocMpsocHelper = new PlocMPSoCHelper(objects::PLOC_MPSOC_HELPER);
-  new PlocMPSoCHandler(objects::PLOC_MPSOC_HANDLER, objects::UART_COM_IF, mpsocCookie,
-                       plocMpsocHelper, Gpio(gpioIds::ENABLE_MPSOC_UART, dummyGpioIF),
-                       objects::PLOC_SUPERVISOR_HANDLER);
-#endif /* OBSW_ADD_PLOC_MPSOC == 1 */
-#if OBSW_ADD_PLOC_SUPERVISOR == 1
-  std::string plocSupvString = "/dev/ploc_supv";
-  auto supervisorCookie =
-      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);
-#endif /* OBSW_ADD_PLOC_SUPERVISOR == 1 */
-#endif
+  new ComIFDummy(objects::DUMMY_COM_IF);
+  ComCookieDummy* comCookieDummy = new ComCookieDummy();
+  new BpxDummy(objects::BPX_BATT_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+  new CoreControllerDummy(objects::CORE_CONTROLLER);
+  new RwDummy(objects::RW1, objects::DUMMY_COM_IF, comCookieDummy);
+  new RwDummy(objects::RW2, objects::DUMMY_COM_IF, comCookieDummy);
+  new RwDummy(objects::RW3, objects::DUMMY_COM_IF, comCookieDummy);
+  new RwDummy(objects::RW4, objects::DUMMY_COM_IF, comCookieDummy);
+  new StarTrackerDummy(objects::STAR_TRACKER, objects::DUMMY_COM_IF, comCookieDummy);
+  new SyrlinksDummy(objects::SYRLINKS_HK_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+  new ImtqDummy(objects::IMTQ_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+  new AcuDummy(objects::ACU_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+  new PduDummy(objects::PDU1_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+  new PduDummy(objects::PDU2_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+  new P60DockDummy(objects::P60DOCK_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+  new GyroAdisDummy(objects::GYRO_0_ADIS_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+  new GyroL3GD20Dummy(objects::GYRO_1_L3G_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+  new GyroAdisDummy(objects::GYRO_2_ADIS_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+  new GyroL3GD20Dummy(objects::GYRO_3_L3G_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+  new MgmLIS3MDLDummy(objects::MGM_0_LIS3_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+  new MgmLIS3MDLDummy(objects::MGM_2_LIS3_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+  new PlPcduDummy(objects::PLPCDU_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+  new TemperatureSensorsDummy();
+  new SusDummy();
+  new ThermalController(objects::THERMAL_CONTROLLER, objects::NO_OBJECT);
 
-  dummy::DummyCfg cfg;
-  dummy::createDummies(cfg, *dummySwitcher, dummyGpioIF);
-
-  HeaterHandler* heaterHandler = nullptr;
-  // new ThermalController(objects::THERMAL_CONTROLLER);
-  ObjectFactory::createGenericHeaterComponents(*dummyGpioIF, *dummySwitcher, heaterHandler);
-  if (heaterHandler == nullptr) {
-    sif::error << "HeaterHandler could not be created" << std::endl;
-  } else {
-    ObjectFactory::createThermalController(*heaterHandler);
-  }
-  new TestTask(objects::TEST_TASK);
+  // new TestTask(objects::TEST_TASK);
 }

bsp_hosted/comIF/ArduinoComIF.cpp

@@ -129,7 +129,9 @@ ArduinoComIF::~ArduinoComIF() {
   CloseHandle(hCom);
 #endif
 }
-ReturnValue_t ArduinoComIF::initializeInterface(CookieIF *cookie) { return returnvalue::OK; }
+ReturnValue_t ArduinoComIF::initializeInterface(CookieIF *cookie) {
+  return HasReturnvaluesIF::RETURN_OK;
+}
 
 ReturnValue_t ArduinoComIF::sendMessage(CookieIF *cookie, const uint8_t *data, size_t len) {
   ArduinoCookie *arduinoCookie = dynamic_cast<ArduinoCookie *>(cookie);
@@ -140,10 +142,10 @@ ReturnValue_t ArduinoComIF::sendMessage(CookieIF *cookie, const uint8_t *data, s
   return sendMessage(arduinoCookie->command, arduinoCookie->address, data, len);
 }
 
-ReturnValue_t ArduinoComIF::getSendSuccess(CookieIF *cookie) { return returnvalue::OK; }
+ReturnValue_t ArduinoComIF::getSendSuccess(CookieIF *cookie) { return RETURN_OK; }
 
 ReturnValue_t ArduinoComIF::requestReceiveMessage(CookieIF *cookie, size_t requestLen) {
-  return returnvalue::OK;
+  return RETURN_OK;
 }
 
 ReturnValue_t ArduinoComIF::readReceivedMessage(CookieIF *cookie, uint8_t **buffer, size_t *size) {
@@ -156,7 +158,7 @@ ReturnValue_t ArduinoComIF::readReceivedMessage(CookieIF *cookie, uint8_t **buff
 
   *buffer = arduinoCookie->replyBuffer.data();
   *size = arduinoCookie->receivedDataLen;
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t ArduinoComIF::sendMessage(uint8_t command, uint8_t address, const uint8_t *data,
@@ -176,14 +178,14 @@ ReturnValue_t ArduinoComIF::sendMessage(uint8_t command, uint8_t address, const
 
   ReturnValue_t result =
       DleEncoder::encode(&command, 1, currentPosition, remainingLen, &encodedLen, false);
-  if (result != returnvalue::OK) {
+  if (result != RETURN_OK) {
     return result;
   }
   currentPosition += encodedLen;
   remainingLen -= encodedLen;  // DleEncoder will never return encodedLen > remainingLen
 
   result = DleEncoder::encode(&address, 1, currentPosition, remainingLen, &encodedLen, false);
-  if (result != returnvalue::OK) {
+  if (result != RETURN_OK) {
     return result;
   }
   currentPosition += encodedLen;
@@ -197,7 +199,7 @@ ReturnValue_t ArduinoComIF::sendMessage(uint8_t command, uint8_t address, const
 
   result =
       DleEncoder::encode(temporaryBuffer, 2, currentPosition, remainingLen, &encodedLen, false);
-  if (result != returnvalue::OK) {
+  if (result != RETURN_OK) {
     return result;
   }
   currentPosition += encodedLen;
@@ -205,7 +207,7 @@ ReturnValue_t ArduinoComIF::sendMessage(uint8_t command, uint8_t address, const
 
   // encoding the actual data
   result = DleEncoder::encode(data, dataLen, currentPosition, remainingLen, &encodedLen, false);
-  if (result != returnvalue::OK) {
+  if (result != RETURN_OK) {
     return result;
   }
   currentPosition += encodedLen;
@@ -222,7 +224,7 @@ ReturnValue_t ArduinoComIF::sendMessage(uint8_t command, uint8_t address, const
 
   result =
       DleEncoder::encode(temporaryBuffer, 2, currentPosition, remainingLen, &encodedLen, false);
-  if (result != returnvalue::OK) {
+  if (result != RETURN_OK) {
     return result;
   }
   currentPosition += encodedLen;
@@ -239,16 +241,16 @@ ReturnValue_t ArduinoComIF::sendMessage(uint8_t command, uint8_t address, const
   ssize_t writtenlen = ::write(serialPort, sendBuffer, encodedLen);
   if (writtenlen < 0) {
     // we could try to find out what happened...
-    return returnvalue::FAILED;
+    return RETURN_FAILED;
   }
   if (writtenlen != encodedLen) {
     // the OS failed us, we do not try to block until everything is written, as
     // we can not block the whole system here
-    return returnvalue::FAILED;
+    return RETURN_FAILED;
   }
-  return returnvalue::OK;
+  return RETURN_OK;
 #elif WIN32
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 #endif
 }
 
@@ -295,7 +297,7 @@ void ArduinoComIF::handleSerialPortRx() {
                                             packet, sizeof(packet), &packetLen);
 
   size_t toDelete = firstSTXinRawData;
-  if (result == returnvalue::OK) {
+  if (result == HasReturnvaluesIF::RETURN_OK) {
     handlePacket(packet, packetLen);
 
     // after handling the packet, we can delete it from the raw stream,

bsp_hosted/comIF/ArduinoComIF.h

@@ -5,7 +5,7 @@
 #include <fsfw/container/SimpleRingBuffer.h>
 #include <fsfw/devicehandlers/DeviceCommunicationIF.h>
 #include <fsfw/objectmanager/SystemObject.h>
-#include <fsfw/returnvalues/returnvalue.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
 
 #include <cstdint>
 #include <map>

bsp_hosted/fsfwconfig/FSFWConfig.h.in

@@ -50,8 +50,6 @@
 //! If set to 1 the binary needs "cap_sys_nice=eip" privileges to run
 #define FSFW_USE_REALTIME_FOR_LINUX 0
 
-#define FSFW_UDP_SEND_WIRETAPPING_ENABLED 0
-
 namespace fsfwconfig {
 
 //! Default timestamp size. The default timestamp will be an seven byte CDC short timestamp.

bsp_hosted/fsfwconfig/OBSWConfig.h.in

@@ -16,7 +16,7 @@
 debugging. */
 #define OBSW_VEBOSE_LEVEL                           1
 
-#define OBSW_ADD_CCSDS_IP_CORES                     0
+#define OBSW_USE_CCSDS_IP_CORE                      0
 // Set to 1 if all telemetry should be sent to the PTME IP Core
 #define OBSW_TM_TO_PTME                             0
 // Set to 1 if telecommands are received via the PDEC IP Core

bsp_hosted/fsfwconfig/events/subsystemIdRanges.h

@@ -1,9 +1,9 @@
 #ifndef CONFIG_EVENTS_SUBSYSTEMIDRANGES_H_
 #define CONFIG_EVENTS_SUBSYSTEMIDRANGES_H_
 
-#include <cstdint>
+#include <common/config/commonSubsystemIds.h>
 
-#include "eive/eventSubsystemIds.h"
+#include <cstdint>
 
 /**
  * These IDs are part of the ID for an event thrown by a subsystem.

bsp_hosted/fsfwconfig/events/translateEvents.cpp

@@ -1,7 +1,7 @@
 /**
- * @brief    Auto-generated event translation file. Contains 277 translations.
+ * @brief    Auto-generated event translation file. Contains 83 translations.
  * @details
- * Generated on: 2023-03-14 17:08:41
+ * Generated on: 2021-05-17 19:49:55
  */
 #include "translateEvents.h"
 
@@ -34,12 +34,11 @@ const char *DEVICE_UNREQUESTED_REPLY_STRING = "DEVICE_UNREQUESTED_REPLY";
 const char *INVALID_DEVICE_COMMAND_STRING = "INVALID_DEVICE_COMMAND";
 const char *MONITORING_LIMIT_EXCEEDED_STRING = "MONITORING_LIMIT_EXCEEDED";
 const char *MONITORING_AMBIGUOUS_STRING = "MONITORING_AMBIGUOUS";
-const char *DEVICE_WANTS_HARD_REBOOT_STRING = "DEVICE_WANTS_HARD_REBOOT";
-const char *SWITCH_WENT_OFF_STRING = "SWITCH_WENT_OFF";
 const char *FUSE_CURRENT_HIGH_STRING = "FUSE_CURRENT_HIGH";
 const char *FUSE_WENT_OFF_STRING = "FUSE_WENT_OFF";
 const char *POWER_ABOVE_HIGH_LIMIT_STRING = "POWER_ABOVE_HIGH_LIMIT";
 const char *POWER_BELOW_LOW_LIMIT_STRING = "POWER_BELOW_LOW_LIMIT";
+const char *SWITCH_WENT_OFF_STRING = "SWITCH_WENT_OFF";
 const char *HEATER_ON_STRING = "HEATER_ON";
 const char *HEATER_OFF_STRING = "HEATER_OFF";
 const char *HEATER_TIMEOUT_STRING = "HEATER_TIMEOUT";
@@ -60,6 +59,7 @@ const char *MONITOR_CHANGED_STATE_STRING = "MONITOR_CHANGED_STATE";
 const char *VALUE_BELOW_LOW_LIMIT_STRING = "VALUE_BELOW_LOW_LIMIT";
 const char *VALUE_ABOVE_HIGH_LIMIT_STRING = "VALUE_ABOVE_HIGH_LIMIT";
 const char *VALUE_OUT_OF_RANGE_STRING = "VALUE_OUT_OF_RANGE";
+const char *SWITCHING_TM_FAILED_STRING = "SWITCHING_TM_FAILED";
 const char *CHANGING_MODE_STRING = "CHANGING_MODE";
 const char *MODE_INFO_STRING = "MODE_INFO";
 const char *FALLBACK_FAILED_STRING = "FALLBACK_FAILED";
@@ -75,211 +75,22 @@ const char *OVERWRITING_HEALTH_STRING = "OVERWRITING_HEALTH";
 const char *TRYING_RECOVERY_STRING = "TRYING_RECOVERY";
 const char *RECOVERY_STEP_STRING = "RECOVERY_STEP";
 const char *RECOVERY_DONE_STRING = "RECOVERY_DONE";
-const char *HANDLE_PACKET_FAILED_STRING = "HANDLE_PACKET_FAILED";
 const char *RF_AVAILABLE_STRING = "RF_AVAILABLE";
 const char *RF_LOST_STRING = "RF_LOST";
 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_SET_FAILURE_STRING = "CLOCK_SET_FAILURE";
-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";
-const char *STORE_ERROR_STRING = "STORE_ERROR";
-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 *SAFE_RATE_VIOLATION_STRING = "SAFE_RATE_VIOLATION";
-const char *SAFE_RATE_RECOVERY_STRING = "SAFE_RATE_RECOVERY";
-const char *MULTIPLE_RW_INVALID_STRING = "MULTIPLE_RW_INVALID";
-const char *MEKF_INVALID_INFO_STRING = "MEKF_INVALID_INFO";
-const char *MEKF_INVALID_MODE_VIOLATION_STRING = "MEKF_INVALID_MODE_VIOLATION";
-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 *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";
-const char *HEATER_WENT_OFF_STRING = "HEATER_WENT_OFF";
-const char *SWITCH_ALREADY_ON_STRING = "SWITCH_ALREADY_ON";
-const char *SWITCH_ALREADY_OFF_STRING = "SWITCH_ALREADY_OFF";
-const char *MAIN_SWITCH_TIMEOUT_STRING = "MAIN_SWITCH_TIMEOUT";
-const char *FAULTY_HEATER_WAS_ON_STRING = "FAULTY_HEATER_WAS_ON";
-const char *BURN_PHASE_START_STRING = "BURN_PHASE_START";
-const char *BURN_PHASE_DONE_STRING = "BURN_PHASE_DONE";
-const char *MAIN_SWITCH_ON_TIMEOUT_STRING = "MAIN_SWITCH_ON_TIMEOUT";
-const char *MAIN_SWITCH_OFF_TIMEOUT_STRING = "MAIN_SWITCH_OFF_TIMEOUT";
-const char *DEPL_SA1_GPIO_SWTICH_ON_FAILED_STRING = "DEPL_SA1_GPIO_SWTICH_ON_FAILED";
-const char *DEPL_SA2_GPIO_SWTICH_ON_FAILED_STRING = "DEPL_SA2_GPIO_SWTICH_ON_FAILED";
-const char *DEPL_SA1_GPIO_SWTICH_OFF_FAILED_STRING = "DEPL_SA1_GPIO_SWTICH_OFF_FAILED";
-const char *DEPL_SA2_GPIO_SWTICH_OFF_FAILED_STRING = "DEPL_SA2_GPIO_SWTICH_OFF_FAILED";
-const char *AUTONOMOUS_DEPLOYMENT_COMPLETED_STRING = "AUTONOMOUS_DEPLOYMENT_COMPLETED";
 const char *MEMORY_READ_RPT_CRC_FAILURE_STRING = "MEMORY_READ_RPT_CRC_FAILURE";
 const char *ACK_FAILURE_STRING = "ACK_FAILURE";
 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 *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";
-const char *SELF_TEST_PWM_FAILURE_STRING = "SELF_TEST_PWM_FAILURE";
-const char *SELF_TEST_TC_FAILURE_STRING = "SELF_TEST_TC_FAILURE";
-const char *SELF_TEST_MTM_RANGE_FAILURE_STRING = "SELF_TEST_MTM_RANGE_FAILURE";
-const char *SELF_TEST_COIL_CURRENT_FAILURE_STRING = "SELF_TEST_COIL_CURRENT_FAILURE";
-const char *INVALID_ERROR_BYTE_STRING = "INVALID_ERROR_BYTE";
-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 *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";
-const char *SUPV_ACK_FAILURE_STRING = "SUPV_ACK_FAILURE";
-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 *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";
-const char *MRAM_DUMP_FAILED_STRING = "MRAM_DUMP_FAILED";
-const char *MRAM_DUMP_FINISHED_STRING = "MRAM_DUMP_FINISHED";
-const char *INVALID_TC_FRAME_STRING = "INVALID_TC_FRAME";
-const char *INVALID_FAR_STRING = "INVALID_FAR";
-const char *CARRIER_LOCK_STRING = "CARRIER_LOCK";
-const char *BIT_LOCK_PDEC_STRING = "BIT_LOCK_PDEC";
-const char *LOST_CARRIER_LOCK_PDEC_STRING = "LOST_CARRIER_LOCK_PDEC";
-const char *LOST_BIT_LOCK_PDEC_STRING = "LOST_BIT_LOCK_PDEC";
-const char *TOO_MANY_IRQS_STRING = "TOO_MANY_IRQS";
-const char *POLL_SYSCALL_ERROR_PDEC_STRING = "POLL_SYSCALL_ERROR_PDEC";
-const char *WRITE_SYSCALL_ERROR_PDEC_STRING = "WRITE_SYSCALL_ERROR_PDEC";
-const char *PDEC_RESET_FAILED_STRING = "PDEC_RESET_FAILED";
-const char *OPEN_IRQ_FILE_FAILED_STRING = "OPEN_IRQ_FILE_FAILED";
-const char *IMAGE_UPLOAD_FAILED_STRING = "IMAGE_UPLOAD_FAILED";
-const char *IMAGE_DOWNLOAD_FAILED_STRING = "IMAGE_DOWNLOAD_FAILED";
-const char *IMAGE_UPLOAD_SUCCESSFUL_STRING = "IMAGE_UPLOAD_SUCCESSFUL";
-const char *IMAGE_DOWNLOAD_SUCCESSFUL_STRING = "IMAGE_DOWNLOAD_SUCCESSFUL";
-const char *FLASH_WRITE_SUCCESSFUL_STRING = "FLASH_WRITE_SUCCESSFUL";
-const char *FLASH_READ_SUCCESSFUL_STRING = "FLASH_READ_SUCCESSFUL";
-const char *FLASH_READ_FAILED_STRING = "FLASH_READ_FAILED";
-const char *FIRMWARE_UPDATE_SUCCESSFUL_STRING = "FIRMWARE_UPDATE_SUCCESSFUL";
-const char *FIRMWARE_UPDATE_FAILED_STRING = "FIRMWARE_UPDATE_FAILED";
-const char *STR_HELPER_READING_REPLY_FAILED_STRING = "STR_HELPER_READING_REPLY_FAILED";
-const char *STR_HELPER_COM_ERROR_STRING = "STR_HELPER_COM_ERROR";
-const char *STR_HELPER_NO_REPLY_STRING = "STR_HELPER_NO_REPLY";
-const char *STR_HELPER_DEC_ERROR_STRING = "STR_HELPER_DEC_ERROR";
-const char *POSITION_MISMATCH_STRING = "POSITION_MISMATCH";
-const char *STR_HELPER_FILE_NOT_EXISTS_STRING = "STR_HELPER_FILE_NOT_EXISTS";
-const char *STR_HELPER_SENDING_PACKET_FAILED_STRING = "STR_HELPER_SENDING_PACKET_FAILED";
-const char *STR_HELPER_REQUESTING_MSG_FAILED_STRING = "STR_HELPER_REQUESTING_MSG_FAILED";
-const char *MPSOC_FLASH_WRITE_FAILED_STRING = "MPSOC_FLASH_WRITE_FAILED";
-const char *MPSOC_FLASH_WRITE_SUCCESSFUL_STRING = "MPSOC_FLASH_WRITE_SUCCESSFUL";
-const char *MPSOC_SENDING_COMMAND_FAILED_STRING = "MPSOC_SENDING_COMMAND_FAILED";
-const char *MPSOC_HELPER_REQUESTING_REPLY_FAILED_STRING = "MPSOC_HELPER_REQUESTING_REPLY_FAILED";
-const char *MPSOC_HELPER_READING_REPLY_FAILED_STRING = "MPSOC_HELPER_READING_REPLY_FAILED";
-const char *MPSOC_MISSING_ACK_STRING = "MPSOC_MISSING_ACK";
-const char *MPSOC_MISSING_EXE_STRING = "MPSOC_MISSING_EXE";
-const char *MPSOC_ACK_FAILURE_REPORT_STRING = "MPSOC_ACK_FAILURE_REPORT";
-const char *MPSOC_EXE_FAILURE_REPORT_STRING = "MPSOC_EXE_FAILURE_REPORT";
-const char *MPSOC_ACK_INVALID_APID_STRING = "MPSOC_ACK_INVALID_APID";
-const char *MPSOC_EXE_INVALID_APID_STRING = "MPSOC_EXE_INVALID_APID";
-const char *MPSOC_HELPER_SEQ_CNT_MISMATCH_STRING = "MPSOC_HELPER_SEQ_CNT_MISMATCH";
-const char *MPSOC_TM_SIZE_ERROR_STRING = "MPSOC_TM_SIZE_ERROR";
-const char *MPSOC_TM_CRC_MISSMATCH_STRING = "MPSOC_TM_CRC_MISSMATCH";
-const char *TRANSITION_BACK_TO_OFF_STRING = "TRANSITION_BACK_TO_OFF";
-const char *NEG_V_OUT_OF_BOUNDS_STRING = "NEG_V_OUT_OF_BOUNDS";
-const char *U_DRO_OUT_OF_BOUNDS_STRING = "U_DRO_OUT_OF_BOUNDS";
-const char *I_DRO_OUT_OF_BOUNDS_STRING = "I_DRO_OUT_OF_BOUNDS";
-const char *U_X8_OUT_OF_BOUNDS_STRING = "U_X8_OUT_OF_BOUNDS";
-const char *I_X8_OUT_OF_BOUNDS_STRING = "I_X8_OUT_OF_BOUNDS";
-const char *U_TX_OUT_OF_BOUNDS_STRING = "U_TX_OUT_OF_BOUNDS";
-const char *I_TX_OUT_OF_BOUNDS_STRING = "I_TX_OUT_OF_BOUNDS";
-const char *U_MPA_OUT_OF_BOUNDS_STRING = "U_MPA_OUT_OF_BOUNDS";
-const char *I_MPA_OUT_OF_BOUNDS_STRING = "I_MPA_OUT_OF_BOUNDS";
-const char *U_HPA_OUT_OF_BOUNDS_STRING = "U_HPA_OUT_OF_BOUNDS";
-const char *I_HPA_OUT_OF_BOUNDS_STRING = "I_HPA_OUT_OF_BOUNDS";
-const char *TRANSITION_OTHER_SIDE_FAILED_STRING = "TRANSITION_OTHER_SIDE_FAILED";
-const char *NOT_ENOUGH_DEVICES_DUAL_MODE_STRING = "NOT_ENOUGH_DEVICES_DUAL_MODE";
-const char *POWER_STATE_MACHINE_TIMEOUT_STRING = "POWER_STATE_MACHINE_TIMEOUT";
-const char *SIDE_SWITCH_TRANSITION_NOT_ALLOWED_STRING = "SIDE_SWITCH_TRANSITION_NOT_ALLOWED";
-const char *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 *P60_BOOT_COUNT_STRING = "P60_BOOT_COUNT";
-const char *BATT_MODE_STRING = "BATT_MODE";
-const char *BATT_MODE_CHANGED_STRING = "BATT_MODE_CHANGED";
-const char *SUPV_UPDATE_FAILED_STRING = "SUPV_UPDATE_FAILED";
-const char *SUPV_UPDATE_SUCCESSFUL_STRING = "SUPV_UPDATE_SUCCESSFUL";
-const char *SUPV_CONTINUE_UPDATE_FAILED_STRING = "SUPV_CONTINUE_UPDATE_FAILED";
-const char *SUPV_CONTINUE_UPDATE_SUCCESSFUL_STRING = "SUPV_CONTINUE_UPDATE_SUCCESSFUL";
-const char *TERMINATED_UPDATE_PROCEDURE_STRING = "TERMINATED_UPDATE_PROCEDURE";
-const char *SUPV_EVENT_BUFFER_REQUEST_SUCCESSFUL_STRING = "SUPV_EVENT_BUFFER_REQUEST_SUCCESSFUL";
-const char *SUPV_EVENT_BUFFER_REQUEST_FAILED_STRING = "SUPV_EVENT_BUFFER_REQUEST_FAILED";
-const char *SUPV_EVENT_BUFFER_REQUEST_TERMINATED_STRING = "SUPV_EVENT_BUFFER_REQUEST_TERMINATED";
-const char *SUPV_MEM_CHECK_OK_STRING = "SUPV_MEM_CHECK_OK";
-const char *SUPV_MEM_CHECK_FAIL_STRING = "SUPV_MEM_CHECK_FAIL";
-const char *SUPV_SENDING_COMMAND_FAILED_STRING = "SUPV_SENDING_COMMAND_FAILED";
-const char *SUPV_HELPER_REQUESTING_REPLY_FAILED_STRING = "SUPV_HELPER_REQUESTING_REPLY_FAILED";
-const char *SUPV_HELPER_READING_REPLY_FAILED_STRING = "SUPV_HELPER_READING_REPLY_FAILED";
-const char *SUPV_MISSING_ACK_STRING = "SUPV_MISSING_ACK";
-const char *SUPV_MISSING_EXE_STRING = "SUPV_MISSING_EXE";
-const char *SUPV_ACK_FAILURE_REPORT_STRING = "SUPV_ACK_FAILURE_REPORT";
-const char *SUPV_EXE_FAILURE_REPORT_STRING = "SUPV_EXE_FAILURE_REPORT";
-const char *SUPV_ACK_INVALID_APID_STRING = "SUPV_ACK_INVALID_APID";
-const char *SUPV_EXE_INVALID_APID_STRING = "SUPV_EXE_INVALID_APID";
-const char *ACK_RECEPTION_FAILURE_STRING = "ACK_RECEPTION_FAILURE";
-const char *EXE_RECEPTION_FAILURE_STRING = "EXE_RECEPTION_FAILURE";
-const char *WRITE_MEMORY_FAILED_STRING = "WRITE_MEMORY_FAILED";
-const char *SUPV_REPLY_SIZE_MISSMATCH_STRING = "SUPV_REPLY_SIZE_MISSMATCH";
-const char *SUPV_REPLY_CRC_MISSMATCH_STRING = "SUPV_REPLY_CRC_MISSMATCH";
-const char *SUPV_UPDATE_PROGRESS_STRING = "SUPV_UPDATE_PROGRESS";
-const char *HDLC_FRAME_REMOVAL_ERROR_STRING = "HDLC_FRAME_REMOVAL_ERROR";
-const char *HDLC_CRC_ERROR_STRING = "HDLC_CRC_ERROR";
-const char *TX_ON_STRING = "TX_ON";
-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 *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";
-const char *WRITE_CONFIGFILE_FAILED_STRING = "WRITE_CONFIGFILE_FAILED";
-const char *READ_CONFIGFILE_FAILED_STRING = "READ_CONFIGFILE_FAILED";
-const char *ALLOC_FAILURE_STRING = "ALLOC_FAILURE";
-const char *REBOOT_SW_STRING = "REBOOT_SW";
-const char *REBOOT_MECHANISM_TRIGGERED_STRING = "REBOOT_MECHANISM_TRIGGERED";
-const char *REBOOT_HW_STRING = "REBOOT_HW";
-const char *NO_SD_CARD_ACTIVE_STRING = "NO_SD_CARD_ACTIVE";
-const char *VERSION_INFO_STRING = "VERSION_INFO";
-const char *CURRENT_IMAGE_INFO_STRING = "CURRENT_IMAGE_INFO";
-const char *REBOOT_COUNTER_STRING = "REBOOT_COUNTER";
-const char *INDIVIDUAL_BOOT_COUNTS_STRING = "INDIVIDUAL_BOOT_COUNTS";
-const char *NO_VALID_SENSOR_TEMPERATURE_STRING = "NO_VALID_SENSOR_TEMPERATURE";
-const char *NO_HEALTHY_HEATER_AVAILABLE_STRING = "NO_HEALTHY_HEATER_AVAILABLE";
-const char *SYRLINKS_OVERHEATING_STRING = "SYRLINKS_OVERHEATING";
-const char *PLOC_OVERHEATING_STRING = "PLOC_OVERHEATING";
-const char *OBC_OVERHEATING_STRING = "OBC_OVERHEATING";
-const char *HPA_OVERHEATING_STRING = "HPA_OVERHEATING";
-const char *PLPCDU_OVERHEATING_STRING = "PLPCDU_OVERHEATING";
-const char *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";
-const char *FILE_TOO_LARGE_STRING = "FILE_TOO_LARGE";
-const char *BUSY_DUMPING_EVENT_STRING = "BUSY_DUMPING_EVENT";
-const char *DUMP_WAS_CANCELLED_STRING = "DUMP_WAS_CANCELLED";
-const char *DUMP_OK_STORE_DONE_STRING = "DUMP_OK_STORE_DONE";
-const char *DUMP_NOK_STORE_DONE_STRING = "DUMP_NOK_STORE_DONE";
-const char *DUMP_MISC_STORE_DONE_STRING = "DUMP_MISC_STORE_DONE";
-const char *DUMP_HK_STORE_DONE_STRING = "DUMP_HK_STORE_DONE";
-const char *DUMP_CFDP_STORE_DONE_STRING = "DUMP_CFDP_STORE_DONE";
+const char *CRC_FAILURE_EVENT_STRING = "CRC_FAILURE_EVENT";
 
 const char *translateEvents(Event event) {
-  switch ((event & 0xFFFF)) {
+  switch ((event & 0xffff)) {
     case (2200):
       return STORE_SEND_WRITE_FAILED_STRING;
     case (2201):
@@ -338,18 +149,16 @@ const char *translateEvents(Event event) {
       return MONITORING_LIMIT_EXCEEDED_STRING;
     case (2810):
       return MONITORING_AMBIGUOUS_STRING;
-    case (2811):
-      return DEVICE_WANTS_HARD_REBOOT_STRING;
+    case (4201):
+      return FUSE_CURRENT_HIGH_STRING;
+    case (4202):
+      return FUSE_WENT_OFF_STRING;
+    case (4204):
+      return POWER_ABOVE_HIGH_LIMIT_STRING;
+    case (4205):
+      return POWER_BELOW_LOW_LIMIT_STRING;
     case (4300):
       return SWITCH_WENT_OFF_STRING;
-    case (4301):
-      return FUSE_CURRENT_HIGH_STRING;
-    case (4302):
-      return FUSE_WENT_OFF_STRING;
-    case (4304):
-      return POWER_ABOVE_HIGH_LIMIT_STRING;
-    case (4305):
-      return POWER_BELOW_LOW_LIMIT_STRING;
     case (5000):
       return HEATER_ON_STRING;
     case (5001):
@@ -390,6 +199,8 @@ const char *translateEvents(Event event) {
       return VALUE_ABOVE_HIGH_LIMIT_STRING;
     case (7204):
       return VALUE_OUT_OF_RANGE_STRING;
+    case (7301):
+      return SWITCHING_TM_FAILED_STRING;
     case (7400):
       return CHANGING_MODE_STRING;
     case (7401):
@@ -420,8 +231,6 @@ const char *translateEvents(Event event) {
       return RECOVERY_STEP_STRING;
     case (7512):
       return RECOVERY_DONE_STRING;
-    case (7600):
-      return HANDLE_PACKET_FAILED_STRING;
     case (7900):
       return RF_AVAILABLE_STRING;
     case (7901):
@@ -435,395 +244,19 @@ const char *translateEvents(Event event) {
     case (8900):
       return CLOCK_SET_STRING;
     case (8901):
-      return CLOCK_DUMP_STRING;
-    case (8902):
       return CLOCK_SET_FAILURE_STRING;
-    case (9100):
-      return TC_DELETION_FAILED_STRING;
     case (9700):
       return TEST_STRING;
     case (10600):
       return CHANGE_OF_SETUP_PARAMETER_STRING;
-    case (10800):
-      return STORE_ERROR_STRING;
-    case (10801):
-      return MSG_QUEUE_ERROR_STRING;
-    case (10802):
-      return SERIALIZATION_ERROR_STRING;
-    case (10803):
-      return FILESTORE_ERROR_STRING;
-    case (10804):
-      return FILENAME_TOO_LARGE_ERROR_STRING;
-    case (11200):
-      return SAFE_RATE_VIOLATION_STRING;
-    case (11201):
-      return SAFE_RATE_RECOVERY_STRING;
-    case (11202):
-      return MULTIPLE_RW_INVALID_STRING;
-    case (11203):
-      return MEKF_INVALID_INFO_STRING;
-    case (11204):
-      return MEKF_INVALID_MODE_VIOLATION_STRING;
-    case (11300):
-      return SWITCH_CMD_SENT_STRING;
-    case (11301):
-      return SWITCH_HAS_CHANGED_STRING;
-    case (11302):
-      return SWITCHING_Q7S_DENIED_STRING;
-    case (11303):
-      return FDIR_REACTION_IGNORED_STRING;
-    case (11400):
-      return GPIO_PULL_HIGH_FAILED_STRING;
-    case (11401):
-      return GPIO_PULL_LOW_FAILED_STRING;
-    case (11402):
-      return HEATER_WENT_ON_STRING;
-    case (11403):
-      return HEATER_WENT_OFF_STRING;
-    case (11404):
-      return SWITCH_ALREADY_ON_STRING;
-    case (11405):
-      return SWITCH_ALREADY_OFF_STRING;
-    case (11406):
-      return MAIN_SWITCH_TIMEOUT_STRING;
-    case (11407):
-      return FAULTY_HEATER_WAS_ON_STRING;
-    case (11500):
-      return BURN_PHASE_START_STRING;
-    case (11501):
-      return BURN_PHASE_DONE_STRING;
-    case (11502):
-      return MAIN_SWITCH_ON_TIMEOUT_STRING;
-    case (11503):
-      return MAIN_SWITCH_OFF_TIMEOUT_STRING;
-    case (11504):
-      return DEPL_SA1_GPIO_SWTICH_ON_FAILED_STRING;
-    case (11505):
-      return DEPL_SA2_GPIO_SWTICH_ON_FAILED_STRING;
-    case (11506):
-      return DEPL_SA1_GPIO_SWTICH_OFF_FAILED_STRING;
-    case (11507):
-      return DEPL_SA2_GPIO_SWTICH_OFF_FAILED_STRING;
-    case (11508):
-      return AUTONOMOUS_DEPLOYMENT_COMPLETED_STRING;
-    case (11601):
+    case (11101):
       return MEMORY_READ_RPT_CRC_FAILURE_STRING;
-    case (11602):
+    case (11102):
       return ACK_FAILURE_STRING;
-    case (11603):
+    case (11103):
       return EXE_FAILURE_STRING;
-    case (11604):
-      return MPSOC_HANDLER_CRC_FAILURE_STRING;
-    case (11605):
-      return MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH_STRING;
-    case (11606):
-      return MPSOC_SHUTDOWN_FAILED_STRING;
-    case (11701):
-      return SELF_TEST_I2C_FAILURE_STRING;
-    case (11702):
-      return SELF_TEST_SPI_FAILURE_STRING;
-    case (11703):
-      return SELF_TEST_ADC_FAILURE_STRING;
-    case (11704):
-      return SELF_TEST_PWM_FAILURE_STRING;
-    case (11705):
-      return SELF_TEST_TC_FAILURE_STRING;
-    case (11706):
-      return SELF_TEST_MTM_RANGE_FAILURE_STRING;
-    case (11707):
-      return SELF_TEST_COIL_CURRENT_FAILURE_STRING;
-    case (11708):
-      return INVALID_ERROR_BYTE_STRING;
-    case (11801):
-      return ERROR_STATE_STRING;
-    case (11802):
-      return RESET_OCCURED_STRING;
-    case (11901):
-      return BOOTING_FIRMWARE_FAILED_EVENT_STRING;
-    case (11902):
-      return BOOTING_BOOTLOADER_FAILED_EVENT_STRING;
-    case (12001):
-      return SUPV_MEMORY_READ_RPT_CRC_FAILURE_STRING;
-    case (12002):
-      return SUPV_UNKNOWN_TM_STRING;
-    case (12003):
-      return SUPV_UNINIMPLEMENTED_TM_STRING;
-    case (12004):
-      return SUPV_ACK_FAILURE_STRING;
-    case (12005):
-      return SUPV_EXE_FAILURE_STRING;
-    case (12006):
-      return SUPV_CRC_FAILURE_EVENT_STRING;
-    case (12007):
-      return SUPV_HELPER_EXECUTING_STRING;
-    case (12008):
-      return SUPV_MPSOC_SHUTDOWN_BUILD_FAILED_STRING;
-    case (12100):
-      return SANITIZATION_FAILED_STRING;
-    case (12101):
-      return MOUNTED_SD_CARD_STRING;
-    case (12300):
-      return SEND_MRAM_DUMP_FAILED_STRING;
-    case (12301):
-      return MRAM_DUMP_FAILED_STRING;
-    case (12302):
-      return MRAM_DUMP_FINISHED_STRING;
-    case (12401):
-      return INVALID_TC_FRAME_STRING;
-    case (12402):
-      return INVALID_FAR_STRING;
-    case (12403):
-      return CARRIER_LOCK_STRING;
-    case (12404):
-      return BIT_LOCK_PDEC_STRING;
-    case (12405):
-      return LOST_CARRIER_LOCK_PDEC_STRING;
-    case (12406):
-      return LOST_BIT_LOCK_PDEC_STRING;
-    case (12407):
-      return TOO_MANY_IRQS_STRING;
-    case (12408):
-      return POLL_SYSCALL_ERROR_PDEC_STRING;
-    case (12409):
-      return WRITE_SYSCALL_ERROR_PDEC_STRING;
-    case (12410):
-      return PDEC_RESET_FAILED_STRING;
-    case (12411):
-      return OPEN_IRQ_FILE_FAILED_STRING;
-    case (12500):
-      return IMAGE_UPLOAD_FAILED_STRING;
-    case (12501):
-      return IMAGE_DOWNLOAD_FAILED_STRING;
-    case (12502):
-      return IMAGE_UPLOAD_SUCCESSFUL_STRING;
-    case (12503):
-      return IMAGE_DOWNLOAD_SUCCESSFUL_STRING;
-    case (12504):
-      return FLASH_WRITE_SUCCESSFUL_STRING;
-    case (12505):
-      return FLASH_READ_SUCCESSFUL_STRING;
-    case (12506):
-      return FLASH_READ_FAILED_STRING;
-    case (12507):
-      return FIRMWARE_UPDATE_SUCCESSFUL_STRING;
-    case (12508):
-      return FIRMWARE_UPDATE_FAILED_STRING;
-    case (12509):
-      return STR_HELPER_READING_REPLY_FAILED_STRING;
-    case (12510):
-      return STR_HELPER_COM_ERROR_STRING;
-    case (12511):
-      return STR_HELPER_NO_REPLY_STRING;
-    case (12512):
-      return STR_HELPER_DEC_ERROR_STRING;
-    case (12513):
-      return POSITION_MISMATCH_STRING;
-    case (12514):
-      return STR_HELPER_FILE_NOT_EXISTS_STRING;
-    case (12515):
-      return STR_HELPER_SENDING_PACKET_FAILED_STRING;
-    case (12516):
-      return STR_HELPER_REQUESTING_MSG_FAILED_STRING;
-    case (12600):
-      return MPSOC_FLASH_WRITE_FAILED_STRING;
-    case (12601):
-      return MPSOC_FLASH_WRITE_SUCCESSFUL_STRING;
-    case (12602):
-      return MPSOC_SENDING_COMMAND_FAILED_STRING;
-    case (12603):
-      return MPSOC_HELPER_REQUESTING_REPLY_FAILED_STRING;
-    case (12604):
-      return MPSOC_HELPER_READING_REPLY_FAILED_STRING;
-    case (12605):
-      return MPSOC_MISSING_ACK_STRING;
-    case (12606):
-      return MPSOC_MISSING_EXE_STRING;
-    case (12607):
-      return MPSOC_ACK_FAILURE_REPORT_STRING;
-    case (12608):
-      return MPSOC_EXE_FAILURE_REPORT_STRING;
-    case (12609):
-      return MPSOC_ACK_INVALID_APID_STRING;
-    case (12610):
-      return MPSOC_EXE_INVALID_APID_STRING;
-    case (12611):
-      return MPSOC_HELPER_SEQ_CNT_MISMATCH_STRING;
-    case (12612):
-      return MPSOC_TM_SIZE_ERROR_STRING;
-    case (12613):
-      return MPSOC_TM_CRC_MISSMATCH_STRING;
-    case (12700):
-      return TRANSITION_BACK_TO_OFF_STRING;
-    case (12701):
-      return NEG_V_OUT_OF_BOUNDS_STRING;
-    case (12702):
-      return U_DRO_OUT_OF_BOUNDS_STRING;
-    case (12703):
-      return I_DRO_OUT_OF_BOUNDS_STRING;
-    case (12704):
-      return U_X8_OUT_OF_BOUNDS_STRING;
-    case (12705):
-      return I_X8_OUT_OF_BOUNDS_STRING;
-    case (12706):
-      return U_TX_OUT_OF_BOUNDS_STRING;
-    case (12707):
-      return I_TX_OUT_OF_BOUNDS_STRING;
-    case (12708):
-      return U_MPA_OUT_OF_BOUNDS_STRING;
-    case (12709):
-      return I_MPA_OUT_OF_BOUNDS_STRING;
-    case (12710):
-      return U_HPA_OUT_OF_BOUNDS_STRING;
-    case (12711):
-      return I_HPA_OUT_OF_BOUNDS_STRING;
-    case (12800):
-      return TRANSITION_OTHER_SIDE_FAILED_STRING;
-    case (12801):
-      return NOT_ENOUGH_DEVICES_DUAL_MODE_STRING;
-    case (12802):
-      return POWER_STATE_MACHINE_TIMEOUT_STRING;
-    case (12803):
-      return SIDE_SWITCH_TRANSITION_NOT_ALLOWED_STRING;
-    case (13000):
-      return CHILDREN_LOST_MODE_STRING;
-    case (13100):
-      return GPS_FIX_CHANGE_STRING;
-    case (13101):
-      return CANT_GET_FIX_STRING;
-    case (13200):
-      return P60_BOOT_COUNT_STRING;
-    case (13201):
-      return BATT_MODE_STRING;
-    case (13202):
-      return BATT_MODE_CHANGED_STRING;
-    case (13600):
-      return SUPV_UPDATE_FAILED_STRING;
-    case (13601):
-      return SUPV_UPDATE_SUCCESSFUL_STRING;
-    case (13602):
-      return SUPV_CONTINUE_UPDATE_FAILED_STRING;
-    case (13603):
-      return SUPV_CONTINUE_UPDATE_SUCCESSFUL_STRING;
-    case (13604):
-      return TERMINATED_UPDATE_PROCEDURE_STRING;
-    case (13605):
-      return SUPV_EVENT_BUFFER_REQUEST_SUCCESSFUL_STRING;
-    case (13606):
-      return SUPV_EVENT_BUFFER_REQUEST_FAILED_STRING;
-    case (13607):
-      return SUPV_EVENT_BUFFER_REQUEST_TERMINATED_STRING;
-    case (13608):
-      return SUPV_MEM_CHECK_OK_STRING;
-    case (13609):
-      return SUPV_MEM_CHECK_FAIL_STRING;
-    case (13616):
-      return SUPV_SENDING_COMMAND_FAILED_STRING;
-    case (13617):
-      return SUPV_HELPER_REQUESTING_REPLY_FAILED_STRING;
-    case (13618):
-      return SUPV_HELPER_READING_REPLY_FAILED_STRING;
-    case (13619):
-      return SUPV_MISSING_ACK_STRING;
-    case (13620):
-      return SUPV_MISSING_EXE_STRING;
-    case (13621):
-      return SUPV_ACK_FAILURE_REPORT_STRING;
-    case (13622):
-      return SUPV_EXE_FAILURE_REPORT_STRING;
-    case (13623):
-      return SUPV_ACK_INVALID_APID_STRING;
-    case (13624):
-      return SUPV_EXE_INVALID_APID_STRING;
-    case (13625):
-      return ACK_RECEPTION_FAILURE_STRING;
-    case (13626):
-      return EXE_RECEPTION_FAILURE_STRING;
-    case (13627):
-      return WRITE_MEMORY_FAILED_STRING;
-    case (13628):
-      return SUPV_REPLY_SIZE_MISSMATCH_STRING;
-    case (13629):
-      return SUPV_REPLY_CRC_MISSMATCH_STRING;
-    case (13630):
-      return SUPV_UPDATE_PROGRESS_STRING;
-    case (13631):
-      return HDLC_FRAME_REMOVAL_ERROR_STRING;
-    case (13632):
-      return HDLC_CRC_ERROR_STRING;
-    case (13701):
-      return TX_ON_STRING;
-    case (13702):
-      return TX_OFF_STRING;
-    case (13800):
-      return MISSING_PACKET_STRING;
-    case (13801):
-      return EXPERIMENT_TIMEDOUT_STRING;
-    case (13802):
-      return MULTI_PACKET_COMMAND_DONE_STRING;
-    case (13901):
-      return SET_CONFIGFILEVALUE_FAILED_STRING;
-    case (13902):
-      return GET_CONFIGFILEVALUE_FAILED_STRING;
-    case (13903):
-      return INSERT_CONFIGFILEVALUE_FAILED_STRING;
-    case (13904):
-      return WRITE_CONFIGFILE_FAILED_STRING;
-    case (13905):
-      return READ_CONFIGFILE_FAILED_STRING;
-    case (14000):
-      return ALLOC_FAILURE_STRING;
-    case (14001):
-      return REBOOT_SW_STRING;
-    case (14002):
-      return REBOOT_MECHANISM_TRIGGERED_STRING;
-    case (14003):
-      return REBOOT_HW_STRING;
-    case (14004):
-      return NO_SD_CARD_ACTIVE_STRING;
-    case (14005):
-      return VERSION_INFO_STRING;
-    case (14006):
-      return CURRENT_IMAGE_INFO_STRING;
-    case (14007):
-      return REBOOT_COUNTER_STRING;
-    case (14008):
-      return INDIVIDUAL_BOOT_COUNTS_STRING;
-    case (14100):
-      return NO_VALID_SENSOR_TEMPERATURE_STRING;
-    case (14101):
-      return NO_HEALTHY_HEATER_AVAILABLE_STRING;
-    case (14102):
-      return SYRLINKS_OVERHEATING_STRING;
-    case (14103):
-      return PLOC_OVERHEATING_STRING;
-    case (14104):
-      return OBC_OVERHEATING_STRING;
-    case (14105):
-      return HPA_OVERHEATING_STRING;
-    case (14106):
-      return PLPCDU_OVERHEATING_STRING;
-    case (14201):
-      return TX_TIMER_EXPIRED_STRING;
-    case (14202):
-      return BIT_LOCK_TX_ON_STRING;
-    case (14300):
-      return POSSIBLE_FILE_CORRUPTION_STRING;
-    case (14301):
-      return FILE_TOO_LARGE_STRING;
-    case (14302):
-      return BUSY_DUMPING_EVENT_STRING;
-    case (14303):
-      return DUMP_WAS_CANCELLED_STRING;
-    case (14305):
-      return DUMP_OK_STORE_DONE_STRING;
-    case (14306):
-      return DUMP_NOK_STORE_DONE_STRING;
-    case (14307):
-      return DUMP_MISC_STORE_DONE_STRING;
-    case (14308):
-      return DUMP_HK_STORE_DONE_STRING;
-    case (14309):
-      return DUMP_CFDP_STORE_DONE_STRING;
+    case (11104):
+      return CRC_FAILURE_EVENT_STRING;
     default:
       return "UNKNOWN_EVENT";
   }

bsp_hosted/fsfwconfig/events/translateEvents.h

@@ -1,8 +1,8 @@
 #ifndef FSFWCONFIG_EVENTS_TRANSLATEEVENTS_H_
 #define FSFWCONFIG_EVENTS_TRANSLATEEVENTS_H_
 
-#include "fsfw/events/Event.h"
+#include <fsfw/events/Event.h>
 
-const char *translateEvents(Event event);
+const char* translateEvents(Event event);
 
 #endif /* FSFWCONFIG_EVENTS_TRANSLATEEVENTS_H_ */

bsp_hosted/fsfwconfig/objects/systemObjectList.h

@@ -1,9 +1,9 @@
 #ifndef HOSTED_CONFIG_OBJECTS_SYSTEMOBJECTLIST_H_
 #define HOSTED_CONFIG_OBJECTS_SYSTEMOBJECTLIST_H_
 
-#include <cstdint>
+#include <commonObjects.h>
 
-#include "eive/objects.h"
+#include <cstdint>
 
 // The objects will be instantiated in the ID order
 namespace objects {
@@ -16,6 +16,8 @@ enum sourceObjects : uint32_t {
   PUS_SERVICE_23 = 0x51002300,
   PUS_SERVICE_201 = 0x51020100,
 
+  TM_FUNNEL = 0x52000002,
+
   /* Test Task */
 
   TEST_TASK = 0x42694269,
@@ -24,7 +26,7 @@ enum sourceObjects : uint32_t {
   /* 0x49 ('I') for Communication Interfaces **/
   ARDUINO_COM_IF = 0x49000001,
 
-  DUMMY_COM_IF = 0x49000002,
+  DUMMY_COM_IF = 0x49000002
 };
 }
 

bsp_hosted/fsfwconfig/objects/translateObjects.cpp

@@ -1,116 +1,23 @@
 /**
- * @brief  Auto-generated object translation file.
+ * @brief	Auto-generated object translation file.
  * @details
- * Contains 169 translations.
- * Generated on: 2023-03-14 17:08:41
+ * Contains 31 translations.
+ * Generated on: 2021-05-17 19:12:49
  */
 #include "translateObjects.h"
 
+#include "systemObjectList.h"
+
 const char *TEST_TASK_STRING = "TEST_TASK";
-const char *ACS_CONTROLLER_STRING = "ACS_CONTROLLER";
-const char *CORE_CONTROLLER_STRING = "CORE_CONTROLLER";
-const char *GLOBAL_JSON_CFG_STRING = "GLOBAL_JSON_CFG";
-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";
-const char *GYRO_0_ADIS_HANDLER_STRING = "GYRO_0_ADIS_HANDLER";
-const char *SUS_0_N_LOC_XFYFZM_PT_XF_STRING = "SUS_0_N_LOC_XFYFZM_PT_XF";
-const char *SUS_1_N_LOC_XBYFZM_PT_XB_STRING = "SUS_1_N_LOC_XBYFZM_PT_XB";
-const char *SUS_2_N_LOC_XFYBZB_PT_YB_STRING = "SUS_2_N_LOC_XFYBZB_PT_YB";
-const char *SUS_3_N_LOC_XFYBZF_PT_YF_STRING = "SUS_3_N_LOC_XFYBZF_PT_YF";
-const char *SUS_4_N_LOC_XMYFZF_PT_ZF_STRING = "SUS_4_N_LOC_XMYFZF_PT_ZF";
-const char *SUS_5_N_LOC_XFYMZB_PT_ZB_STRING = "SUS_5_N_LOC_XFYMZB_PT_ZB";
-const char *SUS_6_R_LOC_XFYBZM_PT_XF_STRING = "SUS_6_R_LOC_XFYBZM_PT_XF";
-const char *SUS_7_R_LOC_XBYBZM_PT_XB_STRING = "SUS_7_R_LOC_XBYBZM_PT_XB";
-const char *SUS_8_R_LOC_XBYBZB_PT_YB_STRING = "SUS_8_R_LOC_XBYBZB_PT_YB";
-const char *SUS_9_R_LOC_XBYBZB_PT_YF_STRING = "SUS_9_R_LOC_XBYBZB_PT_YF";
-const char *SUS_10_N_LOC_XMYBZF_PT_ZF_STRING = "SUS_10_N_LOC_XMYBZF_PT_ZF";
-const char *SUS_11_R_LOC_XBYMZB_PT_ZB_STRING = "SUS_11_R_LOC_XBYMZB_PT_ZB";
-const char *RW1_STRING = "RW1";
-const char *MGM_1_RM3100_HANDLER_STRING = "MGM_1_RM3100_HANDLER";
-const char *GYRO_1_L3G_HANDLER_STRING = "GYRO_1_L3G_HANDLER";
-const char *RW2_STRING = "RW2";
-const char *MGM_2_LIS3_HANDLER_STRING = "MGM_2_LIS3_HANDLER";
-const char *GYRO_2_ADIS_HANDLER_STRING = "GYRO_2_ADIS_HANDLER";
-const char *RW3_STRING = "RW3";
-const char *MGM_3_RM3100_HANDLER_STRING = "MGM_3_RM3100_HANDLER";
-const char *GYRO_3_L3G_HANDLER_STRING = "GYRO_3_L3G_HANDLER";
-const char *RW4_STRING = "RW4";
-const char *STAR_TRACKER_STRING = "STAR_TRACKER";
-const char *GPS_CONTROLLER_STRING = "GPS_CONTROLLER";
-const char *IMTQ_POLLING_STRING = "IMTQ_POLLING";
-const char *IMTQ_HANDLER_STRING = "IMTQ_HANDLER";
-const char *PCDU_HANDLER_STRING = "PCDU_HANDLER";
-const char *P60DOCK_HANDLER_STRING = "P60DOCK_HANDLER";
-const char *PDU1_HANDLER_STRING = "PDU1_HANDLER";
-const char *PDU2_HANDLER_STRING = "PDU2_HANDLER";
-const char *ACU_HANDLER_STRING = "ACU_HANDLER";
-const char *BPX_BATT_HANDLER_STRING = "BPX_BATT_HANDLER";
-const char *PLPCDU_HANDLER_STRING = "PLPCDU_HANDLER";
-const char *RAD_SENSOR_STRING = "RAD_SENSOR";
-const char *PLOC_UPDATER_STRING = "PLOC_UPDATER";
-const char *PLOC_MEMORY_DUMPER_STRING = "PLOC_MEMORY_DUMPER";
-const char *STR_HELPER_STRING = "STR_HELPER";
-const char *PLOC_MPSOC_HELPER_STRING = "PLOC_MPSOC_HELPER";
-const char *AXI_PTME_CONFIG_STRING = "AXI_PTME_CONFIG";
-const char *PTME_CONFIG_STRING = "PTME_CONFIG";
-const char *PTME_VC0_LIVE_TM_STRING = "PTME_VC0_LIVE_TM";
-const char *PTME_VC1_LOG_TM_STRING = "PTME_VC1_LOG_TM";
-const char *PTME_VC2_HK_TM_STRING = "PTME_VC2_HK_TM";
-const char *PTME_VC3_CFDP_TM_STRING = "PTME_VC3_CFDP_TM";
-const char *PLOC_MPSOC_HANDLER_STRING = "PLOC_MPSOC_HANDLER";
-const char *PLOC_SUPERVISOR_HANDLER_STRING = "PLOC_SUPERVISOR_HANDLER";
-const char *PLOC_SUPERVISOR_HELPER_STRING = "PLOC_SUPERVISOR_HELPER";
-const char *SCEX_STRING = "SCEX";
-const char *SOLAR_ARRAY_DEPL_HANDLER_STRING = "SOLAR_ARRAY_DEPL_HANDLER";
-const char *HEATER_HANDLER_STRING = "HEATER_HANDLER";
-const char *TMP1075_HANDLER_TCS_0_STRING = "TMP1075_HANDLER_TCS_0";
-const char *TMP1075_HANDLER_TCS_1_STRING = "TMP1075_HANDLER_TCS_1";
-const char *TMP1075_HANDLER_PLPCDU_0_STRING = "TMP1075_HANDLER_PLPCDU_0";
-const char *TMP1075_HANDLER_PLPCDU_1_STRING = "TMP1075_HANDLER_PLPCDU_1";
-const char *TMP1075_HANDLER_IF_BOARD_STRING = "TMP1075_HANDLER_IF_BOARD";
-const char *RTD_0_IC3_PLOC_HEATSPREADER_STRING = "RTD_0_IC3_PLOC_HEATSPREADER";
-const char *RTD_1_IC4_PLOC_MISSIONBOARD_STRING = "RTD_1_IC4_PLOC_MISSIONBOARD";
-const char *RTD_2_IC5_4K_CAMERA_STRING = "RTD_2_IC5_4K_CAMERA";
-const char *RTD_3_IC6_DAC_HEATSPREADER_STRING = "RTD_3_IC6_DAC_HEATSPREADER";
-const char *RTD_4_IC7_STARTRACKER_STRING = "RTD_4_IC7_STARTRACKER";
-const char *RTD_5_IC8_RW1_MX_MY_STRING = "RTD_5_IC8_RW1_MX_MY";
-const char *RTD_6_IC9_DRO_STRING = "RTD_6_IC9_DRO";
-const char *RTD_7_IC10_SCEX_STRING = "RTD_7_IC10_SCEX";
-const char *RTD_8_IC11_X8_STRING = "RTD_8_IC11_X8";
-const char *RTD_9_IC12_HPA_STRING = "RTD_9_IC12_HPA";
-const char *RTD_10_IC13_PL_TX_STRING = "RTD_10_IC13_PL_TX";
-const char *RTD_11_IC14_MPA_STRING = "RTD_11_IC14_MPA";
-const char *RTD_12_IC15_ACU_STRING = "RTD_12_IC15_ACU";
-const char *RTD_13_IC16_PLPCDU_HEATSPREADER_STRING = "RTD_13_IC16_PLPCDU_HEATSPREADER";
-const char *RTD_14_IC17_TCS_BOARD_STRING = "RTD_14_IC17_TCS_BOARD";
-const char *RTD_15_IC18_IMTQ_STRING = "RTD_15_IC18_IMTQ";
-const char *SYRLINKS_HANDLER_STRING = "SYRLINKS_HANDLER";
 const char *ARDUINO_COM_IF_STRING = "ARDUINO_COM_IF";
-const char *DUMMY_COM_IF_STRING = "DUMMY_COM_IF";
-const char *SCEX_UART_READER_STRING = "SCEX_UART_READER";
-const char *UART_COM_IF_STRING = "UART_COM_IF";
-const char *ACS_BOARD_POLLING_TASK_STRING = "ACS_BOARD_POLLING_TASK";
-const char *RW_POLLING_TASK_STRING = "RW_POLLING_TASK";
-const char *SPI_RTD_COM_IF_STRING = "SPI_RTD_COM_IF";
-const char *SUS_POLLING_TASK_STRING = "SUS_POLLING_TASK";
-const char *CCSDS_PACKET_DISTRIBUTOR_STRING = "CCSDS_PACKET_DISTRIBUTOR";
-const char *PUS_PACKET_DISTRIBUTOR_STRING = "PUS_PACKET_DISTRIBUTOR";
-const char *TCP_TMTC_SERVER_STRING = "TCP_TMTC_SERVER";
-const char *UDP_TMTC_SERVER_STRING = "UDP_TMTC_SERVER";
-const char *TCP_TMTC_POLLING_TASK_STRING = "TCP_TMTC_POLLING_TASK";
-const char *UDP_TMTC_POLLING_TASK_STRING = "UDP_TMTC_POLLING_TASK";
-const char *FILE_SYSTEM_HANDLER_STRING = "FILE_SYSTEM_HANDLER";
-const char *SDC_MANAGER_STRING = "SDC_MANAGER";
-const char *PTME_STRING = "PTME";
-const char *PDEC_HANDLER_STRING = "PDEC_HANDLER";
-const char *CCSDS_HANDLER_STRING = "CCSDS_HANDLER";
 const char *PUS_SERVICE_3_STRING = "PUS_SERVICE_3";
 const char *PUS_SERVICE_5_STRING = "PUS_SERVICE_5";
 const char *PUS_SERVICE_6_STRING = "PUS_SERVICE_6";
 const char *PUS_SERVICE_8_STRING = "PUS_SERVICE_8";
 const char *PUS_SERVICE_23_STRING = "PUS_SERVICE_23";
 const char *PUS_SERVICE_201_STRING = "PUS_SERVICE_201";
+const char *TM_FUNNEL_STRING = "TM_FUNNEL";
 const char *FSFW_OBJECTS_START_STRING = "FSFW_OBJECTS_START";
 const char *PUS_SERVICE_1_VERIFICATION_STRING = "PUS_SERVICE_1_VERIFICATION";
 const char *PUS_SERVICE_2_DEVICE_ACCESS_STRING = "PUS_SERVICE_2_DEVICE_ACCESS";
@@ -118,13 +25,9 @@ const char *PUS_SERVICE_3_HOUSEKEEPING_STRING = "PUS_SERVICE_3_HOUSEKEEPING";
 const char *PUS_SERVICE_5_EVENT_REPORTING_STRING = "PUS_SERVICE_5_EVENT_REPORTING";
 const char *PUS_SERVICE_8_FUNCTION_MGMT_STRING = "PUS_SERVICE_8_FUNCTION_MGMT";
 const char *PUS_SERVICE_9_TIME_MGMT_STRING = "PUS_SERVICE_9_TIME_MGMT";
-const char *PUS_SERVICE_11_TC_SCHEDULER_STRING = "PUS_SERVICE_11_TC_SCHEDULER";
-const char *PUS_SERVICE_15_TM_STORAGE_STRING = "PUS_SERVICE_15_TM_STORAGE";
 const char *PUS_SERVICE_17_TEST_STRING = "PUS_SERVICE_17_TEST";
 const char *PUS_SERVICE_20_PARAMETERS_STRING = "PUS_SERVICE_20_PARAMETERS";
 const char *PUS_SERVICE_200_MODE_MGMT_STRING = "PUS_SERVICE_200_MODE_MGMT";
-const char *PUS_SERVICE_201_HEALTH_STRING = "PUS_SERVICE_201_HEALTH";
-const char *CFDP_PACKET_DISTRIBUTOR_STRING = "CFDP_PACKET_DISTRIBUTOR";
 const char *HEALTH_TABLE_STRING = "HEALTH_TABLE";
 const char *MODE_STORE_STRING = "MODE_STORE";
 const char *EVENT_MANAGER_STRING = "EVENT_MANAGER";
@@ -133,249 +36,19 @@ const char *TC_STORE_STRING = "TC_STORE";
 const char *TM_STORE_STRING = "TM_STORE";
 const char *IPC_STORE_STRING = "IPC_STORE";
 const char *TIME_STAMPER_STRING = "TIME_STAMPER";
-const char *VERIFICATION_REPORTER_STRING = "VERIFICATION_REPORTER";
 const char *FSFW_OBJECTS_END_STRING = "FSFW_OBJECTS_END";
-const char *HEATER_0_PLOC_PROC_BRD_STRING = "HEATER_0_PLOC_PROC_BRD";
-const char *HEATER_1_PCDU_BRD_STRING = "HEATER_1_PCDU_BRD";
-const char *HEATER_2_ACS_BRD_STRING = "HEATER_2_ACS_BRD";
-const char *HEATER_3_OBC_BRD_STRING = "HEATER_3_OBC_BRD";
-const char *HEATER_4_CAMERA_STRING = "HEATER_4_CAMERA";
-const char *HEATER_5_STR_STRING = "HEATER_5_STR";
-const char *HEATER_6_DRO_STRING = "HEATER_6_DRO";
-const char *HEATER_7_SYRLINKS_STRING = "HEATER_7_SYRLINKS";
-const char *ACS_BOARD_ASS_STRING = "ACS_BOARD_ASS";
-const char *SUS_BOARD_ASS_STRING = "SUS_BOARD_ASS";
-const char *TCS_BOARD_ASS_STRING = "TCS_BOARD_ASS";
-const char *RW_ASSY_STRING = "RW_ASSY";
-const char *CAM_SWITCHER_STRING = "CAM_SWITCHER";
-const char *SYRLINKS_ASSY_STRING = "SYRLINKS_ASSY";
-const char *IMTQ_ASSY_STRING = "IMTQ_ASSY";
-const char *STR_ASSY_STRING = "STR_ASSY";
-const char *TM_FUNNEL_STRING = "TM_FUNNEL";
-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 *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 *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";
-const char *HK_TM_STORE_STRING = "HK_TM_STORE";
-const char *CFDP_TM_STORE_STRING = "CFDP_TM_STORE";
-const char *LIVE_TM_TASK_STRING = "LIVE_TM_TASK";
-const char *LOG_STORE_AND_TM_TASK_STRING = "LOG_STORE_AND_TM_TASK";
-const char *HK_STORE_AND_TM_TASK_STRING = "HK_STORE_AND_TM_TASK";
-const char *CFDP_STORE_AND_TM_TASK_STRING = "CFDP_STORE_AND_TM_TASK";
-const char *DOWNLINK_RAM_STORE_STRING = "DOWNLINK_RAM_STORE";
-const char *CCSDS_IP_CORE_BRIDGE_STRING = "CCSDS_IP_CORE_BRIDGE";
-const char *THERMAL_TEMP_INSERTER_STRING = "THERMAL_TEMP_INSERTER";
 const char *DUMMY_INTERFACE_STRING = "DUMMY_INTERFACE";
+const char *THERMAL_CONTROLLER_STRING = "THERMAL_CONTROLLER";
 const char *NO_OBJECT_STRING = "NO_OBJECT";
 
 const char *translateObject(object_id_t object) {
   switch ((object & 0xFFFFFFFF)) {
     case 0x42694269:
       return TEST_TASK_STRING;
-    case 0x43000002:
-      return ACS_CONTROLLER_STRING;
-    case 0x43000003:
-      return CORE_CONTROLLER_STRING;
-    case 0x43000006:
-      return GLOBAL_JSON_CFG_STRING;
-    case 0x43400001:
-      return THERMAL_CONTROLLER_STRING;
-    case 0x44000001:
+    case 0x4400AFFE:
       return DUMMY_HANDLER_STRING;
-    case 0x44120006:
-      return MGM_0_LIS3_HANDLER_STRING;
-    case 0x44120010:
-      return GYRO_0_ADIS_HANDLER_STRING;
-    case 0x44120032:
-      return SUS_0_N_LOC_XFYFZM_PT_XF_STRING;
-    case 0x44120033:
-      return SUS_1_N_LOC_XBYFZM_PT_XB_STRING;
-    case 0x44120034:
-      return SUS_2_N_LOC_XFYBZB_PT_YB_STRING;
-    case 0x44120035:
-      return SUS_3_N_LOC_XFYBZF_PT_YF_STRING;
-    case 0x44120036:
-      return SUS_4_N_LOC_XMYFZF_PT_ZF_STRING;
-    case 0x44120037:
-      return SUS_5_N_LOC_XFYMZB_PT_ZB_STRING;
-    case 0x44120038:
-      return SUS_6_R_LOC_XFYBZM_PT_XF_STRING;
-    case 0x44120039:
-      return SUS_7_R_LOC_XBYBZM_PT_XB_STRING;
-    case 0x44120040:
-      return SUS_8_R_LOC_XBYBZB_PT_YB_STRING;
-    case 0x44120041:
-      return SUS_9_R_LOC_XBYBZB_PT_YF_STRING;
-    case 0x44120042:
-      return SUS_10_N_LOC_XMYBZF_PT_ZF_STRING;
-    case 0x44120043:
-      return SUS_11_R_LOC_XBYMZB_PT_ZB_STRING;
-    case 0x44120047:
-      return RW1_STRING;
-    case 0x44120107:
-      return MGM_1_RM3100_HANDLER_STRING;
-    case 0x44120111:
-      return GYRO_1_L3G_HANDLER_STRING;
-    case 0x44120148:
-      return RW2_STRING;
-    case 0x44120208:
-      return MGM_2_LIS3_HANDLER_STRING;
-    case 0x44120212:
-      return GYRO_2_ADIS_HANDLER_STRING;
-    case 0x44120249:
-      return RW3_STRING;
-    case 0x44120309:
-      return MGM_3_RM3100_HANDLER_STRING;
-    case 0x44120313:
-      return GYRO_3_L3G_HANDLER_STRING;
-    case 0x44120350:
-      return RW4_STRING;
-    case 0x44130001:
-      return STAR_TRACKER_STRING;
-    case 0x44130045:
-      return GPS_CONTROLLER_STRING;
-    case 0x44140013:
-      return IMTQ_POLLING_STRING;
-    case 0x44140014:
-      return IMTQ_HANDLER_STRING;
-    case 0x442000A1:
-      return PCDU_HANDLER_STRING;
-    case 0x44250000:
-      return P60DOCK_HANDLER_STRING;
-    case 0x44250001:
-      return PDU1_HANDLER_STRING;
-    case 0x44250002:
-      return PDU2_HANDLER_STRING;
-    case 0x44250003:
-      return ACU_HANDLER_STRING;
-    case 0x44260000:
-      return BPX_BATT_HANDLER_STRING;
-    case 0x44300000:
-      return PLPCDU_HANDLER_STRING;
-    case 0x443200A5:
-      return RAD_SENSOR_STRING;
-    case 0x44330000:
-      return PLOC_UPDATER_STRING;
-    case 0x44330001:
-      return PLOC_MEMORY_DUMPER_STRING;
-    case 0x44330002:
-      return STR_HELPER_STRING;
-    case 0x44330003:
-      return PLOC_MPSOC_HELPER_STRING;
-    case 0x44330004:
-      return AXI_PTME_CONFIG_STRING;
-    case 0x44330005:
-      return PTME_CONFIG_STRING;
-    case 0x44330006:
-      return PTME_VC0_LIVE_TM_STRING;
-    case 0x44330007:
-      return PTME_VC1_LOG_TM_STRING;
-    case 0x44330008:
-      return PTME_VC2_HK_TM_STRING;
-    case 0x44330009:
-      return PTME_VC3_CFDP_TM_STRING;
-    case 0x44330015:
-      return PLOC_MPSOC_HANDLER_STRING;
-    case 0x44330016:
-      return PLOC_SUPERVISOR_HANDLER_STRING;
-    case 0x44330017:
-      return PLOC_SUPERVISOR_HELPER_STRING;
-    case 0x44330032:
-      return SCEX_STRING;
-    case 0x444100A2:
-      return SOLAR_ARRAY_DEPL_HANDLER_STRING;
-    case 0x444100A4:
-      return HEATER_HANDLER_STRING;
-    case 0x44420004:
-      return TMP1075_HANDLER_TCS_0_STRING;
-    case 0x44420005:
-      return TMP1075_HANDLER_TCS_1_STRING;
-    case 0x44420006:
-      return TMP1075_HANDLER_PLPCDU_0_STRING;
-    case 0x44420007:
-      return TMP1075_HANDLER_PLPCDU_1_STRING;
-    case 0x44420008:
-      return TMP1075_HANDLER_IF_BOARD_STRING;
-    case 0x44420016:
-      return RTD_0_IC3_PLOC_HEATSPREADER_STRING;
-    case 0x44420017:
-      return RTD_1_IC4_PLOC_MISSIONBOARD_STRING;
-    case 0x44420018:
-      return RTD_2_IC5_4K_CAMERA_STRING;
-    case 0x44420019:
-      return RTD_3_IC6_DAC_HEATSPREADER_STRING;
-    case 0x44420020:
-      return RTD_4_IC7_STARTRACKER_STRING;
-    case 0x44420021:
-      return RTD_5_IC8_RW1_MX_MY_STRING;
-    case 0x44420022:
-      return RTD_6_IC9_DRO_STRING;
-    case 0x44420023:
-      return RTD_7_IC10_SCEX_STRING;
-    case 0x44420024:
-      return RTD_8_IC11_X8_STRING;
-    case 0x44420025:
-      return RTD_9_IC12_HPA_STRING;
-    case 0x44420026:
-      return RTD_10_IC13_PL_TX_STRING;
-    case 0x44420027:
-      return RTD_11_IC14_MPA_STRING;
-    case 0x44420028:
-      return RTD_12_IC15_ACU_STRING;
-    case 0x44420029:
-      return RTD_13_IC16_PLPCDU_HEATSPREADER_STRING;
-    case 0x44420030:
-      return RTD_14_IC17_TCS_BOARD_STRING;
-    case 0x44420031:
-      return RTD_15_IC18_IMTQ_STRING;
-    case 0x445300A3:
-      return SYRLINKS_HANDLER_STRING;
     case 0x49000001:
       return ARDUINO_COM_IF_STRING;
-    case 0x49000002:
-      return DUMMY_COM_IF_STRING;
-    case 0x49010006:
-      return SCEX_UART_READER_STRING;
-    case 0x49030003:
-      return UART_COM_IF_STRING;
-    case 0x49060004:
-      return ACS_BOARD_POLLING_TASK_STRING;
-    case 0x49060005:
-      return RW_POLLING_TASK_STRING;
-    case 0x49060006:
-      return SPI_RTD_COM_IF_STRING;
-    case 0x49060007:
-      return SUS_POLLING_TASK_STRING;
-    case 0x50000100:
-      return CCSDS_PACKET_DISTRIBUTOR_STRING;
-    case 0x50000200:
-      return PUS_PACKET_DISTRIBUTOR_STRING;
-    case 0x50000300:
-      return TCP_TMTC_SERVER_STRING;
-    case 0x50000301:
-      return UDP_TMTC_SERVER_STRING;
-    case 0x50000400:
-      return TCP_TMTC_POLLING_TASK_STRING;
-    case 0x50000401:
-      return UDP_TMTC_POLLING_TASK_STRING;
-    case 0x50000500:
-      return FILE_SYSTEM_HANDLER_STRING;
-    case 0x50000550:
-      return SDC_MANAGER_STRING;
-    case 0x50000600:
-      return PTME_STRING;
-    case 0x50000700:
-      return PDEC_HANDLER_STRING;
-    case 0x50000800:
-      return CCSDS_HANDLER_STRING;
     case 0x51000300:
       return PUS_SERVICE_3_STRING;
     case 0x51000400:
@@ -388,6 +61,8 @@ const char *translateObject(object_id_t object) {
       return PUS_SERVICE_23_STRING;
     case 0x51020100:
       return PUS_SERVICE_201_STRING;
+    case 0x52000002:
+      return TM_FUNNEL_STRING;
     case 0x53000000:
       return FSFW_OBJECTS_START_STRING;
     case 0x53000001:
@@ -402,20 +77,12 @@ const char *translateObject(object_id_t object) {
       return PUS_SERVICE_8_FUNCTION_MGMT_STRING;
     case 0x53000009:
       return PUS_SERVICE_9_TIME_MGMT_STRING;
-    case 0x53000011:
-      return PUS_SERVICE_11_TC_SCHEDULER_STRING;
-    case 0x53000015:
-      return PUS_SERVICE_15_TM_STORAGE_STRING;
     case 0x53000017:
       return PUS_SERVICE_17_TEST_STRING;
     case 0x53000020:
       return PUS_SERVICE_20_PARAMETERS_STRING;
     case 0x53000200:
       return PUS_SERVICE_200_MODE_MGMT_STRING;
-    case 0x53000201:
-      return PUS_SERVICE_201_HEALTH_STRING;
-    case 0x53001000:
-      return CFDP_PACKET_DISTRIBUTOR_STRING;
     case 0x53010000:
       return HEALTH_TABLE_STRING;
     case 0x53010100:
@@ -432,88 +99,12 @@ const char *translateObject(object_id_t object) {
       return IPC_STORE_STRING;
     case 0x53500010:
       return TIME_STAMPER_STRING;
-    case 0x53500020:
-      return VERIFICATION_REPORTER_STRING;
     case 0x53ffffff:
       return FSFW_OBJECTS_END_STRING;
-    case 0x60000000:
-      return HEATER_0_PLOC_PROC_BRD_STRING;
-    case 0x60000001:
-      return HEATER_1_PCDU_BRD_STRING;
-    case 0x60000002:
-      return HEATER_2_ACS_BRD_STRING;
-    case 0x60000003:
-      return HEATER_3_OBC_BRD_STRING;
-    case 0x60000004:
-      return HEATER_4_CAMERA_STRING;
-    case 0x60000005:
-      return HEATER_5_STR_STRING;
-    case 0x60000006:
-      return HEATER_6_DRO_STRING;
-    case 0x60000007:
-      return HEATER_7_SYRLINKS_STRING;
-    case 0x73000001:
-      return ACS_BOARD_ASS_STRING;
-    case 0x73000002:
-      return SUS_BOARD_ASS_STRING;
-    case 0x73000003:
-      return TCS_BOARD_ASS_STRING;
-    case 0x73000004:
-      return RW_ASSY_STRING;
-    case 0x73000006:
-      return CAM_SWITCHER_STRING;
-    case 0x73000007:
-      return SYRLINKS_ASSY_STRING;
-    case 0x73000008:
-      return IMTQ_ASSY_STRING;
-    case 0x73000009:
-      return STR_ASSY_STRING;
-    case 0x73000100:
-      return TM_FUNNEL_STRING;
-    case 0x73000101:
-      return PUS_TM_FUNNEL_STRING;
-    case 0x73000102:
-      return CFDP_TM_FUNNEL_STRING;
-    case 0x73000205:
-      return CFDP_HANDLER_STRING;
-    case 0x73000206:
-      return CFDP_DISTRIBUTOR_STRING;
-    case 0x73010000:
-      return EIVE_SYSTEM_STRING;
-    case 0x73010001:
-      return ACS_SUBSYSTEM_STRING;
-    case 0x73010002:
-      return PL_SUBSYSTEM_STRING;
-    case 0x73010003:
-      return TCS_SUBSYSTEM_STRING;
-    case 0x73010004:
-      return COM_SUBSYSTEM_STRING;
-    case 0x73020001:
-      return MISC_TM_STORE_STRING;
-    case 0x73020002:
-      return OK_TM_STORE_STRING;
-    case 0x73020003:
-      return NOT_OK_TM_STORE_STRING;
-    case 0x73020004:
-      return HK_TM_STORE_STRING;
-    case 0x73030000:
-      return CFDP_TM_STORE_STRING;
-    case 0x73040000:
-      return LIVE_TM_TASK_STRING;
-    case 0x73040001:
-      return LOG_STORE_AND_TM_TASK_STRING;
-    case 0x73040002:
-      return HK_STORE_AND_TM_TASK_STRING;
-    case 0x73040003:
-      return CFDP_STORE_AND_TM_TASK_STRING;
-    case 0x73040004:
-      return DOWNLINK_RAM_STORE_STRING;
-    case 0x73500000:
-      return CCSDS_IP_CORE_BRIDGE_STRING;
-    case 0x90000003:
-      return THERMAL_TEMP_INSERTER_STRING;
     case 0xCAFECAFE:
       return DUMMY_INTERFACE_STRING;
+    case objects::THERMAL_CONTROLLER:
+      return THERMAL_CONTROLLER_STRING;
     case 0xFFFFFFFF:
       return NO_OBJECT_STRING;
     default:

bsp_hosted/fsfwconfig/objects/translateObjects.h

@@ -3,6 +3,6 @@
 
 #include <fsfw/objectmanager/SystemObjectIF.h>
 
-const char *translateObject(object_id_t object);
+const char* translateObject(object_id_t object);
 
 #endif /* FSFWCONFIG_OBJECTS_TRANSLATEOBJECTS_H_ */

bsp_hosted/fsfwconfig/pollingsequence/DummyPst.cpp

@@ -44,11 +44,12 @@ ReturnValue_t dummy_pst::pst(FixedTimeslotTaskIF *thisSequence) {
   thisSequence->addSlot(objects::STAR_TRACKER, length * 0, DeviceHandlerIF::SEND_READ);
   thisSequence->addSlot(objects::STAR_TRACKER, length * 0, DeviceHandlerIF::GET_READ);
 
-  thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0, DeviceHandlerIF::GET_READ);
+  thisSequence->addSlot(objects::SYRLINKS_HK_HANDLER, length * 0,
+                        DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::SYRLINKS_HK_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::SYRLINKS_HK_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::SYRLINKS_HK_HANDLER, length * 0, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::SYRLINKS_HK_HANDLER, length * 0, DeviceHandlerIF::GET_READ);
 
   thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
   thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE);
@@ -128,12 +129,12 @@ ReturnValue_t dummy_pst::pst(FixedTimeslotTaskIF *thisSequence) {
   thisSequence->addSlot(objects::PLPCDU_HANDLER, length * 0, DeviceHandlerIF::SEND_READ);
   thisSequence->addSlot(objects::PLPCDU_HANDLER, length * 0, DeviceHandlerIF::GET_READ);
 
-  if (thisSequence->checkSequence() == returnvalue::OK) {
-    return returnvalue::OK;
+  if (thisSequence->checkSequence() == HasReturnvaluesIF::RETURN_OK) {
+    return HasReturnvaluesIF::RETURN_OK;
   } else {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::error << "pst::pollingSequenceInitDefault: Sequence invalid!" << std::endl;
 #endif
-    return returnvalue::FAILED;
+    return HasReturnvaluesIF::RETURN_FAILED;
   }
 }

bsp_hosted/fsfwconfig/pollingsequence/DummyPst.h

@@ -1,7 +1,7 @@
 #ifndef POLLINGSEQUENCEFACTORY_H_
 #define POLLINGSEQUENCEFACTORY_H_
 
-#include <fsfw/returnvalues/returnvalue.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
 
 class FixedTimeslotTaskIF;
 

bsp_hosted/fsfwconfig/returnvalues/classIds.h

@@ -3,7 +3,7 @@
 
 #include <fsfw/returnvalues/FwClassIds.h>
 
-#include "eive/resultClassIds.h"
+#include "commonClassIds.h"
 
 /**
  * Source IDs starts at 73 for now
@@ -13,7 +13,6 @@
 namespace CLASS_ID {
 enum {
   CLASS_ID_START = COMMON_CLASS_ID_END,
-  CLASS_ID_END  // [EXPORT] : [END]
 };
 }
 

bsp_hosted/main.cpp

@@ -2,6 +2,7 @@
 
 #include <iostream>
 
+#include "InitMission.h"
 #include "commonConfig.h"
 #include "fsfw/FSFWVersion.h"
 #include "fsfw/controller/ControllerBase.h"
@@ -10,7 +11,6 @@
 #include "fsfw/modes/ModeMessage.h"
 #include "fsfw/objectmanager/ObjectManager.h"
 #include "fsfw/tasks/TaskFactory.h"
-#include "scheduling.h"
 
 #ifdef WIN32
 static const char* COMPILE_PRINTOUT = "Windows";
@@ -31,11 +31,8 @@ int main(void) {
             << "v" << common::OBSW_VERSION << " | FSFW v" << fsfw::FSFW_VERSION << " --"
             << std::endl;
   std::cout << "-- " << __DATE__ << " " << __TIME__ << " --" << std::endl;
-  std::cout << "-- "
-            << " BSP HOSTED"
-            << " --" << std::endl;
 
-  scheduling::initMission();
+  initmission::initMission();
 
   for (;;) {
     // suspend main thread by sleeping it.

bsp_hosted/scheduling.cpp

@@ -1,238 +0,0 @@
-#include "linux/scheduling.h"
-
-#include <bsp_hosted/fsfwconfig/pollingsequence/DummyPst.h>
-#include <fsfw/objectmanager/ObjectManager.h>
-#include <fsfw/objectmanager/ObjectManagerIF.h>
-#include <fsfw/returnvalues/returnvalue.h>
-#include <fsfw/serviceinterface/ServiceInterfaceStream.h>
-#include <fsfw/tasks/FixedTimeslotTaskIF.h>
-#include <fsfw/tasks/PeriodicTaskIF.h>
-#include <fsfw/tasks/TaskFactory.h>
-#include <mission/utility/InitMission.h>
-
-#include <iostream>
-
-#include "OBSWConfig.h"
-#include "ObjectFactory.h"
-#include "mission/core/scheduling.h"
-#include "scheduling.h"
-
-#ifdef LINUX
-ServiceInterfaceStream sif::debug("DEBUG");
-ServiceInterfaceStream sif::info("INFO");
-ServiceInterfaceStream sif::warning("WARNING");
-ServiceInterfaceStream sif::error("ERROR", false, false, true);
-#else
-ServiceInterfaceStream sif::debug("DEBUG", true);
-ServiceInterfaceStream sif::info("INFO", true);
-ServiceInterfaceStream sif::warning("WARNING", true);
-ServiceInterfaceStream sif::error("ERROR", true, false, true);
-#endif
-
-ObjectManagerIF* objectManager = nullptr;
-
-void scheduling::initMission() {
-  sif::info << "Building global objects.." << std::endl;
-  /* Instantiate global object manager and also create all objects */
-  ObjectManager::instance()->setObjectFactoryFunction(ObjectFactory::produce, nullptr);
-  sif::info << "Initializing all objects.." << std::endl;
-  ObjectManager::instance()->initialize();
-
-  /* This function creates and starts all tasks */
-  initTasks();
-}
-
-void scheduling::initTasks() {
-  TaskFactory* factory = TaskFactory::instance();
-  if (factory == nullptr) {
-    /* Should never happen ! */
-    return;
-  }
-#if OBSW_PRINT_MISSED_DEADLINES == 1
-  void (*missedDeadlineFunc)(void) = TaskFactory::printMissedDeadline;
-#else
-  void (*missedDeadlineFunc)(void) = nullptr;
-#endif
-
-  /* TMTC Distribution */
-  PeriodicTaskIF* tmtcDistributor = factory->createPeriodicTask(
-      "DIST", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
-  ReturnValue_t result = tmtcDistributor->addComponent(objects::CCSDS_PACKET_DISTRIBUTOR);
-  if (result != returnvalue::OK) {
-    sif::error << "adding CCSDS distributor failed" << std::endl;
-  }
-  result = tmtcDistributor->addComponent(objects::PUS_PACKET_DISTRIBUTOR);
-  if (result != returnvalue::OK) {
-    sif::error << "adding PUS distributor failed" << std::endl;
-  }
-  result = tmtcDistributor->addComponent(objects::TM_FUNNEL);
-  if (result != returnvalue::OK) {
-    sif::error << "adding TM funnel failed" << std::endl;
-  }
-  result = tmtcDistributor->addComponent(objects::CFDP_DISTRIBUTOR);
-  if (result != returnvalue::OK) {
-    sif::error << "adding CFDP distributor failed" << std::endl;
-  }
-  result = tmtcDistributor->addComponent(objects::UDP_TMTC_SERVER);
-  if (result != returnvalue::OK) {
-    sif::error << "adding UDP server failed" << std::endl;
-  }
-  result = tmtcDistributor->addComponent(objects::TCP_TMTC_SERVER);
-  if (result != returnvalue::OK) {
-    sif::error << "adding TCP server failed" << std::endl;
-  }
-
-  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;
-  }
-  PeriodicTaskIF* tcpPollingTask = factory->createPeriodicTask(
-      "TCP_POLLING", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
-  result = tcpPollingTask->addComponent(objects::TCP_TMTC_POLLING_TASK);
-  if (result != returnvalue::OK) {
-    sif::error << "Add component UDP Polling failed" << std::endl;
-  }
-
-  PeriodicTaskIF* pusHighPrio = factory->createPeriodicTask(
-      "PUS_HIGH_PRIO", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
-  result = pusHighPrio->addComponent(objects::PUS_SERVICE_1_VERIFICATION);
-  if (result != returnvalue::OK) {
-    sif::error << "Object add component failed" << std::endl;
-  }
-  result = pusHighPrio->addComponent(objects::EVENT_MANAGER);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("EVENT_MGMT", objects::EVENT_MANAGER);
-  }
-  result = pusHighPrio->addComponent(objects::PUS_SERVICE_5_EVENT_REPORTING);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("PUS5", objects::PUS_SERVICE_5_EVENT_REPORTING);
-  }
-  result = pusHighPrio->addComponent(objects::PUS_SERVICE_9_TIME_MGMT);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("PUS9", objects::PUS_SERVICE_9_TIME_MGMT);
-  }
-
-  PeriodicTaskIF* pusMedPrio = factory->createPeriodicTask(
-      "PUS_MED_PRIO", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.8, missedDeadlineFunc);
-  result = pusHighPrio->addComponent(objects::PUS_SERVICE_2_DEVICE_ACCESS);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("PUS2", objects::PUS_SERVICE_2_DEVICE_ACCESS);
-  }
-  result = pusHighPrio->addComponent(objects::PUS_SERVICE_3_HOUSEKEEPING);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("PUS3", objects::PUS_SERVICE_3_HOUSEKEEPING);
-  }
-  result = pusMedPrio->addComponent(objects::PUS_SERVICE_8_FUNCTION_MGMT);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("PUS8", objects::PUS_SERVICE_8_FUNCTION_MGMT);
-  }
-  result = pusMedPrio->addComponent(objects::PUS_SERVICE_15_TM_STORAGE);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("PUS15", objects::PUS_SERVICE_15_TM_STORAGE);
-  }
-  result = pusMedPrio->addComponent(objects::PUS_SERVICE_200_MODE_MGMT);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("PUS200", objects::PUS_SERVICE_200_MODE_MGMT);
-  }
-  result = pusMedPrio->addComponent(objects::PUS_SERVICE_20_PARAMETERS);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("PUS20", objects::PUS_SERVICE_20_PARAMETERS);
-  }
-  result = pusMedPrio->addComponent(objects::PUS_SERVICE_17_TEST);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("PUS17", objects::PUS_SERVICE_17_TEST);
-  }
-
-  PeriodicTaskIF* thermalTask = factory->createPeriodicTask(
-      "THERMAL_CTL_TASK", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, missedDeadlineFunc);
-  result = thermalTask->addComponent(objects::CORE_CONTROLLER);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("Core controller dummy", objects::CORE_CONTROLLER);
-  }
-
-  result = thermalTask->addComponent(objects::THERMAL_CONTROLLER);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("THERMAL_CONTROLLER", objects::THERMAL_CONTROLLER);
-  }
-
-  FixedTimeslotTaskIF* pstTask = factory->createFixedTimeslotTask(
-      "DUMMY_PST", 75, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 0.5, missedDeadlineFunc);
-  result = dummy_pst::pst(pstTask);
-  if (result != returnvalue::OK) {
-    sif::error << "Failed to add dummy pst to fixed timeslot task" << std::endl;
-  }
-
-#if OBSW_ADD_CFDP_COMPONENTS == 1
-  PeriodicTaskIF* cfdpTask = factory->createPeriodicTask(
-      "CFDP Handler", 45, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.4, missedDeadlineFunc);
-  result = cfdpTask->addComponent(objects::CFDP_HANDLER);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("CFDP Handler", objects::CFDP_HANDLER);
-  }
-#endif
-
-#if OBSW_ADD_PLOC_SUPERVISOR == 1
-  PeriodicTaskIF* supvHelperTask = factory->createPeriodicTask(
-      "PLOC_SUPV_HELPER", 20, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, missedDeadlineFunc);
-  result = supvHelperTask->addComponent(objects::PLOC_SUPERVISOR_HELPER);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("PLOC_SUPV_HELPER", objects::PLOC_SUPERVISOR_HELPER);
-  }
-#endif /* OBSW_ADD_PLOC_SUPERVISOR */
-
-  PeriodicTaskIF* plTask = factory->createPeriodicTask(
-      "PL_TASK", 25, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, missedDeadlineFunc);
-  scheduling::addMpsocSupvHandlers(plTask);
-#if OBSW_ADD_TEST_CODE == 1
-  result = testTask->addComponent(objects::TEST_TASK);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("TEST_TASK", objects::TEST_TASK);
-  }
-#endif /* OBSW_ADD_TEST_CODE == 1 */
-
-  PeriodicTaskIF* dummyTask = factory->createPeriodicTask(
-      "DUMMY_TASK", 30, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, missedDeadlineFunc);
-  scheduling::scheduleTmpTempSensors(dummyTask);
-  scheduling::scheduleRtdSensors(dummyTask);
-  dummyTask->addComponent(objects::SUS_0_N_LOC_XFYFZM_PT_XF);
-  dummyTask->addComponent(objects::SUS_1_N_LOC_XBYFZM_PT_XB);
-  dummyTask->addComponent(objects::SUS_2_N_LOC_XFYBZB_PT_YB);
-  dummyTask->addComponent(objects::SUS_3_N_LOC_XFYBZF_PT_YF);
-  dummyTask->addComponent(objects::SUS_4_N_LOC_XMYFZF_PT_ZF);
-  dummyTask->addComponent(objects::SUS_5_N_LOC_XFYMZB_PT_ZB);
-  dummyTask->addComponent(objects::SUS_6_R_LOC_XFYBZM_PT_XF);
-  dummyTask->addComponent(objects::SUS_7_R_LOC_XBYBZM_PT_XB);
-  dummyTask->addComponent(objects::SUS_8_R_LOC_XBYBZB_PT_YB);
-  dummyTask->addComponent(objects::SUS_9_R_LOC_XBYBZB_PT_YF);
-  dummyTask->addComponent(objects::SUS_10_N_LOC_XMYBZF_PT_ZF);
-  dummyTask->addComponent(objects::SUS_11_R_LOC_XBYMZB_PT_ZB);
-
-  sif::info << "Starting tasks.." << std::endl;
-  tmtcDistributor->startTask();
-  udpPollingTask->startTask();
-  tcpPollingTask->startTask();
-
-  pusHighPrio->startTask();
-  pusMedPrio->startTask();
-
-  pstTask->startTask();
-  thermalTask->startTask();
-  dummyTask->startTask();
-#if OBSW_ADD_PLOC_SUPERVISOR == 1
-  supvHelperTask->startTask();
-#endif
-#if OBSW_ADD_PLOC_SUPERVISOR == 1 || OBSW_ADD_PLOC_MPSOC == 1
-  plTask->startTask();
-#endif
-#if OBSW_ADD_CFDP_COMPONENTS == 1
-  cfdpTask->startTask();
-#endif
-
-#if OBSW_ADD_TEST_CODE == 1
-  testTask->startTask();
-#endif /* OBSW_ADD_TEST_CODE == 1 */
-
-  sif::info << "Tasks started.." << std::endl;
-}

bsp_hosted/scheduling.h

@@ -1,6 +0,0 @@
-#pragma once
-
-namespace scheduling {
-void initMission();
-void initTasks();
-};  // namespace scheduling

bsp_linux_board/CMakeLists.txt

@@ -3,4 +3,3 @@ target_sources(${OBSW_NAME} PUBLIC InitMission.cpp main.cpp gpioInit.cpp
 
 add_subdirectory(boardconfig)
 add_subdirectory(boardtest)
-add_subdirectory(fsfwconfig)

bsp_linux_board/InitMission.cpp

@@ -1,14 +1,12 @@
 #include "InitMission.h"
 
-#include <fsfw/devicehandlers/DeviceHandlerIF.h>
 #include <fsfw/objectmanager/ObjectManager.h>
 #include <fsfw/objectmanager/ObjectManagerIF.h>
-#include <fsfw/returnvalues/returnvalue.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
 #include <fsfw/serviceinterface/ServiceInterface.h>
 #include <fsfw/tasks/FixedTimeslotTaskIF.h>
 #include <fsfw/tasks/PeriodicTaskIF.h>
 #include <fsfw/tasks/TaskFactory.h>
-#include <linux/InitMission.h>
 #include <mission/utility/InitMission.h>
 
 #include <iostream>
@@ -38,7 +36,7 @@ void initmission::initMission() {
 
 void initmission::initTasks() {
   TaskFactory* factory = TaskFactory::instance();
-  ReturnValue_t result = returnvalue::OK;
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
   if (factory == nullptr) {
     /* Should never happen ! */
     return;
@@ -53,15 +51,15 @@ void initmission::initTasks() {
   PeriodicTaskIF* tmTcDistributor = factory->createPeriodicTask(
       "DIST", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
   result = tmTcDistributor->addComponent(objects::CCSDS_PACKET_DISTRIBUTOR);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::error << "Object add component failed" << std::endl;
   }
   result = tmTcDistributor->addComponent(objects::PUS_PACKET_DISTRIBUTOR);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::error << "Object add component failed" << std::endl;
   }
   result = tmTcDistributor->addComponent(objects::TM_FUNNEL);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::error << "Object add component failed" << std::endl;
   }
 
@@ -69,22 +67,16 @@ void initmission::initTasks() {
   PeriodicTaskIF* tmtcBridgeTask = factory->createPeriodicTask(
       "TMTC_BRIDGE", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
   result = tmtcBridgeTask->addComponent(objects::TMTC_BRIDGE);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::error << "Add component TMTC Bridge failed" << std::endl;
   }
   PeriodicTaskIF* tmtcPollingTask = factory->createPeriodicTask(
       "TMTC_POLLING", 80, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
   result = tmtcPollingTask->addComponent(objects::TMTC_POLLING_TASK);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::error << "Add component TMTC Polling failed" << std::endl;
   }
 
-#if OBSW_ADD_SCEX_DEVICE == 1
-  PeriodicTaskIF* scexDevHandler;
-  PeriodicTaskIF* scexReaderTask;
-  scheduling::schedulingScex(*factory, scexDevHandler, scexReaderTask);
-#endif
-
   /* PUS Services */
   std::vector<PeriodicTaskIF*> pusTasks;
   createPusTasks(*factory, missedDeadlineFunc, pusTasks);
@@ -117,10 +109,6 @@ void initmission::initTasks() {
 #endif /* OBSW_ADD_TEST_CODE == 1 */
   taskStarter(pstTasks, "PST Tasks");
 
-#if OBSW_ADD_SCEX_DEVICE == 1
-  scexDevHandler->startTask();
-  scexReaderTask->startTask();
-#endif
 #if OBSW_ADD_TEST_PST == 1
   if (startTestPst) {
     pstTestTask->startTask();
@@ -132,11 +120,11 @@ void initmission::initTasks() {
 void initmission::createPusTasks(TaskFactory& factory,
                                  TaskDeadlineMissedFunction missedDeadlineFunc,
                                  std::vector<PeriodicTaskIF*>& taskVec) {
-  ReturnValue_t result = returnvalue::OK;
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
   PeriodicTaskIF* pusVerification = factory.createPeriodicTask(
       "PUS_VERIF", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
   result = pusVerification->addComponent(objects::PUS_SERVICE_1_VERIFICATION);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::error << "Object add component failed" << std::endl;
   }
   taskVec.push_back(pusVerification);
@@ -144,11 +132,11 @@ void initmission::createPusTasks(TaskFactory& factory,
   PeriodicTaskIF* pusEvents = factory.createPeriodicTask(
       "PUS_EVENTS", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
   result = pusEvents->addComponent(objects::PUS_SERVICE_5_EVENT_REPORTING);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("PUS_EVENTS", objects::PUS_SERVICE_5_EVENT_REPORTING);
   }
   result = pusEvents->addComponent(objects::EVENT_MANAGER);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("PUS_MGMT", objects::EVENT_MANAGER);
   }
   taskVec.push_back(pusEvents);
@@ -156,11 +144,11 @@ void initmission::createPusTasks(TaskFactory& factory,
   PeriodicTaskIF* pusHighPrio = factory.createPeriodicTask(
       "PUS_HIGH_PRIO", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
   result = pusHighPrio->addComponent(objects::PUS_SERVICE_2_DEVICE_ACCESS);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("PUS2", objects::PUS_SERVICE_2_DEVICE_ACCESS);
   }
   result = pusHighPrio->addComponent(objects::PUS_SERVICE_9_TIME_MGMT);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("PUS9", objects::PUS_SERVICE_9_TIME_MGMT);
   }
   taskVec.push_back(pusHighPrio);
@@ -168,19 +156,19 @@ void initmission::createPusTasks(TaskFactory& factory,
   PeriodicTaskIF* pusMedPrio = factory.createPeriodicTask(
       "PUS_MED_PRIO", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.8, missedDeadlineFunc);
   result = pusMedPrio->addComponent(objects::PUS_SERVICE_8_FUNCTION_MGMT);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("PUS8", objects::PUS_SERVICE_8_FUNCTION_MGMT);
   }
   result = pusMedPrio->addComponent(objects::PUS_SERVICE_200_MODE_MGMT);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("PUS200", objects::PUS_SERVICE_200_MODE_MGMT);
   }
   result = pusMedPrio->addComponent(objects::PUS_SERVICE_20_PARAMETERS);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("PUS20", objects::PUS_SERVICE_20_PARAMETERS);
   }
   result = pusMedPrio->addComponent(objects::PUS_SERVICE_3_HOUSEKEEPING);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("PUS3", objects::PUS_SERVICE_3_HOUSEKEEPING);
   }
   taskVec.push_back(pusMedPrio);
@@ -188,11 +176,11 @@ void initmission::createPusTasks(TaskFactory& factory,
   PeriodicTaskIF* pusLowPrio = factory.createPeriodicTask(
       "PUS_LOW_PRIO", 30, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.6, missedDeadlineFunc);
   result = pusLowPrio->addComponent(objects::PUS_SERVICE_17_TEST);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("PUS17", objects::PUS_SERVICE_17_TEST);
   }
   result = pusLowPrio->addComponent(objects::INTERNAL_ERROR_REPORTER);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("INT_ERR_RPRT", objects::INTERNAL_ERROR_REPORTER);
   }
   taskVec.push_back(pusLowPrio);
@@ -201,55 +189,45 @@ void initmission::createPusTasks(TaskFactory& factory,
 void initmission::createPstTasks(TaskFactory& factory,
                                  TaskDeadlineMissedFunction missedDeadlineFunc,
                                  std::vector<PeriodicTaskIF*>& taskVec) {
-  ReturnValue_t result = returnvalue::OK;
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 #if OBSW_ADD_SPI_TEST_CODE == 0
   FixedTimeslotTaskIF* spiPst = factory.createFixedTimeslotTask(
       "SPI_PST", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 1.0, missedDeadlineFunc);
   result = pst::pstSpi(spiPst);
-  if (result != returnvalue::OK) {
-    if (result != FixedTimeslotTaskIF::SLOT_LIST_EMPTY) {
-      sif::error << "InitMission::createPstTasks: Creating PST failed!" << std::endl;
-    }
-  } else {
-    taskVec.push_back(spiPst);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    sif::error << "InitMission::initTasks: Creating PST failed!" << std::endl;
   }
+  taskVec.push_back(spiPst);
 #endif
 }
 
 void initmission::createTestTasks(TaskFactory& factory,
                                   TaskDeadlineMissedFunction missedDeadlineFunc,
                                   std::vector<PeriodicTaskIF*>& taskVec) {
-  ReturnValue_t result = returnvalue::OK;
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
   PeriodicTaskIF* testTask = factory.createPeriodicTask(
       "TEST_TASK", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
   result = testTask->addComponent(objects::TEST_TASK);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("TEST_TASK", objects::TEST_TASK);
   }
 #if OBSW_ADD_SPI_TEST_CODE == 1
   result = testTask->addComponent(objects::SPI_TEST);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("SPI_TEST", objects::SPI_TEST);
   }
 #endif /* RPI_ADD_SPI_TEST == 1 */
 #if RPI_ADD_GPIO_TEST == 1
   result = testTask->addComponent(objects::LIBGPIOD_TEST);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("GPIOD_TEST", objects::LIBGPIOD_TEST);
   }
 #endif /* RPI_ADD_GPIO_TEST == 1 */
 #if OBSW_ADD_UART_TEST_CODE == 1
   result = testTask->addComponent(objects::UART_TEST);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("UART_TEST", objects::UART_TEST);
   }
-  PeriodicTaskIF* scexReaderTask = factory.createPeriodicTask(
-      "SCEX_UART_READER", 20, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
-  result = scexReaderTask->addComponent(objects::SCEX_UART_READER);
-  if (result != returnvalue::OK) {
-    initmission::printAddObjectError("SCEX_UART_READER", objects::SCEX_UART_READER);
-  }
-  taskVec.push_back(scexReaderTask);
 #endif /* RPI_ADD_GPIO_TEST == 1 */
   taskVec.push_back(testTask);
 
@@ -259,7 +237,7 @@ void initmission::createTestTasks(TaskFactory& factory,
   FixedTimeslotTaskIF* pstTestTask = factory->createFixedTimeslotTask(
       "TEST_PST", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 2.0, missedDeadlineFunc);
   result = pst::pstTest(pstTestTask);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::info << "initmission::initTasks: ACS PST empty or invalid" << std::endl;
     startTestPst = false;
   }

bsp_linux_board/OBSWConfig.h.in

@@ -28,7 +28,6 @@
 #define OBSW_ADD_RTD_DEVICES                        0
 #define OBSW_ADD_PL_PCDU                            0
 #define OBSW_ADD_TMP_DEVICES                        0
-#define OBSW_ADD_SCEX_DEVICE                        1
 #define OBSW_ADD_RAD_SENSORS                        0
 #define OBSW_ADD_SYRLINKS                           0
 #define OBSW_STAR_TRACKER_GROUND_CONFIG             1
@@ -103,12 +102,6 @@
 /*******************************************************************/
 #cmakedefine EIVE_BUILD_GPSD_GPS_HANDLER
 
-#define OBSW_ADD_CCSDS_IP_CORES                     0
-// Set to 1 if all telemetry should be sent to the PTME IP Core
-#define OBSW_TM_TO_PTME                             0
-// Set to 1 if telecommands are received via the PDEC IP Core
-#define OBSW_TC_FROM_PDEC                           0
-
 #cmakedefine LIBGPS_VERSION_MAJOR @LIBGPS_VERSION_MAJOR@
 #cmakedefine LIBGPS_VERSION_MINOR @LIBGPS_VERSION_MINOR@
 

bsp_linux_board/ObjectFactory.cpp

@@ -1,8 +1,5 @@
 #include "ObjectFactory.h"
 
-#include <bsp_linux_board/RPiSdCardManager.h>
-#include <linux/devices/ScexUartReader.h>
-
 #include "OBSWConfig.h"
 #include "devConf.h"
 #include "devices/addresses.h"
@@ -21,8 +18,9 @@
 #include "mission/core/GenericFactory.h"
 #include "mission/devices/GPSHyperionHandler.h"
 #include "mission/devices/GyroADIS1650XHandler.h"
-#include "mission/tmtc/TmFunnel.h"
+#include "mission/utility/TmFunnel.h"
 #include "objects/systemObjectList.h"
+#include "tmtc/apid.h"
 #include "tmtc/pusIds.h"
 
 /* UDP server includes */
@@ -34,8 +32,8 @@
 #include "fsfw/osal/common/UdpTmTcBridge.h"
 #endif
 
-#include <fsfw_hal/linux/serial/SerialComIF.h>
-#include <fsfw_hal/linux/serial/SerialCookie.h>
+#include <fsfw_hal/linux/uart/UartComIF.h>
+#include <fsfw_hal/linux/uart/UartCookie.h>
 
 #include "fsfw_hal/common/gpio/GpioCookie.h"
 #include "fsfw_hal/devicehandlers/GyroL3GD20Handler.h"
@@ -47,8 +45,8 @@
 #include "fsfw_hal/linux/spi/SpiCookie.h"
 
 void Factory::setStaticFrameworkObjectIds() {
-  PusServiceBase::PUS_DISTRIBUTOR = objects::PUS_PACKET_DISTRIBUTOR;
-  PusServiceBase::PACKET_DESTINATION = objects::TM_FUNNEL;
+  PusServiceBase::packetSource = objects::PUS_PACKET_DISTRIBUTOR;
+  PusServiceBase::packetDestination = objects::TM_FUNNEL;
 
   CommandingServiceBase::defaultPacketSource = objects::PUS_PACKET_DISTRIBUTOR;
   CommandingServiceBase::defaultPacketDestination = objects::TM_FUNNEL;
@@ -56,6 +54,9 @@ void Factory::setStaticFrameworkObjectIds() {
   TmFunnel::downlinkDestination = objects::TMTC_BRIDGE;
   // No storage object for now.
   TmFunnel::storageDestination = objects::NO_OBJECT;
+
+  VerificationReporter::messageReceiver = objects::PUS_SERVICE_1_VERIFICATION;
+  TmPacketBase::timeStamperId = objects::TIME_STAMPER;
 }
 
 void ObjectFactory::produce(void* args) {
@@ -75,17 +76,12 @@ void ObjectFactory::produce(void* args) {
   createRpiAcsBoard(gpioIF, spiDev);
 #endif
 
-#if OBSW_ADD_SUN_SENSORS == 1 || OBSW_ADD_RTD_DEVICES == 1
+#if OBSW_ADD_SUN_SENSORS == 1 || defined(OBSW_ADD_RTD_DEVICES)
 #ifdef RASPBERRY_PI
   rpi::gpio::initSpiCsDecoder(gpioIF);
 #endif
 #endif
 
-#if OBSW_ADD_SCEX_DEVICE == 1
-  auto* sdcMan = new DummySdCardManager("/tmp");
-  createScexComponents(uart::DEV, pwrSwitcher, *sdcMan, true, std::nullopt);
-#endif
-
 #if OBSW_ADD_SUN_SENSORS == 1
   createSunSensorComponents(gpioIF, spiComIF, pwrSwitcher, spi::DEV);
 #endif
@@ -202,7 +198,7 @@ void ObjectFactory::createTestTasks() {
 #if OBSW_ADD_UART_TEST_CODE == 1
   new UartTestClass(objects::UART_TEST);
 #else
-  newSerialComIF(objects::UART_COM_IF);
+  new UartComIF(objects::UART_COM_IF);
 #endif
 
 #if RPI_LOOPBACK_TEST_GPIO == 1

bsp_linux_board/definitions.h

@@ -13,12 +13,6 @@ static constexpr char DEV[] = "/dev/spidev0.1";
 
 }
 
-namespace uart {
-
-static constexpr char DEV[] = "/dev/serial0";
-
-}
-
 /* Adapt these values accordingly */
 namespace gpio {
 static constexpr uint8_t MGM_0_BCM_PIN = 17;

bsp_linux_board/gpioInit.cpp

@@ -40,14 +40,14 @@ void rpi::gpio::initSpiCsDecoder(GpioIF* gpioComIF) {
   for (const auto& info : muxInfo) {
     result = createRpiGpioConfig(spiMuxGpios, info.gpioId, info.bcmNum, info.consumer,
                                  Direction::OUT, Levels::LOW);
-    if (result != returnvalue::OK) {
+    if (result != HasReturnvaluesIF::RETURN_OK) {
       sif::error << "Creating Raspberry Pi SPI Mux GPIO failed with code " << result << std::endl;
       return;
     }
   }
 
   result = gpioComIF->addGpios(spiMuxGpios);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::error << "initSpiCsDecoder: Failed to add mux bit gpios to gpioComIF" << std::endl;
     return;
   }

bsp_q7s/CMakeLists.txt

@@ -9,7 +9,7 @@ add_subdirectory(simple)
 
 target_sources(${OBSW_NAME} PUBLIC main.cpp obsw.cpp)
 
-add_subdirectory(boardtest)
+#add_subdirectory(boardtest)
 
 add_subdirectory(boardconfig)
 add_subdirectory(comIF)
@@ -24,4 +24,3 @@ endif()
 add_subdirectory(memory)
 add_subdirectory(callbacks)
 add_subdirectory(xadc)
-add_subdirectory(fs)

bsp_q7s/OBSWConfig.h.in

@@ -8,67 +8,56 @@
 
 #include "commonConfig.h"
 #include "q7sConfig.h"
+#include "OBSWVersion.h"
 
 /*******************************************************************/
 /** All of the following flags should be enabled for mission code  */
 /*******************************************************************/
 
-#define OBSW_ENABLE_PERIODIC_HK                     0
-#define OBSW_ENABLE_SYRLINKS_TRANSMIT_TIMEOUT       0
-// This switch will cause the SW to command the EIVE system object to safe mode. This will
-// trigger a lot of events, so it can make sense to disable this for debugging purposes
-#define OBSW_COMMAND_SAFE_MODE_AT_STARTUP           1
+#define OBSW_USE_CCSDS_IP_CORE                      1
+// Set to 1 if all telemetry should be sent to the PTME IP Core
+#define OBSW_TM_TO_PTME                             0
+// Set to 1 if telecommands are received via the PDEC IP Core
+#define OBSW_TC_FROM_PDEC                           0
 
+#define OBSW_ENABLE_TIMERS                          1
 #define OBSW_ADD_GOMSPACE_PCDU                      @OBSW_ADD_GOMSPACE_PCDU@
 #define OBSW_ADD_MGT                                @OBSW_ADD_MGT@
 #define OBSW_ADD_BPX_BATTERY_HANDLER                @OBSW_ADD_BPX_BATTERY_HANDLER@
 #define OBSW_ADD_STAR_TRACKER                       @OBSW_ADD_STAR_TRACKER@
-#define OBSW_ADD_PLOC_SUPERVISOR                    @OBSW_ADD_PLOC_SUPERVISOR@
-#define OBSW_ADD_PLOC_MPSOC                         @OBSW_ADD_PLOC_MPSOC@
+#define OBSW_ADD_PLOC_SUPERVISOR                    1
+#define OBSW_ADD_PLOC_MPSOC                         1
 #define OBSW_ADD_SUN_SENSORS                        @OBSW_ADD_SUN_SENSORS@
 #define OBSW_ADD_SUS_BOARD_ASS                      @OBSW_ADD_SUS_BOARD_ASS@
 #define OBSW_ADD_ACS_BOARD                          @OBSW_ADD_ACS_BOARD@
-#define OBSW_ADD_ACS_CTRL                           1
-#define OBSW_ADD_GPS_CTRL                           @OBSW_ADD_GPS_CTRL@
-#define OBSW_ADD_TCS_CTRL                           @OBSW_ADD_TCS_CTRL@
+#define OBSW_ADD_ACS_HANDLERS                       @OBSW_ADD_ACS_HANDLERS@
 #define OBSW_ADD_RW                                 @OBSW_ADD_RW@
 #define OBSW_ADD_RTD_DEVICES                        @OBSW_ADD_RTD_DEVICES@
-#define OBSW_ADD_SA_DEPL                            @OBSW_ADD_SA_DEPL@
-#define OBSW_ADD_SCEX_DEVICE                        @OBSW_ADD_SCEX_DEVICE@
-#define OBSW_ADD_HEATERS                            @OBSW_ADD_HEATERS@
 #define OBSW_ADD_TMP_DEVICES                        @OBSW_ADD_TMP_DEVICES@
 #define OBSW_ADD_RAD_SENSORS                        @OBSW_ADD_RAD_SENSORS@
 #define OBSW_ADD_PL_PCDU                            @OBSW_ADD_PL_PCDU@
 #define OBSW_ADD_SYRLINKS                           @OBSW_ADD_SYRLINKS@
-#define OBSW_ADD_CCSDS_IP_CORES                     @OBSW_ADD_CCSDS_IP_CORES@
-// Set to 1 if all telemetry should be sent to the PTME IP Core
-#define OBSW_TM_TO_PTME                             @OBSW_TM_TO_PTME@
-// Set to 1 if telecommands are received via the PDEC IP Core
-#define OBSW_TC_FROM_PDEC                           @OBSW_TC_FROM_PDEC@
+#define OBSW_ENABLE_SYRLINKS_TRANSMIT_TIMEOUT       0
+#define OBSW_MPSOC_JTAG_BOOT                        0
 
-// Configuration parameter which causes the core controller to try to keep at least one SD card
-// working
-#define OBSW_SD_CARD_MUST_BE_ON                     1
-#define OBSW_ENABLE_TIMERS                          1
+// This is a really tricky switch.. It initializes the PCDU switches to their default states
+// at powerup. I think it would be better
+// to leave it off for now. It makes testing a lot more difficult and it might mess with
+// something the operators might want to do by giving the software too much intelligence
+// at the wrong place. The system component might command all the Switches accordingly anyway
+#define OBSW_INITIALIZE_SWITCHES                    0
+#define OBSW_ENABLE_PERIODIC_HK                     0
 
 /*******************************************************************/
 /** All of the following flags should be disabled for mission code */
 /*******************************************************************/
 
-// Use TCP instead of UDP for the TMTC bridge. This allows using the TMTC client locally
-// because UDP packets are not allowed in the VPN
-// This will cause the OBSW to initialize the TMTC bridge responsible for exchanging data with the
-// CCSDS IP Cores. 
-#define OBSW_ADD_TMTC_TCP_SERVER                    1
-#define OBSW_ADD_TMTC_UDP_SERVER                    1
-
 // Can be used to switch device to NORMAL mode immediately
-#define OBSW_SWITCH_TO_NORMAL_MODE_AFTER_STARTUP    0
+#define OBSW_SWITCH_TO_NORMAL_MODE_AFTER_STARTUP    1
 #define OBSW_PRINT_MISSED_DEADLINES                 1
 
-#define OBSW_MPSOC_JTAG_BOOT                        0
-#define OBSW_STAR_TRACKER_GROUND_CONFIG             @OBSW_STAR_TRACKER_GROUND_CONFIG@
-#define OBSW_SYRLINKS_SIMULATED                     @OBSW_SYRLINKS_SIMULATED@
+#define OBSW_STAR_TRACKER_GROUND_CONFIG             1
+#define OBSW_SYRLINKS_SIMULATED                     1
 #define OBSW_ADD_TEST_CODE                          0
 #define OBSW_ADD_TEST_TASK                          0
 #define OBSW_ADD_TEST_PST                           0
@@ -107,7 +96,6 @@
 #define OBSW_PRINT_CORE_HK                          0
 #define OBSW_DEBUG_PDU1                             0
 #define OBSW_DEBUG_PDU2                             0
-#define OBSW_DEBUG_TMP1075                          0
 #define OBSW_DEBUG_GPS                              0
 #define OBSW_DEBUG_ACU                              0
 #define OBSW_DEBUG_SYRLINKS                         0
@@ -122,12 +110,12 @@
 /*******************************************************************/
 /** CMake Defines                                                  */
 /*******************************************************************/
-
 #cmakedefine EIVE_BUILD_GPSD_GPS_HANDLER
 
 #cmakedefine LIBGPS_VERSION_MAJOR @LIBGPS_VERSION_MAJOR@
 #cmakedefine LIBGPS_VERSION_MINOR @LIBGPS_VERSION_MINOR@
 
+
 #ifdef __cplusplus
 
 #include "objects/systemObjectList.h"

bsp_q7s/boardconfig/busConf.h

@@ -3,38 +3,29 @@
 
 namespace q7s {
 
-static constexpr char SPI_DEFAULT_DEV[] = "/dev/spi_main";
+static constexpr char SPI_DEFAULT_DEV[] = "/dev/spi-main";
 static constexpr uint32_t SPI_MAIN_BUS_LOCK_TIMEOUT = 50;
 
-static constexpr char SPI_RW_DEV[] = "/dev/spi_rw";
+static constexpr char SPI_RW_DEV[] = "/dev/spi-rw";
 
-//! I2C bus using an I2C IP core in the programmable logic (PL)
-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";
+static constexpr char I2C_DEFAULT_DEV[] = "/dev/i2c-eive";
 
 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_SYRLINKS_DEV[] = "/dev/ul_syrlinks";
-static constexpr char UART_STAR_TRACKER_DEV[] = "/dev/ul_str";
-static constexpr char UART_SCEX_DEV[] = "/dev/scex";
+static constexpr char UART_PLOC_MPSOC_DEV[] = "/dev/ul-plmpsoc";
+static constexpr char UART_PLOC_SUPERVSIOR_DEV[] = "/dev/ul-plsv";
+static constexpr char UART_SYRLINKS_DEV[] = "/dev/ul-syrlinks";
+static constexpr char UART_STAR_TRACKER_DEV[] = "/dev/ul-str";
 
-static constexpr char UIO_PDEC_REGISTERS[] = "/dev/uio_pdec_regs";
-static constexpr char UIO_PTME[] = "/dev/uio_ptme";
-static constexpr char UIO_PDEC_CONFIG_MEMORY[] = "/dev/uio_pdec_cfg_mem";
-static constexpr char UIO_PDEC_RAM[] = "/dev/uio_pdec_ram";
-static constexpr char UIO_PDEC_IRQ[] = "/dev/uio_pdec_irq";
+static constexpr char UIO_PDEC_REGISTERS[] = "/dev/uio0";
+static constexpr char UIO_PTME[] = "/dev/uio1";
+static constexpr char UIO_PDEC_CONFIG_MEMORY[] = "/dev/uio2";
+static constexpr char UIO_PDEC_RAM[] = "/dev/uio3";
 static constexpr int MAP_ID_PTME_CONFIG = 3;
 
 namespace uiomapids {
-// Live TM
 static const int PTME_VC0 = 0;
-// OK/NOK/MISC Store
 static const int PTME_VC1 = 1;
-// HK store
 static const int PTME_VC2 = 2;
-// CFDP
 static const int PTME_VC3 = 3;
 static const int PTME_CONFIG = 4;
 }  // namespace uiomapids

bsp_q7s/boardconfig/q7sConfig.h.in

@@ -16,8 +16,18 @@
 /** Other flags                                                    */
 /*******************************************************************/
 
+#define Q7S_SD_NONE                                 0
+#define Q7S_SD_COLD_REDUNDANT                       1
+#define Q7S_SD_HOT_REDUNDANT                        2
+// The OBSW will perform different actions to set up the SD cards depending on the flag set here
+// Set to Q7S_SD_NONE: Don't do anything
+// Set to Q7S_COLD_REDUNDANT: On startup, get the prefered SD card, turn it on and mount it, and 
+//     turn off the second SD card if it is on
+// Set to Q7S_HOT_REDUNDANT: On startup, turn on both SD cards and mount them  
+#define Q7S_SD_CARD_CONFIG                          Q7S_SD_COLD_REDUNDANT
+
 // Probably better if this is disabled for mission code. Convenient for development
-#define Q7S_CHECK_FOR_ALREADY_RUNNING_IMG           @Q7S_CHECK_FOR_ALREADY_RUNNING_IMG@
+#define Q7S_CHECK_FOR_ALREADY_RUNNING_IMG           1
 
 #define Q7S_SIMPLE_ADD_FILE_SYSTEM_TEST             0
 

bsp_q7s/boardtest/CMakeLists.txt

@@ -1,4 +1,4 @@
-target_sources(${OBSW_NAME} PRIVATE FileSystemTest.cpp Q7STestTask.cpp)
+target_sources(${OBSW_NAME} PUBLIC FileSystemTest.cpp Q7STestTask.cpp)
 
 if(EIVE_BUILD_Q7S_SIMPLE_MODE)
   target_sources(${SIMPLE_OBSW_NAME} PRIVATE FileSystemTest.cpp)

bsp_q7s/boardtest/Q7STestTask.cpp

@@ -1,14 +1,11 @@
 #include "Q7STestTask.h"
 
 #include <bsp_q7s/core/CoreController.h>
+#include <bsp_q7s/memory/FileSystemHandler.h>
 #include <bsp_q7s/xadc/Xadc.h>
-#include <fsfw/globalfunctions/arrayprinter.h>
 #include <fsfw/objectmanager/ObjectManager.h>
-#include <fsfw_hal/host/HostFilesystem.h>
 #include <gps.h>
 #include <libgpsmm.h>
-#include <param/param_string.h>
-#include <param/rparam_client.h>
 
 #include <cstdio>
 #include <ctime>
@@ -17,17 +14,12 @@
 #include <iostream>
 #include <nlohmann/json.hpp>
 
-#include "OBSWConfig.h"
-#include "bsp_q7s/fs/SdCardManager.h"
-#include "bsp_q7s/fs/helpers.h"
+#include "bsp_q7s/memory/SdCardManager.h"
 #include "bsp_q7s/memory/scratchApi.h"
 #include "fsfw/tasks/TaskFactory.h"
 #include "fsfw/timemanager/Stopwatch.h"
-#include "p60pdu.h"
 #include "test/DummyParameter.h"
 
-using namespace returnvalue;
-
 Q7STestTask::Q7STestTask(object_id_t objectId) : TestTask(objectId) {
   doTestSdCard = false;
   doTestScratchApi = false;
@@ -43,42 +35,13 @@ ReturnValue_t Q7STestTask::performOneShotAction() {
   if (doTestScratchApi) {
     testScratchApi();
   }
-  if (DO_TEST_GOMSPACE_API) {
-    uint8_t p60pdu_node = 3;
-    uint8_t hk_mem[P60PDU_HK_SIZE];
-    param_index_t p60pdu_hk{};
-    p60pdu_hk.physaddr = hk_mem;
-    if (!p60pdu_get_hk(&p60pdu_hk, p60pdu_node, 1000)) {
-      printf("Error getting p60pdu hk\n");
-    } else {
-      param_list(&p60pdu_hk, 1);
-    }
-  }
-
-  if (DO_TEST_GOMSPACE_GET_CONFIG) {
-    uint8_t p60pdu_node = 3;
-    param_index_t requestStruct{};
-    requestStruct.table = p60pdu_config;
-    requestStruct.mem_id = P60PDU_PARAM;
-    uint8_t hk_mem[P60PDU_PARAM_SIZE];
-    requestStruct.count = p60pdu_config_count;
-    requestStruct.size = P60PDU_PARAM_SIZE;
-    requestStruct.physaddr = hk_mem;
-    int result = rparam_get_full_table(&requestStruct, p60pdu_node, P60_PORT_RPARAM,
-                                       requestStruct.mem_id, 1000);
-    param_list(&requestStruct, 1);
-    return (result == 0);
-  }
-
   // testJsonLibDirect();
   // testDummyParams();
   if (doTestProtHandler) {
     testProtHandler();
   }
-  if (DO_TEST_FS_HANDLER) {
-    FsOpCodes opCode = FsOpCodes::CREATE_EMPTY_FILE_IN_TMP;
-    testFileSystemHandlerDirect(opCode);
-  }
+  FsOpCodes opCode = FsOpCodes::APPEND_TO_FILE;
+  testFileSystemHandlerDirect(opCode);
   return TestTask::performOneShotAction();
 }
 
@@ -132,23 +95,23 @@ void Q7STestTask::fileTests() {
 
 void Q7STestTask::testScratchApi() {
   ReturnValue_t result = scratch::writeNumber("TEST", 1);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::debug << "Q7STestTask::scratchApiTest: Writing number failed" << std::endl;
   }
   int number = 0;
   result = scratch::readNumber("TEST", number);
   sif::info << "Q7STestTask::testScratchApi: Value for key \"TEST\": " << number << std::endl;
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::debug << "Q7STestTask::scratchApiTest: Reading number failed" << std::endl;
   }
 
   result = scratch::writeString("TEST2", "halloWelt");
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::debug << "Q7STestTask::scratchApiTest: Writing string failed" << std::endl;
   }
   std::string string;
   result = scratch::readString("TEST2", string);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::debug << "Q7STestTask::scratchApiTest: Reading number failed" << std::endl;
   }
   sif::info << "Q7STestTask::testScratchApi: Value for key \"TEST2\": " << string << std::endl;
@@ -180,7 +143,7 @@ void Q7STestTask::testDummyParams() {
   }
 
   ReturnValue_t result = param.readJsonFile();
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
   }
 
   param.setValue(DummyParameter::DUMMY_KEY_PARAM_1, 3);
@@ -191,13 +154,13 @@ void Q7STestTask::testDummyParams() {
 
   int test = 0;
   result = param.getValue<int>(DummyParameter::DUMMY_KEY_PARAM_1, test);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::warning << "Q7STestTask::testDummyParams: Key " << DummyParameter::DUMMY_KEY_PARAM_1
                  << " does not exist" << std::endl;
   }
   std::string test2;
   result = param.getValue<std::string>(DummyParameter::DUMMY_KEY_PARAM_2, test2);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::warning << "Q7STestTask::testDummyParams: Key " << DummyParameter::DUMMY_KEY_PARAM_1
                  << " does not exist" << std::endl;
   }
@@ -216,18 +179,18 @@ ReturnValue_t Q7STestTask::initialize() {
 
 void Q7STestTask::testProtHandler() {
   bool opPerformed = false;
-  ReturnValue_t result = returnvalue::OK;
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
   // If any chips are unlocked, lock them here
   result = coreController->setBootCopyProtection(xsc::Chip::ALL_CHIP, xsc::Copy::ALL_COPY, true,
                                                  opPerformed, true);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_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);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::warning << "Q7STestTask::testProtHandler: Op failed" << std::endl;
   }
   if (not opPerformed) {
@@ -241,7 +204,7 @@ void Q7STestTask::testProtHandler() {
   // lock own copy
   result = coreController->setBootCopyProtection(xsc::Chip::SELF_CHIP, xsc::Copy::SELF_COPY, true,
                                                  opPerformed, true);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::warning << "Q7STestTask::testProtHandler: Op failed" << std::endl;
   }
   if (not opPerformed) {
@@ -255,7 +218,7 @@ void Q7STestTask::testProtHandler() {
   // unlock specific copy
   result = coreController->setBootCopyProtection(xsc::Chip::CHIP_1, xsc::Copy::COPY_1, false,
                                                  opPerformed, true);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::warning << "Q7STestTask::testProtHandler: Op failed" << std::endl;
   }
   if (not opPerformed) {
@@ -269,7 +232,7 @@ void Q7STestTask::testProtHandler() {
   // lock specific copy
   result = coreController->setBootCopyProtection(xsc::Chip::CHIP_1, xsc::Copy::COPY_1, true,
                                                  opPerformed, true);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::warning << "Q7STestTask::testProtHandler: Op failed" << std::endl;
   }
   if (not opPerformed) {
@@ -372,28 +335,150 @@ void Q7STestTask::testGpsDaemonSocket() {
 }
 
 void Q7STestTask::testFileSystemHandlerDirect(FsOpCodes opCode) {
-  HostFilesystem hostFs;
-  auto* sdcMan = SdCardManager::instance();
-  std::string mountPrefix = sdcMan->getCurrentMountPrefix();
-  sif::info << "Current mount prefix: " << mountPrefix << std::endl;
-  auto prefixedPath = fshelpers::getPrefixedPath(*sdcMan, "conf/test.txt");
-  sif::info << "Prefixed path: " << prefixedPath << std::endl;
-  if (opCode == FsOpCodes::CREATE_EMPTY_FILE_IN_TMP) {
-    FilesystemParams params("/tmp/hello.txt");
-    auto res = hostFs.createFile(params);
-    if (res != OK) {
-      sif::warning << "Creating empty file in /tmp failed" << std::endl;
+  auto fsHandler = ObjectManager::instance()->get<FileSystemHandler>(objects::FILE_SYSTEM_HANDLER);
+  if (fsHandler == nullptr) {
+    sif::warning << "Q7STestTask::testFileSystemHandlerDirect: No FS handler running.."
+                 << std::endl;
+  }
+  FileSystemHandler::FsCommandCfg cfg = {};
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+
+  // Lambda for common code
+  auto createNonEmptyTmpDir = [&]() {
+    if (not std::filesystem::exists("/tmp/test")) {
+      result = fsHandler->createDirectory("/tmp", "test", false, &cfg);
+      if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+      }
     }
-    bool fileExists = std::filesystem::exists("/tmp/hello.txt");
-    if (not fileExists) {
-      sif::warning << "File was not created!" << std::endl;
+    // Creating sample files
+    sif::info << "Creating sample files in directory" << std::endl;
+    result = fsHandler->createFile("/tmp/test", "test1.txt", nullptr, 0, &cfg);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      return result;
+    }
+    result = fsHandler->createFile("/tmp/test", "test2.txt", nullptr, 0, &cfg);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      return result;
+    }
+    return result;
+  };
+
+  switch (opCode) {
+    case (FsOpCodes::CREATE_EMPTY_FILE_IN_TMP): {
+      // No mount prefix, cause file is created in tmp
+      cfg.useMountPrefix = false;
+      sif::info << "Creating empty file in /tmp folder" << std::endl;
+      // Do not delete file, user can check existence in shell
+      fsHandler->createFile("/tmp/", "test.txt", nullptr, 0, &cfg);
+      break;
+    }
+    case (FsOpCodes::REMOVE_TMP_FILE): {
+      sif::info << "Deleting /tmp/test.txt sample file" << std::endl;
+      // No mount prefix, cause file is created in tmp
+      cfg.useMountPrefix = false;
+      if (not std::filesystem::exists("/tmp/test.txt")) {
+        // Creating sample file
+        sif::info << "Creating sample file /tmp/test.txt to delete" << std::endl;
+        fsHandler->createFile("/tmp/", "test.txt", nullptr, 0, &cfg);
+      }
+      result = fsHandler->removeFile("/tmp", "test.txt", &cfg);
+      if (result == HasReturnvaluesIF::RETURN_OK) {
+        sif::info << "File removed successfully" << std::endl;
+      } else {
+        sif::warning << "File removal failed!" << std::endl;
+      }
+      break;
+    }
+    case (FsOpCodes::CREATE_DIR_IN_TMP): {
+      // No mount prefix, cause file is created in tmp
+      cfg.useMountPrefix = false;
+      sif::info << "Creating empty file in /tmp folder" << std::endl;
+      // Do not delete file, user can check existence in shell
+      ReturnValue_t result = fsHandler->createDirectory("/tmp/", "test", false, &cfg);
+      if (result == HasReturnvaluesIF::RETURN_OK) {
+        sif::info << "Directory created successfully" << std::endl;
+      } else {
+        sif::warning << "Directory creation failed!" << std::endl;
+      }
+      break;
+    }
+    case (FsOpCodes::REMOVE_EMPTY_DIR_IN_TMP): {
+      // No mount prefix, cause file is created in tmp
+      cfg.useMountPrefix = false;
+      if (not std::filesystem::exists("/tmp/test")) {
+        result = fsHandler->createDirectory("/tmp", "test", false, &cfg);
+      } else {
+        // Delete any leftover files to regular dir removal works
+        std::remove("/tmp/test/*");
+      }
+      result = fsHandler->removeDirectory("/tmp/", "test", false, &cfg);
+      if (result == HasReturnvaluesIF::RETURN_OK) {
+        sif::info << "Directory removed successfully" << std::endl;
+      } else {
+        sif::warning << "Directory removal failed!" << std::endl;
+      }
+      break;
+    }
+    case (FsOpCodes::REMOVE_FILLED_DIR_IN_TMP): {
+      result = createNonEmptyTmpDir();
+      if (result != HasReturnvaluesIF::RETURN_OK) {
+        return;
+      }
+      result = fsHandler->removeDirectory("/tmp/", "test", true, &cfg);
+      if (result == HasReturnvaluesIF::RETURN_OK) {
+        sif::info << "Directory removed recursively successfully" << std::endl;
+      } else {
+        sif::warning << "Recursive directory removal failed!" << std::endl;
+      }
+      break;
+    }
+    case (FsOpCodes::ATTEMPT_DIR_REMOVAL_NON_EMPTY): {
+      result = createNonEmptyTmpDir();
+      if (result != HasReturnvaluesIF::RETURN_OK) {
+        return;
+      }
+      result = fsHandler->removeDirectory("/tmp/", "test", false, &cfg);
+      if (result != HasReturnvaluesIF::RETURN_OK) {
+        sif::info << "Directory removal attempt failed as expected" << std::endl;
+      } else {
+        sif::warning << "Directory removal worked when it should not have!" << std::endl;
+      }
+      break;
+    }
+    case (FsOpCodes::RENAME_FILE): {
+      // No mount prefix, cause file is created in tmp
+      cfg.useMountPrefix = false;
+      if (std::filesystem::exists("/tmp/test.txt")) {
+        fsHandler->removeDirectory("/tmp/", "test", false, &cfg);
+      }
+      sif::info << "Creating empty file /tmp/test.txt and rename to /tmp/test2.txt" << std::endl;
+      // Do not delete file, user can check existence in shell
+      fsHandler->createFile("/tmp/", "test.txt", nullptr, 0, &cfg);
+      fsHandler->renameFile("/tmp/", "test.txt", "test2.txt", &cfg);
+      break;
+    }
+    case (FsOpCodes::APPEND_TO_FILE): {
+      // No mount prefix, cause file is created in tmp
+      cfg.useMountPrefix = false;
+      if (std::filesystem::exists("/tmp/test.txt")) {
+        fsHandler->removeDirectory("/tmp/", "test", false, &cfg);
+      }
+      if (std::filesystem::exists("/tmp/test.txt")) {
+        fsHandler->removeDirectory("/tmp/", "test", false, &cfg);
+      }
+      sif::info << "Creating empty file /tmp/test.txt and adding content" << std::endl;
+      std::string content = "Hello World\n";
+      // Do not delete file, user can check existence in shell
+      fsHandler->createFile("/tmp/", "test.txt", nullptr, 0, &cfg);
+      fsHandler->appendToFile("/tmp/", "test.txt", reinterpret_cast<const uint8_t*>(content.data()),
+                              content.size(), 0, &cfg);
     }
-    hostFs.removeFile("/tmp/hello.txt");
   }
 }
 
 void Q7STestTask::xadcTest() {
-  ReturnValue_t result = returnvalue::OK;
+  ReturnValue_t result = RETURN_OK;
   float temperature = 0;
   float vccPint = 0;
   float vccPaux = 0;
@@ -405,39 +490,39 @@ void Q7STestTask::xadcTest() {
   float vrefn = 0;
   Xadc xadc;
   result = xadc.getTemperature(temperature);
-  if (result == returnvalue::OK) {
+  if (result == HasReturnvaluesIF::RETURN_OK) {
     sif::info << "Q7STestTask::xadcTest: Chip Temperature: " << temperature << " °C" << std::endl;
   }
   result = xadc.getVccPint(vccPint);
-  if (result == returnvalue::OK) {
+  if (result == HasReturnvaluesIF::RETURN_OK) {
     sif::info << "Q7STestTask::xadcTest: VCC PS internal: " << vccPint << " mV" << std::endl;
   }
   result = xadc.getVccPaux(vccPaux);
-  if (result == returnvalue::OK) {
+  if (result == HasReturnvaluesIF::RETURN_OK) {
     sif::info << "Q7STestTask::xadcTest: VCC PS auxilliary: " << vccPaux << " mV" << std::endl;
   }
   result = xadc.getVccInt(vccInt);
-  if (result == returnvalue::OK) {
+  if (result == HasReturnvaluesIF::RETURN_OK) {
     sif::info << "Q7STestTask::xadcTest: VCC PL internal: " << vccInt << " mV" << std::endl;
   }
   result = xadc.getVccAux(vccAux);
-  if (result == returnvalue::OK) {
+  if (result == HasReturnvaluesIF::RETURN_OK) {
     sif::info << "Q7STestTask::xadcTest: VCC PL auxilliary: " << vccAux << " mV" << std::endl;
   }
   result = xadc.getVccBram(vccBram);
-  if (result == returnvalue::OK) {
+  if (result == HasReturnvaluesIF::RETURN_OK) {
     sif::info << "Q7STestTask::xadcTest: VCC BRAM: " << vccBram << " mV" << std::endl;
   }
   result = xadc.getVccOddr(vccOddr);
-  if (result == returnvalue::OK) {
+  if (result == HasReturnvaluesIF::RETURN_OK) {
     sif::info << "Q7STestTask::xadcTest: VCC PS I/O DDR : " << vccOddr << " mV" << std::endl;
   }
   result = xadc.getVrefp(vrefp);
-  if (result == returnvalue::OK) {
+  if (result == HasReturnvaluesIF::RETURN_OK) {
     sif::info << "Q7STestTask::xadcTest: Vrefp : " << vrefp << " mV" << std::endl;
   }
   result = xadc.getVrefn(vrefn);
-  if (result == returnvalue::OK) {
+  if (result == HasReturnvaluesIF::RETURN_OK) {
     sif::info << "Q7STestTask::xadcTest: Vrefn : " << vrefn << " mV" << std::endl;
   }
 }

bsp_q7s/boardtest/Q7STestTask.h

@@ -3,7 +3,7 @@
 
 #include <libgpsmm.h>
 
-#include "test/TestTask.h"
+#include "test/testtasks/TestTask.h"
 
 class CoreController;
 
@@ -16,9 +16,6 @@ class Q7STestTask : public TestTask {
  private:
   bool doTestSdCard = false;
   bool doTestScratchApi = false;
-  static constexpr bool DO_TEST_GOMSPACE_API = false;
-  static constexpr bool DO_TEST_GOMSPACE_GET_CONFIG = false;
-  static constexpr bool DO_TEST_FS_HANDLER = false;
   bool doTestGpsShm = false;
   bool doTestGpsSocket = false;
   bool doTestProtHandler = false;

bsp_q7s/callbacks/gnssCallback.cpp

@@ -4,26 +4,20 @@
 #include "fsfw/action/HasActionsIF.h"
 #include "fsfw/tasks/TaskFactory.h"
 
-ReturnValue_t gps::triggerGpioResetPin(const uint8_t* actionData, size_t len, void* args) {
-  // At least one byte which denotes which GPS to reset is required
-  if (len < 1 or actionData == nullptr) {
-    return HasActionsIF::INVALID_PARAMETERS;
-  }
+ReturnValue_t gps::triggerGpioResetPin(uint8_t gpsId, void* args) {
   ResetArgs* resetArgs = reinterpret_cast<ResetArgs*>(args);
   if (args == nullptr) {
-    return returnvalue::FAILED;
+    return HasReturnvaluesIF::RETURN_FAILED;
   }
   if (resetArgs->gpioComIF == nullptr) {
-    return returnvalue::FAILED;
+    return HasReturnvaluesIF::RETURN_FAILED;
   }
-  gpioId_t gpioId;
-  if (actionData[0] == 0) {
-    gpioId = gpioIds::GNSS_0_NRESET;
-  } else {
+  gpioId_t gpioId = gpioIds::GNSS_0_NRESET;
+  if (gpsId == 1) {
     gpioId = gpioIds::GNSS_1_NRESET;
   }
   resetArgs->gpioComIF->pullLow(gpioId);
   TaskFactory::delayTask(resetArgs->waitPeriodMs);
   resetArgs->gpioComIF->pullHigh(gpioId);
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }

bsp_q7s/callbacks/gnssCallback.h

@@ -1,7 +1,7 @@
 #ifndef BSP_Q7S_CALLBACKS_GNSSCALLBACK_H_
 #define BSP_Q7S_CALLBACKS_GNSSCALLBACK_H_
 
-#include "fsfw/returnvalues/returnvalue.h"
+#include "fsfw/returnvalues/HasReturnvaluesIF.h"
 #include "fsfw_hal/linux/gpio/LinuxLibgpioIF.h"
 
 struct ResetArgs {
@@ -11,7 +11,7 @@ struct ResetArgs {
 
 namespace gps {
 
-ReturnValue_t triggerGpioResetPin(const uint8_t* actionData, size_t len, void* args);
+ReturnValue_t triggerGpioResetPin(uint8_t gpsId, void* args);
 
 }
 

bsp_q7s/callbacks/q7sGpioCallbacks.cpp

@@ -47,7 +47,7 @@ void q7s::gpioCallbacks::initSpiCsDecoder(GpioIF* gpioComIF) {
   spiMuxGpios->addGpio(gpioIds::EN_RW_CS, enRwDecoder);
 
   result = gpioComIF->addGpios(spiMuxGpios);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::error << "initSpiCsDecoder: Failed to add SPI MUX bit GPIOs" << std::endl;
     return;
   }

bsp_q7s/callbacks/rwSpiCallback.cpp

@@ -29,32 +29,32 @@ void closeSpi(int fd, gpioId_t gpioId, GpioIF* gpioIF, MutexIF* mutex);
 ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie* cookie, const uint8_t* sendData,
                           size_t sendLen, void* args) {
   // Stopwatch watch;
-  ReturnValue_t result = returnvalue::OK;
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 
   RwHandler* handler = reinterpret_cast<RwHandler*>(args);
   if (handler == nullptr) {
     sif::error << "rwSpiCallback::spiCallback: Pointer to handler is invalid" << std::endl;
-    return returnvalue::FAILED;
+    return HasReturnvaluesIF::RETURN_FAILED;
   }
 
   uint8_t writeBuffer[2] = {};
   uint8_t writeSize = 0;
 
   gpioId_t gpioId = cookie->getChipSelectPin();
-  GpioIF& gpioIF = comIf->getGpioInterface();
+  GpioIF* gpioIF = comIf->getGpioInterface();
   MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
   uint32_t timeoutMs = 0;
   MutexIF* mutex = comIf->getCsMutex();
   cookie->getMutexParams(timeoutType, timeoutMs);
-  if (mutex == nullptr) {
+  if (mutex == nullptr or gpioIF == nullptr) {
     sif::debug << "rwSpiCallback::spiCallback: Mutex or GPIO interface invalid" << std::endl;
-    return returnvalue::FAILED;
+    return HasReturnvaluesIF::RETURN_FAILED;
   }
 
   int fileDescriptor = 0;
   const std::string& dev = comIf->getSpiDev();
-  result = openSpi(dev, O_RDWR, &gpioIF, gpioId, mutex, timeoutType, timeoutMs, fileDescriptor);
-  if (result != returnvalue::OK) {
+  result = openSpi(dev, O_RDWR, gpioIF, gpioId, mutex, timeoutType, timeoutMs, fileDescriptor);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     return result;
   }
 
@@ -75,8 +75,8 @@ ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie* cookie, const uint8_t* sen
 
   if (write(fileDescriptor, writeBuffer, writeSize) != static_cast<ssize_t>(writeSize)) {
     sif::error << "rwSpiCallback::spiCallback: Write failed!" << std::endl;
-    closeSpi(fileDescriptor, gpioId, &gpioIF, mutex);
-    return rws::SPI_WRITE_FAILURE;
+    closeSpi(fileDescriptor, gpioId, gpioIF, mutex);
+    return RwHandler::SPI_WRITE_FAILURE;
   }
 
   /** Encoding and sending command */
@@ -100,8 +100,8 @@ ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie* cookie, const uint8_t* sen
     }
     if (write(fileDescriptor, writeBuffer, writeSize) != static_cast<ssize_t>(writeSize)) {
       sif::error << "rwSpiCallback::spiCallback: Write failed!" << std::endl;
-      closeSpi(fileDescriptor, gpioId, &gpioIF, mutex);
-      return rws::SPI_WRITE_FAILURE;
+      closeSpi(fileDescriptor, gpioId, gpioIF, mutex);
+      return RwHandler::SPI_WRITE_FAILURE;
     }
     idx++;
   }
@@ -112,14 +112,14 @@ ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie* cookie, const uint8_t* sen
 
   if (write(fileDescriptor, writeBuffer, writeSize) != static_cast<ssize_t>(writeSize)) {
     sif::error << "rwSpiCallback::spiCallback: Write failed!" << std::endl;
-    closeSpi(fileDescriptor, gpioId, &gpioIF, mutex);
-    return rws::SPI_WRITE_FAILURE;
+    closeSpi(fileDescriptor, gpioId, gpioIF, mutex);
+    return RwHandler::SPI_WRITE_FAILURE;
   }
 
   uint8_t* rxBuf = nullptr;
   result = comIf->getReadBuffer(cookie->getSpiAddress(), &rxBuf);
-  if (result != returnvalue::OK) {
-    closeSpi(fileDescriptor, gpioId, &gpioIF, mutex);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    closeSpi(fileDescriptor, gpioId, gpioIF, mutex);
     return result;
   }
 
@@ -127,10 +127,10 @@ ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie* cookie, const uint8_t* sen
 
   // There must be a delay of at least 20 ms after sending the command.
   // Delay for 70 ms here and release the SPI bus for that duration.
-  closeSpi(fileDescriptor, gpioId, &gpioIF, mutex);
-  usleep(rws::SPI_REPLY_DELAY);
-  result = openSpi(dev, O_RDWR, &gpioIF, gpioId, mutex, timeoutType, timeoutMs, fileDescriptor);
-  if (result != returnvalue::OK) {
+  closeSpi(fileDescriptor, gpioId, gpioIF, mutex);
+  usleep(RwDefinitions::SPI_REPLY_DELAY);
+  result = openSpi(dev, O_RDWR, gpioIF, gpioId, mutex, timeoutType, timeoutMs, fileDescriptor);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     return result;
   }
 
@@ -139,17 +139,17 @@ ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie* cookie, const uint8_t* sen
    * However, receiving more than 5 empty frames will be interpreted as an error.
    */
   uint8_t byteRead = 0;
-  for (idx = 0; idx < 10; idx++) {
+  for (int idx = 0; idx < 10; idx++) {
     if (read(fileDescriptor, &byteRead, 1) != 1) {
       sif::error << "rwSpiCallback::spiCallback: Read failed" << std::endl;
-      closeSpi(fileDescriptor, gpioId, &gpioIF, mutex);
-      return rws::SPI_READ_FAILURE;
+      closeSpi(fileDescriptor, gpioId, gpioIF, mutex);
+      return RwHandler::SPI_READ_FAILURE;
     }
     if (idx == 0) {
       if (byteRead != FLAG_BYTE) {
         sif::error << "Invalid data, expected start marker" << std::endl;
-        closeSpi(fileDescriptor, gpioId, &gpioIF, mutex);
-        return rws::NO_START_MARKER;
+        closeSpi(fileDescriptor, gpioId, gpioIF, mutex);
+        return RwHandler::NO_START_MARKER;
       }
     }
 
@@ -159,8 +159,8 @@ ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie* cookie, const uint8_t* sen
 
     if (idx == 9) {
       sif::error << "rwSpiCallback::spiCallback: Empty frame timeout" << std::endl;
-      closeSpi(fileDescriptor, gpioId, &gpioIF, mutex);
-      return rws::NO_REPLY;
+      closeSpi(fileDescriptor, gpioId, gpioIF, mutex);
+      return RwHandler::NO_REPLY;
     }
   }
 
@@ -175,7 +175,7 @@ ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie* cookie, const uint8_t* sen
       byteRead = 0;
       if (read(fileDescriptor, &byteRead, 1) != 1) {
         sif::error << "rwSpiCallback::spiCallback: Read failed" << std::endl;
-        result = rws::SPI_READ_FAILURE;
+        result = RwHandler::SPI_READ_FAILURE;
         break;
       }
     }
@@ -186,7 +186,7 @@ ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie* cookie, const uint8_t* sen
     } else if (byteRead == 0x7D) {
       if (read(fileDescriptor, &byteRead, 1) != 1) {
         sif::error << "rwSpiCallback::spiCallback: Read failed" << std::endl;
-        result = rws::SPI_READ_FAILURE;
+        result = RwHandler::SPI_READ_FAILURE;
         break;
       }
       if (byteRead == 0x5E) {
@@ -199,8 +199,8 @@ ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie* cookie, const uint8_t* sen
         continue;
       } else {
         sif::error << "rwSpiCallback::spiCallback: Invalid substitute" << std::endl;
-        closeSpi(fileDescriptor, gpioId, &gpioIF, mutex);
-        result = rws::INVALID_SUBSTITUTE;
+        closeSpi(fileDescriptor, gpioId, gpioIF, mutex);
+        result = RwHandler::INVALID_SUBSTITUTE;
         break;
       }
     } else {
@@ -217,23 +217,23 @@ ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie* cookie, const uint8_t* sen
     if (decodedFrameLen == replyBufferSize) {
       if (read(fileDescriptor, &byteRead, 1) != 1) {
         sif::error << "rwSpiCallback::spiCallback: Failed to read last byte" << std::endl;
-        result = rws::SPI_READ_FAILURE;
+        result = RwHandler::SPI_READ_FAILURE;
         break;
       }
       if (byteRead != FLAG_BYTE) {
         sif::error << "rwSpiCallback::spiCallback: Missing end sign " << static_cast<int>(FLAG_BYTE)
                    << std::endl;
         decodedFrameLen--;
-        result = rws::MISSING_END_SIGN;
+        result = RwHandler::MISSING_END_SIGN;
         break;
       }
     }
-    result = returnvalue::OK;
+    result = HasReturnvaluesIF::RETURN_OK;
   }
 
   cookie->setTransferSize(decodedFrameLen);
 
-  closeSpi(fileDescriptor, gpioId, &gpioIF, mutex);
+  closeSpi(fileDescriptor, gpioId, gpioIF, mutex);
 
   return result;
 }
@@ -244,7 +244,7 @@ ReturnValue_t openSpi(const std::string& devname, int flags, GpioIF* gpioIF, gpi
                       MutexIF* mutex, MutexIF::TimeoutType timeoutType, uint32_t timeoutMs,
                       int& fd) {
   ReturnValue_t result = mutex->lockMutex(timeoutType, timeoutMs);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::debug << "rwSpiCallback::spiCallback: Failed to lock mutex" << std::endl;
     return result;
   }
@@ -258,21 +258,21 @@ ReturnValue_t openSpi(const std::string& devname, int flags, GpioIF* gpioIF, gpi
   // Pull SPI CS low. For now, no support for active high given
   if (gpioId != gpio::NO_GPIO) {
     result = gpioIF->pullLow(gpioId);
-    if (result != returnvalue::OK) {
+    if (result != HasReturnvaluesIF::RETURN_OK) {
       sif::error << "rwSpiCallback::spiCallback: Failed to pull chip select low" << std::endl;
       return result;
     }
   }
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 void closeSpi(int fd, gpioId_t gpioId, GpioIF* gpioIF, MutexIF* mutex) {
   close(fd);
   if (gpioId != gpio::NO_GPIO) {
-    if (gpioIF->pullHigh(gpioId) != returnvalue::OK) {
+    if (gpioIF->pullHigh(gpioId) != HasReturnvaluesIF::RETURN_OK) {
       sif::error << "closeSpi: Failed to pull chip select high" << std::endl;
     }
   }
-  if (mutex->unlockMutex() != returnvalue::OK) {
+  if (mutex->unlockMutex() != HasReturnvaluesIF::RETURN_OK) {
     sif::error << "rwSpiCallback::closeSpi: Failed to unlock mutex" << std::endl;
     ;
   }

bsp_q7s/callbacks/rwSpiCallback.h

@@ -1,7 +1,7 @@
 #ifndef BSP_Q7S_RW_SPI_CALLBACK_H_
 #define BSP_Q7S_RW_SPI_CALLBACK_H_
 
-#include "fsfw/returnvalues/returnvalue.h"
+#include "fsfw/returnvalues/HasReturnvaluesIF.h"
 #include "fsfw_hal/common/gpio/GpioCookie.h"
 #include "fsfw_hal/linux/spi/SpiComIF.h"
 

bsp_q7s/core/CMakeLists.txt

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

bsp_q7s/core/CoreActions.h

@@ -0,0 +1,87 @@
+#pragma once
+
+#include <fsfw/action/MinMaxParameter.h>
+#include <fsfw/action/TemplateAction.h>
+#include <fsfw/introspection/Enum.h>
+
+class CoreController;
+
+namespace core {
+
+FSFW_ENUM(ActionId, ActionId_t,
+          ((LIST_DIRECTORY_INTO_FILE, 0, "List Directory into file"))(
+              (SWITCH_REBOOT_FILE_HANDLING, 5,
+               "Switch Reboot File Handling"))((RESET_REBOOT_COUNTERS, 6, "Reset Boot Counters"))(
+              (SWITCH_IMG_LOCK, 7, "Switch Image Lock"))((SET_MAX_REBOOT_CNT, 8,
+                                                          "Set maximum reboot Count"))(
+              (XSC_REBOOT_OBC, 32, "Reboot using the xsc_boot_copy command"))(
+              (MOUNT_OTHER_COPY, 33, "Mount Other Copy"))((REBOOT_OBC, 34,
+                                                           "Reboot using the reboot command")))
+
+FSFW_ENUM(Boolenum, uint8_t, ((NO, 0, "NO"))((YES, 1, "Yes")))
+
+class ListDirectoryIntoFileAction
+    : public TemplateAction<CoreController, ListDirectoryIntoFileAction, ActionId> {
+ public:
+  ListDirectoryIntoFileAction(CoreController *owner)
+      : TemplateAction(owner, ActionId::LIST_DIRECTORY_INTO_FILE){};
+};
+
+class SwitchRebootFileHandlingAction
+    : public TemplateAction<CoreController, SwitchRebootFileHandlingAction, ActionId> {
+ public:
+  SwitchRebootFileHandlingAction(CoreController *owner)
+      : TemplateAction(owner, ActionId::SWITCH_REBOOT_FILE_HANDLING){};
+
+  Parameter<Boolenum> enableRebootFile =
+      Parameter<Boolenum>::createParameter(this, "Enable Reboot File");
+};
+
+class ResetRebootCountersAction
+    : public TemplateAction<CoreController, ResetRebootCountersAction, ActionId> {
+ public:
+  FSFW_ENUM(Selection, uint8_t, ((ZERO, "0"))((ONE, "1"))((ALL, "All")))
+
+  ResetRebootCountersAction(CoreController *owner)
+      : TemplateAction(owner, ActionId::RESET_REBOOT_COUNTERS){};
+
+  Parameter<Selection> chip = Parameter<Selection>::createParameter(this, "Chip");
+  Parameter<Selection> copy = Parameter<Selection>::createParameter(this, "Copy");
+};
+
+class SwitchImageLockAction
+    : public TemplateAction<CoreController, SwitchImageLockAction, ActionId> {
+ public:
+  FSFW_ENUM(Selection, uint8_t, ((ZERO, "0"))((ONE, "1")))
+
+  SwitchImageLockAction(CoreController *owner) : TemplateAction(owner, ActionId::SWITCH_IMG_LOCK){};
+
+  Parameter<Boolenum> lock = Parameter<Boolenum>::createParameter(this, "Lock Image");
+  Parameter<Selection> chip = Parameter<Selection>::createParameter(this, "Chip");
+  Parameter<Selection> copy = Parameter<Selection>::createParameter(this, "Copy");
+};
+
+class SetMaxRebootCntAction
+    : public TemplateAction<CoreController, SetMaxRebootCntAction, ActionId> {
+ public:
+  SetMaxRebootCntAction(CoreController *owner)
+      : TemplateAction(owner, ActionId::SET_MAX_REBOOT_CNT){};
+
+    Parameter<uint8_t> maxCount = Parameter<uint8_t>::createParameter(this, "Count");
+};
+
+class XscRebootObcAction : public TemplateAction<CoreController, XscRebootObcAction, ActionId> {
+ public:
+  FSFW_ENUM(Selection, uint8_t, ((ZERO, "0"))((ONE, "1"))((SAME, "Same")))
+  XscRebootObcAction(CoreController *owner) : TemplateAction(owner, ActionId::XSC_REBOOT_OBC){};
+
+  Parameter<Selection> chip = Parameter<Selection>::createParameter(this, "Chip");
+  Parameter<Selection> copy = Parameter<Selection>::createParameter(this, "Copy");
+};
+
+class RebootObcAction : public TemplateAction<CoreController, RebootObcAction, ActionId> {
+ public:
+  RebootObcAction(CoreController *owner) : TemplateAction(owner, ActionId::REBOOT_OBC){};
+};
+
+}  // namespace core

bsp_q7s/core/CoreController.h

@@ -1,20 +1,17 @@
 #ifndef BSP_Q7S_CORE_CORECONTROLLER_H_
 #define BSP_Q7S_CORE_CORECONTROLLER_H_
 
-#include <fsfw/container/DynamicFIFO.h>
-#include <fsfw/container/SimpleRingBuffer.h>
 #include <fsfw/globalfunctions/PeriodicOperationDivider.h>
 #include <libxiphos.h>
 
 #include <cstddef>
 
+#include "CoreActions.h"
 #include "CoreDefinitions.h"
-#include "OBSWConfig.h"
-#include "bsp_q7s/fs/SdCardManager.h"
+#include "bsp_q7s/memory/SdCardManager.h"
 #include "events/subsystemIdRanges.h"
 #include "fsfw/controller/ExtendedControllerBase.h"
 #include "mission/devices/devicedefinitions/GPSDefinitions.h"
-#include "mission/trace.h"
 
 class Timer;
 class SdCardManager;
@@ -55,59 +52,22 @@ class CoreController : public ExtendedControllerBase {
   static constexpr char CHIP_PROT_SCRIPT[] = "get-chip-prot-status.sh";
   static constexpr char CHIP_STATE_FILE[] = "/tmp/chip_prot_status.txt";
   static constexpr char CURR_COPY_FILE[] = "/tmp/curr_copy.txt";
-
   static constexpr char CONF_FOLDER[] = "conf";
-
   static constexpr char VERSION_FILE_NAME[] = "version.txt";
   static constexpr char REBOOT_FILE_NAME[] = "reboot.txt";
-  static constexpr char TIME_FILE_NAME[] = "time_backup.txt";
-
+  static constexpr char TIME_FILE_NAME[] = "time.txt";
   const std::string VERSION_FILE =
       "/" + std::string(CONF_FOLDER) + "/" + std::string(VERSION_FILE_NAME);
   const std::string REBOOT_FILE =
       "/" + std::string(CONF_FOLDER) + "/" + std::string(REBOOT_FILE_NAME);
-  const std::string BACKUP_TIME_FILE =
-      "/" + std::string(CONF_FOLDER) + "/" + std::string(TIME_FILE_NAME);
-
-  static constexpr char CHIP_0_COPY_0_MOUNT_DIR[] = "/tmp/mntupdate-xdi-qspi0-nom-rootfs";
-  static constexpr char CHIP_0_COPY_1_MOUNT_DIR[] = "/tmp/mntupdate-xdi-qspi0-gold-rootfs";
-  static constexpr char CHIP_1_COPY_0_MOUNT_DIR[] = "/tmp/mntupdate-xdi-qspi1-nom-rootfs";
-  static constexpr char CHIP_1_COPY_1_MOUNT_DIR[] = "/tmp/mntupdate-xdi-qspi1-gold-rootfs";
-
-  static constexpr dur_millis_t INIT_SD_CARD_CHECK_TIMEOUT = 5000;
-  static constexpr dur_millis_t DEFAULT_SD_CARD_CHECK_TIMEOUT = 60000;
-
-  static constexpr ActionId_t LIST_DIRECTORY_INTO_FILE = 0;
-  static constexpr ActionId_t ANNOUNCE_VERSION = 1;
-  static constexpr ActionId_t ANNOUNCE_CURRENT_IMAGE = 2;
-  static constexpr ActionId_t ANNOUNCE_BOOT_COUNTS = 3;
-  static constexpr ActionId_t SWITCH_REBOOT_FILE_HANDLING = 5;
-  static constexpr ActionId_t RESET_REBOOT_COUNTERS = 6;
-  static constexpr ActionId_t SWITCH_IMG_LOCK = 7;
-  static constexpr ActionId_t SET_MAX_REBOOT_CNT = 8;
-
-  static constexpr ActionId_t OBSW_UPDATE_FROM_SD_0 = 10;
-  static constexpr ActionId_t OBSW_UPDATE_FROM_SD_1 = 11;
-  static constexpr ActionId_t OBSW_UPDATE_FROM_TMP = 12;
-
-  static constexpr ActionId_t SWITCH_TO_SD_0 = 16;
-  static constexpr ActionId_t SWITCH_TO_SD_1 = 17;
-  static constexpr ActionId_t SWITCH_TO_BOTH_SD_CARDS = 18;
-
-  //! Reboot using the xsc_boot_copy command
-  static constexpr ActionId_t XSC_REBOOT_OBC = 32;
-  static constexpr ActionId_t MOUNT_OTHER_COPY = 33;
-  //! Reboot using the reboot command
-  static constexpr ActionId_t REBOOT_OBC = 34;
-
-  static constexpr ActionId_t EXECUTE_SHELL_CMD = 40;
+  const std::string TIME_FILE = "/" + std::string(CONF_FOLDER) + "/" + std::string(TIME_FILE_NAME);
 
   static constexpr uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::CORE;
 
   static constexpr Event ALLOC_FAILURE = event::makeEvent(SUBSYSTEM_ID, 0, severity::MEDIUM);
   //! [EXPORT] : [COMMENT]  Software reboot occurred. Can also be a systemd reboot.
   //! P1: Current Chip, P2: Current Copy
-  static constexpr Event REBOOT_SW = event::makeEvent(SUBSYSTEM_ID, 1, severity::LOW);
+  static constexpr Event REBOOT_SW = event::makeEvent(SUBSYSTEM_ID, 1, severity::MEDIUM);
   //! [EXPORT] : [COMMENT] The reboot mechanism was triggered.
   //! P1: First 16 bits: Last Chip, Last 16 bits: Last Copy,
   //! P2: Each byte is the respective reboot count for the slots
@@ -115,22 +75,6 @@ class CoreController : public ExtendedControllerBase {
       event::makeEvent(SUBSYSTEM_ID, 2, severity::MEDIUM);
   //! Trying to find a way how to determine that the reboot came from ProASIC3 or PCDU..
   static constexpr Event REBOOT_HW = event::makeEvent(SUBSYSTEM_ID, 3, severity::MEDIUM);
-  //! [EXPORT] : [COMMENT] No SD card was active. Core controller will attempt to re-initialize
-  //! a SD card.
-  static constexpr Event NO_SD_CARD_ACTIVE = event::makeEvent(SUBSYSTEM_ID, 4, severity::HIGH);
-  //! [EXPORT] : [COMMENT]
-  //! P1: Byte 0: Major, Byte 1: Minor, Byte 2: Patch, Byte 3: Has Git Hash
-  //! P2: First four letters of Git SHA is the last byte of P1 is set.
-  static constexpr Event VERSION_INFO = event::makeEvent(SUBSYSTEM_ID, 5, severity::INFO);
-  //! [EXPORT] : [COMMENT] P1: Current Chip, P2: Current Copy
-  static constexpr Event CURRENT_IMAGE_INFO = event::makeEvent(SUBSYSTEM_ID, 6, severity::INFO);
-  //! [EXPORT] : [COMMENT] Total reboot counter, which is the sum of the boot count of all
-  //! individual images.
-  static constexpr Event REBOOT_COUNTER = event::makeEvent(SUBSYSTEM_ID, 7, severity::INFO);
-  //! [EXPORT] : [COMMENT] Get the boot count of the individual images.
-  //! P1: First 16 bits boot count of image 0 0, last 16 bits boot count of image 0 1.
-  //! P2: First 16 bits boot count of image 1 0, last 16 bits boot count of image 1 1.
-  static constexpr Event INDIVIDUAL_BOOT_COUNTS = event::makeEvent(SUBSYSTEM_ID, 8, severity::INFO);
 
   CoreController(object_id_t objectId);
   virtual ~CoreController();
@@ -139,8 +83,17 @@ class CoreController : public ExtendedControllerBase {
 
   ReturnValue_t initializeAfterTaskCreation() override;
 
-  ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
-                              const uint8_t* data, size_t size) override;
+  ReturnValue_t executeAction(Action* action) override;
+
+  ReturnValue_t handleAction(core::ListDirectoryIntoFileAction* action);
+  ReturnValue_t handleAction(core::SwitchRebootFileHandlingAction* action);
+  ReturnValue_t handleAction(core::ResetRebootCountersAction* action);
+  ReturnValue_t handleAction(core::SwitchImageLockAction* action);
+  ReturnValue_t handleAction(core::SetMaxRebootCntAction* action);
+  ReturnValue_t handleAction(core::XscRebootObcAction* action);
+  ReturnValue_t handleAction(core::RebootObcAction* action);
+
+  ModeDefinitionHelper getModeDefinitionHelper() override;
 
   ReturnValue_t handleCommandMessage(CommandMessage* message) override;
   void performControlOperation() override;
@@ -152,7 +105,6 @@ class CoreController : public ExtendedControllerBase {
   static ReturnValue_t generateChipStateFile();
   static ReturnValue_t incrementAllocationFailureCount();
   static void getCurrentBootCopy(xsc::Chip& chip, xsc::Copy& copy);
-  static const char* getXscMountDir(xsc::Chip chip, xsc::Copy copy);
 
   ReturnValue_t updateProtInfo(bool regenerateChipStateFile = true);
 
@@ -173,9 +125,11 @@ class CoreController : public ExtendedControllerBase {
   bool sdInitFinished() const;
 
  private:
-  static constexpr uint32_t BOOT_OFFSET_SECONDS = 15;
   static constexpr MutexIF::TimeoutType TIMEOUT_TYPE = MutexIF::TimeoutType::WAITING;
   static constexpr uint32_t MUTEX_TIMEOUT = 20;
+  // Designated value for rechecking FIFO open
+  static constexpr int RETRY_FIFO_OPEN = -2;
+  int watchdogFifoFd = 0;
   GpsHyperion::FixMode gpsFix = GpsHyperion::FixMode::UNKNOWN;
 
   // States for SD state machine, which is used in non-blocking mode
@@ -195,57 +149,39 @@ class CoreController : public ExtendedControllerBase {
     SKIP_CYCLE_BEFORE_INFO_UPDATE,
     UPDATE_INFO,
     // SD initialization done
-    IDLE
+    IDLE,
+    // Used if SD switches or mount commands are issued via telecommand
+    SET_STATE_FROM_COMMAND,
   };
-
-  enum class SwUpdateSources { SD_0, SD_1, TMP_DIR };
-
   static constexpr bool BLOCKING_SD_INIT = false;
 
   SdCardManager* sdcMan = nullptr;
   MessageQueueIF* eventQueue = nullptr;
 
-  SdStates sdFsmState = SdStates::START;
-  enum SdCfgMode { PASSIVE, COLD_REDUNDANT, HOT_REDUNDANT };
-
-  struct SdFsmParams {
-    SdCfgMode cfgMode = SdCfgMode::COLD_REDUNDANT;
-    sd::SdCard active = sd::SdCard::NONE;
+  struct SdInfo {
+    sd::SdCard pref = sd::SdCard::NONE;
     sd::SdCard other = sd::SdCard::NONE;
-    sd::SdState activeState = sd::SdState::OFF;
+    sd::SdState prefState = sd::SdState::OFF;
     sd::SdState otherState = sd::SdState::OFF;
-    std::string activeChar = "0";
+    std::string prefChar = "0";
     std::string otherChar = "1";
     std::pair<bool, bool> mountSwitch = {true, true};
+    SdStates state = SdStates::START;
     // Used to track whether a command was executed
     bool commandExecuted = true;
     bool initFinished = false;
     SdCardManager::SdStatePair currentState;
     uint16_t cycleCount = 0;
+    // These two flags are related to external commanding
+    bool commandIssued = false;
+    bool commandFinished = false;
+    sd::SdState currentlyCommandedState = sd::SdState::OFF;
+    sd::SdCard commandedCard = sd::SdCard::NONE;
+    sd::SdState commandedState = sd::SdState::OFF;
   } sdInfo;
-
-  struct SdCommanding {
-    bool cmdPending = false;
-    MessageQueueId_t commander = MessageQueueIF::NO_QUEUE;
-    DeviceCommandId_t actionId;
-  } sdCommandingInfo;
-
   RebootFile rebootFile = {};
-
-  CommandExecutor cmdExecutor;
-  SimpleRingBuffer cmdReplyBuf;
-  DynamicFIFO<uint16_t> cmdRepliesSizes;
-  bool shellCmdIsExecuting = false;
-  MessageQueueId_t successRecipient = MessageQueueIF::NO_QUEUE;
-
   std::string currMntPrefix;
-  bool timeFileInitDone = false;
-  bool performOneShotSdCardOpsSwitch = false;
-  uint8_t shortSdCardCdCounter = 0;
-#if OBSW_THREAD_TRACING == 1
-  uint32_t opCounter;
-#endif
-  Countdown sdCardCheckCd = Countdown(INIT_SD_CARD_CHECK_TIMEOUT);
+  bool performOneShotSdCardOpsSwitch = true;
 
   /**
    * Index 0: Chip 0 Copy 0
@@ -257,19 +193,21 @@ class CoreController : public ExtendedControllerBase {
   PeriodicOperationDivider opDivider5;
   PeriodicOperationDivider opDivider10;
 
-  PoolEntry<float> tempPoolEntry = PoolEntry<float>(0.0);
-  PoolEntry<float> psVoltageEntry = PoolEntry<float>(0.0);
-  PoolEntry<float> plVoltageEntry = PoolEntry<float>(0.0);
-
   core::HkSet hkSet;
 
-#if OBSW_SD_CARD_MUST_BE_ON == 1
-  bool remountAttemptFlag = true;
-#endif
+  core::ListDirectoryIntoFileAction listDirectoryIntoFileAction =
+      core::ListDirectoryIntoFileAction(this);
+  core::SwitchRebootFileHandlingAction switchRebootFileHandlingAction =
+      core::SwitchRebootFileHandlingAction(this);
+  core::ResetRebootCountersAction resetRebootCountersAction = core::ResetRebootCountersAction(this);
+  core::SwitchImageLockAction switchImageLockAction = core::SwitchImageLockAction(this);
+  core::SetMaxRebootCntAction setMaxRebootCntAction = core::SetMaxRebootCntAction(this);
+  core::XscRebootObcAction xscRebootObcAction = core::XscRebootObcAction(this);
+  core::RebootObcAction rebootObcAction = core::RebootObcAction(this);
 
   ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
                                         LocalDataPoolManager& poolManager) override;
-
+  Countdown sdCardCheckCd = Countdown(120000);
   LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
   ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode, uint32_t* msToReachTheMode);
   void performMountedSdCardOperations();
@@ -277,18 +215,16 @@ class CoreController : public ExtendedControllerBase {
 
   ReturnValue_t initClockFromTimeFile();
   ReturnValue_t performSdCardCheck();
-  ReturnValue_t backupTimeFileHandler();
-  ReturnValue_t initBootCopyFile();
+  ReturnValue_t timeFileHandler();
+  ReturnValue_t initBootCopy();
+  ReturnValue_t initWatchdogFifo();
   ReturnValue_t initSdCardBlocking();
-  bool startSdStateMachine(sd::SdCard targetActiveSd, SdCfgMode mode, MessageQueueId_t commander,
-                           DeviceCommandId_t actionId);
   void initPrint();
 
   ReturnValue_t sdStateMachine();
   void updateSdInfoOther();
   ReturnValue_t sdCardSetup(sd::SdCard sdCard, sd::SdState targetState, std::string sdChar,
                             bool printOutput = true);
-  ReturnValue_t executeSwUpdate(SwUpdateSources sourceDir, const uint8_t* data, size_t size);
   ReturnValue_t sdColdRedundantBlockingInit();
 
   void currentStateSetter(sd::SdCard sdCard, sd::SdState newState);
@@ -296,13 +232,13 @@ class CoreController : public ExtendedControllerBase {
   void checkExternalSdCommandStatus();
   void performRebootFileHandling(bool recreateFile);
 
-  ReturnValue_t actionListDirectoryIntoFile(ActionId_t actionId, MessageQueueId_t commandedBy,
-                                            const uint8_t* data, size_t size);
   ReturnValue_t actionXscReboot(const uint8_t* data, size_t size);
   ReturnValue_t actionReboot(const uint8_t* data, size_t size);
 
   ReturnValue_t gracefulShutdownTasks(xsc::Chip chip, xsc::Copy copy, bool& protOpPerformed);
 
+  void performWatchdogControlOperation();
+
   ReturnValue_t handleProtInfoUpdateLine(std::string nextLine);
   int handleBootCopyProtAtIndex(xsc::Chip targetChip, xsc::Copy targetCopy, bool protect,
                                 bool& protOperationPerformed, bool selfChip, bool selfCopy,
@@ -313,7 +249,6 @@ class CoreController : public ExtendedControllerBase {
   void setRebootMechanismLock(bool lock, xsc::Chip tgtChip, xsc::Copy tgtCopy);
   bool parseRebootFile(std::string path, RebootFile& file);
   void rewriteRebootFile(RebootFile file);
-  void announceBootCounts();
   void readHkData();
   bool isNumber(const std::string& s);
 };

bsp_q7s/core/InitMission.cpp

@@ -0,0 +1,536 @@
+#include "bsp_q7s/core/InitMission.h"
+
+#include <fsfw/devicehandlers/DeviceCommunicationIF.h>
+
+#include <iostream>
+#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"
+#include "fsfw/returnvalues/HasReturnvaluesIF.h"
+#include "fsfw/serviceinterface/ServiceInterfaceStream.h"
+#include "fsfw/tasks/FixedTimeslotTaskIF.h"
+#include "fsfw/tasks/PeriodicTaskIF.h"
+#include "fsfw/tasks/TaskFactory.h"
+#include "mission/devices/devicedefinitions/Max31865Definitions.h"
+#include "mission/utility/InitMission.h"
+#include "pollingsequence/pollingSequenceFactory.h"
+
+/* This is configured for linux without CR */
+#ifdef PLATFORM_UNIX
+ServiceInterfaceStream sif::debug("DEBUG");
+ServiceInterfaceStream sif::info("INFO");
+ServiceInterfaceStream sif::warning("WARNING");
+ServiceInterfaceStream sif::error("ERROR");
+#else
+ServiceInterfaceStream sif::debug("DEBUG", true);
+ServiceInterfaceStream sif::info("INFO", true);
+ServiceInterfaceStream sif::warning("WARNING", true);
+ServiceInterfaceStream sif::error("ERROR", true, false, true);
+#endif
+
+ObjectManagerIF* objectManager = nullptr;
+
+void initmission::initMission() {
+  sif::info << "Building global objects.." << std::endl;
+  try {
+    /* Instantiate global object manager and also create all objects */
+    ObjectManager::instance()->setObjectFactoryFunction(ObjectFactory::produce, nullptr);
+  } catch (const std::invalid_argument& e) {
+    sif::error << "initmission::initMission: Object Construction failed with an "
+                  "invalid argument: "
+               << e.what();
+    std::exit(1);
+  }
+
+  sif::info << "Initializing all objects.." << std::endl;
+  ObjectManager::instance()->initialize();
+
+  /* This function creates and starts all tasks */
+  initTasks();
+}
+
+void initmission::initTasks() {
+  TaskFactory* factory = TaskFactory::instance();
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  if (factory == nullptr) {
+    /* Should never happen ! */
+    return;
+  }
+#if OBSW_PRINT_MISSED_DEADLINES == 1
+  void (*missedDeadlineFunc)(void) = TaskFactory::printMissedDeadline;
+#else
+  void (*missedDeadlineFunc)(void) = nullptr;
+#endif
+
+  PeriodicTaskIF* coreController = factory->createPeriodicTask(
+      "CORE_CTRL", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.4, missedDeadlineFunc);
+  result = coreController->addComponent(objects::CORE_CONTROLLER);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("CORE_CTRL", objects::CORE_CONTROLLER);
+  }
+
+  /* TMTC Distribution */
+  PeriodicTaskIF* tmTcDistributor = factory->createPeriodicTask(
+      "DIST", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
+  result = tmTcDistributor->addComponent(objects::CCSDS_PACKET_DISTRIBUTOR);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("CCSDS_DISTRIB", objects::CCSDS_PACKET_DISTRIBUTOR);
+  }
+  result = tmTcDistributor->addComponent(objects::PUS_PACKET_DISTRIBUTOR);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("PUS_PACKET_DISTRIB", objects::PUS_PACKET_DISTRIBUTOR);
+  }
+  result = tmTcDistributor->addComponent(objects::TM_FUNNEL);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("TM_FUNNEL", objects::TM_FUNNEL);
+  }
+
+#if OBSW_ADD_TCPIP_BRIDGE == 1
+  // TMTC bridge
+  PeriodicTaskIF* tmtcBridgeTask = factory->createPeriodicTask(
+      "TCPIP_TMTC_BRIDGE", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
+  result = tmtcBridgeTask->addComponent(objects::TMTC_BRIDGE);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("TMTC_BRIDGE", objects::TMTC_BRIDGE);
+  }
+  PeriodicTaskIF* tmtcPollingTask = factory->createPeriodicTask(
+      "TMTC_POLLING", 80, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
+  result = tmtcPollingTask->addComponent(objects::TMTC_POLLING_TASK);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("UDP_POLLING", objects::TMTC_POLLING_TASK);
+  }
+#endif
+
+#if OBSW_USE_CCSDS_IP_CORE == 1
+  PeriodicTaskIF* ccsdsHandlerTask = factory->createPeriodicTask(
+      "CCSDS_HANDLER", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
+  result = ccsdsHandlerTask->addComponent(objects::CCSDS_HANDLER);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("CCSDS Handler", objects::CCSDS_HANDLER);
+  }
+
+  // Minimal distance between two received TCs amounts to 0.6 seconds
+  // If a command has not been read before the next one arrives, the old command will be
+  // overwritten by the PDEC.
+  PeriodicTaskIF* pdecHandlerTask = factory->createPeriodicTask(
+      "PDEC_HANDLER", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, missedDeadlineFunc);
+  result = pdecHandlerTask->addComponent(objects::PDEC_HANDLER);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("PDEC Handler", objects::PDEC_HANDLER);
+  }
+#endif /* OBSW_USE_CCSDS_IP_CORE == 1 */
+
+#if OBSW_ADD_ACS_HANDLERS == 1
+  PeriodicTaskIF* acsTask = factory->createPeriodicTask(
+      "ACS_TASK", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 0.4, missedDeadlineFunc);
+  result = acsTask->addComponent(objects::GPS_CONTROLLER);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("GPS_CTRL", objects::GPS_CONTROLLER);
+  }
+#endif /* OBSW_ADD_ACS_HANDLERS */
+
+  acsTask->addComponent(objects::ACS_CONTROLLER);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("ACS_CTRL", objects::ACS_CONTROLLER);
+  }
+
+  PeriodicTaskIF* sysTask = factory->createPeriodicTask(
+      "SYS_TASK", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 0.4, missedDeadlineFunc);
+  static_cast<void>(sysTask);
+#if OBSW_ADD_ACS_HANDLERS == 1
+  result = sysTask->addComponent(objects::ACS_BOARD_ASS);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("ACS_BOARD_ASS", objects::ACS_BOARD_ASS);
+  }
+#endif /* OBSW_ADD_ACS_HANDLERS */
+#if OBSW_ADD_RW == 1
+  result = sysTask->addComponent(objects::RW_ASS);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("RW_ASS", objects::RW_ASS);
+  }
+#endif
+#if OBSW_ADD_SUS_BOARD_ASS == 1
+  result = sysTask->addComponent(objects::SUS_BOARD_ASS);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("SUS_BOARD_ASS", objects::SUS_BOARD_ASS);
+  }
+#endif
+
+#if OBSW_ADD_RTD_DEVICES == 1
+  PeriodicTaskIF* tcsPollingTask = factory->createPeriodicTask(
+      "TCS_POLLING_TASK", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 0.5, missedDeadlineFunc);
+  result = tcsPollingTask->addComponent(objects::SPI_RTD_COM_IF);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("SPI_RTD_POLLING", objects::SPI_RTD_COM_IF);
+  }
+  PeriodicTaskIF* tcsTask = factory->createPeriodicTask(
+      "TCS_TASK", 45, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.8, missedDeadlineFunc);
+  std::array<object_id_t, EiveMax31855::NUM_RTDS> rtdIds = {
+      objects::RTD_0_IC3_PLOC_HEATSPREADER,
+      objects::RTD_1_IC4_PLOC_MISSIONBOARD,
+      objects::RTD_2_IC5_4K_CAMERA,
+      objects::RTD_3_IC6_DAC_HEATSPREADER,
+      objects::RTD_4_IC7_STARTRACKER,
+      objects::RTD_5_IC8_RW1_MX_MY,
+      objects::RTD_6_IC9_DRO,
+      objects::RTD_7_IC10_SCEX,
+      objects::RTD_8_IC11_X8,
+      objects::RTD_9_IC12_HPA,
+      objects::RTD_10_IC13_PL_TX,
+      objects::RTD_11_IC14_MPA,
+      objects::RTD_12_IC15_ACU,
+      objects::RTD_13_IC16_PLPCDU_HEATSPREADER,
+      objects::RTD_14_IC17_TCS_BOARD,
+      objects::RTD_15_IC18_IMTQ,
+  };
+  tcsTask->addComponent(objects::TCS_BOARD_ASS);
+  tcsTask->addComponent(objects::THERMAL_CONTROLLER);
+  for (const auto& rtd : rtdIds) {
+    tcsTask->addComponent(rtd, DeviceHandlerIF::PERFORM_OPERATION);
+    tcsTask->addComponent(rtd, DeviceHandlerIF::SEND_WRITE);
+    tcsTask->addComponent(rtd, DeviceHandlerIF::GET_WRITE);
+    tcsTask->addComponent(rtd, DeviceHandlerIF::SEND_READ);
+    tcsTask->addComponent(rtd, DeviceHandlerIF::GET_READ);
+  }
+#endif /* OBSW_ADD_RTD_DEVICES */
+
+  // FS task, task interval does not matter because it runs in permanent loop, priority low
+  // because it is a non-essential background task
+  PeriodicTaskIF* fsTask = factory->createPeriodicTask(
+      "FILE_SYSTEM_TASK", 25, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.4, missedDeadlineFunc);
+  result = fsTask->addComponent(objects::FILE_SYSTEM_HANDLER);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("FILE_SYSTEM_TASK", objects::FILE_SYSTEM_HANDLER);
+  }
+
+#if OBSW_ADD_STAR_TRACKER == 1
+  PeriodicTaskIF* strHelperTask = factory->createPeriodicTask(
+      "STR_HELPER", 20, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
+  result = strHelperTask->addComponent(objects::STR_HELPER);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("STR_HELPER", objects::STR_HELPER);
+  }
+#endif /* OBSW_ADD_STAR_TRACKER == 1 */
+
+#if OBSW_ADD_PLOC_MPSOC == 1
+  PeriodicTaskIF* mpsocHelperTask = factory->createPeriodicTask(
+      "PLOC_MPSOC_HELPER", 20, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
+  result = mpsocHelperTask->addComponent(objects::PLOC_MPSOC_HELPER);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("PLOC_MPSOC_HELPER", objects::PLOC_MPSOC_HELPER);
+  }
+#endif /* OBSW_ADD_PLOC_MPSOC */
+
+#if OBSW_ADD_PLOC_SUPERVISOR == 1
+  PeriodicTaskIF* supvHelperTask = factory->createPeriodicTask(
+      "PLOC_SUPV_HELPER", 10, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, missedDeadlineFunc);
+  result = supvHelperTask->addComponent(objects::PLOC_SUPERVISOR_HELPER);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("PLOC_SUPV_HELPER", objects::PLOC_SUPERVISOR_HELPER);
+  }
+#endif /* OBSW_ADD_PLOC_SUPERVISOR */
+
+#if OBSW_TEST_CCSDS_BRIDGE == 1
+  PeriodicTaskIF* ptmeTestTask = factory->createPeriodicTask(
+      "PTME_TEST", 80, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
+  result = ptmeTestTask->addComponent(objects::CCSDS_IP_CORE_BRIDGE);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("PTME_TEST", objects::CCSDS_IP_CORE_BRIDGE);
+  }
+#endif
+
+  std::vector<PeriodicTaskIF*> pusTasks;
+  createPusTasks(*factory, missedDeadlineFunc, pusTasks);
+  std::vector<PeriodicTaskIF*> pstTasks;
+  createPstTasks(*factory, missedDeadlineFunc, pstTasks);
+
+#if OBSW_ADD_TEST_CODE == 1
+  std::vector<PeriodicTaskIF*> testTasks;
+  createTestTasks(*factory, missedDeadlineFunc, testTasks);
+#endif
+
+  auto taskStarter = [](std::vector<PeriodicTaskIF*>& taskVector, std::string name) {
+    for (const auto& task : taskVector) {
+      if (task != nullptr) {
+        task->startTask();
+      } else {
+        sif::error << "Task in vector " << name << " is invalid!" << std::endl;
+      }
+    }
+  };
+
+  sif::info << "Starting tasks.." << std::endl;
+  tmTcDistributor->startTask();
+
+#if OBSW_ADD_TCPIP_BRIDGE == 1
+  tmtcBridgeTask->startTask();
+  tmtcPollingTask->startTask();
+#endif
+
+#if OBSW_USE_CCSDS_IP_CORE == 1
+  ccsdsHandlerTask->startTask();
+  pdecHandlerTask->startTask();
+#endif /* OBSW_USE_CCSDS_IP_CORE == 1 */
+
+  coreController->startTask();
+
+  taskStarter(pstTasks, "PST task vector");
+  taskStarter(pusTasks, "PUS task vector");
+#if OBSW_ADD_TEST_CODE == 1
+  taskStarter(testTasks, "Test task vector");
+#endif
+
+#if OBSW_TEST_CCSDS_BRIDGE == 1
+  ptmeTestTask->startTask();
+#endif
+
+  fsTask->startTask();
+#if OBSW_ADD_STAR_TRACKER == 1
+  strHelperTask->startTask();
+#endif /* OBSW_ADD_STAR_TRACKER == 1 */
+
+#if OBSW_ADD_ACS_HANDLERS == 1
+  acsTask->startTask();
+#endif /* OBSW_ADD_ACS_HANDLERS == 1 */
+  sysTask->startTask();
+#if OBSW_ADD_RTD_DEVICES == 1
+  tcsPollingTask->startTask();
+  tcsTask->startTask();
+#endif /* OBSW_ADD_RTD_DEVICES == 1 */
+#if OBSW_ADD_PLOC_SUPERVISOR == 1
+  supvHelperTask->startTask();
+#endif /* OBSW_ADD_PLOC_SUPERVISOR == 1 */
+  sif::info << "Tasks started.." << std::endl;
+}
+
+void initmission::createPstTasks(TaskFactory& factory,
+                                 TaskDeadlineMissedFunction missedDeadlineFunc,
+                                 std::vector<PeriodicTaskIF*>& taskVec) {
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  /* Polling Sequence Table Default */
+#if OBSW_ADD_SPI_TEST_CODE == 0
+  FixedTimeslotTaskIF* spiPst = factory.createFixedTimeslotTask(
+      "MAIN_SPI", 75, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 0.5, missedDeadlineFunc);
+  result = pst::pstSpi(spiPst);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    if (result == FixedTimeslotTaskIF::SLOT_LIST_EMPTY) {
+      sif::warning << "InitMission::initTasks: SPI PST is empty" << std::endl;
+    } else {
+      sif::error << "InitMission::initTasks: Creating SPI PST failed!" << std::endl;
+    }
+  } else {
+    taskVec.push_back(spiPst);
+  }
+#endif
+
+#if OBSW_ADD_RW == 1
+  FixedTimeslotTaskIF* rwPstTask = factory.createFixedTimeslotTask(
+      "RW_SPI", 65, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 1.0, missedDeadlineFunc);
+  result = pst::pstSpiRw(rwPstTask);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    if (result == FixedTimeslotTaskIF::SLOT_LIST_EMPTY) {
+      sif::warning << "InitMission::initTasks: SPI PST is empty" << std::endl;
+    } else {
+      sif::error << "InitMission::initTasks: Creating SPI PST failed!" << std::endl;
+    }
+  } else {
+    taskVec.push_back(rwPstTask);
+  }
+#endif
+
+  FixedTimeslotTaskIF* uartPst = factory.createFixedTimeslotTask(
+      "UART_PST", 65, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 0.2, missedDeadlineFunc);
+  result = pst::pstUart(uartPst);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    if (result == FixedTimeslotTaskIF::SLOT_LIST_EMPTY) {
+      sif::warning << "InitMission::initTasks: UART PST is empty" << std::endl;
+    } else {
+      sif::error << "InitMission::initTasks: Creating UART PST failed!" << std::endl;
+    }
+  } else {
+    taskVec.push_back(uartPst);
+  }
+
+  FixedTimeslotTaskIF* gpioPst = factory.createFixedTimeslotTask(
+      "GPIO_PST", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 0.2, missedDeadlineFunc);
+  result = pst::pstGpio(gpioPst);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    if (result == FixedTimeslotTaskIF::SLOT_LIST_EMPTY) {
+      sif::warning << "InitMission::initTasks: GPIO PST is empty" << std::endl;
+    } else {
+      sif::error << "InitMission::initTasks: Creating GPIO PST failed!" << std::endl;
+    }
+  } else {
+    taskVec.push_back(gpioPst);
+  }
+#if OBSW_ADD_I2C_TEST_CODE == 0
+  FixedTimeslotTaskIF* i2cPst = factory.createFixedTimeslotTask(
+      "I2C_PST", 65, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 0.2, missedDeadlineFunc);
+  result = pst::pstI2c(i2cPst);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    if (result == FixedTimeslotTaskIF::SLOT_LIST_EMPTY) {
+      sif::warning << "InitMission::initTasks: I2C PST is empty" << std::endl;
+    } else {
+      sif::error << "InitMission::initTasks: Creating I2C PST failed!" << std::endl;
+    }
+  } else {
+    taskVec.push_back(i2cPst);
+  }
+#endif
+
+#if OBSW_ADD_GOMSPACE_PCDU == 1
+  FixedTimeslotTaskIF* gomSpacePstTask = factory.createFixedTimeslotTask(
+      "GS_PST_TASK", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 1.0, missedDeadlineFunc);
+  result = pst::pstGompaceCan(gomSpacePstTask);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    if (result != FixedTimeslotTaskIF::SLOT_LIST_EMPTY) {
+      sif::error << "InitMission::initTasks: GomSpace PST initialization failed!" << std::endl;
+    }
+  }
+  taskVec.push_back(gomSpacePstTask);
+#endif
+}
+
+void initmission::createPusTasks(TaskFactory& factory,
+                                 TaskDeadlineMissedFunction missedDeadlineFunc,
+                                 std::vector<PeriodicTaskIF*>& taskVec) {
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  /* PUS Services */
+  PeriodicTaskIF* pusVerification = factory.createPeriodicTask(
+      "PUS_VERIF", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
+  result = pusVerification->addComponent(objects::PUS_SERVICE_1_VERIFICATION);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("PUS_VERIF", objects::PUS_SERVICE_1_VERIFICATION);
+  }
+  taskVec.push_back(pusVerification);
+
+  PeriodicTaskIF* pusEvents = factory.createPeriodicTask(
+      "PUS_EVENTS", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
+  result = pusEvents->addComponent(objects::PUS_SERVICE_5_EVENT_REPORTING);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("PUS_EVENTS", objects::PUS_SERVICE_5_EVENT_REPORTING);
+  }
+  result = pusEvents->addComponent(objects::EVENT_MANAGER);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("PUS_MGMT", objects::EVENT_MANAGER);
+  }
+  taskVec.push_back(pusEvents);
+
+  PeriodicTaskIF* pusHighPrio = factory.createPeriodicTask(
+      "PUS_HIGH_PRIO", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
+  result = pusHighPrio->addComponent(objects::PUS_SERVICE_2_DEVICE_ACCESS);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("PUS_2", objects::PUS_SERVICE_2_DEVICE_ACCESS);
+  }
+  result = pusHighPrio->addComponent(objects::PUS_SERVICE_9_TIME_MGMT);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("PUS_9", objects::PUS_SERVICE_9_TIME_MGMT);
+  }
+  taskVec.push_back(pusHighPrio);
+
+  PeriodicTaskIF* pusMedPrio = factory.createPeriodicTask(
+      "PUS_MED_PRIO", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.8, missedDeadlineFunc);
+
+  result = pusMedPrio->addComponent(objects::PUS_SERVICE_3_HOUSEKEEPING);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("PUS_3", objects::PUS_SERVICE_3_HOUSEKEEPING);
+  }
+  result = pusMedPrio->addComponent(objects::PUS_SERVICE_8_FUNCTION_MGMT);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("PUS_8", objects::PUS_SERVICE_8_FUNCTION_MGMT);
+  }
+  result = pusMedPrio->addComponent(objects::PUS_SERVICE_11_TC_SCHEDULER);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("PUS_11", objects::PUS_SERVICE_11_TC_SCHEDULER);
+  }
+  result = pusMedPrio->addComponent(objects::PUS_SERVICE_20_PARAMETERS);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("PUS_20", objects::PUS_SERVICE_20_PARAMETERS);
+  }
+  result = pusMedPrio->addComponent(objects::PUS_SERVICE_200_MODE_MGMT);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("PUS_200", objects::PUS_SERVICE_200_MODE_MGMT);
+  }
+  result = pusMedPrio->addComponent(objects::PUS_SERVICE_201_HEALTH);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("PUS_201", objects::PUS_SERVICE_201_HEALTH);
+  }
+  taskVec.push_back(pusMedPrio);
+
+  PeriodicTaskIF* pusLowPrio = factory.createPeriodicTask(
+      "PUS_LOW_PRIO", 30, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.6, missedDeadlineFunc);
+  result = pusLowPrio->addComponent(objects::PUS_SERVICE_17_TEST);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("PUS_17", objects::PUS_SERVICE_17_TEST);
+  }
+  result = pusLowPrio->addComponent(objects::INTERNAL_ERROR_REPORTER);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("ERROR_REPORTER", objects::INTERNAL_ERROR_REPORTER);
+  }
+  taskVec.push_back(pusLowPrio);
+}
+
+void initmission::createTestTasks(TaskFactory& factory,
+                                  TaskDeadlineMissedFunction missedDeadlineFunc,
+                                  std::vector<PeriodicTaskIF*>& taskVec) {
+#if OBSW_ADD_TEST_TASK == 1 && OBSW_ADD_TEST_CODE == 1
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  static_cast<void>(result);  // supress warning in case it is not used
+
+  PeriodicTaskIF* testTask = factory.createPeriodicTask(
+      "TEST_TASK", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1, missedDeadlineFunc);
+
+  result = testTask->addComponent(objects::TEST_TASK);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("TEST_TASK", objects::TEST_TASK);
+  }
+
+#if OBSW_ADD_SPI_TEST_CODE == 1
+  result = testTask->addComponent(objects::SPI_TEST);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("SPI_TEST", objects::SPI_TEST);
+  }
+#endif
+#if OBSW_ADD_I2C_TEST_CODE == 1
+  result = testTask->addComponent(objects::I2C_TEST);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("I2C_TEST", objects::I2C_TEST);
+  }
+#endif
+#if OBSW_ADD_UART_TEST_CODE == 1
+  result = testTask->addComponent(objects::UART_TEST);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("UART_TEST", objects::UART_TEST);
+  }
+#endif
+
+  taskVec.push_back(testTask);
+
+#endif  // OBSW_ADD_TEST_TASK == 1 && OBSW_ADD_TEST_CODE == 1
+}
+
+/**
+                   ▄              ▄
+                  ▌▒█           ▄▀▒▌
+                  ▌▒▒█        ▄▀▒▒▒▐
+                 ▐▄▀▒▒▀▀▀▀▄▄▄▀▒▒▒▒▒▐
+               ▄▄▀▒░▒▒▒▒▒▒▒▒▒█▒▒▄█▒▐
+             ▄▀▒▒▒░░░▒▒▒░░░▒▒▒▀██▀▒▌
+            ▐▒▒▒▄▄▒▒▒▒░░░▒▒▒▒▒▒▒▀▄▒▒▌
+            ▌░░▌█▀▒▒▒▒▒▄▀█▄▒▒▒▒▒▒▒█▒▐
+           ▐░░░▒▒▒▒▒▒▒▒▌██▀▒▒░░░▒▒▒▀▄▌
+           ▌░▒▄██▄▒▒▒▒▒▒▒▒▒░░░░░░▒▒▒▒▌
+          ▌▒▀▐▄█▄█▌▄░▀▒▒░░░░░░░░░░▒▒▒▐
+          ▐▒▒▐▀▐▀▒░▄▄▒▄▒▒▒▒▒▒░▒░▒░▒▒▒▒▌
+          ▐▒▒▒▀▀▄▄▒▒▒▄▒▒▒▒▒▒▒▒░▒░▒░▒▒▐
+           ▌▒▒▒▒▒▒▀▀▀▒▒▒▒▒▒░▒░▒░▒░▒▒▒▌
+           ▐▒▒▒▒▒▒▒▒▒▒▒▒▒▒░▒░▒░▒▒▄▒▒▐
+            ▀▄▒▒▒▒▒▒▒▒▒▒▒░▒░▒░▒▄▒▒▒▒▌
+              ▀▄▒▒▒▒▒▒▒▒▒▒▄▄▄▀▒▒▒▒▄▀
+                ▀▄▄▄▄▄▄▀▀▀▒▒▒▒▒▄▄▀
+                   ▒▒▒▒▒▒▒▒▒▒▀▀
+ **/

bsp_q7s/core/InitMission.h

@@ -4,23 +4,20 @@
 #include <vector>
 
 #include "fsfw/tasks/definitions.h"
-#include "mission/core/pollingSeqTables.h"
-
-using pst::AcsPstCfg;
 
 class PeriodicTaskIF;
 class TaskFactory;
 
-namespace scheduling {
+namespace initmission {
 void initMission();
 void initTasks();
 
 void createPstTasks(TaskFactory& factory, TaskDeadlineMissedFunction missedDeadlineFunc,
-                    std::vector<PeriodicTaskIF*>& taskVec, AcsPstCfg cfg);
+                    std::vector<PeriodicTaskIF*>& taskVec);
 void createPusTasks(TaskFactory& factory, TaskDeadlineMissedFunction missedDeadlineFunc,
                     std::vector<PeriodicTaskIF*>& taskVec);
 void createTestTasks(TaskFactory& factory, TaskDeadlineMissedFunction missedDeadlineFunc,
                      std::vector<PeriodicTaskIF*>& taskVec);
-};  // namespace scheduling
+};  // namespace initmission
 
 #endif /* BSP_Q7S_INITMISSION_H_ */

bsp_q7s/core/ObjectFactory.h

@@ -1,20 +1,12 @@
 #ifndef BSP_Q7S_OBJECTFACTORY_H_
 #define BSP_Q7S_OBJECTFACTORY_H_
 
-#include <fsfw/returnvalues/returnvalue.h>
-#include <fsfw_hal/linux/spi/SpiComIF.h>
-#include <mission/core/GenericFactory.h>
-#include <mission/devices/HeaterHandler.h>
-#include <mission/system/objects/Stack5VHandler.h>
-#include <mission/tmtc/CcsdsIpCoreHandler.h>
-#include <mission/tmtc/CfdpTmFunnel.h>
-#include <mission/tmtc/PersistentLogTmStoreTask.h>
-#include <mission/tmtc/PusTmFunnel.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
 
 #include <string>
 
 class LinuxLibgpioIF;
-class SerialComIF;
+class UartComIF;
 class SpiComIF;
 class I2cComIF;
 class PowerSwitchIF;
@@ -24,50 +16,28 @@ class GpioIF;
 
 namespace ObjectFactory {
 
-struct CcsdsComponentArgs {
-  CcsdsComponentArgs(LinuxLibgpioIF& gpioIF, StorageManagerIF& ipcStore, StorageManagerIF& tmStore,
-                     PersistentTmStores& stores, PusTmFunnel& pusFunnel, CfdpTmFunnel& cfdpFunnel,
-                     CcsdsIpCoreHandler** ipCoreHandler)
-      : gpioComIF(gpioIF),
-        ipcStore(ipcStore),
-        tmStore(tmStore),
-        stores(stores),
-        pusFunnel(pusFunnel),
-        cfdpFunnel(cfdpFunnel),
-        ipCoreHandler(ipCoreHandler) {}
-  LinuxLibgpioIF& gpioComIF;
-  StorageManagerIF& ipcStore;
-  StorageManagerIF& tmStore;
-  PersistentTmStores& stores;
-  PusTmFunnel& pusFunnel;
-  CfdpTmFunnel& cfdpFunnel;
-  CcsdsIpCoreHandler** ipCoreHandler;
-  AcceptsTelemetryIF* liveDestination = nullptr;
-};
-
 void setStatics();
 void produce(void* args);
 
-void createCommunicationInterfaces(LinuxLibgpioIF** gpioComIF, SerialComIF** uartComIF,
-                                   SpiComIF** spiMainComIF, I2cComIF** i2cComIF);
+void createCommunicationInterfaces(LinuxLibgpioIF** gpioComIF, UartComIF** uartComIF,
+                                   SpiComIF** spiMainComIF, I2cComIF** i2cComIF,
+                                   SpiComIF** spiRwComIF);
 void createPcduComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchIF** pwrSwitcher);
 void createPlPcduComponents(LinuxLibgpioIF* gpioComIF, SpiComIF* spiComIF,
-                            PowerSwitchIF* pwrSwitcher, Stack5VHandler& stackHandler);
+                            PowerSwitchIF* pwrSwitcher);
 void createTmpComponents();
-ReturnValue_t createRadSensorComponent(LinuxLibgpioIF* gpioComIF, Stack5VHandler& handler);
-void createAcsBoardGpios(GpioCookie& cookie);
-void createAcsBoardComponents(SpiComIF& spiComIF, LinuxLibgpioIF* gpioComIF, SerialComIF* uartComIF,
-                              PowerSwitchIF& pwrSwitcher);
-void createHeaterComponents(GpioIF* gpioIF, PowerSwitchIF* pwrSwitcher, HealthTableIF* healthTable,
-                            HeaterHandler*& heaterHandler);
+void createRadSensorComponent(LinuxLibgpioIF* gpioComIF);
+void createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComIF* uartComIF,
+                              PowerSwitchIF* pwrSwitcher);
+void createHeaterComponents(GpioIF* gpioIF, PowerSwitchIF* pwrSwitcher, HealthTableIF* healthTable);
 void createImtqComponents(PowerSwitchIF* pwrSwitcher);
 void createBpxBatteryComponent();
 void createStrComponents(PowerSwitchIF* pwrSwitcher);
-void createSolarArrayDeploymentComponents(PowerSwitchIF& pwrSwitcher, GpioIF& gpioIF);
+void createSolarArrayDeploymentComponents();
 void createSyrlinksComponents(PowerSwitchIF* pwrSwitcher);
-void createPayloadComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchIF& pwrSwitcher);
+void createPayloadComponents(LinuxLibgpioIF* gpioComIF);
 void createReactionWheelComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchIF* pwrSwitcher);
-ReturnValue_t createCcsdsComponents(CcsdsComponentArgs& args);
+void createCcsdsComponents(LinuxLibgpioIF* gpioComIF);
 void createMiscComponents();
 
 void createTestComponents(LinuxLibgpioIF* gpioComIF);

bsp_q7s/core/WatchdogHandler.cpp

@@ -1,87 +0,0 @@
-#include "WatchdogHandler.h"
-
-#include <fcntl.h>
-#include <unistd.h>
-
-#include <cerrno>
-#include <cstring>
-#include <filesystem>
-
-#include "fsfw/serviceinterface.h"
-#include "watchdog/definitions.h"
-
-WatchdogHandler::WatchdogHandler() {}
-
-void WatchdogHandler::periodicOperation() {
-  if (watchdogFifoFd != 0) {
-    if (watchdogFifoFd == RETRY_FIFO_OPEN) {
-      // Open FIFO write only and non-blocking
-      watchdogFifoFd = open(watchdog::FIFO_NAME.c_str(), O_WRONLY | O_NONBLOCK);
-      if (watchdogFifoFd < 0) {
-        if (errno == ENXIO) {
-          watchdogFifoFd = RETRY_FIFO_OPEN;
-          // No printout for now, would be spam
-          return;
-        } else {
-          sif::error << "Opening pipe " << watchdog::FIFO_NAME << " write-only failed with "
-                     << errno << ": " << strerror(errno) << std::endl;
-          return;
-        }
-      }
-      sif::info << "Opened " << watchdog::FIFO_NAME << " successfully" << std::endl;
-      performStartHandling();
-    } else if (watchdogFifoFd > 0) {
-      // Write to OBSW watchdog FIFO here
-      const char writeChar = watchdog::first::IDLE_CHAR;
-      ssize_t writtenBytes = write(watchdogFifoFd, &writeChar, 1);
-      if (writtenBytes < 0) {
-        sif::error << "Errors writing to watchdog FIFO, code " << errno << ": " << strerror(errno)
-                   << std::endl;
-      }
-    }
-  }
-}
-
-ReturnValue_t WatchdogHandler::initialize(bool enableWatchdogFunction) {
-  using namespace std::filesystem;
-  this->enableWatchFunction = enableWatchdogFunction;
-  std::error_code e;
-  if (not std::filesystem::exists(watchdog::FIFO_NAME, e)) {
-    // Still return returnvalue::OK for now
-    sif::info << "Watchdog FIFO " << watchdog::FIFO_NAME << " does not exist, can't initiate"
-              << " watchdog" << std::endl;
-    return returnvalue::OK;
-  }
-  // Open FIFO write only and non-blocking to prevent SW from killing itself.
-  watchdogFifoFd = open(watchdog::FIFO_NAME.c_str(), O_WRONLY | O_NONBLOCK);
-  if (watchdogFifoFd < 0) {
-    if (errno == ENXIO) {
-      watchdogFifoFd = RETRY_FIFO_OPEN;
-      sif::info << "eive-watchdog not running. FIFO can not be opened" << std::endl;
-    } else {
-      sif::error << "Opening pipe " << watchdog::FIFO_NAME << " write-only failed with " << errno
-                 << ": " << strerror(errno) << std::endl;
-      return returnvalue::FAILED;
-    }
-  }
-  return performStartHandling();
-}
-
-ReturnValue_t WatchdogHandler::performStartHandling() {
-  char startBuf[2];
-  ssize_t writeLen = 1;
-  startBuf[0] = watchdog::first::START_CHAR;
-  if (enableWatchFunction) {
-    writeLen += 1;
-    startBuf[1] = watchdog::second::WATCH_FLAG;
-  }
-  ssize_t writtenBytes = write(watchdogFifoFd, &startBuf, writeLen);
-  if (writtenBytes < 0) {
-    sif::error << "WatchdogHandler: Errors writing to watchdog FIFO, code " << errno << ": "
-               << strerror(errno) << std::endl;
-    return returnvalue::FAILED;
-  } else if (writtenBytes != writeLen) {
-    sif::warning << "WatchdogHandler: Not all bytes were written, possible error" << std::endl;
-  }
-  return returnvalue::OK;
-}

bsp_q7s/core/WatchdogHandler.h

@@ -1,23 +0,0 @@
-#ifndef BSP_Q7S_CORE_WATCHDOGHANDLER_H_
-#define BSP_Q7S_CORE_WATCHDOGHANDLER_H_
-
-#include "fsfw/returnvalues/returnvalue.h"
-
-class WatchdogHandler {
- public:
-  WatchdogHandler();
-
-  ReturnValue_t initialize(bool enableWatchFunction);
-  void periodicOperation();
-
- private:
-  // Designated value for rechecking FIFO open
-  static constexpr int RETRY_FIFO_OPEN = -2;
-
-  int watchdogFifoFd = 0;
-  bool enableWatchFunction = false;
-
-  ReturnValue_t performStartHandling();
-};
-
-#endif /* BSP_Q7S_CORE_WATCHDOGHANDLER_H_ */

bsp_q7s/core/scheduling.cpp

@@ -1,633 +0,0 @@
-#include "scheduling.h"
-
-#include <fsfw/devicehandlers/DeviceCommunicationIF.h>
-#include <fsfw/subsystem/Subsystem.h>
-#include <linux/scheduling.h>
-
-#include <iostream>
-#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"
-#include "fsfw/returnvalues/returnvalue.h"
-#include "fsfw/serviceinterface/ServiceInterfaceStream.h"
-#include "fsfw/tasks/FixedTimeslotTaskIF.h"
-#include "fsfw/tasks/PeriodicTaskIF.h"
-#include "fsfw/tasks/TaskFactory.h"
-#include "mission/core/pollingSeqTables.h"
-#include "mission/core/scheduling.h"
-#include "mission/devices/devicedefinitions/Max31865Definitions.h"
-#include "mission/utility/InitMission.h"
-
-/* This is configured for linux without CR */
-#ifdef PLATFORM_UNIX
-ServiceInterfaceStream sif::debug("DEBUG");
-ServiceInterfaceStream sif::info("INFO");
-ServiceInterfaceStream sif::warning("WARNING");
-ServiceInterfaceStream sif::error("ERROR");
-#else
-ServiceInterfaceStream sif::debug("DEBUG", true);
-ServiceInterfaceStream sif::info("INFO", true);
-ServiceInterfaceStream sif::warning("WARNING", true);
-ServiceInterfaceStream sif::error("ERROR", true, false, true);
-#endif
-
-ObjectManagerIF* objectManager = nullptr;
-
-void scheduling::initMission() {
-  sif::info << "Building global objects.." << std::endl;
-  try {
-    /* Instantiate global object manager and also create all objects */
-    ObjectManager::instance()->setObjectFactoryFunction(ObjectFactory::produce, nullptr);
-  } catch (const std::invalid_argument& e) {
-    sif::error << "scheduling::initMission: Object Construction failed with an "
-                  "invalid argument: "
-               << e.what();
-    std::exit(1);
-  }
-
-  sif::info << "Initializing all objects.." << std::endl;
-  ObjectManager::instance()->initialize();
-
-  /* This function creates and starts all tasks */
-  initTasks();
-}
-
-void scheduling::initTasks() {
-  TaskFactory* factory = TaskFactory::instance();
-  ReturnValue_t result = returnvalue::OK;
-  if (factory == nullptr) {
-    /* Should never happen ! */
-    return;
-  }
-#if OBSW_PRINT_MISSED_DEADLINES == 1
-  void (*missedDeadlineFunc)(void) = TaskFactory::printMissedDeadline;
-#else
-  void (*missedDeadlineFunc)(void) = nullptr;
-#endif
-
-#if OBSW_ADD_SA_DEPL == 1
-  // Could add this to the core controller but the core controller does so many thing that I would
-  // prefer to have the solar array deployment in a seprate task.
-  PeriodicTaskIF* solarArrayDeplTask = factory->createPeriodicTask(
-      "SOLAR_ARRAY_DEPL", 65, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.4, missedDeadlineFunc);
-  result = solarArrayDeplTask->addComponent(objects::SOLAR_ARRAY_DEPL_HANDLER);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("SOLAR_ARRAY_DEPL", objects::SOLAR_ARRAY_DEPL_HANDLER);
-  }
-#endif
-
-  PeriodicTaskIF* coreCtrlTask = factory->createPeriodicTask(
-      "CORE_CTRL", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.4, missedDeadlineFunc);
-  result = coreCtrlTask->addComponent(objects::CORE_CONTROLLER);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("CORE_CTRL", objects::CORE_CONTROLLER);
-  }
-
-  /* TMTC Distribution */
-  PeriodicTaskIF* tmTcDistributor = factory->createPeriodicTask(
-      "DIST", 45, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
-#if OBSW_ADD_TCPIP_SERVERS == 1
-#if OBSW_ADD_TMTC_UDP_SERVER == 1
-  result = tmTcDistributor->addComponent(objects::UDP_TMTC_SERVER);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("UDP_TMTC_SERVER", objects::UDP_TMTC_SERVER);
-  }
-#endif
-#if OBSW_ADD_TMTC_TCP_SERVER == 1
-  result = tmTcDistributor->addComponent(objects::TCP_TMTC_SERVER);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("TCP_TMTC_SERVER", objects::TCP_TMTC_SERVER);
-  }
-#endif
-#endif
-  result = tmTcDistributor->addComponent(objects::CCSDS_PACKET_DISTRIBUTOR);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("CCSDS_DISTRIB", objects::CCSDS_PACKET_DISTRIBUTOR);
-  }
-  result = tmTcDistributor->addComponent(objects::PUS_PACKET_DISTRIBUTOR);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("PUS_PACKET_DISTRIB", objects::PUS_PACKET_DISTRIBUTOR);
-  }
-  result = tmTcDistributor->addComponent(objects::CFDP_DISTRIBUTOR);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("CFDP_DISTRIBUTOR", objects::CFDP_DISTRIBUTOR);
-  }
-
-#if OBSW_ADD_TCPIP_SERVERS == 1
-#if OBSW_ADD_TMTC_UDP_SERVER == 1
-  PeriodicTaskIF* udpPollingTask = factory->createPeriodicTask(
-      "UDP_TMTC_POLLING", 65, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
-  result = udpPollingTask->addComponent(objects::UDP_TMTC_POLLING_TASK);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("UDP_POLLING", objects::UDP_TMTC_POLLING_TASK);
-  }
-#endif
-#if OBSW_ADD_TMTC_TCP_SERVER == 1
-  PeriodicTaskIF* tcpPollingTask = factory->createPeriodicTask(
-      "TCP_TMTC_POLLING", 65, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
-  result = tcpPollingTask->addComponent(objects::TCP_TMTC_POLLING_TASK);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("UDP_POLLING", objects::TCP_TMTC_POLLING_TASK);
-  }
-#endif
-#endif
-
-  PeriodicTaskIF* genericSysTask = factory->createPeriodicTask(
-      "SYSTEM_TASK", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.5, missedDeadlineFunc);
-  result = genericSysTask->addComponent(objects::EIVE_SYSTEM);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("EIVE_SYSTEM", objects::EIVE_SYSTEM);
-  }
-  result = genericSysTask->addComponent(objects::COM_SUBSYSTEM);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("COM_SUBSYSTEM", objects::COM_SUBSYSTEM);
-  }
-  result = genericSysTask->addComponent(objects::SYRLINKS_ASSY);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("SYRLINKS_ASSY", objects::SYRLINKS_ASSY);
-  }
-  result = genericSysTask->addComponent(objects::PL_SUBSYSTEM);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("PL_SUBSYSTEM", objects::PL_SUBSYSTEM);
-  }
-  result = genericSysTask->addComponent(objects::INTERNAL_ERROR_REPORTER);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("ERROR_REPORTER", objects::INTERNAL_ERROR_REPORTER);
-  }
-  result = genericSysTask->addComponent(objects::PUS_SERVICE_17_TEST);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("PUS_17", objects::PUS_SERVICE_17_TEST);
-  }
-
-#if OBSW_ADD_CCSDS_IP_CORES == 1
-  result = genericSysTask->addComponent(objects::CCSDS_HANDLER);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("CCSDS Handler", objects::CCSDS_HANDLER);
-  }
-
-  // Runs in IRQ mode, frequency does not really matter
-  PeriodicTaskIF* pdecHandlerTask = factory->createPeriodicTask(
-      "PDEC_HANDLER", 75, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, missedDeadlineFunc);
-  result = pdecHandlerTask->addComponent(objects::PDEC_HANDLER);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("PDEC Handler", objects::PDEC_HANDLER);
-  }
-
-#endif /* OBSW_ADD_CCSDS_IP_CORE == 1 */
-  // All the TM store tasks run in permanent loops, frequency does not matter
-  PeriodicTaskIF* liveTmTask =
-      factory->createPeriodicTask("LIVE_TM", 55, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, nullptr);
-  result = liveTmTask->addComponent(objects::LIVE_TM_TASK);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("LIVE_TM", objects::LIVE_TM_TASK);
-  }
-  PeriodicTaskIF* logTmTask = factory->createPeriodicTask(
-      "LOG_STORE_AND_TM", 45, 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_STORE_AND_TM", 45, 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_STORE_AND_TM", 45, 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_CFDP_COMPONENTS == 1
-  PeriodicTaskIF* cfdpTask = factory->createPeriodicTask(
-      "CFDP Handler", 45, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.4, missedDeadlineFunc);
-  result = cfdpTask->addComponent(objects::CFDP_HANDLER);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("CFDP Handler", objects::CFDP_HANDLER);
-  }
-#endif
-
-  PeriodicTaskIF* gpsTask = factory->createPeriodicTask(
-      "GPS_TASK", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 0.4, missedDeadlineFunc);
-  result = gpsTask->addComponent(objects::GPS_CONTROLLER);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("GPS_CTRL", objects::GPS_CONTROLLER);
-  }
-
-#if OBSW_ADD_ACS_BOARD == 1
-  PeriodicTaskIF* acsBrdPolling = factory->createPeriodicTask(
-      "ACS_BOARD_POLLING", 85, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 0.4, missedDeadlineFunc);
-  result = acsBrdPolling->addComponent(objects::ACS_BOARD_POLLING_TASK);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("ACS_BOARD_POLLING", objects::ACS_BOARD_POLLING_TASK);
-  }
-#endif
-
-#if OBSW_ADD_RW == 1
-  PeriodicTaskIF* rwPolling = factory->createPeriodicTask(
-      "RW_POLLING_TASK", 85, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 0.4, missedDeadlineFunc);
-  result = rwPolling->addComponent(objects::RW_POLLING_TASK);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("RW_POLLING_TASK", objects::RW_POLLING_TASK);
-  }
-#endif
-#if OBSW_ADD_MGT == 1
-  PeriodicTaskIF* imtqPolling = factory->createPeriodicTask(
-      "IMTQ_POLLING_TASK", 85, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 0.4, missedDeadlineFunc);
-  result = imtqPolling->addComponent(objects::IMTQ_POLLING);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("IMTQ_POLLING_TASK", objects::IMTQ_POLLING);
-  }
-#endif
-
-#if OBSW_ADD_SUN_SENSORS == 1
-  PeriodicTaskIF* susPolling = factory->createPeriodicTask(
-      "SUS_POLLING_TASK", 85, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 0.4, missedDeadlineFunc);
-  result = susPolling->addComponent(objects::SUS_POLLING_TASK);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("SUS_POLLING_TASK", objects::SUS_POLLING_TASK);
-  }
-#endif
-
-  PeriodicTaskIF* acsSysTask = factory->createPeriodicTask(
-      "ACS_SYS_TASK", 55, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 0.4, missedDeadlineFunc);
-  result = acsSysTask->addComponent(objects::ACS_SUBSYSTEM);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("ACS_SUBSYSTEM", objects::ACS_SUBSYSTEM);
-  }
-  result = acsSysTask->addComponent(objects::IMTQ_ASSY);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("IMTQ_ASSY", objects::IMTQ_ASSY);
-  }
-  result = acsSysTask->addComponent(objects::ACS_BOARD_ASS);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("ACS_BOARD_ASS", objects::ACS_BOARD_ASS);
-  }
-  result = acsSysTask->addComponent(objects::RW_ASSY);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("RW_ASS", objects::RW_ASSY);
-  }
-  result = acsSysTask->addComponent(objects::SUS_BOARD_ASS);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("SUS_BOARD_ASS", objects::SUS_BOARD_ASS);
-  }
-  result = acsSysTask->addComponent(objects::STR_ASSY);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("STR_ASSY", objects::STR_ASSY);
-  }
-
-  PeriodicTaskIF* tcsSystemTask = factory->createPeriodicTask(
-      "TCS_TASK", 55, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.5, missedDeadlineFunc);
-  scheduling::scheduleRtdSensors(tcsSystemTask);
-  result = tcsSystemTask->addComponent(objects::TCS_SUBSYSTEM);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("TCS_SUBSYSTEM", objects::TCS_SUBSYSTEM);
-  }
-  result = tcsSystemTask->addComponent(objects::TCS_BOARD_ASS);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("TCS_BOARD_ASS", objects::TCS_BOARD_ASS);
-  }
-#if OBSW_ADD_TCS_CTRL == 1
-  result = tcsSystemTask->addComponent(objects::THERMAL_CONTROLLER);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("THERMAL_CONTROLLER", objects::THERMAL_CONTROLLER);
-  }
-#endif
-#if OBSW_ADD_HEATERS == 1
-  result = tcsSystemTask->addComponent(objects::HEATER_HANDLER);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("HEATER_HANDLER", objects::HEATER_HANDLER);
-  }
-#endif
-
-#if OBSW_ADD_STAR_TRACKER == 1
-  PeriodicTaskIF* strHelperTask = factory->createPeriodicTask(
-      "STR_HELPER", 20, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
-  result = strHelperTask->addComponent(objects::STR_HELPER);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("STR_HELPER", objects::STR_HELPER);
-  }
-#endif /* OBSW_ADD_STAR_TRACKER == 1 */
-
-#if OBSW_ADD_PLOC_MPSOC == 1
-  PeriodicTaskIF* mpsocHelperTask = factory->createPeriodicTask(
-      "PLOC_MPSOC_HELPER", 20, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
-  result = mpsocHelperTask->addComponent(objects::PLOC_MPSOC_HELPER);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("PLOC_MPSOC_HELPER", objects::PLOC_MPSOC_HELPER);
-  }
-#endif /* OBSW_ADD_PLOC_MPSOC */
-
-#if OBSW_ADD_PLOC_SUPERVISOR == 1
-  PeriodicTaskIF* supvHelperTask = factory->createPeriodicTask(
-      "PLOC_SUPV_HELPER", 10, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, missedDeadlineFunc);
-  result = supvHelperTask->addComponent(objects::PLOC_SUPERVISOR_HELPER);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("PLOC_SUPV_HELPER", objects::PLOC_SUPERVISOR_HELPER);
-  }
-#endif /* OBSW_ADD_PLOC_SUPERVISOR */
-
-  PeriodicTaskIF* plTask = factory->createPeriodicTask(
-      "PL_TASK", 30, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.8, missedDeadlineFunc);
-  plTask->addComponent(objects::CAM_SWITCHER);
-  scheduling::addMpsocSupvHandlers(plTask);
-  scheduling::scheduleScexDev(plTask);
-
-#if OBSW_ADD_SCEX_DEVICE == 1
-  PeriodicTaskIF* scexReaderTask;
-  scheduling::scheduleScexReader(*factory, scexReaderTask);
-#endif
-
-  std::vector<PeriodicTaskIF*> pusTasks;
-  createPusTasks(*factory, missedDeadlineFunc, pusTasks);
-  std::vector<PeriodicTaskIF*> pstTasks;
-  AcsPstCfg cfg;
-  createPstTasks(*factory, missedDeadlineFunc, pstTasks, cfg);
-
-#if OBSW_ADD_TEST_CODE == 1
-#if OBSW_TEST_CCSDS_BRIDGE == 1
-  PeriodicTaskIF* ptmeTestTask = factory->createPeriodicTask(
-      "PTME_TEST", 80, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
-  result = ptmeTestTask->addComponent(objects::CCSDS_IP_CORE_BRIDGE);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("PTME_TEST", objects::CCSDS_IP_CORE_BRIDGE);
-  }
-#endif
-  std::vector<PeriodicTaskIF*> testTasks;
-  createTestTasks(*factory, missedDeadlineFunc, testTasks);
-#endif
-
-  auto taskStarter = [](std::vector<PeriodicTaskIF*>& taskVector, std::string name) {
-    for (const auto& task : taskVector) {
-      if (task != nullptr) {
-        task->startTask();
-      } else {
-        sif::error << "Task in vector " << name << " is invalid!" << std::endl;
-      }
-    }
-  };
-
-  sif::info << "Starting tasks.." << std::endl;
-  tmTcDistributor->startTask();
-
-#if OBSW_ADD_TCPIP_SERVERS == 1
-#if OBSW_ADD_TMTC_UDP_SERVER == 1
-  udpPollingTask->startTask();
-#endif
-#if OBSW_ADD_TMTC_TCP_SERVER == 1
-  tcpPollingTask->startTask();
-#endif
-#endif
-
-  genericSysTask->startTask();
-#if OBSW_ADD_CCSDS_IP_CORES == 1
-  pdecHandlerTask->startTask();
-#endif /* OBSW_ADD_CCSDS_IP_CORES == 1 */
-  liveTmTask->startTask();
-  logTmTask->startTask();
-  hkTmTask->startTask();
-  cfdpTmTask->startTask();
-
-  coreCtrlTask->startTask();
-#if OBSW_ADD_SA_DEPL == 1
-  solarArrayDeplTask->startTask();
-#endif
-#if OBSW_ADD_ACS_BOARD == 1
-  acsBrdPolling->startTask();
-#endif
-#if OBSW_ADD_MGT == 1
-  imtqPolling->startTask();
-#endif
-#if OBSW_ADD_SUN_SENSORS == 1
-  susPolling->startTask();
-#endif
-
-  taskStarter(pstTasks, "PST task vector");
-  taskStarter(pusTasks, "PUS task vector");
-#if OBSW_ADD_SCEX_DEVICE == 1
-  scexReaderTask->startTask();
-#endif
-
-#if OBSW_TEST_CCSDS_BRIDGE == 1
-  ptmeTestTask->startTask();
-#endif
-
-#if OBSW_ADD_CFDP_COMPONENTS == 1
-  cfdpTask->startTask();
-#endif
-
-#if OBSW_ADD_STAR_TRACKER == 1
-  strHelperTask->startTask();
-#endif /* OBSW_ADD_STAR_TRACKER == 1 */
-
-#if OBSW_ADD_RW == 1
-  rwPolling->startTask();
-#endif
-  gpsTask->startTask();
-  acsSysTask->startTask();
-  if (not tcsSystemTask->isEmpty()) {
-    tcsSystemTask->startTask();
-  }
-#if OBSW_ADD_PLOC_SUPERVISOR == 1
-  supvHelperTask->startTask();
-#endif /* OBSW_ADD_PLOC_SUPERVISOR == 1 */
-  plTask->startTask();
-
-#if OBSW_ADD_TEST_CODE == 1
-  taskStarter(testTasks, "Test task vector");
-#endif
-
-  sif::info << "Tasks started.." << std::endl;
-}
-
-void scheduling::createPstTasks(TaskFactory& factory, TaskDeadlineMissedFunction missedDeadlineFunc,
-                                std::vector<PeriodicTaskIF*>& taskVec, AcsPstCfg cfg) {
-  ReturnValue_t result = returnvalue::OK;
-
-#ifdef RELEASE_BUILD
-  static constexpr float acsPstPeriod = 0.4;
-#else
-  static constexpr float acsPstPeriod = 0.4;
-#endif
-  FixedTimeslotTaskIF* acsTcsPst = factory.createFixedTimeslotTask(
-      "ACS_TCS_PST", 80, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, acsPstPeriod, missedDeadlineFunc);
-  result = pst::pstTcsAndAcs(acsTcsPst, cfg);
-  if (result != returnvalue::OK) {
-    if (result == FixedTimeslotTaskIF::SLOT_LIST_EMPTY) {
-      sif::warning << "scheduling::initTasks: ACS PST is empty" << std::endl;
-    } else {
-      sif::error << "scheduling::initTasks: Creating ACS PST failed!" << std::endl;
-    }
-  } else {
-    taskVec.push_back(acsTcsPst);
-  }
-
-  /* Polling Sequence Table Default */
-#if OBSW_ADD_SPI_TEST_CODE == 0
-  FixedTimeslotTaskIF* syrlinksPst = factory.createFixedTimeslotTask(
-      "SYRLINKS", 45, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 0.5, missedDeadlineFunc);
-  result = pst::pstSyrlinks(syrlinksPst);
-  if (result != returnvalue::OK) {
-    if (result == FixedTimeslotTaskIF::SLOT_LIST_EMPTY) {
-      sif::warning << "scheduling::initTasks: SPI PST is empty" << std::endl;
-    } else {
-      sif::error << "scheduling::initTasks: Creating SPI PST failed!" << std::endl;
-    }
-  } else {
-    taskVec.push_back(syrlinksPst);
-  }
-#endif
-
-#if OBSW_ADD_I2C_TEST_CODE == 0
-  FixedTimeslotTaskIF* i2cPst = factory.createFixedTimeslotTask(
-      "I2C_PST", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 0.2, missedDeadlineFunc);
-  result = pst::pstI2c(i2cPst);
-  if (result != returnvalue::OK) {
-    if (result == FixedTimeslotTaskIF::SLOT_LIST_EMPTY) {
-      sif::warning << "scheduling::initTasks: I2C PST is empty" << std::endl;
-    } else {
-      sif::error << "scheduling::initTasks: Creating I2C PST failed!" << std::endl;
-    }
-  } else {
-    taskVec.push_back(i2cPst);
-  }
-#endif
-
-  FixedTimeslotTaskIF* gomSpacePstTask = factory.createFixedTimeslotTask(
-      "GS_PST_TASK", 65, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 1.0, missedDeadlineFunc);
-  result = pst::pstGompaceCan(gomSpacePstTask);
-  if (result != returnvalue::OK) {
-    if (result != FixedTimeslotTaskIF::SLOT_LIST_EMPTY) {
-      sif::error << "scheduling::initTasks: GomSpace PST initialization failed!" << std::endl;
-    }
-  }
-  taskVec.push_back(gomSpacePstTask);
-}
-
-void scheduling::createPusTasks(TaskFactory& factory, TaskDeadlineMissedFunction missedDeadlineFunc,
-                                std::vector<PeriodicTaskIF*>& taskVec) {
-  ReturnValue_t result = returnvalue::OK;
-  /* PUS Services */
-  PeriodicTaskIF* pusHighPrio = factory.createPeriodicTask(
-      "PUS_HIGH_PRIO", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
-  result = pusHighPrio->addComponent(objects::PUS_SERVICE_1_VERIFICATION);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("PUS_VERIF", objects::PUS_SERVICE_1_VERIFICATION);
-  }
-  result = pusHighPrio->addComponent(objects::PUS_SERVICE_5_EVENT_REPORTING);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("PUS_EVENTS", objects::PUS_SERVICE_5_EVENT_REPORTING);
-  }
-  result = pusHighPrio->addComponent(objects::EVENT_MANAGER);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("PUS_MGMT", objects::EVENT_MANAGER);
-  }
-  result = pusHighPrio->addComponent(objects::PUS_SERVICE_9_TIME_MGMT);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("PUS_9", objects::PUS_SERVICE_9_TIME_MGMT);
-  }
-  taskVec.push_back(pusHighPrio);
-
-  PeriodicTaskIF* pusMedPrio = factory.createPeriodicTask(
-      "PUS_MED_PRIO", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.8, missedDeadlineFunc);
-  result = pusMedPrio->addComponent(objects::PUS_SERVICE_3_HOUSEKEEPING);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("PUS_3", objects::PUS_SERVICE_3_HOUSEKEEPING);
-  }
-  result = pusMedPrio->addComponent(objects::PUS_SERVICE_8_FUNCTION_MGMT);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("PUS_8", objects::PUS_SERVICE_8_FUNCTION_MGMT);
-  }
-  result = pusMedPrio->addComponent(objects::PUS_SERVICE_15_TM_STORAGE);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("PUS_15", objects::PUS_SERVICE_15_TM_STORAGE);
-  }
-  result = pusMedPrio->addComponent(objects::PUS_SERVICE_11_TC_SCHEDULER);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("PUS_11", objects::PUS_SERVICE_11_TC_SCHEDULER);
-  }
-  result = pusMedPrio->addComponent(objects::PUS_SERVICE_20_PARAMETERS);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("PUS_20", objects::PUS_SERVICE_20_PARAMETERS);
-  }
-  result = pusMedPrio->addComponent(objects::PUS_SERVICE_200_MODE_MGMT);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("PUS_200", objects::PUS_SERVICE_200_MODE_MGMT);
-  }
-  result = pusMedPrio->addComponent(objects::PUS_SERVICE_201_HEALTH);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("PUS_201", objects::PUS_SERVICE_201_HEALTH);
-  }
-  result = pusMedPrio->addComponent(objects::PUS_SERVICE_2_DEVICE_ACCESS);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("PUS_2", objects::PUS_SERVICE_2_DEVICE_ACCESS);
-  }
-  taskVec.push_back(pusMedPrio);
-}
-
-void scheduling::createTestTasks(TaskFactory& factory,
-                                 TaskDeadlineMissedFunction missedDeadlineFunc,
-                                 std::vector<PeriodicTaskIF*>& taskVec) {
-#if OBSW_ADD_TEST_TASK == 1 && OBSW_ADD_TEST_CODE == 1
-  ReturnValue_t result = returnvalue::OK;
-  static_cast<void>(result);  // supress warning in case it is not used
-
-  PeriodicTaskIF* testTask = factory.createPeriodicTask(
-      "TEST_TASK", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1, missedDeadlineFunc);
-
-  result = testTask->addComponent(objects::TEST_TASK);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("TEST_TASK", objects::TEST_TASK);
-  }
-
-#if OBSW_ADD_SPI_TEST_CODE == 1
-  result = testTask->addComponent(objects::SPI_TEST);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("SPI_TEST", objects::SPI_TEST);
-  }
-#endif
-#if OBSW_ADD_I2C_TEST_CODE == 1
-  result = testTask->addComponent(objects::I2C_TEST);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("I2C_TEST", objects::I2C_TEST);
-  }
-#endif
-#if OBSW_ADD_UART_TEST_CODE == 1
-  result = testTask->addComponent(objects::UART_TEST);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("UART_TEST", objects::UART_TEST);
-  }
-#endif
-
-  taskVec.push_back(testTask);
-
-#endif  // OBSW_ADD_TEST_TASK == 1 && OBSW_ADD_TEST_CODE == 1
-}
-
-/**
-                   ▄              ▄
-                  ▌▒█           ▄▀▒▌
-                  ▌▒▒█        ▄▀▒▒▒▐
-                 ▐▄▀▒▒▀▀▀▀▄▄▄▀▒▒▒▒▒▐
-               ▄▄▀▒░▒▒▒▒▒▒▒▒▒█▒▒▄█▒▐
-             ▄▀▒▒▒░░░▒▒▒░░░▒▒▒▀██▀▒▌
-            ▐▒▒▒▄▄▒▒▒▒░░░▒▒▒▒▒▒▒▀▄▒▒▌
-            ▌░░▌█▀▒▒▒▒▒▄▀█▄▒▒▒▒▒▒▒█▒▐
-           ▐░░░▒▒▒▒▒▒▒▒▌██▀▒▒░░░▒▒▒▀▄▌
-           ▌░▒▄██▄▒▒▒▒▒▒▒▒▒░░░░░░▒▒▒▒▌
-          ▌▒▀▐▄█▄█▌▄░▀▒▒░░░░░░░░░░▒▒▒▐
-          ▐▒▒▐▀▐▀▒░▄▄▒▄▒▒▒▒▒▒░▒░▒░▒▒▒▒▌
-          ▐▒▒▒▀▀▄▄▒▒▒▄▒▒▒▒▒▒▒▒░▒░▒░▒▒▐
-           ▌▒▒▒▒▒▒▀▀▀▒▒▒▒▒▒░▒░▒░▒░▒▒▒▌
-           ▐▒▒▒▒▒▒▒▒▒▒▒▒▒▒░▒░▒░▒▒▄▒▒▐
-            ▀▄▒▒▒▒▒▒▒▒▒▒▒░▒░▒░▒▄▒▒▒▒▌
-              ▀▄▒▒▒▒▒▒▒▒▒▒▄▄▄▀▒▒▒▒▄▀
-                ▀▄▄▄▄▄▄▀▀▀▒▒▒▒▒▄▄▀
-                   ▒▒▒▒▒▒▒▒▒▒▀▀
- **/

bsp_q7s/em/emObjectFactory.cpp

@@ -1,108 +1,56 @@
-#include <bsp_q7s/callbacks/q7sGpioCallbacks.h>
-#include <dummies/ComCookieDummy.h>
-#include <dummies/PcduHandlerDummy.h>
 #include <fsfw/health/HealthTableIF.h>
-#include <fsfw/power/DummyPowerSwitcher.h>
-#include <fsfw_hal/common/gpio/GpioCookie.h>
-#include <mission/devices/devicedefinitions/GomspaceDefinitions.h>
-#include <mission/system/tree/system.h>
-#include <mission/utility/DummySdCardManager.h>
 
 #include "OBSWConfig.h"
 #include "bsp_q7s/core/CoreController.h"
 #include "bsp_q7s/core/ObjectFactory.h"
 #include "busConf.h"
+#include "commonObjects.h"
 #include "devConf.h"
-#include "dummies/helpers.h"
-#include "eive/objects.h"
 #include "fsfw_hal/linux/gpio/LinuxLibgpioIF.h"
 #include "linux/ObjectFactory.h"
 #include "linux/callbacks/gpioCallbacks.h"
 #include "mission/core/GenericFactory.h"
-#include "mission/system/tree/comModeTree.h"
 
 void ObjectFactory::produce(void* args) {
   ObjectFactory::setStatics();
   HealthTableIF* healthTable = nullptr;
-  PusTmFunnel* pusFunnel = nullptr;
-  CfdpTmFunnel* cfdpFunnel = nullptr;
-  StorageManagerIF* ipcStore = nullptr;
-  StorageManagerIF* tmStore = nullptr;
-
-  PersistentTmStores stores;
-  ObjectFactory::produceGenericObjects(&healthTable, &pusFunnel, &cfdpFunnel,
-                                       *SdCardManager::instance(), &ipcStore, &tmStore, stores);
+  ObjectFactory::produceGenericObjects(&healthTable);
 
   LinuxLibgpioIF* gpioComIF = nullptr;
-  SerialComIF* uartComIF = nullptr;
+  UartComIF* uartComIF = nullptr;
   SpiComIF* spiMainComIF = nullptr;
   I2cComIF* i2cComIF = nullptr;
-  createCommunicationInterfaces(&gpioComIF, &uartComIF, &spiMainComIF, &i2cComIF);
-  /* Adding gpios for chip select decoding to the gpioComIf */
-  q7s::gpioCallbacks::initSpiCsDecoder(gpioComIF);
-  gpioCallbacks::disableAllDecoder(gpioComIF);
-
-  // Hardware is usually not connected to EM, so we need to create dummies which replace lower
-  // level components.
-  dummy::DummyCfg dummyCfg;
-  dummyCfg.addCoreCtrlCfg = false;
-#if OBSW_ADD_SYRLINKS == 1
-  dummyCfg.addSyrlinksDummies = false;
-#endif
-#if OBSW_ADD_GOMSPACE_PCDU == 1
-  dummyCfg.addPowerDummies = false;
-#endif
-#if OBSW_ADD_ACS_BOARD == 1
-  dummyCfg.addAcsBoardDummies = false;
-#endif
-
   PowerSwitchIF* pwrSwitcher = nullptr;
-#if OBSW_ADD_GOMSPACE_PCDU == 0
-  auto* comCookieDummy = new ComCookieDummy();
-  pwrSwitcher = new PcduHandlerDummy(objects::PCDU_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
-#else
-  createPcduComponents(gpioComIF, &pwrSwitcher);
-#endif
-
-  dummy::createDummies(dummyCfg, *pwrSwitcher, gpioComIF);
-
+  SpiComIF* spiRwComIF = nullptr;
+  createCommunicationInterfaces(&gpioComIF, &uartComIF, &spiMainComIF, &i2cComIF, &spiRwComIF);
+  createTmpComponents();
   new CoreController(objects::CORE_CONTROLLER);
 
-  // Regular FM code, does not work for EM if the hardware is not connected
-  // createPcduComponents(gpioComIF, &pwrSwitcher);
-  // createPlPcduComponents(gpioComIF, spiMainComIF, pwrSwitcher);
-  // createSyrlinksComponents(pwrSwitcher);
-  // createSunSensorComponents(gpioComIF, spiMainComIF, pwrSwitcher, q7s::SPI_DEFAULT_DEV);
-  // createRtdComponents(q7s::SPI_DEFAULT_DEV, gpioComIF, pwrSwitcher, spiMainComIF);
-  // createTmpComponents();
-  // createSolarArrayDeploymentComponents();
-  // createPayloadComponents(gpioComIF);
-  // createHeaterComponents(gpioComIF, pwrSwitcher, healthTable);
-
-  // TODO: Careful! Switching this on somehow messes with the communication with the ProASIC
-  //       and will cause xsc_boot_copy commands to always boot to 0 0
-  // createRadSensorComponent(gpioComIF);
+  gpioCallbacks::disableAllDecoder(gpioComIF);
+  createPcduComponents(gpioComIF, &pwrSwitcher);
+  createRadSensorComponent(gpioComIF);
+  createSunSensorComponents(gpioComIF, spiMainComIF, pwrSwitcher, q7s::SPI_DEFAULT_DEV);
 
 #if OBSW_ADD_ACS_BOARD == 1
-  createAcsBoardComponents(gpioComIF, uartComIF, *pwrSwitcher);
-#else
-  // Still add all GPIOs for EM.
-  GpioCookie* acsBoardGpios = new GpioCookie();
-  createAcsBoardGpios(*acsBoardGpios);
-  gpioChecker(gpioComIF->addGpios(acsBoardGpios), "ACS Board");
+  createAcsBoardComponents(gpioComIF, uartComIF, pwrSwitcher);
 #endif
+  createHeaterComponents(gpioComIF, pwrSwitcher, healthTable);
+  createSolarArrayDeploymentComponents();
+  createPlPcduComponents(gpioComIF, spiMainComIF, pwrSwitcher);
+#if OBSW_ADD_SYRLINKS == 1
+#if OBSW_Q7S_EM == 1
+  createSyrlinksComponents(nullptr);
+#else
+  createSyrlinksComponents(pwrSwitcher);
+#endif /* OBSW_Q7S_EM == 1 */
+#endif /* OBSW_ADD_SYRLINKS == 1 */
+  createRtdComponents(q7s::SPI_DEFAULT_DEV, gpioComIF, pwrSwitcher, spiMainComIF);
+  createPayloadComponents(gpioComIF);
 
 #if OBSW_ADD_MGT == 1
   createImtqComponents(pwrSwitcher);
 #endif
-
-#if OBSW_ADD_SYRLINKS == 1
-  createSyrlinksComponents(pwrSwitcher);
-#endif /* OBSW_ADD_SYRLINKS == 1 */
-
-#if OBSW_ADD_RW == 1
   createReactionWheelComponents(gpioComIF, pwrSwitcher);
-#endif
 
 #if OBSW_ADD_BPX_BATTERY_HANDLER == 1
   createBpxBatteryComponent();
@@ -111,29 +59,13 @@ void ObjectFactory::produce(void* args) {
 #if OBSW_ADD_STAR_TRACKER == 1
   createStrComponents(pwrSwitcher);
 #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);
-  }
-#endif
-#endif /* OBSW_ADD_CCSDS_IP_CORES == 1 */
+#if OBSW_USE_CCSDS_IP_CORE == 1
+  createCcsdsComponents(gpioComIF);
+#endif /* OBSW_USE_CCSDS_IP_CORE == 1 */
   /* Test Task */
 #if OBSW_ADD_TEST_CODE == 1
   createTestComponents(gpioComIF);
 #endif /* OBSW_ADD_TEST_CODE == 1 */
-#if OBSW_ADD_SCEX_DEVICE == 1
-  createScexComponents(q7s::UART_SCEX_DEV, pwrSwitcher, *SdCardManager::instance(), false,
-                       pcdu::Switches::PDU1_CH5_SOLAR_CELL_EXP_5V);
-#endif
-  createAcsController(true);
-  HeaterHandler* heaterHandler = nullptr;
-  ObjectFactory::createGenericHeaterComponents(*gpioComIF, *pwrSwitcher, heaterHandler);
-  createThermalController(*heaterHandler);
-  satsystem::init();
+
+  createMiscComponents();
 }

bsp_q7s/fmObjectFactory.cpp

@@ -1,69 +1,45 @@
-#include <bsp_q7s/callbacks/q7sGpioCallbacks.h>
-#include <fsfw/storagemanager/LocalPool.h>
-#include <fsfw/storagemanager/PoolManager.h>
-#include <mission/devices/devicedefinitions/GomspaceDefinitions.h>
-
 #include "OBSWConfig.h"
 #include "bsp_q7s/core/CoreController.h"
 #include "bsp_q7s/core/ObjectFactory.h"
 #include "busConf.h"
+#include "commonObjects.h"
 #include "devConf.h"
-#include "eive/objects.h"
 #include "fsfw_hal/linux/gpio/LinuxLibgpioIF.h"
 #include "linux/ObjectFactory.h"
 #include "linux/callbacks/gpioCallbacks.h"
 #include "mission/core/GenericFactory.h"
-#include "mission/system/tree/system.h"
-#include "mission/tmtc/tmFilters.h"
 
 void ObjectFactory::produce(void* args) {
   ObjectFactory::setStatics();
   HealthTableIF* healthTable = nullptr;
-  PusTmFunnel* pusFunnel = nullptr;
-  CfdpTmFunnel* cfdpFunnel = nullptr;
-  StorageManagerIF* ipcStore = nullptr;
-  StorageManagerIF* tmStore = nullptr;
-
-  PersistentTmStores stores;
-  ObjectFactory::produceGenericObjects(&healthTable, &pusFunnel, &cfdpFunnel,
-                                       *SdCardManager::instance(), &ipcStore, &tmStore, stores);
+  ObjectFactory::produceGenericObjects(&healthTable);
 
   LinuxLibgpioIF* gpioComIF = nullptr;
-  SerialComIF* uartComIF = nullptr;
+  UartComIF* uartComIF = nullptr;
   SpiComIF* spiMainComIF = nullptr;
   I2cComIF* i2cComIF = nullptr;
   PowerSwitchIF* pwrSwitcher = nullptr;
-  createCommunicationInterfaces(&gpioComIF, &uartComIF, &spiMainComIF, &i2cComIF);
-  /* Adding gpios for chip select decoding to the gpioComIf */
-  q7s::gpioCallbacks::initSpiCsDecoder(gpioComIF);
-  gpioCallbacks::disableAllDecoder(gpioComIF);
-
+  SpiComIF* spiRwComIF = nullptr;
+  createCommunicationInterfaces(&gpioComIF, &uartComIF, &spiMainComIF, &i2cComIF, &spiRwComIF);
+  createTmpComponents();
   new CoreController(objects::CORE_CONTROLLER);
-  createPcduComponents(gpioComIF, &pwrSwitcher);
-  auto* stackHandler = new Stack5VHandler(*pwrSwitcher);
 
-#if OBSW_ADD_RAD_SENSORS == 1
-  createRadSensorComponent(gpioComIF, *stackHandler);
-#endif
-#if OBSW_ADD_SUN_SENSORS == 1
-  createSunSensorComponents(gpioComIF, spiMainComIF, *pwrSwitcher, q7s::SPI_DEFAULT_DEV, true);
-#endif
+  gpioCallbacks::disableAllDecoder(gpioComIF);
+  createPcduComponents(gpioComIF, &pwrSwitcher);
+  createRadSensorComponent(gpioComIF);
+  createSunSensorComponents(gpioComIF, spiMainComIF, pwrSwitcher, q7s::SPI_DEFAULT_DEV);
 
 #if OBSW_ADD_ACS_BOARD == 1
-  createAcsBoardComponents(*spiMainComIF, gpioComIF, uartComIF, *pwrSwitcher);
+  createAcsBoardComponents(gpioComIF, uartComIF, pwrSwitcher);
 #endif
-  HeaterHandler* heaterHandler;
-  createHeaterComponents(gpioComIF, pwrSwitcher, healthTable, heaterHandler);
-#if OBSW_ADD_TMP_DEVICES == 1
-  createTmpComponents();
-#endif
-  createSolarArrayDeploymentComponents(*pwrSwitcher, *gpioComIF);
-  createPlPcduComponents(gpioComIF, spiMainComIF, pwrSwitcher, *stackHandler);
+  createHeaterComponents(gpioComIF, pwrSwitcher, healthTable);
+  createSolarArrayDeploymentComponents();
+  createPlPcduComponents(gpioComIF, spiMainComIF, pwrSwitcher);
 #if OBSW_ADD_SYRLINKS == 1
   createSyrlinksComponents(pwrSwitcher);
 #endif /* OBSW_ADD_SYRLINKS == 1 */
   createRtdComponents(q7s::SPI_DEFAULT_DEV, gpioComIF, pwrSwitcher, spiMainComIF);
-  createPayloadComponents(gpioComIF, *pwrSwitcher);
+  createPayloadComponents(gpioComIF);
 
 #if OBSW_ADD_MGT == 1
   createImtqComponents(pwrSwitcher);
@@ -77,30 +53,15 @@ void ObjectFactory::produce(void* args) {
 #if OBSW_ADD_STAR_TRACKER == 1
   createStrComponents(pwrSwitcher);
 #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);
-  }
-#endif
-#endif /* OBSW_ADD_CCSDS_IP_CORES == 1 */
-
-#if OBSW_ADD_SCEX_DEVICE == 1
-  createScexComponents(q7s::UART_SCEX_DEV, pwrSwitcher, *SdCardManager::instance(), false,
-                       pcdu::Switches::PDU1_CH5_SOLAR_CELL_EXP_5V);
-#endif
+#if OBSW_USE_CCSDS_IP_CORE == 1
+  createCcsdsComponents(gpioComIF);
+#endif /* OBSW_USE_CCSDS_IP_CORE == 1 */
   /* Test Task */
 #if OBSW_ADD_TEST_CODE == 1
   createTestComponents(gpioComIF);
 #endif /* OBSW_ADD_TEST_CODE == 1 */
 
   createMiscComponents();
-  createThermalController(*heaterHandler);
-  createAcsController(true);
-  satsystem::init();
+  createThermalController();
+  createAcsController();
 }

bsp_q7s/fs/CMakeLists.txt

@@ -1,2 +0,0 @@
-target_sources(${OBSW_NAME} PRIVATE helpers.cpp SdCardManager.cpp
-                                    FilesystemHelper.cpp)

bsp_q7s/fs/helpers.cpp

@@ -1,11 +0,0 @@
-#include "helpers.h"
-
-std::filesystem::path fshelpers::getPrefixedPath(SdCardManager &man,
-                                                 std::filesystem::path pathWihtoutPrefix) {
-  auto prefix = man.getCurrentMountPrefix();
-  if (prefix == nullptr) {
-    return pathWihtoutPrefix;
-  }
-  auto resPath = prefix / pathWihtoutPrefix;
-  return resPath;
-}

bsp_q7s/fs/helpers.h

@@ -1,14 +0,0 @@
-#ifndef BSP_Q7S_MEMORY_HELPERS_H_
-#define BSP_Q7S_MEMORY_HELPERS_H_
-
-#include <filesystem>
-
-#include "SdCardManager.h"
-
-namespace fshelpers {
-
-std::filesystem::path getPrefixedPath(SdCardManager& man, std::filesystem::path pathWihtoutPrefix);
-
-}
-
-#endif /* BSP_Q7S_MEMORY_HELPERS_H_ */

bsp_q7s/main.cpp

@@ -12,10 +12,10 @@
  * @brief 	This is the main program for the target hardware.
  * @return
  */
-int main(int argc, char* argv[]) {
+int main(void) {
   using namespace std;
 #if Q7S_SIMPLE_MODE == 0
-  return obsw::obsw(argc, argv);
+  return obsw::obsw();
 #else
   return simple::simple();
 #endif

bsp_q7s/memory/CMakeLists.txt

@@ -1 +1,2 @@
-target_sources(${OBSW_NAME} PRIVATE scratchApi.cpp LocalParameterHandler.cpp)
+target_sources(${OBSW_NAME} PRIVATE FileSystemHandler.cpp SdCardManager.cpp
+                                    scratchApi.cpp FilesystemHelper.cpp)

bsp_q7s/memory/FileSystemHandler.cpp

@@ -0,0 +1,238 @@
+#include "FileSystemHandler.h"
+
+#include <cstring>
+#include <filesystem>
+#include <fstream>
+
+#include "bsp_q7s/core/CoreController.h"
+#include "fsfw/ipc/QueueFactory.h"
+#include "fsfw/memory/GenericFileSystemMessage.h"
+#include "fsfw/tasks/TaskFactory.h"
+
+FileSystemHandler::FileSystemHandler(object_id_t fileSystemHandler)
+    : SystemObject(fileSystemHandler) {
+  auto mqArgs = MqArgs(this->getObjectId());
+  mq = QueueFactory::instance()->createMessageQueue(FS_MAX_QUEUE_SIZE,
+                                                    MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
+}
+
+FileSystemHandler::~FileSystemHandler() { QueueFactory::instance()->deleteMessageQueue(mq); }
+
+ReturnValue_t FileSystemHandler::performOperation(uint8_t unsignedChar) {
+  while (true) {
+    try {
+      fileSystemHandlerLoop();
+    } catch (std::bad_alloc& e) {
+      // Restart OBSW, hints at a memory leak
+      sif::error << "Allocation error in FileSystemHandler::performOperation" << e.what()
+                 << std::endl;
+      // Set up an error file or a special flag in the scratch buffer for these cases
+      triggerEvent(CoreController::ALLOC_FAILURE, 0, 0);
+      CoreController::incrementAllocationFailureCount();
+    }
+  }
+}
+
+void FileSystemHandler::fileSystemHandlerLoop() {
+  CommandMessage filemsg;
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  while (true) {
+    if (opCounter % 5 == 0) {
+      if (coreCtrl->sdInitFinished()) {
+        fileSystemCheckup();
+      }
+    }
+    result = mq->receiveMessage(&filemsg);
+    if (result == MessageQueueIF::EMPTY) {
+      break;
+    } else if (result != HasReturnvaluesIF::RETURN_FAILED) {
+      sif::warning << "FileSystemHandler::performOperation: Message reception failed!" << std::endl;
+      break;
+    }
+    Command_t command = filemsg.getCommand();
+    switch (command) {
+      case (GenericFileSystemMessage::CMD_CREATE_DIRECTORY): {
+        break;
+      }
+      case (GenericFileSystemMessage::CMD_CREATE_FILE): {
+        break;
+      }
+    }
+    opCounter++;
+  }
+
+  // This task will have a low priority and will run permanently in the background
+  // so we will just run in a permanent loop here and check file system
+  // messages permanently
+  opCounter++;
+  TaskFactory::instance()->delayTask(1000);
+}
+
+void FileSystemHandler::fileSystemCheckup() {
+  SdCardManager::SdStatePair statusPair;
+  sdcMan->getSdCardsStatus(statusPair);
+  sd::SdCard preferredSdCard = sdcMan->getPreferredSdCard();
+  if ((preferredSdCard == sd::SdCard::SLOT_0) and (statusPair.first == sd::SdState::MOUNTED)) {
+    currentMountPrefix = SdCardManager::SD_0_MOUNT_POINT;
+  } else if ((preferredSdCard == sd::SdCard::SLOT_1) and
+             (statusPair.second == sd::SdState::MOUNTED)) {
+    currentMountPrefix = SdCardManager::SD_1_MOUNT_POINT;
+  } else {
+    std::string sdString;
+    if (preferredSdCard == sd::SdCard::SLOT_0) {
+      sdString = "0";
+    } else {
+      sdString = "1";
+    }
+    sif::warning << "FileSystemHandler::performOperation: "
+                    "Inconsistent state detected"
+                 << std::endl;
+    sif::warning << "Preferred SD card is " << sdString
+                 << " but does not appear to be mounted. Attempting fix.." << std::endl;
+    // This function will appear to fix the inconsistent state
+    ReturnValue_t result = sdcMan->sanitizeState(&statusPair, preferredSdCard);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      // Oh no.
+      triggerEvent(SdCardManager::SANITIZATION_FAILED, 0, 0);
+      sif::error << "FileSystemHandler::fileSystemCheckup: Sanitization failed" << std::endl;
+    }
+  }
+}
+
+MessageQueueId_t FileSystemHandler::getCommandQueue() const { return mq->getId(); }
+
+ReturnValue_t FileSystemHandler::initialize() {
+  coreCtrl = ObjectManager::instance()->get<CoreController>(objects::CORE_CONTROLLER);
+  if (coreCtrl == nullptr) {
+    sif::error << "FileSystemHandler::initialize: Could not retrieve core controller handle"
+               << std::endl;
+  }
+  sdcMan = SdCardManager::instance();
+  sd::SdCard preferredSdCard = sdcMan->getPreferredSdCard();
+  if (preferredSdCard == sd::SdCard::SLOT_0) {
+    currentMountPrefix = SdCardManager::SD_0_MOUNT_POINT;
+  } else if (preferredSdCard == sd::SdCard::SLOT_1) {
+    currentMountPrefix = SdCardManager::SD_1_MOUNT_POINT;
+  }
+  return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t FileSystemHandler::appendToFile(const char* repositoryPath, const char* filename,
+                                              const uint8_t* data, size_t size,
+                                              uint16_t packetNumber, FileSystemArgsIF* args) {
+  auto path = getInitPath(args) / repositoryPath / filename;
+  if (not std::filesystem::exists(path)) {
+    return FILE_DOES_NOT_EXIST;
+  }
+  std::ofstream file(path, std::ios_base::app | std::ios_base::out);
+  file.write(reinterpret_cast<const char*>(data), size);
+  if (not file.good()) {
+    return GENERIC_FILE_ERROR;
+  }
+  return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t FileSystemHandler::createFile(const char* repositoryPath, const char* filename,
+                                            const uint8_t* data, size_t size,
+                                            FileSystemArgsIF* args) {
+  auto path = getInitPath(args) / filename;
+  if (std::filesystem::exists(path)) {
+    return FILE_ALREADY_EXISTS;
+  }
+  std::ofstream file(path);
+  file.write(reinterpret_cast<const char*>(data), size);
+  if (not file.good()) {
+    return GENERIC_FILE_ERROR;
+  }
+  return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t FileSystemHandler::removeFile(const char* repositoryPath, const char* filename,
+                                            FileSystemArgsIF* args) {
+  auto path = getInitPath(args) / repositoryPath / filename;
+  if (not std::filesystem::exists(path)) {
+    return FILE_DOES_NOT_EXIST;
+  }
+  int result = std::remove(path.c_str());
+  if (result != 0) {
+    sif::warning << "FileSystemHandler::deleteFile: Failed with code " << result << std::endl;
+    return GENERIC_FILE_ERROR;
+  }
+  return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t FileSystemHandler::createDirectory(const char* repositoryPath, const char* dirname,
+                                                 bool createParentDirs, FileSystemArgsIF* args) {
+  auto path = getInitPath(args) / repositoryPath / dirname;
+  if (std::filesystem::exists(path)) {
+    return DIRECTORY_ALREADY_EXISTS;
+  }
+  if (std::filesystem::create_directory(path)) {
+    return HasReturnvaluesIF::RETURN_OK;
+  }
+  sif::warning << "Creating directory " << path << " failed" << std::endl;
+  return GENERIC_FILE_ERROR;
+}
+
+ReturnValue_t FileSystemHandler::removeDirectory(const char* repositoryPath, const char* dirname,
+                                                 bool deleteRecurively, FileSystemArgsIF* args) {
+  auto path = getInitPath(args) / repositoryPath / dirname;
+  if (not std::filesystem::exists(path)) {
+    return DIRECTORY_DOES_NOT_EXIST;
+  }
+  std::error_code err;
+  if (not deleteRecurively) {
+    if (std::filesystem::remove(path, err)) {
+      return HasReturnvaluesIF::RETURN_OK;
+    } else {
+      // Check error code. Most probably denied permissions because folder is not empty
+      sif::warning << "FileSystemHandler::removeDirectory: Deleting directory failed with "
+                      "code "
+                   << err.value() << ": " << strerror(err.value()) << std::endl;
+      if (err.value() == ENOTEMPTY) {
+        return DIRECTORY_NOT_EMPTY;
+      } else {
+        return GENERIC_FILE_ERROR;
+      }
+    }
+  } else {
+    if (std::filesystem::remove_all(path, err)) {
+      return HasReturnvaluesIF::RETURN_OK;
+    } else {
+      sif::warning << "FileSystemHandler::removeDirectory: Deleting directory failed with "
+                      "code "
+                   << err.value() << ": " << strerror(err.value()) << std::endl;
+      // Check error code
+      if (err.value() == ENOTEMPTY) {
+        return DIRECTORY_NOT_EMPTY;
+      } else {
+        return GENERIC_FILE_ERROR;
+      }
+    }
+  }
+
+  return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t FileSystemHandler::renameFile(const char* repositoryPath, const char* oldFilename,
+                                            const char* newFilename, FileSystemArgsIF* args) {
+  auto basepath = getInitPath(args) / repositoryPath;
+  std::filesystem::rename(basepath / oldFilename, basepath / newFilename);
+  return HasReturnvaluesIF::RETURN_OK;
+}
+
+void FileSystemHandler::parseCfg(FsCommandCfg* cfg, bool& useMountPrefix) {
+  if (cfg != nullptr) {
+    useMountPrefix = cfg->useMountPrefix;
+  }
+}
+
+std::filesystem::path FileSystemHandler::getInitPath(FileSystemArgsIF* args) {
+  bool useMountPrefix = true;
+  parseCfg(reinterpret_cast<FsCommandCfg*>(args), useMountPrefix);
+  std::string path;
+  if (useMountPrefix) {
+    path = currentMountPrefix;
+  }
+  return std::filesystem::path(path);
+}

bsp_q7s/memory/FileSystemHandler.h

@@ -0,0 +1,68 @@
+#ifndef BSP_Q7S_MEMORY_FILESYSTEMHANDLER_H_
+#define BSP_Q7S_MEMORY_FILESYSTEMHANDLER_H_
+
+#include <filesystem>
+#include <string>
+
+#include "OBSWConfig.h"
+#include "SdCardManager.h"
+#include "eive/definitions.h"
+#include "fsfw/ipc/MessageQueueIF.h"
+#include "fsfw/memory/HasFileSystemIF.h"
+#include "fsfw/objectmanager/SystemObject.h"
+#include "fsfw/tasks/ExecutableObjectIF.h"
+
+class CoreController;
+
+class FileSystemHandler : public SystemObject, public ExecutableObjectIF, public HasFileSystemIF {
+ public:
+  struct FsCommandCfg : public FileSystemArgsIF {
+    // Can be used to automatically use mount prefix of active SD card.
+    // Otherwise, the operator has to specify the full path to the mounted SD card as well.
+    bool useMountPrefix = false;
+  };
+
+  FileSystemHandler(object_id_t fileSystemHandler);
+  virtual ~FileSystemHandler();
+
+  ReturnValue_t performOperation(uint8_t) override;
+
+  ReturnValue_t initialize() override;
+
+  /**
+   * Function to get the MessageQueueId_t of the implementing object
+   * @return MessageQueueId_t of the object
+   */
+  MessageQueueId_t getCommandQueue() const override;
+  ReturnValue_t appendToFile(const char* repositoryPath, const char* filename, const uint8_t* data,
+                             size_t size, uint16_t packetNumber,
+                             FileSystemArgsIF* args = nullptr) override;
+  ReturnValue_t createFile(const char* repositoryPath, const char* filename,
+                           const uint8_t* data = nullptr, size_t size = 0,
+                           FileSystemArgsIF* args = nullptr) override;
+  ReturnValue_t removeFile(const char* repositoryPath, const char* filename,
+                           FileSystemArgsIF* args = nullptr) override;
+  ReturnValue_t createDirectory(const char* repositoryPath, const char* dirname,
+                                bool createParentDirs, FileSystemArgsIF* args = nullptr) override;
+  ReturnValue_t removeDirectory(const char* repositoryPath, const char* dirname,
+                                bool deleteRecurively = false,
+                                FileSystemArgsIF* args = nullptr) override;
+  ReturnValue_t renameFile(const char* repositoryPath, const char* oldFilename,
+                           const char* newFilename, FileSystemArgsIF* args = nullptr) override;
+
+ private:
+  CoreController* coreCtrl = nullptr;
+  MessageQueueIF* mq = nullptr;
+  std::string currentMountPrefix = SdCardManager::SD_0_MOUNT_POINT;
+  static constexpr uint32_t FS_MAX_QUEUE_SIZE = config::OBSW_FILESYSTEM_HANDLER_QUEUE_SIZE;
+
+  SdCardManager* sdcMan = nullptr;
+  uint8_t opCounter = 0;
+
+  void fileSystemHandlerLoop();
+  void fileSystemCheckup();
+  std::filesystem::path getInitPath(FileSystemArgsIF* args);
+  void parseCfg(FsCommandCfg* cfg, bool& useMountPrefix);
+};
+
+#endif /* BSP_Q7S_MEMORY_FILESYSTEMMANAGER_H_ */

bsp_q7s/memory/FilesystemHelper.cpp

@@ -3,9 +3,8 @@
 #include <filesystem>
 #include <fstream>
 
-#include "SdCardManager.h"
-#include "eive/definitions.h"
-#include "fsfw/serviceinterface.h"
+#include "bsp_q7s/memory/SdCardManager.h"
+#include "fsfw/serviceinterface/ServiceInterfaceStream.h"
 
 FilesystemHelper::FilesystemHelper() {}
 
@@ -13,26 +12,27 @@ ReturnValue_t FilesystemHelper::checkPath(std::string path) {
   SdCardManager* sdcMan = SdCardManager::instance();
   if (sdcMan == nullptr) {
     sif::warning << "FilesystemHelper::checkPath: Invalid SD card manager" << std::endl;
-    return returnvalue::FAILED;
+    return RETURN_FAILED;
   }
-  if (path.substr(0, sizeof(config::SD_0_MOUNT_POINT)) == std::string(config::SD_0_MOUNT_POINT)) {
-    if (!sdcMan->isSdCardUsable(sd::SLOT_0)) {
+  if (path.substr(0, sizeof(SdCardManager::SD_0_MOUNT_POINT)) ==
+      std::string(SdCardManager::SD_0_MOUNT_POINT)) {
+    if (!sdcMan->isSdCardMounted(sd::SLOT_0)) {
       sif::warning << "FilesystemHelper::checkPath: SD card 0 not mounted" << std::endl;
       return SD_NOT_MOUNTED;
     }
-  } else if (path.substr(0, sizeof(config::SD_1_MOUNT_POINT)) ==
-             std::string(config::SD_1_MOUNT_POINT)) {
-    if (!sdcMan->isSdCardUsable(sd::SLOT_1)) {
+  } else if (path.substr(0, sizeof(SdCardManager::SD_1_MOUNT_POINT)) ==
+             std::string(SdCardManager::SD_1_MOUNT_POINT)) {
+    if (!sdcMan->isSdCardMounted(sd::SLOT_0)) {
       sif::warning << "FilesystemHelper::checkPath: SD card 1 not mounted" << std::endl;
       return SD_NOT_MOUNTED;
     }
   }
-  return returnvalue::OK;
+  return RETURN_OK;
 }
 
 ReturnValue_t FilesystemHelper::fileExists(std::string file) {
   if (not std::filesystem::exists(file)) {
     return FILE_NOT_EXISTS;
   }
-  return returnvalue::OK;
+  return RETURN_OK;
 }

bsp_q7s/memory/FilesystemHelper.h

@@ -3,15 +3,15 @@
 
 #include <string>
 
-#include "eive/resultClassIds.h"
-#include "fsfw/returnvalues/returnvalue.h"
+#include "commonClassIds.h"
+#include "fsfw/returnvalues/HasReturnvaluesIF.h"
 
 /**
  * @brief   This class implements often used functions related to the file system management.
  *
  * @author  J. Meier
  */
-class FilesystemHelper {
+class FilesystemHelper : public HasReturnvaluesIF {
  public:
   static const uint8_t INTERFACE_ID = CLASS_ID::FILE_SYSTEM_HELPER;
 
@@ -26,7 +26,7 @@ class FilesystemHelper {
    *
    * @param path  Path to check
    *
-   * @return  returnvalue::OK if path points to SD card and the appropriate SD card is mounted or if
+   * @return  RETURN_OK if path points to SD card and the appropriate SD card is mounted or if
    *          path does not point to SD card.
    *          Return error code if path points to SD card and the corresponding SD card is not
    *          mounted.
@@ -38,7 +38,7 @@ class FilesystemHelper {
    *
    * @param file   File to check
    *
-   * @return  returnvalue::OK if file exists, otherwise return error code.
+   * @return  RETURN_OK if file exists, otherwise return error code.
    */
   static ReturnValue_t fileExists(std::string file);
 

bsp_q7s/memory/LocalParameterHandler.cpp

@@ -1,41 +0,0 @@
-#include "LocalParameterHandler.h"
-
-#include <fsfw/serviceinterface/ServiceInterface.h>
-
-LocalParameterHandler::LocalParameterHandler(std::string sdRelativeName, SdCardMountedIF* sdcMan)
-    : NVMParameterBase(), sdRelativeName(sdRelativeName), sdcMan(sdcMan) {}
-
-LocalParameterHandler::~LocalParameterHandler() {}
-
-ReturnValue_t LocalParameterHandler::initialize() {
-  ReturnValue_t result = updateFullName();
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  result = readJsonFile();
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  return returnvalue::OK;
-}
-
-ReturnValue_t LocalParameterHandler::writeJsonFile() {
-  ReturnValue_t result = updateFullName();
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  return NVMParameterBase::writeJsonFile();
-}
-
-ReturnValue_t LocalParameterHandler::updateFullName() {
-  std::string mountPrefix;
-  auto activeSd = sdcMan->getActiveSdCard();
-  if (activeSd and sdcMan->isSdCardUsable(activeSd.value())) {
-    mountPrefix = sdcMan->getCurrentMountPrefix();
-  } else {
-    return SD_NOT_READY;
-  }
-  std::string fullname = mountPrefix + "/" + sdRelativeName;
-  NVMParameterBase::setFullName(fullname);
-  return returnvalue::OK;
-}

bsp_q7s/memory/LocalParameterHandler.h

@@ -1,106 +0,0 @@
-#ifndef BSP_Q7S_MEMORY_LOCALPARAMETERHANDLER_H_
-#define BSP_Q7S_MEMORY_LOCALPARAMETERHANDLER_H_
-
-#include <mission/memory/NvmParameterBase.h>
-#include <mission/memory/SdCardMountedIF.h>
-
-#include <string>
-
-/**
- * @brief	Class to handle persistent parameters
- *
- */
-class LocalParameterHandler : public NVMParameterBase {
- public:
-  static constexpr uint8_t INTERFACE_ID = CLASS_ID::LOCAL_PARAM_HANDLER;
-
-  static constexpr ReturnValue_t SD_NOT_READY = returnvalue::makeCode(INTERFACE_ID, 0);
-  /**
-   * @brief	Constructor
-   *
-   * @param sdRelativeName	Absolute name of json file relative to mount
-   * 												directory
-   * of SD card. E.g. conf/example.json
-   * @param sdcMan	Pointer to SD card manager
-   */
-  LocalParameterHandler(std::string sdRelativeName, SdCardMountedIF* sdcMan);
-  virtual ~LocalParameterHandler();
-
-  /**
-   * @brief Will initialize the local parameter handler
-   *
-   * @return OK if successful, otherwise error return value
-   */
-  ReturnValue_t initialize();
-
-  /**
-   * @brief Function to add parameter to json file. If the json file does
-   * 				not yet exist it will be created here.
-   *
-   * @param key	The string to identify the parameter
-   * @param value	The value to set for this parameter
-   *
-   * @return OK if successful, otherwise error return value
-   *
-   * @details The function will add the parameter only if it is not already
-   * 					present in the json file
-   */
-  template <typename T>
-  ReturnValue_t addParameter(std::string key, T value);
-
-  /**
-   * @brief	Function will update a parameter which already exists in the json
-   * 				file
-   *
-   * @param key 	The unique string to identify the parameter to update
-   * @param value The new new value to set
-   *
-   * @return OK if successful, otherwise error return value
-   */
-  template <typename T>
-  ReturnValue_t updateParameter(std::string key, T value);
-
- private:
-  // Name relative to mount point of SD card where parameters will be stored
-  std::string sdRelativeName;
-
-  SdCardMountedIF* sdcMan;
-
-  virtual ReturnValue_t writeJsonFile();
-
-  /**
-   * @brief This function sets the name of the json file dependent on the
-   * 				currently active SD card
-   *
-   * @return OK if successful, otherwise error return value
-   */
-  ReturnValue_t updateFullName();
-};
-
-template <typename T>
-inline ReturnValue_t LocalParameterHandler::addParameter(std::string key, T value) {
-  ReturnValue_t result = insertValue(key, value);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  result = writeJsonFile();
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  return returnvalue::OK;
-}
-
-template <typename T>
-inline ReturnValue_t LocalParameterHandler::updateParameter(std::string key, T value) {
-  ReturnValue_t result = setValue(key, value);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  result = writeJsonFile();
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  return returnvalue::OK;
-}
-
-#endif /* BSP_Q7S_MEMORY_LOCALPARAMETERHANDLER_H_ */

bsp_q7s/memory/SdCardManager.cpp

@@ -2,7 +2,6 @@
 
 #include <fsfw/ipc/MutexGuard.h>
 #include <fsfw/timemanager/Countdown.h>
-#include <fsfw/timemanager/Stopwatch.h>
 #include <unistd.h>
 
 #include <cstring>
@@ -11,43 +10,41 @@
 #include <memory>
 
 #include "OBSWConfig.h"
-#include "bsp_q7s/memory/scratchApi.h"
-#include "eive/definitions.h"
-#include "eive/objects.h"
+#include "common/config/commonObjects.h"
 #include "fsfw/ipc/MutexFactory.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"
 #include "linux/utility/utility.h"
+#include "scratchApi.h"
 
 SdCardManager* SdCardManager::INSTANCE = nullptr;
 
 SdCardManager::SdCardManager() : SystemObject(objects::SDC_MANAGER), cmdExecutor(256) {
-  sdLock = MutexFactory::instance()->createMutex();
-  prefLock = MutexFactory::instance()->createMutex();
-  defaultLock = MutexFactory::instance()->createMutex();
-
-  MutexGuard mg(prefLock, LOCK_TYPE, OTHER_TIMEOUT, LOCK_CTX);
-  if (mg.getLockResult() != returnvalue::OK) {
+  mutex = MutexFactory::instance()->createMutex();
+  ReturnValue_t result = mutex->lockMutex();
+  if (result != RETURN_OK) {
     sif::error << "SdCardManager::SdCardManager: Mutex lock failed" << std::endl;
   }
   uint8_t prefSdRaw = 0;
-  ReturnValue_t result = scratch::readNumber(scratch::PREFERED_SDC_KEY, prefSdRaw);
+  result = scratch::readNumber(scratch::PREFERED_SDC_KEY, prefSdRaw);
+  result = mutex->unlockMutex();
+  if (result != RETURN_OK) {
+    sif::error << "SdCardManager::SdCardManager: Mutex unlock failed" << std::endl;
+  }
 
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     if (result == scratch::KEY_NOT_FOUND) {
       sif::warning << "CoreController::sdCardInit: "
                       "Preferred SD card not set. Setting to 0"
                    << std::endl;
       setPreferredSdCard(sd::SdCard::SLOT_0);
-      scratch::writeNumber(scratch::PREFERED_SDC_KEY, static_cast<uint8_t>(sd::SdCard::SLOT_0));
-      prefSdRaw = sd::SdCard::SLOT_0;
-
+      sdInfo.pref = sd::SdCard::SLOT_0;
     } else {
       // Should not happen.
       // TODO: Maybe trigger event?
       sif::error << "SdCardManager::SdCardManager: Reading preferred SD card from scratch"
                     "buffer failed"
                  << std::endl;
-      prefSdRaw = sd::SdCard::SLOT_0;
+      sdInfo.pref = sd::SdCard::SLOT_0;
     }
   }
   sdInfo.pref = static_cast<sd::SdCard>(prefSdRaw);
@@ -68,7 +65,7 @@ SdCardManager* SdCardManager::instance() {
 
 ReturnValue_t SdCardManager::switchOnSdCard(sd::SdCard sdCard, bool doMountSdCard,
                                             SdStatePair* statusPair) {
-  ReturnValue_t result = returnvalue::OK;
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
   if (doMountSdCard) {
     if (not blocking) {
       sif::warning << "SdCardManager::switchOnSdCard: Two-step command but manager is"
@@ -83,7 +80,7 @@ ReturnValue_t SdCardManager::switchOnSdCard(sd::SdCard sdCard, bool doMountSdCar
     sdStatusPtr = std::make_unique<SdStatePair>();
     statusPair = sdStatusPtr.get();
     result = getSdCardsStatus(*statusPair);
-    if (result != returnvalue::OK) {
+    if (result != HasReturnvaluesIF::RETURN_OK) {
       return result;
     }
   }
@@ -92,7 +89,7 @@ ReturnValue_t SdCardManager::switchOnSdCard(sd::SdCard sdCard, bool doMountSdCar
   if (sdCard == sd::SdCard::BOTH) {
     sif::warning << "SdCardManager::switchOffSdCard: API does not allow sd::SdStatus::BOTH"
                  << std::endl;
-    return returnvalue::FAILED;
+    return HasReturnvaluesIF::RETURN_FAILED;
   }
 
   sd::SdState currentState;
@@ -116,10 +113,10 @@ ReturnValue_t SdCardManager::switchOnSdCard(sd::SdCard sdCard, bool doMountSdCar
   } else if (currentState == sd::SdState::OFF) {
     result = setSdCardState(sdCard, true);
   } else {
-    result = returnvalue::FAILED;
+    result = HasReturnvaluesIF::RETURN_FAILED;
   }
 
-  if (result != returnvalue::OK or not doMountSdCard) {
+  if (result != HasReturnvaluesIF::RETURN_OK or not doMountSdCard) {
     return result;
   }
 
@@ -130,7 +127,7 @@ ReturnValue_t SdCardManager::switchOffSdCard(sd::SdCard sdCard, bool doUnmountSd
                                              SdStatePair* statusPair) {
   std::pair<sd::SdState, sd::SdState> active;
   ReturnValue_t result = getSdCardsStatus(active);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     return result;
   }
   if (doUnmountSdCard) {
@@ -145,7 +142,7 @@ ReturnValue_t SdCardManager::switchOffSdCard(sd::SdCard sdCard, bool doUnmountSd
   if (sdCard == sd::SdCard::BOTH) {
     sif::warning << "SdCardManager::switchOffSdCard: API does not allow sd::SdStatus::BOTH"
                  << std::endl;
-    return returnvalue::FAILED;
+    return HasReturnvaluesIF::RETURN_FAILED;
   }
   if (sdCard == sd::SdCard::SLOT_0) {
     if (active.first == sd::SdState::OFF) {
@@ -159,7 +156,7 @@ ReturnValue_t SdCardManager::switchOffSdCard(sd::SdCard sdCard, bool doUnmountSd
 
   if (doUnmountSdCard) {
     result = unmountSdCard(sdCard);
-    if (result != returnvalue::OK) {
+    if (result != HasReturnvaluesIF::RETURN_OK) {
       return result;
     }
   }
@@ -190,16 +187,32 @@ 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 (blocking and result != HasReturnvaluesIF::RETURN_OK) {
     utility::handleSystemError(cmdExecutor.getLastError(), "SdCardManager::setSdCardState");
   }
   return result;
 }
 
-ReturnValue_t SdCardManager::getSdCardsStatus(SdStatePair& sdStates) {
-  MutexGuard mg(sdLock, LOCK_TYPE, SD_LOCK_TIMEOUT, LOCK_CTX);
-  sdStates = this->sdStates;
-  return returnvalue::OK;
+ReturnValue_t SdCardManager::getSdCardsStatus(SdStatePair& active) {
+  using namespace std;
+  MutexGuard mg(mutex);
+  if (not filesystem::exists(SD_STATE_FILE)) {
+    return STATUS_FILE_NEXISTS;
+  }
+
+  // Now the file should exist in any case. Still check whether it exists.
+  fstream sdStatus(SD_STATE_FILE);
+  if (not sdStatus.good()) {
+    return STATUS_FILE_NEXISTS;
+  }
+  string line;
+  uint8_t idx = 0;
+  sd::SdCard currentSd = sd::SdCard::SLOT_0;
+  // Process status file line by line
+  while (std::getline(sdStatus, line)) {
+    processSdStatusLine(active, line, idx, currentSd);
+  }
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t SdCardManager::mountSdCard(sd::SdCard sdCard) {
@@ -210,19 +223,18 @@ ReturnValue_t SdCardManager::mountSdCard(sd::SdCard sdCard) {
   if (sdCard == sd::SdCard::BOTH) {
     sif::warning << "SdCardManager::mountSdCard: API does not allow sd::SdStatus::BOTH"
                  << std::endl;
-    return returnvalue::FAILED;
+    return HasReturnvaluesIF::RETURN_FAILED;
   }
   string mountDev;
   string mountPoint;
   if (sdCard == sd::SdCard::SLOT_0) {
     mountDev = SD_0_DEV_NAME;
-    mountPoint = config::SD_0_MOUNT_POINT;
+    mountPoint = SD_0_MOUNT_POINT;
   } else if (sdCard == sd::SdCard::SLOT_1) {
     mountDev = SD_1_DEV_NAME;
-    mountPoint = config::SD_1_MOUNT_POINT;
+    mountPoint = SD_1_MOUNT_POINT;
   }
-  std::error_code e;
-  if (not filesystem::exists(mountDev, e)) {
+  if (not filesystem::exists(mountDev)) {
     sif::warning << "SdCardManager::mountSdCard: Device file does not exists. Make sure to"
                     " turn on the SD card"
                  << std::endl;
@@ -235,7 +247,7 @@ ReturnValue_t SdCardManager::mountSdCard(sd::SdCard sdCard) {
   string sdMountCommand = "mount " + mountDev + " " + mountPoint;
   cmdExecutor.load(sdMountCommand, blocking, printCmdOutput);
   ReturnValue_t result = cmdExecutor.execute();
-  if (blocking and result != returnvalue::OK) {
+  if (blocking and result != HasReturnvaluesIF::RETURN_OK) {
     utility::handleSystemError(cmdExecutor.getLastError(), "SdCardManager::mountSdCard");
   }
   return result;
@@ -249,16 +261,15 @@ ReturnValue_t SdCardManager::unmountSdCard(sd::SdCard sdCard) {
   if (sdCard == sd::SdCard::BOTH) {
     sif::warning << "SdCardManager::unmountSdCard: API does not allow sd::SdStatus::BOTH"
                  << std::endl;
-    return returnvalue::FAILED;
+    return HasReturnvaluesIF::RETURN_FAILED;
   }
   string mountPoint;
   if (sdCard == sd::SdCard::SLOT_0) {
-    mountPoint = config::SD_0_MOUNT_POINT;
+    mountPoint = SD_0_MOUNT_POINT;
   } else if (sdCard == sd::SdCard::SLOT_1) {
-    mountPoint = config::SD_1_MOUNT_POINT;
+    mountPoint = SD_1_MOUNT_POINT;
   }
-  std::error_code e;
-  if (not filesystem::exists(mountPoint, e)) {
+  if (not filesystem::exists(mountPoint)) {
     sif::error << "SdCardManager::unmountSdCard: Default mount point " << mountPoint
                << "does not exist" << std::endl;
     return UNMOUNT_ERROR;
@@ -274,7 +285,7 @@ ReturnValue_t SdCardManager::unmountSdCard(sd::SdCard sdCard) {
   }
   cmdExecutor.load(sdUnmountCommand, blocking, printCmdOutput);
   ReturnValue_t result = cmdExecutor.execute();
-  if (blocking and result != returnvalue::OK) {
+  if (blocking and result != HasReturnvaluesIF::RETURN_OK) {
     utility::handleSystemError(cmdExecutor.getLastError(), "SdCardManager::unmountSdCard");
   }
   return result;
@@ -282,17 +293,23 @@ ReturnValue_t SdCardManager::unmountSdCard(sd::SdCard sdCard) {
 
 ReturnValue_t SdCardManager::sanitizeState(SdStatePair* statusPair, sd::SdCard prefSdCard) {
   std::unique_ptr<SdStatePair> sdStatusPtr;
-  ReturnValue_t result = returnvalue::OK;
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
   // Enforce blocking operation for now. Be careful to reset it when returning prematurely!
   bool resetNonBlockingState = false;
   if (not this->blocking) {
     blocking = true;
     resetNonBlockingState = true;
   }
-  if (statusPair == nullptr) {
-    return returnvalue::FAILED;
+  if (prefSdCard == sd::SdCard::NONE) {
+    result = getPreferredSdCard();
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+    }
+  }
+  if (statusPair == nullptr) {
+    sdStatusPtr = std::make_unique<SdStatePair>();
+    statusPair = sdStatusPtr.get();
+    getSdCardsStatus(*statusPair);
   }
-  getSdCardsStatus(*statusPair);
 
   if (statusPair->first == sd::SdState::ON) {
     result = mountSdCard(prefSdCard);
@@ -310,34 +327,8 @@ void SdCardManager::resetState() {
   currentOp = Operations::IDLE;
 }
 
-ReturnValue_t SdCardManager::updateSdStatePair() {
-  using namespace std;
-
-  MutexGuard mg(sdLock, LOCK_TYPE, SD_LOCK_TIMEOUT, LOCK_CTX);
-  std::error_code e;
-  if (not filesystem::exists(SD_STATE_FILE, e)) {
-    return STATUS_FILE_NEXISTS;
-  }
-
-  // Now the file should exist in any case. Still check whether it exists.
-  fstream sdStatus(SD_STATE_FILE);
-  if (not sdStatus.good()) {
-    return STATUS_FILE_NEXISTS;
-  }
-  string line;
-  uint8_t idx = 0;
-  sd::SdCard currentSd = sd::SdCard::SLOT_0;
-  // Process status file line by line
-  while (std::getline(sdStatus, line)) {
-    processSdStatusLine(line, idx, currentSd);
-  }
-  if (sdStates.first != sd::SdState::MOUNTED && sdStates.second != sd::SdState::MOUNTED) {
-    sdCardActive = false;
-  }
-  return returnvalue::OK;
-}
-
-void SdCardManager::processSdStatusLine(std::string& line, uint8_t& idx, sd::SdCard& currentSd) {
+void SdCardManager::processSdStatusLine(std::pair<sd::SdState, sd::SdState>& active,
+                                        std::string& line, uint8_t& idx, sd::SdCard& currentSd) {
   using namespace std;
   istringstream iss(line);
   string word;
@@ -358,24 +349,24 @@ void SdCardManager::processSdStatusLine(std::string& line, uint8_t& idx, sd::SdC
 
       if (word == "on") {
         if (currentSd == sd::SdCard::SLOT_0) {
-          sdStates.first = sd::SdState::ON;
+          active.first = sd::SdState::ON;
         } else {
-          sdStates.second = sd::SdState::ON;
+          active.second = sd::SdState::ON;
         }
       } else if (word == "off") {
         if (currentSd == sd::SdCard::SLOT_0) {
-          sdStates.first = sd::SdState::OFF;
+          active.first = sd::SdState::OFF;
         } else {
-          sdStates.second = sd::SdState::OFF;
+          active.second = sd::SdState::OFF;
         }
       }
     }
 
     if (mountLine) {
       if (currentSd == sd::SdCard::SLOT_0) {
-        sdStates.first = sd::SdState::MOUNTED;
+        active.first = sd::SdState::MOUNTED;
       } else {
-        sdStates.second = sd::SdState::MOUNTED;
+        active.second = sd::SdState::MOUNTED;
       }
     }
 
@@ -388,19 +379,19 @@ void SdCardManager::processSdStatusLine(std::string& line, uint8_t& idx, sd::SdC
   idx++;
 }
 
-std::optional<sd::SdCard> SdCardManager::getPreferredSdCard() const {
-  MutexGuard mg(prefLock, LOCK_TYPE, OTHER_TIMEOUT, LOCK_CTX);
+sd::SdCard SdCardManager::getPreferredSdCard() const {
+  MutexGuard mg(mutex);
   auto res = mg.getLockResult();
-  if (res != returnvalue::OK) {
+  if (res != RETURN_OK) {
     sif::error << "SdCardManager::getPreferredSdCard: Lock error" << std::endl;
   }
   return sdInfo.pref;
 }
 
 ReturnValue_t SdCardManager::setPreferredSdCard(sd::SdCard sdCard) {
-  MutexGuard mg(prefLock, LOCK_TYPE, OTHER_TIMEOUT, LOCK_CTX);
+  MutexGuard mg(mutex);
   if (sdCard == sd::SdCard::BOTH) {
-    return returnvalue::FAILED;
+    return HasReturnvaluesIF::RETURN_FAILED;
   }
   sdInfo.pref = sdCard;
   return scratch::writeNumber(scratch::PREFERED_SDC_KEY, static_cast<uint8_t>(sdCard));
@@ -410,23 +401,24 @@ ReturnValue_t SdCardManager::updateSdCardStateFile() {
   if (cmdExecutor.getCurrentState() == CommandExecutor::States::PENDING) {
     return CommandExecutor::COMMAND_PENDING;
   }
-  MutexGuard mg(sdLock, LOCK_TYPE, SD_LOCK_TIMEOUT, LOCK_CTX);
+  MutexGuard mg(mutex);
   // Use q7hw utility and pipe the command output into the state file
   std::string updateCmd = "q7hw sd info all > " + std::string(SD_STATE_FILE);
-  cmdExecutor.load(updateCmd, true, printCmdOutput);
+  cmdExecutor.load(updateCmd, blocking, printCmdOutput);
   ReturnValue_t result = cmdExecutor.execute();
-  if (blocking and result != returnvalue::OK) {
+  if (blocking and result != HasReturnvaluesIF::RETURN_OK) {
     utility::handleSystemError(cmdExecutor.getLastError(), "SdCardManager::mountSdCard");
   }
   return result;
 }
 
-const char* SdCardManager::getCurrentMountPrefix() const {
-  MutexGuard mg(defaultLock, LOCK_TYPE, OTHER_TIMEOUT, LOCK_CTX);
-  if (currentPrefix.has_value()) {
-    return currentPrefix.value().c_str();
+std::string SdCardManager::getCurrentMountPrefix() const {
+  MutexGuard mg(mutex);
+  if (sdInfo.active == sd::SdCard::SLOT_0) {
+    return SD_0_MOUNT_POINT;
+  } else {
+    return SD_1_MOUNT_POINT;
   }
-  return nullptr;
 }
 
 SdCardManager::OpStatus SdCardManager::checkCurrentOp(Operations& currentOp) {
@@ -456,10 +448,10 @@ SdCardManager::OpStatus SdCardManager::checkCurrentOp(Operations& currentOp) {
       case (CommandExecutor::EXECUTION_FINISHED): {
         return OpStatus::SUCCESS;
       }
-      case (returnvalue::OK): {
+      case (HasReturnvaluesIF::RETURN_OK): {
         return OpStatus::ONGOING;
       }
-      case (returnvalue::FAILED): {
+      case (HasReturnvaluesIF::RETURN_FAILED): {
         return OpStatus::FAIL;
       }
       default: {
@@ -473,39 +465,28 @@ void SdCardManager::setBlocking(bool blocking) { this->blocking = blocking; }
 
 void SdCardManager::setPrintCommandOutput(bool print) { this->printCmdOutput = print; }
 
-bool SdCardManager::isSdCardUsable(std::optional<sd::SdCard> sdCard) {
-  {
-    MutexGuard mg(defaultLock, LOCK_TYPE, OTHER_TIMEOUT, LOCK_CTX);
-    if (markedUnusable) {
-      return false;
-    }
-  }
+bool SdCardManager::isSdCardMounted(sd::SdCard sdCard) {
+  SdCardManager::SdStatePair active;
+  ReturnValue_t result = this->getSdCardsStatus(active);
 
-  MutexGuard mg(sdLock, LOCK_TYPE, SD_LOCK_TIMEOUT, LOCK_CTX);
-  if (not sdCard) {
-    if (sdStates.first == sd::MOUNTED or sdStates.second == sd::MOUNTED) {
-      return true;
-    }
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    sif::debug << "SdCardManager::isSdCardMounted: Failed to get SD card active state";
     return false;
   }
   if (sdCard == sd::SLOT_0) {
-    if (sdStates.first == sd::MOUNTED) {
+    if (active.first == sd::MOUNTED) {
       return true;
     } else {
       return false;
     }
-  }
-  if (sdCard == sd::SLOT_1) {
-    if (sdStates.second == sd::MOUNTED) {
+  } else if (sdCard == sd::SLOT_1) {
+    if (active.second == sd::MOUNTED) {
       return true;
     } else {
       return false;
     }
-  }
-  if (sdCard == sd::BOTH) {
-    if (sdStates.first == sd::MOUNTED && sdStates.second == sd::MOUNTED) {
-      return true;
-    }
+  } else {
+    sif::debug << "SdCardManager::isSdCardMounted: Unknown SD card specified" << std::endl;
   }
   return false;
 }
@@ -513,34 +494,41 @@ bool SdCardManager::isSdCardUsable(std::optional<sd::SdCard> sdCard) {
 ReturnValue_t SdCardManager::isSdCardMountedReadOnly(sd::SdCard sdcard, bool& readOnly) {
   std::ostringstream command;
   if (sdcard == sd::SdCard::SLOT_0) {
-    command << "grep -q '" << config::SD_0_MOUNT_POINT << " ext4 rw,' /proc/mounts";
-  } else if (sdcard == sd::SdCard::SLOT_1) {
-    command << "grep -q '" << config::SD_1_MOUNT_POINT << " ext4 rw,' /proc/mounts";
+    command << "grep -q '" << SD_0_MOUNT_POINT << " vfat ro,' /proc/mounts";
   } else {
-    return returnvalue::FAILED;
+    command << "grep -q '" << SD_1_MOUNT_POINT << " vfat ro,' /proc/mounts";
   }
   ReturnValue_t result = cmdExecutor.load(command.str(), true, false);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     return result;
   }
   result = cmdExecutor.execute();
-  if (result == returnvalue::OK) {
-    readOnly = false;
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    int exitStatus = cmdExecutor.getLastError();
+    if (exitStatus == 1) {
+      readOnly = false;
+      return RETURN_OK;
+    }
     return result;
   }
+  auto& readVec = cmdExecutor.getReadVector();
+  size_t readLen = strnlen(readVec.data(), readVec.size());
+  if (readLen == 0) {
+    readOnly = false;
+  }
   readOnly = true;
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t SdCardManager::remountReadWrite(sd::SdCard sdcard) {
   std::ostringstream command;
   if (sdcard == sd::SdCard::SLOT_0) {
-    command << "mount -o remount,rw " << SD_0_DEV_NAME << " " << config::SD_0_MOUNT_POINT;
+    command << "mount -o remount,rw " << SD_0_DEV_NAME << " " << SD_0_MOUNT_POINT;
   } else {
-    command << "mount -o remount,rw " << SD_1_DEV_NAME << " " << config::SD_1_MOUNT_POINT;
+    command << "mount -o remount,rw " << SD_1_DEV_NAME << " " << SD_1_MOUNT_POINT;
   }
   ReturnValue_t result = cmdExecutor.load(command.str(), true, false);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     return result;
   }
   return cmdExecutor.execute();
@@ -554,35 +542,16 @@ ReturnValue_t SdCardManager::performFsck(sd::SdCard sdcard, bool printOutput, in
     command << "fsck -y " << SD_1_DEV_NAME;
   }
   ReturnValue_t result = cmdExecutor.load(command.str(), true, printOutput);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     return result;
   }
   result = cmdExecutor.execute();
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     linuxError = cmdExecutor.getLastError();
   }
   return result;
 }
 
-void SdCardManager::setActiveSdCard(sd::SdCard sdCard) {
-  MutexGuard mg(defaultLock, LOCK_TYPE, OTHER_TIMEOUT, LOCK_CTX);
-  sdInfo.active = sdCard;
-  if (sdInfo.active == sd::SdCard::SLOT_0) {
-    currentPrefix = config::SD_0_MOUNT_POINT;
-  } else {
-    currentPrefix = config::SD_1_MOUNT_POINT;
-  }
-}
+void SdCardManager::setActiveSdCard(sd::SdCard sdCard) { sdInfo.active = sdCard; }
 
-std::optional<sd::SdCard> SdCardManager::getActiveSdCard() const {
-  MutexGuard mg(defaultLock, LOCK_TYPE, OTHER_TIMEOUT, LOCK_CTX);
-  if (markedUnusable) {
-    return std::nullopt;
-  }
-  return sdInfo.active;
-}
-
-void SdCardManager::markUnusable() {
-  MutexGuard mg(defaultLock, LOCK_TYPE, OTHER_TIMEOUT, LOCK_CTX);
-  markedUnusable = true;
-}
+sd::SdCard SdCardManager::getActiveSdCard() const { return sdInfo.active; }

bsp_q7s/memory/SdCardManager.h

@@ -12,7 +12,7 @@
 
 #include "events/subsystemIdRanges.h"
 #include "fsfw/events/Event.h"
-#include "fsfw/returnvalues/returnvalue.h"
+#include "fsfw/returnvalues/HasReturnvaluesIF.h"
 #include "fsfw_hal/linux/CommandExecutor.h"
 #include "mission/memory/SdCardMountedIF.h"
 #include "mission/memory/definitions.h"
@@ -24,8 +24,8 @@ class MutexIF;
  * @brief   Manages handling of SD cards like switching them on or off or getting the current
  *          state
  */
-class SdCardManager : public SystemObject, public SdCardMountedIF {
-  friend class CoreController;
+class SdCardManager : public SystemObject, public HasReturnvaluesIF, public SdCardMountedIF {
+  friend class SdCardAccess;
 
  public:
   using mountInitCb = ReturnValue_t (*)(void* args);
@@ -44,17 +44,22 @@ class SdCardManager : public SystemObject, public SdCardMountedIF {
 
   static constexpr uint8_t INTERFACE_ID = CLASS_ID::SD_CARD_MANAGER;
 
-  static constexpr ReturnValue_t OP_ONGOING = returnvalue::makeCode(INTERFACE_ID, 0);
-  static constexpr ReturnValue_t ALREADY_ON = returnvalue::makeCode(INTERFACE_ID, 1);
-  static constexpr ReturnValue_t ALREADY_MOUNTED = returnvalue::makeCode(INTERFACE_ID, 2);
-  static constexpr ReturnValue_t ALREADY_OFF = returnvalue::makeCode(INTERFACE_ID, 3);
-  static constexpr ReturnValue_t STATUS_FILE_NEXISTS = returnvalue::makeCode(INTERFACE_ID, 10);
+  static constexpr ReturnValue_t OP_ONGOING = HasReturnvaluesIF::makeReturnCode(INTERFACE_ID, 0);
+  static constexpr ReturnValue_t ALREADY_ON = HasReturnvaluesIF::makeReturnCode(INTERFACE_ID, 1);
+  static constexpr ReturnValue_t ALREADY_MOUNTED =
+      HasReturnvaluesIF::makeReturnCode(INTERFACE_ID, 2);
+  static constexpr ReturnValue_t ALREADY_OFF = HasReturnvaluesIF::makeReturnCode(INTERFACE_ID, 3);
+  static constexpr ReturnValue_t STATUS_FILE_NEXISTS =
+      HasReturnvaluesIF::makeReturnCode(INTERFACE_ID, 10);
   static constexpr ReturnValue_t STATUS_FILE_FORMAT_INVALID =
-      returnvalue::makeCode(INTERFACE_ID, 11);
-  static constexpr ReturnValue_t MOUNT_ERROR = returnvalue::makeCode(INTERFACE_ID, 12);
-  static constexpr ReturnValue_t UNMOUNT_ERROR = returnvalue::makeCode(INTERFACE_ID, 13);
-  static constexpr ReturnValue_t SYSTEM_CALL_ERROR = returnvalue::makeCode(INTERFACE_ID, 14);
-  static constexpr ReturnValue_t POPEN_CALL_ERROR = returnvalue::makeCode(INTERFACE_ID, 15);
+      HasReturnvaluesIF::makeReturnCode(INTERFACE_ID, 11);
+  static constexpr ReturnValue_t MOUNT_ERROR = HasReturnvaluesIF::makeReturnCode(INTERFACE_ID, 12);
+  static constexpr ReturnValue_t UNMOUNT_ERROR =
+      HasReturnvaluesIF::makeReturnCode(INTERFACE_ID, 13);
+  static constexpr ReturnValue_t SYSTEM_CALL_ERROR =
+      HasReturnvaluesIF::makeReturnCode(INTERFACE_ID, 14);
+  static constexpr ReturnValue_t POPEN_CALL_ERROR =
+      HasReturnvaluesIF::makeReturnCode(INTERFACE_ID, 15);
 
   static constexpr uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::FILE_SYSTEM;
 
@@ -64,7 +69,8 @@ class SdCardManager : public SystemObject, public SdCardMountedIF {
   // C++17 does not support constexpr std::string yet
   static constexpr char SD_0_DEV_NAME[] = "/dev/mmcblk0p1";
   static constexpr char SD_1_DEV_NAME[] = "/dev/mmcblk1p1";
-
+  static constexpr char SD_0_MOUNT_POINT[] = "/mnt/sd0";
+  static constexpr char SD_1_MOUNT_POINT[] = "/mnt/sd1";
   static constexpr char SD_STATE_FILE[] = "/tmp/sd_status.txt";
 
   virtual ~SdCardManager();
@@ -91,7 +97,7 @@ class SdCardManager : public SystemObject, public SdCardMountedIF {
    * @param sdCard
    * @return
    */
-  std::optional<sd::SdCard> getPreferredSdCard() const override;
+  sd::SdCard getPreferredSdCard() const override;
 
   /**
    * Switch on the specified SD card.
@@ -99,7 +105,7 @@ class SdCardManager : public SystemObject, public SdCardMountedIF {
    * @param doMountSdCard     Mount the SD card after switching it on, which is necessary
    *                          to use it
    * @param statusPair        If the status pair is already available, it can be passed here
-   * @return - returnvalue::OK on success, ALREADY_ON if it is already on,
+   * @return - RETURN_OK on success, ALREADY_ON if it is already on,
    *           SYSTEM_CALL_ERROR on system error
    */
   ReturnValue_t switchOnSdCard(sd::SdCard sdCard, bool doMountSdCard = true,
@@ -111,7 +117,7 @@ class SdCardManager : public SystemObject, public SdCardMountedIF {
    * @param doUnmountSdCard   Unmount the SD card before switching the card off, which makes
    *                          the operation safer
    * @param statusPair        If the status pair is already available, it can be passed here
-   * @return - returnvalue::OK on success, ALREADY_ON if it is already on,
+   * @return - RETURN_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,
@@ -121,9 +127,9 @@ class SdCardManager : public SystemObject, public SdCardMountedIF {
    * Update the state file or creates one if it does not exist. You need to call this
    * function before calling #sdCardActive
    * @return
-   *  - returnvalue::OK if the state file was updated successfully
+   *  - RETURN_OK if the state file was updated successfully
    *  - CommandExecutor::COMMAND_PENDING: Non-blocking command is pending
-   *  - returnvalue::FAILED: blocking command failed
+   *  - RETURN_FAILED: blocking command failed
    */
   ReturnValue_t updateSdCardStateFile();
 
@@ -133,7 +139,7 @@ class SdCardManager : public SystemObject, public SdCardMountedIF {
    * the status of the SD cards and set the field of the provided boolean pair.
    * @param active Pair of booleans, where the first entry is the state of the first SD card
    * and the second one the state of the second SD card
-   * @return - returnvalue::OK if the state was read successfully
+   * @return - RETURN_OK if the state was read successfully
    *         - STATUS_FILE_FORMAT_INVALID if there was an issue with the state file. The user
    *           should call #updateSdCardStateFile again in that case
    *         - STATUS_FILE_NEXISTS if the status file does not exist
@@ -158,7 +164,7 @@ class SdCardManager : public SystemObject, public SdCardMountedIF {
    * mounted
    * @return
    */
-  std::optional<sd::SdCard> getActiveSdCard() const override;
+  sd::SdCard getActiveSdCard() const override;
 
   /**
    * Unmount the specified SD card. This is recommended before switching it off. The SD card
@@ -187,7 +193,7 @@ class SdCardManager : public SystemObject, public SdCardMountedIF {
    * @param prefSdCardPtr
    * @return
    */
-  const char* getCurrentMountPrefix() const override;
+  std::string getCurrentMountPrefix() const override;
 
   OpStatus checkCurrentOp(Operations& currentOp);
 
@@ -206,7 +212,7 @@ class SdCardManager : public SystemObject, public SdCardMountedIF {
    *
    * @return  true if mounted, otherwise false
    */
-  bool isSdCardUsable(std::optional<sd::SdCard> sdCard) override;
+  bool isSdCardMounted(sd::SdCard sdCard) override;
 
   ReturnValue_t isSdCardMountedReadOnly(sd::SdCard sdcard, bool& readOnly);
 
@@ -214,33 +220,21 @@ class SdCardManager : public SystemObject, public SdCardMountedIF {
 
   ReturnValue_t performFsck(sd::SdCard sdcard, bool printOutput, int& linuxError);
 
-  void markUnusable();
-
  private:
   CommandExecutor cmdExecutor;
-  SdStatePair sdStates;
   Operations currentOp = Operations::IDLE;
   bool blocking = false;
-  bool sdCardActive = true;
   bool printCmdOutput = true;
-  bool markedUnusable = false;
-  MutexIF* sdLock = nullptr;
-  MutexIF* prefLock = nullptr;
-  MutexIF* defaultLock = nullptr;
-  static constexpr MutexIF::TimeoutType LOCK_TYPE = MutexIF::TimeoutType::WAITING;
-  static constexpr uint32_t SD_LOCK_TIMEOUT = 250;
-  static constexpr uint32_t OTHER_TIMEOUT = 20;
-  static constexpr char LOCK_CTX[] = "SdCardManager";
+  MutexIF* mutex = nullptr;
 
   SdCardManager();
 
-  ReturnValue_t updateSdStatePair();
-
   ReturnValue_t setSdCardState(sd::SdCard sdCard, bool on);
 
-  void processSdStatusLine(std::string& line, uint8_t& idx, sd::SdCard& currentSd);
+  void processSdStatusLine(SdStatePair& active, std::string& line, uint8_t& idx,
+                           sd::SdCard& currentSd);
 
-  std::optional<std::string> currentPrefix;
+  std::string currentPrefix;
 
   static SdCardManager* INSTANCE;
 };

bsp_q7s/memory/scratchApi.cpp

@@ -1,28 +1,28 @@
 #include "scratchApi.h"
 
 ReturnValue_t scratch::writeString(std::string name, std::string string) {
-  std::ostringstream oss("xsc_scratch write ", std::ostringstream::ate);
-  oss << name << " \"" << string << "\"";
+  std::ostringstream oss;
+  oss << "xsc_scratch write " << name << " \"" << string << "\"";
   int result = std::system(oss.str().c_str());
   if (result != 0) {
     utility::handleSystemError(result, "scratch::writeString");
-    return returnvalue::FAILED;
+    return HasReturnvaluesIF::RETURN_FAILED;
   }
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t scratch::readString(std::string key, std::string &string) {
   std::ifstream file;
   std::string filename;
   ReturnValue_t result = readToFile(key, file, filename);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     return result;
   }
 
   std::string line;
   if (not std::getline(file, line)) {
     std::remove(filename.c_str());
-    return returnvalue::FAILED;
+    return HasReturnvaluesIF::RETURN_FAILED;
   }
 
   size_t pos = line.find("=");
@@ -35,16 +35,16 @@ ReturnValue_t scratch::readString(std::string key, std::string &string) {
     return KEY_NOT_FOUND;
   }
   string = line.substr(pos + 1);
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t scratch::clearValue(std::string key) {
-  std::ostringstream oss("xsc_scratch clear ", std::ostringstream::ate);
-  oss << key;
+  std::ostringstream oss;
+  oss << "xsc_scratch clear " << key;
   int result = std::system(oss.str().c_str());
   if (result != 0) {
     utility::handleSystemError(result, "scratch::clearValue");
-    return returnvalue::FAILED;
+    return HasReturnvaluesIF::RETURN_FAILED;
   }
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }

bsp_q7s/memory/scratchApi.h

@@ -7,7 +7,7 @@
 #include <sstream>
 #include <type_traits>
 
-#include "fsfw/returnvalues/returnvalue.h"
+#include "fsfw/returnvalues/HasReturnvaluesIF.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"
 #include "linux/utility/utility.h"
 #include "returnvalues/classIds.h"
@@ -21,7 +21,7 @@ static constexpr char PREFERED_SDC_KEY[] = "PREFSD";
 static constexpr char ALLOC_FAILURE_COUNT[] = "ALLOCERR";
 
 static constexpr uint8_t INTERFACE_ID = CLASS_ID::SCRATCH_BUFFER;
-static constexpr ReturnValue_t KEY_NOT_FOUND = returnvalue::makeCode(INTERFACE_ID, 0);
+static constexpr ReturnValue_t KEY_NOT_FOUND = HasReturnvaluesIF::makeReturnCode(INTERFACE_ID, 0);
 
 ReturnValue_t clearValue(std::string key);
 
@@ -83,34 +83,34 @@ ReturnValue_t readToFile(std::string name, std::ifstream& file, std::string& fil
     } else {
       utility::handleSystemError(result, "scratch::readToFile");
       std::remove(filename.c_str());
-      return returnvalue::FAILED;
+      return HasReturnvaluesIF::RETURN_FAILED;
     }
   }
   file.open(filename);
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
 }  // End of anonymous namespace
 
-template <typename T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+template <typename T, class>
 inline ReturnValue_t writeNumber(std::string key, T num) noexcept {
-  std::ostringstream oss("xsc_scratch write ", std::ostringstream::ate);
-  oss << key << " " << std::to_string(num);
+  std::ostringstream oss;
+  oss << "xsc_scratch write " << key << " " << std::to_string(num);
   int result = std::system(oss.str().c_str());
   if (result != 0) {
     utility::handleSystemError(result, "scratch::writeNumber");
-    return returnvalue::FAILED;
+    return HasReturnvaluesIF::RETURN_FAILED;
   }
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
-template <typename T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+template <typename T, class>
 inline ReturnValue_t readNumber(std::string key, T& num) noexcept {
   using namespace std;
   ifstream file;
   std::string filename;
   ReturnValue_t result = readToFile(key, file, filename);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     std::remove(filename.c_str());
     return result;
   }
@@ -118,7 +118,7 @@ inline ReturnValue_t readNumber(std::string key, T& num) noexcept {
   string line;
   if (not std::getline(file, line)) {
     std::remove(filename.c_str());
-    return returnvalue::FAILED;
+    return HasReturnvaluesIF::RETURN_FAILED;
   }
 
   size_t pos = line.find("=");
@@ -138,7 +138,7 @@ inline ReturnValue_t readNumber(std::string key, T& num) noexcept {
   }
 
   std::remove(filename.c_str());
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
 }  // namespace scratch

bsp_q7s/obsw.cpp

@@ -1,34 +1,23 @@
 #include "obsw.h"
 
-#include <pwd.h>
-#include <sys/types.h>
-#include <unistd.h>
-
 #include <filesystem>
-#include <fstream>
 #include <iostream>
 
 #include "OBSWConfig.h"
-#include "bsp_q7s/core/WatchdogHandler.h"
 #include "commonConfig.h"
-#include "core/scheduling.h"
+#include "core/InitMission.h"
 #include "fsfw/tasks/TaskFactory.h"
 #include "fsfw/version.h"
-#include "mission/acsDefs.h"
-#include "mission/system/tree/system.h"
 #include "q7sConfig.h"
 #include "watchdog/definitions.h"
 
-static constexpr int OBSW_ALREADY_RUNNING = -2;
+static int OBSW_ALREADY_RUNNING = -2;
 #if OBSW_Q7S_EM == 0
 static const char* DEV_STRING = "Xiphos Q7S FM";
 #else
 static const char* DEV_STRING = "Xiphos Q7S EM";
 #endif
-
-WatchdogHandler WATCHDOG_HANDLER;
-
-int obsw::obsw(int argc, char* argv[]) {
+int obsw::obsw() {
   using namespace fsfw;
   std::cout << "-- EIVE OBSW --" << std::endl;
   std::cout << "-- Compiled for Linux (" << DEV_STRING << ") --" << std::endl;
@@ -37,10 +26,9 @@ int obsw::obsw(int argc, char* argv[]) {
   std::cout << "-- " << __DATE__ << " " << __TIME__ << " --" << std::endl;
 
 #if Q7S_CHECK_FOR_ALREADY_RUNNING_IMG == 1
-  std::error_code e;
   // Check special file here. This file is created or deleted by the eive-watchdog application
   // or systemd service!
-  if (std::filesystem::exists(watchdog::RUNNING_FILE_NAME, e)) {
+  if (std::filesystem::exists(watchdog::RUNNING_FILE_NAME)) {
     sif::warning << "File " << watchdog::RUNNING_FILE_NAME
                  << " exists so the software might "
                     "already be running. Check if obsw systemd service has been stopped."
@@ -48,85 +36,11 @@ int obsw::obsw(int argc, char* argv[]) {
     return OBSW_ALREADY_RUNNING;
   }
 #endif
-
-  // Delay the boot if applicable.
-  bootDelayHandling();
-
-  bool initWatchFunction = false;
-  std::string fullExecPath = argv[0];
-  if (fullExecPath.find("/usr/bin") != std::string::npos) {
-    initWatchFunction = true;
-  }
-  ReturnValue_t result = WATCHDOG_HANDLER.initialize(initWatchFunction);
-  if (result != returnvalue::OK) {
-    std::cerr << "Initiating EIVE watchdog handler failed" << std::endl;
-  }
-
-  scheduling::initMission();
-
-  // Command the EIVE system to safe mode
-#if OBSW_COMMAND_SAFE_MODE_AT_STARTUP == 1
-  commandEiveSystemToSafe();
-#else
-  announceAllModes();
-#endif
+  initmission::initMission();
 
   for (;;) {
-    WATCHDOG_HANDLER.periodicOperation();
-    TaskFactory::delayTask(2000);
+    /* Suspend main thread by sleeping it. */
+    TaskFactory::delayTask(5000);
   }
   return 0;
 }
-
-void obsw::bootDelayHandling() {
-  const char* homedir = nullptr;
-  homedir = getenv("HOME");
-  if (homedir == nullptr) {
-    homedir = getpwuid(getuid())->pw_dir;
-  }
-  std::filesystem::path bootDelayFile = std::filesystem::path(homedir) / "boot_delay_secs.txt";
-  std::error_code e;
-  // Init delay handling.
-  if (std::filesystem::exists(bootDelayFile, e)) {
-    std::ifstream ifile(bootDelayFile);
-    std::string lineStr;
-    unsigned int bootDelaySecs = 0;
-    unsigned int line = 0;
-    // Try to reas delay seconds from file.
-    while (std::getline(ifile, lineStr)) {
-      std::istringstream iss(lineStr);
-      if (!(iss >> bootDelaySecs)) {
-        break;
-      }
-      line++;
-    }
-    if (line == 0) {
-      // If the file is empty, assume default of 6 seconds
-      bootDelaySecs = 6;
-    }
-    std::cout << "Delaying OBSW start for " << bootDelaySecs << " seconds" << std::endl;
-    TaskFactory::delayTask(bootDelaySecs * 1000);
-  }
-}
-
-void obsw::commandEiveSystemToSafe() {
-  auto sysQueueId = satsystem::EIVE_SYSTEM.getCommandQueue();
-  CommandMessage msg;
-  ModeMessage::setCmdModeMessage(msg, acs::AcsMode::SAFE, 0);
-  ReturnValue_t result =
-      MessageQueueSenderIF::sendMessage(sysQueueId, &msg, MessageQueueIF::NO_QUEUE, false);
-  if (result != returnvalue::OK) {
-    sif::error << "Sending safe mode command to EIVE system failed" << std::endl;
-  }
-}
-
-void obsw::announceAllModes() {
-  auto sysQueueId = satsystem::EIVE_SYSTEM.getCommandQueue();
-  CommandMessage msg;
-  ModeMessage::setModeAnnounceMessage(msg, true);
-  ReturnValue_t result =
-      MessageQueueSenderIF::sendMessage(sysQueueId, &msg, MessageQueueIF::NO_QUEUE, false);
-  if (result != returnvalue::OK) {
-    sif::error << "Sending safe mode command to EIVE system failed" << std::endl;
-  }
-}

bsp_q7s/obsw.h

@@ -3,12 +3,8 @@
 
 namespace obsw {
 
-int obsw(int argc, char* argv[]);
+int obsw();
 
-void bootDelayHandling();
-void commandEiveSystemToSafe();
-void announceAllModes();
-
-};  // namespace obsw
+};
 
 #endif /* BSP_Q7S_CORE_OBSW_H_ */

bsp_q7s/xadc/Xadc.cpp

@@ -12,20 +12,20 @@ Xadc::Xadc() {}
 Xadc::~Xadc() {}
 
 ReturnValue_t Xadc::getTemperature(float& temperature) {
-  ReturnValue_t result = returnvalue::OK;
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
   int raw = 0;
   int offset = 0;
   float scale = 0;
   result = readValFromFile<int>(xadc::file::tempRaw.c_str(), raw);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     return result;
   }
   result = readValFromFile<int>(xadc::file::tempOffset.c_str(), offset);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     return result;
   }
   result = readValFromFile<float>(xadc::file::tempScale.c_str(), scale);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     return result;
   }
   temperature = (raw + offset) * scale / 1000;
@@ -35,84 +35,84 @@ ReturnValue_t Xadc::getTemperature(float& temperature) {
 ReturnValue_t Xadc::getVccPint(float& vccPint) {
   ReturnValue_t result =
       readVoltageFromSysfs(xadc::file::vccpintRaw, xadc::file::vccpintScale, vccPint);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     return result;
   }
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t Xadc::getVccPaux(float& vccPaux) {
   ReturnValue_t result =
       readVoltageFromSysfs(xadc::file::vccpauxRaw, xadc::file::vccpauxScale, vccPaux);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     return result;
   }
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t Xadc::getVccInt(float& vccInt) {
   ReturnValue_t result =
       readVoltageFromSysfs(xadc::file::vccintRaw, xadc::file::vccintScale, vccInt);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     return result;
   }
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t Xadc::getVccAux(float& vccAux) {
   ReturnValue_t result =
       readVoltageFromSysfs(xadc::file::vccauxRaw, xadc::file::vccauxScale, vccAux);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     return result;
   }
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t Xadc::getVccBram(float& vccBram) {
   ReturnValue_t result =
       readVoltageFromSysfs(xadc::file::vccbramRaw, xadc::file::vccbramScale, vccBram);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     return result;
   }
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t Xadc::getVccOddr(float& vccOddr) {
   ReturnValue_t result =
       readVoltageFromSysfs(xadc::file::vccoddrRaw, xadc::file::vccoddrScale, vccOddr);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     return result;
   }
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t Xadc::getVrefp(float& vrefp) {
   ReturnValue_t result = readVoltageFromSysfs(xadc::file::vrefpRaw, xadc::file::vrefpScale, vrefp);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     return result;
   }
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t Xadc::getVrefn(float& vrefn) {
   ReturnValue_t result = readVoltageFromSysfs(xadc::file::vrefnRaw, xadc::file::vrefnScale, vrefn);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     return result;
   }
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t Xadc::readVoltageFromSysfs(std::string rawFile, std::string scaleFile,
                                          float& voltage) {
-  ReturnValue_t result = returnvalue::OK;
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
   float raw = 0;
   float scale = 0;
   result = readValFromFile(rawFile.c_str(), raw);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     return result;
   }
   result = readValFromFile(scaleFile.c_str(), scale);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     return result;
   }
   voltage = calculateVoltage(raw, scale);
@@ -127,7 +127,7 @@ ReturnValue_t Xadc::readValFromFile(const char* filename, T& val) {
   fp = fopen(filename, "r");
   if (fp == nullptr) {
     sif::warning << "Xadc::readValFromFile: Failed to open file " << filename << std::endl;
-    return returnvalue::FAILED;
+    return HasReturnvaluesIF::RETURN_FAILED;
   }
   char valstring[MAX_STR_LENGTH] = "";
   char* returnVal = fgets(valstring, MAX_STR_LENGTH, fp);
@@ -135,10 +135,10 @@ ReturnValue_t Xadc::readValFromFile(const char* filename, T& val) {
     sif::warning << "Xadc::readValFromFile: Failed to read string from file " << filename
                  << std::endl;
     fclose(fp);
-    return returnvalue::FAILED;
+    return HasReturnvaluesIF::RETURN_FAILED;
   }
   std::istringstream valSstream(valstring);
   valSstream >> val;
   fclose(fp);
-  return returnvalue::OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }

bsp_q7s/xadc/Xadc.h

@@ -3,7 +3,7 @@
 
 #include <string>
 
-#include "fsfw/returnvalues/returnvalue.h"
+#include "fsfw/returnvalues/HasReturnvaluesIF.h"
 
 namespace xadc {
 using namespace std;

bsp_te0720_1cfa/InitMission.cpp

@@ -2,7 +2,7 @@
 
 #include <fsfw/objectmanager/ObjectManager.h>
 #include <fsfw/objectmanager/ObjectManagerIF.h>
-#include <fsfw/returnvalues/returnvalue.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
 #include <fsfw/serviceinterface/ServiceInterface.h>
 #include <fsfw/tasks/FixedTimeslotTaskIF.h>
 #include <fsfw/tasks/PeriodicTaskIF.h>
@@ -36,7 +36,7 @@ void initmission::initMission() {
 
 void initmission::initTasks() {
   TaskFactory* factory = TaskFactory::instance();
-  ReturnValue_t result = returnvalue::OK;
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
   if (factory == nullptr) {
     /* Should never happen ! */
     return;
@@ -51,28 +51,28 @@ void initmission::initTasks() {
   PeriodicTaskIF* tmtcDistributor = factory->createPeriodicTask(
       "DIST", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
   result = tmtcDistributor->addComponent(objects::CCSDS_PACKET_DISTRIBUTOR);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::error << "Object add component failed" << std::endl;
   }
   result = tmtcDistributor->addComponent(objects::PUS_PACKET_DISTRIBUTOR);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::error << "Object add component failed" << std::endl;
   }
   result = tmtcDistributor->addComponent(objects::TM_FUNNEL);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::error << "Object add component failed" << std::endl;
   }
 
   PeriodicTaskIF* tmtcBridgeTask = factory->createPeriodicTask(
       "TMTC_BRIDGE", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
   result = tmtcBridgeTask->addComponent(objects::TMTC_BRIDGE);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::error << "Add component TMTC Bridge failed" << std::endl;
   }
   PeriodicTaskIF* tmtcPollingTask = factory->createPeriodicTask(
       "TMTC_POLLING", 80, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
   result = tmtcPollingTask->addComponent(objects::TMTC_POLLING_TASK);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::error << "Add component TMTC Polling failed" << std::endl;
   }
 
@@ -84,7 +84,7 @@ void initmission::initTasks() {
   FixedTimeslotTaskIF* pst = factory->createFixedTimeslotTask(
       "UART_PST", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 1.0, missedDeadlineFunc);
   result = pst::pstUart(pst);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::error << "InitMission::initTasks: Creating PST failed!" << std::endl;
   }
   pstTasks.push_back(pst);
@@ -93,7 +93,7 @@ void initmission::initTasks() {
   PeriodicTaskIF* mpsocHelperTask = factory->createPeriodicTask(
       "PLOC_MPSOC_HELPER", 20, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
   result = mpsocHelperTask->addComponent(objects::PLOC_MPSOC_HELPER);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("PLOC_MPSOC_HELPER", objects::PLOC_MPSOC_HELPER);
   }
 #endif /* OBSW_ADD_PLOC_MPSOC == 1*/
@@ -102,16 +102,16 @@ void initmission::initTasks() {
   PeriodicTaskIF* supvHelperTask = factory->createPeriodicTask(
       "PLOC_SUPV_HELPER", 20, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
   result = supvHelperTask->addComponent(objects::PLOC_SUPERVISOR_HELPER);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("PLOC_SUPV_HELPER", objects::PLOC_SUPERVISOR_HELPER);
   }
 #endif /* OBSW_ADD_PLOC_SUPERVISOR == 1 */
 
-#if OBSW_ADD_CCSDS_IP_CORES == 1
+#if OBSW_USE_CCSDS_IP_CORE == 1
   PeriodicTaskIF* ccsdsHandlerTask = factory->createPeriodicTask(
       "CCSDS_HANDLER", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
   result = ccsdsHandlerTask->addComponent(objects::CCSDS_HANDLER);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("CCSDS Handler", objects::CCSDS_HANDLER);
   }
 
@@ -121,10 +121,10 @@ void initmission::initTasks() {
   PeriodicTaskIF* pdecHandlerTask = factory->createPeriodicTask(
       "PDEC_HANDLER", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, missedDeadlineFunc);
   result = pdecHandlerTask->addComponent(objects::PDEC_HANDLER);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("PDEC Handler", objects::PDEC_HANDLER);
   }
-#endif /* OBSW_ADD_CCSDS_IP_CORES == 1 */
+#endif /* OBSW_USE_CCSDS_IP_CORE == 1 */
 
   auto taskStarter = [](std::vector<PeriodicTaskIF*>& taskVector, std::string name) {
     for (const auto& task : taskVector) {
@@ -140,10 +140,10 @@ void initmission::initTasks() {
   tmtcDistributor->startTask();
   tmtcBridgeTask->startTask();
   tmtcPollingTask->startTask();
-#if OBSW_ADD_CCSDS_IP_CORE == 1
+#if OBSW_USE_CCSDS_IP_CORE == 1
   pdecHandlerTask->startTask();
   ccsdsHandlerTask->startTask();
-#endif /* #if OBSW_ADD_CCSDS_IP_CORE == 1 */
+#endif /* #if OBSW_USE_CCSDS_IP_CORE == 1 */
 #if OBSW_ADD_PLOC_SUPERVISOR == 1
   supvHelperTask->startTask();
 #endif /* OBSW_ADD_PLOC_SUPERVISOR == 1 */
@@ -160,11 +160,11 @@ void initmission::initTasks() {
 void initmission::createPusTasks(TaskFactory& factory,
                                  TaskDeadlineMissedFunction missedDeadlineFunc,
                                  std::vector<PeriodicTaskIF*>& taskVec) {
-  ReturnValue_t result = returnvalue::OK;
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
   PeriodicTaskIF* pusVerification = factory.createPeriodicTask(
       "PUS_VERIF", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
   result = pusVerification->addComponent(objects::PUS_SERVICE_1_VERIFICATION);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::error << "Object add component failed" << std::endl;
   }
   taskVec.push_back(pusVerification);
@@ -172,11 +172,11 @@ void initmission::createPusTasks(TaskFactory& factory,
   PeriodicTaskIF* pusEvents = factory.createPeriodicTask(
       "PUS_EVENTS", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
   result = pusEvents->addComponent(objects::PUS_SERVICE_5_EVENT_REPORTING);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("PUS_EVENTS", objects::PUS_SERVICE_5_EVENT_REPORTING);
   }
   result = pusEvents->addComponent(objects::EVENT_MANAGER);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("PUS_MGMT", objects::EVENT_MANAGER);
   }
   taskVec.push_back(pusEvents);
@@ -184,11 +184,11 @@ void initmission::createPusTasks(TaskFactory& factory,
   PeriodicTaskIF* pusHighPrio = factory.createPeriodicTask(
       "PUS_HIGH_PRIO", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
   result = pusHighPrio->addComponent(objects::PUS_SERVICE_2_DEVICE_ACCESS);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("PUS2", objects::PUS_SERVICE_2_DEVICE_ACCESS);
   }
   result = pusHighPrio->addComponent(objects::PUS_SERVICE_9_TIME_MGMT);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("PUS9", objects::PUS_SERVICE_9_TIME_MGMT);
   }
   taskVec.push_back(pusHighPrio);
@@ -196,19 +196,19 @@ void initmission::createPusTasks(TaskFactory& factory,
   PeriodicTaskIF* pusMedPrio = factory.createPeriodicTask(
       "PUS_MED_PRIO", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.8, missedDeadlineFunc);
   result = pusMedPrio->addComponent(objects::PUS_SERVICE_8_FUNCTION_MGMT);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("PUS8", objects::PUS_SERVICE_8_FUNCTION_MGMT);
   }
   result = pusMedPrio->addComponent(objects::PUS_SERVICE_200_MODE_MGMT);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("PUS200", objects::PUS_SERVICE_200_MODE_MGMT);
   }
   result = pusMedPrio->addComponent(objects::PUS_SERVICE_20_PARAMETERS);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("PUS20", objects::PUS_SERVICE_20_PARAMETERS);
   }
   result = pusMedPrio->addComponent(objects::PUS_SERVICE_3_HOUSEKEEPING);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("PUS3", objects::PUS_SERVICE_3_HOUSEKEEPING);
   }
   taskVec.push_back(pusMedPrio);
@@ -216,11 +216,11 @@ void initmission::createPusTasks(TaskFactory& factory,
   PeriodicTaskIF* pusLowPrio = factory.createPeriodicTask(
       "PUS_LOW_PRIO", 30, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.6, missedDeadlineFunc);
   result = pusLowPrio->addComponent(objects::PUS_SERVICE_17_TEST);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("PUS17", objects::PUS_SERVICE_17_TEST);
   }
   result = pusLowPrio->addComponent(objects::INTERNAL_ERROR_REPORTER);
-  if (result != returnvalue::OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("INT_ERR_RPRT", objects::INTERNAL_ERROR_REPORTER);
   }
   taskVec.push_back(pusLowPrio);

bsp_te0720_1cfa/OBSWConfig.h.in

@@ -13,7 +13,7 @@
 /** All of the following flags should be enabled for mission code  */
 /*******************************************************************/
 
-#define OBSW_ADD_CCSDS_IP_CORE                      0
+#define OBSW_USE_CCSDS_IP_CORE                      0
 // Set to 1 if all telemetry should be sent to the PTME IP Core
 #define OBSW_TM_TO_PTME                             0
 // Set to 1 if telecommands are received via the PDEC IP Core

bsp_te0720_1cfa/ObjectFactory.cpp

@@ -12,8 +12,8 @@
 #include "fsfw/tmtcservices/PusServiceBase.h"
 #include "fsfw_hal/linux/i2c/I2cComIF.h"
 #include "fsfw_hal/linux/i2c/I2cCookie.h"
-#include "fsfw_hal/linux/serial/SerialComIF.h"
-#include "fsfw_hal/linux/serial/SerialCookie.h"
+#include "fsfw_hal/linux/uart/UartComIF.h"
+#include "fsfw_hal/linux/uart/UartCookie.h"
 #include "fsfw_hal/common/gpio/GpioCookie.h"
 #include "linux/ObjectFactory.h"
 #include "linux/devices/ploc/PlocMPSoCHandler.h"
@@ -59,7 +59,7 @@ void ObjectFactory::produce(void* args) {
   ObjectFactory::produceGenericObjects();
 
   LinuxLibgpioIF* gpioComIF = new LinuxLibgpioIF(objects::GPIO_IF);;
-  newSerialComIF(objects::UART_COM_IF);
+  new UartComIF(objects::UART_COM_IF);
 
 #if OBSW_ADD_PLOC_MPSOC == 1
   UartCookie* mpsocUartCookie = new UartCookie(objects::PLOC_MPSOC_HANDLER, te0720_1cfa::MPSOC_UART,

clone-submodules-no-privlibs.sh

@@ -1,6 +0,0 @@
-#!/bin/bash
-
-root="$(pwd)"
-ln -s "$root/hooks" "$root/.git/hooks"
-
-git submodule update --init fsfw thirdparty/rapidcsv thirdparty/lwgps thirdparty/json

cmake/BuildType.cmake

@@ -21,13 +21,10 @@ if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
 	)
 endif()
 
-set(RELEASE_BUILD 1 PARENT_SCOPE)
-
 if(${CMAKE_BUILD_TYPE} MATCHES "Debug")
 	message(STATUS 
 		"Building Debug application with flags: ${CMAKE_C_FLAGS_DEBUG}"
 	)
-	set(RELEASE_BUILD 0 PARENT_SCOPE)
 elseif(${CMAKE_BUILD_TYPE} MATCHES "RelWithDebInfo")
 	message(STATUS 
 		"Building Release (Debug) application with "

cmake/EiveHelpers.cmake

@@ -4,7 +4,7 @@
 # 2. Major version
 # 3. Minor version
 # 4. Revision
-# 5. (Optional) git SHA hash and commits since tag when applicable
+# 5. git SHA hash and commits since tag
 function(determine_version_with_git)
     include(GetGitRevisionDescription)
     git_describe(VERSION ${ARGN})
@@ -22,9 +22,7 @@ function(determine_version_with_git)
     list(APPEND GIT_INFO ${_VERSION_MAJOR})
     list(APPEND GIT_INFO ${_VERSION_MINOR})
     list(APPEND GIT_INFO ${_VERSION_PATCH})
-    if(NOT VERSION_SHA1 STREQUAL VERSION)
-        list(APPEND GIT_INFO ${VERSION_SHA1})
-    endif()
+    list(APPEND GIT_INFO ${VERSION_SHA1})
     set(GIT_INFO ${GIT_INFO} PARENT_SCOPE)
     message(STATUS "eive | Set git version info into GIT_INFO from the git tag ${VERSION}")
 endfunction()

cmake/scripts/cmake-build-cfg.py

@@ -22,38 +22,24 @@ def main():
     parser = argparse.ArgumentParser(
         description="Processing arguments for CMake build configuration."
     )
+    parser.add_argument("-o", "--osal", type=str, choices=["freertos", "linux", "rtems", "host"],
+                        help="FSFW OSAL. Valid arguments: host, linux, rtems, freertos")
     parser.add_argument(
-        "-o",
-        "--osal",
-        type=str,
-        choices=["freertos", "linux", "rtems", "host"],
-        help="FSFW OSAL. Valid arguments: host, linux, rtems, freertos",
-    )
-    parser.add_argument(
-        "-b",
-        "--buildtype",
-        type=str,
-        choices=["debug", "release", "size", "reldeb"],
+        "-b", "--buildtype", type=str, choices=["debug", "release", "size", "reldeb"],
         help="CMake build type. Valid arguments: debug, release, size, reldeb (Release with Debug "
-        "Information)",
-        default="debug",
+             "Information)", default="debug"
     )
     parser.add_argument("-l", "--builddir", type=str, help="Specify build directory.")
     parser.add_argument(
-        "-g", "--generator", type=str, help="CMake Generator", choices=["make", "ninja"]
+        "-g", "--generator", type=str, help="CMake Generator", choices=['make', 'ninja']
     )
     parser.add_argument(
-        "-d",
-        "--defines",
+        "-d", "--defines",
         help="Additional custom defines passed to CMake (supply without -D prefix!)",
-        nargs="*",
-        type=str,
+        nargs="*", type=str
     )
     parser.add_argument(
-        "-t",
-        "--target-bsp",
-        type=str,
-        help="Target BSP, combination of architecture and machine",
+        "-t", "--target-bsp", type=str, help="Target BSP, combination of architecture and machine"
     )
 
     args = parser.parse_args()
@@ -73,13 +59,13 @@ def main():
     if args.generator is None:
         generator_cmake_arg = ""
     else:
-        if args.generator == "make":
-            if os.name == "nt":
+        if args.generator == 'make':
+            if os.name == 'nt':
                 generator_cmake_arg = '-G "MinGW Makefiles"'
             else:
                 generator_cmake_arg = '-G "Unix Makefiles"'
-        elif args.generator == "ninja":
-            generator_cmake_arg = "-G Ninja"
+        elif args.generator == 'ninja':
+            generator_cmake_arg = '-G Ninja'
         else:
             generator_cmake_arg = args.generator
 
@@ -93,7 +79,7 @@ def main():
         cmake_build_type = "RelWithDebInfo"
 
     if args.target_bsp is not None:
-        cmake_target_cfg_cmd = f'-DTGT_BSP="{args.target_bsp}"'
+        cmake_target_cfg_cmd = f"-DTGT_BSP=\"{args.target_bsp}\""
     else:
         cmake_target_cfg_cmd = ""
 
@@ -106,12 +92,10 @@ def main():
     build_folder = cmake_build_type
     if args.builddir is not None:
         build_folder = args.builddir
-
+    
     build_path = source_location + os.path.sep + build_folder
     if os.path.isdir(build_path):
-        remove_old_dir = input(
-            f"{build_folder} folder already exists. Remove old directory? [y/n]: "
-        )
+        remove_old_dir = input(f"{build_folder} folder already exists. Remove old directory? [y/n]: ")
         if str(remove_old_dir).lower() in ["yes", "y", 1]:
             remove_old_dir = True
         else:
@@ -125,19 +109,17 @@ def main():
     print(f"Navigating into build directory: {build_path}")
     os.chdir(build_folder)
 
-    cmake_command = (
-        f'cmake {generator_cmake_arg} -DFSFW_OSAL="{osal}" '
-        f'-DCMAKE_BUILD_TYPE="{cmake_build_type}" {cmake_target_cfg_cmd} '
-        f"{define_string} {source_location}"
-    )
+    cmake_command = f"cmake {generator_cmake_arg} -DFSFW_OSAL=\"{osal}\" " \
+                    f"-DCMAKE_BUILD_TYPE=\"{cmake_build_type}\" {cmake_target_cfg_cmd} " \
+                    f"{define_string} {source_location}"
     # Remove redundant spaces
-    cmake_command = " ".join(cmake_command.split())
+    cmake_command = ' '.join(cmake_command.split())
     print("Running CMake command: ")
-    print(f'" {cmake_command} "')
+    print(f"\" {cmake_command} \"")
     os.system(cmake_command)
     print("-- CMake configuration done. --")
-
-
+    
+    
 def rm_build_dir(path: str):
     # On windows the permissions of the build directory may have been set to read-only. If this
     # is the case the permissions are changed before trying to delete the directory.
@@ -152,9 +134,7 @@ def determine_source_location() -> str:
         index += 1
         os.chdir("..")
         if index >= 5:
-            print(
-                "Error: Could not find source directory (determined by looking for fsfw folder!)"
-            )
+            print("Error: Could not find source directory (determined by looking for fsfw folder!)")
             sys.exit(1)
     return os.getcwd()
 

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

@@ -1,14 +1,12 @@
 #!/bin/bash
 cfg_script_name="cmake-build-cfg.py"
 init_dir=$(pwd)
-root_dir=""
 if [ -z "${EIVE_OBSW_ROOT}" ]; then
     counter=0
     while [ ${counter} -lt 5 ]
     do
         cd ..
         if [ -f ${cfg_script_name} ];then
-            root_dir=$(realpath "../..")
             break
         fi
         counter=$((counter=counter + 1))
@@ -20,7 +18,6 @@ if [ -z "${EIVE_OBSW_ROOT}" ]; then
     fi
 else
     cfg_script_name="${EIVE_OBSW_ROOT}/cmake/scripts/${cfg_script_name}"
-    root_dir=${EIVE_OBSW_ROOT}
 fi
 
 build_generator="make"
@@ -37,5 +34,4 @@ echo "Running command (without the leading +):"
 set -x # Print command 
 ${python} ${cfg_script_name} -o "${os_fsfw}" -g "${build_generator}" -b "debug" -l "${builddir}"
 # Use this if commands are added which should not be printed
-set +x
-cd ${root_dir}/${builddir}
+# set +x

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

@@ -7,7 +7,6 @@ if [ -z "${EIVE_OBSW_ROOT}" ]; then
     do
         cd ..
         if [ -f ${cfg_script_name} ];then
-            root_dir=$(realpath "../..")
             break
         fi
         counter=$((counter=counter + 1))
@@ -21,7 +20,7 @@ else
     cfg_script_name="${EIVE_OBSW_ROOT}/cmake/scripts/${cfg_script_name}"
 fi
 
-build_generator="make"
+build_generator="Unix Makefiles"
 os_fsfw="host"
 builddir="cmake-build-release"
 if [ "${OS}" = "Windows_NT" ]; then
@@ -35,5 +34,4 @@ echo "Running command (without the leading +):"
 set -x # Print command 
 ${python} ${cfg_script_name} -o "${os_fsfw}" -g "${build_generator}" -b "release" -l "${builddir}"
 # Use this if commands are added which should not be printed
-set +x
-cd ${root_dir}/${builddir}
+# set +x

common/config/OBSWVersion.h

@@ -0,0 +1,10 @@
+#ifndef COMMON_CONFIG_OBSWVERSION_H_
+#define COMMON_CONFIG_OBSWVERSION_H_
+
+const char* const SW_NAME = "eive";
+
+#define SW_VERSION 1
+#define SW_SUBVERSION 12
+#define SW_REVISION 1
+
+#endif /* COMMON_CONFIG_OBSWVERSION_H_ */

common/config/commonClassIds.h

@@ -35,17 +35,9 @@ enum commonClassIds : uint8_t {
   SA_DEPL_HANDLER,          // SADPL
   MPSOC_RETURN_VALUES_IF,   // MPSOCRTVIF
   SUPV_RETURN_VALUES_IF,    // SPVRTVIF
-  ACS_CTRL,                 // ACSCTRL
-  ACS_MEKF,                 // ACSMEKF
-  ACS_SAFE,                 // ACSSAF
-  ACS_PTG,                  // ACSPTG
-  ACS_DETUMBLE,             // ACSDTB
-  SD_CARD_MANAGER,          // SDMA
-  LOCAL_PARAM_HANDLER,      // LPH
-  PERSISTENT_TM_STORE,      // PTM
-  TM_SINK,                  // TMS
   COMMON_CLASS_ID_END       // [EXPORT] : [END]
 };
+
 }
 
 #endif /* COMMON_CONFIG_COMMONCLASSIDS_H_ */

common/config/commonConfig.cpp

@@ -1,11 +1,8 @@
 #include "commonConfig.h"
 
-#include "eive/definitions.h"
-#include "fsfw/tmtcpacket/ccsds/defs.h"
+#include "fsfw/tmtcpacket/SpacePacket.h"
+#include "tmtc/apid.h"
 
 const fsfw::Version common::OBSW_VERSION{OBSW_VERSION_MAJOR, OBSW_VERSION_MINOR,
                                          OBSW_VERSION_REVISION, OBSW_VERSION_CST_GIT_SHA1};
-const uint16_t common::PUS_PACKET_ID =
-    ccsds::getTcSpacePacketIdFromApid(config::EIVE_PUS_APID, true);
-const uint16_t common::CFDP_PACKET_ID =
-    ccsds::getTcSpacePacketIdFromApid(config::EIVE_CFDP_APID, false);
+const uint16_t common::PUS_PACKET_ID = spacepacket::getTcSpacePacketIdFromApid(apid::EIVE_OBSW);

common/config/commonConfig.h.in

@@ -4,8 +4,6 @@
 #include <cstdint>
 #include "fsfw/version.h"
 
-#cmakedefine RELEASE_BUILD
-
 #cmakedefine RASPBERRY_PI
 #cmakedefine XIPHOS_Q7S
 #cmakedefine BEAGLEBONEBLACK
@@ -19,9 +17,13 @@ debugging. */
 #define OBSW_ADD_LWGPS_TEST                 0   
 
 // Disable this for mission code. It allows exchanging TMTC packets via the Ethernet port
-#define OBSW_ADD_TCPIP_SERVERS              1
+#define OBSW_ADD_TCPIP_BRIDGE               1
 
-#define OBSW_ADD_CFDP_COMPONENTS            1
+// Use TCP instead of UDP for the TMTC bridge. This allows using the TMTC client locally
+// because UDP packets are not allowed in the VPN
+// This will cause the OBSW to initialize the TMTC bridge responsible for exchanging data with the
+// CCSDS IP Cores. 
+#define OBSW_USE_TMTC_TCP_BRIDGE            1
 
 namespace common {
 
@@ -37,7 +39,14 @@ static constexpr uint32_t OBSW_MAX_SCHEDULED_TCS = @OBSW_MAX_SCHEDULED_TCS@;
 extern const fsfw::Version OBSW_VERSION;
 
 extern const uint16_t PUS_PACKET_ID;
-extern const uint16_t CFDP_PACKET_ID;
+
+static constexpr uint32_t CCSDS_HANDLER_QUEUE_SIZE = 50;
+static constexpr uint8_t NUMBER_OF_VIRTUAL_CHANNELS = 4;
+static constexpr uint8_t VC0_QUEUE_SIZE = 50;
+static constexpr uint8_t VC1_QUEUE_SIZE = 50;
+static constexpr uint8_t VC2_QUEUE_SIZE = 50;
+static constexpr uint8_t VC3_QUEUE_SIZE = 50;
+
 }
 
 #endif /* COMMON_CONFIG_COMMONCONFIG_H_ */

common/config/commonObjects.h

@@ -0,0 +1,130 @@
+#ifndef COMMON_CONFIG_COMMONOBJECTS_H_
+#define COMMON_CONFIG_COMMONOBJECTS_H_
+
+#include <cstdint>
+
+#include <fsfw/introspection/ClasslessEnum.h>
+
+namespace objects {
+FSFW_CLASSLESS_ENUM(commonObjects, uint32_t,
+  /* First Byte 0x50-0x52 reserved for PUS Services **/
+((CCSDS_PACKET_DISTRIBUTOR, 0x50000100, "CCSDS_PACKET_DISTRIBUTOR"))
+((PUS_PACKET_DISTRIBUTOR, 0x50000200, "PUS_PACKET_DISTRIBUTOR"))
+((TMTC_BRIDGE, 0x50000300, "TMTC_BRIDGE"))
+((TMTC_POLLING_TASK, 0x50000400, "TMTC_POLLING_TASK"))
+((FILE_SYSTEM_HANDLER, 0x50000500, "FILE_SYSTEM_HANDLER"))
+((SDC_MANAGER, 0x50000550, "SDC_MANAGER"))
+((PTME, 0x50000600, "PTME"))
+((PDEC_HANDLER, 0x50000700, "PDEC_HANDLER"))
+((CCSDS_HANDLER, 0x50000800, "CCSDS_HANDLER"))
+
+  /* 0x43 ('C') for Controllers */
+((THERMAL_CONTROLLER, 0x43400001, "THERMAL_CONTROLLER"))
+((ACS_CONTROLLER, 0x43000002, "ACS_CONTROLLER"))
+((CORE_CONTROLLER, 0x43000003, "CORE_CONTROLLER"))
+
+  /* 0x44 ('D') for device handlers */
+((MGM_0_LIS3_HANDLER, 0x44120006, "MGM_0_LIS3_HANDLER"))
+((MGM_1_RM3100_HANDLER, 0x44120107, "MGM_1_RM3100_HANDLER"))
+((MGM_2_LIS3_HANDLER, 0x44120208, "MGM_2_LIS3_HANDLER"))
+((MGM_3_RM3100_HANDLER, 0x44120309, "MGM_3_RM3100_HANDLER"))
+((GYRO_0_ADIS_HANDLER, 0x44120010, "GYRO_0_ADIS_HANDLER"))
+((GYRO_1_L3G_HANDLER, 0x44120111, "GYRO_1_L3G_HANDLER"))
+((GYRO_2_ADIS_HANDLER, 0x44120212, "GYRO_2_ADIS_HANDLER"))
+((GYRO_3_L3G_HANDLER, 0x44120313, "GYRO_3_L3G_HANDLER"))
+((RW1, 0x44120047, "RW1"))
+((RW2, 0x44120148, "RW2"))
+((RW3, 0x44120249, "RW3"))
+((RW4, 0x44120350, "RW4"))
+((STAR_TRACKER, 0x44130001, "STAR_TRACKER"))
+((GPS_CONTROLLER, 0x44130045, "GPS_CONTROLLER"))
+
+((IMTQ_HANDLER, 0x44140014, "IMTQ_HANDLER"))
+((TMP1075_HANDLER_1, 0x44420004, "TMP1075_HANDLER_1"))
+((TMP1075_HANDLER_2, 0x44420005, "TMP1075_HANDLER_2"))
+((PCDU_HANDLER, 0x442000A1, "PCDU_HANDLER"))
+((P60DOCK_HANDLER, 0x44250000, "P60DOCK_HANDLER"))
+((PDU1_HANDLER, 0x44250001, "PDU1_HANDLER"))
+((PDU2_HANDLER, 0x44250002, "PDU2_HANDLER"))
+((ACU_HANDLER, 0x44250003, "ACU_HANDLER"))
+((BPX_BATT_HANDLER, 0x44260000, "BPX_BATT_HANDLER"))
+((PLPCDU_HANDLER, 0x44300000, "PLPCDU_HANDLER"))
+((RAD_SENSOR, 0x443200A5, "RAD_SENSOR"))
+((PLOC_UPDATER, 0x44330000, "PLOC_UPDATER"))
+((PLOC_MEMORY_DUMPER, 0x44330001, "PLOC_MEMORY_DUMPER"))
+((STR_HELPER, 0x44330002, "STR_HELPER"))
+((PLOC_MPSOC_HELPER, 0x44330003, "PLOC_MPSOC_HELPER"))
+((AXI_PTME_CONFIG, 0x44330004, "AXI_PTME_CONFIG"))
+((PTME_CONFIG, 0x44330005, "PTME_CONFIG"))
+((PLOC_MPSOC_HANDLER, 0x44330015, "PLOC_MPSOC_HANDLER"))
+((PLOC_SUPERVISOR_HANDLER, 0x44330016, "PLOC_SUPERVISOR_HANDLER"))
+((PLOC_SUPERVISOR_HELPER, 0x44330017, "PLOC_SUPERVISOR_HELPER"))
+((SOLAR_ARRAY_DEPL_HANDLER, 0x444100A2, "SOLAR_ARRAY_DEPL_HANDLER"))
+((HEATER_HANDLER, 0x444100A4, "HEATER_HANDLER"))
+
+  /**
+   * Not yet specified which pt1000 will measure which device/location in the satellite.
+   * Therefore object ids are named according to the IC naming of the RTDs in the schematic.
+   */
+((RTD_0_IC3_PLOC_HEATSPREADER, 0x44420016, "RTD_0_IC3_PLOC_HEATSPREADER"))
+((RTD_1_IC4_PLOC_MISSIONBOARD, 0x44420017, "RTD_1_IC4_PLOC_MISSIONBOARD"))
+((RTD_2_IC5_4K_CAMERA, 0x44420018, "RTD_2_IC5_4K_CAMERA"))
+((RTD_3_IC6_DAC_HEATSPREADER, 0x44420019, "RTD_3_IC6_DAC_HEATSPREADER"))
+((RTD_4_IC7_STARTRACKER, 0x44420020, "RTD_4_IC7_STARTRACKER"))
+((RTD_5_IC8_RW1_MX_MY, 0x44420021, "RTD_5_IC8_RW1_MX_MY"))
+((RTD_6_IC9_DRO, 0x44420022, "RTD_6_IC9_DRO"))
+((RTD_7_IC10_SCEX, 0x44420023, "RTD_7_IC10_SCEX"))
+((RTD_8_IC11_X8, 0x44420024, "RTD_8_IC11_X8"))
+((RTD_9_IC12_HPA, 0x44420025, "RTD_9_IC12_HPA"))
+((RTD_10_IC13_PL_TX, 0x44420026, "RTD_10_IC13_PL_TX"))
+((RTD_11_IC14_MPA, 0x44420027, "RTD_11_IC14_MPA"))
+((RTD_12_IC15_ACU, 0x44420028, "RTD_12_IC15_ACU"))
+((RTD_13_IC16_PLPCDU_HEATSPREADER, 0x44420029, "RTD_13_IC16_PLPCDU_HEATSPREADER"))
+((RTD_14_IC17_TCS_BOARD, 0x44420030, "RTD_14_IC17_TCS_BOARD"))
+((RTD_15_IC18_IMTQ, 0x44420031, "RTD_15_IC18_IMTQ"))
+
+  // Name convention for SUS devices
+  // SUS_<IDX>_<N/R>_LOC_X<F/M/B>Y<F/M/B>Z<F/M/B>_PT_<DIR><F/B>
+  // LOC: Location
+  // PT: Pointing
+  // N/R: Nominal/Redundant
+  // F/M/B: Forward/Middle/Backwards
+((SUS_0_N_LOC_XFYFZM_PT_XF, 0x44120032, "SUS_0_N_LOC_XFYFZM_PT_XF"))
+((SUS_6_R_LOC_XFYBZM_PT_XF, 0x44120038, "SUS_6_R_LOC_XFYBZM_PT_XF"))
+
+((SUS_1_N_LOC_XBYFZM_PT_XB, 0x44120033, "SUS_1_N_LOC_XBYFZM_PT_XB"))
+((SUS_7_R_LOC_XBYBZM_PT_XB, 0x44120039, "SUS_7_R_LOC_XBYBZM_PT_XB"))
+
+((SUS_2_N_LOC_XFYBZB_PT_YB, 0x44120034, "SUS_2_N_LOC_XFYBZB_PT_YB"))
+((SUS_8_R_LOC_XBYBZB_PT_YB, 0x44120040, "SUS_8_R_LOC_XBYBZB_PT_YB"))
+
+((SUS_3_N_LOC_XFYBZF_PT_YF, 0x44120035, "SUS_3_N_LOC_XFYBZF_PT_YF"))
+((SUS_9_R_LOC_XBYBZB_PT_YF, 0x44120041, "SUS_9_R_LOC_XBYBZB_PT_YF"))
+
+((SUS_4_N_LOC_XMYFZF_PT_ZF, 0x44120036, "SUS_4_N_LOC_XMYFZF_PT_ZF"))
+((SUS_10_N_LOC_XMYBZF_PT_ZF, 0x44120042, "SUS_10_N_LOC_XMYBZF_PT_ZF"))
+
+((SUS_5_N_LOC_XFYMZB_PT_ZB, 0x44120037, "SUS_5_N_LOC_XFYMZB_PT_ZB"))
+((SUS_11_R_LOC_XBYMZB_PT_ZB, 0x44120043, "SUS_11_R_LOC_XBYMZB_PT_ZB"))
+
+((SYRLINKS_HK_HANDLER, 0x445300A3, "SYRLINKS_HK_HANDLER"))
+
+  // 0x60 for other stuff
+((HEATER_0_PLOC_PROC_BRD, 0x60000000, "HEATER_0_PLOC_PROC_BRD"))
+((HEATER_1_PCDU_BRD, 0x60000001, "HEATER_1_PCDU_BRD"))
+((HEATER_2_ACS_BRD, 0x60000002, "HEATER_2_ACS_BRD"))
+((HEATER_3_OBC_BRD, 0x60000003, "HEATER_3_OBC_BRD"))
+((HEATER_4_CAMERA, 0x60000004, "HEATER_4_CAMERA"))
+((HEATER_5_STR, 0x60000005, "HEATER_5_STR"))
+((HEATER_6_DRO, 0x60000006, "HEATER_6_DRO"))
+((HEATER_7_HPA, 0x60000007, "HEATER_7_HPA"))
+
+  // 0x73 ('s') for assemblies and system/subsystem components
+((ACS_BOARD_ASS, 0x73000001, "ACS_BOARD_ASS"))
+((SUS_BOARD_ASS, 0x73000002, "SUS_BOARD_ASS"))
+((TCS_BOARD_ASS, 0x73000003, "TCS_BOARD_ASS"))
+((RW_ASS, 0x73000004, "RW_ASS"))
+)
+}
+
+#endif /* COMMON_CONFIG_COMMONOBJECTS_H_ */

common/config/commonSubsystemIds.h

@@ -4,7 +4,6 @@
 #include <fsfw/events/fwSubsystemIdRanges.h>
 
 namespace SUBSYSTEM_ID {
-
 enum : uint8_t {
   COMMON_SUBSYSTEM_ID_START = FW_SUBSYSTEM_ID_RANGE,
   ACS_SUBSYSTEM = 112,
@@ -33,14 +32,7 @@ enum : uint8_t {
   ACU_HANDLER = 135,
   PLOC_SUPV_HELPER = 136,
   SYRLINKS = 137,
-  SCEX_HANDLER = 138,
-  CONFIGHANDLER = 139,
-  CORE = 140,
-  TCS_CONTROLLER = 141,
-  COM_SUBSYSTEM = 142,
-  PERSISTENT_TM_STORE = 143,
   COMMON_SUBSYSTEM_ID_END
-
 };
 }
 

common/config/devConf.h

@@ -1,14 +1,11 @@
 #ifndef COMMON_CONFIG_DEVCONF_H_
 #define COMMON_CONFIG_DEVCONF_H_
 
-#include <fsfw_hal/linux/serial/SerialCookie.h>
-
 #include <cstdint>
 
-#include "commonConfig.h"
 #include "fsfw/timemanager/clockDefinitions.h"
-#include "fsfw_hal/linux/serial/SerialCookie.h"
 #include "fsfw_hal/linux/spi/spiDefinitions.h"
+#include "fsfw_hal/linux/uart/UartCookie.h"
 
 /**
  * SPI configuration will be contained here to let the device handlers remain independent
@@ -48,29 +45,19 @@ static constexpr spi::SpiModes DEFAULT_ADIS16507_MODE = spi::SpiModes::MODE_3;
 static constexpr uint32_t RW_SPEED = 300'000;
 static constexpr spi::SpiModes RW_MODE = spi::SpiModes::MODE_0;
 
-#ifdef RELEASE_BUILD
-static constexpr uint8_t CS_FACTOR = 1;
-#else
-static constexpr uint8_t CS_FACTOR = 3;
-#endif
-
-static constexpr dur_millis_t RTD_CS_TIMEOUT = 50 * CS_FACTOR;
+static constexpr dur_millis_t RTD_CS_TIMEOUT = 50;
 static constexpr uint32_t RTD_SPEED = 2'000'000;
 static constexpr spi::SpiModes RTD_MODE = spi::SpiModes::MODE_3;
 
-static constexpr dur_millis_t SUS_CS_TIMEOUT = 50 * CS_FACTOR;
-static constexpr dur_millis_t ACS_BOARD_CS_TIMEOUT = 50 * CS_FACTOR;
-
 }  // namespace spi
 
 namespace uart {
 
 static constexpr size_t HYPERION_GPS_REPLY_MAX_BUFFER = 1024;
 static constexpr UartBaudRate SYRLINKS_BAUD = UartBaudRate::RATE_38400;
-static constexpr UartBaudRate SCEX_BAUD = UartBaudRate::RATE_115200;
 static constexpr UartBaudRate GNSS_BAUD = UartBaudRate::RATE_9600;
 static constexpr UartBaudRate PLOC_MPSOC_BAUD = UartBaudRate::RATE_115200;
-static constexpr UartBaudRate PLOC_SUPV_BAUD = UartBaudRate::RATE_921600;
+static constexpr UartBaudRate PLOC_SUPV_BAUD = UartBaudRate::RATE_115200;
 static constexpr UartBaudRate STAR_TRACKER_BAUD = UartBaudRate::RATE_921600;
 
 }  // namespace uart

common/config/devices/heaterSwitcherList.h

@@ -12,7 +12,7 @@ enum Switchers : uint8_t {
   HEATER_4_CAMERA,
   HEATER_5_STR,
   HEATER_6_DRO,
-  HEATER_7_S_BAND,
+  HEATER_7_HPA,
   NUMBER_OF_SWITCHES
 };
 }

common/config/eive/definitions.h

@@ -5,21 +5,6 @@
 
 namespace config {
 
-static constexpr char SD_0_MOUNT_POINT[] = "/mnt/sd0";
-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 OBSW_PATH[] = "/usr/bin/eive-obsw";
-static constexpr char OBSW_VERSION_FILE_PATH[] = "/usr/share/eive-obsw/obsw_version.txt";
-
-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;
-static constexpr uint16_t EIVE_GROUND_CFDP_ENTITY_ID = 1;
-
 static constexpr uint32_t PL_PCDU_TRANSITION_TIMEOUT_MS = 20 * 60 * 1000;
 static constexpr uint32_t LONGEST_MODE_TIMEOUT_SECONDS = PL_PCDU_TRANSITION_TIMEOUT_MS / 1000;
 
@@ -34,61 +19,6 @@ static constexpr uint8_t LIVE_TM = 0;
 static constexpr uint32_t MAX_PATH_SIZE = 100;
 static constexpr uint32_t MAX_FILENAME_SIZE = 50;
 
-static constexpr uint32_t SA_DEPL_INIT_BUFFER_SECS = 120;
-// Burn time for autonomous deployment
-static constexpr uint32_t SA_DEPL_BURN_TIME_SECS = 180;
-static constexpr uint32_t SA_DEPL_WAIT_TIME_SECS = 45 * 60;
-// HW constraints (current limit) mean that the GPIO channels need to be switched on in alternation
-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 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;
-// There are three individual log stores!
-static constexpr uint32_t MISC_STORE_QUEUE_SIZE = 200;
-static constexpr uint32_t OK_STORE_QUEUE_SIZE = 350;
-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 MAX_PUS_FUNNEL_QUEUE_DEPTH = 100;
-static constexpr uint32_t MAX_CFDP_FUNNEL_QUEUE_DEPTH = 80;
-
-static constexpr uint32_t MAX_STORED_CMDS_UDP = 150;
-static constexpr uint32_t MAX_STORED_CMDS_TCP = 180;
-
-namespace spiSched {
-
-static constexpr uint32_t SCHED_BLOCK_1_SUS_READ_MS = 15;
-static constexpr uint32_t SCHED_BLOCK_2_SENSOR_READ_MS = 30;
-static constexpr uint32_t SCHED_BLOCK_3_READ_IMTQ_MGM_MS = 43;
-static constexpr uint32_t SCHED_BLOCK_4_ACS_CTRL_MS = 45;
-static constexpr uint32_t SCHED_BLOCK_5_ACTUATOR_MS = 55;
-static constexpr uint32_t SCHED_BLOCK_6_IMTQ_BLOCK_2_MS = 105;
-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;
-
-// 15 ms for FM
-static constexpr float SCHED_BLOCK_1_PERIOD = static_cast<float>(SCHED_BLOCK_1_SUS_READ_MS) / 400.0;
-static constexpr float SCHED_BLOCK_2_PERIOD =
-    static_cast<float>(SCHED_BLOCK_2_SENSOR_READ_MS) / 400.0;
-static constexpr float SCHED_BLOCK_3_PERIOD =
-    static_cast<float>(SCHED_BLOCK_3_READ_IMTQ_MGM_MS) / 400.0;
-static constexpr float SCHED_BLOCK_4_PERIOD = static_cast<float>(SCHED_BLOCK_4_ACS_CTRL_MS) / 400.0;
-static constexpr float SCHED_BLOCK_5_PERIOD = static_cast<float>(SCHED_BLOCK_5_ACTUATOR_MS) / 400.0;
-static constexpr float SCHED_BLOCK_6_PERIOD =
-    static_cast<float>(SCHED_BLOCK_6_IMTQ_BLOCK_2_MS) / 400.0;
-static constexpr float SCHED_BLOCK_RTD_PERIOD = static_cast<float>(SCHED_BLOCK_RTD) / 400.0;
-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;
-
-}  // namespace spiSched
-
 }  // namespace config
 
 #endif /* COMMON_CONFIG_DEFINITIONS_H_ */

common/config/eive/objects.h

@@ -1,182 +0,0 @@
-#ifndef COMMON_CONFIG_COMMONOBJECTS_H_
-#define COMMON_CONFIG_COMMONOBJECTS_H_
-
-#include <cstdint>
-
-namespace objects {
-enum commonObjects : uint32_t {
-  /* First Byte 0x50-0x52 reserved for PUS Services **/
-  CCSDS_PACKET_DISTRIBUTOR = 0x50000100,
-  PUS_PACKET_DISTRIBUTOR = 0x50000200,
-  TCP_TMTC_SERVER = 0x50000300,
-  UDP_TMTC_SERVER = 0x50000301,
-  TCP_TMTC_POLLING_TASK = 0x50000400,
-  UDP_TMTC_POLLING_TASK = 0x50000401,
-  FILE_SYSTEM_HANDLER = 0x50000500,
-  SDC_MANAGER = 0x50000550,
-  PTME = 0x50000600,
-  PDEC_HANDLER = 0x50000700,
-  CCSDS_HANDLER = 0x50000800,
-
-  /* 0x49 ('I') for Communication Interfaces **/
-  UART_COM_IF = 0x49030003,
-  SCEX_UART_READER = 0x49010006,
-
-  /* 0x43 ('C') for Controllers */
-  THERMAL_CONTROLLER = 0x43400001,
-  ACS_CONTROLLER = 0x43000002,
-  CORE_CONTROLLER = 0x43000003,
-  GLOBAL_JSON_CFG = 0x43000006,
-
-  /* 0x44 ('D') for device handlers */
-  MGM_0_LIS3_HANDLER = 0x44120006,
-  MGM_1_RM3100_HANDLER = 0x44120107,
-  MGM_2_LIS3_HANDLER = 0x44120208,
-  MGM_3_RM3100_HANDLER = 0x44120309,
-  GYRO_0_ADIS_HANDLER = 0x44120010,
-  GYRO_1_L3G_HANDLER = 0x44120111,
-  GYRO_2_ADIS_HANDLER = 0x44120212,
-  GYRO_3_L3G_HANDLER = 0x44120313,
-  RW1 = 0x44120047,
-  RW2 = 0x44120148,
-  RW3 = 0x44120249,
-  RW4 = 0x44120350,
-  STAR_TRACKER = 0x44130001,
-  GPS_CONTROLLER = 0x44130045,
-
-  IMTQ_POLLING = 0x44140013,
-  IMTQ_HANDLER = 0x44140014,
-  TMP1075_HANDLER_TCS_0 = 0x44420004,
-  TMP1075_HANDLER_TCS_1 = 0x44420005,
-  TMP1075_HANDLER_PLPCDU_0 = 0x44420006,
-  TMP1075_HANDLER_PLPCDU_1 = 0x44420007,
-  TMP1075_HANDLER_IF_BOARD = 0x44420008,
-
-  PCDU_HANDLER = 0x442000A1,
-  P60DOCK_HANDLER = 0x44250000,
-  PDU1_HANDLER = 0x44250001,
-  PDU2_HANDLER = 0x44250002,
-  ACU_HANDLER = 0x44250003,
-  BPX_BATT_HANDLER = 0x44260000,
-  PLPCDU_HANDLER = 0x44300000,
-  RAD_SENSOR = 0x443200A5,
-  PLOC_UPDATER = 0x44330000,
-  PLOC_MEMORY_DUMPER = 0x44330001,
-  STR_HELPER = 0x44330002,
-  PLOC_MPSOC_HELPER = 0x44330003,
-  AXI_PTME_CONFIG = 0x44330004,
-  PTME_CONFIG = 0x44330005,
-  PTME_VC0_LIVE_TM = 0x44330006,
-  PTME_VC1_LOG_TM = 0x44330007,
-  PTME_VC2_HK_TM = 0x44330008,
-  PTME_VC3_CFDP_TM = 0x44330009,
-  PLOC_MPSOC_HANDLER = 0x44330015,
-  PLOC_SUPERVISOR_HANDLER = 0x44330016,
-  PLOC_SUPERVISOR_HELPER = 0x44330017,
-  SCEX = 0x44330032,
-  SOLAR_ARRAY_DEPL_HANDLER = 0x444100A2,
-  HEATER_HANDLER = 0x444100A4,
-
-  /**
-   * Not yet specified which pt1000 will measure which device/location in the satellite.
-   * Therefore object ids are named according to the IC naming of the RTDs in the schematic.
-   */
-  RTD_0_IC3_PLOC_HEATSPREADER = 0x44420016,
-  RTD_1_IC4_PLOC_MISSIONBOARD = 0x44420017,
-  RTD_2_IC5_4K_CAMERA = 0x44420018,
-  RTD_3_IC6_DAC_HEATSPREADER = 0x44420019,
-  RTD_4_IC7_STARTRACKER = 0x44420020,
-  RTD_5_IC8_RW1_MX_MY = 0x44420021,
-  RTD_6_IC9_DRO = 0x44420022,
-  RTD_7_IC10_SCEX = 0x44420023,
-  RTD_8_IC11_X8 = 0x44420024,
-  RTD_9_IC12_HPA = 0x44420025,
-  RTD_10_IC13_PL_TX = 0x44420026,
-  RTD_11_IC14_MPA = 0x44420027,
-  RTD_12_IC15_ACU = 0x44420028,
-  RTD_13_IC16_PLPCDU_HEATSPREADER = 0x44420029,
-  RTD_14_IC17_TCS_BOARD = 0x44420030,
-  RTD_15_IC18_IMTQ = 0x44420031,
-
-  // Name convention for SUS devices
-  // SUS_<IDX>_<N/R>_LOC_X<F/M/B>Y<F/M/B>Z<F/M/B>_PT_<DIR><F/B>
-  // LOC: Location
-  // PT: Pointing
-  // N/R: Nominal/Redundant
-  // F/M/B: Forward/Middle/Backwards
-  SUS_0_N_LOC_XFYFZM_PT_XF = 0x44120032,
-  SUS_6_R_LOC_XFYBZM_PT_XF = 0x44120038,
-
-  SUS_1_N_LOC_XBYFZM_PT_XB = 0x44120033,
-  SUS_7_R_LOC_XBYBZM_PT_XB = 0x44120039,
-
-  SUS_2_N_LOC_XFYBZB_PT_YB = 0x44120034,
-  SUS_8_R_LOC_XBYBZB_PT_YB = 0x44120040,
-
-  SUS_3_N_LOC_XFYBZF_PT_YF = 0x44120035,
-  SUS_9_R_LOC_XBYBZB_PT_YF = 0x44120041,
-
-  SUS_4_N_LOC_XMYFZF_PT_ZF = 0x44120036,
-  SUS_10_N_LOC_XMYBZF_PT_ZF = 0x44120042,
-
-  SUS_5_N_LOC_XFYMZB_PT_ZB = 0x44120037,
-  SUS_11_R_LOC_XBYMZB_PT_ZB = 0x44120043,
-
-  SYRLINKS_HANDLER = 0x445300A3,
-  // might be obsolete, was not used in Q7S FM SW
-  // CCSDS_IP_CORE_BRIDGE = 0x73500000,
-
-  /* 0x49 ('I') for Communication Interfaces */
-  ACS_BOARD_POLLING_TASK = 0x49060004,
-  RW_POLLING_TASK = 0x49060005,
-  SPI_RTD_COM_IF = 0x49060006,
-  SUS_POLLING_TASK = 0x49060007,
-
-  // 0x60 for other stuff
-  HEATER_0_PLOC_PROC_BRD = 0x60000000,
-  HEATER_1_PCDU_BRD = 0x60000001,
-  HEATER_2_ACS_BRD = 0x60000002,
-  HEATER_3_OBC_BRD = 0x60000003,
-  HEATER_4_CAMERA = 0x60000004,
-  HEATER_5_STR = 0x60000005,
-  HEATER_6_DRO = 0x60000006,
-  HEATER_7_SYRLINKS = 0x60000007,
-
-  // 0x73 ('s') for assemblies and system/subsystem components
-  ACS_BOARD_ASS = 0x73000001,
-  SUS_BOARD_ASS = 0x73000002,
-  TCS_BOARD_ASS = 0x73000003,
-  RW_ASSY = 0x73000004,
-  CAM_SWITCHER = 0x73000006,
-  SYRLINKS_ASSY = 0x73000007,
-  IMTQ_ASSY = 0x73000008,
-  STR_ASSY = 0x73000009,
-  EIVE_SYSTEM = 0x73010000,
-  ACS_SUBSYSTEM = 0x73010001,
-  PL_SUBSYSTEM = 0x73010002,
-  TCS_SUBSYSTEM = 0x73010003,
-  COM_SUBSYSTEM = 0x73010004,
-
-  TM_FUNNEL = 0x73000100,
-  PUS_TM_FUNNEL = 0x73000101,
-  CFDP_TM_FUNNEL = 0x73000102,
-  CFDP_HANDLER = 0x73000205,
-  CFDP_DISTRIBUTOR = 0x73000206,
-  MISC_TM_STORE = 0x73020001,
-  OK_TM_STORE = 0x73020002,
-  NOT_OK_TM_STORE = 0x73020003,
-  HK_TM_STORE = 0x73020004,
-  CFDP_TM_STORE = 0x73030000,
-
-  LIVE_TM_TASK = 0x73040000,
-  LOG_STORE_AND_TM_TASK = 0x73040001,
-  HK_STORE_AND_TM_TASK = 0x73040002,
-  CFDP_STORE_AND_TM_TASK = 0x73040003,
-  DOWNLINK_RAM_STORE = 0x73040004,
-
-  // Other stuff
-  THERMAL_TEMP_INSERTER = 0x90000003,
-};
-}
-
-#endif /* COMMON_CONFIG_COMMONOBJECTS_H_ */