some sort of filter handling

bsp_q7s/core/ObjectFactory.cpp

@@ -574,7 +574,7 @@ void ObjectFactory::createSolarArrayDeploymentComponents(PowerSwitchIF& pwrSwitc
 void ObjectFactory::createSyrlinksComponents(PowerSwitchIF* pwrSwitcher) {
   auto* syrlinksUartCookie =
       new SerialCookie(objects::SYRLINKS_HK_HANDLER, q7s::UART_SYRLINKS_DEV, uart::SYRLINKS_BAUD,
-                     syrlinks::MAX_REPLY_SIZE, UartModes::NON_CANONICAL);
+                       syrlinks::MAX_REPLY_SIZE, UartModes::NON_CANONICAL);
   syrlinksUartCookie->setParityEven();
 
   auto syrlinksFdir = new SyrlinksFdir(objects::SYRLINKS_HK_HANDLER);
@@ -603,7 +603,7 @@ void ObjectFactory::createPayloadComponents(LinuxLibgpioIF* gpioComIF, PowerSwit
   gpioChecker(gpioComIF->addGpios(mpsocGpioCookie), "PLOC MPSoC");
   auto mpsocCookie =
       new SerialCookie(objects::PLOC_MPSOC_HANDLER, q7s::UART_PLOC_MPSOC_DEV, uart::PLOC_MPSOC_BAUD,
-                     mpsoc::MAX_REPLY_SIZE, UartModes::NON_CANONICAL);
+                       mpsoc::MAX_REPLY_SIZE, UartModes::NON_CANONICAL);
   mpsocCookie->setNoFixedSizeReply();
   auto plocMpsocHelper = new PlocMPSoCHelper(objects::PLOC_MPSOC_HELPER);
   auto* mpsocHandler = new PlocMPSoCHandler(
@@ -620,7 +620,7 @@ void ObjectFactory::createPayloadComponents(LinuxLibgpioIF* gpioComIF, PowerSwit
   gpioComIF->addGpios(supvGpioCookie);
   auto supervisorCookie =
       new SerialCookie(objects::PLOC_SUPERVISOR_HANDLER, q7s::UART_PLOC_SUPERVSIOR_DEV,
-                     uart::PLOC_SUPV_BAUD, supv::MAX_PACKET_SIZE * 20, UartModes::NON_CANONICAL);
+                       uart::PLOC_SUPV_BAUD, supv::MAX_PACKET_SIZE * 20, UartModes::NON_CANONICAL);
   supervisorCookie->setNoFixedSizeReply();
   auto supvHelper = new PlocSupvHelper(objects::PLOC_SUPERVISOR_HELPER);
   auto* supvHandler = new PlocSupervisorHandler(
@@ -907,7 +907,7 @@ void ObjectFactory::createTestComponents(LinuxLibgpioIF* gpioComIF) {
 void ObjectFactory::createStrComponents(PowerSwitchIF* pwrSwitcher) {
   auto* starTrackerCookie =
       new SerialCookie(objects::STAR_TRACKER, q7s::UART_STAR_TRACKER_DEV, uart::STAR_TRACKER_BAUD,
-                     startracker::MAX_FRAME_SIZE * 2 + 2, UartModes::NON_CANONICAL);
+                       startracker::MAX_FRAME_SIZE * 2 + 2, UartModes::NON_CANONICAL);
   starTrackerCookie->setNoFixedSizeReply();
   StrHelper* strHelper = new StrHelper(objects::STR_HELPER);
   auto starTracker =

fsfw

@@ -1 +1 @@
-Subproject commit 046dbe1deb8053f64d7ef85992dec22aea9a3a10
+Subproject commit 2b6a33e718f896300ca08345a9211c2ae974d014

mission/tmtc/CMakeLists.txt

@@ -1,4 +1,10 @@
 target_sources(
   ${LIB_EIVE_MISSION}
-  PRIVATE CcsdsIpCoreHandler.cpp VirtualChannel.cpp TmFunnelHandler.cpp
+  PRIVATE CcsdsIpCoreHandler.cpp
-          TmFunnelBase.cpp CfdpTmFunnel.cpp Service15TmStorage.cpp TmStore.cpp PusTmFunnel.cpp)
+          VirtualChannel.cpp
+          TmFunnelHandler.cpp
+          TmFunnelBase.cpp
+          CfdpTmFunnel.cpp
+          Service15TmStorage.cpp
+          TmStore.cpp
+          PusTmFunnel.cpp)

mission/tmtc/TmStore.cpp

@@ -1,14 +1,49 @@
 #include "TmStore.h"
+
 #include <mission/memory/SdCardMountedIF.h>
 
+#include <algorithm>
 
 using namespace returnvalue;
 
-TmStore::TmStore(object_id_t objectId, SdCardMountedIF& sdcMan)
+TmStore::TmStore(object_id_t objectId, std::string baseName, PacketFilter filter, SdCardMountedIF& sdcMan)
-  : SystemObject(objectId), sdcMan(sdcMan) {}
+    : SystemObject(objectId), filter(filter), sdcMan(sdcMan) {}
 
 ReturnValue_t TmStore::passPacket(PusTmReader& reader) {
+  bool inApidList = false;
+  if (filter.apid) {
+    auto& apidFilter = filter.apid.value();
+    if (std::find(apidFilter.begin(), apidFilter.end(), reader.getApid()) != apidFilter.end()) {
+      if (not filter.serviceSubservices and not filter.services) {
+        return storePacket(reader);
+      }
+      inApidList = true;
+    }
+  }
+  std::pair<uint8_t, uint8_t> serviceSubservice;
+  serviceSubservice.first = reader.getService();
+  serviceSubservice.second = reader.getSubService();
+  if (filter.services) {
+    auto& serviceFilter = filter.services.value();
+    if (std::find(serviceFilter.begin(), serviceFilter.end(), serviceSubservice.first) !=
+        serviceFilter.end()) {
+      if (filter.apid and inApidList) {
+        return storePacket(reader);
+      }
+    }
+  }
+  if (filter.serviceSubservices) {
+    auto& serviceSubserviceFilter = filter.serviceSubservices.value();
+    if (std::find(serviceSubserviceFilter.begin(), serviceSubserviceFilter.end(),
+                  serviceSubservice) != serviceSubserviceFilter.end()) {
+      if (filter.apid and inApidList) {
+        return storePacket(reader);
+      }
+    }
+  }
   return returnvalue::OK;
 }
 
+ReturnValue_t TmStore::storePacket(PusTmReader& reader) { return returnvalue::OK; }
+
 MessageQueueId_t TmStore::getCommandQueue() { return MessageQueueIF::NO_QUEUE; }

mission/tmtc/TmStore.h

@@ -1,24 +1,24 @@
 #ifndef MISSION_TMTC_TMSTOREBACKEND_H_
 #define MISSION_TMTC_TMSTOREBACKEND_H_
 
-#include <mission/memory/SdCardMountedIF.h>
-
 #include <fsfw/objectmanager/SystemObject.h>
 #include <fsfw/tmstorage/TmStoreFrontendIF.h>
 #include <fsfw/tmtcpacket/pus/tm/PusTmReader.h>
 #include <fsfw/tmtcservices/AcceptsTelemetryIF.h>
+#include <mission/memory/SdCardMountedIF.h>
 
 struct PacketFilter {
-  std::optional<uint16_t> apid;
+  std::optional<std::vector<uint16_t>> apid;
-  std::optional<uint8_t> service;
+  std::optional<std::vector<uint8_t>> services;
-  std::optional<std::pair<uint8_t, uint8_t>> serviceSubservice;
+  std::optional<std::vector<std::pair<uint8_t, uint8_t>>> serviceSubservices;
 };
 
 class TmStore : public SystemObject {
  public:
-  TmStore(object_id_t objectId, SdCardMountedIF& sdcMan);
+  TmStore(object_id_t objectId, std::string baseName, PacketFilter filter, SdCardMountedIF& sdcMan);
 
   ReturnValue_t passPacket(PusTmReader& reader);
+  ReturnValue_t storePacket(PusTmReader& reader);
 
  private:
   /**
@@ -26,13 +26,8 @@ class TmStore : public SystemObject {
    * @return  Id of command queue.
    */
   MessageQueueId_t getCommandQueue();
-
+  PacketFilter filter;
   SdCardMountedIF& sdcMan;
-
-
-  std::vector<uint16_t> apidToStore;
-  std::vector<uint8_t> servicesToStore;
-  std::vector<std::pair<uint8_t, uint8_t>> serviceSubserviceCombinationToStore;
 };
 
 #endif /* MISSION_TMTC_TMSTOREBACKEND_H_ */