Cleanroom Laptop L15
9301206485
All checks were successful
EIVE/eive-obsw/pipeline/head This commit looks good
1777 lines
67 KiB
C++
1777 lines
67 KiB
C++
#include "PlocSupervisorHandler.h"
|
|
|
|
#include <filesystem>
|
|
#include <fstream>
|
|
#include <sstream>
|
|
#include <string>
|
|
|
|
#include "OBSWConfig.h"
|
|
#include "eive/definitions.h"
|
|
#include "fsfw/datapool/PoolReadGuard.h"
|
|
#include "fsfw/globalfunctions/CRC.h"
|
|
#include "fsfw/ipc/QueueFactory.h"
|
|
#include "fsfw/timemanager/Clock.h"
|
|
|
|
PlocSupervisorHandler::PlocSupervisorHandler(object_id_t objectId, object_id_t uartComIFid,
|
|
CookieIF* comCookie, Gpio uartIsolatorSwitch,
|
|
power::Switch_t powerSwitch,
|
|
PlocSupvHelper* supvHelper)
|
|
: DeviceHandlerBase(objectId, uartComIFid, comCookie),
|
|
uartIsolatorSwitch(uartIsolatorSwitch),
|
|
hkset(this),
|
|
bootStatusReport(this),
|
|
latchupStatusReport(this),
|
|
loggingReport(this),
|
|
adcReport(this),
|
|
powerSwitch(powerSwitch),
|
|
supvHelper(supvHelper) {
|
|
if (comCookie == NULL) {
|
|
sif::error << "PlocSupervisorHandler: Invalid com cookie" << std::endl;
|
|
}
|
|
eventQueue = QueueFactory::instance()->createMessageQueue(EventMessage::EVENT_MESSAGE_SIZE * 5);
|
|
}
|
|
|
|
PlocSupervisorHandler::~PlocSupervisorHandler() {}
|
|
|
|
ReturnValue_t PlocSupervisorHandler::initialize() {
|
|
ReturnValue_t result = RETURN_OK;
|
|
result = DeviceHandlerBase::initialize();
|
|
if (result != RETURN_OK) {
|
|
return result;
|
|
}
|
|
uartComIf = dynamic_cast<UartComIF*>(communicationInterface);
|
|
if (uartComIf == nullptr) {
|
|
sif::warning << "PlocSupervisorHandler::initialize: Invalid uart com if" << std::endl;
|
|
return ObjectManagerIF::CHILD_INIT_FAILED;
|
|
}
|
|
#ifndef TE0720_1CFA
|
|
sdcMan = SdCardManager::instance();
|
|
#endif /* TE0720_1CFA */
|
|
if (supvHelper == nullptr) {
|
|
sif::warning << "PlocSupervisorHandler::initialize: Invalid supervisor helper" << std::endl;
|
|
return ObjectManagerIF::CHILD_INIT_FAILED;
|
|
}
|
|
result = supvHelper->setComIF(uartComIf);
|
|
if (result != RETURN_OK) {
|
|
return ObjectManagerIF::CHILD_INIT_FAILED;
|
|
}
|
|
supvHelper->setComCookie(comCookie);
|
|
|
|
result = eventSubscription();
|
|
if (result != RETURN_OK) {
|
|
return result;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
void PlocSupervisorHandler::performOperationHook() {
|
|
EventMessage event;
|
|
for (ReturnValue_t result = eventQueue->receiveMessage(&event); result == RETURN_OK;
|
|
result = eventQueue->receiveMessage(&event)) {
|
|
switch (event.getMessageId()) {
|
|
case EventMessage::EVENT_MESSAGE:
|
|
handleEvent(&event);
|
|
break;
|
|
default:
|
|
sif::debug << "PlocSupervisorHandler::performOperationHook: Did not subscribe to this event"
|
|
<< " message" << std::endl;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
ReturnValue_t PlocSupervisorHandler::executeAction(ActionId_t actionId,
|
|
MessageQueueId_t commandedBy,
|
|
const uint8_t* data, size_t size) {
|
|
using namespace supv;
|
|
ReturnValue_t result = RETURN_OK;
|
|
|
|
switch (actionId) {
|
|
case TERMINATE_SUPV_HELPER: {
|
|
supvHelper->stopProcess();
|
|
return EXECUTION_FINISHED;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (plocSupvHelperExecuting) {
|
|
return SupvReturnValuesIF::SUPV_HELPER_EXECUTING;
|
|
}
|
|
|
|
switch (actionId) {
|
|
case PERFORM_UPDATE: {
|
|
if (size > config::MAX_PATH_SIZE + config::MAX_FILENAME_SIZE) {
|
|
return SupvReturnValuesIF::FILENAME_TOO_LONG;
|
|
}
|
|
std::string file = "";
|
|
uint8_t memoryId = 0;
|
|
uint32_t startAddress = 0;
|
|
result = extractUpdateCommand(data, size, &file, &memoryId, &startAddress);
|
|
if (result != RETURN_OK) {
|
|
return result;
|
|
}
|
|
result = supvHelper->startUpdate(file, memoryId, startAddress);
|
|
if (result != RETURN_OK) {
|
|
return result;
|
|
}
|
|
plocSupvHelperExecuting = true;
|
|
return EXECUTION_FINISHED;
|
|
}
|
|
case LOGGING_REQUEST_EVENT_BUFFERS: {
|
|
if (size > config::MAX_PATH_SIZE) {
|
|
return SupvReturnValuesIF::FILENAME_TOO_LONG;
|
|
}
|
|
result = supvHelper->startEventbBufferRequest(
|
|
std::string(reinterpret_cast<const char*>(data), size));
|
|
if (result != RETURN_OK) {
|
|
return result;
|
|
}
|
|
plocSupvHelperExecuting = true;
|
|
return EXECUTION_FINISHED;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
return DeviceHandlerBase::executeAction(actionId, commandedBy, data, size);
|
|
}
|
|
|
|
void PlocSupervisorHandler::doStartUp() {
|
|
setMode(_MODE_TO_ON);
|
|
uartIsolatorSwitch.pullHigh();
|
|
}
|
|
|
|
void PlocSupervisorHandler::doShutDown() {
|
|
setMode(_MODE_POWER_DOWN);
|
|
uartIsolatorSwitch.pullLow();
|
|
}
|
|
|
|
ReturnValue_t PlocSupervisorHandler::buildNormalDeviceCommand(DeviceCommandId_t* id) {
|
|
return NOTHING_TO_SEND;
|
|
}
|
|
|
|
ReturnValue_t PlocSupervisorHandler::buildTransitionDeviceCommand(DeviceCommandId_t* id) {
|
|
return NOTHING_TO_SEND;
|
|
}
|
|
|
|
ReturnValue_t PlocSupervisorHandler::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
|
|
const uint8_t* commandData,
|
|
size_t commandDataLen) {
|
|
using namespace supv;
|
|
ReturnValue_t result = RETURN_FAILED;
|
|
switch (deviceCommand) {
|
|
case GET_HK_REPORT: {
|
|
sif::warning << "PlocSupervisorHandler::buildCommandFromCommand: Housekeeping report is "
|
|
<< "faulty. Needs to be fixed in vorago software" << std::endl;
|
|
prepareEmptyCmd(APID_GET_HK_REPORT);
|
|
result = RETURN_OK;
|
|
break;
|
|
}
|
|
case START_MPSOC: {
|
|
prepareEmptyCmd(APID_START_MPSOC);
|
|
result = RETURN_OK;
|
|
break;
|
|
}
|
|
case SHUTDOWN_MPSOC: {
|
|
prepareEmptyCmd(APID_SHUTWOWN_MPSOC);
|
|
result = RETURN_OK;
|
|
break;
|
|
}
|
|
case SEL_MPSOC_BOOT_IMAGE: {
|
|
prepareSelBootImageCmd(commandData);
|
|
result = RETURN_OK;
|
|
break;
|
|
}
|
|
case RESET_MPSOC: {
|
|
prepareEmptyCmd(APID_RESET_MPSOC);
|
|
result = RETURN_OK;
|
|
break;
|
|
}
|
|
case SET_TIME_REF: {
|
|
result = prepareSetTimeRefCmd();
|
|
break;
|
|
}
|
|
case SET_BOOT_TIMEOUT: {
|
|
prepareSetBootTimeoutCmd(commandData);
|
|
result = RETURN_OK;
|
|
break;
|
|
}
|
|
case SET_MAX_RESTART_TRIES: {
|
|
prepareRestartTriesCmd(commandData);
|
|
result = RETURN_OK;
|
|
break;
|
|
}
|
|
case DISABLE_PERIOIC_HK_TRANSMISSION: {
|
|
prepareDisableHk();
|
|
result = RETURN_OK;
|
|
break;
|
|
}
|
|
case GET_BOOT_STATUS_REPORT: {
|
|
prepareEmptyCmd(APID_GET_BOOT_STATUS_RPT);
|
|
result = RETURN_OK;
|
|
break;
|
|
}
|
|
case ENABLE_LATCHUP_ALERT: {
|
|
result = prepareLatchupConfigCmd(commandData, deviceCommand);
|
|
break;
|
|
}
|
|
case DISABLE_LATCHUP_ALERT: {
|
|
result = prepareLatchupConfigCmd(commandData, deviceCommand);
|
|
break;
|
|
}
|
|
case SET_ALERT_LIMIT: {
|
|
result = prepareSetAlertLimitCmd(commandData);
|
|
break;
|
|
}
|
|
case SET_ADC_ENABLED_CHANNELS: {
|
|
prepareSetAdcEnabledChannelsCmd(commandData);
|
|
result = RETURN_OK;
|
|
break;
|
|
}
|
|
case SET_ADC_WINDOW_AND_STRIDE: {
|
|
prepareSetAdcWindowAndStrideCmd(commandData);
|
|
result = RETURN_OK;
|
|
break;
|
|
}
|
|
case SET_ADC_THRESHOLD: {
|
|
prepareSetAdcThresholdCmd(commandData);
|
|
result = RETURN_OK;
|
|
break;
|
|
}
|
|
case GET_LATCHUP_STATUS_REPORT: {
|
|
prepareEmptyCmd(APID_GET_LATCHUP_STATUS_REPORT);
|
|
result = RETURN_OK;
|
|
break;
|
|
}
|
|
case COPY_ADC_DATA_TO_MRAM: {
|
|
prepareEmptyCmd(APID_COPY_ADC_DATA_TO_MRAM);
|
|
result = RETURN_OK;
|
|
break;
|
|
}
|
|
case REQUEST_ADC_REPORT: {
|
|
prepareEmptyCmd(APID_REQUEST_ADC_REPORT);
|
|
result = RETURN_OK;
|
|
break;
|
|
}
|
|
case RUN_AUTO_EM_TESTS: {
|
|
result = prepareRunAutoEmTest(commandData);
|
|
break;
|
|
}
|
|
case WIPE_MRAM: {
|
|
result = prepareWipeMramCmd(commandData);
|
|
break;
|
|
}
|
|
case FIRST_MRAM_DUMP:
|
|
case CONSECUTIVE_MRAM_DUMP:
|
|
result = prepareDumpMramCmd(commandData);
|
|
break;
|
|
case SET_GPIO: {
|
|
prepareSetGpioCmd(commandData);
|
|
result = RETURN_OK;
|
|
break;
|
|
}
|
|
case READ_GPIO: {
|
|
prepareReadGpioCmd(commandData);
|
|
result = RETURN_OK;
|
|
break;
|
|
}
|
|
case RESTART_SUPERVISOR: {
|
|
prepareEmptyCmd(APID_RESTART_SUPERVISOR);
|
|
result = RETURN_OK;
|
|
break;
|
|
}
|
|
case FACTORY_RESET_CLEAR_ALL: {
|
|
FactoryReset packet(FactoryReset::Op::CLEAR_ALL);
|
|
packetToOutBuffer(packet.getWholeData(), packet.getFullSize());
|
|
result = RETURN_OK;
|
|
break;
|
|
}
|
|
case FACTORY_RESET_CLEAR_MIRROR: {
|
|
FactoryReset packet(FactoryReset::Op::MIRROR_ENTRIES);
|
|
packetToOutBuffer(packet.getWholeData(), packet.getFullSize());
|
|
result = RETURN_OK;
|
|
break;
|
|
}
|
|
case FACTORY_RESET_CLEAR_CIRCULAR: {
|
|
FactoryReset packet(FactoryReset::Op::CIRCULAR_ENTRIES);
|
|
packetToOutBuffer(packet.getWholeData(), packet.getFullSize());
|
|
result = RETURN_OK;
|
|
break;
|
|
}
|
|
case START_MPSOC_QUIET: {
|
|
prepareEmptyCmd(APID_START_MPSOC_QUIET);
|
|
result = RETURN_OK;
|
|
break;
|
|
}
|
|
case SET_SHUTDOWN_TIMEOUT: {
|
|
prepareSetShutdownTimeoutCmd(commandData);
|
|
result = RETURN_OK;
|
|
break;
|
|
}
|
|
case FACTORY_FLASH: {
|
|
prepareEmptyCmd(APID_FACTORY_FLASH);
|
|
result = RETURN_OK;
|
|
break;
|
|
}
|
|
case ENABLE_AUTO_TM: {
|
|
EnableAutoTm packet;
|
|
packetToOutBuffer(packet.getWholeData(), packet.getFullSize());
|
|
result = RETURN_OK;
|
|
break;
|
|
}
|
|
case DISABLE_AUTO_TM: {
|
|
DisableAutoTm packet;
|
|
packetToOutBuffer(packet.getWholeData(), packet.getFullSize());
|
|
result = RETURN_OK;
|
|
break;
|
|
}
|
|
case LOGGING_REQUEST_COUNTERS: {
|
|
RequestLoggingData packet(RequestLoggingData::Sa::REQUEST_COUNTERS);
|
|
packetToOutBuffer(packet.getWholeData(), packet.getFullSize());
|
|
result = RETURN_OK;
|
|
break;
|
|
}
|
|
case LOGGING_CLEAR_COUNTERS: {
|
|
RequestLoggingData packet(RequestLoggingData::Sa::CLEAR_COUNTERS);
|
|
packetToOutBuffer(packet.getWholeData(), packet.getFullSize());
|
|
result = RETURN_OK;
|
|
break;
|
|
}
|
|
case LOGGING_SET_TOPIC: {
|
|
uint8_t tpc = *(commandData);
|
|
RequestLoggingData packet(RequestLoggingData::Sa::SET_LOGGING_TOPIC, tpc);
|
|
packetToOutBuffer(packet.getWholeData(), packet.getFullSize());
|
|
result = RETURN_OK;
|
|
break;
|
|
}
|
|
default:
|
|
sif::debug << "PlocSupervisorHandler::buildCommandFromCommand: Command not implemented"
|
|
<< std::endl;
|
|
result = DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
|
|
break;
|
|
}
|
|
|
|
if (result == RETURN_OK) {
|
|
/**
|
|
* Flushing the receive buffer to make sure there are no data left from a faulty reply.
|
|
*/
|
|
uartComIf->flushUartRxBuffer(comCookie);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
void PlocSupervisorHandler::fillCommandAndReplyMap() {
|
|
using namespace supv;
|
|
this->insertInCommandMap(GET_HK_REPORT);
|
|
this->insertInCommandMap(START_MPSOC);
|
|
this->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(PRINT_CPU_STATS);
|
|
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->insertInCommandAndReplyMap(FIRST_MRAM_DUMP, 3);
|
|
this->insertInCommandAndReplyMap(CONSECUTIVE_MRAM_DUMP, 3);
|
|
this->insertInReplyMap(ACK_REPORT, 3, nullptr, SIZE_ACK_REPORT);
|
|
this->insertInReplyMap(EXE_REPORT, 50, nullptr, SIZE_EXE_REPORT);
|
|
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);
|
|
}
|
|
|
|
ReturnValue_t PlocSupervisorHandler::enableReplyInReplyMap(DeviceCommandMap::iterator command,
|
|
uint8_t expectedReplies,
|
|
bool useAlternateId,
|
|
DeviceCommandId_t alternateReplyID) {
|
|
using namespace supv;
|
|
ReturnValue_t result = RETURN_OK;
|
|
|
|
uint8_t enabledReplies = 0;
|
|
|
|
switch (command->first) {
|
|
case GET_HK_REPORT: {
|
|
enabledReplies = 3;
|
|
result =
|
|
DeviceHandlerBase::enableReplyInReplyMap(command, enabledReplies, true, HK_REPORT);
|
|
if (result != RETURN_OK) {
|
|
sif::debug << "PlocSupervisorHandler::enableReplyInReplyMap: Reply with id "
|
|
<< HK_REPORT << " not in replyMap" << std::endl;
|
|
}
|
|
break;
|
|
}
|
|
case GET_BOOT_STATUS_REPORT: {
|
|
enabledReplies = 3;
|
|
result = DeviceHandlerBase::enableReplyInReplyMap(command, enabledReplies, true,
|
|
BOOT_STATUS_REPORT);
|
|
if (result != RETURN_OK) {
|
|
sif::debug << "PlocSupervisorHandler::enableReplyInReplyMap: Reply with id "
|
|
<< BOOT_STATUS_REPORT << " not in replyMap" << std::endl;
|
|
}
|
|
break;
|
|
}
|
|
case GET_LATCHUP_STATUS_REPORT: {
|
|
enabledReplies = 3;
|
|
result = DeviceHandlerBase::enableReplyInReplyMap(command, enabledReplies, true,
|
|
LATCHUP_REPORT);
|
|
if (result != RETURN_OK) {
|
|
sif::debug << "PlocSupervisorHandler::enableReplyInReplyMap: Reply with id "
|
|
<< LATCHUP_REPORT << " not in replyMap" << std::endl;
|
|
}
|
|
break;
|
|
}
|
|
case LOGGING_REQUEST_COUNTERS: {
|
|
enabledReplies = 3;
|
|
result = DeviceHandlerBase::enableReplyInReplyMap(command, enabledReplies, true,
|
|
LOGGING_REPORT);
|
|
if (result != RETURN_OK) {
|
|
sif::debug << "PlocSupervisorHandler::enableReplyInReplyMap: Reply with id "
|
|
<< LOGGING_REPORT << " not in replyMap" << std::endl;
|
|
}
|
|
break;
|
|
}
|
|
case REQUEST_ADC_REPORT: {
|
|
enabledReplies = 3;
|
|
result = DeviceHandlerBase::enableReplyInReplyMap(command, enabledReplies, true,
|
|
ADC_REPORT);
|
|
if (result != RETURN_OK) {
|
|
sif::debug << "PlocSupervisorHandler::enableReplyInReplyMap: Reply with id "
|
|
<< ADC_REPORT << " not in replyMap" << std::endl;
|
|
}
|
|
break;
|
|
}
|
|
case FIRST_MRAM_DUMP: {
|
|
enabledReplies = 2; // expected replies will be increased in handleMramDumpPacket
|
|
result = DeviceHandlerBase::enableReplyInReplyMap(command, enabledReplies, true,
|
|
FIRST_MRAM_DUMP);
|
|
if (result != RETURN_OK) {
|
|
sif::debug << "PlocSupervisorHandler::enableReplyInReplyMap: Reply with id "
|
|
<< FIRST_MRAM_DUMP << " not in replyMap" << std::endl;
|
|
}
|
|
break;
|
|
}
|
|
case CONSECUTIVE_MRAM_DUMP: {
|
|
enabledReplies = 2; // expected replies will be increased in handleMramDumpPacket
|
|
result = DeviceHandlerBase::enableReplyInReplyMap(command, enabledReplies, true,
|
|
CONSECUTIVE_MRAM_DUMP);
|
|
if (result != RETURN_OK) {
|
|
sif::debug << "PlocSupervisorHandler::enableReplyInReplyMap: Reply with id "
|
|
<< CONSECUTIVE_MRAM_DUMP << " not in replyMap" << std::endl;
|
|
}
|
|
break;
|
|
}
|
|
case START_MPSOC:
|
|
case SHUTDOWN_MPSOC:
|
|
case SEL_MPSOC_BOOT_IMAGE:
|
|
case SET_BOOT_TIMEOUT:
|
|
case SET_MAX_RESTART_TRIES:
|
|
case RESET_MPSOC:
|
|
case SET_TIME_REF:
|
|
case ENABLE_LATCHUP_ALERT:
|
|
case DISABLE_LATCHUP_ALERT:
|
|
case SET_ALERT_LIMIT:
|
|
case SET_ADC_ENABLED_CHANNELS:
|
|
case SET_ADC_WINDOW_AND_STRIDE:
|
|
case SET_ADC_THRESHOLD:
|
|
case COPY_ADC_DATA_TO_MRAM:
|
|
case RUN_AUTO_EM_TESTS:
|
|
case WIPE_MRAM:
|
|
case PRINT_CPU_STATS:
|
|
case SET_GPIO:
|
|
case READ_GPIO:
|
|
case RESTART_SUPERVISOR:
|
|
case FACTORY_RESET_CLEAR_ALL:
|
|
case FACTORY_RESET_CLEAR_MIRROR:
|
|
case FACTORY_RESET_CLEAR_CIRCULAR:
|
|
case DISABLE_PERIOIC_HK_TRANSMISSION:
|
|
case START_MPSOC_QUIET:
|
|
case SET_SHUTDOWN_TIMEOUT:
|
|
case FACTORY_FLASH:
|
|
case ENABLE_AUTO_TM:
|
|
case DISABLE_AUTO_TM:
|
|
case LOGGING_CLEAR_COUNTERS:
|
|
case LOGGING_SET_TOPIC:
|
|
enabledReplies = 2;
|
|
break;
|
|
default:
|
|
sif::debug << "PlocSupervisorHandler::enableReplyInReplyMap: Unknown command id" << std::endl;
|
|
break;
|
|
}
|
|
|
|
/**
|
|
* Every command causes at least one acknowledgment and one execution report. Therefore both
|
|
* replies will be enabled here.
|
|
*/
|
|
result =
|
|
DeviceHandlerBase::enableReplyInReplyMap(command, enabledReplies, true, ACK_REPORT);
|
|
if (result != RETURN_OK) {
|
|
sif::debug << "PlocSupervisorHandler::enableReplyInReplyMap: Reply with id " << ACK_REPORT
|
|
<< " not in replyMap" << std::endl;
|
|
}
|
|
|
|
result =
|
|
DeviceHandlerBase::enableReplyInReplyMap(command, enabledReplies, true, EXE_REPORT);
|
|
if (result != RETURN_OK) {
|
|
sif::debug << "PlocSupervisorHandler::enableReplyInReplyMap: Reply with id " << EXE_REPORT
|
|
<< " not in replyMap" << std::endl;
|
|
}
|
|
|
|
return RETURN_OK;
|
|
}
|
|
|
|
ReturnValue_t PlocSupervisorHandler::scanForReply(const uint8_t* start, size_t remainingSize,
|
|
DeviceCommandId_t* foundId, size_t* foundLen) {
|
|
using namespace supv;
|
|
if (nextReplyId == FIRST_MRAM_DUMP) {
|
|
*foundId = FIRST_MRAM_DUMP;
|
|
return parseMramPackets(start, remainingSize, foundLen);
|
|
} else if (nextReplyId == CONSECUTIVE_MRAM_DUMP) {
|
|
*foundId = CONSECUTIVE_MRAM_DUMP;
|
|
return parseMramPackets(start, remainingSize, foundLen);
|
|
}
|
|
|
|
ReturnValue_t result = RETURN_OK;
|
|
|
|
uint16_t apid = (*(start) << 8 | *(start + 1)) & APID_MASK;
|
|
|
|
switch (apid) {
|
|
case (APID_ACK_SUCCESS):
|
|
*foundLen = SIZE_ACK_REPORT;
|
|
*foundId = ACK_REPORT;
|
|
break;
|
|
case (APID_ACK_FAILURE):
|
|
*foundLen = SIZE_ACK_REPORT;
|
|
*foundId = ACK_REPORT;
|
|
break;
|
|
case (APID_HK_REPORT):
|
|
*foundLen = SIZE_HK_REPORT;
|
|
*foundId = HK_REPORT;
|
|
break;
|
|
case (APID_BOOT_STATUS_REPORT):
|
|
*foundLen = SIZE_BOOT_STATUS_REPORT;
|
|
*foundId = BOOT_STATUS_REPORT;
|
|
break;
|
|
case (APID_LATCHUP_STATUS_REPORT):
|
|
*foundLen = SIZE_LATCHUP_STATUS_REPORT;
|
|
*foundId = LATCHUP_REPORT;
|
|
break;
|
|
case (APID_DATA_LOGGER_DATA):
|
|
*foundLen = SIZE_LOGGING_REPORT;
|
|
*foundId = LOGGING_REPORT;
|
|
break;
|
|
case (APID_ADC_REPORT):
|
|
*foundLen = SIZE_ADC_REPORT;
|
|
*foundId = ADC_REPORT;
|
|
break;
|
|
case (APID_EXE_SUCCESS):
|
|
*foundLen = SIZE_EXE_REPORT;
|
|
*foundId = EXE_REPORT;
|
|
break;
|
|
case (APID_EXE_FAILURE):
|
|
*foundLen = SIZE_EXE_REPORT;
|
|
*foundId = EXE_REPORT;
|
|
break;
|
|
default: {
|
|
sif::debug << "PlocSupervisorHandler::scanForReply: Reply has invalid apid" << std::endl;
|
|
*foundLen = remainingSize;
|
|
return SupvReturnValuesIF::INVALID_APID;
|
|
}
|
|
}
|
|
|
|
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 RETURN_OK;
|
|
}
|
|
|
|
ReturnValue_t PlocSupervisorHandler::interpretDeviceReply(DeviceCommandId_t id,
|
|
const uint8_t* packet) {
|
|
using namespace supv;
|
|
ReturnValue_t result = RETURN_OK;
|
|
|
|
switch (id) {
|
|
case ACK_REPORT: {
|
|
result = handleAckReport(packet);
|
|
break;
|
|
}
|
|
case (HK_REPORT): {
|
|
result = handleHkReport(packet);
|
|
break;
|
|
}
|
|
case (BOOT_STATUS_REPORT): {
|
|
result = handleBootStatusReport(packet);
|
|
break;
|
|
}
|
|
case (LATCHUP_REPORT): {
|
|
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;
|
|
}
|
|
default: {
|
|
sif::debug << "PlocSupervisorHandler::interpretDeviceReply: Unknown device reply id"
|
|
<< std::endl;
|
|
return DeviceHandlerIF::UNKNOWN_DEVICE_REPLY;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
void PlocSupervisorHandler::setNormalDatapoolEntriesInvalid() {}
|
|
|
|
uint32_t PlocSupervisorHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 500; }
|
|
|
|
ReturnValue_t PlocSupervisorHandler::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
|
|
LocalDataPoolManager& poolManager) {
|
|
localDataPoolMap.emplace(supv::NUM_TMS, new PoolEntry<uint32_t>({0}));
|
|
localDataPoolMap.emplace(supv::TEMP_PS, new PoolEntry<uint32_t>({0}));
|
|
localDataPoolMap.emplace(supv::TEMP_PL, new PoolEntry<uint32_t>({0}));
|
|
localDataPoolMap.emplace(supv::HK_SOC_STATE, new PoolEntry<uint32_t>({0}));
|
|
localDataPoolMap.emplace(supv::NVM0_1_STATE, new PoolEntry<uint8_t>({0}));
|
|
localDataPoolMap.emplace(supv::NVM3_STATE, new PoolEntry<uint8_t>({0}));
|
|
localDataPoolMap.emplace(supv::MISSION_IO_STATE, new PoolEntry<uint8_t>({0}));
|
|
localDataPoolMap.emplace(supv::FMC_STATE, new PoolEntry<uint32_t>({0}));
|
|
localDataPoolMap.emplace(supv::NUM_TCS, new PoolEntry<uint32_t>({0}));
|
|
localDataPoolMap.emplace(supv::UPTIME, new PoolEntry<uint64_t>({0}));
|
|
localDataPoolMap.emplace(supv::CPULOAD, new PoolEntry<uint32_t>({0}));
|
|
localDataPoolMap.emplace(supv::AVAILABLEHEAP, new PoolEntry<uint32_t>({0}));
|
|
|
|
localDataPoolMap.emplace(supv::BR_SOC_STATE, new PoolEntry<uint8_t>({0}));
|
|
localDataPoolMap.emplace(supv::POWER_CYCLES, new PoolEntry<uint8_t>({0}));
|
|
localDataPoolMap.emplace(supv::BOOT_AFTER_MS, new PoolEntry<uint32_t>({0}));
|
|
localDataPoolMap.emplace(supv::BOOT_TIMEOUT_MS, new PoolEntry<uint32_t>({0}));
|
|
localDataPoolMap.emplace(supv::ACTIVE_NVM, new PoolEntry<uint8_t>({0}));
|
|
localDataPoolMap.emplace(supv::BP0_STATE, new PoolEntry<uint8_t>({0}));
|
|
localDataPoolMap.emplace(supv::BP1_STATE, new PoolEntry<uint8_t>({0}));
|
|
localDataPoolMap.emplace(supv::BP2_STATE, new PoolEntry<uint8_t>({0}));
|
|
|
|
localDataPoolMap.emplace(supv::LATCHUP_ID, new PoolEntry<uint8_t>({0}));
|
|
localDataPoolMap.emplace(supv::CNT0, new PoolEntry<uint16_t>({0}));
|
|
localDataPoolMap.emplace(supv::CNT1, new PoolEntry<uint16_t>({0}));
|
|
localDataPoolMap.emplace(supv::CNT2, new PoolEntry<uint16_t>({0}));
|
|
localDataPoolMap.emplace(supv::CNT3, new PoolEntry<uint16_t>({0}));
|
|
localDataPoolMap.emplace(supv::CNT4, new PoolEntry<uint16_t>({0}));
|
|
localDataPoolMap.emplace(supv::CNT5, new PoolEntry<uint16_t>({0}));
|
|
localDataPoolMap.emplace(supv::CNT6, new PoolEntry<uint16_t>({0}));
|
|
localDataPoolMap.emplace(supv::LATCHUP_RPT_TIME_MSEC, new PoolEntry<uint16_t>({0}));
|
|
localDataPoolMap.emplace(supv::LATCHUP_RPT_TIME_SEC, new PoolEntry<uint8_t>({0}));
|
|
localDataPoolMap.emplace(supv::LATCHUP_RPT_TIME_MIN, new PoolEntry<uint8_t>({0}));
|
|
localDataPoolMap.emplace(supv::LATCHUP_RPT_TIME_HOUR, new PoolEntry<uint8_t>({0}));
|
|
localDataPoolMap.emplace(supv::LATCHUP_RPT_TIME_DAY, new PoolEntry<uint8_t>({0}));
|
|
localDataPoolMap.emplace(supv::LATCHUP_RPT_TIME_MON, new PoolEntry<uint8_t>({0}));
|
|
localDataPoolMap.emplace(supv::LATCHUP_RPT_TIME_YEAR, new PoolEntry<uint8_t>({0}));
|
|
localDataPoolMap.emplace(supv::LATCHUP_RPT_IS_SET, new PoolEntry<uint8_t>({0}));
|
|
|
|
localDataPoolMap.emplace(supv::LATCHUP_HAPPENED_CNT_0, new PoolEntry<uint32_t>({0}));
|
|
localDataPoolMap.emplace(supv::LATCHUP_HAPPENED_CNT_1, new PoolEntry<uint32_t>({0}));
|
|
localDataPoolMap.emplace(supv::LATCHUP_HAPPENED_CNT_2, new PoolEntry<uint32_t>({0}));
|
|
localDataPoolMap.emplace(supv::LATCHUP_HAPPENED_CNT_3, new PoolEntry<uint32_t>({0}));
|
|
localDataPoolMap.emplace(supv::LATCHUP_HAPPENED_CNT_4, new PoolEntry<uint32_t>({0}));
|
|
localDataPoolMap.emplace(supv::LATCHUP_HAPPENED_CNT_5, new PoolEntry<uint32_t>({0}));
|
|
localDataPoolMap.emplace(supv::LATCHUP_HAPPENED_CNT_6, new PoolEntry<uint32_t>({0}));
|
|
localDataPoolMap.emplace(supv::ADC_DEVIATION_TRIGGERS_CNT, new PoolEntry<uint32_t>({0}));
|
|
localDataPoolMap.emplace(supv::TC_RECEIVED_CNT, new PoolEntry<uint32_t>({0}));
|
|
localDataPoolMap.emplace(supv::TM_AVAILABLE_CNT, new PoolEntry<uint32_t>({0}));
|
|
localDataPoolMap.emplace(supv::SUPERVISOR_BOOTS, new PoolEntry<uint32_t>({0}));
|
|
localDataPoolMap.emplace(supv::MPSOC_BOOTS, new PoolEntry<uint32_t>({0}));
|
|
localDataPoolMap.emplace(supv::MPSOC_BOOT_FAILED_ATTEMPTS, new PoolEntry<uint32_t>({0}));
|
|
localDataPoolMap.emplace(supv::MPSOC_POWER_UP, new PoolEntry<uint32_t>({0}));
|
|
localDataPoolMap.emplace(supv::MPSOC_UPDATES, new PoolEntry<uint32_t>({0}));
|
|
localDataPoolMap.emplace(supv::LAST_RECVD_TC, new PoolEntry<uint32_t>({0}));
|
|
|
|
localDataPoolMap.emplace(supv::ADC_RAW_0, new PoolEntry<uint16_t>({0}));
|
|
localDataPoolMap.emplace(supv::ADC_RAW_1, new PoolEntry<uint16_t>({0}));
|
|
localDataPoolMap.emplace(supv::ADC_RAW_2, new PoolEntry<uint16_t>({0}));
|
|
localDataPoolMap.emplace(supv::ADC_RAW_3, new PoolEntry<uint16_t>({0}));
|
|
localDataPoolMap.emplace(supv::ADC_RAW_4, new PoolEntry<uint16_t>({0}));
|
|
localDataPoolMap.emplace(supv::ADC_RAW_5, new PoolEntry<uint16_t>({0}));
|
|
localDataPoolMap.emplace(supv::ADC_RAW_6, new PoolEntry<uint16_t>({0}));
|
|
localDataPoolMap.emplace(supv::ADC_RAW_7, new PoolEntry<uint16_t>({0}));
|
|
localDataPoolMap.emplace(supv::ADC_RAW_8, new PoolEntry<uint16_t>({0}));
|
|
localDataPoolMap.emplace(supv::ADC_RAW_9, new PoolEntry<uint16_t>({0}));
|
|
localDataPoolMap.emplace(supv::ADC_RAW_10, new PoolEntry<uint16_t>({0}));
|
|
localDataPoolMap.emplace(supv::ADC_RAW_11, new PoolEntry<uint16_t>({0}));
|
|
localDataPoolMap.emplace(supv::ADC_RAW_12, new PoolEntry<uint16_t>({0}));
|
|
localDataPoolMap.emplace(supv::ADC_RAW_13, new PoolEntry<uint16_t>({0}));
|
|
localDataPoolMap.emplace(supv::ADC_RAW_14, new PoolEntry<uint16_t>({0}));
|
|
localDataPoolMap.emplace(supv::ADC_RAW_15, new PoolEntry<uint16_t>({0}));
|
|
|
|
localDataPoolMap.emplace(supv::ADC_ENG_0, new PoolEntry<uint16_t>({0}));
|
|
localDataPoolMap.emplace(supv::ADC_ENG_1, new PoolEntry<uint16_t>({0}));
|
|
localDataPoolMap.emplace(supv::ADC_ENG_2, new PoolEntry<uint16_t>({0}));
|
|
localDataPoolMap.emplace(supv::ADC_ENG_3, new PoolEntry<uint16_t>({0}));
|
|
localDataPoolMap.emplace(supv::ADC_ENG_4, new PoolEntry<uint16_t>({0}));
|
|
localDataPoolMap.emplace(supv::ADC_ENG_5, new PoolEntry<uint16_t>({0}));
|
|
localDataPoolMap.emplace(supv::ADC_ENG_6, new PoolEntry<uint16_t>({0}));
|
|
localDataPoolMap.emplace(supv::ADC_ENG_7, new PoolEntry<uint16_t>({0}));
|
|
localDataPoolMap.emplace(supv::ADC_ENG_8, new PoolEntry<uint16_t>({0}));
|
|
localDataPoolMap.emplace(supv::ADC_ENG_9, new PoolEntry<uint16_t>({0}));
|
|
localDataPoolMap.emplace(supv::ADC_ENG_10, new PoolEntry<uint16_t>({0}));
|
|
localDataPoolMap.emplace(supv::ADC_ENG_11, new PoolEntry<uint16_t>({0}));
|
|
localDataPoolMap.emplace(supv::ADC_ENG_12, new PoolEntry<uint16_t>({0}));
|
|
localDataPoolMap.emplace(supv::ADC_ENG_13, new PoolEntry<uint16_t>({0}));
|
|
localDataPoolMap.emplace(supv::ADC_ENG_14, new PoolEntry<uint16_t>({0}));
|
|
localDataPoolMap.emplace(supv::ADC_ENG_15, new PoolEntry<uint16_t>({0}));
|
|
|
|
return HasReturnvaluesIF::RETURN_OK;
|
|
}
|
|
|
|
void PlocSupervisorHandler::handleEvent(EventMessage* eventMessage) {
|
|
object_id_t objectId = eventMessage->getReporter();
|
|
switch (objectId) {
|
|
case objects::PLOC_SUPERVISOR_HELPER: {
|
|
plocSupvHelperExecuting = false;
|
|
break;
|
|
}
|
|
default:
|
|
sif::debug << "PlocMPSoCHandler::handleEvent: Did not subscribe to this event" << std::endl;
|
|
break;
|
|
}
|
|
}
|
|
|
|
ReturnValue_t PlocSupervisorHandler::verifyPacket(const uint8_t* start, size_t foundLen) {
|
|
uint16_t receivedCrc = *(start + foundLen - 2) << 8 | *(start + foundLen - 1);
|
|
uint16_t recalculatedCrc = CRC::crc16ccitt(start, foundLen - 2);
|
|
if (receivedCrc != recalculatedCrc) {
|
|
return SupvReturnValuesIF::CRC_FAILURE;
|
|
}
|
|
return RETURN_OK;
|
|
}
|
|
|
|
ReturnValue_t PlocSupervisorHandler::handleAckReport(const uint8_t* data) {
|
|
ReturnValue_t result = RETURN_OK;
|
|
|
|
result = verifyPacket(data, supv::SIZE_ACK_REPORT);
|
|
if (result == SupvReturnValuesIF::CRC_FAILURE) {
|
|
sif::error << "PlocSupervisorHandler::handleAckReport: CRC failure" << std::endl;
|
|
nextReplyId = supv::NONE;
|
|
replyRawReplyIfnotWiretapped(data, supv::SIZE_ACK_REPORT);
|
|
triggerEvent(SUPV_CRC_FAILURE_EVENT);
|
|
sendFailureReport(supv::ACK_REPORT, SupvReturnValuesIF::CRC_FAILURE);
|
|
disableAllReplies();
|
|
return RETURN_OK;
|
|
}
|
|
|
|
uint16_t apid = (*(data) << 8 | *(data + 1)) & APID_MASK;
|
|
|
|
switch (apid) {
|
|
case supv::APID_ACK_FAILURE: {
|
|
// TODO: Interpretation of status field in acknowledgment report
|
|
sif::debug << "PlocSupervisorHandler::handleAckReport: Received Ack failure report"
|
|
<< std::endl;
|
|
DeviceCommandId_t commandId = getPendingCommand();
|
|
if (commandId != DeviceHandlerIF::NO_COMMAND_ID) {
|
|
triggerEvent(SUPV_ACK_FAILURE, commandId);
|
|
}
|
|
sendFailureReport(supv::ACK_REPORT, SupvReturnValuesIF::RECEIVED_ACK_FAILURE);
|
|
disableAllReplies();
|
|
nextReplyId = supv::NONE;
|
|
result = IGNORE_REPLY_DATA;
|
|
break;
|
|
}
|
|
case supv::APID_ACK_SUCCESS: {
|
|
setNextReplyId();
|
|
break;
|
|
}
|
|
default: {
|
|
sif::debug << "PlocSupervisorHandler::handleAckReport: Invalid APID in Ack report"
|
|
<< std::endl;
|
|
result = RETURN_FAILED;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
ReturnValue_t PlocSupervisorHandler::handleExecutionReport(const uint8_t* data) {
|
|
ReturnValue_t result = RETURN_OK;
|
|
|
|
result = verifyPacket(data, supv::SIZE_EXE_REPORT);
|
|
if (result == SupvReturnValuesIF::CRC_FAILURE) {
|
|
sif::error << "PlocSupervisorHandler::handleExecutionReport: CRC failure" << std::endl;
|
|
nextReplyId = supv::NONE;
|
|
return result;
|
|
}
|
|
|
|
uint16_t apid = (*(data) << 8 | *(data + 1)) & APID_MASK;
|
|
|
|
switch (apid) {
|
|
case (supv::APID_EXE_SUCCESS): {
|
|
break;
|
|
}
|
|
case (supv::APID_EXE_FAILURE): {
|
|
// TODO: Interpretation of status field in execution report
|
|
sif::error
|
|
<< "PlocSupervisorHandler::handleExecutionReport: Received execution failure report"
|
|
<< std::endl;
|
|
DeviceCommandId_t commandId = getPendingCommand();
|
|
if (commandId != DeviceHandlerIF::NO_COMMAND_ID) {
|
|
triggerEvent(SUPV_EXE_FAILURE, commandId);
|
|
} else {
|
|
sif::debug << "PlocSupervisorHandler::handleExecutionReport: Unknown command id"
|
|
<< std::endl;
|
|
}
|
|
uint16_t status = *(data + EXE_STATUS_OFFSET) << 8 | *(data + EXE_STATUS_OFFSET + 1);
|
|
sif::info << "Execution status: 0x" << std::hex << status << std::endl;
|
|
sendFailureReport(supv::EXE_REPORT, SupvReturnValuesIF::RECEIVED_EXE_FAILURE);
|
|
disableExeReportReply();
|
|
result = IGNORE_REPLY_DATA;
|
|
break;
|
|
}
|
|
default: {
|
|
sif::error << "PlocSupervisorHandler::handleExecutionReport: Unknown APID" << std::endl;
|
|
result = RETURN_FAILED;
|
|
break;
|
|
}
|
|
}
|
|
|
|
nextReplyId = supv::NONE;
|
|
|
|
return result;
|
|
}
|
|
|
|
ReturnValue_t PlocSupervisorHandler::handleHkReport(const uint8_t* data) {
|
|
ReturnValue_t result = RETURN_OK;
|
|
|
|
result = verifyPacket(data, supv::SIZE_HK_REPORT);
|
|
|
|
if (result == SupvReturnValuesIF::CRC_FAILURE) {
|
|
sif::error << "PlocSupervisorHandler::handleHkReport: Hk report has invalid crc" << std::endl;
|
|
}
|
|
|
|
uint16_t offset = supv::DATA_FIELD_OFFSET;
|
|
hkset.tempPs = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8 |
|
|
*(data + offset + 3);
|
|
offset += 4;
|
|
hkset.tempPl = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8 |
|
|
*(data + offset + 3);
|
|
offset += 4;
|
|
hkset.tempSup = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8 |
|
|
*(data + offset + 3);
|
|
offset += 4;
|
|
size_t size = sizeof(hkset.uptime.value);
|
|
result = SerializeAdapter::deSerialize(&hkset.uptime, data + offset, &size,
|
|
SerializeIF::Endianness::BIG);
|
|
offset += 8;
|
|
hkset.cpuLoad = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8 |
|
|
*(data + offset + 3);
|
|
offset += 4;
|
|
hkset.availableHeap = *(data + offset) << 24 | *(data + offset + 1) << 16 |
|
|
*(data + offset + 2) << 8 | *(data + offset + 3);
|
|
offset += 4;
|
|
hkset.numTcs = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8 |
|
|
*(data + offset + 3);
|
|
offset += 4;
|
|
hkset.numTms = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8 |
|
|
*(data + offset + 3);
|
|
offset += 4;
|
|
hkset.socState = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8 |
|
|
*(data + offset + 3);
|
|
offset += 4;
|
|
hkset.nvm0_1_state = *(data + offset);
|
|
offset += 1;
|
|
hkset.nvm3_state = *(data + offset);
|
|
offset += 1;
|
|
hkset.missionIoState = *(data + offset);
|
|
offset += 1;
|
|
hkset.fmcState = *(data + offset);
|
|
offset += 1;
|
|
|
|
nextReplyId = supv::EXE_REPORT;
|
|
|
|
#if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_PLOC_SUPERVISOR == 1
|
|
sif::info << "PlocSupervisorHandler::handleHkReport: temp_ps: " << hkset.tempPs << std::endl;
|
|
sif::info << "PlocSupervisorHandler::handleHkReport: temp_pl: " << hkset.tempPl << std::endl;
|
|
sif::info << "PlocSupervisorHandler::handleHkReport: temp_sup: " << hkset.tempSup << std::endl;
|
|
sif::info << "PlocSupervisorHandler::handleHkReport: uptime: " << hkset.uptime << std::endl;
|
|
sif::info << "PlocSupervisorHandler::handleHkReport: cpu_load: " << hkset.cpuLoad << std::endl;
|
|
sif::info << "PlocSupervisorHandler::handleHkReport: available_heap: " << hkset.availableHeap
|
|
<< std::endl;
|
|
sif::info << "PlocSupervisorHandler::handleHkReport: num_tcs: " << hkset.numTcs << std::endl;
|
|
sif::info << "PlocSupervisorHandler::handleHkReport: num_tms: " << hkset.numTms << std::endl;
|
|
sif::info << "PlocSupervisorHandler::handleHkReport: soc_state: " << hkset.socState << std::endl;
|
|
sif::info << "PlocSupervisorHandler::handleHkReport: nvm0_1_state: "
|
|
<< static_cast<unsigned int>(hkset.nvm0_1_state.value) << std::endl;
|
|
sif::info << "PlocSupervisorHandler::handleHkReport: nvm3_state: "
|
|
<< static_cast<unsigned int>(hkset.nvm3_state.value) << std::endl;
|
|
sif::info << "PlocSupervisorHandler::handleHkReport: mission_io_state: "
|
|
<< static_cast<unsigned int>(hkset.missionIoState.value) << std::endl;
|
|
sif::info << "PlocSupervisorHandler::handleHkReport: fmc_state: "
|
|
<< static_cast<unsigned int>(hkset.fmcState.value) << std::endl;
|
|
|
|
#endif
|
|
|
|
return result;
|
|
}
|
|
|
|
ReturnValue_t PlocSupervisorHandler::handleBootStatusReport(const uint8_t* data) {
|
|
ReturnValue_t result = RETURN_OK;
|
|
|
|
result = verifyPacket(data, supv::SIZE_BOOT_STATUS_REPORT);
|
|
|
|
if (result == SupvReturnValuesIF::CRC_FAILURE) {
|
|
sif::error << "PlocSupervisorHandler::handleBootStatusReport: Boot status report has invalid"
|
|
" crc"
|
|
<< std::endl;
|
|
return result;
|
|
}
|
|
|
|
uint16_t offset = supv::DATA_FIELD_OFFSET;
|
|
bootStatusReport.socState = *(data + offset);
|
|
offset += 1;
|
|
bootStatusReport.powerCycles = *(data + offset);
|
|
offset += 1;
|
|
bootStatusReport.bootAfterMs = *(data + offset) << 24 | *(data + offset + 1) << 16 |
|
|
*(data + offset + 2) << 8 | *(data + offset + 3);
|
|
offset += 4;
|
|
bootStatusReport.bootTimeoutMs = *(data + offset) << 24 | *(data + offset + 1) << 16 |
|
|
*(data + offset + 2) << 8 | *(data + offset + 3);
|
|
offset += 4;
|
|
bootStatusReport.activeNvm = *(data + offset);
|
|
offset += 1;
|
|
bootStatusReport.bp0State = *(data + offset);
|
|
offset += 1;
|
|
bootStatusReport.bp1State = *(data + offset);
|
|
offset += 1;
|
|
bootStatusReport.bp2State = *(data + offset);
|
|
offset += 1;
|
|
bootStatusReport.bootState = *(data + offset);
|
|
offset += 1;
|
|
bootStatusReport.bootCycles = *(data + offset);
|
|
|
|
nextReplyId = supv::EXE_REPORT;
|
|
|
|
#if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_PLOC_SUPERVISOR == 1
|
|
sif::info << "PlocSupervisorHandler::handleBootStatusReport: SoC State: "
|
|
<< static_cast<unsigned int>(bootStatusReport.socState.value) << std::endl;
|
|
sif::info << "PlocSupervisorHandler::handleBootStatusReport: Power Cycles: "
|
|
<< static_cast<unsigned int>(bootStatusReport.powerCycles.value) << std::endl;
|
|
sif::info << "PlocSupervisorHandler::handleBootStatusReport: BootAfterMs: "
|
|
<< bootStatusReport.bootAfterMs << " ms" << std::endl;
|
|
sif::info << "PlocSupervisorHandler::handleBootStatusReport: BootTimeoutMs: " << std::dec
|
|
<< bootStatusReport.bootTimeoutMs << " ms" << std::endl;
|
|
sif::info << "PlocSupervisorHandler::handleBootStatusReport: Active NVM: "
|
|
<< static_cast<unsigned int>(bootStatusReport.activeNvm.value) << std::endl;
|
|
sif::info << "PlocSupervisorHandler::handleBootStatusReport: BP0: "
|
|
<< static_cast<unsigned int>(bootStatusReport.bp0State.value) << std::endl;
|
|
sif::info << "PlocSupervisorHandler::handleBootStatusReport: BP1: "
|
|
<< static_cast<unsigned int>(bootStatusReport.bp1State.value) << std::endl;
|
|
sif::info << "PlocSupervisorHandler::handleBootStatusReport: BP2: "
|
|
<< static_cast<unsigned int>(bootStatusReport.bp2State.value) << std::endl;
|
|
sif::info << "PlocSupervisorHandler::handleBootStatusReport: Boot state: "
|
|
<< static_cast<unsigned int>(bootStatusReport.bootState.value) << std::endl;
|
|
sif::info << "PlocSupervisorHandler::handleBootStatusReport: Boot cycles: "
|
|
<< static_cast<unsigned int>(bootStatusReport.bootCycles.value) << std::endl;
|
|
#endif
|
|
|
|
return result;
|
|
}
|
|
|
|
ReturnValue_t PlocSupervisorHandler::handleLatchupStatusReport(const uint8_t* data) {
|
|
ReturnValue_t result = RETURN_OK;
|
|
|
|
result = verifyPacket(data, supv::SIZE_LATCHUP_STATUS_REPORT);
|
|
|
|
if (result == SupvReturnValuesIF::CRC_FAILURE) {
|
|
sif::error << "PlocSupervisorHandler::handleLatchupStatusReport: Latchup status report has "
|
|
<< "invalid crc" << std::endl;
|
|
return result;
|
|
}
|
|
|
|
uint16_t offset = supv::DATA_FIELD_OFFSET;
|
|
latchupStatusReport.id = *(data + offset);
|
|
offset += 1;
|
|
latchupStatusReport.cnt0 = *(data + offset) << 8 | *(data + offset + 1);
|
|
offset += 2;
|
|
latchupStatusReport.cnt1 = *(data + offset) << 8 | *(data + offset + 1);
|
|
offset += 2;
|
|
latchupStatusReport.cnt2 = *(data + offset) << 8 | *(data + offset + 1);
|
|
offset += 2;
|
|
latchupStatusReport.cnt3 = *(data + offset) << 8 | *(data + offset + 1);
|
|
offset += 2;
|
|
latchupStatusReport.cnt4 = *(data + offset) << 8 | *(data + offset + 1);
|
|
offset += 2;
|
|
latchupStatusReport.cnt5 = *(data + offset) << 8 | *(data + offset + 1);
|
|
offset += 2;
|
|
latchupStatusReport.cnt6 = *(data + offset) << 8 | *(data + offset + 1);
|
|
offset += 2;
|
|
uint16_t msec = *(data + offset) << 8 | *(data + offset + 1);
|
|
latchupStatusReport.isSet = msec >> supv::LatchupStatusReport::IS_SET_BIT_POS;
|
|
latchupStatusReport.timeMsec = msec & (~(1 << latchupStatusReport.IS_SET_BIT_POS));
|
|
offset += 2;
|
|
latchupStatusReport.timeSec = *(data + offset);
|
|
offset += 1;
|
|
latchupStatusReport.timeMin = *(data + offset);
|
|
offset += 1;
|
|
latchupStatusReport.timeHour = *(data + offset);
|
|
offset += 1;
|
|
latchupStatusReport.timeDay = *(data + offset);
|
|
offset += 1;
|
|
latchupStatusReport.timeMon = *(data + offset);
|
|
offset += 1;
|
|
latchupStatusReport.timeYear = *(data + offset);
|
|
|
|
nextReplyId = supv::EXE_REPORT;
|
|
|
|
#if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_PLOC_SUPERVISOR == 1
|
|
sif::info << "PlocSupervisorHandler::handleLatchupStatusReport: Latchup ID: "
|
|
<< static_cast<unsigned int>(latchupStatusReport.id.value) << std::endl;
|
|
sif::info << "PlocSupervisorHandler::handleLatchupStatusReport: CNT0: "
|
|
<< latchupStatusReport.cnt0 << std::endl;
|
|
sif::info << "PlocSupervisorHandler::handleLatchupStatusReport: CNT1: "
|
|
<< latchupStatusReport.cnt1 << std::endl;
|
|
sif::info << "PlocSupervisorHandler::handleLatchupStatusReport: CNT2: "
|
|
<< latchupStatusReport.cnt2 << std::endl;
|
|
sif::info << "PlocSupervisorHandler::handleLatchupStatusReport: CNT3: "
|
|
<< latchupStatusReport.cnt3 << std::endl;
|
|
sif::info << "PlocSupervisorHandler::handleLatchupStatusReport: CNT4: "
|
|
<< latchupStatusReport.cnt4 << std::endl;
|
|
sif::info << "PlocSupervisorHandler::handleLatchupStatusReport: CNT5: "
|
|
<< latchupStatusReport.cnt5 << std::endl;
|
|
sif::info << "PlocSupervisorHandler::handleLatchupStatusReport: CNT6: "
|
|
<< latchupStatusReport.cnt6 << std::endl;
|
|
sif::info << "PlocSupervisorHandler::handleLatchupStatusReport: Sec: "
|
|
<< static_cast<unsigned int>(latchupStatusReport.timeSec.value) << std::endl;
|
|
sif::info << "PlocSupervisorHandler::handleLatchupStatusReport: Min: "
|
|
<< static_cast<unsigned int>(latchupStatusReport.timeMin.value) << std::endl;
|
|
sif::info << "PlocSupervisorHandler::handleLatchupStatusReport: Hour: "
|
|
<< static_cast<unsigned int>(latchupStatusReport.timeHour.value) << std::endl;
|
|
sif::info << "PlocSupervisorHandler::handleLatchupStatusReport: Day: "
|
|
<< static_cast<unsigned int>(latchupStatusReport.timeDay.value) << std::endl;
|
|
sif::info << "PlocSupervisorHandler::handleLatchupStatusReport: Mon: "
|
|
<< static_cast<unsigned int>(latchupStatusReport.timeMon.value) << std::endl;
|
|
sif::info << "PlocSupervisorHandler::handleLatchupStatusReport: Year: "
|
|
<< static_cast<unsigned int>(latchupStatusReport.timeYear.value) << std::endl;
|
|
sif::info << "PlocSupervisorHandler::handleLatchupStatusReport: Msec: "
|
|
<< static_cast<unsigned int>(latchupStatusReport.timeMsec.value) << std::endl;
|
|
sif::info << "PlocSupervisorHandler::handleLatchupStatusReport: isSet: "
|
|
<< static_cast<unsigned int>(latchupStatusReport.isSet.value) << std::endl;
|
|
#endif
|
|
|
|
return result;
|
|
}
|
|
|
|
ReturnValue_t PlocSupervisorHandler::handleLoggingReport(const uint8_t* data) {
|
|
ReturnValue_t result = RETURN_OK;
|
|
|
|
result = verifyPacket(data, supv::SIZE_LOGGING_REPORT);
|
|
|
|
if (result == SupvReturnValuesIF::CRC_FAILURE) {
|
|
sif::error << "PlocSupervisorHandler::handleLoggingReport: Logging report has "
|
|
<< "invalid crc" << std::endl;
|
|
return result;
|
|
}
|
|
|
|
const uint8_t* dataField = data + supv::DATA_FIELD_OFFSET + sizeof(supv::RequestLoggingData::Sa);
|
|
result = loggingReport.read();
|
|
if (result != RETURN_OK) {
|
|
return result;
|
|
}
|
|
loggingReport.setValidityBufferGeneration(false);
|
|
size_t size = loggingReport.getSerializedSize();
|
|
result = loggingReport.deSerialize(&dataField, &size, SerializeIF::Endianness::BIG);
|
|
if (result != RETURN_OK) {
|
|
sif::warning << "PlocSupervisorHandler::handleLoggingReport: Deserialization failed" << std::endl;
|
|
}
|
|
loggingReport.setValidityBufferGeneration(true);
|
|
loggingReport.setValidity(true, true);
|
|
result = loggingReport.commit();
|
|
if (result != RETURN_OK) {
|
|
return result;
|
|
}
|
|
#if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_PLOC_SUPERVISOR == 1
|
|
loggingReport.printSet();
|
|
#endif
|
|
nextReplyId = supv::EXE_REPORT;
|
|
return result;
|
|
}
|
|
|
|
ReturnValue_t PlocSupervisorHandler::handleAdcReport(const uint8_t* data) {
|
|
ReturnValue_t result = RETURN_OK;
|
|
|
|
result = verifyPacket(data, supv::SIZE_ADC_REPORT);
|
|
|
|
if (result == SupvReturnValuesIF::CRC_FAILURE) {
|
|
sif::error << "PlocSupervisorHandler::handleAdcReport: ADC report has "
|
|
<< "invalid crc" << std::endl;
|
|
return result;
|
|
}
|
|
|
|
const uint8_t* dataField = data + supv::DATA_FIELD_OFFSET;
|
|
result = adcReport.read();
|
|
if (result != RETURN_OK) {
|
|
return result;
|
|
}
|
|
adcReport.setValidityBufferGeneration(false);
|
|
size_t size = adcReport.getSerializedSize();
|
|
result = adcReport.deSerialize(&dataField, &size, SerializeIF::Endianness::BIG);
|
|
if (result != RETURN_OK) {
|
|
sif::warning << "PlocSupervisorHandler::handleAdcReport: Deserialization failed" << std::endl;
|
|
}
|
|
adcReport.setValidityBufferGeneration(true);
|
|
adcReport.setValidity(true, true);
|
|
result = adcReport.commit();
|
|
if (result != RETURN_OK) {
|
|
return result;
|
|
}
|
|
#if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_PLOC_SUPERVISOR == 1
|
|
adcReport.printSet();
|
|
#endif
|
|
nextReplyId = supv::EXE_REPORT;
|
|
return result;
|
|
}
|
|
|
|
void PlocSupervisorHandler::setNextReplyId() {
|
|
switch (getPendingCommand()) {
|
|
case supv::GET_HK_REPORT:
|
|
nextReplyId = supv::HK_REPORT;
|
|
break;
|
|
case supv::GET_BOOT_STATUS_REPORT:
|
|
nextReplyId = supv::BOOT_STATUS_REPORT;
|
|
break;
|
|
case supv::GET_LATCHUP_STATUS_REPORT:
|
|
nextReplyId = supv::LATCHUP_REPORT;
|
|
break;
|
|
case supv::FIRST_MRAM_DUMP:
|
|
nextReplyId = supv::FIRST_MRAM_DUMP;
|
|
break;
|
|
case supv::CONSECUTIVE_MRAM_DUMP:
|
|
nextReplyId = supv::CONSECUTIVE_MRAM_DUMP;
|
|
break;
|
|
case supv::LOGGING_REQUEST_COUNTERS:
|
|
nextReplyId = supv::LOGGING_REPORT;
|
|
break;
|
|
case supv::REQUEST_ADC_REPORT:
|
|
nextReplyId = supv::ADC_REPORT;
|
|
break;
|
|
default:
|
|
/* If no telemetry is expected the next reply is always the execution report */
|
|
nextReplyId = supv::EXE_REPORT;
|
|
break;
|
|
}
|
|
}
|
|
|
|
size_t PlocSupervisorHandler::getNextReplyLength(DeviceCommandId_t commandId) {
|
|
size_t replyLen = 0;
|
|
|
|
if (nextReplyId == supv::NONE) {
|
|
return replyLen;
|
|
}
|
|
|
|
if (nextReplyId == supv::FIRST_MRAM_DUMP || nextReplyId == supv::CONSECUTIVE_MRAM_DUMP) {
|
|
/**
|
|
* Try to read 20 MRAM packets. If reply is larger, the packets will be read with the
|
|
* next doSendRead call. The command will be as long active as the packet with the sequence
|
|
* count indicating the last packet has not been received.
|
|
*/
|
|
replyLen = supv::MAX_PACKET_SIZE * 20;
|
|
return replyLen;
|
|
}
|
|
|
|
DeviceReplyIter iter = deviceReplyMap.find(nextReplyId);
|
|
if (iter != deviceReplyMap.end()) {
|
|
if (iter->second.delayCycles == 0) {
|
|
/* Reply inactive */
|
|
return replyLen;
|
|
}
|
|
replyLen = iter->second.replyLen;
|
|
} else {
|
|
sif::debug << "PlocSupervisorHandler::getNextReplyLength: No entry for reply with reply id "
|
|
<< std::hex << nextReplyId << " in deviceReplyMap" << std::endl;
|
|
}
|
|
|
|
return replyLen;
|
|
}
|
|
|
|
ReturnValue_t PlocSupervisorHandler::doSendReadHook() {
|
|
// Prevent DHB from polling UART during commands executed by the supervisor helper task
|
|
if (plocSupvHelperExecuting) {
|
|
return RETURN_FAILED;
|
|
}
|
|
return RETURN_OK;
|
|
}
|
|
|
|
void PlocSupervisorHandler::handleDeviceTM(const uint8_t* data, size_t dataSize,
|
|
DeviceCommandId_t replyId) {
|
|
ReturnValue_t result = RETURN_OK;
|
|
|
|
if (wiretappingMode == RAW) {
|
|
/* Data already sent in doGetRead() */
|
|
return;
|
|
}
|
|
|
|
DeviceReplyMap::iterator iter = deviceReplyMap.find(replyId);
|
|
if (iter == deviceReplyMap.end()) {
|
|
sif::debug << "PlocSupervisorHandler::handleDeviceTM: Unknown reply id" << std::endl;
|
|
return;
|
|
}
|
|
MessageQueueId_t queueId = iter->second.command->second.sendReplyTo;
|
|
|
|
if (queueId == NO_COMMANDER) {
|
|
return;
|
|
}
|
|
|
|
result = actionHelper.reportData(queueId, replyId, data, dataSize);
|
|
if (result != RETURN_OK) {
|
|
sif::debug << "PlocSupervisorHandler::handleDeviceTM: Failed to report data" << std::endl;
|
|
}
|
|
}
|
|
|
|
void PlocSupervisorHandler::prepareEmptyCmd(uint16_t apid) {
|
|
supv::ApidOnlyPacket packet(apid);
|
|
packetToOutBuffer(packet.getWholeData(), packet.getFullSize());
|
|
}
|
|
|
|
void PlocSupervisorHandler::prepareSelBootImageCmd(const uint8_t* commandData) {
|
|
supv::MPSoCBootSelect packet(*commandData, *(commandData + 1), *(commandData + 2),
|
|
*(commandData + 3));
|
|
packetToOutBuffer(packet.getWholeData(), packet.getFullSize());
|
|
}
|
|
|
|
ReturnValue_t PlocSupervisorHandler::prepareSetTimeRefCmd() {
|
|
Clock::TimeOfDay_t time;
|
|
ReturnValue_t result = Clock::getDateAndTime(&time);
|
|
if (result != RETURN_OK) {
|
|
sif::warning << "PlocSupervisorHandler::prepareSetTimeRefCmd: Failed to get current time"
|
|
<< std::endl;
|
|
return SupvReturnValuesIF::GET_TIME_FAILURE;
|
|
}
|
|
supv::SetTimeRef packet(&time);
|
|
packetToOutBuffer(packet.getWholeData(), packet.getFullSize());
|
|
return RETURN_OK;
|
|
}
|
|
|
|
void PlocSupervisorHandler::prepareDisableHk() {
|
|
supv::DisablePeriodicHkTransmission packet;
|
|
packetToOutBuffer(packet.getWholeData(), packet.getFullSize());
|
|
}
|
|
|
|
void PlocSupervisorHandler::prepareSetBootTimeoutCmd(const uint8_t* commandData) {
|
|
uint32_t timeout = *(commandData) << 24 | *(commandData + 1) << 16 | *(commandData + 2) << 8 |
|
|
*(commandData + 3);
|
|
supv::SetBootTimeout packet(timeout);
|
|
packetToOutBuffer(packet.getWholeData(), packet.getFullSize());
|
|
}
|
|
|
|
void PlocSupervisorHandler::prepareRestartTriesCmd(const uint8_t* commandData) {
|
|
uint8_t restartTries = *(commandData);
|
|
supv::SetRestartTries packet(restartTries);
|
|
packetToOutBuffer(packet.getWholeData(), packet.getFullSize());
|
|
}
|
|
|
|
ReturnValue_t PlocSupervisorHandler::prepareLatchupConfigCmd(const uint8_t* commandData,
|
|
DeviceCommandId_t deviceCommand) {
|
|
ReturnValue_t result = RETURN_OK;
|
|
uint8_t latchupId = *commandData;
|
|
if (latchupId > 6) {
|
|
return SupvReturnValuesIF::INVALID_LATCHUP_ID;
|
|
}
|
|
switch (deviceCommand) {
|
|
case (supv::ENABLE_LATCHUP_ALERT): {
|
|
supv::LatchupAlert packet(true, latchupId);
|
|
packetToOutBuffer(packet.getWholeData(), packet.getFullSize());
|
|
break;
|
|
}
|
|
case (supv::DISABLE_LATCHUP_ALERT): {
|
|
supv::LatchupAlert packet(false, latchupId);
|
|
packetToOutBuffer(packet.getWholeData(), packet.getFullSize());
|
|
break;
|
|
}
|
|
default: {
|
|
sif::debug << "PlocSupervisorHandler::prepareLatchupConfigCmd: Invalid command id"
|
|
<< std::endl;
|
|
result = RETURN_FAILED;
|
|
break;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
ReturnValue_t PlocSupervisorHandler::prepareSetAlertLimitCmd(const uint8_t* commandData) {
|
|
uint8_t offset = 0;
|
|
uint8_t latchupId = *commandData;
|
|
offset += 1;
|
|
uint32_t dutycycle = *(commandData + offset) << 24 | *(commandData + offset + 1) << 16 |
|
|
*(commandData + offset + 2) << 8 | *(commandData + offset + 3);
|
|
if (latchupId > 6) {
|
|
return SupvReturnValuesIF::INVALID_LATCHUP_ID;
|
|
}
|
|
supv::SetAlertlimit packet(latchupId, dutycycle);
|
|
packetToOutBuffer(packet.getWholeData(), packet.getFullSize());
|
|
return RETURN_OK;
|
|
}
|
|
|
|
void PlocSupervisorHandler::prepareSetAdcEnabledChannelsCmd(const uint8_t* commandData) {
|
|
uint16_t ch = *(commandData) << 8 | *(commandData + 1);
|
|
supv::SetAdcEnabledChannels packet(ch);
|
|
packetToOutBuffer(packet.getWholeData(), packet.getFullSize());
|
|
}
|
|
|
|
void PlocSupervisorHandler::prepareSetAdcWindowAndStrideCmd(const uint8_t* commandData) {
|
|
uint8_t offset = 0;
|
|
uint16_t windowSize = *(commandData + offset) << 8 | *(commandData + offset + 1);
|
|
offset += 2;
|
|
uint16_t stridingStepSize = *(commandData + offset) << 8 | *(commandData + offset + 1);
|
|
supv::SetAdcWindowAndStride packet(windowSize, stridingStepSize);
|
|
packetToOutBuffer(packet.getWholeData(), packet.getFullSize());
|
|
}
|
|
|
|
void PlocSupervisorHandler::prepareSetAdcThresholdCmd(const uint8_t* commandData) {
|
|
uint32_t threshold = *(commandData) << 24 | *(commandData + 1) << 16 | *(commandData + 2) << 8 |
|
|
*(commandData + 3);
|
|
supv::SetAdcThreshold packet(threshold);
|
|
packetToOutBuffer(packet.getWholeData(), packet.getFullSize());
|
|
}
|
|
|
|
ReturnValue_t PlocSupervisorHandler::prepareRunAutoEmTest(const uint8_t* commandData) {
|
|
uint8_t test = *commandData;
|
|
if (test != 1 && test != 2) {
|
|
return SupvReturnValuesIF::INVALID_TEST_PARAM;
|
|
}
|
|
supv::RunAutoEmTests packet(test);
|
|
packetToOutBuffer(packet.getWholeData(), packet.getFullSize());
|
|
return RETURN_OK;
|
|
}
|
|
|
|
ReturnValue_t PlocSupervisorHandler::prepareWipeMramCmd(const uint8_t* commandData) {
|
|
uint32_t start = 0;
|
|
uint32_t stop = 0;
|
|
size_t size = sizeof(start) + sizeof(stop);
|
|
SerializeAdapter::deSerialize(&start, &commandData, &size, SerializeIF::Endianness::BIG);
|
|
SerializeAdapter::deSerialize(&stop, &commandData, &size, SerializeIF::Endianness::BIG);
|
|
if ((stop - start) <= 0) {
|
|
return SupvReturnValuesIF::INVALID_MRAM_ADDRESSES;
|
|
}
|
|
supv::MramCmd packet(start, stop, supv::MramCmd::MramAction::WIPE);
|
|
packetToOutBuffer(packet.getWholeData(), packet.getFullSize());
|
|
return RETURN_OK;
|
|
}
|
|
|
|
ReturnValue_t PlocSupervisorHandler::prepareDumpMramCmd(const uint8_t* commandData) {
|
|
uint32_t start = 0;
|
|
uint32_t stop = 0;
|
|
size_t size = sizeof(start) + sizeof(stop);
|
|
SerializeAdapter::deSerialize(&start, &commandData, &size, SerializeIF::Endianness::BIG);
|
|
SerializeAdapter::deSerialize(&stop, &commandData, &size, SerializeIF::Endianness::BIG);
|
|
supv::MramCmd packet(start, stop, supv::MramCmd::MramAction::DUMP);
|
|
packetToOutBuffer(packet.getWholeData(), packet.getFullSize());
|
|
if ((stop - start) <= 0) {
|
|
return SupvReturnValuesIF::INVALID_MRAM_ADDRESSES;
|
|
}
|
|
expectedMramDumpPackets = (stop - start) / supv::MAX_DATA_CAPACITY;
|
|
if ((stop - start) % supv::MAX_DATA_CAPACITY) {
|
|
expectedMramDumpPackets++;
|
|
}
|
|
receivedMramDumpPackets = 0;
|
|
return RETURN_OK;
|
|
}
|
|
|
|
void PlocSupervisorHandler::prepareSetGpioCmd(const uint8_t* commandData) {
|
|
uint8_t port = *commandData;
|
|
uint8_t pin = *(commandData + 1);
|
|
uint8_t val = *(commandData + 2);
|
|
supv::SetGpio packet(port, pin, val);
|
|
packetToOutBuffer(packet.getWholeData(), packet.getFullSize());
|
|
}
|
|
|
|
void PlocSupervisorHandler::prepareReadGpioCmd(const uint8_t* commandData) {
|
|
uint8_t port = *commandData;
|
|
uint8_t pin = *(commandData + 1);
|
|
supv::ReadGpio packet(port, pin);
|
|
packetToOutBuffer(packet.getWholeData(), packet.getFullSize());
|
|
}
|
|
|
|
void PlocSupervisorHandler::packetToOutBuffer(uint8_t* packetData, size_t fullSize) {
|
|
memcpy(commandBuffer, packetData, fullSize);
|
|
rawPacket = commandBuffer;
|
|
rawPacketLen = fullSize;
|
|
nextReplyId = supv::ACK_REPORT;
|
|
}
|
|
|
|
void PlocSupervisorHandler::prepareSetShutdownTimeoutCmd(const uint8_t* commandData) {
|
|
uint32_t timeout = 0;
|
|
ReturnValue_t result = RETURN_OK;
|
|
size_t size = sizeof(timeout);
|
|
result =
|
|
SerializeAdapter::deSerialize(&timeout, &commandData, &size, SerializeIF::Endianness::BIG);
|
|
if (result != RETURN_OK) {
|
|
sif::warning
|
|
<< "PlocSupervisorHandler::prepareSetShutdownTimeoutCmd: Failed to deserialize timeout"
|
|
<< std::endl;
|
|
}
|
|
supv::SetShutdownTimeout packet(timeout);
|
|
packetToOutBuffer(packet.getWholeData(), packet.getFullSize());
|
|
}
|
|
|
|
ReturnValue_t PlocSupervisorHandler::prepareLoggingRequest(const uint8_t* commandData,
|
|
size_t commandDataLen) {
|
|
using namespace supv;
|
|
RequestLoggingData::Sa sa = static_cast<RequestLoggingData::Sa>(*commandData);
|
|
uint8_t tpc = *(commandData + 1);
|
|
RequestLoggingData packet(sa, tpc);
|
|
packetToOutBuffer(packet.getWholeData(), packet.getFullSize());
|
|
return RETURN_OK;
|
|
}
|
|
|
|
void PlocSupervisorHandler::disableAllReplies() {
|
|
DeviceReplyMap::iterator iter;
|
|
|
|
/* Disable ack reply */
|
|
iter = deviceReplyMap.find(supv::ACK_REPORT);
|
|
DeviceReplyInfo* info = &(iter->second);
|
|
info->delayCycles = 0;
|
|
info->command = deviceCommandMap.end();
|
|
|
|
DeviceCommandId_t commandId = getPendingCommand();
|
|
|
|
/* If the command expects a telemetry packet the appropriate tm reply will be disabled here */
|
|
switch (commandId) {
|
|
case supv::GET_HK_REPORT: {
|
|
iter = deviceReplyMap.find(supv::GET_HK_REPORT);
|
|
info = &(iter->second);
|
|
info->delayCycles = 0;
|
|
info->command = deviceCommandMap.end();
|
|
break;
|
|
}
|
|
default: {
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* We must always disable the execution report reply here */
|
|
disableExeReportReply();
|
|
}
|
|
|
|
void PlocSupervisorHandler::sendFailureReport(DeviceCommandId_t replyId, ReturnValue_t status) {
|
|
DeviceReplyIter iter = deviceReplyMap.find(replyId);
|
|
|
|
if (iter == deviceReplyMap.end()) {
|
|
sif::debug << "PlocSupervisorHandler::sendFailureReport: Reply not in reply map" << std::endl;
|
|
return;
|
|
}
|
|
|
|
DeviceCommandInfo* info = &(iter->second.command->second);
|
|
|
|
if (info == nullptr) {
|
|
sif::debug << "PlocSupervisorHandler::sendFailureReport: Reply has no active command"
|
|
<< std::endl;
|
|
return;
|
|
}
|
|
|
|
if (info->sendReplyTo != NO_COMMANDER) {
|
|
actionHelper.finish(false, info->sendReplyTo, iter->first, status);
|
|
}
|
|
info->isExecuting = false;
|
|
}
|
|
|
|
void PlocSupervisorHandler::disableExeReportReply() {
|
|
DeviceReplyIter iter = deviceReplyMap.find(supv::EXE_REPORT);
|
|
DeviceReplyInfo* info = &(iter->second);
|
|
info->delayCycles = 0;
|
|
info->command = deviceCommandMap.end();
|
|
/* Expected replies is set to one here. The value will set to 0 in replyToReply() */
|
|
info->command->second.expectedReplies = 1;
|
|
}
|
|
|
|
ReturnValue_t PlocSupervisorHandler::parseMramPackets(const uint8_t* packet, size_t remainingSize,
|
|
size_t* foundLen) {
|
|
ReturnValue_t result = IGNORE_FULL_PACKET;
|
|
uint16_t packetLen = 0;
|
|
*foundLen = 0;
|
|
|
|
for (size_t idx = 0; idx < remainingSize; idx++) {
|
|
std::memcpy(spacePacketBuffer + bufferTop, packet + idx, 1);
|
|
bufferTop += 1;
|
|
*foundLen += 1;
|
|
if (bufferTop >= supv::SPACE_PACKET_HEADER_LENGTH) {
|
|
packetLen = readSpacePacketLength(spacePacketBuffer);
|
|
}
|
|
|
|
if (bufferTop == supv::SPACE_PACKET_HEADER_LENGTH + packetLen + 1) {
|
|
packetInBuffer = true;
|
|
bufferTop = 0;
|
|
return checkMramPacketApid();
|
|
}
|
|
|
|
if (bufferTop == supv::MAX_PACKET_SIZE) {
|
|
*foundLen = remainingSize;
|
|
disableAllReplies();
|
|
bufferTop = 0;
|
|
sif::info << "PlocSupervisorHandler::parseMramPackets: Can not find MRAM packet in space packet buffer" << std::endl;
|
|
return SupvReturnValuesIF::MRAM_PACKET_PARSING_FAILURE;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
ReturnValue_t PlocSupervisorHandler::handleMramDumpPacket(DeviceCommandId_t id) {
|
|
ReturnValue_t result = RETURN_FAILED;
|
|
|
|
// Prepare packet for downlink
|
|
if (packetInBuffer) {
|
|
uint16_t packetLen = readSpacePacketLength(spacePacketBuffer);
|
|
result = verifyPacket(spacePacketBuffer, supv::SPACE_PACKET_HEADER_LENGTH + packetLen + 1);
|
|
if (result != RETURN_OK) {
|
|
sif::warning << "PlocSupervisorHandler::handleMramDumpPacket: CRC failure" << std::endl;
|
|
return result;
|
|
}
|
|
handleMramDumpFile(id);
|
|
if (downlinkMramDump == true) {
|
|
handleDeviceTM(spacePacketBuffer + supv::SPACE_PACKET_HEADER_LENGTH, packetLen - 1, id);
|
|
}
|
|
packetInBuffer = false;
|
|
receivedMramDumpPackets++;
|
|
if (expectedMramDumpPackets == receivedMramDumpPackets) {
|
|
nextReplyId = supv::EXE_REPORT;
|
|
}
|
|
increaseExpectedMramReplies(id);
|
|
return RETURN_OK;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
void PlocSupervisorHandler::increaseExpectedMramReplies(DeviceCommandId_t id) {
|
|
DeviceReplyMap::iterator mramDumpIter = deviceReplyMap.find(id);
|
|
DeviceReplyMap::iterator exeReportIter = deviceReplyMap.find(supv::EXE_REPORT);
|
|
if (mramDumpIter == deviceReplyMap.end()) {
|
|
sif::debug << "PlocSupervisorHandler::increaseExpectedMramReplies: Dump MRAM reply not "
|
|
<< "in reply map" << std::endl;
|
|
return;
|
|
}
|
|
if (exeReportIter == deviceReplyMap.end()) {
|
|
sif::debug << "PlocSupervisorHandler::increaseExpectedMramReplies: Execution report not "
|
|
<< "in reply map" << std::endl;
|
|
return;
|
|
}
|
|
DeviceReplyInfo* mramReplyInfo = &(mramDumpIter->second);
|
|
if (mramReplyInfo == nullptr) {
|
|
sif::debug << "PlocSupervisorHandler::increaseExpectedReplies: MRAM reply info nullptr"
|
|
<< std::endl;
|
|
return;
|
|
}
|
|
DeviceReplyInfo* exeReplyInfo = &(exeReportIter->second);
|
|
if (exeReplyInfo == nullptr) {
|
|
sif::debug << "PlocSupervisorHandler::increaseExpectedReplies: Execution reply info"
|
|
<< " nullptr" << std::endl;
|
|
return;
|
|
}
|
|
DeviceCommandInfo* info = &(mramReplyInfo->command->second);
|
|
if (info == nullptr) {
|
|
sif::debug << "PlocSupervisorHandler::increaseExpectedReplies: Command info nullptr"
|
|
<< std::endl;
|
|
return;
|
|
}
|
|
uint8_t sequenceFlags = spacePacketBuffer[2] >> 6;
|
|
if (sequenceFlags != static_cast<uint8_t>(supv::SequenceFlags::LAST_PKT) &&
|
|
(sequenceFlags != static_cast<uint8_t>(supv::SequenceFlags::STANDALONE_PKT))) {
|
|
// Command expects at least one MRAM packet more and the execution report
|
|
info->expectedReplies = 2;
|
|
// Wait maximum of 2 cycles for next MRAM packet
|
|
mramReplyInfo->delayCycles = 2;
|
|
// Also adapting delay cycles for execution report
|
|
exeReplyInfo->delayCycles = 3;
|
|
} else {
|
|
// Command expects the execution report
|
|
info->expectedReplies = 1;
|
|
mramReplyInfo->delayCycles = 0;
|
|
}
|
|
return;
|
|
}
|
|
|
|
ReturnValue_t PlocSupervisorHandler::checkMramPacketApid() {
|
|
uint16_t apid = (spacePacketBuffer[0] << 8 | spacePacketBuffer[1]) & supv::APID_MASK;
|
|
if (apid != supv::APID_MRAM_DUMP_TM) {
|
|
sif::warning << "PlocSupervisorHandler::checkMramPacketApid: 0x" << std::hex << apid << std::endl;
|
|
return SupvReturnValuesIF::NO_MRAM_PACKET;
|
|
}
|
|
return APERIODIC_REPLY;
|
|
}
|
|
|
|
ReturnValue_t PlocSupervisorHandler::handleMramDumpFile(DeviceCommandId_t id) {
|
|
ReturnValue_t result = RETURN_OK;
|
|
uint16_t packetLen = readSpacePacketLength(spacePacketBuffer);
|
|
uint8_t sequenceFlags = readSequenceFlags(spacePacketBuffer);
|
|
if (id == supv::FIRST_MRAM_DUMP) {
|
|
if (sequenceFlags == static_cast<uint8_t>(supv::SequenceFlags::FIRST_PKT) ||
|
|
(sequenceFlags == static_cast<uint8_t>(supv::SequenceFlags::STANDALONE_PKT))) {
|
|
result = createMramDumpFile();
|
|
if (result != RETURN_OK) {
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
if (not std::filesystem::exists(activeMramFile)) {
|
|
sif::warning << "PlocSupervisorHandler::handleMramDumpFile: MRAM file does not exist"
|
|
<< std::endl;
|
|
return SupvReturnValuesIF::MRAM_FILE_NOT_EXISTS;
|
|
}
|
|
std::ofstream file(activeMramFile, std::ios_base::app | std::ios_base::out);
|
|
file.write(reinterpret_cast<const char*>(spacePacketBuffer + supv::SPACE_PACKET_HEADER_LENGTH),
|
|
packetLen - 1);
|
|
file.close();
|
|
return RETURN_OK;
|
|
}
|
|
|
|
uint16_t PlocSupervisorHandler::readSpacePacketLength(uint8_t* spacePacket) {
|
|
return spacePacket[4] << 8 | spacePacket[5];
|
|
}
|
|
|
|
uint8_t PlocSupervisorHandler::readSequenceFlags(uint8_t* spacePacket) {
|
|
return spacePacketBuffer[2] >> 6;
|
|
}
|
|
|
|
ReturnValue_t PlocSupervisorHandler::createMramDumpFile() {
|
|
ReturnValue_t result = RETURN_OK;
|
|
std::string timeStamp;
|
|
result = getTimeStampString(timeStamp);
|
|
if (result != RETURN_OK) {
|
|
return result;
|
|
}
|
|
|
|
std::string filename = "mram-dump--" + timeStamp + ".bin";
|
|
|
|
#ifndef TE0720_1CFA
|
|
std::string currentMountPrefix = sdcMan->getCurrentMountPrefix();
|
|
#else
|
|
std::string currentMountPrefix("/mnt/sd0");
|
|
#endif /* BOARD_TE0720 == 0 */
|
|
|
|
// Check if path to PLOC directory exists
|
|
if (not std::filesystem::exists(std::string(currentMountPrefix + "/" + plocFilePath))) {
|
|
sif::warning << "PlocSupervisorHandler::createMramDumpFile: Ploc path does not exist"
|
|
<< std::endl;
|
|
return SupvReturnValuesIF::PATH_DOES_NOT_EXIST;
|
|
}
|
|
activeMramFile = currentMountPrefix + "/" + plocFilePath + "/" + filename;
|
|
// Create new file
|
|
std::ofstream file(activeMramFile, std::ios_base::out);
|
|
file.close();
|
|
|
|
return RETURN_OK;
|
|
}
|
|
|
|
ReturnValue_t PlocSupervisorHandler::getTimeStampString(std::string& timeStamp) {
|
|
Clock::TimeOfDay_t time;
|
|
ReturnValue_t result = Clock::getDateAndTime(&time);
|
|
if (result != RETURN_OK) {
|
|
sif::warning << "PlocSupervisorHandler::createMramDumpFile: Failed to get current time"
|
|
<< std::endl;
|
|
return SupvReturnValuesIF::GET_TIME_FAILURE;
|
|
}
|
|
timeStamp = std::to_string(time.year) + "-" + std::to_string(time.month) + "-" +
|
|
std::to_string(time.day) + "--" + std::to_string(time.hour) + "-" +
|
|
std::to_string(time.minute) + "-" + std::to_string(time.second);
|
|
return RETURN_OK;
|
|
}
|
|
|
|
ReturnValue_t PlocSupervisorHandler::extractUpdateCommand(const uint8_t* commandData, size_t size,
|
|
std::string* file, uint8_t* memoryId,
|
|
uint32_t* startAddress) {
|
|
ReturnValue_t result = RETURN_OK;
|
|
if (size > (config::MAX_FILENAME_SIZE + config::MAX_PATH_SIZE + sizeof(*memoryId)) +
|
|
sizeof(*startAddress)) {
|
|
sif::warning << "PlocSupervisorHandler::extractUpdateCommand: Data size too big" << std::endl;
|
|
return SupvReturnValuesIF::INVALID_LENGTH;
|
|
}
|
|
*file = std::string(reinterpret_cast<const char*>(commandData));
|
|
if (file->size() > (config::MAX_FILENAME_SIZE + config::MAX_PATH_SIZE)) {
|
|
sif::warning << "PlocSupervisorHandler::extractUpdateCommand: Filename too long" << std::endl;
|
|
return SupvReturnValuesIF::FILENAME_TOO_LONG;
|
|
}
|
|
*memoryId = *(commandData + file->size() + SIZE_NULL_TERMINATOR);
|
|
const uint8_t* startAddressPtr =
|
|
commandData + file->size() + SIZE_NULL_TERMINATOR + sizeof(*memoryId);
|
|
size_t remainingSize = 4;
|
|
result = SerializeAdapter::deSerialize(startAddress, startAddressPtr, &remainingSize,
|
|
SerializeIF::Endianness::BIG);
|
|
if (result != RETURN_OK) {
|
|
sif::warning
|
|
<< "PlocSupervisorHandler::extractUpdateCommand: Failed to deserialize start address"
|
|
<< std::endl;
|
|
return result;
|
|
}
|
|
return RETURN_OK;
|
|
}
|
|
|
|
ReturnValue_t PlocSupervisorHandler::eventSubscription() {
|
|
ReturnValue_t result = RETURN_OK;
|
|
EventManagerIF* manager = ObjectManager::instance()->get<EventManagerIF>(objects::EVENT_MANAGER);
|
|
if (manager == nullptr) {
|
|
#if FSFW_CPP_OSTREAM_ENABLED == 1
|
|
sif::error << "PlocSupervisorHandler::eventSubscritpion: Invalid event manager" << std::endl;
|
|
#endif
|
|
return ObjectManagerIF::CHILD_INIT_FAILED;
|
|
;
|
|
}
|
|
result = manager->registerListener(eventQueue->getId());
|
|
if (result != RETURN_OK) {
|
|
return result;
|
|
}
|
|
result = manager->subscribeToEventRange(
|
|
eventQueue->getId(), event::getEventId(PlocSupvHelper::SUPV_UPDATE_FAILED),
|
|
event::getEventId(PlocSupvHelper::SUPV_EVENT_BUFFER_REQUEST_TERMINATED));
|
|
if (result != RETURN_OK) {
|
|
#if FSFW_CPP_OSTREAM_ENABLED == 1
|
|
sif::warning << "PlocSupervisorHandler::eventSubscritpion: Failed to subscribe to events from "
|
|
" ploc supervisor helper"
|
|
<< std::endl;
|
|
#endif
|
|
return ObjectManagerIF::CHILD_INIT_FAILED;
|
|
}
|
|
return result;
|
|
}
|