bsp_q7s/core/ObjectFactory.cpp

@@ -1198,8 +1198,9 @@ void ObjectFactory::createPlPcduComponents(LinuxLibgpioIF* gpioComIF, SpiComIF*
                                        q7s::SPI_DEFAULT_DEV, plpcdu::MAX_ADC_REPLY_SIZE,
                                        spi::DEFAULT_MAX_1227_MODE, spi::DEFAULT_MAX_1227_SPEED);
   // Create device handler components
-  auto plPcduHandler = new PayloadPcduHandler(objects::PLPCDU_HANDLER, objects::SPI_COM_IF,
+  auto plPcduHandler =
-      spiCookie, gpioComIF, SdCardManager::instance(), false);
+      new PayloadPcduHandler(objects::PLPCDU_HANDLER, objects::SPI_COM_IF, spiCookie, gpioComIF,
+                             SdCardManager::instance(), false);
   spiCookie->setCallbackMode(PayloadPcduHandler::extConvAsTwoCallback, plPcduHandler);
   static_cast<void>(plPcduHandler);
 #if OBSW_TEST_PL_PCDU == 1

bsp_q7s/memory/SdCardManager.cpp

@@ -1,6 +1,6 @@
-#include <fsfw/ipc/MutexGuard.h>
 #include "SdCardManager.h"
 
+#include <fsfw/ipc/MutexGuard.h>
 #include <unistd.h>
 
 #include <cstring>

bsp_q7s/memory/SdCardManager.h

@@ -10,12 +10,12 @@
 #include <string>
 #include <utility>
 
-#include "mission/memory/definitions.h"
-#include "mission/memory/SdCardMountedIF.h"
 #include "events/subsystemIdRanges.h"
 #include "fsfw/events/Event.h"
 #include "fsfw/returnvalues/HasReturnvaluesIF.h"
 #include "fsfw_hal/linux/CommandExecutor.h"
+#include "mission/memory/SdCardMountedIF.h"
+#include "mission/memory/definitions.h"
 #include "returnvalues/classIds.h"
 
 class MutexIF;
@@ -24,11 +24,11 @@ class MutexIF;
  * @brief   Manages handling of SD cards like switching them on or off or getting the current
  *          state
  */
-class SdCardManager: public SystemObject, public SdCardMountedIF {
+class SdCardManager : public SystemObject, public SdCardMountedIF {
   friend class SdCardAccess;
 
  public:
-  using mountInitCb = ReturnValue_t (*) (void *args);
+  using mountInitCb = ReturnValue_t (*)(void* args);
 
   enum class Operations { SWITCHING_ON, SWITCHING_OFF, MOUNTING, UNMOUNTING, IDLE };
 

linux/fsfwconfig/events/translateEvents.cpp

@@ -159,313 +159,313 @@ const char *I_MPA_OUT_OF_BOUNDS_STRING = "I_MPA_OUT_OF_BOUNDS";
 const char *U_HPA_OUT_OF_BOUNDS_STRING = "U_HPA_OUT_OF_BOUNDS";
 const char *I_HPA_OUT_OF_BOUNDS_STRING = "I_HPA_OUT_OF_BOUNDS";
 
-const char * translateEvents(Event event) {
+const char *translateEvents(Event event) {
-  switch( (event & 0xffff) ) {
+  switch ((event & 0xffff)) {
-  case(2200):
+    case (2200):
       return STORE_SEND_WRITE_FAILED_STRING;
-  case(2201):
+    case (2201):
       return STORE_WRITE_FAILED_STRING;
-  case(2202):
+    case (2202):
       return STORE_SEND_READ_FAILED_STRING;
-  case(2203):
+    case (2203):
       return STORE_READ_FAILED_STRING;
-  case(2204):
+    case (2204):
       return UNEXPECTED_MSG_STRING;
-  case(2205):
+    case (2205):
       return STORING_FAILED_STRING;
-  case(2206):
+    case (2206):
       return TM_DUMP_FAILED_STRING;
-  case(2207):
+    case (2207):
       return STORE_INIT_FAILED_STRING;
-  case(2208):
+    case (2208):
       return STORE_INIT_EMPTY_STRING;
-  case(2209):
+    case (2209):
       return STORE_CONTENT_CORRUPTED_STRING;
-  case(2210):
+    case (2210):
       return STORE_INITIALIZE_STRING;
-  case(2211):
+    case (2211):
       return INIT_DONE_STRING;
-  case(2212):
+    case (2212):
       return DUMP_FINISHED_STRING;
-  case(2213):
+    case (2213):
       return DELETION_FINISHED_STRING;
-  case(2214):
+    case (2214):
       return DELETION_FAILED_STRING;
-  case(2215):
+    case (2215):
       return AUTO_CATALOGS_SENDING_FAILED_STRING;
-  case(2600):
+    case (2600):
       return GET_DATA_FAILED_STRING;
-  case(2601):
+    case (2601):
       return STORE_DATA_FAILED_STRING;
-  case(2800):
+    case (2800):
       return DEVICE_BUILDING_COMMAND_FAILED_STRING;
-  case(2801):
+    case (2801):
       return DEVICE_SENDING_COMMAND_FAILED_STRING;
-  case(2802):
+    case (2802):
       return DEVICE_REQUESTING_REPLY_FAILED_STRING;
-  case(2803):
+    case (2803):
       return DEVICE_READING_REPLY_FAILED_STRING;
-  case(2804):
+    case (2804):
       return DEVICE_INTERPRETING_REPLY_FAILED_STRING;
-  case(2805):
+    case (2805):
       return DEVICE_MISSED_REPLY_STRING;
-  case(2806):
+    case (2806):
       return DEVICE_UNKNOWN_REPLY_STRING;
-  case(2807):
+    case (2807):
       return DEVICE_UNREQUESTED_REPLY_STRING;
-  case(2808):
+    case (2808):
       return INVALID_DEVICE_COMMAND_STRING;
-  case(2809):
+    case (2809):
       return MONITORING_LIMIT_EXCEEDED_STRING;
-  case(2810):
+    case (2810):
       return MONITORING_AMBIGUOUS_STRING;
-  case(2811):
+    case (2811):
       return DEVICE_WANTS_HARD_REBOOT_STRING;
-  case(4201):
+    case (4201):
       return FUSE_CURRENT_HIGH_STRING;
-  case(4202):
+    case (4202):
       return FUSE_WENT_OFF_STRING;
-  case(4204):
+    case (4204):
       return POWER_ABOVE_HIGH_LIMIT_STRING;
-  case(4205):
+    case (4205):
       return POWER_BELOW_LOW_LIMIT_STRING;
-  case(4300):
+    case (4300):
       return SWITCH_WENT_OFF_STRING;
-  case(5000):
+    case (5000):
       return HEATER_ON_STRING;
-  case(5001):
+    case (5001):
       return HEATER_OFF_STRING;
-  case(5002):
+    case (5002):
       return HEATER_TIMEOUT_STRING;
-  case(5003):
+    case (5003):
       return HEATER_STAYED_ON_STRING;
-  case(5004):
+    case (5004):
       return HEATER_STAYED_OFF_STRING;
-  case(5200):
+    case (5200):
       return TEMP_SENSOR_HIGH_STRING;
-  case(5201):
+    case (5201):
       return TEMP_SENSOR_LOW_STRING;
-  case(5202):
+    case (5202):
       return TEMP_SENSOR_GRADIENT_STRING;
-  case(5901):
+    case (5901):
       return COMPONENT_TEMP_LOW_STRING;
-  case(5902):
+    case (5902):
       return COMPONENT_TEMP_HIGH_STRING;
-  case(5903):
+    case (5903):
       return COMPONENT_TEMP_OOL_LOW_STRING;
-  case(5904):
+    case (5904):
       return COMPONENT_TEMP_OOL_HIGH_STRING;
-  case(5905):
+    case (5905):
       return TEMP_NOT_IN_OP_RANGE_STRING;
-  case(7101):
+    case (7101):
       return FDIR_CHANGED_STATE_STRING;
-  case(7102):
+    case (7102):
       return FDIR_STARTS_RECOVERY_STRING;
-  case(7103):
+    case (7103):
       return FDIR_TURNS_OFF_DEVICE_STRING;
-  case(7201):
+    case (7201):
       return MONITOR_CHANGED_STATE_STRING;
-  case(7202):
+    case (7202):
       return VALUE_BELOW_LOW_LIMIT_STRING;
-  case(7203):
+    case (7203):
       return VALUE_ABOVE_HIGH_LIMIT_STRING;
-  case(7204):
+    case (7204):
       return VALUE_OUT_OF_RANGE_STRING;
-  case(7400):
+    case (7400):
       return CHANGING_MODE_STRING;
-  case(7401):
+    case (7401):
       return MODE_INFO_STRING;
-  case(7402):
+    case (7402):
       return FALLBACK_FAILED_STRING;
-  case(7403):
+    case (7403):
       return MODE_TRANSITION_FAILED_STRING;
-  case(7404):
+    case (7404):
       return CANT_KEEP_MODE_STRING;
-  case(7405):
+    case (7405):
       return OBJECT_IN_INVALID_MODE_STRING;
-  case(7406):
+    case (7406):
       return FORCING_MODE_STRING;
-  case(7407):
+    case (7407):
       return MODE_CMD_REJECTED_STRING;
-  case(7506):
+    case (7506):
       return HEALTH_INFO_STRING;
-  case(7507):
+    case (7507):
       return CHILD_CHANGED_HEALTH_STRING;
-  case(7508):
+    case (7508):
       return CHILD_PROBLEMS_STRING;
-  case(7509):
+    case (7509):
       return OVERWRITING_HEALTH_STRING;
-  case(7510):
+    case (7510):
       return TRYING_RECOVERY_STRING;
-  case(7511):
+    case (7511):
       return RECOVERY_STEP_STRING;
-  case(7512):
+    case (7512):
       return RECOVERY_DONE_STRING;
-  case(7900):
+    case (7900):
       return RF_AVAILABLE_STRING;
-  case(7901):
+    case (7901):
       return RF_LOST_STRING;
-  case(7902):
+    case (7902):
       return BIT_LOCK_STRING;
-  case(7903):
+    case (7903):
       return BIT_LOCK_LOST_STRING;
-  case(7905):
+    case (7905):
       return FRAME_PROCESSING_FAILED_STRING;
-  case(8900):
+    case (8900):
       return CLOCK_SET_STRING;
-  case(8901):
+    case (8901):
       return CLOCK_SET_FAILURE_STRING;
-  case(9700):
+    case (9700):
       return TEST_STRING;
-  case(10600):
+    case (10600):
       return CHANGE_OF_SETUP_PARAMETER_STRING;
-  case(10900):
+    case (10900):
       return GPIO_PULL_HIGH_FAILED_STRING;
-  case(10901):
+    case (10901):
       return GPIO_PULL_LOW_FAILED_STRING;
-  case(10902):
+    case (10902):
       return SWITCH_ALREADY_ON_STRING;
-  case(10903):
+    case (10903):
       return SWITCH_ALREADY_OFF_STRING;
-  case(10904):
+    case (10904):
       return MAIN_SWITCH_TIMEOUT_STRING;
-  case(11000):
+    case (11000):
       return MAIN_SWITCH_ON_TIMEOUT_STRING;
-  case(11001):
+    case (11001):
       return MAIN_SWITCH_OFF_TIMEOUT_STRING;
-  case(11002):
+    case (11002):
       return DEPLOYMENT_FAILED_STRING;
-  case(11003):
+    case (11003):
       return DEPL_SA1_GPIO_SWTICH_ON_FAILED_STRING;
-  case(11004):
+    case (11004):
       return DEPL_SA2_GPIO_SWTICH_ON_FAILED_STRING;
-  case(11101):
+    case (11101):
       return MEMORY_READ_RPT_CRC_FAILURE_STRING;
-  case(11102):
+    case (11102):
       return ACK_FAILURE_STRING;
-  case(11103):
+    case (11103):
       return EXE_FAILURE_STRING;
-  case(11104):
+    case (11104):
       return CRC_FAILURE_EVENT_STRING;
-  case(11201):
+    case (11201):
       return SELF_TEST_I2C_FAILURE_STRING;
-  case(11202):
+    case (11202):
       return SELF_TEST_SPI_FAILURE_STRING;
-  case(11203):
+    case (11203):
       return SELF_TEST_ADC_FAILURE_STRING;
-  case(11204):
+    case (11204):
       return SELF_TEST_PWM_FAILURE_STRING;
-  case(11205):
+    case (11205):
       return SELF_TEST_TC_FAILURE_STRING;
-  case(11206):
+    case (11206):
       return SELF_TEST_MTM_RANGE_FAILURE_STRING;
-  case(11207):
+    case (11207):
       return SELF_TEST_COIL_CURRENT_FAILURE_STRING;
-  case(11208):
+    case (11208):
       return INVALID_ERROR_BYTE_STRING;
-  case(11301):
+    case (11301):
       return ERROR_STATE_STRING;
-  case(11501):
+    case (11501):
       return SUPV_MEMORY_READ_RPT_CRC_FAILURE_STRING;
-  case(11502):
+    case (11502):
       return SUPV_ACK_FAILURE_STRING;
-  case(11503):
+    case (11503):
       return SUPV_EXE_FAILURE_STRING;
-  case(11504):
+    case (11504):
       return SUPV_CRC_FAILURE_EVENT_STRING;
-  case(11600):
+    case (11600):
       return ALLOC_FAILURE_STRING;
-  case(11601):
+    case (11601):
       return REBOOT_SW_STRING;
-  case(11603):
+    case (11603):
       return REBOOT_HW_STRING;
-  case(11700):
+    case (11700):
       return UPDATE_FILE_NOT_EXISTS_STRING;
-  case(11701):
+    case (11701):
       return ACTION_COMMANDING_FAILED_STRING;
-  case(11702):
+    case (11702):
       return UPDATE_AVAILABLE_FAILED_STRING;
-  case(11703):
+    case (11703):
       return UPDATE_TRANSFER_FAILED_STRING;
-  case(11704):
+    case (11704):
       return UPDATE_VERIFY_FAILED_STRING;
-  case(11705):
+    case (11705):
       return UPDATE_FINISHED_STRING;
-  case(11800):
+    case (11800):
       return SEND_MRAM_DUMP_FAILED_STRING;
-  case(11801):
+    case (11801):
       return MRAM_DUMP_FAILED_STRING;
-  case(11802):
+    case (11802):
       return MRAM_DUMP_FINISHED_STRING;
-  case(11901):
+    case (11901):
       return INVALID_TC_FRAME_STRING;
-  case(11902):
+    case (11902):
       return INVALID_FAR_STRING;
-  case(11903):
+    case (11903):
       return CARRIER_LOCK_STRING;
-  case(11904):
+    case (11904):
       return BIT_LOCK_PDEC_STRING;
-  case(12000):
+    case (12000):
       return IMAGE_UPLOAD_FAILED_STRING;
-  case(12001):
+    case (12001):
       return IMAGE_DOWNLOAD_FAILED_STRING;
-  case(12002):
+    case (12002):
       return IMAGE_UPLOAD_SUCCESSFUL_STRING;
-  case(12003):
+    case (12003):
       return IMAGE_DOWNLOAD_SUCCESSFUL_STRING;
-  case(12004):
+    case (12004):
       return FLASH_WRITE_SUCCESSFUL_STRING;
-  case(12005):
+    case (12005):
       return FLASH_READ_SUCCESSFUL_STRING;
-  case(12006):
+    case (12006):
       return FLASH_WRITE_FAILED_STRING;
-  case(12007):
+    case (12007):
       return FLASH_READ_FAILED_STRING;
-  case(12008):
+    case (12008):
       return FPGA_DOWNLOAD_SUCCESSFUL_STRING;
-  case(12009):
+    case (12009):
       return FPGA_DOWNLOAD_FAILED_STRING;
-  case(12010):
+    case (12010):
       return FPGA_UPLOAD_SUCCESSFUL_STRING;
-  case(12011):
+    case (12011):
       return FPGA_UPLOAD_FAILED_STRING;
-  case(12012):
+    case (12012):
       return STR_HELPER_READING_REPLY_FAILED_STRING;
-  case(12013):
+    case (12013):
       return STR_HELPER_COM_ERROR_STRING;
-  case(12014):
+    case (12014):
       return STR_HELPER_NO_REPLY_STRING;
-  case(12015):
+    case (12015):
       return STR_HELPER_DEC_ERROR_STRING;
-  case(12016):
+    case (12016):
       return POSITION_MISMATCH_STRING;
-  case(12017):
+    case (12017):
       return STR_HELPER_FILE_NOT_EXISTS_STRING;
-  case(12018):
+    case (12018):
       return STR_HELPER_SENDING_PACKET_FAILED_STRING;
-  case(12019):
+    case (12019):
       return STR_HELPER_REQUESTING_MSG_FAILED_STRING;
-  case(12101):
+    case (12101):
       return NEG_V_OUT_OF_BOUNDS_STRING;
-  case(12102):
+    case (12102):
       return U_DRO_OUT_OF_BOUNDS_STRING;
-  case(12103):
+    case (12103):
       return I_DRO_OUT_OF_BOUNDS_STRING;
-  case(12104):
+    case (12104):
       return U_X8_OUT_OF_BOUNDS_STRING;
-  case(12105):
+    case (12105):
       return I_X8_OUT_OF_BOUNDS_STRING;
-  case(12106):
+    case (12106):
       return U_TX_OUT_OF_BOUNDS_STRING;
-  case(12107):
+    case (12107):
       return I_TX_OUT_OF_BOUNDS_STRING;
-  case(12108):
+    case (12108):
       return U_MPA_OUT_OF_BOUNDS_STRING;
-  case(12109):
+    case (12109):
       return I_MPA_OUT_OF_BOUNDS_STRING;
-  case(12110):
+    case (12110):
       return U_HPA_OUT_OF_BOUNDS_STRING;
-  case(12111):
+    case (12111):
       return I_HPA_OUT_OF_BOUNDS_STRING;
     default:
       return "UNKNOWN_EVENT";

linux/fsfwconfig/events/translateEvents.h

@@ -3,6 +3,6 @@
 
 #include "fsfw/events/Event.h"
 
-const char * translateEvents(Event event);
+const char* translateEvents(Event event);
 
 #endif /* FSFWCONFIG_EVENTS_TRANSLATEEVENTS_H_ */

mission/devices/PayloadPcduHandler.cpp

@@ -39,6 +39,8 @@ void PayloadPcduHandler::doStartUp() {
       transitionOk = false;
       // We are now in ON mode
       startTransition(MODE_NORMAL, 0);
+      adcCountdown.setTimeout(50);
+      adcCountdown.resetTimer();
       adcState = AdcStates::BOOT_DELAY;
       // The ADC can now be read. If the values are not close to zero, we should not allow
       // transition
@@ -47,6 +49,139 @@ void PayloadPcduHandler::doStartUp() {
   }
 }
 
+void PayloadPcduHandler::stateMachineToNormal() {
+  using namespace plpcdu;
+  if (adcState == AdcStates::BOOT_DELAY) {
+    if (adcCountdown.hasTimedOut()) {
+      adcState = AdcStates::SEND_SETUP;
+      adcCmdExecuted = false;
+    }
+  }
+  if (adcState == AdcStates::SEND_SETUP) {
+    if (adcCmdExecuted) {
+      adcState = AdcStates::NORMAL;
+      setMode(MODE_NORMAL, NORMAL_ADC_ONLY);
+      adcCountdown.setTimeout(100);
+      adcCountdown.resetTimer();
+      adcCmdExecuted = false;
+    }
+  }
+  if (submode == plpcdu::NORMAL_ALL_ON) {
+    if (state == States::ON_TRANS_ADC_CLOSE_ZERO) {
+      if (not commandExecuted) {
+        float waitTime = SSR_TO_DRO_WAIT_TIME;
+        params.getValue(PlPcduParameter::SSR_TO_DRO_WAIT_TIME_K, waitTime);
+        countdown.setTimeout(std::round(waitTime * 1000));
+        countdown.resetTimer();
+        commandExecuted = true;
+        // TODO: For now, skip ADC check
+        transitionOk = true;
+      }
+      // ADC values are ok, 5 seconds have elapsed
+      if (transitionOk and countdown.hasTimedOut()) {
+        state = States::ON_TRANS_DRO;
+        // Now start monitoring for negative voltages instead
+        monMode = MonitoringMode::NEGATIVE;
+        commandExecuted = false;
+        transitionOk = false;
+      }
+    }
+    if (state == States::ON_TRANS_DRO) {
+      if (not commandExecuted) {
+        float waitTime = DRO_TO_X8_WAIT_TIME;
+        params.getValue(PlPcduParameter::DRO_TO_X8_WAIT_TIME_K, waitTime);
+        countdown.setTimeout(std::round(waitTime * 1000));
+        countdown.resetTimer();
+        // Switch on DRO and start monitoring for negative voltages
+        gpioIF->pullHigh(gpioIds::PLPCDU_ENB_DRO);
+        adcCountdown.setTimeout(100);
+        adcCountdown.resetTimer();
+        commandExecuted = true;
+      }
+      // ADC values are ok, 5 seconds have elapsed
+      if (transitionOk and countdown.hasTimedOut()) {
+        state = States::ON_TRANS_X8;
+        commandExecuted = false;
+        transitionOk = false;
+      }
+    }
+    if (state == States::ON_TRANS_X8) {
+      if (not commandExecuted) {
+        float waitTime = X8_TO_TX_WAIT_TIME;
+        params.getValue(PlPcduParameter::X8_TO_TX_WAIT_TIME_K, waitTime);
+        countdown.setTimeout(std::round(waitTime * 1000));
+        countdown.resetTimer();
+        // Switch on X8
+        gpioIF->pullHigh(gpioIds::PLPCDU_ENB_X8);
+        adcCountdown.setTimeout(100);
+        adcCountdown.resetTimer();
+        commandExecuted = true;
+      }
+      // ADC values are ok, 5 seconds have elapsed
+      if (transitionOk and countdown.hasTimedOut()) {
+        state = States::ON_TRANS_TX;
+        commandExecuted = false;
+        transitionOk = false;
+      }
+    }
+    if (state == States::ON_TRANS_TX) {
+      if (not commandExecuted) {
+        float waitTime = TX_TO_MPA_WAIT_TIME;
+        params.getValue(PlPcduParameter::TX_TO_MPA_WAIT_TIME_K, waitTime);
+        countdown.setTimeout(std::round(waitTime * 1000));
+        countdown.resetTimer();
+        // Switch on TX
+        gpioIF->pullHigh(gpioIds::PLPCDU_ENB_TX);
+        // Wait for 100 ms before checking ADC values
+        adcCountdown.setTimeout(100);
+        adcCountdown.resetTimer();
+        commandExecuted = true;
+      }
+      // ADC values are ok, 5 seconds have elapsed
+      if (transitionOk and countdown.hasTimedOut()) {
+        state = States::ON_TRANS_MPA;
+        commandExecuted = false;
+        transitionOk = false;
+      }
+    }
+    if (state == States::ON_TRANS_MPA) {
+      if (not commandExecuted) {
+        float waitTime = MPA_TO_HPA_WAIT_TIME;
+        params.getValue(PlPcduParameter::MPA_TO_HPA_WAIT_TIME_K, waitTime);
+        countdown.setTimeout(std::round(waitTime * 1000));
+        countdown.resetTimer();
+        // Switch on MPA
+        gpioIF->pullHigh(gpioIds::PLPCDU_ENB_MPA);
+        // Wait for 100 ms before checking ADC values
+        adcCountdown.setTimeout(100);
+        adcCountdown.resetTimer();
+        commandExecuted = true;
+      }
+      // ADC values are ok, 5 seconds have elapsed
+      if (transitionOk and countdown.hasTimedOut()) {
+        state = States::ON_TRANS_HPA;
+        commandExecuted = false;
+        transitionOk = false;
+      }
+    }
+    if (state == States::ON_TRANS_HPA) {
+      if (not commandExecuted) {
+        // Switch on HPA
+        gpioIF->pullHigh(gpioIds::PLPCDU_ENB_HPA);
+        commandExecuted = true;
+      }
+      // ADC values are ok, 5 seconds have elapsed
+      if (transitionOk and countdown.hasTimedOut()) {
+        state = States::PCDU_ON;
+        setMode(MODE_NORMAL, plpcdu::NORMAL_ALL_ON);
+        countdown.resetTimer();
+        commandExecuted = false;
+        transitionOk = false;
+      }
+    }
+  }
+}
+
 void PayloadPcduHandler::doTransition(Mode_t modeFrom, Submode_t subModeFrom) {
   if (mode == _MODE_TO_NORMAL) {
     stateMachineToNormal();
@@ -269,152 +404,126 @@ void PayloadPcduHandler::checkAdcValues() {
   adcSet.processed[U_X8_DIV_6] = static_cast<float>(adcSet.channels[9]) * SCALE_VOLTAGE;
   adcSet.processed[I_DRO] = static_cast<float>(adcSet.channels[10]) * SCALE_CURRENT_DRO * 1000.0;
   adcSet.processed[U_DRO_DIV_6] = static_cast<float>(adcSet.channels[11]) * SCALE_VOLTAGE;
-  if(state >= States::ON_TRANS_DRO) {
+  float lowerBound = 0.0;
-    if(adcSet.processed[U_BAT_DIV_6] < -6.0 or adcSet.processed[U_BAT_DIV_6] > -3.3) {
+  float upperBound = 0.0;
-      bool tooLarge = false;
+  bool adcTransition = false;
-      if(adcSet.processed[U_BAT_DIV_6] > -3.3) {
+  adcTransition = state == States::ON_TRANS_DRO and adcCountdown.isBusy();
-        tooLarge = true;
+  // Now check against voltage and current limits, depending on state
+  if (state >= States::ON_TRANS_DRO and not adcTransition) {
+    params.getValue(PlPcduParameter::NEG_V_LOWER_BOUND_K, lowerBound);
+    params.getValue(PlPcduParameter::NEG_V_UPPER_BOUND_K, upperBound);
+    if (not checkVoltage(adcSet.processed[U_NEG_V_FB], lowerBound, upperBound,
+                         NEG_V_OUT_OF_BOUNDS)) {
+      return;
     }
-      uint32_t rawVoltage = 0;
+    params.getValue(PlPcduParameter::DRO_U_LOWER_BOUND_K, lowerBound);
-      size_t serSize = 0;
+    params.getValue(PlPcduParameter::DRO_U_UPPER_BOUND_K, upperBound);
-      SerializeAdapter::serialize(&adcSet.processed[U_BAT_DIV_6],
+    if (not checkVoltage(adcSet.processed[U_DRO_DIV_6], lowerBound, upperBound,
-          reinterpret_cast<uint8_t*>(&rawVoltage), &serSize, 4, SerializeIF::Endianness::NETWORK);
+                         U_DRO_OUT_OF_BOUNDS)) {
-      triggerEvent(NEG_V_OUT_OF_BOUNDS, tooLarge, rawVoltage);
+      return;
-      transitionBackToOff();
+    }
+    params.getValue(PlPcduParameter::DRO_I_UPPER_BOUND_K, upperBound);
+    if (not checkCurrent(adcSet.processed[I_DRO], upperBound, I_DRO_OUT_OF_BOUNDS)) {
+      return;
+    }
+  }
+  adcTransition = state == States::ON_TRANS_X8 and adcCountdown.isBusy();
+  if (state >= States::ON_TRANS_X8 and not adcTransition) {
+    params.getValue(PlPcduParameter::X8_U_LOWER_BOUND_K, lowerBound);
+    params.getValue(PlPcduParameter::X8_U_UPPER_BOUND_K, upperBound);
+    if (not checkVoltage(adcSet.processed[U_X8_DIV_6], lowerBound, upperBound,
+                         U_X8_OUT_OF_BOUNDS)) {
+      return;
+    }
+    params.getValue(PlPcduParameter::X8_I_UPPER_BOUND_K, upperBound);
+    if (not checkCurrent(adcSet.processed[I_X8], upperBound, I_X8_OUT_OF_BOUNDS)) {
+      return;
+    }
+  }
+  adcTransition = state == States::ON_TRANS_TX and adcCountdown.isBusy();
+  if (state >= States::ON_TRANS_TX and not adcTransition) {
+    params.getValue(PlPcduParameter::TX_U_LOWER_BOUND_K, lowerBound);
+    params.getValue(PlPcduParameter::TX_U_UPPER_BOUND_K, upperBound);
+    if (not checkVoltage(adcSet.processed[U_TX_DIV_6], lowerBound, upperBound,
+                         U_TX_OUT_OF_BOUNDS)) {
+      return;
+    }
+    params.getValue(PlPcduParameter::TX_I_UPPER_BOUND_K, upperBound);
+    if (not checkCurrent(adcSet.processed[I_TX], upperBound, I_TX_OUT_OF_BOUNDS)) {
+      return;
+    }
+  }
+  adcTransition = state == States::ON_TRANS_MPA and adcCountdown.isBusy();
+  if (state >= States::ON_TRANS_MPA and not adcTransition) {
+    params.getValue(PlPcduParameter::MPA_U_LOWER_BOUND_K, lowerBound);
+    params.getValue(PlPcduParameter::MPA_U_UPPER_BOUND_K, upperBound);
+    if (not checkVoltage(adcSet.processed[U_MPA_DIV_6], lowerBound, upperBound,
+                         U_MPA_OUT_OF_BOUNDS)) {
+      return;
+    }
+    params.getValue(PlPcduParameter::MPA_I_UPPER_BOUND_K, upperBound);
+    if (not checkCurrent(adcSet.processed[I_MPA], upperBound, I_MPA_OUT_OF_BOUNDS)) {
+      return;
+    }
+  }
+  adcTransition = state == States::ON_TRANS_HPA and adcCountdown.isBusy();
+  if (state >= States::ON_TRANS_HPA and not adcTransition) {
+    params.getValue(PlPcduParameter::HPA_U_LOWER_BOUND_K, lowerBound);
+    params.getValue(PlPcduParameter::HPA_U_UPPER_BOUND_K, upperBound);
+    if (not checkVoltage(adcSet.processed[U_HPA_DIV_6], lowerBound, upperBound,
+                         U_HPA_OUT_OF_BOUNDS)) {
+      return;
+    }
+    params.getValue(PlPcduParameter::HPA_I_UPPER_BOUND_K, upperBound);
+    if (not checkCurrent(adcSet.processed[I_HPA], upperBound, I_HPA_OUT_OF_BOUNDS)) {
+      return;
     }
   }
 }
 
 void PayloadPcduHandler::checkJsonFileInit() {
-  if(not jsonFileInitComplete) {
+  if (not jsonFileInitComplete) {
     sd::SdCard prefSd;
     sdcMan->getPreferredSdCard(prefSd);
-    if(sdcMan->isSdCardMounted(prefSd)) {
+    if (sdcMan->isSdCardMounted(prefSd)) {
       params.initialize(sdcMan->getCurrentMountPrefix(prefSd));
       jsonFileInitComplete = true;
     }
   }
 }
 
-void PayloadPcduHandler::stateMachineToNormal() {
+bool PayloadPcduHandler::checkVoltage(float val, float lowerBound, float upperBound, Event event) {
-  using namespace plpcdu;
+  bool tooLarge = false;
-  if (adcState == AdcStates::BOOT_DELAY) {
+  if (val < lowerBound or val > upperBound) {
-    if (adcCountdown.hasTimedOut()) {
+    if (val > upperBound) {
-      adcState = AdcStates::SEND_SETUP;
+      tooLarge = true;
-      adcCmdExecuted = false;
+    } else {
-    }
+      tooLarge = false;
-  }
-  if (adcState == AdcStates::SEND_SETUP) {
-    if (adcCmdExecuted) {
-      adcState = AdcStates::NORMAL;
-      setMode(MODE_NORMAL, NORMAL_ADC_ONLY);
-      adcCmdExecuted = false;
-    }
-  }
-  if (submode == plpcdu::NORMAL_ALL_ON) {
-    if (state == States::ON_TRANS_ADC_CLOSE_ZERO) {
-      if (not commandExecuted) {
-        float waitTime = SSR_TO_DRO_WAIT_TIME;
-        params.getValue(PlPcduParameter::SSR_TO_DRO_WAIT_TIME_K, waitTime);
-        countdown.setTimeout(std::round(waitTime * 1000));
-        countdown.resetTimer();
-        commandExecuted = true;
-        // TODO: For now, skip ADC check
-        transitionOk = true;
-      }
-      // ADC values are ok, 5 seconds have elapsed
-      if (transitionOk and countdown.hasTimedOut()) {
-        state = States::ON_TRANS_DRO;
-        // Now start monitoring for negative voltages instead
-        monMode = MonitoringMode::NEGATIVE;
-        commandExecuted = false;
-        transitionOk = false;
-      }
-    }
-    if (state == States::ON_TRANS_DRO) {
-      if (not commandExecuted) {
-        float waitTime = DRO_TO_X8_WAIT_TIME;
-        params.getValue(PlPcduParameter::DRO_TO_X8_WAIT_TIME_K, waitTime);
-        countdown.setTimeout(std::round(waitTime * 1000));
-        countdown.resetTimer();
-        // Switch on DRO and start monitoring for negative voltages
-        gpioIF->pullHigh(gpioIds::PLPCDU_ENB_DRO);
-        commandExecuted = true;
-      }
-      // ADC values are ok, 5 seconds have elapsed
-      if (transitionOk and countdown.hasTimedOut()) {
-        state = States::ON_TRANS_X8;
-        commandExecuted = false;
-        transitionOk = false;
-      }
-    }
-    if (state == States::ON_TRANS_X8) {
-      if (not commandExecuted) {
-        float waitTime = X8_TO_TX_WAIT_TIME;
-        params.getValue(PlPcduParameter::X8_TO_TX_WAIT_TIME_K, waitTime);
-        countdown.setTimeout(std::round(waitTime * 1000));
-        countdown.resetTimer();
-        // Switch on X8
-        gpioIF->pullHigh(gpioIds::PLPCDU_ENB_X8);
-        commandExecuted = true;
-      }
-      // ADC values are ok, 5 seconds have elapsed
-      if (transitionOk and countdown.hasTimedOut()) {
-        state = States::ON_TRANS_TX;
-        commandExecuted = false;
-        transitionOk = false;
-      }
-    }
-    if (state == States::ON_TRANS_TX) {
-      if (not commandExecuted) {
-        float waitTime = TX_TO_MPA_WAIT_TIME;
-        params.getValue(PlPcduParameter::TX_TO_MPA_WAIT_TIME_K, waitTime);
-        countdown.setTimeout(std::round(waitTime * 1000));
-        countdown.resetTimer();
-        // Switch on TX
-        gpioIF->pullHigh(gpioIds::PLPCDU_ENB_TX);
-        commandExecuted = true;
-      }
-      // ADC values are ok, 5 seconds have elapsed
-      if (transitionOk and countdown.hasTimedOut()) {
-        state = States::ON_TRANS_MPA;
-        commandExecuted = false;
-        transitionOk = false;
-      }
-    }
-    if (state == States::ON_TRANS_MPA) {
-      if (not commandExecuted) {
-        float waitTime = MPA_TO_HPA_WAIT_TIME;
-        params.getValue(PlPcduParameter::MPA_TO_HPA_WAIT_TIME_K, waitTime);
-        countdown.setTimeout(std::round(waitTime * 1000));
-        countdown.resetTimer();
-        // Switch on MPA
-        gpioIF->pullHigh(gpioIds::PLPCDU_ENB_MPA);
-        commandExecuted = true;
-      }
-      // ADC values are ok, 5 seconds have elapsed
-      if (transitionOk and countdown.hasTimedOut()) {
-        state = States::ON_TRANS_HPA;
-        commandExecuted = false;
-        transitionOk = false;
-      }
-    }
-    if (state == States::ON_TRANS_HPA) {
-      if (not commandExecuted) {
-        // Switch on HPA
-        gpioIF->pullHigh(gpioIds::PLPCDU_ENB_HPA);
-        commandExecuted = true;
-      }
-      // ADC values are ok, 5 seconds have elapsed
-      if (transitionOk and countdown.hasTimedOut()) {
-        state = States::PCDU_ON;
-        setMode(MODE_NORMAL, plpcdu::NORMAL_ALL_ON);
-        countdown.resetTimer();
-        commandExecuted = false;
-        transitionOk = false;
     }
+    uint32_t p2 = 0;
+    serializeFloat(p2, val);
+    triggerEvent(event, tooLarge, p2);
+    transitionBackToOff();
+    return false;
   }
+  return true;
+}
+
+bool PayloadPcduHandler::checkCurrent(float val, float upperBound, Event event) {
+  if (val > upperBound) {
+    uint32_t p2 = 0;
+    serializeFloat(p2, val);
+    triggerEvent(event, true, p2);
+    transitionBackToOff();
+    return false;
   }
+  return true;
+}
+
+ReturnValue_t PayloadPcduHandler::serializeFloat(uint32_t& param, float val) {
+  size_t dummy = 0;
+  return SerializeAdapter::serialize(&val, reinterpret_cast<uint8_t*>(&param), &dummy, 4,
+                                     SerializeIF::Endianness::NETWORK);
 }
 
 #ifdef FSFW_OSAL_LINUX
@@ -546,4 +655,5 @@ ReturnValue_t PayloadPcduHandler::transferAsTwo(SpiComIF* comIf, SpiCookie* cook
   }
   return HasReturnvaluesIF::RETURN_OK;
 }
+
 #endif

mission/devices/PayloadPcduHandler.h

@@ -144,6 +144,9 @@ class PayloadPcduHandler : public DeviceHandlerBase {
   void checkAdcValues();
   void checkJsonFileInit();
   void stateMachineToNormal();
+  bool checkVoltage(float val, float lowerBound, float upperBound, Event event);
+  bool checkCurrent(float val, float upperBound, Event event);
+  ReturnValue_t serializeFloat(uint32_t& param, float val);
 };
 
 #endif /* LINUX_DEVICES_PLPCDUHANDLER_H_ */

mission/devices/devicedefinitions/payloadPcduDefinitions.h

@@ -1,18 +1,17 @@
 #ifndef LINUX_DEVICES_DEVICEDEFINITIONS_PAYLOADPCDUDEFINITIONS_H_
 #define LINUX_DEVICES_DEVICEDEFINITIONS_PAYLOADPCDUDEFINITIONS_H_
 
+#include <fsfw/datapoollocal/StaticLocalDataSet.h>
+#include <fsfw/devicehandlers/DeviceHandlerIF.h>
+
+#include <cstddef>
+#include <filesystem>
+#include <nlohmann/json.hpp>
+
 #include "OBSWConfig.h"
 #include "mission/devices/max1227.h"
 #include "mission/memory/NVMParameterBase.h"
 
-#include <fsfw/datapoollocal/StaticLocalDataSet.h>
-#include <fsfw/devicehandlers/DeviceHandlerIF.h>
-#include <nlohmann/json.hpp>
-
-#include <cstddef>
-#include <filesystem>
-
-
 namespace plpcdu {
 
 using namespace max1227;
@@ -84,35 +83,35 @@ static constexpr float SCALE_CURRENT_DRO = MAX122X_SCALE / (GAIN_INA169 * R_SHUN
 
 // TODO: Make these configurable parameters using a JSON file
 // Upper bound of currents in milliamperes [mA]
-static constexpr float NEG_V_LOWER_BOUND = -6.0;
+static constexpr double NEG_V_LOWER_BOUND = -6.0;
-static constexpr float NEG_V_UPPER_BOUND = -3.3;
+static constexpr double NEG_V_UPPER_BOUND = -3.3;
 
-static constexpr float DRO_U_LOWER_BOUND = 5.0;
+static constexpr double DRO_U_LOWER_BOUND = 5.0;
-static constexpr float DRO_U_UPPER_BOUND = 7.0;
+static constexpr double DRO_U_UPPER_BOUND = 7.0;
-static constexpr float DRO_I_UPPER_BOUND = 40.0;
+static constexpr double DRO_I_UPPER_BOUND = 40.0;
 
-static constexpr float X8_U_LOWER_BOUND = 2.6;
+static constexpr double X8_U_LOWER_BOUND = 2.6;
-static constexpr float X8_U_UPPER_BOUND = 4.0;
+static constexpr double X8_U_UPPER_BOUND = 4.0;
-static constexpr float X8_I_UPPER_BOUND = 100.0;
+static constexpr double X8_I_UPPER_BOUND = 100.0;
 
-static constexpr float TX_U_LOWER_BOUND = 2.6;
+static constexpr double TX_U_LOWER_BOUND = 2.6;
-static constexpr float TX_U_UPPER_BOUND = 4.0;
+static constexpr double TX_U_UPPER_BOUND = 4.0;
-static constexpr float TX_I_UPPER_BOUND = 250.0;
+static constexpr double TX_I_UPPER_BOUND = 250.0;
 
-static constexpr float MPA_U_LOWER_BOUND = 2.6;
+static constexpr double MPA_U_LOWER_BOUND = 2.6;
-static constexpr float MPA_U_UPPER_BOUND = 4.0;
+static constexpr double MPA_U_UPPER_BOUND = 4.0;
-static constexpr float MPA_I_UPPER_BOUND = 650.0;
+static constexpr double MPA_I_UPPER_BOUND = 650.0;
 
-static constexpr float HPA_U_LOWER_BOUND = 9.6;
+static constexpr double HPA_U_LOWER_BOUND = 9.6;
-static constexpr float HPA_U_UPPER_BOUND = 11.0;
+static constexpr double HPA_U_UPPER_BOUND = 11.0;
-static constexpr float HPA_I_UPPER_BOUND = 3000.0;
+static constexpr double HPA_I_UPPER_BOUND = 3000.0;
 
 // Wait time in floating point seconds
-static constexpr float SSR_TO_DRO_WAIT_TIME = 5.0;
+static constexpr double SSR_TO_DRO_WAIT_TIME = 5.0;
-static constexpr float DRO_TO_X8_WAIT_TIME = 905.0;
+static constexpr double DRO_TO_X8_WAIT_TIME = 905.0;
-static constexpr float X8_TO_TX_WAIT_TIME = 5.0;
+static constexpr double X8_TO_TX_WAIT_TIME = 5.0;
-static constexpr float TX_TO_MPA_WAIT_TIME = 5.0;
+static constexpr double TX_TO_MPA_WAIT_TIME = 5.0;
-static constexpr float MPA_TO_HPA_WAIT_TIME = 5.0;
+static constexpr double MPA_TO_HPA_WAIT_TIME = 5.0;
 
 /**
  * The current of the processed values is calculated and stored as a milliamperes [mA].
@@ -137,20 +136,59 @@ class PlPcduParameter : public NVMParameterBase {
   static constexpr char TX_TO_MPA_WAIT_TIME_K[] = "txToMpaWait";
   static constexpr char MPA_TO_HPA_WAIT_TIME_K[] = "mpaToHpaWait";
 
-  PlPcduParameter()
+  static constexpr char NEG_V_LOWER_BOUND_K[] = "negVoltLowerBound";
-      : NVMParameterBase(""), mountPrefix("") {
+  static constexpr char NEG_V_UPPER_BOUND_K[] = "negVoltUpperBound";
+
+  static constexpr char DRO_U_LOWER_BOUND_K[] = "droVoltLowerBound";
+  static constexpr char DRO_U_UPPER_BOUND_K[] = "droVoltUpperBound";
+  static constexpr char DRO_I_UPPER_BOUND_K[] = "droCurrUpperBound";
+
+  static constexpr char X8_U_LOWER_BOUND_K[] = "x8VoltLowerBound";
+  static constexpr char X8_U_UPPER_BOUND_K[] = "x8VoltUpperBound";
+  static constexpr char X8_I_UPPER_BOUND_K[] = "x8CurrUpperBound";
+
+  static constexpr char TX_U_LOWER_BOUND_K[] = "txVoltLowerBound";
+  static constexpr char TX_U_UPPER_BOUND_K[] = "txVoltUpperBound";
+  static constexpr char TX_I_UPPER_BOUND_K[] = "txCurrUpperBound";
+
+  static constexpr char MPA_U_LOWER_BOUND_K[] = "mpaVoltLowerBound";
+  static constexpr char MPA_U_UPPER_BOUND_K[] = "mpaVoltUpperBound";
+  static constexpr char MPA_I_UPPER_BOUND_K[] = "mpaCurrUpperBound";
+
+  static constexpr char HPA_U_LOWER_BOUND_K[] = "hpaVoltLowerBound";
+  static constexpr char HPA_U_UPPER_BOUND_K[] = "hpaVoltUpperBound";
+  static constexpr char HPA_I_UPPER_BOUND_K[] = "hpaCurrUpperBound";
+
+  PlPcduParameter() : NVMParameterBase(""), mountPrefix("") {
     // Initialize with default values
     insertValue(SSR_TO_DRO_WAIT_TIME_K, SSR_TO_DRO_WAIT_TIME);
     insertValue(DRO_TO_X8_WAIT_TIME_K, DRO_TO_X8_WAIT_TIME);
     insertValue(X8_TO_TX_WAIT_TIME_K, X8_TO_TX_WAIT_TIME);
     insertValue(TX_TO_MPA_WAIT_TIME_K, TX_TO_MPA_WAIT_TIME);
     insertValue(MPA_TO_HPA_WAIT_TIME_K, MPA_TO_HPA_WAIT_TIME);
+    insertValue(NEG_V_LOWER_BOUND_K, NEG_V_LOWER_BOUND);
+    insertValue(NEG_V_UPPER_BOUND_K, NEG_V_UPPER_BOUND);
+    insertValue(DRO_U_LOWER_BOUND_K, DRO_U_LOWER_BOUND);
+    insertValue(DRO_U_UPPER_BOUND_K, DRO_U_UPPER_BOUND);
+    insertValue(DRO_I_UPPER_BOUND_K, DRO_I_UPPER_BOUND);
+    insertValue(X8_U_LOWER_BOUND_K, X8_U_LOWER_BOUND);
+    insertValue(X8_U_UPPER_BOUND_K, X8_U_UPPER_BOUND);
+    insertValue(X8_I_UPPER_BOUND_K, X8_I_UPPER_BOUND);
+    insertValue(TX_U_LOWER_BOUND_K, TX_U_LOWER_BOUND);
+    insertValue(TX_U_UPPER_BOUND_K, TX_U_UPPER_BOUND);
+    insertValue(TX_I_UPPER_BOUND_K, TX_I_UPPER_BOUND);
+    insertValue(MPA_U_LOWER_BOUND_K, MPA_U_LOWER_BOUND);
+    insertValue(MPA_U_UPPER_BOUND_K, MPA_U_UPPER_BOUND);
+    insertValue(MPA_I_UPPER_BOUND_K, MPA_I_UPPER_BOUND);
+    insertValue(HPA_U_LOWER_BOUND_K, HPA_U_LOWER_BOUND);
+    insertValue(HPA_U_UPPER_BOUND_K, HPA_U_UPPER_BOUND);
+    insertValue(HPA_I_UPPER_BOUND_K, HPA_I_UPPER_BOUND);
   }
 
   ReturnValue_t initialize(std::string mountPrefix) {
     setFullName(mountPrefix + "/conf/plpcdu.json");
     ReturnValue_t result = readJsonFile();
-    if(result != HasReturnvaluesIF::RETURN_OK) {
+    if (result != HasReturnvaluesIF::RETURN_OK) {
       // File does not exist. Create it. Keys and appropriate init values were
       // specified in constructor
 #if OBSW_VERBOSE_LEVEL >= 1

mission/memory/SdCardMountedIF.h

@@ -1,21 +1,18 @@
 #ifndef MISSION_MEMORY_SDCARDMOUNTERIF_H_
 #define MISSION_MEMORY_SDCARDMOUNTERIF_H_
 
-#include "definitions.h"
-
 #include <string>
 
+#include "definitions.h"
+
 class SdCardMountedIF {
-public:
+ public:
-  virtual~SdCardMountedIF() {};
+  virtual ~SdCardMountedIF(){};
   virtual std::string getCurrentMountPrefix(sd::SdCard prefSdCardPtr = sd::SdCard::NONE) = 0;
   virtual bool isSdCardMounted(sd::SdCard sdCard) = 0;
   virtual ReturnValue_t getPreferredSdCard(sd::SdCard& sdCard) const = 0;
-private:
 
+ private:
 };
 
-
-
-
 #endif /* MISSION_MEMORY_SDCARDMOUNTERIF_H_ */