added processed values to dataset

mission/devices/PayloadPcduHandler.cpp

@@ -51,7 +51,7 @@ void PayloadPcduHandler::doTransition(Mode_t modeFrom, Submode_t subModeFrom) {
   }
 }
 
-void PayloadPcduHandler::doShutDown() {}
+void PayloadPcduHandler::doShutDown() { transitionBackToOff(); }
 
 ReturnValue_t PayloadPcduHandler::buildNormalDeviceCommand(DeviceCommandId_t* id) {
   switch (adcState) {
@@ -150,6 +150,8 @@ ReturnValue_t PayloadPcduHandler::interpretDeviceReply(DeviceCommandId_t id,
         return pg.getReadResult();
       }
       handleExtConvRead(packet);
+      checkAdcValues();
+      adcSet.setValidity(true, true);
       handlePrintout();
       break;
     }
@@ -162,6 +164,8 @@ ReturnValue_t PayloadPcduHandler::interpretDeviceReply(DeviceCommandId_t id,
       uint8_t tempStartIdx = ADC_REPLY_SIZE + TEMP_REPLY_SIZE - 2;
       adcSet.tempC.value =
           max1227::getTemperature(packet[tempStartIdx] << 8 | packet[tempStartIdx + 1]);
+      checkAdcValues();
+      adcSet.setValidity(true, true);
       handlePrintout();
       break;
     }
@@ -180,7 +184,9 @@ uint32_t PayloadPcduHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo
 ReturnValue_t PayloadPcduHandler::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
                                                           LocalDataPoolManager& poolManager) {
   localDataPoolMap.emplace(plpcdu::PlPcduPoolIds::CHANNEL_VEC, &channelValues);
+  localDataPoolMap.emplace(plpcdu::PlPcduPoolIds::PROCESSED_VEC, &processedValues);
   localDataPoolMap.emplace(plpcdu::PlPcduPoolIds::TEMP, &tempC);
+  poolManager.subscribeForPeriodicPacket(adcSet.getSid(), false, 0.1, true);
   return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -231,6 +237,25 @@ void PayloadPcduHandler::transitionBackToOff() {
   triggerEvent(TRANSITION_BACK_TO_OFF, static_cast<uint32_t>(currentState));
 }
 
+void PayloadPcduHandler::checkAdcValues() {
+  using namespace plpcdu;
+  adcSet.processed[U_BAT_DIV_6] =
+      static_cast<float>(adcSet.channels[0]) * VOLTAGE_DIV / MAX122X_BIT * MAX122X_VREF;
+  adcSet.processed[U_NEG_V_FB] =
+      V_POS - VOLTAGE_DIV_U_NEG *
+                  (V_POS - static_cast<float>(adcSet.channels[1]) / MAX122X_BIT * MAX122X_VREF);
+  adcSet.processed[I_HPA] = static_cast<float>(adcSet.channels[2]) * SCALE_CURRENT_HPA * 1000.0;
+  adcSet.processed[U_HPA_DIV_6] = static_cast<float>(adcSet.channels[3]) * SCALE_VOLTAGE;
+  adcSet.processed[I_MPA] = static_cast<float>(adcSet.channels[4]) * SCALE_CURRENT_MPA * 1000.0;
+  adcSet.processed[U_MPA_DIV_6] = static_cast<float>(adcSet.channels[5]) * SCALE_VOLTAGE;
+  adcSet.processed[I_TX] = static_cast<float>(adcSet.channels[6]) * SCALE_CURRENT_TX * 1000.0;
+  adcSet.processed[U_TX_DIV_6] = static_cast<float>(adcSet.channels[7]) * SCALE_VOLTAGE;
+  adcSet.processed[I_X8] = static_cast<float>(adcSet.channels[8]) * SCALE_CURRENT_X8 * 1000.0;
+  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;
+}
+
 void PayloadPcduHandler::stateMachineToNormal() {
   if (adcState == AdcStates::BOOT_DELAY) {
     if (adcCountdown.hasTimedOut()) {

mission/devices/PayloadPcduHandler.h

@@ -93,6 +93,8 @@ class PayloadPcduHandler : public DeviceHandlerBase {
   GpioIF* gpioIF;
 
   PoolEntry<uint16_t> channelValues = PoolEntry<uint16_t>({0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0});
+  PoolEntry<float> processedValues =
+      PoolEntry<float>({0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0});
   PoolEntry<float> tempC = PoolEntry<float>({0.0});
 
   void doTransition(Mode_t modeFrom, Submode_t subModeFrom) override;
@@ -114,6 +116,7 @@ class PayloadPcduHandler : public DeviceHandlerBase {
 
   void handleExtConvRead(const uint8_t* bufStart);
   void handlePrintout();
+  void checkAdcValues();
   void stateMachineToNormal();
 };
 

mission/devices/devicedefinitions/payloadPcduDefinitions.h

@@ -16,7 +16,7 @@ enum PlPcduAdcChannels : uint8_t {
   U_BAT_DIV_6 = 0,
   // According to schematic, will be 2.2158V for Vneg = +0V and 0.2446V for Vneg = -6V
   // Full Forumula: V_neg = V_post - (R1 + R2) / R1 * (V_pos - V_out) with R1 being 27.4k
-  // and R2 being 49.9k
+  // and R2 being 49.9k. FB = Feedback
   U_NEG_V_FB = 1,
   I_HPA = 2,
   U_HPA_DIV_6 = 3,
@@ -31,7 +31,7 @@ enum PlPcduAdcChannels : uint8_t {
   NUM_CHANNELS = 12
 };
 
-enum PlPcduPoolIds : uint32_t { CHANNEL_VEC = 0, TEMP = 1 };
+enum PlPcduPoolIds : uint32_t { CHANNEL_VEC = 0, PROCESSED_VEC = 1, TEMP = 2 };
 
 static constexpr size_t MAX_ADC_REPLY_SIZE = 64;
 
@@ -57,6 +57,30 @@ static constexpr uint8_t CHANNEL_N = CHANNELS_NUM - 1;
 // Store temperature as well
 static constexpr size_t DATASET_ENTRIES = CHANNELS_NUM + 1;
 
+static constexpr uint8_t VOLTAGE_DIV = 6;
+// 12-bit ADC: 2 to the power of 12 minus 1
+static constexpr uint16_t MAX122X_BIT = 4095;
+static constexpr float MAX122X_VREF = 2.5;
+static constexpr float GAIN_INA169 = 100.0;
+static constexpr float R_SHUNT_HPA = 0.008;
+static constexpr float R_SHUNT_MPA = 0.015;
+static constexpr float R_SHUNT_TX = 0.05;
+static constexpr float R_SHUNT_X8 = 0.015;
+static constexpr float R_SHUNT_DRO = 0.022;
+static constexpr float V_POS = 3.3;
+static constexpr float VOLTAGE_DIV_U_NEG = (49.9 + 27.4) / 27.4;
+static constexpr float MAX122X_SCALE = MAX122X_VREF / MAX122X_BIT;
+static constexpr float SCALE_VOLTAGE = MAX122X_SCALE * VOLTAGE_DIV;
+static constexpr float SCALE_CURRENT_HPA = MAX122X_SCALE / (GAIN_INA169 * R_SHUNT_HPA);
+static constexpr float SCALE_CURRENT_MPA = MAX122X_SCALE / (GAIN_INA169 * R_SHUNT_MPA);
+static constexpr float SCALE_CURRENT_TX = MAX122X_SCALE / (GAIN_INA169 * R_SHUNT_TX);
+static constexpr float SCALE_CURRENT_X8 = MAX122X_SCALE / (GAIN_INA169 * R_SHUNT_X8);
+static constexpr float SCALE_CURRENT_DRO = MAX122X_SCALE / (GAIN_INA169 * R_SHUNT_DRO);
+
+/**
+ * The current of the processed values is calculated and stored as a milli ampere value.
+ * The voltages are stored as Volt values.
+ */
 class PlPcduAdcSet : public StaticLocalDataSet<DATASET_ENTRIES> {
  public:
   PlPcduAdcSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, ADC_SET_ID) {}
@@ -64,6 +88,7 @@ class PlPcduAdcSet : public StaticLocalDataSet<DATASET_ENTRIES> {
   PlPcduAdcSet(object_id_t objectId) : StaticLocalDataSet(sid_t(objectId, ADC_SET_ID)) {}
 
   lp_vec_t<uint16_t, 12> channels = lp_vec_t<uint16_t, 12>(sid.objectId, CHANNEL_VEC, this);
+  lp_vec_t<float, 12> processed = lp_vec_t<float, 12>(sid.objectId, PROCESSED_VEC, this);
   lp_var_t<float> tempC = lp_var_t<float>(sid.objectId, TEMP, this);
 };