312 lines
9.9 KiB
C++
312 lines
9.9 KiB
C++
#include "ScexDeviceHandler.h"
|
||
|
||
#include <linux/devices/ScexHelper.h>
|
||
#include <mission/memory/SdCardMountedIF.h>
|
||
|
||
#include <algorithm>
|
||
#include <iostream>
|
||
#include <random>
|
||
|
||
#include "fsfw/globalfunctions/CRC.h"
|
||
#include "mission/devices/devicedefinitions/ScexDefinitions.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) {}
|
||
|
||
ScexDeviceHandler::~ScexDeviceHandler() {}
|
||
|
||
void ScexDeviceHandler::doStartUp() {
|
||
// mode on
|
||
setMode(MODE_ON);
|
||
}
|
||
|
||
void ScexDeviceHandler::doShutDown() { setMode(_MODE_POWER_DOWN); }
|
||
|
||
ReturnValue_t ScexDeviceHandler::buildNormalDeviceCommand(DeviceCommandId_t* id) { return OK; }
|
||
|
||
ReturnValue_t ScexDeviceHandler::buildTransitionDeviceCommand(DeviceCommandId_t* id) { return OK; }
|
||
|
||
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;
|
||
}
|
||
|
||
prepareScexCmd(cmdTyped, {cmdBuf.data(), cmdBuf.size()}, rawPacketLen,
|
||
{commandData + 1, commandDataLen - 1}, tempCheck);
|
||
break;
|
||
}
|
||
case (ONE_CELL): {
|
||
finishCountdown.setTimeout(LONG_CD);
|
||
// countdown starts
|
||
finishCountdown.resetTimer();
|
||
prepareScexCmd(cmdTyped, {cmdBuf.data(), cmdBuf.size()}, rawPacketLen,
|
||
{commandData + 1, commandDataLen - 1}, tempCheck);
|
||
break;
|
||
}
|
||
case (ALL_CELLS_CMD): {
|
||
finishCountdown.setTimeout(LONG_CD);
|
||
// countdown starts
|
||
finishCountdown.resetTimer();
|
||
prepareScexCmd(cmdTyped, {cmdBuf.data(), cmdBuf.size()}, rawPacketLen,
|
||
{commandData + 1, commandDataLen - 1}, tempCheck);
|
||
break;
|
||
}
|
||
default: {
|
||
return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
|
||
}
|
||
}
|
||
commandActive = true;
|
||
rawPacket = cmdBuf.data();
|
||
return OK;
|
||
}
|
||
|
||
void ScexDeviceHandler::fillCommandAndReplyMap() {
|
||
insertInCommandAndReplyMap(scex::Cmds::PING, 5);
|
||
insertInCommandAndReplyMap(scex::Cmds::ION_CMD, 3);
|
||
insertInCommandAndReplyMap(scex::Cmds::TEMP_CMD, 3);
|
||
insertInCommandAndReplyMap(scex::Cmds::EXP_STATUS_CMD, 3);
|
||
|
||
// TODO: Pr<50>fen: richtige Variablen?
|
||
insertInCommandAndReplyMap(scex::Cmds::ALL_CELLS_CMD, 0, nullptr, 0, false, false,
|
||
scex::Cmds::ALL_CELLS_CMD, &finishCountdown);
|
||
insertInCommandAndReplyMap(scex::Cmds::ONE_CELL, 0, nullptr, 0, false, false,
|
||
scex::Cmds::ONE_CELL, &finishCountdown);
|
||
insertInCommandAndReplyMap(scex::Cmds::FRAM, 0, nullptr, 0, false, 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);
|
||
bool commandFound = false;
|
||
|
||
if (result == ScexHelper::INVALID_CRC) {
|
||
sif::warning << "ScexDeviceHandler::scanForReply: CRC invalid" << std::endl;
|
||
} else {
|
||
*foundId = helper.getCmd();
|
||
commandFound = true;
|
||
*foundLen = remainingSize;
|
||
}
|
||
|
||
if (commandFound) {
|
||
uint32_t remainingMillis = finishCountdown.getRemainingMillis();
|
||
if (commandActive and finishCountdown.hasTimedOut()) {
|
||
triggerEvent(scex::EXPERIMENT_TIMEDOUT, currCmd, 0);
|
||
reader.finish();
|
||
sif::warning << "ScexDeviceHandler::performOperationHook: Reader timeout; RemMillis: "
|
||
<< remainingMillis << std::endl;
|
||
fileNameSet = false;
|
||
commandActive = false;
|
||
}
|
||
}
|
||
|
||
auto multiFileHandler = [&](std::string cmdName) {
|
||
if ((helper.getPacketCounter() == 1) or (not fileNameSet)) {
|
||
fileId = random_string(6);
|
||
std::ostringstream oss("/tmp/scex-", std::ostringstream::ate);
|
||
oss << cmdName << fileId << ".bin";
|
||
fileName = oss.str();
|
||
fileNameSet = true;
|
||
ofstream out(fileName, ofstream::binary);
|
||
if (debugMode) {
|
||
uint32_t remainingMillis = finishCountdown.getRemainingMillis();
|
||
sif::info << "ScexDeviceHandler::interpretDeviceReply:MultifileHandler: RemMillis: "
|
||
<< remainingMillis << std::endl;
|
||
}
|
||
if (out.bad()) {
|
||
sif::error << "ScexDeviceHandler::interpretDeviceReply: Could not open file " << fileName
|
||
<< std::endl;
|
||
return FAILED;
|
||
}
|
||
} else {
|
||
ofstream out(fileName,
|
||
ofstream::binary | ofstream::app); // append
|
||
if (debugMode) {
|
||
out << helper;
|
||
}
|
||
}
|
||
|
||
return OK;
|
||
};
|
||
ReturnValue_t status = OK;
|
||
switch (helper.getCmd()) {
|
||
case (FRAM): {
|
||
if (debugMode) {
|
||
uint32_t remainingMillis = finishCountdown.getRemainingMillis();
|
||
|
||
sif::info << "ScexDeviceHandler::interpretDeviceReply: RemMillis: " << remainingMillis
|
||
<< std::endl;
|
||
}
|
||
status = multiFileHandler("fram_");
|
||
break;
|
||
}
|
||
case (ONE_CELL): {
|
||
status = multiFileHandler("one_cell_");
|
||
break;
|
||
}
|
||
case (ALL_CELLS_CMD): {
|
||
status = multiFileHandler("all_cell_");
|
||
break;
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
|
||
ReturnValue_t ScexDeviceHandler::interpretDeviceReply(DeviceCommandId_t id, const uint8_t* packet) {
|
||
// cmd auswertung (in file reinschreiben)
|
||
using namespace scex;
|
||
|
||
ReturnValue_t status = OK;
|
||
auto oneFileHandler = [&](std::string cmdName) {
|
||
fileId = random_string(6);
|
||
std::ostringstream oss("/tmp/scex-", std::ostringstream::ate);
|
||
oss << cmdName << fileId << ".bin";
|
||
fileName = oss.str();
|
||
std::cout << fileName << std::endl;
|
||
ofstream out(fileName, ofstream::binary);
|
||
if (out.bad()) {
|
||
sif::error << "ScexDeviceHandler::interpretDeviceReply: Could not open file " << fileName
|
||
<< std::endl;
|
||
return FAILED;
|
||
}
|
||
if (debugMode) {
|
||
out << helper;
|
||
}
|
||
return OK;
|
||
};
|
||
|
||
switch (id) {
|
||
case (PING): {
|
||
status = oneFileHandler("ping_");
|
||
break;
|
||
}
|
||
case (ION_CMD): {
|
||
status = oneFileHandler("ion_");
|
||
break;
|
||
}
|
||
case (TEMP_CMD): {
|
||
status = oneFileHandler("temp_");
|
||
break;
|
||
}
|
||
case (EXP_STATUS_CMD): {
|
||
status = oneFileHandler("exp_status_");
|
||
break;
|
||
}
|
||
|
||
default:
|
||
// Unknown DeviceCommand
|
||
return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
|
||
}
|
||
if (helper.getPacketCounter() == helper.getTotalPacketCounter()) {
|
||
reader.finish();
|
||
commandActive = false;
|
||
if (id != PING) {
|
||
sif::info << "ScexDeviceHandler::interpretDeviceReply:Reader is finished" << std::endl;
|
||
fileNameSet = false;
|
||
}
|
||
}
|
||
if (debugMode) {
|
||
uint32_t remainingMillis = finishCountdown.getRemainingMillis();
|
||
sif::info << __FILE__ << __func__ << "(" << __LINE__ << ") RemMillis: " << remainingMillis
|
||
<< std::endl;
|
||
}
|
||
return status;
|
||
}
|
||
|
||
void ScexDeviceHandler::performOperationHook() {}
|
||
|
||
uint32_t ScexDeviceHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return OK; }
|
||
|
||
ReturnValue_t ScexDeviceHandler::getSwitches(const uint8_t** switches, uint8_t* numberOfSwitches) {
|
||
return OK;
|
||
}
|
||
|
||
ReturnValue_t ScexDeviceHandler::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
|
||
LocalDataPoolManager& poolManager) {
|
||
return OK;
|
||
}
|
||
|
||
std::string ScexDeviceHandler::random_string(std::string::size_type length) {
|
||
static auto& chrs =
|
||
"0123456789"
|
||
"abcdefghijklmnopqrstuvwxyz"
|
||
"ABCDEFGHIJKLMNOPQRSTUVWXYZ";
|
||
|
||
thread_local static std::mt19937 rg{std::random_device{}()};
|
||
thread_local static std::uniform_int_distribution<std::string::size_type> pick(0,
|
||
sizeof(chrs) - 2);
|
||
|
||
std::string s;
|
||
|
||
s.reserve(length);
|
||
|
||
while (length--) s += chrs[pick(rg)];
|
||
|
||
return s;
|
||
}
|
||
|
||
void ScexDeviceHandler::modeChanged() {}
|