bsp_q7s/core/ObjectFactory.cpp

@@ -160,7 +160,9 @@ void ObjectFactory::produce(void* args) {
 #if OBSW_ADD_MGT == 1
   I2cCookie* imtqI2cCookie =
       new I2cCookie(addresses::IMTQ, IMTQ::MAX_REPLY_SIZE, q7s::I2C_DEFAULT_DEV);
-  auto imtqHandler = new IMTQHandler(objects::IMTQ_HANDLER, objects::I2C_COM_IF, imtqI2cCookie);
+  auto imtqHandler = new IMTQHandler(objects::IMTQ_HANDLER, objects::I2C_COM_IF, imtqI2cCookie,
+                                     pcdu::Switches::PDU1_CH3_MGT_5V);
+  imtqHandler->setPowerSwitcher(pwrSwitcher);
   static_cast<void>(imtqHandler);
 #if OBSW_DEBUG_IMTQ == 1
   imtqHandler->setStartUpImmediately();
@@ -187,12 +189,14 @@ void ObjectFactory::produce(void* args) {
 
 #if OBSW_ADD_STAR_TRACKER == 1
   UartCookie* starTrackerCookie =
-      new UartCookie(objects::STAR_TRACKER, q7s::UART_STAR_TRACKER_DEV, UartModes::NON_CANONICAL,
+      new UartCookie(objects::STAR_TRACKER, q7s::UART_STAR_TRACKER_DEV, uart::STAR_TRACKER_BAUD,
-                     uart::STAR_TRACKER_BAUD, startracker::MAX_FRAME_SIZE * 2 + 2);
+                     startracker::MAX_FRAME_SIZE * 2 + 2, UartModes::NON_CANONICAL);
   starTrackerCookie->setNoFixedSizeReply();
   StrHelper* strHelper = new StrHelper(objects::STR_HELPER);
-  new StarTrackerHandler(objects::STAR_TRACKER, objects::UART_COM_IF, starTrackerCookie, strHelper,
+  auto starTracker =
-                         pcdu::PDU1_CH2_STAR_TRACKER_5V);
+      new StarTrackerHandler(objects::STAR_TRACKER, objects::UART_COM_IF, starTrackerCookie,
+                             strHelper, pcdu::PDU1_CH2_STAR_TRACKER_5V);
+  starTracker->setPowerSwitcher(pwrSwitcher);
 
 #endif /* OBSW_ADD_STAR_TRACKER == 1 */
 
@@ -625,14 +629,15 @@ void ObjectFactory::createSolarArrayDeploymentComponents() {
                                   gpioIds::DEPLSA1, gpioIds::DEPLSA2, 1000);
 }
 
-void ObjectFactory::createSyrlinksComponents() {
+void ObjectFactory::createSyrlinksComponents(PowerSwitchIF* pwrSwitcher) {
   UartCookie* syrlinksUartCookie =
-      new UartCookie(objects::SYRLINKS_HK_HANDLER, q7s::UART_SYRLINKS_DEV, UartModes::NON_CANONICAL,
+      new UartCookie(objects::SYRLINKS_HK_HANDLER, q7s::UART_SYRLINKS_DEV, uart::SYRLINKS_BAUD,
-                     uart::SYRLINKS_BAUD, syrlinks::MAX_REPLY_SIZE);
+                     syrlinks::MAX_REPLY_SIZE, UartModes::NON_CANONICAL);
   syrlinksUartCookie->setParityEven();
 
-  new SyrlinksHkHandler(objects::SYRLINKS_HK_HANDLER, objects::UART_COM_IF, syrlinksUartCookie,
+  auto syrlinksHandler = new SyrlinksHkHandler(objects::SYRLINKS_HK_HANDLER, objects::UART_COM_IF,
-                        pcdu::PDU1_CH1_SYRLINKS_12V);
+                                               syrlinksUartCookie, pcdu::PDU1_CH1_SYRLINKS_12V);
+  syrlinksHandler->setPowerSwitcher(pwrSwitcher);
 }
 
 void ObjectFactory::createPayloadComponents(LinuxLibgpioIF* gpioComIF) {
@@ -646,8 +651,8 @@ void ObjectFactory::createPayloadComponents(LinuxLibgpioIF* gpioComIF) {
   mpsocGpioCookie->addGpio(gpioIds::ENABLE_MPSOC_UART, gpioConfigMPSoC);
   gpioComIF->addGpios(mpsocGpioCookie);
   auto mpsocCookie =
-      new UartCookie(objects::PLOC_MPSOC_HANDLER, q7s::UART_PLOC_MPSOC_DEV,
+      new UartCookie(objects::PLOC_MPSOC_HANDLER, q7s::UART_PLOC_MPSOC_DEV, uart::PLOC_MPSOC_BAUD,
-                     UartModes::NON_CANONICAL, uart::PLOC_MPSOC_BAUD, mpsoc::MAX_REPLY_SIZE);
+                     mpsoc::MAX_REPLY_SIZE, UartModes::NON_CANONICAL);
   mpsocCookie->setNoFixedSizeReply();
   auto plocMpsocHelper = new PlocMPSoCHelper(objects::PLOC_MPSOC_HELPER);
   new PlocMPSoCHandler(objects::PLOC_MPSOC_HANDLER, objects::UART_COM_IF, mpsocCookie,
@@ -663,8 +668,8 @@ void ObjectFactory::createPayloadComponents(LinuxLibgpioIF* gpioComIF) {
   supvGpioCookie->addGpio(gpioIds::ENABLE_SUPV_UART, gpioConfigSupv);
   gpioComIF->addGpios(supvGpioCookie);
   auto supervisorCookie = new UartCookie(objects::PLOC_SUPERVISOR_HANDLER,
-                                         q7s::UART_PLOC_SUPERVSIOR_DEV, UartModes::NON_CANONICAL,
+                                         q7s::UART_PLOC_SUPERVSIOR_DEV, uart::PLOC_SUPERVISOR_BAUD,
-                                         uart::PLOC_SUPERVISOR_BAUD, supv::MAX_PACKET_SIZE * 20);
+                                         supv::MAX_PACKET_SIZE * 20, UartModes::NON_CANONICAL);
   supervisorCookie->setNoFixedSizeReply();
   new PlocSupervisorHandler(objects::PLOC_SUPERVISOR_HANDLER, objects::UART_COM_IF,
                             supervisorCookie, Gpio(gpioIds::ENABLE_SUPV_UART, gpioComIF),

bsp_q7s/core/ObjectFactory.h

@@ -24,7 +24,7 @@ void createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComIF* uartComIF,
                               PowerSwitchIF* pwrSwitcher);
 void createHeaterComponents();
 void createSolarArrayDeploymentComponents();
-void createSyrlinksComponents();
+void createSyrlinksComponents(PowerSwitchIF* pwrSwitcher);
 void createPayloadComponents(LinuxLibgpioIF* gpioComIF);
 void createReactionWheelComponents(LinuxLibgpioIF* gpioComIF);
 void createCcsdsComponents(LinuxLibgpioIF* gpioComIF);

linux/boardtest/UartTestClass.cpp

@@ -21,17 +21,17 @@
 #endif
 
 UartTestClass::UartTestClass(object_id_t objectId, ScexUartReader* reader)
-: TestTask(objectId), reader(reader) {
+    : TestTask(objectId), reader(reader) {
   mode = TestModes::SCEX;
-	scexMode = ScexModes::SIMPLE;
+  scexMode = ScexModes::READER_TASK;
-	currCmd = scex::ScexCmds::FRAM;
+  currCmd = scex::ScexCmds::PING;
   if (scexMode == ScexModes::SIMPLE) {
     auto encodingBuf = new std::array<uint8_t, 4096>;
-		DleParser::BufPair encodingBufPair  {encodingBuf->data(), encodingBuf->size()};
+    DleParser::BufPair encodingBufPair{encodingBuf->data(), encodingBuf->size()};
     auto decodedBuf = new std::array<uint8_t, 4096>;
-		DleParser::BufPair decodingBufPair  {decodedBuf->data(), decodedBuf->size()};
+    DleParser::BufPair decodingBufPair{decodedBuf->data(), decodedBuf->size()};
-		dleParser =
+    dleParser = new ScexDleParser(*(new SimpleRingBuffer(4096, true)), dleEncoder, encodingBufPair,
-				new ScexDleParser(*(new SimpleRingBuffer(4096, true)), dleEncoder, encodingBufPair, decodingBufPair, &foundDlePacketHandler, this);
+                                  decodingBufPair, &foundDlePacketHandler, this);
   }
 }
 
@@ -174,53 +174,55 @@ void UartTestClass::scexPeriodic() {
   if (scexMode == ScexModes::SIMPLE) {
     scexSimplePeriodic();
   } else {
-		if (not cmdSent){
+    if (not cmdSent) {
       size_t len = 0;
       prepareScexCmd(scex::ScexCmds::PING, false, cmdBuf.data(), &len);
       reader->sendMessage(uartCookie, cmdBuf.data(), len);
       cmdSent = true;
       cmdDone = false;
     }
-		if (cmdSent and not cmdDone){
+    if (cmdSent and not cmdDone) {
       uint8_t* decodedPacket = nullptr;
       size_t len = 0;
       ReturnValue_t result = reader->readReceivedMessage(uartCookie, &decodedPacket, &len);
 
-			if(len > 0){
+      if (len > 0) {
-				sif::info<<"CmdByte: "<<(int)decodedPacket[0]<<endl;
+        sif::info << "CmdByte: " << std::setw(2) << std::setfill('0') << std::hex
+                  << (int)decodedPacket[0] << std::dec << endl;
         scex::ScexCmds cmd = static_cast<scex::ScexCmds>((decodedPacket[0] >> 1) & 0b11111);
+        sif::info << "Command: 0x" << std::setw(2) << std::setfill('0') << std::hex
+                  << static_cast<int>(cmd) << std::dec << std::endl;
         size_t packetCounter = decodedPacket[1];
-				sif::info<<"PacketCounter: "<<packetCounter<<endl;
+        sif::info << "PacketCounter: " << packetCounter << endl;
         size_t totalPacketCounter = decodedPacket[2];
-				sif::info<<"TotalPacketCount: "<<totalPacketCounter<<endl;
+        sif::info << "TotalPacketCount: " << totalPacketCounter << endl;
-				uint16_t packetLen = (decodedPacket[3]<< 8) | (decodedPacket[4]);
+        uint16_t packetLen = (decodedPacket[3] << 8) | (decodedPacket[4]);
-				sif::info<<"PacketLength: "<< packetLen <<endl;
+        sif::info << "PacketLength: " << packetLen << endl;
         uint16_t expectedPacketLen = packetLen + 7;
 
-				sif::info<<"ExpectedPacketLength: "<< packetLen+7 <<endl;
+        sif::info << "ExpectedPacketLength: " << packetLen + 7 << endl;
-				if(expectedPacketLen != len){
+        if (expectedPacketLen != len) {
-					sif::warning<<"ExpectedPacketLength "  << expectedPacketLen <<" is not Length"<< len<<endl;
+          sif::warning << "ExpectedPacketLength " << expectedPacketLen << " is not Length" << len
-
+                       << endl;
         }
-				if(CRC::crc16ccitt(decodedPacket, expectedPacketLen) != 0){
+        if (CRC::crc16ccitt(decodedPacket, expectedPacketLen) != 0) {
-					sif::warning<<"CRC invalid"<<endl;
+          sif::warning << "CRC invalid" << endl;
-				}else{
+        } else {
-					sif::info<<"CRC valid"<<endl;
+          sif::info << "CRC valid" << endl;
         }
-				if(packetCounter == totalPacketCounter){
+        if (packetCounter == totalPacketCounter) {
           reader->finish();
-					sif::info<<"Reader is finished" << endl;
+          sif::info << "Reader is finished" << endl;
           cmdDone = true;
-					if(cmd == scex::ScexCmds::PING){
+          // TODO: Bug in firmware, other command will be returned
           cmdSent = false;
+          // if (cmd == scex::ScexCmds::PING) {
+          //   cmdSent = false;
+          // }
         }
       }
-
     }
   }
-
-	}
-
 }
 
 void UartTestClass::scexSimpleInit() {
@@ -249,8 +251,8 @@ void UartTestClass::scexSimpleInit() {
 
   // Non-blocking mode, read until either line is 0.1 second idle or maximum of 255 bytes are
   // received in one go
-	tty.c_cc[VTIME] = 10;  // In units of 0.1 seconds
+  tty.c_cc[VTIME] = 0;  // In units of 0.1 seconds
-	tty.c_cc[VMIN] = 255;  // Read up to 255 bytes
+  tty.c_cc[VMIN] = 0;   // Read up to 255 bytes
 
   // Q7S UART Lite has fixed baud rate. For other linux systems, set baud rate here.
 #if !defined(XIPHOS_Q7S)

linux/devices/ScexUartReader.cpp

@@ -5,6 +5,7 @@
 #include <fsfw/ipc/MutexFactory.h>
 #include <fsfw/ipc/MutexGuard.h>
 #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()
@@ -34,16 +35,17 @@ ReturnValue_t ScexUartReader::performOperation(uint8_t operationCode) {
     semaphore->acquire();
     sif::info << "task was started" << std::endl;
     int bytesRead = 0;
-    while(true) {
+    while (true) {
       bytesRead = read(serialPort, reinterpret_cast<void *>(recBuf.data()),
                        static_cast<unsigned int>(recBuf.size()));
       if (bytesRead == 0) {
         MutexGuard mg(lock);
-        States currentState = state;
+        if (state == States::FINISH) {
-        if (currentState == States::FINISH) {
+          sif::debug << "finish detected" << std::endl;
           state = States::IDLE;
           break;
         }
+        TaskFactory::delayTask(1000);
       } else if (bytesRead < 0) {
         sif::warning << "ScexUartReader::performOperation: read call failed with error [" << errno
                      << ", " << strerror(errno) << "]" << std::endl;
@@ -63,7 +65,7 @@ ReturnValue_t ScexUartReader::performOperation(uint8_t operationCode) {
       }
     };
     // task block comes here
-    std::cout << "done" << std::endl;
+    sif::info << "task was stopped" << std::endl;
   }
   return RETURN_OK;
 }
@@ -94,8 +96,8 @@ ReturnValue_t ScexUartReader::initializeInterface(CookieIF *cookie) {
   tty.c_lflag &= ~(ICANON | ECHO);
 
   // Non-blocking mode, use polling
-  tty.c_cc[VTIME] = 10;  // Read for up to 1 seconds
+  tty.c_cc[VTIME] = 0;
-  tty.c_cc[VMIN] = 255;   // Read as much as there is available
+  tty.c_cc[VMIN] = 0;
 
   // Q7S UART Lite has fixed baud rate. For other linux systems, set baud rate here.
 #if !defined(XIPHOS_Q7S)
@@ -109,7 +111,7 @@ ReturnValue_t ScexUartReader::initializeInterface(CookieIF *cookie) {
                  << std::endl;
   }
   // Flush received and unread data
-  tcflush(serialPort, TCIFLUSH);
+  tcflush(serialPort, TCIOFLUSH);
   return RETURN_OK;
 }
 
@@ -172,12 +174,12 @@ void ScexUartReader::handleFoundDlePacket(uint8_t *packet, size_t len) {
   sif::info << "Detected DLE encoded packet with decoded size " << len << std::endl;
   MutexGuard mg(lock);
   ReturnValue_t result = ipcQueue.insert(len);
-  if(result != RETURN_OK){
+  if (result != RETURN_OK) {
-	  sif::warning<< "IPCQueue error" << std::endl;
+    sif::warning << "IPCQueue error" << std::endl;
   }
   result = ipcRingBuf.writeData(packet, len);
-  if(result != RETURN_OK){
+  if (result != RETURN_OK) {
-  	  sif::warning<< "IPCRingBuf error" << std::endl;
+    sif::warning << "IPCRingBuf error" << std::endl;
   }
   sif::info << "DLE handler done" << std::endl;
 }
@@ -189,7 +191,8 @@ ReturnValue_t ScexUartReader::readReceivedMessage(CookieIF *cookie, uint8_t **bu
     *size = 0;
     return RETURN_OK;
   }
-  *size = ipcQueue.pop();
+  sif::info << "returning data" << std::endl;
+  ipcQueue.retrieve(size);
   *buffer = ipcBuffer.data();
   ReturnValue_t result = ipcRingBuf.readData(ipcBuffer.data(), *size, true);
   if (result != RETURN_OK) {

mission/devices/IMTQHandler.cpp

@@ -7,7 +7,8 @@
 
 #include "OBSWConfig.h"
 
-IMTQHandler::IMTQHandler(object_id_t objectId, object_id_t comIF, CookieIF* comCookie)
+IMTQHandler::IMTQHandler(object_id_t objectId, object_id_t comIF, CookieIF* comCookie,
+                         power::Switch_t pwrSwitcher)
     : DeviceHandlerBase(objectId, comIF, comCookie),
       engHkDataset(this),
       calMtmMeasurementSet(this),
@@ -17,8 +18,9 @@ IMTQHandler::IMTQHandler(object_id_t objectId, object_id_t comIF, CookieIF* comC
       posYselfTestDataset(this),
       negYselfTestDataset(this),
       posZselfTestDataset(this),
-      negZselfTestDataset(this) {
+      negZselfTestDataset(this),
-  if (comCookie == NULL) {
+      switcher(pwrSwitcher) {
+  if (comCookie == nullptr) {
     sif::error << "IMTQHandler: Invalid com cookie" << std::endl;
   }
 }
@@ -118,7 +120,7 @@ ReturnValue_t IMTQHandler::buildCommandFromCommand(DeviceCommandId_t deviceComma
     case (IMTQ::START_ACTUATION_DIPOLE): {
       /* IMTQ expects low byte first */
       commandBuffer[0] = IMTQ::CC::START_ACTUATION_DIPOLE;
-      if(commandData == nullptr) {
+      if (commandData == nullptr) {
         return DeviceHandlerIF::INVALID_COMMAND_PARAMETER;
       }
       commandBuffer[1] = commandData[1];
@@ -2178,3 +2180,12 @@ std::string IMTQHandler::makeStepString(const uint8_t step) {
   }
   return stepString;
 }
+
+ReturnValue_t IMTQHandler::getSwitches(const uint8_t** switches, uint8_t* numberOfSwitches) {
+  if (switcher != power::NO_SWITCH) {
+    *numberOfSwitches = 1;
+    *switches = &switcher;
+    return RETURN_OK;
+  }
+  return DeviceHandlerBase::NO_SWITCH;
+}

mission/devices/IMTQHandler.h

@@ -12,7 +12,8 @@
  */
 class IMTQHandler : public DeviceHandlerBase {
  public:
-  IMTQHandler(object_id_t objectId, object_id_t comIF, CookieIF* comCookie);
+  IMTQHandler(object_id_t objectId, object_id_t comIF, CookieIF* comCookie,
+              power::Switch_t pwrSwitcher);
   virtual ~IMTQHandler();
 
   /**
@@ -36,6 +37,7 @@ class IMTQHandler : public DeviceHandlerBase {
   uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override;
   ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
                                         LocalDataPoolManager& poolManager) override;
+  ReturnValue_t getSwitches(const uint8_t** switches, uint8_t* numberOfSwitches) override;
 
  private:
   static const uint8_t INTERFACE_ID = CLASS_ID::IMTQ_HANDLER;
@@ -111,6 +113,7 @@ class IMTQHandler : public DeviceHandlerBase {
 
   StartupStep startupStep = StartupStep::COMMAND_SELF_TEST;
 
+  power::Switch_t switcher = power::NO_SWITCH;
   bool selfTestPerformed = false;
 
   /**

mission/system/AcsSubsystem.cpp

@@ -1 +1,5 @@
 #include "AcsSubsystem.h"
+
+AcsSubsystem::AcsSubsystem(object_id_t setObjectId, object_id_t parent,
+                           uint32_t maxNumberOfSequences, uint32_t maxNumberOfTables)
+    : Subsystem(setObjectId, parent, maxNumberOfSequences, maxNumberOfTables) {}

mission/system/AcsSubsystem.h

@@ -1,4 +1,14 @@
 #ifndef MISSION_SYSTEM_ACSSUBSYSTEM_H_
 #define MISSION_SYSTEM_ACSSUBSYSTEM_H_
 
+#include <fsfw/subsystem/Subsystem.h>
+
+class AcsSubsystem : public Subsystem {
+ public:
+  AcsSubsystem(object_id_t setObjectId, object_id_t parent, uint32_t maxNumberOfSequences,
+               uint32_t maxNumberOfTables);
+
+ private:
+};
+
 #endif /* MISSION_SYSTEM_ACSSUBSYSTEM_H_ */

mission/system/CMakeLists.txt

@@ -1,9 +1,11 @@
 target_sources(${LIB_EIVE_MISSION} PRIVATE
+    EiveSystem.cpp
+    AcsSubsystem.cpp
+    ComSubsystem.cpp
+    PayloadSubsystem.cpp
+
     AcsBoardAssembly.cpp
     SusAssembly.cpp
-    AcsSubsystem.cpp
-    EiveSystem.cpp
-    ComSubsystem.cpp
     DualLanePowerStateMachine.cpp
     PowerStateMachineBase.cpp
     DualLaneAssemblyBase.cpp

mission/system/ComSubsystem.cpp

@@ -1 +1,5 @@
 #include "ComSubsystem.h"
+
+ComSubsystem::ComSubsystem(object_id_t setObjectId, object_id_t parent,
+                           uint32_t maxNumberOfSequences, uint32_t maxNumberOfTables)
+    : Subsystem(setObjectId, parent, maxNumberOfSequences, maxNumberOfTables) {}

mission/system/ComSubsystem.h

@@ -1,4 +1,14 @@
 #ifndef MISSION_SYSTEM_COMSUBSYSTEM_H_
 #define MISSION_SYSTEM_COMSUBSYSTEM_H_
 
+#include <fsfw/subsystem/Subsystem.h>
+
+class ComSubsystem : public Subsystem {
+ public:
+  ComSubsystem(object_id_t setObjectId, object_id_t parent, uint32_t maxNumberOfSequences,
+               uint32_t maxNumberOfTables);
+
+ private:
+};
+
 #endif /* MISSION_SYSTEM_COMSUBSYSTEM_H_ */

mission/system/EiveSystem.cpp

@@ -1 +1,5 @@
 #include "EiveSystem.h"
+
+EiveSystem::EiveSystem(object_id_t setObjectId, object_id_t parent, uint32_t maxNumberOfSequences,
+                       uint32_t maxNumberOfTables)
+    : Subsystem(setObjectId, parent, maxNumberOfSequences, maxNumberOfTables) {}

mission/system/EiveSystem.h

@@ -1,4 +1,14 @@
 #ifndef MISSION_SYSTEM_EIVESYSTEM_H_
 #define MISSION_SYSTEM_EIVESYSTEM_H_
 
+#include <fsfw/subsystem/Subsystem.h>
+
+class EiveSystem : public Subsystem {
+ public:
+  EiveSystem(object_id_t setObjectId, object_id_t parent, uint32_t maxNumberOfSequences,
+             uint32_t maxNumberOfTables);
+
+ private:
+};
+
 #endif /* MISSION_SYSTEM_EIVESYSTEM_H_ */

mission/system/PayloadSubsystem.cpp

@@ -1 +1,5 @@
 #include "PayloadSubsystem.h"
+
+PayloadSubsystem::PayloadSubsystem(object_id_t setObjectId, object_id_t parent,
+                                   uint32_t maxNumberOfSequences, uint32_t maxNumberOfTables)
+    : Subsystem(setObjectId, parent, maxNumberOfSequences, maxNumberOfTables) {}

mission/system/PayloadSubsystem.h

@@ -1,4 +1,14 @@
 #ifndef MISSION_SYSTEM_PAYLOADSUBSYSTEM_H_
 #define MISSION_SYSTEM_PAYLOADSUBSYSTEM_H_
 
+#include <fsfw/subsystem/Subsystem.h>
+
+class PayloadSubsystem : public Subsystem {
+ public:
+  PayloadSubsystem(object_id_t setObjectId, object_id_t parent, uint32_t maxNumberOfSequences,
+                   uint32_t maxNumberOfTables);
+
+ private:
+};
+
 #endif /* MISSION_SYSTEM_PAYLOADSUBSYSTEM_H_ */