eive-obsw/mission/devices/PCDUHandler.cpp

#include "PCDUHandler.h"

#include <OBSWConfig.h>
#include <devices/powerSwitcherList.h>
#include <fsfw/datapool/PoolReadGuard.h>
#include <fsfw/housekeeping/HousekeepingSnapshot.h>
#include <fsfw/ipc/MutexFactory.h>
#include <fsfw/ipc/QueueFactory.h>
#include <mission/devices/devicedefinitions/GomSpacePackets.h>

PCDUHandler::PCDUHandler(object_id_t setObjectId, size_t cmdQueueSize)
    : SystemObject(setObjectId),
      poolManager(this, nullptr),
      pdu2HkTableDataset(this),
      pdu1HkTableDataset(this),
      cmdQueueSize(cmdQueueSize) {
  auto mqArgs = MqArgs(setObjectId, static_cast<void*>(this));
  commandQueue = QueueFactory::instance()->createMessageQueue(
      cmdQueueSize, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
  pwrMutex = MutexFactory::instance()->createMutex();
}

PCDUHandler::~PCDUHandler() {}

ReturnValue_t PCDUHandler::performOperation(uint8_t counter) {
  if (counter == DeviceHandlerIF::PERFORM_OPERATION) {
    readCommandQueue();
    return RETURN_OK;
  }
  return RETURN_OK;
}

ReturnValue_t PCDUHandler::initialize() {
  ReturnValue_t result;

  IPCStore = ObjectManager::instance()->get<StorageManagerIF>(objects::IPC_STORE);
  if (IPCStore == nullptr) {
    return ObjectManagerIF::CHILD_INIT_FAILED;
  }

  result = poolManager.initialize(commandQueue);
  if (result != HasReturnvaluesIF::RETURN_OK) {
    return result;
  }

  /* Subscribing for housekeeping table update messages of the PDU2 */
  HasLocalDataPoolIF* pdu2Handler =
      ObjectManager::instance()->get<HasLocalDataPoolIF>(objects::PDU2_HANDLER);
  if (pdu2Handler == nullptr) {
    sif::error << "PCDUHandler::initialize: Invalid pdu2Handler" << std::endl;
    return RETURN_FAILED;
  }
  result = pdu2Handler->getSubscriptionInterface()->subscribeForSetUpdateMessage(
      PDU2::HK_TABLE_DATA_SET_ID, this->getObjectId(), commandQueue->getId(), true);
  if (result != RETURN_OK) {
    sif::error << "PCDUHandler::initialize: Failed to subscribe for set update messages from "
               << "PDU2Handler" << std::endl;
    return result;
  }

  /* Subscribing for housekeeping table update messages of the PDU1 */
  HasLocalDataPoolIF* pdu1Handler =
      ObjectManager::instance()->get<HasLocalDataPoolIF>(objects::PDU1_HANDLER);
  if (pdu1Handler == nullptr) {
    sif::error << "PCDUHandler::initialize: Invalid pdu1Handler" << std::endl;
    return RETURN_FAILED;
  }
  result = pdu1Handler->getSubscriptionInterface()->subscribeForSetUpdateMessage(
      PDU1::HK_TABLE_DATA_SET_ID, this->getObjectId(), commandQueue->getId(), true);
  if (result != RETURN_OK) {
    sif::error << "PCDUHandler::initialize: Failed to subscribe for set update messages from "
               << "PDU1Handler" << std::endl;
    return result;
  }

  return RETURN_OK;
}

void PCDUHandler::initializeSwitchStates() {
  using namespace pcduSwitches;
  for (uint8_t idx = 0; idx < Switches::NUMBER_OF_SWITCHES; idx++) {
    switchStates[idx] = INIT_SWITCH_STATES[idx];
  }
}

void PCDUHandler::readCommandQueue() {
  ReturnValue_t result;
  CommandMessage command;

  result = commandQueue->receiveMessage(&command);
  if (result != RETURN_OK) {
    return;
  }

  result = poolManager.handleHousekeepingMessage(&command);
  if (result == RETURN_OK) {
    return;
  }
}

MessageQueueId_t PCDUHandler::getCommandQueue() const { return commandQueue->getId(); }

void PCDUHandler::handleChangedDataset(sid_t sid, store_address_t storeId, bool* clearMessage) {
  if (sid == sid_t(objects::PDU2_HANDLER, PDU2::HK_TABLE_DATA_SET_ID)) {
    updateHkTableDataset(storeId, &pdu2HkTableDataset, &timeStampPdu2HkDataset);
    updatePdu2SwitchStates();
  } else if (sid == sid_t(objects::PDU1_HANDLER, PDU1::HK_TABLE_DATA_SET_ID)) {
    updateHkTableDataset(storeId, &pdu1HkTableDataset, &timeStampPdu1HkDataset);
    updatePdu1SwitchStates();
  } else {
    sif::error << "PCDUHandler::handleChangedDataset: Invalid sid" << std::endl;
  }
}

void PCDUHandler::updateHkTableDataset(store_address_t storeId, LocalPoolDataSetBase* dataset,
                                       CCSDSTime::CDS_short* datasetTimeStamp) {
  ReturnValue_t result;

  HousekeepingSnapshot packetUpdate(reinterpret_cast<uint8_t*>(datasetTimeStamp),
                                    sizeof(CCSDSTime::CDS_short), dataset);
  const uint8_t* packet_ptr = NULL;
  size_t size;
  result = IPCStore->getData(storeId, &packet_ptr, &size);
  if (result != RETURN_OK) {
    sif::error << "PCDUHandler::updateHkTableDataset: Failed to get data from IPCStore."
               << std::endl;
  }
  dataset->read();
  result = packetUpdate.deSerialize(&packet_ptr, &size, SerializeIF::Endianness::MACHINE);
  if (result != RETURN_OK) {
    sif::error << "PCDUHandler::updateHkTableDataset: Failed to deserialize received packet "
                  "in hk table dataset"
               << std::endl;
  }
  dataset->commit();
  result = IPCStore->deleteData(storeId);
  if (result != RETURN_OK) {
    sif::error << "PCDUHandler::updateHkTableDataset: Failed to delete data in IPCStore"
               << std::endl;
  }
}

void PCDUHandler::updatePdu2SwitchStates() {
  using namespace pcduSwitches;
  GOMSPACE::Pdu pdu = GOMSPACE::Pdu::PDU2;
  PoolReadGuard rg(&pdu2HkTableDataset);
  if (rg.getReadResult() == RETURN_OK) {
    MutexGuard mg(pwrMutex);
    checkAndUpdateSwitch(pdu, Switches::PDU2_CH0_Q7S, pdu2HkTableDataset.outEnabledQ7S.value);

    checkAndUpdateSwitch(pdu, Switches::PDU2_CH1_PL_PCDU_BATT_0_14V8,
                         pdu2HkTableDataset.outEnabledPlPCDUCh1.value);
    checkAndUpdateSwitch(pdu, Switches::PDU2_CH2_RW_5V,
                         pdu2HkTableDataset.outEnabledReactionWheels.value);
    checkAndUpdateSwitch(pdu, Switches::PDU2_CH3_TCS_BOARD_HEATER_IN_8V,
                         pdu2HkTableDataset.outEnabledTCSBoardHeaterIn.value);
    checkAndUpdateSwitch(pdu, Switches::PDU2_CH4_SUS_REDUNDANT_3V3,
                         pdu2HkTableDataset.outEnabledSUSRedundant.value);
    checkAndUpdateSwitch(pdu, Switches::PDU2_CH5_DEPLOYMENT_MECHANISM_8V,
                         pdu2HkTableDataset.outEnabledDeplMechanism.value);
    checkAndUpdateSwitch(pdu, Switches::PDU2_CH6_PL_PCDU_BATT_1_14V8,
                         pdu2HkTableDataset.outEnabledPlPCDUCh6.value);
    checkAndUpdateSwitch(pdu, Switches::PDU2_CH7_ACS_BOARD_SIDE_B_3V3,
                         pdu2HkTableDataset.outEnabledAcsBoardSideB.value);
    checkAndUpdateSwitch(pdu, Switches::PDU2_CH8_PAYLOAD_CAMERA,
                         pdu2HkTableDataset.outEnabledPayloadCamera.value);
    if (firstSwitchInfoPdu2) {
      firstSwitchInfoPdu2 = false;
    }
  } else {
    sif::debug << "PCDUHandler::updatePdu2SwitchStates: Failed to read PDU2 Hk Dataset"
               << std::endl;
  }
}

void PCDUHandler::updatePdu1SwitchStates() {
  using namespace pcduSwitches;
  PoolReadGuard rg(&pdu1HkTableDataset);
  GOMSPACE::Pdu pdu = GOMSPACE::Pdu::PDU1;
  if (rg.getReadResult() == RETURN_OK) {
    MutexGuard mg(pwrMutex);
    checkAndUpdateSwitch(pdu, Switches::PDU1_CH0_TCS_BOARD_3V3,
                         pdu1HkTableDataset.outEnabledTCSBoard3V3.value);
    checkAndUpdateSwitch(pdu, Switches::PDU1_CH1_SYRLINKS_12V,
                         pdu1HkTableDataset.outEnabledSyrlinks.value);
    checkAndUpdateSwitch(pdu, Switches::PDU1_CH2_STAR_TRACKER_5V,
                         pdu1HkTableDataset.outEnabledStarTracker.value);
    checkAndUpdateSwitch(pdu, Switches::PDU1_CH3_MGT_5V, pdu1HkTableDataset.outEnabledMGT.value);
    checkAndUpdateSwitch(pdu, Switches::PDU1_CH4_SUS_NOMINAL_3V3,
                         pdu1HkTableDataset.outEnabledSUSNominal.value);
    checkAndUpdateSwitch(pdu, Switches::PDU1_CH5_SOLAR_CELL_EXP_5V,
                         pdu1HkTableDataset.outEnabledSolarCellExp.value);
    checkAndUpdateSwitch(pdu, Switches::PDU1_CH6_PLOC_12V, pdu1HkTableDataset.outEnabledPLOC.value);
    checkAndUpdateSwitch(pdu, Switches::PDU1_CH7_ACS_A_SIDE_3V3,
                         pdu1HkTableDataset.outEnabledAcsBoardSideA.value);
    checkAndUpdateSwitch(pdu, Switches::PDU1_CH8_UNOCCUPIED,
                         pdu1HkTableDataset.outEnabledChannel8.value);
    if (firstSwitchInfoPdu1) {
      firstSwitchInfoPdu1 = false;
    }
  } else {
    sif::debug << "PCDUHandler::updatePdu1SwitchStates: Failed to read dataset" << std::endl;
  }
}

LocalDataPoolManager* PCDUHandler::getHkManagerHandle() { return &poolManager; }

ReturnValue_t PCDUHandler::sendSwitchCommand(uint8_t switchNr, ReturnValue_t onOff) {
  using namespace pcduSwitches;
  ReturnValue_t result;
  uint16_t memoryAddress = 0;
  size_t parameterValueSize = sizeof(uint8_t);
  uint8_t parameterValue = 0;
  GomspaceDeviceHandler* pdu = nullptr;

  switch (switchNr) {
    case pcduSwitches::PDU1_CH0_TCS_BOARD_3V3: {
      memoryAddress = PDU1::CONFIG_ADDRESS_OUT_EN_TCS_BOARD_3V3;
      pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU1_HANDLER);
      break;
    }
    case pcduSwitches::PDU1_CH1_SYRLINKS_12V: {
      memoryAddress = PDU1::CONFIG_ADDRESS_OUT_EN_SYRLINKS;
      pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU1_HANDLER);
      break;
    }
    case pcduSwitches::PDU1_CH2_STAR_TRACKER_5V: {
      memoryAddress = PDU1::CONFIG_ADDRESS_OUT_EN_STAR_TRACKER;
      pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU1_HANDLER);
      break;
    }
    case pcduSwitches::PDU1_CH3_MGT_5V: {
      memoryAddress = PDU1::CONFIG_ADDRESS_OUT_EN_MGT;
      pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU1_HANDLER);
      break;
    }
    case pcduSwitches::PDU1_CH4_SUS_NOMINAL_3V3: {
      memoryAddress = PDU1::CONFIG_ADDRESS_OUT_EN_SUS_NOMINAL;
      pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU1_HANDLER);
      break;
    }
    case pcduSwitches::PDU1_CH5_SOLAR_CELL_EXP_5V: {
      memoryAddress = PDU1::CONFIG_ADDRESS_OUT_EN_SOLAR_CELL_EXP;
      pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU1_HANDLER);
      break;
    }
    case pcduSwitches::PDU1_CH6_PLOC_12V: {
      memoryAddress = PDU1::CONFIG_ADDRESS_OUT_EN_PLOC;
      pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU1_HANDLER);
      break;
    }
    case pcduSwitches::PDU1_CH7_ACS_A_SIDE_3V3: {
      memoryAddress = PDU1::CONFIG_ADDRESS_OUT_EN_ACS_BOARD_SIDE_A;
      pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU1_HANDLER);
      break;
    }
    case pcduSwitches::PDU1_CH8_UNOCCUPIED: {
      memoryAddress = PDU1::CONFIG_ADDRESS_OUT_EN_CHANNEL8;
      pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU1_HANDLER);
      break;
    }
    // This is a dangerous command. Reject/Igore it for now
    case pcduSwitches::PDU2_CH0_Q7S: {
      return RETURN_FAILED;
      // memoryAddress = PDU2::CONFIG_ADDRESS_OUT_EN_Q7S;
      // pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU2_HANDLER);
      // break;
    }
    case pcduSwitches::PDU2_CH1_PL_PCDU_BATT_0_14V8: {
      memoryAddress = PDU2::CONFIG_ADDRESS_OUT_EN_PAYLOAD_PCDU_CH1;
      pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU2_HANDLER);
      break;
    }
    case pcduSwitches::PDU2_CH2_RW_5V: {
      memoryAddress = PDU2::CONFIG_ADDRESS_OUT_EN_RW;
      pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU2_HANDLER);
      break;
    }
    case pcduSwitches::PDU2_CH3_TCS_BOARD_HEATER_IN_8V: {
      memoryAddress = PDU2::CONFIG_ADDRESS_OUT_EN_TCS_BOARD_HEATER_IN;
      pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU2_HANDLER);
      break;
    }
    case pcduSwitches::PDU2_CH4_SUS_REDUNDANT_3V3: {
      memoryAddress = PDU2::CONFIG_ADDRESS_OUT_EN_SUS_REDUNDANT;
      pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU2_HANDLER);
      break;
    }
    case pcduSwitches::PDU2_CH5_DEPLOYMENT_MECHANISM_8V: {
      memoryAddress = PDU2::CONFIG_ADDRESS_OUT_EN_DEPLOYMENT_MECHANISM;
      pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU2_HANDLER);
      break;
    }
    case pcduSwitches::PDU2_CH6_PL_PCDU_BATT_1_14V8: {
      memoryAddress = PDU2::CONFIG_ADDRESS_OUT_EN_PAYLOAD_PCDU_CH6;
      pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU2_HANDLER);
      break;
    }
    case pcduSwitches::PDU2_CH7_ACS_BOARD_SIDE_B_3V3: {
      memoryAddress = PDU2::CONFIG_ADDRESS_OUT_EN_ACS_BOARD_SIDE_B;
      pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU2_HANDLER);
      break;
    }
    case pcduSwitches::PDU2_CH8_PAYLOAD_CAMERA: {
      memoryAddress = PDU2::CONFIG_ADDRESS_OUT_EN_PAYLOAD_CAMERA;
      pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU2_HANDLER);
      break;
    }

    default: {
      sif::error << "PCDUHandler::sendSwitchCommand: Invalid switch number " << std::endl;
      return RETURN_FAILED;
    }
  }

  switch (onOff) {
    case PowerSwitchIF::SWITCH_ON:
      parameterValue = 1;
      break;
    case PowerSwitchIF::SWITCH_OFF:
      parameterValue = 0;
      break;
    default:
      sif::error << "PCDUHandler::sendSwitchCommand: Invalid state commanded" << std::endl;
      return RETURN_FAILED;
  }

  GomspaceSetParamMessage setParamMessage(memoryAddress, &parameterValue, parameterValueSize);

  size_t serializedLength = 0;
  uint8_t command[4];
  uint8_t* commandPtr = command;
  size_t maxSize = sizeof(command);
  setParamMessage.serialize(&commandPtr, &serializedLength, maxSize, SerializeIF::Endianness::BIG);

  store_address_t storeAddress;
  result = IPCStore->addData(&storeAddress, command, sizeof(command));

  CommandMessage message;
  ActionMessage::setCommand(&message, GOMSPACE::PARAM_SET, storeAddress);

  result = commandQueue->sendMessage(pdu->getCommandQueue(), &message, 0);
  if (result != RETURN_OK) {
    sif::debug << "PCDUHandler::sendSwitchCommand: Failed to send message to PDU Handler"
               << std::endl;
  } else {
    // Can't use trigger event because of const function constraint, but this hack seems to work
    this->forwardEvent(power::SWITCH_CMD_SENT, parameterValue, switchNr);
  }
  return result;
}

ReturnValue_t PCDUHandler::sendFuseOnCommand(uint8_t fuseNr) { return RETURN_OK; }

ReturnValue_t PCDUHandler::getSwitchState(uint8_t switchNr) const {
  if (switchNr >= pcduSwitches::NUMBER_OF_SWITCHES) {
    sif::debug << "PCDUHandler::getSwitchState: Invalid switch number" << std::endl;
    return RETURN_FAILED;
  }
  pwrMutex->lockMutex();
  uint8_t currentState = switchStates[switchNr];
  pwrMutex->unlockMutex();
  if (currentState == 1) {
    return PowerSwitchIF::SWITCH_ON;
  } else {
    return PowerSwitchIF::SWITCH_OFF;
  }
}

ReturnValue_t PCDUHandler::getFuseState(uint8_t fuseNr) const { return RETURN_OK; }

uint32_t PCDUHandler::getSwitchDelayMs(void) const { return 20000; }

object_id_t PCDUHandler::getObjectId() const { return SystemObject::getObjectId(); }

ReturnValue_t PCDUHandler::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
                                                   LocalDataPoolManager& poolManager) {
  using namespace pcduSwitches;
  using namespace P60System;
  localDataPoolMap.emplace(pool::PDU2_CURRENT_OUT_Q7S, new PoolEntry<int16_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_CURRENT_OUT_PAYLOAD_PCDU_CH1, new PoolEntry<int16_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_CURRENT_OUT_RW, new PoolEntry<int16_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_CURRENT_OUT_TCS_BOARD_HEATER_IN, new PoolEntry<int16_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_CURRENT_OUT_SUS_REDUNDANT, new PoolEntry<int16_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_CURRENT_OUT_DEPLOYMENT_MECHANISM,
                           new PoolEntry<int16_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_CURRENT_OUT_PAYLOAD_PCDU_CH6, new PoolEntry<int16_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_CURRENT_OUT_ACS_BOARD_SIDE_B, new PoolEntry<int16_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_CURRENT_OUT_PAYLOAD_CAMERA, new PoolEntry<int16_t>({0}));

  localDataPoolMap.emplace(pool::PDU2_VOLTAGE_OUT_Q7S, new PoolEntry<int16_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_VOLTAGE_OUT_PAYLOAD_PCDU_CH1, new PoolEntry<int16_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_VOLTAGE_OUT_RW, new PoolEntry<int16_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_VOLTAGE_OUT_TCS_BOARD_HEATER_IN, new PoolEntry<int16_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_VOLTAGE_OUT_SUS_REDUNDANT, new PoolEntry<int16_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_VOLTAGE_OUT_DEPLOYMENT_MECHANISM,
                           new PoolEntry<int16_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_VOLTAGE_OUT_PAYLOAD_PCDU_CH6, new PoolEntry<int16_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_VOLTAGE_OUT_ACS_BOARD_SIDE_B, new PoolEntry<int16_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_VOLTAGE_OUT_PAYLOAD_CAMERA, new PoolEntry<int16_t>({0}));

  localDataPoolMap.emplace(pool::PDU2_VCC, new PoolEntry<int16_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_VBAT, new PoolEntry<int16_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_TEMPERATURE, new PoolEntry<int16_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_CONV_EN_1, new PoolEntry<uint8_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_CONV_EN_2, new PoolEntry<uint8_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_CONV_EN_3, new PoolEntry<uint8_t>({0}));

  localDataPoolMap.emplace(pool::PDU2_OUT_EN_Q7S,
                           new PoolEntry<uint8_t>({INIT_SWITCH_STATES[Switches::PDU2_CH0_Q7S]}));
  localDataPoolMap.emplace(
      pool::PDU2_OUT_EN_PAYLOAD_PCDU_CH1,
      new PoolEntry<uint8_t>({INIT_SWITCH_STATES[Switches::PDU2_CH1_PL_PCDU_BATT_0_14V8]}));
  localDataPoolMap.emplace(pool::PDU2_OUT_EN_RW,
                           new PoolEntry<uint8_t>({INIT_SWITCH_STATES[Switches::PDU2_CH2_RW_5V]}));
#ifdef TE0720_1CFA
  localDataPoolMap.emplace(pool::PDU2_OUT_EN_TCS_BOARD_HEATER_IN, new PoolEntry<uint8_t>({1}));
#else
  localDataPoolMap.emplace(
      pool::PDU2_OUT_EN_TCS_BOARD_HEATER_IN,
      new PoolEntry<uint8_t>({INIT_SWITCH_STATES[Switches::PDU2_CH3_TCS_BOARD_HEATER_IN_8V]}));
#endif
  localDataPoolMap.emplace(
      pool::PDU2_OUT_EN_SUS_REDUNDANT,
      new PoolEntry<uint8_t>({INIT_SWITCH_STATES[Switches::PDU2_CH4_SUS_REDUNDANT_3V3]}));
  localDataPoolMap.emplace(
      pool::PDU2_OUT_EN_DEPLOYMENT_MECHANISM,
      new PoolEntry<uint8_t>({INIT_SWITCH_STATES[Switches::PDU2_CH5_DEPLOYMENT_MECHANISM_8V]}));
  localDataPoolMap.emplace(
      pool::PDU2_OUT_EN_PAYLOAD_PCDU_CH6,
      new PoolEntry<uint8_t>({INIT_SWITCH_STATES[Switches::PDU2_CH6_PL_PCDU_BATT_1_14V8]}));
  localDataPoolMap.emplace(
      pool::PDU2_OUT_EN_ACS_BOARD_SIDE_B,
      new PoolEntry<uint8_t>({INIT_SWITCH_STATES[Switches::PDU2_CH7_ACS_BOARD_SIDE_B_3V3]}));
  localDataPoolMap.emplace(
      pool::PDU2_OUT_EN_PAYLOAD_CAMERA,
      new PoolEntry<uint8_t>({INIT_SWITCH_STATES[Switches::PDU2_CH8_PAYLOAD_CAMERA]}));

  localDataPoolMap.emplace(pool::PDU2_BOOTCAUSE, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_BOOTCNT, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_UPTIME, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_RESETCAUSE, new PoolEntry<uint16_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_BATT_MODE, new PoolEntry<uint8_t>({0}));

  localDataPoolMap.emplace(pool::PDU2_LATCHUP_Q7S, new PoolEntry<uint16_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_LATCHUP_PAYLOAD_PCDU_CH1, new PoolEntry<uint16_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_LATCHUP_RW, new PoolEntry<uint16_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_LATCHUP_TCS_BOARD_HEATER_IN, new PoolEntry<uint16_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_LATCHUP_TCS_BOARD_HEATER_IN, new PoolEntry<uint16_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_LATCHUP_SUS_REDUNDANT, new PoolEntry<uint16_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_LATCHUP_DEPLOYMENT_MECHANISM, new PoolEntry<uint16_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_LATCHUP_PAYLOAD_PCDU_CH6, new PoolEntry<uint16_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_LATCHUP_ACS_BOARD_SIDE_B, new PoolEntry<uint16_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_LATCHUP_PAYLOAD_CAMERA, new PoolEntry<uint16_t>({0}));

  localDataPoolMap.emplace(pool::PDU2_DEVICE_0, new PoolEntry<uint8_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_DEVICE_1, new PoolEntry<uint8_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_DEVICE_2, new PoolEntry<uint8_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_DEVICE_3, new PoolEntry<uint8_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_DEVICE_4, new PoolEntry<uint8_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_DEVICE_5, new PoolEntry<uint8_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_DEVICE_6, new PoolEntry<uint8_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_DEVICE_7, new PoolEntry<uint8_t>({0}));

  localDataPoolMap.emplace(pool::PDU2_DEVICE_0_STATUS, new PoolEntry<uint8_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_DEVICE_1_STATUS, new PoolEntry<uint8_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_DEVICE_2_STATUS, new PoolEntry<uint8_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_DEVICE_3_STATUS, new PoolEntry<uint8_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_DEVICE_4_STATUS, new PoolEntry<uint8_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_DEVICE_5_STATUS, new PoolEntry<uint8_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_DEVICE_6_STATUS, new PoolEntry<uint8_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_DEVICE_7_STATUS, new PoolEntry<uint8_t>({0}));

  localDataPoolMap.emplace(pool::PDU2_WDT_CNT_GND, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_WDT_CNT_I2C, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_WDT_CNT_CAN, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_WDT_CNT_CSP1, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_WDT_CNT_CSP2, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_WDT_GND_LEFT, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_WDT_I2C_LEFT, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_WDT_CAN_LEFT, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_WDT_CSP_LEFT1, new PoolEntry<uint8_t>({0}));
  localDataPoolMap.emplace(pool::PDU2_WDT_CSP_LEFT2, new PoolEntry<uint8_t>({0}));

  localDataPoolMap.emplace(pool::PDU1_CURRENT_OUT_TCS_BOARD_3V3, new PoolEntry<int16_t>({0}));
  localDataPoolMap.emplace(pool::PDU1_CURRENT_OUT_SYRLINKS, new PoolEntry<int16_t>({0}));
  localDataPoolMap.emplace(pool::PDU1_CURRENT_OUT_STAR_TRACKER, new PoolEntry<int16_t>({0}));
  localDataPoolMap.emplace(pool::PDU1_CURRENT_OUT_MGT, new PoolEntry<int16_t>({0}));
  localDataPoolMap.emplace(pool::PDU1_CURRENT_OUT_SUS_NOMINAL, new PoolEntry<int16_t>({0}));
  localDataPoolMap.emplace(pool::PDU1_CURRENT_OUT_SOLAR_CELL_EXP, new PoolEntry<int16_t>({0}));
  localDataPoolMap.emplace(pool::PDU1_CURRENT_OUT_PLOC, new PoolEntry<int16_t>({0}));
  localDataPoolMap.emplace(pool::PDU1_CURRENT_OUT_ACS_BOARD_SIDE_A, new PoolEntry<int16_t>({0}));
  localDataPoolMap.emplace(pool::PDU1_CURRENT_OUT_CHANNEL8, new PoolEntry<int16_t>({0}));

  localDataPoolMap.emplace(
      pool::PDU1_VOLTAGE_OUT_TCS_BOARD_3V3,
      new PoolEntry<int16_t>({INIT_SWITCH_STATES[Switches::PDU1_CH0_TCS_BOARD_3V3]}));
  localDataPoolMap.emplace(
      pool::PDU1_VOLTAGE_OUT_SYRLINKS,
      new PoolEntry<int16_t>({INIT_SWITCH_STATES[Switches::PDU1_CH1_SYRLINKS_12V]}));
  localDataPoolMap.emplace(
      pool::PDU1_VOLTAGE_OUT_STAR_TRACKER,
      new PoolEntry<int16_t>({INIT_SWITCH_STATES[Switches::PDU1_CH2_STAR_TRACKER_5V]}));
  localDataPoolMap.emplace(pool::PDU1_VOLTAGE_OUT_MGT,
                           new PoolEntry<int16_t>({INIT_SWITCH_STATES[Switches::PDU1_CH3_MGT_5V]}));
  localDataPoolMap.emplace(
      pool::PDU1_VOLTAGE_OUT_SUS_NOMINAL,
      new PoolEntry<int16_t>({INIT_SWITCH_STATES[Switches::PDU1_CH4_SUS_NOMINAL_3V3]}));
  localDataPoolMap.emplace(
      pool::PDU1_VOLTAGE_OUT_SOLAR_CELL_EXP,
      new PoolEntry<int16_t>({INIT_SWITCH_STATES[Switches::PDU1_CH5_SOLAR_CELL_EXP_5V]}));
  localDataPoolMap.emplace(
      pool::PDU1_VOLTAGE_OUT_PLOC,
      new PoolEntry<int16_t>({INIT_SWITCH_STATES[Switches::PDU1_CH6_PLOC_12V]}));
  localDataPoolMap.emplace(
      pool::PDU1_VOLTAGE_OUT_ACS_BOARD_SIDE_A,
      new PoolEntry<int16_t>({INIT_SWITCH_STATES[Switches::PDU1_CH7_ACS_A_SIDE_3V3]}));
  localDataPoolMap.emplace(
      pool::PDU1_VOLTAGE_OUT_CHANNEL8,
      new PoolEntry<int16_t>({INIT_SWITCH_STATES[Switches::PDU1_CH8_UNOCCUPIED]}));

  localDataPoolMap.emplace(pool::PDU1_VCC, new PoolEntry<int16_t>({0}));
  localDataPoolMap.emplace(pool::PDU1_VBAT, new PoolEntry<int16_t>({0}));
  localDataPoolMap.emplace(pool::PDU1_TEMPERATURE, new PoolEntry<int16_t>({0}));
  localDataPoolMap.emplace(pool::PDU1_CONV_EN_1, new PoolEntry<uint8_t>({0}));
  localDataPoolMap.emplace(pool::PDU1_CONV_EN_2, new PoolEntry<uint8_t>({0}));
  localDataPoolMap.emplace(pool::PDU1_CONV_EN_3, new PoolEntry<uint8_t>({0}));

  localDataPoolMap.emplace(pool::PDU1_OUT_EN_TCS_BOARD_3V3, new PoolEntry<uint8_t>({0}));
  localDataPoolMap.emplace(pool::PDU1_OUT_EN_SYRLINKS, new PoolEntry<uint8_t>({0}));
  localDataPoolMap.emplace(pool::PDU1_OUT_EN_STAR_TRACKER, new PoolEntry<uint8_t>({0}));
  localDataPoolMap.emplace(pool::PDU1_OUT_EN_MGT, new PoolEntry<uint8_t>({0}));
  localDataPoolMap.emplace(pool::PDU1_OUT_EN_SUS_NOMINAL, new PoolEntry<uint8_t>({0}));
  localDataPoolMap.emplace(pool::PDU1_OUT_EN_SOLAR_CELL_EXP, new PoolEntry<uint8_t>({0}));
  localDataPoolMap.emplace(pool::PDU1_OUT_EN_PLOC, new PoolEntry<uint8_t>({0}));
  localDataPoolMap.emplace(pool::PDU1_OUT_EN_ACS_BOARD_SIDE_A, new PoolEntry<uint8_t>({0}));
  localDataPoolMap.emplace(pool::PDU1_OUT_EN_CHANNEL8, new PoolEntry<uint8_t>({0}));

  localDataPoolMap.emplace(pool::PDU1_BOOTCAUSE, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(pool::PDU1_BOOTCNT, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(pool::PDU1_UPTIME, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(pool::PDU1_RESETCAUSE, new PoolEntry<uint16_t>({0}));
  localDataPoolMap.emplace(pool::PDU1_BATT_MODE, new PoolEntry<uint8_t>({0}));

  localDataPoolMap.emplace(pool::PDU1_LATCHUP_TCS_BOARD_3V3, new PoolEntry<uint16_t>({0}));
  localDataPoolMap.emplace(pool::PDU1_LATCHUP_SYRLINKS, new PoolEntry<uint16_t>({0}));
  localDataPoolMap.emplace(pool::PDU1_LATCHUP_STAR_TRACKER, new PoolEntry<uint16_t>({0}));
  localDataPoolMap.emplace(pool::PDU1_LATCHUP_MGT, new PoolEntry<uint16_t>({0}));
  localDataPoolMap.emplace(pool::PDU1_LATCHUP_SUS_NOMINAL, new PoolEntry<uint16_t>({0}));
  localDataPoolMap.emplace(pool::PDU1_LATCHUP_SOLAR_CELL_EXP, new PoolEntry<uint16_t>({0}));
  localDataPoolMap.emplace(pool::PDU1_LATCHUP_PLOC, new PoolEntry<uint16_t>({0}));
  localDataPoolMap.emplace(pool::PDU1_LATCHUP_ACS_BOARD_SIDE_A, new PoolEntry<uint16_t>({0}));
  localDataPoolMap.emplace(pool::PDU1_LATCHUP_CHANNEL8, new PoolEntry<uint16_t>({0}));

  localDataPoolMap.emplace(pool::PDU1_DEVICE_0, new PoolEntry<uint8_t>({0}));
  localDataPoolMap.emplace(pool::PDU1_DEVICE_1, new PoolEntry<uint8_t>({0}));
  localDataPoolMap.emplace(pool::PDU1_DEVICE_2, new PoolEntry<uint8_t>({0}));
  localDataPoolMap.emplace(pool::PDU1_DEVICE_3, new PoolEntry<uint8_t>({0}));
  localDataPoolMap.emplace(pool::PDU1_DEVICE_4, new PoolEntry<uint8_t>({0}));
  localDataPoolMap.emplace(pool::PDU1_DEVICE_5, new PoolEntry<uint8_t>({0}));
  localDataPoolMap.emplace(pool::PDU1_DEVICE_6, new PoolEntry<uint8_t>({0}));
  localDataPoolMap.emplace(pool::PDU1_DEVICE_7, new PoolEntry<uint8_t>({0}));

  localDataPoolMap.emplace(pool::PDU1_DEVICE_0_STATUS, new PoolEntry<uint8_t>({0}));
  localDataPoolMap.emplace(pool::PDU1_DEVICE_1_STATUS, new PoolEntry<uint8_t>({0}));
  localDataPoolMap.emplace(pool::PDU1_DEVICE_2_STATUS, new PoolEntry<uint8_t>({0}));
  localDataPoolMap.emplace(pool::PDU1_DEVICE_3_STATUS, new PoolEntry<uint8_t>({0}));
  localDataPoolMap.emplace(pool::PDU1_DEVICE_4_STATUS, new PoolEntry<uint8_t>({0}));
  localDataPoolMap.emplace(pool::PDU1_DEVICE_5_STATUS, new PoolEntry<uint8_t>({0}));
  localDataPoolMap.emplace(pool::PDU1_DEVICE_6_STATUS, new PoolEntry<uint8_t>({0}));
  localDataPoolMap.emplace(pool::PDU1_DEVICE_7_STATUS, new PoolEntry<uint8_t>({0}));

  localDataPoolMap.emplace(pool::PDU1_WDT_CNT_GND, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(pool::PDU1_WDT_CNT_I2C, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(pool::PDU1_WDT_CNT_CAN, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(pool::PDU1_WDT_CNT_CSP1, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(pool::PDU1_WDT_CNT_CSP2, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(pool::PDU1_WDT_GND_LEFT, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(pool::PDU1_WDT_I2C_LEFT, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(pool::PDU1_WDT_CAN_LEFT, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(pool::PDU1_WDT_CSP_LEFT1, new PoolEntry<uint8_t>({0}));
  localDataPoolMap.emplace(pool::PDU1_WDT_CSP_LEFT2, new PoolEntry<uint8_t>({0}));

  return HasReturnvaluesIF::RETURN_OK;
}

ReturnValue_t PCDUHandler::initializeAfterTaskCreation() {
  if (executingTask != nullptr) {
    pstIntervalMs = executingTask->getPeriodMs();
  }
  this->poolManager.initializeAfterTaskCreation();

  initializeSwitchStates();

  return HasReturnvaluesIF::RETURN_OK;
}

uint32_t PCDUHandler::getPeriodicOperationFrequency() const { return pstIntervalMs; }

void PCDUHandler::setTaskIF(PeriodicTaskIF* task) { executingTask = task; }

LocalPoolDataSetBase* PCDUHandler::getDataSetHandle(sid_t sid) {
  if (sid == pdu2HkTableDataset.getSid()) {
    return &pdu2HkTableDataset;
  } else {
    sif::error << "PCDUHandler::getDataSetHandle: Invalid sid" << std::endl;
    return nullptr;
  }
}

void PCDUHandler::checkAndUpdateSwitch(GOMSPACE::Pdu pdu, pcduSwitches::Switches switchIdx,
                                       uint8_t setValue) {
  using namespace pcduSwitches;
  if (switchStates[switchIdx] != setValue) {
#if OBSW_INITIALIZE_SWITCHES == 1
    // This code initializes the switches to the default init switch states on every reboot.
    // This is not done by the PCDU unless it is power-cycled.
    if (((pdu == GOMSPACE::Pdu::PDU1) and firstSwitchInfoPdu1) or
        ((pdu == GOMSPACE::Pdu::PDU2) and firstSwitchInfoPdu2)) {
      ReturnValue_t state = PowerSwitchIF::SWITCH_OFF;
      if (INIT_SWITCH_STATES[switchIdx] == ON) {
        state = PowerSwitchIF::SWITCH_ON;
      }
      sendSwitchCommand(switchIdx, state);
    } else {
      triggerEvent(power::SWITCH_HAS_CHANGED, setValue, switchIdx);
    }
#else
    triggerEvent(power::SWITCH_HAS_CHANGED, setValue, switchIdx);
#endif
  }
  switchStates[switchIdx] = setValue;
}