eive/eive-obsw
eive/eive-obsw
13
4
Fork 0
Code Issues 4 Pull Requests 1 Releases 120 Wiki Activity

I knew this was stupid: Revert "changing mission dependend object IDs to FSFW_ENUM"

Browse Source 
This reverts commit 2800484f6b.
This commit is contained in:
Ulrich Mohr 2022-08-25 14:43:27 +02:00
parent 2800484f6b
commit fe8036361d
24 changed files with 780 additions and 787 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

140
bsp_q7s/core/InitMission.cpp
View File

@ -161,16 +161,8 @@ void initmission::initMission() {
sif::info << "Looping.." << std::endl; sif::info << "Looping.." << std::endl;
for (auto iter : *objectList) { for (auto iter : *objectList) {
const char * name = "UNKNOWN"; //SystemObjects objectId(iter.first);
commonObjects commonObjectId(iter.first); printf("Object \"%s\" (0x%08x)\n", "TODO", 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);
HasActionsIF* actionIf = dynamic_cast<HasActionsIF*>(iter.second); HasActionsIF* actionIf = dynamic_cast<HasActionsIF*>(iter.second);
if (actionIf != nullptr) { if (actionIf != nullptr) {
@ -217,49 +209,49 @@ void initmission::initTasks() {
PeriodicTaskIF* coreController = factory->createPeriodicTask( PeriodicTaskIF* coreController = factory->createPeriodicTask(
"CORE_CTRL", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.4, missedDeadlineFunc); "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) { if (result != HasReturnvaluesIF::RETURN_OK) {
initmission::printAddObjectError("CORE_CTRL", commonObjects::CORE_CONTROLLER); initmission::printAddObjectError("CORE_CTRL", objects::CORE_CONTROLLER);
} }
/* TMTC Distribution */ /* TMTC Distribution */
PeriodicTaskIF* tmTcDistributor = factory->createPeriodicTask( PeriodicTaskIF* tmTcDistributor = factory->createPeriodicTask(
"DIST", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc); "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) { 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) { 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) { 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 #if OBSW_ADD_TCPIP_BRIDGE == 1
// TMTC bridge // TMTC bridge
PeriodicTaskIF* tmtcBridgeTask = factory->createPeriodicTask( PeriodicTaskIF* tmtcBridgeTask = factory->createPeriodicTask(
"TCPIP_TMTC_BRIDGE", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc); "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) { if (result != HasReturnvaluesIF::RETURN_OK) {
initmission::printAddObjectError("TMTC_BRIDGE", commonObjects::TMTC_BRIDGE); initmission::printAddObjectError("TMTC_BRIDGE", objects::TMTC_BRIDGE);
} }
PeriodicTaskIF* tmtcPollingTask = factory->createPeriodicTask( PeriodicTaskIF* tmtcPollingTask = factory->createPeriodicTask(
"TMTC_POLLING", 80, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc); "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) { if (result != HasReturnvaluesIF::RETURN_OK) {
initmission::printAddObjectError("UDP_POLLING", commonObjects::TMTC_POLLING_TASK); initmission::printAddObjectError("UDP_POLLING", objects::TMTC_POLLING_TASK);
} }
#endif #endif
#if OBSW_USE_CCSDS_IP_CORE == 1 #if OBSW_USE_CCSDS_IP_CORE == 1
PeriodicTaskIF* ccsdsHandlerTask = factory->createPeriodicTask( PeriodicTaskIF* ccsdsHandlerTask = factory->createPeriodicTask(
"CCSDS_HANDLER", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc); "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) { 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 // Minimal distance between two received TCs amounts to 0.6 seconds
@ -267,77 +259,77 @@ void initmission::initTasks() {
// overwritten by the PDEC. // overwritten by the PDEC.
PeriodicTaskIF* pdecHandlerTask = factory->createPeriodicTask( PeriodicTaskIF* pdecHandlerTask = factory->createPeriodicTask(
"PDEC_HANDLER", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, missedDeadlineFunc); "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) { 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 */ #endif /* OBSW_USE_CCSDS_IP_CORE == 1 */
#if OBSW_ADD_ACS_HANDLERS == 1 #if OBSW_ADD_ACS_HANDLERS == 1
PeriodicTaskIF* acsTask = factory->createPeriodicTask( PeriodicTaskIF* acsTask = factory->createPeriodicTask(
"ACS_TASK", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 0.4, missedDeadlineFunc); "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) { if (result != HasReturnvaluesIF::RETURN_OK) {
initmission::printAddObjectError("GPS_CTRL", commonObjects::GPS_CONTROLLER); initmission::printAddObjectError("GPS_CTRL", objects::GPS_CONTROLLER);
} }
#endif /* OBSW_ADD_ACS_HANDLERS */ #endif /* OBSW_ADD_ACS_HANDLERS */
acsTask->addComponent(commonObjects::ACS_CONTROLLER); acsTask->addComponent(objects::ACS_CONTROLLER);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
initmission::printAddObjectError("ACS_CTRL", commonObjects::ACS_CONTROLLER); initmission::printAddObjectError("ACS_CTRL", objects::ACS_CONTROLLER);
} }
PeriodicTaskIF* sysTask = factory->createPeriodicTask( PeriodicTaskIF* sysTask = factory->createPeriodicTask(
"SYS_TASK", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 0.4, missedDeadlineFunc); "SYS_TASK", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 0.4, missedDeadlineFunc);
static_cast<void>(sysTask); static_cast<void>(sysTask);
#if OBSW_ADD_ACS_HANDLERS == 1 #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) { 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 */ #endif /* OBSW_ADD_ACS_HANDLERS */
#if OBSW_ADD_RW == 1 #if OBSW_ADD_RW == 1
result = sysTask->addComponent(commonObjects::RW_ASS); result = sysTask->addComponent(objects::RW_ASS);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
initmission::printAddObjectError("RW_ASS", commonObjects::RW_ASS); initmission::printAddObjectError("RW_ASS", objects::RW_ASS);
} }
#endif #endif
#if OBSW_ADD_SUS_BOARD_ASS == 1 #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) { if (result != HasReturnvaluesIF::RETURN_OK) {
initmission::printAddObjectError("SUS_BOARD_ASS", commonObjects::SUS_BOARD_ASS); initmission::printAddObjectError("SUS_BOARD_ASS", objects::SUS_BOARD_ASS);
} }
#endif #endif
#if OBSW_ADD_RTD_DEVICES == 1 #if OBSW_ADD_RTD_DEVICES == 1
PeriodicTaskIF* tcsPollingTask = factory->createPeriodicTask( PeriodicTaskIF* tcsPollingTask = factory->createPeriodicTask(
"TCS_POLLING_TASK", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 0.5, missedDeadlineFunc); "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) { 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( PeriodicTaskIF* tcsTask = factory->createPeriodicTask(
"TCS_TASK", 45, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.8, missedDeadlineFunc); "TCS_TASK", 45, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.8, missedDeadlineFunc);
std::array<object_id_t, EiveMax31855::NUM_RTDS> rtdIds = { std::array<object_id_t, EiveMax31855::NUM_RTDS> rtdIds = {
commonObjects::RTD_0_IC3_PLOC_HEATSPREADER, objects::RTD_0_IC3_PLOC_HEATSPREADER,
commonObjects::RTD_1_IC4_PLOC_MISSIONBOARD, objects::RTD_1_IC4_PLOC_MISSIONBOARD,
commonObjects::RTD_2_IC5_4K_CAMERA, objects::RTD_2_IC5_4K_CAMERA,
commonObjects::RTD_3_IC6_DAC_HEATSPREADER, objects::RTD_3_IC6_DAC_HEATSPREADER,
commonObjects::RTD_4_IC7_STARTRACKER, objects::RTD_4_IC7_STARTRACKER,
commonObjects::RTD_5_IC8_RW1_MX_MY, objects::RTD_5_IC8_RW1_MX_MY,
commonObjects::RTD_6_IC9_DRO, objects::RTD_6_IC9_DRO,
commonObjects::RTD_7_IC10_SCEX, objects::RTD_7_IC10_SCEX,
commonObjects::RTD_8_IC11_X8, objects::RTD_8_IC11_X8,
commonObjects::RTD_9_IC12_HPA, objects::RTD_9_IC12_HPA,
commonObjects::RTD_10_IC13_PL_TX, objects::RTD_10_IC13_PL_TX,
commonObjects::RTD_11_IC14_MPA, objects::RTD_11_IC14_MPA,
commonObjects::RTD_12_IC15_ACU, objects::RTD_12_IC15_ACU,
commonObjects::RTD_13_IC16_PLPCDU_HEATSPREADER, objects::RTD_13_IC16_PLPCDU_HEATSPREADER,
commonObjects::RTD_14_IC17_TCS_BOARD, objects::RTD_14_IC17_TCS_BOARD,
commonObjects::RTD_15_IC18_IMTQ, objects::RTD_15_IC18_IMTQ,
}; };
tcsTask->addComponent(commonObjects::TCS_BOARD_ASS); tcsTask->addComponent(objects::TCS_BOARD_ASS);
tcsTask->addComponent(commonObjects::THERMAL_CONTROLLER); tcsTask->addComponent(objects::THERMAL_CONTROLLER);
for (const auto& rtd : rtdIds) { for (const auto& rtd : rtdIds) {
tcsTask->addComponent(rtd, DeviceHandlerIF::PERFORM_OPERATION); tcsTask->addComponent(rtd, DeviceHandlerIF::PERFORM_OPERATION);
tcsTask->addComponent(rtd, DeviceHandlerIF::SEND_WRITE); tcsTask->addComponent(rtd, DeviceHandlerIF::SEND_WRITE);
@ -351,44 +343,44 @@ void initmission::initTasks() {
// because it is a non-essential background task // because it is a non-essential background task
PeriodicTaskIF* fsTask = factory->createPeriodicTask( PeriodicTaskIF* fsTask = factory->createPeriodicTask(
"FILE_SYSTEM_TASK", 25, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.4, missedDeadlineFunc); "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) { 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 #if OBSW_ADD_STAR_TRACKER == 1
PeriodicTaskIF* strHelperTask = factory->createPeriodicTask( PeriodicTaskIF* strHelperTask = factory->createPeriodicTask(
"STR_HELPER", 20, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc); "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) { 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 */ #endif /* OBSW_ADD_STAR_TRACKER == 1 */
#if OBSW_ADD_PLOC_MPSOC == 1 #if OBSW_ADD_PLOC_MPSOC == 1
PeriodicTaskIF* mpsocHelperTask = factory->createPeriodicTask( PeriodicTaskIF* mpsocHelperTask = factory->createPeriodicTask(
"PLOC_MPSOC_HELPER", 20, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc); "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) { 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 */ #endif /* OBSW_ADD_PLOC_MPSOC */
#if OBSW_ADD_PLOC_SUPERVISOR == 1 #if OBSW_ADD_PLOC_SUPERVISOR == 1
PeriodicTaskIF* supvHelperTask = factory->createPeriodicTask( PeriodicTaskIF* supvHelperTask = factory->createPeriodicTask(
"PLOC_SUPV_HELPER", 10, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, missedDeadlineFunc); "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) { 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 */ #endif /* OBSW_ADD_PLOC_SUPERVISOR */
#if OBSW_TEST_CCSDS_BRIDGE == 1 #if OBSW_TEST_CCSDS_BRIDGE == 1
PeriodicTaskIF* ptmeTestTask = factory->createPeriodicTask( PeriodicTaskIF* ptmeTestTask = factory->createPeriodicTask(
"PTME_TEST", 80, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc); "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) { if (result != HasReturnvaluesIF::RETURN_OK) {
initmission::printAddObjectError("PTME_TEST", commonObjects::CCSDS_IP_CORE_BRIDGE); initmission::printAddObjectError("PTME_TEST", objects::CCSDS_IP_CORE_BRIDGE);
} }
#endif #endif
@ -633,27 +625,27 @@ void initmission::createTestTasks(TaskFactory& factory,
PeriodicTaskIF* testTask = factory.createPeriodicTask( PeriodicTaskIF* testTask = factory.createPeriodicTask(
"TEST_TASK", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1, missedDeadlineFunc); "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) { 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 #if OBSW_ADD_SPI_TEST_CODE == 1
result = testTask->addComponent(commonObjects::SPI_TEST); result = testTask->addComponent(objects::SPI_TEST);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
initmission::printAddObjectError("SPI_TEST", commonObjects::SPI_TEST); initmission::printAddObjectError("SPI_TEST", objects::SPI_TEST);
} }
#endif #endif
#if OBSW_ADD_I2C_TEST_CODE == 1 #if OBSW_ADD_I2C_TEST_CODE == 1
result = testTask->addComponent(commonObjects::I2C_TEST); result = testTask->addComponent(objects::I2C_TEST);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
initmission::printAddObjectError("I2C_TEST", commonObjects::I2C_TEST); initmission::printAddObjectError("I2C_TEST", objects::I2C_TEST);
} }
#endif #endif
#if OBSW_ADD_UART_TEST_CODE == 1 #if OBSW_ADD_UART_TEST_CODE == 1
result = testTask->addComponent(commonObjects::UART_TEST); result = testTask->addComponent(objects::UART_TEST);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
initmission::printAddObjectError("UART_TEST", commonObjects::UART_TEST); initmission::printAddObjectError("UART_TEST", objects::UART_TEST);
} }
#endif #endif

248
bsp_q7s/core/ObjectFactory.cpp
View File

@ -95,22 +95,22 @@
ResetArgs RESET_ARGS_GNSS; ResetArgs RESET_ARGS_GNSS;
void Factory::setStaticFrameworkObjectIds() { void Factory::setStaticFrameworkObjectIds() {
PusServiceBase::packetSource = commonObjects::PUS_PACKET_DISTRIBUTOR; PusServiceBase::packetSource = objects::PUS_PACKET_DISTRIBUTOR;
PusServiceBase::packetDestination = systemObjects::TM_FUNNEL; PusServiceBase::packetDestination = objects::TM_FUNNEL;
CommandingServiceBase::defaultPacketSource = commonObjects::PUS_PACKET_DISTRIBUTOR; CommandingServiceBase::defaultPacketSource = objects::PUS_PACKET_DISTRIBUTOR;
CommandingServiceBase::defaultPacketDestination = systemObjects::TM_FUNNEL; CommandingServiceBase::defaultPacketDestination = objects::TM_FUNNEL;
#if OBSW_Q7S_EM == 1 #if OBSW_Q7S_EM == 1
DeviceHandlerBase::powerSwitcherId = objetcs::NO_OBJECT; DeviceHandlerBase::powerSwitcherId = objects::NO_OBJECT;
#else #else
DeviceHandlerBase::powerSwitcherId = commonObjects::PCDU_HANDLER; DeviceHandlerBase::powerSwitcherId = objects::PCDU_HANDLER;
#endif /* OBSW_Q7S_EM == 1 */ #endif /* OBSW_Q7S_EM == 1 */
#if OBSW_TM_TO_PTME == 1 #if OBSW_TM_TO_PTME == 1
TmFunnel::downlinkDestination = commonObjects::CCSDS_HANDLER; TmFunnel::downlinkDestination = objects::CCSDS_HANDLER;
#else #else
TmFunnel::downlinkDestination = commonObjects::TMTC_BRIDGE; TmFunnel::downlinkDestination = objects::TMTC_BRIDGE;
#endif /* OBSW_TM_TO_PTME == 1 */ #endif /* OBSW_TM_TO_PTME == 1 */
// No storage object for now. // No storage object for now.
TmFunnel::storageDestination = objects::NO_OBJECT; TmFunnel::storageDestination = objects::NO_OBJECT;
@ -131,10 +131,10 @@ void ObjectFactory::createTmpComponents() {
/* Temperature sensors */ /* Temperature sensors */
Tmp1075Handler* tmp1075Handler_1 = 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; (void)tmp1075Handler_1;
Tmp1075Handler* tmp1075Handler_2 = 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; (void)tmp1075Handler_2;
} }
@ -146,14 +146,14 @@ void ObjectFactory::createCommunicationInterfaces(LinuxLibgpioIF** gpioComIF, Ua
sif::error << "ObjectFactory::createCommunicationInterfaces: Invalid passed ComIF pointer" sif::error << "ObjectFactory::createCommunicationInterfaces: Invalid passed ComIF pointer"
<< std::endl; << std::endl;
} }
*gpioComIF = new LinuxLibgpioIF(systemObjects::GPIO_IF); *gpioComIF = new LinuxLibgpioIF(objects::GPIO_IF);
/* Communication interfaces */ /* Communication interfaces */
new CspComIF(systemObjects::CSP_COM_IF); new CspComIF(objects::CSP_COM_IF);
*i2cComIF = new I2cComIF(systemObjects::I2C_COM_IF); *i2cComIF = new I2cComIF(objects::I2C_COM_IF);
*uartComIF = new UartComIF(systemObjects::UART_COM_IF); *uartComIF = new UartComIF(objects::UART_COM_IF);
*spiMainComIF = new SpiComIF(systemObjects::SPI_MAIN_COM_IF, q7s::SPI_DEFAULT_DEV, *gpioComIF); *spiMainComIF = new SpiComIF(objects::SPI_MAIN_COM_IF, q7s::SPI_DEFAULT_DEV, *gpioComIF);
*spiRWComIF = new SpiComIF(systemObjects::SPI_RW_COM_IF, q7s::SPI_RW_DEV, *gpioComIF); *spiRWComIF = new SpiComIF(objects::SPI_RW_COM_IF, q7s::SPI_RW_DEV, *gpioComIF);
/* Adding gpios for chip select decoding to the gpioComIf */ /* Adding gpios for chip select decoding to the gpioComIf */
q7s::gpioCallbacks::initSpiCsDecoder(*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* pdu2CspCookie = new CspCookie(PDU::MAX_REPLY_LENGTH, addresses::PDU2);
CspCookie* acuCspCookie = new CspCookie(ACU::MAX_REPLY_LENGTH, addresses::ACU); 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 = 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 = 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 = 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 = ACUHandler* acuhandler =
new ACUHandler(commonObjects::ACU_HANDLER, systemObjects::CSP_COM_IF, acuCspCookie, acuFdir); new ACUHandler(objects::ACU_HANDLER, objects::CSP_COM_IF, acuCspCookie, acuFdir);
auto pcduHandler = new PCDUHandler(commonObjects::PCDU_HANDLER, 50); auto pcduHandler = new PCDUHandler(objects::PCDU_HANDLER, 50);
/** /**
* Setting PCDU devices to mode normal immediately after start up because PCDU is always * 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; using namespace gpio;
GpioCookie* gpioCookieRadSensor = new GpioCookie; GpioCookie* gpioCookieRadSensor = new GpioCookie;
std::stringstream consumer; std::stringstream consumer;
consumer << "0x" << std::hex << commonObjects::RAD_SENSOR; consumer << "0x" << std::hex << objects::RAD_SENSOR;
GpiodRegularByLineName* gpio = new GpiodRegularByLineName( GpiodRegularByLineName* gpio = new GpiodRegularByLineName(
q7s::gpioNames::RAD_SENSOR_CHIP_SELECT, consumer.str(), Direction::OUT, Levels::HIGH); q7s::gpioNames::RAD_SENSOR_CHIP_SELECT, consumer.str(), Direction::OUT, Levels::HIGH);
gpioCookieRadSensor->addGpio(gpioIds::CS_RAD_SENSOR, gpio); 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, new SpiCookie(addresses::RAD_SENSOR, gpioIds::CS_RAD_SENSOR, RAD_SENSOR::READ_SIZE,
spi::DEFAULT_MAX_1227_MODE, spi::DEFAULT_MAX_1227_SPEED); spi::DEFAULT_MAX_1227_MODE, spi::DEFAULT_MAX_1227_SPEED);
spiCookieRadSensor->setMutexParams(MutexIF::TimeoutType::WAITING, spi::RAD_SENSOR_CS_TIMEOUT); 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); spiCookieRadSensor, gpioComIF);
static_cast<void>(radSensor); static_cast<void>(radSensor);
// The radiation sensor ADC is powered by the 5V stack connector which should always be on // 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; std::stringstream consumer;
GpiodRegularByLineName* gpio = nullptr; 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, gpio = new GpiodRegularByLineName(q7s::gpioNames::GYRO_0_ADIS_CS, consumer.str(), Direction::OUT,
Levels::HIGH); Levels::HIGH);
gpioCookieAcsBoard->addGpio(gpioIds::GYRO_0_ADIS_CS, gpio); gpioCookieAcsBoard->addGpio(gpioIds::GYRO_0_ADIS_CS, gpio);
consumer.str(""); 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, gpio = new GpiodRegularByLineName(q7s::gpioNames::GYRO_1_L3G_CS, consumer.str(), Direction::OUT,
Levels::HIGH); Levels::HIGH);
gpioCookieAcsBoard->addGpio(gpioIds::GYRO_1_L3G_CS, gpio); gpioCookieAcsBoard->addGpio(gpioIds::GYRO_1_L3G_CS, gpio);
consumer.str(""); 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, gpio = new GpiodRegularByLineName(q7s::gpioNames::GYRO_2_ADIS_CS, consumer.str(), Direction::OUT,
Levels::HIGH); Levels::HIGH);
gpioCookieAcsBoard->addGpio(gpioIds::GYRO_2_ADIS_CS, gpio); gpioCookieAcsBoard->addGpio(gpioIds::GYRO_2_ADIS_CS, gpio);
consumer.str(""); 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, gpio = new GpiodRegularByLineName(q7s::gpioNames::GYRO_3_L3G_CS, consumer.str(), Direction::OUT,
Levels::HIGH); Levels::HIGH);
gpioCookieAcsBoard->addGpio(gpioIds::GYRO_3_L3G_CS, gpio); gpioCookieAcsBoard->addGpio(gpioIds::GYRO_3_L3G_CS, gpio);
consumer.str(""); 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, gpio = new GpiodRegularByLineName(q7s::gpioNames::MGM_0_CS, consumer.str(), Direction::OUT,
Levels::HIGH); Levels::HIGH);
gpioCookieAcsBoard->addGpio(gpioIds::MGM_0_LIS3_CS, gpio); gpioCookieAcsBoard->addGpio(gpioIds::MGM_0_LIS3_CS, gpio);
consumer.str(""); 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, gpio = new GpiodRegularByLineName(q7s::gpioNames::MGM_1_CS, consumer.str(), Direction::OUT,
Levels::HIGH); Levels::HIGH);
gpioCookieAcsBoard->addGpio(gpioIds::MGM_1_RM3100_CS, gpio); gpioCookieAcsBoard->addGpio(gpioIds::MGM_1_RM3100_CS, gpio);
consumer.str(""); 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, gpio = new GpiodRegularByLineName(q7s::gpioNames::MGM_2_CS, consumer.str(), Direction::OUT,
Levels::HIGH); Levels::HIGH);
gpioCookieAcsBoard->addGpio(gpioIds::MGM_2_LIS3_CS, gpio); gpioCookieAcsBoard->addGpio(gpioIds::MGM_2_LIS3_CS, gpio);
consumer.str(""); 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, gpio = new GpiodRegularByLineName(q7s::gpioNames::MGM_3_CS, consumer.str(), Direction::OUT,
Levels::HIGH); Levels::HIGH);
gpioCookieAcsBoard->addGpio(gpioIds::MGM_3_RM3100_CS, gpio); gpioCookieAcsBoard->addGpio(gpioIds::MGM_3_RM3100_CS, gpio);
consumer.str(""); consumer.str("");
consumer << "0x" << std::hex << commonObjects::GPS_CONTROLLER; consumer << "0x" << std::hex << objects::GPS_CONTROLLER;
// GNSS reset pins are active low // GNSS reset pins are active low
gpio = new GpiodRegularByLineName(q7s::gpioNames::RESET_GNSS_0, consumer.str(), Direction::OUT, gpio = new GpiodRegularByLineName(q7s::gpioNames::RESET_GNSS_0, consumer.str(), Direction::OUT,
Levels::HIGH); Levels::HIGH);
gpioCookieAcsBoard->addGpio(gpioIds::GNSS_0_NRESET, gpio); gpioCookieAcsBoard->addGpio(gpioIds::GNSS_0_NRESET, gpio);
consumer.str(""); 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, gpio = new GpiodRegularByLineName(q7s::gpioNames::RESET_GNSS_1, consumer.str(), Direction::OUT,
Levels::HIGH); Levels::HIGH);
gpioCookieAcsBoard->addGpio(gpioIds::GNSS_1_NRESET, gpio); gpioCookieAcsBoard->addGpio(gpioIds::GNSS_1_NRESET, gpio);
consumer.str(""); 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 // Enable pins must be pulled low for regular operations
gpio = new GpiodRegularByLineName(q7s::gpioNames::GYRO_0_ENABLE, consumer.str(), Direction::OUT, gpio = new GpiodRegularByLineName(q7s::gpioNames::GYRO_0_ENABLE, consumer.str(), Direction::OUT,
Levels::LOW); Levels::LOW);
gpioCookieAcsBoard->addGpio(gpioIds::GYRO_0_ENABLE, gpio); gpioCookieAcsBoard->addGpio(gpioIds::GYRO_0_ENABLE, gpio);
consumer.str(""); 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, gpio = new GpiodRegularByLineName(q7s::gpioNames::GYRO_2_ENABLE, consumer.str(), Direction::OUT,
Levels::LOW); Levels::LOW);
gpioCookieAcsBoard->addGpio(gpioIds::GYRO_2_ENABLE, gpio); gpioCookieAcsBoard->addGpio(gpioIds::GYRO_2_ENABLE, gpio);
// Enable pins for GNSS // Enable pins for GNSS
consumer.str(""); 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, gpio = new GpiodRegularByLineName(q7s::gpioNames::GNSS_0_ENABLE, consumer.str(), Direction::OUT,
Levels::LOW); Levels::LOW);
gpioCookieAcsBoard->addGpio(gpioIds::GNSS_0_ENABLE, gpio); gpioCookieAcsBoard->addGpio(gpioIds::GNSS_0_ENABLE, gpio);
consumer.str(""); 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, gpio = new GpiodRegularByLineName(q7s::gpioNames::GNSS_1_ENABLE, consumer.str(), Direction::OUT,
Levels::LOW); Levels::LOW);
gpioCookieAcsBoard->addGpio(gpioIds::GNSS_1_ENABLE, gpio); gpioCookieAcsBoard->addGpio(gpioIds::GNSS_1_ENABLE, gpio);
// Select pin. 0 for GPS side A, 1 for GPS side B // Select pin. 0 for GPS side A, 1 for GPS side B
consumer.str(""); 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, gpio = new GpiodRegularByLineName(q7s::gpioNames::GNSS_SELECT, consumer.str(), Direction::OUT,
Levels::LOW); Levels::LOW);
gpioCookieAcsBoard->addGpio(gpioIds::GNSS_SELECT, gpio); gpioCookieAcsBoard->addGpio(gpioIds::GNSS_SELECT, gpio);
@ -337,9 +337,9 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComI
SpiCookie* spiCookie = SpiCookie* spiCookie =
new SpiCookie(addresses::MGM_0_LIS3, gpioIds::MGM_0_LIS3_CS, MGMLIS3MDL::MAX_BUFFER_SIZE, new SpiCookie(addresses::MGM_0_LIS3, gpioIds::MGM_0_LIS3_CS, MGMLIS3MDL::MAX_BUFFER_SIZE,
spi::DEFAULT_LIS3_MODE, spi::DEFAULT_LIS3_SPEED); 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); spiCookie, spi::LIS3_TRANSITION_DELAY);
fdir = new AcsBoardFdir(commonObjects::MGM_0_LIS3_HANDLER); fdir = new AcsBoardFdir(objects::MGM_0_LIS3_HANDLER);
mgmLis3Handler->setCustomFdir(fdir); mgmLis3Handler->setCustomFdir(fdir);
static_cast<void>(mgmLis3Handler); static_cast<void>(mgmLis3Handler);
#if OBSW_TEST_ACS == 1 #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, new SpiCookie(addresses::MGM_1_RM3100, gpioIds::MGM_1_RM3100_CS, RM3100::MAX_BUFFER_SIZE,
spi::DEFAULT_RM3100_MODE, spi::DEFAULT_RM3100_SPEED); spi::DEFAULT_RM3100_MODE, spi::DEFAULT_RM3100_SPEED);
auto mgmRm3100Handler = 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); spi::RM3100_TRANSITION_DELAY);
fdir = new AcsBoardFdir(commonObjects::MGM_1_RM3100_HANDLER); fdir = new AcsBoardFdir(objects::MGM_1_RM3100_HANDLER);
mgmRm3100Handler->setCustomFdir(fdir); mgmRm3100Handler->setCustomFdir(fdir);
mgmRm3100Handler->setParent(commonObjects::ACS_BOARD_ASS); mgmRm3100Handler->setParent(objects::ACS_BOARD_ASS);
static_cast<void>(mgmRm3100Handler); static_cast<void>(mgmRm3100Handler);
#if OBSW_TEST_ACS == 1 #if OBSW_TEST_ACS == 1
mgmRm3100Handler->setStartUpImmediately(); mgmRm3100Handler->setStartUpImmediately();
@ -369,11 +369,11 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComI
spiCookie = spiCookie =
new SpiCookie(addresses::MGM_2_LIS3, gpioIds::MGM_2_LIS3_CS, MGMLIS3MDL::MAX_BUFFER_SIZE, new SpiCookie(addresses::MGM_2_LIS3, gpioIds::MGM_2_LIS3_CS, MGMLIS3MDL::MAX_BUFFER_SIZE,
spi::DEFAULT_LIS3_MODE, spi::DEFAULT_LIS3_SPEED); 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); 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->setCustomFdir(fdir);
mgmLis3Handler->setParent(commonObjects::ACS_BOARD_ASS); mgmLis3Handler->setParent(objects::ACS_BOARD_ASS);
static_cast<void>(mgmLis3Handler); static_cast<void>(mgmLis3Handler);
#if OBSW_TEST_ACS == 1 #if OBSW_TEST_ACS == 1
mgmLis3Handler->setStartUpImmediately(); mgmLis3Handler->setStartUpImmediately();
@ -385,11 +385,11 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComI
spiCookie = spiCookie =
new SpiCookie(addresses::MGM_3_RM3100, gpioIds::MGM_3_RM3100_CS, RM3100::MAX_BUFFER_SIZE, new SpiCookie(addresses::MGM_3_RM3100, gpioIds::MGM_3_RM3100_CS, RM3100::MAX_BUFFER_SIZE,
spi::DEFAULT_RM3100_MODE, spi::DEFAULT_RM3100_SPEED); 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); 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->setCustomFdir(fdir);
mgmRm3100Handler->setParent(commonObjects::ACS_BOARD_ASS); mgmRm3100Handler->setParent(objects::ACS_BOARD_ASS);
#if OBSW_TEST_ACS == 1 #if OBSW_TEST_ACS == 1
mgmRm3100Handler->setStartUpImmediately(); mgmRm3100Handler->setStartUpImmediately();
mgmRm3100Handler->setToGoToNormalMode(true); 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, new SpiCookie(addresses::GYRO_0_ADIS, gpioIds::GYRO_0_ADIS_CS, ADIS1650X::MAXIMUM_REPLY_SIZE,
spi::DEFAULT_ADIS16507_MODE, spi::DEFAULT_ADIS16507_SPEED); spi::DEFAULT_ADIS16507_MODE, spi::DEFAULT_ADIS16507_SPEED);
auto adisHandler = 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); ADIS1650X::Type::ADIS16505);
fdir = new AcsBoardFdir(commonObjects::GYRO_0_ADIS_HANDLER); fdir = new AcsBoardFdir(objects::GYRO_0_ADIS_HANDLER);
adisHandler->setCustomFdir(fdir); adisHandler->setCustomFdir(fdir);
adisHandler->setParent(commonObjects::ACS_BOARD_ASS); adisHandler->setParent(objects::ACS_BOARD_ASS);
static_cast<void>(adisHandler); static_cast<void>(adisHandler);
#if OBSW_TEST_ACS == 1 #if OBSW_TEST_ACS == 1
adisHandler->setStartUpImmediately(); 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, spiCookie = new SpiCookie(addresses::GYRO_1_L3G, gpioIds::GYRO_1_L3G_CS, L3GD20H::MAX_BUFFER_SIZE,
spi::DEFAULT_L3G_MODE, spi::DEFAULT_L3G_SPEED); spi::DEFAULT_L3G_MODE, spi::DEFAULT_L3G_SPEED);
auto gyroL3gHandler = new GyroHandlerL3GD20H( auto gyroL3gHandler = new GyroHandlerL3GD20H(
commonObjects::GYRO_1_L3G_HANDLER, systemObjects::SPI_MAIN_COM_IF, spiCookie, spi::L3G_TRANSITION_DELAY); objects::GYRO_1_L3G_HANDLER, objects::SPI_MAIN_COM_IF, spiCookie, spi::L3G_TRANSITION_DELAY);
fdir = new AcsBoardFdir(commonObjects::GYRO_1_L3G_HANDLER); fdir = new AcsBoardFdir(objects::GYRO_1_L3G_HANDLER);
gyroL3gHandler->setCustomFdir(fdir); gyroL3gHandler->setCustomFdir(fdir);
gyroL3gHandler->setParent(commonObjects::ACS_BOARD_ASS); gyroL3gHandler->setParent(objects::ACS_BOARD_ASS);
static_cast<void>(gyroL3gHandler); static_cast<void>(gyroL3gHandler);
#if OBSW_TEST_ACS == 1 #if OBSW_TEST_ACS == 1
gyroL3gHandler->setStartUpImmediately(); gyroL3gHandler->setStartUpImmediately();
@ -436,11 +436,11 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComI
spiCookie = spiCookie =
new SpiCookie(addresses::GYRO_2_ADIS, gpioIds::GYRO_2_ADIS_CS, ADIS1650X::MAXIMUM_REPLY_SIZE, new SpiCookie(addresses::GYRO_2_ADIS, gpioIds::GYRO_2_ADIS_CS, ADIS1650X::MAXIMUM_REPLY_SIZE,
spi::DEFAULT_ADIS16507_MODE, spi::DEFAULT_ADIS16507_SPEED); 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); spiCookie, ADIS1650X::Type::ADIS16505);
fdir = new AcsBoardFdir(commonObjects::GYRO_2_ADIS_HANDLER); fdir = new AcsBoardFdir(objects::GYRO_2_ADIS_HANDLER);
adisHandler->setCustomFdir(fdir); adisHandler->setCustomFdir(fdir);
adisHandler->setParent(commonObjects::ACS_BOARD_ASS); adisHandler->setParent(objects::ACS_BOARD_ASS);
#if OBSW_TEST_ACS == 1 #if OBSW_TEST_ACS == 1
adisHandler->setStartUpImmediately(); adisHandler->setStartUpImmediately();
adisHandler->setToGoToNormalModeImmediately(); adisHandler->setToGoToNormalModeImmediately();
@ -448,11 +448,11 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComI
// Gyro 3 Side B // Gyro 3 Side B
spiCookie = new SpiCookie(addresses::GYRO_3_L3G, gpioIds::GYRO_3_L3G_CS, L3GD20H::MAX_BUFFER_SIZE, spiCookie = new SpiCookie(addresses::GYRO_3_L3G, gpioIds::GYRO_3_L3G_CS, L3GD20H::MAX_BUFFER_SIZE,
spi::DEFAULT_L3G_MODE, spi::DEFAULT_L3G_SPEED); 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); 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->setCustomFdir(fdir);
gyroL3gHandler->setParent(commonObjects::ACS_BOARD_ASS); gyroL3gHandler->setParent(objects::ACS_BOARD_ASS);
#if OBSW_TEST_ACS == 1 #if OBSW_TEST_ACS == 1
gyroL3gHandler->setStartUpImmediately(); gyroL3gHandler->setStartUpImmediately();
gyroL3gHandler->setToGoToNormalMode(true); gyroL3gHandler->setToGoToNormalMode(true);
@ -467,14 +467,14 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComI
RESET_ARGS_GNSS.gpioComIF = gpioComIF; RESET_ARGS_GNSS.gpioComIF = gpioComIF;
RESET_ARGS_GNSS.waitPeriodMs = 100; RESET_ARGS_GNSS.waitPeriodMs = 100;
auto gpsCtrl = 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); gpsCtrl->setResetPinTriggerFunction(gps::triggerGpioResetPin, &RESET_ARGS_GNSS);
AcsBoardHelper acsBoardHelper = AcsBoardHelper( AcsBoardHelper acsBoardHelper = AcsBoardHelper(
commonObjects::MGM_0_LIS3_HANDLER, commonObjects::MGM_1_RM3100_HANDLER, commonObjects::MGM_2_LIS3_HANDLER, objects::MGM_0_LIS3_HANDLER, objects::MGM_1_RM3100_HANDLER, objects::MGM_2_LIS3_HANDLER,
commonObjects::MGM_3_RM3100_HANDLER, commonObjects::GYRO_0_ADIS_HANDLER, commonObjects::GYRO_1_L3G_HANDLER, objects::MGM_3_RM3100_HANDLER, objects::GYRO_0_ADIS_HANDLER, objects::GYRO_1_L3G_HANDLER,
commonObjects::GYRO_2_ADIS_HANDLER, commonObjects::GYRO_3_L3G_HANDLER, commonObjects::GPS_CONTROLLER); objects::GYRO_2_ADIS_HANDLER, objects::GYRO_3_L3G_HANDLER, objects::GPS_CONTROLLER);
auto acsAss = new AcsBoardAssembly(commonObjects::ACS_BOARD_ASS, objects::NO_OBJECT, pwrSwitcher, auto acsAss = new AcsBoardAssembly(objects::ACS_BOARD_ASS, objects::NO_OBJECT, pwrSwitcher,
acsBoardHelper, gpioComIF); acsBoardHelper, gpioComIF);
static_cast<void>(acsAss); static_cast<void>(acsAss);
#endif /* OBSW_ADD_ACS_HANDLERS == 1 */ #endif /* OBSW_ADD_ACS_HANDLERS == 1 */
@ -487,7 +487,7 @@ void ObjectFactory::createHeaterComponents(GpioIF* gpioIF, PowerSwitchIF* pwrSwi
GpiodRegularByLineName* gpio = nullptr; GpiodRegularByLineName* gpio = nullptr;
std::stringstream consumer; std::stringstream consumer;
consumer << "0x" << std::hex << commonObjects::HEATER_HANDLER; consumer << "0x" << std::hex << objects::HEATER_HANDLER;
/* Pin H2-11 on stack connector */ /* Pin H2-11 on stack connector */
gpio = new GpiodRegularByLineName(q7s::gpioNames::HEATER_0, consumer.str(), Direction::OUT, gpio = new GpiodRegularByLineName(q7s::gpioNames::HEATER_0, consumer.str(), Direction::OUT,
Levels::LOW); Levels::LOW);
@ -525,17 +525,17 @@ void ObjectFactory::createHeaterComponents(GpioIF* gpioIF, PowerSwitchIF* pwrSwi
gpioIF->addGpios(heaterGpiosCookie); gpioIF->addGpios(heaterGpiosCookie);
HeaterHelper helper({{ 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}, gpioIds::HEATER_0},
{new HealthDevice(commonObjects::HEATER_1_PCDU_BRD, MessageQueueIF::NO_QUEUE), gpioIds::HEATER_1}, {new HealthDevice(objects::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(objects::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(objects::HEATER_3_OBC_BRD, MessageQueueIF::NO_QUEUE), gpioIds::HEATER_3},
{new HealthDevice(commonObjects::HEATER_4_CAMERA, MessageQueueIF::NO_QUEUE), gpioIds::HEATER_4}, {new HealthDevice(objects::HEATER_4_CAMERA, MessageQueueIF::NO_QUEUE), gpioIds::HEATER_4},
{new HealthDevice(commonObjects::HEATER_5_STR, MessageQueueIF::NO_QUEUE), gpioIds::HEATER_5}, {new HealthDevice(objects::HEATER_5_STR, MessageQueueIF::NO_QUEUE), gpioIds::HEATER_5},
{new HealthDevice(commonObjects::HEATER_6_DRO, MessageQueueIF::NO_QUEUE), gpioIds::HEATER_6}, {new HealthDevice(objects::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_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); pcdu::Switches::PDU2_CH3_TCS_BOARD_HEATER_IN_8V);
} }
@ -545,7 +545,7 @@ void ObjectFactory::createSolarArrayDeploymentComponents() {
GpiodRegularByLineName* gpio = nullptr; GpiodRegularByLineName* gpio = nullptr;
std::stringstream consumer; 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, gpio = new GpiodRegularByLineName(q7s::gpioNames::SA_DPL_PIN_0, consumer.str(), Direction::OUT,
Levels::LOW); Levels::LOW);
solarArrayDeplCookie->addGpio(gpioIds::DEPLSA1, gpio); solarArrayDeplCookie->addGpio(gpioIds::DEPLSA1, gpio);
@ -554,21 +554,21 @@ void ObjectFactory::createSolarArrayDeploymentComponents() {
solarArrayDeplCookie->addGpio(gpioIds::DEPLSA2, gpio); solarArrayDeplCookie->addGpio(gpioIds::DEPLSA2, gpio);
// TODO: Find out burn time. For now set to 1000 ms. // TODO: Find out burn time. For now set to 1000 ms.
new SolarArrayDeploymentHandler(commonObjects::SOLAR_ARRAY_DEPL_HANDLER, systemObjects::GPIO_IF, new SolarArrayDeploymentHandler(objects::SOLAR_ARRAY_DEPL_HANDLER, objects::GPIO_IF,
solarArrayDeplCookie, commonObjects::PCDU_HANDLER, solarArrayDeplCookie, objects::PCDU_HANDLER,
pcdu::Switches::PDU2_CH5_DEPLOYMENT_MECHANISM_8V, pcdu::Switches::PDU2_CH5_DEPLOYMENT_MECHANISM_8V,
gpioIds::DEPLSA1, gpioIds::DEPLSA2, 1000); gpioIds::DEPLSA1, gpioIds::DEPLSA2, 1000);
} }
void ObjectFactory::createSyrlinksComponents(PowerSwitchIF* pwrSwitcher) { void ObjectFactory::createSyrlinksComponents(PowerSwitchIF* pwrSwitcher) {
UartCookie* syrlinksUartCookie = 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); syrlinks::MAX_REPLY_SIZE, UartModes::NON_CANONICAL);
syrlinksUartCookie->setParityEven(); syrlinksUartCookie->setParityEven();
auto syrlinksFdir = new SyrlinksFdir(commonObjects::SYRLINKS_HK_HANDLER); auto syrlinksFdir = new SyrlinksFdir(objects::SYRLINKS_HK_HANDLER);
auto syrlinksHandler = 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); pcdu::PDU1_CH1_SYRLINKS_12V, syrlinksFdir);
syrlinksHandler->setPowerSwitcher(pwrSwitcher); syrlinksHandler->setPowerSwitcher(pwrSwitcher);
#if OBSW_DEBUG_SYRLINKS == 1 #if OBSW_DEBUG_SYRLINKS == 1
@ -580,34 +580,34 @@ void ObjectFactory::createPayloadComponents(LinuxLibgpioIF* gpioComIF) {
using namespace gpio; using namespace gpio;
std::stringstream consumer; std::stringstream consumer;
#if OBSW_ADD_PLOC_MPSOC == 1 #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, auto gpioConfigMPSoC = new GpiodRegularByLineName(q7s::gpioNames::ENABLE_MPSOC_UART,
consumer.str(), Direction::OUT, Levels::HIGH); consumer.str(), Direction::OUT, Levels::HIGH);
auto mpsocGpioCookie = new GpioCookie; auto mpsocGpioCookie = new GpioCookie;
mpsocGpioCookie->addGpio(gpioIds::ENABLE_MPSOC_UART, gpioConfigMPSoC); mpsocGpioCookie->addGpio(gpioIds::ENABLE_MPSOC_UART, gpioConfigMPSoC);
gpioChecker(gpioComIF->addGpios(mpsocGpioCookie), "PLOC MPSoC"); gpioChecker(gpioComIF->addGpios(mpsocGpioCookie), "PLOC MPSoC");
auto mpsocCookie = 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); mpsoc::MAX_REPLY_SIZE, UartModes::NON_CANONICAL);
mpsocCookie->setNoFixedSizeReply(); mpsocCookie->setNoFixedSizeReply();
auto plocMpsocHelper = new PlocMPSoCHelper(commonObjects::PLOC_MPSOC_HELPER); auto plocMpsocHelper = new PlocMPSoCHelper(objects::PLOC_MPSOC_HELPER);
new PlocMPSoCHandler(commonObjects::PLOC_MPSOC_HANDLER, systemObjects::UART_COM_IF, mpsocCookie, new PlocMPSoCHandler(objects::PLOC_MPSOC_HANDLER, objects::UART_COM_IF, mpsocCookie,
plocMpsocHelper, Gpio(gpioIds::ENABLE_MPSOC_UART, gpioComIF), plocMpsocHelper, Gpio(gpioIds::ENABLE_MPSOC_UART, gpioComIF),
commonObjects::PLOC_SUPERVISOR_HANDLER); objects::PLOC_SUPERVISOR_HANDLER);
#endif /* OBSW_ADD_PLOC_MPSOC == 1 */ #endif /* OBSW_ADD_PLOC_MPSOC == 1 */
#if OBSW_ADD_PLOC_SUPERVISOR == 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(), auto gpioConfigSupv = new GpiodRegularByLineName(q7s::gpioNames::ENABLE_SUPV_UART, consumer.str(),
Direction::OUT, Levels::LOW); Direction::OUT, Levels::LOW);
auto supvGpioCookie = new GpioCookie; auto supvGpioCookie = new GpioCookie;
supvGpioCookie->addGpio(gpioIds::ENABLE_SUPV_UART, gpioConfigSupv); supvGpioCookie->addGpio(gpioIds::ENABLE_SUPV_UART, gpioConfigSupv);
gpioComIF->addGpios(supvGpioCookie); gpioComIF->addGpios(supvGpioCookie);
auto supervisorCookie = 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); uart::PLOC_SUPV_BAUD, supv::MAX_PACKET_SIZE * 20, UartModes::NON_CANONICAL);
supervisorCookie->setNoFixedSizeReply(); supervisorCookie->setNoFixedSizeReply();
auto supvHelper = new PlocSupvHelper(commonObjects::PLOC_SUPERVISOR_HELPER); auto supvHelper = new PlocSupvHelper(objects::PLOC_SUPERVISOR_HELPER);
new PlocSupervisorHandler(commonObjects::PLOC_SUPERVISOR_HANDLER, systemObjects::UART_COM_IF, new PlocSupervisorHandler(objects::PLOC_SUPERVISOR_HANDLER, objects::UART_COM_IF,
supervisorCookie, Gpio(gpioIds::ENABLE_SUPV_UART, gpioComIF), supervisorCookie, Gpio(gpioIds::ENABLE_SUPV_UART, gpioComIF),
pcdu::PDU1_CH6_PLOC_12V, supvHelper); pcdu::PDU1_CH6_PLOC_12V, supvHelper);
#endif /* OBSW_ADD_PLOC_SUPERVISOR == 1 */ #endif /* OBSW_ADD_PLOC_SUPERVISOR == 1 */
@ -637,22 +637,22 @@ void ObjectFactory::createReactionWheelComponents(LinuxLibgpioIF* gpioComIF,
std::stringstream consumer; std::stringstream consumer;
GpiodRegularByLineName* gpio = nullptr; 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, gpio = new GpiodRegularByLineName(q7s::gpioNames::EN_RW_1, consumer.str(), Direction::OUT,
Levels::LOW); Levels::LOW);
gpioCookieRw->addGpio(gpioIds::EN_RW1, gpio); gpioCookieRw->addGpio(gpioIds::EN_RW1, gpio);
consumer.str(""); 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, gpio = new GpiodRegularByLineName(q7s::gpioNames::EN_RW_2, consumer.str(), Direction::OUT,
Levels::LOW); Levels::LOW);
gpioCookieRw->addGpio(gpioIds::EN_RW2, gpio); gpioCookieRw->addGpio(gpioIds::EN_RW2, gpio);
consumer.str(""); 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, gpio = new GpiodRegularByLineName(q7s::gpioNames::EN_RW_3, consumer.str(), Direction::OUT,
Levels::LOW); Levels::LOW);
gpioCookieRw->addGpio(gpioIds::EN_RW3, gpio); gpioCookieRw->addGpio(gpioIds::EN_RW3, gpio);
consumer.str(""); 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, gpio = new GpiodRegularByLineName(q7s::gpioNames::EN_RW_4, consumer.str(), Direction::OUT,
Levels::LOW); Levels::LOW);
gpioCookieRw->addGpio(gpioIds::EN_RW4, gpio); gpioCookieRw->addGpio(gpioIds::EN_RW4, gpio);
@ -666,7 +666,7 @@ void ObjectFactory::createReactionWheelComponents(LinuxLibgpioIF* gpioComIF,
{addresses::RW3, gpioIds::CS_RW3}, {addresses::RW3, gpioIds::CS_RW3},
{addresses::RW4, gpioIds::CS_RW4}}}; {addresses::RW4, gpioIds::CS_RW4}}};
std::array<SpiCookie*, 4> rwCookies = {}; std::array<SpiCookie*, 4> rwCookies = {};
std::array<object_id_t, 4> rwIds = {commonObjects::RW1, commonObjects::RW2, commonObjects::RW3, commonObjects::RW4}; std::array<object_id_t, 4> rwIds = {objects::RW1, objects::RW2, objects::RW3, objects::RW4};
std::array<gpioId_t, 4> rwGpioIds = {gpioIds::EN_RW1, gpioIds::EN_RW2, gpioIds::EN_RW3, std::array<gpioId_t, 4> rwGpioIds = {gpioIds::EN_RW1, gpioIds::EN_RW2, gpioIds::EN_RW3,
gpioIds::EN_RW4}; gpioIds::EN_RW4};
std::array<RwHandler*, 4> rws = {}; std::array<RwHandler*, 4> rws = {};
@ -674,7 +674,7 @@ void ObjectFactory::createReactionWheelComponents(LinuxLibgpioIF* gpioComIF,
rwCookies[idx] = new SpiCookie(rwCookieParams[idx].first, rwCookieParams[idx].second, rwCookies[idx] = new SpiCookie(rwCookieParams[idx].first, rwCookieParams[idx].second,
RwDefinitions::MAX_REPLY_SIZE, spi::RW_MODE, spi::RW_SPEED, RwDefinitions::MAX_REPLY_SIZE, spi::RW_MODE, spi::RW_SPEED,
&rwSpiCallback::spiCallback, nullptr); &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]); rwGpioIds[idx]);
rwCookies[idx]->setCallbackArgs(rws[idx]); rwCookies[idx]->setCallbackArgs(rws[idx]);
#if OBSW_TEST_RW == 1 #if OBSW_TEST_RW == 1
@ -686,7 +686,7 @@ void ObjectFactory::createReactionWheelComponents(LinuxLibgpioIF* gpioComIF,
} }
RwHelper rwHelper(rwIds); 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); pcdu::Switches::PDU2_CH2_RW_5V, rwHelper);
static_cast<void>(rwAss); static_cast<void>(rwAss);
#endif /* OBSW_ADD_RW == 1 */ #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, new PapbVcInterface(gpioComIF, gpioIds::VC3_PAPB_BUSY, gpioIds::VC3_PAPB_EMPTY, q7s::UIO_PTME,
q7s::uiomapids::PTME_VC3); q7s::uiomapids::PTME_VC3);
// Creating ptme object and adding virtual channel interfaces // 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::VC0, vc0);
ptme->addVcInterface(ccsds::VC1, vc1); ptme->addVcInterface(ccsds::VC1, vc1);
ptme->addVcInterface(ccsds::VC2, vc2); ptme->addVcInterface(ccsds::VC2, vc2);
ptme->addVcInterface(ccsds::VC3, vc3); ptme->addVcInterface(ccsds::VC3, vc3);
AxiPtmeConfig* axiPtmeConfig = AxiPtmeConfig* axiPtmeConfig =
new AxiPtmeConfig(commonObjects::AXI_PTME_CONFIG, q7s::UIO_PTME, q7s::uiomapids::PTME_CONFIG); new AxiPtmeConfig(objects::AXI_PTME_CONFIG, q7s::UIO_PTME, q7s::uiomapids::PTME_CONFIG);
PtmeConfig* ptmeConfig = new PtmeConfig(commonObjects::PTME_CONFIG, axiPtmeConfig); PtmeConfig* ptmeConfig = new PtmeConfig(objects::PTME_CONFIG, axiPtmeConfig);
#if OBSW_ENABLE_SYRLINKS_TRANSMIT_TIMEOUT == 1 #if OBSW_ENABLE_SYRLINKS_TRANSMIT_TIMEOUT == 1
// Set to high value when not sending via syrlinks // Set to high value when not sending via syrlinks
static const uint32_t TRANSMITTER_TIMEOUT = 86400000; // 1 day 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 static const uint32_t TRANSMITTER_TIMEOUT = 900000; // 15 minutes
#endif #endif
CCSDSHandler* ccsdsHandler = new CCSDSHandler( 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); gpioComIF, gpioIds::RS485_EN_TX_CLOCK, gpioIds::RS485_EN_TX_DATA, TRANSMITTER_TIMEOUT);
VirtualChannel* vc = nullptr; 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); 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); 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); 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); ccsdsHandler->addVirtualChannel(ccsds::VC3, vc);
GpioCookie* gpioCookiePdec = new GpioCookie; GpioCookie* gpioCookiePdec = new GpioCookie;
consumer.str(""); 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 also low after linux boot (specified by device-tree)
gpio = new GpiodRegularByLineName(q7s::gpioNames::PDEC_RESET, consumer.str(), Direction::OUT, gpio = new GpiodRegularByLineName(q7s::gpioNames::PDEC_RESET, consumer.str(), Direction::OUT,
Levels::LOW); Levels::LOW);
gpioCookiePdec->addGpio(gpioIds::PDEC_RESET, gpio); gpioCookiePdec->addGpio(gpioIds::PDEC_RESET, gpio);
gpioChecker(gpioComIF->addGpios(gpioCookiePdec), "PDEC"); 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); q7s::UIO_PDEC_CONFIG_MEMORY, q7s::UIO_PDEC_RAM, q7s::UIO_PDEC_REGISTERS);
GpioCookie* gpioRS485Chip = new GpioCookie; GpioCookie* gpioRS485Chip = new GpioCookie;
gpio = new GpiodRegularByLineName(q7s::gpioNames::RS485_EN_TX_CLOCK, "RS485 Transceiver", 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); spi::DEFAULT_MAX_1227_MODE, spi::PL_PCDU_MAX_1227_SPEED);
// Create device handler components // Create device handler components
auto plPcduHandler = new PayloadPcduHandler( 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, SdCardManager::instance(), pwrSwitcher, pcdu::Switches::PDU2_CH1_PL_PCDU_BATT_0_14V8,
pcdu::Switches::PDU2_CH6_PL_PCDU_BATT_1_14V8, false); pcdu::Switches::PDU2_CH6_PL_PCDU_BATT_1_14V8, false);
spiCookie->setCallbackMode(PayloadPcduHandler::extConvAsTwoCallback, plPcduHandler); spiCookie->setCallbackMode(PayloadPcduHandler::extConvAsTwoCallback, plPcduHandler);
@ -858,26 +858,26 @@ void ObjectFactory::createPlPcduComponents(LinuxLibgpioIF* gpioComIF, SpiComIF*
} }
void ObjectFactory::createTestComponents(LinuxLibgpioIF* gpioComIF) { void ObjectFactory::createTestComponents(LinuxLibgpioIF* gpioComIF) {
new Q7STestTask(systemObjects::TEST_TASK); new Q7STestTask(objects::TEST_TASK);
#if OBSW_ADD_SPI_TEST_CODE == 1 #if OBSW_ADD_SPI_TEST_CODE == 1
new SpiTestClass(commonObjects::SPI_TEST, gpioComIF); new SpiTestClass(objects::SPI_TEST, gpioComIF);
#endif #endif
#if OBSW_ADD_I2C_TEST_CODE == 1 #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 #endif
#if OBSW_ADD_UART_TEST_CODE == 1 #if OBSW_ADD_UART_TEST_CODE == 1
new UartTestClass(commonObjects::UART_TEST); new UartTestClass(objects::UART_TEST);
#endif #endif
} }
void ObjectFactory::createStrComponents(PowerSwitchIF* pwrSwitcher) { void ObjectFactory::createStrComponents(PowerSwitchIF* pwrSwitcher) {
UartCookie* starTrackerCookie = 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); startracker::MAX_FRAME_SIZE * 2 + 2, UartModes::NON_CANONICAL);
starTrackerCookie->setNoFixedSizeReply(); starTrackerCookie->setNoFixedSizeReply();
StrHelper* strHelper = new StrHelper(commonObjects::STR_HELPER); StrHelper* strHelper = new StrHelper(objects::STR_HELPER);
auto starTracker = 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); strHelper, pcdu::PDU1_CH2_STAR_TRACKER_5V);
starTracker->setPowerSwitcher(pwrSwitcher); starTracker->setPowerSwitcher(pwrSwitcher);
} }
@ -885,7 +885,7 @@ void ObjectFactory::createStrComponents(PowerSwitchIF* pwrSwitcher) {
void ObjectFactory::createImtqComponents(PowerSwitchIF* pwrSwitcher) { void ObjectFactory::createImtqComponents(PowerSwitchIF* pwrSwitcher) {
I2cCookie* imtqI2cCookie = I2cCookie* imtqI2cCookie =
new I2cCookie(addresses::IMTQ, IMTQ::MAX_REPLY_SIZE, q7s::I2C_DEFAULT_DEV); 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); pcdu::Switches::PDU1_CH3_MGT_5V);
imtqHandler->setPowerSwitcher(pwrSwitcher); imtqHandler->setPowerSwitcher(pwrSwitcher);
static_cast<void>(imtqHandler); static_cast<void>(imtqHandler);
@ -901,7 +901,7 @@ void ObjectFactory::createImtqComponents(PowerSwitchIF* pwrSwitcher) {
void ObjectFactory::createBpxBatteryComponent() { void ObjectFactory::createBpxBatteryComponent() {
I2cCookie* bpxI2cCookie = new I2cCookie(addresses::BPX_BATTERY, 100, q7s::I2C_DEFAULT_DEV); I2cCookie* bpxI2cCookie = new I2cCookie(addresses::BPX_BATTERY, 100, q7s::I2C_DEFAULT_DEV);
BpxBatteryHandler* bpxHandler = 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->setStartUpImmediately();
bpxHandler->setToGoToNormalMode(true); bpxHandler->setToGoToNormalMode(true);
#if OBSW_DEBUG_BPX_BATT == 1 #if OBSW_DEBUG_BPX_BATT == 1
@ -910,8 +910,8 @@ void ObjectFactory::createBpxBatteryComponent() {
} }
void ObjectFactory::createMiscComponents() { void ObjectFactory::createMiscComponents() {
new FileSystemHandler(commonObjects::FILE_SYSTEM_HANDLER); new FileSystemHandler(objects::FILE_SYSTEM_HANDLER);
new PlocMemoryDumper(commonObjects::PLOC_MEMORY_DUMPER); new PlocMemoryDumper(objects::PLOC_MEMORY_DUMPER);
} }
void ObjectFactory::testAcsBrdAss(AcsBoardAssembly* acsAss) { void ObjectFactory::testAcsBrdAss(AcsBoardAssembly* acsAss) {

2
bsp_q7s/fmObjectFactory.cpp
View File

@ -22,7 +22,7 @@ void ObjectFactory::produce(void* args) {
SpiComIF* spiRwComIF = nullptr; SpiComIF* spiRwComIF = nullptr;
createCommunicationInterfaces(&gpioComIF, &uartComIF, &spiMainComIF, &i2cComIF, &spiRwComIF); createCommunicationInterfaces(&gpioComIF, &uartComIF, &spiMainComIF, &i2cComIF, &spiRwComIF);
createTmpComponents(); createTmpComponents();
new CoreController(commonObjects::CORE_CONTROLLER); new CoreController(objects::CORE_CONTROLLER);
gpioCallbacks::disableAllDecoder(gpioComIF); gpioCallbacks::disableAllDecoder(gpioComIF);
createPcduComponents(gpioComIF, &pwrSwitcher); createPcduComponents(gpioComIF, &pwrSwitcher);

2
bsp_q7s/memory/FileSystemHandler.cpp
View File

@ -102,7 +102,7 @@ void FileSystemHandler::fileSystemCheckup() {
MessageQueueId_t FileSystemHandler::getCommandQueue() const { return mq->getId(); } MessageQueueId_t FileSystemHandler::getCommandQueue() const { return mq->getId(); }
ReturnValue_t FileSystemHandler::initialize() { ReturnValue_t FileSystemHandler::initialize() {
coreCtrl = ObjectManager::instance()->get<CoreController>(commonObjects::CORE_CONTROLLER); coreCtrl = ObjectManager::instance()->get<CoreController>(objects::CORE_CONTROLLER);
if (coreCtrl == nullptr) { if (coreCtrl == nullptr) {
sif::error << "FileSystemHandler::initialize: Could not retrieve core controller handle" sif::error << "FileSystemHandler::initialize: Could not retrieve core controller handle"
<< std::endl; << std::endl;

2
bsp_q7s/memory/SdCardManager.cpp
View File

@ -18,7 +18,7 @@
SdCardManager* SdCardManager::INSTANCE = nullptr; SdCardManager* SdCardManager::INSTANCE = nullptr;
SdCardManager::SdCardManager() : SystemObject(commonObjects::SDC_MANAGER), cmdExecutor(256) { SdCardManager::SdCardManager() : SystemObject(objects::SDC_MANAGER), cmdExecutor(256) {
mutex = MutexFactory::instance()->createMutex(); mutex = MutexFactory::instance()->createMutex();
ReturnValue_t result = mutex->lockMutex(); ReturnValue_t result = mutex->lockMutex();
if (result != RETURN_OK) { if (result != RETURN_OK) {

187
common/config/commonObjects.h
View File

@ -2,84 +2,84 @@
#define COMMON_CONFIG_COMMONOBJECTS_H_ #define COMMON_CONFIG_COMMONOBJECTS_H_
#include <cstdint> #include <cstdint>
#include <fsfw/introspection/Enum.h>
FSFW_ENUM(commonObjects, uint32_t, namespace objects {
/* First Byte 0x50-0x52 reserved for PUS Services **/ enum commonObjects : uint32_t {
((CCSDS_PACKET_DISTRIBUTOR, 0x50000100, "CCSDS_PACKET_DISTRIBUTOR")) /* First Byte 0x50-0x52 reserved for PUS Services **/
((PUS_PACKET_DISTRIBUTOR, 0x50000200, "PUS_PACKET_DISTRIBUTOR")) CCSDS_PACKET_DISTRIBUTOR = 0x50000100,
((TMTC_BRIDGE, 0x50000300, "TMTC_BRIDGE")) PUS_PACKET_DISTRIBUTOR = 0x50000200,
((TMTC_POLLING_TASK, 0x50000400, "TMTC_POLLING_TASK")) TMTC_BRIDGE = 0x50000300,
((FILE_SYSTEM_HANDLER, 0x50000500, "FILE_SYSTEM_HANDLER")) TMTC_POLLING_TASK = 0x50000400,
((SDC_MANAGER, 0x50000550, "SDC_MANAGER")) FILE_SYSTEM_HANDLER = 0x50000500,
((PTME, 0x50000600, "PTME")) SDC_MANAGER = 0x50000550,
((PDEC_HANDLER, 0x50000700, "PDEC_HANDLER")) PTME = 0x50000600,
((CCSDS_HANDLER, 0x50000800, "CCSDS_HANDLER")) PDEC_HANDLER = 0x50000700,
CCSDS_HANDLER = 0x50000800,
/* 0x43 ('C') for Controllers */ /* 0x43 ('C') for Controllers */
((THERMAL_CONTROLLER, 0x43400001, "THERMAL_CONTROLLER")) THERMAL_CONTROLLER = 0x43400001,
((ACS_CONTROLLER, 0x43000002, "ACS_CONTROLLER")) ACS_CONTROLLER = 0x43000002,
((CORE_CONTROLLER, 0x43000003, "CORE_CONTROLLER")) CORE_CONTROLLER = 0x43000003,
/* 0x44 ('D') for device handlers */ /* 0x44 ('D') for device handlers */
((MGM_0_LIS3_HANDLER, 0x44120006, "MGM_0_LIS3_HANDLER")) MGM_0_LIS3_HANDLER = 0x44120006,
((MGM_1_RM3100_HANDLER, 0x44120107, "MGM_1_RM3100_HANDLER")) MGM_1_RM3100_HANDLER = 0x44120107,
((MGM_2_LIS3_HANDLER, 0x44120208, "MGM_2_LIS3_HANDLER")) MGM_2_LIS3_HANDLER = 0x44120208,
((MGM_3_RM3100_HANDLER, 0x44120309, "MGM_3_RM3100_HANDLER")) MGM_3_RM3100_HANDLER = 0x44120309,
((GYRO_0_ADIS_HANDLER, 0x44120010, "GYRO_0_ADIS_HANDLER")) GYRO_0_ADIS_HANDLER = 0x44120010,
((GYRO_1_L3G_HANDLER, 0x44120111, "GYRO_1_L3G_HANDLER")) GYRO_1_L3G_HANDLER = 0x44120111,
((GYRO_2_ADIS_HANDLER, 0x44120212, "GYRO_2_ADIS_HANDLER")) GYRO_2_ADIS_HANDLER = 0x44120212,
((GYRO_3_L3G_HANDLER, 0x44120313, "GYRO_3_L3G_HANDLER")) GYRO_3_L3G_HANDLER = 0x44120313,
((RW1, 0x44120047, "RW1")) RW1 = 0x44120047,
((RW2, 0x44120148, "RW2")) RW2 = 0x44120148,
((RW3, 0x44120249, "RW3")) RW3 = 0x44120249,
((RW4, 0x44120350, "RW4")) RW4 = 0x44120350,
((STAR_TRACKER, 0x44130001, "STAR_TRACKER")) STAR_TRACKER = 0x44130001,
((GPS_CONTROLLER, 0x44130045, "GPS_CONTROLLER")) GPS_CONTROLLER = 0x44130045,
((IMTQ_HANDLER, 0x44140014, "IMTQ_HANDLER")) IMTQ_HANDLER = 0x44140014,
((TMP1075_HANDLER_1, 0x44420004, "TMP1075_HANDLER_1")) TMP1075_HANDLER_1 = 0x44420004,
((TMP1075_HANDLER_2, 0x44420005, "TMP1075_HANDLER_2")) TMP1075_HANDLER_2 = 0x44420005,
((PCDU_HANDLER, 0x442000A1, "PCDU_HANDLER")) PCDU_HANDLER = 0x442000A1,
((P60DOCK_HANDLER, 0x44250000, "P60DOCK_HANDLER")) P60DOCK_HANDLER = 0x44250000,
((PDU1_HANDLER, 0x44250001, "PDU1_HANDLER")) PDU1_HANDLER = 0x44250001,
((PDU2_HANDLER, 0x44250002, "PDU2_HANDLER")) PDU2_HANDLER = 0x44250002,
((ACU_HANDLER, 0x44250003, "ACU_HANDLER")) ACU_HANDLER = 0x44250003,
((BPX_BATT_HANDLER, 0x44260000, "BPX_BATT_HANDLER")) BPX_BATT_HANDLER = 0x44260000,
((PLPCDU_HANDLER, 0x44300000, "PLPCDU_HANDLER")) PLPCDU_HANDLER = 0x44300000,
((RAD_SENSOR, 0x443200A5, "RAD_SENSOR")) RAD_SENSOR = 0x443200A5,
((PLOC_UPDATER, 0x44330000, "PLOC_UPDATER")) PLOC_UPDATER = 0x44330000,
((PLOC_MEMORY_DUMPER, 0x44330001, "PLOC_MEMORY_DUMPER")) PLOC_MEMORY_DUMPER = 0x44330001,
((STR_HELPER, 0x44330002, "STR_HELPER")) STR_HELPER = 0x44330002,
((PLOC_MPSOC_HELPER, 0x44330003, "PLOC_MPSOC_HELPER")) PLOC_MPSOC_HELPER = 0x44330003,
((AXI_PTME_CONFIG, 0x44330004, "AXI_PTME_CONFIG")) AXI_PTME_CONFIG = 0x44330004,
((PTME_CONFIG, 0x44330005, "PTME_CONFIG")) PTME_CONFIG = 0x44330005,
((PLOC_MPSOC_HANDLER, 0x44330015, "PLOC_MPSOC_HANDLER")) PLOC_MPSOC_HANDLER = 0x44330015,
((PLOC_SUPERVISOR_HANDLER, 0x44330016, "PLOC_SUPERVISOR_HANDLER")) PLOC_SUPERVISOR_HANDLER = 0x44330016,
((PLOC_SUPERVISOR_HELPER, 0x44330017, "PLOC_SUPERVISOR_HELPER")) PLOC_SUPERVISOR_HELPER = 0x44330017,
((SOLAR_ARRAY_DEPL_HANDLER, 0x444100A2, "SOLAR_ARRAY_DEPL_HANDLER")) SOLAR_ARRAY_DEPL_HANDLER = 0x444100A2,
((HEATER_HANDLER, 0x444100A4, "HEATER_HANDLER")) HEATER_HANDLER = 0x444100A4,
/** /**
* Not yet specified which pt1000 will measure which device/location in the satellite. * 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. * 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_0_IC3_PLOC_HEATSPREADER = 0x44420016,
((RTD_1_IC4_PLOC_MISSIONBOARD, 0x44420017, "RTD_1_IC4_PLOC_MISSIONBOARD")) RTD_1_IC4_PLOC_MISSIONBOARD = 0x44420017,
((RTD_2_IC5_4K_CAMERA, 0x44420018, "RTD_2_IC5_4K_CAMERA")) RTD_2_IC5_4K_CAMERA = 0x44420018,
((RTD_3_IC6_DAC_HEATSPREADER, 0x44420019, "RTD_3_IC6_DAC_HEATSPREADER")) RTD_3_IC6_DAC_HEATSPREADER = 0x44420019,
((RTD_4_IC7_STARTRACKER, 0x44420020, "RTD_4_IC7_STARTRACKER")) RTD_4_IC7_STARTRACKER = 0x44420020,
((RTD_5_IC8_RW1_MX_MY, 0x44420021, "RTD_5_IC8_RW1_MX_MY")) RTD_5_IC8_RW1_MX_MY = 0x44420021,
((RTD_6_IC9_DRO, 0x44420022, "RTD_6_IC9_DRO")) RTD_6_IC9_DRO = 0x44420022,
((RTD_7_IC10_SCEX, 0x44420023, "RTD_7_IC10_SCEX")) RTD_7_IC10_SCEX = 0x44420023,
((RTD_8_IC11_X8, 0x44420024, "RTD_8_IC11_X8")) RTD_8_IC11_X8 = 0x44420024,
((RTD_9_IC12_HPA, 0x44420025, "RTD_9_IC12_HPA")) RTD_9_IC12_HPA = 0x44420025,
((RTD_10_IC13_PL_TX, 0x44420026, "RTD_10_IC13_PL_TX")) RTD_10_IC13_PL_TX = 0x44420026,
((RTD_11_IC14_MPA, 0x44420027, "RTD_11_IC14_MPA")) RTD_11_IC14_MPA = 0x44420027,
((RTD_12_IC15_ACU, 0x44420028, "RTD_12_IC15_ACU")) RTD_12_IC15_ACU = 0x44420028,
((RTD_13_IC16_PLPCDU_HEATSPREADER, 0x44420029, "RTD_13_IC16_PLPCDU_HEATSPREADER")) RTD_13_IC16_PLPCDU_HEATSPREADER = 0x44420029,
((RTD_14_IC17_TCS_BOARD, 0x44420030, "RTD_14_IC17_TCS_BOARD")) RTD_14_IC17_TCS_BOARD = 0x44420030,
((RTD_15_IC18_IMTQ, 0x44420031, "RTD_15_IC18_IMTQ")) RTD_15_IC18_IMTQ = 0x44420031,
// Name convention for SUS devices // Name convention for SUS devices
// SUS_<IDX>_<N/R>_LOC_X<F/M/B>Y<F/M/B>Z<F/M/B>_PT_<DIR><F/B> // SUS_<IDX>_<N/R>_LOC_X<F/M/B>Y<F/M/B>Z<F/M/B>_PT_<DIR><F/B>
@ -87,41 +87,42 @@ FSFW_ENUM(commonObjects, uint32_t,
// PT: Pointing // PT: Pointing
// N/R: Nominal/Redundant // N/R: Nominal/Redundant
// F/M/B: Forward/Middle/Backwards // F/M/B: Forward/Middle/Backwards
((SUS_0_N_LOC_XFYFZM_PT_XF, 0x44120032, "SUS_0_N_LOC_XFYFZM_PT_XF")) SUS_0_N_LOC_XFYFZM_PT_XF = 0x44120032,
((SUS_6_R_LOC_XFYBZM_PT_XF, 0x44120038, "SUS_6_R_LOC_XFYBZM_PT_XF")) SUS_6_R_LOC_XFYBZM_PT_XF = 0x44120038,
((SUS_1_N_LOC_XBYFZM_PT_XB, 0x44120033, "SUS_1_N_LOC_XBYFZM_PT_XB")) SUS_1_N_LOC_XBYFZM_PT_XB = 0x44120033,
((SUS_7_R_LOC_XBYBZM_PT_XB, 0x44120039, "SUS_7_R_LOC_XBYBZM_PT_XB")) SUS_7_R_LOC_XBYBZM_PT_XB = 0x44120039,
((SUS_2_N_LOC_XFYBZB_PT_YB, 0x44120034, "SUS_2_N_LOC_XFYBZB_PT_YB")) SUS_2_N_LOC_XFYBZB_PT_YB = 0x44120034,
((SUS_8_R_LOC_XBYBZB_PT_YB, 0x44120040, "SUS_8_R_LOC_XBYBZB_PT_YB")) SUS_8_R_LOC_XBYBZB_PT_YB = 0x44120040,
((SUS_3_N_LOC_XFYBZF_PT_YF, 0x44120035, "SUS_3_N_LOC_XFYBZF_PT_YF")) SUS_3_N_LOC_XFYBZF_PT_YF = 0x44120035,
((SUS_9_R_LOC_XBYBZB_PT_YF, 0x44120041, "SUS_9_R_LOC_XBYBZB_PT_YF")) SUS_9_R_LOC_XBYBZB_PT_YF = 0x44120041,
((SUS_4_N_LOC_XMYFZF_PT_ZF, 0x44120036, "SUS_4_N_LOC_XMYFZF_PT_ZF")) SUS_4_N_LOC_XMYFZF_PT_ZF = 0x44120036,
((SUS_10_N_LOC_XMYBZF_PT_ZF, 0x44120042, "SUS_10_N_LOC_XMYBZF_PT_ZF")) SUS_10_N_LOC_XMYBZF_PT_ZF = 0x44120042,
((SUS_5_N_LOC_XFYMZB_PT_ZB, 0x44120037, "SUS_5_N_LOC_XFYMZB_PT_ZB")) SUS_5_N_LOC_XFYMZB_PT_ZB = 0x44120037,
((SUS_11_R_LOC_XBYMZB_PT_ZB, 0x44120043, "SUS_11_R_LOC_XBYMZB_PT_ZB")) SUS_11_R_LOC_XBYMZB_PT_ZB = 0x44120043,
((SYRLINKS_HK_HANDLER, 0x445300A3, "SYRLINKS_HK_HANDLER")) SYRLINKS_HK_HANDLER = 0x445300A3,
// 0x60 for other stuff // 0x60 for other stuff
((HEATER_0_PLOC_PROC_BRD, 0x60000000, "HEATER_0_PLOC_PROC_BRD")) HEATER_0_PLOC_PROC_BRD = 0x60000000,
((HEATER_1_PCDU_BRD, 0x60000001, "HEATER_1_PCDU_BRD")) HEATER_1_PCDU_BRD = 0x60000001,
((HEATER_2_ACS_BRD, 0x60000002, "HEATER_2_ACS_BRD")) HEATER_2_ACS_BRD = 0x60000002,
((HEATER_3_OBC_BRD, 0x60000003, "HEATER_3_OBC_BRD")) HEATER_3_OBC_BRD = 0x60000003,
((HEATER_4_CAMERA, 0x60000004, "HEATER_4_CAMERA")) HEATER_4_CAMERA = 0x60000004,
((HEATER_5_STR, 0x60000005, "HEATER_5_STR")) HEATER_5_STR = 0x60000005,
((HEATER_6_DRO, 0x60000006, "HEATER_6_DRO")) HEATER_6_DRO = 0x60000006,
((HEATER_7_HPA, 0x60000007, "HEATER_7_HPA")) HEATER_7_HPA = 0x60000007,
// 0x73 ('s') for assemblies and system/subsystem components // 0x73 ('s') for assemblies and system/subsystem components
((ACS_BOARD_ASS, 0x73000001, "ACS_BOARD_ASS")) ACS_BOARD_ASS = 0x73000001,
((SUS_BOARD_ASS, 0x73000002, "SUS_BOARD_ASS")) SUS_BOARD_ASS = 0x73000002,
((TCS_BOARD_ASS, 0x73000003, "TCS_BOARD_ASS")) TCS_BOARD_ASS = 0x73000003,
((RW_ASS, 0x73000004, "RW_ASS")) RW_ASS = 0x73000004
) };
}
#endif /* COMMON_CONFIG_COMMONOBJECTS_H_ */ #endif /* COMMON_CONFIG_COMMONOBJECTS_H_ */

24
dummies/SusDummy.cpp
View File

@ -6,18 +6,18 @@
#include <cstdlib> #include <cstdlib>
SusDummy::SusDummy() SusDummy::SusDummy()
: ExtendedControllerBase(commonObjects::SUS_0_N_LOC_XFYFZM_PT_XF, objects::NO_OBJECT), susSet(this) { : ExtendedControllerBase(objects::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(objects::SUS_6_R_LOC_XFYBZM_PT_XF, this);
ObjectManager::instance()->insert(commonObjects::SUS_1_N_LOC_XBYFZM_PT_XB, this); ObjectManager::instance()->insert(objects::SUS_1_N_LOC_XBYFZM_PT_XB, this);
ObjectManager::instance()->insert(commonObjects::SUS_7_R_LOC_XBYBZM_PT_XB, this); ObjectManager::instance()->insert(objects::SUS_7_R_LOC_XBYBZM_PT_XB, this);
ObjectManager::instance()->insert(commonObjects::SUS_2_N_LOC_XFYBZB_PT_YB, this); ObjectManager::instance()->insert(objects::SUS_2_N_LOC_XFYBZB_PT_YB, this);
ObjectManager::instance()->insert(commonObjects::SUS_8_R_LOC_XBYBZB_PT_YB, this); ObjectManager::instance()->insert(objects::SUS_8_R_LOC_XBYBZB_PT_YB, this);
ObjectManager::instance()->insert(commonObjects::SUS_3_N_LOC_XFYBZF_PT_YF, this); ObjectManager::instance()->insert(objects::SUS_3_N_LOC_XFYBZF_PT_YF, this);
ObjectManager::instance()->insert(commonObjects::SUS_9_R_LOC_XBYBZB_PT_YF, this); ObjectManager::instance()->insert(objects::SUS_9_R_LOC_XBYBZB_PT_YF, this);
ObjectManager::instance()->insert(commonObjects::SUS_4_N_LOC_XMYFZF_PT_ZF, this); ObjectManager::instance()->insert(objects::SUS_4_N_LOC_XMYFZF_PT_ZF, this);
ObjectManager::instance()->insert(commonObjects::SUS_10_N_LOC_XMYBZF_PT_ZF, this); ObjectManager::instance()->insert(objects::SUS_10_N_LOC_XMYBZF_PT_ZF, this);
ObjectManager::instance()->insert(commonObjects::SUS_5_N_LOC_XFYMZB_PT_ZB, this); ObjectManager::instance()->insert(objects::SUS_5_N_LOC_XFYMZB_PT_ZB, this);
ObjectManager::instance()->insert(commonObjects::SUS_11_R_LOC_XBYMZB_PT_ZB, this); ObjectManager::instance()->insert(objects::SUS_11_R_LOC_XBYMZB_PT_ZB, this);
} }
ReturnValue_t SusDummy::initialize() { ReturnValue_t SusDummy::initialize() {

36
dummies/TemperatureSensorsDummy.cpp
View File

@ -6,25 +6,25 @@
#include <cstdlib> #include <cstdlib>
TemperatureSensorsDummy::TemperatureSensorsDummy() 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) { max31865Set(this, MAX31865::MAX31865_SET_ID) {
ObjectManager::instance()->insert(commonObjects::RTD_1_IC4_PLOC_MISSIONBOARD, this); ObjectManager::instance()->insert(objects::RTD_1_IC4_PLOC_MISSIONBOARD, this);
ObjectManager::instance()->insert(commonObjects::RTD_2_IC5_4K_CAMERA, this); ObjectManager::instance()->insert(objects::RTD_2_IC5_4K_CAMERA, this);
ObjectManager::instance()->insert(commonObjects::RTD_3_IC6_DAC_HEATSPREADER, this); ObjectManager::instance()->insert(objects::RTD_3_IC6_DAC_HEATSPREADER, this);
ObjectManager::instance()->insert(commonObjects::RTD_4_IC7_STARTRACKER, this); ObjectManager::instance()->insert(objects::RTD_4_IC7_STARTRACKER, this);
ObjectManager::instance()->insert(commonObjects::RTD_5_IC8_RW1_MX_MY, this); ObjectManager::instance()->insert(objects::RTD_5_IC8_RW1_MX_MY, this);
ObjectManager::instance()->insert(commonObjects::RTD_6_IC9_DRO, this); ObjectManager::instance()->insert(objects::RTD_6_IC9_DRO, this);
ObjectManager::instance()->insert(commonObjects::RTD_7_IC10_SCEX, this); ObjectManager::instance()->insert(objects::RTD_7_IC10_SCEX, this);
ObjectManager::instance()->insert(commonObjects::RTD_8_IC11_X8, this); ObjectManager::instance()->insert(objects::RTD_8_IC11_X8, this);
ObjectManager::instance()->insert(commonObjects::RTD_9_IC12_HPA, this); ObjectManager::instance()->insert(objects::RTD_9_IC12_HPA, this);
ObjectManager::instance()->insert(commonObjects::RTD_10_IC13_PL_TX, this); ObjectManager::instance()->insert(objects::RTD_10_IC13_PL_TX, this);
ObjectManager::instance()->insert(commonObjects::RTD_11_IC14_MPA, this); ObjectManager::instance()->insert(objects::RTD_11_IC14_MPA, this);
ObjectManager::instance()->insert(commonObjects::RTD_12_IC15_ACU, this); ObjectManager::instance()->insert(objects::RTD_12_IC15_ACU, this);
ObjectManager::instance()->insert(commonObjects::RTD_13_IC16_PLPCDU_HEATSPREADER, this); ObjectManager::instance()->insert(objects::RTD_13_IC16_PLPCDU_HEATSPREADER, this);
ObjectManager::instance()->insert(commonObjects::RTD_14_IC17_TCS_BOARD, this); ObjectManager::instance()->insert(objects::RTD_14_IC17_TCS_BOARD, this);
ObjectManager::instance()->insert(commonObjects::RTD_15_IC18_IMTQ, this); ObjectManager::instance()->insert(objects::RTD_15_IC18_IMTQ, this);
ObjectManager::instance()->insert(commonObjects::TMP1075_HANDLER_1, this); ObjectManager::instance()->insert(objects::TMP1075_HANDLER_1, this);
ObjectManager::instance()->insert(commonObjects::TMP1075_HANDLER_2, this); ObjectManager::instance()->insert(objects::TMP1075_HANDLER_2, this);
} }
ReturnValue_t TemperatureSensorsDummy::initialize() { ReturnValue_t TemperatureSensorsDummy::initialize() {

130
linux/ObjectFactory.cpp
View File

@ -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, 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); spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
susHandlers[0] = susHandlers[0] =
new SusHandler(commonObjects::SUS_0_N_LOC_XFYFZM_PT_XF, 0, systemObjects::SPI_MAIN_COM_IF, spiCookie); new SusHandler(objects::SUS_0_N_LOC_XFYFZM_PT_XF, 0, objects::SPI_MAIN_COM_IF, spiCookie);
fdir = new SusFdir(commonObjects::SUS_0_N_LOC_XFYFZM_PT_XF); fdir = new SusFdir(objects::SUS_0_N_LOC_XFYFZM_PT_XF);
susHandlers[0]->setParent(commonObjects::SUS_BOARD_ASS); susHandlers[0]->setParent(objects::SUS_BOARD_ASS);
susHandlers[0]->setCustomFdir(fdir); susHandlers[0]->setCustomFdir(fdir);
spiCookie = new SpiCookie(addresses::SUS_1, gpioIds::CS_SUS_1, SUS::MAX_CMD_SIZE, spiCookie = new SpiCookie(addresses::SUS_1, gpioIds::CS_SUS_1, SUS::MAX_CMD_SIZE,
spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ); spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
susHandlers[1] = susHandlers[1] =
new SusHandler(commonObjects::SUS_1_N_LOC_XBYFZM_PT_XB, 1, systemObjects::SPI_MAIN_COM_IF, spiCookie); new SusHandler(objects::SUS_1_N_LOC_XBYFZM_PT_XB, 1, objects::SPI_MAIN_COM_IF, spiCookie);
fdir = new SusFdir(commonObjects::SUS_1_N_LOC_XBYFZM_PT_XB); fdir = new SusFdir(objects::SUS_1_N_LOC_XBYFZM_PT_XB);
susHandlers[1]->setParent(commonObjects::SUS_BOARD_ASS); susHandlers[1]->setParent(objects::SUS_BOARD_ASS);
susHandlers[1]->setCustomFdir(fdir); susHandlers[1]->setCustomFdir(fdir);
spiCookie = new SpiCookie(addresses::SUS_2, gpioIds::CS_SUS_2, SUS::MAX_CMD_SIZE, spiCookie = new SpiCookie(addresses::SUS_2, gpioIds::CS_SUS_2, SUS::MAX_CMD_SIZE,
spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ); spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
susHandlers[2] = susHandlers[2] =
new SusHandler(commonObjects::SUS_2_N_LOC_XFYBZB_PT_YB, 2, systemObjects::SPI_MAIN_COM_IF, spiCookie); new SusHandler(objects::SUS_2_N_LOC_XFYBZB_PT_YB, 2, objects::SPI_MAIN_COM_IF, spiCookie);
fdir = new SusFdir(commonObjects::SUS_2_N_LOC_XFYBZB_PT_YB); fdir = new SusFdir(objects::SUS_2_N_LOC_XFYBZB_PT_YB);
susHandlers[2]->setParent(commonObjects::SUS_BOARD_ASS); susHandlers[2]->setParent(objects::SUS_BOARD_ASS);
susHandlers[2]->setCustomFdir(fdir); susHandlers[2]->setCustomFdir(fdir);
spiCookie = new SpiCookie(addresses::SUS_3, gpioIds::CS_SUS_3, SUS::MAX_CMD_SIZE, spiCookie = new SpiCookie(addresses::SUS_3, gpioIds::CS_SUS_3, SUS::MAX_CMD_SIZE,
spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ); spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
susHandlers[3] = susHandlers[3] =
new SusHandler(commonObjects::SUS_3_N_LOC_XFYBZF_PT_YF, 3, systemObjects::SPI_MAIN_COM_IF, spiCookie); new SusHandler(objects::SUS_3_N_LOC_XFYBZF_PT_YF, 3, objects::SPI_MAIN_COM_IF, spiCookie);
fdir = new SusFdir(commonObjects::SUS_3_N_LOC_XFYBZF_PT_YF); fdir = new SusFdir(objects::SUS_3_N_LOC_XFYBZF_PT_YF);
susHandlers[3]->setParent(commonObjects::SUS_BOARD_ASS); susHandlers[3]->setParent(objects::SUS_BOARD_ASS);
susHandlers[3]->setCustomFdir(fdir); susHandlers[3]->setCustomFdir(fdir);
spiCookie = new SpiCookie(addresses::SUS_4, gpioIds::CS_SUS_4, SUS::MAX_CMD_SIZE, spiCookie = new SpiCookie(addresses::SUS_4, gpioIds::CS_SUS_4, SUS::MAX_CMD_SIZE,
spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ); spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
susHandlers[4] = susHandlers[4] =
new SusHandler(commonObjects::SUS_4_N_LOC_XMYFZF_PT_ZF, 4, systemObjects::SPI_MAIN_COM_IF, spiCookie); new SusHandler(objects::SUS_4_N_LOC_XMYFZF_PT_ZF, 4, objects::SPI_MAIN_COM_IF, spiCookie);
fdir = new SusFdir(commonObjects::SUS_4_N_LOC_XMYFZF_PT_ZF); fdir = new SusFdir(objects::SUS_4_N_LOC_XMYFZF_PT_ZF);
susHandlers[4]->setParent(commonObjects::SUS_BOARD_ASS); susHandlers[4]->setParent(objects::SUS_BOARD_ASS);
susHandlers[4]->setCustomFdir(fdir); susHandlers[4]->setCustomFdir(fdir);
spiCookie = new SpiCookie(addresses::SUS_5, gpioIds::CS_SUS_5, SUS::MAX_CMD_SIZE, spiCookie = new SpiCookie(addresses::SUS_5, gpioIds::CS_SUS_5, SUS::MAX_CMD_SIZE,
spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ); spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
susHandlers[5] = susHandlers[5] =
new SusHandler(commonObjects::SUS_5_N_LOC_XFYMZB_PT_ZB, 5, systemObjects::SPI_MAIN_COM_IF, spiCookie); new SusHandler(objects::SUS_5_N_LOC_XFYMZB_PT_ZB, 5, objects::SPI_MAIN_COM_IF, spiCookie);
fdir = new SusFdir(commonObjects::SUS_5_N_LOC_XFYMZB_PT_ZB); fdir = new SusFdir(objects::SUS_5_N_LOC_XFYMZB_PT_ZB);
susHandlers[5]->setParent(commonObjects::SUS_BOARD_ASS); susHandlers[5]->setParent(objects::SUS_BOARD_ASS);
susHandlers[5]->setCustomFdir(fdir); susHandlers[5]->setCustomFdir(fdir);
spiCookie = new SpiCookie(addresses::SUS_6, gpioIds::CS_SUS_6, SUS::MAX_CMD_SIZE, spiCookie = new SpiCookie(addresses::SUS_6, gpioIds::CS_SUS_6, SUS::MAX_CMD_SIZE,
spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ); spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
susHandlers[6] = susHandlers[6] =
new SusHandler(commonObjects::SUS_6_R_LOC_XFYBZM_PT_XF, 6, systemObjects::SPI_MAIN_COM_IF, spiCookie); new SusHandler(objects::SUS_6_R_LOC_XFYBZM_PT_XF, 6, objects::SPI_MAIN_COM_IF, spiCookie);
fdir = new SusFdir(commonObjects::SUS_6_R_LOC_XFYBZM_PT_XF); fdir = new SusFdir(objects::SUS_6_R_LOC_XFYBZM_PT_XF);
susHandlers[6]->setParent(commonObjects::SUS_BOARD_ASS); susHandlers[6]->setParent(objects::SUS_BOARD_ASS);
susHandlers[6]->setCustomFdir(fdir); susHandlers[6]->setCustomFdir(fdir);
spiCookie = new SpiCookie(addresses::SUS_7, gpioIds::CS_SUS_7, SUS::MAX_CMD_SIZE, spiCookie = new SpiCookie(addresses::SUS_7, gpioIds::CS_SUS_7, SUS::MAX_CMD_SIZE,
spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ); spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
susHandlers[7] = susHandlers[7] =
new SusHandler(commonObjects::SUS_7_R_LOC_XBYBZM_PT_XB, 7, systemObjects::SPI_MAIN_COM_IF, spiCookie); new SusHandler(objects::SUS_7_R_LOC_XBYBZM_PT_XB, 7, objects::SPI_MAIN_COM_IF, spiCookie);
fdir = new SusFdir(commonObjects::SUS_7_R_LOC_XBYBZM_PT_XB); fdir = new SusFdir(objects::SUS_7_R_LOC_XBYBZM_PT_XB);
susHandlers[7]->setParent(commonObjects::SUS_BOARD_ASS); susHandlers[7]->setParent(objects::SUS_BOARD_ASS);
susHandlers[7]->setCustomFdir(fdir); susHandlers[7]->setCustomFdir(fdir);
spiCookie = new SpiCookie(addresses::SUS_8, gpioIds::CS_SUS_8, SUS::MAX_CMD_SIZE, spiCookie = new SpiCookie(addresses::SUS_8, gpioIds::CS_SUS_8, SUS::MAX_CMD_SIZE,
spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ); spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
susHandlers[8] = susHandlers[8] =
new SusHandler(commonObjects::SUS_8_R_LOC_XBYBZB_PT_YB, 8, systemObjects::SPI_MAIN_COM_IF, spiCookie); new SusHandler(objects::SUS_8_R_LOC_XBYBZB_PT_YB, 8, objects::SPI_MAIN_COM_IF, spiCookie);
fdir = new SusFdir(commonObjects::SUS_8_R_LOC_XBYBZB_PT_YB); fdir = new SusFdir(objects::SUS_8_R_LOC_XBYBZB_PT_YB);
susHandlers[8]->setParent(commonObjects::SUS_BOARD_ASS); susHandlers[8]->setParent(objects::SUS_BOARD_ASS);
susHandlers[8]->setCustomFdir(fdir); susHandlers[8]->setCustomFdir(fdir);
spiCookie = new SpiCookie(addresses::SUS_9, gpioIds::CS_SUS_9, SUS::MAX_CMD_SIZE, spiCookie = new SpiCookie(addresses::SUS_9, gpioIds::CS_SUS_9, SUS::MAX_CMD_SIZE,
spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ); spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
susHandlers[9] = susHandlers[9] =
new SusHandler(commonObjects::SUS_9_R_LOC_XBYBZB_PT_YF, 9, systemObjects::SPI_MAIN_COM_IF, spiCookie); new SusHandler(objects::SUS_9_R_LOC_XBYBZB_PT_YF, 9, objects::SPI_MAIN_COM_IF, spiCookie);
fdir = new SusFdir(commonObjects::SUS_9_R_LOC_XBYBZB_PT_YF); fdir = new SusFdir(objects::SUS_9_R_LOC_XBYBZB_PT_YF);
susHandlers[9]->setParent(commonObjects::SUS_BOARD_ASS); susHandlers[9]->setParent(objects::SUS_BOARD_ASS);
susHandlers[9]->setCustomFdir(fdir); susHandlers[9]->setCustomFdir(fdir);
spiCookie = new SpiCookie(addresses::SUS_10, gpioIds::CS_SUS_10, SUS::MAX_CMD_SIZE, spiCookie = new SpiCookie(addresses::SUS_10, gpioIds::CS_SUS_10, SUS::MAX_CMD_SIZE,
spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ); spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
susHandlers[10] = susHandlers[10] =
new SusHandler(commonObjects::SUS_10_N_LOC_XMYBZF_PT_ZF, 10, systemObjects::SPI_MAIN_COM_IF, spiCookie); new SusHandler(objects::SUS_10_N_LOC_XMYBZF_PT_ZF, 10, objects::SPI_MAIN_COM_IF, spiCookie);
fdir = new SusFdir(commonObjects::SUS_10_N_LOC_XMYBZF_PT_ZF); fdir = new SusFdir(objects::SUS_10_N_LOC_XMYBZF_PT_ZF);
susHandlers[10]->setParent(commonObjects::SUS_BOARD_ASS); susHandlers[10]->setParent(objects::SUS_BOARD_ASS);
susHandlers[10]->setCustomFdir(fdir); susHandlers[10]->setCustomFdir(fdir);
spiCookie = new SpiCookie(addresses::SUS_11, gpioIds::CS_SUS_11, SUS::MAX_CMD_SIZE, spiCookie = new SpiCookie(addresses::SUS_11, gpioIds::CS_SUS_11, SUS::MAX_CMD_SIZE,
spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ); spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
susHandlers[11] = susHandlers[11] =
new SusHandler(commonObjects::SUS_11_R_LOC_XBYMZB_PT_ZB, 11, systemObjects::SPI_MAIN_COM_IF, spiCookie); new SusHandler(objects::SUS_11_R_LOC_XBYMZB_PT_ZB, 11, objects::SPI_MAIN_COM_IF, spiCookie);
fdir = new SusFdir(commonObjects::SUS_11_R_LOC_XBYMZB_PT_ZB); fdir = new SusFdir(objects::SUS_11_R_LOC_XBYMZB_PT_ZB);
susHandlers[11]->setParent(commonObjects::SUS_BOARD_ASS); susHandlers[11]->setParent(objects::SUS_BOARD_ASS);
susHandlers[11]->setCustomFdir(fdir); susHandlers[11]->setCustomFdir(fdir);
for (auto& sus : susHandlers) { for (auto& sus : susHandlers) {
@ -179,15 +179,15 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo
} }
} }
std::array<object_id_t, 12> susIds = { std::array<object_id_t, 12> susIds = {
commonObjects::SUS_0_N_LOC_XFYFZM_PT_XF, commonObjects::SUS_1_N_LOC_XBYFZM_PT_XB, objects::SUS_0_N_LOC_XFYFZM_PT_XF, objects::SUS_1_N_LOC_XBYFZM_PT_XB,
commonObjects::SUS_2_N_LOC_XFYBZB_PT_YB, commonObjects::SUS_3_N_LOC_XFYBZF_PT_YF, objects::SUS_2_N_LOC_XFYBZB_PT_YB, objects::SUS_3_N_LOC_XFYBZF_PT_YF,
commonObjects::SUS_4_N_LOC_XMYFZF_PT_ZF, commonObjects::SUS_5_N_LOC_XFYMZB_PT_ZB, objects::SUS_4_N_LOC_XMYFZF_PT_ZF, objects::SUS_5_N_LOC_XFYMZB_PT_ZB,
commonObjects::SUS_6_R_LOC_XFYBZM_PT_XF, commonObjects::SUS_7_R_LOC_XBYBZM_PT_XB, objects::SUS_6_R_LOC_XFYBZM_PT_XF, objects::SUS_7_R_LOC_XBYBZM_PT_XB,
commonObjects::SUS_8_R_LOC_XBYBZB_PT_YB, commonObjects::SUS_9_R_LOC_XBYBZB_PT_YF, objects::SUS_8_R_LOC_XBYBZB_PT_YB, objects::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_10_N_LOC_XMYBZF_PT_ZF, objects::SUS_11_R_LOC_XBYMZB_PT_ZB};
SusAssHelper susAssHelper = SusAssHelper(susIds); SusAssHelper susAssHelper = SusAssHelper(susIds);
auto susAss = 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<void>(susAss); static_cast<void>(susAss);
#endif /* OBSW_ADD_SUN_SENSORS == 1 */ #endif /* OBSW_ADD_SUN_SENSORS == 1 */
} }
@ -270,28 +270,28 @@ void ObjectFactory::createRtdComponents(std::string spiDev, GpioIF* gpioComIF,
}}; }};
// HSPD: Heatspreader // HSPD: Heatspreader
std::array<std::pair<object_id_t, std::string>, NUM_RTDS> rtdInfos = {{ std::array<std::pair<object_id_t, std::string>, NUM_RTDS> rtdInfos = {{
{commonObjects::RTD_0_IC3_PLOC_HEATSPREADER, "RTD_0_PLOC_HSPD"}, {objects::RTD_0_IC3_PLOC_HEATSPREADER, "RTD_0_PLOC_HSPD"},
{commonObjects::RTD_1_IC4_PLOC_MISSIONBOARD, "RTD_1_PLOC_MISSIONBRD"}, {objects::RTD_1_IC4_PLOC_MISSIONBOARD, "RTD_1_PLOC_MISSIONBRD"},
{commonObjects::RTD_2_IC5_4K_CAMERA, "RTD_2_4K_CAMERA"}, {objects::RTD_2_IC5_4K_CAMERA, "RTD_2_4K_CAMERA"},
{commonObjects::RTD_3_IC6_DAC_HEATSPREADER, "RTD_3_DAC_HSPD"}, {objects::RTD_3_IC6_DAC_HEATSPREADER, "RTD_3_DAC_HSPD"},
{commonObjects::RTD_4_IC7_STARTRACKER, "RTD_4_STARTRACKER"}, {objects::RTD_4_IC7_STARTRACKER, "RTD_4_STARTRACKER"},
{commonObjects::RTD_5_IC8_RW1_MX_MY, "RTD_5_RW1_MX_MY"}, {objects::RTD_5_IC8_RW1_MX_MY, "RTD_5_RW1_MX_MY"},
{commonObjects::RTD_6_IC9_DRO, "RTD_6_DRO"}, {objects::RTD_6_IC9_DRO, "RTD_6_DRO"},
{commonObjects::RTD_7_IC10_SCEX, "RTD_7_SCEX"}, {objects::RTD_7_IC10_SCEX, "RTD_7_SCEX"},
{commonObjects::RTD_8_IC11_X8, "RTD_8_X8"}, {objects::RTD_8_IC11_X8, "RTD_8_X8"},
{commonObjects::RTD_9_IC12_HPA, "RTD_9_HPA"}, {objects::RTD_9_IC12_HPA, "RTD_9_HPA"},
{commonObjects::RTD_10_IC13_PL_TX, "RTD_10_PL_TX,"}, {objects::RTD_10_IC13_PL_TX, "RTD_10_PL_TX,"},
{commonObjects::RTD_11_IC14_MPA, "RTD_11_MPA"}, {objects::RTD_11_IC14_MPA, "RTD_11_MPA"},
{commonObjects::RTD_12_IC15_ACU, "RTD_12_ACU"}, {objects::RTD_12_IC15_ACU, "RTD_12_ACU"},
{commonObjects::RTD_13_IC16_PLPCDU_HEATSPREADER, "RTD_13_PLPCDU_HSPD"}, {objects::RTD_13_IC16_PLPCDU_HEATSPREADER, "RTD_13_PLPCDU_HSPD"},
{commonObjects::RTD_14_IC17_TCS_BOARD, "RTD_14_TCS_BOARD"}, {objects::RTD_14_IC17_TCS_BOARD, "RTD_14_TCS_BOARD"},
{commonObjects::RTD_15_IC18_IMTQ, "RTD_15_IMTQ"}, {objects::RTD_15_IC18_IMTQ, "RTD_15_IMTQ"},
}}; }};
std::array<SpiCookie*, NUM_RTDS> rtdCookies = {}; std::array<SpiCookie*, NUM_RTDS> rtdCookies = {};
std::array<Max31865EiveHandler*, NUM_RTDS> rtds = {}; std::array<Max31865EiveHandler*, NUM_RTDS> rtds = {};
RtdFdir* rtdFdir = nullptr; RtdFdir* rtdFdir = nullptr;
// Create special low level reader communication interface // 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++) { for (uint8_t idx = 0; idx < NUM_RTDS; idx++) {
rtdCookies[idx] = new SpiCookie(cookieArgs[idx].first, cookieArgs[idx].second, rtdCookies[idx] = new SpiCookie(cookieArgs[idx].first, cookieArgs[idx].second,
MAX31865::MAX_REPLY_SIZE, spi::RTD_MODE, spi::RTD_SPEED); MAX31865::MAX_REPLY_SIZE, spi::RTD_MODE, spi::RTD_SPEED);
@ -299,9 +299,9 @@ void ObjectFactory::createRtdComponents(std::string spiDev, GpioIF* gpioComIF,
Max31865ReaderCookie* rtdLowLevelCookie = Max31865ReaderCookie* rtdLowLevelCookie =
new Max31865ReaderCookie(rtdInfos[idx].first, idx, rtdInfos[idx].second, rtdCookies[idx]); new Max31865ReaderCookie(rtdInfos[idx].first, idx, rtdInfos[idx].second, rtdCookies[idx]);
rtds[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]->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); rtdFdir = new RtdFdir(rtdInfos[idx].first);
rtds[idx]->setCustomFdir(rtdFdir); rtds[idx]->setCustomFdir(rtdFdir);
#if OBSW_DEBUG_RTD == 1 #if OBSW_DEBUG_RTD == 1
@ -315,17 +315,17 @@ void ObjectFactory::createRtdComponents(std::string spiDev, GpioIF* gpioComIF,
TcsBoardHelper helper(rtdInfos); TcsBoardHelper helper(rtdInfos);
TcsBoardAssembly* tcsBoardAss = 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); pcdu::Switches::PDU1_CH0_TCS_BOARD_3V3, helper);
static_cast<void>(tcsBoardAss); static_cast<void>(tcsBoardAss);
#endif // OBSW_ADD_RTD_DEVICES == 1 #endif // OBSW_ADD_RTD_DEVICES == 1
} }
void ObjectFactory::createThermalController() { 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) { void ObjectFactory::gpioChecker(ReturnValue_t result, std::string output) {
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {

2
linux/devices/ploc/PlocMPSoCHandler.cpp
View File

@ -317,7 +317,7 @@ ReturnValue_t PlocMPSoCHandler::initializeLocalDataPool(localpool::DataPool& loc
void PlocMPSoCHandler::handleEvent(EventMessage* eventMessage) { void PlocMPSoCHandler::handleEvent(EventMessage* eventMessage) {
object_id_t objectId = eventMessage->getReporter(); object_id_t objectId = eventMessage->getReporter();
switch (objectId) { switch (objectId) {
case commonObjects::PLOC_MPSOC_HELPER: { case objects::PLOC_MPSOC_HELPER: {
plocMPSoCHelperExecuting = false; plocMPSoCHelperExecuting = false;
break; break;
} }

2
linux/devices/ploc/PlocMemoryDumper.cpp
View File

@ -167,7 +167,7 @@ void PlocMemoryDumper::commandNextMramDump(ActionId_t dumpCommand) {
MemoryParams params(tempStartAddress, tempEndAddress); MemoryParams params(tempStartAddress, tempEndAddress);
result = result =
commandActionHelper.commandAction(commonObjects::PLOC_SUPERVISOR_HANDLER, dumpCommand, &params); commandActionHelper.commandAction(objects::PLOC_SUPERVISOR_HANDLER, dumpCommand, &params);
if (result != RETURN_OK) { if (result != RETURN_OK) {
sif::warning << "PlocMemoryDumper::commandNextMramDump: Failed to send mram dump command " sif::warning << "PlocMemoryDumper::commandNextMramDump: Failed to send mram dump command "
<< "with start address " << tempStartAddress << " and end address " << "with start address " << tempStartAddress << " and end address "

2
linux/devices/ploc/PlocSupervisorHandler.cpp
View File

@ -823,7 +823,7 @@ void PlocSupervisorHandler::handleEvent(EventMessage* eventMessage) {
object_id_t objectId = eventMessage->getReporter(); object_id_t objectId = eventMessage->getReporter();
Event event = eventMessage->getEvent(); Event event = eventMessage->getEvent();
switch (objectId) { switch (objectId) {
case commonObjects::PLOC_SUPERVISOR_HELPER: { case objects::PLOC_SUPERVISOR_HELPER: {
plocSupvHelperExecuting = false; plocSupvHelperExecuting = false;
// After execution of update procedure, PLOC is in a state where it draws approx. 700 mA of // 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. // current. To leave this state the shutdown MPSoC command must be sent here.

2
linux/devices/startracker/StarTrackerHandler.cpp
View File

@ -1461,7 +1461,7 @@ ReturnValue_t StarTrackerHandler::scanForTmReply(DeviceCommandId_t* foundId) {
void StarTrackerHandler::handleEvent(EventMessage* eventMessage) { void StarTrackerHandler::handleEvent(EventMessage* eventMessage) {
object_id_t objectId = eventMessage->getReporter(); object_id_t objectId = eventMessage->getReporter();
switch (objectId) { 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 // All events from image loader signal either that the operation was successful or that it
// failed // failed
strHelperExecuting = false; strHelperExecuting = false;

42
linux/fsfwconfig/devices/addresses.h
View File

@ -12,30 +12,30 @@ namespace addresses {
enum logicalAddresses : address_t { enum logicalAddresses : address_t {
PCDU, PCDU,
MGM_0_LIS3 = commonObjects::MGM_0_LIS3_HANDLER, MGM_0_LIS3 = objects::MGM_0_LIS3_HANDLER,
MGM_1_RM3100 = commonObjects::MGM_1_RM3100_HANDLER, MGM_1_RM3100 = objects::MGM_1_RM3100_HANDLER,
MGM_2_LIS3 = commonObjects::MGM_2_LIS3_HANDLER, MGM_2_LIS3 = objects::MGM_2_LIS3_HANDLER,
MGM_3_RM3100 = commonObjects::MGM_3_RM3100_HANDLER, MGM_3_RM3100 = objects::MGM_3_RM3100_HANDLER,
GYRO_0_ADIS = commonObjects::GYRO_0_ADIS_HANDLER, GYRO_0_ADIS = objects::GYRO_0_ADIS_HANDLER,
GYRO_1_L3G = commonObjects::GYRO_1_L3G_HANDLER, GYRO_1_L3G = objects::GYRO_1_L3G_HANDLER,
GYRO_2_ADIS = commonObjects::GYRO_2_ADIS_HANDLER, GYRO_2_ADIS = objects::GYRO_2_ADIS_HANDLER,
GYRO_3_L3G = commonObjects::GYRO_3_L3G_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_0 = objects::SUS_0_N_LOC_XFYFZM_PT_XF,
SUS_1 = commonObjects::SUS_1_N_LOC_XBYFZM_PT_XB, SUS_1 = objects::SUS_1_N_LOC_XBYFZM_PT_XB,
SUS_2 = commonObjects::SUS_2_N_LOC_XFYBZB_PT_YB, SUS_2 = objects::SUS_2_N_LOC_XFYBZB_PT_YB,
SUS_3 = commonObjects::SUS_3_N_LOC_XFYBZF_PT_YF, SUS_3 = objects::SUS_3_N_LOC_XFYBZF_PT_YF,
SUS_4 = commonObjects::SUS_4_N_LOC_XMYFZF_PT_ZF, SUS_4 = objects::SUS_4_N_LOC_XMYFZF_PT_ZF,
SUS_5 = commonObjects::SUS_5_N_LOC_XFYMZB_PT_ZB, SUS_5 = objects::SUS_5_N_LOC_XFYMZB_PT_ZB,
SUS_6 = commonObjects::SUS_6_R_LOC_XFYBZM_PT_XF, SUS_6 = objects::SUS_6_R_LOC_XFYBZM_PT_XF,
SUS_7 = commonObjects::SUS_7_R_LOC_XBYBZM_PT_XB, SUS_7 = objects::SUS_7_R_LOC_XBYBZM_PT_XB,
SUS_8 = commonObjects::SUS_8_R_LOC_XBYBZB_PT_YB, SUS_8 = objects::SUS_8_R_LOC_XBYBZB_PT_YB,
SUS_9 = commonObjects::SUS_9_R_LOC_XBYBZB_PT_YF, SUS_9 = objects::SUS_9_R_LOC_XBYBZB_PT_YF,
SUS_10 = commonObjects::SUS_10_N_LOC_XMYBZF_PT_ZF, SUS_10 = objects::SUS_10_N_LOC_XMYBZF_PT_ZF,
SUS_11 = commonObjects::SUS_11_R_LOC_XBYMZB_PT_ZB, SUS_11 = objects::SUS_11_R_LOC_XBYMZB_PT_ZB,
/* Dummy and Test Addresses */ /* Dummy and Test Addresses */
DUMMY_ECHO = 129, DUMMY_ECHO = 129,

52
linux/fsfwconfig/objects/systemObjectList.h
View File

@ -7,8 +7,6 @@
#include "commonObjects.h" #include "commonObjects.h"
#include <fsfw/introspection/Enum.h>
// The objects will be instantiated in the ID order // The objects will be instantiated in the ID order
// For naming scheme see flight manual // 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. Fourth byte is a unique counter.
*/ */
FSFW_ENUM( systemObjects, uint32_t, namespace objects {
enum sourceObjects : uint32_t {
/* 0x53 reserved for FSFW */ /* 0x53 reserved for FSFW */
/*((FW_ADDRESS_START, PUS_SERVICE_1_VERIFICATION, "FW_ADDRESS_START"))*/ FW_ADDRESS_START = PUS_SERVICE_1_VERIFICATION,
/*((FW_ADDRESS_END, TIME_STAMPER, "FW_ADDRESS_END"))*/ FW_ADDRESS_END = TIME_STAMPER,
((PUS_SERVICE_6, 0x51000500, "PUS_SERVICE_6")) PUS_SERVICE_6 = 0x51000500,
((CCSDS_IP_CORE_BRIDGE, 0x73500000, "CCSDS_IP_CORE_BRIDGE")) CCSDS_IP_CORE_BRIDGE = 0x73500000,
((TM_FUNNEL, 0x73000100, "TM_FUNNEL")) TM_FUNNEL = 0x73000100,
/* 0x49 ('I') for Communication Interfaces **/ /* 0x49 ('I') for Communication Interfaces **/
((ARDUINO_COM_IF, 0x49000000, "ARDUINO_COM_IF")) ARDUINO_COM_IF = 0x49000000,
((CSP_COM_IF, 0x49050001, "CSP_COM_IF")) CSP_COM_IF = 0x49050001,
((I2C_COM_IF, 0x49040002, "I2C_COM_IF")) I2C_COM_IF = 0x49040002,
((UART_COM_IF, 0x49030003, "UART_COM_IF")) UART_COM_IF = 0x49030003,
((SPI_MAIN_COM_IF, 0x49020004, "SPI_MAIN_COM_IF")) SPI_MAIN_COM_IF = 0x49020004,
((GPIO_IF, 0x49010005, "GPIO_IF")) GPIO_IF = 0x49010005,
((SPI_RW_COM_IF, 0x49020005, "SPI_RW_COM_IF")) SPI_RW_COM_IF = 0x49020005,
((SPI_RTD_COM_IF, 0x49020006, "SPI_RTD_COM_IF")) SPI_RTD_COM_IF = 0x49020006,
/* 0x54 ('T') for test handlers */ /* 0x54 ('T') for test handlers */
((TEST_TASK, 0x54694269, "TEST_TASK")) TEST_TASK = 0x54694269,
((LIBGPIOD_TEST, 0x54123456, "LIBGPIOD_TEST")) LIBGPIOD_TEST = 0x54123456,
((SPI_TEST, 0x54000010, "SPI_TEST")) SPI_TEST = 0x54000010,
((UART_TEST, 0x54000020, "UART_TEST")) UART_TEST = 0x54000020,
((I2C_TEST, 0x54000030, "I2C_TEST")) I2C_TEST = 0x54000030,
((DUMMY_INTERFACE, 0x5400CAFE, "DUMMY_INTERFACE")) DUMMY_INTERFACE = 0x5400CAFE,
((DUMMY_HANDLER, 0x5400AFFE, "DUMMY_HANDLER")) DUMMY_HANDLER = 0x5400AFFE,
((P60DOCK_TEST_TASK, 0x00005060, "P60DOCK_TEST_TASK")) P60DOCK_TEST_TASK = 0x00005060,
((DUMMY_COM_IF, 0x54000040, "DUMMY_COM_IF")) DUMMY_COM_IF = 0x54000040
) };
}
#endif /* LINUX_FSFWCONFIG_OBJECTS_SYSTEMOBJECTLIST_H_ */ #endif /* LINUX_FSFWCONFIG_OBJECTS_SYSTEMOBJECTLIST_H_ */

504
linux/fsfwconfig/pollingsequence/pollingSequenceFactory.cpp
View File

@ -19,8 +19,8 @@ ReturnValue_t pst::pstGpio(FixedTimeslotTaskIF *thisSequence) {
// Length of a communication cycle // Length of a communication cycle
uint32_t length = thisSequence->getPeriodMs(); uint32_t length = thisSequence->getPeriodMs();
thisSequence->addSlot(commonObjects::HEATER_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION); thisSequence->addSlot(objects::HEATER_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
thisSequence->addSlot(commonObjects::SOLAR_ARRAY_DEPL_HANDLER, length * 0, thisSequence->addSlot(objects::SOLAR_ARRAY_DEPL_HANDLER, length * 0,
DeviceHandlerIF::PERFORM_OPERATION); DeviceHandlerIF::PERFORM_OPERATION);
if (thisSequence->checkSequence() == HasReturnvaluesIF::RETURN_OK) { if (thisSequence->checkSequence() == HasReturnvaluesIF::RETURN_OK) {
@ -34,30 +34,30 @@ ReturnValue_t pst::pstGpio(FixedTimeslotTaskIF *thisSequence) {
ReturnValue_t pst::pstSpiRw(FixedTimeslotTaskIF *thisSequence) { ReturnValue_t pst::pstSpiRw(FixedTimeslotTaskIF *thisSequence) {
uint32_t length = thisSequence->getPeriodMs(); uint32_t length = thisSequence->getPeriodMs();
static_cast<void>(length); static_cast<void>(length);
thisSequence->addSlot(commonObjects::RW1, length * 0, DeviceHandlerIF::PERFORM_OPERATION); thisSequence->addSlot(objects::RW1, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
thisSequence->addSlot(commonObjects::RW2, length * 0, DeviceHandlerIF::PERFORM_OPERATION); thisSequence->addSlot(objects::RW2, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
thisSequence->addSlot(commonObjects::RW3, length * 0, DeviceHandlerIF::PERFORM_OPERATION); thisSequence->addSlot(objects::RW3, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
thisSequence->addSlot(commonObjects::RW4, 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(objects::RW1, length * 0.2, DeviceHandlerIF::SEND_WRITE);
thisSequence->addSlot(commonObjects::RW2, length * 0.2, DeviceHandlerIF::SEND_WRITE); thisSequence->addSlot(objects::RW2, length * 0.2, DeviceHandlerIF::SEND_WRITE);
thisSequence->addSlot(commonObjects::RW3, length * 0.2, DeviceHandlerIF::SEND_WRITE); thisSequence->addSlot(objects::RW3, length * 0.2, DeviceHandlerIF::SEND_WRITE);
thisSequence->addSlot(commonObjects::RW4, 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(objects::RW1, length * 0.8, DeviceHandlerIF::GET_WRITE);
thisSequence->addSlot(commonObjects::RW2, length * 0.8, DeviceHandlerIF::GET_WRITE); thisSequence->addSlot(objects::RW2, length * 0.8, DeviceHandlerIF::GET_WRITE);
thisSequence->addSlot(commonObjects::RW3, length * 0.8, DeviceHandlerIF::GET_WRITE); thisSequence->addSlot(objects::RW3, length * 0.8, DeviceHandlerIF::GET_WRITE);
thisSequence->addSlot(commonObjects::RW4, 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(objects::RW1, length * 0.8, DeviceHandlerIF::SEND_READ);
thisSequence->addSlot(commonObjects::RW2, length * 0.8, DeviceHandlerIF::SEND_READ); thisSequence->addSlot(objects::RW2, length * 0.8, DeviceHandlerIF::SEND_READ);
thisSequence->addSlot(commonObjects::RW3, length * 0.8, DeviceHandlerIF::SEND_READ); thisSequence->addSlot(objects::RW3, length * 0.8, DeviceHandlerIF::SEND_READ);
thisSequence->addSlot(commonObjects::RW4, 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(objects::RW1, length * 0.8, DeviceHandlerIF::GET_READ);
thisSequence->addSlot(commonObjects::RW2, length * 0.8, DeviceHandlerIF::GET_READ); thisSequence->addSlot(objects::RW2, length * 0.8, DeviceHandlerIF::GET_READ);
thisSequence->addSlot(commonObjects::RW3, length * 0.8, DeviceHandlerIF::GET_READ); thisSequence->addSlot(objects::RW3, length * 0.8, DeviceHandlerIF::GET_READ);
thisSequence->addSlot(commonObjects::RW4, length * 0.8, DeviceHandlerIF::GET_READ); thisSequence->addSlot(objects::RW4, length * 0.8, DeviceHandlerIF::GET_READ);
return thisSequence->checkSequence(); return thisSequence->checkSequence();
} }
@ -65,35 +65,35 @@ ReturnValue_t pst::pstSpi(FixedTimeslotTaskIF *thisSequence) {
uint32_t length = thisSequence->getPeriodMs(); uint32_t length = thisSequence->getPeriodMs();
static_cast<void>(length); static_cast<void>(length);
#if OBSW_ADD_PL_PCDU == 1 #if OBSW_ADD_PL_PCDU == 1
thisSequence->addSlot(commonObjects::PLPCDU_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION); thisSequence->addSlot(objects::PLPCDU_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
thisSequence->addSlot(commonObjects::PLPCDU_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE); thisSequence->addSlot(objects::PLPCDU_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE);
thisSequence->addSlot(commonObjects::PLPCDU_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE); thisSequence->addSlot(objects::PLPCDU_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
thisSequence->addSlot(commonObjects::PLPCDU_HANDLER, length * 0, DeviceHandlerIF::SEND_READ); thisSequence->addSlot(objects::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::GET_READ);
#endif #endif
#if OBSW_ADD_TMP_DEVICES == 1 #if OBSW_ADD_TMP_DEVICES == 1
thisSequence->addSlot(commonObjects::TMP1075_HANDLER_1, length * 0, DeviceHandlerIF::PERFORM_OPERATION); thisSequence->addSlot(objects::TMP1075_HANDLER_1, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
thisSequence->addSlot(commonObjects::TMP1075_HANDLER_2, length * 0, DeviceHandlerIF::PERFORM_OPERATION); thisSequence->addSlot(objects::TMP1075_HANDLER_2, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
#endif #endif
#if OBSW_ADD_TMP_DEVICES == 1 #if OBSW_ADD_TMP_DEVICES == 1
thisSequence->addSlot(commonObjects::TMP1075_HANDLER_1, length * 0.2, DeviceHandlerIF::SEND_WRITE); thisSequence->addSlot(objects::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_2, length * 0.2, DeviceHandlerIF::SEND_WRITE);
#endif #endif
#if OBSW_ADD_TMP_DEVICES == 1 #if OBSW_ADD_TMP_DEVICES == 1
thisSequence->addSlot(commonObjects::TMP1075_HANDLER_1, length * 0.2, DeviceHandlerIF::GET_WRITE); thisSequence->addSlot(objects::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_2, length * 0.2, DeviceHandlerIF::GET_WRITE);
#endif #endif
#if OBSW_ADD_TMP_DEVICES == 1 #if OBSW_ADD_TMP_DEVICES == 1
thisSequence->addSlot(commonObjects::TMP1075_HANDLER_1, length * 0.2, DeviceHandlerIF::SEND_READ); thisSequence->addSlot(objects::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_2, length * 0.2, DeviceHandlerIF::SEND_READ);
#endif #endif
#if OBSW_ADD_TMP_DEVICES == 1 #if OBSW_ADD_TMP_DEVICES == 1
thisSequence->addSlot(commonObjects::TMP1075_HANDLER_1, length * 0.2, DeviceHandlerIF::GET_READ); thisSequence->addSlot(objects::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_2, length * 0.2, DeviceHandlerIF::GET_READ);
#endif #endif
#if OBSW_ADD_SUN_SENSORS == 1 #if OBSW_ADD_SUN_SENSORS == 1
@ -113,261 +113,261 @@ ReturnValue_t pst::pstSpi(FixedTimeslotTaskIF *thisSequence) {
if (addSus0) { if (addSus0) {
/* Write setup */ /* 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); 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); 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); 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); 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); 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); 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); 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); DeviceHandlerIF::GET_READ);
} }
if (addSus1) { 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); 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); 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); 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); 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); 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); 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); 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); DeviceHandlerIF::GET_READ);
} }
if (addSus2) { 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); 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); 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); 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); 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); 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); 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); 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); DeviceHandlerIF::GET_READ);
} }
if (addSus3) { 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); 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); 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); 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); 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); 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); 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); 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); DeviceHandlerIF::GET_READ);
} }
if (addSus4) { 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); 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); 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); 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); 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); 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); 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); 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); DeviceHandlerIF::GET_READ);
} }
if (addSus5) { 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); 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); 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); 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); 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); 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); 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); 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); DeviceHandlerIF::GET_READ);
} }
if (addSus6) { 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); 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); 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); 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); 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); 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); 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); 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); DeviceHandlerIF::GET_READ);
} }
if (addSus7) { 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); 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); 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); 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); 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); 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); 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); 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); DeviceHandlerIF::GET_READ);
} }
if (addSus8) { 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); 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); 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); 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); 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); 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); 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); 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); DeviceHandlerIF::GET_READ);
} }
if (addSus9) { 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); 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); 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); 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); DeviceHandlerIF::SEND_READ);
thisSequence->addSlot(commonObjects::SUS_9_R_LOC_XBYBZB_PT_YF, length * 0, DeviceHandlerIF::GET_READ); thisSequence->addSlot(objects::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.4,
DeviceHandlerIF::SEND_WRITE); 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); 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); 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); DeviceHandlerIF::GET_READ);
} }
if (addSus10) { 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); 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); 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); 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); 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); 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); 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); 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); 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); DeviceHandlerIF::GET_READ);
} }
if (addSus11) { 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); 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); 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); 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); 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); 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); 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); 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); 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); DeviceHandlerIF::GET_READ);
} }
#endif /* OBSW_ADD_SUN_SENSORS == 1 */ #endif /* OBSW_ADD_SUN_SENSORS == 1 */
#if OBSW_ADD_RAD_SENSORS == 1 #if OBSW_ADD_RAD_SENSORS == 1
/* Radiation sensor */ /* Radiation sensor */
thisSequence->addSlot(commonObjects::RAD_SENSOR, length * 0, DeviceHandlerIF::PERFORM_OPERATION); thisSequence->addSlot(objects::RAD_SENSOR, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
thisSequence->addSlot(commonObjects::RAD_SENSOR, length * 0.2, DeviceHandlerIF::SEND_WRITE); thisSequence->addSlot(objects::RAD_SENSOR, length * 0.2, DeviceHandlerIF::SEND_WRITE);
thisSequence->addSlot(commonObjects::RAD_SENSOR, length * 0.4, DeviceHandlerIF::GET_WRITE); thisSequence->addSlot(objects::RAD_SENSOR, length * 0.4, DeviceHandlerIF::GET_WRITE);
thisSequence->addSlot(commonObjects::RAD_SENSOR, length * 0.6, DeviceHandlerIF::SEND_READ); thisSequence->addSlot(objects::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.8, DeviceHandlerIF::GET_READ);
#endif #endif
#if OBSW_ADD_ACS_BOARD == 1 && OBSW_ADD_ACS_HANDLERS == 1 #if OBSW_ADD_ACS_BOARD == 1 && OBSW_ADD_ACS_HANDLERS == 1
@ -375,66 +375,66 @@ ReturnValue_t pst::pstSpi(FixedTimeslotTaskIF *thisSequence) {
bool enableBside = true; bool enableBside = true;
if (enableAside) { if (enableAside) {
// A side // A side
thisSequence->addSlot(commonObjects::MGM_0_LIS3_HANDLER, length * 0, thisSequence->addSlot(objects::MGM_0_LIS3_HANDLER, length * 0,
DeviceHandlerIF::PERFORM_OPERATION); DeviceHandlerIF::PERFORM_OPERATION);
thisSequence->addSlot(commonObjects::MGM_0_LIS3_HANDLER, length * 0.25, DeviceHandlerIF::SEND_WRITE); thisSequence->addSlot(objects::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(objects::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(objects::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.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); 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); DeviceHandlerIF::SEND_WRITE);
thisSequence->addSlot(commonObjects::MGM_1_RM3100_HANDLER, length * 0.6, DeviceHandlerIF::GET_WRITE); thisSequence->addSlot(objects::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(objects::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.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); DeviceHandlerIF::PERFORM_OPERATION);
thisSequence->addSlot(commonObjects::GYRO_0_ADIS_HANDLER, length * 0.25, DeviceHandlerIF::SEND_WRITE); thisSequence->addSlot(objects::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(objects::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(objects::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.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); DeviceHandlerIF::PERFORM_OPERATION);
thisSequence->addSlot(commonObjects::GYRO_1_L3G_HANDLER, length * 0.25, DeviceHandlerIF::SEND_WRITE); thisSequence->addSlot(objects::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(objects::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(objects::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.85, DeviceHandlerIF::GET_READ);
} }
if (enableBside) { if (enableBside) {
// B side // B side
thisSequence->addSlot(commonObjects::MGM_2_LIS3_HANDLER, length * 0, thisSequence->addSlot(objects::MGM_2_LIS3_HANDLER, length * 0,
DeviceHandlerIF::PERFORM_OPERATION); DeviceHandlerIF::PERFORM_OPERATION);
thisSequence->addSlot(commonObjects::MGM_2_LIS3_HANDLER, length * 0.25, DeviceHandlerIF::SEND_WRITE); thisSequence->addSlot(objects::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(objects::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(objects::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.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); 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); DeviceHandlerIF::SEND_WRITE);
thisSequence->addSlot(commonObjects::MGM_3_RM3100_HANDLER, length * 0.6, DeviceHandlerIF::GET_WRITE); thisSequence->addSlot(objects::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(objects::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.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); DeviceHandlerIF::PERFORM_OPERATION);
thisSequence->addSlot(commonObjects::GYRO_2_ADIS_HANDLER, length * 0.25, DeviceHandlerIF::SEND_WRITE); thisSequence->addSlot(objects::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(objects::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(objects::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.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); DeviceHandlerIF::PERFORM_OPERATION);
thisSequence->addSlot(commonObjects::GYRO_3_L3G_HANDLER, length * 0.25, DeviceHandlerIF::SEND_WRITE); thisSequence->addSlot(objects::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(objects::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(objects::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.85, DeviceHandlerIF::GET_READ);
} }
#endif /* OBSW_ADD_ACS_BOARD == 1 && OBSW_ADD_ACS_HANDLERS == 1 */ #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(); uint32_t length = thisSequence->getPeriodMs();
static_cast<void>(length); static_cast<void>(length);
#if OBSW_ADD_MGT == 1 #if OBSW_ADD_MGT == 1
thisSequence->addSlot(commonObjects::IMTQ_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION); thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
thisSequence->addSlot(commonObjects::IMTQ_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE); thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE);
thisSequence->addSlot(commonObjects::IMTQ_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE); thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE);
thisSequence->addSlot(commonObjects::IMTQ_HANDLER, length * 0.6, DeviceHandlerIF::SEND_READ); thisSequence->addSlot(objects::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.8, DeviceHandlerIF::GET_READ);
#endif #endif
#if OBSW_ADD_BPX_BATTERY_HANDLER == 1 #if OBSW_ADD_BPX_BATTERY_HANDLER == 1
thisSequence->addSlot(commonObjects::BPX_BATT_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION); thisSequence->addSlot(objects::BPX_BATT_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
thisSequence->addSlot(commonObjects::BPX_BATT_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE); thisSequence->addSlot(objects::BPX_BATT_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE);
thisSequence->addSlot(commonObjects::BPX_BATT_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE); thisSequence->addSlot(objects::BPX_BATT_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE);
thisSequence->addSlot(commonObjects::BPX_BATT_HANDLER, length * 0.6, DeviceHandlerIF::SEND_READ); thisSequence->addSlot(objects::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.8, DeviceHandlerIF::GET_READ);
#endif #endif
static_cast<void>(length); static_cast<void>(length);
return thisSequence->checkSequence(); return thisSequence->checkSequence();
@ -470,43 +470,43 @@ ReturnValue_t pst::pstUart(FixedTimeslotTaskIF *thisSequence) {
#if OBSW_ADD_PLOC_MPSOC == 1 #if OBSW_ADD_PLOC_MPSOC == 1
uartPstEmpty = false; uartPstEmpty = false;
thisSequence->addSlot(commonObjects::PLOC_MPSOC_HANDLER, length * 0, thisSequence->addSlot(objects::PLOC_MPSOC_HANDLER, length * 0,
DeviceHandlerIF::PERFORM_OPERATION); DeviceHandlerIF::PERFORM_OPERATION);
thisSequence->addSlot(commonObjects::PLOC_MPSOC_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE); thisSequence->addSlot(objects::PLOC_MPSOC_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE);
thisSequence->addSlot(commonObjects::PLOC_MPSOC_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE); thisSequence->addSlot(objects::PLOC_MPSOC_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE);
thisSequence->addSlot(commonObjects::PLOC_MPSOC_HANDLER, length * 0.6, DeviceHandlerIF::SEND_READ); thisSequence->addSlot(objects::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.8, DeviceHandlerIF::GET_READ);
#endif #endif
thisSequence->addSlot(commonObjects::PLOC_MEMORY_DUMPER, length * 0, thisSequence->addSlot(objects::PLOC_MEMORY_DUMPER, length * 0,
DeviceHandlerIF::PERFORM_OPERATION); DeviceHandlerIF::PERFORM_OPERATION);
#if OBSW_ADD_PLOC_SUPERVISOR == 1 #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); DeviceHandlerIF::PERFORM_OPERATION);
thisSequence->addSlot(commonObjects::PLOC_SUPERVISOR_HANDLER, length * 0.2, thisSequence->addSlot(objects::PLOC_SUPERVISOR_HANDLER, length * 0.2,
DeviceHandlerIF::SEND_WRITE); DeviceHandlerIF::SEND_WRITE);
thisSequence->addSlot(commonObjects::PLOC_SUPERVISOR_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE); thisSequence->addSlot(objects::PLOC_SUPERVISOR_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE);
thisSequence->addSlot(commonObjects::PLOC_SUPERVISOR_HANDLER, length * 0.6, DeviceHandlerIF::SEND_READ); thisSequence->addSlot(objects::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.8, DeviceHandlerIF::GET_READ);
#endif #endif
#if OBSW_ADD_SYRLINKS == 1 #if OBSW_ADD_SYRLINKS == 1
uartPstEmpty = false; uartPstEmpty = false;
thisSequence->addSlot(commonObjects::SYRLINKS_HK_HANDLER, length * 0, thisSequence->addSlot(objects::SYRLINKS_HK_HANDLER, length * 0,
DeviceHandlerIF::PERFORM_OPERATION); DeviceHandlerIF::PERFORM_OPERATION);
thisSequence->addSlot(commonObjects::SYRLINKS_HK_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE); thisSequence->addSlot(objects::SYRLINKS_HK_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE);
thisSequence->addSlot(commonObjects::SYRLINKS_HK_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE); thisSequence->addSlot(objects::SYRLINKS_HK_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE);
thisSequence->addSlot(commonObjects::SYRLINKS_HK_HANDLER, length * 0.6, DeviceHandlerIF::SEND_READ); thisSequence->addSlot(objects::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.8, DeviceHandlerIF::GET_READ);
#endif #endif
#if OBSW_ADD_STAR_TRACKER == 1 #if OBSW_ADD_STAR_TRACKER == 1
uartPstEmpty = false; uartPstEmpty = false;
thisSequence->addSlot(commonObjects::STAR_TRACKER, length * 0, DeviceHandlerIF::PERFORM_OPERATION); thisSequence->addSlot(objects::STAR_TRACKER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
thisSequence->addSlot(commonObjects::STAR_TRACKER, length * 0.2, DeviceHandlerIF::SEND_WRITE); thisSequence->addSlot(objects::STAR_TRACKER, length * 0.2, DeviceHandlerIF::SEND_WRITE);
thisSequence->addSlot(commonObjects::STAR_TRACKER, length * 0.4, DeviceHandlerIF::GET_WRITE); thisSequence->addSlot(objects::STAR_TRACKER, length * 0.4, DeviceHandlerIF::GET_WRITE);
thisSequence->addSlot(commonObjects::STAR_TRACKER, length * 0.6, DeviceHandlerIF::SEND_READ); thisSequence->addSlot(objects::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.8, DeviceHandlerIF::GET_READ);
#endif #endif
static_cast<void>(length); static_cast<void>(length);
if (uartPstEmpty) { if (uartPstEmpty) {
@ -522,32 +522,32 @@ ReturnValue_t pst::pstUart(FixedTimeslotTaskIF *thisSequence) {
ReturnValue_t pst::pstGompaceCan(FixedTimeslotTaskIF *thisSequence) { ReturnValue_t pst::pstGompaceCan(FixedTimeslotTaskIF *thisSequence) {
uint32_t length = thisSequence->getPeriodMs(); uint32_t length = thisSequence->getPeriodMs();
// PCDU handlers receives two messages and both must be handled // 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(objects::P60DOCK_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
thisSequence->addSlot(commonObjects::PDU1_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION); thisSequence->addSlot(objects::PDU1_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
thisSequence->addSlot(commonObjects::PDU2_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION); thisSequence->addSlot(objects::PDU2_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
thisSequence->addSlot(commonObjects::ACU_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(objects::P60DOCK_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE);
thisSequence->addSlot(commonObjects::PDU1_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE); thisSequence->addSlot(objects::PDU1_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE);
thisSequence->addSlot(commonObjects::PDU2_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE); thisSequence->addSlot(objects::PDU2_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE);
thisSequence->addSlot(commonObjects::ACU_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(objects::P60DOCK_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE);
thisSequence->addSlot(commonObjects::PDU1_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE); thisSequence->addSlot(objects::PDU1_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE);
thisSequence->addSlot(commonObjects::PDU2_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE); thisSequence->addSlot(objects::PDU2_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE);
thisSequence->addSlot(commonObjects::ACU_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(objects::P60DOCK_HANDLER, length * 0.6, DeviceHandlerIF::SEND_READ);
thisSequence->addSlot(commonObjects::PDU1_HANDLER, length * 0.6, DeviceHandlerIF::SEND_READ); thisSequence->addSlot(objects::PDU1_HANDLER, length * 0.6, DeviceHandlerIF::SEND_READ);
thisSequence->addSlot(commonObjects::PDU2_HANDLER, length * 0.6, DeviceHandlerIF::SEND_READ); thisSequence->addSlot(objects::PDU2_HANDLER, length * 0.6, DeviceHandlerIF::SEND_READ);
thisSequence->addSlot(commonObjects::ACU_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(objects::P60DOCK_HANDLER, length * 0.8, DeviceHandlerIF::GET_READ);
thisSequence->addSlot(commonObjects::PDU1_HANDLER, length * 0.8, DeviceHandlerIF::GET_READ); thisSequence->addSlot(objects::PDU1_HANDLER, length * 0.8, DeviceHandlerIF::GET_READ);
thisSequence->addSlot(commonObjects::PDU2_HANDLER, length * 0.8, DeviceHandlerIF::GET_READ); thisSequence->addSlot(objects::PDU2_HANDLER, length * 0.8, DeviceHandlerIF::GET_READ);
thisSequence->addSlot(commonObjects::ACU_HANDLER, length * 0.8, DeviceHandlerIF::GET_READ); thisSequence->addSlot(objects::ACU_HANDLER, length * 0.8, DeviceHandlerIF::GET_READ);
if (thisSequence->checkSequence() != HasReturnvaluesIF::RETURN_OK) { if (thisSequence->checkSequence() != HasReturnvaluesIF::RETURN_OK) {
sif::error << "GomSpace PST initialization failed" << std::endl; sif::error << "GomSpace PST initialization failed" << std::endl;
return HasReturnvaluesIF::RETURN_FAILED; return HasReturnvaluesIF::RETURN_FAILED;
@ -563,23 +563,23 @@ ReturnValue_t pst::pstTest(FixedTimeslotTaskIF *thisSequence) {
#if RPI_TEST_ADIS16507 == 1 #if RPI_TEST_ADIS16507 == 1
notEmpty = true; notEmpty = true;
thisSequence->addSlot(commonObjects::GYRO_0_ADIS_HANDLER, length * 0, thisSequence->addSlot(objects::GYRO_0_ADIS_HANDLER, length * 0,
DeviceHandlerIF::PERFORM_OPERATION); DeviceHandlerIF::PERFORM_OPERATION);
thisSequence->addSlot(commonObjects::GYRO_0_ADIS_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE); thisSequence->addSlot(objects::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(objects::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(objects::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.8, DeviceHandlerIF::GET_READ);
#endif #endif
#if RPI_TEST_GPS_HANDLER == 1 #if RPI_TEST_GPS_HANDLER == 1
notEmpty = true; 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(objects::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::GET_READ);
thisSequence->addSlot(commonObjects::GPS0_HANDLER, length * 0.5, DeviceHandlerIF::SEND_READ); thisSequence->addSlot(objects::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::GET_READ);
#endif #endif
static_cast<void>(length); static_cast<void>(length);
if (not notEmpty) { if (not notEmpty) {

10
mission/controller/AcsController.h
View File

@ -33,11 +33,11 @@ class AcsController : public ExtendedControllerBase {
// MGMs // MGMs
acsctrl::MgmData mgmData; acsctrl::MgmData mgmData;
MGMLIS3MDL::MgmPrimaryDataset mgm0Lis3Set = MGMLIS3MDL::MgmPrimaryDataset(commonObjects::MGM_0_LIS3_HANDLER); MGMLIS3MDL::MgmPrimaryDataset mgm0Lis3Set = MGMLIS3MDL::MgmPrimaryDataset(objects::MGM_0_LIS3_HANDLER);
RM3100::Rm3100PrimaryDataset mgm1Rm3100Set = RM3100::Rm3100PrimaryDataset(commonObjects::MGM_1_RM3100_HANDLER); RM3100::Rm3100PrimaryDataset mgm1Rm3100Set = RM3100::Rm3100PrimaryDataset(objects::MGM_1_RM3100_HANDLER);
MGMLIS3MDL::MgmPrimaryDataset mgm2Lis3Set = MGMLIS3MDL::MgmPrimaryDataset(commonObjects::MGM_2_LIS3_HANDLER); MGMLIS3MDL::MgmPrimaryDataset mgm2Lis3Set = MGMLIS3MDL::MgmPrimaryDataset(objects::MGM_2_LIS3_HANDLER);
RM3100::Rm3100PrimaryDataset mgm3Rm3100Set = RM3100::Rm3100PrimaryDataset(commonObjects::MGM_3_RM3100_HANDLER); RM3100::Rm3100PrimaryDataset mgm3Rm3100Set = RM3100::Rm3100PrimaryDataset(objects::MGM_3_RM3100_HANDLER);
IMTQ::CalibratedMtmMeasurementSet imtqMgmSet = IMTQ::CalibratedMtmMeasurementSet(commonObjects::IMTQ_HANDLER); IMTQ::CalibratedMtmMeasurementSet imtqMgmSet = IMTQ::CalibratedMtmMeasurementSet(objects::IMTQ_HANDLER);
PoolEntry<float> mgm0PoolVec = PoolEntry<float>(3); PoolEntry<float> mgm0PoolVec = PoolEntry<float>(3);
PoolEntry<float> mgm1PoolVec = PoolEntry<float>(3); PoolEntry<float> mgm1PoolVec = PoolEntry<float>(3);

110
mission/controller/ThermalController.cpp
View File

@ -19,39 +19,39 @@ ThermalController::ThermalController(object_id_t objectId, object_id_t parentId)
sensorTemperatures(this), sensorTemperatures(this),
susTemperatures(this), susTemperatures(this),
deviceTemperatures(this), deviceTemperatures(this),
max31865Set0(commonObjects::RTD_0_IC3_PLOC_HEATSPREADER, max31865Set0(objects::RTD_0_IC3_PLOC_HEATSPREADER,
EiveMax31855::RtdCommands::EXCHANGE_SET_ID), EiveMax31855::RtdCommands::EXCHANGE_SET_ID),
max31865Set1(commonObjects::RTD_1_IC4_PLOC_MISSIONBOARD, max31865Set1(objects::RTD_1_IC4_PLOC_MISSIONBOARD,
EiveMax31855::RtdCommands::EXCHANGE_SET_ID), EiveMax31855::RtdCommands::EXCHANGE_SET_ID),
max31865Set2(commonObjects::RTD_2_IC5_4K_CAMERA, EiveMax31855::RtdCommands::EXCHANGE_SET_ID), max31865Set2(objects::RTD_2_IC5_4K_CAMERA, EiveMax31855::RtdCommands::EXCHANGE_SET_ID),
max31865Set3(commonObjects::RTD_3_IC6_DAC_HEATSPREADER, EiveMax31855::RtdCommands::EXCHANGE_SET_ID), max31865Set3(objects::RTD_3_IC6_DAC_HEATSPREADER, EiveMax31855::RtdCommands::EXCHANGE_SET_ID),
max31865Set4(commonObjects::RTD_4_IC7_STARTRACKER, EiveMax31855::RtdCommands::EXCHANGE_SET_ID), max31865Set4(objects::RTD_4_IC7_STARTRACKER, EiveMax31855::RtdCommands::EXCHANGE_SET_ID),
max31865Set5(commonObjects::RTD_5_IC8_RW1_MX_MY, EiveMax31855::RtdCommands::EXCHANGE_SET_ID), max31865Set5(objects::RTD_5_IC8_RW1_MX_MY, EiveMax31855::RtdCommands::EXCHANGE_SET_ID),
max31865Set6(commonObjects::RTD_6_IC9_DRO, EiveMax31855::RtdCommands::EXCHANGE_SET_ID), max31865Set6(objects::RTD_6_IC9_DRO, EiveMax31855::RtdCommands::EXCHANGE_SET_ID),
max31865Set7(commonObjects::RTD_7_IC10_SCEX, EiveMax31855::RtdCommands::EXCHANGE_SET_ID), max31865Set7(objects::RTD_7_IC10_SCEX, EiveMax31855::RtdCommands::EXCHANGE_SET_ID),
max31865Set8(commonObjects::RTD_8_IC11_X8, EiveMax31855::RtdCommands::EXCHANGE_SET_ID), max31865Set8(objects::RTD_8_IC11_X8, EiveMax31855::RtdCommands::EXCHANGE_SET_ID),
max31865Set9(commonObjects::RTD_9_IC12_HPA, EiveMax31855::RtdCommands::EXCHANGE_SET_ID), max31865Set9(objects::RTD_9_IC12_HPA, EiveMax31855::RtdCommands::EXCHANGE_SET_ID),
max31865Set10(commonObjects::RTD_10_IC13_PL_TX, EiveMax31855::RtdCommands::EXCHANGE_SET_ID), max31865Set10(objects::RTD_10_IC13_PL_TX, EiveMax31855::RtdCommands::EXCHANGE_SET_ID),
max31865Set11(commonObjects::RTD_11_IC14_MPA, EiveMax31855::RtdCommands::EXCHANGE_SET_ID), max31865Set11(objects::RTD_11_IC14_MPA, EiveMax31855::RtdCommands::EXCHANGE_SET_ID),
max31865Set12(commonObjects::RTD_12_IC15_ACU, EiveMax31855::RtdCommands::EXCHANGE_SET_ID), max31865Set12(objects::RTD_12_IC15_ACU, EiveMax31855::RtdCommands::EXCHANGE_SET_ID),
max31865Set13(commonObjects::RTD_13_IC16_PLPCDU_HEATSPREADER, max31865Set13(objects::RTD_13_IC16_PLPCDU_HEATSPREADER,
EiveMax31855::RtdCommands::EXCHANGE_SET_ID), EiveMax31855::RtdCommands::EXCHANGE_SET_ID),
max31865Set14(commonObjects::RTD_14_IC17_TCS_BOARD, EiveMax31855::RtdCommands::EXCHANGE_SET_ID), max31865Set14(objects::RTD_14_IC17_TCS_BOARD, EiveMax31855::RtdCommands::EXCHANGE_SET_ID),
max31865Set15(commonObjects::RTD_15_IC18_IMTQ, EiveMax31855::RtdCommands::EXCHANGE_SET_ID), max31865Set15(objects::RTD_15_IC18_IMTQ, EiveMax31855::RtdCommands::EXCHANGE_SET_ID),
tmp1075Set1(commonObjects::TMP1075_HANDLER_1), tmp1075Set1(objects::TMP1075_HANDLER_1),
tmp1075Set2(commonObjects::TMP1075_HANDLER_2), tmp1075Set2(objects::TMP1075_HANDLER_2),
susSet0(commonObjects::SUS_0_N_LOC_XFYFZM_PT_XF), susSet0(objects::SUS_0_N_LOC_XFYFZM_PT_XF),
susSet1(commonObjects::SUS_1_N_LOC_XBYFZM_PT_XB), susSet1(objects::SUS_1_N_LOC_XBYFZM_PT_XB),
susSet2(commonObjects::SUS_2_N_LOC_XFYBZB_PT_YB), susSet2(objects::SUS_2_N_LOC_XFYBZB_PT_YB),
susSet3(commonObjects::SUS_3_N_LOC_XFYBZF_PT_YF), susSet3(objects::SUS_3_N_LOC_XFYBZF_PT_YF),
susSet4(commonObjects::SUS_4_N_LOC_XMYFZF_PT_ZF), susSet4(objects::SUS_4_N_LOC_XMYFZF_PT_ZF),
susSet5(commonObjects::SUS_5_N_LOC_XFYMZB_PT_ZB), susSet5(objects::SUS_5_N_LOC_XFYMZB_PT_ZB),
susSet6(commonObjects::SUS_6_R_LOC_XFYBZM_PT_XF), susSet6(objects::SUS_6_R_LOC_XFYBZM_PT_XF),
susSet7(commonObjects::SUS_7_R_LOC_XBYBZM_PT_XB), susSet7(objects::SUS_7_R_LOC_XBYBZM_PT_XB),
susSet8(commonObjects::SUS_8_R_LOC_XBYBZB_PT_YB), susSet8(objects::SUS_8_R_LOC_XBYBZB_PT_YB),
susSet9(commonObjects::SUS_9_R_LOC_XBYBZB_PT_YF), susSet9(objects::SUS_9_R_LOC_XBYBZB_PT_YF),
susSet10(commonObjects::SUS_10_N_LOC_XMYBZF_PT_ZF), susSet10(objects::SUS_10_N_LOC_XMYBZF_PT_ZF),
susSet11(commonObjects::SUS_11_R_LOC_XBYMZB_PT_ZB) {} susSet11(objects::SUS_11_R_LOC_XBYMZB_PT_ZB) {}
ReturnValue_t ThermalController::initialize() { ReturnValue_t ThermalController::initialize() {
auto result = ExtendedControllerBase::initialize(); auto result = ExtendedControllerBase::initialize();
@ -505,7 +505,7 @@ void ThermalController::copySus() {
} }
void ThermalController::copyDevices() { void ThermalController::copyDevices() {
lp_var_t<float> tempQ7s = lp_var_t<float>(commonObjects::CORE_CONTROLLER, core::PoolIds::TEMPERATURE); lp_var_t<float> tempQ7s = lp_var_t<float>(objects::CORE_CONTROLLER, core::PoolIds::TEMPERATURE);
ReturnValue_t result = tempQ7s.read(); ReturnValue_t result = tempQ7s.read();
if (result != RETURN_OK) { if (result != RETURN_OK) {
sif::warning << "ThermalController: Failed to read Q7S temperature" << std::endl; 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; sif::warning << "ThermalController: Failed to commit" << std::endl;
} }
lp_var_t<int16_t> battTemp1 = lp_var_t<int16_t> battTemp1 =
lp_var_t<int16_t>(commonObjects::BPX_BATT_HANDLER, BpxBattery::BATT_TEMP_1); lp_var_t<int16_t>(objects::BPX_BATT_HANDLER, BpxBattery::BATT_TEMP_1);
result = battTemp1.read(); result = battTemp1.read();
if (result != RETURN_OK) { if (result != RETURN_OK) {
sif::warning << "ThermalController: Failed to read battery temperature 1" << std::endl; 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; sif::warning << "ThermalController: Failed to commit" << std::endl;
} }
lp_var_t<int16_t> battTemp2 = lp_var_t<int16_t> battTemp2 =
lp_var_t<int16_t>(commonObjects::BPX_BATT_HANDLER, BpxBattery::BATT_TEMP_2); lp_var_t<int16_t>(objects::BPX_BATT_HANDLER, BpxBattery::BATT_TEMP_2);
result = battTemp2.read(); result = battTemp2.read();
if (result != RETURN_OK) { if (result != RETURN_OK) {
sif::warning << "ThermalController: Failed to read battery temperature 2" << std::endl; 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; sif::warning << "ThermalController: Failed to commit" << std::endl;
} }
lp_var_t<int16_t> battTemp3 = lp_var_t<int16_t> battTemp3 =
lp_var_t<int16_t>(commonObjects::BPX_BATT_HANDLER, BpxBattery::BATT_TEMP_3); lp_var_t<int16_t>(objects::BPX_BATT_HANDLER, BpxBattery::BATT_TEMP_3);
result = battTemp3.read(); result = battTemp3.read();
if (result != RETURN_OK) { if (result != RETURN_OK) {
sif::warning << "ThermalController: Failed to read battery temperature 3" << std::endl; 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; sif::warning << "ThermalController: Failed to commit" << std::endl;
} }
lp_var_t<int16_t> battTemp4 = lp_var_t<int16_t> battTemp4 =
lp_var_t<int16_t>(commonObjects::BPX_BATT_HANDLER, BpxBattery::BATT_TEMP_4); lp_var_t<int16_t>(objects::BPX_BATT_HANDLER, BpxBattery::BATT_TEMP_4);
result = battTemp4.read(); result = battTemp4.read();
if (result != RETURN_OK) { if (result != RETURN_OK) {
sif::warning << "ThermalController: Failed to read battery temperature 4" << std::endl; sif::warning << "ThermalController: Failed to read battery temperature 4" << std::endl;
@ -579,7 +579,7 @@ void ThermalController::copyDevices() {
if (result != RETURN_OK) { if (result != RETURN_OK) {
sif::warning << "ThermalController: Failed to commit" << std::endl; sif::warning << "ThermalController: Failed to commit" << std::endl;
} }
lp_var_t<int32_t> tempRw1 = lp_var_t<int32_t>(commonObjects::RW1, RwDefinitions::TEMPERATURE_C); lp_var_t<int32_t> tempRw1 = lp_var_t<int32_t>(objects::RW1, RwDefinitions::TEMPERATURE_C);
result = tempRw1.read(); result = tempRw1.read();
if (result != RETURN_OK) { if (result != RETURN_OK) {
sif::warning << "ThermalController: Failed to read reaction wheel 1 temperature" << std::endl; sif::warning << "ThermalController: Failed to read reaction wheel 1 temperature" << std::endl;
@ -593,7 +593,7 @@ void ThermalController::copyDevices() {
if (result != RETURN_OK) { if (result != RETURN_OK) {
sif::warning << "ThermalController: Failed to commit" << std::endl; sif::warning << "ThermalController: Failed to commit" << std::endl;
} }
lp_var_t<int32_t> tempRw2 = lp_var_t<int32_t>(commonObjects::RW2, RwDefinitions::TEMPERATURE_C); lp_var_t<int32_t> tempRw2 = lp_var_t<int32_t>(objects::RW2, RwDefinitions::TEMPERATURE_C);
result = tempRw2.read(); result = tempRw2.read();
if (result != RETURN_OK) { if (result != RETURN_OK) {
sif::warning << "ThermalController: Failed to read reaction wheel 2 temperature" << std::endl; sif::warning << "ThermalController: Failed to read reaction wheel 2 temperature" << std::endl;
@ -607,7 +607,7 @@ void ThermalController::copyDevices() {
if (result != RETURN_OK) { if (result != RETURN_OK) {
sif::warning << "ThermalController: Failed to commit" << std::endl; sif::warning << "ThermalController: Failed to commit" << std::endl;
} }
lp_var_t<int32_t> tempRw3 = lp_var_t<int32_t>(commonObjects::RW3, RwDefinitions::TEMPERATURE_C); lp_var_t<int32_t> tempRw3 = lp_var_t<int32_t>(objects::RW3, RwDefinitions::TEMPERATURE_C);
result = tempRw3.read(); result = tempRw3.read();
if (result != RETURN_OK) { if (result != RETURN_OK) {
sif::warning << "ThermalController: Failed to read reaction wheel 3 temperature" << std::endl; sif::warning << "ThermalController: Failed to read reaction wheel 3 temperature" << std::endl;
@ -621,7 +621,7 @@ void ThermalController::copyDevices() {
if (result != RETURN_OK) { if (result != RETURN_OK) {
sif::warning << "ThermalController: Failed to commit" << std::endl; sif::warning << "ThermalController: Failed to commit" << std::endl;
} }
lp_var_t<int32_t> tempRw4 = lp_var_t<int32_t>(commonObjects::RW4, RwDefinitions::TEMPERATURE_C); lp_var_t<int32_t> tempRw4 = lp_var_t<int32_t>(objects::RW4, RwDefinitions::TEMPERATURE_C);
result = tempRw4.read(); result = tempRw4.read();
if (result != RETURN_OK) { if (result != RETURN_OK) {
sif::warning << "ThermalController: Failed to read reaction wheel 4 temperature" << std::endl; 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; sif::warning << "ThermalController: Failed to commit" << std::endl;
} }
lp_var_t<float> tempStartracker = lp_var_t<float> tempStartracker =
lp_var_t<float>(commonObjects::STAR_TRACKER, startracker::MCU_TEMPERATURE); lp_var_t<float>(objects::STAR_TRACKER, startracker::MCU_TEMPERATURE);
result = tempStartracker.read(); result = tempStartracker.read();
if (result != RETURN_OK) { if (result != RETURN_OK) {
sif::warning << "ThermalController: Failed to read startracker temperature" << std::endl; 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; sif::warning << "ThermalController: Failed to commit" << std::endl;
} }
lp_var_t<float> tempSyrlinksPowerAmplifier = lp_var_t<float> tempSyrlinksPowerAmplifier =
lp_var_t<float>(commonObjects::SYRLINKS_HK_HANDLER, syrlinks::TEMP_POWER_AMPLIFIER); lp_var_t<float>(objects::SYRLINKS_HK_HANDLER, syrlinks::TEMP_POWER_AMPLIFIER);
result = tempSyrlinksPowerAmplifier.read(); result = tempSyrlinksPowerAmplifier.read();
if (result != RETURN_OK) { if (result != RETURN_OK) {
sif::warning << "ThermalController: Failed to read syrlinks power amplifier temperature" 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; sif::warning << "ThermalController: Failed to commit" << std::endl;
} }
lp_var_t<float> tempSyrlinksBasebandBoard = lp_var_t<float> tempSyrlinksBasebandBoard =
lp_var_t<float>(commonObjects::SYRLINKS_HK_HANDLER, syrlinks::TEMP_BASEBAND_BOARD); lp_var_t<float>(objects::SYRLINKS_HK_HANDLER, syrlinks::TEMP_BASEBAND_BOARD);
result = tempSyrlinksBasebandBoard.read(); result = tempSyrlinksBasebandBoard.read();
if (result != RETURN_OK) { if (result != RETURN_OK) {
sif::warning << "ThermalController: Failed to read syrlinks baseband board temperature" sif::warning << "ThermalController: Failed to read syrlinks baseband board temperature"
@ -682,7 +682,7 @@ void ThermalController::copyDevices() {
if (result != RETURN_OK) { if (result != RETURN_OK) {
sif::warning << "ThermalController: Failed to commit" << std::endl; sif::warning << "ThermalController: Failed to commit" << std::endl;
} }
lp_var_t<int16_t> tempMgt = lp_var_t<int16_t>(commonObjects::IMTQ_HANDLER, IMTQ::MCU_TEMPERATURE); lp_var_t<int16_t> tempMgt = lp_var_t<int16_t>(objects::IMTQ_HANDLER, IMTQ::MCU_TEMPERATURE);
result = tempMgt.read(); result = tempMgt.read();
if (result != RETURN_OK) { if (result != RETURN_OK) {
sif::warning << "ThermalController: Failed to read MGT temperature" << std::endl; 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; sif::warning << "ThermalController: Failed to commit" << std::endl;
} }
lp_vec_t<float, 3> tempAcu = lp_vec_t<float, 3> tempAcu =
lp_vec_t<float, 3>(commonObjects::ACU_HANDLER, P60System::pool::ACU_TEMPERATURES); lp_vec_t<float, 3>(objects::ACU_HANDLER, P60System::pool::ACU_TEMPERATURES);
result = tempAcu.read(); result = tempAcu.read();
if (result != RETURN_OK) { if (result != RETURN_OK) {
sif::warning << "ThermalController: Failed to read ACU temperatures" << std::endl; 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; sif::warning << "ThermalController: Failed to commit" << std::endl;
} }
lp_var_t<float> tempPdu1 = lp_var_t<float> tempPdu1 =
lp_var_t<float>(commonObjects::PDU1_HANDLER, P60System::pool::PDU_TEMPERATURE); lp_var_t<float>(objects::PDU1_HANDLER, P60System::pool::PDU_TEMPERATURE);
result = tempPdu1.read(); result = tempPdu1.read();
if (result != RETURN_OK) { if (result != RETURN_OK) {
sif::warning << "ThermalController: Failed to read PDU1 temperature" << std::endl; 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; sif::warning << "ThermalController: Failed to commit" << std::endl;
} }
lp_var_t<float> tempPdu2 = lp_var_t<float> tempPdu2 =
lp_var_t<float>(commonObjects::PDU2_HANDLER, P60System::pool::PDU_TEMPERATURE); lp_var_t<float>(objects::PDU2_HANDLER, P60System::pool::PDU_TEMPERATURE);
result = tempPdu2.read(); result = tempPdu2.read();
if (result != RETURN_OK) { if (result != RETURN_OK) {
sif::warning << "ThermalController: Failed to read PDU2 temperature" << std::endl; 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; sif::warning << "ThermalController: Failed to commit" << std::endl;
} }
lp_var_t<float> temp1P60dock = lp_var_t<float> temp1P60dock =
lp_var_t<float>(commonObjects::P60DOCK_HANDLER, P60System::pool::P60DOCK_TEMPERATURE_1); lp_var_t<float>(objects::P60DOCK_HANDLER, P60System::pool::P60DOCK_TEMPERATURE_1);
result = temp1P60dock.read(); result = temp1P60dock.read();
if (result != RETURN_OK) { if (result != RETURN_OK) {
sif::warning << "ThermalController: Failed to read P60 dock temperature 1" << std::endl; 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; sif::warning << "ThermalController: Failed to commit" << std::endl;
} }
lp_var_t<float> temp2P60dock = lp_var_t<float> temp2P60dock =
lp_var_t<float>(commonObjects::P60DOCK_HANDLER, P60System::pool::P60DOCK_TEMPERATURE_2); lp_var_t<float>(objects::P60DOCK_HANDLER, P60System::pool::P60DOCK_TEMPERATURE_2);
result = temp2P60dock.read(); result = temp2P60dock.read();
if (result != RETURN_OK) { if (result != RETURN_OK) {
sif::warning << "ThermalController: Failed to read P60 dock temperature 2" << std::endl; sif::warning << "ThermalController: Failed to read P60 dock temperature 2" << std::endl;
@ -773,7 +773,7 @@ void ThermalController::copyDevices() {
if (result != RETURN_OK) { if (result != RETURN_OK) {
sif::warning << "ThermalController: Failed to commit" << std::endl; sif::warning << "ThermalController: Failed to commit" << std::endl;
} }
lp_var_t<float> tempGyro0 = lp_var_t<float>(commonObjects::GYRO_0_ADIS_HANDLER, ADIS1650X::TEMPERATURE); lp_var_t<float> tempGyro0 = lp_var_t<float>(objects::GYRO_0_ADIS_HANDLER, ADIS1650X::TEMPERATURE);
result = tempGyro0.read(); result = tempGyro0.read();
if (result != RETURN_OK) { if (result != RETURN_OK) {
sif::warning << "ThermalController: Failed to read gyro 0 temperature" << std::endl; sif::warning << "ThermalController: Failed to read gyro 0 temperature" << std::endl;
@ -787,7 +787,7 @@ void ThermalController::copyDevices() {
if (result != RETURN_OK) { if (result != RETURN_OK) {
sif::warning << "ThermalController: Failed to commit" << std::endl; sif::warning << "ThermalController: Failed to commit" << std::endl;
} }
lp_var_t<float> tempGyro1 = lp_var_t<float>(commonObjects::GYRO_1_L3G_HANDLER, L3GD20H::TEMPERATURE); lp_var_t<float> tempGyro1 = lp_var_t<float>(objects::GYRO_1_L3G_HANDLER, L3GD20H::TEMPERATURE);
result = tempGyro1.read(); result = tempGyro1.read();
if (result != RETURN_OK) { if (result != RETURN_OK) {
sif::warning << "ThermalController: Failed to read gyro 1 temperature" << std::endl; sif::warning << "ThermalController: Failed to read gyro 1 temperature" << std::endl;
@ -801,7 +801,7 @@ void ThermalController::copyDevices() {
if (result != RETURN_OK) { if (result != RETURN_OK) {
sif::warning << "ThermalController: Failed to commit" << std::endl; sif::warning << "ThermalController: Failed to commit" << std::endl;
} }
lp_var_t<float> tempGyro2 = lp_var_t<float>(commonObjects::GYRO_2_ADIS_HANDLER, ADIS1650X::TEMPERATURE); lp_var_t<float> tempGyro2 = lp_var_t<float>(objects::GYRO_2_ADIS_HANDLER, ADIS1650X::TEMPERATURE);
result = tempGyro2.read(); result = tempGyro2.read();
if (result != RETURN_OK) { if (result != RETURN_OK) {
sif::warning << "ThermalController: Failed to read gyro 2 temperature" << std::endl; sif::warning << "ThermalController: Failed to read gyro 2 temperature" << std::endl;
@ -815,7 +815,7 @@ void ThermalController::copyDevices() {
if (result != RETURN_OK) { if (result != RETURN_OK) {
sif::warning << "ThermalController: Failed to commit" << std::endl; sif::warning << "ThermalController: Failed to commit" << std::endl;
} }
lp_var_t<float> tempGyro3 = lp_var_t<float>(commonObjects::GYRO_3_L3G_HANDLER, L3GD20H::TEMPERATURE); lp_var_t<float> tempGyro3 = lp_var_t<float>(objects::GYRO_3_L3G_HANDLER, L3GD20H::TEMPERATURE);
result = tempGyro3.read(); result = tempGyro3.read();
if (result != RETURN_OK) { if (result != RETURN_OK) {
sif::warning << "ThermalController: Failed to read gyro 3 temperature" << std::endl; 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; sif::warning << "ThermalController: Failed to commit" << std::endl;
} }
lp_var_t<float> tempMgm0 = lp_var_t<float> tempMgm0 =
lp_var_t<float>(commonObjects::MGM_0_LIS3_HANDLER, MGMLIS3MDL::TEMPERATURE_CELCIUS); lp_var_t<float>(objects::MGM_0_LIS3_HANDLER, MGMLIS3MDL::TEMPERATURE_CELCIUS);
result = tempMgm0.read(); result = tempMgm0.read();
if (result != RETURN_OK) { if (result != RETURN_OK) {
sif::warning << "ThermalController: Failed to read MGM 0 temperature" << std::endl; 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; sif::warning << "ThermalController: Failed to commit" << std::endl;
} }
lp_var_t<float> tempMgm2 = lp_var_t<float> tempMgm2 =
lp_var_t<float>(commonObjects::MGM_2_LIS3_HANDLER, MGMLIS3MDL::TEMPERATURE_CELCIUS); lp_var_t<float>(objects::MGM_2_LIS3_HANDLER, MGMLIS3MDL::TEMPERATURE_CELCIUS);
result = tempMgm2.read(); result = tempMgm2.read();
if (result != RETURN_OK) { if (result != RETURN_OK) {
sif::warning << "ThermalController: Failed to read MGM 2 temperature" << std::endl; sif::warning << "ThermalController: Failed to read MGM 2 temperature" << std::endl;
@ -859,7 +859,7 @@ void ThermalController::copyDevices() {
if (result != RETURN_OK) { if (result != RETURN_OK) {
sif::warning << "ThermalController: Failed to commit" << std::endl; sif::warning << "ThermalController: Failed to commit" << std::endl;
} }
lp_var_t<float> tempAdcPayloadPcdu = lp_var_t<float>(commonObjects::PLPCDU_HANDLER, plpcdu::TEMP); lp_var_t<float> tempAdcPayloadPcdu = lp_var_t<float>(objects::PLPCDU_HANDLER, plpcdu::TEMP);
result = tempAdcPayloadPcdu.read(); result = tempAdcPayloadPcdu.read();
if (result != RETURN_OK) { if (result != RETURN_OK) {
sif::warning << "ThermalController: Failed to read payload PCDU ADC temperature" << std::endl; sif::warning << "ThermalController: Failed to read payload PCDU ADC temperature" << std::endl;

18
mission/core/GenericFactory.cpp
View File

@ -74,20 +74,20 @@ void ObjectFactory::produceGenericObjects(HealthTableIF** healthTable_) {
new PoolManager(objects::IPC_STORE, poolCfg); new PoolManager(objects::IPC_STORE, poolCfg);
} }
auto* ccsdsDistrib = new CCSDSDistributor(apid::EIVE_OBSW, commonObjects::CCSDS_PACKET_DISTRIBUTOR); auto* ccsdsDistrib = new CCSDSDistributor(apid::EIVE_OBSW, objects::CCSDS_PACKET_DISTRIBUTOR);
new PUSDistributor(apid::EIVE_OBSW, commonObjects::PUS_PACKET_DISTRIBUTOR, new PUSDistributor(apid::EIVE_OBSW, objects::PUS_PACKET_DISTRIBUTOR,
commonObjects::CCSDS_PACKET_DISTRIBUTOR); objects::CCSDS_PACKET_DISTRIBUTOR);
uint8_t vc = 0; uint8_t vc = 0;
#if OBSW_TM_TO_PTME == 1 #if OBSW_TM_TO_PTME == 1
vc = config::LIVE_TM; vc = config::LIVE_TM;
#endif #endif
// Every TM packet goes through this funnel // Every TM packet goes through this funnel
new TmFunnel(systemObjects::TM_FUNNEL, 50, vc); new TmFunnel(objects::TM_FUNNEL, 50, vc);
// PUS service stack // PUS service stack
new Service1TelecommandVerification(objects::PUS_SERVICE_1_VERIFICATION, apid::EIVE_OBSW, 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, new Service2DeviceAccess(objects::PUS_SERVICE_2_DEVICE_ACCESS, apid::EIVE_OBSW,
pus::PUS_SERVICE_2, 3, 10); pus::PUS_SERVICE_2, 3, 10);
new Service3Housekeeping(objects::PUS_SERVICE_3_HOUSEKEEPING, apid::EIVE_OBSW, new Service3Housekeeping(objects::PUS_SERVICE_3_HOUSEKEEPING, apid::EIVE_OBSW,
@ -109,13 +109,13 @@ void ObjectFactory::produceGenericObjects(HealthTableIF** healthTable_) {
pus::PUS_SERVICE_201); pus::PUS_SERVICE_201);
#if OBSW_ADD_TCPIP_BRIDGE == 1 #if OBSW_ADD_TCPIP_BRIDGE == 1
#if OBSW_USE_TMTC_TCP_BRIDGE == 0 #if OBSW_USE_TMTC_TCP_BRIDGE == 0
auto tmtcBridge = new UdpTmTcBridge(commonObjects::TMTC_BRIDGE, commonObjects::CCSDS_PACKET_DISTRIBUTOR); auto tmtcBridge = new UdpTmTcBridge(objects::TMTC_BRIDGE, objects::CCSDS_PACKET_DISTRIBUTOR);
new UdpTcPollingTask(commonObjects::TMTC_POLLING_TASK, commonObjects::TMTC_BRIDGE); new UdpTcPollingTask(objects::TMTC_POLLING_TASK, objects::TMTC_BRIDGE);
sif::info << "Created UDP server for TMTC commanding with listener port " sif::info << "Created UDP server for TMTC commanding with listener port "
<< udpBridge->getUdpPort() << std::endl; << udpBridge->getUdpPort() << std::endl;
#else #else
auto tmtcBridge = new TcpTmTcBridge(commonObjects::TMTC_BRIDGE, commonObjects::CCSDS_PACKET_DISTRIBUTOR); auto tmtcBridge = new TcpTmTcBridge(objects::TMTC_BRIDGE, objects::CCSDS_PACKET_DISTRIBUTOR);
auto tcpServer = new TcpTmTcServer(commonObjects::TMTC_POLLING_TASK, commonObjects::TMTC_BRIDGE); 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 // TCP is stream based. Use packet ID as start marker when parsing for space packets
tcpServer->setSpacePacketParsingOptions({common::PUS_PACKET_ID}); tcpServer->setSpacePacketParsingOptions({common::PUS_PACKET_ID});
sif::info << "Created TCP server for TMTC commanding with listener port " sif::info << "Created TCP server for TMTC commanding with listener port "

2
mission/devices/GomspaceDeviceHandler.cpp
View File

@ -143,7 +143,7 @@ void GomspaceDeviceHandler::setNormalDatapoolEntriesInvalid() {}
ReturnValue_t GomspaceDeviceHandler::handleAction(ParamSetAction* action) { ReturnValue_t GomspaceDeviceHandler::handleAction(ParamSetAction* action) {
// This breaks layering but I really don't want to accept this command.. // This breaks layering but I really don't want to accept this command..
if (action->address == PDU2::CONFIG_ADDRESS_OUT_EN_Q7S and 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); triggerEvent(power::SWITCHING_Q7S_DENIED, 0, 0);
return HasReturnvaluesIF::RETURN_FAILED; return HasReturnvaluesIF::RETURN_FAILED;
} }

44
mission/devices/PCDUHandler.cpp
View File

@ -46,7 +46,7 @@ ReturnValue_t PCDUHandler::initialize() {
/* Subscribing for housekeeping table update messages of the PDU2 */ /* Subscribing for housekeeping table update messages of the PDU2 */
HasLocalDataPoolIF* pdu2Handler = HasLocalDataPoolIF* pdu2Handler =
ObjectManager::instance()->get<HasLocalDataPoolIF>(commonObjects::PDU2_HANDLER); ObjectManager::instance()->get<HasLocalDataPoolIF>(objects::PDU2_HANDLER);
if (pdu2Handler == nullptr) { if (pdu2Handler == nullptr) {
sif::error << "PCDUHandler::initialize: Invalid pdu2Handler" << std::endl; sif::error << "PCDUHandler::initialize: Invalid pdu2Handler" << std::endl;
return RETURN_FAILED; return RETURN_FAILED;
@ -62,7 +62,7 @@ ReturnValue_t PCDUHandler::initialize() {
/* Subscribing for housekeeping table update messages of the PDU1 */ /* Subscribing for housekeeping table update messages of the PDU1 */
HasLocalDataPoolIF* pdu1Handler = HasLocalDataPoolIF* pdu1Handler =
ObjectManager::instance()->get<HasLocalDataPoolIF>(commonObjects::PDU1_HANDLER); ObjectManager::instance()->get<HasLocalDataPoolIF>(objects::PDU1_HANDLER);
if (pdu1Handler == nullptr) { if (pdu1Handler == nullptr) {
sif::error << "PCDUHandler::initialize: Invalid pdu1Handler" << std::endl; sif::error << "PCDUHandler::initialize: Invalid pdu1Handler" << std::endl;
return RETURN_FAILED; return RETURN_FAILED;
@ -110,11 +110,11 @@ void PCDUHandler::readCommandQueue() {
MessageQueueId_t PCDUHandler::getCommandQueue() const { return commandQueue->getId(); } MessageQueueId_t PCDUHandler::getCommandQueue() const { return commandQueue->getId(); }
void PCDUHandler::handleChangedDataset(sid_t sid, store_address_t storeId, bool* clearMessage) { void PCDUHandler::handleChangedDataset(sid_t sid, store_address_t storeId, bool* clearMessage) {
if (sid == sid_t(commonObjects::PDU2_HANDLER, static_cast<uint32_t>(P60System::SetIds::PDU_2_CORE))) { if (sid == sid_t(objects::PDU2_HANDLER, static_cast<uint32_t>(P60System::SetIds::PDU_2_CORE))) {
updateHkTableDataset(storeId, &pdu2CoreHk, &timeStampPdu2HkDataset); updateHkTableDataset(storeId, &pdu2CoreHk, &timeStampPdu2HkDataset);
updatePdu2SwitchStates(); updatePdu2SwitchStates();
} else if (sid == } else if (sid ==
sid_t(commonObjects::PDU1_HANDLER, static_cast<uint32_t>(P60System::SetIds::PDU_1_CORE))) { sid_t(objects::PDU1_HANDLER, static_cast<uint32_t>(P60System::SetIds::PDU_1_CORE))) {
updateHkTableDataset(storeId, &pdu1CoreHk, &timeStampPdu1HkDataset); updateHkTableDataset(storeId, &pdu1CoreHk, &timeStampPdu1HkDataset);
updatePdu1SwitchStates(); updatePdu1SwitchStates();
} else { } else {
@ -232,94 +232,94 @@ ReturnValue_t PCDUHandler::sendSwitchCommand(uint8_t switchNr, ReturnValue_t onO
switch (switchNr) { switch (switchNr) {
case pcdu::PDU1_CH0_TCS_BOARD_3V3: { case pcdu::PDU1_CH0_TCS_BOARD_3V3: {
memoryAddress = PDU1::CONFIG_ADDRESS_OUT_EN_TCS_BOARD_3V3; memoryAddress = PDU1::CONFIG_ADDRESS_OUT_EN_TCS_BOARD_3V3;
pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(commonObjects::PDU1_HANDLER); pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU1_HANDLER);
break; break;
} }
case pcdu::PDU1_CH1_SYRLINKS_12V: { case pcdu::PDU1_CH1_SYRLINKS_12V: {
memoryAddress = PDU1::CONFIG_ADDRESS_OUT_EN_SYRLINKS; memoryAddress = PDU1::CONFIG_ADDRESS_OUT_EN_SYRLINKS;
pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(commonObjects::PDU1_HANDLER); pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU1_HANDLER);
break; break;
} }
case pcdu::PDU1_CH2_STAR_TRACKER_5V: { case pcdu::PDU1_CH2_STAR_TRACKER_5V: {
memoryAddress = PDU1::CONFIG_ADDRESS_OUT_EN_STAR_TRACKER; memoryAddress = PDU1::CONFIG_ADDRESS_OUT_EN_STAR_TRACKER;
pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(commonObjects::PDU1_HANDLER); pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU1_HANDLER);
break; break;
} }
case pcdu::PDU1_CH3_MGT_5V: { case pcdu::PDU1_CH3_MGT_5V: {
memoryAddress = PDU1::CONFIG_ADDRESS_OUT_EN_MGT; memoryAddress = PDU1::CONFIG_ADDRESS_OUT_EN_MGT;
pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(commonObjects::PDU1_HANDLER); pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU1_HANDLER);
break; break;
} }
case pcdu::PDU1_CH4_SUS_NOMINAL_3V3: { case pcdu::PDU1_CH4_SUS_NOMINAL_3V3: {
memoryAddress = PDU1::CONFIG_ADDRESS_OUT_EN_SUS_NOMINAL; memoryAddress = PDU1::CONFIG_ADDRESS_OUT_EN_SUS_NOMINAL;
pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(commonObjects::PDU1_HANDLER); pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU1_HANDLER);
break; break;
} }
case pcdu::PDU1_CH5_SOLAR_CELL_EXP_5V: { case pcdu::PDU1_CH5_SOLAR_CELL_EXP_5V: {
memoryAddress = PDU1::CONFIG_ADDRESS_OUT_EN_SOLAR_CELL_EXP; memoryAddress = PDU1::CONFIG_ADDRESS_OUT_EN_SOLAR_CELL_EXP;
pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(commonObjects::PDU1_HANDLER); pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU1_HANDLER);
break; break;
} }
case pcdu::PDU1_CH6_PLOC_12V: { case pcdu::PDU1_CH6_PLOC_12V: {
memoryAddress = PDU1::CONFIG_ADDRESS_OUT_EN_PLOC; memoryAddress = PDU1::CONFIG_ADDRESS_OUT_EN_PLOC;
pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(commonObjects::PDU1_HANDLER); pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU1_HANDLER);
break; break;
} }
case pcdu::PDU1_CH7_ACS_A_SIDE_3V3: { case pcdu::PDU1_CH7_ACS_A_SIDE_3V3: {
memoryAddress = PDU1::CONFIG_ADDRESS_OUT_EN_ACS_BOARD_SIDE_A; memoryAddress = PDU1::CONFIG_ADDRESS_OUT_EN_ACS_BOARD_SIDE_A;
pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(commonObjects::PDU1_HANDLER); pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU1_HANDLER);
break; break;
} }
case pcdu::PDU1_CH8_UNOCCUPIED: { case pcdu::PDU1_CH8_UNOCCUPIED: {
memoryAddress = PDU1::CONFIG_ADDRESS_OUT_EN_CHANNEL8; memoryAddress = PDU1::CONFIG_ADDRESS_OUT_EN_CHANNEL8;
pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(commonObjects::PDU1_HANDLER); pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU1_HANDLER);
break; break;
} }
// This is a dangerous command. Reject/Igore it for now // This is a dangerous command. Reject/Igore it for now
case pcdu::PDU2_CH0_Q7S: { case pcdu::PDU2_CH0_Q7S: {
return RETURN_FAILED; return RETURN_FAILED;
// memoryAddress = PDU2::CONFIG_ADDRESS_OUT_EN_Q7S; // memoryAddress = PDU2::CONFIG_ADDRESS_OUT_EN_Q7S;
// pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(commonObjects::PDU2_HANDLER); // pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU2_HANDLER);
// break; // break;
} }
case pcdu::PDU2_CH1_PL_PCDU_BATT_0_14V8: { case pcdu::PDU2_CH1_PL_PCDU_BATT_0_14V8: {
memoryAddress = PDU2::CONFIG_ADDRESS_OUT_EN_PAYLOAD_PCDU_CH1; memoryAddress = PDU2::CONFIG_ADDRESS_OUT_EN_PAYLOAD_PCDU_CH1;
pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(commonObjects::PDU2_HANDLER); pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU2_HANDLER);
break; break;
} }
case pcdu::PDU2_CH2_RW_5V: { case pcdu::PDU2_CH2_RW_5V: {
memoryAddress = PDU2::CONFIG_ADDRESS_OUT_EN_RW; memoryAddress = PDU2::CONFIG_ADDRESS_OUT_EN_RW;
pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(commonObjects::PDU2_HANDLER); pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU2_HANDLER);
break; break;
} }
case pcdu::PDU2_CH3_TCS_BOARD_HEATER_IN_8V: { case pcdu::PDU2_CH3_TCS_BOARD_HEATER_IN_8V: {
memoryAddress = PDU2::CONFIG_ADDRESS_OUT_EN_TCS_BOARD_HEATER_IN; memoryAddress = PDU2::CONFIG_ADDRESS_OUT_EN_TCS_BOARD_HEATER_IN;
pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(commonObjects::PDU2_HANDLER); pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU2_HANDLER);
break; break;
} }
case pcdu::PDU2_CH4_SUS_REDUNDANT_3V3: { case pcdu::PDU2_CH4_SUS_REDUNDANT_3V3: {
memoryAddress = PDU2::CONFIG_ADDRESS_OUT_EN_SUS_REDUNDANT; memoryAddress = PDU2::CONFIG_ADDRESS_OUT_EN_SUS_REDUNDANT;
pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(commonObjects::PDU2_HANDLER); pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU2_HANDLER);
break; break;
} }
case pcdu::PDU2_CH5_DEPLOYMENT_MECHANISM_8V: { case pcdu::PDU2_CH5_DEPLOYMENT_MECHANISM_8V: {
memoryAddress = PDU2::CONFIG_ADDRESS_OUT_EN_DEPLOYMENT_MECHANISM; memoryAddress = PDU2::CONFIG_ADDRESS_OUT_EN_DEPLOYMENT_MECHANISM;
pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(commonObjects::PDU2_HANDLER); pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU2_HANDLER);
break; break;
} }
case pcdu::PDU2_CH6_PL_PCDU_BATT_1_14V8: { case pcdu::PDU2_CH6_PL_PCDU_BATT_1_14V8: {
memoryAddress = PDU2::CONFIG_ADDRESS_OUT_EN_PAYLOAD_PCDU_CH6; memoryAddress = PDU2::CONFIG_ADDRESS_OUT_EN_PAYLOAD_PCDU_CH6;
pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(commonObjects::PDU2_HANDLER); pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU2_HANDLER);
break; break;
} }
case pcdu::PDU2_CH7_ACS_BOARD_SIDE_B_3V3: { case pcdu::PDU2_CH7_ACS_BOARD_SIDE_B_3V3: {
memoryAddress = PDU2::CONFIG_ADDRESS_OUT_EN_ACS_BOARD_SIDE_B; memoryAddress = PDU2::CONFIG_ADDRESS_OUT_EN_ACS_BOARD_SIDE_B;
pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(commonObjects::PDU2_HANDLER); pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU2_HANDLER);
break; break;
} }
case pcdu::PDU2_CH8_PAYLOAD_CAMERA: { case pcdu::PDU2_CH8_PAYLOAD_CAMERA: {
memoryAddress = PDU2::CONFIG_ADDRESS_OUT_EN_PAYLOAD_CAMERA; memoryAddress = PDU2::CONFIG_ADDRESS_OUT_EN_PAYLOAD_CAMERA;
pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(commonObjects::PDU2_HANDLER); pdu = ObjectManager::instance()->get<GomspaceDeviceHandler>(objects::PDU2_HANDLER);
break; break;
} }

2
mission/system/fdir/AcsBoardFdir.cpp
View File

@ -3,4 +3,4 @@
#include <common/config/commonObjects.h> #include <common/config/commonObjects.h>
AcsBoardFdir::AcsBoardFdir(object_id_t sensorId) AcsBoardFdir::AcsBoardFdir(object_id_t sensorId)
: DeviceHandlerFailureIsolation(sensorId, commonObjects::ACS_BOARD_ASS) {} : DeviceHandlerFailureIsolation(sensorId, objects::ACS_BOARD_ASS) {}

2
mission/system/fdir/RtdFdir.cpp
View File

@ -3,4 +3,4 @@
#include <common/config/commonObjects.h> #include <common/config/commonObjects.h>
RtdFdir::RtdFdir(object_id_t sensorId) RtdFdir::RtdFdir(object_id_t sensorId)
: DeviceHandlerFailureIsolation(sensorId, commonObjects::TCS_BOARD_ASS) {} : DeviceHandlerFailureIsolation(sensorId, objects::TCS_BOARD_ASS) {}

2
mission/system/fdir/SusFdir.cpp
View File

@ -3,4 +3,4 @@
#include <common/config/commonObjects.h> #include <common/config/commonObjects.h>
SusFdir::SusFdir(object_id_t sensorId) SusFdir::SusFdir(object_id_t sensorId)
: DeviceHandlerFailureIsolation(sensorId, commonObjects::SUS_BOARD_ASS) {} : DeviceHandlerFailureIsolation(sensorId, objects::SUS_BOARD_ASS) {}