Merge pull request 'v1.33.0' (#410) from v1.33.0 into develop

Reviewed-on: #410

.gitignore

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

.run/Q7S FM.run.xml

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

CHANGELOG.md

@@ -8,26 +8,191 @@ 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:
+Starting at v2.0.0, this project will adhere to semantic versioning and the the following changes
+will consitute of a breaking change warranting a new major release:
 
 - The TMTC interface changes in any shape of form.
-- The behavour of the OBSW changes in a major shape or form relevant
-  for operations
+- The behaviour of the OBSW changes in a major shape or form relevant for operations
 
 # [unreleased]
 
+# [v1.33.0]
+
+eive-tmtc: v2.16.2
+
+## Changed
+
+- Move ACS board polling to separate worker thread.
+- Move SUS board polling to separate worker thread.
+
+## Fixed
+
+- Linux GPS handler now checks the individual `*_SET` flags when analysing the `gpsd` struct.
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/400
+
+# [v1.32.0]
+
+eive-tmtc: v2.16.1
+
+## Fixed
+
+- ADIS1650X: Added missing MDL_RANG pool entry for configuration set
+- Bumped FSFW for bugfix in health service: No execution complete for targeted health announce
+  command.
+- Removed matrix determinant calculation as part of the `MEKF`, which would take about
+  300ms of runtime
+- Resetting the `MEKF` now also actually resets its stored state
+- Bumped FSFW for bugfix in destination handler: Better error handling and able to process
+  destination folder path.
+
+## Changed
+
+- Added basic persistent TM store for PUS telemetry and basic interface to dump and delete
+  telemetry. Implementation is based on a timed rotating files, with the addition that files
+  might be generated more often if the maximum file size of 8192 bytes is exceeded.
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/320/files
+- Commented out commanding of actuators as part of the `AcsController`
+- Collection sets of the `AcsController` now get updated before running the actual ACS
+  algorithm
+- `GpsController` now always gets scheduled
+- The `CoreController` now initializes the initial clock from the time file as early as possible
+  (in the constructor) if possible, which should usually be the case.
+
+## Added
+
+- Added basic persistent TM store for PUS telemetry and basic interface to dump and delete
+  telemetry.
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/320/files
+- `ExecutableComIfDummy` class to have a dummy for classes like the RTD polling class.
+- Added `AcsController` action command to confirm solar array deployment, which then deletes
+  two files
+- Added `AcsController` action command to reset `MEKF`
+- `GpsCtrlDummy` now initializes the `gpsSet`
+- `RwDummy` now initializes with a non faulty state
+
+
+# [v1.31.1]
+
+## Fixed
+
+- ADIS1650X configuration set was empty because the local pool variables were not registered.
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/402
+- ACS Controller: Correction for size of MEKF dataset and some optimization and fixes
+  for actuator control which lead to a crash.
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/403
+
+# [v1.31.0]
+
+eive-tmtc: v2.16.0
+
+## Fixed
+
+- Usage of floats as iterators and using them to calculate a uint8_t index in `SusConverter`
+- Removed unused variables in the `AcsController`
+- Remove shadowing variables inside ACS assembly classes.
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/issues/385
+
+## Changed
+
+COM PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/364
+
+* Moved transmitter timer and handling of carrier and bitlock event from CCSDS handler to COM
+  subsystem
+* Added parameter command to be able to change the transmitter timeout
+* Solves [#362](https://egit.irs.uni-stuttgart.de/eive/eive-obsw/issues/362)
+* Solves [#360](https://egit.irs.uni-stuttgart.de/eive/eive-obsw/issues/360)
+* Solves [#361](https://egit.irs.uni-stuttgart.de/eive/eive-obsw/issues/361)
+* Solves [#386](https://egit.irs.uni-stuttgart.de/eive/eive-obsw/issues/386)
+- All `targetQuat` functions in `Guidance` now return the target quaternion (target
+  in ECI frame), which is passed on to `CtrlValData`.
+- Moved polling sequence table definitions and source code to `mission/core` folder.
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/395
+
+## Added
+
+- `MEKF` now returns an unique returnvalue depending on why the function terminates. These
+  returnvalues are used in the `AcsController` to determine on how to procede with its
+  perform functions. In case the `MEKF` did terminate before estimating the quaternion
+  and rotational rate, an info event will be triggered. Another info event can only be
+  triggered after the `MEKF` has run successfully again. If the `AcsController` tries to
+  perform any pointing mode and the `MEKF` fails, the `performPointingCtrl` function will
+  set the RWs to the last RW speeds and set a zero dipole vector. If the `MEKF` does not
+  recover within 5 cycles (2 mins) the `AcsController` triggers another event, resulting in
+  the `AcsSubsystem` being commanded to `SAFE`.
+- `MekfData` now includes `mekfStatus`
+- `CtrlValData` now includes `tgtRotRate`
+
+# [v1.30.0]
+
+eive-tmtc: v2.14.0
+
+Event IDs for PDEC handler have changed in a breaking manner.
+
+## Added and Fixed
+
+- PDEC: Added basic FDIR to limit the number of allowed TC interrupts and to allow complete task
+  lockups in the case an IRQ is immediately re-raised by the PDEC module. This is done by only
+  allowing a certain number of handled IRQs (whether they yield a valid TC or not) during
+  time windows of one second. Right now, 800 IRQs/TCs are allowed per time window.
+  This time window is reset if a TC reception timeout after 500ms occurs. TBD whether the maximum
+  allowed number will be a configurable parameter. If the number of occured IRQs is exceeded,
+  an event is triggered and the task is delayed for 400 ms.
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/393
+
+# [v1.29.1]
+
+## Fixed
+
+- Limit number of handled messages for core TM handlers:
+  - https://egit.irs.uni-stuttgart.de/eive/eive-obsw/issues/391
+  - https://egit.irs.uni-stuttgart.de/eive/eive-obsw/issues/390
+  - https://egit.irs.uni-stuttgart.de/eive/eive-obsw/issues/389
+- HeaterHandler better handling for faulty message reception
+  Issue: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/issues/388
+- Disable stopwatch in MAX31865 polling task
+
+# [v1.29.0]
+
+eive-tmtc: v2.13.0
+
+## Changed
+
+- Refactored IMTQ handlers to also perform low level I2C communication tasks in separate thread.
+  This avoids the various delays needed for I2C communication with that device inside the ACS PST.
+  (e.g. 1 ms delay between each transfer, or 10 ms integration delay for MGM measurements).
+
+## Added
+
+- Added new heater info set for the TCS controller. This set contains the heater switch states
+  and the current draw.
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/351
+- The HeaterHandler now exposes a mode which reflects whether the heater power
+  is on or off. It also triggers mode events for its heater children objects
+  which show whether the specific heaters are on or off. The heater handler
+  will be part of the TCS tree.
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/351
+
 # [v1.28.1]
 
 ## Fixed
 
 - Patch version which compiles for EM
 - CFDP Funnel bugfix: CCSDS wrapping was buggy and works properly now.
+- PDEC: Some adaptions to prevent task lockups on invalid FAR states.
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/393
 - CMakeLists.txt fix which broke CI/CD builds when server could not retrieve full git SHA.
+- Possible regression in the MAX31865 polling task: Using a `ManualCsLockGuard` for reconfiguring
+  and then polling the sensor is problematic, invalid sensor values will be read.
+  CS probably needs to be de-asserted or some other HW/SPI specific issue. Letting the SPI ComIF
+  do the locking does the job.
 
 ## Changed
 
 - Add `-Wshadow=local` shadowing warnings and fixed all of them
+- Updated generated CSV files: Support for skip directive and explicit
+  "No description" info string
+- The polling threads for actuator polling now have a slightly higher priority than the ACS PST
+  to ensure timing requirements are met.
 
 ## Added
 
@@ -158,6 +323,7 @@ eive-tmtc: v2.12.2
 ## Changed
 
 - Reworked dummy handling for the TCS controller.
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/325
 - Generator scripts now generate files for hosted and for Q7S build.
 
 ## Fixed

CMakeLists.txt

@@ -10,8 +10,8 @@
 cmake_minimum_required(VERSION 3.13)
 
 set(OBSW_VERSION_MAJOR 1)
-set(OBSW_VERSION_MINOR 28)
-set(OBSW_VERSION_REVISION 1)
+set(OBSW_VERSION_MINOR 33)
+set(OBSW_VERSION_REVISION 0)
 
 # set(CMAKE_VERBOSE TRUE)
 
@@ -223,6 +223,7 @@ set(LIB_JSON_PATH ${THIRD_PARTY_FOLDER}/json)
 
 set(FSFW_WARNING_SHADOW_LOCAL_GCC OFF)
 set(EIVE_ADD_LINUX_FILES OFF)
+set(FSFW_ADD_TMSTORAGE ON)
 
 # Analyse different OS and architecture/target options, determine BSP_PATH,
 # display information about compiler etc.

README.md

@@ -18,6 +18,7 @@
 11. [Q7S OBC](#q7s)
 12. [Static Code Analysis](#static-code-analysis)
 13. [Eclipse](#eclipse)
+14. [CLion](#clion)
 14. [Running the OBSW on a Raspberry Pi](#rpi)
 15. [Running OBSW on EGSE](#egse)
 16. [Manually preparing sysroots to compile gpsd](#gpsd)
@@ -1229,6 +1230,22 @@ Finally, you can convert the generated `.xml` file to HTML with the following co
 cppcheck-htmlreport --file=report.xml --report-dir=cppcheck --source-dir=..
 ```
 
+# <a id="CLion"></a> CLion
+
+CLion is the recommended IDE for the development of the hosted version of EIVE.
+You can also set up CLion for cross-compilation of the primary OBSW.
+
+There is a shared `.idea/cmake.xml` file to get started with this.
+To make cross-compilation work, two special environment variables
+need to be set:
+
+- `ZYNQ_7020_ROOTFS` pointing to the root filesystem
+- `CROSS_COMPILE` pointing to the the full path of the cross-compiler
+  without the specific tool suffix. For example, if the the cross-compiler
+  tools are located at `/opt/q7s-gcc/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin`,
+  this variable would be set
+  to `/opt/q7s-gcc/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin/arm-linux-gnueabihf`
+
 # <a id="eclipse"></a> Eclipse
 
 When using Eclipse, there are two special build variables in the project properties

bsp_hosted/ObjectFactory.cpp

@@ -8,6 +8,7 @@
 #include <mission/tmtc/TmFunnelHandler.h>
 #include <objects/systemObjectList.h>
 
+#include "../mission/utility/DummySdCardManager.h"
 #include "OBSWConfig.h"
 #include "fsfw/platform.h"
 #include "fsfw_tests/integration/task/TestTask.h"
@@ -29,7 +30,6 @@
 #include <dummies/CoreControllerDummy.h>
 
 #include "dummies/helpers.h"
-#include "mission/utility/GlobalConfigHandler.h"
 
 #ifdef PLATFORM_UNIX
 #include <fsfw_hal/linux/serial/SerialComIF.h>
@@ -58,7 +58,8 @@ void ObjectFactory::produce(void* args) {
   Factory::setStaticFrameworkObjectIds();
   PusTmFunnel* pusFunnel;
   CfdpTmFunnel* cfdpFunnel;
-  ObjectFactory::produceGenericObjects(nullptr, &pusFunnel, &cfdpFunnel);
+  auto sdcMan = new DummySdCardManager("/tmp");
+  ObjectFactory::produceGenericObjects(nullptr, &pusFunnel, &cfdpFunnel, *sdcMan);
 
   auto* dummyGpioIF = new DummyGpioIF();
   auto* dummySwitcher = new DummyPowerSwitcher(objects::PCDU_HANDLER, 18, 0);

bsp_hosted/fsfwconfig/events/translateEvents.cpp

@@ -1,7 +1,7 @@
 /**
- * @brief    Auto-generated event translation file. Contains 257 translations.
+ * @brief    Auto-generated event translation file. Contains 267 translations.
  * @details
- * Generated on: 2023-02-21 00:24:44
+ * Generated on: 2023-03-01 18:34:32
  */
 #include "translateEvents.h"
 
@@ -90,9 +90,13 @@ const char *CHANGE_OF_SETUP_PARAMETER_STRING = "CHANGE_OF_SETUP_PARAMETER";
 const char *STORE_ERROR_STRING = "STORE_ERROR";
 const char *MSG_QUEUE_ERROR_STRING = "MSG_QUEUE_ERROR";
 const char *SERIALIZATION_ERROR_STRING = "SERIALIZATION_ERROR";
+const char *FILESTORE_ERROR_STRING = "FILESTORE_ERROR";
+const char *FILENAME_TOO_LARGE_ERROR_STRING = "FILENAME_TOO_LARGE_ERROR";
 const char *SAFE_RATE_VIOLATION_STRING = "SAFE_RATE_VIOLATION";
 const char *SAFE_RATE_RECOVERY_STRING = "SAFE_RATE_RECOVERY";
 const char *MULTIPLE_RW_INVALID_STRING = "MULTIPLE_RW_INVALID";
+const char *MEKF_INVALID_INFO_STRING = "MEKF_INVALID_INFO";
+const char *MEKF_INVALID_MODE_VIOLATION_STRING = "MEKF_INVALID_MODE_VIOLATION";
 const char *SWITCH_CMD_SENT_STRING = "SWITCH_CMD_SENT";
 const char *SWITCH_HAS_CHANGED_STRING = "SWITCH_HAS_CHANGED";
 const char *SWITCHING_Q7S_DENIED_STRING = "SWITCHING_Q7S_DENIED";
@@ -151,8 +155,11 @@ const char *CARRIER_LOCK_STRING = "CARRIER_LOCK";
 const char *BIT_LOCK_PDEC_STRING = "BIT_LOCK_PDEC";
 const char *LOST_CARRIER_LOCK_PDEC_STRING = "LOST_CARRIER_LOCK_PDEC";
 const char *LOST_BIT_LOCK_PDEC_STRING = "LOST_BIT_LOCK_PDEC";
+const char *TOO_MANY_IRQS_STRING = "TOO_MANY_IRQS";
 const char *POLL_SYSCALL_ERROR_PDEC_STRING = "POLL_SYSCALL_ERROR_PDEC";
 const char *WRITE_SYSCALL_ERROR_PDEC_STRING = "WRITE_SYSCALL_ERROR_PDEC";
+const char *PDEC_RESET_FAILED_STRING = "PDEC_RESET_FAILED";
+const char *OPEN_IRQ_FILE_FAILED_STRING = "OPEN_IRQ_FILE_FAILED";
 const char *IMAGE_UPLOAD_FAILED_STRING = "IMAGE_UPLOAD_FAILED";
 const char *IMAGE_DOWNLOAD_FAILED_STRING = "IMAGE_DOWNLOAD_FAILED";
 const char *IMAGE_UPLOAD_SUCCESSFUL_STRING = "IMAGE_UPLOAD_SUCCESSFUL";
@@ -257,6 +264,9 @@ const char *PLOC_OVERHEATING_STRING = "PLOC_OVERHEATING";
 const char *OBC_OVERHEATING_STRING = "OBC_OVERHEATING";
 const char *HPA_OVERHEATING_STRING = "HPA_OVERHEATING";
 const char *PLPCDU_OVERHEATING_STRING = "PLPCDU_OVERHEATING";
+const char *TX_TIMER_EXPIRED_STRING = "TX_TIMER_EXPIRED";
+const char *BIT_LOCK_TX_ON_STRING = "BIT_LOCK_TX_ON";
+const char *POSSIBLE_FILE_CORRUPTION_STRING = "POSSIBLE_FILE_CORRUPTION";
 
 const char *translateEvents(Event event) {
   switch ((event & 0xFFFF)) {
@@ -430,12 +440,20 @@ const char *translateEvents(Event event) {
       return MSG_QUEUE_ERROR_STRING;
     case (10802):
       return SERIALIZATION_ERROR_STRING;
+    case (10803):
+      return FILESTORE_ERROR_STRING;
+    case (10804):
+      return FILENAME_TOO_LARGE_ERROR_STRING;
     case (11200):
       return SAFE_RATE_VIOLATION_STRING;
     case (11201):
       return SAFE_RATE_RECOVERY_STRING;
     case (11202):
       return MULTIPLE_RW_INVALID_STRING;
+    case (11203):
+      return MEKF_INVALID_INFO_STRING;
+    case (11204):
+      return MEKF_INVALID_MODE_VIOLATION_STRING;
     case (11300):
       return SWITCH_CMD_SENT_STRING;
     case (11301):
@@ -553,9 +571,15 @@ const char *translateEvents(Event event) {
     case (12406):
       return LOST_BIT_LOCK_PDEC_STRING;
     case (12407):
-      return POLL_SYSCALL_ERROR_PDEC_STRING;
+      return TOO_MANY_IRQS_STRING;
     case (12408):
+      return POLL_SYSCALL_ERROR_PDEC_STRING;
+    case (12409):
       return WRITE_SYSCALL_ERROR_PDEC_STRING;
+    case (12410):
+      return PDEC_RESET_FAILED_STRING;
+    case (12411):
+      return OPEN_IRQ_FILE_FAILED_STRING;
     case (12500):
       return IMAGE_UPLOAD_FAILED_STRING;
     case (12501):
@@ -764,6 +788,12 @@ const char *translateEvents(Event event) {
       return HPA_OVERHEATING_STRING;
     case (14106):
       return PLPCDU_OVERHEATING_STRING;
+    case (14201):
+      return TX_TIMER_EXPIRED_STRING;
+    case (14202):
+      return BIT_LOCK_TX_ON_STRING;
+    case (14300):
+      return POSSIBLE_FILE_CORRUPTION_STRING;
     default:
       return "UNKNOWN_EVENT";
   }

bsp_hosted/fsfwconfig/objects/translateObjects.cpp

@@ -1,8 +1,8 @@
 /**
  * @brief  Auto-generated object translation file.
  * @details
- * Contains 147 translations.
- * Generated on: 2023-02-21 00:24:44
+ * Contains 157 translations.
+ * Generated on: 2023-03-01 18:34:32
  */
 #include "translateObjects.h"
 
@@ -38,6 +38,7 @@ const char *GYRO_3_L3G_HANDLER_STRING = "GYRO_3_L3G_HANDLER";
 const char *RW4_STRING = "RW4";
 const char *STAR_TRACKER_STRING = "STAR_TRACKER";
 const char *GPS_CONTROLLER_STRING = "GPS_CONTROLLER";
+const char *IMTQ_POLLING_STRING = "IMTQ_POLLING";
 const char *IMTQ_HANDLER_STRING = "IMTQ_HANDLER";
 const char *PCDU_HANDLER_STRING = "PCDU_HANDLER";
 const char *P60DOCK_HANDLER_STRING = "P60DOCK_HANDLER";
@@ -84,8 +85,11 @@ const char *SYRLINKS_HANDLER_STRING = "SYRLINKS_HANDLER";
 const char *ARDUINO_COM_IF_STRING = "ARDUINO_COM_IF";
 const char *DUMMY_COM_IF_STRING = "DUMMY_COM_IF";
 const char *SCEX_UART_READER_STRING = "SCEX_UART_READER";
-const char *SPI_RTD_COM_IF_STRING = "SPI_RTD_COM_IF";
 const char *UART_COM_IF_STRING = "UART_COM_IF";
+const char *ACS_BOARD_POLLING_TASK_STRING = "ACS_BOARD_POLLING_TASK";
+const char *RW_POLLING_TASK_STRING = "RW_POLLING_TASK";
+const char *SPI_RTD_COM_IF_STRING = "SPI_RTD_COM_IF";
+const char *SUS_POLLING_TASK_STRING = "SUS_POLLING_TASK";
 const char *CCSDS_PACKET_DISTRIBUTOR_STRING = "CCSDS_PACKET_DISTRIBUTOR";
 const char *PUS_PACKET_DISTRIBUTOR_STRING = "PUS_PACKET_DISTRIBUTOR";
 const char *TCP_TMTC_SERVER_STRING = "TCP_TMTC_SERVER";
@@ -111,6 +115,7 @@ const char *PUS_SERVICE_5_EVENT_REPORTING_STRING = "PUS_SERVICE_5_EVENT_REPORTIN
 const char *PUS_SERVICE_8_FUNCTION_MGMT_STRING = "PUS_SERVICE_8_FUNCTION_MGMT";
 const char *PUS_SERVICE_9_TIME_MGMT_STRING = "PUS_SERVICE_9_TIME_MGMT";
 const char *PUS_SERVICE_11_TC_SCHEDULER_STRING = "PUS_SERVICE_11_TC_SCHEDULER";
+const char *PUS_SERVICE_15_TM_STORAGE_STRING = "PUS_SERVICE_15_TM_STORAGE";
 const char *PUS_SERVICE_17_TEST_STRING = "PUS_SERVICE_17_TEST";
 const char *PUS_SERVICE_20_PARAMETERS_STRING = "PUS_SERVICE_20_PARAMETERS";
 const char *PUS_SERVICE_200_MODE_MGMT_STRING = "PUS_SERVICE_200_MODE_MGMT";
@@ -149,6 +154,11 @@ const char *ACS_SUBSYSTEM_STRING = "ACS_SUBSYSTEM";
 const char *PL_SUBSYSTEM_STRING = "PL_SUBSYSTEM";
 const char *TCS_SUBSYSTEM_STRING = "TCS_SUBSYSTEM";
 const char *COM_SUBSYSTEM_STRING = "COM_SUBSYSTEM";
+const char *MISC_TM_STORE_STRING = "MISC_TM_STORE";
+const char *OK_TM_STORE_STRING = "OK_TM_STORE";
+const char *NOT_OK_TM_STORE_STRING = "NOT_OK_TM_STORE";
+const char *HK_TM_STORE_STRING = "HK_TM_STORE";
+const char *CFDP_TM_STORE_STRING = "CFDP_TM_STORE";
 const char *CCSDS_IP_CORE_BRIDGE_STRING = "CCSDS_IP_CORE_BRIDGE";
 const char *THERMAL_TEMP_INSERTER_STRING = "THERMAL_TEMP_INSERTER";
 const char *DUMMY_INTERFACE_STRING = "DUMMY_INTERFACE";
@@ -220,6 +230,8 @@ const char *translateObject(object_id_t object) {
       return STAR_TRACKER_STRING;
     case 0x44130045:
       return GPS_CONTROLLER_STRING;
+    case 0x44140013:
+      return IMTQ_POLLING_STRING;
     case 0x44140014:
       return IMTQ_HANDLER_STRING;
     case 0x442000A1:
@@ -312,10 +324,16 @@ const char *translateObject(object_id_t object) {
       return DUMMY_COM_IF_STRING;
     case 0x49010006:
       return SCEX_UART_READER_STRING;
-    case 0x49020006:
-      return SPI_RTD_COM_IF_STRING;
     case 0x49030003:
       return UART_COM_IF_STRING;
+    case 0x49060004:
+      return ACS_BOARD_POLLING_TASK_STRING;
+    case 0x49060005:
+      return RW_POLLING_TASK_STRING;
+    case 0x49060006:
+      return SPI_RTD_COM_IF_STRING;
+    case 0x49060007:
+      return SUS_POLLING_TASK_STRING;
     case 0x50000100:
       return CCSDS_PACKET_DISTRIBUTOR_STRING;
     case 0x50000200:
@@ -366,6 +384,8 @@ const char *translateObject(object_id_t object) {
       return PUS_SERVICE_9_TIME_MGMT_STRING;
     case 0x53000011:
       return PUS_SERVICE_11_TC_SCHEDULER_STRING;
+    case 0x53000015:
+      return PUS_SERVICE_15_TM_STORAGE_STRING;
     case 0x53000017:
       return PUS_SERVICE_17_TEST_STRING;
     case 0x53000020:
@@ -442,6 +462,16 @@ const char *translateObject(object_id_t object) {
       return TCS_SUBSYSTEM_STRING;
     case 0x73010004:
       return COM_SUBSYSTEM_STRING;
+    case 0x73020001:
+      return MISC_TM_STORE_STRING;
+    case 0x73020002:
+      return OK_TM_STORE_STRING;
+    case 0x73020003:
+      return NOT_OK_TM_STORE_STRING;
+    case 0x73020004:
+      return HK_TM_STORE_STRING;
+    case 0x73030000:
+      return CFDP_TM_STORE_STRING;
     case 0x73500000:
       return CCSDS_IP_CORE_BRIDGE_STRING;
     case 0x90000003:

bsp_hosted/scheduling.cpp

@@ -95,46 +95,43 @@ void scheduling::initTasks() {
     sif::error << "Add component UDP Polling failed" << std::endl;
   }
 
-  /* PUS Services */
-  PeriodicTaskIF* pusVerification = factory->createPeriodicTask(
-      "PUS_VERIF", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
-  result = pusVerification->addComponent(objects::PUS_SERVICE_1_VERIFICATION);
+  PeriodicTaskIF* pusHighPrio = factory->createPeriodicTask(
+      "PUS_HIGH_PRIO", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
+  result = pusHighPrio->addComponent(objects::PUS_SERVICE_1_VERIFICATION);
   if (result != returnvalue::OK) {
     sif::error << "Object add component failed" << std::endl;
   }
-
-  PeriodicTaskIF* eventHandling = factory->createPeriodicTask(
-      "EVENTS", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
-  result = eventHandling->addComponent(objects::EVENT_MANAGER);
+  result = pusHighPrio->addComponent(objects::EVENT_MANAGER);
   if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("EVENT_MNGR", objects::EVENT_MANAGER);
+    scheduling::printAddObjectError("EVENT_MGMT", objects::EVENT_MANAGER);
   }
-  result = eventHandling->addComponent(objects::PUS_SERVICE_5_EVENT_REPORTING);
+  result = pusHighPrio->addComponent(objects::PUS_SERVICE_5_EVENT_REPORTING);
   if (result != returnvalue::OK) {
     scheduling::printAddObjectError("PUS5", objects::PUS_SERVICE_5_EVENT_REPORTING);
   }
-
-  PeriodicTaskIF* pusHighPrio = factory->createPeriodicTask(
-      "PUS_HIGH_PRIO", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
-  result = pusHighPrio->addComponent(objects::PUS_SERVICE_2_DEVICE_ACCESS);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("PUS2", objects::PUS_SERVICE_2_DEVICE_ACCESS);
-  }
   result = pusHighPrio->addComponent(objects::PUS_SERVICE_9_TIME_MGMT);
   if (result != returnvalue::OK) {
     scheduling::printAddObjectError("PUS9", objects::PUS_SERVICE_9_TIME_MGMT);
   }
+
+  PeriodicTaskIF* pusMedPrio = factory->createPeriodicTask(
+      "PUS_MED_PRIO", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.8, missedDeadlineFunc);
+  result = pusHighPrio->addComponent(objects::PUS_SERVICE_2_DEVICE_ACCESS);
+  if (result != returnvalue::OK) {
+    scheduling::printAddObjectError("PUS2", objects::PUS_SERVICE_2_DEVICE_ACCESS);
+  }
   result = pusHighPrio->addComponent(objects::PUS_SERVICE_3_HOUSEKEEPING);
   if (result != returnvalue::OK) {
     scheduling::printAddObjectError("PUS3", objects::PUS_SERVICE_3_HOUSEKEEPING);
   }
-
-  PeriodicTaskIF* pusMedPrio = factory->createPeriodicTask(
-      "PUS_MED_PRIO", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.8, missedDeadlineFunc);
   result = pusMedPrio->addComponent(objects::PUS_SERVICE_8_FUNCTION_MGMT);
   if (result != returnvalue::OK) {
     scheduling::printAddObjectError("PUS8", objects::PUS_SERVICE_8_FUNCTION_MGMT);
   }
+  result = pusMedPrio->addComponent(objects::PUS_SERVICE_15_TM_STORAGE);
+  if (result != returnvalue::OK) {
+    scheduling::printAddObjectError("PUS15", objects::PUS_SERVICE_15_TM_STORAGE);
+  }
   result = pusMedPrio->addComponent(objects::PUS_SERVICE_200_MODE_MGMT);
   if (result != returnvalue::OK) {
     scheduling::printAddObjectError("PUS200", objects::PUS_SERVICE_200_MODE_MGMT);
@@ -143,10 +140,7 @@ void scheduling::initTasks() {
   if (result != returnvalue::OK) {
     scheduling::printAddObjectError("PUS20", objects::PUS_SERVICE_20_PARAMETERS);
   }
-
-  PeriodicTaskIF* pusLowPrio = factory->createPeriodicTask(
-      "PUS_LOW_PRIO", 30, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.6, missedDeadlineFunc);
-  result = pusLowPrio->addComponent(objects::PUS_SERVICE_17_TEST);
+  result = pusMedPrio->addComponent(objects::PUS_SERVICE_17_TEST);
   if (result != returnvalue::OK) {
     scheduling::printAddObjectError("PUS17", objects::PUS_SERVICE_17_TEST);
   }
@@ -220,11 +214,8 @@ void scheduling::initTasks() {
   udpPollingTask->startTask();
   tcpPollingTask->startTask();
 
-  pusVerification->startTask();
-  eventHandling->startTask();
   pusHighPrio->startTask();
   pusMedPrio->startTask();
-  pusLowPrio->startTask();
 
   pstTask->startTask();
   thermalTask->startTask();

bsp_linux_board/CMakeLists.txt

@@ -1,5 +1,5 @@
 target_sources(${OBSW_NAME} PUBLIC InitMission.cpp main.cpp gpioInit.cpp
-                                   ObjectFactory.cpp RPiSdCardManager.cpp)
+                                   ObjectFactory.cpp)
 
 add_subdirectory(boardconfig)
 add_subdirectory(boardtest)

bsp_linux_board/ObjectFactory.cpp

@@ -82,7 +82,7 @@ void ObjectFactory::produce(void* args) {
 #endif
 
 #if OBSW_ADD_SCEX_DEVICE == 1
-  auto* sdcMan = new RPiSdCardManager("/tmp");
+  auto* sdcMan = new DummySdCardManager("/tmp");
   createScexComponents(uart::DEV, pwrSwitcher, *sdcMan, true, std::nullopt);
 #endif
 

bsp_linux_board/RPiSdCardManager.cpp

@@ -1,13 +0,0 @@
-#include "RPiSdCardManager.h"
-
-RPiSdCardManager::RPiSdCardManager(std::string prefix) : prefix(std::move(prefix)) {}
-
-const std::string& RPiSdCardManager::getCurrentMountPrefix() const { return prefix; }
-
-bool RPiSdCardManager::isSdCardUsable(sd::SdCard sdCard) { return true; }
-
-std::optional<sd::SdCard> RPiSdCardManager::getPreferredSdCard() const { return std::nullopt; }
-
-void RPiSdCardManager::setActiveSdCard(sd::SdCard sdCard) {}
-
-std::optional<sd::SdCard> RPiSdCardManager::getActiveSdCard() const { return std::nullopt; }

bsp_q7s/core/CoreController.cpp

@@ -49,6 +49,8 @@ CoreController::CoreController(object_id_t objectId)
     }
 
     getCurrentBootCopy(CURRENT_CHIP, CURRENT_COPY);
+
+    initClockFromTimeFile();
   } catch (const std::filesystem::filesystem_error &e) {
     sif::error << "CoreController::CoreController: Failed with exception " << e.what() << std::endl;
   }
@@ -159,6 +161,9 @@ ReturnValue_t CoreController::initializeAfterTaskCreation() {
   }
   sdcMan->setActiveSdCard(sdInfo.active);
   currMntPrefix = sdcMan->getCurrentMountPrefix();
+  if (currMntPrefix == "") {
+    return ObjectManagerIF::CHILD_INIT_FAILED;
+  }
   if (BLOCKING_SD_INIT) {
     result = initSdCardBlocking();
     if (result != returnvalue::OK and result != SdCardManager::ALREADY_MOUNTED) {
@@ -389,7 +394,7 @@ ReturnValue_t CoreController::sdStateMachine() {
       sdInfo.cycleCount = 0;
       return true;
     } else if (sdInfo.cycleCount > 4) {
-      sif::warning << "CoreController::sdInitStateMachine: " << opPrintout << " takes too long"
+      sif::warning << "CoreController::sdStateMachine: " << opPrintout << " takes too long"
                    << std::endl;
       return false;
     }
@@ -401,7 +406,7 @@ ReturnValue_t CoreController::sdStateMachine() {
       // Create updated status file
       result = sdcMan->updateSdCardStateFile();
       if (result != returnvalue::OK) {
-        sif::warning << "CoreController::initialize: Updating SD card state file failed"
+        sif::warning << "CoreController::sdStateMachine: Updating SD card state file failed"
                      << std::endl;
       }
       sdInfo.commandExecuted = true;
@@ -1219,6 +1224,9 @@ ReturnValue_t CoreController::handleProtInfoUpdateLine(std::string nextLine) {
       }
     }
     wordIdx++;
+    if(wordIdx >= 10) {
+      break;
+    }
   }
   return returnvalue::OK;
 }
@@ -1266,10 +1274,12 @@ void CoreController::performMountedSdCardOperations() {
       if (result != returnvalue::OK) {
         sif::warning << "CoreController::CoreController: Boot copy init" << std::endl;
       }
-      initClockFromTimeFile();
+      if (not timeFileInitDone) {
+        initClockFromTimeFile();
+      }
       performRebootFileHandling(false);
     }
-    timeFileHandler();
+    backupTimeFileHandler();
   };
   bool someSdCardActive = false;
   if (sdInfo.active == sd::SdCard::SLOT_0 and sdcMan->isSdCardUsable(sd::SdCard::SLOT_0)) {
@@ -1783,7 +1793,7 @@ void CoreController::setRebootMechanismLock(bool lock, xsc::Chip tgtChip, xsc::C
   rewriteRebootFile(rebootFile);
 }
 
-ReturnValue_t CoreController::timeFileHandler() {
+ReturnValue_t CoreController::backupTimeFileHandler() {
   // Always set time. We could only set it if it is updated by GPS, but then the backup time would
   // become obsolete on GPS problems.
   if (opDivider10.check()) {
@@ -1793,14 +1803,14 @@ ReturnValue_t CoreController::timeFileHandler() {
     if (result != returnvalue::OK) {
       return result;
     }
-    std::string fileName = currMntPrefix + TIME_FILE;
+    std::string fileName = currMntPrefix + BACKUP_TIME_FILE;
     std::ofstream timeFile(fileName);
     if (not timeFile.good()) {
       sif::error << "CoreController::timeFileHandler: Error opening time file: " << strerror(errno)
                  << std::endl;
       return returnvalue::FAILED;
     }
-    timeFile << "UNIX SECONDS: " << currentTime.tv_sec << std::endl;
+    timeFile << "UNIX SECONDS: " << currentTime.tv_sec + BOOT_OFFSET_SECONDS << std::endl;
   }
   return returnvalue::OK;
 }
@@ -1808,8 +1818,8 @@ ReturnValue_t CoreController::timeFileHandler() {
 ReturnValue_t CoreController::initClockFromTimeFile() {
   using namespace GpsHyperion;
   using namespace std;
-  std::string fileName = currMntPrefix + TIME_FILE;
-  if (std::filesystem::exists(fileName) and
+  std::string fileName = currMntPrefix + BACKUP_TIME_FILE;
+  if (sdcMan->isSdCardUsable(std::nullopt) and std::filesystem::exists(fileName) and
       ((gpsFix == FixMode::UNKNOWN or gpsFix == FixMode::NOT_SEEN) or
        not utility::timeSanityCheck())) {
     ifstream timeFile(fileName);
@@ -1837,6 +1847,7 @@ ReturnValue_t CoreController::initClockFromTimeFile() {
     sif::info << "Setting system time from time files: " << std::put_time(time, "%c %Z")
               << std::endl;
 #endif
+    timeFileInitDone = true;
     return Clock::setClock(&currentTime);
   }
   return returnvalue::OK;

bsp_q7s/core/CoreController.h

@@ -58,13 +58,14 @@ class CoreController : public ExtendedControllerBase {
 
   static constexpr char VERSION_FILE_NAME[] = "version.txt";
   static constexpr char REBOOT_FILE_NAME[] = "reboot.txt";
-  static constexpr char TIME_FILE_NAME[] = "time.txt";
+  static constexpr char TIME_FILE_NAME[] = "time_backup.txt";
 
   const std::string VERSION_FILE =
       "/" + std::string(CONF_FOLDER) + "/" + std::string(VERSION_FILE_NAME);
   const std::string REBOOT_FILE =
       "/" + std::string(CONF_FOLDER) + "/" + std::string(REBOOT_FILE_NAME);
-  const std::string TIME_FILE = "/" + std::string(CONF_FOLDER) + "/" + std::string(TIME_FILE_NAME);
+  const std::string BACKUP_TIME_FILE =
+      "/" + std::string(CONF_FOLDER) + "/" + std::string(TIME_FILE_NAME);
 
   static constexpr char CHIP_0_COPY_0_MOUNT_DIR[] = "/tmp/mntupdate-xdi-qspi0-nom-rootfs";
   static constexpr char CHIP_0_COPY_1_MOUNT_DIR[] = "/tmp/mntupdate-xdi-qspi0-gold-rootfs";
@@ -160,6 +161,7 @@ class CoreController : public ExtendedControllerBase {
   bool sdInitFinished() const;
 
  private:
+  static constexpr uint32_t BOOT_OFFSET_SECONDS = 15;
   static constexpr MutexIF::TimeoutType TIMEOUT_TYPE = MutexIF::TimeoutType::WAITING;
   static constexpr uint32_t MUTEX_TIMEOUT = 20;
   // Designated value for rechecking FIFO open
@@ -221,6 +223,7 @@ class CoreController : public ExtendedControllerBase {
 
   RebootFile rebootFile = {};
   std::string currMntPrefix;
+  bool timeFileInitDone = false;
   bool performOneShotSdCardOpsSwitch = false;
   uint8_t shortSdCardCdCounter = 0;
 #if OBSW_THREAD_TRACING == 1
@@ -258,7 +261,7 @@ class CoreController : public ExtendedControllerBase {
 
   ReturnValue_t initClockFromTimeFile();
   ReturnValue_t performSdCardCheck();
-  ReturnValue_t timeFileHandler();
+  ReturnValue_t backupTimeFileHandler();
   ReturnValue_t initBootCopyFile();
   ReturnValue_t initWatchdogFifo();
   ReturnValue_t initSdCardBlocking();

bsp_q7s/core/ObjectFactory.cpp

@@ -1,7 +1,12 @@
 #include "ObjectFactory.h"
 
 #include <fsfw/subsystem/Subsystem.h>
+#include <linux/devices/AcsBoardPolling.h>
+#include <linux/devices/ImtqPollingTask.h>
 #include <linux/devices/RwPollingTask.h>
+#include <mission/devices/GyrL3gCustomHandler.h>
+#include <mission/devices/MgmLis3CustomHandler.h>
+#include <mission/devices/MgmRm3100CustomHandler.h>
 #include <mission/system/objects/CamSwitcher.h>
 
 #include "OBSWConfig.h"
@@ -39,6 +44,7 @@
 #include "linux/ipcore/PdecHandler.h"
 #include "linux/ipcore/Ptme.h"
 #include "linux/ipcore/PtmeConfig.h"
+#include "mission/config/configfile.h"
 #include "mission/csp/CspCookie.h"
 #include "mission/system/fdir/AcsBoardFdir.h"
 #include "mission/system/fdir/GomspacePowerFdir.h"
@@ -52,10 +58,12 @@
 #include "mission/system/tree/comModeTree.h"
 #include "mission/system/tree/payloadModeTree.h"
 #include "mission/system/tree/tcsModeTree.h"
+#include "mission/utility/GlobalConfigHandler.h"
 #include "tmtc/pusIds.h"
 #if OBSW_TEST_LIBGPIOD == 1
 #include "linux/boardtest/LibgpiodTest.h"
 #endif
+#include <mission/devices/GyrAdis1650XHandler.h>
 #include <mission/devices/ImtqHandler.h>
 #include <mission/devices/PcduHandler.h>
 #include <mission/devices/SyrlinksHandler.h>
@@ -82,7 +90,6 @@
 #include "mission/core/GenericFactory.h"
 #include "mission/devices/ACUHandler.h"
 #include "mission/devices/BpxBatteryHandler.h"
-#include "mission/devices/GyroADIS1650XHandler.h"
 #include "mission/devices/HeaterHandler.h"
 #include "mission/devices/Max31865PT1000Handler.h"
 #include "mission/devices/P60DockHandler.h"
@@ -238,8 +245,8 @@ ReturnValue_t ObjectFactory::createRadSensorComponent(LinuxLibgpioIF* gpioComIF,
   return returnvalue::OK;
 }
 
-void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, SerialComIF* uartComIF,
-                                             PowerSwitchIF& pwrSwitcher) {
+void ObjectFactory::createAcsBoardComponents(SpiComIF& spiComIF, LinuxLibgpioIF* gpioComIF,
+                                             SerialComIF* uartComIF, PowerSwitchIF& pwrSwitcher) {
   using namespace gpio;
   GpioCookie* gpioCookieAcsBoard = new GpioCookie();
 
@@ -342,14 +349,16 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, SerialCo
   static_cast<void>(fdir);
 
 #if OBSW_ADD_ACS_BOARD == 1
+  new AcsBoardPolling(objects::ACS_BOARD_POLLING_TASK, spiComIF, *gpioComIF);
   std::string spiDev = q7s::SPI_DEFAULT_DEV;
   std::array<DeviceHandlerBase*, 8> assemblyChildren;
   SpiCookie* spiCookie =
-      new SpiCookie(addresses::MGM_0_LIS3, gpioIds::MGM_0_LIS3_CS, MGMLIS3MDL::MAX_BUFFER_SIZE,
+      new SpiCookie(addresses::MGM_0_LIS3, gpioIds::MGM_0_LIS3_CS, mgmLis3::MAX_BUFFER_SIZE,
                     spi::DEFAULT_LIS3_MODE, spi::DEFAULT_LIS3_SPEED);
   spiCookie->setMutexParams(MutexIF::TimeoutType::WAITING, spi::ACS_BOARD_CS_TIMEOUT);
-  auto mgmLis3Handler0 = new MgmLIS3MDLHandler(
-      objects::MGM_0_LIS3_HANDLER, objects::SPI_MAIN_COM_IF, spiCookie, spi::LIS3_TRANSITION_DELAY);
+  auto mgmLis3Handler0 =
+      new MgmLis3CustomHandler(objects::MGM_0_LIS3_HANDLER, objects::ACS_BOARD_POLLING_TASK,
+                               spiCookie, spi::LIS3_TRANSITION_DELAY);
   fdir = new AcsBoardFdir(objects::MGM_0_LIS3_HANDLER);
   mgmLis3Handler0->setCustomFdir(fdir);
   assemblyChildren[0] = mgmLis3Handler0;
@@ -361,12 +370,12 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, SerialCo
   mgmLis3Handler->enablePeriodicPrintouts(true, 10);
 #endif
   spiCookie =
-      new SpiCookie(addresses::MGM_1_RM3100, gpioIds::MGM_1_RM3100_CS, RM3100::MAX_BUFFER_SIZE,
+      new SpiCookie(addresses::MGM_1_RM3100, gpioIds::MGM_1_RM3100_CS, mgmRm3100::MAX_BUFFER_SIZE,
                     spi::DEFAULT_RM3100_MODE, spi::DEFAULT_RM3100_SPEED);
   spiCookie->setMutexParams(MutexIF::TimeoutType::WAITING, spi::ACS_BOARD_CS_TIMEOUT);
   auto mgmRm3100Handler1 =
-      new MgmRM3100Handler(objects::MGM_1_RM3100_HANDLER, objects::SPI_MAIN_COM_IF, spiCookie,
-                           spi::RM3100_TRANSITION_DELAY);
+      new MgmRm3100CustomHandler(objects::MGM_1_RM3100_HANDLER, objects::ACS_BOARD_POLLING_TASK,
+                                 spiCookie, spi::RM3100_TRANSITION_DELAY);
   fdir = new AcsBoardFdir(objects::MGM_1_RM3100_HANDLER);
   mgmRm3100Handler1->setCustomFdir(fdir);
   assemblyChildren[1] = mgmRm3100Handler1;
@@ -377,12 +386,12 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, SerialCo
 #if OBSW_DEBUG_ACS == 1
   mgmRm3100Handler->enablePeriodicPrintouts(true, 10);
 #endif
-  spiCookie =
-      new SpiCookie(addresses::MGM_2_LIS3, gpioIds::MGM_2_LIS3_CS, MGMLIS3MDL::MAX_BUFFER_SIZE,
-                    spi::DEFAULT_LIS3_MODE, spi::DEFAULT_LIS3_SPEED);
+  spiCookie = new SpiCookie(addresses::MGM_2_LIS3, gpioIds::MGM_2_LIS3_CS, mgmLis3::MAX_BUFFER_SIZE,
+                            spi::DEFAULT_LIS3_MODE, spi::DEFAULT_LIS3_SPEED);
   spiCookie->setMutexParams(MutexIF::TimeoutType::WAITING, spi::ACS_BOARD_CS_TIMEOUT);
-  auto* mgmLis3Handler2 = new MgmLIS3MDLHandler(
-      objects::MGM_2_LIS3_HANDLER, objects::SPI_MAIN_COM_IF, spiCookie, spi::LIS3_TRANSITION_DELAY);
+  auto* mgmLis3Handler2 =
+      new MgmLis3CustomHandler(objects::MGM_2_LIS3_HANDLER, objects::ACS_BOARD_POLLING_TASK,
+                               spiCookie, spi::LIS3_TRANSITION_DELAY);
   fdir = new AcsBoardFdir(objects::MGM_2_LIS3_HANDLER);
   mgmLis3Handler2->setCustomFdir(fdir);
   assemblyChildren[2] = mgmLis3Handler2;
@@ -394,12 +403,12 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, SerialCo
   mgmLis3Handler->enablePeriodicPrintouts(true, 10);
 #endif
   spiCookie =
-      new SpiCookie(addresses::MGM_3_RM3100, gpioIds::MGM_3_RM3100_CS, RM3100::MAX_BUFFER_SIZE,
+      new SpiCookie(addresses::MGM_3_RM3100, gpioIds::MGM_3_RM3100_CS, mgmRm3100::MAX_BUFFER_SIZE,
                     spi::DEFAULT_RM3100_MODE, spi::DEFAULT_RM3100_SPEED);
   spiCookie->setMutexParams(MutexIF::TimeoutType::WAITING, spi::ACS_BOARD_CS_TIMEOUT);
   auto* mgmRm3100Handler3 =
-      new MgmRM3100Handler(objects::MGM_3_RM3100_HANDLER, objects::SPI_MAIN_COM_IF, spiCookie,
-                           spi::RM3100_TRANSITION_DELAY);
+      new MgmRm3100CustomHandler(objects::MGM_3_RM3100_HANDLER, objects::ACS_BOARD_POLLING_TASK,
+                                 spiCookie, spi::RM3100_TRANSITION_DELAY);
   fdir = new AcsBoardFdir(objects::MGM_3_RM3100_HANDLER);
   mgmRm3100Handler3->setCustomFdir(fdir);
   assemblyChildren[3] = mgmRm3100Handler3;
@@ -413,12 +422,12 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, SerialCo
   // Commented until ACS board V2 in in clean room again
   // Gyro 0 Side A
   spiCookie =
-      new SpiCookie(addresses::GYRO_0_ADIS, gpioIds::GYRO_0_ADIS_CS, ADIS1650X::MAXIMUM_REPLY_SIZE,
+      new SpiCookie(addresses::GYRO_0_ADIS, gpioIds::GYRO_0_ADIS_CS, adis1650x::MAXIMUM_REPLY_SIZE,
                     spi::DEFAULT_ADIS16507_MODE, spi::DEFAULT_ADIS16507_SPEED);
   spiCookie->setMutexParams(MutexIF::TimeoutType::WAITING, spi::ACS_BOARD_CS_TIMEOUT);
   auto adisHandler =
-      new GyroADIS1650XHandler(objects::GYRO_0_ADIS_HANDLER, objects::SPI_MAIN_COM_IF, spiCookie,
-                               ADIS1650X::Type::ADIS16505);
+      new GyrAdis1650XHandler(objects::GYRO_0_ADIS_HANDLER, objects::ACS_BOARD_POLLING_TASK,
+                              spiCookie, adis1650x::Type::ADIS16505);
   fdir = new AcsBoardFdir(objects::GYRO_0_ADIS_HANDLER);
   adisHandler->setCustomFdir(fdir);
   assemblyChildren[4] = adisHandler;
@@ -430,11 +439,12 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, SerialCo
   adisHandler->enablePeriodicPrintouts(true, 10);
 #endif
   // Gyro 1 Side A
-  spiCookie = new SpiCookie(addresses::GYRO_1_L3G, gpioIds::GYRO_1_L3G_CS, L3GD20H::MAX_BUFFER_SIZE,
+  spiCookie = new SpiCookie(addresses::GYRO_1_L3G, gpioIds::GYRO_1_L3G_CS, l3gd20h::MAX_BUFFER_SIZE,
                             spi::DEFAULT_L3G_MODE, spi::DEFAULT_L3G_SPEED);
   spiCookie->setMutexParams(MutexIF::TimeoutType::WAITING, spi::ACS_BOARD_CS_TIMEOUT);
-  auto gyroL3gHandler1 = new GyroHandlerL3GD20H(
-      objects::GYRO_1_L3G_HANDLER, objects::SPI_MAIN_COM_IF, spiCookie, spi::L3G_TRANSITION_DELAY);
+  auto gyroL3gHandler1 =
+      new GyrL3gCustomHandler(objects::GYRO_1_L3G_HANDLER, objects::ACS_BOARD_POLLING_TASK,
+                              spiCookie, spi::L3G_TRANSITION_DELAY);
   fdir = new AcsBoardFdir(objects::GYRO_1_L3G_HANDLER);
   gyroL3gHandler1->setCustomFdir(fdir);
   assemblyChildren[5] = gyroL3gHandler1;
@@ -447,11 +457,12 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, SerialCo
 #endif
   // Gyro 2 Side B
   spiCookie =
-      new SpiCookie(addresses::GYRO_2_ADIS, gpioIds::GYRO_2_ADIS_CS, ADIS1650X::MAXIMUM_REPLY_SIZE,
+      new SpiCookie(addresses::GYRO_2_ADIS, gpioIds::GYRO_2_ADIS_CS, adis1650x::MAXIMUM_REPLY_SIZE,
                     spi::DEFAULT_ADIS16507_MODE, spi::DEFAULT_ADIS16507_SPEED);
   spiCookie->setMutexParams(MutexIF::TimeoutType::WAITING, spi::ACS_BOARD_CS_TIMEOUT);
-  adisHandler = new GyroADIS1650XHandler(objects::GYRO_2_ADIS_HANDLER, objects::SPI_MAIN_COM_IF,
-                                         spiCookie, ADIS1650X::Type::ADIS16505);
+  adisHandler =
+      new GyrAdis1650XHandler(objects::GYRO_2_ADIS_HANDLER, objects::ACS_BOARD_POLLING_TASK,
+                              spiCookie, adis1650x::Type::ADIS16505);
   fdir = new AcsBoardFdir(objects::GYRO_2_ADIS_HANDLER);
   adisHandler->setCustomFdir(fdir);
   assemblyChildren[6] = adisHandler;
@@ -460,11 +471,12 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, SerialCo
   adisHandler->setToGoToNormalModeImmediately();
 #endif
   // Gyro 3 Side B
-  spiCookie = new SpiCookie(addresses::GYRO_3_L3G, gpioIds::GYRO_3_L3G_CS, L3GD20H::MAX_BUFFER_SIZE,
+  spiCookie = new SpiCookie(addresses::GYRO_3_L3G, gpioIds::GYRO_3_L3G_CS, l3gd20h::MAX_BUFFER_SIZE,
                             spi::DEFAULT_L3G_MODE, spi::DEFAULT_L3G_SPEED);
   spiCookie->setMutexParams(MutexIF::TimeoutType::WAITING, spi::ACS_BOARD_CS_TIMEOUT);
-  auto gyroL3gHandler3 = new GyroHandlerL3GD20H(
-      objects::GYRO_3_L3G_HANDLER, objects::SPI_MAIN_COM_IF, spiCookie, spi::L3G_TRANSITION_DELAY);
+  auto gyroL3gHandler3 =
+      new GyrL3gCustomHandler(objects::GYRO_3_L3G_HANDLER, objects::ACS_BOARD_POLLING_TASK,
+                              spiCookie, spi::L3G_TRANSITION_DELAY);
   fdir = new AcsBoardFdir(objects::GYRO_3_L3G_HANDLER);
   gyroL3gHandler3->setCustomFdir(fdir);
   assemblyChildren[7] = gyroL3gHandler3;
@@ -572,7 +584,6 @@ void ObjectFactory::createSyrlinksComponents(PowerSwitchIF* pwrSwitcher) {
       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);
@@ -755,15 +766,10 @@ ReturnValue_t ObjectFactory::createCcsdsComponents(LinuxLibgpioIF* gpioComIF,
   AxiPtmeConfig* axiPtmeConfig =
       new AxiPtmeConfig(objects::AXI_PTME_CONFIG, q7s::UIO_PTME, q7s::uiomapids::PTME_CONFIG);
   PtmeConfig* ptmeConfig = new PtmeConfig(objects::PTME_CONFIG, axiPtmeConfig);
-#if OBSW_ENABLE_SYRLINKS_TRANSMIT_TIMEOUT == 1
-  // Set to high value when not sending via syrlinks
-  static const uint32_t TRANSMITTER_TIMEOUT = 86400000;  // 1 day
-#else
-  static const uint32_t TRANSMITTER_TIMEOUT = 900000;  // 15 minutes
-#endif
-  *ipCoreHandler = new CcsdsIpCoreHandler(
-      objects::CCSDS_HANDLER, objects::PTME, objects::CCSDS_PACKET_DISTRIBUTOR, ptmeConfig,
-      gpioComIF, gpioIds::RS485_EN_TX_CLOCK, gpioIds::RS485_EN_TX_DATA, TRANSMITTER_TIMEOUT);
+
+  *ipCoreHandler = new CcsdsIpCoreHandler(objects::CCSDS_HANDLER, objects::PTME,
+                                          objects::CCSDS_PACKET_DISTRIBUTOR, ptmeConfig, gpioComIF,
+                                          gpioIds::RS485_EN_TX_CLOCK, gpioIds::RS485_EN_TX_DATA);
   VirtualChannel* vc = nullptr;
   vc = new VirtualChannel(ccsds::VC0, config::VC0_QUEUE_SIZE, objects::CCSDS_HANDLER);
   (*ipCoreHandler)->addVirtualChannel(ccsds::VC0, vc);
@@ -906,8 +912,9 @@ void ObjectFactory::createStrComponents(PowerSwitchIF* pwrSwitcher) {
 }
 
 void ObjectFactory::createImtqComponents(PowerSwitchIF* pwrSwitcher) {
-  I2cCookie* imtqI2cCookie = new I2cCookie(addresses::IMTQ, IMTQ::MAX_REPLY_SIZE, q7s::I2C_PL_EIVE);
-  auto imtqHandler = new ImtqHandler(objects::IMTQ_HANDLER, objects::I2C_COM_IF, imtqI2cCookie,
+  new ImtqPollingTask(objects::IMTQ_POLLING);
+  I2cCookie* imtqI2cCookie = new I2cCookie(addresses::IMTQ, imtq::MAX_REPLY_SIZE, q7s::I2C_PL_EIVE);
+  auto imtqHandler = new ImtqHandler(objects::IMTQ_HANDLER, objects::IMTQ_POLLING, imtqI2cCookie,
                                      pcdu::Switches::PDU1_CH3_MGT_5V);
   imtqHandler->enableThermalModule(ThermalStateCfg());
   imtqHandler->setPowerSwitcher(pwrSwitcher);

bsp_q7s/core/ObjectFactory.h

@@ -2,6 +2,7 @@
 #define BSP_Q7S_OBJECTFACTORY_H_
 
 #include <fsfw/returnvalues/returnvalue.h>
+#include <fsfw_hal/linux/spi/SpiComIF.h>
 #include <mission/devices/HeaterHandler.h>
 #include <mission/system/objects/Stack5VHandler.h>
 #include <mission/tmtc/CcsdsIpCoreHandler.h>
@@ -31,7 +32,7 @@ void createPlPcduComponents(LinuxLibgpioIF* gpioComIF, SpiComIF* spiComIF,
                             PowerSwitchIF* pwrSwitcher, Stack5VHandler& stackHandler);
 void createTmpComponents();
 ReturnValue_t createRadSensorComponent(LinuxLibgpioIF* gpioComIF, Stack5VHandler& handler);
-void createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, SerialComIF* uartComIF,
+void createAcsBoardComponents(SpiComIF& spiComIF, LinuxLibgpioIF* gpioComIF, SerialComIF* uartComIF,
                               PowerSwitchIF& pwrSwitcher);
 void createHeaterComponents(GpioIF* gpioIF, PowerSwitchIF* pwrSwitcher, HealthTableIF* healthTable,
                             HeaterHandler*& heaterHandler);

bsp_q7s/core/scheduling.cpp

@@ -17,10 +17,10 @@
 #include "fsfw/tasks/FixedTimeslotTaskIF.h"
 #include "fsfw/tasks/PeriodicTaskIF.h"
 #include "fsfw/tasks/TaskFactory.h"
+#include "mission/core/pollingSeqTables.h"
 #include "mission/core/scheduling.h"
 #include "mission/devices/devicedefinitions/Max31865Definitions.h"
 #include "mission/utility/InitMission.h"
-#include "pollingsequence/pollingSequenceFactory.h"
 
 /* This is configured for linux without CR */
 #ifdef PLATFORM_UNIX
@@ -187,23 +187,47 @@ void scheduling::initTasks() {
   }
 #endif
 
-#if OBSW_ADD_GPS_CTRL == 1
   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 */
+
+#if OBSW_ADD_ACS_BOARD == 1
+  PeriodicTaskIF* acsBrdPolling = factory->createPeriodicTask(
+      "ACS_BOARD_POLLING", 85, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 0.4, missedDeadlineFunc);
+  result = acsBrdPolling->addComponent(objects::ACS_BOARD_POLLING_TASK);
+  if (result != returnvalue::OK) {
+    scheduling::printAddObjectError("ACS_BOARD_POLLING", objects::ACS_BOARD_POLLING_TASK);
+  }
+#endif
 
 #if OBSW_ADD_RW == 1
   PeriodicTaskIF* rwPolling = factory->createPeriodicTask(
-      "RW_POLLING_TASK", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 0.4, missedDeadlineFunc);
+      "RW_POLLING_TASK", 85, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 0.4, missedDeadlineFunc);
   result = rwPolling->addComponent(objects::RW_POLLING_TASK);
   if (result != returnvalue::OK) {
     scheduling::printAddObjectError("RW_POLLING_TASK", objects::RW_POLLING_TASK);
   }
 #endif
+#if OBSW_ADD_MGT == 1
+  PeriodicTaskIF* imtqPolling = factory->createPeriodicTask(
+      "IMTQ_POLLING_TASK", 85, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 0.4, missedDeadlineFunc);
+  result = imtqPolling->addComponent(objects::IMTQ_POLLING);
+  if (result != returnvalue::OK) {
+    scheduling::printAddObjectError("IMTQ_POLLING_TASK", objects::IMTQ_POLLING);
+  }
+#endif
+
+#if OBSW_ADD_SUN_SENSORS == 1
+  PeriodicTaskIF* susPolling = factory->createPeriodicTask(
+      "SUS_POLLING_TASK", 85, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 0.4, missedDeadlineFunc);
+  result = susPolling->addComponent(objects::SUS_POLLING_TASK);
+  if (result != returnvalue::OK) {
+    scheduling::printAddObjectError("SUS_POLLING_TASK", objects::SUS_POLLING_TASK);
+  }
+#endif
 
   PeriodicTaskIF* acsSysTask = factory->createPeriodicTask(
       "ACS_SYS_TASK", 55, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 0.4, missedDeadlineFunc);
@@ -345,6 +369,15 @@ void scheduling::initTasks() {
 #if OBSW_ADD_SA_DEPL == 1
   solarArrayDeplTask->startTask();
 #endif
+#if OBSW_ADD_ACS_BOARD == 1
+  acsBrdPolling->startTask();
+#endif
+#if OBSW_ADD_MGT == 1
+  imtqPolling->startTask();
+#endif
+#if OBSW_ADD_SUN_SENSORS == 1
+  susPolling->startTask();
+#endif
 
   taskStarter(pstTasks, "PST task vector");
   taskStarter(pusTasks, "PUS task vector");
@@ -367,9 +400,7 @@ void scheduling::initTasks() {
 #if OBSW_ADD_RW == 1
   rwPolling->startTask();
 #endif
-#if OBSW_ADD_GPS_CTRL == 1
   gpsTask->startTask();
-#endif
   acsSysTask->startTask();
   if (not tcsSystemTask->isEmpty()) {
     tcsSystemTask->startTask();
@@ -393,10 +424,10 @@ void scheduling::createPstTasks(TaskFactory& factory, TaskDeadlineMissedFunction
 #ifdef RELEASE_BUILD
   static constexpr float acsPstPeriod = 0.4;
 #else
-  static constexpr float acsPstPeriod = 0.8;
+  static constexpr float acsPstPeriod = 0.4;
 #endif
   FixedTimeslotTaskIF* acsTcsPst = factory.createFixedTimeslotTask(
-      "ACS_TCS_PST", 85, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, acsPstPeriod, missedDeadlineFunc);
+      "ACS_TCS_PST", 80, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, acsPstPeriod, missedDeadlineFunc);
   result = pst::pstTcsAndAcs(acsTcsPst, cfg);
   if (result != returnvalue::OK) {
     if (result == FixedTimeslotTaskIF::SLOT_LIST_EMPTY) {

bsp_q7s/core/scheduling.h

@@ -1,11 +1,10 @@
 #ifndef BSP_Q7S_INITMISSION_H_
 #define BSP_Q7S_INITMISSION_H_
 
-#include <pollingsequence/pollingSequenceFactory.h>
-
 #include <vector>
 
 #include "fsfw/tasks/definitions.h"
+#include "mission/core/pollingSeqTables.h"
 
 using pst::AcsPstCfg;
 

bsp_q7s/em/emObjectFactory.cpp

@@ -3,6 +3,7 @@
 #include <fsfw/power/DummyPowerSwitcher.h>
 #include <mission/devices/devicedefinitions/GomspaceDefinitions.h>
 #include <mission/system/tree/system.h>
+#include <mission/utility/DummySdCardManager.h>
 
 #include "OBSWConfig.h"
 #include "bsp_q7s/core/CoreController.h"
@@ -22,7 +23,8 @@ void ObjectFactory::produce(void* args) {
   HealthTableIF* healthTable = nullptr;
   PusTmFunnel* pusFunnel = nullptr;
   CfdpTmFunnel* cfdpFunnel = nullptr;
-  ObjectFactory::produceGenericObjects(&healthTable, &pusFunnel, &cfdpFunnel);
+  ObjectFactory::produceGenericObjects(&healthTable, &pusFunnel, &cfdpFunnel,
+                                       *SdCardManager::instance());
 
   LinuxLibgpioIF* gpioComIF = nullptr;
   SerialComIF* uartComIF = nullptr;

bsp_q7s/fmObjectFactory.cpp

@@ -18,7 +18,8 @@ void ObjectFactory::produce(void* args) {
   HealthTableIF* healthTable = nullptr;
   PusTmFunnel* pusFunnel = nullptr;
   CfdpTmFunnel* cfdpFunnel = nullptr;
-  ObjectFactory::produceGenericObjects(&healthTable, &pusFunnel, &cfdpFunnel);
+  ObjectFactory::produceGenericObjects(&healthTable, &pusFunnel, &cfdpFunnel,
+                                       *SdCardManager::instance());
 
   LinuxLibgpioIF* gpioComIF = nullptr;
   SerialComIF* uartComIF = nullptr;
@@ -42,7 +43,7 @@ void ObjectFactory::produce(void* args) {
 #endif
 
 #if OBSW_ADD_ACS_BOARD == 1
-  createAcsBoardComponents(gpioComIF, uartComIF, *pwrSwitcher);
+  createAcsBoardComponents(*spiMainComIF, gpioComIF, uartComIF, *pwrSwitcher);
 #endif
   HeaterHandler* heaterHandler;
   createHeaterComponents(gpioComIF, pwrSwitcher, healthTable, heaterHandler);

bsp_q7s/fs/FilesystemHelper.cpp

@@ -22,7 +22,7 @@ ReturnValue_t FilesystemHelper::checkPath(std::string path) {
     }
   } else if (path.substr(0, sizeof(config::SD_1_MOUNT_POINT)) ==
              std::string(config::SD_1_MOUNT_POINT)) {
-    if (!sdcMan->isSdCardUsable(sd::SLOT_0)) {
+    if (!sdcMan->isSdCardUsable(sd::SLOT_1)) {
       sif::warning << "FilesystemHelper::checkPath: SD card 1 not mounted" << std::endl;
       return SD_NOT_MOUNTED;
     }

bsp_q7s/fs/SdCardManager.cpp

@@ -410,9 +410,12 @@ ReturnValue_t SdCardManager::updateSdCardStateFile() {
   return result;
 }
 
-const std::string& SdCardManager::getCurrentMountPrefix() const {
+const char* SdCardManager::getCurrentMountPrefix() const {
   MutexGuard mg(mutex);
-  return currentPrefix;
+  if (currentPrefix.has_value()) {
+    return currentPrefix.value().c_str();
+  }
+  return nullptr;
 }
 
 SdCardManager::OpStatus SdCardManager::checkCurrentOp(Operations& currentOp) {
@@ -505,9 +508,9 @@ bool SdCardManager::isSdCardUsable(std::optional<sd::SdCard> sdCard) {
 ReturnValue_t SdCardManager::isSdCardMountedReadOnly(sd::SdCard sdcard, bool& readOnly) {
   std::ostringstream command;
   if (sdcard == sd::SdCard::SLOT_0) {
-    command << "grep -q '" << config::SD_0_MOUNT_POINT << " ext4 ro,' /proc/mounts";
+    command << "grep -q '" << config::SD_0_MOUNT_POINT << " ext4 rw,' /proc/mounts";
   } else if (sdcard == sd::SdCard::SLOT_1) {
-    command << "grep -q '" << config::SD_1_MOUNT_POINT << " ext4 ro,' /proc/mounts";
+    command << "grep -q '" << config::SD_1_MOUNT_POINT << " ext4 rw,' /proc/mounts";
   } else {
     return returnvalue::FAILED;
   }
@@ -516,18 +519,9 @@ ReturnValue_t SdCardManager::isSdCardMountedReadOnly(sd::SdCard sdcard, bool& re
     return result;
   }
   result = cmdExecutor.execute();
-  if (result != returnvalue::OK) {
-    int exitStatus = cmdExecutor.getLastError();
-    if (exitStatus == 1) {
-      readOnly = false;
-      return returnvalue::OK;
-    }
-    return result;
-  }
-  auto& readVec = cmdExecutor.getReadVector();
-  size_t readLen = strnlen(readVec.data(), readVec.size());
-  if (readLen == 0) {
+  if (result == returnvalue::OK) {
     readOnly = false;
+    return result;
   }
   readOnly = true;
   return returnvalue::OK;

bsp_q7s/fs/SdCardManager.h

@@ -187,7 +187,7 @@ class SdCardManager : public SystemObject, public SdCardMountedIF {
    * @param prefSdCardPtr
    * @return
    */
-  const std::string& getCurrentMountPrefix() const override;
+  const char* getCurrentMountPrefix() const override;
 
   OpStatus checkCurrentOp(Operations& currentOp);
 
@@ -232,7 +232,7 @@ class SdCardManager : public SystemObject, public SdCardMountedIF {
   void processSdStatusLine(SdStatePair& active, std::string& line, uint8_t& idx,
                            sd::SdCard& currentSd);
 
-  std::string currentPrefix;
+  std::optional<std::string> currentPrefix;
 
   static SdCardManager* INSTANCE;
 };

bsp_q7s/fs/helpers.cpp

@@ -3,6 +3,9 @@
 std::filesystem::path fshelpers::getPrefixedPath(SdCardManager &man,
                                                  std::filesystem::path pathWihtoutPrefix) {
   auto prefix = man.getCurrentMountPrefix();
+  if (prefix == nullptr) {
+    return pathWihtoutPrefix;
+  }
   auto resPath = prefix / pathWihtoutPrefix;
   return resPath;
 }

bsp_q7s/memory/CMakeLists.txt

@@ -1 +1 @@
-target_sources(${OBSW_NAME} PRIVATE scratchApi.cpp)
+target_sources(${OBSW_NAME} PRIVATE scratchApi.cpp LocalParameterHandler.cpp)

bsp_q7s/memory/LocalParameterHandler.cpp

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

bsp_q7s/memory/LocalParameterHandler.h

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

common/config/eive/definitions.h

@@ -59,17 +59,25 @@ namespace acs {
 
 static constexpr uint32_t SCHED_BLOCK_1_SUS_READ_MS = 15;
 static constexpr uint32_t SCHED_BLOCK_2_SENSOR_READ_MS = 30;
-static constexpr uint32_t SCHED_BLOCK_3_ACS_CTRL_MS = 45;
-static constexpr uint32_t SCHED_BLOCK_4_ACTUATOR_MS = 50;
-static constexpr uint32_t SCHED_BLOCK_5_RW_READ_MS = 300;
+static constexpr uint32_t SCHED_BLOCK_3_READ_IMTQ_MGM_MS = 42;
+static constexpr uint32_t SCHED_BLOCK_4_ACS_CTRL_MS = 45;
+static constexpr uint32_t SCHED_BLOCK_5_ACTUATOR_MS = 55;
+static constexpr uint32_t SCHED_BLOCK_6_IMTQ_BLOCK_2_MS = 95;
+static constexpr uint32_t SCHED_BLOCK_RTD = 150;
+static constexpr uint32_t SCHED_BLOCK_7_RW_READ_MS = 300;
 
 // 15 ms for FM
 static constexpr float SCHED_BLOCK_1_PERIOD = static_cast<float>(SCHED_BLOCK_1_SUS_READ_MS) / 400.0;
 static constexpr float SCHED_BLOCK_2_PERIOD =
     static_cast<float>(SCHED_BLOCK_2_SENSOR_READ_MS) / 400.0;
-static constexpr float SCHED_BLOCK_3_PERIOD = static_cast<float>(SCHED_BLOCK_3_ACS_CTRL_MS) / 400.0;
-static constexpr float SCHED_BLOCK_4_PERIOD = static_cast<float>(SCHED_BLOCK_4_ACTUATOR_MS) / 400.0;
-static constexpr float SCHED_BLOCK_5_PERIOD = static_cast<float>(SCHED_BLOCK_5_RW_READ_MS) / 400.0;
+static constexpr float SCHED_BLOCK_3_PERIOD =
+    static_cast<float>(SCHED_BLOCK_3_READ_IMTQ_MGM_MS) / 400.0;
+static constexpr float SCHED_BLOCK_4_PERIOD = static_cast<float>(SCHED_BLOCK_4_ACS_CTRL_MS) / 400.0;
+static constexpr float SCHED_BLOCK_5_PERIOD = static_cast<float>(SCHED_BLOCK_5_ACTUATOR_MS) / 400.0;
+static constexpr float SCHED_BLOCK_6_PERIOD =
+    static_cast<float>(SCHED_BLOCK_6_IMTQ_BLOCK_2_MS) / 400.0;
+static constexpr float SCHED_BLOCK_7_PERIOD = static_cast<float>(SCHED_BLOCK_7_RW_READ_MS) / 400.0;
+static constexpr float SCHED_BLOCK_RTD_PERIOD = static_cast<float>(SCHED_BLOCK_RTD) / 400.0;
 
 }  // namespace acs
 

common/config/eive/eventSubsystemIds.h

@@ -37,6 +37,8 @@ enum : uint8_t {
   CONFIGHANDLER = 139,
   CORE = 140,
   TCS_CONTROLLER = 141,
+  COM_SUBSYSTEM = 142,
+  PERSISTENT_TM_STORE = 143,
   COMMON_SUBSYSTEM_ID_END
 
 };

common/config/eive/objects.h

@@ -44,6 +44,7 @@ enum commonObjects : uint32_t {
   STAR_TRACKER = 0x44130001,
   GPS_CONTROLLER = 0x44130045,
 
+  IMTQ_POLLING = 0x44140013,
   IMTQ_HANDLER = 0x44140014,
   TMP1075_HANDLER_TCS_0 = 0x44420004,
   TMP1075_HANDLER_TCS_1 = 0x44420005,
@@ -122,7 +123,10 @@ enum commonObjects : uint32_t {
   // CCSDS_IP_CORE_BRIDGE = 0x73500000,
 
   /* 0x49 ('I') for Communication Interfaces */
-  SPI_RTD_COM_IF = 0x49020006,
+  ACS_BOARD_POLLING_TASK = 0x49060004,
+  RW_POLLING_TASK = 0x49060005,
+  SPI_RTD_COM_IF = 0x49060006,
+  SUS_POLLING_TASK = 0x49060007,
 
   // 0x60 for other stuff
   HEATER_0_PLOC_PROC_BRD = 0x60000000,
@@ -151,6 +155,11 @@ enum commonObjects : uint32_t {
   CFDP_TM_FUNNEL = 0x73000102,
   CFDP_HANDLER = 0x73000205,
   CFDP_DISTRIBUTOR = 0x73000206,
+  MISC_TM_STORE = 0x73020001,
+  OK_TM_STORE = 0x73020002,
+  NOT_OK_TM_STORE = 0x73020003,
+  HK_TM_STORE = 0x73020004,
+  CFDP_TM_STORE = 0x73030000,
 
   // Other stuff
   THERMAL_TEMP_INSERTER = 0x90000003,

common/config/eive/resultClassIds.h

@@ -35,14 +35,15 @@ enum commonClassIds : uint8_t {
   SA_DEPL_HANDLER,          // SADPL
   MPSOC_RETURN_VALUES_IF,   // MPSOCRTVIF
   SUPV_RETURN_VALUES_IF,    // SPVRTVIF
-  ACS_KALMAN,               // ACSKAL
+  ACS_CTRL,                 // ACSCTRL
+  ACS_MEKF,                 // ACSMEKF
   ACS_SAFE,                 // ACSSAF
   ACS_PTG,                  // ACSPTG
   ACS_DETUMBLE,             // ACSDTB
-  ACS_MEKF,                 // ACSMEK
+  SD_CARD_MANAGER,          // SDMA
+  LOCAL_PARAM_HANDLER,      // LPH
   COMMON_CLASS_ID_END       // [EXPORT] : [END]
 };
-
 }
 
 #endif /* COMMON_CONFIG_COMMONCLASSIDS_H_ */

common/config/tmtc/pusIds.h

@@ -12,6 +12,7 @@ enum Ids {
   PUS_SERVICE_8 = 8,
   PUS_SERVICE_9 = 9,
   PUS_SERVICE_11 = 11,
+  PUS_SERVICE_15 = 15,
   PUS_SERVICE_17 = 17,
   PUS_SERVICE_19 = 19,
   PUS_SERVICE_20 = 20,

dummies/CMakeLists.txt

@@ -20,6 +20,7 @@ target_sources(
          GyroL3GD20Dummy.cpp
          MgmLIS3MDLDummy.cpp
          PlPcduDummy.cpp
+         ExecutableComIfDummy.cpp
          ScexDummy.cpp
          CoreControllerDummy.cpp
          PlocMpsocDummy.cpp

dummies/CoreControllerDummy.h

@@ -1,7 +1,7 @@
 #pragma once
 
 #include <fsfw/controller/ExtendedControllerBase.h>
-#include <mission/devices/devicedefinitions/SusDefinitions.h>
+#include <mission/devices/devicedefinitions/susMax1227Helpers.h>
 
 class CoreControllerDummy : public ExtendedControllerBase {
  public:

dummies/ExecutableComIfDummy.cpp

@@ -0,0 +1,27 @@
+#include <dummies/ExecutableComIfDummy.h>
+
+ExecutableComIfDummy::ExecutableComIfDummy(object_id_t objectId) : SystemObject(objectId) {}
+
+ReturnValue_t ExecutableComIfDummy::initializeInterface(CookieIF *cookie) {
+  return returnvalue::OK;
+}
+
+ReturnValue_t ExecutableComIfDummy::sendMessage(CookieIF *cookie, const uint8_t *sendData,
+                                                size_t sendLen) {
+  return returnvalue::OK;
+}
+
+ReturnValue_t ExecutableComIfDummy::getSendSuccess(CookieIF *cookie) { return returnvalue::OK; }
+
+ReturnValue_t ExecutableComIfDummy::requestReceiveMessage(CookieIF *cookie, size_t requestLen) {
+  return returnvalue::OK;
+}
+
+ReturnValue_t ExecutableComIfDummy::performOperation(uint8_t operationCode) {
+  return returnvalue::OK;
+}
+
+ReturnValue_t ExecutableComIfDummy::readReceivedMessage(CookieIF *cookie, uint8_t **buffer,
+                                                        size_t *size) {
+  return returnvalue::OK;
+}

dummies/ExecutableComIfDummy.h

@@ -0,0 +1,21 @@
+#ifndef DUMMIES_EXECUTABLECOMIFDUMMY_H_
+#define DUMMIES_EXECUTABLECOMIFDUMMY_H_
+
+#include <fsfw/devicehandlers/DeviceCommunicationIF.h>
+#include <fsfw/objectmanager/SystemObject.h>
+#include <fsfw/tasks/ExecutableObjectIF.h>
+
+class ExecutableComIfDummy : public ExecutableObjectIF,
+                             public DeviceCommunicationIF,
+                             public SystemObject {
+ public:
+  ExecutableComIfDummy(object_id_t objectId);
+  ReturnValue_t performOperation(uint8_t operationCode = 0) override;
+  ReturnValue_t initializeInterface(CookieIF *cookie) override;
+  ReturnValue_t sendMessage(CookieIF *cookie, const uint8_t *sendData, size_t sendLen) override;
+  ReturnValue_t getSendSuccess(CookieIF *cookie) override;
+  ReturnValue_t requestReceiveMessage(CookieIF *cookie, size_t requestLen) override;
+  ReturnValue_t readReceivedMessage(CookieIF *cookie, uint8_t **buffer, size_t *size) override;
+};
+
+#endif /* DUMMIES_EXECUTABLECOMIFDUMMY_H_ */

dummies/GpsCtrlDummy.cpp

@@ -1,6 +1,7 @@
 #include "GpsCtrlDummy.h"
 
-GpsCtrlDummy::GpsCtrlDummy(object_id_t objectId) : ExtendedControllerBase(objectId, 20) {}
+GpsCtrlDummy::GpsCtrlDummy(object_id_t objectId)
+    : ExtendedControllerBase(objectId, 20), gpsSet(this) {}
 
 ReturnValue_t GpsCtrlDummy::handleCommandMessage(CommandMessage* message) {
   return returnvalue::OK;
@@ -13,9 +14,23 @@ ReturnValue_t GpsCtrlDummy::checkModeCommand(Mode_t mode, Submode_t submode,
   return returnvalue::OK;
 }
 
+LocalPoolDataSetBase* GpsCtrlDummy::getDataSetHandle(sid_t sid) { return &gpsSet; }
+
 ReturnValue_t GpsCtrlDummy::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
                                                     LocalDataPoolManager& poolManager) {
+  localDataPoolMap.emplace(GpsHyperion::ALTITUDE, new PoolEntry<double>({537222.3469}, true));
+  localDataPoolMap.emplace(GpsHyperion::LONGITUDE, new PoolEntry<double>({-8.8579}, true));
+  localDataPoolMap.emplace(GpsHyperion::LATITUDE, new PoolEntry<double>({49.5952}, true));
+  localDataPoolMap.emplace(GpsHyperion::SPEED, new PoolEntry<double>({0}));
+  localDataPoolMap.emplace(GpsHyperion::YEAR, new PoolEntry<uint16_t>({2023}, true));
+  localDataPoolMap.emplace(GpsHyperion::MONTH, new PoolEntry<uint8_t>({5}, true));
+  localDataPoolMap.emplace(GpsHyperion::DAY, new PoolEntry<uint8_t>({16}, true));
+  localDataPoolMap.emplace(GpsHyperion::HOURS, new PoolEntry<uint8_t>({1}, true));
+  localDataPoolMap.emplace(GpsHyperion::MINUTES, new PoolEntry<uint8_t>({0}, true));
+  localDataPoolMap.emplace(GpsHyperion::SECONDS, new PoolEntry<uint8_t>({0}, true));
+  localDataPoolMap.emplace(GpsHyperion::UNIX_SECONDS, new PoolEntry<uint32_t>({1684191600}, true));
+  localDataPoolMap.emplace(GpsHyperion::SATS_IN_USE, new PoolEntry<uint8_t>());
+  localDataPoolMap.emplace(GpsHyperion::SATS_IN_VIEW, new PoolEntry<uint8_t>());
+  localDataPoolMap.emplace(GpsHyperion::FIX_MODE, new PoolEntry<uint8_t>());
   return returnvalue::OK;
 }
-
-LocalPoolDataSetBase* GpsCtrlDummy::getDataSetHandle(sid_t sid) { return nullptr; }

dummies/GpsCtrlDummy.h

@@ -2,12 +2,15 @@
 #define DUMMIES_GPSCTRLDUMMY_H_
 
 #include <fsfw/controller/ExtendedControllerBase.h>
+#include <mission/devices/devicedefinitions/GPSDefinitions.h>
 
 class GpsCtrlDummy : public ExtendedControllerBase {
  public:
   GpsCtrlDummy(object_id_t objectId);
 
  private:
+  GpsPrimaryDataset gpsSet;
+
   ReturnValue_t handleCommandMessage(CommandMessage* message) override;
   void performControlOperation() override;
   ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,

dummies/GyroAdisDummy.cpp

@@ -1,6 +1,6 @@
 #include "GyroAdisDummy.h"
 
-#include "mission/devices/devicedefinitions/GyroADIS1650XDefinitions.h"
+#include <mission/devices/devicedefinitions/gyroAdisHelpers.h>
 
 GyroAdisDummy::GyroAdisDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
     : DeviceHandlerBase(objectId, comif, comCookie), dataset(this) {}
@@ -40,13 +40,13 @@ uint32_t GyroAdisDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { r
 
 ReturnValue_t GyroAdisDummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                                      LocalDataPoolManager &poolManager) {
-  localDataPoolMap.emplace(ADIS1650X::ANG_VELOC_X, new PoolEntry<double>({-0.5}, true));
-  localDataPoolMap.emplace(ADIS1650X::ANG_VELOC_Y, new PoolEntry<double>({0.2}, true));
-  localDataPoolMap.emplace(ADIS1650X::ANG_VELOC_Z, new PoolEntry<double>({-1.2}, true));
-  localDataPoolMap.emplace(ADIS1650X::ACCELERATION_X, new PoolEntry<double>({0.0}));
-  localDataPoolMap.emplace(ADIS1650X::ACCELERATION_Y, new PoolEntry<double>({0.0}));
-  localDataPoolMap.emplace(ADIS1650X::ACCELERATION_Z, new PoolEntry<double>({0.0}));
-  localDataPoolMap.emplace(ADIS1650X::TEMPERATURE, new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(adis1650x::ANG_VELOC_X, new PoolEntry<double>({-0.5}, true));
+  localDataPoolMap.emplace(adis1650x::ANG_VELOC_Y, new PoolEntry<double>({0.2}, true));
+  localDataPoolMap.emplace(adis1650x::ANG_VELOC_Z, new PoolEntry<double>({-1.2}, true));
+  localDataPoolMap.emplace(adis1650x::ACCELERATION_X, new PoolEntry<double>({0.0}));
+  localDataPoolMap.emplace(adis1650x::ACCELERATION_Y, new PoolEntry<double>({0.0}));
+  localDataPoolMap.emplace(adis1650x::ACCELERATION_Z, new PoolEntry<double>({0.0}));
+  localDataPoolMap.emplace(adis1650x::TEMPERATURE, new PoolEntry<float>({0.0}));
 
   return returnvalue::OK;
 }

dummies/GyroAdisDummy.h

@@ -2,8 +2,7 @@
 #define DUMMIES_GYROADISDUMMY_H_
 
 #include <fsfw/devicehandlers/DeviceHandlerBase.h>
-
-#include "mission/devices/devicedefinitions/GyroADIS1650XDefinitions.h"
+#include <mission/devices/devicedefinitions/gyroAdisHelpers.h>
 
 class GyroAdisDummy : public DeviceHandlerBase {
  public:

dummies/GyroL3GD20Dummy.cpp

@@ -1,6 +1,6 @@
 #include "GyroL3GD20Dummy.h"
 
-#include "fsfw_hal/devicehandlers/devicedefinitions/GyroL3GD20Definitions.h"
+#include <fsfw_hal/devicehandlers/devicedefinitions/gyroL3gHelpers.h>
 
 GyroL3GD20Dummy::GyroL3GD20Dummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
     : DeviceHandlerBase(objectId, comif, comCookie) {}
@@ -40,9 +40,9 @@ uint32_t GyroL3GD20Dummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) {
 
 ReturnValue_t GyroL3GD20Dummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                                        LocalDataPoolManager &poolManager) {
-  localDataPoolMap.emplace(L3GD20H::ANG_VELOC_X, new PoolEntry<float>({1.2}, true));
-  localDataPoolMap.emplace(L3GD20H::ANG_VELOC_Y, new PoolEntry<float>({-0.1}, true));
-  localDataPoolMap.emplace(L3GD20H::ANG_VELOC_Z, new PoolEntry<float>({0.7}, true));
-  localDataPoolMap.emplace(L3GD20H::TEMPERATURE, new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(l3gd20h::ANG_VELOC_X, new PoolEntry<float>({1.2}, true));
+  localDataPoolMap.emplace(l3gd20h::ANG_VELOC_Y, new PoolEntry<float>({-0.1}, true));
+  localDataPoolMap.emplace(l3gd20h::ANG_VELOC_Z, new PoolEntry<float>({0.7}, true));
+  localDataPoolMap.emplace(l3gd20h::TEMPERATURE, new PoolEntry<float>({0.0}));
   return returnvalue::OK;
 }

dummies/ImtqDummy.cpp

@@ -1,6 +1,6 @@
 #include "ImtqDummy.h"
 
-#include <mission/devices/devicedefinitions/imtqHandlerDefinitions.h>
+#include <mission/devices/devicedefinitions/imtqHelpers.h>
 
 ImtqDummy::ImtqDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
     : DeviceHandlerBase(objectId, comif, comCookie) {}
@@ -38,10 +38,10 @@ uint32_t ImtqDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { retur
 
 ReturnValue_t ImtqDummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                                  LocalDataPoolManager &poolManager) {
-  localDataPoolMap.emplace(IMTQ::MCU_TEMPERATURE, new PoolEntry<int16_t>({0}));
-  localDataPoolMap.emplace(IMTQ::MGM_CAL_NT, new PoolEntry<float>({0.0, 0.0, 0.0}));
-  localDataPoolMap.emplace(IMTQ::ACTUATION_CAL_STATUS, new PoolEntry<uint8_t>({0}));
-  localDataPoolMap.emplace(IMTQ::MTM_RAW, new PoolEntry<float>({0.12, 0.76, -0.45}, true));
-  localDataPoolMap.emplace(IMTQ::ACTUATION_RAW_STATUS, new PoolEntry<uint8_t>({0}));
+  localDataPoolMap.emplace(imtq::MCU_TEMPERATURE, new PoolEntry<int16_t>({0}));
+  localDataPoolMap.emplace(imtq::MGM_CAL_NT, new PoolEntry<float>({0.0, 0.0, 0.0}));
+  localDataPoolMap.emplace(imtq::ACTUATION_CAL_STATUS, new PoolEntry<uint8_t>({0}));
+  localDataPoolMap.emplace(imtq::MTM_RAW, new PoolEntry<float>({0.12, 0.76, -0.45}, true));
+  localDataPoolMap.emplace(imtq::ACTUATION_RAW_STATUS, new PoolEntry<uint8_t>({0}));
   return DeviceHandlerBase::initializeLocalDataPool(localDataPoolMap, poolManager);
 }

dummies/MgmLIS3MDLDummy.cpp

@@ -1,6 +1,6 @@
 #include "MgmLIS3MDLDummy.h"
 
-#include "fsfw_hal/devicehandlers/devicedefinitions/MgmLIS3HandlerDefs.h"
+#include <fsfw_hal/devicehandlers/devicedefinitions/mgmLis3Helpers.h>
 
 MgmLIS3MDLDummy::MgmLIS3MDLDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
     : DeviceHandlerBase(objectId, comif, comCookie), dataset(this) {}
@@ -40,8 +40,8 @@ uint32_t MgmLIS3MDLDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) {
 
 ReturnValue_t MgmLIS3MDLDummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                                        LocalDataPoolManager &poolManager) {
-  localDataPoolMap.emplace(MGMLIS3MDL::TEMPERATURE_CELCIUS, new PoolEntry<float>({0.0}));
-  localDataPoolMap.emplace(MGMLIS3MDL::FIELD_STRENGTHS,
+  localDataPoolMap.emplace(mgmLis3::TEMPERATURE_CELCIUS, new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(mgmLis3::FIELD_STRENGTHS,
                            new PoolEntry<float>({1.02, 0.56, -0.78}, true));
   return returnvalue::OK;
 }

dummies/MgmLIS3MDLDummy.h

@@ -2,8 +2,7 @@
 #define DUMMIES_MGMLIS3MDLDUMMY_H_
 
 #include <fsfw/devicehandlers/DeviceHandlerBase.h>
-
-#include "fsfw_hal/devicehandlers/devicedefinitions/MgmLIS3HandlerDefs.h"
+#include <fsfw_hal/devicehandlers/devicedefinitions/mgmLis3Helpers.h>
 
 class MgmLIS3MDLDummy : public DeviceHandlerBase {
  public:
@@ -17,7 +16,7 @@ class MgmLIS3MDLDummy : public DeviceHandlerBase {
   virtual ~MgmLIS3MDLDummy();
 
  protected:
-  MGMLIS3MDL::MgmPrimaryDataset dataset;
+  mgmLis3::MgmPrimaryDataset dataset;
   void doStartUp() override;
   void doShutDown() override;
   ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t *id) override;

dummies/MgmRm3100Dummy.cpp

@@ -36,7 +36,7 @@ uint32_t MgmRm3100Dummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) {
 
 ReturnValue_t MgmRm3100Dummy::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
                                                       LocalDataPoolManager& poolManager) {
-  localDataPoolMap.emplace(RM3100::FIELD_STRENGTHS,
+  localDataPoolMap.emplace(mgmRm3100::FIELD_STRENGTHS,
                            new PoolEntry<float>({0.87, -0.95, 0.11}, true));
   return returnvalue::OK;
 }

dummies/MgmRm3100Dummy.h

@@ -1,8 +1,9 @@
 #ifndef DUMMIES_MGMRM3100DUMMY_H_
 #define DUMMIES_MGMRM3100DUMMY_H_
 
+#include <fsfw_hal/devicehandlers/devicedefinitions/mgmRm3100Helpers.h>
+
 #include "fsfw/devicehandlers/DeviceHandlerBase.h"
-#include "fsfw_hal/devicehandlers/devicedefinitions/MgmRM3100HandlerDefs.h"
 
 class MgmRm3100Dummy : public DeviceHandlerBase {
  public:
@@ -10,7 +11,7 @@ class MgmRm3100Dummy : public DeviceHandlerBase {
   virtual ~MgmRm3100Dummy();
 
  protected:
-  RM3100::Rm3100PrimaryDataset dataset;
+  mgmRm3100::Rm3100PrimaryDataset dataset;
   void doStartUp() override;
   void doShutDown() override;
   ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t *id) override;

dummies/PduDummy.cpp

@@ -3,7 +3,8 @@
 #include <mission/devices/devicedefinitions/GomspaceDefinitions.h>
 
 PduDummy::PduDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
-    : DeviceHandlerBase(objectId, comif, comCookie) {}
+    : DeviceHandlerBase(objectId, comif, comCookie),
+      coreHk(this, static_cast<uint32_t>(P60System::SetIds::CORE)) {}
 
 PduDummy::~PduDummy() {}
 
@@ -38,5 +39,7 @@ uint32_t PduDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return
 ReturnValue_t PduDummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                                 LocalDataPoolManager &poolManager) {
   localDataPoolMap.emplace(PDU::pool::PDU_TEMPERATURE, new PoolEntry<float>({0}));
+  localDataPoolMap.emplace(PDU::pool::PDU_VOLTAGES, &pduVoltages);
+  localDataPoolMap.emplace(PDU::pool::PDU_CURRENTS, &pduCurrents);
   return returnvalue::OK;
 }

dummies/PduDummy.h

@@ -3,6 +3,8 @@
 
 #include <fsfw/devicehandlers/DeviceHandlerBase.h>
 
+#include "mission/devices/devicedefinitions/GomspaceDefinitions.h"
+
 class PduDummy : public DeviceHandlerBase {
  public:
   static const DeviceCommandId_t SIMPLE_COMMAND = 1;
@@ -15,6 +17,10 @@ class PduDummy : public DeviceHandlerBase {
   virtual ~PduDummy();
 
  protected:
+  PDU::PduCoreHk coreHk;
+  PoolEntry<int16_t> pduVoltages = PoolEntry<int16_t>(9);
+  PoolEntry<int16_t> pduCurrents = PoolEntry<int16_t>(9);
+
   void doStartUp() override;
   void doShutDown() override;
   ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t *id) override;

dummies/RwDummy.cpp

@@ -41,7 +41,7 @@ ReturnValue_t RwDummy::initializeLocalDataPool(localpool::DataPool &localDataPoo
 
   localDataPoolMap.emplace(rws::CURR_SPEED, new PoolEntry<int32_t>({0}));
   localDataPoolMap.emplace(rws::REFERENCE_SPEED, new PoolEntry<int32_t>({0}));
-  localDataPoolMap.emplace(rws::STATE, new PoolEntry<uint8_t>({0}));
+  localDataPoolMap.emplace(rws::STATE, new PoolEntry<uint8_t>({1}, true));
   localDataPoolMap.emplace(rws::CLC_MODE, new PoolEntry<uint8_t>({0}));
 
   localDataPoolMap.emplace(rws::LAST_RESET_STATUS, new PoolEntry<uint8_t>({0}));

dummies/SusDummy.cpp

@@ -35,9 +35,10 @@ uint32_t SusDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return
 
 ReturnValue_t SusDummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                                 LocalDataPoolManager &poolManager) {
-  localDataPoolMap.emplace(SUS::SusPoolIds::TEMPERATURE_C, new PoolEntry<float>({0}, 1, true));
-  localDataPoolMap.emplace(SUS::SusPoolIds::CHANNEL_VEC,
-                           new PoolEntry<uint16_t>({0, 0, 0, 0, 0, 0}, true));
+  localDataPoolMap.emplace(susMax1227::SusPoolIds::TEMPERATURE_C,
+                           new PoolEntry<float>({0}, 1, true));
+  localDataPoolMap.emplace(susMax1227::SusPoolIds::CHANNEL_VEC,
+                           new PoolEntry<uint16_t>({2603, 781, 2760, 2048, 4056, 0}, true));
 
   return returnvalue::OK;
 }

dummies/SusDummy.h

@@ -2,8 +2,7 @@
 #define DUMMIES_SUSDUMMY_H_
 
 #include <fsfw/devicehandlers/DeviceHandlerBase.h>
-
-#include "mission/devices/devicedefinitions/SusDefinitions.h"
+#include <mission/devices/devicedefinitions/susMax1227Helpers.h>
 
 class SusDummy : public DeviceHandlerBase {
  public:
@@ -17,7 +16,7 @@ class SusDummy : public DeviceHandlerBase {
   virtual ~SusDummy();
 
  protected:
-  SUS::SusDataset susSet;
+  susMax1227::SusDataset susSet;
   void doStartUp() override;
   void doShutDown() override;
   ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t *id) override;

dummies/helpers.cpp

@@ -5,6 +5,7 @@
 #include <dummies/ComCookieDummy.h>
 #include <dummies/ComIFDummy.h>
 #include <dummies/CoreControllerDummy.h>
+#include <dummies/ExecutableComIfDummy.h>
 #include <dummies/GpsCtrlDummy.h>
 #include <dummies/GpsDhbDummy.h>
 #include <dummies/GyroAdisDummy.h>
@@ -45,7 +46,7 @@ void dummy::createDummies(DummyCfg cfg, PowerSwitchIF& pwrSwitcher, GpioIF* gpio
     new CoreControllerDummy(objects::CORE_CONTROLLER);
   }
   if (cfg.addRtdComIFDummy) {
-    new ComIFDummy(objects::SPI_RTD_COM_IF);
+    new ExecutableComIfDummy(objects::SPI_RTD_COM_IF);
   }
   std::array<object_id_t, 4> rwIds = {objects::RW1, objects::RW2, objects::RW3, objects::RW4};
   std::array<DeviceHandlerBase*, 4> rws;

generators/.gitignore

@@ -1,2 +1,4 @@
 .~lock*
 /venv
+/.idea/*
+!/.idea/runConfigurations

generators/bsp_hosted_events.csv

@@ -84,9 +84,13 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 10800;0x2a30;STORE_ERROR;LOW;No description;fsfw/src/fsfw/cfdp/handler/defs.h
 10801;0x2a31;MSG_QUEUE_ERROR;LOW;No description;fsfw/src/fsfw/cfdp/handler/defs.h
 10802;0x2a32;SERIALIZATION_ERROR;LOW;No description;fsfw/src/fsfw/cfdp/handler/defs.h
+10803;0x2a33;FILESTORE_ERROR;LOW;No description;fsfw/src/fsfw/cfdp/handler/defs.h
+10804;0x2a34;FILENAME_TOO_LARGE_ERROR;LOW;P1: Transaction step ID, P2: 0 for source file name, 1 for dest file name;fsfw/src/fsfw/cfdp/handler/defs.h
 11200;0x2bc0;SAFE_RATE_VIOLATION;MEDIUM;No description;mission/acsDefs.h
 11201;0x2bc1;SAFE_RATE_RECOVERY;MEDIUM;No description;mission/acsDefs.h
 11202;0x2bc2;MULTIPLE_RW_INVALID;HIGH;No description;mission/acsDefs.h
+11203;0x2bc3;MEKF_INVALID_INFO;INFO;No description;mission/acsDefs.h
+11204;0x2bc4;MEKF_INVALID_MODE_VIOLATION;HIGH;No description;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;No description;mission/devices/devicedefinitions/powerDefinitions.h
@@ -145,8 +149,11 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 12404;0x3074;BIT_LOCK_PDEC;INFO;Bit lock detected (data valid);linux/ipcore/PdecHandler.h
 12405;0x3075;LOST_CARRIER_LOCK_PDEC;INFO;Lost carrier lock;linux/ipcore/PdecHandler.h
 12406;0x3076;LOST_BIT_LOCK_PDEC;INFO;Lost bit lock;linux/ipcore/PdecHandler.h
-12407;0x3077;POLL_SYSCALL_ERROR_PDEC;MEDIUM;No description;linux/ipcore/PdecHandler.h
-12408;0x3078;WRITE_SYSCALL_ERROR_PDEC;MEDIUM;No description;linux/ipcore/PdecHandler.h
+12407;0x3077;TOO_MANY_IRQS;MEDIUM;Too many IRQs over the time window of one second. P1: Allowed TCs;linux/ipcore/PdecHandler.h
+12408;0x3078;POLL_SYSCALL_ERROR_PDEC;MEDIUM;No description;linux/ipcore/PdecHandler.h
+12409;0x3079;WRITE_SYSCALL_ERROR_PDEC;HIGH;No description;linux/ipcore/PdecHandler.h
+12410;0x307a;PDEC_RESET_FAILED;HIGH;Failed to pull PDEC reset to low;linux/ipcore/PdecHandler.h
+12411;0x307b;OPEN_IRQ_FILE_FAILED;HIGH;Failed to open the IRQ uio file;linux/ipcore/PdecHandler.h
 12500;0x30d4;IMAGE_UPLOAD_FAILED;LOW;Image upload failed;linux/devices/startracker/StrHelper.h
 12501;0x30d5;IMAGE_DOWNLOAD_FAILED;LOW;Image download failed;linux/devices/startracker/StrHelper.h
 12502;0x30d6;IMAGE_UPLOAD_SUCCESSFUL;LOW;Uploading image to star tracker was successfulop;linux/devices/startracker/StrHelper.h
@@ -256,3 +263,6 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 14104;0x3718;OBC_OVERHEATING;HIGH;No description;mission/controller/ThermalController.h
 14105;0x3719;HPA_OVERHEATING;HIGH;No description;mission/controller/ThermalController.h
 14106;0x371a;PLPCDU_OVERHEATING;HIGH;No description;mission/controller/ThermalController.h
+14201;0x3779;TX_TIMER_EXPIRED;INFO;The transmit timer to protect the Syrlinks expired P1: The current timer value;mission/system/objects/ComSubsystem.h
+14202;0x377a;BIT_LOCK_TX_ON;INFO;Transmitter will be turned on due to detection of bitlock;mission/system/objects/ComSubsystem.h
+14300;0x37dc;POSSIBLE_FILE_CORRUPTION;LOW;P1: Result code of TM packet parser. P2: Timestamp of possibly corrupt file as a unix timestamp.;mission/tmtc/PersistentTmStore.h

generators/bsp_hosted_objects.csv

@@ -30,6 +30,7 @@
 0x44120350;RW4
 0x44130001;STAR_TRACKER
 0x44130045;GPS_CONTROLLER
+0x44140013;IMTQ_POLLING
 0x44140014;IMTQ_HANDLER
 0x442000A1;PCDU_HANDLER
 0x44250000;P60DOCK_HANDLER
@@ -76,8 +77,11 @@
 0x49000001;ARDUINO_COM_IF
 0x49000002;DUMMY_COM_IF
 0x49010006;SCEX_UART_READER
-0x49020006;SPI_RTD_COM_IF
 0x49030003;UART_COM_IF
+0x49060004;ACS_BOARD_POLLING_TASK
+0x49060005;RW_POLLING_TASK
+0x49060006;SPI_RTD_COM_IF
+0x49060007;SUS_POLLING_TASK
 0x50000100;CCSDS_PACKET_DISTRIBUTOR
 0x50000200;PUS_PACKET_DISTRIBUTOR
 0x50000300;TCP_TMTC_SERVER
@@ -103,6 +107,7 @@
 0x53000008;PUS_SERVICE_8_FUNCTION_MGMT
 0x53000009;PUS_SERVICE_9_TIME_MGMT
 0x53000011;PUS_SERVICE_11_TC_SCHEDULER
+0x53000015;PUS_SERVICE_15_TM_STORAGE
 0x53000017;PUS_SERVICE_17_TEST
 0x53000020;PUS_SERVICE_20_PARAMETERS
 0x53000200;PUS_SERVICE_200_MODE_MGMT
@@ -141,6 +146,11 @@
 0x73010002;PL_SUBSYSTEM
 0x73010003;TCS_SUBSYSTEM
 0x73010004;COM_SUBSYSTEM
+0x73020001;MISC_TM_STORE
+0x73020002;OK_TM_STORE
+0x73020003;NOT_OK_TM_STORE
+0x73020004;HK_TM_STORE
+0x73030000;CFDP_TM_STORE
 0x73500000;CCSDS_IP_CORE_BRIDGE
 0x90000003;THERMAL_TEMP_INSERTER
 0xCAFECAFE;DUMMY_INTERFACE

generators/bsp_hosted_returnvalues.csv

@@ -2,7 +2,16 @@ 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
 0x63a0;NVMB_KeyNotExists;Specified key does not exist in json file;160;NVM_PARAM_BASE;mission/memory/NVMParameterBase.h
-0x6300;NVMB_Busy;No description;0;NVM_PARAM_BASE;mission/system/objects/Stack5VHandler.h
+0x5100;IMTQ_InvalidCommandCode;No description;0;IMTQ_HANDLER;mission/devices/devicedefinitions/imtqHelpers.h
+0x5101;IMTQ_MgmMeasurementLowLevelError;No description;1;IMTQ_HANDLER;mission/devices/devicedefinitions/imtqHelpers.h
+0x5102;IMTQ_ActuateCmdLowLevelError;No description;2;IMTQ_HANDLER;mission/devices/devicedefinitions/imtqHelpers.h
+0x5103;IMTQ_ParameterMissing;No description;3;IMTQ_HANDLER;mission/devices/devicedefinitions/imtqHelpers.h
+0x5104;IMTQ_ParameterInvalid;No description;4;IMTQ_HANDLER;mission/devices/devicedefinitions/imtqHelpers.h
+0x5105;IMTQ_CcUnavailable;No description;5;IMTQ_HANDLER;mission/devices/devicedefinitions/imtqHelpers.h
+0x5106;IMTQ_InternalProcessingError;No description;6;IMTQ_HANDLER;mission/devices/devicedefinitions/imtqHelpers.h
+0x5107;IMTQ_RejectedWithoutReason;No description;7;IMTQ_HANDLER;mission/devices/devicedefinitions/imtqHelpers.h
+0x5108;IMTQ_CmdErrUnknown;No description;8;IMTQ_HANDLER;mission/devices/devicedefinitions/imtqHelpers.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/devicedefinitions/imtqHelpers.h
 0x52b0;RWHA_SpiWriteFailure;No description;176;RW_HANDLER;mission/devices/devicedefinitions/rwHelpers.h
 0x52b1;RWHA_SpiReadFailure;Used by the spi send function to tell a failing read call;177;RW_HANDLER;mission/devices/devicedefinitions/rwHelpers.h
 0x52b2;RWHA_MissingStartSign;Can be used by the HDLC decoding mechanism to inform about a missing start sign 0x7E;178;RW_HANDLER;mission/devices/devicedefinitions/rwHelpers.h
@@ -11,21 +20,14 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x52b5;RWHA_NoReply;Reaction wheel only responds with empty frames.;181;RW_HANDLER;mission/devices/devicedefinitions/rwHelpers.h
 0x52b6;RWHA_NoStartMarker;Expected a start marker as first byte;182;RW_HANDLER;mission/devices/devicedefinitions/rwHelpers.h
 0x52b7;RWHA_SpiReadTimeout;Timeout when reading reply;183;RW_HANDLER;mission/devices/devicedefinitions/rwHelpers.h
-0x58a0;SUSS_ErrorUnlockMutex;No description;160;SUS_HANDLER;mission/devices/SusHandler.h
-0x58a1;SUSS_ErrorLockMutex;No description;161;SUS_HANDLER;mission/devices/SusHandler.h
-0x66a0;SADPL_CommandNotSupported;No description;160;SA_DEPL_HANDLER;mission/devices/SolarArrayDeploymentHandler.h
-0x66a1;SADPL_DeploymentAlreadyExecuting;No description;161;SA_DEPL_HANDLER;mission/devices/SolarArrayDeploymentHandler.h
-0x66a2;SADPL_MainSwitchTimeoutFailure;No description;162;SA_DEPL_HANDLER;mission/devices/SolarArrayDeploymentHandler.h
-0x66a3;SADPL_SwitchingDeplSa1Failed;No description;163;SA_DEPL_HANDLER;mission/devices/SolarArrayDeploymentHandler.h
-0x66a4;SADPL_SwitchingDeplSa2Failed;No description;164;SA_DEPL_HANDLER;mission/devices/SolarArrayDeploymentHandler.h
-0x51a0;IMTQ_InvalidSpeed;Action Message with invalid speed was received. Valid speeds must be in the range of [-65000, 1000] or [1000, 65000];160;IMTQ_HANDLER;mission/devices/RwHandler.h
-0x51a1;IMTQ_InvalidRampTime;Action Message with invalid ramp time was received.;161;IMTQ_HANDLER;mission/devices/RwHandler.h
-0x51a2;IMTQ_SetSpeedCommandInvalidLength;Received set speed command has invalid length. Should be 6.;162;IMTQ_HANDLER;mission/devices/RwHandler.h
-0x51a3;IMTQ_ExecutionFailed;Command execution failed;163;IMTQ_HANDLER;mission/devices/RwHandler.h
-0x51a4;IMTQ_CrcError;Reaction wheel reply has invalid crc;164;IMTQ_HANDLER;mission/devices/RwHandler.h
-0x51a5;IMTQ_ValueNotRead;No description;165;IMTQ_HANDLER;mission/devices/RwHandler.h
-0x51a6;IMTQ_CmdErrUnknown;No description;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
+0x58a0;SUSS_ErrorUnlockMutex;No description;160;SUS_HANDLER;mission/devices/LegacySusHandler.h
+0x58a1;SUSS_ErrorLockMutex;No description;161;SUS_HANDLER;mission/devices/LegacySusHandler.h
+0x66a0;SADPL_InvalidSpeed;Action Message with invalid speed was received. Valid speeds must be in the range of [-65000, 1000] or [1000, 65000];160;SA_DEPL_HANDLER;mission/devices/RwHandler.h
+0x66a1;SADPL_InvalidRampTime;Action Message with invalid ramp time was received.;161;SA_DEPL_HANDLER;mission/devices/RwHandler.h
+0x66a2;SADPL_SetSpeedCommandInvalidLength;Received set speed command has invalid length. Should be 6.;162;SA_DEPL_HANDLER;mission/devices/RwHandler.h
+0x66a3;SADPL_ExecutionFailed;Command execution failed;163;SA_DEPL_HANDLER;mission/devices/RwHandler.h
+0x66a4;SADPL_CrcError;Reaction wheel reply has invalid crc;164;SA_DEPL_HANDLER;mission/devices/RwHandler.h
+0x66a5;SADPL_ValueNotRead;No description;165;SA_DEPL_HANDLER;mission/devices/RwHandler.h
 0x50a0;SYRLINKS_CrcFailure;No description;160;SYRLINKS_HANDLER;mission/devices/SyrlinksHandler.h
 0x50a1;SYRLINKS_UartFraminOrParityErrorAck;No description;161;SYRLINKS_HANDLER;mission/devices/SyrlinksHandler.h
 0x50a2;SYRLINKS_BadCharacterAck;No description;162;SYRLINKS_HANDLER;mission/devices/SyrlinksHandler.h
@@ -47,12 +49,17 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x4fa4;HEATER_MainSwitchSetTimeout;No description;164;HEATER_HANDLER;mission/devices/HeaterHandler.h
 0x4fa5;HEATER_CommandAlreadyWaiting;No description;165;HEATER_HANDLER;mission/devices/HeaterHandler.h
 0x60a0;CCSDS_CommandNotImplemented;Received action message with unknown action id;160;CCSDS_HANDLER;mission/tmtc/CcsdsIpCoreHandler.h
-0x6a01;ACSSAF_SafectrlMekfInputInvalid;No description;1;ACS_SAFE;mission/controller/acs/control/SafeCtrl.h
-0x6b01;ACSPTG_PtgctrlMekfInputInvalid;No description;1;ACS_PTG;mission/controller/acs/control/PtgCtrl.h
-0x6c01;ACSDTB_DetumbleNoSensordata;No description;1;ACS_DETUMBLE;mission/controller/acs/control/Detumble.h
-0x6901;ACSKAL_KalmanNoGyrMeas;No description;1;ACS_KALMAN;mission/controller/acs/MultiplicativeKalmanFilter.h
-0x6902;ACSKAL_KalmanNoModel;No description;2;ACS_KALMAN;mission/controller/acs/MultiplicativeKalmanFilter.h
-0x6903;ACSKAL_KalmanInversionFailed;No description;3;ACS_KALMAN;mission/controller/acs/MultiplicativeKalmanFilter.h
+0x6b01;ACSSAF_SafectrlMekfInputInvalid;No description;1;ACS_SAFE;mission/controller/acs/control/SafeCtrl.h
+0x6c01;ACSPTG_PtgctrlMekfInputInvalid;No description;1;ACS_PTG;mission/controller/acs/control/PtgCtrl.h
+0x6d01;ACSDTB_DetumbleNoSensordata;No description;1;ACS_DETUMBLE;mission/controller/acs/control/Detumble.h
+0x6a02;ACSMEKF_MekfUninitialized;No description;2;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
+0x6a03;ACSMEKF_MekfNoGyrData;No description;3;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
+0x6a04;ACSMEKF_MekfNoModelVectors;No description;4;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
+0x6a05;ACSMEKF_MekfNoSusMgmStrData;No description;5;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
+0x6a06;ACSMEKF_MekfCovarianceInversionFailed;No description;6;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
+0x6a07;ACSMEKF_MekfInitialized;No description;7;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
+0x6a08;ACSMEKF_MekfRunning;No description;8;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
+0x6900;ACSCTRL_FileDeletionFailed;No description;0;ACS_CTRL;mission/controller/AcsController.h
 0x4500;HSPI_OpeningFileFailed;No description;0;HAL_SPI;fsfw/src/fsfw_hal/linux/spi/SpiComIF.h
 0x4501;HSPI_FullDuplexTransferFailed;No description;1;HAL_SPI;fsfw/src/fsfw_hal/linux/spi/SpiComIF.h
 0x4502;HSPI_HalfDuplexTransferFailed;No description;2;HAL_SPI;fsfw/src/fsfw_hal/linux/spi/SpiComIF.h

generators/bsp_q7s_events.csv

@@ -84,9 +84,13 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 10800;0x2a30;STORE_ERROR;LOW;No description;fsfw/src/fsfw/cfdp/handler/defs.h
 10801;0x2a31;MSG_QUEUE_ERROR;LOW;No description;fsfw/src/fsfw/cfdp/handler/defs.h
 10802;0x2a32;SERIALIZATION_ERROR;LOW;No description;fsfw/src/fsfw/cfdp/handler/defs.h
+10803;0x2a33;FILESTORE_ERROR;LOW;No description;fsfw/src/fsfw/cfdp/handler/defs.h
+10804;0x2a34;FILENAME_TOO_LARGE_ERROR;LOW;P1: Transaction step ID, P2: 0 for source file name, 1 for dest file name;fsfw/src/fsfw/cfdp/handler/defs.h
 11200;0x2bc0;SAFE_RATE_VIOLATION;MEDIUM;No description;mission/acsDefs.h
 11201;0x2bc1;SAFE_RATE_RECOVERY;MEDIUM;No description;mission/acsDefs.h
 11202;0x2bc2;MULTIPLE_RW_INVALID;HIGH;No description;mission/acsDefs.h
+11203;0x2bc3;MEKF_INVALID_INFO;INFO;No description;mission/acsDefs.h
+11204;0x2bc4;MEKF_INVALID_MODE_VIOLATION;HIGH;No description;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;No description;mission/devices/devicedefinitions/powerDefinitions.h
@@ -145,8 +149,11 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 12404;0x3074;BIT_LOCK_PDEC;INFO;Bit lock detected (data valid);linux/ipcore/PdecHandler.h
 12405;0x3075;LOST_CARRIER_LOCK_PDEC;INFO;Lost carrier lock;linux/ipcore/PdecHandler.h
 12406;0x3076;LOST_BIT_LOCK_PDEC;INFO;Lost bit lock;linux/ipcore/PdecHandler.h
-12407;0x3077;POLL_SYSCALL_ERROR_PDEC;MEDIUM;No description;linux/ipcore/PdecHandler.h
-12408;0x3078;WRITE_SYSCALL_ERROR_PDEC;MEDIUM;No description;linux/ipcore/PdecHandler.h
+12407;0x3077;TOO_MANY_IRQS;MEDIUM;Too many IRQs over the time window of one second. P1: Allowed TCs;linux/ipcore/PdecHandler.h
+12408;0x3078;POLL_SYSCALL_ERROR_PDEC;MEDIUM;No description;linux/ipcore/PdecHandler.h
+12409;0x3079;WRITE_SYSCALL_ERROR_PDEC;HIGH;No description;linux/ipcore/PdecHandler.h
+12410;0x307a;PDEC_RESET_FAILED;HIGH;Failed to pull PDEC reset to low;linux/ipcore/PdecHandler.h
+12411;0x307b;OPEN_IRQ_FILE_FAILED;HIGH;Failed to open the IRQ uio file;linux/ipcore/PdecHandler.h
 12500;0x30d4;IMAGE_UPLOAD_FAILED;LOW;Image upload failed;linux/devices/startracker/StrHelper.h
 12501;0x30d5;IMAGE_DOWNLOAD_FAILED;LOW;Image download failed;linux/devices/startracker/StrHelper.h
 12502;0x30d6;IMAGE_UPLOAD_SUCCESSFUL;LOW;Uploading image to star tracker was successfulop;linux/devices/startracker/StrHelper.h
@@ -256,3 +263,6 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 14104;0x3718;OBC_OVERHEATING;HIGH;No description;mission/controller/ThermalController.h
 14105;0x3719;HPA_OVERHEATING;HIGH;No description;mission/controller/ThermalController.h
 14106;0x371a;PLPCDU_OVERHEATING;HIGH;No description;mission/controller/ThermalController.h
+14201;0x3779;TX_TIMER_EXPIRED;INFO;The transmit timer to protect the Syrlinks expired P1: The current timer value;mission/system/objects/ComSubsystem.h
+14202;0x377a;BIT_LOCK_TX_ON;INFO;Transmitter will be turned on due to detection of bitlock;mission/system/objects/ComSubsystem.h
+14300;0x37dc;POSSIBLE_FILE_CORRUPTION;LOW;P1: Result code of TM packet parser. P2: Timestamp of possibly corrupt file as a unix timestamp.;mission/tmtc/PersistentTmStore.h

generators/bsp_q7s_objects.csv

@@ -29,6 +29,7 @@
 0x44120350;RW4
 0x44130001;STAR_TRACKER
 0x44130045;GPS_CONTROLLER
+0x44140013;IMTQ_POLLING
 0x44140014;IMTQ_HANDLER
 0x442000A1;PCDU_HANDLER
 0x44250000;P60DOCK_HANDLER
@@ -76,11 +77,13 @@
 0x49010005;GPIO_IF
 0x49010006;SCEX_UART_READER
 0x49020004;SPI_MAIN_COM_IF
-0x49020005;RW_POLLING_TASK
-0x49020006;SPI_RTD_COM_IF
 0x49030003;UART_COM_IF
 0x49040002;I2C_COM_IF
 0x49050001;CSP_COM_IF
+0x49060004;ACS_BOARD_POLLING_TASK
+0x49060005;RW_POLLING_TASK
+0x49060006;SPI_RTD_COM_IF
+0x49060007;SUS_POLLING_TASK
 0x50000100;CCSDS_PACKET_DISTRIBUTOR
 0x50000200;PUS_PACKET_DISTRIBUTOR
 0x50000300;TCP_TMTC_SERVER
@@ -101,6 +104,7 @@
 0x53000008;PUS_SERVICE_8_FUNCTION_MGMT
 0x53000009;PUS_SERVICE_9_TIME_MGMT
 0x53000011;PUS_SERVICE_11_TC_SCHEDULER
+0x53000015;PUS_SERVICE_15_TM_STORAGE
 0x53000017;PUS_SERVICE_17_TEST
 0x53000020;PUS_SERVICE_20_PARAMETERS
 0x53000200;PUS_SERVICE_200_MODE_MGMT
@@ -147,6 +151,11 @@
 0x73010002;PL_SUBSYSTEM
 0x73010003;TCS_SUBSYSTEM
 0x73010004;COM_SUBSYSTEM
+0x73020001;MISC_TM_STORE
+0x73020002;OK_TM_STORE
+0x73020003;NOT_OK_TM_STORE
+0x73020004;HK_TM_STORE
+0x73030000;CFDP_TM_STORE
 0x73500000;CCSDS_IP_CORE_BRIDGE
 0x90000003;THERMAL_TEMP_INSERTER
 0xFFFFFFFF;NO_OBJECT

generators/bsp_q7s_returnvalues.csv

@@ -2,7 +2,16 @@ 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
 0x63a0;NVMB_KeyNotExists;Specified key does not exist in json file;160;NVM_PARAM_BASE;mission/memory/NVMParameterBase.h
-0x6300;NVMB_Busy;No description;0;NVM_PARAM_BASE;mission/system/objects/Stack5VHandler.h
+0x5100;IMTQ_InvalidCommandCode;No description;0;IMTQ_HANDLER;mission/devices/devicedefinitions/imtqHelpers.h
+0x5101;IMTQ_MgmMeasurementLowLevelError;No description;1;IMTQ_HANDLER;mission/devices/devicedefinitions/imtqHelpers.h
+0x5102;IMTQ_ActuateCmdLowLevelError;No description;2;IMTQ_HANDLER;mission/devices/devicedefinitions/imtqHelpers.h
+0x5103;IMTQ_ParameterMissing;No description;3;IMTQ_HANDLER;mission/devices/devicedefinitions/imtqHelpers.h
+0x5104;IMTQ_ParameterInvalid;No description;4;IMTQ_HANDLER;mission/devices/devicedefinitions/imtqHelpers.h
+0x5105;IMTQ_CcUnavailable;No description;5;IMTQ_HANDLER;mission/devices/devicedefinitions/imtqHelpers.h
+0x5106;IMTQ_InternalProcessingError;No description;6;IMTQ_HANDLER;mission/devices/devicedefinitions/imtqHelpers.h
+0x5107;IMTQ_RejectedWithoutReason;No description;7;IMTQ_HANDLER;mission/devices/devicedefinitions/imtqHelpers.h
+0x5108;IMTQ_CmdErrUnknown;No description;8;IMTQ_HANDLER;mission/devices/devicedefinitions/imtqHelpers.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/devicedefinitions/imtqHelpers.h
 0x52b0;RWHA_SpiWriteFailure;No description;176;RW_HANDLER;mission/devices/devicedefinitions/rwHelpers.h
 0x52b1;RWHA_SpiReadFailure;Used by the spi send function to tell a failing read call;177;RW_HANDLER;mission/devices/devicedefinitions/rwHelpers.h
 0x52b2;RWHA_MissingStartSign;Can be used by the HDLC decoding mechanism to inform about a missing start sign 0x7E;178;RW_HANDLER;mission/devices/devicedefinitions/rwHelpers.h
@@ -11,21 +20,14 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x52b5;RWHA_NoReply;Reaction wheel only responds with empty frames.;181;RW_HANDLER;mission/devices/devicedefinitions/rwHelpers.h
 0x52b6;RWHA_NoStartMarker;Expected a start marker as first byte;182;RW_HANDLER;mission/devices/devicedefinitions/rwHelpers.h
 0x52b7;RWHA_SpiReadTimeout;Timeout when reading reply;183;RW_HANDLER;mission/devices/devicedefinitions/rwHelpers.h
-0x58a0;SUSS_ErrorUnlockMutex;No description;160;SUS_HANDLER;mission/devices/SusHandler.h
-0x58a1;SUSS_ErrorLockMutex;No description;161;SUS_HANDLER;mission/devices/SusHandler.h
-0x66a0;SADPL_CommandNotSupported;No description;160;SA_DEPL_HANDLER;mission/devices/SolarArrayDeploymentHandler.h
-0x66a1;SADPL_DeploymentAlreadyExecuting;No description;161;SA_DEPL_HANDLER;mission/devices/SolarArrayDeploymentHandler.h
-0x66a2;SADPL_MainSwitchTimeoutFailure;No description;162;SA_DEPL_HANDLER;mission/devices/SolarArrayDeploymentHandler.h
-0x66a3;SADPL_SwitchingDeplSa1Failed;No description;163;SA_DEPL_HANDLER;mission/devices/SolarArrayDeploymentHandler.h
-0x66a4;SADPL_SwitchingDeplSa2Failed;No description;164;SA_DEPL_HANDLER;mission/devices/SolarArrayDeploymentHandler.h
-0x51a0;IMTQ_InvalidSpeed;Action Message with invalid speed was received. Valid speeds must be in the range of [-65000, 1000] or [1000, 65000];160;IMTQ_HANDLER;mission/devices/RwHandler.h
-0x51a1;IMTQ_InvalidRampTime;Action Message with invalid ramp time was received.;161;IMTQ_HANDLER;mission/devices/RwHandler.h
-0x51a2;IMTQ_SetSpeedCommandInvalidLength;Received set speed command has invalid length. Should be 6.;162;IMTQ_HANDLER;mission/devices/RwHandler.h
-0x51a3;IMTQ_ExecutionFailed;Command execution failed;163;IMTQ_HANDLER;mission/devices/RwHandler.h
-0x51a4;IMTQ_CrcError;Reaction wheel reply has invalid crc;164;IMTQ_HANDLER;mission/devices/RwHandler.h
-0x51a5;IMTQ_ValueNotRead;No description;165;IMTQ_HANDLER;mission/devices/RwHandler.h
-0x51a6;IMTQ_CmdErrUnknown;No description;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
+0x58a0;SUSS_ErrorUnlockMutex;No description;160;SUS_HANDLER;mission/devices/LegacySusHandler.h
+0x58a1;SUSS_ErrorLockMutex;No description;161;SUS_HANDLER;mission/devices/LegacySusHandler.h
+0x66a0;SADPL_InvalidSpeed;Action Message with invalid speed was received. Valid speeds must be in the range of [-65000, 1000] or [1000, 65000];160;SA_DEPL_HANDLER;mission/devices/RwHandler.h
+0x66a1;SADPL_InvalidRampTime;Action Message with invalid ramp time was received.;161;SA_DEPL_HANDLER;mission/devices/RwHandler.h
+0x66a2;SADPL_SetSpeedCommandInvalidLength;Received set speed command has invalid length. Should be 6.;162;SA_DEPL_HANDLER;mission/devices/RwHandler.h
+0x66a3;SADPL_ExecutionFailed;Command execution failed;163;SA_DEPL_HANDLER;mission/devices/RwHandler.h
+0x66a4;SADPL_CrcError;Reaction wheel reply has invalid crc;164;SA_DEPL_HANDLER;mission/devices/RwHandler.h
+0x66a5;SADPL_ValueNotRead;No description;165;SA_DEPL_HANDLER;mission/devices/RwHandler.h
 0x50a0;SYRLINKS_CrcFailure;No description;160;SYRLINKS_HANDLER;mission/devices/SyrlinksHandler.h
 0x50a1;SYRLINKS_UartFraminOrParityErrorAck;No description;161;SYRLINKS_HANDLER;mission/devices/SyrlinksHandler.h
 0x50a2;SYRLINKS_BadCharacterAck;No description;162;SYRLINKS_HANDLER;mission/devices/SyrlinksHandler.h
@@ -47,12 +49,17 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x4fa4;HEATER_MainSwitchSetTimeout;No description;164;HEATER_HANDLER;mission/devices/HeaterHandler.h
 0x4fa5;HEATER_CommandAlreadyWaiting;No description;165;HEATER_HANDLER;mission/devices/HeaterHandler.h
 0x60a0;CCSDS_CommandNotImplemented;Received action message with unknown action id;160;CCSDS_HANDLER;mission/tmtc/CcsdsIpCoreHandler.h
-0x6a01;ACSSAF_SafectrlMekfInputInvalid;No description;1;ACS_SAFE;mission/controller/acs/control/SafeCtrl.h
-0x6b01;ACSPTG_PtgctrlMekfInputInvalid;No description;1;ACS_PTG;mission/controller/acs/control/PtgCtrl.h
-0x6c01;ACSDTB_DetumbleNoSensordata;No description;1;ACS_DETUMBLE;mission/controller/acs/control/Detumble.h
-0x6901;ACSKAL_KalmanNoGyrMeas;No description;1;ACS_KALMAN;mission/controller/acs/MultiplicativeKalmanFilter.h
-0x6902;ACSKAL_KalmanNoModel;No description;2;ACS_KALMAN;mission/controller/acs/MultiplicativeKalmanFilter.h
-0x6903;ACSKAL_KalmanInversionFailed;No description;3;ACS_KALMAN;mission/controller/acs/MultiplicativeKalmanFilter.h
+0x6b01;ACSSAF_SafectrlMekfInputInvalid;No description;1;ACS_SAFE;mission/controller/acs/control/SafeCtrl.h
+0x6c01;ACSPTG_PtgctrlMekfInputInvalid;No description;1;ACS_PTG;mission/controller/acs/control/PtgCtrl.h
+0x6d01;ACSDTB_DetumbleNoSensordata;No description;1;ACS_DETUMBLE;mission/controller/acs/control/Detumble.h
+0x6a02;ACSMEKF_MekfUninitialized;No description;2;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
+0x6a03;ACSMEKF_MekfNoGyrData;No description;3;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
+0x6a04;ACSMEKF_MekfNoModelVectors;No description;4;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
+0x6a05;ACSMEKF_MekfNoSusMgmStrData;No description;5;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
+0x6a06;ACSMEKF_MekfCovarianceInversionFailed;No description;6;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
+0x6a07;ACSMEKF_MekfInitialized;No description;7;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
+0x6a08;ACSMEKF_MekfRunning;No description;8;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
+0x6900;ACSCTRL_FileDeletionFailed;No description;0;ACS_CTRL;mission/controller/AcsController.h
 0x4500;HSPI_OpeningFileFailed;No description;0;HAL_SPI;fsfw/src/fsfw_hal/linux/spi/SpiComIF.h
 0x4501;HSPI_FullDuplexTransferFailed;No description;1;HAL_SPI;fsfw/src/fsfw_hal/linux/spi/SpiComIF.h
 0x4502;HSPI_HalfDuplexTransferFailed;No description;2;HAL_SPI;fsfw/src/fsfw_hal/linux/spi/SpiComIF.h
@@ -467,19 +474,20 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x1d03;ATC_IllegalApplicationData;No description;3;ACCEPTS_TELECOMMANDS_IF;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h
 0x1d04;ATC_SendTmFailed;No description;4;ACCEPTS_TELECOMMANDS_IF;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h
 0x1d05;ATC_Timeout;No description;5;ACCEPTS_TELECOMMANDS_IF;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h
-0x7000;SCBU_KeyNotFound;No description;0;SCRATCH_BUFFER;bsp_q7s/memory/scratchApi.h
+0x7100;SCBU_KeyNotFound;No description;0;SCRATCH_BUFFER;bsp_q7s/memory/scratchApi.h
+0x6f00;LPH_SdNotReady;No description;0;LOCAL_PARAM_HANDLER;bsp_q7s/memory/LocalParameterHandler.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
-0x6f00;SDMA_OpOngoing;No description;0;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
-0x6f01;SDMA_AlreadyOn;No description;1;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
-0x6f02;SDMA_AlreadyMounted;No description;2;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
-0x6f03;SDMA_AlreadyOff;No description;3;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
-0x6f0a;SDMA_StatusFileNexists;No description;10;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
-0x6f0b;SDMA_StatusFileFormatInvalid;No description;11;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
-0x6f0c;SDMA_MountError;No description;12;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
-0x6f0d;SDMA_UnmountError;No description;13;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
-0x6f0e;SDMA_SystemCallError;No description;14;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
-0x6f0f;SDMA_PopenCallError;No description;15;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
+0x6e00;SDMA_OpOngoing;No description;0;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
+0x6e01;SDMA_AlreadyOn;No description;1;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
+0x6e02;SDMA_AlreadyMounted;No description;2;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
+0x6e03;SDMA_AlreadyOff;No description;3;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
+0x6e0a;SDMA_StatusFileNexists;No description;10;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
+0x6e0b;SDMA_StatusFileFormatInvalid;No description;11;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
+0x6e0c;SDMA_MountError;No description;12;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
+0x6e0d;SDMA_UnmountError;No description;13;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
+0x6e0e;SDMA_SystemCallError;No description;14;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
+0x6e0f;SDMA_PopenCallError;No description;15;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
 0x65a0;PLMPHLP_FileClosedAccidentally;File accidentally close;160;PLOC_MPSOC_HELPER;linux/devices/ploc/PlocMPSoCHelper.h
 0x5ea0;PLMEMDUMP_MramAddressTooHigh;The capacity of the MRAM amounts to 512 kB. Thus the maximum address must not be higher than 0x7d000.;160;PLOC_MEMORY_DUMPER;linux/devices/ploc/PlocMemoryDumper.h
 0x5ea1;PLMEMDUMP_MramInvalidAddressCombination;The specified end address is lower than the start address;161;PLOC_MEMORY_DUMPER;linux/devices/ploc/PlocMemoryDumper.h
@@ -566,6 +574,7 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x53b6;STRH_StartrackerAlreadyBooted;Star tracker is already in firmware mode;182;STR_HANDLER;linux/devices/startracker/StarTrackerHandler.h
 0x53b7;STRH_StartrackerRunningFirmware;Star tracker is in firmware mode but must be in bootloader mode to execute this command;183;STR_HANDLER;linux/devices/startracker/StarTrackerHandler.h
 0x53b8;STRH_StartrackerRunningBootloader;Star tracker is in bootloader mode but must be in firmware mode to execute this command;184;STR_HANDLER;linux/devices/startracker/StarTrackerHandler.h
+0x5300;STRH_NoReplyAvailable;No description;0;STR_HANDLER;linux/devices/ImtqPollingTask.h
 0x5302;STRH_InvalidCrc;No description;2;STR_HANDLER;linux/devices/ScexHelper.h
 0x5aa0;PTME_UnknownVcId;No description;160;PTME;linux/ipcore/Ptme.h
 0x5fa0;PDEC_AbandonedCltuRetval;No description;160;PDEC_HANDLER;linux/ipcore/PdecHandler.h

generators/events/translateEvents.cpp

@@ -1,7 +1,7 @@
 /**
- * @brief    Auto-generated event translation file. Contains 257 translations.
+ * @brief    Auto-generated event translation file. Contains 267 translations.
  * @details
- * Generated on: 2023-02-21 00:24:44
+ * Generated on: 2023-03-01 18:34:32
  */
 #include "translateEvents.h"
 
@@ -90,9 +90,13 @@ const char *CHANGE_OF_SETUP_PARAMETER_STRING = "CHANGE_OF_SETUP_PARAMETER";
 const char *STORE_ERROR_STRING = "STORE_ERROR";
 const char *MSG_QUEUE_ERROR_STRING = "MSG_QUEUE_ERROR";
 const char *SERIALIZATION_ERROR_STRING = "SERIALIZATION_ERROR";
+const char *FILESTORE_ERROR_STRING = "FILESTORE_ERROR";
+const char *FILENAME_TOO_LARGE_ERROR_STRING = "FILENAME_TOO_LARGE_ERROR";
 const char *SAFE_RATE_VIOLATION_STRING = "SAFE_RATE_VIOLATION";
 const char *SAFE_RATE_RECOVERY_STRING = "SAFE_RATE_RECOVERY";
 const char *MULTIPLE_RW_INVALID_STRING = "MULTIPLE_RW_INVALID";
+const char *MEKF_INVALID_INFO_STRING = "MEKF_INVALID_INFO";
+const char *MEKF_INVALID_MODE_VIOLATION_STRING = "MEKF_INVALID_MODE_VIOLATION";
 const char *SWITCH_CMD_SENT_STRING = "SWITCH_CMD_SENT";
 const char *SWITCH_HAS_CHANGED_STRING = "SWITCH_HAS_CHANGED";
 const char *SWITCHING_Q7S_DENIED_STRING = "SWITCHING_Q7S_DENIED";
@@ -151,8 +155,11 @@ const char *CARRIER_LOCK_STRING = "CARRIER_LOCK";
 const char *BIT_LOCK_PDEC_STRING = "BIT_LOCK_PDEC";
 const char *LOST_CARRIER_LOCK_PDEC_STRING = "LOST_CARRIER_LOCK_PDEC";
 const char *LOST_BIT_LOCK_PDEC_STRING = "LOST_BIT_LOCK_PDEC";
+const char *TOO_MANY_IRQS_STRING = "TOO_MANY_IRQS";
 const char *POLL_SYSCALL_ERROR_PDEC_STRING = "POLL_SYSCALL_ERROR_PDEC";
 const char *WRITE_SYSCALL_ERROR_PDEC_STRING = "WRITE_SYSCALL_ERROR_PDEC";
+const char *PDEC_RESET_FAILED_STRING = "PDEC_RESET_FAILED";
+const char *OPEN_IRQ_FILE_FAILED_STRING = "OPEN_IRQ_FILE_FAILED";
 const char *IMAGE_UPLOAD_FAILED_STRING = "IMAGE_UPLOAD_FAILED";
 const char *IMAGE_DOWNLOAD_FAILED_STRING = "IMAGE_DOWNLOAD_FAILED";
 const char *IMAGE_UPLOAD_SUCCESSFUL_STRING = "IMAGE_UPLOAD_SUCCESSFUL";
@@ -257,6 +264,9 @@ const char *PLOC_OVERHEATING_STRING = "PLOC_OVERHEATING";
 const char *OBC_OVERHEATING_STRING = "OBC_OVERHEATING";
 const char *HPA_OVERHEATING_STRING = "HPA_OVERHEATING";
 const char *PLPCDU_OVERHEATING_STRING = "PLPCDU_OVERHEATING";
+const char *TX_TIMER_EXPIRED_STRING = "TX_TIMER_EXPIRED";
+const char *BIT_LOCK_TX_ON_STRING = "BIT_LOCK_TX_ON";
+const char *POSSIBLE_FILE_CORRUPTION_STRING = "POSSIBLE_FILE_CORRUPTION";
 
 const char *translateEvents(Event event) {
   switch ((event & 0xFFFF)) {
@@ -430,12 +440,20 @@ const char *translateEvents(Event event) {
       return MSG_QUEUE_ERROR_STRING;
     case (10802):
       return SERIALIZATION_ERROR_STRING;
+    case (10803):
+      return FILESTORE_ERROR_STRING;
+    case (10804):
+      return FILENAME_TOO_LARGE_ERROR_STRING;
     case (11200):
       return SAFE_RATE_VIOLATION_STRING;
     case (11201):
       return SAFE_RATE_RECOVERY_STRING;
     case (11202):
       return MULTIPLE_RW_INVALID_STRING;
+    case (11203):
+      return MEKF_INVALID_INFO_STRING;
+    case (11204):
+      return MEKF_INVALID_MODE_VIOLATION_STRING;
     case (11300):
       return SWITCH_CMD_SENT_STRING;
     case (11301):
@@ -553,9 +571,15 @@ const char *translateEvents(Event event) {
     case (12406):
       return LOST_BIT_LOCK_PDEC_STRING;
     case (12407):
-      return POLL_SYSCALL_ERROR_PDEC_STRING;
+      return TOO_MANY_IRQS_STRING;
     case (12408):
+      return POLL_SYSCALL_ERROR_PDEC_STRING;
+    case (12409):
       return WRITE_SYSCALL_ERROR_PDEC_STRING;
+    case (12410):
+      return PDEC_RESET_FAILED_STRING;
+    case (12411):
+      return OPEN_IRQ_FILE_FAILED_STRING;
     case (12500):
       return IMAGE_UPLOAD_FAILED_STRING;
     case (12501):
@@ -764,6 +788,12 @@ const char *translateEvents(Event event) {
       return HPA_OVERHEATING_STRING;
     case (14106):
       return PLPCDU_OVERHEATING_STRING;
+    case (14201):
+      return TX_TIMER_EXPIRED_STRING;
+    case (14202):
+      return BIT_LOCK_TX_ON_STRING;
+    case (14300):
+      return POSSIBLE_FILE_CORRUPTION_STRING;
     default:
       return "UNKNOWN_EVENT";
   }

generators/objects/translateObjects.cpp

@@ -1,8 +1,8 @@
 /**
  * @brief  Auto-generated object translation file.
  * @details
- * Contains 152 translations.
- * Generated on: 2023-02-21 00:24:44
+ * Contains 161 translations.
+ * Generated on: 2023-03-01 18:34:32
  */
 #include "translateObjects.h"
 
@@ -37,6 +37,7 @@ const char *GYRO_3_L3G_HANDLER_STRING = "GYRO_3_L3G_HANDLER";
 const char *RW4_STRING = "RW4";
 const char *STAR_TRACKER_STRING = "STAR_TRACKER";
 const char *GPS_CONTROLLER_STRING = "GPS_CONTROLLER";
+const char *IMTQ_POLLING_STRING = "IMTQ_POLLING";
 const char *IMTQ_HANDLER_STRING = "IMTQ_HANDLER";
 const char *PCDU_HANDLER_STRING = "PCDU_HANDLER";
 const char *P60DOCK_HANDLER_STRING = "P60DOCK_HANDLER";
@@ -84,11 +85,13 @@ 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";
 const char *SPI_MAIN_COM_IF_STRING = "SPI_MAIN_COM_IF";
-const char *RW_POLLING_TASK_STRING = "RW_POLLING_TASK";
-const char *SPI_RTD_COM_IF_STRING = "SPI_RTD_COM_IF";
 const char *UART_COM_IF_STRING = "UART_COM_IF";
 const char *I2C_COM_IF_STRING = "I2C_COM_IF";
 const char *CSP_COM_IF_STRING = "CSP_COM_IF";
+const char *ACS_BOARD_POLLING_TASK_STRING = "ACS_BOARD_POLLING_TASK";
+const char *RW_POLLING_TASK_STRING = "RW_POLLING_TASK";
+const char *SPI_RTD_COM_IF_STRING = "SPI_RTD_COM_IF";
+const char *SUS_POLLING_TASK_STRING = "SUS_POLLING_TASK";
 const char *CCSDS_PACKET_DISTRIBUTOR_STRING = "CCSDS_PACKET_DISTRIBUTOR";
 const char *PUS_PACKET_DISTRIBUTOR_STRING = "PUS_PACKET_DISTRIBUTOR";
 const char *TCP_TMTC_SERVER_STRING = "TCP_TMTC_SERVER";
@@ -109,6 +112,7 @@ const char *PUS_SERVICE_5_EVENT_REPORTING_STRING = "PUS_SERVICE_5_EVENT_REPORTIN
 const char *PUS_SERVICE_8_FUNCTION_MGMT_STRING = "PUS_SERVICE_8_FUNCTION_MGMT";
 const char *PUS_SERVICE_9_TIME_MGMT_STRING = "PUS_SERVICE_9_TIME_MGMT";
 const char *PUS_SERVICE_11_TC_SCHEDULER_STRING = "PUS_SERVICE_11_TC_SCHEDULER";
+const char *PUS_SERVICE_15_TM_STORAGE_STRING = "PUS_SERVICE_15_TM_STORAGE";
 const char *PUS_SERVICE_17_TEST_STRING = "PUS_SERVICE_17_TEST";
 const char *PUS_SERVICE_20_PARAMETERS_STRING = "PUS_SERVICE_20_PARAMETERS";
 const char *PUS_SERVICE_200_MODE_MGMT_STRING = "PUS_SERVICE_200_MODE_MGMT";
@@ -155,6 +159,11 @@ const char *ACS_SUBSYSTEM_STRING = "ACS_SUBSYSTEM";
 const char *PL_SUBSYSTEM_STRING = "PL_SUBSYSTEM";
 const char *TCS_SUBSYSTEM_STRING = "TCS_SUBSYSTEM";
 const char *COM_SUBSYSTEM_STRING = "COM_SUBSYSTEM";
+const char *MISC_TM_STORE_STRING = "MISC_TM_STORE";
+const char *OK_TM_STORE_STRING = "OK_TM_STORE";
+const char *NOT_OK_TM_STORE_STRING = "NOT_OK_TM_STORE";
+const char *HK_TM_STORE_STRING = "HK_TM_STORE";
+const char *CFDP_TM_STORE_STRING = "CFDP_TM_STORE";
 const char *CCSDS_IP_CORE_BRIDGE_STRING = "CCSDS_IP_CORE_BRIDGE";
 const char *THERMAL_TEMP_INSERTER_STRING = "THERMAL_TEMP_INSERTER";
 const char *NO_OBJECT_STRING = "NO_OBJECT";
@@ -223,6 +232,8 @@ const char *translateObject(object_id_t object) {
       return STAR_TRACKER_STRING;
     case 0x44130045:
       return GPS_CONTROLLER_STRING;
+    case 0x44140013:
+      return IMTQ_POLLING_STRING;
     case 0x44140014:
       return IMTQ_HANDLER_STRING;
     case 0x442000A1:
@@ -317,16 +328,20 @@ const char *translateObject(object_id_t object) {
       return SCEX_UART_READER_STRING;
     case 0x49020004:
       return SPI_MAIN_COM_IF_STRING;
-    case 0x49020005:
-      return RW_POLLING_TASK_STRING;
-    case 0x49020006:
-      return SPI_RTD_COM_IF_STRING;
     case 0x49030003:
       return UART_COM_IF_STRING;
     case 0x49040002:
       return I2C_COM_IF_STRING;
     case 0x49050001:
       return CSP_COM_IF_STRING;
+    case 0x49060004:
+      return ACS_BOARD_POLLING_TASK_STRING;
+    case 0x49060005:
+      return RW_POLLING_TASK_STRING;
+    case 0x49060006:
+      return SPI_RTD_COM_IF_STRING;
+    case 0x49060007:
+      return SUS_POLLING_TASK_STRING;
     case 0x50000100:
       return CCSDS_PACKET_DISTRIBUTOR_STRING;
     case 0x50000200:
@@ -367,6 +382,8 @@ const char *translateObject(object_id_t object) {
       return PUS_SERVICE_9_TIME_MGMT_STRING;
     case 0x53000011:
       return PUS_SERVICE_11_TC_SCHEDULER_STRING;
+    case 0x53000015:
+      return PUS_SERVICE_15_TM_STORAGE_STRING;
     case 0x53000017:
       return PUS_SERVICE_17_TEST_STRING;
     case 0x53000020:
@@ -459,6 +476,16 @@ const char *translateObject(object_id_t object) {
       return TCS_SUBSYSTEM_STRING;
     case 0x73010004:
       return COM_SUBSYSTEM_STRING;
+    case 0x73020001:
+      return MISC_TM_STORE_STRING;
+    case 0x73020002:
+      return OK_TM_STORE_STRING;
+    case 0x73020003:
+      return NOT_OK_TM_STORE_STRING;
+    case 0x73020004:
+      return HK_TM_STORE_STRING;
+    case 0x73030000:
+      return CFDP_TM_STORE_STRING;
     case 0x73500000:
       return CCSDS_IP_CORE_BRIDGE_STRING;
     case 0x90000003:

generators/requirements.txt

@@ -1,2 +1,2 @@
 colorlog==6.7.0
-git+https://egit.irs.uni-stuttgart.de/fsfw/fsfwgen@66e31885a7c87fbb4340cd2a51a13e1196f377af#egg=fsfwgen
+git+https://egit.irs.uni-stuttgart.de/fsfw/fsfwgen@v0.3.0#egg=fsfwgen

linux/ObjectFactory.cpp

@@ -9,9 +9,11 @@
 #include <fsfw_hal/linux/spi/SpiComIF.h>
 #include <fsfw_hal/linux/spi/SpiCookie.h>
 #include <linux/callbacks/gpioCallbacks.h>
-#include <linux/devices/Max31865RtdLowlevelHandler.h>
+#include <linux/devices/Max31865RtdPolling.h>
+#include <linux/devices/SusPolling.h>
 #include <mission/controller/AcsController.h>
 #include <mission/core/GenericFactory.h>
+#include <mission/devices/LegacySusHandler.h>
 #include <mission/devices/Max31865EiveHandler.h>
 #include <mission/devices/ScexDeviceHandler.h>
 #include <mission/devices/SusHandler.h>
@@ -33,6 +35,7 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo
                                               PowerSwitchIF& pwrSwitcher, std::string spiDev,
                                               bool swap0And6) {
   using namespace gpio;
+  new SusPolling(objects::SUS_POLLING_TASK, *spiComIF, *gpioComIF);
   GpioCookie* gpioCookieSus = new GpioCookie();
   GpioCallback* susgpio = nullptr;
 
@@ -78,99 +81,100 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo
 #if OBSW_ADD_SUN_SENSORS == 1
   SusFdir* fdir = nullptr;
   std::array<SusHandler*, 12> susHandlers = {};
-  SpiCookie* spiCookie = new SpiCookie(addresses::SUS_0, gpioIds::CS_SUS_0, SUS::MAX_CMD_SIZE,
-                                       spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
+  SpiCookie* spiCookie =
+      new SpiCookie(addresses::SUS_0, gpioIds::CS_SUS_0, susMax1227::MAX_CMD_SIZE,
+                    spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
   spiCookie->setMutexParams(MutexIF::TimeoutType::WAITING, spi::SUS_CS_TIMEOUT);
   susHandlers[0] =
-      new SusHandler(objects::SUS_0_N_LOC_XFYFZM_PT_XF, 0, objects::SPI_MAIN_COM_IF, spiCookie);
+      new SusHandler(objects::SUS_0_N_LOC_XFYFZM_PT_XF, 0, objects::SUS_POLLING_TASK, spiCookie);
   fdir = new SusFdir(objects::SUS_0_N_LOC_XFYFZM_PT_XF);
   susHandlers[0]->setCustomFdir(fdir);
 
-  spiCookie = new SpiCookie(addresses::SUS_1, gpioIds::CS_SUS_1, SUS::MAX_CMD_SIZE,
+  spiCookie = new SpiCookie(addresses::SUS_1, gpioIds::CS_SUS_1, susMax1227::MAX_CMD_SIZE,
                             spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
   spiCookie->setMutexParams(MutexIF::TimeoutType::WAITING, spi::SUS_CS_TIMEOUT);
   susHandlers[1] =
-      new SusHandler(objects::SUS_1_N_LOC_XBYFZM_PT_XB, 1, objects::SPI_MAIN_COM_IF, spiCookie);
+      new SusHandler(objects::SUS_1_N_LOC_XBYFZM_PT_XB, 1, objects::SUS_POLLING_TASK, spiCookie);
   fdir = new SusFdir(objects::SUS_1_N_LOC_XBYFZM_PT_XB);
   susHandlers[1]->setCustomFdir(fdir);
 
-  spiCookie = new SpiCookie(addresses::SUS_2, gpioIds::CS_SUS_2, SUS::MAX_CMD_SIZE,
+  spiCookie = new SpiCookie(addresses::SUS_2, gpioIds::CS_SUS_2, susMax1227::MAX_CMD_SIZE,
                             spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
   spiCookie->setMutexParams(MutexIF::TimeoutType::WAITING, spi::SUS_CS_TIMEOUT);
   susHandlers[2] =
-      new SusHandler(objects::SUS_2_N_LOC_XFYBZB_PT_YB, 2, objects::SPI_MAIN_COM_IF, spiCookie);
+      new SusHandler(objects::SUS_2_N_LOC_XFYBZB_PT_YB, 2, objects::SUS_POLLING_TASK, spiCookie);
   fdir = new SusFdir(objects::SUS_2_N_LOC_XFYBZB_PT_YB);
   susHandlers[2]->setCustomFdir(fdir);
 
-  spiCookie = new SpiCookie(addresses::SUS_3, gpioIds::CS_SUS_3, SUS::MAX_CMD_SIZE,
+  spiCookie = new SpiCookie(addresses::SUS_3, gpioIds::CS_SUS_3, susMax1227::MAX_CMD_SIZE,
                             spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
   spiCookie->setMutexParams(MutexIF::TimeoutType::WAITING, spi::SUS_CS_TIMEOUT);
   susHandlers[3] =
-      new SusHandler(objects::SUS_3_N_LOC_XFYBZF_PT_YF, 3, objects::SPI_MAIN_COM_IF, spiCookie);
+      new SusHandler(objects::SUS_3_N_LOC_XFYBZF_PT_YF, 3, objects::SUS_POLLING_TASK, spiCookie);
   fdir = new SusFdir(objects::SUS_3_N_LOC_XFYBZF_PT_YF);
   susHandlers[3]->setCustomFdir(fdir);
 
-  spiCookie = new SpiCookie(addresses::SUS_4, gpioIds::CS_SUS_4, SUS::MAX_CMD_SIZE,
+  spiCookie = new SpiCookie(addresses::SUS_4, gpioIds::CS_SUS_4, susMax1227::MAX_CMD_SIZE,
                             spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
   spiCookie->setMutexParams(MutexIF::TimeoutType::WAITING, spi::SUS_CS_TIMEOUT);
   susHandlers[4] =
-      new SusHandler(objects::SUS_4_N_LOC_XMYFZF_PT_ZF, 4, objects::SPI_MAIN_COM_IF, spiCookie);
+      new SusHandler(objects::SUS_4_N_LOC_XMYFZF_PT_ZF, 4, objects::SUS_POLLING_TASK, spiCookie);
   fdir = new SusFdir(objects::SUS_4_N_LOC_XMYFZF_PT_ZF);
   susHandlers[4]->setCustomFdir(fdir);
 
-  spiCookie = new SpiCookie(addresses::SUS_5, gpioIds::CS_SUS_5, SUS::MAX_CMD_SIZE,
+  spiCookie = new SpiCookie(addresses::SUS_5, gpioIds::CS_SUS_5, susMax1227::MAX_CMD_SIZE,
                             spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
   spiCookie->setMutexParams(MutexIF::TimeoutType::WAITING, spi::SUS_CS_TIMEOUT);
   susHandlers[5] =
-      new SusHandler(objects::SUS_5_N_LOC_XFYMZB_PT_ZB, 5, objects::SPI_MAIN_COM_IF, spiCookie);
+      new SusHandler(objects::SUS_5_N_LOC_XFYMZB_PT_ZB, 5, objects::SUS_POLLING_TASK, spiCookie);
   fdir = new SusFdir(objects::SUS_5_N_LOC_XFYMZB_PT_ZB);
   susHandlers[5]->setCustomFdir(fdir);
 
-  spiCookie = new SpiCookie(addresses::SUS_6, gpioIds::CS_SUS_6, SUS::MAX_CMD_SIZE,
+  spiCookie = new SpiCookie(addresses::SUS_6, gpioIds::CS_SUS_6, susMax1227::MAX_CMD_SIZE,
                             spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
   spiCookie->setMutexParams(MutexIF::TimeoutType::WAITING, spi::SUS_CS_TIMEOUT);
   susHandlers[6] =
-      new SusHandler(objects::SUS_6_R_LOC_XFYBZM_PT_XF, 6, objects::SPI_MAIN_COM_IF, spiCookie);
+      new SusHandler(objects::SUS_6_R_LOC_XFYBZM_PT_XF, 6, objects::SUS_POLLING_TASK, spiCookie);
   fdir = new SusFdir(objects::SUS_6_R_LOC_XFYBZM_PT_XF);
   susHandlers[6]->setCustomFdir(fdir);
 
-  spiCookie = new SpiCookie(addresses::SUS_7, gpioIds::CS_SUS_7, SUS::MAX_CMD_SIZE,
+  spiCookie = new SpiCookie(addresses::SUS_7, gpioIds::CS_SUS_7, susMax1227::MAX_CMD_SIZE,
                             spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
   spiCookie->setMutexParams(MutexIF::TimeoutType::WAITING, spi::SUS_CS_TIMEOUT);
   susHandlers[7] =
-      new SusHandler(objects::SUS_7_R_LOC_XBYBZM_PT_XB, 7, objects::SPI_MAIN_COM_IF, spiCookie);
+      new SusHandler(objects::SUS_7_R_LOC_XBYBZM_PT_XB, 7, objects::SUS_POLLING_TASK, spiCookie);
   fdir = new SusFdir(objects::SUS_7_R_LOC_XBYBZM_PT_XB);
   susHandlers[7]->setCustomFdir(fdir);
 
-  spiCookie = new SpiCookie(addresses::SUS_8, gpioIds::CS_SUS_8, SUS::MAX_CMD_SIZE,
+  spiCookie = new SpiCookie(addresses::SUS_8, gpioIds::CS_SUS_8, susMax1227::MAX_CMD_SIZE,
                             spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
   spiCookie->setMutexParams(MutexIF::TimeoutType::WAITING, spi::SUS_CS_TIMEOUT);
   susHandlers[8] =
-      new SusHandler(objects::SUS_8_R_LOC_XBYBZB_PT_YB, 8, objects::SPI_MAIN_COM_IF, spiCookie);
+      new SusHandler(objects::SUS_8_R_LOC_XBYBZB_PT_YB, 8, objects::SUS_POLLING_TASK, spiCookie);
   fdir = new SusFdir(objects::SUS_8_R_LOC_XBYBZB_PT_YB);
   susHandlers[8]->setCustomFdir(fdir);
 
-  spiCookie = new SpiCookie(addresses::SUS_9, gpioIds::CS_SUS_9, SUS::MAX_CMD_SIZE,
+  spiCookie = new SpiCookie(addresses::SUS_9, gpioIds::CS_SUS_9, susMax1227::MAX_CMD_SIZE,
                             spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
   spiCookie->setMutexParams(MutexIF::TimeoutType::WAITING, spi::SUS_CS_TIMEOUT);
   susHandlers[9] =
-      new SusHandler(objects::SUS_9_R_LOC_XBYBZB_PT_YF, 9, objects::SPI_MAIN_COM_IF, spiCookie);
+      new SusHandler(objects::SUS_9_R_LOC_XBYBZB_PT_YF, 9, objects::SUS_POLLING_TASK, spiCookie);
   fdir = new SusFdir(objects::SUS_9_R_LOC_XBYBZB_PT_YF);
   susHandlers[9]->setCustomFdir(fdir);
 
-  spiCookie = new SpiCookie(addresses::SUS_10, gpioIds::CS_SUS_10, SUS::MAX_CMD_SIZE,
+  spiCookie = new SpiCookie(addresses::SUS_10, gpioIds::CS_SUS_10, susMax1227::MAX_CMD_SIZE,
                             spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
   spiCookie->setMutexParams(MutexIF::TimeoutType::WAITING, spi::SUS_CS_TIMEOUT);
   susHandlers[10] =
-      new SusHandler(objects::SUS_10_N_LOC_XMYBZF_PT_ZF, 10, objects::SPI_MAIN_COM_IF, spiCookie);
+      new SusHandler(objects::SUS_10_N_LOC_XMYBZF_PT_ZF, 10, objects::SUS_POLLING_TASK, spiCookie);
   fdir = new SusFdir(objects::SUS_10_N_LOC_XMYBZF_PT_ZF);
   susHandlers[10]->setCustomFdir(fdir);
 
-  spiCookie = new SpiCookie(addresses::SUS_11, gpioIds::CS_SUS_11, SUS::MAX_CMD_SIZE,
+  spiCookie = new SpiCookie(addresses::SUS_11, gpioIds::CS_SUS_11, susMax1227::MAX_CMD_SIZE,
                             spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
   spiCookie->setMutexParams(MutexIF::TimeoutType::WAITING, spi::SUS_CS_TIMEOUT);
   susHandlers[11] =
-      new SusHandler(objects::SUS_11_R_LOC_XBYMZB_PT_ZB, 11, objects::SPI_MAIN_COM_IF, spiCookie);
+      new SusHandler(objects::SUS_11_R_LOC_XBYMZB_PT_ZB, 11, objects::SUS_POLLING_TASK, spiCookie);
   fdir = new SusFdir(objects::SUS_11_R_LOC_XBYMZB_PT_ZB);
   susHandlers[11]->setCustomFdir(fdir);
 
@@ -278,7 +282,7 @@ void ObjectFactory::createRtdComponents(std::string spiDev, GpioIF* gpioComIF,
   TcsBoardAssembly* tcsBoardAss = ObjectFactory::createTcsBoardAssy(*pwrSwitcher);
 
   // Create special low level reader communication interface
-  new Max31865RtdReader(objects::SPI_RTD_COM_IF, comIF, gpioComIF);
+  new Max31865RtdPolling(objects::SPI_RTD_COM_IF, comIF, gpioComIF);
   for (uint8_t idx = 0; idx < NUM_RTDS; idx++) {
     rtdCookies[idx] = new SpiCookie(cookieArgs[idx].first, cookieArgs[idx].second,
                                     MAX31865::MAX_REPLY_SIZE, spi::RTD_MODE, spi::RTD_SPEED);

linux/devices/AcsBoardPolling.cpp

@@ -0,0 +1,730 @@
+#include "AcsBoardPolling.h"
+
+#include <fcntl.h>
+#include <fsfw/globalfunctions/arrayprinter.h>
+#include <fsfw/tasks/SemaphoreFactory.h>
+#include <fsfw/tasks/TaskFactory.h>
+#include <fsfw_hal/devicehandlers/devicedefinitions/gyroL3gHelpers.h>
+#include <fsfw_hal/devicehandlers/devicedefinitions/mgmLis3Helpers.h>
+#include <fsfw_hal/linux/UnixFileGuard.h>
+#include <fsfw_hal/linux/spi/SpiCookie.h>
+#include <fsfw_hal/linux/utility.h>
+#include <mission/devices/devicedefinitions/gyroAdisHelpers.h>
+#include <sys/ioctl.h>
+
+#include "devices/gpioIds.h"
+
+using namespace returnvalue;
+
+AcsBoardPolling::AcsBoardPolling(object_id_t objectId, SpiComIF& lowLevelComIF, GpioIF& gpioIF)
+    : SystemObject(objectId), spiComIF(lowLevelComIF), gpioIF(gpioIF) {
+  semaphore = SemaphoreFactory::instance()->createBinarySemaphore();
+  semaphore->acquire();
+  ipcLock = MutexFactory::instance()->createMutex();
+}
+
+ReturnValue_t AcsBoardPolling::performOperation(uint8_t operationCode) {
+  while (true) {
+    ipcLock->lockMutex();
+    state = InternalState::IDLE;
+    ipcLock->unlockMutex();
+    semaphore->acquire();
+    // Give all tasks or the PST some time to submit all consecutive requests.
+    TaskFactory::delayTask(2);
+    gyroAdisHandler(gyro0Adis);
+    gyroAdisHandler(gyro2Adis);
+    gyroL3gHandler(gyro1L3g);
+    gyroL3gHandler(gyro3L3g);
+    mgmRm3100Handler(mgm1Rm3100);
+    mgmRm3100Handler(mgm3Rm3100);
+    mgmLis3Handler(mgm0Lis3);
+    mgmLis3Handler(mgm2Lis3);
+    // To prevent task being not reactivated by tardy tasks
+    TaskFactory::delayTask(20);
+  }
+  return returnvalue::OK;
+}
+
+ReturnValue_t AcsBoardPolling::initialize() { return returnvalue::OK; }
+
+ReturnValue_t AcsBoardPolling::initializeInterface(CookieIF* cookie) {
+  SpiCookie* spiCookie = dynamic_cast<SpiCookie*>(cookie);
+  if (spiCookie == nullptr) {
+    return returnvalue::FAILED;
+  }
+  switch (spiCookie->getChipSelectPin()) {
+    case (gpioIds::MGM_0_LIS3_CS): {
+      mgm0Lis3.cookie = spiCookie;
+      break;
+    }
+    case (gpioIds::MGM_1_RM3100_CS): {
+      mgm1Rm3100.cookie = spiCookie;
+      break;
+    }
+    case (gpioIds::MGM_2_LIS3_CS): {
+      mgm2Lis3.cookie = spiCookie;
+      break;
+    }
+    case (gpioIds::MGM_3_RM3100_CS): {
+      mgm3Rm3100.cookie = spiCookie;
+      break;
+    }
+    case (gpioIds::GYRO_0_ADIS_CS): {
+      gyro0Adis.cookie = spiCookie;
+      break;
+    }
+    case (gpioIds::GYRO_1_L3G_CS): {
+      gyro1L3g.cookie = spiCookie;
+      break;
+    }
+    case (gpioIds::GYRO_2_ADIS_CS): {
+      gyro2Adis.cookie = spiCookie;
+      break;
+    }
+    case (gpioIds::GYRO_3_L3G_CS): {
+      gyro3L3g.cookie = spiCookie;
+      break;
+    }
+    default: {
+      sif::error << "AcsBoardPollingTask: invalid spi cookie" << std::endl;
+    }
+  }
+  return spiComIF.initializeInterface(cookie);
+}
+
+ReturnValue_t AcsBoardPolling::sendMessage(CookieIF* cookie, const uint8_t* sendData,
+                                           size_t sendLen) {
+  SpiCookie* spiCookie = dynamic_cast<SpiCookie*>(cookie);
+  if (spiCookie == nullptr) {
+    return returnvalue::FAILED;
+  }
+  auto handleAdisRequest = [&](GyroAdis& adis) {
+    if (sendLen != sizeof(acs::Adis1650XRequest)) {
+      sif::error << "AcsBoardPolling: invalid adis request send length";
+      adis.replyResult = returnvalue::FAILED;
+      return returnvalue::FAILED;
+    }
+    auto* req = reinterpret_cast<const acs::Adis1650XRequest*>(sendData);
+    MutexGuard mg(ipcLock);
+    if (req->mode != adis.mode) {
+      if (req->mode == acs::SimpleSensorMode::NORMAL) {
+        adis.type = req->type;
+        adis.countdown.setTimeout(adis1650x::START_UP_TIME);
+        adis.countdown.resetTimer();
+        if (adis.type == adis1650x::Type::ADIS16507) {
+          adis.ownReply.data.accelScaling = adis1650x::ACCELEROMETER_RANGE_16507;
+        } else if (adis.type == adis1650x::Type::ADIS16505) {
+          adis.ownReply.data.accelScaling = adis1650x::ACCELEROMETER_RANGE_16505;
+        } else {
+          sif::warning << "AcsBoardPolling: Unknown ADIS type" << std::endl;
+        }
+        adis.performStartup = true;
+      } else if (req->mode == acs::SimpleSensorMode::OFF) {
+        adis.performStartup = false;
+        adis.ownReply.cfgWasSet = false;
+        adis.ownReply.dataWasSet = false;
+      }
+      adis.mode = req->mode;
+    }
+    return returnvalue::OK;
+  };
+  auto handleL3gRequest = [&](GyroL3g& gyro) {
+    if (sendLen != sizeof(acs::GyroL3gRequest)) {
+      sif::error << "AcsBoardPolling: invalid l3g request send length";
+      gyro.replyResult = returnvalue::FAILED;
+      return returnvalue::FAILED;
+    }
+    auto* req = reinterpret_cast<const acs::GyroL3gRequest*>(sendData);
+    MutexGuard mg(ipcLock);
+    if (req->mode != gyro.mode) {
+      if (req->mode == acs::SimpleSensorMode::NORMAL) {
+        std::memcpy(gyro.sensorCfg, req->ctrlRegs, 5);
+        gyro.performStartup = true;
+      } else {
+        gyro.ownReply.cfgWasSet = false;
+      }
+      gyro.mode = req->mode;
+    }
+    return returnvalue::OK;
+  };
+  auto handleLis3Request = [&](MgmLis3& mgm) {
+    if (sendLen != sizeof(acs::MgmLis3Request)) {
+      sif::error << "AcsBoardPolling: invalid lis3 request send length";
+      mgm.replyResult = returnvalue::FAILED;
+      return returnvalue::FAILED;
+    }
+    auto* req = reinterpret_cast<const acs::MgmLis3Request*>(sendData);
+    MutexGuard mg(ipcLock);
+    if (req->mode != mgm.mode) {
+      if (req->mode == acs::SimpleSensorMode::NORMAL) {
+        mgm.performStartup = true;
+      } else {
+        mgm.ownReply.dataWasSet = false;
+        mgm.ownReply.temperatureWasSet = false;
+      }
+      mgm.mode = req->mode;
+    }
+    return returnvalue::OK;
+  };
+  auto handleRm3100Request = [&](MgmRm3100& mgm) {
+    if (sendLen != sizeof(acs::MgmRm3100Request)) {
+      sif::error << "AcsBoardPolling: invalid rm3100 request send length";
+      mgm.replyResult = returnvalue::FAILED;
+      return returnvalue::FAILED;
+    }
+    auto* req = reinterpret_cast<const acs::MgmRm3100Request*>(sendData);
+    MutexGuard mg(ipcLock);
+    if (req->mode != mgm.mode) {
+      if (req->mode == acs::SimpleSensorMode::NORMAL) {
+        mgm.performStartup = true;
+      } else {
+        mgm.ownReply.dataWasRead = false;
+      }
+      mgm.mode = req->mode;
+    }
+    return returnvalue::OK;
+  };
+  switch (spiCookie->getChipSelectPin()) {
+    case (gpioIds::MGM_0_LIS3_CS): {
+      handleLis3Request(mgm0Lis3);
+      break;
+    }
+    case (gpioIds::MGM_1_RM3100_CS): {
+      handleRm3100Request(mgm1Rm3100);
+      break;
+    }
+    case (gpioIds::MGM_2_LIS3_CS): {
+      handleLis3Request(mgm2Lis3);
+      break;
+    }
+    case (gpioIds::MGM_3_RM3100_CS): {
+      handleRm3100Request(mgm3Rm3100);
+      break;
+    }
+    case (gpioIds::GYRO_0_ADIS_CS): {
+      handleAdisRequest(gyro0Adis);
+      break;
+    }
+    case (gpioIds::GYRO_2_ADIS_CS): {
+      handleAdisRequest(gyro2Adis);
+      break;
+    }
+    case (gpioIds::GYRO_1_L3G_CS): {
+      handleL3gRequest(gyro1L3g);
+      break;
+    }
+    case (gpioIds::GYRO_3_L3G_CS): {
+      handleL3gRequest(gyro3L3g);
+      break;
+    }
+  }
+  MutexGuard mg(ipcLock);
+  if (state == InternalState::IDLE) {
+    state = InternalState::BUSY;
+    semaphore->release();
+  }
+  return returnvalue::OK;
+}
+
+ReturnValue_t AcsBoardPolling::getSendSuccess(CookieIF* cookie) { return returnvalue::OK; }
+
+ReturnValue_t AcsBoardPolling::requestReceiveMessage(CookieIF* cookie, size_t requestLen) {
+  return returnvalue::OK;
+}
+
+ReturnValue_t AcsBoardPolling::readReceivedMessage(CookieIF* cookie, uint8_t** buffer,
+                                                   size_t* size) {
+  SpiCookie* spiCookie = dynamic_cast<SpiCookie*>(cookie);
+  if (spiCookie == nullptr) {
+    return returnvalue::FAILED;
+  }
+  MutexGuard mg(ipcLock);
+  auto handleAdisReply = [&](GyroAdis& gyro) {
+    std::memcpy(&gyro.readerReply, &gyro.ownReply, sizeof(acs::Adis1650XReply));
+    *buffer = reinterpret_cast<uint8_t*>(&gyro.readerReply);
+    *size = sizeof(acs::Adis1650XReply);
+    return gyro.replyResult;
+  };
+  auto handleL3gReply = [&](GyroL3g& gyro) {
+    std::memcpy(&gyro.readerReply, &gyro.ownReply, sizeof(acs::GyroL3gReply));
+    *buffer = reinterpret_cast<uint8_t*>(&gyro.readerReply);
+    *size = sizeof(acs::GyroL3gReply);
+    return gyro.replyResult;
+  };
+  auto handleRm3100Reply = [&](MgmRm3100& mgm) {
+    std::memcpy(&mgm.readerReply, &mgm.ownReply, sizeof(acs::MgmRm3100Reply));
+    *buffer = reinterpret_cast<uint8_t*>(&mgm.readerReply);
+    *size = sizeof(acs::MgmRm3100Reply);
+    return mgm.replyResult;
+  };
+  auto handleLis3Reply = [&](MgmLis3& mgm) {
+    std::memcpy(&mgm.readerReply, &mgm.ownReply, sizeof(acs::MgmLis3Reply));
+    *buffer = reinterpret_cast<uint8_t*>(&mgm.readerReply);
+    *size = sizeof(acs::MgmLis3Reply);
+    return mgm.replyResult;
+  };
+  switch (spiCookie->getChipSelectPin()) {
+    case (gpioIds::MGM_0_LIS3_CS): {
+      return handleLis3Reply(mgm0Lis3);
+    }
+    case (gpioIds::MGM_1_RM3100_CS): {
+      return handleRm3100Reply(mgm1Rm3100);
+    }
+    case (gpioIds::MGM_2_LIS3_CS): {
+      return handleLis3Reply(mgm2Lis3);
+    }
+    case (gpioIds::MGM_3_RM3100_CS): {
+      return handleRm3100Reply(mgm3Rm3100);
+    }
+    case (gpioIds::GYRO_0_ADIS_CS): {
+      return handleAdisReply(gyro0Adis);
+    }
+    case (gpioIds::GYRO_2_ADIS_CS): {
+      return handleAdisReply(gyro2Adis);
+    }
+    case (gpioIds::GYRO_1_L3G_CS): {
+      return handleL3gReply(gyro1L3g);
+    }
+    case (gpioIds::GYRO_3_L3G_CS): {
+      return handleL3gReply(gyro3L3g);
+    }
+  }
+  return returnvalue::OK;
+}
+
+void AcsBoardPolling::gyroL3gHandler(GyroL3g& l3g) {
+  ReturnValue_t result;
+  acs::SimpleSensorMode mode;
+  bool gyroPerformStartup;
+  {
+    MutexGuard mg(ipcLock);
+    mode = l3g.mode;
+    gyroPerformStartup = l3g.performStartup;
+  }
+  if (mode == acs::SimpleSensorMode::NORMAL) {
+    if (gyroPerformStartup) {
+      cmdBuf[0] = l3gd20h::CTRL_REG_1 | l3gd20h::AUTO_INCREMENT_MASK;
+      std::memcpy(cmdBuf.data() + 1, l3g.sensorCfg, 5);
+      result = spiComIF.sendMessage(l3g.cookie, cmdBuf.data(), 6);
+      if (result != returnvalue::OK) {
+        l3g.replyResult = returnvalue::OK;
+      }
+      // Ignore useless reply and red config
+      cmdBuf[0] = l3gd20h::CTRL_REG_1 | l3gd20h::AUTO_INCREMENT_MASK | l3gd20h::READ_MASK;
+      std::memset(cmdBuf.data() + 1, 0, 5);
+      result = spiComIF.sendMessage(l3g.cookie, cmdBuf.data(), 6);
+      if (result != returnvalue::OK) {
+        l3g.replyResult = returnvalue::OK;
+      }
+      result = spiComIF.readReceivedMessage(l3g.cookie, &rawReply, &dummy);
+      if (result != returnvalue::OK) {
+        l3g.replyResult = returnvalue::OK;
+      }
+      MutexGuard mg(ipcLock);
+      // Cross check configuration as verification that communication is working
+      for (uint8_t idx = 0; idx < 5; idx++) {
+        if (rawReply[idx + 1] != l3g.sensorCfg[idx]) {
+          sif::warning << "AcsBoardPolling: l3g config check missmatch" << std::endl;
+          l3g.replyResult = returnvalue::FAILED;
+          return;
+        }
+      }
+      l3g.performStartup = false;
+      l3g.ownReply.cfgWasSet = true;
+      l3g.ownReply.sensitivity = l3gd20h::ctrlReg4ToSensitivity(l3g.sensorCfg[3]);
+    }
+    cmdBuf[0] = l3gd20h::READ_START | l3gd20h::AUTO_INCREMENT_MASK | l3gd20h::READ_MASK;
+    std::memset(cmdBuf.data() + 1, 0, l3gd20h::READ_LEN);
+    result = spiComIF.sendMessage(l3g.cookie, cmdBuf.data(), l3gd20h::READ_LEN + 1);
+    if (result != returnvalue::OK) {
+      l3g.replyResult = returnvalue::FAILED;
+      return;
+    }
+    result = spiComIF.readReceivedMessage(l3g.cookie, &rawReply, &dummy);
+    if (result != returnvalue::OK) {
+      l3g.replyResult = returnvalue::FAILED;
+      return;
+    }
+    MutexGuard mg(ipcLock);
+    // The regular read function always returns the full sensor config as well. Use that
+    // to verify communications.
+    for (uint8_t idx = 0; idx < 5; idx++) {
+      if (rawReply[idx + 1] != l3g.sensorCfg[idx]) {
+        sif::warning << "AcsBoardPolling: l3g config check missmatch" << std::endl;
+        l3g.replyResult = returnvalue::FAILED;
+        return;
+      }
+    }
+    l3g.ownReply.statusReg = rawReply[l3gd20h::STATUS_IDX];
+    l3g.ownReply.angVelocities[0] = (rawReply[l3gd20h::OUT_X_H] << 8) | rawReply[l3gd20h::OUT_X_L];
+    l3g.ownReply.angVelocities[1] = (rawReply[l3gd20h::OUT_Y_H] << 8) | rawReply[l3gd20h::OUT_Y_L];
+    l3g.ownReply.angVelocities[2] = (rawReply[l3gd20h::OUT_Z_H] << 8) | rawReply[l3gd20h::OUT_Z_L];
+    l3g.ownReply.tempOffsetRaw = rawReply[l3gd20h::TEMPERATURE_IDX];
+  }
+}
+
+ReturnValue_t AcsBoardPolling::readAdisCfg(SpiCookie& cookie, size_t transferLen) {
+  ReturnValue_t result = returnvalue::OK;
+  int retval = 0;
+  // Prepare transfer
+  int fileDescriptor = 0;
+  std::string device = spiComIF.getSpiDev();
+  UnixFileGuard fileHelper(device, fileDescriptor, O_RDWR, "SpiComIF::sendMessage");
+  if (fileHelper.getOpenResult() != returnvalue::OK) {
+    return SpiComIF::OPENING_FILE_FAILED;
+  }
+  spi::SpiModes spiMode = spi::SpiModes::MODE_0;
+  uint32_t spiSpeed = 0;
+  cookie.getSpiParameters(spiMode, spiSpeed, nullptr);
+  spiComIF.setSpiSpeedAndMode(fileDescriptor, spiMode, spiSpeed);
+  cookie.assignWriteBuffer(cmdBuf.data());
+  cookie.setTransferSize(2);
+
+  gpioId_t gpioId = cookie.getChipSelectPin();
+  MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
+  uint32_t timeoutMs = 0;
+  MutexIF* mutex = spiComIF.getCsMutex();
+  cookie.getMutexParams(timeoutType, timeoutMs);
+  if (mutex == nullptr) {
+    sif::warning << "GyroADIS16507Handler::spiSendCallback: "
+                    "Mutex or GPIO interface invalid"
+                 << std::endl;
+    return returnvalue::FAILED;
+  }
+
+  size_t idx = 0;
+  spi_ioc_transfer* transferStruct = cookie.getTransferStructHandle();
+  uint64_t origTx = transferStruct->tx_buf;
+  uint64_t origRx = transferStruct->rx_buf;
+  while (idx < transferLen) {
+    result = mutex->lockMutex(timeoutType, timeoutMs);
+    if (result != returnvalue::OK) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+      sif::error << "AcsBoardPolling: Failed to lock mutex" << std::endl;
+#endif
+      return result;
+    }
+    // Pull SPI CS low. For now, no support for active high given
+    if (gpioId != gpio::NO_GPIO) {
+      gpioIF.pullLow(gpioId);
+    }
+
+    // Execute transfer
+    // Initiate a full duplex SPI transfer.
+    retval = ioctl(fileDescriptor, SPI_IOC_MESSAGE(1), cookie.getTransferStructHandle());
+    if (retval < 0) {
+      utility::handleIoctlError("SpiComIF::sendMessage: ioctl error.");
+      result = SpiComIF::FULL_DUPLEX_TRANSFER_FAILED;
+    }
+#if FSFW_HAL_SPI_WIRETAPPING == 1
+    comIf->performSpiWiretapping(cookie);
+#endif /* FSFW_LINUX_SPI_WIRETAPPING == 1 */
+
+    if (gpioId != gpio::NO_GPIO) {
+      gpioIF.pullHigh(gpioId);
+    }
+    mutex->unlockMutex();
+
+    idx += 2;
+    transferStruct->tx_buf += 2;
+    transferStruct->rx_buf += 2;
+    if (idx < transferLen) {
+      usleep(adis1650x::STALL_TIME_MICROSECONDS);
+    }
+  }
+  transferStruct->tx_buf = origTx;
+  transferStruct->rx_buf = origRx;
+  cookie.setTransferSize(transferLen);
+  return returnvalue::OK;
+}
+
+void AcsBoardPolling::gyroAdisHandler(GyroAdis& gyro) {
+  ReturnValue_t result;
+  acs::SimpleSensorMode mode;
+  bool cdHasTimedOut = false;
+  bool mustPerformStartup = false;
+  {
+    MutexGuard mg(ipcLock);
+    mode = gyro.mode;
+    cdHasTimedOut = gyro.countdown.hasTimedOut();
+    mustPerformStartup = gyro.performStartup;
+  }
+  if (mode == acs::SimpleSensorMode::NORMAL and cdHasTimedOut) {
+    if (mustPerformStartup) {
+      uint8_t regList[6];
+      // Read configuration
+      regList[0] = adis1650x::DIAG_STAT_REG;
+      regList[1] = adis1650x::FILTER_CTRL_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;
+      size_t transferLen =
+          adis1650x::prepareReadCommand(regList, sizeof(regList), cmdBuf.data(), cmdBuf.size());
+      result = readAdisCfg(*gyro.cookie, transferLen);
+      if (result != returnvalue::OK) {
+        gyro.replyResult = result;
+        return;
+      }
+      result = spiComIF.readReceivedMessage(gyro.cookie, &rawReply, &dummy);
+      if (result != returnvalue::OK or rawReply == nullptr) {
+        gyro.replyResult = result;
+        return;
+      }
+      uint16_t prodId = (rawReply[12] << 8) | rawReply[13];
+      if (((gyro.type == adis1650x::Type::ADIS16505) and (prodId != adis1650x::PROD_ID_16505)) or
+          ((gyro.type == adis1650x::Type::ADIS16507) and (prodId != adis1650x::PROD_ID_16507))) {
+        sif::warning << "AcsPollingTask: Invalid  ADIS product ID " << prodId << std::endl;
+        gyro.replyResult = returnvalue::FAILED;
+        return;
+      }
+      MutexGuard mg(ipcLock);
+      gyro.ownReply.cfgWasSet = true;
+      gyro.ownReply.cfg.diagStat = (rawReply[2] << 8) | rawReply[3];
+      gyro.ownReply.cfg.filterSetting = (rawReply[4] << 8) | rawReply[5];
+      gyro.ownReply.cfg.rangMdl = (rawReply[6] << 8) | rawReply[7];
+      gyro.ownReply.cfg.mscCtrlReg = (rawReply[8] << 8) | rawReply[9];
+      gyro.ownReply.cfg.decRateReg = (rawReply[10] << 8) | rawReply[11];
+      gyro.ownReply.cfg.prodId = prodId;
+      gyro.ownReply.data.sensitivity = adis1650x::rangMdlToSensitivity(gyro.ownReply.cfg.rangMdl);
+      gyro.performStartup = false;
+    }
+    // Read regular registers
+    std::memcpy(cmdBuf.data(), adis1650x::BURST_READ_ENABLE.data(),
+                adis1650x::BURST_READ_ENABLE.size());
+    std::memset(cmdBuf.data() + 2, 0, 10 * 2);
+    result = spiComIF.sendMessage(gyro.cookie, cmdBuf.data(), adis1650x::SENSOR_READOUT_SIZE);
+    if (result != returnvalue::OK) {
+      gyro.replyResult = returnvalue::FAILED;
+      return;
+    }
+    result = spiComIF.readReceivedMessage(gyro.cookie, &rawReply, &dummy);
+    if (result != returnvalue::OK or rawReply == nullptr) {
+      gyro.replyResult = returnvalue::FAILED;
+      return;
+    }
+    uint16_t checksum = (rawReply[20] << 8) | rawReply[21];
+
+    // Now verify the read checksum with the expected checksum according to datasheet p. 20
+    uint16_t calcChecksum = 0;
+    for (size_t idx = 2; idx < 20; idx++) {
+      calcChecksum += rawReply[idx];
+    }
+    if (checksum != calcChecksum) {
+      sif::warning << "AcsPollingTask: Invalid ADIS reply checksum" << std::endl;
+      gyro.replyResult = returnvalue::FAILED;
+      return;
+    }
+
+    auto burstMode = adis1650x::burstModeFromMscCtrl(gyro.ownReply.cfg.mscCtrlReg);
+    if (burstMode != adis1650x::BurstModes::BURST_16_BURST_SEL_0) {
+      sif::error << "GyroADIS1650XHandler::interpretDeviceReply: Analysis for select burst mode"
+                    " not implemented!"
+                 << std::endl;
+      gyro.replyResult = returnvalue::FAILED;
+      return;
+    }
+
+    MutexGuard mg(ipcLock);
+    gyro.ownReply.dataWasSet = true;
+    gyro.ownReply.cfg.diagStat = rawReply[2] << 8 | rawReply[3];
+    gyro.ownReply.data.angVelocities[0] = (rawReply[4] << 8) | rawReply[5];
+    gyro.ownReply.data.angVelocities[1] = (rawReply[6] << 8) | rawReply[7];
+    gyro.ownReply.data.angVelocities[2] = (rawReply[8] << 8) | rawReply[9];
+
+    gyro.ownReply.data.accelerations[0] = (rawReply[10] << 8) | rawReply[11];
+    gyro.ownReply.data.accelerations[1] = (rawReply[12] << 8) | rawReply[13];
+    gyro.ownReply.data.accelerations[2] = (rawReply[14] << 8) | rawReply[15];
+
+    gyro.ownReply.data.temperatureRaw = (rawReply[16] << 8) | rawReply[17];
+  }
+}
+
+void AcsBoardPolling::mgmLis3Handler(MgmLis3& mgm) {
+  ReturnValue_t result;
+  acs::SimpleSensorMode mode;
+  bool mustPerformStartup = false;
+  {
+    MutexGuard mg(ipcLock);
+    mode = mgm.mode;
+    mustPerformStartup = mgm.performStartup;
+  }
+  if (mode == acs::SimpleSensorMode::NORMAL) {
+    if (mustPerformStartup) {
+      // To check valid communication, read back identification
+      // register which should always be the same value.
+      cmdBuf[0] = mgmLis3::readCommand(mgmLis3::IDENTIFY_DEVICE_REG_ADDR);
+      cmdBuf[1] = 0x00;
+      result = spiComIF.sendMessage(mgm.cookie, cmdBuf.data(), 2);
+      if (result != OK) {
+        mgm.replyResult = result;
+        return;
+      }
+      result = spiComIF.readReceivedMessage(mgm.cookie, &rawReply, &dummy);
+      if (result != OK) {
+        mgm.replyResult = result;
+        return;
+      }
+      if (rawReply[1] != mgmLis3::DEVICE_ID) {
+        sif::error << "AcsPollingTask: invalid MGM lis3 device ID" << std::endl;
+        mgm.replyResult = result;
+        return;
+      }
+      mgm.cfg[0] = mgmLis3::CTRL_REG1_DEFAULT;
+      mgm.cfg[1] = mgmLis3::CTRL_REG2_DEFAULT;
+      mgm.cfg[2] = mgmLis3::CTRL_REG3_DEFAULT;
+      mgm.cfg[3] = mgmLis3::CTRL_REG4_DEFAULT;
+      mgm.cfg[4] = mgmLis3::CTRL_REG5_DEFAULT;
+      cmdBuf[0] = mgmLis3::writeCommand(mgmLis3::CTRL_REG1, true);
+      std::memcpy(cmdBuf.data() + 1, mgm.cfg, 5);
+      result = spiComIF.sendMessage(mgm.cookie, cmdBuf.data(), 6);
+      if (result != OK) {
+        mgm.replyResult = result;
+        return;
+      }
+      // Done here. We can always read back config and data during periodic handling
+      mgm.performStartup = false;
+    }
+    cmdBuf[0] = mgmLis3::readCommand(mgmLis3::CTRL_REG1, true);
+    std::memset(cmdBuf.data() + 1, 0, mgmLis3::NR_OF_DATA_AND_CFG_REGISTERS);
+    result =
+        spiComIF.sendMessage(mgm.cookie, cmdBuf.data(), mgmLis3::NR_OF_DATA_AND_CFG_REGISTERS + 1);
+    if (result != returnvalue::OK) {
+      mgm.replyResult = result;
+      return;
+    }
+    result = spiComIF.readReceivedMessage(mgm.cookie, &rawReply, &dummy);
+    if (result != returnvalue::OK) {
+      mgm.replyResult = result;
+      return;
+    }
+    // Verify communication by re-checking config
+    if (rawReply[1] != mgm.cfg[0] or rawReply[2] != mgm.cfg[1] or rawReply[3] != mgm.cfg[2] or
+        rawReply[4] != mgm.cfg[3] or rawReply[5] != mgm.cfg[4]) {
+      mgm.replyResult = result;
+      return;
+    }
+    {
+      MutexGuard mg(ipcLock);
+      mgm.ownReply.dataWasSet = true;
+      mgm.ownReply.sensitivity = mgmLis3::getSensitivityFactor(mgmLis3::getSensitivity(mgm.cfg[1]));
+      mgm.ownReply.mgmValuesRaw[0] =
+          (rawReply[mgmLis3::X_HIGHBYTE_IDX] << 8) | rawReply[mgmLis3::X_LOWBYTE_IDX];
+      mgm.ownReply.mgmValuesRaw[1] =
+          (rawReply[mgmLis3::Y_HIGHBYTE_IDX] << 8) | rawReply[mgmLis3::Y_LOWBYTE_IDX];
+      mgm.ownReply.mgmValuesRaw[2] =
+          (rawReply[mgmLis3::Z_HIGHBYTE_IDX] << 8) | rawReply[mgmLis3::Z_LOWBYTE_IDX];
+    }
+    // Read tempetature
+    cmdBuf[0] = mgmLis3::readCommand(mgmLis3::TEMP_LOWBYTE, true);
+    result = spiComIF.sendMessage(mgm.cookie, cmdBuf.data(), 3);
+    if (result != returnvalue::OK) {
+      mgm.replyResult = result;
+      return;
+    }
+    result = spiComIF.readReceivedMessage(mgm.cookie, &rawReply, &dummy);
+    if (result != returnvalue::OK) {
+      mgm.replyResult = result;
+      return;
+    }
+    MutexGuard mg(ipcLock);
+    mgm.ownReply.temperatureWasSet = true;
+    mgm.ownReply.temperatureRaw = (rawReply[2] << 8) | rawReply[1];
+  }
+}
+
+void AcsBoardPolling::mgmRm3100Handler(MgmRm3100& mgm) {
+  ReturnValue_t result;
+  acs::SimpleSensorMode mode;
+  bool mustPerformStartup = false;
+  {
+    MutexGuard mg(ipcLock);
+    mode = mgm.mode;
+    mustPerformStartup = mgm.performStartup;
+  }
+  if (mode == acs::SimpleSensorMode::NORMAL) {
+    if (mustPerformStartup) {
+      // Configure CMM first
+      cmdBuf[0] = mgmRm3100::CMM_REGISTER;
+      cmdBuf[1] = mgmRm3100::CMM_VALUE;
+      result = spiComIF.sendMessage(mgm.cookie, cmdBuf.data(), 2);
+      if (result != OK) {
+        mgm.replyResult = result;
+        return;
+      }
+      // Read back register
+      cmdBuf[0] = mgmRm3100::CMM_REGISTER | mgmRm3100::READ_MASK;
+      cmdBuf[1] = 0;
+      result = spiComIF.sendMessage(mgm.cookie, cmdBuf.data(), 2);
+      if (result != OK) {
+        mgm.replyResult = result;
+        return;
+      }
+      result = spiComIF.readReceivedMessage(mgm.cookie, &rawReply, &dummy);
+      if (result != OK) {
+        mgm.replyResult = result;
+        return;
+      }
+      if (rawReply[1] != mgmRm3100::CMM_VALUE) {
+        sif::error << "AcsBoardPolling: MGM RM3100 read back CMM invalid" << std::endl;
+        mgm.replyResult = result;
+        return;
+      }
+      // Configure TMRC register
+      cmdBuf[0] = mgmRm3100::TMRC_REGISTER;
+      // hardcoded for now
+      cmdBuf[1] = mgm.tmrcValue;
+      result = spiComIF.sendMessage(mgm.cookie, cmdBuf.data(), 2);
+      if (result != OK) {
+        mgm.replyResult = result;
+        return;
+      }
+      // Read back and verify value
+      cmdBuf[0] = mgmRm3100::TMRC_REGISTER | mgmRm3100::READ_MASK;
+      cmdBuf[1] = 0;
+      result = spiComIF.sendMessage(mgm.cookie, cmdBuf.data(), 2);
+      if (result != OK) {
+        mgm.replyResult = result;
+        return;
+      }
+      result = spiComIF.readReceivedMessage(mgm.cookie, &rawReply, &dummy);
+      if (result != OK) {
+        mgm.replyResult = result;
+        return;
+      }
+      if (rawReply[1] != mgm.tmrcValue) {
+        sif::error << "AcsBoardPolling: MGM RM3100 read back TMRC invalid" << std::endl;
+        mgm.replyResult = result;
+        return;
+      }
+      mgm.performStartup = false;
+    }
+    // Regular read operation
+    cmdBuf[0] = mgmRm3100::MEASUREMENT_REG_START | mgmRm3100::READ_MASK;
+    std::memset(cmdBuf.data() + 1, 0, 9);
+    result = spiComIF.sendMessage(mgm.cookie, cmdBuf.data(), 10);
+    if (result != OK) {
+      mgm.replyResult = result;
+      return;
+    }
+    result = spiComIF.readReceivedMessage(mgm.cookie, &rawReply, &dummy);
+    if (result != OK) {
+      mgm.replyResult = result;
+      return;
+    }
+    MutexGuard mg(ipcLock);
+    for (uint8_t idx = 0; idx < 3; idx++) {
+      // Hardcoded, but note that the gain depends on the cycle count
+      // value which is configurable!
+      mgm.ownReply.scaleFactors[idx] = 1.0 / mgmRm3100::DEFAULT_GAIN;
+    }
+    mgm.ownReply.dataWasRead = true;
+    // Bitshift trickery to account for 24 bit signed value.
+    mgm.ownReply.mgmValuesRaw[0] =
+        ((rawReply[1] << 24) | (rawReply[2] << 16) | (rawReply[3] << 8)) >> 8;
+    mgm.ownReply.mgmValuesRaw[1] =
+        ((rawReply[4] << 24) | (rawReply[5] << 16) | (rawReply[6] << 8)) >> 8;
+    mgm.ownReply.mgmValuesRaw[2] =
+        ((rawReply[7] << 24) | (rawReply[8] << 16) | (rawReply[9] << 8)) >> 8;
+  }
+}

linux/devices/AcsBoardPolling.h

@@ -0,0 +1,88 @@
+#ifndef LINUX_DEVICES_ACSBOARDPOLLING_H_
+#define LINUX_DEVICES_ACSBOARDPOLLING_H_
+
+#include <fsfw/devicehandlers/DeviceCommunicationIF.h>
+#include <fsfw/objectmanager/SystemObject.h>
+#include <fsfw/tasks/ExecutableObjectIF.h>
+#include <fsfw/tasks/SemaphoreIF.h>
+#include <fsfw_hal/devicehandlers/devicedefinitions/mgmRm3100Helpers.h>
+#include <fsfw_hal/linux/spi/SpiComIF.h>
+#include <mission/devices/devicedefinitions/acsPolling.h>
+#include <mission/devices/devicedefinitions/gyroAdisHelpers.h>
+
+class AcsBoardPolling : public SystemObject,
+                        public ExecutableObjectIF,
+                        public DeviceCommunicationIF {
+ public:
+  AcsBoardPolling(object_id_t objectId, SpiComIF& lowLevelComIF, GpioIF& gpioIF);
+
+  ReturnValue_t performOperation(uint8_t operationCode) override;
+  ReturnValue_t initialize() override;
+
+ private:
+  enum class InternalState { IDLE, BUSY } state = InternalState::IDLE;
+  MutexIF* ipcLock;
+  SemaphoreIF* semaphore;
+  std::array<uint8_t, 32> cmdBuf;
+
+  struct DevBase {
+    SpiCookie* cookie = nullptr;
+    bool performStartup = false;
+    acs::SimpleSensorMode mode = acs::SimpleSensorMode::OFF;
+    ReturnValue_t replyResult = returnvalue::OK;
+  };
+
+  struct GyroAdis : public DevBase {
+    adis1650x::Type type;
+    Countdown countdown;
+    acs::Adis1650XReply ownReply;
+    acs::Adis1650XReply readerReply;
+  };
+  GyroAdis gyro0Adis{};
+  GyroAdis gyro2Adis{};
+
+  struct GyroL3g : public DevBase {
+    uint8_t sensorCfg[5];
+    acs::GyroL3gReply ownReply;
+    acs::GyroL3gReply readerReply;
+  };
+  GyroL3g gyro1L3g{};
+  GyroL3g gyro3L3g{};
+
+  struct MgmRm3100 : public DevBase {
+    uint8_t tmrcValue = mgmRm3100::TMRC_DEFAULT_37HZ_VALUE;
+    acs::MgmRm3100Reply ownReply;
+    acs::MgmRm3100Reply readerReply;
+  };
+  MgmRm3100 mgm1Rm3100;
+  MgmRm3100 mgm3Rm3100;
+
+  struct MgmLis3 : public DevBase {
+    uint8_t cfg[5]{};
+    acs::MgmLis3Reply ownReply;
+    acs::MgmLis3Reply readerReply;
+  };
+  MgmLis3 mgm0Lis3;
+  MgmLis3 mgm2Lis3;
+
+  uint8_t* rawReply = nullptr;
+  size_t dummy = 0;
+
+  SpiComIF& spiComIF;
+  GpioIF& gpioIF;
+
+  ReturnValue_t initializeInterface(CookieIF* cookie) override;
+  ReturnValue_t sendMessage(CookieIF* cookie, const uint8_t* sendData, size_t sendLen) override;
+  ReturnValue_t getSendSuccess(CookieIF* cookie) override;
+  ReturnValue_t requestReceiveMessage(CookieIF* cookie, size_t requestLen) override;
+  ReturnValue_t readReceivedMessage(CookieIF* cookie, uint8_t** buffer, size_t* size) override;
+
+  void gyroL3gHandler(GyroL3g& l3g);
+  void gyroAdisHandler(GyroAdis& gyro);
+  void mgmLis3Handler(MgmLis3& mgm);
+  void mgmRm3100Handler(MgmRm3100& mgm);
+  // Special readout: 16us stall time between small 2 byte transfers.
+  ReturnValue_t readAdisCfg(SpiCookie& spiCookie, size_t transferLen);
+};
+
+#endif /* LINUX_DEVICES_ACSBOARDPOLLING_H_ */

linux/devices/CMakeLists.txt

@@ -3,8 +3,15 @@ if(EIVE_BUILD_GPSD_GPS_HANDLER)
 endif()
 
 target_sources(
-  ${OBSW_NAME} PRIVATE Max31865RtdLowlevelHandler.cpp ScexUartReader.cpp
-                       ScexDleParser.cpp ScexHelper.cpp RwPollingTask.cpp)
+  ${OBSW_NAME}
+  PRIVATE Max31865RtdPolling.cpp
+          ScexUartReader.cpp
+          ImtqPollingTask.cpp
+          SusPolling.cpp
+          ScexDleParser.cpp
+          ScexHelper.cpp
+          RwPollingTask.cpp
+          AcsBoardPolling.cpp)
 
 add_subdirectory(ploc)
 

linux/devices/GpsHyperionLinuxController.cpp

@@ -172,20 +172,10 @@ bool GpsHyperionLinuxController::readGpsDataFromGpsd() {
         return false;
       }
       oneShotSwitches.gpsReadFailedSwitch = true;
-      // did not event get mode, nothing to see.
-      if (MODE_SET != (MODE_SET & gps.set)) {
-        if (mode != MODE_OFF) {
-          if (maxTimeToReachFix.hasTimedOut() and oneShotSwitches.cantGetFixSwitch) {
-            sif::warning
-                << "GPSHyperionHandler::readGpsDataFromGpsd: No mode could be set in allowed "
-                << maxTimeToReachFix.timeout / 1000 << " seconds" << std::endl;
-            triggerEvent(GpsHyperion::CANT_GET_FIX, maxTimeToReachFix.timeout);
-            oneShotSwitches.cantGetFixSwitch = false;
-          }
-          // Mode is on, so do next read immediately
-          return true;
-        }
-        // GPS device is off anyway, so do other handling
+      ReturnValue_t result = handleGpsReadData();
+      if (result == returnvalue::OK) {
+        return true;
+      } else {
         return false;
       }
       noModeSetCntr = 0;
@@ -197,11 +187,26 @@ bool GpsHyperionLinuxController::readGpsDataFromGpsd() {
                   "SHM read not implemented"
                << std::endl;
   }
-  handleGpsReadData();
   return true;
 }
 
 ReturnValue_t GpsHyperionLinuxController::handleGpsReadData() {
+  bool modeIsSet = true;
+  if (MODE_SET != (MODE_SET & gps.set)) {
+    if (mode != MODE_OFF) {
+      if (maxTimeToReachFix.hasTimedOut() and oneShotSwitches.cantGetFixSwitch) {
+        sif::warning << "GpsHyperionLinuxController: No mode could be set in allowed "
+                     << maxTimeToReachFix.timeout / 1000 << " seconds" << std::endl;
+        triggerEvent(GpsHyperion::CANT_GET_FIX, maxTimeToReachFix.timeout);
+        oneShotSwitches.cantGetFixSwitch = false;
+      }
+      modeIsSet = false;
+    } else {
+      // GPS device is off anyway, so do other handling
+      return returnvalue::FAILED;
+    }
+  }
+
   PoolReadGuard pg(&gpsSet);
   if (pg.getReadResult() != returnvalue::OK) {
 #if FSFW_VERBOSE_LEVEL >= 1
@@ -211,66 +216,93 @@ ReturnValue_t GpsHyperionLinuxController::handleGpsReadData() {
   }
 
   bool validFix = false;
-  // 0: Not seen, 1: No fix, 2: 2D-Fix, 3: 3D-Fix
-  if (gps.fix.mode == 2 or gps.fix.mode == 3) {
-    validFix = true;
-  }
-  if (gpsSet.fixMode.value != gps.fix.mode) {
-    triggerEvent(GpsHyperion::GPS_FIX_CHANGE, gpsSet.fixMode.value, gps.fix.mode);
-  }
-  gpsSet.fixMode.value = gps.fix.mode;
-  if (gps.fix.mode == 0 or gps.fix.mode == 1) {
-    if (modeCommanded and maxTimeToReachFix.hasTimedOut()) {
-      // We are supposed to be on and functioning, but no fix was found
-      if (mode == MODE_ON or mode == MODE_NORMAL) {
-        mode = MODE_OFF;
-      }
-      modeCommanded = false;
+  if (modeIsSet) {
+    // 0: Not seen, 1: No fix, 2: 2D-Fix, 3: 3D-Fix
+    if (gps.fix.mode == 2 or gps.fix.mode == 3) {
+      validFix = true;
+    }
+    if (gpsSet.fixMode.value != gps.fix.mode) {
+      triggerEvent(GpsHyperion::GPS_FIX_CHANGE, gpsSet.fixMode.value, gps.fix.mode);
+    }
+    gpsSet.fixMode.value = gps.fix.mode;
+    if (gps.fix.mode == 0 or gps.fix.mode == 1) {
+      if (modeCommanded and maxTimeToReachFix.hasTimedOut()) {
+        // We are supposed to be on and functioning, but no fix was found
+        if (mode == MODE_ON or mode == MODE_NORMAL) {
+          mode = MODE_OFF;
+        }
+        modeCommanded = false;
+      }
+    }
+  }
+  gpsSet.fixMode.setValid(modeIsSet);
+
+  // Only set on specific messages, so only set a valid flag to invalid
+  // if not set for more than a full message set (10 messages here)
+  if (SATELLITE_SET == (SATELLITE_SET & gps.set)) {
+    gpsSet.satInUse.value = gps.satellites_used;
+    gpsSet.satInView.value = gps.satellites_visible;
+    if (not gpsSet.satInUse.isValid()) {
+      gpsSet.satInUse.setValid(true);
+      gpsSet.satInView.setValid(true);
+    }
+    satNotSetCounter = 0;
+  } else {
+    satNotSetCounter++;
+    if (gpsSet.satInUse.isValid() and satNotSetCounter >= 10) {
+      gpsSet.satInUse.setValid(false);
+      gpsSet.satInView.setValid(false);
     }
-    gpsSet.setValidity(false, true);
-  } else if (gps.satellites_used > 0 && validFix && mode != MODE_OFF) {
-    gpsSet.setValidity(true, true);
   }
 
-  gpsSet.satInUse.value = gps.satellites_used;
-  gpsSet.satInView.value = gps.satellites_visible;
-
+  // LATLON is set for every message, no need for a counter
   bool latValid = false;
-  if (std::isfinite(gps.fix.latitude)) {
-    // Negative latitude -> South direction
-    gpsSet.latitude.value = gps.fix.latitude;
-    if (gps.fix.mode >= 2) {
-      latValid = true;
+  bool longValid = false;
+  if (LATLON_SET == (LATLON_SET & gps.set)) {
+    if (std::isfinite(gps.fix.latitude)) {
+      // Negative latitude -> South direction
+      gpsSet.latitude.value = gps.fix.latitude;
+      // As specified in gps.h: Only valid if mode >= 2
+      if (gps.fix.mode >= 2) {
+        latValid = true;
+      }
+    }
+
+    if (std::isfinite(gps.fix.longitude)) {
+      // Negative longitude -> West direction
+      gpsSet.longitude.value = gps.fix.longitude;
+      // As specified in gps.h: Only valid if mode >= 2
+      if (gps.fix.mode >= 2) {
+        longValid = true;
+      }
     }
   }
   gpsSet.latitude.setValid(latValid);
+  gpsSet.longitude.setValid(longValid);
 
-  bool longValid = false;
-  if (std::isfinite(gps.fix.longitude)) {
-    // Negative longitude -> West direction
-    gpsSet.longitude.value = gps.fix.longitude;
-    if (gps.fix.mode >= 2) {
-      longValid = true;
-    }
-  }
-  gpsSet.latitude.setValid(longValid);
-
+  // ALTITUDE is set for every message, no need for a counter
   bool altitudeValid = false;
-  if (std::isfinite(gps.fix.altitude)) {
+  if (ALTITUDE_SET == (ALTITUDE_SET & gps.set) && std::isfinite(gps.fix.altitude)) {
     gpsSet.altitude.value = gps.fix.altitude;
+    // As specified in gps.h: Only valid if mode == 3
     if (gps.fix.mode == 3) {
       altitudeValid = true;
     }
   }
   gpsSet.altitude.setValid(altitudeValid);
 
-  if (std::isfinite(gps.fix.speed)) {
+  // SPEED is set for every message, no need for a counter
+  bool speedValid = false;
+  if (SPEED_SET == (SPEED_SET & gps.set) && std::isfinite(gps.fix.speed)) {
     gpsSet.speed.value = gps.fix.speed;
-  } else {
-    gpsSet.speed.setValid(false);
+    speedValid = true;
   }
+  gpsSet.speed.setValid(speedValid);
 
+  // TIME is set for every message, no need for a counter
+  bool timeValid = false;
   if (TIME_SET == (TIME_SET & gps.set)) {
+    timeValid = true;
     timeval time = {};
 #if LIBGPS_VERSION_MINOR <= 17
     gpsSet.unixSeconds.value = std::floor(gps.fix.time);
@@ -294,15 +326,14 @@ ReturnValue_t GpsHyperionLinuxController::handleGpsReadData() {
     gpsSet.hours = timeOfDay.hour;
     gpsSet.minutes = timeOfDay.minute;
     gpsSet.seconds = timeOfDay.second;
-  } else {
-    gpsSet.unixSeconds.setValid(false);
-    gpsSet.year.setValid(false);
-    gpsSet.month.setValid(false);
-    gpsSet.day.setValid(false);
-    gpsSet.hours.setValid(false);
-    gpsSet.minutes.setValid(false);
-    gpsSet.seconds.setValid(false);
   }
+  gpsSet.unixSeconds.setValid(timeValid);
+  gpsSet.year.setValid(timeValid);
+  gpsSet.month.setValid(timeValid);
+  gpsSet.day.setValid(timeValid);
+  gpsSet.hours.setValid(timeValid);
+  gpsSet.minutes.setValid(timeValid);
+  gpsSet.seconds.setValid(timeValid);
 
   if (debugHyperionGps) {
     sif::info << "-- Hyperion GPS Data --" << std::endl;

linux/devices/GpsHyperionLinuxController.h

@@ -61,6 +61,8 @@ class GpsHyperionLinuxController : public ExtendedControllerBase {
   Countdown maxTimeToReachFix = Countdown(MAX_SECONDS_TO_REACH_FIX * 1000);
   bool modeCommanded = false;
   bool timeInit = false;
+  uint8_t satNotSetCounter = 0;
+
 #if OBSW_THREAD_TRACING == 1
   uint32_t opCounter = 0;
 #endif

linux/devices/ImtqPollingTask.cpp

@@ -0,0 +1,433 @@
+#include "ImtqPollingTask.h"
+
+#include <fcntl.h>
+#include <fsfw/tasks/SemaphoreFactory.h>
+#include <fsfw/tasks/TaskFactory.h>
+#include <fsfw/timemanager/Stopwatch.h>
+#include <fsfw_hal/linux/UnixFileGuard.h>
+#include <linux/i2c-dev.h>
+#include <sys/ioctl.h>
+
+#include "fsfw/FSFW.h"
+
+ImtqPollingTask::ImtqPollingTask(object_id_t imtqPollingTask) : SystemObject(imtqPollingTask) {
+  semaphore = SemaphoreFactory::instance()->createBinarySemaphore();
+  semaphore->acquire();
+  ipcLock = MutexFactory::instance()->createMutex();
+  bufLock = MutexFactory::instance()->createMutex();
+}
+
+ReturnValue_t ImtqPollingTask::performOperation(uint8_t operationCode) {
+  while (true) {
+    ipcLock->lockMutex();
+    state = InternalState::IDLE;
+    ipcLock->unlockMutex();
+    semaphore->acquire();
+
+    comStatus = returnvalue::OK;
+    // Stopwatch watch;
+    switch (currentRequest) {
+      case imtq::RequestType::MEASURE_NO_ACTUATION: {
+        handleMeasureStep();
+        break;
+      }
+      case imtq::RequestType::ACTUATE: {
+        handleActuateStep();
+        break;
+      }
+    };
+  }
+  return returnvalue::OK;
+}
+
+void ImtqPollingTask::handleMeasureStep() {
+  size_t replyLen = 0;
+  uint8_t* replyPtr;
+  ImtqRepliesDefault replies(replyBuf.data());
+  // Can be used later to verify correct timing (e.g. all data has been read)
+  clearReadFlagsDefault(replies);
+  auto i2cCmdExecMeasure = [&](imtq::CC::CC cc) {
+    ccToReplyPtrMeasure(replies, cc, &replyPtr, replyLen);
+    return i2cCmdExecDefault(cc, replyPtr, replyLen, imtq::MGM_MEASUREMENT_LOW_LEVEL_ERROR);
+  };
+
+  cmdLen = 1;
+  cmdBuf[0] = imtq::CC::GET_SYSTEM_STATE;
+  if (i2cCmdExecMeasure(imtq::CC::GET_SYSTEM_STATE) != returnvalue::OK) {
+    return;
+  }
+
+  ignoreNextActuateRequest =
+      (replies.getSystemState()[2] == static_cast<uint8_t>(imtq::mode::SELF_TEST));
+  if (ignoreNextActuateRequest) {
+    // Do not command anything until self-test is done.
+    return;
+  }
+
+  if (specialRequest != imtq::SpecialRequest::NONE) {
+    auto executeSelfTest = [&](imtq::selfTest::Axis axis) {
+      cmdBuf[0] = imtq::CC::SELF_TEST_CMD;
+      cmdBuf[1] = axis;
+      return i2cCmdExecMeasure(imtq::CC::SELF_TEST_CMD);
+    };
+    // If a self-test is already ongoing, ignore the request.
+    if (replies.getSystemState()[2] != static_cast<uint8_t>(imtq::mode::SELF_TEST)) {
+      switch (specialRequest) {
+        case (imtq::SpecialRequest::DO_SELF_TEST_POS_X): {
+          executeSelfTest(imtq::selfTest::Axis::X_POSITIVE);
+          break;
+        }
+        case (imtq::SpecialRequest::DO_SELF_TEST_NEG_X): {
+          executeSelfTest(imtq::selfTest::Axis::X_NEGATIVE);
+          break;
+        }
+        case (imtq::SpecialRequest::DO_SELF_TEST_POS_Y): {
+          executeSelfTest(imtq::selfTest::Axis::Y_POSITIVE);
+          break;
+        }
+        case (imtq::SpecialRequest::DO_SELF_TEST_NEG_Y): {
+          executeSelfTest(imtq::selfTest::Axis::Y_NEGATIVE);
+          break;
+        }
+        case (imtq::SpecialRequest::DO_SELF_TEST_POS_Z): {
+          executeSelfTest(imtq::selfTest::Axis::Z_POSITIVE);
+          break;
+        }
+        case (imtq::SpecialRequest::DO_SELF_TEST_NEG_Z): {
+          executeSelfTest(imtq::selfTest::Axis::Z_NEGATIVE);
+          break;
+        }
+        case (imtq::SpecialRequest::GET_SELF_TEST_RESULT): {
+          cmdBuf[0] = imtq::CC::GET_SELF_TEST_RESULT;
+          i2cCmdExecMeasure(imtq::CC::GET_SELF_TEST_RESULT);
+          break;
+        }
+        default: {
+          // Should never happen
+          break;
+        }
+      }
+      // We are done. Only request self test or results here.
+      return;
+    }
+  }
+
+  cmdBuf[0] = imtq::CC::START_MTM_MEASUREMENT;
+  if (i2cCmdExecMeasure(imtq::CC::START_MTM_MEASUREMENT) != returnvalue::OK) {
+    return;
+  }
+  // Takes a bit of time to take measurements. Subtract a bit because of the delay of previous
+  // commands.
+  TaskFactory::delayTask(currentIntegrationTimeMs);
+
+  cmdBuf[0] = imtq::CC::GET_RAW_MTM_MEASUREMENT;
+  if (i2cCmdExecMeasure(imtq::CC::GET_RAW_MTM_MEASUREMENT) != returnvalue::OK) {
+    return;
+  }
+
+  cmdBuf[0] = imtq::CC::GET_ENG_HK_DATA;
+  if (i2cCmdExecMeasure(imtq::CC::GET_ENG_HK_DATA) != returnvalue::OK) {
+    return;
+  }
+
+  cmdBuf[0] = imtq::CC::GET_CAL_MTM_MEASUREMENT;
+  if (i2cCmdExecMeasure(imtq::CC::GET_CAL_MTM_MEASUREMENT) != returnvalue::OK) {
+    return;
+  }
+  // sif::debug << "measure done" << std::endl;
+  return;
+}
+
+void ImtqPollingTask::handleActuateStep() {
+  uint8_t* replyPtr = nullptr;
+  size_t replyLen = 0;
+  // No point when self-test mode is active.
+  if (ignoreNextActuateRequest) {
+    return;
+  }
+  ImtqRepliesWithTorque replies(replyBufActuation.data());
+  // Can be used later to verify correct timing (e.g. all data has been read)
+  clearReadFlagsWithTorque(replies);
+  auto i2cCmdExecActuate = [&](imtq::CC::CC cc) {
+    ccToReplyPtrActuate(replies, cc, &replyPtr, replyLen);
+    return i2cCmdExecDefault(cc, replyPtr, replyLen, imtq::ACTUATE_CMD_LOW_LEVEL_ERROR);
+  };
+  buildDipoleCommand();
+  if (i2cCmdExecActuate(imtq::CC::START_ACTUATION_DIPOLE) != returnvalue::OK) {
+    return;
+  }
+
+  cmdLen = 1;
+  cmdBuf[0] = imtq::CC::START_MTM_MEASUREMENT;
+  if (i2cCmdExecActuate(imtq::CC::START_MTM_MEASUREMENT) != returnvalue::OK) {
+    return;
+  }
+
+  TaskFactory::delayTask(currentIntegrationTimeMs);
+
+  cmdBuf[0] = imtq::CC::GET_RAW_MTM_MEASUREMENT;
+  if (i2cCmdExecActuate(imtq::CC::GET_RAW_MTM_MEASUREMENT) != returnvalue::OK) {
+    return;
+  }
+  cmdBuf[0] = imtq::CC::GET_ENG_HK_DATA;
+  if (i2cCmdExecActuate(imtq::CC::GET_ENG_HK_DATA) != returnvalue::OK) {
+    return;
+  }
+  // sif::debug << "measure with torque done" << std::endl;
+  return;
+}
+
+ReturnValue_t ImtqPollingTask::initialize() { return returnvalue::OK; }
+
+ReturnValue_t ImtqPollingTask::initializeInterface(CookieIF* cookie) {
+  i2cCookie = dynamic_cast<I2cCookie*>(cookie);
+  if (i2cCookie == nullptr) {
+    sif::error << "ImtqPollingTask::initializeInterface: Invalid I2C cookie" << std::endl;
+    return returnvalue::FAILED;
+  }
+  i2cDev = i2cCookie->getDeviceFile().c_str();
+  i2cAddr = i2cCookie->getAddress();
+  return returnvalue::OK;
+}
+
+ReturnValue_t ImtqPollingTask::sendMessage(CookieIF* cookie, const uint8_t* sendData,
+                                           size_t sendLen) {
+  ImtqRequest request(sendData, sendLen);
+  {
+    MutexGuard mg(ipcLock);
+    currentRequest = request.getRequestType();
+    if (currentRequest == imtq::RequestType::ACTUATE) {
+      std::memcpy(dipoles, request.getDipoles(), 6);
+      torqueDuration = request.getTorqueDuration();
+    }
+    specialRequest = request.getSpecialRequest();
+    if (state != InternalState::IDLE) {
+      return returnvalue::FAILED;
+    }
+    state = InternalState::BUSY;
+  }
+  semaphore->release();
+
+  return returnvalue::OK;
+}
+
+ReturnValue_t ImtqPollingTask::getSendSuccess(CookieIF* cookie) { return returnvalue::OK; }
+
+ReturnValue_t ImtqPollingTask::requestReceiveMessage(CookieIF* cookie, size_t requestLen) {
+  return returnvalue::OK;
+}
+
+void ImtqPollingTask::ccToReplyPtrMeasure(ImtqRepliesDefault& replies, imtq::CC::CC cc,
+                                          uint8_t** replyBuf, size_t& replyLen) {
+  replyLen = imtq::getReplySize(cc);
+  switch (cc) {
+    case (imtq::CC::CC::GET_ENG_HK_DATA): {
+      *replyBuf = replies.engHk;
+      break;
+    }
+    case (imtq::CC::CC::SOFTWARE_RESET): {
+      *replyBuf = replies.swReset;
+      break;
+    }
+    case (imtq::CC::CC::GET_SYSTEM_STATE): {
+      *replyBuf = replies.systemState;
+      break;
+    }
+    case (imtq::CC::CC::START_MTM_MEASUREMENT): {
+      *replyBuf = replies.startMtmMeasurement;
+      break;
+    }
+    case (imtq::CC::CC::GET_RAW_MTM_MEASUREMENT): {
+      *replyBuf = replies.rawMgmMeasurement;
+      break;
+    }
+    case (imtq::CC::CC::GET_CAL_MTM_MEASUREMENT): {
+      *replyBuf = replies.calibMgmMeasurement;
+      break;
+    }
+    default: {
+      *replyBuf = replies.specialRequestReply;
+      break;
+    }
+  }
+}
+
+void ImtqPollingTask::ccToReplyPtrActuate(ImtqRepliesWithTorque& replies, imtq::CC::CC cc,
+                                          uint8_t** replyBuf, size_t& replyLen) {
+  replyLen = imtq::getReplySize(cc);
+  switch (cc) {
+    case (imtq::CC::CC::START_ACTUATION_DIPOLE): {
+      *replyBuf = replies.dipoleActuation;
+      break;
+    }
+    case (imtq::CC::CC::GET_ENG_HK_DATA): {
+      *replyBuf = replies.engHk;
+      break;
+    }
+    case (imtq::CC::CC::START_MTM_MEASUREMENT): {
+      *replyBuf = replies.startMtmMeasurement;
+      break;
+    }
+    case (imtq::CC::CC::GET_RAW_MTM_MEASUREMENT): {
+      *replyBuf = replies.rawMgmMeasurement;
+      break;
+    }
+    default: {
+      *replyBuf = nullptr;
+      replyLen = 0;
+      break;
+    }
+  }
+}
+size_t ImtqPollingTask::getExchangeBufLen(imtq::SpecialRequest specialRequest) {
+  size_t baseLen = ImtqRepliesDefault::BASE_LEN;
+  switch (specialRequest) {
+    case (imtq::SpecialRequest::NONE):
+    case (imtq::SpecialRequest::DO_SELF_TEST_POS_X):
+    case (imtq::SpecialRequest::DO_SELF_TEST_NEG_X):
+    case (imtq::SpecialRequest::DO_SELF_TEST_POS_Y):
+    case (imtq::SpecialRequest::DO_SELF_TEST_NEG_Y):
+    case (imtq::SpecialRequest::DO_SELF_TEST_POS_Z):
+    case (imtq::SpecialRequest::DO_SELF_TEST_NEG_Z): {
+      break;
+    }
+    case (imtq::SpecialRequest::GET_SELF_TEST_RESULT): {
+      baseLen += imtq::replySize::SELF_TEST_RESULTS;
+      break;
+    }
+  }
+  return baseLen;
+}
+
+void ImtqPollingTask::buildDipoleCommand() {
+  cmdBuf[0] = imtq::CC::CC::START_ACTUATION_DIPOLE;
+  uint8_t* serPtr = cmdBuf.data() + 1;
+  size_t serLen = 0;
+  for (uint8_t idx = 0; idx < 3; idx++) {
+    SerializeAdapter::serialize(&dipoles[idx], &serPtr, &serLen, cmdBuf.size(),
+                                SerializeIF::Endianness::LITTLE);
+  }
+  SerializeAdapter::serialize(&torqueDuration, &serPtr, &serLen, cmdBuf.size(),
+                              SerializeIF::Endianness::LITTLE);
+  cmdLen = 1 + serLen;
+}
+
+ReturnValue_t ImtqPollingTask::readReceivedMessage(CookieIF* cookie, uint8_t** buffer,
+                                                   size_t* size) {
+  imtq::RequestType currentRequest;
+  {
+    MutexGuard mg(ipcLock);
+    currentRequest = this->currentRequest;
+  }
+
+  size_t replyLen = 0;
+  MutexGuard mg(bufLock);
+  if (currentRequest == imtq::RequestType::MEASURE_NO_ACTUATION) {
+    replyLen = getExchangeBufLen(specialRequest);
+    memcpy(exchangeBuf.data(), replyBuf.data(), replyLen);
+  } else {
+    replyLen = ImtqRepliesWithTorque::BASE_LEN;
+    memcpy(exchangeBuf.data(), replyBufActuation.data(), replyLen);
+  }
+  *buffer = exchangeBuf.data();
+  *size = replyLen;
+  return comStatus;
+}
+
+void ImtqPollingTask::clearReadFlagsDefault(ImtqRepliesDefault& replies) {
+  replies.calibMgmMeasurement[0] = false;
+  replies.rawMgmMeasurement[0] = false;
+  replies.systemState[0] = false;
+  replies.specialRequestReply[0] = false;
+  replies.engHk[0] = false;
+}
+
+ReturnValue_t ImtqPollingTask::i2cCmdExecDefault(imtq::CC::CC cc, uint8_t* replyPtr,
+                                                 size_t replyLen, ReturnValue_t comErrIfFails) {
+  ReturnValue_t res = performI2cFullRequest(replyPtr + 1, replyLen);
+  if (res != returnvalue::OK) {
+    sif::error << "IMTQ: I2C transaction for command 0x" << std::hex << std::setw(2) << cc
+               << " failed" << std::dec << std::endl;
+    comStatus = comErrIfFails;
+    return returnvalue::FAILED;
+  }
+  if (replyPtr[1] != cc) {
+    sif::warning << "IMTQ: Unexpected CC 0x" << std::hex << std::setw(2)
+                 << static_cast<int>(replyPtr[1]) << " for command 0x" << cc << std::dec
+                 << std::endl;
+    comStatus = comErrIfFails;
+    return returnvalue::FAILED;
+  }
+  replyPtr[0] = true;
+  return returnvalue::OK;
+}
+
+void ImtqPollingTask::clearReadFlagsWithTorque(ImtqRepliesWithTorque& replies) {
+  replies.dipoleActuation[0] = false;
+  replies.engHk[0] = false;
+  replies.rawMgmMeasurement[0] = false;
+  replies.startMtmMeasurement[0] = false;
+}
+
+ReturnValue_t ImtqPollingTask::performI2cFullRequest(uint8_t* reply, size_t replyLen) {
+  int fd = 0;
+  if (cmdLen == 0 or reply == nullptr) {
+    return returnvalue::FAILED;
+  }
+
+  {
+    UnixFileGuard fileHelper(i2cDev, fd, O_RDWR, "ImtqPollingTask::performI2cFullRequest");
+    if (fileHelper.getOpenResult() != returnvalue::OK) {
+      return fileHelper.getOpenResult();
+    }
+    if (ioctl(fd, I2C_SLAVE, i2cAddr) < 0) {
+      sif::warning << "Opening IMTQ slave device failed with code " << errno << ": "
+                   << strerror(errno) << std::endl;
+    }
+
+    int written = write(fd, cmdBuf.data(), cmdLen);
+    if (written < 0) {
+      sif::error << "IMTQ: Failed to send with error code " << errno
+                 << ". Error description: " << strerror(errno) << std::endl;
+      return returnvalue::FAILED;
+    } else if (static_cast<size_t>(written) != cmdLen) {
+      sif::error << "IMTQ: Could not write all bytes" << std::endl;
+      return returnvalue::FAILED;
+    }
+  }
+#if FSFW_HAL_I2C_WIRETAPPING == 1
+  sif::info << "Sent I2C data to bus " << deviceFile << ":" << std::endl;
+  arrayprinter::print(sendData, sendLen);
+#endif
+
+  // wait 1 ms like specified in the datasheet. This is the time the IMTQ needs
+  // to prepare a reply.
+  usleep(1000);
+
+  {
+    UnixFileGuard fileHelper(i2cDev, fd, O_RDWR, "ImtqPollingTask::performI2cFullRequest");
+    if (fileHelper.getOpenResult() != returnvalue::OK) {
+      return fileHelper.getOpenResult();
+    }
+    if (ioctl(fd, I2C_SLAVE, i2cAddr) < 0) {
+      sif::warning << "Opening IMTQ slave device failed with code " << errno << ": "
+                   << strerror(errno) << std::endl;
+    }
+    MutexGuard mg(bufLock);
+    int readLen = read(fd, reply, replyLen);
+    if (readLen != static_cast<int>(replyLen)) {
+      if (readLen < 0) {
+        sif::warning << "IMTQ: Reading failed with error code " << errno << " | " << strerror(errno)
+                     << std::endl;
+      } else {
+        sif::warning << "IMTQ: Read only" << readLen << " from " << replyLen << " bytes"
+                     << std::endl;
+      }
+    }
+  }
+  if (reply[0] == 0xff or reply[1] == 0xff) {
+    sif::warning << "IMTQ: No reply available after 1 millisecond";
+    return NO_REPLY_AVAILABLE;
+  }
+  return returnvalue::OK;
+}

linux/devices/ImtqPollingTask.h

@@ -0,0 +1,70 @@
+#ifndef LINUX_DEVICES_IMTQPOLLINGTASK_H_
+#define LINUX_DEVICES_IMTQPOLLINGTASK_H_
+
+#include <fsfw/tasks/SemaphoreIF.h>
+#include <fsfw_hal/linux/i2c/I2cCookie.h>
+
+#include "fsfw/devicehandlers/DeviceCommunicationIF.h"
+#include "fsfw/objectmanager/SystemObject.h"
+#include "fsfw/tasks/ExecutableObjectIF.h"
+#include "mission/devices/devicedefinitions/imtqHelpers.h"
+
+class ImtqPollingTask : public SystemObject,
+                        public ExecutableObjectIF,
+                        public DeviceCommunicationIF {
+ public:
+  ImtqPollingTask(object_id_t imtqPollingTask);
+
+  ReturnValue_t performOperation(uint8_t operationCode) override;
+  ReturnValue_t initialize() override;
+
+ private:
+  static constexpr ReturnValue_t NO_REPLY_AVAILABLE = returnvalue::makeCode(2, 0);
+
+  enum class InternalState { IDLE, BUSY } state = InternalState::IDLE;
+  imtq::RequestType currentRequest = imtq::RequestType::MEASURE_NO_ACTUATION;
+
+  SemaphoreIF* semaphore;
+  ReturnValue_t comStatus = returnvalue::OK;
+  MutexIF* ipcLock;
+  MutexIF* bufLock;
+  I2cCookie* i2cCookie = nullptr;
+  const char* i2cDev = nullptr;
+  address_t i2cAddr = 0;
+  uint32_t currentIntegrationTimeMs = 10;
+  bool ignoreNextActuateRequest = false;
+
+  imtq::SpecialRequest specialRequest = imtq::SpecialRequest::NONE;
+  int16_t dipoles[3] = {};
+  uint16_t torqueDuration = 0;
+  // uint8_t startActuateRawBuf[3] = {};
+
+  std::array<uint8_t, 32> cmdBuf;
+  std::array<uint8_t, 524> replyBuf;
+  std::array<uint8_t, 524> replyBufActuation;
+  std::array<uint8_t, 524> exchangeBuf;
+  size_t cmdLen = 0;
+
+  // DeviceCommunicationIF overrides
+  ReturnValue_t initializeInterface(CookieIF* cookie) override;
+  ReturnValue_t sendMessage(CookieIF* cookie, const uint8_t* sendData, size_t sendLen) override;
+  ReturnValue_t getSendSuccess(CookieIF* cookie) override;
+  ReturnValue_t requestReceiveMessage(CookieIF* cookie, size_t requestLen) override;
+  ReturnValue_t readReceivedMessage(CookieIF* cookie, uint8_t** buffer, size_t* size) override;
+
+  void ccToReplyPtrMeasure(ImtqRepliesDefault& replies, imtq::CC::CC cc, uint8_t** replyBuf,
+                           size_t& replyLen);
+  void ccToReplyPtrActuate(ImtqRepliesWithTorque& replies, imtq::CC::CC cc, uint8_t** replyBuf,
+                           size_t& replyLen);
+  void clearReadFlagsDefault(ImtqRepliesDefault& replies);
+  void clearReadFlagsWithTorque(ImtqRepliesWithTorque& replies);
+  size_t getExchangeBufLen(imtq::SpecialRequest specialRequest);
+  void buildDipoleCommand();
+  void handleMeasureStep();
+  void handleActuateStep();
+  ReturnValue_t i2cCmdExecDefault(imtq::CC::CC cc, uint8_t* replyPtr, size_t replyLen,
+                                  ReturnValue_t comErrIfFails);
+  ReturnValue_t performI2cFullRequest(uint8_t* reply, size_t replyLen);
+};
+
+#endif /* LINUX_DEVICES_IMTQPOLLINGTASK_H_ */

linux/devices/Max31865RtdPolling.cpp

@@ -1,8 +1,7 @@
-#include "Max31865RtdLowlevelHandler.h"
-
 #include <fsfw/tasks/TaskFactory.h>
 #include <fsfw/timemanager/Stopwatch.h>
 #include <fsfw_hal/linux/spi/ManualCsLockGuard.h>
+#include <linux/devices/Max31865RtdPolling.h>
 
 #define OBSW_RTD_AUTO_MODE 1
 
@@ -17,12 +16,13 @@ static constexpr uint8_t BASE_CFG =
     (MAX31865::ConvMode::NORM_OFF << MAX31865::CfgBitPos::CONV_MODE);
 #endif
 
-Max31865RtdReader::Max31865RtdReader(object_id_t objectId, SpiComIF* lowLevelComIF, GpioIF* gpioIF)
+Max31865RtdPolling::Max31865RtdPolling(object_id_t objectId, SpiComIF* lowLevelComIF,
+                                       GpioIF* gpioIF)
     : SystemObject(objectId), rtds(EiveMax31855::NUM_RTDS), comIF(lowLevelComIF), gpioIF(gpioIF) {
   readerMutex = MutexFactory::instance()->createMutex();
 }
 
-ReturnValue_t Max31865RtdReader::performOperation(uint8_t operationCode) {
+ReturnValue_t Max31865RtdPolling::performOperation(uint8_t operationCode) {
   using namespace MAX31865;
   ReturnValue_t result = returnvalue::OK;
   static_cast<void>(result);
@@ -49,17 +49,16 @@ ReturnValue_t Max31865RtdReader::performOperation(uint8_t operationCode) {
   return periodicReadHandling();
 }
 
-bool Max31865RtdReader::rtdIsActive(uint8_t idx) {
+bool Max31865RtdPolling::rtdIsActive(uint8_t idx) {
   if (rtds[idx]->on and rtds[idx]->db.active and rtds[idx]->db.configured) {
     return true;
   }
   return false;
 }
 
-bool Max31865RtdReader::periodicInitHandling() {
+bool Max31865RtdPolling::periodicInitHandling() {
   using namespace MAX31865;
   ReturnValue_t result = returnvalue::OK;
-
   for (auto& rtd : rtds) {
     if (rtd == nullptr) {
       continue;
@@ -70,11 +69,9 @@ bool Max31865RtdReader::periodicInitHandling() {
       return false;
     }
     if ((rtd->on or rtd->db.active) and not rtd->db.configured and rtd->cd.hasTimedOut()) {
-      ManualCsLockWrapper mg1(csLock, gpioIF, rtd->spiCookie, csTimeoutType, csTimeoutMs);
-      if (mg1.lockResult != returnvalue::OK or mg1.gpioResult != returnvalue::OK) {
-        sif::error << "Max31865RtdReader::periodicInitHandling: Manual CS lock failed" << std::endl;
-        continue;
-      }
+      // Please note that using the manual CS lock wrapper here is problematic. Might be a SPI
+      // or hardware specific issue where the CS needs to be pulled high and then low again
+      // between transfers
       result = writeCfgReg(rtd->spiCookie, BASE_CFG);
       if (result != returnvalue::OK) {
         handleSpiError(rtd, result, "writeCfgReg");
@@ -115,7 +112,7 @@ bool Max31865RtdReader::periodicInitHandling() {
   return someRtdUsable;
 }
 
-ReturnValue_t Max31865RtdReader::periodicReadReqHandling() {
+ReturnValue_t Max31865RtdPolling::periodicReadReqHandling() {
   using namespace MAX31865;
   // Now request one shot config for all active RTDs
   for (auto& rtd : rtds) {
@@ -139,7 +136,7 @@ ReturnValue_t Max31865RtdReader::periodicReadReqHandling() {
   return returnvalue::OK;
 }
 
-ReturnValue_t Max31865RtdReader::periodicReadHandling() {
+ReturnValue_t Max31865RtdPolling::periodicReadHandling() {
   using namespace MAX31865;
   auto result = returnvalue::OK;
   // Now read the RTD values
@@ -153,11 +150,9 @@ ReturnValue_t Max31865RtdReader::periodicReadHandling() {
       return returnvalue::FAILED;
     }
     if (rtdIsActive(rtd->idx)) {
-      ManualCsLockWrapper mg1(csLock, gpioIF, rtd->spiCookie, csTimeoutType, csTimeoutMs);
-      if (mg1.lockResult != returnvalue::OK or mg1.gpioResult != returnvalue::OK) {
-        sif::error << "Max31865RtdReader::periodicInitHandling: Manual CS lock failed" << std::endl;
-        continue;
-      }
+      // Please note that using the manual CS lock wrapper here is problematic. Might be a SPI
+      // or hardware specific issue where the CS needs to be pulled high and then low again
+      // between transfers
       uint16_t rtdVal = 0;
       bool faultBitSet = false;
       result = writeCfgReg(rtd->spiCookie, BASE_CFG);
@@ -166,6 +161,7 @@ ReturnValue_t Max31865RtdReader::periodicReadHandling() {
         continue;
       }
       result = readRtdVal(rtd->spiCookie, rtdVal, faultBitSet);
+      // sif::debug << "RTD Val: " << rtdVal << std::endl;
       if (result != returnvalue::OK) {
         handleSpiError(rtd, result, "readRtdVal");
         continue;
@@ -191,7 +187,7 @@ ReturnValue_t Max31865RtdReader::periodicReadHandling() {
   return returnvalue::OK;
 }
 
-ReturnValue_t Max31865RtdReader::initializeInterface(CookieIF* cookie) {
+ReturnValue_t Max31865RtdPolling::initializeInterface(CookieIF* cookie) {
   if (cookie == nullptr) {
     throw std::invalid_argument("Invalid MAX31865 Reader Cookie");
   }
@@ -211,8 +207,8 @@ ReturnValue_t Max31865RtdReader::initializeInterface(CookieIF* cookie) {
   return returnvalue::OK;
 }
 
-ReturnValue_t Max31865RtdReader::sendMessage(CookieIF* cookie, const uint8_t* sendData,
-                                             size_t sendLen) {
+ReturnValue_t Max31865RtdPolling::sendMessage(CookieIF* cookie, const uint8_t* sendData,
+                                              size_t sendLen) {
   if (cookie == nullptr) {
     return returnvalue::FAILED;
   }
@@ -308,14 +304,14 @@ ReturnValue_t Max31865RtdReader::sendMessage(CookieIF* cookie, const uint8_t* se
   return returnvalue::OK;
 }
 
-ReturnValue_t Max31865RtdReader::getSendSuccess(CookieIF* cookie) { return returnvalue::OK; }
+ReturnValue_t Max31865RtdPolling::getSendSuccess(CookieIF* cookie) { return returnvalue::OK; }
 
-ReturnValue_t Max31865RtdReader::requestReceiveMessage(CookieIF* cookie, size_t requestLen) {
+ReturnValue_t Max31865RtdPolling::requestReceiveMessage(CookieIF* cookie, size_t requestLen) {
   return returnvalue::OK;
 }
 
-ReturnValue_t Max31865RtdReader::readReceivedMessage(CookieIF* cookie, uint8_t** buffer,
-                                                     size_t* size) {
+ReturnValue_t Max31865RtdPolling::readReceivedMessage(CookieIF* cookie, uint8_t** buffer,
+                                                      size_t* size) {
   MutexGuard mg(readerMutex);
   if (mg.getLockResult() != returnvalue::OK) {
     // TODO: Emit warning
@@ -338,13 +334,13 @@ ReturnValue_t Max31865RtdReader::readReceivedMessage(CookieIF* cookie, uint8_t**
   return returnvalue::OK;
 }
 
-ReturnValue_t Max31865RtdReader::writeCfgReg(SpiCookie* cookie, uint8_t cfg) {
+ReturnValue_t Max31865RtdPolling::writeCfgReg(SpiCookie* cookie, uint8_t cfg) {
   using namespace MAX31865;
   return writeNToReg(cookie, CONFIG, 1, &cfg, nullptr);
 }
 
-ReturnValue_t Max31865RtdReader::writeBiasSel(MAX31865::Bias bias, SpiCookie* cookie,
-                                              uint8_t baseCfg) {
+ReturnValue_t Max31865RtdPolling::writeBiasSel(MAX31865::Bias bias, SpiCookie* cookie,
+                                               uint8_t baseCfg) {
   using namespace MAX31865;
   if (bias == MAX31865::Bias::OFF) {
     baseCfg &= ~(1 << CfgBitPos::BIAS_SEL);
@@ -354,7 +350,7 @@ ReturnValue_t Max31865RtdReader::writeBiasSel(MAX31865::Bias bias, SpiCookie* co
   return writeCfgReg(cookie, baseCfg);
 }
 
-ReturnValue_t Max31865RtdReader::clearFaultStatus(SpiCookie* cookie) {
+ReturnValue_t Max31865RtdPolling::clearFaultStatus(SpiCookie* cookie) {
   using namespace MAX31865;
   // Read back the current configuration to avoid overwriting it when clearing te fault status
   uint8_t currentCfg = 0;
@@ -368,7 +364,7 @@ ReturnValue_t Max31865RtdReader::clearFaultStatus(SpiCookie* cookie) {
   return writeCfgReg(cookie, currentCfg);
 }
 
-ReturnValue_t Max31865RtdReader::readCfgReg(SpiCookie* cookie, uint8_t& cfg) {
+ReturnValue_t Max31865RtdPolling::readCfgReg(SpiCookie* cookie, uint8_t& cfg) {
   using namespace MAX31865;
   uint8_t* replyPtr = nullptr;
   auto result = readNFromReg(cookie, CONFIG, 1, &replyPtr);
@@ -378,19 +374,19 @@ ReturnValue_t Max31865RtdReader::readCfgReg(SpiCookie* cookie, uint8_t& cfg) {
   return result;
 }
 
-ReturnValue_t Max31865RtdReader::writeLowThreshold(SpiCookie* cookie, uint16_t val) {
+ReturnValue_t Max31865RtdPolling::writeLowThreshold(SpiCookie* cookie, uint16_t val) {
   using namespace MAX31865;
   uint8_t cmd[2] = {static_cast<uint8_t>((val >> 8) & 0xff), static_cast<uint8_t>(val & 0xff)};
   return writeNToReg(cookie, LOW_THRESHOLD, 2, cmd, nullptr);
 }
 
-ReturnValue_t Max31865RtdReader::writeHighThreshold(SpiCookie* cookie, uint16_t val) {
+ReturnValue_t Max31865RtdPolling::writeHighThreshold(SpiCookie* cookie, uint16_t val) {
   using namespace MAX31865;
   uint8_t cmd[2] = {static_cast<uint8_t>((val >> 8) & 0xff), static_cast<uint8_t>(val & 0xff)};
   return writeNToReg(cookie, HIGH_THRESHOLD, 2, cmd, nullptr);
 }
 
-ReturnValue_t Max31865RtdReader::readLowThreshold(SpiCookie* cookie, uint16_t& lowThreshold) {
+ReturnValue_t Max31865RtdPolling::readLowThreshold(SpiCookie* cookie, uint16_t& lowThreshold) {
   using namespace MAX31865;
   uint8_t* replyPtr = nullptr;
   auto result = readNFromReg(cookie, LOW_THRESHOLD, 2, &replyPtr);
@@ -400,7 +396,7 @@ ReturnValue_t Max31865RtdReader::readLowThreshold(SpiCookie* cookie, uint16_t& l
   return result;
 }
 
-ReturnValue_t Max31865RtdReader::readHighThreshold(SpiCookie* cookie, uint16_t& highThreshold) {
+ReturnValue_t Max31865RtdPolling::readHighThreshold(SpiCookie* cookie, uint16_t& highThreshold) {
   using namespace MAX31865;
   uint8_t* replyPtr = nullptr;
   auto result = readNFromReg(cookie, HIGH_THRESHOLD, 2, &replyPtr);
@@ -410,8 +406,8 @@ ReturnValue_t Max31865RtdReader::readHighThreshold(SpiCookie* cookie, uint16_t&
   return result;
 }
 
-ReturnValue_t Max31865RtdReader::writeNToReg(SpiCookie* cookie, uint8_t reg, size_t n, uint8_t* cmd,
-                                             uint8_t** reply) {
+ReturnValue_t Max31865RtdPolling::writeNToReg(SpiCookie* cookie, uint8_t reg, size_t n,
+                                              uint8_t* cmd, uint8_t** reply) {
   using namespace MAX31865;
   if (n > cmdBuf.size() - 1) {
     return returnvalue::FAILED;
@@ -423,7 +419,7 @@ ReturnValue_t Max31865RtdReader::writeNToReg(SpiCookie* cookie, uint8_t reg, siz
   return comIF->sendMessage(cookie, cmdBuf.data(), n + 1);
 }
 
-ReturnValue_t Max31865RtdReader::readRtdVal(SpiCookie* cookie, uint16_t& val, bool& faultBitSet) {
+ReturnValue_t Max31865RtdPolling::readRtdVal(SpiCookie* cookie, uint16_t& val, bool& faultBitSet) {
   using namespace MAX31865;
   uint8_t* replyPtr = nullptr;
   auto result = readNFromReg(cookie, RTD, 2, &replyPtr);
@@ -438,8 +434,8 @@ ReturnValue_t Max31865RtdReader::readRtdVal(SpiCookie* cookie, uint16_t& val, bo
   return result;
 }
 
-ReturnValue_t Max31865RtdReader::readNFromReg(SpiCookie* cookie, uint8_t reg, size_t n,
-                                              uint8_t** reply) {
+ReturnValue_t Max31865RtdPolling::readNFromReg(SpiCookie* cookie, uint8_t reg, size_t n,
+                                               uint8_t** reply) {
   using namespace MAX31865;
   if (n > 4) {
     return returnvalue::FAILED;
@@ -465,15 +461,15 @@ ReturnValue_t Max31865RtdReader::readNFromReg(SpiCookie* cookie, uint8_t reg, si
   return returnvalue::OK;
 }
 
-ReturnValue_t Max31865RtdReader::handleSpiError(Max31865ReaderCookie* cookie, ReturnValue_t result,
-                                                const char* ctx) {
+ReturnValue_t Max31865RtdPolling::handleSpiError(Max31865ReaderCookie* cookie, ReturnValue_t result,
+                                                 const char* ctx) {
   cookie->db.spiErrorCount.value += 1;
   sif::warning << "Max31865RtdReader::handleSpiError: " << ctx << " | Failed with result " << result
                << std::endl;
   return result;
 }
 
-ReturnValue_t Max31865RtdReader::initialize() {
+ReturnValue_t Max31865RtdPolling::initialize() {
   csLock = comIF->getCsMutex();
   return SystemObject::initialize();
 }

linux/devices/Max31865RtdPolling.h

@@ -35,11 +35,11 @@ struct Max31865ReaderCookie : public CookieIF {
   EiveMax31855::ReadOutStruct db;
 };
 
-class Max31865RtdReader : public SystemObject,
-                          public ExecutableObjectIF,
-                          public DeviceCommunicationIF {
+class Max31865RtdPolling : public SystemObject,
+                           public ExecutableObjectIF,
+                           public DeviceCommunicationIF {
  public:
-  Max31865RtdReader(object_id_t objectId, SpiComIF* lowLevelComIF, GpioIF* gpioIF);
+  Max31865RtdPolling(object_id_t objectId, SpiComIF* lowLevelComIF, GpioIF* gpioIF);
 
   ReturnValue_t performOperation(uint8_t operationCode) override;
   ReturnValue_t initialize() override;

linux/devices/RwPollingTask.cpp

@@ -162,11 +162,15 @@ ReturnValue_t RwPollingTask::requestReceiveMessage(CookieIF* cookie, size_t requ
 
 ReturnValue_t RwPollingTask::readReceivedMessage(CookieIF* cookie, uint8_t** buffer, size_t* size) {
   RwCookie* rwCookie = dynamic_cast<RwCookie*>(cookie);
-  {
-    MutexGuard mg(ipcLock);
-    *buffer = rwCookie->replyBuf.data();
-    *size = rwCookie->replyBuf.size();
+  if (rwCookie == nullptr or rwCookie->bufLock == nullptr) {
+    return returnvalue::FAILED;
   }
+  {
+    MutexGuard mg(rwCookie->bufLock);
+    memcpy(rwCookie->exchangeBuf.data(), rwCookie->replyBuf.data(), rwCookie->replyBuf.size());
+  }
+  *buffer = rwCookie->exchangeBuf.data();
+  *size = rwCookie->exchangeBuf.size();
   return returnvalue::OK;
 }
 
@@ -248,6 +252,7 @@ ReturnValue_t RwPollingTask::readNextReply(RwCookie& rwCookie, uint8_t* replyBuf
 #endif
 
   size_t decodedFrameLen = 0;
+  MutexGuard mg(rwCookie.bufLock);
 
   while (decodedFrameLen < maxReplyLen) {
     // First byte already read in
@@ -428,7 +433,12 @@ void RwPollingTask::handleSpecialRequests() {
     }
     uint8_t* replyBuf;
     size_t maxReadLen = idAndIdxToReadBuffer(specialRequestIds[idx], idx, &replyBuf);
-    readNextReply(*rwCookies[idx], replyBuf, maxReadLen);
+    result = readNextReply(*rwCookies[idx], replyBuf, maxReadLen);
+    if (result == returnvalue::OK) {
+      // The first byte is always a flag which shows whether the value was read
+      // properly at least once.
+      replyBuf[0] = true;
+    }
   }
 }
 

linux/devices/RwPollingTask.h

@@ -18,10 +18,14 @@ class RwCookie : public SpiCookie {
   static constexpr size_t REPLY_BUF_LEN = 524;
   RwCookie(uint8_t rwIdx, address_t spiAddress, gpioId_t chipSelect, const size_t maxSize,
            spi::SpiModes spiMode, uint32_t spiSpeed)
-      : SpiCookie(spiAddress, chipSelect, maxSize, spiMode, spiSpeed), rwIdx(rwIdx) {}
+      : SpiCookie(spiAddress, chipSelect, maxSize, spiMode, spiSpeed), rwIdx(rwIdx) {
+    bufLock = MutexFactory::instance()->createMutex();
+  }
 
  private:
   std::array<uint8_t, REPLY_BUF_LEN> replyBuf{};
+  std::array<uint8_t, REPLY_BUF_LEN> exchangeBuf{};
+  MutexIF* bufLock;
   bool setSpeed = true;
   int32_t currentRwSpeed = 0;
   uint16_t currentRampTime = 0;
@@ -56,6 +60,13 @@ class RwPollingTask : public SystemObject, public ExecutableObjectIF, public Dev
   static constexpr uint32_t TIMEOUT_MS = 20;
   static constexpr uint8_t MAX_RETRIES_REPLY = 5;
 
+  // DeviceCommunicationIF overrides
+  ReturnValue_t initializeInterface(CookieIF* cookie) override;
+  ReturnValue_t sendMessage(CookieIF* cookie, const uint8_t* sendData, size_t sendLen) override;
+  ReturnValue_t getSendSuccess(CookieIF* cookie) override;
+  ReturnValue_t requestReceiveMessage(CookieIF* cookie, size_t requestLen) override;
+  ReturnValue_t readReceivedMessage(CookieIF* cookie, uint8_t** buffer, size_t* size) override;
+
   ReturnValue_t writeAndReadAllRws(DeviceCommandId_t id);
   ReturnValue_t writeOneRwCmd(uint8_t rwIdx, int fd);
   ReturnValue_t readAllRws(DeviceCommandId_t id);
@@ -64,15 +75,6 @@ class RwPollingTask : public SystemObject, public ExecutableObjectIF, public Dev
   ReturnValue_t readNextReply(RwCookie& rwCookie, uint8_t* replyBuf, size_t maxReplyLen);
   void handleSpecialRequests();
 
-  ReturnValue_t initializeInterface(CookieIF* cookie) override;
-
-  ReturnValue_t sendMessage(CookieIF* cookie, const uint8_t* sendData, size_t sendLen) override;
-
-  ReturnValue_t getSendSuccess(CookieIF* cookie) override;
-
-  ReturnValue_t requestReceiveMessage(CookieIF* cookie, size_t requestLen) override;
-
-  ReturnValue_t readReceivedMessage(CookieIF* cookie, uint8_t** buffer, size_t* size) override;
   ReturnValue_t openSpi(int flags, int& fd);
   ReturnValue_t pullCsLow(gpioId_t gpioId, GpioIF& gpioIF);
   void prepareSimpleCommand(DeviceCommandId_t id);

linux/devices/SusPolling.cpp

@@ -0,0 +1,220 @@
+#include "SusPolling.h"
+
+#include <fsfw/tasks/SemaphoreFactory.h>
+#include <fsfw/tasks/TaskFactory.h>
+#include <fsfw/timemanager/Stopwatch.h>
+#include <fsfw_hal/linux/spi/SpiCookie.h>
+#include <mission/controller/acs/AcsParameters.h>
+#include <mission/devices/max1227.h>
+#include <unistd.h>
+
+#include "mission/devices/devicedefinitions/susMax1227Helpers.h"
+
+using namespace returnvalue;
+
+SusPolling::SusPolling(object_id_t objectId, SpiComIF& spiComIF, GpioIF& gpioIF)
+    : SystemObject(objectId), spiComIF(spiComIF), gpioIF(gpioIF) {
+  semaphore = SemaphoreFactory::instance()->createBinarySemaphore();
+  semaphore->acquire();
+  ipcLock = MutexFactory::instance()->createMutex();
+}
+
+ReturnValue_t SusPolling::performOperation(uint8_t operationCode) {
+  while (true) {
+    ipcLock->lockMutex();
+    state = InternalState::IDLE;
+    ipcLock->unlockMutex();
+    semaphore->acquire();
+    // Give SUS handlers a chance to submit all requests.
+    TaskFactory::delayTask(2);
+    {
+      // Takes 4-5 ms in debug mode.
+      // Stopwatch watch;
+      handleSusPolling();
+    }
+    // Protection against tardy tasks unlocking the thread again immediately.
+    TaskFactory::delayTask(20);
+  }
+  return OK;
+}
+
+ReturnValue_t SusPolling::initialize() { return OK; }
+
+ReturnValue_t SusPolling::initializeInterface(CookieIF* cookie) {
+  auto* spiCookie = dynamic_cast<SpiCookie*>(cookie);
+  if (spiCookie == nullptr) {
+    return FAILED;
+  }
+  int susIdx = addressToIndex(spiCookie->getSpiAddress());
+  if (susIdx < 0) {
+    return FAILED;
+  }
+  susDevs[susIdx].cookie = spiCookie;
+  return spiComIF.initializeInterface(cookie);
+}
+
+ReturnValue_t SusPolling::sendMessage(CookieIF* cookie, const uint8_t* sendData, size_t sendLen) {
+  auto* spiCookie = dynamic_cast<SpiCookie*>(cookie);
+  if (spiCookie == nullptr) {
+    return FAILED;
+  }
+  int susIdx = addressToIndex(spiCookie->getSpiAddress());
+  if (susIdx < 0) {
+    return FAILED;
+  }
+  if (sendLen != sizeof(acs::SusRequest)) {
+    return FAILED;
+  }
+  const auto* susReq = reinterpret_cast<const acs::SusRequest*>(sendData);
+  MutexGuard mg(ipcLock);
+  if (susDevs[susIdx].mode != susReq->mode) {
+    if (susReq->mode == acs::SimpleSensorMode::NORMAL) {
+      susDevs[susIdx].performStartup = true;
+    } else {
+      susDevs[susIdx].ownReply.cfgWasSet = false;
+      susDevs[susIdx].ownReply.dataWasSet = false;
+    }
+    susDevs[susIdx].mode = susReq->mode;
+  }
+  if (state == InternalState::IDLE) {
+    state = InternalState::BUSY;
+    semaphore->release();
+  }
+  return OK;
+}
+
+ReturnValue_t SusPolling::getSendSuccess(CookieIF* cookie) { return OK; }
+
+ReturnValue_t SusPolling::requestReceiveMessage(CookieIF* cookie, size_t requestLen) { return OK; }
+
+ReturnValue_t SusPolling::readReceivedMessage(CookieIF* cookie, uint8_t** buffer, size_t* size) {
+  auto* spiCookie = dynamic_cast<SpiCookie*>(cookie);
+  if (spiCookie == nullptr) {
+    return FAILED;
+  }
+  int susIdx = addressToIndex(spiCookie->getSpiAddress());
+  if (susIdx < 0) {
+    return FAILED;
+  }
+  MutexGuard mg(ipcLock);
+  std::memcpy(&susDevs[susIdx].readerReply, &susDevs[susIdx].ownReply, sizeof(acs::SusReply));
+  *buffer = reinterpret_cast<uint8_t*>(&susDevs[susIdx].readerReply);
+  *size = sizeof(acs::SusReply);
+  return OK;
+}
+
+ReturnValue_t SusPolling::handleSusPolling() {
+  ReturnValue_t result;
+  acs::SimpleSensorMode modes[12];
+  bool performStartups[12]{};
+  bool cfgsWereSet[12]{};
+  uint8_t idx = 0;
+  {
+    MutexGuard mg(ipcLock);
+    for (idx = 0; idx < 12; idx++) {
+      modes[idx] = susDevs[idx].mode;
+      performStartups[idx] = susDevs[idx].performStartup;
+    }
+  }
+  for (idx = 0; idx < 12; idx++) {
+    if (modes[idx] == acs::SimpleSensorMode::NORMAL) {
+      if (performStartups[idx]) {
+        // Startup handling.
+        cmdBuf[0] = susMax1227::SETUP_INT_CLOKED;
+        result = spiComIF.sendMessage(susDevs[idx].cookie, cmdBuf.data(), 1);
+        if (result != OK) {
+          susDevs[idx].replyResult = result;
+          continue;
+        }
+        MutexGuard mg(ipcLock);
+        susDevs[idx].ownReply.cfgWasSet = true;
+        cfgsWereSet[idx] = true;
+        susDevs[idx].performStartup = true;
+      }
+    }
+  }
+  for (idx = 0; idx < 12; idx++) {
+    if (modes[idx] == acs::SimpleSensorMode::NORMAL and cfgsWereSet[idx]) {
+      // Regular sensor polling.
+      cmdBuf[0] = max1227::buildResetByte(true);
+      cmdBuf[1] = susMax1227::CONVERSION;
+      result = spiComIF.sendMessage(susDevs[idx].cookie, cmdBuf.data(), 2);
+      if (result != OK) {
+        susDevs[idx].replyResult = result;
+        continue;
+      }
+    }
+  }
+
+  // Internal conversion time is 3.5 us
+  usleep(4);
+
+  for (idx = 0; idx < 12; idx++) {
+    if (modes[idx] == acs::SimpleSensorMode::NORMAL and cfgsWereSet[idx]) {
+      std::memset(cmdBuf.data(), 0, susMax1227::SIZE_READ_INT_CONVERSIONS);
+      result = spiComIF.sendMessage(susDevs[idx].cookie, cmdBuf.data(),
+                                    susMax1227::SIZE_READ_INT_CONVERSIONS);
+      if (result != OK) {
+        susDevs[idx].replyResult = result;
+        continue;
+      }
+      result = spiComIF.readReceivedMessage(susDevs[idx].cookie, &rawReply, &dummy);
+      if (result != OK) {
+        susDevs[idx].replyResult = result;
+        continue;
+      }
+      MutexGuard mg(ipcLock);
+      susDevs[idx].ownReply.tempRaw = ((rawReply[0] & 0x0f) << 8) | rawReply[1];
+      for (unsigned chIdx = 0; chIdx < 6; chIdx++) {
+        susDevs[idx].ownReply.channelsRaw[chIdx] =
+            (rawReply[chIdx * 2 + 2] << 8) | rawReply[chIdx * 2 + 3];
+      }
+      susDevs[idx].ownReply.dataWasSet = true;
+    }
+  }
+  return OK;
+}
+
+int SusPolling::addressToIndex(address_t addr) {
+  switch (addr) {
+    case (addresses::SUS_0):
+      return 0;
+      break;
+    case (addresses::SUS_1):
+      return 1;
+      break;
+    case (addresses::SUS_2):
+      return 2;
+      break;
+    case (addresses::SUS_3):
+      return 3;
+      break;
+    case (addresses::SUS_4):
+      return 4;
+      break;
+    case (addresses::SUS_5):
+      return 5;
+      break;
+    case (addresses::SUS_6):
+      return 6;
+      break;
+    case (addresses::SUS_7):
+      return 7;
+      break;
+    case (addresses::SUS_8):
+      return 8;
+      break;
+    case (addresses::SUS_9):
+      return 9;
+      break;
+    case (addresses::SUS_10):
+      return 10;
+      break;
+    case (addresses::SUS_11):
+      return 11;
+      break;
+    default: {
+      return -1;
+    }
+  }
+}

linux/devices/SusPolling.h

@@ -0,0 +1,52 @@
+#ifndef LINUX_DEVICES_SUSPOLLING_H_
+#define LINUX_DEVICES_SUSPOLLING_H_
+
+#include <fsfw/devicehandlers/DeviceCommunicationIF.h>
+#include <fsfw/objectmanager/SystemObject.h>
+#include <fsfw/tasks/ExecutableObjectIF.h>
+#include <fsfw/tasks/SemaphoreIF.h>
+#include <fsfw_hal/linux/spi/SpiComIF.h>
+
+#include "devices/addresses.h"
+#include "mission/devices/devicedefinitions/acsPolling.h"
+
+class SusPolling : public SystemObject, public ExecutableObjectIF, public DeviceCommunicationIF {
+ public:
+  SusPolling(object_id_t objectId, SpiComIF& spiComIF, GpioIF& gpioIF);
+
+  ReturnValue_t performOperation(uint8_t operationCode) override;
+  ReturnValue_t initialize() override;
+
+ private:
+  enum class InternalState { IDLE, BUSY } state = InternalState::IDLE;
+
+  struct SusDev {
+    SpiCookie* cookie = nullptr;
+    bool performStartup = false;
+    acs::SimpleSensorMode mode = acs::SimpleSensorMode::OFF;
+    ReturnValue_t replyResult = returnvalue::OK;
+    acs::SusReply ownReply{};
+    acs::SusReply readerReply{};
+  };
+
+  MutexIF* ipcLock;
+  SemaphoreIF* semaphore;
+  uint8_t* rawReply = nullptr;
+  size_t dummy = 0;
+  SpiComIF& spiComIF;
+  GpioIF& gpioIF;
+
+  std::array<SusDev, 12> susDevs;
+  std::array<uint8_t, 32> cmdBuf;
+
+  ReturnValue_t initializeInterface(CookieIF* cookie) override;
+  ReturnValue_t sendMessage(CookieIF* cookie, const uint8_t* sendData, size_t sendLen) override;
+  ReturnValue_t getSendSuccess(CookieIF* cookie) override;
+  ReturnValue_t requestReceiveMessage(CookieIF* cookie, size_t requestLen) override;
+  ReturnValue_t readReceivedMessage(CookieIF* cookie, uint8_t** buffer, size_t* size) override;
+
+  ReturnValue_t handleSusPolling();
+  static int addressToIndex(address_t addr);
+};
+
+#endif /* LINUX_DEVICES_SUSPOLLING_H_ */

linux/devices/ploc/PlocSupervisorHandler.cpp

@@ -1742,18 +1742,21 @@ ReturnValue_t PlocSupervisorHandler::createMramDumpFile() {
   std::string filename = "mram-dump--" + timeStamp + ".bin";
 
 #ifdef XIPHOS_Q7S
-  std::string currentMountPrefix = sdcMan->getCurrentMountPrefix();
+  const char* currentMountPrefix = sdcMan->getCurrentMountPrefix();
 #else
-  std::string currentMountPrefix("/mnt/sd0");
+  const char* currentMountPrefix = "/mnt/sd0";
 #endif /* BOARD_TE0720 == 0 */
+  if (currentMountPrefix == nullptr) {
+    return returnvalue::FAILED;
+  }
 
   // Check if path to PLOC directory exists
-  if (not std::filesystem::exists(std::string(currentMountPrefix + "/" + supervisorFilePath))) {
+  if (not std::filesystem::exists(std::string(currentMountPrefix) + "/" + supervisorFilePath)) {
     sif::warning << "PlocSupervisorHandler::createMramDumpFile: Supervisor path does not exist"
                  << std::endl;
     return result::PATH_DOES_NOT_EXIST;
   }
-  activeMramFile = currentMountPrefix + "/" + supervisorFilePath + "/" + filename;
+  activeMramFile = std::string(currentMountPrefix) + "/" + supervisorFilePath + "/" + filename;
   // Create new file
   std::ofstream file(activeMramFile, std::ios_base::out);
   file.close();

linux/fsfwconfig/CMakeLists.txt

@@ -1,5 +1,4 @@
-target_sources(${OBSW_NAME} PRIVATE ipc/MissionMessageTypes.cpp
-                                    pollingsequence/pollingSequenceFactory.cpp)
+target_sources(${OBSW_NAME} PRIVATE ipc/MissionMessageTypes.cpp)
 
 target_include_directories(${OBSW_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
 

linux/fsfwconfig/FSFWConfig.h.in

@@ -42,7 +42,7 @@
 
 //! When using the newlib nano library, C99 support for stdio facilities
 //! will not be provided. This define should be set to 1 if this is the case.
-#define FSFW_NO_C99_IO 	            1
+#define FSFW_NO_C99_IO 	            0
 
 //! Specify whether a special mode store is used for Subsystem components.
 #define FSFW_USE_MODESTORE          0

linux/fsfwconfig/events/translateEvents.cpp

@@ -1,7 +1,7 @@
 /**
- * @brief    Auto-generated event translation file. Contains 257 translations.
+ * @brief    Auto-generated event translation file. Contains 267 translations.
  * @details
- * Generated on: 2023-02-21 00:24:44
+ * Generated on: 2023-03-01 18:34:32
  */
 #include "translateEvents.h"
 
@@ -90,9 +90,13 @@ const char *CHANGE_OF_SETUP_PARAMETER_STRING = "CHANGE_OF_SETUP_PARAMETER";
 const char *STORE_ERROR_STRING = "STORE_ERROR";
 const char *MSG_QUEUE_ERROR_STRING = "MSG_QUEUE_ERROR";
 const char *SERIALIZATION_ERROR_STRING = "SERIALIZATION_ERROR";
+const char *FILESTORE_ERROR_STRING = "FILESTORE_ERROR";
+const char *FILENAME_TOO_LARGE_ERROR_STRING = "FILENAME_TOO_LARGE_ERROR";
 const char *SAFE_RATE_VIOLATION_STRING = "SAFE_RATE_VIOLATION";
 const char *SAFE_RATE_RECOVERY_STRING = "SAFE_RATE_RECOVERY";
 const char *MULTIPLE_RW_INVALID_STRING = "MULTIPLE_RW_INVALID";
+const char *MEKF_INVALID_INFO_STRING = "MEKF_INVALID_INFO";
+const char *MEKF_INVALID_MODE_VIOLATION_STRING = "MEKF_INVALID_MODE_VIOLATION";
 const char *SWITCH_CMD_SENT_STRING = "SWITCH_CMD_SENT";
 const char *SWITCH_HAS_CHANGED_STRING = "SWITCH_HAS_CHANGED";
 const char *SWITCHING_Q7S_DENIED_STRING = "SWITCHING_Q7S_DENIED";
@@ -151,8 +155,11 @@ const char *CARRIER_LOCK_STRING = "CARRIER_LOCK";
 const char *BIT_LOCK_PDEC_STRING = "BIT_LOCK_PDEC";
 const char *LOST_CARRIER_LOCK_PDEC_STRING = "LOST_CARRIER_LOCK_PDEC";
 const char *LOST_BIT_LOCK_PDEC_STRING = "LOST_BIT_LOCK_PDEC";
+const char *TOO_MANY_IRQS_STRING = "TOO_MANY_IRQS";
 const char *POLL_SYSCALL_ERROR_PDEC_STRING = "POLL_SYSCALL_ERROR_PDEC";
 const char *WRITE_SYSCALL_ERROR_PDEC_STRING = "WRITE_SYSCALL_ERROR_PDEC";
+const char *PDEC_RESET_FAILED_STRING = "PDEC_RESET_FAILED";
+const char *OPEN_IRQ_FILE_FAILED_STRING = "OPEN_IRQ_FILE_FAILED";
 const char *IMAGE_UPLOAD_FAILED_STRING = "IMAGE_UPLOAD_FAILED";
 const char *IMAGE_DOWNLOAD_FAILED_STRING = "IMAGE_DOWNLOAD_FAILED";
 const char *IMAGE_UPLOAD_SUCCESSFUL_STRING = "IMAGE_UPLOAD_SUCCESSFUL";
@@ -257,6 +264,9 @@ const char *PLOC_OVERHEATING_STRING = "PLOC_OVERHEATING";
 const char *OBC_OVERHEATING_STRING = "OBC_OVERHEATING";
 const char *HPA_OVERHEATING_STRING = "HPA_OVERHEATING";
 const char *PLPCDU_OVERHEATING_STRING = "PLPCDU_OVERHEATING";
+const char *TX_TIMER_EXPIRED_STRING = "TX_TIMER_EXPIRED";
+const char *BIT_LOCK_TX_ON_STRING = "BIT_LOCK_TX_ON";
+const char *POSSIBLE_FILE_CORRUPTION_STRING = "POSSIBLE_FILE_CORRUPTION";
 
 const char *translateEvents(Event event) {
   switch ((event & 0xFFFF)) {
@@ -430,12 +440,20 @@ const char *translateEvents(Event event) {
       return MSG_QUEUE_ERROR_STRING;
     case (10802):
       return SERIALIZATION_ERROR_STRING;
+    case (10803):
+      return FILESTORE_ERROR_STRING;
+    case (10804):
+      return FILENAME_TOO_LARGE_ERROR_STRING;
     case (11200):
       return SAFE_RATE_VIOLATION_STRING;
     case (11201):
       return SAFE_RATE_RECOVERY_STRING;
     case (11202):
       return MULTIPLE_RW_INVALID_STRING;
+    case (11203):
+      return MEKF_INVALID_INFO_STRING;
+    case (11204):
+      return MEKF_INVALID_MODE_VIOLATION_STRING;
     case (11300):
       return SWITCH_CMD_SENT_STRING;
     case (11301):
@@ -553,9 +571,15 @@ const char *translateEvents(Event event) {
     case (12406):
       return LOST_BIT_LOCK_PDEC_STRING;
     case (12407):
-      return POLL_SYSCALL_ERROR_PDEC_STRING;
+      return TOO_MANY_IRQS_STRING;
     case (12408):
+      return POLL_SYSCALL_ERROR_PDEC_STRING;
+    case (12409):
       return WRITE_SYSCALL_ERROR_PDEC_STRING;
+    case (12410):
+      return PDEC_RESET_FAILED_STRING;
+    case (12411):
+      return OPEN_IRQ_FILE_FAILED_STRING;
     case (12500):
       return IMAGE_UPLOAD_FAILED_STRING;
     case (12501):
@@ -764,6 +788,12 @@ const char *translateEvents(Event event) {
       return HPA_OVERHEATING_STRING;
     case (14106):
       return PLPCDU_OVERHEATING_STRING;
+    case (14201):
+      return TX_TIMER_EXPIRED_STRING;
+    case (14202):
+      return BIT_LOCK_TX_ON_STRING;
+    case (14300):
+      return POSSIBLE_FILE_CORRUPTION_STRING;
     default:
       return "UNKNOWN_EVENT";
   }

linux/fsfwconfig/objects/systemObjectList.h

@@ -47,7 +47,6 @@ enum sourceObjects : uint32_t {
   GPIO_IF = 0x49010005,
 
   /* Custom device handler */
-  RW_POLLING_TASK = 0x49020005,
 
   /* 0x54 ('T') for test handlers */
   TEST_TASK = 0x54694269,

linux/fsfwconfig/objects/translateObjects.cpp

@@ -1,8 +1,8 @@
 /**
  * @brief  Auto-generated object translation file.
  * @details
- * Contains 152 translations.
- * Generated on: 2023-02-21 00:24:44
+ * Contains 161 translations.
+ * Generated on: 2023-03-01 18:34:32
  */
 #include "translateObjects.h"
 
@@ -37,6 +37,7 @@ const char *GYRO_3_L3G_HANDLER_STRING = "GYRO_3_L3G_HANDLER";
 const char *RW4_STRING = "RW4";
 const char *STAR_TRACKER_STRING = "STAR_TRACKER";
 const char *GPS_CONTROLLER_STRING = "GPS_CONTROLLER";
+const char *IMTQ_POLLING_STRING = "IMTQ_POLLING";
 const char *IMTQ_HANDLER_STRING = "IMTQ_HANDLER";
 const char *PCDU_HANDLER_STRING = "PCDU_HANDLER";
 const char *P60DOCK_HANDLER_STRING = "P60DOCK_HANDLER";
@@ -84,11 +85,13 @@ 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";
 const char *SPI_MAIN_COM_IF_STRING = "SPI_MAIN_COM_IF";
-const char *RW_POLLING_TASK_STRING = "RW_POLLING_TASK";
-const char *SPI_RTD_COM_IF_STRING = "SPI_RTD_COM_IF";
 const char *UART_COM_IF_STRING = "UART_COM_IF";
 const char *I2C_COM_IF_STRING = "I2C_COM_IF";
 const char *CSP_COM_IF_STRING = "CSP_COM_IF";
+const char *ACS_BOARD_POLLING_TASK_STRING = "ACS_BOARD_POLLING_TASK";
+const char *RW_POLLING_TASK_STRING = "RW_POLLING_TASK";
+const char *SPI_RTD_COM_IF_STRING = "SPI_RTD_COM_IF";
+const char *SUS_POLLING_TASK_STRING = "SUS_POLLING_TASK";
 const char *CCSDS_PACKET_DISTRIBUTOR_STRING = "CCSDS_PACKET_DISTRIBUTOR";
 const char *PUS_PACKET_DISTRIBUTOR_STRING = "PUS_PACKET_DISTRIBUTOR";
 const char *TCP_TMTC_SERVER_STRING = "TCP_TMTC_SERVER";
@@ -109,6 +112,7 @@ const char *PUS_SERVICE_5_EVENT_REPORTING_STRING = "PUS_SERVICE_5_EVENT_REPORTIN
 const char *PUS_SERVICE_8_FUNCTION_MGMT_STRING = "PUS_SERVICE_8_FUNCTION_MGMT";
 const char *PUS_SERVICE_9_TIME_MGMT_STRING = "PUS_SERVICE_9_TIME_MGMT";
 const char *PUS_SERVICE_11_TC_SCHEDULER_STRING = "PUS_SERVICE_11_TC_SCHEDULER";
+const char *PUS_SERVICE_15_TM_STORAGE_STRING = "PUS_SERVICE_15_TM_STORAGE";
 const char *PUS_SERVICE_17_TEST_STRING = "PUS_SERVICE_17_TEST";
 const char *PUS_SERVICE_20_PARAMETERS_STRING = "PUS_SERVICE_20_PARAMETERS";
 const char *PUS_SERVICE_200_MODE_MGMT_STRING = "PUS_SERVICE_200_MODE_MGMT";
@@ -155,6 +159,11 @@ const char *ACS_SUBSYSTEM_STRING = "ACS_SUBSYSTEM";
 const char *PL_SUBSYSTEM_STRING = "PL_SUBSYSTEM";
 const char *TCS_SUBSYSTEM_STRING = "TCS_SUBSYSTEM";
 const char *COM_SUBSYSTEM_STRING = "COM_SUBSYSTEM";
+const char *MISC_TM_STORE_STRING = "MISC_TM_STORE";
+const char *OK_TM_STORE_STRING = "OK_TM_STORE";
+const char *NOT_OK_TM_STORE_STRING = "NOT_OK_TM_STORE";
+const char *HK_TM_STORE_STRING = "HK_TM_STORE";
+const char *CFDP_TM_STORE_STRING = "CFDP_TM_STORE";
 const char *CCSDS_IP_CORE_BRIDGE_STRING = "CCSDS_IP_CORE_BRIDGE";
 const char *THERMAL_TEMP_INSERTER_STRING = "THERMAL_TEMP_INSERTER";
 const char *NO_OBJECT_STRING = "NO_OBJECT";
@@ -223,6 +232,8 @@ const char *translateObject(object_id_t object) {
       return STAR_TRACKER_STRING;
     case 0x44130045:
       return GPS_CONTROLLER_STRING;
+    case 0x44140013:
+      return IMTQ_POLLING_STRING;
     case 0x44140014:
       return IMTQ_HANDLER_STRING;
     case 0x442000A1:
@@ -317,16 +328,20 @@ const char *translateObject(object_id_t object) {
       return SCEX_UART_READER_STRING;
     case 0x49020004:
       return SPI_MAIN_COM_IF_STRING;
-    case 0x49020005:
-      return RW_POLLING_TASK_STRING;
-    case 0x49020006:
-      return SPI_RTD_COM_IF_STRING;
     case 0x49030003:
       return UART_COM_IF_STRING;
     case 0x49040002:
       return I2C_COM_IF_STRING;
     case 0x49050001:
       return CSP_COM_IF_STRING;
+    case 0x49060004:
+      return ACS_BOARD_POLLING_TASK_STRING;
+    case 0x49060005:
+      return RW_POLLING_TASK_STRING;
+    case 0x49060006:
+      return SPI_RTD_COM_IF_STRING;
+    case 0x49060007:
+      return SUS_POLLING_TASK_STRING;
     case 0x50000100:
       return CCSDS_PACKET_DISTRIBUTOR_STRING;
     case 0x50000200:
@@ -367,6 +382,8 @@ const char *translateObject(object_id_t object) {
       return PUS_SERVICE_9_TIME_MGMT_STRING;
     case 0x53000011:
       return PUS_SERVICE_11_TC_SCHEDULER_STRING;
+    case 0x53000015:
+      return PUS_SERVICE_15_TM_STORAGE_STRING;
     case 0x53000017:
       return PUS_SERVICE_17_TEST_STRING;
     case 0x53000020:
@@ -459,6 +476,16 @@ const char *translateObject(object_id_t object) {
       return TCS_SUBSYSTEM_STRING;
     case 0x73010004:
       return COM_SUBSYSTEM_STRING;
+    case 0x73020001:
+      return MISC_TM_STORE_STRING;
+    case 0x73020002:
+      return OK_TM_STORE_STRING;
+    case 0x73020003:
+      return NOT_OK_TM_STORE_STRING;
+    case 0x73020004:
+      return HK_TM_STORE_STRING;
+    case 0x73030000:
+      return CFDP_TM_STORE_STRING;
     case 0x73500000:
       return CCSDS_IP_CORE_BRIDGE_STRING;
     case 0x90000003:

linux/fsfwconfig/returnvalues/classIds.h

@@ -13,9 +13,8 @@
 namespace CLASS_ID {
 enum {
   CLASS_ID_START = COMMON_CLASS_ID_END,
-  SD_CARD_MANAGER,  // SDMA
-  SCRATCH_BUFFER,   // SCBU
-  CLASS_ID_END      // [EXPORT] : [END]
+  SCRATCH_BUFFER,  // SCBU
+  CLASS_ID_END     // [EXPORT] : [END]
 };
 }
 

linux/ipcore/PdecConfig.cpp

@@ -1,12 +1,120 @@
 #include "PdecConfig.h"
 
+#include "fsfw/filesystem/HasFileSystemIF.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"
+#include "pdecconfigdefs.h"
 
-PdecConfig::PdecConfig() { initialize(); }
+PdecConfig::PdecConfig()
+    : localParameterHandler("conf/pdecconfig.json", SdCardManager::instance()) {}
 
 PdecConfig::~PdecConfig() {}
 
-void PdecConfig::initialize() {
+void PdecConfig::setMemoryBaseAddress(uint32_t* memoryBaseAddress_) {
+  memoryBaseAddress = memoryBaseAddress_;
+}
+
+ReturnValue_t PdecConfig::write() {
+  if (memoryBaseAddress == nullptr) {
+    sif::error << "PdecConfig::write: Memory base address not set" << std::endl;
+    return returnvalue::FAILED;
+  }
+  ReturnValue_t result = initializePersistentParameters();
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = writeFrameHeaderFirstOctet();
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = writeFrameHeaderSecondOctet();
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  writeMapConfig();
+  return returnvalue::OK;
+}
+
+ReturnValue_t PdecConfig::initializePersistentParameters() {
+  ReturnValue_t result = localParameterHandler.initialize();
+  if (result == HasFileSystemIF::FILE_DOES_NOT_EXIST) {
+    result = createPersistentConfig();
+    if (result != returnvalue::OK) {
+      return result;
+    }
+  }
+  return result;
+}
+
+ReturnValue_t PdecConfig::createPersistentConfig() {
+  ReturnValue_t result = localParameterHandler.addParameter(
+      pdecconfigdefs::paramkeys::POSITIVE_WINDOW, pdecconfigdefs::defaultvalue::positiveWindow);
+  if (result != returnvalue::OK) {
+    sif::error << "PdecConfig::createPersistentConfig: Failed to set positive window" << std::endl;
+    return result;
+  }
+  result = localParameterHandler.addParameter(pdecconfigdefs::paramkeys::NEGATIVE_WINDOW,
+                                              pdecconfigdefs::defaultvalue::negativeWindow);
+  if (result != returnvalue::OK) {
+    sif::error << "PdecConfig::createPersistentConfig: Failed to set negative window" << std::endl;
+    return result;
+  }
+  return returnvalue::OK;
+}
+
+uint32_t PdecConfig::getImrReg() {
+  return static_cast<uint32_t>(enableNewFarIrq << 2) |
+         static_cast<uint32_t>(enableTcAbortIrq << 1) | static_cast<uint32_t>(enableTcNewIrq);
+}
+
+ReturnValue_t PdecConfig::setPositiveWindow(uint8_t pw) {
+  if (memoryBaseAddress == nullptr) {
+    sif::error << "PdecConfig::setPositiveWindow: Memory base address not set" << std::endl;
+    return returnvalue::FAILED;
+  }
+  ReturnValue_t result =
+      localParameterHandler.updateParameter(pdecconfigdefs::paramkeys::POSITIVE_WINDOW, pw);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  // Rewrite second config word which contains the positive window parameter
+  writeFrameHeaderSecondOctet();
+  return returnvalue::OK;
+}
+
+ReturnValue_t PdecConfig::setNegativeWindow(uint8_t nw) {
+  if (memoryBaseAddress == nullptr) {
+    sif::error << "PdecConfig::setPositiveWindow: Memory base address not set" << std::endl;
+    return returnvalue::FAILED;
+  }
+  ReturnValue_t result =
+      localParameterHandler.updateParameter(pdecconfigdefs::paramkeys::NEGATIVE_WINDOW, nw);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  // Rewrite second config word which contains the negative window parameter
+  writeFrameHeaderSecondOctet();
+  return returnvalue::OK;
+}
+
+ReturnValue_t PdecConfig::getPositiveWindow(uint8_t& positiveWindow) {
+  ReturnValue_t result =
+      localParameterHandler.getValue(pdecconfigdefs::paramkeys::POSITIVE_WINDOW, positiveWindow);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  return returnvalue::OK;
+}
+
+ReturnValue_t PdecConfig::getNegativeWindow(uint8_t& negativeWindow) {
+  ReturnValue_t result =
+      localParameterHandler.getValue(pdecconfigdefs::paramkeys::NEGATIVE_WINDOW, negativeWindow);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  return returnvalue::OK;
+}
+
+ReturnValue_t PdecConfig::writeFrameHeaderFirstOctet() {
   uint32_t word = 0;
   word |= (VERSION_ID << 30);
 
@@ -19,24 +127,65 @@ void PdecConfig::initialize() {
   word |= (SPACECRAFT_ID << 16);
   word |= (VIRTUAL_CHANNEL << 10);
   word |= (DUMMY_BITS << 8);
-  word |= POSITIVE_WINDOW;
-  configWords[0] = word;
+  uint8_t positiveWindow = 0;
+  ReturnValue_t result =
+      localParameterHandler.getValue(pdecconfigdefs::paramkeys::POSITIVE_WINDOW, positiveWindow);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  word |= static_cast<uint32_t>(positiveWindow);
+  *(memoryBaseAddress + FRAME_HEADER_OFFSET) = word;
+  return returnvalue::OK;
+}
+
+ReturnValue_t PdecConfig::writeFrameHeaderSecondOctet() {
+  uint8_t negativeWindow = 0;
+  ReturnValue_t result =
+      localParameterHandler.getValue(pdecconfigdefs::paramkeys::NEGATIVE_WINDOW, negativeWindow);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  uint32_t word = 0;
   word = 0;
-  word |= (static_cast<uint32_t>(NEGATIVE_WINDOW) << 24);
+  word |= (static_cast<uint32_t>(negativeWindow) << 24);
   word |= (HIGH_AU_MAP_ID << 16);
   word |= (ENABLE_DERANDOMIZER << 8);
-  configWords[1] = word;
+  *(memoryBaseAddress + FRAME_HEADER_OFFSET + 1) = word;
+  return returnvalue::OK;
 }
 
-uint32_t PdecConfig::getConfigWord(uint8_t wordNo) {
-  if (wordNo >= CONFIG_WORDS_NUM) {
-    sif::error << "PdecConfig::getConfigWord: Invalid word number" << std::endl;
-    return 0;
+void PdecConfig::writeMapConfig() {
+  // Configure all MAP IDs as invalid
+  for (int idx = 0; idx <= MAX_MAP_ADDR; idx += 4) {
+    *(memoryBaseAddress + MAP_ADDR_LUT_OFFSET + idx / 4) =
+        NO_DESTINATION << 24 | NO_DESTINATION << 16 | NO_DESTINATION << 8 | NO_DESTINATION;
+  }
+
+  // All TCs with MAP ID 7 will be routed to the PM module (can then be read from memory)
+  uint8_t routeToPm = calcMapAddrEntry(PM_BUFFER);
+  *(memoryBaseAddress + MAP_ADDR_LUT_OFFSET + 1) =
+      (NO_DESTINATION << 24) | (NO_DESTINATION << 16) | (NO_DESTINATION << 8) | routeToPm;
+
+  // Write map id clock frequencies
+  for (int idx = 0; idx <= MAX_MAP_ADDR; idx += 4) {
+    *(memoryBaseAddress + MAP_CLK_FREQ_OFFSET + idx / 4) =
+        MAP_CLK_FREQ << 24 | MAP_CLK_FREQ << 16 | MAP_CLK_FREQ << 8 | MAP_CLK_FREQ;
   }
-  return configWords[wordNo];
 }
 
-uint32_t PdecConfig::getImrReg() {
-  return static_cast<uint32_t>(enableNewFarIrq << 2) |
-         static_cast<uint32_t>(enableTcAbortIrq << 1) | static_cast<uint32_t>(enableTcNewIrq);
+uint8_t PdecConfig::calcMapAddrEntry(uint8_t moduleId) {
+  uint8_t lutEntry = 0;
+  uint8_t parity = getOddParity(moduleId | (1 << VALID_POSITION));
+  lutEntry = (parity << PARITY_POSITION) | (1 << VALID_POSITION) | moduleId;
+  return lutEntry;
+}
+
+uint8_t PdecConfig::getOddParity(uint8_t number) {
+  uint8_t parityBit = 0;
+  uint8_t countBits = 0;
+  for (unsigned int idx = 0; idx < sizeof(number) * 8; idx++) {
+    countBits += (number >> idx) & 0x1;
+  }
+  parityBit = ~(countBits & 0x1) & 0x1;
+  return parityBit;
 }

linux/ipcore/PdecConfig.h

@@ -1,30 +1,53 @@
 #ifndef LINUX_OBC_PDECCONFIG_H_
 #define LINUX_OBC_PDECCONFIG_H_
 
-#include <cstring>
+#include <string>
 
+#include "bsp_q7s/fs/SdCardManager.h"
+#include "bsp_q7s/memory/LocalParameterHandler.h"
 #include "fsfw/returnvalues/returnvalue.h"
+#include "pdec.h"
 
 /**
  * @brief   This class generates the configuration words for the configuration memory of the PDEC
  *          IP Cores.
  *
- * @details Fields are initialized according to pecification in PDEC datasheet section 6.11.3.1
+ * @details Fields are initialized according to specification in PDEC datasheet section 6.11.3.1
  *          PROM usage.
  *
  * @author  J. Meier
  */
 class PdecConfig {
  public:
+  /**
+   * @brief	Constructor
+   */
   PdecConfig();
   virtual ~PdecConfig();
 
   /**
-   * @brief   Returns the configuration word by specifying the position.
+   * @brief	Sets the memory base address pointer
+   */
+  void setMemoryBaseAddress(uint32_t* memoryBaseAddress_);
+
+  /**
+   * @brief	Will write the config to the PDEC configuration memory. New config
+   * 				becomes active after resetting PDEC.
+   */
+  ReturnValue_t write();
+
+  /**
+   * @brief	Returns the value to write to the interrupt mask register. This
+   * 				value defines which interrupts should be enabled/disabled.
    */
-  uint32_t getConfigWord(uint8_t wordNo);
   uint32_t getImrReg();
 
+  ReturnValue_t setPositiveWindow(uint8_t pw);
+  ReturnValue_t setNegativeWindow(uint8_t nw);
+
+  ReturnValue_t getPositiveWindow(uint8_t& positiveWindow);
+  ReturnValue_t getNegativeWindow(uint8_t& negativeWindow);
+
  private:
   // TC transfer frame configuration parameters
   static const uint8_t VERSION_ID = 0;
@@ -36,21 +59,73 @@ class PdecConfig {
   static const uint8_t RESERVED_FIELD_A = 0;
   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
-  static const uint8_t POSITIVE_WINDOW = 10;
-  static const uint8_t NEGATIVE_WINDOW = 151;
   static const uint8_t HIGH_AU_MAP_ID = 0xF;
   static const uint8_t ENABLE_DERANDOMIZER = 1;
 
   static const uint8_t CONFIG_WORDS_NUM = 2;
 
+  // 0x200 / 4 = 0x80
+  static const uint32_t FRAME_HEADER_OFFSET = 0x80;
+
+  static const uint32_t MAP_ADDR_LUT_OFFSET = 0xA0;
+  static const uint32_t MAP_CLK_FREQ_OFFSET = 0x90;
+  // MAP clock frequency. Must be a value between 1 and 13 otherwise the TC segment will be
+  // discarded
+  static const uint8_t MAP_CLK_FREQ = 2;
+
+  static const uint8_t MAX_MAP_ADDR = 63;
+  // Writing this to the map address in the look up table will invalidate a MAP ID.
+  static const uint8_t NO_DESTINATION = 0;
+  static const uint8_t VALID_POSITION = 6;
+  static const uint8_t PARITY_POSITION = 7;
+
+  /**
+   * TCs with map addresses (also know as Map IDs) assigned to this channel will be stored in
+   * the PDEC memory.
+   */
+  static const uint8_t PM_BUFFER = 7;
+
+  uint32_t* memoryBaseAddress = nullptr;
+
+  // Pointer to object providing access to persistent configuration parameters
+  LocalParameterHandler localParameterHandler;
+
   uint32_t configWords[CONFIG_WORDS_NUM];
   bool enableTcNewIrq = true;
   bool enableTcAbortIrq = true;
   bool enableNewFarIrq = true;
 
-  void initialize();
+  ReturnValue_t initializePersistentParameters();
+  /**
+   * @brief	If the json file containing the persistent config parameters does
+   * 				not exist it will be created here.
+   */
+  ReturnValue_t createPersistentConfig();
+
+  ReturnValue_t writeFrameHeaderFirstOctet();
+  ReturnValue_t writeFrameHeaderSecondOctet();
+  void writeMapConfig();
+
+  /**
+   * @brief   This function calculates the entry for the configuration of the MAP ID routing.
+   *
+   * @param mapAddr   The MAP ID to configure
+   * @param moduleId  The destination module where all TCs with the map id mapAddr will be routed
+   *                  to.
+   *
+   * @details The PDEC has different modules where the TCs can be routed to. A lookup table is
+   *          used which links the MAP ID field to the destination module. The entry for this
+   *          lookup table is created by this function and must be stored in the configuration
+   *          memory region of the PDEC. The entry has a specific format
+   */
+  uint8_t calcMapAddrEntry(uint8_t moduleId);
+
+  /**
+   * @brief   This functions calculates the odd parity of the bits in number.
+   *
+   * @param number    The number from which to calculate the odd parity.
+   */
+  uint8_t getOddParity(uint8_t number);
 };
 
 #endif /* LINUX_OBC_PDECCONFIG_H_ */

linux/ipcore/PdecHandler.cpp

@@ -1,6 +1,7 @@
 #include "PdecHandler.h"
 
 #include <fcntl.h>
+#include <fsfw/tasks/TaskFactory.h>
 #include <poll.h>
 #include <sys/mman.h>
 #include <unistd.h>
@@ -28,7 +29,8 @@ PdecHandler::PdecHandler(object_id_t objectId, object_id_t tcDestinationId,
       gpioComIF(gpioComIF),
       pdecReset(pdecReset),
       actionHelper(this, nullptr),
-      uioNames(names) {
+      uioNames(names),
+      paramHelper(this) {
   auto mqArgs = MqArgs(objectId, static_cast<void*>(this));
   commandQueue = QueueFactory::instance()->createMessageQueue(
       QUEUE_SIZE, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
@@ -61,6 +63,8 @@ ReturnValue_t PdecHandler::initialize() {
   result = configMemMapper.getMappedAdress(&memoryBaseAddress, UioMapper::Permissions::READ_WRITE);
   if (result != returnvalue::OK) {
     return ObjectManagerIF::CHILD_INIT_FAILED;
+  } else {
+    pdecConfig.setMemoryBaseAddress(memoryBaseAddress);
   }
   UioMapper ramMapper(uioNames.ramMemory);
   result = ramMapper.getMappedAdress(&ramBaseAddress, UioMapper::Permissions::READ_WRITE);
@@ -72,12 +76,34 @@ ReturnValue_t PdecHandler::initialize() {
     sif::error << "Can not use IRQ mode if IRQ UIO name is invalid" << std::endl;
     return returnvalue::FAILED;
   }
-  PdecConfig pdecConfig;
-  writePdecConfigDuringReset(pdecConfig);
+
+  result = actionHelper.initialize(commandQueue);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+
+  result = paramHelper.initialize();
+  if (result != returnvalue::OK) {
+    return result;
+  }
+
+  return returnvalue::OK;
+}
+
+ReturnValue_t PdecHandler::firstLoop() {
+  ReturnValue_t result = pdecConfig.write();
+  if (result != returnvalue::OK) {
+    if (result == LocalParameterHandler::SD_NOT_READY) {
+      return result;
+    } else {
+      sif::error << "PdecHandler::firstLoop: Failed to write PDEC config" << std::endl;
+    }
+    return returnvalue::FAILED;
+  }
 
   result = releasePdec();
   if (result != returnvalue::OK) {
-    return ObjectManagerIF::CHILD_INIT_FAILED;
+    return returnvalue::FAILED;
   }
 
   // This configuration must be done while the PDEC is not held in reset.
@@ -85,11 +111,12 @@ ReturnValue_t PdecHandler::initialize() {
     // Configure interrupt mask register to enable interrupts
     *(registerBaseAddress + PDEC_IMR_OFFSET) = pdecConfig.getImrReg();
   }
-  result = actionHelper.initialize(commandQueue);
+  result = resetFarStatFlag();
   if (result != returnvalue::OK) {
+    // Requires reconfiguration and reinitialization of PDEC
+    triggerEvent(INVALID_FAR);
     return result;
   }
-
   return returnvalue::OK;
 }
 
@@ -103,26 +130,28 @@ ReturnValue_t PdecHandler::performOperation(uint8_t operationCode) {
 }
 
 ReturnValue_t PdecHandler::polledOperation() {
-  ReturnValue_t result = returnvalue::OK;
   readCommandQueue();
 
   switch (state) {
-    case State::INIT:
-      resetFarStatFlag();
-      if (result != returnvalue::OK) {
-        // Requires reconfiguration and reinitialization of PDEC
-        triggerEvent(INVALID_FAR);
-        state = State::WAIT_FOR_RECOVERY;
-        return result;
-      }
-      state = State::RUNNING;
+    case State::INIT: {
+      handleInitState();
       break;
-    case State::RUNNING:
+    }
+    case State::RUNNING: {
       if (newTcReceived()) {
         handleNewTc();
       }
       checkLocks();
       break;
+    }
+    case State::PDEC_RESET: {
+      ReturnValue_t result = pdecToReset();
+      if (result != returnvalue::OK) {
+        triggerEvent(PDEC_RESET_FAILED);
+      }
+      state = State::INIT;
+      break;
+    }
     case State::WAIT_FOR_RECOVERY:
       break;
     default:
@@ -136,17 +165,12 @@ ReturnValue_t PdecHandler::polledOperation() {
 // See https://yurovsky.github.io/2014/10/10/linux-uio-gpio-interrupt.html for more information.
 ReturnValue_t PdecHandler::irqOperation() {
   ReturnValue_t result = returnvalue::OK;
-  int fd = open(uioNames.irq, O_RDWR);
-  if (fd < 0) {
-    sif::error << "PdecHandler::irqOperation: Opening UIO IRQ file" << uioNames.irq << " failed"
-               << std::endl;
-    return returnvalue::FAILED;
-  }
-
+  int fd = -1;
   // Used to unmask IRQ
   uint32_t info = 1;
-  ssize_t nb = 0;
-  int ret = 0;
+
+  interruptWindowCd.resetTimer();
+
   // Clear interrupts with dummy read before unmasking the interrupt. Use a volatile to prevent
   // read being optimized away.
   volatile uint32_t dummy = *(registerBaseAddress + PDEC_PIR_OFFSET);
@@ -156,68 +180,33 @@ ReturnValue_t PdecHandler::irqOperation() {
     info = 1;
     readCommandQueue();
     switch (state) {
-      case State::INIT:
-        resetFarStatFlag();
-        if (result != returnvalue::OK) {
-          // Requires reconfiguration and reinitialization of PDEC
-          triggerEvent(INVALID_FAR);
-          state = State::WAIT_FOR_RECOVERY;
-          return result;
-        }
-        state = State::RUNNING;
-        break;
-      case State::RUNNING: {
-        nb = write(fd, &info, sizeof(info));
-        if (nb != static_cast<ssize_t>(sizeof(info))) {
-          sif::error << "PdecHandler::irqOperation: Unmasking IRQ failed" << std::endl;
-          triggerEvent(WRITE_SYSCALL_ERROR_PDEC, errno);
-          close(fd);
-          state = State::INIT;
-          return returnvalue::FAILED;
-        }
-        struct pollfd fds = {.fd = fd, .events = POLLIN, .revents = 0};
-        ret = poll(&fds, 1, IRQ_TIMEOUT_MS);
-        if (ret == 0) {
-          // No TCs for timeout period
-          checkLocks();
-          lockCheckCd.resetTimer();
-        } else if (ret >= 1) {
-          nb = read(fd, &info, sizeof(info));
-          if (nb == static_cast<ssize_t>(sizeof(info))) {
-            uint32_t pisr = *(registerBaseAddress + PDEC_PISR_OFFSET);
-            if ((pisr & TC_NEW_MASK) == TC_NEW_MASK) {
-              // handle TC
-              handleNewTc();
-            }
-            if ((pisr & TC_ABORT_MASK) == TC_ABORT_MASK) {
-              tcAbortCounter += 1;
-            }
-            if ((pisr & NEW_FAR_MASK) == NEW_FAR_MASK) {
-              // Read FAR here
-              CURRENT_FAR = readFar();
-              checkFrameAna(CURRENT_FAR);
-            }
-            if (lockCheckCd.hasTimedOut()) {
-              checkLocks();
-              lockCheckCd.resetTimer();
-            }
-            // Clear interrupts with dummy read
-            dummy = *(registerBaseAddress + PDEC_PIR_OFFSET);
-          }
-        } else {
-          sif::error << "PdecHandler::irqOperation: Poll error with errno " << errno << ": "
-                     << strerror(errno) << std::endl;
-          triggerEvent(POLL_SYSCALL_ERROR_PDEC, errno);
-          close(fd);
-          state = State::INIT;
-          return returnvalue::FAILED;
+      case State::INIT: {
+        result = handleInitState();
+        if (result == returnvalue::OK) {
+          openIrqFile(&fd);
         }
         break;
       }
+      case State::PDEC_RESET: {
+        result = pdecToReset();
+        if (result != returnvalue::OK) {
+          triggerEvent(PDEC_RESET_FAILED);
+        }
+        state = State::INIT;
+        break;
+      }
+      case State::RUNNING: {
+        checkLocks();
+        checkAndHandleIrqs(fd, info);
+        break;
+      }
       case State::WAIT_FOR_RECOVERY:
+        TaskFactory::delayTask(400);
         break;
       default:
+        // Should never happen.
         sif::error << "PdecHandler::performOperation: Invalid state" << std::endl;
+        TaskFactory::delayTask(400);
         break;
     }
   }
@@ -226,18 +215,117 @@ ReturnValue_t PdecHandler::irqOperation() {
   return returnvalue::OK;
 }
 
+ReturnValue_t PdecHandler::handleInitState() {
+  ReturnValue_t result = firstLoop();
+  if (result != returnvalue::OK) {
+    if (result == LocalParameterHandler::SD_NOT_READY) {
+      TaskFactory::delayTask(400);
+      if (initTries == MAX_INIT_TRIES) {
+        sif::error << "PdecHandler::handleInitState: SD card never "
+                      "becomes ready"
+                   << std::endl;
+        state = State::WAIT_FOR_RECOVERY;
+      } else {
+        state = State::INIT;
+      }
+      return result;
+    }
+    state = State::WAIT_FOR_RECOVERY;
+    return result;
+  }
+  state = State::RUNNING;
+  return returnvalue::OK;
+}
+
+void PdecHandler::openIrqFile(int* fd) {
+  *fd = open(uioNames.irq, O_RDWR);
+  if (*fd < 0) {
+    sif::error << "PdecHandler::irqOperation: Opening UIO IRQ file" << uioNames.irq << " failed"
+               << std::endl;
+    triggerEvent(OPEN_IRQ_FILE_FAILED);
+    state = State::WAIT_FOR_RECOVERY;
+  }
+}
+
+ReturnValue_t PdecHandler::checkAndHandleIrqs(int fd, uint32_t& info) {
+  ssize_t nb = write(fd, &info, sizeof(info));
+  if (nb != static_cast<ssize_t>(sizeof(info))) {
+    sif::error << "PdecHandler::irqOperation: Unmasking IRQ failed" << std::endl;
+    triggerEvent(WRITE_SYSCALL_ERROR_PDEC, errno);
+    close(fd);
+    state = State::INIT;
+    return returnvalue::FAILED;
+  }
+  struct pollfd fds = {.fd = fd, .events = POLLIN, .revents = 0};
+  int ret = poll(&fds, 1, IRQ_TIMEOUT_MS);
+  if (ret == 0) {
+    // No TCs for timeout period
+    genericCheckCd.resetTimer();
+    resetIrqLimiters();
+  } else if (ret >= 1) {
+    // Interrupt handling.
+    nb = read(fd, &info, sizeof(info));
+    interruptCounter++;
+    if (nb == static_cast<ssize_t>(sizeof(info))) {
+      uint32_t pisr = *(registerBaseAddress + PDEC_PISR_OFFSET);
+      if ((pisr & TC_NEW_MASK) == TC_NEW_MASK) {
+        // handle TC
+        handleNewTc();
+      }
+      if ((pisr & TC_ABORT_MASK) == TC_ABORT_MASK) {
+        tcAbortCounter += 1;
+      }
+      if ((pisr & NEW_FAR_MASK) == NEW_FAR_MASK) {
+        // Read FAR here
+        CURRENT_FAR = readFar();
+        checkFrameAna(CURRENT_FAR);
+      }
+      // Clear interrupts with dummy read. Volatile is important here to prevent
+      // compiler opitmizations in release builds!
+      volatile uint32_t dummy = *(registerBaseAddress + PDEC_PIR_OFFSET);
+      static_cast<void>(dummy);
+
+      if (genericCheckCd.hasTimedOut()) {
+        genericCheckCd.resetTimer();
+        if (interruptWindowCd.hasTimedOut()) {
+          if (interruptCounter >= MAX_ALLOWED_IRQS_PER_WINDOW) {
+            sif::error << "PdecHandler::irqOperation: Possible IRQ storm" << std::endl;
+            triggerEvent(TOO_MANY_IRQS, MAX_ALLOWED_IRQS_PER_WINDOW);
+            resetIrqLimiters();
+            TaskFactory::delayTask(400);
+            return returnvalue::FAILED;
+          }
+          resetIrqLimiters();
+        }
+      }
+    }
+  } else {
+    sif::error << "PdecHandler::irqOperation: Poll error with errno " << errno << ": "
+               << strerror(errno) << std::endl;
+    triggerEvent(POLL_SYSCALL_ERROR_PDEC, errno);
+    close(fd);
+    state = State::INIT;
+    return returnvalue::FAILED;
+  }
+  return returnvalue::OK;
+}
+
 void PdecHandler::readCommandQueue(void) {
-  CommandMessage commandMessage;
+  CommandMessage message;
   ReturnValue_t result = returnvalue::FAILED;
 
-  result = commandQueue->receiveMessage(&commandMessage);
+  result = commandQueue->receiveMessage(&message);
   if (result == returnvalue::OK) {
-    result = actionHelper.handleActionMessage(&commandMessage);
+    result = actionHelper.handleActionMessage(&message);
+    if (result == returnvalue::OK) {
+      return;
+    }
+    result = paramHelper.handleParameterMessage(&message);
     if (result == returnvalue::OK) {
       return;
     }
     CommandMessage reply;
-    reply.setReplyRejected(CommandMessage::UNKNOWN_COMMAND, commandMessage.getCommand());
+    reply.setReplyRejected(CommandMessage::UNKNOWN_COMMAND, message.getCommand());
     commandQueue->reply(&reply);
     return;
   }
@@ -245,26 +333,69 @@ void PdecHandler::readCommandQueue(void) {
 
 MessageQueueId_t PdecHandler::getCommandQueue() const { return commandQueue->getId(); }
 
-void PdecHandler::writePdecConfigDuringReset(PdecConfig& pdecConfig) {
-  *(memoryBaseAddress + FRAME_HEADER_OFFSET) = pdecConfig.getConfigWord(0);
-  *(memoryBaseAddress + FRAME_HEADER_OFFSET + 1) = pdecConfig.getConfigWord(1);
-
-  // Configure all MAP IDs as invalid
-  for (int idx = 0; idx <= MAX_MAP_ADDR; idx += 4) {
-    *(memoryBaseAddress + MAP_ADDR_LUT_OFFSET + idx / 4) =
-        NO_DESTINATION << 24 | NO_DESTINATION << 16 | NO_DESTINATION << 8 | NO_DESTINATION;
+ReturnValue_t PdecHandler::executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
+                                         const uint8_t* data, size_t size) {
+  switch (actionId) {
+    case PRINT_CLCW:
+      printClcw();
+      return EXECUTION_FINISHED;
+    case PRINT_PDEC_MON:
+      printPdecMon();
+      return EXECUTION_FINISHED;
+    default:
+      return COMMAND_NOT_IMPLEMENTED;
   }
+}
 
-  // All TCs with MAP ID 7 will be routed to the PM module (can then be read from memory)
-  uint8_t routeToPm = calcMapAddrEntry(PM_BUFFER);
-  *(memoryBaseAddress + MAP_ADDR_LUT_OFFSET + 1) =
-      (NO_DESTINATION << 24) | (NO_DESTINATION << 16) | (NO_DESTINATION << 8) | routeToPm;
-
-  // Write map id clock frequencies
-  for (int idx = 0; idx <= MAX_MAP_ADDR; idx += 4) {
-    *(memoryBaseAddress + MAP_CLK_FREQ_OFFSET + idx / 4) =
-        MAP_CLK_FREQ << 24 | MAP_CLK_FREQ << 16 | MAP_CLK_FREQ << 8 | MAP_CLK_FREQ;
+ReturnValue_t PdecHandler::getParameter(uint8_t domainId, uint8_t uniqueIdentifier,
+                                        ParameterWrapper* parameterWrapper,
+                                        const ParameterWrapper* newValues, uint16_t startAtIndex) {
+  if ((domainId == 0) and (uniqueIdentifier == ParameterId::POSITIVE_WINDOW)) {
+    uint8_t newVal = 0;
+    ReturnValue_t result = newValues->getElement(&newVal);
+    if (result != returnvalue::OK) {
+      return result;
+    }
+    uint8_t positiveWindow = 0;
+    result = pdecConfig.getPositiveWindow(positiveWindow);
+    if (result != returnvalue::OK) {
+      sif::warning << "PdecHandler::getParameter: Failed to get positive window from pdec config"
+                   << std::endl;
+      return returnvalue::FAILED;
+    }
+    parameterWrapper->set(positiveWindow);
+    result = pdecConfig.setPositiveWindow(newVal);
+    if (result != returnvalue::OK) {
+      sif::warning << "PdecHandler::getParameter: Failed to set positive window" << std::endl;
+      return returnvalue::FAILED;
+    }
+    // PDEC needs reset to apply this parameter change
+    state = State::PDEC_RESET;
+    return returnvalue::OK;
+  } else if ((domainId == 0) and (uniqueIdentifier == ParameterId::NEGATIVE_WINDOW)) {
+    uint8_t newVal = 0;
+    ReturnValue_t result = newValues->getElement(&newVal);
+    if (result != returnvalue::OK) {
+      return result;
+    }
+    uint8_t negativeWindow = 0;
+    result = pdecConfig.getNegativeWindow(negativeWindow);
+    if (result != returnvalue::OK) {
+      sif::warning << "PdecHandler::getParameter: Failed to get negative window from pdec config"
+                   << std::endl;
+      return returnvalue::FAILED;
+    }
+    parameterWrapper->set(negativeWindow);
+    result = pdecConfig.setNegativeWindow(newVal);
+    if (result != returnvalue::OK) {
+      sif::warning << "PdecHandler::getParameter: Failed to set negative window" << std::endl;
+      return returnvalue::FAILED;
+    }
+    // PDEC needs reset to apply this parameter change
+    state = State::PDEC_RESET;
+    return returnvalue::OK;
   }
+  return returnvalue::OK;
 }
 
 ReturnValue_t PdecHandler::resetFarStatFlag() {
@@ -293,6 +424,17 @@ ReturnValue_t PdecHandler::releasePdec() {
   return result;
 }
 
+ReturnValue_t PdecHandler::pdecToReset() {
+  ReturnValue_t result = returnvalue::OK;
+  result = gpioComIF->pullLow(pdecReset);
+  if (result != returnvalue::OK) {
+    sif::error << "PdecHandler::pdecToReset: Failed to pull PDEC reset line"
+                  " to low"
+               << std::endl;
+  }
+  return result;
+}
+
 bool PdecHandler::newTcReceived() {
   uint32_t pdecFar = readFar();
 
@@ -530,23 +672,6 @@ void PdecHandler::printTC(uint32_t tcLength) {
   sif::info << tcSegmentStream.str() << std::endl;
 }
 
-uint8_t PdecHandler::calcMapAddrEntry(uint8_t moduleId) {
-  uint8_t lutEntry = 0;
-  uint8_t parity = getOddParity(moduleId | (1 << VALID_POSITION));
-  lutEntry = (parity << PARITY_POSITION) | (1 << VALID_POSITION) | moduleId;
-  return lutEntry;
-}
-
-uint8_t PdecHandler::getOddParity(uint8_t number) {
-  uint8_t parityBit = 0;
-  uint8_t countBits = 0;
-  for (unsigned int idx = 0; idx < sizeof(number) * 8; idx++) {
-    countBits += (number >> idx) & 0x1;
-  }
-  parityBit = ~(countBits & 0x1) & 0x1;
-  return parityBit;
-}
-
 uint32_t PdecHandler::getClcw() { return *(registerBaseAddress + PDEC_CLCW_OFFSET); }
 
 uint32_t PdecHandler::getPdecMon() { return *(registerBaseAddress + PDEC_MON_OFFSET); }
@@ -618,6 +743,11 @@ void PdecHandler::printPdecMon() {
 
 uint32_t PdecHandler::readFar() { return *(registerBaseAddress + PDEC_FAR_OFFSET); }
 
+void PdecHandler::resetIrqLimiters() {
+  interruptWindowCd.resetTimer();
+  interruptCounter = 0;
+}
+
 std::string PdecHandler::getMonStatusString(uint32_t status) {
   switch (status) {
     case TC_CHANNEL_INACTIVE:
@@ -632,17 +762,3 @@ std::string PdecHandler::getMonStatusString(uint32_t status) {
       break;
   }
 }
-
-ReturnValue_t PdecHandler::executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
-                                         const uint8_t* data, size_t size) {
-  switch (actionId) {
-    case PRINT_CLCW:
-      printClcw();
-      return EXECUTION_FINISHED;
-    case PRINT_PDEC_MON:
-      printPdecMon();
-      return EXECUTION_FINISHED;
-    default:
-      return COMMAND_NOT_IMPLEMENTED;
-  }
-}

linux/ipcore/PdecHandler.h

@@ -9,6 +9,8 @@
 #include "fsfw/action/ActionHelper.h"
 #include "fsfw/action/HasActionsIF.h"
 #include "fsfw/objectmanager/SystemObject.h"
+#include "fsfw/parameters/ParameterHelper.h"
+#include "fsfw/parameters/ReceivesParameterMessagesIF.h"
 #include "fsfw/returnvalues/returnvalue.h"
 #include "fsfw/storagemanager/StorageManagerIF.h"
 #include "fsfw/tasks/ExecutableObjectIF.h"
@@ -41,7 +43,10 @@ struct UioNames {
  *
  * @author  J. Meier
  */
-class PdecHandler : public SystemObject, public ExecutableObjectIF, public HasActionsIF {
+class PdecHandler : public SystemObject,
+                    public ExecutableObjectIF,
+                    public HasActionsIF,
+                    public ReceivesParameterMessagesIF {
  public:
   static constexpr dur_millis_t IRQ_TIMEOUT_MS = 500;
 
@@ -70,6 +75,10 @@ class PdecHandler : public SystemObject, public ExecutableObjectIF, public HasAc
   ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
                               const uint8_t* data, size_t size) override;
 
+  ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueIdentifier,
+                             ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues,
+                             uint16_t startAtIndex) override;
+
   static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PDEC_HANDLER;
 
   //! [EXPORT] : [COMMENT] Frame acceptance report signals an invalid frame
@@ -87,10 +96,16 @@ class PdecHandler : public SystemObject, public ExecutableObjectIF, public HasAc
   static const Event LOST_CARRIER_LOCK_PDEC = MAKE_EVENT(5, severity::INFO);
   //! [EXPORT] : [COMMENT] Lost bit lock
   static const Event LOST_BIT_LOCK_PDEC = MAKE_EVENT(6, severity::INFO);
+  //! [EXPORT] : [COMMENT] Too many IRQs over the time window of one second. P1: Allowed TCs
+  static constexpr Event TOO_MANY_IRQS = MAKE_EVENT(7, severity::MEDIUM);
   static constexpr Event POLL_SYSCALL_ERROR_PDEC =
-      event::makeEvent(SUBSYSTEM_ID, 7, severity::MEDIUM);
-  static constexpr Event WRITE_SYSCALL_ERROR_PDEC =
       event::makeEvent(SUBSYSTEM_ID, 8, severity::MEDIUM);
+  static constexpr Event WRITE_SYSCALL_ERROR_PDEC =
+      event::makeEvent(SUBSYSTEM_ID, 9, severity::HIGH);
+  //! [EXPORT] : [COMMENT] Failed to pull PDEC reset to low
+  static constexpr Event PDEC_RESET_FAILED = event::makeEvent(SUBSYSTEM_ID, 10, severity::HIGH);
+  //! [EXPORT] : [COMMENT] Failed to open the IRQ uio file
+  static constexpr Event OPEN_IRQ_FILE_FAILED = event::makeEvent(SUBSYSTEM_ID, 11, severity::HIGH);
 
  private:
   static const uint8_t INTERFACE_ID = CLASS_ID::PDEC_HANDLER;
@@ -141,9 +156,6 @@ class PdecHandler : public SystemObject, public ExecutableObjectIF, public HasAc
   static const int REGISTER_MAP_SIZE = 0x4000;
 #endif /* BOARD_TE0720 == 1 */
 
-  // 0x200 / 4 = 0x80
-  static const uint32_t FRAME_HEADER_OFFSET = 0x80;
-
   static const size_t MAX_TC_SEGMENT_SIZE = 1017;
   static const uint8_t MAP_ID_MASK = 0x3F;
 
@@ -153,15 +165,6 @@ class PdecHandler : public SystemObject, public ExecutableObjectIF, public HasAc
   static const uint32_t PHYSICAL_RAM_BASE_ADDRESS = 0x26000000;
 #endif
 
-  static const uint32_t MAP_ADDR_LUT_OFFSET = 0xA0;
-  static const uint32_t MAP_CLK_FREQ_OFFSET = 0x90;
-
-  static const uint8_t MAX_MAP_ADDR = 63;
-  // Writing this to the map address in the look up table will invalidate a MAP ID.
-  static const uint8_t NO_DESTINATION = 0;
-  static const uint8_t VALID_POSITION = 6;
-  static const uint8_t PARITY_POSITION = 7;
-
   // Expected value stored in FAR register after reset
   static const uint32_t FAR_RESET = 0x7FE0;
 
@@ -170,15 +173,17 @@ class PdecHandler : public SystemObject, public ExecutableObjectIF, public HasAc
   static const uint32_t NO_RF_MASK = 0x8000;
   static const uint32_t NO_BITLOCK_MASK = 0x4000;
 
-  /**
-   * TCs with map addresses (also know as Map IDs) assigned to this channel will be stored in
-   * the PDEC memory.
-   */
-  static const uint8_t PM_BUFFER = 7;
+  static const uint32_t MAX_INIT_TRIES = 20;
 
-  // MAP clock frequency. Must be a value between 1 and 13 otherwise the TC segment will be
-  // discarded
-  static const uint8_t MAP_CLK_FREQ = 2;
+  class ParameterId {
+   public:
+    // ID of the parameter to update the positive window of AD frames
+    static const uint8_t POSITIVE_WINDOW = 0;
+    // ID of the parameter to update the negative window of AD frames
+    static const uint8_t NEGATIVE_WINDOW = 1;
+  };
+
+  static constexpr uint32_t MAX_ALLOWED_IRQS_PER_WINDOW = 800;
 
   enum class FrameAna_t : uint8_t {
     ABANDONED_CLTU,
@@ -202,17 +207,20 @@ class PdecHandler : public SystemObject, public ExecutableObjectIF, public HasAc
     INCORRECT_BC_CC
   };
 
-  enum class State : uint8_t { INIT, RUNNING, WAIT_FOR_RECOVERY };
+  enum class State : uint8_t { INIT, PDEC_RESET, RUNNING, WAIT_FOR_RECOVERY };
 
   static uint32_t CURRENT_FAR;
 
-  Countdown lockCheckCd = Countdown(IRQ_TIMEOUT_MS);
+  Countdown genericCheckCd = Countdown(IRQ_TIMEOUT_MS);
   object_id_t tcDestinationId;
 
   AcceptsTelecommandsIF* tcDestination = nullptr;
 
   LinuxLibgpioIF* gpioComIF = nullptr;
 
+  uint32_t interruptCounter = 0;
+  Countdown interruptWindowCd = Countdown(1000);
+
   /**
    * Reset signal is required to hold PDEC in reset state until the configuration has been
    * written to the appropriate memory space.
@@ -252,6 +260,20 @@ class PdecHandler : public SystemObject, public ExecutableObjectIF, public HasAc
 
   UioNames uioNames;
 
+  ParameterHelper paramHelper;
+
+  PdecConfig pdecConfig;
+
+  uint32_t initTries = 0;
+
+  /**
+   * @brief	Performs initialization stuff which must be performed in first
+   * 				loop of running task
+   *
+   * @return OK if successful, otherwise FAILED
+   */
+  ReturnValue_t firstLoop();
+
   /**
    * @brief   Reads and handles messages stored in the commandQueue
    */
@@ -259,6 +281,9 @@ class PdecHandler : public SystemObject, public ExecutableObjectIF, public HasAc
 
   ReturnValue_t polledOperation();
   ReturnValue_t irqOperation();
+  ReturnValue_t handleInitState();
+  void openIrqFile(int* fd);
+  ReturnValue_t checkAndHandleIrqs(int fd, uint32_t& info);
 
   uint32_t readFar();
 
@@ -283,6 +308,14 @@ class PdecHandler : public SystemObject, public ExecutableObjectIF, public HasAc
    */
   ReturnValue_t releasePdec();
 
+  /**
+   * @brief Will set PDEC in reset state. Use releasePdec() to release PDEC
+   * 				from reset state
+   *
+   * @return OK if successful, otherwise error return value
+   */
+  ReturnValue_t pdecToReset();
+
   /**
    * @brief   Reads the FAR register and checks if a new TC has been received.
    */
@@ -294,6 +327,8 @@ class PdecHandler : public SystemObject, public ExecutableObjectIF, public HasAc
    */
   void checkLocks();
 
+  void resetIrqLimiters();
+
   /**
    * @brief   Analyzes the FramAna field (frame analysis data) of a FAR report.
    *
@@ -344,13 +379,6 @@ class PdecHandler : public SystemObject, public ExecutableObjectIF, public HasAc
    */
   uint8_t calcMapAddrEntry(uint8_t moduleId);
 
-  /**
-   * @brief   This functions calculates the odd parity of the bits in number.
-   *
-   * @param number    The number from which to calculate the odd parity.
-   */
-  uint8_t getOddParity(uint8_t number);
-
   /**
    * brief    Returns the 32-bit wide communication link control word (CLCW)
    */

linux/ipcore/pdecconfigdefs.h

@@ -0,0 +1,20 @@
+#ifndef LINUX_IPCORE_PDECCONFIGDEFS_H_
+#define LINUX_IPCORE_PDECCONFIGDEFS_H_
+
+#include <string>
+
+namespace pdecconfigdefs {
+
+namespace paramkeys {
+static const std::string POSITIVE_WINDOW = "positive_window";
+static const std::string NEGATIVE_WINDOW = "negattive_window";
+}  // namespace paramkeys
+
+namespace defaultvalue {
+static const uint8_t positiveWindow = 10;
+static const uint8_t negativeWindow = 151;
+}  // namespace defaultvalue
+
+}  // namespace pdecconfigdefs
+
+#endif /* LINUX_IPCORE_PDECCONFIGDEFS_H_ */

mission/acsDefs.h

@@ -25,6 +25,10 @@ static const Event SAFE_RATE_VIOLATION = MAKE_EVENT(0, severity::MEDIUM);
 static constexpr Event SAFE_RATE_RECOVERY = MAKE_EVENT(1, severity::MEDIUM);
 //!< Multiple RWs are invalid, not commandable and therefore higher ACS modes cannot be maintained.
 static constexpr Event MULTIPLE_RW_INVALID = MAKE_EVENT(2, severity::HIGH);
+//!< MEKF was not able to compute a solution.
+static constexpr Event MEKF_INVALID_INFO = MAKE_EVENT(3, severity::INFO);
+//!< MEKF was not able to compute a solution during any pointing ACS mode for a prolonged time.
+static constexpr Event MEKF_INVALID_MODE_VIOLATION = MAKE_EVENT(4, severity::HIGH);
 
 extern const char* getModeStr(AcsMode mode);
 

mission/comDefs.h

@@ -24,7 +24,7 @@ enum class CcsdsSubmode : uint8_t {
   DATARATE_HIGH = 2,
   DATARATE_DEFAULT = 3
 };
-enum class ParameterId : uint8_t { DATARATE = 0 };
+enum class ParameterId : uint8_t { DATARATE = 0, TRANSMITTER_TIMEOUT = 1 };
 
 }  // namespace com
 

mission/config/configfile.h

@@ -0,0 +1,9 @@
+#ifndef MISSION_CONFIG_CONFIGFILE_H_
+#define MISSION_CONFIG_CONFIGFILE_H_
+
+namespace configfile {
+// Name of global config file relative to currently mounted SD card
+static const char sdrelative[] = "config/global_config.json";
+}  // namespace configfile
+
+#endif /* MISSION_CONFIG_CONFIGFILE_H_ */

mission/controller/AcsController.cpp

@@ -1,9 +1,8 @@
 #include "AcsController.h"
 
 #include <fsfw/datapool/PoolReadGuard.h>
-
-#include "mission/acsDefs.h"
-#include "mission/config/torquer.h"
+#include <mission/acsDefs.h>
+#include <mission/config/torquer.h>
 
 AcsController::AcsController(object_id_t objectId)
     : ExtendedControllerBase(objectId),
@@ -14,8 +13,6 @@ AcsController::AcsController(object_id_t objectId)
       safeCtrl(&acsParameters),
       detumble(&acsParameters),
       ptgCtrl(&acsParameters),
-      detumbleCounter{0},
-      multipleRwUnavailableCounter{0},
       parameterHelper(this),
       mgmDataRaw(this),
       mgmDataProcessed(this),
@@ -28,6 +25,14 @@ AcsController::AcsController(object_id_t objectId)
       ctrlValData(this),
       actuatorCmdData(this) {}
 
+ReturnValue_t AcsController::initialize() {
+  ReturnValue_t result = parameterHelper.initialize();
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  return ExtendedControllerBase::initialize();
+}
+
 ReturnValue_t AcsController::handleCommandMessage(CommandMessage *message) {
   ReturnValue_t result = actionHelper.handleActionMessage(message);
   if (result == returnvalue::OK) {
@@ -40,6 +45,26 @@ ReturnValue_t AcsController::handleCommandMessage(CommandMessage *message) {
   return result;
 }
 
+ReturnValue_t AcsController::executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
+                                           const uint8_t *data, size_t size) {
+  switch (actionId) {
+    case SOLAR_ARRAY_DEPLOYMENT_SUCCESSFUL: {
+      ReturnValue_t result = guidance.solarArrayDeploymentComplete();
+      if (result == returnvalue::FAILED) {
+        return FILE_DELETION_FAILED;
+      }
+      return HasActionsIF::EXECUTION_FINISHED;
+    }
+    case RESET_MEKF: {
+      navigation.resetMekf(&mekfData);
+      return HasActionsIF::EXECUTION_FINISHED;
+    }
+    default: {
+      return HasActionsIF::INVALID_ACTION_ID;
+    }
+  }
+}
+
 MessageQueueId_t AcsController::getCommandQueue() const { return commandQueue->getId(); }
 
 ReturnValue_t AcsController::getParameter(uint8_t domainId, uint8_t parameterId,
@@ -54,6 +79,25 @@ void AcsController::performControlOperation() {
 #if OBSW_THREAD_TRACING == 1
   trace::threadTrace(opCounter, "ACS & TCS PST");
 #endif
+  {
+    PoolReadGuard pg(&mgmDataRaw);
+    if (pg.getReadResult() == returnvalue::OK) {
+      copyMgmData();
+    }
+  }
+  {
+    PoolReadGuard pg(&susDataRaw);
+    if (pg.getReadResult() == returnvalue::OK) {
+      copySusData();
+    }
+  }
+  {
+    PoolReadGuard pg(&gyrDataRaw);
+    if (pg.getReadResult() == returnvalue::OK) {
+      copyGyrData();
+    }
+  }
+
   switch (internalState) {
     case InternalState::STARTUP: {
       initialCountdown.resetTimer();
@@ -89,25 +133,6 @@ void AcsController::performControlOperation() {
     default:
       break;
   }
-
-  {
-    PoolReadGuard pg(&mgmDataRaw);
-    if (pg.getReadResult() == returnvalue::OK) {
-      copyMgmData();
-    }
-  }
-  {
-    PoolReadGuard pg(&susDataRaw);
-    if (pg.getReadResult() == returnvalue::OK) {
-      copySusData();
-    }
-  }
-  {
-    PoolReadGuard pg(&gyrDataRaw);
-    if (pg.getReadResult() == returnvalue::OK) {
-      copyGyrData();
-    }
-  }
 }
 
 void AcsController::performSafe() {
@@ -116,17 +141,24 @@ void AcsController::performSafe() {
 
   sensorProcessing.process(now, &sensorValues, &mgmDataProcessed, &susDataProcessed,
                            &gyrDataProcessed, &gpsDataProcessed, &acsParameters);
-  ReturnValue_t validMekf;
-  navigation.useMekf(&sensorValues, &gyrDataProcessed, &mgmDataProcessed, &susDataProcessed,
-                     &mekfData, &validMekf);
-
-  // give desired satellite rate and sun direction to align
+  ReturnValue_t result = navigation.useMekf(&sensorValues, &gyrDataProcessed, &mgmDataProcessed,
+                                            &susDataProcessed, &mekfData);
+  if (result != MultiplicativeKalmanFilter::MEKF_RUNNING &&
+      result != MultiplicativeKalmanFilter::MEKF_INITIALIZED) {
+    if (not mekfInvalidFlag) {
+      triggerEvent(acs::MEKF_INVALID_INFO);
+      mekfInvalidFlag = true;
+    }
+  } else {
+    mekfInvalidFlag = false;
+  }
+  // get desired satellite rate and sun direction to align
   double satRateSafe[3] = {0, 0, 0}, sunTargetDir[3] = {0, 0, 0};
   guidance.getTargetParamsSafe(sunTargetDir, satRateSafe);
   // if MEKF is working
   double magMomMtq[3] = {0, 0, 0}, errAng = 0.0;
   bool magMomMtqValid = false;
-  if (validMekf == returnvalue::OK) {
+  if (result == MultiplicativeKalmanFilter::MEKF_RUNNING) {
     safeCtrl.safeMekf(now, mekfData.quatMekf.value, mekfData.quatMekf.isValid(),
                       mgmDataProcessed.magIgrfModel.value, mgmDataProcessed.magIgrfModel.isValid(),
                       susDataProcessed.sunIjkModel.value, susDataProcessed.isValid(),
@@ -141,24 +173,9 @@ void AcsController::performSafe() {
         sunTargetDir, satRateSafe, &errAng, magMomMtq, &magMomMtqValid);
   }
 
-  int16_t cmdDipolMtqs[3] = {0, 0, 0};
   actuatorCmd.cmdDipolMtq(magMomMtq, cmdDipolMtqs);
 
-  {
-    PoolReadGuard pg(&ctrlValData);
-    if (pg.getReadResult() == returnvalue::OK) {
-      double unitQuat[4] = {0, 0, 0, 1};
-      std::memcpy(ctrlValData.tgtQuat.value, unitQuat, 4 * sizeof(double));
-      ctrlValData.tgtQuat.setValid(false);
-      std::memcpy(ctrlValData.errQuat.value, unitQuat, 4 * sizeof(double));
-      ctrlValData.errQuat.setValid(false);
-      ctrlValData.errAng.value = errAng;
-      ctrlValData.errAng.setValid(true);
-      ctrlValData.setValidity(true, false);
-    }
-  }
-
-  //	Detumble check and switch
+  // detumble check and switch
   if (mekfData.satRotRateMekf.isValid() &&
       VectorOperations<double>::norm(mekfData.satRotRateMekf.value, 3) >
           acsParameters.detumbleParameter.omegaDetumbleStart) {
@@ -176,20 +193,8 @@ void AcsController::performSafe() {
     triggerEvent(acs::SAFE_RATE_VIOLATION);
   }
 
-  {
-    PoolReadGuard pg(&actuatorCmdData);
-    if (pg.getReadResult() == returnvalue::OK) {
-      int32_t zeroVec[4] = {0, 0, 0, 0};
-      std::memcpy(actuatorCmdData.rwTargetTorque.value, zeroVec, 4 * sizeof(int32_t));
-      actuatorCmdData.rwTargetTorque.setValid(false);
-      std::memcpy(actuatorCmdData.rwTargetSpeed.value, zeroVec, 4 * sizeof(int32_t));
-      actuatorCmdData.rwTargetSpeed.setValid(false);
-      std::memcpy(actuatorCmdData.mtqTargetDipole.value, cmdDipolMtqs, 3 * sizeof(int16_t));
-      actuatorCmdData.mtqTargetDipole.setValid(true);
-      actuatorCmdData.setValidity(true, false);
-    }
-  }
-
+  updateCtrlValData(errAng);
+  updateActuatorCmdData(cmdDipolMtqs);
   //  commandActuators(cmdDipolMtqs[0], cmdDipolMtqs[1], cmdDipolMtqs[2],
   //                   acsParameters.magnetorquesParameter.torqueDuration, 0, 0, 0, 0,
   //                   acsParameters.rwHandlingParameters.rampTime);
@@ -201,15 +206,21 @@ void AcsController::performDetumble() {
 
   sensorProcessing.process(now, &sensorValues, &mgmDataProcessed, &susDataProcessed,
                            &gyrDataProcessed, &gpsDataProcessed, &acsParameters);
-  ReturnValue_t validMekf;
-  navigation.useMekf(&sensorValues, &gyrDataProcessed, &mgmDataProcessed, &susDataProcessed,
-                     &mekfData, &validMekf);
-
+  ReturnValue_t result = navigation.useMekf(&sensorValues, &gyrDataProcessed, &mgmDataProcessed,
+                                            &susDataProcessed, &mekfData);
+  if (result != MultiplicativeKalmanFilter::MEKF_RUNNING &&
+      result != MultiplicativeKalmanFilter::MEKF_INITIALIZED) {
+    if (not mekfInvalidFlag) {
+      triggerEvent(acs::MEKF_INVALID_INFO);
+      mekfInvalidFlag = true;
+    }
+  } else {
+    mekfInvalidFlag = false;
+  }
   double magMomMtq[3] = {0, 0, 0};
   detumble.bDotLaw(mgmDataProcessed.mgmVecTotDerivative.value,
                    mgmDataProcessed.mgmVecTotDerivative.isValid(), mgmDataProcessed.mgmVecTot.value,
                    mgmDataProcessed.mgmVecTot.isValid(), magMomMtq);
-  int16_t cmdDipolMtqs[3] = {0, 0, 0};
   actuatorCmd.cmdDipolMtq(magMomMtq, cmdDipolMtqs);
 
   if (mekfData.satRotRateMekf.isValid() &&
@@ -229,19 +240,8 @@ void AcsController::performDetumble() {
     triggerEvent(acs::SAFE_RATE_RECOVERY);
   }
 
-  {
-    PoolReadGuard pg(&actuatorCmdData);
-    if (pg.getReadResult() == returnvalue::OK) {
-      std::memset(actuatorCmdData.rwTargetTorque.value, 0, 4 * sizeof(double));
-      actuatorCmdData.rwTargetTorque.setValid(false);
-      std::memset(actuatorCmdData.rwTargetSpeed.value, 0, 4 * sizeof(int32_t));
-      actuatorCmdData.rwTargetSpeed.setValid(false);
-      std::memcpy(actuatorCmdData.mtqTargetDipole.value, cmdDipolMtqs, 3 * sizeof(int16_t));
-      actuatorCmdData.mtqTargetDipole.setValid(true);
-      actuatorCmdData.setValidity(true, false);
-    }
-  }
-
+  disableCtrlValData();
+  updateActuatorCmdData(cmdDipolMtqs);
   //  commandActuators(cmdDipolMtqs[0], cmdDipolMtqs[1], cmdDipolMtqs[2],
   //                   acsParameters.magnetorquesParameter.torqueDuration, 0, 0, 0, 0,
   //                   acsParameters.rwHandlingParameters.rampTime);
@@ -253,23 +253,35 @@ void AcsController::performPointingCtrl() {
 
   sensorProcessing.process(now, &sensorValues, &mgmDataProcessed, &susDataProcessed,
                            &gyrDataProcessed, &gpsDataProcessed, &acsParameters);
-  ReturnValue_t validMekf;
-  navigation.useMekf(&sensorValues, &gyrDataProcessed, &mgmDataProcessed, &susDataProcessed,
-                     &mekfData, &validMekf);
-
-  double targetQuat[4] = {0, 0, 0, 0}, refSatRate[3] = {0, 0, 0};
-  double quatRef[4] = {0, 0, 0, 0};
+  ReturnValue_t result = navigation.useMekf(&sensorValues, &gyrDataProcessed, &mgmDataProcessed,
+                                            &susDataProcessed, &mekfData);
+  if (result != MultiplicativeKalmanFilter::MEKF_RUNNING &&
+      result != MultiplicativeKalmanFilter::MEKF_INITIALIZED) {
+    if (not mekfInvalidFlag) {
+      triggerEvent(acs::MEKF_INVALID_INFO);
+      mekfInvalidFlag = true;
+    }
+    if (mekfInvalidCounter > 4) {
+      triggerEvent(acs::MEKF_INVALID_MODE_VIOLATION);
+    }
+    mekfInvalidCounter++;
+    //    commandActuators(0, 0, 0, acsParameters.magnetorquesParameter.torqueDuration,
+    //    cmdSpeedRws[0],
+    //                     cmdSpeedRws[1], cmdSpeedRws[2], cmdSpeedRws[3],
+    //                     acsParameters.rwHandlingParameters.rampTime);
+    return;
+  } else {
+    mekfInvalidFlag = false;
+    mekfInvalidCounter = 0;
+  }
   uint8_t enableAntiStiction = true;
-
-  double quatErrorComplete[4] = {0, 0, 0, 0}, quatError[3] = {0, 0, 0},
-         deltaRate[3] = {0, 0, 0};  // ToDo: check if pointer needed
   double rwPseudoInv[4][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
-  ReturnValue_t result = guidance.getDistributionMatrixRw(&sensorValues, *rwPseudoInv);
+  result = guidance.getDistributionMatrixRw(&sensorValues, *rwPseudoInv);
   if (result == returnvalue::FAILED) {
-    multipleRwUnavailableCounter++;
     if (multipleRwUnavailableCounter > 4) {
       triggerEvent(acs::MULTIPLE_RW_INVALID);
     }
+    multipleRwUnavailableCounter++;
     return;
   } else {
     multipleRwUnavailableCounter = 0;
@@ -278,40 +290,37 @@ void AcsController::performPointingCtrl() {
   double torqueRws[4] = {0, 0, 0, 0}, torqueRwsScaled[4] = {0, 0, 0, 0};
   double mgtDpDes[3] = {0, 0, 0};
 
+  // Variables required for guidance
+  double targetQuat[4] = {0, 0, 0, 1}, targetSatRotRate[3] = {0, 0, 0}, errorQuat[4] = {0, 0, 0, 1},
+         errorAngle = 0, errorSatRotRate[3] = {0, 0, 0};
   switch (submode) {
     case acs::PTG_IDLE:
-      guidance.sunQuatPtg(&sensorValues, &mekfData, &susDataProcessed, &gpsDataProcessed, now,
-                          targetQuat, refSatRate);
-      std::memcpy(quatRef, acsParameters.targetModeControllerParameters.quatRef,
-                  4 * sizeof(double));
-      enableAntiStiction = acsParameters.targetModeControllerParameters.enableAntiStiction;
-      guidance.comparePtg(targetQuat, &mekfData, quatRef, refSatRate, quatErrorComplete, quatError,
-                          deltaRate);
-      ptgCtrl.ptgLaw(&acsParameters.targetModeControllerParameters, quatError, deltaRate,
-                     *rwPseudoInv, torquePtgRws);
+      guidance.targetQuatPtgSun(susDataProcessed.sunIjkModel.value, targetQuat, targetSatRotRate);
+      guidance.comparePtg(mekfData.quatMekf.value, mekfData.satRotRateMekf.value, targetQuat,
+                          targetSatRotRate, errorQuat, errorSatRotRate, errorAngle);
       ptgCtrl.ptgNullspace(
-          &acsParameters.targetModeControllerParameters, &(sensorValues.rw1Set.currSpeed.value),
+          &acsParameters.idleModeControllerParameters, &(sensorValues.rw1Set.currSpeed.value),
           &(sensorValues.rw2Set.currSpeed.value), &(sensorValues.rw3Set.currSpeed.value),
           &(sensorValues.rw4Set.currSpeed.value), rwTrqNs);
       VectorOperations<double>::add(torquePtgRws, rwTrqNs, torqueRws, 4);
       actuatorCmd.scalingTorqueRws(torqueRws, torqueRwsScaled);
       ptgCtrl.ptgDesaturation(
-          &acsParameters.targetModeControllerParameters, mgmDataProcessed.mgmVecTot.value,
+          &acsParameters.idleModeControllerParameters, mgmDataProcessed.mgmVecTot.value,
           mgmDataProcessed.mgmVecTot.isValid(), mekfData.satRotRateMekf.value,
           &(sensorValues.rw1Set.currSpeed.value), &(sensorValues.rw2Set.currSpeed.value),
           &(sensorValues.rw3Set.currSpeed.value), &(sensorValues.rw4Set.currSpeed.value), mgtDpDes);
-
+      enableAntiStiction = acsParameters.idleModeControllerParameters.enableAntiStiction;
       break;
 
     case acs::PTG_TARGET:
-      guidance.targetQuatPtgThreeAxes(&sensorValues, &gpsDataProcessed, &mekfData, now, targetQuat,
-                                      refSatRate);
-      std::memcpy(quatRef, acsParameters.targetModeControllerParameters.quatRef,
-                  4 * sizeof(double));
-      enableAntiStiction = acsParameters.targetModeControllerParameters.enableAntiStiction;
-      guidance.comparePtg(targetQuat, &mekfData, quatRef, refSatRate, quatErrorComplete, quatError,
-                          deltaRate);
-      ptgCtrl.ptgLaw(&acsParameters.targetModeControllerParameters, quatError, deltaRate,
+      guidance.targetQuatPtgThreeAxes(now, gpsDataProcessed.gpsPosition.value,
+                                      gpsDataProcessed.gpsVelocity.value, targetQuat,
+                                      targetSatRotRate);
+      guidance.comparePtg(mekfData.quatMekf.value, mekfData.satRotRateMekf.value, targetQuat,
+                          targetSatRotRate, acsParameters.targetModeControllerParameters.quatRef,
+                          acsParameters.targetModeControllerParameters.refRotRate, errorQuat,
+                          errorSatRotRate, errorAngle);
+      ptgCtrl.ptgLaw(&acsParameters.targetModeControllerParameters, errorQuat, errorSatRotRate,
                      *rwPseudoInv, torquePtgRws);
       ptgCtrl.ptgNullspace(
           &acsParameters.targetModeControllerParameters, &(sensorValues.rw1Set.currSpeed.value),
@@ -324,17 +333,15 @@ void AcsController::performPointingCtrl() {
           mgmDataProcessed.mgmVecTot.isValid(), mekfData.satRotRateMekf.value,
           &(sensorValues.rw1Set.currSpeed.value), &(sensorValues.rw2Set.currSpeed.value),
           &(sensorValues.rw3Set.currSpeed.value), &(sensorValues.rw4Set.currSpeed.value), mgtDpDes);
+      enableAntiStiction = acsParameters.targetModeControllerParameters.enableAntiStiction;
       break;
 
     case acs::PTG_TARGET_GS:
-      guidance.targetQuatPtgGs(&sensorValues, &mekfData, &susDataProcessed, &gpsDataProcessed, now,
-                               targetQuat, refSatRate);
-      std::memcpy(quatRef, acsParameters.targetModeControllerParameters.quatRef,
-                  4 * sizeof(double));
-      enableAntiStiction = acsParameters.targetModeControllerParameters.enableAntiStiction;
-      guidance.comparePtg(targetQuat, &mekfData, quatRef, refSatRate, quatErrorComplete, quatError,
-                          deltaRate);
-      ptgCtrl.ptgLaw(&acsParameters.targetModeControllerParameters, quatError, deltaRate,
+      guidance.targetQuatPtgGs(now, gpsDataProcessed.gpsPosition.value,
+                               susDataProcessed.sunIjkModel.value, targetQuat, targetSatRotRate);
+      guidance.comparePtg(mekfData.quatMekf.value, mekfData.satRotRateMekf.value, targetQuat,
+                          targetSatRotRate, errorQuat, errorSatRotRate, errorAngle);
+      ptgCtrl.ptgLaw(&acsParameters.targetModeControllerParameters, errorQuat, errorSatRotRate,
                      *rwPseudoInv, torquePtgRws);
       ptgCtrl.ptgNullspace(
           &acsParameters.targetModeControllerParameters, &(sensorValues.rw1Set.currSpeed.value),
@@ -347,16 +354,18 @@ void AcsController::performPointingCtrl() {
           mgmDataProcessed.mgmVecTot.isValid(), mekfData.satRotRateMekf.value,
           &(sensorValues.rw1Set.currSpeed.value), &(sensorValues.rw2Set.currSpeed.value),
           &(sensorValues.rw3Set.currSpeed.value), &(sensorValues.rw4Set.currSpeed.value), mgtDpDes);
+      enableAntiStiction = acsParameters.targetModeControllerParameters.enableAntiStiction;
       break;
 
     case acs::PTG_NADIR:
-      guidance.quatNadirPtgThreeAxes(&sensorValues, &gpsDataProcessed, &mekfData, now, targetQuat,
-                                     refSatRate);
-      std::memcpy(quatRef, acsParameters.nadirModeControllerParameters.quatRef, 4 * sizeof(double));
-      enableAntiStiction = acsParameters.nadirModeControllerParameters.enableAntiStiction;
-      guidance.comparePtg(targetQuat, &mekfData, quatRef, refSatRate, quatErrorComplete, quatError,
-                          deltaRate);
-      ptgCtrl.ptgLaw(&acsParameters.nadirModeControllerParameters, quatError, deltaRate,
+      guidance.targetQuatPtgNadirThreeAxes(now, gpsDataProcessed.gpsPosition.value,
+                                           gpsDataProcessed.gpsVelocity.value, targetQuat,
+                                           targetSatRotRate);
+      guidance.comparePtg(mekfData.quatMekf.value, mekfData.satRotRateMekf.value, targetQuat,
+                          targetSatRotRate, acsParameters.nadirModeControllerParameters.quatRef,
+                          acsParameters.nadirModeControllerParameters.refRotRate, errorQuat,
+                          errorSatRotRate, errorAngle);
+      ptgCtrl.ptgLaw(&acsParameters.nadirModeControllerParameters, errorQuat, errorSatRotRate,
                      *rwPseudoInv, torquePtgRws);
       ptgCtrl.ptgNullspace(
           &acsParameters.nadirModeControllerParameters, &(sensorValues.rw1Set.currSpeed.value),
@@ -369,16 +378,17 @@ void AcsController::performPointingCtrl() {
           mgmDataProcessed.mgmVecTot.isValid(), mekfData.satRotRateMekf.value,
           &(sensorValues.rw1Set.currSpeed.value), &(sensorValues.rw2Set.currSpeed.value),
           &(sensorValues.rw3Set.currSpeed.value), &(sensorValues.rw4Set.currSpeed.value), mgtDpDes);
+      enableAntiStiction = acsParameters.nadirModeControllerParameters.enableAntiStiction;
       break;
 
     case acs::PTG_INERTIAL:
-      guidance.inertialQuatPtg(targetQuat, refSatRate);
-      std::memcpy(quatRef, acsParameters.inertialModeControllerParameters.quatRef,
+      std::memcpy(targetQuat, acsParameters.inertialModeControllerParameters.tgtQuat,
                   4 * sizeof(double));
-      enableAntiStiction = acsParameters.inertialModeControllerParameters.enableAntiStiction;
-      guidance.comparePtg(targetQuat, &mekfData, quatRef, refSatRate, quatErrorComplete, quatError,
-                          deltaRate);
-      ptgCtrl.ptgLaw(&acsParameters.inertialModeControllerParameters, quatError, deltaRate,
+      guidance.comparePtg(mekfData.quatMekf.value, mekfData.satRotRateMekf.value, targetQuat,
+                          targetSatRotRate, acsParameters.inertialModeControllerParameters.quatRef,
+                          acsParameters.inertialModeControllerParameters.refRotRate, errorQuat,
+                          errorSatRotRate, errorAngle);
+      ptgCtrl.ptgLaw(&acsParameters.inertialModeControllerParameters, errorQuat, errorSatRotRate,
                      *rwPseudoInv, torquePtgRws);
       ptgCtrl.ptgNullspace(
           &acsParameters.inertialModeControllerParameters, &(sensorValues.rw1Set.currSpeed.value),
@@ -391,6 +401,7 @@ void AcsController::performPointingCtrl() {
           mgmDataProcessed.mgmVecTot.isValid(), mekfData.satRotRateMekf.value,
           &(sensorValues.rw1Set.currSpeed.value), &(sensorValues.rw2Set.currSpeed.value),
           &(sensorValues.rw3Set.currSpeed.value), &(sensorValues.rw4Set.currSpeed.value), mgtDpDes);
+      enableAntiStiction = acsParameters.inertialModeControllerParameters.enableAntiStiction;
       break;
   }
 
@@ -398,24 +409,14 @@ void AcsController::performPointingCtrl() {
     ptgCtrl.rwAntistiction(&sensorValues, torqueRwsScaled);
   }
 
-  int32_t cmdSpeedRws[4] = {0, 0, 0, 0};
   actuatorCmd.cmdSpeedToRws(sensorValues.rw1Set.currSpeed.value,
                             sensorValues.rw2Set.currSpeed.value,
                             sensorValues.rw3Set.currSpeed.value,
                             sensorValues.rw4Set.currSpeed.value, torqueRwsScaled, cmdSpeedRws);
-  int16_t cmdDipolMtqs[3] = {0, 0, 0};
   actuatorCmd.cmdDipolMtq(mgtDpDes, cmdDipolMtqs);
 
-  {
-    PoolReadGuard pg(&actuatorCmdData);
-    if (pg.getReadResult() == returnvalue::OK) {
-      std::memcpy(actuatorCmdData.rwTargetTorque.value, rwTrqNs, 4 * sizeof(double));
-      std::memcpy(actuatorCmdData.rwTargetSpeed.value, cmdSpeedRws, 4 * sizeof(int32_t));
-      std::memcpy(actuatorCmdData.mtqTargetDipole.value, cmdDipolMtqs, 3 * sizeof(int16_t));
-      actuatorCmdData.setValidity(true, true);
-    }
-  }
-
+  updateCtrlValData(targetQuat, errorQuat, errorAngle, targetSatRotRate);
+  updateActuatorCmdData(rwTrqNs, cmdSpeedRws, cmdDipolMtqs);
   //  commandActuators(cmdDipolMtqs[0], cmdDipolMtqs[1], cmdDipolMtqs[2],
   //                   acsParameters.magnetorquesParameter.torqueDuration, cmdSpeedRws[0],
   //                   cmdSpeedRws[1], cmdSpeedRws[2], cmdSpeedRws[3],
@@ -451,6 +452,60 @@ ReturnValue_t AcsController::commandActuators(int16_t xDipole, int16_t yDipole,
   return returnvalue::OK;
 }
 
+void AcsController::updateActuatorCmdData(const int16_t *mtqTargetDipole) {
+  updateActuatorCmdData(RW_OFF_TORQUE, RW_OFF_SPEED, mtqTargetDipole);
+}
+
+void AcsController::updateActuatorCmdData(const double *rwTargetTorque,
+                                          const int32_t *rwTargetSpeed,
+                                          const int16_t *mtqTargetDipole) {
+  PoolReadGuard pg(&actuatorCmdData);
+  if (pg.getReadResult() == returnvalue::OK) {
+    std::memcpy(actuatorCmdData.rwTargetTorque.value, rwTargetTorque, 4 * sizeof(double));
+    std::memcpy(actuatorCmdData.rwTargetSpeed.value, rwTargetSpeed, 4 * sizeof(int32_t));
+    std::memcpy(actuatorCmdData.mtqTargetDipole.value, mtqTargetDipole, 3 * sizeof(int16_t));
+    actuatorCmdData.setValidity(true, true);
+  }
+}
+
+void AcsController::updateCtrlValData(double errAng) {
+  PoolReadGuard pg(&ctrlValData);
+  if (pg.getReadResult() == returnvalue::OK) {
+    std::memcpy(ctrlValData.tgtQuat.value, UNIT_QUAT, 4 * sizeof(double));
+    ctrlValData.tgtQuat.setValid(false);
+    std::memcpy(ctrlValData.errQuat.value, UNIT_QUAT, 4 * sizeof(double));
+    ctrlValData.errQuat.setValid(false);
+    ctrlValData.errAng.value = errAng;
+    ctrlValData.errAng.setValid(true);
+    std::memcpy(ctrlValData.tgtRotRate.value, ZERO_VEC, 3 * sizeof(double));
+    ctrlValData.tgtRotRate.setValid(false);
+    ctrlValData.setValidity(true, false);
+  }
+}
+
+void AcsController::updateCtrlValData(const double *tgtQuat, const double *errQuat, double errAng,
+                                      const double *tgtRotRate) {
+  PoolReadGuard pg(&ctrlValData);
+  if (pg.getReadResult() == returnvalue::OK) {
+    std::memcpy(ctrlValData.tgtQuat.value, tgtQuat, 4 * sizeof(double));
+    std::memcpy(ctrlValData.errQuat.value, errQuat, 4 * sizeof(double));
+    ctrlValData.errAng.value = errAng;
+    std::memcpy(ctrlValData.tgtRotRate.value, tgtRotRate, 3 * sizeof(double));
+    ctrlValData.setValidity(true, true);
+  }
+}
+
+void AcsController::disableCtrlValData() {
+  PoolReadGuard pg(&ctrlValData);
+  if (pg.getReadResult() == returnvalue::OK) {
+    std::memcpy(ctrlValData.tgtQuat.value, UNIT_QUAT, 4 * sizeof(double));
+    std::memcpy(ctrlValData.errQuat.value, UNIT_QUAT, 4 * sizeof(double));
+    ctrlValData.errAng.value = 0;
+    std::memcpy(ctrlValData.tgtRotRate.value, ZERO_VEC, 3 * sizeof(double));
+    ctrlValData.setValidity(false, true);
+  }
+}
+
 ReturnValue_t AcsController::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                                      LocalDataPoolManager &poolManager) {
   // MGM Raw
@@ -524,11 +579,13 @@ ReturnValue_t AcsController::initializeLocalDataPool(localpool::DataPool &localD
   // MEKF
   localDataPoolMap.emplace(acsctrl::PoolIds::QUAT_MEKF, &quatMekf);
   localDataPoolMap.emplace(acsctrl::PoolIds::SAT_ROT_RATE_MEKF, &satRotRateMekf);
+  localDataPoolMap.emplace(acsctrl::PoolIds::MEKF_STATUS, &mekfStatus);
   poolManager.subscribeForDiagPeriodicPacket({mekfData.getSid(), false, 5.0});
   // Ctrl Values
   localDataPoolMap.emplace(acsctrl::PoolIds::TGT_QUAT, &tgtQuat);
   localDataPoolMap.emplace(acsctrl::PoolIds::ERROR_QUAT, &errQuat);
   localDataPoolMap.emplace(acsctrl::PoolIds::ERROR_ANG, &errAng);
+  localDataPoolMap.emplace(acsctrl::PoolIds::TGT_ROT_RATE, &tgtRotRate);
   poolManager.subscribeForRegularPeriodicPacket({ctrlValData.getSid(), false, 5.0});
   // Actuator CMD
   localDataPoolMap.emplace(acsctrl::PoolIds::RW_TARGET_TORQUE, &rwTargetTorque);
@@ -795,11 +852,3 @@ void AcsController::copyGyrData() {
     }
   }
 }
-
-ReturnValue_t AcsController::initialize() {
-  ReturnValue_t result = parameterHelper.initialize();
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  return ExtendedControllerBase::initialize();
-}

mission/controller/AcsController.h

@@ -1,26 +1,27 @@
 #ifndef MISSION_CONTROLLER_ACSCONTROLLER_H_
 #define MISSION_CONTROLLER_ACSCONTROLLER_H_
 
+#include <eive/objects.h>
 #include <fsfw/controller/ExtendedControllerBase.h>
 #include <fsfw/globalfunctions/math/VectorOperations.h>
 #include <fsfw/parameters/ParameterHelper.h>
 #include <fsfw/parameters/ReceivesParameterMessagesIF.h>
+#include <fsfw_hal/devicehandlers/MgmLIS3MDLHandler.h>
+#include <fsfw_hal/devicehandlers/MgmRM3100Handler.h>
+#include <mission/devices/devicedefinitions/imtqHelpers.h>
 #include <mission/devices/devicedefinitions/rwHelpers.h>
+#include <mission/devices/devicedefinitions/susMax1227Helpers.h>
+#include <mission/trace.h>
 
 #include "acs/ActuatorCmd.h"
 #include "acs/Guidance.h"
+#include "acs/MultiplicativeKalmanFilter.h"
 #include "acs/Navigation.h"
 #include "acs/SensorProcessing.h"
 #include "acs/control/Detumble.h"
 #include "acs/control/PtgCtrl.h"
 #include "acs/control/SafeCtrl.h"
 #include "controllerdefinitions/AcsCtrlDefinitions.h"
-#include "eive/objects.h"
-#include "fsfw_hal/devicehandlers/MgmLIS3MDLHandler.h"
-#include "fsfw_hal/devicehandlers/MgmRM3100Handler.h"
-#include "mission/devices/devicedefinitions/SusDefinitions.h"
-#include "mission/devices/devicedefinitions/imtqHandlerDefinitions.h"
-#include "mission/trace.h"
 
 class AcsController : public ExtendedControllerBase, public ReceivesParameterMessagesIF {
  public:
@@ -39,6 +40,11 @@ class AcsController : public ExtendedControllerBase, public ReceivesParameterMes
   void performPointingCtrl();
 
  private:
+  static constexpr double UNIT_QUAT[4] = {0, 0, 0, 1};
+  static constexpr double ZERO_VEC[3] = {0, 0, 0};
+  static constexpr double RW_OFF_TORQUE[4] = {0.0, 0.0, 0.0, 0.0};
+  static constexpr int32_t RW_OFF_SPEED[4] = {0, 0, 0, 0};
+
   AcsParameters acsParameters;
   SensorProcessing sensorProcessing;
   Navigation navigation;
@@ -49,23 +55,37 @@ class AcsController : public ExtendedControllerBase, public ReceivesParameterMes
   Detumble detumble;
   PtgCtrl ptgCtrl;
 
-  uint8_t detumbleCounter;
-  uint8_t multipleRwUnavailableCounter;
-
   ParameterHelper parameterHelper;
 
+  uint8_t detumbleCounter = 0;
+  uint8_t multipleRwUnavailableCounter = 0;
+  bool mekfInvalidFlag = false;
+  uint8_t mekfInvalidCounter = 0;
+  int32_t cmdSpeedRws[4] = {0, 0, 0, 0};
+  int16_t cmdDipolMtqs[3] = {0, 0, 0};
+
 #if OBSW_THREAD_TRACING == 1
   uint32_t opCounter = 0;
 #endif
 
   enum class InternalState { STARTUP, INITIAL_DELAY, READY };
-
   InternalState internalState = InternalState::STARTUP;
 
+  /** Device command IDs */
+  static const DeviceCommandId_t SOLAR_ARRAY_DEPLOYMENT_SUCCESSFUL = 0x0;
+  static const DeviceCommandId_t RESET_MEKF = 0x1;
+
+  static const uint8_t INTERFACE_ID = CLASS_ID::ACS_CTRL;
+  static constexpr ReturnValue_t FILE_DELETION_FAILED = MAKE_RETURN_CODE(0);
+
   ReturnValue_t initialize() override;
   ReturnValue_t handleCommandMessage(CommandMessage* message) override;
   void performControlOperation() override;
 
+  /* HasActionsIF overrides */
+  ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
+                              const uint8_t* data, size_t size) override;
+
   ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
                                         LocalDataPoolManager& poolManager) override;
   LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
@@ -79,12 +99,19 @@ class AcsController : public ExtendedControllerBase, public ReceivesParameterMes
   ReturnValue_t commandActuators(int16_t xDipole, int16_t yDipole, int16_t zDipole,
                                  uint16_t dipoleTorqueDuration, int32_t rw1Speed, int32_t rw2Speed,
                                  int32_t rw3Speed, int32_t rw4Speed, uint16_t rampTime);
+  void updateActuatorCmdData(const int16_t* mtqTargetDipole);
+  void updateActuatorCmdData(const double* rwTargetTorque, const int32_t* rwTargetSpeed,
+                             const int16_t* mtqTargetDipole);
+  void updateCtrlValData(double errAng);
+  void updateCtrlValData(const double* tgtQuat, const double* errQuat, double errAng,
+                         const double* tgtRotRate);
+  void disableCtrlValData();
 
   /* ACS Sensor Values */
   ACS::SensorValues sensorValues;
 
   /* ACS Actuation Datasets */
-  IMTQ::DipoleActuationSet dipoleSet = IMTQ::DipoleActuationSet(objects::IMTQ_HANDLER);
+  imtq::DipoleActuationSet dipoleSet = imtq::DipoleActuationSet(objects::IMTQ_HANDLER);
   rws::RwSpeedActuationSet rw1SpeedSet = rws::RwSpeedActuationSet(objects::RW1);
   rws::RwSpeedActuationSet rw2SpeedSet = rws::RwSpeedActuationSet(objects::RW2);
   rws::RwSpeedActuationSet rw3SpeedSet = rws::RwSpeedActuationSet(objects::RW3);
@@ -169,12 +196,14 @@ class AcsController : public ExtendedControllerBase, public ReceivesParameterMes
   acsctrl::MekfData mekfData;
   PoolEntry<double> quatMekf = PoolEntry<double>(4);
   PoolEntry<double> satRotRateMekf = PoolEntry<double>(3);
+  PoolEntry<uint8_t> mekfStatus = PoolEntry<uint8_t>();
 
   // Ctrl Values
   acsctrl::CtrlValData ctrlValData;
   PoolEntry<double> tgtQuat = PoolEntry<double>(4);
   PoolEntry<double> errQuat = PoolEntry<double>(4);
   PoolEntry<double> errAng = PoolEntry<double>();
+  PoolEntry<double> tgtRotRate = PoolEntry<double>(3);
 
   // Actuator CMD
   acsctrl::ActuatorCmdData actuatorCmdData;

mission/controller/ThermalController.cpp

@@ -3,14 +3,14 @@
 #include <bsp_q7s/core/CoreDefinitions.h>
 #include <fsfw/datapool/PoolReadGuard.h>
 #include <fsfw/thermal/ThermalComponentIF.h>
-#include <fsfw_hal/devicehandlers/devicedefinitions/MgmLIS3HandlerDefs.h>
+#include <fsfw_hal/devicehandlers/devicedefinitions/mgmLis3Helpers.h>
 #include <linux/devices/devicedefinitions/StarTrackerDefinitions.h>
 #include <mission/devices/devicedefinitions/BpxBatteryDefinitions.h>
 #include <mission/devices/devicedefinitions/GomspaceDefinitions.h>
-#include <mission/devices/devicedefinitions/GyroADIS1650XDefinitions.h>
 #include <mission/devices/devicedefinitions/GyroL3GD20Definitions.h>
 #include <mission/devices/devicedefinitions/SyrlinksDefinitions.h>
-#include <mission/devices/devicedefinitions/imtqHandlerDefinitions.h>
+#include <mission/devices/devicedefinitions/gyroAdisHelpers.h>
+#include <mission/devices/devicedefinitions/imtqHelpers.h>
 #include <mission/devices/devicedefinitions/payloadPcduDefinitions.h>
 #include <mission/devices/devicedefinitions/rwHelpers.h>
 #include <objects/systemObjectList.h>
@@ -21,6 +21,7 @@ ThermalController::ThermalController(object_id_t objectId, HeaterHandler& heater
       sensorTemperatures(this),
       susTemperatures(this),
       deviceTemperatures(this),
+      heaterInfo(this),
       imtqThermalSet(objects::IMTQ_HANDLER, ThermalStateCfg()),
       max31865Set0(objects::RTD_0_IC3_PLOC_HEATSPREADER,
                    EiveMax31855::RtdCommands::EXCHANGE_SET_ID),
@@ -112,108 +113,88 @@ void ThermalController::performControlOperation() {
     deviceTemperatures.commit();
   }
 
+  std::array<HeaterHandler::SwitchState, 8> heaterStates;
+  heaterHandler.getAllSwitchStates(heaterStates);
+  {
+    PoolReadGuard pg(&heaterInfo);
+    std::memcpy(heaterInfo.heaterSwitchState.value, heaterStates.data(), 8);
+    {
+      PoolReadGuard pg2(&currentVecPdu2);
+      if (pg.getReadResult() == returnvalue::OK and pg2.getReadResult() == returnvalue::OK) {
+        heaterInfo.heaterCurrent.value = currentVecPdu2.value[PDU2::Channels::TCS_HEATER_IN];
+      }
+    }
+  }
+
   // performThermalModuleCtrl();
 }
 
 ReturnValue_t ThermalController::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
                                                          LocalDataPoolManager& poolManager) {
-  localDataPoolMap.emplace(thermalControllerDefinitions::SENSOR_PLOC_HEATSPREADER,
-                           new PoolEntry<float>({0.0}));
-  localDataPoolMap.emplace(thermalControllerDefinitions::SENSOR_PLOC_MISSIONBOARD,
-                           new PoolEntry<float>({1.0}));
-  localDataPoolMap.emplace(thermalControllerDefinitions::SENSOR_4K_CAMERA,
-                           new PoolEntry<float>({2.0}));
-  localDataPoolMap.emplace(thermalControllerDefinitions::SENSOR_DAC_HEATSPREADER,
-                           new PoolEntry<float>({3.0}));
-  localDataPoolMap.emplace(thermalControllerDefinitions::SENSOR_STARTRACKER,
-                           new PoolEntry<float>({4.0}));
-  localDataPoolMap.emplace(thermalControllerDefinitions::SENSOR_RW1, new PoolEntry<float>({5.0}));
-  localDataPoolMap.emplace(thermalControllerDefinitions::SENSOR_DRO, new PoolEntry<float>({6.0}));
-  localDataPoolMap.emplace(thermalControllerDefinitions::SENSOR_SCEX, new PoolEntry<float>({7.0}));
-  localDataPoolMap.emplace(thermalControllerDefinitions::SENSOR_X8, new PoolEntry<float>({8.0}));
-  localDataPoolMap.emplace(thermalControllerDefinitions::SENSOR_HPA, new PoolEntry<float>({9.0}));
-  localDataPoolMap.emplace(thermalControllerDefinitions::SENSOR_TX_MODUL,
-                           new PoolEntry<float>({10.0}));
-  localDataPoolMap.emplace(thermalControllerDefinitions::SENSOR_MPA, new PoolEntry<float>({11.0}));
-  localDataPoolMap.emplace(thermalControllerDefinitions::SENSOR_ACU, new PoolEntry<float>({12.0}));
-  localDataPoolMap.emplace(thermalControllerDefinitions::SENSOR_PLPCDU_HEATSPREADER,
-                           new PoolEntry<float>({13.0}));
-  localDataPoolMap.emplace(thermalControllerDefinitions::SENSOR_TCS_BOARD,
-                           new PoolEntry<float>({14.0}));
-  localDataPoolMap.emplace(thermalControllerDefinitions::SENSOR_MAGNETTORQUER,
-                           new PoolEntry<float>({15.0}));
-  localDataPoolMap.emplace(thermalControllerDefinitions::SENSOR_TMP1075_TCS_0, &tmp1075Tcs0);
-  localDataPoolMap.emplace(thermalControllerDefinitions::SENSOR_TMP1075_TCS_1, &tmp1075Tcs1);
-  localDataPoolMap.emplace(thermalControllerDefinitions::SENSOR_TMP1075_PLPCDU_0, &tmp1075PlPcdu0);
-  localDataPoolMap.emplace(thermalControllerDefinitions::SENSOR_TMP1075_PLPCDU_1, &tmp1075PlPcdu1);
-  localDataPoolMap.emplace(thermalControllerDefinitions::SENSOR_TMP1075_IF_BOARD, &tmp1075IfBrd);
+  localDataPoolMap.emplace(tcsCtrl::SENSOR_PLOC_HEATSPREADER, new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(tcsCtrl::SENSOR_PLOC_MISSIONBOARD, new PoolEntry<float>({1.0}));
+  localDataPoolMap.emplace(tcsCtrl::SENSOR_4K_CAMERA, new PoolEntry<float>({2.0}));
+  localDataPoolMap.emplace(tcsCtrl::SENSOR_DAC_HEATSPREADER, new PoolEntry<float>({3.0}));
+  localDataPoolMap.emplace(tcsCtrl::SENSOR_STARTRACKER, new PoolEntry<float>({4.0}));
+  localDataPoolMap.emplace(tcsCtrl::SENSOR_RW1, new PoolEntry<float>({5.0}));
+  localDataPoolMap.emplace(tcsCtrl::SENSOR_DRO, new PoolEntry<float>({6.0}));
+  localDataPoolMap.emplace(tcsCtrl::SENSOR_SCEX, new PoolEntry<float>({7.0}));
+  localDataPoolMap.emplace(tcsCtrl::SENSOR_X8, new PoolEntry<float>({8.0}));
+  localDataPoolMap.emplace(tcsCtrl::SENSOR_HPA, new PoolEntry<float>({9.0}));
+  localDataPoolMap.emplace(tcsCtrl::SENSOR_TX_MODUL, new PoolEntry<float>({10.0}));
+  localDataPoolMap.emplace(tcsCtrl::SENSOR_MPA, new PoolEntry<float>({11.0}));
+  localDataPoolMap.emplace(tcsCtrl::SENSOR_ACU, new PoolEntry<float>({12.0}));
+  localDataPoolMap.emplace(tcsCtrl::SENSOR_PLPCDU_HEATSPREADER, new PoolEntry<float>({13.0}));
+  localDataPoolMap.emplace(tcsCtrl::SENSOR_TCS_BOARD, new PoolEntry<float>({14.0}));
+  localDataPoolMap.emplace(tcsCtrl::SENSOR_MAGNETTORQUER, new PoolEntry<float>({15.0}));
+  localDataPoolMap.emplace(tcsCtrl::SENSOR_TMP1075_TCS_0, &tmp1075Tcs0);
+  localDataPoolMap.emplace(tcsCtrl::SENSOR_TMP1075_TCS_1, &tmp1075Tcs1);
+  localDataPoolMap.emplace(tcsCtrl::SENSOR_TMP1075_PLPCDU_0, &tmp1075PlPcdu0);
+  localDataPoolMap.emplace(tcsCtrl::SENSOR_TMP1075_PLPCDU_1, &tmp1075PlPcdu1);
+  localDataPoolMap.emplace(tcsCtrl::SENSOR_TMP1075_IF_BOARD, &tmp1075IfBrd);
 
-  localDataPoolMap.emplace(thermalControllerDefinitions::SUS_0_N_LOC_XFYFZM_PT_XF,
-                           new PoolEntry<float>({0.0}));
-  localDataPoolMap.emplace(thermalControllerDefinitions::SUS_6_R_LOC_XFYBZM_PT_XF,
-                           new PoolEntry<float>({0.0}));
-  localDataPoolMap.emplace(thermalControllerDefinitions::SUS_1_N_LOC_XBYFZM_PT_XB,
-                           new PoolEntry<float>({0.0}));
-  localDataPoolMap.emplace(thermalControllerDefinitions::SUS_7_R_LOC_XBYBZM_PT_XB,
-                           new PoolEntry<float>({0.0}));
-  localDataPoolMap.emplace(thermalControllerDefinitions::SUS_2_N_LOC_XFYBZB_PT_YB,
-                           new PoolEntry<float>({0.0}));
-  localDataPoolMap.emplace(thermalControllerDefinitions::SUS_8_R_LOC_XBYBZB_PT_YB,
-                           new PoolEntry<float>({0.0}));
-  localDataPoolMap.emplace(thermalControllerDefinitions::SUS_3_N_LOC_XFYBZF_PT_YF,
-                           new PoolEntry<float>({0.0}));
-  localDataPoolMap.emplace(thermalControllerDefinitions::SUS_9_R_LOC_XBYBZB_PT_YF,
-                           new PoolEntry<float>({0.0}));
-  localDataPoolMap.emplace(thermalControllerDefinitions::SUS_4_N_LOC_XMYFZF_PT_ZF,
-                           new PoolEntry<float>({0.0}));
-  localDataPoolMap.emplace(thermalControllerDefinitions::SUS_10_N_LOC_XMYBZF_PT_ZF,
-                           new PoolEntry<float>({0.0}));
-  localDataPoolMap.emplace(thermalControllerDefinitions::SUS_5_N_LOC_XFYMZB_PT_ZB,
-                           new PoolEntry<float>({0.0}));
-  localDataPoolMap.emplace(thermalControllerDefinitions::SUS_11_R_LOC_XBYMZB_PT_ZB,
-                           new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(tcsCtrl::SUS_0_N_LOC_XFYFZM_PT_XF, new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(tcsCtrl::SUS_6_R_LOC_XFYBZM_PT_XF, new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(tcsCtrl::SUS_1_N_LOC_XBYFZM_PT_XB, new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(tcsCtrl::SUS_7_R_LOC_XBYBZM_PT_XB, new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(tcsCtrl::SUS_2_N_LOC_XFYBZB_PT_YB, new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(tcsCtrl::SUS_8_R_LOC_XBYBZB_PT_YB, new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(tcsCtrl::SUS_3_N_LOC_XFYBZF_PT_YF, new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(tcsCtrl::SUS_9_R_LOC_XBYBZB_PT_YF, new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(tcsCtrl::SUS_4_N_LOC_XMYFZF_PT_ZF, new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(tcsCtrl::SUS_10_N_LOC_XMYBZF_PT_ZF, new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(tcsCtrl::SUS_5_N_LOC_XFYMZB_PT_ZB, new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(tcsCtrl::SUS_11_R_LOC_XBYMZB_PT_ZB, new PoolEntry<float>({0.0}));
 
-  localDataPoolMap.emplace(thermalControllerDefinitions::COMPONENT_RW, new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(tcsCtrl::COMPONENT_RW, new PoolEntry<float>({0.0}));
 
-  localDataPoolMap.emplace(thermalControllerDefinitions::TEMP_Q7S, new PoolEntry<float>({0.0}));
-  localDataPoolMap.emplace(thermalControllerDefinitions::BATTERY_TEMP_1,
-                           new PoolEntry<int16_t>({0}));
-  localDataPoolMap.emplace(thermalControllerDefinitions::BATTERY_TEMP_2,
-                           new PoolEntry<int16_t>({0}));
-  localDataPoolMap.emplace(thermalControllerDefinitions::BATTERY_TEMP_3,
-                           new PoolEntry<int16_t>({0}));
-  localDataPoolMap.emplace(thermalControllerDefinitions::BATTERY_TEMP_4,
-                           new PoolEntry<int16_t>({0}));
-  localDataPoolMap.emplace(thermalControllerDefinitions::TEMP_RW1, new PoolEntry<int32_t>({0}));
-  localDataPoolMap.emplace(thermalControllerDefinitions::TEMP_RW2, new PoolEntry<int32_t>({0}));
-  localDataPoolMap.emplace(thermalControllerDefinitions::TEMP_RW3, new PoolEntry<int32_t>({0}));
-  localDataPoolMap.emplace(thermalControllerDefinitions::TEMP_RW4, new PoolEntry<int32_t>({0}));
-  localDataPoolMap.emplace(thermalControllerDefinitions::TEMP_STAR_TRACKER,
-                           new PoolEntry<float>({0.0}));
-  localDataPoolMap.emplace(thermalControllerDefinitions::TEMP_SYRLINKS_POWER_AMPLIFIER,
-                           new PoolEntry<float>({0}));
-  localDataPoolMap.emplace(thermalControllerDefinitions::TEMP_SYRLINKS_BASEBAND_BOARD,
-                           new PoolEntry<float>({0}));
-  localDataPoolMap.emplace(thermalControllerDefinitions::TEMP_MGT, new PoolEntry<int16_t>({0}));
-  localDataPoolMap.emplace(thermalControllerDefinitions::TEMP_ACU, new PoolEntry<float>({0}));
-  localDataPoolMap.emplace(thermalControllerDefinitions::TEMP_PDU1, new PoolEntry<float>({0}));
-  localDataPoolMap.emplace(thermalControllerDefinitions::TEMP_PDU2, new PoolEntry<float>({0}));
-  localDataPoolMap.emplace(thermalControllerDefinitions::TEMP_1_P60DOCK, new PoolEntry<float>({0}));
-  localDataPoolMap.emplace(thermalControllerDefinitions::TEMP_2_P60DOCK, new PoolEntry<float>({0}));
-  localDataPoolMap.emplace(thermalControllerDefinitions::TEMP_GYRO_0_SIDE_A,
-                           new PoolEntry<float>({0.0}));
-  localDataPoolMap.emplace(thermalControllerDefinitions::TEMP_GYRO_1_SIDE_A,
-                           new PoolEntry<float>({0.0}));
-  localDataPoolMap.emplace(thermalControllerDefinitions::TEMP_GYRO_2_SIDE_B,
-                           new PoolEntry<float>({0.0}));
-  localDataPoolMap.emplace(thermalControllerDefinitions::TEMP_GYRO_3_SIDE_B,
-                           new PoolEntry<float>({0.0}));
-  localDataPoolMap.emplace(thermalControllerDefinitions::TEMP_MGM_0_SIDE_A,
-                           new PoolEntry<float>({0.0}));
-  localDataPoolMap.emplace(thermalControllerDefinitions::TEMP_MGM_2_SIDE_B,
-                           new PoolEntry<float>({0.0}));
-  localDataPoolMap.emplace(thermalControllerDefinitions::TEMP_ADC_PAYLOAD_PCDU,
-                           new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(tcsCtrl::TEMP_Q7S, new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(tcsCtrl::BATTERY_TEMP_1, new PoolEntry<int16_t>({0}));
+  localDataPoolMap.emplace(tcsCtrl::BATTERY_TEMP_2, new PoolEntry<int16_t>({0}));
+  localDataPoolMap.emplace(tcsCtrl::BATTERY_TEMP_3, new PoolEntry<int16_t>({0}));
+  localDataPoolMap.emplace(tcsCtrl::BATTERY_TEMP_4, new PoolEntry<int16_t>({0}));
+  localDataPoolMap.emplace(tcsCtrl::TEMP_RW1, new PoolEntry<int32_t>({0}));
+  localDataPoolMap.emplace(tcsCtrl::TEMP_RW2, new PoolEntry<int32_t>({0}));
+  localDataPoolMap.emplace(tcsCtrl::TEMP_RW3, new PoolEntry<int32_t>({0}));
+  localDataPoolMap.emplace(tcsCtrl::TEMP_RW4, new PoolEntry<int32_t>({0}));
+  localDataPoolMap.emplace(tcsCtrl::TEMP_STAR_TRACKER, new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(tcsCtrl::TEMP_SYRLINKS_POWER_AMPLIFIER, new PoolEntry<float>({0}));
+  localDataPoolMap.emplace(tcsCtrl::TEMP_SYRLINKS_BASEBAND_BOARD, new PoolEntry<float>({0}));
+  localDataPoolMap.emplace(tcsCtrl::TEMP_MGT, new PoolEntry<int16_t>({0}));
+  localDataPoolMap.emplace(tcsCtrl::TEMP_ACU, new PoolEntry<float>({0}));
+  localDataPoolMap.emplace(tcsCtrl::TEMP_PDU1, new PoolEntry<float>({0}));
+  localDataPoolMap.emplace(tcsCtrl::TEMP_PDU2, new PoolEntry<float>({0}));
+  localDataPoolMap.emplace(tcsCtrl::TEMP_1_P60DOCK, new PoolEntry<float>({0}));
+  localDataPoolMap.emplace(tcsCtrl::TEMP_2_P60DOCK, new PoolEntry<float>({0}));
+  localDataPoolMap.emplace(tcsCtrl::TEMP_GYRO_0_SIDE_A, new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(tcsCtrl::TEMP_GYRO_1_SIDE_A, new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(tcsCtrl::TEMP_GYRO_2_SIDE_B, new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(tcsCtrl::TEMP_GYRO_3_SIDE_B, new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(tcsCtrl::TEMP_MGM_0_SIDE_A, new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(tcsCtrl::TEMP_MGM_2_SIDE_B, new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(tcsCtrl::TEMP_ADC_PAYLOAD_PCDU, new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(tcsCtrl::HEATER_SWITCH_LIST, &heaterSwitchStates);
+  localDataPoolMap.emplace(tcsCtrl::HEATER_CURRENT, &heaterCurrent);
 
   poolManager.subscribeForRegularPeriodicPacket(
       subdp::RegularHkPeriodicParams(sensorTemperatures.getSid(), false, 10.0));
@@ -221,17 +202,21 @@ ReturnValue_t ThermalController::initializeLocalDataPool(localpool::DataPool& lo
       subdp::RegularHkPeriodicParams(susTemperatures.getSid(), false, 10.0));
   poolManager.subscribeForRegularPeriodicPacket(
       subdp::RegularHkPeriodicParams(deviceTemperatures.getSid(), false, 10.0));
+  poolManager.subscribeForDiagPeriodicPacket(
+      subdp::DiagnosticsHkPeriodicParams(heaterInfo.getSid(), false, 10.0));
   return returnvalue::OK;
 }
 
 LocalPoolDataSetBase* ThermalController::getDataSetHandle(sid_t sid) {
   switch (sid.ownerSetId) {
-    case thermalControllerDefinitions::SENSOR_TEMPERATURES:
+    case tcsCtrl::SENSOR_TEMPERATURES:
       return &sensorTemperatures;
-    case thermalControllerDefinitions::SUS_TEMPERATURES:
+    case tcsCtrl::SUS_TEMPERATURES:
       return &susTemperatures;
-    case thermalControllerDefinitions::DEVICE_TEMPERATURES:
+    case tcsCtrl::DEVICE_TEMPERATURES:
       return &deviceTemperatures;
+    case tcsCtrl::HEATER_SET:
+      return &heaterInfo;
     default:
       return nullptr;
   }
@@ -489,8 +474,8 @@ void ThermalController::copySus() {
   {
     PoolReadGuard pg0(&susSet0, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
     if (pg0.getReadResult() == returnvalue::OK) {
-      susTemperatures.sus_0_n_loc_xfyfzm_pt_xf.value = susSet0.temperatureCelcius.value;
-      susTemperatures.sus_0_n_loc_xfyfzm_pt_xf.setValid(susSet0.temperatureCelcius.isValid());
+      susTemperatures.sus_0_n_loc_xfyfzm_pt_xf.value = susSet0.tempC.value;
+      susTemperatures.sus_0_n_loc_xfyfzm_pt_xf.setValid(susSet0.tempC.isValid());
       if (not susTemperatures.sus_0_n_loc_xfyfzm_pt_xf.isValid()) {
         susTemperatures.sus_0_n_loc_xfyfzm_pt_xf.value = INVALID_TEMPERATURE;
       }
@@ -500,8 +485,8 @@ void ThermalController::copySus() {
   {
     PoolReadGuard pg1(&susSet1, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
     if (pg1.getReadResult() == returnvalue::OK) {
-      susTemperatures.sus_6_r_loc_xfybzm_pt_xf.value = susSet1.temperatureCelcius.value;
-      susTemperatures.sus_6_r_loc_xfybzm_pt_xf.setValid(susSet1.temperatureCelcius.isValid());
+      susTemperatures.sus_6_r_loc_xfybzm_pt_xf.value = susSet1.tempC.value;
+      susTemperatures.sus_6_r_loc_xfybzm_pt_xf.setValid(susSet1.tempC.isValid());
       if (not susTemperatures.sus_6_r_loc_xfybzm_pt_xf.isValid()) {
         susTemperatures.sus_6_r_loc_xfybzm_pt_xf.value = INVALID_TEMPERATURE;
       }
@@ -511,8 +496,8 @@ void ThermalController::copySus() {
   {
     PoolReadGuard pg2(&susSet2, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
     if (pg2.getReadResult() == returnvalue::OK) {
-      susTemperatures.sus_1_n_loc_xbyfzm_pt_xb.value = susSet2.temperatureCelcius.value;
-      susTemperatures.sus_1_n_loc_xbyfzm_pt_xb.setValid(susSet2.temperatureCelcius.isValid());
+      susTemperatures.sus_1_n_loc_xbyfzm_pt_xb.value = susSet2.tempC.value;
+      susTemperatures.sus_1_n_loc_xbyfzm_pt_xb.setValid(susSet2.tempC.isValid());
       if (not susTemperatures.sus_1_n_loc_xbyfzm_pt_xb.isValid()) {
         susTemperatures.sus_1_n_loc_xbyfzm_pt_xb.value = INVALID_TEMPERATURE;
       }
@@ -522,8 +507,8 @@ void ThermalController::copySus() {
   {
     PoolReadGuard pg3(&susSet3, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
     if (pg3.getReadResult() == returnvalue::OK) {
-      susTemperatures.sus_7_r_loc_xbybzm_pt_xb.value = susSet3.temperatureCelcius.value;
-      susTemperatures.sus_7_r_loc_xbybzm_pt_xb.setValid(susSet3.temperatureCelcius.isValid());
+      susTemperatures.sus_7_r_loc_xbybzm_pt_xb.value = susSet3.tempC.value;
+      susTemperatures.sus_7_r_loc_xbybzm_pt_xb.setValid(susSet3.tempC.isValid());
       if (not susTemperatures.sus_7_r_loc_xbybzm_pt_xb.isValid()) {
         susTemperatures.sus_7_r_loc_xbybzm_pt_xb.value = INVALID_TEMPERATURE;
       }
@@ -533,8 +518,8 @@ void ThermalController::copySus() {
   {
     PoolReadGuard pg4(&susSet4, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
     if (pg4.getReadResult() == returnvalue::OK) {
-      susTemperatures.sus_2_n_loc_xfybzb_pt_yb.value = susSet4.temperatureCelcius.value;
-      susTemperatures.sus_2_n_loc_xfybzb_pt_yb.setValid(susSet4.temperatureCelcius.isValid());
+      susTemperatures.sus_2_n_loc_xfybzb_pt_yb.value = susSet4.tempC.value;
+      susTemperatures.sus_2_n_loc_xfybzb_pt_yb.setValid(susSet4.tempC.isValid());
       if (not susTemperatures.sus_2_n_loc_xfybzb_pt_yb.isValid()) {
         susTemperatures.sus_2_n_loc_xfybzb_pt_yb.value = INVALID_TEMPERATURE;
       }
@@ -544,8 +529,8 @@ void ThermalController::copySus() {
   {
     PoolReadGuard pg5(&susSet5, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
     if (pg5.getReadResult() == returnvalue::OK) {
-      susTemperatures.sus_8_r_loc_xbybzb_pt_yb.value = susSet5.temperatureCelcius.value;
-      susTemperatures.sus_8_r_loc_xbybzb_pt_yb.setValid(susSet5.temperatureCelcius.isValid());
+      susTemperatures.sus_8_r_loc_xbybzb_pt_yb.value = susSet5.tempC.value;
+      susTemperatures.sus_8_r_loc_xbybzb_pt_yb.setValid(susSet5.tempC.isValid());
       if (not susTemperatures.sus_8_r_loc_xbybzb_pt_yb.isValid()) {
         susTemperatures.sus_8_r_loc_xbybzb_pt_yb.value = INVALID_TEMPERATURE;
       }
@@ -555,8 +540,8 @@ void ThermalController::copySus() {
   {
     PoolReadGuard pg6(&susSet6, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
     if (pg6.getReadResult() == returnvalue::OK) {
-      susTemperatures.sus_3_n_loc_xfybzf_pt_yf.value = susSet6.temperatureCelcius.value;
-      susTemperatures.sus_3_n_loc_xfybzf_pt_yf.setValid(susSet6.temperatureCelcius.isValid());
+      susTemperatures.sus_3_n_loc_xfybzf_pt_yf.value = susSet6.tempC.value;
+      susTemperatures.sus_3_n_loc_xfybzf_pt_yf.setValid(susSet6.tempC.isValid());
       if (not susTemperatures.sus_3_n_loc_xfybzf_pt_yf.isValid()) {
         susTemperatures.sus_3_n_loc_xfybzf_pt_yf.value = INVALID_TEMPERATURE;
       }
@@ -566,8 +551,8 @@ void ThermalController::copySus() {
   {
     PoolReadGuard pg7(&susSet7, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
     if (pg7.getReadResult() == returnvalue::OK) {
-      susTemperatures.sus_9_r_loc_xbybzb_pt_yf.value = susSet7.temperatureCelcius.value;
-      susTemperatures.sus_9_r_loc_xbybzb_pt_yf.setValid(susSet7.temperatureCelcius.isValid());
+      susTemperatures.sus_9_r_loc_xbybzb_pt_yf.value = susSet7.tempC.value;
+      susTemperatures.sus_9_r_loc_xbybzb_pt_yf.setValid(susSet7.tempC.isValid());
       if (not susTemperatures.sus_9_r_loc_xbybzb_pt_yf.isValid()) {
         susTemperatures.sus_9_r_loc_xbybzb_pt_yf.value = INVALID_TEMPERATURE;
       }
@@ -577,8 +562,8 @@ void ThermalController::copySus() {
   {
     PoolReadGuard pg8(&susSet8, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
     if (pg8.getReadResult() == returnvalue::OK) {
-      susTemperatures.sus_4_n_loc_xmyfzf_pt_zf.value = susSet8.temperatureCelcius.value;
-      susTemperatures.sus_4_n_loc_xmyfzf_pt_zf.setValid(susSet8.temperatureCelcius.isValid());
+      susTemperatures.sus_4_n_loc_xmyfzf_pt_zf.value = susSet8.tempC.value;
+      susTemperatures.sus_4_n_loc_xmyfzf_pt_zf.setValid(susSet8.tempC.isValid());
       if (not susTemperatures.sus_4_n_loc_xmyfzf_pt_zf.isValid()) {
         susTemperatures.sus_4_n_loc_xmyfzf_pt_zf.value = INVALID_TEMPERATURE;
       }
@@ -588,8 +573,8 @@ void ThermalController::copySus() {
   {
     PoolReadGuard pg9(&susSet9, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
     if (pg9.getReadResult() == returnvalue::OK) {
-      susTemperatures.sus_10_n_loc_xmybzf_pt_zf.value = susSet9.temperatureCelcius.value;
-      susTemperatures.sus_10_n_loc_xmybzf_pt_zf.setValid(susSet9.temperatureCelcius.isValid());
+      susTemperatures.sus_10_n_loc_xmybzf_pt_zf.value = susSet9.tempC.value;
+      susTemperatures.sus_10_n_loc_xmybzf_pt_zf.setValid(susSet9.tempC.isValid());
       if (not susTemperatures.sus_10_n_loc_xmybzf_pt_zf.isValid()) {
         susTemperatures.sus_10_n_loc_xmybzf_pt_zf.value = INVALID_TEMPERATURE;
       }
@@ -599,8 +584,8 @@ void ThermalController::copySus() {
   {
     PoolReadGuard pg10(&susSet10, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
     if (pg10.getReadResult() == returnvalue::OK) {
-      susTemperatures.sus_5_n_loc_xfymzb_pt_zb.value = susSet10.temperatureCelcius.value;
-      susTemperatures.sus_5_n_loc_xfymzb_pt_zb.setValid(susSet10.temperatureCelcius.isValid());
+      susTemperatures.sus_5_n_loc_xfymzb_pt_zb.value = susSet10.tempC.value;
+      susTemperatures.sus_5_n_loc_xfymzb_pt_zb.setValid(susSet10.tempC.isValid());
       if (not susTemperatures.sus_5_n_loc_xfymzb_pt_zb.isValid()) {
         susTemperatures.sus_5_n_loc_xfymzb_pt_zb.value = INVALID_TEMPERATURE;
       }
@@ -610,8 +595,8 @@ void ThermalController::copySus() {
   {
     PoolReadGuard pg11(&susSet11, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
     if (pg11.getReadResult() == returnvalue::OK) {
-      susTemperatures.sus_11_r_loc_xbymzb_pt_zb.value = susSet11.temperatureCelcius.value;
-      susTemperatures.sus_11_r_loc_xbymzb_pt_zb.setValid(susSet11.temperatureCelcius.isValid());
+      susTemperatures.sus_11_r_loc_xbymzb_pt_zb.value = susSet11.tempC.value;
+      susTemperatures.sus_11_r_loc_xbymzb_pt_zb.setValid(susSet11.tempC.isValid());
       if (not susTemperatures.sus_11_r_loc_xbymzb_pt_zb.isValid()) {
         susTemperatures.sus_11_r_loc_xbymzb_pt_zb.value = INVALID_TEMPERATURE;
       }
@@ -785,7 +770,7 @@ void ThermalController::copyDevices() {
   }
 
   {
-    lp_var_t<int16_t> tempMgt = lp_var_t<int16_t>(objects::IMTQ_HANDLER, IMTQ::MCU_TEMPERATURE);
+    lp_var_t<int16_t> tempMgt = lp_var_t<int16_t>(objects::IMTQ_HANDLER, imtq::MCU_TEMPERATURE);
     PoolReadGuard pg(&tempMgt, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
     if (pg.getReadResult() != returnvalue::OK) {
       sif::warning << "ThermalController: Failed to read MGT temperature" << std::endl;
@@ -869,7 +854,7 @@ void ThermalController::copyDevices() {
 
   {
     lp_var_t<float> tempGyro0 =
-        lp_var_t<float>(objects::GYRO_0_ADIS_HANDLER, ADIS1650X::TEMPERATURE);
+        lp_var_t<float>(objects::GYRO_0_ADIS_HANDLER, adis1650x::TEMPERATURE);
     PoolReadGuard pg(&tempGyro0, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
     if (pg.getReadResult() != returnvalue::OK) {
       sif::warning << "ThermalController: Failed to read gyro 0 temperature" << std::endl;
@@ -882,7 +867,7 @@ void ThermalController::copyDevices() {
   }
 
   {
-    lp_var_t<float> tempGyro1 = lp_var_t<float>(objects::GYRO_1_L3G_HANDLER, L3GD20H::TEMPERATURE);
+    lp_var_t<float> tempGyro1 = lp_var_t<float>(objects::GYRO_1_L3G_HANDLER, l3gd20h::TEMPERATURE);
     PoolReadGuard pg(&tempGyro1, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
     if (pg.getReadResult() != returnvalue::OK) {
       sif::warning << "ThermalController: Failed to read gyro 1 temperature" << std::endl;
@@ -896,7 +881,7 @@ void ThermalController::copyDevices() {
 
   {
     lp_var_t<float> tempGyro2 =
-        lp_var_t<float>(objects::GYRO_2_ADIS_HANDLER, ADIS1650X::TEMPERATURE);
+        lp_var_t<float>(objects::GYRO_2_ADIS_HANDLER, adis1650x::TEMPERATURE);
     PoolReadGuard pg(&tempGyro2, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
     if (pg.getReadResult() != returnvalue::OK) {
       sif::warning << "ThermalController: Failed to read gyro 2 temperature" << std::endl;
@@ -909,7 +894,7 @@ void ThermalController::copyDevices() {
   }
 
   {
-    lp_var_t<float> tempGyro3 = lp_var_t<float>(objects::GYRO_3_L3G_HANDLER, L3GD20H::TEMPERATURE);
+    lp_var_t<float> tempGyro3 = lp_var_t<float>(objects::GYRO_3_L3G_HANDLER, l3gd20h::TEMPERATURE);
     PoolReadGuard pg(&tempGyro3, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
     if (pg.getReadResult() != returnvalue::OK) {
       sif::warning << "ThermalController: Failed to read gyro 3 temperature" << std::endl;
@@ -923,7 +908,7 @@ void ThermalController::copyDevices() {
 
   {
     lp_var_t<float> tempMgm0 =
-        lp_var_t<float>(objects::MGM_0_LIS3_HANDLER, MGMLIS3MDL::TEMPERATURE_CELCIUS);
+        lp_var_t<float>(objects::MGM_0_LIS3_HANDLER, mgmLis3::TEMPERATURE_CELCIUS);
     PoolReadGuard pg(&tempMgm0, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
     if (pg.getReadResult() != returnvalue::OK) {
       sif::warning << "ThermalController: Failed to read MGM 0 temperature" << std::endl;
@@ -937,7 +922,7 @@ void ThermalController::copyDevices() {
 
   {
     lp_var_t<float> tempMgm2 =
-        lp_var_t<float>(objects::MGM_2_LIS3_HANDLER, MGMLIS3MDL::TEMPERATURE_CELCIUS);
+        lp_var_t<float>(objects::MGM_2_LIS3_HANDLER, mgmLis3::TEMPERATURE_CELCIUS);
     PoolReadGuard pg(&tempMgm2, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
     if (pg.getReadResult() != returnvalue::OK) {
       sif::warning << "ThermalController: Failed to read MGM 2 temperature" << std::endl;

mission/controller/ThermalController.h

@@ -6,12 +6,13 @@
 #include <fsfw/timemanager/Countdown.h>
 #include <mission/controller/controllerdefinitions/ThermalControllerDefinitions.h>
 #include <mission/devices/devicedefinitions/Max31865Definitions.h>
-#include <mission/devices/devicedefinitions/SusDefinitions.h>
 #include <mission/devices/devicedefinitions/Tmp1075Definitions.h>
+#include <mission/devices/devicedefinitions/susMax1227Helpers.h>
 
 #include <list>
 
 #include "mission/devices/HeaterHandler.h"
+#include "mission/devices/devicedefinitions/GomspaceDefinitions.h"
 #include "mission/trace.h"
 
 /**
@@ -76,9 +77,12 @@ class ThermalController : public ExtendedControllerBase {
 
   HeaterHandler& heaterHandler;
 
-  thermalControllerDefinitions::SensorTemperatures sensorTemperatures;
-  thermalControllerDefinitions::SusTemperatures susTemperatures;
-  thermalControllerDefinitions::DeviceTemperatures deviceTemperatures;
+  tcsCtrl::SensorTemperatures sensorTemperatures;
+  tcsCtrl::SusTemperatures susTemperatures;
+  tcsCtrl::DeviceTemperatures deviceTemperatures;
+  tcsCtrl::HeaterInfo heaterInfo;
+  lp_vec_t<int16_t, 9> currentVecPdu2 =
+      lp_vec_t<int16_t, 9>(gp_id_t(objects::PDU2_HANDLER, PDU::pool::PDU_CURRENTS));
 
   DeviceHandlerThermalSet imtqThermalSet;
 
@@ -108,18 +112,18 @@ class ThermalController : public ExtendedControllerBase {
   TMP1075::Tmp1075Dataset tmp1075SetIfBoard;
 
   // SUS
-  SUS::SusDataset susSet0;
-  SUS::SusDataset susSet1;
-  SUS::SusDataset susSet2;
-  SUS::SusDataset susSet3;
-  SUS::SusDataset susSet4;
-  SUS::SusDataset susSet5;
-  SUS::SusDataset susSet6;
-  SUS::SusDataset susSet7;
-  SUS::SusDataset susSet8;
-  SUS::SusDataset susSet9;
-  SUS::SusDataset susSet10;
-  SUS::SusDataset susSet11;
+  susMax1227::SusDataset susSet0;
+  susMax1227::SusDataset susSet1;
+  susMax1227::SusDataset susSet2;
+  susMax1227::SusDataset susSet3;
+  susMax1227::SusDataset susSet4;
+  susMax1227::SusDataset susSet5;
+  susMax1227::SusDataset susSet6;
+  susMax1227::SusDataset susSet7;
+  susMax1227::SusDataset susSet8;
+  susMax1227::SusDataset susSet9;
+  susMax1227::SusDataset susSet10;
+  susMax1227::SusDataset susSet11;
 
   // TempLimits
   TempLimits acsBoardLimits = TempLimits(-40.0, -40.0, 80.0, 85.0, 85.0);
@@ -160,11 +164,13 @@ class ThermalController : public ExtendedControllerBase {
   std::array<std::pair<bool, double>, 5> sensors;
   uint8_t numSensors = 0;
 
-  PoolEntry<float> tmp1075Tcs0 = PoolEntry<float>(10.0);
-  PoolEntry<float> tmp1075Tcs1 = PoolEntry<float>(10.0);
-  PoolEntry<float> tmp1075PlPcdu0 = PoolEntry<float>(10.0);
-  PoolEntry<float> tmp1075PlPcdu1 = PoolEntry<float>(10.0);
-  PoolEntry<float> tmp1075IfBrd = PoolEntry<float>(10.0);
+  PoolEntry<float> tmp1075Tcs0 = PoolEntry<float>({10.0});
+  PoolEntry<float> tmp1075Tcs1 = PoolEntry<float>({10.0});
+  PoolEntry<float> tmp1075PlPcdu0 = PoolEntry<float>({10.0});
+  PoolEntry<float> tmp1075PlPcdu1 = PoolEntry<float>({10.0});
+  PoolEntry<float> tmp1075IfBrd = PoolEntry<float>({10.0});
+  PoolEntry<uint8_t> heaterSwitchStates = PoolEntry<uint8_t>(heater::NUMBER_OF_SWITCHES);
+  PoolEntry<int16_t> heaterCurrent = PoolEntry<int16_t>();
 
   static constexpr dur_millis_t MUTEX_TIMEOUT = 50;
 

mission/controller/acs/AcsParameters.cpp

@@ -342,7 +342,41 @@ ReturnValue_t AcsParameters::getParameter(uint8_t domainId, uint8_t parameterId,
           return INVALID_IDENTIFIER_ID;
       }
       break;
-    case (0x9):  // TargetModeControllerParameters
+    case (0x9):  // IdleModeControllerParameters
+      switch (parameterId) {
+        case 0x0:
+          parameterWrapper->set(targetModeControllerParameters.zeta);
+          break;
+        case 0x1:
+          parameterWrapper->set(targetModeControllerParameters.om);
+          break;
+        case 0x2:
+          parameterWrapper->set(targetModeControllerParameters.omMax);
+          break;
+        case 0x3:
+          parameterWrapper->set(targetModeControllerParameters.qiMin);
+          break;
+        case 0x4:
+          parameterWrapper->set(targetModeControllerParameters.gainNullspace);
+          break;
+        case 0x5:
+          parameterWrapper->set(targetModeControllerParameters.desatMomentumRef);
+          break;
+        case 0x6:
+          parameterWrapper->set(targetModeControllerParameters.deSatGainFactor);
+          break;
+        case 0x7:
+          parameterWrapper->set(targetModeControllerParameters.desatOn);
+          break;
+        case 0x8:
+          parameterWrapper->set(targetModeControllerParameters.enableAntiStiction);
+          break;
+
+        default:
+          return INVALID_IDENTIFIER_ID;
+      }
+      break;
+    case (0xA):  // TargetModeControllerParameters
       switch (parameterId) {
         case 0x0:
           parameterWrapper->set(targetModeControllerParameters.zeta);
@@ -408,7 +442,61 @@ ReturnValue_t AcsParameters::getParameter(uint8_t domainId, uint8_t parameterId,
           return INVALID_IDENTIFIER_ID;
       }
       break;
-    case (0xA):  // NadirModeControllerParameters
+    case (0xB):  // GsTargetModeControllerParameters
+      switch (parameterId) {
+        case 0x0:
+          parameterWrapper->set(targetModeControllerParameters.zeta);
+          break;
+        case 0x1:
+          parameterWrapper->set(targetModeControllerParameters.om);
+          break;
+        case 0x2:
+          parameterWrapper->set(targetModeControllerParameters.omMax);
+          break;
+        case 0x3:
+          parameterWrapper->set(targetModeControllerParameters.qiMin);
+          break;
+        case 0x4:
+          parameterWrapper->set(targetModeControllerParameters.gainNullspace);
+          break;
+        case 0x5:
+          parameterWrapper->set(targetModeControllerParameters.desatMomentumRef);
+          break;
+        case 0x6:
+          parameterWrapper->set(targetModeControllerParameters.deSatGainFactor);
+          break;
+        case 0x7:
+          parameterWrapper->set(targetModeControllerParameters.desatOn);
+          break;
+        case 0x8:
+          parameterWrapper->set(targetModeControllerParameters.enableAntiStiction);
+          break;
+        case 0x9:
+          parameterWrapper->set(targetModeControllerParameters.refDirection);
+          break;
+        case 0xA:
+          parameterWrapper->set(targetModeControllerParameters.refRotRate);
+          break;
+        case 0xB:
+          parameterWrapper->set(targetModeControllerParameters.quatRef);
+          break;
+        case 0xC:
+          parameterWrapper->set(targetModeControllerParameters.timeElapsedMax);
+          break;
+        case 0xD:
+          parameterWrapper->set(targetModeControllerParameters.latitudeTgt);
+          break;
+        case 0xE:
+          parameterWrapper->set(targetModeControllerParameters.longitudeTgt);
+          break;
+        case 0xF:
+          parameterWrapper->set(targetModeControllerParameters.altitudeTgt);
+          break;
+        default:
+          return INVALID_IDENTIFIER_ID;
+      }
+      break;
+    case (0xC):  // NadirModeControllerParameters
       switch (parameterId) {
         case 0x0:
           parameterWrapper->set(nadirModeControllerParameters.zeta);
@@ -450,7 +538,7 @@ ReturnValue_t AcsParameters::getParameter(uint8_t domainId, uint8_t parameterId,
           return INVALID_IDENTIFIER_ID;
       }
       break;
-    case (0xB):  // InertialModeControllerParameters
+    case (0xD):  // InertialModeControllerParameters
       switch (parameterId) {
         case 0x0:
           parameterWrapper->set(inertialModeControllerParameters.zeta);
@@ -492,7 +580,7 @@ ReturnValue_t AcsParameters::getParameter(uint8_t domainId, uint8_t parameterId,
           return INVALID_IDENTIFIER_ID;
       }
       break;
-    case (0xC):  // StrParameters
+    case (0xE):  // StrParameters
       switch (parameterId) {
         case 0x0:
           parameterWrapper->set(strParameters.exclusionAngle);
@@ -504,7 +592,7 @@ ReturnValue_t AcsParameters::getParameter(uint8_t domainId, uint8_t parameterId,
           return INVALID_IDENTIFIER_ID;
       }
       break;
-    case (0xD):  // GpsParameters
+    case (0xF):  // GpsParameters
       switch (parameterId) {
         case 0x0:
           parameterWrapper->set(gpsParameters.timeDiffVelocityMax);
@@ -513,7 +601,7 @@ ReturnValue_t AcsParameters::getParameter(uint8_t domainId, uint8_t parameterId,
           return INVALID_IDENTIFIER_ID;
       }
       break;
-    case (0xE):  // SunModelParameters
+    case (0x10):  // SunModelParameters
       switch (parameterId) {
         case 0x0:
           parameterWrapper->set(sunModelParameters.domega);
@@ -543,7 +631,7 @@ ReturnValue_t AcsParameters::getParameter(uint8_t domainId, uint8_t parameterId,
           return INVALID_IDENTIFIER_ID;
       }
       break;
-    case (0xF):  // KalmanFilterParameters
+    case (0x11):  // KalmanFilterParameters
       switch (parameterId) {
         case 0x0:
           parameterWrapper->set(kalmanFilterParameters.sensorNoiseSTR);
@@ -567,7 +655,7 @@ ReturnValue_t AcsParameters::getParameter(uint8_t domainId, uint8_t parameterId,
           return INVALID_IDENTIFIER_ID;
       }
       break;
-    case (0x10):  // MagnetorquesParameter
+    case (0x12):  // MagnetorquesParameter
       switch (parameterId) {
         case 0x0:
           parameterWrapper->set(magnetorquesParameter.mtq0orientationMatrix);
@@ -594,7 +682,7 @@ ReturnValue_t AcsParameters::getParameter(uint8_t domainId, uint8_t parameterId,
           return INVALID_IDENTIFIER_ID;
       }
       break;
-    case (0x11):  // DetumbleParameter
+    case (0x13):  // DetumbleParameter
       switch (parameterId) {
         case 0x0:
           parameterWrapper->set(detumbleParameter.detumblecounter);

mission/controller/acs/AcsParameters.h

@@ -1,8 +1,3 @@
-/*******************************
- *	EIVE Flight Software Framework (FSFW)
- * (c) 2022 IRS, Uni Stuttgart
- *******************************/
-
 #ifndef ACSPARAMETERS_H_
 #define ACSPARAMETERS_H_
 
@@ -841,10 +836,12 @@ class AcsParameters : public HasParametersIF {
     uint8_t enableAntiStiction = true;
   } pointingLawParameters;
 
+  struct IdleModeControllerParameters : PointingLawParameters {
+  } idleModeControllerParameters;
+
   struct TargetModeControllerParameters : PointingLawParameters {
     double refDirection[3] = {-1, 0, 0};  // Antenna
-    double refRotRate[3] = {0, 0, 0};     // Not used atm, do we want an option to
-    // give this as an input- currently en calculation is done
+    double refRotRate[3] = {0, 0, 0};
     double quatRef[4] = {0, 0, 0, 1};
     int8_t timeElapsedMax = 10;  // rot rate calculations
 
@@ -860,9 +857,20 @@ class AcsParameters : public HasParametersIF {
     double blindRotRate = 1 * M_PI / 180;
   } targetModeControllerParameters;
 
+  struct GsTargetModeControllerParameters : PointingLawParameters {
+    double refDirection[3] = {-1, 0, 0};  // Antenna
+    int8_t timeElapsedMax = 10;           // rot rate calculations
+
+    // Default is Stuttgart GS
+    double latitudeTgt = 48.7495 * M_PI / 180.;   // [rad] Latitude
+    double longitudeTgt = 9.10384 * M_PI / 180.;  // [rad] Longitude
+    double altitudeTgt = 500;                     // [m]
+  } gsTargetModeControllerParameters;
+
   struct NadirModeControllerParameters : PointingLawParameters {
     double refDirection[3] = {-1, 0, 0};  // Antenna
     double quatRef[4] = {0, 0, 0, 1};
+    double refRotRate[3] = {0, 0, 0};
     int8_t timeElapsedMax = 10;  // rot rate calculations
   } nadirModeControllerParameters;
 

mission/controller/acs/Guidance.cpp

@@ -1,10 +1,3 @@
-/*
- * Guidance.cpp
- *
- *  Created on: 6 Jun 2022
- *      Author: Robin Marquardt
- */
-
 #include "Guidance.h"
 
 #include <fsfw/datapool/PoolReadGuard.h>
@@ -19,74 +12,50 @@
 #include "util/CholeskyDecomposition.h"
 #include "util/MathOperations.h"
 
-Guidance::Guidance(AcsParameters *acsParameters_) { acsParameters = *acsParameters_; }
+Guidance::Guidance(AcsParameters *acsParameters_) : acsParameters(*acsParameters_) {}
 
 Guidance::~Guidance() {}
 
-void Guidance::getTargetParamsSafe(double sunTargetSafe[3], double satRateSafe[3]) {
-  if (not std::filesystem::exists(SD_0_SKEWED_PTG_FILE) or
-      not std::filesystem::exists(SD_1_SKEWED_PTG_FILE)) {  // ToDo: if file does not exist anymore
-    std::memcpy(sunTargetSafe, acsParameters.safeModeControllerParameters.sunTargetDir,
-                3 * sizeof(double));
-  } else {
-    std::memcpy(sunTargetSafe, acsParameters.safeModeControllerParameters.sunTargetDirLeop,
-                3 * sizeof(double));
-  }
-  std::memcpy(satRateSafe, acsParameters.safeModeControllerParameters.satRateRef,
-              3 * sizeof(double));
-}
-
-void Guidance::targetQuatPtgSingleAxis(ACS::SensorValues *sensorValues, acsctrl::MekfData *mekfData,
-                                       acsctrl::SusDataProcessed *susDataProcessed,
-                                       acsctrl::GpsDataProcessed *gpsDataProcessed, timeval now,
-                                       double targetQuat[4], double refSatRate[3]) {
+void Guidance::targetQuatPtgSingleAxis(timeval now, double posSatE[3], double velSatE[3],
+                                       double sunDirI[3], double refDirB[3], double quatBI[4],
+                                       double targetQuat[4], double targetSatRotRate[3]) {
   //-------------------------------------------------------------------------------------
   //	Calculation of target quaternion to groundstation or given latitude, longitude and altitude
   //-------------------------------------------------------------------------------------
-  //	Transform longitude, latitude and altitude to cartesian coordiantes (earth
-  // fixed/centered frame)
-  double targetCart[3] = {0, 0, 0};
+  // transform longitude, latitude and altitude to ECEF
+  double targetE[3] = {0, 0, 0};
 
   MathOperations<double>::cartesianFromLatLongAlt(
       acsParameters.targetModeControllerParameters.latitudeTgt,
       acsParameters.targetModeControllerParameters.longitudeTgt,
-      acsParameters.targetModeControllerParameters.altitudeTgt, targetCart);
+      acsParameters.targetModeControllerParameters.altitudeTgt, targetE);
 
-  //	Position of the satellite in the earth/fixed frame via GPS
-  double posSatE[3] = {0, 0, 0};
-  double geodeticLatRad = (sensorValues->gpsSet.latitude.value) * PI / 180;
-  double longitudeRad = (sensorValues->gpsSet.longitude.value) * PI / 180;
-  MathOperations<double>::cartesianFromLatLongAlt(geodeticLatRad, longitudeRad,
-                                                  sensorValues->gpsSet.altitude.value, posSatE);
-
-  //	Target direction in the ECEF frame
+  // target direction in the ECEF frame
   double targetDirE[3] = {0, 0, 0};
-  VectorOperations<double>::subtract(targetCart, posSatE, targetDirE, 3);
+  VectorOperations<double>::subtract(targetE, posSatE, targetDirE, 3);
 
-  //	Transformation between ECEF and IJK frame
-  double dcmEJ[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
-  double dcmJE[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
-  double dcmEJDot[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
-  MathOperations<double>::ecfToEciWithNutPre(now, *dcmEJ, *dcmEJDot);
-  MathOperations<double>::inverseMatrixDimThree(*dcmEJ, *dcmJE);
+  // transformation between ECEF and ECI frame
+  double dcmEI[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
+  double dcmIE[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
+  double dcmEIDot[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
+  MathOperations<double>::ecfToEciWithNutPre(now, *dcmEI, *dcmEIDot);
+  MathOperations<double>::inverseMatrixDimThree(*dcmEI, *dcmIE);
 
-  double dcmJEDot[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
-  MathOperations<double>::inverseMatrixDimThree(*dcmEJDot, *dcmJEDot);
+  double dcmIEDot[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
+  MathOperations<double>::inverseMatrixDimThree(*dcmEIDot, *dcmIEDot);
 
-  //	Transformation between ECEF and Body frame
-  double dcmBJ[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
+  // transformation between ECEF and Body frame
+  double dcmBI[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
   double dcmBE[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
-  double quatBJ[4] = {0, 0, 0, 0};
-  std::memcpy(quatBJ, mekfData->quatMekf.value, 4 * sizeof(double));
 
-  QuaternionOperations::toDcm(quatBJ, dcmBJ);
-  MatrixOperations<double>::multiply(*dcmBJ, *dcmJE, *dcmBE, 3, 3, 3);
+  QuaternionOperations::toDcm(quatBI, dcmBI);
+  MatrixOperations<double>::multiply(*dcmBI, *dcmIE, *dcmBE, 3, 3, 3);
 
-  //	Target Direction in the body frame
+  // target Direction in the body frame
   double targetDirB[3] = {0, 0, 0};
   MatrixOperations<double>::multiply(*dcmBE, targetDirE, targetDirB, 3, 3, 1);
 
-  //	rotation quaternion from two vectors
+  // rotation quaternion from two vectors
   double refDir[3] = {0, 0, 0};
   refDir[0] = acsParameters.targetModeControllerParameters.refDirection[0];
   refDir[1] = acsParameters.targetModeControllerParameters.refDirection[1];
@@ -106,15 +75,13 @@ void Guidance::targetQuatPtgSingleAxis(ACS::SensorValues *sensorValues, acsctrl:
   VectorOperations<double>::normalize(targetQuat, targetQuat, 4);
 
   //-------------------------------------------------------------------------------------
-  //	Calculation of reference rotation rate
+  // calculation of reference rotation rate
   //-------------------------------------------------------------------------------------
-  double velSatE[3] = {0, 0, 0};
-  std::memcpy(velSatE, gpsDataProcessed->gpsVelocity.value, 3 * sizeof(double));
   double velSatB[3] = {0, 0, 0}, velSatBPart1[3] = {0, 0, 0}, velSatBPart2[3] = {0, 0, 0};
-  //	Velocity: v_B = dcm_BI * dcmIE * v_E + dcm_BI * DotDcm_IE * v_E
+  // velocity: v_B = dcm_BI * dcmIE * v_E + dcm_BI * DotDcm_IE * v_E
   MatrixOperations<double>::multiply(*dcmBE, velSatE, velSatBPart1, 3, 3, 1);
   double dcmBEDot[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
-  MatrixOperations<double>::multiply(*dcmBJ, *dcmJEDot, *dcmBEDot, 3, 3, 3);
+  MatrixOperations<double>::multiply(*dcmBI, *dcmIEDot, *dcmBEDot, 3, 3, 3);
   MatrixOperations<double>::multiply(*dcmBEDot, posSatE, velSatBPart2, 3, 3, 1);
   VectorOperations<double>::add(velSatBPart1, velSatBPart2, velSatB, 3);
 
@@ -124,21 +91,14 @@ void Guidance::targetQuatPtgSingleAxis(ACS::SensorValues *sensorValues, acsctrl:
   double satRateDir[3] = {0, 0, 0};
   VectorOperations<double>::cross(velSatB, targetDirB, satRateDir);
   VectorOperations<double>::normalize(satRateDir, satRateDir, 3);
-  VectorOperations<double>::mulScalar(satRateDir, normRefSatRate, refSatRate, 3);
+  VectorOperations<double>::mulScalar(satRateDir, normRefSatRate, targetSatRotRate, 3);
 
   //-------------------------------------------------------------------------------------
   //	Calculation of reference rotation rate in case of star tracker blinding
   //-------------------------------------------------------------------------------------
   if (acsParameters.targetModeControllerParameters.avoidBlindStr) {
     double sunDirB[3] = {0, 0, 0};
-
-    if (susDataProcessed->sunIjkModel.isValid()) {
-      double sunDirJ[3] = {0, 0, 0};
-      std::memcpy(sunDirJ, susDataProcessed->sunIjkModel.value, 3 * sizeof(double));
-      MatrixOperations<double>::multiply(*dcmBJ, sunDirJ, sunDirB, 3, 3, 1);
-    } else {
-      std::memcpy(sunDirB, susDataProcessed->susVecTot.value, 3 * sizeof(double));
-    }
+    MatrixOperations<double>::multiply(*dcmBI, sunDirI, sunDirB, 3, 3, 1);
 
     double exclAngle = acsParameters.strParameters.exclusionAngle,
            blindStart = acsParameters.targetModeControllerParameters.blindAvoidStart,
@@ -148,18 +108,13 @@ void Guidance::targetQuatPtgSingleAxis(ACS::SensorValues *sensorValues, acsctrl:
 
     if (!(strBlindAvoidFlag)) {
       double critSightAngle = blindStart * exclAngle;
-
       if (sightAngleSun < critSightAngle) {
         strBlindAvoidFlag = true;
       }
-
-    }
-
-    else {
+    } else {
       if (sightAngleSun < blindEnd * exclAngle) {
         double normBlindRefRate = acsParameters.targetModeControllerParameters.blindRotRate;
         double blindRefRate[3] = {0, 0, 0};
-
         if (sunDirB[1] < 0) {
           blindRefRate[0] = normBlindRefRate;
           blindRefRate[1] = 0;
@@ -169,21 +124,353 @@ void Guidance::targetQuatPtgSingleAxis(ACS::SensorValues *sensorValues, acsctrl:
           blindRefRate[1] = 0;
           blindRefRate[2] = 0;
         }
-
-        VectorOperations<double>::add(blindRefRate, refSatRate, refSatRate, 3);
-
+        VectorOperations<double>::add(blindRefRate, targetSatRotRate, targetSatRotRate, 3);
       } else {
         strBlindAvoidFlag = false;
       }
     }
   }
+  // revert calculated quaternion from qBX to qIX
+  double quatIB[4] = {0, 0, 0, 1};
+  QuaternionOperations::inverse(quatBI, quatIB);
+  QuaternionOperations::multiply(quatIB, targetQuat, targetQuat);
 }
 
-void Guidance::refRotationRate(int8_t timeElapsedMax, timeval now, double quatInertialTarget[4],
-                               double *refSatRate) {
+void Guidance::targetQuatPtgThreeAxes(timeval now, double posSatE[3], double velSatE[3],
+                                      double targetQuat[4], double targetSatRotRate[3]) {
+  //-------------------------------------------------------------------------------------
+  //	Calculation of target quaternion for target pointing
+  //-------------------------------------------------------------------------------------
+  // transform longitude, latitude and altitude to cartesian coordiantes (ECEF)
+  double targetE[3] = {0, 0, 0};
+  MathOperations<double>::cartesianFromLatLongAlt(
+      acsParameters.targetModeControllerParameters.latitudeTgt,
+      acsParameters.targetModeControllerParameters.longitudeTgt,
+      acsParameters.targetModeControllerParameters.altitudeTgt, targetE);
+  double targetDirE[3] = {0, 0, 0};
+  VectorOperations<double>::subtract(targetE, posSatE, targetDirE, 3);
+
+  // transformation between ECEF and ECI frame
+  double dcmEI[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
+  double dcmIE[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
+  double dcmEIDot[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
+  MathOperations<double>::ecfToEciWithNutPre(now, *dcmEI, *dcmEIDot);
+  MathOperations<double>::inverseMatrixDimThree(*dcmEI, *dcmIE);
+
+  double dcmIEDot[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
+  MathOperations<double>::inverseMatrixDimThree(*dcmEIDot, *dcmIEDot);
+
+  // target direction in the ECI frame
+  double posSatI[3] = {0, 0, 0}, targetI[3] = {0, 0, 0}, targetDirI[3] = {0, 0, 0};
+  MatrixOperations<double>::multiply(*dcmIE, posSatE, posSatI, 3, 3, 1);
+  MatrixOperations<double>::multiply(*dcmIE, targetE, targetI, 3, 3, 1);
+  VectorOperations<double>::subtract(targetI, posSatI, targetDirI, 3);
+
+  // x-axis aligned with target direction
+  // this aligns with the camera, E- and S-band antennas
+  double xAxis[3] = {0, 0, 0};
+  VectorOperations<double>::normalize(targetDirI, xAxis, 3);
+
+  // transform velocity into inertial frame
+  double velocityI[3] = {0, 0, 0}, velPart1[3] = {0, 0, 0}, velPart2[3] = {0, 0, 0};
+  MatrixOperations<double>::multiply(*dcmIE, velSatE, velPart1, 3, 3, 1);
+  MatrixOperations<double>::multiply(*dcmIEDot, posSatE, velPart2, 3, 3, 1);
+  VectorOperations<double>::add(velPart1, velPart2, velocityI, 3);
+
+  // orbital normal vector of target and velocity vector
+  double orbitalNormalI[3] = {0, 0, 0};
+  VectorOperations<double>::cross(posSatI, velocityI, orbitalNormalI);
+  VectorOperations<double>::normalize(orbitalNormalI, orbitalNormalI, 3);
+
+  // y-axis of satellite in orbit plane so that z-axis is parallel to long side of picture
+  // resolution
+  double yAxis[3] = {0, 0, 0};
+  VectorOperations<double>::cross(orbitalNormalI, xAxis, yAxis);
+  VectorOperations<double>::normalize(yAxis, yAxis, 3);
+
+  // z-axis completes RHS
+  double zAxis[3] = {0, 0, 0};
+  VectorOperations<double>::cross(xAxis, yAxis, zAxis);
+
+  // join transformation matrix
+  double dcmIX[3][3] = {{xAxis[0], yAxis[0], zAxis[0]},
+                        {xAxis[1], yAxis[1], zAxis[1]},
+                        {xAxis[2], yAxis[2], zAxis[2]}};
+  QuaternionOperations::fromDcm(dcmIX, targetQuat);
+
+  int8_t timeElapsedMax = acsParameters.targetModeControllerParameters.timeElapsedMax;
+  targetRotationRate(timeElapsedMax, now, targetQuat, targetSatRotRate);
+}
+
+void Guidance::targetQuatPtgGs(timeval now, double posSatE[3], double sunDirI[3],
+                               double targetQuat[4], double targetSatRotRate[3]) {
+  //-------------------------------------------------------------------------------------
+  //	Calculation of target quaternion for ground station pointing
+  //-------------------------------------------------------------------------------------
+  // transform longitude, latitude and altitude to cartesian coordiantes (ECEF)
+  double groundStationE[3] = {0, 0, 0};
+
+  MathOperations<double>::cartesianFromLatLongAlt(
+      acsParameters.gsTargetModeControllerParameters.latitudeTgt,
+      acsParameters.gsTargetModeControllerParameters.longitudeTgt,
+      acsParameters.gsTargetModeControllerParameters.altitudeTgt, groundStationE);
+  double targetDirE[3] = {0, 0, 0};
+  VectorOperations<double>::subtract(groundStationE, posSatE, targetDirE, 3);
+
+  // transformation between ECEF and ECI frame
+  double dcmEI[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
+  double dcmIE[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
+  double dcmEIDot[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
+  MathOperations<double>::ecfToEciWithNutPre(now, *dcmEI, *dcmEIDot);
+  MathOperations<double>::inverseMatrixDimThree(*dcmEI, *dcmIE);
+
+  double dcmIEDot[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
+  MathOperations<double>::inverseMatrixDimThree(*dcmEIDot, *dcmIEDot);
+
+  // target direction in the ECI frame
+  double posSatI[3] = {0, 0, 0}, groundStationI[3] = {0, 0, 0}, groundStationDirI[3] = {0, 0, 0};
+  MatrixOperations<double>::multiply(*dcmIE, posSatE, posSatI, 3, 3, 1);
+  MatrixOperations<double>::multiply(*dcmIE, groundStationE, groundStationI, 3, 3, 1);
+  VectorOperations<double>::subtract(groundStationI, posSatI, groundStationDirI, 3);
+
+  // negative x-axis aligned with target direction
+  // this aligns with the camera, E- and S-band antennas
+  double xAxis[3] = {0, 0, 0};
+  VectorOperations<double>::normalize(groundStationDirI, xAxis, 3);
+  VectorOperations<double>::mulScalar(xAxis, -1, xAxis, 3);
+
+  // get sun vector model in ECI
+  VectorOperations<double>::normalize(sunDirI, sunDirI, 3);
+
+  // calculate z-axis as projection of sun vector into plane defined by x-axis as normal vector
+  // z = sPerpenticular =  s - sParallel = s - (x*s)/norm(x)^2 * x
+  double xDotS = VectorOperations<double>::dot(xAxis, sunDirI);
+  xDotS /= pow(VectorOperations<double>::norm(xAxis, 3), 2);
+  double sunParallel[3], zAxis[3];
+  VectorOperations<double>::mulScalar(xAxis, xDotS, sunParallel, 3);
+  VectorOperations<double>::subtract(sunDirI, sunParallel, zAxis, 3);
+  VectorOperations<double>::normalize(zAxis, zAxis, 3);
+
+  // y-axis completes RHS
+  double yAxis[3];
+  VectorOperations<double>::cross(zAxis, xAxis, yAxis);
+  VectorOperations<double>::normalize(yAxis, yAxis, 3);
+
+  // join transformation matrix
+  double dcmTgt[3][3] = {{xAxis[0], yAxis[0], zAxis[0]},
+                         {xAxis[1], yAxis[1], zAxis[1]},
+                         {xAxis[2], yAxis[2], zAxis[2]}};
+  QuaternionOperations::fromDcm(dcmTgt, targetQuat);
+
+  int8_t timeElapsedMax = acsParameters.gsTargetModeControllerParameters.timeElapsedMax;
+  targetRotationRate(timeElapsedMax, now, targetQuat, targetSatRotRate);
+}
+
+void Guidance::targetQuatPtgSun(double sunDirI[3], double targetQuat[4], double refSatRate[3]) {
+  //-------------------------------------------------------------------------------------
+  //	Calculation of target quaternion to sun
+  //-------------------------------------------------------------------------------------
+  //  positive z-Axis of EIVE in direction of sun
+  double zAxis[3] = {0, 0, 0};
+  VectorOperations<double>::normalize(sunDirI, zAxis, 3);
+
+  //  assign helper vector (north pole inertial)
+  double helperVec[3] = {0, 0, 1};
+
+  //  construct y-axis from helper vector and z-axis
+  double yAxis[3] = {0, 0, 0};
+  VectorOperations<double>::cross(zAxis, helperVec, yAxis);
+  VectorOperations<double>::normalize(yAxis, yAxis, 3);
+
+  //  x-axis completes RHS
+  double xAxis[3] = {0, 0, 0};
+  VectorOperations<double>::cross(yAxis, zAxis, xAxis);
+  VectorOperations<double>::normalize(xAxis, xAxis, 3);
+
+  // join transformation matrix
+  double dcmTgt[3][3] = {{xAxis[0], yAxis[0], zAxis[0]},
+                         {xAxis[1], yAxis[1], zAxis[1]},
+                         {xAxis[2], yAxis[2], zAxis[2]}};
+  QuaternionOperations::fromDcm(dcmTgt, targetQuat);
+
+  //----------------------------------------------------------------------------
+  //	Calculation of reference rotation rate
+  //----------------------------------------------------------------------------
+  refSatRate[0] = 0;
+  refSatRate[1] = 0;
+  refSatRate[2] = 0;
+}
+
+void Guidance::targetQuatPtgNadirSingleAxis(timeval now, double posSatE[3], double quatBI[4],
+                                            double targetQuat[4], double refDirB[3],
+                                            double refSatRate[3]) {
+  //-------------------------------------------------------------------------------------
+  //	Calculation of target quaternion for Nadir pointing
+  //-------------------------------------------------------------------------------------
+  double targetDirE[3] = {0, 0, 0};
+  VectorOperations<double>::mulScalar(posSatE, -1, targetDirE, 3);
+
+  // transformation between ECEF and ECI frame
+  double dcmEI[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
+  double dcmIE[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
+  double dcmEIDot[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
+  MathOperations<double>::ecfToEciWithNutPre(now, *dcmEI, *dcmEIDot);
+  MathOperations<double>::inverseMatrixDimThree(*dcmEI, *dcmIE);
+
+  double dcmIEDot[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
+  MathOperations<double>::inverseMatrixDimThree(*dcmEIDot, *dcmIEDot);
+
+  // transformation between ECEF and Body frame
+  double dcmBI[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
+  double dcmBE[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
+  QuaternionOperations::toDcm(quatBI, dcmBI);
+  MatrixOperations<double>::multiply(*dcmBI, *dcmIE, *dcmBE, 3, 3, 3);
+
+  // target Direction in the body frame
+  double targetDirB[3] = {0, 0, 0};
+  MatrixOperations<double>::multiply(*dcmBE, targetDirE, targetDirB, 3, 3, 1);
+
+  // rotation quaternion from two vectors
+  double refDir[3] = {0, 0, 0};
+  refDir[0] = acsParameters.nadirModeControllerParameters.refDirection[0];
+  refDir[1] = acsParameters.nadirModeControllerParameters.refDirection[1];
+  refDir[2] = acsParameters.nadirModeControllerParameters.refDirection[2];
+  double noramlizedTargetDirB[3] = {0, 0, 0};
+  VectorOperations<double>::normalize(targetDirB, noramlizedTargetDirB, 3);
+  VectorOperations<double>::normalize(refDir, refDir, 3);
+  double normTargetDirB = VectorOperations<double>::norm(noramlizedTargetDirB, 3);
+  double normRefDir = VectorOperations<double>::norm(refDir, 3);
+  double crossDir[3] = {0, 0, 0};
+  double dotDirections = VectorOperations<double>::dot(noramlizedTargetDirB, refDir);
+  VectorOperations<double>::cross(noramlizedTargetDirB, refDir, crossDir);
+  targetQuat[0] = crossDir[0];
+  targetQuat[1] = crossDir[1];
+  targetQuat[2] = crossDir[2];
+  targetQuat[3] = sqrt(pow(normTargetDirB, 2) * pow(normRefDir, 2) + dotDirections);
+  VectorOperations<double>::normalize(targetQuat, targetQuat, 4);
+
   //-------------------------------------------------------------------------------------
   //	Calculation of reference rotation rate
   //-------------------------------------------------------------------------------------
+  refSatRate[0] = 0;
+  refSatRate[1] = 0;
+  refSatRate[2] = 0;
+
+  // revert calculated quaternion from qBX to qIX
+  double quatIB[4] = {0, 0, 0, 1};
+  QuaternionOperations::inverse(quatBI, quatIB);
+  QuaternionOperations::multiply(quatIB, targetQuat, targetQuat);
+}
+
+void Guidance::targetQuatPtgNadirThreeAxes(timeval now, double posSatE[3], double velSatE[3],
+                                           double targetQuat[4], double refSatRate[3]) {
+  //-------------------------------------------------------------------------------------
+  //	Calculation of target quaternion for Nadir pointing
+  //-------------------------------------------------------------------------------------
+  // transformation between ECEF and ECI frame
+  double dcmEI[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
+  double dcmIE[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
+  double dcmEIDot[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
+  MathOperations<double>::ecfToEciWithNutPre(now, *dcmEI, *dcmEIDot);
+  MathOperations<double>::inverseMatrixDimThree(*dcmEI, *dcmIE);
+
+  double dcmIEDot[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
+  MathOperations<double>::inverseMatrixDimThree(*dcmEIDot, *dcmIEDot);
+
+  // satellite position in inertial reference frame
+  double posSatI[3] = {0, 0, 0};
+  MatrixOperations<double>::multiply(*dcmIE, posSatE, posSatI, 3, 3, 1);
+
+  // negative x-axis aligned with position vector
+  // this aligns with the camera, E- and S-band antennas
+  double xAxis[3] = {0, 0, 0};
+  VectorOperations<double>::normalize(posSatI, xAxis, 3);
+  VectorOperations<double>::mulScalar(xAxis, -1, xAxis, 3);
+
+  // make z-Axis parallel to major part of camera resolution
+  double zAxis[3] = {0, 0, 0};
+  double velocityI[3] = {0, 0, 0}, velPart1[3] = {0, 0, 0}, velPart2[3] = {0, 0, 0};
+  MatrixOperations<double>::multiply(*dcmIE, velSatE, velPart1, 3, 3, 1);
+  MatrixOperations<double>::multiply(*dcmIEDot, posSatE, velPart2, 3, 3, 1);
+  VectorOperations<double>::add(velPart1, velPart2, velocityI, 3);
+  VectorOperations<double>::cross(xAxis, velocityI, zAxis);
+  VectorOperations<double>::normalize(zAxis, zAxis, 3);
+
+  // y-Axis completes RHS
+  double yAxis[3] = {0, 0, 0};
+  VectorOperations<double>::cross(zAxis, xAxis, yAxis);
+
+  // join transformation matrix
+  double dcmTgt[3][3] = {{xAxis[0], yAxis[0], zAxis[0]},
+                         {xAxis[1], yAxis[1], zAxis[1]},
+                         {xAxis[2], yAxis[2], zAxis[2]}};
+  QuaternionOperations::fromDcm(dcmTgt, targetQuat);
+
+  int8_t timeElapsedMax = acsParameters.nadirModeControllerParameters.timeElapsedMax;
+  targetRotationRate(timeElapsedMax, now, targetQuat, refSatRate);
+}
+
+void Guidance::comparePtg(double currentQuat[4], double currentSatRotRate[3], double targetQuat[4],
+                          double targetSatRotRate[3], double refQuat[4], double refSatRotRate[3],
+                          double errorQuat[4], double errorSatRotRate[3], double errorAngle) {
+  // First calculate error quaternion between current and target orientation
+  QuaternionOperations::multiply(currentQuat, targetQuat, errorQuat);
+  // Last calculate add rotation from reference quaternion
+  QuaternionOperations::multiply(refQuat, errorQuat, errorQuat);
+  // Keep scalar part of quaternion positive
+  if (errorQuat[3] < 0) {
+    VectorOperations<double>::mulScalar(errorQuat, -1, errorQuat, 4);
+  }
+  // Calculate error angle
+  errorAngle = QuaternionOperations::getAngle(errorQuat, true);
+
+  // Only give back error satellite rotational rate if orientation has already been aquired
+  if (errorAngle < 2. / 180. * M_PI) {
+    // First combine the target and reference satellite rotational rates
+    double combinedRefSatRotRate[3] = {0, 0, 0};
+    VectorOperations<double>::add(targetSatRotRate, refSatRotRate, combinedRefSatRotRate, 3);
+    // Then substract the combined required satellite rotational rates from the actual rate
+    VectorOperations<double>::subtract(currentSatRotRate, combinedRefSatRotRate, errorSatRotRate,
+                                       3);
+  } else {
+    // If orientation has not been aquired yet set satellite rotational rate to zero
+    errorSatRotRate = 0;
+  }
+
+  // target flag in matlab, importance, does look like it only gives feedback if pointing control is
+  // under 150 arcsec ??
+}
+
+void Guidance::comparePtg(double currentQuat[4], double currentSatRotRate[3], double targetQuat[4],
+                          double targetSatRotRate[3], double errorQuat[4],
+                          double errorSatRotRate[3], double errorAngle) {
+  // First calculate error quaternion between current and target orientation
+  QuaternionOperations::multiply(currentQuat, targetQuat, errorQuat);
+  // Keep scalar part of quaternion positive
+  if (errorQuat[3] < 0) {
+    VectorOperations<double>::mulScalar(errorQuat, -1, errorQuat, 4);
+  }
+  // Calculate error angle
+  errorAngle = QuaternionOperations::getAngle(errorQuat, true);
+
+  // Only give back error satellite rotational rate if orientation has already been aquired
+  if (errorAngle < 2. / 180. * M_PI) {
+    // Then substract the combined required satellite rotational rates from the actual rate
+    VectorOperations<double>::subtract(currentSatRotRate, targetSatRotRate, errorSatRotRate, 3);
+  } else {
+    // If orientation has not been aquired yet set satellite rotational rate to zero
+    errorSatRotRate = 0;
+  }
+
+  // target flag in matlab, importance, does look like it only gives feedback if pointing control is
+  // under 150 arcsec ??
+}
+
+void Guidance::targetRotationRate(int8_t timeElapsedMax, timeval now, double quatInertialTarget[4],
+                                  double *refSatRate) {
+  //-------------------------------------------------------------------------------------
+  //	Calculation of target rotation rate
+  //-------------------------------------------------------------------------------------
   double timeElapsed = now.tv_sec + now.tv_usec * pow(10, -6) -
                        (timeSavedQuaternion.tv_sec +
                         timeSavedQuaternion.tv_usec * pow((double)timeSavedQuaternion.tv_usec, -6));
@@ -221,395 +508,6 @@ void Guidance::refRotationRate(int8_t timeElapsedMax, timeval now, double quatIn
   savedQuaternion[3] = quatInertialTarget[3];
 }
 
-void Guidance::targetQuatPtgThreeAxes(ACS::SensorValues *sensorValues,
-                                      acsctrl::GpsDataProcessed *gpsDataProcessed,
-                                      acsctrl::MekfData *mekfData, timeval now,
-                                      double targetQuat[4], double refSatRate[3]) {
-  //-------------------------------------------------------------------------------------
-  //	Calculation of target quaternion for target pointing
-  //-------------------------------------------------------------------------------------
-  //	Transform longitude, latitude and altitude to cartesian coordiantes (earth
-  // fixed/centered frame)
-  double targetCart[3] = {0, 0, 0};
-
-  MathOperations<double>::cartesianFromLatLongAlt(
-      acsParameters.targetModeControllerParameters.latitudeTgt,
-      acsParameters.targetModeControllerParameters.longitudeTgt,
-      acsParameters.targetModeControllerParameters.altitudeTgt, targetCart);
-  //	Position of the satellite in the earth/fixed frame via GPS
-  double posSatE[3] = {0, 0, 0};
-  std::memcpy(posSatE, gpsDataProcessed->gpsPosition.value, 3 * sizeof(double));
-  double targetDirE[3] = {0, 0, 0};
-  VectorOperations<double>::subtract(targetCart, posSatE, targetDirE, 3);
-
-  //	Transformation between ECEF and IJK frame
-  double dcmEJ[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
-  double dcmJE[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
-  double dcmEJDot[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
-  MathOperations<double>::ecfToEciWithNutPre(now, *dcmEJ, *dcmEJDot);
-  MathOperations<double>::inverseMatrixDimThree(*dcmEJ, *dcmJE);
-
-  double dcmJEDot[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
-  MathOperations<double>::inverseMatrixDimThree(*dcmEJDot, *dcmJEDot);
-
-  //	Target Direction and position vector in the inertial frame
-  double targetDirJ[3] = {0, 0, 0}, posSatJ[3] = {0, 0, 0};
-  MatrixOperations<double>::multiply(*dcmJE, targetDirE, targetDirJ, 3, 3, 1);
-  MatrixOperations<double>::multiply(*dcmJE, posSatE, posSatJ, 3, 3, 1);
-
-  // negative x-Axis aligned with target (Camera/E-band transmitter position)
-  double xAxis[3] = {0, 0, 0};
-  VectorOperations<double>::normalize(targetDirJ, xAxis, 3);
-  VectorOperations<double>::mulScalar(xAxis, -1, xAxis, 3);
-
-  // Transform velocity into inertial frame
-  double velocityE[3];
-  std::memcpy(velocityE, gpsDataProcessed->gpsVelocity.value, 3 * sizeof(double));
-  double velocityJ[3] = {0, 0, 0}, velPart1[3] = {0, 0, 0}, velPart2[3] = {0, 0, 0};
-  MatrixOperations<double>::multiply(*dcmJE, velocityE, velPart1, 3, 3, 1);
-  MatrixOperations<double>::multiply(*dcmJEDot, posSatE, velPart2, 3, 3, 1);
-  VectorOperations<double>::add(velPart1, velPart2, velocityJ, 3);
-
-  // orbital normal vector
-  double orbitalNormalJ[3] = {0, 0, 0};
-  VectorOperations<double>::cross(posSatJ, velocityJ, orbitalNormalJ);
-  VectorOperations<double>::normalize(orbitalNormalJ, orbitalNormalJ, 3);
-
-  // y-Axis of satellite in orbit plane so that z-axis parallel to long side of picture resolution
-  double yAxis[3] = {0, 0, 0};
-  VectorOperations<double>::cross(orbitalNormalJ, xAxis, yAxis);
-  VectorOperations<double>::normalize(yAxis, yAxis, 3);
-
-  // z-Axis completes RHS
-  double zAxis[3] = {0, 0, 0};
-  VectorOperations<double>::cross(xAxis, yAxis, zAxis);
-
-  // Complete transformation matrix
-  double dcmTgt[3][3] = {{xAxis[0], yAxis[0], zAxis[0]},
-                         {xAxis[1], yAxis[1], zAxis[1]},
-                         {xAxis[2], yAxis[2], zAxis[2]}};
-  double quatInertialTarget[4] = {0, 0, 0, 0};
-  QuaternionOperations::fromDcm(dcmTgt, quatInertialTarget);
-
-  int8_t timeElapsedMax = acsParameters.targetModeControllerParameters.timeElapsedMax;
-  refRotationRate(timeElapsedMax, now, quatInertialTarget, refSatRate);
-
-  // Transform in system relative to satellite frame
-  double quatBJ[4] = {0, 0, 0, 0};
-  std::memcpy(quatBJ, mekfData->quatMekf.value, 4 * sizeof(double));
-  QuaternionOperations::multiply(quatBJ, quatInertialTarget, targetQuat);
-}
-
-void Guidance::targetQuatPtgGs(ACS::SensorValues *sensorValues, acsctrl::MekfData *mekfData,
-                               acsctrl::SusDataProcessed *susDataProcessed,
-                               acsctrl::GpsDataProcessed *gpsDataProcessed, timeval now,
-                               double targetQuat[4], double refSatRate[3]) {
-  //-------------------------------------------------------------------------------------
-  //	Calculation of target quaternion for ground station pointing
-  //-------------------------------------------------------------------------------------
-  //	Transform longitude, latitude and altitude to cartesian coordiantes (earth
-  // fixed/centered frame)
-  double groundStationCart[3] = {0, 0, 0};
-
-  MathOperations<double>::cartesianFromLatLongAlt(
-      acsParameters.targetModeControllerParameters.latitudeTgt,
-      acsParameters.targetModeControllerParameters.longitudeTgt,
-      acsParameters.targetModeControllerParameters.altitudeTgt, groundStationCart);
-  //	Position of the satellite in the earth/fixed frame via GPS
-  double posSatE[3] = {0, 0, 0};
-  double geodeticLatRad = (sensorValues->gpsSet.latitude.value) * PI / 180;
-  double longitudeRad = (sensorValues->gpsSet.longitude.value) * PI / 180;
-  MathOperations<double>::cartesianFromLatLongAlt(geodeticLatRad, longitudeRad,
-                                                  sensorValues->gpsSet.altitude.value, posSatE);
-  double targetDirE[3] = {0, 0, 0};
-  VectorOperations<double>::subtract(groundStationCart, posSatE, targetDirE, 3);
-
-  //	Transformation between ECEF and IJK frame
-  double dcmEJ[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
-  double dcmJE[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
-  double dcmEJDot[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
-  MathOperations<double>::ecfToEciWithNutPre(now, *dcmEJ, *dcmEJDot);
-  MathOperations<double>::inverseMatrixDimThree(*dcmEJ, *dcmJE);
-
-  double dcmJEDot[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
-  MathOperations<double>::inverseMatrixDimThree(*dcmEJDot, *dcmJEDot);
-
-  //	Target Direction and position vector in the inertial frame
-  double targetDirJ[3] = {0, 0, 0}, posSatJ[3] = {0, 0, 0};
-  MatrixOperations<double>::multiply(*dcmJE, targetDirE, targetDirJ, 3, 3, 1);
-  MatrixOperations<double>::multiply(*dcmJE, posSatE, posSatJ, 3, 3, 1);
-
-  // negative x-Axis aligned with target (Camera/E-band transmitter position)
-  double xAxis[3] = {0, 0, 0};
-  VectorOperations<double>::normalize(targetDirJ, xAxis, 3);
-  VectorOperations<double>::mulScalar(xAxis, -1, xAxis, 3);
-
-  // get Sun Vector Model in ECI
-  double sunJ[3];
-  std::memcpy(sunJ, susDataProcessed->sunIjkModel.value, 3 * sizeof(double));
-  VectorOperations<double>::normalize(sunJ, sunJ, 3);
-
-  // calculate z-axis as projection of sun vector into plane defined by x-axis as normal vector
-  // z = sPerpenticular =  s - sParallel = s - (x*s)/norm(x)^2 * x
-  double xDotS = VectorOperations<double>::dot(xAxis, sunJ);
-  xDotS /= pow(VectorOperations<double>::norm(xAxis, 3), 2);
-  double sunParallel[3], zAxis[3];
-  VectorOperations<double>::mulScalar(xAxis, xDotS, sunParallel, 3);
-  VectorOperations<double>::subtract(sunJ, sunParallel, zAxis, 3);
-  VectorOperations<double>::normalize(zAxis, zAxis, 3);
-
-  // calculate y-axis
-  double yAxis[3];
-  VectorOperations<double>::cross(zAxis, xAxis, yAxis);
-  VectorOperations<double>::normalize(yAxis, yAxis, 3);
-
-  // Complete transformation matrix
-  double dcmTgt[3][3] = {{xAxis[0], yAxis[0], zAxis[0]},
-                         {xAxis[1], yAxis[1], zAxis[1]},
-                         {xAxis[2], yAxis[2], zAxis[2]}};
-  double quatInertialTarget[4] = {0, 0, 0, 0};
-  QuaternionOperations::fromDcm(dcmTgt, quatInertialTarget);
-
-  int8_t timeElapsedMax = acsParameters.targetModeControllerParameters.timeElapsedMax;
-  refRotationRate(timeElapsedMax, now, quatInertialTarget, refSatRate);
-
-  // Transform in system relative to satellite frame
-  double quatBJ[4] = {0, 0, 0, 0};
-  std::memcpy(quatBJ, mekfData->quatMekf.value, 4 * sizeof(double));
-  QuaternionOperations::multiply(quatBJ, quatInertialTarget, targetQuat);
-}
-
-void Guidance::sunQuatPtg(ACS::SensorValues *sensorValues, acsctrl::MekfData *mekfData,
-                          acsctrl::SusDataProcessed *susDataProcessed,
-                          acsctrl::GpsDataProcessed *gpsDataProcessed, timeval now,
-                          double targetQuat[4], double refSatRate[3]) {
-  //-------------------------------------------------------------------------------------
-  //	Calculation of target quaternion to sun
-  //-------------------------------------------------------------------------------------
-  double quatBJ[4] = {0, 0, 0, 0};
-  double dcmBJ[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
-  std::memcpy(quatBJ, mekfData->quatMekf.value, 4 * sizeof(double));
-  QuaternionOperations::toDcm(quatBJ, dcmBJ);
-
-  double sunDirJ[3] = {0, 0, 0}, sunDirB[3] = {0, 0, 0};
-  if (susDataProcessed->sunIjkModel.isValid()) {
-    std::memcpy(sunDirJ, susDataProcessed->sunIjkModel.value, 3 * sizeof(double));
-    MatrixOperations<double>::multiply(*dcmBJ, sunDirJ, sunDirB, 3, 3, 1);
-  } else if (susDataProcessed->susVecTot.isValid()) {
-    std::memcpy(sunDirB, susDataProcessed->susVecTot.value, 3 * sizeof(double));
-  } else {
-    return;
-  }
-
-  //	Transformation between ECEF and IJK frame
-  double dcmEJ[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
-  double dcmJE[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
-  double dcmEJDot[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
-  MathOperations<double>::ecfToEciWithNutPre(now, *dcmEJ, *dcmEJDot);
-  MathOperations<double>::inverseMatrixDimThree(*dcmEJ, *dcmJE);
-  double dcmJEDot[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
-  MathOperations<double>::inverseMatrixDimThree(*dcmEJDot, *dcmJEDot);
-
-  // positive z-Axis of EIVE in direction of sun
-  double zAxis[3] = {0, 0, 0};
-  VectorOperations<double>::normalize(sunDirB, zAxis, 3);
-
-  // Assign helper vector (north pole inertial)
-  double helperVec[3] = {0, 0, 1};
-
-  //
-  double yAxis[3] = {0, 0, 0};
-  VectorOperations<double>::cross(zAxis, helperVec, yAxis);
-  VectorOperations<double>::normalize(yAxis, yAxis, 3);
-
-  //
-  double xAxis[3] = {0, 0, 0};
-  VectorOperations<double>::cross(yAxis, zAxis, xAxis);
-  VectorOperations<double>::normalize(xAxis, xAxis, 3);
-
-  // Transformation matrix to Sun, no further transforamtions, reference is already
-  // the EIVE body frame
-  double dcmTgt[3][3] = {{xAxis[0], yAxis[0], zAxis[0]},
-                         {xAxis[1], yAxis[1], zAxis[1]},
-                         {xAxis[2], yAxis[2], zAxis[2]}};
-  double quatSun[4] = {0, 0, 0, 0};
-  QuaternionOperations::fromDcm(dcmTgt, quatSun);
-
-  targetQuat[0] = quatSun[0];
-  targetQuat[1] = quatSun[1];
-  targetQuat[2] = quatSun[2];
-  targetQuat[3] = quatSun[3];
-
-  //----------------------------------------------------------------------------
-  //	Calculation of reference rotation rate
-  //----------------------------------------------------------------------------
-  refSatRate[0] = 0;
-  refSatRate[1] = 0;
-  refSatRate[2] = 0;
-}
-
-void Guidance::quatNadirPtgSingleAxis(ACS::SensorValues *sensorValues, acsctrl::MekfData *mekfData,
-                                      timeval now, double targetQuat[4],
-                                      double refSatRate[3]) {  // old version of Nadir Pointing
-  //-------------------------------------------------------------------------------------
-  //	Calculation of target quaternion for Nadir pointing
-  //-------------------------------------------------------------------------------------
-  //	Position of the satellite in the earth/fixed frame via GPS
-  double posSatE[3] = {0, 0, 0};
-  double geodeticLatRad = (sensorValues->gpsSet.latitude.value) * PI / 180;
-  double longitudeRad = (sensorValues->gpsSet.longitude.value) * PI / 180;
-  MathOperations<double>::cartesianFromLatLongAlt(geodeticLatRad, longitudeRad,
-                                                  sensorValues->gpsSet.altitude.value, posSatE);
-  double targetDirE[3] = {0, 0, 0};
-  VectorOperations<double>::mulScalar(posSatE, -1, targetDirE, 3);
-
-  //	Transformation between ECEF and IJK frame
-  double dcmEJ[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
-  double dcmJE[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
-  double dcmEJDot[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
-  MathOperations<double>::ecfToEciWithNutPre(now, *dcmEJ, *dcmEJDot);
-  MathOperations<double>::inverseMatrixDimThree(*dcmEJ, *dcmJE);
-
-  double dcmJEDot[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
-  MathOperations<double>::inverseMatrixDimThree(*dcmEJDot, *dcmJEDot);
-
-  //	Transformation between ECEF and Body frame
-  double dcmBJ[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
-  double dcmBE[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
-  double quatBJ[4] = {0, 0, 0, 0};
-  std::memcpy(quatBJ, mekfData->quatMekf.value, 4 * sizeof(double));
-  QuaternionOperations::toDcm(quatBJ, dcmBJ);
-  MatrixOperations<double>::multiply(*dcmBJ, *dcmJE, *dcmBE, 3, 3, 3);
-
-  //	Target Direction in the body frame
-  double targetDirB[3] = {0, 0, 0};
-  MatrixOperations<double>::multiply(*dcmBE, targetDirE, targetDirB, 3, 3, 1);
-
-  //	rotation quaternion from two vectors
-  double refDir[3] = {0, 0, 0};
-  refDir[0] = acsParameters.nadirModeControllerParameters.refDirection[0];
-  refDir[1] = acsParameters.nadirModeControllerParameters.refDirection[1];
-  refDir[2] = acsParameters.nadirModeControllerParameters.refDirection[2];
-  double noramlizedTargetDirB[3] = {0, 0, 0};
-  VectorOperations<double>::normalize(targetDirB, noramlizedTargetDirB, 3);
-  VectorOperations<double>::normalize(refDir, refDir, 3);
-  double normTargetDirB = VectorOperations<double>::norm(noramlizedTargetDirB, 3);
-  double normRefDir = VectorOperations<double>::norm(refDir, 3);
-  double crossDir[3] = {0, 0, 0};
-  double dotDirections = VectorOperations<double>::dot(noramlizedTargetDirB, refDir);
-  VectorOperations<double>::cross(noramlizedTargetDirB, refDir, crossDir);
-  targetQuat[0] = crossDir[0];
-  targetQuat[1] = crossDir[1];
-  targetQuat[2] = crossDir[2];
-  targetQuat[3] = sqrt(pow(normTargetDirB, 2) * pow(normRefDir, 2) + dotDirections);
-  VectorOperations<double>::normalize(targetQuat, targetQuat, 4);
-
-  //-------------------------------------------------------------------------------------
-  //	Calculation of reference rotation rate
-  //-------------------------------------------------------------------------------------
-  refSatRate[0] = 0;
-  refSatRate[1] = 0;
-  refSatRate[2] = 0;
-}
-
-void Guidance::quatNadirPtgThreeAxes(ACS::SensorValues *sensorValues,
-                                     acsctrl::GpsDataProcessed *gpsDataProcessed,
-                                     acsctrl::MekfData *mekfData, timeval now, double targetQuat[4],
-                                     double refSatRate[3]) {
-  //-------------------------------------------------------------------------------------
-  //	Calculation of target quaternion for Nadir pointing
-  //-------------------------------------------------------------------------------------
-  //	Position of the satellite in the earth/fixed frame via GPS
-  double posSatE[3] = {0, 0, 0};
-  double geodeticLatRad = (sensorValues->gpsSet.latitude.value) * PI / 180;
-  double longitudeRad = (sensorValues->gpsSet.longitude.value) * PI / 180;
-  MathOperations<double>::cartesianFromLatLongAlt(geodeticLatRad, longitudeRad,
-                                                  sensorValues->gpsSet.altitude.value, posSatE);
-  double targetDirE[3] = {0, 0, 0};
-  VectorOperations<double>::mulScalar(posSatE, -1, targetDirE, 3);
-
-  //	Transformation between ECEF and IJK frame
-  double dcmEJ[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
-  double dcmJE[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
-  double dcmEJDot[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
-  MathOperations<double>::ecfToEciWithNutPre(now, *dcmEJ, *dcmEJDot);
-  MathOperations<double>::inverseMatrixDimThree(*dcmEJ, *dcmJE);
-
-  double dcmJEDot[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
-  MathOperations<double>::inverseMatrixDimThree(*dcmEJDot, *dcmJEDot);
-
-  //	Target Direction in the body frame
-  double targetDirJ[3] = {0, 0, 0};
-  MatrixOperations<double>::multiply(*dcmJE, targetDirE, targetDirJ, 3, 3, 1);
-
-  // negative x-Axis aligned with target (Camera position)
-  double xAxis[3] = {0, 0, 0};
-  VectorOperations<double>::normalize(targetDirJ, xAxis, 3);
-  VectorOperations<double>::mulScalar(xAxis, -1, xAxis, 3);
-
-  // z-Axis parallel to long side of picture resolution
-  double zAxis[3] = {0, 0, 0}, velocityE[3];
-  std::memcpy(velocityE, gpsDataProcessed->gpsVelocity.value, 3 * sizeof(double));
-  double velocityJ[3] = {0, 0, 0}, velPart1[3] = {0, 0, 0}, velPart2[3] = {0, 0, 0};
-  MatrixOperations<double>::multiply(*dcmJE, velocityE, velPart1, 3, 3, 1);
-  MatrixOperations<double>::multiply(*dcmJEDot, posSatE, velPart2, 3, 3, 1);
-  VectorOperations<double>::add(velPart1, velPart2, velocityJ, 3);
-  VectorOperations<double>::cross(xAxis, velocityJ, zAxis);
-  VectorOperations<double>::normalize(zAxis, zAxis, 3);
-
-  // y-Axis completes RHS
-  double yAxis[3] = {0, 0, 0};
-  VectorOperations<double>::cross(zAxis, xAxis, yAxis);
-
-  // Complete transformation matrix
-  double dcmTgt[3][3] = {{xAxis[0], yAxis[0], zAxis[0]},
-                         {xAxis[1], yAxis[1], zAxis[1]},
-                         {xAxis[2], yAxis[2], zAxis[2]}};
-  double quatInertialTarget[4] = {0, 0, 0, 0};
-  QuaternionOperations::fromDcm(dcmTgt, quatInertialTarget);
-
-  int8_t timeElapsedMax = acsParameters.nadirModeControllerParameters.timeElapsedMax;
-  refRotationRate(timeElapsedMax, now, quatInertialTarget, refSatRate);
-
-  // Transform in system relative to satellite frame
-  double quatBJ[4] = {0, 0, 0, 0};
-  std::memcpy(quatBJ, mekfData->quatMekf.value, 4 * sizeof(double));
-  QuaternionOperations::multiply(quatBJ, quatInertialTarget, targetQuat);
-}
-
-void Guidance::inertialQuatPtg(double targetQuat[4], double refSatRate[3]) {
-  std::memcpy(targetQuat, acsParameters.inertialModeControllerParameters.tgtQuat,
-              4 * sizeof(double));
-  std::memcpy(refSatRate, acsParameters.inertialModeControllerParameters.refRotRate,
-              3 * sizeof(double));
-}
-
-void Guidance::comparePtg(double targetQuat[4], acsctrl::MekfData *mekfData, double quatRef[4],
-                          double refSatRate[3], double quatErrorComplete[4], double quatError[3],
-                          double deltaRate[3]) {
-  double satRate[3] = {0, 0, 0};
-  std::memcpy(satRate, mekfData->satRotRateMekf.value, 3 * sizeof(double));
-  VectorOperations<double>::subtract(satRate, refSatRate, deltaRate, 3);
-  // valid checks ?
-  double quatErrorMtx[4][4] = {{quatRef[3], quatRef[2], -quatRef[1], -quatRef[0]},
-                               {-quatRef[2], quatRef[3], quatRef[0], -quatRef[1]},
-                               {quatRef[1], -quatRef[0], quatRef[3], -quatRef[2]},
-                               {quatRef[0], -quatRef[1], quatRef[2], quatRef[3]}};
-
-  MatrixOperations<double>::multiply(*quatErrorMtx, targetQuat, quatErrorComplete, 4, 4, 1);
-
-  if (quatErrorComplete[3] < 0) {
-    quatErrorComplete[3] *= -1;
-  }
-
-  quatError[0] = quatErrorComplete[0];
-  quatError[1] = quatErrorComplete[1];
-  quatError[2] = quatErrorComplete[2];
-
-  // target flag in matlab, importance, does look like it only gives feedback if pointing control is
-  // under 150 arcsec ??
-}
-
 ReturnValue_t Guidance::getDistributionMatrixRw(ACS::SensorValues *sensorValues,
                                                 double *rwPseudoInv) {
   bool rw1valid = (sensorValues->rw1Set.state.value && sensorValues->rw1Set.state.isValid());
@@ -640,3 +538,32 @@ ReturnValue_t Guidance::getDistributionMatrixRw(ACS::SensorValues *sensorValues,
     return returnvalue::FAILED;
   }
 }
+
+void Guidance::getTargetParamsSafe(double sunTargetSafe[3], double satRateSafe[3]) {
+  if (not std::filesystem::exists(SD_0_SKEWED_PTG_FILE) or
+      not std::filesystem::exists(SD_1_SKEWED_PTG_FILE)) {  // ToDo: if file does not exist anymore
+    std::memcpy(sunTargetSafe, acsParameters.safeModeControllerParameters.sunTargetDir,
+                3 * sizeof(double));
+  } else {
+    std::memcpy(sunTargetSafe, acsParameters.safeModeControllerParameters.sunTargetDirLeop,
+                3 * sizeof(double));
+  }
+  std::memcpy(satRateSafe, acsParameters.safeModeControllerParameters.satRateRef,
+              3 * sizeof(double));
+}
+
+ReturnValue_t Guidance::solarArrayDeploymentComplete() {
+  if (std::filesystem::exists(SD_0_SKEWED_PTG_FILE)) {
+    std::remove(SD_0_SKEWED_PTG_FILE);
+    if (std::filesystem::exists(SD_0_SKEWED_PTG_FILE)) {
+      return returnvalue::FAILED;
+    }
+  }
+  if (std::filesystem::exists(SD_1_SKEWED_PTG_FILE)) {
+    std::remove(SD_1_SKEWED_PTG_FILE);
+    if (std::filesystem::exists(SD_1_SKEWED_PTG_FILE)) {
+      return returnvalue::FAILED;
+    }
+  }
+  return returnvalue::OK;
+}

mission/controller/acs/Guidance.h

@@ -1,10 +1,3 @@
-/*
- * Guidance.h
- *
- *  Created on: 6 Jun 2022
- *      Author: Robin Marquardt
- */
-
 #ifndef GUIDANCE_H_
 #define GUIDANCE_H_
 
@@ -20,52 +13,44 @@ class Guidance {
   virtual ~Guidance();
 
   void getTargetParamsSafe(double sunTargetSafe[3], double satRateRef[3]);
+  ReturnValue_t solarArrayDeploymentComplete();
 
   // Function to get the target quaternion and refence rotation rate from gps position and
   // position of the ground station
-  void targetQuatPtgThreeAxes(ACS::SensorValues *sensorValues,
-                              acsctrl::GpsDataProcessed *gpsDataProcessed,
-                              acsctrl::MekfData *mekfData, timeval now, double targetQuat[4],
-                              double refSatRate[3]);
-  void targetQuatPtgGs(ACS::SensorValues *sensorValues, acsctrl::MekfData *mekfData,
-                       acsctrl::SusDataProcessed *susDataProcessed,
-                       acsctrl::GpsDataProcessed *gpsDataProcessed, timeval now,
-                       double targetQuat[4], double refSatRate[3]);
-  void targetQuatPtgSingleAxis(ACS::SensorValues *sensorValues, acsctrl::MekfData *mekfData,
-                               acsctrl::SusDataProcessed *susDataProcessed,
-                               acsctrl::GpsDataProcessed *gpsDataProcessed, timeval now,
-                               double targetQuat[4], double refSatRate[3]);
+  void targetQuatPtgSingleAxis(timeval now, double posSatE[3], double velSatE[3], double sunDirI[3],
+                               double refDirB[3], double quatBI[4], double targetQuat[4],
+                               double targetSatRotRate[3]);
+  void targetQuatPtgThreeAxes(timeval now, double posSatE[3], double velSatE[3], double quatIX[4],
+                              double targetSatRotRate[3]);
+  void targetQuatPtgGs(timeval now, double posSatE[3], double sunDirI[3], double quatIX[4],
+                       double targetSatRotRate[3]);
 
   // Function to get the target quaternion and refence rotation rate for sun pointing after ground
   // station
-  void sunQuatPtg(ACS::SensorValues *sensorValues, acsctrl::MekfData *mekfData,
-                  acsctrl::SusDataProcessed *susDataProcessed,
-                  acsctrl::GpsDataProcessed *gpsDataProcessed, timeval now, double targetQuat[4],
-                  double refSatRate[3]);
+  void targetQuatPtgSun(double sunDirI[3], double targetQuat[4], double refSatRate[3]);
 
   // Function to get the target quaternion and refence rotation rate from gps position for Nadir
   // pointing
-  void quatNadirPtgThreeAxes(ACS::SensorValues *sensorValues,
-                             acsctrl::GpsDataProcessed *gpsDataProcessed,
-                             acsctrl::MekfData *mekfData, timeval now, double targetQuat[4],
-                             double refSatRate[3]);
-  void quatNadirPtgSingleAxis(ACS::SensorValues *sensorValues, acsctrl::MekfData *mekfData,
-                              timeval now, double targetQuat[4], double refSatRate[3]);
+  void targetQuatPtgNadirSingleAxis(timeval now, double posSatE[3], double quatBI[4],
+                                    double targetQuat[4], double refDirB[3], double refSatRate[3]);
+  void targetQuatPtgNadirThreeAxes(timeval now, double posSatE[3], double velSatE[3],
+                                   double targetQuat[4], double refSatRate[3]);
 
-  // Function to get the target quaternion and refence rotation rate from parameters for inertial
-  // pointing
-  void inertialQuatPtg(double targetQuat[4], double refSatRate[3]);
+  // @note: Calculates the error quaternion between the current orientation and the target
+  // quaternion, considering a reference quaternion. Additionally the difference between the  actual
+  // and a desired satellite rotational rate is calculated, again considering a reference rotational
+  // rate. Lastly gives back the error angle of the error quaternion.
+  void comparePtg(double currentQuat[4], double currentSatRotRate[3], double targetQuat[4],
+                  double targetSatRotRate[3], double refQuat[4], double refSatRotRate[3],
+                  double errorQuat[4], double errorSatRotRate[3], double errorAngle);
+  void comparePtg(double currentQuat[4], double currentSatRotRate[3], double targetQuat[4],
+                  double targetSatRotRate[3], double errorQuat[4], double errorSatRotRate[3],
+                  double errorAngle);
 
-  // @note: compares target Quaternion and reference quaternion, also actual satellite rate and
-  // desired
-  void comparePtg(double targetQuat[4], acsctrl::MekfData *mekfData, double quatRef[4],
-                  double refSatRate[3], double quatErrorComplete[4], double quatError[3],
-                  double deltaRate[3]);
+  void targetRotationRate(int8_t timeElapsedMax, timeval now, double quatInertialTarget[4],
+                          double *targetSatRotRate);
 
-  void refRotationRate(int8_t timeElapsedMax, timeval now, double quatInertialTarget[4],
-                       double *refSatRate);
-
-  //	@note: will give back the pseudoinverse matrix for the reaction wheel depending on the valid
+  // @note: will give back the pseudoinverse matrix for the reaction wheel depending on the valid
   // reation wheel 	maybe can be done in "commanding.h"
   ReturnValue_t getDistributionMatrixRw(ACS::SensorValues *sensorValues, double *rwPseudoInv);