eive-obsw/mission/core/GenericFactory.cpp

#include "GenericFactory.h"

#include <fsfw/events/EventManager.h>
#include <fsfw/health/HealthTable.h>
#include <fsfw/internalerror/InternalErrorReporter.h>
#include <fsfw/pus/CService200ModeCommanding.h>
#include <fsfw/pus/CService201HealthCommanding.h>
#include <fsfw/pus/Service17Test.h>
#include <fsfw/pus/Service1TelecommandVerification.h>
#include <fsfw/pus/Service20ParameterManagement.h>
#include <fsfw/pus/Service2DeviceAccess.h>
#include <fsfw/pus/Service3Housekeeping.h>
#include <fsfw/pus/Service5EventReporting.h>
#include <fsfw/pus/Service8FunctionManagement.h>
#include <fsfw/pus/Service9TimeManagement.h>
#include <fsfw/storagemanager/PoolManager.h>
#include <fsfw/tcdistribution/CCSDSDistributor.h>
#include <fsfw/tcdistribution/PusDistributor.h>
#include <fsfw/timemanager/CdsShortTimeStamper.h>
#include <mission/tmtc/TmFunnel.h>

#include "OBSWConfig.h"
#include "eive/definitions.h"
#include "fsfw/pus/Service11TelecommandScheduling.h"
#include "objects/systemObjectList.h"
#include "tmtc/apid.h"
#include "tmtc/pusIds.h"

#if OBSW_ADD_TCPIP_BRIDGE == 1
#if OBSW_USE_TMTC_TCP_BRIDGE == 0
// UDP server includes
#include "fsfw/osal/common/UdpTcPollingTask.h"
#include "fsfw/osal/common/UdpTmTcBridge.h"
#else
// TCP server includes
#include "fsfw/osal/common/TcpTmTcBridge.h"
#include "fsfw/osal/common/TcpTmTcServer.h"
#endif
#endif

#if OBSW_ADD_TEST_CODE == 1
#include <test/testtasks/TestTask.h>
#endif

#ifndef OBSW_TM_TO_PTME
#define OBSW_TM_TO_PTME 0
#endif

void ObjectFactory::produceGenericObjects(HealthTableIF** healthTable_) {
  // Framework objects
  new EventManager(objects::EVENT_MANAGER);
  auto healthTable = new HealthTable(objects::HEALTH_TABLE);
  if (healthTable_ != nullptr) {
    *healthTable_ = healthTable;
  }
  new InternalErrorReporter(objects::INTERNAL_ERROR_REPORTER);
  new VerificationReporter();
  auto* timeStamper = new CdsShortTimeStamper(objects::TIME_STAMPER);

  {
    PoolManager::LocalPoolConfig poolCfg = {{300, 16},  {300, 32},   {200, 64},
                                            {200, 128}, {100, 1024}, {10, 2048}};
    new PoolManager(objects::TC_STORE, poolCfg);
  }

  {
    PoolManager::LocalPoolConfig poolCfg = {{300, 16},  {300, 32},   {100, 64},
                                            {100, 128}, {100, 1024}, {10, 2048}};
    new PoolManager(objects::TM_STORE, poolCfg);
  }

  {
    PoolManager::LocalPoolConfig poolCfg = {{300, 16},  {200, 32}, {150, 64},  {150, 128},
                                            {100, 256}, {50, 512}, {50, 1024}, {10, 2048}};
    new PoolManager(objects::IPC_STORE, poolCfg);
  }

  auto* ccsdsDistrib = new CCSDSDistributor(apid::EIVE_OBSW, objects::CCSDS_PACKET_DISTRIBUTOR);
  new PusDistributor(apid::EIVE_OBSW, objects::PUS_PACKET_DISTRIBUTOR, ccsdsDistrib);

  uint8_t vc = 0;
#if OBSW_TM_TO_PTME == 1
  vc = config::LIVE_TM;
#endif
  // Every TM packet goes through this funnel
  new TmFunnel(objects::TM_FUNNEL, *timeStamper, 50, vc);

  // PUS service stack
  new Service1TelecommandVerification(objects::PUS_SERVICE_1_VERIFICATION, apid::EIVE_OBSW,
                                      pus::PUS_SERVICE_1, objects::TM_FUNNEL, 20);
  new Service2DeviceAccess(objects::PUS_SERVICE_2_DEVICE_ACCESS, apid::EIVE_OBSW,
                           pus::PUS_SERVICE_2, 3, 10);
  new Service3Housekeeping(objects::PUS_SERVICE_3_HOUSEKEEPING, apid::EIVE_OBSW,
                           pus::PUS_SERVICE_3);
  new Service5EventReporting(
      PsbParams(objects::PUS_SERVICE_5_EVENT_REPORTING, apid::EIVE_OBSW, pus::PUS_SERVICE_5), 15,
      45);
  new Service8FunctionManagement(objects::PUS_SERVICE_8_FUNCTION_MGMT, apid::EIVE_OBSW,
                                 pus::PUS_SERVICE_8, 16, 60);
  new Service9TimeManagement(
      PsbParams(objects::PUS_SERVICE_9_TIME_MGMT, apid::EIVE_OBSW, pus::PUS_SERVICE_9));

  new Service11TelecommandScheduling<common::OBSW_MAX_SCHEDULED_TCS>(
      PsbParams(objects::PUS_SERVICE_11_TC_SCHEDULER, apid::EIVE_OBSW, pus::PUS_SERVICE_11),
      ccsdsDistrib);
  new Service17Test(PsbParams(objects::PUS_SERVICE_17_TEST, apid::EIVE_OBSW, pus::PUS_SERVICE_17));
  new Service20ParameterManagement(objects::PUS_SERVICE_20_PARAMETERS, apid::EIVE_OBSW,
                                   pus::PUS_SERVICE_20);
  new CService200ModeCommanding(objects::PUS_SERVICE_200_MODE_MGMT, apid::EIVE_OBSW,
                                pus::PUS_SERVICE_200, 8);
  new CService201HealthCommanding(objects::PUS_SERVICE_201_HEALTH, apid::EIVE_OBSW,
                                  pus::PUS_SERVICE_201);
#if OBSW_ADD_TCPIP_BRIDGE == 1
#if OBSW_USE_TMTC_TCP_BRIDGE == 0
  auto tmtcBridge = new UdpTmTcBridge(objects::TMTC_BRIDGE, objects::CCSDS_PACKET_DISTRIBUTOR);
  new UdpTcPollingTask(objects::TMTC_POLLING_TASK, objects::TMTC_BRIDGE);
  sif::info << "Created UDP server for TMTC commanding with listener port "
            << udpBridge->getUdpPort() << std::endl;
#else
  auto tmtcBridge = new TcpTmTcBridge(objects::TMTC_BRIDGE, objects::CCSDS_PACKET_DISTRIBUTOR);
  auto tcpServer = new TcpTmTcServer(objects::TMTC_POLLING_TASK, objects::TMTC_BRIDGE);
  // TCP is stream based. Use packet ID as start marker when parsing for space packets
  tcpServer->setSpacePacketParsingOptions({common::PUS_PACKET_ID});
  sif::info << "Created TCP server for TMTC commanding with listener port "
            << tcpServer->getTcpPort() << std::endl;
#if OBSW_TCP_SERVER_WIRETAPPING == 1
  tcpServer->enableWiretapping(true);
#endif /* OBSW_TCP_SERVER_WIRETAPPING == 1 */
#endif /* OBSW_USE_TMTC_TCP_BRIDGE == 0 */
  tmtcBridge->setMaxNumberOfPacketsStored(300);
#endif /* OBSW_ADD_TCPIP_BRIDGE == 1 */
}