bump fsfw

Reviewed-on: #374

CHANGELOG.md

@@ -17,6 +17,28 @@ change warranting a new major release:
 
 # [unreleased]
 
+# [v1.26.2] 2023-02-08
+
+## Changed
+
+- ACS Controller scheduling is now configurable via the `eive/definitions.h` file. Also ensured
+  that scheduling is done in big blocks to reduce risk of missed deadlines.
+- Replaced chained locks for polling new sensor data to the `AcsController`.
+- Made TM store even larger.
+
+## Fixed
+
+- Bugfix for PDEC handler which causes the PIR register of the PDEC to never
+  be cleared on release builds. The dummy variable used to read the register
+  needs to be declared volatile to avoid compiler optimizations.
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/374
+- Bumped FSFW for fix of possible memory leaks in TCP/IP TMTC bridge
+  inside the FSFW.
+
+## Added
+
+- Create TCS controller for EM build.
+
 # [v1.26.1] 2023-02-08
 
 - Initialize parameter helper in ACS controller.

CMakeLists.txt

@@ -11,7 +11,7 @@ cmake_minimum_required(VERSION 3.13)
 
 set(OBSW_VERSION_MAJOR 1)
 set(OBSW_VERSION_MINOR 26)
-set(OBSW_VERSION_REVISION 1)
+set(OBSW_VERSION_REVISION 2)
 
 # set(CMAKE_VERBOSE TRUE)
 

bsp_q7s/core/scheduling.cpp

@@ -313,7 +313,8 @@ void scheduling::initTasks() {
   std::vector<PeriodicTaskIF*> pusTasks;
   createPusTasks(*factory, missedDeadlineFunc, pusTasks);
   std::vector<PeriodicTaskIF*> pstTasks;
-  createPstTasks(*factory, missedDeadlineFunc, pstTasks);
+  AcsPstCfg cfg;
+  createPstTasks(*factory, missedDeadlineFunc, pstTasks, cfg);
 
 #if OBSW_ADD_TEST_CODE == 1
 #if OBSW_TEST_CCSDS_BRIDGE == 1
@@ -403,7 +404,7 @@ void scheduling::initTasks() {
 }
 
 void scheduling::createPstTasks(TaskFactory& factory, TaskDeadlineMissedFunction missedDeadlineFunc,
-                                std::vector<PeriodicTaskIF*>& taskVec) {
+                                std::vector<PeriodicTaskIF*>& taskVec, AcsPstCfg cfg) {
   ReturnValue_t result = returnvalue::OK;
 
 #ifdef RELEASE_BUILD
@@ -413,7 +414,7 @@ void scheduling::createPstTasks(TaskFactory& factory, TaskDeadlineMissedFunction
 #endif
   FixedTimeslotTaskIF* acsPst = factory.createFixedTimeslotTask(
       "ACS_PST", 85, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, acsPstPeriod, missedDeadlineFunc);
-  result = pst::pstAcs(acsPst);
+  result = pst::pstAcs(acsPst, cfg);
   if (result != returnvalue::OK) {
     if (result == FixedTimeslotTaskIF::SLOT_LIST_EMPTY) {
       sif::warning << "scheduling::initTasks: ACS PST is empty" << std::endl;

bsp_q7s/core/scheduling.h

@@ -1,10 +1,14 @@
 #ifndef BSP_Q7S_INITMISSION_H_
 #define BSP_Q7S_INITMISSION_H_
 
+#include <pollingsequence/pollingSequenceFactory.h>
+
 #include <vector>
 
 #include "fsfw/tasks/definitions.h"
 
+using pst::AcsPstCfg;
+
 class PeriodicTaskIF;
 class TaskFactory;
 
@@ -13,7 +17,7 @@ void initMission();
 void initTasks();
 
 void createPstTasks(TaskFactory& factory, TaskDeadlineMissedFunction missedDeadlineFunc,
-                    std::vector<PeriodicTaskIF*>& taskVec);
+                    std::vector<PeriodicTaskIF*>& taskVec, AcsPstCfg cfg);
 void createPusTasks(TaskFactory& factory, TaskDeadlineMissedFunction missedDeadlineFunc,
                     std::vector<PeriodicTaskIF*>& taskVec);
 void createTestTasks(TaskFactory& factory, TaskDeadlineMissedFunction missedDeadlineFunc,

bsp_q7s/em/emObjectFactory.cpp

@@ -43,6 +43,9 @@ void ObjectFactory::produce(void* args) {
 #if OBSW_ADD_GOMSPACE_PCDU == 1
   dummyCfg.addPowerDummies = false;
 #endif
+#if OBSW_ADD_ACS_BOARD == 1
+  dummyCfg.addAcsBoardDummies = false;
+#endif
 
   PowerSwitchIF* pwrSwitcher = nullptr;
 #if OBSW_ADD_GOMSPACE_PCDU == 0
@@ -109,5 +112,6 @@ void ObjectFactory::produce(void* args) {
                        pcdu::Switches::PDU1_CH5_SOLAR_CELL_EXP_5V);
 #endif
   createAcsController(true);
+  createThermalController();
   satsystem::com::init();
 }

common/config/eive/definitions.h

@@ -55,6 +55,19 @@ static constexpr uint32_t MAX_PUS_FUNNEL_QUEUE_DEPTH = 100;
 static constexpr uint32_t MAX_STORED_CMDS_UDP = 120;
 static constexpr uint32_t MAX_STORED_CMDS_TCP = 120;
 
+namespace acs {
+
+static constexpr uint32_t SCHED_BLOCK_1_SENSORS_MS = 15;
+static constexpr uint32_t SCHED_BLOCK_2_ACS_CTRL_MS = 40;
+static constexpr uint32_t SCHED_BLOCK_3_ACTUATOR_MS = 45;
+
+// 15 ms for FM
+static constexpr float SCHED_BLOCK_1_PERIOD = static_cast<float>(SCHED_BLOCK_1_SENSORS_MS) / 400.0;
+static constexpr float SCHED_BLOCK_2_PERIOD = static_cast<float>(SCHED_BLOCK_2_ACS_CTRL_MS) / 400.0;
+static constexpr float SCHED_BLOCK_3_PERIOD = static_cast<float>(SCHED_BLOCK_3_ACTUATOR_MS) / 400.0;
+
+}  // namespace acs
+
 }  // namespace config
 
 #endif /* COMMON_CONFIG_DEFINITIONS_H_ */

linux/fsfwconfig/pollingsequence/pollingSequenceFactory.cpp

@@ -5,6 +5,7 @@
 #include <fsfw/serviceinterface/ServiceInterfaceStream.h>
 #include <fsfw/tasks/FixedTimeslotTaskIF.h>
 
+#include "eive/definitions.h"
 #include "mission/devices/devicedefinitions/Max31865Definitions.h"
 
 #ifndef RPI_TEST_ADIS16507
@@ -183,94 +184,115 @@ ReturnValue_t pst::pstTest(FixedTimeslotTaskIF *thisSequence) {
   return returnvalue::OK;
 }
 
-ReturnValue_t pst::pstAcs(FixedTimeslotTaskIF *thisSequence) {
+ReturnValue_t pst::pstAcs(FixedTimeslotTaskIF *thisSequence, AcsPstCfg cfg) {
   /* Length of a communication cycle */
   uint32_t length = thisSequence->getPeriodMs();
-#if OBSW_ADD_ACS_BOARD == 1
   bool enableAside = true;
   bool enableBside = true;
+  if (cfg.scheduleAcsBoard) {
     if (enableAside) {
       // A side
-    thisSequence->addSlot(objects::MGM_0_LIS3_HANDLER, length * 0.0625,
+      thisSequence->addSlot(objects::MGM_0_LIS3_HANDLER, length * config::acs::SCHED_BLOCK_1_PERIOD,
                             DeviceHandlerIF::PERFORM_OPERATION);
-    thisSequence->addSlot(objects::MGM_0_LIS3_HANDLER, length * 0.0625,
+      thisSequence->addSlot(objects::MGM_0_LIS3_HANDLER, length * config::acs::SCHED_BLOCK_1_PERIOD,
                             DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::MGM_0_LIS3_HANDLER, length * 0.0625, DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::MGM_0_LIS3_HANDLER, length * 0.0625, DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::MGM_0_LIS3_HANDLER, length * 0.0625, DeviceHandlerIF::GET_READ);
-
-    thisSequence->addSlot(objects::MGM_1_RM3100_HANDLER, length * 0.0625,
-                          DeviceHandlerIF::PERFORM_OPERATION);
-    thisSequence->addSlot(objects::MGM_1_RM3100_HANDLER, length * 0.0625,
-                          DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::MGM_1_RM3100_HANDLER, length * 0.0625,
+      thisSequence->addSlot(objects::MGM_0_LIS3_HANDLER, length * config::acs::SCHED_BLOCK_1_PERIOD,
                             DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::MGM_1_RM3100_HANDLER, length * 0.0625,
+      thisSequence->addSlot(objects::MGM_0_LIS3_HANDLER, length * config::acs::SCHED_BLOCK_1_PERIOD,
                             DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::MGM_1_RM3100_HANDLER, length * 0.0625,
+      thisSequence->addSlot(objects::MGM_0_LIS3_HANDLER, length * config::acs::SCHED_BLOCK_1_PERIOD,
                             DeviceHandlerIF::GET_READ);
 
-    thisSequence->addSlot(objects::GYRO_0_ADIS_HANDLER, length * 0.0625,
+      thisSequence->addSlot(objects::MGM_1_RM3100_HANDLER,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD,
                             DeviceHandlerIF::PERFORM_OPERATION);
-    thisSequence->addSlot(objects::GYRO_0_ADIS_HANDLER, length * 0.0625,
+      thisSequence->addSlot(objects::MGM_1_RM3100_HANDLER,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD,
                             DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::GYRO_0_ADIS_HANDLER, length * 0.0625,
-                          DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::GYRO_0_ADIS_HANDLER, length * 0.0625,
-                          DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::GYRO_0_ADIS_HANDLER, length * 0.0625, DeviceHandlerIF::GET_READ);
+      thisSequence->addSlot(objects::MGM_1_RM3100_HANDLER,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::GET_WRITE);
+      thisSequence->addSlot(objects::MGM_1_RM3100_HANDLER,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::SEND_READ);
+      thisSequence->addSlot(objects::MGM_1_RM3100_HANDLER,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::GET_READ);
 
-    thisSequence->addSlot(objects::GYRO_1_L3G_HANDLER, length * 0.0625,
+      thisSequence->addSlot(objects::GYRO_0_ADIS_HANDLER,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD,
                             DeviceHandlerIF::PERFORM_OPERATION);
-    thisSequence->addSlot(objects::GYRO_1_L3G_HANDLER, length * 0.0625,
+      thisSequence->addSlot(objects::GYRO_0_ADIS_HANDLER,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD,
                             DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::GYRO_1_L3G_HANDLER, length * 0.0625, DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::GYRO_1_L3G_HANDLER, length * 0.0625, DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::GYRO_1_L3G_HANDLER, length * 0.0625, DeviceHandlerIF::GET_READ);
+      thisSequence->addSlot(objects::GYRO_0_ADIS_HANDLER,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::GET_WRITE);
+      thisSequence->addSlot(objects::GYRO_0_ADIS_HANDLER,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::SEND_READ);
+      thisSequence->addSlot(objects::GYRO_0_ADIS_HANDLER,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::GET_READ);
+
+      thisSequence->addSlot(objects::GYRO_1_L3G_HANDLER, length * config::acs::SCHED_BLOCK_1_PERIOD,
+                            DeviceHandlerIF::PERFORM_OPERATION);
+      thisSequence->addSlot(objects::GYRO_1_L3G_HANDLER, length * config::acs::SCHED_BLOCK_1_PERIOD,
+                            DeviceHandlerIF::SEND_WRITE);
+      thisSequence->addSlot(objects::GYRO_1_L3G_HANDLER, length * config::acs::SCHED_BLOCK_1_PERIOD,
+                            DeviceHandlerIF::GET_WRITE);
+      thisSequence->addSlot(objects::GYRO_1_L3G_HANDLER, length * config::acs::SCHED_BLOCK_1_PERIOD,
+                            DeviceHandlerIF::SEND_READ);
+      thisSequence->addSlot(objects::GYRO_1_L3G_HANDLER, length * config::acs::SCHED_BLOCK_1_PERIOD,
+                            DeviceHandlerIF::GET_READ);
     }
 
     if (enableBside) {
       // B side
-    thisSequence->addSlot(objects::MGM_2_LIS3_HANDLER, length * 0.0625,
+      thisSequence->addSlot(objects::MGM_2_LIS3_HANDLER, length * config::acs::SCHED_BLOCK_1_PERIOD,
                             DeviceHandlerIF::PERFORM_OPERATION);
-    thisSequence->addSlot(objects::MGM_2_LIS3_HANDLER, length * 0.0625,
+      thisSequence->addSlot(objects::MGM_2_LIS3_HANDLER, length * config::acs::SCHED_BLOCK_1_PERIOD,
                             DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::MGM_2_LIS3_HANDLER, length * 0.0625, DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::MGM_2_LIS3_HANDLER, length * 0.0625, DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::MGM_2_LIS3_HANDLER, length * 0.0625, DeviceHandlerIF::GET_READ);
-
-    thisSequence->addSlot(objects::MGM_3_RM3100_HANDLER, length * 0.0625,
-                          DeviceHandlerIF::PERFORM_OPERATION);
-    thisSequence->addSlot(objects::MGM_3_RM3100_HANDLER, length * 0.0625,
-                          DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::MGM_3_RM3100_HANDLER, length * 0.0625,
+      thisSequence->addSlot(objects::MGM_2_LIS3_HANDLER, length * config::acs::SCHED_BLOCK_1_PERIOD,
                             DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::MGM_3_RM3100_HANDLER, length * 0.0625,
+      thisSequence->addSlot(objects::MGM_2_LIS3_HANDLER, length * config::acs::SCHED_BLOCK_1_PERIOD,
                             DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::MGM_3_RM3100_HANDLER, length * 0.0625,
+      thisSequence->addSlot(objects::MGM_2_LIS3_HANDLER, length * config::acs::SCHED_BLOCK_1_PERIOD,
                             DeviceHandlerIF::GET_READ);
 
-    thisSequence->addSlot(objects::GYRO_2_ADIS_HANDLER, length * 0.0625,
+      thisSequence->addSlot(objects::MGM_3_RM3100_HANDLER,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD,
                             DeviceHandlerIF::PERFORM_OPERATION);
-    thisSequence->addSlot(objects::GYRO_2_ADIS_HANDLER, length * 0.0625,
+      thisSequence->addSlot(objects::MGM_3_RM3100_HANDLER,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD,
                             DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::GYRO_2_ADIS_HANDLER, length * 0.0625,
-                          DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::GYRO_2_ADIS_HANDLER, length * 0.0625,
-                          DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::GYRO_2_ADIS_HANDLER, length * 0.0625, DeviceHandlerIF::GET_READ);
+      thisSequence->addSlot(objects::MGM_3_RM3100_HANDLER,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::GET_WRITE);
+      thisSequence->addSlot(objects::MGM_3_RM3100_HANDLER,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::SEND_READ);
+      thisSequence->addSlot(objects::MGM_3_RM3100_HANDLER,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::GET_READ);
 
-    thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * 0.0625,
+      thisSequence->addSlot(objects::GYRO_2_ADIS_HANDLER,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD,
                             DeviceHandlerIF::PERFORM_OPERATION);
-    thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * 0.0625,
+      thisSequence->addSlot(objects::GYRO_2_ADIS_HANDLER,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD,
                             DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * 0.0625, DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * 0.0625, DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * 0.0625, DeviceHandlerIF::GET_READ);
+      thisSequence->addSlot(objects::GYRO_2_ADIS_HANDLER,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::GET_WRITE);
+      thisSequence->addSlot(objects::GYRO_2_ADIS_HANDLER,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::SEND_READ);
+      thisSequence->addSlot(objects::GYRO_2_ADIS_HANDLER,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::GET_READ);
+
+      thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * config::acs::SCHED_BLOCK_1_PERIOD,
+                            DeviceHandlerIF::PERFORM_OPERATION);
+      thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * config::acs::SCHED_BLOCK_1_PERIOD,
+                            DeviceHandlerIF::SEND_WRITE);
+      thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * config::acs::SCHED_BLOCK_1_PERIOD,
+                            DeviceHandlerIF::GET_WRITE);
+      thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * config::acs::SCHED_BLOCK_1_PERIOD,
+                            DeviceHandlerIF::SEND_READ);
+      thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * config::acs::SCHED_BLOCK_1_PERIOD,
+                            DeviceHandlerIF::GET_READ);
+    }
   }
-#endif /* OBSW_ADD_ACS_BOARD == 1 */
   // SUS: 16 ms
-#if OBSW_ADD_SUN_SENSORS == 1
 
   bool addSus0 = true;
   bool addSus1 = true;
@@ -285,6 +307,7 @@ ReturnValue_t pst::pstAcs(FixedTimeslotTaskIF *thisSequence) {
   bool addSus10 = true;
   bool addSus11 = true;
 
+  if (cfg.scheduleSus) {
     if (addSus0) {
       /* Write setup */
       thisSequence->addSlot(objects::SUS_0_N_LOC_XFYFZM_PT_XF, length * 0,
@@ -295,16 +318,18 @@ ReturnValue_t pst::pstAcs(FixedTimeslotTaskIF *thisSequence) {
                             DeviceHandlerIF::GET_WRITE);
       thisSequence->addSlot(objects::SUS_0_N_LOC_XFYFZM_PT_XF, length * 0,
                             DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::SUS_0_N_LOC_XFYFZM_PT_XF, length * 0, DeviceHandlerIF::GET_READ);
-
-    thisSequence->addSlot(objects::SUS_0_N_LOC_XFYFZM_PT_XF, length * 0.0325,
-                          DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::SUS_0_N_LOC_XFYFZM_PT_XF, length * 0.0325,
-                          DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::SUS_0_N_LOC_XFYFZM_PT_XF, length * 0.0325,
-                          DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::SUS_0_N_LOC_XFYFZM_PT_XF, length * 0.0325,
+      thisSequence->addSlot(objects::SUS_0_N_LOC_XFYFZM_PT_XF, length * 0,
                             DeviceHandlerIF::GET_READ);
+
+      thisSequence->addSlot(objects::SUS_0_N_LOC_XFYFZM_PT_XF,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD,
+                            DeviceHandlerIF::SEND_WRITE);
+      thisSequence->addSlot(objects::SUS_0_N_LOC_XFYFZM_PT_XF,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::GET_WRITE);
+      thisSequence->addSlot(objects::SUS_0_N_LOC_XFYFZM_PT_XF,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::SEND_READ);
+      thisSequence->addSlot(objects::SUS_0_N_LOC_XFYFZM_PT_XF,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::GET_READ);
     }
     if (addSus1) {
       thisSequence->addSlot(objects::SUS_1_N_LOC_XBYFZM_PT_XB, length * 0,
@@ -315,16 +340,18 @@ ReturnValue_t pst::pstAcs(FixedTimeslotTaskIF *thisSequence) {
                             DeviceHandlerIF::GET_WRITE);
       thisSequence->addSlot(objects::SUS_1_N_LOC_XBYFZM_PT_XB, length * 0,
                             DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::SUS_1_N_LOC_XBYFZM_PT_XB, length * 0, DeviceHandlerIF::GET_READ);
-
-    thisSequence->addSlot(objects::SUS_1_N_LOC_XBYFZM_PT_XB, length * 0.0325,
-                          DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::SUS_1_N_LOC_XBYFZM_PT_XB, length * 0.0325,
-                          DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::SUS_1_N_LOC_XBYFZM_PT_XB, length * 0.0325,
-                          DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::SUS_1_N_LOC_XBYFZM_PT_XB, length * 0.0325,
+      thisSequence->addSlot(objects::SUS_1_N_LOC_XBYFZM_PT_XB, length * 0,
                             DeviceHandlerIF::GET_READ);
+
+      thisSequence->addSlot(objects::SUS_1_N_LOC_XBYFZM_PT_XB,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD,
+                            DeviceHandlerIF::SEND_WRITE);
+      thisSequence->addSlot(objects::SUS_1_N_LOC_XBYFZM_PT_XB,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::GET_WRITE);
+      thisSequence->addSlot(objects::SUS_1_N_LOC_XBYFZM_PT_XB,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::SEND_READ);
+      thisSequence->addSlot(objects::SUS_1_N_LOC_XBYFZM_PT_XB,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::GET_READ);
     }
     if (addSus2) {
       thisSequence->addSlot(objects::SUS_2_N_LOC_XFYBZB_PT_YB, length * 0,
@@ -335,16 +362,18 @@ ReturnValue_t pst::pstAcs(FixedTimeslotTaskIF *thisSequence) {
                             DeviceHandlerIF::GET_WRITE);
       thisSequence->addSlot(objects::SUS_2_N_LOC_XFYBZB_PT_YB, length * 0,
                             DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::SUS_2_N_LOC_XFYBZB_PT_YB, length * 0, DeviceHandlerIF::GET_READ);
-
-    thisSequence->addSlot(objects::SUS_2_N_LOC_XFYBZB_PT_YB, length * 0.0325,
-                          DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::SUS_2_N_LOC_XFYBZB_PT_YB, length * 0.0325,
-                          DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::SUS_2_N_LOC_XFYBZB_PT_YB, length * 0.0325,
-                          DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::SUS_2_N_LOC_XFYBZB_PT_YB, length * 0.0325,
+      thisSequence->addSlot(objects::SUS_2_N_LOC_XFYBZB_PT_YB, length * 0,
                             DeviceHandlerIF::GET_READ);
+
+      thisSequence->addSlot(objects::SUS_2_N_LOC_XFYBZB_PT_YB,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD,
+                            DeviceHandlerIF::SEND_WRITE);
+      thisSequence->addSlot(objects::SUS_2_N_LOC_XFYBZB_PT_YB,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::GET_WRITE);
+      thisSequence->addSlot(objects::SUS_2_N_LOC_XFYBZB_PT_YB,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::SEND_READ);
+      thisSequence->addSlot(objects::SUS_2_N_LOC_XFYBZB_PT_YB,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::GET_READ);
     }
     if (addSus3) {
       thisSequence->addSlot(objects::SUS_3_N_LOC_XFYBZF_PT_YF, length * 0,
@@ -355,16 +384,18 @@ ReturnValue_t pst::pstAcs(FixedTimeslotTaskIF *thisSequence) {
                             DeviceHandlerIF::GET_WRITE);
       thisSequence->addSlot(objects::SUS_3_N_LOC_XFYBZF_PT_YF, length * 0,
                             DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::SUS_3_N_LOC_XFYBZF_PT_YF, length * 0, DeviceHandlerIF::GET_READ);
-
-    thisSequence->addSlot(objects::SUS_3_N_LOC_XFYBZF_PT_YF, length * 0.0325,
-                          DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::SUS_3_N_LOC_XFYBZF_PT_YF, length * 0.0325,
-                          DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::SUS_3_N_LOC_XFYBZF_PT_YF, length * 0.0325,
-                          DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::SUS_3_N_LOC_XFYBZF_PT_YF, length * 0.0325,
+      thisSequence->addSlot(objects::SUS_3_N_LOC_XFYBZF_PT_YF, length * 0,
                             DeviceHandlerIF::GET_READ);
+
+      thisSequence->addSlot(objects::SUS_3_N_LOC_XFYBZF_PT_YF,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD,
+                            DeviceHandlerIF::SEND_WRITE);
+      thisSequence->addSlot(objects::SUS_3_N_LOC_XFYBZF_PT_YF,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::GET_WRITE);
+      thisSequence->addSlot(objects::SUS_3_N_LOC_XFYBZF_PT_YF,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::SEND_READ);
+      thisSequence->addSlot(objects::SUS_3_N_LOC_XFYBZF_PT_YF,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::GET_READ);
     }
     if (addSus4) {
       thisSequence->addSlot(objects::SUS_4_N_LOC_XMYFZF_PT_ZF, length * 0,
@@ -375,16 +406,18 @@ ReturnValue_t pst::pstAcs(FixedTimeslotTaskIF *thisSequence) {
                             DeviceHandlerIF::GET_WRITE);
       thisSequence->addSlot(objects::SUS_4_N_LOC_XMYFZF_PT_ZF, length * 0,
                             DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::SUS_4_N_LOC_XMYFZF_PT_ZF, length * 0, DeviceHandlerIF::GET_READ);
-
-    thisSequence->addSlot(objects::SUS_4_N_LOC_XMYFZF_PT_ZF, length * 0.0325,
-                          DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::SUS_4_N_LOC_XMYFZF_PT_ZF, length * 0.0325,
-                          DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::SUS_4_N_LOC_XMYFZF_PT_ZF, length * 0.0325,
-                          DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::SUS_4_N_LOC_XMYFZF_PT_ZF, length * 0.0325,
+      thisSequence->addSlot(objects::SUS_4_N_LOC_XMYFZF_PT_ZF, length * 0,
                             DeviceHandlerIF::GET_READ);
+
+      thisSequence->addSlot(objects::SUS_4_N_LOC_XMYFZF_PT_ZF,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD,
+                            DeviceHandlerIF::SEND_WRITE);
+      thisSequence->addSlot(objects::SUS_4_N_LOC_XMYFZF_PT_ZF,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::GET_WRITE);
+      thisSequence->addSlot(objects::SUS_4_N_LOC_XMYFZF_PT_ZF,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::SEND_READ);
+      thisSequence->addSlot(objects::SUS_4_N_LOC_XMYFZF_PT_ZF,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::GET_READ);
     }
     if (addSus5) {
       thisSequence->addSlot(objects::SUS_5_N_LOC_XFYMZB_PT_ZB, length * 0,
@@ -395,16 +428,18 @@ ReturnValue_t pst::pstAcs(FixedTimeslotTaskIF *thisSequence) {
                             DeviceHandlerIF::GET_WRITE);
       thisSequence->addSlot(objects::SUS_5_N_LOC_XFYMZB_PT_ZB, length * 0,
                             DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::SUS_5_N_LOC_XFYMZB_PT_ZB, length * 0, DeviceHandlerIF::GET_READ);
-
-    thisSequence->addSlot(objects::SUS_5_N_LOC_XFYMZB_PT_ZB, length * 0.0325,
-                          DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::SUS_5_N_LOC_XFYMZB_PT_ZB, length * 0.0325,
-                          DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::SUS_5_N_LOC_XFYMZB_PT_ZB, length * 0.0325,
-                          DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::SUS_5_N_LOC_XFYMZB_PT_ZB, length * 0.0325,
+      thisSequence->addSlot(objects::SUS_5_N_LOC_XFYMZB_PT_ZB, length * 0,
                             DeviceHandlerIF::GET_READ);
+
+      thisSequence->addSlot(objects::SUS_5_N_LOC_XFYMZB_PT_ZB,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD,
+                            DeviceHandlerIF::SEND_WRITE);
+      thisSequence->addSlot(objects::SUS_5_N_LOC_XFYMZB_PT_ZB,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::GET_WRITE);
+      thisSequence->addSlot(objects::SUS_5_N_LOC_XFYMZB_PT_ZB,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::SEND_READ);
+      thisSequence->addSlot(objects::SUS_5_N_LOC_XFYMZB_PT_ZB,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::GET_READ);
     }
 
     if (addSus6) {
@@ -416,16 +451,18 @@ ReturnValue_t pst::pstAcs(FixedTimeslotTaskIF *thisSequence) {
                             DeviceHandlerIF::GET_WRITE);
       thisSequence->addSlot(objects::SUS_6_R_LOC_XFYBZM_PT_XF, length * 0,
                             DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::SUS_6_R_LOC_XFYBZM_PT_XF, length * 0, DeviceHandlerIF::GET_READ);
-
-    thisSequence->addSlot(objects::SUS_6_R_LOC_XFYBZM_PT_XF, length * 0.0325,
-                          DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::SUS_6_R_LOC_XFYBZM_PT_XF, length * 0.0325,
-                          DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::SUS_6_R_LOC_XFYBZM_PT_XF, length * 0.0325,
-                          DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::SUS_6_R_LOC_XFYBZM_PT_XF, length * 0.0325,
+      thisSequence->addSlot(objects::SUS_6_R_LOC_XFYBZM_PT_XF, length * 0,
                             DeviceHandlerIF::GET_READ);
+
+      thisSequence->addSlot(objects::SUS_6_R_LOC_XFYBZM_PT_XF,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD,
+                            DeviceHandlerIF::SEND_WRITE);
+      thisSequence->addSlot(objects::SUS_6_R_LOC_XFYBZM_PT_XF,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::GET_WRITE);
+      thisSequence->addSlot(objects::SUS_6_R_LOC_XFYBZM_PT_XF,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::SEND_READ);
+      thisSequence->addSlot(objects::SUS_6_R_LOC_XFYBZM_PT_XF,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::GET_READ);
     }
 
     if (addSus7) {
@@ -437,16 +474,18 @@ ReturnValue_t pst::pstAcs(FixedTimeslotTaskIF *thisSequence) {
                             DeviceHandlerIF::GET_WRITE);
       thisSequence->addSlot(objects::SUS_7_R_LOC_XBYBZM_PT_XB, length * 0,
                             DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::SUS_7_R_LOC_XBYBZM_PT_XB, length * 0, DeviceHandlerIF::GET_READ);
-
-    thisSequence->addSlot(objects::SUS_7_R_LOC_XBYBZM_PT_XB, length * 0.0325,
-                          DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::SUS_7_R_LOC_XBYBZM_PT_XB, length * 0.0325,
-                          DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::SUS_7_R_LOC_XBYBZM_PT_XB, length * 0.0325,
-                          DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::SUS_7_R_LOC_XBYBZM_PT_XB, length * 0.0325,
+      thisSequence->addSlot(objects::SUS_7_R_LOC_XBYBZM_PT_XB, length * 0,
                             DeviceHandlerIF::GET_READ);
+
+      thisSequence->addSlot(objects::SUS_7_R_LOC_XBYBZM_PT_XB,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD,
+                            DeviceHandlerIF::SEND_WRITE);
+      thisSequence->addSlot(objects::SUS_7_R_LOC_XBYBZM_PT_XB,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::GET_WRITE);
+      thisSequence->addSlot(objects::SUS_7_R_LOC_XBYBZM_PT_XB,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::SEND_READ);
+      thisSequence->addSlot(objects::SUS_7_R_LOC_XBYBZM_PT_XB,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::GET_READ);
     }
 
     if (addSus8) {
@@ -458,16 +497,18 @@ ReturnValue_t pst::pstAcs(FixedTimeslotTaskIF *thisSequence) {
                             DeviceHandlerIF::GET_WRITE);
       thisSequence->addSlot(objects::SUS_8_R_LOC_XBYBZB_PT_YB, length * 0,
                             DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::SUS_8_R_LOC_XBYBZB_PT_YB, length * 0, DeviceHandlerIF::GET_READ);
-
-    thisSequence->addSlot(objects::SUS_8_R_LOC_XBYBZB_PT_YB, length * 0.0325,
-                          DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::SUS_8_R_LOC_XBYBZB_PT_YB, length * 0.0325,
-                          DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::SUS_8_R_LOC_XBYBZB_PT_YB, length * 0.0325,
-                          DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::SUS_8_R_LOC_XBYBZB_PT_YB, length * 0.0325,
+      thisSequence->addSlot(objects::SUS_8_R_LOC_XBYBZB_PT_YB, length * 0,
                             DeviceHandlerIF::GET_READ);
+
+      thisSequence->addSlot(objects::SUS_8_R_LOC_XBYBZB_PT_YB,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD,
+                            DeviceHandlerIF::SEND_WRITE);
+      thisSequence->addSlot(objects::SUS_8_R_LOC_XBYBZB_PT_YB,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::GET_WRITE);
+      thisSequence->addSlot(objects::SUS_8_R_LOC_XBYBZB_PT_YB,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::SEND_READ);
+      thisSequence->addSlot(objects::SUS_8_R_LOC_XBYBZB_PT_YB,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::GET_READ);
     }
 
     if (addSus9) {
@@ -479,15 +520,17 @@ ReturnValue_t pst::pstAcs(FixedTimeslotTaskIF *thisSequence) {
                             DeviceHandlerIF::GET_WRITE);
       thisSequence->addSlot(objects::SUS_9_R_LOC_XBYBZB_PT_YF, length * 0,
                             DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::SUS_9_R_LOC_XBYBZB_PT_YF, length * 0, DeviceHandlerIF::GET_READ);
-    thisSequence->addSlot(objects::SUS_9_R_LOC_XBYBZB_PT_YF, length * 0.0325,
-                          DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::SUS_9_R_LOC_XBYBZB_PT_YF, length * 0.0325,
-                          DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::SUS_9_R_LOC_XBYBZB_PT_YF, length * 0.0325,
-                          DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::SUS_9_R_LOC_XBYBZB_PT_YF, length * 0.0325,
+      thisSequence->addSlot(objects::SUS_9_R_LOC_XBYBZB_PT_YF, length * 0,
                             DeviceHandlerIF::GET_READ);
+      thisSequence->addSlot(objects::SUS_9_R_LOC_XBYBZB_PT_YF,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD,
+                            DeviceHandlerIF::SEND_WRITE);
+      thisSequence->addSlot(objects::SUS_9_R_LOC_XBYBZB_PT_YF,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::GET_WRITE);
+      thisSequence->addSlot(objects::SUS_9_R_LOC_XBYBZB_PT_YF,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::SEND_READ);
+      thisSequence->addSlot(objects::SUS_9_R_LOC_XBYBZB_PT_YF,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::GET_READ);
     }
 
     if (addSus10) {
@@ -502,14 +545,15 @@ ReturnValue_t pst::pstAcs(FixedTimeslotTaskIF *thisSequence) {
       thisSequence->addSlot(objects::SUS_10_N_LOC_XMYBZF_PT_ZF, length * 0,
                             DeviceHandlerIF::GET_READ);
 
-    thisSequence->addSlot(objects::SUS_10_N_LOC_XMYBZF_PT_ZF, length * 0.0325,
+      thisSequence->addSlot(objects::SUS_10_N_LOC_XMYBZF_PT_ZF,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD,
                             DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::SUS_10_N_LOC_XMYBZF_PT_ZF, length * 0.0325,
-                          DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::SUS_10_N_LOC_XMYBZF_PT_ZF, length * 0.0325,
-                          DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::SUS_10_N_LOC_XMYBZF_PT_ZF, length * 0.0325,
-                          DeviceHandlerIF::GET_READ);
+      thisSequence->addSlot(objects::SUS_10_N_LOC_XMYBZF_PT_ZF,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::GET_WRITE);
+      thisSequence->addSlot(objects::SUS_10_N_LOC_XMYBZF_PT_ZF,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::SEND_READ);
+      thisSequence->addSlot(objects::SUS_10_N_LOC_XMYBZF_PT_ZF,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::GET_READ);
     }
 
     if (addSus11) {
@@ -524,80 +568,121 @@ ReturnValue_t pst::pstAcs(FixedTimeslotTaskIF *thisSequence) {
       thisSequence->addSlot(objects::SUS_11_R_LOC_XBYMZB_PT_ZB, length * 0,
                             DeviceHandlerIF::GET_READ);
 
-    thisSequence->addSlot(objects::SUS_11_R_LOC_XBYMZB_PT_ZB, length * 0.0325,
+      thisSequence->addSlot(objects::SUS_11_R_LOC_XBYMZB_PT_ZB,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD,
                             DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::SUS_11_R_LOC_XBYMZB_PT_ZB, length * 0.0325,
-                          DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::SUS_11_R_LOC_XBYMZB_PT_ZB, length * 0.0325,
-                          DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::SUS_11_R_LOC_XBYMZB_PT_ZB, length * 0.0325,
-                          DeviceHandlerIF::GET_READ);
+      thisSequence->addSlot(objects::SUS_11_R_LOC_XBYMZB_PT_ZB,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::GET_WRITE);
+      thisSequence->addSlot(objects::SUS_11_R_LOC_XBYMZB_PT_ZB,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::SEND_READ);
+      thisSequence->addSlot(objects::SUS_11_R_LOC_XBYMZB_PT_ZB,
+                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::GET_READ);
+    }
   }
-#endif /* OBSW_ADD_SUN_SENSORS == 1 */
 
-#if OBSW_ADD_STAR_TRACKER == 1
+  if (cfg.scheduleStr) {
     thisSequence->addSlot(objects::STAR_TRACKER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
     thisSequence->addSlot(objects::STAR_TRACKER, length * 0, DeviceHandlerIF::SEND_WRITE);
     thisSequence->addSlot(objects::STAR_TRACKER, length * 0, DeviceHandlerIF::GET_WRITE);
     thisSequence->addSlot(objects::STAR_TRACKER, length * 0, DeviceHandlerIF::SEND_READ);
     thisSequence->addSlot(objects::STAR_TRACKER, length * 0, DeviceHandlerIF::GET_READ);
-#endif
+  }
 
-#if OBSW_ADD_MGT == 1
+  if (cfg.scheduleImtq) {
     // This is the MTM measurement cycle
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.0625, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.0625, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.0625, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.0625, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.0625, DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.0625, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.0625, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.0625, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.0625, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.0625, DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.0625, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.0625, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.0625, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.0625, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.0625, DeviceHandlerIF::GET_READ);
-#endif
+    thisSequence->addSlot(objects::IMTQ_HANDLER, length * config::acs::SCHED_BLOCK_1_PERIOD,
+                          DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::IMTQ_HANDLER, length * config::acs::SCHED_BLOCK_1_PERIOD,
+                          DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::IMTQ_HANDLER, length * config::acs::SCHED_BLOCK_1_PERIOD,
+                          DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::IMTQ_HANDLER, length * config::acs::SCHED_BLOCK_1_PERIOD,
+                          DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::IMTQ_HANDLER, length * config::acs::SCHED_BLOCK_1_PERIOD,
+                          DeviceHandlerIF::GET_READ);
+    thisSequence->addSlot(objects::IMTQ_HANDLER, length * config::acs::SCHED_BLOCK_1_PERIOD,
+                          DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::IMTQ_HANDLER, length * config::acs::SCHED_BLOCK_1_PERIOD,
+                          DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::IMTQ_HANDLER, length * config::acs::SCHED_BLOCK_1_PERIOD,
+                          DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::IMTQ_HANDLER, length * config::acs::SCHED_BLOCK_1_PERIOD,
+                          DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::IMTQ_HANDLER, length * config::acs::SCHED_BLOCK_1_PERIOD,
+                          DeviceHandlerIF::GET_READ);
+    thisSequence->addSlot(objects::IMTQ_HANDLER, length * config::acs::SCHED_BLOCK_1_PERIOD,
+                          DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::IMTQ_HANDLER, length * config::acs::SCHED_BLOCK_1_PERIOD,
+                          DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::IMTQ_HANDLER, length * config::acs::SCHED_BLOCK_1_PERIOD,
+                          DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::IMTQ_HANDLER, length * config::acs::SCHED_BLOCK_1_PERIOD,
+                          DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::IMTQ_HANDLER, length * config::acs::SCHED_BLOCK_1_PERIOD,
+                          DeviceHandlerIF::GET_READ);
+  }
 
-  thisSequence->addSlot(objects::ACS_CONTROLLER, length * 0.1, 0);
+  thisSequence->addSlot(objects::ACS_CONTROLLER, length * config::acs::SCHED_BLOCK_2_PERIOD, 0);
 
-#if OBSW_ADD_MGT == 1
+  if (cfg.scheduleImtq) {
     // This is the torquing cycle.
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.1125, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.1125, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.1125, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.1125, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.1125, DeviceHandlerIF::GET_READ);
-#endif
+    thisSequence->addSlot(objects::IMTQ_HANDLER, length * config::acs::SCHED_BLOCK_2_PERIOD,
+                          DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::IMTQ_HANDLER, length * config::acs::SCHED_BLOCK_2_PERIOD,
+                          DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::IMTQ_HANDLER, length * config::acs::SCHED_BLOCK_2_PERIOD,
+                          DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::IMTQ_HANDLER, length * config::acs::SCHED_BLOCK_2_PERIOD,
+                          DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::IMTQ_HANDLER, length * config::acs::SCHED_BLOCK_2_PERIOD,
+                          DeviceHandlerIF::GET_READ);
+  }
 
-#if OBSW_ADD_RW == 1
-  thisSequence->addSlot(objects::RW1, length * 0.1125, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::RW2, length * 0.1125, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::RW3, length * 0.1125, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::RW4, length * 0.1125, DeviceHandlerIF::PERFORM_OPERATION);
+  if (cfg.scheduleRws) {
+    thisSequence->addSlot(objects::RW1, length * config::acs::SCHED_BLOCK_2_PERIOD,
+                          DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::RW2, length * config::acs::SCHED_BLOCK_2_PERIOD,
+                          DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::RW3, length * config::acs::SCHED_BLOCK_2_PERIOD,
+                          DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::RW4, length * config::acs::SCHED_BLOCK_2_PERIOD,
+                          DeviceHandlerIF::PERFORM_OPERATION);
 
-  thisSequence->addSlot(objects::RW1, length * 0.1125, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::RW2, length * 0.1125, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::RW3, length * 0.1125, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::RW4, length * 0.1125, DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::RW1, length * config::acs::SCHED_BLOCK_2_PERIOD,
+                          DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::RW2, length * config::acs::SCHED_BLOCK_2_PERIOD,
+                          DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::RW3, length * config::acs::SCHED_BLOCK_2_PERIOD,
+                          DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::RW4, length * config::acs::SCHED_BLOCK_2_PERIOD,
+                          DeviceHandlerIF::SEND_WRITE);
 
-  thisSequence->addSlot(objects::RW1, length * 0.1125, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::RW2, length * 0.1125, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::RW3, length * 0.1125, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::RW4, length * 0.1125, DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::RW1, length * config::acs::SCHED_BLOCK_2_PERIOD,
+                          DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::RW2, length * config::acs::SCHED_BLOCK_2_PERIOD,
+                          DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::RW3, length * config::acs::SCHED_BLOCK_2_PERIOD,
+                          DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::RW4, length * config::acs::SCHED_BLOCK_2_PERIOD,
+                          DeviceHandlerIF::GET_WRITE);
 
-  thisSequence->addSlot(objects::RW1, length * 0.1125, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::RW2, length * 0.1125, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::RW3, length * 0.1125, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::RW4, length * 0.1125, DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::RW1, length * config::acs::SCHED_BLOCK_2_PERIOD,
+                          DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::RW2, length * config::acs::SCHED_BLOCK_2_PERIOD,
+                          DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::RW3, length * config::acs::SCHED_BLOCK_2_PERIOD,
+                          DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::RW4, length * config::acs::SCHED_BLOCK_2_PERIOD,
+                          DeviceHandlerIF::SEND_READ);
 
-  thisSequence->addSlot(objects::RW1, length * 0.1125, DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::RW2, length * 0.1125, DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::RW3, length * 0.1125, DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::RW4, length * 0.1125, DeviceHandlerIF::GET_READ);
-#endif
+    thisSequence->addSlot(objects::RW1, length * config::acs::SCHED_BLOCK_2_PERIOD,
+                          DeviceHandlerIF::GET_READ);
+    thisSequence->addSlot(objects::RW2, length * config::acs::SCHED_BLOCK_2_PERIOD,
+                          DeviceHandlerIF::GET_READ);
+    thisSequence->addSlot(objects::RW3, length * config::acs::SCHED_BLOCK_2_PERIOD,
+                          DeviceHandlerIF::GET_READ);
+    thisSequence->addSlot(objects::RW4, length * config::acs::SCHED_BLOCK_2_PERIOD,
+                          DeviceHandlerIF::GET_READ);
+  }
   return returnvalue::OK;
 }

linux/fsfwconfig/pollingsequence/pollingSequenceFactory.h

@@ -31,6 +31,14 @@ class FixedTimeslotTaskIF;
  */
 namespace pst {
 
+struct AcsPstCfg {
+  bool scheduleAcsBoard = true;
+  bool scheduleImtq = true;
+  bool scheduleRws = true;
+  bool scheduleSus = true;
+  bool scheduleStr = true;
+};
+
 /**
  * @brief	This function creates the PST for all gomspace devices.
  * @details
@@ -41,7 +49,7 @@ ReturnValue_t pstGompaceCan(FixedTimeslotTaskIF* thisSequence);
 
 ReturnValue_t pstSpiAndSyrlinks(FixedTimeslotTaskIF* thisSequence);
 
-ReturnValue_t pstAcs(FixedTimeslotTaskIF* thisSequence);
+ReturnValue_t pstAcs(FixedTimeslotTaskIF* thisSequence, AcsPstCfg cfg);
 
 ReturnValue_t pstI2c(FixedTimeslotTaskIF* thisSequence);
 

linux/ipcore/PdecHandler.cpp

@@ -132,6 +132,7 @@ ReturnValue_t PdecHandler::polledOperation() {
   return returnvalue::OK;
 }
 
+// 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);
@@ -141,15 +142,17 @@ ReturnValue_t PdecHandler::irqOperation() {
     return returnvalue::FAILED;
   }
 
-  struct pollfd fds = {.fd = fd, .events = POLLIN, .revents = 0};
   // Used to unmask IRQ
   uint32_t info = 1;
   ssize_t nb = 0;
   int ret = 0;
-  // Clear interrupts with dummy read before unmasking the interrupt
-  ret = *(registerBaseAddress + PDEC_PIR_OFFSET);
+  // 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);
 
   while (true) {
+    // Default value to unmask IRQ on the write call.
+    info = 1;
     readCommandQueue();
     switch (state) {
       case State::INIT:
@@ -166,9 +169,12 @@ ReturnValue_t PdecHandler::irqOperation() {
         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
@@ -195,12 +201,15 @@ ReturnValue_t PdecHandler::irqOperation() {
               lockCheckCd.resetTimer();
             }
             // Clear interrupts with dummy read
-            ret = *(registerBaseAddress + PDEC_PIR_OFFSET);
+            dummy = *(registerBaseAddress + PDEC_PIR_OFFSET);
           }
         } else {
           sif::error << "PdecHandler::irqOperation: Poll error with errno " << errno << ": "
                      << strerror(errno) << std::endl;
-          triggerEvent(POLL_ERROR_PDEC, errno);
+          triggerEvent(POLL_SYSCALL_ERROR_PDEC, errno);
+          close(fd);
+          state = State::INIT;
+          return returnvalue::FAILED;
         }
         break;
       }
@@ -211,6 +220,8 @@ ReturnValue_t PdecHandler::irqOperation() {
         break;
     }
   }
+  // To avoid compiler warning
+  static_cast<void>(dummy);
   return returnvalue::OK;
 }
 

linux/ipcore/PdecHandler.h

@@ -87,7 +87,10 @@ 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);
-  static constexpr Event POLL_ERROR_PDEC = event::makeEvent(SUBSYSTEM_ID, 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);
 
  private:
   static const uint8_t INTERFACE_ID = CLASS_ID::PDEC_HANDLER;

mission/controller/AcsController.cpp

@@ -107,8 +107,6 @@ void AcsController::performControlOperation() {
 }
 
 void AcsController::performSafe() {
-  ACS::SensorValues sensorValues;
-
   timeval now;
   Clock::getClock_timeval(&now);
 
@@ -197,8 +195,6 @@ void AcsController::performSafe() {
 }
 
 void AcsController::performDetumble() {
-  ACS::SensorValues sensorValues;
-
   timeval now;
   Clock::getClock_timeval(&now);
 
@@ -258,8 +254,6 @@ void AcsController::performDetumble() {
 }
 
 void AcsController::performPointingCtrl() {
-  ACS::SensorValues sensorValues;
-
   timeval now;
   Clock::getClock_timeval(&now);
 
@@ -721,14 +715,6 @@ void AcsController::copySusData() {
   }
 }
 
-ReturnValue_t AcsController::initialize() {
-  ReturnValue_t result = parameterHelper.initialize();
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  return ExtendedControllerBase::initialize();
-}
-
 void AcsController::copyGyrData() {
   ACS::SensorValues sensorValues;
   {
@@ -776,3 +762,11 @@ 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

@@ -69,8 +69,10 @@ class AcsController : public ExtendedControllerBase, public ReceivesParameterMes
   void modeChanged(Mode_t mode, Submode_t submode);
   void announceMode(bool recursive);
 
-  /* ACS Datasets */
+  /* ACS Sensor Values */
   ACS::SensorValues sensorValues;
+
+  /* ACS Datasets */
   IMTQ::DipoleActuationSet dipoleSet = IMTQ::DipoleActuationSet(objects::IMTQ_HANDLER);
   // MGMs
   acsctrl::MgmDataRaw mgmDataRaw;

mission/controller/acs/SensorValues.cpp

@@ -20,61 +20,112 @@ SensorValues::SensorValues() {}
 SensorValues::~SensorValues() {}
 
 ReturnValue_t SensorValues::updateMgm() {
-  ReturnValue_t result;
-  PoolReadGuard pgMgm0(&mgm0Lis3Set), pgMgm1(&mgm1Rm3100Set), pgMgm2(&mgm2Lis3Set),
-      pgMgm3(&mgm3Rm3100Set), pgImtq(&imtqMgmSet);
+  std::vector<ReturnValue_t> results;
 
-  result = (pgMgm0.getReadResult() || pgMgm1.getReadResult() || pgMgm2.getReadResult() ||
-            pgMgm3.getReadResult() || pgImtq.getReadResult());
+  {
+    PoolReadGuard pgMgm(&mgm0Lis3Set);
+    results.push_back(pgMgm.getReadResult());
+  }
+  {
+    PoolReadGuard pgMgm(&mgm1Rm3100Set);
+    results.push_back(pgMgm.getReadResult());
+  }
+  {
+    PoolReadGuard pgMgm(&mgm2Lis3Set);
+    results.push_back(pgMgm.getReadResult());
+  }
+  {
+    PoolReadGuard pgMgm(&mgm3Rm3100Set);
+    results.push_back(pgMgm.getReadResult());
+  }
+  {
+    PoolReadGuard pgMgm(&imtqMgmSet);
+    results.push_back(pgMgm.getReadResult());
+  }
+  for (const auto& result : results) {
+    if (result != returnvalue::OK) {
       return result;
+    }
+  }
+  return returnvalue::OK;
 }
 
 ReturnValue_t SensorValues::updateSus() {
-  ReturnValue_t result;
-  PoolReadGuard pgSus0(&susSets[0]), pgSus1(&susSets[1]), pgSus2(&susSets[2]), pgSus3(&susSets[3]),
-      pgSus4(&susSets[4]), pgSus5(&susSets[5]), pgSus6(&susSets[6]), pgSus7(&susSets[7]),
-      pgSus8(&susSets[8]), pgSus9(&susSets[9]), pgSus10(&susSets[10]), pgSus11(&susSets[11]);
-
-  result = (pgSus0.getReadResult() || pgSus1.getReadResult() || pgSus2.getReadResult() ||
-            pgSus3.getReadResult() || pgSus4.getReadResult() || pgSus5.getReadResult() ||
-            pgSus6.getReadResult() || pgSus7.getReadResult() || pgSus8.getReadResult() ||
-            pgSus9.getReadResult() || pgSus10.getReadResult() || pgSus11.getReadResult());
+  std::vector<ReturnValue_t> results;
+  for (auto& susSet : susSets) {
+    {
+      PoolReadGuard pgSus(&susSet);
+      results.push_back(pgSus.getReadResult());
+    }
+  }
+  for (const auto& result : results) {
+    if (result != returnvalue::OK) {
       return result;
+    }
+  }
+  return returnvalue::OK;
 }
 
 ReturnValue_t SensorValues::updateGyr() {
-  ReturnValue_t result;
-  PoolReadGuard pgGyr0(&gyr0AdisSet), pgGyr1(&gyr1L3gSet), pgGyr2(&gyr2AdisSet),
-      pgGyr3(&gyr3L3gSet);
-
-  result = (pgGyr0.getReadResult() || pgGyr1.getReadResult() || pgGyr2.getReadResult() ||
-            pgGyr3.getReadResult());
+  std::vector<ReturnValue_t> results;
+  {
+    PoolReadGuard pgGyr(&gyr0AdisSet);
+    results.push_back(pgGyr.getReadResult());
+  }
+  {
+    PoolReadGuard pgGyr(&gyr1L3gSet);
+    results.push_back(pgGyr.getReadResult());
+  }
+  {
+    PoolReadGuard pgGyr(&gyr2AdisSet);
+    results.push_back(pgGyr.getReadResult());
+  }
+  {
+    PoolReadGuard pgGyr(&gyr3L3gSet);
+    results.push_back(pgGyr.getReadResult());
+  }
+  for (const auto& result : results) {
+    if (result != returnvalue::OK) {
       return result;
+    }
+  }
+  return returnvalue::OK;
 }
 
 ReturnValue_t SensorValues::updateStr() {
-  ReturnValue_t result;
   PoolReadGuard pgStr(&strSet);
-
-  result = pgStr.getReadResult();
-  return result;
+  return pgStr.getReadResult();
 }
 
 ReturnValue_t SensorValues::updateGps() {
-  ReturnValue_t result;
   PoolReadGuard pgGps(&gpsSet);
-
-  result = pgGps.getReadResult();
-  return result;
+  return pgGps.getReadResult();
 }
 
 ReturnValue_t SensorValues::updateRw() {
-  ReturnValue_t result;
-  PoolReadGuard pgRw1(&rw1Set), pgRw2(&rw2Set), pgRw3(&rw3Set), pgRw4(&rw4Set);
-
-  result = (pgRw1.getReadResult() || pgRw2.getReadResult() || pgRw3.getReadResult() ||
-            pgRw4.getReadResult());
+  std::vector<ReturnValue_t> results;
+  {
+    PoolReadGuard pgRw(&rw1Set);
+    results.push_back(pgRw.getReadResult());
+  }
+  {
+    PoolReadGuard pgRw(&rw2Set);
+    results.push_back(pgRw.getReadResult());
+  }
+  {
+    PoolReadGuard pgRw(&rw3Set);
+    results.push_back(pgRw.getReadResult());
+  }
+  {
+    PoolReadGuard pgRw(&rw4Set);
+    results.push_back(pgRw.getReadResult());
+  }
+  for (const auto& result : results) {
+    if (result != returnvalue::OK) {
       return result;
+    }
+  }
+  return returnvalue::OK;
 }
 
 ReturnValue_t SensorValues::update() {

mission/core/GenericFactory.cpp

@@ -87,14 +87,14 @@ void ObjectFactory::produceGenericObjects(HealthTableIF** healthTable_, PusTmFun
   }
 
   {
-    PoolManager::LocalPoolConfig poolCfg = {{300, 16},  {350, 32},   {350, 64},
-                                            {200, 128}, {150, 1024}, {150, 2048}};
+    PoolManager::LocalPoolConfig poolCfg = {{400, 32},  {350, 64},   {200, 128},
+                                            {150, 512}, {150, 1024}, {150, 2048}};
     tmStore = new PoolManager(objects::TM_STORE, poolCfg);
   }
 
   {
     PoolManager::LocalPoolConfig poolCfg = {{300, 16},  {200, 32}, {150, 64},  {150, 128},
-                                            {100, 256}, {50, 512}, {50, 1024}, {10, 2048}};
+                                            {100, 256}, {50, 512}, {50, 1024}, {50, 2048}};
     new PoolManager(objects::IPC_STORE, poolCfg);
   }