ScexDeviceHandler

2022-05-19 11:56:59 +02:00 · 2022-05-19 11:56:59 +02:00 · e8882b11cf
commit e8882b11cf
parent b4e1451501
4 changed files with 113 additions and 24 deletions
--- a/linux/devices/ScexHelper.cpp
+++ b/linux/devices/ScexHelper.cpp
@ -35,6 +35,7 @@ ReturnValue_t ScexHelper::deSerialize(const uint8_t** buffer, size_t* size,
  payloadLen = (**buffer << 8) | *(*buffer + 1);

  *buffer += 2;
+  payloadStart = *buffer;
  totalPacketLen = payloadLen + scex::HEADER_LEN + scex::CRC_LEN;
  if (totalPacketLen >= *size) {
    return STREAM_TOO_SHORT;
--- a/linux/devices/ScexHelper.h
+++ b/linux/devices/ScexHelper.h
@ -41,6 +41,7 @@ class ScexHelper : public HasReturnvaluesIF, public SerializeIF {
  int packetCounter = 0;
  int totalPacketCounter = 0;
  uint16_t payloadLen = 0;
+  const uint8_t *payloadStart = 0;
  size_t totalPacketLen = 0;
 };

--- a/mission/devices/ScexDeviceHandler.cpp
+++ b/mission/devices/ScexDeviceHandler.cpp
@ -1,6 +1,7 @@
 #include "ScexDeviceHandler.h"

 #include <linux/devices/ScexHelper.h>
+#include <mission/memory/SdCardMountedIF.h>

 #include <algorithm>
 #include <iostream>
@ -10,8 +11,9 @@

 using std::ofstream;

-ScexDeviceHandler::ScexDeviceHandler(object_id_t objectId, ScexUartReader& reader, CookieIF* cookie)
-    : DeviceHandlerBase(objectId, reader.getObjectId(), cookie), reader(reader) {}
+ScexDeviceHandler::ScexDeviceHandler(object_id_t objectId, ScexUartReader& reader, CookieIF* cookie,
+                                     SdCardMountedIF* sdcMan)
+    : DeviceHandlerBase(objectId, reader.getObjectId(), cookie), reader(reader), sdcMan(sdcMan) {}

 ScexDeviceHandler::~ScexDeviceHandler() {}

@ -31,11 +33,12 @@ ReturnValue_t ScexDeviceHandler::buildTransitionDeviceCommand(DeviceCommandId_t*
 }

 ReturnValue_t ScexDeviceHandler::buildCommandFromCommand(
-    scex::Cmds deviceCommand,  // DeviceCommandId_t
+    DeviceCommandId_t deviceCommand,  // DeviceCommandId_t
    const uint8_t* commandData, size_t commandDataLen) {
  using namespace scex;

-  if (not std::find(VALID_CMDS.begin(), VALID_CMDS.end(), deviceCommand) != VALID_CMDS.end()) {
+  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;
  }
  if (commandDataLen < 1) {
@ -44,39 +47,38 @@ ReturnValue_t ScexDeviceHandler::buildCommandFromCommand(

  switch (deviceCommand) {
    case (PING): {
-      rawPacket = cmdBuf.size();
-
-      prepareScexCmd(deviceCommand, commandData[0], {cmdBuf.data(), cmdBuf.size()}, rawPacketLen,
+      rawPacket = cmdBuf.data();
+      prepareScexCmd(cmdTyped, commandData[0], {cmdBuf.data(), cmdBuf.size()}, rawPacketLen,
                     {nullptr, 0});
      return RETURN_OK;
    }
    case (FRAM): {
-      prepareScexCmd(deviceCommand, commandData[0], {cmdBuf.data(), cmdBuf.size()}, rawPacketLen,
+      prepareScexCmd(cmdTyped, commandData[0], {cmdBuf.data(), cmdBuf.size()}, rawPacketLen,
                     {nullptr, 0});
      return RETURN_OK;
    }
    case (ION_CMD): {
-      prepareScexCmd(deviceCommand, commandData[0], {cmdBuf.data(), cmdBuf.size()}, rawPacketLen,
+      prepareScexCmd(cmdTyped, commandData[0], {cmdBuf.data(), cmdBuf.size()}, rawPacketLen,
                     {nullptr, 0});
      return RETURN_OK;
    }
    case (TEMP_CMD): {
-      prepareScexCmd(deviceCommand, commandData[0], {cmdBuf.data(), cmdBuf.size()}, rawPacketLen,
+      prepareScexCmd(cmdTyped, commandData[0], {cmdBuf.data(), cmdBuf.size()}, rawPacketLen,
                     {nullptr, 0});
      return RETURN_OK;
    }
    case (ONE_CELL): {
-      prepareScexCmd(deviceCommand, commandData[0], {cmdBuf.data(), cmdBuf.size()}, rawPacketLen,
-                     {commandData + 1, commandData - 1});
+      prepareScexCmd(cmdTyped, commandData[0], {cmdBuf.data(), cmdBuf.size()}, rawPacketLen,
+                     {commandData + 1, commandDataLen - 1});
      return RETURN_OK;
    }
    case (ALL_CELLS_CMD): {
-      prepareScexCmd(deviceCommand, commandData[0], {cmdBuf.data(), cmdBuf.size()}, rawPacketLen,
-                     {commandData + 1, commandData - 1});
+      prepareScexCmd(cmdTyped, commandData[0], {cmdBuf.data(), cmdBuf.size()}, rawPacketLen,
+                     {commandData + 1, commandDataLen - 1});
      return RETURN_OK;
    }
    case (EXP_STATUS_CMD): {
-      prepareScexCmd(deviceCommand, commandData[0], {cmdBuf.data(), cmdBuf.size()}, rawPacketLen,
+      prepareScexCmd(cmdTyped, commandData[0], {cmdBuf.data(), cmdBuf.size()}, rawPacketLen,
                     {nullptr, 0});
      return RETURN_OK;
    }
@ -111,9 +113,8 @@ ReturnValue_t ScexDeviceHandler::scanForReply(const uint8_t* start, size_t remai
  // crc check
  if (result == ScexHelper::INVALID_CRC) {
    sif::warning << "CRC invalid" << std::endl;
+    return result;
  }
-  sif::info << helper << std::endl;
-
  *foundId = helper.getCmd();
  *foundLen = remainingSize;

@ -123,14 +124,86 @@ ReturnValue_t ScexDeviceHandler::scanForReply(const uint8_t* start, size_t remai
 ReturnValue_t ScexDeviceHandler::interpretDeviceReply(DeviceCommandId_t id, const uint8_t* packet) {
  // cmd auswertung (in file reinschreiben)
  using namespace scex;
-  if (helper.getCmd() == PING) {
-    ofstream out("/tmp/scex-ping.bin", ofstream::binary);
+
+  auto oneFileHandler = [&](std::string cmdName) {
+    fileId = random_string(6);
+    std::ostringstream oss("/tmp/scex-");
+    oss << cmdName << fileId << ".bin";
+    fileName = oss.str();
+    ofstream out(fileName, ofstream::binary);
    if (out.bad()) {
-      sif::warning << "bad" << std::endl;
+      sif::error << "ScexDeviceHandler::interpretDeviceReply: Could not open file " << fileName
+                 << std::endl;
+      return RETURN_FAILED;
+    }
+    if (debugMode) {
+      out << helper;
+    }
+    return RETURN_OK;
+  };
+  auto multiFileHandler = [&](std::string cmdName) {
+    if (helper.getPacketCounter() == 1) {
+      // countdown starten
+      finishCountdown.resetTimer();
+      fileId = random_string(6);
+      std::ostringstream oss("/tmp/scex-");
+      oss << cmdName << fileId << ".bin";
+      fileName = oss.str();
+      ofstream out(fileName,
+                   ofstream::binary);  // neues file anlegen
+    } else {
+      ofstream out(fileName,
+                   ofstream::binary | ofstream::app);  // an bestehendes file appenden
+      if (debugMode) {
+        out << helper;
+      }
+    }
+    if (finishCountdown.hasTimedOut()) {
+      triggerEvent(scex::EXPERIMENT_TIMEDOUT, id, 0);
+      reader.finish();
+      sif::warning << "ScexDeviceHandler: Reader timeout" << std::endl;
+      // cmdDone = true;
+      fileNameSet = false;
+    }
+    return RETURN_OK;
+  };
+  switch (id) {
+    case (PING): {
+      return oneFileHandler("ping_");
+    }
+    case (ION_CMD): {
+      return oneFileHandler("ion_");
+    }
+    case (TEMP_CMD): {
+      return oneFileHandler("temp_");
+    }
+    case (EXP_STATUS_CMD): {
+      return oneFileHandler("exp_status_");
+    }
+    case (FRAM): {
+      return multiFileHandler("fram_");
+    }
+    case (ONE_CELL): {
+      return multiFileHandler("one_cell_");
+    }
+    case (ALL_CELLS_CMD): {
+      return multiFileHandler("all_cell_");
+    }
+    default:
+      // Unknown DeviceCommand
+      return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
+  }
+
+  if (helper.getPacketCounter() == helper.getTotalPacketCounter()) {
+    reader.finish();
+    sif::info << "Reader is finished" << std::endl;
+    // cmdDone = true;
+    fileNameSet = false;
+    if (helper.getCmd() == scex::Cmds::PING) {
+      // cmdSent = false;
+      fileNameSet = true;  // to not generate everytime new file
    }
-    out << helper;
  }
-  // was alles hier rein?
  return RETURN_OK;
 }

--- a/mission/devices/ScexDeviceHandler.h
+++ b/mission/devices/ScexDeviceHandler.h
@ -5,15 +5,29 @@
 #include <linux/devices/ScexHelper.h>
 #include <linux/devices/ScexUartReader.h>

+class SdCardMountedIF;
+
 class ScexDeviceHandler : public DeviceHandlerBase {
 public:
  // ctor vervollständigen
-  ScexDeviceHandler(object_id_t objectId, ScexUartReader &reader, CookieIF *cookie);
+  ScexDeviceHandler(object_id_t objectId, ScexUartReader &reader, CookieIF *cookie,
+                    SdCardMountedIF *sdcMan);
  virtual ~ScexDeviceHandler();

 private:
  std::array<uint8_t, 64> cmdBuf = {};

+  std::string fileId = "";
+  std::string fileName = "";
+  bool fileNameSet = false;
+  bool debugMode = true;
+
+  scex::Cmds currCmd = scex::Cmds::PING;
+  SdCardMountedIF *sdcMan = nullptr;
+  Countdown finishCountdown = Countdown(180 * 1000);
+
+  std::string random_string(std::string::size_type length);
+
  // DeviceHandlerBase private function implementation
  void doStartUp() override;
  void doShutDown() override;
@ -21,7 +35,7 @@ class ScexDeviceHandler : public DeviceHandlerBase {
  ScexUartReader &reader;
  ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t *id) override;
  ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t *id) override;
-  ReturnValue_t buildCommandFromCommand(scex::Cmds deviceCommand, const uint8_t *commandData,
+  ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand, const uint8_t *commandData,
                                        size_t commandDataLen) override;
  void fillCommandAndReplyMap() override;
  ReturnValue_t scanForReply(const uint8_t *start, size_t remainingSize, DeviceCommandId_t *foundId,