eive/eive-obsw
eive/eive-obsw
12
3
Fork 0
Code Issues 4 Pull Requests 3 Releases 119 Wiki Activity

remove non-working commands
All checks were successful
EIVE/eive-obsw/pipeline/pr-develop This commit looks good
Details

Browse Source
This commit is contained in:
Robin Müller 2022-11-08 20:04:57 +01:00
parent 27e46615b6
commit fd5cc19231
No known key found for this signature in database
GPG Key ID: 71B58F8A3CDFA9AC
3 changed files with 65 additions and 133 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -1248,6 +1248,8 @@ class ExecutionReport : public VerificationReport {
public: public:
ExecutionReport(TmBase& readerBase) : VerificationReport(readerBase) {} ExecutionReport(TmBase& readerBase) : VerificationReport(readerBase) {}
TmBase& getReader() { return readerBase; }
ReturnValue_t parse() override { ReturnValue_t parse() override {
if (readerBase.getServiceId() != static_cast<uint8_t>(tm::TmtcId::EXEC_ACK) and if (readerBase.getServiceId() != static_cast<uint8_t>(tm::TmtcId::EXEC_ACK) and
readerBase.getServiceId() != static_cast<uint8_t>(tm::TmtcId::EXEC_NAK)) { readerBase.getServiceId() != static_cast<uint8_t>(tm::TmtcId::EXEC_NAK)) {

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

@ -443,55 +443,39 @@ ReturnValue_t PlocSupervisorHandler::buildCommandFromCommand(DeviceCommandId_t d
} }
void PlocSupervisorHandler::fillCommandAndReplyMap() { void PlocSupervisorHandler::fillCommandAndReplyMap() {
// Command only
insertInCommandMap(GET_HK_REPORT); insertInCommandMap(GET_HK_REPORT);
insertInCommandMap(START_MPSOC); insertInCommandMap(START_MPSOC);
insertInCommandMap(SHUTDOWN_MPSOC); insertInCommandMap(SHUTDOWN_MPSOC);
this->insertInCommandMap(SEL_MPSOC_BOOT_IMAGE); insertInCommandMap(SEL_MPSOC_BOOT_IMAGE);
this->insertInCommandMap(SET_BOOT_TIMEOUT); insertInCommandMap(SET_BOOT_TIMEOUT);
this->insertInCommandMap(SET_MAX_RESTART_TRIES); insertInCommandMap(SET_MAX_RESTART_TRIES);
this->insertInCommandMap(RESET_MPSOC); insertInCommandMap(RESET_MPSOC);
this->insertInCommandMap(SET_TIME_REF); insertInCommandMap(SET_TIME_REF);
this->insertInCommandMap(DISABLE_PERIOIC_HK_TRANSMISSION); insertInCommandMap(DISABLE_PERIOIC_HK_TRANSMISSION);
this->insertInCommandMap(GET_BOOT_STATUS_REPORT); insertInCommandMap(GET_BOOT_STATUS_REPORT);
this->insertInCommandMap(ENABLE_LATCHUP_ALERT); insertInCommandMap(ENABLE_LATCHUP_ALERT);
this->insertInCommandMap(DISABLE_LATCHUP_ALERT); insertInCommandMap(DISABLE_LATCHUP_ALERT);
this->insertInCommandMap(SET_ALERT_LIMIT); insertInCommandMap(SET_ALERT_LIMIT);
this->insertInCommandMap(SET_ADC_ENABLED_CHANNELS); insertInCommandMap(GET_LATCHUP_STATUS_REPORT);
this->insertInCommandMap(SET_ADC_WINDOW_AND_STRIDE); insertInCommandMap(RUN_AUTO_EM_TESTS);
this->insertInCommandMap(SET_ADC_THRESHOLD); insertInCommandMap(SET_GPIO);
this->insertInCommandMap(GET_LATCHUP_STATUS_REPORT); insertInCommandMap(READ_GPIO);
this->insertInCommandMap(COPY_ADC_DATA_TO_MRAM); insertInCommandMap(SET_SHUTDOWN_TIMEOUT);
this->insertInCommandMap(REQUEST_ADC_REPORT); insertInCommandMap(FACTORY_FLASH);
this->insertInCommandMap(RUN_AUTO_EM_TESTS); insertInCommandMap(RESET_PL);
this->insertInCommandMap(WIPE_MRAM);
this->insertInCommandMap(SET_GPIO); // ACK replies, use countdown for them
this->insertInCommandMap(READ_GPIO); insertInReplyMap(ACK_REPORT, 0, nullptr, SIZE_ACK_REPORT, false,
this->insertInCommandMap(RESTART_SUPERVISOR);
this->insertInCommandMap(FACTORY_RESET_CLEAR_ALL);
this->insertInCommandMap(FACTORY_RESET_CLEAR_MIRROR);
this->insertInCommandMap(FACTORY_RESET_CLEAR_CIRCULAR);
this->insertInCommandMap(START_MPSOC_QUIET);
this->insertInCommandMap(SET_SHUTDOWN_TIMEOUT);
this->insertInCommandMap(FACTORY_FLASH);
this->insertInCommandMap(ENABLE_AUTO_TM);
this->insertInCommandMap(DISABLE_AUTO_TM);
this->insertInCommandMap(LOGGING_REQUEST_COUNTERS);
this->insertInCommandMap(LOGGING_CLEAR_COUNTERS);
this->insertInCommandMap(LOGGING_SET_TOPIC);
this->insertInCommandMap(RESET_PL);
this->insertInCommandMap(ENABLE_NVMS);
this->insertInCommandAndReplyMap(FIRST_MRAM_DUMP, 0, nullptr, 0, false, false, FIRST_MRAM_DUMP,
&mramDumpTimeout);
this->insertInCommandAndReplyMap(CONSECUTIVE_MRAM_DUMP, 0, nullptr, 0, false, false,
CONSECUTIVE_MRAM_DUMP, &mramDumpTimeout);
this->insertInReplyMap(ACK_REPORT, 3, nullptr, SIZE_ACK_REPORT, false,
&acknowledgementReportTimeout); &acknowledgementReportTimeout);
this->insertInReplyMap(EXE_REPORT, 0, nullptr, SIZE_EXE_REPORT, false, &executionReportTimeout); insertInReplyMap(EXE_REPORT, 0, nullptr, SIZE_EXE_REPORT, false, &executionReportTimeout);
this->insertInReplyMap(HK_REPORT, 3, &hkset, SIZE_HK_REPORT);
this->insertInReplyMap(BOOT_STATUS_REPORT, 3, &bootStatusReport, SIZE_BOOT_STATUS_REPORT); // TM replies
this->insertInReplyMap(LATCHUP_REPORT, 3, &latchupStatusReport, SIZE_LATCHUP_STATUS_REPORT); insertInReplyMap(HK_REPORT, 3, &hkset, SIZE_HK_REPORT);
this->insertInReplyMap(LOGGING_REPORT, 3, &loggingReport, SIZE_LOGGING_REPORT); insertInReplyMap(BOOT_STATUS_REPORT, 3, &bootStatusReport, SIZE_BOOT_STATUS_REPORT);
this->insertInReplyMap(ADC_REPORT, 3, &adcReport, SIZE_ADC_REPORT); insertInReplyMap(LATCHUP_REPORT, 3, &latchupStatusReport, SIZE_LATCHUP_STATUS_REPORT);
insertInReplyMap(LOGGING_REPORT, 3, &loggingReport, SIZE_LOGGING_REPORT);
insertInReplyMap(ADC_REPORT, 3, &adcReport, SIZE_ADC_REPORT);
} }
ReturnValue_t PlocSupervisorHandler::enableReplyInReplyMap(DeviceCommandMap::iterator command, ReturnValue_t PlocSupervisorHandler::enableReplyInReplyMap(DeviceCommandMap::iterator command,
@ -723,18 +707,10 @@ ReturnValue_t PlocSupervisorHandler::interpretDeviceReply(DeviceCommandId_t id,
result = handleLatchupStatusReport(packet); result = handleLatchupStatusReport(packet);
break; break;
} }
// case (LOGGING_REPORT): {
// result = handleLoggingReport(packet);
// break;
// }
case (ADC_REPORT): { case (ADC_REPORT): {
result = handleAdcReport(packet); result = handleAdcReport(packet);
break; break;
} }
case (FIRST_MRAM_DUMP):
case (CONSECUTIVE_MRAM_DUMP):
result = handleMramDumpPacket(id);
break;
case (EXE_REPORT): { case (EXE_REPORT): {
result = handleExecutionReport(packet); result = handleExecutionReport(packet);
break; break;
@ -749,22 +725,6 @@ ReturnValue_t PlocSupervisorHandler::interpretDeviceReply(DeviceCommandId_t id,
return result; return result;
} }
ReturnValue_t PlocSupervisorHandler::getSwitches(const uint8_t** switches,
uint8_t* numberOfSwitches) {
if (powerSwitch == power::NO_SWITCH) {
return DeviceHandlerBase::NO_SWITCH;
}
*numberOfSwitches = 1;
*switches = &powerSwitch;
return returnvalue::OK;
}
void PlocSupervisorHandler::setNormalDatapoolEntriesInvalid() {}
uint32_t PlocSupervisorHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) {
return 7000;
}
ReturnValue_t PlocSupervisorHandler::initializeLocalDataPool(localpool::DataPool& localDataPoolMap, ReturnValue_t PlocSupervisorHandler::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
LocalDataPoolManager& poolManager) { LocalDataPoolManager& poolManager) {
localDataPoolMap.emplace(supv::NUM_TMS, new PoolEntry<uint32_t>({0})); localDataPoolMap.emplace(supv::NUM_TMS, new PoolEntry<uint32_t>({0}));
@ -975,40 +935,6 @@ ReturnValue_t PlocSupervisorHandler::handleExecutionReport(const uint8_t* data)
} }
nextReplyId = supv::NONE; nextReplyId = supv::NONE;
return result; return result;
// TODO: Fix
// ExecutionReport exe(data, SIZE_EXE_REPORT);
// result = exe.checkSize();
// if (result != returnvalue::OK) {
// return result;
// }
//
// result = exe.checkCrc();
// if (result != returnvalue::OK) {
// sif::error << "PlocSupervisorHandler::handleExecutionReport: CRC failure" << std::endl;
// nextReplyId = supv::NONE;
// return result;
// }
//
// result = exe.checkApid();
//
// switch (result) {
// case (returnvalue::OK): {
// handleExecutionSuccessReport(data);
// break;
// }
// case (SupvReturnValuesIF::RECEIVED_EXE_FAILURE): {
// handleExecutionFailureReport(exe.getStatusCode());
// result = returnvalue::OK;
// break;
// }
// default: {
// sif::error << "PlocSupervisorHandler::handleExecutionReport: Unknown APID" << std::endl;
// result = returnvalue::FAILED;
// break;
// }
// }
// nextReplyId = supv::NONE;
return result;
} }
ReturnValue_t PlocSupervisorHandler::handleHkReport(const uint8_t* data) { ReturnValue_t PlocSupervisorHandler::handleHkReport(const uint8_t* data) {
@ -2096,38 +2022,29 @@ ReturnValue_t PlocSupervisorHandler::eventSubscription() {
ReturnValue_t PlocSupervisorHandler::handleExecutionSuccessReport(ExecutionReport& report) { ReturnValue_t PlocSupervisorHandler::handleExecutionSuccessReport(ExecutionReport& report) {
DeviceCommandId_t commandId = getPendingCommand(); DeviceCommandId_t commandId = getPendingCommand();
ReturnValue_t result = OK;
switch (commandId) { switch (commandId) {
case supv::READ_GPIO: { case supv::READ_GPIO: {
// TODO: Fix // TODO: Fix
// supv::ExecutionReport exe(data, supv::SIZE_EXE_REPORT); uint16_t gpioState = report.getStatusCode();
// if (exe.isNull()) { #if OBSW_DEBUG_PLOC_SUPERVISOR == 1
// return returnvalue::FAILED; sif::info << "PlocSupervisorHandler: Read GPIO TM, State: " << gpioState << std::endl;
// } #endif /* OBSW_DEBUG_PLOC_SUPERVISOR == 1 */
// ReturnValue_t result = exe.checkSize(); DeviceCommandMap::iterator iter = deviceCommandMap.find(commandId);
// if (result != returnvalue::OK) { if (iter->second.sendReplyTo == NO_COMMAND_ID) {
// return result; return returnvalue::OK;
// } }
// uint16_t gpioState = exe.getStatusCode(); uint8_t data[sizeof(gpioState)];
//#if OBSW_DEBUG_PLOC_SUPERVISOR == 1 size_t size = 0;
// sif::info << "PlocSupervisorHandler: Read GPIO TM, State: " << gpioState << std::endl; result = SerializeAdapter::serialize(&gpioState, data, &size, sizeof(gpioState),
//#endif /* OBSW_DEBUG_PLOC_SUPERVISOR == 1 */ SerializeIF::Endianness::BIG);
// DeviceCommandMap::iterator iter = deviceCommandMap.find(commandId); if (result != returnvalue::OK) {
// if (iter->second.sendReplyTo == NO_COMMAND_ID) { sif::debug << "PlocSupervisorHandler: Failed to deserialize GPIO state" << std::endl;
// return returnvalue::OK; }
// } result = actionHelper.reportData(iter->second.sendReplyTo, commandId, data, sizeof(data));
// uint8_t data[sizeof(gpioState)]; if (result != returnvalue::OK) {
// size_t size = 0; sif::warning << "PlocSupervisorHandler: Read GPIO, failed to report data" << std::endl;
// result = SerializeAdapter::serialize(&gpioState, data, &size, sizeof(gpioState), }
// SerializeIF::Endianness::BIG);
// if (result != returnvalue::OK) {
// sif::debug << "PlocSupervisorHandler: Failed to deserialize GPIO state" <<
// std::endl;
// }
// result = actionHelper.reportData(iter->second.sendReplyTo, commandId, data,
// sizeof(data)); if (result != returnvalue::OK) {
// sif::warning << "PlocSupervisorHandler: Read GPIO, failed to report data" <<
// std::endl;
// }
break; break;
} }
case supv::SET_TIME_REF: { case supv::SET_TIME_REF: {
@ -2179,3 +2096,17 @@ void PlocSupervisorHandler::printAckFailureInfo(uint16_t statusCode, DeviceComma
break; break;
} }
} }
ReturnValue_t PlocSupervisorHandler::getSwitches(const uint8_t** switches,
uint8_t* numberOfSwitches) {
if (powerSwitch == power::NO_SWITCH) {
return DeviceHandlerBase::NO_SWITCH;
}
*numberOfSwitches = 1;
*switches = &powerSwitch;
return returnvalue::OK;
}
uint32_t PlocSupervisorHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) {
return 7000;
}

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

@ -50,7 +50,6 @@ class PlocSupervisorHandler : public DeviceHandlerBase {
ReturnValue_t scanForReply(const uint8_t* start, size_t remainingSize, DeviceCommandId_t* foundId, ReturnValue_t scanForReply(const uint8_t* start, size_t remainingSize, DeviceCommandId_t* foundId,
size_t* foundLen) override; size_t* foundLen) override;
ReturnValue_t interpretDeviceReply(DeviceCommandId_t id, const uint8_t* packet) override; ReturnValue_t interpretDeviceReply(DeviceCommandId_t id, const uint8_t* packet) override;
void setNormalDatapoolEntriesInvalid() override;
uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override; uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override;
ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap, ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
LocalDataPoolManager& poolManager) override; LocalDataPoolManager& poolManager) override;