diff --git a/CMakeLists.txt b/CMakeLists.txt index 1d468c41..585284ac 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -74,7 +74,7 @@ set(LIB_JSON_NAME nlohmann_json::nlohmann_json) # Set path names set(FSFW_PATH fsfw) -set(TEST_PATH test/testtasks) +set(TEST_PATH test) set(UNITTEST_PATH unittest) set(LINUX_PATH linux) set(COMMON_PATH common) @@ -100,7 +100,8 @@ pre_source_hw_os_config() if(TGT_BSP) if(TGT_BSP MATCHES "arm/q7s" OR TGT_BSP MATCHES "arm/raspberrypi" - OR TGT_BSP MATCHES "arm/beagleboneblack" OR TGT_BSP MATCHES "arm/egse" + OR TGT_BSP MATCHES "arm/beagleboneblack" OR TGT_BSP MATCHES "arm/egse" + OR TGT_BSP MATCHES "arm/te0720-1cfa" ) set(FSFW_CONFIG_PATH "linux/fsfwconfig") if(NOT BUILD_Q7S_SIMPLE_MODE) @@ -133,6 +134,10 @@ if(TGT_BSP) # Used by configure file set(XIPHOS_Q7S ON) endif() + + if(TGT_BSP MATCHES "arm/te0720-1cfa") + set(TE0720_1CFA ON) + endif() else() # Required by FSFW library set(FSFW_CONFIG_PATH "${BSP_PATH}/fsfwconfig") @@ -205,7 +210,7 @@ elseif(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC") set(COMPILER_FLAGS "/permissive-") endif() - +if (NOT(TGT_BSP MATCHES "arm/te0720-1cfa") AND NOT(TGT_BSP MATCHES "arm/q7s")) # Not installed, so use FetchContent to download and provide Catch2 if(NOT Catch2_FOUND) message(STATUS "Did not find a valid Catch2 installation. Using FetchContent to install it") @@ -223,7 +228,7 @@ if(NOT Catch2_FOUND) set_target_properties(Catch2 PROPERTIES EXCLUDE_FROM_ALL "true") set_target_properties(Catch2WithMain PROPERTIES EXCLUDE_FROM_ALL "true") endif() - +endif() add_library(${LIB_EIVE_MISSION}) diff --git a/automation/Dockerfile b/automation/Dockerfile index 9042cf13..63592c77 100644 --- a/automation/Dockerfile +++ b/automation/Dockerfile @@ -16,5 +16,5 @@ RUN mkdir -p /usr/tools; \ curl https://buggy.irs.uni-stuttgart.de/eive/tools/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf.tar.gz \ | tar -xz -C /usr/tools -ENV Q7S_SYSROOT="/usr/rootfs/cortexa9hf-neon-xiphos-linux-gnueabi" -ENV PATH=$PATH:"/usr/tools/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin" \ No newline at end of file +ENV ZYNQ_7020_SYSROOT="/usr/rootfs/cortexa9hf-neon-xiphos-linux-gnueabi" +ENV PATH=$PATH:"/usr/tools/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin" diff --git a/automation/Jenkinsfile b/automation/Jenkinsfile index fe79dc73..ee50924a 100644 --- a/automation/Jenkinsfile +++ b/automation/Jenkinsfile @@ -5,7 +5,7 @@ pipeline { } agent { docker { - image 'eive-obsw-ci:d2' + image 'eive-obsw-ci:d3' args '--sysctl fs.mqueue.msg_max=100' } } diff --git a/bsp_egse/ObjectFactory.cpp b/bsp_egse/ObjectFactory.cpp index 10eea471..8d5e3416 100644 --- a/bsp_egse/ObjectFactory.cpp +++ b/bsp_egse/ObjectFactory.cpp @@ -3,7 +3,6 @@ #include #include #include -#include #include "OBSWConfig.h" #include "busConf.h" diff --git a/bsp_egse/main.cpp b/bsp_egse/main.cpp index ce7966ff..75fb4f19 100644 --- a/bsp_egse/main.cpp +++ b/bsp_egse/main.cpp @@ -3,8 +3,8 @@ #include "InitMission.h" #include "OBSWConfig.h" #include "OBSWVersion.h" -#include "fsfw/FSFWVersion.h" #include "fsfw/tasks/TaskFactory.h" +#include "fsfw/version.h" /** * @brief This is the main program entry point for the egse (raspberry pi 4) diff --git a/bsp_q7s/CMakeLists.txt b/bsp_q7s/CMakeLists.txt index f148e128..459ead8a 100644 --- a/bsp_q7s/CMakeLists.txt +++ b/bsp_q7s/CMakeLists.txt @@ -22,5 +22,4 @@ add_subdirectory(comIF) add_subdirectory(core) add_subdirectory(memory) add_subdirectory(callbacks) -add_subdirectory(devices) add_subdirectory(xadc) diff --git a/bsp_q7s/boardconfig/busConf.h b/bsp_q7s/boardconfig/busConf.h index eba4fb36..5c52693c 100644 --- a/bsp_q7s/boardconfig/busConf.h +++ b/bsp_q7s/boardconfig/busConf.h @@ -94,6 +94,9 @@ static constexpr char PL_PCDU_ENABLE_HPA[] = "enable_plpcdu_hpa"; static constexpr char PL_PCDU_ENABLE_MPA[] = "enable_plpcdu_mpa"; static constexpr char PL_PCDU_ADC_CS[] = "plpcdu_adc_chip_select"; +static constexpr char ENABLE_SUPV_UART[] = "enable_supv_uart"; +static constexpr char ENABLE_MPSOC_UART[] = "enable_mpsoc_uart"; + } // namespace gpioNames } // namespace q7s diff --git a/bsp_q7s/core/InitMission.cpp b/bsp_q7s/core/InitMission.cpp index 751aedee..1d502fef 100644 --- a/bsp_q7s/core/InitMission.cpp +++ b/bsp_q7s/core/InitMission.cpp @@ -55,14 +55,12 @@ void initmission::initTasks() { void (*missedDeadlineFunc)(void) = nullptr; #endif -#if BOARD_TE0720 == 0 PeriodicTaskIF* coreController = factory->createPeriodicTask( "CORE_CTRL", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.4, missedDeadlineFunc); result = coreController->addComponent(objects::CORE_CONTROLLER); if (result != HasReturnvaluesIF::RETURN_OK) { initmission::printAddObjectError("CORE_CTRL", objects::CORE_CONTROLLER); } -#endif /* TMTC Distribution */ PeriodicTaskIF* tmTcDistributor = factory->createPeriodicTask( @@ -140,7 +138,6 @@ void initmission::initTasks() { initmission::printAddObjectError("TCS_BOARD_ASS", objects::TCS_BOARD_ASS); } -#if BOARD_TE0720 == 0 // FS task, task interval does not matter because it runs in permanent loop, priority low // because it is a non-essential background task PeriodicTaskIF* fsTask = factory->createPeriodicTask( @@ -159,7 +156,14 @@ void initmission::initTasks() { } #endif /* OBSW_ADD_STAR_TRACKER == 1 */ -#endif /* BOARD_TE0720 */ +#if OBSW_ADD_PLOC_MPSOC == 1 + PeriodicTaskIF* mpsocHelperTask = factory->createPeriodicTask( + "PLOC_MPSOC_HELPER", 20, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc); + result = mpsocHelperTask->addComponent(objects::PLOC_MPSOC_HELPER); + if (result != HasReturnvaluesIF::RETURN_OK) { + initmission::printAddObjectError("PLOC_MPSOC_HELPER", objects::PLOC_MPSOC_HELPER); + } +#endif /* OBSW_ADD_PLOC_MPSOC */ #if OBSW_TEST_CCSDS_BRIDGE == 1 PeriodicTaskIF* ptmeTestTask = factory->createPeriodicTask( @@ -203,9 +207,7 @@ void initmission::initTasks() { pdecHandlerTask->startTask(); #endif /* OBSW_USE_CCSDS_IP_CORE == 1 */ -#if BOARD_TE0720 == 0 coreController->startTask(); -#endif taskStarter(pstTasks, "PST task vector"); taskStarter(pusTasks, "PUS task vector"); @@ -217,12 +219,10 @@ void initmission::initTasks() { ptmeTestTask->startTask(); #endif -#if BOARD_TE0720 == 0 fsTask->startTask(); #if OBSW_ADD_STAR_TRACKER == 1 - strHelperTask > startTask(); + strHelperTask->startTask(); #endif /* OBSW_ADD_STAR_TRACKER == 1 */ -#endif #if OBSW_ADD_ACS_HANDLERS == 1 acsTask->startTask(); @@ -236,7 +236,6 @@ void initmission::createPstTasks(TaskFactory& factory, TaskDeadlineMissedFunction missedDeadlineFunc, std::vector& taskVec) { ReturnValue_t result = HasReturnvaluesIF::RETURN_OK; -#if BOARD_TE0720 == 0 /* Polling Sequence Table Default */ #if OBSW_ADD_SPI_TEST_CODE == 0 FixedTimeslotTaskIF* spiPst = factory.createFixedTimeslotTask( @@ -302,15 +301,6 @@ void initmission::createPstTasks(TaskFactory& factory, } } taskVec.push_back(gomSpacePstTask); -#else /* BOARD_TE7020 == 0 */ - FixedTimeslotTaskIF* pollingSequenceTaskTE0720 = factory.createFixedTimeslotTask( - "PST_TASK_TE0720", 30, PeriodicTaskIF::MINIMUM_STACK_SIZE * 8, 3.0, missedDeadlineFunc); - result = pst::pollingSequenceTE0720(pollingSequenceTaskTE0720); - if (result != HasReturnvaluesIF::RETURN_OK) { - sif::error << "InitMission::initTasks: Creating TE0720 PST failed!" << std::endl; - } - taskVec.push_back(pollingSequenceTaskTE0720); -#endif /* BOARD_TE7020 == 1 */ } void initmission::createPusTasks(TaskFactory& factory, @@ -417,12 +407,6 @@ void initmission::createTestTasks(TaskFactory& factory, } #endif -#if BOARD_TE0720 == 1 && OBSW_TEST_LIBGPIOD == 1 - result = testTask->addComponent(objects::LIBGPIOD_TEST); - if (result != HasReturnvaluesIF::RETURN_OK) { - initmission::printAddObjectError("GPIOD_TEST", objects::LIBGPIOD_TEST); - } -#endif /* BOARD_TE0720 == 1 && OBSW_TEST_LIBGPIOD == 1 */ taskVec.push_back(testTask); #endif // OBSW_ADD_TEST_TASK == 1 && OBSW_ADD_TEST_CODE == 1 diff --git a/bsp_q7s/core/ObjectFactory.cpp b/bsp_q7s/core/ObjectFactory.cpp index 4c8ec3fc..7d99dbee 100644 --- a/bsp_q7s/core/ObjectFactory.cpp +++ b/bsp_q7s/core/ObjectFactory.cpp @@ -19,9 +19,6 @@ #include "bsp_q7s/callbacks/pcduSwitchCb.h" #include "bsp_q7s/callbacks/rwSpiCallback.h" #include "bsp_q7s/core/CoreController.h" -#include "bsp_q7s/devices/PlocMemoryDumper.h" -#include "bsp_q7s/devices/PlocSupervisorHandler.h" -#include "bsp_q7s/devices/PlocUpdater.h" #include "bsp_q7s/memory/FileSystemHandler.h" #include "busConf.h" #include "ccsdsConfig.h" @@ -35,7 +32,13 @@ #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 "tmtc/apid.h" @@ -52,6 +55,7 @@ #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" @@ -74,7 +78,6 @@ #include "mission/devices/PDU1Handler.h" #include "mission/devices/PDU2Handler.h" #include "mission/devices/PayloadPcduHandler.h" -#include "mission/devices/PlocMPSoCHandler.h" #include "mission/devices/RadiationSensorHandler.h" #include "mission/devices/RwHandler.h" #include "mission/devices/SolarArrayDeploymentHandler.h" @@ -83,7 +86,6 @@ #include "mission/devices/Tmp1075Handler.h" #include "mission/devices/devicedefinitions/GomspaceDefinitions.h" #include "mission/devices/devicedefinitions/Max31865Definitions.h" -#include "mission/devices/devicedefinitions/PlocMPSoCDefinitions.h" #include "mission/devices/devicedefinitions/RadSensorDefinitions.h" #include "mission/devices/devicedefinitions/RwDefinitions.h" #include "mission/devices/devicedefinitions/SusDefinitions.h" @@ -106,8 +108,8 @@ void Factory::setStaticFrameworkObjectIds() { CommandingServiceBase::defaultPacketSource = objects::PUS_PACKET_DISTRIBUTOR; CommandingServiceBase::defaultPacketDestination = objects::TM_FUNNEL; - // DeviceHandlerBase::powerSwitcherId = objects::PCDU_HANDLER; - DeviceHandlerBase::powerSwitcherId = objects::NO_OBJECT; + DeviceHandlerBase::powerSwitcherId = objects::PCDU_HANDLER; + // DeviceHandlerBase::powerSwitcherId = objects::NO_OBJECT; #if OBSW_TM_TO_PTME == 1 TmFunnel::downlinkDestination = objects::CCSDS_HANDLER; @@ -134,7 +136,6 @@ void ObjectFactory::produce(void* args) { PowerSwitchIF* pwrSwitcher = nullptr; createCommunicationInterfaces(&gpioComIF, &uartComIF, &spiComIF, &i2cComIF); createTmpComponents(); -#if BOARD_TE0720 == 0 new CoreController(objects::CORE_CONTROLLER); gpioCallbacks::disableAllDecoder(); @@ -153,6 +154,7 @@ void ObjectFactory::produce(void* args) { createSyrlinksComponents(); #endif /* OBSW_ADD_SYRLINKS == 1 */ createRtdComponents(gpioComIF, pwrSwitcher); + createPayloadComponents(gpioComIF); #if OBSW_ADD_MGT == 1 I2cCookie* imtqI2cCookie = @@ -180,29 +182,12 @@ void ObjectFactory::produce(void* args) { #endif #endif -#if OBSW_ADD_PLOC_MPSOC == 1 - UartCookie* plocMpsocCookie = - new UartCookie(objects::PLOC_MPSOC_HANDLER, q7s::UART_PLOC_MPSOC_DEV, - UartModes::NON_CANONICAL, uart::PLOC_MPSOC_BAUD, PLOC_MPSOC::MAX_REPLY_SIZE); - new PlocMPSoCHandler(objects::PLOC_MPSOC_HANDLER, objects::UART_COM_IF, plocMpsocCookie); -#endif /* OBSW_ADD_PLOC_MPSOC == 1 */ - -#if OBSW_ADD_PLOC_SUPERVISOR == 1 - UartCookie* plocSupervisorCookie = new UartCookie( - objects::PLOC_SUPERVISOR_HANDLER, q7s::UART_PLOC_SUPERVSIOR_DEV, UartModes::NON_CANONICAL, - uart::PLOC_SUPERVISOR_BAUD, PLOC_SPV::MAX_PACKET_SIZE * 20); - plocSupervisorCookie->setNoFixedSizeReply(); - PlocSupervisorHandler* plocSupervisor = new PlocSupervisorHandler( - objects::PLOC_SUPERVISOR_HANDLER, objects::UART_COM_IF, plocSupervisorCookie); - plocSupervisor->setStartUpImmediately(); -#endif /* OBSW_ADD_PLOC_SUPERVISOR == 1 */ - new FileSystemHandler(objects::FILE_SYSTEM_HANDLER); #if OBSW_ADD_STAR_TRACKER == 1 UartCookie* starTrackerCookie = new UartCookie(objects::STAR_TRACKER, q7s::UART_STAR_TRACKER_DEV, UartModes::NON_CANONICAL, - uart::STAR_TRACKER_BAUD, StarTracker::MAX_FRAME_SIZE * 2 + 2); + uart::STAR_TRACKER_BAUD, startracker::MAX_FRAME_SIZE * 2 + 2); starTrackerCookie->setNoFixedSizeReply(); StrHelper* strHelper = new StrHelper(objects::STR_HELPER); StarTrackerHandler* starTrackerHandler = new StarTrackerHandler( @@ -211,8 +196,6 @@ void ObjectFactory::produce(void* args) { #endif /* OBSW_ADD_STAR_TRACKER == 1 */ -#endif /* TE7020 == 0 */ - #if OBSW_USE_CCSDS_IP_CORE == 1 createCcsdsComponents(gpioComIF); #endif /* OBSW_USE_CCSDS_IP_CORE == 1 */ @@ -227,17 +210,10 @@ void ObjectFactory::produce(void* args) { } void ObjectFactory::createTmpComponents() { -#if BOARD_TE0720 == 1 - I2cCookie* i2cCookieTmp1075tcs1 = - new I2cCookie(addresses::TMP1075_TCS_1, TMP1075::MAX_REPLY_LENGTH, std::string("/dev/i2c-0")); - I2cCookie* i2cCookieTmp1075tcs2 = - new I2cCookie(addresses::TMP1075_TCS_2, TMP1075::MAX_REPLY_LENGTH, std::string("/dev/i2c-0")); -#else 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); -#endif /* Temperature sensors */ Tmp1075Handler* tmp1075Handler_1 = @@ -262,10 +238,8 @@ void ObjectFactory::createCommunicationInterfaces(LinuxLibgpioIF** gpioComIF, Ua *uartComIF = new UartComIF(objects::UART_COM_IF); *spiComIF = new SpiComIF(objects::SPI_COM_IF, *gpioComIF); -#if BOARD_TE0720 == 0 /* Adding gpios for chip select decoding to the gpioComIf */ gpioCallbacks::initSpiCsDecoder(*gpioComIF); -#endif } void ObjectFactory::createPcduComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchIF** pwrSwitcher) { @@ -936,6 +910,44 @@ void ObjectFactory::createRtdComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchIF #endif // OBSW_ADD_RTD_DEVICES == 1 } +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, + UartModes::NON_CANONICAL, uart::PLOC_MPSOC_BAUD, mpsoc::MAX_REPLY_SIZE); + mpsocCookie->setNoFixedSizeReply(); + auto plocMpsocHelper = new PlocMPSoCHelper(objects::PLOC_MPSOC_HELPER); + auto plocMPSoC = + new PlocMPSoCHandler(objects::PLOC_MPSOC_HANDLER, objects::UART_COM_IF, mpsocCookie, + plocMpsocHelper, Gpio(gpioIds::ENABLE_MPSOC_UART, gpioComIF)); + plocMPSoC->setStartUpImmediately(); +#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, UartModes::NON_CANONICAL, + uart::PLOC_SUPERVISOR_BAUD, PLOC_SPV::MAX_PACKET_SIZE * 20); + supervisorCookie->setNoFixedSizeReply(); + new PlocSupervisorHandler(objects::PLOC_SUPERVISOR_HANDLER, objects::UART_COM_IF, + supervisorCookie, Gpio(gpioIds::ENABLE_SUPV_UART, gpioComIF)); +#endif /* OBSW_ADD_PLOC_SUPERVISOR == 1 */ + static_cast(consumer); +} + void ObjectFactory::createReactionWheelComponents(LinuxLibgpioIF* gpioComIF) { using namespace gpio; GpioCookie* gpioCookieRw = new GpioCookie; @@ -1120,7 +1132,6 @@ void ObjectFactory::createCcsdsComponents(LinuxLibgpioIF* gpioComIF) { 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); -#if BOARD_TE0720 == 0 GpioCookie* gpioRS485Chip = new GpioCookie; gpio = new GpiodRegularByLineName(q7s::gpioNames::RS485_EN_TX_CLOCK, "RS485 Transceiver", Direction::OUT, Levels::LOW); @@ -1138,7 +1149,6 @@ void ObjectFactory::createCcsdsComponents(LinuxLibgpioIF* gpioComIF) { gpioRS485Chip->addGpio(gpioIds::RS485_EN_RX_DATA, gpio); gpioComIF->addGpios(gpioRS485Chip); -#endif /* BOARD_TE0720 == 0 */ } void ObjectFactory::createPlPcduComponents(LinuxLibgpioIF* gpioComIF, SpiComIF* spiComIF) { @@ -1191,112 +1201,19 @@ void ObjectFactory::createPlPcduComponents(LinuxLibgpioIF* gpioComIF, SpiComIF* new PayloadPcduHandler(objects::PLPCDU_HANDLER, objects::SPI_COM_IF, spiCookie, gpioComIF, SdCardManager::instance(), false); spiCookie->setCallbackMode(PayloadPcduHandler::extConvAsTwoCallback, plPcduHandler); - static_cast(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, 5); + plPcduHandler->enablePeriodicPrintout(true, 10); #endif } void ObjectFactory::createTestComponents(LinuxLibgpioIF* gpioComIF) { -#if BOARD_TE0720 == 0 new Q7STestTask(objects::TEST_TASK); -#endif - -#if BOARD_TE0720 == 1 && OBSW_TEST_LIBGPIOD == 1 -#if OBSW_TEST_GPIO_OPEN_BYLABEL == 1 - /* Configure MIO0 as input */ - GpiodRegular* testGpio = new GpiodRegular("MIO0", Direction::OUT, 0, "/amba_pl/gpio@41200000", 0); -#elif OBSW_TEST_GPIO_OPEN_BY_LINE_NAME - GpiodRegularByLineName* testGpio = - new GpiodRegularByLineName("test-name", "gpio-test", Direction::OUT, 0); -#else - /* Configure MIO0 as input */ - GpiodRegular* testGpio = new GpiodRegular("gpiochip0", 0, "MIO0", gpio::IN, 0); -#endif /* OBSW_TEST_GPIO_LABEL == 1 */ - GpioCookie* gpioCookie = new GpioCookie; - gpioCookie->addGpio(gpioIds::TEST_ID_0, testGpio); - new LibgpiodTest(objects::LIBGPIOD_TEST, objects::GPIO_IF, gpioCookie); -#endif - -#if BOARD_TE0720 == 1 && OBSW_TEST_SUS == 1 - GpioCookie* gpioCookieSus = new GpioCookie; - GpiodRegular* chipSelectSus = new GpiodRegular( - std::string("gpiochip1"), 9, std::string("Chip Select Sus Sensor"), Direction::OUT, 1); - gpioCookieSus->addGpio(gpioIds::CS_SUS_0, chipSelectSus); - gpioComIF->addGpios(gpioCookieSus); - - SpiCookie* spiCookieSus = - new SpiCookie(addresses::SUS_0, std::string("/dev/spidev1.0"), SUS::MAX_CMD_SIZE, - spi::DEFAULT_MAX_1227_MODE, spi::DEFAULT_MAX_1227_SPEED); - - new SusHandler(objects::SUS_0, objects::SPI_COM_IF, spiCookieSus, gpioComIF, gpioIds::CS_SUS_0); -#endif - -#if BOARD_TE0720 == 1 && OBSW_TEST_CCSDS_BRIDGE == 1 - GpioCookie* gpioCookieCcsdsIp = new GpioCookie; - GpiodRegular* papbBusyN = - new GpiodRegular(std::string("gpiochip0"), 0, std::string("PAPBBusy_VC0")); - gpioCookieCcsdsIp->addGpio(gpioIds::PAPB_BUSY_N, papbBusyN); - GpiodRegular* papbEmpty = - new GpiodRegular(std::string("gpiochip0"), 1, std::string("PAPBEmpty_VC0")); - gpioCookieCcsdsIp->addGpio(gpioIds::PAPB_EMPTY, papbEmpty); - gpioComIF->addGpios(gpioCookieCcsdsIp); - - new CCSDSIPCoreBridge(objects::CCSDS_IP_CORE_BRIDGE, objects::CCSDS_PACKET_DISTRIBUTOR, - objects::TM_STORE, objects::TC_STORE, gpioComIF, std::string("/dev/uio0"), - gpioIds::PAPB_BUSY_N, gpioIds::PAPB_EMPTY); -#endif - -#if BOARD_TE0720 == 1 && OBSW_TEST_RAD_SENSOR == 1 - GpioCookie* gpioCookieRadSensor = new GpioCookie; - GpiodRegular* chipSelectRadSensor = new GpiodRegular( - std::string("gpiochip1"), 0, std::string("Chip select radiation sensor"), Direction::OUT, 1); - gpioCookieRadSensor->addGpio(gpioIds::CS_RAD_SENSOR, chipSelectRadSensor); - gpioComIF->addGpios(gpioCookieRadSensor); - - SpiCookie* spiCookieRadSensor = - new SpiCookie(addresses::RAD_SENSOR, gpioIds::CS_RAD_SENSOR, std::string("/dev/spidev1.0"), - SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE, spi::DEFAULT_MAX_1227_SPEED); - - RadiationSensorHandler* radSensor = - new RadiationSensorHandler(objects::RAD_SENSOR, objects::SPI_COM_IF, spiCookieRadSensor); - radSensor->setStartUpImmediately(); -#endif - -#if BOARD_TE0720 == 1 && OBSW_ADD_PLOC_MPSOC == 1 - UartCookie* plocUartCookie = - new UartCookie(std::string("/dev/ttyPS1"), 115200, PLOC_MPSOC::MAX_REPLY_SIZE); - /* Testing PlocMPSoCHandler on TE0720-03-1CFA */ - PlocMPSoCHandler* mpsocPlocHandler = - new PlocMPSoCHandler(objects::PLOC_MPSOC_HANDLER, objects::UART_COM_IF, plocUartCookie); - mpsocPlocHandler->setStartUpImmediately(); -#endif - -#if BOARD_TE0720 == 1 && OBSW_TEST_TE7020_HEATER == 1 - /* Configuration for MIO0 on TE0720-03-1CFA */ - GpiodRegular* heaterGpio = - new GpiodRegular(std::string("gpiochip0"), 0, std::string("MIO0"), gpio::IN, 0); - GpioCookie* gpioCookie = new GpioCookie; - gpioCookie->addGpio(gpioIds::HEATER_0, heaterGpio); - new HeaterHandler(objects::HEATER_HANDLER, objects::GPIO_IF, gpioCookie, objects::PCDU_HANDLER, - pcduSwitches::TCS_BOARD_8V_HEATER_IN); -#endif - -#if BOARD_TE0720 == 1 && OBSW_ADD_PLOC_SUPERVISOR == 1 - /* Configuration for MIO0 on TE0720-03-1CFA */ - UartCookie* plocSupervisorCookie = - new UartCookie(objects::PLOC_SUPERVISOR_HANDLER, std::string("/dev/ttyPS1"), - UartModes::NON_CANONICAL, 115200, PLOC_SPV::MAX_PACKET_SIZE * 20); - plocSupervisorCookie->setNoFixedSizeReply(); - PlocSupervisorHandler* plocSupervisor = new PlocSupervisorHandler( - objects::PLOC_SUPERVISOR_HANDLER, objects::UART_COM_IF, plocSupervisorCookie); - plocSupervisor->setStartUpImmediately(); -#endif - #if OBSW_ADD_SPI_TEST_CODE == 1 new SpiTestClass(objects::SPI_TEST, gpioComIF); #endif diff --git a/bsp_q7s/core/ObjectFactory.h b/bsp_q7s/core/ObjectFactory.h index ff88db8e..958e8f86 100644 --- a/bsp_q7s/core/ObjectFactory.h +++ b/bsp_q7s/core/ObjectFactory.h @@ -26,6 +26,7 @@ void createHeaterComponents(); void createSolarArrayDeploymentComponents(); void createSyrlinksComponents(); void createRtdComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchIF* pwrSwitcher); +void createPayloadComponents(LinuxLibgpioIF* gpioComIF); void createReactionWheelComponents(LinuxLibgpioIF* gpioComIF); void createCcsdsComponents(LinuxLibgpioIF* gpioComIF); void createTestComponents(LinuxLibgpioIF* gpioComIF); diff --git a/bsp_q7s/core/obsw.cpp b/bsp_q7s/core/obsw.cpp index 197ca66b..aede1698 100644 --- a/bsp_q7s/core/obsw.cpp +++ b/bsp_q7s/core/obsw.cpp @@ -15,7 +15,7 @@ static int OBSW_ALREADY_RUNNING = -2; int obsw::obsw() { using namespace fsfw; std::cout << "-- EIVE OBSW --" << std::endl; -#if BOARD_TE0720 == 0 +#ifdef TE0720_1CFA std::cout << "-- Compiled for Linux (Xiphos Q7S) --" << std::endl; #else std::cout << "-- Compiled for Linux (TE0720) --" << std::endl; diff --git a/bsp_q7s/memory/CMakeLists.txt b/bsp_q7s/memory/CMakeLists.txt index 0658242a..a0d4f66f 100644 --- a/bsp_q7s/memory/CMakeLists.txt +++ b/bsp_q7s/memory/CMakeLists.txt @@ -2,4 +2,5 @@ target_sources(${OBSW_NAME} PRIVATE FileSystemHandler.cpp SdCardManager.cpp scratchApi.cpp + FilesystemHelper.cpp ) \ No newline at end of file diff --git a/bsp_q7s/memory/FilesystemHelper.cpp b/bsp_q7s/memory/FilesystemHelper.cpp new file mode 100644 index 00000000..4b9140f1 --- /dev/null +++ b/bsp_q7s/memory/FilesystemHelper.cpp @@ -0,0 +1,40 @@ +#include "FilesystemHelper.h" + +#include +#include + +#include "bsp_q7s/memory/SdCardManager.h" +#include "fsfw/serviceinterface/ServiceInterfaceStream.h" + +FilesystemHelper::FilesystemHelper() {} + +FilesystemHelper::~FilesystemHelper() {} + +ReturnValue_t FilesystemHelper::checkPath(std::string path) { + SdCardManager* sdcMan = SdCardManager::instance(); + if (sdcMan == nullptr) { + sif::warning << "FilesystemHelper::checkPath: Invalid SD card manager" << std::endl; + return RETURN_FAILED; + } + if (path.substr(0, sizeof(SdCardManager::SD_0_MOUNT_POINT)) == + std::string(SdCardManager::SD_0_MOUNT_POINT)) { + if (!sdcMan->isSdCardMounted(sd::SLOT_0)) { + sif::warning << "FilesystemHelper::checkPath: SD card 0 not mounted" << std::endl; + return SD_NOT_MOUNTED; + } + } else if (path.substr(0, sizeof(SdCardManager::SD_1_MOUNT_POINT)) == + std::string(SdCardManager::SD_1_MOUNT_POINT)) { + if (!sdcMan->isSdCardMounted(sd::SLOT_0)) { + sif::warning << "FilesystemHelper::checkPath: SD card 1 not mounted" << std::endl; + return SD_NOT_MOUNTED; + } + } + return RETURN_OK; +} + +ReturnValue_t FilesystemHelper::fileExists(std::string file) { + if (not std::filesystem::exists(file)) { + return FILE_NOT_EXISTS; + } + return RETURN_OK; +} diff --git a/bsp_q7s/memory/FilesystemHelper.h b/bsp_q7s/memory/FilesystemHelper.h new file mode 100644 index 00000000..cb8e27a8 --- /dev/null +++ b/bsp_q7s/memory/FilesystemHelper.h @@ -0,0 +1,49 @@ +#ifndef BSP_Q7S_MEMORY_FILESYSTEMHELPER_H_ +#define BSP_Q7S_MEMORY_FILESYSTEMHELPER_H_ + +#include + +#include "commonClassIds.h" +#include "fsfw/returnvalues/HasReturnvaluesIF.h" + +/** + * @brief This class implements often used functions concerning the file system management. + * + * @author J. Meier + */ +class FilesystemHelper : public HasReturnvaluesIF { + public: + static const uint8_t INTERFACE_ID = CLASS_ID::FILE_SYSTEM_HELPER; + + //! [EXPORT] : [COMMENT] SD card specified with path string not mounted + static const ReturnValue_t SD_NOT_MOUNTED = MAKE_RETURN_CODE(0xA0); + //! [EXPORT] : [COMMENT] Specified file does not exist on filesystem + static const ReturnValue_t FILE_NOT_EXISTS = MAKE_RETURN_CODE(0xA1); + + FilesystemHelper(); + virtual ~FilesystemHelper(); + + /** + * @brief In case the path points to a directory on the sd card the function checks if the + * appropriate SD card is mounted. + * + * @param path Path to check + * + * @return RETURN_OK if path points to SD card and the appropriate SD card is mounted or if + * path does not point to SD card. + * Return error code if path points to SD card and the corresponding SD card is not + * mounted. + */ + static ReturnValue_t checkPath(std::string path); + + /** + * @brief Checks if the file exists on the filesystem. + * + * param file File to check + * + * @return RETURN_OK if fiel exists, otherwise return error code. + */ + static ReturnValue_t fileExists(std::string file); +}; + +#endif /* BSP_Q7S_MEMORY_FILESYSTEMHELPER_H_ */ diff --git a/bsp_te0720_1cfa/CMakeLists.txt b/bsp_te0720_1cfa/CMakeLists.txt new file mode 100644 index 00000000..cb02f937 --- /dev/null +++ b/bsp_te0720_1cfa/CMakeLists.txt @@ -0,0 +1,7 @@ +target_sources(${OBSW_NAME} PUBLIC + InitMission.cpp + main.cpp + ObjectFactory.cpp +) + +add_subdirectory(boardconfig) diff --git a/bsp_te0720_1cfa/InitMission.cpp b/bsp_te0720_1cfa/InitMission.cpp new file mode 100644 index 00000000..6b39cfb6 --- /dev/null +++ b/bsp_te0720_1cfa/InitMission.cpp @@ -0,0 +1,188 @@ +#include "InitMission.h" + +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include "OBSWConfig.h" +#include "ObjectFactory.h" +#include "objects/systemObjectList.h" +#include "pollingsequence/pollingSequenceFactory.h" + +ServiceInterfaceStream sif::debug("DEBUG"); +ServiceInterfaceStream sif::info("INFO"); +ServiceInterfaceStream sif::warning("WARNING"); +ServiceInterfaceStream sif::error("ERROR"); + +ObjectManagerIF* objectManager = nullptr; + +void initmission::initMission() { + sif::info << "Building global objects.." << std::endl; + /* Instantiate global object manager and also create all objects */ + ObjectManager::instance()->setObjectFactoryFunction(ObjectFactory::produce, nullptr); + sif::info << "Initializing all objects.." << std::endl; + ObjectManager::instance()->initialize(); + + /* This function creates and starts all tasks */ + initTasks(); +} + +void initmission::initTasks() { + TaskFactory* factory = TaskFactory::instance(); + ReturnValue_t result = HasReturnvaluesIF::RETURN_OK; + if (factory == nullptr) { + /* Should never happen ! */ + return; + } +#if OBSW_PRINT_MISSED_DEADLINES == 1 + void (*missedDeadlineFunc)(void) = TaskFactory::printMissedDeadline; +#else + void (*missedDeadlineFunc)(void) = nullptr; +#endif + + /* TMTC Distribution */ + PeriodicTaskIF* tmtcDistributor = factory->createPeriodicTask( + "DIST", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc); + result = tmtcDistributor->addComponent(objects::CCSDS_PACKET_DISTRIBUTOR); + if (result != HasReturnvaluesIF::RETURN_OK) { + sif::error << "Object add component failed" << std::endl; + } + result = tmtcDistributor->addComponent(objects::PUS_PACKET_DISTRIBUTOR); + if (result != HasReturnvaluesIF::RETURN_OK) { + sif::error << "Object add component failed" << std::endl; + } + result = tmtcDistributor->addComponent(objects::TM_FUNNEL); + if (result != HasReturnvaluesIF::RETURN_OK) { + sif::error << "Object add component failed" << std::endl; + } + + PeriodicTaskIF* tmtcBridgeTask = factory->createPeriodicTask( + "TMTC_BRIDGE", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc); + result = tmtcBridgeTask->addComponent(objects::TMTC_BRIDGE); + if (result != HasReturnvaluesIF::RETURN_OK) { + sif::error << "Add component TMTC Bridge failed" << std::endl; + } + PeriodicTaskIF* tmtcPollingTask = factory->createPeriodicTask( + "TMTC_POLLING", 80, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc); + result = tmtcPollingTask->addComponent(objects::TMTC_POLLING_TASK); + if (result != HasReturnvaluesIF::RETURN_OK) { + sif::error << "Add component TMTC Polling failed" << std::endl; + } + + /* PUS Services */ + std::vector pusTasks; + createPusTasks(*factory, missedDeadlineFunc, pusTasks); + + std::vector pstTasks; + FixedTimeslotTaskIF* pst = factory->createFixedTimeslotTask( + "UART_PST", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 0.5, missedDeadlineFunc); + result = pst::pstUart(pst); + if (result != HasReturnvaluesIF::RETURN_OK) { + sif::error << "InitMission::initTasks: Creating PST failed!" << std::endl; + } + pstTasks.push_back(pst); + + PeriodicTaskIF* mpsocHelperTask = factory->createPeriodicTask( + "PLOC_MPSOC_HELPER", 20, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc); + result = mpsocHelperTask->addComponent(objects::PLOC_MPSOC_HELPER); + if (result != HasReturnvaluesIF::RETURN_OK) { + initmission::printAddObjectError("PLOC_MPSOC_HELPER", objects::PLOC_MPSOC_HELPER); + } + pstTasks.push_back(mpsocHelperTask); + + auto taskStarter = [](std::vector& taskVector, std::string name) { + for (const auto& task : taskVector) { + if (task != nullptr) { + task->startTask(); + } else { + sif::error << "Task in vector " << name << " is invalid!" << std::endl; + } + } + }; + + sif::info << "Starting tasks.." << std::endl; + tmtcDistributor->startTask(); + tmtcBridgeTask->startTask(); + tmtcPollingTask->startTask(); + + taskStarter(pstTasks, "PST Tasks"); + taskStarter(pusTasks, "PUS Tasks"); + + sif::info << "Tasks started.." << std::endl; +} + +void initmission::createPusTasks(TaskFactory& factory, + TaskDeadlineMissedFunction missedDeadlineFunc, + std::vector& taskVec) { + ReturnValue_t result = HasReturnvaluesIF::RETURN_OK; + PeriodicTaskIF* pusVerification = factory.createPeriodicTask( + "PUS_VERIF", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc); + result = pusVerification->addComponent(objects::PUS_SERVICE_1_VERIFICATION); + if (result != HasReturnvaluesIF::RETURN_OK) { + sif::error << "Object add component failed" << std::endl; + } + taskVec.push_back(pusVerification); + + PeriodicTaskIF* pusEvents = factory.createPeriodicTask( + "PUS_EVENTS", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc); + result = pusEvents->addComponent(objects::PUS_SERVICE_5_EVENT_REPORTING); + if (result != HasReturnvaluesIF::RETURN_OK) { + initmission::printAddObjectError("PUS_EVENTS", objects::PUS_SERVICE_5_EVENT_REPORTING); + } + result = pusEvents->addComponent(objects::EVENT_MANAGER); + if (result != HasReturnvaluesIF::RETURN_OK) { + initmission::printAddObjectError("PUS_MGMT", objects::EVENT_MANAGER); + } + taskVec.push_back(pusEvents); + + PeriodicTaskIF* pusHighPrio = factory.createPeriodicTask( + "PUS_HIGH_PRIO", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc); + result = pusHighPrio->addComponent(objects::PUS_SERVICE_2_DEVICE_ACCESS); + if (result != HasReturnvaluesIF::RETURN_OK) { + initmission::printAddObjectError("PUS2", objects::PUS_SERVICE_2_DEVICE_ACCESS); + } + result = pusHighPrio->addComponent(objects::PUS_SERVICE_9_TIME_MGMT); + if (result != HasReturnvaluesIF::RETURN_OK) { + initmission::printAddObjectError("PUS9", objects::PUS_SERVICE_9_TIME_MGMT); + } + taskVec.push_back(pusHighPrio); + + PeriodicTaskIF* pusMedPrio = factory.createPeriodicTask( + "PUS_MED_PRIO", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.8, missedDeadlineFunc); + result = pusMedPrio->addComponent(objects::PUS_SERVICE_8_FUNCTION_MGMT); + if (result != HasReturnvaluesIF::RETURN_OK) { + initmission::printAddObjectError("PUS8", objects::PUS_SERVICE_8_FUNCTION_MGMT); + } + result = pusMedPrio->addComponent(objects::PUS_SERVICE_200_MODE_MGMT); + if (result != HasReturnvaluesIF::RETURN_OK) { + initmission::printAddObjectError("PUS200", objects::PUS_SERVICE_200_MODE_MGMT); + } + result = pusMedPrio->addComponent(objects::PUS_SERVICE_20_PARAMETERS); + if (result != HasReturnvaluesIF::RETURN_OK) { + initmission::printAddObjectError("PUS20", objects::PUS_SERVICE_20_PARAMETERS); + } + result = pusMedPrio->addComponent(objects::PUS_SERVICE_3_HOUSEKEEPING); + if (result != HasReturnvaluesIF::RETURN_OK) { + initmission::printAddObjectError("PUS3", objects::PUS_SERVICE_3_HOUSEKEEPING); + } + taskVec.push_back(pusMedPrio); + + PeriodicTaskIF* pusLowPrio = factory.createPeriodicTask( + "PUS_LOW_PRIO", 30, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.6, missedDeadlineFunc); + result = pusLowPrio->addComponent(objects::PUS_SERVICE_17_TEST); + if (result != HasReturnvaluesIF::RETURN_OK) { + initmission::printAddObjectError("PUS17", objects::PUS_SERVICE_17_TEST); + } + result = pusLowPrio->addComponent(objects::INTERNAL_ERROR_REPORTER); + if (result != HasReturnvaluesIF::RETURN_OK) { + initmission::printAddObjectError("INT_ERR_RPRT", objects::INTERNAL_ERROR_REPORTER); + } + taskVec.push_back(pusLowPrio); +} diff --git a/bsp_te0720_1cfa/InitMission.h b/bsp_te0720_1cfa/InitMission.h new file mode 100644 index 00000000..c3ba58ec --- /dev/null +++ b/bsp_te0720_1cfa/InitMission.h @@ -0,0 +1,21 @@ +#ifndef BSP_LINUX_INITMISSION_H_ +#define BSP_LINUX_INITMISSION_H_ + +#include + +#include "fsfw/tasks/Typedef.h" + +class PeriodicTaskIF; +class TaskFactory; + +namespace initmission { +void initMission(); +void initTasks(); + +void createPstTasks(TaskFactory& factory, TaskDeadlineMissedFunction missedDeadlineFunc, + std::vector& taskVec); +void createPusTasks(TaskFactory& factory, TaskDeadlineMissedFunction missedDeadlineFunc, + std::vector& taskVec); +}; // namespace initmission + +#endif /* BSP_LINUX_INITMISSION_H_ */ diff --git a/bsp_te0720_1cfa/ObjectFactory.cpp b/bsp_te0720_1cfa/ObjectFactory.cpp new file mode 100644 index 00000000..757cf31c --- /dev/null +++ b/bsp_te0720_1cfa/ObjectFactory.cpp @@ -0,0 +1,152 @@ +#include "ObjectFactory.h" + +#include +#include "fsfw_hal/linux/uart/UartComIF.h" +#include "fsfw_hal/linux/i2c/I2cComIF.h" +#include "fsfw_hal/linux/uart/UartCookie.h" + +#include "OBSWConfig.h" +#include "busConf.h" +#include "devConf.h" +#include "fsfw/datapoollocal/LocalDataPoolManager.h" +#include "fsfw/tmtcpacket/pus/tm.h" +#include "fsfw/tmtcservices/CommandingServiceBase.h" +#include "fsfw/tmtcservices/PusServiceBase.h" +#include "fsfw_hal/linux/i2c/I2cCookie.h" +#include "linux/devices/ploc/PlocMPSoCHandler.h" +#include "linux/devices/ploc/PlocMPSoCHelper.h" +#include "mission/devices/Tmp1075Handler.h" +#include "mission/core/GenericFactory.h" +#include "mission/utility/TmFunnel.h" +#include "test/gpio/DummyGpioIF.h" +#include "objects/systemObjectList.h" +#include "devices/addresses.h" +#include "devices/gpioIds.h" +#include "tmtc/apid.h" +#include "tmtc/pusIds.h" + +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; + + TmFunnel::downlinkDestination = objects::TMTC_BRIDGE; + TmFunnel::storageDestination = objects::NO_OBJECT; + + VerificationReporter::messageReceiver = objects::PUS_SERVICE_1_VERIFICATION; + TmPacketBase::timeStamperId = objects::TIME_STAMPER; +} + +void ObjectFactory::produce(void* args) { + Factory::setStaticFrameworkObjectIds(); + ObjectFactory::produceGenericObjects(); + +#if OBSW_ADD_PLOC_MPSOC == 1 + UartCookie* mpsocUartCookie = + new UartCookie(objects::PLOC_MPSOC_HANDLER, te0720_1cfa::MPSOC_UART, UartModes::NON_CANONICAL, + uart::PLOC_MPSOC_BAUD, mpsoc::MAX_REPLY_SIZE); + mpsocUartCookie->setNoFixedSizeReply(); + PlocMPSoCHelper* plocMpsocHelper = new PlocMPSoCHelper(objects::PLOC_MPSOC_HELPER); + new UartComIF(objects::UART_COM_IF); + auto dummyGpioIF = new DummyGpioIF(); + PlocMPSoCHandler* plocMPSoCHandler = + new PlocMPSoCHandler(objects::PLOC_MPSOC_HANDLER, objects::UART_COM_IF, mpsocUartCookie, + plocMpsocHelper, Gpio(gpioIds::ENABLE_MPSOC_UART, dummyGpioIF)); + plocMPSoCHandler->setStartUpImmediately(); +#endif /* OBSW_ADD_PLOC_MPSOC == 1 */ + +#if OBSW_TEST_LIBGPIOD == 1 +#if OBSW_TEST_GPIO_OPEN_BYLABEL == 1 + /* Configure MIO0 as input */ + GpiodRegular* testGpio = new GpiodRegular("MIO0", Direction::OUT, 0, "/amba_pl/gpio@41200000", 0); +#elif OBSW_TEST_GPIO_OPEN_BY_LINE_NAME + GpiodRegularByLineName* testGpio = + new GpiodRegularByLineName("test-name", "gpio-test", Direction::OUT, 0); +#else + /* Configure MIO0 as input */ + GpiodRegular* testGpio = new GpiodRegular("gpiochip0", 0, "MIO0", gpio::IN, 0); +#endif /* OBSW_TEST_GPIO_LABEL == 1 */ + GpioCookie* gpioCookie = new GpioCookie; + gpioCookie->addGpio(gpioIds::TEST_ID_0, testGpio); + new LibgpiodTest(objects::LIBGPIOD_TEST, objects::GPIO_IF, gpioCookie); +#endif + +#if OBSW_TEST_SUS == 1 + GpioCookie* gpioCookieSus = new GpioCookie; + GpiodRegular* chipSelectSus = new GpiodRegular( + std::string("gpiochip1"), 9, std::string("Chip Select Sus Sensor"), Direction::OUT, 1); + gpioCookieSus->addGpio(gpioIds::CS_SUS_0, chipSelectSus); + gpioComIF->addGpios(gpioCookieSus); + + SpiCookie* spiCookieSus = + new SpiCookie(addresses::SUS_0, std::string("/dev/spidev1.0"), SUS::MAX_CMD_SIZE, + spi::DEFAULT_MAX_1227_MODE, spi::DEFAULT_MAX_1227_SPEED); + + new SusHandler(objects::SUS_0, objects::SPI_COM_IF, spiCookieSus, gpioComIF, gpioIds::CS_SUS_0); +#endif + +#if OBSW_TEST_CCSDS_BRIDGE == 1 + GpioCookie* gpioCookieCcsdsIp = new GpioCookie; + GpiodRegular* papbBusyN = + new GpiodRegular(std::string("gpiochip0"), 0, std::string("PAPBBusy_VC0")); + gpioCookieCcsdsIp->addGpio(gpioIds::PAPB_BUSY_N, papbBusyN); + GpiodRegular* papbEmpty = + new GpiodRegular(std::string("gpiochip0"), 1, std::string("PAPBEmpty_VC0")); + gpioCookieCcsdsIp->addGpio(gpioIds::PAPB_EMPTY, papbEmpty); + gpioComIF->addGpios(gpioCookieCcsdsIp); + + new CCSDSIPCoreBridge(objects::CCSDS_IP_CORE_BRIDGE, objects::CCSDS_PACKET_DISTRIBUTOR, + objects::TM_STORE, objects::TC_STORE, gpioComIF, std::string("/dev/uio0"), + gpioIds::PAPB_BUSY_N, gpioIds::PAPB_EMPTY); +#endif + +#if OBSW_TEST_RAD_SENSOR == 1 + GpioCookie* gpioCookieRadSensor = new GpioCookie; + GpiodRegular* chipSelectRadSensor = new GpiodRegular( + std::string("gpiochip1"), 0, std::string("Chip select radiation sensor"), Direction::OUT, 1); + gpioCookieRadSensor->addGpio(gpioIds::CS_RAD_SENSOR, chipSelectRadSensor); + gpioComIF->addGpios(gpioCookieRadSensor); + + SpiCookie* spiCookieRadSensor = + new SpiCookie(addresses::RAD_SENSOR, gpioIds::CS_RAD_SENSOR, std::string("/dev/spidev1.0"), + SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE, spi::DEFAULT_MAX_1227_SPEED); + + RadiationSensorHandler* radSensor = + new RadiationSensorHandler(objects::RAD_SENSOR, objects::SPI_COM_IF, spiCookieRadSensor); + radSensor->setStartUpImmediately(); +#endif + +#if OBSW_TEST_TE7020_HEATER == 1 + /* Configuration for MIO0 on TE0720-03-1CFA */ + GpiodRegular* heaterGpio = + new GpiodRegular(std::string("gpiochip0"), 0, std::string("MIO0"), gpio::IN, 0); + GpioCookie* gpioCookie = new GpioCookie; + gpioCookie->addGpio(gpioIds::HEATER_0, heaterGpio); + new HeaterHandler(objects::HEATER_HANDLER, objects::GPIO_IF, gpioCookie, objects::PCDU_HANDLER, + pcduSwitches::TCS_BOARD_8V_HEATER_IN); +#endif + +#if OBSW_ADD_PLOC_SUPERVISOR == 1 + /* Configuration for MIO0 on TE0720-03-1CFA */ + UartCookie* plocSupervisorCookie = + new UartCookie(objects::PLOC_SUPERVISOR_HANDLER, std::string("/dev/ttyPS1"), + UartModes::NON_CANONICAL, 115200, PLOC_SPV::MAX_PACKET_SIZE * 20); + plocSupervisorCookie->setNoFixedSizeReply(); + PlocSupervisorHandler* plocSupervisor = new PlocSupervisorHandler( + objects::PLOC_SUPERVISOR_HANDLER, objects::UART_COM_IF, plocSupervisorCookie); + plocSupervisor->setStartUpImmediately(); +#endif + +new I2cComIF(objects::I2C_COM_IF); + +I2cCookie* i2cCookieTmp1075tcs1 = + new I2cCookie(addresses::TMP1075_TCS_1, TMP1075::MAX_REPLY_LENGTH, std::string("/dev/i2c-0")); +I2cCookie* i2cCookieTmp1075tcs2 = + new I2cCookie(addresses::TMP1075_TCS_2, TMP1075::MAX_REPLY_LENGTH, std::string("/dev/i2c-0")); + +/* Temperature sensors */ +new Tmp1075Handler(objects::TMP1075_HANDLER_1, objects::I2C_COM_IF, i2cCookieTmp1075tcs1); +new Tmp1075Handler(objects::TMP1075_HANDLER_2, objects::I2C_COM_IF, i2cCookieTmp1075tcs2); +} diff --git a/bsp_te0720_1cfa/ObjectFactory.h b/bsp_te0720_1cfa/ObjectFactory.h new file mode 100644 index 00000000..b24dd321 --- /dev/null +++ b/bsp_te0720_1cfa/ObjectFactory.h @@ -0,0 +1,8 @@ +#ifndef BSP_LINUX_OBJECTFACTORY_H_ +#define BSP_LINUX_OBJECTFACTORY_H_ + +namespace ObjectFactory { +void produce(void* args); +}; // namespace ObjectFactory + +#endif /* BSP_LINUX_OBJECTFACTORY_H_ */ diff --git a/bsp_te0720_1cfa/boardconfig/CMakeLists.txt b/bsp_te0720_1cfa/boardconfig/CMakeLists.txt new file mode 100644 index 00000000..f9136e3e --- /dev/null +++ b/bsp_te0720_1cfa/boardconfig/CMakeLists.txt @@ -0,0 +1,7 @@ +target_sources(${OBSW_NAME} PRIVATE + print.c +) + +target_include_directories(${OBSW_NAME} PUBLIC + ${CMAKE_CURRENT_SOURCE_DIR} +) diff --git a/bsp_te0720_1cfa/boardconfig/busConf.h b/bsp_te0720_1cfa/boardconfig/busConf.h new file mode 100644 index 00000000..893014c1 --- /dev/null +++ b/bsp_te0720_1cfa/boardconfig/busConf.h @@ -0,0 +1,11 @@ +#ifndef BSP_EGSE_BOARDCONFIG_BUSCONF_H_ +#define BSP_EGSE_BOARDCONFIG_BUSCONF_H_ + +namespace te0720_1cfa { +static constexpr char MPSOC_UART[] = "/dev/ttyPS1"; +namespace baudrate { + +} +} + +#endif /* BSP_EGSE_BOARDCONFIG_BUSCONF_H_ */ diff --git a/bsp_te0720_1cfa/boardconfig/etl_profile.h b/bsp_te0720_1cfa/boardconfig/etl_profile.h new file mode 100644 index 00000000..54aca344 --- /dev/null +++ b/bsp_te0720_1cfa/boardconfig/etl_profile.h @@ -0,0 +1,38 @@ +///\file + +/****************************************************************************** +The MIT License(MIT) + +Embedded Template Library. +https://github.com/ETLCPP/etl +https://www.etlcpp.com + +Copyright(c) 2019 jwellbelove + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files(the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and / or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions : + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +******************************************************************************/ +#ifndef __ETL_PROFILE_H__ +#define __ETL_PROFILE_H__ + +#define ETL_CHECK_PUSH_POP + +#define ETL_CPP11_SUPPORTED 1 +#define ETL_NO_NULLPTR_SUPPORT 0 + +#endif diff --git a/bsp_te0720_1cfa/boardconfig/gcov.h b/bsp_te0720_1cfa/boardconfig/gcov.h new file mode 100644 index 00000000..80acdd86 --- /dev/null +++ b/bsp_te0720_1cfa/boardconfig/gcov.h @@ -0,0 +1,15 @@ +#ifndef LINUX_GCOV_H_ +#define LINUX_GCOV_H_ +#include + +#ifdef GCOV +extern "C" void __gcov_flush(); +#else +void __gcov_flush() { + sif::info << "GCC GCOV: Please supply GCOV=1 in Makefile if " + "coverage information is desired.\n" + << std::flush; +} +#endif + +#endif /* LINUX_GCOV_H_ */ diff --git a/bsp_te0720_1cfa/boardconfig/print.c b/bsp_te0720_1cfa/boardconfig/print.c new file mode 100644 index 00000000..1739e90b --- /dev/null +++ b/bsp_te0720_1cfa/boardconfig/print.c @@ -0,0 +1,10 @@ +#include +#include + +void printChar(const char* character, bool errStream) { + if (errStream) { + putc(*character, stderr); + return; + } + putc(*character, stdout); +} diff --git a/bsp_te0720_1cfa/boardconfig/print.h b/bsp_te0720_1cfa/boardconfig/print.h new file mode 100644 index 00000000..8e7e2e5d --- /dev/null +++ b/bsp_te0720_1cfa/boardconfig/print.h @@ -0,0 +1,8 @@ +#ifndef HOSTED_BOARDCONFIG_PRINT_H_ +#define HOSTED_BOARDCONFIG_PRINT_H_ + +#include + +void printChar(const char* character, bool errStream); + +#endif /* HOSTED_BOARDCONFIG_PRINT_H_ */ diff --git a/bsp_te0720_1cfa/main.cpp b/bsp_te0720_1cfa/main.cpp new file mode 100644 index 00000000..cb7d987e --- /dev/null +++ b/bsp_te0720_1cfa/main.cpp @@ -0,0 +1,29 @@ +#include + +#include "InitMission.h" +#include "OBSWConfig.h" +#include "OBSWVersion.h" +#include "fsfw/version.h" +#include "fsfw/tasks/TaskFactory.h" + +/** + * @brief This is the main program entry point for the obsw running on the trenz electronic + * te0720-1cfa. + * @return + */ +int main(void) { + using namespace fsfw; + std::cout << "-- EIVE OBSW --" << std::endl; + std::cout << "-- Compiled for Trenz TE0720-1CFA" + << " --" << std::endl; + std::cout << "-- OBSW v" << SW_VERSION << "." << SW_SUBVERSION << "." << SW_REVISION << ", FSFW v" + << FSFW_VERSION << "--" << std::endl; + std::cout << "-- " << __DATE__ << " " << __TIME__ << " --" << std::endl; + + initmission::initMission(); + + for (;;) { + /* Suspend main thread by sleeping it. */ + TaskFactory::delayTask(5000); + } +} diff --git a/cmake/HardwareOsPreConfig.cmake b/cmake/HardwareOsPreConfig.cmake index 88df808c..7b90eb54 100644 --- a/cmake/HardwareOsPreConfig.cmake +++ b/cmake/HardwareOsPreConfig.cmake @@ -59,6 +59,8 @@ if(TGT_BSP) set(BSP_PATH "bsp_q7s") elseif(TGT_BSP MATCHES "arm/egse") set(BSP_PATH "bsp_egse") + elseif(TGT_BSP MATCHES "arm/te0720-1cfa") + set(BSP_PATH "bsp_te0720_1cfa") else() message(WARNING "CMake not configured for this target!") message(FATAL_ERROR "Target: ${TGT_BSP}!") diff --git a/cmake/PreProjectConfig.cmake b/cmake/PreProjectConfig.cmake index fa50baf3..41dd7de4 100644 --- a/cmake/PreProjectConfig.cmake +++ b/cmake/PreProjectConfig.cmake @@ -12,9 +12,9 @@ endif() # Disable compiler checks for cross-compiling. if(FSFW_OSAL MATCHES linux AND TGT_BSP) - if(TGT_BSP MATCHES "arm/q7s") + if(TGT_BSP MATCHES "arm/q7s" OR TGT_BSP MATCHES "arm/te0720-1cfa") set(CMAKE_TOOLCHAIN_FILE - "${CMAKE_SCRIPT_PATH}/Q7SCrossCompileConfig.cmake" + "${CMAKE_SCRIPT_PATH}/Zynq7020CrossCompileConfig.cmake" PARENT_SCOPE ) elseif(TGT_BSP MATCHES "arm/raspberrypi" OR TGT_BSP MATCHES "arm/egse") diff --git a/cmake/Q7SCrossCompileConfig.cmake b/cmake/Zynq7020CrossCompileConfig.cmake similarity index 87% rename from cmake/Q7SCrossCompileConfig.cmake rename to cmake/Zynq7020CrossCompileConfig.cmake index db05c8f0..be6702a1 100644 --- a/cmake/Q7SCrossCompileConfig.cmake +++ b/cmake/Zynq7020CrossCompileConfig.cmake @@ -1,16 +1,16 @@ -if(DEFINED ENV{Q7S_SYSROOT}) - set(ENV{Q7S_ROOTFS} $ENV{Q7S_SYSROOT}) +if(DEFINED ENV{ZYNQ_7020_SYSROOT}) + set(ENV{ZYNQ_7020_ROOTFS} $ENV{ZYNQ_7020_SYSROOT}) endif() # CROSS_COMPILE also needs to be set accordingly or passed to the CMake command -if(NOT DEFINED ENV{Q7S_ROOTFS}) +if(NOT DEFINED ENV{ZYNQ_7020_ROOTFS}) # Sysroot has not been cached yet and was not set in environment either if(NOT DEFINED SYSROOT_PATH) message(FATAL_ERROR - "Define the Q7S_ROOTFS variable to point to the Q7S rootfs." + "Define the ZYNQ_7020_ROOTFS variable to point to the Zynq-7020 rootfs." ) endif() else() - set(SYSROOT_PATH "$ENV{Q7S_ROOTFS}" CACHE PATH "Q7S root filesystem path") + set(SYSROOT_PATH "$ENV{ZYNQ_7020_ROOTFS}" CACHE PATH "Zynq-7020 root filesystem path") endif() if(NOT DEFINED ENV{CROSS_COMPILE}) @@ -87,18 +87,21 @@ set(C_FLAGS -mfloat-abi=hard ${COMMON_FLAGS} -lgpiod - -lxiphos ) +if (TGT_BSP MATCHES "arm/q7s") + set(C_FLAGS ${C_FLAGS} -lxiphos) +endif() + string (REPLACE ";" " " C_FLAGS "${C_FLAGS}") set(CMAKE_C_FLAGS ${C_FLAGS} - CACHE STRING "C flags for Q7S" + CACHE STRING "C flags for Zynq-7020" ) set(CMAKE_CXX_FLAGS "${CMAKE_C_FLAGS}" - CACHE STRING "CPP flags for Q7S" + CACHE STRING "CPP flags for Zynq-7020" ) # search for programs in the build host directories diff --git a/cmake/scripts/Q7S/q7s-env.sh b/cmake/scripts/Q7S/q7s-env.sh index 818ff213..df9dbadc 100755 --- a/cmake/scripts/Q7S/q7s-env.sh +++ b/cmake/scripts/Q7S/q7s-env.sh @@ -2,6 +2,6 @@ export PATH=$PATH:"$HOME/EIVE/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin" export CROSS_COMPILE="arm-linux-gnueabihf" -export Q7S_SYSROOT="$HOME/Xilinx/cortexa9hf-neon-xiphos-linux-gnueabi" +export ZYNQ_7020_SYSROOT="$HOME/Xilinx/cortexa9hf-neon-xiphos-linux-gnueabi" export CONSOLE_PREFIX="[Q7S ENV]" /bin/bash diff --git a/cmake/scripts/Q7S/win-q7s-env.sh b/cmake/scripts/Q7S/win-q7s-env.sh new file mode 100644 index 00000000..703949e3 --- /dev/null +++ b/cmake/scripts/Q7S/win-q7s-env.sh @@ -0,0 +1,49 @@ +#!/bin/sh +# Run with: source win-q7s-env.sh [OPTIONS] +function help () { + echo "source win-q7s-env.sh [options] -t|--toolchain= -s|--sysroot=" +} + +TOOLCHAIN_PATH="/c/Xilinx/Vitis/2019.2/gnu/aarch32/nt/gcc-arm-linux-gnueabi/bin" +SYSROOT="/c/Users/${USER}/eive-software/cortexa9hf-neon-xiphos-linux-gnueabi" + +for i in "$@"; do + case $i in + -t=*|--toolchain=*) + TOOLCHAIN_PATH="${i#*=}" + shift + ;; + -s=*|--sysroot=*) + SYSROOT="${i#*=}" + shift + ;; + -h|--help) + help + shift + ;; + -*|--*) + echo "Unknown option $i" + help + return + ;; + *) + ;; + esac +done + +if [ -d "$TOOLCHAIN_PATH" ]; then + export PATH=$PATH:"/c/Xilinx/Vitis/2019.2/gnu/aarch32/nt/gcc-arm-linux-gnueabi/bin" + export CROSS_COMPILE="arm-linux-gnueabihf" + echo "Set toolchain path to /c/Xilinx/Vitis/2019.2/gnu/aarch32/nt/gcc-arm-linux-gnueabi/bin" +else + echo "Toolchain path $TOOLCHAIN_PATH does not exist" + return +fi + +if [ -d "$SYSROOT" ]; then + export ZYNQ_7020_SYSROOT=$SYSROOT + echo "Set sysroot path to $SYSROOT" +else + echo "Sysroot path $SYSROOT does not exist" + return +fi \ No newline at end of file diff --git a/cmake/scripts/cmake-build-cfg.py b/cmake/scripts/cmake-build-cfg.py index 5d1b1048..4c5ee536 100755 --- a/cmake/scripts/cmake-build-cfg.py +++ b/cmake/scripts/cmake-build-cfg.py @@ -12,6 +12,7 @@ import os import sys import argparse import shutil +import stat def main(): @@ -102,7 +103,7 @@ def main(): build_path = source_location + os.path.sep + build_folder remove_old_dir = False if remove_old_dir: - shutil.rmtree(build_path) + rm_build_dir(build_path) os.chdir(source_location) os.mkdir(build_folder) print(f"Navigating into build directory: {build_path}") @@ -117,6 +118,14 @@ def main(): print(f"\" {cmake_command} \"") os.system(cmake_command) print("-- CMake configuration done. --") + + +def rm_build_dir(path: str): + # On windows the permissions of the build directory may have been set to read-only. If this + # is the case the permissions are changed before trying to delete the directory. + if not os.access(path, os.W_OK): + os.chmod(path, stat.S_IWUSR) + shutil.rmtree(path) def determine_source_location() -> str: diff --git a/cmake/scripts/te0720-1cfa/make-debug-cfg.sh b/cmake/scripts/te0720-1cfa/make-debug-cfg.sh new file mode 100644 index 00000000..46008c41 --- /dev/null +++ b/cmake/scripts/te0720-1cfa/make-debug-cfg.sh @@ -0,0 +1,34 @@ +#!/bin/sh +counter=0 +cfg_script_name="cmake-build-cfg.py" +while [ ${counter} -lt 5 ] +do + cd .. + if [ -f ${cfg_script_name} ];then + break + fi + counter=$((counter=counter + 1)) +done + +if [ "${counter}" -ge 5 ];then + echo "${cfg_script_name} not found in upper directories!" + exit 1 +fi + + +os_fsfw="linux" +tgt_bsp="arm/te0720-1cfa" +build_generator="make" +build_dir="build-Debug-te0720-1cfa" +if [ "${OS}" = "Windows_NT" ]; then + python="py" +# Could be other OS but this works for now. +else + python="python3" +fi + +echo "Running command (without the leading +):" +set -x # Print command +${python} ${cfg_script_name} -o "${os_fsfw}" -g "${build_generator}" -b "debug" -t "${tgt_bsp}" \ + -l"${build_dir}" +# set +x diff --git a/cmake/scripts/Q7S/q7s-env-win.sh b/cmake/scripts/te0720-1cfa/win-env-te0720-1cfa.sh similarity index 87% rename from cmake/scripts/Q7S/q7s-env-win.sh rename to cmake/scripts/te0720-1cfa/win-env-te0720-1cfa.sh index 2cbc0bab..e77de4c8 100644 --- a/cmake/scripts/Q7S/q7s-env-win.sh +++ b/cmake/scripts/te0720-1cfa/win-env-te0720-1cfa.sh @@ -5,7 +5,7 @@ function help () { } TOOLCHAIN_PATH="/c/Xilinx/Vitis/2019.2/gnu/aarch32/nt/gcc-arm-linux-gnueabi/bin" -SYSROOT="/c/Users/${USER}/eive-software/cortexa9hf-neon-xiphos-linux-gnueabi" +SYSROOT="/c/Users/${USER}/eive-software/sysroots-petalinux-2019-2/cortexa9t2hf-neon-xilinx-linux-gnueabi" for i in "$@"; do case $i in @@ -41,7 +41,7 @@ else fi if [ -d "$SYSROOT" ]; then - export Q7S_SYSROOT=$SYSROOT + export ZYNQ_7020_SYSROOT=$SYSROOT echo "Set sysroot path to $SYSROOT" else echo "Sysroot path $SYSROOT does not exist" diff --git a/common/config/commonClassIds.h b/common/config/commonClassIds.h index 01f186a4..03d51888 100644 --- a/common/config/commonClassIds.h +++ b/common/config/commonClassIds.h @@ -13,7 +13,8 @@ enum commonClassIds: uint8_t { IMTQ_HANDLER, //IMTQ RW_HANDLER, //RWHA STR_HANDLER, //STRH - PLOC_MPSOC_HANDLER, //PLMP + DWLPWRON_CMD, //DWLPWRON + MPSOC_TM, //MPTM PLOC_SUPERVISOR_HANDLER, //PLSV SUS_HANDLER, //SUSS CCSDS_IP_CORE_BRIDGE, //IPCI @@ -27,7 +28,10 @@ enum commonClassIds: uint8_t { RATE_SETTER, //RS ARCSEC_JSON_BASE, //JSONBASE NVM_PARAM_BASE, //NVMB + FILE_SYSTEM_HELPER, //FSHLP + PLOC_MPSOC_HELPER, // PLMPHLP SA_DEPL_HANDLER, //SADPL + MPSOC_RETURN_VALUES_IF, //MPSOCRTVIF COMMON_CLASS_ID_END // [EXPORT] : [END] }; diff --git a/common/config/commonObjects.h b/common/config/commonObjects.h index 2e7c8411..a4f3319e 100644 --- a/common/config/commonObjects.h +++ b/common/config/commonObjects.h @@ -42,6 +42,7 @@ enum commonObjects: uint32_t { IMTQ_HANDLER = 0x44140014, PLOC_MPSOC_HANDLER = 0x44330015, PLOC_SUPERVISOR_HANDLER = 0x44330016, + PLOC_SUPERVISOR_HELPER = 0x44330017, /** * Not yet specified which pt1000 will measure which device/location in the satellite. @@ -89,8 +90,9 @@ enum commonObjects: uint32_t { PLOC_UPDATER = 0x44330000, PLOC_MEMORY_DUMPER = 0x44330001, STR_HELPER = 0x44330002, - AXI_PTME_CONFIG = 44330003, - PTME_CONFIG = 44330004, + PLOC_MPSOC_HELPER = 0x44330003, + AXI_PTME_CONFIG = 44330004, + PTME_CONFIG = 44330005, // 0x73 ('s') for assemblies and system/subsystem components ACS_BOARD_ASS = 0x73000001, diff --git a/common/config/commonSubsystemIds.h b/common/config/commonSubsystemIds.h index 77a3a810..a93986a1 100644 --- a/common/config/commonSubsystemIds.h +++ b/common/config/commonSubsystemIds.h @@ -19,10 +19,11 @@ enum: uint8_t { PLOC_MEMORY_DUMPER = 118, PDEC_HANDLER = 119, STR_HELPER = 120, - PL_PCDU_HANDLER = 121, - ACS_BOARD_ASS = 122, - SUS_BOARD_ASS = 123, - TCS_BOARD_ASS = 124, + PLOC_MPSOC_HELPER = 121, + PL_PCDU_HANDLER = 122, + ACS_BOARD_ASS = 123, + SUS_BOARD_ASS = 124, + TCS_BOARD_ASS = 125, COMMON_SUBSYSTEM_ID_END }; } diff --git a/common/config/devConf.h b/common/config/devConf.h index 73252e35..7e09b50f 100644 --- a/common/config/devConf.h +++ b/common/config/devConf.h @@ -51,7 +51,7 @@ namespace uart { static constexpr size_t HYPERION_GPS_REPLY_MAX_BUFFER = 1024; static constexpr uint32_t SYRLINKS_BAUD = 38400; static constexpr uint32_t GNSS_BAUD = 9600; -static constexpr uint32_t PLOC_MPSOC_BAUD = 921600; +static constexpr uint32_t PLOC_MPSOC_BAUD = 115200; static constexpr uint32_t PLOC_SUPERVISOR_BAUD = 115200; static constexpr uint32_t STAR_TRACKER_BAUD = 921600; diff --git a/common/config/devices/gpioIds.h b/common/config/devices/gpioIds.h index e6f42eb4..199439cc 100644 --- a/common/config/devices/gpioIds.h +++ b/common/config/devices/gpioIds.h @@ -119,7 +119,11 @@ enum gpioId_t { PLPCDU_ENB_TX, PLPCDU_ENB_HPA, PLPCDU_ENB_MPA, - PLPCDU_ADC_CS + PLPCDU_ADC_CS, + + ENABLE_MPSOC_UART, + ENABLE_SUPV_UART + }; } diff --git a/common/config/devices/powerSwitcherList.h b/common/config/devices/powerSwitcherList.h index f99e0930..27c90e18 100644 --- a/common/config/devices/powerSwitcherList.h +++ b/common/config/devices/powerSwitcherList.h @@ -39,7 +39,7 @@ static const uint8_t OFF = 0; const std::array INIT_SWITCH_STATES = { // PDU 1 // Because the TE0720 is not connected to the PCDU, this switch is always on -#if BOARD_TE0720 == 1 +#ifdef TE0720_1CFA ON, #else OFF, diff --git a/common/config/eive/definitions.h b/common/config/eive/definitions.h index a7316ad9..db430540 100644 --- a/common/config/eive/definitions.h +++ b/common/config/eive/definitions.h @@ -15,6 +15,10 @@ static constexpr uint32_t STR_IMG_HELPER_QUEUE_SIZE = 50; static constexpr uint8_t LIVE_TM = 0; +/* Limits for filename and path checks */ +static constexpr uint32_t MAX_PATH_SIZE = 100; +static constexpr uint32_t MAX_FILENAME_SIZE = 50; + } diff --git a/fsfw b/fsfw index e6130263..b52f1925 160000 --- a/fsfw +++ b/fsfw @@ -1 +1 @@ -Subproject commit e6130263ef144c5b1f6eafef734a0150a92d6cda +Subproject commit b52f19254b8072a32203eaab91ea3c65b513ba7e diff --git a/generators/bsp_q7s_events.csv b/generators/bsp_q7s_events.csv index 53d6d6aa..994e7517 100644 --- a/generators/bsp_q7s_events.csv +++ b/generators/bsp_q7s_events.csv @@ -90,10 +90,11 @@ 11002;0x2afa;DEPLOYMENT_FAILED;HIGH;;mission/devices/SolarArrayDeploymentHandler.h 11003;0x2afb;DEPL_SA1_GPIO_SWTICH_ON_FAILED;HIGH;;mission/devices/SolarArrayDeploymentHandler.h 11004;0x2afc;DEPL_SA2_GPIO_SWTICH_ON_FAILED;HIGH;;mission/devices/SolarArrayDeploymentHandler.h -11101;0x2b5d;MEMORY_READ_RPT_CRC_FAILURE;LOW;;mission/devices/PlocMPSoCHandler.h -11102;0x2b5e;ACK_FAILURE;LOW;;mission/devices/PlocMPSoCHandler.h -11103;0x2b5f;EXE_FAILURE;LOW;;mission/devices/PlocMPSoCHandler.h -11104;0x2b60;CRC_FAILURE_EVENT;LOW;;mission/devices/PlocMPSoCHandler.h +11101;0x2b5d;MEMORY_READ_RPT_CRC_FAILURE;LOW;PLOC crc failure in telemetry packet;linux/devices/ploc/PlocMPSoCHandler.h +11102;0x2b5e;ACK_FAILURE;LOW;PLOC receive acknowledgment failure report P1: Command Id which leads the acknowledgment failure report P2: The status field inserted by the MPSoC into the data field;linux/devices/ploc/PlocMPSoCHandler.h +11103;0x2b5f;EXE_FAILURE;LOW;PLOC receive execution failure report P1: Command Id which leads the execution failure report P2: The status field inserted by the MPSoC into the data field;linux/devices/ploc/PlocMPSoCHandler.h +11104;0x2b60;MPSOC_HANDLER_CRC_FAILURE;LOW;PLOC reply has invalid crc;linux/devices/ploc/PlocMPSoCHandler.h +11105;0x2b61;MPSOC_HANDLER_SEQ_CNT_MISMATCH;LOW;Packet sequence count in received space packet does not match expected count P1: Expected sequence count P2: Received sequence count;linux/devices/ploc/PlocMPSoCHandler.h 11201;0x2bc1;SELF_TEST_I2C_FAILURE;LOW;Get self test result returns I2C failure P1: Indicates on which axis the failure occurred. 0 -> INIT, 1 -> +X, 2 -> -X, 3 -> +Y, 4 -> -Y, 5 -> +Z, 6 -> -Z, 7 -> FINA;mission/devices/IMTQHandler.h 11202;0x2bc2;SELF_TEST_SPI_FAILURE;LOW;Get self test result returns SPI failure. This concerns the MTM connectivity. P1: Indicates on which axis the failure occurred. 0 -> INIT, 1 -> +X, 2 -> -X, 3 -> +Y, 4 -> -Y, 5 -> +Z, 6 -> -Z, 7 -> FINA;mission/devices/IMTQHandler.h 11203;0x2bc3;SELF_TEST_ADC_FAILURE;LOW;Get self test result returns failure in measurement of current and temperature. P1: Indicates on which axis the failure occurred. 0 -> INIT, 1 -> +X, 2 -> -X, 3 -> +Y, 4 -> -Y, 5 -> +Z, 6 -> -Z, 7 -> FINA;mission/devices/IMTQHandler.h @@ -105,21 +106,21 @@ 11301;0x2c25;ERROR_STATE;HIGH;Reaction wheel signals an error state;mission/devices/RwHandler.h 11401;0x2c89;BOOTING_FIRMWARE_FAILED;LOW;Failed to boot firmware;linux/devices/startracker/StarTrackerHandler.h 11402;0x2c8a;BOOTING_BOOTLOADER_FAILED;LOW;Failed to boot star tracker into bootloader mode;linux/devices/startracker/StarTrackerHandler.h -11501;0x2ced;SUPV_MEMORY_READ_RPT_CRC_FAILURE;LOW;PLOC supervisor crc failure in telemetry packet;bsp_q7s/devices/PlocSupervisorHandler.h -11502;0x2cee;SUPV_ACK_FAILURE;LOW;PLOC supervisor received acknowledgment failure report;bsp_q7s/devices/PlocSupervisorHandler.h -11503;0x2cef;SUPV_EXE_FAILURE;LOW;PLOC received execution failure report;bsp_q7s/devices/PlocSupervisorHandler.h -11504;0x2cf0;SUPV_CRC_FAILURE_EVENT;LOW;PLOC supervisor reply has invalid crc;bsp_q7s/devices/PlocSupervisorHandler.h +11501;0x2ced;SUPV_MEMORY_READ_RPT_CRC_FAILURE;LOW;PLOC supervisor crc failure in telemetry packet;linux/devices/ploc/PlocSupervisorHandler.h +11502;0x2cee;SUPV_ACK_FAILURE;LOW;PLOC supervisor received acknowledgment failure report;linux/devices/ploc/PlocSupervisorHandler.h +11503;0x2cef;SUPV_EXE_FAILURE;LOW;PLOC received execution failure report;linux/devices/ploc/PlocSupervisorHandler.h +11504;0x2cf0;SUPV_CRC_FAILURE_EVENT;LOW;PLOC supervisor reply has invalid crc;linux/devices/ploc/PlocSupervisorHandler.h 11600;0x2d50;SANITIZATION_FAILED;LOW;;bsp_q7s/memory/SdCardManager.h 11601;0x2d51;MOUNTED_SD_CARD;INFO;;bsp_q7s/memory/SdCardManager.h -11700;0x2db4;UPDATE_FILE_NOT_EXISTS;LOW;;bsp_q7s/devices/PlocUpdater.h -11701;0x2db5;ACTION_COMMANDING_FAILED;LOW;Failed to send command to supervisor handler P1: Return value of CommandActionHelper::commandAction P2: Action ID of command to send;bsp_q7s/devices/PlocUpdater.h -11702;0x2db6;UPDATE_AVAILABLE_FAILED;LOW;Supervisor handler replied action message indicating a command execution failure of the update available command;bsp_q7s/devices/PlocUpdater.h -11703;0x2db7;UPDATE_TRANSFER_FAILED;LOW;Supervisor handler failed to transfer an update space packet. P1: Parameter holds the number of update packets already sent (inclusive the failed packet);bsp_q7s/devices/PlocUpdater.h -11704;0x2db8;UPDATE_VERIFY_FAILED;LOW;Supervisor failed to execute the update verify command.;bsp_q7s/devices/PlocUpdater.h -11705;0x2db9;UPDATE_FINISHED;INFO;MPSoC update successful completed;bsp_q7s/devices/PlocUpdater.h -11800;0x2e18;SEND_MRAM_DUMP_FAILED;LOW;Failed to send mram dump command to supervisor handler P1: Return value of commandAction function P2: Start address of MRAM to dump with this command;bsp_q7s/devices/PlocMemoryDumper.h -11801;0x2e19;MRAM_DUMP_FAILED;LOW;Received completion failure report form PLOC supervisor handler P1: MRAM start address of failing dump command;bsp_q7s/devices/PlocMemoryDumper.h -11802;0x2e1a;MRAM_DUMP_FINISHED;LOW;MRAM dump finished successfully;bsp_q7s/devices/PlocMemoryDumper.h +11700;0x2db4;UPDATE_FILE_NOT_EXISTS;LOW;;linux/devices/ploc/PlocUpdater.h +11701;0x2db5;ACTION_COMMANDING_FAILED;LOW;Failed to send command to supervisor handler P1: Return value of CommandActionHelper::commandAction P2: Action ID of command to send;linux/devices/ploc/PlocUpdater.h +11702;0x2db6;UPDATE_AVAILABLE_FAILED;LOW;Supervisor handler replied action message indicating a command execution failure of the update available command;linux/devices/ploc/PlocUpdater.h +11703;0x2db7;UPDATE_TRANSFER_FAILED;LOW;Supervisor handler failed to transfer an update space packet. P1: Parameter holds the number of update packets already sent (inclusive the failed packet);linux/devices/ploc/PlocUpdater.h +11704;0x2db8;UPDATE_VERIFY_FAILED;LOW;Supervisor failed to execute the update verify command.;linux/devices/ploc/PlocUpdater.h +11705;0x2db9;UPDATE_FINISHED;INFO;MPSoC update successful completed;linux/devices/ploc/PlocUpdater.h +11800;0x2e18;SEND_MRAM_DUMP_FAILED;LOW;Failed to send mram dump command to supervisor handler P1: Return value of commandAction function P2: Start address of MRAM to dump with this command;linux/devices/ploc/PlocMemoryDumper.h +11801;0x2e19;MRAM_DUMP_FAILED;LOW;Received completion failure report form PLOC supervisor handler P1: MRAM start address of failing dump command;linux/devices/ploc/PlocMemoryDumper.h +11802;0x2e1a;MRAM_DUMP_FINISHED;LOW;MRAM dump finished successfully;linux/devices/ploc/PlocMemoryDumper.h 11901;0x2e7d;INVALID_TC_FRAME;HIGH;;linux/obc/PdecHandler.h 11902;0x2e7e;INVALID_FAR;HIGH;Read invalid FAR from PDEC after startup;linux/obc/PdecHandler.h 11903;0x2e7f;CARRIER_LOCK;INFO;Carrier lock detected;linux/obc/PdecHandler.h @@ -141,27 +142,39 @@ 12014;0x2eee;STR_HELPER_FILE_NOT_EXISTS;LOW;Specified file does not exist P1: Internal state of str helper;linux/devices/startracker/StrHelper.h 12015;0x2eef;STR_HELPER_SENDING_PACKET_FAILED;LOW;;linux/devices/startracker/StrHelper.h 12016;0x2ef0;STR_HELPER_REQUESTING_MSG_FAILED;LOW;;linux/devices/startracker/StrHelper.h -12100;0x2f44;TRANSITION_BACK_TO_OFF;MEDIUM;Could not transition properly and went back to ALL OFF;mission/devices/PayloadPcduHandler.h -12101;0x2f45;NEG_V_OUT_OF_BOUNDS;MEDIUM;P1: 0 -> too low, 1 -> too high P2: Float value;mission/devices/PayloadPcduHandler.h -12102;0x2f46;U_DRO_OUT_OF_BOUNDS;MEDIUM;P1: 0 -> too low, 1 -> too high P2: Float value;mission/devices/PayloadPcduHandler.h -12103;0x2f47;I_DRO_OUT_OF_BOUNDS;MEDIUM;P1: 0 -> too low, 1 -> too high P2: Float value;mission/devices/PayloadPcduHandler.h -12104;0x2f48;U_X8_OUT_OF_BOUNDS;MEDIUM;P1: 0 -> too low, 1 -> too high P2: Float value;mission/devices/PayloadPcduHandler.h -12105;0x2f49;I_X8_OUT_OF_BOUNDS;MEDIUM;P1: 0 -> too low, 1 -> too high P2: Float value;mission/devices/PayloadPcduHandler.h -12106;0x2f4a;U_TX_OUT_OF_BOUNDS;MEDIUM;P1: 0 -> too low, 1 -> too high P2: Float value;mission/devices/PayloadPcduHandler.h -12107;0x2f4b;I_TX_OUT_OF_BOUNDS;MEDIUM;P1: 0 -> too low, 1 -> too high P2: Float value;mission/devices/PayloadPcduHandler.h -12108;0x2f4c;U_MPA_OUT_OF_BOUNDS;MEDIUM;P1: 0 -> too low, 1 -> too high P2: Float value;mission/devices/PayloadPcduHandler.h -12109;0x2f4d;I_MPA_OUT_OF_BOUNDS;MEDIUM;P1: 0 -> too low, 1 -> too high P2: Float value;mission/devices/PayloadPcduHandler.h -12110;0x2f4e;U_HPA_OUT_OF_BOUNDS;MEDIUM;P1: 0 -> too low, 1 -> too high P2: Float value;mission/devices/PayloadPcduHandler.h -12111;0x2f4f;I_HPA_OUT_OF_BOUNDS;MEDIUM;P1: 0 -> too low, 1 -> too high P2: Float value;mission/devices/PayloadPcduHandler.h -12200;0x2fa8;TRANSITION_OTHER_SIDE_FAILED;HIGH;;mission/system/AcsBoardAssembly.h -12201;0x2fa9;NOT_ENOUGH_DEVICES_DUAL_MODE;HIGH;;mission/system/AcsBoardAssembly.h -12202;0x2faa;POWER_STATE_MACHINE_TIMEOUT;MEDIUM;;mission/system/AcsBoardAssembly.h -12203;0x2fab;SIDE_SWITCH_TRANSITION_NOT_ALLOWED;LOW;Not implemented, would increase already high complexity. Operator should instead command the assembly off first and then command the assembly on into the desired mode/submode combination;mission/system/AcsBoardAssembly.h -12300;0x300c;TRANSITION_OTHER_SIDE_FAILED;HIGH;;mission/system/SusAssembly.h -12301;0x300d;NOT_ENOUGH_DEVICES_DUAL_MODE;HIGH;;mission/system/SusAssembly.h -12302;0x300e;POWER_STATE_MACHINE_TIMEOUT;MEDIUM;;mission/system/SusAssembly.h -12303;0x300f;SIDE_SWITCH_TRANSITION_NOT_ALLOWED;LOW;Not implemented, would increase already high complexity. Operator should instead command the assembly off first and then command the assembly on into the desired mode/submode combination;mission/system/SusAssembly.h -12400;0x3070;CHILDREN_LOST_MODE;MEDIUM;;mission/system/TcsBoardAssembly.h +12100;0x2f44;MPSOC_FLASH_WRITE_FAILED;LOW;Flash write fails;linux/devices/ploc/PlocMPSoCHelper.h +12101;0x2f45;MPSOC_FLASH_WRITE_SUCCESSFUL;LOW;Flash write successful;linux/devices/ploc/PlocMPSoCHelper.h +12102;0x2f46;SENDING_COMMAND_FAILED;LOW;;linux/devices/ploc/PlocMPSoCHelper.h +12103;0x2f47;MPSOC_HELPER_REQUESTING_REPLY_FAILED;LOW;Request receive message of communication interface failed P1: Return value returned by the communication interface requestReceiveMessage function P2: Internal state of MPSoC helper;linux/devices/ploc/PlocMPSoCHelper.h +12104;0x2f48;MPSOC_HELPER_READING_REPLY_FAILED;LOW;Reading receive message of communication interface failed P1: Return value returned by the communication interface readingReceivedMessage function P2: Internal state of MPSoC helper;linux/devices/ploc/PlocMPSoCHelper.h +12105;0x2f49;MISSING_ACK;LOW;Did not receive acknowledgement report P1: Number of bytes missing P2: Internal state of MPSoC helper;linux/devices/ploc/PlocMPSoCHelper.h +12106;0x2f4a;MISSING_EXE;LOW;Did not receive execution report P1: Number of bytes missing P2: Internal state of MPSoC helper;linux/devices/ploc/PlocMPSoCHelper.h +12107;0x2f4b;ACK_FAILURE_REPORT;LOW;Received acknowledgement failure report P1: Internal state of MPSoC;linux/devices/ploc/PlocMPSoCHelper.h +12108;0x2f4c;EXE_FAILURE_REPORT;LOW;Received execution failure report P1: Internal state of MPSoC;linux/devices/ploc/PlocMPSoCHelper.h +12109;0x2f4d;ACK_INVALID_APID;LOW;Expected acknowledgement report but received space packet with other apid P1: Apid of received space packet P2: Internal state of MPSoC;linux/devices/ploc/PlocMPSoCHelper.h +12110;0x2f4e;EXE_INVALID_APID;LOW;Expected execution report but received space packet with other apid P1: Apid of received space packet P2: Internal state of MPSoC;linux/devices/ploc/PlocMPSoCHelper.h +12111;0x2f4f;MPSOC_HELPER_SEQ_CNT_MISMATCH;LOW;Received sequence count does not match expected sequence count P1: Expected sequence count P2: Received sequence count;linux/devices/ploc/PlocMPSoCHelper.h +12200;0x2fa8;TRANSITION_BACK_TO_OFF;MEDIUM;Could not transition properly and went back to ALL OFF;mission/devices/PayloadPcduHandler.h +12201;0x2fa9;NEG_V_OUT_OF_BOUNDS;MEDIUM;P1: 0 -> too low, 1 -> too high P2: Float value;mission/devices/PayloadPcduHandler.h +12202;0x2faa;U_DRO_OUT_OF_BOUNDS;MEDIUM;P1: 0 -> too low, 1 -> too high P2: Float value;mission/devices/PayloadPcduHandler.h +12203;0x2fab;I_DRO_OUT_OF_BOUNDS;MEDIUM;P1: 0 -> too low, 1 -> too high P2: Float value;mission/devices/PayloadPcduHandler.h +12204;0x2fac;U_X8_OUT_OF_BOUNDS;MEDIUM;P1: 0 -> too low, 1 -> too high P2: Float value;mission/devices/PayloadPcduHandler.h +12205;0x2fad;I_X8_OUT_OF_BOUNDS;MEDIUM;P1: 0 -> too low, 1 -> too high P2: Float value;mission/devices/PayloadPcduHandler.h +12206;0x2fae;U_TX_OUT_OF_BOUNDS;MEDIUM;P1: 0 -> too low, 1 -> too high P2: Float value;mission/devices/PayloadPcduHandler.h +12207;0x2faf;I_TX_OUT_OF_BOUNDS;MEDIUM;P1: 0 -> too low, 1 -> too high P2: Float value;mission/devices/PayloadPcduHandler.h +12208;0x2fb0;U_MPA_OUT_OF_BOUNDS;MEDIUM;P1: 0 -> too low, 1 -> too high P2: Float value;mission/devices/PayloadPcduHandler.h +12209;0x2fb1;I_MPA_OUT_OF_BOUNDS;MEDIUM;P1: 0 -> too low, 1 -> too high P2: Float value;mission/devices/PayloadPcduHandler.h +12210;0x2fb2;U_HPA_OUT_OF_BOUNDS;MEDIUM;P1: 0 -> too low, 1 -> too high P2: Float value;mission/devices/PayloadPcduHandler.h +12211;0x2fb3;I_HPA_OUT_OF_BOUNDS;MEDIUM;P1: 0 -> too low, 1 -> too high P2: Float value;mission/devices/PayloadPcduHandler.h +12300;0x300c;TRANSITION_OTHER_SIDE_FAILED;HIGH;;mission/system/AcsBoardAssembly.h +12301;0x300d;NOT_ENOUGH_DEVICES_DUAL_MODE;HIGH;;mission/system/AcsBoardAssembly.h +12302;0x300e;POWER_STATE_MACHINE_TIMEOUT;MEDIUM;;mission/system/AcsBoardAssembly.h +12303;0x300f;SIDE_SWITCH_TRANSITION_NOT_ALLOWED;LOW;Not implemented, would increase already high complexity. Operator should instead command the assembly off first and then command the assembly on into the desired mode/submode combination;mission/system/AcsBoardAssembly.h +12400;0x3070;TRANSITION_OTHER_SIDE_FAILED;HIGH;;mission/system/SusAssembly.h +12401;0x3071;NOT_ENOUGH_DEVICES_DUAL_MODE;HIGH;;mission/system/SusAssembly.h +12402;0x3072;POWER_STATE_MACHINE_TIMEOUT;MEDIUM;;mission/system/SusAssembly.h +12403;0x3073;SIDE_SWITCH_TRANSITION_NOT_ALLOWED;LOW;Not implemented, would increase already high complexity. Operator should instead command the assembly off first and then command the assembly on into the desired mode/submode combination;mission/system/SusAssembly.h +12500;0x30d4;CHILDREN_LOST_MODE;MEDIUM;;mission/system/TcsBoardAssembly.h 13600;0x3520;ALLOC_FAILURE;MEDIUM;;bsp_q7s/core/CoreController.h 13601;0x3521;REBOOT_SW;MEDIUM; Software reboot occured. Can also be a systemd reboot. P1: Current Chip, P2: Current Copy;bsp_q7s/core/CoreController.h 13602;0x3522;REBOOT_MECHANISM_TRIGGERED;MEDIUM;The reboot mechanism was triggered. P1: First 16 bits: Last Chip, Last 16 bits: Last Copy, P2: Each byte is the respective reboot count for the slots;bsp_q7s/core/CoreController.h diff --git a/generators/bsp_q7s_objects.csv b/generators/bsp_q7s_objects.csv index 9f8ce56a..a19c8e77 100644 --- a/generators/bsp_q7s_objects.csv +++ b/generators/bsp_q7s_objects.csv @@ -40,8 +40,10 @@ 0x44330000;PLOC_UPDATER 0x44330001;PLOC_MEMORY_DUMPER 0x44330002;STR_HELPER +0x44330003;PLOC_MPSOC_HELPER 0x44330015;PLOC_MPSOC_HANDLER 0x44330016;PLOC_SUPERVISOR_HANDLER +0x44330017;PLOC_SUPERVISOR_HELPER 0x444100A2;SOLAR_ARRAY_DEPL_HANDLER 0x444100A4;HEATER_HANDLER 0x44420004;TMP1075_HANDLER_1 diff --git a/generators/bsp_q7s_returnvalues.csv b/generators/bsp_q7s_returnvalues.csv index e4601245..01b2f676 100644 --- a/generators/bsp_q7s_returnvalues.csv +++ b/generators/bsp_q7s_returnvalues.csv @@ -1,12 +1,13 @@ 0x0;OK;System-wide code for ok.;RETURN_OK;HasReturnvaluesIF.h;HasReturnvaluesIF 0x1;Failed;Unspecified system-wide code for failed.;RETURN_FAILED;HasReturnvaluesIF.h;HasReturnvaluesIF -0x61a0;CCSDS_CommandNotImplemented;Received action message with unknown action id;0xA0;mission/tmtc/CCSDSHandler.h;CCSDS_HANDLER -0x5e00;GOMS_PacketTooLong;;0;mission/devices/GomspaceDeviceHandler.h;GOM_SPACE_HANDLER -0x5e01;GOMS_InvalidTableId;;1;mission/devices/GomspaceDeviceHandler.h;GOM_SPACE_HANDLER -0x5e02;GOMS_InvalidAddress;;2;mission/devices/GomspaceDeviceHandler.h;GOM_SPACE_HANDLER -0x5e03;GOMS_InvalidParamSize;;3;mission/devices/GomspaceDeviceHandler.h;GOM_SPACE_HANDLER -0x5e04;GOMS_InvalidPayloadSize;;4;mission/devices/GomspaceDeviceHandler.h;GOM_SPACE_HANDLER -0x5e05;GOMS_UnknownReplyId;;5;mission/devices/GomspaceDeviceHandler.h;GOM_SPACE_HANDLER +0x62a0;CCSDS_CommandNotImplemented;Received action message with unknown action id;0xA0;mission/tmtc/CCSDSHandler.h;CCSDS_HANDLER +0x68a0;SADPL_CommandNotSupported;;0xA0;mission/devices/SolarArrayDeploymentHandler.h;SA_DEPL_HANDLER +0x68a1;SADPL_DeploymentAlreadyExecuting;;0xA1;mission/devices/SolarArrayDeploymentHandler.h;SA_DEPL_HANDLER +0x68a2;SADPL_MainSwitchTimeoutFailure;;0xA2;mission/devices/SolarArrayDeploymentHandler.h;SA_DEPL_HANDLER +0x68a3;SADPL_SwitchingDeplSa1Failed;;0xA3;mission/devices/SolarArrayDeploymentHandler.h;SA_DEPL_HANDLER +0x68a4;SADPL_SwitchingDeplSa2Failed;;0xA4;mission/devices/SolarArrayDeploymentHandler.h;SA_DEPL_HANDLER +0x5aa0;SUSS_ErrorUnlockMutex;;0xA0;mission/devices/SusHandler.h;SUS_HANDLER +0x5aa1;SUSS_ErrorLockMutex;;0xA1;mission/devices/SusHandler.h;SUS_HANDLER 0x55b0;RWHA_SpiWriteFailure;;0xB0;mission/devices/RwHandler.h;RW_HANDLER 0x55b1;RWHA_SpiReadFailure;Used by the spi send function to tell a failing read call;0xB1;mission/devices/RwHandler.h;RW_HANDLER 0x55b2;RWHA_MissingStartSign;Can be used by the HDLC decoding mechanism to inform about a missing start sign 0x7E;0xB2;mission/devices/RwHandler.h;RW_HANDLER @@ -19,13 +20,6 @@ 0x55a2;RWHA_SetSpeedCommandInvalidLength;Received set speed command has invalid length. Should be 6.;0xA2;mission/devices/RwHandler.h;RW_HANDLER 0x55a3;RWHA_ExecutionFailed;Command execution failed;0xA3;mission/devices/RwHandler.h;RW_HANDLER 0x55a4;RWHA_CrcError;Reaction wheel reply has invalid crc;0xA4;mission/devices/RwHandler.h;RW_HANDLER -0x52a1;HEATER_CommandNotSupported;;0xA1;mission/devices/HeaterHandler.h;HEATER_HANDLER -0x52a2;HEATER_InitFailed;;0xA2;mission/devices/HeaterHandler.h;HEATER_HANDLER -0x52a3;HEATER_InvalidSwitchNr;;0xA3;mission/devices/HeaterHandler.h;HEATER_HANDLER -0x52a4;HEATER_MainSwitchSetTimeout;;0xA4;mission/devices/HeaterHandler.h;HEATER_HANDLER -0x52a5;HEATER_CommandAlreadyWaiting;;0xA5;mission/devices/HeaterHandler.h;HEATER_HANDLER -0x59a0;SUSS_ErrorUnlockMutex;;0xA0;mission/devices/SusHandler.h;SUS_HANDLER -0x59a1;SUSS_ErrorLockMutex;;0xA1;mission/devices/SusHandler.h;SUS_HANDLER 0x54a0;IMTQ_InvalidCommandCode;;0xA0;mission/devices/IMTQHandler.h;IMTQ_HANDLER 0x54a1;IMTQ_ParameterMissing;;0xA1;mission/devices/IMTQHandler.h;IMTQ_HANDLER 0x54a2;IMTQ_ParameterInvalid;;0xA2;mission/devices/IMTQHandler.h;IMTQ_HANDLER @@ -34,6 +28,17 @@ 0x54a5;IMTQ_RejectedWithoutReason;;0xA5;mission/devices/IMTQHandler.h;IMTQ_HANDLER 0x54a6;IMTQ_CmdErrUnknown;;0xA6;mission/devices/IMTQHandler.h;IMTQ_HANDLER 0x54a7;IMTQ_UnexpectedSelfTestReply;The status reply to a self test command was received but no self test command has been sent. This should normally never happen.;0xA7;mission/devices/IMTQHandler.h;IMTQ_HANDLER +0x52a1;HEATER_CommandNotSupported;;0xA1;mission/devices/HeaterHandler.h;HEATER_HANDLER +0x52a2;HEATER_InitFailed;;0xA2;mission/devices/HeaterHandler.h;HEATER_HANDLER +0x52a3;HEATER_InvalidSwitchNr;;0xA3;mission/devices/HeaterHandler.h;HEATER_HANDLER +0x52a4;HEATER_MainSwitchSetTimeout;;0xA4;mission/devices/HeaterHandler.h;HEATER_HANDLER +0x52a5;HEATER_CommandAlreadyWaiting;;0xA5;mission/devices/HeaterHandler.h;HEATER_HANDLER +0x5f00;GOMS_PacketTooLong;;0;mission/devices/GomspaceDeviceHandler.h;GOM_SPACE_HANDLER +0x5f01;GOMS_InvalidTableId;;1;mission/devices/GomspaceDeviceHandler.h;GOM_SPACE_HANDLER +0x5f02;GOMS_InvalidAddress;;2;mission/devices/GomspaceDeviceHandler.h;GOM_SPACE_HANDLER +0x5f03;GOMS_InvalidParamSize;;3;mission/devices/GomspaceDeviceHandler.h;GOM_SPACE_HANDLER +0x5f04;GOMS_InvalidPayloadSize;;4;mission/devices/GomspaceDeviceHandler.h;GOM_SPACE_HANDLER +0x5f05;GOMS_UnknownReplyId;;5;mission/devices/GomspaceDeviceHandler.h;GOM_SPACE_HANDLER 0x53a0;SYRLINKS_CrcFailure;;0xA0;mission/devices/SyrlinksHkHandler.h;SYRLINKS_HANDLER 0x53a1;SYRLINKS_UartFraminOrParityErrorAck;;0xA1;mission/devices/SyrlinksHkHandler.h;SYRLINKS_HANDLER 0x53a2;SYRLINKS_BadCharacterAck;;0xA2;mission/devices/SyrlinksHkHandler.h;SYRLINKS_HANDLER @@ -43,19 +48,10 @@ 0x53a6;SYRLINKS_BadCrcAck;;0xA6;mission/devices/SyrlinksHkHandler.h;SYRLINKS_HANDLER 0x53a7;SYRLINKS_ReplyWrongSize;;0xA7;mission/devices/SyrlinksHkHandler.h;SYRLINKS_HANDLER 0x53a8;SYRLINKS_MissingStartFrameCharacter;;0xA8;mission/devices/SyrlinksHkHandler.h;SYRLINKS_HANDLER -0x65a0;SADPL_CommandNotSupported;;0xA0;mission/devices/SolarArrayDeploymentHandler.h;SA_DEPL_HANDLER -0x65a1;SADPL_DeploymentAlreadyExecuting;;0xA1;mission/devices/SolarArrayDeploymentHandler.h;SA_DEPL_HANDLER -0x65a2;SADPL_MainSwitchTimeoutFailure;;0xA2;mission/devices/SolarArrayDeploymentHandler.h;SA_DEPL_HANDLER -0x65a3;SADPL_SwitchingDeplSa1Failed;;0xA3;mission/devices/SolarArrayDeploymentHandler.h;SA_DEPL_HANDLER -0x65a4;SADPL_SwitchingDeplSa2Failed;;0xA4;mission/devices/SolarArrayDeploymentHandler.h;SA_DEPL_HANDLER -0x57a0;PLMP_CrcFailure;;0xA0;mission/devices/PlocMPSoCHandler.h;PLOC_MPSOC_HANDLER -0x57a1;PLMP_ReceivedAckFailure;;0xA1;mission/devices/PlocMPSoCHandler.h;PLOC_MPSOC_HANDLER -0x57a2;PLMP_ReceivedExeFailure;;0xA2;mission/devices/PlocMPSoCHandler.h;PLOC_MPSOC_HANDLER -0x57a3;PLMP_InvalidApid;;0xA3;mission/devices/PlocMPSoCHandler.h;PLOC_MPSOC_HANDLER -0x64a0;NVMB_KeyNotExists;Specified key does not exist in json file;0xA0;mission/memory/NVMParameterBase.h;NVM_PARAM_BASE -0x4300; HSPI_HalTimeoutRetval;;0;fsfw/hal/src/fsfw_hal/stm32h7/spi/spiDefinitions.h;HAL_SPI -0x4301; HSPI_HalBusyRetval;;1;fsfw/hal/src/fsfw_hal/stm32h7/spi/spiDefinitions.h;HAL_SPI -0x4302; HSPI_HalErrorRetval;;2;fsfw/hal/src/fsfw_hal/stm32h7/spi/spiDefinitions.h;HAL_SPI +0x65a0;NVMB_KeyNotExists;Specified key does not exist in json file;0xA0;mission/memory/NVMParameterBase.h;NVM_PARAM_BASE +0x4300; HSPI_OpeningFileFailed;;0;fsfw/hal/src/fsfw_hal/linux/spi/SpiComIF.h;HAL_SPI +0x4301; HSPI_FullDuplexTransferFailed;;1;fsfw/hal/src/fsfw_hal/linux/spi/SpiComIF.h;HAL_SPI +0x4302; HSPI_HalfDuplexTransferFailed;;2;fsfw/hal/src/fsfw_hal/linux/spi/SpiComIF.h;HAL_SPI 0x4401; HURT_UartReadFailure;;1;fsfw/hal/src/fsfw_hal/linux/uart/UartComIF.h;HAL_UART 0x4402; HURT_UartReadSizeMissmatch;;2;fsfw/hal/src/fsfw_hal/linux/uart/UartComIF.h;HAL_UART 0x4403; HURT_UartRxBufferTooSmall;;3;fsfw/hal/src/fsfw_hal/linux/uart/UartComIF.h;HAL_UART @@ -70,36 +66,119 @@ 0x4203; UXOS_CommandError;Command execution failed;3;fsfw/hal/src/fsfw_hal/linux/CommandExecutor.h;LINUX_OSAL 0x4204; UXOS_NoCommandLoadedOrPending;;4;fsfw/hal/src/fsfw_hal/linux/CommandExecutor.h;LINUX_OSAL 0x4206; UXOS_PcloseCallError;;6;fsfw/hal/src/fsfw_hal/linux/CommandExecutor.h;LINUX_OSAL -0x2b01; CCS_BcIsSetVrCommand;;0x01;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF -0x2b02; CCS_BcIsUnlockCommand;;0x02;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF -0x2bb0; CCS_BcIllegalCommand;;0xB0;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF -0x2bb1; CCS_BoardReadingNotFinished;;0xB1;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF -0x2bf0; CCS_NsPositiveW;;0xF0;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF -0x2bf1; CCS_NsNegativeW;;0xF1;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF -0x2bf2; CCS_NsLockout;;0xF2;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF -0x2bf3; CCS_FarmInLockout;;0xF3;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF -0x2bf4; CCS_FarmInWait;;0xF4;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF -0x2be0; CCS_WrongSymbol;;0xE0;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF -0x2be1; CCS_DoubleStart;;0xE1;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF -0x2be2; CCS_StartSymbolMissed;;0xE2;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF -0x2be3; CCS_EndWithoutStart;;0xE3;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF -0x2be4; CCS_TooLarge;;0xE4;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF -0x2be5; CCS_TooShort;;0xE5;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF -0x2be6; CCS_WrongTfVersion;;0xE6;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF -0x2be7; CCS_WrongSpacecraftId;;0xE7;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF -0x2be8; CCS_NoValidFrameType;;0xE8;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF -0x2be9; CCS_CrcFailed;;0xE9;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF -0x2bea; CCS_VcNotFound;;0xEA;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF -0x2beb; CCS_ForwardingFailed;;0xEB;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF -0x2bec; CCS_ContentTooLarge;;0xEC;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF -0x2bed; CCS_ResidualData;;0xED;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF -0x2bee; CCS_DataCorrupted;;0xEE;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF -0x2bef; CCS_IllegalSegmentationFlag;;0xEF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF -0x2bd0; CCS_IllegalFlagCombination;;0xD0;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF -0x2bd1; CCS_ShorterThanHeader;;0xD1;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF -0x2bd2; CCS_TooShortBlockedPacket;;0xD2;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF -0x2bd3; CCS_TooShortMapExtraction;;0xD3;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF -0x3a00; SPH_ConnBroken;;0;fsfw/src/fsfw/osal/common/TcpTmTcServer.h;SEMAPHORE_IF +0x3b00; LPIF_PoolEntryNotFound;;0x00;fsfw/src/fsfw/datapoollocal/localPoolDefinitions.h;LOCAL_POOL_OWNER_IF +0x3b01; LPIF_PoolEntryTypeConflict;;0x01;fsfw/src/fsfw/datapoollocal/localPoolDefinitions.h;LOCAL_POOL_OWNER_IF +0x3d00; HKM_QueueOrDestinationInvalid;;0;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h;HOUSEKEEPING_MANAGER +0x3d01; HKM_WrongHkPacketType;;1;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h;HOUSEKEEPING_MANAGER +0x3d02; HKM_ReportingStatusUnchanged;;2;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h;HOUSEKEEPING_MANAGER +0x3d03; HKM_PeriodicHelperInvalid;;3;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h;HOUSEKEEPING_MANAGER +0x3d04; HKM_PoolobjectNotFound;;4;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h;HOUSEKEEPING_MANAGER +0x3d05; HKM_DatasetNotFound;;5;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h;HOUSEKEEPING_MANAGER +0x3501; CFDP_InvalidTlvType;;1;fsfw/src/fsfw/cfdp/definitions.h;CFDP +0x3502; CFDP_InvalidDirectiveFields;;2;fsfw/src/fsfw/cfdp/definitions.h;CFDP +0x3503; CFDP_InvalidPduDatafieldLen;;3;fsfw/src/fsfw/cfdp/definitions.h;CFDP +0x3504; CFDP_InvalidAckDirectiveFields;;4;fsfw/src/fsfw/cfdp/definitions.h;CFDP +0x3505; CFDP_MetadataCantParseOptions;;5;fsfw/src/fsfw/cfdp/definitions.h;CFDP +0x3506; CFDP_FinishedCantParseFsResponses;;6;fsfw/src/fsfw/cfdp/definitions.h;CFDP +0x3508; CFDP_FilestoreRequiresSecondFile;;8;fsfw/src/fsfw/cfdp/definitions.h;CFDP +0x3509; CFDP_FilestoreResponseCantParseFsMessage;;9;fsfw/src/fsfw/cfdp/definitions.h;CFDP +0x3101; CF_ObjectHasNoFunctions;;1;fsfw/src/fsfw/action/CommandsActionsIF.h;COMMANDS_ACTIONS_IF +0x3102; CF_AlreadyCommanding;;2;fsfw/src/fsfw/action/CommandsActionsIF.h;COMMANDS_ACTIONS_IF +0x3201; HF_IsBusy;;1;fsfw/src/fsfw/action/HasActionsIF.h;HAS_ACTIONS_IF +0x3202; HF_InvalidParameters;;2;fsfw/src/fsfw/action/HasActionsIF.h;HAS_ACTIONS_IF +0x3203; HF_ExecutionFinished;;3;fsfw/src/fsfw/action/HasActionsIF.h;HAS_ACTIONS_IF +0x3204; HF_InvalidActionId;;4;fsfw/src/fsfw/action/HasActionsIF.h;HAS_ACTIONS_IF +0x2d01; HPA_InvalidIdentifierId;;0x01;fsfw/src/fsfw/parameters/HasParametersIF.h;HAS_PARAMETERS_IF +0x2d02; HPA_InvalidDomainId;;0x02;fsfw/src/fsfw/parameters/HasParametersIF.h;HAS_PARAMETERS_IF +0x2d03; HPA_InvalidValue;;0x03;fsfw/src/fsfw/parameters/HasParametersIF.h;HAS_PARAMETERS_IF +0x2d05; HPA_ReadOnly;;0x05;fsfw/src/fsfw/parameters/HasParametersIF.h;HAS_PARAMETERS_IF +0x2c01; PAW_UnknownDatatype;;0x01;fsfw/src/fsfw/parameters/ParameterWrapper.h;PARAMETER_WRAPPER +0x2c02; PAW_DatatypeMissmatch;;0x02;fsfw/src/fsfw/parameters/ParameterWrapper.h;PARAMETER_WRAPPER +0x2c03; PAW_Readonly;;0x03;fsfw/src/fsfw/parameters/ParameterWrapper.h;PARAMETER_WRAPPER +0x2c04; PAW_TooBig;;0x04;fsfw/src/fsfw/parameters/ParameterWrapper.h;PARAMETER_WRAPPER +0x2c05; PAW_SourceNotSet;;0x05;fsfw/src/fsfw/parameters/ParameterWrapper.h;PARAMETER_WRAPPER +0x2c06; PAW_OutOfBounds;;0x06;fsfw/src/fsfw/parameters/ParameterWrapper.h;PARAMETER_WRAPPER +0x2c07; PAW_NotSet;;0x07;fsfw/src/fsfw/parameters/ParameterWrapper.h;PARAMETER_WRAPPER +0x2c08; PAW_ColumnOrRowsZero;;0x08;fsfw/src/fsfw/parameters/ParameterWrapper.h;PARAMETER_WRAPPER +0x1701; HHI_ObjectNotHealthy;;1;fsfw/src/fsfw/health/HasHealthIF.h;HAS_HEALTH_IF +0x1702; HHI_InvalidHealthState;;2;fsfw/src/fsfw/health/HasHealthIF.h;HAS_HEALTH_IF +0x2701; SM_DataTooLarge;;1;fsfw/src/fsfw/storagemanager/StorageManagerIF.h;STORAGE_MANAGER_IF +0x2702; SM_DataStorageFull;;2;fsfw/src/fsfw/storagemanager/StorageManagerIF.h;STORAGE_MANAGER_IF +0x2703; SM_IllegalStorageId;;3;fsfw/src/fsfw/storagemanager/StorageManagerIF.h;STORAGE_MANAGER_IF +0x2704; SM_DataDoesNotExist;;4;fsfw/src/fsfw/storagemanager/StorageManagerIF.h;STORAGE_MANAGER_IF +0x2705; SM_IllegalAddress;;5;fsfw/src/fsfw/storagemanager/StorageManagerIF.h;STORAGE_MANAGER_IF +0x2706; SM_PoolTooLarge;;6;fsfw/src/fsfw/storagemanager/StorageManagerIF.h;STORAGE_MANAGER_IF +0x2301; MT_TooDetailedRequest;;1;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h;MATCH_TREE_CLASS +0x2302; MT_TooGeneralRequest;;2;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h;MATCH_TREE_CLASS +0x2303; MT_NoMatch;;3;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h;MATCH_TREE_CLASS +0x2304; MT_Full;;4;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h;MATCH_TREE_CLASS +0x2305; MT_NewNodeCreated;;5;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h;MATCH_TREE_CLASS +0x3e01; DLEE_StreamTooShort;;0x01;fsfw/src/fsfw/globalfunctions/DleEncoder.h;DLE_ENCODER +0x3e02; DLEE_DecodingError;;0x02;fsfw/src/fsfw/globalfunctions/DleEncoder.h;DLE_ENCODER +0x2e01; ASC_TooLongForTargetType;;1;fsfw/src/fsfw/globalfunctions/AsciiConverter.h;ASCII_CONVERTER +0x2e02; ASC_InvalidCharacters;;2;fsfw/src/fsfw/globalfunctions/AsciiConverter.h;ASCII_CONVERTER +0x2e03; ASC_BufferTooSmall;;0x3;fsfw/src/fsfw/globalfunctions/AsciiConverter.h;ASCII_CONVERTER +0x1c01; TCD_PacketLost;;1;fsfw/src/fsfw/tcdistribution/TcDistributor.h;PACKET_DISTRIBUTION +0x1c02; TCD_DestinationNotFound;;2;fsfw/src/fsfw/tcdistribution/TcDistributor.h;PACKET_DISTRIBUTION +0x1c03; TCD_ServiceIdAlreadyExists;;3;fsfw/src/fsfw/tcdistribution/TcDistributor.h;PACKET_DISTRIBUTION +0x1b00; TCC_IllegalApid;;0;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h;TC_PACKET_CHECK +0x1b01; TCC_IncompletePacket;;1;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h;TC_PACKET_CHECK +0x1b02; TCC_IncorrectChecksum;;2;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h;TC_PACKET_CHECK +0x1b03; TCC_IllegalPacketType;;3;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h;TC_PACKET_CHECK +0x1b04; TCC_IllegalPacketSubtype;;4;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h;TC_PACKET_CHECK +0x1b05; TCC_IncorrectPrimaryHeader;;5;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h;TC_PACKET_CHECK +0x1b06; TCC_IncorrectSecondaryHeader;;6;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h;TC_PACKET_CHECK +0x3901; MQI_Empty;;1;fsfw/src/fsfw/ipc/MessageQueueIF.h;MESSAGE_QUEUE_IF +0x3902; MQI_Full;No space left for more messages;2;fsfw/src/fsfw/ipc/MessageQueueIF.h;MESSAGE_QUEUE_IF +0x3903; MQI_NoReplyPartner;Returned if a reply method was called without partner;3;fsfw/src/fsfw/ipc/MessageQueueIF.h;MESSAGE_QUEUE_IF +0x3904; MQI_DestinationInvalid;Returned if the target destination is invalid.;4;fsfw/src/fsfw/ipc/MessageQueueIF.h;MESSAGE_QUEUE_IF +0xf01; CM_UnknownCommand;;1;fsfw/src/fsfw/ipc/CommandMessageIF.h;COMMAND_MESSAGE +0x3801; MUX_NotEnoughResources;;1;fsfw/src/fsfw/ipc/MutexIF.h;MUTEX_IF +0x3802; MUX_InsufficientMemory;;2;fsfw/src/fsfw/ipc/MutexIF.h;MUTEX_IF +0x3803; MUX_NoPrivilege;;3;fsfw/src/fsfw/ipc/MutexIF.h;MUTEX_IF +0x3804; MUX_WrongAttributeSetting;;4;fsfw/src/fsfw/ipc/MutexIF.h;MUTEX_IF +0x3805; MUX_MutexAlreadyLocked;;5;fsfw/src/fsfw/ipc/MutexIF.h;MUTEX_IF +0x3806; MUX_MutexNotFound;;6;fsfw/src/fsfw/ipc/MutexIF.h;MUTEX_IF +0x3807; MUX_MutexMaxLocks;;7;fsfw/src/fsfw/ipc/MutexIF.h;MUTEX_IF +0x3808; MUX_CurrThreadAlreadyOwnsMutex;;8;fsfw/src/fsfw/ipc/MutexIF.h;MUTEX_IF +0x3809; MUX_CurrThreadDoesNotOwnMutex;;9;fsfw/src/fsfw/ipc/MutexIF.h;MUTEX_IF +0x380a; MUX_MutexTimeout;;10;fsfw/src/fsfw/ipc/MutexIF.h;MUTEX_IF +0x380b; MUX_MutexInvalidId;;11;fsfw/src/fsfw/ipc/MutexIF.h;MUTEX_IF +0x380c; MUX_MutexDestroyedWhileWaiting;;12;fsfw/src/fsfw/ipc/MutexIF.h;MUTEX_IF +0x2801; TC_InvalidTargetState;;1;fsfw/src/fsfw/thermal/ThermalComponentIF.h;THERMAL_COMPONENT_IF +0x28f1; TC_AboveOperationalLimit;;0xF1;fsfw/src/fsfw/thermal/ThermalComponentIF.h;THERMAL_COMPONENT_IF +0x28f2; TC_BelowOperationalLimit;;0xF2;fsfw/src/fsfw/thermal/ThermalComponentIF.h;THERMAL_COMPONENT_IF +0x801; DPS_InvalidParameterDefinition;;1;fsfw/src/fsfw/datapool/DataSetIF.h;DATA_SET_CLASS +0x802; DPS_SetWasAlreadyRead;;2;fsfw/src/fsfw/datapool/DataSetIF.h;DATA_SET_CLASS +0x803; DPS_CommitingWithoutReading;;3;fsfw/src/fsfw/datapool/DataSetIF.h;DATA_SET_CLASS +0x804; DPS_DataSetUninitialised;;4;fsfw/src/fsfw/datapool/DataSetIF.h;DATA_SET_CLASS +0x805; DPS_DataSetFull;;5;fsfw/src/fsfw/datapool/DataSetIF.h;DATA_SET_CLASS +0x806; DPS_PoolVarNull;;6;fsfw/src/fsfw/datapool/DataSetIF.h;DATA_SET_CLASS +0x3ca0; PVA_InvalidReadWriteMode;;0xA0;fsfw/src/fsfw/datapool/PoolVariableIF.h;POOL_VARIABLE_IF +0x3ca1; PVA_InvalidPoolEntry;;0xA1;fsfw/src/fsfw/datapool/PoolVariableIF.h;POOL_VARIABLE_IF +0xc02; MS_InvalidEntry;;0x02;fsfw/src/fsfw/subsystem/modes/ModeStoreIF.h;MODE_STORE_IF +0xc03; MS_TooManyElements;;0x03;fsfw/src/fsfw/subsystem/modes/ModeStoreIF.h;MODE_STORE_IF +0xc04; MS_CantStoreEmpty;;0x04;fsfw/src/fsfw/subsystem/modes/ModeStoreIF.h;MODE_STORE_IF +0xd01; SS_SequenceAlreadyExists;;0x01;fsfw/src/fsfw/subsystem/Subsystem.h;SUBSYSTEM +0xd02; SS_TableAlreadyExists;;0x02;fsfw/src/fsfw/subsystem/Subsystem.h;SUBSYSTEM +0xd03; SS_TableDoesNotExist;;0x03;fsfw/src/fsfw/subsystem/Subsystem.h;SUBSYSTEM +0xd04; SS_TableOrSequenceLengthInvalid;;0x04;fsfw/src/fsfw/subsystem/Subsystem.h;SUBSYSTEM +0xd05; SS_SequenceDoesNotExist;;0x05;fsfw/src/fsfw/subsystem/Subsystem.h;SUBSYSTEM +0xd06; SS_TableContainsInvalidObjectId;;0x06;fsfw/src/fsfw/subsystem/Subsystem.h;SUBSYSTEM +0xd07; SS_FallbackSequenceDoesNotExist;;0x07;fsfw/src/fsfw/subsystem/Subsystem.h;SUBSYSTEM +0xd08; SS_NoTargetTable;;0x08;fsfw/src/fsfw/subsystem/Subsystem.h;SUBSYSTEM +0xd09; SS_SequenceOrTableTooLong;;0x09;fsfw/src/fsfw/subsystem/Subsystem.h;SUBSYSTEM +0xd0b; SS_IsFallbackSequence;;0x0B;fsfw/src/fsfw/subsystem/Subsystem.h;SUBSYSTEM +0xd0c; SS_AccessDenied;;0x0C;fsfw/src/fsfw/subsystem/Subsystem.h;SUBSYSTEM +0xd0e; SS_TableInUse;;0x0E;fsfw/src/fsfw/subsystem/Subsystem.h;SUBSYSTEM +0xda1; SS_TargetTableNotReached;;0xA1;fsfw/src/fsfw/subsystem/Subsystem.h;SUBSYSTEM +0xda2; SS_TableCheckFailed;;0xA2;fsfw/src/fsfw/subsystem/Subsystem.h;SUBSYSTEM +0xb01; SB_ChildNotFound;;0x01;fsfw/src/fsfw/subsystem/SubsystemBase.h;SUBSYSTEM_BASE +0xb02; SB_ChildInfoUpdated;;0x02;fsfw/src/fsfw/subsystem/SubsystemBase.h;SUBSYSTEM_BASE +0xb03; SB_ChildDoesntHaveModes;;0x03;fsfw/src/fsfw/subsystem/SubsystemBase.h;SUBSYSTEM_BASE +0xb04; SB_CouldNotInsertChild;;0x04;fsfw/src/fsfw/subsystem/SubsystemBase.h;SUBSYSTEM_BASE +0xb05; SB_TableContainsInvalidObjectId;;0x05;fsfw/src/fsfw/subsystem/SubsystemBase.h;SUBSYSTEM_BASE +0xb00; SB_ConnBroken;;0;fsfw/src/fsfw/osal/common/TcpTmTcServer.h;SUBSYSTEM_BASE 0x2901; IEC_NoConfigurationTable;;0x01;fsfw/src/fsfw/osal/InternalErrorCodes.h;INTERNAL_ERROR_CODES 0x2902; IEC_NoCpuTable;;0x02;fsfw/src/fsfw/osal/InternalErrorCodes.h;INTERNAL_ERROR_CODES 0x2903; IEC_InvalidWorkspaceAddress;;0x03;fsfw/src/fsfw/osal/InternalErrorCodes.h;INTERNAL_ERROR_CODES @@ -121,69 +200,26 @@ 0x2913; IEC_ImplementationBlockingOperationCancel;;0x13;fsfw/src/fsfw/osal/InternalErrorCodes.h;INTERNAL_ERROR_CODES 0x2914; IEC_MutexObtainFromBadState;;0x14;fsfw/src/fsfw/osal/InternalErrorCodes.h;INTERNAL_ERROR_CODES 0x2915; IEC_UnlimitedAndMaximumIs0;;0x15;fsfw/src/fsfw/osal/InternalErrorCodes.h;INTERNAL_ERROR_CODES -0xe01; HM_InvalidMode;;0x01;fsfw/src/fsfw/modes/HasModesIF.h;HAS_MODES_IF -0xe02; HM_TransNotAllowed;;0x02;fsfw/src/fsfw/modes/HasModesIF.h;HAS_MODES_IF -0xe03; HM_InTransition;;0x03;fsfw/src/fsfw/modes/HasModesIF.h;HAS_MODES_IF -0xe04; HM_InvalidSubmode;;0x04;fsfw/src/fsfw/modes/HasModesIF.h;HAS_MODES_IF -0x2d01; HPA_InvalidIdentifierId;;0x01;fsfw/src/fsfw/parameters/HasParametersIF.h;HAS_PARAMETERS_IF -0x2d02; HPA_InvalidDomainId;;0x02;fsfw/src/fsfw/parameters/HasParametersIF.h;HAS_PARAMETERS_IF -0x2d03; HPA_InvalidValue;;0x03;fsfw/src/fsfw/parameters/HasParametersIF.h;HAS_PARAMETERS_IF -0x2d05; HPA_ReadOnly;;0x05;fsfw/src/fsfw/parameters/HasParametersIF.h;HAS_PARAMETERS_IF -0x2c01; PAW_UnknownDatatype;;0x01;fsfw/src/fsfw/parameters/ParameterWrapper.h;PARAMETER_WRAPPER -0x2c02; PAW_DatatypeMissmatch;;0x02;fsfw/src/fsfw/parameters/ParameterWrapper.h;PARAMETER_WRAPPER -0x2c03; PAW_Readonly;;0x03;fsfw/src/fsfw/parameters/ParameterWrapper.h;PARAMETER_WRAPPER -0x2c04; PAW_TooBig;;0x04;fsfw/src/fsfw/parameters/ParameterWrapper.h;PARAMETER_WRAPPER -0x2c05; PAW_SourceNotSet;;0x05;fsfw/src/fsfw/parameters/ParameterWrapper.h;PARAMETER_WRAPPER -0x2c06; PAW_OutOfBounds;;0x06;fsfw/src/fsfw/parameters/ParameterWrapper.h;PARAMETER_WRAPPER -0x2c07; PAW_NotSet;;0x07;fsfw/src/fsfw/parameters/ParameterWrapper.h;PARAMETER_WRAPPER -0x2c08; PAW_ColumnOrRowsZero;;0x08;fsfw/src/fsfw/parameters/ParameterWrapper.h;PARAMETER_WRAPPER -0x3101; CF_ObjectHasNoFunctions;;1;fsfw/src/fsfw/action/CommandsActionsIF.h;COMMANDS_ACTIONS_IF -0x3102; CF_AlreadyCommanding;;2;fsfw/src/fsfw/action/CommandsActionsIF.h;COMMANDS_ACTIONS_IF -0x3201; HF_IsBusy;;1;fsfw/src/fsfw/action/HasActionsIF.h;HAS_ACTIONS_IF -0x3202; HF_InvalidParameters;;2;fsfw/src/fsfw/action/HasActionsIF.h;HAS_ACTIONS_IF -0x3203; HF_ExecutionFinished;;3;fsfw/src/fsfw/action/HasActionsIF.h;HAS_ACTIONS_IF -0x3204; HF_InvalidActionId;;4;fsfw/src/fsfw/action/HasActionsIF.h;HAS_ACTIONS_IF -0x201; OM_InsertionFailed;;1;fsfw/src/fsfw/objectmanager/ObjectManagerIF.h;OBJECT_MANAGER_IF -0x202; OM_NotFound;;2;fsfw/src/fsfw/objectmanager/ObjectManagerIF.h;OBJECT_MANAGER_IF -0x203; OM_ChildInitFailed;;3;fsfw/src/fsfw/objectmanager/ObjectManagerIF.h;OBJECT_MANAGER_IF -0x204; OM_InternalErrReporterUninit;;4;fsfw/src/fsfw/objectmanager/ObjectManagerIF.h;OBJECT_MANAGER_IF +0x1401; SE_BufferTooShort;;1;fsfw/src/fsfw/serialize/SerializeIF.h;SERIALIZE_IF +0x1402; SE_StreamTooShort;;2;fsfw/src/fsfw/serialize/SerializeIF.h;SERIALIZE_IF +0x1403; SE_TooManyElements;;3;fsfw/src/fsfw/serialize/SerializeIF.h;SERIALIZE_IF +0x4a00; SPPA_NoPacketFound;;0x00;fsfw/src/fsfw/tmtcservices/SpacePacketParser.h;SPACE_PACKET_PARSER +0x4a01; SPPA_SplitPacket;;0x01;fsfw/src/fsfw/tmtcservices/SpacePacketParser.h;SPACE_PACKET_PARSER +0x1d01; PUS_ActivityStarted;;1;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h;ACCEPTS_TELECOMMANDS_IF +0x1d02; PUS_InvalidSubservice;;2;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h;ACCEPTS_TELECOMMANDS_IF +0x1d03; PUS_IllegalApplicationData;;3;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h;ACCEPTS_TELECOMMANDS_IF +0x1d04; PUS_SendTmFailed;;4;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h;ACCEPTS_TELECOMMANDS_IF +0x1d05; PUS_Timeout;;5;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h;ACCEPTS_TELECOMMANDS_IF +0x1f01; CSB_ExecutionComplete;;1;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h;COMMAND_SERVICE_BASE +0x1f02; CSB_NoStepMessage;;2;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h;COMMAND_SERVICE_BASE +0x1f03; CSB_ObjectBusy;;3;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h;COMMAND_SERVICE_BASE +0x1f04; CSB_Busy;;4;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h;COMMAND_SERVICE_BASE +0x1f05; CSB_InvalidTc;;5;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h;COMMAND_SERVICE_BASE +0x1f06; CSB_InvalidObject;;6;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h;COMMAND_SERVICE_BASE +0x1f07; CSB_InvalidReply;;7;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h;COMMAND_SERVICE_BASE 0x2500; FDI_YourFault;;0;fsfw/src/fsfw/fdir/ConfirmsFailuresIF.h;HANDLES_FAILURES_IF 0x2501; FDI_MyFault;;1;fsfw/src/fsfw/fdir/ConfirmsFailuresIF.h;HANDLES_FAILURES_IF 0x2502; FDI_ConfirmLater;;2;fsfw/src/fsfw/fdir/ConfirmsFailuresIF.h;HANDLES_FAILURES_IF -0x2101; TMF_Busy;;1;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h;TM_STORE_FRONTEND_IF -0x2102; TMF_LastPacketFound;;2;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h;TM_STORE_FRONTEND_IF -0x2103; TMF_StopFetch;;3;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h;TM_STORE_FRONTEND_IF -0x2104; TMF_Timeout;;4;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h;TM_STORE_FRONTEND_IF -0x2105; TMF_TmChannelFull;;5;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h;TM_STORE_FRONTEND_IF -0x2106; TMF_NotStored;;6;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h;TM_STORE_FRONTEND_IF -0x2107; TMF_AllDeleted;;7;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h;TM_STORE_FRONTEND_IF -0x2108; TMF_InvalidData;;8;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h;TM_STORE_FRONTEND_IF -0x2109; TMF_NotReady;;9;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h;TM_STORE_FRONTEND_IF -0x2001; TMB_Busy;;1;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF -0x2002; TMB_Full;;2;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF -0x2003; TMB_Empty;;3;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF -0x2004; TMB_NullRequested;;4;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF -0x2005; TMB_TooLarge;;5;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF -0x2006; TMB_NotReady;;6;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF -0x2007; TMB_DumpError;;7;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF -0x2008; TMB_CrcError;;8;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF -0x2009; TMB_Timeout;;9;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF -0x200a; TMB_IdlePacketFound;;10;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF -0x200b; TMB_TelecommandFound;;11;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF -0x200c; TMB_NoPusATm;;12;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF -0x200d; TMB_TooSmall;;13;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF -0x200e; TMB_BlockNotFound;;14;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF -0x200f; TMB_InvalidRequest;;15;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF -0x1c01; TCD_PacketLost;;1;fsfw/src/fsfw/tcdistribution/TcDistributor.h;PACKET_DISTRIBUTION -0x1c02; TCD_DestinationNotFound;;2;fsfw/src/fsfw/tcdistribution/TcDistributor.h;PACKET_DISTRIBUTION -0x1c03; TCD_ServiceIdAlreadyExists;;3;fsfw/src/fsfw/tcdistribution/TcDistributor.h;PACKET_DISTRIBUTION -0x1b00; TCC_IllegalApid;;0;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h;TC_PACKET_CHECK -0x1b01; TCC_IncompletePacket;;1;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h;TC_PACKET_CHECK -0x1b02; TCC_IncorrectChecksum;;2;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h;TC_PACKET_CHECK -0x1b03; TCC_IllegalPacketType;;3;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h;TC_PACKET_CHECK -0x1b04; TCC_IllegalPacketSubtype;;4;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h;TC_PACKET_CHECK -0x1b05; TCC_IncorrectPrimaryHeader;;5;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h;TC_PACKET_CHECK -0x1b06; TCC_IncorrectSecondaryHeader;;6;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h;TC_PACKET_CHECK 0x4e1; RMP_CommandNoDescriptorsAvailable;;0xE1;fsfw/src/fsfw/rmap/RMAP.h;RMAP_CHANNEL 0x4e2; RMP_CommandBufferFull;;0xE2;fsfw/src/fsfw/rmap/RMAP.h;RMAP_CHANNEL 0x4e3; RMP_CommandChannelOutOfRange;;0xE3;fsfw/src/fsfw/rmap/RMAP.h;RMAP_CHANNEL @@ -224,12 +260,35 @@ 0x40a; RMP_ReplyCommandNotImplementedOrNotAuthorised;;10;fsfw/src/fsfw/rmap/RMAP.h;RMAP_CHANNEL 0x40b; RMP_ReplyRmwDataLengthError;;11;fsfw/src/fsfw/rmap/RMAP.h;RMAP_CHANNEL 0x40c; RMP_ReplyInvalidTargetLogicalAddress;;12;fsfw/src/fsfw/rmap/RMAP.h;RMAP_CHANNEL -0x2701; SM_DataTooLarge;;1;fsfw/src/fsfw/storagemanager/StorageManagerIF.h;STORAGE_MANAGER_IF -0x2702; SM_DataStorageFull;;2;fsfw/src/fsfw/storagemanager/StorageManagerIF.h;STORAGE_MANAGER_IF -0x2703; SM_IllegalStorageId;;3;fsfw/src/fsfw/storagemanager/StorageManagerIF.h;STORAGE_MANAGER_IF -0x2704; SM_DataDoesNotExist;;4;fsfw/src/fsfw/storagemanager/StorageManagerIF.h;STORAGE_MANAGER_IF -0x2705; SM_IllegalAddress;;5;fsfw/src/fsfw/storagemanager/StorageManagerIF.h;STORAGE_MANAGER_IF -0x2706; SM_PoolTooLarge;;6;fsfw/src/fsfw/storagemanager/StorageManagerIF.h;STORAGE_MANAGER_IF +0x2b01; CCS_BcIsSetVrCommand;;0x01;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF +0x2b02; CCS_BcIsUnlockCommand;;0x02;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF +0x2bb0; CCS_BcIllegalCommand;;0xB0;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF +0x2bb1; CCS_BoardReadingNotFinished;;0xB1;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF +0x2bf0; CCS_NsPositiveW;;0xF0;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF +0x2bf1; CCS_NsNegativeW;;0xF1;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF +0x2bf2; CCS_NsLockout;;0xF2;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF +0x2bf3; CCS_FarmInLockout;;0xF3;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF +0x2bf4; CCS_FarmInWait;;0xF4;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF +0x2be0; CCS_WrongSymbol;;0xE0;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF +0x2be1; CCS_DoubleStart;;0xE1;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF +0x2be2; CCS_StartSymbolMissed;;0xE2;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF +0x2be3; CCS_EndWithoutStart;;0xE3;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF +0x2be4; CCS_TooLarge;;0xE4;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF +0x2be5; CCS_TooShort;;0xE5;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF +0x2be6; CCS_WrongTfVersion;;0xE6;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF +0x2be7; CCS_WrongSpacecraftId;;0xE7;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF +0x2be8; CCS_NoValidFrameType;;0xE8;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF +0x2be9; CCS_CrcFailed;;0xE9;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF +0x2bea; CCS_VcNotFound;;0xEA;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF +0x2beb; CCS_ForwardingFailed;;0xEB;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF +0x2bec; CCS_ContentTooLarge;;0xEC;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF +0x2bed; CCS_ResidualData;;0xED;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF +0x2bee; CCS_DataCorrupted;;0xEE;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF +0x2bef; CCS_IllegalSegmentationFlag;;0xEF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF +0x2bd0; CCS_IllegalFlagCombination;;0xD0;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF +0x2bd1; CCS_ShorterThanHeader;;0xD1;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF +0x2bd2; CCS_TooShortBlockedPacket;;0xD2;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF +0x2bd3; CCS_TooShortMapExtraction;;0xD3;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF 0x37a1; SGP4_InvalidEccentricity;;0xA1;fsfw/src/fsfw/coordinates/Sgp4Propagator.h;SGP4PROPAGATOR_CLASS 0x37a2; SGP4_InvalidMeanMotion;;0xA2;fsfw/src/fsfw/coordinates/Sgp4Propagator.h;SGP4PROPAGATOR_CLASS 0x37a3; SGP4_InvalidPerturbationElements;;0xA3;fsfw/src/fsfw/coordinates/Sgp4Propagator.h;SGP4PROPAGATOR_CLASS @@ -238,142 +297,10 @@ 0x37a6; SGP4_SatelliteHasDecayed;;0xA6;fsfw/src/fsfw/coordinates/Sgp4Propagator.h;SGP4PROPAGATOR_CLASS 0x37b1; SGP4_TleTooOld;;0xB1;fsfw/src/fsfw/coordinates/Sgp4Propagator.h;SGP4PROPAGATOR_CLASS 0x37b2; SGP4_TleNotInitialized;;0xB2;fsfw/src/fsfw/coordinates/Sgp4Propagator.h;SGP4PROPAGATOR_CLASS -0x2301; MT_TooDetailedRequest;;1;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h;MATCH_TREE_CLASS -0x2302; MT_TooGeneralRequest;;2;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h;MATCH_TREE_CLASS -0x2303; MT_NoMatch;;3;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h;MATCH_TREE_CLASS -0x2304; MT_Full;;4;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h;MATCH_TREE_CLASS -0x2305; MT_NewNodeCreated;;5;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h;MATCH_TREE_CLASS -0x3e01; DLEE_StreamTooShort;;0x01;fsfw/src/fsfw/globalfunctions/DleEncoder.h;DLE_ENCODER -0x3e02; DLEE_DecodingError;;0x02;fsfw/src/fsfw/globalfunctions/DleEncoder.h;DLE_ENCODER -0x2e01; ASC_TooLongForTargetType;;1;fsfw/src/fsfw/globalfunctions/AsciiConverter.h;ASCII_CONVERTER -0x2e02; ASC_InvalidCharacters;;2;fsfw/src/fsfw/globalfunctions/AsciiConverter.h;ASCII_CONVERTER -0x2e03; ASC_BufferTooSmall;;0x3;fsfw/src/fsfw/globalfunctions/AsciiConverter.h;ASCII_CONVERTER -0xf01; CM_UnknownCommand;;1;fsfw/src/fsfw/ipc/CommandMessageIF.h;COMMAND_MESSAGE -0x3901; MQI_Empty;;1;fsfw/src/fsfw/ipc/MessageQueueIF.h;MESSAGE_QUEUE_IF -0x3902; MQI_Full;No space left for more messages;2;fsfw/src/fsfw/ipc/MessageQueueIF.h;MESSAGE_QUEUE_IF -0x3903; MQI_NoReplyPartner;Returned if a reply method was called without partner;3;fsfw/src/fsfw/ipc/MessageQueueIF.h;MESSAGE_QUEUE_IF -0x3904; MQI_DestinationInvalid;Returned if the target destination is invalid.;4;fsfw/src/fsfw/ipc/MessageQueueIF.h;MESSAGE_QUEUE_IF -0x3801; MUX_NotEnoughResources;;1;fsfw/src/fsfw/ipc/MutexIF.h;MUTEX_IF -0x3802; MUX_InsufficientMemory;;2;fsfw/src/fsfw/ipc/MutexIF.h;MUTEX_IF -0x3803; MUX_NoPrivilege;;3;fsfw/src/fsfw/ipc/MutexIF.h;MUTEX_IF -0x3804; MUX_WrongAttributeSetting;;4;fsfw/src/fsfw/ipc/MutexIF.h;MUTEX_IF -0x3805; MUX_MutexAlreadyLocked;;5;fsfw/src/fsfw/ipc/MutexIF.h;MUTEX_IF -0x3806; MUX_MutexNotFound;;6;fsfw/src/fsfw/ipc/MutexIF.h;MUTEX_IF -0x3807; MUX_MutexMaxLocks;;7;fsfw/src/fsfw/ipc/MutexIF.h;MUTEX_IF -0x3808; MUX_CurrThreadAlreadyOwnsMutex;;8;fsfw/src/fsfw/ipc/MutexIF.h;MUTEX_IF -0x3809; MUX_CurrThreadDoesNotOwnMutex;;9;fsfw/src/fsfw/ipc/MutexIF.h;MUTEX_IF -0x380a; MUX_MutexTimeout;;10;fsfw/src/fsfw/ipc/MutexIF.h;MUTEX_IF -0x380b; MUX_MutexInvalidId;;11;fsfw/src/fsfw/ipc/MutexIF.h;MUTEX_IF -0x380c; MUX_MutexDestroyedWhileWaiting;;12;fsfw/src/fsfw/ipc/MutexIF.h;MUTEX_IF -0x3a01; SPH_SemaphoreTimeout;;1;fsfw/src/fsfw/tasks/SemaphoreIF.h;SEMAPHORE_IF -0x3a02; SPH_SemaphoreNotOwned;;2;fsfw/src/fsfw/tasks/SemaphoreIF.h;SEMAPHORE_IF -0x3a03; SPH_SemaphoreInvalid;;3;fsfw/src/fsfw/tasks/SemaphoreIF.h;SEMAPHORE_IF -0x3501; CFDP_InvalidTlvType;;1;fsfw/src/fsfw/cfdp/definitions.h;CFDP -0x3502; CFDP_InvalidDirectiveFields;;2;fsfw/src/fsfw/cfdp/definitions.h;CFDP -0x3503; CFDP_InvalidPduDatafieldLen;;3;fsfw/src/fsfw/cfdp/definitions.h;CFDP -0x3504; CFDP_InvalidAckDirectiveFields;;4;fsfw/src/fsfw/cfdp/definitions.h;CFDP -0x3505; CFDP_MetadataCantParseOptions;;5;fsfw/src/fsfw/cfdp/definitions.h;CFDP -0x3506; CFDP_FinishedCantParseFsResponses;;6;fsfw/src/fsfw/cfdp/definitions.h;CFDP -0x3508; CFDP_FilestoreRequiresSecondFile;;8;fsfw/src/fsfw/cfdp/definitions.h;CFDP -0x3509; CFDP_FilestoreResponseCantParseFsMessage;;9;fsfw/src/fsfw/cfdp/definitions.h;CFDP -0x2801; TC_InvalidTargetState;;1;fsfw/src/fsfw/thermal/ThermalComponentIF.h;THERMAL_COMPONENT_IF -0x28f1; TC_AboveOperationalLimit;;0xF1;fsfw/src/fsfw/thermal/ThermalComponentIF.h;THERMAL_COMPONENT_IF -0x28f2; TC_BelowOperationalLimit;;0xF2;fsfw/src/fsfw/thermal/ThermalComponentIF.h;THERMAL_COMPONENT_IF -0xc02; MS_InvalidEntry;;0x02;fsfw/src/fsfw/subsystem/modes/ModeStoreIF.h;MODE_STORE_IF -0xc03; MS_TooManyElements;;0x03;fsfw/src/fsfw/subsystem/modes/ModeStoreIF.h;MODE_STORE_IF -0xc04; MS_CantStoreEmpty;;0x04;fsfw/src/fsfw/subsystem/modes/ModeStoreIF.h;MODE_STORE_IF -0xd01; SS_SequenceAlreadyExists;;0x01;fsfw/src/fsfw/subsystem/Subsystem.h;SUBSYSTEM -0xd02; SS_TableAlreadyExists;;0x02;fsfw/src/fsfw/subsystem/Subsystem.h;SUBSYSTEM -0xd03; SS_TableDoesNotExist;;0x03;fsfw/src/fsfw/subsystem/Subsystem.h;SUBSYSTEM -0xd04; SS_TableOrSequenceLengthInvalid;;0x04;fsfw/src/fsfw/subsystem/Subsystem.h;SUBSYSTEM -0xd05; SS_SequenceDoesNotExist;;0x05;fsfw/src/fsfw/subsystem/Subsystem.h;SUBSYSTEM -0xd06; SS_TableContainsInvalidObjectId;;0x06;fsfw/src/fsfw/subsystem/Subsystem.h;SUBSYSTEM -0xd07; SS_FallbackSequenceDoesNotExist;;0x07;fsfw/src/fsfw/subsystem/Subsystem.h;SUBSYSTEM -0xd08; SS_NoTargetTable;;0x08;fsfw/src/fsfw/subsystem/Subsystem.h;SUBSYSTEM -0xd09; SS_SequenceOrTableTooLong;;0x09;fsfw/src/fsfw/subsystem/Subsystem.h;SUBSYSTEM -0xd0b; SS_IsFallbackSequence;;0x0B;fsfw/src/fsfw/subsystem/Subsystem.h;SUBSYSTEM -0xd0c; SS_AccessDenied;;0x0C;fsfw/src/fsfw/subsystem/Subsystem.h;SUBSYSTEM -0xd0e; SS_TableInUse;;0x0E;fsfw/src/fsfw/subsystem/Subsystem.h;SUBSYSTEM -0xda1; SS_TargetTableNotReached;;0xA1;fsfw/src/fsfw/subsystem/Subsystem.h;SUBSYSTEM -0xda2; SS_TableCheckFailed;;0xA2;fsfw/src/fsfw/subsystem/Subsystem.h;SUBSYSTEM -0xb01; SB_ChildNotFound;;0x01;fsfw/src/fsfw/subsystem/SubsystemBase.h;SUBSYSTEM_BASE -0xb02; SB_ChildInfoUpdated;;0x02;fsfw/src/fsfw/subsystem/SubsystemBase.h;SUBSYSTEM_BASE -0xb03; SB_ChildDoesntHaveModes;;0x03;fsfw/src/fsfw/subsystem/SubsystemBase.h;SUBSYSTEM_BASE -0xb04; SB_CouldNotInsertChild;;0x04;fsfw/src/fsfw/subsystem/SubsystemBase.h;SUBSYSTEM_BASE -0xb05; SB_TableContainsInvalidObjectId;;0x05;fsfw/src/fsfw/subsystem/SubsystemBase.h;SUBSYSTEM_BASE -0x3d00; HKM_QueueOrDestinationInvalid;;0;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h;HOUSEKEEPING_MANAGER -0x3d01; HKM_WrongHkPacketType;;1;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h;HOUSEKEEPING_MANAGER -0x3d02; HKM_ReportingStatusUnchanged;;2;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h;HOUSEKEEPING_MANAGER -0x3d03; HKM_PeriodicHelperInvalid;;3;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h;HOUSEKEEPING_MANAGER -0x3d04; HKM_PoolobjectNotFound;;4;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h;HOUSEKEEPING_MANAGER -0x3d05; HKM_DatasetNotFound;;5;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h;HOUSEKEEPING_MANAGER -0x3b00; LPIF_PoolEntryNotFound;;0x00;fsfw/src/fsfw/datapoollocal/localPoolDefinitions.h;LOCAL_POOL_OWNER_IF -0x3b01; LPIF_PoolEntryTypeConflict;;0x01;fsfw/src/fsfw/datapoollocal/localPoolDefinitions.h;LOCAL_POOL_OWNER_IF -0x3ca0; PVA_InvalidReadWriteMode;;0xA0;fsfw/src/fsfw/datapool/PoolVariableIF.h;POOL_VARIABLE_IF -0x3ca1; PVA_InvalidPoolEntry;;0xA1;fsfw/src/fsfw/datapool/PoolVariableIF.h;POOL_VARIABLE_IF -0x801; DPS_InvalidParameterDefinition;;1;fsfw/src/fsfw/datapool/DataSetIF.h;DATA_SET_CLASS -0x802; DPS_SetWasAlreadyRead;;2;fsfw/src/fsfw/datapool/DataSetIF.h;DATA_SET_CLASS -0x803; DPS_CommitingWithoutReading;;3;fsfw/src/fsfw/datapool/DataSetIF.h;DATA_SET_CLASS -0x804; DPS_DataSetUninitialised;;4;fsfw/src/fsfw/datapool/DataSetIF.h;DATA_SET_CLASS -0x805; DPS_DataSetFull;;5;fsfw/src/fsfw/datapool/DataSetIF.h;DATA_SET_CLASS -0x806; DPS_PoolVarNull;;6;fsfw/src/fsfw/datapool/DataSetIF.h;DATA_SET_CLASS -0x1000; TIM_UnsupportedTimeFormat;;0;fsfw/src/fsfw/timemanager/CCSDSTime.h;CCSDS_TIME_HELPER_CLASS -0x1001; TIM_NotEnoughInformationForTargetFormat;;1;fsfw/src/fsfw/timemanager/CCSDSTime.h;CCSDS_TIME_HELPER_CLASS -0x1002; TIM_LengthMismatch;;2;fsfw/src/fsfw/timemanager/CCSDSTime.h;CCSDS_TIME_HELPER_CLASS -0x1003; TIM_InvalidTimeFormat;;3;fsfw/src/fsfw/timemanager/CCSDSTime.h;CCSDS_TIME_HELPER_CLASS -0x1004; TIM_InvalidDayOfYear;;4;fsfw/src/fsfw/timemanager/CCSDSTime.h;CCSDS_TIME_HELPER_CLASS -0x1005; TIM_TimeDoesNotFitFormat;;5;fsfw/src/fsfw/timemanager/CCSDSTime.h;CCSDS_TIME_HELPER_CLASS -0x3601; TSI_BadTimestamp;;1;fsfw/src/fsfw/timemanager/TimeStamperIF.h;TIME_STAMPER_IF -0x1d01; PUS_ActivityStarted;;1;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h;ACCEPTS_TELECOMMANDS_IF -0x1d02; PUS_InvalidSubservice;;2;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h;ACCEPTS_TELECOMMANDS_IF -0x1d03; PUS_IllegalApplicationData;;3;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h;ACCEPTS_TELECOMMANDS_IF -0x1d04; PUS_SendTmFailed;;4;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h;ACCEPTS_TELECOMMANDS_IF -0x1d05; PUS_Timeout;;5;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h;ACCEPTS_TELECOMMANDS_IF -0x4a00; SPPA_NoPacketFound;;0x00;fsfw/src/fsfw/tmtcservices/SpacePacketParser.h;SPACE_PACKET_PARSER -0x4a01; SPPA_SplitPacket;;0x01;fsfw/src/fsfw/tmtcservices/SpacePacketParser.h;SPACE_PACKET_PARSER -0x1f01; CSB_ExecutionComplete;;1;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h;COMMAND_SERVICE_BASE -0x1f02; CSB_NoStepMessage;;2;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h;COMMAND_SERVICE_BASE -0x1f03; CSB_ObjectBusy;;3;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h;COMMAND_SERVICE_BASE -0x1f04; CSB_Busy;;4;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h;COMMAND_SERVICE_BASE -0x1f05; CSB_InvalidTc;;5;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h;COMMAND_SERVICE_BASE -0x1f06; CSB_InvalidObject;;6;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h;COMMAND_SERVICE_BASE -0x1f07; CSB_InvalidReply;;7;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h;COMMAND_SERVICE_BASE -0x1101; AL_Full;;0x01;fsfw/src/fsfw/container/ArrayList.h;ARRAY_LIST -0x1801; FF_Full;;1;fsfw/src/fsfw/container/FIFOBase.h;FIFO_CLASS -0x1802; FF_Empty;;2;fsfw/src/fsfw/container/FIFOBase.h;FIFO_CLASS -0x1601; FMM_MapFull;;0x01;fsfw/src/fsfw/container/FixedOrderedMultimap.h;FIXED_MULTIMAP -0x1602; FMM_KeyDoesNotExist;;0x02;fsfw/src/fsfw/container/FixedOrderedMultimap.h;FIXED_MULTIMAP -0x1501; FM_KeyAlreadyExists;;0x01;fsfw/src/fsfw/container/FixedMap.h;FIXED_MAP -0x1502; FM_MapFull;;0x02;fsfw/src/fsfw/container/FixedMap.h;FIXED_MAP -0x1503; FM_KeyDoesNotExist;;0x03;fsfw/src/fsfw/container/FixedMap.h;FIXED_MAP -0x2401; EV_ListenerNotFound;;1;fsfw/src/fsfw/events/EventManagerIF.h;EVENT_MANAGER_IF -0x1701; HHI_ObjectNotHealthy;;1;fsfw/src/fsfw/health/HasHealthIF.h;HAS_HEALTH_IF -0x1702; HHI_InvalidHealthState;;2;fsfw/src/fsfw/health/HasHealthIF.h;HAS_HEALTH_IF -0x2f01; POS_InPowerTransition;;1;fsfw/src/fsfw/power/PowerSwitcher.h;POWER_SWITCHER -0x2f02; POS_SwitchStateMismatch;;2;fsfw/src/fsfw/power/PowerSwitcher.h;POWER_SWITCHER -0x501; PS_SwitchOn;;1;fsfw/src/fsfw/power/PowerSwitchIF.h;POWER_SWITCH_IF -0x500; PS_SwitchOff;;0;fsfw/src/fsfw/power/PowerSwitchIF.h;POWER_SWITCH_IF -0x502; PS_SwitchTimeout;;2;fsfw/src/fsfw/power/PowerSwitchIF.h;POWER_SWITCH_IF -0x503; PS_FuseOn;;3;fsfw/src/fsfw/power/PowerSwitchIF.h;POWER_SWITCH_IF -0x504; PS_FuseOff;;4;fsfw/src/fsfw/power/PowerSwitchIF.h;POWER_SWITCH_IF -0x1a01; TRC_NotEnoughSensors;;1;fsfw/src/fsfw/monitoring/TriplexMonitor.h;TRIPLE_REDUNDACY_CHECK -0x1a02; TRC_LowestValueOol;;2;fsfw/src/fsfw/monitoring/TriplexMonitor.h;TRIPLE_REDUNDACY_CHECK -0x1a03; TRC_HighestValueOol;;3;fsfw/src/fsfw/monitoring/TriplexMonitor.h;TRIPLE_REDUNDACY_CHECK -0x1a04; TRC_BothValuesOol;;4;fsfw/src/fsfw/monitoring/TriplexMonitor.h;TRIPLE_REDUNDACY_CHECK -0x1a05; TRC_DuplexOol;;5;fsfw/src/fsfw/monitoring/TriplexMonitor.h;TRIPLE_REDUNDACY_CHECK -0x3001; LIM_Unchecked;;1;fsfw/src/fsfw/monitoring/MonitoringIF.h;LIMITS_IF -0x3002; LIM_Invalid;;2;fsfw/src/fsfw/monitoring/MonitoringIF.h;LIMITS_IF -0x3003; LIM_Unselected;;3;fsfw/src/fsfw/monitoring/MonitoringIF.h;LIMITS_IF -0x3004; LIM_BelowLowLimit;;4;fsfw/src/fsfw/monitoring/MonitoringIF.h;LIMITS_IF -0x3005; LIM_AboveHighLimit;;5;fsfw/src/fsfw/monitoring/MonitoringIF.h;LIMITS_IF -0x3006; LIM_UnexpectedValue;;6;fsfw/src/fsfw/monitoring/MonitoringIF.h;LIMITS_IF -0x3007; LIM_OutOfRange;;7;fsfw/src/fsfw/monitoring/MonitoringIF.h;LIMITS_IF -0x30a0; LIM_FirstSample;;0xA0;fsfw/src/fsfw/monitoring/MonitoringIF.h;LIMITS_IF -0x30e0; LIM_InvalidSize;;0xE0;fsfw/src/fsfw/monitoring/MonitoringIF.h;LIMITS_IF -0x30e1; LIM_WrongType;;0xE1;fsfw/src/fsfw/monitoring/MonitoringIF.h;LIMITS_IF -0x30e2; LIM_WrongPid;;0xE2;fsfw/src/fsfw/monitoring/MonitoringIF.h;LIMITS_IF -0x30e3; LIM_WrongLimitId;;0xE3;fsfw/src/fsfw/monitoring/MonitoringIF.h;LIMITS_IF -0x30ee; LIM_MonitorNotFound;;0xEE;fsfw/src/fsfw/monitoring/MonitoringIF.h;LIMITS_IF +0x13e0; MH_UnknownCmd;;0xE0;fsfw/src/fsfw/memory/MemoryHelper.h;MEMORY_HELPER +0x13e1; MH_InvalidAddress;;0xE1;fsfw/src/fsfw/memory/MemoryHelper.h;MEMORY_HELPER +0x13e2; MH_InvalidSize;;0xE2;fsfw/src/fsfw/memory/MemoryHelper.h;MEMORY_HELPER +0x13e3; MH_StateMismatch;;0xE3;fsfw/src/fsfw/memory/MemoryHelper.h;MEMORY_HELPER 0x4100; FILS_GenericFileError;;0;fsfw/src/fsfw/memory/HasFileSystemIF.h;FILE_SYSTEM 0x4101; FILS_IsBusy;;1;fsfw/src/fsfw/memory/HasFileSystemIF.h;FILE_SYSTEM 0x4102; FILS_InvalidParameters;;2;fsfw/src/fsfw/memory/HasFileSystemIF.h;FILE_SYSTEM @@ -399,16 +326,60 @@ 0x6e2; PP_InvalidContent;;0xE2;fsfw/src/fsfw/memory/HasMemoryIF.h;HAS_MEMORY_IF 0x6e3; PP_UnalignedAccess;;0xE3;fsfw/src/fsfw/memory/HasMemoryIF.h;HAS_MEMORY_IF 0x6e4; PP_WriteProtected;;0xE4;fsfw/src/fsfw/memory/HasMemoryIF.h;HAS_MEMORY_IF -0x13e0; MH_UnknownCmd;;0xE0;fsfw/src/fsfw/memory/MemoryHelper.h;MEMORY_HELPER -0x13e1; MH_InvalidAddress;;0xE1;fsfw/src/fsfw/memory/MemoryHelper.h;MEMORY_HELPER -0x13e2; MH_InvalidSize;;0xE2;fsfw/src/fsfw/memory/MemoryHelper.h;MEMORY_HELPER -0x13e3; MH_StateMismatch;;0xE3;fsfw/src/fsfw/memory/MemoryHelper.h;MEMORY_HELPER -0x1201; AB_NeedSecondStep;;0x01;fsfw/src/fsfw/devicehandlers/AssemblyBase.h;ASSEMBLY_BASE -0x1202; AB_NeedToReconfigure;;0x02;fsfw/src/fsfw/devicehandlers/AssemblyBase.h;ASSEMBLY_BASE -0x1203; AB_ModeFallback;;0x03;fsfw/src/fsfw/devicehandlers/AssemblyBase.h;ASSEMBLY_BASE -0x1204; AB_ChildNotCommandable;;0x04;fsfw/src/fsfw/devicehandlers/AssemblyBase.h;ASSEMBLY_BASE -0x1205; AB_NeedToChangeHealth;;0x05;fsfw/src/fsfw/devicehandlers/AssemblyBase.h;ASSEMBLY_BASE -0x12a1; AB_NotEnoughChildrenInCorrectState;;0xa1;fsfw/src/fsfw/devicehandlers/AssemblyBase.h;ASSEMBLY_BASE +0x201; OM_InsertionFailed;;1;fsfw/src/fsfw/objectmanager/ObjectManagerIF.h;OBJECT_MANAGER_IF +0x202; OM_NotFound;;2;fsfw/src/fsfw/objectmanager/ObjectManagerIF.h;OBJECT_MANAGER_IF +0x203; OM_ChildInitFailed;;3;fsfw/src/fsfw/objectmanager/ObjectManagerIF.h;OBJECT_MANAGER_IF +0x204; OM_InternalErrReporterUninit;;4;fsfw/src/fsfw/objectmanager/ObjectManagerIF.h;OBJECT_MANAGER_IF +0x501; PS_SwitchOn;;1;fsfw/src/fsfw/power/PowerSwitchIF.h;POWER_SWITCH_IF +0x500; PS_SwitchOff;;0;fsfw/src/fsfw/power/PowerSwitchIF.h;POWER_SWITCH_IF +0x502; PS_SwitchTimeout;;2;fsfw/src/fsfw/power/PowerSwitchIF.h;POWER_SWITCH_IF +0x503; PS_FuseOn;;3;fsfw/src/fsfw/power/PowerSwitchIF.h;POWER_SWITCH_IF +0x504; PS_FuseOff;;4;fsfw/src/fsfw/power/PowerSwitchIF.h;POWER_SWITCH_IF +0x2f01; POS_InPowerTransition;;1;fsfw/src/fsfw/power/PowerSwitcher.h;POWER_SWITCHER +0x2f02; POS_SwitchStateMismatch;;2;fsfw/src/fsfw/power/PowerSwitcher.h;POWER_SWITCHER +0x1000; TIM_UnsupportedTimeFormat;;0;fsfw/src/fsfw/timemanager/CCSDSTime.h;CCSDS_TIME_HELPER_CLASS +0x1001; TIM_NotEnoughInformationForTargetFormat;;1;fsfw/src/fsfw/timemanager/CCSDSTime.h;CCSDS_TIME_HELPER_CLASS +0x1002; TIM_LengthMismatch;;2;fsfw/src/fsfw/timemanager/CCSDSTime.h;CCSDS_TIME_HELPER_CLASS +0x1003; TIM_InvalidTimeFormat;;3;fsfw/src/fsfw/timemanager/CCSDSTime.h;CCSDS_TIME_HELPER_CLASS +0x1004; TIM_InvalidDayOfYear;;4;fsfw/src/fsfw/timemanager/CCSDSTime.h;CCSDS_TIME_HELPER_CLASS +0x1005; TIM_TimeDoesNotFitFormat;;5;fsfw/src/fsfw/timemanager/CCSDSTime.h;CCSDS_TIME_HELPER_CLASS +0x3601; TSI_BadTimestamp;;1;fsfw/src/fsfw/timemanager/TimeStamperIF.h;TIME_STAMPER_IF +0x2101; TMF_Busy;;1;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h;TM_STORE_FRONTEND_IF +0x2102; TMF_LastPacketFound;;2;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h;TM_STORE_FRONTEND_IF +0x2103; TMF_StopFetch;;3;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h;TM_STORE_FRONTEND_IF +0x2104; TMF_Timeout;;4;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h;TM_STORE_FRONTEND_IF +0x2105; TMF_TmChannelFull;;5;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h;TM_STORE_FRONTEND_IF +0x2106; TMF_NotStored;;6;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h;TM_STORE_FRONTEND_IF +0x2107; TMF_AllDeleted;;7;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h;TM_STORE_FRONTEND_IF +0x2108; TMF_InvalidData;;8;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h;TM_STORE_FRONTEND_IF +0x2109; TMF_NotReady;;9;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h;TM_STORE_FRONTEND_IF +0x2001; TMB_Busy;;1;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF +0x2002; TMB_Full;;2;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF +0x2003; TMB_Empty;;3;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF +0x2004; TMB_NullRequested;;4;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF +0x2005; TMB_TooLarge;;5;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF +0x2006; TMB_NotReady;;6;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF +0x2007; TMB_DumpError;;7;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF +0x2008; TMB_CrcError;;8;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF +0x2009; TMB_Timeout;;9;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF +0x200a; TMB_IdlePacketFound;;10;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF +0x200b; TMB_TelecommandFound;;11;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF +0x200c; TMB_NoPusATm;;12;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF +0x200d; TMB_TooSmall;;13;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF +0x200e; TMB_BlockNotFound;;14;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF +0x200f; TMB_InvalidRequest;;15;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF +0xe01; HM_InvalidMode;;0x01;fsfw/src/fsfw/modes/HasModesIF.h;HAS_MODES_IF +0xe02; HM_TransNotAllowed;;0x02;fsfw/src/fsfw/modes/HasModesIF.h;HAS_MODES_IF +0xe03; HM_InTransition;;0x03;fsfw/src/fsfw/modes/HasModesIF.h;HAS_MODES_IF +0xe04; HM_InvalidSubmode;;0x04;fsfw/src/fsfw/modes/HasModesIF.h;HAS_MODES_IF +0x1501; FM_KeyAlreadyExists;;0x01;fsfw/src/fsfw/container/FixedMap.h;FIXED_MAP +0x1502; FM_MapFull;;0x02;fsfw/src/fsfw/container/FixedMap.h;FIXED_MAP +0x1503; FM_KeyDoesNotExist;;0x03;fsfw/src/fsfw/container/FixedMap.h;FIXED_MAP +0x1101; AL_Full;;0x01;fsfw/src/fsfw/container/ArrayList.h;ARRAY_LIST +0x1601; FMM_MapFull;;0x01;fsfw/src/fsfw/container/FixedOrderedMultimap.h;FIXED_MULTIMAP +0x1602; FMM_KeyDoesNotExist;;0x02;fsfw/src/fsfw/container/FixedOrderedMultimap.h;FIXED_MULTIMAP +0x1801; FF_Full;;1;fsfw/src/fsfw/container/FIFOBase.h;FIFO_CLASS +0x1802; FF_Empty;;2;fsfw/src/fsfw/container/FIFOBase.h;FIFO_CLASS 0x3a0; DHB_InvalidChannel;;0xA0;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h;DEVICE_HANDLER_BASE 0x3b0; DHB_AperiodicReply;;0xB0;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h;DEVICE_HANDLER_BASE 0x3b1; DHB_IgnoreReplyData;;0xB1;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h;DEVICE_HANDLER_BASE @@ -418,12 +389,12 @@ 0x3d0; DHB_NoSwitch;;0xD0;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h;DEVICE_HANDLER_BASE 0x3e0; DHB_ChildTimeout;;0xE0;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h;DEVICE_HANDLER_BASE 0x3e1; DHB_SwitchFailed;;0xE1;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h;DEVICE_HANDLER_BASE -0x3301; DC_NoReplyReceived;;0x01;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h;DEVICE_COMMUNICATION_IF -0x3302; DC_ProtocolError;;0x02;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h;DEVICE_COMMUNICATION_IF -0x3303; DC_Nullpointer;;0x03;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h;DEVICE_COMMUNICATION_IF -0x3304; DC_InvalidCookieType;;0x04;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h;DEVICE_COMMUNICATION_IF -0x3305; DC_NotActive;;0x05;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h;DEVICE_COMMUNICATION_IF -0x3306; DC_TooMuchData;;0x06;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h;DEVICE_COMMUNICATION_IF +0x1201; AB_NeedSecondStep;;0x01;fsfw/src/fsfw/devicehandlers/AssemblyBase.h;ASSEMBLY_BASE +0x1202; AB_NeedToReconfigure;;0x02;fsfw/src/fsfw/devicehandlers/AssemblyBase.h;ASSEMBLY_BASE +0x1203; AB_ModeFallback;;0x03;fsfw/src/fsfw/devicehandlers/AssemblyBase.h;ASSEMBLY_BASE +0x1204; AB_ChildNotCommandable;;0x04;fsfw/src/fsfw/devicehandlers/AssemblyBase.h;ASSEMBLY_BASE +0x1205; AB_NeedToChangeHealth;;0x05;fsfw/src/fsfw/devicehandlers/AssemblyBase.h;ASSEMBLY_BASE +0x12a1; AB_NotEnoughChildrenInCorrectState;;0xa1;fsfw/src/fsfw/devicehandlers/AssemblyBase.h;ASSEMBLY_BASE 0x26a0; DHI_NoCommandData;;0xA0;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h;DEVICE_HANDLER_IF 0x26a1; DHI_CommandNotSupported;;0xA1;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h;DEVICE_HANDLER_IF 0x26a2; DHI_CommandAlreadySent;;0xA2;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h;DEVICE_HANDLER_IF @@ -445,48 +416,87 @@ 0x26c3; DHI_DeviceReplyInvalid;;0xC3;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h;DEVICE_HANDLER_IF 0x26d0; DHI_InvalidCommandParameter;;0xD0;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h;DEVICE_HANDLER_IF 0x26d1; DHI_InvalidNumberOrLengthOfParameters;;0xD1;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h;DEVICE_HANDLER_IF -0x1401; SE_BufferTooShort;;1;fsfw/src/fsfw/serialize/SerializeIF.h;SERIALIZE_IF -0x1402; SE_StreamTooShort;;2;fsfw/src/fsfw/serialize/SerializeIF.h;SERIALIZE_IF -0x1403; SE_TooManyElements;;3;fsfw/src/fsfw/serialize/SerializeIF.h;SERIALIZE_IF -0x58a0;PLSV_CrcFailure;Space Packet received from PLOC supervisor has invalid CRC;0xA0;bsp_q7s/devices/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER -0x58a1;PLSV_ReceivedAckFailure;Received ACK failure reply from PLOC supervisor;0xA1;bsp_q7s/devices/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER -0x58a2;PLSV_ReceivedExeFailure;Received execution failure reply from PLOC supervisor;0xA2;bsp_q7s/devices/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER -0x58a3;PLSV_InvalidApid;Received space packet with invalid APID from PLOC supervisor;0xA3;bsp_q7s/devices/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER -0x58a4;PLSV_GetTimeFailure;Failed to read current system time;0xA4;bsp_q7s/devices/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER -0x58a5;PLSV_InvalidUartComIf;Invalid communication interface specified;0xA5;bsp_q7s/devices/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER -0x58a6;PLSV_InvalidWatchdog;Received command with invalid watchdog parameter. Valid watchdogs are 0 for PS, 1 for PL and 2 for INT;0xA6;bsp_q7s/devices/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER -0x58a7;PLSV_InvalidWatchdogTimeout;Received watchdog timeout config command with invalid timeout. Valid timeouts must be in the range between 1000 and 360000 ms.;0xA7;bsp_q7s/devices/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER -0x58a8;PLSV_InvalidLatchupId;Received latchup config command with invalid latchup ID;0xA8;bsp_q7s/devices/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER -0x58a9;PLSV_SweepPeriodTooSmall;Received set adc sweep period command with invalid sweep period. Must be larger than 21.;0xA9;bsp_q7s/devices/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER -0x58aa;PLSV_InvalidTestParam;Receive auto EM test command with invalid test param. Valid params are 1 and 2.;0xAA;bsp_q7s/devices/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER -0x58ab;PLSV_MramPacketParsingFailure;Returned when scanning for MRAM dump packets failed.;0xAB;bsp_q7s/devices/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER -0x58ac;PLSV_InvalidMramAddresses;Returned when the start and stop addresses of the MRAM dump or MRAM wipe commands are invalid (e.g. start address bigger than stop address);0xAC;bsp_q7s/devices/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER -0x58ad;PLSV_NoMramPacket;Expect reception of an MRAM dump packet but received space packet with other apid.;0xAD;bsp_q7s/devices/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER -0x58ae;PLSV_PathDoesNotExist;Path to PLOC directory on SD card does not exist;0xAE;bsp_q7s/devices/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER -0x58af;PLSV_MramFileNotExists;MRAM dump file does not exists. The file should actually already have been created with the reception of the first dump packet.;0xAF;bsp_q7s/devices/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER -0x5fa0;PLMEMDUMP_MramAddressTooHigh;The capacity of the MRAM amounts to 512 kB. Thus the maximum address must not be higher than 0x7d000.;0xA0;bsp_q7s/devices/PlocMemoryDumper.h;PLOC_MEMORY_DUMPER -0x5fa1;PLMEMDUMP_MramInvalidAddressCombination;The specified end address is lower than the start address;0xA1;bsp_q7s/devices/PlocMemoryDumper.h;PLOC_MEMORY_DUMPER -0x5ca0;PLUD_UpdaterBusy;Updater is already performing an update;0xA0;bsp_q7s/devices/PlocUpdater.h;PLOC_UPDATER -0x5ca1;PLUD_NameTooLong;Received update command with invalid path string (too long).;0xA1;bsp_q7s/devices/PlocUpdater.h;PLOC_UPDATER -0x5ca2;PLUD_SdNotMounted;Received command to initiate update but SD card with update image not mounted.;0xA2;bsp_q7s/devices/PlocUpdater.h;PLOC_UPDATER -0x5ca3;PLUD_FileNotExists;Update file received with update command does not exist.;0xA3;bsp_q7s/devices/PlocUpdater.h;PLOC_UPDATER -0x6c00; SDMA_OpOngoing;;0;bsp_q7s/memory/SdCardManager.h;SD_CARD_MANAGER -0x6c01; SDMA_AlreadyOn;;1;bsp_q7s/memory/SdCardManager.h;SD_CARD_MANAGER -0x6c02; SDMA_AlreadyMounted;;2;bsp_q7s/memory/SdCardManager.h;SD_CARD_MANAGER -0x6c03; SDMA_AlreadyOff;;3;bsp_q7s/memory/SdCardManager.h;SD_CARD_MANAGER -0x6c0a; SDMA_StatusFileNexists;;10;bsp_q7s/memory/SdCardManager.h;SD_CARD_MANAGER -0x6c0b; SDMA_StatusFileFormatInvalid;;11;bsp_q7s/memory/SdCardManager.h;SD_CARD_MANAGER -0x6c0c; SDMA_MountError;;12;bsp_q7s/memory/SdCardManager.h;SD_CARD_MANAGER -0x6c0d; SDMA_UnmountError;;13;bsp_q7s/memory/SdCardManager.h;SD_CARD_MANAGER -0x6c0e; SDMA_SystemCallError;;14;bsp_q7s/memory/SdCardManager.h;SD_CARD_MANAGER -0x6c0f; SDMA_PopenCallError;;15;bsp_q7s/memory/SdCardManager.h;SD_CARD_MANAGER -0x6d00; SCBU_KeyNotFound;;0;bsp_q7s/memory/scratchApi.h;SCRATCH_BUFFER +0x3301; DC_NoReplyReceived;;0x01;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h;DEVICE_COMMUNICATION_IF +0x3302; DC_ProtocolError;;0x02;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h;DEVICE_COMMUNICATION_IF +0x3303; DC_Nullpointer;;0x03;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h;DEVICE_COMMUNICATION_IF +0x3304; DC_InvalidCookieType;;0x04;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h;DEVICE_COMMUNICATION_IF +0x3305; DC_NotActive;;0x05;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h;DEVICE_COMMUNICATION_IF +0x3306; DC_TooMuchData;;0x06;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h;DEVICE_COMMUNICATION_IF +0x2401; EV_ListenerNotFound;;1;fsfw/src/fsfw/events/EventManagerIF.h;EVENT_MANAGER_IF +0x1a01; TRC_NotEnoughSensors;;1;fsfw/src/fsfw/monitoring/TriplexMonitor.h;TRIPLE_REDUNDACY_CHECK +0x1a02; TRC_LowestValueOol;;2;fsfw/src/fsfw/monitoring/TriplexMonitor.h;TRIPLE_REDUNDACY_CHECK +0x1a03; TRC_HighestValueOol;;3;fsfw/src/fsfw/monitoring/TriplexMonitor.h;TRIPLE_REDUNDACY_CHECK +0x1a04; TRC_BothValuesOol;;4;fsfw/src/fsfw/monitoring/TriplexMonitor.h;TRIPLE_REDUNDACY_CHECK +0x1a05; TRC_DuplexOol;;5;fsfw/src/fsfw/monitoring/TriplexMonitor.h;TRIPLE_REDUNDACY_CHECK +0x3001; LIM_Unchecked;;1;fsfw/src/fsfw/monitoring/MonitoringIF.h;LIMITS_IF +0x3002; LIM_Invalid;;2;fsfw/src/fsfw/monitoring/MonitoringIF.h;LIMITS_IF +0x3003; LIM_Unselected;;3;fsfw/src/fsfw/monitoring/MonitoringIF.h;LIMITS_IF +0x3004; LIM_BelowLowLimit;;4;fsfw/src/fsfw/monitoring/MonitoringIF.h;LIMITS_IF +0x3005; LIM_AboveHighLimit;;5;fsfw/src/fsfw/monitoring/MonitoringIF.h;LIMITS_IF +0x3006; LIM_UnexpectedValue;;6;fsfw/src/fsfw/monitoring/MonitoringIF.h;LIMITS_IF +0x3007; LIM_OutOfRange;;7;fsfw/src/fsfw/monitoring/MonitoringIF.h;LIMITS_IF +0x30a0; LIM_FirstSample;;0xA0;fsfw/src/fsfw/monitoring/MonitoringIF.h;LIMITS_IF +0x30e0; LIM_InvalidSize;;0xE0;fsfw/src/fsfw/monitoring/MonitoringIF.h;LIMITS_IF +0x30e1; LIM_WrongType;;0xE1;fsfw/src/fsfw/monitoring/MonitoringIF.h;LIMITS_IF +0x30e2; LIM_WrongPid;;0xE2;fsfw/src/fsfw/monitoring/MonitoringIF.h;LIMITS_IF +0x30e3; LIM_WrongLimitId;;0xE3;fsfw/src/fsfw/monitoring/MonitoringIF.h;LIMITS_IF +0x30ee; LIM_MonitorNotFound;;0xEE;fsfw/src/fsfw/monitoring/MonitoringIF.h;LIMITS_IF +0x3a01; SPH_SemaphoreTimeout;;1;fsfw/src/fsfw/tasks/SemaphoreIF.h;SEMAPHORE_IF +0x3a02; SPH_SemaphoreNotOwned;;2;fsfw/src/fsfw/tasks/SemaphoreIF.h;SEMAPHORE_IF +0x3a03; SPH_SemaphoreInvalid;;3;fsfw/src/fsfw/tasks/SemaphoreIF.h;SEMAPHORE_IF +0x7000; SDMA_OpOngoing;;0;bsp_q7s/memory/SdCardManager.h;SD_CARD_MANAGER +0x7001; SDMA_AlreadyOn;;1;bsp_q7s/memory/SdCardManager.h;SD_CARD_MANAGER +0x7002; SDMA_AlreadyMounted;;2;bsp_q7s/memory/SdCardManager.h;SD_CARD_MANAGER +0x7003; SDMA_AlreadyOff;;3;bsp_q7s/memory/SdCardManager.h;SD_CARD_MANAGER +0x700a; SDMA_StatusFileNexists;;10;bsp_q7s/memory/SdCardManager.h;SD_CARD_MANAGER +0x700b; SDMA_StatusFileFormatInvalid;;11;bsp_q7s/memory/SdCardManager.h;SD_CARD_MANAGER +0x700c; SDMA_MountError;;12;bsp_q7s/memory/SdCardManager.h;SD_CARD_MANAGER +0x700d; SDMA_UnmountError;;13;bsp_q7s/memory/SdCardManager.h;SD_CARD_MANAGER +0x700e; SDMA_SystemCallError;;14;bsp_q7s/memory/SdCardManager.h;SD_CARD_MANAGER +0x700f; SDMA_PopenCallError;;15;bsp_q7s/memory/SdCardManager.h;SD_CARD_MANAGER +0x7100; SCBU_KeyNotFound;;0;bsp_q7s/memory/scratchApi.h;SCRATCH_BUFFER +0x66a0;FSHLP_SdNotMounted;SD card specified with path string not mounted;0xA0;bsp_q7s/memory/FilesystemHelper.h;FILE_SYSTEM_HELPER +0x66a1;FSHLP_FileNotExists;Specified file does not exist on filesystem;0xA1;bsp_q7s/memory/FilesystemHelper.h;FILE_SYSTEM_HELPER +0x69a0;MPSOCRTVIF_CrcFailure;Space Packet received from PLOC has invalid CRC;0xA0;linux/devices/devicedefinitions/MPSoCReturnValuesIF.h;MPSOC_RETURN_VALUES_IF +0x69a1;MPSOCRTVIF_ReceivedAckFailure;Received ACK failure reply from PLOC;0xA1;linux/devices/devicedefinitions/MPSoCReturnValuesIF.h;MPSOC_RETURN_VALUES_IF +0x69a2;MPSOCRTVIF_ReceivedExeFailure;Received execution failure reply from PLOC;0xA2;linux/devices/devicedefinitions/MPSoCReturnValuesIF.h;MPSOC_RETURN_VALUES_IF +0x69a3;MPSOCRTVIF_InvalidApid;Received space packet with invalid APID from PLOC;0xA3;linux/devices/devicedefinitions/MPSoCReturnValuesIF.h;MPSOC_RETURN_VALUES_IF +0x69a4;MPSOCRTVIF_InvalidLength;Received command with invalid length;0xA4;linux/devices/devicedefinitions/MPSoCReturnValuesIF.h;MPSOC_RETURN_VALUES_IF +0x69a5;MPSOCRTVIF_FilenameTooLong;Filename of file in OBC filesystem is too long;0xA5;linux/devices/devicedefinitions/MPSoCReturnValuesIF.h;MPSOC_RETURN_VALUES_IF +0x69a6;MPSOCRTVIF_MpsocHelperExecuting;MPSoC helper is currently executing a command;0xA6;linux/devices/devicedefinitions/MPSoCReturnValuesIF.h;MPSOC_RETURN_VALUES_IF +0x69a7;MPSOCRTVIF_MpsocFilenameTooLong;Filename of MPSoC file is to long (max. 256 bytes);0xA7;linux/devices/devicedefinitions/MPSoCReturnValuesIF.h;MPSOC_RETURN_VALUES_IF +0x69a8;MPSOCRTVIF_InvalidParameter;Command has invalid parameter;0xA8;linux/devices/devicedefinitions/MPSoCReturnValuesIF.h;MPSOC_RETURN_VALUES_IF +0x57e0;DWLPWRON_InvalidMode;Received command has invalid JESD mode (valid modes are 0 - 5);0xE0;linux/devices/devicedefinitions/PlocMPSoCDefinitions.h;DWLPWRON_CMD +0x57e1;DWLPWRON_InvalidLaneRate;Received command has invalid lane rate (valid lane rate are 0 - 9);0xE1;linux/devices/devicedefinitions/PlocMPSoCDefinitions.h;DWLPWRON_CMD +0x60a0;PLMEMDUMP_MramAddressTooHigh;The capacity of the MRAM amounts to 512 kB. Thus the maximum address must not be higher than 0x7d000.;0xA0;linux/devices/ploc/PlocMemoryDumper.h;PLOC_MEMORY_DUMPER +0x60a1;PLMEMDUMP_MramInvalidAddressCombination;The specified end address is lower than the start address;0xA1;linux/devices/ploc/PlocMemoryDumper.h;PLOC_MEMORY_DUMPER +0x67a0; PLMPHLP_FileClosedAccidentally;File accidentally close;0xA0;linux/devices/ploc/PlocMPSoCHelper.h;PLOC_MPSOC_HELPER +0x5da0;PLUD_UpdaterBusy;Updater is already performing an update;0xA0;linux/devices/ploc/PlocUpdater.h;PLOC_UPDATER +0x5da1;PLUD_NameTooLong;Received update command with invalid path string (too long).;0xA1;linux/devices/ploc/PlocUpdater.h;PLOC_UPDATER +0x5da2;PLUD_SdNotMounted;Received command to initiate update but SD card with update image not mounted.;0xA2;linux/devices/ploc/PlocUpdater.h;PLOC_UPDATER +0x5da3;PLUD_FileNotExists;Update file received with update command does not exist.;0xA3;linux/devices/ploc/PlocUpdater.h;PLOC_UPDATER +0x59a0;PLSV_CrcFailure;Space Packet received from PLOC supervisor has invalid CRC;0xA0;linux/devices/ploc/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER +0x59a1;PLSV_ReceivedAckFailure;Received ACK failure reply from PLOC supervisor;0xA1;linux/devices/ploc/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER +0x59a2;PLSV_ReceivedExeFailure;Received execution failure reply from PLOC supervisor;0xA2;linux/devices/ploc/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER +0x59a3;PLSV_InvalidApid;Received space packet with invalid APID from PLOC supervisor;0xA3;linux/devices/ploc/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER +0x59a4;PLSV_GetTimeFailure;Failed to read current system time;0xA4;linux/devices/ploc/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER +0x59a5;PLSV_InvalidWatchdog;Received command with invalid watchdog parameter. Valid watchdogs are 0 for PS, 1 for PL and 2 for INT;0xA5;linux/devices/ploc/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER +0x59a6;PLSV_InvalidWatchdogTimeout;Received watchdog timeout config command with invalid timeout. Valid timeouts must be in the range between 1000 and 360000 ms.;0xA6;linux/devices/ploc/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER +0x59a7;PLSV_InvalidLatchupId;Received latchup config command with invalid latchup ID;0xA7;linux/devices/ploc/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER +0x59a8;PLSV_SweepPeriodTooSmall;Received set adc sweep period command with invalid sweep period. Must be larger than 21.;0xA8;linux/devices/ploc/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER +0x59a9;PLSV_InvalidTestParam;Receive auto EM test command with invalid test param. Valid params are 1 and 2.;0xA9;linux/devices/ploc/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER +0x59aa;PLSV_MramPacketParsingFailure;Returned when scanning for MRAM dump packets failed.;0xAA;linux/devices/ploc/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER +0x59ab;PLSV_InvalidMramAddresses;Returned when the start and stop addresses of the MRAM dump or MRAM wipe commands are invalid (e.g. start address bigger than stop address);0xAB;linux/devices/ploc/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER +0x59ac;PLSV_NoMramPacket;Expect reception of an MRAM dump packet but received space packet with other apid.;0xAC;linux/devices/ploc/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER +0x59ad;PLSV_PathDoesNotExist;Path to PLOC directory on SD card does not exist;0xAD;linux/devices/ploc/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER +0x59ae;PLSV_MramFileNotExists;MRAM dump file does not exists. The file should actually already have been created with the reception of the first dump packet.;0xAE;linux/devices/ploc/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER +0x59d0;PLSV_NameTooLong;Received command has file string with invalid length;0xD0;linux/devices/ploc/PlocMPSoCHandler.h;PLOC_SUPERVISOR_HANDLER +0x6401;JSONBASE_JsonFileNotExists;Specified json file does not exist;1;linux/devices/startracker/ArcsecJsonParamBase.h;ARCSEC_JSON_BASE +0x6402;JSONBASE_SetNotExists;Requested set does not exist in json file;2;linux/devices/startracker/ArcsecJsonParamBase.h;ARCSEC_JSON_BASE +0x6403;JSONBASE_ParamNotExists;Requested parameter does not exist in json file;3;linux/devices/startracker/ArcsecJsonParamBase.h;ARCSEC_JSON_BASE 0x56a0;STRH_TemperatureReqFailed;Status in temperature reply signals error;0xA0;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER 0x56a1;STRH_PingFailed;Ping command failed;0xA1;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER 0x56a2;STRH_VersionReqFailed;Status in version reply signals error;0xA2;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER -0x6301;JSONBASE_JsonFileNotExists;Specified json file does not exist;1;linux/devices/startracker/ArcsecJsonParamBase.h;ARCSEC_JSON_BASE -0x6302;JSONBASE_SetNotExists;Requested set does not exist in json file;2;linux/devices/startracker/ArcsecJsonParamBase.h;ARCSEC_JSON_BASE -0x6303;JSONBASE_ParamNotExists;Requested parameter does not exist in json file;3;linux/devices/startracker/ArcsecJsonParamBase.h;ARCSEC_JSON_BASE 0x56a3;STRH_InterfaceReqFailed;Status in interface reply signals error;0xA3;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER 0x56a4;STRH_PowerReqFailed;Status in power reply signals error;0xA4;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER 0x56a5;STRH_SetParamFailed;Status of reply to parameter set command signals error;0xA5;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER @@ -509,33 +519,33 @@ 0x56b6;STRH_StartrackerAlreadyBooted;Star tracker is already in firmware mode;0xB6;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER 0x56b7;STRH_StartrackerRunningFirmware;Star tracker is in firmware mode but must be in bootloader mode to execute this command;0xB7;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER 0x56b8;STRH_StartrackerRunningBootloader;Star tracker is in bootloader mode but must be in firmware mode to execute this command;0xB8;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER -0x5da0;STRHLP_SdNotMounted;SD card specified in path string not mounted;0xA0;linux/devices/startracker/StrHelper.h;STR_HELPER -0x5da1;STRHLP_FileNotExists;Specified file does not exist on filesystem;0xA1;linux/devices/startracker/StrHelper.h;STR_HELPER -0x5da2;STRHLP_PathNotExists;Specified path does not exist;0xA2;linux/devices/startracker/StrHelper.h;STR_HELPER -0x5da3;STRHLP_FileCreationFailed;Failed to create download image or read flash file;0xA3;linux/devices/startracker/StrHelper.h;STR_HELPER -0x5da4;STRHLP_RegionMismatch;Region in flash write/read reply does not match expected region;0xA4;linux/devices/startracker/StrHelper.h;STR_HELPER -0x5da5;STRHLP_AddressMismatch;Address in flash write/read reply does not match expected address;0xA5;linux/devices/startracker/StrHelper.h;STR_HELPER -0x5da6;STRHLP_LengthMismatch;Length in flash write/read reply does not match expected length;0xA6;linux/devices/startracker/StrHelper.h;STR_HELPER -0x5da7;STRHLP_StatusError;Status field in reply signals error;0xA7;linux/devices/startracker/StrHelper.h;STR_HELPER -0x5da8;STRHLP_InvalidTypeId;Reply has invalid type ID (should be of action reply type);0xA8;linux/devices/startracker/StrHelper.h;STR_HELPER -0x5aa0;IPCI_PapbBusy;;0xA0;linux/obc/PapbVcInterface.h;CCSDS_IP_CORE_BRIDGE -0x5ba0;PTME_UnknownVcId;;0xA0;linux/obc/Ptme.h;PTME -0x60a0;PDEC_AbandonedCltu;;0xA0;linux/obc/PdecHandler.h;PDEC_HANDLER -0x60a1;PDEC_FrameDirty;;0xA1;linux/obc/PdecHandler.h;PDEC_HANDLER -0x60a2;PDEC_FrameIllegalMultipleReasons;;0xA2;linux/obc/PdecHandler.h;PDEC_HANDLER -0x60a3;PDEC_AdDiscardedLockout;;0xA3;linux/obc/PdecHandler.h;PDEC_HANDLER -0x60a4;PDEC_AdDiscardedWait;;0xA4;linux/obc/PdecHandler.h;PDEC_HANDLER -0x60a5;PDEC_AdDiscardedNsVs;;0xA5;linux/obc/PdecHandler.h;PDEC_HANDLER -0x60b0;PDEC_CommandNotImplemented;Received action message with unknown action id;0xB0;linux/obc/PdecHandler.h;PDEC_HANDLER -0x60a6;PDEC_NoReport;;0xA6;linux/obc/PdecHandler.h;PDEC_HANDLER -0x60a7;PDEC_ErrorVersionNumber;;0xA7;linux/obc/PdecHandler.h;PDEC_HANDLER -0x60a8;PDEC_IllegalCombination;;0xA8;linux/obc/PdecHandler.h;PDEC_HANDLER -0x60a9;PDEC_InvalidScId;;0xA9;linux/obc/PdecHandler.h;PDEC_HANDLER -0x60aa;PDEC_InvalidVcIdMsb;;0xAA;linux/obc/PdecHandler.h;PDEC_HANDLER -0x60ab;PDEC_InvalidVcIdLsb;;0xAB;linux/obc/PdecHandler.h;PDEC_HANDLER -0x60ac;PDEC_NsNotZero;;0xAC;linux/obc/PdecHandler.h;PDEC_HANDLER -0x60ae;PDEC_InvalidBcCc;;0xAE;linux/obc/PdecHandler.h;PDEC_HANDLER -0x62a0;RS_RateNotSupported;The commanded rate is not supported by the current FPGA design;0xA0;linux/obc/PtmeConfig.h;RATE_SETTER -0x62a1;RS_BadBitRate;Bad bitrate has been commanded (e.g. 0);0xA1;linux/obc/PtmeConfig.h;RATE_SETTER -0x62a2;RS_ClkInversionFailed;Failed to invert clock and thus change the time the data is updated with respect to the tx clock;0xA2;linux/obc/PtmeConfig.h;RATE_SETTER -0x62a3;RS_TxManipulatorConfigFailed;Failed to change configuration bit of tx clock manipulator;0xA3;linux/obc/PtmeConfig.h;RATE_SETTER +0x5ea0;STRHLP_SdNotMounted;SD card specified in path string not mounted;0xA0;linux/devices/startracker/StrHelper.h;STR_HELPER +0x5ea1;STRHLP_FileNotExists;Specified file does not exist on filesystem;0xA1;linux/devices/startracker/StrHelper.h;STR_HELPER +0x5ea2;STRHLP_PathNotExists;Specified path does not exist;0xA2;linux/devices/startracker/StrHelper.h;STR_HELPER +0x5ea3;STRHLP_FileCreationFailed;Failed to create download image or read flash file;0xA3;linux/devices/startracker/StrHelper.h;STR_HELPER +0x5ea4;STRHLP_RegionMismatch;Region in flash write/read reply does not match expected region;0xA4;linux/devices/startracker/StrHelper.h;STR_HELPER +0x5ea5;STRHLP_AddressMismatch;Address in flash write/read reply does not match expected address;0xA5;linux/devices/startracker/StrHelper.h;STR_HELPER +0x5ea6;STRHLP_LengthMismatch;Length in flash write/read reply does not match expected length;0xA6;linux/devices/startracker/StrHelper.h;STR_HELPER +0x5ea7;STRHLP_StatusError;Status field in reply signals error;0xA7;linux/devices/startracker/StrHelper.h;STR_HELPER +0x5ea8;STRHLP_InvalidTypeId;Reply has invalid type ID (should be of action reply type);0xA8;linux/devices/startracker/StrHelper.h;STR_HELPER +0x5ba0;IPCI_PapbBusy;;0xA0;linux/obc/PapbVcInterface.h;CCSDS_IP_CORE_BRIDGE +0x5ca0;PTME_UnknownVcId;;0xA0;linux/obc/Ptme.h;PTME +0x63a0;RS_RateNotSupported;The commanded rate is not supported by the current FPGA design;0xA0;linux/obc/PtmeConfig.h;RATE_SETTER +0x63a1;RS_BadBitRate;Bad bitrate has been commanded (e.g. 0);0xA1;linux/obc/PtmeConfig.h;RATE_SETTER +0x63a2;RS_ClkInversionFailed;Failed to invert clock and thus change the time the data is updated with respect to the tx clock;0xA2;linux/obc/PtmeConfig.h;RATE_SETTER +0x63a3;RS_TxManipulatorConfigFailed;Failed to change configuration bit of tx clock manipulator;0xA3;linux/obc/PtmeConfig.h;RATE_SETTER +0x61a0;PDEC_AbandonedCltu;;0xA0;linux/obc/PdecHandler.h;PDEC_HANDLER +0x61a1;PDEC_FrameDirty;;0xA1;linux/obc/PdecHandler.h;PDEC_HANDLER +0x61a2;PDEC_FrameIllegalMultipleReasons;;0xA2;linux/obc/PdecHandler.h;PDEC_HANDLER +0x61a3;PDEC_AdDiscardedLockout;;0xA3;linux/obc/PdecHandler.h;PDEC_HANDLER +0x61a4;PDEC_AdDiscardedWait;;0xA4;linux/obc/PdecHandler.h;PDEC_HANDLER +0x61a5;PDEC_AdDiscardedNsVs;;0xA5;linux/obc/PdecHandler.h;PDEC_HANDLER +0x61b0;PDEC_CommandNotImplemented;Received action message with unknown action id;0xB0;linux/obc/PdecHandler.h;PDEC_HANDLER +0x61a6;PDEC_NoReport;;0xA6;linux/obc/PdecHandler.h;PDEC_HANDLER +0x61a7;PDEC_ErrorVersionNumber;;0xA7;linux/obc/PdecHandler.h;PDEC_HANDLER +0x61a8;PDEC_IllegalCombination;;0xA8;linux/obc/PdecHandler.h;PDEC_HANDLER +0x61a9;PDEC_InvalidScId;;0xA9;linux/obc/PdecHandler.h;PDEC_HANDLER +0x61aa;PDEC_InvalidVcIdMsb;;0xAA;linux/obc/PdecHandler.h;PDEC_HANDLER +0x61ab;PDEC_InvalidVcIdLsb;;0xAB;linux/obc/PdecHandler.h;PDEC_HANDLER +0x61ac;PDEC_NsNotZero;;0xAC;linux/obc/PdecHandler.h;PDEC_HANDLER +0x61ae;PDEC_InvalidBcCc;;0xAE;linux/obc/PdecHandler.h;PDEC_HANDLER diff --git a/generators/events/translateEvents.cpp b/generators/events/translateEvents.cpp index 9ac5c923..ece0bf14 100644 --- a/generators/events/translateEvents.cpp +++ b/generators/events/translateEvents.cpp @@ -1,7 +1,7 @@ /** - * @brief Auto-generated event translation file. Contains 168 translations. + * @brief Auto-generated event translation file. Contains 181 translations. * @details - * Generated on: 2022-03-22 20:43:04 + * Generated on: 2022-03-28 12:48:26 */ #include "translateEvents.h" @@ -100,7 +100,8 @@ const char *DEPL_SA2_GPIO_SWTICH_ON_FAILED_STRING = "DEPL_SA2_GPIO_SWTICH_ON_FAI const char *MEMORY_READ_RPT_CRC_FAILURE_STRING = "MEMORY_READ_RPT_CRC_FAILURE"; const char *ACK_FAILURE_STRING = "ACK_FAILURE"; const char *EXE_FAILURE_STRING = "EXE_FAILURE"; -const char *CRC_FAILURE_EVENT_STRING = "CRC_FAILURE_EVENT"; +const char *MPSOC_HANDLER_CRC_FAILURE_STRING = "MPSOC_HANDLER_CRC_FAILURE"; +const char *MPSOC_HANDLER_SEQ_CNT_MISMATCH_STRING = "MPSOC_HANDLER_SEQ_CNT_MISMATCH"; const char *SELF_TEST_I2C_FAILURE_STRING = "SELF_TEST_I2C_FAILURE"; const char *SELF_TEST_SPI_FAILURE_STRING = "SELF_TEST_SPI_FAILURE"; const char *SELF_TEST_ADC_FAILURE_STRING = "SELF_TEST_ADC_FAILURE"; @@ -148,6 +149,18 @@ const char *POSITION_MISMATCH_STRING = "POSITION_MISMATCH"; const char *STR_HELPER_FILE_NOT_EXISTS_STRING = "STR_HELPER_FILE_NOT_EXISTS"; const char *STR_HELPER_SENDING_PACKET_FAILED_STRING = "STR_HELPER_SENDING_PACKET_FAILED"; const char *STR_HELPER_REQUESTING_MSG_FAILED_STRING = "STR_HELPER_REQUESTING_MSG_FAILED"; +const char *MPSOC_FLASH_WRITE_FAILED_STRING = "MPSOC_FLASH_WRITE_FAILED"; +const char *MPSOC_FLASH_WRITE_SUCCESSFUL_STRING = "MPSOC_FLASH_WRITE_SUCCESSFUL"; +const char *SENDING_COMMAND_FAILED_STRING = "SENDING_COMMAND_FAILED"; +const char *MPSOC_HELPER_REQUESTING_REPLY_FAILED_STRING = "MPSOC_HELPER_REQUESTING_REPLY_FAILED"; +const char *MPSOC_HELPER_READING_REPLY_FAILED_STRING = "MPSOC_HELPER_READING_REPLY_FAILED"; +const char *MISSING_ACK_STRING = "MISSING_ACK"; +const char *MISSING_EXE_STRING = "MISSING_EXE"; +const char *ACK_FAILURE_REPORT_STRING = "ACK_FAILURE_REPORT"; +const char *EXE_FAILURE_REPORT_STRING = "EXE_FAILURE_REPORT"; +const char *ACK_INVALID_APID_STRING = "ACK_INVALID_APID"; +const char *EXE_INVALID_APID_STRING = "EXE_INVALID_APID"; +const char *MPSOC_HELPER_SEQ_CNT_MISMATCH_STRING = "MPSOC_HELPER_SEQ_CNT_MISMATCH"; const char *TRANSITION_BACK_TO_OFF_STRING = "TRANSITION_BACK_TO_OFF"; const char *NEG_V_OUT_OF_BOUNDS_STRING = "NEG_V_OUT_OF_BOUNDS"; const char *U_DRO_OUT_OF_BOUNDS_STRING = "U_DRO_OUT_OF_BOUNDS"; @@ -363,7 +376,9 @@ const char *translateEvents(Event event) { case (11103): return EXE_FAILURE_STRING; case (11104): - return CRC_FAILURE_EVENT_STRING; + return MPSOC_HANDLER_CRC_FAILURE_STRING; + case (11105): + return MPSOC_HANDLER_SEQ_CNT_MISMATCH_STRING; case (11201): return SELF_TEST_I2C_FAILURE_STRING; case (11202): @@ -459,38 +474,62 @@ const char *translateEvents(Event event) { case (12016): return STR_HELPER_REQUESTING_MSG_FAILED_STRING; case (12100): - return TRANSITION_BACK_TO_OFF_STRING; + return MPSOC_FLASH_WRITE_FAILED_STRING; case (12101): - return NEG_V_OUT_OF_BOUNDS_STRING; + return MPSOC_FLASH_WRITE_SUCCESSFUL_STRING; case (12102): - return U_DRO_OUT_OF_BOUNDS_STRING; + return SENDING_COMMAND_FAILED_STRING; case (12103): - return I_DRO_OUT_OF_BOUNDS_STRING; + return MPSOC_HELPER_REQUESTING_REPLY_FAILED_STRING; case (12104): - return U_X8_OUT_OF_BOUNDS_STRING; + return MPSOC_HELPER_READING_REPLY_FAILED_STRING; case (12105): - return I_X8_OUT_OF_BOUNDS_STRING; + return MISSING_ACK_STRING; case (12106): - return U_TX_OUT_OF_BOUNDS_STRING; + return MISSING_EXE_STRING; case (12107): - return I_TX_OUT_OF_BOUNDS_STRING; + return ACK_FAILURE_REPORT_STRING; case (12108): - return U_MPA_OUT_OF_BOUNDS_STRING; + return EXE_FAILURE_REPORT_STRING; case (12109): - return I_MPA_OUT_OF_BOUNDS_STRING; + return ACK_INVALID_APID_STRING; case (12110): - return U_HPA_OUT_OF_BOUNDS_STRING; + return EXE_INVALID_APID_STRING; case (12111): - return I_HPA_OUT_OF_BOUNDS_STRING; + return MPSOC_HELPER_SEQ_CNT_MISMATCH_STRING; case (12200): - return TRANSITION_OTHER_SIDE_FAILED_STRING; + return TRANSITION_BACK_TO_OFF_STRING; case (12201): - return NOT_ENOUGH_DEVICES_DUAL_MODE_STRING; + return NEG_V_OUT_OF_BOUNDS_STRING; case (12202): - return POWER_STATE_MACHINE_TIMEOUT_STRING; + return U_DRO_OUT_OF_BOUNDS_STRING; case (12203): + return I_DRO_OUT_OF_BOUNDS_STRING; + case (12204): + return U_X8_OUT_OF_BOUNDS_STRING; + case (12205): + return I_X8_OUT_OF_BOUNDS_STRING; + case (12206): + return U_TX_OUT_OF_BOUNDS_STRING; + case (12207): + return I_TX_OUT_OF_BOUNDS_STRING; + case (12208): + return U_MPA_OUT_OF_BOUNDS_STRING; + case (12209): + return I_MPA_OUT_OF_BOUNDS_STRING; + case (12210): + return U_HPA_OUT_OF_BOUNDS_STRING; + case (12211): + return I_HPA_OUT_OF_BOUNDS_STRING; + case (12300): + return TRANSITION_OTHER_SIDE_FAILED_STRING; + case (12301): + return NOT_ENOUGH_DEVICES_DUAL_MODE_STRING; + case (12302): + return POWER_STATE_MACHINE_TIMEOUT_STRING; + case (12303): return SIDE_SWITCH_TRANSITION_NOT_ALLOWED_STRING; - case (12400): + case (12500): return CHILDREN_LOST_MODE_STRING; case (13600): return ALLOC_FAILURE_STRING; diff --git a/generators/objects/translateObjects.cpp b/generators/objects/translateObjects.cpp index 272de238..32799af0 100644 --- a/generators/objects/translateObjects.cpp +++ b/generators/objects/translateObjects.cpp @@ -1,8 +1,8 @@ /** * @brief Auto-generated object translation file. * @details - * Contains 115 translations. - * Generated on: 2022-03-22 20:43:04 + * Contains 117 translations. + * Generated on: 2022-03-28 12:48:33 */ #include "translateObjects.h" @@ -48,8 +48,10 @@ const char *RAD_SENSOR_STRING = "RAD_SENSOR"; const char *PLOC_UPDATER_STRING = "PLOC_UPDATER"; const char *PLOC_MEMORY_DUMPER_STRING = "PLOC_MEMORY_DUMPER"; const char *STR_HELPER_STRING = "STR_HELPER"; +const char *PLOC_MPSOC_HELPER_STRING = "PLOC_MPSOC_HELPER"; const char *PLOC_MPSOC_HANDLER_STRING = "PLOC_MPSOC_HANDLER"; const char *PLOC_SUPERVISOR_HANDLER_STRING = "PLOC_SUPERVISOR_HANDLER"; +const char *PLOC_SUPERVISOR_HELPER_STRING = "PLOC_SUPERVISOR_HELPER"; const char *SOLAR_ARRAY_DEPL_HANDLER_STRING = "SOLAR_ARRAY_DEPL_HANDLER"; const char *HEATER_HANDLER_STRING = "HEATER_HANDLER"; const char *TMP1075_HANDLER_1_STRING = "TMP1075_HANDLER_1"; @@ -208,10 +210,14 @@ const char *translateObject(object_id_t object) { return PLOC_MEMORY_DUMPER_STRING; case 0x44330002: return STR_HELPER_STRING; + case 0x44330003: + return PLOC_MPSOC_HELPER_STRING; case 0x44330015: return PLOC_MPSOC_HANDLER_STRING; case 0x44330016: return PLOC_SUPERVISOR_HANDLER_STRING; + case 0x44330017: + return PLOC_SUPERVISOR_HELPER_STRING; case 0x444100A2: return SOLAR_ARRAY_DEPL_HANDLER_STRING; case 0x444100A4: diff --git a/linux/boardtest/SpiTestClass.cpp b/linux/boardtest/SpiTestClass.cpp index 5287b6e9..ff721967 100644 --- a/linux/boardtest/SpiTestClass.cpp +++ b/linux/boardtest/SpiTestClass.cpp @@ -339,6 +339,8 @@ void SpiTestClass::performMax1227Test() { std::string deviceName = ""; #elif defined(EGSE) std::string deviceName = ""; +#elif defined(TE0720_1CFA) + std::string deviceName = ""; #endif int fd = 0; UnixFileGuard fileHelper(deviceName, &fd, O_RDWR, "SpiComIF::initializeInterface"); diff --git a/linux/devices/CMakeLists.txt b/linux/devices/CMakeLists.txt index 7d39837d..00d407e8 100644 --- a/linux/devices/CMakeLists.txt +++ b/linux/devices/CMakeLists.txt @@ -4,4 +4,5 @@ if(EIVE_BUILD_GPSD_GPS_HANDLER) ) endif() +add_subdirectory(ploc) add_subdirectory(startracker) diff --git a/linux/devices/devicedefinitions/MPSoCReturnValuesIF.h b/linux/devices/devicedefinitions/MPSoCReturnValuesIF.h new file mode 100644 index 00000000..141c55aa --- /dev/null +++ b/linux/devices/devicedefinitions/MPSoCReturnValuesIF.h @@ -0,0 +1,30 @@ +#ifndef MPSOC_RETURN_VALUES_IF_H_ +#define MPSOC_RETURN_VALUES_IF_H_ + +#include "fsfw/returnvalues/HasReturnvaluesIF.h" + +class MPSoCReturnValuesIF { + public: + static const uint8_t INTERFACE_ID = CLASS_ID::MPSOC_RETURN_VALUES_IF; + + //! [EXPORT] : [COMMENT] Space Packet received from PLOC has invalid CRC + static const ReturnValue_t CRC_FAILURE = MAKE_RETURN_CODE(0xA0); + //! [EXPORT] : [COMMENT] Received ACK failure reply from PLOC + static const ReturnValue_t RECEIVED_ACK_FAILURE = MAKE_RETURN_CODE(0xA1); + //! [EXPORT] : [COMMENT] Received execution failure reply from PLOC + static const ReturnValue_t RECEIVED_EXE_FAILURE = MAKE_RETURN_CODE(0xA2); + //! [EXPORT] : [COMMENT] Received space packet with invalid APID from PLOC + static const ReturnValue_t INVALID_APID = MAKE_RETURN_CODE(0xA3); + //! [EXPORT] : [COMMENT] Received command with invalid length + static const ReturnValue_t INVALID_LENGTH = MAKE_RETURN_CODE(0xA4); + //! [EXPORT] : [COMMENT] Filename of file in OBC filesystem is too long + static const ReturnValue_t FILENAME_TOO_LONG = MAKE_RETURN_CODE(0xA5); + //! [EXPORT] : [COMMENT] MPSoC helper is currently executing a command + static const ReturnValue_t MPSOC_HELPER_EXECUTING = MAKE_RETURN_CODE(0xA6); + //! [EXPORT] : [COMMENT] Filename of MPSoC file is to long (max. 256 bytes) + static const ReturnValue_t MPSOC_FILENAME_TOO_LONG = MAKE_RETURN_CODE(0xA7); + //! [EXPORT] : [COMMENT] Command has invalid parameter + static const ReturnValue_t INVALID_PARAMETER = MAKE_RETURN_CODE(0xA8); +}; + +#endif /* MPSOC_RETURN_VALUES_IF_H_ */ diff --git a/linux/devices/devicedefinitions/PlocMPSoCDefinitions.h b/linux/devices/devicedefinitions/PlocMPSoCDefinitions.h new file mode 100644 index 00000000..9a73a8b4 --- /dev/null +++ b/linux/devices/devicedefinitions/PlocMPSoCDefinitions.h @@ -0,0 +1,620 @@ +#ifndef MISSION_DEVICES_DEVICEDEFINITIONS_PLOCMPSOCDEFINITIONS_H_ +#define MISSION_DEVICES_DEVICEDEFINITIONS_PLOCMPSOCDEFINITIONS_H_ + +#include "MPSoCReturnValuesIF.h" +#include "OBSWConfig.h" +#include "eive/definitions.h" +#include "fsfw/globalfunctions/CRC.h" +#include "fsfw/serialize/SerializeAdapter.h" +#include "fsfw/tmtcpacket/SpacePacket.h" + +namespace mpsoc { + +static const DeviceCommandId_t NONE = 0; +static const DeviceCommandId_t TC_MEM_WRITE = 1; +static const DeviceCommandId_t TC_MEM_READ = 2; +static const DeviceCommandId_t ACK_REPORT = 3; +static const DeviceCommandId_t EXE_REPORT = 5; +static const DeviceCommandId_t TM_MEMORY_READ_REPORT = 6; +static const DeviceCommandId_t TC_FLASHFOPEN = 7; +static const DeviceCommandId_t TC_FLASHFCLOSE = 8; +static const DeviceCommandId_t TC_FLASHWRITE = 9; +static const DeviceCommandId_t TC_FLASHDELETE = 10; +static const DeviceCommandId_t TC_REPLAY_START = 11; +static const DeviceCommandId_t TC_REPLAY_STOP = 12; +static const DeviceCommandId_t TC_REPLAY_WRITE_SEQUENCE = 13; +static const DeviceCommandId_t TC_DOWNLINK_PWR_ON = 14; +static const DeviceCommandId_t TC_DOWNLINK_PWR_OFF = 15; +static const DeviceCommandId_t TC_MODE_REPLAY = 16; + +// Will reset the sequence count of the OBSW +static const DeviceCommandId_t OBSW_RESET_SEQ_COUNT = 50; + +static const uint16_t SIZE_ACK_REPORT = 14; +static const uint16_t SIZE_EXE_REPORT = 14; +static const uint16_t SIZE_TM_MEM_READ_REPORT = 18; + +/** + * SpacePacket apids of PLOC telecommands and telemetry. + */ +namespace apid { +static const uint16_t TC_REPLAY_START = 0x110; +static const uint16_t TC_REPLAY_STOP = 0x111; +static const uint16_t TC_REPLAY_WRITE_SEQUENCE = 0x112; +static const uint16_t TC_DOWNLINK_PWR_ON = 0x113; +static const uint16_t TC_MEM_WRITE = 0x114; +static const uint16_t TC_MEM_READ = 0x115; +static const uint16_t TC_FLASHWRITE = 0x117; +static const uint16_t TC_FLASHFOPEN = 0x119; +static const uint16_t TC_FLASHFCLOSE = 0x11A; +static const uint16_t TC_FLASHDELETE = 0x11C; +static const uint16_t TC_MODE_REPLAY = 0x11F; +static const uint16_t TC_DOWNLINK_PWR_OFF = 0x124; +static const uint16_t TM_MEMORY_READ_REPORT = 0x404; +static const uint16_t ACK_SUCCESS = 0x400; +static const uint16_t ACK_FAILURE = 0x401; +static const uint16_t EXE_SUCCESS = 0x402; +static const uint16_t EXE_FAILURE = 0x403; +} // namespace apid + +/** Offset from first byte in space packet to first byte of data field */ +static const uint8_t DATA_FIELD_OFFSET = 6; +static const size_t MEM_READ_RPT_LEN_OFFSET = 10; +static const char NULL_TERMINATOR = '\0'; + +/** + * The size of payload data which will be forwarded to the requesting object. e.g. PUS Service + * 8. + */ +static const uint8_t SIZE_MEM_READ_RPT_FIX = 6; + +static const size_t MAX_FILENAME_SIZE = 256; + +/** + * PLOC space packet length for fixed size packets. This is the size of the whole packet data + * field. For the length field in the space packet this size will be substracted by one. + */ +static const uint16_t LENGTH_TC_MEM_WRITE = 12; +static const uint16_t LENGTH_TC_MEM_READ = 8; + +static const size_t MAX_REPLY_SIZE = SpacePacket::PACKET_MAX_SIZE * 3; +static const size_t MAX_COMMAND_SIZE = SpacePacket::PACKET_MAX_SIZE; +static const size_t MAX_DATA_SIZE = 1016; + +/** + * The replay write sequence command has a maximum delay for the execution report which amounts to + * 30 seconds. (80 cycles * 0.5 seconds = 40 seconds). + */ +static const uint16_t TC_WRITE_SEQ_EXECUTION_DELAY = 80; +// Requires approx. 2 seconds for execution. 8 => 4 seconds +static const uint16_t TC_DOWNLINK_PWR_ON_EXECUTION_DELAY = 8; + +/** + * @brief Abstract base class for TC space packet of MPSoC. + */ +class TcBase : public SpacePacket, public MPSoCReturnValuesIF { + public: + // Initial length field of space packet. Will always be updated when packet is created. + static const uint16_t INIT_LENGTH = 1; + + /** + * @brief Constructor + * + * @param sequenceCount Sequence count of space packet which will be incremented with each + * sent and received packets. + */ + TcBase(uint16_t apid, uint16_t sequenceCount) + : SpacePacket(INIT_LENGTH, true, apid, sequenceCount) {} + + /** + * @brief Function to initialize the space packet + * + * @param commandData Pointer to command specific data + * @param commandDataLen Length of command data + * + * @return RETURN_OK if packet creation was successful, otherwise error return value + */ + virtual ReturnValue_t createPacket(const uint8_t* commandData, size_t commandDataLen) { + ReturnValue_t result = HasReturnvaluesIF::RETURN_OK; + result = initPacket(commandData, commandDataLen); + if (result != HasReturnvaluesIF::HasReturnvaluesIF::RETURN_OK) { + return result; + } + result = addCrc(); + if (result != HasReturnvaluesIF::HasReturnvaluesIF::RETURN_OK) { + return result; + } + return result; + } + + protected: + /** + * @brief Must be overwritten by the child class to define the command specific parameters + * + * @param commandData Pointer to received command data + * @param commandDataLen Length of received command data + */ + virtual ReturnValue_t initPacket(const uint8_t* commandData, size_t commandDataLen) { + return HasReturnvaluesIF::RETURN_OK; + } + + /** + * @brief Calculates and adds the CRC + */ + ReturnValue_t addCrc() { + ReturnValue_t result = HasReturnvaluesIF::RETURN_OK; + size_t serializedSize = 0; + uint32_t full_size = getFullSize(); + uint16_t crc = CRC::crc16ccitt(getWholeData(), full_size - CRC_SIZE); + result = SerializeAdapter::serialize( + &crc, this->localData.byteStream + full_size - CRC_SIZE, &serializedSize, sizeof(crc), + SerializeIF::Endianness::BIG); + if (result != HasReturnvaluesIF::RETURN_OK) { + sif::debug << "TcBase::addCrc: Failed to serialize crc field" << std::endl; + } + return result; + } +}; + +/** + * @brief Class for handling tm replies of the PLOC MPSoC. + */ +class TmPacket : public SpacePacket, public MPSoCReturnValuesIF { + public: + /** + * @brief Constructor creates idle packet and sets length field to maximum allowed size. + */ + TmPacket() : SpacePacket(PACKET_MAX_SIZE) {} + + ReturnValue_t checkCrc() { + uint8_t* crcPtr = this->getPacketData() + this->getPacketDataLength() - 1; + uint16_t receivedCrc = *(crcPtr) << 8 | *(crcPtr + 1); + uint16_t recalculatedCrc = + CRC::crc16ccitt(this->localData.byteStream, this->getFullSize() - CRC_SIZE); + if (recalculatedCrc != receivedCrc) { + return CRC_FAILURE; + } + return HasReturnvaluesIF::RETURN_OK; + } +}; + +/** + * @brief This class helps to build the memory read command for the PLOC. + */ +class TcMemRead : public TcBase { + public: + /** + * @brief Constructor + */ + TcMemRead(uint16_t sequenceCount) : TcBase(apid::TC_MEM_READ, sequenceCount) { + this->setPacketDataLength(PACKET_LENGTH); + } + + uint16_t getMemLen() const { return memLen; } + + protected: + ReturnValue_t initPacket(const uint8_t* commandData, size_t commandDataLen) { + ReturnValue_t result = HasReturnvaluesIF::RETURN_OK; + result = lengthCheck(commandDataLen); + if (result != HasReturnvaluesIF::RETURN_OK) { + return result; + } + std::memcpy(this->localData.fields.buffer, commandData, MEM_ADDRESS_SIZE); + std::memcpy(this->localData.fields.buffer + MEM_ADDRESS_SIZE, commandData + MEM_ADDRESS_SIZE, + MEM_LEN_SIZE); + size_t size = sizeof(memLen); + const uint8_t* memLenPtr = commandData + MEM_ADDRESS_SIZE; + result = + SerializeAdapter::deSerialize(&memLen, &memLenPtr, &size, SerializeIF::Endianness::BIG); + if (result != HasReturnvaluesIF::RETURN_OK) { + return result; + } + return result; + } + + private: + static const size_t COMMAND_LENGTH = 6; + static const size_t MEM_ADDRESS_SIZE = 4; + static const size_t MEM_LEN_SIZE = 2; + static const uint16_t PACKET_LENGTH = 7; + + uint16_t memLen = 0; + + ReturnValue_t lengthCheck(size_t commandDataLen) { + if (commandDataLen != COMMAND_LENGTH) { + return INVALID_LENGTH; + } + return HasReturnvaluesIF::RETURN_OK; + } +}; + +/** + * @brief This class helps to generate the space packet to write data to a memory address within + * the PLOC. + */ +class TcMemWrite : public TcBase { + public: + /** + * @brief Constructor + */ + TcMemWrite(uint16_t sequenceCount) : TcBase(apid::TC_MEM_WRITE, sequenceCount) {} + + protected: + ReturnValue_t initPacket(const uint8_t* commandData, size_t commandDataLen) { + ReturnValue_t result = HasReturnvaluesIF::RETURN_OK; + result = lengthCheck(commandDataLen); + if (result != HasReturnvaluesIF::RETURN_OK) { + return result; + } + std::memcpy(this->localData.fields.buffer, commandData, commandDataLen); + uint16_t memLen = + *(commandData + MEM_ADDRESS_SIZE) << 8 | *(commandData + MEM_ADDRESS_SIZE + 1); + this->setPacketDataLength(memLen * 4 + FIX_LENGTH - 1); + return result; + } + + private: + // Min length consists of 4 byte address, 2 byte mem length field, 4 byte data (1 word) + static const size_t MIN_COMMAND_DATA_LENGTH = 10; + static const size_t MEM_ADDRESS_SIZE = 4; + static const size_t FIX_LENGTH = 8; + + ReturnValue_t lengthCheck(size_t commandDataLen) { + if (commandDataLen < MIN_COMMAND_DATA_LENGTH) { + sif::warning << "TcMemWrite: Command has invalid length " << commandDataLen << std::endl; + return INVALID_LENGTH; + } + return HasReturnvaluesIF::RETURN_OK; + } +}; + +/** + * @brief Class to help creation of flash fopen command. + */ +class FlashFopen : public TcBase { + public: + FlashFopen(uint16_t sequenceCount) : TcBase(apid::TC_FLASHFOPEN, sequenceCount) {} + + static const char APPEND = 'a'; + static const char WRITE = 'w'; + static const char READ = 'r'; + + ReturnValue_t createPacket(std::string filename, char accessMode_) { + accessMode = accessMode_; + ReturnValue_t result = HasReturnvaluesIF::RETURN_OK; + size_t nameSize = filename.size(); + std::memcpy(this->getPacketData(), filename.c_str(), nameSize); + *(this->getPacketData() + nameSize) = NULL_TERMINATOR; + std::memcpy(this->getPacketData() + nameSize + sizeof(NULL_TERMINATOR), &accessMode, + sizeof(accessMode)); + this->setPacketDataLength(nameSize + sizeof(NULL_TERMINATOR) + sizeof(accessMode) + CRC_SIZE - + 1); + result = addCrc(); + if (result != HasReturnvaluesIF::RETURN_OK) { + return result; + } + return result; + } + + private: + char accessMode = APPEND; +}; + +/** + * @brief Class to help creation of flash fclose command. + */ +class FlashFclose : public TcBase { + public: + FlashFclose(uint16_t sequenceCount) : TcBase(apid::TC_FLASHFCLOSE, sequenceCount) {} + + ReturnValue_t createPacket(std::string filename) { + ReturnValue_t result = HasReturnvaluesIF::RETURN_OK; + size_t nameSize = filename.size(); + std::memcpy(this->getPacketData(), filename.c_str(), nameSize); + *(this->getPacketData() + nameSize) = NULL_TERMINATOR; + this->setPacketDataLength(nameSize + sizeof(NULL_TERMINATOR) + CRC_SIZE - 1); + result = addCrc(); + if (result != HasReturnvaluesIF::RETURN_OK) { + return result; + } + return result; + } +}; + +/** + * @brief Class to build flash write space packet. + */ +class TcFlashWrite : public TcBase { + public: + TcFlashWrite(uint16_t sequenceCount) : TcBase(apid::TC_FLASHWRITE, sequenceCount) {} + + ReturnValue_t createPacket(const uint8_t* writeData, uint32_t writeLen_) { + ReturnValue_t result = HasReturnvaluesIF::RETURN_OK; + writeLen = writeLen_; + if (writeLen > MAX_DATA_SIZE) { + sif::debug << "FlashWrite::createPacket: Command data too big" << std::endl; + return HasReturnvaluesIF::RETURN_FAILED; + } + size_t serializedSize = 0; + result = + SerializeAdapter::serialize(&writeLen, this->getPacketData(), &serializedSize, + sizeof(writeLen), SerializeIF::Endianness::BIG); + if (result != HasReturnvaluesIF::RETURN_OK) { + return result; + } + std::memcpy(this->getPacketData() + sizeof(writeLen), writeData, writeLen); + this->setPacketDataLength(static_cast(writeLen + CRC_SIZE - 1)); + result = addCrc(); + if (result != HasReturnvaluesIF::RETURN_OK) { + return result; + } + return HasReturnvaluesIF::RETURN_OK; + } + + private: + uint32_t writeLen = 0; +}; + +/** + * @brief Class to help creation of flash delete command. + */ +class TcFlashDelete : public TcBase { + public: + TcFlashDelete(uint16_t sequenceCount) : TcBase(apid::TC_FLASHDELETE, sequenceCount) {} + + ReturnValue_t createPacket(std::string filename) { + ReturnValue_t result = HasReturnvaluesIF::RETURN_OK; + size_t nameSize = filename.size(); + std::memcpy(this->getPacketData(), filename.c_str(), nameSize); + *(this->getPacketData() + nameSize) = NULL_TERMINATOR; + this->setPacketDataLength(nameSize + sizeof(NULL_TERMINATOR) + CRC_SIZE - 1); + result = addCrc(); + if (result != HasReturnvaluesIF::RETURN_OK) { + return result; + } + return result; + } +}; + +/** + * @brief Class to build replay stop space packet. + */ +class TcReplayStop : public TcBase { + public: + TcReplayStop(uint16_t sequenceCount) : TcBase(apid::TC_REPLAY_STOP, sequenceCount) {} + + ReturnValue_t createPacket() { + ReturnValue_t result = HasReturnvaluesIF::RETURN_OK; + result = addCrc(); + if (result != HasReturnvaluesIF::RETURN_OK) { + return result; + } + this->setPacketDataLength(static_cast(CRC_SIZE - 1)); + return HasReturnvaluesIF::RETURN_OK; + } +}; + +/** + * @brief This class helps to build the replay start command. + */ +class TcReplayStart : public TcBase { + public: + /** + * @brief Constructor + */ + TcReplayStart(uint16_t sequenceCount) : TcBase(apid::TC_REPLAY_START, sequenceCount) {} + + protected: + ReturnValue_t initPacket(const uint8_t* commandData, size_t commandDataLen) { + ReturnValue_t result = HasReturnvaluesIF::RETURN_OK; + result = lengthCheck(commandDataLen); + if (result != HasReturnvaluesIF::RETURN_OK) { + return result; + } + result = checkData(*commandData); + if (result != HasReturnvaluesIF::RETURN_OK) { + return result; + } + std::memcpy(this->localData.fields.buffer, commandData, commandDataLen); + this->setPacketDataLength(commandDataLen + CRC_SIZE - 1); + return result; + } + + private: + static const size_t COMMAND_DATA_LENGTH = 1; + static const uint8_t REPEATING = 0; + static const uint8_t ONCE = 1; + + ReturnValue_t lengthCheck(size_t commandDataLen) { + if (commandDataLen != COMMAND_DATA_LENGTH) { + sif::warning << "TcReplayStart: Command has invalid length " << commandDataLen << std::endl; + return INVALID_LENGTH; + } + return HasReturnvaluesIF::RETURN_OK; + } + + ReturnValue_t checkData(uint8_t replay) { + if (replay != REPEATING && replay != ONCE) { + sif::warning << "TcReplayStart::checkData: Invalid replay value" << std::endl; + return INVALID_PARAMETER; + } + return HasReturnvaluesIF::RETURN_OK; + } +}; + +/** + * @brief This class helps to build downlink power on command. + */ +class TcDownlinkPwrOn : public TcBase { + public: + /** + * @brief Constructor + */ + TcDownlinkPwrOn(uint16_t sequenceCount) : TcBase(apid::TC_DOWNLINK_PWR_ON, sequenceCount) {} + + protected: + ReturnValue_t initPacket(const uint8_t* commandData, size_t commandDataLen) { + ReturnValue_t result = HasReturnvaluesIF::RETURN_OK; + result = lengthCheck(commandDataLen); + if (result != HasReturnvaluesIF::RETURN_OK) { + return result; + } + result = modeCheck(*commandData); + if (result != HasReturnvaluesIF::RETURN_OK) { + return result; + } + result = laneRateCheck(*(commandData + 1)); + if (result != HasReturnvaluesIF::RETURN_OK) { + return result; + } + std::memcpy(this->localData.fields.buffer, commandData, commandDataLen); + std::memcpy(this->localData.fields.buffer + commandDataLen, &MAX_AMPLITUDE, + sizeof(MAX_AMPLITUDE)); + this->setPacketDataLength(commandDataLen + sizeof(MAX_AMPLITUDE) + CRC_SIZE - 1); + return result; + } + + private: + static const uint8_t INTERFACE_ID = CLASS_ID::DWLPWRON_CMD; + + //! [EXPORT] : [COMMENT] Received command has invalid JESD mode (valid modes are 0 - 5) + static const ReturnValue_t INVALID_MODE = MAKE_RETURN_CODE(0xE0); + //! [EXPORT] : [COMMENT] Received command has invalid lane rate (valid lane rate are 0 - 9) + static const ReturnValue_t INVALID_LANE_RATE = MAKE_RETURN_CODE(0xE1); + + static const size_t COMMAND_DATA_LENGTH = 2; + static const uint8_t MAX_MODE = 5; + static const uint8_t MAX_LANE_RATE = 9; + static const uint16_t MAX_AMPLITUDE = 0; + + ReturnValue_t lengthCheck(size_t commandDataLen) { + if (commandDataLen != COMMAND_DATA_LENGTH) { + sif::warning << "TcDownlinkPwrOn: Command has invalid length " << commandDataLen << std::endl; + return INVALID_LENGTH; + } + return HasReturnvaluesIF::RETURN_OK; + } + + ReturnValue_t modeCheck(uint8_t mode) { + if (mode > MAX_MODE) { + sif::warning << "TcDwonlinkPwrOn::modeCheck: Invalid JESD mode" << std::endl; + return INVALID_MODE; + } + return HasReturnvaluesIF::RETURN_OK; + } + + ReturnValue_t laneRateCheck(uint8_t laneRate) { + if (laneRate > MAX_LANE_RATE) { + sif::warning << "TcReplayStart::laneRateCheck: Invalid lane rate" << std::endl; + return INVALID_LANE_RATE; + } + return HasReturnvaluesIF::RETURN_OK; + } +}; + +/** + * @brief Class to build replay stop space packet. + */ +class TcDownlinkPwrOff : public TcBase { + public: + TcDownlinkPwrOff(uint16_t sequenceCount) : TcBase(apid::TC_DOWNLINK_PWR_OFF, sequenceCount) {} + + ReturnValue_t createPacket() { + ReturnValue_t result = HasReturnvaluesIF::RETURN_OK; + result = addCrc(); + if (result != HasReturnvaluesIF::RETURN_OK) { + return result; + } + this->setPacketDataLength(static_cast(CRC_SIZE - 1)); + return HasReturnvaluesIF::RETURN_OK; + } +}; + +/** + * @brief This class helps to build the replay start command. + */ +class TcReplayWriteSeq : public TcBase { + public: + /** + * @brief Constructor + */ + TcReplayWriteSeq(uint16_t sequenceCount) + : TcBase(apid::TC_REPLAY_WRITE_SEQUENCE, sequenceCount) {} + + protected: + ReturnValue_t initPacket(const uint8_t* commandData, size_t commandDataLen) { + ReturnValue_t result = HasReturnvaluesIF::RETURN_OK; + result = lengthCheck(commandDataLen); + if (result != HasReturnvaluesIF::RETURN_OK) { + return result; + } + std::memcpy(this->localData.fields.buffer, commandData, commandDataLen); + *(this->localData.fields.buffer + commandDataLen) = NULL_TERMINATOR; + this->setPacketDataLength(commandDataLen + sizeof(NULL_TERMINATOR) + CRC_SIZE - 1); + return result; + } + + private: + static const size_t USE_DECODING_LENGTH = 1; + + ReturnValue_t lengthCheck(size_t commandDataLen) { + if (commandDataLen > USE_DECODING_LENGTH + MAX_FILENAME_SIZE) { + sif::warning << "TcReplayWriteSeq: Command has invalid length " << commandDataLen + << std::endl; + return INVALID_LENGTH; + } + return HasReturnvaluesIF::RETURN_OK; + } +}; + +class FlashWritePusCmd : public MPSoCReturnValuesIF { + public: + FlashWritePusCmd(){}; + + ReturnValue_t extractFields(const uint8_t* commandData, size_t commandDataLen) { + if (commandDataLen > (config::MAX_PATH_SIZE + config::MAX_FILENAME_SIZE + MAX_FILENAME_SIZE)) { + return INVALID_LENGTH; + } + obcFile = std::string(reinterpret_cast(commandData)); + if (obcFile.size() > (config::MAX_PATH_SIZE + config::MAX_FILENAME_SIZE)) { + return FILENAME_TOO_LONG; + } + mpsocFile = std::string( + reinterpret_cast(commandData + obcFile.size() + SIZE_NULL_TERMINATOR)); + if (mpsocFile.size() > MAX_FILENAME_SIZE) { + return MPSOC_FILENAME_TOO_LONG; + } + return HasReturnvaluesIF::RETURN_OK; + } + + std::string getObcFile() { return obcFile; } + + std::string getMPSoCFile() { return mpsocFile; } + + private: + static const size_t SIZE_NULL_TERMINATOR = 1; + std::string obcFile = ""; + std::string mpsocFile = ""; +}; + +/** + * @brief Class to build replay stop space packet. + */ +class TcModeReplay : public TcBase { + public: + TcModeReplay(uint16_t sequenceCount) : TcBase(apid::TC_MODE_REPLAY, sequenceCount) {} + + ReturnValue_t createPacket() { + ReturnValue_t result = HasReturnvaluesIF::RETURN_OK; + result = addCrc(); + if (result != HasReturnvaluesIF::RETURN_OK) { + return result; + } + this->setPacketDataLength(static_cast(CRC_SIZE - 1)); + return HasReturnvaluesIF::RETURN_OK; + } +}; + +} // namespace mpsoc + +#endif /* MISSION_DEVICES_DEVICEDEFINITIONS_PLOCMPSOCDEFINITIONS_H_ */ diff --git a/bsp_q7s/devices/devicedefinitions/PlocMemDumpDefinitions.h b/linux/devices/devicedefinitions/PlocMemDumpDefinitions.h similarity index 100% rename from bsp_q7s/devices/devicedefinitions/PlocMemDumpDefinitions.h rename to linux/devices/devicedefinitions/PlocMemDumpDefinitions.h diff --git a/bsp_q7s/devices/devicedefinitions/PlocSupervisorDefinitions.h b/linux/devices/devicedefinitions/PlocSupervisorDefinitions.h similarity index 100% rename from bsp_q7s/devices/devicedefinitions/PlocSupervisorDefinitions.h rename to linux/devices/devicedefinitions/PlocSupervisorDefinitions.h diff --git a/bsp_q7s/devices/CMakeLists.txt b/linux/devices/ploc/CMakeLists.txt similarity index 68% rename from bsp_q7s/devices/CMakeLists.txt rename to linux/devices/ploc/CMakeLists.txt index e0f6ee2f..2d1e1998 100644 --- a/bsp_q7s/devices/CMakeLists.txt +++ b/linux/devices/ploc/CMakeLists.txt @@ -2,4 +2,6 @@ target_sources(${OBSW_NAME} PRIVATE PlocSupervisorHandler.cpp PlocUpdater.cpp PlocMemoryDumper.cpp -) \ No newline at end of file + PlocMPSoCHandler.cpp + PlocMPSoCHelper.cpp +) diff --git a/linux/devices/ploc/PlocMPSoCHandler.cpp b/linux/devices/ploc/PlocMPSoCHandler.cpp new file mode 100644 index 00000000..acdfbbca --- /dev/null +++ b/linux/devices/ploc/PlocMPSoCHandler.cpp @@ -0,0 +1,766 @@ +#include "PlocMPSoCHandler.h" + +#include "OBSWConfig.h" +#include "fsfw/datapool/PoolReadGuard.h" +#include "fsfw/globalfunctions/CRC.h" + +PlocMPSoCHandler::PlocMPSoCHandler(object_id_t objectId, object_id_t uartComIFid, + CookieIF* comCookie, PlocMPSoCHelper* plocMPSoCHelper, + Gpio uartIsolatorSwitch) + : DeviceHandlerBase(objectId, uartComIFid, comCookie), + plocMPSoCHelper(plocMPSoCHelper), + uartIsolatorSwitch(uartIsolatorSwitch) { + if (comCookie == nullptr) { + sif::error << "PlocMPSoCHandler: Invalid communication cookie" << std::endl; + } + eventQueue = QueueFactory::instance()->createMessageQueue(EventMessage::EVENT_MESSAGE_SIZE * 5); +} + +PlocMPSoCHandler::~PlocMPSoCHandler() {} + +ReturnValue_t PlocMPSoCHandler::initialize() { + ReturnValue_t result = RETURN_OK; + result = DeviceHandlerBase::initialize(); + if (result != RETURN_OK) { + return result; + } + uartComIf = dynamic_cast(communicationInterface); + if (uartComIf == nullptr) { + sif::warning << "PlocMPSoCHandler::initialize: Invalid uart com if" << std::endl; + return ObjectManagerIF::CHILD_INIT_FAILED; + } + + EventManagerIF* manager = ObjectManager::instance()->get(objects::EVENT_MANAGER); + if (manager == nullptr) { +#if FSFW_CPP_OSTREAM_ENABLED == 1 + sif::error << "PlocMPSoCHandler::initialize: Invalid event manager" << std::endl; +#endif + return ObjectManagerIF::CHILD_INIT_FAILED; + ; + } + result = manager->registerListener(eventQueue->getId()); + if (result != RETURN_OK) { + return result; + } + result = manager->subscribeToEventRange( + eventQueue->getId(), event::getEventId(PlocMPSoCHelper::MPSOC_FLASH_WRITE_FAILED), + event::getEventId(PlocMPSoCHelper::MPSOC_FLASH_WRITE_SUCCESSFUL)); + if (result != RETURN_OK) { +#if FSFW_CPP_OSTREAM_ENABLED == 1 + sif::warning << "PlocMPSoCHandler::initialize: Failed to subscribe to events from " + " ploc mpsoc helper" + << std::endl; +#endif + return ObjectManagerIF::CHILD_INIT_FAILED; + } + + result = plocMPSoCHelper->setComIF(communicationInterface); + if (result != RETURN_OK) { + return ObjectManagerIF::CHILD_INIT_FAILED; + } + plocMPSoCHelper->setComCookie(comCookie); + plocMPSoCHelper->setSequenceCount(&sequenceCount); + return result; +} + +void PlocMPSoCHandler::performOperationHook() { + EventMessage event; + for (ReturnValue_t result = eventQueue->receiveMessage(&event); result == RETURN_OK; + result = eventQueue->receiveMessage(&event)) { + switch (event.getMessageId()) { + case EventMessage::EVENT_MESSAGE: + handleEvent(&event); + break; + default: + sif::debug << "PlocMPSoCHandler::performOperationHook: Did not subscribe to this event" + << " message" << std::endl; + break; + } + } +} + +ReturnValue_t PlocMPSoCHandler::executeAction(ActionId_t actionId, MessageQueueId_t commandedBy, + const uint8_t* data, size_t size) { + ReturnValue_t result = RETURN_OK; + + if (plocMPSoCHelperExecuting) { + return MPSoCReturnValuesIF::MPSOC_HELPER_EXECUTING; + } + + switch (actionId) { + case mpsoc::TC_FLASHWRITE: { + if (size > config::MAX_PATH_SIZE + config::MAX_FILENAME_SIZE) { + return MPSoCReturnValuesIF::FILENAME_TOO_LONG; + } + mpsoc::FlashWritePusCmd flashWritePusCmd; + result = flashWritePusCmd.extractFields(data, size); + if (result != RETURN_OK) { + return result; + } + result = plocMPSoCHelper->startFlashWrite(flashWritePusCmd.getObcFile(), + flashWritePusCmd.getMPSoCFile()); + if (result != RETURN_OK) { + return result; + } + plocMPSoCHelperExecuting = true; + return EXECUTION_FINISHED; + } + case (mpsoc::OBSW_RESET_SEQ_COUNT): { + sequenceCount = 0; + return EXECUTION_FINISHED; + } + default: + break; + } + return DeviceHandlerBase::executeAction(actionId, commandedBy, data, size); +} + +void PlocMPSoCHandler::doStartUp() { +#if OBSW_SWITCH_TO_NORMAL_MODE_AFTER_STARTUP == 1 + setMode(MODE_NORMAL); +#else + setMode(_MODE_TO_ON); +#endif + uartIsolatorSwitch.pullHigh(); +} + +void PlocMPSoCHandler::doShutDown() { + uartIsolatorSwitch.pullLow(); + setMode(_MODE_POWER_DOWN); +} + +ReturnValue_t PlocMPSoCHandler::buildNormalDeviceCommand(DeviceCommandId_t* id) { + return NOTHING_TO_SEND; +} + +ReturnValue_t PlocMPSoCHandler::buildTransitionDeviceCommand(DeviceCommandId_t* id) { + return HasReturnvaluesIF::RETURN_OK; +} + +ReturnValue_t PlocMPSoCHandler::buildCommandFromCommand(DeviceCommandId_t deviceCommand, + const uint8_t* commandData, + size_t commandDataLen) { + ReturnValue_t result = RETURN_OK; + switch (deviceCommand) { + case (mpsoc::TC_MEM_WRITE): { + result = prepareTcMemWrite(commandData, commandDataLen); + break; + } + case (mpsoc::TC_MEM_READ): { + result = prepareTcMemRead(commandData, commandDataLen); + break; + } + case (mpsoc::TC_FLASHDELETE): { + result = prepareTcFlashDelete(commandData, commandDataLen); + break; + } + case (mpsoc::TC_REPLAY_START): { + result = prepareTcReplayStart(commandData, commandDataLen); + break; + } + case (mpsoc::TC_REPLAY_STOP): { + result = prepareTcReplayStop(); + break; + } + case (mpsoc::TC_DOWNLINK_PWR_ON): { + result = prepareTcDownlinkPwrOn(commandData, commandDataLen); + break; + } + case (mpsoc::TC_DOWNLINK_PWR_OFF): { + result = prepareTcDownlinkPwrOff(); + break; + } + case (mpsoc::TC_REPLAY_WRITE_SEQUENCE): { + result = prepareTcReplayWriteSequence(commandData, commandDataLen); + break; + } + case (mpsoc::TC_MODE_REPLAY): { + result = prepareTcModeReplay(); + break; + } + default: + sif::debug << "PlocMPSoCHandler::buildCommandFromCommand: Command not implemented" + << std::endl; + result = DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED; + break; + } + + if (result == RETURN_OK) { + /** + * Flushing the receive buffer to make sure there are no data left from a faulty reply. + */ + uartComIf->flushUartRxBuffer(comCookie); + } + + return result; +} + +void PlocMPSoCHandler::fillCommandAndReplyMap() { + this->insertInCommandMap(mpsoc::TC_MEM_WRITE); + this->insertInCommandMap(mpsoc::TC_MEM_READ); + this->insertInCommandMap(mpsoc::TC_FLASHDELETE); + this->insertInCommandMap(mpsoc::TC_REPLAY_START); + this->insertInCommandMap(mpsoc::TC_REPLAY_STOP); + this->insertInCommandMap(mpsoc::TC_DOWNLINK_PWR_ON); + this->insertInCommandMap(mpsoc::TC_DOWNLINK_PWR_OFF); + this->insertInCommandMap(mpsoc::TC_REPLAY_WRITE_SEQUENCE); + this->insertInCommandMap(mpsoc::TC_MODE_REPLAY); + this->insertInReplyMap(mpsoc::ACK_REPORT, 1, nullptr, mpsoc::SIZE_ACK_REPORT); + this->insertInReplyMap(mpsoc::EXE_REPORT, 3, nullptr, mpsoc::SIZE_EXE_REPORT); + this->insertInReplyMap(mpsoc::TM_MEMORY_READ_REPORT, 2, nullptr, mpsoc::SIZE_TM_MEM_READ_REPORT); +} + +ReturnValue_t PlocMPSoCHandler::scanForReply(const uint8_t* start, size_t remainingSize, + DeviceCommandId_t* foundId, size_t* foundLen) { + ReturnValue_t result = RETURN_OK; + + uint16_t apid = (*(start) << 8 | *(start + 1)) & APID_MASK; + + switch (apid) { + case (mpsoc::apid::ACK_SUCCESS): + *foundLen = mpsoc::SIZE_ACK_REPORT; + *foundId = mpsoc::ACK_REPORT; + break; + case (mpsoc::apid::ACK_FAILURE): + *foundLen = mpsoc::SIZE_ACK_REPORT; + *foundId = mpsoc::ACK_REPORT; + break; + case (mpsoc::apid::TM_MEMORY_READ_REPORT): + *foundLen = tmMemReadReport.rememberRequestedSize; + *foundId = mpsoc::TM_MEMORY_READ_REPORT; + break; + case (mpsoc::apid::EXE_SUCCESS): + *foundLen = mpsoc::SIZE_EXE_REPORT; + *foundId = mpsoc::EXE_REPORT; + break; + case (mpsoc::apid::EXE_FAILURE): + *foundLen = mpsoc::SIZE_EXE_REPORT; + *foundId = mpsoc::EXE_REPORT; + break; + default: { + sif::debug << "PlocMPSoCHandler::scanForReply: Reply has invalid apid" << std::endl; + *foundLen = remainingSize; + return MPSoCReturnValuesIF::INVALID_APID; + } + } + sequenceCount++; + uint16_t recvSeqCnt = (*(start + 2) << 8 | *(start + 3)) & PACKET_SEQUENCE_COUNT_MASK; + if (recvSeqCnt != sequenceCount) { + triggerEvent(MPSOC_HANDLER_SEQ_CNT_MISMATCH, sequenceCount, recvSeqCnt); + sequenceCount = recvSeqCnt; + } + return result; +} + +ReturnValue_t PlocMPSoCHandler::interpretDeviceReply(DeviceCommandId_t id, const uint8_t* packet) { + ReturnValue_t result = RETURN_OK; + + switch (id) { + case mpsoc::ACK_REPORT: { + result = handleAckReport(packet); + break; + } + case (mpsoc::TM_MEMORY_READ_REPORT): { + result = handleMemoryReadReport(packet); + break; + } + case (mpsoc::EXE_REPORT): { + result = handleExecutionReport(packet); + break; + } + default: { + sif::debug << "PlocMPSoCHandler::interpretDeviceReply: Unknown device reply id" << std::endl; + return DeviceHandlerIF::UNKNOWN_DEVICE_REPLY; + } + } + + return result; +} + +void PlocMPSoCHandler::setNormalDatapoolEntriesInvalid() {} + +uint32_t PlocMPSoCHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 500; } + +ReturnValue_t PlocMPSoCHandler::initializeLocalDataPool(localpool::DataPool& localDataPoolMap, + LocalDataPoolManager& poolManager) { + return HasReturnvaluesIF::RETURN_OK; +} + +void PlocMPSoCHandler::handleEvent(EventMessage* eventMessage) { + object_id_t objectId = eventMessage->getReporter(); + switch (objectId) { + case objects::PLOC_MPSOC_HELPER: { + plocMPSoCHelperExecuting = false; + break; + } + default: + sif::debug << "PlocMPSoCHandler::handleEvent: Did not subscribe to this event" << std::endl; + break; + } +} + +ReturnValue_t PlocMPSoCHandler::prepareTcMemWrite(const uint8_t* commandData, + size_t commandDataLen) { + ReturnValue_t result = RETURN_OK; + sequenceCount++; + mpsoc::TcMemWrite tcMemWrite(sequenceCount); + result = tcMemWrite.createPacket(commandData, commandDataLen); + if (result != RETURN_OK) { + sequenceCount--; + return result; + } + copyToCommandBuffer(&tcMemWrite); + return RETURN_OK; +} + +ReturnValue_t PlocMPSoCHandler::prepareTcMemRead(const uint8_t* commandData, + size_t commandDataLen) { + ReturnValue_t result = RETURN_OK; + sequenceCount++; + mpsoc::TcMemRead tcMemRead(sequenceCount); + result = tcMemRead.createPacket(commandData, commandDataLen); + if (result != RETURN_OK) { + sequenceCount--; + return result; + } + copyToCommandBuffer(&tcMemRead); + tmMemReadReport.rememberRequestedSize = tcMemRead.getMemLen() * 4 + TmMemReadReport::FIX_SIZE; + return RETURN_OK; +} + +ReturnValue_t PlocMPSoCHandler::prepareTcFlashDelete(const uint8_t* commandData, + size_t commandDataLen) { + if (commandDataLen > config::MAX_PATH_SIZE + config::MAX_FILENAME_SIZE) { + return NAME_TOO_LONG; + } + ReturnValue_t result = RETURN_OK; + sequenceCount++; + mpsoc::TcFlashDelete tcFlashDelete(sequenceCount); + result = tcFlashDelete.createPacket( + std::string(reinterpret_cast(commandData), commandDataLen)); + if (result != RETURN_OK) { + sequenceCount--; + return result; + } + copyToCommandBuffer(&tcFlashDelete); + return RETURN_OK; +} + +ReturnValue_t PlocMPSoCHandler::prepareTcReplayStart(const uint8_t* commandData, + size_t commandDataLen) { + ReturnValue_t result = RETURN_OK; + sequenceCount++; + mpsoc::TcReplayStart tcReplayStart(sequenceCount); + result = tcReplayStart.createPacket(commandData, commandDataLen); + if (result != RETURN_OK) { + sequenceCount--; + return result; + } + copyToCommandBuffer(&tcReplayStart); + return RETURN_OK; +} + +ReturnValue_t PlocMPSoCHandler::prepareTcReplayStop() { + ReturnValue_t result = RETURN_OK; + sequenceCount++; + mpsoc::TcReplayStop tcReplayStop(sequenceCount); + result = tcReplayStop.createPacket(); + if (result != RETURN_OK) { + sequenceCount--; + return result; + } + copyToCommandBuffer(&tcReplayStop); + return RETURN_OK; +} + +ReturnValue_t PlocMPSoCHandler::prepareTcDownlinkPwrOn(const uint8_t* commandData, + size_t commandDataLen) { + ReturnValue_t result = RETURN_OK; + sequenceCount++; + mpsoc::TcDownlinkPwrOn tcDownlinkPwrOn(sequenceCount); + result = tcDownlinkPwrOn.createPacket(commandData, commandDataLen); + if (result != RETURN_OK) { + sequenceCount--; + return result; + } + copyToCommandBuffer(&tcDownlinkPwrOn); + return RETURN_OK; +} + +ReturnValue_t PlocMPSoCHandler::prepareTcDownlinkPwrOff() { + ReturnValue_t result = RETURN_OK; + sequenceCount++; + mpsoc::TcDownlinkPwrOff tcDownlinkPwrOff(sequenceCount); + result = tcDownlinkPwrOff.createPacket(); + if (result != RETURN_OK) { + sequenceCount--; + return result; + } + copyToCommandBuffer(&tcDownlinkPwrOff); + return RETURN_OK; +} + +ReturnValue_t PlocMPSoCHandler::prepareTcReplayWriteSequence(const uint8_t* commandData, + size_t commandDataLen) { + ReturnValue_t result = RETURN_OK; + sequenceCount++; + mpsoc::TcReplayWriteSeq tcReplayWriteSeq(sequenceCount); + result = tcReplayWriteSeq.createPacket(commandData, commandDataLen); + if (result != RETURN_OK) { + sequenceCount--; + return result; + } + copyToCommandBuffer(&tcReplayWriteSeq); + return RETURN_OK; +} + +ReturnValue_t PlocMPSoCHandler::prepareTcModeReplay() { + ReturnValue_t result = RETURN_OK; + sequenceCount++; + mpsoc::TcModeReplay tcModeReplay(sequenceCount); + result = tcModeReplay.createPacket(); + if (result != RETURN_OK) { + sequenceCount--; + return result; + } + memcpy(commandBuffer, tcModeReplay.getWholeData(), tcModeReplay.getFullSize()); + rawPacket = commandBuffer; + rawPacketLen = tcModeReplay.getFullSize(); + nextReplyId = mpsoc::ACK_REPORT; + return RETURN_OK; +} + +void PlocMPSoCHandler::copyToCommandBuffer(mpsoc::TcBase* tc) { + if (tc == nullptr) { + sif::debug << "PlocMPSoCHandler::copyToCommandBuffer: Invalid TC" << std::endl; + } + memcpy(commandBuffer, tc->getWholeData(), tc->getFullSize()); + rawPacket = commandBuffer; + rawPacketLen = tc->getFullSize(); + nextReplyId = mpsoc::ACK_REPORT; +} + +ReturnValue_t PlocMPSoCHandler::verifyPacket(const uint8_t* start, size_t foundLen) { + uint16_t receivedCrc = *(start + foundLen - 2) << 8 | *(start + foundLen - 1); + uint16_t recalculatedCrc = CRC::crc16ccitt(start, foundLen - 2); + if (receivedCrc != recalculatedCrc) { + return MPSoCReturnValuesIF::CRC_FAILURE; + } + return RETURN_OK; +} + +ReturnValue_t PlocMPSoCHandler::handleAckReport(const uint8_t* data) { + ReturnValue_t result = RETURN_OK; + + result = verifyPacket(data, mpsoc::SIZE_ACK_REPORT); + if (result == MPSoCReturnValuesIF::CRC_FAILURE) { + sif::warning << "PlocMPSoCHandler::handleAckReport: CRC failure" << std::endl; + nextReplyId = mpsoc::NONE; + replyRawReplyIfnotWiretapped(data, mpsoc::SIZE_ACK_REPORT); + triggerEvent(MPSOC_HANDLER_CRC_FAILURE); + sendFailureReport(mpsoc::ACK_REPORT, MPSoCReturnValuesIF::CRC_FAILURE); + disableAllReplies(); + return IGNORE_REPLY_DATA; + } + + uint16_t apid = (*(data) << 8 | *(data + 1)) & APID_MASK; + + switch (apid) { + case mpsoc::apid::ACK_FAILURE: { + // TODO: Interpretation of status field in acknowledgment report + sif::debug << "PlocMPSoCHandler::handleAckReport: Received Ack failure report" << std::endl; + DeviceCommandId_t commandId = getPendingCommand(); + uint16_t status = getStatus(data); + if (commandId != DeviceHandlerIF::NO_COMMAND_ID) { + triggerEvent(ACK_FAILURE, commandId, status); + } + sendFailureReport(mpsoc::ACK_REPORT, MPSoCReturnValuesIF::RECEIVED_ACK_FAILURE); + disableAllReplies(); + nextReplyId = mpsoc::NONE; + result = IGNORE_REPLY_DATA; + break; + } + case mpsoc::apid::ACK_SUCCESS: { + setNextReplyId(); + break; + } + default: { + sif::debug << "PlocMPSoCHandler::handleAckReport: Invalid APID in Ack report" << std::endl; + result = RETURN_FAILED; + break; + } + } + + return result; +} + +ReturnValue_t PlocMPSoCHandler::handleExecutionReport(const uint8_t* data) { + ReturnValue_t result = RETURN_OK; + + result = verifyPacket(data, mpsoc::SIZE_EXE_REPORT); + if (result == MPSoCReturnValuesIF::CRC_FAILURE) { + sif::warning << "PlocMPSoCHandler::handleExecutionReport: CRC failure" << std::endl; + nextReplyId = mpsoc::NONE; + return result; + } + + uint16_t apid = (*(data) << 8 | *(data + 1)) & APID_MASK; + + switch (apid) { + case (mpsoc::apid::EXE_SUCCESS): { + break; + } + case (mpsoc::apid::EXE_FAILURE): { + // TODO: Interpretation of status field in execution report + sif::warning << "PlocMPSoCHandler::handleExecutionReport: Received execution failure report" + << std::endl; + DeviceCommandId_t commandId = getPendingCommand(); + if (commandId != DeviceHandlerIF::NO_COMMAND_ID) { + uint16_t status = getStatus(data); + triggerEvent(EXE_FAILURE, commandId, status); + } else { + sif::debug << "PlocMPSoCHandler::handleExecutionReport: Unknown command id" << std::endl; + } + printStatus(data); + sendFailureReport(mpsoc::EXE_REPORT, MPSoCReturnValuesIF::RECEIVED_EXE_FAILURE); + disableExeReportReply(); + result = IGNORE_REPLY_DATA; + break; + } + default: { + sif::warning << "PlocMPSoCHandler::handleExecutionReport: Unknown APID" << std::endl; + result = RETURN_FAILED; + break; + } + } + nextReplyId = mpsoc::NONE; + return result; +} + +ReturnValue_t PlocMPSoCHandler::handleMemoryReadReport(const uint8_t* data) { + ReturnValue_t result = RETURN_OK; + result = verifyPacket(data, tmMemReadReport.rememberRequestedSize); + if (result == MPSoCReturnValuesIF::CRC_FAILURE) { + sif::warning << "PlocMPSoCHandler::handleMemoryReadReport: Memory read report has invalid crc" + << std::endl; + } + uint16_t memLen = + *(data + mpsoc::MEM_READ_RPT_LEN_OFFSET) << 8 | *(data + mpsoc::MEM_READ_RPT_LEN_OFFSET + 1); + /** Send data to commanding queue */ + handleDeviceTM(data + mpsoc::DATA_FIELD_OFFSET, mpsoc::SIZE_MEM_READ_RPT_FIX + memLen * 4, + mpsoc::TM_MEMORY_READ_REPORT); + nextReplyId = mpsoc::EXE_REPORT; + return result; +} + +ReturnValue_t PlocMPSoCHandler::enableReplyInReplyMap(DeviceCommandMap::iterator command, + uint8_t expectedReplies, bool useAlternateId, + DeviceCommandId_t alternateReplyID) { + ReturnValue_t result = RETURN_OK; + + uint8_t enabledReplies = 0; + + switch (command->first) { + case mpsoc::TC_MEM_WRITE: + case mpsoc::TC_FLASHDELETE: + case mpsoc::TC_REPLAY_START: + case mpsoc::TC_REPLAY_STOP: + case mpsoc::TC_DOWNLINK_PWR_ON: + case mpsoc::TC_DOWNLINK_PWR_OFF: + case mpsoc::TC_REPLAY_WRITE_SEQUENCE: + case mpsoc::TC_MODE_REPLAY: + enabledReplies = 2; + break; + case mpsoc::TC_MEM_READ: { + enabledReplies = 3; + result = DeviceHandlerBase::enableReplyInReplyMap(command, enabledReplies, true, + mpsoc::TM_MEMORY_READ_REPORT); + if (result != RETURN_OK) { + sif::debug << "PlocMPSoCHandler::enableReplyInReplyMap: Reply with id " + << mpsoc::TM_MEMORY_READ_REPORT << " not in replyMap" << std::endl; + } + break; + } + case mpsoc::OBSW_RESET_SEQ_COUNT: + break; + default: + sif::debug << "PlocMPSoCHandler::enableReplyInReplyMap: Unknown command id" << std::endl; + break; + } + + /** + * Every command causes at least one acknowledgment and one execution report. Therefore both + * replies will be enabled here. + */ + result = + DeviceHandlerBase::enableReplyInReplyMap(command, enabledReplies, true, mpsoc::ACK_REPORT); + if (result != RETURN_OK) { + sif::debug << "PlocMPSoCHandler::enableReplyInReplyMap: Reply with id " << mpsoc::ACK_REPORT + << " not in replyMap" << std::endl; + } + + result = + DeviceHandlerBase::enableReplyInReplyMap(command, enabledReplies, true, mpsoc::EXE_REPORT); + if (result != RETURN_OK) { + sif::debug << "PlocMPSoCHandler::enableReplyInReplyMap: Reply with id " << mpsoc::EXE_REPORT + << " not in replyMap" << std::endl; + } + + switch (command->first) { + case mpsoc::TC_REPLAY_WRITE_SEQUENCE: { + DeviceReplyIter iter = deviceReplyMap.find(mpsoc::EXE_REPORT); + // Overwrite delay cycles because replay write sequence command can required up to + // 30 seconds for execution + iter->second.delayCycles = mpsoc::TC_WRITE_SEQ_EXECUTION_DELAY; + break; + } + case mpsoc::TC_DOWNLINK_PWR_ON: { + DeviceReplyIter iter = deviceReplyMap.find(mpsoc::EXE_REPORT); + // + iter->second.delayCycles = mpsoc::TC_DOWNLINK_PWR_ON; + break; + } + default: + break; + } + + return RETURN_OK; +} + +void PlocMPSoCHandler::setNextReplyId() { + switch (getPendingCommand()) { + case mpsoc::TC_MEM_READ: + nextReplyId = mpsoc::TM_MEMORY_READ_REPORT; + break; + default: + /* If no telemetry is expected the next reply is always the execution report */ + nextReplyId = mpsoc::EXE_REPORT; + break; + } +} +size_t PlocMPSoCHandler::getNextReplyLength(DeviceCommandId_t commandId) { + size_t replyLen = 0; + + if (nextReplyId == mpsoc::NONE) { + return replyLen; + } + + DeviceReplyIter iter = deviceReplyMap.find(nextReplyId); + + if (iter != deviceReplyMap.end()) { + if (iter->second.delayCycles == 0) { + /* Reply inactive */ + return replyLen; + } + switch (nextReplyId) { + case mpsoc::TM_MEMORY_READ_REPORT: { + replyLen = tmMemReadReport.rememberRequestedSize; + break; + } + default: { + replyLen = iter->second.replyLen; + break; + } + } + } else { + sif::debug << "PlocMPSoCHandler::getNextReplyLength: No entry for reply with reply id " + << std::hex << nextReplyId << " in deviceReplyMap" << std::endl; + } + + return replyLen; +} + +void PlocMPSoCHandler::handleDeviceTM(const uint8_t* data, size_t dataSize, + DeviceCommandId_t replyId) { + ReturnValue_t result = RETURN_OK; + + if (wiretappingMode == RAW) { + /* Data already sent in doGetRead() */ + return; + } + + DeviceReplyMap::iterator iter = deviceReplyMap.find(replyId); + if (iter == deviceReplyMap.end()) { + sif::debug << "PlocMPSoCHandler::handleDeviceTM: Unknown reply id" << std::endl; + return; + } + MessageQueueId_t queueId = iter->second.command->second.sendReplyTo; + + if (queueId == NO_COMMANDER) { + return; + } + + result = actionHelper.reportData(queueId, replyId, data, dataSize); + if (result != RETURN_OK) { + sif::debug << "PlocMPSoCHandler::handleDeviceTM: Failed to report data" << std::endl; + } +} + +void PlocMPSoCHandler::disableAllReplies() { + DeviceReplyMap::iterator iter; + + /* Disable ack reply */ + iter = deviceReplyMap.find(mpsoc::ACK_REPORT); + DeviceReplyInfo* info = &(iter->second); + info->delayCycles = 0; + info->command = deviceCommandMap.end(); + + DeviceCommandId_t commandId = getPendingCommand(); + + /* If the command expects a telemetry packet the appropriate tm reply will be disabled here */ + switch (commandId) { + case mpsoc::TC_MEM_WRITE: + break; + case mpsoc::TC_MEM_READ: { + iter = deviceReplyMap.find(mpsoc::TM_MEMORY_READ_REPORT); + info = &(iter->second); + info->delayCycles = 0; + info->command = deviceCommandMap.end(); + break; + } + default: { + sif::debug << "PlocMPSoCHandler::disableAllReplies: Unknown command id" << commandId + << std::endl; + break; + } + } + + /* We must always disable the execution report reply here */ + disableExeReportReply(); + nextReplyId = mpsoc::NONE; +} + +void PlocMPSoCHandler::sendFailureReport(DeviceCommandId_t replyId, ReturnValue_t status) { + DeviceReplyIter iter = deviceReplyMap.find(replyId); + if (iter == deviceReplyMap.end()) { + sif::debug << "PlocMPSoCHandler::sendFailureReport: Reply not in reply map" << std::endl; + return; + } + DeviceCommandInfo* info = &(iter->second.command->second); + if (info == nullptr) { + sif::debug << "PlocMPSoCHandler::sendFailureReport: Reply has no active command" << std::endl; + return; + } + if (info->sendReplyTo != NO_COMMANDER) { + actionHelper.finish(false, info->sendReplyTo, iter->first, status); + } + info->isExecuting = false; +} + +void PlocMPSoCHandler::disableExeReportReply() { + DeviceReplyIter iter = deviceReplyMap.find(mpsoc::EXE_REPORT); + DeviceReplyInfo* info = &(iter->second); + info->delayCycles = 0; + info->command = deviceCommandMap.end(); + /* Expected replies is set to one here. The value will be set to 0 in replyToReply() */ + info->command->second.expectedReplies = 0; +} + +void PlocMPSoCHandler::printStatus(const uint8_t* data) { + uint16_t status = *(data + STATUS_OFFSET) << 8 | *(data + STATUS_OFFSET + 1); + sif::info << "Verification report status: 0x" << std::hex << status << std::endl; +} + +uint16_t PlocMPSoCHandler::getStatus(const uint8_t* data) { + return *(data + STATUS_OFFSET) << 8 | *(data + STATUS_OFFSET + 1); +} diff --git a/mission/devices/PlocMPSoCHandler.h b/linux/devices/ploc/PlocMPSoCHandler.h similarity index 54% rename from mission/devices/PlocMPSoCHandler.h rename to linux/devices/ploc/PlocMPSoCHandler.h index 09ad2e2a..3b323109 100644 --- a/mission/devices/PlocMPSoCHandler.h +++ b/linux/devices/ploc/PlocMPSoCHandler.h @@ -1,33 +1,40 @@ -#ifndef MISSION_DEVICES_PLOCMPSOCHANDLER_H_ -#define MISSION_DEVICES_PLOCMPSOCHANDLER_H_ +#ifndef BSP_Q7S_DEVICES_PLOC_PLOCMPSOCHANDLER_H_ +#define BSP_Q7S_DEVICES_PLOC_PLOCMPSOCHANDLER_H_ -#include -#include +#include -#include +#include "PlocMPSoCHelper.h" +#include "fsfw/devicehandlers/DeviceHandlerBase.h" +#include "fsfw/ipc/QueueFactory.h" +#include "fsfw/tmtcservices/SourceSequenceCounter.h" +#include "fsfw_hal/linux/gpio/Gpio.h" +#include "fsfw_hal/linux/uart/UartComIF.h" +#include "linux/devices/devicedefinitions/MPSoCReturnValuesIF.h" +#include "linux/devices/devicedefinitions/PlocMPSoCDefinitions.h" /** - * @brief This is the device handler for the MPSoC which is programmed by the ILH of the - * university of stuttgart. + * @brief This is the device handler for the MPSoC of the payload computer. + * + * @details The PLOC uses the space packet protocol for communication. Each command will be + * answered with at least one acknowledgment and one execution report. + * Flight manual: + * https://egit.irs.uni-stuttgart.de/redmine/projects/eive-flight-manual/wiki/PLOC_MPSoC ICD: + * https://eive-cloud.irs.uni-stuttgart.de/index.php/apps/files/?dir=/EIVE_TAS-ILH-IRS/ICD-PLOC/ILH&fileid=1030263 + * + * @note The sequence count in the space packets must be incremented with each received and sent + * packet otherwise the MPSoC will reply with an acknowledgment failure report. * - * @details - * The PLOC uses the space packet protocol for communication. To each command the PLOC - * answers with at least one acknowledgment and one execution report. - * Flight manual: - * https://egit.irs.uni-stuttgart.de/redmine/projects/eive-flight-manual/wiki/PLOC_Commands - * ILH ICD: https://eive-cloud.irs.uni-stuttgart.de/index.php/apps/files/?dir=/EIVE_IRS/ - * Arbeitsdaten/08_Used%20Components/PLOC&fileid=940960 * @author J. Meier */ class PlocMPSoCHandler : public DeviceHandlerBase { public: - PlocMPSoCHandler(object_id_t objectId, object_id_t comIF, CookieIF* comCookie); + PlocMPSoCHandler(object_id_t objectId, object_id_t uartComIFid, CookieIF* comCookie, + PlocMPSoCHelper* plocMPSoCHelper, Gpio uartIsolatorSwitch); virtual ~PlocMPSoCHandler(); - - /** - * @brief Sets mode to MODE_NORMAL. Can be used for debugging. - */ - void setModeNormal(); + virtual ReturnValue_t initialize() override; + ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy, + const uint8_t* data, size_t size) override; + void performOperationHook() override; protected: void doStartUp() override; @@ -50,71 +57,78 @@ class PlocMPSoCHandler : public DeviceHandlerBase { size_t getNextReplyLength(DeviceCommandId_t deviceCommand) override; private: - static const uint8_t INTERFACE_ID = CLASS_ID::PLOC_MPSOC_HANDLER; - - //! Space Packet received from PLOC has invalid CRC - static const ReturnValue_t CRC_FAILURE = MAKE_RETURN_CODE(0xA0); - //! Received ACK failure reply from PLOC - static const ReturnValue_t RECEIVED_ACK_FAILURE = MAKE_RETURN_CODE(0xA1); - //! Received execution failure reply from PLOC - static const ReturnValue_t RECEIVED_EXE_FAILURE = MAKE_RETURN_CODE(0xA2); - //! Received space packet with invalid APID from PLOC - static const ReturnValue_t INVALID_APID = MAKE_RETURN_CODE(0xA3); - static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PLOC_MPSOC_HANDLER; - //! PLOC crc failure in telemetry packet + //! [EXPORT] : [COMMENT] PLOC crc failure in telemetry packet static const Event MEMORY_READ_RPT_CRC_FAILURE = MAKE_EVENT(1, severity::LOW); - //! PLOC receive acknowledgment failure report + //! [EXPORT] : [COMMENT] PLOC receive acknowledgment failure report + //! P1: Command Id which leads the acknowledgment failure report + //! P2: The status field inserted by the MPSoC into the data field static const Event ACK_FAILURE = MAKE_EVENT(2, severity::LOW); - //! PLOC receive execution failure report + //! [EXPORT] : [COMMENT] PLOC receive execution failure report + //! P1: Command Id which leads the execution failure report + //! P2: The status field inserted by the MPSoC into the data field static const Event EXE_FAILURE = MAKE_EVENT(3, severity::LOW); - //! PLOC reply has invalid crc - static const Event CRC_FAILURE_EVENT = MAKE_EVENT(4, severity::LOW); + //! [EXPORT] : [COMMENT] PLOC reply has invalid crc + static const Event MPSOC_HANDLER_CRC_FAILURE = MAKE_EVENT(4, severity::LOW); + //! [EXPORT] : [COMMENT] Packet sequence count in received space packet does not match expected + //! count P1: Expected sequence count P2: Received sequence count + static const Event MPSOC_HANDLER_SEQ_CNT_MISMATCH = MAKE_EVENT(5, severity::LOW); + + //! [EXPORT] : [COMMENT] Received command has file string with invalid length + static const ReturnValue_t NAME_TOO_LONG = MAKE_RETURN_CODE(0xD0); static const uint16_t APID_MASK = 0x7FF; static const uint16_t PACKET_SEQUENCE_COUNT_MASK = 0x3FFF; + static const uint8_t STATUS_OFFSET = 10; - uint8_t commandBuffer[PLOC_MPSOC::MAX_COMMAND_SIZE]; + MessageQueueIF* eventQueue = nullptr; - /** - * @brief This object is incremented each time a packet is sent or received. By checking the - * packet sequence count of a received packet, no packets can be lost without noticing - * it. Only the least significant 14 bits represent the packet sequence count in a - * space packet. Thus the maximum value amounts to 16383 (0x3FFF). - * @note Normally this should never happen because the PLOC replies are always sent in a - * fixed order. However, the PLOC software checks this value and will return an ACK - * failure report in case the sequence count is not incremented with each transferred - * space packet. - */ - uint16_t packetSequenceCount = 0x3FFF; + SourceSequenceCounter sequenceCount; + + uint8_t commandBuffer[mpsoc::MAX_COMMAND_SIZE]; /** * This variable is used to store the id of the next reply to receive. This is necessary * because the PLOC sends as reply to each command at least one acknowledgment and execution * report. */ - DeviceCommandId_t nextReplyId = PLOC_MPSOC::NONE; + DeviceCommandId_t nextReplyId = mpsoc::NONE; + + UartComIF* uartComIf = nullptr; + + PlocMPSoCHelper* plocMPSoCHelper = nullptr; + Gpio uartIsolatorSwitch; + + // Used to block incoming commands when MPSoC helper class is currently executing a command + bool plocMPSoCHelperExecuting = false; + + class TmMemReadReport { + public: + static const uint8_t FIX_SIZE = 14; + size_t rememberRequestedSize = 0; + }; + + TmMemReadReport tmMemReadReport; /** - * @brief This function fills the commandBuffer to initiate the write memory command. - * - * @param commandData Pointer to action command data. - * @param commanDataLen Size of command data in bytes. - * - * @return RETURN_OK if successful, else RETURN_FAILURE. + * @brief Handles events received from the PLOC MPSoC helper */ - ReturnValue_t prepareTcMemWriteCommand(const uint8_t* commandData, size_t commandDataLen); + void handleEvent(EventMessage* eventMessage); + + ReturnValue_t prepareTcMemWrite(const uint8_t* commandData, size_t commandDataLen); + ReturnValue_t prepareTcMemRead(const uint8_t* commandData, size_t commandDataLen); + ReturnValue_t prepareTcFlashDelete(const uint8_t* commandData, size_t commandDataLen); + ReturnValue_t prepareTcReplayStart(const uint8_t* commandData, size_t commandDataLen); + ReturnValue_t prepareTcReplayStop(); + ReturnValue_t prepareTcDownlinkPwrOn(const uint8_t* commandData, size_t commandDataLen); + ReturnValue_t prepareTcDownlinkPwrOff(); + ReturnValue_t prepareTcReplayWriteSequence(const uint8_t* commandData, size_t commandDataLen); /** - * @brief This function fills the commandBuffer to initiate the write reads command. - * - * @param commandData Pointer to action command data. - * @param commanDataLen Size of command data in bytes. - * - * @return RETURN_OK if successful, else RETURN_FAILURE. + * @brief Copies space packet into command buffer */ - ReturnValue_t prepareTcMemReadCommand(const uint8_t* commandData, size_t commandDataLen); + void copyToCommandBuffer(mpsoc::TcBase* tc); /** * @brief This function checks the crc of the received PLOC reply. @@ -193,20 +207,11 @@ class PlocMPSoCHandler : public DeviceHandlerBase { */ void disableExeReportReply(); - /** - * @brief This function checks and increments the packet sequence count of a received space - * packet. - * - * @param data Pointer to a space packet. - * - * @return RETURN_OK if successful - * - * @details There should be never a case in which a wrong packet sequence count is received - * because the communication scheme between PLOC and OBC always follows a strict - * procedure. Thus this function mainly serves for debugging purposes to detected an - * invalid handling of the packet sequence count. - */ - ReturnValue_t checkPacketSequenceCount(const uint8_t* data); + void printStatus(const uint8_t* data); + + ReturnValue_t prepareTcModeReplay(); + + uint16_t getStatus(const uint8_t* data); }; -#endif /* MISSION_DEVICES_PLOCMPSOCHANDLER_H_ */ +#endif /* BSP_Q7S_DEVICES_PLOC_PLOCMPSOCHANDLER_H_ */ diff --git a/linux/devices/ploc/PlocMPSoCHelper.cpp b/linux/devices/ploc/PlocMPSoCHelper.cpp new file mode 100644 index 00000000..e940e8f3 --- /dev/null +++ b/linux/devices/ploc/PlocMPSoCHelper.cpp @@ -0,0 +1,321 @@ +#include "PlocMPSoCHelper.h" + +#include +#include + +#include "OBSWConfig.h" +#ifdef XIPHOS_Q7S +#include "bsp_q7s/memory/FilesystemHelper.h" +#endif + +#include "mission/utility/Timestamp.h" + +PlocMPSoCHelper::PlocMPSoCHelper(object_id_t objectId) : SystemObject(objectId) {} + +PlocMPSoCHelper::~PlocMPSoCHelper() {} + +ReturnValue_t PlocMPSoCHelper::initialize() { +#ifdef XIPHOS_Q7S + sdcMan = SdCardManager::instance(); + if (sdcMan == nullptr) { + sif::warning << "PlocMPSoCHelper::initialize: Invalid SD Card Manager" << std::endl; + return RETURN_FAILED; + } +#endif + return RETURN_OK; +} + +ReturnValue_t PlocMPSoCHelper::performOperation(uint8_t operationCode) { + ReturnValue_t result = RETURN_OK; + semaphore.acquire(); + while (true) { + switch (internalState) { + case InternalState::IDLE: { + semaphore.acquire(); + break; + } + case InternalState::FLASH_WRITE: { + result = performFlashWrite(); + if (result == RETURN_OK) { + triggerEvent(MPSOC_FLASH_WRITE_SUCCESSFUL); + } else { + triggerEvent(MPSOC_FLASH_WRITE_FAILED); + } + internalState = InternalState::IDLE; + break; + } + default: + sif::debug << "PlocMPSoCHelper::performOperation: Invalid state" << std::endl; + break; + } + } +} + +ReturnValue_t PlocMPSoCHelper::setComIF(DeviceCommunicationIF* communicationInterface_) { + uartComIF = dynamic_cast(communicationInterface_); + if (uartComIF == nullptr) { + sif::warning << "PlocMPSoCHelper::initialize: Invalid uart com if" << std::endl; + return RETURN_FAILED; + } + return RETURN_OK; +} + +void PlocMPSoCHelper::setComCookie(CookieIF* comCookie_) { comCookie = comCookie_; } + +void PlocMPSoCHelper::setSequenceCount(SourceSequenceCounter* sequenceCount_) { + sequenceCount = sequenceCount_; +} + +ReturnValue_t PlocMPSoCHelper::startFlashWrite(std::string obcFile, std::string mpsocFile) { + ReturnValue_t result = RETURN_OK; +#ifdef XIPHOS_Q7S + result = FilesystemHelper::checkPath(obcFile); + if (result != RETURN_OK) { + return result; + } + result = FilesystemHelper::fileExists(mpsocFile); + if (result != RETURN_OK) { + return result; + } +#endif +#ifdef TE0720_1CFA + if (not std::filesystem::exists(obcFile)) { + sif::warning << "PlocMPSoCHelper::startFlashWrite: File " << obcFile << "does not exist" + << std::endl; + return RETURN_FAILED; + } +#endif + + flashWrite.obcFile = obcFile; + flashWrite.mpsocFile = mpsocFile; + internalState = InternalState::FLASH_WRITE; + result = resetHelper(); + if (result != RETURN_OK) { + return result; + } + return result; +} + +ReturnValue_t PlocMPSoCHelper::resetHelper() { + ReturnValue_t result = RETURN_OK; + semaphore.release(); + terminate = false; + result = uartComIF->flushUartRxBuffer(comCookie); + return result; +} + +void PlocMPSoCHelper::stopProcess() { terminate = true; } + +ReturnValue_t PlocMPSoCHelper::performFlashWrite() { + ReturnValue_t result = RETURN_OK; + result = flashfopen(); + if (result != RETURN_OK) { + return result; + } + uint8_t tempData[mpsoc::MAX_DATA_SIZE]; + std::ifstream file(flashWrite.obcFile, std::ifstream::binary); + // Set position of next character to end of file input stream + file.seekg(0, file.end); + // tellg returns position of character in input stream + size_t remainingSize = file.tellg(); + size_t dataLength = 0; + size_t bytesRead = 0; + while (remainingSize > 0) { + if (terminate) { + return RETURN_OK; + } + if (remainingSize > mpsoc::MAX_DATA_SIZE) { + dataLength = mpsoc::MAX_DATA_SIZE; + } else { + dataLength = remainingSize; + } + if (file.is_open()) { + file.seekg(bytesRead, file.beg); + file.read(reinterpret_cast(tempData), dataLength); + bytesRead += dataLength; + remainingSize -= dataLength; + } else { + return FILE_CLOSED_ACCIDENTALLY; + } + (*sequenceCount)++; + mpsoc::TcFlashWrite tc(*sequenceCount); + tc.createPacket(tempData, dataLength); + result = handlePacketTransmission(tc); + if (result != RETURN_OK) { + return result; + } + } + result = flashfclose(); + if (result != RETURN_OK) { + return result; + } + return result; +} + +ReturnValue_t PlocMPSoCHelper::flashfopen() { + ReturnValue_t result = RETURN_OK; + (*sequenceCount)++; + mpsoc::FlashFopen flashFopen(*sequenceCount); + result = flashFopen.createPacket(flashWrite.mpsocFile, mpsoc::FlashFopen::APPEND); + if (result != RETURN_OK) { + return result; + } + result = handlePacketTransmission(flashFopen); + if (result != RETURN_OK) { + return result; + } + return RETURN_OK; +} + +ReturnValue_t PlocMPSoCHelper::flashfclose() { + ReturnValue_t result = RETURN_OK; + (*sequenceCount)++; + mpsoc::FlashFclose flashFclose(*sequenceCount); + result = flashFclose.createPacket(flashWrite.mpsocFile); + if (result != RETURN_OK) { + return result; + } + result = handlePacketTransmission(flashFclose); + if (result != RETURN_OK) { + return result; + } + return RETURN_OK; +} + +ReturnValue_t PlocMPSoCHelper::handlePacketTransmission(mpsoc::TcBase& tc) { + ReturnValue_t result = RETURN_OK; + result = sendCommand(tc); + if (result != RETURN_OK) { + return result; + } + result = handleAck(); + if (result != RETURN_OK) { + return result; + } + result = handleExe(); + if (result != RETURN_OK) { + return result; + } + return RETURN_OK; +} + +ReturnValue_t PlocMPSoCHelper::sendCommand(mpsoc::TcBase& tc) { + ReturnValue_t result = RETURN_OK; + result = uartComIF->sendMessage(comCookie, tc.getWholeData(), tc.getFullSize()); + if (result != RETURN_OK) { + sif::warning << "PlocMPSoCHelper::sendCommand: Failed to send command" << std::endl; + triggerEvent(SENDING_COMMAND_FAILED, result, static_cast(internalState)); + return result; + } + return result; +} + +ReturnValue_t PlocMPSoCHelper::handleAck() { + ReturnValue_t result = RETURN_OK; + mpsoc::TmPacket tmPacket; + result = handleTmReception(&tmPacket, mpsoc::SIZE_ACK_REPORT); + if (result != RETURN_OK) { + return result; + } + uint16_t apid = tmPacket.getAPID(); + if (apid != mpsoc::apid::ACK_SUCCESS) { + handleAckApidFailure(apid); + return RETURN_FAILED; + } + return RETURN_OK; +} + +void PlocMPSoCHelper::handleAckApidFailure(uint16_t apid) { + if (apid == mpsoc::apid::ACK_FAILURE) { + triggerEvent(ACK_FAILURE_REPORT, static_cast(internalState)); + sif::warning << "PlocMPSoCHelper::handleAckApidFailure: Received acknowledgement failure " + << "report" << std::endl; + } else { + triggerEvent(ACK_INVALID_APID, apid, static_cast(internalState)); + sif::warning << "PlocMPSoCHelper::handleAckApidFailure: Expected acknowledgement report " + << "but received space packet with apid " << std::hex << apid << std::endl; + } +} + +ReturnValue_t PlocMPSoCHelper::handleExe() { + ReturnValue_t result = RETURN_OK; + mpsoc::TmPacket tmPacket; + result = handleTmReception(&tmPacket, mpsoc::SIZE_EXE_REPORT); + if (result != RETURN_OK) { + return result; + } + uint16_t apid = tmPacket.getAPID(); + if (apid != mpsoc::apid::EXE_SUCCESS) { + handleExeApidFailure(apid); + return RETURN_FAILED; + } + return RETURN_OK; +} + +void PlocMPSoCHelper::handleExeApidFailure(uint16_t apid) { + if (apid == mpsoc::apid::EXE_FAILURE) { + triggerEvent(EXE_FAILURE_REPORT, static_cast(internalState)); + sif::warning << "PlocMPSoCHelper::handleExeApidFailure: Received execution failure " + << "report" << std::endl; + } else { + triggerEvent(EXE_INVALID_APID, apid, static_cast(internalState)); + sif::warning << "PlocMPSoCHelper::handleExeApidFailure: Expected execution report " + << "but received space packet with apid " << std::hex << apid << std::endl; + } +} + +ReturnValue_t PlocMPSoCHelper::handleTmReception(mpsoc::TmPacket* tmPacket, size_t remainingBytes) { + ReturnValue_t result = RETURN_OK; + size_t readBytes = 0; + size_t currentBytes = 0; + for (int retries = 0; retries < RETRIES; retries++) { + result = receive(tmPacket->getWholeData() + readBytes, ¤tBytes, remainingBytes); + if (result != RETURN_OK) { + return result; + } + readBytes += currentBytes; + remainingBytes = remainingBytes - currentBytes; + if (remainingBytes == 0) { + break; + } + } + if (remainingBytes != 0) { + sif::warning << "PlocMPSoCHelper::handleTmReception: Failed to receive reply" << std::endl; + triggerEvent(MISSING_EXE, remainingBytes, static_cast(internalState)); + return RETURN_FAILED; + } + result = tmPacket->checkCrc(); + if (result != RETURN_OK) { + sif::warning << "PlocMPSoCHelper::handleTmReception: CRC check failed" << std::endl; + return result; + } + (*sequenceCount)++; + uint16_t recvSeqCnt = tmPacket->getPacketSequenceCount(); + if (recvSeqCnt != *sequenceCount) { + triggerEvent(MPSOC_HELPER_SEQ_CNT_MISMATCH, *sequenceCount, recvSeqCnt); + *sequenceCount = recvSeqCnt; + } + return result; +} + +ReturnValue_t PlocMPSoCHelper::receive(uint8_t* data, size_t* readBytes, size_t requestBytes) { + ReturnValue_t result = RETURN_OK; + uint8_t* buffer = nullptr; + result = uartComIF->requestReceiveMessage(comCookie, requestBytes); + if (result != RETURN_OK) { + sif::warning << "PlocMPSoCHelper::receive: Failed to request reply" << std::endl; + triggerEvent(MPSOC_HELPER_REQUESTING_REPLY_FAILED, result, + static_cast(static_cast(internalState))); + return RETURN_FAILED; + } + result = uartComIF->readReceivedMessage(comCookie, &buffer, readBytes); + if (result != RETURN_OK) { + sif::warning << "PlocMPSoCHelper::receive: Failed to read received message" << std::endl; + triggerEvent(MPSOC_HELPER_READING_REPLY_FAILED, result, static_cast(internalState)); + return RETURN_FAILED; + } + if (*readBytes > 0) { + std::memcpy(data, buffer, *readBytes); + } + return result; +} diff --git a/linux/devices/ploc/PlocMPSoCHelper.h b/linux/devices/ploc/PlocMPSoCHelper.h new file mode 100644 index 00000000..4cb882c7 --- /dev/null +++ b/linux/devices/ploc/PlocMPSoCHelper.h @@ -0,0 +1,153 @@ +#ifndef BSP_Q7S_DEVICES_PLOCMPSOCHELPER_H_ +#define BSP_Q7S_DEVICES_PLOCMPSOCHELPER_H_ + +#include + +#include "fsfw/devicehandlers/CookieIF.h" +#include "fsfw/objectmanager/SystemObject.h" +#include "fsfw/osal/linux/BinarySemaphore.h" +#include "fsfw/returnvalues/HasReturnvaluesIF.h" +#include "fsfw/tasks/ExecutableObjectIF.h" +#include "fsfw/tmtcservices/SourceSequenceCounter.h" +#include "fsfw_hal/linux/uart/UartComIF.h" +#include "linux/devices/devicedefinitions/PlocMPSoCDefinitions.h" +#ifdef XIPHOS_Q7S +#include "bsp_q7s/memory/SdCardManager.h" +#endif + +/** + * @brief Helper class for MPSoC of PLOC intended to accelerate large data transfers between + * MPSoC and OBC. + * @author J. Meier + */ +class PlocMPSoCHelper : public SystemObject, public ExecutableObjectIF, public HasReturnvaluesIF { + public: + static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PLOC_MPSOC_HELPER; + + //! [EXPORT] : [COMMENT] Flash write fails + static const Event MPSOC_FLASH_WRITE_FAILED = MAKE_EVENT(0, severity::LOW); + //! [EXPORT] : [COMMENT] Flash write successful + static const Event MPSOC_FLASH_WRITE_SUCCESSFUL = MAKE_EVENT(1, severity::LOW); + //! [EXPORT] : [COMMENT] Communication interface returned failure when trying to send the command + //! ot the PLOC + //! P1: Return value returned by the communication interface sendMessage function + //! P2: Internal state of MPSoC helper + static const Event SENDING_COMMAND_FAILED = MAKE_EVENT(2, severity::LOW); + //! [EXPORT] : [COMMENT] Request receive message of communication interface failed + //! P1: Return value returned by the communication interface requestReceiveMessage function + //! P2: Internal state of MPSoC helper + static const Event MPSOC_HELPER_REQUESTING_REPLY_FAILED = MAKE_EVENT(3, severity::LOW); + //! [EXPORT] : [COMMENT] Reading receive message of communication interface failed + //! P1: Return value returned by the communication interface readingReceivedMessage function + //! P2: Internal state of MPSoC helper + static const Event MPSOC_HELPER_READING_REPLY_FAILED = MAKE_EVENT(4, severity::LOW); + //! [EXPORT] : [COMMENT] Did not receive acknowledgement report + //! P1: Number of bytes missing + //! P2: Internal state of MPSoC helper + static const Event MISSING_ACK = MAKE_EVENT(5, severity::LOW); + //! [EXPORT] : [COMMENT] Did not receive execution report + //! P1: Number of bytes missing + //! P2: Internal state of MPSoC helper + static const Event MISSING_EXE = MAKE_EVENT(6, severity::LOW); + //! [EXPORT] : [COMMENT] Received acknowledgement failure report + //! P1: Internal state of MPSoC + static const Event ACK_FAILURE_REPORT = MAKE_EVENT(7, severity::LOW); + //! [EXPORT] : [COMMENT] Received execution failure report + //! P1: Internal state of MPSoC + static const Event EXE_FAILURE_REPORT = MAKE_EVENT(8, severity::LOW); + //! [EXPORT] : [COMMENT] Expected acknowledgement report but received space packet with other apid + //! P1: Apid of received space packet + //! P2: Internal state of MPSoC + static const Event ACK_INVALID_APID = MAKE_EVENT(9, severity::LOW); + //! [EXPORT] : [COMMENT] Expected execution report but received space packet with other apid + //! P1: Apid of received space packet + //! P2: Internal state of MPSoC + static const Event EXE_INVALID_APID = MAKE_EVENT(10, severity::LOW); + //! [EXPORT] : [COMMENT] Received sequence count does not match expected sequence count + //! P1: Expected sequence count + //! P2: Received sequence count + static const Event MPSOC_HELPER_SEQ_CNT_MISMATCH = MAKE_EVENT(11, severity::LOW); + + PlocMPSoCHelper(object_id_t objectId); + virtual ~PlocMPSoCHelper(); + + ReturnValue_t initialize() override; + ReturnValue_t performOperation(uint8_t operationCode = 0) override; + + ReturnValue_t setComIF(DeviceCommunicationIF* communicationInterface_); + void setComCookie(CookieIF* comCookie_); + + /** + * @brief Starts flash write sequence + * + * @param obcFile File where to read from the data + * @param mpsocFile The file of the MPSoC where should be written to + * + * @return RETURN_OK if successful, otherwise error return value + */ + ReturnValue_t startFlashWrite(std::string obcFile, std::string mpsocFile); + + /** + * @brief Can be used to interrupt a running data transfer. + */ + void stopProcess(); + + /** + * @brief Sets the sequence count object responsible for the sequence count handling + */ + void setSequenceCount(SourceSequenceCounter* sequenceCount_); + + private: + static const uint8_t INTERFACE_ID = CLASS_ID::PLOC_MPSOC_HELPER; + + //! [EXPORT] : [COMMENT] File accidentally close + static const ReturnValue_t FILE_CLOSED_ACCIDENTALLY = MAKE_RETURN_CODE(0xA0); + + // Maximum number of times the communication interface retries polling data from the reply + // buffer + static const int RETRIES = 10000; + + struct FlashWrite { + std::string obcFile; + std::string mpsocFile; + }; + + struct FlashWrite flashWrite; + + enum class InternalState { IDLE, FLASH_WRITE, FLASH_READ }; + + InternalState internalState = InternalState::IDLE; + + BinarySemaphore semaphore; +#ifdef XIPHOS_Q7S + SdCardManager* sdcMan = nullptr; +#endif + uint8_t commandBuffer[mpsoc::MAX_COMMAND_SIZE]; + + bool terminate = false; + + /** + * Communication interface of MPSoC responsible for low level access. Must be set by the + * MPSoC Handler. + */ + UartComIF* uartComIF = nullptr; + // Communication cookie. Must be set by the MPSoC Handler + CookieIF* comCookie = nullptr; + // Sequence count, must be set by Ploc MPSoC Handler + SourceSequenceCounter* sequenceCount; + + ReturnValue_t resetHelper(); + ReturnValue_t performFlashWrite(); + ReturnValue_t flashfopen(); + ReturnValue_t flashfclose(); + ReturnValue_t handlePacketTransmission(mpsoc::TcBase& tc); + ReturnValue_t sendCommand(mpsoc::TcBase& tc); + ReturnValue_t receive(uint8_t* data, size_t* readBytes, size_t requestBytes); + ReturnValue_t handleAck(); + ReturnValue_t handleExe(); + void handleAckApidFailure(uint16_t apid); + void handleExeApidFailure(uint16_t apid); + ReturnValue_t handleTmReception(mpsoc::TmPacket* tmPacket, size_t remainingBytes); +}; + +#endif /* BSP_Q7S_DEVICES_PLOCMPSOCHELPER_H_ */ diff --git a/bsp_q7s/devices/PlocMemoryDumper.cpp b/linux/devices/ploc/PlocMemoryDumper.cpp similarity index 100% rename from bsp_q7s/devices/PlocMemoryDumper.cpp rename to linux/devices/ploc/PlocMemoryDumper.cpp diff --git a/bsp_q7s/devices/PlocMemoryDumper.h b/linux/devices/ploc/PlocMemoryDumper.h similarity index 96% rename from bsp_q7s/devices/PlocMemoryDumper.h rename to linux/devices/ploc/PlocMemoryDumper.h index 2ee26824..559e7ec8 100644 --- a/bsp_q7s/devices/PlocMemoryDumper.h +++ b/linux/devices/ploc/PlocMemoryDumper.h @@ -1,8 +1,8 @@ #ifndef MISSION_DEVICES_PLOCMEMORYDUMPER_H_ #define MISSION_DEVICES_PLOCMEMORYDUMPER_H_ -#include -#include +#include +#include #include "OBSWConfig.h" #include "bsp_q7s/memory/SdCardManager.h" diff --git a/bsp_q7s/devices/PlocSupervisorHandler.cpp b/linux/devices/ploc/PlocSupervisorHandler.cpp similarity index 99% rename from bsp_q7s/devices/PlocSupervisorHandler.cpp rename to linux/devices/ploc/PlocSupervisorHandler.cpp index a56c9e1c..838e090d 100644 --- a/bsp_q7s/devices/PlocSupervisorHandler.cpp +++ b/linux/devices/ploc/PlocSupervisorHandler.cpp @@ -12,8 +12,9 @@ #include "OBSWConfig.h" PlocSupervisorHandler::PlocSupervisorHandler(object_id_t objectId, object_id_t uartComIFid, - CookieIF* comCookie) + CookieIF* comCookie, Gpio uartIsolatorSwitch) : DeviceHandlerBase(objectId, uartComIFid, comCookie), + uartIsolatorSwitch(uartIsolatorSwitch), hkset(this), bootStatusReport(this), latchupStatusReport(this) { @@ -33,25 +34,23 @@ ReturnValue_t PlocSupervisorHandler::initialize() { uartComIf = dynamic_cast(communicationInterface); if (uartComIf == nullptr) { sif::warning << "PlocSupervisorHandler::initialize: Invalid uart com if" << std::endl; - return INVALID_UART_COM_IF; + return ObjectManagerIF::CHILD_INIT_FAILED; } - -#if BOARD_TE0720 == 0 +#ifdef TE0720_1CFA sdcMan = SdCardManager::instance(); #endif /* BOARD_TE0720 == 0 */ - return result; } void PlocSupervisorHandler::doStartUp() { -#if OBSW_SWITCH_TO_NORMAL_MODE_AFTER_STARTUP == 1 - setMode(MODE_NORMAL); -#else setMode(_MODE_TO_ON); -#endif + uartIsolatorSwitch.pullHigh(); } -void PlocSupervisorHandler::doShutDown() { setMode(_MODE_POWER_DOWN); } +void PlocSupervisorHandler::doShutDown() { + setMode(_MODE_POWER_DOWN); + uartIsolatorSwitch.pullLow(); +} ReturnValue_t PlocSupervisorHandler::buildNormalDeviceCommand(DeviceCommandId_t* id) { return NOTHING_TO_SEND; @@ -380,6 +379,13 @@ ReturnValue_t PlocSupervisorHandler::scanForReply(const uint8_t* start, size_t r return result; } +ReturnValue_t PlocSupervisorHandler::getSwitches(const uint8_t** switches, + uint8_t* numberOfSwitches) { + *numberOfSwitches = 1; + *switches = &powerSwitch; + return RETURN_OK; +} + ReturnValue_t PlocSupervisorHandler::interpretDeviceReply(DeviceCommandId_t id, const uint8_t* packet) { ReturnValue_t result = RETURN_OK; @@ -594,13 +600,10 @@ ReturnValue_t PlocSupervisorHandler::enableReplyInReplyMap(DeviceCommandMap::ite ReturnValue_t PlocSupervisorHandler::verifyPacket(const uint8_t* start, size_t foundLen) { uint16_t receivedCrc = *(start + foundLen - 2) << 8 | *(start + foundLen - 1); - uint16_t recalculatedCrc = CRC::crc16ccitt(start, foundLen - 2); - if (receivedCrc != recalculatedCrc) { return CRC_FAILURE; } - return RETURN_OK; } @@ -1476,7 +1479,7 @@ ReturnValue_t PlocSupervisorHandler::createMramDumpFile() { std::string filename = "mram-dump--" + timeStamp + ".bin"; -#if BOARD_TE0720 == 0 +#ifdef TE0720_1CFA std::string currentMountPrefix = sdcMan->getCurrentMountPrefix(); #else std::string currentMountPrefix("/mnt/sd0"); diff --git a/bsp_q7s/devices/PlocSupervisorHandler.h b/linux/devices/ploc/PlocSupervisorHandler.h similarity index 95% rename from bsp_q7s/devices/PlocSupervisorHandler.h rename to linux/devices/ploc/PlocSupervisorHandler.h index b85b8ace..c3cfb44a 100644 --- a/bsp_q7s/devices/PlocSupervisorHandler.h +++ b/linux/devices/ploc/PlocSupervisorHandler.h @@ -1,12 +1,14 @@ #ifndef MISSION_DEVICES_PLOCSUPERVISORHANDLER_H_ #define MISSION_DEVICES_PLOCSUPERVISORHANDLER_H_ -#include -#include -#include - #include "OBSWConfig.h" -#include "devicedefinitions/PlocSupervisorDefinitions.h" +#include "bsp_q7s/memory/SdCardManager.h" +#include "devices/powerSwitcherList.h" +#include "fsfw/devicehandlers/DeviceHandlerBase.h" +#include "fsfw_hal/linux/gpio/Gpio.h" +#include "fsfw_hal/linux/gpio/LinuxLibgpioIF.h" +#include "fsfw_hal/linux/uart/UartComIF.h" +#include "linux/devices/devicedefinitions/PlocSupervisorDefinitions.h" /** * @brief This is the device handler for the supervisor of the PLOC which is programmed by @@ -22,7 +24,8 @@ */ class PlocSupervisorHandler : public DeviceHandlerBase { public: - PlocSupervisorHandler(object_id_t objectId, object_id_t uartComIFid, CookieIF* comCookie); + PlocSupervisorHandler(object_id_t objectId, object_id_t uartComIFid, CookieIF* comCookie, + Gpio uartIsolatorSwitch); virtual ~PlocSupervisorHandler(); virtual ReturnValue_t initialize() override; @@ -60,35 +63,33 @@ class PlocSupervisorHandler : public DeviceHandlerBase { static const ReturnValue_t INVALID_APID = MAKE_RETURN_CODE(0xA3); //! [EXPORT] : [COMMENT] Failed to read current system time static const ReturnValue_t GET_TIME_FAILURE = MAKE_RETURN_CODE(0xA4); - //! [EXPORT] : [COMMENT] Invalid communication interface specified - static const ReturnValue_t INVALID_UART_COM_IF = MAKE_RETURN_CODE(0xA5); //! [EXPORT] : [COMMENT] Received command with invalid watchdog parameter. Valid watchdogs are 0 //! for PS, 1 for PL and 2 for INT - static const ReturnValue_t INVALID_WATCHDOG = MAKE_RETURN_CODE(0xA6); + static const ReturnValue_t INVALID_WATCHDOG = MAKE_RETURN_CODE(0xA5); //! [EXPORT] : [COMMENT] Received watchdog timeout config command with invalid timeout. Valid //! timeouts must be in the range between 1000 and 360000 ms. - static const ReturnValue_t INVALID_WATCHDOG_TIMEOUT = MAKE_RETURN_CODE(0xA7); + static const ReturnValue_t INVALID_WATCHDOG_TIMEOUT = MAKE_RETURN_CODE(0xA6); //! [EXPORT] : [COMMENT] Received latchup config command with invalid latchup ID - static const ReturnValue_t INVALID_LATCHUP_ID = MAKE_RETURN_CODE(0xA8); + static const ReturnValue_t INVALID_LATCHUP_ID = MAKE_RETURN_CODE(0xA7); //! [EXPORT] : [COMMENT] Received set adc sweep period command with invalid sweep period. Must be //! larger than 21. - static const ReturnValue_t SWEEP_PERIOD_TOO_SMALL = MAKE_RETURN_CODE(0xA9); + static const ReturnValue_t SWEEP_PERIOD_TOO_SMALL = MAKE_RETURN_CODE(0xA8); //! [EXPORT] : [COMMENT] Receive auto EM test command with invalid test param. Valid params are 1 //! and 2. - static const ReturnValue_t INVALID_TEST_PARAM = MAKE_RETURN_CODE(0xAA); + static const ReturnValue_t INVALID_TEST_PARAM = MAKE_RETURN_CODE(0xA9); //! [EXPORT] : [COMMENT] Returned when scanning for MRAM dump packets failed. - static const ReturnValue_t MRAM_PACKET_PARSING_FAILURE = MAKE_RETURN_CODE(0xAB); + static const ReturnValue_t MRAM_PACKET_PARSING_FAILURE = MAKE_RETURN_CODE(0xAA); //! [EXPORT] : [COMMENT] Returned when the start and stop addresses of the MRAM dump or MRAM wipe //! commands are invalid (e.g. start address bigger than stop address) - static const ReturnValue_t INVALID_MRAM_ADDRESSES = MAKE_RETURN_CODE(0xAC); + static const ReturnValue_t INVALID_MRAM_ADDRESSES = MAKE_RETURN_CODE(0xAB); //! [EXPORT] : [COMMENT] Expect reception of an MRAM dump packet but received space packet with //! other apid. - static const ReturnValue_t NO_MRAM_PACKET = MAKE_RETURN_CODE(0xAD); + static const ReturnValue_t NO_MRAM_PACKET = MAKE_RETURN_CODE(0xAC); //! [EXPORT] : [COMMENT] Path to PLOC directory on SD card does not exist - static const ReturnValue_t PATH_DOES_NOT_EXIST = MAKE_RETURN_CODE(0xAE); + static const ReturnValue_t PATH_DOES_NOT_EXIST = MAKE_RETURN_CODE(0xAD); //! [EXPORT] : [COMMENT] MRAM dump file does not exists. The file should actually already have //! been created with the reception of the first dump packet. - static const ReturnValue_t MRAM_FILE_NOT_EXISTS = MAKE_RETURN_CODE(0xAF); + static const ReturnValue_t MRAM_FILE_NOT_EXISTS = MAKE_RETURN_CODE(0xAE); static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PLOC_SUPERVISOR_HANDLER; @@ -114,11 +115,15 @@ class PlocSupervisorHandler : public DeviceHandlerBase { DeviceCommandId_t nextReplyId = PLOC_SPV::NONE; UartComIF* uartComIf = nullptr; + LinuxLibgpioIF* gpioComIF = nullptr; + Gpio uartIsolatorSwitch; PLOC_SPV::HkSet hkset; PLOC_SPV::BootStatusReport bootStatusReport; PLOC_SPV::LatchupStatusReport latchupStatusReport; + const power::Switch_t powerSwitch = pcduSwitches::PDU1_CH6_PLOC_12V; + /** Number of expected replies following the MRAM dump command */ uint32_t expectedMramDumpPackets = 0; uint32_t receivedMramDumpPackets = 0; @@ -130,7 +135,7 @@ class PlocSupervisorHandler : public DeviceHandlerBase { /** This buffer is used to concatenate space packets received in two different read steps */ uint8_t spacePacketBuffer[PLOC_SPV::MAX_PACKET_SIZE]; -#if BOARD_TE0720 == 0 +#ifdef TE0720_1CFA SdCardManager* sdcMan = nullptr; #endif /* BOARD_TE0720 == 0 */ @@ -141,6 +146,8 @@ class PlocSupervisorHandler : public DeviceHandlerBase { /** Setting this variable to true will enable direct downlink of MRAM packets */ bool downlinkMramDump = false; + ReturnValue_t getSwitches(const uint8_t** switches, uint8_t* numberOfSwitches); + /** * @brief This function checks the crc of the received PLOC reply. * diff --git a/bsp_q7s/devices/PlocUpdater.cpp b/linux/devices/ploc/PlocUpdater.cpp similarity index 99% rename from bsp_q7s/devices/PlocUpdater.cpp rename to linux/devices/ploc/PlocUpdater.cpp index b1d7f0c9..0980f669 100644 --- a/bsp_q7s/devices/PlocUpdater.cpp +++ b/linux/devices/ploc/PlocUpdater.cpp @@ -16,7 +16,7 @@ PlocUpdater::PlocUpdater(object_id_t objectId) PlocUpdater::~PlocUpdater() {} ReturnValue_t PlocUpdater::initialize() { -#if BOARD_TE0720 == 0 +#ifdef XIPHOS_Q7S sdcMan = SdCardManager::instance(); #endif ReturnValue_t result = SystemObject::initialize(); @@ -163,7 +163,7 @@ ReturnValue_t PlocUpdater::getImageLocation(const uint8_t* data, size_t size) { return result; } -#if BOARD_TE0720 == 0 +#ifdef XIPHOS_Q7S // Check if file is stored on SD card and if associated SD card is mounted if (std::string(reinterpret_cast(data), SD_PREFIX_LENGTH) == std::string(SdCardManager::SD_0_MOUNT_POINT)) { diff --git a/bsp_q7s/devices/PlocUpdater.h b/linux/devices/ploc/PlocUpdater.h similarity index 97% rename from bsp_q7s/devices/PlocUpdater.h rename to linux/devices/ploc/PlocUpdater.h index ad6e46fa..a7e6db4a 100644 --- a/bsp_q7s/devices/PlocUpdater.h +++ b/linux/devices/ploc/PlocUpdater.h @@ -1,9 +1,10 @@ #ifndef MISSION_DEVICES_PLOCUPDATER_H_ #define MISSION_DEVICES_PLOCUPDATER_H_ +#include + #include "OBSWConfig.h" #include "bsp_q7s/memory/SdCardManager.h" -#include "devicedefinitions/PlocSupervisorDefinitions.h" #include "eive/definitions.h" #include "fsfw/action/ActionHelper.h" #include "fsfw/action/CommandActionHelper.h" @@ -13,6 +14,7 @@ #include "fsfw/returnvalues/HasReturnvaluesIF.h" #include "fsfw/tasks/ExecutableObjectIF.h" #include "fsfw/tmtcpacket/SpacePacket.h" +#include "linux/devices/devicedefinitions/PlocSupervisorDefinitions.h" #include "linux/fsfwconfig/objects/systemObjectList.h" /** @@ -103,7 +105,7 @@ class PlocUpdater : public SystemObject, MessageQueueIF* commandQueue = nullptr; -#if BOARD_TE0720 == 0 +#ifdef XIPHOS_Q7S SdCardManager* sdcMan = nullptr; #endif CommandActionHelper commandActionHelper; diff --git a/linux/fsfwconfig/OBSWConfig.h.in b/linux/fsfwconfig/OBSWConfig.h.in index 5abe4e3f..69e6744b 100644 --- a/linux/fsfwconfig/OBSWConfig.h.in +++ b/linux/fsfwconfig/OBSWConfig.h.in @@ -10,6 +10,7 @@ #cmakedefine XIPHOS_Q7S #cmakedefine BEAGLEBONEBLACK #cmakedefine EGSE +#cmakedefine TE0720_1CFA #include "commonConfig.h" #include "OBSWVersion.h" @@ -17,9 +18,7 @@ /* These defines should be disabled for mission code but are useful for debugging. */ #define OBSW_VERBOSE_LEVEL 1 - -//! Board defines -#define BOARD_TE0720 0 + #define Q7S_EM 0 /*******************************************************************/ @@ -30,6 +29,8 @@ 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 @@ -64,6 +65,37 @@ debugging. */ #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 +#define OBSW_ADD_STAR_TRACKER 0 +#define OBSW_ADD_PLOC_SUPERVISOR 0 +#define OBSW_ADD_PLOC_MPSOC 1 +#define OBSW_ADD_SUN_SENSORS 0 +#define OBSW_ADD_ACS_BOARD 1 +#define OBSW_ADD_ACS_HANDLERS 0 +#define OBSW_ADD_RW 0 +#define OBSW_ADD_RTD_DEVICES 0 +#define OBSW_ADD_TMP_DEVICES 0 +#define OBSW_ADD_RAD_SENSORS 0 +#define OBSW_ADD_PL_PCDU 0 +#define OBSW_ADD_SYRLINKS 0 +#define OBSW_ENABLE_SYRLINKS_TRANSMIT_TIMEOUT 0 +#define OBSW_SYRLINKS_SIMULATED 1 +#define OBSW_STAR_TRACKER_GROUND_CONFIG 1 +#define OBSW_ENABLE_PERIODIC_HK 0 +#define OBSW_PRINT_CORE_HK 0 +#define OBSW_INITIALIZE_SWITCHES 0 + +#endif + /*******************************************************************/ /** All of the following flags should be disabled for mission code */ /*******************************************************************/ @@ -113,10 +145,21 @@ debugging. */ #define OBSW_DEBUG_SYRLINKS 0 #define OBSW_DEBUG_IMTQ 0 #define OBSW_DEBUG_RW 0 -#define OBSW_DEBUG_PLOC_MPSOC 0 -#define OBSW_DEBUG_PLOC_SUPERVISOR 0 #define OBSW_DEBUG_PDEC_HANDLER 0 -#define OBSW_DEBUG_STARTRACKER @OBSW_DEBUG_STARTRACKER@ + +#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 @@ -140,6 +183,11 @@ debugging. */ #endif // RASPBERRY_PI +#define TCP_SERVER_WIRETAPPING 0 + +/*******************************************************************/ +/** CMake Defines */ +/*******************************************************************/ #cmakedefine EIVE_BUILD_GPSD_GPS_HANDLER #ifdef RASPBERRY_PI @@ -154,11 +202,6 @@ debugging. */ #include "events/subsystemIdRanges.h" #include "returnvalues/classIds.h" -namespace config { -#endif - -#ifdef __cplusplus -} #endif #endif /* FSFWCONFIG_OBSWCONFIG_H_ */ diff --git a/linux/fsfwconfig/events/translateEvents.cpp b/linux/fsfwconfig/events/translateEvents.cpp index 9ac5c923..ece0bf14 100644 --- a/linux/fsfwconfig/events/translateEvents.cpp +++ b/linux/fsfwconfig/events/translateEvents.cpp @@ -1,7 +1,7 @@ /** - * @brief Auto-generated event translation file. Contains 168 translations. + * @brief Auto-generated event translation file. Contains 181 translations. * @details - * Generated on: 2022-03-22 20:43:04 + * Generated on: 2022-03-28 12:48:26 */ #include "translateEvents.h" @@ -100,7 +100,8 @@ const char *DEPL_SA2_GPIO_SWTICH_ON_FAILED_STRING = "DEPL_SA2_GPIO_SWTICH_ON_FAI const char *MEMORY_READ_RPT_CRC_FAILURE_STRING = "MEMORY_READ_RPT_CRC_FAILURE"; const char *ACK_FAILURE_STRING = "ACK_FAILURE"; const char *EXE_FAILURE_STRING = "EXE_FAILURE"; -const char *CRC_FAILURE_EVENT_STRING = "CRC_FAILURE_EVENT"; +const char *MPSOC_HANDLER_CRC_FAILURE_STRING = "MPSOC_HANDLER_CRC_FAILURE"; +const char *MPSOC_HANDLER_SEQ_CNT_MISMATCH_STRING = "MPSOC_HANDLER_SEQ_CNT_MISMATCH"; const char *SELF_TEST_I2C_FAILURE_STRING = "SELF_TEST_I2C_FAILURE"; const char *SELF_TEST_SPI_FAILURE_STRING = "SELF_TEST_SPI_FAILURE"; const char *SELF_TEST_ADC_FAILURE_STRING = "SELF_TEST_ADC_FAILURE"; @@ -148,6 +149,18 @@ const char *POSITION_MISMATCH_STRING = "POSITION_MISMATCH"; const char *STR_HELPER_FILE_NOT_EXISTS_STRING = "STR_HELPER_FILE_NOT_EXISTS"; const char *STR_HELPER_SENDING_PACKET_FAILED_STRING = "STR_HELPER_SENDING_PACKET_FAILED"; const char *STR_HELPER_REQUESTING_MSG_FAILED_STRING = "STR_HELPER_REQUESTING_MSG_FAILED"; +const char *MPSOC_FLASH_WRITE_FAILED_STRING = "MPSOC_FLASH_WRITE_FAILED"; +const char *MPSOC_FLASH_WRITE_SUCCESSFUL_STRING = "MPSOC_FLASH_WRITE_SUCCESSFUL"; +const char *SENDING_COMMAND_FAILED_STRING = "SENDING_COMMAND_FAILED"; +const char *MPSOC_HELPER_REQUESTING_REPLY_FAILED_STRING = "MPSOC_HELPER_REQUESTING_REPLY_FAILED"; +const char *MPSOC_HELPER_READING_REPLY_FAILED_STRING = "MPSOC_HELPER_READING_REPLY_FAILED"; +const char *MISSING_ACK_STRING = "MISSING_ACK"; +const char *MISSING_EXE_STRING = "MISSING_EXE"; +const char *ACK_FAILURE_REPORT_STRING = "ACK_FAILURE_REPORT"; +const char *EXE_FAILURE_REPORT_STRING = "EXE_FAILURE_REPORT"; +const char *ACK_INVALID_APID_STRING = "ACK_INVALID_APID"; +const char *EXE_INVALID_APID_STRING = "EXE_INVALID_APID"; +const char *MPSOC_HELPER_SEQ_CNT_MISMATCH_STRING = "MPSOC_HELPER_SEQ_CNT_MISMATCH"; const char *TRANSITION_BACK_TO_OFF_STRING = "TRANSITION_BACK_TO_OFF"; const char *NEG_V_OUT_OF_BOUNDS_STRING = "NEG_V_OUT_OF_BOUNDS"; const char *U_DRO_OUT_OF_BOUNDS_STRING = "U_DRO_OUT_OF_BOUNDS"; @@ -363,7 +376,9 @@ const char *translateEvents(Event event) { case (11103): return EXE_FAILURE_STRING; case (11104): - return CRC_FAILURE_EVENT_STRING; + return MPSOC_HANDLER_CRC_FAILURE_STRING; + case (11105): + return MPSOC_HANDLER_SEQ_CNT_MISMATCH_STRING; case (11201): return SELF_TEST_I2C_FAILURE_STRING; case (11202): @@ -459,38 +474,62 @@ const char *translateEvents(Event event) { case (12016): return STR_HELPER_REQUESTING_MSG_FAILED_STRING; case (12100): - return TRANSITION_BACK_TO_OFF_STRING; + return MPSOC_FLASH_WRITE_FAILED_STRING; case (12101): - return NEG_V_OUT_OF_BOUNDS_STRING; + return MPSOC_FLASH_WRITE_SUCCESSFUL_STRING; case (12102): - return U_DRO_OUT_OF_BOUNDS_STRING; + return SENDING_COMMAND_FAILED_STRING; case (12103): - return I_DRO_OUT_OF_BOUNDS_STRING; + return MPSOC_HELPER_REQUESTING_REPLY_FAILED_STRING; case (12104): - return U_X8_OUT_OF_BOUNDS_STRING; + return MPSOC_HELPER_READING_REPLY_FAILED_STRING; case (12105): - return I_X8_OUT_OF_BOUNDS_STRING; + return MISSING_ACK_STRING; case (12106): - return U_TX_OUT_OF_BOUNDS_STRING; + return MISSING_EXE_STRING; case (12107): - return I_TX_OUT_OF_BOUNDS_STRING; + return ACK_FAILURE_REPORT_STRING; case (12108): - return U_MPA_OUT_OF_BOUNDS_STRING; + return EXE_FAILURE_REPORT_STRING; case (12109): - return I_MPA_OUT_OF_BOUNDS_STRING; + return ACK_INVALID_APID_STRING; case (12110): - return U_HPA_OUT_OF_BOUNDS_STRING; + return EXE_INVALID_APID_STRING; case (12111): - return I_HPA_OUT_OF_BOUNDS_STRING; + return MPSOC_HELPER_SEQ_CNT_MISMATCH_STRING; case (12200): - return TRANSITION_OTHER_SIDE_FAILED_STRING; + return TRANSITION_BACK_TO_OFF_STRING; case (12201): - return NOT_ENOUGH_DEVICES_DUAL_MODE_STRING; + return NEG_V_OUT_OF_BOUNDS_STRING; case (12202): - return POWER_STATE_MACHINE_TIMEOUT_STRING; + return U_DRO_OUT_OF_BOUNDS_STRING; case (12203): + return I_DRO_OUT_OF_BOUNDS_STRING; + case (12204): + return U_X8_OUT_OF_BOUNDS_STRING; + case (12205): + return I_X8_OUT_OF_BOUNDS_STRING; + case (12206): + return U_TX_OUT_OF_BOUNDS_STRING; + case (12207): + return I_TX_OUT_OF_BOUNDS_STRING; + case (12208): + return U_MPA_OUT_OF_BOUNDS_STRING; + case (12209): + return I_MPA_OUT_OF_BOUNDS_STRING; + case (12210): + return U_HPA_OUT_OF_BOUNDS_STRING; + case (12211): + return I_HPA_OUT_OF_BOUNDS_STRING; + case (12300): + return TRANSITION_OTHER_SIDE_FAILED_STRING; + case (12301): + return NOT_ENOUGH_DEVICES_DUAL_MODE_STRING; + case (12302): + return POWER_STATE_MACHINE_TIMEOUT_STRING; + case (12303): return SIDE_SWITCH_TRANSITION_NOT_ALLOWED_STRING; - case (12400): + case (12500): return CHILDREN_LOST_MODE_STRING; case (13600): return ALLOC_FAILURE_STRING; diff --git a/linux/fsfwconfig/objects/translateObjects.cpp b/linux/fsfwconfig/objects/translateObjects.cpp index 272de238..32799af0 100644 --- a/linux/fsfwconfig/objects/translateObjects.cpp +++ b/linux/fsfwconfig/objects/translateObjects.cpp @@ -1,8 +1,8 @@ /** * @brief Auto-generated object translation file. * @details - * Contains 115 translations. - * Generated on: 2022-03-22 20:43:04 + * Contains 117 translations. + * Generated on: 2022-03-28 12:48:33 */ #include "translateObjects.h" @@ -48,8 +48,10 @@ const char *RAD_SENSOR_STRING = "RAD_SENSOR"; const char *PLOC_UPDATER_STRING = "PLOC_UPDATER"; const char *PLOC_MEMORY_DUMPER_STRING = "PLOC_MEMORY_DUMPER"; const char *STR_HELPER_STRING = "STR_HELPER"; +const char *PLOC_MPSOC_HELPER_STRING = "PLOC_MPSOC_HELPER"; const char *PLOC_MPSOC_HANDLER_STRING = "PLOC_MPSOC_HANDLER"; const char *PLOC_SUPERVISOR_HANDLER_STRING = "PLOC_SUPERVISOR_HANDLER"; +const char *PLOC_SUPERVISOR_HELPER_STRING = "PLOC_SUPERVISOR_HELPER"; const char *SOLAR_ARRAY_DEPL_HANDLER_STRING = "SOLAR_ARRAY_DEPL_HANDLER"; const char *HEATER_HANDLER_STRING = "HEATER_HANDLER"; const char *TMP1075_HANDLER_1_STRING = "TMP1075_HANDLER_1"; @@ -208,10 +210,14 @@ const char *translateObject(object_id_t object) { return PLOC_MEMORY_DUMPER_STRING; case 0x44330002: return STR_HELPER_STRING; + case 0x44330003: + return PLOC_MPSOC_HELPER_STRING; case 0x44330015: return PLOC_MPSOC_HANDLER_STRING; case 0x44330016: return PLOC_SUPERVISOR_HANDLER_STRING; + case 0x44330017: + return PLOC_SUPERVISOR_HELPER_STRING; case 0x444100A2: return SOLAR_ARRAY_DEPL_HANDLER_STRING; case 0x444100A4: diff --git a/linux/fsfwconfig/pollingsequence/pollingSequenceFactory.cpp b/linux/fsfwconfig/pollingsequence/pollingSequenceFactory.cpp index 41866af5..fdd4897e 100644 --- a/linux/fsfwconfig/pollingsequence/pollingSequenceFactory.cpp +++ b/linux/fsfwconfig/pollingsequence/pollingSequenceFactory.cpp @@ -517,6 +517,7 @@ 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); @@ -551,6 +552,7 @@ ReturnValue_t pst::pstGompaceCan(FixedTimeslotTaskIF *thisSequence) { return HasReturnvaluesIF::RETURN_FAILED; } #endif /* Q7S_EM == 0 */ +#endif static_cast(length); return HasReturnvaluesIF::RETURN_OK; } @@ -590,69 +592,3 @@ ReturnValue_t pst::pstTest(FixedTimeslotTaskIF *thisSequence) { } return HasReturnvaluesIF::RETURN_OK; } - -#if BOARD_TE0720 == 1 -ReturnValue_t pst::pollingSequenceTE0720(FixedTimeslotTaskIF *thisSequence) { - uint32_t length = thisSequence->getPeriodMs(); - -#if TEST_PLOC_MPSOC_HANDLER == 1 - thisSequence->addSlot(objects::PLOC_MPSOC_HANDLER, length * 0, - DeviceHandlerIF::PERFORM_OPERATION); - thisSequence->addSlot(objects::PLOC_MPSOC_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(objects::PLOC_MPSOC_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(objects::PLOC_MPSOC_HANDLER, length * 0.6, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(objects::PLOC_MPSOC_HANDLER, length * 0.8, DeviceHandlerIF::GET_READ); -#endif - -#if OBSW_TEST_RAD_SENSOR == 1 - thisSequence->addSlot(objects::RAD_SENSOR, length * 0, DeviceHandlerIF::PERFORM_OPERATION); - thisSequence->addSlot(objects::RAD_SENSOR, length * 0.2, DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(objects::RAD_SENSOR, length * 0.4, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(objects::RAD_SENSOR, length * 0.6, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(objects::RAD_SENSOR, length * 0.8, DeviceHandlerIF::GET_READ); -#endif - -#if OBSW_TEST_SUS == 1 - /* Write setup */ - thisSequence->addSlot(objects::SUS_1, length * 0.901, DeviceHandlerIF::PERFORM_OPERATION); - thisSequence->addSlot(objects::SUS_1, length * 0.902, SusHandler::FIRST_WRITE); - thisSequence->addSlot(objects::SUS_1, length * 0.903, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(objects::SUS_1, length * 0.904, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(objects::SUS_1, length * 0.905, DeviceHandlerIF::GET_READ); - - /* Start conversion*/ - thisSequence->addSlot(objects::SUS_1, length * 0.906, DeviceHandlerIF::PERFORM_OPERATION); - thisSequence->addSlot(objects::SUS_1, length * 0.907, DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(objects::SUS_1, length * 0.908, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(objects::SUS_1, length * 0.909, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(objects::SUS_1, length * 0.91, DeviceHandlerIF::GET_READ); - - /* Read conversions */ - thisSequence->addSlot(objects::SUS_1, length * 0.911, DeviceHandlerIF::PERFORM_OPERATION); - thisSequence->addSlot(objects::SUS_1, length * 0.912, DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(objects::SUS_1, length * 0.913, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(objects::SUS_1, length * 0.914, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(objects::SUS_1, length * 0.915, DeviceHandlerIF::GET_READ); -#endif - -#if OBSW_ADD_PLOC_SUPERVISOR == 1 - thisSequence->addSlot(objects::PLOC_SUPERVISOR_HANDLER, length * 0, - DeviceHandlerIF::PERFORM_OPERATION); - thisSequence->addSlot(objects::PLOC_SUPERVISOR_HANDLER, length * 0.2, - DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(objects::PLOC_SUPERVISOR_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(objects::PLOC_SUPERVISOR_HANDLER, length * 0.7, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(objects::PLOC_SUPERVISOR_HANDLER, length * 0.8, DeviceHandlerIF::GET_READ); -#endif - - thisSequence->addSlot(objects::PLOC_UPDATER, length * 0, DeviceHandlerIF::PERFORM_OPERATION); - thisSequence->addSlot(objects::PLOC_MEMORY_DUMPER, length * 0, - DeviceHandlerIF::PERFORM_OPERATION); - - if (thisSequence->checkSequence() != HasReturnvaluesIF::RETURN_OK) { - sif::error << "Initialization of TE0720 PST failed" << std::endl; - return HasReturnvaluesIF::RETURN_FAILED; - } - return HasReturnvaluesIF::RETURN_OK; -} -#endif /* BOARD_TE0720 == 1 */ diff --git a/linux/fsfwconfig/pollingsequence/pollingSequenceFactory.h b/linux/fsfwconfig/pollingsequence/pollingSequenceFactory.h index 36b86ba8..19c86e52 100644 --- a/linux/fsfwconfig/pollingsequence/pollingSequenceFactory.h +++ b/linux/fsfwconfig/pollingsequence/pollingSequenceFactory.h @@ -54,14 +54,6 @@ ReturnValue_t pstI2c(FixedTimeslotTaskIF* thisSequence); * @return */ ReturnValue_t pstTest(FixedTimeslotTaskIF* thisSequence); - -#if BOARD_TE0720 == 1 -/** - * @brief This polling sequence will be created when the software is compiled for the TE0720. - */ -ReturnValue_t pollingSequenceTE0720(FixedTimeslotTaskIF* thisSequence); -#endif - } // namespace pst #endif /* POLLINGSEQUENCEINIT_H_ */ diff --git a/linux/obc/PdecHandler.h b/linux/obc/PdecHandler.h index 16a9abd4..14863627 100644 --- a/linux/obc/PdecHandler.h +++ b/linux/obc/PdecHandler.h @@ -153,7 +153,7 @@ class PdecHandler : public SystemObject, static const uint32_t PDEC_SLEN_OFFSET = 0xA26; static const uint32_t PDEC_MON_OFFSET = 0xA27; -#if BOARD_TE0720 == 1 +#ifdef TE0720_1CFA static const int CONFIG_MEMORY_MAP_SIZE = 0x400; static const int RAM_MAP_SIZE = 0x4000; static const int REGISTER_MAP_SIZE = 0x10000; @@ -169,7 +169,7 @@ class PdecHandler : public SystemObject, static const size_t MAX_TC_SEGMENT_SIZE = 1017; static const uint8_t MAP_ID_MASK = 0x3F; -#if BOARD_TE0720 == 1 +#ifdef TE0720_1CFA static const uint32_t PHYSICAL_RAM_BASE_ADDRESS = 0x32000000; #else static const uint32_t PHYSICAL_RAM_BASE_ADDRESS = 0x26000000; diff --git a/mission/core/GenericFactory.cpp b/mission/core/GenericFactory.cpp index 1e93a15a..4b17865d 100644 --- a/mission/core/GenericFactory.cpp +++ b/mission/core/GenericFactory.cpp @@ -111,6 +111,9 @@ void ObjectFactory::produceGenericObjects() { tcpServer->setSpacePacketParsingOptions({common::PUS_PACKET_ID}); sif::info << "Created TCP server for TMTC commanding with listener port " << tcpServer->getTcpPort() << std::endl; +#if TCP_SERVER_WIRETAPPING == 1 + tcpServer->enableWiretapping(true); +#endif /* TCP_SERVER_WIRETAPPING == 1 */ #endif /* OBSW_USE_TMTC_TCP_BRIDGE == 0 */ tmtcBridge->setMaxNumberOfPacketsStored(70); #endif /* OBSW_ADD_TCPIP_BRIDGE == 1 */ diff --git a/mission/devices/CMakeLists.txt b/mission/devices/CMakeLists.txt index 6a9035cf..2919ff1f 100644 --- a/mission/devices/CMakeLists.txt +++ b/mission/devices/CMakeLists.txt @@ -11,7 +11,6 @@ target_sources(${LIB_EIVE_MISSION} PRIVATE Max31865PT1000Handler.cpp IMTQHandler.cpp HeaterHandler.cpp - PlocMPSoCHandler.cpp RadiationSensorHandler.cpp GyroADIS1650XHandler.cpp RwHandler.cpp diff --git a/mission/devices/PCDUHandler.cpp b/mission/devices/PCDUHandler.cpp index e54222b1..2f91c140 100644 --- a/mission/devices/PCDUHandler.cpp +++ b/mission/devices/PCDUHandler.cpp @@ -419,7 +419,7 @@ ReturnValue_t PCDUHandler::initializeLocalDataPool(localpool::DataPool& localDat new PoolEntry({INIT_SWITCH_STATES[Switches::PDU2_CH1_PL_PCDU_BATT_0_14V8]})); localDataPoolMap.emplace(P60System::PDU2_OUT_EN_RW, new PoolEntry({INIT_SWITCH_STATES[Switches::PDU2_CH2_RW_5V]})); -#if BOARD_TE0720 == 1 +#ifdef TE0720_1CFA localDataPoolMap.emplace(P60System::PDU2_OUT_EN_TCS_BOARD_HEATER_IN, new PoolEntry({1})); #else localDataPoolMap.emplace( diff --git a/mission/devices/PDU2Handler.cpp b/mission/devices/PDU2Handler.cpp index 3d7e260d..512d8745 100644 --- a/mission/devices/PDU2Handler.cpp +++ b/mission/devices/PDU2Handler.cpp @@ -306,7 +306,7 @@ ReturnValue_t PDU2Handler::initializeLocalDataPool(localpool::DataPool &localDat localDataPoolMap.emplace(P60System::PDU2_OUT_EN_Q7S, new PoolEntry({0})); localDataPoolMap.emplace(P60System::PDU2_OUT_EN_PAYLOAD_PCDU_CH1, new PoolEntry({0})); localDataPoolMap.emplace(P60System::PDU2_OUT_EN_RW, new PoolEntry({0})); -#if BOARD_TE0720 == 1 +#ifdef TE0720_1CFA localDataPoolMap.emplace(P60System::PDU2_OUT_EN_TCS_BOARD_HEATER_IN, new PoolEntry({1})); #else localDataPoolMap.emplace(P60System::PDU2_OUT_EN_TCS_BOARD_HEATER_IN, new PoolEntry({0})); diff --git a/mission/devices/PayloadPcduHandler.cpp b/mission/devices/PayloadPcduHandler.cpp index 761fa383..40f894af 100644 --- a/mission/devices/PayloadPcduHandler.cpp +++ b/mission/devices/PayloadPcduHandler.cpp @@ -525,6 +525,8 @@ void PayloadPcduHandler::checkAdcValues() { } params.getValue(PARAM_KEY_MAP[HPA_I_UPPER_BOUND], upperBound); if (not checkCurrent(adcSet.processed[I_HPA], upperBound, I_HPA_OUT_OF_BOUNDS)) { + sif::warning << "PayloadPcduHandler::checkCurrent: I HPA exceeded limit: Measured " + << adcSet.processed[I_HPA] << " mA" << std::endl; return; } } diff --git a/mission/devices/PlocMPSoCHandler.cpp b/mission/devices/PlocMPSoCHandler.cpp deleted file mode 100644 index 07b9b0fa..00000000 --- a/mission/devices/PlocMPSoCHandler.cpp +++ /dev/null @@ -1,473 +0,0 @@ -#include "PlocMPSoCHandler.h" - -#include -#include - -#include "OBSWConfig.h" - -PlocMPSoCHandler::PlocMPSoCHandler(object_id_t objectId, object_id_t comIF, CookieIF* comCookie) - : DeviceHandlerBase(objectId, comIF, comCookie) { - if (comCookie == NULL) { - sif::error << "PlocMPSoCHandler: Invalid com cookie" << std::endl; - } -} - -PlocMPSoCHandler::~PlocMPSoCHandler() {} - -void PlocMPSoCHandler::doStartUp() { - if (mode == _MODE_START_UP) { - setMode(MODE_ON); - } -} - -void PlocMPSoCHandler::doShutDown() { setMode(_MODE_POWER_DOWN); } - -ReturnValue_t PlocMPSoCHandler::buildNormalDeviceCommand(DeviceCommandId_t* id) { - return RETURN_OK; -} - -ReturnValue_t PlocMPSoCHandler::buildTransitionDeviceCommand(DeviceCommandId_t* id) { - return HasReturnvaluesIF::RETURN_OK; -} - -ReturnValue_t PlocMPSoCHandler::buildCommandFromCommand(DeviceCommandId_t deviceCommand, - const uint8_t* commandData, - size_t commandDataLen) { - switch (deviceCommand) { - case (PLOC_MPSOC::TC_MEM_WRITE): { - return prepareTcMemWriteCommand(commandData, commandDataLen); - } - case (PLOC_MPSOC::TC_MEM_READ): { - return prepareTcMemReadCommand(commandData, commandDataLen); - } - default: - sif::debug << "PlocMPSoCHandler::buildCommandFromCommand: Command not implemented" - << std::endl; - return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED; - } - return HasReturnvaluesIF::RETURN_FAILED; -} - -void PlocMPSoCHandler::fillCommandAndReplyMap() { - this->insertInCommandMap(PLOC_MPSOC::TC_MEM_WRITE); - this->insertInCommandMap(PLOC_MPSOC::TC_MEM_READ); - this->insertInReplyMap(PLOC_MPSOC::ACK_REPORT, 1, nullptr, PLOC_MPSOC::SIZE_ACK_REPORT); - this->insertInReplyMap(PLOC_MPSOC::EXE_REPORT, 3, nullptr, PLOC_MPSOC::SIZE_EXE_REPORT); - this->insertInReplyMap(PLOC_MPSOC::TM_MEMORY_READ_REPORT, 2, nullptr, - PLOC_MPSOC::SIZE_TM_MEM_READ_REPORT); -} - -ReturnValue_t PlocMPSoCHandler::scanForReply(const uint8_t* start, size_t remainingSize, - DeviceCommandId_t* foundId, size_t* foundLen) { - ReturnValue_t result = RETURN_OK; - - uint16_t apid = (*(start) << 8 | *(start + 1)) & APID_MASK; - - switch (apid) { - case (PLOC_MPSOC::APID_ACK_SUCCESS): - *foundLen = PLOC_MPSOC::SIZE_ACK_REPORT; - *foundId = PLOC_MPSOC::ACK_REPORT; - break; - case (PLOC_MPSOC::APID_ACK_FAILURE): - *foundLen = PLOC_MPSOC::SIZE_ACK_REPORT; - *foundId = PLOC_MPSOC::ACK_REPORT; - break; - case (PLOC_MPSOC::APID_TM_MEMORY_READ_REPORT): - *foundLen = PLOC_MPSOC::SIZE_TM_MEM_READ_REPORT; - *foundId = PLOC_MPSOC::TM_MEMORY_READ_REPORT; - break; - case (PLOC_MPSOC::APID_EXE_SUCCESS): - *foundLen = PLOC_MPSOC::SIZE_EXE_REPORT; - *foundId = PLOC_MPSOC::EXE_REPORT; - break; - case (PLOC_MPSOC::APID_EXE_FAILURE): - *foundLen = PLOC_MPSOC::SIZE_EXE_REPORT; - *foundId = PLOC_MPSOC::EXE_REPORT; - break; - default: { - sif::debug << "PlocMPSoCHandler::scanForReply: Reply has invalid apid" << std::endl; - *foundLen = remainingSize; - return INVALID_APID; - } - } - - /** - * This should normally never fail. However, this function is also responsible for incrementing - * the packet sequence count why it is called here. - */ - result = checkPacketSequenceCount(start); - - return result; -} - -ReturnValue_t PlocMPSoCHandler::interpretDeviceReply(DeviceCommandId_t id, const uint8_t* packet) { - ReturnValue_t result = RETURN_OK; - - switch (id) { - case PLOC_MPSOC::ACK_REPORT: { - result = handleAckReport(packet); - break; - } - case (PLOC_MPSOC::TM_MEMORY_READ_REPORT): { - result = handleMemoryReadReport(packet); - break; - } - case (PLOC_MPSOC::EXE_REPORT): { - result = handleExecutionReport(packet); - break; - } - default: { - sif::debug << "PlocMPSoCHandler::interpretDeviceReply: Unknown device reply id" << std::endl; - return DeviceHandlerIF::UNKNOWN_DEVICE_REPLY; - } - } - - return result; -} - -void PlocMPSoCHandler::setNormalDatapoolEntriesInvalid() {} - -uint32_t PlocMPSoCHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 500; } - -ReturnValue_t PlocMPSoCHandler::initializeLocalDataPool(localpool::DataPool& localDataPoolMap, - LocalDataPoolManager& poolManager) { - return HasReturnvaluesIF::RETURN_OK; -} - -void PlocMPSoCHandler::setModeNormal() { mode = MODE_NORMAL; } - -ReturnValue_t PlocMPSoCHandler::prepareTcMemWriteCommand(const uint8_t* commandData, - size_t commandDataLen) { - const uint32_t memoryAddress = *(commandData) << 24 | *(commandData + 1) << 16 | - *(commandData + 2) << 8 | *(commandData + 3); - const uint32_t memoryData = *(commandData + 4) << 24 | *(commandData + 5) << 16 | - *(commandData + 6) << 8 | *(commandData + 7); - packetSequenceCount = (packetSequenceCount + 1) & PACKET_SEQUENCE_COUNT_MASK; - PLOC_MPSOC::TcMemWrite tcMemWrite(memoryAddress, memoryData, packetSequenceCount); - if (tcMemWrite.getFullSize() > PLOC_MPSOC::MAX_COMMAND_SIZE) { - sif::debug << "PlocMPSoCHandler::prepareTcMemWriteCommand: Command too big" << std::endl; - return RETURN_FAILED; - } - memcpy(commandBuffer, tcMemWrite.getWholeData(), tcMemWrite.getFullSize()); - rawPacket = commandBuffer; - rawPacketLen = tcMemWrite.getFullSize(); - nextReplyId = PLOC_MPSOC::ACK_REPORT; - return RETURN_OK; -} - -ReturnValue_t PlocMPSoCHandler::prepareTcMemReadCommand(const uint8_t* commandData, - size_t commandDataLen) { - const uint32_t memoryAddress = *(commandData) << 24 | *(commandData + 1) << 16 | - *(commandData + 2) << 8 | *(commandData + 3); - packetSequenceCount = (packetSequenceCount + 1) & PACKET_SEQUENCE_COUNT_MASK; - PLOC_MPSOC::TcMemRead tcMemRead(memoryAddress, packetSequenceCount); - if (tcMemRead.getFullSize() > PLOC_MPSOC::MAX_COMMAND_SIZE) { - sif::debug << "PlocMPSoCHandler::prepareTcMemReadCommand: Command too big" << std::endl; - return RETURN_FAILED; - } - memcpy(commandBuffer, tcMemRead.getWholeData(), tcMemRead.getFullSize()); - rawPacket = commandBuffer; - rawPacketLen = tcMemRead.getFullSize(); - nextReplyId = PLOC_MPSOC::ACK_REPORT; - - return RETURN_OK; -} - -ReturnValue_t PlocMPSoCHandler::verifyPacket(const uint8_t* start, size_t foundLen) { - uint16_t receivedCrc = *(start + foundLen - 2) << 8 | *(start + foundLen - 1); - - uint16_t recalculatedCrc = CRC::crc16ccitt(start, foundLen - 2); - - if (receivedCrc != recalculatedCrc) { - return CRC_FAILURE; - } - - return RETURN_OK; -} - -ReturnValue_t PlocMPSoCHandler::handleAckReport(const uint8_t* data) { - ReturnValue_t result = RETURN_OK; - - result = verifyPacket(data, PLOC_MPSOC::SIZE_ACK_REPORT); - if (result == CRC_FAILURE) { - sif::error << "PlocMPSoCHandler::handleAckReport: CRC failure" << std::endl; - nextReplyId = PLOC_MPSOC::NONE; - replyRawReplyIfnotWiretapped(data, PLOC_MPSOC::SIZE_ACK_REPORT); - triggerEvent(CRC_FAILURE_EVENT); - sendFailureReport(PLOC_MPSOC::ACK_REPORT, CRC_FAILURE); - disableAllReplies(); - return IGNORE_REPLY_DATA; - } - - uint16_t apid = (*(data) << 8 | *(data + 1)) & APID_MASK; - - switch (apid) { - case PLOC_MPSOC::APID_ACK_FAILURE: { - // TODO: Interpretation of status field in acknowledgment report - sif::debug << "PlocMPSoCHandler::handleAckReport: Received Ack failure report" << std::endl; - DeviceCommandId_t commandId = getPendingCommand(); - if (commandId != DeviceHandlerIF::NO_COMMAND_ID) { - triggerEvent(ACK_FAILURE, commandId); - } - sendFailureReport(PLOC_MPSOC::ACK_REPORT, RECEIVED_ACK_FAILURE); - disableAllReplies(); - nextReplyId = PLOC_MPSOC::NONE; - result = IGNORE_REPLY_DATA; - break; - } - case PLOC_MPSOC::APID_ACK_SUCCESS: { - setNextReplyId(); - break; - } - default: { - sif::debug << "PlocMPSoCHandler::handleAckReport: Invalid APID in Ack report" << std::endl; - result = RETURN_FAILED; - break; - } - } - - return result; -} - -ReturnValue_t PlocMPSoCHandler::handleExecutionReport(const uint8_t* data) { - ReturnValue_t result = RETURN_OK; - - result = verifyPacket(data, PLOC_MPSOC::SIZE_EXE_REPORT); - if (result == CRC_FAILURE) { - sif::error << "PlocMPSoCHandler::handleExecutionReport: CRC failure" << std::endl; - nextReplyId = PLOC_MPSOC::NONE; - return result; - } - - uint16_t apid = (*(data) << 8 | *(data + 1)) & APID_MASK; - - switch (apid) { - case (PLOC_MPSOC::APID_EXE_SUCCESS): { - break; - } - case (PLOC_MPSOC::APID_EXE_FAILURE): { - // TODO: Interpretation of status field in execution report - sif::error << "PlocMPSoCHandler::handleExecutionReport: Received execution failure report" - << std::endl; - DeviceCommandId_t commandId = getPendingCommand(); - if (commandId != DeviceHandlerIF::NO_COMMAND_ID) { - triggerEvent(EXE_FAILURE, commandId); - } else { - sif::debug << "PlocMPSoCHandler::handleExecutionReport: Unknown command id" << std::endl; - } - sendFailureReport(PLOC_MPSOC::EXE_REPORT, RECEIVED_EXE_FAILURE); - disableExeReportReply(); - result = IGNORE_REPLY_DATA; - break; - } - default: { - sif::error << "PlocMPSoCHandler::handleExecutionReport: Unknown APID" << std::endl; - result = RETURN_FAILED; - break; - } - } - - nextReplyId = PLOC_MPSOC::NONE; - - return result; -} - -ReturnValue_t PlocMPSoCHandler::handleMemoryReadReport(const uint8_t* data) { - ReturnValue_t result = RETURN_OK; - - result = verifyPacket(data, PLOC_MPSOC::SIZE_TM_MEM_READ_REPORT); - - if (result == CRC_FAILURE) { - sif::error << "PlocMPSoCHandler::handleMemoryReadReport: Memory read report has invalid crc" - << std::endl; - } - /** Send data to commanding queue */ - handleDeviceTM(data + PLOC_MPSOC::DATA_FIELD_OFFSET, PLOC_MPSOC::SIZE_MEM_READ_REPORT_DATA, - PLOC_MPSOC::TM_MEMORY_READ_REPORT); - - nextReplyId = PLOC_MPSOC::EXE_REPORT; - - return result; -} - -ReturnValue_t PlocMPSoCHandler::enableReplyInReplyMap(DeviceCommandMap::iterator command, - uint8_t expectedReplies, bool useAlternateId, - DeviceCommandId_t alternateReplyID) { - ReturnValue_t result = RETURN_OK; - - uint8_t enabledReplies = 0; - - switch (command->first) { - case PLOC_MPSOC::TC_MEM_WRITE: - enabledReplies = 2; - break; - case PLOC_MPSOC::TC_MEM_READ: { - enabledReplies = 3; - result = DeviceHandlerBase::enableReplyInReplyMap(command, enabledReplies, true, - PLOC_MPSOC::TM_MEMORY_READ_REPORT); - if (result != RETURN_OK) { - sif::debug << "PlocMPSoCHandler::enableReplyInReplyMap: Reply with id " - << PLOC_MPSOC::TM_MEMORY_READ_REPORT << " not in replyMap" << std::endl; - } - break; - } - default: - sif::debug << "PlocMPSoCHandler::enableReplyInReplyMap: Unknown command id" << std::endl; - break; - } - - /** - * Every command causes at least one acknowledgment and one execution report. Therefore both - * replies will be enabled here. - */ - result = DeviceHandlerBase::enableReplyInReplyMap(command, enabledReplies, true, - PLOC_MPSOC::ACK_REPORT); - if (result != RETURN_OK) { - sif::debug << "PlocMPSoCHandler::enableReplyInReplyMap: Reply with id " - << PLOC_MPSOC::ACK_REPORT << " not in replyMap" << std::endl; - } - - result = DeviceHandlerBase::enableReplyInReplyMap(command, enabledReplies, true, - PLOC_MPSOC::EXE_REPORT); - if (result != RETURN_OK) { - sif::debug << "PlocMPSoCHandler::enableReplyInReplyMap: Reply with id " - << PLOC_MPSOC::EXE_REPORT << " not in replyMap" << std::endl; - } - - return RETURN_OK; -} - -void PlocMPSoCHandler::setNextReplyId() { - switch (getPendingCommand()) { - case PLOC_MPSOC::TC_MEM_READ: - nextReplyId = PLOC_MPSOC::TM_MEMORY_READ_REPORT; - break; - default: - /* If no telemetry is expected the next reply is always the execution report */ - nextReplyId = PLOC_MPSOC::EXE_REPORT; - break; - } -} -size_t PlocMPSoCHandler::getNextReplyLength(DeviceCommandId_t commandId) { - size_t replyLen = 0; - - if (nextReplyId == PLOC_MPSOC::NONE) { - return replyLen; - } - - DeviceReplyIter iter = deviceReplyMap.find(nextReplyId); - if (iter != deviceReplyMap.end()) { - if (iter->second.delayCycles == 0) { - /* Reply inactive */ - return replyLen; - } - replyLen = iter->second.replyLen; - } else { - sif::debug << "PlocMPSoCHandler::getNextReplyLength: No entry for reply with reply id " - << std::hex << nextReplyId << " in deviceReplyMap" << std::endl; - } - - return replyLen; -} - -void PlocMPSoCHandler::handleDeviceTM(const uint8_t* data, size_t dataSize, - DeviceCommandId_t replyId) { - ReturnValue_t result = RETURN_OK; - - if (wiretappingMode == RAW) { - /* Data already sent in doGetRead() */ - return; - } - - DeviceReplyMap::iterator iter = deviceReplyMap.find(replyId); - if (iter == deviceReplyMap.end()) { - sif::debug << "PlocMPSoCHandler::handleDeviceTM: Unknown reply id" << std::endl; - return; - } - MessageQueueId_t queueId = iter->second.command->second.sendReplyTo; - - if (queueId == NO_COMMANDER) { - return; - } - - result = actionHelper.reportData(queueId, replyId, data, dataSize); - if (result != RETURN_OK) { - sif::debug << "PlocMPSoCHandler::handleDeviceTM: Failed to report data" << std::endl; - } -} - -void PlocMPSoCHandler::disableAllReplies() { - DeviceReplyMap::iterator iter; - - /* Disable ack reply */ - iter = deviceReplyMap.find(PLOC_MPSOC::ACK_REPORT); - DeviceReplyInfo* info = &(iter->second); - info->delayCycles = 0; - info->command = deviceCommandMap.end(); - - DeviceCommandId_t commandId = getPendingCommand(); - - /* If the command expects a telemetry packet the appropriate tm reply will be disabled here */ - switch (commandId) { - case PLOC_MPSOC::TC_MEM_WRITE: - break; - case PLOC_MPSOC::TC_MEM_READ: { - iter = deviceReplyMap.find(PLOC_MPSOC::TM_MEMORY_READ_REPORT); - info = &(iter->second); - info->delayCycles = 0; - info->command = deviceCommandMap.end(); - break; - } - default: { - sif::debug << "PlocMPSoCHandler::disableAllReplies: Unknown command id" << commandId - << std::endl; - break; - } - } - - /* We must always disable the execution report reply here */ - disableExeReportReply(); -} - -void PlocMPSoCHandler::sendFailureReport(DeviceCommandId_t replyId, ReturnValue_t status) { - DeviceReplyIter iter = deviceReplyMap.find(replyId); - - if (iter == deviceReplyMap.end()) { - sif::debug << "PlocMPSoCHandler::sendFailureReport: Reply not in reply map" << std::endl; - return; - } - - DeviceCommandInfo* info = &(iter->second.command->second); - - if (info == nullptr) { - sif::debug << "PlocMPSoCHandler::sendFailureReport: Reply has no active command" << std::endl; - return; - } - - if (info->sendReplyTo != NO_COMMANDER) { - actionHelper.finish(false, info->sendReplyTo, iter->first, status); - } - info->isExecuting = false; -} - -void PlocMPSoCHandler::disableExeReportReply() { - DeviceReplyIter iter = deviceReplyMap.find(PLOC_MPSOC::EXE_REPORT); - DeviceReplyInfo* info = &(iter->second); - info->delayCycles = 0; - info->command = deviceCommandMap.end(); - /* Expected replies is set to one here. The value will set to 0 in replyToReply() */ - info->command->second.expectedReplies = 0; -} - -ReturnValue_t PlocMPSoCHandler::checkPacketSequenceCount(const uint8_t* data) { - uint16_t receivedSequenceCount = (*(data + 2) << 8 | *(data + 3)) & PACKET_SEQUENCE_COUNT_MASK; - uint16_t expectedPacketSequenceCount = ((packetSequenceCount + 1) & PACKET_SEQUENCE_COUNT_MASK); - if (receivedSequenceCount != expectedPacketSequenceCount) { - sif::debug << "PlocMPSoCHandler::checkPacketSequenceCount: Packet sequence count mismatch. " - << std::endl; - sif::debug << "Received sequence count: " << receivedSequenceCount << ". OBSW sequence " - << "count: " << expectedPacketSequenceCount << std::endl; - } - packetSequenceCount = receivedSequenceCount; - return RETURN_OK; -} diff --git a/mission/devices/RwHandler.cpp b/mission/devices/RwHandler.cpp index f3cd0737..941abf29 100644 --- a/mission/devices/RwHandler.cpp +++ b/mission/devices/RwHandler.cpp @@ -30,12 +30,7 @@ void RwHandler::doStartUp() { if (gpioComIF->pullHigh(enableGpio) != RETURN_OK) { sif::debug << "RwHandler::doStartUp: Failed to pull enable gpio to high"; } - -#if OBSW_SWITCH_TO_NORMAL_MODE_AFTER_STARTUP == 1 - setMode(MODE_NORMAL); -#else setMode(_MODE_TO_ON); -#endif } void RwHandler::doShutDown() { @@ -472,52 +467,52 @@ void RwHandler::handleGetTelemetryReply(const uint8_t* packet) { tmDataset.spiTotalNumOfErrors = *(packet + offset + 3) << 24 | *(packet + offset + 2) << 16 | *(packet + offset + 1) << 8 | *(packet + offset); #if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_RW == 1 - sif::info << "RwHandler::handleTemperatureReply: Last reset status: " + sif::info << "RwHandler::handleGetTelemetryReply: Last reset status: " << static_cast(tmDataset.lastResetStatus.value) << std::endl; - sif::info << "RwHandler::handleTemperatureReply: MCU temperature: " << tmDataset.mcuTemperature + sif::info << "RwHandler::handleGetTelemetryReply: MCU temperature: " << tmDataset.mcuTemperature << std::endl; - sif::info << "RwHandler::handleTemperatureReply: Pressure sensor temperature: " + sif::info << "RwHandler::handleGetTelemetryReply: Pressure sensor temperature: " << tmDataset.pressureSensorTemperature << std::endl; - sif::info << "RwHandler::handleTemperatureReply: Pressure " << tmDataset.pressure << std::endl; - sif::info << "RwHandler::handleTemperatureReply: State: " + sif::info << "RwHandler::handleGetTelemetryReply: Pressure " << tmDataset.pressure << std::endl; + sif::info << "RwHandler::handleGetTelemetryReply: State: " << static_cast(tmDataset.rwState.value) << std::endl; - sif::info << "RwHandler::handleTemperatureReply: CLC mode: " + sif::info << "RwHandler::handleGetTelemetryReply: CLC mode: " << static_cast(tmDataset.rwClcMode.value) << std::endl; - sif::info << "RwHandler::handleTemperatureReply: Current speed: " << tmDataset.rwCurrSpeed + sif::info << "RwHandler::handleGetTelemetryReply: Current speed: " << tmDataset.rwCurrSpeed << std::endl; - sif::info << "RwHandler::handleTemperatureReply: Reference speed: " << tmDataset.rwRefSpeed + sif::info << "RwHandler::handleGetTelemetryReply: Reference speed: " << tmDataset.rwRefSpeed << std::endl; - sif::info << "RwHandler::handleTemperatureReply: Number of invalid CRC packets: " + sif::info << "RwHandler::handleGetTelemetryReply: Number of invalid CRC packets: " << tmDataset.numOfInvalidCrcPackets << std::endl; - sif::info << "RwHandler::handleTemperatureReply: Number of invalid length packets: " + sif::info << "RwHandler::handleGetTelemetryReply: Number of invalid length packets: " << tmDataset.numOfInvalidLenPackets << std::endl; - sif::info << "RwHandler::handleTemperatureReply: Number of invalid command packets: " + sif::info << "RwHandler::handleGetTelemetryReply: Number of invalid command packets: " << tmDataset.numOfInvalidCmdPackets << std::endl; - sif::info << "RwHandler::handleTemperatureReply: Number of command executed replies: " + sif::info << "RwHandler::handleGetTelemetryReply: Number of command executed replies: " << tmDataset.numOfCmdExecutedReplies << std::endl; - sif::info << "RwHandler::handleTemperatureReply: Number of command replies: " + sif::info << "RwHandler::handleGetTelemetryReply: Number of command replies: " << tmDataset.numOfCmdReplies << std::endl; - sif::info << "RwHandler::handleTemperatureReply: UART number of bytes written: " + sif::info << "RwHandler::handleGetTelemetryReply: UART number of bytes written: " << tmDataset.uartNumOfBytesWritten << std::endl; - sif::info << "RwHandler::handleTemperatureReply: UART number of bytes read: " + sif::info << "RwHandler::handleGetTelemetryReply: UART number of bytes read: " << tmDataset.uartNumOfBytesRead << std::endl; - sif::info << "RwHandler::handleTemperatureReply: UART number of parity errors: " + sif::info << "RwHandler::handleGetTelemetryReply: UART number of parity errors: " << tmDataset.uartNumOfParityErrors << std::endl; - sif::info << "RwHandler::handleTemperatureReply: UART number of noise errors: " + sif::info << "RwHandler::handleGetTelemetryReply: UART number of noise errors: " << tmDataset.uartNumOfNoiseErrors << std::endl; - sif::info << "RwHandler::handleTemperatureReply: UART number of frame errors: " + sif::info << "RwHandler::handleGetTelemetryReply: UART number of frame errors: " << tmDataset.uartNumOfFrameErrors << std::endl; - sif::info << "RwHandler::handleTemperatureReply: UART number of register overrun errors: " + sif::info << "RwHandler::handleGetTelemetryReply: UART number of register overrun errors: " << tmDataset.uartNumOfRegisterOverrunErrors << std::endl; - sif::info << "RwHandler::handleTemperatureReply: UART number of total errors: " + sif::info << "RwHandler::handleGetTelemetryReply: UART number of total errors: " << tmDataset.uartTotalNumOfErrors << std::endl; - sif::info << "RwHandler::handleTemperatureReply: SPI number of bytes written: " + sif::info << "RwHandler::handleGetTelemetryReply: SPI number of bytes written: " << tmDataset.spiNumOfBytesWritten << std::endl; - sif::info << "RwHandler::handleTemperatureReply: SPI number of bytes read: " + sif::info << "RwHandler::handleGetTelemetryReply: SPI number of bytes read: " << tmDataset.spiNumOfBytesRead << std::endl; - sif::info << "RwHandler::handleTemperatureReply: SPI number of register overrun errors: " + sif::info << "RwHandler::handleGetTelemetryReply: SPI number of register overrun errors: " << tmDataset.spiNumOfRegisterOverrunErrors << std::endl; - sif::info << "RwHandler::handleTemperatureReply: SPI number of register total errors: " + sif::info << "RwHandler::handleGetTelemetryReply: SPI number of register total errors: " << tmDataset.spiTotalNumOfErrors << std::endl; #endif } diff --git a/mission/devices/devicedefinitions/PlocMPSoCDefinitions.h b/mission/devices/devicedefinitions/PlocMPSoCDefinitions.h deleted file mode 100644 index 2c8a081c..00000000 --- a/mission/devices/devicedefinitions/PlocMPSoCDefinitions.h +++ /dev/null @@ -1,166 +0,0 @@ -#ifndef MISSION_DEVICES_DEVICEDEFINITIONS_PLOCMPSOCDEFINITIONS_H_ -#define MISSION_DEVICES_DEVICEDEFINITIONS_PLOCMPSOCDEFINITIONS_H_ - -#include -#include -#include - -namespace PLOC_MPSOC { - -static const DeviceCommandId_t NONE = 0x0; -static const DeviceCommandId_t TC_MEM_WRITE = 0x1; -static const DeviceCommandId_t TC_MEM_READ = 0x2; -static const DeviceCommandId_t ACK_REPORT = 0x3; -static const DeviceCommandId_t EXE_REPORT = 0x5; -static const DeviceCommandId_t TM_MEMORY_READ_REPORT = 0x6; - -static const uint16_t SIZE_ACK_REPORT = 14; -static const uint16_t SIZE_EXE_REPORT = 14; -static const uint16_t SIZE_TM_MEM_READ_REPORT = 18; - -/** - * SpacePacket apids of PLOC telecommands and telemetry. - */ -static const uint16_t APID_TC_MEM_WRITE = 0x714; -static const uint16_t APID_TC_MEM_READ = 0x715; -static const uint16_t APID_TM_MEMORY_READ_REPORT = 0x404; -static const uint16_t APID_ACK_SUCCESS = 0x400; -static const uint16_t APID_ACK_FAILURE = 0x401; -static const uint16_t APID_EXE_SUCCESS = 0x402; -static const uint16_t APID_EXE_FAILURE = 0x403; - -/** Offset from first byte in Space packet to first byte of data field */ -static const uint8_t DATA_FIELD_OFFSET = 6; - -/** - * The size of payload data which will be forwarded to the requesting object. e.g. PUS Service - * 8. - */ -static const uint8_t SIZE_MEM_READ_REPORT_DATA = 10; - -/** - * PLOC space packet length for fixed size packets. This is the size of the whole packet data - * field. For the length field in the space packet this size will be substracted by one. - */ -static const uint16_t LENGTH_TC_MEM_WRITE = 12; -static const uint16_t LENGTH_TC_MEM_READ = 8; - -static const size_t MAX_REPLY_SIZE = SIZE_TM_MEM_READ_REPORT; -static const size_t MAX_COMMAND_SIZE = 18; - -/** - * @brief This class helps to build the memory read command for the PLOC. - * - * @details The last two bytes of the packet data field contain a CRC calculated over the whole - * space packet. This is the CRC-16-CCITT as specified in - * ECSS-E-ST-70-41C Telemetry and telecommand packet utilization. - */ -class TcMemRead : public SpacePacket { - public: - /** - * @brief Constructor - * - * @param memAddr The memory address to read from. - */ - TcMemRead(const uint32_t memAddr, uint16_t sequenceCount) - : SpacePacket(LENGTH_TC_MEM_READ - 1, true, APID_TC_MEM_READ, sequenceCount) { - fillPacketDataField(&memAddr); - } - - private: - /** - * @brief This function builds the packet data field for the mem read command. - * - * @param memAddrPtr Pointer to the memory address to read from. - */ - void fillPacketDataField(const uint32_t* memAddrPtr) { - /* Add memAddr to packet data field */ - size_t serializedSize = 0; - uint8_t* memoryAddressPos = this->localData.fields.buffer; - SerializeAdapter::serialize(memAddrPtr, &memoryAddressPos, &serializedSize, - sizeof(*memAddrPtr), SerializeIF::Endianness::LITTLE); - - /* Add memLen to packet data field */ - this->localData.fields.buffer[OFFSET_MEM_LEN_FIELD] = 1; - this->localData.fields.buffer[OFFSET_MEM_LEN_FIELD + 1] = 0; - - /* Calculate crc */ - uint16_t crc = CRC::crc16ccitt(this->localData.byteStream, - sizeof(CCSDSPrimaryHeader) + LENGTH_TC_MEM_READ - CRC_SIZE); - - /* Add crc to packet data field of space packet */ - serializedSize = 0; - uint8_t* crcPos = this->localData.fields.buffer + CRC_OFFSET; - SerializeAdapter::serialize(&crc, &crcPos, &serializedSize, sizeof(crc), - SerializeIF::Endianness::BIG); - } - - static const uint8_t OFFSET_MEM_LEN_FIELD = 4; - static const uint8_t CRC_OFFSET = 6; -}; - -/** - * @brief This class helps to generate the space packet to write to a memory address within - * the PLOC. - * @details The last two bytes of the packet data field contain a CRC calculated over the whole - * space packet. This is the CRC-16-CCITT as specified in - * ECSS-E-ST-70-41C Telemetry and telecommand packet utilization. - */ -class TcMemWrite : public SpacePacket { - public: - /** - * @brief Constructor - * - * @param memAddr The PLOC memory address where to write to. - * @param memoryData The data to write to the specified memory address. - * @param sequenceCount The subsequence count. Must be incremented with each new packet. - */ - TcMemWrite(const uint32_t memAddr, const uint32_t memoryData, uint16_t sequenceCount) - : SpacePacket(LENGTH_TC_MEM_WRITE - 1, true, APID_TC_MEM_WRITE, sequenceCount) { - fillPacketDataField(&memAddr, &memoryData); - } - - private: - /** - * @brief This function builds the packet data field for the mem write command. - * - * @param memAddrPtr Pointer to the PLOC memory address where to write to. - * @param memoryDataPtr Pointer to the memoryData to write - */ - void fillPacketDataField(const uint32_t* memAddrPtr, const uint32_t* memoryDataPtr) { - /* Add memAddr to packet data field */ - size_t serializedSize = 0; - uint8_t* memoryAddressPos = this->localData.fields.buffer; - SerializeAdapter::serialize(memAddrPtr, &memoryAddressPos, &serializedSize, - sizeof(*memAddrPtr), SerializeIF::Endianness::BIG); - - /* Add memLen to packet data field */ - this->localData.fields.buffer[OFFSET_MEM_LEN_FIELD] = 1; - this->localData.fields.buffer[OFFSET_MEM_LEN_FIELD + 1] = 0; - - /* Add memData to packet data field */ - serializedSize = 0; - uint8_t* memoryDataPos = this->localData.fields.buffer + OFFSET_MEM_DATA_FIELD; - SerializeAdapter::serialize(memoryDataPtr, &memoryDataPos, &serializedSize, - sizeof(*memoryDataPtr), SerializeIF::Endianness::BIG); - - /* Calculate crc */ - uint16_t crc = CRC::crc16ccitt(this->localData.byteStream, - sizeof(CCSDSPrimaryHeader) + LENGTH_TC_MEM_WRITE - CRC_SIZE); - - serializedSize = 0; - uint8_t* crcPos = this->localData.fields.buffer + CRC_OFFSET; - /* Add crc to packet data field of space packet */ - SerializeAdapter::serialize(&crc, &crcPos, &serializedSize, sizeof(crc), - SerializeIF::Endianness::BIG); - } - - /** Offsets from base address of packet data field */ - static const uint8_t OFFSET_MEM_LEN_FIELD = 4; - static const uint8_t OFFSET_MEM_DATA_FIELD = 6; - static const uint8_t CRC_OFFSET = 10; -}; - -} // namespace PLOC_MPSOC - -#endif /* MISSION_DEVICES_DEVICEDEFINITIONS_PLOCMPSOCDEFINITIONS_H_ */ diff --git a/mission/devices/devicedefinitions/payloadPcduDefinitions.h b/mission/devices/devicedefinitions/payloadPcduDefinitions.h index b6ce949e..b3ee3c71 100644 --- a/mission/devices/devicedefinitions/payloadPcduDefinitions.h +++ b/mission/devices/devicedefinitions/payloadPcduDefinitions.h @@ -152,7 +152,7 @@ static constexpr double DFT_MPA_I_UPPER_BOUND = 650.0; static constexpr double DFT_HPA_U_LOWER_BOUND = 9.4; static constexpr double DFT_HPA_U_UPPER_BOUND = 11.0; -static constexpr double DFT_HPA_I_UPPER_BOUND = 3000.0; +static constexpr double DFT_HPA_I_UPPER_BOUND = 3800.0; // Wait time in floating point seconds static constexpr double DFT_SSR_TO_DRO_WAIT_TIME = 5.0; diff --git a/mission/tmtc/CCSDSHandler.cpp b/mission/tmtc/CCSDSHandler.cpp index dcffe5f9..70e71052 100644 --- a/mission/tmtc/CCSDSHandler.cpp +++ b/mission/tmtc/CCSDSHandler.cpp @@ -313,7 +313,7 @@ void CCSDSHandler::enableTransmit() { return; } transmitterCountdown.setTimeout(TRANSMITTER_TIMEOUT); -#if BOARD_TE0720 == 0 +#ifdef TE0720_1CFA gpioIF->pullHigh(enTxClock); gpioIF->pullHigh(enTxData); #endif /* BOARD_TE0720 == 0 */ @@ -332,7 +332,7 @@ void CCSDSHandler::checkTxTimer() { } void CCSDSHandler::disableTransmit() { -#if BOARD_TE0720 == 0 +#ifdef TE0720_1CFA gpioIF->pullLow(enTxClock); gpioIF->pullLow(enTxData); #endif /* BOARD_TE0720 == 0 */ diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index 06c053c8..aea49d86 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -1 +1,2 @@ add_subdirectory(testtasks) +add_subdirectory(gpio) diff --git a/test/gpio/CMakeLists.txt b/test/gpio/CMakeLists.txt new file mode 100644 index 00000000..880f097c --- /dev/null +++ b/test/gpio/CMakeLists.txt @@ -0,0 +1,7 @@ +target_sources(${OBSW_NAME} PUBLIC + DummyGpioIF.cpp +) + +target_include_directories(${OBSW_NAME} PUBLIC + ${CMAKE_CURRENT_SOURCE_DIR} +) \ No newline at end of file diff --git a/test/gpio/DummyGpioIF.cpp b/test/gpio/DummyGpioIF.cpp new file mode 100644 index 00000000..2db78eec --- /dev/null +++ b/test/gpio/DummyGpioIF.cpp @@ -0,0 +1,16 @@ +#include "DummyGpioIF.h" + +DummyGpioIF::DummyGpioIF() {} + +DummyGpioIF::~DummyGpioIF() {} + +ReturnValue_t DummyGpioIF::addGpios(GpioCookie* cookie) { return RETURN_OK; } + +ReturnValue_t DummyGpioIF::pullHigh(gpioId_t gpioId) { return RETURN_OK; } + +ReturnValue_t DummyGpioIF::pullLow(gpioId_t gpioId) { return RETURN_OK; } + +ReturnValue_t DummyGpioIF::readGpio(gpioId_t gpioId, int* gpioState) { + *gpioState = 0; + return RETURN_OK; +} diff --git a/test/gpio/DummyGpioIF.h b/test/gpio/DummyGpioIF.h new file mode 100644 index 00000000..e6037628 --- /dev/null +++ b/test/gpio/DummyGpioIF.h @@ -0,0 +1,16 @@ +#ifndef TEST_GPIO_DUMMYGPIOIF_H_ +#define TEST_GPIO_DUMMYGPIOIF_H_ + +#include "fsfw_hal/common/gpio/GpioIF.h" + +class DummyGpioIF : public GpioIF { + public: + DummyGpioIF(); + virtual ~DummyGpioIF(); + virtual ReturnValue_t addGpios(GpioCookie* cookie); + virtual ReturnValue_t pullHigh(gpioId_t gpioId); + virtual ReturnValue_t pullLow(gpioId_t gpioId); + virtual ReturnValue_t readGpio(gpioId_t gpioId, int* gpioState); +}; + +#endif /* TEST_GPIO_DUMMYGPIOIF_H_ */ diff --git a/test/gpio/GpioDummy.h b/test/gpio/GpioDummy.h new file mode 100644 index 00000000..a849bae1 --- /dev/null +++ b/test/gpio/GpioDummy.h @@ -0,0 +1,27 @@ +#ifndef TEST_GPIODUMMY_H_ +#define TEST_GPIODUMMY_H_ + +#include "fsfw_hal/common/gpio/GpioIF.h" +#include "fsfw_hal/common/gpio/gpioDefinitions.h" + +/** + * @brief Additional abstraction layer for handling GPIOs. + * + * @author J. Meier + */ +class Gpio { + public: + Gpio(gpioId_t gpioId, GpioIF* gpioIF) : gpioId(gpioId), gpioIF(gpioIF) { + if (gpioIF == nullptr) { + sif::error << "Gpio::Gpio: Invalid GpioIF" << std::endl; + } + } + ReturnValue_t pullHigh() { return gpioIF->pullHigh(gpioId); } + ReturnValue_t pullLow() { return gpioIF->pullLow(gpioId); } + + private: + gpioId_t gpioId = gpio::NO_GPIO; + GpioIF* gpioIF = nullptr; +}; + +#endif /* TEST_GPIODUMMY_H_ */ diff --git a/tmtc b/tmtc index 43a534db..6db0a2cb 160000 --- a/tmtc +++ b/tmtc @@ -1 +1 @@ -Subproject commit 43a534db9cf8ee14e6c1296dac8b3e2c3c94b240 +Subproject commit 6db0a2cb791909a69506ed56df5518c277ece275