comntinued scex handler

bsp_linux_board/InitMission.cpp

@@ -81,37 +81,31 @@ void initmission::initTasks() {
 #if OBSW_ADD_SCEX == 1
   PeriodicTaskIF* scexDevHandler = factory->createPeriodicTask(
       "SCEX_DEV", 35, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 0.5, missedDeadlineFunc);
-  result = tmtcPollingTask->addComponent(objects::SCEX, DeviceHandlerIF::PERFORM_OPERATION);
+  result = scexDevHandler->addComponent(objects::SCEX, DeviceHandlerIF::PERFORM_OPERATION);
   if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("SCEX_DEV", objects::SCEX);
   }
-  result = tmtcPollingTask->addComponent(objects::SCEX, DeviceHandlerIF::SEND_WRITE);
+  result = scexDevHandler->addComponent(objects::SCEX, DeviceHandlerIF::SEND_WRITE);
   if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("SCEX_DEV", objects::SCEX);
   }
-  result = tmtcPollingTask->addComponent(objects::SCEX, DeviceHandlerIF::GET_WRITE);
+  result = scexDevHandler->addComponent(objects::SCEX, DeviceHandlerIF::GET_WRITE);
   if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("SCEX_DEV", objects::SCEX);
   }
-  result = tmtcPollingTask->addComponent(objects::SCEX, DeviceHandlerIF::SEND_READ);
+  result = scexDevHandler->addComponent(objects::SCEX, DeviceHandlerIF::SEND_READ);
   if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("SCEX_DEV", objects::SCEX);
   }
-  result = tmtcPollingTask->addComponent(objects::SCEX, DeviceHandlerIF::GET_READ);
+  result = scexDevHandler->addComponent(objects::SCEX, DeviceHandlerIF::GET_READ);
-#endif
 
-#if OBSW_ADD_SCEX_READER == 1
   result = HasReturnvaluesIF::RETURN_OK;
-    PeriodicTaskIF* scexReaderTask = factory->createPeriodicTask(
+  PeriodicTaskIF* scexReaderTask = factory->createPeriodicTask(
-        "SCEX_UART_READER", 20, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
+      "SCEX_UART_READER", 20, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
-    result = scexReaderTask->addComponent(objects::SCEX_UART_READER);
+  result = scexReaderTask->addComponent(objects::SCEX_UART_READER);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
-      initmission::printAddObjectError("SCEX_UART_READER", objects::SCEX_UART_READER);
+    initmission::printAddObjectError("SCEX_UART_READER", objects::SCEX_UART_READER);
-    }
+  }
-    sif::info << "Starting tasks.." << std::endl;
-     tmTcDistributor->startTask();
-     tmtcBridgeTask->startTask();
-     tmtcPollingTask->startTask();
 #endif
 
   /* PUS Services */
@@ -148,6 +142,7 @@ void initmission::initTasks() {
 
 #if OBSW_ADD_SCEX == 1
   scexDevHandler->startTask();
+  scexReaderTask->startTask();
 #endif
 #if OBSW_ADD_TEST_PST == 1
   if (startTestPst) {
@@ -235,9 +230,12 @@ void initmission::createPstTasks(TaskFactory& factory,
       "SPI_PST", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 1.0, missedDeadlineFunc);
   result = pst::pstSpi(spiPst);
   if (result != HasReturnvaluesIF::RETURN_OK) {
-    sif::error << "InitMission::initTasks: Creating PST failed!" << std::endl;
+    if (result != FixedTimeslotTaskIF::SLOT_LIST_EMPTY) {
+      sif::error << "InitMission::initTasks: Creating PST failed!" << std::endl;
+    }
+  } else {
+    taskVec.push_back(spiPst);
   }
-  taskVec.push_back(spiPst);
 #endif
 }
 

common/config/devConf.h

@@ -55,6 +55,7 @@ namespace uart {
 
 static constexpr size_t HYPERION_GPS_REPLY_MAX_BUFFER = 1024;
 static constexpr UartBaudRate SYRLINKS_BAUD = UartBaudRate::RATE_38400;
+static constexpr UartBaudRate SCEX_BAUD = UartBaudRate::RATE_57600;
 static constexpr UartBaudRate GNSS_BAUD = UartBaudRate::RATE_9600;
 static constexpr UartBaudRate PLOC_MPSOC_BAUD = UartBaudRate::RATE_115200;
 static constexpr UartBaudRate PLOC_SUPV_BAUD = UartBaudRate::RATE_115200;

fsfw

@@ -1 +1 @@
-Subproject commit ebbe08639caae43667829d2cc2bcbdf91260e175
+Subproject commit 1910a7838c712f1cf34031d2a8b53e2f7cd24f66

linux/ObjectFactory.cpp

@@ -6,6 +6,7 @@
 #include <fsfw_hal/common/gpio/gpioDefinitions.h>
 #include <fsfw_hal/linux/spi/SpiComIF.h>
 #include <fsfw_hal/linux/spi/SpiCookie.h>
+#include <fsfw_hal/linux/uart/UartCookie.h>
 #include <linux/callbacks/gpioCallbacks.h>
 #include <linux/devices/Max31865RtdLowlevelHandler.h>
 #include <mission/devices/Max31865EiveHandler.h>
@@ -323,10 +324,11 @@ void ObjectFactory::createRtdComponents(std::string spiDev, GpioIF* gpioComIF,
 void ObjectFactory::createScexComponents(std::string uartDev, PowerSwitchIF* pwrSwitcher) {
   // objekte anlegen
   SdCardMountedIF* sdcMan = nullptr;
-  CookieIF* cookie = new CookieIF;
+  auto* cookie = new UartCookie(objects::SCEX, uartDev, uart::SCEX_BAUD, 4096);
 
   auto scexUartReader = new ScexUartReader(objects::SCEX_UART_READER);
-  new ScexDeviceHandler(objects::SCEX, *scexUartReader, cookie, sdcMan);
+  auto scexHandler = new ScexDeviceHandler(objects::SCEX, *scexUartReader, cookie, sdcMan);
+  scexHandler->setStartUpImmediately();
 }
 
 void ObjectFactory::gpioChecker(ReturnValue_t result, std::string output) {

linux/devices/ScexDleParser.h

@@ -1,5 +1,4 @@
-#ifndef LINUX_DEVICES_SCEXDLEPARSER_H_
+#pragma once
-#define LINUX_DEVICES_SCEXDLEPARSER_H_
 
 #include <fsfw/globalfunctions/DleParser.h>
 
@@ -16,5 +15,3 @@ class ScexDleParser : public DleParser {
 
  private:
 };
-
-#endif /* LINUX_DEVICES_SCEXDLEPARSER_H_ */

linux/devices/ScexUartReader.cpp

@@ -7,7 +7,6 @@
 #include <fsfw/tasks/SemaphoreFactory.h>
 #include <fsfw/tasks/TaskFactory.h>
 #include <fsfw_hal/linux/uart/UartCookie.h>
-#include <linux/devices/ScexDleParser.h>
 #include <unistd.h>  // write(), read(), close()
 
 #include <cerrno>  // Error integer and strerror() function
@@ -21,7 +20,7 @@ ScexUartReader::ScexUartReader(object_id_t objectId)
       ipcRingBuf(200 * 2048, true),
       ipcQueue(200),
       dleParser(decodeRingBuf, dleEncoder, {encodedBuf.data(), encodedBuf.size()},
-                {decodedBuf.data(), decodedBuf.size()}, &foundDlePacketHandler, this) {
+                {decodedBuf.data(), decodedBuf.size()}, &foundDlePacketHandler, (void *)this) {
   semaphore = SemaphoreFactory::instance()->createBinarySemaphore();
   semaphore->acquire();
   lock = MutexFactory::instance()->createMutex();
@@ -80,8 +79,8 @@ ReturnValue_t ScexUartReader::initializeInterface(CookieIF *cookie) {
   /* Get file descriptor */
   serialPort = open(devname.c_str(), O_RDWR);
   if (serialPort < 0) {
-    sif::warning << "open call failed with error [" << errno << ", " << strerror(errno)
+    sif::warning << "ScexUartReader::initializeInterface: open call failed with error [" << errno
-                 << std::endl;
+                 << ", " << strerror(errno) << std::endl;
     return HasReturnvaluesIF::RETURN_FAILED;
   }
   // Setting up UART parameters
@@ -107,8 +106,8 @@ ReturnValue_t ScexUartReader::initializeInterface(CookieIF *cookie) {
 #endif
 
   if (tcsetattr(serialPort, TCSANOW, &tty) != 0) {
-    sif::warning << "tcsetattr call failed with error [" << errno << ", " << strerror(errno)
+    sif::warning << "ScexUartReader::initializeInterface: tcsetattr call failed with error ["
-                 << std::endl;
+                 << errno << ", " << strerror(errno) << std::endl;
   }
   // Flush received and unread data
   tcflush(serialPort, TCIOFLUSH);
@@ -117,6 +116,9 @@ ReturnValue_t ScexUartReader::initializeInterface(CookieIF *cookie) {
 
 ReturnValue_t ScexUartReader::sendMessage(CookieIF *cookie, const uint8_t *sendData,
                                           size_t sendLen) {
+  if (sendData == nullptr or sendLen == 0) {
+    return HasReturnvaluesIF::RETURN_FAILED;
+  }
   lock->lockMutex();
   if (state == States::NOT_READY or state == States::RUNNING) {
     lock->unlockMutex();
@@ -128,17 +130,18 @@ ReturnValue_t ScexUartReader::sendMessage(CookieIF *cookie, const uint8_t *sendD
   ReturnValue_t result =
       dleEncoder.encode(sendData, sendLen, cmdbuf.data(), cmdbuf.size(), &encodedLen, true);
   if (result != HasReturnvaluesIF::RETURN_OK) {
-    sif::warning << "UartTestClass::scexInit: Encoding failed" << std::endl;
+    sif::warning << "ScexUartReader::sendMessage: Encoding failed" << std::endl;
     return RETURN_FAILED;
   }
   size_t bytesWritten = write(serialPort, cmdbuf.data(), encodedLen);
   if (bytesWritten != encodedLen) {
-    sif::warning << "Sending ping command to solar experiment failed" << std::endl;
+    sif::warning << "ScexUartReader::sendMessage: Sending ping command to solar experiment failed"
+                 << std::endl;
     return RETURN_FAILED;
   }
   result = semaphore->release();
   if (result != HasReturnvaluesIF::RETURN_OK) {
-    std::cout << "ScexUartReader::sendMessag: Releasing semaphore failed" << std::endl;
+    std::cout << "ScexUartReader::sendMessage: Releasing semaphore failed" << std::endl;
   }
   return RETURN_OK;
 }
@@ -160,12 +163,12 @@ ReturnValue_t ScexUartReader::finish() {
   return RETURN_OK;
 }
 
-void ScexUartReader::foundDlePacketHandler(const DleParser::Context &ctx) {
+void ScexUartReader::foundDlePacketHandler(const ScexDleParser::Context &ctx) {
   ScexUartReader *obj = reinterpret_cast<ScexUartReader *>(ctx.userArgs);
-  if (ctx.getType() == DleParser::ContextType::PACKET_FOUND) {
+  if (ctx.getType() == ScexDleParser::ContextType::PACKET_FOUND) {
     obj->handleFoundDlePacket(ctx.decodedPacket.first, ctx.decodedPacket.second);
   } else {
-	  DleParser::defaultErrorHandler(ctx.error.first, ctx.error.second);
+    ScexDleParser::defaultErrorHandler(ctx.error.first, ctx.error.second);
   }
 }
 
@@ -175,11 +178,11 @@ void ScexUartReader::handleFoundDlePacket(uint8_t *packet, size_t len) {
   MutexGuard mg(lock);
   ReturnValue_t result = ipcQueue.insert(len);
   if (result != RETURN_OK) {
-    sif::warning << "IPCQueue error" << std::endl;
+    sif::warning << "ScexUartReader::handleFoundDlePacket: IPCQueue error" << std::endl;
   }
   result = ipcRingBuf.writeData(packet, len);
   if (result != RETURN_OK) {
-    sif::warning << "IPCRingBuf error" << std::endl;
+    sif::warning << "ScexUartReader::handleFoundDlePacket: IPCRingBuf error" << std::endl;
   }
   // sif::info << "DLE handler done" << std::endl;
 }

linux/devices/ScexUartReader.h

@@ -1,5 +1,4 @@
-#ifndef LINUX_DEVICES_SCEXUARTREADER_H_
+#pragma once
-#define LINUX_DEVICES_SCEXUARTREADER_H_
 
 #include <fsfw/container/DynamicFIFO.h>
 #include <fsfw/container/SimpleRingBuffer.h>
@@ -58,5 +57,3 @@ class ScexUartReader : public SystemObject,  // strg+shift+n
   ReturnValue_t requestReceiveMessage(CookieIF *cookie, size_t requestLen) override;
   ReturnValue_t readReceivedMessage(CookieIF *cookie, uint8_t **buffer, size_t *size) override;
 };
-
-#endif /* LINUX_DEVICES_SCEXUARTREADER_H_ */

mission/devices/CMakeLists.txt

@@ -21,3 +21,5 @@ target_sources(
           PayloadPcduHandler.cpp
           SolarArrayDeploymentHandler.cpp
           ScexDeviceHandler.cpp)
+
+add_subdirectory(devicedefinitions)

mission/devices/ScexDeviceHandler.cpp

@@ -14,7 +14,7 @@ using std::ofstream;
 
 ScexDeviceHandler::ScexDeviceHandler(object_id_t objectId, ScexUartReader& reader, CookieIF* cookie,
                                      SdCardMountedIF* sdcMan)
-    : DeviceHandlerBase(objectId, reader.getObjectId(), cookie), reader(reader), sdcMan(sdcMan) {}
+    : DeviceHandlerBase(objectId, reader.getObjectId(), cookie), sdcMan(sdcMan), reader(reader) {}
 
 ScexDeviceHandler::~ScexDeviceHandler() {}
 
@@ -42,48 +42,52 @@ ReturnValue_t ScexDeviceHandler::buildCommandFromCommand(DeviceCommandId_t devic
   if (std::find(VALID_CMDS.begin(), VALID_CMDS.end(), deviceCommand) == VALID_CMDS.end()) {
     return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
   }
-  if (commandDataLen < 1) {
+  bool tempCheck = false;
-    return DeviceHandlerIF::INVALID_COMMAND_PARAMETER;
+  if (commandDataLen == 1) {
+    tempCheck = commandData[0];
   }
 
   switch (deviceCommand) {
     case (PING): {
-      // rawPacket = cmdBuf.data();
+      prepareScexCmd(cmdTyped, {cmdBuf.data(), cmdBuf.size()}, rawPacketLen, {nullptr, 0},
-      prepareScexCmd(cmdTyped, commandData[0], {cmdBuf.data(), cmdBuf.size()}, rawPacketLen,
+                     tempCheck);
-                     {nullptr, 0});
+      break;
-      return RETURN_OK;
     }
     case (EXP_STATUS_CMD): {
-      prepareScexCmd(cmdTyped, commandData[0], {cmdBuf.data(), cmdBuf.size()}, rawPacketLen,
+      prepareScexCmd(cmdTyped, {cmdBuf.data(), cmdBuf.size()}, rawPacketLen, {nullptr, 0},
-                     {nullptr, 0});
+                     tempCheck);
-      return RETURN_OK;
+      break;
     }
     case (ION_CMD): {
-      prepareScexCmd(cmdTyped, commandData[0], {cmdBuf.data(), cmdBuf.size()}, rawPacketLen,
+      prepareScexCmd(cmdTyped, {cmdBuf.data(), cmdBuf.size()}, rawPacketLen, {nullptr, 0},
-                     {nullptr, 0});
+                     tempCheck);
-      return RETURN_OK;
+      break;
     }
     case (TEMP_CMD): {
-      prepareScexCmd(cmdTyped, commandData[0], {cmdBuf.data(), cmdBuf.size()}, rawPacketLen,
+      prepareScexCmd(cmdTyped, {cmdBuf.data(), cmdBuf.size()}, rawPacketLen, {nullptr, 0},
-                     {nullptr, 0});
+                     tempCheck);
-      return RETURN_OK;
+      break;
     }
     case (FRAM): {
-      prepareScexCmd(cmdTyped, commandData[0], {cmdBuf.data(), cmdBuf.size()}, rawPacketLen,
+      prepareScexCmd(cmdTyped, {cmdBuf.data(), cmdBuf.size()}, rawPacketLen,
-                     {commandData + 1, commandDataLen - 1});
+                     {commandData + 1, commandDataLen - 1}, tempCheck);
-      return RETURN_OK;
+      break;
     }
     case (ONE_CELL): {
-      prepareScexCmd(cmdTyped, commandData[0], {cmdBuf.data(), cmdBuf.size()}, rawPacketLen,
+      prepareScexCmd(cmdTyped, {cmdBuf.data(), cmdBuf.size()}, rawPacketLen,
-                     {commandData + 1, commandDataLen - 1});
+                     {commandData + 1, commandDataLen - 1}, tempCheck);
-      return RETURN_OK;
+      break;
     }
     case (ALL_CELLS_CMD): {
-      prepareScexCmd(cmdTyped, commandData[0], {cmdBuf.data(), cmdBuf.size()}, rawPacketLen,
+      prepareScexCmd(cmdTyped, {cmdBuf.data(), cmdBuf.size()}, rawPacketLen,
-                     {commandData + 1, commandDataLen - 1});
+                     {commandData + 1, commandDataLen - 1}, tempCheck);
-      return RETURN_OK;
+      break;
+    }
+    default: {
+      return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
     }
   }
+  rawPacket = cmdBuf.data();
   return RETURN_OK;
 }
 

mission/devices/ScexDeviceHandler.h

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

mission/devices/devicedefinitions/ScexDefinitions.cpp

@@ -8,8 +8,8 @@ uint8_t scex::createCmdByte(Cmds cmd, bool tempCheck) {
   return (IDLE_BIT_0_DEF_STATE << 7) | (IDLE_BIT_1_DEF_STATE << 6) | (cmd << 1) | tempCheck;
 }
 
-ReturnValue_t scex::prepareScexCmd(Cmds cmd, bool tempCheck, std::pair<uint8_t*, size_t> cmdBufPair,
+ReturnValue_t scex::prepareScexCmd(Cmds cmd, std::pair<uint8_t*, size_t> cmdBufPair, size_t& cmdLen,
-                                   size_t& cmdLen, std::pair<const uint8_t*, size_t> usrDataPair) {
+                                   std::pair<const uint8_t*, size_t> usrDataPair, bool tempCheck) {
   using namespace scex;
   uint8_t* cmdBuf = cmdBufPair.first;
   const uint8_t* userData = usrDataPair.first;

mission/devices/devicedefinitions/ScexDefinitions.h

@@ -38,10 +38,10 @@ static constexpr uint8_t CRC_LEN = 2;
 static constexpr uint8_t IDLE_BIT_0_DEF_STATE = 0;
 static constexpr uint8_t IDLE_BIT_1_DEF_STATE = 1;
 
-uint8_t createCmdByte(Cmds cmd, bool tempCheck);
+uint8_t createCmdByte(Cmds cmd, bool tempCheck = false);
 
-ReturnValue_t prepareScexCmd(Cmds cmd, bool tempCheck, std::pair<uint8_t*, size_t> cmdBufPair,
+ReturnValue_t prepareScexCmd(Cmds cmd, std::pair<uint8_t*, size_t> cmdBufPair, size_t& cmdLen,
-                             size_t& cmdLen, std::pair<const uint8_t*, size_t> usrDataPair);
+                             std::pair<const uint8_t*, size_t> usrDataPair, bool tempCheck = false);
 
 }  // namespace scex
 

scripts/rpi-port.sh

@@ -1,8 +1,10 @@
 #!/bin/bash
 echo "-L 1538:raspberrypi.local:1538 for Raspberry Pi connect with TCF agent"
 echo "-L 1539:raspberrypi.local:22 for Raspberry Pi file transfers"
+echo "-L 7301:raspberrypi.local:7301 for Raspberry Pi TMTC Commands"
 
 ssh -L 1538:raspberrypi.local:1534 \
    -L 1539:raspberrypi.local:22 \
-    eive@2001:7c0:2018:1099:babe:0:e1fe:f1a5 \
+   -L 7301:raspberrypi.local:7301 \
+   eive@2001:7c0:2018:1099:babe:0:e1fe:f1a5 \
     -t 'CONSOLE_PREFIX="[RPi Tunnel]" /bin/bash'

tmtc

@@ -1 +1 @@
-Subproject commit ef349856d614be7a408ffadf0c27c677d8be3157
+Subproject commit 7012a6c41f6e211c060f583c21061fe7ca3f4c45