eive/eive-obsw
eive
/
eive-obsw
12
3
Fork 0
Code Issues 3 Pull Requests 1 Releases 117 Wiki Activity

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

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:
ExecutionReport(TmBase& readerBase) : VerificationReport(readerBase) {}
TmBase& getReader() { return readerBase; }
ReturnValue_t parse() override {
if (readerBase.getServiceId() != static_cast<uint8_t>(tm::TmtcId::EXEC_ACK) and
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() {
// Command only
insertInCommandMap(GET_HK_REPORT);
insertInCommandMap(START_MPSOC);
insertInCommandMap(SHUTDOWN_MPSOC);
this->insertInCommandMap(SEL_MPSOC_BOOT_IMAGE);
this->insertInCommandMap(SET_BOOT_TIMEOUT);
this->insertInCommandMap(SET_MAX_RESTART_TRIES);
this->insertInCommandMap(RESET_MPSOC);
this->insertInCommandMap(SET_TIME_REF);
this->insertInCommandMap(DISABLE_PERIOIC_HK_TRANSMISSION);
this->insertInCommandMap(GET_BOOT_STATUS_REPORT);
this->insertInCommandMap(ENABLE_LATCHUP_ALERT);
this->insertInCommandMap(DISABLE_LATCHUP_ALERT);
this->insertInCommandMap(SET_ALERT_LIMIT);
this->insertInCommandMap(SET_ADC_ENABLED_CHANNELS);
this->insertInCommandMap(SET_ADC_WINDOW_AND_STRIDE);
this->insertInCommandMap(SET_ADC_THRESHOLD);
this->insertInCommandMap(GET_LATCHUP_STATUS_REPORT);
this->insertInCommandMap(COPY_ADC_DATA_TO_MRAM);
this->insertInCommandMap(REQUEST_ADC_REPORT);
this->insertInCommandMap(RUN_AUTO_EM_TESTS);
this->insertInCommandMap(WIPE_MRAM);
this->insertInCommandMap(SET_GPIO);
this->insertInCommandMap(READ_GPIO);
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,
insertInCommandMap(SEL_MPSOC_BOOT_IMAGE);
insertInCommandMap(SET_BOOT_TIMEOUT);
insertInCommandMap(SET_MAX_RESTART_TRIES);
insertInCommandMap(RESET_MPSOC);
insertInCommandMap(SET_TIME_REF);
insertInCommandMap(DISABLE_PERIOIC_HK_TRANSMISSION);
insertInCommandMap(GET_BOOT_STATUS_REPORT);
insertInCommandMap(ENABLE_LATCHUP_ALERT);
insertInCommandMap(DISABLE_LATCHUP_ALERT);
insertInCommandMap(SET_ALERT_LIMIT);
insertInCommandMap(GET_LATCHUP_STATUS_REPORT);
insertInCommandMap(RUN_AUTO_EM_TESTS);
insertInCommandMap(SET_GPIO);
insertInCommandMap(READ_GPIO);
insertInCommandMap(SET_SHUTDOWN_TIMEOUT);
insertInCommandMap(FACTORY_FLASH);
insertInCommandMap(RESET_PL);
// ACK replies, use countdown for them
insertInReplyMap(ACK_REPORT, 0, nullptr, SIZE_ACK_REPORT, false,
&acknowledgementReportTimeout);
this->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);
this->insertInReplyMap(LATCHUP_REPORT, 3, &latchupStatusReport, SIZE_LATCHUP_STATUS_REPORT);
this->insertInReplyMap(LOGGING_REPORT, 3, &loggingReport, SIZE_LOGGING_REPORT);
this->insertInReplyMap(ADC_REPORT, 3, &adcReport, SIZE_ADC_REPORT);
insertInReplyMap(EXE_REPORT, 0, nullptr, SIZE_EXE_REPORT, false, &executionReportTimeout);
// TM replies
insertInReplyMap(HK_REPORT, 3, &hkset, SIZE_HK_REPORT);
insertInReplyMap(BOOT_STATUS_REPORT, 3, &bootStatusReport, SIZE_BOOT_STATUS_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,
@ -723,18 +707,10 @@ ReturnValue_t PlocSupervisorHandler::interpretDeviceReply(DeviceCommandId_t id,
result = handleLatchupStatusReport(packet);
break;
}
// case (LOGGING_REPORT): {
// result = handleLoggingReport(packet);
// break;
// }
case (ADC_REPORT): {
result = handleAdcReport(packet);
break;
}
case (FIRST_MRAM_DUMP):
case (CONSECUTIVE_MRAM_DUMP):
result = handleMramDumpPacket(id);
break;
case (EXE_REPORT): {
result = handleExecutionReport(packet);
break;
@ -749,22 +725,6 @@ ReturnValue_t PlocSupervisorHandler::interpretDeviceReply(DeviceCommandId_t id,
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,
LocalDataPoolManager& poolManager) {
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;
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) {
@ -2096,38 +2022,29 @@ ReturnValue_t PlocSupervisorHandler::eventSubscription() {
ReturnValue_t PlocSupervisorHandler::handleExecutionSuccessReport(ExecutionReport& report) {
DeviceCommandId_t commandId = getPendingCommand();
ReturnValue_t result = OK;
switch (commandId) {
case supv::READ_GPIO: {
// TODO: Fix
// supv::ExecutionReport exe(data, supv::SIZE_EXE_REPORT);
// if (exe.isNull()) {
// return returnvalue::FAILED;
// }
// ReturnValue_t result = exe.checkSize();
// if (result != returnvalue::OK) {
// return result;
// }
// uint16_t gpioState = exe.getStatusCode();
//#if OBSW_DEBUG_PLOC_SUPERVISOR == 1
// sif::info << "PlocSupervisorHandler: Read GPIO TM, State: " << gpioState << std::endl;
//#endif /* OBSW_DEBUG_PLOC_SUPERVISOR == 1 */
// DeviceCommandMap::iterator iter = deviceCommandMap.find(commandId);
// if (iter->second.sendReplyTo == NO_COMMAND_ID) {
// return returnvalue::OK;
// }
// uint8_t data[sizeof(gpioState)];
// size_t size = 0;
// 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;
// }
uint16_t gpioState = report.getStatusCode();
#if OBSW_DEBUG_PLOC_SUPERVISOR == 1
sif::info << "PlocSupervisorHandler: Read GPIO TM, State: " << gpioState << std::endl;
#endif /* OBSW_DEBUG_PLOC_SUPERVISOR == 1 */
DeviceCommandMap::iterator iter = deviceCommandMap.find(commandId);
if (iter->second.sendReplyTo == NO_COMMAND_ID) {
return returnvalue::OK;
}
uint8_t data[sizeof(gpioState)];
size_t size = 0;
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;
}
case supv::SET_TIME_REF: {
@ -2179,3 +2096,17 @@ void PlocSupervisorHandler::printAckFailureInfo(uint16_t statusCode, DeviceComma
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,
size_t* foundLen) 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;
ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
LocalDataPoolManager& poolManager) override;