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

5V stack commanding for device handlers #335

Merged
meierj merged 30 commits from mueller_5v_stack_cmd_for_devices into develop 2023-01-10 15:49:10 +01:00
Conversation 1 Commits 30 Files Changed 16 +48 -66
9 changed files with 48 additions and 66 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit 8d0448341b - Show all commits

4
CHANGELOG.md
View File

@ -10,6 +10,10 @@ list yields a list of all related PRs for each release.
# [unreleased] # [unreleased]
## Fixed
- PLOC SUPV: Minor adaptions and important bugfix for UART manager
## Added ## Added
- First version of ACS controller - First version of ACS controller

2
linux/devices/devicedefinitions/PlocMPSoCDefinitions.h
View File

@ -152,7 +152,7 @@ class TcBase : public ploc::SpTcBase, public MPSoCReturnValuesIF {
* sent and received packets. * sent and received packets.
*/ */
TcBase(ploc::SpTcParams params, uint16_t apid, uint16_t sequenceCount) TcBase(ploc::SpTcParams params, uint16_t apid, uint16_t sequenceCount)
: ploc::SpTcBase(params, apid, sequenceCount) { : ploc::SpTcBase(params, apid, 0, sequenceCount) {
spParams.setFullPayloadLen(INIT_LENGTH); spParams.setFullPayloadLen(INIT_LENGTH);
} }

10
linux/devices/devicedefinitions/PlocSupervisorDefinitions.h
View File

@ -730,17 +730,13 @@ class FactoryReset : public TcBase {
: TcBase(params, Apid::DATA_LOGGER, : TcBase(params, Apid::DATA_LOGGER,
static_cast<uint8_t>(tc::DataLoggerServiceId::FACTORY_RESET), 0) {} static_cast<uint8_t>(tc::DataLoggerServiceId::FACTORY_RESET), 0) {}
ReturnValue_t buildPacket(std::optional<uint8_t> op) { ReturnValue_t buildPacket(uint8_t op) {
if (op) { setLenFromPayloadLen(1);
setLenFromPayloadLen(1);
}
auto res = checkSizeAndSerializeHeader(); auto res = checkSizeAndSerializeHeader();
if (res != returnvalue::OK) { if (res != returnvalue::OK) {
return res; return res;
} }
if (op) { payloadStart[0] = op;
payloadStart[0] = op.value();
}
return calcAndSetCrc(); return calcAndSetCrc();
} }

26
linux/devices/ploc/PlocMPSoCHandler.cpp
View File

@ -184,12 +184,14 @@ void PlocMPSoCHandler::doShutDown() {
powerState = PowerState::SHUTDOWN; powerState = PowerState::SHUTDOWN;
break; break;
case PowerState::OFF: case PowerState::OFF:
sequenceCount = 0;
setMode(_MODE_POWER_DOWN); setMode(_MODE_POWER_DOWN);
break; break;
default: default:
break; break;
} }
#else #else
sequenceCount = 0;
uartIsolatorSwitch.pullLow(); uartIsolatorSwitch.pullLow();
setMode(_MODE_POWER_DOWN); setMode(_MODE_POWER_DOWN);
powerState = PowerState::OFF; powerState = PowerState::OFF;
@ -340,7 +342,6 @@ ReturnValue_t PlocMPSoCHandler::scanForReply(const uint8_t* start, size_t remain
} }
} }
sequenceCount++;
uint16_t recvSeqCnt = (*(start + 2) << 8 | *(start + 3)) & PACKET_SEQUENCE_COUNT_MASK; uint16_t recvSeqCnt = (*(start + 2) << 8 | *(start + 3)) & PACKET_SEQUENCE_COUNT_MASK;
if (recvSeqCnt != sequenceCount) { if (recvSeqCnt != sequenceCount) {
triggerEvent(MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH, sequenceCount, recvSeqCnt); triggerEvent(MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH, sequenceCount, recvSeqCnt);
@ -403,11 +404,9 @@ void PlocMPSoCHandler::handleEvent(EventMessage* eventMessage) {
ReturnValue_t PlocMPSoCHandler::prepareTcMemWrite(const uint8_t* commandData, ReturnValue_t PlocMPSoCHandler::prepareTcMemWrite(const uint8_t* commandData,
size_t commandDataLen) { size_t commandDataLen) {
ReturnValue_t result = returnvalue::OK; ReturnValue_t result = returnvalue::OK;
sequenceCount++;
mpsoc::TcMemWrite tcMemWrite(spParams, sequenceCount); mpsoc::TcMemWrite tcMemWrite(spParams, sequenceCount);
result = tcMemWrite.buildPacket(commandData, commandDataLen); result = tcMemWrite.buildPacket(commandData, commandDataLen);
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
sequenceCount--;
return result; return result;
} }
finishTcPrep(tcMemWrite.getFullPacketLen()); finishTcPrep(tcMemWrite.getFullPacketLen());
@ -417,11 +416,9 @@ ReturnValue_t PlocMPSoCHandler::prepareTcMemWrite(const uint8_t* commandData,
ReturnValue_t PlocMPSoCHandler::prepareTcMemRead(const uint8_t* commandData, ReturnValue_t PlocMPSoCHandler::prepareTcMemRead(const uint8_t* commandData,
size_t commandDataLen) { size_t commandDataLen) {
ReturnValue_t result = returnvalue::OK; ReturnValue_t result = returnvalue::OK;
sequenceCount++;
mpsoc::TcMemRead tcMemRead(spParams, sequenceCount); mpsoc::TcMemRead tcMemRead(spParams, sequenceCount);
result = tcMemRead.buildPacket(commandData, commandDataLen); result = tcMemRead.buildPacket(commandData, commandDataLen);
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
sequenceCount--;
return result; return result;
} }
finishTcPrep(tcMemRead.getFullPacketLen()); finishTcPrep(tcMemRead.getFullPacketLen());
@ -435,12 +432,10 @@ ReturnValue_t PlocMPSoCHandler::prepareTcFlashDelete(const uint8_t* commandData,
return MPSoCReturnValuesIF::NAME_TOO_LONG; return MPSoCReturnValuesIF::NAME_TOO_LONG;
} }
ReturnValue_t result = returnvalue::OK; ReturnValue_t result = returnvalue::OK;
sequenceCount++;
mpsoc::TcFlashDelete tcFlashDelete(spParams, sequenceCount); mpsoc::TcFlashDelete tcFlashDelete(spParams, sequenceCount);
result = tcFlashDelete.buildPacket( result = tcFlashDelete.buildPacket(
std::string(reinterpret_cast<const char*>(commandData), commandDataLen)); std::string(reinterpret_cast<const char*>(commandData), commandDataLen));
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
sequenceCount--;
return result; return result;
} }
finishTcPrep(tcFlashDelete.getFullPacketLen()); finishTcPrep(tcFlashDelete.getFullPacketLen());
@ -450,11 +445,9 @@ ReturnValue_t PlocMPSoCHandler::prepareTcFlashDelete(const uint8_t* commandData,
ReturnValue_t PlocMPSoCHandler::prepareTcReplayStart(const uint8_t* commandData, ReturnValue_t PlocMPSoCHandler::prepareTcReplayStart(const uint8_t* commandData,
size_t commandDataLen) { size_t commandDataLen) {
ReturnValue_t result = returnvalue::OK; ReturnValue_t result = returnvalue::OK;
sequenceCount++;
mpsoc::TcReplayStart tcReplayStart(spParams, sequenceCount); mpsoc::TcReplayStart tcReplayStart(spParams, sequenceCount);
result = tcReplayStart.buildPacket(commandData, commandDataLen); result = tcReplayStart.buildPacket(commandData, commandDataLen);
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
sequenceCount--;
return result; return result;
} }
finishTcPrep(tcReplayStart.getFullPacketLen()); finishTcPrep(tcReplayStart.getFullPacketLen());
@ -463,11 +456,9 @@ ReturnValue_t PlocMPSoCHandler::prepareTcReplayStart(const uint8_t* commandData,
ReturnValue_t PlocMPSoCHandler::prepareTcReplayStop() { ReturnValue_t PlocMPSoCHandler::prepareTcReplayStop() {
ReturnValue_t result = returnvalue::OK; ReturnValue_t result = returnvalue::OK;
sequenceCount++;
mpsoc::TcReplayStop tcReplayStop(spParams, sequenceCount); mpsoc::TcReplayStop tcReplayStop(spParams, sequenceCount);
result = tcReplayStop.buildPacket(); result = tcReplayStop.buildPacket();
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
sequenceCount--;
return result; return result;
} }
finishTcPrep(tcReplayStop.getFullPacketLen()); finishTcPrep(tcReplayStop.getFullPacketLen());
@ -477,11 +468,9 @@ ReturnValue_t PlocMPSoCHandler::prepareTcReplayStop() {
ReturnValue_t PlocMPSoCHandler::prepareTcDownlinkPwrOn(const uint8_t* commandData, ReturnValue_t PlocMPSoCHandler::prepareTcDownlinkPwrOn(const uint8_t* commandData,
size_t commandDataLen) { size_t commandDataLen) {
ReturnValue_t result = returnvalue::OK; ReturnValue_t result = returnvalue::OK;
sequenceCount++;
mpsoc::TcDownlinkPwrOn tcDownlinkPwrOn(spParams, sequenceCount); mpsoc::TcDownlinkPwrOn tcDownlinkPwrOn(spParams, sequenceCount);
result = tcDownlinkPwrOn.buildPacket(commandData, commandDataLen); result = tcDownlinkPwrOn.buildPacket(commandData, commandDataLen);
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
sequenceCount--;
return result; return result;
} }
finishTcPrep(tcDownlinkPwrOn.getFullPacketLen()); finishTcPrep(tcDownlinkPwrOn.getFullPacketLen());
@ -490,11 +479,9 @@ ReturnValue_t PlocMPSoCHandler::prepareTcDownlinkPwrOn(const uint8_t* commandDat
ReturnValue_t PlocMPSoCHandler::prepareTcDownlinkPwrOff() { ReturnValue_t PlocMPSoCHandler::prepareTcDownlinkPwrOff() {
ReturnValue_t result = returnvalue::OK; ReturnValue_t result = returnvalue::OK;
sequenceCount++;
mpsoc::TcDownlinkPwrOff tcDownlinkPwrOff(spParams, sequenceCount); mpsoc::TcDownlinkPwrOff tcDownlinkPwrOff(spParams, sequenceCount);
result = tcDownlinkPwrOff.buildPacket(); result = tcDownlinkPwrOff.buildPacket();
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
sequenceCount--;
return result; return result;
} }
finishTcPrep(tcDownlinkPwrOff.getFullPacketLen()); finishTcPrep(tcDownlinkPwrOff.getFullPacketLen());
@ -504,11 +491,9 @@ ReturnValue_t PlocMPSoCHandler::prepareTcDownlinkPwrOff() {
ReturnValue_t PlocMPSoCHandler::prepareTcReplayWriteSequence(const uint8_t* commandData, ReturnValue_t PlocMPSoCHandler::prepareTcReplayWriteSequence(const uint8_t* commandData,
size_t commandDataLen) { size_t commandDataLen) {
ReturnValue_t result = returnvalue::OK; ReturnValue_t result = returnvalue::OK;
sequenceCount++;
mpsoc::TcReplayWriteSeq tcReplayWriteSeq(spParams, sequenceCount); mpsoc::TcReplayWriteSeq tcReplayWriteSeq(spParams, sequenceCount);
result = tcReplayWriteSeq.buildPacket(commandData, commandDataLen); result = tcReplayWriteSeq.buildPacket(commandData, commandDataLen);
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
sequenceCount--;
return result; return result;
} }
finishTcPrep(tcReplayWriteSeq.getFullPacketLen()); finishTcPrep(tcReplayWriteSeq.getFullPacketLen());
@ -517,11 +502,9 @@ ReturnValue_t PlocMPSoCHandler::prepareTcReplayWriteSequence(const uint8_t* comm
ReturnValue_t PlocMPSoCHandler::prepareTcModeReplay() { ReturnValue_t PlocMPSoCHandler::prepareTcModeReplay() {
ReturnValue_t result = returnvalue::OK; ReturnValue_t result = returnvalue::OK;
sequenceCount++;
mpsoc::TcModeReplay tcModeReplay(spParams, sequenceCount); mpsoc::TcModeReplay tcModeReplay(spParams, sequenceCount);
result = tcModeReplay.buildPacket(); result = tcModeReplay.buildPacket();
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
sequenceCount--;
return result; return result;
} }
finishTcPrep(tcModeReplay.getFullPacketLen()); finishTcPrep(tcModeReplay.getFullPacketLen());
@ -530,11 +513,9 @@ ReturnValue_t PlocMPSoCHandler::prepareTcModeReplay() {
ReturnValue_t PlocMPSoCHandler::prepareTcModeIdle() { ReturnValue_t PlocMPSoCHandler::prepareTcModeIdle() {
ReturnValue_t result = returnvalue::OK; ReturnValue_t result = returnvalue::OK;
sequenceCount++;
mpsoc::TcModeIdle tcModeIdle(spParams, sequenceCount); mpsoc::TcModeIdle tcModeIdle(spParams, sequenceCount);
result = tcModeIdle.buildPacket(); result = tcModeIdle.buildPacket();
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
sequenceCount--;
return result; return result;
} }
finishTcPrep(tcModeIdle.getFullPacketLen()); finishTcPrep(tcModeIdle.getFullPacketLen());
@ -544,11 +525,9 @@ ReturnValue_t PlocMPSoCHandler::prepareTcModeIdle() {
ReturnValue_t PlocMPSoCHandler::prepareTcCamCmdSend(const uint8_t* commandData, ReturnValue_t PlocMPSoCHandler::prepareTcCamCmdSend(const uint8_t* commandData,
size_t commandDataLen) { size_t commandDataLen) {
ReturnValue_t result = returnvalue::OK; ReturnValue_t result = returnvalue::OK;
sequenceCount++;
mpsoc::TcCamcmdSend tcCamCmdSend(spParams, sequenceCount); mpsoc::TcCamcmdSend tcCamCmdSend(spParams, sequenceCount);
result = tcCamCmdSend.buildPacket(commandData, commandDataLen); result = tcCamCmdSend.buildPacket(commandData, commandDataLen);
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
sequenceCount--;
return result; return result;
} }
finishTcPrep(tcCamCmdSend.getFullPacketLen()); finishTcPrep(tcCamCmdSend.getFullPacketLen());
@ -560,6 +539,7 @@ void PlocMPSoCHandler::finishTcPrep(size_t packetLen) {
nextReplyId = mpsoc::ACK_REPORT; nextReplyId = mpsoc::ACK_REPORT;
rawPacket = commandBuffer; rawPacket = commandBuffer;
rawPacketLen = packetLen; rawPacketLen = packetLen;
sequenceCount++;
} }
ReturnValue_t PlocMPSoCHandler::verifyPacket(const uint8_t* start, size_t foundLen) { ReturnValue_t PlocMPSoCHandler::verifyPacket(const uint8_t* start, size_t foundLen) {

5
linux/devices/ploc/PlocMPSoCHandler.h
View File

@ -107,10 +107,7 @@ class PlocMPSoCHandler : public DeviceHandlerBase, public CommandsActionsIF {
MessageQueueIF* eventQueue = nullptr; MessageQueueIF* eventQueue = nullptr;
MessageQueueIF* commandActionHelperQueue = nullptr; MessageQueueIF* commandActionHelperQueue = nullptr;
// Initiate the sequence count with the maximum value. It is incremented before SourceSequenceCounter sequenceCount = SourceSequenceCounter(0);
// a packet is sent, so the first value will be 0 accordingly using
// the wrap around of the counter.
SourceSequenceCounter sequenceCount = SourceSequenceCounter(ccsds::LIMIT_SEQUENCE_COUNT - 1);
uint8_t commandBuffer[mpsoc::MAX_COMMAND_SIZE]; uint8_t commandBuffer[mpsoc::MAX_COMMAND_SIZE];
SpacePacketCreator creator; SpacePacketCreator creator;

45
linux/devices/ploc/PlocSupervisorHandler.cpp
View File

@ -136,29 +136,34 @@ ReturnValue_t PlocSupervisorHandler::executeAction(ActionId_t actionId,
} }
void PlocSupervisorHandler::doStartUp() { void PlocSupervisorHandler::doStartUp() {
if (setTimeDuringStartup) { if (startupState == StartupState::OFF) {
if (startupState == StartupState::OFF) { bootTimeout.resetTimer();
bootTimeout.resetTimer(); startupState = StartupState::BOOTING;
startupState = StartupState::BOOTING; }
} if (startupState == StartupState::BOOTING) {
if (startupState == StartupState::BOOTING) { if (bootTimeout.hasTimedOut()) {
if (bootTimeout.hasTimedOut()) { uartIsolatorSwitch.pullHigh();
uartIsolatorSwitch.pullHigh(); uartManager.start();
uartManager.start(); if (SET_TIME_DURING_BOOT) {
startupState = StartupState::SET_TIME; startupState = StartupState::SET_TIME;
} else {
startupState = StartupState::ON;
} }
} }
if (startupState == StartupState::ON) { }
setMode(_MODE_TO_ON); if (startupState == StartupState::SET_TIME_EXECUTING) {
} startupState = StartupState::ON;
} else { }
uartIsolatorSwitch.pullHigh(); if (startupState == StartupState::ON) {
setMode(_MODE_TO_ON); setMode(_MODE_TO_ON);
} }
} }
void PlocSupervisorHandler::doShutDown() { void PlocSupervisorHandler::doShutDown() {
setMode(_MODE_POWER_DOWN); setMode(_MODE_POWER_DOWN);
shutdownCmdSent = false;
packetInBuffer = false;
nextReplyId = supv::NONE;
uartManager.stop(); uartManager.stop();
uartIsolatorSwitch.pullLow(); uartIsolatorSwitch.pullLow();
startupState = StartupState::OFF; startupState = StartupState::OFF;
@ -1467,11 +1472,10 @@ ReturnValue_t PlocSupervisorHandler::prepareReadGpioCmd(const uint8_t* commandDa
ReturnValue_t PlocSupervisorHandler::prepareFactoryResetCmd(const uint8_t* commandData, ReturnValue_t PlocSupervisorHandler::prepareFactoryResetCmd(const uint8_t* commandData,
size_t len) { size_t len) {
FactoryReset resetCmd(spParams); FactoryReset resetCmd(spParams);
std::optional<uint8_t> op; if (len < 1) {
if (len > 0) { return HasActionsIF::INVALID_PARAMETERS;
op = commandData[0];
} }
ReturnValue_t result = resetCmd.buildPacket(op); ReturnValue_t result = resetCmd.buildPacket(commandData[0]);
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
return result; return result;
} }
@ -1897,9 +1901,8 @@ ReturnValue_t PlocSupervisorHandler::handleExecutionSuccessReport(ExecutionRepor
break; break;
} }
case supv::SET_TIME_REF: { case supv::SET_TIME_REF: {
if (startupState == StartupState::SET_TIME_EXECUTING) { // We could only allow proper bootup when the time was set successfully, but
startupState = StartupState::ON; // this makes debugging difficult.
}
break; break;
} }
default: default:

8
linux/devices/ploc/PlocSupervisorHandler.h
View File

@ -97,11 +97,11 @@ class PlocSupervisorHandler : public DeviceHandlerBase {
static const uint32_t COPY_ADC_TO_MRAM_TIMEOUT = 70000; static const uint32_t COPY_ADC_TO_MRAM_TIMEOUT = 70000;
// 60 s // 60 s
static const uint32_t MRAM_DUMP_TIMEOUT = 60000; static const uint32_t MRAM_DUMP_TIMEOUT = 60000;
// 2 s // 4 s
static const uint32_t BOOT_TIMEOUT = 2000; static const uint32_t BOOT_TIMEOUT = 4000;
enum class StartupState : uint8_t { OFF, BOOTING, SET_TIME, SET_TIME_EXECUTING, ON }; enum class StartupState : uint8_t { OFF, BOOTING, SET_TIME, SET_TIME_EXECUTING, ON };
bool setTimeDuringStartup = true; static constexpr bool SET_TIME_DURING_BOOT = true;
StartupState startupState = StartupState::OFF; StartupState startupState = StartupState::OFF;
@ -138,8 +138,6 @@ class PlocSupervisorHandler : public DeviceHandlerBase {
uint32_t receivedMramDumpPackets = 0; uint32_t receivedMramDumpPackets = 0;
/** Set to true as soon as a complete space packet is present in the spacePacketBuffer */ /** Set to true as soon as a complete space packet is present in the spacePacketBuffer */
bool packetInBuffer = false; bool packetInBuffer = false;
/** Points to the next free position in the space packet buffer */
uint16_t bufferTop = 0;
/** This buffer is used to concatenate space packets received in two different read steps */ /** This buffer is used to concatenate space packets received in two different read steps */
uint8_t spacePacketBuffer[supv::MAX_PACKET_SIZE]; uint8_t spacePacketBuffer[supv::MAX_PACKET_SIZE];

12
linux/devices/ploc/PlocSupvUartMan.cpp
View File

@ -100,6 +100,7 @@ ReturnValue_t PlocSupvUartManager::performOperation(uint8_t operationCode) {
state = InternalState::SLEEPING; state = InternalState::SLEEPING;
lock->unlockMutex(); lock->unlockMutex();
semaphore->acquire(); semaphore->acquire();
putTaskToSleep = false;
while (true) { while (true) {
if (putTaskToSleep) { if (putTaskToSleep) {
performUartShutdown(); performUartShutdown();
@ -295,11 +296,14 @@ void PlocSupvUartManager::stop() {
} }
void PlocSupvUartManager::start() { void PlocSupvUartManager::start() {
MutexGuard mg(lock); {
if (state != InternalState::SLEEPING and state != InternalState::GO_TO_SLEEP) { MutexGuard mg(lock);
return; if (state != InternalState::SLEEPING and state != InternalState::GO_TO_SLEEP) {
return;
}
state = InternalState::DEFAULT;
} }
state = InternalState::DEFAULT;
semaphore->release(); semaphore->release();
} }

2
tmtc

@ -1 +1 @@
Subproject commit 9016d3d992bb6c5aa8dd11065ceb913b8ba88491 Subproject commit 5c675560eadadfbb5e674d9be87c206df09d1771