From fe8036361d33b5dba012aba9b8010df84776582b Mon Sep 17 00:00:00 2001 From: Ulrich Mohr Date: Thu, 25 Aug 2022 14:43:27 +0200 Subject: [PATCH] I knew this was stupid: Revert "changing mission dependend object IDs to FSFW_ENUM" This reverts commit 2800484f6b1896b84144953cfbe68d0e23170651. --- bsp_q7s/core/InitMission.cpp | 140 +++-- bsp_q7s/core/ObjectFactory.cpp | 248 ++++----- bsp_q7s/fmObjectFactory.cpp | 2 +- bsp_q7s/memory/FileSystemHandler.cpp | 2 +- bsp_q7s/memory/SdCardManager.cpp | 2 +- common/config/commonObjects.h | 187 +++---- dummies/SusDummy.cpp | 24 +- dummies/TemperatureSensorsDummy.cpp | 36 +- linux/ObjectFactory.cpp | 130 ++--- linux/devices/ploc/PlocMPSoCHandler.cpp | 2 +- linux/devices/ploc/PlocMemoryDumper.cpp | 2 +- linux/devices/ploc/PlocSupervisorHandler.cpp | 2 +- .../startracker/StarTrackerHandler.cpp | 2 +- linux/fsfwconfig/devices/addresses.h | 42 +- linux/fsfwconfig/objects/systemObjectList.h | 52 +- .../pollingSequenceFactory.cpp | 504 +++++++++--------- mission/controller/AcsController.h | 10 +- mission/controller/ThermalController.cpp | 110 ++-- mission/core/GenericFactory.cpp | 18 +- mission/devices/GomspaceDeviceHandler.cpp | 2 +- mission/devices/PCDUHandler.cpp | 44 +- mission/system/fdir/AcsBoardFdir.cpp | 2 +- mission/system/fdir/RtdFdir.cpp | 2 +- mission/system/fdir/SusFdir.cpp | 2 +- 24 files changed, 780 insertions(+), 787 deletions(-) diff --git a/bsp_q7s/core/InitMission.cpp b/bsp_q7s/core/InitMission.cpp index d53a940f..29b9ec4e 100644 --- a/bsp_q7s/core/InitMission.cpp +++ b/bsp_q7s/core/InitMission.cpp @@ -161,16 +161,8 @@ void initmission::initMission() { sif::info << "Looping.." << std::endl; for (auto iter : *objectList) { - const char * name = "UNKNOWN"; - commonObjects commonObjectId(iter.first); - if (commonObjectId.isValid()){ - name = commonObjectId.getDescription(); - } - systemObjects systemObject(iter.first); - if( systemObject.isValid()){ - name = systemObject.getDescription(); - } - printf("Object \"%s\" (0x%08x)\n", name, iter.first); + //SystemObjects objectId(iter.first); + printf("Object \"%s\" (0x%08x)\n", "TODO", iter.first); HasActionsIF* actionIf = dynamic_cast(iter.second); if (actionIf != nullptr) { @@ -217,49 +209,49 @@ void initmission::initTasks() { PeriodicTaskIF* coreController = factory->createPeriodicTask( "CORE_CTRL", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.4, missedDeadlineFunc); - result = coreController->addComponent(commonObjects::CORE_CONTROLLER); + result = coreController->addComponent(objects::CORE_CONTROLLER); if (result != HasReturnvaluesIF::RETURN_OK) { - initmission::printAddObjectError("CORE_CTRL", commonObjects::CORE_CONTROLLER); + initmission::printAddObjectError("CORE_CTRL", objects::CORE_CONTROLLER); } /* TMTC Distribution */ PeriodicTaskIF* tmTcDistributor = factory->createPeriodicTask( "DIST", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc); - result = tmTcDistributor->addComponent(commonObjects::CCSDS_PACKET_DISTRIBUTOR); + result = tmTcDistributor->addComponent(objects::CCSDS_PACKET_DISTRIBUTOR); if (result != HasReturnvaluesIF::RETURN_OK) { - initmission::printAddObjectError("CCSDS_DISTRIB", commonObjects::CCSDS_PACKET_DISTRIBUTOR); + initmission::printAddObjectError("CCSDS_DISTRIB", objects::CCSDS_PACKET_DISTRIBUTOR); } - result = tmTcDistributor->addComponent(commonObjects::PUS_PACKET_DISTRIBUTOR); + result = tmTcDistributor->addComponent(objects::PUS_PACKET_DISTRIBUTOR); if (result != HasReturnvaluesIF::RETURN_OK) { - initmission::printAddObjectError("PUS_PACKET_DISTRIB", commonObjects::PUS_PACKET_DISTRIBUTOR); + initmission::printAddObjectError("PUS_PACKET_DISTRIB", objects::PUS_PACKET_DISTRIBUTOR); } - result = tmTcDistributor->addComponent(systemObjects::TM_FUNNEL); + result = tmTcDistributor->addComponent(objects::TM_FUNNEL); if (result != HasReturnvaluesIF::RETURN_OK) { - initmission::printAddObjectError("TM_FUNNEL", systemObjects::TM_FUNNEL); + initmission::printAddObjectError("TM_FUNNEL", objects::TM_FUNNEL); } #if OBSW_ADD_TCPIP_BRIDGE == 1 // TMTC bridge PeriodicTaskIF* tmtcBridgeTask = factory->createPeriodicTask( "TCPIP_TMTC_BRIDGE", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc); - result = tmtcBridgeTask->addComponent(commonObjects::TMTC_BRIDGE); + result = tmtcBridgeTask->addComponent(objects::TMTC_BRIDGE); if (result != HasReturnvaluesIF::RETURN_OK) { - initmission::printAddObjectError("TMTC_BRIDGE", commonObjects::TMTC_BRIDGE); + initmission::printAddObjectError("TMTC_BRIDGE", objects::TMTC_BRIDGE); } PeriodicTaskIF* tmtcPollingTask = factory->createPeriodicTask( "TMTC_POLLING", 80, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc); - result = tmtcPollingTask->addComponent(commonObjects::TMTC_POLLING_TASK); + result = tmtcPollingTask->addComponent(objects::TMTC_POLLING_TASK); if (result != HasReturnvaluesIF::RETURN_OK) { - initmission::printAddObjectError("UDP_POLLING", commonObjects::TMTC_POLLING_TASK); + initmission::printAddObjectError("UDP_POLLING", objects::TMTC_POLLING_TASK); } #endif #if OBSW_USE_CCSDS_IP_CORE == 1 PeriodicTaskIF* ccsdsHandlerTask = factory->createPeriodicTask( "CCSDS_HANDLER", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc); - result = ccsdsHandlerTask->addComponent(commonObjects::CCSDS_HANDLER); + result = ccsdsHandlerTask->addComponent(objects::CCSDS_HANDLER); if (result != HasReturnvaluesIF::RETURN_OK) { - initmission::printAddObjectError("CCSDS Handler", commonObjects::CCSDS_HANDLER); + initmission::printAddObjectError("CCSDS Handler", objects::CCSDS_HANDLER); } // Minimal distance between two received TCs amounts to 0.6 seconds @@ -267,77 +259,77 @@ void initmission::initTasks() { // overwritten by the PDEC. PeriodicTaskIF* pdecHandlerTask = factory->createPeriodicTask( "PDEC_HANDLER", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, missedDeadlineFunc); - result = pdecHandlerTask->addComponent(commonObjects::PDEC_HANDLER); + result = pdecHandlerTask->addComponent(objects::PDEC_HANDLER); if (result != HasReturnvaluesIF::RETURN_OK) { - initmission::printAddObjectError("PDEC Handler", commonObjects::PDEC_HANDLER); + initmission::printAddObjectError("PDEC Handler", objects::PDEC_HANDLER); } #endif /* OBSW_USE_CCSDS_IP_CORE == 1 */ #if OBSW_ADD_ACS_HANDLERS == 1 PeriodicTaskIF* acsTask = factory->createPeriodicTask( "ACS_TASK", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 0.4, missedDeadlineFunc); - result = acsTask->addComponent(commonObjects::GPS_CONTROLLER); + result = acsTask->addComponent(objects::GPS_CONTROLLER); if (result != HasReturnvaluesIF::RETURN_OK) { - initmission::printAddObjectError("GPS_CTRL", commonObjects::GPS_CONTROLLER); + initmission::printAddObjectError("GPS_CTRL", objects::GPS_CONTROLLER); } #endif /* OBSW_ADD_ACS_HANDLERS */ - acsTask->addComponent(commonObjects::ACS_CONTROLLER); + acsTask->addComponent(objects::ACS_CONTROLLER); if (result != HasReturnvaluesIF::RETURN_OK) { - initmission::printAddObjectError("ACS_CTRL", commonObjects::ACS_CONTROLLER); + initmission::printAddObjectError("ACS_CTRL", objects::ACS_CONTROLLER); } PeriodicTaskIF* sysTask = factory->createPeriodicTask( "SYS_TASK", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 0.4, missedDeadlineFunc); static_cast(sysTask); #if OBSW_ADD_ACS_HANDLERS == 1 - result = sysTask->addComponent(commonObjects::ACS_BOARD_ASS); + result = sysTask->addComponent(objects::ACS_BOARD_ASS); if (result != HasReturnvaluesIF::RETURN_OK) { - initmission::printAddObjectError("ACS_BOARD_ASS", commonObjects::ACS_BOARD_ASS); + initmission::printAddObjectError("ACS_BOARD_ASS", objects::ACS_BOARD_ASS); } #endif /* OBSW_ADD_ACS_HANDLERS */ #if OBSW_ADD_RW == 1 - result = sysTask->addComponent(commonObjects::RW_ASS); + result = sysTask->addComponent(objects::RW_ASS); if (result != HasReturnvaluesIF::RETURN_OK) { - initmission::printAddObjectError("RW_ASS", commonObjects::RW_ASS); + initmission::printAddObjectError("RW_ASS", objects::RW_ASS); } #endif #if OBSW_ADD_SUS_BOARD_ASS == 1 - result = sysTask->addComponent(commonObjects::SUS_BOARD_ASS); + result = sysTask->addComponent(objects::SUS_BOARD_ASS); if (result != HasReturnvaluesIF::RETURN_OK) { - initmission::printAddObjectError("SUS_BOARD_ASS", commonObjects::SUS_BOARD_ASS); + initmission::printAddObjectError("SUS_BOARD_ASS", objects::SUS_BOARD_ASS); } #endif #if OBSW_ADD_RTD_DEVICES == 1 PeriodicTaskIF* tcsPollingTask = factory->createPeriodicTask( "TCS_POLLING_TASK", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 0.5, missedDeadlineFunc); - result = tcsPollingTask->addComponent(systemObjects::SPI_RTD_COM_IF); + result = tcsPollingTask->addComponent(objects::SPI_RTD_COM_IF); if (result != HasReturnvaluesIF::RETURN_OK) { - initmission::printAddObjectError("SPI_RTD_POLLING", systemObjects::SPI_RTD_COM_IF); + initmission::printAddObjectError("SPI_RTD_POLLING", objects::SPI_RTD_COM_IF); } PeriodicTaskIF* tcsTask = factory->createPeriodicTask( "TCS_TASK", 45, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.8, missedDeadlineFunc); std::array rtdIds = { - commonObjects::RTD_0_IC3_PLOC_HEATSPREADER, - commonObjects::RTD_1_IC4_PLOC_MISSIONBOARD, - commonObjects::RTD_2_IC5_4K_CAMERA, - commonObjects::RTD_3_IC6_DAC_HEATSPREADER, - commonObjects::RTD_4_IC7_STARTRACKER, - commonObjects::RTD_5_IC8_RW1_MX_MY, - commonObjects::RTD_6_IC9_DRO, - commonObjects::RTD_7_IC10_SCEX, - commonObjects::RTD_8_IC11_X8, - commonObjects::RTD_9_IC12_HPA, - commonObjects::RTD_10_IC13_PL_TX, - commonObjects::RTD_11_IC14_MPA, - commonObjects::RTD_12_IC15_ACU, - commonObjects::RTD_13_IC16_PLPCDU_HEATSPREADER, - commonObjects::RTD_14_IC17_TCS_BOARD, - commonObjects::RTD_15_IC18_IMTQ, + objects::RTD_0_IC3_PLOC_HEATSPREADER, + objects::RTD_1_IC4_PLOC_MISSIONBOARD, + objects::RTD_2_IC5_4K_CAMERA, + objects::RTD_3_IC6_DAC_HEATSPREADER, + objects::RTD_4_IC7_STARTRACKER, + objects::RTD_5_IC8_RW1_MX_MY, + objects::RTD_6_IC9_DRO, + objects::RTD_7_IC10_SCEX, + objects::RTD_8_IC11_X8, + objects::RTD_9_IC12_HPA, + objects::RTD_10_IC13_PL_TX, + objects::RTD_11_IC14_MPA, + objects::RTD_12_IC15_ACU, + objects::RTD_13_IC16_PLPCDU_HEATSPREADER, + objects::RTD_14_IC17_TCS_BOARD, + objects::RTD_15_IC18_IMTQ, }; - tcsTask->addComponent(commonObjects::TCS_BOARD_ASS); - tcsTask->addComponent(commonObjects::THERMAL_CONTROLLER); + tcsTask->addComponent(objects::TCS_BOARD_ASS); + tcsTask->addComponent(objects::THERMAL_CONTROLLER); for (const auto& rtd : rtdIds) { tcsTask->addComponent(rtd, DeviceHandlerIF::PERFORM_OPERATION); tcsTask->addComponent(rtd, DeviceHandlerIF::SEND_WRITE); @@ -351,44 +343,44 @@ void initmission::initTasks() { // because it is a non-essential background task PeriodicTaskIF* fsTask = factory->createPeriodicTask( "FILE_SYSTEM_TASK", 25, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.4, missedDeadlineFunc); - result = fsTask->addComponent(commonObjects::FILE_SYSTEM_HANDLER); + result = fsTask->addComponent(objects::FILE_SYSTEM_HANDLER); if (result != HasReturnvaluesIF::RETURN_OK) { - initmission::printAddObjectError("FILE_SYSTEM_TASK", commonObjects::FILE_SYSTEM_HANDLER); + initmission::printAddObjectError("FILE_SYSTEM_TASK", objects::FILE_SYSTEM_HANDLER); } #if OBSW_ADD_STAR_TRACKER == 1 PeriodicTaskIF* strHelperTask = factory->createPeriodicTask( "STR_HELPER", 20, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc); - result = strHelperTask->addComponent(commonObjects::STR_HELPER); + result = strHelperTask->addComponent(objects::STR_HELPER); if (result != HasReturnvaluesIF::RETURN_OK) { - initmission::printAddObjectError("STR_HELPER", commonObjects::STR_HELPER); + initmission::printAddObjectError("STR_HELPER", objects::STR_HELPER); } #endif /* OBSW_ADD_STAR_TRACKER == 1 */ #if OBSW_ADD_PLOC_MPSOC == 1 PeriodicTaskIF* mpsocHelperTask = factory->createPeriodicTask( "PLOC_MPSOC_HELPER", 20, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc); - result = mpsocHelperTask->addComponent(commonObjects::PLOC_MPSOC_HELPER); + result = mpsocHelperTask->addComponent(objects::PLOC_MPSOC_HELPER); if (result != HasReturnvaluesIF::RETURN_OK) { - initmission::printAddObjectError("PLOC_MPSOC_HELPER", commonObjects::PLOC_MPSOC_HELPER); + initmission::printAddObjectError("PLOC_MPSOC_HELPER", objects::PLOC_MPSOC_HELPER); } #endif /* OBSW_ADD_PLOC_MPSOC */ #if OBSW_ADD_PLOC_SUPERVISOR == 1 PeriodicTaskIF* supvHelperTask = factory->createPeriodicTask( "PLOC_SUPV_HELPER", 10, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, missedDeadlineFunc); - result = supvHelperTask->addComponent(commonObjects::PLOC_SUPERVISOR_HELPER); + result = supvHelperTask->addComponent(objects::PLOC_SUPERVISOR_HELPER); if (result != HasReturnvaluesIF::RETURN_OK) { - initmission::printAddObjectError("PLOC_SUPV_HELPER", commonObjects::PLOC_SUPERVISOR_HELPER); + initmission::printAddObjectError("PLOC_SUPV_HELPER", objects::PLOC_SUPERVISOR_HELPER); } #endif /* OBSW_ADD_PLOC_SUPERVISOR */ #if OBSW_TEST_CCSDS_BRIDGE == 1 PeriodicTaskIF* ptmeTestTask = factory->createPeriodicTask( "PTME_TEST", 80, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc); - result = ptmeTestTask->addComponent(commonObjects::CCSDS_IP_CORE_BRIDGE); + result = ptmeTestTask->addComponent(objects::CCSDS_IP_CORE_BRIDGE); if (result != HasReturnvaluesIF::RETURN_OK) { - initmission::printAddObjectError("PTME_TEST", commonObjects::CCSDS_IP_CORE_BRIDGE); + initmission::printAddObjectError("PTME_TEST", objects::CCSDS_IP_CORE_BRIDGE); } #endif @@ -633,27 +625,27 @@ void initmission::createTestTasks(TaskFactory& factory, PeriodicTaskIF* testTask = factory.createPeriodicTask( "TEST_TASK", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1, missedDeadlineFunc); - result = testTask->addComponent(commonObjects::TEST_TASK); + result = testTask->addComponent(objects::TEST_TASK); if (result != HasReturnvaluesIF::RETURN_OK) { - initmission::printAddObjectError("TEST_TASK", commonObjects::TEST_TASK); + initmission::printAddObjectError("TEST_TASK", objects::TEST_TASK); } #if OBSW_ADD_SPI_TEST_CODE == 1 - result = testTask->addComponent(commonObjects::SPI_TEST); + result = testTask->addComponent(objects::SPI_TEST); if (result != HasReturnvaluesIF::RETURN_OK) { - initmission::printAddObjectError("SPI_TEST", commonObjects::SPI_TEST); + initmission::printAddObjectError("SPI_TEST", objects::SPI_TEST); } #endif #if OBSW_ADD_I2C_TEST_CODE == 1 - result = testTask->addComponent(commonObjects::I2C_TEST); + result = testTask->addComponent(objects::I2C_TEST); if (result != HasReturnvaluesIF::RETURN_OK) { - initmission::printAddObjectError("I2C_TEST", commonObjects::I2C_TEST); + initmission::printAddObjectError("I2C_TEST", objects::I2C_TEST); } #endif #if OBSW_ADD_UART_TEST_CODE == 1 - result = testTask->addComponent(commonObjects::UART_TEST); + result = testTask->addComponent(objects::UART_TEST); if (result != HasReturnvaluesIF::RETURN_OK) { - initmission::printAddObjectError("UART_TEST", commonObjects::UART_TEST); + initmission::printAddObjectError("UART_TEST", objects::UART_TEST); } #endif diff --git a/bsp_q7s/core/ObjectFactory.cpp b/bsp_q7s/core/ObjectFactory.cpp index 732919aa..43b1da31 100644 --- a/bsp_q7s/core/ObjectFactory.cpp +++ b/bsp_q7s/core/ObjectFactory.cpp @@ -95,22 +95,22 @@ ResetArgs RESET_ARGS_GNSS; void Factory::setStaticFrameworkObjectIds() { - PusServiceBase::packetSource = commonObjects::PUS_PACKET_DISTRIBUTOR; - PusServiceBase::packetDestination = systemObjects::TM_FUNNEL; + PusServiceBase::packetSource = objects::PUS_PACKET_DISTRIBUTOR; + PusServiceBase::packetDestination = objects::TM_FUNNEL; - CommandingServiceBase::defaultPacketSource = commonObjects::PUS_PACKET_DISTRIBUTOR; - CommandingServiceBase::defaultPacketDestination = systemObjects::TM_FUNNEL; + CommandingServiceBase::defaultPacketSource = objects::PUS_PACKET_DISTRIBUTOR; + CommandingServiceBase::defaultPacketDestination = objects::TM_FUNNEL; #if OBSW_Q7S_EM == 1 - DeviceHandlerBase::powerSwitcherId = objetcs::NO_OBJECT; + DeviceHandlerBase::powerSwitcherId = objects::NO_OBJECT; #else - DeviceHandlerBase::powerSwitcherId = commonObjects::PCDU_HANDLER; + DeviceHandlerBase::powerSwitcherId = objects::PCDU_HANDLER; #endif /* OBSW_Q7S_EM == 1 */ #if OBSW_TM_TO_PTME == 1 - TmFunnel::downlinkDestination = commonObjects::CCSDS_HANDLER; + TmFunnel::downlinkDestination = objects::CCSDS_HANDLER; #else - TmFunnel::downlinkDestination = commonObjects::TMTC_BRIDGE; + TmFunnel::downlinkDestination = objects::TMTC_BRIDGE; #endif /* OBSW_TM_TO_PTME == 1 */ // No storage object for now. TmFunnel::storageDestination = objects::NO_OBJECT; @@ -131,10 +131,10 @@ void ObjectFactory::createTmpComponents() { /* Temperature sensors */ Tmp1075Handler* tmp1075Handler_1 = - new Tmp1075Handler(commonObjects::TMP1075_HANDLER_1, systemObjects::I2C_COM_IF, i2cCookieTmp1075tcs1); + new Tmp1075Handler(objects::TMP1075_HANDLER_1, objects::I2C_COM_IF, i2cCookieTmp1075tcs1); (void)tmp1075Handler_1; Tmp1075Handler* tmp1075Handler_2 = - new Tmp1075Handler(commonObjects::TMP1075_HANDLER_2, systemObjects::I2C_COM_IF, i2cCookieTmp1075tcs2); + new Tmp1075Handler(objects::TMP1075_HANDLER_2, objects::I2C_COM_IF, i2cCookieTmp1075tcs2); (void)tmp1075Handler_2; } @@ -146,14 +146,14 @@ void ObjectFactory::createCommunicationInterfaces(LinuxLibgpioIF** gpioComIF, Ua sif::error << "ObjectFactory::createCommunicationInterfaces: Invalid passed ComIF pointer" << std::endl; } - *gpioComIF = new LinuxLibgpioIF(systemObjects::GPIO_IF); + *gpioComIF = new LinuxLibgpioIF(objects::GPIO_IF); /* Communication interfaces */ - new CspComIF(systemObjects::CSP_COM_IF); - *i2cComIF = new I2cComIF(systemObjects::I2C_COM_IF); - *uartComIF = new UartComIF(systemObjects::UART_COM_IF); - *spiMainComIF = new SpiComIF(systemObjects::SPI_MAIN_COM_IF, q7s::SPI_DEFAULT_DEV, *gpioComIF); - *spiRWComIF = new SpiComIF(systemObjects::SPI_RW_COM_IF, q7s::SPI_RW_DEV, *gpioComIF); + new CspComIF(objects::CSP_COM_IF); + *i2cComIF = new I2cComIF(objects::I2C_COM_IF); + *uartComIF = new UartComIF(objects::UART_COM_IF); + *spiMainComIF = new SpiComIF(objects::SPI_MAIN_COM_IF, q7s::SPI_DEFAULT_DEV, *gpioComIF); + *spiRWComIF = new SpiComIF(objects::SPI_RW_COM_IF, q7s::SPI_RW_DEV, *gpioComIF); /* Adding gpios for chip select decoding to the gpioComIf */ q7s::gpioCallbacks::initSpiCsDecoder(*gpioComIF); } @@ -164,22 +164,22 @@ void ObjectFactory::createPcduComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchI CspCookie* pdu2CspCookie = new CspCookie(PDU::MAX_REPLY_LENGTH, addresses::PDU2); CspCookie* acuCspCookie = new CspCookie(ACU::MAX_REPLY_LENGTH, addresses::ACU); - auto p60Fdir = new GomspacePowerFdir(commonObjects::P60DOCK_HANDLER); + auto p60Fdir = new GomspacePowerFdir(objects::P60DOCK_HANDLER); P60DockHandler* p60dockhandler = - new P60DockHandler(commonObjects::P60DOCK_HANDLER, systemObjects::CSP_COM_IF, p60DockCspCookie, p60Fdir); + new P60DockHandler(objects::P60DOCK_HANDLER, objects::CSP_COM_IF, p60DockCspCookie, p60Fdir); - auto pdu1Fdir = new GomspacePowerFdir(commonObjects::PDU1_HANDLER); + auto pdu1Fdir = new GomspacePowerFdir(objects::PDU1_HANDLER); PDU1Handler* pdu1handler = - new PDU1Handler(commonObjects::PDU1_HANDLER, systemObjects::CSP_COM_IF, pdu1CspCookie, pdu1Fdir); + new PDU1Handler(objects::PDU1_HANDLER, objects::CSP_COM_IF, pdu1CspCookie, pdu1Fdir); - auto pdu2Fdir = new GomspacePowerFdir(commonObjects::PDU2_HANDLER); + auto pdu2Fdir = new GomspacePowerFdir(objects::PDU2_HANDLER); PDU2Handler* pdu2handler = - new PDU2Handler(commonObjects::PDU2_HANDLER, systemObjects::CSP_COM_IF, pdu2CspCookie, pdu2Fdir); + new PDU2Handler(objects::PDU2_HANDLER, objects::CSP_COM_IF, pdu2CspCookie, pdu2Fdir); - auto acuFdir = new GomspacePowerFdir(commonObjects::ACU_HANDLER); + auto acuFdir = new GomspacePowerFdir(objects::ACU_HANDLER); ACUHandler* acuhandler = - new ACUHandler(commonObjects::ACU_HANDLER, systemObjects::CSP_COM_IF, acuCspCookie, acuFdir); - auto pcduHandler = new PCDUHandler(commonObjects::PCDU_HANDLER, 50); + new ACUHandler(objects::ACU_HANDLER, objects::CSP_COM_IF, acuCspCookie, acuFdir); + auto pcduHandler = new PCDUHandler(objects::PCDU_HANDLER, 50); /** * Setting PCDU devices to mode normal immediately after start up because PCDU is always @@ -204,7 +204,7 @@ void ObjectFactory::createRadSensorComponent(LinuxLibgpioIF* gpioComIF) { using namespace gpio; GpioCookie* gpioCookieRadSensor = new GpioCookie; std::stringstream consumer; - consumer << "0x" << std::hex << commonObjects::RAD_SENSOR; + consumer << "0x" << std::hex << objects::RAD_SENSOR; GpiodRegularByLineName* gpio = new GpiodRegularByLineName( q7s::gpioNames::RAD_SENSOR_CHIP_SELECT, consumer.str(), Direction::OUT, Levels::HIGH); gpioCookieRadSensor->addGpio(gpioIds::CS_RAD_SENSOR, gpio); @@ -217,7 +217,7 @@ void ObjectFactory::createRadSensorComponent(LinuxLibgpioIF* gpioComIF) { new SpiCookie(addresses::RAD_SENSOR, gpioIds::CS_RAD_SENSOR, RAD_SENSOR::READ_SIZE, spi::DEFAULT_MAX_1227_MODE, spi::DEFAULT_MAX_1227_SPEED); spiCookieRadSensor->setMutexParams(MutexIF::TimeoutType::WAITING, spi::RAD_SENSOR_CS_TIMEOUT); - auto radSensor = new RadiationSensorHandler(commonObjects::RAD_SENSOR, systemObjects::SPI_MAIN_COM_IF, + auto radSensor = new RadiationSensorHandler(objects::RAD_SENSOR, objects::SPI_MAIN_COM_IF, spiCookieRadSensor, gpioComIF); static_cast(radSensor); // The radiation sensor ADC is powered by the 5V stack connector which should always be on @@ -236,95 +236,95 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComI std::stringstream consumer; GpiodRegularByLineName* gpio = nullptr; - consumer << "0x" << std::hex << commonObjects::GYRO_0_ADIS_HANDLER; + consumer << "0x" << std::hex << objects::GYRO_0_ADIS_HANDLER; gpio = new GpiodRegularByLineName(q7s::gpioNames::GYRO_0_ADIS_CS, consumer.str(), Direction::OUT, Levels::HIGH); gpioCookieAcsBoard->addGpio(gpioIds::GYRO_0_ADIS_CS, gpio); consumer.str(""); - consumer << "0x" << std::hex << commonObjects::GYRO_1_L3G_HANDLER; + consumer << "0x" << std::hex << objects::GYRO_1_L3G_HANDLER; gpio = new GpiodRegularByLineName(q7s::gpioNames::GYRO_1_L3G_CS, consumer.str(), Direction::OUT, Levels::HIGH); gpioCookieAcsBoard->addGpio(gpioIds::GYRO_1_L3G_CS, gpio); consumer.str(""); - consumer << "0x" << std::hex << commonObjects::GYRO_2_ADIS_HANDLER; + consumer << "0x" << std::hex << objects::GYRO_2_ADIS_HANDLER; gpio = new GpiodRegularByLineName(q7s::gpioNames::GYRO_2_ADIS_CS, consumer.str(), Direction::OUT, Levels::HIGH); gpioCookieAcsBoard->addGpio(gpioIds::GYRO_2_ADIS_CS, gpio); consumer.str(""); - consumer << "0x" << std::hex << commonObjects::GYRO_3_L3G_HANDLER; + consumer << "0x" << std::hex << objects::GYRO_3_L3G_HANDLER; gpio = new GpiodRegularByLineName(q7s::gpioNames::GYRO_3_L3G_CS, consumer.str(), Direction::OUT, Levels::HIGH); gpioCookieAcsBoard->addGpio(gpioIds::GYRO_3_L3G_CS, gpio); consumer.str(""); - consumer << "0x" << std::hex << commonObjects::MGM_0_LIS3_HANDLER; + consumer << "0x" << std::hex << objects::MGM_0_LIS3_HANDLER; gpio = new GpiodRegularByLineName(q7s::gpioNames::MGM_0_CS, consumer.str(), Direction::OUT, Levels::HIGH); gpioCookieAcsBoard->addGpio(gpioIds::MGM_0_LIS3_CS, gpio); consumer.str(""); - consumer << "0x" << std::hex << commonObjects::MGM_1_RM3100_HANDLER; + consumer << "0x" << std::hex << objects::MGM_1_RM3100_HANDLER; gpio = new GpiodRegularByLineName(q7s::gpioNames::MGM_1_CS, consumer.str(), Direction::OUT, Levels::HIGH); gpioCookieAcsBoard->addGpio(gpioIds::MGM_1_RM3100_CS, gpio); consumer.str(""); - consumer << "0x" << std::hex << commonObjects::MGM_2_LIS3_HANDLER; + consumer << "0x" << std::hex << objects::MGM_2_LIS3_HANDLER; gpio = new GpiodRegularByLineName(q7s::gpioNames::MGM_2_CS, consumer.str(), Direction::OUT, Levels::HIGH); gpioCookieAcsBoard->addGpio(gpioIds::MGM_2_LIS3_CS, gpio); consumer.str(""); - consumer << "0x" << std::hex << commonObjects::MGM_3_RM3100_HANDLER; + consumer << "0x" << std::hex << objects::MGM_3_RM3100_HANDLER; gpio = new GpiodRegularByLineName(q7s::gpioNames::MGM_3_CS, consumer.str(), Direction::OUT, Levels::HIGH); gpioCookieAcsBoard->addGpio(gpioIds::MGM_3_RM3100_CS, gpio); consumer.str(""); - consumer << "0x" << std::hex << commonObjects::GPS_CONTROLLER; + consumer << "0x" << std::hex << objects::GPS_CONTROLLER; // GNSS reset pins are active low gpio = new GpiodRegularByLineName(q7s::gpioNames::RESET_GNSS_0, consumer.str(), Direction::OUT, Levels::HIGH); gpioCookieAcsBoard->addGpio(gpioIds::GNSS_0_NRESET, gpio); consumer.str(""); - consumer << "0x" << std::hex << commonObjects::GPS_CONTROLLER; + consumer << "0x" << std::hex << objects::GPS_CONTROLLER; gpio = new GpiodRegularByLineName(q7s::gpioNames::RESET_GNSS_1, consumer.str(), Direction::OUT, Levels::HIGH); gpioCookieAcsBoard->addGpio(gpioIds::GNSS_1_NRESET, gpio); consumer.str(""); - consumer << "0x" << std::hex << commonObjects::GYRO_0_ADIS_HANDLER; + consumer << "0x" << std::hex << objects::GYRO_0_ADIS_HANDLER; // Enable pins must be pulled low for regular operations gpio = new GpiodRegularByLineName(q7s::gpioNames::GYRO_0_ENABLE, consumer.str(), Direction::OUT, Levels::LOW); gpioCookieAcsBoard->addGpio(gpioIds::GYRO_0_ENABLE, gpio); consumer.str(""); - consumer << "0x" << std::hex << commonObjects::GYRO_2_ADIS_HANDLER; + consumer << "0x" << std::hex << objects::GYRO_2_ADIS_HANDLER; gpio = new GpiodRegularByLineName(q7s::gpioNames::GYRO_2_ENABLE, consumer.str(), Direction::OUT, Levels::LOW); gpioCookieAcsBoard->addGpio(gpioIds::GYRO_2_ENABLE, gpio); // Enable pins for GNSS consumer.str(""); - consumer << "0x" << std::hex << commonObjects::GPS_CONTROLLER; + consumer << "0x" << std::hex << objects::GPS_CONTROLLER; gpio = new GpiodRegularByLineName(q7s::gpioNames::GNSS_0_ENABLE, consumer.str(), Direction::OUT, Levels::LOW); gpioCookieAcsBoard->addGpio(gpioIds::GNSS_0_ENABLE, gpio); consumer.str(""); - consumer << "0x" << std::hex << commonObjects::GPS_CONTROLLER; + consumer << "0x" << std::hex << objects::GPS_CONTROLLER; gpio = new GpiodRegularByLineName(q7s::gpioNames::GNSS_1_ENABLE, consumer.str(), Direction::OUT, Levels::LOW); gpioCookieAcsBoard->addGpio(gpioIds::GNSS_1_ENABLE, gpio); // Select pin. 0 for GPS side A, 1 for GPS side B consumer.str(""); - consumer << "0x" << std::hex << commonObjects::GPS_CONTROLLER; + consumer << "0x" << std::hex << objects::GPS_CONTROLLER; gpio = new GpiodRegularByLineName(q7s::gpioNames::GNSS_SELECT, consumer.str(), Direction::OUT, Levels::LOW); gpioCookieAcsBoard->addGpio(gpioIds::GNSS_SELECT, gpio); @@ -337,9 +337,9 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComI SpiCookie* spiCookie = new SpiCookie(addresses::MGM_0_LIS3, gpioIds::MGM_0_LIS3_CS, MGMLIS3MDL::MAX_BUFFER_SIZE, spi::DEFAULT_LIS3_MODE, spi::DEFAULT_LIS3_SPEED); - auto mgmLis3Handler = new MgmLIS3MDLHandler(commonObjects::MGM_0_LIS3_HANDLER, systemObjects::SPI_MAIN_COM_IF, + auto mgmLis3Handler = new MgmLIS3MDLHandler(objects::MGM_0_LIS3_HANDLER, objects::SPI_MAIN_COM_IF, spiCookie, spi::LIS3_TRANSITION_DELAY); - fdir = new AcsBoardFdir(commonObjects::MGM_0_LIS3_HANDLER); + fdir = new AcsBoardFdir(objects::MGM_0_LIS3_HANDLER); mgmLis3Handler->setCustomFdir(fdir); static_cast(mgmLis3Handler); #if OBSW_TEST_ACS == 1 @@ -353,11 +353,11 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComI new SpiCookie(addresses::MGM_1_RM3100, gpioIds::MGM_1_RM3100_CS, RM3100::MAX_BUFFER_SIZE, spi::DEFAULT_RM3100_MODE, spi::DEFAULT_RM3100_SPEED); auto mgmRm3100Handler = - new MgmRM3100Handler(commonObjects::MGM_1_RM3100_HANDLER, systemObjects::SPI_MAIN_COM_IF, spiCookie, + new MgmRM3100Handler(objects::MGM_1_RM3100_HANDLER, objects::SPI_MAIN_COM_IF, spiCookie, spi::RM3100_TRANSITION_DELAY); - fdir = new AcsBoardFdir(commonObjects::MGM_1_RM3100_HANDLER); + fdir = new AcsBoardFdir(objects::MGM_1_RM3100_HANDLER); mgmRm3100Handler->setCustomFdir(fdir); - mgmRm3100Handler->setParent(commonObjects::ACS_BOARD_ASS); + mgmRm3100Handler->setParent(objects::ACS_BOARD_ASS); static_cast(mgmRm3100Handler); #if OBSW_TEST_ACS == 1 mgmRm3100Handler->setStartUpImmediately(); @@ -369,11 +369,11 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComI spiCookie = new SpiCookie(addresses::MGM_2_LIS3, gpioIds::MGM_2_LIS3_CS, MGMLIS3MDL::MAX_BUFFER_SIZE, spi::DEFAULT_LIS3_MODE, spi::DEFAULT_LIS3_SPEED); - mgmLis3Handler = new MgmLIS3MDLHandler(commonObjects::MGM_2_LIS3_HANDLER, systemObjects::SPI_MAIN_COM_IF, + mgmLis3Handler = new MgmLIS3MDLHandler(objects::MGM_2_LIS3_HANDLER, objects::SPI_MAIN_COM_IF, spiCookie, spi::LIS3_TRANSITION_DELAY); - fdir = new AcsBoardFdir(commonObjects::MGM_2_LIS3_HANDLER); + fdir = new AcsBoardFdir(objects::MGM_2_LIS3_HANDLER); mgmLis3Handler->setCustomFdir(fdir); - mgmLis3Handler->setParent(commonObjects::ACS_BOARD_ASS); + mgmLis3Handler->setParent(objects::ACS_BOARD_ASS); static_cast(mgmLis3Handler); #if OBSW_TEST_ACS == 1 mgmLis3Handler->setStartUpImmediately(); @@ -385,11 +385,11 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComI spiCookie = new SpiCookie(addresses::MGM_3_RM3100, gpioIds::MGM_3_RM3100_CS, RM3100::MAX_BUFFER_SIZE, spi::DEFAULT_RM3100_MODE, spi::DEFAULT_RM3100_SPEED); - mgmRm3100Handler = new MgmRM3100Handler(commonObjects::MGM_3_RM3100_HANDLER, systemObjects::SPI_MAIN_COM_IF, + mgmRm3100Handler = new MgmRM3100Handler(objects::MGM_3_RM3100_HANDLER, objects::SPI_MAIN_COM_IF, spiCookie, spi::RM3100_TRANSITION_DELAY); - fdir = new AcsBoardFdir(commonObjects::MGM_3_RM3100_HANDLER); + fdir = new AcsBoardFdir(objects::MGM_3_RM3100_HANDLER); mgmRm3100Handler->setCustomFdir(fdir); - mgmRm3100Handler->setParent(commonObjects::ACS_BOARD_ASS); + mgmRm3100Handler->setParent(objects::ACS_BOARD_ASS); #if OBSW_TEST_ACS == 1 mgmRm3100Handler->setStartUpImmediately(); mgmRm3100Handler->setToGoToNormalMode(true); @@ -403,11 +403,11 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComI new SpiCookie(addresses::GYRO_0_ADIS, gpioIds::GYRO_0_ADIS_CS, ADIS1650X::MAXIMUM_REPLY_SIZE, spi::DEFAULT_ADIS16507_MODE, spi::DEFAULT_ADIS16507_SPEED); auto adisHandler = - new GyroADIS1650XHandler(commonObjects::GYRO_0_ADIS_HANDLER, systemObjects::SPI_MAIN_COM_IF, spiCookie, + new GyroADIS1650XHandler(objects::GYRO_0_ADIS_HANDLER, objects::SPI_MAIN_COM_IF, spiCookie, ADIS1650X::Type::ADIS16505); - fdir = new AcsBoardFdir(commonObjects::GYRO_0_ADIS_HANDLER); + fdir = new AcsBoardFdir(objects::GYRO_0_ADIS_HANDLER); adisHandler->setCustomFdir(fdir); - adisHandler->setParent(commonObjects::ACS_BOARD_ASS); + adisHandler->setParent(objects::ACS_BOARD_ASS); static_cast(adisHandler); #if OBSW_TEST_ACS == 1 adisHandler->setStartUpImmediately(); @@ -420,10 +420,10 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComI spiCookie = new SpiCookie(addresses::GYRO_1_L3G, gpioIds::GYRO_1_L3G_CS, L3GD20H::MAX_BUFFER_SIZE, spi::DEFAULT_L3G_MODE, spi::DEFAULT_L3G_SPEED); auto gyroL3gHandler = new GyroHandlerL3GD20H( - commonObjects::GYRO_1_L3G_HANDLER, systemObjects::SPI_MAIN_COM_IF, spiCookie, spi::L3G_TRANSITION_DELAY); - fdir = new AcsBoardFdir(commonObjects::GYRO_1_L3G_HANDLER); + objects::GYRO_1_L3G_HANDLER, objects::SPI_MAIN_COM_IF, spiCookie, spi::L3G_TRANSITION_DELAY); + fdir = new AcsBoardFdir(objects::GYRO_1_L3G_HANDLER); gyroL3gHandler->setCustomFdir(fdir); - gyroL3gHandler->setParent(commonObjects::ACS_BOARD_ASS); + gyroL3gHandler->setParent(objects::ACS_BOARD_ASS); static_cast(gyroL3gHandler); #if OBSW_TEST_ACS == 1 gyroL3gHandler->setStartUpImmediately(); @@ -436,11 +436,11 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComI spiCookie = new SpiCookie(addresses::GYRO_2_ADIS, gpioIds::GYRO_2_ADIS_CS, ADIS1650X::MAXIMUM_REPLY_SIZE, spi::DEFAULT_ADIS16507_MODE, spi::DEFAULT_ADIS16507_SPEED); - adisHandler = new GyroADIS1650XHandler(commonObjects::GYRO_2_ADIS_HANDLER, systemObjects::SPI_MAIN_COM_IF, + adisHandler = new GyroADIS1650XHandler(objects::GYRO_2_ADIS_HANDLER, objects::SPI_MAIN_COM_IF, spiCookie, ADIS1650X::Type::ADIS16505); - fdir = new AcsBoardFdir(commonObjects::GYRO_2_ADIS_HANDLER); + fdir = new AcsBoardFdir(objects::GYRO_2_ADIS_HANDLER); adisHandler->setCustomFdir(fdir); - adisHandler->setParent(commonObjects::ACS_BOARD_ASS); + adisHandler->setParent(objects::ACS_BOARD_ASS); #if OBSW_TEST_ACS == 1 adisHandler->setStartUpImmediately(); adisHandler->setToGoToNormalModeImmediately(); @@ -448,11 +448,11 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComI // Gyro 3 Side B spiCookie = new SpiCookie(addresses::GYRO_3_L3G, gpioIds::GYRO_3_L3G_CS, L3GD20H::MAX_BUFFER_SIZE, spi::DEFAULT_L3G_MODE, spi::DEFAULT_L3G_SPEED); - gyroL3gHandler = new GyroHandlerL3GD20H(commonObjects::GYRO_3_L3G_HANDLER, systemObjects::SPI_MAIN_COM_IF, + gyroL3gHandler = new GyroHandlerL3GD20H(objects::GYRO_3_L3G_HANDLER, objects::SPI_MAIN_COM_IF, spiCookie, spi::L3G_TRANSITION_DELAY); - fdir = new AcsBoardFdir(commonObjects::GYRO_3_L3G_HANDLER); + fdir = new AcsBoardFdir(objects::GYRO_3_L3G_HANDLER); gyroL3gHandler->setCustomFdir(fdir); - gyroL3gHandler->setParent(commonObjects::ACS_BOARD_ASS); + gyroL3gHandler->setParent(objects::ACS_BOARD_ASS); #if OBSW_TEST_ACS == 1 gyroL3gHandler->setStartUpImmediately(); gyroL3gHandler->setToGoToNormalMode(true); @@ -467,14 +467,14 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComI RESET_ARGS_GNSS.gpioComIF = gpioComIF; RESET_ARGS_GNSS.waitPeriodMs = 100; auto gpsCtrl = - new GPSHyperionLinuxController(commonObjects::GPS_CONTROLLER, objects::NO_OBJECT, debugGps); + new GPSHyperionLinuxController(objects::GPS_CONTROLLER, objects::NO_OBJECT, debugGps); gpsCtrl->setResetPinTriggerFunction(gps::triggerGpioResetPin, &RESET_ARGS_GNSS); AcsBoardHelper acsBoardHelper = AcsBoardHelper( - commonObjects::MGM_0_LIS3_HANDLER, commonObjects::MGM_1_RM3100_HANDLER, commonObjects::MGM_2_LIS3_HANDLER, - commonObjects::MGM_3_RM3100_HANDLER, commonObjects::GYRO_0_ADIS_HANDLER, commonObjects::GYRO_1_L3G_HANDLER, - commonObjects::GYRO_2_ADIS_HANDLER, commonObjects::GYRO_3_L3G_HANDLER, commonObjects::GPS_CONTROLLER); - auto acsAss = new AcsBoardAssembly(commonObjects::ACS_BOARD_ASS, objects::NO_OBJECT, pwrSwitcher, + 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); + auto acsAss = new AcsBoardAssembly(objects::ACS_BOARD_ASS, objects::NO_OBJECT, pwrSwitcher, acsBoardHelper, gpioComIF); static_cast(acsAss); #endif /* OBSW_ADD_ACS_HANDLERS == 1 */ @@ -487,7 +487,7 @@ void ObjectFactory::createHeaterComponents(GpioIF* gpioIF, PowerSwitchIF* pwrSwi GpiodRegularByLineName* gpio = nullptr; std::stringstream consumer; - consumer << "0x" << std::hex << commonObjects::HEATER_HANDLER; + consumer << "0x" << std::hex << objects::HEATER_HANDLER; /* Pin H2-11 on stack connector */ gpio = new GpiodRegularByLineName(q7s::gpioNames::HEATER_0, consumer.str(), Direction::OUT, Levels::LOW); @@ -525,17 +525,17 @@ void ObjectFactory::createHeaterComponents(GpioIF* gpioIF, PowerSwitchIF* pwrSwi gpioIF->addGpios(heaterGpiosCookie); HeaterHelper helper({{ - {new HealthDevice(commonObjects::HEATER_0_PLOC_PROC_BRD, MessageQueueIF::NO_QUEUE), + {new HealthDevice(objects::HEATER_0_PLOC_PROC_BRD, MessageQueueIF::NO_QUEUE), gpioIds::HEATER_0}, - {new HealthDevice(commonObjects::HEATER_1_PCDU_BRD, MessageQueueIF::NO_QUEUE), gpioIds::HEATER_1}, - {new HealthDevice(commonObjects::HEATER_2_ACS_BRD, MessageQueueIF::NO_QUEUE), gpioIds::HEATER_2}, - {new HealthDevice(commonObjects::HEATER_3_OBC_BRD, MessageQueueIF::NO_QUEUE), gpioIds::HEATER_3}, - {new HealthDevice(commonObjects::HEATER_4_CAMERA, MessageQueueIF::NO_QUEUE), gpioIds::HEATER_4}, - {new HealthDevice(commonObjects::HEATER_5_STR, MessageQueueIF::NO_QUEUE), gpioIds::HEATER_5}, - {new HealthDevice(commonObjects::HEATER_6_DRO, MessageQueueIF::NO_QUEUE), gpioIds::HEATER_6}, - {new HealthDevice(commonObjects::HEATER_7_HPA, MessageQueueIF::NO_QUEUE), gpioIds::HEATER_7}, + {new HealthDevice(objects::HEATER_1_PCDU_BRD, MessageQueueIF::NO_QUEUE), gpioIds::HEATER_1}, + {new HealthDevice(objects::HEATER_2_ACS_BRD, MessageQueueIF::NO_QUEUE), gpioIds::HEATER_2}, + {new HealthDevice(objects::HEATER_3_OBC_BRD, MessageQueueIF::NO_QUEUE), gpioIds::HEATER_3}, + {new HealthDevice(objects::HEATER_4_CAMERA, MessageQueueIF::NO_QUEUE), gpioIds::HEATER_4}, + {new HealthDevice(objects::HEATER_5_STR, MessageQueueIF::NO_QUEUE), gpioIds::HEATER_5}, + {new HealthDevice(objects::HEATER_6_DRO, MessageQueueIF::NO_QUEUE), gpioIds::HEATER_6}, + {new HealthDevice(objects::HEATER_7_HPA, MessageQueueIF::NO_QUEUE), gpioIds::HEATER_7}, }}); - new HeaterHandler(commonObjects::HEATER_HANDLER, gpioIF, helper, pwrSwitcher, + new HeaterHandler(objects::HEATER_HANDLER, gpioIF, helper, pwrSwitcher, pcdu::Switches::PDU2_CH3_TCS_BOARD_HEATER_IN_8V); } @@ -545,7 +545,7 @@ void ObjectFactory::createSolarArrayDeploymentComponents() { GpiodRegularByLineName* gpio = nullptr; std::stringstream consumer; - consumer << "0x" << std::hex << commonObjects::SOLAR_ARRAY_DEPL_HANDLER; + consumer << "0x" << std::hex << objects::SOLAR_ARRAY_DEPL_HANDLER; gpio = new GpiodRegularByLineName(q7s::gpioNames::SA_DPL_PIN_0, consumer.str(), Direction::OUT, Levels::LOW); solarArrayDeplCookie->addGpio(gpioIds::DEPLSA1, gpio); @@ -554,21 +554,21 @@ void ObjectFactory::createSolarArrayDeploymentComponents() { solarArrayDeplCookie->addGpio(gpioIds::DEPLSA2, gpio); // TODO: Find out burn time. For now set to 1000 ms. - new SolarArrayDeploymentHandler(commonObjects::SOLAR_ARRAY_DEPL_HANDLER, systemObjects::GPIO_IF, - solarArrayDeplCookie, commonObjects::PCDU_HANDLER, + new SolarArrayDeploymentHandler(objects::SOLAR_ARRAY_DEPL_HANDLER, objects::GPIO_IF, + solarArrayDeplCookie, objects::PCDU_HANDLER, pcdu::Switches::PDU2_CH5_DEPLOYMENT_MECHANISM_8V, gpioIds::DEPLSA1, gpioIds::DEPLSA2, 1000); } void ObjectFactory::createSyrlinksComponents(PowerSwitchIF* pwrSwitcher) { UartCookie* syrlinksUartCookie = - new UartCookie(commonObjects::SYRLINKS_HK_HANDLER, q7s::UART_SYRLINKS_DEV, uart::SYRLINKS_BAUD, + new UartCookie(objects::SYRLINKS_HK_HANDLER, q7s::UART_SYRLINKS_DEV, uart::SYRLINKS_BAUD, syrlinks::MAX_REPLY_SIZE, UartModes::NON_CANONICAL); syrlinksUartCookie->setParityEven(); - auto syrlinksFdir = new SyrlinksFdir(commonObjects::SYRLINKS_HK_HANDLER); + auto syrlinksFdir = new SyrlinksFdir(objects::SYRLINKS_HK_HANDLER); auto syrlinksHandler = - new SyrlinksHkHandler(commonObjects::SYRLINKS_HK_HANDLER, systemObjects::UART_COM_IF, syrlinksUartCookie, + new SyrlinksHkHandler(objects::SYRLINKS_HK_HANDLER, objects::UART_COM_IF, syrlinksUartCookie, pcdu::PDU1_CH1_SYRLINKS_12V, syrlinksFdir); syrlinksHandler->setPowerSwitcher(pwrSwitcher); #if OBSW_DEBUG_SYRLINKS == 1 @@ -580,34 +580,34 @@ void ObjectFactory::createPayloadComponents(LinuxLibgpioIF* gpioComIF) { using namespace gpio; std::stringstream consumer; #if OBSW_ADD_PLOC_MPSOC == 1 - consumer << "0x" << std::hex << commonObjects::PLOC_MPSOC_HANDLER; + consumer << "0x" << std::hex << objects::PLOC_MPSOC_HANDLER; auto gpioConfigMPSoC = new GpiodRegularByLineName(q7s::gpioNames::ENABLE_MPSOC_UART, consumer.str(), Direction::OUT, Levels::HIGH); auto mpsocGpioCookie = new GpioCookie; mpsocGpioCookie->addGpio(gpioIds::ENABLE_MPSOC_UART, gpioConfigMPSoC); gpioChecker(gpioComIF->addGpios(mpsocGpioCookie), "PLOC MPSoC"); auto mpsocCookie = - new UartCookie(commonObjects::PLOC_MPSOC_HANDLER, q7s::UART_PLOC_MPSOC_DEV, uart::PLOC_MPSOC_BAUD, + new UartCookie(objects::PLOC_MPSOC_HANDLER, q7s::UART_PLOC_MPSOC_DEV, uart::PLOC_MPSOC_BAUD, mpsoc::MAX_REPLY_SIZE, UartModes::NON_CANONICAL); mpsocCookie->setNoFixedSizeReply(); - auto plocMpsocHelper = new PlocMPSoCHelper(commonObjects::PLOC_MPSOC_HELPER); - new PlocMPSoCHandler(commonObjects::PLOC_MPSOC_HANDLER, systemObjects::UART_COM_IF, mpsocCookie, + auto plocMpsocHelper = new PlocMPSoCHelper(objects::PLOC_MPSOC_HELPER); + new PlocMPSoCHandler(objects::PLOC_MPSOC_HANDLER, objects::UART_COM_IF, mpsocCookie, plocMpsocHelper, Gpio(gpioIds::ENABLE_MPSOC_UART, gpioComIF), - commonObjects::PLOC_SUPERVISOR_HANDLER); + objects::PLOC_SUPERVISOR_HANDLER); #endif /* OBSW_ADD_PLOC_MPSOC == 1 */ #if OBSW_ADD_PLOC_SUPERVISOR == 1 - consumer << "0x" << std::hex << commonObjects::PLOC_SUPERVISOR_HANDLER; + consumer << "0x" << std::hex << objects::PLOC_SUPERVISOR_HANDLER; auto gpioConfigSupv = new GpiodRegularByLineName(q7s::gpioNames::ENABLE_SUPV_UART, consumer.str(), Direction::OUT, Levels::LOW); auto supvGpioCookie = new GpioCookie; supvGpioCookie->addGpio(gpioIds::ENABLE_SUPV_UART, gpioConfigSupv); gpioComIF->addGpios(supvGpioCookie); auto supervisorCookie = - new UartCookie(commonObjects::PLOC_SUPERVISOR_HANDLER, q7s::UART_PLOC_SUPERVSIOR_DEV, + new UartCookie(objects::PLOC_SUPERVISOR_HANDLER, q7s::UART_PLOC_SUPERVSIOR_DEV, uart::PLOC_SUPV_BAUD, supv::MAX_PACKET_SIZE * 20, UartModes::NON_CANONICAL); supervisorCookie->setNoFixedSizeReply(); - auto supvHelper = new PlocSupvHelper(commonObjects::PLOC_SUPERVISOR_HELPER); - new PlocSupervisorHandler(commonObjects::PLOC_SUPERVISOR_HANDLER, systemObjects::UART_COM_IF, + auto supvHelper = new PlocSupvHelper(objects::PLOC_SUPERVISOR_HELPER); + new PlocSupervisorHandler(objects::PLOC_SUPERVISOR_HANDLER, objects::UART_COM_IF, supervisorCookie, Gpio(gpioIds::ENABLE_SUPV_UART, gpioComIF), pcdu::PDU1_CH6_PLOC_12V, supvHelper); #endif /* OBSW_ADD_PLOC_SUPERVISOR == 1 */ @@ -637,22 +637,22 @@ void ObjectFactory::createReactionWheelComponents(LinuxLibgpioIF* gpioComIF, std::stringstream consumer; GpiodRegularByLineName* gpio = nullptr; - consumer << "0x" << std::hex << commonObjects::RW1; + consumer << "0x" << std::hex << objects::RW1; gpio = new GpiodRegularByLineName(q7s::gpioNames::EN_RW_1, consumer.str(), Direction::OUT, Levels::LOW); gpioCookieRw->addGpio(gpioIds::EN_RW1, gpio); consumer.str(""); - consumer << "0x" << std::hex << commonObjects::RW2; + consumer << "0x" << std::hex << objects::RW2; gpio = new GpiodRegularByLineName(q7s::gpioNames::EN_RW_2, consumer.str(), Direction::OUT, Levels::LOW); gpioCookieRw->addGpio(gpioIds::EN_RW2, gpio); consumer.str(""); - consumer << "0x" << std::hex << commonObjects::RW3; + consumer << "0x" << std::hex << objects::RW3; gpio = new GpiodRegularByLineName(q7s::gpioNames::EN_RW_3, consumer.str(), Direction::OUT, Levels::LOW); gpioCookieRw->addGpio(gpioIds::EN_RW3, gpio); consumer.str(""); - consumer << "0x" << std::hex << commonObjects::RW4; + consumer << "0x" << std::hex << objects::RW4; gpio = new GpiodRegularByLineName(q7s::gpioNames::EN_RW_4, consumer.str(), Direction::OUT, Levels::LOW); gpioCookieRw->addGpio(gpioIds::EN_RW4, gpio); @@ -666,7 +666,7 @@ void ObjectFactory::createReactionWheelComponents(LinuxLibgpioIF* gpioComIF, {addresses::RW3, gpioIds::CS_RW3}, {addresses::RW4, gpioIds::CS_RW4}}}; std::array rwCookies = {}; - std::array rwIds = {commonObjects::RW1, commonObjects::RW2, commonObjects::RW3, commonObjects::RW4}; + std::array rwIds = {objects::RW1, objects::RW2, objects::RW3, objects::RW4}; std::array rwGpioIds = {gpioIds::EN_RW1, gpioIds::EN_RW2, gpioIds::EN_RW3, gpioIds::EN_RW4}; std::array rws = {}; @@ -674,7 +674,7 @@ void ObjectFactory::createReactionWheelComponents(LinuxLibgpioIF* gpioComIF, rwCookies[idx] = new SpiCookie(rwCookieParams[idx].first, rwCookieParams[idx].second, RwDefinitions::MAX_REPLY_SIZE, spi::RW_MODE, spi::RW_SPEED, &rwSpiCallback::spiCallback, nullptr); - rws[idx] = new RwHandler(rwIds[idx], systemObjects::SPI_RW_COM_IF, rwCookies[idx], gpioComIF, + rws[idx] = new RwHandler(rwIds[idx], objects::SPI_RW_COM_IF, rwCookies[idx], gpioComIF, rwGpioIds[idx]); rwCookies[idx]->setCallbackArgs(rws[idx]); #if OBSW_TEST_RW == 1 @@ -686,7 +686,7 @@ void ObjectFactory::createReactionWheelComponents(LinuxLibgpioIF* gpioComIF, } RwHelper rwHelper(rwIds); - auto* rwAss = new RwAssembly(commonObjects::RW_ASS, objects::NO_OBJECT, pwrSwitcher, + auto* rwAss = new RwAssembly(objects::RW_ASS, objects::NO_OBJECT, pwrSwitcher, pcdu::Switches::PDU2_CH2_RW_5V, rwHelper); static_cast(rwAss); #endif /* OBSW_ADD_RW == 1 */ @@ -741,14 +741,14 @@ void ObjectFactory::createCcsdsComponents(LinuxLibgpioIF* gpioComIF) { new PapbVcInterface(gpioComIF, gpioIds::VC3_PAPB_BUSY, gpioIds::VC3_PAPB_EMPTY, q7s::UIO_PTME, q7s::uiomapids::PTME_VC3); // Creating ptme object and adding virtual channel interfaces - Ptme* ptme = new Ptme(commonObjects::PTME); + Ptme* ptme = new Ptme(objects::PTME); ptme->addVcInterface(ccsds::VC0, vc0); ptme->addVcInterface(ccsds::VC1, vc1); ptme->addVcInterface(ccsds::VC2, vc2); ptme->addVcInterface(ccsds::VC3, vc3); AxiPtmeConfig* axiPtmeConfig = - new AxiPtmeConfig(commonObjects::AXI_PTME_CONFIG, q7s::UIO_PTME, q7s::uiomapids::PTME_CONFIG); - PtmeConfig* ptmeConfig = new PtmeConfig(commonObjects::PTME_CONFIG, axiPtmeConfig); + new AxiPtmeConfig(objects::AXI_PTME_CONFIG, q7s::UIO_PTME, q7s::uiomapids::PTME_CONFIG); + PtmeConfig* ptmeConfig = new PtmeConfig(objects::PTME_CONFIG, axiPtmeConfig); #if OBSW_ENABLE_SYRLINKS_TRANSMIT_TIMEOUT == 1 // Set to high value when not sending via syrlinks static const uint32_t TRANSMITTER_TIMEOUT = 86400000; // 1 day @@ -756,26 +756,26 @@ void ObjectFactory::createCcsdsComponents(LinuxLibgpioIF* gpioComIF) { static const uint32_t TRANSMITTER_TIMEOUT = 900000; // 15 minutes #endif CCSDSHandler* ccsdsHandler = new CCSDSHandler( - commonObjects::CCSDS_HANDLER, commonObjects::PTME, commonObjects::CCSDS_PACKET_DISTRIBUTOR, ptmeConfig, + objects::CCSDS_HANDLER, objects::PTME, objects::CCSDS_PACKET_DISTRIBUTOR, ptmeConfig, gpioComIF, gpioIds::RS485_EN_TX_CLOCK, gpioIds::RS485_EN_TX_DATA, TRANSMITTER_TIMEOUT); VirtualChannel* vc = nullptr; - vc = new VirtualChannel(ccsds::VC0, common::VC0_QUEUE_SIZE, commonObjects::CCSDS_HANDLER); + vc = new VirtualChannel(ccsds::VC0, common::VC0_QUEUE_SIZE, objects::CCSDS_HANDLER); ccsdsHandler->addVirtualChannel(ccsds::VC0, vc); - vc = new VirtualChannel(ccsds::VC1, common::VC1_QUEUE_SIZE, commonObjects::CCSDS_HANDLER); + vc = new VirtualChannel(ccsds::VC1, common::VC1_QUEUE_SIZE, objects::CCSDS_HANDLER); ccsdsHandler->addVirtualChannel(ccsds::VC1, vc); - vc = new VirtualChannel(ccsds::VC2, common::VC2_QUEUE_SIZE, commonObjects::CCSDS_HANDLER); + vc = new VirtualChannel(ccsds::VC2, common::VC2_QUEUE_SIZE, objects::CCSDS_HANDLER); ccsdsHandler->addVirtualChannel(ccsds::VC2, vc); - vc = new VirtualChannel(ccsds::VC3, common::VC3_QUEUE_SIZE, commonObjects::CCSDS_HANDLER); + vc = new VirtualChannel(ccsds::VC3, common::VC3_QUEUE_SIZE, objects::CCSDS_HANDLER); ccsdsHandler->addVirtualChannel(ccsds::VC3, vc); GpioCookie* gpioCookiePdec = new GpioCookie; consumer.str(""); - consumer << "0x" << std::hex << commonObjects::PDEC_HANDLER; + consumer << "0x" << std::hex << objects::PDEC_HANDLER; // GPIO also low after linux boot (specified by device-tree) gpio = new GpiodRegularByLineName(q7s::gpioNames::PDEC_RESET, consumer.str(), Direction::OUT, Levels::LOW); gpioCookiePdec->addGpio(gpioIds::PDEC_RESET, gpio); gpioChecker(gpioComIF->addGpios(gpioCookiePdec), "PDEC"); - new PdecHandler(commonObjects::PDEC_HANDLER, commonObjects::CCSDS_HANDLER, gpioComIF, gpioIds::PDEC_RESET, + new PdecHandler(objects::PDEC_HANDLER, objects::CCSDS_HANDLER, gpioComIF, gpioIds::PDEC_RESET, q7s::UIO_PDEC_CONFIG_MEMORY, q7s::UIO_PDEC_RAM, q7s::UIO_PDEC_REGISTERS); GpioCookie* gpioRS485Chip = new GpioCookie; gpio = new GpiodRegularByLineName(q7s::gpioNames::RS485_EN_TX_CLOCK, "RS485 Transceiver", @@ -842,7 +842,7 @@ void ObjectFactory::createPlPcduComponents(LinuxLibgpioIF* gpioComIF, SpiComIF* spi::DEFAULT_MAX_1227_MODE, spi::PL_PCDU_MAX_1227_SPEED); // Create device handler components auto plPcduHandler = new PayloadPcduHandler( - commonObjects::PLPCDU_HANDLER, systemObjects::SPI_MAIN_COM_IF, spiCookie, gpioComIF, + objects::PLPCDU_HANDLER, objects::SPI_MAIN_COM_IF, spiCookie, gpioComIF, SdCardManager::instance(), pwrSwitcher, pcdu::Switches::PDU2_CH1_PL_PCDU_BATT_0_14V8, pcdu::Switches::PDU2_CH6_PL_PCDU_BATT_1_14V8, false); spiCookie->setCallbackMode(PayloadPcduHandler::extConvAsTwoCallback, plPcduHandler); @@ -858,26 +858,26 @@ void ObjectFactory::createPlPcduComponents(LinuxLibgpioIF* gpioComIF, SpiComIF* } void ObjectFactory::createTestComponents(LinuxLibgpioIF* gpioComIF) { - new Q7STestTask(systemObjects::TEST_TASK); + new Q7STestTask(objects::TEST_TASK); #if OBSW_ADD_SPI_TEST_CODE == 1 - new SpiTestClass(commonObjects::SPI_TEST, gpioComIF); + new SpiTestClass(objects::SPI_TEST, gpioComIF); #endif #if OBSW_ADD_I2C_TEST_CODE == 1 - new I2cTestClass(commonObjects::I2C_TEST, q7s::I2C_DEFAULT_DEV); + new I2cTestClass(objects::I2C_TEST, q7s::I2C_DEFAULT_DEV); #endif #if OBSW_ADD_UART_TEST_CODE == 1 - new UartTestClass(commonObjects::UART_TEST); + new UartTestClass(objects::UART_TEST); #endif } void ObjectFactory::createStrComponents(PowerSwitchIF* pwrSwitcher) { UartCookie* starTrackerCookie = - new UartCookie(commonObjects::STAR_TRACKER, q7s::UART_STAR_TRACKER_DEV, uart::STAR_TRACKER_BAUD, + new UartCookie(objects::STAR_TRACKER, q7s::UART_STAR_TRACKER_DEV, uart::STAR_TRACKER_BAUD, startracker::MAX_FRAME_SIZE * 2 + 2, UartModes::NON_CANONICAL); starTrackerCookie->setNoFixedSizeReply(); - StrHelper* strHelper = new StrHelper(commonObjects::STR_HELPER); + StrHelper* strHelper = new StrHelper(objects::STR_HELPER); auto starTracker = - new StarTrackerHandler(commonObjects::STAR_TRACKER, systemObjects::UART_COM_IF, starTrackerCookie, + new StarTrackerHandler(objects::STAR_TRACKER, objects::UART_COM_IF, starTrackerCookie, strHelper, pcdu::PDU1_CH2_STAR_TRACKER_5V); starTracker->setPowerSwitcher(pwrSwitcher); } @@ -885,7 +885,7 @@ void ObjectFactory::createStrComponents(PowerSwitchIF* pwrSwitcher) { void ObjectFactory::createImtqComponents(PowerSwitchIF* pwrSwitcher) { I2cCookie* imtqI2cCookie = new I2cCookie(addresses::IMTQ, IMTQ::MAX_REPLY_SIZE, q7s::I2C_DEFAULT_DEV); - auto imtqHandler = new IMTQHandler(commonObjects::IMTQ_HANDLER, systemObjects::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(imtqHandler); @@ -901,7 +901,7 @@ void ObjectFactory::createImtqComponents(PowerSwitchIF* pwrSwitcher) { void ObjectFactory::createBpxBatteryComponent() { I2cCookie* bpxI2cCookie = new I2cCookie(addresses::BPX_BATTERY, 100, q7s::I2C_DEFAULT_DEV); BpxBatteryHandler* bpxHandler = - new BpxBatteryHandler(commonObjects::BPX_BATT_HANDLER, systemObjects::I2C_COM_IF, bpxI2cCookie); + new BpxBatteryHandler(objects::BPX_BATT_HANDLER, objects::I2C_COM_IF, bpxI2cCookie); bpxHandler->setStartUpImmediately(); bpxHandler->setToGoToNormalMode(true); #if OBSW_DEBUG_BPX_BATT == 1 @@ -910,8 +910,8 @@ void ObjectFactory::createBpxBatteryComponent() { } void ObjectFactory::createMiscComponents() { - new FileSystemHandler(commonObjects::FILE_SYSTEM_HANDLER); - new PlocMemoryDumper(commonObjects::PLOC_MEMORY_DUMPER); + new FileSystemHandler(objects::FILE_SYSTEM_HANDLER); + new PlocMemoryDumper(objects::PLOC_MEMORY_DUMPER); } void ObjectFactory::testAcsBrdAss(AcsBoardAssembly* acsAss) { diff --git a/bsp_q7s/fmObjectFactory.cpp b/bsp_q7s/fmObjectFactory.cpp index f208364d..acce5dfb 100644 --- a/bsp_q7s/fmObjectFactory.cpp +++ b/bsp_q7s/fmObjectFactory.cpp @@ -22,7 +22,7 @@ void ObjectFactory::produce(void* args) { SpiComIF* spiRwComIF = nullptr; createCommunicationInterfaces(&gpioComIF, &uartComIF, &spiMainComIF, &i2cComIF, &spiRwComIF); createTmpComponents(); - new CoreController(commonObjects::CORE_CONTROLLER); + new CoreController(objects::CORE_CONTROLLER); gpioCallbacks::disableAllDecoder(gpioComIF); createPcduComponents(gpioComIF, &pwrSwitcher); diff --git a/bsp_q7s/memory/FileSystemHandler.cpp b/bsp_q7s/memory/FileSystemHandler.cpp index 9a95edf1..33849fbe 100644 --- a/bsp_q7s/memory/FileSystemHandler.cpp +++ b/bsp_q7s/memory/FileSystemHandler.cpp @@ -102,7 +102,7 @@ void FileSystemHandler::fileSystemCheckup() { MessageQueueId_t FileSystemHandler::getCommandQueue() const { return mq->getId(); } ReturnValue_t FileSystemHandler::initialize() { - coreCtrl = ObjectManager::instance()->get(commonObjects::CORE_CONTROLLER); + coreCtrl = ObjectManager::instance()->get(objects::CORE_CONTROLLER); if (coreCtrl == nullptr) { sif::error << "FileSystemHandler::initialize: Could not retrieve core controller handle" << std::endl; diff --git a/bsp_q7s/memory/SdCardManager.cpp b/bsp_q7s/memory/SdCardManager.cpp index c1f87d16..cfd4f490 100644 --- a/bsp_q7s/memory/SdCardManager.cpp +++ b/bsp_q7s/memory/SdCardManager.cpp @@ -18,7 +18,7 @@ SdCardManager* SdCardManager::INSTANCE = nullptr; -SdCardManager::SdCardManager() : SystemObject(commonObjects::SDC_MANAGER), cmdExecutor(256) { +SdCardManager::SdCardManager() : SystemObject(objects::SDC_MANAGER), cmdExecutor(256) { mutex = MutexFactory::instance()->createMutex(); ReturnValue_t result = mutex->lockMutex(); if (result != RETURN_OK) { diff --git a/common/config/commonObjects.h b/common/config/commonObjects.h index f1024b72..e0efbce7 100644 --- a/common/config/commonObjects.h +++ b/common/config/commonObjects.h @@ -2,84 +2,84 @@ #define COMMON_CONFIG_COMMONOBJECTS_H_ #include -#include -FSFW_ENUM(commonObjects, uint32_t, - /* First Byte 0x50-0x52 reserved for PUS Services **/ -((CCSDS_PACKET_DISTRIBUTOR, 0x50000100, "CCSDS_PACKET_DISTRIBUTOR")) -((PUS_PACKET_DISTRIBUTOR, 0x50000200, "PUS_PACKET_DISTRIBUTOR")) -((TMTC_BRIDGE, 0x50000300, "TMTC_BRIDGE")) -((TMTC_POLLING_TASK, 0x50000400, "TMTC_POLLING_TASK")) -((FILE_SYSTEM_HANDLER, 0x50000500, "FILE_SYSTEM_HANDLER")) -((SDC_MANAGER, 0x50000550, "SDC_MANAGER")) -((PTME, 0x50000600, "PTME")) -((PDEC_HANDLER, 0x50000700, "PDEC_HANDLER")) -((CCSDS_HANDLER, 0x50000800, "CCSDS_HANDLER")) +namespace objects { +enum commonObjects : uint32_t { + /* First Byte 0x50-0x52 reserved for PUS Services **/ + CCSDS_PACKET_DISTRIBUTOR = 0x50000100, + PUS_PACKET_DISTRIBUTOR = 0x50000200, + TMTC_BRIDGE = 0x50000300, + TMTC_POLLING_TASK = 0x50000400, + FILE_SYSTEM_HANDLER = 0x50000500, + SDC_MANAGER = 0x50000550, + PTME = 0x50000600, + PDEC_HANDLER = 0x50000700, + CCSDS_HANDLER = 0x50000800, /* 0x43 ('C') for Controllers */ -((THERMAL_CONTROLLER, 0x43400001, "THERMAL_CONTROLLER")) -((ACS_CONTROLLER, 0x43000002, "ACS_CONTROLLER")) -((CORE_CONTROLLER, 0x43000003, "CORE_CONTROLLER")) + THERMAL_CONTROLLER = 0x43400001, + ACS_CONTROLLER = 0x43000002, + CORE_CONTROLLER = 0x43000003, /* 0x44 ('D') for device handlers */ -((MGM_0_LIS3_HANDLER, 0x44120006, "MGM_0_LIS3_HANDLER")) -((MGM_1_RM3100_HANDLER, 0x44120107, "MGM_1_RM3100_HANDLER")) -((MGM_2_LIS3_HANDLER, 0x44120208, "MGM_2_LIS3_HANDLER")) -((MGM_3_RM3100_HANDLER, 0x44120309, "MGM_3_RM3100_HANDLER")) -((GYRO_0_ADIS_HANDLER, 0x44120010, "GYRO_0_ADIS_HANDLER")) -((GYRO_1_L3G_HANDLER, 0x44120111, "GYRO_1_L3G_HANDLER")) -((GYRO_2_ADIS_HANDLER, 0x44120212, "GYRO_2_ADIS_HANDLER")) -((GYRO_3_L3G_HANDLER, 0x44120313, "GYRO_3_L3G_HANDLER")) -((RW1, 0x44120047, "RW1")) -((RW2, 0x44120148, "RW2")) -((RW3, 0x44120249, "RW3")) -((RW4, 0x44120350, "RW4")) -((STAR_TRACKER, 0x44130001, "STAR_TRACKER")) -((GPS_CONTROLLER, 0x44130045, "GPS_CONTROLLER")) + MGM_0_LIS3_HANDLER = 0x44120006, + MGM_1_RM3100_HANDLER = 0x44120107, + MGM_2_LIS3_HANDLER = 0x44120208, + MGM_3_RM3100_HANDLER = 0x44120309, + GYRO_0_ADIS_HANDLER = 0x44120010, + GYRO_1_L3G_HANDLER = 0x44120111, + GYRO_2_ADIS_HANDLER = 0x44120212, + GYRO_3_L3G_HANDLER = 0x44120313, + RW1 = 0x44120047, + RW2 = 0x44120148, + RW3 = 0x44120249, + RW4 = 0x44120350, + STAR_TRACKER = 0x44130001, + GPS_CONTROLLER = 0x44130045, -((IMTQ_HANDLER, 0x44140014, "IMTQ_HANDLER")) -((TMP1075_HANDLER_1, 0x44420004, "TMP1075_HANDLER_1")) -((TMP1075_HANDLER_2, 0x44420005, "TMP1075_HANDLER_2")) -((PCDU_HANDLER, 0x442000A1, "PCDU_HANDLER")) -((P60DOCK_HANDLER, 0x44250000, "P60DOCK_HANDLER")) -((PDU1_HANDLER, 0x44250001, "PDU1_HANDLER")) -((PDU2_HANDLER, 0x44250002, "PDU2_HANDLER")) -((ACU_HANDLER, 0x44250003, "ACU_HANDLER")) -((BPX_BATT_HANDLER, 0x44260000, "BPX_BATT_HANDLER")) -((PLPCDU_HANDLER, 0x44300000, "PLPCDU_HANDLER")) -((RAD_SENSOR, 0x443200A5, "RAD_SENSOR")) -((PLOC_UPDATER, 0x44330000, "PLOC_UPDATER")) -((PLOC_MEMORY_DUMPER, 0x44330001, "PLOC_MEMORY_DUMPER")) -((STR_HELPER, 0x44330002, "STR_HELPER")) -((PLOC_MPSOC_HELPER, 0x44330003, "PLOC_MPSOC_HELPER")) -((AXI_PTME_CONFIG, 0x44330004, "AXI_PTME_CONFIG")) -((PTME_CONFIG, 0x44330005, "PTME_CONFIG")) -((PLOC_MPSOC_HANDLER, 0x44330015, "PLOC_MPSOC_HANDLER")) -((PLOC_SUPERVISOR_HANDLER, 0x44330016, "PLOC_SUPERVISOR_HANDLER")) -((PLOC_SUPERVISOR_HELPER, 0x44330017, "PLOC_SUPERVISOR_HELPER")) -((SOLAR_ARRAY_DEPL_HANDLER, 0x444100A2, "SOLAR_ARRAY_DEPL_HANDLER")) -((HEATER_HANDLER, 0x444100A4, "HEATER_HANDLER")) + IMTQ_HANDLER = 0x44140014, + TMP1075_HANDLER_1 = 0x44420004, + TMP1075_HANDLER_2 = 0x44420005, + PCDU_HANDLER = 0x442000A1, + P60DOCK_HANDLER = 0x44250000, + PDU1_HANDLER = 0x44250001, + PDU2_HANDLER = 0x44250002, + ACU_HANDLER = 0x44250003, + BPX_BATT_HANDLER = 0x44260000, + PLPCDU_HANDLER = 0x44300000, + RAD_SENSOR = 0x443200A5, + PLOC_UPDATER = 0x44330000, + PLOC_MEMORY_DUMPER = 0x44330001, + STR_HELPER = 0x44330002, + PLOC_MPSOC_HELPER = 0x44330003, + AXI_PTME_CONFIG = 0x44330004, + PTME_CONFIG = 0x44330005, + PLOC_MPSOC_HANDLER = 0x44330015, + PLOC_SUPERVISOR_HANDLER = 0x44330016, + PLOC_SUPERVISOR_HELPER = 0x44330017, + SOLAR_ARRAY_DEPL_HANDLER = 0x444100A2, + HEATER_HANDLER = 0x444100A4, /** * Not yet specified which pt1000 will measure which device/location in the satellite. * Therefore object ids are named according to the IC naming of the RTDs in the schematic. */ -((RTD_0_IC3_PLOC_HEATSPREADER, 0x44420016, "RTD_0_IC3_PLOC_HEATSPREADER")) -((RTD_1_IC4_PLOC_MISSIONBOARD, 0x44420017, "RTD_1_IC4_PLOC_MISSIONBOARD")) -((RTD_2_IC5_4K_CAMERA, 0x44420018, "RTD_2_IC5_4K_CAMERA")) -((RTD_3_IC6_DAC_HEATSPREADER, 0x44420019, "RTD_3_IC6_DAC_HEATSPREADER")) -((RTD_4_IC7_STARTRACKER, 0x44420020, "RTD_4_IC7_STARTRACKER")) -((RTD_5_IC8_RW1_MX_MY, 0x44420021, "RTD_5_IC8_RW1_MX_MY")) -((RTD_6_IC9_DRO, 0x44420022, "RTD_6_IC9_DRO")) -((RTD_7_IC10_SCEX, 0x44420023, "RTD_7_IC10_SCEX")) -((RTD_8_IC11_X8, 0x44420024, "RTD_8_IC11_X8")) -((RTD_9_IC12_HPA, 0x44420025, "RTD_9_IC12_HPA")) -((RTD_10_IC13_PL_TX, 0x44420026, "RTD_10_IC13_PL_TX")) -((RTD_11_IC14_MPA, 0x44420027, "RTD_11_IC14_MPA")) -((RTD_12_IC15_ACU, 0x44420028, "RTD_12_IC15_ACU")) -((RTD_13_IC16_PLPCDU_HEATSPREADER, 0x44420029, "RTD_13_IC16_PLPCDU_HEATSPREADER")) -((RTD_14_IC17_TCS_BOARD, 0x44420030, "RTD_14_IC17_TCS_BOARD")) -((RTD_15_IC18_IMTQ, 0x44420031, "RTD_15_IC18_IMTQ")) + RTD_0_IC3_PLOC_HEATSPREADER = 0x44420016, + RTD_1_IC4_PLOC_MISSIONBOARD = 0x44420017, + RTD_2_IC5_4K_CAMERA = 0x44420018, + RTD_3_IC6_DAC_HEATSPREADER = 0x44420019, + RTD_4_IC7_STARTRACKER = 0x44420020, + RTD_5_IC8_RW1_MX_MY = 0x44420021, + RTD_6_IC9_DRO = 0x44420022, + RTD_7_IC10_SCEX = 0x44420023, + RTD_8_IC11_X8 = 0x44420024, + RTD_9_IC12_HPA = 0x44420025, + RTD_10_IC13_PL_TX = 0x44420026, + RTD_11_IC14_MPA = 0x44420027, + RTD_12_IC15_ACU = 0x44420028, + RTD_13_IC16_PLPCDU_HEATSPREADER = 0x44420029, + RTD_14_IC17_TCS_BOARD = 0x44420030, + RTD_15_IC18_IMTQ = 0x44420031, // Name convention for SUS devices // SUS___LOC_XYZ_PT_ @@ -87,41 +87,42 @@ FSFW_ENUM(commonObjects, uint32_t, // PT: Pointing // N/R: Nominal/Redundant // F/M/B: Forward/Middle/Backwards -((SUS_0_N_LOC_XFYFZM_PT_XF, 0x44120032, "SUS_0_N_LOC_XFYFZM_PT_XF")) -((SUS_6_R_LOC_XFYBZM_PT_XF, 0x44120038, "SUS_6_R_LOC_XFYBZM_PT_XF")) + SUS_0_N_LOC_XFYFZM_PT_XF = 0x44120032, + SUS_6_R_LOC_XFYBZM_PT_XF = 0x44120038, -((SUS_1_N_LOC_XBYFZM_PT_XB, 0x44120033, "SUS_1_N_LOC_XBYFZM_PT_XB")) -((SUS_7_R_LOC_XBYBZM_PT_XB, 0x44120039, "SUS_7_R_LOC_XBYBZM_PT_XB")) + SUS_1_N_LOC_XBYFZM_PT_XB = 0x44120033, + SUS_7_R_LOC_XBYBZM_PT_XB = 0x44120039, -((SUS_2_N_LOC_XFYBZB_PT_YB, 0x44120034, "SUS_2_N_LOC_XFYBZB_PT_YB")) -((SUS_8_R_LOC_XBYBZB_PT_YB, 0x44120040, "SUS_8_R_LOC_XBYBZB_PT_YB")) + SUS_2_N_LOC_XFYBZB_PT_YB = 0x44120034, + SUS_8_R_LOC_XBYBZB_PT_YB = 0x44120040, -((SUS_3_N_LOC_XFYBZF_PT_YF, 0x44120035, "SUS_3_N_LOC_XFYBZF_PT_YF")) -((SUS_9_R_LOC_XBYBZB_PT_YF, 0x44120041, "SUS_9_R_LOC_XBYBZB_PT_YF")) + SUS_3_N_LOC_XFYBZF_PT_YF = 0x44120035, + SUS_9_R_LOC_XBYBZB_PT_YF = 0x44120041, -((SUS_4_N_LOC_XMYFZF_PT_ZF, 0x44120036, "SUS_4_N_LOC_XMYFZF_PT_ZF")) -((SUS_10_N_LOC_XMYBZF_PT_ZF, 0x44120042, "SUS_10_N_LOC_XMYBZF_PT_ZF")) + SUS_4_N_LOC_XMYFZF_PT_ZF = 0x44120036, + SUS_10_N_LOC_XMYBZF_PT_ZF = 0x44120042, -((SUS_5_N_LOC_XFYMZB_PT_ZB, 0x44120037, "SUS_5_N_LOC_XFYMZB_PT_ZB")) -((SUS_11_R_LOC_XBYMZB_PT_ZB, 0x44120043, "SUS_11_R_LOC_XBYMZB_PT_ZB")) + SUS_5_N_LOC_XFYMZB_PT_ZB = 0x44120037, + SUS_11_R_LOC_XBYMZB_PT_ZB = 0x44120043, -((SYRLINKS_HK_HANDLER, 0x445300A3, "SYRLINKS_HK_HANDLER")) + SYRLINKS_HK_HANDLER = 0x445300A3, // 0x60 for other stuff -((HEATER_0_PLOC_PROC_BRD, 0x60000000, "HEATER_0_PLOC_PROC_BRD")) -((HEATER_1_PCDU_BRD, 0x60000001, "HEATER_1_PCDU_BRD")) -((HEATER_2_ACS_BRD, 0x60000002, "HEATER_2_ACS_BRD")) -((HEATER_3_OBC_BRD, 0x60000003, "HEATER_3_OBC_BRD")) -((HEATER_4_CAMERA, 0x60000004, "HEATER_4_CAMERA")) -((HEATER_5_STR, 0x60000005, "HEATER_5_STR")) -((HEATER_6_DRO, 0x60000006, "HEATER_6_DRO")) -((HEATER_7_HPA, 0x60000007, "HEATER_7_HPA")) + HEATER_0_PLOC_PROC_BRD = 0x60000000, + HEATER_1_PCDU_BRD = 0x60000001, + HEATER_2_ACS_BRD = 0x60000002, + HEATER_3_OBC_BRD = 0x60000003, + HEATER_4_CAMERA = 0x60000004, + HEATER_5_STR = 0x60000005, + HEATER_6_DRO = 0x60000006, + HEATER_7_HPA = 0x60000007, // 0x73 ('s') for assemblies and system/subsystem components -((ACS_BOARD_ASS, 0x73000001, "ACS_BOARD_ASS")) -((SUS_BOARD_ASS, 0x73000002, "SUS_BOARD_ASS")) -((TCS_BOARD_ASS, 0x73000003, "TCS_BOARD_ASS")) -((RW_ASS, 0x73000004, "RW_ASS")) -) + ACS_BOARD_ASS = 0x73000001, + SUS_BOARD_ASS = 0x73000002, + TCS_BOARD_ASS = 0x73000003, + RW_ASS = 0x73000004 +}; +} #endif /* COMMON_CONFIG_COMMONOBJECTS_H_ */ diff --git a/dummies/SusDummy.cpp b/dummies/SusDummy.cpp index 95af2aa5..58b2ac8d 100644 --- a/dummies/SusDummy.cpp +++ b/dummies/SusDummy.cpp @@ -6,18 +6,18 @@ #include SusDummy::SusDummy() - : ExtendedControllerBase(commonObjects::SUS_0_N_LOC_XFYFZM_PT_XF, objects::NO_OBJECT), susSet(this) { - ObjectManager::instance()->insert(commonObjects::SUS_6_R_LOC_XFYBZM_PT_XF, this); - ObjectManager::instance()->insert(commonObjects::SUS_1_N_LOC_XBYFZM_PT_XB, this); - ObjectManager::instance()->insert(commonObjects::SUS_7_R_LOC_XBYBZM_PT_XB, this); - ObjectManager::instance()->insert(commonObjects::SUS_2_N_LOC_XFYBZB_PT_YB, this); - ObjectManager::instance()->insert(commonObjects::SUS_8_R_LOC_XBYBZB_PT_YB, this); - ObjectManager::instance()->insert(commonObjects::SUS_3_N_LOC_XFYBZF_PT_YF, this); - ObjectManager::instance()->insert(commonObjects::SUS_9_R_LOC_XBYBZB_PT_YF, this); - ObjectManager::instance()->insert(commonObjects::SUS_4_N_LOC_XMYFZF_PT_ZF, this); - ObjectManager::instance()->insert(commonObjects::SUS_10_N_LOC_XMYBZF_PT_ZF, this); - ObjectManager::instance()->insert(commonObjects::SUS_5_N_LOC_XFYMZB_PT_ZB, this); - ObjectManager::instance()->insert(commonObjects::SUS_11_R_LOC_XBYMZB_PT_ZB, this); + : ExtendedControllerBase(objects::SUS_0_N_LOC_XFYFZM_PT_XF, objects::NO_OBJECT), susSet(this) { + ObjectManager::instance()->insert(objects::SUS_6_R_LOC_XFYBZM_PT_XF, this); + ObjectManager::instance()->insert(objects::SUS_1_N_LOC_XBYFZM_PT_XB, this); + ObjectManager::instance()->insert(objects::SUS_7_R_LOC_XBYBZM_PT_XB, this); + ObjectManager::instance()->insert(objects::SUS_2_N_LOC_XFYBZB_PT_YB, this); + ObjectManager::instance()->insert(objects::SUS_8_R_LOC_XBYBZB_PT_YB, this); + ObjectManager::instance()->insert(objects::SUS_3_N_LOC_XFYBZF_PT_YF, this); + ObjectManager::instance()->insert(objects::SUS_9_R_LOC_XBYBZB_PT_YF, this); + ObjectManager::instance()->insert(objects::SUS_4_N_LOC_XMYFZF_PT_ZF, this); + ObjectManager::instance()->insert(objects::SUS_10_N_LOC_XMYBZF_PT_ZF, this); + ObjectManager::instance()->insert(objects::SUS_5_N_LOC_XFYMZB_PT_ZB, this); + ObjectManager::instance()->insert(objects::SUS_11_R_LOC_XBYMZB_PT_ZB, this); } ReturnValue_t SusDummy::initialize() { diff --git a/dummies/TemperatureSensorsDummy.cpp b/dummies/TemperatureSensorsDummy.cpp index 53a35028..129b20bd 100644 --- a/dummies/TemperatureSensorsDummy.cpp +++ b/dummies/TemperatureSensorsDummy.cpp @@ -6,25 +6,25 @@ #include TemperatureSensorsDummy::TemperatureSensorsDummy() - : ExtendedControllerBase(commonObjects::RTD_0_IC3_PLOC_HEATSPREADER, objects::NO_OBJECT), + : ExtendedControllerBase(objects::RTD_0_IC3_PLOC_HEATSPREADER, objects::NO_OBJECT), max31865Set(this, MAX31865::MAX31865_SET_ID) { - ObjectManager::instance()->insert(commonObjects::RTD_1_IC4_PLOC_MISSIONBOARD, this); - ObjectManager::instance()->insert(commonObjects::RTD_2_IC5_4K_CAMERA, this); - ObjectManager::instance()->insert(commonObjects::RTD_3_IC6_DAC_HEATSPREADER, this); - ObjectManager::instance()->insert(commonObjects::RTD_4_IC7_STARTRACKER, this); - ObjectManager::instance()->insert(commonObjects::RTD_5_IC8_RW1_MX_MY, this); - ObjectManager::instance()->insert(commonObjects::RTD_6_IC9_DRO, this); - ObjectManager::instance()->insert(commonObjects::RTD_7_IC10_SCEX, this); - ObjectManager::instance()->insert(commonObjects::RTD_8_IC11_X8, this); - ObjectManager::instance()->insert(commonObjects::RTD_9_IC12_HPA, this); - ObjectManager::instance()->insert(commonObjects::RTD_10_IC13_PL_TX, this); - ObjectManager::instance()->insert(commonObjects::RTD_11_IC14_MPA, this); - ObjectManager::instance()->insert(commonObjects::RTD_12_IC15_ACU, this); - ObjectManager::instance()->insert(commonObjects::RTD_13_IC16_PLPCDU_HEATSPREADER, this); - ObjectManager::instance()->insert(commonObjects::RTD_14_IC17_TCS_BOARD, this); - ObjectManager::instance()->insert(commonObjects::RTD_15_IC18_IMTQ, this); - ObjectManager::instance()->insert(commonObjects::TMP1075_HANDLER_1, this); - ObjectManager::instance()->insert(commonObjects::TMP1075_HANDLER_2, this); + ObjectManager::instance()->insert(objects::RTD_1_IC4_PLOC_MISSIONBOARD, this); + ObjectManager::instance()->insert(objects::RTD_2_IC5_4K_CAMERA, this); + ObjectManager::instance()->insert(objects::RTD_3_IC6_DAC_HEATSPREADER, this); + ObjectManager::instance()->insert(objects::RTD_4_IC7_STARTRACKER, this); + ObjectManager::instance()->insert(objects::RTD_5_IC8_RW1_MX_MY, this); + ObjectManager::instance()->insert(objects::RTD_6_IC9_DRO, this); + ObjectManager::instance()->insert(objects::RTD_7_IC10_SCEX, this); + ObjectManager::instance()->insert(objects::RTD_8_IC11_X8, this); + ObjectManager::instance()->insert(objects::RTD_9_IC12_HPA, this); + ObjectManager::instance()->insert(objects::RTD_10_IC13_PL_TX, this); + ObjectManager::instance()->insert(objects::RTD_11_IC14_MPA, this); + ObjectManager::instance()->insert(objects::RTD_12_IC15_ACU, this); + ObjectManager::instance()->insert(objects::RTD_13_IC16_PLPCDU_HEATSPREADER, this); + ObjectManager::instance()->insert(objects::RTD_14_IC17_TCS_BOARD, this); + ObjectManager::instance()->insert(objects::RTD_15_IC18_IMTQ, this); + ObjectManager::instance()->insert(objects::TMP1075_HANDLER_1, this); + ObjectManager::instance()->insert(objects::TMP1075_HANDLER_2, this); } ReturnValue_t TemperatureSensorsDummy::initialize() { diff --git a/linux/ObjectFactory.cpp b/linux/ObjectFactory.cpp index d14cb747..494b0baa 100644 --- a/linux/ObjectFactory.cpp +++ b/linux/ObjectFactory.cpp @@ -74,97 +74,97 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo SpiCookie* spiCookie = new SpiCookie(addresses::SUS_0, gpioIds::CS_SUS_0, SUS::MAX_CMD_SIZE, spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ); susHandlers[0] = - new SusHandler(commonObjects::SUS_0_N_LOC_XFYFZM_PT_XF, 0, systemObjects::SPI_MAIN_COM_IF, spiCookie); - fdir = new SusFdir(commonObjects::SUS_0_N_LOC_XFYFZM_PT_XF); - susHandlers[0]->setParent(commonObjects::SUS_BOARD_ASS); + new SusHandler(objects::SUS_0_N_LOC_XFYFZM_PT_XF, 0, objects::SPI_MAIN_COM_IF, spiCookie); + fdir = new SusFdir(objects::SUS_0_N_LOC_XFYFZM_PT_XF); + susHandlers[0]->setParent(objects::SUS_BOARD_ASS); susHandlers[0]->setCustomFdir(fdir); spiCookie = new SpiCookie(addresses::SUS_1, gpioIds::CS_SUS_1, SUS::MAX_CMD_SIZE, spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ); susHandlers[1] = - new SusHandler(commonObjects::SUS_1_N_LOC_XBYFZM_PT_XB, 1, systemObjects::SPI_MAIN_COM_IF, spiCookie); - fdir = new SusFdir(commonObjects::SUS_1_N_LOC_XBYFZM_PT_XB); - susHandlers[1]->setParent(commonObjects::SUS_BOARD_ASS); + new SusHandler(objects::SUS_1_N_LOC_XBYFZM_PT_XB, 1, objects::SPI_MAIN_COM_IF, spiCookie); + fdir = new SusFdir(objects::SUS_1_N_LOC_XBYFZM_PT_XB); + susHandlers[1]->setParent(objects::SUS_BOARD_ASS); susHandlers[1]->setCustomFdir(fdir); spiCookie = new SpiCookie(addresses::SUS_2, gpioIds::CS_SUS_2, SUS::MAX_CMD_SIZE, spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ); susHandlers[2] = - new SusHandler(commonObjects::SUS_2_N_LOC_XFYBZB_PT_YB, 2, systemObjects::SPI_MAIN_COM_IF, spiCookie); - fdir = new SusFdir(commonObjects::SUS_2_N_LOC_XFYBZB_PT_YB); - susHandlers[2]->setParent(commonObjects::SUS_BOARD_ASS); + new SusHandler(objects::SUS_2_N_LOC_XFYBZB_PT_YB, 2, objects::SPI_MAIN_COM_IF, spiCookie); + fdir = new SusFdir(objects::SUS_2_N_LOC_XFYBZB_PT_YB); + susHandlers[2]->setParent(objects::SUS_BOARD_ASS); susHandlers[2]->setCustomFdir(fdir); spiCookie = new SpiCookie(addresses::SUS_3, gpioIds::CS_SUS_3, SUS::MAX_CMD_SIZE, spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ); susHandlers[3] = - new SusHandler(commonObjects::SUS_3_N_LOC_XFYBZF_PT_YF, 3, systemObjects::SPI_MAIN_COM_IF, spiCookie); - fdir = new SusFdir(commonObjects::SUS_3_N_LOC_XFYBZF_PT_YF); - susHandlers[3]->setParent(commonObjects::SUS_BOARD_ASS); + new SusHandler(objects::SUS_3_N_LOC_XFYBZF_PT_YF, 3, objects::SPI_MAIN_COM_IF, spiCookie); + fdir = new SusFdir(objects::SUS_3_N_LOC_XFYBZF_PT_YF); + susHandlers[3]->setParent(objects::SUS_BOARD_ASS); susHandlers[3]->setCustomFdir(fdir); spiCookie = new SpiCookie(addresses::SUS_4, gpioIds::CS_SUS_4, SUS::MAX_CMD_SIZE, spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ); susHandlers[4] = - new SusHandler(commonObjects::SUS_4_N_LOC_XMYFZF_PT_ZF, 4, systemObjects::SPI_MAIN_COM_IF, spiCookie); - fdir = new SusFdir(commonObjects::SUS_4_N_LOC_XMYFZF_PT_ZF); - susHandlers[4]->setParent(commonObjects::SUS_BOARD_ASS); + new SusHandler(objects::SUS_4_N_LOC_XMYFZF_PT_ZF, 4, objects::SPI_MAIN_COM_IF, spiCookie); + fdir = new SusFdir(objects::SUS_4_N_LOC_XMYFZF_PT_ZF); + susHandlers[4]->setParent(objects::SUS_BOARD_ASS); susHandlers[4]->setCustomFdir(fdir); spiCookie = new SpiCookie(addresses::SUS_5, gpioIds::CS_SUS_5, SUS::MAX_CMD_SIZE, spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ); susHandlers[5] = - new SusHandler(commonObjects::SUS_5_N_LOC_XFYMZB_PT_ZB, 5, systemObjects::SPI_MAIN_COM_IF, spiCookie); - fdir = new SusFdir(commonObjects::SUS_5_N_LOC_XFYMZB_PT_ZB); - susHandlers[5]->setParent(commonObjects::SUS_BOARD_ASS); + new SusHandler(objects::SUS_5_N_LOC_XFYMZB_PT_ZB, 5, objects::SPI_MAIN_COM_IF, spiCookie); + fdir = new SusFdir(objects::SUS_5_N_LOC_XFYMZB_PT_ZB); + susHandlers[5]->setParent(objects::SUS_BOARD_ASS); susHandlers[5]->setCustomFdir(fdir); spiCookie = new SpiCookie(addresses::SUS_6, gpioIds::CS_SUS_6, SUS::MAX_CMD_SIZE, spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ); susHandlers[6] = - new SusHandler(commonObjects::SUS_6_R_LOC_XFYBZM_PT_XF, 6, systemObjects::SPI_MAIN_COM_IF, spiCookie); - fdir = new SusFdir(commonObjects::SUS_6_R_LOC_XFYBZM_PT_XF); - susHandlers[6]->setParent(commonObjects::SUS_BOARD_ASS); + new SusHandler(objects::SUS_6_R_LOC_XFYBZM_PT_XF, 6, objects::SPI_MAIN_COM_IF, spiCookie); + fdir = new SusFdir(objects::SUS_6_R_LOC_XFYBZM_PT_XF); + susHandlers[6]->setParent(objects::SUS_BOARD_ASS); susHandlers[6]->setCustomFdir(fdir); spiCookie = new SpiCookie(addresses::SUS_7, gpioIds::CS_SUS_7, SUS::MAX_CMD_SIZE, spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ); susHandlers[7] = - new SusHandler(commonObjects::SUS_7_R_LOC_XBYBZM_PT_XB, 7, systemObjects::SPI_MAIN_COM_IF, spiCookie); - fdir = new SusFdir(commonObjects::SUS_7_R_LOC_XBYBZM_PT_XB); - susHandlers[7]->setParent(commonObjects::SUS_BOARD_ASS); + new SusHandler(objects::SUS_7_R_LOC_XBYBZM_PT_XB, 7, objects::SPI_MAIN_COM_IF, spiCookie); + fdir = new SusFdir(objects::SUS_7_R_LOC_XBYBZM_PT_XB); + susHandlers[7]->setParent(objects::SUS_BOARD_ASS); susHandlers[7]->setCustomFdir(fdir); spiCookie = new SpiCookie(addresses::SUS_8, gpioIds::CS_SUS_8, SUS::MAX_CMD_SIZE, spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ); susHandlers[8] = - new SusHandler(commonObjects::SUS_8_R_LOC_XBYBZB_PT_YB, 8, systemObjects::SPI_MAIN_COM_IF, spiCookie); - fdir = new SusFdir(commonObjects::SUS_8_R_LOC_XBYBZB_PT_YB); - susHandlers[8]->setParent(commonObjects::SUS_BOARD_ASS); + new SusHandler(objects::SUS_8_R_LOC_XBYBZB_PT_YB, 8, objects::SPI_MAIN_COM_IF, spiCookie); + fdir = new SusFdir(objects::SUS_8_R_LOC_XBYBZB_PT_YB); + susHandlers[8]->setParent(objects::SUS_BOARD_ASS); susHandlers[8]->setCustomFdir(fdir); spiCookie = new SpiCookie(addresses::SUS_9, gpioIds::CS_SUS_9, SUS::MAX_CMD_SIZE, spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ); susHandlers[9] = - new SusHandler(commonObjects::SUS_9_R_LOC_XBYBZB_PT_YF, 9, systemObjects::SPI_MAIN_COM_IF, spiCookie); - fdir = new SusFdir(commonObjects::SUS_9_R_LOC_XBYBZB_PT_YF); - susHandlers[9]->setParent(commonObjects::SUS_BOARD_ASS); + new SusHandler(objects::SUS_9_R_LOC_XBYBZB_PT_YF, 9, objects::SPI_MAIN_COM_IF, spiCookie); + fdir = new SusFdir(objects::SUS_9_R_LOC_XBYBZB_PT_YF); + susHandlers[9]->setParent(objects::SUS_BOARD_ASS); susHandlers[9]->setCustomFdir(fdir); spiCookie = new SpiCookie(addresses::SUS_10, gpioIds::CS_SUS_10, SUS::MAX_CMD_SIZE, spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ); susHandlers[10] = - new SusHandler(commonObjects::SUS_10_N_LOC_XMYBZF_PT_ZF, 10, systemObjects::SPI_MAIN_COM_IF, spiCookie); - fdir = new SusFdir(commonObjects::SUS_10_N_LOC_XMYBZF_PT_ZF); - susHandlers[10]->setParent(commonObjects::SUS_BOARD_ASS); + new SusHandler(objects::SUS_10_N_LOC_XMYBZF_PT_ZF, 10, objects::SPI_MAIN_COM_IF, spiCookie); + fdir = new SusFdir(objects::SUS_10_N_LOC_XMYBZF_PT_ZF); + susHandlers[10]->setParent(objects::SUS_BOARD_ASS); susHandlers[10]->setCustomFdir(fdir); spiCookie = new SpiCookie(addresses::SUS_11, gpioIds::CS_SUS_11, SUS::MAX_CMD_SIZE, spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ); susHandlers[11] = - new SusHandler(commonObjects::SUS_11_R_LOC_XBYMZB_PT_ZB, 11, systemObjects::SPI_MAIN_COM_IF, spiCookie); - fdir = new SusFdir(commonObjects::SUS_11_R_LOC_XBYMZB_PT_ZB); - susHandlers[11]->setParent(commonObjects::SUS_BOARD_ASS); + new SusHandler(objects::SUS_11_R_LOC_XBYMZB_PT_ZB, 11, objects::SPI_MAIN_COM_IF, spiCookie); + fdir = new SusFdir(objects::SUS_11_R_LOC_XBYMZB_PT_ZB); + susHandlers[11]->setParent(objects::SUS_BOARD_ASS); susHandlers[11]->setCustomFdir(fdir); for (auto& sus : susHandlers) { @@ -179,15 +179,15 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo } } std::array susIds = { - commonObjects::SUS_0_N_LOC_XFYFZM_PT_XF, commonObjects::SUS_1_N_LOC_XBYFZM_PT_XB, - commonObjects::SUS_2_N_LOC_XFYBZB_PT_YB, commonObjects::SUS_3_N_LOC_XFYBZF_PT_YF, - commonObjects::SUS_4_N_LOC_XMYFZF_PT_ZF, commonObjects::SUS_5_N_LOC_XFYMZB_PT_ZB, - commonObjects::SUS_6_R_LOC_XFYBZM_PT_XF, commonObjects::SUS_7_R_LOC_XBYBZM_PT_XB, - commonObjects::SUS_8_R_LOC_XBYBZB_PT_YB, commonObjects::SUS_9_R_LOC_XBYBZB_PT_YF, - commonObjects::SUS_10_N_LOC_XMYBZF_PT_ZF, commonObjects::SUS_11_R_LOC_XBYMZB_PT_ZB}; + 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}; SusAssHelper susAssHelper = SusAssHelper(susIds); auto susAss = - new SusAssembly(commonObjects::SUS_BOARD_ASS, objects::NO_OBJECT, pwrSwitcher, susAssHelper); + new SusAssembly(objects::SUS_BOARD_ASS, objects::NO_OBJECT, pwrSwitcher, susAssHelper); static_cast(susAss); #endif /* OBSW_ADD_SUN_SENSORS == 1 */ } @@ -270,28 +270,28 @@ void ObjectFactory::createRtdComponents(std::string spiDev, GpioIF* gpioComIF, }}; // HSPD: Heatspreader std::array, NUM_RTDS> rtdInfos = {{ - {commonObjects::RTD_0_IC3_PLOC_HEATSPREADER, "RTD_0_PLOC_HSPD"}, - {commonObjects::RTD_1_IC4_PLOC_MISSIONBOARD, "RTD_1_PLOC_MISSIONBRD"}, - {commonObjects::RTD_2_IC5_4K_CAMERA, "RTD_2_4K_CAMERA"}, - {commonObjects::RTD_3_IC6_DAC_HEATSPREADER, "RTD_3_DAC_HSPD"}, - {commonObjects::RTD_4_IC7_STARTRACKER, "RTD_4_STARTRACKER"}, - {commonObjects::RTD_5_IC8_RW1_MX_MY, "RTD_5_RW1_MX_MY"}, - {commonObjects::RTD_6_IC9_DRO, "RTD_6_DRO"}, - {commonObjects::RTD_7_IC10_SCEX, "RTD_7_SCEX"}, - {commonObjects::RTD_8_IC11_X8, "RTD_8_X8"}, - {commonObjects::RTD_9_IC12_HPA, "RTD_9_HPA"}, - {commonObjects::RTD_10_IC13_PL_TX, "RTD_10_PL_TX,"}, - {commonObjects::RTD_11_IC14_MPA, "RTD_11_MPA"}, - {commonObjects::RTD_12_IC15_ACU, "RTD_12_ACU"}, - {commonObjects::RTD_13_IC16_PLPCDU_HEATSPREADER, "RTD_13_PLPCDU_HSPD"}, - {commonObjects::RTD_14_IC17_TCS_BOARD, "RTD_14_TCS_BOARD"}, - {commonObjects::RTD_15_IC18_IMTQ, "RTD_15_IMTQ"}, + {objects::RTD_0_IC3_PLOC_HEATSPREADER, "RTD_0_PLOC_HSPD"}, + {objects::RTD_1_IC4_PLOC_MISSIONBOARD, "RTD_1_PLOC_MISSIONBRD"}, + {objects::RTD_2_IC5_4K_CAMERA, "RTD_2_4K_CAMERA"}, + {objects::RTD_3_IC6_DAC_HEATSPREADER, "RTD_3_DAC_HSPD"}, + {objects::RTD_4_IC7_STARTRACKER, "RTD_4_STARTRACKER"}, + {objects::RTD_5_IC8_RW1_MX_MY, "RTD_5_RW1_MX_MY"}, + {objects::RTD_6_IC9_DRO, "RTD_6_DRO"}, + {objects::RTD_7_IC10_SCEX, "RTD_7_SCEX"}, + {objects::RTD_8_IC11_X8, "RTD_8_X8"}, + {objects::RTD_9_IC12_HPA, "RTD_9_HPA"}, + {objects::RTD_10_IC13_PL_TX, "RTD_10_PL_TX,"}, + {objects::RTD_11_IC14_MPA, "RTD_11_MPA"}, + {objects::RTD_12_IC15_ACU, "RTD_12_ACU"}, + {objects::RTD_13_IC16_PLPCDU_HEATSPREADER, "RTD_13_PLPCDU_HSPD"}, + {objects::RTD_14_IC17_TCS_BOARD, "RTD_14_TCS_BOARD"}, + {objects::RTD_15_IC18_IMTQ, "RTD_15_IMTQ"}, }}; std::array rtdCookies = {}; std::array rtds = {}; RtdFdir* rtdFdir = nullptr; // Create special low level reader communication interface - new Max31865RtdReader(systemObjects::SPI_RTD_COM_IF, comIF, gpioComIF); + new Max31865RtdReader(objects::SPI_RTD_COM_IF, comIF, gpioComIF); for (uint8_t idx = 0; idx < NUM_RTDS; idx++) { rtdCookies[idx] = new SpiCookie(cookieArgs[idx].first, cookieArgs[idx].second, MAX31865::MAX_REPLY_SIZE, spi::RTD_MODE, spi::RTD_SPEED); @@ -299,9 +299,9 @@ void ObjectFactory::createRtdComponents(std::string spiDev, GpioIF* gpioComIF, Max31865ReaderCookie* rtdLowLevelCookie = new Max31865ReaderCookie(rtdInfos[idx].first, idx, rtdInfos[idx].second, rtdCookies[idx]); rtds[idx] = - new Max31865EiveHandler(rtdInfos[idx].first, systemObjects::SPI_RTD_COM_IF, rtdLowLevelCookie); + new Max31865EiveHandler(rtdInfos[idx].first, objects::SPI_RTD_COM_IF, rtdLowLevelCookie); rtds[idx]->setDeviceInfo(idx, rtdInfos[idx].second); - rtds[idx]->setParent(commonObjects::TCS_BOARD_ASS); + rtds[idx]->setParent(objects::TCS_BOARD_ASS); rtdFdir = new RtdFdir(rtdInfos[idx].first); rtds[idx]->setCustomFdir(rtdFdir); #if OBSW_DEBUG_RTD == 1 @@ -315,17 +315,17 @@ void ObjectFactory::createRtdComponents(std::string spiDev, GpioIF* gpioComIF, TcsBoardHelper helper(rtdInfos); TcsBoardAssembly* tcsBoardAss = - new TcsBoardAssembly(commonObjects::TCS_BOARD_ASS, objects::NO_OBJECT, pwrSwitcher, + new TcsBoardAssembly(objects::TCS_BOARD_ASS, objects::NO_OBJECT, pwrSwitcher, pcdu::Switches::PDU1_CH0_TCS_BOARD_3V3, helper); static_cast(tcsBoardAss); #endif // OBSW_ADD_RTD_DEVICES == 1 } void ObjectFactory::createThermalController() { - new ThermalController(commonObjects::THERMAL_CONTROLLER, objects::NO_OBJECT); + new ThermalController(objects::THERMAL_CONTROLLER, objects::NO_OBJECT); } -void ObjectFactory::createAcsController() { new AcsController(commonObjects::ACS_CONTROLLER); } +void ObjectFactory::createAcsController() { new AcsController(objects::ACS_CONTROLLER); } void ObjectFactory::gpioChecker(ReturnValue_t result, std::string output) { if (result != HasReturnvaluesIF::RETURN_OK) { diff --git a/linux/devices/ploc/PlocMPSoCHandler.cpp b/linux/devices/ploc/PlocMPSoCHandler.cpp index ae5eb5a7..d775a083 100644 --- a/linux/devices/ploc/PlocMPSoCHandler.cpp +++ b/linux/devices/ploc/PlocMPSoCHandler.cpp @@ -317,7 +317,7 @@ ReturnValue_t PlocMPSoCHandler::initializeLocalDataPool(localpool::DataPool& loc void PlocMPSoCHandler::handleEvent(EventMessage* eventMessage) { object_id_t objectId = eventMessage->getReporter(); switch (objectId) { - case commonObjects::PLOC_MPSOC_HELPER: { + case objects::PLOC_MPSOC_HELPER: { plocMPSoCHelperExecuting = false; break; } diff --git a/linux/devices/ploc/PlocMemoryDumper.cpp b/linux/devices/ploc/PlocMemoryDumper.cpp index 792bc2b4..a6d9ebed 100644 --- a/linux/devices/ploc/PlocMemoryDumper.cpp +++ b/linux/devices/ploc/PlocMemoryDumper.cpp @@ -167,7 +167,7 @@ void PlocMemoryDumper::commandNextMramDump(ActionId_t dumpCommand) { MemoryParams params(tempStartAddress, tempEndAddress); result = - commandActionHelper.commandAction(commonObjects::PLOC_SUPERVISOR_HANDLER, dumpCommand, ¶ms); + commandActionHelper.commandAction(objects::PLOC_SUPERVISOR_HANDLER, dumpCommand, ¶ms); if (result != RETURN_OK) { sif::warning << "PlocMemoryDumper::commandNextMramDump: Failed to send mram dump command " << "with start address " << tempStartAddress << " and end address " diff --git a/linux/devices/ploc/PlocSupervisorHandler.cpp b/linux/devices/ploc/PlocSupervisorHandler.cpp index 523bea70..ff3a195b 100644 --- a/linux/devices/ploc/PlocSupervisorHandler.cpp +++ b/linux/devices/ploc/PlocSupervisorHandler.cpp @@ -823,7 +823,7 @@ void PlocSupervisorHandler::handleEvent(EventMessage* eventMessage) { object_id_t objectId = eventMessage->getReporter(); Event event = eventMessage->getEvent(); switch (objectId) { - case commonObjects::PLOC_SUPERVISOR_HELPER: { + case objects::PLOC_SUPERVISOR_HELPER: { plocSupvHelperExecuting = false; // After execution of update procedure, PLOC is in a state where it draws approx. 700 mA of // current. To leave this state the shutdown MPSoC command must be sent here. diff --git a/linux/devices/startracker/StarTrackerHandler.cpp b/linux/devices/startracker/StarTrackerHandler.cpp index e6f8d33c..5c4ba73e 100644 --- a/linux/devices/startracker/StarTrackerHandler.cpp +++ b/linux/devices/startracker/StarTrackerHandler.cpp @@ -1461,7 +1461,7 @@ ReturnValue_t StarTrackerHandler::scanForTmReply(DeviceCommandId_t* foundId) { void StarTrackerHandler::handleEvent(EventMessage* eventMessage) { object_id_t objectId = eventMessage->getReporter(); switch (objectId) { - case commonObjects::STR_HELPER: { + case objects::STR_HELPER: { // All events from image loader signal either that the operation was successful or that it // failed strHelperExecuting = false; diff --git a/linux/fsfwconfig/devices/addresses.h b/linux/fsfwconfig/devices/addresses.h index 6f5a0421..ec794490 100644 --- a/linux/fsfwconfig/devices/addresses.h +++ b/linux/fsfwconfig/devices/addresses.h @@ -12,30 +12,30 @@ namespace addresses { enum logicalAddresses : address_t { PCDU, - MGM_0_LIS3 = commonObjects::MGM_0_LIS3_HANDLER, - MGM_1_RM3100 = commonObjects::MGM_1_RM3100_HANDLER, - MGM_2_LIS3 = commonObjects::MGM_2_LIS3_HANDLER, - MGM_3_RM3100 = commonObjects::MGM_3_RM3100_HANDLER, + MGM_0_LIS3 = objects::MGM_0_LIS3_HANDLER, + MGM_1_RM3100 = objects::MGM_1_RM3100_HANDLER, + MGM_2_LIS3 = objects::MGM_2_LIS3_HANDLER, + MGM_3_RM3100 = objects::MGM_3_RM3100_HANDLER, - GYRO_0_ADIS = commonObjects::GYRO_0_ADIS_HANDLER, - GYRO_1_L3G = commonObjects::GYRO_1_L3G_HANDLER, - GYRO_2_ADIS = commonObjects::GYRO_2_ADIS_HANDLER, - GYRO_3_L3G = commonObjects::GYRO_3_L3G_HANDLER, + GYRO_0_ADIS = objects::GYRO_0_ADIS_HANDLER, + GYRO_1_L3G = objects::GYRO_1_L3G_HANDLER, + GYRO_2_ADIS = objects::GYRO_2_ADIS_HANDLER, + GYRO_3_L3G = objects::GYRO_3_L3G_HANDLER, - RAD_SENSOR = commonObjects::RAD_SENSOR, + RAD_SENSOR = objects::RAD_SENSOR, - SUS_0 = commonObjects::SUS_0_N_LOC_XFYFZM_PT_XF, - SUS_1 = commonObjects::SUS_1_N_LOC_XBYFZM_PT_XB, - SUS_2 = commonObjects::SUS_2_N_LOC_XFYBZB_PT_YB, - SUS_3 = commonObjects::SUS_3_N_LOC_XFYBZF_PT_YF, - SUS_4 = commonObjects::SUS_4_N_LOC_XMYFZF_PT_ZF, - SUS_5 = commonObjects::SUS_5_N_LOC_XFYMZB_PT_ZB, - SUS_6 = commonObjects::SUS_6_R_LOC_XFYBZM_PT_XF, - SUS_7 = commonObjects::SUS_7_R_LOC_XBYBZM_PT_XB, - SUS_8 = commonObjects::SUS_8_R_LOC_XBYBZB_PT_YB, - SUS_9 = commonObjects::SUS_9_R_LOC_XBYBZB_PT_YF, - SUS_10 = commonObjects::SUS_10_N_LOC_XMYBZF_PT_ZF, - SUS_11 = commonObjects::SUS_11_R_LOC_XBYMZB_PT_ZB, + SUS_0 = objects::SUS_0_N_LOC_XFYFZM_PT_XF, + SUS_1 = objects::SUS_1_N_LOC_XBYFZM_PT_XB, + SUS_2 = objects::SUS_2_N_LOC_XFYBZB_PT_YB, + SUS_3 = objects::SUS_3_N_LOC_XFYBZF_PT_YF, + SUS_4 = objects::SUS_4_N_LOC_XMYFZF_PT_ZF, + SUS_5 = objects::SUS_5_N_LOC_XFYMZB_PT_ZB, + SUS_6 = objects::SUS_6_R_LOC_XFYBZM_PT_XF, + SUS_7 = objects::SUS_7_R_LOC_XBYBZM_PT_XB, + SUS_8 = objects::SUS_8_R_LOC_XBYBZB_PT_YB, + SUS_9 = objects::SUS_9_R_LOC_XBYBZB_PT_YF, + SUS_10 = objects::SUS_10_N_LOC_XMYBZF_PT_ZF, + SUS_11 = objects::SUS_11_R_LOC_XBYMZB_PT_ZB, /* Dummy and Test Addresses */ DUMMY_ECHO = 129, diff --git a/linux/fsfwconfig/objects/systemObjectList.h b/linux/fsfwconfig/objects/systemObjectList.h index 5bb0a32d..669fcc9f 100644 --- a/linux/fsfwconfig/objects/systemObjectList.h +++ b/linux/fsfwconfig/objects/systemObjectList.h @@ -7,8 +7,6 @@ #include "commonObjects.h" -#include - // The objects will be instantiated in the ID order // For naming scheme see flight manual /* @@ -34,35 +32,37 @@ Third byte is an assembly counter if there are multiple redundant devices. Fourth byte is a unique counter. */ -FSFW_ENUM( systemObjects, uint32_t, +namespace objects { +enum sourceObjects : uint32_t { /* 0x53 reserved for FSFW */ - /*((FW_ADDRESS_START, PUS_SERVICE_1_VERIFICATION, "FW_ADDRESS_START"))*/ - /*((FW_ADDRESS_END, TIME_STAMPER, "FW_ADDRESS_END"))*/ -((PUS_SERVICE_6, 0x51000500, "PUS_SERVICE_6")) + FW_ADDRESS_START = PUS_SERVICE_1_VERIFICATION, + FW_ADDRESS_END = TIME_STAMPER, + PUS_SERVICE_6 = 0x51000500, -((CCSDS_IP_CORE_BRIDGE, 0x73500000, "CCSDS_IP_CORE_BRIDGE")) -((TM_FUNNEL, 0x73000100, "TM_FUNNEL")) + CCSDS_IP_CORE_BRIDGE = 0x73500000, + TM_FUNNEL = 0x73000100, /* 0x49 ('I') for Communication Interfaces **/ -((ARDUINO_COM_IF, 0x49000000, "ARDUINO_COM_IF")) -((CSP_COM_IF, 0x49050001, "CSP_COM_IF")) -((I2C_COM_IF, 0x49040002, "I2C_COM_IF")) -((UART_COM_IF, 0x49030003, "UART_COM_IF")) -((SPI_MAIN_COM_IF, 0x49020004, "SPI_MAIN_COM_IF")) -((GPIO_IF, 0x49010005, "GPIO_IF")) -((SPI_RW_COM_IF, 0x49020005, "SPI_RW_COM_IF")) -((SPI_RTD_COM_IF, 0x49020006, "SPI_RTD_COM_IF")) + ARDUINO_COM_IF = 0x49000000, + CSP_COM_IF = 0x49050001, + I2C_COM_IF = 0x49040002, + UART_COM_IF = 0x49030003, + SPI_MAIN_COM_IF = 0x49020004, + GPIO_IF = 0x49010005, + SPI_RW_COM_IF = 0x49020005, + SPI_RTD_COM_IF = 0x49020006, /* 0x54 ('T') for test handlers */ -((TEST_TASK, 0x54694269, "TEST_TASK")) -((LIBGPIOD_TEST, 0x54123456, "LIBGPIOD_TEST")) -((SPI_TEST, 0x54000010, "SPI_TEST")) -((UART_TEST, 0x54000020, "UART_TEST")) -((I2C_TEST, 0x54000030, "I2C_TEST")) -((DUMMY_INTERFACE, 0x5400CAFE, "DUMMY_INTERFACE")) -((DUMMY_HANDLER, 0x5400AFFE, "DUMMY_HANDLER")) -((P60DOCK_TEST_TASK, 0x00005060, "P60DOCK_TEST_TASK")) -((DUMMY_COM_IF, 0x54000040, "DUMMY_COM_IF")) -) + TEST_TASK = 0x54694269, + LIBGPIOD_TEST = 0x54123456, + SPI_TEST = 0x54000010, + UART_TEST = 0x54000020, + I2C_TEST = 0x54000030, + DUMMY_INTERFACE = 0x5400CAFE, + DUMMY_HANDLER = 0x5400AFFE, + P60DOCK_TEST_TASK = 0x00005060, + DUMMY_COM_IF = 0x54000040 +}; +} #endif /* LINUX_FSFWCONFIG_OBJECTS_SYSTEMOBJECTLIST_H_ */ diff --git a/linux/fsfwconfig/pollingsequence/pollingSequenceFactory.cpp b/linux/fsfwconfig/pollingsequence/pollingSequenceFactory.cpp index eabecf69..87bd9c51 100644 --- a/linux/fsfwconfig/pollingsequence/pollingSequenceFactory.cpp +++ b/linux/fsfwconfig/pollingsequence/pollingSequenceFactory.cpp @@ -19,8 +19,8 @@ ReturnValue_t pst::pstGpio(FixedTimeslotTaskIF *thisSequence) { // Length of a communication cycle uint32_t length = thisSequence->getPeriodMs(); - thisSequence->addSlot(commonObjects::HEATER_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION); - thisSequence->addSlot(commonObjects::SOLAR_ARRAY_DEPL_HANDLER, length * 0, + thisSequence->addSlot(objects::HEATER_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION); + thisSequence->addSlot(objects::SOLAR_ARRAY_DEPL_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION); if (thisSequence->checkSequence() == HasReturnvaluesIF::RETURN_OK) { @@ -34,30 +34,30 @@ ReturnValue_t pst::pstGpio(FixedTimeslotTaskIF *thisSequence) { ReturnValue_t pst::pstSpiRw(FixedTimeslotTaskIF *thisSequence) { uint32_t length = thisSequence->getPeriodMs(); static_cast(length); - thisSequence->addSlot(commonObjects::RW1, length * 0, DeviceHandlerIF::PERFORM_OPERATION); - thisSequence->addSlot(commonObjects::RW2, length * 0, DeviceHandlerIF::PERFORM_OPERATION); - thisSequence->addSlot(commonObjects::RW3, length * 0, DeviceHandlerIF::PERFORM_OPERATION); - thisSequence->addSlot(commonObjects::RW4, length * 0, DeviceHandlerIF::PERFORM_OPERATION); + thisSequence->addSlot(objects::RW1, length * 0, DeviceHandlerIF::PERFORM_OPERATION); + thisSequence->addSlot(objects::RW2, length * 0, DeviceHandlerIF::PERFORM_OPERATION); + thisSequence->addSlot(objects::RW3, length * 0, DeviceHandlerIF::PERFORM_OPERATION); + thisSequence->addSlot(objects::RW4, length * 0, DeviceHandlerIF::PERFORM_OPERATION); - thisSequence->addSlot(commonObjects::RW1, length * 0.2, DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(commonObjects::RW2, length * 0.2, DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(commonObjects::RW3, length * 0.2, DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(commonObjects::RW4, length * 0.2, DeviceHandlerIF::SEND_WRITE); + thisSequence->addSlot(objects::RW1, length * 0.2, DeviceHandlerIF::SEND_WRITE); + thisSequence->addSlot(objects::RW2, length * 0.2, DeviceHandlerIF::SEND_WRITE); + thisSequence->addSlot(objects::RW3, length * 0.2, DeviceHandlerIF::SEND_WRITE); + thisSequence->addSlot(objects::RW4, length * 0.2, DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(commonObjects::RW1, length * 0.8, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(commonObjects::RW2, length * 0.8, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(commonObjects::RW3, length * 0.8, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(commonObjects::RW4, length * 0.8, DeviceHandlerIF::GET_WRITE); + thisSequence->addSlot(objects::RW1, length * 0.8, DeviceHandlerIF::GET_WRITE); + thisSequence->addSlot(objects::RW2, length * 0.8, DeviceHandlerIF::GET_WRITE); + thisSequence->addSlot(objects::RW3, length * 0.8, DeviceHandlerIF::GET_WRITE); + thisSequence->addSlot(objects::RW4, length * 0.8, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(commonObjects::RW1, length * 0.8, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(commonObjects::RW2, length * 0.8, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(commonObjects::RW3, length * 0.8, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(commonObjects::RW4, length * 0.8, DeviceHandlerIF::SEND_READ); + thisSequence->addSlot(objects::RW1, length * 0.8, DeviceHandlerIF::SEND_READ); + thisSequence->addSlot(objects::RW2, length * 0.8, DeviceHandlerIF::SEND_READ); + thisSequence->addSlot(objects::RW3, length * 0.8, DeviceHandlerIF::SEND_READ); + thisSequence->addSlot(objects::RW4, length * 0.8, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(commonObjects::RW1, length * 0.8, DeviceHandlerIF::GET_READ); - thisSequence->addSlot(commonObjects::RW2, length * 0.8, DeviceHandlerIF::GET_READ); - thisSequence->addSlot(commonObjects::RW3, length * 0.8, DeviceHandlerIF::GET_READ); - thisSequence->addSlot(commonObjects::RW4, length * 0.8, DeviceHandlerIF::GET_READ); + thisSequence->addSlot(objects::RW1, length * 0.8, DeviceHandlerIF::GET_READ); + thisSequence->addSlot(objects::RW2, length * 0.8, DeviceHandlerIF::GET_READ); + thisSequence->addSlot(objects::RW3, length * 0.8, DeviceHandlerIF::GET_READ); + thisSequence->addSlot(objects::RW4, length * 0.8, DeviceHandlerIF::GET_READ); return thisSequence->checkSequence(); } @@ -65,35 +65,35 @@ ReturnValue_t pst::pstSpi(FixedTimeslotTaskIF *thisSequence) { uint32_t length = thisSequence->getPeriodMs(); static_cast(length); #if OBSW_ADD_PL_PCDU == 1 - thisSequence->addSlot(commonObjects::PLPCDU_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION); - thisSequence->addSlot(commonObjects::PLPCDU_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(commonObjects::PLPCDU_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(commonObjects::PLPCDU_HANDLER, length * 0, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(commonObjects::PLPCDU_HANDLER, length * 0, DeviceHandlerIF::GET_READ); + thisSequence->addSlot(objects::PLPCDU_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION); + thisSequence->addSlot(objects::PLPCDU_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE); + thisSequence->addSlot(objects::PLPCDU_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE); + thisSequence->addSlot(objects::PLPCDU_HANDLER, length * 0, DeviceHandlerIF::SEND_READ); + thisSequence->addSlot(objects::PLPCDU_HANDLER, length * 0, DeviceHandlerIF::GET_READ); #endif #if OBSW_ADD_TMP_DEVICES == 1 - thisSequence->addSlot(commonObjects::TMP1075_HANDLER_1, length * 0, DeviceHandlerIF::PERFORM_OPERATION); - thisSequence->addSlot(commonObjects::TMP1075_HANDLER_2, length * 0, DeviceHandlerIF::PERFORM_OPERATION); + thisSequence->addSlot(objects::TMP1075_HANDLER_1, length * 0, DeviceHandlerIF::PERFORM_OPERATION); + thisSequence->addSlot(objects::TMP1075_HANDLER_2, length * 0, DeviceHandlerIF::PERFORM_OPERATION); #endif #if OBSW_ADD_TMP_DEVICES == 1 - thisSequence->addSlot(commonObjects::TMP1075_HANDLER_1, length * 0.2, DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(commonObjects::TMP1075_HANDLER_2, length * 0.2, DeviceHandlerIF::SEND_WRITE); + thisSequence->addSlot(objects::TMP1075_HANDLER_1, length * 0.2, DeviceHandlerIF::SEND_WRITE); + thisSequence->addSlot(objects::TMP1075_HANDLER_2, length * 0.2, DeviceHandlerIF::SEND_WRITE); #endif #if OBSW_ADD_TMP_DEVICES == 1 - thisSequence->addSlot(commonObjects::TMP1075_HANDLER_1, length * 0.2, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(commonObjects::TMP1075_HANDLER_2, length * 0.2, DeviceHandlerIF::GET_WRITE); + thisSequence->addSlot(objects::TMP1075_HANDLER_1, length * 0.2, DeviceHandlerIF::GET_WRITE); + thisSequence->addSlot(objects::TMP1075_HANDLER_2, length * 0.2, DeviceHandlerIF::GET_WRITE); #endif #if OBSW_ADD_TMP_DEVICES == 1 - thisSequence->addSlot(commonObjects::TMP1075_HANDLER_1, length * 0.2, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(commonObjects::TMP1075_HANDLER_2, length * 0.2, DeviceHandlerIF::SEND_READ); + thisSequence->addSlot(objects::TMP1075_HANDLER_1, length * 0.2, DeviceHandlerIF::SEND_READ); + thisSequence->addSlot(objects::TMP1075_HANDLER_2, length * 0.2, DeviceHandlerIF::SEND_READ); #endif #if OBSW_ADD_TMP_DEVICES == 1 - thisSequence->addSlot(commonObjects::TMP1075_HANDLER_1, length * 0.2, DeviceHandlerIF::GET_READ); - thisSequence->addSlot(commonObjects::TMP1075_HANDLER_2, length * 0.2, DeviceHandlerIF::GET_READ); + thisSequence->addSlot(objects::TMP1075_HANDLER_1, length * 0.2, DeviceHandlerIF::GET_READ); + thisSequence->addSlot(objects::TMP1075_HANDLER_2, length * 0.2, DeviceHandlerIF::GET_READ); #endif #if OBSW_ADD_SUN_SENSORS == 1 @@ -113,261 +113,261 @@ ReturnValue_t pst::pstSpi(FixedTimeslotTaskIF *thisSequence) { if (addSus0) { /* Write setup */ - thisSequence->addSlot(commonObjects::SUS_0_N_LOC_XFYFZM_PT_XF, length * 0, + thisSequence->addSlot(objects::SUS_0_N_LOC_XFYFZM_PT_XF, length * 0, DeviceHandlerIF::PERFORM_OPERATION); - thisSequence->addSlot(commonObjects::SUS_0_N_LOC_XFYFZM_PT_XF, length * 0, + thisSequence->addSlot(objects::SUS_0_N_LOC_XFYFZM_PT_XF, length * 0, DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(commonObjects::SUS_0_N_LOC_XFYFZM_PT_XF, length * 0, + thisSequence->addSlot(objects::SUS_0_N_LOC_XFYFZM_PT_XF, length * 0, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(commonObjects::SUS_0_N_LOC_XFYFZM_PT_XF, length * 0, + thisSequence->addSlot(objects::SUS_0_N_LOC_XFYFZM_PT_XF, length * 0, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(commonObjects::SUS_0_N_LOC_XFYFZM_PT_XF, length * 0, DeviceHandlerIF::GET_READ); + thisSequence->addSlot(objects::SUS_0_N_LOC_XFYFZM_PT_XF, length * 0, DeviceHandlerIF::GET_READ); - thisSequence->addSlot(commonObjects::SUS_0_N_LOC_XFYFZM_PT_XF, length * 0.4, + thisSequence->addSlot(objects::SUS_0_N_LOC_XFYFZM_PT_XF, length * 0.4, DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(commonObjects::SUS_0_N_LOC_XFYFZM_PT_XF, length * 0.4, + thisSequence->addSlot(objects::SUS_0_N_LOC_XFYFZM_PT_XF, length * 0.4, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(commonObjects::SUS_0_N_LOC_XFYFZM_PT_XF, length * 0.4, + thisSequence->addSlot(objects::SUS_0_N_LOC_XFYFZM_PT_XF, length * 0.4, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(commonObjects::SUS_0_N_LOC_XFYFZM_PT_XF, length * 0.4, + thisSequence->addSlot(objects::SUS_0_N_LOC_XFYFZM_PT_XF, length * 0.4, DeviceHandlerIF::GET_READ); } if (addSus1) { - thisSequence->addSlot(commonObjects::SUS_1_N_LOC_XBYFZM_PT_XB, length * 0, + thisSequence->addSlot(objects::SUS_1_N_LOC_XBYFZM_PT_XB, length * 0, DeviceHandlerIF::PERFORM_OPERATION); - thisSequence->addSlot(commonObjects::SUS_1_N_LOC_XBYFZM_PT_XB, length * 0, + thisSequence->addSlot(objects::SUS_1_N_LOC_XBYFZM_PT_XB, length * 0, DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(commonObjects::SUS_1_N_LOC_XBYFZM_PT_XB, length * 0, + thisSequence->addSlot(objects::SUS_1_N_LOC_XBYFZM_PT_XB, length * 0, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(commonObjects::SUS_1_N_LOC_XBYFZM_PT_XB, length * 0, + thisSequence->addSlot(objects::SUS_1_N_LOC_XBYFZM_PT_XB, length * 0, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(commonObjects::SUS_1_N_LOC_XBYFZM_PT_XB, length * 0, DeviceHandlerIF::GET_READ); + thisSequence->addSlot(objects::SUS_1_N_LOC_XBYFZM_PT_XB, length * 0, DeviceHandlerIF::GET_READ); - thisSequence->addSlot(commonObjects::SUS_1_N_LOC_XBYFZM_PT_XB, length * 0.4, + thisSequence->addSlot(objects::SUS_1_N_LOC_XBYFZM_PT_XB, length * 0.4, DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(commonObjects::SUS_1_N_LOC_XBYFZM_PT_XB, length * 0.4, + thisSequence->addSlot(objects::SUS_1_N_LOC_XBYFZM_PT_XB, length * 0.4, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(commonObjects::SUS_1_N_LOC_XBYFZM_PT_XB, length * 0.4, + thisSequence->addSlot(objects::SUS_1_N_LOC_XBYFZM_PT_XB, length * 0.4, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(commonObjects::SUS_1_N_LOC_XBYFZM_PT_XB, length * 0.4, + thisSequence->addSlot(objects::SUS_1_N_LOC_XBYFZM_PT_XB, length * 0.4, DeviceHandlerIF::GET_READ); } if (addSus2) { - thisSequence->addSlot(commonObjects::SUS_2_N_LOC_XFYBZB_PT_YB, length * 0, + thisSequence->addSlot(objects::SUS_2_N_LOC_XFYBZB_PT_YB, length * 0, DeviceHandlerIF::PERFORM_OPERATION); - thisSequence->addSlot(commonObjects::SUS_2_N_LOC_XFYBZB_PT_YB, length * 0, + thisSequence->addSlot(objects::SUS_2_N_LOC_XFYBZB_PT_YB, length * 0, DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(commonObjects::SUS_2_N_LOC_XFYBZB_PT_YB, length * 0, + thisSequence->addSlot(objects::SUS_2_N_LOC_XFYBZB_PT_YB, length * 0, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(commonObjects::SUS_2_N_LOC_XFYBZB_PT_YB, length * 0, + thisSequence->addSlot(objects::SUS_2_N_LOC_XFYBZB_PT_YB, length * 0, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(commonObjects::SUS_2_N_LOC_XFYBZB_PT_YB, length * 0, DeviceHandlerIF::GET_READ); + thisSequence->addSlot(objects::SUS_2_N_LOC_XFYBZB_PT_YB, length * 0, DeviceHandlerIF::GET_READ); - thisSequence->addSlot(commonObjects::SUS_2_N_LOC_XFYBZB_PT_YB, length * 0.4, + thisSequence->addSlot(objects::SUS_2_N_LOC_XFYBZB_PT_YB, length * 0.4, DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(commonObjects::SUS_2_N_LOC_XFYBZB_PT_YB, length * 0.4, + thisSequence->addSlot(objects::SUS_2_N_LOC_XFYBZB_PT_YB, length * 0.4, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(commonObjects::SUS_2_N_LOC_XFYBZB_PT_YB, length * 0.4, + thisSequence->addSlot(objects::SUS_2_N_LOC_XFYBZB_PT_YB, length * 0.4, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(commonObjects::SUS_2_N_LOC_XFYBZB_PT_YB, length * 0.4, + thisSequence->addSlot(objects::SUS_2_N_LOC_XFYBZB_PT_YB, length * 0.4, DeviceHandlerIF::GET_READ); } if (addSus3) { - thisSequence->addSlot(commonObjects::SUS_3_N_LOC_XFYBZF_PT_YF, length * 0, + thisSequence->addSlot(objects::SUS_3_N_LOC_XFYBZF_PT_YF, length * 0, DeviceHandlerIF::PERFORM_OPERATION); - thisSequence->addSlot(commonObjects::SUS_3_N_LOC_XFYBZF_PT_YF, length * 0, + thisSequence->addSlot(objects::SUS_3_N_LOC_XFYBZF_PT_YF, length * 0, DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(commonObjects::SUS_3_N_LOC_XFYBZF_PT_YF, length * 0, + thisSequence->addSlot(objects::SUS_3_N_LOC_XFYBZF_PT_YF, length * 0, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(commonObjects::SUS_3_N_LOC_XFYBZF_PT_YF, length * 0, + thisSequence->addSlot(objects::SUS_3_N_LOC_XFYBZF_PT_YF, length * 0, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(commonObjects::SUS_3_N_LOC_XFYBZF_PT_YF, length * 0, DeviceHandlerIF::GET_READ); + thisSequence->addSlot(objects::SUS_3_N_LOC_XFYBZF_PT_YF, length * 0, DeviceHandlerIF::GET_READ); - thisSequence->addSlot(commonObjects::SUS_3_N_LOC_XFYBZF_PT_YF, length * 0.4, + thisSequence->addSlot(objects::SUS_3_N_LOC_XFYBZF_PT_YF, length * 0.4, DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(commonObjects::SUS_3_N_LOC_XFYBZF_PT_YF, length * 0.4, + thisSequence->addSlot(objects::SUS_3_N_LOC_XFYBZF_PT_YF, length * 0.4, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(commonObjects::SUS_3_N_LOC_XFYBZF_PT_YF, length * 0.4, + thisSequence->addSlot(objects::SUS_3_N_LOC_XFYBZF_PT_YF, length * 0.4, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(commonObjects::SUS_3_N_LOC_XFYBZF_PT_YF, length * 0.4, + thisSequence->addSlot(objects::SUS_3_N_LOC_XFYBZF_PT_YF, length * 0.4, DeviceHandlerIF::GET_READ); } if (addSus4) { - thisSequence->addSlot(commonObjects::SUS_4_N_LOC_XMYFZF_PT_ZF, length * 0, + thisSequence->addSlot(objects::SUS_4_N_LOC_XMYFZF_PT_ZF, length * 0, DeviceHandlerIF::PERFORM_OPERATION); - thisSequence->addSlot(commonObjects::SUS_4_N_LOC_XMYFZF_PT_ZF, length * 0, + thisSequence->addSlot(objects::SUS_4_N_LOC_XMYFZF_PT_ZF, length * 0, DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(commonObjects::SUS_4_N_LOC_XMYFZF_PT_ZF, length * 0, + thisSequence->addSlot(objects::SUS_4_N_LOC_XMYFZF_PT_ZF, length * 0, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(commonObjects::SUS_4_N_LOC_XMYFZF_PT_ZF, length * 0, + thisSequence->addSlot(objects::SUS_4_N_LOC_XMYFZF_PT_ZF, length * 0, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(commonObjects::SUS_4_N_LOC_XMYFZF_PT_ZF, length * 0, DeviceHandlerIF::GET_READ); + thisSequence->addSlot(objects::SUS_4_N_LOC_XMYFZF_PT_ZF, length * 0, DeviceHandlerIF::GET_READ); - thisSequence->addSlot(commonObjects::SUS_4_N_LOC_XMYFZF_PT_ZF, length * 0.4, + thisSequence->addSlot(objects::SUS_4_N_LOC_XMYFZF_PT_ZF, length * 0.4, DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(commonObjects::SUS_4_N_LOC_XMYFZF_PT_ZF, length * 0.4, + thisSequence->addSlot(objects::SUS_4_N_LOC_XMYFZF_PT_ZF, length * 0.4, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(commonObjects::SUS_4_N_LOC_XMYFZF_PT_ZF, length * 0.4, + thisSequence->addSlot(objects::SUS_4_N_LOC_XMYFZF_PT_ZF, length * 0.4, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(commonObjects::SUS_4_N_LOC_XMYFZF_PT_ZF, length * 0.4, + thisSequence->addSlot(objects::SUS_4_N_LOC_XMYFZF_PT_ZF, length * 0.4, DeviceHandlerIF::GET_READ); } if (addSus5) { - thisSequence->addSlot(commonObjects::SUS_5_N_LOC_XFYMZB_PT_ZB, length * 0, + thisSequence->addSlot(objects::SUS_5_N_LOC_XFYMZB_PT_ZB, length * 0, DeviceHandlerIF::PERFORM_OPERATION); - thisSequence->addSlot(commonObjects::SUS_5_N_LOC_XFYMZB_PT_ZB, length * 0, + thisSequence->addSlot(objects::SUS_5_N_LOC_XFYMZB_PT_ZB, length * 0, DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(commonObjects::SUS_5_N_LOC_XFYMZB_PT_ZB, length * 0, + thisSequence->addSlot(objects::SUS_5_N_LOC_XFYMZB_PT_ZB, length * 0, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(commonObjects::SUS_5_N_LOC_XFYMZB_PT_ZB, length * 0, + thisSequence->addSlot(objects::SUS_5_N_LOC_XFYMZB_PT_ZB, length * 0, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(commonObjects::SUS_5_N_LOC_XFYMZB_PT_ZB, length * 0, DeviceHandlerIF::GET_READ); + thisSequence->addSlot(objects::SUS_5_N_LOC_XFYMZB_PT_ZB, length * 0, DeviceHandlerIF::GET_READ); - thisSequence->addSlot(commonObjects::SUS_5_N_LOC_XFYMZB_PT_ZB, length * 0.4, + thisSequence->addSlot(objects::SUS_5_N_LOC_XFYMZB_PT_ZB, length * 0.4, DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(commonObjects::SUS_5_N_LOC_XFYMZB_PT_ZB, length * 0.4, + thisSequence->addSlot(objects::SUS_5_N_LOC_XFYMZB_PT_ZB, length * 0.4, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(commonObjects::SUS_5_N_LOC_XFYMZB_PT_ZB, length * 0.4, + thisSequence->addSlot(objects::SUS_5_N_LOC_XFYMZB_PT_ZB, length * 0.4, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(commonObjects::SUS_5_N_LOC_XFYMZB_PT_ZB, length * 0.4, + thisSequence->addSlot(objects::SUS_5_N_LOC_XFYMZB_PT_ZB, length * 0.4, DeviceHandlerIF::GET_READ); } if (addSus6) { - thisSequence->addSlot(commonObjects::SUS_6_R_LOC_XFYBZM_PT_XF, length * 0, + thisSequence->addSlot(objects::SUS_6_R_LOC_XFYBZM_PT_XF, length * 0, DeviceHandlerIF::PERFORM_OPERATION); - thisSequence->addSlot(commonObjects::SUS_6_R_LOC_XFYBZM_PT_XF, length * 0, + thisSequence->addSlot(objects::SUS_6_R_LOC_XFYBZM_PT_XF, length * 0, DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(commonObjects::SUS_6_R_LOC_XFYBZM_PT_XF, length * 0, + thisSequence->addSlot(objects::SUS_6_R_LOC_XFYBZM_PT_XF, length * 0, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(commonObjects::SUS_6_R_LOC_XFYBZM_PT_XF, length * 0, + thisSequence->addSlot(objects::SUS_6_R_LOC_XFYBZM_PT_XF, length * 0, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(commonObjects::SUS_6_R_LOC_XFYBZM_PT_XF, length * 0, DeviceHandlerIF::GET_READ); + thisSequence->addSlot(objects::SUS_6_R_LOC_XFYBZM_PT_XF, length * 0, DeviceHandlerIF::GET_READ); - thisSequence->addSlot(commonObjects::SUS_6_R_LOC_XFYBZM_PT_XF, length * 0.4, + thisSequence->addSlot(objects::SUS_6_R_LOC_XFYBZM_PT_XF, length * 0.4, DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(commonObjects::SUS_6_R_LOC_XFYBZM_PT_XF, length * 0.4, + thisSequence->addSlot(objects::SUS_6_R_LOC_XFYBZM_PT_XF, length * 0.4, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(commonObjects::SUS_6_R_LOC_XFYBZM_PT_XF, length * 0.4, + thisSequence->addSlot(objects::SUS_6_R_LOC_XFYBZM_PT_XF, length * 0.4, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(commonObjects::SUS_6_R_LOC_XFYBZM_PT_XF, length * 0.4, + thisSequence->addSlot(objects::SUS_6_R_LOC_XFYBZM_PT_XF, length * 0.4, DeviceHandlerIF::GET_READ); } if (addSus7) { - thisSequence->addSlot(commonObjects::SUS_7_R_LOC_XBYBZM_PT_XB, length * 0, + thisSequence->addSlot(objects::SUS_7_R_LOC_XBYBZM_PT_XB, length * 0, DeviceHandlerIF::PERFORM_OPERATION); - thisSequence->addSlot(commonObjects::SUS_7_R_LOC_XBYBZM_PT_XB, length * 0, + thisSequence->addSlot(objects::SUS_7_R_LOC_XBYBZM_PT_XB, length * 0, DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(commonObjects::SUS_7_R_LOC_XBYBZM_PT_XB, length * 0, + thisSequence->addSlot(objects::SUS_7_R_LOC_XBYBZM_PT_XB, length * 0, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(commonObjects::SUS_7_R_LOC_XBYBZM_PT_XB, length * 0, + thisSequence->addSlot(objects::SUS_7_R_LOC_XBYBZM_PT_XB, length * 0, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(commonObjects::SUS_7_R_LOC_XBYBZM_PT_XB, length * 0, DeviceHandlerIF::GET_READ); + thisSequence->addSlot(objects::SUS_7_R_LOC_XBYBZM_PT_XB, length * 0, DeviceHandlerIF::GET_READ); - thisSequence->addSlot(commonObjects::SUS_7_R_LOC_XBYBZM_PT_XB, length * 0.4, + thisSequence->addSlot(objects::SUS_7_R_LOC_XBYBZM_PT_XB, length * 0.4, DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(commonObjects::SUS_7_R_LOC_XBYBZM_PT_XB, length * 0.4, + thisSequence->addSlot(objects::SUS_7_R_LOC_XBYBZM_PT_XB, length * 0.4, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(commonObjects::SUS_7_R_LOC_XBYBZM_PT_XB, length * 0.4, + thisSequence->addSlot(objects::SUS_7_R_LOC_XBYBZM_PT_XB, length * 0.4, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(commonObjects::SUS_7_R_LOC_XBYBZM_PT_XB, length * 0.4, + thisSequence->addSlot(objects::SUS_7_R_LOC_XBYBZM_PT_XB, length * 0.4, DeviceHandlerIF::GET_READ); } if (addSus8) { - thisSequence->addSlot(commonObjects::SUS_8_R_LOC_XBYBZB_PT_YB, length * 0, + thisSequence->addSlot(objects::SUS_8_R_LOC_XBYBZB_PT_YB, length * 0, DeviceHandlerIF::PERFORM_OPERATION); - thisSequence->addSlot(commonObjects::SUS_8_R_LOC_XBYBZB_PT_YB, length * 0, + thisSequence->addSlot(objects::SUS_8_R_LOC_XBYBZB_PT_YB, length * 0, DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(commonObjects::SUS_8_R_LOC_XBYBZB_PT_YB, length * 0, + thisSequence->addSlot(objects::SUS_8_R_LOC_XBYBZB_PT_YB, length * 0, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(commonObjects::SUS_8_R_LOC_XBYBZB_PT_YB, length * 0, + thisSequence->addSlot(objects::SUS_8_R_LOC_XBYBZB_PT_YB, length * 0, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(commonObjects::SUS_8_R_LOC_XBYBZB_PT_YB, length * 0, DeviceHandlerIF::GET_READ); + thisSequence->addSlot(objects::SUS_8_R_LOC_XBYBZB_PT_YB, length * 0, DeviceHandlerIF::GET_READ); - thisSequence->addSlot(commonObjects::SUS_8_R_LOC_XBYBZB_PT_YB, length * 0.4, + thisSequence->addSlot(objects::SUS_8_R_LOC_XBYBZB_PT_YB, length * 0.4, DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(commonObjects::SUS_8_R_LOC_XBYBZB_PT_YB, length * 0.4, + thisSequence->addSlot(objects::SUS_8_R_LOC_XBYBZB_PT_YB, length * 0.4, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(commonObjects::SUS_8_R_LOC_XBYBZB_PT_YB, length * 0.4, + thisSequence->addSlot(objects::SUS_8_R_LOC_XBYBZB_PT_YB, length * 0.4, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(commonObjects::SUS_8_R_LOC_XBYBZB_PT_YB, length * 0.4, + thisSequence->addSlot(objects::SUS_8_R_LOC_XBYBZB_PT_YB, length * 0.4, DeviceHandlerIF::GET_READ); } if (addSus9) { - thisSequence->addSlot(commonObjects::SUS_9_R_LOC_XBYBZB_PT_YF, length * 0, + thisSequence->addSlot(objects::SUS_9_R_LOC_XBYBZB_PT_YF, length * 0, DeviceHandlerIF::PERFORM_OPERATION); - thisSequence->addSlot(commonObjects::SUS_9_R_LOC_XBYBZB_PT_YF, length * 0, + thisSequence->addSlot(objects::SUS_9_R_LOC_XBYBZB_PT_YF, length * 0, DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(commonObjects::SUS_9_R_LOC_XBYBZB_PT_YF, length * 0, + thisSequence->addSlot(objects::SUS_9_R_LOC_XBYBZB_PT_YF, length * 0, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(commonObjects::SUS_9_R_LOC_XBYBZB_PT_YF, length * 0, + thisSequence->addSlot(objects::SUS_9_R_LOC_XBYBZB_PT_YF, length * 0, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(commonObjects::SUS_9_R_LOC_XBYBZB_PT_YF, length * 0, DeviceHandlerIF::GET_READ); - thisSequence->addSlot(commonObjects::SUS_9_R_LOC_XBYBZB_PT_YF, length * 0.4, + thisSequence->addSlot(objects::SUS_9_R_LOC_XBYBZB_PT_YF, length * 0, DeviceHandlerIF::GET_READ); + thisSequence->addSlot(objects::SUS_9_R_LOC_XBYBZB_PT_YF, length * 0.4, DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(commonObjects::SUS_9_R_LOC_XBYBZB_PT_YF, length * 0.4, + thisSequence->addSlot(objects::SUS_9_R_LOC_XBYBZB_PT_YF, length * 0.4, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(commonObjects::SUS_9_R_LOC_XBYBZB_PT_YF, length * 0.4, + thisSequence->addSlot(objects::SUS_9_R_LOC_XBYBZB_PT_YF, length * 0.4, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(commonObjects::SUS_9_R_LOC_XBYBZB_PT_YF, length * 0.4, + thisSequence->addSlot(objects::SUS_9_R_LOC_XBYBZB_PT_YF, length * 0.4, DeviceHandlerIF::GET_READ); } if (addSus10) { - thisSequence->addSlot(commonObjects::SUS_10_N_LOC_XMYBZF_PT_ZF, length * 0, + thisSequence->addSlot(objects::SUS_10_N_LOC_XMYBZF_PT_ZF, length * 0, DeviceHandlerIF::PERFORM_OPERATION); - thisSequence->addSlot(commonObjects::SUS_10_N_LOC_XMYBZF_PT_ZF, length * 0, + thisSequence->addSlot(objects::SUS_10_N_LOC_XMYBZF_PT_ZF, length * 0, DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(commonObjects::SUS_10_N_LOC_XMYBZF_PT_ZF, length * 0, + thisSequence->addSlot(objects::SUS_10_N_LOC_XMYBZF_PT_ZF, length * 0, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(commonObjects::SUS_10_N_LOC_XMYBZF_PT_ZF, length * 0, + thisSequence->addSlot(objects::SUS_10_N_LOC_XMYBZF_PT_ZF, length * 0, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(commonObjects::SUS_10_N_LOC_XMYBZF_PT_ZF, length * 0, + thisSequence->addSlot(objects::SUS_10_N_LOC_XMYBZF_PT_ZF, length * 0, DeviceHandlerIF::GET_READ); - thisSequence->addSlot(commonObjects::SUS_10_N_LOC_XMYBZF_PT_ZF, length * 0.4, + thisSequence->addSlot(objects::SUS_10_N_LOC_XMYBZF_PT_ZF, length * 0.4, DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(commonObjects::SUS_10_N_LOC_XMYBZF_PT_ZF, length * 0.4, + thisSequence->addSlot(objects::SUS_10_N_LOC_XMYBZF_PT_ZF, length * 0.4, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(commonObjects::SUS_10_N_LOC_XMYBZF_PT_ZF, length * 0.4, + thisSequence->addSlot(objects::SUS_10_N_LOC_XMYBZF_PT_ZF, length * 0.4, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(commonObjects::SUS_10_N_LOC_XMYBZF_PT_ZF, length * 0.4, + thisSequence->addSlot(objects::SUS_10_N_LOC_XMYBZF_PT_ZF, length * 0.4, DeviceHandlerIF::GET_READ); } if (addSus11) { - thisSequence->addSlot(commonObjects::SUS_11_R_LOC_XBYMZB_PT_ZB, length * 0, + thisSequence->addSlot(objects::SUS_11_R_LOC_XBYMZB_PT_ZB, length * 0, DeviceHandlerIF::PERFORM_OPERATION); - thisSequence->addSlot(commonObjects::SUS_11_R_LOC_XBYMZB_PT_ZB, length * 0, + thisSequence->addSlot(objects::SUS_11_R_LOC_XBYMZB_PT_ZB, length * 0, DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(commonObjects::SUS_11_R_LOC_XBYMZB_PT_ZB, length * 0, + thisSequence->addSlot(objects::SUS_11_R_LOC_XBYMZB_PT_ZB, length * 0, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(commonObjects::SUS_11_R_LOC_XBYMZB_PT_ZB, length * 0, + thisSequence->addSlot(objects::SUS_11_R_LOC_XBYMZB_PT_ZB, length * 0, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(commonObjects::SUS_11_R_LOC_XBYMZB_PT_ZB, length * 0, + thisSequence->addSlot(objects::SUS_11_R_LOC_XBYMZB_PT_ZB, length * 0, DeviceHandlerIF::GET_READ); - thisSequence->addSlot(commonObjects::SUS_11_R_LOC_XBYMZB_PT_ZB, length * 0.4, + thisSequence->addSlot(objects::SUS_11_R_LOC_XBYMZB_PT_ZB, length * 0.4, DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(commonObjects::SUS_11_R_LOC_XBYMZB_PT_ZB, length * 0.4, + thisSequence->addSlot(objects::SUS_11_R_LOC_XBYMZB_PT_ZB, length * 0.4, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(commonObjects::SUS_11_R_LOC_XBYMZB_PT_ZB, length * 0.4, + thisSequence->addSlot(objects::SUS_11_R_LOC_XBYMZB_PT_ZB, length * 0.4, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(commonObjects::SUS_11_R_LOC_XBYMZB_PT_ZB, length * 0.4, + thisSequence->addSlot(objects::SUS_11_R_LOC_XBYMZB_PT_ZB, length * 0.4, DeviceHandlerIF::GET_READ); } #endif /* OBSW_ADD_SUN_SENSORS == 1 */ #if OBSW_ADD_RAD_SENSORS == 1 /* Radiation sensor */ - thisSequence->addSlot(commonObjects::RAD_SENSOR, length * 0, DeviceHandlerIF::PERFORM_OPERATION); - thisSequence->addSlot(commonObjects::RAD_SENSOR, length * 0.2, DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(commonObjects::RAD_SENSOR, length * 0.4, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(commonObjects::RAD_SENSOR, length * 0.6, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(commonObjects::RAD_SENSOR, length * 0.8, DeviceHandlerIF::GET_READ); + thisSequence->addSlot(objects::RAD_SENSOR, length * 0, DeviceHandlerIF::PERFORM_OPERATION); + thisSequence->addSlot(objects::RAD_SENSOR, length * 0.2, DeviceHandlerIF::SEND_WRITE); + thisSequence->addSlot(objects::RAD_SENSOR, length * 0.4, DeviceHandlerIF::GET_WRITE); + thisSequence->addSlot(objects::RAD_SENSOR, length * 0.6, DeviceHandlerIF::SEND_READ); + thisSequence->addSlot(objects::RAD_SENSOR, length * 0.8, DeviceHandlerIF::GET_READ); #endif #if OBSW_ADD_ACS_BOARD == 1 && OBSW_ADD_ACS_HANDLERS == 1 @@ -375,66 +375,66 @@ ReturnValue_t pst::pstSpi(FixedTimeslotTaskIF *thisSequence) { bool enableBside = true; if (enableAside) { // A side - thisSequence->addSlot(commonObjects::MGM_0_LIS3_HANDLER, length * 0, + thisSequence->addSlot(objects::MGM_0_LIS3_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION); - thisSequence->addSlot(commonObjects::MGM_0_LIS3_HANDLER, length * 0.25, DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(commonObjects::MGM_0_LIS3_HANDLER, length * 0.6, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(commonObjects::MGM_0_LIS3_HANDLER, length * 0.7, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(commonObjects::MGM_0_LIS3_HANDLER, length * 0.85, DeviceHandlerIF::GET_READ); + thisSequence->addSlot(objects::MGM_0_LIS3_HANDLER, length * 0.25, DeviceHandlerIF::SEND_WRITE); + thisSequence->addSlot(objects::MGM_0_LIS3_HANDLER, length * 0.6, DeviceHandlerIF::GET_WRITE); + thisSequence->addSlot(objects::MGM_0_LIS3_HANDLER, length * 0.7, DeviceHandlerIF::SEND_READ); + thisSequence->addSlot(objects::MGM_0_LIS3_HANDLER, length * 0.85, DeviceHandlerIF::GET_READ); - thisSequence->addSlot(commonObjects::MGM_1_RM3100_HANDLER, length * 0, + thisSequence->addSlot(objects::MGM_1_RM3100_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION); - thisSequence->addSlot(commonObjects::MGM_1_RM3100_HANDLER, length * 0.25, + thisSequence->addSlot(objects::MGM_1_RM3100_HANDLER, length * 0.25, DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(commonObjects::MGM_1_RM3100_HANDLER, length * 0.6, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(commonObjects::MGM_1_RM3100_HANDLER, length * 0.7, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(commonObjects::MGM_1_RM3100_HANDLER, length * 0.85, DeviceHandlerIF::GET_READ); + thisSequence->addSlot(objects::MGM_1_RM3100_HANDLER, length * 0.6, DeviceHandlerIF::GET_WRITE); + thisSequence->addSlot(objects::MGM_1_RM3100_HANDLER, length * 0.7, DeviceHandlerIF::SEND_READ); + thisSequence->addSlot(objects::MGM_1_RM3100_HANDLER, length * 0.85, DeviceHandlerIF::GET_READ); - thisSequence->addSlot(commonObjects::GYRO_0_ADIS_HANDLER, length * 0, + thisSequence->addSlot(objects::GYRO_0_ADIS_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION); - thisSequence->addSlot(commonObjects::GYRO_0_ADIS_HANDLER, length * 0.25, DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(commonObjects::GYRO_0_ADIS_HANDLER, length * 0.6, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(commonObjects::GYRO_0_ADIS_HANDLER, length * 0.7, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(commonObjects::GYRO_0_ADIS_HANDLER, length * 0.85, DeviceHandlerIF::GET_READ); + thisSequence->addSlot(objects::GYRO_0_ADIS_HANDLER, length * 0.25, DeviceHandlerIF::SEND_WRITE); + thisSequence->addSlot(objects::GYRO_0_ADIS_HANDLER, length * 0.6, DeviceHandlerIF::GET_WRITE); + thisSequence->addSlot(objects::GYRO_0_ADIS_HANDLER, length * 0.7, DeviceHandlerIF::SEND_READ); + thisSequence->addSlot(objects::GYRO_0_ADIS_HANDLER, length * 0.85, DeviceHandlerIF::GET_READ); - thisSequence->addSlot(commonObjects::GYRO_1_L3G_HANDLER, length * 0, + thisSequence->addSlot(objects::GYRO_1_L3G_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION); - thisSequence->addSlot(commonObjects::GYRO_1_L3G_HANDLER, length * 0.25, DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(commonObjects::GYRO_1_L3G_HANDLER, length * 0.6, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(commonObjects::GYRO_1_L3G_HANDLER, length * 0.7, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(commonObjects::GYRO_1_L3G_HANDLER, length * 0.85, DeviceHandlerIF::GET_READ); + thisSequence->addSlot(objects::GYRO_1_L3G_HANDLER, length * 0.25, DeviceHandlerIF::SEND_WRITE); + thisSequence->addSlot(objects::GYRO_1_L3G_HANDLER, length * 0.6, DeviceHandlerIF::GET_WRITE); + thisSequence->addSlot(objects::GYRO_1_L3G_HANDLER, length * 0.7, DeviceHandlerIF::SEND_READ); + thisSequence->addSlot(objects::GYRO_1_L3G_HANDLER, length * 0.85, DeviceHandlerIF::GET_READ); } if (enableBside) { // B side - thisSequence->addSlot(commonObjects::MGM_2_LIS3_HANDLER, length * 0, + thisSequence->addSlot(objects::MGM_2_LIS3_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION); - thisSequence->addSlot(commonObjects::MGM_2_LIS3_HANDLER, length * 0.25, DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(commonObjects::MGM_2_LIS3_HANDLER, length * 0.6, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(commonObjects::MGM_2_LIS3_HANDLER, length * 0.7, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(commonObjects::MGM_2_LIS3_HANDLER, length * 0.85, DeviceHandlerIF::GET_READ); + thisSequence->addSlot(objects::MGM_2_LIS3_HANDLER, length * 0.25, DeviceHandlerIF::SEND_WRITE); + thisSequence->addSlot(objects::MGM_2_LIS3_HANDLER, length * 0.6, DeviceHandlerIF::GET_WRITE); + thisSequence->addSlot(objects::MGM_2_LIS3_HANDLER, length * 0.7, DeviceHandlerIF::SEND_READ); + thisSequence->addSlot(objects::MGM_2_LIS3_HANDLER, length * 0.85, DeviceHandlerIF::GET_READ); - thisSequence->addSlot(commonObjects::MGM_3_RM3100_HANDLER, length * 0, + thisSequence->addSlot(objects::MGM_3_RM3100_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION); - thisSequence->addSlot(commonObjects::MGM_3_RM3100_HANDLER, length * 0.25, + thisSequence->addSlot(objects::MGM_3_RM3100_HANDLER, length * 0.25, DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(commonObjects::MGM_3_RM3100_HANDLER, length * 0.6, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(commonObjects::MGM_3_RM3100_HANDLER, length * 0.7, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(commonObjects::MGM_3_RM3100_HANDLER, length * 0.85, DeviceHandlerIF::GET_READ); + thisSequence->addSlot(objects::MGM_3_RM3100_HANDLER, length * 0.6, DeviceHandlerIF::GET_WRITE); + thisSequence->addSlot(objects::MGM_3_RM3100_HANDLER, length * 0.7, DeviceHandlerIF::SEND_READ); + thisSequence->addSlot(objects::MGM_3_RM3100_HANDLER, length * 0.85, DeviceHandlerIF::GET_READ); - thisSequence->addSlot(commonObjects::GYRO_2_ADIS_HANDLER, length * 0, + thisSequence->addSlot(objects::GYRO_2_ADIS_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION); - thisSequence->addSlot(commonObjects::GYRO_2_ADIS_HANDLER, length * 0.25, DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(commonObjects::GYRO_2_ADIS_HANDLER, length * 0.6, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(commonObjects::GYRO_2_ADIS_HANDLER, length * 0.7, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(commonObjects::GYRO_2_ADIS_HANDLER, length * 0.85, DeviceHandlerIF::GET_READ); + thisSequence->addSlot(objects::GYRO_2_ADIS_HANDLER, length * 0.25, DeviceHandlerIF::SEND_WRITE); + thisSequence->addSlot(objects::GYRO_2_ADIS_HANDLER, length * 0.6, DeviceHandlerIF::GET_WRITE); + thisSequence->addSlot(objects::GYRO_2_ADIS_HANDLER, length * 0.7, DeviceHandlerIF::SEND_READ); + thisSequence->addSlot(objects::GYRO_2_ADIS_HANDLER, length * 0.85, DeviceHandlerIF::GET_READ); - thisSequence->addSlot(commonObjects::GYRO_3_L3G_HANDLER, length * 0, + thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION); - thisSequence->addSlot(commonObjects::GYRO_3_L3G_HANDLER, length * 0.25, DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(commonObjects::GYRO_3_L3G_HANDLER, length * 0.6, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(commonObjects::GYRO_3_L3G_HANDLER, length * 0.7, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(commonObjects::GYRO_3_L3G_HANDLER, length * 0.85, DeviceHandlerIF::GET_READ); + thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * 0.25, DeviceHandlerIF::SEND_WRITE); + thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * 0.6, DeviceHandlerIF::GET_WRITE); + thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * 0.7, DeviceHandlerIF::SEND_READ); + thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * 0.85, DeviceHandlerIF::GET_READ); } #endif /* OBSW_ADD_ACS_BOARD == 1 && OBSW_ADD_ACS_HANDLERS == 1 */ @@ -446,18 +446,18 @@ ReturnValue_t pst::pstI2c(FixedTimeslotTaskIF *thisSequence) { uint32_t length = thisSequence->getPeriodMs(); static_cast(length); #if OBSW_ADD_MGT == 1 - thisSequence->addSlot(commonObjects::IMTQ_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION); - thisSequence->addSlot(commonObjects::IMTQ_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(commonObjects::IMTQ_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(commonObjects::IMTQ_HANDLER, length * 0.6, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(commonObjects::IMTQ_HANDLER, length * 0.8, DeviceHandlerIF::GET_READ); + thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION); + thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE); + thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE); + thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.6, DeviceHandlerIF::SEND_READ); + thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.8, DeviceHandlerIF::GET_READ); #endif #if OBSW_ADD_BPX_BATTERY_HANDLER == 1 - thisSequence->addSlot(commonObjects::BPX_BATT_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION); - thisSequence->addSlot(commonObjects::BPX_BATT_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(commonObjects::BPX_BATT_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(commonObjects::BPX_BATT_HANDLER, length * 0.6, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(commonObjects::BPX_BATT_HANDLER, length * 0.8, DeviceHandlerIF::GET_READ); + thisSequence->addSlot(objects::BPX_BATT_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION); + thisSequence->addSlot(objects::BPX_BATT_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE); + thisSequence->addSlot(objects::BPX_BATT_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE); + thisSequence->addSlot(objects::BPX_BATT_HANDLER, length * 0.6, DeviceHandlerIF::SEND_READ); + thisSequence->addSlot(objects::BPX_BATT_HANDLER, length * 0.8, DeviceHandlerIF::GET_READ); #endif static_cast(length); return thisSequence->checkSequence(); @@ -470,43 +470,43 @@ ReturnValue_t pst::pstUart(FixedTimeslotTaskIF *thisSequence) { #if OBSW_ADD_PLOC_MPSOC == 1 uartPstEmpty = false; - thisSequence->addSlot(commonObjects::PLOC_MPSOC_HANDLER, length * 0, + thisSequence->addSlot(objects::PLOC_MPSOC_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION); - thisSequence->addSlot(commonObjects::PLOC_MPSOC_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(commonObjects::PLOC_MPSOC_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(commonObjects::PLOC_MPSOC_HANDLER, length * 0.6, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(commonObjects::PLOC_MPSOC_HANDLER, length * 0.8, DeviceHandlerIF::GET_READ); + thisSequence->addSlot(objects::PLOC_MPSOC_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE); + thisSequence->addSlot(objects::PLOC_MPSOC_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE); + thisSequence->addSlot(objects::PLOC_MPSOC_HANDLER, length * 0.6, DeviceHandlerIF::SEND_READ); + thisSequence->addSlot(objects::PLOC_MPSOC_HANDLER, length * 0.8, DeviceHandlerIF::GET_READ); #endif - thisSequence->addSlot(commonObjects::PLOC_MEMORY_DUMPER, length * 0, + thisSequence->addSlot(objects::PLOC_MEMORY_DUMPER, length * 0, DeviceHandlerIF::PERFORM_OPERATION); #if OBSW_ADD_PLOC_SUPERVISOR == 1 - thisSequence->addSlot(commonObjects::PLOC_SUPERVISOR_HANDLER, length * 0, + thisSequence->addSlot(objects::PLOC_SUPERVISOR_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION); - thisSequence->addSlot(commonObjects::PLOC_SUPERVISOR_HANDLER, length * 0.2, + thisSequence->addSlot(objects::PLOC_SUPERVISOR_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(commonObjects::PLOC_SUPERVISOR_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(commonObjects::PLOC_SUPERVISOR_HANDLER, length * 0.6, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(commonObjects::PLOC_SUPERVISOR_HANDLER, length * 0.8, DeviceHandlerIF::GET_READ); + thisSequence->addSlot(objects::PLOC_SUPERVISOR_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE); + thisSequence->addSlot(objects::PLOC_SUPERVISOR_HANDLER, length * 0.6, DeviceHandlerIF::SEND_READ); + thisSequence->addSlot(objects::PLOC_SUPERVISOR_HANDLER, length * 0.8, DeviceHandlerIF::GET_READ); #endif #if OBSW_ADD_SYRLINKS == 1 uartPstEmpty = false; - thisSequence->addSlot(commonObjects::SYRLINKS_HK_HANDLER, length * 0, + thisSequence->addSlot(objects::SYRLINKS_HK_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION); - thisSequence->addSlot(commonObjects::SYRLINKS_HK_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(commonObjects::SYRLINKS_HK_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(commonObjects::SYRLINKS_HK_HANDLER, length * 0.6, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(commonObjects::SYRLINKS_HK_HANDLER, length * 0.8, DeviceHandlerIF::GET_READ); + thisSequence->addSlot(objects::SYRLINKS_HK_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE); + thisSequence->addSlot(objects::SYRLINKS_HK_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE); + thisSequence->addSlot(objects::SYRLINKS_HK_HANDLER, length * 0.6, DeviceHandlerIF::SEND_READ); + thisSequence->addSlot(objects::SYRLINKS_HK_HANDLER, length * 0.8, DeviceHandlerIF::GET_READ); #endif #if OBSW_ADD_STAR_TRACKER == 1 uartPstEmpty = false; - thisSequence->addSlot(commonObjects::STAR_TRACKER, length * 0, DeviceHandlerIF::PERFORM_OPERATION); - thisSequence->addSlot(commonObjects::STAR_TRACKER, length * 0.2, DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(commonObjects::STAR_TRACKER, length * 0.4, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(commonObjects::STAR_TRACKER, length * 0.6, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(commonObjects::STAR_TRACKER, length * 0.8, DeviceHandlerIF::GET_READ); + thisSequence->addSlot(objects::STAR_TRACKER, length * 0, DeviceHandlerIF::PERFORM_OPERATION); + thisSequence->addSlot(objects::STAR_TRACKER, length * 0.2, DeviceHandlerIF::SEND_WRITE); + thisSequence->addSlot(objects::STAR_TRACKER, length * 0.4, DeviceHandlerIF::GET_WRITE); + thisSequence->addSlot(objects::STAR_TRACKER, length * 0.6, DeviceHandlerIF::SEND_READ); + thisSequence->addSlot(objects::STAR_TRACKER, length * 0.8, DeviceHandlerIF::GET_READ); #endif static_cast(length); if (uartPstEmpty) { @@ -522,32 +522,32 @@ ReturnValue_t pst::pstUart(FixedTimeslotTaskIF *thisSequence) { ReturnValue_t pst::pstGompaceCan(FixedTimeslotTaskIF *thisSequence) { uint32_t length = thisSequence->getPeriodMs(); // PCDU handlers receives two messages and both must be handled - thisSequence->addSlot(commonObjects::PCDU_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION); + thisSequence->addSlot(objects::PCDU_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION); - thisSequence->addSlot(commonObjects::P60DOCK_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION); - thisSequence->addSlot(commonObjects::PDU1_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION); - thisSequence->addSlot(commonObjects::PDU2_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION); - thisSequence->addSlot(commonObjects::ACU_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION); + thisSequence->addSlot(objects::P60DOCK_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION); + thisSequence->addSlot(objects::PDU1_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION); + thisSequence->addSlot(objects::PDU2_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION); + thisSequence->addSlot(objects::ACU_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION); - thisSequence->addSlot(commonObjects::P60DOCK_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(commonObjects::PDU1_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(commonObjects::PDU2_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(commonObjects::ACU_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE); + thisSequence->addSlot(objects::P60DOCK_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE); + thisSequence->addSlot(objects::PDU1_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE); + thisSequence->addSlot(objects::PDU2_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE); + thisSequence->addSlot(objects::ACU_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(commonObjects::P60DOCK_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(commonObjects::PDU1_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(commonObjects::PDU2_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(commonObjects::ACU_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE); + thisSequence->addSlot(objects::P60DOCK_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE); + thisSequence->addSlot(objects::PDU1_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE); + thisSequence->addSlot(objects::PDU2_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE); + thisSequence->addSlot(objects::ACU_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(commonObjects::P60DOCK_HANDLER, length * 0.6, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(commonObjects::PDU1_HANDLER, length * 0.6, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(commonObjects::PDU2_HANDLER, length * 0.6, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(commonObjects::ACU_HANDLER, length * 0.6, DeviceHandlerIF::SEND_READ); + thisSequence->addSlot(objects::P60DOCK_HANDLER, length * 0.6, DeviceHandlerIF::SEND_READ); + thisSequence->addSlot(objects::PDU1_HANDLER, length * 0.6, DeviceHandlerIF::SEND_READ); + thisSequence->addSlot(objects::PDU2_HANDLER, length * 0.6, DeviceHandlerIF::SEND_READ); + thisSequence->addSlot(objects::ACU_HANDLER, length * 0.6, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(commonObjects::P60DOCK_HANDLER, length * 0.8, DeviceHandlerIF::GET_READ); - thisSequence->addSlot(commonObjects::PDU1_HANDLER, length * 0.8, DeviceHandlerIF::GET_READ); - thisSequence->addSlot(commonObjects::PDU2_HANDLER, length * 0.8, DeviceHandlerIF::GET_READ); - thisSequence->addSlot(commonObjects::ACU_HANDLER, length * 0.8, DeviceHandlerIF::GET_READ); + thisSequence->addSlot(objects::P60DOCK_HANDLER, length * 0.8, DeviceHandlerIF::GET_READ); + thisSequence->addSlot(objects::PDU1_HANDLER, length * 0.8, DeviceHandlerIF::GET_READ); + thisSequence->addSlot(objects::PDU2_HANDLER, length * 0.8, DeviceHandlerIF::GET_READ); + thisSequence->addSlot(objects::ACU_HANDLER, length * 0.8, DeviceHandlerIF::GET_READ); if (thisSequence->checkSequence() != HasReturnvaluesIF::RETURN_OK) { sif::error << "GomSpace PST initialization failed" << std::endl; return HasReturnvaluesIF::RETURN_FAILED; @@ -563,23 +563,23 @@ ReturnValue_t pst::pstTest(FixedTimeslotTaskIF *thisSequence) { #if RPI_TEST_ADIS16507 == 1 notEmpty = true; - thisSequence->addSlot(commonObjects::GYRO_0_ADIS_HANDLER, length * 0, + thisSequence->addSlot(objects::GYRO_0_ADIS_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION); - thisSequence->addSlot(commonObjects::GYRO_0_ADIS_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(commonObjects::GYRO_0_ADIS_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(commonObjects::GYRO_0_ADIS_HANDLER, length * 0.6, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(commonObjects::GYRO_0_ADIS_HANDLER, length * 0.8, DeviceHandlerIF::GET_READ); + thisSequence->addSlot(objects::GYRO_0_ADIS_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE); + thisSequence->addSlot(objects::GYRO_0_ADIS_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE); + thisSequence->addSlot(objects::GYRO_0_ADIS_HANDLER, length * 0.6, DeviceHandlerIF::SEND_READ); + thisSequence->addSlot(objects::GYRO_0_ADIS_HANDLER, length * 0.8, DeviceHandlerIF::GET_READ); #endif #if RPI_TEST_GPS_HANDLER == 1 notEmpty = true; - thisSequence->addSlot(commonObjects::GPS0_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION); + thisSequence->addSlot(objects::GPS0_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION); - thisSequence->addSlot(commonObjects::GPS0_HANDLER, length * 0, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(commonObjects::GPS0_HANDLER, length * 0, DeviceHandlerIF::GET_READ); + thisSequence->addSlot(objects::GPS0_HANDLER, length * 0, DeviceHandlerIF::SEND_READ); + thisSequence->addSlot(objects::GPS0_HANDLER, length * 0, DeviceHandlerIF::GET_READ); - thisSequence->addSlot(commonObjects::GPS0_HANDLER, length * 0.5, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(commonObjects::GPS0_HANDLER, length * 0.5, DeviceHandlerIF::GET_READ); + thisSequence->addSlot(objects::GPS0_HANDLER, length * 0.5, DeviceHandlerIF::SEND_READ); + thisSequence->addSlot(objects::GPS0_HANDLER, length * 0.5, DeviceHandlerIF::GET_READ); #endif static_cast(length); if (not notEmpty) { diff --git a/mission/controller/AcsController.h b/mission/controller/AcsController.h index a51bfc30..8dbe38aa 100644 --- a/mission/controller/AcsController.h +++ b/mission/controller/AcsController.h @@ -33,11 +33,11 @@ class AcsController : public ExtendedControllerBase { // MGMs acsctrl::MgmData mgmData; - MGMLIS3MDL::MgmPrimaryDataset mgm0Lis3Set = MGMLIS3MDL::MgmPrimaryDataset(commonObjects::MGM_0_LIS3_HANDLER); - RM3100::Rm3100PrimaryDataset mgm1Rm3100Set = RM3100::Rm3100PrimaryDataset(commonObjects::MGM_1_RM3100_HANDLER); - MGMLIS3MDL::MgmPrimaryDataset mgm2Lis3Set = MGMLIS3MDL::MgmPrimaryDataset(commonObjects::MGM_2_LIS3_HANDLER); - RM3100::Rm3100PrimaryDataset mgm3Rm3100Set = RM3100::Rm3100PrimaryDataset(commonObjects::MGM_3_RM3100_HANDLER); - IMTQ::CalibratedMtmMeasurementSet imtqMgmSet = IMTQ::CalibratedMtmMeasurementSet(commonObjects::IMTQ_HANDLER); + MGMLIS3MDL::MgmPrimaryDataset mgm0Lis3Set = MGMLIS3MDL::MgmPrimaryDataset(objects::MGM_0_LIS3_HANDLER); + RM3100::Rm3100PrimaryDataset mgm1Rm3100Set = RM3100::Rm3100PrimaryDataset(objects::MGM_1_RM3100_HANDLER); + MGMLIS3MDL::MgmPrimaryDataset mgm2Lis3Set = MGMLIS3MDL::MgmPrimaryDataset(objects::MGM_2_LIS3_HANDLER); + RM3100::Rm3100PrimaryDataset mgm3Rm3100Set = RM3100::Rm3100PrimaryDataset(objects::MGM_3_RM3100_HANDLER); + IMTQ::CalibratedMtmMeasurementSet imtqMgmSet = IMTQ::CalibratedMtmMeasurementSet(objects::IMTQ_HANDLER); PoolEntry mgm0PoolVec = PoolEntry(3); PoolEntry mgm1PoolVec = PoolEntry(3); diff --git a/mission/controller/ThermalController.cpp b/mission/controller/ThermalController.cpp index 906b9ddb..9e0fbd5a 100644 --- a/mission/controller/ThermalController.cpp +++ b/mission/controller/ThermalController.cpp @@ -19,39 +19,39 @@ ThermalController::ThermalController(object_id_t objectId, object_id_t parentId) sensorTemperatures(this), susTemperatures(this), deviceTemperatures(this), - max31865Set0(commonObjects::RTD_0_IC3_PLOC_HEATSPREADER, + max31865Set0(objects::RTD_0_IC3_PLOC_HEATSPREADER, EiveMax31855::RtdCommands::EXCHANGE_SET_ID), - max31865Set1(commonObjects::RTD_1_IC4_PLOC_MISSIONBOARD, + max31865Set1(objects::RTD_1_IC4_PLOC_MISSIONBOARD, EiveMax31855::RtdCommands::EXCHANGE_SET_ID), - max31865Set2(commonObjects::RTD_2_IC5_4K_CAMERA, EiveMax31855::RtdCommands::EXCHANGE_SET_ID), - max31865Set3(commonObjects::RTD_3_IC6_DAC_HEATSPREADER, EiveMax31855::RtdCommands::EXCHANGE_SET_ID), - max31865Set4(commonObjects::RTD_4_IC7_STARTRACKER, EiveMax31855::RtdCommands::EXCHANGE_SET_ID), - max31865Set5(commonObjects::RTD_5_IC8_RW1_MX_MY, EiveMax31855::RtdCommands::EXCHANGE_SET_ID), - max31865Set6(commonObjects::RTD_6_IC9_DRO, EiveMax31855::RtdCommands::EXCHANGE_SET_ID), - max31865Set7(commonObjects::RTD_7_IC10_SCEX, EiveMax31855::RtdCommands::EXCHANGE_SET_ID), - max31865Set8(commonObjects::RTD_8_IC11_X8, EiveMax31855::RtdCommands::EXCHANGE_SET_ID), - max31865Set9(commonObjects::RTD_9_IC12_HPA, EiveMax31855::RtdCommands::EXCHANGE_SET_ID), - max31865Set10(commonObjects::RTD_10_IC13_PL_TX, EiveMax31855::RtdCommands::EXCHANGE_SET_ID), - max31865Set11(commonObjects::RTD_11_IC14_MPA, EiveMax31855::RtdCommands::EXCHANGE_SET_ID), - max31865Set12(commonObjects::RTD_12_IC15_ACU, EiveMax31855::RtdCommands::EXCHANGE_SET_ID), - max31865Set13(commonObjects::RTD_13_IC16_PLPCDU_HEATSPREADER, + max31865Set2(objects::RTD_2_IC5_4K_CAMERA, EiveMax31855::RtdCommands::EXCHANGE_SET_ID), + max31865Set3(objects::RTD_3_IC6_DAC_HEATSPREADER, EiveMax31855::RtdCommands::EXCHANGE_SET_ID), + max31865Set4(objects::RTD_4_IC7_STARTRACKER, EiveMax31855::RtdCommands::EXCHANGE_SET_ID), + max31865Set5(objects::RTD_5_IC8_RW1_MX_MY, EiveMax31855::RtdCommands::EXCHANGE_SET_ID), + max31865Set6(objects::RTD_6_IC9_DRO, EiveMax31855::RtdCommands::EXCHANGE_SET_ID), + max31865Set7(objects::RTD_7_IC10_SCEX, EiveMax31855::RtdCommands::EXCHANGE_SET_ID), + max31865Set8(objects::RTD_8_IC11_X8, EiveMax31855::RtdCommands::EXCHANGE_SET_ID), + max31865Set9(objects::RTD_9_IC12_HPA, EiveMax31855::RtdCommands::EXCHANGE_SET_ID), + max31865Set10(objects::RTD_10_IC13_PL_TX, EiveMax31855::RtdCommands::EXCHANGE_SET_ID), + max31865Set11(objects::RTD_11_IC14_MPA, EiveMax31855::RtdCommands::EXCHANGE_SET_ID), + max31865Set12(objects::RTD_12_IC15_ACU, EiveMax31855::RtdCommands::EXCHANGE_SET_ID), + max31865Set13(objects::RTD_13_IC16_PLPCDU_HEATSPREADER, EiveMax31855::RtdCommands::EXCHANGE_SET_ID), - max31865Set14(commonObjects::RTD_14_IC17_TCS_BOARD, EiveMax31855::RtdCommands::EXCHANGE_SET_ID), - max31865Set15(commonObjects::RTD_15_IC18_IMTQ, EiveMax31855::RtdCommands::EXCHANGE_SET_ID), - tmp1075Set1(commonObjects::TMP1075_HANDLER_1), - tmp1075Set2(commonObjects::TMP1075_HANDLER_2), - susSet0(commonObjects::SUS_0_N_LOC_XFYFZM_PT_XF), - susSet1(commonObjects::SUS_1_N_LOC_XBYFZM_PT_XB), - susSet2(commonObjects::SUS_2_N_LOC_XFYBZB_PT_YB), - susSet3(commonObjects::SUS_3_N_LOC_XFYBZF_PT_YF), - susSet4(commonObjects::SUS_4_N_LOC_XMYFZF_PT_ZF), - susSet5(commonObjects::SUS_5_N_LOC_XFYMZB_PT_ZB), - susSet6(commonObjects::SUS_6_R_LOC_XFYBZM_PT_XF), - susSet7(commonObjects::SUS_7_R_LOC_XBYBZM_PT_XB), - susSet8(commonObjects::SUS_8_R_LOC_XBYBZB_PT_YB), - susSet9(commonObjects::SUS_9_R_LOC_XBYBZB_PT_YF), - susSet10(commonObjects::SUS_10_N_LOC_XMYBZF_PT_ZF), - susSet11(commonObjects::SUS_11_R_LOC_XBYMZB_PT_ZB) {} + max31865Set14(objects::RTD_14_IC17_TCS_BOARD, EiveMax31855::RtdCommands::EXCHANGE_SET_ID), + max31865Set15(objects::RTD_15_IC18_IMTQ, EiveMax31855::RtdCommands::EXCHANGE_SET_ID), + tmp1075Set1(objects::TMP1075_HANDLER_1), + tmp1075Set2(objects::TMP1075_HANDLER_2), + susSet0(objects::SUS_0_N_LOC_XFYFZM_PT_XF), + susSet1(objects::SUS_1_N_LOC_XBYFZM_PT_XB), + susSet2(objects::SUS_2_N_LOC_XFYBZB_PT_YB), + susSet3(objects::SUS_3_N_LOC_XFYBZF_PT_YF), + susSet4(objects::SUS_4_N_LOC_XMYFZF_PT_ZF), + susSet5(objects::SUS_5_N_LOC_XFYMZB_PT_ZB), + susSet6(objects::SUS_6_R_LOC_XFYBZM_PT_XF), + susSet7(objects::SUS_7_R_LOC_XBYBZM_PT_XB), + susSet8(objects::SUS_8_R_LOC_XBYBZB_PT_YB), + susSet9(objects::SUS_9_R_LOC_XBYBZB_PT_YF), + susSet10(objects::SUS_10_N_LOC_XMYBZF_PT_ZF), + susSet11(objects::SUS_11_R_LOC_XBYMZB_PT_ZB) {} ReturnValue_t ThermalController::initialize() { auto result = ExtendedControllerBase::initialize(); @@ -505,7 +505,7 @@ void ThermalController::copySus() { } void ThermalController::copyDevices() { - lp_var_t tempQ7s = lp_var_t(commonObjects::CORE_CONTROLLER, core::PoolIds::TEMPERATURE); + lp_var_t tempQ7s = lp_var_t(objects::CORE_CONTROLLER, core::PoolIds::TEMPERATURE); ReturnValue_t result = tempQ7s.read(); if (result != RETURN_OK) { sif::warning << "ThermalController: Failed to read Q7S temperature" << std::endl; @@ -520,7 +520,7 @@ void ThermalController::copyDevices() { sif::warning << "ThermalController: Failed to commit" << std::endl; } lp_var_t battTemp1 = - lp_var_t(commonObjects::BPX_BATT_HANDLER, BpxBattery::BATT_TEMP_1); + lp_var_t(objects::BPX_BATT_HANDLER, BpxBattery::BATT_TEMP_1); result = battTemp1.read(); if (result != RETURN_OK) { sif::warning << "ThermalController: Failed to read battery temperature 1" << std::endl; @@ -535,7 +535,7 @@ void ThermalController::copyDevices() { sif::warning << "ThermalController: Failed to commit" << std::endl; } lp_var_t battTemp2 = - lp_var_t(commonObjects::BPX_BATT_HANDLER, BpxBattery::BATT_TEMP_2); + lp_var_t(objects::BPX_BATT_HANDLER, BpxBattery::BATT_TEMP_2); result = battTemp2.read(); if (result != RETURN_OK) { sif::warning << "ThermalController: Failed to read battery temperature 2" << std::endl; @@ -550,7 +550,7 @@ void ThermalController::copyDevices() { sif::warning << "ThermalController: Failed to commit" << std::endl; } lp_var_t battTemp3 = - lp_var_t(commonObjects::BPX_BATT_HANDLER, BpxBattery::BATT_TEMP_3); + lp_var_t(objects::BPX_BATT_HANDLER, BpxBattery::BATT_TEMP_3); result = battTemp3.read(); if (result != RETURN_OK) { sif::warning << "ThermalController: Failed to read battery temperature 3" << std::endl; @@ -565,7 +565,7 @@ void ThermalController::copyDevices() { sif::warning << "ThermalController: Failed to commit" << std::endl; } lp_var_t battTemp4 = - lp_var_t(commonObjects::BPX_BATT_HANDLER, BpxBattery::BATT_TEMP_4); + lp_var_t(objects::BPX_BATT_HANDLER, BpxBattery::BATT_TEMP_4); result = battTemp4.read(); if (result != RETURN_OK) { sif::warning << "ThermalController: Failed to read battery temperature 4" << std::endl; @@ -579,7 +579,7 @@ void ThermalController::copyDevices() { if (result != RETURN_OK) { sif::warning << "ThermalController: Failed to commit" << std::endl; } - lp_var_t tempRw1 = lp_var_t(commonObjects::RW1, RwDefinitions::TEMPERATURE_C); + lp_var_t tempRw1 = lp_var_t(objects::RW1, RwDefinitions::TEMPERATURE_C); result = tempRw1.read(); if (result != RETURN_OK) { sif::warning << "ThermalController: Failed to read reaction wheel 1 temperature" << std::endl; @@ -593,7 +593,7 @@ void ThermalController::copyDevices() { if (result != RETURN_OK) { sif::warning << "ThermalController: Failed to commit" << std::endl; } - lp_var_t tempRw2 = lp_var_t(commonObjects::RW2, RwDefinitions::TEMPERATURE_C); + lp_var_t tempRw2 = lp_var_t(objects::RW2, RwDefinitions::TEMPERATURE_C); result = tempRw2.read(); if (result != RETURN_OK) { sif::warning << "ThermalController: Failed to read reaction wheel 2 temperature" << std::endl; @@ -607,7 +607,7 @@ void ThermalController::copyDevices() { if (result != RETURN_OK) { sif::warning << "ThermalController: Failed to commit" << std::endl; } - lp_var_t tempRw3 = lp_var_t(commonObjects::RW3, RwDefinitions::TEMPERATURE_C); + lp_var_t tempRw3 = lp_var_t(objects::RW3, RwDefinitions::TEMPERATURE_C); result = tempRw3.read(); if (result != RETURN_OK) { sif::warning << "ThermalController: Failed to read reaction wheel 3 temperature" << std::endl; @@ -621,7 +621,7 @@ void ThermalController::copyDevices() { if (result != RETURN_OK) { sif::warning << "ThermalController: Failed to commit" << std::endl; } - lp_var_t tempRw4 = lp_var_t(commonObjects::RW4, RwDefinitions::TEMPERATURE_C); + lp_var_t tempRw4 = lp_var_t(objects::RW4, RwDefinitions::TEMPERATURE_C); result = tempRw4.read(); if (result != RETURN_OK) { sif::warning << "ThermalController: Failed to read reaction wheel 4 temperature" << std::endl; @@ -636,7 +636,7 @@ void ThermalController::copyDevices() { sif::warning << "ThermalController: Failed to commit" << std::endl; } lp_var_t tempStartracker = - lp_var_t(commonObjects::STAR_TRACKER, startracker::MCU_TEMPERATURE); + lp_var_t(objects::STAR_TRACKER, startracker::MCU_TEMPERATURE); result = tempStartracker.read(); if (result != RETURN_OK) { sif::warning << "ThermalController: Failed to read startracker temperature" << std::endl; @@ -651,7 +651,7 @@ void ThermalController::copyDevices() { sif::warning << "ThermalController: Failed to commit" << std::endl; } lp_var_t tempSyrlinksPowerAmplifier = - lp_var_t(commonObjects::SYRLINKS_HK_HANDLER, syrlinks::TEMP_POWER_AMPLIFIER); + lp_var_t(objects::SYRLINKS_HK_HANDLER, syrlinks::TEMP_POWER_AMPLIFIER); result = tempSyrlinksPowerAmplifier.read(); if (result != RETURN_OK) { sif::warning << "ThermalController: Failed to read syrlinks power amplifier temperature" @@ -667,7 +667,7 @@ void ThermalController::copyDevices() { sif::warning << "ThermalController: Failed to commit" << std::endl; } lp_var_t tempSyrlinksBasebandBoard = - lp_var_t(commonObjects::SYRLINKS_HK_HANDLER, syrlinks::TEMP_BASEBAND_BOARD); + lp_var_t(objects::SYRLINKS_HK_HANDLER, syrlinks::TEMP_BASEBAND_BOARD); result = tempSyrlinksBasebandBoard.read(); if (result != RETURN_OK) { sif::warning << "ThermalController: Failed to read syrlinks baseband board temperature" @@ -682,7 +682,7 @@ void ThermalController::copyDevices() { if (result != RETURN_OK) { sif::warning << "ThermalController: Failed to commit" << std::endl; } - lp_var_t tempMgt = lp_var_t(commonObjects::IMTQ_HANDLER, IMTQ::MCU_TEMPERATURE); + lp_var_t tempMgt = lp_var_t(objects::IMTQ_HANDLER, IMTQ::MCU_TEMPERATURE); result = tempMgt.read(); if (result != RETURN_OK) { sif::warning << "ThermalController: Failed to read MGT temperature" << std::endl; @@ -697,7 +697,7 @@ void ThermalController::copyDevices() { sif::warning << "ThermalController: Failed to commit" << std::endl; } lp_vec_t tempAcu = - lp_vec_t(commonObjects::ACU_HANDLER, P60System::pool::ACU_TEMPERATURES); + lp_vec_t(objects::ACU_HANDLER, P60System::pool::ACU_TEMPERATURES); result = tempAcu.read(); if (result != RETURN_OK) { sif::warning << "ThermalController: Failed to read ACU temperatures" << std::endl; @@ -714,7 +714,7 @@ void ThermalController::copyDevices() { sif::warning << "ThermalController: Failed to commit" << std::endl; } lp_var_t tempPdu1 = - lp_var_t(commonObjects::PDU1_HANDLER, P60System::pool::PDU_TEMPERATURE); + lp_var_t(objects::PDU1_HANDLER, P60System::pool::PDU_TEMPERATURE); result = tempPdu1.read(); if (result != RETURN_OK) { sif::warning << "ThermalController: Failed to read PDU1 temperature" << std::endl; @@ -729,7 +729,7 @@ void ThermalController::copyDevices() { sif::warning << "ThermalController: Failed to commit" << std::endl; } lp_var_t tempPdu2 = - lp_var_t(commonObjects::PDU2_HANDLER, P60System::pool::PDU_TEMPERATURE); + lp_var_t(objects::PDU2_HANDLER, P60System::pool::PDU_TEMPERATURE); result = tempPdu2.read(); if (result != RETURN_OK) { sif::warning << "ThermalController: Failed to read PDU2 temperature" << std::endl; @@ -744,7 +744,7 @@ void ThermalController::copyDevices() { sif::warning << "ThermalController: Failed to commit" << std::endl; } lp_var_t temp1P60dock = - lp_var_t(commonObjects::P60DOCK_HANDLER, P60System::pool::P60DOCK_TEMPERATURE_1); + lp_var_t(objects::P60DOCK_HANDLER, P60System::pool::P60DOCK_TEMPERATURE_1); result = temp1P60dock.read(); if (result != RETURN_OK) { sif::warning << "ThermalController: Failed to read P60 dock temperature 1" << std::endl; @@ -759,7 +759,7 @@ void ThermalController::copyDevices() { sif::warning << "ThermalController: Failed to commit" << std::endl; } lp_var_t temp2P60dock = - lp_var_t(commonObjects::P60DOCK_HANDLER, P60System::pool::P60DOCK_TEMPERATURE_2); + lp_var_t(objects::P60DOCK_HANDLER, P60System::pool::P60DOCK_TEMPERATURE_2); result = temp2P60dock.read(); if (result != RETURN_OK) { sif::warning << "ThermalController: Failed to read P60 dock temperature 2" << std::endl; @@ -773,7 +773,7 @@ void ThermalController::copyDevices() { if (result != RETURN_OK) { sif::warning << "ThermalController: Failed to commit" << std::endl; } - lp_var_t tempGyro0 = lp_var_t(commonObjects::GYRO_0_ADIS_HANDLER, ADIS1650X::TEMPERATURE); + lp_var_t tempGyro0 = lp_var_t(objects::GYRO_0_ADIS_HANDLER, ADIS1650X::TEMPERATURE); result = tempGyro0.read(); if (result != RETURN_OK) { sif::warning << "ThermalController: Failed to read gyro 0 temperature" << std::endl; @@ -787,7 +787,7 @@ void ThermalController::copyDevices() { if (result != RETURN_OK) { sif::warning << "ThermalController: Failed to commit" << std::endl; } - lp_var_t tempGyro1 = lp_var_t(commonObjects::GYRO_1_L3G_HANDLER, L3GD20H::TEMPERATURE); + lp_var_t tempGyro1 = lp_var_t(objects::GYRO_1_L3G_HANDLER, L3GD20H::TEMPERATURE); result = tempGyro1.read(); if (result != RETURN_OK) { sif::warning << "ThermalController: Failed to read gyro 1 temperature" << std::endl; @@ -801,7 +801,7 @@ void ThermalController::copyDevices() { if (result != RETURN_OK) { sif::warning << "ThermalController: Failed to commit" << std::endl; } - lp_var_t tempGyro2 = lp_var_t(commonObjects::GYRO_2_ADIS_HANDLER, ADIS1650X::TEMPERATURE); + lp_var_t tempGyro2 = lp_var_t(objects::GYRO_2_ADIS_HANDLER, ADIS1650X::TEMPERATURE); result = tempGyro2.read(); if (result != RETURN_OK) { sif::warning << "ThermalController: Failed to read gyro 2 temperature" << std::endl; @@ -815,7 +815,7 @@ void ThermalController::copyDevices() { if (result != RETURN_OK) { sif::warning << "ThermalController: Failed to commit" << std::endl; } - lp_var_t tempGyro3 = lp_var_t(commonObjects::GYRO_3_L3G_HANDLER, L3GD20H::TEMPERATURE); + lp_var_t tempGyro3 = lp_var_t(objects::GYRO_3_L3G_HANDLER, L3GD20H::TEMPERATURE); result = tempGyro3.read(); if (result != RETURN_OK) { sif::warning << "ThermalController: Failed to read gyro 3 temperature" << std::endl; @@ -830,7 +830,7 @@ void ThermalController::copyDevices() { sif::warning << "ThermalController: Failed to commit" << std::endl; } lp_var_t tempMgm0 = - lp_var_t(commonObjects::MGM_0_LIS3_HANDLER, MGMLIS3MDL::TEMPERATURE_CELCIUS); + lp_var_t(objects::MGM_0_LIS3_HANDLER, MGMLIS3MDL::TEMPERATURE_CELCIUS); result = tempMgm0.read(); if (result != RETURN_OK) { sif::warning << "ThermalController: Failed to read MGM 0 temperature" << std::endl; @@ -845,7 +845,7 @@ void ThermalController::copyDevices() { sif::warning << "ThermalController: Failed to commit" << std::endl; } lp_var_t tempMgm2 = - lp_var_t(commonObjects::MGM_2_LIS3_HANDLER, MGMLIS3MDL::TEMPERATURE_CELCIUS); + lp_var_t(objects::MGM_2_LIS3_HANDLER, MGMLIS3MDL::TEMPERATURE_CELCIUS); result = tempMgm2.read(); if (result != RETURN_OK) { sif::warning << "ThermalController: Failed to read MGM 2 temperature" << std::endl; @@ -859,7 +859,7 @@ void ThermalController::copyDevices() { if (result != RETURN_OK) { sif::warning << "ThermalController: Failed to commit" << std::endl; } - lp_var_t tempAdcPayloadPcdu = lp_var_t(commonObjects::PLPCDU_HANDLER, plpcdu::TEMP); + lp_var_t tempAdcPayloadPcdu = lp_var_t(objects::PLPCDU_HANDLER, plpcdu::TEMP); result = tempAdcPayloadPcdu.read(); if (result != RETURN_OK) { sif::warning << "ThermalController: Failed to read payload PCDU ADC temperature" << std::endl; diff --git a/mission/core/GenericFactory.cpp b/mission/core/GenericFactory.cpp index dfc00ab3..1be91594 100644 --- a/mission/core/GenericFactory.cpp +++ b/mission/core/GenericFactory.cpp @@ -74,20 +74,20 @@ void ObjectFactory::produceGenericObjects(HealthTableIF** healthTable_) { new PoolManager(objects::IPC_STORE, poolCfg); } - auto* ccsdsDistrib = new CCSDSDistributor(apid::EIVE_OBSW, commonObjects::CCSDS_PACKET_DISTRIBUTOR); - new PUSDistributor(apid::EIVE_OBSW, commonObjects::PUS_PACKET_DISTRIBUTOR, - commonObjects::CCSDS_PACKET_DISTRIBUTOR); + auto* ccsdsDistrib = new CCSDSDistributor(apid::EIVE_OBSW, objects::CCSDS_PACKET_DISTRIBUTOR); + new PUSDistributor(apid::EIVE_OBSW, objects::PUS_PACKET_DISTRIBUTOR, + objects::CCSDS_PACKET_DISTRIBUTOR); uint8_t vc = 0; #if OBSW_TM_TO_PTME == 1 vc = config::LIVE_TM; #endif // Every TM packet goes through this funnel - new TmFunnel(systemObjects::TM_FUNNEL, 50, vc); + new TmFunnel(objects::TM_FUNNEL, 50, vc); // PUS service stack new Service1TelecommandVerification(objects::PUS_SERVICE_1_VERIFICATION, apid::EIVE_OBSW, - pus::PUS_SERVICE_1, systemObjects::TM_FUNNEL, 20); + 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, @@ -109,13 +109,13 @@ void ObjectFactory::produceGenericObjects(HealthTableIF** healthTable_) { pus::PUS_SERVICE_201); #if OBSW_ADD_TCPIP_BRIDGE == 1 #if OBSW_USE_TMTC_TCP_BRIDGE == 0 - auto tmtcBridge = new UdpTmTcBridge(commonObjects::TMTC_BRIDGE, commonObjects::CCSDS_PACKET_DISTRIBUTOR); - new UdpTcPollingTask(commonObjects::TMTC_POLLING_TASK, commonObjects::TMTC_BRIDGE); + 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(commonObjects::TMTC_BRIDGE, commonObjects::CCSDS_PACKET_DISTRIBUTOR); - auto tcpServer = new TcpTmTcServer(commonObjects::TMTC_POLLING_TASK, commonObjects::TMTC_BRIDGE); + 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 " diff --git a/mission/devices/GomspaceDeviceHandler.cpp b/mission/devices/GomspaceDeviceHandler.cpp index 0ea91ea7..1d7ef718 100644 --- a/mission/devices/GomspaceDeviceHandler.cpp +++ b/mission/devices/GomspaceDeviceHandler.cpp @@ -143,7 +143,7 @@ void GomspaceDeviceHandler::setNormalDatapoolEntriesInvalid() {} ReturnValue_t GomspaceDeviceHandler::handleAction(ParamSetAction* action) { // This breaks layering but I really don't want to accept this command.. if (action->address == PDU2::CONFIG_ADDRESS_OUT_EN_Q7S and - this->getObjectId() == commonObjects::PDU2_HANDLER) { + this->getObjectId() == objects::PDU2_HANDLER) { triggerEvent(power::SWITCHING_Q7S_DENIED, 0, 0); return HasReturnvaluesIF::RETURN_FAILED; } diff --git a/mission/devices/PCDUHandler.cpp b/mission/devices/PCDUHandler.cpp index b4f379dd..fc2851b5 100644 --- a/mission/devices/PCDUHandler.cpp +++ b/mission/devices/PCDUHandler.cpp @@ -46,7 +46,7 @@ ReturnValue_t PCDUHandler::initialize() { /* Subscribing for housekeeping table update messages of the PDU2 */ HasLocalDataPoolIF* pdu2Handler = - ObjectManager::instance()->get(commonObjects::PDU2_HANDLER); + ObjectManager::instance()->get(objects::PDU2_HANDLER); if (pdu2Handler == nullptr) { sif::error << "PCDUHandler::initialize: Invalid pdu2Handler" << std::endl; return RETURN_FAILED; @@ -62,7 +62,7 @@ ReturnValue_t PCDUHandler::initialize() { /* Subscribing for housekeeping table update messages of the PDU1 */ HasLocalDataPoolIF* pdu1Handler = - ObjectManager::instance()->get(commonObjects::PDU1_HANDLER); + ObjectManager::instance()->get(objects::PDU1_HANDLER); if (pdu1Handler == nullptr) { sif::error << "PCDUHandler::initialize: Invalid pdu1Handler" << std::endl; return RETURN_FAILED; @@ -110,11 +110,11 @@ void PCDUHandler::readCommandQueue() { MessageQueueId_t PCDUHandler::getCommandQueue() const { return commandQueue->getId(); } void PCDUHandler::handleChangedDataset(sid_t sid, store_address_t storeId, bool* clearMessage) { - if (sid == sid_t(commonObjects::PDU2_HANDLER, static_cast(P60System::SetIds::PDU_2_CORE))) { + if (sid == sid_t(objects::PDU2_HANDLER, static_cast(P60System::SetIds::PDU_2_CORE))) { updateHkTableDataset(storeId, &pdu2CoreHk, &timeStampPdu2HkDataset); updatePdu2SwitchStates(); } else if (sid == - sid_t(commonObjects::PDU1_HANDLER, static_cast(P60System::SetIds::PDU_1_CORE))) { + sid_t(objects::PDU1_HANDLER, static_cast(P60System::SetIds::PDU_1_CORE))) { updateHkTableDataset(storeId, &pdu1CoreHk, &timeStampPdu1HkDataset); updatePdu1SwitchStates(); } else { @@ -232,94 +232,94 @@ ReturnValue_t PCDUHandler::sendSwitchCommand(uint8_t switchNr, ReturnValue_t onO switch (switchNr) { case pcdu::PDU1_CH0_TCS_BOARD_3V3: { memoryAddress = PDU1::CONFIG_ADDRESS_OUT_EN_TCS_BOARD_3V3; - pdu = ObjectManager::instance()->get(commonObjects::PDU1_HANDLER); + pdu = ObjectManager::instance()->get(objects::PDU1_HANDLER); break; } case pcdu::PDU1_CH1_SYRLINKS_12V: { memoryAddress = PDU1::CONFIG_ADDRESS_OUT_EN_SYRLINKS; - pdu = ObjectManager::instance()->get(commonObjects::PDU1_HANDLER); + pdu = ObjectManager::instance()->get(objects::PDU1_HANDLER); break; } case pcdu::PDU1_CH2_STAR_TRACKER_5V: { memoryAddress = PDU1::CONFIG_ADDRESS_OUT_EN_STAR_TRACKER; - pdu = ObjectManager::instance()->get(commonObjects::PDU1_HANDLER); + pdu = ObjectManager::instance()->get(objects::PDU1_HANDLER); break; } case pcdu::PDU1_CH3_MGT_5V: { memoryAddress = PDU1::CONFIG_ADDRESS_OUT_EN_MGT; - pdu = ObjectManager::instance()->get(commonObjects::PDU1_HANDLER); + pdu = ObjectManager::instance()->get(objects::PDU1_HANDLER); break; } case pcdu::PDU1_CH4_SUS_NOMINAL_3V3: { memoryAddress = PDU1::CONFIG_ADDRESS_OUT_EN_SUS_NOMINAL; - pdu = ObjectManager::instance()->get(commonObjects::PDU1_HANDLER); + pdu = ObjectManager::instance()->get(objects::PDU1_HANDLER); break; } case pcdu::PDU1_CH5_SOLAR_CELL_EXP_5V: { memoryAddress = PDU1::CONFIG_ADDRESS_OUT_EN_SOLAR_CELL_EXP; - pdu = ObjectManager::instance()->get(commonObjects::PDU1_HANDLER); + pdu = ObjectManager::instance()->get(objects::PDU1_HANDLER); break; } case pcdu::PDU1_CH6_PLOC_12V: { memoryAddress = PDU1::CONFIG_ADDRESS_OUT_EN_PLOC; - pdu = ObjectManager::instance()->get(commonObjects::PDU1_HANDLER); + pdu = ObjectManager::instance()->get(objects::PDU1_HANDLER); break; } case pcdu::PDU1_CH7_ACS_A_SIDE_3V3: { memoryAddress = PDU1::CONFIG_ADDRESS_OUT_EN_ACS_BOARD_SIDE_A; - pdu = ObjectManager::instance()->get(commonObjects::PDU1_HANDLER); + pdu = ObjectManager::instance()->get(objects::PDU1_HANDLER); break; } case pcdu::PDU1_CH8_UNOCCUPIED: { memoryAddress = PDU1::CONFIG_ADDRESS_OUT_EN_CHANNEL8; - pdu = ObjectManager::instance()->get(commonObjects::PDU1_HANDLER); + pdu = ObjectManager::instance()->get(objects::PDU1_HANDLER); break; } // This is a dangerous command. Reject/Igore it for now case pcdu::PDU2_CH0_Q7S: { return RETURN_FAILED; // memoryAddress = PDU2::CONFIG_ADDRESS_OUT_EN_Q7S; - // pdu = ObjectManager::instance()->get(commonObjects::PDU2_HANDLER); + // pdu = ObjectManager::instance()->get(objects::PDU2_HANDLER); // break; } case pcdu::PDU2_CH1_PL_PCDU_BATT_0_14V8: { memoryAddress = PDU2::CONFIG_ADDRESS_OUT_EN_PAYLOAD_PCDU_CH1; - pdu = ObjectManager::instance()->get(commonObjects::PDU2_HANDLER); + pdu = ObjectManager::instance()->get(objects::PDU2_HANDLER); break; } case pcdu::PDU2_CH2_RW_5V: { memoryAddress = PDU2::CONFIG_ADDRESS_OUT_EN_RW; - pdu = ObjectManager::instance()->get(commonObjects::PDU2_HANDLER); + pdu = ObjectManager::instance()->get(objects::PDU2_HANDLER); break; } case pcdu::PDU2_CH3_TCS_BOARD_HEATER_IN_8V: { memoryAddress = PDU2::CONFIG_ADDRESS_OUT_EN_TCS_BOARD_HEATER_IN; - pdu = ObjectManager::instance()->get(commonObjects::PDU2_HANDLER); + pdu = ObjectManager::instance()->get(objects::PDU2_HANDLER); break; } case pcdu::PDU2_CH4_SUS_REDUNDANT_3V3: { memoryAddress = PDU2::CONFIG_ADDRESS_OUT_EN_SUS_REDUNDANT; - pdu = ObjectManager::instance()->get(commonObjects::PDU2_HANDLER); + pdu = ObjectManager::instance()->get(objects::PDU2_HANDLER); break; } case pcdu::PDU2_CH5_DEPLOYMENT_MECHANISM_8V: { memoryAddress = PDU2::CONFIG_ADDRESS_OUT_EN_DEPLOYMENT_MECHANISM; - pdu = ObjectManager::instance()->get(commonObjects::PDU2_HANDLER); + pdu = ObjectManager::instance()->get(objects::PDU2_HANDLER); break; } case pcdu::PDU2_CH6_PL_PCDU_BATT_1_14V8: { memoryAddress = PDU2::CONFIG_ADDRESS_OUT_EN_PAYLOAD_PCDU_CH6; - pdu = ObjectManager::instance()->get(commonObjects::PDU2_HANDLER); + pdu = ObjectManager::instance()->get(objects::PDU2_HANDLER); break; } case pcdu::PDU2_CH7_ACS_BOARD_SIDE_B_3V3: { memoryAddress = PDU2::CONFIG_ADDRESS_OUT_EN_ACS_BOARD_SIDE_B; - pdu = ObjectManager::instance()->get(commonObjects::PDU2_HANDLER); + pdu = ObjectManager::instance()->get(objects::PDU2_HANDLER); break; } case pcdu::PDU2_CH8_PAYLOAD_CAMERA: { memoryAddress = PDU2::CONFIG_ADDRESS_OUT_EN_PAYLOAD_CAMERA; - pdu = ObjectManager::instance()->get(commonObjects::PDU2_HANDLER); + pdu = ObjectManager::instance()->get(objects::PDU2_HANDLER); break; } diff --git a/mission/system/fdir/AcsBoardFdir.cpp b/mission/system/fdir/AcsBoardFdir.cpp index 607e4189..931f43c0 100644 --- a/mission/system/fdir/AcsBoardFdir.cpp +++ b/mission/system/fdir/AcsBoardFdir.cpp @@ -3,4 +3,4 @@ #include AcsBoardFdir::AcsBoardFdir(object_id_t sensorId) - : DeviceHandlerFailureIsolation(sensorId, commonObjects::ACS_BOARD_ASS) {} + : DeviceHandlerFailureIsolation(sensorId, objects::ACS_BOARD_ASS) {} diff --git a/mission/system/fdir/RtdFdir.cpp b/mission/system/fdir/RtdFdir.cpp index c911caad..f4f9806e 100644 --- a/mission/system/fdir/RtdFdir.cpp +++ b/mission/system/fdir/RtdFdir.cpp @@ -3,4 +3,4 @@ #include RtdFdir::RtdFdir(object_id_t sensorId) - : DeviceHandlerFailureIsolation(sensorId, commonObjects::TCS_BOARD_ASS) {} + : DeviceHandlerFailureIsolation(sensorId, objects::TCS_BOARD_ASS) {} diff --git a/mission/system/fdir/SusFdir.cpp b/mission/system/fdir/SusFdir.cpp index d8871250..a2e0aff4 100644 --- a/mission/system/fdir/SusFdir.cpp +++ b/mission/system/fdir/SusFdir.cpp @@ -3,4 +3,4 @@ #include SusFdir::SusFdir(object_id_t sensorId) - : DeviceHandlerFailureIsolation(sensorId, commonObjects::SUS_BOARD_ASS) {} + : DeviceHandlerFailureIsolation(sensorId, objects::SUS_BOARD_ASS) {}