396 lines
12 KiB
C++
396 lines
12 KiB
C++
#include <fsfw/filesystem/HasFileSystemIF.h>
|
|
#include <linux/payload/ScexHelper.h>
|
|
#include <mission/memory/SdCardMountedIF.h>
|
|
#include <mission/payload/ScexDeviceHandler.h>
|
|
#include <mission/payload/scexHelpers.h>
|
|
|
|
#include <algorithm>
|
|
#include <ctime>
|
|
#include <filesystem>
|
|
#include <fstream>
|
|
#include <iostream>
|
|
#include <random>
|
|
|
|
#include "eive/definitions.h"
|
|
#include "fsfw/globalfunctions/CRC.h"
|
|
|
|
using std::ofstream;
|
|
using namespace returnvalue;
|
|
|
|
ScexDeviceHandler::ScexDeviceHandler(object_id_t objectId, ScexUartReader& reader, CookieIF* cookie,
|
|
SdCardMountedIF& sdcMan)
|
|
: DeviceHandlerBase(objectId, reader.getObjectId(), cookie), sdcMan(sdcMan), reader(reader) {
|
|
fsUnusableEventCd.timeOut();
|
|
}
|
|
|
|
ScexDeviceHandler::~ScexDeviceHandler() {}
|
|
|
|
void ScexDeviceHandler::doStartUp() {
|
|
filesystemChecks();
|
|
setMode(MODE_ON);
|
|
}
|
|
|
|
void ScexDeviceHandler::doShutDown() {
|
|
reader.reset();
|
|
commandActive = false;
|
|
fileNameSet = false;
|
|
multiFileFinishOutstanding = false;
|
|
setMode(_MODE_POWER_DOWN);
|
|
}
|
|
|
|
ReturnValue_t ScexDeviceHandler::buildNormalDeviceCommand(DeviceCommandId_t* id) {
|
|
return NOTHING_TO_SEND;
|
|
}
|
|
|
|
ReturnValue_t ScexDeviceHandler::buildTransitionDeviceCommand(DeviceCommandId_t* id) {
|
|
return NOTHING_TO_SEND;
|
|
}
|
|
|
|
ReturnValue_t ScexDeviceHandler::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
|
|
const uint8_t* commandData,
|
|
size_t commandDataLen) {
|
|
using namespace scex;
|
|
|
|
auto cmdTyped = static_cast<scex::Cmds>(deviceCommand);
|
|
if (std::find(VALID_CMDS.begin(), VALID_CMDS.end(), deviceCommand) == VALID_CMDS.end()) {
|
|
return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
|
|
}
|
|
bool tempCheck = false;
|
|
if (commandDataLen >= 1) {
|
|
tempCheck = commandData[0];
|
|
}
|
|
if (commandActive) {
|
|
return DeviceHandlerIF::BUSY;
|
|
}
|
|
|
|
switch (deviceCommand) {
|
|
case (PING): {
|
|
finishCountdown.setTimeout(SHORT_CD);
|
|
// countdown starten
|
|
finishCountdown.resetTimer();
|
|
prepareScexCmd(cmdTyped, {cmdBuf.data(), cmdBuf.size()}, rawPacketLen, {nullptr, 0},
|
|
tempCheck);
|
|
break;
|
|
}
|
|
case (EXP_STATUS_CMD): {
|
|
finishCountdown.setTimeout(SHORT_CD);
|
|
// countdown starten
|
|
finishCountdown.resetTimer();
|
|
prepareScexCmd(cmdTyped, {cmdBuf.data(), cmdBuf.size()}, rawPacketLen, {nullptr, 0},
|
|
tempCheck);
|
|
break;
|
|
}
|
|
case (ION_CMD): {
|
|
finishCountdown.setTimeout(SHORT_CD);
|
|
// countdown starten
|
|
finishCountdown.resetTimer();
|
|
prepareScexCmd(cmdTyped, {cmdBuf.data(), cmdBuf.size()}, rawPacketLen, {nullptr, 0},
|
|
tempCheck);
|
|
break;
|
|
}
|
|
case (TEMP_CMD): {
|
|
finishCountdown.setTimeout(SHORT_CD);
|
|
// countdown starten
|
|
finishCountdown.resetTimer();
|
|
prepareScexCmd(cmdTyped, {cmdBuf.data(), cmdBuf.size()}, rawPacketLen, {nullptr, 0},
|
|
tempCheck);
|
|
break;
|
|
}
|
|
case (FRAM): {
|
|
finishCountdown.setTimeout(LONG_CD);
|
|
// countdown starten
|
|
finishCountdown.resetTimer();
|
|
if (debugMode) {
|
|
uint32_t remainingMillis = finishCountdown.getRemainingMillis();
|
|
|
|
sif::info << "ScexDeviceHandler::buildCommandFromCommand: RemainingMillis: "
|
|
<< remainingMillis << std::endl;
|
|
}
|
|
|
|
multiFileFinishOutstanding = true;
|
|
prepareScexCmd(cmdTyped, {cmdBuf.data(), cmdBuf.size()}, rawPacketLen,
|
|
{commandData + 1, commandDataLen - 1}, tempCheck);
|
|
updatePeriodicReply(true, deviceCommand);
|
|
break;
|
|
}
|
|
case (ONE_CELL): {
|
|
finishCountdown.setTimeout(LONG_CD);
|
|
// countdown starts
|
|
finishCountdown.resetTimer();
|
|
multiFileFinishOutstanding = true;
|
|
prepareScexCmd(cmdTyped, {cmdBuf.data(), cmdBuf.size()}, rawPacketLen,
|
|
{commandData + 1, commandDataLen - 1}, tempCheck);
|
|
updatePeriodicReply(true, deviceCommand);
|
|
break;
|
|
}
|
|
case (ALL_CELLS_CMD): {
|
|
finishCountdown.setTimeout(LONG_CD);
|
|
// countdown starts
|
|
finishCountdown.resetTimer();
|
|
multiFileFinishOutstanding = true;
|
|
prepareScexCmd(cmdTyped, {cmdBuf.data(), cmdBuf.size()}, rawPacketLen,
|
|
{commandData + 1, commandDataLen - 1}, tempCheck);
|
|
updatePeriodicReply(true, deviceCommand);
|
|
break;
|
|
}
|
|
default: {
|
|
return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
|
|
}
|
|
}
|
|
commandActive = true;
|
|
rawPacket = cmdBuf.data();
|
|
return OK;
|
|
}
|
|
|
|
void ScexDeviceHandler::fillCommandAndReplyMap() {
|
|
insertInCommandAndReplyMap(scex::Cmds::PING, 5, nullptr, 0, false, false, 0, &finishCountdown);
|
|
insertInCommandAndReplyMap(scex::Cmds::ION_CMD, 3, nullptr, 0, false, false, 0, &finishCountdown);
|
|
insertInCommandAndReplyMap(scex::Cmds::TEMP_CMD, 3, nullptr, 0, false, false, 0,
|
|
&finishCountdown);
|
|
insertInCommandAndReplyMap(scex::Cmds::EXP_STATUS_CMD, 3, nullptr, 0, false, false, 0,
|
|
&finishCountdown);
|
|
|
|
insertInCommandAndReplyMap(scex::Cmds::ALL_CELLS_CMD, 0, nullptr, 0, true, false,
|
|
scex::Cmds::ALL_CELLS_CMD, &finishCountdown);
|
|
insertInCommandAndReplyMap(scex::Cmds::ONE_CELL, 0, nullptr, 0, true, false, scex::Cmds::ONE_CELL,
|
|
&finishCountdown);
|
|
insertInCommandAndReplyMap(scex::Cmds::FRAM, 0, nullptr, 0, true, false, scex::Cmds::FRAM,
|
|
&finishCountdown);
|
|
|
|
insertInReplyMap(scex::Cmds::ERROR_REPLY, 3);
|
|
}
|
|
|
|
ReturnValue_t ScexDeviceHandler::scanForReply(const uint8_t* start, size_t remainingSize,
|
|
DeviceCommandId_t* foundId, size_t* foundLen) {
|
|
size_t len = remainingSize;
|
|
ReturnValue_t result = helper.deSerialize(&start, &len);
|
|
|
|
if (result == ScexHelper::INVALID_CRC) {
|
|
sif::warning << "ScexDeviceHandler::scanForReply: CRC invalid" << std::endl;
|
|
*foundLen = remainingSize;
|
|
} else {
|
|
result = handleValidReply(remainingSize, foundId, foundLen);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
ReturnValue_t ScexDeviceHandler::handleValidReply(size_t remSize, DeviceCommandId_t* foundId,
|
|
size_t* foundLen) {
|
|
using namespace scex;
|
|
ReturnValue_t result = OK;
|
|
|
|
switch (helper.getCmd()) {
|
|
case (FRAM): {
|
|
if (debugMode) {
|
|
uint32_t remainingMillis = finishCountdown.getRemainingMillis();
|
|
|
|
sif::info << "ScexDeviceHandler::handleValidReply: RemMillis: " << remainingMillis
|
|
<< std::endl;
|
|
}
|
|
result = APERIODIC_REPLY;
|
|
break;
|
|
}
|
|
case (ONE_CELL): {
|
|
result = APERIODIC_REPLY;
|
|
break;
|
|
}
|
|
case (ALL_CELLS_CMD): {
|
|
result = APERIODIC_REPLY;
|
|
break;
|
|
}
|
|
default: {
|
|
break;
|
|
}
|
|
}
|
|
if (result == APERIODIC_REPLY and multiFileFinishOutstanding) {
|
|
finishAction(true, helper.getCmd(), OK);
|
|
multiFileFinishOutstanding = false;
|
|
}
|
|
|
|
*foundId = helper.getCmd();
|
|
*foundLen = remSize;
|
|
return result;
|
|
}
|
|
|
|
ReturnValue_t ScexDeviceHandler::interpretDeviceReply(DeviceCommandId_t id, const uint8_t* packet) {
|
|
using namespace scex;
|
|
|
|
ReturnValue_t status = OK;
|
|
auto multiFileHandler = [&](const char* cmdName) {
|
|
if ((helper.getPacketCounter() == 1) or (not fileNameSet)) {
|
|
status = generateNewScexFile(cmdName);
|
|
if (status != returnvalue::OK) {
|
|
return status;
|
|
}
|
|
fileNameSet = true;
|
|
} else {
|
|
if (!sdcMan.isSdCardUsable(std::nullopt)) {
|
|
fsUnsableEvent();
|
|
return returnvalue::FAILED;
|
|
}
|
|
// Append to existing file.
|
|
ofstream out(fileName, ofstream::binary | ofstream::app);
|
|
if (out.bad()) {
|
|
sif::error << "ScexDeviceHandler::handleValidReply: Could not open file " << fileName
|
|
<< std::endl;
|
|
return FAILED;
|
|
}
|
|
out << helper;
|
|
}
|
|
return OK;
|
|
};
|
|
id = helper.getCmd();
|
|
switch (id) {
|
|
case (PING): {
|
|
status = generateNewScexFile(PING_IDLE_BASE_NAME);
|
|
break;
|
|
}
|
|
case (ION_CMD): {
|
|
status = generateNewScexFile(ION_BASE_NAME);
|
|
break;
|
|
}
|
|
case (TEMP_CMD): {
|
|
status = generateNewScexFile(TEMPERATURE_BASE_NAME);
|
|
break;
|
|
}
|
|
case (EXP_STATUS_CMD): {
|
|
status = generateNewScexFile(EXP_STATUS_BASE_NAME);
|
|
break;
|
|
}
|
|
case (FRAM): {
|
|
status = multiFileHandler(FRAM_BASE_NAME);
|
|
break;
|
|
}
|
|
case (ONE_CELL): {
|
|
status = multiFileHandler(ONE_CELL_BASE_NAME);
|
|
break;
|
|
}
|
|
case (ALL_CELLS_CMD): {
|
|
status = multiFileHandler(ALL_CELLS_BASE_NAME);
|
|
break;
|
|
}
|
|
default:
|
|
// Unknown DeviceCommand
|
|
return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
|
|
}
|
|
if (helper.getPacketCounter() >= helper.getTotalPacketCounter()) {
|
|
reader.finish();
|
|
commandActive = false;
|
|
if (id != PING) {
|
|
fileNameSet = false;
|
|
}
|
|
if (id == FRAM or id == ALL_CELLS_CMD or id == ONE_CELL) {
|
|
triggerEvent(MULTI_PACKET_COMMAND_DONE, id);
|
|
updatePeriodicReply(false, id);
|
|
}
|
|
}
|
|
if (debugMode) {
|
|
uint32_t remainingMillis = finishCountdown.getRemainingMillis();
|
|
sif::info << __FILE__ << __func__ << "(" << __LINE__ << ") RemMillis: " << remainingMillis
|
|
<< std::endl;
|
|
}
|
|
return status;
|
|
}
|
|
|
|
void ScexDeviceHandler::performOperationHook() {
|
|
if (getMode() != MODE_OFF) {
|
|
filesystemChecks();
|
|
}
|
|
uint32_t remainingMillis = finishCountdown.getRemainingMillis();
|
|
if (commandActive and finishCountdown.hasTimedOut()) {
|
|
triggerEvent(scex::EXPERIMENT_TIMEDOUT, currCmd, 0);
|
|
reader.finish();
|
|
sif::warning << "ScexDeviceHandler::scanForReply: Reader timeout; RemMillis: "
|
|
<< remainingMillis << std::endl;
|
|
fileNameSet = false;
|
|
commandActive = false;
|
|
}
|
|
}
|
|
|
|
uint32_t ScexDeviceHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 5000; }
|
|
|
|
ReturnValue_t ScexDeviceHandler::getSwitches(const uint8_t** switches, uint8_t* numberOfSwitches) {
|
|
if (switchId) {
|
|
*numberOfSwitches = 1;
|
|
*switches = &switchId.value();
|
|
}
|
|
return OK;
|
|
}
|
|
|
|
ReturnValue_t ScexDeviceHandler::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
|
|
LocalDataPoolManager& poolManager) {
|
|
return OK;
|
|
}
|
|
|
|
void ScexDeviceHandler::filesystemChecks() {
|
|
auto mntPrefix = sdcMan.getCurrentMountPrefix();
|
|
if (mntPrefix == nullptr or !sdcMan.isSdCardUsable(std::nullopt)) {
|
|
sif::warning << "SCEX: Filesystem currently unavailable" << std::endl;
|
|
fsUnsableEvent();
|
|
} else {
|
|
std::filesystem::path fullFilePath = mntPrefix;
|
|
std::error_code e;
|
|
fullFilePath /= "scex";
|
|
bool fileExists = std::filesystem::exists(fullFilePath, e);
|
|
if (not fileExists) {
|
|
bool created = std::filesystem::create_directory(fullFilePath, e);
|
|
if (not created) {
|
|
sif::error << "Could not create SCEX directory: " << e << std::endl;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void ScexDeviceHandler::fsUnsableEvent() {
|
|
if (fsUnusableEventCd.isBusy()) {
|
|
return;
|
|
}
|
|
triggerEvent(scex::FS_UNUSABLE);
|
|
fsUnusableEventCd.resetTimer();
|
|
}
|
|
|
|
ReturnValue_t ScexDeviceHandler::generateNewScexFile(const char* cmdName) {
|
|
char timeString[64]{};
|
|
auto activeSd = sdcMan.getActiveSdCard();
|
|
if (not activeSd) {
|
|
return HasFileSystemIF::FILESYSTEM_INACTIVE;
|
|
}
|
|
|
|
std::ostringstream oss;
|
|
auto prefix = sdcMan.getCurrentMountPrefix();
|
|
if (prefix == nullptr or !sdcMan.isSdCardUsable(std::nullopt)) {
|
|
fsUnsableEvent();
|
|
return returnvalue::FAILED;
|
|
}
|
|
timeval tv;
|
|
Clock::getClock_timeval(&tv);
|
|
time_t epoch = tv.tv_sec;
|
|
struct tm* time = gmtime(&epoch);
|
|
size_t writtenBytes = strftime(reinterpret_cast<char*>(timeString), sizeof(timeString),
|
|
config::FILE_DATE_FORMAT, time);
|
|
if (writtenBytes == 0) {
|
|
sif::error << "PersistentTmStore::createMostRecentFile: Could not create file timestamp"
|
|
<< std::endl;
|
|
return returnvalue::FAILED;
|
|
}
|
|
oss << prefix << "/scex/scex-" << cmdName << "-" << timeString << ".bin";
|
|
fileName = oss.str();
|
|
ofstream out(fileName, ofstream::binary);
|
|
if (out.bad()) {
|
|
sif::error << "ScexDeviceHandler::interpretDeviceReply: Could not open file " << fileName
|
|
<< std::endl;
|
|
return FAILED;
|
|
}
|
|
out << helper;
|
|
return OK;
|
|
}
|
|
|
|
void ScexDeviceHandler::setPowerSwitcher(PowerSwitchIF& powerSwitcher, power::Switch_t switchId) {
|
|
DeviceHandlerBase::setPowerSwitcher(&powerSwitcher);
|
|
this->switchId = switchId;
|
|
}
|
|
|
|
ReturnValue_t ScexDeviceHandler::initializeAfterTaskCreation() {
|
|
return DeviceHandlerBase::initializeAfterTaskCreation();
|
|
}
|