Merge branch 'develop' into meier/deviceHandlerUpdate
All checks were successful
EIVE/eive-obsw/pipeline/pr-develop This commit looks good

This commit is contained in:
Jakob Meier 2022-03-31 15:48:58 +02:00
commit 222f17edcc
15 changed files with 230 additions and 214 deletions

View File

@ -149,7 +149,7 @@ void ObjectFactory::produce(void* args) {
createHeaterComponents();
createSolarArrayDeploymentComponents();
createPlPcduComponents(gpioComIF, spiComIF);
createPlPcduComponents(gpioComIF, spiComIF, pwrSwitcher);
#if OBSW_ADD_SYRLINKS == 1
createSyrlinksComponents();
#endif /* OBSW_ADD_SYRLINKS == 1 */
@ -1151,7 +1151,8 @@ void ObjectFactory::createCcsdsComponents(LinuxLibgpioIF* gpioComIF) {
gpioComIF->addGpios(gpioRS485Chip);
}
void ObjectFactory::createPlPcduComponents(LinuxLibgpioIF* gpioComIF, SpiComIF* spiComIF) {
void ObjectFactory::createPlPcduComponents(LinuxLibgpioIF* gpioComIF, SpiComIF* spiComIF,
PowerSwitchIF* pwrSwitcher) {
using namespace gpio;
// Create all GPIO components first
GpioCookie* plPcduGpios = new GpioCookie;
@ -1197,9 +1198,10 @@ void ObjectFactory::createPlPcduComponents(LinuxLibgpioIF* gpioComIF, SpiComIF*
q7s::SPI_DEFAULT_DEV, plpcdu::MAX_ADC_REPLY_SIZE,
spi::DEFAULT_MAX_1227_MODE, spi::PL_PCDU_MAX_1227_SPEED);
// Create device handler components
auto plPcduHandler =
new PayloadPcduHandler(objects::PLPCDU_HANDLER, objects::SPI_COM_IF, spiCookie, gpioComIF,
SdCardManager::instance(), false);
auto plPcduHandler = new PayloadPcduHandler(
objects::PLPCDU_HANDLER, objects::SPI_COM_IF, spiCookie, gpioComIF, SdCardManager::instance(),
pwrSwitcher, pcduSwitches::Switches::PDU2_CH1_PL_PCDU_BATT_0_14V8,
pcduSwitches::Switches::PDU2_CH6_PL_PCDU_BATT_1_14V8, false);
spiCookie->setCallbackMode(PayloadPcduHandler::extConvAsTwoCallback, plPcduHandler);
// plPcduHandler->enablePeriodicPrintout(true, 5);
// static_cast<void>(plPcduHandler);

View File

@ -15,7 +15,8 @@ void produce(void* args);
void createCommunicationInterfaces(LinuxLibgpioIF** gpioComIF, UartComIF** uartComIF,
SpiComIF** spiComIF, I2cComIF** i2cComIF);
void createPcduComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchIF** pwrSwitcher);
void createPlPcduComponents(LinuxLibgpioIF* gpioComIF, SpiComIF* spiComIF);
void createPlPcduComponents(LinuxLibgpioIF* gpioComIF, SpiComIF* spiComIF,
PowerSwitchIF* pwrSwitcher);
void createTmpComponents();
void createRadSensorComponent(LinuxLibgpioIF* gpioComIF);
void createSunSensorComponents(LinuxLibgpioIF* gpioComIF, SpiComIF* spiComIF,

View File

@ -3,12 +3,15 @@
#include "OBSWConfig.h"
#include <fsfw/power/definitions.h>
#include <array>
#include <cstdint>
namespace pcduSwitches {
/* Switches are uint8_t datatype and go from 0 to 255 */
enum Switches: uint8_t {
enum Switches: power::Switch_t {
PDU1_CH0_TCS_BOARD_3V3,
PDU1_CH1_SYRLINKS_12V,
PDU1_CH2_STAR_TRACKER_5V,

View File

@ -50,7 +50,7 @@ debugging. */
#define OBSW_ADD_RTD_DEVICES 1
#define OBSW_ADD_TMP_DEVICES 0
#define OBSW_ADD_RAD_SENSORS 1
#define OBSW_ADD_PL_PCDU 0
#define OBSW_ADD_PL_PCDU 1
#define OBSW_ADD_SYRLINKS 0
#define OBSW_ENABLE_SYRLINKS_TRANSMIT_TIMEOUT 0
#define OBSW_STAR_TRACKER_GROUND_CONFIG 1
@ -88,10 +88,10 @@ debugging. */
#define OBSW_ADD_PL_PCDU 0
#define OBSW_ADD_SYRLINKS 0
#define OBSW_ENABLE_SYRLINKS_TRANSMIT_TIMEOUT 0
#define OBSW_SYRLINKS_SIMULATED 1
#define OBSW_SYRLINKS_SIMULATED 1
#define OBSW_STAR_TRACKER_GROUND_CONFIG 1
#define OBSW_ENABLE_PERIODIC_HK 0
#define OBSW_PRINT_CORE_HK 0
#define OBSW_PRINT_CORE_HK 0
#define OBSW_INITIALIZE_SWITCHES 0
#endif

View File

@ -134,7 +134,7 @@ ReturnValue_t HeaterHandler::executeAction(ActionId_t actionId, MessageQueueId_t
return result;
}
void HeaterHandler::sendSwitchCommand(uint8_t switchNr, ReturnValue_t onOff) const {
ReturnValue_t HeaterHandler::sendSwitchCommand(uint8_t switchNr, ReturnValue_t onOff) {
ReturnValue_t result;
store_address_t storeAddress;
uint8_t commandData[2];
@ -164,6 +164,7 @@ void HeaterHandler::sendSwitchCommand(uint8_t switchNr, ReturnValue_t onOff) con
<< "message" << std::endl;
}
}
return result;
}
void HeaterHandler::handleActiveCommands() {
@ -338,7 +339,9 @@ gpioId_t HeaterHandler::getGpioIdFromSwitchNr(int switchNr) {
MessageQueueId_t HeaterHandler::getCommandQueue() const { return commandQueue->getId(); }
void HeaterHandler::sendFuseOnCommand(uint8_t fuseNr) const {}
ReturnValue_t HeaterHandler::sendFuseOnCommand(uint8_t fuseNr) {
return RETURN_OK;
}
ReturnValue_t HeaterHandler::getSwitchState(uint8_t switchNr) const { return 0; }

View File

@ -43,8 +43,8 @@ class HeaterHandler : public ExecutableObjectIF,
virtual ReturnValue_t performOperation(uint8_t operationCode = 0) override;
virtual void sendSwitchCommand(uint8_t switchNr, ReturnValue_t onOff) const override;
virtual void sendFuseOnCommand(uint8_t fuseNr) const override;
virtual ReturnValue_t sendSwitchCommand(uint8_t switchNr, ReturnValue_t onOff) override;
virtual ReturnValue_t sendFuseOnCommand(uint8_t fuseNr) override;
/**
* @brief This function will be called from the Heater object to check
* the current switch state.

View File

@ -205,7 +205,7 @@ void PCDUHandler::updatePdu1SwitchStates() {
LocalDataPoolManager* PCDUHandler::getHkManagerHandle() { return &poolManager; }
void PCDUHandler::sendSwitchCommand(uint8_t switchNr, ReturnValue_t onOff) const {
ReturnValue_t PCDUHandler::sendSwitchCommand(uint8_t switchNr, ReturnValue_t onOff) {
using namespace pcduSwitches;
ReturnValue_t result;
uint16_t memoryAddress = 0;
@ -261,7 +261,7 @@ void PCDUHandler::sendSwitchCommand(uint8_t switchNr, ReturnValue_t onOff) const
}
// This is a dangerous command. Reject/Igore it for now
case pcduSwitches::PDU2_CH0_Q7S: {
return;
return RETURN_FAILED;
// memoryAddress = PDU2::CONFIG_ADDRESS_OUT_EN_Q7S;
// pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU2_HANDLER);
// break;
@ -309,7 +309,7 @@ void PCDUHandler::sendSwitchCommand(uint8_t switchNr, ReturnValue_t onOff) const
default: {
sif::error << "PCDUHandler::sendSwitchCommand: Invalid switch number " << std::endl;
return;
return RETURN_FAILED;
}
}
@ -322,7 +322,7 @@ void PCDUHandler::sendSwitchCommand(uint8_t switchNr, ReturnValue_t onOff) const
break;
default:
sif::error << "PCDUHandler::sendSwitchCommand: Invalid state commanded" << std::endl;
return;
return RETURN_FAILED;
}
GomspaceSetParamMessage setParamMessage(memoryAddress, &parameterValue, parameterValueSize);
@ -347,9 +347,12 @@ void PCDUHandler::sendSwitchCommand(uint8_t switchNr, ReturnValue_t onOff) const
// 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;
}
void PCDUHandler::sendFuseOnCommand(uint8_t fuseNr) const {}
ReturnValue_t PCDUHandler::sendFuseOnCommand(uint8_t fuseNr) {
return RETURN_OK;
}
ReturnValue_t PCDUHandler::getSwitchState(uint8_t switchNr) const {
if (switchNr >= pcduSwitches::NUMBER_OF_SWITCHES) {

View File

@ -33,8 +33,8 @@ class PCDUHandler : public PowerSwitchIF,
store_address_t storeId = storeId::INVALID_STORE_ADDRESS,
bool* clearMessage = nullptr) override;
virtual void sendSwitchCommand(uint8_t switchNr, ReturnValue_t onOff) const override;
virtual void sendFuseOnCommand(uint8_t fuseNr) const override;
virtual ReturnValue_t sendSwitchCommand(uint8_t switchNr, ReturnValue_t onOff) override;
virtual ReturnValue_t sendFuseOnCommand(uint8_t fuseNr) override;
virtual ReturnValue_t getSwitchState(uint8_t switchNr) const override;
virtual ReturnValue_t getFuseState(uint8_t fuseNr) const override;
virtual uint32_t getSwitchDelayMs(void) const override;

View File

@ -14,197 +14,164 @@
PayloadPcduHandler::PayloadPcduHandler(object_id_t objectId, object_id_t comIF, CookieIF* cookie,
GpioIF* gpioIF, SdCardMountedIF* sdcMan,
bool periodicPrintout)
PowerSwitchIF* pwrSwitcher, power::Switch_t switchA,
power::Switch_t switchB, bool periodicPrintout)
: DeviceHandlerBase(objectId, comIF, cookie),
adcSet(this),
periodicPrintout(periodicPrintout),
gpioIF(gpioIF),
sdcMan(sdcMan) {}
sdcMan(sdcMan),
pwrStateMachine(switchA, switchB, pwrSwitcher) {}
void PayloadPcduHandler::doStartUp() {
if ((state != States::PCDU_OFF) and (state != States::ON_TRANS_SSR)) {
if ((state != States::PL_PCDU_OFF) and (state != States::ON_TRANS_SSR)) {
// Config error
sif::error << "PayloadPcduHandler::doStartUp: Invalid state" << std::endl;
}
if (state == States::PCDU_OFF) {
// Switch on relays here
gpioIF->pullHigh(gpioIds::PLPCDU_ENB_VBAT0);
gpioIF->pullHigh(gpioIds::PLPCDU_ENB_VBAT1);
state = States::ON_TRANS_SSR;
transitionOk = true;
if (pwrStateMachine.getState() == power::States::IDLE) {
pwrStateMachine.start(MODE_ON, pwrSubmode);
}
if (state == States::ON_TRANS_SSR) {
// If necessary, check whether a certain amount of time has elapsed
if (transitionOk) {
transitionOk = false;
state = States::ON_TRANS_ADC_CLOSE_ZERO;
// 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
monMode = MonitoringMode::CLOSE_TO_ZERO;
}
auto opCode = pwrStateMachine.fsm();
if (opCode == power::OpCodes::TO_NOT_OFF_DONE or opCode == power::OpCodes::TIMEOUT_OCCURED) {
pwrStateMachine.reset();
quickTransitionAlreadyCalled = false;
state = States::POWER_CHANNELS_ON;
setMode(_MODE_TO_ON);
}
}
void PayloadPcduHandler::stateMachineToNormal() {
using namespace plpcdu;
if (adcState == AdcStates::BOOT_DELAY) {
if (adcCountdown.hasTimedOut()) {
adcState = AdcStates::SEND_SETUP;
adcCmdExecuted = false;
}
void PayloadPcduHandler::doShutDown() {
if (not quickTransitionAlreadyCalled) {
quickTransitionBackToOff(false, false);
quickTransitionAlreadyCalled = true;
}
if (adcState == AdcStates::SEND_SETUP) {
if (adcCmdExecuted) {
adcState = AdcStates::NORMAL;
setMode(MODE_NORMAL, NORMAL_ADC_ONLY);
adcCountdown.setTimeout(100);
adcCountdown.resetTimer();
adcCmdExecuted = false;
}
if (pwrStateMachine.getState() == power::States::IDLE) {
pwrStateMachine.start(MODE_OFF, 0);
}
if (submode == plpcdu::NORMAL_ALL_ON) {
if (state == States::ON_TRANS_ADC_CLOSE_ZERO) {
if (not commandExecuted) {
float waitTime = DFT_SSR_TO_DRO_WAIT_TIME;
params.getValue(PARAM_KEY_MAP[SSR_TO_DRO_WAIT_TIME], 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 = DFT_DRO_TO_X8_WAIT_TIME;
params.getValue(PARAM_KEY_MAP[DRO_TO_X8_WAIT_TIME], waitTime);
countdown.setTimeout(std::round(waitTime * 1000));
countdown.resetTimer();
#if OBSW_VERBOSE_LEVEL >= 1
sif::info << "Enabling PL PCDU DRO module" << std::endl;
#endif
// 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 = DFT_X8_TO_TX_WAIT_TIME;
params.getValue(PARAM_KEY_MAP[X8_TO_TX_WAIT_TIME], waitTime);
countdown.setTimeout(std::round(waitTime * 1000));
countdown.resetTimer();
#if OBSW_VERBOSE_LEVEL >= 1
sif::info << "Enabling PL PCDU X8 module" << std::endl;
#endif
// 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 = DFT_TX_TO_MPA_WAIT_TIME;
params.getValue(PARAM_KEY_MAP[TX_TO_MPA_WAIT_TIME], waitTime);
countdown.setTimeout(std::round(waitTime * 1000));
countdown.resetTimer();
#if OBSW_VERBOSE_LEVEL >= 1
sif::info << "Enabling PL PCDU TX module" << std::endl;
#endif
// 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 = DFT_MPA_TO_HPA_WAIT_TIME;
params.getValue(PARAM_KEY_MAP[MPA_TO_HPA_WAIT_TIME], waitTime);
countdown.setTimeout(std::round(waitTime * 1000));
countdown.resetTimer();
#if OBSW_VERBOSE_LEVEL >= 1
sif::info << "Enabling PL PCDU MPA module" << std::endl;
#endif
// 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);
#if OBSW_VERBOSE_LEVEL >= 1
sif::info << "Enabling PL PCDU HPA module" << std::endl;
#endif
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;
}
}
auto opCode = pwrStateMachine.fsm();
if (opCode == power::OpCodes::TO_OFF_DONE or opCode == power::OpCodes::TIMEOUT_OCCURED) {
pwrStateMachine.reset();
// No need to set mode _MODE_POWER_DOWN, power switching was already handled
setMode(MODE_OFF);
}
}
void PayloadPcduHandler::doTransition(Mode_t modeFrom, Submode_t subModeFrom) {
if (mode == _MODE_TO_NORMAL) {
stateMachineToNormal();
stateMachineToNormal(modeFrom, subModeFrom);
return;
}
DeviceHandlerBase::doTransition(modeFrom, subModeFrom);
}
void PayloadPcduHandler::doShutDown() { transitionBackToOff(false); }
ReturnValue_t PayloadPcduHandler::stateMachineToNormal(Mode_t modeFrom, Submode_t subModeFrom) {
using namespace plpcdu;
if (submode == NormalSubmodes::SOLID_STATE_RELAYS_ADC_ON) {
if (state == States::PL_PCDU_OFF) {
sif::error << "PayloadPcduHandler::stateMachineToNormal: Unexpected state PL_PCDU_OFF"
<< "detected" << std::endl;
setMode(MODE_OFF);
return HasReturnvaluesIF::RETURN_FAILED;
}
if (state == States::POWER_CHANNELS_ON) {
#if OBSW_VERBOSE_LEVEL >= 1
sif::info << "Switching on SSR VBAT0 & VBAT1 GPIOs" << std::endl;
#endif
// Switch on relays here
gpioIF->pullHigh(gpioIds::PLPCDU_ENB_VBAT0);
gpioIF->pullHigh(gpioIds::PLPCDU_ENB_VBAT1);
state = States::ON_TRANS_SSR;
transitionOk = true;
}
if (state == States::ON_TRANS_SSR) {
// If necessary, check whether a certain amount of time has elapsed
if (transitionOk) {
transitionOk = false;
state = States::ON_TRANS_ADC_CLOSE_ZERO;
adcCountdown.setTimeout(50);
adcCountdown.resetTimer();
adcState = AdcStates::BOOT_DELAY;
// If the values are not close to zero, we should not allow transition
monMode = MonitoringMode::CLOSE_TO_ZERO;
}
}
if (state == States::ON_TRANS_ADC_CLOSE_ZERO) {
if (adcState == AdcStates::BOOT_DELAY) {
if (adcCountdown.hasTimedOut()) {
adcState = AdcStates::SEND_SETUP;
adcCmdExecuted = false;
}
}
if (adcState == AdcStates::SEND_SETUP) {
if (adcCmdExecuted) {
adcState = AdcStates::NORMAL;
adcCountdown.setTimeout(100);
adcCountdown.resetTimer();
adcCmdExecuted = false;
setMode(MODE_NORMAL, submode);
return HasReturnvaluesIF::RETURN_OK;
}
}
}
}
if (submode == NormalSubmodes::DRO_ON) {
#if OBSW_VERBOSE_LEVEL >= 1
sif::info << "Enabling PL PCDU DRO module" << std::endl;
#endif
// Switch on DRO and start monitoring for negative voltages
gpioIF->pullHigh(gpioIds::PLPCDU_ENB_DRO);
adcCountdown.setTimeout(100);
adcCountdown.resetTimer();
setMode(MODE_NORMAL, submode);
}
if (submode == NormalSubmodes::X8_ON) {
#if OBSW_VERBOSE_LEVEL >= 1
sif::info << "Enabling PL PCDU X8 module" << std::endl;
#endif
// Switch on DRO and start monitoring for negative voltages
gpioIF->pullHigh(gpioIds::PLPCDU_ENB_X8);
adcCountdown.setTimeout(100);
adcCountdown.resetTimer();
setMode(MODE_NORMAL, submode);
}
if (submode == NormalSubmodes::TX_ON) {
#if OBSW_VERBOSE_LEVEL >= 1
sif::info << "Enabling PL PCDU TX module" << std::endl;
#endif
// Switch on DRO and start monitoring for negative voltages
gpioIF->pullHigh(gpioIds::PLPCDU_ENB_TX);
adcCountdown.setTimeout(100);
adcCountdown.resetTimer();
setMode(MODE_NORMAL, submode);
}
if (submode == NormalSubmodes::MPA_ON) {
#if OBSW_VERBOSE_LEVEL >= 1
sif::info << "Enabling PL PCDU MPA module" << std::endl;
#endif
// Switch on DRO and start monitoring for negative voltages
gpioIF->pullHigh(gpioIds::PLPCDU_ENB_MPA);
adcCountdown.setTimeout(100);
adcCountdown.resetTimer();
setMode(MODE_NORMAL, submode);
}
if (submode == NormalSubmodes::HPA_ON) {
#if OBSW_VERBOSE_LEVEL >= 1
sif::info << "Enabling PL PCDU HPA module" << std::endl;
#endif
// Switch on DRO and start monitoring for negative voltages
gpioIF->pullHigh(gpioIds::PLPCDU_ENB_HPA);
adcCountdown.setTimeout(100);
adcCountdown.resetTimer();
setMode(MODE_NORMAL, submode);
}
return RETURN_OK;
}
ReturnValue_t PayloadPcduHandler::buildNormalDeviceCommand(DeviceCommandId_t* id) {
switch (adcState) {
@ -388,7 +355,7 @@ void PayloadPcduHandler::enablePeriodicPrintout(bool enable, uint8_t divider) {
opDivider.setDivider(divider);
}
void PayloadPcduHandler::transitionBackToOff(bool notifyFdir) {
void PayloadPcduHandler::quickTransitionBackToOff(bool startTransitionToOff, bool notifyFdir) {
States currentState = state;
gpioIF->pullLow(gpioIds::PLPCDU_ENB_HPA);
gpioIF->pullLow(gpioIds::PLPCDU_ENB_MPA);
@ -398,9 +365,11 @@ void PayloadPcduHandler::transitionBackToOff(bool notifyFdir) {
gpioIF->pullLow(gpioIds::PLPCDU_ENB_TX);
gpioIF->pullLow(gpioIds::PLPCDU_ENB_VBAT0);
gpioIF->pullLow(gpioIds::PLPCDU_ENB_VBAT1);
state = States::PCDU_OFF;
state = States::PL_PCDU_OFF;
adcState = AdcStates::OFF;
setMode(MODE_OFF);
if (startTransitionToOff) {
startTransition(MODE_OFF, 0);
}
if (notifyFdir) {
triggerEvent(TRANSITION_BACK_TO_OFF, static_cast<uint32_t>(currentState));
}
@ -556,7 +525,8 @@ bool PayloadPcduHandler::checkVoltage(float val, float lowerBound, float upperBo
serializeFloat(p2, val);
triggerEvent(event, tooLarge, p2);
transitionOk = false;
transitionBackToOff(true);
quickTransitionBackToOff(true, true);
quickTransitionAlreadyCalled = true;
return false;
}
return true;
@ -568,14 +538,37 @@ bool PayloadPcduHandler::checkCurrent(float val, float upperBound, Event event)
serializeFloat(p2, val);
triggerEvent(event, true, p2);
transitionOk = false;
transitionBackToOff(true);
quickTransitionBackToOff(true, true);
quickTransitionAlreadyCalled = true;
return false;
}
return true;
}
ReturnValue_t PayloadPcduHandler::isModeCombinationValid(Mode_t mode, Submode_t submode) {
if (mode == MODE_NORMAL and submode <= 1) {
using namespace plpcdu;
if (mode == MODE_NORMAL) {
// Also deals with the case where the mode is MODE_ON, submode should be 0 here
if (submode == NormalSubmodes::SOLID_STATE_RELAYS_ADC_ON and
(this->mode == MODE_NORMAL and this->submode != NormalSubmodes::ALL_OFF)) {
return TRANS_NOT_ALLOWED;
}
if ((submode == NormalSubmodes::DRO_ON and
this->submode != NormalSubmodes::SOLID_STATE_RELAYS_ADC_ON)) {
return TRANS_NOT_ALLOWED;
}
if ((submode == NormalSubmodes::X8_ON and this->submode != NormalSubmodes::DRO_ON)) {
return TRANS_NOT_ALLOWED;
}
if ((submode == NormalSubmodes::TX_ON and this->submode != NormalSubmodes::X8_ON)) {
return TRANS_NOT_ALLOWED;
}
if ((submode == NormalSubmodes::MPA_ON and this->submode != NormalSubmodes::TX_ON)) {
return TRANS_NOT_ALLOWED;
}
if ((submode == NormalSubmodes::HPA_ON and this->submode != NormalSubmodes::MPA_ON)) {
return TRANS_NOT_ALLOWED;
}
return HasReturnvaluesIF::RETURN_OK;
}
return DeviceHandlerBase::isModeCombinationValid(mode, submode);
@ -658,7 +651,8 @@ void PayloadPcduHandler::handleFailureInjection(std::string output, Event event)
<< std::endl;
triggerEvent(event, 0, 0);
transitionOk = false;
transitionBackToOff(true);
quickTransitionBackToOff(true, true);
quickTransitionAlreadyCalled = true;
droToX8InjectionRequested = false;
}

View File

@ -10,6 +10,8 @@
#include "fsfw_hal/common/gpio/GpioIF.h"
#include "mission/devices/devicedefinitions/payloadPcduDefinitions.h"
#include "mission/memory/SdCardMountedIF.h"
#include "mission/system/DualLanePowerStateMachine.h"
#include "mission/system/definitions.h"
#ifdef FSFW_OSAL_LINUX
class SpiComIF;
@ -60,7 +62,8 @@ class PayloadPcduHandler : public DeviceHandlerBase {
static constexpr Event I_HPA_OUT_OF_BOUNDS = event::makeEvent(SUBSYSTEM_ID, 11, severity::MEDIUM);
PayloadPcduHandler(object_id_t objectId, object_id_t comIF, CookieIF* cookie, GpioIF* gpioIF,
SdCardMountedIF* sdcMan, bool periodicPrintout);
SdCardMountedIF* sdcMan, PowerSwitchIF* pwrSwitcher, power::Switch_t switchCh0,
power::Switch_t switchCh1, bool periodicPrintout);
void setToGoToNormalModeImmediately(bool enable);
void enablePeriodicPrintout(bool enable, uint8_t divider);
@ -75,7 +78,8 @@ class PayloadPcduHandler : public DeviceHandlerBase {
private:
enum class States : uint8_t {
PCDU_OFF,
PL_PCDU_OFF,
POWER_CHANNELS_ON,
// Solid State Relay, enable battery voltages VBAT0 and VBAT1. This will also switch on
// the ADC
ON_TRANS_SSR,
@ -92,8 +96,10 @@ class PayloadPcduHandler : public DeviceHandlerBase {
// Switch on HPA component and monitor voltages for 5 seconds
ON_TRANS_HPA,
// All components of the experiment are on
PCDU_ON,
} state = States::PCDU_OFF;
PL_PCDU_ON,
} state = States::PL_PCDU_OFF;
duallane::Submodes pwrSubmode = duallane::Submodes::A_SIDE;
enum class AdcMode { EXT_CONV, INT_CONV } adcMode = AdcMode::INT_CONV;
@ -127,17 +133,19 @@ class PayloadPcduHandler : public DeviceHandlerBase {
GpioIF* gpioIF;
SdCardMountedIF* sdcMan;
plpcdu::PlPcduParameter params;
bool quickTransitionAlreadyCalled = true;
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});
DualLanePowerStateMachine pwrStateMachine;
void doTransition(Mode_t modeFrom, Submode_t subModeFrom) override;
void doStartUp() override;
void doShutDown() override;
// Main FDIR function which goes from any PL PCDU state back to all off
void transitionBackToOff(bool notifyFdir);
void quickTransitionBackToOff(bool startTransitionToOff, bool notifyFdir);
ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t* id) override;
ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t* id) override;
void fillCommandAndReplyMap() override;
@ -158,7 +166,7 @@ class PayloadPcduHandler : public DeviceHandlerBase {
void checkAdcValues();
void handleOutOfBoundsPrintout();
void checkJsonFileInit();
void stateMachineToNormal();
ReturnValue_t stateMachineToNormal(Mode_t modeFrom, Submode_t subModeFrom);
bool checkVoltage(float val, float lowerBound, float upperBound, Event event);
bool checkCurrent(float val, float upperBound, Event event);
void handleFailureInjection(std::string output, Event event);

View File

@ -91,8 +91,15 @@ static constexpr DeviceCommandId_t SETUP_CMD = 1;
static constexpr DeviceCommandId_t READ_TEMP_EXT = 2;
static constexpr DeviceCommandId_t READ_WITH_TEMP_EXT = 3;
static constexpr Submode_t NORMAL_ADC_ONLY = 0;
static constexpr Submode_t NORMAL_ALL_ON = 1;
enum NormalSubmodes {
ALL_OFF = 0,
SOLID_STATE_RELAYS_ADC_ON = 1,
DRO_ON = 2,
X8_ON = 3,
TX_ON = 4,
MPA_ON = 5,
HPA_ON = 6
};
// 12 ADC values * 2 + trailing zero
static constexpr size_t ADC_REPLY_SIZE = 25;

View File

@ -3,8 +3,8 @@
#include <fsfw/devicehandlers/AssemblyBase.h>
#include <fsfw/power/PowerSwitchIF.h>
DualLanePowerStateMachine::DualLanePowerStateMachine(pcduSwitches::Switches switchA,
pcduSwitches::Switches switchB,
DualLanePowerStateMachine::DualLanePowerStateMachine(power::Switch_t switchA,
power::Switch_t switchB,
PowerSwitchIF* pwrSwitcher,
dur_millis_t checkTimeout)
: PowerStateMachineBase(pwrSwitcher, checkTimeout), SWITCH_A(switchA), SWITCH_B(switchB) {}

View File

@ -12,12 +12,12 @@ class PowerSwitchIF;
class DualLanePowerStateMachine : public PowerStateMachineBase {
public:
DualLanePowerStateMachine(pcduSwitches::Switches switchA, pcduSwitches::Switches switchB,
DualLanePowerStateMachine(power::Switch_t switchA, power::Switch_t switchB,
PowerSwitchIF* pwrSwitcher, dur_millis_t checkTimeout = 5000);
power::OpCodes fsm() override;
const pcduSwitches::Switches SWITCH_A;
const pcduSwitches::Switches SWITCH_B;
const power::Switch_t SWITCH_A;
const power::Switch_t SWITCH_B;
private:
};

View File

@ -1 +0,0 @@
#include "PlPcduAssembly.h"

View File

@ -1,4 +0,0 @@
#ifndef MISSION_SYSTEM_PLPCDUASSEMBLY_H_
#define MISSION_SYSTEM_PLPCDUASSEMBLY_H_
#endif /* MISSION_SYSTEM_PLPCDUASSEMBLY_H_ */