eive-obsw/mission/devices/PcduHandler.cpp

470 lines
18 KiB
C++
Raw Normal View History

2022-01-17 15:58:27 +01:00
#include <OBSWConfig.h>
#include <devices/powerSwitcherList.h>
#include <fsfw/datapool/PoolReadGuard.h>
#include <fsfw/housekeeping/HousekeepingSnapshot.h>
#include <fsfw/ipc/MutexFactory.h>
2022-01-17 15:58:27 +01:00
#include <fsfw/ipc/QueueFactory.h>
2023-01-10 14:17:55 +01:00
#include <mission/devices/PcduHandler.h>
2022-01-17 15:58:27 +01:00
#include <mission/devices/devicedefinitions/GomSpacePackets.h>
2023-03-14 13:56:19 +01:00
PcduHandler::PcduHandler(object_id_t setObjectId, size_t cmdQueueSize)
2022-01-17 15:58:27 +01:00
: SystemObject(setObjectId),
poolManager(this, nullptr),
p60CoreHk(objects::P60DOCK_HANDLER),
2022-04-07 19:48:09 +02:00
pdu1CoreHk(this),
pdu2CoreHk(this),
switcherSet(this),
2022-01-17 15:58:27 +01:00
cmdQueueSize(cmdQueueSize) {
auto mqArgs = MqArgs(setObjectId, static_cast<void*>(this));
2022-01-17 15:58:27 +01:00
commandQueue = QueueFactory::instance()->createMessageQueue(
cmdQueueSize, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
2023-03-02 15:21:45 +01:00
pwrLock = MutexFactory::instance()->createMutex();
2023-03-14 13:32:13 +01:00
std::memset(switchStates, SWITCH_STATE_UNKNOWN, sizeof(switchStates));
2021-01-23 17:22:40 +01:00
}
2023-03-14 13:56:19 +01:00
PcduHandler::~PcduHandler() {}
2021-01-23 17:22:40 +01:00
2023-03-14 13:56:19 +01:00
ReturnValue_t PcduHandler::performOperation(uint8_t counter) {
2022-01-17 15:58:27 +01:00
if (counter == DeviceHandlerIF::PERFORM_OPERATION) {
readCommandQueue();
}
uint8_t switchState = 0;
{
PoolReadGuard pg(&p60CoreHk.outputEnables);
if (pg.getReadResult() == returnvalue::OK) {
switchState = p60CoreHk.outputEnables.value[10];
2022-12-22 16:18:30 +01:00
} else {
return returnvalue::OK;
}
}
{
PoolReadGuard pg(&switcherSet.p60Dock5VStack);
if (pg.getReadResult() == returnvalue::OK) {
if (switcherSet.p60Dock5VStack.value != switchState) {
triggerEvent(power::SWITCH_HAS_CHANGED, switchState, pcdu::Switches::P60_DOCK_5V_STACK);
2023-03-02 15:22:21 +01:00
MutexGuard mg(pwrLock, LOCK_TYPE, LOCK_TIMEOUT, LOCK_CTX);
2023-01-10 15:04:49 +01:00
switchStates[pcdu::P60_DOCK_5V_STACK] = switchState;
}
2022-12-22 16:18:30 +01:00
switcherSet.p60Dock5VStack.setValid(true);
switcherSet.p60Dock5VStack.value = switchState;
}
}
2022-08-24 17:27:47 +02:00
return returnvalue::OK;
2021-01-28 14:55:21 +01:00
}
2023-03-14 13:56:19 +01:00
ReturnValue_t PcduHandler::initialize() {
2022-01-17 15:58:27 +01:00
ReturnValue_t result;
IPCStore = ObjectManager::instance()->get<StorageManagerIF>(objects::IPC_STORE);
if (IPCStore == nullptr) {
return ObjectManagerIF::CHILD_INIT_FAILED;
}
result = poolManager.initialize(commandQueue);
2022-08-24 17:27:47 +02:00
if (result != returnvalue::OK) {
2022-01-17 15:58:27 +01:00
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;
2022-08-24 17:27:47 +02:00
return returnvalue::FAILED;
2022-01-17 15:58:27 +01:00
}
result = pdu2Handler->getSubscriptionInterface()->subscribeForSetUpdateMessage(
2022-10-19 10:46:57 +02:00
static_cast<uint32_t>(P60System::SetIds::CORE), this->getObjectId(), commandQueue->getId(),
true);
2022-08-24 17:27:47 +02:00
if (result != returnvalue::OK) {
2022-01-17 15:58:27 +01:00
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;
2022-08-24 17:27:47 +02:00
return returnvalue::FAILED;
2022-01-17 15:58:27 +01:00
}
result = pdu1Handler->getSubscriptionInterface()->subscribeForSetUpdateMessage(
2022-10-19 10:46:57 +02:00
static_cast<uint32_t>(P60System::SetIds::CORE), this->getObjectId(), commandQueue->getId(),
true);
2022-08-24 17:27:47 +02:00
if (result != returnvalue::OK) {
2022-01-17 15:58:27 +01:00
sif::error << "PCDUHandler::initialize: Failed to subscribe for set update messages from "
<< "PDU1Handler" << std::endl;
return result;
}
2022-08-24 17:27:47 +02:00
return returnvalue::OK;
2021-01-28 14:55:21 +01:00
}
2023-03-14 13:56:19 +01:00
void PcduHandler::initializeSwitchStates() {
2022-04-07 19:48:09 +02:00
using namespace pcdu;
try {
for (uint8_t idx = 0; idx < NUMBER_OF_SWITCHES; idx++) {
if (idx < PDU::CHANNELS_LEN) {
switchStates[idx] = INIT_SWITCHES_PDU1.at(idx);
2023-01-10 14:17:55 +01:00
} else if (idx < PDU::CHANNELS_LEN * 2) {
switchStates[idx] = INIT_SWITCHES_PDU2.at(idx - PDU::CHANNELS_LEN);
2023-01-10 14:17:55 +01:00
} else {
switchStates[idx] = OFF;
}
2022-04-07 19:48:09 +02:00
}
} catch (const std::out_of_range& err) {
sif::error << "PCDUHandler::initializeSwitchStates: " << err.what() << std::endl;
}
}
2023-03-14 13:56:19 +01:00
void PcduHandler::readCommandQueue() {
2022-08-24 17:27:47 +02:00
ReturnValue_t result = returnvalue::OK;
2022-01-17 15:58:27 +01:00
CommandMessage command;
2022-08-24 17:27:47 +02:00
for (result = commandQueue->receiveMessage(&command); result == returnvalue::OK;
result = commandQueue->receiveMessage(&command)) {
result = poolManager.handleHousekeepingMessage(&command);
2022-08-24 17:27:47 +02:00
if (result == returnvalue::OK) {
continue;
}
2022-01-17 15:58:27 +01:00
}
2021-01-28 14:55:21 +01:00
}
2023-03-14 13:56:19 +01:00
MessageQueueId_t PcduHandler::getCommandQueue() const { return commandQueue->getId(); }
2021-01-28 14:55:21 +01:00
2023-03-14 13:56:19 +01:00
void PcduHandler::handleChangedDataset(sid_t sid, store_address_t storeId, bool* clearMessage) {
2022-10-18 11:01:33 +02:00
if (sid == sid_t(objects::PDU2_HANDLER, static_cast<uint32_t>(P60System::SetIds::CORE))) {
2022-04-07 19:48:09 +02:00
updateHkTableDataset(storeId, &pdu2CoreHk, &timeStampPdu2HkDataset);
2022-01-17 15:58:27 +01:00
updatePdu2SwitchStates();
2022-10-19 10:46:57 +02:00
} else if (sid == sid_t(objects::PDU1_HANDLER, static_cast<uint32_t>(P60System::SetIds::CORE))) {
2022-04-07 19:48:09 +02:00
updateHkTableDataset(storeId, &pdu1CoreHk, &timeStampPdu1HkDataset);
2022-01-17 15:58:27 +01:00
updatePdu1SwitchStates();
} else {
sif::error << "PCDUHandler::handleChangedDataset: Invalid sid" << std::endl;
}
2021-01-28 14:55:21 +01:00
}
2023-03-14 13:56:19 +01:00
void PcduHandler::updateHkTableDataset(store_address_t storeId, LocalPoolDataSetBase* dataset,
2022-01-17 15:58:27 +01:00
CCSDSTime::CDS_short* datasetTimeStamp) {
ReturnValue_t result;
HousekeepingSnapshot packetUpdate(reinterpret_cast<uint8_t*>(datasetTimeStamp),
sizeof(CCSDSTime::CDS_short), dataset);
2022-04-12 16:11:04 +02:00
const uint8_t* packet_ptr = nullptr;
size_t size = 0;
2022-01-17 15:58:27 +01:00
result = IPCStore->getData(storeId, &packet_ptr, &size);
2022-08-24 17:27:47 +02:00
if (result != returnvalue::OK) {
2022-01-17 15:58:27 +01:00
sif::error << "PCDUHandler::updateHkTableDataset: Failed to get data from IPCStore."
<< std::endl;
}
result = packetUpdate.deSerialize(&packet_ptr, &size, SerializeIF::Endianness::MACHINE);
2022-08-24 17:27:47 +02:00
if (result != returnvalue::OK) {
2022-01-17 15:58:27 +01:00
sif::error << "PCDUHandler::updateHkTableDataset: Failed to deserialize received packet "
"in hk table dataset"
<< std::endl;
}
result = IPCStore->deleteData(storeId);
2022-08-24 17:27:47 +02:00
if (result != returnvalue::OK) {
2022-01-17 15:58:27 +01:00
sif::error << "PCDUHandler::updateHkTableDataset: Failed to delete data in IPCStore"
<< std::endl;
}
2021-02-06 11:57:45 +01:00
}
2023-03-14 13:56:19 +01:00
void PcduHandler::updatePdu2SwitchStates() {
2022-04-07 19:48:09 +02:00
using namespace pcdu;
using namespace PDU2;
GOMSPACE::Pdu pdu = GOMSPACE::Pdu::PDU2;
2022-04-07 19:48:09 +02:00
PoolReadGuard rg0(&switcherSet);
2022-08-24 17:27:47 +02:00
if (rg0.getReadResult() == returnvalue::OK) {
2022-04-07 19:48:09 +02:00
for (uint8_t idx = 0; idx < PDU::CHANNELS_LEN; idx++) {
switcherSet.pdu2Switches[idx] = pdu2CoreHk.outputEnables[idx];
}
2022-12-22 16:20:32 +01:00
switcherSet.pdu2Switches.setValid(true);
2023-03-02 15:21:45 +01:00
MutexGuard mg(pwrLock, LOCK_TYPE, LOCK_TIMEOUT, LOCK_CTX);
2023-01-10 15:04:49 +01:00
checkAndUpdatePduSwitch(pdu, Switches::PDU2_CH0_Q7S, pdu2CoreHk.outputEnables[Channels::Q7S]);
checkAndUpdatePduSwitch(pdu, Switches::PDU2_CH1_PL_PCDU_BATT_0_14V8,
pdu2CoreHk.outputEnables[Channels::PAYLOAD_PCDU_CH1]);
checkAndUpdatePduSwitch(pdu, Switches::PDU2_CH2_RW_5V, pdu2CoreHk.outputEnables[Channels::RW]);
checkAndUpdatePduSwitch(pdu, Switches::PDU2_CH3_TCS_BOARD_HEATER_IN_8V,
pdu2CoreHk.outputEnables[Channels::TCS_HEATER_IN]);
checkAndUpdatePduSwitch(pdu, Switches::PDU2_CH4_SUS_REDUNDANT_3V3,
pdu2CoreHk.outputEnables[Channels::SUS_REDUNDANT]);
checkAndUpdatePduSwitch(pdu, Switches::PDU2_CH5_DEPLOYMENT_MECHANISM_8V,
pdu2CoreHk.outputEnables[Channels::DEPY_MECHANISM]);
checkAndUpdatePduSwitch(pdu, Switches::PDU2_CH6_PL_PCDU_BATT_1_14V8,
pdu2CoreHk.outputEnables[Channels::PAYLOAD_PCDU_CH6]);
checkAndUpdatePduSwitch(pdu, Switches::PDU2_CH7_ACS_BOARD_SIDE_B_3V3,
pdu2CoreHk.outputEnables[Channels::ACS_B_SIDE]);
checkAndUpdatePduSwitch(pdu, Switches::PDU2_CH8_PAYLOAD_CAMERA,
pdu2CoreHk.outputEnables[Channels::PAYLOAD_CAMERA]);
if (firstSwitchInfoPdu2) {
firstSwitchInfoPdu2 = false;
}
2022-01-17 15:58:27 +01:00
} else {
sif::debug << "PCDUHandler::updatePdu2SwitchStates: Failed to read PDU2 Hk Dataset"
<< std::endl;
}
}
2023-03-14 13:56:19 +01:00
void PcduHandler::updatePdu1SwitchStates() {
2022-04-07 19:48:09 +02:00
using namespace pcdu;
using namespace PDU1;
PoolReadGuard rg0(&switcherSet);
GOMSPACE::Pdu pdu = GOMSPACE::Pdu::PDU1;
2022-08-24 17:27:47 +02:00
if (rg0.getReadResult() == returnvalue::OK) {
2022-04-07 19:48:09 +02:00
for (uint8_t idx = 0; idx < PDU::CHANNELS_LEN; idx++) {
switcherSet.pdu1Switches[idx] = pdu1CoreHk.outputEnables[idx];
}
2022-12-22 16:20:32 +01:00
switcherSet.pdu1Switches.setValid(true);
2023-03-02 15:21:45 +01:00
MutexGuard mg(pwrLock, LOCK_TYPE, LOCK_TIMEOUT, LOCK_CTX);
2023-01-10 15:04:49 +01:00
checkAndUpdatePduSwitch(pdu, Switches::PDU1_CH0_TCS_BOARD_3V3,
pdu1CoreHk.outputEnables[Channels::TCS_BOARD_3V3]);
checkAndUpdatePduSwitch(pdu, Switches::PDU1_CH1_SYRLINKS_12V,
pdu1CoreHk.outputEnables[Channels::SYRLINKS]);
checkAndUpdatePduSwitch(pdu, Switches::PDU1_CH2_STAR_TRACKER_5V,
pdu1CoreHk.outputEnables[Channels::STR]);
checkAndUpdatePduSwitch(pdu, Switches::PDU1_CH3_MGT_5V,
pdu1CoreHk.outputEnables[Channels::MGT]);
checkAndUpdatePduSwitch(pdu, Switches::PDU1_CH4_SUS_NOMINAL_3V3,
pdu1CoreHk.outputEnables[Channels::SUS_NOMINAL]);
checkAndUpdatePduSwitch(pdu, Switches::PDU1_CH5_SOLAR_CELL_EXP_5V,
pdu1CoreHk.outputEnables[Channels::SOL_CELL_EXPERIMENT]);
checkAndUpdatePduSwitch(pdu, Switches::PDU1_CH6_PLOC_12V,
pdu1CoreHk.outputEnables[Channels::PLOC]);
checkAndUpdatePduSwitch(pdu, Switches::PDU1_CH7_ACS_A_SIDE_3V3,
pdu1CoreHk.outputEnables[Channels::ACS_A_SIDE]);
checkAndUpdatePduSwitch(pdu, Switches::PDU1_CH8_UNOCCUPIED,
pdu1CoreHk.outputEnables[Channels::UNUSED]);
if (firstSwitchInfoPdu1) {
firstSwitchInfoPdu1 = false;
}
2022-01-17 15:58:27 +01:00
} else {
sif::debug << "PCDUHandler::updatePdu1SwitchStates: Failed to read dataset" << std::endl;
}
}
2023-03-14 13:56:19 +01:00
LocalDataPoolManager* PcduHandler::getHkManagerHandle() { return &poolManager; }
2021-01-28 14:55:21 +01:00
2023-03-14 13:56:19 +01:00
ReturnValue_t PcduHandler::sendSwitchCommand(uint8_t switchNr, ReturnValue_t onOff) {
2022-04-07 19:48:09 +02:00
using namespace pcdu;
2022-01-17 15:58:27 +01:00
ReturnValue_t result;
uint16_t memoryAddress = 0;
2022-01-17 15:58:27 +01:00
size_t parameterValueSize = sizeof(uint8_t);
uint8_t parameterValue = 0;
2023-01-10 15:08:38 +01:00
GomspaceDeviceHandler* module = nullptr;
2021-01-28 14:55:21 +01:00
2022-01-17 15:58:27 +01:00
switch (switchNr) {
2022-04-07 19:48:09 +02:00
case pcdu::PDU1_CH0_TCS_BOARD_3V3: {
memoryAddress = PDU1::CONFIG_ADDRESS_OUT_EN_TCS_BOARD_3V3;
2023-01-10 15:08:38 +01:00
module = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU1_HANDLER);
break;
}
2022-04-07 19:48:09 +02:00
case pcdu::PDU1_CH1_SYRLINKS_12V: {
memoryAddress = PDU1::CONFIG_ADDRESS_OUT_EN_SYRLINKS;
2023-01-10 15:08:38 +01:00
module = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU1_HANDLER);
break;
}
2022-04-07 19:48:09 +02:00
case pcdu::PDU1_CH2_STAR_TRACKER_5V: {
memoryAddress = PDU1::CONFIG_ADDRESS_OUT_EN_STAR_TRACKER;
2023-01-10 15:08:38 +01:00
module = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU1_HANDLER);
break;
}
2022-04-07 19:48:09 +02:00
case pcdu::PDU1_CH3_MGT_5V: {
memoryAddress = PDU1::CONFIG_ADDRESS_OUT_EN_MGT;
2023-01-10 15:08:38 +01:00
module = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU1_HANDLER);
break;
}
2022-04-07 19:48:09 +02:00
case pcdu::PDU1_CH4_SUS_NOMINAL_3V3: {
memoryAddress = PDU1::CONFIG_ADDRESS_OUT_EN_SUS_NOMINAL;
2023-01-10 15:08:38 +01:00
module = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU1_HANDLER);
break;
}
2022-04-07 19:48:09 +02:00
case pcdu::PDU1_CH5_SOLAR_CELL_EXP_5V: {
memoryAddress = PDU1::CONFIG_ADDRESS_OUT_EN_SOLAR_CELL_EXP;
2023-01-10 15:08:38 +01:00
module = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU1_HANDLER);
break;
}
2022-04-07 19:48:09 +02:00
case pcdu::PDU1_CH6_PLOC_12V: {
memoryAddress = PDU1::CONFIG_ADDRESS_OUT_EN_PLOC;
2023-01-10 15:08:38 +01:00
module = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU1_HANDLER);
break;
}
2022-04-07 19:48:09 +02:00
case pcdu::PDU1_CH7_ACS_A_SIDE_3V3: {
memoryAddress = PDU1::CONFIG_ADDRESS_OUT_EN_ACS_BOARD_SIDE_A;
2023-01-10 15:08:38 +01:00
module = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU1_HANDLER);
break;
}
2022-04-07 19:48:09 +02:00
case pcdu::PDU1_CH8_UNOCCUPIED: {
memoryAddress = PDU1::CONFIG_ADDRESS_OUT_EN_CHANNEL8;
2023-01-10 15:08:38 +01:00
module = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU1_HANDLER);
break;
}
// This is a dangerous command. Reject/Igore it for now
2022-04-07 19:48:09 +02:00
case pcdu::PDU2_CH0_Q7S: {
2022-08-24 17:27:47 +02:00
return returnvalue::FAILED;
// memoryAddress = PDU2::CONFIG_ADDRESS_OUT_EN_Q7S;
// pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU2_HANDLER);
// break;
}
2022-04-07 19:48:09 +02:00
case pcdu::PDU2_CH1_PL_PCDU_BATT_0_14V8: {
memoryAddress = PDU2::CONFIG_ADDRESS_OUT_EN_PAYLOAD_PCDU_CH1;
2023-01-10 15:08:38 +01:00
module = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU2_HANDLER);
break;
}
2022-04-07 19:48:09 +02:00
case pcdu::PDU2_CH2_RW_5V: {
memoryAddress = PDU2::CONFIG_ADDRESS_OUT_EN_RW;
2023-01-10 15:08:38 +01:00
module = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU2_HANDLER);
break;
}
2022-04-07 19:48:09 +02:00
case pcdu::PDU2_CH3_TCS_BOARD_HEATER_IN_8V: {
2022-01-17 15:58:27 +01:00
memoryAddress = PDU2::CONFIG_ADDRESS_OUT_EN_TCS_BOARD_HEATER_IN;
2023-01-10 15:08:38 +01:00
module = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU2_HANDLER);
2022-01-17 15:58:27 +01:00
break;
}
2022-04-07 19:48:09 +02:00
case pcdu::PDU2_CH4_SUS_REDUNDANT_3V3: {
memoryAddress = PDU2::CONFIG_ADDRESS_OUT_EN_SUS_REDUNDANT;
2023-01-10 15:08:38 +01:00
module = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU2_HANDLER);
break;
}
2022-04-07 19:48:09 +02:00
case pcdu::PDU2_CH5_DEPLOYMENT_MECHANISM_8V: {
2022-01-17 15:58:27 +01:00
memoryAddress = PDU2::CONFIG_ADDRESS_OUT_EN_DEPLOYMENT_MECHANISM;
2023-01-10 15:08:38 +01:00
module = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU2_HANDLER);
2022-01-17 15:58:27 +01:00
break;
}
2022-04-07 19:48:09 +02:00
case pcdu::PDU2_CH6_PL_PCDU_BATT_1_14V8: {
memoryAddress = PDU2::CONFIG_ADDRESS_OUT_EN_PAYLOAD_PCDU_CH6;
2023-01-10 15:08:38 +01:00
module = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU2_HANDLER);
break;
}
2022-04-07 19:48:09 +02:00
case pcdu::PDU2_CH7_ACS_BOARD_SIDE_B_3V3: {
memoryAddress = PDU2::CONFIG_ADDRESS_OUT_EN_ACS_BOARD_SIDE_B;
2023-01-10 15:08:38 +01:00
module = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU2_HANDLER);
break;
}
2022-04-07 19:48:09 +02:00
case pcdu::PDU2_CH8_PAYLOAD_CAMERA: {
memoryAddress = PDU2::CONFIG_ADDRESS_OUT_EN_PAYLOAD_CAMERA;
2023-01-10 15:08:38 +01:00
module = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU2_HANDLER);
break;
}
2022-12-21 13:40:31 +01:00
case pcdu::P60_DOCK_5V_STACK: {
memoryAddress = P60Dock::CONFIG_ADDRESS_OUT_EN_5V_STACK;
2023-01-10 15:08:38 +01:00
module = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::P60DOCK_HANDLER);
2022-12-21 13:40:31 +01:00
break;
}
default: {
2022-01-17 15:58:27 +01:00
sif::error << "PCDUHandler::sendSwitchCommand: Invalid switch number " << std::endl;
2022-08-24 17:27:47 +02:00
return returnvalue::FAILED;
}
2022-01-17 15:58:27 +01:00
}
2021-01-28 14:55:21 +01:00
2022-01-17 15:58:27 +01:00
switch (onOff) {
2021-01-28 14:55:21 +01:00
case PowerSwitchIF::SWITCH_ON:
2022-01-17 15:58:27 +01:00
parameterValue = 1;
break;
2021-01-28 14:55:21 +01:00
case PowerSwitchIF::SWITCH_OFF:
2022-01-17 15:58:27 +01:00
parameterValue = 0;
break;
2021-01-28 14:55:21 +01:00
default:
2022-01-17 15:58:27 +01:00
sif::error << "PCDUHandler::sendSwitchCommand: Invalid state commanded" << std::endl;
2022-08-24 17:27:47 +02:00
return returnvalue::FAILED;
2022-01-17 15:58:27 +01:00
}
2021-01-28 14:55:21 +01:00
2022-01-17 15:58:27 +01:00
GomspaceSetParamMessage setParamMessage(memoryAddress, &parameterValue, parameterValueSize);
2021-01-28 14:55:21 +01:00
2022-01-17 15:58:27 +01:00
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);
2021-01-28 14:55:21 +01:00
2022-01-17 15:58:27 +01:00
store_address_t storeAddress;
result = IPCStore->addData(&storeAddress, command, sizeof(command));
2021-01-28 14:55:21 +01:00
2022-01-17 15:58:27 +01:00
CommandMessage message;
ActionMessage::setCommand(&message, GOMSPACE::PARAM_SET, storeAddress);
2021-01-28 14:55:21 +01:00
2023-01-10 15:08:38 +01:00
result = commandQueue->sendMessage(module->getCommandQueue(), &message, 0);
2022-08-24 17:27:47 +02:00
if (result != returnvalue::OK) {
2022-01-17 15:58:27 +01:00
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);
2022-01-17 15:58:27 +01:00
}
2022-03-30 12:22:49 +02:00
return result;
2021-01-28 14:55:21 +01:00
}
2023-03-14 13:56:19 +01:00
ReturnValue_t PcduHandler::sendFuseOnCommand(uint8_t fuseNr) { return returnvalue::OK; }
2022-01-17 15:58:27 +01:00
2023-03-14 13:56:19 +01:00
ReturnValue_t PcduHandler::getSwitchState(uint8_t switchNr) const {
2022-04-07 19:48:09 +02:00
if (switchNr >= pcdu::NUMBER_OF_SWITCHES) {
2022-01-17 15:58:27 +01:00
sif::debug << "PCDUHandler::getSwitchState: Invalid switch number" << std::endl;
2022-08-24 17:27:47 +02:00
return returnvalue::FAILED;
2022-01-17 15:58:27 +01:00
}
2023-03-02 15:21:45 +01:00
uint8_t currentState = 0;
{
MutexGuard mg(pwrLock, LOCK_TYPE, LOCK_TIMEOUT, LOCK_CTX);
2023-03-02 15:22:21 +01:00
currentState = switchStates[switchNr];
2023-03-02 15:21:45 +01:00
}
2023-03-14 13:32:13 +01:00
if (currentState == SWITCH_STATE_UNKNOWN) {
2023-03-14 13:56:19 +01:00
return PowerSwitchIF::SWITCH_UNKNOWN;
2023-03-14 13:32:13 +01:00
}
if (currentState == 1) {
2022-01-17 15:58:27 +01:00
return PowerSwitchIF::SWITCH_ON;
} else {
return PowerSwitchIF::SWITCH_OFF;
}
2021-01-28 14:55:21 +01:00
}
2023-03-14 13:56:19 +01:00
ReturnValue_t PcduHandler::getFuseState(uint8_t fuseNr) const { return returnvalue::OK; }
2022-01-17 15:58:27 +01:00
2023-03-14 13:56:19 +01:00
uint32_t PcduHandler::getSwitchDelayMs(void) const { return 20000; }
2022-01-17 15:58:27 +01:00
2023-03-14 13:56:19 +01:00
object_id_t PcduHandler::getObjectId() const { return SystemObject::getObjectId(); }
2022-01-17 15:58:27 +01:00
2023-03-14 13:56:19 +01:00
ReturnValue_t PcduHandler::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
2022-01-17 15:58:27 +01:00
LocalDataPoolManager& poolManager) {
2022-04-07 19:48:09 +02:00
using namespace pcdu;
localDataPoolMap.emplace(PoolIds::PDU1_SWITCHES, &pdu1Switches);
2022-04-12 16:11:04 +02:00
localDataPoolMap.emplace(PoolIds::PDU2_SWITCHES, &pdu2Switches);
localDataPoolMap.emplace(PoolIds::P60DOCK_SWITCHES, &p60Dock5VSwitch);
2023-01-24 13:18:29 +01:00
poolManager.subscribeForDiagPeriodicPacket(
subdp::DiagnosticsHkPeriodicParams(switcherSet.getSid(), false, 5.0));
2022-08-24 17:27:47 +02:00
return returnvalue::OK;
2021-01-28 14:55:21 +01:00
}
2023-03-14 13:56:19 +01:00
ReturnValue_t PcduHandler::initializeAfterTaskCreation() {
2022-01-17 15:58:27 +01:00
if (executingTask != nullptr) {
pstIntervalMs = executingTask->getPeriodMs();
}
this->poolManager.initializeAfterTaskCreation();
2021-01-28 14:55:21 +01:00
2022-01-17 15:58:27 +01:00
initializeSwitchStates();
2021-01-28 14:55:21 +01:00
2022-08-24 17:27:47 +02:00
return returnvalue::OK;
2021-01-28 14:55:21 +01:00
}
2023-03-14 13:56:19 +01:00
uint32_t PcduHandler::getPeriodicOperationFrequency() const { return pstIntervalMs; }
2021-01-28 14:55:21 +01:00
2023-03-14 13:56:19 +01:00
void PcduHandler::setTaskIF(PeriodicTaskIF* task) { executingTask = task; }
2021-01-28 14:55:21 +01:00
2023-03-14 13:56:19 +01:00
LocalPoolDataSetBase* PcduHandler::getDataSetHandle(sid_t sid) {
2022-04-07 19:48:09 +02:00
if (sid == switcherSet.getSid()) {
return &switcherSet;
2022-01-17 15:58:27 +01:00
} else {
sif::error << "PCDUHandler::getDataSetHandle: Invalid sid" << std::endl;
return nullptr;
}
2021-01-28 14:55:21 +01:00
}
2023-03-14 13:56:19 +01:00
void PcduHandler::checkAndUpdatePduSwitch(GOMSPACE::Pdu pdu, pcdu::Switches switchIdx,
2023-01-10 15:04:49 +01:00
uint8_t setValue) {
2022-04-07 19:48:09 +02:00
using namespace pcdu;
if (switchStates[switchIdx] != setValue) {
triggerEvent(power::SWITCH_HAS_CHANGED, setValue, switchIdx);
}
switchStates[switchIdx] = setValue;
}