diff --git a/CMakeLists.txt b/CMakeLists.txt index ff73e3f9..592fc176 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -29,6 +29,7 @@ if(TGT_BSP) option(LINUX_CROSS_COMPILE ON) option(EIVE_BUILD_GPSD_GPS_HANDLER "Build GPSD dependent GPS Handler" OFF) elseif(TGT_BSP MATCHES "arm/q7s") + option(EIVE_Q7S_EM "Build configuration for the EM" OFF) option(EIVE_BUILD_GPSD_GPS_HANDLER "Build GPSD dependent GPS Handler" ON) endif() option(EIVE_CREATE_UNIQUE_OBSW_BIN "Append username to generated binary name" ON) @@ -53,8 +54,26 @@ include(EiveHelpers) option(EIVE_ADD_ETL_LIB "Add ETL library" ON) option(EIVE_ADD_JSON_LIB "Add JSON library" ON) -set(OBSW_ADD_STAR_TRACKER 0) -set(OBSW_DEBUG_STARTRACKER 0) +if(EIVE_Q7S_EM) + set(OBSW_Q7S_EM 1 CACHE STRING "Q7S EM configuration") + set(INIT_VAL 0) +else() + set(OBSW_Q7S_EM 0 CACHE STRING "Q7S EM configuration") + set(INIT_VAL 1) +endif() +set(OBSW_ADD_MGT ${INIT_VAL} CACHE STRING "Add MGT module" ) +set(OBSW_ADD_BPX_BATTERY_HANDLER ${INIT_VAL} CACHE STRING "Add MGT module") +set(OBSW_ADD_STAR_TRACKER ${INIT_VAL} CACHE STRING "Add Startracker module") +set(OBSW_ADD_SUN_SENSORS ${INIT_VAL} CACHE STRING "Add sun sensor module") +set(OBSW_ADD_SUS_BOARD_ASS ${INIT_VAL} CACHE STRING "Add sun sensor board assembly") +set(OBSW_ADD_ACS_BOARD ${INIT_VAL} CACHE STRING "Add ACS board module") +set(OBSW_ADD_ACS_HANDLERS ${INIT_VAL} CACHE STRING "Add ACS handlers") +set(OBSW_ADD_RTD_DEVICES ${INIT_VAL} CACHE STRING "Add RTD devices") +set(OBSW_ADD_RAD_SENSORS ${INIT_VAL} CACHE STRING "Add Rad Sensor module") +set(OBSW_ADD_PL_PCDU ${INIT_VAL} CACHE STRING "Add Payload PCDU modukle") +set(OBSW_ADD_SYRLINKS ${INIT_VAL} CACHE STRING "Add Syrlinks module") +set(OBSW_ADD_TMP_DEVICES ${INIT_VAL} CACHE STRING "Add TMP devices") +set(OBSW_ADD_GOMSPACE_PCDU ${INIT_VAL} CACHE STRING "Add GomSpace PCDU modules") ################################################################################ # Pre-Sources preparation @@ -188,7 +207,7 @@ endif() # Configuration files configure_file(${COMMON_CONFIG_PATH}/commonConfig.h.in commonConfig.h) configure_file(${FSFW_CONFIG_PATH}/FSFWConfig.h.in FSFWConfig.h) -configure_file(${FSFW_CONFIG_PATH}/OBSWConfig.h.in OBSWConfig.h) +configure_file(${BSP_PATH}/OBSWConfig.h.in OBSWConfig.h) if(TGT_BSP MATCHES "arm/q7s") configure_file(${BSP_PATH}/boardconfig/q7sConfig.h.in q7sConfig.h) elseif(TGT_BSP MATCHES "arm/raspberrypi" OR TGT_BSP MATCHES "arm/egse") diff --git a/bsp_hosted/OBSWConfig.h.in b/bsp_hosted/OBSWConfig.h.in new file mode 100644 index 00000000..9c7a3f03 --- /dev/null +++ b/bsp_hosted/OBSWConfig.h.in @@ -0,0 +1,122 @@ +/** + * @brief This file can be used to add preprocessor define for conditional + * code inclusion exclusion or various other project constants and + * properties in one place. + */ +#ifndef FSFWCONFIG_OBSWCONFIG_H_ +#define FSFWCONFIG_OBSWCONFIG_H_ + +#include "commonConfig.h" +#include "OBSWVersion.h" + +/*******************************************************************/ +/** All of the following flags should be enabled for mission code */ +/*******************************************************************/ + +#define OBSW_ENABLE_TIMERS 1 +#define OBSW_ADD_STAR_TRACKER 0 +#define OBSW_ADD_PLOC_SUPERVISOR 0 +#define OBSW_ADD_PLOC_MPSOC 0 +#define OBSW_ADD_SUN_SENSORS 0 +#define OBSW_ADD_MGT 0 +#define OBSW_ADD_ACS_BOARD 0 +#define OBSW_ADD_ACS_HANDLERS 0 +#define OBSW_ADD_GPS_0 0 +#define OBSW_ADD_GPS_1 0 +#define OBSW_ADD_RW 0 +#define OBSW_ADD_BPX_BATTERY_HANDLER 0 +#define OBSW_ADD_RTD_DEVICES 0 +#define OBSW_ADD_PL_PCDU 0 +#define OBSW_ADD_TMP_DEVICES 0 +#define OBSW_ADD_RAD_SENSORS 0 +#define OBSW_ADD_SYRLINKS 0 +#define OBSW_STAR_TRACKER_GROUND_CONFIG 1 + +// This is a really tricky switch.. It initializes the PCDU switches to their default states +// at powerup. I think it would be better +// to leave it off for now. It makes testing a lot more difficult and it might mess with +// something the operators might want to do by giving the software too much intelligence +// at the wrong place. The system component might command all the Switches accordingly anyway +#define OBSW_INITIALIZE_SWITCHES 0 +#define OBSW_ENABLE_PERIODIC_HK 0 + +/*******************************************************************/ +/** All of the following flags should be disabled for mission code */ +/*******************************************************************/ + +// Can be used to switch device to NORMAL mode immediately +#define OBSW_SWITCH_TO_NORMAL_MODE_AFTER_STARTUP 1 +#define OBSW_PRINT_MISSED_DEADLINES 1 + +#define OBSW_SYRLINKS_SIMULATED 1 +#define OBSW_ADD_TEST_CODE 0 +#define OBSW_ADD_TEST_TASK 0 +#define OBSW_ADD_TEST_PST 0 +// If this is enabled, all other SPI code should be disabled +#define OBSW_ADD_SPI_TEST_CODE 0 +// If this is enabled, all other I2C code should be disabled +#define OBSW_ADD_I2C_TEST_CODE 0 +#define OBSW_ADD_UART_TEST_CODE 0 + +#define OBSW_TEST_ACS 0 +#define OBSW_DEBUG_ACS 0 +#define OBSW_TEST_SUS 0 +#define OBSW_DEBUG_SUS 0 +#define OBSW_TEST_RTD 0 +#define OBSW_DEBUG_RTD 0 +#define OBSW_TEST_RAD_SENSOR 0 +#define OBSW_DEBUG_RAD_SENSOR 0 +#define OBSW_TEST_PL_PCDU 0 +#define OBSW_DEBUG_PL_PCDU 0 +#define OBSW_TEST_BPX_BATT 0 +#define OBSW_DEBUG_BPX_BATT 0 +#define OBSW_TEST_IMTQ 0 +#define OBSW_DEBUG_IMTQ 0 +#define OBSW_TEST_RW 0 +#define OBSW_DEBUG_RW 0 + +#define OBSW_TEST_LIBGPIOD 0 +#define OBSW_TEST_PLOC_HANDLER 0 +#define OBSW_TEST_CCSDS_BRIDGE 0 +#define OBSW_TEST_CCSDS_PTME 0 +#define OBSW_TEST_TE7020_HEATER 0 +#define OBSW_TEST_GPIO_OPEN_BY_LABEL 0 +#define OBSW_TEST_GPIO_OPEN_BY_LINE_NAME 0 +#define OBSW_DEBUG_P60DOCK 0 + +#define OBSW_PRINT_CORE_HK 0 +#define OBSW_DEBUG_PDU1 0 +#define OBSW_DEBUG_PDU2 0 +#define OBSW_DEBUG_GPS 0 +#define OBSW_DEBUG_ACU 0 +#define OBSW_DEBUG_SYRLINKS 0 + +#define OBSW_DEBUG_PDEC_HANDLER 0 +#define OBSW_DEBUG_PLOC_SUPERVISOR 0 +#define OBSW_DEBUG_PLOC_MPSOC 0 +#define OBSW_DEBUG_STARTRACKER 0 +#define OBSW_TCP_SERVER_WIRETAPPING 0 + +/*******************************************************************/ +/** CMake Defines */ +/*******************************************************************/ +#cmakedefine EIVE_BUILD_GPSD_GPS_HANDLER + +#cmakedefine LIBGPS_VERSION_MAJOR @LIBGPS_VERSION_MAJOR@ +#cmakedefine LIBGPS_VERSION_MINOR @LIBGPS_VERSION_MINOR@ + +#ifdef RASPBERRY_PI +#include "rpiConfig.h" +#elif defined(XIPHOS_Q7S) +#include "q7sConfig.h" +#endif + +#ifdef __cplusplus + +#include "objects/systemObjectList.h" +#include "events/subsystemIdRanges.h" +#include "returnvalues/classIds.h" + +#endif + +#endif /* FSFWCONFIG_OBSWCONFIG_H_ */ diff --git a/bsp_hosted/bsp_hosted.mk b/bsp_hosted/bsp_hosted.mk deleted file mode 100644 index 9595ffbf..00000000 --- a/bsp_hosted/bsp_hosted.mk +++ /dev/null @@ -1,11 +0,0 @@ -# add main and others -CXXSRC += $(wildcard $(CURRENTPATH)/*.cpp) -CSRC += $(wildcard $(CURRENTPATH)/*.c) - -CSRC += $(wildcard $(CURRENTPATH)/boardconfig/*.c) - -CXXSRC += $(wildcard $(CURRENTPATH)/comIF/*.cpp) -CSRC += $(wildcard $(CURRENTPATH)/comIF/*.c) - -INCLUDES += $(CURRENTPATH)/boardconfig -INCLUDES += $(CURRENTPATH)/fsfwconfig \ No newline at end of file diff --git a/bsp_linux_board/OBSWConfig.h.in b/bsp_linux_board/OBSWConfig.h.in new file mode 100644 index 00000000..d8a981bd --- /dev/null +++ b/bsp_linux_board/OBSWConfig.h.in @@ -0,0 +1,122 @@ +/** + * @brief This file can be used to add preprocessor define for conditional + * code inclusion exclusion or various other project constants and + * properties in one place. + */ +#ifndef FSFWCONFIG_OBSWCONFIG_H_ +#define FSFWCONFIG_OBSWCONFIG_H_ + +#include "commonConfig.h" +#include "OBSWVersion.h" + +/*******************************************************************/ +/** All of the following flags should be enabled for mission code */ +/*******************************************************************/ + +#define OBSW_ENABLE_TIMERS 1 +#define OBSW_ADD_STAR_TRACKER 0 +#define OBSW_ADD_PLOC_SUPERVISOR 0 +#define OBSW_ADD_PLOC_MPSOC 0 +#define OBSW_ADD_SUN_SENSORS 0 +#define OBSW_ADD_MGT 0 +#define OBSW_ADD_ACS_BOARD 0 +#define OBSW_ADD_ACS_HANDLERS 0 +#define OBSW_ADD_GPS_0 0 +#define OBSW_ADD_GPS_1 0 +#define OBSW_ADD_RW 0 +#define OBSW_ADD_BPX_BATTERY_HANDLER 0 +#define OBSW_ADD_RTD_DEVICES 0 +#define OBSW_ADD_PL_PCDU 0 +#define OBSW_ADD_TMP_DEVICES 0 +#define OBSW_ADD_RAD_SENSORS 0 +#define OBSW_ADD_SYRLINKS 0 +#define OBSW_STAR_TRACKER_GROUND_CONFIG 1 + +// This is a really tricky switch.. It initializes the PCDU switches to their default states +// at powerup. I think it would be better +// to leave it off for now. It makes testing a lot more difficult and it might mess with +// something the operators might want to do by giving the software too much intelligence +// at the wrong place. The system component might command all the Switches accordingly anyway +#define OBSW_INITIALIZE_SWITCHES 0 +#define OBSW_ENABLE_PERIODIC_HK 0 + +/*******************************************************************/ +/** All of the following flags should be disabled for mission code */ +/*******************************************************************/ + +// Can be used to switch device to NORMAL mode immediately +#define OBSW_SWITCH_TO_NORMAL_MODE_AFTER_STARTUP 1 +#define OBSW_PRINT_MISSED_DEADLINES 1 + +#define OBSW_SYRLINKS_SIMULATED 1 +#define OBSW_ADD_TEST_CODE 0 +#define OBSW_ADD_TEST_TASK 0 +#define OBSW_ADD_TEST_PST 0 +// If this is enabled, all other SPI code should be disabled +#define OBSW_ADD_SPI_TEST_CODE 0 +// If this is enabled, all other I2C code should be disabled +#define OBSW_ADD_I2C_TEST_CODE 0 +#define OBSW_ADD_UART_TEST_CODE 0 + +#define OBSW_TEST_ACS 0 +#define OBSW_DEBUG_ACS 0 +#define OBSW_TEST_SUS 0 +#define OBSW_DEBUG_SUS 0 +#define OBSW_TEST_RTD 0 +#define OBSW_DEBUG_RTD 0 +#define OBSW_TEST_RAD_SENSOR 0 +#define OBSW_DEBUG_RAD_SENSOR 0 +#define OBSW_TEST_PL_PCDU 0 +#define OBSW_DEBUG_PL_PCDU 0 +#define OBSW_TEST_BPX_BATT 0 +#define OBSW_DEBUG_BPX_BATT 0 +#define OBSW_TEST_IMTQ 0 +#define OBSW_DEBUG_IMTQ 0 +#define OBSW_TEST_RW 0 +#define OBSW_DEBUG_RW 0 + +#define OBSW_TEST_LIBGPIOD 0 +#define OBSW_TEST_PLOC_HANDLER 0 +#define OBSW_TEST_CCSDS_BRIDGE 0 +#define OBSW_TEST_CCSDS_PTME 0 +#define OBSW_TEST_TE7020_HEATER 0 +#define OBSW_TEST_GPIO_OPEN_BY_LABEL 0 +#define OBSW_TEST_GPIO_OPEN_BY_LINE_NAME 0 +#define OBSW_DEBUG_P60DOCK 0 + +#define OBSW_PRINT_CORE_HK 0 +#define OBSW_DEBUG_PDU1 0 +#define OBSW_DEBUG_PDU2 0 +#define OBSW_DEBUG_GPS 0 +#define OBSW_DEBUG_ACU 0 +#define OBSW_DEBUG_SYRLINKS 0 + +#define OBSW_DEBUG_PDEC_HANDLER 0 +#define OBSW_DEBUG_PLOC_SUPERVISOR 0 +#define OBSW_DEBUG_PLOC_MPSOC 0 +#define OBSW_DEBUG_STARTRACKER 0 +#define OBSW_TCP_SERVER_WIRETAPPING 0 + +/*******************************************************************/ +/** CMake Defines */ +/*******************************************************************/ +#cmakedefine EIVE_BUILD_GPSD_GPS_HANDLER + +#cmakedefine LIBGPS_VERSION_MAJOR @LIBGPS_VERSION_MAJOR@ +#cmakedefine LIBGPS_VERSION_MINOR @LIBGPS_VERSION_MINOR@ + +#ifdef RASPBERRY_PI +#include "rpiConfig.h" +#elif defined(XIPHOS_Q7S) +#include "q7sConfig.h" +#endif + +#ifdef __cplusplus + +#include "objects/systemObjectList.h" +#include "events/subsystemIdRanges.h" +#include "returnvalues/classIds.h" + +#endif + +#endif /* FSFWCONFIG_OBSWCONFIG_H_ */ diff --git a/bsp_q7s/CMakeLists.txt b/bsp_q7s/CMakeLists.txt index 459ead8a..34ee8e2a 100644 --- a/bsp_q7s/CMakeLists.txt +++ b/bsp_q7s/CMakeLists.txt @@ -13,6 +13,7 @@ add_subdirectory(simple) target_sources(${OBSW_NAME} PUBLIC main.cpp + obsw.cpp ) add_subdirectory(boardtest) @@ -20,6 +21,13 @@ add_subdirectory(boardtest) add_subdirectory(boardconfig) add_subdirectory(comIF) add_subdirectory(core) + +if(EIVE_Q7S_EM) + add_subdirectory(em) +else() + add_subdirectory(fm) +endif() + add_subdirectory(memory) add_subdirectory(callbacks) add_subdirectory(xadc) diff --git a/bsp_q7s/OBSWConfig.h.in b/bsp_q7s/OBSWConfig.h.in new file mode 100644 index 00000000..0f2556da --- /dev/null +++ b/bsp_q7s/OBSWConfig.h.in @@ -0,0 +1,126 @@ +/** + * @brief This file can be used to add preprocessor define for conditional + * code inclusion exclusion or various other project constants and + * properties in one place. + */ +#ifndef FSFWCONFIG_OBSWCONFIG_H_ +#define FSFWCONFIG_OBSWCONFIG_H_ + +#include "commonConfig.h" +#include "q7sConfig.h" +#include "OBSWVersion.h" + +/*******************************************************************/ +/** All of the following flags should be enabled for mission code */ +/*******************************************************************/ + +#define OBSW_USE_CCSDS_IP_CORE 1 +// Set to 1 if all telemetry should be sent to the PTME IP Core +#define OBSW_TM_TO_PTME 0 +// Set to 1 if telecommands are received via the PDEC IP Core +#define OBSW_TC_FROM_PDEC 0 + +#define OBSW_ENABLE_TIMERS 1 +#define OBSW_ADD_GOMSPACE_PCDU @OBSW_ADD_GOMSPACE_PCDU@ +#define OBSW_ADD_MGT @OBSW_ADD_MGT@ +#define OBSW_ADD_BPX_BATTERY_HANDLER @OBSW_ADD_BPX_BATTERY_HANDLER@ +#define OBSW_ADD_STAR_TRACKER @OBSW_ADD_STAR_TRACKER@ +#define OBSW_ADD_PLOC_SUPERVISOR 0 +#define OBSW_ADD_PLOC_MPSOC 0 +#define OBSW_ADD_SUN_SENSORS @OBSW_ADD_SUN_SENSORS@ +#define OBSW_ADD_SUS_BOARD_ASS @OBSW_ADD_SUS_BOARD_ASS@ +#define OBSW_ADD_ACS_BOARD @OBSW_ADD_ACS_BOARD@ +#define OBSW_ADD_ACS_HANDLERS @OBSW_ADD_ACS_HANDLERS@ +#define OBSW_ADD_RW 0 +#define OBSW_ADD_RTD_DEVICES @OBSW_ADD_RTD_DEVICES@ +#define OBSW_ADD_TMP_DEVICES @OBSW_ADD_TMP_DEVICES@ +#define OBSW_ADD_RAD_SENSORS @OBSW_ADD_RAD_SENSORS@ +#define OBSW_ADD_PL_PCDU @OBSW_ADD_PL_PCDU@ +#define OBSW_ADD_SYRLINKS @OBSW_ADD_SYRLINKS@ +#define OBSW_ENABLE_SYRLINKS_TRANSMIT_TIMEOUT 0 + +// This is a really tricky switch.. It initializes the PCDU switches to their default states +// at powerup. I think it would be better +// to leave it off for now. It makes testing a lot more difficult and it might mess with +// something the operators might want to do by giving the software too much intelligence +// at the wrong place. The system component might command all the Switches accordingly anyway +#define OBSW_INITIALIZE_SWITCHES 0 +#define OBSW_ENABLE_PERIODIC_HK 0 + +/*******************************************************************/ +/** All of the following flags should be disabled for mission code */ +/*******************************************************************/ + +// Can be used to switch device to NORMAL mode immediately +#define OBSW_SWITCH_TO_NORMAL_MODE_AFTER_STARTUP 1 +#define OBSW_PRINT_MISSED_DEADLINES 1 + +#define OBSW_STAR_TRACKER_GROUND_CONFIG 1 +#define OBSW_SYRLINKS_SIMULATED 1 +#define OBSW_ADD_TEST_CODE 0 +#define OBSW_ADD_TEST_TASK 0 +#define OBSW_ADD_TEST_PST 0 +// If this is enabled, all other SPI code should be disabled +#define OBSW_ADD_SPI_TEST_CODE 0 +// If this is enabled, all other I2C code should be disabled +#define OBSW_ADD_I2C_TEST_CODE 0 +#define OBSW_ADD_UART_TEST_CODE 0 + +#define OBSW_TEST_ACS 0 +#define OBSW_DEBUG_ACS 0 +#define OBSW_TEST_SUS 0 +#define OBSW_DEBUG_SUS 0 +#define OBSW_TEST_RTD 0 +#define OBSW_DEBUG_RTD 0 +#define OBSW_TEST_RAD_SENSOR 0 +#define OBSW_DEBUG_RAD_SENSOR 0 +#define OBSW_TEST_PL_PCDU 0 +#define OBSW_DEBUG_PL_PCDU 0 +#define OBSW_TEST_BPX_BATT 0 +#define OBSW_DEBUG_BPX_BATT 0 +#define OBSW_TEST_IMTQ 0 +#define OBSW_DEBUG_IMTQ 0 +#define OBSW_TEST_RW 0 +#define OBSW_DEBUG_RW 0 + +#define OBSW_TEST_LIBGPIOD 0 +#define OBSW_TEST_PLOC_HANDLER 0 +#define OBSW_TEST_CCSDS_BRIDGE 0 +#define OBSW_TEST_CCSDS_PTME 0 +#define OBSW_TEST_TE7020_HEATER 0 +#define OBSW_TEST_GPIO_OPEN_BY_LABEL 0 +#define OBSW_TEST_GPIO_OPEN_BY_LINE_NAME 0 +#define OBSW_DEBUG_P60DOCK 0 + +#define OBSW_PRINT_CORE_HK 0 +#define OBSW_DEBUG_PDU1 0 +#define OBSW_DEBUG_PDU2 0 +#define OBSW_DEBUG_GPS 0 +#define OBSW_DEBUG_ACU 0 +#define OBSW_DEBUG_SYRLINKS 0 + +#define OBSW_DEBUG_PDEC_HANDLER 0 +#define OBSW_DEBUG_PLOC_SUPERVISOR 0 +#define OBSW_DEBUG_PLOC_MPSOC 0 +#define OBSW_DEBUG_STARTRACKER 0 + +#define OBSW_TCP_SERVER_WIRETAPPING 0 + +/*******************************************************************/ +/** CMake Defines */ +/*******************************************************************/ +#cmakedefine EIVE_BUILD_GPSD_GPS_HANDLER + +#cmakedefine LIBGPS_VERSION_MAJOR @LIBGPS_VERSION_MAJOR@ +#cmakedefine LIBGPS_VERSION_MINOR @LIBGPS_VERSION_MINOR@ + + +#ifdef __cplusplus + +#include "objects/systemObjectList.h" +#include "events/subsystemIdRanges.h" +#include "returnvalues/classIds.h" + +#endif + +#endif /* FSFWCONFIG_OBSWCONFIG_H_ */ diff --git a/bsp_q7s/boardconfig/q7sConfig.h.in b/bsp_q7s/boardconfig/q7sConfig.h.in index 1dd1d85a..a678764a 100644 --- a/bsp_q7s/boardconfig/q7sConfig.h.in +++ b/bsp_q7s/boardconfig/q7sConfig.h.in @@ -3,6 +3,8 @@ #include +#define OBSW_Q7S_EM @OBSW_Q7S_EM@ + /*******************************************************************/ /** All of the following flags should be enabled for mission code */ /*******************************************************************/ diff --git a/bsp_q7s/core/CMakeLists.txt b/bsp_q7s/core/CMakeLists.txt index 8731b7a3..e5668acc 100644 --- a/bsp_q7s/core/CMakeLists.txt +++ b/bsp_q7s/core/CMakeLists.txt @@ -1,8 +1,6 @@ target_sources(${OBSW_NAME} PRIVATE CoreController.cpp - obsw.cpp InitMission.cpp - ObjectFactory.cpp ) target_sources(${SIMPLE_OBSW_NAME} PRIVATE diff --git a/bsp_q7s/core/InitMission.cpp b/bsp_q7s/core/InitMission.cpp index ced1d12a..6fd2d723 100644 --- a/bsp_q7s/core/InitMission.cpp +++ b/bsp_q7s/core/InitMission.cpp @@ -1,10 +1,10 @@ -#include "InitMission.h" +#include "bsp_q7s/core/InitMission.h" #include #include #include "OBSWConfig.h" -#include "ObjectFactory.h" +#include "bsp_q7s/core/ObjectFactory.h" #include "fsfw/objectmanager/ObjectManager.h" #include "fsfw/objectmanager/ObjectManagerIF.h" #include "fsfw/platform.h" @@ -294,6 +294,7 @@ void initmission::createPstTasks(TaskFactory& factory, } #endif +#if OBSW_ADD_GOMSPACE_PCDU == 1 FixedTimeslotTaskIF* gomSpacePstTask = factory.createFixedTimeslotTask( "GS_PST_TASK", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 1.0, missedDeadlineFunc); result = pst::pstGompaceCan(gomSpacePstTask); @@ -303,6 +304,7 @@ void initmission::createPstTasks(TaskFactory& factory, } } taskVec.push_back(gomSpacePstTask); +#endif } void initmission::createPusTasks(TaskFactory& factory, diff --git a/bsp_q7s/core/ParameterHandler.cpp b/bsp_q7s/core/ParameterHandler.cpp deleted file mode 100644 index 8cee046e..00000000 --- a/bsp_q7s/core/ParameterHandler.cpp +++ /dev/null @@ -1,5 +0,0 @@ -#include "ParameterHandler.h" - -ParameterHandler::ParameterHandler(std::string mountPrefix) : mountPrefix(mountPrefix) {} - -void ParameterHandler::setMountPrefix(std::string prefix) { mountPrefix = prefix; } diff --git a/bsp_q7s/core/ParameterHandler.h b/bsp_q7s/core/ParameterHandler.h deleted file mode 100644 index 4a108586..00000000 --- a/bsp_q7s/core/ParameterHandler.h +++ /dev/null @@ -1,20 +0,0 @@ -#ifndef BSP_Q7S_CORE_PARAMETERHANDLER_H_ -#define BSP_Q7S_CORE_PARAMETERHANDLER_H_ - -#include -#include - -class ParameterHandler { - public: - ParameterHandler(std::string mountPrefix); - - void setMountPrefix(std::string prefix); - - void setUpDummyParameter(); - - private: - std::string mountPrefix; - DummyParameter dummyParam; -}; - -#endif /* BSP_Q7S_CORE_PARAMETERHANDLER_H_ */ diff --git a/bsp_q7s/em/CMakeLists.txt b/bsp_q7s/em/CMakeLists.txt new file mode 100644 index 00000000..cce9da77 --- /dev/null +++ b/bsp_q7s/em/CMakeLists.txt @@ -0,0 +1,7 @@ +target_sources(${OBSW_NAME} PRIVATE + ObjectFactory.cpp +) + +target_sources(${SIMPLE_OBSW_NAME} PRIVATE + InitMission.cpp +) diff --git a/bsp_q7s/core/ObjectFactory.cpp b/bsp_q7s/em/ObjectFactory.cpp similarity index 99% rename from bsp_q7s/core/ObjectFactory.cpp rename to bsp_q7s/em/ObjectFactory.cpp index 6c7d31a1..3942d20d 100644 --- a/bsp_q7s/core/ObjectFactory.cpp +++ b/bsp_q7s/em/ObjectFactory.cpp @@ -1,4 +1,4 @@ -#include "ObjectFactory.h" +#include "bsp_q7s/core/ObjectFactory.h" #include "OBSWConfig.h" #include "bsp_q7s/boardtest/Q7STestTask.h" diff --git a/bsp_q7s/fm/CMakeLists.txt b/bsp_q7s/fm/CMakeLists.txt new file mode 100644 index 00000000..6e97d7c7 --- /dev/null +++ b/bsp_q7s/fm/CMakeLists.txt @@ -0,0 +1,3 @@ +target_sources(${OBSW_NAME} PRIVATE + ObjectFactory.cpp +) diff --git a/bsp_q7s/fm/ObjectFactory.cpp b/bsp_q7s/fm/ObjectFactory.cpp new file mode 100644 index 00000000..3942d20d --- /dev/null +++ b/bsp_q7s/fm/ObjectFactory.cpp @@ -0,0 +1,980 @@ +#include "bsp_q7s/core/ObjectFactory.h" + +#include "OBSWConfig.h" +#include "bsp_q7s/boardtest/Q7STestTask.h" +#include "bsp_q7s/callbacks/gnssCallback.h" +#include "bsp_q7s/callbacks/pcduSwitchCb.h" +#include "bsp_q7s/callbacks/q7sGpioCallbacks.h" +#include "bsp_q7s/callbacks/rwSpiCallback.h" +#include "bsp_q7s/core/CoreController.h" +#include "bsp_q7s/memory/FileSystemHandler.h" +#include "busConf.h" +#include "ccsdsConfig.h" +#include "devConf.h" +#include "devices/addresses.h" +#include "devices/gpioIds.h" +#include "devices/powerSwitcherList.h" +#include "fsfw/ipc/QueueFactory.h" +#include "linux/ObjectFactory.h" +#include "linux/boardtest/I2cTestClass.h" +#include "linux/boardtest/SpiTestClass.h" +#include "linux/boardtest/UartTestClass.h" +#include "linux/callbacks/gpioCallbacks.h" +#include "linux/csp/CspComIF.h" +#include "linux/csp/CspCookie.h" +#include "linux/devices/GPSHyperionLinuxController.h" +#include "linux/devices/devicedefinitions/PlocMPSoCDefinitions.h" +#include "linux/devices/devicedefinitions/StarTrackerDefinitions.h" +#include "linux/devices/ploc/PlocMPSoCHandler.h" +#include "linux/devices/ploc/PlocMPSoCHelper.h" +#include "linux/devices/ploc/PlocMemoryDumper.h" +#include "linux/devices/ploc/PlocSupervisorHandler.h" +#include "linux/devices/ploc/PlocUpdater.h" +#include "linux/devices/startracker/StarTrackerHandler.h" +#include "linux/devices/startracker/StrHelper.h" +#include "linux/obc/AxiPtmeConfig.h" +#include "linux/obc/PapbVcInterface.h" +#include "linux/obc/PdecHandler.h" +#include "linux/obc/Ptme.h" +#include "linux/obc/PtmeConfig.h" +#include "mission/system/AcsBoardFdir.h" +#include "mission/system/RtdFdir.h" +#include "mission/system/SusAssembly.h" +#include "mission/system/SusFdir.h" +#include "mission/system/TcsBoardAssembly.h" +#include "tmtc/apid.h" +#include "tmtc/pusIds.h" + +#if OBSW_TEST_LIBGPIOD == 1 +#include "linux/boardtest/LibgpiodTest.h" +#endif + +#include + +#include "fsfw/datapoollocal/LocalDataPoolManager.h" +#include "fsfw/tmtcpacket/pus/tm.h" +#include "fsfw/tmtcservices/CommandingServiceBase.h" +#include "fsfw/tmtcservices/PusServiceBase.h" +#include "fsfw_hal/common/gpio/GpioCookie.h" +#include "fsfw_hal/common/gpio/gpioDefinitions.h" +#include "fsfw_hal/devicehandlers/GyroL3GD20Handler.h" +#include "fsfw_hal/devicehandlers/MgmLIS3MDLHandler.h" +#include "fsfw_hal/devicehandlers/MgmRM3100Handler.h" +#include "fsfw_hal/linux/gpio/LinuxLibgpioIF.h" +#include "fsfw_hal/linux/i2c/I2cComIF.h" +#include "fsfw_hal/linux/i2c/I2cCookie.h" +#include "fsfw_hal/linux/spi/SpiComIF.h" +#include "fsfw_hal/linux/spi/SpiCookie.h" +#include "fsfw_hal/linux/uart/UartComIF.h" +#include "fsfw_hal/linux/uart/UartCookie.h" +#include "mission/core/GenericFactory.h" +#include "mission/devices/ACUHandler.h" +#include "mission/devices/BpxBatteryHandler.h" +#include "mission/devices/GyroADIS1650XHandler.h" +#include "mission/devices/HeaterHandler.h" +#include "mission/devices/IMTQHandler.h" +#include "mission/devices/Max31865PT1000Handler.h" +#include "mission/devices/P60DockHandler.h" +#include "mission/devices/PCDUHandler.h" +#include "mission/devices/PDU1Handler.h" +#include "mission/devices/PDU2Handler.h" +#include "mission/devices/PayloadPcduHandler.h" +#include "mission/devices/RadiationSensorHandler.h" +#include "mission/devices/RwHandler.h" +#include "mission/devices/SolarArrayDeploymentHandler.h" +#include "mission/devices/SusHandler.h" +#include "mission/devices/SyrlinksHkHandler.h" +#include "mission/devices/Tmp1075Handler.h" +#include "mission/devices/devicedefinitions/GomspaceDefinitions.h" +#include "mission/devices/devicedefinitions/Max31865Definitions.h" +#include "mission/devices/devicedefinitions/RadSensorDefinitions.h" +#include "mission/devices/devicedefinitions/RwDefinitions.h" +#include "mission/devices/devicedefinitions/SusDefinitions.h" +#include "mission/devices/devicedefinitions/SyrlinksDefinitions.h" +#include "mission/devices/devicedefinitions/payloadPcduDefinitions.h" +#include "mission/system/AcsBoardAssembly.h" +#include "mission/tmtc/CCSDSHandler.h" +#include "mission/tmtc/VirtualChannel.h" +#include "mission/utility/TmFunnel.h" + +ResetArgs resetArgsGnss0; +ResetArgs resetArgsGnss1; + +void ObjectFactory::setStatics() { Factory::setStaticFrameworkObjectIds(); } + +void Factory::setStaticFrameworkObjectIds() { + PusServiceBase::packetSource = objects::PUS_PACKET_DISTRIBUTOR; + PusServiceBase::packetDestination = objects::TM_FUNNEL; + + CommandingServiceBase::defaultPacketSource = objects::PUS_PACKET_DISTRIBUTOR; + CommandingServiceBase::defaultPacketDestination = objects::TM_FUNNEL; + + DeviceHandlerBase::powerSwitcherId = objects::PCDU_HANDLER; + // DeviceHandlerBase::powerSwitcherId = objects::NO_OBJECT; + +#if OBSW_TM_TO_PTME == 1 + TmFunnel::downlinkDestination = objects::CCSDS_HANDLER; +#else + TmFunnel::downlinkDestination = objects::TMTC_BRIDGE; +#endif /* OBSW_TM_TO_PTME == 1 */ + // No storage object for now. + TmFunnel::storageDestination = objects::NO_OBJECT; + + LocalDataPoolManager::defaultHkDestination = objects::PUS_SERVICE_3_HOUSEKEEPING; + + VerificationReporter::messageReceiver = objects::PUS_SERVICE_1_VERIFICATION; + TmPacketBase::timeStamperId = objects::TIME_STAMPER; +} + +void ObjectFactory::produce(void* args) { + ObjectFactory::setStatics(); + ObjectFactory::produceGenericObjects(); + + LinuxLibgpioIF* gpioComIF = nullptr; + UartComIF* uartComIF = nullptr; + SpiComIF* spiComIF = nullptr; + I2cComIF* i2cComIF = nullptr; + PowerSwitchIF* pwrSwitcher = nullptr; + createCommunicationInterfaces(&gpioComIF, &uartComIF, &spiComIF, &i2cComIF); + createTmpComponents(); + new CoreController(objects::CORE_CONTROLLER); + + gpioCallbacks::disableAllDecoder(gpioComIF); + createPcduComponents(gpioComIF, &pwrSwitcher); + createRadSensorComponent(gpioComIF); + createSunSensorComponents(gpioComIF, spiComIF, pwrSwitcher, q7s::SPI_DEFAULT_DEV); + +#if OBSW_ADD_ACS_BOARD == 1 + createAcsBoardComponents(gpioComIF, uartComIF, pwrSwitcher); +#endif + + createHeaterComponents(); + createSolarArrayDeploymentComponents(); + createPlPcduComponents(gpioComIF, spiComIF, pwrSwitcher); +#if OBSW_ADD_SYRLINKS == 1 + createSyrlinksComponents(pwrSwitcher); +#endif /* OBSW_ADD_SYRLINKS == 1 */ + createRtdComponents(q7s::SPI_DEFAULT_DEV, gpioComIF, pwrSwitcher); + createPayloadComponents(gpioComIF); + +#if OBSW_ADD_MGT == 1 + I2cCookie* imtqI2cCookie = + new I2cCookie(addresses::IMTQ, IMTQ::MAX_REPLY_SIZE, q7s::I2C_DEFAULT_DEV); + auto imtqHandler = new IMTQHandler(objects::IMTQ_HANDLER, objects::I2C_COM_IF, imtqI2cCookie, + pcdu::Switches::PDU1_CH3_MGT_5V); + imtqHandler->setPowerSwitcher(pwrSwitcher); + static_cast(imtqHandler); +#if OBSW_TEST_IMTQ == 1 + imtqHandler->setStartUpImmediately(); + imtqHandler->setToGoToNormal(true); +#endif +#if OBSW_DEBUG_IMTQ == 1 + imtqHandler->setDebugMode(true); +#endif +#endif + createReactionWheelComponents(gpioComIF); + +#if OBSW_ADD_BPX_BATTERY_HANDLER == 1 + I2cCookie* bpxI2cCookie = new I2cCookie(addresses::BPX_BATTERY, 100, q7s::I2C_DEFAULT_DEV); + BpxBatteryHandler* bpxHandler = + new BpxBatteryHandler(objects::BPX_BATT_HANDLER, objects::I2C_COM_IF, bpxI2cCookie); + bpxHandler->setStartUpImmediately(); + bpxHandler->setToGoToNormalMode(true); +#if OBSW_DEBUG_BPX_BATT == 1 + bpxHandler->setDebugMode(true); +#endif +#endif + + new FileSystemHandler(objects::FILE_SYSTEM_HANDLER); + +#if OBSW_ADD_STAR_TRACKER == 1 + UartCookie* starTrackerCookie = + new UartCookie(objects::STAR_TRACKER, q7s::UART_STAR_TRACKER_DEV, uart::STAR_TRACKER_BAUD, + startracker::MAX_FRAME_SIZE * 2 + 2, UartModes::NON_CANONICAL); + starTrackerCookie->setNoFixedSizeReply(); + StrHelper* strHelper = new StrHelper(objects::STR_HELPER); + auto starTracker = + new StarTrackerHandler(objects::STAR_TRACKER, objects::UART_COM_IF, starTrackerCookie, + strHelper, pcdu::PDU1_CH2_STAR_TRACKER_5V); + starTracker->setPowerSwitcher(pwrSwitcher); + +#endif /* OBSW_ADD_STAR_TRACKER == 1 */ + +#if OBSW_USE_CCSDS_IP_CORE == 1 + createCcsdsComponents(gpioComIF); +#endif /* OBSW_USE_CCSDS_IP_CORE == 1 */ + + /* Test Task */ +#if OBSW_ADD_TEST_CODE == 1 + createTestComponents(gpioComIF); +#endif /* OBSW_ADD_TEST_CODE == 1 */ + + new PlocUpdater(objects::PLOC_UPDATER); + new PlocMemoryDumper(objects::PLOC_MEMORY_DUMPER); +} + +void ObjectFactory::createTmpComponents() { + I2cCookie* i2cCookieTmp1075tcs1 = + new I2cCookie(addresses::TMP1075_TCS_1, TMP1075::MAX_REPLY_LENGTH, q7s::I2C_DEFAULT_DEV); + I2cCookie* i2cCookieTmp1075tcs2 = + new I2cCookie(addresses::TMP1075_TCS_2, TMP1075::MAX_REPLY_LENGTH, q7s::I2C_DEFAULT_DEV); + + /* Temperature sensors */ + Tmp1075Handler* tmp1075Handler_1 = + new Tmp1075Handler(objects::TMP1075_HANDLER_1, objects::I2C_COM_IF, i2cCookieTmp1075tcs1); + (void)tmp1075Handler_1; + Tmp1075Handler* tmp1075Handler_2 = + new Tmp1075Handler(objects::TMP1075_HANDLER_2, objects::I2C_COM_IF, i2cCookieTmp1075tcs2); + (void)tmp1075Handler_2; +} + +void ObjectFactory::createCommunicationInterfaces(LinuxLibgpioIF** gpioComIF, UartComIF** uartComIF, + SpiComIF** spiComIF, I2cComIF** i2cComIF) { + if (gpioComIF == nullptr or uartComIF == nullptr or spiComIF == nullptr) { + sif::error << "ObjectFactory::createCommunicationInterfaces: Invalid passed ComIF pointer" + << std::endl; + } + *gpioComIF = new LinuxLibgpioIF(objects::GPIO_IF); + + /* Communication interfaces */ + new CspComIF(objects::CSP_COM_IF); + *i2cComIF = new I2cComIF(objects::I2C_COM_IF); + *uartComIF = new UartComIF(objects::UART_COM_IF); + *spiComIF = new SpiComIF(objects::SPI_COM_IF, *gpioComIF); + + /* Adding gpios for chip select decoding to the gpioComIf */ + q7s::gpioCallbacks::initSpiCsDecoder(*gpioComIF); +} + +void ObjectFactory::createPcduComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchIF** pwrSwitcher) { + CspCookie* p60DockCspCookie = new CspCookie(P60Dock::MAX_REPLY_LENGTH, addresses::P60DOCK); + CspCookie* pdu1CspCookie = new CspCookie(PDU::MAX_REPLY_LENGTH, addresses::PDU1); + CspCookie* pdu2CspCookie = new CspCookie(PDU::MAX_REPLY_LENGTH, addresses::PDU2); + CspCookie* acuCspCookie = new CspCookie(ACU::MAX_REPLY_LENGTH, addresses::ACU); + /* Device Handler */ + P60DockHandler* p60dockhandler = + new P60DockHandler(objects::P60DOCK_HANDLER, objects::CSP_COM_IF, p60DockCspCookie); + PDU1Handler* pdu1handler = + new PDU1Handler(objects::PDU1_HANDLER, objects::CSP_COM_IF, pdu1CspCookie); + PDU2Handler* pdu2handler = + new PDU2Handler(objects::PDU2_HANDLER, objects::CSP_COM_IF, pdu2CspCookie); + ACUHandler* acuhandler = new ACUHandler(objects::ACU_HANDLER, objects::CSP_COM_IF, acuCspCookie); + auto pcduHandler = new PCDUHandler(objects::PCDU_HANDLER, 50); + + /** + * Setting PCDU devices to mode normal immediately after start up because PCDU is always + * running. + */ + p60dockhandler->setModeNormal(); + pdu1handler->setModeNormal(); + pdu2handler->setModeNormal(); + acuhandler->setModeNormal(); + if (pwrSwitcher != nullptr) { + *pwrSwitcher = pcduHandler; + } +#if OBSW_DEBUG_P60DOCK == 1 + p60dockhandler->setDebugMode(true); +#endif +#if OBSW_DEBUG_ACU == 1 + acuhandler->setDebugMode(true); +#endif +} + +void ObjectFactory::createRadSensorComponent(LinuxLibgpioIF* gpioComIF) { + using namespace gpio; + GpioCookie* gpioCookieRadSensor = new GpioCookie; + std::stringstream consumer; + consumer << "0x" << std::hex << objects::RAD_SENSOR; + GpiodRegularByLineName* gpio = new GpiodRegularByLineName( + q7s::gpioNames::RAD_SENSOR_CHIP_SELECT, consumer.str(), Direction::OUT, Levels::HIGH); + gpioCookieRadSensor->addGpio(gpioIds::CS_RAD_SENSOR, gpio); + gpio = new GpiodRegularByLineName(q7s::gpioNames::ENABLE_RADFET, consumer.str(), Direction::OUT, + Levels::LOW); + gpioCookieRadSensor->addGpio(gpioIds::ENABLE_RADFET, gpio); + gpioComIF->addGpios(gpioCookieRadSensor); + + SpiCookie* spiCookieRadSensor = new SpiCookie( + addresses::RAD_SENSOR, gpioIds::CS_RAD_SENSOR, std::string(q7s::SPI_DEFAULT_DEV), + RAD_SENSOR::READ_SIZE, spi::DEFAULT_MAX_1227_MODE, spi::DEFAULT_MAX_1227_SPEED); + auto radSensor = new RadiationSensorHandler(objects::RAD_SENSOR, objects::SPI_COM_IF, + spiCookieRadSensor, gpioComIF); + static_cast(radSensor); + // The radiation sensor ADC is powered by the 5V stack connector which should always be on + radSensor->setStartUpImmediately(); + // It's a simple sensor, so just to to normal mode immediately + radSensor->setToGoToNormalModeImmediately(); +#if OBSW_DEBUG_RAD_SENSOR == 1 + radSensor->enablePeriodicDataPrint(true); +#endif +} + +void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComIF* uartComIF, + PowerSwitchIF* pwrSwitcher) { + using namespace gpio; + GpioCookie* gpioCookieAcsBoard = new GpioCookie(); + + std::stringstream consumer; + GpiodRegularByLineName* gpio = nullptr; + consumer << "0x" << std::hex << objects::GYRO_0_ADIS_HANDLER; + gpio = new GpiodRegularByLineName(q7s::gpioNames::GYRO_0_ADIS_CS, consumer.str(), Direction::OUT, + Levels::HIGH); + gpioCookieAcsBoard->addGpio(gpioIds::GYRO_0_ADIS_CS, gpio); + + consumer.str(""); + consumer << "0x" << std::hex << objects::GYRO_1_L3G_HANDLER; + gpio = new GpiodRegularByLineName(q7s::gpioNames::GYRO_1_L3G_CS, consumer.str(), Direction::OUT, + Levels::HIGH); + gpioCookieAcsBoard->addGpio(gpioIds::GYRO_1_L3G_CS, gpio); + + consumer.str(""); + consumer << "0x" << std::hex << objects::GYRO_2_ADIS_HANDLER; + gpio = new GpiodRegularByLineName(q7s::gpioNames::GYRO_2_ADIS_CS, consumer.str(), Direction::OUT, + Levels::HIGH); + gpioCookieAcsBoard->addGpio(gpioIds::GYRO_2_ADIS_CS, gpio); + + consumer.str(""); + consumer << "0x" << std::hex << objects::GYRO_3_L3G_HANDLER; + gpio = new GpiodRegularByLineName(q7s::gpioNames::GYRO_3_L3G_CS, consumer.str(), Direction::OUT, + Levels::HIGH); + gpioCookieAcsBoard->addGpio(gpioIds::GYRO_3_L3G_CS, gpio); + + consumer.str(""); + consumer << "0x" << std::hex << objects::MGM_0_LIS3_HANDLER; + gpio = new GpiodRegularByLineName(q7s::gpioNames::MGM_0_CS, consumer.str(), Direction::OUT, + Levels::HIGH); + gpioCookieAcsBoard->addGpio(gpioIds::MGM_0_LIS3_CS, gpio); + + consumer.str(""); + consumer << "0x" << std::hex << objects::MGM_1_RM3100_HANDLER; + gpio = new GpiodRegularByLineName(q7s::gpioNames::MGM_1_CS, consumer.str(), Direction::OUT, + Levels::HIGH); + gpioCookieAcsBoard->addGpio(gpioIds::MGM_1_RM3100_CS, gpio); + + consumer.str(""); + consumer << "0x" << std::hex << objects::MGM_2_LIS3_HANDLER; + gpio = new GpiodRegularByLineName(q7s::gpioNames::MGM_2_CS, consumer.str(), Direction::OUT, + Levels::HIGH); + gpioCookieAcsBoard->addGpio(gpioIds::MGM_2_LIS3_CS, gpio); + + consumer.str(""); + consumer << "0x" << std::hex << objects::MGM_3_RM3100_HANDLER; + gpio = new GpiodRegularByLineName(q7s::gpioNames::MGM_3_CS, consumer.str(), Direction::OUT, + Levels::HIGH); + gpioCookieAcsBoard->addGpio(gpioIds::MGM_3_RM3100_CS, gpio); + + consumer.str(""); + consumer << "0x" << std::hex << objects::GPS_CONTROLLER; + // GNSS reset pins are active low + gpio = new GpiodRegularByLineName(q7s::gpioNames::RESET_GNSS_0, consumer.str(), Direction::OUT, + Levels::HIGH); + gpioCookieAcsBoard->addGpio(gpioIds::GNSS_0_NRESET, gpio); + + consumer.str(""); + consumer << "0x" << std::hex << objects::GPS_CONTROLLER; + gpio = new GpiodRegularByLineName(q7s::gpioNames::RESET_GNSS_1, consumer.str(), Direction::OUT, + Levels::HIGH); + gpioCookieAcsBoard->addGpio(gpioIds::GNSS_1_NRESET, gpio); + + consumer.str(""); + consumer << "0x" << std::hex << objects::GYRO_0_ADIS_HANDLER; + // Enable pins must be pulled low for regular operations + gpio = new GpiodRegularByLineName(q7s::gpioNames::GYRO_0_ENABLE, consumer.str(), Direction::OUT, + Levels::LOW); + gpioCookieAcsBoard->addGpio(gpioIds::GYRO_0_ENABLE, gpio); + + consumer.str(""); + consumer << "0x" << std::hex << objects::GYRO_2_ADIS_HANDLER; + gpio = new GpiodRegularByLineName(q7s::gpioNames::GYRO_2_ENABLE, consumer.str(), Direction::OUT, + Levels::LOW); + gpioCookieAcsBoard->addGpio(gpioIds::GYRO_2_ENABLE, gpio); + + // Enable pins for GNSS + consumer.str(""); + consumer << "0x" << std::hex << objects::GPS_CONTROLLER; + gpio = new GpiodRegularByLineName(q7s::gpioNames::GNSS_0_ENABLE, consumer.str(), Direction::OUT, + Levels::LOW); + gpioCookieAcsBoard->addGpio(gpioIds::GNSS_0_ENABLE, gpio); + + consumer.str(""); + consumer << "0x" << std::hex << objects::GPS_CONTROLLER; + gpio = new GpiodRegularByLineName(q7s::gpioNames::GNSS_1_ENABLE, consumer.str(), Direction::OUT, + Levels::LOW); + gpioCookieAcsBoard->addGpio(gpioIds::GNSS_1_ENABLE, gpio); + + // Select pin. 0 for GPS side A, 1 for GPS side B + consumer.str(""); + consumer << "0x" << std::hex << objects::GPS_CONTROLLER; + gpio = new GpiodRegularByLineName(q7s::gpioNames::GNSS_SELECT, consumer.str(), Direction::OUT, + Levels::LOW); + gpioCookieAcsBoard->addGpio(gpioIds::GNSS_SELECT, gpio); + gpioComIF->addGpios(gpioCookieAcsBoard); + AcsBoardFdir* fdir = nullptr; + static_cast(fdir); + +#if OBSW_ADD_ACS_HANDLERS == 1 + std::string spiDev = q7s::SPI_DEFAULT_DEV; + SpiCookie* spiCookie = + new SpiCookie(addresses::MGM_0_LIS3, gpioIds::MGM_0_LIS3_CS, spiDev, + MGMLIS3MDL::MAX_BUFFER_SIZE, spi::DEFAULT_LIS3_MODE, spi::DEFAULT_LIS3_SPEED); + auto mgmLis3Handler = new MgmLIS3MDLHandler(objects::MGM_0_LIS3_HANDLER, objects::SPI_COM_IF, + spiCookie, spi::LIS3_TRANSITION_DELAY); + fdir = new AcsBoardFdir(objects::MGM_0_LIS3_HANDLER); + mgmLis3Handler->setCustomFdir(fdir); + static_cast(mgmLis3Handler); +#if OBSW_TEST_ACS == 1 + mgmLis3Handler->setStartUpImmediately(); + mgmLis3Handler->setToGoToNormalMode(true); +#endif +#if OBSW_DEBUG_ACS == 1 + mgmLis3Handler->enablePeriodicPrintouts(true, 10); +#endif + + spiCookie = + new SpiCookie(addresses::MGM_1_RM3100, gpioIds::MGM_1_RM3100_CS, spiDev, + RM3100::MAX_BUFFER_SIZE, spi::DEFAULT_RM3100_MODE, spi::DEFAULT_RM3100_SPEED); + auto mgmRm3100Handler = new MgmRM3100Handler(objects::MGM_1_RM3100_HANDLER, objects::SPI_COM_IF, + spiCookie, spi::RM3100_TRANSITION_DELAY); + fdir = new AcsBoardFdir(objects::MGM_1_RM3100_HANDLER); + mgmRm3100Handler->setCustomFdir(fdir); + mgmRm3100Handler->setParent(objects::ACS_BOARD_ASS); + static_cast(mgmRm3100Handler); +#if OBSW_TEST_ACS == 1 + mgmRm3100Handler->setStartUpImmediately(); + mgmRm3100Handler->setToGoToNormalMode(true); +#endif +#if OBSW_DEBUG_ACS == 1 + mgmRm3100Handler->enablePeriodicPrintouts(true, 10); +#endif + + spiCookie = + new SpiCookie(addresses::MGM_2_LIS3, gpioIds::MGM_2_LIS3_CS, spiDev, + MGMLIS3MDL::MAX_BUFFER_SIZE, spi::DEFAULT_LIS3_MODE, spi::DEFAULT_LIS3_SPEED); + mgmLis3Handler = new MgmLIS3MDLHandler(objects::MGM_2_LIS3_HANDLER, objects::SPI_COM_IF, + spiCookie, spi::LIS3_TRANSITION_DELAY); + fdir = new AcsBoardFdir(objects::MGM_2_LIS3_HANDLER); + mgmLis3Handler->setCustomFdir(fdir); + mgmLis3Handler->setParent(objects::ACS_BOARD_ASS); + static_cast(mgmLis3Handler); +#if OBSW_TEST_ACS == 1 + mgmLis3Handler->setStartUpImmediately(); + mgmLis3Handler->setToGoToNormalMode(true); +#endif +#if OBSW_DEBUG_ACS == 1 + mgmLis3Handler->enablePeriodicPrintouts(true, 10); +#endif + spiCookie = + new SpiCookie(addresses::MGM_3_RM3100, gpioIds::MGM_3_RM3100_CS, spiDev, + RM3100::MAX_BUFFER_SIZE, spi::DEFAULT_RM3100_MODE, spi::DEFAULT_RM3100_SPEED); + mgmRm3100Handler = new MgmRM3100Handler(objects::MGM_3_RM3100_HANDLER, objects::SPI_COM_IF, + spiCookie, spi::RM3100_TRANSITION_DELAY); + fdir = new AcsBoardFdir(objects::MGM_3_RM3100_HANDLER); + mgmRm3100Handler->setCustomFdir(fdir); + mgmRm3100Handler->setParent(objects::ACS_BOARD_ASS); +#if OBSW_TEST_ACS == 1 + mgmRm3100Handler->setStartUpImmediately(); + mgmRm3100Handler->setToGoToNormalMode(true); +#endif +#if OBSW_DEBUG_ACS == 1 + mgmRm3100Handler->enablePeriodicPrintouts(true, 10); +#endif + + // Commented until ACS board V2 in in clean room again + // Gyro 0 Side A + spiCookie = new SpiCookie(addresses::GYRO_0_ADIS, gpioIds::GYRO_0_ADIS_CS, spiDev, + ADIS1650X::MAXIMUM_REPLY_SIZE, spi::DEFAULT_ADIS16507_MODE, + spi::DEFAULT_ADIS16507_SPEED); + auto adisHandler = new GyroADIS1650XHandler(objects::GYRO_0_ADIS_HANDLER, objects::SPI_COM_IF, + spiCookie, ADIS1650X::Type::ADIS16505); + fdir = new AcsBoardFdir(objects::GYRO_0_ADIS_HANDLER); + adisHandler->setCustomFdir(fdir); + adisHandler->setParent(objects::ACS_BOARD_ASS); + static_cast(adisHandler); +#if OBSW_TEST_ACS == 1 + adisHandler->setStartUpImmediately(); + adisHandler->setToGoToNormalModeImmediately(); +#endif +#if OBSW_DEBUG_ACS == 1 + adisHandler->enablePeriodicPrintouts(true, 10); +#endif + + // Gyro 1 Side A + spiCookie = + new SpiCookie(addresses::GYRO_1_L3G, gpioIds::GYRO_1_L3G_CS, spiDev, L3GD20H::MAX_BUFFER_SIZE, + spi::DEFAULT_L3G_MODE, spi::DEFAULT_L3G_SPEED); + auto gyroL3gHandler = new GyroHandlerL3GD20H(objects::GYRO_1_L3G_HANDLER, objects::SPI_COM_IF, + spiCookie, spi::L3G_TRANSITION_DELAY); + fdir = new AcsBoardFdir(objects::GYRO_1_L3G_HANDLER); + gyroL3gHandler->setCustomFdir(fdir); + gyroL3gHandler->setParent(objects::ACS_BOARD_ASS); + static_cast(gyroL3gHandler); +#if OBSW_TEST_ACS == 1 + gyroL3gHandler->setStartUpImmediately(); + gyroL3gHandler->setToGoToNormalMode(true); +#endif +#if OBSW_DEBUG_ACS == 1 + gyroL3gHandler->enablePeriodicPrintouts(true, 10); +#endif + + // Gyro 2 Side B + spiCookie = new SpiCookie(addresses::GYRO_2_ADIS, gpioIds::GYRO_2_ADIS_CS, spiDev, + ADIS1650X::MAXIMUM_REPLY_SIZE, spi::DEFAULT_ADIS16507_MODE, + spi::DEFAULT_ADIS16507_SPEED); + adisHandler = new GyroADIS1650XHandler(objects::GYRO_2_ADIS_HANDLER, objects::SPI_COM_IF, + spiCookie, ADIS1650X::Type::ADIS16505); + fdir = new AcsBoardFdir(objects::GYRO_2_ADIS_HANDLER); + adisHandler->setCustomFdir(fdir); + adisHandler->setParent(objects::ACS_BOARD_ASS); +#if OBSW_TEST_ACS == 1 + adisHandler->setStartUpImmediately(); + adisHandler->setToGoToNormalModeImmediately(); +#endif + // Gyro 3 Side B + spiCookie = + new SpiCookie(addresses::GYRO_3_L3G, gpioIds::GYRO_3_L3G_CS, spiDev, L3GD20H::MAX_BUFFER_SIZE, + spi::DEFAULT_L3G_MODE, spi::DEFAULT_L3G_SPEED); + gyroL3gHandler = new GyroHandlerL3GD20H(objects::GYRO_3_L3G_HANDLER, objects::SPI_COM_IF, + spiCookie, spi::L3G_TRANSITION_DELAY); + fdir = new AcsBoardFdir(objects::GYRO_3_L3G_HANDLER); + gyroL3gHandler->setCustomFdir(fdir); + gyroL3gHandler->setParent(objects::ACS_BOARD_ASS); +#if OBSW_TEST_ACS == 1 + gyroL3gHandler->setStartUpImmediately(); + gyroL3gHandler->setToGoToNormalMode(true); +#endif +#if OBSW_DEBUG_ACS == 1 + gyroL3gHandler->enablePeriodicPrintouts(true, 10); +#endif + + bool debugGps = false; +#if OBSW_DEBUG_GPS == 1 + debugGps = true; +#endif + resetArgsGnss1.gnss1 = true; + resetArgsGnss1.gpioComIF = gpioComIF; + resetArgsGnss1.waitPeriodMs = 100; + resetArgsGnss0.gnss1 = false; + resetArgsGnss0.gpioComIF = gpioComIF; + resetArgsGnss0.waitPeriodMs = 100; + auto gpsHandler0 = + new GPSHyperionLinuxController(objects::GPS_CONTROLLER, objects::NO_OBJECT, debugGps); + gpsHandler0->setResetPinTriggerFunction(gps::triggerGpioResetPin, &resetArgsGnss0); + + AcsBoardHelper acsBoardHelper = AcsBoardHelper( + objects::MGM_0_LIS3_HANDLER, objects::MGM_1_RM3100_HANDLER, objects::MGM_2_LIS3_HANDLER, + objects::MGM_3_RM3100_HANDLER, objects::GYRO_0_ADIS_HANDLER, objects::GYRO_1_L3G_HANDLER, + objects::GYRO_2_ADIS_HANDLER, objects::GYRO_3_L3G_HANDLER, objects::GPS_CONTROLLER); + auto acsAss = new AcsBoardAssembly(objects::ACS_BOARD_ASS, objects::NO_OBJECT, pwrSwitcher, + acsBoardHelper, gpioComIF); + static_cast(acsAss); +#endif /* OBSW_ADD_ACS_HANDLERS == 1 */ +} + +void ObjectFactory::createHeaterComponents() { + using namespace gpio; + GpioCookie* heaterGpiosCookie = new GpioCookie; + GpiodRegularByLineName* gpio = nullptr; + + std::stringstream consumer; + consumer << "0x" << std::hex << objects::HEATER_HANDLER; + /* Pin H2-11 on stack connector */ + gpio = new GpiodRegularByLineName(q7s::gpioNames::HEATER_0, consumer.str(), Direction::OUT, + Levels::LOW); + heaterGpiosCookie->addGpio(gpioIds::HEATER_0, gpio); + /* Pin H2-12 on stack connector */ + gpio = new GpiodRegularByLineName(q7s::gpioNames::HEATER_1, consumer.str(), Direction::OUT, + Levels::LOW); + heaterGpiosCookie->addGpio(gpioIds::HEATER_1, gpio); + + /* Pin H2-13 on stack connector */ + gpio = new GpiodRegularByLineName(q7s::gpioNames::HEATER_2, consumer.str(), Direction::OUT, + Levels::LOW); + heaterGpiosCookie->addGpio(gpioIds::HEATER_2, gpio); + + gpio = new GpiodRegularByLineName(q7s::gpioNames::HEATER_3, consumer.str(), Direction::OUT, + Levels::LOW); + heaterGpiosCookie->addGpio(gpioIds::HEATER_3, gpio); + + gpio = new GpiodRegularByLineName(q7s::gpioNames::HEATER_4, consumer.str(), Direction::OUT, + Levels::LOW); + heaterGpiosCookie->addGpio(gpioIds::HEATER_4, gpio); + + gpio = new GpiodRegularByLineName(q7s::gpioNames::HEATER_5, consumer.str(), Direction::OUT, + Levels::LOW); + heaterGpiosCookie->addGpio(gpioIds::HEATER_5, gpio); + + gpio = new GpiodRegularByLineName(q7s::gpioNames::HEATER_6, consumer.str(), Direction::OUT, + Levels::LOW); + heaterGpiosCookie->addGpio(gpioIds::HEATER_6, gpio); + + gpio = new GpiodRegularByLineName(q7s::gpioNames::HEATER_7, consumer.str(), Direction::OUT, + Levels::LOW); + heaterGpiosCookie->addGpio(gpioIds::HEATER_7, gpio); + + new HeaterHandler(objects::HEATER_HANDLER, objects::GPIO_IF, heaterGpiosCookie, + objects::PCDU_HANDLER, pcdu::Switches::PDU2_CH3_TCS_BOARD_HEATER_IN_8V); +} + +void ObjectFactory::createSolarArrayDeploymentComponents() { + using namespace gpio; + GpioCookie* solarArrayDeplCookie = new GpioCookie; + GpiodRegularByLineName* gpio = nullptr; + + std::stringstream consumer; + consumer << "0x" << std::hex << objects::SOLAR_ARRAY_DEPL_HANDLER; + gpio = new GpiodRegularByLineName(q7s::gpioNames::SA_DPL_PIN_0, consumer.str(), Direction::OUT, + Levels::LOW); + solarArrayDeplCookie->addGpio(gpioIds::DEPLSA1, gpio); + gpio = new GpiodRegularByLineName(q7s::gpioNames::SA_DPL_PIN_1, consumer.str(), Direction::OUT, + Levels::LOW); + solarArrayDeplCookie->addGpio(gpioIds::DEPLSA2, gpio); + + // TODO: Find out burn time. For now set to 1000 ms. + new SolarArrayDeploymentHandler(objects::SOLAR_ARRAY_DEPL_HANDLER, objects::GPIO_IF, + solarArrayDeplCookie, objects::PCDU_HANDLER, + pcdu::Switches::PDU2_CH5_DEPLOYMENT_MECHANISM_8V, + gpioIds::DEPLSA1, gpioIds::DEPLSA2, 1000); +} + +void ObjectFactory::createSyrlinksComponents(PowerSwitchIF* pwrSwitcher) { + UartCookie* syrlinksUartCookie = + new UartCookie(objects::SYRLINKS_HK_HANDLER, q7s::UART_SYRLINKS_DEV, uart::SYRLINKS_BAUD, + syrlinks::MAX_REPLY_SIZE, UartModes::NON_CANONICAL); + syrlinksUartCookie->setParityEven(); + + auto syrlinksHandler = new SyrlinksHkHandler(objects::SYRLINKS_HK_HANDLER, objects::UART_COM_IF, + syrlinksUartCookie, pcdu::PDU1_CH1_SYRLINKS_12V); + syrlinksHandler->setPowerSwitcher(pwrSwitcher); +#if OBSW_DEBUG_SYRLINKS == 1 + syrlinksHandler->setDebugMode(true); +#endif +} + +void ObjectFactory::createPayloadComponents(LinuxLibgpioIF* gpioComIF) { + using namespace gpio; + std::stringstream consumer; +#if OBSW_ADD_PLOC_MPSOC == 1 + consumer << "0x" << std::hex << objects::PLOC_MPSOC_HANDLER; + auto gpioConfigMPSoC = new GpiodRegularByLineName(q7s::gpioNames::ENABLE_MPSOC_UART, + consumer.str(), Direction::OUT, Levels::HIGH); + auto mpsocGpioCookie = new GpioCookie; + mpsocGpioCookie->addGpio(gpioIds::ENABLE_MPSOC_UART, gpioConfigMPSoC); + gpioComIF->addGpios(mpsocGpioCookie); + auto mpsocCookie = + new UartCookie(objects::PLOC_MPSOC_HANDLER, q7s::UART_PLOC_MPSOC_DEV, uart::PLOC_MPSOC_BAUD, + mpsoc::MAX_REPLY_SIZE, UartModes::NON_CANONICAL); + mpsocCookie->setNoFixedSizeReply(); + auto plocMpsocHelper = new PlocMPSoCHelper(objects::PLOC_MPSOC_HELPER); + new PlocMPSoCHandler(objects::PLOC_MPSOC_HANDLER, objects::UART_COM_IF, mpsocCookie, + plocMpsocHelper, Gpio(gpioIds::ENABLE_MPSOC_UART, gpioComIF), + objects::PLOC_SUPERVISOR_HANDLER); +#endif /* OBSW_ADD_PLOC_MPSOC == 1 */ + +#if OBSW_ADD_PLOC_SUPERVISOR == 1 + consumer << "0x" << std::hex << objects::PLOC_SUPERVISOR_HANDLER; + auto gpioConfigSupv = new GpiodRegularByLineName(q7s::gpioNames::ENABLE_SUPV_UART, consumer.str(), + Direction::OUT, Levels::HIGH); + auto supvGpioCookie = new GpioCookie; + supvGpioCookie->addGpio(gpioIds::ENABLE_SUPV_UART, gpioConfigSupv); + gpioComIF->addGpios(supvGpioCookie); + auto supervisorCookie = new UartCookie(objects::PLOC_SUPERVISOR_HANDLER, + q7s::UART_PLOC_SUPERVSIOR_DEV, uart::PLOC_SUPERVISOR_BAUD, + supv::MAX_PACKET_SIZE * 20, UartModes::NON_CANONICAL); + supervisorCookie->setNoFixedSizeReply(); + new PlocSupervisorHandler(objects::PLOC_SUPERVISOR_HANDLER, objects::UART_COM_IF, + supervisorCookie, Gpio(gpioIds::ENABLE_SUPV_UART, gpioComIF), + pcdu::PDU1_CH6_PLOC_12V); +#endif /* OBSW_ADD_PLOC_SUPERVISOR == 1 */ + static_cast(consumer); +} + +void ObjectFactory::createReactionWheelComponents(LinuxLibgpioIF* gpioComIF) { + using namespace gpio; + GpioCookie* gpioCookieRw = new GpioCookie; + GpioCallback* csRw1 = + new GpioCallback("Chip select reaction wheel 1", Direction::OUT, Levels::HIGH, + &gpioCallbacks::spiCsDecoderCallback, gpioComIF); + gpioCookieRw->addGpio(gpioIds::CS_RW1, csRw1); + GpioCallback* csRw2 = + new GpioCallback("Chip select reaction wheel 2", Direction::OUT, Levels::HIGH, + &gpioCallbacks::spiCsDecoderCallback, gpioComIF); + gpioCookieRw->addGpio(gpioIds::CS_RW2, csRw2); + GpioCallback* csRw3 = + new GpioCallback("Chip select reaction wheel 3", Direction::OUT, Levels::HIGH, + &gpioCallbacks::spiCsDecoderCallback, gpioComIF); + gpioCookieRw->addGpio(gpioIds::CS_RW3, csRw3); + GpioCallback* csRw4 = + new GpioCallback("Chip select reaction wheel 4", Direction::OUT, Levels::HIGH, + &gpioCallbacks::spiCsDecoderCallback, gpioComIF); + gpioCookieRw->addGpio(gpioIds::CS_RW4, csRw4); + + std::stringstream consumer; + GpiodRegularByLineName* gpio = nullptr; + consumer << "0x" << std::hex << objects::RW1; + gpio = new GpiodRegularByLineName(q7s::gpioNames::EN_RW_1, consumer.str(), Direction::OUT, + Levels::LOW); + gpioCookieRw->addGpio(gpioIds::EN_RW1, gpio); + consumer.str(""); + consumer << "0x" << std::hex << objects::RW2; + gpio = new GpiodRegularByLineName(q7s::gpioNames::EN_RW_2, consumer.str(), Direction::OUT, + Levels::LOW); + gpioCookieRw->addGpio(gpioIds::EN_RW2, gpio); + consumer.str(""); + consumer << "0x" << std::hex << objects::RW3; + gpio = new GpiodRegularByLineName(q7s::gpioNames::EN_RW_3, consumer.str(), Direction::OUT, + Levels::LOW); + gpioCookieRw->addGpio(gpioIds::EN_RW3, gpio); + consumer.str(""); + consumer << "0x" << std::hex << objects::RW4; + gpio = new GpiodRegularByLineName(q7s::gpioNames::EN_RW_4, consumer.str(), Direction::OUT, + Levels::LOW); + gpioCookieRw->addGpio(gpioIds::EN_RW4, gpio); + + gpioComIF->addGpios(gpioCookieRw); + +#if OBSW_ADD_RW == 1 + auto rw1SpiCookie = + new SpiCookie(addresses::RW1, gpioIds::CS_RW1, q7s::SPI_RW_DEV, RwDefinitions::MAX_REPLY_SIZE, + spi::RW_MODE, spi::RW_SPEED, &rwSpiCallback::spiCallback, nullptr); + auto rw2SpiCookie = + new SpiCookie(addresses::RW2, gpioIds::CS_RW2, q7s::SPI_RW_DEV, RwDefinitions::MAX_REPLY_SIZE, + spi::RW_MODE, spi::RW_SPEED, &rwSpiCallback::spiCallback, nullptr); + auto rw3SpiCookie = + new SpiCookie(addresses::RW3, gpioIds::CS_RW3, q7s::SPI_RW_DEV, RwDefinitions::MAX_REPLY_SIZE, + spi::RW_MODE, spi::RW_SPEED, &rwSpiCallback::spiCallback, nullptr); + auto rw4SpiCookie = + new SpiCookie(addresses::RW4, gpioIds::CS_RW4, q7s::SPI_RW_DEV, RwDefinitions::MAX_REPLY_SIZE, + spi::RW_MODE, spi::RW_SPEED, &rwSpiCallback::spiCallback, nullptr); + + auto rwHandler1 = + new RwHandler(objects::RW1, objects::SPI_COM_IF, rw1SpiCookie, gpioComIF, gpioIds::EN_RW1); + rw1SpiCookie->setCallbackArgs(rwHandler1); +#if OBSW_DEBUG_RW == 1 + rwHandler1->setStartUpImmediately(); + rwHandler1->setDebugMode(true); +#endif + + auto rwHandler2 = + new RwHandler(objects::RW2, objects::SPI_COM_IF, rw2SpiCookie, gpioComIF, gpioIds::EN_RW2); + rw2SpiCookie->setCallbackArgs(rwHandler2); +#if OBSW_DEBUG_RW == 1 + rwHandler2->setStartUpImmediately(); + rwHandler2->setDebugMode(true); +#endif + + auto rwHandler3 = + new RwHandler(objects::RW3, objects::SPI_COM_IF, rw3SpiCookie, gpioComIF, gpioIds::EN_RW3); + rw3SpiCookie->setCallbackArgs(rwHandler3); +#if OBSW_DEBUG_RW == 1 + rwHandler3->setStartUpImmediately(); + rwHandler3->setDebugMode(true); +#endif + + auto rwHandler4 = + new RwHandler(objects::RW4, objects::SPI_COM_IF, rw4SpiCookie, gpioComIF, gpioIds::EN_RW4); + rw4SpiCookie->setCallbackArgs(rwHandler4); +#if OBSW_DEBUG_RW == 1 + rwHandler4->setStartUpImmediately(); + rwHandler4->setDebugMode(true); +#endif + +#endif /* OBSW_ADD_RW == 1 */ +} + +void ObjectFactory::createCcsdsComponents(LinuxLibgpioIF* gpioComIF) { + using namespace gpio; + // GPIO definitions of signals connected to the virtual channel interfaces of the PTME IP Core + GpioCookie* gpioCookiePtmeIp = new GpioCookie; + GpiodRegularByLineName* gpio = nullptr; + std::stringstream consumer; + consumer.str("PAPB VC0"); + gpio = new GpiodRegularByLineName(q7s::gpioNames::PAPB_BUSY_SIGNAL_VC0, consumer.str()); + gpioCookiePtmeIp->addGpio(gpioIds::VC0_PAPB_BUSY, gpio); + consumer.str("PAPB VC0"); + gpio = new GpiodRegularByLineName(q7s::gpioNames::PAPB_EMPTY_SIGNAL_VC0, consumer.str()); + gpioCookiePtmeIp->addGpio(gpioIds::VC0_PAPB_EMPTY, gpio); + consumer.str("PAPB VC 1"); + gpio = new GpiodRegularByLineName(q7s::gpioNames::PAPB_BUSY_SIGNAL_VC1, consumer.str()); + gpioCookiePtmeIp->addGpio(gpioIds::VC1_PAPB_BUSY, gpio); + consumer.str(""); + consumer.str("PAPB VC 1"); + gpioCookiePtmeIp->addGpio(gpioIds::VC1_PAPB_EMPTY, gpio); + consumer.str(""); + consumer.str("PAPB VC 2"); + gpio = new GpiodRegularByLineName(q7s::gpioNames::PAPB_BUSY_SIGNAL_VC2, consumer.str()); + gpioCookiePtmeIp->addGpio(gpioIds::VC2_PAPB_BUSY, gpio); + consumer.str(""); + consumer.str("PAPB VC 2"); + gpio = new GpiodRegularByLineName(q7s::gpioNames::PAPB_EMPTY_SIGNAL_VC2, consumer.str()); + gpioCookiePtmeIp->addGpio(gpioIds::VC2_PAPB_EMPTY, gpio); + consumer.str(""); + consumer.str("PAPB VC 3"); + gpio = new GpiodRegularByLineName(q7s::gpioNames::PAPB_BUSY_SIGNAL_VC3, consumer.str()); + gpioCookiePtmeIp->addGpio(gpioIds::VC3_PAPB_BUSY, gpio); + consumer.str(""); + consumer.str("PAPB VC 3"); + gpio = new GpiodRegularByLineName(q7s::gpioNames::PAPB_EMPTY_SIGNAL_VC3, consumer.str()); + gpioCookiePtmeIp->addGpio(gpioIds::VC3_PAPB_EMPTY, gpio); + + gpioComIF->addGpios(gpioCookiePtmeIp); + + // Creating virtual channel interfaces + VcInterfaceIF* vc0 = + new PapbVcInterface(gpioComIF, gpioIds::VC0_PAPB_BUSY, gpioIds::VC0_PAPB_EMPTY, q7s::UIO_PTME, + q7s::uiomapids::PTME_VC0); + VcInterfaceIF* vc1 = + new PapbVcInterface(gpioComIF, gpioIds::VC1_PAPB_BUSY, gpioIds::VC1_PAPB_EMPTY, q7s::UIO_PTME, + q7s::uiomapids::PTME_VC1); + VcInterfaceIF* vc2 = + new PapbVcInterface(gpioComIF, gpioIds::VC2_PAPB_BUSY, gpioIds::VC2_PAPB_EMPTY, q7s::UIO_PTME, + q7s::uiomapids::PTME_VC2); + VcInterfaceIF* vc3 = + new PapbVcInterface(gpioComIF, gpioIds::VC3_PAPB_BUSY, gpioIds::VC3_PAPB_EMPTY, q7s::UIO_PTME, + q7s::uiomapids::PTME_VC3); + + // Creating ptme object and adding virtual channel interfaces + Ptme* ptme = new Ptme(objects::PTME); + ptme->addVcInterface(ccsds::VC0, vc0); + ptme->addVcInterface(ccsds::VC1, vc1); + ptme->addVcInterface(ccsds::VC2, vc2); + ptme->addVcInterface(ccsds::VC3, vc3); + + AxiPtmeConfig* axiPtmeConfig = + new AxiPtmeConfig(objects::AXI_PTME_CONFIG, q7s::UIO_PTME, q7s::uiomapids::PTME_CONFIG); + PtmeConfig* ptmeConfig = new PtmeConfig(objects::PTME_CONFIG, axiPtmeConfig); +#if OBSW_ENABLE_SYRLINKS_TRANSMIT_TIMEOUT == 1 + // Set to high value when not sending via syrlinks + static const uint32_t TRANSMITTER_TIMEOUT = 86400000; // 1 day +#else + static const uint32_t TRANSMITTER_TIMEOUT = 900000; // 15 minutes +#endif + CCSDSHandler* ccsdsHandler = new CCSDSHandler( + objects::CCSDS_HANDLER, objects::PTME, objects::CCSDS_PACKET_DISTRIBUTOR, ptmeConfig, + gpioComIF, gpioIds::RS485_EN_TX_CLOCK, gpioIds::RS485_EN_TX_DATA, TRANSMITTER_TIMEOUT); + + VirtualChannel* vc = nullptr; + vc = new VirtualChannel(ccsds::VC0, common::VC0_QUEUE_SIZE, objects::CCSDS_HANDLER); + ccsdsHandler->addVirtualChannel(ccsds::VC0, vc); + vc = new VirtualChannel(ccsds::VC1, common::VC1_QUEUE_SIZE, objects::CCSDS_HANDLER); + ccsdsHandler->addVirtualChannel(ccsds::VC1, vc); + vc = new VirtualChannel(ccsds::VC2, common::VC2_QUEUE_SIZE, objects::CCSDS_HANDLER); + ccsdsHandler->addVirtualChannel(ccsds::VC2, vc); + vc = new VirtualChannel(ccsds::VC3, common::VC3_QUEUE_SIZE, objects::CCSDS_HANDLER); + ccsdsHandler->addVirtualChannel(ccsds::VC3, vc); + + GpioCookie* gpioCookiePdec = new GpioCookie; + consumer.str(""); + consumer << "0x" << std::hex << objects::PDEC_HANDLER; + // GPIO also low after linux boot (specified by device-tree) + gpio = new GpiodRegularByLineName(q7s::gpioNames::PDEC_RESET, consumer.str(), Direction::OUT, + Levels::LOW); + gpioCookiePdec->addGpio(gpioIds::PDEC_RESET, gpio); + + gpioComIF->addGpios(gpioCookiePdec); + + new PdecHandler(objects::PDEC_HANDLER, objects::CCSDS_HANDLER, gpioComIF, gpioIds::PDEC_RESET, + q7s::UIO_PDEC_CONFIG_MEMORY, q7s::UIO_PDEC_RAM, q7s::UIO_PDEC_REGISTERS); + + GpioCookie* gpioRS485Chip = new GpioCookie; + gpio = new GpiodRegularByLineName(q7s::gpioNames::RS485_EN_TX_CLOCK, "RS485 Transceiver", + Direction::OUT, Levels::LOW); + gpioRS485Chip->addGpio(gpioIds::RS485_EN_TX_CLOCK, gpio); + gpio = new GpiodRegularByLineName(q7s::gpioNames::RS485_EN_TX_DATA, "RS485 Transceiver", + Direction::OUT, Levels::LOW); + gpioRS485Chip->addGpio(gpioIds::RS485_EN_TX_DATA, gpio); + + // Default configuration enables RX channels (RXEN = LOW) + gpio = new GpiodRegularByLineName(q7s::gpioNames::RS485_EN_RX_CLOCK, "RS485 Transceiver", + Direction::OUT, Levels::LOW); + gpioRS485Chip->addGpio(gpioIds::RS485_EN_RX_CLOCK, gpio); + gpio = new GpiodRegularByLineName(q7s::gpioNames::RS485_EN_RX_DATA, "RS485 Transceiver", + Direction::OUT, Levels::LOW); + gpioRS485Chip->addGpio(gpioIds::RS485_EN_RX_DATA, gpio); + + gpioComIF->addGpios(gpioRS485Chip); +} + +void ObjectFactory::createPlPcduComponents(LinuxLibgpioIF* gpioComIF, SpiComIF* spiComIF, + PowerSwitchIF* pwrSwitcher) { + using namespace gpio; + // Create all GPIO components first + GpioCookie* plPcduGpios = new GpioCookie; + GpiodRegularByLineName* gpio = nullptr; + std::string consumer; + // Switch pins are active high + consumer = "PLPCDU_ENB_VBAT_0"; + gpio = new GpiodRegularByLineName(q7s::gpioNames::PL_PCDU_ENABLE_VBAT0, consumer, Direction::OUT, + gpio::Levels::LOW); + plPcduGpios->addGpio(gpioIds::PLPCDU_ENB_VBAT0, gpio); + consumer = "PLPCDU_ENB_VBAT_1"; + gpio = new GpiodRegularByLineName(q7s::gpioNames::PL_PCDU_ENABLE_VBAT1, consumer, Direction::OUT, + gpio::Levels::LOW); + plPcduGpios->addGpio(gpioIds::PLPCDU_ENB_VBAT1, gpio); + consumer = "PLPCDU_ENB_DRO"; + gpio = new GpiodRegularByLineName(q7s::gpioNames::PL_PCDU_ENABLE_DRO, consumer, Direction::OUT, + gpio::Levels::LOW); + plPcduGpios->addGpio(gpioIds::PLPCDU_ENB_DRO, gpio); + consumer = "PLPCDU_ENB_X8"; + gpio = new GpiodRegularByLineName(q7s::gpioNames::PL_PCDU_ENABLE_X8, consumer, Direction::OUT, + gpio::Levels::LOW); + plPcduGpios->addGpio(gpioIds::PLPCDU_ENB_X8, gpio); + consumer = "PLPCDU_ENB_TX"; + gpio = new GpiodRegularByLineName(q7s::gpioNames::PL_PCDU_ENABLE_TX, consumer, Direction::OUT, + gpio::Levels::LOW); + plPcduGpios->addGpio(gpioIds::PLPCDU_ENB_TX, gpio); + consumer = "PLPCDU_ENB_MPA"; + gpio = new GpiodRegularByLineName(q7s::gpioNames::PL_PCDU_ENABLE_MPA, consumer, Direction::OUT, + gpio::Levels::LOW); + plPcduGpios->addGpio(gpioIds::PLPCDU_ENB_MPA, gpio); + consumer = "PLPCDU_ENB_HPA"; + gpio = new GpiodRegularByLineName(q7s::gpioNames::PL_PCDU_ENABLE_HPA, consumer, Direction::OUT, + gpio::Levels::LOW); + plPcduGpios->addGpio(gpioIds::PLPCDU_ENB_HPA, gpio); + + // Chip select pin is active low + consumer = "PLPCDU_ADC_CS"; + gpio = new GpiodRegularByLineName(q7s::gpioNames::PL_PCDU_ADC_CS, consumer, Direction::OUT, + gpio::Levels::HIGH); + plPcduGpios->addGpio(gpioIds::PLPCDU_ADC_CS, gpio); + gpioComIF->addGpios(plPcduGpios); + SpiCookie* spiCookie = new SpiCookie(addresses::PLPCDU_ADC, gpioIds::PLPCDU_ADC_CS, + q7s::SPI_DEFAULT_DEV, plpcdu::MAX_ADC_REPLY_SIZE, + spi::DEFAULT_MAX_1227_MODE, spi::PL_PCDU_MAX_1227_SPEED); + // Create device handler components + auto plPcduHandler = new PayloadPcduHandler( + objects::PLPCDU_HANDLER, objects::SPI_COM_IF, spiCookie, gpioComIF, SdCardManager::instance(), + pwrSwitcher, pcdu::Switches::PDU2_CH1_PL_PCDU_BATT_0_14V8, + pcdu::Switches::PDU2_CH6_PL_PCDU_BATT_1_14V8, false); + spiCookie->setCallbackMode(PayloadPcduHandler::extConvAsTwoCallback, plPcduHandler); +// plPcduHandler->enablePeriodicPrintout(true, 5); +// static_cast(plPcduHandler); +#if OBSW_TEST_PL_PCDU == 1 + plPcduHandler->setStartUpImmediately(); +#endif +#if OBSW_DEBUG_PL_PCDU == 1 + plPcduHandler->setToGoToNormalModeImmediately(true); + plPcduHandler->enablePeriodicPrintout(true, 10); +#endif +} + +void ObjectFactory::createTestComponents(LinuxLibgpioIF* gpioComIF) { + new Q7STestTask(objects::TEST_TASK); +#if OBSW_ADD_SPI_TEST_CODE == 1 + new SpiTestClass(objects::SPI_TEST, gpioComIF); +#endif +#if OBSW_ADD_I2C_TEST_CODE == 1 + new I2cTestClass(objects::I2C_TEST, q7s::I2C_DEFAULT_DEV); +#endif +#if OBSW_ADD_UART_TEST_CODE == 1 + new UartTestClass(objects::UART_TEST); +#endif +} + +void ObjectFactory::testAcsBrdAss(AcsBoardAssembly* acsAss) { + CommandMessage msg; + ModeMessage::setModeMessage(&msg, ModeMessage::CMD_MODE_COMMAND, DeviceHandlerIF::MODE_NORMAL, + duallane::A_SIDE); + ReturnValue_t result = MessageQueueSenderIF::sendMessage(acsAss->getCommandQueue(), &msg); + if (result != HasReturnvaluesIF::RETURN_OK) { + sif::warning << "Sending mode command failed" << std::endl; + } +} diff --git a/bsp_q7s/main.cpp b/bsp_q7s/main.cpp index dfcaebf0..56327005 100644 --- a/bsp_q7s/main.cpp +++ b/bsp_q7s/main.cpp @@ -1,7 +1,7 @@ #include "q7sConfig.h" #if Q7S_SIMPLE_MODE == 0 -#include "core/obsw.h" +#include "obsw.h" #else #include "simple/simple.h" #endif diff --git a/bsp_q7s/core/obsw.cpp b/bsp_q7s/obsw.cpp similarity index 97% rename from bsp_q7s/core/obsw.cpp rename to bsp_q7s/obsw.cpp index a2888875..74a1b300 100644 --- a/bsp_q7s/core/obsw.cpp +++ b/bsp_q7s/obsw.cpp @@ -3,9 +3,9 @@ #include #include -#include "InitMission.h" #include "OBSWConfig.h" #include "commonConfig.h" +#include "core/InitMission.h" #include "fsfw/tasks/TaskFactory.h" #include "fsfw/version.h" #include "watchdog/definitions.h" diff --git a/bsp_q7s/core/obsw.h b/bsp_q7s/obsw.h similarity index 100% rename from bsp_q7s/core/obsw.h rename to bsp_q7s/obsw.h diff --git a/linux/fsfwconfig/OBSWConfig.h.in b/bsp_te0720_1cfa/OBSWConfig.h.in similarity index 65% rename from linux/fsfwconfig/OBSWConfig.h.in rename to bsp_te0720_1cfa/OBSWConfig.h.in index 356570e5..14867682 100644 --- a/linux/fsfwconfig/OBSWConfig.h.in +++ b/bsp_te0720_1cfa/OBSWConfig.h.in @@ -6,69 +6,19 @@ #ifndef FSFWCONFIG_OBSWCONFIG_H_ #define FSFWCONFIG_OBSWCONFIG_H_ -#cmakedefine RASPBERRY_PI -#cmakedefine XIPHOS_Q7S -#cmakedefine BEAGLEBONEBLACK -#cmakedefine EGSE -#cmakedefine TE0720_1CFA - #include "commonConfig.h" #include "OBSWVersion.h" - -#define Q7S_EM 0 - + /*******************************************************************/ /** All of the following flags should be enabled for mission code */ /*******************************************************************/ -//! Timers can mess up the code when debugging -//! All of this should be enabled for mission code! -#if defined XIPHOS_Q7S - -#define Q7S_EM 0 - -#define OBSW_USE_CCSDS_IP_CORE 1 -// Set to 1 if all telemetry should be sent to the PTME IP Core -#define OBSW_TM_TO_PTME 0 -// Set to 1 if telecommands are received via the PDEC IP Core -#define OBSW_TC_FROM_PDEC 0 - -#define OBSW_ENABLE_TIMERS 1 -#define OBSW_ADD_MGT 1 -#define OBSW_ADD_BPX_BATTERY_HANDLER 1 -#define OBSW_ADD_STAR_TRACKER @OBSW_ADD_STAR_TRACKER@ -#define OBSW_ADD_PLOC_SUPERVISOR 0 -#define OBSW_ADD_PLOC_MPSOC 0 -#define OBSW_ADD_SUN_SENSORS 1 -#define OBSW_ADD_SUS_BOARD_ASS 1 -#define OBSW_ADD_ACS_BOARD 1 -#define OBSW_ADD_ACS_HANDLERS 1 -#define OBSW_ADD_RW 0 -#define OBSW_ADD_RTD_DEVICES 1 -#define OBSW_ADD_TMP_DEVICES 1 -#define OBSW_ADD_RAD_SENSORS 1 -#define OBSW_ADD_PL_PCDU 1 -#define OBSW_ADD_SYRLINKS 1 -#define OBSW_ENABLE_SYRLINKS_TRANSMIT_TIMEOUT 0 -#define OBSW_STAR_TRACKER_GROUND_CONFIG 1 - -#endif // XIPHOS_Q7S - -// This is a really tricky switch.. It initializes the PCDU switches to their default states -// at powerup. I think it would be better -// to leave it off for now. It makes testing a lot more difficult and it might mess with -// something the operators might want to do by giving the software too much intelligence -// at the wrong place. The system component might command all the Switches accordingly anyway -#define OBSW_INITIALIZE_SWITCHES 0 -#define OBSW_ENABLE_PERIODIC_HK 0 - -#ifdef TE0720_1CFA - #define OBSW_USE_CCSDS_IP_CORE 0 // Set to 1 if all telemetry should be sent to the PTME IP Core #define OBSW_TM_TO_PTME 0 // Set to 1 if telecommands are received via the PDEC IP Core #define OBSW_TC_FROM_PDEC 0 + #define OBSW_ENABLE_TIMERS 1 #define OBSW_ADD_MGT 0 #define OBSW_ADD_BPX_BATTERY_HANDLER 0 @@ -91,7 +41,13 @@ #define OBSW_PRINT_CORE_HK 0 #define OBSW_INITIALIZE_SWITCHES 0 -#endif +// This is a really tricky switch.. It initializes the PCDU switches to their default states +// at powerup. I think it would be better +// to leave it off for now. It makes testing a lot more difficult and it might mess with +// something the operators might want to do by giving the software too much intelligence +// at the wrong place. The system component might command all the Switches accordingly anyway +#define OBSW_INITIALIZE_SWITCHES 0 +#define OBSW_ENABLE_PERIODIC_HK 0 /*******************************************************************/ /** All of the following flags should be disabled for mission code */ @@ -146,43 +102,10 @@ #define OBSW_DEBUG_PDEC_HANDLER 0 -#ifdef TE0720_1CFA #define OBSW_DEBUG_PLOC_SUPERVISOR 1 #define OBSW_DEBUG_PLOC_MPSOC 1 -#else -#define OBSW_DEBUG_PLOC_SUPERVISOR 0 -#define OBSW_DEBUG_PLOC_MPSOC 0 -#endif -#ifdef EGSE -#define OBSW_DEBUG_STARTRACKER 1 -#else #define OBSW_DEBUG_STARTRACKER 0 -#endif - -#ifdef RASPBERRY_PI - -#define OBSW_ENABLE_TIMERS 1 -#define OBSW_ADD_STAR_TRACKER 0 -#define OBSW_ADD_PLOC_SUPERVISOR 0 -#define OBSW_ADD_PLOC_MPSOC 0 -#define OBSW_ADD_SUN_SENSORS 0 -#define OBSW_ADD_MGT 0 -#define OBSW_ADD_ACS_BOARD 0 -#define OBSW_ADD_ACS_HANDLERS 0 -#define OBSW_ADD_GPS_0 0 -#define OBSW_ADD_GPS_1 0 -#define OBSW_ADD_RW 0 -#define OBSW_ADD_BPX_BATTERY_HANDLER 0 -#define OBSW_ADD_RTD_DEVICES 0 -#define OBSW_ADD_PL_PCDU 0 -#define OBSW_ADD_TMP_DEVICES 0 -#define OBSW_ADD_RAD_SENSORS 0 -#define OBSW_ADD_SYRLINKS 0 -#define OBSW_STAR_TRACKER_GROUND_CONFIG 1 - -#endif // RASPBERRY_PI - #define OBSW_TCP_SERVER_WIRETAPPING 0 /*******************************************************************/ @@ -193,12 +116,6 @@ #cmakedefine LIBGPS_VERSION_MAJOR @LIBGPS_VERSION_MAJOR@ #cmakedefine LIBGPS_VERSION_MINOR @LIBGPS_VERSION_MINOR@ -#ifdef RASPBERRY_PI -#include "rpiConfig.h" -#elif defined(XIPHOS_Q7S) -#include "q7sConfig.h" -#endif - #ifdef __cplusplus #include "objects/systemObjectList.h" diff --git a/cmake/PreProjectConfig.cmake b/cmake/PreProjectConfig.cmake index df1d92b4..1c998e83 100644 --- a/cmake/PreProjectConfig.cmake +++ b/cmake/PreProjectConfig.cmake @@ -1,3 +1,6 @@ +function(obsw_module_config) +endfunction() + function(pre_source_hw_os_config) # FreeRTOS diff --git a/common/config/commonConfig.h.in b/common/config/commonConfig.h.in index 528342b1..ebd6563b 100644 --- a/common/config/commonConfig.h.in +++ b/common/config/commonConfig.h.in @@ -4,6 +4,12 @@ #include #include "fsfw/version.h" +#cmakedefine RASPBERRY_PI +#cmakedefine XIPHOS_Q7S +#cmakedefine BEAGLEBONEBLACK +#cmakedefine EGSE +#cmakedefine TE0720_1CFA + /* These defines should be disabled for mission code but are useful for debugging. */ #define OBSW_VERBOSE_LEVEL 1 diff --git a/linux/fsfwconfig/FSFWConfig.h.in b/linux/fsfwconfig/FSFWConfig.h.in index 9db84254..072c47c8 100644 --- a/linux/fsfwconfig/FSFWConfig.h.in +++ b/linux/fsfwconfig/FSFWConfig.h.in @@ -76,9 +76,4 @@ static constexpr size_t FSFW_MAX_TM_PACKET_SIZE = 2048; #define FSFW_HAL_I2C_WIRETAPPING 0 #define FSFW_DEV_HYPERION_GPS_CREATE_NMEA_CSV 0 -#define FSFW_HAL_L3GD20_GYRO_DEBUG 0 -#define FSFW_HAL_RM3100_MGM_DEBUG 0 -#define FSFW_HAL_LIS3MDL_MGM_DEBUG 0 -#define FSFW_HAL_ADIS1650X_GYRO_DEBUG 0 - #endif /* CONFIG_FSFWCONFIG_H_ */ diff --git a/linux/fsfwconfig/pollingsequence/pollingSequenceFactory.cpp b/linux/fsfwconfig/pollingsequence/pollingSequenceFactory.cpp index 942404d3..02130d6b 100644 --- a/linux/fsfwconfig/pollingsequence/pollingSequenceFactory.cpp +++ b/linux/fsfwconfig/pollingsequence/pollingSequenceFactory.cpp @@ -510,8 +510,6 @@ ReturnValue_t pst::pstUart(FixedTimeslotTaskIF *thisSequence) { ReturnValue_t pst::pstGompaceCan(FixedTimeslotTaskIF *thisSequence) { uint32_t length = thisSequence->getPeriodMs(); -#ifndef TE0720_1CFA -#if Q7S_EM != 1 // PCDU handlers receives two messages and both must be handled thisSequence->addSlot(objects::PCDU_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION); @@ -543,8 +541,6 @@ ReturnValue_t pst::pstGompaceCan(FixedTimeslotTaskIF *thisSequence) { sif::error << "GomSpace PST initialization failed" << std::endl; return HasReturnvaluesIF::RETURN_FAILED; } -#endif /* Q7S_EM == 0 */ -#endif static_cast(length); return HasReturnvaluesIF::RETURN_OK; } diff --git a/misc/eclipse/.cproject b/misc/eclipse/.cproject index b0f56271..af67f899 100644 --- a/misc/eclipse/.cproject +++ b/misc/eclipse/.cproject @@ -589,7 +589,7 @@ - + @@ -603,7 +603,7 @@ - + diff --git a/tmtc b/tmtc index 76da8042..168b6622 160000 --- a/tmtc +++ b/tmtc @@ -1 +1 @@ -Subproject commit 76da8042a4601087e99fa856af241afe9e43695d +Subproject commit 168b662288175f9db77a5796a02f38cb66911092