eive/eive-obsw
eive/eive-obsw
13
4
Fork 0
Code Issues 4 Pull Requests 1 Releases 120 Wiki Activity

this should fix some bugs

Browse Source
This commit is contained in:
Robin Müller 2023-04-04 16:46:07 +02:00
parent 677457bbe7
commit 8d4b980c32
No known key found for this signature in database
GPG Key ID: 11D4952C8CCEF814
4 changed files with 89 additions and 127 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
bsp_q7s/core/scheduling.cpp
View File

@ -538,7 +538,7 @@ void scheduling::createPstTasks(TaskFactory& factory, TaskDeadlineMissedFunction
FixedTimeslotTaskIF* gomSpacePstTask = FixedTimeslotTaskIF* gomSpacePstTask =
factory.createFixedTimeslotTask("GS_PST_TASK", 65, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, factory.createFixedTimeslotTask("GS_PST_TASK", 65, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4,
0.5, missedDeadlineFunc, &RR_SCHEDULING); 0.25, missedDeadlineFunc, &RR_SCHEDULING);
result = pst::pstGompaceCan(gomSpacePstTask); result = pst::pstGompaceCan(gomSpacePstTask);
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
if (result != FixedTimeslotTaskIF::SLOT_LIST_EMPTY) { if (result != FixedTimeslotTaskIF::SLOT_LIST_EMPTY) {

135
mission/com/SyrlinksHandler.cpp
View File

@ -21,15 +21,14 @@ SyrlinksHandler::~SyrlinksHandler() = default;
void SyrlinksHandler::doStartUp() { void SyrlinksHandler::doStartUp() {
if (internalState == InternalState::OFF) { if (internalState == InternalState::OFF) {
transitionCommandPending = false;
internalState = InternalState::ENABLE_TEMPERATURE_PROTECTION; internalState = InternalState::ENABLE_TEMPERATURE_PROTECTION;
commandExecuted = false; commandExecuted = false;
} }
if (internalState == InternalState::ENABLE_TEMPERATURE_PROTECTION) { if (internalState == InternalState::ENABLE_TEMPERATURE_PROTECTION) {
if (commandExecuted) { if (commandExecuted) {
// Go to normal mode immediately and disable transmitter on startup. // Go to normal mode immediately and disable transmitter on startup.
setMode(_MODE_TO_NORMAL); setMode(_MODE_TO_ON);
internalState = InternalState::IDLE; internalState = InternalState::TX_TRANSITION;
commandExecuted = false; commandExecuted = false;
} }
} }
@ -37,15 +36,16 @@ void SyrlinksHandler::doStartUp() {
void SyrlinksHandler::doShutDown() { void SyrlinksHandler::doShutDown() {
// In any case, always disable TX first. // In any case, always disable TX first.
if (internalState != InternalState::SET_TX_STANDBY) { if (internalState != InternalState::TX_TRANSITION) {
internalState = InternalState::SET_TX_STANDBY; internalState = InternalState::TX_TRANSITION;
transitionCommandPending = false; transState = TransitionState::SET_TX_STANDBY;
commandExecuted = false; commandExecuted = false;
} }
if (internalState == InternalState::SET_TX_STANDBY) { if (internalState == InternalState::TX_TRANSITION) {
if (commandExecuted) { if (commandExecuted) {
temperatureSet.setValidity(false, true); temperatureSet.setValidity(false, true);
internalState = InternalState::OFF; internalState = InternalState::OFF;
transState = TransitionState::IDLE;
commandExecuted = false; commandExecuted = false;
setMode(_MODE_POWER_DOWN); setMode(_MODE_POWER_DOWN);
} }
@ -104,23 +104,25 @@ ReturnValue_t SyrlinksHandler::buildTransitionDeviceCommand(DeviceCommandId_t* i
*id = syrlinks::WRITE_LCL_CONFIG; *id = syrlinks::WRITE_LCL_CONFIG;
return buildCommandFromCommand(*id, nullptr, 0); return buildCommandFromCommand(*id, nullptr, 0);
} }
case InternalState::SET_TX_MODULATION: { case InternalState::TX_TRANSITION: {
switch (transState) {
case TransitionState::SET_TX_MODULATION: {
*id = syrlinks::SET_TX_MODE_MODULATION; *id = syrlinks::SET_TX_MODE_MODULATION;
return buildCommandFromCommand(*id, nullptr, 0); return buildCommandFromCommand(*id, nullptr, 0);
} }
case InternalState::SELECT_MODULATION_BPSK: { case TransitionState::SELECT_MODULATION_BPSK: {
*id = syrlinks::SET_WAVEFORM_BPSK; *id = syrlinks::SET_WAVEFORM_BPSK;
return buildCommandFromCommand(*id, nullptr, 0); return buildCommandFromCommand(*id, nullptr, 0);
} }
case InternalState::SELECT_MODULATION_0QPSK: { case TransitionState::SELECT_MODULATION_0QPSK: {
*id = syrlinks::SET_WAVEFORM_0QPSK; *id = syrlinks::SET_WAVEFORM_0QPSK;
return buildCommandFromCommand(*id, nullptr, 0); return buildCommandFromCommand(*id, nullptr, 0);
} }
case InternalState::SET_TX_CW: { case TransitionState::SET_TX_CW: {
*id = syrlinks::SET_TX_MODE_CW; *id = syrlinks::SET_TX_MODE_CW;
return buildCommandFromCommand(*id, nullptr, 0); return buildCommandFromCommand(*id, nullptr, 0);
} }
case InternalState::SET_TX_STANDBY: { case TransitionState::SET_TX_STANDBY: {
*id = syrlinks::SET_TX_MODE_STANDBY; *id = syrlinks::SET_TX_MODE_STANDBY;
return buildCommandFromCommand(*id, nullptr, 0); return buildCommandFromCommand(*id, nullptr, 0);
} }
@ -128,6 +130,11 @@ ReturnValue_t SyrlinksHandler::buildTransitionDeviceCommand(DeviceCommandId_t* i
break; break;
} }
} }
}
default: {
break;
}
}
return NOTHING_TO_SEND; return NOTHING_TO_SEND;
} }
@ -675,12 +682,31 @@ ReturnValue_t SyrlinksHandler::handleAckReply(const uint8_t* packet) {
break; break;
} }
case (syrlinks::SET_WAVEFORM_BPSK): case (syrlinks::SET_WAVEFORM_BPSK):
case (syrlinks::SET_WAVEFORM_0QPSK): case (syrlinks::SET_WAVEFORM_0QPSK): {
case (syrlinks::SET_TX_MODE_STANDBY): if (result == returnvalue::OK and isTransitionalMode()) {
case (syrlinks::SET_TX_MODE_MODULATION): transState = TransitionState::SET_TX_MODULATION;
commandExecuted = true;
}
break;
}
case (syrlinks::SET_TX_MODE_STANDBY): {
if (result == returnvalue::OK and isTransitionalMode()) {
transState = TransitionState::DONE;
commandExecuted = true;
}
break;
}
case (syrlinks::SET_TX_MODE_MODULATION): {
if (result == returnvalue::OK and isTransitionalMode()) {
transState = TransitionState::DONE;
commandExecuted = true;
}
break;
}
case (syrlinks::SET_TX_MODE_CW): { case (syrlinks::SET_TX_MODE_CW): {
if (result == returnvalue::OK and isTransitionalMode()) { if (result == returnvalue::OK and isTransitionalMode()) {
commandExecuted = true; commandExecuted = true;
transState = TransitionState::DONE;
} }
break; break;
} }
@ -731,77 +757,41 @@ void SyrlinksHandler::setDebugMode(bool enable) { this->debugMode = enable; }
void SyrlinksHandler::doTransition(Mode_t modeFrom, Submode_t subModeFrom) { void SyrlinksHandler::doTransition(Mode_t modeFrom, Submode_t subModeFrom) {
Mode_t tgtMode = getBaseMode(getMode()); Mode_t tgtMode = getBaseMode(getMode());
auto commandDone = [&]() { if (transState == TransitionState::DONE) {
setMode(tgtMode); setMode(tgtMode);
transitionCommandPending = false;
internalState = InternalState::IDLE; internalState = InternalState::IDLE;
}; transState = TransitionState::IDLE;
auto txOnHandler = [&](InternalState selMod) { return;
txDataset.setReportingEnabled(true);
poolManager.changeCollectionInterval(txDataset.getSid(), 10.0);
poolManager.changeCollectionInterval(temperatureSet.getSid(), 5.0);
if (internalState == InternalState::IDLE) {
transitionCommandPending = false;
commandExecuted = false;
internalState = selMod;
} }
// Select modulation first (BPSK or 0QPSK).
if (internalState == selMod) {
if (commandExecuted) {
transitionCommandPending = false;
internalState = InternalState::SET_TX_MODULATION;
commandExecuted = false;
}
}
// Now go into modulation mode.
if (internalState == InternalState::SET_TX_MODULATION) {
if (commandExecuted) {
commandDone();
return true;
}
}
return false;
};
auto txStandbyHandler = [&]() { auto txStandbyHandler = [&]() {
txDataset.setReportingEnabled(false); txDataset.setReportingEnabled(false);
poolManager.changeCollectionInterval(temperatureSet.getSid(), 60.0); poolManager.changeCollectionInterval(temperatureSet.getSid(), 60.0);
if (internalState == InternalState::IDLE) { };
transitionCommandPending = false; auto txOnHandler = [&]() {
internalState = InternalState::SET_TX_STANDBY; txDataset.setReportingEnabled(true);
commandExecuted = false; poolManager.changeCollectionInterval(txDataset.getSid(), 10.0);
} poolManager.changeCollectionInterval(temperatureSet.getSid(), 5.0);
if (internalState == InternalState::SET_TX_STANDBY) {
if (commandExecuted) {
commandDone();
return;
}
}
}; };
if (tgtMode == HasModesIF::MODE_ON or tgtMode == DeviceHandlerIF::MODE_NORMAL) { if (tgtMode == HasModesIF::MODE_ON or tgtMode == DeviceHandlerIF::MODE_NORMAL) {
switch (getSubmode()) { switch (getSubmode()) {
case (com::Submode::RX_AND_TX_DEFAULT_DATARATE): { case (com::Submode::RX_AND_TX_DEFAULT_DATARATE): {
auto currentDatarate = com::getCurrentDatarate(); auto currentDatarate = com::getCurrentDatarate();
txOnHandler();
if (currentDatarate == com::Datarate::LOW_RATE_MODULATION_BPSK) { if (currentDatarate == com::Datarate::LOW_RATE_MODULATION_BPSK) {
if (txOnHandler(InternalState::SELECT_MODULATION_BPSK)) { transState = TransitionState::SELECT_MODULATION_BPSK;
return;
}
} else if (currentDatarate == com::Datarate::HIGH_RATE_MODULATION_0QPSK) { } else if (currentDatarate == com::Datarate::HIGH_RATE_MODULATION_0QPSK) {
if (txOnHandler(InternalState::SELECT_MODULATION_0QPSK)) { transState = TransitionState::SELECT_MODULATION_0QPSK;
return;
}
} }
break; break;
} }
case (com::Submode::RX_AND_TX_LOW_DATARATE): { case (com::Submode::RX_AND_TX_LOW_DATARATE): {
if (txOnHandler(InternalState::SELECT_MODULATION_BPSK)) { txOnHandler();
return; transState = TransitionState::SELECT_MODULATION_BPSK;
}
break; break;
} }
case (com::Submode::RX_AND_TX_HIGH_DATARATE): { case (com::Submode::RX_AND_TX_HIGH_DATARATE): {
if (txOnHandler(InternalState::SELECT_MODULATION_0QPSK)) { txOnHandler();
return; transState = TransitionState::SELECT_MODULATION_0QPSK;
}
break; break;
} }
case (com::Submode::RX_ONLY): { case (com::Submode::RX_ONLY): {
@ -809,21 +799,16 @@ void SyrlinksHandler::doTransition(Mode_t modeFrom, Submode_t subModeFrom) {
return; return;
} }
case (com::Submode::RX_AND_TX_CW): { case (com::Submode::RX_AND_TX_CW): {
if (internalState == InternalState::IDLE) { txOnHandler();
internalState = InternalState::SET_TX_STANDBY; transState = TransitionState::SET_TX_CW;
commandExecuted = false;
}
if (commandExecuted) {
commandDone();
return;
}
break; break;
} }
default: { default: {
commandDone(); DeviceHandlerBase::doTransition(modeFrom, subModeFrom);
} }
} }
} else if (tgtMode == HasModesIF::MODE_OFF) { } else if (tgtMode == HasModesIF::MODE_OFF) {
txStandbyHandler(); txStandbyHandler();
transState = TransitionState::SET_TX_STANDBY;
} }
} }

13
mission/com/SyrlinksHandler.h
View File

@ -112,22 +112,25 @@ class SyrlinksHandler : public DeviceHandlerBase {
float tempPowerAmplifier = 0; float tempPowerAmplifier = 0;
float tempBasebandBoard = 0; float tempBasebandBoard = 0;
bool commandExecuted = false; bool commandExecuted = false;
bool transitionCommandPending = false;
uint8_t commandBuffer[syrlinks::MAX_COMMAND_SIZE]; uint8_t commandBuffer[syrlinks::MAX_COMMAND_SIZE];
enum class InternalState { enum class InternalState {
OFF, OFF,
ENABLE_TEMPERATURE_PROTECTION, ENABLE_TEMPERATURE_PROTECTION,
TX_TRANSITION,
IDLE
} internalState = InternalState::OFF;
enum class TransitionState {
IDLE,
SELECT_MODULATION_BPSK, SELECT_MODULATION_BPSK,
SELECT_MODULATION_0QPSK, SELECT_MODULATION_0QPSK,
SET_TX_MODULATION, SET_TX_MODULATION,
SET_TX_CW, SET_TX_CW,
SET_TX_STANDBY, SET_TX_STANDBY,
IDLE DONE
}; } transState = TransitionState::IDLE;
InternalState internalState = InternalState::OFF;
/** /**
* This object is used to store the id of the next command to execute. This controls the * This object is used to store the id of the next command to execute. This controls the

36
mission/pollingSeqTables.cpp
View File

@ -26,8 +26,7 @@ ReturnValue_t pst::pstSyrlinks(FixedTimeslotTaskIF *thisSequence) {
thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE); thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0.25, DeviceHandlerIF::SEND_READ); thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0.25, DeviceHandlerIF::SEND_READ);
thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0.25, DeviceHandlerIF::GET_READ); thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0.25, DeviceHandlerIF::GET_READ);
thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0.4,
DeviceHandlerIF::PERFORM_OPERATION);
thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0.4, DeviceHandlerIF::SEND_WRITE); thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0.4, DeviceHandlerIF::SEND_WRITE);
thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE); thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE);
thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0.75, DeviceHandlerIF::SEND_READ); thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0.75, DeviceHandlerIF::SEND_READ);
@ -119,35 +118,10 @@ ReturnValue_t pst::pstGompaceCan(FixedTimeslotTaskIF *thisSequence) {
thisSequence->addSlot(objects::PDU2_HANDLER, length * 0.25, DeviceHandlerIF::SEND_READ); thisSequence->addSlot(objects::PDU2_HANDLER, length * 0.25, DeviceHandlerIF::SEND_READ);
thisSequence->addSlot(objects::ACU_HANDLER, length * 0.25, DeviceHandlerIF::SEND_READ); thisSequence->addSlot(objects::ACU_HANDLER, length * 0.25, DeviceHandlerIF::SEND_READ);
thisSequence->addSlot(objects::P60DOCK_HANDLER, length * 0.25, DeviceHandlerIF::GET_READ); thisSequence->addSlot(objects::P60DOCK_HANDLER, length * 0.5, DeviceHandlerIF::GET_READ);
thisSequence->addSlot(objects::PDU1_HANDLER, length * 0.25, DeviceHandlerIF::GET_READ); thisSequence->addSlot(objects::PDU1_HANDLER, length * 0.5, DeviceHandlerIF::GET_READ);
thisSequence->addSlot(objects::PDU2_HANDLER, length * 0.25, DeviceHandlerIF::GET_READ); thisSequence->addSlot(objects::PDU2_HANDLER, length * 0.5, DeviceHandlerIF::GET_READ);
thisSequence->addSlot(objects::ACU_HANDLER, length * 0.25, DeviceHandlerIF::GET_READ); thisSequence->addSlot(objects::ACU_HANDLER, length * 0.5, DeviceHandlerIF::GET_READ);
thisSequence->addSlot(objects::P60DOCK_HANDLER, length * 0.5, DeviceHandlerIF::PERFORM_OPERATION);
thisSequence->addSlot(objects::PDU1_HANDLER, length * 0.5, DeviceHandlerIF::PERFORM_OPERATION);
thisSequence->addSlot(objects::PDU2_HANDLER, length * 0.5, DeviceHandlerIF::PERFORM_OPERATION);
thisSequence->addSlot(objects::ACU_HANDLER, length * 0.5, DeviceHandlerIF::PERFORM_OPERATION);
thisSequence->addSlot(objects::P60DOCK_HANDLER, length * 0.5, DeviceHandlerIF::SEND_WRITE);
thisSequence->addSlot(objects::PDU1_HANDLER, length * 0.5, DeviceHandlerIF::SEND_WRITE);
thisSequence->addSlot(objects::PDU2_HANDLER, length * 0.5, DeviceHandlerIF::SEND_WRITE);
thisSequence->addSlot(objects::ACU_HANDLER, length * 0.5, DeviceHandlerIF::SEND_WRITE);
thisSequence->addSlot(objects::P60DOCK_HANDLER, length * 0.5, DeviceHandlerIF::GET_WRITE);
thisSequence->addSlot(objects::PDU1_HANDLER, length * 0.5, DeviceHandlerIF::GET_WRITE);
thisSequence->addSlot(objects::PDU2_HANDLER, length * 0.5, DeviceHandlerIF::GET_WRITE);
thisSequence->addSlot(objects::ACU_HANDLER, length * 0.5, DeviceHandlerIF::GET_WRITE);
thisSequence->addSlot(objects::P60DOCK_HANDLER, length * 0.75, DeviceHandlerIF::SEND_READ);
thisSequence->addSlot(objects::PDU1_HANDLER, length * 0.75, DeviceHandlerIF::SEND_READ);
thisSequence->addSlot(objects::PDU2_HANDLER, length * 0.75, DeviceHandlerIF::SEND_READ);
thisSequence->addSlot(objects::ACU_HANDLER, length * 0.75, DeviceHandlerIF::SEND_READ);
thisSequence->addSlot(objects::P60DOCK_HANDLER, length * 0.75, DeviceHandlerIF::GET_READ);
thisSequence->addSlot(objects::PDU1_HANDLER, length * 0.75, DeviceHandlerIF::GET_READ);
thisSequence->addSlot(objects::PDU2_HANDLER, length * 0.75, DeviceHandlerIF::GET_READ);
thisSequence->addSlot(objects::ACU_HANDLER, length * 0.75, DeviceHandlerIF::GET_READ);
if (thisSequence->checkSequence() != returnvalue::OK) { if (thisSequence->checkSequence() != returnvalue::OK) {
sif::error << "GomSpace PST initialization failed" << std::endl; sif::error << "GomSpace PST initialization failed" << std::endl;
return returnvalue::FAILED; return returnvalue::FAILED;