on and normal mode finally work
Some checks failed
EIVE/eive-obsw/pipeline/pr-main There was a failure building this commit
Some checks failed
EIVE/eive-obsw/pipeline/pr-main There was a failure building this commit
This commit is contained in:
parent
193c45ee33
commit
bd74b95ffd
GPG Key ID:
A649FB78196E3849
@ -613,11 +613,11 @@ void ObjectFactory::createSyrlinksComponents(PowerSwitchIF* pwrSwitcher) {
|
||||
#endif
|
||||
}
|
||||
|
||||
void ObjectFactory::createPayloadComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchIF& pwrSwitch) {
|
||||
void ObjectFactory::createPayloadComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchIF& pwrSwitcher) {
|
||||
using namespace gpio;
|
||||
std::stringstream consumer;
|
||||
auto* camSwitcher =
|
||||
new CamSwitcher(objects::CAM_SWITCHER, pwrSwitch, power::PDU2_CH8_PAYLOAD_CAMERA);
|
||||
new CamSwitcher(objects::CAM_SWITCHER, pwrSwitcher, power::PDU2_CH8_PAYLOAD_CAMERA);
|
||||
camSwitcher->connectModeTreeParent(satsystem::payload::SUBSYSTEM);
|
||||
#if OBSW_ADD_PLOC_MPSOC == 1
|
||||
consumer << "0x" << std::hex << objects::PLOC_MPSOC_HANDLER;
|
||||
@ -651,18 +651,11 @@ void ObjectFactory::createPayloadComponents(LinuxLibgpioIF* gpioComIF, PowerSwit
|
||||
new SerialCookie(objects::PLOC_SUPERVISOR_HANDLER, plocSupvDev, serial::PLOC_SUPV_BAUD,
|
||||
supv::MAX_PACKET_SIZE * 20, UartModes::NON_CANONICAL);
|
||||
supervisorCookie->setNoFixedSizeReply();
|
||||
auto supvHelper = new PlocSupvUartManager(objects::PLOC_SUPERVISOR_HELPER);
|
||||
|
||||
new PlocSupvUartManager(objects::PLOC_SUPERVISOR_HELPER);
|
||||
DhbConfig dhbConf(objects::PLOC_SUPERVISOR_HANDLER);
|
||||
auto* supvHandler =
|
||||
new FreshSupvHandler(dhbConf, supervisorCookie, Gpio(gpioIds::ENABLE_SUPV_UART, gpioComIF),
|
||||
pwrSwitch, power::PDU1_CH6_PLOC_12V, *supvHelper);
|
||||
/*
|
||||
auto* supvHandler = new PlocSupervisorHandler(objects::PLOC_SUPERVISOR_HANDLER, supervisorCookie,
|
||||
Gpio(gpioIds::ENABLE_SUPV_UART, gpioComIF),
|
||||
power::PDU1_CH6_PLOC_12V, *supvHelper);
|
||||
supvHandler->setPowerSwitcher(&pwrSwitch);
|
||||
*/
|
||||
pwrSwitcher, power::PDU1_CH6_PLOC_12V);
|
||||
supvHandler->connectModeTreeParent(satsystem::payload::SUBSYSTEM);
|
||||
#endif /* OBSW_ADD_PLOC_SUPERVISOR == 1 */
|
||||
static_cast<void>(consumer);
|
||||
|
||||
2
fsfw
2
fsfw
@ -1 +1 @@
|
||||
Subproject commit 91b194d8ebd79352ad358f955274d49f15dd3e6d
|
||||
Subproject commit 7673d8b396764186d93c3378496ccfc3c1b2e2e8
|
||||
@ -3,7 +3,6 @@ target_sources(
|
||||
PUBLIC PlocMemoryDumper.cpp
|
||||
PlocMpsocHandler.cpp
|
||||
FreshSupvHandler.cpp
|
||||
PlocSupervisorHandler.cpp
|
||||
PlocMpsocSpecialComHelper.cpp
|
||||
plocMpsocHelpers.cpp
|
||||
PlocSupvUartMan.cpp
|
||||
|
||||
@ -7,8 +7,10 @@
|
||||
#include <filesystem>
|
||||
|
||||
#include "eive/definitions.h"
|
||||
#include "eive/objects.h"
|
||||
#include "fsfw/ipc/MessageQueueIF.h"
|
||||
#include "fsfw/ipc/QueueFactory.h"
|
||||
#include "fsfw/objectmanager/ObjectManagerIF.h"
|
||||
#include "fsfw/returnvalues/returnvalue.h"
|
||||
#include "fsfw/tasks/TaskFactory.h"
|
||||
#include "linux/payload/plocSupvDefs.h"
|
||||
@ -19,10 +21,8 @@ using namespace returnvalue;
|
||||
std::atomic_bool supv::SUPV_ON = false;
|
||||
|
||||
FreshSupvHandler::FreshSupvHandler(DhbConfig cfg, CookieIF* comCookie, Gpio uartIsolatorSwitch,
|
||||
PowerSwitchIF& switchIF, power::Switch_t powerSwitch,
|
||||
PlocSupvUartManager& supvHelper)
|
||||
PowerSwitchIF& switchIF, power::Switch_t powerSwitch)
|
||||
: FreshDeviceHandlerBase(cfg),
|
||||
uartManager(supvHelper),
|
||||
comCookie(comCookie),
|
||||
switchIF(switchIF),
|
||||
switchId(powerSwitch),
|
||||
@ -75,7 +75,8 @@ void FreshSupvHandler::performDeviceOperation(uint8_t opCode) {
|
||||
buildActiveCmdKey(Apid::HK, static_cast<uint8_t>(tc::HkId::GET_REPORT)));
|
||||
if (cmdIter == activeActionCmds.end() or not cmdIter->second.isPending) {
|
||||
spParams.buf = commandBuffer.data();
|
||||
sendEmptyCmd(Apid::HK, static_cast<uint8_t>(tc::HkId::GET_REPORT), true);
|
||||
sendEmptyCmd(supv::GET_HK_REPORT, Apid::HK, static_cast<uint8_t>(tc::HkId::GET_REPORT),
|
||||
true);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -195,7 +196,7 @@ ReturnValue_t FreshSupvHandler::executeAction(ActionId_t actionId, MessageQueueI
|
||||
const uint8_t* data, size_t size) {
|
||||
using namespace supv;
|
||||
ReturnValue_t result;
|
||||
if (uartManager.longerRequestActive()) {
|
||||
if (uartManager->longerRequestActive()) {
|
||||
return result::SUPV_HELPER_EXECUTING;
|
||||
}
|
||||
|
||||
@ -209,14 +210,14 @@ ReturnValue_t FreshSupvHandler::executeAction(ActionId_t actionId, MessageQueueI
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
}
|
||||
result = uartManager.performUpdate(params);
|
||||
result = uartManager->performUpdate(params);
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
}
|
||||
return EXECUTION_FINISHED;
|
||||
}
|
||||
case CONTINUE_UPDATE: {
|
||||
uartManager.initiateUpdateContinuation();
|
||||
uartManager->initiateUpdateContinuation();
|
||||
return EXECUTION_FINISHED;
|
||||
}
|
||||
case MEMORY_CHECK_WITH_FILE: {
|
||||
@ -228,7 +229,7 @@ ReturnValue_t FreshSupvHandler::executeAction(ActionId_t actionId, MessageQueueI
|
||||
if (not std::filesystem::exists(params.file)) {
|
||||
return HasFileSystemIF::FILE_DOES_NOT_EXIST;
|
||||
}
|
||||
uartManager.performMemCheck(params.file, params.memId, params.startAddr);
|
||||
uartManager->performMemCheck(params.file, params.memId, params.startAddr);
|
||||
return EXECUTION_FINISHED;
|
||||
}
|
||||
default:
|
||||
@ -240,19 +241,21 @@ ReturnValue_t FreshSupvHandler::executeAction(ActionId_t actionId, MessageQueueI
|
||||
spParams.buf = commandBuffer.data();
|
||||
switch (actionId) {
|
||||
case GET_HK_REPORT: {
|
||||
sendEmptyCmd(Apid::HK, static_cast<uint8_t>(tc::HkId::GET_REPORT), true);
|
||||
sendEmptyCmd(supv::GET_HK_REPORT, Apid::HK, static_cast<uint8_t>(tc::HkId::GET_REPORT), true);
|
||||
result = returnvalue::OK;
|
||||
break;
|
||||
}
|
||||
case START_MPSOC: {
|
||||
sif::info << "PLOC SUPV: Starting MPSoC" << std::endl;
|
||||
sendEmptyCmd(Apid::BOOT_MAN, static_cast<uint8_t>(tc::BootManId::START_MPSOC), false);
|
||||
sendEmptyCmd(supv::START_MPSOC, Apid::BOOT_MAN,
|
||||
static_cast<uint8_t>(tc::BootManId::START_MPSOC), false);
|
||||
result = returnvalue::OK;
|
||||
break;
|
||||
}
|
||||
case SHUTDOWN_MPSOC: {
|
||||
sif::info << "PLOC SUPV: Shutting down MPSoC" << std::endl;
|
||||
sendEmptyCmd(Apid::BOOT_MAN, static_cast<uint8_t>(tc::BootManId::SHUTDOWN_MPSOC), false);
|
||||
sendEmptyCmd(supv::SHUTDOWN_MPSOC, Apid::BOOT_MAN,
|
||||
static_cast<uint8_t>(tc::BootManId::SHUTDOWN_MPSOC), false);
|
||||
result = returnvalue::OK;
|
||||
break;
|
||||
}
|
||||
@ -263,7 +266,8 @@ ReturnValue_t FreshSupvHandler::executeAction(ActionId_t actionId, MessageQueueI
|
||||
}
|
||||
case RESET_MPSOC: {
|
||||
sif::info << "PLOC SUPV: Resetting MPSoC" << std::endl;
|
||||
sendEmptyCmd(Apid::BOOT_MAN, static_cast<uint8_t>(tc::BootManId::RESET_MPSOC), false);
|
||||
sendEmptyCmd(supv::RESET_MPSOC, Apid::BOOT_MAN,
|
||||
static_cast<uint8_t>(tc::BootManId::RESET_MPSOC), false);
|
||||
result = returnvalue::OK;
|
||||
break;
|
||||
}
|
||||
@ -287,8 +291,8 @@ ReturnValue_t FreshSupvHandler::executeAction(ActionId_t actionId, MessageQueueI
|
||||
break;
|
||||
}
|
||||
case GET_BOOT_STATUS_REPORT: {
|
||||
sendEmptyCmd(Apid::BOOT_MAN, static_cast<uint8_t>(tc::BootManId::GET_BOOT_STATUS_REPORT),
|
||||
true);
|
||||
sendEmptyCmd(supv::GET_BOOT_STATUS_REPORT, Apid::BOOT_MAN,
|
||||
static_cast<uint8_t>(tc::BootManId::GET_BOOT_STATUS_REPORT), true);
|
||||
result = returnvalue::OK;
|
||||
break;
|
||||
}
|
||||
@ -305,8 +309,8 @@ ReturnValue_t FreshSupvHandler::executeAction(ActionId_t actionId, MessageQueueI
|
||||
break;
|
||||
}
|
||||
case GET_LATCHUP_STATUS_REPORT: {
|
||||
sendEmptyCmd(Apid::LATCHUP_MON, static_cast<uint8_t>(tc::LatchupMonId::GET_STATUS_REPORT),
|
||||
true);
|
||||
sendEmptyCmd(supv::GET_LATCHUP_STATUS_REPORT, Apid::LATCHUP_MON,
|
||||
static_cast<uint8_t>(tc::LatchupMonId::GET_STATUS_REPORT), true);
|
||||
result = returnvalue::OK;
|
||||
break;
|
||||
}
|
||||
@ -328,12 +332,14 @@ ReturnValue_t FreshSupvHandler::executeAction(ActionId_t actionId, MessageQueueI
|
||||
break;
|
||||
}
|
||||
case FACTORY_FLASH: {
|
||||
sendEmptyCmd(Apid::BOOT_MAN, static_cast<uint8_t>(tc::BootManId::FACTORY_FLASH), false);
|
||||
sendEmptyCmd(supv::FACTORY_FLASH, Apid::BOOT_MAN,
|
||||
static_cast<uint8_t>(tc::BootManId::FACTORY_FLASH), false);
|
||||
result = returnvalue::OK;
|
||||
break;
|
||||
}
|
||||
case RESET_PL: {
|
||||
sendEmptyCmd(Apid::BOOT_MAN, static_cast<uint8_t>(tc::BootManId::RESET_PL), false);
|
||||
sendEmptyCmd(supv::RESET_PL, Apid::BOOT_MAN, static_cast<uint8_t>(tc::BootManId::RESET_PL),
|
||||
false);
|
||||
result = returnvalue::OK;
|
||||
break;
|
||||
}
|
||||
@ -357,12 +363,13 @@ ReturnValue_t FreshSupvHandler::executeAction(ActionId_t actionId, MessageQueueI
|
||||
break;
|
||||
}
|
||||
case REQUEST_ADC_REPORT: {
|
||||
sendEmptyCmd(Apid::ADC_MON, static_cast<uint8_t>(tc::AdcMonId::REQUEST_ADC_SAMPLE), true);
|
||||
sendEmptyCmd(supv::REQUEST_ADC_REPORT, Apid::ADC_MON,
|
||||
static_cast<uint8_t>(tc::AdcMonId::REQUEST_ADC_SAMPLE), true);
|
||||
result = returnvalue::OK;
|
||||
break;
|
||||
}
|
||||
case REQUEST_LOGGING_COUNTERS: {
|
||||
sendEmptyCmd(Apid::DATA_LOGGER,
|
||||
sendEmptyCmd(supv::REQUEST_LOGGING_COUNTERS, Apid::DATA_LOGGER,
|
||||
static_cast<uint8_t>(tc::DataLoggerServiceId::REQUEST_COUNTERS), true);
|
||||
result = returnvalue::OK;
|
||||
break;
|
||||
@ -389,7 +396,7 @@ ReturnValue_t FreshSupvHandler::prepareSetTimeRefCmd() {
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
}
|
||||
sendCommand(packet, false);
|
||||
sendCommand(supv::SET_TIME_REF, packet, false);
|
||||
return returnvalue::OK;
|
||||
}
|
||||
|
||||
@ -424,12 +431,13 @@ ReturnValue_t FreshSupvHandler::prepareSelBootImageCmd(const uint8_t* commandDat
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
}
|
||||
sendCommand(packet, false);
|
||||
sendCommand(supv::SEL_MPSOC_BOOT_IMAGE, packet, false);
|
||||
return returnvalue::OK;
|
||||
}
|
||||
|
||||
void FreshSupvHandler::startTransition(Mode_t newMode, Submode_t newSubmode) {
|
||||
if (newMode == mode or (mode == MODE_ON and newMode == MODE_NORMAL)) {
|
||||
if (newMode == mode or (mode == MODE_ON and newMode == MODE_NORMAL) or
|
||||
(newMode == MODE_ON and mode == MODE_NORMAL)) {
|
||||
// Can finish immediately.
|
||||
setMode(newMode, newSubmode);
|
||||
return;
|
||||
@ -469,7 +477,7 @@ void FreshSupvHandler::handleTransitionToOn() {
|
||||
}
|
||||
if (startupState == StartupState::BOOTING and bootTimeout.hasTimedOut()) {
|
||||
uartIsolatorSwitch.pullHigh();
|
||||
uartManager.start();
|
||||
uartManager->start();
|
||||
if (SET_TIME_DURING_BOOT) {
|
||||
startupState = StartupState::SET_TIME;
|
||||
} else {
|
||||
@ -501,7 +509,7 @@ void FreshSupvHandler::handleTransitionToOff() {
|
||||
if (shutdownState == ShutdownState::IDLE) {
|
||||
hkSet.setReportingEnabled(false);
|
||||
hkSet.setValidity(false, true);
|
||||
uartManager.stop();
|
||||
uartManager->stop();
|
||||
uartIsolatorSwitch.pullLow();
|
||||
switchIF.sendSwitchCommand(switchId, PowerSwitchIF::SWITCH_OFF);
|
||||
shutdownState = ShutdownState::POWER_SWITCHING;
|
||||
@ -515,13 +523,13 @@ void FreshSupvHandler::handleTransitionToOff() {
|
||||
}
|
||||
}
|
||||
|
||||
ReturnValue_t FreshSupvHandler::sendCommand(TcBase& tc, bool replyExpected,
|
||||
uint32_t cmdCountdownMs) {
|
||||
ReturnValue_t FreshSupvHandler::sendCommand(DeviceCommandId_t commandId, TcBase& tc,
|
||||
bool replyExpected, uint32_t cmdCountdownMs) {
|
||||
if (supv::DEBUG_PLOC_SUPV) {
|
||||
sif::debug << "PLOC SUPV: SEND PACKET Size " << tc.getFullPacketLen() << " Module APID "
|
||||
<< (int)tc.getModuleApid() << " Service ID " << (int)tc.getServiceId() << std::endl;
|
||||
}
|
||||
ActiveCmdInfo info(cmdCountdownMs);
|
||||
ActiveCmdInfo info(commandId, cmdCountdownMs);
|
||||
auto activeCmdIter =
|
||||
activeActionCmds.find(buildActiveCmdKey(tc.getModuleApid(), tc.getServiceId()));
|
||||
if (activeCmdIter == activeActionCmds.end()) {
|
||||
@ -532,6 +540,7 @@ ReturnValue_t FreshSupvHandler::sendCommand(TcBase& tc, bool replyExpected,
|
||||
return HasActionsIF::IS_BUSY;
|
||||
}
|
||||
activeCmdIter->second.isPending = true;
|
||||
activeCmdIter->second.commandId = commandId;
|
||||
activeCmdIter->second.ackRecv = false;
|
||||
activeCmdIter->second.ackExeRecv = false;
|
||||
activeCmdIter->second.replyPacketExpected = replyExpected;
|
||||
@ -539,11 +548,16 @@ ReturnValue_t FreshSupvHandler::sendCommand(TcBase& tc, bool replyExpected,
|
||||
activeCmdIter->second.cmdCountdown.setTimeout(cmdCountdownMs);
|
||||
activeCmdIter->second.cmdCountdown.resetTimer();
|
||||
}
|
||||
return uartManager.sendMessage(comCookie, tc.getFullPacket(), tc.getFullPacketLen());
|
||||
return uartManager->sendMessage(comCookie, tc.getFullPacket(), tc.getFullPacketLen());
|
||||
}
|
||||
|
||||
ReturnValue_t FreshSupvHandler::initialize() {
|
||||
uartManager.initializeInterface(comCookie);
|
||||
uartManager =
|
||||
ObjectManager::instance()->get<PlocSupvUartManager>(objects::PLOC_SUPERVISOR_HELPER);
|
||||
if (uartManager == nullptr) {
|
||||
return returnvalue::FAILED;
|
||||
}
|
||||
uartManager->initializeInterface(comCookie);
|
||||
|
||||
ReturnValue_t result = eventSubscription();
|
||||
if (result != returnvalue::OK) {
|
||||
@ -552,13 +566,14 @@ ReturnValue_t FreshSupvHandler::initialize() {
|
||||
return FreshDeviceHandlerBase::initialize();
|
||||
}
|
||||
|
||||
ReturnValue_t FreshSupvHandler::sendEmptyCmd(uint16_t apid, uint8_t serviceId, bool replyExpected) {
|
||||
ReturnValue_t FreshSupvHandler::sendEmptyCmd(DeviceCommandId_t commandId, uint16_t apid,
|
||||
uint8_t serviceId, bool replyExpected) {
|
||||
supv::NoPayloadPacket packet(spParams, apid, serviceId);
|
||||
ReturnValue_t result = packet.buildPacket();
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
}
|
||||
sendCommand(packet, replyExpected);
|
||||
sendCommand(commandId, packet, replyExpected);
|
||||
return returnvalue::OK;
|
||||
}
|
||||
|
||||
@ -574,7 +589,7 @@ ReturnValue_t FreshSupvHandler::prepareSetBootTimeoutCmd(const uint8_t* commandD
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
}
|
||||
sendCommand(packet, false);
|
||||
sendCommand(supv::SET_BOOT_TIMEOUT, packet, false);
|
||||
return returnvalue::OK;
|
||||
}
|
||||
|
||||
@ -589,7 +604,7 @@ ReturnValue_t FreshSupvHandler::prepareRestartTriesCmd(const uint8_t* commandDat
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
}
|
||||
sendCommand(packet, false);
|
||||
sendCommand(supv::ENABLE_AUTO_TM, packet, false);
|
||||
return returnvalue::OK;
|
||||
}
|
||||
|
||||
@ -599,7 +614,7 @@ ReturnValue_t FreshSupvHandler::prepareDisableHk() {
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
}
|
||||
sendCommand(packet, false);
|
||||
sendCommand(supv::DISABLE_AUTO_TM, packet, false);
|
||||
return returnvalue::OK;
|
||||
}
|
||||
|
||||
@ -621,7 +636,7 @@ ReturnValue_t FreshSupvHandler::prepareLatchupConfigCmd(const uint8_t* commandDa
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
}
|
||||
sendCommand(packet, false);
|
||||
sendCommand(deviceCommand, packet, false);
|
||||
break;
|
||||
}
|
||||
case (supv::DISABLE_LATCHUP_ALERT): {
|
||||
@ -630,7 +645,7 @@ ReturnValue_t FreshSupvHandler::prepareLatchupConfigCmd(const uint8_t* commandDa
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
}
|
||||
sendCommand(packet, false);
|
||||
sendCommand(deviceCommand, packet, false);
|
||||
break;
|
||||
}
|
||||
default: {
|
||||
@ -661,7 +676,7 @@ ReturnValue_t FreshSupvHandler::prepareSetAlertLimitCmd(const uint8_t* commandDa
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
}
|
||||
sendCommand(packet, false);
|
||||
sendCommand(supv::SET_ALERT_LIMIT, packet, false);
|
||||
return returnvalue::OK;
|
||||
}
|
||||
|
||||
@ -686,7 +701,7 @@ ReturnValue_t FreshSupvHandler::prepareSetShutdownTimeoutCmd(const uint8_t* comm
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
}
|
||||
sendCommand(packet, false);
|
||||
sendCommand(supv::SET_SHUTDOWN_TIMEOUT, packet, false);
|
||||
return returnvalue::OK;
|
||||
}
|
||||
|
||||
@ -703,7 +718,7 @@ ReturnValue_t FreshSupvHandler::prepareSetGpioCmd(const uint8_t* commandData,
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
}
|
||||
sendCommand(packet, false);
|
||||
sendCommand(supv::SET_GPIO, packet, false);
|
||||
return returnvalue::OK;
|
||||
}
|
||||
|
||||
@ -719,7 +734,7 @@ ReturnValue_t FreshSupvHandler::prepareReadGpioCmd(const uint8_t* commandData,
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
}
|
||||
sendCommand(packet, false);
|
||||
sendCommand(supv::READ_GPIO, packet, false);
|
||||
return returnvalue::OK;
|
||||
}
|
||||
|
||||
@ -732,7 +747,7 @@ ReturnValue_t FreshSupvHandler::prepareFactoryResetCmd(const uint8_t* commandDat
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
}
|
||||
sendCommand(resetCmd, false);
|
||||
sendCommand(supv::FACTORY_RESET, resetCmd, false);
|
||||
return returnvalue::OK;
|
||||
}
|
||||
|
||||
@ -743,7 +758,7 @@ ReturnValue_t FreshSupvHandler::prepareSetAdcEnabledChannelsCmd(const uint8_t* c
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
}
|
||||
sendCommand(packet, false);
|
||||
sendCommand(supv::SET_ADC_ENABLED_CHANNELS, packet, false);
|
||||
return returnvalue::OK;
|
||||
}
|
||||
|
||||
@ -757,7 +772,7 @@ ReturnValue_t FreshSupvHandler::prepareSetAdcWindowAndStrideCmd(const uint8_t* c
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
}
|
||||
sendCommand(packet, false);
|
||||
sendCommand(supv::SET_ADC_WINDOW_AND_STRIDE, packet, false);
|
||||
return returnvalue::OK;
|
||||
}
|
||||
|
||||
@ -769,7 +784,7 @@ ReturnValue_t FreshSupvHandler::prepareSetAdcThresholdCmd(const uint8_t* command
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
}
|
||||
sendCommand(packet, false);
|
||||
sendCommand(supv::SET_ADC_THRESHOLD, packet, false);
|
||||
return returnvalue::OK;
|
||||
}
|
||||
|
||||
@ -790,7 +805,7 @@ ReturnValue_t FreshSupvHandler::prepareWipeMramCmd(const uint8_t* commandData, s
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
}
|
||||
sendCommand(packet, false);
|
||||
sendCommand(supv::WIPE_MRAM, packet, false);
|
||||
return returnvalue::OK;
|
||||
}
|
||||
|
||||
@ -798,11 +813,16 @@ ReturnValue_t FreshSupvHandler::parseTmPackets() {
|
||||
uint8_t* receivedData = nullptr;
|
||||
size_t receivedSize = 0;
|
||||
while (true) {
|
||||
ReturnValue_t result = uartManager.readReceivedMessage(comCookie, &receivedData, &receivedSize);
|
||||
ReturnValue_t result =
|
||||
uartManager->readReceivedMessage(comCookie, &receivedData, &receivedSize);
|
||||
if (result != returnvalue::OK or receivedSize == 0) {
|
||||
break;
|
||||
}
|
||||
tmReader.setData(receivedData, receivedSize);
|
||||
tmReader.setReadOnlyData(receivedData, receivedSize);
|
||||
if (tmReader.checkCrc() != returnvalue::OK) {
|
||||
sif::warning << "PlocSupervisorHandler::parseTmPackets: CRC failure" << std::endl;
|
||||
continue;
|
||||
}
|
||||
uint16_t apid = tmReader.getModuleApid();
|
||||
if (supv::DEBUG_PLOC_SUPV) {
|
||||
handlePacketPrint();
|
||||
@ -892,9 +912,17 @@ void FreshSupvHandler::handlePacketPrint() {
|
||||
if ((tmReader.getServiceId() == static_cast<uint8_t>(supv::tm::TmtcId::ACK)) or
|
||||
(tmReader.getServiceId() == static_cast<uint8_t>(supv::tm::TmtcId::NAK))) {
|
||||
AcknowledgmentReport ack(tmReader);
|
||||
ReturnValue_t result = ack.parse();
|
||||
ReturnValue_t result = ack.parse(false);
|
||||
if (result != returnvalue::OK) {
|
||||
sif::warning << "PlocSupervisorHandler: Parsing ACK failed" << std::endl;
|
||||
sif::warning << "PlocSupervisorHandler: Parsing ACK failed. ";
|
||||
if (result == result::INVALID_SERVICE_ID) {
|
||||
sif::warning << "Invalid service ID" << std::endl;
|
||||
} else if (result == result::CRC_FAILURE) {
|
||||
sif::warning << "CRC check failed" << std::endl;
|
||||
} else {
|
||||
sif::warning << "Returncode 0x" << std::hex << std::setw(4) << result << std::dec
|
||||
<< std::endl;
|
||||
}
|
||||
}
|
||||
if (supv::REDUCE_NORMAL_MODE_PRINTOUT and
|
||||
ack.getRefModuleApid() == (uint8_t)supv::Apid::HK and
|
||||
@ -915,7 +943,7 @@ void FreshSupvHandler::handlePacketPrint() {
|
||||
} else if ((tmReader.getServiceId() == static_cast<uint8_t>(supv::tm::TmtcId::EXEC_ACK)) or
|
||||
(tmReader.getServiceId() == static_cast<uint8_t>(supv::tm::TmtcId::EXEC_NAK))) {
|
||||
ExecutionReport exe(tmReader);
|
||||
ReturnValue_t result = exe.parse();
|
||||
ReturnValue_t result = exe.parse(false);
|
||||
if (result != returnvalue::OK) {
|
||||
sif::warning << "PlocSupervisorHandler: Parsing EXE failed" << std::endl;
|
||||
}
|
||||
@ -1092,13 +1120,8 @@ ReturnValue_t FreshSupvHandler::eventSubscription() {
|
||||
ReturnValue_t FreshSupvHandler::handleAckReport(const uint8_t* data) {
|
||||
using namespace supv;
|
||||
ReturnValue_t result = returnvalue::OK;
|
||||
if (not tmReader.verifyCrc()) {
|
||||
sif::error << "PlocSupervisorHandler::handleAckReport: CRC failure" << std::endl;
|
||||
triggerEvent(SUPV_CRC_FAILURE_EVENT);
|
||||
return returnvalue::FAILED;
|
||||
}
|
||||
AcknowledgmentReport ack(tmReader);
|
||||
result = ack.parse();
|
||||
result = ack.parse(false);
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
}
|
||||
@ -1111,7 +1134,7 @@ ReturnValue_t FreshSupvHandler::handleAckReport(const uint8_t* data) {
|
||||
ActiveCmdInfo& info = infoIter->second;
|
||||
if (tmReader.getServiceId() == static_cast<uint8_t>(supv::tm::TmtcId::NAK)) {
|
||||
triggerEvent(SUPV_ACK_FAILURE, info.commandId, static_cast<uint32_t>(ack.getStatusCode()));
|
||||
ack.printStatusInformation();
|
||||
ack.printStatusInformationAck();
|
||||
printAckFailureInfo(ack.getStatusCode(), info.commandId);
|
||||
if (info.commandedBy != MessageQueueIF::NO_QUEUE) {
|
||||
actionHelper.finish(false, info.commandedBy, info.commandId, result::RECEIVED_ACK_FAILURE);
|
||||
@ -1129,7 +1152,9 @@ void FreshSupvHandler::performCommandCompletionHandling(supv::Apid apid, uint8_t
|
||||
ActiveCmdInfo& info) {
|
||||
if (info.ackRecv and info.ackExeRecv and
|
||||
(not info.replyPacketExpected or info.replyPacketReceived)) {
|
||||
if (info.commandedBy != MessageQueueIF::NO_QUEUE) {
|
||||
actionHelper.finish(true, info.commandedBy, info.commandId, returnvalue::OK);
|
||||
}
|
||||
info.isPending = false;
|
||||
}
|
||||
}
|
||||
@ -1154,13 +1179,10 @@ uint32_t FreshSupvHandler::buildActiveCmdKey(uint16_t moduleApid, uint8_t servic
|
||||
ReturnValue_t FreshSupvHandler::handleExecutionReport(const uint8_t* data) {
|
||||
using namespace supv;
|
||||
ReturnValue_t result = returnvalue::OK;
|
||||
|
||||
if (not tmReader.verifyCrc()) {
|
||||
return result::CRC_FAILURE;
|
||||
}
|
||||
ExecutionReport exe(tmReader);
|
||||
result = exe.parse();
|
||||
result = exe.parse(false);
|
||||
if (result != OK) {
|
||||
sif::warning << "FreshSupvHandler::handleExecutionReport: Parsing ACK EXE failed" << std::endl;
|
||||
return result;
|
||||
}
|
||||
auto infoIter =
|
||||
@ -1219,7 +1241,7 @@ ReturnValue_t FreshSupvHandler::handleExecutionSuccessReport(ActiveCmdInfo& info
|
||||
|
||||
void FreshSupvHandler::handleExecutionFailureReport(ActiveCmdInfo& info, ExecutionReport& report) {
|
||||
using namespace supv;
|
||||
report.printStatusInformation();
|
||||
report.printStatusInformationExe();
|
||||
if (info.commandId != DeviceHandlerIF::NO_COMMAND_ID) {
|
||||
triggerEvent(SUPV_EXE_FAILURE, info.commandId, static_cast<uint32_t>(report.getStatusCode()));
|
||||
}
|
||||
|
||||
@ -22,8 +22,7 @@ class FreshSupvHandler : public FreshDeviceHandlerBase {
|
||||
enum OpCode { DEFAULT_OPERATION = 0, PARSE_TM = 1 };
|
||||
|
||||
FreshSupvHandler(DhbConfig cfg, CookieIF* comCookie, Gpio uartIsolatorSwitch,
|
||||
PowerSwitchIF& switchIF, power::Switch_t powerSwitch,
|
||||
PlocSupvUartManager& supvHelper);
|
||||
PowerSwitchIF& switchIF, power::Switch_t powerSwitch);
|
||||
/**
|
||||
* Periodic helper executed function, implemented by child class.
|
||||
*/
|
||||
@ -82,7 +81,7 @@ class FreshSupvHandler : public FreshDeviceHandlerBase {
|
||||
enum class ShutdownState : uint8_t { IDLE, POWER_SWITCHING };
|
||||
ShutdownState shutdownState = ShutdownState::IDLE;
|
||||
|
||||
PlocSupvUartManager uartManager;
|
||||
PlocSupvUartManager* uartManager;
|
||||
CookieIF* comCookie;
|
||||
PowerSwitchIF& switchIF;
|
||||
power::Switch_t switchId;
|
||||
@ -114,7 +113,8 @@ class FreshSupvHandler : public FreshDeviceHandlerBase {
|
||||
pwrctrl::EnablePl enablePl = pwrctrl::EnablePl(objects::POWER_CONTROLLER);
|
||||
|
||||
struct ActiveCmdInfo {
|
||||
ActiveCmdInfo(uint32_t cmdCountdownMs) : cmdCountdown(cmdCountdownMs) {}
|
||||
ActiveCmdInfo(DeviceCommandId_t commandId, uint32_t cmdCountdownMs)
|
||||
: commandId(commandId), cmdCountdown(cmdCountdownMs) {}
|
||||
|
||||
DeviceCommandId_t commandId = DeviceHandlerIF::NO_COMMAND_ID;
|
||||
bool isPending = false;
|
||||
@ -132,14 +132,16 @@ class FreshSupvHandler : public FreshDeviceHandlerBase {
|
||||
// Map for Action commands. For normal commands, a separate static structure will be used.
|
||||
std::map<uint32_t, ActiveCmdInfo> activeActionCmds;
|
||||
|
||||
std::array<uint8_t, supv::MAX_COMMAND_SIZE> commandBuffer;
|
||||
std::array<uint8_t, supv::MAX_COMMAND_SIZE> commandBuffer{};
|
||||
SpacePacketCreator creator;
|
||||
supv::TcParams spParams = supv::TcParams(creator);
|
||||
|
||||
ReturnValue_t parseTmPackets();
|
||||
|
||||
ReturnValue_t sendCommand(TcBase& tc, bool replyPacketExpected, uint32_t cmdCountdownMs = 1000);
|
||||
ReturnValue_t sendEmptyCmd(uint16_t apid, uint8_t serviceId, bool replyPacketExpected);
|
||||
ReturnValue_t sendCommand(DeviceCommandId_t commandId, TcBase& tc, bool replyPacketExpected,
|
||||
uint32_t cmdCountdownMs = 1000);
|
||||
ReturnValue_t sendEmptyCmd(DeviceCommandId_t commandId, uint16_t apid, uint8_t serviceId,
|
||||
bool replyPacketExpected);
|
||||
ReturnValue_t prepareSelBootImageCmd(const uint8_t* commandData);
|
||||
ReturnValue_t prepareSetTimeRefCmd();
|
||||
ReturnValue_t prepareSetBootTimeoutCmd(const uint8_t* commandData, size_t cmdDataLen);
|
||||
|
||||
@ -21,8 +21,7 @@ PlocMpsocHandler::PlocMpsocHandler(object_id_t objectId, object_id_t uartComIFid
|
||||
sif::error << "PlocMPSoCHandler: Invalid communication cookie" << std::endl;
|
||||
}
|
||||
eventQueue = QueueFactory::instance()->createMessageQueue(10);
|
||||
commandActionHelperQueue =
|
||||
QueueFactory::instance()->createMessageQueue(10);
|
||||
commandActionHelperQueue = QueueFactory::instance()->createMessageQueue(10);
|
||||
spParams.maxSize = sizeof(commandBuffer);
|
||||
spParams.buf = commandBuffer;
|
||||
}
|
||||
|
||||
@ -504,7 +504,7 @@ ReturnValue_t PlocMpsocSpecialComHelper::checkReceivedTm() {
|
||||
triggerEvent(MPSOC_TM_SIZE_ERROR);
|
||||
return result;
|
||||
}
|
||||
spReader.checkCrc();
|
||||
result = spReader.checkCrc();
|
||||
if (result != returnvalue::OK) {
|
||||
sif::warning << "PLOC MPSoC: CRC check failed" << std::endl;
|
||||
triggerEvent(MPSOC_TM_CRC_MISSMATCH, *sequenceCount);
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,386 +0,0 @@
|
||||
#ifndef MISSION_DEVICES_PLOCSUPERVISORHANDLER_H_
|
||||
#define MISSION_DEVICES_PLOCSUPERVISORHANDLER_H_
|
||||
|
||||
#include <linux/payload/PlocSupvUartMan.h>
|
||||
#include <linux/payload/plocSupvDefs.h>
|
||||
#include <mission/controller/controllerdefinitions/PowerCtrlDefinitions.h>
|
||||
|
||||
#include "OBSWConfig.h"
|
||||
#include "devices/powerSwitcherList.h"
|
||||
#include "fsfw/devicehandlers/DeviceHandlerBase.h"
|
||||
#include "fsfw/timemanager/Countdown.h"
|
||||
#include "fsfw_hal/linux/gpio/Gpio.h"
|
||||
#include "fsfw_hal/linux/gpio/LinuxLibgpioIF.h"
|
||||
#include "fsfw_hal/linux/serial/SerialComIF.h"
|
||||
|
||||
#ifdef XIPHOS_Q7S
|
||||
#include "bsp_q7s/fs/SdCardManager.h"
|
||||
#endif
|
||||
|
||||
using supv::ExecutionReport;
|
||||
using supv::TcBase;
|
||||
|
||||
/**
|
||||
* @brief This is the device handler for the supervisor of the PLOC which is programmed by
|
||||
* Thales.
|
||||
*
|
||||
* @details The PLOC uses the space packet protocol for communication. On each command the PLOC
|
||||
* answers with at least one acknowledgment and one execution report.
|
||||
* Flight manual:
|
||||
* https://egit.irs.uni-stuttgart.de/redmine/projects/eive-flight-manual/wiki/PLOC_Commands
|
||||
* ILH ICD: https://eive-cloud.irs.uni-stuttgart.de/index.php/apps/files/?dir=/EIVE_IRS/
|
||||
* Arbeitsdaten/08_Used%20Components/PLOC&fileid=940960
|
||||
* @author J. Meier
|
||||
*/
|
||||
class PlocSupervisorHandler : public DeviceHandlerBase {
|
||||
public:
|
||||
PlocSupervisorHandler(object_id_t objectId, CookieIF* comCookie, Gpio uartIsolatorSwitch,
|
||||
power::Switch_t powerSwitch, PlocSupvUartManager& supvHelper);
|
||||
virtual ~PlocSupervisorHandler();
|
||||
|
||||
virtual ReturnValue_t initialize() override;
|
||||
void performOperationHook() override;
|
||||
ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
|
||||
const uint8_t* data, size_t size) override;
|
||||
|
||||
protected:
|
||||
void doStartUp() override;
|
||||
void doShutDown() override;
|
||||
ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t* id) override;
|
||||
ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t* id) override;
|
||||
void fillCommandAndReplyMap() override;
|
||||
ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand, const uint8_t* commandData,
|
||||
size_t commandDataLen) override;
|
||||
ReturnValue_t scanForReply(const uint8_t* start, size_t remainingSize, DeviceCommandId_t* foundId,
|
||||
size_t* foundLen) override;
|
||||
ReturnValue_t interpretDeviceReply(DeviceCommandId_t id, const uint8_t* packet) override;
|
||||
uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override;
|
||||
ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
|
||||
LocalDataPoolManager& poolManager) override;
|
||||
ReturnValue_t enableReplyInReplyMap(DeviceCommandMap::iterator command,
|
||||
uint8_t expectedReplies = 1, bool useAlternateId = false,
|
||||
DeviceCommandId_t alternateReplyID = 0) override;
|
||||
size_t getNextReplyLength(DeviceCommandId_t deviceCommand) override;
|
||||
// ReturnValue_t doSendReadHook() override;
|
||||
void doOffActivity() override;
|
||||
|
||||
private:
|
||||
static const uint16_t APID_MASK = 0x7FF;
|
||||
static const uint16_t PACKET_SEQUENCE_COUNT_MASK = 0x3FFF;
|
||||
static const uint8_t EXE_STATUS_OFFSET = 10;
|
||||
static const uint8_t SIZE_NULL_TERMINATOR = 1;
|
||||
// 5 s
|
||||
static const uint32_t EXECUTION_DEFAULT_TIMEOUT = 5000;
|
||||
// 70 S
|
||||
static const uint32_t ACKNOWLEDGE_DEFAULT_TIMEOUT = 5000;
|
||||
// 60 s
|
||||
static const uint32_t MRAM_DUMP_EXECUTION_TIMEOUT = 60000;
|
||||
// 70 s
|
||||
static const uint32_t COPY_ADC_TO_MRAM_TIMEOUT = 70000;
|
||||
// 60 s
|
||||
static const uint32_t MRAM_DUMP_TIMEOUT = 60000;
|
||||
|
||||
enum class StartupState : uint8_t {
|
||||
OFF,
|
||||
BOOTING,
|
||||
SET_TIME,
|
||||
WAIT_FOR_TIME_REPLY,
|
||||
TIME_WAS_SET,
|
||||
ON
|
||||
};
|
||||
|
||||
static constexpr bool SET_TIME_DURING_BOOT = true;
|
||||
|
||||
StartupState startupState = StartupState::OFF;
|
||||
|
||||
uint8_t commandBuffer[supv::MAX_COMMAND_SIZE];
|
||||
SpacePacketCreator creator;
|
||||
supv::TcParams spParams = supv::TcParams(creator);
|
||||
|
||||
/**
|
||||
* This variable is used to store the id of the next reply to receive. This is necessary
|
||||
* because the PLOC sends as reply to each command at least one acknowledgment and execution
|
||||
* report.
|
||||
*/
|
||||
DeviceCommandId_t nextReplyId = supv::NONE;
|
||||
|
||||
SerialComIF* uartComIf = nullptr;
|
||||
LinuxLibgpioIF* gpioComIF = nullptr;
|
||||
Gpio uartIsolatorSwitch;
|
||||
bool shutdownCmdSent = false;
|
||||
// Yeah, I am using an extra variable because I once again don't know
|
||||
// what the hell the base class is doing and I don't care anymore.
|
||||
bool normalCommandIsPending = false;
|
||||
// True men implement their reply timeout handling themselves!
|
||||
Countdown normalCmdCd = Countdown(2000);
|
||||
bool commandIsPending = false;
|
||||
Countdown cmdCd = Countdown(2000);
|
||||
|
||||
supv::HkSet hkset;
|
||||
supv::BootStatusReport bootStatusReport;
|
||||
supv::LatchupStatusReport latchupStatusReport;
|
||||
supv::CountersReport countersReport;
|
||||
supv::AdcReport adcReport;
|
||||
|
||||
const power::Switch_t powerSwitch = power::NO_SWITCH;
|
||||
supv::TmBase tmReader;
|
||||
|
||||
PlocSupvUartManager& uartManager;
|
||||
MessageQueueIF* eventQueue = nullptr;
|
||||
|
||||
/** Number of expected replies following the MRAM dump command */
|
||||
uint32_t expectedMramDumpPackets = 0;
|
||||
uint32_t receivedMramDumpPackets = 0;
|
||||
/** Set to true as soon as a complete space packet is present in the spacePacketBuffer */
|
||||
bool packetInBuffer = false;
|
||||
|
||||
/** This buffer is used to concatenate space packets received in two different read steps */
|
||||
uint8_t spacePacketBuffer[supv::MAX_PACKET_SIZE];
|
||||
|
||||
#ifdef XIPHOS_Q7S
|
||||
SdCardManager* sdcMan = nullptr;
|
||||
#endif
|
||||
|
||||
// Path to supervisor specific files on SD card
|
||||
std::string supervisorFilePath = "ploc/supervisor";
|
||||
std::string activeMramFile;
|
||||
|
||||
Countdown executionReportTimeout = Countdown(EXECUTION_DEFAULT_TIMEOUT, false);
|
||||
Countdown acknowledgementReportTimeout = Countdown(ACKNOWLEDGE_DEFAULT_TIMEOUT, false);
|
||||
// Vorago nees some time to boot properly
|
||||
Countdown bootTimeout = Countdown(supv::BOOT_TIMEOUT_MS);
|
||||
Countdown mramDumpTimeout = Countdown(MRAM_DUMP_TIMEOUT);
|
||||
|
||||
PoolEntry<uint16_t> adcRawEntry = PoolEntry<uint16_t>(16);
|
||||
PoolEntry<uint16_t> adcEngEntry = PoolEntry<uint16_t>(16);
|
||||
PoolEntry<uint32_t> latchupCounters = PoolEntry<uint32_t>(7);
|
||||
PoolEntry<uint8_t> fmcStateEntry = PoolEntry<uint8_t>(1);
|
||||
PoolEntry<uint8_t> bootStateEntry = PoolEntry<uint8_t>(1);
|
||||
PoolEntry<uint8_t> bootCyclesEntry = PoolEntry<uint8_t>(1);
|
||||
PoolEntry<uint32_t> tempSupEntry = PoolEntry<uint32_t>(1);
|
||||
|
||||
/**
|
||||
* @brief Adjusts the timeout of the execution report dependent on command
|
||||
*/
|
||||
void setExecutionTimeout(DeviceCommandId_t command);
|
||||
|
||||
void handlePacketPrint();
|
||||
|
||||
/**
|
||||
* @brief Handles event messages received from the supervisor helper
|
||||
*/
|
||||
void handleEvent(EventMessage* eventMessage);
|
||||
|
||||
ReturnValue_t getSwitches(const uint8_t** switches, uint8_t* numberOfSwitches);
|
||||
|
||||
/**
|
||||
* @brief This function checks the crc of the received PLOC reply.
|
||||
*
|
||||
* @param start Pointer to the first byte of the reply.
|
||||
* @param foundLen Pointer to the length of the whole packet.
|
||||
*
|
||||
* @return returnvalue::OK if CRC is ok, otherwise CRC_FAILURE.
|
||||
*/
|
||||
ReturnValue_t verifyPacket(const uint8_t* start, size_t foundLen);
|
||||
|
||||
/**
|
||||
* @brief This function handles the acknowledgment report.
|
||||
*
|
||||
* @param data Pointer to the data holding the acknowledgment report.
|
||||
*
|
||||
* @return returnvalue::OK if successful, otherwise an error code.
|
||||
*/
|
||||
ReturnValue_t handleAckReport(const uint8_t* data);
|
||||
|
||||
/**
|
||||
* @brief This function handles the data of a execution report.
|
||||
*
|
||||
* @param data Pointer to the received data packet.
|
||||
*
|
||||
* @return returnvalue::OK if successful, otherwise an error code.
|
||||
*/
|
||||
ReturnValue_t handleExecutionReport(const uint8_t* data);
|
||||
|
||||
/**
|
||||
* @brief This function handles the housekeeping report. This means verifying the CRC of the
|
||||
* reply and filling the appropriate dataset.
|
||||
*
|
||||
* @param data Pointer to the data buffer holding the housekeeping read report.
|
||||
*
|
||||
* @return returnvalue::OK if successful, otherwise an error code.
|
||||
*/
|
||||
ReturnValue_t handleHkReport(const uint8_t* data);
|
||||
|
||||
/**
|
||||
* @brief This function calls the function to check the CRC of the received boot status report
|
||||
* and fills the associated dataset with the boot status information.
|
||||
*/
|
||||
ReturnValue_t handleBootStatusReport(const uint8_t* data);
|
||||
|
||||
ReturnValue_t handleLatchupStatusReport(const uint8_t* data);
|
||||
ReturnValue_t handleCounterReport(const uint8_t* data);
|
||||
void handleBadApidServiceCombination(Event result, unsigned int apid, unsigned int serviceId);
|
||||
ReturnValue_t handleAdcReport(const uint8_t* data);
|
||||
ReturnValue_t genericHandleTm(const char* contextString, const uint8_t* data,
|
||||
LocalPoolDataSetBase& set);
|
||||
|
||||
void disableCommand(DeviceCommandId_t cmd);
|
||||
|
||||
/**
|
||||
* @brief Depending on the current active command, this function sets the reply id of the
|
||||
* next reply after a successful acknowledgment report has been received. This is
|
||||
* required by the function getNextReplyLength() to identify the length of the next
|
||||
* reply to read.
|
||||
*/
|
||||
void setNextReplyId();
|
||||
|
||||
/**
|
||||
* @brief This function handles action message replies in case the telemetry has been
|
||||
* requested by another object.
|
||||
*
|
||||
* @param data Pointer to the telemetry data.
|
||||
* @param dataSize Size of telemetry in bytes.
|
||||
* @param replyId Id of the reply. This will be added to the ActionMessage.
|
||||
*/
|
||||
void handleDeviceTm(const uint8_t* data, size_t dataSize, DeviceCommandId_t replyId);
|
||||
|
||||
/**
|
||||
* @brief This function prepares a space packet which does not transport any data in the
|
||||
* packet data field apart from the crc.
|
||||
*/
|
||||
ReturnValue_t prepareEmptyCmd(uint16_t apid, uint8_t serviceId);
|
||||
|
||||
/**
|
||||
* @brief This function initializes the space packet to select the boot image of the MPSoC.
|
||||
*/
|
||||
ReturnValue_t prepareSelBootImageCmd(const uint8_t* commandData);
|
||||
|
||||
ReturnValue_t prepareDisableHk();
|
||||
|
||||
/**
|
||||
* @brief This function fills the commandBuffer with the data to update the time of the
|
||||
* PLOC supervisor.
|
||||
*/
|
||||
ReturnValue_t prepareSetTimeRefCmd();
|
||||
|
||||
/**
|
||||
* @brief This function fills the commandBuffer with the data to change the boot timeout
|
||||
* value in the PLOC supervisor.
|
||||
*/
|
||||
ReturnValue_t prepareSetBootTimeoutCmd(const uint8_t* commandData);
|
||||
|
||||
ReturnValue_t prepareRestartTriesCmd(const uint8_t* commandData);
|
||||
|
||||
ReturnValue_t prepareFactoryResetCmd(const uint8_t* commandData, size_t len);
|
||||
|
||||
/**
|
||||
* @brief This function fills the command buffer with the packet to enable or disable the
|
||||
* watchdogs on the PLOC.
|
||||
*/
|
||||
void prepareWatchdogsEnableCmd(const uint8_t* commandData);
|
||||
|
||||
/**
|
||||
* @brief This function fills the command buffer with the packet to set the watchdog timer
|
||||
* of one of the three watchdogs (PS, PL, INT).
|
||||
*/
|
||||
ReturnValue_t prepareWatchdogsConfigTimeoutCmd(const uint8_t* commandData);
|
||||
|
||||
ReturnValue_t prepareLatchupConfigCmd(const uint8_t* commandData,
|
||||
DeviceCommandId_t deviceCommand);
|
||||
ReturnValue_t prepareSetAlertLimitCmd(const uint8_t* commandData);
|
||||
ReturnValue_t prepareSetAdcEnabledChannelsCmd(const uint8_t* commandData);
|
||||
ReturnValue_t prepareSetAdcWindowAndStrideCmd(const uint8_t* commandData);
|
||||
ReturnValue_t prepareSetAdcThresholdCmd(const uint8_t* commandData);
|
||||
ReturnValue_t prepareRunAutoEmTest(const uint8_t* commandData);
|
||||
ReturnValue_t prepareWipeMramCmd(const uint8_t* commandData);
|
||||
ReturnValue_t prepareSetGpioCmd(const uint8_t* commandData, size_t commandDataLen);
|
||||
ReturnValue_t prepareReadGpioCmd(const uint8_t* commandData, size_t commandDataLen);
|
||||
|
||||
/**
|
||||
* @brief Copies the content of a space packet to the command buffer.
|
||||
*/
|
||||
void finishTcPrep(TcBase& tc);
|
||||
|
||||
/**
|
||||
* @brief In case an acknowledgment failure reply has been received this function disables
|
||||
* all previously enabled commands and resets the exepected replies variable of an
|
||||
* active command.
|
||||
*/
|
||||
void disableAllReplies();
|
||||
|
||||
void disableReply(DeviceCommandId_t replyId);
|
||||
|
||||
/**
|
||||
* @brief This function sends a failure report if the active action was commanded by an other
|
||||
* object.
|
||||
*
|
||||
* @param replyId The id of the reply which signals a failure.
|
||||
* @param status A status byte which gives information about the failure type.
|
||||
*/
|
||||
void sendFailureReport(DeviceCommandId_t replyId, ReturnValue_t status);
|
||||
|
||||
/**
|
||||
* @brief This function disables the execution report reply. Within this function also the
|
||||
* the variable expectedReplies of an active command will be set to 0.
|
||||
*/
|
||||
void disableExeReportReply();
|
||||
|
||||
/**
|
||||
* @brief This function generates the Service 8 packets for the MRAM dump data.
|
||||
*/
|
||||
ReturnValue_t handleMramDumpPacket(DeviceCommandId_t id);
|
||||
|
||||
/**
|
||||
* @brief With this function the number of expected replies following an MRAM dump command
|
||||
* will be increased. This is necessary to release the command in case not all replies
|
||||
* have been received.
|
||||
*/
|
||||
void increaseExpectedMramReplies(DeviceCommandId_t id);
|
||||
|
||||
/**
|
||||
* @brief Writes the data of the MRAM dump to a file. The file will be created when receiving
|
||||
* the first packet.
|
||||
*/
|
||||
ReturnValue_t handleMramDumpFile(DeviceCommandId_t id);
|
||||
|
||||
/**
|
||||
* @brief Extracts the length field of a spacePacket referenced by the spacePacket pointer.
|
||||
*
|
||||
* @param spacePacket Pointer to the buffer holding the space packet.
|
||||
*
|
||||
* @return The value stored in the length field of the data field.
|
||||
*/
|
||||
uint16_t readSpacePacketLength(uint8_t* spacePacket);
|
||||
|
||||
/**
|
||||
* @brief Extracts the sequence flags from a space packet referenced by the spacePacket
|
||||
* pointer.
|
||||
*
|
||||
* @param spacePacket Pointer to the buffer holding the space packet.
|
||||
*
|
||||
* @return uint8_t where the two least significant bits hold the sequence flags.
|
||||
*/
|
||||
uint8_t readSequenceFlags(uint8_t* spacePacket);
|
||||
|
||||
ReturnValue_t createMramDumpFile();
|
||||
ReturnValue_t getTimeStampString(std::string& timeStamp);
|
||||
|
||||
ReturnValue_t prepareSetShutdownTimeoutCmd(const uint8_t* commandData);
|
||||
|
||||
ReturnValue_t extractUpdateCommand(const uint8_t* commandData, size_t size,
|
||||
supv::UpdateParams& params);
|
||||
ReturnValue_t extractBaseParams(const uint8_t** commandData, size_t& remSize,
|
||||
supv::UpdateParams& params);
|
||||
ReturnValue_t eventSubscription();
|
||||
|
||||
ReturnValue_t handleExecutionSuccessReport(ExecutionReport& report);
|
||||
void handleExecutionFailureReport(ExecutionReport& report);
|
||||
|
||||
void printAckFailureInfo(uint16_t statusCode, DeviceCommandId_t commandId);
|
||||
|
||||
pwrctrl::EnablePl enablePl = pwrctrl::EnablePl(objects::POWER_CONTROLLER);
|
||||
ReturnValue_t checkModeCommand(Mode_t commandedMode, Submode_t commandedSubmode,
|
||||
uint32_t* msToReachTheMode) override;
|
||||
};
|
||||
|
||||
#endif /* MISSION_DEVICES_PLOCSUPERVISORHANDLER_H_ */
|
||||
@ -80,7 +80,6 @@ ReturnValue_t PlocSupvUartManager::initializeInterface(CookieIF* cookie) {
|
||||
}
|
||||
// Flush received and unread data
|
||||
tcflush(serialPort, TCIOFLUSH);
|
||||
sif::debug << "serial port: " << serialPort << std::endl;
|
||||
return OK;
|
||||
}
|
||||
|
||||
@ -98,9 +97,10 @@ ReturnValue_t PlocSupvUartManager::initialize() {
|
||||
ReturnValue_t PlocSupvUartManager::performOperation(uint8_t operationCode) {
|
||||
bool putTaskToSleep = false;
|
||||
while (true) {
|
||||
lock->lockMutex();
|
||||
{
|
||||
MutexGuard mg(lock);
|
||||
state = InternalState::SLEEPING;
|
||||
lock->unlockMutex();
|
||||
}
|
||||
semaphore->acquire();
|
||||
putTaskToSleep = false;
|
||||
#if OBSW_THREAD_TRACING == 1
|
||||
@ -112,9 +112,11 @@ ReturnValue_t PlocSupvUartManager::performOperation(uint8_t operationCode) {
|
||||
break;
|
||||
}
|
||||
handleUartReception();
|
||||
lock->lockMutex();
|
||||
InternalState currentState = state;
|
||||
lock->unlockMutex();
|
||||
InternalState currentState;
|
||||
{
|
||||
MutexGuard mg(lock);
|
||||
currentState = state;
|
||||
}
|
||||
switch (currentState) {
|
||||
case InternalState::SLEEPING:
|
||||
case InternalState::GO_TO_SLEEP: {
|
||||
@ -140,9 +142,7 @@ ReturnValue_t PlocSupvUartManager::performOperation(uint8_t operationCode) {
|
||||
ReturnValue_t PlocSupvUartManager::handleUartReception() {
|
||||
ReturnValue_t result = OK;
|
||||
ReturnValue_t status = OK;
|
||||
sif::debug << "reading port " << serialPort << std::endl;
|
||||
TaskFactory::delayTask(100);
|
||||
ssize_t bytesRead = read(302, reinterpret_cast<void*>(recBuf.data()),
|
||||
ssize_t bytesRead = read(serialPort, reinterpret_cast<void*>(recBuf.data()),
|
||||
static_cast<unsigned int>(recBuf.size()));
|
||||
if (bytesRead == 0) {
|
||||
while (result != NO_PACKET_FOUND) {
|
||||
@ -160,7 +160,7 @@ ReturnValue_t PlocSupvUartManager::handleUartReception() {
|
||||
<< " bytes" << std::endl;
|
||||
return FAILED;
|
||||
} else if (bytesRead > 0) {
|
||||
if (debugMode) {
|
||||
if (DEBUG_MODE) {
|
||||
sif::info << "Received " << bytesRead << " bytes from the PLOC Supervisor:" << std::endl;
|
||||
arrayprinter::print(recBuf.data(), bytesRead);
|
||||
}
|
||||
@ -575,7 +575,7 @@ ReturnValue_t PlocSupvUartManager::handlePacketTransmissionNoReply(
|
||||
size_t packetLen = 0;
|
||||
decodedQueue.retrieve(&packetLen);
|
||||
decodedRingBuf.readData(decodedBuf.data(), packetLen, true);
|
||||
tmReader.setData(decodedBuf.data(), packetLen);
|
||||
tmReader.setReadOnlyData(decodedBuf.data(), packetLen);
|
||||
result = checkReceivedTm();
|
||||
if (result != returnvalue::OK) {
|
||||
continue;
|
||||
@ -621,7 +621,7 @@ int PlocSupvUartManager::handleAckReception(supv::TcBase& tc, size_t packetLen)
|
||||
if (serviceId == static_cast<uint8_t>(supv::tm::TmtcId::ACK) or
|
||||
serviceId == static_cast<uint8_t>(supv::tm::TmtcId::NAK)) {
|
||||
AcknowledgmentReport ackReport(tmReader);
|
||||
ReturnValue_t result = ackReport.parse();
|
||||
ReturnValue_t result = ackReport.parse(false);
|
||||
if (result != returnvalue::OK) {
|
||||
triggerEvent(ACK_RECEPTION_FAILURE);
|
||||
return -1;
|
||||
@ -631,7 +631,7 @@ int PlocSupvUartManager::handleAckReception(supv::TcBase& tc, size_t packetLen)
|
||||
if (serviceId == static_cast<uint8_t>(supv::tm::TmtcId::ACK)) {
|
||||
return 1;
|
||||
} else if (serviceId == static_cast<uint8_t>(supv::tm::TmtcId::NAK)) {
|
||||
ackReport.printStatusInformation();
|
||||
ackReport.printStatusInformationAck();
|
||||
triggerEvent(
|
||||
SUPV_ACK_FAILURE_REPORT,
|
||||
buildApidServiceParam1(ackReport.getRefModuleApid(), ackReport.getRefServiceId()),
|
||||
@ -653,7 +653,7 @@ int PlocSupvUartManager::handleExeAckReception(supv::TcBase& tc, size_t packetLe
|
||||
if (serviceId == static_cast<uint8_t>(supv::tm::TmtcId::EXEC_ACK) or
|
||||
serviceId == static_cast<uint8_t>(supv::tm::TmtcId::EXEC_NAK)) {
|
||||
ExecutionReport exeReport(tmReader);
|
||||
ReturnValue_t result = exeReport.parse();
|
||||
ReturnValue_t result = exeReport.parse(false);
|
||||
if (result != returnvalue::OK) {
|
||||
triggerEvent(EXE_RECEPTION_FAILURE);
|
||||
return -1;
|
||||
@ -663,7 +663,7 @@ int PlocSupvUartManager::handleExeAckReception(supv::TcBase& tc, size_t packetLe
|
||||
if (serviceId == static_cast<uint8_t>(supv::tm::TmtcId::EXEC_ACK)) {
|
||||
return 1;
|
||||
} else if (serviceId == static_cast<uint8_t>(supv::tm::TmtcId::EXEC_NAK)) {
|
||||
exeReport.printStatusInformation();
|
||||
exeReport.printStatusInformationExe();
|
||||
triggerEvent(
|
||||
SUPV_EXE_FAILURE_REPORT,
|
||||
buildApidServiceParam1(exeReport.getRefModuleApid(), exeReport.getRefServiceId()),
|
||||
@ -686,7 +686,7 @@ ReturnValue_t PlocSupvUartManager::checkReceivedTm() {
|
||||
triggerEvent(SUPV_REPLY_SIZE_MISSMATCH, rememberApid);
|
||||
return result;
|
||||
}
|
||||
if (not tmReader.verifyCrc()) {
|
||||
if (tmReader.checkCrc() != returnvalue::OK) {
|
||||
triggerEvent(SUPV_REPLY_CRC_MISSMATCH, rememberApid);
|
||||
return result;
|
||||
}
|
||||
@ -762,7 +762,7 @@ ReturnValue_t PlocSupvUartManager::handleCheckMemoryCommand(uint8_t failStep) {
|
||||
size_t packetLen = 0;
|
||||
decodedQueue.retrieve(&packetLen);
|
||||
decodedRingBuf.readData(decodedBuf.data(), packetLen, true);
|
||||
tmReader.setData(decodedBuf.data(), packetLen);
|
||||
tmReader.setReadOnlyData(decodedBuf.data(), packetLen);
|
||||
result = checkReceivedTm();
|
||||
if (result != returnvalue::OK) {
|
||||
continue;
|
||||
@ -790,7 +790,7 @@ ReturnValue_t PlocSupvUartManager::handleCheckMemoryCommand(uint8_t failStep) {
|
||||
} else if (tmReader.getModuleApid() == Apid::MEM_MAN) {
|
||||
if (ackReceived) {
|
||||
supv::UpdateStatusReport report(tmReader);
|
||||
result = report.parse();
|
||||
result = report.parse(false);
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
}
|
||||
@ -966,12 +966,10 @@ ReturnValue_t PlocSupvUartManager::handleRunningLongerRequest() {
|
||||
ReturnValue_t PlocSupvUartManager::encodeAndSendPacket(const uint8_t* sendData, size_t sendLen) {
|
||||
size_t encodedLen = 0;
|
||||
addHdlcFraming(sendData, sendLen, encodedSendBuf.data(), &encodedLen, encodedSendBuf.size());
|
||||
if (printTc) {
|
||||
if (PRINT_TC) {
|
||||
sif::debug << "Sending TC" << std::endl;
|
||||
arrayprinter::print(encodedSendBuf.data(), encodedLen);
|
||||
}
|
||||
sif::debug << "writing to serial port: " << serialPort << std::endl;
|
||||
TaskFactory::delayTask(50);
|
||||
size_t bytesWritten = write(serialPort, encodedSendBuf.data(), encodedLen);
|
||||
if (bytesWritten != encodedLen) {
|
||||
sif::warning
|
||||
@ -990,6 +988,9 @@ ReturnValue_t PlocSupvUartManager::readReceivedMessage(CookieIF* cookie, uint8_t
|
||||
return OK;
|
||||
}
|
||||
ipcQueue.retrieve(size);
|
||||
if (*size > ipcBuffer.size()) {
|
||||
return FAILED;
|
||||
}
|
||||
*buffer = ipcBuffer.data();
|
||||
ReturnValue_t result = ipcRingBuf.readData(ipcBuffer.data(), *size, true);
|
||||
if (result != OK) {
|
||||
@ -1090,11 +1091,14 @@ void PlocSupvUartManager::performUartShutdown() {
|
||||
while (not decodedQueue.empty()) {
|
||||
decodedQueue.pop();
|
||||
}
|
||||
MutexGuard mg(ipcLock);
|
||||
{
|
||||
MutexGuard mg0(ipcLock);
|
||||
ipcRingBuf.clear();
|
||||
while (not ipcQueue.empty()) {
|
||||
ipcQueue.pop();
|
||||
}
|
||||
}
|
||||
MutexGuard mg1(lock);
|
||||
state = InternalState::GO_TO_SLEEP;
|
||||
}
|
||||
|
||||
|
||||
@ -282,8 +282,8 @@ class PlocSupvUartManager : public DeviceCommunicationIF,
|
||||
|
||||
std::array<uint8_t, supv::MAX_COMMAND_SIZE> tmBuf{};
|
||||
|
||||
bool printTc = true;
|
||||
bool debugMode = true;
|
||||
static constexpr bool PRINT_TC = false;
|
||||
static constexpr bool DEBUG_MODE = false;
|
||||
bool timestamping = true;
|
||||
|
||||
// Remembers APID to know at which command a procedure failed
|
||||
|
||||
@ -556,15 +556,6 @@ class TmBase : public ploc::SpTmReader {
|
||||
}
|
||||
}
|
||||
|
||||
bool verifyCrc() {
|
||||
if (checkCrc() == returnvalue::OK) {
|
||||
crcOk = true;
|
||||
}
|
||||
return crcOk;
|
||||
}
|
||||
|
||||
bool crcIsOk() const { return crcOk; }
|
||||
|
||||
uint8_t getServiceId() const { return getPacketData()[TIMESTAMP_LEN]; }
|
||||
|
||||
uint16_t getModuleApid() const { return getApid() & APID_MODULE_MASK; }
|
||||
@ -576,9 +567,6 @@ class TmBase : public ploc::SpTmReader {
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
private:
|
||||
bool crcOk = false;
|
||||
};
|
||||
|
||||
class NoPayloadPacket : public TcBase {
|
||||
@ -786,8 +774,6 @@ class SetRestartTries : public TcBase {
|
||||
}
|
||||
|
||||
private:
|
||||
uint8_t restartTries = 0;
|
||||
|
||||
void initPacket(uint8_t restartTries) { payloadStart[0] = restartTries; }
|
||||
};
|
||||
|
||||
@ -848,8 +834,6 @@ class LatchupAlert : public TcBase {
|
||||
}
|
||||
|
||||
private:
|
||||
uint8_t latchupId = 0;
|
||||
|
||||
void initPacket(uint8_t latchupId) { payloadStart[0] = latchupId; }
|
||||
};
|
||||
|
||||
@ -879,9 +863,6 @@ class SetAlertlimit : public TcBase {
|
||||
}
|
||||
|
||||
private:
|
||||
uint8_t latchupId = 0;
|
||||
uint32_t dutycycle = 0;
|
||||
|
||||
ReturnValue_t initPacket(uint8_t latchupId, uint32_t dutycycle) {
|
||||
payloadStart[0] = latchupId;
|
||||
size_t serLen = 0;
|
||||
@ -1312,8 +1293,8 @@ class VerificationReport {
|
||||
|
||||
virtual ~VerificationReport() = default;
|
||||
|
||||
virtual ReturnValue_t parse() {
|
||||
if (not readerBase.crcIsOk()) {
|
||||
virtual ReturnValue_t parse(bool checkCrc) {
|
||||
if (checkCrc and readerBase.checkCrc() != returnvalue::OK) {
|
||||
return result::CRC_FAILURE;
|
||||
}
|
||||
if (readerBase.getModuleApid() != Apid::TMTC_MAN) {
|
||||
@ -1330,27 +1311,27 @@ class VerificationReport {
|
||||
ReturnValue_t result = SerializeAdapter::deSerialize(&refApid, &payloadStart, &remLen,
|
||||
SerializeIF::Endianness::BIG);
|
||||
if (result != returnvalue::OK) {
|
||||
sif::debug << "VerificationReport: Failed to deserialize reference APID field" << std::endl;
|
||||
sif::warning << "VerificationReport: Failed to deserialize reference APID field" << std::endl;
|
||||
return result;
|
||||
}
|
||||
result = SerializeAdapter::deSerialize(&refServiceId, &payloadStart, &remLen,
|
||||
SerializeIF::Endianness::BIG);
|
||||
if (result != returnvalue::OK) {
|
||||
sif::debug << "VerificationReport: Failed to deserialize reference Service ID field"
|
||||
sif::warning << "VerificationReport: Failed to deserialize reference Service ID field"
|
||||
<< std::endl;
|
||||
return result;
|
||||
}
|
||||
result = SerializeAdapter::deSerialize(&refSeqCount, &payloadStart, &remLen,
|
||||
SerializeIF::Endianness::BIG);
|
||||
if (result != returnvalue::OK) {
|
||||
sif::debug << "VerificationReport: Failed to deserialize reference sequence count field"
|
||||
sif::warning << "VerificationReport: Failed to deserialize reference sequence count field"
|
||||
<< std::endl;
|
||||
return result;
|
||||
}
|
||||
result = SerializeAdapter::deSerialize(&statusCode, &payloadStart, &remLen,
|
||||
SerializeIF::Endianness::BIG);
|
||||
if (result != returnvalue::OK) {
|
||||
sif::debug << "VerificationReport: Failed to deserialize status code field" << std::endl;
|
||||
sif::warning << "VerificationReport: Failed to deserialize status code field" << std::endl;
|
||||
return result;
|
||||
}
|
||||
return returnvalue::OK;
|
||||
@ -1367,7 +1348,7 @@ class VerificationReport {
|
||||
|
||||
uint32_t getStatusCode() const { return statusCode; }
|
||||
|
||||
virtual void printStatusInformation(const char* prefix) {
|
||||
virtual void printStatusInformation(const char* prefix) const {
|
||||
bool codeHandled = true;
|
||||
if (statusCode < 0x100) {
|
||||
GeneralStatusCode code = static_cast<GeneralStatusCode>(getStatusCode());
|
||||
@ -1654,15 +1635,15 @@ class AcknowledgmentReport : public VerificationReport {
|
||||
public:
|
||||
AcknowledgmentReport(TmBase& readerBase) : VerificationReport(readerBase) {}
|
||||
|
||||
virtual ReturnValue_t parse() override {
|
||||
ReturnValue_t parse(bool checkCrc) override {
|
||||
if (readerBase.getServiceId() != static_cast<uint8_t>(tm::TmtcId::ACK) and
|
||||
readerBase.getServiceId() != static_cast<uint8_t>(tm::TmtcId::NAK)) {
|
||||
return result::INVALID_SERVICE_ID;
|
||||
}
|
||||
return VerificationReport::parse();
|
||||
return VerificationReport::parse(checkCrc);
|
||||
}
|
||||
|
||||
void printStatusInformation() {
|
||||
void printStatusInformationAck() {
|
||||
VerificationReport::printStatusInformation(STATUS_PRINTOUT_PREFIX);
|
||||
}
|
||||
|
||||
@ -1676,15 +1657,15 @@ class ExecutionReport : public VerificationReport {
|
||||
|
||||
TmBase& getReader() { return readerBase; }
|
||||
|
||||
ReturnValue_t parse() override {
|
||||
ReturnValue_t parse(bool checkCrc) override {
|
||||
if (readerBase.getServiceId() != static_cast<uint8_t>(tm::TmtcId::EXEC_ACK) and
|
||||
readerBase.getServiceId() != static_cast<uint8_t>(tm::TmtcId::EXEC_NAK)) {
|
||||
return returnvalue::FAILED;
|
||||
}
|
||||
return VerificationReport::parse();
|
||||
return VerificationReport::parse(checkCrc);
|
||||
}
|
||||
|
||||
void printStatusInformation() {
|
||||
void printStatusInformationExe() {
|
||||
VerificationReport::printStatusInformation(STATUS_PRINTOUT_PREFIX);
|
||||
}
|
||||
|
||||
@ -1696,8 +1677,8 @@ class UpdateStatusReport {
|
||||
public:
|
||||
UpdateStatusReport(TmBase& tmReader) : tmReader(tmReader) {}
|
||||
|
||||
ReturnValue_t parse() {
|
||||
if (not tmReader.crcIsOk()) {
|
||||
ReturnValue_t parse(bool checkCrc) {
|
||||
if (checkCrc and tmReader.checkCrc() != returnvalue::OK) {
|
||||
return result::CRC_FAILURE;
|
||||
}
|
||||
if (tmReader.getModuleApid() != Apid::MEM_MAN) {
|
||||
|
||||
@ -104,10 +104,6 @@ class SpTmReader : public SpacePacketReader {
|
||||
*/
|
||||
SpTmReader(const uint8_t* buf, size_t maxSize) : SpacePacketReader(buf, maxSize) {}
|
||||
|
||||
ReturnValue_t setData(const uint8_t* buf, size_t maxSize) {
|
||||
return setReadOnlyData(buf, maxSize);
|
||||
}
|
||||
|
||||
ReturnValue_t checkCrc() const {
|
||||
if (CRC::crc16ccitt(getFullData(), getFullPacketLen()) != 0) {
|
||||
return returnvalue::FAILED;
|
||||
|
||||
Loading…
Reference in New Issue
Block a user