410 lines
20 KiB
C++
410 lines
20 KiB
C++
#include <fsfw/cfdp/CfdpDistributor.h>
|
|
#include <fsfw/cfdp/handler/RemoteConfigTableIF.h>
|
|
#include <fsfw/controller/ControllerBase.h>
|
|
#include <fsfw/controller/ExtendedControllerBase.h>
|
|
#include <fsfw/events/EventManager.h>
|
|
#include <fsfw/health/HealthTable.h>
|
|
#include <fsfw/internalerror/InternalErrorReporter.h>
|
|
#include <fsfw/ipc/QueueFactory.h>
|
|
#include <fsfw/pus/CService200ModeCommanding.h>
|
|
#include <fsfw/pus/CServiceHealthCommanding.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/subsystem/SubsystemBase.h>
|
|
#include <fsfw/tcdistribution/CcsdsDistributor.h>
|
|
#include <fsfw/tcdistribution/PusDistributor.h>
|
|
#include <fsfw/timemanager/CdsShortTimeStamper.h>
|
|
#include <fsfw_hal/host/HostFilesystem.h>
|
|
#include <mission/cfdp/CfdpFaultHandler.h>
|
|
#include <mission/cfdp/CfdpHandler.h>
|
|
#include <mission/cfdp/CfdpUser.h>
|
|
#include <mission/controller/ThermalController.h>
|
|
#include <mission/genericFactory.h>
|
|
#include <mission/persistentTmStoreDefs.h>
|
|
#include <mission/power/gsDefs.h>
|
|
#include <mission/system/acs/AcsBoardAssembly.h>
|
|
#include <mission/system/acs/RwAssembly.h>
|
|
#include <mission/system/acs/SusAssembly.h>
|
|
#include <mission/system/tcs/TcsBoardAssembly.h>
|
|
#include <mission/tcs/HeaterHandler.h>
|
|
#include <mission/tmtc/CfdpTmFunnel.h>
|
|
#include <mission/tmtc/PersistentTmStore.h>
|
|
#include <mission/tmtc/PersistentTmStoreWithTmQueue.h>
|
|
#include <mission/tmtc/PusPacketFilter.h>
|
|
#include <mission/tmtc/PusTmFunnel.h>
|
|
#include <mission/tmtc/PusTmRouteByFilterHelper.h>
|
|
#include <mission/tmtc/TmFunnelHandler.h>
|
|
|
|
#include "OBSWConfig.h"
|
|
#include "devices/gpioIds.h"
|
|
#include "eive/definitions.h"
|
|
#include "fsfw/pus/Service11TelecommandScheduling.h"
|
|
#include "mission/system/acs/RwAssembly.h"
|
|
#include "mission/system/acs/acsModeTree.h"
|
|
#include "mission/system/tcs/tcsModeTree.h"
|
|
#include "mission/tcs/defs.h"
|
|
#include "mission/tmtc/Service15TmStorage.h"
|
|
#include "mission/tmtc/tmFilters.h"
|
|
#include "objects/systemObjectList.h"
|
|
#include "tmtc/pusIds.h"
|
|
|
|
using persTmStore::PersistentTmStores;
|
|
|
|
#if OBSW_ADD_TCPIP_SERVERS == 1
|
|
#if OBSW_ADD_TMTC_UDP_SERVER == 1
|
|
// UDP server includes
|
|
#include <fsfw/osal/common/UdpTcPollingTask.h>
|
|
#include <fsfw/osal/common/UdpTmTcBridge.h>
|
|
#endif
|
|
#if OBSW_ADD_TMTC_TCP_SERVER == 1
|
|
// 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
|
|
|
|
namespace cfdp {
|
|
|
|
PacketInfoList<64> PACKET_LIST;
|
|
LostSegmentsList<128> LOST_SEGMENTS;
|
|
EntityId REMOTE_CFDP_ID(UnsignedByteField<uint16_t>(config::EIVE_GROUND_CFDP_ENTITY_ID));
|
|
RemoteEntityCfg GROUND_REMOTE_CFG(REMOTE_CFDP_ID);
|
|
OneRemoteConfigProvider REMOTE_CFG_PROVIDER(GROUND_REMOTE_CFG);
|
|
HostFilesystem HOST_FS;
|
|
|
|
} // namespace cfdp
|
|
|
|
std::atomic_bool tcs::TCS_BOARD_SHORTLY_UNAVAILABLE = false;
|
|
std::atomic_bool core::SAVE_PUS_SEQUENCE_COUNT = false;
|
|
std::atomic_bool core::SAVE_CFDP_SEQUENCE_COUNT = false;
|
|
|
|
void ObjectFactory::produceGenericObjects(HealthTableIF** healthTable_, PusTmFunnel** pusFunnel,
|
|
CfdpTmFunnel** cfdpFunnel, SdCardMountedIF& sdcMan,
|
|
StorageManagerIF** ipcStore, StorageManagerIF** tmStore,
|
|
PersistentTmStores& stores,
|
|
uint32_t eventManagerQueueDepth, bool enableHkSets,
|
|
bool routeToPersistentStores) {
|
|
// Framework objects
|
|
new EventManager(objects::EVENT_MANAGER, eventManagerQueueDepth);
|
|
auto healthTable = new HealthTable(objects::HEALTH_TABLE);
|
|
if (healthTable_ != nullptr) {
|
|
*healthTable_ = healthTable;
|
|
}
|
|
new InternalErrorReporter(objects::INTERNAL_ERROR_REPORTER, 5, enableHkSets, 120);
|
|
new VerificationReporter();
|
|
auto* timeStamper = new CdsShortTimeStamper(objects::TIME_STAMPER);
|
|
StorageManagerIF* tcStore;
|
|
{
|
|
PoolManager::LocalPoolConfig poolCfg = {{250, 16}, {250, 32}, {250, 64},
|
|
{150, 128}, {120, 1200}, {120, 2048}};
|
|
tcStore = new PoolManager(objects::TC_STORE, poolCfg);
|
|
}
|
|
|
|
{
|
|
PoolManager::LocalPoolConfig poolCfg = {{600, 32}, {400, 64}, {400, 128},
|
|
{400, 512}, {800, 1200}, {150, 2048}};
|
|
*tmStore = new PoolManager(objects::TM_STORE, poolCfg);
|
|
}
|
|
|
|
{
|
|
PoolManager::LocalPoolConfig poolCfg = {{300, 16}, {250, 32}, {150, 64}, {150, 128},
|
|
{100, 256}, {50, 512}, {50, 1200}, {10, 2048}};
|
|
*ipcStore = new PoolManager(objects::IPC_STORE, poolCfg);
|
|
}
|
|
PoolManager::LocalPoolConfig poolCfg = {{300, 32}, {400, 64}, {250, 128},
|
|
{150, 512}, {400, 1200}, {150, 2048}};
|
|
auto* ramToFileStore = new PoolManager(objects::DOWNLINK_RAM_STORE, poolCfg);
|
|
|
|
#if OBSW_ADD_TCPIP_SERVERS == 1
|
|
#if OBSW_ADD_TMTC_UDP_SERVER == 1
|
|
auto udpBridge = new UdpTmTcBridge(objects::UDP_TMTC_SERVER, objects::CCSDS_PACKET_DISTRIBUTOR,
|
|
config::UDP_MSG_QUEUE_DEPTH);
|
|
new UdpTcPollingTask(objects::UDP_TMTC_POLLING_TASK, objects::UDP_TMTC_SERVER);
|
|
sif::info << "Created UDP server for TMTC commanding with listener port "
|
|
<< udpBridge->getUdpPort() << std::endl;
|
|
udpBridge->setMaxNumberOfPacketsStored(config::UDP_MAX_STORED_CMDS);
|
|
#endif
|
|
#if OBSW_ADD_TMTC_TCP_SERVER == 1
|
|
auto tcpBridge = new TcpTmTcBridge(objects::TCP_TMTC_SERVER, objects::CCSDS_PACKET_DISTRIBUTOR,
|
|
config::TCP_MSG_QUEUE_DEPTH);
|
|
TcpTmTcServer::TcpConfig cfg(true, true);
|
|
auto tcpServer = new TcpTmTcServer(objects::TCP_TMTC_POLLING_TASK, objects::TCP_TMTC_SERVER, cfg);
|
|
// TCP is stream based. Use packet ID as start marker when parsing for space packets
|
|
tcpServer->setSpacePacketParsingOptions({common::PUS_PACKET_ID, common::CFDP_PACKET_ID});
|
|
sif::info << "Created TCP server for TMTC commanding with listener port "
|
|
<< tcpServer->getTcpPort() << std::endl;
|
|
tcpBridge->setMaxNumberOfPacketsStored(config::TCP_MAX_STORED_CMDS);
|
|
tcpBridge->setNumberOfSentPacketsPerCycle(config::TCP_MAX_NUMBER_TMS_SENT_PER_CYCLE);
|
|
#endif /* OBSW_USE_TMTC_TCP_BRIDGE == 0 */
|
|
#endif /* OBSW_ADD_TCPIP_BRIDGE == 1 */
|
|
|
|
auto* ccsdsDistrib =
|
|
new CcsdsDistributor(config::EIVE_PUS_APID, objects::CCSDS_PACKET_DISTRIBUTOR);
|
|
new PusDistributor(config::EIVE_PUS_APID, objects::PUS_PACKET_DISTRIBUTOR, ccsdsDistrib);
|
|
|
|
PusTmFunnel::FunnelCfg pusFunnelCfg(objects::PUS_TM_FUNNEL, "PusTmFunnel", **tmStore, **ipcStore,
|
|
config::MAX_PUS_FUNNEL_QUEUE_DEPTH, sdcMan,
|
|
config::PUS_SEQUENCE_COUNT_FILE,
|
|
core::SAVE_PUS_SEQUENCE_COUNT);
|
|
// The PUS funnel routes all live TM to the live destinations and to the TM stores.
|
|
*pusFunnel = new PusTmFunnel(pusFunnelCfg, *ramToFileStore, *timeStamper);
|
|
|
|
// MISC store and PUS funnel to MISC store routing
|
|
{
|
|
PersistentTmStoreArgs storeArgs(objects::MISC_TM_STORE, "tm", "misc",
|
|
|
|
RolloverInterval::HOURLY, 2, *ramToFileStore, sdcMan);
|
|
stores.miscStore =
|
|
new PersistentTmStoreWithTmQueue(storeArgs, "MISC STORE", config::MISC_STORE_QUEUE_SIZE);
|
|
(*pusFunnel)
|
|
->addPersistentTmStoreRouting(filters::miscFilter(),
|
|
stores.miscStore->getReportReceptionQueue(0));
|
|
}
|
|
|
|
// OK store and PUS Funnel to OK store routing
|
|
{
|
|
PersistentTmStoreArgs storeArgs(objects::OK_TM_STORE, "tm", "ok", RolloverInterval::MINUTELY,
|
|
30, *ramToFileStore, sdcMan);
|
|
stores.okStore =
|
|
new PersistentTmStoreWithTmQueue(storeArgs, "OK STORE", config::OK_STORE_QUEUE_SIZE);
|
|
(*pusFunnel)
|
|
->addPersistentTmStoreRouting(filters::okFilter(),
|
|
stores.okStore->getReportReceptionQueue(0));
|
|
}
|
|
|
|
// NOT OK store and PUS funnel to NOT OK store routing
|
|
{
|
|
PersistentTmStoreArgs storeArgs(objects::NOT_OK_TM_STORE, "tm", "nok",
|
|
RolloverInterval::MINUTELY, 30, *ramToFileStore, sdcMan);
|
|
stores.notOkStore =
|
|
new PersistentTmStoreWithTmQueue(storeArgs, "NOT OK STORE", config::NOK_STORE_QUEUE_SIZE);
|
|
(*pusFunnel)
|
|
->addPersistentTmStoreRouting(filters::notOkFilter(),
|
|
stores.notOkStore->getReportReceptionQueue(0));
|
|
}
|
|
|
|
// HK store and PUS funnel to HK store routing
|
|
{
|
|
PersistentTmStoreArgs storeArgs(objects::HK_TM_STORE, "tm", "hk", RolloverInterval::MINUTELY, 2,
|
|
*ramToFileStore, sdcMan);
|
|
stores.hkStore =
|
|
new PersistentTmStoreWithTmQueue(storeArgs, "HK STORE", config::HK_STORE_QUEUE_SIZE);
|
|
(*pusFunnel)
|
|
->addPersistentTmStoreRouting(filters::hkFilter(),
|
|
stores.hkStore->getReportReceptionQueue(0));
|
|
}
|
|
|
|
// CFDP store and PUS funnel to CFDP store routing
|
|
{
|
|
PersistentTmStoreArgs storeArgs(objects::CFDP_TM_STORE, "tm", "cfdp",
|
|
RolloverInterval::MINUTELY, 30, *ramToFileStore, sdcMan);
|
|
stores.cfdpStore =
|
|
new PersistentTmStoreWithTmQueue(storeArgs, "CFDP STORE", config::CFDP_STORE_QUEUE_SIZE);
|
|
|
|
(*pusFunnel)
|
|
->addPersistentTmStoreRouting(filters::cfdpFilter(),
|
|
stores.cfdpStore->getReportReceptionQueue(0));
|
|
}
|
|
PusTmFunnel::FunnelCfg cfdpFunnelCfg(objects::CFDP_TM_FUNNEL, "CfdpTmFunnel", **tmStore,
|
|
**ipcStore, config::MAX_CFDP_FUNNEL_QUEUE_DEPTH, sdcMan,
|
|
config::CFDP_SEQUENCE_COUNT_FILE,
|
|
core::SAVE_CFDP_SEQUENCE_COUNT);
|
|
std::optional<MessageQueueId_t> fileStoreDest{};
|
|
if (routeToPersistentStores) {
|
|
fileStoreDest = stores.cfdpStore->getReportReceptionQueue(0);
|
|
}
|
|
*cfdpFunnel =
|
|
new CfdpTmFunnel(cfdpFunnelCfg, fileStoreDest, *ramToFileStore, config::EIVE_CFDP_APID);
|
|
|
|
#if OBSW_ADD_TCPIP_SERVERS == 1
|
|
#if OBSW_ADD_TMTC_UDP_SERVER == 1
|
|
(*cfdpFunnel)->addLiveDestination("UDP Server", *udpBridge, 0);
|
|
(*pusFunnel)->addLiveDestination("UDP Server", *udpBridge, 0);
|
|
#endif
|
|
#if OBSW_ADD_TMTC_TCP_SERVER == 1
|
|
(*cfdpFunnel)->addLiveDestination("TCP Server", *tcpBridge, 0);
|
|
(*pusFunnel)->addLiveDestination("TCP Server", *tcpBridge, 0);
|
|
#endif
|
|
#endif
|
|
|
|
// PUS service stack
|
|
new Service1TelecommandVerification(objects::PUS_SERVICE_1_VERIFICATION, config::EIVE_PUS_APID,
|
|
pus::PUS_SERVICE_1, objects::PUS_TM_FUNNEL,
|
|
config::VERIFICATION_SERVICE_QUEUE_DEPTH);
|
|
new Service2DeviceAccess(objects::PUS_SERVICE_2_DEVICE_ACCESS, config::EIVE_PUS_APID,
|
|
pus::PUS_SERVICE_2, 3, 10);
|
|
new Service3Housekeeping(objects::PUS_SERVICE_3_HOUSEKEEPING, config::EIVE_PUS_APID,
|
|
pus::PUS_SERVICE_3, config::HK_SERVICE_QUEUE_DEPTH, 16);
|
|
|
|
auto psbParamsService5 =
|
|
PsbParams(objects::PUS_SERVICE_5_EVENT_REPORTING, config::EIVE_PUS_APID, pus::PUS_SERVICE_5);
|
|
psbParamsService5.requestQueueDepth = 50;
|
|
psbParamsService5.maxPacketsPerCycle = 50;
|
|
new Service5EventReporting(psbParamsService5, 80, 160);
|
|
new Service8FunctionManagement(objects::PUS_SERVICE_8_FUNCTION_MGMT, config::EIVE_PUS_APID,
|
|
pus::PUS_SERVICE_8, config::ACTION_SERVICE_QUEUE_DEPTH, 16, 60);
|
|
new Service9TimeManagement(
|
|
PsbParams(objects::PUS_SERVICE_9_TIME_MGMT, config::EIVE_PUS_APID, pus::PUS_SERVICE_9));
|
|
|
|
auto psbParamsService11 =
|
|
PsbParams(objects::PUS_SERVICE_11_TC_SCHEDULER, config::EIVE_PUS_APID, pus::PUS_SERVICE_11);
|
|
psbParamsService11.requestQueueDepth = 100;
|
|
psbParamsService11.maxPacketsPerCycle = 100;
|
|
new Service11TelecommandScheduling<common::OBSW_MAX_SCHEDULED_TCS>(psbParamsService11,
|
|
ccsdsDistrib);
|
|
|
|
new Service15TmStorage(objects::PUS_SERVICE_15_TM_STORAGE, config::EIVE_PUS_APID, 10);
|
|
auto psbParamsService17 =
|
|
PsbParams(objects::PUS_SERVICE_17_TEST, config::EIVE_PUS_APID, pus::PUS_SERVICE_17);
|
|
psbParamsService17.requestQueueDepth = 50;
|
|
psbParamsService17.maxPacketsPerCycle = 50;
|
|
new Service17Test(psbParamsService17);
|
|
new Service20ParameterManagement(objects::PUS_SERVICE_20_PARAMETERS, config::EIVE_PUS_APID,
|
|
pus::PUS_SERVICE_20);
|
|
new CService200ModeCommanding(objects::PUS_SERVICE_200_MODE_MGMT, config::EIVE_PUS_APID,
|
|
pus::PUS_SERVICE_200, 8);
|
|
HealthServiceCfg healthCfg(objects::PUS_SERVICE_201_HEALTH, config::EIVE_PUS_APID,
|
|
objects::HEALTH_TABLE, 20);
|
|
new CServiceHealthCommanding(healthCfg);
|
|
|
|
#if OBSW_ADD_CFDP_COMPONENTS == 1
|
|
using namespace cfdp;
|
|
|
|
MessageQueueIF* cfdpMsgQueue = QueueFactory::instance()->createMessageQueue(32);
|
|
CfdpDistribCfg distribCfg(objects::CFDP_DISTRIBUTOR, *tcStore, cfdpMsgQueue);
|
|
new CfdpDistributor(distribCfg);
|
|
|
|
auto* tmtcQueue = QueueFactory::instance()->createMessageQueue(32);
|
|
auto* cfdpQueue = QueueFactory::instance()->createMessageQueue(16);
|
|
auto eiveUserHandler = new cfdp::EiveUserHandler(HOST_FS, **ipcStore, cfdpQueue->getId());
|
|
FsfwHandlerParams params(objects::CFDP_HANDLER, HOST_FS, **cfdpFunnel, *tcStore, **tmStore,
|
|
**ipcStore, *tmtcQueue, *cfdpQueue);
|
|
cfdp::IndicationCfg indicationCfg;
|
|
UnsignedByteField<uint16_t> apid(config::EIVE_LOCAL_CFDP_ENTITY_ID);
|
|
cfdp::EntityId localId(apid);
|
|
GROUND_REMOTE_CFG.defaultChecksum = cfdp::ChecksumType::CRC_32;
|
|
GROUND_REMOTE_CFG.maxFileSegmentLen = config::CFDP_MAX_FILE_SEGMENT_LEN;
|
|
auto eiveFaultHandler = new EiveFaultHandler(objects::CFDP_FAULT_HANDLER);
|
|
CfdpHandlerCfg cfdpCfg(localId, indicationCfg, *eiveUserHandler, *eiveFaultHandler, PACKET_LIST,
|
|
LOST_SEGMENTS, REMOTE_CFG_PROVIDER);
|
|
auto* cfdpHandler = new CfdpHandler(params, cfdpCfg, signals::CFDP_CHANNEL_THROTTLE_SIGNAL);
|
|
// All CFDP packets arrive wrapped inside CCSDS space packets
|
|
CcsdsDistributorIF::DestInfo info("CFDP Destination", config::EIVE_CFDP_APID,
|
|
cfdpHandler->getRequestQueue(), true);
|
|
ccsdsDistrib->registerApplication(info);
|
|
#endif
|
|
}
|
|
|
|
void ObjectFactory::createGenericHeaterComponents(GpioIF& gpioIF, PowerSwitchIF& pwrSwitcher,
|
|
HeaterHandler*& heaterHandler) {
|
|
HeaterHelper helper({{
|
|
{new HeaterHealthDev(objects::HEATER_0_PLOC_PROC_BRD, MessageQueueIF::NO_QUEUE),
|
|
gpioIds::HEATER_0},
|
|
{new HeaterHealthDev(objects::HEATER_1_PCDU_BRD, MessageQueueIF::NO_QUEUE),
|
|
gpioIds::HEATER_1},
|
|
{new HeaterHealthDev(objects::HEATER_2_ACS_BRD, MessageQueueIF::NO_QUEUE), gpioIds::HEATER_2},
|
|
{new HeaterHealthDev(objects::HEATER_3_OBC_BRD, MessageQueueIF::NO_QUEUE), gpioIds::HEATER_3},
|
|
{new HeaterHealthDev(objects::HEATER_4_CAMERA, MessageQueueIF::NO_QUEUE), gpioIds::HEATER_4},
|
|
{new HeaterHealthDev(objects::HEATER_5_STR, MessageQueueIF::NO_QUEUE), gpioIds::HEATER_5},
|
|
{new HeaterHealthDev(objects::HEATER_6_DRO, MessageQueueIF::NO_QUEUE), gpioIds::HEATER_6},
|
|
{new HeaterHealthDev(objects::HEATER_7_SYRLINKS, MessageQueueIF::NO_QUEUE),
|
|
gpioIds::HEATER_7},
|
|
}});
|
|
heaterHandler = new HeaterHandler(objects::HEATER_HANDLER, &gpioIF, helper, &pwrSwitcher,
|
|
power::Switches::PDU2_CH3_TCS_BOARD_HEATER_IN_8V);
|
|
heaterHandler->connectModeTreeParent(satsystem::tcs::SUBSYSTEM);
|
|
}
|
|
|
|
void ObjectFactory::createThermalController(HeaterHandler& heaterHandler, bool pollPlPcduTmp1) {
|
|
auto* tcsCtrl = new ThermalController(objects::THERMAL_CONTROLLER, heaterHandler,
|
|
tcs::TCS_BOARD_SHORTLY_UNAVAILABLE, pollPlPcduTmp1);
|
|
tcsCtrl->connectModeTreeParent(satsystem::tcs::SUBSYSTEM);
|
|
}
|
|
void ObjectFactory::createRwAssy(PowerSwitchIF& pwrSwitcher, power::Switch_t theSwitch,
|
|
std::array<DeviceHandlerBase*, 4> rws,
|
|
std::array<object_id_t, 4> rwIds) {
|
|
RwHelper rwHelper(rwIds);
|
|
auto* rwAss = new RwAssembly(objects::RW_ASSY, &pwrSwitcher, theSwitch, rwHelper);
|
|
for (size_t idx = 0; idx < rwIds.size(); idx++) {
|
|
ReturnValue_t result = rws[idx]->connectModeTreeParent(*rwAss);
|
|
if (result != returnvalue::OK) {
|
|
sif::error << "Connecting RW " << static_cast<int>(idx) << " to RW assembly failed"
|
|
<< std::endl;
|
|
}
|
|
}
|
|
rwAss->connectModeTreeParent(satsystem::acs::ACS_SUBSYSTEM);
|
|
}
|
|
|
|
void ObjectFactory::createSusAssy(PowerSwitchIF& pwrSwitcher,
|
|
std::array<DeviceHandlerBase*, 12> suses) {
|
|
std::array<object_id_t, 12> susIds = {
|
|
objects::SUS_0_N_LOC_XFYFZM_PT_XF, objects::SUS_1_N_LOC_XBYFZM_PT_XB,
|
|
objects::SUS_2_N_LOC_XFYBZB_PT_YB, objects::SUS_3_N_LOC_XFYBZF_PT_YF,
|
|
objects::SUS_4_N_LOC_XMYFZF_PT_ZF, objects::SUS_5_N_LOC_XFYMZB_PT_ZB,
|
|
objects::SUS_6_R_LOC_XFYBZM_PT_XF, objects::SUS_7_R_LOC_XBYBZM_PT_XB,
|
|
objects::SUS_8_R_LOC_XBYBZB_PT_YB, objects::SUS_9_R_LOC_XBYBZB_PT_YF,
|
|
objects::SUS_10_N_LOC_XMYBZF_PT_ZF, objects::SUS_11_R_LOC_XBYMZB_PT_ZB};
|
|
auto susAssHelper = SusAssHelper(susIds);
|
|
auto susAss = new SusAssembly(objects::SUS_BOARD_ASS, &pwrSwitcher, susAssHelper);
|
|
for (auto& sus : suses) {
|
|
if (sus != nullptr) {
|
|
ReturnValue_t result = sus->connectModeTreeParent(*susAss);
|
|
if (result != returnvalue::OK) {
|
|
sif::error << "Connecting SUS " << sus->getObjectId() << " to SUS assembly failed"
|
|
<< std::endl;
|
|
}
|
|
}
|
|
}
|
|
susAss->connectModeTreeParent(satsystem::acs::ACS_SUBSYSTEM);
|
|
}
|
|
|
|
void ObjectFactory::createAcsBoardAssy(PowerSwitchIF& pwrSwitcher,
|
|
std::array<DeviceHandlerBase*, 8> assemblyDhbs,
|
|
ExtendedControllerBase* gpsCtrl, GpioIF* gpioComIF) {
|
|
AcsBoardHelper acsBoardHelper = AcsBoardHelper(
|
|
objects::MGM_0_LIS3_HANDLER, objects::MGM_1_RM3100_HANDLER, objects::MGM_2_LIS3_HANDLER,
|
|
objects::MGM_3_RM3100_HANDLER, objects::GYRO_0_ADIS_HANDLER, objects::GYRO_1_L3G_HANDLER,
|
|
objects::GYRO_2_ADIS_HANDLER, objects::GYRO_3_L3G_HANDLER, objects::GPS_CONTROLLER,
|
|
objects::GPS_0_HEALTH_DEV, objects::GPS_1_HEALTH_DEV);
|
|
auto acsAss =
|
|
new AcsBoardAssembly(objects::ACS_BOARD_ASS, &pwrSwitcher, acsBoardHelper, gpioComIF);
|
|
for (auto& assChild : assemblyDhbs) {
|
|
ReturnValue_t result = assChild->connectModeTreeParent(*acsAss);
|
|
if (result != returnvalue::OK) {
|
|
sif::error << "Connecting assembly for ACS board component " << assChild->getObjectId()
|
|
<< " failed" << std::endl;
|
|
}
|
|
}
|
|
gpsCtrl->connectModeTreeParent(*acsAss);
|
|
auto* gps0HealthDev = new HealthDevice(objects::GPS_0_HEALTH_DEV, acsAss->getCommandQueue());
|
|
auto* gps1HealthDev = new HealthDevice(objects::GPS_1_HEALTH_DEV, acsAss->getCommandQueue());
|
|
acsAss->registerChild(objects::GPS_0_HEALTH_DEV, gps0HealthDev->getCommandQueue());
|
|
acsAss->registerChild(objects::GPS_1_HEALTH_DEV, gps1HealthDev->getCommandQueue());
|
|
acsAss->connectModeTreeParent(satsystem::acs::ACS_SUBSYSTEM);
|
|
}
|
|
|
|
TcsBoardAssembly* ObjectFactory::createTcsBoardAssy(PowerSwitchIF& pwrSwitcher,
|
|
std::atomic_bool& tcsShortlyUnavailable) {
|
|
TcsBoardHelper helper(RTD_INFOS);
|
|
auto* tcsBoardAss =
|
|
new TcsBoardAssembly(objects::TCS_BOARD_ASS, &pwrSwitcher,
|
|
power::Switches::PDU1_CH0_TCS_BOARD_3V3, helper, tcsShortlyUnavailable);
|
|
tcsBoardAss->connectModeTreeParent(satsystem::tcs::SUBSYSTEM);
|
|
return tcsBoardAss;
|
|
}
|