prep v1.25.0

Reviewed-on: #368

CHANGELOG.md

@@ -8,9 +8,190 @@ 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, the following changes will consitute of a breaking
+change warranting a new major release:
+
+- The TMTC interface changes in any shape of form.
+- The behavour of the OBSW changes in a major shape or form relevant
+  for operations
+
 # [unreleased]
 
-# [v1.19.0] 10.01.2023
+# [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
+
+- `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
 
@@ -32,7 +213,7 @@ list yields a list of all related PRs for each release.
 - Add automatic 5V stack commanding for all connected devices
   PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/335
 
-# [v1.18.0] 01.12.2022
+# [v1.18.0] 2022-12-01
 
 ## Changed
 
@@ -41,7 +222,7 @@ list yields a list of all related PRs for each release.
 - 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] 28.11.2022
+# [v1.17.0] 2022-11-28
 
 ## Added
 
@@ -50,7 +231,7 @@ list yields a list of all related PRs for each release.
   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] 18.11.2022
+# [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
@@ -67,7 +248,7 @@ list yields a list of all related PRs for each release.
 - Add remaining missing TMP1075 device handlers.
   PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/318
 
-# [v1.15.0] 27.10.2022
+# [v1.15.0] 2022-10-27
 
 - Consistent device file naming
 - Remove rad sensor from EM build, lead to weird bugs on EM which

CMakeLists.txt

@@ -10,7 +10,7 @@
 cmake_minimum_required(VERSION 3.13)
 
 set(OBSW_VERSION_MAJOR_IF_GIT_FAILS 1)
-set(OBSW_VERSION_MINOR_IF_GIT_FAILS 19)
+set(OBSW_VERSION_MINOR_IF_GIT_FAILS 25)
 set(OBSW_VERSION_REVISION_IF_GIT_FAILS 0)
 
 # set(CMAKE_VERBOSE TRUE)
@@ -135,7 +135,7 @@ set(OBSW_ADD_PL_PCDU
     ${INIT_VAL}
     CACHE STRING "Add Payload PCDU modukle")
 set(OBSW_ADD_SYRLINKS
-    ${INIT_VAL}
+    1
     CACHE STRING "Add Syrlinks module")
 set(OBSW_ADD_TMP_DEVICES
     ${INIT_VAL}
@@ -150,7 +150,7 @@ set(OBSW_ADD_SCEX_DEVICE
     ${INIT_VAL}
     CACHE STRING "Add Solar Cell Experiment module")
 set(OBSW_SYRLINKS_SIMULATED
-    ${OBSW_Q7S_EM}
+    0
     CACHE STRING "Syrlinks is simulated")
 
 # ##############################################################################

README.md

@@ -95,9 +95,7 @@ When using Windows, run theses steps in MSYS2.
 2. Update all the submodules
 
    ```sh
-   git submodule init
-   git submodule sync
-   git submodule update
+   git submodule update --init
    ```
 
 3. Ensure that the cross-compiler is working with `arm-linux-gnueabihf-gcc --version` and that
@@ -322,6 +320,8 @@ cmake --build . -j
 ### Hosted OBSW
 
 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.
 
 ```sh
 mkdir cmake-build-debug && cd cmake-build-debug

bsp_hosted/fsfwconfig/pollingsequence/DummyPst.cpp

@@ -44,12 +44,11 @@ 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_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::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::IMTQ_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
   thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE);

bsp_q7s/core/ObjectFactory.cpp

@@ -23,7 +23,7 @@
 #include "linux/boardtest/UartTestClass.h"
 #include "linux/callbacks/gpioCallbacks.h"
 #include "linux/csp/CspComIF.h"
-#include "linux/devices/GPSHyperionLinuxController.h"
+#include "linux/devices/GpsHyperionLinuxController.h"
 #include "linux/devices/ScexUartReader.h"
 #include "linux/devices/devicedefinitions/PlocMPSoCDefinitions.h"
 #include "linux/devices/devicedefinitions/StarTrackerDefinitions.h"
@@ -48,13 +48,16 @@
 #include "mission/system/objects/RwAssembly.h"
 #include "mission/system/objects/TcsBoardAssembly.h"
 #include "mission/system/tree/acsModeTree.h"
+#include "mission/system/tree/comModeTree.h"
 #include "mission/system/tree/payloadModeTree.h"
+#include "mission/system/tree/tcsModeTree.h"
 #include "tmtc/pusIds.h"
 #if OBSW_TEST_LIBGPIOD == 1
 #include "linux/boardtest/LibgpiodTest.h"
 #endif
 #include <mission/devices/ImtqHandler.h>
 #include <mission/devices/PcduHandler.h>
+#include <mission/devices/SyrlinksHandler.h>
 
 #include <sstream>
 
@@ -87,7 +90,6 @@
 #include "mission/devices/RadiationSensorHandler.h"
 #include "mission/devices/RwHandler.h"
 #include "mission/devices/SolarArrayDeploymentHandler.h"
-#include "mission/devices/SyrlinksHkHandler.h"
 #include "mission/devices/Tmp1075Handler.h"
 #include "mission/devices/devicedefinitions/GomspaceDefinitions.h"
 #include "mission/devices/devicedefinitions/Max31865Definitions.h"
@@ -138,6 +140,7 @@ void ObjectFactory::createTmpComponents() {
         new I2cCookie(tmpDevIds[idx].second, TMP1075::MAX_REPLY_LENGTH, q7s::I2C_PS_EIVE));
     auto* tmpDevHandler =
         new Tmp1075Handler(tmpDevIds[idx].first, objects::I2C_COM_IF, tmpDevCookies[idx]);
+    tmpDevHandler->connectModeTreeParent(satsystem::tcs::SUBSYSTEM);
     // TODO: Remove this after TCS subsystem was added
     // These devices are connected to the 3V3 stack and should be powered permanently. Therefore,
     // we set them to normal mode immediately here.
@@ -471,7 +474,7 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, SerialCo
   RESET_ARGS_GNSS.gpioComIF = gpioComIF;
   RESET_ARGS_GNSS.waitPeriodMs = 100;
   auto gpsCtrl =
-      new GPSHyperionLinuxController(objects::GPS_CONTROLLER, objects::NO_OBJECT, debugGps);
+      new GpsHyperionLinuxController(objects::GPS_CONTROLLER, objects::NO_OBJECT, debugGps);
   gpsCtrl->setResetPinTriggerFunction(gps::triggerGpioResetPin, &RESET_ARGS_GNSS);
 
   AcsBoardHelper acsBoardHelper = AcsBoardHelper(
@@ -578,15 +581,17 @@ void ObjectFactory::createSolarArrayDeploymentComponents(PowerSwitchIF& pwrSwitc
 
 void ObjectFactory::createSyrlinksComponents(PowerSwitchIF* pwrSwitcher) {
   auto* syrlinksUartCookie =
-      new SerialCookie(objects::SYRLINKS_HK_HANDLER, q7s::UART_SYRLINKS_DEV, uart::SYRLINKS_BAUD,
+      new SerialCookie(objects::SYRLINKS_HANDLER, q7s::UART_SYRLINKS_DEV, uart::SYRLINKS_BAUD,
                        syrlinks::MAX_REPLY_SIZE, UartModes::NON_CANONICAL);
   syrlinksUartCookie->setParityEven();
 
-  auto syrlinksFdir = new SyrlinksFdir(objects::SYRLINKS_HK_HANDLER);
+  auto syrlinksFdir = new SyrlinksFdir(objects::SYRLINKS_HANDLER);
   auto syrlinksHandler =
-      new SyrlinksHkHandler(objects::SYRLINKS_HK_HANDLER, objects::UART_COM_IF, syrlinksUartCookie,
-                            pcdu::PDU1_CH1_SYRLINKS_12V, syrlinksFdir);
+      new SyrlinksHandler(objects::SYRLINKS_HANDLER, objects::UART_COM_IF, syrlinksUartCookie,
+                          pcdu::PDU1_CH1_SYRLINKS_12V, syrlinksFdir);
   syrlinksHandler->setPowerSwitcher(pwrSwitcher);
+  syrlinksHandler->setStartUpImmediately();
+  syrlinksHandler->connectModeTreeParent(satsystem::com::SUBSYSTEM);
 #if OBSW_DEBUG_SYRLINKS == 1
   syrlinksHandler->setDebugMode(true);
 #endif
@@ -788,15 +793,22 @@ ReturnValue_t ObjectFactory::createCcsdsComponents(LinuxLibgpioIF* gpioComIF,
       objects::CCSDS_HANDLER, objects::PTME, objects::CCSDS_PACKET_DISTRIBUTOR, ptmeConfig,
       gpioComIF, gpioIds::RS485_EN_TX_CLOCK, gpioIds::RS485_EN_TX_DATA, TRANSMITTER_TIMEOUT);
   VirtualChannel* vc = nullptr;
-  vc = new VirtualChannel(ccsds::VC0, common::VC0_QUEUE_SIZE, objects::CCSDS_HANDLER);
+  vc = new VirtualChannel(ccsds::VC0, config::VC0_QUEUE_SIZE, objects::CCSDS_HANDLER);
   (*ipCoreHandler)->addVirtualChannel(ccsds::VC0, vc);
-  vc = new VirtualChannel(ccsds::VC1, common::VC1_QUEUE_SIZE, objects::CCSDS_HANDLER);
+  vc = new VirtualChannel(ccsds::VC1, config::VC1_QUEUE_SIZE, objects::CCSDS_HANDLER);
   (*ipCoreHandler)->addVirtualChannel(ccsds::VC1, vc);
-  vc = new VirtualChannel(ccsds::VC2, common::VC2_QUEUE_SIZE, objects::CCSDS_HANDLER);
+  vc = new VirtualChannel(ccsds::VC2, config::VC2_QUEUE_SIZE, objects::CCSDS_HANDLER);
   (*ipCoreHandler)->addVirtualChannel(ccsds::VC2, vc);
-  vc = new VirtualChannel(ccsds::VC3, common::VC3_QUEUE_SIZE, objects::CCSDS_HANDLER);
+  vc = new VirtualChannel(ccsds::VC3, config::VC3_QUEUE_SIZE, objects::CCSDS_HANDLER);
   (*ipCoreHandler)->addVirtualChannel(ccsds::VC3, vc);
 
+  ReturnValue_t result = (*ipCoreHandler)->connectModeTreeParent(satsystem::com::SUBSYSTEM);
+  if (result != returnvalue::OK) {
+    sif::error
+        << "ObjectFactory::createCcsdsComponents: Connecting COM subsystem to CCSDS handler failed"
+        << std::endl;
+  }
+
   GpioCookie* gpioCookiePdec = new GpioCookie;
   consumer.str("");
   consumer << "0x" << std::hex << objects::PDEC_HANDLER;

bsp_q7s/core/scheduling.cpp

@@ -1,6 +1,7 @@
 #include "scheduling.h"
 
 #include <fsfw/devicehandlers/DeviceCommunicationIF.h>
+#include <fsfw/subsystem/Subsystem.h>
 #include <linux/scheduling.h>
 
 #include <iostream>
@@ -142,10 +143,14 @@ void scheduling::initTasks() {
 #endif
 #endif
 
-#if OBSW_ADD_CCSDS_IP_CORES == 1
-  PeriodicTaskIF* ccsdsHandlerTask = factory->createPeriodicTask(
+  PeriodicTaskIF* comTask = factory->createPeriodicTask(
       "CCSDS_HANDLER", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
-  result = ccsdsHandlerTask->addComponent(objects::CCSDS_HANDLER);
+  result = comTask->addComponent(objects::COM_SUBSYSTEM);
+  if (result != returnvalue::OK) {
+    scheduling::printAddObjectError("COM subsystem", objects::COM_SUBSYSTEM);
+  }
+#if OBSW_ADD_CCSDS_IP_CORES == 1
+  result = comTask->addComponent(objects::CCSDS_HANDLER);
   if (result != returnvalue::OK) {
     scheduling::printAddObjectError("CCSDS Handler", objects::CCSDS_HANDLER);
   }
@@ -168,54 +173,25 @@ void scheduling::initTasks() {
   }
 #endif
 
-  PeriodicTaskIF* acsCtrlTask = factory->createPeriodicTask(
-      "ACS_TASK", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 0.4, missedDeadlineFunc);
 #if OBSW_ADD_GPS_CTRL == 1
-  result = acsCtrlTask->addComponent(objects::GPS_CONTROLLER);
+  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);
   }
 #endif /* OBSW_ADD_GPS_CTRL */
 
+  PeriodicTaskIF* acsSysTask = factory->createPeriodicTask(
+      "SYS_TASK", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 0.4, missedDeadlineFunc);
+  static_cast<void>(acsSysTask);
+  // To be removed soon because it will be part of the ACS PST.
 #if OBSW_ADD_ACS_CTRL == 1
-  acsCtrlTask->addComponent(objects::ACS_CONTROLLER);
+  acsSysTask->addComponent(objects::ACS_CONTROLLER);
   if (result != returnvalue::OK) {
     scheduling::printAddObjectError("ACS_CTRL", objects::ACS_CONTROLLER);
   }
 #endif
-#if OBSW_Q7S_EM == 1
-  acsCtrlTask->addComponent(objects::MGM_0_LIS3_HANDLER);
-  acsCtrlTask->addComponent(objects::MGM_1_RM3100_HANDLER);
-  acsCtrlTask->addComponent(objects::MGM_2_LIS3_HANDLER);
-  acsCtrlTask->addComponent(objects::MGM_3_RM3100_HANDLER);
-  acsCtrlTask->addComponent(objects::IMTQ_HANDLER);
-  acsCtrlTask->addComponent(objects::SUS_0_N_LOC_XFYFZM_PT_XF);
-  acsCtrlTask->addComponent(objects::SUS_6_R_LOC_XFYBZM_PT_XF);
-  acsCtrlTask->addComponent(objects::SUS_1_N_LOC_XBYFZM_PT_XB);
-  acsCtrlTask->addComponent(objects::SUS_7_R_LOC_XBYBZM_PT_XB);
-  acsCtrlTask->addComponent(objects::SUS_2_N_LOC_XFYBZB_PT_YB);
-  acsCtrlTask->addComponent(objects::SUS_8_R_LOC_XBYBZB_PT_YB);
-  acsCtrlTask->addComponent(objects::SUS_3_N_LOC_XFYBZF_PT_YF);
-  acsCtrlTask->addComponent(objects::SUS_9_R_LOC_XBYBZB_PT_YF);
-  acsCtrlTask->addComponent(objects::SUS_4_N_LOC_XMYFZF_PT_ZF);
-  acsCtrlTask->addComponent(objects::SUS_10_N_LOC_XMYBZF_PT_ZF);
-  acsCtrlTask->addComponent(objects::SUS_5_N_LOC_XFYMZB_PT_ZB);
-  acsCtrlTask->addComponent(objects::SUS_11_R_LOC_XBYMZB_PT_ZB);
-  acsCtrlTask->addComponent(objects::GYRO_0_ADIS_HANDLER);
-  acsCtrlTask->addComponent(objects::GYRO_1_L3G_HANDLER);
-  acsCtrlTask->addComponent(objects::GYRO_2_ADIS_HANDLER);
-  acsCtrlTask->addComponent(objects::GYRO_3_L3G_HANDLER);
-  acsCtrlTask->addComponent(objects::GPS_CONTROLLER);
-  acsCtrlTask->addComponent(objects::STAR_TRACKER);
-  acsCtrlTask->addComponent(objects::RW1);
-  acsCtrlTask->addComponent(objects::RW2);
-  acsCtrlTask->addComponent(objects::RW3);
-  acsCtrlTask->addComponent(objects::RW4);
-#endif
-
-  PeriodicTaskIF* acsSysTask = factory->createPeriodicTask(
-      "SYS_TASK", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 0.4, missedDeadlineFunc);
-  static_cast<void>(acsSysTask);
 #if OBSW_ADD_ACS_BOARD == 1
   result = acsSysTask->addComponent(objects::ACS_BOARD_ASS);
   if (result != returnvalue::OK) {
@@ -239,6 +215,35 @@ void scheduling::initTasks() {
     scheduling::printAddObjectError("ACS_SUBSYSTEM", objects::ACS_SUBSYSTEM);
   }
 
+#if OBSW_Q7S_EM == 1
+  acsSysTask->addComponent(objects::MGM_0_LIS3_HANDLER);
+  acsSysTask->addComponent(objects::MGM_1_RM3100_HANDLER);
+  acsSysTask->addComponent(objects::MGM_2_LIS3_HANDLER);
+  acsSysTask->addComponent(objects::MGM_3_RM3100_HANDLER);
+  acsSysTask->addComponent(objects::IMTQ_HANDLER);
+  acsSysTask->addComponent(objects::SUS_0_N_LOC_XFYFZM_PT_XF);
+  acsSysTask->addComponent(objects::SUS_6_R_LOC_XFYBZM_PT_XF);
+  acsSysTask->addComponent(objects::SUS_1_N_LOC_XBYFZM_PT_XB);
+  acsSysTask->addComponent(objects::SUS_7_R_LOC_XBYBZM_PT_XB);
+  acsSysTask->addComponent(objects::SUS_2_N_LOC_XFYBZB_PT_YB);
+  acsSysTask->addComponent(objects::SUS_8_R_LOC_XBYBZB_PT_YB);
+  acsSysTask->addComponent(objects::SUS_3_N_LOC_XFYBZF_PT_YF);
+  acsSysTask->addComponent(objects::SUS_9_R_LOC_XBYBZB_PT_YF);
+  acsSysTask->addComponent(objects::SUS_4_N_LOC_XMYFZF_PT_ZF);
+  acsSysTask->addComponent(objects::SUS_10_N_LOC_XMYBZF_PT_ZF);
+  acsSysTask->addComponent(objects::SUS_5_N_LOC_XFYMZB_PT_ZB);
+  acsSysTask->addComponent(objects::SUS_11_R_LOC_XBYMZB_PT_ZB);
+  acsSysTask->addComponent(objects::GYRO_0_ADIS_HANDLER);
+  acsSysTask->addComponent(objects::GYRO_1_L3G_HANDLER);
+  acsSysTask->addComponent(objects::GYRO_2_ADIS_HANDLER);
+  acsSysTask->addComponent(objects::GYRO_3_L3G_HANDLER);
+  acsSysTask->addComponent(objects::GPS_CONTROLLER);
+  acsSysTask->addComponent(objects::STAR_TRACKER);
+  acsSysTask->addComponent(objects::RW1);
+  acsSysTask->addComponent(objects::RW2);
+  acsSysTask->addComponent(objects::RW3);
+  acsSysTask->addComponent(objects::RW4);
+#endif
 #if OBSW_ADD_RTD_DEVICES == 1
   PeriodicTaskIF* tcsPollingTask = factory->createPeriodicTask(
       "TCS_POLLING_TASK", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 0.5, missedDeadlineFunc);
@@ -279,6 +284,10 @@ void scheduling::initTasks() {
 
   PeriodicTaskIF* tcsSystemTask = factory->createPeriodicTask(
       "TCS_TASK", 45, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.5, missedDeadlineFunc);
+  result = tcsSystemTask->addComponent(objects::TCS_SUBSYSTEM);
+  if (result != returnvalue::OK) {
+    scheduling::printAddObjectError("TCS_SUBSYSTEM", objects::TCS_SUBSYSTEM);
+  }
 #if OBSW_ADD_RTD_DEVICES == 1
   result = tcsSystemTask->addComponent(objects::TCS_BOARD_ASS);
   if (result != returnvalue::OK) {
@@ -376,8 +385,8 @@ void scheduling::initTasks() {
 #endif
 #endif
 
+  comTask->startTask();
 #if OBSW_ADD_CCSDS_IP_CORES == 1
-  ccsdsHandlerTask->startTask();
   pdecHandlerTask->startTask();
 #endif /* OBSW_ADD_CCSDS_IP_CORES == 1 */
 
@@ -405,7 +414,9 @@ void scheduling::initTasks() {
   strHelperTask->startTask();
 #endif /* OBSW_ADD_STAR_TRACKER == 1 */
 
-  acsCtrlTask->startTask();
+#if OBSW_ADD_GPS_CTRL == 1
+  gpsTask->startTask();
+#endif
   acsSysTask->startTask();
 #if OBSW_ADD_RTD_DEVICES == 1
   tcsPollingTask->startTask();

bsp_q7s/em/emObjectFactory.cpp

@@ -14,6 +14,7 @@
 #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();
@@ -108,4 +109,5 @@ void ObjectFactory::produce(void* args) {
                        pcdu::Switches::PDU1_CH5_SOLAR_CELL_EXP_5V);
 #endif
   createAcsController(true);
+  satsystem::com::init();
 }

bsp_q7s/fmObjectFactory.cpp

@@ -39,7 +39,7 @@ void ObjectFactory::produce(void* args) {
   createRadSensorComponent(gpioComIF, *stackHandler);
 #endif
 #if OBSW_ADD_SUN_SENSORS == 1
-  createSunSensorComponents(gpioComIF, spiMainComIF, pwrSwitcher, q7s::SPI_DEFAULT_DEV);
+  createSunSensorComponents(gpioComIF, spiMainComIF, pwrSwitcher, q7s::SPI_DEFAULT_DEV, true);
 #endif
 
 #if OBSW_ADD_ACS_BOARD == 1

bsp_q7s/obsw.cpp

@@ -1,6 +1,11 @@
 #include "obsw.h"
 
+#include <pwd.h>
+#include <sys/types.h>
+#include <unistd.h>
+
 #include <filesystem>
+#include <fstream>
 #include <iostream>
 
 #include "OBSWConfig.h"
@@ -36,6 +41,35 @@ int obsw::obsw() {
     return OBSW_ALREADY_RUNNING;
   }
 #endif
+
+  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";
+  // Init delay handling.
+  if (std::filesystem::exists(bootDelayFile)) {
+    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);
+  }
+
   scheduling::initMission();
 
   for (;;) {

common/config/commonConfig.h.in

@@ -36,14 +36,6 @@ 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/devices/addresses.h

@@ -9,7 +9,7 @@
 
 namespace addresses {
 /* Logical addresses have uint32_t datatype */
-enum logicalAddresses : address_t {
+enum LogicAddress : address_t {
   PCDU,
 
   MGM_0_LIS3 = objects::MGM_0_LIS3_HANDLER,

common/config/eive/definitions.h

@@ -39,10 +39,22 @@ static constexpr uint32_t SA_DEPL_INIT_BUFFER_SECS = 120;
 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 SA_DEPL_CHANNEL_ALTERNATION_INTERVAL_SECS = 5;
+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 uint8_t VC0_QUEUE_SIZE = 80;
+static constexpr uint8_t VC1_QUEUE_SIZE = 80;
+static constexpr uint8_t VC2_QUEUE_SIZE = 50;
+static constexpr uint8_t VC3_QUEUE_SIZE = 50;
+
+static constexpr uint32_t MAX_PUS_FUNNEL_QUEUE_DEPTH = 100;
+
+static constexpr uint32_t MAX_STORED_CMDS_UDP = 120;
+static constexpr uint32_t MAX_STORED_CMDS_TCP = 120;
+
 }  // namespace config
 
 #endif /* COMMON_CONFIG_DEFINITIONS_H_ */

common/config/eive/eventSubsystemIds.h

@@ -35,6 +35,7 @@ enum : uint8_t {
   SYRLINKS = 137,
   SCEX_HANDLER = 138,
   CONFIGHANDLER = 139,
+  CORE = 140,
   COMMON_SUBSYSTEM_ID_END
 
 };

common/config/eive/objects.h

@@ -50,7 +50,8 @@ enum commonObjects : uint32_t {
   TMP1075_HANDLER_PLPCDU_0 = 0x44420006,
   TMP1075_HANDLER_PLPCDU_1 = 0x44420007,
   TMP1075_HANDLER_IF_BOARD = 0x44420008,
-  TMP1075_HANDLER_OBC_IF_BOARD = 0x44420009,
+  // Does not exist anymore
+  // TMP1075_HANDLER_OBC_IF_BOARD = 0x44420009,
   PCDU_HANDLER = 0x442000A1,
   P60DOCK_HANDLER = 0x44250000,
   PDU1_HANDLER = 0x44250001,
@@ -117,7 +118,9 @@ enum commonObjects : uint32_t {
   SUS_5_N_LOC_XFYMZB_PT_ZB = 0x44120037,
   SUS_11_R_LOC_XBYMZB_PT_ZB = 0x44120043,
 
-  SYRLINKS_HK_HANDLER = 0x445300A3,
+  SYRLINKS_HANDLER = 0x445300A3,
+  // might be obsolete, was not used in Q7S FM SW
+  // CCSDS_IP_CORE_BRIDGE = 0x73500000,
 
   /* 0x49 ('I') for Communication Interfaces */
   SPI_RTD_COM_IF = 0x49020006,
@@ -138,9 +141,12 @@ enum commonObjects : uint32_t {
   TCS_BOARD_ASS = 0x73000003,
   RW_ASS = 0x73000004,
   CAM_SWITCHER = 0x73000006,
+  EIVE_SYSTEM = 0x73010000,
   ACS_SUBSYSTEM = 0x73010001,
   PL_SUBSYSTEM = 0x73010002,
-  EIVE_SYSTEM = 0x73010000,
+  TCS_SUBSYSTEM = 0x73010003,
+  COM_SUBSYSTEM = 0x73010004,
+
   TM_FUNNEL = 0x73000100,
   PUS_TM_FUNNEL = 0x73000101,
   CFDP_TM_FUNNEL = 0x73000102,

dummies/helpers.cpp

@@ -41,7 +41,7 @@ void dummy::createDummies(DummyCfg cfg, PowerSwitchIF& pwrSwitch) {
   new SaDeplDummy(objects::SOLAR_ARRAY_DEPL_HANDLER);
   new StarTrackerDummy(objects::STAR_TRACKER, objects::DUMMY_COM_IF, comCookieDummy);
   if (cfg.addSyrlinksDummies) {
-    new SyrlinksDummy(objects::SYRLINKS_HK_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+    new SyrlinksDummy(objects::SYRLINKS_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
   }
   new ImtqDummy(objects::IMTQ_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
   if (cfg.addPowerDummies) {

generators/bsp_q7s_events.csv

@@ -76,13 +76,16 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 7903;0x1edf;BIT_LOCK_LOST;INFO;A previously found Bit Lock signal was lost. P1: raw BLO state, P2: 0;fsfw/src/fsfw/datalinklayer/DataLinkLayer.h
 7905;0x1ee1;FRAME_PROCESSING_FAILED;LOW;The CCSDS Board could not interpret a TC;fsfw/src/fsfw/datalinklayer/DataLinkLayer.h
 8900;0x22c4;CLOCK_SET;INFO;;fsfw/src/fsfw/pus/Service9TimeManagement.h
-8901;0x22c5;CLOCK_SET_FAILURE;LOW;;fsfw/src/fsfw/pus/Service9TimeManagement.h
+8901;0x22c5;CLOCK_DUMP;INFO;;fsfw/src/fsfw/pus/Service9TimeManagement.h
+8902;0x22c6;CLOCK_SET_FAILURE;LOW;;fsfw/src/fsfw/pus/Service9TimeManagement.h
 9100;0x238c;TC_DELETION_FAILED;MEDIUM;Deletion of a TC from the map failed. P1: First 32 bit of request ID, P2. Last 32 bit of Request ID;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
 9700;0x25e4;TEST;INFO;;fsfw/src/fsfw/pus/Service17Test.h
 10600;0x2968;CHANGE_OF_SETUP_PARAMETER;LOW;;fsfw/src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.h
 10800;0x2a30;STORE_ERROR;LOW;;fsfw/src/fsfw/cfdp/handler/defs.h
 10801;0x2a31;MSG_QUEUE_ERROR;LOW;;fsfw/src/fsfw/cfdp/handler/defs.h
 10802;0x2a32;SERIALIZATION_ERROR;LOW;;fsfw/src/fsfw/cfdp/handler/defs.h
+11200;0x2bc0;SAFE_RATE_VIOLATION;MEDIUM;;mission/acsDefs.h
+11201;0x2bc1;SAFE_RATE_RECOVERY;MEDIUM;;mission/acsDefs.h
 11300;0x2c24;SWITCH_CMD_SENT;INFO;Indicates that a FSFW object requested setting a switch P1: 1 if on was requested, 0 for off | P2: Switch Index;mission/devices/devicedefinitions/powerDefinitions.h
 11301;0x2c25;SWITCH_HAS_CHANGED;INFO;Indicated that a switch state has changed P1: New switch state, 1 for on, 0 for off | P2: Switch Index;mission/devices/devicedefinitions/powerDefinitions.h
 11302;0x2c26;SWITCHING_Q7S_DENIED;MEDIUM;;mission/devices/devicedefinitions/powerDefinitions.h
@@ -225,11 +228,9 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 13630;0x353e;SUPV_UPDATE_PROGRESS;INFO;Will be triggered every 5 percent of the update progress. P1: First byte percent, third and fourth byte Sequence Count, P2: Bytes written;linux/devices/ploc/PlocSupvUartMan.h
 13631;0x353f;HDLC_FRAME_REMOVAL_ERROR;INFO;;linux/devices/ploc/PlocSupvUartMan.h
 13632;0x3540;HDLC_CRC_ERROR;INFO;;linux/devices/ploc/PlocSupvUartMan.h
-13700;0x3584;ALLOC_FAILURE;MEDIUM;;bsp_q7s/core/CoreController.h
-13701;0x3585;REBOOT_SW;MEDIUM; Software reboot occurred. Can also be a systemd reboot. P1: Current Chip, P2: Current Copy;bsp_q7s/core/CoreController.h
-13702;0x3586;REBOOT_MECHANISM_TRIGGERED;MEDIUM;The reboot mechanism was triggered. P1: First 16 bits: Last Chip, Last 16 bits: Last Copy, P2: Each byte is the respective reboot count for the slots;bsp_q7s/core/CoreController.h
-13703;0x3587;REBOOT_HW;MEDIUM;;bsp_q7s/core/CoreController.h
-13704;0x3588;NO_SD_CARD_ACTIVE;HIGH;No SD card was active. Core controller will attempt to re-initialize a SD card.;bsp_q7s/core/CoreController.h
+13700;0x3584;FDIR_REACTION_IGNORED;MEDIUM;;mission/devices/devicedefinitions/SyrlinksDefinitions.h
+13701;0x3585;TX_ON;INFO;Transmitter is on now. P1: Submode, P2: Current default datarate.;mission/devices/devicedefinitions/SyrlinksDefinitions.h
+13702;0x3586;TX_OFF;INFO;Transmitter is off now.;mission/devices/devicedefinitions/SyrlinksDefinitions.h
 13800;0x35e8;MISSING_PACKET;LOW;;mission/devices/devicedefinitions/ScexDefinitions.h
 13801;0x35e9;EXPERIMENT_TIMEDOUT;LOW;;mission/devices/devicedefinitions/ScexDefinitions.h
 13802;0x35ea;MULTI_PACKET_COMMAND_DONE;INFO;;mission/devices/devicedefinitions/ScexDefinitions.h
@@ -238,3 +239,8 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 13903;0x364f;INSERT_CONFIGFILEVALUE_FAILED;MEDIUM;;mission/utility/GlobalConfigHandler.h
 13904;0x3650;WRITE_CONFIGFILE_FAILED;MEDIUM;;mission/utility/GlobalConfigHandler.h
 13905;0x3651;READ_CONFIGFILE_FAILED;MEDIUM;;mission/utility/GlobalConfigHandler.h
+14000;0x36b0;ALLOC_FAILURE;MEDIUM;;bsp_q7s/core/CoreController.h
+14001;0x36b1;REBOOT_SW;MEDIUM; Software reboot occurred. Can also be a systemd reboot. P1: Current Chip, P2: Current Copy;bsp_q7s/core/CoreController.h
+14002;0x36b2;REBOOT_MECHANISM_TRIGGERED;MEDIUM;The reboot mechanism was triggered. P1: First 16 bits: Last Chip, Last 16 bits: Last Copy, P2: Each byte is the respective reboot count for the slots;bsp_q7s/core/CoreController.h
+14003;0x36b3;REBOOT_HW;MEDIUM;;bsp_q7s/core/CoreController.h
+14004;0x36b4;NO_SD_CARD_ACTIVE;HIGH;No SD card was active. Core controller will attempt to re-initialize a SD card.;bsp_q7s/core/CoreController.h

generators/bsp_q7s_objects.csv

@@ -72,7 +72,7 @@
 0x44420029;RTD_13_IC16_PLPCDU_HEATSPREADER
 0x44420030;RTD_14_IC17_TCS_BOARD
 0x44420031;RTD_15_IC18_IMTQ
-0x445300A3;SYRLINKS_HK_HANDLER
+0x445300A3;SYRLINKS_HANDLER
 0x49000000;ARDUINO_COM_IF
 0x49010005;GPIO_IF
 0x49010006;SCEX_UART_READER
@@ -84,8 +84,10 @@
 0x49050001;CSP_COM_IF
 0x50000100;CCSDS_PACKET_DISTRIBUTOR
 0x50000200;PUS_PACKET_DISTRIBUTOR
-0x50000300;TMTC_BRIDGE
-0x50000400;TMTC_POLLING_TASK
+0x50000300;TCP_TMTC_SERVER
+0x50000301;UDP_TMTC_SERVER
+0x50000400;TCP_TMTC_POLLING_TASK
+0x50000401;UDP_TMTC_POLLING_TASK
 0x50000500;FILE_SYSTEM_HANDLER
 0x50000550;SDC_MANAGER
 0x50000600;PTME
@@ -144,5 +146,7 @@
 0x73010000;EIVE_SYSTEM
 0x73010001;ACS_SUBSYSTEM
 0x73010002;PL_SUBSYSTEM
+0x73010003;TCS_SUBSYSTEM
+0x73010004;COM_SUBSYSTEM
 0x73500000;CCSDS_IP_CORE_BRIDGE
 0xFFFFFFFF;NO_OBJECT

generators/bsp_q7s_returnvalues.csv

@@ -1,14 +1,23 @@
 Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x0000;OK;System-wide code for ok.;0;HasReturnvaluesIF;fsfw/returnvalues/returnvalue.h
 0x0001;Failed;Unspecified system-wide code for failed.;1;HasReturnvaluesIF;fsfw/returnvalues/returnvalue.h
-0x60a0;CCSDS_CommandNotImplemented;Received action message with unknown action id;160;CCSDS_HANDLER;mission/tmtc/CcsdsIpCoreHandler.h
+0x63a0;NVMB_KeyNotExists;Specified key does not exist in json file;160;NVM_PARAM_BASE;mission/memory/NVMParameterBase.h
+0x6300;NVMB_Busy;;0;NVM_PARAM_BASE;mission/system/objects/Stack5VHandler.h
+0x58a0;SUSS_ErrorUnlockMutex;;160;SUS_HANDLER;mission/devices/SusHandler.h
+0x58a1;SUSS_ErrorLockMutex;;161;SUS_HANDLER;mission/devices/SusHandler.h
 0x66a0;SADPL_CommandNotSupported;;160;SA_DEPL_HANDLER;mission/devices/SolarArrayDeploymentHandler.h
 0x66a1;SADPL_DeploymentAlreadyExecuting;;161;SA_DEPL_HANDLER;mission/devices/SolarArrayDeploymentHandler.h
 0x66a2;SADPL_MainSwitchTimeoutFailure;;162;SA_DEPL_HANDLER;mission/devices/SolarArrayDeploymentHandler.h
 0x66a3;SADPL_SwitchingDeplSa1Failed;;163;SA_DEPL_HANDLER;mission/devices/SolarArrayDeploymentHandler.h
 0x66a4;SADPL_SwitchingDeplSa2Failed;;164;SA_DEPL_HANDLER;mission/devices/SolarArrayDeploymentHandler.h
-0x58a0;SUSS_ErrorUnlockMutex;;160;SUS_HANDLER;mission/devices/SusHandler.h
-0x58a1;SUSS_ErrorLockMutex;;161;SUS_HANDLER;mission/devices/SusHandler.h
+0x51a0;IMTQ_InvalidCommandCode;;160;IMTQ_HANDLER;mission/devices/ImtqHandler.h
+0x51a1;IMTQ_ParameterMissing;;161;IMTQ_HANDLER;mission/devices/ImtqHandler.h
+0x51a2;IMTQ_ParameterInvalid;;162;IMTQ_HANDLER;mission/devices/ImtqHandler.h
+0x51a3;IMTQ_CcUnavailable;;163;IMTQ_HANDLER;mission/devices/ImtqHandler.h
+0x51a4;IMTQ_InternalProcessingError;;164;IMTQ_HANDLER;mission/devices/ImtqHandler.h
+0x51a5;IMTQ_RejectedWithoutReason;;165;IMTQ_HANDLER;mission/devices/ImtqHandler.h
+0x51a6;IMTQ_CmdErrUnknown;;166;IMTQ_HANDLER;mission/devices/ImtqHandler.h
+0x51a7;IMTQ_UnexpectedSelfTestReply;The status reply to a self test command was received but no self test command has been sent. This should normally never happen.;167;IMTQ_HANDLER;mission/devices/ImtqHandler.h
 0x52b0;RWHA_SpiWriteFailure;;176;RW_HANDLER;mission/devices/RwHandler.h
 0x52b1;RWHA_SpiReadFailure;Used by the spi send function to tell a failing read call;177;RW_HANDLER;mission/devices/RwHandler.h
 0x52b2;RWHA_MissingStartSign;Can be used by the HDLC decoding mechanism to inform about a missing start sign 0x7E;178;RW_HANDLER;mission/devices/RwHandler.h
@@ -21,115 +30,85 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x52a2;RWHA_SetSpeedCommandInvalidLength;Received set speed command has invalid length. Should be 6.;162;RW_HANDLER;mission/devices/RwHandler.h
 0x52a3;RWHA_ExecutionFailed;Command execution failed;163;RW_HANDLER;mission/devices/RwHandler.h
 0x52a4;RWHA_CrcError;Reaction wheel reply has invalid crc;164;RW_HANDLER;mission/devices/RwHandler.h
-0x4fa1;HEATER_CommandNotSupported;;161;HEATER_HANDLER;mission/devices/HeaterHandler.h
-0x4fa2;HEATER_InitFailed;;162;HEATER_HANDLER;mission/devices/HeaterHandler.h
-0x4fa3;HEATER_InvalidSwitchNr;;163;HEATER_HANDLER;mission/devices/HeaterHandler.h
-0x4fa4;HEATER_MainSwitchSetTimeout;;164;HEATER_HANDLER;mission/devices/HeaterHandler.h
-0x4fa5;HEATER_CommandAlreadyWaiting;;165;HEATER_HANDLER;mission/devices/HeaterHandler.h
+0x50a0;SYRLINKS_CrcFailure;;160;SYRLINKS_HANDLER;mission/devices/SyrlinksHandler.h
+0x50a1;SYRLINKS_UartFraminOrParityErrorAck;;161;SYRLINKS_HANDLER;mission/devices/SyrlinksHandler.h
+0x50a2;SYRLINKS_BadCharacterAck;;162;SYRLINKS_HANDLER;mission/devices/SyrlinksHandler.h
+0x50a3;SYRLINKS_BadParameterValueAck;;163;SYRLINKS_HANDLER;mission/devices/SyrlinksHandler.h
+0x50a4;SYRLINKS_BadEndOfFrameAck;;164;SYRLINKS_HANDLER;mission/devices/SyrlinksHandler.h
+0x50a5;SYRLINKS_UnknownCommandIdAck;;165;SYRLINKS_HANDLER;mission/devices/SyrlinksHandler.h
+0x50a6;SYRLINKS_BadCrcAck;;166;SYRLINKS_HANDLER;mission/devices/SyrlinksHandler.h
+0x50a7;SYRLINKS_ReplyWrongSize;;167;SYRLINKS_HANDLER;mission/devices/SyrlinksHandler.h
+0x50a8;SYRLINKS_MissingStartFrameCharacter;;168;SYRLINKS_HANDLER;mission/devices/SyrlinksHandler.h
 0x5d00;GOMS_PacketTooLong;;0;GOM_SPACE_HANDLER;mission/devices/GomspaceDeviceHandler.h
 0x5d01;GOMS_InvalidTableId;;1;GOM_SPACE_HANDLER;mission/devices/GomspaceDeviceHandler.h
 0x5d02;GOMS_InvalidAddress;;2;GOM_SPACE_HANDLER;mission/devices/GomspaceDeviceHandler.h
 0x5d03;GOMS_InvalidParamSize;;3;GOM_SPACE_HANDLER;mission/devices/GomspaceDeviceHandler.h
 0x5d04;GOMS_InvalidPayloadSize;;4;GOM_SPACE_HANDLER;mission/devices/GomspaceDeviceHandler.h
 0x5d05;GOMS_UnknownReplyId;;5;GOM_SPACE_HANDLER;mission/devices/GomspaceDeviceHandler.h
-0x51a0;IMTQ_InvalidCommandCode;;160;IMTQ_HANDLER;mission/devices/ImtqHandler.h
-0x51a1;IMTQ_ParameterMissing;;161;IMTQ_HANDLER;mission/devices/ImtqHandler.h
-0x51a2;IMTQ_ParameterInvalid;;162;IMTQ_HANDLER;mission/devices/ImtqHandler.h
-0x51a3;IMTQ_CcUnavailable;;163;IMTQ_HANDLER;mission/devices/ImtqHandler.h
-0x51a4;IMTQ_InternalProcessingError;;164;IMTQ_HANDLER;mission/devices/ImtqHandler.h
-0x51a5;IMTQ_RejectedWithoutReason;;165;IMTQ_HANDLER;mission/devices/ImtqHandler.h
-0x51a6;IMTQ_CmdErrUnknown;;166;IMTQ_HANDLER;mission/devices/ImtqHandler.h
-0x51a7;IMTQ_UnexpectedSelfTestReply;The status reply to a self test command was received but no self test command has been sent. This should normally never happen.;167;IMTQ_HANDLER;mission/devices/ImtqHandler.h
-0x50a0;SYRLINKS_CrcFailure;;160;SYRLINKS_HANDLER;mission/devices/SyrlinksHkHandler.h
-0x50a1;SYRLINKS_UartFraminOrParityErrorAck;;161;SYRLINKS_HANDLER;mission/devices/SyrlinksHkHandler.h
-0x50a2;SYRLINKS_BadCharacterAck;;162;SYRLINKS_HANDLER;mission/devices/SyrlinksHkHandler.h
-0x50a3;SYRLINKS_BadParameterValueAck;;163;SYRLINKS_HANDLER;mission/devices/SyrlinksHkHandler.h
-0x50a4;SYRLINKS_BadEndOfFrameAck;;164;SYRLINKS_HANDLER;mission/devices/SyrlinksHkHandler.h
-0x50a5;SYRLINKS_UnknownCommandIdAck;;165;SYRLINKS_HANDLER;mission/devices/SyrlinksHkHandler.h
-0x50a6;SYRLINKS_BadCrcAck;;166;SYRLINKS_HANDLER;mission/devices/SyrlinksHkHandler.h
-0x50a7;SYRLINKS_ReplyWrongSize;;167;SYRLINKS_HANDLER;mission/devices/SyrlinksHkHandler.h
-0x50a8;SYRLINKS_MissingStartFrameCharacter;;168;SYRLINKS_HANDLER;mission/devices/SyrlinksHkHandler.h
-0x63a0;NVMB_KeyNotExists;Specified key does not exist in json file;160;NVM_PARAM_BASE;mission/memory/NVMParameterBase.h
-0x3c00;LPIF_PoolEntryNotFound;;0;LOCAL_POOL_OWNER_IF;fsfw/src/fsfw/datapoollocal/localPoolDefinitions.h
-0x3c01;LPIF_PoolEntryTypeConflict;;1;LOCAL_POOL_OWNER_IF;fsfw/src/fsfw/datapoollocal/localPoolDefinitions.h
-0x3e00;HKM_QueueOrDestinationInvalid;;0;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
-0x3e01;HKM_WrongHkPacketType;;1;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
-0x3e02;HKM_ReportingStatusUnchanged;;2;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
-0x3e03;HKM_PeriodicHelperInvalid;;3;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
-0x3e04;HKM_PoolobjectNotFound;;4;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
-0x3e05;HKM_DatasetNotFound;;5;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
-0x3601;CFDP_InvalidTlvType;;1;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3602;CFDP_InvalidDirectiveField;;2;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3603;CFDP_InvalidPduDatafieldLen;;3;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3604;CFDP_InvalidAckDirectiveFields;;4;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3605;CFDP_MetadataCantParseOptions;;5;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3606;CFDP_NakCantParseOptions;;6;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3607;CFDP_FinishedCantParseFsResponses;;7;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3608;CFDP_FilestoreRequiresSecondFile;;8;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3609;CFDP_FilestoreResponseCantParseFsMessage;;9;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x360a;CFDP_InvalidPduFormat;;10;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3201;CF_ObjectHasNoFunctions;;1;COMMANDS_ACTIONS_IF;fsfw/src/fsfw/action/CommandsActionsIF.h
-0x3202;CF_AlreadyCommanding;;2;COMMANDS_ACTIONS_IF;fsfw/src/fsfw/action/CommandsActionsIF.h
-0x3301;HF_IsBusy;;1;HAS_ACTIONS_IF;fsfw/src/fsfw/action/HasActionsIF.h
-0x3302;HF_InvalidParameters;;2;HAS_ACTIONS_IF;fsfw/src/fsfw/action/HasActionsIF.h
-0x3303;HF_ExecutionFinished;;3;HAS_ACTIONS_IF;fsfw/src/fsfw/action/HasActionsIF.h
-0x3304;HF_InvalidActionId;;4;HAS_ACTIONS_IF;fsfw/src/fsfw/action/HasActionsIF.h
-0x1e00;PUS_InvalidPusVersion;;0;PUS_IF;fsfw/src/fsfw/tmtcpacket/pus/PusIF.h
-0x1e01;PUS_InvalidCrc16;;1;PUS_IF;fsfw/src/fsfw/tmtcpacket/pus/PusIF.h
-0x2e01;HPA_InvalidIdentifierId;;1;HAS_PARAMETERS_IF;fsfw/src/fsfw/parameters/HasParametersIF.h
-0x2e02;HPA_InvalidDomainId;;2;HAS_PARAMETERS_IF;fsfw/src/fsfw/parameters/HasParametersIF.h
-0x2e03;HPA_InvalidValue;;3;HAS_PARAMETERS_IF;fsfw/src/fsfw/parameters/HasParametersIF.h
-0x2e05;HPA_ReadOnly;;5;HAS_PARAMETERS_IF;fsfw/src/fsfw/parameters/HasParametersIF.h
-0x2d01;PAW_UnknownDatatype;;1;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
-0x2d02;PAW_DatatypeMissmatch;;2;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
-0x2d03;PAW_Readonly;;3;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
-0x2d04;PAW_TooBig;;4;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
-0x2d05;PAW_SourceNotSet;;5;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
-0x2d06;PAW_OutOfBounds;;6;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
-0x2d07;PAW_NotSet;;7;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
-0x2d08;PAW_ColumnOrRowsZero;;8;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
-0x1701;HHI_ObjectNotHealthy;;1;HAS_HEALTH_IF;fsfw/src/fsfw/health/HasHealthIF.h
-0x1702;HHI_InvalidHealthState;;2;HAS_HEALTH_IF;fsfw/src/fsfw/health/HasHealthIF.h
-0x1703;HHI_IsExternallyControlled;;3;HAS_HEALTH_IF;fsfw/src/fsfw/health/HasHealthIF.h
+0x4fa1;HEATER_CommandNotSupported;;161;HEATER_HANDLER;mission/devices/HeaterHandler.h
+0x4fa2;HEATER_InitFailed;;162;HEATER_HANDLER;mission/devices/HeaterHandler.h
+0x4fa3;HEATER_InvalidSwitchNr;;163;HEATER_HANDLER;mission/devices/HeaterHandler.h
+0x4fa4;HEATER_MainSwitchSetTimeout;;164;HEATER_HANDLER;mission/devices/HeaterHandler.h
+0x4fa5;HEATER_CommandAlreadyWaiting;;165;HEATER_HANDLER;mission/devices/HeaterHandler.h
+0x60a0;CCSDS_CommandNotImplemented;Received action message with unknown action id;160;CCSDS_HANDLER;mission/tmtc/CcsdsIpCoreHandler.h
+0x6001;CCSDS_KalmanNoGyrMeas;;1;CCSDS_HANDLER;mission/controller/acs/MultiplicativeKalmanFilter.h
+0x6002;CCSDS_KalmanNoModel;;2;CCSDS_HANDLER;mission/controller/acs/MultiplicativeKalmanFilter.h
+0x6003;CCSDS_KalmanInversionFailed;;3;CCSDS_HANDLER;mission/controller/acs/MultiplicativeKalmanFilter.h
+0x4500;HSPI_OpeningFileFailed;;0;HAL_SPI;fsfw/src/fsfw_hal/linux/spi/SpiComIF.h
+0x4501;HSPI_FullDuplexTransferFailed;;1;HAL_SPI;fsfw/src/fsfw_hal/linux/spi/SpiComIF.h
+0x4502;HSPI_HalfDuplexTransferFailed;;2;HAL_SPI;fsfw/src/fsfw_hal/linux/spi/SpiComIF.h
+0x4801;HGIO_UnknownGpioId;;1;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+0x4802;HGIO_DriveGpioFailure;;2;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+0x4803;HGIO_GpioTypeFailure;;3;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+0x4804;HGIO_GpioInvalidInstance;;4;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+0x4805;HGIO_GpioDuplicateDetected;;5;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+0x4806;HGIO_GpioInitFailed;;6;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+0x4807;HGIO_GpioGetValueFailed;;7;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+0x4601;HURT_UartReadFailure;;1;HAL_UART;fsfw/src/fsfw_hal/linux/serial/SerialComIF.h
+0x4602;HURT_UartReadSizeMissmatch;;2;HAL_UART;fsfw/src/fsfw_hal/linux/serial/SerialComIF.h
+0x4603;HURT_UartRxBufferTooSmall;;3;HAL_UART;fsfw/src/fsfw_hal/linux/serial/SerialComIF.h
+0x4400;UXOS_ExecutionFinished;Execution of the current command has finished;0;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
+0x4401;UXOS_CommandPending;Command is pending. This will also be returned if the user tries to load another command but a command is still pending;1;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
+0x4402;UXOS_BytesRead;Some bytes have been read from the executing process;2;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
+0x4403;UXOS_CommandError;Command execution failed;3;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
+0x4404;UXOS_NoCommandLoadedOrPending;;4;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
+0x4406;UXOS_PcloseCallError;;6;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
 0x2801;SM_DataTooLarge;;1;STORAGE_MANAGER_IF;fsfw/src/fsfw/storagemanager/StorageManagerIF.h
 0x2802;SM_DataStorageFull;;2;STORAGE_MANAGER_IF;fsfw/src/fsfw/storagemanager/StorageManagerIF.h
 0x2803;SM_IllegalStorageId;;3;STORAGE_MANAGER_IF;fsfw/src/fsfw/storagemanager/StorageManagerIF.h
 0x2804;SM_DataDoesNotExist;;4;STORAGE_MANAGER_IF;fsfw/src/fsfw/storagemanager/StorageManagerIF.h
 0x2805;SM_IllegalAddress;;5;STORAGE_MANAGER_IF;fsfw/src/fsfw/storagemanager/StorageManagerIF.h
 0x2806;SM_PoolTooLarge;;6;STORAGE_MANAGER_IF;fsfw/src/fsfw/storagemanager/StorageManagerIF.h
-0x2401;MT_TooDetailedRequest;;1;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h
-0x2402;MT_TooGeneralRequest;;2;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h
-0x2403;MT_NoMatch;;3;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h
-0x2404;MT_Full;;4;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h
-0x2405;MT_NewNodeCreated;;5;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h
-0x3f01;DLEE_StreamTooShort;;1;DLE_ENCODER;fsfw/src/fsfw/globalfunctions/DleEncoder.h
-0x3f02;DLEE_DecodingError;;2;DLE_ENCODER;fsfw/src/fsfw/globalfunctions/DleEncoder.h
-0x2f01;ASC_NoPacketFound;;1;ASCII_CONVERTER;fsfw/src/fsfw/globalfunctions/DleParser.h
-0x2f02;ASC_PossiblePacketLoss;;2;ASCII_CONVERTER;fsfw/src/fsfw/globalfunctions/DleParser.h
-0x2f03;ASC_BufferTooSmall;;3;ASCII_CONVERTER;fsfw/src/fsfw/globalfunctions/AsciiConverter.h
-0x4201;PUS11_InvalidTypeTimeWindow;;1;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
-0x4202;PUS11_InvalidTimeWindow;;2;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
-0x4203;PUS11_TimeshiftingNotPossible;;3;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
-0x4204;PUS11_InvalidRelativeTime;;4;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
-0x1c01;TCD_PacketLost;;1;PACKET_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/TcDistributorBase.h
-0x1c02;TCD_DestinationNotFound;;2;PACKET_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/TcDistributorBase.h
-0x1c03;TCD_ServiceIdAlreadyExists;;3;PACKET_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/TcDistributorBase.h
-0x1b00;TCC_NoDestinationFound;;0;TMTC_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/definitions.h
-0x1b01;TCC_InvalidCcsdsVersion;;1;TMTC_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/definitions.h
-0x1b02;TCC_InvalidApid;;2;TMTC_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/definitions.h
-0x1b03;TCC_InvalidPacketType;;3;TMTC_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/definitions.h
-0x1b04;TCC_InvalidSecHeaderField;;4;TMTC_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/definitions.h
-0x1b05;TCC_IncorrectPrimaryHeader;;5;TMTC_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/definitions.h
-0x1b07;TCC_IncompletePacket;;7;TMTC_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/definitions.h
-0x1b08;TCC_InvalidPusVersion;;8;TMTC_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/definitions.h
-0x1b09;TCC_IncorrectChecksum;;9;TMTC_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/definitions.h
-0x1b0a;TCC_IllegalPacketSubtype;;10;TMTC_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/definitions.h
-0x1b0b;TCC_IncorrectSecondaryHeader;;11;TMTC_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/definitions.h
-0x3a01;MQI_Empty;;1;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
-0x3a02;MQI_Full;No space left for more messages;2;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
-0x3a03;MQI_NoReplyPartner;Returned if a reply method was called without partner;3;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
-0x3a04;MQI_DestinationInvalid;Returned if the target destination is invalid.;4;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
-0x0f01;CM_UnknownCommand;;1;COMMAND_MESSAGE;fsfw/src/fsfw/ipc/CommandMessageIF.h
+0x0601;PP_DoItMyself;;1;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
+0x0602;PP_PointsToVariable;;2;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
+0x0603;PP_PointsToMemory;;3;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
+0x0604;PP_ActivityCompleted;;4;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
+0x0605;PP_PointsToVectorUint8;;5;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
+0x0606;PP_PointsToVectorUint16;;6;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
+0x0607;PP_PointsToVectorUint32;;7;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
+0x0608;PP_PointsToVectorFloat;;8;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
+0x06a0;PP_DumpNotSupported;;160;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
+0x06e0;PP_InvalidSize;;224;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
+0x06e1;PP_InvalidAddress;;225;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
+0x06e2;PP_InvalidContent;;226;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
+0x06e3;PP_UnalignedAccess;;227;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
+0x06e4;PP_WriteProtected;;228;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
+0x13e0;MH_UnknownCmd;;224;MEMORY_HELPER;fsfw/src/fsfw/memory/MemoryHelper.h
+0x13e1;MH_InvalidAddress;;225;MEMORY_HELPER;fsfw/src/fsfw/memory/MemoryHelper.h
+0x13e2;MH_InvalidSize;;226;MEMORY_HELPER;fsfw/src/fsfw/memory/MemoryHelper.h
+0x13e3;MH_StateMismatch;;227;MEMORY_HELPER;fsfw/src/fsfw/memory/MemoryHelper.h
+0x38a1;SGP4_InvalidEccentricity;;161;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x38a2;SGP4_InvalidMeanMotion;;162;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x38a3;SGP4_InvalidPerturbationElements;;163;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x38a4;SGP4_InvalidSemiLatusRectum;;164;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x38a5;SGP4_InvalidEpochElements;;165;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x38a6;SGP4_SatelliteHasDecayed;;166;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x38b1;SGP4_TleTooOld;;177;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x38b2;SGP4_TleNotInitialized;;178;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x1801;FF_Full;;1;FIFO_CLASS;fsfw/src/fsfw/container/FIFOBase.h
+0x1802;FF_Empty;;2;FIFO_CLASS;fsfw/src/fsfw/container/FIFOBase.h
+0x1601;FMM_MapFull;;1;FIXED_MULTIMAP;fsfw/src/fsfw/container/FixedOrderedMultimap.h
+0x1602;FMM_KeyDoesNotExist;;2;FIXED_MULTIMAP;fsfw/src/fsfw/container/FixedOrderedMultimap.h
 0x3901;MUX_NotEnoughResources;;1;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
 0x3902;MUX_InsufficientMemory;;2;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
 0x3903;MUX_NoPrivilege;;3;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
@@ -142,20 +121,23 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x390a;MUX_MutexTimeout;;10;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
 0x390b;MUX_MutexInvalidId;;11;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
 0x390c;MUX_MutexDestroyedWhileWaiting;;12;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x2901;TC_InvalidTargetState;;1;THERMAL_COMPONENT_IF;fsfw/src/fsfw/thermal/ThermalComponentIF.h
-0x29f1;TC_AboveOperationalLimit;;241;THERMAL_COMPONENT_IF;fsfw/src/fsfw/thermal/ThermalComponentIF.h
-0x29f2;TC_BelowOperationalLimit;;242;THERMAL_COMPONENT_IF;fsfw/src/fsfw/thermal/ThermalComponentIF.h
-0x0801;DPS_InvalidParameterDefinition;;1;DATA_SET_CLASS;fsfw/src/fsfw/datapool/DataSetIF.h
-0x0802;DPS_SetWasAlreadyRead;;2;DATA_SET_CLASS;fsfw/src/fsfw/datapool/DataSetIF.h
-0x0803;DPS_CommitingWithoutReading;;3;DATA_SET_CLASS;fsfw/src/fsfw/datapool/DataSetIF.h
-0x0804;DPS_DataSetUninitialised;;4;DATA_SET_CLASS;fsfw/src/fsfw/datapool/DataSetIF.h
-0x0805;DPS_DataSetFull;;5;DATA_SET_CLASS;fsfw/src/fsfw/datapool/DataSetIF.h
-0x0806;DPS_PoolVarNull;;6;DATA_SET_CLASS;fsfw/src/fsfw/datapool/DataSetIF.h
-0x3da0;PVA_InvalidReadWriteMode;;160;POOL_VARIABLE_IF;fsfw/src/fsfw/datapool/PoolVariableIF.h
-0x3da1;PVA_InvalidPoolEntry;;161;POOL_VARIABLE_IF;fsfw/src/fsfw/datapool/PoolVariableIF.h
+0x3a01;MQI_Empty;;1;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
+0x3a02;MQI_Full;No space left for more messages;2;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
+0x3a03;MQI_NoReplyPartner;Returned if a reply method was called without partner;3;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
+0x3a04;MQI_DestinationInvalid;Returned if the target destination is invalid.;4;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
+0x0f01;CM_UnknownCommand;;1;COMMAND_MESSAGE;fsfw/src/fsfw/ipc/CommandMessageIF.h
+0x0e01;HM_InvalidMode;;1;HAS_MODES_IF;fsfw/src/fsfw/modes/HasModesIF.h
+0x0e02;HM_TransNotAllowed;;2;HAS_MODES_IF;fsfw/src/fsfw/modes/HasModesIF.h
+0x0e03;HM_InTransition;;3;HAS_MODES_IF;fsfw/src/fsfw/modes/HasModesIF.h
+0x0e04;HM_InvalidSubmode;;4;HAS_MODES_IF;fsfw/src/fsfw/modes/HasModesIF.h
 0x0c02;MS_InvalidEntry;;2;MODE_STORE_IF;fsfw/src/fsfw/subsystem/modes/ModeStoreIF.h
 0x0c03;MS_TooManyElements;;3;MODE_STORE_IF;fsfw/src/fsfw/subsystem/modes/ModeStoreIF.h
 0x0c04;MS_CantStoreEmpty;;4;MODE_STORE_IF;fsfw/src/fsfw/subsystem/modes/ModeStoreIF.h
+0x0b01;SB_ChildNotFound;;1;SUBSYSTEM_BASE;fsfw/src/fsfw/subsystem/SubsystemBase.h
+0x0b02;SB_ChildInfoUpdated;;2;SUBSYSTEM_BASE;fsfw/src/fsfw/subsystem/SubsystemBase.h
+0x0b03;SB_ChildDoesntHaveModes;;3;SUBSYSTEM_BASE;fsfw/src/fsfw/subsystem/SubsystemBase.h
+0x0b04;SB_CouldNotInsertChild;;4;SUBSYSTEM_BASE;fsfw/src/fsfw/subsystem/SubsystemBase.h
+0x0b05;SB_TableContainsInvalidObjectId;;5;SUBSYSTEM_BASE;fsfw/src/fsfw/subsystem/SubsystemBase.h
 0x0d01;SS_SequenceAlreadyExists;;1;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
 0x0d02;SS_TableAlreadyExists;;2;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
 0x0d03;SS_TableDoesNotExist;;3;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
@@ -170,53 +152,7 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x0d0e;SS_TableInUse;;14;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
 0x0da1;SS_TargetTableNotReached;;161;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
 0x0da2;SS_TableCheckFailed;;162;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
-0x0b01;SB_ChildNotFound;;1;SUBSYSTEM_BASE;fsfw/src/fsfw/subsystem/SubsystemBase.h
-0x0b02;SB_ChildInfoUpdated;;2;SUBSYSTEM_BASE;fsfw/src/fsfw/subsystem/SubsystemBase.h
-0x0b03;SB_ChildDoesntHaveModes;;3;SUBSYSTEM_BASE;fsfw/src/fsfw/subsystem/SubsystemBase.h
-0x0b04;SB_CouldNotInsertChild;;4;SUBSYSTEM_BASE;fsfw/src/fsfw/subsystem/SubsystemBase.h
-0x0b05;SB_TableContainsInvalidObjectId;;5;SUBSYSTEM_BASE;fsfw/src/fsfw/subsystem/SubsystemBase.h
-0x0b00;SB_ConnBroken;;0;SUBSYSTEM_BASE;fsfw/src/fsfw/osal/common/TcpTmTcServer.h
-0x2a01;IEC_NoConfigurationTable;;1;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2a02;IEC_NoCpuTable;;2;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2a03;IEC_InvalidWorkspaceAddress;;3;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2a04;IEC_TooLittleWorkspace;;4;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2a05;IEC_WorkspaceAllocation;;5;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2a06;IEC_InterruptStackTooSmall;;6;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2a07;IEC_ThreadExitted;;7;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2a08;IEC_InconsistentMpInformation;;8;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2a09;IEC_InvalidNode;;9;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2a0a;IEC_NoMpci;;10;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2a0b;IEC_BadPacket;;11;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2a0c;IEC_OutOfPackets;;12;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2a0d;IEC_OutOfGlobalObjects;;13;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2a0e;IEC_OutOfProxies;;14;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2a0f;IEC_InvalidGlobalId;;15;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2a10;IEC_BadStackHook;;16;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2a11;IEC_BadAttributes;;17;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2a12;IEC_ImplementationKeyCreateInconsistency;;18;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2a13;IEC_ImplementationBlockingOperationCancel;;19;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2a14;IEC_MutexObtainFromBadState;;20;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2a15;IEC_UnlimitedAndMaximumIs0;;21;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x1401;SE_BufferTooShort;;1;SERIALIZE_IF;fsfw/src/fsfw/serialize/SerializeIF.h
-0x1402;SE_StreamTooShort;;2;SERIALIZE_IF;fsfw/src/fsfw/serialize/SerializeIF.h
-0x1403;SE_TooManyElements;;3;SERIALIZE_IF;fsfw/src/fsfw/serialize/SerializeIF.h
-0x4c00;SPPA_NoPacketFound;;0;SPACE_PACKET_PARSER;fsfw/src/fsfw/tmtcservices/SpacePacketParser.h
-0x4c01;SPPA_SplitPacket;;1;SPACE_PACKET_PARSER;fsfw/src/fsfw/tmtcservices/SpacePacketParser.h
-0x1d01;ATC_ActivityStarted;;1;ACCEPTS_TELECOMMANDS_IF;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h
-0x1d02;ATC_InvalidSubservice;;2;ACCEPTS_TELECOMMANDS_IF;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h
-0x1d03;ATC_IllegalApplicationData;;3;ACCEPTS_TELECOMMANDS_IF;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h
-0x1d04;ATC_SendTmFailed;;4;ACCEPTS_TELECOMMANDS_IF;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h
-0x1d05;ATC_Timeout;;5;ACCEPTS_TELECOMMANDS_IF;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h
-0x2001;CSB_ExecutionComplete;;1;COMMAND_SERVICE_BASE;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h
-0x2002;CSB_NoStepMessage;;2;COMMAND_SERVICE_BASE;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h
-0x2003;CSB_ObjectBusy;;3;COMMAND_SERVICE_BASE;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h
-0x2004;CSB_Busy;;4;COMMAND_SERVICE_BASE;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h
-0x2005;CSB_InvalidTc;;5;COMMAND_SERVICE_BASE;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h
-0x2006;CSB_InvalidObject;;6;COMMAND_SERVICE_BASE;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h
-0x2007;CSB_InvalidReply;;7;COMMAND_SERVICE_BASE;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h
-0x2600;FDI_YourFault;;0;HANDLES_FAILURES_IF;fsfw/src/fsfw/fdir/ConfirmsFailuresIF.h
-0x2601;FDI_MyFault;;1;HANDLES_FAILURES_IF;fsfw/src/fsfw/fdir/ConfirmsFailuresIF.h
-0x2602;FDI_ConfirmLater;;2;HANDLES_FAILURES_IF;fsfw/src/fsfw/fdir/ConfirmsFailuresIF.h
+0x2501;EV_ListenerNotFound;;1;EVENT_MANAGER_IF;fsfw/src/fsfw/events/EventManagerIF.h
 0x04e1;RMP_CommandNoDescriptorsAvailable;;225;RMAP_CHANNEL;fsfw/src/fsfw/rmap/RMAP.h
 0x04e2;RMP_CommandBufferFull;;226;RMAP_CHANNEL;fsfw/src/fsfw/rmap/RMAP.h
 0x04e3;RMP_CommandChannelOutOfRange;;227;RMAP_CHANNEL;fsfw/src/fsfw/rmap/RMAP.h
@@ -257,6 +193,153 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x040a;RMP_ReplyCommandNotImplementedOrNotAuthorised;;10;RMAP_CHANNEL;fsfw/src/fsfw/rmap/RMAP.h
 0x040b;RMP_ReplyRmwDataLengthError;;11;RMAP_CHANNEL;fsfw/src/fsfw/rmap/RMAP.h
 0x040c;RMP_ReplyInvalidTargetLogicalAddress;;12;RMAP_CHANNEL;fsfw/src/fsfw/rmap/RMAP.h
+0x1401;SE_BufferTooShort;;1;SERIALIZE_IF;fsfw/src/fsfw/serialize/SerializeIF.h
+0x1402;SE_StreamTooShort;;2;SERIALIZE_IF;fsfw/src/fsfw/serialize/SerializeIF.h
+0x1403;SE_TooManyElements;;3;SERIALIZE_IF;fsfw/src/fsfw/serialize/SerializeIF.h
+0x3da0;PVA_InvalidReadWriteMode;;160;POOL_VARIABLE_IF;fsfw/src/fsfw/datapool/PoolVariableIF.h
+0x3da1;PVA_InvalidPoolEntry;;161;POOL_VARIABLE_IF;fsfw/src/fsfw/datapool/PoolVariableIF.h
+0x0801;DPS_InvalidParameterDefinition;;1;DATA_SET_CLASS;fsfw/src/fsfw/datapool/DataSetIF.h
+0x0802;DPS_SetWasAlreadyRead;;2;DATA_SET_CLASS;fsfw/src/fsfw/datapool/DataSetIF.h
+0x0803;DPS_CommitingWithoutReading;;3;DATA_SET_CLASS;fsfw/src/fsfw/datapool/DataSetIF.h
+0x0804;DPS_DataSetUninitialised;;4;DATA_SET_CLASS;fsfw/src/fsfw/datapool/DataSetIF.h
+0x0805;DPS_DataSetFull;;5;DATA_SET_CLASS;fsfw/src/fsfw/datapool/DataSetIF.h
+0x0806;DPS_PoolVarNull;;6;DATA_SET_CLASS;fsfw/src/fsfw/datapool/DataSetIF.h
+0x1c01;TCD_PacketLost;;1;PACKET_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/TcDistributorBase.h
+0x1c02;TCD_DestinationNotFound;;2;PACKET_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/TcDistributorBase.h
+0x1c03;TCD_ServiceIdAlreadyExists;;3;PACKET_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/TcDistributorBase.h
+0x1b00;TCC_NoDestinationFound;;0;TMTC_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/definitions.h
+0x1b01;TCC_InvalidCcsdsVersion;;1;TMTC_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/definitions.h
+0x1b02;TCC_InvalidApid;;2;TMTC_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/definitions.h
+0x1b03;TCC_InvalidPacketType;;3;TMTC_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/definitions.h
+0x1b04;TCC_InvalidSecHeaderField;;4;TMTC_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/definitions.h
+0x1b05;TCC_IncorrectPrimaryHeader;;5;TMTC_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/definitions.h
+0x1b07;TCC_IncompletePacket;;7;TMTC_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/definitions.h
+0x1b08;TCC_InvalidPusVersion;;8;TMTC_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/definitions.h
+0x1b09;TCC_IncorrectChecksum;;9;TMTC_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/definitions.h
+0x1b0a;TCC_IllegalPacketSubtype;;10;TMTC_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/definitions.h
+0x1b0b;TCC_IncorrectSecondaryHeader;;11;TMTC_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/definitions.h
+0x3001;POS_InPowerTransition;;1;POWER_SWITCHER;fsfw/src/fsfw/power/PowerSwitcher.h
+0x3002;POS_SwitchStateMismatch;;2;POWER_SWITCHER;fsfw/src/fsfw/power/PowerSwitcher.h
+0x0501;PS_SwitchOn;;1;POWER_SWITCH_IF;fsfw/src/fsfw/power/PowerSwitchIF.h
+0x0500;PS_SwitchOff;;0;POWER_SWITCH_IF;fsfw/src/fsfw/power/PowerSwitchIF.h
+0x0502;PS_SwitchTimeout;;2;POWER_SWITCH_IF;fsfw/src/fsfw/power/PowerSwitchIF.h
+0x0503;PS_FuseOn;;3;POWER_SWITCH_IF;fsfw/src/fsfw/power/PowerSwitchIF.h
+0x0504;PS_FuseOff;;4;POWER_SWITCH_IF;fsfw/src/fsfw/power/PowerSwitchIF.h
+0x3b00;SPH_ConnBroken;;0;SEMAPHORE_IF;fsfw/src/fsfw/osal/common/TcpTmTcServer.h
+0x2a01;IEC_NoConfigurationTable;;1;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x2a02;IEC_NoCpuTable;;2;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x2a03;IEC_InvalidWorkspaceAddress;;3;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x2a04;IEC_TooLittleWorkspace;;4;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x2a05;IEC_WorkspaceAllocation;;5;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x2a06;IEC_InterruptStackTooSmall;;6;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x2a07;IEC_ThreadExitted;;7;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x2a08;IEC_InconsistentMpInformation;;8;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x2a09;IEC_InvalidNode;;9;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x2a0a;IEC_NoMpci;;10;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x2a0b;IEC_BadPacket;;11;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x2a0c;IEC_OutOfPackets;;12;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x2a0d;IEC_OutOfGlobalObjects;;13;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x2a0e;IEC_OutOfProxies;;14;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x2a0f;IEC_InvalidGlobalId;;15;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x2a10;IEC_BadStackHook;;16;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x2a11;IEC_BadAttributes;;17;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x2a12;IEC_ImplementationKeyCreateInconsistency;;18;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x2a13;IEC_ImplementationBlockingOperationCancel;;19;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x2a14;IEC_MutexObtainFromBadState;;20;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x2a15;IEC_UnlimitedAndMaximumIs0;;21;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x2600;FDI_YourFault;;0;HANDLES_FAILURES_IF;fsfw/src/fsfw/fdir/ConfirmsFailuresIF.h
+0x2601;FDI_MyFault;;1;HANDLES_FAILURES_IF;fsfw/src/fsfw/fdir/ConfirmsFailuresIF.h
+0x2602;FDI_ConfirmLater;;2;HANDLES_FAILURES_IF;fsfw/src/fsfw/fdir/ConfirmsFailuresIF.h
+0x1e00;PUS_InvalidPusVersion;;0;PUS_IF;fsfw/src/fsfw/tmtcpacket/pus/PusIF.h
+0x1e01;PUS_InvalidCrc16;;1;PUS_IF;fsfw/src/fsfw/tmtcpacket/pus/PusIF.h
+0x0201;OM_InsertionFailed;;1;OBJECT_MANAGER_IF;fsfw/src/fsfw/objectmanager/ObjectManagerIF.h
+0x0202;OM_NotFound;;2;OBJECT_MANAGER_IF;fsfw/src/fsfw/objectmanager/ObjectManagerIF.h
+0x0203;OM_ChildInitFailed;;3;OBJECT_MANAGER_IF;fsfw/src/fsfw/objectmanager/ObjectManagerIF.h
+0x0204;OM_InternalErrReporterUninit;;4;OBJECT_MANAGER_IF;fsfw/src/fsfw/objectmanager/ObjectManagerIF.h
+0x2201;TMF_Busy;;1;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
+0x2202;TMF_LastPacketFound;;2;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
+0x2203;TMF_StopFetch;;3;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
+0x2204;TMF_Timeout;;4;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
+0x2205;TMF_TmChannelFull;;5;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
+0x2206;TMF_NotStored;;6;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
+0x2207;TMF_AllDeleted;;7;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
+0x2208;TMF_InvalidData;;8;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
+0x2209;TMF_NotReady;;9;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
+0x2101;TMB_Busy;;1;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x2102;TMB_Full;;2;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x2103;TMB_Empty;;3;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x2104;TMB_NullRequested;;4;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x2105;TMB_TooLarge;;5;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x2106;TMB_NotReady;;6;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x2107;TMB_DumpError;;7;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x2108;TMB_CrcError;;8;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x2109;TMB_Timeout;;9;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x210a;TMB_IdlePacketFound;;10;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x210b;TMB_TelecommandFound;;11;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x210c;TMB_NoPusATm;;12;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x210d;TMB_TooSmall;;13;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x210e;TMB_BlockNotFound;;14;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x210f;TMB_InvalidRequest;;15;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x2d01;PAW_UnknownDatatype;;1;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
+0x2d02;PAW_DatatypeMissmatch;;2;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
+0x2d03;PAW_Readonly;;3;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
+0x2d04;PAW_TooBig;;4;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
+0x2d05;PAW_SourceNotSet;;5;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
+0x2d06;PAW_OutOfBounds;;6;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
+0x2d07;PAW_NotSet;;7;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
+0x2d08;PAW_ColumnOrRowsZero;;8;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
+0x2e01;HPA_InvalidIdentifierId;;1;HAS_PARAMETERS_IF;fsfw/src/fsfw/parameters/HasParametersIF.h
+0x2e02;HPA_InvalidDomainId;;2;HAS_PARAMETERS_IF;fsfw/src/fsfw/parameters/HasParametersIF.h
+0x2e03;HPA_InvalidValue;;3;HAS_PARAMETERS_IF;fsfw/src/fsfw/parameters/HasParametersIF.h
+0x2e05;HPA_ReadOnly;;5;HAS_PARAMETERS_IF;fsfw/src/fsfw/parameters/HasParametersIF.h
+0x3b01;SPH_SemaphoreTimeout;;1;SEMAPHORE_IF;fsfw/src/fsfw/tasks/SemaphoreIF.h
+0x3b02;SPH_SemaphoreNotOwned;;2;SEMAPHORE_IF;fsfw/src/fsfw/tasks/SemaphoreIF.h
+0x3b03;SPH_SemaphoreInvalid;;3;SEMAPHORE_IF;fsfw/src/fsfw/tasks/SemaphoreIF.h
+0x1a01;TRC_NotEnoughSensors;;1;TRIPLE_REDUNDACY_CHECK;fsfw/src/fsfw/monitoring/TriplexMonitor.h
+0x1a02;TRC_LowestValueOol;;2;TRIPLE_REDUNDACY_CHECK;fsfw/src/fsfw/monitoring/TriplexMonitor.h
+0x1a03;TRC_HighestValueOol;;3;TRIPLE_REDUNDACY_CHECK;fsfw/src/fsfw/monitoring/TriplexMonitor.h
+0x1a04;TRC_BothValuesOol;;4;TRIPLE_REDUNDACY_CHECK;fsfw/src/fsfw/monitoring/TriplexMonitor.h
+0x1a05;TRC_DuplexOol;;5;TRIPLE_REDUNDACY_CHECK;fsfw/src/fsfw/monitoring/TriplexMonitor.h
+0x3101;LIM_Unchecked;;1;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
+0x3102;LIM_Invalid;;2;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
+0x3103;LIM_Unselected;;3;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
+0x3104;LIM_BelowLowLimit;;4;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
+0x3105;LIM_AboveHighLimit;;5;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
+0x3106;LIM_UnexpectedValue;;6;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
+0x3107;LIM_OutOfRange;;7;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
+0x31a0;LIM_FirstSample;;160;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
+0x31e0;LIM_InvalidSize;;224;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
+0x31e1;LIM_WrongType;;225;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
+0x31e2;LIM_WrongPid;;226;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
+0x31e3;LIM_WrongLimitId;;227;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
+0x31ee;LIM_MonitorNotFound;;238;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
+0x3601;CFDP_InvalidTlvType;;1;CFDP;fsfw/src/fsfw/cfdp/definitions.h
+0x3602;CFDP_InvalidDirectiveField;;2;CFDP;fsfw/src/fsfw/cfdp/definitions.h
+0x3603;CFDP_InvalidPduDatafieldLen;;3;CFDP;fsfw/src/fsfw/cfdp/definitions.h
+0x3604;CFDP_InvalidAckDirectiveFields;;4;CFDP;fsfw/src/fsfw/cfdp/definitions.h
+0x3605;CFDP_MetadataCantParseOptions;;5;CFDP;fsfw/src/fsfw/cfdp/definitions.h
+0x3606;CFDP_NakCantParseOptions;;6;CFDP;fsfw/src/fsfw/cfdp/definitions.h
+0x3607;CFDP_FinishedCantParseFsResponses;;7;CFDP;fsfw/src/fsfw/cfdp/definitions.h
+0x3608;CFDP_FilestoreRequiresSecondFile;;8;CFDP;fsfw/src/fsfw/cfdp/definitions.h
+0x3609;CFDP_FilestoreResponseCantParseFsMessage;;9;CFDP;fsfw/src/fsfw/cfdp/definitions.h
+0x360a;CFDP_InvalidPduFormat;;10;CFDP;fsfw/src/fsfw/cfdp/definitions.h
+0x4300;FILS_GenericFileError;;0;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4301;FILS_GenericDirError;;1;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4302;FILS_FilesystemInactive;;2;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4303;FILS_GenericRenameError;;3;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4304;FILS_IsBusy;;4;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4305;FILS_InvalidParameters;;5;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x430a;FILS_FileDoesNotExist;;10;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x430b;FILS_FileAlreadyExists;;11;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x430c;FILS_NotAFile;;12;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x430d;FILS_FileLocked;;13;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x430e;FILS_PermissionDenied;;14;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4315;FILS_DirectoryDoesNotExist;;21;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4316;FILS_DirectoryAlreadyExists;;22;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4317;FILS_NotADirectory;;23;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4318;FILS_DirectoryNotEmpty;;24;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x431e;FILS_SequencePacketMissingWrite;;30;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x431f;FILS_SequencePacketMissingRead;;31;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
 0x2c01;CCS_BcIsSetVrCommand;;1;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
 0x2c02;CCS_BcIsUnlockCommand;;2;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
 0x2cb0;CCS_BcIllegalCommand;;176;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
@@ -286,99 +369,18 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x2cd1;CCS_ShorterThanHeader;;209;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
 0x2cd2;CCS_TooShortBlockedPacket;;210;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
 0x2cd3;CCS_TooShortMapExtraction;;211;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x38a1;SGP4_InvalidEccentricity;;161;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x38a2;SGP4_InvalidMeanMotion;;162;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x38a3;SGP4_InvalidPerturbationElements;;163;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x38a4;SGP4_InvalidSemiLatusRectum;;164;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x38a5;SGP4_InvalidEpochElements;;165;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x38a6;SGP4_SatelliteHasDecayed;;166;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x38b1;SGP4_TleTooOld;;177;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x38b2;SGP4_TleNotInitialized;;178;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x4300;FILS_GenericFileError;;0;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4301;FILS_GenericDirError;;1;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4302;FILS_FilesystemInactive;;2;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4303;FILS_GenericRenameError;;3;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4304;FILS_IsBusy;;4;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4305;FILS_InvalidParameters;;5;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x430a;FILS_FileDoesNotExist;;10;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x430b;FILS_FileAlreadyExists;;11;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x430c;FILS_NotAFile;;12;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x430d;FILS_FileLocked;;13;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x430e;FILS_PermissionDenied;;14;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4315;FILS_DirectoryDoesNotExist;;21;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4316;FILS_DirectoryAlreadyExists;;22;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4317;FILS_NotADirectory;;23;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4318;FILS_DirectoryNotEmpty;;24;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x431e;FILS_SequencePacketMissingWrite;;30;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x431f;FILS_SequencePacketMissingRead;;31;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x13e0;MH_UnknownCmd;;224;MEMORY_HELPER;fsfw/src/fsfw/memory/MemoryHelper.h
-0x13e1;MH_InvalidAddress;;225;MEMORY_HELPER;fsfw/src/fsfw/memory/MemoryHelper.h
-0x13e2;MH_InvalidSize;;226;MEMORY_HELPER;fsfw/src/fsfw/memory/MemoryHelper.h
-0x13e3;MH_StateMismatch;;227;MEMORY_HELPER;fsfw/src/fsfw/memory/MemoryHelper.h
-0x0601;PP_DoItMyself;;1;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
-0x0602;PP_PointsToVariable;;2;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
-0x0603;PP_PointsToMemory;;3;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
-0x0604;PP_ActivityCompleted;;4;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
-0x0605;PP_PointsToVectorUint8;;5;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
-0x0606;PP_PointsToVectorUint16;;6;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
-0x0607;PP_PointsToVectorUint32;;7;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
-0x0608;PP_PointsToVectorFloat;;8;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
-0x06a0;PP_DumpNotSupported;;160;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
-0x06e0;PP_InvalidSize;;224;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
-0x06e1;PP_InvalidAddress;;225;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
-0x06e2;PP_InvalidContent;;226;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
-0x06e3;PP_UnalignedAccess;;227;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
-0x06e4;PP_WriteProtected;;228;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
-0x0201;OM_InsertionFailed;;1;OBJECT_MANAGER_IF;fsfw/src/fsfw/objectmanager/ObjectManagerIF.h
-0x0202;OM_NotFound;;2;OBJECT_MANAGER_IF;fsfw/src/fsfw/objectmanager/ObjectManagerIF.h
-0x0203;OM_ChildInitFailed;;3;OBJECT_MANAGER_IF;fsfw/src/fsfw/objectmanager/ObjectManagerIF.h
-0x0204;OM_InternalErrReporterUninit;;4;OBJECT_MANAGER_IF;fsfw/src/fsfw/objectmanager/ObjectManagerIF.h
-0x0501;PS_SwitchOn;;1;POWER_SWITCH_IF;fsfw/src/fsfw/power/PowerSwitchIF.h
-0x0500;PS_SwitchOff;;0;POWER_SWITCH_IF;fsfw/src/fsfw/power/PowerSwitchIF.h
-0x0502;PS_SwitchTimeout;;2;POWER_SWITCH_IF;fsfw/src/fsfw/power/PowerSwitchIF.h
-0x0503;PS_FuseOn;;3;POWER_SWITCH_IF;fsfw/src/fsfw/power/PowerSwitchIF.h
-0x0504;PS_FuseOff;;4;POWER_SWITCH_IF;fsfw/src/fsfw/power/PowerSwitchIF.h
-0x3001;POS_InPowerTransition;;1;POWER_SWITCHER;fsfw/src/fsfw/power/PowerSwitcher.h
-0x3002;POS_SwitchStateMismatch;;2;POWER_SWITCHER;fsfw/src/fsfw/power/PowerSwitcher.h
-0x1000;TIM_UnsupportedTimeFormat;;0;CCSDS_TIME_HELPER_CLASS;fsfw/src/fsfw/timemanager/CCSDSTime.h
-0x1001;TIM_NotEnoughInformationForTargetFormat;;1;CCSDS_TIME_HELPER_CLASS;fsfw/src/fsfw/timemanager/CCSDSTime.h
-0x1002;TIM_LengthMismatch;;2;CCSDS_TIME_HELPER_CLASS;fsfw/src/fsfw/timemanager/CCSDSTime.h
-0x1003;TIM_InvalidTimeFormat;;3;CCSDS_TIME_HELPER_CLASS;fsfw/src/fsfw/timemanager/CCSDSTime.h
-0x1004;TIM_InvalidDayOfYear;;4;CCSDS_TIME_HELPER_CLASS;fsfw/src/fsfw/timemanager/CCSDSTime.h
-0x1005;TIM_TimeDoesNotFitFormat;;5;CCSDS_TIME_HELPER_CLASS;fsfw/src/fsfw/timemanager/CCSDSTime.h
-0x3701;TSI_BadTimestamp;;1;TIME_STAMPER_IF;fsfw/src/fsfw/timemanager/TimeStampIF.h
-0x2201;TMF_Busy;;1;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
-0x2202;TMF_LastPacketFound;;2;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
-0x2203;TMF_StopFetch;;3;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
-0x2204;TMF_Timeout;;4;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
-0x2205;TMF_TmChannelFull;;5;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
-0x2206;TMF_NotStored;;6;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
-0x2207;TMF_AllDeleted;;7;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
-0x2208;TMF_InvalidData;;8;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
-0x2209;TMF_NotReady;;9;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
-0x2101;TMB_Busy;;1;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x2102;TMB_Full;;2;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x2103;TMB_Empty;;3;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x2104;TMB_NullRequested;;4;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x2105;TMB_TooLarge;;5;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x2106;TMB_NotReady;;6;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x2107;TMB_DumpError;;7;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x2108;TMB_CrcError;;8;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x2109;TMB_Timeout;;9;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x210a;TMB_IdlePacketFound;;10;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x210b;TMB_TelecommandFound;;11;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x210c;TMB_NoPusATm;;12;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x210d;TMB_TooSmall;;13;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x210e;TMB_BlockNotFound;;14;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x210f;TMB_InvalidRequest;;15;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x0e01;HM_InvalidMode;;1;HAS_MODES_IF;fsfw/src/fsfw/modes/HasModesIF.h
-0x0e02;HM_TransNotAllowed;;2;HAS_MODES_IF;fsfw/src/fsfw/modes/HasModesIF.h
-0x0e03;HM_InTransition;;3;HAS_MODES_IF;fsfw/src/fsfw/modes/HasModesIF.h
-0x0e04;HM_InvalidSubmode;;4;HAS_MODES_IF;fsfw/src/fsfw/modes/HasModesIF.h
-0x1601;FMM_MapFull;;1;FIXED_MULTIMAP;fsfw/src/fsfw/container/FixedOrderedMultimap.h
-0x1602;FMM_KeyDoesNotExist;;2;FIXED_MULTIMAP;fsfw/src/fsfw/container/FixedOrderedMultimap.h
-0x1801;FF_Full;;1;FIFO_CLASS;fsfw/src/fsfw/container/FIFOBase.h
-0x1802;FF_Empty;;2;FIFO_CLASS;fsfw/src/fsfw/container/FIFOBase.h
+0x4201;PUS11_InvalidTypeTimeWindow;;1;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
+0x4202;PUS11_InvalidTimeWindow;;2;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
+0x4203;PUS11_TimeshiftingNotPossible;;3;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
+0x4204;PUS11_InvalidRelativeTime;;4;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
+0x4205;PUS11_ContainedTcTooSmall;;5;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
+0x4206;PUS11_ContainedTcCrcMissmatch;;6;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
+0x3401;DC_NoReplyReceived;;1;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
+0x3402;DC_ProtocolError;;2;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
+0x3403;DC_Nullpointer;;3;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
+0x3404;DC_InvalidCookieType;;4;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
+0x3405;DC_NotActive;;5;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
+0x3406;DC_TooMuchData;;6;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
 0x03a0;DHB_InvalidChannel;;160;DEVICE_HANDLER_BASE;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h
 0x03b0;DHB_AperiodicReply;;176;DEVICE_HANDLER_BASE;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h
 0x03b1;DHB_IgnoreReplyData;;177;DEVICE_HANDLER_BASE;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h
@@ -415,53 +417,60 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x27c3;DHI_DeviceReplyInvalid;;195;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
 0x27d0;DHI_InvalidCommandParameter;;208;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
 0x27d1;DHI_InvalidNumberOrLengthOfParameters;;209;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
-0x3401;DC_NoReplyReceived;;1;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
-0x3402;DC_ProtocolError;;2;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
-0x3403;DC_Nullpointer;;3;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
-0x3404;DC_InvalidCookieType;;4;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
-0x3405;DC_NotActive;;5;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
-0x3406;DC_TooMuchData;;6;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
-0x2501;EV_ListenerNotFound;;1;EVENT_MANAGER_IF;fsfw/src/fsfw/events/EventManagerIF.h
-0x1a01;TRC_NotEnoughSensors;;1;TRIPLE_REDUNDACY_CHECK;fsfw/src/fsfw/monitoring/TriplexMonitor.h
-0x1a02;TRC_LowestValueOol;;2;TRIPLE_REDUNDACY_CHECK;fsfw/src/fsfw/monitoring/TriplexMonitor.h
-0x1a03;TRC_HighestValueOol;;3;TRIPLE_REDUNDACY_CHECK;fsfw/src/fsfw/monitoring/TriplexMonitor.h
-0x1a04;TRC_BothValuesOol;;4;TRIPLE_REDUNDACY_CHECK;fsfw/src/fsfw/monitoring/TriplexMonitor.h
-0x1a05;TRC_DuplexOol;;5;TRIPLE_REDUNDACY_CHECK;fsfw/src/fsfw/monitoring/TriplexMonitor.h
-0x3101;LIM_Unchecked;;1;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
-0x3102;LIM_Invalid;;2;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
-0x3103;LIM_Unselected;;3;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
-0x3104;LIM_BelowLowLimit;;4;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
-0x3105;LIM_AboveHighLimit;;5;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
-0x3106;LIM_UnexpectedValue;;6;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
-0x3107;LIM_OutOfRange;;7;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
-0x31a0;LIM_FirstSample;;160;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
-0x31e0;LIM_InvalidSize;;224;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
-0x31e1;LIM_WrongType;;225;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
-0x31e2;LIM_WrongPid;;226;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
-0x31e3;LIM_WrongLimitId;;227;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
-0x31ee;LIM_MonitorNotFound;;238;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
-0x3b01;SPH_SemaphoreTimeout;;1;SEMAPHORE_IF;fsfw/src/fsfw/tasks/SemaphoreIF.h
-0x3b02;SPH_SemaphoreNotOwned;;2;SEMAPHORE_IF;fsfw/src/fsfw/tasks/SemaphoreIF.h
-0x3b03;SPH_SemaphoreInvalid;;3;SEMAPHORE_IF;fsfw/src/fsfw/tasks/SemaphoreIF.h
-0x4500;HSPI_OpeningFileFailed;;0;HAL_SPI;fsfw/src/fsfw_hal/linux/spi/SpiComIF.h
-0x4501;HSPI_FullDuplexTransferFailed;;1;HAL_SPI;fsfw/src/fsfw_hal/linux/spi/SpiComIF.h
-0x4502;HSPI_HalfDuplexTransferFailed;;2;HAL_SPI;fsfw/src/fsfw_hal/linux/spi/SpiComIF.h
-0x4601;HURT_UartReadFailure;;1;HAL_UART;fsfw/src/fsfw_hal/linux/serial/SerialComIF.h
-0x4602;HURT_UartReadSizeMissmatch;;2;HAL_UART;fsfw/src/fsfw_hal/linux/serial/SerialComIF.h
-0x4603;HURT_UartRxBufferTooSmall;;3;HAL_UART;fsfw/src/fsfw_hal/linux/serial/SerialComIF.h
-0x4801;HGIO_UnknownGpioId;;1;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x4802;HGIO_DriveGpioFailure;;2;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x4803;HGIO_GpioTypeFailure;;3;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x4804;HGIO_GpioInvalidInstance;;4;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x4805;HGIO_GpioDuplicateDetected;;5;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x4806;HGIO_GpioInitFailed;;6;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x4807;HGIO_GpioGetValueFailed;;7;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x4400;UXOS_ExecutionFinished;Execution of the current command has finished;0;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
-0x4401;UXOS_CommandPending;Command is pending. This will also be returned if the user tries to load another command but a command is still pending;1;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
-0x4402;UXOS_BytesRead;Some bytes have been read from the executing process;2;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
-0x4403;UXOS_CommandError;Command execution failed;3;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
-0x4404;UXOS_NoCommandLoadedOrPending;;4;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
-0x4406;UXOS_PcloseCallError;;6;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
+0x2401;MT_TooDetailedRequest;;1;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h
+0x2402;MT_TooGeneralRequest;;2;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h
+0x2403;MT_NoMatch;;3;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h
+0x2404;MT_Full;;4;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h
+0x2405;MT_NewNodeCreated;;5;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h
+0x3f01;DLEE_NoPacketFound;;1;DLE_ENCODER;fsfw/src/fsfw/globalfunctions/DleParser.h
+0x3f02;DLEE_PossiblePacketLoss;;2;DLE_ENCODER;fsfw/src/fsfw/globalfunctions/DleParser.h
+0x2f01;ASC_TooLongForTargetType;;1;ASCII_CONVERTER;fsfw/src/fsfw/globalfunctions/AsciiConverter.h
+0x2f02;ASC_InvalidCharacters;;2;ASCII_CONVERTER;fsfw/src/fsfw/globalfunctions/AsciiConverter.h
+0x2f03;ASC_BufferTooSmall;;3;ASCII_CONVERTER;fsfw/src/fsfw/globalfunctions/AsciiConverter.h
+0x1701;HHI_ObjectNotHealthy;;1;HAS_HEALTH_IF;fsfw/src/fsfw/health/HasHealthIF.h
+0x1702;HHI_InvalidHealthState;;2;HAS_HEALTH_IF;fsfw/src/fsfw/health/HasHealthIF.h
+0x1703;HHI_IsExternallyControlled;;3;HAS_HEALTH_IF;fsfw/src/fsfw/health/HasHealthIF.h
+0x3201;CF_ObjectHasNoFunctions;;1;COMMANDS_ACTIONS_IF;fsfw/src/fsfw/action/CommandsActionsIF.h
+0x3202;CF_AlreadyCommanding;;2;COMMANDS_ACTIONS_IF;fsfw/src/fsfw/action/CommandsActionsIF.h
+0x3301;HF_IsBusy;;1;HAS_ACTIONS_IF;fsfw/src/fsfw/action/HasActionsIF.h
+0x3302;HF_InvalidParameters;;2;HAS_ACTIONS_IF;fsfw/src/fsfw/action/HasActionsIF.h
+0x3303;HF_ExecutionFinished;;3;HAS_ACTIONS_IF;fsfw/src/fsfw/action/HasActionsIF.h
+0x3304;HF_InvalidActionId;;4;HAS_ACTIONS_IF;fsfw/src/fsfw/action/HasActionsIF.h
+0x1000;TIM_UnsupportedTimeFormat;;0;CCSDS_TIME_HELPER_CLASS;fsfw/src/fsfw/timemanager/CCSDSTime.h
+0x1001;TIM_NotEnoughInformationForTargetFormat;;1;CCSDS_TIME_HELPER_CLASS;fsfw/src/fsfw/timemanager/CCSDSTime.h
+0x1002;TIM_LengthMismatch;;2;CCSDS_TIME_HELPER_CLASS;fsfw/src/fsfw/timemanager/CCSDSTime.h
+0x1003;TIM_InvalidTimeFormat;;3;CCSDS_TIME_HELPER_CLASS;fsfw/src/fsfw/timemanager/CCSDSTime.h
+0x1004;TIM_InvalidDayOfYear;;4;CCSDS_TIME_HELPER_CLASS;fsfw/src/fsfw/timemanager/CCSDSTime.h
+0x1005;TIM_TimeDoesNotFitFormat;;5;CCSDS_TIME_HELPER_CLASS;fsfw/src/fsfw/timemanager/CCSDSTime.h
+0x3701;TSI_BadTimestamp;;1;TIME_STAMPER_IF;fsfw/src/fsfw/timemanager/TimeStampIF.h
+0x3c00;LPIF_PoolEntryNotFound;;0;LOCAL_POOL_OWNER_IF;fsfw/src/fsfw/datapoollocal/localPoolDefinitions.h
+0x3c01;LPIF_PoolEntryTypeConflict;;1;LOCAL_POOL_OWNER_IF;fsfw/src/fsfw/datapoollocal/localPoolDefinitions.h
+0x3e00;HKM_QueueOrDestinationInvalid;;0;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
+0x3e01;HKM_WrongHkPacketType;;1;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
+0x3e02;HKM_ReportingStatusUnchanged;;2;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
+0x3e03;HKM_PeriodicHelperInvalid;;3;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
+0x3e04;HKM_PoolobjectNotFound;;4;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
+0x3e05;HKM_DatasetNotFound;;5;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
+0x2901;TC_InvalidTargetState;;1;THERMAL_COMPONENT_IF;fsfw/src/fsfw/thermal/ThermalComponentIF.h
+0x29f1;TC_AboveOperationalLimit;;241;THERMAL_COMPONENT_IF;fsfw/src/fsfw/thermal/ThermalComponentIF.h
+0x29f2;TC_BelowOperationalLimit;;242;THERMAL_COMPONENT_IF;fsfw/src/fsfw/thermal/ThermalComponentIF.h
+0x2001;CSB_ExecutionComplete;;1;COMMAND_SERVICE_BASE;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h
+0x2002;CSB_NoStepMessage;;2;COMMAND_SERVICE_BASE;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h
+0x2003;CSB_ObjectBusy;;3;COMMAND_SERVICE_BASE;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h
+0x2004;CSB_Busy;;4;COMMAND_SERVICE_BASE;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h
+0x2005;CSB_InvalidTc;;5;COMMAND_SERVICE_BASE;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h
+0x2006;CSB_InvalidObject;;6;COMMAND_SERVICE_BASE;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h
+0x2007;CSB_InvalidReply;;7;COMMAND_SERVICE_BASE;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h
+0x4c00;SPPA_NoPacketFound;;0;SPACE_PACKET_PARSER;fsfw/src/fsfw/tmtcservices/SpacePacketParser.h
+0x4c01;SPPA_SplitPacket;;1;SPACE_PACKET_PARSER;fsfw/src/fsfw/tmtcservices/SpacePacketParser.h
+0x1d01;ATC_ActivityStarted;;1;ACCEPTS_TELECOMMANDS_IF;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h
+0x1d02;ATC_InvalidSubservice;;2;ACCEPTS_TELECOMMANDS_IF;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h
+0x1d03;ATC_IllegalApplicationData;;3;ACCEPTS_TELECOMMANDS_IF;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h
+0x1d04;ATC_SendTmFailed;;4;ACCEPTS_TELECOMMANDS_IF;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h
+0x1d05;ATC_Timeout;;5;ACCEPTS_TELECOMMANDS_IF;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h
+0x6b00;SCBU_KeyNotFound;;0;SCRATCH_BUFFER;bsp_q7s/memory/scratchApi.h
+0x64a0;FSHLP_SdNotMounted;SD card specified with path string not mounted;160;FILE_SYSTEM_HELPER;bsp_q7s/fs/FilesystemHelper.h
+0x64a1;FSHLP_FileNotExists;Specified file does not exist on filesystem;161;FILE_SYSTEM_HELPER;bsp_q7s/fs/FilesystemHelper.h
 0x6a00;SDMA_OpOngoing;;0;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
 0x6a01;SDMA_AlreadyOn;;1;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
 0x6a02;SDMA_AlreadyMounted;;2;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
@@ -472,6 +481,3 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x6a0d;SDMA_UnmountError;;13;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
 0x6a0e;SDMA_SystemCallError;;14;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
 0x6a0f;SDMA_PopenCallError;;15;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
-0x64a0;FSHLP_SdNotMounted;SD card specified with path string not mounted;160;FILE_SYSTEM_HELPER;bsp_q7s/fs/FilesystemHelper.h
-0x64a1;FSHLP_FileNotExists;Specified file does not exist on filesystem;161;FILE_SYSTEM_HELPER;bsp_q7s/fs/FilesystemHelper.h
-0x6b00;SCBU_KeyNotFound;;0;SCRATCH_BUFFER;bsp_q7s/memory/scratchApi.h

generators/events/translateEvents.cpp

@@ -1,7 +1,7 @@
 /**
- * @brief    Auto-generated event translation file. Contains 239 translations.
+ * @brief    Auto-generated event translation file. Contains 245 translations.
  * @details
- * Generated on: 2022-12-01 17:07:27
+ * Generated on: 2023-02-03 10:52:53
  */
 #include "translateEvents.h"
 
@@ -82,6 +82,7 @@ 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";
@@ -89,6 +90,8 @@ 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 *SAFE_RATE_VIOLATION_STRING = "SAFE_RATE_VIOLATION";
+const char *SAFE_RATE_RECOVERY_STRING = "SAFE_RATE_RECOVERY";
 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";
@@ -227,11 +230,8 @@ 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 *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 *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";
@@ -240,6 +240,11 @@ 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 *translateEvents(Event event) {
   switch ((event & 0xFFFF)) {
@@ -398,6 +403,8 @@ 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;
@@ -411,6 +418,10 @@ const char *translateEvents(Event event) {
       return MSG_QUEUE_ERROR_STRING;
     case (10802):
       return SERIALIZATION_ERROR_STRING;
+    case (11200):
+      return SAFE_RATE_VIOLATION_STRING;
+    case (11201):
+      return SAFE_RATE_RECOVERY_STRING;
     case (11300):
       return SWITCH_CMD_SENT_STRING;
     case (11301):
@@ -687,16 +698,10 @@ const char *translateEvents(Event event) {
       return HDLC_FRAME_REMOVAL_ERROR_STRING;
     case (13632):
       return HDLC_CRC_ERROR_STRING;
-    case (13700):
-      return ALLOC_FAILURE_STRING;
     case (13701):
-      return REBOOT_SW_STRING;
+      return TX_ON_STRING;
     case (13702):
-      return REBOOT_MECHANISM_TRIGGERED_STRING;
-    case (13703):
-      return REBOOT_HW_STRING;
-    case (13704):
-      return NO_SD_CARD_ACTIVE_STRING;
+      return TX_OFF_STRING;
     case (13800):
       return MISSING_PACKET_STRING;
     case (13801):
@@ -713,6 +718,16 @@ const char *translateEvents(Event event) {
       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;
     default:
       return "UNKNOWN_EVENT";
   }

generators/objects/translateObjects.cpp

@@ -1,8 +1,8 @@
 /**
  * @brief  Auto-generated object translation file.
  * @details
- * Contains 148 translations.
- * Generated on: 2022-12-01 17:07:27
+ * Contains 152 translations.
+ * Generated on: 2023-02-03 10:52:53
  */
 #include "translateObjects.h"
 
@@ -80,7 +80,7 @@ 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_HK_HANDLER_STRING = "SYRLINKS_HK_HANDLER";
+const char *SYRLINKS_HANDLER_STRING = "SYRLINKS_HANDLER";
 const char *ARDUINO_COM_IF_STRING = "ARDUINO_COM_IF";
 const char *GPIO_IF_STRING = "GPIO_IF";
 const char *SCEX_UART_READER_STRING = "SCEX_UART_READER";
@@ -92,8 +92,10 @@ const char *I2C_COM_IF_STRING = "I2C_COM_IF";
 const char *CSP_COM_IF_STRING = "CSP_COM_IF";
 const char *CCSDS_PACKET_DISTRIBUTOR_STRING = "CCSDS_PACKET_DISTRIBUTOR";
 const char *PUS_PACKET_DISTRIBUTOR_STRING = "PUS_PACKET_DISTRIBUTOR";
-const char *TMTC_BRIDGE_STRING = "TMTC_BRIDGE";
-const char *TMTC_POLLING_TASK_STRING = "TMTC_POLLING_TASK";
+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";
@@ -152,6 +154,8 @@ 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 *CCSDS_IP_CORE_BRIDGE_STRING = "CCSDS_IP_CORE_BRIDGE";
 const char *NO_OBJECT_STRING = "NO_OBJECT";
 
@@ -306,7 +310,7 @@ const char *translateObject(object_id_t object) {
     case 0x44420031:
       return RTD_15_IC18_IMTQ_STRING;
     case 0x445300A3:
-      return SYRLINKS_HK_HANDLER_STRING;
+      return SYRLINKS_HANDLER_STRING;
     case 0x49000000:
       return ARDUINO_COM_IF_STRING;
     case 0x49010005:
@@ -330,9 +334,13 @@ const char *translateObject(object_id_t object) {
     case 0x50000200:
       return PUS_PACKET_DISTRIBUTOR_STRING;
     case 0x50000300:
-      return TMTC_BRIDGE_STRING;
+      return TCP_TMTC_SERVER_STRING;
+    case 0x50000301:
+      return UDP_TMTC_SERVER_STRING;
     case 0x50000400:
-      return TMTC_POLLING_TASK_STRING;
+      return TCP_TMTC_POLLING_TASK_STRING;
+    case 0x50000401:
+      return UDP_TMTC_POLLING_TASK_STRING;
     case 0x50000500:
       return FILE_SYSTEM_HANDLER_STRING;
     case 0x50000550:
@@ -449,6 +457,10 @@ const char *translateObject(object_id_t object) {
       return ACS_SUBSYSTEM_STRING;
     case 0x73010002:
       return PL_SUBSYSTEM_STRING;
+    case 0x73010003:
+      return TCS_SUBSYSTEM_STRING;
+    case 0x73010004:
+      return COM_SUBSYSTEM_STRING;
     case 0x73500000:
       return CCSDS_IP_CORE_BRIDGE_STRING;
     case 0xFFFFFFFF:

linux/ObjectFactory.cpp

@@ -28,9 +28,11 @@
 #include "mission/system/objects/TcsBoardAssembly.h"
 #include "mission/system/tree/acsModeTree.h"
 #include "mission/system/tree/payloadModeTree.h"
+#include "mission/system/tree/tcsModeTree.h"
 
 void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiComIF,
-                                              PowerSwitchIF* pwrSwitcher, std::string spiDev) {
+                                              PowerSwitchIF* pwrSwitcher, std::string spiDev,
+                                              bool swap0And6) {
   using namespace gpio;
   GpioCookie* gpioCookieSus = new GpioCookie();
   GpioCallback* susgpio = nullptr;
@@ -292,7 +294,7 @@ void ObjectFactory::createRtdComponents(std::string spiDev, GpioIF* gpioComIF,
   TcsBoardHelper helper(rtdInfos);
   TcsBoardAssembly* tcsBoardAss = new TcsBoardAssembly(
       objects::TCS_BOARD_ASS, pwrSwitcher, pcdu::Switches::PDU1_CH0_TCS_BOARD_3V3, helper);
-  static_cast<void>(tcsBoardAss);
+  tcsBoardAss->connectModeTreeParent(satsystem::tcs::SUBSYSTEM);
   // Create special low level reader communication interface
   new Max31865RtdReader(objects::SPI_RTD_COM_IF, comIF, gpioComIF);
   for (uint8_t idx = 0; idx < NUM_RTDS; idx++) {
@@ -341,7 +343,8 @@ void ObjectFactory::createScexComponents(std::string uartDev, PowerSwitchIF* pwr
 }
 
 void ObjectFactory::createThermalController() {
-  new ThermalController(objects::THERMAL_CONTROLLER);
+  auto* tcsCtrl = new ThermalController(objects::THERMAL_CONTROLLER);
+  tcsCtrl->connectModeTreeParent(satsystem::tcs::SUBSYSTEM);
 }
 
 AcsController* ObjectFactory::createAcsController(bool connectSubsystem) {

linux/ObjectFactory.h

@@ -19,7 +19,7 @@ class AcsController;
 namespace ObjectFactory {
 
 void createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiComIF, PowerSwitchIF* pwrSwitcher,
-                               std::string spiDev);
+                               std::string spiDev, bool swap0And6);
 void createRtdComponents(std::string spiDev, GpioIF* gpioComIF, PowerSwitchIF* pwrSwitcher,
                          SpiComIF* comIF);
 

linux/devices/CMakeLists.txt

@@ -1,5 +1,5 @@
 if(EIVE_BUILD_GPSD_GPS_HANDLER)
-  target_sources(${OBSW_NAME} PRIVATE GPSHyperionLinuxController.cpp)
+  target_sources(${OBSW_NAME} PRIVATE GpsHyperionLinuxController.cpp)
 endif()
 
 target_sources(

linux/devices/GpsHyperionLinuxController.cpp

@@ -1,5 +1,6 @@
-#include "GPSHyperionLinuxController.h"
+#include "GpsHyperionLinuxController.h"
 
+#include <fsfw/tasks/TaskFactory.h>
 #include <fsfw/timemanager/Stopwatch.h>
 
 #include "OBSWConfig.h"
@@ -16,26 +17,20 @@
 #include <cmath>
 #include <ctime>
 
-GPSHyperionLinuxController::GPSHyperionLinuxController(object_id_t objectId, object_id_t parentId,
+GpsHyperionLinuxController::GpsHyperionLinuxController(object_id_t objectId, object_id_t parentId,
                                                        bool debugHyperionGps)
     : ExtendedControllerBase(objectId), gpsSet(this), debugHyperionGps(debugHyperionGps) {
   timeUpdateCd.resetTimer();
 }
 
-GPSHyperionLinuxController::~GPSHyperionLinuxController() {
+GpsHyperionLinuxController::~GpsHyperionLinuxController() {
   gps_stream(&gps, WATCH_DISABLE, nullptr);
   gps_close(&gps);
 }
 
-void GPSHyperionLinuxController::performControlOperation() {
-#ifdef FSFW_OSAL_LINUX
-  readGpsDataFromGpsd();
-#endif
-}
+LocalPoolDataSetBase *GpsHyperionLinuxController::getDataSetHandle(sid_t sid) { return &gpsSet; }
 
-LocalPoolDataSetBase *GPSHyperionLinuxController::getDataSetHandle(sid_t sid) { return &gpsSet; }
-
-ReturnValue_t GPSHyperionLinuxController::checkModeCommand(Mode_t mode, Submode_t submode,
+ReturnValue_t GpsHyperionLinuxController::checkModeCommand(Mode_t mode, Submode_t submode,
                                                            uint32_t *msToReachTheMode) {
   if (not modeCommanded) {
     if (mode == MODE_ON or mode == MODE_OFF) {
@@ -48,10 +43,13 @@ ReturnValue_t GPSHyperionLinuxController::checkModeCommand(Mode_t mode, Submode_
       return HasModesIF::INVALID_MODE;
     }
   }
+  if (mode == MODE_OFF) {
+    gpsSet.setValidity(false, true);
+  }
   return returnvalue::OK;
 }
 
-ReturnValue_t GPSHyperionLinuxController::executeAction(ActionId_t actionId,
+ReturnValue_t GpsHyperionLinuxController::executeAction(ActionId_t actionId,
                                                         MessageQueueId_t commandedBy,
                                                         const uint8_t *data, size_t size) {
   switch (actionId) {
@@ -69,7 +67,7 @@ ReturnValue_t GPSHyperionLinuxController::executeAction(ActionId_t actionId,
   return returnvalue::OK;
 }
 
-ReturnValue_t GPSHyperionLinuxController::initializeLocalDataPool(
+ReturnValue_t GpsHyperionLinuxController::initializeLocalDataPool(
     localpool::DataPool &localDataPoolMap, LocalDataPoolManager &poolManager) {
   localDataPoolMap.emplace(GpsHyperion::ALTITUDE, new PoolEntry<double>({0.0}));
   localDataPoolMap.emplace(GpsHyperion::LONGITUDE, new PoolEntry<double>({0.0}));
@@ -89,13 +87,27 @@ ReturnValue_t GPSHyperionLinuxController::initializeLocalDataPool(
   return returnvalue::OK;
 }
 
-void GPSHyperionLinuxController::setResetPinTriggerFunction(gpioResetFunction_t resetCallback,
+void GpsHyperionLinuxController::setResetPinTriggerFunction(gpioResetFunction_t resetCallback,
                                                             void *args) {
   this->resetCallback = resetCallback;
   resetCallbackArgs = args;
 }
 
-ReturnValue_t GPSHyperionLinuxController::initialize() {
+ReturnValue_t GpsHyperionLinuxController::performOperation(uint8_t opCode) {
+  handleQueue();
+  poolManager.performHkOperation();
+  while (true) {
+    bool callAgainImmediately = readGpsDataFromGpsd();
+    if (not callAgainImmediately) {
+      handleQueue();
+      poolManager.performHkOperation();
+    }
+  }
+  // Should never be reached.
+  return returnvalue::OK;
+}
+
+ReturnValue_t GpsHyperionLinuxController::initialize() {
   ReturnValue_t result = ExtendedControllerBase::initialize();
   if (result != returnvalue::OK) {
     return result;
@@ -115,6 +127,7 @@ ReturnValue_t GPSHyperionLinuxController::initialize() {
     if (retval != 0) {
       openError("Socket", retval);
     }
+    gps_stream(&gps, WATCH_ENABLE | WATCH_JSON, nullptr);
   } else if (readMode == ReadModes::SHM) {
     int retval = gps_open(GPSD_SHARED_MEMORY, "", &gps);
     if (retval != 0) {
@@ -124,57 +137,58 @@ ReturnValue_t GPSHyperionLinuxController::initialize() {
   return result;
 }
 
-ReturnValue_t GPSHyperionLinuxController::handleCommandMessage(CommandMessage *message) {
+ReturnValue_t GpsHyperionLinuxController::handleCommandMessage(CommandMessage *message) {
   return ExtendedControllerBase::handleCommandMessage(message);
 }
 
-#ifdef FSFW_OSAL_LINUX
+void GpsHyperionLinuxController::performControlOperation() {}
 
-void GPSHyperionLinuxController::readGpsDataFromGpsd() {
-  auto readError = [&](int error) {
+bool GpsHyperionLinuxController::readGpsDataFromGpsd() {
+  auto readError = [&]() {
     if (gpsReadFailedSwitch) {
       gpsReadFailedSwitch = false;
       sif::warning << "GPSHyperionHandler::readGpsDataFromGpsd: Reading GPS data failed | "
                       "Error "
-                   << error << " | " << gps_errstr(error) << std::endl;
+                   << errno << " | " << gps_errstr(errno) << std::endl;
     }
   };
-  currentClientBuf = gps_data(&gps);
   if (readMode == ReadModes::SOCKET) {
-    gps_stream(&gps, WATCH_ENABLE | WATCH_JSON, nullptr);
-    // Exit if no data is seen in 2 seconds (should not happen)
-    if (not gps_waiting(&gps, 2000000)) {
-      return;
-    }
-    int result = gps_read(&gps);
-    if (result == -1) {
-      readError(result);
-      return;
-    }
-    if (MODE_SET != (MODE_SET & gps.set)) {
-      if (noModeSetCntr >= 0) {
-        noModeSetCntr++;
+    // Perform other necessary handling if not data seen for 0.2 seconds.
+    if (gps_waiting(&gps, 200000)) {
+      if (-1 == gps_read(&gps)) {
+        readError();
+        return false;
       }
-      if (noModeSetCntr == 10) {
-        // TODO: Trigger event here
-        sif::warning << "GPSHyperionHandler::readGpsDataFromGpsd: No mode could be "
-                        "read for 10 consecutive reads"
-                     << std::endl;
-        noModeSetCntr = -1;
+      if (MODE_SET != (MODE_SET & gps.set)) {
+        if (mode == MODE_ON) {
+          if (noModeSetCntr >= 0) {
+            noModeSetCntr++;
+          }
+          if (noModeSetCntr == 10) {
+            // TODO: Trigger event here
+            sif::warning << "GPSHyperionHandler::readGpsDataFromGpsd: No mode could be "
+                            "read for 10 consecutive reads"
+                         << std::endl;
+            noModeSetCntr = -1;
+          }
+          // did not event get mode, nothing to see.
+          return false;
+        }
       }
+      noModeSetCntr = 0;
+    } else {
+      return false;
     }
-    noModeSetCntr = 0;
   } else if (readMode == ReadModes::SHM) {
-    int result = gps_read(&gps);
-    if (result == -1) {
-      readError(result);
-      return;
-    }
+    sif::error << "GpsHyperionLinuxController::readGpsDataFromGpsdPermanentLoop: "
+                  "SHM read not implemented"
+               << std::endl;
   }
-  handleGpsRead();
+  handleGpsReadData();
+  return true;
 }
 
-ReturnValue_t GPSHyperionLinuxController::handleGpsRead() {
+ReturnValue_t GpsHyperionLinuxController::handleGpsReadData() {
   PoolReadGuard pg(&gpsSet);
   if (pg.getReadResult() != returnvalue::OK) {
 #if FSFW_VERBOSE_LEVEL >= 1
@@ -311,5 +325,3 @@ ReturnValue_t GPSHyperionLinuxController::handleGpsRead() {
   }
   return returnvalue::OK;
 }
-
-#endif

linux/devices/GpsHyperionLinuxController.h

@@ -20,18 +20,19 @@
  * This device handler can only be used on Linux system where the gpsd daemon with shared memory
  * export is running.
  */
-class GPSHyperionLinuxController : public ExtendedControllerBase {
+class GpsHyperionLinuxController : public ExtendedControllerBase {
  public:
   static constexpr uint32_t MAX_SECONDS_TO_REACH_FIX = 60 * 60 * 5;
 
   enum ReadModes { SHM = 0, SOCKET = 1 };
 
-  GPSHyperionLinuxController(object_id_t objectId, object_id_t parentId,
+  GpsHyperionLinuxController(object_id_t objectId, object_id_t parentId,
                              bool debugHyperionGps = false);
-  virtual ~GPSHyperionLinuxController();
+  virtual ~GpsHyperionLinuxController();
 
   using gpioResetFunction_t = ReturnValue_t (*)(const uint8_t* actionData, size_t len, void* args);
 
+  ReturnValue_t performOperation(uint8_t opCode) override;
   void setResetPinTriggerFunction(gpioResetFunction_t resetCallback, void* args);
   ReturnValue_t handleCommandMessage(CommandMessage* message) override;
   void performControlOperation() override;
@@ -49,7 +50,7 @@ class GPSHyperionLinuxController : public ExtendedControllerBase {
   ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
                                         LocalDataPoolManager& poolManager) override;
 
-  ReturnValue_t handleGpsRead();
+  ReturnValue_t handleGpsReadData();
 
  private:
   GpsPrimaryDataset gpsSet;
@@ -66,7 +67,9 @@ class GPSHyperionLinuxController : public ExtendedControllerBase {
   uint32_t timeIsConstantCounter = 0;
   Countdown timeUpdateCd = Countdown(60);
 
-  void readGpsDataFromGpsd();
+  // Returns true if the function should be called again or false if other
+  // controller handling can be done.
+  bool readGpsDataFromGpsd();
 };
 
 #endif /* MISSION_DEVICES_GPSHYPERIONHANDLER_H_ */

linux/devices/Max31865RtdLowlevelHandler.cpp

@@ -143,7 +143,7 @@ ReturnValue_t Max31865RtdReader::periodicReadHandling() {
   auto result = returnvalue::OK;
   MutexGuard mg(readerMutex);
   if (mg.getLockResult() != returnvalue::OK) {
-    sif::warning << "Max31865RtdReader::periodicReadReqHandling: Mutex lock failed" << std::endl;
+    sif::warning << "Max31865RtdReader::periodicReadHandling: Mutex lock failed" << std::endl;
     return returnvalue::FAILED;
   }
   // Now read the RTD values
@@ -154,6 +154,10 @@ ReturnValue_t Max31865RtdReader::periodicReadHandling() {
     if (rtdIsActive(rtd->idx)) {
       uint16_t rtdVal = 0;
       bool faultBitSet = false;
+      result = writeCfgReg(rtd->spiCookie, BASE_CFG);
+      if (result != returnvalue::OK) {
+        handleSpiError(rtd, result, "writeCfgReg");
+      }
       result = readRtdVal(rtd->spiCookie, rtdVal, faultBitSet);
       if (result != returnvalue::OK) {
         handleSpiError(rtd, result, "readRtdVal");
@@ -282,7 +286,13 @@ ReturnValue_t Max31865RtdReader::sendMessage(CookieIF* cookie, const uint8_t* se
       }
       break;
     }
-    case (EiveMax31855::RtdCommands::CFG):
+    case (EiveMax31855::RtdCommands::CFG): {
+      ReturnValue_t result = writeCfgReg(rtdCookie->spiCookie, BASE_CFG);
+      if (result != returnvalue::OK) {
+        handleSpiError(rtdCookie, result, "writeCfgReg");
+      }
+      break;
+    }
     default: {
       // TODO: Only implement if needed
       break;

linux/devices/startracker/StarTrackerHandler.cpp

@@ -1209,6 +1209,21 @@ ReturnValue_t StarTrackerHandler::initializeLocalDataPool(localpool::DataPool& l
   localDataPoolMap.emplace(startracker::DEBUG_CAMERA_TEST, new PoolEntry<uint32_t>({0}));
 
   localDataPoolMap.emplace(startracker::CHKSUM, new PoolEntry<uint32_t>({0}));
+
+  poolManager.subscribeForDiagPeriodicPacket(
+      subdp::DiagnosticsHkPeriodicParams(temperatureSet.getSid(), false, 10.0));
+  poolManager.subscribeForRegularPeriodicPacket(
+      subdp::RegularHkPeriodicParams(powerSet.getSid(), false, 10.0));
+  poolManager.subscribeForRegularPeriodicPacket(
+      subdp::RegularHkPeriodicParams(interfaceSet.getSid(), false, 10.0));
+  poolManager.subscribeForDiagPeriodicPacket(
+      subdp::DiagnosticsHkPeriodicParams(solutionSet.getSid(), false, 5.0));
+  poolManager.subscribeForRegularPeriodicPacket(
+      subdp::RegularHkPeriodicParams(cameraSet.getSid(), false, 10.0));
+  poolManager.subscribeForRegularPeriodicPacket(
+      subdp::RegularHkPeriodicParams(histogramSet.getSid(), false, 10.0));
+  poolManager.subscribeForRegularPeriodicPacket(
+      subdp::RegularHkPeriodicParams(lisaSet.getSid(), false, 10.0));
   return returnvalue::OK;
 }
 

linux/fsfwconfig/events/subsystemIdRanges.h

@@ -13,7 +13,6 @@
 namespace SUBSYSTEM_ID {
 enum : uint8_t {
   SUBSYSTEM_ID_START = COMMON_SUBSYSTEM_ID_END,
-  CORE = 137,
 };
 }
 

linux/fsfwconfig/events/translateEvents.cpp

@@ -1,7 +1,7 @@
 /**
- * @brief    Auto-generated event translation file. Contains 239 translations.
+ * @brief    Auto-generated event translation file. Contains 245 translations.
  * @details
- * Generated on: 2022-12-01 17:07:27
+ * Generated on: 2023-02-03 10:52:53
  */
 #include "translateEvents.h"
 
@@ -82,6 +82,7 @@ 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";
@@ -89,6 +90,8 @@ 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 *SAFE_RATE_VIOLATION_STRING = "SAFE_RATE_VIOLATION";
+const char *SAFE_RATE_RECOVERY_STRING = "SAFE_RATE_RECOVERY";
 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";
@@ -227,11 +230,8 @@ 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 *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 *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";
@@ -240,6 +240,11 @@ 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 *translateEvents(Event event) {
   switch ((event & 0xFFFF)) {
@@ -398,6 +403,8 @@ 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;
@@ -411,6 +418,10 @@ const char *translateEvents(Event event) {
       return MSG_QUEUE_ERROR_STRING;
     case (10802):
       return SERIALIZATION_ERROR_STRING;
+    case (11200):
+      return SAFE_RATE_VIOLATION_STRING;
+    case (11201):
+      return SAFE_RATE_RECOVERY_STRING;
     case (11300):
       return SWITCH_CMD_SENT_STRING;
     case (11301):
@@ -687,16 +698,10 @@ const char *translateEvents(Event event) {
       return HDLC_FRAME_REMOVAL_ERROR_STRING;
     case (13632):
       return HDLC_CRC_ERROR_STRING;
-    case (13700):
-      return ALLOC_FAILURE_STRING;
     case (13701):
-      return REBOOT_SW_STRING;
+      return TX_ON_STRING;
     case (13702):
-      return REBOOT_MECHANISM_TRIGGERED_STRING;
-    case (13703):
-      return REBOOT_HW_STRING;
-    case (13704):
-      return NO_SD_CARD_ACTIVE_STRING;
+      return TX_OFF_STRING;
     case (13800):
       return MISSING_PACKET_STRING;
     case (13801):
@@ -713,6 +718,16 @@ const char *translateEvents(Event event) {
       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;
     default:
       return "UNKNOWN_EVENT";
   }

linux/fsfwconfig/objects/systemObjectList.h

@@ -39,8 +39,6 @@ enum sourceObjects : uint32_t {
   FW_ADDRESS_END = TIME_STAMPER,
   PUS_SERVICE_6 = 0x51000500,
 
-  CCSDS_IP_CORE_BRIDGE = 0x73500000,
-
   /* 0x49 ('I') for Communication Interfaces **/
   ARDUINO_COM_IF = 0x49000000,
   CSP_COM_IF = 0x49050001,

linux/fsfwconfig/objects/translateObjects.cpp

@@ -1,8 +1,8 @@
 /**
  * @brief  Auto-generated object translation file.
  * @details
- * Contains 148 translations.
- * Generated on: 2022-12-01 17:07:27
+ * Contains 152 translations.
+ * Generated on: 2023-02-03 10:52:53
  */
 #include "translateObjects.h"
 
@@ -80,7 +80,7 @@ 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_HK_HANDLER_STRING = "SYRLINKS_HK_HANDLER";
+const char *SYRLINKS_HANDLER_STRING = "SYRLINKS_HANDLER";
 const char *ARDUINO_COM_IF_STRING = "ARDUINO_COM_IF";
 const char *GPIO_IF_STRING = "GPIO_IF";
 const char *SCEX_UART_READER_STRING = "SCEX_UART_READER";
@@ -92,8 +92,10 @@ const char *I2C_COM_IF_STRING = "I2C_COM_IF";
 const char *CSP_COM_IF_STRING = "CSP_COM_IF";
 const char *CCSDS_PACKET_DISTRIBUTOR_STRING = "CCSDS_PACKET_DISTRIBUTOR";
 const char *PUS_PACKET_DISTRIBUTOR_STRING = "PUS_PACKET_DISTRIBUTOR";
-const char *TMTC_BRIDGE_STRING = "TMTC_BRIDGE";
-const char *TMTC_POLLING_TASK_STRING = "TMTC_POLLING_TASK";
+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";
@@ -152,6 +154,8 @@ 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 *CCSDS_IP_CORE_BRIDGE_STRING = "CCSDS_IP_CORE_BRIDGE";
 const char *NO_OBJECT_STRING = "NO_OBJECT";
 
@@ -306,7 +310,7 @@ const char *translateObject(object_id_t object) {
     case 0x44420031:
       return RTD_15_IC18_IMTQ_STRING;
     case 0x445300A3:
-      return SYRLINKS_HK_HANDLER_STRING;
+      return SYRLINKS_HANDLER_STRING;
     case 0x49000000:
       return ARDUINO_COM_IF_STRING;
     case 0x49010005:
@@ -330,9 +334,13 @@ const char *translateObject(object_id_t object) {
     case 0x50000200:
       return PUS_PACKET_DISTRIBUTOR_STRING;
     case 0x50000300:
-      return TMTC_BRIDGE_STRING;
+      return TCP_TMTC_SERVER_STRING;
+    case 0x50000301:
+      return UDP_TMTC_SERVER_STRING;
     case 0x50000400:
-      return TMTC_POLLING_TASK_STRING;
+      return TCP_TMTC_POLLING_TASK_STRING;
+    case 0x50000401:
+      return UDP_TMTC_POLLING_TASK_STRING;
     case 0x50000500:
       return FILE_SYSTEM_HANDLER_STRING;
     case 0x50000550:
@@ -449,6 +457,10 @@ const char *translateObject(object_id_t object) {
       return ACS_SUBSYSTEM_STRING;
     case 0x73010002:
       return PL_SUBSYSTEM_STRING;
+    case 0x73010003:
+      return TCS_SUBSYSTEM_STRING;
+    case 0x73010004:
+      return COM_SUBSYSTEM_STRING;
     case 0x73500000:
       return CCSDS_IP_CORE_BRIDGE_STRING;
     case 0xFFFFFFFF:

linux/fsfwconfig/pollingsequence/pollingSequenceFactory.cpp

@@ -487,12 +487,11 @@ ReturnValue_t pst::pstUart(FixedTimeslotTaskIF *thisSequence) {
   static_cast<void>(length);
 
 #if OBSW_ADD_SYRLINKS == 1
-  thisSequence->addSlot(objects::SYRLINKS_HK_HANDLER, length * 0,
-                        DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::SYRLINKS_HK_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::SYRLINKS_HK_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::SYRLINKS_HK_HANDLER, length * 0.6, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::SYRLINKS_HK_HANDLER, length * 0.8, DeviceHandlerIF::GET_READ);
+  thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0.6, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0.8, DeviceHandlerIF::GET_READ);
 #endif
 
 #if OBSW_ADD_STAR_TRACKER == 1

linux/ipcore/PdecConfig.cpp

@@ -9,8 +9,12 @@ PdecConfig::~PdecConfig() {}
 void PdecConfig::initialize() {
   uint32_t word = 0;
   word |= (VERSION_ID << 30);
+
+  // Setting the bypass flag and the control command flag should not have any
+  // implication on the operation of the PDEC IP Core
   word |= (BYPASS_FLAG << 29);
   word |= (CONTROL_COMMAND_FLAG << 28);
+
   word |= (RESERVED_FIELD_A << 26);
   word |= (SPACECRAFT_ID << 16);
   word |= (VIRTUAL_CHANNEL << 10);

linux/ipcore/PdecConfig.h

@@ -34,7 +34,7 @@ class PdecConfig {
 
   static const uint8_t VIRTUAL_CHANNEL = 0;
   static const uint8_t RESERVED_FIELD_A = 0;
-  static const uint16_t SPACECRAFT_ID = 0x274;
+  static const uint16_t SPACECRAFT_ID = 0x3DC;
   static const uint16_t DUMMY_BITS = 0;
   // Parameters to control the FARM for AD frames
   // Set here for future use

linux/ipcore/PdecHandler.cpp

@@ -188,6 +188,7 @@ ReturnValue_t PdecHandler::irqOperation() {
             if ((pisr & NEW_FAR_MASK) == NEW_FAR_MASK) {
               // Read FAR here
               CURRENT_FAR = readFar();
+              checkFrameAna(CURRENT_FAR);
             }
             if (lockCheckCd.hasTimedOut()) {
               checkLocks();

linux/ipcore/PdecHandler.h

@@ -5,6 +5,7 @@
 
 #include "OBSWConfig.h"
 #include "PdecConfig.h"
+#include "eive/definitions.h"
 #include "fsfw/action/ActionHelper.h"
 #include "fsfw/action/HasActionsIF.h"
 #include "fsfw/objectmanager/SystemObject.h"
@@ -120,7 +121,7 @@ class PdecHandler : public SystemObject, public ExecutableObjectIF, public HasAc
   //! Invalid BC control command
   static const ReturnValue_t INVALID_BC_CC = MAKE_RETURN_CODE(0xAE);
 
-  static const uint32_t QUEUE_SIZE = common::CCSDS_HANDLER_QUEUE_SIZE;
+  static const uint32_t QUEUE_SIZE = config::CCSDS_HANDLER_QUEUE_SIZE;
 
   // Action IDs
   static const ActionId_t PRINT_CLCW = 0;

linux/ipcore/Ptme.cpp

@@ -4,6 +4,7 @@
 #include <unistd.h>
 
 #include "PtmeConfig.h"
+#include "eive/definitions.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"
 
 Ptme::Ptme(object_id_t objectId) : SystemObject(objectId) {}
@@ -32,7 +33,7 @@ ReturnValue_t Ptme::writeToVc(uint8_t vcId, const uint8_t* data, size_t size) {
 }
 
 void Ptme::addVcInterface(VcId_t vcId, VcInterfaceIF* vc) {
-  if (vcId > common::NUMBER_OF_VIRTUAL_CHANNELS) {
+  if (vcId > config::NUMBER_OF_VIRTUAL_CHANNELS) {
     sif::warning << "Ptme::addVcInterface: Invalid virtual channel ID" << std::endl;
     return;
   }

mission/CMakeLists.txt

@@ -7,3 +7,4 @@ add_subdirectory(tmtc)
 add_subdirectory(system)
 add_subdirectory(csp)
 add_subdirectory(cfdp)
+add_subdirectory(config)

mission/acsDefs.h

@@ -0,0 +1,28 @@
+#ifndef MISSION_ACSDEFS_H_
+#define MISSION_ACSDEFS_H_
+
+#include <eive/eventSubsystemIds.h>
+#include <fsfw/modes/HasModesIF.h>
+
+namespace acs {
+
+enum CtrlSubmode {
+  OFF = HasModesIF::MODE_OFF,
+  SAFE = 10,
+  DETUMBLE = 11,
+  IDLE = 12,
+  PTG_TARGET_NADIR = 13,
+  PTG_TARGET = 14,
+  PTG_TARGET_GS = 15,
+  PTG_TARGET_INERTIAL = 16,
+};
+
+static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::ACS_SUBSYSTEM;
+//!< The limits for the rotation in safe mode were violated.
+static const Event SAFE_RATE_VIOLATION = MAKE_EVENT(0, severity::MEDIUM);
+//!< The system has recovered from a safe rate rotation violation.
+static constexpr Event SAFE_RATE_RECOVERY = MAKE_EVENT(1, severity::MEDIUM);
+
+}  // namespace acs
+
+#endif /* MISSION_ACSDEFS_H_ */

mission/comDefs.h

@@ -0,0 +1,31 @@
+#ifndef MISSION_COMDEFS_H_
+#define MISSION_COMDEFS_H_
+
+namespace com {
+
+enum class Datarate : uint8_t {
+  LOW_RATE_MODULATION_BPSK,
+  HIGH_RATE_MODULATION_0QPSK,
+  NUM_DATARATES
+};
+
+enum Submode : uint8_t {
+  RX_ONLY = 10,
+  RX_AND_TX_DEFAULT_DATARATE = 11,
+  RX_AND_TX_LOW_DATARATE = 12,
+  RX_AND_TX_HIGH_DATARATE = 13,
+  RX_AND_TX_CW = 14,
+  NUM_SUBMODES
+};
+
+enum class CcsdsSubmode : uint8_t {
+  UNSET = 0,
+  DATARATE_LOW = 1,
+  DATARATE_HIGH = 2,
+  DATARATE_DEFAULT = 3
+};
+enum class ParameterId : uint8_t { DATARATE = 0 };
+
+}  // namespace com
+
+#endif /* MISSION_COMDEFS_H_ */

mission/config/CMakeLists.txt

@@ -0,0 +1 @@
+target_sources(${LIB_EIVE_MISSION} PRIVATE comCfg.cpp torquer.cpp)

mission/config/comCfg.cpp

@@ -0,0 +1,26 @@
+#include "comCfg.h"
+
+#include <fsfw/ipc/MutexFactory.h>
+#include <fsfw/ipc/MutexGuard.h>
+
+com::Datarate DATARATE_CFG_RAW = com::Datarate::LOW_RATE_MODULATION_BPSK;
+MutexIF* DATARATE_LOCK = nullptr;
+
+MutexIF* lazyLock();
+
+com::Datarate com::getCurrentDatarate() {
+  MutexGuard mg(lazyLock());
+  return DATARATE_CFG_RAW;
+}
+
+void com::setCurrentDatarate(com::Datarate newRate) {
+  MutexGuard mg(lazyLock());
+  DATARATE_CFG_RAW = newRate;
+}
+
+MutexIF* lazyLock() {
+  if (DATARATE_LOCK == nullptr) {
+    return MutexFactory::instance()->createMutex();
+  }
+  return DATARATE_LOCK;
+}

mission/config/comCfg.h

@@ -0,0 +1,15 @@
+#ifndef MISSION_COMCFG_H_
+#define MISSION_COMCFG_H_
+
+#include <fsfw/ipc/MutexIF.h>
+
+#include "mission/comDefs.h"
+
+namespace com {
+
+com::Datarate getCurrentDatarate();
+void setCurrentDatarate(com::Datarate newRate);
+
+}  // namespace com
+
+#endif /* MISSION_COMCFG_H_ */

mission/controller/AcsController.cpp

@@ -2,7 +2,8 @@
 
 #include <fsfw/datapool/PoolReadGuard.h>
 
-#include "mission/devices/torquer.h"
+#include "mission/acsDefs.h"
+#include "mission/config/torquer.h"
 
 AcsController::AcsController(object_id_t objectId)
     : ExtendedControllerBase(objectId),
@@ -45,15 +46,15 @@ void AcsController::performControlOperation() {
     case InternalState::READY: {
       if (mode != MODE_OFF) {
         switch (submode) {
-          case SUBMODE_SAFE:
+          case acs::SAFE:
             performSafe();
             break;
-          case SUBMODE_DETUMBLE:
+          case acs::DETUMBLE:
             performDetumble();
             break;
-          case SUBMODE_PTG_TARGET:
-          case SUBMODE_PTG_NADIR:
-          case SUBMODE_PTG_INERTIAL:
+          case acs::PTG_TARGET:
+          case acs::PTG_TARGET_NADIR:
+          case acs::PTG_TARGET_INERTIAL:
             performPointingCtrl();
             break;
         }
@@ -151,9 +152,9 @@ void AcsController::performSafe() {
     detumbleCounter = 0;
   }
   if (detumbleCounter > acsParameters.detumbleParameter.detumblecounter) {
-    submode = SUBMODE_DETUMBLE;
     detumbleCounter = 0;
-    triggerEvent(SAFE_RATE_VIOLATION);
+    // Triggers detubmle mode transition in subsystem
+    triggerEvent(acs::SAFE_RATE_VIOLATION);
   }
 
   {
@@ -208,8 +209,9 @@ void AcsController::performDetumble() {
     detumbleCounter = 0;
   }
   if (detumbleCounter > acsParameters.detumbleParameter.detumblecounter) {
-    submode = SUBMODE_SAFE;
     detumbleCounter = 0;
+    // Triggers safe mode transition in subsystem
+    triggerEvent(acs::SAFE_RATE_RECOVERY);
   }
 
   int16_t cmdDipolUnitsInt[3] = {0, 0, 0};
@@ -358,14 +360,14 @@ ReturnValue_t AcsController::initializeLocalDataPool(localpool::DataPool &localD
   localDataPoolMap.emplace(acsctrl::PoolIds::GYR_1_L3, &gyr1VecRaw);
   localDataPoolMap.emplace(acsctrl::PoolIds::GYR_2_ADIS, &gyr2VecRaw);
   localDataPoolMap.emplace(acsctrl::PoolIds::GYR_3_L3, &gyr3VecRaw);
-  poolManager.subscribeForRegularPeriodicPacket({gyrDataRaw.getSid(), false, 5.0});
+  poolManager.subscribeForDiagPeriodicPacket({gyrDataRaw.getSid(), false, 5.0});
   // GYR Processed
   localDataPoolMap.emplace(acsctrl::PoolIds::GYR_0_VEC, &gyr0VecProc);
   localDataPoolMap.emplace(acsctrl::PoolIds::GYR_1_VEC, &gyr1VecProc);
   localDataPoolMap.emplace(acsctrl::PoolIds::GYR_2_VEC, &gyr2VecProc);
   localDataPoolMap.emplace(acsctrl::PoolIds::GYR_3_VEC, &gyr3VecProc);
   localDataPoolMap.emplace(acsctrl::PoolIds::GYR_VEC_TOT, &gyrVecTot);
-  poolManager.subscribeForRegularPeriodicPacket({gyrDataProcessed.getSid(), false, 5.0});
+  poolManager.subscribeForDiagPeriodicPacket({gyrDataProcessed.getSid(), false, 5.0});
   // GPS Processed
   localDataPoolMap.emplace(acsctrl::PoolIds::GC_LATITUDE, &gcLatitude);
   localDataPoolMap.emplace(acsctrl::PoolIds::GD_LONGITUDE, &gdLongitude);
@@ -373,7 +375,7 @@ ReturnValue_t AcsController::initializeLocalDataPool(localpool::DataPool &localD
   // MEKF
   localDataPoolMap.emplace(acsctrl::PoolIds::QUAT_MEKF, &quatMekf);
   localDataPoolMap.emplace(acsctrl::PoolIds::SAT_ROT_RATE_MEKF, &satRotRateMekf);
-  poolManager.subscribeForRegularPeriodicPacket({mekfData.getSid(), false, 5.0});
+  poolManager.subscribeForDiagPeriodicPacket({mekfData.getSid(), false, 5.0});
   // Ctrl Values
   localDataPoolMap.emplace(acsctrl::PoolIds::TGT_QUAT, &tgtQuat);
   localDataPoolMap.emplace(acsctrl::PoolIds::ERROR_QUAT, &errQuat);
@@ -484,9 +486,9 @@ void AcsController::copyMgmData() {
 }
 
 void AcsController::copySusData() {
-  ACS::SensorValues sensorValues;
   {
     PoolReadGuard pg(&sensorValues.susSets[0]);
+
     if (pg.getReadResult() == returnvalue::OK) {
       std::memcpy(susDataRaw.sus0.value, sensorValues.susSets[0].channels.value,
                   6 * sizeof(uint16_t));

mission/controller/AcsController.h

@@ -24,16 +24,6 @@ class AcsController : public ExtendedControllerBase {
 
   AcsController(object_id_t objectId);
 
-  static const Submode_t SUBMODE_SAFE = 2;
-  static const Submode_t SUBMODE_DETUMBLE = 3;
-  static const Submode_t SUBMODE_PTG_TARGET = 4;
-  static const Submode_t SUBMODE_PTG_NADIR = 5;
-  static const Submode_t SUBMODE_PTG_INERTIAL = 6;
-
-  static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::ACS_SUBSYSTEM;
-  static const Event SAFE_RATE_VIOLATION =
-      MAKE_EVENT(0, severity::MEDIUM);  //!< The limits for the rotation in safe mode were violated.
-
  protected:
   void performSafe();
   void performDetumble();
@@ -70,6 +60,7 @@ class AcsController : public ExtendedControllerBase {
   void announceMode(bool recursive);
 
   /* ACS Datasets */
+  ACS::SensorValues sensorValues;
   IMTQ::DipoleActuationSet dipoleSet = IMTQ::DipoleActuationSet(objects::IMTQ_HANDLER);
   // MGMs
   acsctrl::MgmDataRaw mgmDataRaw;

mission/controller/ThermalController.cpp

@@ -746,7 +746,7 @@ void ThermalController::copyDevices() {
 
   {
     lp_var_t<float> tempSyrlinksPowerAmplifier =
-        lp_var_t<float>(objects::SYRLINKS_HK_HANDLER, syrlinks::TEMP_POWER_AMPLIFIER);
+        lp_var_t<float>(objects::SYRLINKS_HANDLER, syrlinks::TEMP_POWER_AMPLIFIER);
     PoolReadGuard pg(&tempSyrlinksPowerAmplifier, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
     if (pg.getReadResult() != returnvalue::OK) {
       sif::warning << "ThermalController: Failed to read syrlinks power amplifier temperature"
@@ -761,7 +761,7 @@ void ThermalController::copyDevices() {
 
   {
     lp_var_t<float> tempSyrlinksBasebandBoard =
-        lp_var_t<float>(objects::SYRLINKS_HK_HANDLER, syrlinks::TEMP_BASEBAND_BOARD);
+        lp_var_t<float>(objects::SYRLINKS_HANDLER, syrlinks::TEMP_BASEBAND_BOARD);
     PoolReadGuard pg(&tempSyrlinksBasebandBoard, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
     if (pg.getReadResult() != returnvalue::OK) {
       sif::warning << "ThermalController: Failed to read syrlinks baseband board temperature"

mission/controller/acs/AcsParameters.h

@@ -37,21 +37,24 @@ class AcsParameters /*: public HasParametersIF*/ {
     float mgm3orientationMatrix[3][3] = {{0, 0, 1}, {0, -1, 0}, {1, 0, 0}};
     float mgm4orientationMatrix[3][3] = {{0, 0, -1}, {-1, 0, 0}, {0, 1, 0}};
 
-    float mgm0hardIronOffset[3] = {19.89364, -29.94111, -31.07508};
-    float mgm1hardIronOffset[3] = {10.95500, -8.053403, -33.36383};
-    float mgm2hardIronOffset[3] = {15.72181, -26.87090, -62.19010};
+    float mgm0hardIronOffset[3] = {0.0, 0.0, 0.0};  //{19.89364, -29.94111, -31.07508};
+    float mgm1hardIronOffset[3] = {0.0, 0.0, 0.0};  //{10.95500, -8.053403, -33.36383};
+    float mgm2hardIronOffset[3] = {0.0, 0.0, 0.0};  //{15.72181, -26.87090, -62.19010};
     float mgm3hardIronOffset[3] = {0.0, 0.0, 0.0};
     float mgm4hardIronOffset[3] = {0.0, 0.0, 0.0};
 
-    float mgm0softIronInverse[3][3] = {{1420.727e-3, 9.352825e-3, -127.1979e-3},
-                                       {9.352825e-3, 1031.965e-3, -80.02734e-3},
-                                       {-127.1979e-3, -80.02734e-3, 934.8899e-3}};
-    float mgm1softIronInverse[3][3] = {{126.7325e-2, -4.146410e-2, -18.37963e-2},
-                                       {-4.146410e-2, 109.3310e-2, -5.246314e-2},
-                                       {-18.37963e-2, -5.246314e-2, 105.7300e-2}};
-    float mgm2softIronInverse[3][3] = {{143.0438e-2, 7.095763e-2, 15.67482e-2},
-                                       {7.095763e-2, 99.65167e-2, -6.958760e-2},
-                                       {15.67482e-2, -6.958760e-2, 94.50124e-2}};
+    float mgm0softIronInverse[3][3] = {
+        {1, 0, 0}, {0, 1, 0}, {0, 0, 1}}; /*{{1420.727e-3, 9.352825e-3,
+         -127.1979e-3}, {9.352825e-3, 1031.965e-3, -80.02734e-3},
+         {-127.1979e-3, -80.02734e-3, 934.8899e-3}};*/
+    float mgm1softIronInverse[3][3] = {
+        {1, 0, 0}, {0, 1, 0}, {0, 0, 1}}; /*{{126.7325e-2, -4.146410e-2, -18.37963e-2},
+         {-4.146410e-2, 109.3310e-2, -5.246314e-2},
+         {-18.37963e-2, -5.246314e-2, 105.7300e-2}};*/
+    float mgm2softIronInverse[3][3] = {
+        {1, 0, 0}, {0, 1, 0}, {0, 0, 1}}; /*{{143.0438e-2, 7.095763e-2,
+         15.67482e-2}, {7.095763e-2, 99.65167e-2, -6.958760e-2},
+         {15.67482e-2, -6.958760e-2, 94.50124e-2}};*/
     float mgm3softIronInverse[3][3] = {{1, 0, 0}, {0, 1, 0}, {0, 0, 1}};
     float mgm4softIronInverse[3][3] = {{1, 0, 0}, {0, 1, 0}, {0, 0, 1}};
     float mgm02variance[3] = {1, 1, 1};
@@ -896,8 +899,8 @@ class AcsParameters /*: public HasParametersIF*/ {
 
   struct DetumbleParameter {
     uint8_t detumblecounter = 75;  // 30 s
-    double omegaDetumbleStart = 2 * M_PI / 180;
-    double omegaDetumbleEnd = 0.4 * M_PI / 180;
+    double omegaDetumbleStart = 2;
+    double omegaDetumbleEnd = 0.4;
     double gainD = pow(10.0, -3.3);
   } detumbleParameter;
 };

mission/controller/acs/ActuatorCmd.cpp

@@ -54,21 +54,22 @@ void ActuatorCmd::cmdSpeedToRws(const int32_t *speedRw0, const int32_t *speedRw1
   VectorOperations<double>::add(speedRws, deltaSpeed, rwCmdSpeed, 4);
 }
 
-void ActuatorCmd::cmdDipolMtq(const double *dipolMoment, double *dipolMomentUnits) {
-  //	Convert to Unit frame
+void ActuatorCmd::cmdDipolMtq(const double *dipolMoment, double *dipolMomentActuator) {
+  // Convert to actuator frame
   MatrixOperations<double>::multiply(*acsParameters.magnetorquesParameter.inverseAlignment,
-                                     dipolMoment, dipolMomentUnits, 3, 3, 1);
-  //  Scaling along largest element if dipol exceeds maximum
+                                     dipolMoment, dipolMomentActuator, 3, 3, 1);
+  // Scaling along largest element if dipol exceeds maximum
   double maxDipol = acsParameters.magnetorquesParameter.DipolMax;
   double maxValue = 0;
   for (int i = 0; i < 3; i++) {
-    if (abs(dipolMomentUnits[i]) > maxDipol) {
-      maxValue = abs(dipolMomentUnits[i]);
+    if (abs(dipolMomentActuator[i]) > maxDipol) {
+      maxValue = abs(dipolMomentActuator[i]);
     }
   }
-
   if (maxValue > maxDipol) {
     double scalingFactor = maxDipol / maxValue;
-    VectorOperations<double>::mulScalar(dipolMomentUnits, scalingFactor, dipolMomentUnits, 3);
+    VectorOperations<double>::mulScalar(dipolMomentActuator, scalingFactor, dipolMomentActuator, 3);
   }
+  // scale dipole from 1 Am^2 to 1e^-4 Am^2
+  VectorOperations<double>::mulScalar(dipolMomentActuator, 1e4, dipolMomentActuator, 3);
 }

mission/controller/acs/ActuatorCmd.h

@@ -35,9 +35,9 @@ class ActuatorCmd {
    * @brief:	cmdDipolMtq()		gives the commanded dipol moment for the magnetorques
    *
    * @param:	dipolMoment 		given dipol moment in spacecraft frame
-   * 			dipolMomentUnits	resulting dipol moment for every unit
+   * 			dipolMomentActuator	resulting dipol moment in actuator reference frame
    */
-  void cmdDipolMtq(const double *dipolMoment, double *dipolMomentUnits);
+  void cmdDipolMtq(const double *dipolMoment, double *dipolMomentActuator);
 
  protected:
  private:

mission/controller/acs/SensorProcessing.cpp

@@ -103,7 +103,7 @@ void SensorProcessing::processMgm(const float *mgm0Value, bool mgm0valid, const
   }
   if (mgm4valid) {
     float mgm4ValueNT[3];
-    VectorOperations<float>::mulScalar(mgm4Value, 1e3, mgm4ValueNT, 3);  // uT to nT
+    VectorOperations<float>::mulScalar(mgm4Value, 1e-3, mgm4ValueNT, 3);  // uT to nT
     VectorOperations<float>::subtract(mgm4ValueNT, mgmParameters->mgm4hardIronOffset,
                                       mgm4ValueNoBias, 3);
     MatrixOperations<float>::multiply(mgmParameters->mgm4softIronInverse[0], mgm4ValueNoBias,

mission/controller/controllerdefinitions/AcsControllerDefinitions.h

@@ -1,14 +0,0 @@
-#ifndef MISSION_CONTROLLER_CONTROLLERDEFINITIONS_ACSCONTROLLERDEFINITIONS_H_
-#define MISSION_CONTROLLER_CONTROLLERDEFINITIONS_ACSCONTROLLERDEFINITIONS_H_
-
-#include <fsfw/modes/HasModesIF.h>
-
-namespace acs {
-
-enum CtrlModes { OFF = HasModesIF::MODE_OFF, SAFE = 1, DETUMBLE = 2, IDLE = 3, TARGET_PT = 4 };
-
-static constexpr Submode_t IDLE_CHARGE = 1;
-
-}  // namespace acs
-
-#endif /* MISSION_CONTROLLER_CONTROLLERDEFINITIONS_ACSCONTROLLERDEFINITIONS_H_ */

mission/controller/controllerdefinitions/AcsCtrlDefinitions.h

@@ -182,9 +182,9 @@ class SusDataProcessed : public StaticLocalDataSet<SUS_SET_PROCESSED_ENTRIES> {
   lp_vec_t<float, 3> sus6vec = lp_vec_t<float, 3>(sid.objectId, SUS_6_VEC, this);
   lp_vec_t<float, 3> sus7vec = lp_vec_t<float, 3>(sid.objectId, SUS_7_VEC, this);
   lp_vec_t<float, 3> sus8vec = lp_vec_t<float, 3>(sid.objectId, SUS_8_VEC, this);
-  lp_vec_t<float, 3> sus9vec = lp_vec_t<float, 3>(sid.objectId, SUS_8_VEC, this);
-  lp_vec_t<float, 3> sus10vec = lp_vec_t<float, 3>(sid.objectId, SUS_8_VEC, this);
-  lp_vec_t<float, 3> sus11vec = lp_vec_t<float, 3>(sid.objectId, SUS_8_VEC, this);
+  lp_vec_t<float, 3> sus9vec = lp_vec_t<float, 3>(sid.objectId, SUS_9_VEC, this);
+  lp_vec_t<float, 3> sus10vec = lp_vec_t<float, 3>(sid.objectId, SUS_10_VEC, this);
+  lp_vec_t<float, 3> sus11vec = lp_vec_t<float, 3>(sid.objectId, SUS_11_VEC, this);
   lp_vec_t<double, 3> susVecTot = lp_vec_t<double, 3>(sid.objectId, SUS_VEC_TOT, this);
   lp_vec_t<double, 3> susVecTotDerivative =
       lp_vec_t<double, 3>(sid.objectId, SUS_VEC_TOT_DERIVATIVE, this);

mission/core/GenericFactory.cpp

@@ -8,7 +8,7 @@
 #include <fsfw/internalerror/InternalErrorReporter.h>
 #include <fsfw/ipc/QueueFactory.h>
 #include <fsfw/pus/CService200ModeCommanding.h>
-#include <fsfw/pus/CService201HealthCommanding.h>
+#include <fsfw/pus/CServiceHealthCommanding.h>
 #include <fsfw/pus/Service17Test.h>
 #include <fsfw/pus/Service1TelecommandVerification.h>
 #include <fsfw/pus/Service20ParameterManagement.h>
@@ -104,16 +104,17 @@ void ObjectFactory::produceGenericObjects(HealthTableIF** healthTable_, PusTmFun
   new UdpTcPollingTask(objects::UDP_TMTC_POLLING_TASK, objects::UDP_TMTC_SERVER);
   sif::info << "Created UDP server for TMTC commanding with listener port "
             << udpBridge->getUdpPort() << std::endl;
-  udpBridge->setMaxNumberOfPacketsStored(150);
+  udpBridge->setMaxNumberOfPacketsStored(config::MAX_STORED_CMDS_UDP);
 #endif
 #if OBSW_ADD_TMTC_TCP_SERVER == 1
   auto tcpBridge = new TcpTmTcBridge(objects::TCP_TMTC_SERVER, objects::CCSDS_PACKET_DISTRIBUTOR);
-  auto tcpServer = new TcpTmTcServer(objects::TCP_TMTC_POLLING_TASK, objects::TCP_TMTC_SERVER);
+  TcpTmTcServer::TcpConfig cfg(true, true);
+  auto tcpServer = new TcpTmTcServer(objects::TCP_TMTC_POLLING_TASK, objects::TCP_TMTC_SERVER, cfg);
   // TCP is stream based. Use packet ID as start marker when parsing for space packets
   tcpServer->setSpacePacketParsingOptions({common::PUS_PACKET_ID, common::CFDP_PACKET_ID});
   sif::info << "Created TCP server for TMTC commanding with listener port "
             << tcpServer->getTcpPort() << std::endl;
-  tcpBridge->setMaxNumberOfPacketsStored(150);
+  tcpBridge->setMaxNumberOfPacketsStored(config::MAX_STORED_CMDS_TCP);
 #endif /* OBSW_USE_TMTC_TCP_BRIDGE == 0 */
 #endif /* OBSW_ADD_TCPIP_BRIDGE == 1 */
 
@@ -122,7 +123,8 @@ void ObjectFactory::produceGenericObjects(HealthTableIF** healthTable_, PusTmFun
   new PusDistributor(config::EIVE_PUS_APID, objects::PUS_PACKET_DISTRIBUTOR, ccsdsDistrib);
 
   *cfdpFunnel = new CfdpTmFunnel(objects::CFDP_TM_FUNNEL, config::EIVE_CFDP_APID, *tmStore, 50);
-  *pusFunnel = new PusTmFunnel(objects::PUS_TM_FUNNEL, *timeStamper, *tmStore, 80);
+  *pusFunnel = new PusTmFunnel(objects::PUS_TM_FUNNEL, *timeStamper, *tmStore,
+                               config::MAX_PUS_FUNNEL_QUEUE_DEPTH);
 #if OBSW_ADD_TCPIP_SERVERS == 1
 #if OBSW_ADD_TMTC_UDP_SERVER == 1
   (*cfdpFunnel)->addDestination(*udpBridge, 0);
@@ -160,8 +162,9 @@ void ObjectFactory::produceGenericObjects(HealthTableIF** healthTable_, PusTmFun
                                    pus::PUS_SERVICE_20);
   new CService200ModeCommanding(objects::PUS_SERVICE_200_MODE_MGMT, config::EIVE_PUS_APID,
                                 pus::PUS_SERVICE_200, 8);
-  new CService201HealthCommanding(objects::PUS_SERVICE_201_HEALTH, config::EIVE_PUS_APID,
-                                  pus::PUS_SERVICE_201);
+  HealthServiceCfg healthCfg(objects::PUS_SERVICE_201_HEALTH, config::EIVE_PUS_APID, *healthTable,
+                             20);
+  new CServiceHealthCommanding(healthCfg);
 
 #if OBSW_ADD_CFDP_COMPONENTS == 1
   using namespace cfdp;

mission/devices/CMakeLists.txt

@@ -8,7 +8,7 @@ target_sources(
           PDU1Handler.cpp
           PDU2Handler.cpp
           ACUHandler.cpp
-          SyrlinksHkHandler.cpp
+          SyrlinksHandler.cpp
           Max31865PT1000Handler.cpp
           Max31865EiveHandler.cpp
           ImtqHandler.cpp
@@ -20,7 +20,6 @@ target_sources(
           SusHandler.cpp
           PayloadPcduHandler.cpp
           SolarArrayDeploymentHandler.cpp
-          ScexDeviceHandler.cpp
-          torquer.cpp)
+          ScexDeviceHandler.cpp)
 
 add_subdirectory(devicedefinitions)

mission/devices/GyroADIS1650XHandler.cpp

@@ -63,6 +63,7 @@ void GyroADIS1650XHandler::doStartUp() {
 
 void GyroADIS1650XHandler::doShutDown() {
   commandExecuted = false;
+  internalState = InternalState::STARTUP;
   setMode(_MODE_POWER_DOWN);
 }
 
@@ -99,12 +100,13 @@ ReturnValue_t GyroADIS1650XHandler::buildCommandFromCommand(DeviceCommandId_t de
   switch (deviceCommand) {
     case (ADIS1650X::READ_OUT_CONFIG): {
       this->rawPacketLen = ADIS1650X::CONFIG_READOUT_SIZE;
-      uint8_t regList[5] = {};
+      uint8_t regList[6] = {};
       regList[0] = ADIS1650X::DIAG_STAT_REG;
       regList[1] = ADIS1650X::FILTER_CTRL_REG;
-      regList[2] = ADIS1650X::MSC_CTRL_REG;
-      regList[3] = ADIS1650X::DEC_RATE_REG;
-      regList[4] = ADIS1650X::PROD_ID_REG;
+      regList[2] = ADIS1650X::RANG_MDL_REG;
+      regList[3] = ADIS1650X::MSC_CTRL_REG;
+      regList[4] = ADIS1650X::DEC_RATE_REG;
+      regList[5] = ADIS1650X::PROD_ID_REG;
       prepareReadCommand(regList, sizeof(regList));
       this->rawPacket = commandBuffer.data();
       break;
@@ -203,9 +205,10 @@ ReturnValue_t GyroADIS1650XHandler::scanForReply(const uint8_t *start, size_t re
 
 ReturnValue_t GyroADIS1650XHandler::interpretDeviceReply(DeviceCommandId_t id,
                                                          const uint8_t *packet) {
+  using namespace ADIS1650X;
   switch (id) {
     case (ADIS1650X::READ_OUT_CONFIG): {
-      uint16_t readProdId = packet[10] << 8 | packet[11];
+      uint16_t readProdId = packet[12] << 8 | packet[13];
       if (((adisType == ADIS1650X::Type::ADIS16507) and (readProdId != ADIS1650X::PROD_ID_16507)) or
           ((adisType == ADIS1650X::Type::ADIS16505) and (readProdId != ADIS1650X::PROD_ID_16505))) {
 #if OBSW_VERBOSE_LEVEL >= 1
@@ -220,8 +223,32 @@ ReturnValue_t GyroADIS1650XHandler::interpretDeviceReply(DeviceCommandId_t id,
       PoolReadGuard rg(&configDataset);
       configDataset.diagStatReg.value = packet[2] << 8 | packet[3];
       configDataset.filterSetting.value = packet[4] << 8 | packet[5];
-      configDataset.mscCtrlReg.value = packet[6] << 8 | packet[7];
-      configDataset.decRateReg.value = packet[8] << 8 | packet[9];
+      uint16_t rangMdlRaw = packet[6] << 8 | packet[7];
+      ADIS1650X::RangMdlBitfield bitfield =
+          static_cast<ADIS1650X::RangMdlBitfield>((rangMdlRaw >> 2) & 0b11);
+      switch (bitfield) {
+        case (ADIS1650X::RangMdlBitfield::RANGE_125_1BMLZ): {
+          sensitivity = SENSITIVITY_1BMLZ;
+          break;
+        }
+        case (ADIS1650X::RangMdlBitfield::RANGE_500_2BMLZ): {
+          sensitivity = SENSITIVITY_2BMLZ;
+          break;
+        }
+        case (ADIS1650X::RangMdlBitfield::RANGE_2000_3BMLZ): {
+          sensitivity = SENSITIVITY_3BMLZ;
+          break;
+        }
+        case (RangMdlBitfield::RESERVED): {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+          sif::error << "ADIS1650X: Unexpected value for RANG_MDL register" << std::endl;
+#endif
+          break;
+        }
+      }
+      configDataset.rangMdl.value = rangMdlRaw;
+      configDataset.mscCtrlReg.value = packet[8] << 8 | packet[9];
+      configDataset.decRateReg.value = packet[10] << 8 | packet[11];
       configDataset.setValidity(true, true);
       if (internalState == InternalState::CONFIG) {
         commandExecuted = true;
@@ -271,14 +298,11 @@ ReturnValue_t GyroADIS1650XHandler::handleSensorData(const uint8_t *packet) {
       {
         PoolReadGuard pg(&primaryDataset);
         int16_t angVelocXRaw = packet[4] << 8 | packet[5];
-        primaryDataset.angVelocX.value =
-            static_cast<float>(angVelocXRaw) / INT16_MAX * ADIS1650X::GYRO_RANGE;
+        primaryDataset.angVelocX.value = static_cast<float>(angVelocXRaw) * sensitivity;
         int16_t angVelocYRaw = packet[6] << 8 | packet[7];
-        primaryDataset.angVelocY.value =
-            static_cast<float>(angVelocYRaw) / INT16_MAX * ADIS1650X::GYRO_RANGE;
+        primaryDataset.angVelocY.value = static_cast<float>(angVelocYRaw) * sensitivity;
         int16_t angVelocZRaw = packet[8] << 8 | packet[9];
-        primaryDataset.angVelocZ.value =
-            static_cast<float>(angVelocZRaw) / INT16_MAX * ADIS1650X::GYRO_RANGE;
+        primaryDataset.angVelocZ.value = static_cast<float>(angVelocZRaw) * sensitivity;
 
         float accelScaling = 0;
         if (adisType == ADIS1650X::Type::ADIS16507) {

mission/devices/GyroADIS1650XHandler.h

@@ -46,6 +46,8 @@ class GyroADIS1650XHandler : public DeviceHandlerBase {
   ADIS1650X::Type adisType;
   AdisGyroPrimaryDataset primaryDataset;
   AdisGyroConfigDataset configDataset;
+  double sensitivity = ADIS1650X::SENSITIVITY_UNSET;
+
   bool goToNormalMode = false;
   bool warningSwitch = true;
 

mission/devices/ImtqHandler.cpp

@@ -25,7 +25,7 @@
 #include <cmath>
 #include <fsfw/datapoollocal/LocalPoolVariable.tpp>
 
-#include "mission/devices/torquer.h"
+#include "mission/config/torquer.h"
 
 static constexpr bool ACTUATION_WIRETAPPING = false;
 

mission/devices/Max31865EiveHandler.cpp

@@ -36,6 +36,7 @@ void Max31865EiveHandler::doShutDown() {
     transitionOk = false;
   }
   if (state == InternalState::INACTIVE and transitionOk) {
+    updatePeriodicReply(false, EiveMax31855::RtdCommands::EXCHANGE_SET_ID);
     setMode(MODE_OFF);
   }
 }
@@ -69,7 +70,8 @@ ReturnValue_t Max31865EiveHandler::buildCommandFromCommand(DeviceCommandId_t dev
   switch (cmdTyped) {
     case (EiveMax31855::RtdCommands::ON):
     case (EiveMax31855::RtdCommands::ACTIVE):
-    case (EiveMax31855::RtdCommands::OFF): {
+    case (EiveMax31855::RtdCommands::OFF):
+    case (EiveMax31855::RtdCommands::CFG): {
       simpleCommand(cmdTyped);
       break;
     }
@@ -77,9 +79,6 @@ ReturnValue_t Max31865EiveHandler::buildCommandFromCommand(DeviceCommandId_t dev
     case (EiveMax31855::RtdCommands::HIGH_TRESHOLD): {
       break;
     }
-    case (EiveMax31855::RtdCommands::CFG): {
-      break;
-    }
     default:
       return NOTHING_TO_SEND;
   }
@@ -100,6 +99,7 @@ void Max31865EiveHandler::simpleCommand(EiveMax31855::RtdCommands cmd) {
   rawPacket = cmdBuf.data();
   rawPacketLen = 1;
 }
+
 void Max31865EiveHandler::doTransition(Mode_t modeFrom, Submode_t subModeFrom) {
   if (getMode() == _MODE_TO_NORMAL) {
     if (state != InternalState::ACTIVE) {
@@ -117,6 +117,7 @@ void Max31865EiveHandler::fillCommandAndReplyMap() {
   insertInCommandMap(EiveMax31855::RtdCommands::ON);
   insertInCommandMap(EiveMax31855::RtdCommands::ACTIVE);
   insertInCommandMap(EiveMax31855::RtdCommands::OFF);
+  insertInCommandMap(EiveMax31855::RtdCommands::CFG);
   insertInReplyMap(EiveMax31855::RtdCommands::EXCHANGE_SET_ID, 200, &sensorDataset, 0, true);
 }
 

mission/devices/PcduHandler.cpp

@@ -424,8 +424,8 @@ ReturnValue_t PCDUHandler::initializeLocalDataPool(localpool::DataPool& localDat
   localDataPoolMap.emplace(PoolIds::PDU1_SWITCHES, &pdu1Switches);
   localDataPoolMap.emplace(PoolIds::PDU2_SWITCHES, &pdu2Switches);
   localDataPoolMap.emplace(PoolIds::P60DOCK_SWITCHES, &p60Dock5VSwitch);
-  poolManager.subscribeForRegularPeriodicPacket(
-      subdp::RegularHkPeriodicParams(switcherSet.getSid(), false, 5.0));
+  poolManager.subscribeForDiagPeriodicPacket(
+      subdp::DiagnosticsHkPeriodicParams(switcherSet.getSid(), false, 5.0));
   return returnvalue::OK;
 }
 

mission/devices/SolarArrayDeploymentHandler.cpp

@@ -97,12 +97,19 @@ void SolarArrayDeploymentHandler::handleStateMachine() {
     // This should never fail
     channelAlternationCd.resetTimer();
     if (not fsmInfo.dryRun) {
-      sa2Off();
-      sa1On();
-      fsmInfo.alternationDummy = true;
+      if (fsmInfo.initChannel == 0) {
+        sa2Off();
+        sa1On();
+        fsmInfo.alternationDummy = true;
+      } else {
+        sa1Off();
+        sa2On();
+        fsmInfo.alternationDummy = false;
+      }
     }
     sif::info << "S/A Deployment: Burning" << std::endl;
     triggerEvent(BURN_PHASE_START, fsmInfo.burnCountdownMs, fsmInfo.dryRun);
+    channelAlternationCd.resetTimer();
     stateMachine = BURNING;
   }
   if (stateMachine == BURNING) {
@@ -219,7 +226,8 @@ bool SolarArrayDeploymentHandler::autonomousDeplForFile(sd::SdCard sdCard, const
   if (stateSwitch or firstAutonomousCycle) {
     if (deplState == AutonomousDeplState::FIRST_BURN or
         deplState == AutonomousDeplState::SECOND_BURN) {
-      startFsmOn(config::SA_DEPL_BURN_TIME_SECS, dryRun);
+      startFsmOn(config::SA_DEPL_BURN_TIME_SECS, (config::SA_DEPL_BURN_TIME_SECS / 2) * 1000, 0,
+                 dryRun);
     } else if (deplState == AutonomousDeplState::WAIT or deplState == AutonomousDeplState::DONE or
                deplState == AutonomousDeplState::INIT) {
       startFsmOff();
@@ -283,15 +291,19 @@ bool SolarArrayDeploymentHandler::checkMainPower(bool onOff) {
   return false;
 }
 
-bool SolarArrayDeploymentHandler::startFsmOn(uint32_t burnCountdownSecs, bool dryRun) {
+bool SolarArrayDeploymentHandler::startFsmOn(uint32_t burnCountdownSecs,
+                                             uint32_t channelAlternationIntervalMs,
+                                             uint8_t initChannel, bool dryRun) {
   if (stateMachine != StateMachine::IDLE) {
     return false;
   }
+  channelAlternationCd.setTimeout(channelAlternationIntervalMs);
   if (burnCountdownSecs > config::SA_DEPL_MAX_BURN_TIME) {
     burnCountdownSecs = config::SA_DEPL_MAX_BURN_TIME;
   }
   fsmInfo.dryRun = dryRun;
   fsmInfo.burnCountdownMs = burnCountdownSecs * 1000;
+  fsmInfo.initChannel = initChannel;
   stateMachine = StateMachine::MAIN_POWER_ON;
   retryCounter = 0;
   return true;
@@ -354,8 +366,9 @@ ReturnValue_t SolarArrayDeploymentHandler::executeAction(ActionId_t actionId,
     if (result != returnvalue::OK) {
       return result;
     }
-    uint32_t burnCountdown = cmd.getBurnTime();
-    if (not startFsmOn(burnCountdown, cmd.isDryRun())) {
+    uint32_t burnCountdown = cmd.getBurnTimeSecs();
+    if (not startFsmOn(burnCountdown, cmd.getSwitchIntervalMs(), cmd.getInitChannel(),
+                       cmd.isDryRun())) {
       return HasActionsIF::IS_BUSY;
     }
     actionActive = true;

mission/devices/SolarArrayDeploymentHandler.h

@@ -28,16 +28,24 @@ class ManualDeploymentCommand : public SerialLinkedListAdapter<SerializeIF> {
   ManualDeploymentCommand() { setLinks(); }
 
   void setLinks() {
-    setStart(&burnTime);
-    burnTime.setNext(&dryRun);
+    setStart(&burnTimeSecs);
+    burnTimeSecs.setNext(&switchIntervalMs);
+    switchIntervalMs.setNext(&initChannel);
+    initChannel.setNext(&dryRun);
   }
 
-  uint32_t getBurnTime() const { return burnTime.entry; }
+  uint32_t getBurnTimeSecs() const { return burnTimeSecs.entry; }
+
+  uint32_t getSwitchIntervalMs() const { return switchIntervalMs.entry; };
+
+  uint8_t getInitChannel() const { return initChannel.entry; };
 
   bool isDryRun() const { return dryRun.entry; }
 
  private:
-  SerializeElement<uint32_t> burnTime;
+  SerializeElement<uint32_t> burnTimeSecs;
+  SerializeElement<uint32_t> switchIntervalMs;
+  SerializeElement<uint8_t> initChannel;
   SerializeElement<uint8_t> dryRun;
 };
 
@@ -50,7 +58,16 @@ class SolarArrayDeploymentHandler : public ExecutableObjectIF,
                                     public SystemObject,
                                     public HasActionsIF {
  public:
-  //! Manual deployment of the solar arrays. Burn time and channels are supplied with TC parameters
+  //! Manual deployment of the solar arrays. Burn time, channel switch interval, initial
+  //! burn channel and dry run flag are supplied as parameters. There are following cases to
+  //! consider.
+  //!
+  //! - Channel switch interval greater or equal to burn time: Only burn one channel. The init
+  //!   burn channel parameter can be used to select which channel is burned.
+  //! - Channel switch interval half of burn time: Burn each channel for half of the burn time.
+  //!
+  //! The dry run flag can be used to avoid actually toggling IO pins and only test the
+  //! application logic.
   static constexpr DeviceCommandId_t DEPLOY_SOLAR_ARRAYS_MANUALLY = 0x05;
   static constexpr DeviceCommandId_t SWITCH_OFF_DEPLOYMENT = 0x06;
 
@@ -119,6 +136,7 @@ class SolarArrayDeploymentHandler : public ExecutableObjectIF,
     // DeploymentChannels channel;
     bool dryRun;
     bool alternationDummy = false;
+    uint8_t initChannel = 0;
     uint32_t burnCountdownMs = config::SA_DEPL_MAX_BURN_TIME;
   };
 
@@ -157,7 +175,8 @@ class SolarArrayDeploymentHandler : public ExecutableObjectIF,
   PeriodicOperationDivider opDivider = PeriodicOperationDivider(5);
   uint8_t retryCounter = 3;
 
-  bool startFsmOn(uint32_t burnCountdownSecs, bool dryRun);
+  bool startFsmOn(uint32_t burnCountdownSecs, uint32_t channelAlternationIntervalMs,
+                  uint8_t initChannel, bool dryRun);
   void startFsmOff();
 
   void finishFsm(ReturnValue_t resultForActionHelper);
@@ -175,8 +194,9 @@ class SolarArrayDeploymentHandler : public ExecutableObjectIF,
    */
   Countdown burnCountdown;
 
+  // Only initial value, new approach is to burn each channel half of the total burn time.
   Countdown channelAlternationCd =
-      Countdown(config::SA_DEPL_CHANNEL_ALTERNATION_INTERVAL_SECS * 1000);
+      Countdown(config::LEGACY_SA_DEPL_CHANNEL_ALTERNATION_INTERVAL_SECS * 1000);
 
   /**
    * The message queue id of the component commanding an action will be stored in this variable.

mission/devices/SyrlinksHandler.cpp

@@ -1,11 +1,12 @@
 #include <fsfw/datapool/PoolReadGuard.h>
 #include <fsfw/globalfunctions/CRC.h>
-#include <mission/devices/SyrlinksHkHandler.h>
+#include <mission/devices/SyrlinksHandler.h>
 
 #include "OBSWConfig.h"
+#include "mission/config/comCfg.h"
 
-SyrlinksHkHandler::SyrlinksHkHandler(object_id_t objectId, object_id_t comIF, CookieIF* comCookie,
-                                     power::Switch_t powerSwitch, FailureIsolationBase* customFdir)
+SyrlinksHandler::SyrlinksHandler(object_id_t objectId, object_id_t comIF, CookieIF* comCookie,
+                                 power::Switch_t powerSwitch, FailureIsolationBase* customFdir)
     : DeviceHandlerBase(objectId, comIF, comCookie, customFdir),
       rxDataset(this),
       txDataset(this),
@@ -16,26 +17,40 @@ SyrlinksHkHandler::SyrlinksHkHandler(object_id_t objectId, object_id_t comIF, Co
   }
 }
 
-SyrlinksHkHandler::~SyrlinksHkHandler() {}
+SyrlinksHandler::~SyrlinksHandler() = default;
 
-void SyrlinksHkHandler::doStartUp() {
-  switch (startupState) {
-    case StartupState::OFF: {
-      startupState = StartupState::ENABLE_TEMPERATURE_PROTECTION;
-      break;
+void SyrlinksHandler::doStartUp() {
+  if (internalState == InternalState::OFF) {
+    internalState = InternalState::ENABLE_TEMPERATURE_PROTECTION;
+    commandExecuted = false;
+  }
+  if (internalState == InternalState::ENABLE_TEMPERATURE_PROTECTION) {
+    if (commandExecuted) {
+      // Go to normal mode immediately and disable transmitter on startup.
+      setMode(_MODE_TO_NORMAL);
+      internalState = InternalState::IDLE;
+      commandExecuted = false;
     }
-    case StartupState::DONE: {
-      setMode(_MODE_TO_ON);
-      break;
-    }
-    default:
-      break;
   }
 }
 
-void SyrlinksHkHandler::doShutDown() { setMode(_MODE_POWER_DOWN); }
+void SyrlinksHandler::doShutDown() {
+  // In any case, always disable TX first.
+  if (internalState != InternalState::SET_TX_STANDBY) {
+    internalState = InternalState::SET_TX_STANDBY;
+    commandExecuted = false;
+  }
+  if (internalState == InternalState::SET_TX_STANDBY) {
+    if (commandExecuted) {
+      temperatureSet.setValidity(false, true);
+      internalState = InternalState::OFF;
+      commandExecuted = false;
+      setMode(_MODE_POWER_DOWN);
+    }
+  }
+}
 
-ReturnValue_t SyrlinksHkHandler::buildNormalDeviceCommand(DeviceCommandId_t* id) {
+ReturnValue_t SyrlinksHandler::buildNormalDeviceCommand(DeviceCommandId_t* id) {
   switch (nextCommand) {
     case (syrlinks::READ_RX_STATUS_REGISTERS):
       *id = syrlinks::READ_RX_STATUS_REGISTERS;
@@ -81,21 +96,41 @@ ReturnValue_t SyrlinksHkHandler::buildNormalDeviceCommand(DeviceCommandId_t* id)
   return buildCommandFromCommand(*id, nullptr, 0);
 }
 
-ReturnValue_t SyrlinksHkHandler::buildTransitionDeviceCommand(DeviceCommandId_t* id) {
-  switch (startupState) {
-    case StartupState::ENABLE_TEMPERATURE_PROTECTION: {
+ReturnValue_t SyrlinksHandler::buildTransitionDeviceCommand(DeviceCommandId_t* id) {
+  switch (internalState) {
+    case InternalState::ENABLE_TEMPERATURE_PROTECTION: {
       *id = syrlinks::WRITE_LCL_CONFIG;
       return buildCommandFromCommand(*id, nullptr, 0);
     }
+    case InternalState::SET_TX_MODULATION: {
+      *id = syrlinks::SET_TX_MODE_MODULATION;
+      return buildCommandFromCommand(*id, nullptr, 0);
+    }
+    case InternalState::SELECT_MODULATION_BPSK: {
+      *id = syrlinks::SET_WAVEFORM_BPSK;
+      return buildCommandFromCommand(*id, nullptr, 0);
+    }
+    case InternalState::SELECT_MODULATION_0QPSK: {
+      *id = syrlinks::SET_WAVEFORM_0QPSK;
+      return buildCommandFromCommand(*id, nullptr, 0);
+    }
+    case InternalState::SET_TX_CW: {
+      *id = syrlinks::SET_TX_MODE_CW;
+      return buildCommandFromCommand(*id, nullptr, 0);
+    }
+    case InternalState::SET_TX_STANDBY: {
+      *id = syrlinks::SET_TX_MODE_STANDBY;
+      return buildCommandFromCommand(*id, nullptr, 0);
+    }
     default:
       break;
   }
   return NOTHING_TO_SEND;
 }
 
-ReturnValue_t SyrlinksHkHandler::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
-                                                         const uint8_t* commandData,
-                                                         size_t commandDataLen) {
+ReturnValue_t SyrlinksHandler::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
+                                                       const uint8_t* commandData,
+                                                       size_t commandDataLen) {
   switch (deviceCommand) {
     case (syrlinks::RESET_UNIT): {
       prepareCommand(resetCommand, deviceCommand);
@@ -157,11 +192,11 @@ ReturnValue_t SyrlinksHkHandler::buildCommandFromCommand(DeviceCommandId_t devic
       prepareCommand(tempBasebandBoardLowByte, deviceCommand);
       return returnvalue::OK;
     }
-    case (syrlinks::CONFIG_BPSK): {
+    case (syrlinks::SET_WAVEFORM_BPSK): {
       prepareCommand(configBPSK, deviceCommand);
       return returnvalue::OK;
     }
-    case (syrlinks::CONFIG_OQPSK): {
+    case (syrlinks::SET_WAVEFORM_0QPSK): {
       prepareCommand(configOQPSK, deviceCommand);
       return returnvalue::OK;
     }
@@ -181,7 +216,7 @@ ReturnValue_t SyrlinksHkHandler::buildCommandFromCommand(DeviceCommandId_t devic
   return returnvalue::FAILED;
 }
 
-void SyrlinksHkHandler::fillCommandAndReplyMap() {
+void SyrlinksHandler::fillCommandAndReplyMap() {
   this->insertInCommandAndReplyMap(syrlinks::RESET_UNIT, 1, nullptr, syrlinks::ACK_SIZE, false,
                                    true, syrlinks::ACK_REPLY);
   this->insertInCommandAndReplyMap(syrlinks::SET_TX_MODE_STANDBY, 1, nullptr, syrlinks::ACK_SIZE,
@@ -192,10 +227,10 @@ void SyrlinksHkHandler::fillCommandAndReplyMap() {
                                    true, syrlinks::ACK_REPLY);
   this->insertInCommandAndReplyMap(syrlinks::WRITE_LCL_CONFIG, 1, nullptr, syrlinks::ACK_SIZE,
                                    false, true, syrlinks::ACK_REPLY);
-  this->insertInCommandAndReplyMap(syrlinks::CONFIG_BPSK, 1, nullptr, syrlinks::ACK_SIZE, false,
-                                   true, syrlinks::ACK_REPLY);
-  this->insertInCommandAndReplyMap(syrlinks::CONFIG_OQPSK, 1, nullptr, syrlinks::ACK_SIZE, false,
-                                   true, syrlinks::ACK_REPLY);
+  this->insertInCommandAndReplyMap(syrlinks::SET_WAVEFORM_BPSK, 1, nullptr, syrlinks::ACK_SIZE,
+                                   false, true, syrlinks::ACK_REPLY);
+  this->insertInCommandAndReplyMap(syrlinks::SET_WAVEFORM_0QPSK, 1, nullptr, syrlinks::ACK_SIZE,
+                                   false, true, syrlinks::ACK_REPLY);
   this->insertInCommandMap(syrlinks::ENABLE_DEBUG);
   this->insertInCommandMap(syrlinks::DISABLE_DEBUG);
   this->insertInCommandAndReplyMap(syrlinks::READ_LCL_CONFIG, 1, nullptr,
@@ -220,8 +255,8 @@ void SyrlinksHkHandler::fillCommandAndReplyMap() {
                                    syrlinks::RX_STATUS_REGISTERS_REPLY_SIZE);
 }
 
-ReturnValue_t SyrlinksHkHandler::scanForReply(const uint8_t* start, size_t remainingSize,
-                                              DeviceCommandId_t* foundId, size_t* foundLen) {
+ReturnValue_t SyrlinksHandler::scanForReply(const uint8_t* start, size_t remainingSize,
+                                            DeviceCommandId_t* foundId, size_t* foundLen) {
   ReturnValue_t result = returnvalue::OK;
 
   if (*start != '<') {
@@ -251,7 +286,7 @@ ReturnValue_t SyrlinksHkHandler::scanForReply(const uint8_t* start, size_t remai
   return result;
 }
 
-ReturnValue_t SyrlinksHkHandler::getSwitches(const uint8_t** switches, uint8_t* numberOfSwitches) {
+ReturnValue_t SyrlinksHandler::getSwitches(const uint8_t** switches, uint8_t* numberOfSwitches) {
   if (powerSwitch == power::NO_SWITCH) {
     return DeviceHandlerBase::NO_SWITCH;
   }
@@ -260,7 +295,7 @@ ReturnValue_t SyrlinksHkHandler::getSwitches(const uint8_t** switches, uint8_t*
   return returnvalue::OK;
 }
 
-ReturnValue_t SyrlinksHkHandler::interpretDeviceReply(DeviceCommandId_t id, const uint8_t* packet) {
+ReturnValue_t SyrlinksHandler::interpretDeviceReply(DeviceCommandId_t id, const uint8_t* packet) {
   ReturnValue_t result;
 
   switch (id) {
@@ -363,6 +398,7 @@ ReturnValue_t SyrlinksHkHandler::interpretDeviceReply(DeviceCommandId_t id, cons
       tempBasebandBoard = calcTempVal(rawTempBasebandBoard);
       PoolReadGuard rg(&temperatureSet);
       temperatureSet.temperatureBasebandBoard = tempBasebandBoard;
+      temperatureSet.temperatureBasebandBoard.setValid(true);
       if (debugMode) {
         sif::info << "Syrlinks temperature baseband board: " << tempBasebandBoard << "  °C"
                   << std::endl;
@@ -394,6 +430,7 @@ ReturnValue_t SyrlinksHkHandler::interpretDeviceReply(DeviceCommandId_t id, cons
       tempPowerAmplifier = calcTempVal(rawTempPowerAmplifier);
       PoolReadGuard rg(&temperatureSet);
       temperatureSet.temperaturePowerAmplifier = tempPowerAmplifier;
+      temperatureSet.temperaturePowerAmplifier.setValid(true);
       if (debugMode) {
         sif::info << "Syrlinks temperature power amplifier board: " << tempPowerAmplifier << "  °C"
                   << std::endl;
@@ -409,7 +446,7 @@ ReturnValue_t SyrlinksHkHandler::interpretDeviceReply(DeviceCommandId_t id, cons
   return returnvalue::OK;
 }
 
-LocalPoolDataSetBase* SyrlinksHkHandler::getDataSetHandle(sid_t sid) {
+LocalPoolDataSetBase* SyrlinksHandler::getDataSetHandle(sid_t sid) {
   if (sid == rxDataset.getSid()) {
     return &rxDataset;
   } else if (sid == txDataset.getSid()) {
@@ -422,13 +459,13 @@ LocalPoolDataSetBase* SyrlinksHkHandler::getDataSetHandle(sid_t sid) {
   }
 }
 
-std::string SyrlinksHkHandler::convertUint16ToHexString(uint16_t intValue) {
+std::string SyrlinksHandler::convertUint16ToHexString(uint16_t intValue) {
   std::stringstream stream;
   stream << std::setfill('0') << std::setw(4) << std::hex << std::uppercase << intValue;
   return stream.str();
 }
 
-uint8_t SyrlinksHkHandler::convertHexStringToUint8(const char* twoChars) {
+uint8_t SyrlinksHandler::convertHexStringToUint8(const char* twoChars) {
   uint32_t value;
   std::string hexString(twoChars, 2);
   std::stringstream stream;
@@ -437,36 +474,13 @@ uint8_t SyrlinksHkHandler::convertHexStringToUint8(const char* twoChars) {
   return static_cast<uint8_t>(value);
 }
 
-uint16_t SyrlinksHkHandler::convertHexStringToUint16(const char* fourChars) {
+uint16_t SyrlinksHandler::convertHexStringToUint16(const char* fourChars) {
   uint16_t value = 0;
   value = convertHexStringToUint8(fourChars) << 8 | convertHexStringToUint8(fourChars + 2);
   return value;
 }
 
-uint32_t SyrlinksHkHandler::convertHexStringToUint32(const char* characters,
-                                                     uint8_t numberOfChars) {
-  uint32_t value = 0;
-
-  switch (numberOfChars) {
-    case 6:
-      value = convertHexStringToUint8(characters) << 16 |
-              convertHexStringToUint8(characters + 2) << 8 |
-              convertHexStringToUint8(characters + 4);
-      return value;
-    case 8:
-      value = convertHexStringToUint8(characters) << 24 |
-              convertHexStringToUint8(characters + 2) << 16 |
-              convertHexStringToUint8(characters + 4) << 8 |
-              convertHexStringToUint8(characters + 4);
-      return value;
-    default:
-      sif::debug << "SyrlinksHkHandler::convertHexStringToUint32: Invalid number of characters. "
-                 << "Must be either 6 or 8" << std::endl;
-      return 0;
-  }
-}
-
-ReturnValue_t SyrlinksHkHandler::parseReplyStatus(const char* status) {
+ReturnValue_t SyrlinksHandler::parseReplyStatus(const char* status) {
   switch (*status) {
     case '0':
       return returnvalue::OK;
@@ -498,7 +512,7 @@ ReturnValue_t SyrlinksHkHandler::parseReplyStatus(const char* status) {
   }
 }
 
-ReturnValue_t SyrlinksHkHandler::verifyReply(const uint8_t* packet, uint8_t size) {
+ReturnValue_t SyrlinksHandler::verifyReply(const uint8_t* packet, uint8_t size) {
   int result = 0;
   /* Calculate crc from received packet */
   uint16_t crc =
@@ -518,28 +532,31 @@ ReturnValue_t SyrlinksHkHandler::verifyReply(const uint8_t* packet, uint8_t size
   return returnvalue::OK;
 }
 
-void SyrlinksHkHandler::parseRxStatusRegistersReply(const uint8_t* packet) {
+void SyrlinksHandler::parseRxStatusRegistersReply(const uint8_t* packet) {
   PoolReadGuard readHelper(&rxDataset);
   uint16_t offset = syrlinks::MESSAGE_HEADER_SIZE;
   rxDataset.rxStatus = convertHexStringToUint8(reinterpret_cast<const char*>(packet + offset));
   offset += 2;
   rxDataset.rxSensitivity =
-      convertHexStringToUint32(reinterpret_cast<const char*>(packet + offset), 6);
+      convertHexStringTo32bit<uint32_t>(reinterpret_cast<const char*>(packet + offset), 6);
   offset += 6;
   rxDataset.rxFrequencyShift =
-      convertHexStringToUint32(reinterpret_cast<const char*>(packet + offset), 6);
+      convertHexStringTo32bit<int32_t>(reinterpret_cast<const char*>(packet + offset), 6);
   offset += 6;
   rxDataset.rxIqPower = convertHexStringToUint16(reinterpret_cast<const char*>(packet + offset));
   offset += 4;
   rxDataset.rxAgcValue = convertHexStringToUint16(reinterpret_cast<const char*>(packet + offset));
   offset += 4;
   offset += 2;  // reserved register
-  rxDataset.rxDemodEb = convertHexStringToUint32(reinterpret_cast<const char*>(packet + offset), 6);
+  rxDataset.rxDemodEb =
+      convertHexStringTo32bit<uint32_t>(reinterpret_cast<const char*>(packet + offset), 6);
   offset += 6;
-  rxDataset.rxDemodN0 = convertHexStringToUint32(reinterpret_cast<const char*>(packet + offset), 6);
+  rxDataset.rxDemodN0 =
+      convertHexStringTo32bit<uint32_t>(reinterpret_cast<const char*>(packet + offset), 6);
   offset += 6;
   rxDataset.rxDataRate = convertHexStringToUint8(reinterpret_cast<const char*>(packet + offset));
 
+  rxDataset.setValidity(true, true);
   if (debugMode) {
 #if OBSW_VERBOSE_LEVEL >= 1
     sif::info << "Syrlinks RX Status: 0x" << std::hex << (unsigned int)rxDataset.rxStatus.value
@@ -555,7 +572,7 @@ void SyrlinksHkHandler::parseRxStatusRegistersReply(const uint8_t* packet) {
   }
 }
 
-void SyrlinksHkHandler::parseLclConfigReply(const uint8_t* packet) {
+void SyrlinksHandler::parseLclConfigReply(const uint8_t* packet) {
   uint16_t offset = syrlinks::MESSAGE_HEADER_SIZE;
   uint8_t lclConfig = convertHexStringToUint8(reinterpret_cast<const char*>(packet + offset));
   if (debugMode) {
@@ -564,51 +581,54 @@ void SyrlinksHkHandler::parseLclConfigReply(const uint8_t* packet) {
   }
 }
 
-void SyrlinksHkHandler::parseTxStatusReply(const uint8_t* packet) {
+void SyrlinksHandler::parseTxStatusReply(const uint8_t* packet) {
   PoolReadGuard readHelper(&txDataset);
   uint16_t offset = syrlinks::MESSAGE_HEADER_SIZE;
   txDataset.txStatus = convertHexStringToUint8(reinterpret_cast<const char*>(packet + offset));
+  txDataset.txStatus.setValid(true);
   if (debugMode) {
     sif::info << "Syrlinks TX Status: 0x" << std::hex << (unsigned int)txDataset.txStatus.value
               << std::endl;
   }
 }
 
-void SyrlinksHkHandler::parseTxWaveformReply(const uint8_t* packet) {
+void SyrlinksHandler::parseTxWaveformReply(const uint8_t* packet) {
   PoolReadGuard readHelper(&txDataset);
   uint16_t offset = syrlinks::MESSAGE_HEADER_SIZE;
   txDataset.txWaveform = convertHexStringToUint8(reinterpret_cast<const char*>(packet + offset));
+  txDataset.txWaveform.setValid(true);
   if (debugMode) {
     sif::info << "Syrlinks TX Waveform: 0x" << std::hex << (unsigned int)txDataset.txWaveform.value
               << std::endl;
   }
 }
 
-void SyrlinksHkHandler::parseAgcLowByte(const uint8_t* packet) {
+void SyrlinksHandler::parseAgcLowByte(const uint8_t* packet) {
   PoolReadGuard readHelper(&txDataset);
   uint16_t offset = syrlinks::MESSAGE_HEADER_SIZE;
   txDataset.txAgcValue = agcValueHighByte << 8 |
                          convertHexStringToUint8(reinterpret_cast<const char*>(packet + offset));
+  txDataset.txAgcValue.setValid(true);
   if (debugMode) {
     sif::info << "Syrlinks TX AGC Value: " << txDataset.txAgcValue << std::endl;
   }
 }
 
-void SyrlinksHkHandler::parseAgcHighByte(const uint8_t* packet) {
+void SyrlinksHandler::parseAgcHighByte(const uint8_t* packet) {
   PoolReadGuard readHelper(&txDataset);
   uint16_t offset = syrlinks::MESSAGE_HEADER_SIZE;
   agcValueHighByte = convertHexStringToUint8(reinterpret_cast<const char*>(packet + offset));
 }
 
-void SyrlinksHkHandler::setNormalDatapoolEntriesInvalid() {}
+void SyrlinksHandler::setNormalDatapoolEntriesInvalid() {}
 
-uint32_t SyrlinksHkHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 500; }
+uint32_t SyrlinksHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 2500; }
 
-ReturnValue_t SyrlinksHkHandler::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
-                                                         LocalDataPoolManager& poolManager) {
+ReturnValue_t SyrlinksHandler::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
+                                                       LocalDataPoolManager& poolManager) {
   localDataPoolMap.emplace(syrlinks::RX_STATUS, new PoolEntry<uint8_t>({0}));
   localDataPoolMap.emplace(syrlinks::RX_SENSITIVITY, new PoolEntry<uint32_t>({0}));
-  localDataPoolMap.emplace(syrlinks::RX_FREQUENCY_SHIFT, new PoolEntry<uint32_t>({0}));
+  localDataPoolMap.emplace(syrlinks::RX_FREQUENCY_SHIFT, new PoolEntry<int32_t>({0}));
   localDataPoolMap.emplace(syrlinks::RX_IQ_POWER, new PoolEntry<uint16_t>({0}));
   localDataPoolMap.emplace(syrlinks::RX_AGC_VALUE, new PoolEntry<uint16_t>({0}));
   localDataPoolMap.emplace(syrlinks::RX_DEMOD_EB, new PoolEntry<uint32_t>({0}));
@@ -630,26 +650,162 @@ ReturnValue_t SyrlinksHkHandler::initializeLocalDataPool(localpool::DataPool& lo
   return returnvalue::OK;
 }
 
-void SyrlinksHkHandler::setModeNormal() { setMode(MODE_NORMAL); }
+void SyrlinksHandler::setModeNormal() { setMode(MODE_NORMAL); }
 
-float SyrlinksHkHandler::calcTempVal(uint16_t raw) { return 0.126984 * raw - 67.87; }
+float SyrlinksHandler::calcTempVal(uint16_t raw) { return 0.126984 * raw - 67.87; }
 
-ReturnValue_t SyrlinksHkHandler::handleAckReply(const uint8_t* packet) {
+ReturnValue_t SyrlinksHandler::handleAckReply(const uint8_t* packet) {
   ReturnValue_t result =
       parseReplyStatus(reinterpret_cast<const char*>(packet + syrlinks::MESSAGE_HEADER_SIZE));
-  if (rememberCommandId == syrlinks::WRITE_LCL_CONFIG and result != returnvalue::OK) {
-    startupState = StartupState::OFF;
-  } else if (rememberCommandId == syrlinks::WRITE_LCL_CONFIG and result == returnvalue::OK) {
-    startupState = StartupState::DONE;
+  switch (rememberCommandId) {
+    case (syrlinks::WRITE_LCL_CONFIG): {
+      if (isTransitionalMode()) {
+        if (result != returnvalue::OK) {
+          internalState = InternalState::OFF;
+        } else if (result == returnvalue::OK) {
+          commandExecuted = true;
+        }
+      }
+      break;
+    }
+    case (syrlinks::SET_WAVEFORM_BPSK):
+    case (syrlinks::SET_WAVEFORM_0QPSK):
+    case (syrlinks::SET_TX_MODE_STANDBY):
+    case (syrlinks::SET_TX_MODE_MODULATION):
+    case (syrlinks::SET_TX_MODE_CW): {
+      if (result == returnvalue::OK and isTransitionalMode()) {
+        commandExecuted = true;
+      }
+      break;
+    }
+  }
+  switch (rememberCommandId) {
+    case (syrlinks::SET_TX_MODE_STANDBY): {
+      triggerEvent(syrlinks::TX_OFF, 0, 0);
+      break;
+    }
+    case (syrlinks::SET_TX_MODE_MODULATION):
+    case (syrlinks::SET_TX_MODE_CW): {
+      triggerEvent(syrlinks::TX_ON, getSubmode(), static_cast<uint8_t>(com::getCurrentDatarate()));
+      break;
+    }
   }
   return result;
 }
 
-void SyrlinksHkHandler::prepareCommand(std::string command, DeviceCommandId_t commandId) {
+ReturnValue_t SyrlinksHandler::isModeCombinationValid(Mode_t mode, Submode_t submode) {
+  if (mode == HasModesIF::MODE_ON or mode == DeviceHandlerIF::MODE_NORMAL) {
+    if (submode >= com::Submode::NUM_SUBMODES) {
+      return HasModesIF::INVALID_SUBMODE;
+    }
+    return returnvalue::OK;
+  }
+  return DeviceHandlerBase::isModeCombinationValid(mode, submode);
+}
+
+ReturnValue_t SyrlinksHandler::getParameter(uint8_t domainId, uint8_t uniqueId,
+                                            ParameterWrapper* parameterWrapper,
+                                            const ParameterWrapper* newValues,
+                                            uint16_t startAtIndex) {
+  return DeviceHandlerBase::getParameter(domainId, uniqueId, parameterWrapper, newValues,
+                                         startAtIndex);
+}
+
+void SyrlinksHandler::prepareCommand(std::string command, DeviceCommandId_t commandId) {
   command.copy(reinterpret_cast<char*>(commandBuffer), command.size(), 0);
   rawPacketLen = command.size();
   rememberCommandId = commandId;
   rawPacket = commandBuffer;
 }
 
-void SyrlinksHkHandler::setDebugMode(bool enable) { this->debugMode = enable; }
+void SyrlinksHandler::setDebugMode(bool enable) { this->debugMode = enable; }
+
+void SyrlinksHandler::doTransition(Mode_t modeFrom, Submode_t subModeFrom) {
+  Mode_t tgtMode = getBaseMode(getMode());
+  auto commandDone = [&]() {
+    setMode(tgtMode);
+    internalState = InternalState::IDLE;
+  };
+  auto txOnHandler = [&](InternalState selMod) {
+    if (internalState == InternalState::IDLE) {
+      commandExecuted = false;
+      internalState = selMod;
+    }
+    // Select modulation first (BPSK or 0QPSK).
+    if (internalState == selMod) {
+      if (commandExecuted) {
+        internalState = InternalState::SET_TX_MODULATION;
+        commandExecuted = false;
+      }
+    }
+    // Now go into modulation mode.
+    if (internalState == InternalState::SET_TX_MODULATION) {
+      if (commandExecuted) {
+        commandDone();
+        return true;
+      }
+    }
+    return false;
+  };
+  auto txStandbyHandler = [&]() {
+    if (internalState == InternalState::IDLE) {
+      internalState = InternalState::SET_TX_STANDBY;
+      commandExecuted = false;
+    }
+    if (internalState == InternalState::SET_TX_STANDBY) {
+      if (commandExecuted) {
+        commandDone();
+        return;
+      }
+    }
+  };
+  if (tgtMode == HasModesIF::MODE_ON or tgtMode == DeviceHandlerIF::MODE_NORMAL) {
+    switch (getSubmode()) {
+      case (com::Submode::RX_AND_TX_DEFAULT_DATARATE): {
+        auto currentDatarate = com::getCurrentDatarate();
+        if (currentDatarate == com::Datarate::LOW_RATE_MODULATION_BPSK) {
+          if (txOnHandler(InternalState::SELECT_MODULATION_BPSK)) {
+            return;
+          }
+        } else if (currentDatarate == com::Datarate::HIGH_RATE_MODULATION_0QPSK) {
+          if (txOnHandler(InternalState::SELECT_MODULATION_0QPSK)) {
+            return;
+          }
+        }
+        break;
+      }
+      case (com::Submode::RX_AND_TX_LOW_DATARATE): {
+        if (txOnHandler(InternalState::SELECT_MODULATION_BPSK)) {
+          return;
+        }
+        break;
+      }
+      case (com::Submode::RX_AND_TX_HIGH_DATARATE): {
+        if (txOnHandler(InternalState::SELECT_MODULATION_0QPSK)) {
+          return;
+        }
+        break;
+      }
+      case (com::Submode::RX_ONLY): {
+        txStandbyHandler();
+        return;
+      }
+      case (com::Submode::RX_AND_TX_CW): {
+        if (internalState == InternalState::IDLE) {
+          internalState = InternalState::SET_TX_STANDBY;
+          commandExecuted = false;
+        }
+        if (commandExecuted) {
+          commandDone();
+          return;
+        }
+        break;
+      }
+      default: {
+        commandDone();
+      }
+    }
+  } else if (tgtMode == HasModesIF::MODE_OFF) {
+    txStandbyHandler();
+  }
+}

mission/devices/SyrlinksHandler.h

@@ -1,5 +1,5 @@
-#ifndef MISSION_DEVICES_SYRLINKSHKHANDLER_H_
-#define MISSION_DEVICES_SYRLINKSHKHANDLER_H_
+#ifndef MISSION_DEVICES_SYRLINKSHANDLER_H_
+#define MISSION_DEVICES_SYRLINKSHANDLER_H_
 
 #include <string.h>
 
@@ -7,6 +7,7 @@
 #include "fsfw/devicehandlers/DeviceHandlerBase.h"
 #include "fsfw/timemanager/Countdown.h"
 #include "fsfw_hal/linux/gpio/Gpio.h"
+#include "mission/comDefs.h"
 #include "mission/devices/devicedefinitions/SyrlinksDefinitions.h"
 #include "returnvalues/classIds.h"
 
@@ -18,11 +19,11 @@
  *
  * @author	J. Meier
  */
-class SyrlinksHkHandler : public DeviceHandlerBase {
+class SyrlinksHandler : public DeviceHandlerBase {
  public:
-  SyrlinksHkHandler(object_id_t objectId, object_id_t comIF, CookieIF* comCookie,
-                    power::Switch_t powerSwitch, FailureIsolationBase* customFdir);
-  virtual ~SyrlinksHkHandler();
+  SyrlinksHandler(object_id_t objectId, object_id_t comIF, CookieIF* comCookie,
+                  power::Switch_t powerSwitch, FailureIsolationBase* customFdir);
+  virtual ~SyrlinksHandler();
 
   /**
    * @brief   Sets mode to MODE_NORMAL. Can be used for debugging.
@@ -34,6 +35,8 @@ class SyrlinksHkHandler : public DeviceHandlerBase {
  protected:
   void doStartUp() override;
   void doShutDown() override;
+  void doTransition(Mode_t modeFrom, Submode_t subModeFrom) override;
+  ReturnValue_t isModeCombinationValid(Mode_t mode, Submode_t submode) override;
   ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t* id) override;
   ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t* id) override;
   ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand, const uint8_t* commandData,
@@ -49,6 +52,10 @@ class SyrlinksHkHandler : public DeviceHandlerBase {
                                         LocalDataPoolManager& poolManager) override;
   LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
 
+  // Parameter IF
+  ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueId, ParameterWrapper* parameterWrapper,
+                             const ParameterWrapper* newValues, uint16_t startAtIndex) override;
+
  private:
   static const uint8_t INTERFACE_ID = CLASS_ID::SYRLINKS_HANDLER;
 
@@ -104,12 +111,22 @@ class SyrlinksHkHandler : public DeviceHandlerBase {
   uint16_t rawTempBasebandBoard = 0;
   float tempPowerAmplifier = 0;
   float tempBasebandBoard = 0;
+  bool commandExecuted = false;
 
   uint8_t commandBuffer[syrlinks::MAX_COMMAND_SIZE];
 
-  enum class StartupState { OFF, ENABLE_TEMPERATURE_PROTECTION, DONE };
+  enum class InternalState {
+    OFF,
+    ENABLE_TEMPERATURE_PROTECTION,
+    SELECT_MODULATION_BPSK,
+    SELECT_MODULATION_0QPSK,
+    SET_TX_MODULATION,
+    SET_TX_CW,
+    SET_TX_STANDBY,
+    IDLE
+  };
 
-  StartupState startupState = StartupState::OFF;
+  InternalState internalState = InternalState::OFF;
 
   /**
    * This object is used to store the id of the next command to execute. This controls the
@@ -147,15 +164,16 @@ class SyrlinksHkHandler : public DeviceHandlerBase {
   uint16_t convertHexStringToUint16(const char* fourChars);
 
   /**
-   * @brief   Function converts a hex number represented by 6 or 8 characters to an uint32_t.
+   * @brief   Function converts a hex number represented by 6 or 8 characters to an uint32_t or
+   * int32_t, depending on the template parameter.
    *
    * @param characters    Pointer to the hex characters array.
    * @param numberOfChars Number of characters representing the hex value. Must be 6 or 8.
    *
-   * @return  The uint32_t value.
+   * @return  The value.
    */
-  uint32_t convertHexStringToUint32(const char* characters, uint8_t numberOfChars);
-
+  template <typename T>
+  T convertHexStringTo32bit(const char* characters, uint8_t numberOfChars);
   /**
    * @brief   This function parses the status reply
    * @param status    Pointer to the status information.
@@ -214,4 +232,33 @@ class SyrlinksHkHandler : public DeviceHandlerBase {
   void prepareCommand(std::string command, DeviceCommandId_t commandId);
 };
 
-#endif /* MISSION_DEVICES_SYRLINKSHKHANDLER_H_ */
+template <typename T>
+T SyrlinksHandler::convertHexStringTo32bit(const char* characters, uint8_t numberOfChars) {
+  if (sizeof(T) < 4) {
+    sif::error << "SyrlinksHkHandler::convertHexStringToRaw: Only works for 32-bit conversion"
+               << std::endl;
+  }
+  T value = 0;
+
+  switch (numberOfChars) {
+    case 6:
+      // The bitshift trickery required is necessary when creating an int32_t from a
+      // 24 bit signed value.
+      value = ((convertHexStringToUint8(characters) << 24) |
+               (convertHexStringToUint8(characters + 2) << 16) |
+               (convertHexStringToUint8(characters + 4) << 8)) >>
+              8;
+      return value;
+    case 8:
+      value = convertHexStringToUint8(characters) << 24 |
+              convertHexStringToUint8(characters + 2) << 16 |
+              convertHexStringToUint8(characters + 4) << 8 |
+              convertHexStringToUint8(characters + 4);
+      return value;
+    default:
+      sif::debug << "SyrlinksHkHandler::convertHexStringToUint32: Invalid number of characters. "
+                 << "Must be either 6 or 8" << std::endl;
+      return 0;
+  }
+}
+#endif /* MISSION_DEVICES_SYRLINKSHANDLER_H_ */

mission/devices/Tmp1075Handler.cpp

@@ -17,7 +17,10 @@ void Tmp1075Handler::doStartUp() {
   }
 }
 
-void Tmp1075Handler::doShutDown() { setMode(_MODE_POWER_DOWN); }
+void Tmp1075Handler::doShutDown() {
+  communicationStep = CommunicationStep::START_ADC_CONVERSION;
+  setMode(_MODE_POWER_DOWN);
+}
 
 ReturnValue_t Tmp1075Handler::buildNormalDeviceCommand(DeviceCommandId_t *id) {
   if (communicationStep == CommunicationStep::START_ADC_CONVERSION) {
@@ -33,7 +36,7 @@ ReturnValue_t Tmp1075Handler::buildNormalDeviceCommand(DeviceCommandId_t *id) {
 }
 
 ReturnValue_t Tmp1075Handler::buildTransitionDeviceCommand(DeviceCommandId_t *id) {
-  return returnvalue::OK;
+  return NOTHING_TO_SEND;
 }
 
 ReturnValue_t Tmp1075Handler::buildCommandFromCommand(DeviceCommandId_t deviceCommand,

mission/devices/devicedefinitions/GPSDefinitions.h

@@ -63,7 +63,7 @@ class GpsPrimaryDataset : public StaticLocalDataSet<18> {
       lp_var_t<uint32_t>(sid.objectId, GpsHyperion::UNIX_SECONDS, this);
 
  private:
-  friend class GPSHyperionLinuxController;
+  friend class GpsHyperionLinuxController;
   GpsPrimaryDataset(HasLocalDataPoolIF* hkOwner)
       : StaticLocalDataSet(hkOwner, GpsHyperion::DATASET_ID) {}
 };

mission/devices/devicedefinitions/GyroADIS1650XDefinitions.h

@@ -13,7 +13,24 @@ enum class Type { ADIS16505, ADIS16507 };
 static constexpr size_t MAXIMUM_REPLY_SIZE = 64;
 static constexpr uint8_t WRITE_MASK = 0b1000'0000;
 
-static constexpr uint32_t GYRO_RANGE = 125;
+// Ranges in deg / s
+static constexpr double RANGE_UNSET = 0.0;
+static constexpr double RANGE_1BMLZ = 125.0;
+static constexpr double RANGE_2BMLZ = 500.0;
+static constexpr double RANGE_3BMLZ = 2000.0;
+// Sensitivities in deg/s/LSB
+static constexpr double SENSITIVITY_UNSET = 0.0;
+static constexpr double SENSITIVITY_1BMLZ = 0.00625;
+static constexpr double SENSITIVITY_2BMLZ = 0.025;
+static constexpr double SENSITIVITY_3BMLZ = 0.1;
+
+enum RangMdlBitfield {
+  RANGE_125_1BMLZ = 0b00,
+  RANGE_500_2BMLZ = 0b01,
+  RESERVED = 0b10,
+  RANGE_2000_3BMLZ = 0b11
+};
+
 static constexpr uint32_t ACCELEROMETER_RANGE_16507 = 392;
 static constexpr float ACCELEROMETER_RANGE_16505 = 78.4;
 
@@ -33,6 +50,7 @@ static constexpr dur_millis_t SELF_TEST_BREAK = 24;
 
 static constexpr uint8_t DIAG_STAT_REG = 0x02;
 static constexpr uint8_t FILTER_CTRL_REG = 0x5c;
+static constexpr uint8_t RANG_MDL_REG = 0x5e;
 static constexpr uint8_t MSC_CTRL_REG = 0x60;
 static constexpr uint8_t DEC_RATE_REG = 0x64;
 static constexpr uint8_t GLOB_CMD = 0x68;
@@ -54,7 +72,7 @@ static constexpr uint16_t BURST_SEL_BIT = 1 << 8;
 static constexpr uint16_t LIN_ACCEL_COMPENSATION_BIT = 1 << 7;
 static constexpr uint16_t POINT_PERCUSSION_COMPENSATION_BIT = 1 << 6;
 
-static constexpr size_t CONFIG_READOUT_SIZE = 10 + 2;
+static constexpr size_t CONFIG_READOUT_SIZE = 12 + 2;
 static constexpr size_t SENSOR_READOUT_SIZE = 20 + 2;
 
 static constexpr uint32_t ADIS_DATASET_ID = READ_SENSOR_DATA;
@@ -78,6 +96,7 @@ enum PrimaryPoolIds : lp_id_t {
   TEMPERATURE,
   DIAG_STAT_REGISTER,
   FILTER_SETTINGS,
+  RANG_MDL,
   MSC_CTRL_REGISTER,
   DEC_RATE_REGISTER,
 };
@@ -130,6 +149,7 @@ class AdisGyroConfigDataset : public StaticLocalDataSet<5> {
 
   lp_var_t<uint16_t> diagStatReg = lp_var_t<uint16_t>(sid.objectId, ADIS1650X::DIAG_STAT_REGISTER);
   lp_var_t<uint8_t> filterSetting = lp_var_t<uint8_t>(sid.objectId, ADIS1650X::FILTER_SETTINGS);
+  lp_var_t<uint16_t> rangMdl = lp_var_t<uint16_t>(sid.objectId, ADIS1650X::RANG_MDL);
   lp_var_t<uint16_t> mscCtrlReg = lp_var_t<uint16_t>(sid.objectId, ADIS1650X::MSC_CTRL_REGISTER);
   lp_var_t<uint16_t> decRateReg = lp_var_t<uint16_t>(sid.objectId, ADIS1650X::DEC_RATE_REGISTER);
 

mission/devices/devicedefinitions/SyrlinksDefinitions.h

@@ -6,9 +6,15 @@
 
 namespace syrlinks {
 
+enum class ParameterId : uint8_t { DATARATE = 0 };
+
 static constexpr uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::SYRLINKS;
 
 static constexpr Event FDIR_REACTION_IGNORED = event::makeEvent(SUBSYSTEM_ID, 0, severity::MEDIUM);
+//! [EXPORT] : [COMMENT] Transmitter is on now. P1: Submode, P2: Current default datarate.
+static constexpr Event TX_ON = event::makeEvent(SUBSYSTEM_ID, 1, severity::INFO);
+//! [EXPORT] : [COMMENT] Transmitter is off now.
+static constexpr Event TX_OFF = event::makeEvent(SUBSYSTEM_ID, 2, severity::INFO);
 
 static const DeviceCommandId_t NONE = 0;
 static const DeviceCommandId_t RESET_UNIT = 1;
@@ -31,9 +37,9 @@ static const DeviceCommandId_t TEMP_POWER_AMPLIFIER_HIGH_BYTE = 13;
 static const DeviceCommandId_t TEMP_POWER_AMPLIFIER_LOW_BYTE = 14;
 static const DeviceCommandId_t TEMP_BASEBAND_BOARD_HIGH_BYTE = 15;
 static const DeviceCommandId_t TEMP_BASEBAND_BOARD_LOW_BYTE = 16;
-static const DeviceCommandId_t CONFIG_OQPSK = 17;
+static const DeviceCommandId_t SET_WAVEFORM_0QPSK = 17;
 // After startup syrlinks always in BSPK configuration
-static const DeviceCommandId_t CONFIG_BPSK = 18;
+static const DeviceCommandId_t SET_WAVEFORM_BPSK = 18;
 static const DeviceCommandId_t ENABLE_DEBUG = 20;
 static const DeviceCommandId_t DISABLE_DEBUG = 21;
 
@@ -86,7 +92,7 @@ class RxDataset : public StaticLocalDataSet<RX_DATASET_SIZE> {
 
   lp_var_t<uint8_t> rxStatus = lp_var_t<uint8_t>(sid.objectId, RX_STATUS, this);
   lp_var_t<uint32_t> rxSensitivity = lp_var_t<uint32_t>(sid.objectId, RX_SENSITIVITY, this);
-  lp_var_t<uint32_t> rxFrequencyShift = lp_var_t<uint32_t>(sid.objectId, RX_FREQUENCY_SHIFT, this);
+  lp_var_t<int32_t> rxFrequencyShift = lp_var_t<int32_t>(sid.objectId, RX_FREQUENCY_SHIFT, this);
   lp_var_t<uint16_t> rxIqPower = lp_var_t<uint16_t>(sid.objectId, RX_IQ_POWER, this);
   lp_var_t<uint16_t> rxAgcValue = lp_var_t<uint16_t>(sid.objectId, RX_AGC_VALUE, this);
   lp_var_t<uint32_t> rxDemodEb = lp_var_t<uint32_t>(sid.objectId, RX_DEMOD_EB, this);

mission/devices/devicedefinitions/imtqHandlerDefinitions.h

@@ -489,7 +489,7 @@ class DipoleActuationSet : public StaticLocalDataSet<4> {
   // Refresh torque command without changing any of the set dipoles.
   void refreshTorqueing(uint16_t durationMs_) { currentTorqueDurationMs = durationMs_; }
 
-  void setDipoles(uint16_t xDipole_, uint16_t yDipole_, uint16_t zDipole_,
+  void setDipoles(int16_t xDipole_, int16_t yDipole_, int16_t zDipole_,
                   uint16_t currentTorqueDurationMs_) {
     if (xDipole.value != xDipole_) {
     }
@@ -503,7 +503,7 @@ class DipoleActuationSet : public StaticLocalDataSet<4> {
     currentTorqueDurationMs = currentTorqueDurationMs_;
   }
 
-  void getDipoles(uint16_t& xDipole_, uint16_t& yDipole_, uint16_t& zDipole_) {
+  void getDipoles(int16_t& xDipole_, int16_t& yDipole_, int16_t& zDipole_) {
     xDipole_ = xDipole.value;
     yDipole_ = yDipole.value;
     zDipole_ = zDipole.value;

mission/system/objects/AcsSubsystem.cpp

@@ -1,5 +1,83 @@
 #include "AcsSubsystem.h"
 
+#include <fsfw/events/EventManagerIF.h>
+#include <fsfw/ipc/QueueFactory.h>
+
+#include "fsfw/modes/ModeMessage.h"
+#include "mission/acsDefs.h"
+
 AcsSubsystem::AcsSubsystem(object_id_t setObjectId, uint32_t maxNumberOfSequences,
                            uint32_t maxNumberOfTables)
-    : Subsystem(setObjectId, maxNumberOfSequences, maxNumberOfTables) {}
+    : Subsystem(setObjectId, maxNumberOfSequences, maxNumberOfTables) {
+  auto mqArgs = MqArgs(getObjectId(), static_cast<void*>(this));
+  eventQueue =
+      QueueFactory::instance()->createMessageQueue(10, EventMessage::EVENT_MESSAGE_SIZE, &mqArgs);
+}
+
+ReturnValue_t AcsSubsystem::initialize() {
+  EventManagerIF* manager = ObjectManager::instance()->get<EventManagerIF>(objects::EVENT_MANAGER);
+  if (manager == nullptr) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "AcsSubsystem::initialize: Invalid event manager" << std::endl;
+#endif
+    return ObjectManagerIF::CHILD_INIT_FAILED;
+  }
+  ReturnValue_t result = manager->registerListener(eventQueue->getId());
+  if (result != returnvalue::OK) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "AcsSubsystem::registerListener: Failed to register as "
+                    "listener"
+                 << std::endl;
+#endif
+    return ObjectManagerIF::CHILD_INIT_FAILED;
+    ;
+  }
+  result =
+      manager->subscribeToEvent(eventQueue->getId(), event::getEventId(acs::SAFE_RATE_VIOLATION));
+  if (result != returnvalue::OK) {
+    sif::error << "AcsSubsystem: Subscribing for acs::SAFE_RATE_VIOLATION failed" << std::endl;
+  }
+  result =
+      manager->subscribeToEvent(eventQueue->getId(), event::getEventId(acs::SAFE_RATE_RECOVERY));
+  if (result != returnvalue::OK) {
+    sif::error << "AcsSubsystem: Subscribing for acs::SAFE_RATE_RECOVERY failed" << std::endl;
+  }
+  return Subsystem::initialize();
+}
+
+void AcsSubsystem::performChildOperation() {
+  handleEventMessages();
+  return Subsystem::performChildOperation();
+}
+
+void AcsSubsystem::handleEventMessages() {
+  EventMessage event;
+  for (ReturnValue_t result = eventQueue->receiveMessage(&event); result == returnvalue::OK;
+       result = eventQueue->receiveMessage(&event)) {
+    switch (event.getMessageId()) {
+      case EventMessage::EVENT_MESSAGE:
+        if (event.getEvent() == acs::SAFE_RATE_VIOLATION) {
+          CommandMessage msg;
+          ModeMessage::setCmdModeModeMessage(msg, acs::CtrlSubmode::DETUMBLE, 0);
+          ReturnValue_t result = commandQueue->sendMessage(commandQueue->getId(), &msg);
+          if (result != returnvalue::OK) {
+            sif::error << "AcsSubsystem: sending DETUMBLE mode cmd to self has failed" << std::endl;
+          }
+        }
+        if (event.getEvent() == acs::SAFE_RATE_RECOVERY) {
+          CommandMessage msg;
+          ModeMessage::setCmdModeModeMessage(msg, acs::CtrlSubmode::SAFE, 0);
+          ReturnValue_t result = commandQueue->sendMessage(commandQueue->getId(), &msg);
+          if (result != returnvalue::OK) {
+            sif::error << "AcsSubsystem: sending IDLE mode cmd to self has failed" << std::endl;
+          }
+        }
+        break;
+      default:
+        sif::debug << "AcsSubsystem::performChildOperation: Did not subscribe "
+                      "to this event message"
+                   << std::endl;
+        break;
+    }
+  }
+}

mission/system/objects/AcsSubsystem.h

@@ -8,6 +8,12 @@ class AcsSubsystem : public Subsystem {
   AcsSubsystem(object_id_t setObjectId, uint32_t maxNumberOfSequences, uint32_t maxNumberOfTables);
 
  private:
+  ReturnValue_t initialize() override;
+  void performChildOperation() override;
+
+  void handleEventMessages();
+
+  MessageQueueIF* eventQueue = nullptr;
 };
 
 #endif /* MISSION_SYSTEM_ACSSUBSYSTEM_H_ */

mission/system/objects/ComSubsystem.cpp

@@ -1,5 +1,48 @@
 #include "ComSubsystem.h"
 
+#include <fsfw/ipc/MutexGuard.h>
+
+#include "mission/config/comCfg.h"
+
 ComSubsystem::ComSubsystem(object_id_t setObjectId, uint32_t maxNumberOfSequences,
                            uint32_t maxNumberOfTables)
-    : Subsystem(setObjectId, maxNumberOfSequences, maxNumberOfTables) {}
+    : Subsystem(setObjectId, maxNumberOfSequences, maxNumberOfTables), paramHelper(this) {
+  com::setCurrentDatarate(com::Datarate::LOW_RATE_MODULATION_BPSK);
+}
+
+MessageQueueId_t ComSubsystem::getCommandQueue() const { return Subsystem::getCommandQueue(); }
+
+ReturnValue_t ComSubsystem::getParameter(uint8_t domainId, uint8_t uniqueIdentifier,
+                                         ParameterWrapper *parameterWrapper,
+                                         const ParameterWrapper *newValues, uint16_t startAtIndex) {
+  if ((domainId == 0) and (uniqueIdentifier == static_cast<uint8_t>(com::ParameterId::DATARATE))) {
+    uint8_t newVal = 0;
+    ReturnValue_t result = newValues->getElement(&newVal);
+    if (result != returnvalue::OK) {
+      return result;
+    }
+    if (newVal >= static_cast<uint8_t>(com::Datarate::NUM_DATARATES)) {
+      return HasParametersIF::INVALID_VALUE;
+    }
+    parameterWrapper->set(datarateCfg);
+    com::setCurrentDatarate(static_cast<com::Datarate>(newVal));
+    return returnvalue::OK;
+  }
+  return returnvalue::OK;
+}
+
+ReturnValue_t ComSubsystem::handleCommandMessage(CommandMessage *message) {
+  ReturnValue_t result = paramHelper.handleParameterMessage(message);
+  if (result == returnvalue::OK) {
+    return result;
+  }
+  return Subsystem::handleCommandMessage(message);
+}
+
+ReturnValue_t ComSubsystem::initialize() {
+  ReturnValue_t result = paramHelper.initialize();
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  return Subsystem::initialize();
+}

mission/system/objects/ComSubsystem.h

@@ -1,13 +1,29 @@
 #ifndef MISSION_SYSTEM_COMSUBSYSTEM_H_
 #define MISSION_SYSTEM_COMSUBSYSTEM_H_
 
+#include <fsfw/parameters/HasParametersIF.h>
+#include <fsfw/parameters/ParameterHelper.h>
 #include <fsfw/subsystem/Subsystem.h>
 
-class ComSubsystem : public Subsystem {
+#include "mission/comDefs.h"
+
+class ComSubsystem : public Subsystem, public ReceivesParameterMessagesIF {
  public:
   ComSubsystem(object_id_t setObjectId, uint32_t maxNumberOfSequences, uint32_t maxNumberOfTables);
+  virtual ~ComSubsystem() = default;
+
+  MessageQueueId_t getCommandQueue() const override;
+  ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueIdentifier,
+                             ParameterWrapper *parameterWrapper, const ParameterWrapper *newValues,
+                             uint16_t startAtIndex) override;
 
  private:
+  ReturnValue_t handleCommandMessage(CommandMessage *message) override;
+
+  ReturnValue_t initialize() override;
+
+  uint8_t datarateCfg = static_cast<uint8_t>(com::Datarate::LOW_RATE_MODULATION_BPSK);
+  ParameterHelper paramHelper;
 };
 
 #endif /* MISSION_SYSTEM_COMSUBSYSTEM_H_ */

mission/system/objects/definitions.h

@@ -18,7 +18,14 @@ enum Submodes : Submode_t { A_SIDE = 0, B_SIDE = 1, DUAL_MODE = 2 };
 
 namespace payload {
 
-enum Modes { NONE = 0, SUPV_ONLY = 1, MPSOC_STREAM = 2, CAM_STREAM = 3, EARTH_OBSV = 4, SCEX = 5 };
+enum Mode {
+  OFF = 0,
+  SUPV_ONLY = 10,
+  MPSOC_STREAM = 11,
+  CAM_STREAM = 12,
+  EARTH_OBSV = 13,
+  SCEX = 14
+};
 
 namespace ploc {
 

mission/system/tree/CMakeLists.txt

@@ -1,2 +1,4 @@
-target_sources(${LIB_EIVE_MISSION} PRIVATE acsModeTree.cpp payloadModeTree.cpp
-                                           system.cpp util.cpp)
+target_sources(
+  ${LIB_EIVE_MISSION}
+  PRIVATE acsModeTree.cpp payloadModeTree.cpp comModeTree.cpp tcsModeTree.cpp
+          system.cpp util.cpp)

mission/system/tree/acsModeTree.cpp

@@ -7,92 +7,127 @@
 #include <fsfw/subsystem/modes/ModeDefinitions.h>
 
 #include "eive/objects.h"
-#include "mission/controller/controllerdefinitions/AcsControllerDefinitions.h"
+#include "mission/acsDefs.h"
 #include "util.h"
 
-Subsystem satsystem::acs::ACS_SUBSYSTEM(objects::ACS_SUBSYSTEM, 12, 24);
+AcsSubsystem satsystem::acs::ACS_SUBSYSTEM(objects::ACS_SUBSYSTEM, 12, 24);
 
 namespace {
 // Alias for checker function
 const auto check = subsystem::checkInsert;
 
-void buildOffSequence(Subsystem* ss, ModeListEntry& eh);
-void buildDetumbleSequence(Subsystem* ss, ModeListEntry& entryHelper);
-void buildSafeSequence(Subsystem* ss, ModeListEntry& entryHelper);
-void buildIdleSequence(Subsystem* ss, ModeListEntry& entryHelper);
-void buildIdleChargeSequence(Subsystem* ss, ModeListEntry& entryHelper);
-void buildTargetPtSequence(Subsystem* ss, ModeListEntry& entryHelper);
+void buildOffSequence(Subsystem& ss, ModeListEntry& eh);
+void buildDetumbleSequence(Subsystem& ss, ModeListEntry& entryHelper);
+void buildSafeSequence(Subsystem& ss, ModeListEntry& entryHelper);
+void buildIdleSequence(Subsystem& ss, ModeListEntry& entryHelper);
+void buildTargetPtNadirSequence(Subsystem& ss, ModeListEntry& eh);
+void buildTargetPtSequence(Subsystem& ss, ModeListEntry& entryHelper);
+void buildTargetPtGsSequence(Subsystem& ss, ModeListEntry& entryHelper);
+void buildTargetPtInertialSequence(Subsystem& ss, ModeListEntry& entryHelper);
+
 }  // namespace
 
 static const auto OFF = HasModesIF::MODE_OFF;
 static const auto NML = DeviceHandlerIF::MODE_NORMAL;
 
-auto ACS_SEQUENCE_OFF =
-    std::make_pair(acs::CtrlModes::OFF << 24, FixedArrayList<ModeListEntry, 2>());
+auto ACS_SEQUENCE_OFF = std::make_pair(acs::CtrlSubmode::OFF, FixedArrayList<ModeListEntry, 3>());
 auto ACS_TABLE_OFF_TGT =
-    std::make_pair((acs::CtrlModes::OFF << 24) | 1, FixedArrayList<ModeListEntry, 1>());
-auto ACS_TABLE_OFF_TRANS =
-    std::make_pair((acs::CtrlModes::OFF << 24) | 2, FixedArrayList<ModeListEntry, 6>());
+    std::make_pair((acs::CtrlSubmode::OFF << 24) | 1, FixedArrayList<ModeListEntry, 1>());
+auto ACS_TABLE_OFF_TRANS_0 =
+    std::make_pair((acs::CtrlSubmode::OFF << 24) | 2, FixedArrayList<ModeListEntry, 1>());
+auto ACS_TABLE_OFF_TRANS_1 =
+    std::make_pair((acs::CtrlSubmode::OFF << 24) | 3, FixedArrayList<ModeListEntry, 6>());
 
 auto ACS_SEQUENCE_DETUMBLE =
-    std::make_pair(acs::CtrlModes::DETUMBLE << 24, FixedArrayList<ModeListEntry, 3>());
+    std::make_pair(acs::CtrlSubmode::DETUMBLE, FixedArrayList<ModeListEntry, 3>());
 auto ACS_TABLE_DETUMBLE_TGT =
-    std::make_pair((acs::CtrlModes::DETUMBLE << 24) | 1, FixedArrayList<ModeListEntry, 4>());
+    std::make_pair((acs::CtrlSubmode::DETUMBLE << 24) | 1, FixedArrayList<ModeListEntry, 4>());
 auto ACS_TABLE_DETUMBLE_TRANS_0 =
-    std::make_pair((acs::CtrlModes::DETUMBLE << 24) | 2, FixedArrayList<ModeListEntry, 5>());
+    std::make_pair((acs::CtrlSubmode::DETUMBLE << 24) | 2, FixedArrayList<ModeListEntry, 5>());
 auto ACS_TABLE_DETUMBLE_TRANS_1 =
-    std::make_pair((acs::CtrlModes::DETUMBLE << 24) | 3, FixedArrayList<ModeListEntry, 1>());
+    std::make_pair((acs::CtrlSubmode::DETUMBLE << 24) | 3, FixedArrayList<ModeListEntry, 1>());
 
-auto ACS_SEQUENCE_SAFE =
-    std::make_pair(acs::CtrlModes::SAFE << 24, FixedArrayList<ModeListEntry, 3>());
+auto ACS_SEQUENCE_SAFE = std::make_pair(acs::CtrlSubmode::SAFE, FixedArrayList<ModeListEntry, 3>());
 auto ACS_TABLE_SAFE_TGT =
-    std::make_pair((acs::CtrlModes::SAFE << 24) | 1, FixedArrayList<ModeListEntry, 4>());
+    std::make_pair((acs::CtrlSubmode::SAFE << 24) | 1, FixedArrayList<ModeListEntry, 4>());
 auto ACS_TABLE_SAFE_TRANS_0 =
-    std::make_pair((acs::CtrlModes::SAFE << 24) | 2, FixedArrayList<ModeListEntry, 5>());
+    std::make_pair((acs::CtrlSubmode::SAFE << 24) | 2, FixedArrayList<ModeListEntry, 5>());
 auto ACS_TABLE_SAFE_TRANS_1 =
-    std::make_pair((acs::CtrlModes::SAFE << 24) | 3, FixedArrayList<ModeListEntry, 1>());
+    std::make_pair((acs::CtrlSubmode::SAFE << 24) | 3, FixedArrayList<ModeListEntry, 1>());
 
-auto ACS_SEQUENCE_IDLE =
-    std::make_pair(acs::CtrlModes::IDLE << 24, FixedArrayList<ModeListEntry, 3>());
+auto ACS_SEQUENCE_IDLE = std::make_pair(acs::CtrlSubmode::IDLE, FixedArrayList<ModeListEntry, 3>());
 auto ACS_TABLE_IDLE_TGT =
-    std::make_pair((acs::CtrlModes::IDLE << 24) | 1, FixedArrayList<ModeListEntry, 5>());
+    std::make_pair((acs::CtrlSubmode::IDLE << 24) | 1, FixedArrayList<ModeListEntry, 6>());
 auto ACS_TABLE_IDLE_TRANS_0 =
-    std::make_pair((acs::CtrlModes::IDLE << 24) | 2, FixedArrayList<ModeListEntry, 5>());
+    std::make_pair((acs::CtrlSubmode::IDLE << 24) | 2, FixedArrayList<ModeListEntry, 6>());
 auto ACS_TABLE_IDLE_TRANS_1 =
-    std::make_pair((acs::CtrlModes::IDLE << 24) | 3, FixedArrayList<ModeListEntry, 1>());
+    std::make_pair((acs::CtrlSubmode::IDLE << 24) | 3, FixedArrayList<ModeListEntry, 2>());
 
-auto ACS_SEQUENCE_IDLE_CHRG = std::make_pair(acs::CtrlModes::IDLE << 24 | (acs::IDLE_CHARGE << 8),
-                                             FixedArrayList<ModeListEntry, 3>());
-auto ACS_TABLE_IDLE_CHRG_TGT = std::make_pair(
-    (acs::CtrlModes::IDLE << 24) | (acs::IDLE_CHARGE << 8) | 1, FixedArrayList<ModeListEntry, 4>());
-auto ACS_TABLE_IDLE_CHRG_TRANS_0 = std::make_pair(
-    (acs::CtrlModes::IDLE << 24) | (acs::IDLE_CHARGE << 8) | 2, FixedArrayList<ModeListEntry, 5>());
-auto ACS_TABLE_IDLE_CHRG_TRANS_1 = std::make_pair(
-    (acs::CtrlModes::IDLE << 24) | (acs::IDLE_CHARGE << 8) | 3, FixedArrayList<ModeListEntry, 1>());
+auto ACS_TABLE_PTG_TRANS_0 =
+    std::make_pair((acs::CtrlSubmode::PTG_TARGET << 24) | 2, FixedArrayList<ModeListEntry, 5>());
 
-auto ACS_SEQUENCE_TARGET_PT =
-    std::make_pair(acs::CtrlModes::TARGET_PT, FixedArrayList<ModeListEntry, 3>());
-auto ACS_TABLE_TARGET_PT_TGT =
-    std::make_pair((acs::CtrlModes::TARGET_PT << 24) | 1, FixedArrayList<ModeListEntry, 6>());
-auto ACS_TABLE_TARGET_PT_TRANS_0 =
-    std::make_pair((acs::CtrlModes::TARGET_PT << 24) | 2, FixedArrayList<ModeListEntry, 5>());
-auto ACS_TABLE_TARGET_PT_TRANS_1 =
-    std::make_pair((acs::CtrlModes::TARGET_PT << 24) | 3, FixedArrayList<ModeListEntry, 1>());
+auto ACS_SEQUENCE_PTG_TARGET =
+    std::make_pair(acs::CtrlSubmode::PTG_TARGET, FixedArrayList<ModeListEntry, 3>());
+auto ACS_TABLE_PTG_TARGET_TGT =
+    std::make_pair((acs::CtrlSubmode::PTG_TARGET << 24) | 1, FixedArrayList<ModeListEntry, 6>());
+auto ACS_TABLE_PTG_TARGET_TRANS_1 =
+    std::make_pair((acs::CtrlSubmode::PTG_TARGET << 24) | 3, FixedArrayList<ModeListEntry, 1>());
+
+auto ACS_SEQUENCE_PTG_TARGET_GS =
+    std::make_pair(acs::CtrlSubmode::PTG_TARGET_GS, FixedArrayList<ModeListEntry, 3>());
+auto ACS_TABLE_PTG_TARGET_GS_TGT =
+    std::make_pair((acs::CtrlSubmode::PTG_TARGET_GS << 24) | 1, FixedArrayList<ModeListEntry, 6>());
+auto ACS_TABLE_PTG_TARGET_GS_TRANS_1 =
+    std::make_pair((acs::CtrlSubmode::PTG_TARGET_GS << 24) | 3, FixedArrayList<ModeListEntry, 1>());
+
+auto ACS_SEQUENCE_PTG_TARGET_NADIR =
+    std::make_pair(acs::CtrlSubmode::PTG_TARGET_NADIR, FixedArrayList<ModeListEntry, 3>());
+auto ACS_TABLE_PTG_TARGET_NADIR_TGT = std::make_pair((acs::CtrlSubmode::PTG_TARGET_NADIR << 24) | 1,
+                                                     FixedArrayList<ModeListEntry, 6>());
+auto ACS_TABLE_PTG_TARGET_NADIR_TRANS_1 = std::make_pair(
+    (acs::CtrlSubmode::PTG_TARGET_NADIR << 24) | 3, FixedArrayList<ModeListEntry, 1>());
+
+auto ACS_SEQUENCE_PTG_TARGET_INERTIAL =
+    std::make_pair(acs::CtrlSubmode::PTG_TARGET_INERTIAL, FixedArrayList<ModeListEntry, 3>());
+auto ACS_TABLE_PTG_TARGET_INERTIAL_TGT = std::make_pair(
+    (acs::CtrlSubmode::PTG_TARGET_INERTIAL << 24) | 1, FixedArrayList<ModeListEntry, 6>());
+auto ACS_TABLE_PTG_TARGET_INERTIAL_TRANS_1 = std::make_pair(
+    (acs::CtrlSubmode::PTG_TARGET_INERTIAL << 24) | 3, FixedArrayList<ModeListEntry, 1>());
 
 void satsystem::acs::init() {
   ModeListEntry entry;
-  buildOffSequence(&ACS_SUBSYSTEM, entry);
-  buildSafeSequence(&ACS_SUBSYSTEM, entry);
-  buildDetumbleSequence(&ACS_SUBSYSTEM, entry);
-  buildIdleSequence(&ACS_SUBSYSTEM, entry);
-  buildIdleChargeSequence(&ACS_SUBSYSTEM, entry);
-  buildTargetPtSequence(&ACS_SUBSYSTEM, entry);
-  ACS_SUBSYSTEM.setInitialMode(HasModesIF::MODE_OFF);
+  const char* ctxc = "satsystem::acs::init: generic target";
+  // Insert Helper Table
+  auto iht = [&](object_id_t obj, Mode_t mode, Submode_t submode, ArrayList<ModeListEntry>& table) {
+    entry.setObject(obj);
+    entry.setMode(mode);
+    entry.setSubmode(submode);
+    check(table.insert(entry), "satsystem::acs::init: generic target");
+  };
+  // Build TARGET PT transition 0
+  iht(objects::IMTQ_HANDLER, NML, 0, ACS_TABLE_PTG_TRANS_0.second);
+  iht(objects::SUS_BOARD_ASS, NML, 0, ACS_TABLE_PTG_TRANS_0.second);
+  iht(objects::ACS_BOARD_ASS, NML, 0, ACS_TABLE_PTG_TRANS_0.second);
+  iht(objects::RW_ASS, NML, 0, ACS_TABLE_PTG_TRANS_0.second);
+  iht(objects::STAR_TRACKER, NML, 0, ACS_TABLE_PTG_TRANS_0.second);
+  check(ACS_SUBSYSTEM.addTable(
+            TableEntry(ACS_TABLE_PTG_TRANS_0.first, &ACS_TABLE_PTG_TRANS_0.second)),
+        ctxc);
+
+  buildOffSequence(ACS_SUBSYSTEM, entry);
+  buildSafeSequence(ACS_SUBSYSTEM, entry);
+  buildDetumbleSequence(ACS_SUBSYSTEM, entry);
+  buildIdleSequence(ACS_SUBSYSTEM, entry);
+  buildTargetPtSequence(ACS_SUBSYSTEM, entry);
+  buildTargetPtGsSequence(ACS_SUBSYSTEM, entry);
+  buildTargetPtNadirSequence(ACS_SUBSYSTEM, entry);
+  buildTargetPtInertialSequence(ACS_SUBSYSTEM, entry);
+  ACS_SUBSYSTEM.setInitialMode(::acs::CtrlSubmode::SAFE);
 }
 
 namespace {
 
-void buildOffSequence(Subsystem* ss, ModeListEntry& eh) {
+void buildOffSequence(Subsystem& ss, ModeListEntry& eh) {
   std::string context = "satsystem::acs::buildOffSequence";
   auto ctxc = context.c_str();
   // Insert Helper Table
@@ -112,26 +147,30 @@ void buildOffSequence(Subsystem* ss, ModeListEntry& eh) {
   };
 
   // OFF Target table is empty
-  check(ss->addTable(&ACS_TABLE_OFF_TGT.second, ACS_TABLE_OFF_TGT.first, false, true), ctxc);
+  check(ss.addTable(TableEntry(ACS_TABLE_OFF_TGT.first, &ACS_TABLE_OFF_TGT.second)), ctxc);
 
-  // Build OFF transition
-  iht(objects::ACS_CONTROLLER, OFF, 0, ACS_TABLE_OFF_TRANS.second);
-  iht(objects::IMTQ_HANDLER, OFF, 0, ACS_TABLE_OFF_TRANS.second);
-  iht(objects::STAR_TRACKER, OFF, 0, ACS_TABLE_OFF_TRANS.second);
-  iht(objects::ACS_BOARD_ASS, OFF, 0, ACS_TABLE_OFF_TRANS.second);
-  iht(objects::SUS_BOARD_ASS, OFF, 0, ACS_TABLE_OFF_TRANS.second);
-  iht(objects::RW_ASS, OFF, 0, ACS_TABLE_OFF_TRANS.second);
-  check(ss->addTable(&ACS_TABLE_OFF_TRANS.second, ACS_TABLE_OFF_TRANS.first, false, true), ctxc);
+  // Build OFF transition 0
+  iht(objects::ACS_CONTROLLER, OFF, 0, ACS_TABLE_OFF_TRANS_0.second);
+  check(ss.addTable(TableEntry(ACS_TABLE_OFF_TRANS_0.first, &ACS_TABLE_OFF_TRANS_0.second)), ctxc);
+
+  // Build OFF transition 1
+  iht(objects::IMTQ_HANDLER, OFF, 0, ACS_TABLE_OFF_TRANS_1.second);
+  iht(objects::STAR_TRACKER, OFF, 0, ACS_TABLE_OFF_TRANS_1.second);
+  iht(objects::ACS_BOARD_ASS, OFF, 0, ACS_TABLE_OFF_TRANS_1.second);
+  iht(objects::SUS_BOARD_ASS, OFF, 0, ACS_TABLE_OFF_TRANS_1.second);
+  iht(objects::RW_ASS, OFF, 0, ACS_TABLE_OFF_TRANS_1.second);
+  check(ss.addTable(TableEntry(ACS_TABLE_OFF_TRANS_1.first, &ACS_TABLE_OFF_TRANS_1.second)), ctxc);
 
   // Build OFF sequence
   ihs(ACS_SEQUENCE_OFF.second, ACS_TABLE_OFF_TGT.first, 0, false);
-  ihs(ACS_SEQUENCE_OFF.second, ACS_TABLE_OFF_TRANS.first, 0, false);
-  check(ss->addSequence(&ACS_SEQUENCE_OFF.second, ACS_SEQUENCE_OFF.first, ACS_SEQUENCE_OFF.first,
-                        false, true),
+  ihs(ACS_SEQUENCE_OFF.second, ACS_TABLE_OFF_TRANS_0.first, 0, false);
+  ihs(ACS_SEQUENCE_OFF.second, ACS_TABLE_OFF_TRANS_1.first, 0, false);
+  check(ss.addSequence(&ACS_SEQUENCE_OFF.second, ACS_SEQUENCE_OFF.first, ACS_SEQUENCE_OFF.first,
+                       false, true),
         ctxc);
 }
 
-void buildSafeSequence(Subsystem* ss, ModeListEntry& eh) {
+void buildSafeSequence(Subsystem& ss, ModeListEntry& eh) {
   std::string context = "satsystem::acs::buildSafeSequence";
   auto ctxc = context.c_str();
   // Insert Helper Table
@@ -151,11 +190,11 @@ void buildSafeSequence(Subsystem* ss, ModeListEntry& eh) {
     check(sequence.insert(eh), ctxc);
   };
   // Build SAFE target
-  iht(objects::ACS_CONTROLLER, acs::CtrlModes::SAFE, 0, ACS_TABLE_SAFE_TGT.second);
+  iht(objects::ACS_CONTROLLER, NML, acs::CtrlSubmode::SAFE, ACS_TABLE_SAFE_TGT.second);
   iht(objects::IMTQ_HANDLER, NML, 0, ACS_TABLE_SAFE_TGT.second);
   iht(objects::SUS_BOARD_ASS, NML, 0, ACS_TABLE_SAFE_TGT.second);
   iht(objects::ACS_BOARD_ASS, NML, 0, ACS_TABLE_SAFE_TGT.second);
-  check(ss->addTable(&ACS_TABLE_SAFE_TGT.second, ACS_TABLE_SAFE_TGT.first, false, true), ctxc);
+  check(ss.addTable(&ACS_TABLE_SAFE_TGT.second, ACS_TABLE_SAFE_TGT.first, false, true), ctxc);
 
   // Build SAFE transition 0
   iht(objects::IMTQ_HANDLER, NML, 0, ACS_TABLE_SAFE_TRANS_0.second);
@@ -163,24 +202,24 @@ void buildSafeSequence(Subsystem* ss, ModeListEntry& eh) {
   iht(objects::ACS_BOARD_ASS, NML, 0, ACS_TABLE_SAFE_TRANS_0.second);
   iht(objects::STAR_TRACKER, OFF, 0, ACS_TABLE_SAFE_TRANS_0.second);
   iht(objects::RW_ASS, OFF, 0, ACS_TABLE_SAFE_TRANS_0.second);
-  check(ss->addTable(&ACS_TABLE_SAFE_TRANS_0.second, ACS_TABLE_SAFE_TRANS_0.first, false, true),
+  check(ss.addTable(&ACS_TABLE_SAFE_TRANS_0.second, ACS_TABLE_SAFE_TRANS_0.first, false, true),
         ctxc);
 
   // Build SAFE transition 1
-  iht(objects::ACS_CONTROLLER, acs::CtrlModes::SAFE, 0, ACS_TABLE_SAFE_TRANS_1.second);
-  check(ss->addTable(&ACS_TABLE_SAFE_TRANS_1.second, ACS_TABLE_SAFE_TRANS_1.first, false, true),
+  iht(objects::ACS_CONTROLLER, NML, acs::CtrlSubmode::SAFE, ACS_TABLE_SAFE_TRANS_1.second);
+  check(ss.addTable(&ACS_TABLE_SAFE_TRANS_1.second, ACS_TABLE_SAFE_TRANS_1.first, false, true),
         ctxc);
 
   // Build SAFE sequence
   ihs(ACS_SEQUENCE_SAFE.second, ACS_TABLE_SAFE_TGT.first, 0, true);
   ihs(ACS_SEQUENCE_SAFE.second, ACS_TABLE_SAFE_TRANS_0.first, 0, false);
   ihs(ACS_SEQUENCE_SAFE.second, ACS_TABLE_SAFE_TRANS_1.first, 0, false);
-  check(ss->addSequence(&ACS_SEQUENCE_SAFE.second, ACS_SEQUENCE_SAFE.first, ACS_SEQUENCE_SAFE.first,
-                        false, true),
+  check(ss.addSequence(&ACS_SEQUENCE_SAFE.second, ACS_SEQUENCE_SAFE.first, ACS_SEQUENCE_SAFE.first,
+                       false, true),
         ctxc);
 }
 
-void buildDetumbleSequence(Subsystem* ss, ModeListEntry& eh) {
+void buildDetumbleSequence(Subsystem& ss, ModeListEntry& eh) {
   std::string context = "satsystem::acs::buildDetumbleSequence";
   auto ctxc = context.c_str();
   // Insert Helper Table
@@ -200,11 +239,11 @@ void buildDetumbleSequence(Subsystem* ss, ModeListEntry& eh) {
     check(sequence.insert(eh), ctxc);
   };
   // Build DETUMBLE target
-  iht(objects::ACS_CONTROLLER, acs::CtrlModes::DETUMBLE, 0, ACS_TABLE_DETUMBLE_TGT.second);
+  iht(objects::ACS_CONTROLLER, NML, acs::CtrlSubmode::DETUMBLE, ACS_TABLE_DETUMBLE_TGT.second);
   iht(objects::IMTQ_HANDLER, NML, 0, ACS_TABLE_DETUMBLE_TGT.second);
   iht(objects::SUS_BOARD_ASS, NML, 0, ACS_TABLE_DETUMBLE_TGT.second);
   iht(objects::ACS_BOARD_ASS, NML, 0, ACS_TABLE_DETUMBLE_TGT.second);
-  check(ss->addTable(&ACS_TABLE_DETUMBLE_TGT.second, ACS_TABLE_DETUMBLE_TGT.first, false, true),
+  check(ss.addTable(&ACS_TABLE_DETUMBLE_TGT.second, ACS_TABLE_DETUMBLE_TGT.first, false, true),
         ctxc);
 
   // Build DETUMBLE transition 0
@@ -213,26 +252,26 @@ void buildDetumbleSequence(Subsystem* ss, ModeListEntry& eh) {
   iht(objects::SUS_BOARD_ASS, NML, 0, ACS_TABLE_DETUMBLE_TRANS_0.second);
   iht(objects::STAR_TRACKER, OFF, 0, ACS_TABLE_DETUMBLE_TRANS_0.second);
   iht(objects::RW_ASS, OFF, 0, ACS_TABLE_DETUMBLE_TRANS_0.second);
-  check(ss->addTable(&ACS_TABLE_DETUMBLE_TRANS_0.second, ACS_TABLE_DETUMBLE_TRANS_0.first, false,
-                     true),
+  check(ss.addTable(&ACS_TABLE_DETUMBLE_TRANS_0.second, ACS_TABLE_DETUMBLE_TRANS_0.first, false,
+                    true),
         ctxc);
 
   // Build DETUMBLE transition 1
-  iht(objects::ACS_CONTROLLER, acs::CtrlModes::DETUMBLE, 0, ACS_TABLE_DETUMBLE_TRANS_1.second);
-  check(ss->addTable(&ACS_TABLE_DETUMBLE_TRANS_1.second, ACS_TABLE_DETUMBLE_TRANS_1.first, false,
-                     true),
+  iht(objects::ACS_CONTROLLER, NML, acs::CtrlSubmode::DETUMBLE, ACS_TABLE_DETUMBLE_TRANS_1.second);
+  check(ss.addTable(&ACS_TABLE_DETUMBLE_TRANS_1.second, ACS_TABLE_DETUMBLE_TRANS_1.first, false,
+                    true),
         ctxc);
 
   // Build DETUMBLE sequence
   ihs(ACS_SEQUENCE_DETUMBLE.second, ACS_TABLE_DETUMBLE_TGT.first, 0, true);
   ihs(ACS_SEQUENCE_DETUMBLE.second, ACS_TABLE_DETUMBLE_TRANS_0.first, 0, false);
   ihs(ACS_SEQUENCE_DETUMBLE.second, ACS_TABLE_DETUMBLE_TRANS_1.first, 0, false);
-  check(ss->addSequence(&ACS_SEQUENCE_DETUMBLE.second, ACS_SEQUENCE_DETUMBLE.first,
-                        ACS_SEQUENCE_SAFE.first, false, true),
+  check(ss.addSequence(&ACS_SEQUENCE_DETUMBLE.second, ACS_SEQUENCE_DETUMBLE.first,
+                       ACS_SEQUENCE_SAFE.first, false, true),
         ctxc);
 }
 
-void buildIdleSequence(Subsystem* ss, ModeListEntry& eh) {
+void buildIdleSequence(Subsystem& ss, ModeListEntry& eh) {
   std::string context = "satsystem::acs::buildIdleSequence";
   auto ctxc = context.c_str();
   // Insert Helper Table
@@ -252,88 +291,34 @@ void buildIdleSequence(Subsystem* ss, ModeListEntry& eh) {
     check(sequence.insert(eh), ctxc);
   };
   // Build IDLE target
-  iht(objects::ACS_CONTROLLER, acs::CtrlModes::IDLE, 0, ACS_TABLE_IDLE_TGT.second);
+  iht(objects::ACS_CONTROLLER, NML, acs::CtrlSubmode::IDLE, ACS_TABLE_IDLE_TGT.second);
   iht(objects::IMTQ_HANDLER, NML, 0, ACS_TABLE_IDLE_TGT.second);
   iht(objects::RW_ASS, NML, 0, ACS_TABLE_IDLE_TGT.second);
   iht(objects::SUS_BOARD_ASS, NML, 0, ACS_TABLE_IDLE_TGT.second);
   iht(objects::ACS_BOARD_ASS, NML, 0, ACS_TABLE_IDLE_TGT.second);
-  ss->addTable(&ACS_TABLE_IDLE_TGT.second, ACS_TABLE_IDLE_TGT.first, false, true);
+  ss.addTable(&ACS_TABLE_IDLE_TGT.second, ACS_TABLE_IDLE_TGT.first, false, true);
 
   // Build IDLE transition 0
   iht(objects::IMTQ_HANDLER, NML, 0, ACS_TABLE_IDLE_TRANS_0.second);
   iht(objects::ACS_BOARD_ASS, NML, 0, ACS_TABLE_IDLE_TRANS_0.second);
   iht(objects::SUS_BOARD_ASS, NML, 0, ACS_TABLE_IDLE_TRANS_0.second);
   iht(objects::RW_ASS, NML, 0, ACS_TABLE_IDLE_TRANS_0.second);
-  iht(objects::STAR_TRACKER, OFF, 0, ACS_TABLE_IDLE_TRANS_0.second);
-  ss->addTable(&ACS_TABLE_IDLE_TRANS_0.second, ACS_TABLE_IDLE_TRANS_0.first, false, true);
+  iht(objects::STAR_TRACKER, NML, 0, ACS_TABLE_IDLE_TRANS_0.second);
+  ss.addTable(&ACS_TABLE_IDLE_TRANS_0.second, ACS_TABLE_IDLE_TRANS_0.first, false, true);
 
   // Build IDLE transition 1
-  iht(objects::ACS_CONTROLLER, acs::CtrlModes::IDLE, 0, ACS_TABLE_IDLE_TRANS_1.second);
-  ss->addTable(&ACS_TABLE_IDLE_TRANS_1.second, ACS_TABLE_IDLE_TRANS_1.first, false, true);
+  iht(objects::ACS_CONTROLLER, NML, acs::CtrlSubmode::IDLE, ACS_TABLE_IDLE_TRANS_1.second);
+  ss.addTable(&ACS_TABLE_IDLE_TRANS_1.second, ACS_TABLE_IDLE_TRANS_1.first, false, true);
 
   // Build IDLE sequence
   ihs(ACS_SEQUENCE_IDLE.second, ACS_TABLE_IDLE_TGT.first, 0, true);
   ihs(ACS_SEQUENCE_IDLE.second, ACS_TABLE_IDLE_TRANS_0.first, 0, true);
-  ihs(ACS_SEQUENCE_IDLE.second, ACS_TABLE_IDLE_TRANS_1.first, 0, false);
-  ss->addSequence(&ACS_SEQUENCE_IDLE.second, ACS_SEQUENCE_IDLE.first, ACS_SEQUENCE_SAFE.first,
-                  false, true);
+  ihs(ACS_SEQUENCE_IDLE.second, ACS_TABLE_IDLE_TRANS_1.first, 0, true);
+  ss.addSequence(&ACS_SEQUENCE_IDLE.second, ACS_SEQUENCE_IDLE.first, ACS_SEQUENCE_SAFE.first, false,
+                 true);
 }
 
-void buildIdleChargeSequence(Subsystem* ss, ModeListEntry& eh) {
-  std::string context = "satsystem::acs::buildIdleChargeSequence";
-  auto ctxc = context.c_str();
-  // Insert Helper Table
-  auto iht = [&](object_id_t obj, Mode_t mode, Submode_t submode,
-                 ArrayList<ModeListEntry>& sequence) {
-    eh.setObject(obj);
-    eh.setMode(mode);
-    eh.setSubmode(submode);
-    check(sequence.insert(eh), ctxc);
-  };
-  // Insert Helper Sequence
-  auto ihs = [&](ArrayList<ModeListEntry>& sequence, Mode_t tableId, uint32_t waitSeconds,
-                 bool checkSuccess) {
-    eh.setTableId(tableId);
-    eh.setWaitSeconds(waitSeconds);
-    eh.setCheckSuccess(checkSuccess);
-    check(sequence.insert(eh), ctxc);
-  };
-  // Build IDLE target
-  iht(objects::ACS_CONTROLLER, acs::CtrlModes::IDLE, acs::IDLE_CHARGE,
-      ACS_TABLE_IDLE_CHRG_TGT.second);
-  iht(objects::IMTQ_HANDLER, NML, 0, ACS_TABLE_IDLE_CHRG_TGT.second);
-  iht(objects::SUS_BOARD_ASS, NML, 0, ACS_TABLE_IDLE_CHRG_TGT.second);
-  iht(objects::ACS_BOARD_ASS, NML, 0, ACS_TABLE_IDLE_CHRG_TGT.second);
-  check(ss->addTable(&ACS_TABLE_IDLE_CHRG_TGT.second, ACS_TABLE_IDLE_CHRG_TGT.first, false, true),
-        ctxc);
-
-  // Build IDLE transition 0
-  iht(objects::IMTQ_HANDLER, NML, 0, ACS_TABLE_IDLE_CHRG_TRANS_0.second);
-  iht(objects::ACS_BOARD_ASS, NML, 0, ACS_TABLE_IDLE_CHRG_TRANS_0.second);
-  iht(objects::SUS_BOARD_ASS, NML, 0, ACS_TABLE_IDLE_CHRG_TRANS_0.second);
-  iht(objects::RW_ASS, OFF, 0, ACS_TABLE_IDLE_CHRG_TRANS_0.second);
-  iht(objects::STAR_TRACKER, OFF, 0, ACS_TABLE_IDLE_CHRG_TRANS_0.second);
-  check(ss->addTable(&ACS_TABLE_IDLE_CHRG_TRANS_0.second, ACS_TABLE_IDLE_CHRG_TRANS_0.first, false,
-                     true),
-        ctxc);
-
-  // Build IDLE transition 1
-  iht(objects::ACS_CONTROLLER, acs::CtrlModes::IDLE, acs::IDLE_CHARGE,
-      ACS_TABLE_IDLE_CHRG_TRANS_1.second);
-  check(ss->addTable(&ACS_TABLE_IDLE_CHRG_TRANS_1.second, ACS_TABLE_IDLE_CHRG_TRANS_1.first, false,
-                     true),
-        ctxc);
-
-  // Build IDLE sequence
-  ihs(ACS_SEQUENCE_IDLE_CHRG.second, ACS_TABLE_IDLE_CHRG_TGT.first, 0, true);
-  ihs(ACS_SEQUENCE_IDLE_CHRG.second, ACS_TABLE_IDLE_CHRG_TRANS_0.first, 0, true);
-  ihs(ACS_SEQUENCE_IDLE_CHRG.second, ACS_TABLE_IDLE_CHRG_TRANS_1.first, 0, false);
-  check(ss->addSequence(&ACS_SEQUENCE_IDLE_CHRG.second, ACS_SEQUENCE_IDLE_CHRG.first,
-                        ACS_SEQUENCE_SAFE.first, false, true),
-        ctxc);
-}
-
-void buildTargetPtSequence(Subsystem* ss, ModeListEntry& eh) {
+void buildTargetPtSequence(Subsystem& ss, ModeListEntry& eh) {
   std::string context = "satsystem::acs::buildTargetPtSequence";
   auto ctxc = context.c_str();
   // Insert Helper Table
@@ -354,37 +339,179 @@ void buildTargetPtSequence(Subsystem* ss, ModeListEntry& eh) {
   };
 
   // Build TARGET PT table
-  iht(objects::ACS_CONTROLLER, acs::CtrlModes::TARGET_PT, 0, ACS_TABLE_TARGET_PT_TGT.second);
-  iht(objects::IMTQ_HANDLER, NML, 0, ACS_TABLE_TARGET_PT_TGT.second);
-  iht(objects::SUS_BOARD_ASS, NML, 0, ACS_TABLE_TARGET_PT_TGT.second);
-  iht(objects::ACS_BOARD_ASS, NML, 0, ACS_TABLE_TARGET_PT_TGT.second);
-  iht(objects::RW_ASS, NML, 0, ACS_TABLE_TARGET_PT_TGT.second);
-  iht(objects::STAR_TRACKER, NML, 0, ACS_TABLE_TARGET_PT_TGT.second);
-  check(ss->addTable(&ACS_TABLE_TARGET_PT_TGT.second, ACS_TABLE_TARGET_PT_TGT.first, false, true),
-        ctxc);
-
-  // Build TARGET PT transition 0
-  iht(objects::IMTQ_HANDLER, NML, 0, ACS_TABLE_TARGET_PT_TRANS_0.second);
-  iht(objects::SUS_BOARD_ASS, NML, 0, ACS_TABLE_TARGET_PT_TRANS_0.second);
-  iht(objects::ACS_BOARD_ASS, NML, 0, ACS_TABLE_TARGET_PT_TRANS_0.second);
-  iht(objects::RW_ASS, NML, 0, ACS_TABLE_TARGET_PT_TRANS_0.second);
-  iht(objects::STAR_TRACKER, NML, 0, ACS_TABLE_TARGET_PT_TRANS_0.second);
-  check(ss->addTable(&ACS_TABLE_TARGET_PT_TRANS_0.second, ACS_TABLE_TARGET_PT_TRANS_0.first, false,
-                     true),
+  iht(objects::ACS_CONTROLLER, NML, acs::CtrlSubmode::PTG_TARGET, ACS_TABLE_PTG_TARGET_TGT.second);
+  iht(objects::IMTQ_HANDLER, NML, 0, ACS_TABLE_PTG_TARGET_TGT.second);
+  iht(objects::SUS_BOARD_ASS, NML, 0, ACS_TABLE_PTG_TARGET_TGT.second);
+  iht(objects::ACS_BOARD_ASS, NML, 0, ACS_TABLE_PTG_TARGET_TGT.second);
+  iht(objects::RW_ASS, NML, 0, ACS_TABLE_PTG_TARGET_TGT.second);
+  iht(objects::STAR_TRACKER, NML, 0, ACS_TABLE_PTG_TARGET_TGT.second);
+  check(ss.addTable(&ACS_TABLE_PTG_TARGET_TGT.second, ACS_TABLE_PTG_TARGET_TGT.first, false, true),
         ctxc);
 
+  // Transition 0 already built
   // Build TARGET PT transition 1
-  iht(objects::ACS_CONTROLLER, acs::CtrlModes::TARGET_PT, 0, ACS_TABLE_TARGET_PT_TRANS_1.second);
-  check(ss->addTable(&ACS_TABLE_TARGET_PT_TRANS_1.second, ACS_TABLE_TARGET_PT_TRANS_1.first, false,
-                     true),
+  iht(objects::ACS_CONTROLLER, NML, acs::CtrlSubmode::PTG_TARGET,
+      ACS_TABLE_PTG_TARGET_TRANS_1.second);
+  check(ss.addTable(&ACS_TABLE_PTG_TARGET_TRANS_1.second, ACS_TABLE_PTG_TARGET_TRANS_1.first, false,
+                    true),
         ctxc);
 
   // Build IDLE sequence
-  ihs(ACS_SEQUENCE_TARGET_PT.second, ACS_TABLE_TARGET_PT_TGT.first, 0, true);
-  ihs(ACS_SEQUENCE_TARGET_PT.second, ACS_TABLE_TARGET_PT_TRANS_0.first, 0, true);
-  ihs(ACS_SEQUENCE_TARGET_PT.second, ACS_TABLE_TARGET_PT_TRANS_1.first, 0, false);
-  check(ss->addSequence(&ACS_SEQUENCE_TARGET_PT.second, ACS_SEQUENCE_TARGET_PT.first,
-                        ACS_SEQUENCE_IDLE.first, false, true),
+  ihs(ACS_SEQUENCE_PTG_TARGET.second, ACS_TABLE_PTG_TARGET_TGT.first, 0, true);
+  ihs(ACS_SEQUENCE_PTG_TARGET.second, ACS_TABLE_PTG_TRANS_0.first, 0, true);
+  ihs(ACS_SEQUENCE_PTG_TARGET.second, ACS_TABLE_PTG_TARGET_TRANS_1.first, 0, true);
+  check(ss.addSequence(&ACS_SEQUENCE_PTG_TARGET.second, ACS_SEQUENCE_PTG_TARGET.first,
+                       ACS_SEQUENCE_IDLE.first, false, true),
+        ctxc);
+}
+
+void buildTargetPtNadirSequence(Subsystem& ss, ModeListEntry& eh) {
+  std::string context = "satsystem::acs::buildTargetPtNadirSequence";
+  auto ctxc = context.c_str();
+  // Insert Helper Table
+  auto iht = [&](object_id_t obj, Mode_t mode, Submode_t submode,
+                 ArrayList<ModeListEntry>& sequence) {
+    eh.setObject(obj);
+    eh.setMode(mode);
+    eh.setSubmode(submode);
+    check(sequence.insert(eh), ctxc);
+  };
+  // Insert Helper Sequence
+  auto ihs = [&](ArrayList<ModeListEntry>& sequence, Mode_t tableId, uint32_t waitSeconds,
+                 bool checkSuccess) {
+    eh.setTableId(tableId);
+    eh.setWaitSeconds(waitSeconds);
+    eh.setCheckSuccess(checkSuccess);
+    check(sequence.insert(eh), ctxc);
+  };
+
+  // Build TARGET PT table
+  iht(objects::ACS_CONTROLLER, NML, acs::CtrlSubmode::PTG_TARGET,
+      ACS_TABLE_PTG_TARGET_NADIR_TGT.second);
+  iht(objects::IMTQ_HANDLER, NML, 0, ACS_TABLE_PTG_TARGET_NADIR_TGT.second);
+  iht(objects::SUS_BOARD_ASS, NML, 0, ACS_TABLE_PTG_TARGET_NADIR_TGT.second);
+  iht(objects::ACS_BOARD_ASS, NML, 0, ACS_TABLE_PTG_TARGET_NADIR_TGT.second);
+  iht(objects::RW_ASS, NML, 0, ACS_TABLE_PTG_TARGET_NADIR_TGT.second);
+  iht(objects::STAR_TRACKER, NML, 0, ACS_TABLE_PTG_TARGET_NADIR_TGT.second);
+  check(ss.addTable(TableEntry(ACS_TABLE_PTG_TARGET_NADIR_TGT.first,
+                               &ACS_TABLE_PTG_TARGET_NADIR_TGT.second)),
+        ctxc);
+
+  // Transition 0 already built
+  // Build TARGET PT transition 1
+  iht(objects::ACS_CONTROLLER, NML, acs::CtrlSubmode::PTG_TARGET_NADIR,
+      ACS_TABLE_PTG_TARGET_NADIR_TRANS_1.second);
+  check(ss.addTable(TableEntry(ACS_TABLE_PTG_TARGET_NADIR_TRANS_1.first,
+                               &ACS_TABLE_PTG_TARGET_NADIR_TRANS_1.second)),
+        ctxc);
+
+  // Build IDLE sequence
+  ihs(ACS_SEQUENCE_PTG_TARGET_NADIR.second, ACS_TABLE_PTG_TARGET_NADIR_TGT.first, 0, true);
+  ihs(ACS_SEQUENCE_PTG_TARGET_NADIR.second, ACS_TABLE_PTG_TRANS_0.first, 0, true);
+  ihs(ACS_SEQUENCE_PTG_TARGET_NADIR.second, ACS_TABLE_PTG_TARGET_NADIR_TRANS_1.first, 0, true);
+  check(
+      ss.addSequence(SequenceEntry(ACS_SEQUENCE_PTG_TARGET_NADIR.first,
+                                   &ACS_SEQUENCE_PTG_TARGET_NADIR.second, ACS_SEQUENCE_IDLE.first)),
+      ctxc);
+}
+
+void buildTargetPtGsSequence(Subsystem& ss, ModeListEntry& eh) {
+  std::string context = "satsystem::acs::buildTargetPtGsSequence";
+  auto ctxc = context.c_str();
+  // Insert Helper Table
+  auto iht = [&](object_id_t obj, Mode_t mode, Submode_t submode,
+                 ArrayList<ModeListEntry>& sequence) {
+    eh.setObject(obj);
+    eh.setMode(mode);
+    eh.setSubmode(submode);
+    check(sequence.insert(eh), ctxc);
+  };
+  // Insert Helper Sequence
+  auto ihs = [&](ArrayList<ModeListEntry>& sequence, Mode_t tableId, uint32_t waitSeconds,
+                 bool checkSuccess) {
+    eh.setTableId(tableId);
+    eh.setWaitSeconds(waitSeconds);
+    eh.setCheckSuccess(checkSuccess);
+    check(sequence.insert(eh), ctxc);
+  };
+
+  // Build TARGET PT table
+  iht(objects::ACS_CONTROLLER, NML, acs::CtrlSubmode::PTG_TARGET_GS,
+      ACS_TABLE_PTG_TARGET_GS_TGT.second);
+  iht(objects::IMTQ_HANDLER, NML, 0, ACS_TABLE_PTG_TARGET_GS_TGT.second);
+  iht(objects::SUS_BOARD_ASS, NML, 0, ACS_TABLE_PTG_TARGET_GS_TGT.second);
+  iht(objects::ACS_BOARD_ASS, NML, 0, ACS_TABLE_PTG_TARGET_GS_TGT.second);
+  iht(objects::RW_ASS, NML, 0, ACS_TABLE_PTG_TARGET_GS_TGT.second);
+  iht(objects::STAR_TRACKER, NML, 0, ACS_TABLE_PTG_TARGET_GS_TGT.second);
+  check(ss.addTable(
+            TableEntry(ACS_TABLE_PTG_TARGET_GS_TGT.first, &ACS_TABLE_PTG_TARGET_GS_TGT.second)),
+        ctxc);
+
+  // Transition 0 already built
+  // Build TARGET PT transition 1
+  iht(objects::ACS_CONTROLLER, NML, acs::CtrlSubmode::PTG_TARGET_GS,
+      ACS_TABLE_PTG_TARGET_GS_TRANS_1.second);
+  check(ss.addTable(TableEntry(ACS_TABLE_PTG_TARGET_GS_TRANS_1.first,
+                               &ACS_TABLE_PTG_TARGET_GS_TRANS_1.second)),
+        ctxc);
+
+  // Build IDLE sequence
+  ihs(ACS_SEQUENCE_PTG_TARGET_GS.second, ACS_TABLE_PTG_TARGET_GS_TGT.first, 0, true);
+  ihs(ACS_SEQUENCE_PTG_TARGET_GS.second, ACS_TABLE_PTG_TRANS_0.first, 0, true);
+  ihs(ACS_SEQUENCE_PTG_TARGET_GS.second, ACS_TABLE_PTG_TARGET_GS_TRANS_1.first, 0, true);
+  check(ss.addSequence(SequenceEntry(ACS_SEQUENCE_PTG_TARGET_GS.first,
+                                     &ACS_SEQUENCE_PTG_TARGET_GS.second, ACS_SEQUENCE_IDLE.first)),
+        ctxc);
+}
+
+void buildTargetPtInertialSequence(Subsystem& ss, ModeListEntry& eh) {
+  std::string context = "satsystem::acs::buildTargetPtInertialSequence";
+  auto ctxc = context.c_str();
+  // Insert Helper Table
+  auto iht = [&](object_id_t obj, Mode_t mode, Submode_t submode,
+                 ArrayList<ModeListEntry>& sequence) {
+    eh.setObject(obj);
+    eh.setMode(mode);
+    eh.setSubmode(submode);
+    check(sequence.insert(eh), ctxc);
+  };
+  // Insert Helper Sequence
+  auto ihs = [&](ArrayList<ModeListEntry>& sequence, Mode_t tableId, uint32_t waitSeconds,
+                 bool checkSuccess) {
+    eh.setTableId(tableId);
+    eh.setWaitSeconds(waitSeconds);
+    eh.setCheckSuccess(checkSuccess);
+    check(sequence.insert(eh), ctxc);
+  };
+
+  // Build TARGET PT table
+  iht(objects::ACS_CONTROLLER, NML, acs::CtrlSubmode::PTG_TARGET_INERTIAL,
+      ACS_TABLE_PTG_TARGET_INERTIAL_TGT.second);
+  iht(objects::IMTQ_HANDLER, NML, 0, ACS_TABLE_PTG_TARGET_INERTIAL_TGT.second);
+  iht(objects::SUS_BOARD_ASS, NML, 0, ACS_TABLE_PTG_TARGET_INERTIAL_TGT.second);
+  iht(objects::ACS_BOARD_ASS, NML, 0, ACS_TABLE_PTG_TARGET_INERTIAL_TGT.second);
+  iht(objects::RW_ASS, NML, 0, ACS_TABLE_PTG_TARGET_INERTIAL_TGT.second);
+  iht(objects::STAR_TRACKER, NML, 0, ACS_TABLE_PTG_TARGET_INERTIAL_TGT.second);
+  check(ss.addTable(TableEntry(ACS_TABLE_PTG_TARGET_INERTIAL_TGT.first,
+                               &ACS_TABLE_PTG_TARGET_INERTIAL_TGT.second)),
+        ctxc);
+
+  // Transition 0 already built
+  // Build TARGET PT transition 1
+  iht(objects::ACS_CONTROLLER, NML, acs::CtrlSubmode::PTG_TARGET_INERTIAL,
+      ACS_TABLE_PTG_TARGET_INERTIAL_TRANS_1.second);
+  check(ss.addTable(TableEntry(ACS_TABLE_PTG_TARGET_INERTIAL_TRANS_1.first,
+                               &ACS_TABLE_PTG_TARGET_INERTIAL_TRANS_1.second)),
+        ctxc);
+
+  // Build IDLE sequence
+  ihs(ACS_SEQUENCE_PTG_TARGET_INERTIAL.second, ACS_TABLE_PTG_TARGET_INERTIAL_TGT.first, 0, true);
+  ihs(ACS_SEQUENCE_PTG_TARGET_INERTIAL.second, ACS_TABLE_PTG_TRANS_0.first, 0, true);
+  ihs(ACS_SEQUENCE_PTG_TARGET_INERTIAL.second, ACS_TABLE_PTG_TARGET_INERTIAL_TRANS_1.first, 0,
+      true);
+  check(ss.addSequence(SequenceEntry(ACS_SEQUENCE_PTG_TARGET_INERTIAL.first,
+                                     &ACS_SEQUENCE_PTG_TARGET_INERTIAL.second,
+                                     ACS_SEQUENCE_IDLE.first)),
         ctxc);
 }
 

mission/system/tree/acsModeTree.h

@@ -1,11 +1,9 @@
-#include <fsfw/subsystem/modes/ModeDefinitions.h>
-
-class Subsystem;
+#include <mission/system/objects/AcsSubsystem.h>
 
 namespace satsystem {
 namespace acs {
 
-extern Subsystem ACS_SUBSYSTEM;
+extern AcsSubsystem ACS_SUBSYSTEM;
 void init();
 
 }  // namespace acs

mission/system/tree/comModeTree.cpp

@@ -0,0 +1,281 @@
+#include "comModeTree.h"
+
+#include <fsfw/devicehandlers/DeviceHandlerIF.h>
+#include <fsfw/modes/HasModesIF.h>
+#include <fsfw/returnvalues/returnvalue.h>
+#include <fsfw/subsystem/Subsystem.h>
+
+#include "eive/objects.h"
+#include "mission/comDefs.h"
+#include "util.h"
+
+const auto check = subsystem::checkInsert;
+
+ComSubsystem satsystem::com::SUBSYSTEM = ComSubsystem(objects::COM_SUBSYSTEM, 12, 24);
+
+static const auto OFF = HasModesIF::MODE_OFF;
+static const auto ON = HasModesIF::MODE_ON;
+static const auto NML = DeviceHandlerIF::MODE_NORMAL;
+
+auto COM_SEQUENCE_RX_ONLY =
+    std::make_pair(::com::Submode::RX_ONLY, FixedArrayList<ModeListEntry, 3>());
+auto COM_TABLE_RX_ONLY_TGT =
+    std::make_pair((::com::Submode::RX_ONLY << 24) | 1, FixedArrayList<ModeListEntry, 3>());
+auto COM_TABLE_RX_ONLY_TRANS_0 =
+    std::make_pair((::com::Submode::RX_ONLY << 24) | 2, FixedArrayList<ModeListEntry, 3>());
+auto COM_TABLE_RX_ONLY_TRANS_1 =
+    std::make_pair((::com::Submode::RX_ONLY << 24) | 3, FixedArrayList<ModeListEntry, 3>());
+
+auto COM_SEQUENCE_RX_AND_TX_LOW_RATE =
+    std::make_pair(::com::Submode::RX_AND_TX_LOW_DATARATE, FixedArrayList<ModeListEntry, 3>());
+auto COM_TABLE_RX_AND_TX_LOW_RATE_TGT = std::make_pair(
+    (::com::Submode::RX_AND_TX_LOW_DATARATE << 24) | 1, FixedArrayList<ModeListEntry, 3>());
+auto COM_TABLE_RX_AND_TX_LOW_RATE_TRANS_0 = std::make_pair(
+    (::com::Submode::RX_AND_TX_LOW_DATARATE << 24) | 2, FixedArrayList<ModeListEntry, 3>());
+auto COM_TABLE_RX_AND_TX_LOW_RATE_TRANS_1 = std::make_pair(
+    (::com::Submode::RX_AND_TX_LOW_DATARATE << 24) | 3, FixedArrayList<ModeListEntry, 3>());
+
+auto COM_SEQUENCE_RX_AND_TX_HIGH_RATE =
+    std::make_pair(::com::Submode::RX_AND_TX_HIGH_DATARATE, FixedArrayList<ModeListEntry, 3>());
+auto COM_TABLE_RX_AND_TX_HIGH_RATE_TGT = std::make_pair(
+    (::com::Submode::RX_AND_TX_HIGH_DATARATE << 24) | 1, FixedArrayList<ModeListEntry, 3>());
+auto COM_TABLE_RX_AND_TX_HIGH_RATE_TRANS_0 = std::make_pair(
+    (::com::Submode::RX_AND_TX_HIGH_DATARATE << 24) | 2, FixedArrayList<ModeListEntry, 3>());
+auto COM_TABLE_RX_AND_TX_HIGH_RATE_TRANS_1 = std::make_pair(
+    (::com::Submode::RX_AND_TX_HIGH_DATARATE << 24) | 3, FixedArrayList<ModeListEntry, 3>());
+
+auto COM_SEQUENCE_RX_AND_TX_DEFAULT_RATE =
+    std::make_pair(::com::Submode::RX_AND_TX_DEFAULT_DATARATE, FixedArrayList<ModeListEntry, 3>());
+auto COM_TABLE_RX_AND_TX_DEFAULT_RATE_TGT = std::make_pair(
+    (::com::Submode::RX_AND_TX_DEFAULT_DATARATE << 24) | 1, FixedArrayList<ModeListEntry, 3>());
+auto COM_TABLE_RX_AND_TX_DEFAULT_RATE_TRANS_0 = std::make_pair(
+    (::com::Submode::RX_AND_TX_DEFAULT_DATARATE << 24) | 2, FixedArrayList<ModeListEntry, 3>());
+auto COM_TABLE_RX_AND_TX_DEFAULT_RATE_TRANS_1 = std::make_pair(
+    (::com::Submode::RX_AND_TX_DEFAULT_DATARATE << 24) | 3, FixedArrayList<ModeListEntry, 3>());
+
+namespace {
+
+void buildRxOnlySequence(Subsystem& ss, ModeListEntry& eh);
+void buildTxAndRxLowRateSequence(Subsystem& ss, ModeListEntry& eh);
+void buildTxAndRxHighRateSequence(Subsystem& ss, ModeListEntry& eh);
+void buildTxAndRxDefaultRateSequence(Subsystem& ss, ModeListEntry& eh);
+
+}  // namespace
+
+void satsystem::com::init() {
+  ModeListEntry entry;
+  buildRxOnlySequence(SUBSYSTEM, entry);
+  buildTxAndRxLowRateSequence(SUBSYSTEM, entry);
+  buildTxAndRxHighRateSequence(SUBSYSTEM, entry);
+  buildTxAndRxDefaultRateSequence(SUBSYSTEM, entry);
+  SUBSYSTEM.setInitialMode(NML, ::com::Submode::RX_ONLY);
+}
+
+namespace {
+
+void buildRxOnlySequence(Subsystem& ss, ModeListEntry& eh) {
+  std::string context = "satsystem::com::buildRxOnlySequence";
+  auto ctxc = context.c_str();
+  // Insert Helper Table
+  auto iht = [&](object_id_t obj, Mode_t mode, Submode_t submode, ArrayList<ModeListEntry>& table) {
+    eh.setObject(obj);
+    eh.setMode(mode);
+    eh.setSubmode(submode);
+    check(table.insert(eh), ctxc);
+  };
+  // Insert Helper Sequence
+  auto ihs = [&](ArrayList<ModeListEntry>& sequence, Mode_t tableId, uint32_t waitSeconds,
+                 bool checkSuccess) {
+    eh.setTableId(tableId);
+    eh.setWaitSeconds(waitSeconds);
+    eh.setCheckSuccess(checkSuccess);
+    check(sequence.insert(eh), ctxc);
+  };
+
+  // Build RX Only table. We could track the state of the CCSDS IP core handler
+  // as well but I do not think this is necessary because enabling that should
+  // not intefere with the Syrlinks Handler.
+  iht(objects::SYRLINKS_HANDLER, NML, ::com::Submode::RX_ONLY, COM_TABLE_RX_ONLY_TGT.second);
+  check(ss.addTable(TableEntry(COM_TABLE_RX_ONLY_TGT.first, &COM_TABLE_RX_ONLY_TGT.second)), ctxc);
+
+  // Build RX Only transition 0
+  iht(objects::SYRLINKS_HANDLER, NML, ::com::Submode::RX_ONLY, COM_TABLE_RX_ONLY_TRANS_0.second);
+  check(ss.addTable(TableEntry(COM_TABLE_RX_ONLY_TRANS_0.first, &COM_TABLE_RX_ONLY_TRANS_0.second)),
+        ctxc);
+
+  // Build RX Only transition 1
+  iht(objects::CCSDS_HANDLER, OFF, 0, COM_TABLE_RX_ONLY_TRANS_1.second);
+  check(ss.addTable(TableEntry(COM_TABLE_RX_ONLY_TRANS_1.first, &COM_TABLE_RX_ONLY_TRANS_1.second)),
+        ctxc);
+
+  // Build TX OFF sequence
+  ihs(COM_SEQUENCE_RX_ONLY.second, COM_TABLE_RX_ONLY_TGT.first, 0, true);
+  ihs(COM_SEQUENCE_RX_ONLY.second, COM_TABLE_RX_ONLY_TRANS_0.first, 0, false);
+  ihs(COM_SEQUENCE_RX_ONLY.second, COM_TABLE_RX_ONLY_TRANS_1.first, 0, false);
+  check(ss.addSequence(SequenceEntry(COM_SEQUENCE_RX_ONLY.first, &COM_SEQUENCE_RX_ONLY.second,
+                                     COM_SEQUENCE_RX_ONLY.first)),
+        ctxc);
+}
+
+void buildTxAndRxLowRateSequence(Subsystem& ss, ModeListEntry& eh) {
+  std::string context = "satsystem::com::buildTxAndRxLowRateSequence";
+  auto ctxc = context.c_str();
+  // Insert Helper Table
+  auto iht = [&](object_id_t obj, Mode_t mode, Submode_t submode, ArrayList<ModeListEntry>& table) {
+    eh.setObject(obj);
+    eh.setMode(mode);
+    eh.setSubmode(submode);
+    check(table.insert(eh), ctxc);
+  };
+  // Insert Helper Sequence
+  auto ihs = [&](ArrayList<ModeListEntry>& sequence, Mode_t tableId, uint32_t waitSeconds,
+                 bool checkSuccess) {
+    eh.setTableId(tableId);
+    eh.setWaitSeconds(waitSeconds);
+    eh.setCheckSuccess(checkSuccess);
+    check(sequence.insert(eh), ctxc);
+  };
+
+  // Build RX and TX low datarate table.
+  iht(objects::SYRLINKS_HANDLER, NML, ::com::Submode::RX_AND_TX_LOW_DATARATE,
+      COM_TABLE_RX_AND_TX_LOW_RATE_TGT.second);
+  iht(objects::CCSDS_HANDLER, ON, static_cast<Submode_t>(::com::CcsdsSubmode::DATARATE_LOW),
+      COM_TABLE_RX_AND_TX_LOW_RATE_TGT.second);
+  check(ss.addTable(TableEntry(COM_TABLE_RX_AND_TX_LOW_RATE_TGT.first,
+                               &COM_TABLE_RX_AND_TX_LOW_RATE_TGT.second)),
+        ctxc);
+
+  // Build TX and RX low datarate transition 0, switch CCSDS handler first
+  iht(objects::CCSDS_HANDLER, ON, static_cast<Submode_t>(::com::CcsdsSubmode::DATARATE_LOW),
+      COM_TABLE_RX_AND_TX_LOW_RATE_TRANS_0.second);
+  check(ss.addTable(TableEntry(COM_TABLE_RX_AND_TX_LOW_RATE_TRANS_0.first,
+                               &COM_TABLE_RX_AND_TX_LOW_RATE_TRANS_0.second)),
+        ctxc);
+
+  // Build TX and RX low transition 1
+  iht(objects::SYRLINKS_HANDLER, NML, ::com::Submode::RX_AND_TX_LOW_DATARATE,
+      COM_TABLE_RX_AND_TX_LOW_RATE_TRANS_1.second);
+  check(ss.addTable(TableEntry(COM_TABLE_RX_AND_TX_LOW_RATE_TRANS_1.first,
+                               &COM_TABLE_RX_AND_TX_LOW_RATE_TRANS_1.second)),
+        ctxc);
+
+  // Build TX and RX low datarate sequence
+  ihs(COM_SEQUENCE_RX_AND_TX_LOW_RATE.second, COM_TABLE_RX_AND_TX_LOW_RATE_TGT.first, 0, true);
+  ihs(COM_SEQUENCE_RX_AND_TX_LOW_RATE.second, COM_TABLE_RX_AND_TX_LOW_RATE_TRANS_0.first, 0, false);
+  ihs(COM_SEQUENCE_RX_AND_TX_LOW_RATE.second, COM_TABLE_RX_AND_TX_LOW_RATE_TRANS_1.first, 0, false);
+  check(ss.addSequence(SequenceEntry(COM_SEQUENCE_RX_AND_TX_LOW_RATE.first,
+                                     &COM_SEQUENCE_RX_AND_TX_LOW_RATE.second,
+                                     COM_SEQUENCE_RX_ONLY.first)),
+        ctxc);
+}
+
+void buildTxAndRxHighRateSequence(Subsystem& ss, ModeListEntry& eh) {
+  std::string context = "satsystem::com::buildTxAndRxHighRateSequence";
+  auto ctxc = context.c_str();
+  // Insert Helper Table
+  auto iht = [&](object_id_t obj, Mode_t mode, Submode_t submode, ArrayList<ModeListEntry>& table) {
+    eh.setObject(obj);
+    eh.setMode(mode);
+    eh.setSubmode(submode);
+    check(table.insert(eh), ctxc);
+  };
+  // Insert Helper Sequence
+  auto ihs = [&](ArrayList<ModeListEntry>& sequence, Mode_t tableId, uint32_t waitSeconds,
+                 bool checkSuccess) {
+    eh.setTableId(tableId);
+    eh.setWaitSeconds(waitSeconds);
+    eh.setCheckSuccess(checkSuccess);
+    check(sequence.insert(eh), ctxc);
+  };
+
+  // Build RX and TX high datarate table.
+  iht(objects::SYRLINKS_HANDLER, NML, ::com::Submode::RX_AND_TX_HIGH_DATARATE,
+      COM_TABLE_RX_AND_TX_HIGH_RATE_TGT.second);
+  iht(objects::CCSDS_HANDLER, ON, static_cast<Submode_t>(::com::CcsdsSubmode::DATARATE_HIGH),
+      COM_TABLE_RX_AND_TX_HIGH_RATE_TGT.second);
+  check(ss.addTable(TableEntry(COM_TABLE_RX_AND_TX_HIGH_RATE_TGT.first,
+                               &COM_TABLE_RX_AND_TX_HIGH_RATE_TGT.second)),
+        ctxc);
+
+  // Build TX and RX high datarate transition 0, switch CCSDS handler first
+  iht(objects::CCSDS_HANDLER, ON, static_cast<Submode_t>(::com::CcsdsSubmode::DATARATE_HIGH),
+      COM_TABLE_RX_AND_TX_HIGH_RATE_TRANS_0.second);
+  check(ss.addTable(TableEntry(COM_TABLE_RX_AND_TX_HIGH_RATE_TRANS_0.first,
+                               &COM_TABLE_RX_AND_TX_HIGH_RATE_TRANS_0.second)),
+        ctxc);
+
+  // Build TX and RX high transition 1
+  iht(objects::SYRLINKS_HANDLER, NML, ::com::Submode::RX_AND_TX_HIGH_DATARATE,
+      COM_TABLE_RX_AND_TX_HIGH_RATE_TRANS_1.second);
+  check(ss.addTable(TableEntry(COM_TABLE_RX_AND_TX_HIGH_RATE_TRANS_1.first,
+                               &COM_TABLE_RX_AND_TX_HIGH_RATE_TRANS_1.second)),
+        ctxc);
+
+  // Build TX and RX low datarate sequence
+  ihs(COM_SEQUENCE_RX_AND_TX_HIGH_RATE.second, COM_TABLE_RX_AND_TX_HIGH_RATE_TGT.first, 0, true);
+  ihs(COM_SEQUENCE_RX_AND_TX_HIGH_RATE.second, COM_TABLE_RX_AND_TX_HIGH_RATE_TRANS_0.first, 0,
+      false);
+  ihs(COM_SEQUENCE_RX_AND_TX_HIGH_RATE.second, COM_TABLE_RX_AND_TX_HIGH_RATE_TRANS_1.first, 0,
+      false);
+  check(ss.addSequence(SequenceEntry(COM_SEQUENCE_RX_AND_TX_HIGH_RATE.first,
+                                     &COM_SEQUENCE_RX_AND_TX_HIGH_RATE.second,
+                                     COM_SEQUENCE_RX_ONLY.first)),
+        ctxc);
+}
+
+void buildTxAndRxDefaultRateSequence(Subsystem& ss, ModeListEntry& eh) {
+  std::string context = "satsystem::com::buildTxAndRxDefaultRateSequence";
+  auto ctxc = context.c_str();
+  // Insert Helper Table
+  auto iht = [&](object_id_t obj, Mode_t mode, Submode_t submode, ArrayList<ModeListEntry>& table) {
+    eh.setObject(obj);
+    eh.setMode(mode);
+    eh.setSubmode(submode);
+    check(table.insert(eh), ctxc);
+  };
+  // Insert Helper Sequence
+  auto ihs = [&](ArrayList<ModeListEntry>& sequence, Mode_t tableId, uint32_t waitSeconds,
+                 bool checkSuccess) {
+    eh.setTableId(tableId);
+    eh.setWaitSeconds(waitSeconds);
+    eh.setCheckSuccess(checkSuccess);
+    check(sequence.insert(eh), ctxc);
+  };
+
+  // Build RX and TX default datarate table.
+  iht(objects::SYRLINKS_HANDLER, NML, ::com::Submode::RX_AND_TX_DEFAULT_DATARATE,
+      COM_TABLE_RX_AND_TX_DEFAULT_RATE_TGT.second);
+  iht(objects::CCSDS_HANDLER, ON, static_cast<Submode_t>(::com::CcsdsSubmode::DATARATE_DEFAULT),
+      COM_TABLE_RX_AND_TX_DEFAULT_RATE_TGT.second);
+  check(ss.addTable(TableEntry(COM_TABLE_RX_AND_TX_DEFAULT_RATE_TGT.first,
+                               &COM_TABLE_RX_AND_TX_DEFAULT_RATE_TGT.second)),
+        ctxc);
+
+  // Build TX and RX low datarate transition 0, switch CCSDS handler first
+  iht(objects::CCSDS_HANDLER, ON, static_cast<Submode_t>(::com::CcsdsSubmode::DATARATE_DEFAULT),
+      COM_TABLE_RX_AND_TX_DEFAULT_RATE_TRANS_0.second);
+  check(ss.addTable(TableEntry(COM_TABLE_RX_AND_TX_DEFAULT_RATE_TRANS_0.first,
+                               &COM_TABLE_RX_AND_TX_DEFAULT_RATE_TRANS_0.second)),
+        ctxc);
+
+  // Build TX and RX default transition 1
+  iht(objects::SYRLINKS_HANDLER, NML, ::com::Submode::RX_AND_TX_DEFAULT_DATARATE,
+      COM_TABLE_RX_AND_TX_DEFAULT_RATE_TRANS_1.second);
+  check(ss.addTable(TableEntry(COM_TABLE_RX_AND_TX_DEFAULT_RATE_TRANS_1.first,
+                               &COM_TABLE_RX_AND_TX_DEFAULT_RATE_TRANS_1.second)),
+        ctxc);
+
+  // Build TX and RX default datarate sequence
+  ihs(COM_SEQUENCE_RX_AND_TX_DEFAULT_RATE.second, COM_TABLE_RX_AND_TX_DEFAULT_RATE_TGT.first, 0,
+      true);
+  ihs(COM_SEQUENCE_RX_AND_TX_DEFAULT_RATE.second, COM_TABLE_RX_AND_TX_DEFAULT_RATE_TRANS_0.first, 0,
+      false);
+  ihs(COM_SEQUENCE_RX_AND_TX_DEFAULT_RATE.second, COM_TABLE_RX_AND_TX_DEFAULT_RATE_TRANS_1.first, 0,
+      false);
+  check(ss.addSequence(SequenceEntry(COM_SEQUENCE_RX_AND_TX_DEFAULT_RATE.first,
+                                     &COM_SEQUENCE_RX_AND_TX_DEFAULT_RATE.second,
+                                     COM_SEQUENCE_RX_ONLY.first)),
+        ctxc);
+}
+
+}  // namespace

mission/system/tree/comModeTree.h

@@ -0,0 +1,16 @@
+#ifndef MISSION_SYSTEM_TREE_COMMODETREE_H_
+#define MISSION_SYSTEM_TREE_COMMODETREE_H_
+
+#include <mission/system/objects/ComSubsystem.h>
+
+namespace satsystem {
+
+namespace com {
+extern ComSubsystem SUBSYSTEM;
+
+void init();
+}  // namespace com
+
+}  // namespace satsystem
+
+#endif /* MISSION_SYSTEM_TREE_COMMODETREE_H_ */

mission/system/tree/payloadModeTree.cpp

@@ -27,53 +27,55 @@ static const auto OFF = HasModesIF::MODE_OFF;
 static const auto ON = HasModesIF::MODE_ON;
 static const auto NML = DeviceHandlerIF::MODE_NORMAL;
 
-auto PL_SEQUENCE_OFF = std::make_pair(OFF << 24, FixedArrayList<ModeListEntry, 3>());
-auto PL_TABLE_OFF_TGT = std::make_pair((OFF << 24) | 1, FixedArrayList<ModeListEntry, 1>());
-auto PL_TABLE_OFF_TRANS_0 = std::make_pair((OFF << 24) | 2, FixedArrayList<ModeListEntry, 5>());
-auto PL_TABLE_OFF_TRANS_1 = std::make_pair((OFF << 24) | 3, FixedArrayList<ModeListEntry, 1>());
+auto PL_SEQUENCE_OFF = std::make_pair(payload::Mode::OFF, FixedArrayList<ModeListEntry, 3>());
+auto PL_TABLE_OFF_TGT =
+    std::make_pair((payload::Mode::OFF << 24) | 1, FixedArrayList<ModeListEntry, 1>());
+auto PL_TABLE_OFF_TRANS_0 =
+    std::make_pair((payload::Mode::OFF << 24) | 2, FixedArrayList<ModeListEntry, 5>());
+auto PL_TABLE_OFF_TRANS_1 =
+    std::make_pair((payload::Mode::OFF << 24) | 3, FixedArrayList<ModeListEntry, 1>());
 
 auto PL_SEQUENCE_MPSOC_STREAM =
-    std::make_pair(payload::Modes::MPSOC_STREAM << 24, FixedArrayList<ModeListEntry, 3>());
+    std::make_pair(payload::Mode::MPSOC_STREAM, FixedArrayList<ModeListEntry, 3>());
 auto PL_TABLE_MPSOC_STREAM_TGT =
-    std::make_pair((payload::Modes::MPSOC_STREAM << 24) | 1, FixedArrayList<ModeListEntry, 5>());
+    std::make_pair((payload::Mode::MPSOC_STREAM << 24) | 1, FixedArrayList<ModeListEntry, 5>());
 auto PL_TABLE_MPSOC_STREAM_TRANS_0 =
-    std::make_pair((payload::Modes::MPSOC_STREAM << 24) | 2, FixedArrayList<ModeListEntry, 4>());
+    std::make_pair((payload::Mode::MPSOC_STREAM << 24) | 2, FixedArrayList<ModeListEntry, 4>());
 auto PL_TABLE_MPSOC_STREAM_TRANS_1 =
-    std::make_pair((payload::Modes::MPSOC_STREAM << 24) | 3, FixedArrayList<ModeListEntry, 2>());
+    std::make_pair((payload::Mode::MPSOC_STREAM << 24) | 3, FixedArrayList<ModeListEntry, 2>());
 
 auto PL_SEQUENCE_CAM_STREAM =
-    std::make_pair(payload::Modes::CAM_STREAM << 24, FixedArrayList<ModeListEntry, 3>());
+    std::make_pair(payload::Mode::CAM_STREAM, FixedArrayList<ModeListEntry, 3>());
 auto PL_TABLE_CAM_STREAM_TGT =
-    std::make_pair((payload::Modes::CAM_STREAM << 24) | 1, FixedArrayList<ModeListEntry, 2>());
+    std::make_pair((payload::Mode::CAM_STREAM << 24) | 1, FixedArrayList<ModeListEntry, 2>());
 auto PL_TABLE_CAM_STREAM_TRANS_0 =
-    std::make_pair((payload::Modes::CAM_STREAM << 24) | 2, FixedArrayList<ModeListEntry, 4>());
+    std::make_pair((payload::Mode::CAM_STREAM << 24) | 2, FixedArrayList<ModeListEntry, 4>());
 auto PL_TABLE_CAM_STREAM_TRANS_1 =
-    std::make_pair((payload::Modes::CAM_STREAM << 24) | 3, FixedArrayList<ModeListEntry, 2>());
+    std::make_pair((payload::Mode::CAM_STREAM << 24) | 3, FixedArrayList<ModeListEntry, 2>());
 
 auto PL_SEQUENCE_SUPV_ONLY =
-    std::make_pair(payload::Modes::SUPV_ONLY << 24, FixedArrayList<ModeListEntry, 3>());
+    std::make_pair(payload::Mode::SUPV_ONLY, FixedArrayList<ModeListEntry, 3>());
 auto PL_TABLE_SUPV_ONLY_TGT =
-    std::make_pair((payload::Modes::SUPV_ONLY << 24) | 1, FixedArrayList<ModeListEntry, 5>());
+    std::make_pair((payload::Mode::SUPV_ONLY << 24) | 1, FixedArrayList<ModeListEntry, 5>());
 auto PL_TABLE_SUPV_ONLY_TRANS_0 =
-    std::make_pair((payload::Modes::SUPV_ONLY << 24) | 2, FixedArrayList<ModeListEntry, 5>());
+    std::make_pair((payload::Mode::SUPV_ONLY << 24) | 2, FixedArrayList<ModeListEntry, 5>());
 auto PL_TABLE_SUPV_ONLY_TRANS_1 =
-    std::make_pair((payload::Modes::SUPV_ONLY << 24) | 3, FixedArrayList<ModeListEntry, 5>());
+    std::make_pair((payload::Mode::SUPV_ONLY << 24) | 3, FixedArrayList<ModeListEntry, 5>());
 
 auto PL_SEQUENCE_EARTH_OBSV =
-    std::make_pair(payload::Modes::EARTH_OBSV << 24, FixedArrayList<ModeListEntry, 3>());
+    std::make_pair(payload::Mode::EARTH_OBSV, FixedArrayList<ModeListEntry, 3>());
 auto PL_TABLE_EARTH_OBSV_TGT =
-    std::make_pair((payload::Modes::EARTH_OBSV << 24) | 1, FixedArrayList<ModeListEntry, 5>());
+    std::make_pair((payload::Mode::EARTH_OBSV << 24) | 1, FixedArrayList<ModeListEntry, 5>());
 auto PL_TABLE_EARTH_OBSV_TRANS_0 =
-    std::make_pair((payload::Modes::EARTH_OBSV << 24) | 2, FixedArrayList<ModeListEntry, 3>());
+    std::make_pair((payload::Mode::EARTH_OBSV << 24) | 2, FixedArrayList<ModeListEntry, 3>());
 auto PL_TABLE_EARTH_OBSV_TRANS_1 =
-    std::make_pair((payload::Modes::EARTH_OBSV << 24) | 3, FixedArrayList<ModeListEntry, 2>());
+    std::make_pair((payload::Mode::EARTH_OBSV << 24) | 3, FixedArrayList<ModeListEntry, 2>());
 
-auto PL_SEQUENCE_SCEX =
-    std::make_pair(payload::Modes::SCEX << 24, FixedArrayList<ModeListEntry, 2>());
+auto PL_SEQUENCE_SCEX = std::make_pair(payload::Mode::SCEX, FixedArrayList<ModeListEntry, 2>());
 auto PL_TABLE_SCEX_TGT =
-    std::make_pair((payload::Modes::SCEX << 24) | 1, FixedArrayList<ModeListEntry, 1>());
+    std::make_pair((payload::Mode::SCEX << 24) | 1, FixedArrayList<ModeListEntry, 1>());
 auto PL_TABLE_SCEX_TRANS_0 =
-    std::make_pair((payload::Modes::SCEX << 24) | 2, FixedArrayList<ModeListEntry, 1>());
+    std::make_pair((payload::Mode::SCEX << 24) | 2, FixedArrayList<ModeListEntry, 1>());
 
 void satsystem::pl::init() {
   ModeListEntry entry;

mission/system/tree/system.cpp

@@ -1,9 +1,13 @@
 #include "system.h"
 
 #include "acsModeTree.h"
+#include "comModeTree.h"
 #include "payloadModeTree.h"
+#include "tcsModeTree.h"
 
 void satsystem::init() {
   acs::init();
   pl::init();
+  tcs::init();
+  com::init();
 }

mission/system/tree/tcsModeTree.cpp

@@ -0,0 +1,125 @@
+#include "tcsModeTree.h"
+
+#include "eive/objects.h"
+#include "fsfw/devicehandlers/DeviceHandlerIF.h"
+#include "fsfw/subsystem/Subsystem.h"
+#include "mission/system/tree/util.h"
+
+Subsystem satsystem::tcs::SUBSYSTEM(objects::TCS_SUBSYSTEM, 12, 24);
+
+namespace {
+// Alias for checker function
+const auto check = subsystem::checkInsert;
+void buildOffSequence(Subsystem& ss, ModeListEntry& eh);
+void buildNormalSequence(Subsystem& ss, ModeListEntry& eh);
+}  // namespace
+
+static const auto OFF = HasModesIF::MODE_OFF;
+static const auto NML = DeviceHandlerIF::MODE_NORMAL;
+
+auto TCS_SEQUENCE_OFF = std::make_pair(OFF, FixedArrayList<ModeListEntry, 3>());
+auto TCS_TABLE_OFF_TGT = std::make_pair((OFF << 24) | 1, FixedArrayList<ModeListEntry, 2>());
+auto TCS_TABLE_OFF_TRANS_0 = std::make_pair((OFF << 24) | 2, FixedArrayList<ModeListEntry, 7>());
+auto TCS_TABLE_OFF_TRANS_1 = std::make_pair((OFF << 24) | 3, FixedArrayList<ModeListEntry, 2>());
+
+auto TCS_SEQUENCE_NORMAL = std::make_pair(NML, FixedArrayList<ModeListEntry, 3>());
+auto TCS_TABLE_NORMAL_TGT = std::make_pair((NML << 24) | 1, FixedArrayList<ModeListEntry, 2>());
+auto TCS_TABLE_NORMAL_TRANS_0 = std::make_pair((NML << 24) | 2, FixedArrayList<ModeListEntry, 7>());
+auto TCS_TABLE_NORMAL_TRANS_1 = std::make_pair((NML << 24) | 3, FixedArrayList<ModeListEntry, 2>());
+
+void satsystem::tcs::init() {
+  ModeListEntry entry;
+  buildOffSequence(SUBSYSTEM, entry);
+  buildNormalSequence(SUBSYSTEM, entry);
+  SUBSYSTEM.setInitialMode(OFF);
+}
+
+namespace {
+
+void buildOffSequence(Subsystem& ss, ModeListEntry& eh) {
+  std::string context = "satsystem::tcs::buildOffSequence";
+  auto ctxc = context.c_str();
+  // Insert Helper Table
+  auto iht = [&](object_id_t obj, Mode_t mode, Submode_t submode, ArrayList<ModeListEntry>& table) {
+    eh.setObject(obj);
+    eh.setMode(mode);
+    eh.setSubmode(submode);
+    check(table.insert(eh), ctxc);
+  };
+  // Insert Helper Sequence
+  auto ihs = [&](ArrayList<ModeListEntry>& sequence, Mode_t tableId, uint32_t waitSeconds,
+                 bool checkSuccess) {
+    eh.setTableId(tableId);
+    eh.setWaitSeconds(waitSeconds);
+    eh.setCheckSuccess(checkSuccess);
+    check(sequence.insert(eh), ctxc);
+  };
+
+  // OFF target table is empty
+  check(ss.addTable(TableEntry(TCS_TABLE_OFF_TGT.first, &TCS_TABLE_OFF_TGT.second)), ctxc);
+
+  iht(objects::TCS_BOARD_ASS, OFF, 0, TCS_TABLE_OFF_TRANS_0.second);
+  iht(objects::TMP1075_HANDLER_TCS_0, OFF, 0, TCS_TABLE_OFF_TRANS_0.second);
+  iht(objects::TMP1075_HANDLER_TCS_1, OFF, 0, TCS_TABLE_OFF_TRANS_0.second);
+  iht(objects::TMP1075_HANDLER_PLPCDU_0, OFF, 0, TCS_TABLE_OFF_TRANS_0.second);
+  // damaged
+  // iht(objects::TMP1075_HANDLER_PLPCDU_1, OFF, 0, TCS_TABLE_OFF_TRANS_0.second);
+  iht(objects::TMP1075_HANDLER_IF_BOARD, OFF, 0, TCS_TABLE_OFF_TRANS_0.second);
+  check(ss.addTable(TableEntry(TCS_TABLE_OFF_TRANS_0.first, &TCS_TABLE_OFF_TRANS_0.second)), ctxc);
+
+  iht(objects::THERMAL_CONTROLLER, OFF, 0, TCS_TABLE_OFF_TRANS_0.second);
+  check(ss.addTable(TableEntry(TCS_TABLE_OFF_TRANS_1.first, &TCS_TABLE_OFF_TRANS_1.second)), ctxc);
+
+  ihs(TCS_SEQUENCE_OFF.second, TCS_TABLE_OFF_TGT.first, 0, false);
+  ihs(TCS_SEQUENCE_OFF.second, TCS_TABLE_OFF_TRANS_0.first, 0, false);
+  ihs(TCS_SEQUENCE_OFF.second, TCS_TABLE_OFF_TRANS_1.first, 0, false);
+  check(ss.addSequence(SequenceEntry(TCS_SEQUENCE_OFF.first, &TCS_SEQUENCE_OFF.second,
+                                     TCS_SEQUENCE_OFF.first)),
+        ctxc);
+}
+
+void buildNormalSequence(Subsystem& ss, ModeListEntry& eh) {
+  std::string context = "satsystem::tcs::buildNormalSequence";
+  auto ctxc = context.c_str();
+  // Insert Helper Table
+  auto iht = [&](object_id_t obj, Mode_t mode, Submode_t submode, ArrayList<ModeListEntry>& table) {
+    eh.setObject(obj);
+    eh.setMode(mode);
+    eh.setSubmode(submode);
+    check(table.insert(eh), ctxc);
+  };
+  // Insert Helper Sequence
+  auto ihs = [&](ArrayList<ModeListEntry>& sequence, Mode_t tableId, uint32_t waitSeconds,
+                 bool checkSuccess) {
+    eh.setTableId(tableId);
+    eh.setWaitSeconds(waitSeconds);
+    eh.setCheckSuccess(checkSuccess);
+    check(sequence.insert(eh), ctxc);
+  };
+
+  // OFF target table is empty
+  check(ss.addTable(TableEntry(TCS_TABLE_NORMAL_TGT.first, &TCS_TABLE_NORMAL_TGT.second)), ctxc);
+
+  iht(objects::TCS_BOARD_ASS, NML, 0, TCS_TABLE_NORMAL_TRANS_0.second);
+  iht(objects::TMP1075_HANDLER_TCS_0, NML, 0, TCS_TABLE_NORMAL_TRANS_0.second);
+  iht(objects::TMP1075_HANDLER_TCS_1, NML, 0, TCS_TABLE_NORMAL_TRANS_0.second);
+  iht(objects::TMP1075_HANDLER_PLPCDU_0, NML, 0, TCS_TABLE_NORMAL_TRANS_0.second);
+  // damaged
+  // iht(objects::TMP1075_HANDLER_PLPCDU_1, NML, 0, TCS_TABLE_NORMAL_TRANS_0.second);
+  iht(objects::TMP1075_HANDLER_IF_BOARD, NML, 0, TCS_TABLE_NORMAL_TRANS_0.second);
+  check(ss.addTable(TableEntry(TCS_TABLE_NORMAL_TRANS_0.first, &TCS_TABLE_NORMAL_TRANS_0.second)),
+        ctxc);
+
+  iht(objects::THERMAL_CONTROLLER, NML, 0, TCS_TABLE_NORMAL_TRANS_0.second);
+  check(ss.addTable(TableEntry(TCS_TABLE_NORMAL_TRANS_1.first, &TCS_TABLE_NORMAL_TRANS_1.second)),
+        ctxc);
+
+  ihs(TCS_SEQUENCE_NORMAL.second, TCS_TABLE_NORMAL_TGT.first, 0, false);
+  ihs(TCS_SEQUENCE_NORMAL.second, TCS_TABLE_NORMAL_TRANS_0.first, 0, false);
+  ihs(TCS_SEQUENCE_NORMAL.second, TCS_TABLE_NORMAL_TRANS_1.first, 0, false);
+  check(ss.addSequence(SequenceEntry(TCS_SEQUENCE_NORMAL.first, &TCS_SEQUENCE_NORMAL.second,
+                                     TCS_SEQUENCE_NORMAL.first)),
+        ctxc);
+}
+
+}  // namespace

mission/system/tree/tcsModeTree.h

@@ -0,0 +1,15 @@
+#ifndef MISSION_SYSTEM_TREE_TCSMODETREE_H_
+#define MISSION_SYSTEM_TREE_TCSMODETREE_H_
+
+class Subsystem;
+
+namespace satsystem {
+namespace tcs {
+
+extern Subsystem SUBSYSTEM;
+void init();
+
+}  // namespace tcs
+}  // namespace satsystem
+
+#endif /* MISSION_SYSTEM_TREE_TCSMODETREE_H_ */

mission/tmtc/CcsdsIpCoreHandler.cpp

@@ -1,8 +1,11 @@
 #include "CcsdsIpCoreHandler.h"
 
+#include <fsfw/subsystem/helper.h>
 #include <linux/ipcore/PdecHandler.h>
 #include <linux/ipcore/PtmeConfig.h>
+#include <mission/config/comCfg.h>
 
+#include "eive/definitions.h"
 #include "fsfw/events/EventManagerIF.h"
 #include "fsfw/ipc/QueueFactory.h"
 #include "fsfw/objectmanager/ObjectManager.h"
@@ -20,6 +23,7 @@ CcsdsIpCoreHandler::CcsdsIpCoreHandler(object_id_t objectId, object_id_t ptmeId,
       tcDestination(tcDestination),
       parameterHelper(this),
       actionHelper(this, nullptr),
+      modeHelper(this),
       ptmeConfig(ptmeConfig),
       gpioIF(gpioIF),
       enTxClock(enTxClock),
@@ -80,6 +84,11 @@ ReturnValue_t CcsdsIpCoreHandler::initialize() {
     return result;
   }
 
+  result = modeHelper.initialize();
+  if (result != returnvalue::OK) {
+    return result;
+  }
+
   VirtualChannelMapIter iter;
   for (iter = virtualChannelMap.begin(); iter != virtualChannelMap.end(); iter++) {
     result = iter->second->initialize();
@@ -126,10 +135,12 @@ ReturnValue_t CcsdsIpCoreHandler::initialize() {
     return ObjectManagerIF::CHILD_INIT_FAILED;
   }
 
+  transmitterCountdown.setTimeout(transmitterTimeout);
+  transmitterCountdown.timeOut();
+
 #if OBSW_SYRLINKS_SIMULATED == 1
   // Update data on rising edge
   ptmeConfig->invertTxClock(false);
-  transmitterCountdown.setTimeout(transmitterTimeout);
   linkState = UP;
   forwardLinkstate();
 #endif /* OBSW_SYRLINKS_SIMULATED == 1*/
@@ -151,6 +162,10 @@ void CcsdsIpCoreHandler::readCommandQueue(void) {
     if (result == returnvalue::OK) {
       return;
     }
+    result = modeHelper.handleModeCommand(&commandMessage);
+    if (result == returnvalue::OK) {
+      return;
+    }
     CommandMessage reply;
     reply.setReplyRejected(CommandMessage::UNKNOWN_COMMAND, commandMessage.getCommand());
     commandQueue->reply(&reply);
@@ -161,7 +176,7 @@ void CcsdsIpCoreHandler::readCommandQueue(void) {
 MessageQueueId_t CcsdsIpCoreHandler::getCommandQueue() const { return commandQueue->getId(); }
 
 void CcsdsIpCoreHandler::addVirtualChannel(VcId_t vcId, VirtualChannel* virtualChannel) {
-  if (vcId > common::NUMBER_OF_VIRTUAL_CHANNELS) {
+  if (vcId > config::NUMBER_OF_VIRTUAL_CHANNELS) {
     sif::warning << "CcsdsHandler::addVirtualChannel: Invalid virtual channel ID" << std::endl;
     return;
   }
@@ -182,7 +197,7 @@ void CcsdsIpCoreHandler::addVirtualChannel(VcId_t vcId, VirtualChannel* virtualC
 }
 
 MessageQueueId_t CcsdsIpCoreHandler::getReportReceptionQueue(uint8_t virtualChannel) const {
-  if (virtualChannel < common::NUMBER_OF_VIRTUAL_CHANNELS) {
+  if (virtualChannel < config::NUMBER_OF_VIRTUAL_CHANNELS) {
     auto iter = virtualChannelMap.find(virtualChannel);
     if (iter != virtualChannelMap.end()) {
       return iter->second->getReportReceptionQueue();
@@ -217,10 +232,12 @@ ReturnValue_t CcsdsIpCoreHandler::executeAction(ActionId_t actionId, MessageQueu
   ReturnValue_t result = returnvalue::OK;
   switch (actionId) {
     case SET_LOW_RATE: {
+      submode = static_cast<Submode_t>(com::CcsdsSubmode::DATARATE_LOW);
       result = ptmeConfig->setRate(RATE_100KBPS);
       break;
     }
     case SET_HIGH_RATE: {
+      submode = static_cast<Submode_t>(com::CcsdsSubmode::DATARATE_HIGH);
       result = ptmeConfig->setRate(RATE_500KBPS);
       break;
     }
@@ -232,10 +249,16 @@ ReturnValue_t CcsdsIpCoreHandler::executeAction(ActionId_t actionId, MessageQueu
     }
     case EN_TRANSMITTER: {
       enableTransmit();
+      if (mode == HasModesIF::MODE_OFF) {
+        mode = HasModesIF::MODE_ON;
+      }
       return EXECUTION_FINISHED;
     }
     case DISABLE_TRANSMITTER: {
       disableTransmit();
+      if (mode == HasModesIF::MODE_ON) {
+        mode = HasModesIF::MODE_OFF;
+      }
       return EXECUTION_FINISHED;
     }
     case ENABLE_TX_CLK_MANIPULATOR: {
@@ -327,6 +350,9 @@ void CcsdsIpCoreHandler::enableTransmit() {
   gpioIF->pullHigh(enTxClock);
   gpioIF->pullHigh(enTxData);
 #endif
+  linkState = UP;
+  forwardLinkstate();
+  transmitterCountdown.resetTimer();
 }
 
 void CcsdsIpCoreHandler::checkTxTimer() {
@@ -335,9 +361,69 @@ void CcsdsIpCoreHandler::checkTxTimer() {
   }
   if (transmitterCountdown.hasTimedOut()) {
     disableTransmit();
+    // TODO: set mode to off (move timer to subsystem)
   }
 }
 
+void CcsdsIpCoreHandler::getMode(Mode_t* mode, Submode_t* submode) {
+  *mode = this->mode;
+  *submode = this->submode;
+}
+
+ReturnValue_t CcsdsIpCoreHandler::checkModeCommand(Mode_t mode, Submode_t submode,
+                                                   uint32_t* msToReachTheMode) {
+  if (mode == HasModesIF::MODE_ON) {
+    if (submode != static_cast<Submode_t>(com::CcsdsSubmode::DATARATE_HIGH) and
+        submode != static_cast<Submode_t>(com::CcsdsSubmode::DATARATE_LOW) and
+        submode != static_cast<Submode_t>(com::CcsdsSubmode::DATARATE_DEFAULT)) {
+      return HasModesIF::INVALID_SUBMODE;
+    }
+  } else if (mode != HasModesIF::MODE_OFF) {
+    return returnvalue::FAILED;
+  }
+  *msToReachTheMode = 2000;
+  return returnvalue::OK;
+}
+
+void CcsdsIpCoreHandler::startTransition(Mode_t mode, Submode_t submode) {
+  auto rateHigh = [&]() {
+    ReturnValue_t result = ptmeConfig->setRate(RATE_500KBPS);
+    if (result == returnvalue::OK) {
+      this->mode = HasModesIF::MODE_ON;
+    }
+  };
+  auto rateLow = [&]() {
+    ReturnValue_t result = ptmeConfig->setRate(RATE_100KBPS);
+    if (result == returnvalue::OK) {
+      this->mode = HasModesIF::MODE_ON;
+    }
+  };
+  if (mode == HasModesIF::MODE_ON) {
+    enableTransmit();
+    if (submode == static_cast<Submode_t>(com::CcsdsSubmode::DATARATE_DEFAULT)) {
+      com::Datarate currentDatarate = com::getCurrentDatarate();
+      if (currentDatarate == com::Datarate::LOW_RATE_MODULATION_BPSK) {
+        rateLow();
+      } else if (currentDatarate == com::Datarate::HIGH_RATE_MODULATION_0QPSK) {
+        rateHigh();
+      }
+    } else if (submode == static_cast<Submode_t>(com::CcsdsSubmode::DATARATE_HIGH)) {
+      rateHigh();
+    } else if (submode == static_cast<Submode_t>(com::CcsdsSubmode::DATARATE_LOW)) {
+      rateLow();
+    }
+
+  } else if (mode == HasModesIF::MODE_OFF) {
+    disableTransmit();
+    this->mode = HasModesIF::MODE_OFF;
+  }
+  this->submode = submode;
+  modeHelper.modeChanged(mode, submode);
+  announceMode(false);
+}
+
+void CcsdsIpCoreHandler::announceMode(bool recursive) { triggerEvent(MODE_INFO, mode, submode); }
+
 void CcsdsIpCoreHandler::disableTransmit() {
 #ifndef TE0720_1CFA
   gpioIF->pullLow(enTxClock);
@@ -345,7 +431,19 @@ void CcsdsIpCoreHandler::disableTransmit() {
 #endif
   linkState = DOWN;
   forwardLinkstate();
-  transmitterCountdown.setTimeout(0);
+  transmitterCountdown.timeOut();
 }
 
 const char* CcsdsIpCoreHandler::getName() const { return "CCSDS Handler"; }
+
+const HasHealthIF* CcsdsIpCoreHandler::getOptHealthIF() const { return nullptr; }
+
+const HasModesIF& CcsdsIpCoreHandler::getModeIF() const { return *this; }
+
+ReturnValue_t CcsdsIpCoreHandler::connectModeTreeParent(HasModeTreeChildrenIF& parent) {
+  return modetree::connectModeTreeParent(parent, *this, nullptr, modeHelper);
+}
+
+ModeTreeChildIF& CcsdsIpCoreHandler::getModeTreeChildIF() { return *this; }
+
+object_id_t CcsdsIpCoreHandler::getObjectId() const { return SystemObject::getObjectId(); }

mission/tmtc/CcsdsIpCoreHandler.h

@@ -1,16 +1,21 @@
 #ifndef CCSDSHANDLER_H_
 #define CCSDSHANDLER_H_
 
+#include <fsfw/modes/HasModesIF.h>
+
+#include <cstdint>
 #include <unordered_map>
 
 #include "OBSWConfig.h"
 #include "VirtualChannel.h"
+#include "eive/definitions.h"
 #include "fsfw/action/ActionHelper.h"
 #include "fsfw/action/HasActionsIF.h"
 #include "fsfw/events/EventMessage.h"
 #include "fsfw/objectmanager/SystemObject.h"
 #include "fsfw/parameters/ParameterHelper.h"
 #include "fsfw/returnvalues/returnvalue.h"
+#include "fsfw/subsystem/ModeTreeConnectionIF.h"
 #include "fsfw/tasks/ExecutableObjectIF.h"
 #include "fsfw/timemanager/Countdown.h"
 #include "fsfw/tmtcservices/AcceptsTelecommandsIF.h"
@@ -18,6 +23,7 @@
 #include "fsfw_hal/common/gpio/GpioIF.h"
 #include "fsfw_hal/common/gpio/gpioDefinitions.h"
 #include "linux/ipcore/PtmeConfig.h"
+#include "mission/comDefs.h"
 
 /**
  * @brief   This class handles the data exchange with the CCSDS IP cores implemented in the
@@ -30,6 +36,9 @@
  */
 class CcsdsIpCoreHandler : public SystemObject,
                            public ExecutableObjectIF,
+                           public ModeTreeChildIF,
+                           public ModeTreeConnectionIF,
+                           public HasModesIF,
                            public AcceptsTelemetryIF,
                            public AcceptsTelecommandsIF,
                            public ReceivesParameterMessagesIF,
@@ -57,7 +66,14 @@ class CcsdsIpCoreHandler : public SystemObject,
 
   ReturnValue_t performOperation(uint8_t operationCode = 0) override;
   ReturnValue_t initialize();
-  MessageQueueId_t getCommandQueue() const;
+  MessageQueueId_t getCommandQueue() const override;
+
+  // ModesIF
+  void getMode(Mode_t* mode, Submode_t* submode) override;
+  ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
+                                 uint32_t* msToReachTheMode) override;
+  void startTransition(Mode_t mode, Submode_t submode) override;
+  void announceMode(bool recursive) override;
 
   /**
    * @brief   Function to add a virtual channel
@@ -78,12 +94,17 @@ class CcsdsIpCoreHandler : public SystemObject,
 
   virtual ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
                                       const uint8_t* data, size_t size);
+  const HasHealthIF* getOptHealthIF() const override;
+  const HasModesIF& getModeIF() const override;
+  object_id_t getObjectId() const override;
+  ReturnValue_t connectModeTreeParent(HasModeTreeChildrenIF& parent) override;
+  ModeTreeChildIF& getModeTreeChildIF() override;
 
  private:
   static const uint8_t INTERFACE_ID = CLASS_ID::CCSDS_HANDLER;
   static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PLOC_MPSOC_HANDLER;
 
-  static const uint32_t QUEUE_SIZE = common::CCSDS_HANDLER_QUEUE_SIZE;
+  static const uint32_t QUEUE_SIZE = config::CCSDS_HANDLER_QUEUE_SIZE;
 
   static const ActionId_t SET_LOW_RATE = 0;
   static const ActionId_t SET_HIGH_RATE = 1;
@@ -124,6 +145,9 @@ class CcsdsIpCoreHandler : public SystemObject,
   ParameterHelper parameterHelper;
 
   ActionHelper actionHelper;
+  Mode_t mode = HasModesIF::MODE_OFF;
+  Submode_t submode = static_cast<Submode_t>(com::CcsdsSubmode::UNSET);
+  ModeHelper modeHelper;
 
   MessageQueueId_t tcDistributorQueueId = MessageQueueIF::NO_QUEUE;
 

scripts/q7s-port-em.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+echo "Setting up all Q7S ports for EM"
+echo "-L 1538:192.168.133.10:1534 for connection to the TCF agent on the EM"
+echo "-L 1539:192.168.133.10:22 for file transfers to the EM"
+echo "-L 1540:192.168.133.10:7301 for TMTC commanding using the TCP/IP IF on the EM"
+
+ssh -L 1538:192.168.133.10:1534 \
+   -L 1539:192.168.133.10:22 \
+   -L 1540:192.168.133.10:7301 \
+   eive@2001:7c0:2018:1099:babe:0:e1fe:f1a5 \
+   -t 'CONSOLE_PREFIX="[Q7S Tunnel]" /bin/bash'

scripts/q7s-ssh-udp-forwarding.sh

@@ -0,0 +1,8 @@
+#!/bin/bash
+echo "Setting up all Q7S ports"
+echo "upd connection from local port 18000 -> tcp ssh tunnel -> EM port 7301"
+
+
+socat udp4-listen:18000,reuseaddr,fork tcp:localhost:18002 &
+ssh -L 18002:localhost:18123 eive@flatsat.eive.absatvirt.lw 'socat tcp4-listen:18123,reuseaddr udp:192.168.133.10:7301'
+