Heater Handling #325
@ -10,6 +10,13 @@ list yields a list of all related PRs for each release.
|
||||
|
||||
# [unreleased]
|
||||
|
||||
## Added
|
||||
|
||||
- PLOC Supervisor Update: Update SW to use newest PLOC SUPV version by TAS
|
||||
PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/316
|
||||
|
||||
# [v1.16.0] 18.11.2022
|
||||
|
||||
- It is now possible to compile Linux components for the hosted build conditionally
|
||||
PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/322
|
||||
- ACS Subsystem. PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/231
|
||||
|
||||
@ -10,7 +10,7 @@
|
||||
cmake_minimum_required(VERSION 3.13)
|
||||
|
||||
set(OBSW_VERSION_MAJOR_IF_GIT_FAILS 1)
|
||||
set(OBSW_VERSION_MINOR_IF_GIT_FAILS 15)
|
||||
set(OBSW_VERSION_MINOR_IF_GIT_FAILS 16)
|
||||
set(OBSW_VERSION_REVISION_IF_GIT_FAILS 0)
|
||||
|
||||
# set(CMAKE_VERBOSE TRUE)
|
||||
@ -141,7 +141,7 @@ set(OBSW_ADD_TMP_DEVICES
|
||||
${INIT_VAL}
|
||||
CACHE STRING "Add TMP devices")
|
||||
set(OBSW_ADD_GOMSPACE_PCDU
|
||||
${INIT_VAL}
|
||||
1
|
||||
CACHE STRING "Add GomSpace PCDU modules")
|
||||
set(OBSW_ADD_RW
|
||||
${INIT_VAL}
|
||||
@ -296,6 +296,9 @@ if(TGT_BSP)
|
||||
else()
|
||||
# Required by FSFW library
|
||||
set(FSFW_CONFIG_PATH "${BSP_PATH}/fsfwconfig")
|
||||
if(UNIX)
|
||||
set(EIVE_ADD_LINUX_FILES ON)
|
||||
endif()
|
||||
endif()
|
||||
|
||||
# Configuration files
|
||||
|
||||
23
README.md
23
README.md
@ -1055,6 +1055,29 @@ Get fill count:
|
||||
xsc_scratch read | wc -c
|
||||
```
|
||||
|
||||
## Custom device names in Linux with the `udev` module
|
||||
|
||||
You can assign custom device names using the Linux `udev` system.
|
||||
This works by specifying a rules file inside the `/etc/udev/rules.d` folder
|
||||
which creates a SYMLINK if certain device properties are true.
|
||||
|
||||
Each rule is a new line inside a rules file.
|
||||
For example, the rule
|
||||
|
||||
```txt
|
||||
SUBSYSTEM=="tty", ATTRS{interface}=="Dual RS232-HS", ATTRS{bInterfaceNumber}=="01", SYMLINK+="ploc_supv
|
||||
```
|
||||
|
||||
Will create a symlink `/dev/ploc_supv` if a connected USB device has the
|
||||
same `interface` and `bInterfaceNumber` properties as shown above.
|
||||
|
||||
You can list the properties for a given connected device using `udevadm`.
|
||||
For example, you can do this for a connected example device `/dev/ttyUSB0`
|
||||
by using
|
||||
|
||||
```txt
|
||||
udevadm info -a /dev/ttyUSB0
|
||||
```
|
||||
|
||||
## Using `system` when debugging
|
||||
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
target_sources(${OBSW_NAME} PUBLIC InitMission.cpp main.cpp ObjectFactory.cpp)
|
||||
target_sources(${OBSW_NAME} PUBLIC scheduling.cpp main.cpp ObjectFactory.cpp)
|
||||
|
||||
add_subdirectory(fsfwconfig)
|
||||
add_subdirectory(boardconfig)
|
||||
|
||||
@ -1,9 +0,0 @@
|
||||
#ifndef BSP_LINUX_INITMISSION_H_
|
||||
#define BSP_LINUX_INITMISSION_H_
|
||||
|
||||
namespace initmission {
|
||||
void initMission();
|
||||
void initTasks();
|
||||
}; // namespace initmission
|
||||
|
||||
#endif /* BSP_LINUX_INITMISSION_H_ */
|
||||
@ -15,7 +15,7 @@
|
||||
|
||||
#define OBSW_ENABLE_TIMERS 1
|
||||
#define OBSW_ADD_STAR_TRACKER 0
|
||||
#define OBSW_ADD_PLOC_SUPERVISOR 0
|
||||
#define OBSW_ADD_PLOC_SUPERVISOR 1
|
||||
#define OBSW_ADD_PLOC_MPSOC 0
|
||||
#define OBSW_ADD_SUN_SENSORS 0
|
||||
#define OBSW_ADD_MGT 0
|
||||
@ -24,6 +24,7 @@
|
||||
#define OBSW_ADD_GPS_0 0
|
||||
#define OBSW_ADD_GPS_1 0
|
||||
#define OBSW_ADD_RW 0
|
||||
#define OBSW_DEBUG_TMP1075 0
|
||||
#define OBSW_ADD_BPX_BATTERY_HANDLER 0
|
||||
#define OBSW_ADD_RTD_DEVICES 0
|
||||
#define OBSW_ADD_PL_PCDU 0
|
||||
@ -100,6 +101,13 @@
|
||||
/*******************************************************************/
|
||||
/** CMake Defines */
|
||||
/*******************************************************************/
|
||||
|
||||
// Use TCP instead of UDP for the TMTC bridge. This allows using the TMTC client locally
|
||||
// because UDP packets are not allowed in the VPN
|
||||
// This will cause the OBSW to initialize the TMTC bridge responsible for exchanging data with the
|
||||
// CCSDS IP Cores.
|
||||
#define OBSW_USE_TMTC_TCP_BRIDGE 0
|
||||
|
||||
#cmakedefine EIVE_BUILD_GPSD_GPS_HANDLER
|
||||
|
||||
#cmakedefine LIBGPS_VERSION_MAJOR @LIBGPS_VERSION_MAJOR@
|
||||
|
||||
@ -1,16 +1,19 @@
|
||||
#include "ObjectFactory.h"
|
||||
|
||||
#include <fsfw/power/DummyPowerSwitcher.h>
|
||||
#include <fsfw/tmtcservices/CommandingServiceBase.h>
|
||||
#include <fsfw/tmtcservices/PusServiceBase.h>
|
||||
#include <mission/controller/ThermalController.h>
|
||||
#include <mission/core/GenericFactory.h>
|
||||
#include <mission/tmtc/TmFunnelHandler.h>
|
||||
#include <objects/systemObjectList.h>
|
||||
#include <tmtc/pusIds.h>
|
||||
|
||||
#include "OBSWConfig.h"
|
||||
#include "devConf.h"
|
||||
#include "eive/definitions.h"
|
||||
#include "fsfw/platform.h"
|
||||
#include "fsfw_tests/integration/task/TestTask.h"
|
||||
#include "tmtc/pusIds.h"
|
||||
|
||||
#if OBSW_USE_TMTC_TCP_BRIDGE == 0
|
||||
#include "fsfw/osal/common/UdpTcPollingTask.h"
|
||||
@ -47,12 +50,25 @@
|
||||
#include "dummies/helpers.h"
|
||||
#include "mission/utility/GlobalConfigHandler.h"
|
||||
|
||||
#ifdef PLATFORM_UNIX
|
||||
#include <fsfw_hal/linux/serial/SerialComIF.h>
|
||||
#include <fsfw_hal/linux/serial/SerialCookie.h>
|
||||
|
||||
#include "devices/gpioIds.h"
|
||||
#include "fsfw_hal/linux/gpio/Gpio.h"
|
||||
#include "linux/devices/ploc/PlocMPSoCHandler.h"
|
||||
#include "linux/devices/ploc/PlocMPSoCHelper.h"
|
||||
#include "linux/devices/ploc/PlocSupervisorHandler.h"
|
||||
#include "linux/devices/ploc/PlocSupvUartMan.h"
|
||||
#include "test/gpio/DummyGpioIF.h"
|
||||
#endif
|
||||
|
||||
void Factory::setStaticFrameworkObjectIds() {
|
||||
PusServiceBase::PUS_DISTRIBUTOR = objects::PUS_PACKET_DISTRIBUTOR;
|
||||
PusServiceBase::PACKET_DESTINATION = objects::TM_FUNNEL;
|
||||
PusServiceBase::PACKET_DESTINATION = objects::PUS_TM_FUNNEL;
|
||||
|
||||
CommandingServiceBase::defaultPacketSource = objects::PUS_PACKET_DISTRIBUTOR;
|
||||
CommandingServiceBase::defaultPacketDestination = objects::TM_FUNNEL;
|
||||
CommandingServiceBase::defaultPacketDestination = objects::PUS_TM_FUNNEL;
|
||||
|
||||
VerificationReporter::DEFAULT_RECEIVER = objects::PUS_SERVICE_1_VERIFICATION;
|
||||
}
|
||||
@ -63,10 +79,36 @@ void ObjectFactory::produce(void* args) {
|
||||
CfdpTmFunnel* cfdpFunnel;
|
||||
ObjectFactory::produceGenericObjects(nullptr, &pusFunnel, &cfdpFunnel);
|
||||
|
||||
DummyGpioIF* dummyGpioIF = new DummyGpioIF();
|
||||
auto* dummySwitcher = new DummyPowerSwitcher(objects::PCDU_HANDLER, 18, 0);
|
||||
static_cast<void>(dummyGpioIF);
|
||||
#ifdef PLATFORM_UNIX
|
||||
new SerialComIF(objects::UART_COM_IF);
|
||||
#if OBSW_ADD_PLOC_MPSOC == 1
|
||||
std::string mpscoDev = "";
|
||||
auto mpsocCookie = new UartCookie(objects::PLOC_MPSOC_HANDLER, mpscoDev, uart::PLOC_MPSOC_BAUD,
|
||||
mpsoc::MAX_REPLY_SIZE, UartModes::NON_CANONICAL);
|
||||
mpsocCookie->setNoFixedSizeReply();
|
||||
auto plocMpsocHelper = new PlocMPSoCHelper(objects::PLOC_MPSOC_HELPER);
|
||||
new PlocMPSoCHandler(objects::PLOC_MPSOC_HANDLER, objects::UART_COM_IF, mpsocCookie,
|
||||
plocMpsocHelper, Gpio(gpioIds::ENABLE_MPSOC_UART, dummyGpioIF),
|
||||
objects::PLOC_SUPERVISOR_HANDLER);
|
||||
#endif /* OBSW_ADD_PLOC_MPSOC == 1 */
|
||||
#if OBSW_ADD_PLOC_SUPERVISOR == 1
|
||||
std::string plocSupvString = "/dev/ploc_supv";
|
||||
auto supervisorCookie =
|
||||
new SerialCookie(objects::PLOC_SUPERVISOR_HANDLER, plocSupvString, uart::PLOC_SUPV_BAUD,
|
||||
supv::MAX_PACKET_SIZE * 20, UartModes::NON_CANONICAL);
|
||||
supervisorCookie->setNoFixedSizeReply();
|
||||
auto supvHelper = new PlocSupvUartManager(objects::PLOC_SUPERVISOR_HELPER);
|
||||
new PlocSupervisorHandler(objects::PLOC_SUPERVISOR_HANDLER, supervisorCookie,
|
||||
Gpio(gpioIds::ENABLE_SUPV_UART, dummyGpioIF), pcdu::PDU1_CH6_PLOC_12V,
|
||||
*supvHelper);
|
||||
#endif /* OBSW_ADD_PLOC_SUPERVISOR == 1 */
|
||||
#endif
|
||||
|
||||
dummy::DummyCfg cfg;
|
||||
dummy::createDummies(cfg);
|
||||
new TemperatureSensorsDummy();
|
||||
new SusDummy();
|
||||
dummy::createDummies(cfg, *dummySwitcher);
|
||||
new ThermalController(objects::THERMAL_CONTROLLER);
|
||||
new TestTask(objects::TEST_TASK);
|
||||
}
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
/**
|
||||
* @brief Auto-generated event translation file. Contains 83 translations.
|
||||
* @brief Auto-generated event translation file. Contains 239 translations.
|
||||
* @details
|
||||
* Generated on: 2021-05-17 19:49:55
|
||||
* Generated on: 2022-11-16 15:25:08
|
||||
*/
|
||||
#include "translateEvents.h"
|
||||
|
||||
@ -34,6 +34,7 @@ const char *DEVICE_UNREQUESTED_REPLY_STRING = "DEVICE_UNREQUESTED_REPLY";
|
||||
const char *INVALID_DEVICE_COMMAND_STRING = "INVALID_DEVICE_COMMAND";
|
||||
const char *MONITORING_LIMIT_EXCEEDED_STRING = "MONITORING_LIMIT_EXCEEDED";
|
||||
const char *MONITORING_AMBIGUOUS_STRING = "MONITORING_AMBIGUOUS";
|
||||
const char *DEVICE_WANTS_HARD_REBOOT_STRING = "DEVICE_WANTS_HARD_REBOOT";
|
||||
const char *FUSE_CURRENT_HIGH_STRING = "FUSE_CURRENT_HIGH";
|
||||
const char *FUSE_WENT_OFF_STRING = "FUSE_WENT_OFF";
|
||||
const char *POWER_ABOVE_HIGH_LIMIT_STRING = "POWER_ABOVE_HIGH_LIMIT";
|
||||
@ -59,7 +60,6 @@ const char *MONITOR_CHANGED_STATE_STRING = "MONITOR_CHANGED_STATE";
|
||||
const char *VALUE_BELOW_LOW_LIMIT_STRING = "VALUE_BELOW_LOW_LIMIT";
|
||||
const char *VALUE_ABOVE_HIGH_LIMIT_STRING = "VALUE_ABOVE_HIGH_LIMIT";
|
||||
const char *VALUE_OUT_OF_RANGE_STRING = "VALUE_OUT_OF_RANGE";
|
||||
const char *SWITCHING_TM_FAILED_STRING = "SWITCHING_TM_FAILED";
|
||||
const char *CHANGING_MODE_STRING = "CHANGING_MODE";
|
||||
const char *MODE_INFO_STRING = "MODE_INFO";
|
||||
const char *FALLBACK_FAILED_STRING = "FALLBACK_FAILED";
|
||||
@ -75,6 +75,7 @@ const char *OVERWRITING_HEALTH_STRING = "OVERWRITING_HEALTH";
|
||||
const char *TRYING_RECOVERY_STRING = "TRYING_RECOVERY";
|
||||
const char *RECOVERY_STEP_STRING = "RECOVERY_STEP";
|
||||
const char *RECOVERY_DONE_STRING = "RECOVERY_DONE";
|
||||
const char *HANDLE_PACKET_FAILED_STRING = "HANDLE_PACKET_FAILED";
|
||||
const char *RF_AVAILABLE_STRING = "RF_AVAILABLE";
|
||||
const char *RF_LOST_STRING = "RF_LOST";
|
||||
const char *BIT_LOCK_STRING = "BIT_LOCK";
|
||||
@ -82,15 +83,166 @@ const char *BIT_LOCK_LOST_STRING = "BIT_LOCK_LOST";
|
||||
const char *FRAME_PROCESSING_FAILED_STRING = "FRAME_PROCESSING_FAILED";
|
||||
const char *CLOCK_SET_STRING = "CLOCK_SET";
|
||||
const char *CLOCK_SET_FAILURE_STRING = "CLOCK_SET_FAILURE";
|
||||
const char *TC_DELETION_FAILED_STRING = "TC_DELETION_FAILED";
|
||||
const char *TEST_STRING = "TEST";
|
||||
const char *CHANGE_OF_SETUP_PARAMETER_STRING = "CHANGE_OF_SETUP_PARAMETER";
|
||||
const char *STORE_ERROR_STRING = "STORE_ERROR";
|
||||
const char *MSG_QUEUE_ERROR_STRING = "MSG_QUEUE_ERROR";
|
||||
const char *SERIALIZATION_ERROR_STRING = "SERIALIZATION_ERROR";
|
||||
const char *SWITCH_CMD_SENT_STRING = "SWITCH_CMD_SENT";
|
||||
const char *SWITCH_HAS_CHANGED_STRING = "SWITCH_HAS_CHANGED";
|
||||
const char *SWITCHING_Q7S_DENIED_STRING = "SWITCHING_Q7S_DENIED";
|
||||
const char *FDIR_REACTION_IGNORED_STRING = "FDIR_REACTION_IGNORED";
|
||||
const char *GPIO_PULL_HIGH_FAILED_STRING = "GPIO_PULL_HIGH_FAILED";
|
||||
const char *GPIO_PULL_LOW_FAILED_STRING = "GPIO_PULL_LOW_FAILED";
|
||||
const char *HEATER_WENT_ON_STRING = "HEATER_WENT_ON";
|
||||
const char *HEATER_WENT_OFF_STRING = "HEATER_WENT_OFF";
|
||||
const char *SWITCH_ALREADY_ON_STRING = "SWITCH_ALREADY_ON";
|
||||
const char *SWITCH_ALREADY_OFF_STRING = "SWITCH_ALREADY_OFF";
|
||||
const char *MAIN_SWITCH_TIMEOUT_STRING = "MAIN_SWITCH_TIMEOUT";
|
||||
const char *FAULTY_HEATER_WAS_ON_STRING = "FAULTY_HEATER_WAS_ON";
|
||||
const char *BURN_PHASE_START_STRING = "BURN_PHASE_START";
|
||||
const char *BURN_PHASE_DONE_STRING = "BURN_PHASE_DONE";
|
||||
const char *MAIN_SWITCH_ON_TIMEOUT_STRING = "MAIN_SWITCH_ON_TIMEOUT";
|
||||
const char *MAIN_SWITCH_OFF_TIMEOUT_STRING = "MAIN_SWITCH_OFF_TIMEOUT";
|
||||
const char *DEPL_SA1_GPIO_SWTICH_ON_FAILED_STRING = "DEPL_SA1_GPIO_SWTICH_ON_FAILED";
|
||||
const char *DEPL_SA2_GPIO_SWTICH_ON_FAILED_STRING = "DEPL_SA2_GPIO_SWTICH_ON_FAILED";
|
||||
const char *DEPL_SA1_GPIO_SWTICH_OFF_FAILED_STRING = "DEPL_SA1_GPIO_SWTICH_OFF_FAILED";
|
||||
const char *DEPL_SA2_GPIO_SWTICH_OFF_FAILED_STRING = "DEPL_SA2_GPIO_SWTICH_OFF_FAILED";
|
||||
const char *AUTONOMOUS_DEPLOYMENT_COMPLETED_STRING = "AUTONOMOUS_DEPLOYMENT_COMPLETED";
|
||||
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_SEQUENCE_COUNT_MISMATCH_STRING = "MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH";
|
||||
const char *MPSOC_SHUTDOWN_FAILED_STRING = "MPSOC_SHUTDOWN_FAILED";
|
||||
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";
|
||||
const char *SELF_TEST_PWM_FAILURE_STRING = "SELF_TEST_PWM_FAILURE";
|
||||
const char *SELF_TEST_TC_FAILURE_STRING = "SELF_TEST_TC_FAILURE";
|
||||
const char *SELF_TEST_MTM_RANGE_FAILURE_STRING = "SELF_TEST_MTM_RANGE_FAILURE";
|
||||
const char *SELF_TEST_COIL_CURRENT_FAILURE_STRING = "SELF_TEST_COIL_CURRENT_FAILURE";
|
||||
const char *INVALID_ERROR_BYTE_STRING = "INVALID_ERROR_BYTE";
|
||||
const char *ERROR_STATE_STRING = "ERROR_STATE";
|
||||
const char *RESET_OCCURED_STRING = "RESET_OCCURED";
|
||||
const char *BOOTING_FIRMWARE_FAILED_STRING = "BOOTING_FIRMWARE_FAILED";
|
||||
const char *BOOTING_BOOTLOADER_FAILED_STRING = "BOOTING_BOOTLOADER_FAILED";
|
||||
const char *SUPV_MEMORY_READ_RPT_CRC_FAILURE_STRING = "SUPV_MEMORY_READ_RPT_CRC_FAILURE";
|
||||
const char *SUPV_UNKNOWN_TM_STRING = "SUPV_UNKNOWN_TM";
|
||||
const char *SUPV_UNINIMPLEMENTED_TM_STRING = "SUPV_UNINIMPLEMENTED_TM";
|
||||
const char *SUPV_ACK_FAILURE_STRING = "SUPV_ACK_FAILURE";
|
||||
const char *SUPV_EXE_FAILURE_STRING = "SUPV_EXE_FAILURE";
|
||||
const char *SUPV_CRC_FAILURE_EVENT_STRING = "SUPV_CRC_FAILURE_EVENT";
|
||||
const char *SUPV_HELPER_EXECUTING_STRING = "SUPV_HELPER_EXECUTING";
|
||||
const char *SUPV_MPSOC_SHUWDOWN_BUILD_FAILED_STRING = "SUPV_MPSOC_SHUWDOWN_BUILD_FAILED";
|
||||
const char *SANITIZATION_FAILED_STRING = "SANITIZATION_FAILED";
|
||||
const char *MOUNTED_SD_CARD_STRING = "MOUNTED_SD_CARD";
|
||||
const char *SEND_MRAM_DUMP_FAILED_STRING = "SEND_MRAM_DUMP_FAILED";
|
||||
const char *MRAM_DUMP_FAILED_STRING = "MRAM_DUMP_FAILED";
|
||||
const char *MRAM_DUMP_FINISHED_STRING = "MRAM_DUMP_FINISHED";
|
||||
const char *INVALID_TC_FRAME_STRING = "INVALID_TC_FRAME";
|
||||
const char *INVALID_FAR_STRING = "INVALID_FAR";
|
||||
const char *CARRIER_LOCK_STRING = "CARRIER_LOCK";
|
||||
const char *BIT_LOCK_PDEC_STRING = "BIT_LOCK_PDEC";
|
||||
const char *LOST_CARRIER_LOCK_PDEC_STRING = "LOST_CARRIER_LOCK_PDEC";
|
||||
const char *LOST_BIT_LOCK_PDEC_STRING = "LOST_BIT_LOCK_PDEC";
|
||||
const char *POLL_ERROR_PDEC_STRING = "POLL_ERROR_PDEC";
|
||||
const char *IMAGE_UPLOAD_FAILED_STRING = "IMAGE_UPLOAD_FAILED";
|
||||
const char *IMAGE_DOWNLOAD_FAILED_STRING = "IMAGE_DOWNLOAD_FAILED";
|
||||
const char *IMAGE_UPLOAD_SUCCESSFUL_STRING = "IMAGE_UPLOAD_SUCCESSFUL";
|
||||
const char *IMAGE_DOWNLOAD_SUCCESSFUL_STRING = "IMAGE_DOWNLOAD_SUCCESSFUL";
|
||||
const char *FLASH_WRITE_SUCCESSFUL_STRING = "FLASH_WRITE_SUCCESSFUL";
|
||||
const char *FLASH_READ_SUCCESSFUL_STRING = "FLASH_READ_SUCCESSFUL";
|
||||
const char *FLASH_READ_FAILED_STRING = "FLASH_READ_FAILED";
|
||||
const char *FIRMWARE_UPDATE_SUCCESSFUL_STRING = "FIRMWARE_UPDATE_SUCCESSFUL";
|
||||
const char *FIRMWARE_UPDATE_FAILED_STRING = "FIRMWARE_UPDATE_FAILED";
|
||||
const char *STR_HELPER_READING_REPLY_FAILED_STRING = "STR_HELPER_READING_REPLY_FAILED";
|
||||
const char *STR_HELPER_COM_ERROR_STRING = "STR_HELPER_COM_ERROR";
|
||||
const char *STR_HELPER_NO_REPLY_STRING = "STR_HELPER_NO_REPLY";
|
||||
const char *STR_HELPER_DEC_ERROR_STRING = "STR_HELPER_DEC_ERROR";
|
||||
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 *MPSOC_SENDING_COMMAND_FAILED_STRING = "MPSOC_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 *MPSOC_MISSING_ACK_STRING = "MPSOC_MISSING_ACK";
|
||||
const char *MPSOC_MISSING_EXE_STRING = "MPSOC_MISSING_EXE";
|
||||
const char *MPSOC_ACK_FAILURE_REPORT_STRING = "MPSOC_ACK_FAILURE_REPORT";
|
||||
const char *MPSOC_EXE_FAILURE_REPORT_STRING = "MPSOC_EXE_FAILURE_REPORT";
|
||||
const char *MPSOC_ACK_INVALID_APID_STRING = "MPSOC_ACK_INVALID_APID";
|
||||
const char *MPSOC_EXE_INVALID_APID_STRING = "MPSOC_EXE_INVALID_APID";
|
||||
const char *MPSOC_HELPER_SEQ_CNT_MISMATCH_STRING = "MPSOC_HELPER_SEQ_CNT_MISMATCH";
|
||||
const char *MPSOC_TM_SIZE_ERROR_STRING = "MPSOC_TM_SIZE_ERROR";
|
||||
const char *MPSOC_TM_CRC_MISSMATCH_STRING = "MPSOC_TM_CRC_MISSMATCH";
|
||||
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";
|
||||
const char *I_DRO_OUT_OF_BOUNDS_STRING = "I_DRO_OUT_OF_BOUNDS";
|
||||
const char *U_X8_OUT_OF_BOUNDS_STRING = "U_X8_OUT_OF_BOUNDS";
|
||||
const char *I_X8_OUT_OF_BOUNDS_STRING = "I_X8_OUT_OF_BOUNDS";
|
||||
const char *U_TX_OUT_OF_BOUNDS_STRING = "U_TX_OUT_OF_BOUNDS";
|
||||
const char *I_TX_OUT_OF_BOUNDS_STRING = "I_TX_OUT_OF_BOUNDS";
|
||||
const char *U_MPA_OUT_OF_BOUNDS_STRING = "U_MPA_OUT_OF_BOUNDS";
|
||||
const char *I_MPA_OUT_OF_BOUNDS_STRING = "I_MPA_OUT_OF_BOUNDS";
|
||||
const char *U_HPA_OUT_OF_BOUNDS_STRING = "U_HPA_OUT_OF_BOUNDS";
|
||||
const char *I_HPA_OUT_OF_BOUNDS_STRING = "I_HPA_OUT_OF_BOUNDS";
|
||||
const char *TRANSITION_OTHER_SIDE_FAILED_STRING = "TRANSITION_OTHER_SIDE_FAILED";
|
||||
const char *NOT_ENOUGH_DEVICES_DUAL_MODE_STRING = "NOT_ENOUGH_DEVICES_DUAL_MODE";
|
||||
const char *POWER_STATE_MACHINE_TIMEOUT_STRING = "POWER_STATE_MACHINE_TIMEOUT";
|
||||
const char *SIDE_SWITCH_TRANSITION_NOT_ALLOWED_STRING = "SIDE_SWITCH_TRANSITION_NOT_ALLOWED";
|
||||
const char *CHILDREN_LOST_MODE_STRING = "CHILDREN_LOST_MODE";
|
||||
const char *GPS_FIX_CHANGE_STRING = "GPS_FIX_CHANGE";
|
||||
const char *P60_BOOT_COUNT_STRING = "P60_BOOT_COUNT";
|
||||
const char *BATT_MODE_STRING = "BATT_MODE";
|
||||
const char *BATT_MODE_CHANGED_STRING = "BATT_MODE_CHANGED";
|
||||
const char *SUPV_UPDATE_FAILED_STRING = "SUPV_UPDATE_FAILED";
|
||||
const char *SUPV_UPDATE_SUCCESSFUL_STRING = "SUPV_UPDATE_SUCCESSFUL";
|
||||
const char *SUPV_CONTINUE_UPDATE_FAILED_STRING = "SUPV_CONTINUE_UPDATE_FAILED";
|
||||
const char *SUPV_CONTINUE_UPDATE_SUCCESSFUL_STRING = "SUPV_CONTINUE_UPDATE_SUCCESSFUL";
|
||||
const char *TERMINATED_UPDATE_PROCEDURE_STRING = "TERMINATED_UPDATE_PROCEDURE";
|
||||
const char *SUPV_EVENT_BUFFER_REQUEST_SUCCESSFUL_STRING = "SUPV_EVENT_BUFFER_REQUEST_SUCCESSFUL";
|
||||
const char *SUPV_EVENT_BUFFER_REQUEST_FAILED_STRING = "SUPV_EVENT_BUFFER_REQUEST_FAILED";
|
||||
const char *SUPV_EVENT_BUFFER_REQUEST_TERMINATED_STRING = "SUPV_EVENT_BUFFER_REQUEST_TERMINATED";
|
||||
const char *SUPV_MEM_CHECK_OK_STRING = "SUPV_MEM_CHECK_OK";
|
||||
const char *SUPV_MEM_CHECK_FAIL_STRING = "SUPV_MEM_CHECK_FAIL";
|
||||
const char *SUPV_SENDING_COMMAND_FAILED_STRING = "SUPV_SENDING_COMMAND_FAILED";
|
||||
const char *SUPV_HELPER_REQUESTING_REPLY_FAILED_STRING = "SUPV_HELPER_REQUESTING_REPLY_FAILED";
|
||||
const char *SUPV_HELPER_READING_REPLY_FAILED_STRING = "SUPV_HELPER_READING_REPLY_FAILED";
|
||||
const char *SUPV_MISSING_ACK_STRING = "SUPV_MISSING_ACK";
|
||||
const char *SUPV_MISSING_EXE_STRING = "SUPV_MISSING_EXE";
|
||||
const char *SUPV_ACK_FAILURE_REPORT_STRING = "SUPV_ACK_FAILURE_REPORT";
|
||||
const char *SUPV_EXE_FAILURE_REPORT_STRING = "SUPV_EXE_FAILURE_REPORT";
|
||||
const char *SUPV_ACK_INVALID_APID_STRING = "SUPV_ACK_INVALID_APID";
|
||||
const char *SUPV_EXE_INVALID_APID_STRING = "SUPV_EXE_INVALID_APID";
|
||||
const char *ACK_RECEPTION_FAILURE_STRING = "ACK_RECEPTION_FAILURE";
|
||||
const char *EXE_RECEPTION_FAILURE_STRING = "EXE_RECEPTION_FAILURE";
|
||||
const char *WRITE_MEMORY_FAILED_STRING = "WRITE_MEMORY_FAILED";
|
||||
const char *SUPV_REPLY_SIZE_MISSMATCH_STRING = "SUPV_REPLY_SIZE_MISSMATCH";
|
||||
const char *SUPV_REPLY_CRC_MISSMATCH_STRING = "SUPV_REPLY_CRC_MISSMATCH";
|
||||
const char *SUPV_UPDATE_PROGRESS_STRING = "SUPV_UPDATE_PROGRESS";
|
||||
const char *HDLC_FRAME_REMOVAL_ERROR_STRING = "HDLC_FRAME_REMOVAL_ERROR";
|
||||
const char *HDLC_CRC_ERROR_STRING = "HDLC_CRC_ERROR";
|
||||
const char *ALLOC_FAILURE_STRING = "ALLOC_FAILURE";
|
||||
const char *REBOOT_SW_STRING = "REBOOT_SW";
|
||||
const char *REBOOT_MECHANISM_TRIGGERED_STRING = "REBOOT_MECHANISM_TRIGGERED";
|
||||
const char *REBOOT_HW_STRING = "REBOOT_HW";
|
||||
const char *NO_SD_CARD_ACTIVE_STRING = "NO_SD_CARD_ACTIVE";
|
||||
const char *MISSING_PACKET_STRING = "MISSING_PACKET";
|
||||
const char *EXPERIMENT_TIMEDOUT_STRING = "EXPERIMENT_TIMEDOUT";
|
||||
const char *MULTI_PACKET_COMMAND_DONE_STRING = "MULTI_PACKET_COMMAND_DONE";
|
||||
const char *SET_CONFIGFILEVALUE_FAILED_STRING = "SET_CONFIGFILEVALUE_FAILED";
|
||||
const char *GET_CONFIGFILEVALUE_FAILED_STRING = "GET_CONFIGFILEVALUE_FAILED";
|
||||
const char *INSERT_CONFIGFILEVALUE_FAILED_STRING = "INSERT_CONFIGFILEVALUE_FAILED";
|
||||
const char *WRITE_CONFIGFILE_FAILED_STRING = "WRITE_CONFIGFILE_FAILED";
|
||||
const char *READ_CONFIGFILE_FAILED_STRING = "READ_CONFIGFILE_FAILED";
|
||||
|
||||
const char *translateEvents(Event event) {
|
||||
switch ((event & 0xffff)) {
|
||||
switch ((event & 0xFFFF)) {
|
||||
case (2200):
|
||||
return STORE_SEND_WRITE_FAILED_STRING;
|
||||
case (2201):
|
||||
@ -149,6 +301,8 @@ const char *translateEvents(Event event) {
|
||||
return MONITORING_LIMIT_EXCEEDED_STRING;
|
||||
case (2810):
|
||||
return MONITORING_AMBIGUOUS_STRING;
|
||||
case (2811):
|
||||
return DEVICE_WANTS_HARD_REBOOT_STRING;
|
||||
case (4201):
|
||||
return FUSE_CURRENT_HIGH_STRING;
|
||||
case (4202):
|
||||
@ -199,8 +353,6 @@ const char *translateEvents(Event event) {
|
||||
return VALUE_ABOVE_HIGH_LIMIT_STRING;
|
||||
case (7204):
|
||||
return VALUE_OUT_OF_RANGE_STRING;
|
||||
case (7301):
|
||||
return SWITCHING_TM_FAILED_STRING;
|
||||
case (7400):
|
||||
return CHANGING_MODE_STRING;
|
||||
case (7401):
|
||||
@ -231,6 +383,8 @@ const char *translateEvents(Event event) {
|
||||
return RECOVERY_STEP_STRING;
|
||||
case (7512):
|
||||
return RECOVERY_DONE_STRING;
|
||||
case (7600):
|
||||
return HANDLE_PACKET_FAILED_STRING;
|
||||
case (7900):
|
||||
return RF_AVAILABLE_STRING;
|
||||
case (7901):
|
||||
@ -245,18 +399,320 @@ const char *translateEvents(Event event) {
|
||||
return CLOCK_SET_STRING;
|
||||
case (8901):
|
||||
return CLOCK_SET_FAILURE_STRING;
|
||||
case (9100):
|
||||
return TC_DELETION_FAILED_STRING;
|
||||
case (9700):
|
||||
return TEST_STRING;
|
||||
case (10600):
|
||||
return CHANGE_OF_SETUP_PARAMETER_STRING;
|
||||
case (11101):
|
||||
case (10800):
|
||||
return STORE_ERROR_STRING;
|
||||
case (10801):
|
||||
return MSG_QUEUE_ERROR_STRING;
|
||||
case (10802):
|
||||
return SERIALIZATION_ERROR_STRING;
|
||||
case (11300):
|
||||
return SWITCH_CMD_SENT_STRING;
|
||||
case (11301):
|
||||
return SWITCH_HAS_CHANGED_STRING;
|
||||
case (11302):
|
||||
return SWITCHING_Q7S_DENIED_STRING;
|
||||
case (11303):
|
||||
return FDIR_REACTION_IGNORED_STRING;
|
||||
case (11400):
|
||||
return GPIO_PULL_HIGH_FAILED_STRING;
|
||||
case (11401):
|
||||
return GPIO_PULL_LOW_FAILED_STRING;
|
||||
case (11402):
|
||||
return HEATER_WENT_ON_STRING;
|
||||
case (11403):
|
||||
return HEATER_WENT_OFF_STRING;
|
||||
case (11404):
|
||||
return SWITCH_ALREADY_ON_STRING;
|
||||
case (11405):
|
||||
return SWITCH_ALREADY_OFF_STRING;
|
||||
case (11406):
|
||||
return MAIN_SWITCH_TIMEOUT_STRING;
|
||||
case (11407):
|
||||
return FAULTY_HEATER_WAS_ON_STRING;
|
||||
case (11500):
|
||||
return BURN_PHASE_START_STRING;
|
||||
case (11501):
|
||||
return BURN_PHASE_DONE_STRING;
|
||||
case (11502):
|
||||
return MAIN_SWITCH_ON_TIMEOUT_STRING;
|
||||
case (11503):
|
||||
return MAIN_SWITCH_OFF_TIMEOUT_STRING;
|
||||
case (11504):
|
||||
return DEPL_SA1_GPIO_SWTICH_ON_FAILED_STRING;
|
||||
case (11505):
|
||||
return DEPL_SA2_GPIO_SWTICH_ON_FAILED_STRING;
|
||||
case (11506):
|
||||
return DEPL_SA1_GPIO_SWTICH_OFF_FAILED_STRING;
|
||||
case (11507):
|
||||
return DEPL_SA2_GPIO_SWTICH_OFF_FAILED_STRING;
|
||||
case (11508):
|
||||
return AUTONOMOUS_DEPLOYMENT_COMPLETED_STRING;
|
||||
case (11601):
|
||||
return MEMORY_READ_RPT_CRC_FAILURE_STRING;
|
||||
case (11102):
|
||||
case (11602):
|
||||
return ACK_FAILURE_STRING;
|
||||
case (11103):
|
||||
case (11603):
|
||||
return EXE_FAILURE_STRING;
|
||||
case (11104):
|
||||
return CRC_FAILURE_EVENT_STRING;
|
||||
case (11604):
|
||||
return MPSOC_HANDLER_CRC_FAILURE_STRING;
|
||||
case (11605):
|
||||
return MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH_STRING;
|
||||
case (11606):
|
||||
return MPSOC_SHUTDOWN_FAILED_STRING;
|
||||
case (11701):
|
||||
return SELF_TEST_I2C_FAILURE_STRING;
|
||||
case (11702):
|
||||
return SELF_TEST_SPI_FAILURE_STRING;
|
||||
case (11703):
|
||||
return SELF_TEST_ADC_FAILURE_STRING;
|
||||
case (11704):
|
||||
return SELF_TEST_PWM_FAILURE_STRING;
|
||||
case (11705):
|
||||
return SELF_TEST_TC_FAILURE_STRING;
|
||||
case (11706):
|
||||
return SELF_TEST_MTM_RANGE_FAILURE_STRING;
|
||||
case (11707):
|
||||
return SELF_TEST_COIL_CURRENT_FAILURE_STRING;
|
||||
case (11708):
|
||||
return INVALID_ERROR_BYTE_STRING;
|
||||
case (11801):
|
||||
return ERROR_STATE_STRING;
|
||||
case (11802):
|
||||
return RESET_OCCURED_STRING;
|
||||
case (11901):
|
||||
return BOOTING_FIRMWARE_FAILED_STRING;
|
||||
case (11902):
|
||||
return BOOTING_BOOTLOADER_FAILED_STRING;
|
||||
case (12001):
|
||||
return SUPV_MEMORY_READ_RPT_CRC_FAILURE_STRING;
|
||||
case (12002):
|
||||
return SUPV_UNKNOWN_TM_STRING;
|
||||
case (12003):
|
||||
return SUPV_UNINIMPLEMENTED_TM_STRING;
|
||||
case (12004):
|
||||
return SUPV_ACK_FAILURE_STRING;
|
||||
case (12005):
|
||||
return SUPV_EXE_FAILURE_STRING;
|
||||
case (12006):
|
||||
return SUPV_CRC_FAILURE_EVENT_STRING;
|
||||
case (12007):
|
||||
return SUPV_HELPER_EXECUTING_STRING;
|
||||
case (12008):
|
||||
return SUPV_MPSOC_SHUWDOWN_BUILD_FAILED_STRING;
|
||||
case (12100):
|
||||
return SANITIZATION_FAILED_STRING;
|
||||
case (12101):
|
||||
return MOUNTED_SD_CARD_STRING;
|
||||
case (12300):
|
||||
return SEND_MRAM_DUMP_FAILED_STRING;
|
||||
case (12301):
|
||||
return MRAM_DUMP_FAILED_STRING;
|
||||
case (12302):
|
||||
return MRAM_DUMP_FINISHED_STRING;
|
||||
case (12401):
|
||||
return INVALID_TC_FRAME_STRING;
|
||||
case (12402):
|
||||
return INVALID_FAR_STRING;
|
||||
case (12403):
|
||||
return CARRIER_LOCK_STRING;
|
||||
case (12404):
|
||||
return BIT_LOCK_PDEC_STRING;
|
||||
case (12405):
|
||||
return LOST_CARRIER_LOCK_PDEC_STRING;
|
||||
case (12406):
|
||||
return LOST_BIT_LOCK_PDEC_STRING;
|
||||
case (12407):
|
||||
return POLL_ERROR_PDEC_STRING;
|
||||
case (12500):
|
||||
return IMAGE_UPLOAD_FAILED_STRING;
|
||||
case (12501):
|
||||
return IMAGE_DOWNLOAD_FAILED_STRING;
|
||||
case (12502):
|
||||
return IMAGE_UPLOAD_SUCCESSFUL_STRING;
|
||||
case (12503):
|
||||
return IMAGE_DOWNLOAD_SUCCESSFUL_STRING;
|
||||
case (12504):
|
||||
return FLASH_WRITE_SUCCESSFUL_STRING;
|
||||
case (12505):
|
||||
return FLASH_READ_SUCCESSFUL_STRING;
|
||||
case (12506):
|
||||
return FLASH_READ_FAILED_STRING;
|
||||
case (12507):
|
||||
return FIRMWARE_UPDATE_SUCCESSFUL_STRING;
|
||||
case (12508):
|
||||
return FIRMWARE_UPDATE_FAILED_STRING;
|
||||
case (12509):
|
||||
return STR_HELPER_READING_REPLY_FAILED_STRING;
|
||||
case (12510):
|
||||
return STR_HELPER_COM_ERROR_STRING;
|
||||
case (12511):
|
||||
return STR_HELPER_NO_REPLY_STRING;
|
||||
case (12512):
|
||||
return STR_HELPER_DEC_ERROR_STRING;
|
||||
case (12513):
|
||||
return POSITION_MISMATCH_STRING;
|
||||
case (12514):
|
||||
return STR_HELPER_FILE_NOT_EXISTS_STRING;
|
||||
case (12515):
|
||||
return STR_HELPER_SENDING_PACKET_FAILED_STRING;
|
||||
case (12516):
|
||||
return STR_HELPER_REQUESTING_MSG_FAILED_STRING;
|
||||
case (12600):
|
||||
return MPSOC_FLASH_WRITE_FAILED_STRING;
|
||||
case (12601):
|
||||
return MPSOC_FLASH_WRITE_SUCCESSFUL_STRING;
|
||||
case (12602):
|
||||
return MPSOC_SENDING_COMMAND_FAILED_STRING;
|
||||
case (12603):
|
||||
return MPSOC_HELPER_REQUESTING_REPLY_FAILED_STRING;
|
||||
case (12604):
|
||||
return MPSOC_HELPER_READING_REPLY_FAILED_STRING;
|
||||
case (12605):
|
||||
return MPSOC_MISSING_ACK_STRING;
|
||||
case (12606):
|
||||
return MPSOC_MISSING_EXE_STRING;
|
||||
case (12607):
|
||||
return MPSOC_ACK_FAILURE_REPORT_STRING;
|
||||
case (12608):
|
||||
return MPSOC_EXE_FAILURE_REPORT_STRING;
|
||||
case (12609):
|
||||
return MPSOC_ACK_INVALID_APID_STRING;
|
||||
case (12610):
|
||||
return MPSOC_EXE_INVALID_APID_STRING;
|
||||
case (12611):
|
||||
return MPSOC_HELPER_SEQ_CNT_MISMATCH_STRING;
|
||||
case (12612):
|
||||
return MPSOC_TM_SIZE_ERROR_STRING;
|
||||
case (12613):
|
||||
return MPSOC_TM_CRC_MISSMATCH_STRING;
|
||||
case (12700):
|
||||
return TRANSITION_BACK_TO_OFF_STRING;
|
||||
case (12701):
|
||||
return NEG_V_OUT_OF_BOUNDS_STRING;
|
||||
case (12702):
|
||||
return U_DRO_OUT_OF_BOUNDS_STRING;
|
||||
case (12703):
|
||||
return I_DRO_OUT_OF_BOUNDS_STRING;
|
||||
case (12704):
|
||||
return U_X8_OUT_OF_BOUNDS_STRING;
|
||||
case (12705):
|
||||
return I_X8_OUT_OF_BOUNDS_STRING;
|
||||
case (12706):
|
||||
return U_TX_OUT_OF_BOUNDS_STRING;
|
||||
case (12707):
|
||||
return I_TX_OUT_OF_BOUNDS_STRING;
|
||||
case (12708):
|
||||
return U_MPA_OUT_OF_BOUNDS_STRING;
|
||||
case (12709):
|
||||
return I_MPA_OUT_OF_BOUNDS_STRING;
|
||||
case (12710):
|
||||
return U_HPA_OUT_OF_BOUNDS_STRING;
|
||||
case (12711):
|
||||
return I_HPA_OUT_OF_BOUNDS_STRING;
|
||||
case (12800):
|
||||
return TRANSITION_OTHER_SIDE_FAILED_STRING;
|
||||
case (12801):
|
||||
return NOT_ENOUGH_DEVICES_DUAL_MODE_STRING;
|
||||
case (12802):
|
||||
return POWER_STATE_MACHINE_TIMEOUT_STRING;
|
||||
case (12803):
|
||||
return SIDE_SWITCH_TRANSITION_NOT_ALLOWED_STRING;
|
||||
case (13000):
|
||||
return CHILDREN_LOST_MODE_STRING;
|
||||
case (13100):
|
||||
return GPS_FIX_CHANGE_STRING;
|
||||
case (13200):
|
||||
return P60_BOOT_COUNT_STRING;
|
||||
case (13201):
|
||||
return BATT_MODE_STRING;
|
||||
case (13202):
|
||||
return BATT_MODE_CHANGED_STRING;
|
||||
case (13600):
|
||||
return SUPV_UPDATE_FAILED_STRING;
|
||||
case (13601):
|
||||
return SUPV_UPDATE_SUCCESSFUL_STRING;
|
||||
case (13602):
|
||||
return SUPV_CONTINUE_UPDATE_FAILED_STRING;
|
||||
case (13603):
|
||||
return SUPV_CONTINUE_UPDATE_SUCCESSFUL_STRING;
|
||||
case (13604):
|
||||
return TERMINATED_UPDATE_PROCEDURE_STRING;
|
||||
case (13605):
|
||||
return SUPV_EVENT_BUFFER_REQUEST_SUCCESSFUL_STRING;
|
||||
case (13606):
|
||||
return SUPV_EVENT_BUFFER_REQUEST_FAILED_STRING;
|
||||
case (13607):
|
||||
return SUPV_EVENT_BUFFER_REQUEST_TERMINATED_STRING;
|
||||
case (13608):
|
||||
return SUPV_MEM_CHECK_OK_STRING;
|
||||
case (13609):
|
||||
return SUPV_MEM_CHECK_FAIL_STRING;
|
||||
case (13616):
|
||||
return SUPV_SENDING_COMMAND_FAILED_STRING;
|
||||
case (13617):
|
||||
return SUPV_HELPER_REQUESTING_REPLY_FAILED_STRING;
|
||||
case (13618):
|
||||
return SUPV_HELPER_READING_REPLY_FAILED_STRING;
|
||||
case (13619):
|
||||
return SUPV_MISSING_ACK_STRING;
|
||||
case (13620):
|
||||
return SUPV_MISSING_EXE_STRING;
|
||||
case (13621):
|
||||
return SUPV_ACK_FAILURE_REPORT_STRING;
|
||||
case (13622):
|
||||
return SUPV_EXE_FAILURE_REPORT_STRING;
|
||||
case (13623):
|
||||
return SUPV_ACK_INVALID_APID_STRING;
|
||||
case (13624):
|
||||
return SUPV_EXE_INVALID_APID_STRING;
|
||||
case (13625):
|
||||
return ACK_RECEPTION_FAILURE_STRING;
|
||||
case (13626):
|
||||
return EXE_RECEPTION_FAILURE_STRING;
|
||||
case (13627):
|
||||
return WRITE_MEMORY_FAILED_STRING;
|
||||
case (13628):
|
||||
return SUPV_REPLY_SIZE_MISSMATCH_STRING;
|
||||
case (13629):
|
||||
return SUPV_REPLY_CRC_MISSMATCH_STRING;
|
||||
case (13630):
|
||||
return SUPV_UPDATE_PROGRESS_STRING;
|
||||
case (13631):
|
||||
return HDLC_FRAME_REMOVAL_ERROR_STRING;
|
||||
case (13632):
|
||||
return HDLC_CRC_ERROR_STRING;
|
||||
case (13700):
|
||||
return ALLOC_FAILURE_STRING;
|
||||
case (13701):
|
||||
return REBOOT_SW_STRING;
|
||||
case (13702):
|
||||
return REBOOT_MECHANISM_TRIGGERED_STRING;
|
||||
case (13703):
|
||||
return REBOOT_HW_STRING;
|
||||
case (13704):
|
||||
return NO_SD_CARD_ACTIVE_STRING;
|
||||
case (13800):
|
||||
return MISSING_PACKET_STRING;
|
||||
case (13801):
|
||||
return EXPERIMENT_TIMEDOUT_STRING;
|
||||
case (13802):
|
||||
return MULTI_PACKET_COMMAND_DONE_STRING;
|
||||
case (13901):
|
||||
return SET_CONFIGFILEVALUE_FAILED_STRING;
|
||||
case (13902):
|
||||
return GET_CONFIGFILEVALUE_FAILED_STRING;
|
||||
case (13903):
|
||||
return INSERT_CONFIGFILEVALUE_FAILED_STRING;
|
||||
case (13904):
|
||||
return WRITE_CONFIGFILE_FAILED_STRING;
|
||||
case (13905):
|
||||
return READ_CONFIGFILE_FAILED_STRING;
|
||||
default:
|
||||
return "UNKNOWN_EVENT";
|
||||
}
|
||||
|
||||
@ -1,8 +1,8 @@
|
||||
#ifndef FSFWCONFIG_EVENTS_TRANSLATEEVENTS_H_
|
||||
#define FSFWCONFIG_EVENTS_TRANSLATEEVENTS_H_
|
||||
|
||||
#include <fsfw/events/Event.h>
|
||||
#include "fsfw/events/Event.h"
|
||||
|
||||
const char* translateEvents(Event event);
|
||||
const char *translateEvents(Event event);
|
||||
|
||||
#endif /* FSFWCONFIG_EVENTS_TRANSLATEEVENTS_H_ */
|
||||
|
||||
@ -1,23 +1,105 @@
|
||||
/**
|
||||
* @brief Auto-generated object translation file.
|
||||
* @brief Auto-generated object translation file.
|
||||
* @details
|
||||
* Contains 31 translations.
|
||||
* Generated on: 2021-05-17 19:12:49
|
||||
* Contains 148 translations.
|
||||
* Generated on: 2022-11-15 17:44:20
|
||||
*/
|
||||
#include "translateObjects.h"
|
||||
|
||||
#include "systemObjectList.h"
|
||||
|
||||
const char *TEST_TASK_STRING = "TEST_TASK";
|
||||
const char *DUMMY_HANDLER_STRING = "DUMMY_HANDLER";
|
||||
const char *P60DOCK_TEST_TASK_STRING = "P60DOCK_TEST_TASK";
|
||||
const char *ACS_CONTROLLER_STRING = "ACS_CONTROLLER";
|
||||
const char *CORE_CONTROLLER_STRING = "CORE_CONTROLLER";
|
||||
const char *GLOBAL_JSON_CFG_STRING = "GLOBAL_JSON_CFG";
|
||||
const char *THERMAL_CONTROLLER_STRING = "THERMAL_CONTROLLER";
|
||||
const char *MGM_0_LIS3_HANDLER_STRING = "MGM_0_LIS3_HANDLER";
|
||||
const char *GYRO_0_ADIS_HANDLER_STRING = "GYRO_0_ADIS_HANDLER";
|
||||
const char *SUS_0_N_LOC_XFYFZM_PT_XF_STRING = "SUS_0_N_LOC_XFYFZM_PT_XF";
|
||||
const char *SUS_1_N_LOC_XBYFZM_PT_XB_STRING = "SUS_1_N_LOC_XBYFZM_PT_XB";
|
||||
const char *SUS_2_N_LOC_XFYBZB_PT_YB_STRING = "SUS_2_N_LOC_XFYBZB_PT_YB";
|
||||
const char *SUS_3_N_LOC_XFYBZF_PT_YF_STRING = "SUS_3_N_LOC_XFYBZF_PT_YF";
|
||||
const char *SUS_4_N_LOC_XMYFZF_PT_ZF_STRING = "SUS_4_N_LOC_XMYFZF_PT_ZF";
|
||||
const char *SUS_5_N_LOC_XFYMZB_PT_ZB_STRING = "SUS_5_N_LOC_XFYMZB_PT_ZB";
|
||||
const char *SUS_6_R_LOC_XFYBZM_PT_XF_STRING = "SUS_6_R_LOC_XFYBZM_PT_XF";
|
||||
const char *SUS_7_R_LOC_XBYBZM_PT_XB_STRING = "SUS_7_R_LOC_XBYBZM_PT_XB";
|
||||
const char *SUS_8_R_LOC_XBYBZB_PT_YB_STRING = "SUS_8_R_LOC_XBYBZB_PT_YB";
|
||||
const char *SUS_9_R_LOC_XBYBZB_PT_YF_STRING = "SUS_9_R_LOC_XBYBZB_PT_YF";
|
||||
const char *SUS_10_N_LOC_XMYBZF_PT_ZF_STRING = "SUS_10_N_LOC_XMYBZF_PT_ZF";
|
||||
const char *SUS_11_R_LOC_XBYMZB_PT_ZB_STRING = "SUS_11_R_LOC_XBYMZB_PT_ZB";
|
||||
const char *RW1_STRING = "RW1";
|
||||
const char *MGM_1_RM3100_HANDLER_STRING = "MGM_1_RM3100_HANDLER";
|
||||
const char *GYRO_1_L3G_HANDLER_STRING = "GYRO_1_L3G_HANDLER";
|
||||
const char *RW2_STRING = "RW2";
|
||||
const char *MGM_2_LIS3_HANDLER_STRING = "MGM_2_LIS3_HANDLER";
|
||||
const char *GYRO_2_ADIS_HANDLER_STRING = "GYRO_2_ADIS_HANDLER";
|
||||
const char *RW3_STRING = "RW3";
|
||||
const char *MGM_3_RM3100_HANDLER_STRING = "MGM_3_RM3100_HANDLER";
|
||||
const char *GYRO_3_L3G_HANDLER_STRING = "GYRO_3_L3G_HANDLER";
|
||||
const char *RW4_STRING = "RW4";
|
||||
const char *STAR_TRACKER_STRING = "STAR_TRACKER";
|
||||
const char *GPS_CONTROLLER_STRING = "GPS_CONTROLLER";
|
||||
const char *IMTQ_HANDLER_STRING = "IMTQ_HANDLER";
|
||||
const char *PCDU_HANDLER_STRING = "PCDU_HANDLER";
|
||||
const char *P60DOCK_HANDLER_STRING = "P60DOCK_HANDLER";
|
||||
const char *PDU1_HANDLER_STRING = "PDU1_HANDLER";
|
||||
const char *PDU2_HANDLER_STRING = "PDU2_HANDLER";
|
||||
const char *ACU_HANDLER_STRING = "ACU_HANDLER";
|
||||
const char *BPX_BATT_HANDLER_STRING = "BPX_BATT_HANDLER";
|
||||
const char *PLPCDU_HANDLER_STRING = "PLPCDU_HANDLER";
|
||||
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 *AXI_PTME_CONFIG_STRING = "AXI_PTME_CONFIG";
|
||||
const char *PTME_CONFIG_STRING = "PTME_CONFIG";
|
||||
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 *SCEX_STRING = "SCEX";
|
||||
const char *SOLAR_ARRAY_DEPL_HANDLER_STRING = "SOLAR_ARRAY_DEPL_HANDLER";
|
||||
const char *HEATER_HANDLER_STRING = "HEATER_HANDLER";
|
||||
const char *TMP1075_HANDLER_TCS_0_STRING = "TMP1075_HANDLER_TCS_0";
|
||||
const char *TMP1075_HANDLER_TCS_1_STRING = "TMP1075_HANDLER_TCS_1";
|
||||
const char *TMP1075_HANDLER_PLPCDU_0_STRING = "TMP1075_HANDLER_PLPCDU_0";
|
||||
const char *TMP1075_HANDLER_PLPCDU_1_STRING = "TMP1075_HANDLER_PLPCDU_1";
|
||||
const char *TMP1075_HANDLER_IF_BOARD_STRING = "TMP1075_HANDLER_IF_BOARD";
|
||||
const char *TMP1075_HANDLER_OBC_IF_BOARD_STRING = "TMP1075_HANDLER_OBC_IF_BOARD";
|
||||
const char *RTD_0_IC3_PLOC_HEATSPREADER_STRING = "RTD_0_IC3_PLOC_HEATSPREADER";
|
||||
const char *RTD_1_IC4_PLOC_MISSIONBOARD_STRING = "RTD_1_IC4_PLOC_MISSIONBOARD";
|
||||
const char *RTD_2_IC5_4K_CAMERA_STRING = "RTD_2_IC5_4K_CAMERA";
|
||||
const char *RTD_3_IC6_DAC_HEATSPREADER_STRING = "RTD_3_IC6_DAC_HEATSPREADER";
|
||||
const char *RTD_4_IC7_STARTRACKER_STRING = "RTD_4_IC7_STARTRACKER";
|
||||
const char *RTD_5_IC8_RW1_MX_MY_STRING = "RTD_5_IC8_RW1_MX_MY";
|
||||
const char *RTD_6_IC9_DRO_STRING = "RTD_6_IC9_DRO";
|
||||
const char *RTD_7_IC10_SCEX_STRING = "RTD_7_IC10_SCEX";
|
||||
const char *RTD_8_IC11_X8_STRING = "RTD_8_IC11_X8";
|
||||
const char *RTD_9_IC12_HPA_STRING = "RTD_9_IC12_HPA";
|
||||
const char *RTD_10_IC13_PL_TX_STRING = "RTD_10_IC13_PL_TX";
|
||||
const char *RTD_11_IC14_MPA_STRING = "RTD_11_IC14_MPA";
|
||||
const char *RTD_12_IC15_ACU_STRING = "RTD_12_IC15_ACU";
|
||||
const char *RTD_13_IC16_PLPCDU_HEATSPREADER_STRING = "RTD_13_IC16_PLPCDU_HEATSPREADER";
|
||||
const char *RTD_14_IC17_TCS_BOARD_STRING = "RTD_14_IC17_TCS_BOARD";
|
||||
const char *RTD_15_IC18_IMTQ_STRING = "RTD_15_IC18_IMTQ";
|
||||
const char *SYRLINKS_HK_HANDLER_STRING = "SYRLINKS_HK_HANDLER";
|
||||
const char *ARDUINO_COM_IF_STRING = "ARDUINO_COM_IF";
|
||||
const char *PUS_SERVICE_3_STRING = "PUS_SERVICE_3";
|
||||
const char *PUS_SERVICE_5_STRING = "PUS_SERVICE_5";
|
||||
const char *GPIO_IF_STRING = "GPIO_IF";
|
||||
const char *SCEX_UART_READER_STRING = "SCEX_UART_READER";
|
||||
const char *SPI_MAIN_COM_IF_STRING = "SPI_MAIN_COM_IF";
|
||||
const char *SPI_RW_COM_IF_STRING = "SPI_RW_COM_IF";
|
||||
const char *SPI_RTD_COM_IF_STRING = "SPI_RTD_COM_IF";
|
||||
const char *UART_COM_IF_STRING = "UART_COM_IF";
|
||||
const char *I2C_COM_IF_STRING = "I2C_COM_IF";
|
||||
const char *CSP_COM_IF_STRING = "CSP_COM_IF";
|
||||
const char *CCSDS_PACKET_DISTRIBUTOR_STRING = "CCSDS_PACKET_DISTRIBUTOR";
|
||||
const char *PUS_PACKET_DISTRIBUTOR_STRING = "PUS_PACKET_DISTRIBUTOR";
|
||||
const char *TMTC_BRIDGE_STRING = "TMTC_BRIDGE";
|
||||
const char *TMTC_POLLING_TASK_STRING = "TMTC_POLLING_TASK";
|
||||
const char *FILE_SYSTEM_HANDLER_STRING = "FILE_SYSTEM_HANDLER";
|
||||
const char *SDC_MANAGER_STRING = "SDC_MANAGER";
|
||||
const char *PTME_STRING = "PTME";
|
||||
const char *PDEC_HANDLER_STRING = "PDEC_HANDLER";
|
||||
const char *CCSDS_HANDLER_STRING = "CCSDS_HANDLER";
|
||||
const char *PUS_SERVICE_6_STRING = "PUS_SERVICE_6";
|
||||
const char *PUS_SERVICE_8_STRING = "PUS_SERVICE_8";
|
||||
const char *PUS_SERVICE_23_STRING = "PUS_SERVICE_23";
|
||||
const char *PUS_SERVICE_201_STRING = "PUS_SERVICE_201";
|
||||
const char *TM_FUNNEL_STRING = "TM_FUNNEL";
|
||||
const char *FSFW_OBJECTS_START_STRING = "FSFW_OBJECTS_START";
|
||||
const char *PUS_SERVICE_1_VERIFICATION_STRING = "PUS_SERVICE_1_VERIFICATION";
|
||||
const char *PUS_SERVICE_2_DEVICE_ACCESS_STRING = "PUS_SERVICE_2_DEVICE_ACCESS";
|
||||
@ -25,9 +107,12 @@ const char *PUS_SERVICE_3_HOUSEKEEPING_STRING = "PUS_SERVICE_3_HOUSEKEEPING";
|
||||
const char *PUS_SERVICE_5_EVENT_REPORTING_STRING = "PUS_SERVICE_5_EVENT_REPORTING";
|
||||
const char *PUS_SERVICE_8_FUNCTION_MGMT_STRING = "PUS_SERVICE_8_FUNCTION_MGMT";
|
||||
const char *PUS_SERVICE_9_TIME_MGMT_STRING = "PUS_SERVICE_9_TIME_MGMT";
|
||||
const char *PUS_SERVICE_11_TC_SCHEDULER_STRING = "PUS_SERVICE_11_TC_SCHEDULER";
|
||||
const char *PUS_SERVICE_17_TEST_STRING = "PUS_SERVICE_17_TEST";
|
||||
const char *PUS_SERVICE_20_PARAMETERS_STRING = "PUS_SERVICE_20_PARAMETERS";
|
||||
const char *PUS_SERVICE_200_MODE_MGMT_STRING = "PUS_SERVICE_200_MODE_MGMT";
|
||||
const char *PUS_SERVICE_201_HEALTH_STRING = "PUS_SERVICE_201_HEALTH";
|
||||
const char *CFDP_PACKET_DISTRIBUTOR_STRING = "CFDP_PACKET_DISTRIBUTOR";
|
||||
const char *HEALTH_TABLE_STRING = "HEALTH_TABLE";
|
||||
const char *MODE_STORE_STRING = "MODE_STORE";
|
||||
const char *EVENT_MANAGER_STRING = "EVENT_MANAGER";
|
||||
@ -36,33 +121,230 @@ const char *TC_STORE_STRING = "TC_STORE";
|
||||
const char *TM_STORE_STRING = "TM_STORE";
|
||||
const char *IPC_STORE_STRING = "IPC_STORE";
|
||||
const char *TIME_STAMPER_STRING = "TIME_STAMPER";
|
||||
const char *VERIFICATION_REPORTER_STRING = "VERIFICATION_REPORTER";
|
||||
const char *FSFW_OBJECTS_END_STRING = "FSFW_OBJECTS_END";
|
||||
const char *SPI_TEST_STRING = "SPI_TEST";
|
||||
const char *UART_TEST_STRING = "UART_TEST";
|
||||
const char *I2C_TEST_STRING = "I2C_TEST";
|
||||
const char *DUMMY_COM_IF_STRING = "DUMMY_COM_IF";
|
||||
const char *DUMMY_HANDLER_STRING = "DUMMY_HANDLER";
|
||||
const char *DUMMY_INTERFACE_STRING = "DUMMY_INTERFACE";
|
||||
const char *THERMAL_CONTROLLER_STRING = "THERMAL_CONTROLLER";
|
||||
const char *LIBGPIOD_TEST_STRING = "LIBGPIOD_TEST";
|
||||
const char *TEST_TASK_STRING = "TEST_TASK";
|
||||
const char *HEATER_0_PLOC_PROC_BRD_STRING = "HEATER_0_PLOC_PROC_BRD";
|
||||
const char *HEATER_1_PCDU_BRD_STRING = "HEATER_1_PCDU_BRD";
|
||||
const char *HEATER_2_ACS_BRD_STRING = "HEATER_2_ACS_BRD";
|
||||
const char *HEATER_3_OBC_BRD_STRING = "HEATER_3_OBC_BRD";
|
||||
const char *HEATER_4_CAMERA_STRING = "HEATER_4_CAMERA";
|
||||
const char *HEATER_5_STR_STRING = "HEATER_5_STR";
|
||||
const char *HEATER_6_DRO_STRING = "HEATER_6_DRO";
|
||||
const char *HEATER_7_HPA_STRING = "HEATER_7_HPA";
|
||||
const char *ACS_BOARD_ASS_STRING = "ACS_BOARD_ASS";
|
||||
const char *SUS_BOARD_ASS_STRING = "SUS_BOARD_ASS";
|
||||
const char *TCS_BOARD_ASS_STRING = "TCS_BOARD_ASS";
|
||||
const char *RW_ASS_STRING = "RW_ASS";
|
||||
const char *CAM_SWITCHER_STRING = "CAM_SWITCHER";
|
||||
const char *TM_FUNNEL_STRING = "TM_FUNNEL";
|
||||
const char *PUS_TM_FUNNEL_STRING = "PUS_TM_FUNNEL";
|
||||
const char *CFDP_TM_FUNNEL_STRING = "CFDP_TM_FUNNEL";
|
||||
const char *CFDP_HANDLER_STRING = "CFDP_HANDLER";
|
||||
const char *CFDP_DISTRIBUTOR_STRING = "CFDP_DISTRIBUTOR";
|
||||
const char *EIVE_SYSTEM_STRING = "EIVE_SYSTEM";
|
||||
const char *ACS_SUBSYSTEM_STRING = "ACS_SUBSYSTEM";
|
||||
const char *PL_SUBSYSTEM_STRING = "PL_SUBSYSTEM";
|
||||
const char *CCSDS_IP_CORE_BRIDGE_STRING = "CCSDS_IP_CORE_BRIDGE";
|
||||
const char *NO_OBJECT_STRING = "NO_OBJECT";
|
||||
|
||||
const char *translateObject(object_id_t object) {
|
||||
switch ((object & 0xFFFFFFFF)) {
|
||||
case 0x42694269:
|
||||
return TEST_TASK_STRING;
|
||||
case 0x4400AFFE:
|
||||
return DUMMY_HANDLER_STRING;
|
||||
case 0x49000001:
|
||||
case 0x00005060:
|
||||
return P60DOCK_TEST_TASK_STRING;
|
||||
case 0x43000002:
|
||||
return ACS_CONTROLLER_STRING;
|
||||
case 0x43000003:
|
||||
return CORE_CONTROLLER_STRING;
|
||||
case 0x43000006:
|
||||
return GLOBAL_JSON_CFG_STRING;
|
||||
case 0x43400001:
|
||||
return THERMAL_CONTROLLER_STRING;
|
||||
case 0x44120006:
|
||||
return MGM_0_LIS3_HANDLER_STRING;
|
||||
case 0x44120010:
|
||||
return GYRO_0_ADIS_HANDLER_STRING;
|
||||
case 0x44120032:
|
||||
return SUS_0_N_LOC_XFYFZM_PT_XF_STRING;
|
||||
case 0x44120033:
|
||||
return SUS_1_N_LOC_XBYFZM_PT_XB_STRING;
|
||||
case 0x44120034:
|
||||
return SUS_2_N_LOC_XFYBZB_PT_YB_STRING;
|
||||
case 0x44120035:
|
||||
return SUS_3_N_LOC_XFYBZF_PT_YF_STRING;
|
||||
case 0x44120036:
|
||||
return SUS_4_N_LOC_XMYFZF_PT_ZF_STRING;
|
||||
case 0x44120037:
|
||||
return SUS_5_N_LOC_XFYMZB_PT_ZB_STRING;
|
||||
case 0x44120038:
|
||||
return SUS_6_R_LOC_XFYBZM_PT_XF_STRING;
|
||||
case 0x44120039:
|
||||
return SUS_7_R_LOC_XBYBZM_PT_XB_STRING;
|
||||
case 0x44120040:
|
||||
return SUS_8_R_LOC_XBYBZB_PT_YB_STRING;
|
||||
case 0x44120041:
|
||||
return SUS_9_R_LOC_XBYBZB_PT_YF_STRING;
|
||||
case 0x44120042:
|
||||
return SUS_10_N_LOC_XMYBZF_PT_ZF_STRING;
|
||||
case 0x44120043:
|
||||
return SUS_11_R_LOC_XBYMZB_PT_ZB_STRING;
|
||||
case 0x44120047:
|
||||
return RW1_STRING;
|
||||
case 0x44120107:
|
||||
return MGM_1_RM3100_HANDLER_STRING;
|
||||
case 0x44120111:
|
||||
return GYRO_1_L3G_HANDLER_STRING;
|
||||
case 0x44120148:
|
||||
return RW2_STRING;
|
||||
case 0x44120208:
|
||||
return MGM_2_LIS3_HANDLER_STRING;
|
||||
case 0x44120212:
|
||||
return GYRO_2_ADIS_HANDLER_STRING;
|
||||
case 0x44120249:
|
||||
return RW3_STRING;
|
||||
case 0x44120309:
|
||||
return MGM_3_RM3100_HANDLER_STRING;
|
||||
case 0x44120313:
|
||||
return GYRO_3_L3G_HANDLER_STRING;
|
||||
case 0x44120350:
|
||||
return RW4_STRING;
|
||||
case 0x44130001:
|
||||
return STAR_TRACKER_STRING;
|
||||
case 0x44130045:
|
||||
return GPS_CONTROLLER_STRING;
|
||||
case 0x44140014:
|
||||
return IMTQ_HANDLER_STRING;
|
||||
case 0x442000A1:
|
||||
return PCDU_HANDLER_STRING;
|
||||
case 0x44250000:
|
||||
return P60DOCK_HANDLER_STRING;
|
||||
case 0x44250001:
|
||||
return PDU1_HANDLER_STRING;
|
||||
case 0x44250002:
|
||||
return PDU2_HANDLER_STRING;
|
||||
case 0x44250003:
|
||||
return ACU_HANDLER_STRING;
|
||||
case 0x44260000:
|
||||
return BPX_BATT_HANDLER_STRING;
|
||||
case 0x44300000:
|
||||
return PLPCDU_HANDLER_STRING;
|
||||
case 0x443200A5:
|
||||
return RAD_SENSOR_STRING;
|
||||
case 0x44330000:
|
||||
return PLOC_UPDATER_STRING;
|
||||
case 0x44330001:
|
||||
return PLOC_MEMORY_DUMPER_STRING;
|
||||
case 0x44330002:
|
||||
return STR_HELPER_STRING;
|
||||
case 0x44330003:
|
||||
return PLOC_MPSOC_HELPER_STRING;
|
||||
case 0x44330004:
|
||||
return AXI_PTME_CONFIG_STRING;
|
||||
case 0x44330005:
|
||||
return PTME_CONFIG_STRING;
|
||||
case 0x44330015:
|
||||
return PLOC_MPSOC_HANDLER_STRING;
|
||||
case 0x44330016:
|
||||
return PLOC_SUPERVISOR_HANDLER_STRING;
|
||||
case 0x44330017:
|
||||
return PLOC_SUPERVISOR_HELPER_STRING;
|
||||
case 0x44330032:
|
||||
return SCEX_STRING;
|
||||
case 0x444100A2:
|
||||
return SOLAR_ARRAY_DEPL_HANDLER_STRING;
|
||||
case 0x444100A4:
|
||||
return HEATER_HANDLER_STRING;
|
||||
case 0x44420004:
|
||||
return TMP1075_HANDLER_TCS_0_STRING;
|
||||
case 0x44420005:
|
||||
return TMP1075_HANDLER_TCS_1_STRING;
|
||||
case 0x44420006:
|
||||
return TMP1075_HANDLER_PLPCDU_0_STRING;
|
||||
case 0x44420007:
|
||||
return TMP1075_HANDLER_PLPCDU_1_STRING;
|
||||
case 0x44420008:
|
||||
return TMP1075_HANDLER_IF_BOARD_STRING;
|
||||
case 0x44420009:
|
||||
return TMP1075_HANDLER_OBC_IF_BOARD_STRING;
|
||||
case 0x44420016:
|
||||
return RTD_0_IC3_PLOC_HEATSPREADER_STRING;
|
||||
case 0x44420017:
|
||||
return RTD_1_IC4_PLOC_MISSIONBOARD_STRING;
|
||||
case 0x44420018:
|
||||
return RTD_2_IC5_4K_CAMERA_STRING;
|
||||
case 0x44420019:
|
||||
return RTD_3_IC6_DAC_HEATSPREADER_STRING;
|
||||
case 0x44420020:
|
||||
return RTD_4_IC7_STARTRACKER_STRING;
|
||||
case 0x44420021:
|
||||
return RTD_5_IC8_RW1_MX_MY_STRING;
|
||||
case 0x44420022:
|
||||
return RTD_6_IC9_DRO_STRING;
|
||||
case 0x44420023:
|
||||
return RTD_7_IC10_SCEX_STRING;
|
||||
case 0x44420024:
|
||||
return RTD_8_IC11_X8_STRING;
|
||||
case 0x44420025:
|
||||
return RTD_9_IC12_HPA_STRING;
|
||||
case 0x44420026:
|
||||
return RTD_10_IC13_PL_TX_STRING;
|
||||
case 0x44420027:
|
||||
return RTD_11_IC14_MPA_STRING;
|
||||
case 0x44420028:
|
||||
return RTD_12_IC15_ACU_STRING;
|
||||
case 0x44420029:
|
||||
return RTD_13_IC16_PLPCDU_HEATSPREADER_STRING;
|
||||
case 0x44420030:
|
||||
return RTD_14_IC17_TCS_BOARD_STRING;
|
||||
case 0x44420031:
|
||||
return RTD_15_IC18_IMTQ_STRING;
|
||||
case 0x445300A3:
|
||||
return SYRLINKS_HK_HANDLER_STRING;
|
||||
case 0x49000000:
|
||||
return ARDUINO_COM_IF_STRING;
|
||||
case 0x51000300:
|
||||
return PUS_SERVICE_3_STRING;
|
||||
case 0x51000400:
|
||||
return PUS_SERVICE_5_STRING;
|
||||
case 0x49010005:
|
||||
return GPIO_IF_STRING;
|
||||
case 0x49010006:
|
||||
return SCEX_UART_READER_STRING;
|
||||
case 0x49020004:
|
||||
return SPI_MAIN_COM_IF_STRING;
|
||||
case 0x49020005:
|
||||
return SPI_RW_COM_IF_STRING;
|
||||
case 0x49020006:
|
||||
return SPI_RTD_COM_IF_STRING;
|
||||
case 0x49030003:
|
||||
return UART_COM_IF_STRING;
|
||||
case 0x49040002:
|
||||
return I2C_COM_IF_STRING;
|
||||
case 0x49050001:
|
||||
return CSP_COM_IF_STRING;
|
||||
case 0x50000100:
|
||||
return CCSDS_PACKET_DISTRIBUTOR_STRING;
|
||||
case 0x50000200:
|
||||
return PUS_PACKET_DISTRIBUTOR_STRING;
|
||||
case 0x50000300:
|
||||
return TMTC_BRIDGE_STRING;
|
||||
case 0x50000400:
|
||||
return TMTC_POLLING_TASK_STRING;
|
||||
case 0x50000500:
|
||||
return FILE_SYSTEM_HANDLER_STRING;
|
||||
case 0x50000550:
|
||||
return SDC_MANAGER_STRING;
|
||||
case 0x50000600:
|
||||
return PTME_STRING;
|
||||
case 0x50000700:
|
||||
return PDEC_HANDLER_STRING;
|
||||
case 0x50000800:
|
||||
return CCSDS_HANDLER_STRING;
|
||||
case 0x51000500:
|
||||
return PUS_SERVICE_6_STRING;
|
||||
case 0x51000800:
|
||||
return PUS_SERVICE_8_STRING;
|
||||
case 0x51002300:
|
||||
return PUS_SERVICE_23_STRING;
|
||||
case 0x51020100:
|
||||
return PUS_SERVICE_201_STRING;
|
||||
case 0x52000002:
|
||||
return TM_FUNNEL_STRING;
|
||||
case 0x53000000:
|
||||
return FSFW_OBJECTS_START_STRING;
|
||||
case 0x53000001:
|
||||
@ -77,12 +359,18 @@ const char *translateObject(object_id_t object) {
|
||||
return PUS_SERVICE_8_FUNCTION_MGMT_STRING;
|
||||
case 0x53000009:
|
||||
return PUS_SERVICE_9_TIME_MGMT_STRING;
|
||||
case 0x53000011:
|
||||
return PUS_SERVICE_11_TC_SCHEDULER_STRING;
|
||||
case 0x53000017:
|
||||
return PUS_SERVICE_17_TEST_STRING;
|
||||
case 0x53000020:
|
||||
return PUS_SERVICE_20_PARAMETERS_STRING;
|
||||
case 0x53000200:
|
||||
return PUS_SERVICE_200_MODE_MGMT_STRING;
|
||||
case 0x53000201:
|
||||
return PUS_SERVICE_201_HEALTH_STRING;
|
||||
case 0x53001000:
|
||||
return CFDP_PACKET_DISTRIBUTOR_STRING;
|
||||
case 0x53010000:
|
||||
return HEALTH_TABLE_STRING;
|
||||
case 0x53010100:
|
||||
@ -99,12 +387,70 @@ const char *translateObject(object_id_t object) {
|
||||
return IPC_STORE_STRING;
|
||||
case 0x53500010:
|
||||
return TIME_STAMPER_STRING;
|
||||
case 0x53500020:
|
||||
return VERIFICATION_REPORTER_STRING;
|
||||
case 0x53ffffff:
|
||||
return FSFW_OBJECTS_END_STRING;
|
||||
case 0xCAFECAFE:
|
||||
case 0x54000010:
|
||||
return SPI_TEST_STRING;
|
||||
case 0x54000020:
|
||||
return UART_TEST_STRING;
|
||||
case 0x54000030:
|
||||
return I2C_TEST_STRING;
|
||||
case 0x54000040:
|
||||
return DUMMY_COM_IF_STRING;
|
||||
case 0x5400AFFE:
|
||||
return DUMMY_HANDLER_STRING;
|
||||
case 0x5400CAFE:
|
||||
return DUMMY_INTERFACE_STRING;
|
||||
case objects::THERMAL_CONTROLLER:
|
||||
return THERMAL_CONTROLLER_STRING;
|
||||
case 0x54123456:
|
||||
return LIBGPIOD_TEST_STRING;
|
||||
case 0x54694269:
|
||||
return TEST_TASK_STRING;
|
||||
case 0x60000000:
|
||||
return HEATER_0_PLOC_PROC_BRD_STRING;
|
||||
case 0x60000001:
|
||||
return HEATER_1_PCDU_BRD_STRING;
|
||||
case 0x60000002:
|
||||
return HEATER_2_ACS_BRD_STRING;
|
||||
case 0x60000003:
|
||||
return HEATER_3_OBC_BRD_STRING;
|
||||
case 0x60000004:
|
||||
return HEATER_4_CAMERA_STRING;
|
||||
case 0x60000005:
|
||||
return HEATER_5_STR_STRING;
|
||||
case 0x60000006:
|
||||
return HEATER_6_DRO_STRING;
|
||||
case 0x60000007:
|
||||
return HEATER_7_HPA_STRING;
|
||||
case 0x73000001:
|
||||
return ACS_BOARD_ASS_STRING;
|
||||
case 0x73000002:
|
||||
return SUS_BOARD_ASS_STRING;
|
||||
case 0x73000003:
|
||||
return TCS_BOARD_ASS_STRING;
|
||||
case 0x73000004:
|
||||
return RW_ASS_STRING;
|
||||
case 0x73000006:
|
||||
return CAM_SWITCHER_STRING;
|
||||
case 0x73000100:
|
||||
return TM_FUNNEL_STRING;
|
||||
case 0x73000101:
|
||||
return PUS_TM_FUNNEL_STRING;
|
||||
case 0x73000102:
|
||||
return CFDP_TM_FUNNEL_STRING;
|
||||
case 0x73000205:
|
||||
return CFDP_HANDLER_STRING;
|
||||
case 0x73000206:
|
||||
return CFDP_DISTRIBUTOR_STRING;
|
||||
case 0x73010000:
|
||||
return EIVE_SYSTEM_STRING;
|
||||
case 0x73010001:
|
||||
return ACS_SUBSYSTEM_STRING;
|
||||
case 0x73010002:
|
||||
return PL_SUBSYSTEM_STRING;
|
||||
case 0x73500000:
|
||||
return CCSDS_IP_CORE_BRIDGE_STRING;
|
||||
case 0xFFFFFFFF:
|
||||
return NO_OBJECT_STRING;
|
||||
default:
|
||||
|
||||
@ -3,6 +3,6 @@
|
||||
|
||||
#include <fsfw/objectmanager/SystemObjectIF.h>
|
||||
|
||||
const char* translateObject(object_id_t object);
|
||||
const char *translateObject(object_id_t object);
|
||||
|
||||
#endif /* FSFWCONFIG_OBJECTS_TRANSLATEOBJECTS_H_ */
|
||||
|
||||
@ -2,7 +2,6 @@
|
||||
|
||||
#include <iostream>
|
||||
|
||||
#include "InitMission.h"
|
||||
#include "commonConfig.h"
|
||||
#include "fsfw/FSFWVersion.h"
|
||||
#include "fsfw/controller/ControllerBase.h"
|
||||
@ -11,6 +10,7 @@
|
||||
#include "fsfw/modes/ModeMessage.h"
|
||||
#include "fsfw/objectmanager/ObjectManager.h"
|
||||
#include "fsfw/tasks/TaskFactory.h"
|
||||
#include "scheduling.h"
|
||||
|
||||
#ifdef WIN32
|
||||
static const char* COMPILE_PRINTOUT = "Windows";
|
||||
@ -35,7 +35,7 @@ int main(void) {
|
||||
<< " BSP HOSTED"
|
||||
<< " --" << std::endl;
|
||||
|
||||
initmission::initMission();
|
||||
scheduling::initMission();
|
||||
|
||||
for (;;) {
|
||||
// suspend main thread by sleeping it.
|
||||
|
||||
@ -1,6 +1,5 @@
|
||||
#include "InitMission.h"
|
||||
#include "linux/scheduling.h"
|
||||
|
||||
#include <OBSWConfig.h>
|
||||
#include <bsp_hosted/fsfwconfig/pollingsequence/DummyPst.h>
|
||||
#include <fsfw/objectmanager/ObjectManager.h>
|
||||
#include <fsfw/objectmanager/ObjectManagerIF.h>
|
||||
@ -13,7 +12,9 @@
|
||||
|
||||
#include <iostream>
|
||||
|
||||
#include "OBSWConfig.h"
|
||||
#include "ObjectFactory.h"
|
||||
#include "scheduling.h"
|
||||
|
||||
#ifdef LINUX
|
||||
ServiceInterfaceStream sif::debug("DEBUG");
|
||||
@ -29,7 +30,7 @@ ServiceInterfaceStream sif::error("ERROR", true, false, true);
|
||||
|
||||
ObjectManagerIF* objectManager = nullptr;
|
||||
|
||||
void initmission::initMission() {
|
||||
void scheduling::initMission() {
|
||||
sif::info << "Building global objects.." << std::endl;
|
||||
/* Instantiate global object manager and also create all objects */
|
||||
ObjectManager::instance()->setObjectFactoryFunction(ObjectFactory::produce, nullptr);
|
||||
@ -40,7 +41,7 @@ void initmission::initMission() {
|
||||
initTasks();
|
||||
}
|
||||
|
||||
void initmission::initTasks() {
|
||||
void scheduling::initTasks() {
|
||||
TaskFactory* factory = TaskFactory::instance();
|
||||
if (factory == nullptr) {
|
||||
/* Should never happen ! */
|
||||
@ -53,28 +54,25 @@ void initmission::initTasks() {
|
||||
#endif
|
||||
|
||||
/* TMTC Distribution */
|
||||
PeriodicTaskIF* tmTcDistributor = factory->createPeriodicTask(
|
||||
"DIST", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
|
||||
ReturnValue_t result = tmTcDistributor->addComponent(objects::CCSDS_PACKET_DISTRIBUTOR);
|
||||
PeriodicTaskIF* tmtcDistributor = factory->createPeriodicTask(
|
||||
"DIST", 45, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
|
||||
ReturnValue_t result = tmtcDistributor->addComponent(objects::CCSDS_PACKET_DISTRIBUTOR);
|
||||
if (result != returnvalue::OK) {
|
||||
sif::error << "Object add component failed" << std::endl;
|
||||
}
|
||||
result = tmTcDistributor->addComponent(objects::PUS_PACKET_DISTRIBUTOR);
|
||||
result = tmtcDistributor->addComponent(objects::PUS_PACKET_DISTRIBUTOR);
|
||||
if (result != returnvalue::OK) {
|
||||
sif::error << "Object add component failed" << std::endl;
|
||||
}
|
||||
result = tmTcDistributor->addComponent(objects::TM_FUNNEL);
|
||||
result = tmtcDistributor->addComponent(objects::TM_FUNNEL);
|
||||
if (result != returnvalue::OK) {
|
||||
sif::error << "Object add component failed" << std::endl;
|
||||
}
|
||||
|
||||
/* UDP bridge */
|
||||
PeriodicTaskIF* tmtcBridgeTask = factory->createPeriodicTask(
|
||||
"TMTC_UNIX_BRIDGE", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
|
||||
result = tmtcBridgeTask->addComponent(objects::TMTC_BRIDGE);
|
||||
result = tmtcDistributor->addComponent(objects::TMTC_BRIDGE);
|
||||
if (result != returnvalue::OK) {
|
||||
sif::error << "Add component UDP Unix Bridge failed" << std::endl;
|
||||
}
|
||||
|
||||
PeriodicTaskIF* tmtcPollingTask = factory->createPeriodicTask(
|
||||
"UDP_POLLING", 80, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
|
||||
result = tmtcPollingTask->addComponent(objects::TMTC_POLLING_TASK);
|
||||
@ -94,69 +92,69 @@ void initmission::initTasks() {
|
||||
"EVENTS", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
|
||||
result = eventHandling->addComponent(objects::EVENT_MANAGER);
|
||||
if (result != returnvalue::OK) {
|
||||
initmission::printAddObjectError("EVENT_MNGR", objects::EVENT_MANAGER);
|
||||
scheduling::printAddObjectError("EVENT_MNGR", objects::EVENT_MANAGER);
|
||||
}
|
||||
result = eventHandling->addComponent(objects::PUS_SERVICE_5_EVENT_REPORTING);
|
||||
if (result != returnvalue::OK) {
|
||||
initmission::printAddObjectError("PUS5", objects::PUS_SERVICE_5_EVENT_REPORTING);
|
||||
scheduling::printAddObjectError("PUS5", objects::PUS_SERVICE_5_EVENT_REPORTING);
|
||||
}
|
||||
|
||||
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 != returnvalue::OK) {
|
||||
initmission::printAddObjectError("PUS2", objects::PUS_SERVICE_2_DEVICE_ACCESS);
|
||||
scheduling::printAddObjectError("PUS2", objects::PUS_SERVICE_2_DEVICE_ACCESS);
|
||||
}
|
||||
result = pusHighPrio->addComponent(objects::PUS_SERVICE_9_TIME_MGMT);
|
||||
if (result != returnvalue::OK) {
|
||||
initmission::printAddObjectError("PUS9", objects::PUS_SERVICE_9_TIME_MGMT);
|
||||
scheduling::printAddObjectError("PUS9", objects::PUS_SERVICE_9_TIME_MGMT);
|
||||
}
|
||||
result = pusHighPrio->addComponent(objects::PUS_SERVICE_3_HOUSEKEEPING);
|
||||
if (result != returnvalue::OK) {
|
||||
initmission::printAddObjectError("PUS3", objects::PUS_SERVICE_3_HOUSEKEEPING);
|
||||
scheduling::printAddObjectError("PUS3", objects::PUS_SERVICE_3_HOUSEKEEPING);
|
||||
}
|
||||
|
||||
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 != returnvalue::OK) {
|
||||
initmission::printAddObjectError("PUS8", objects::PUS_SERVICE_8_FUNCTION_MGMT);
|
||||
scheduling::printAddObjectError("PUS8", objects::PUS_SERVICE_8_FUNCTION_MGMT);
|
||||
}
|
||||
result = pusMedPrio->addComponent(objects::PUS_SERVICE_200_MODE_MGMT);
|
||||
if (result != returnvalue::OK) {
|
||||
initmission::printAddObjectError("PUS200", objects::PUS_SERVICE_200_MODE_MGMT);
|
||||
scheduling::printAddObjectError("PUS200", objects::PUS_SERVICE_200_MODE_MGMT);
|
||||
}
|
||||
result = pusMedPrio->addComponent(objects::PUS_SERVICE_20_PARAMETERS);
|
||||
if (result != returnvalue::OK) {
|
||||
initmission::printAddObjectError("PUS20", objects::PUS_SERVICE_20_PARAMETERS);
|
||||
scheduling::printAddObjectError("PUS20", objects::PUS_SERVICE_20_PARAMETERS);
|
||||
}
|
||||
|
||||
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 != returnvalue::OK) {
|
||||
initmission::printAddObjectError("PUS17", objects::PUS_SERVICE_17_TEST);
|
||||
scheduling::printAddObjectError("PUS17", objects::PUS_SERVICE_17_TEST);
|
||||
}
|
||||
|
||||
PeriodicTaskIF* thermalTask = factory->createPeriodicTask(
|
||||
"THERMAL_CTL_TASK", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, missedDeadlineFunc);
|
||||
result = thermalTask->addComponent(objects::RTD_0_IC3_PLOC_HEATSPREADER);
|
||||
if (result != returnvalue::OK) {
|
||||
initmission::printAddObjectError("RTD_0_dummy", objects::RTD_0_IC3_PLOC_HEATSPREADER);
|
||||
scheduling::printAddObjectError("RTD_0_dummy", objects::RTD_0_IC3_PLOC_HEATSPREADER);
|
||||
}
|
||||
result = thermalTask->addComponent(objects::SUS_0_N_LOC_XFYFZM_PT_XF);
|
||||
if (result != returnvalue::OK) {
|
||||
initmission::printAddObjectError("SUS_0_dummy", objects::SUS_0_N_LOC_XFYFZM_PT_XF);
|
||||
scheduling::printAddObjectError("SUS_0_dummy", objects::SUS_0_N_LOC_XFYFZM_PT_XF);
|
||||
}
|
||||
|
||||
result = thermalTask->addComponent(objects::CORE_CONTROLLER);
|
||||
if (result != returnvalue::OK) {
|
||||
initmission::printAddObjectError("Core controller dummy", objects::CORE_CONTROLLER);
|
||||
scheduling::printAddObjectError("Core controller dummy", objects::CORE_CONTROLLER);
|
||||
}
|
||||
|
||||
result = thermalTask->addComponent(objects::THERMAL_CONTROLLER);
|
||||
if (result != returnvalue::OK) {
|
||||
initmission::printAddObjectError("THERMAL_CONTROLLER", objects::THERMAL_CONTROLLER);
|
||||
scheduling::printAddObjectError("THERMAL_CONTROLLER", objects::THERMAL_CONTROLLER);
|
||||
}
|
||||
|
||||
FixedTimeslotTaskIF* pstTask = factory->createFixedTimeslotTask(
|
||||
@ -166,16 +164,27 @@ void initmission::initTasks() {
|
||||
sif::error << "Failed to add dummy pst to fixed timeslot task" << std::endl;
|
||||
}
|
||||
|
||||
#if OBSW_ADD_PLOC_SUPERVISOR == 1
|
||||
PeriodicTaskIF* supvHelperTask = factory->createPeriodicTask(
|
||||
"PLOC_SUPV_HELPER", 20, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, missedDeadlineFunc);
|
||||
result = supvHelperTask->addComponent(objects::PLOC_SUPERVISOR_HELPER);
|
||||
if (result != returnvalue::OK) {
|
||||
scheduling::printAddObjectError("PLOC_SUPV_HELPER", objects::PLOC_SUPERVISOR_HELPER);
|
||||
}
|
||||
#endif /* OBSW_ADD_PLOC_SUPERVISOR */
|
||||
|
||||
PeriodicTaskIF* plTask = factory->createPeriodicTask(
|
||||
"PL_TASK", 25, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, missedDeadlineFunc);
|
||||
scheduling::addMpsocSupvHandlers(plTask);
|
||||
#if OBSW_ADD_TEST_CODE == 1
|
||||
result = testTask->addComponent(objects::TEST_TASK);
|
||||
if (result != returnvalue::OK) {
|
||||
initmission::printAddObjectError("TEST_TASK", objects::TEST_TASK);
|
||||
scheduling::printAddObjectError("TEST_TASK", objects::TEST_TASK);
|
||||
}
|
||||
#endif /* OBSW_ADD_TEST_CODE == 1 */
|
||||
|
||||
sif::info << "Starting tasks.." << std::endl;
|
||||
tmTcDistributor->startTask();
|
||||
tmtcBridgeTask->startTask();
|
||||
tmtcDistributor->startTask();
|
||||
tmtcPollingTask->startTask();
|
||||
|
||||
pusVerification->startTask();
|
||||
@ -186,6 +195,12 @@ void initmission::initTasks() {
|
||||
|
||||
pstTask->startTask();
|
||||
thermalTask->startTask();
|
||||
#if OBSW_ADD_PLOC_SUPERVISOR == 1
|
||||
supvHelperTask->startTask();
|
||||
#endif
|
||||
#if OBSW_ADD_PLOC_SUPERVISOR == 1 || OBSW_ADD_PLOC_MPSOC == 1
|
||||
plTask->startTask();
|
||||
#endif
|
||||
|
||||
#if OBSW_ADD_TEST_CODE == 1
|
||||
testTask->startTask();
|
||||
6
bsp_hosted/scheduling.h
Normal file
6
bsp_hosted/scheduling.h
Normal file
@ -0,0 +1,6 @@
|
||||
#pragma once
|
||||
|
||||
namespace scheduling {
|
||||
void initMission();
|
||||
void initTasks();
|
||||
}; // namespace scheduling
|
||||
@ -119,6 +119,13 @@
|
||||
/*******************************************************************/
|
||||
/** CMake Defines */
|
||||
/*******************************************************************/
|
||||
|
||||
// Use TCP instead of UDP for the TMTC bridge. This allows using the TMTC client locally
|
||||
// because UDP packets are not allowed in the VPN
|
||||
// This will cause the OBSW to initialize the TMTC bridge responsible for exchanging data with the
|
||||
// CCSDS IP Cores.
|
||||
#define OBSW_USE_TMTC_TCP_BRIDGE 1
|
||||
|
||||
#cmakedefine EIVE_BUILD_GPSD_GPS_HANDLER
|
||||
|
||||
#cmakedefine LIBGPS_VERSION_MAJOR @LIBGPS_VERSION_MAJOR@
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
#include "bsp_q7s/core/InitMission.h"
|
||||
|
||||
#include <fsfw/devicehandlers/DeviceCommunicationIF.h>
|
||||
#include <linux/InitMission.h>
|
||||
#include <linux/scheduling.h>
|
||||
|
||||
#include <iostream>
|
||||
#include <vector>
|
||||
@ -74,7 +74,7 @@ void initmission::initTasks() {
|
||||
"SOLAR_ARRAY_DEPL", 65, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.4, missedDeadlineFunc);
|
||||
result = solarArrayDeplTask->addComponent(objects::SOLAR_ARRAY_DEPL_HANDLER);
|
||||
if (result != returnvalue::OK) {
|
||||
initmission::printAddObjectError("SOLAR_ARRAY_DEPL", objects::SOLAR_ARRAY_DEPL_HANDLER);
|
||||
scheduling::printAddObjectError("SOLAR_ARRAY_DEPL", objects::SOLAR_ARRAY_DEPL_HANDLER);
|
||||
}
|
||||
#endif
|
||||
|
||||
@ -82,11 +82,11 @@ void initmission::initTasks() {
|
||||
"CORE_CTRL", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.4, missedDeadlineFunc);
|
||||
result = sysTask->addComponent(objects::CORE_CONTROLLER);
|
||||
if (result != returnvalue::OK) {
|
||||
initmission::printAddObjectError("CORE_CTRL", objects::CORE_CONTROLLER);
|
||||
scheduling::printAddObjectError("CORE_CTRL", objects::CORE_CONTROLLER);
|
||||
}
|
||||
result = sysTask->addComponent(objects::PL_SUBSYSTEM);
|
||||
if (result != returnvalue::OK) {
|
||||
initmission::printAddObjectError("PL_SUBSYSTEM", objects::PL_SUBSYSTEM);
|
||||
scheduling::printAddObjectError("PL_SUBSYSTEM", objects::PL_SUBSYSTEM);
|
||||
}
|
||||
|
||||
/* TMTC Distribution */
|
||||
@ -95,24 +95,24 @@ void initmission::initTasks() {
|
||||
#if OBSW_ADD_TCPIP_BRIDGE == 1
|
||||
result = tmTcDistributor->addComponent(objects::TMTC_BRIDGE);
|
||||
if (result != returnvalue::OK) {
|
||||
initmission::printAddObjectError("TMTC_BRIDGE", objects::TMTC_BRIDGE);
|
||||
scheduling::printAddObjectError("TMTC_BRIDGE", objects::TMTC_BRIDGE);
|
||||
}
|
||||
#endif
|
||||
result = tmTcDistributor->addComponent(objects::CCSDS_PACKET_DISTRIBUTOR);
|
||||
if (result != returnvalue::OK) {
|
||||
initmission::printAddObjectError("CCSDS_DISTRIB", objects::CCSDS_PACKET_DISTRIBUTOR);
|
||||
scheduling::printAddObjectError("CCSDS_DISTRIB", objects::CCSDS_PACKET_DISTRIBUTOR);
|
||||
}
|
||||
result = tmTcDistributor->addComponent(objects::PUS_PACKET_DISTRIBUTOR);
|
||||
if (result != returnvalue::OK) {
|
||||
initmission::printAddObjectError("PUS_PACKET_DISTRIB", objects::PUS_PACKET_DISTRIBUTOR);
|
||||
scheduling::printAddObjectError("PUS_PACKET_DISTRIB", objects::PUS_PACKET_DISTRIBUTOR);
|
||||
}
|
||||
result = tmTcDistributor->addComponent(objects::CFDP_DISTRIBUTOR);
|
||||
if (result != returnvalue::OK) {
|
||||
initmission::printAddObjectError("CFDP_DISTRIBUTOR", objects::CFDP_DISTRIBUTOR);
|
||||
scheduling::printAddObjectError("CFDP_DISTRIBUTOR", objects::CFDP_DISTRIBUTOR);
|
||||
}
|
||||
result = tmTcDistributor->addComponent(objects::TM_FUNNEL);
|
||||
if (result != returnvalue::OK) {
|
||||
initmission::printAddObjectError("TM_FUNNEL", objects::TM_FUNNEL);
|
||||
scheduling::printAddObjectError("TM_FUNNEL", objects::TM_FUNNEL);
|
||||
}
|
||||
|
||||
#if OBSW_ADD_TCPIP_BRIDGE == 1
|
||||
@ -120,7 +120,7 @@ void initmission::initTasks() {
|
||||
"TMTC_POLLING", 80, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
|
||||
result = tmtcPollingTask->addComponent(objects::TMTC_POLLING_TASK);
|
||||
if (result != returnvalue::OK) {
|
||||
initmission::printAddObjectError("UDP_POLLING", objects::TMTC_POLLING_TASK);
|
||||
scheduling::printAddObjectError("UDP_POLLING", objects::TMTC_POLLING_TASK);
|
||||
}
|
||||
#endif
|
||||
|
||||
@ -129,7 +129,7 @@ void initmission::initTasks() {
|
||||
"CCSDS_HANDLER", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
|
||||
result = ccsdsHandlerTask->addComponent(objects::CCSDS_HANDLER);
|
||||
if (result != returnvalue::OK) {
|
||||
initmission::printAddObjectError("CCSDS Handler", objects::CCSDS_HANDLER);
|
||||
scheduling::printAddObjectError("CCSDS Handler", objects::CCSDS_HANDLER);
|
||||
}
|
||||
|
||||
// Runs in IRQ mode, frequency does not really matter
|
||||
@ -137,7 +137,7 @@ void initmission::initTasks() {
|
||||
"PDEC_HANDLER", 75, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, missedDeadlineFunc);
|
||||
result = pdecHandlerTask->addComponent(objects::PDEC_HANDLER);
|
||||
if (result != returnvalue::OK) {
|
||||
initmission::printAddObjectError("PDEC Handler", objects::PDEC_HANDLER);
|
||||
scheduling::printAddObjectError("PDEC Handler", objects::PDEC_HANDLER);
|
||||
}
|
||||
#endif /* OBSW_ADD_CCSDS_IP_CORE == 1 */
|
||||
|
||||
@ -146,7 +146,7 @@ void initmission::initTasks() {
|
||||
"CFDP Handler", 45, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.4, missedDeadlineFunc);
|
||||
result = cfdpTask->addComponent(objects::CFDP_HANDLER);
|
||||
if (result != returnvalue::OK) {
|
||||
initmission::printAddObjectError("CFDP Handler", objects::CFDP_HANDLER);
|
||||
scheduling::printAddObjectError("CFDP Handler", objects::CFDP_HANDLER);
|
||||
}
|
||||
#endif
|
||||
|
||||
@ -155,14 +155,14 @@ void initmission::initTasks() {
|
||||
#if OBSW_ADD_GPS_CTRL == 1
|
||||
result = acsCtrlTask->addComponent(objects::GPS_CONTROLLER);
|
||||
if (result != returnvalue::OK) {
|
||||
initmission::printAddObjectError("GPS_CTRL", objects::GPS_CONTROLLER);
|
||||
scheduling::printAddObjectError("GPS_CTRL", objects::GPS_CONTROLLER);
|
||||
}
|
||||
#endif /* OBSW_ADD_GPS_CTRL */
|
||||
|
||||
#if OBSW_ADD_ACS_CTRL == 1
|
||||
acsCtrlTask->addComponent(objects::ACS_CONTROLLER);
|
||||
if (result != returnvalue::OK) {
|
||||
initmission::printAddObjectError("ACS_CTRL", objects::ACS_CONTROLLER);
|
||||
scheduling::printAddObjectError("ACS_CTRL", objects::ACS_CONTROLLER);
|
||||
}
|
||||
#endif
|
||||
|
||||
@ -172,24 +172,24 @@ void initmission::initTasks() {
|
||||
#if OBSW_ADD_ACS_BOARD == 1
|
||||
result = acsSysTask->addComponent(objects::ACS_BOARD_ASS);
|
||||
if (result != returnvalue::OK) {
|
||||
initmission::printAddObjectError("ACS_BOARD_ASS", objects::ACS_BOARD_ASS);
|
||||
scheduling::printAddObjectError("ACS_BOARD_ASS", objects::ACS_BOARD_ASS);
|
||||
}
|
||||
#endif /* OBSW_ADD_ACS_HANDLERS */
|
||||
#if OBSW_ADD_RW == 1
|
||||
result = acsSysTask->addComponent(objects::RW_ASS);
|
||||
if (result != returnvalue::OK) {
|
||||
initmission::printAddObjectError("RW_ASS", objects::RW_ASS);
|
||||
scheduling::printAddObjectError("RW_ASS", objects::RW_ASS);
|
||||
}
|
||||
#endif
|
||||
#if OBSW_ADD_SUS_BOARD_ASS == 1
|
||||
result = acsSysTask->addComponent(objects::SUS_BOARD_ASS);
|
||||
if (result != returnvalue::OK) {
|
||||
initmission::printAddObjectError("SUS_BOARD_ASS", objects::SUS_BOARD_ASS);
|
||||
scheduling::printAddObjectError("SUS_BOARD_ASS", objects::SUS_BOARD_ASS);
|
||||
}
|
||||
#endif
|
||||
result = acsSysTask->addComponent(objects::ACS_SUBSYSTEM);
|
||||
if (result != returnvalue::OK) {
|
||||
initmission::printAddObjectError("ACS_SUBSYSTEM", objects::ACS_SUBSYSTEM);
|
||||
scheduling::printAddObjectError("ACS_SUBSYSTEM", objects::ACS_SUBSYSTEM);
|
||||
}
|
||||
|
||||
#if OBSW_ADD_RTD_DEVICES == 1
|
||||
@ -197,7 +197,7 @@ void initmission::initTasks() {
|
||||
"TCS_POLLING_TASK", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 0.5, missedDeadlineFunc);
|
||||
result = tcsPollingTask->addComponent(objects::SPI_RTD_COM_IF);
|
||||
if (result != returnvalue::OK) {
|
||||
initmission::printAddObjectError("SPI_RTD_POLLING", objects::SPI_RTD_COM_IF);
|
||||
scheduling::printAddObjectError("SPI_RTD_POLLING", objects::SPI_RTD_COM_IF);
|
||||
}
|
||||
|
||||
PeriodicTaskIF* tcsTask = factory->createPeriodicTask(
|
||||
@ -235,19 +235,19 @@ void initmission::initTasks() {
|
||||
#if OBSW_ADD_RTD_DEVICES == 1
|
||||
result = tcsSystemTask->addComponent(objects::TCS_BOARD_ASS);
|
||||
if (result != returnvalue::OK) {
|
||||
initmission::printAddObjectError("TCS_BOARD_ASS", objects::TCS_BOARD_ASS);
|
||||
scheduling::printAddObjectError("TCS_BOARD_ASS", objects::TCS_BOARD_ASS);
|
||||
}
|
||||
#endif /* OBSW_ADD_RTD_DEVICES */
|
||||
#if OBSW_ADD_TCS_CTRL == 1
|
||||
result = tcsSystemTask->addComponent(objects::THERMAL_CONTROLLER);
|
||||
if (result != returnvalue::OK) {
|
||||
initmission::printAddObjectError("THERMAL_CONTROLLER", objects::THERMAL_CONTROLLER);
|
||||
scheduling::printAddObjectError("THERMAL_CONTROLLER", objects::THERMAL_CONTROLLER);
|
||||
}
|
||||
#endif
|
||||
#if OBSW_ADD_HEATERS == 1
|
||||
result = tcsSystemTask->addComponent(objects::HEATER_HANDLER);
|
||||
if (result != returnvalue::OK) {
|
||||
initmission::printAddObjectError("HEATER_HANDLER", objects::HEATER_HANDLER);
|
||||
scheduling::printAddObjectError("HEATER_HANDLER", objects::HEATER_HANDLER);
|
||||
}
|
||||
#endif
|
||||
|
||||
@ -256,7 +256,7 @@ void initmission::initTasks() {
|
||||
"STR_HELPER", 20, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
|
||||
result = strHelperTask->addComponent(objects::STR_HELPER);
|
||||
if (result != returnvalue::OK) {
|
||||
initmission::printAddObjectError("STR_HELPER", objects::STR_HELPER);
|
||||
scheduling::printAddObjectError("STR_HELPER", objects::STR_HELPER);
|
||||
}
|
||||
#endif /* OBSW_ADD_STAR_TRACKER == 1 */
|
||||
|
||||
@ -265,7 +265,7 @@ void initmission::initTasks() {
|
||||
"PLOC_MPSOC_HELPER", 20, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
|
||||
result = mpsocHelperTask->addComponent(objects::PLOC_MPSOC_HELPER);
|
||||
if (result != returnvalue::OK) {
|
||||
initmission::printAddObjectError("PLOC_MPSOC_HELPER", objects::PLOC_MPSOC_HELPER);
|
||||
scheduling::printAddObjectError("PLOC_MPSOC_HELPER", objects::PLOC_MPSOC_HELPER);
|
||||
}
|
||||
#endif /* OBSW_ADD_PLOC_MPSOC */
|
||||
|
||||
@ -274,7 +274,7 @@ void initmission::initTasks() {
|
||||
"PLOC_SUPV_HELPER", 10, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, missedDeadlineFunc);
|
||||
result = supvHelperTask->addComponent(objects::PLOC_SUPERVISOR_HELPER);
|
||||
if (result != returnvalue::OK) {
|
||||
initmission::printAddObjectError("PLOC_SUPV_HELPER", objects::PLOC_SUPERVISOR_HELPER);
|
||||
scheduling::printAddObjectError("PLOC_SUPV_HELPER", objects::PLOC_SUPERVISOR_HELPER);
|
||||
}
|
||||
#endif /* OBSW_ADD_PLOC_SUPERVISOR */
|
||||
|
||||
@ -300,7 +300,7 @@ void initmission::initTasks() {
|
||||
"PTME_TEST", 80, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
|
||||
result = ptmeTestTask->addComponent(objects::CCSDS_IP_CORE_BRIDGE);
|
||||
if (result != returnvalue::OK) {
|
||||
initmission::printAddObjectError("PTME_TEST", objects::CCSDS_IP_CORE_BRIDGE);
|
||||
scheduling::printAddObjectError("PTME_TEST", objects::CCSDS_IP_CORE_BRIDGE);
|
||||
}
|
||||
#endif
|
||||
std::vector<PeriodicTaskIF*> testTasks;
|
||||
@ -458,7 +458,7 @@ void initmission::createPusTasks(TaskFactory& factory,
|
||||
"PUS_VERIF", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
|
||||
result = pusVerification->addComponent(objects::PUS_SERVICE_1_VERIFICATION);
|
||||
if (result != returnvalue::OK) {
|
||||
initmission::printAddObjectError("PUS_VERIF", objects::PUS_SERVICE_1_VERIFICATION);
|
||||
scheduling::printAddObjectError("PUS_VERIF", objects::PUS_SERVICE_1_VERIFICATION);
|
||||
}
|
||||
taskVec.push_back(pusVerification);
|
||||
|
||||
@ -466,11 +466,11 @@ void initmission::createPusTasks(TaskFactory& factory,
|
||||
"PUS_EVENTS", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
|
||||
result = pusEvents->addComponent(objects::PUS_SERVICE_5_EVENT_REPORTING);
|
||||
if (result != returnvalue::OK) {
|
||||
initmission::printAddObjectError("PUS_EVENTS", objects::PUS_SERVICE_5_EVENT_REPORTING);
|
||||
scheduling::printAddObjectError("PUS_EVENTS", objects::PUS_SERVICE_5_EVENT_REPORTING);
|
||||
}
|
||||
result = pusEvents->addComponent(objects::EVENT_MANAGER);
|
||||
if (result != returnvalue::OK) {
|
||||
initmission::printAddObjectError("PUS_MGMT", objects::EVENT_MANAGER);
|
||||
scheduling::printAddObjectError("PUS_MGMT", objects::EVENT_MANAGER);
|
||||
}
|
||||
taskVec.push_back(pusEvents);
|
||||
|
||||
@ -478,11 +478,11 @@ void initmission::createPusTasks(TaskFactory& factory,
|
||||
"PUS_HIGH_PRIO", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
|
||||
result = pusHighPrio->addComponent(objects::PUS_SERVICE_2_DEVICE_ACCESS);
|
||||
if (result != returnvalue::OK) {
|
||||
initmission::printAddObjectError("PUS_2", objects::PUS_SERVICE_2_DEVICE_ACCESS);
|
||||
scheduling::printAddObjectError("PUS_2", objects::PUS_SERVICE_2_DEVICE_ACCESS);
|
||||
}
|
||||
result = pusHighPrio->addComponent(objects::PUS_SERVICE_9_TIME_MGMT);
|
||||
if (result != returnvalue::OK) {
|
||||
initmission::printAddObjectError("PUS_9", objects::PUS_SERVICE_9_TIME_MGMT);
|
||||
scheduling::printAddObjectError("PUS_9", objects::PUS_SERVICE_9_TIME_MGMT);
|
||||
}
|
||||
|
||||
taskVec.push_back(pusHighPrio);
|
||||
@ -492,32 +492,32 @@ void initmission::createPusTasks(TaskFactory& factory,
|
||||
|
||||
result = pusMedPrio->addComponent(objects::PUS_SERVICE_3_HOUSEKEEPING);
|
||||
if (result != returnvalue::OK) {
|
||||
initmission::printAddObjectError("PUS_3", objects::PUS_SERVICE_3_HOUSEKEEPING);
|
||||
scheduling::printAddObjectError("PUS_3", objects::PUS_SERVICE_3_HOUSEKEEPING);
|
||||
}
|
||||
result = pusMedPrio->addComponent(objects::PUS_SERVICE_8_FUNCTION_MGMT);
|
||||
if (result != returnvalue::OK) {
|
||||
initmission::printAddObjectError("PUS_8", objects::PUS_SERVICE_8_FUNCTION_MGMT);
|
||||
scheduling::printAddObjectError("PUS_8", objects::PUS_SERVICE_8_FUNCTION_MGMT);
|
||||
}
|
||||
result = pusMedPrio->addComponent(objects::PUS_SERVICE_11_TC_SCHEDULER);
|
||||
if (result != returnvalue::OK) {
|
||||
initmission::printAddObjectError("PUS_11", objects::PUS_SERVICE_11_TC_SCHEDULER);
|
||||
scheduling::printAddObjectError("PUS_11", objects::PUS_SERVICE_11_TC_SCHEDULER);
|
||||
}
|
||||
result = pusMedPrio->addComponent(objects::PUS_SERVICE_20_PARAMETERS);
|
||||
if (result != returnvalue::OK) {
|
||||
initmission::printAddObjectError("PUS_20", objects::PUS_SERVICE_20_PARAMETERS);
|
||||
scheduling::printAddObjectError("PUS_20", objects::PUS_SERVICE_20_PARAMETERS);
|
||||
}
|
||||
result = pusMedPrio->addComponent(objects::PUS_SERVICE_200_MODE_MGMT);
|
||||
if (result != returnvalue::OK) {
|
||||
initmission::printAddObjectError("PUS_200", objects::PUS_SERVICE_200_MODE_MGMT);
|
||||
scheduling::printAddObjectError("PUS_200", objects::PUS_SERVICE_200_MODE_MGMT);
|
||||
}
|
||||
result = pusMedPrio->addComponent(objects::PUS_SERVICE_201_HEALTH);
|
||||
if (result != returnvalue::OK) {
|
||||
initmission::printAddObjectError("PUS_201", objects::PUS_SERVICE_201_HEALTH);
|
||||
scheduling::printAddObjectError("PUS_201", objects::PUS_SERVICE_201_HEALTH);
|
||||
}
|
||||
// Used for connection tests, therefore use higher priority
|
||||
result = pusMedPrio->addComponent(objects::PUS_SERVICE_17_TEST);
|
||||
if (result != returnvalue::OK) {
|
||||
initmission::printAddObjectError("PUS_17", objects::PUS_SERVICE_17_TEST);
|
||||
scheduling::printAddObjectError("PUS_17", objects::PUS_SERVICE_17_TEST);
|
||||
}
|
||||
taskVec.push_back(pusMedPrio);
|
||||
|
||||
@ -525,7 +525,7 @@ void initmission::createPusTasks(TaskFactory& factory,
|
||||
"PUS_LOW_PRIO", 30, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.6, missedDeadlineFunc);
|
||||
result = pusLowPrio->addComponent(objects::INTERNAL_ERROR_REPORTER);
|
||||
if (result != returnvalue::OK) {
|
||||
initmission::printAddObjectError("ERROR_REPORTER", objects::INTERNAL_ERROR_REPORTER);
|
||||
scheduling::printAddObjectError("ERROR_REPORTER", objects::INTERNAL_ERROR_REPORTER);
|
||||
}
|
||||
taskVec.push_back(pusLowPrio);
|
||||
}
|
||||
@ -542,25 +542,25 @@ void initmission::createTestTasks(TaskFactory& factory,
|
||||
|
||||
result = testTask->addComponent(objects::TEST_TASK);
|
||||
if (result != returnvalue::OK) {
|
||||
initmission::printAddObjectError("TEST_TASK", objects::TEST_TASK);
|
||||
scheduling::printAddObjectError("TEST_TASK", objects::TEST_TASK);
|
||||
}
|
||||
|
||||
#if OBSW_ADD_SPI_TEST_CODE == 1
|
||||
result = testTask->addComponent(objects::SPI_TEST);
|
||||
if (result != returnvalue::OK) {
|
||||
initmission::printAddObjectError("SPI_TEST", objects::SPI_TEST);
|
||||
scheduling::printAddObjectError("SPI_TEST", objects::SPI_TEST);
|
||||
}
|
||||
#endif
|
||||
#if OBSW_ADD_I2C_TEST_CODE == 1
|
||||
result = testTask->addComponent(objects::I2C_TEST);
|
||||
if (result != returnvalue::OK) {
|
||||
initmission::printAddObjectError("I2C_TEST", objects::I2C_TEST);
|
||||
scheduling::printAddObjectError("I2C_TEST", objects::I2C_TEST);
|
||||
}
|
||||
#endif
|
||||
#if OBSW_ADD_UART_TEST_CODE == 1
|
||||
result = testTask->addComponent(objects::UART_TEST);
|
||||
if (result != returnvalue::OK) {
|
||||
initmission::printAddObjectError("UART_TEST", objects::UART_TEST);
|
||||
scheduling::printAddObjectError("UART_TEST", objects::UART_TEST);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
@ -600,7 +600,6 @@ void ObjectFactory::createPayloadComponents(LinuxLibgpioIF* gpioComIF, PowerSwit
|
||||
auto* camSwitcher =
|
||||
new CamSwitcher(objects::CAM_SWITCHER, pwrSwitch, pcdu::PDU2_CH8_PAYLOAD_CAMERA);
|
||||
camSwitcher->connectModeTreeParent(satsystem::pl::SUBSYSTEM);
|
||||
// camSwitcher->
|
||||
#if OBSW_ADD_PLOC_MPSOC == 1
|
||||
consumer << "0x" << std::hex << objects::PLOC_MPSOC_HANDLER;
|
||||
auto gpioConfigMPSoC = new GpiodRegularByLineName(q7s::gpioNames::ENABLE_MPSOC_UART,
|
||||
@ -629,10 +628,10 @@ void ObjectFactory::createPayloadComponents(LinuxLibgpioIF* gpioComIF, PowerSwit
|
||||
new SerialCookie(objects::PLOC_SUPERVISOR_HANDLER, q7s::UART_PLOC_SUPERVSIOR_DEV,
|
||||
uart::PLOC_SUPV_BAUD, supv::MAX_PACKET_SIZE * 20, UartModes::NON_CANONICAL);
|
||||
supervisorCookie->setNoFixedSizeReply();
|
||||
auto supvHelper = new PlocSupvHelper(objects::PLOC_SUPERVISOR_HELPER);
|
||||
auto* supvHandler = new PlocSupervisorHandler(
|
||||
objects::PLOC_SUPERVISOR_HANDLER, objects::UART_COM_IF, supervisorCookie,
|
||||
Gpio(gpioIds::ENABLE_SUPV_UART, gpioComIF), pcdu::PDU1_CH6_PLOC_12V, supvHelper);
|
||||
auto supvHelper = new PlocSupvUartManager(objects::PLOC_SUPERVISOR_HELPER);
|
||||
auto* supvHandler = new PlocSupervisorHandler(objects::PLOC_SUPERVISOR_HANDLER, supervisorCookie,
|
||||
Gpio(gpioIds::ENABLE_SUPV_UART, gpioComIF),
|
||||
pcdu::PDU1_CH6_PLOC_12V, *supvHelper);
|
||||
supvHandler->connectModeTreeParent(satsystem::pl::SUBSYSTEM);
|
||||
#endif /* OBSW_ADD_PLOC_SUPERVISOR == 1 */
|
||||
static_cast<void>(consumer);
|
||||
|
||||
@ -1,6 +1,7 @@
|
||||
#include <bsp_q7s/callbacks/q7sGpioCallbacks.h>
|
||||
#include <fsfw/health/HealthTableIF.h>
|
||||
#include <fsfw/power/DummyPowerSwitcher.h>
|
||||
#include <mission/devices/devicedefinitions/GomspaceDefinitions.h>
|
||||
|
||||
#include "OBSWConfig.h"
|
||||
#include "bsp_q7s/core/CoreController.h"
|
||||
@ -38,13 +39,21 @@ void ObjectFactory::produce(void* args) {
|
||||
#if OBSW_ADD_SYRLINKS == 1
|
||||
dummyCfg.addSyrlinksDummies = false;
|
||||
#endif
|
||||
dummy::createDummies(dummyCfg);
|
||||
#if OBSW_ADD_GOMSPACE_PCDU == 1
|
||||
dummyCfg.addPowerDummies = false;
|
||||
#endif
|
||||
|
||||
PowerSwitchIF* pwrSwitcher = nullptr;
|
||||
#if OBSW_ADD_GOMSPACE_PCDU == 0
|
||||
pwrSwitcher = new DummyPowerSwitcher(objects::PCDU_HANDLER, 18, 0);
|
||||
#else
|
||||
createPcduComponents(gpioComIF, &pwrSwitcher);
|
||||
#endif
|
||||
|
||||
dummy::createDummies(dummyCfg, *pwrSwitcher);
|
||||
|
||||
new CoreController(objects::CORE_CONTROLLER);
|
||||
|
||||
PowerSwitchIF* pwrSwitcher = new DummyPowerSwitcher(objects::PCDU_HANDLER, 18, 0);
|
||||
static_cast<void>(pwrSwitcher);
|
||||
|
||||
// Regular FM code, does not work for EM if the hardware is not connected
|
||||
// createPcduComponents(gpioComIF, &pwrSwitcher);
|
||||
// createPlPcduComponents(gpioComIF, spiMainComIF, pwrSwitcher);
|
||||
@ -95,8 +104,8 @@ void ObjectFactory::produce(void* args) {
|
||||
createTestComponents(gpioComIF);
|
||||
#endif /* OBSW_ADD_TEST_CODE == 1 */
|
||||
#if OBSW_ADD_SCEX_DEVICE == 1
|
||||
createScexComponents(q7s::UART_SCEX_DEV, pwrSwitcher, *SdCardManager::instance(), true,
|
||||
std::nullopt);
|
||||
createScexComponents(q7s::UART_SCEX_DEV, pwrSwitcher, *SdCardManager::instance(), false,
|
||||
pcdu::Switches::PDU1_CH5_SOLAR_CELL_EXP_5V);
|
||||
#endif
|
||||
createAcsController(true);
|
||||
}
|
||||
|
||||
@ -19,12 +19,6 @@ debugging. */
|
||||
// Disable this for mission code. It allows exchanging TMTC packets via the Ethernet port
|
||||
#define OBSW_ADD_TCPIP_BRIDGE 1
|
||||
|
||||
// Use TCP instead of UDP for the TMTC bridge. This allows using the TMTC client locally
|
||||
// because UDP packets are not allowed in the VPN
|
||||
// This will cause the OBSW to initialize the TMTC bridge responsible for exchanging data with the
|
||||
// CCSDS IP Cores.
|
||||
#define OBSW_USE_TMTC_TCP_BRIDGE 1
|
||||
|
||||
#define OBSW_ADD_CFDP_COMPONENTS 1
|
||||
|
||||
namespace common {
|
||||
|
||||
@ -1,6 +1,8 @@
|
||||
#ifndef COMMON_CONFIG_DEVCONF_H_
|
||||
#define COMMON_CONFIG_DEVCONF_H_
|
||||
|
||||
#include <fsfw_hal/linux/serial/SerialCookie.h>
|
||||
|
||||
#include <cstdint>
|
||||
|
||||
#include "fsfw/timemanager/clockDefinitions.h"
|
||||
@ -55,7 +57,7 @@ namespace uart {
|
||||
|
||||
static constexpr size_t HYPERION_GPS_REPLY_MAX_BUFFER = 1024;
|
||||
static constexpr UartBaudRate SYRLINKS_BAUD = UartBaudRate::RATE_38400;
|
||||
static constexpr UartBaudRate SCEX_BAUD = UartBaudRate::RATE_38400;
|
||||
static constexpr UartBaudRate SCEX_BAUD = UartBaudRate::RATE_115200;
|
||||
static constexpr UartBaudRate GNSS_BAUD = UartBaudRate::RATE_9600;
|
||||
static constexpr UartBaudRate PLOC_MPSOC_BAUD = UartBaudRate::RATE_115200;
|
||||
static constexpr UartBaudRate PLOC_SUPV_BAUD = UartBaudRate::RATE_115200;
|
||||
|
||||
@ -16,6 +16,10 @@ enum commonObjects : uint32_t {
|
||||
PDEC_HANDLER = 0x50000700,
|
||||
CCSDS_HANDLER = 0x50000800,
|
||||
|
||||
/* 0x49 ('I') for Communication Interfaces **/
|
||||
UART_COM_IF = 0x49030003,
|
||||
SCEX_UART_READER = 0x49010006,
|
||||
|
||||
/* 0x43 ('C') for Controllers */
|
||||
THERMAL_CONTROLLER = 0x43400001,
|
||||
ACS_CONTROLLER = 0x43000002,
|
||||
|
||||
@ -26,6 +26,10 @@ TemperatureSensorsDummy::TemperatureSensorsDummy()
|
||||
ObjectManager::instance()->insert(objects::RTD_15_IC18_IMTQ, this);
|
||||
ObjectManager::instance()->insert(objects::TMP1075_HANDLER_TCS_0, this);
|
||||
ObjectManager::instance()->insert(objects::TMP1075_HANDLER_TCS_1, this);
|
||||
|
||||
ObjectManager::instance()->insert(objects::TMP1075_HANDLER_PLPCDU_0, this);
|
||||
ObjectManager::instance()->insert(objects::TMP1075_HANDLER_PLPCDU_1, this);
|
||||
ObjectManager::instance()->insert(objects::TMP1075_HANDLER_IF_BOARD, this);
|
||||
}
|
||||
|
||||
ReturnValue_t TemperatureSensorsDummy::initialize() {
|
||||
|
||||
@ -19,10 +19,11 @@
|
||||
#include <dummies/SusDummy.h>
|
||||
#include <dummies/SyrlinksDummy.h>
|
||||
#include <dummies/TemperatureSensorsDummy.h>
|
||||
#include <mission/system/objects/CamSwitcher.h>
|
||||
|
||||
using namespace dummy;
|
||||
|
||||
void dummy::createDummies(DummyCfg cfg) {
|
||||
void dummy::createDummies(DummyCfg cfg, PowerSwitchIF& pwrSwitch) {
|
||||
new ComIFDummy(objects::DUMMY_COM_IF);
|
||||
ComCookieDummy* comCookieDummy = new ComCookieDummy();
|
||||
new BpxDummy(objects::BPX_BATT_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
|
||||
@ -67,5 +68,6 @@ void dummy::createDummies(DummyCfg cfg) {
|
||||
if (cfg.addTempSensorDummies) {
|
||||
new TemperatureSensorsDummy();
|
||||
}
|
||||
new CamSwitcher(objects::CAM_SWITCHER, pwrSwitch, power::NO_SWITCH);
|
||||
new PlPcduDummy(objects::PLPCDU_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
|
||||
}
|
||||
|
||||
@ -1,5 +1,7 @@
|
||||
#pragma once
|
||||
|
||||
#include <fsfw/power/PowerSwitchIF.h>
|
||||
|
||||
namespace dummy {
|
||||
|
||||
struct DummyCfg {
|
||||
@ -12,6 +14,6 @@ struct DummyCfg {
|
||||
bool addRtdComIFDummy = true;
|
||||
};
|
||||
|
||||
void createDummies(DummyCfg cfg);
|
||||
void createDummies(DummyCfg cfg, PowerSwitchIF& pwrSwitch);
|
||||
|
||||
} // namespace dummy
|
||||
|
||||
@ -123,10 +123,13 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
|
||||
11901;0x2e7d;BOOTING_FIRMWARE_FAILED;LOW;Failed to boot firmware;linux/devices/startracker/StarTrackerHandler.h
|
||||
11902;0x2e7e;BOOTING_BOOTLOADER_FAILED;LOW;Failed to boot star tracker into bootloader mode;linux/devices/startracker/StarTrackerHandler.h
|
||||
12001;0x2ee1;SUPV_MEMORY_READ_RPT_CRC_FAILURE;LOW;PLOC supervisor crc failure in telemetry packet;linux/devices/ploc/PlocSupervisorHandler.h
|
||||
12002;0x2ee2;SUPV_ACK_FAILURE;LOW;PLOC supervisor received acknowledgment failure report;linux/devices/ploc/PlocSupervisorHandler.h
|
||||
12003;0x2ee3;SUPV_EXE_FAILURE;LOW;PLOC received execution failure report P1: ID of command for which the execution failed P2: Status code sent by the supervisor handler;linux/devices/ploc/PlocSupervisorHandler.h
|
||||
12004;0x2ee4;SUPV_CRC_FAILURE_EVENT;LOW;PLOC supervisor reply has invalid crc;linux/devices/ploc/PlocSupervisorHandler.h
|
||||
12005;0x2ee5;SUPV_MPSOC_SHUWDOWN_BUILD_FAILED;LOW;Failed to build the command to shutdown the MPSoC;linux/devices/ploc/PlocSupervisorHandler.h
|
||||
12002;0x2ee2;SUPV_UNKNOWN_TM;LOW;Unhandled event. P1: APID, P2: Service ID;linux/devices/ploc/PlocSupervisorHandler.h
|
||||
12003;0x2ee3;SUPV_UNINIMPLEMENTED_TM;LOW;;linux/devices/ploc/PlocSupervisorHandler.h
|
||||
12004;0x2ee4;SUPV_ACK_FAILURE;LOW;PLOC supervisor received acknowledgment failure report;linux/devices/ploc/PlocSupervisorHandler.h
|
||||
12005;0x2ee5;SUPV_EXE_FAILURE;LOW;PLOC received execution failure report P1: ID of command for which the execution failed P2: Status code sent by the supervisor handler;linux/devices/ploc/PlocSupervisorHandler.h
|
||||
12006;0x2ee6;SUPV_CRC_FAILURE_EVENT;LOW;PLOC supervisor reply has invalid crc;linux/devices/ploc/PlocSupervisorHandler.h
|
||||
12007;0x2ee7;SUPV_HELPER_EXECUTING;LOW;Supervisor helper currently executing a command;linux/devices/ploc/PlocSupervisorHandler.h
|
||||
12008;0x2ee8;SUPV_MPSOC_SHUWDOWN_BUILD_FAILED;LOW;Failed to build the command to shutdown the MPSoC;linux/devices/ploc/PlocSupervisorHandler.h
|
||||
12100;0x2f44;SANITIZATION_FAILED;LOW;;bsp_q7s/fs/SdCardManager.h
|
||||
12101;0x2f45;MOUNTED_SD_CARD;INFO;;bsp_q7s/fs/SdCardManager.h
|
||||
12300;0x300c;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
|
||||
@ -195,31 +198,33 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
|
||||
13200;0x3390;P60_BOOT_COUNT;INFO;P60 boot count is broadcasted once at SW startup. P1: Boot count;mission/devices/P60DockHandler.h
|
||||
13201;0x3391;BATT_MODE;INFO;Battery mode is broadcasted at startup. P1: Mode;mission/devices/P60DockHandler.h
|
||||
13202;0x3392;BATT_MODE_CHANGED;MEDIUM;Battery mode has changed. P1: Old mode. P2: New mode;mission/devices/P60DockHandler.h
|
||||
13600;0x3520;SUPV_UPDATE_FAILED;LOW;update failed;linux/devices/ploc/PlocSupvHelper.h
|
||||
13601;0x3521;SUPV_UPDATE_SUCCESSFUL;LOW;update successful;linux/devices/ploc/PlocSupvHelper.h
|
||||
13602;0x3522;SUPV_CONTINUE_UPDATE_FAILED;LOW;Continue update command failed;linux/devices/ploc/PlocSupvHelper.h
|
||||
13603;0x3523;SUPV_CONTINUE_UPDATE_SUCCESSFUL;LOW;Continue update command successful;linux/devices/ploc/PlocSupvHelper.h
|
||||
13604;0x3524;TERMINATED_UPDATE_PROCEDURE;LOW;Terminated update procedure by command;linux/devices/ploc/PlocSupvHelper.h
|
||||
13605;0x3525;SUPV_EVENT_BUFFER_REQUEST_SUCCESSFUL;LOW;Requesting event buffer was successful;linux/devices/ploc/PlocSupvHelper.h
|
||||
13606;0x3526;SUPV_EVENT_BUFFER_REQUEST_FAILED;LOW;Requesting event buffer failed;linux/devices/ploc/PlocSupvHelper.h
|
||||
13607;0x3527;SUPV_EVENT_BUFFER_REQUEST_TERMINATED;LOW;Terminated event buffer request by command P1: Number of packets read before process was terminated;linux/devices/ploc/PlocSupvHelper.h
|
||||
13608;0x3528;SUPV_MEM_CHECK_OK;INFO;;linux/devices/ploc/PlocSupvHelper.h
|
||||
13609;0x3529;SUPV_MEM_CHECK_FAIL;INFO;;linux/devices/ploc/PlocSupvHelper.h
|
||||
13616;0x3530;SUPV_SENDING_COMMAND_FAILED;LOW;;linux/devices/ploc/PlocSupvHelper.h
|
||||
13617;0x3531;SUPV_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 supervisor helper;linux/devices/ploc/PlocSupvHelper.h
|
||||
13618;0x3532;SUPV_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 supervisor helper;linux/devices/ploc/PlocSupvHelper.h
|
||||
13619;0x3533;SUPV_MISSING_ACK;LOW;Did not receive acknowledgement report P1: Number of bytes missing P2: Internal state of MPSoC helper;linux/devices/ploc/PlocSupvHelper.h
|
||||
13620;0x3534;SUPV_MISSING_EXE;LOW;Supervisor did not receive execution report P1: Number of bytes missing P2: Internal state of supervisor helper;linux/devices/ploc/PlocSupvHelper.h
|
||||
13621;0x3535;SUPV_ACK_FAILURE_REPORT;LOW;Supervisor received acknowledgment failure report P1: Internal state of supervisor helper;linux/devices/ploc/PlocSupvHelper.h
|
||||
13622;0x3536;SUPV_EXE_FAILURE_REPORT;LOW;Execution report failure P1:;linux/devices/ploc/PlocSupvHelper.h
|
||||
13623;0x3537;SUPV_ACK_INVALID_APID;LOW;Supervisor expected acknowledgment report but received space packet with other apid P1: Apid of received space packet P2: Internal state of supervisor helper;linux/devices/ploc/PlocSupvHelper.h
|
||||
13624;0x3538;SUPV_EXE_INVALID_APID;LOW;Supervisor helper expected execution report but received space packet with other apid P1: Apid of received space packet P2: Internal state of supervisor helper;linux/devices/ploc/PlocSupvHelper.h
|
||||
13625;0x3539;ACK_RECEPTION_FAILURE;LOW;Failed to receive acknowledgment report P1: Return value P2: Apid of command for which the reception of the acknowledgment report failed;linux/devices/ploc/PlocSupvHelper.h
|
||||
13626;0x353a;EXE_RECEPTION_FAILURE;LOW;Failed to receive execution report P1: Return value P2: Apid of command for which the reception of the execution report failed;linux/devices/ploc/PlocSupvHelper.h
|
||||
13627;0x353b;WRITE_MEMORY_FAILED;LOW;Update procedure failed when sending packet. P1: First byte percent, third and fourth byte Sequence Count, P2: Bytes written;linux/devices/ploc/PlocSupvHelper.h
|
||||
13628;0x353c;SUPV_REPLY_SIZE_MISSMATCH;LOW;;linux/devices/ploc/PlocSupvHelper.h
|
||||
13629;0x353d;SUPV_REPLY_CRC_MISSMATCH;LOW;;linux/devices/ploc/PlocSupvHelper.h
|
||||
13630;0x353e;SUPV_UPDATE_PROGRESS;INFO;Will be triggered every 5 percent of the update progress. P1: First byte percent, third and fourth byte Sequence Count, P2: Bytes written;linux/devices/ploc/PlocSupvHelper.h
|
||||
13600;0x3520;SUPV_UPDATE_FAILED;LOW;update failed;linux/devices/ploc/PlocSupvUartMan.h
|
||||
13601;0x3521;SUPV_UPDATE_SUCCESSFUL;LOW;update successful;linux/devices/ploc/PlocSupvUartMan.h
|
||||
13602;0x3522;SUPV_CONTINUE_UPDATE_FAILED;LOW;Continue update command failed;linux/devices/ploc/PlocSupvUartMan.h
|
||||
13603;0x3523;SUPV_CONTINUE_UPDATE_SUCCESSFUL;LOW;Continue update command successful;linux/devices/ploc/PlocSupvUartMan.h
|
||||
13604;0x3524;TERMINATED_UPDATE_PROCEDURE;LOW;Terminated update procedure by command;linux/devices/ploc/PlocSupvUartMan.h
|
||||
13605;0x3525;SUPV_EVENT_BUFFER_REQUEST_SUCCESSFUL;LOW;Requesting event buffer was successful;linux/devices/ploc/PlocSupvUartMan.h
|
||||
13606;0x3526;SUPV_EVENT_BUFFER_REQUEST_FAILED;LOW;Requesting event buffer failed;linux/devices/ploc/PlocSupvUartMan.h
|
||||
13607;0x3527;SUPV_EVENT_BUFFER_REQUEST_TERMINATED;LOW;Terminated event buffer request by command P1: Number of packets read before process was terminated;linux/devices/ploc/PlocSupvUartMan.h
|
||||
13608;0x3528;SUPV_MEM_CHECK_OK;INFO;;linux/devices/ploc/PlocSupvUartMan.h
|
||||
13609;0x3529;SUPV_MEM_CHECK_FAIL;INFO;;linux/devices/ploc/PlocSupvUartMan.h
|
||||
13616;0x3530;SUPV_SENDING_COMMAND_FAILED;LOW;;linux/devices/ploc/PlocSupvUartMan.h
|
||||
13617;0x3531;SUPV_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 supervisor helper;linux/devices/ploc/PlocSupvUartMan.h
|
||||
13618;0x3532;SUPV_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 supervisor helper;linux/devices/ploc/PlocSupvUartMan.h
|
||||
13619;0x3533;SUPV_MISSING_ACK;LOW;Did not receive acknowledgement report P1: Number of bytes missing P2: Internal state of MPSoC helper;linux/devices/ploc/PlocSupvUartMan.h
|
||||
13620;0x3534;SUPV_MISSING_EXE;LOW;Supervisor did not receive execution report P1: Number of bytes missing P2: Internal state of supervisor helper;linux/devices/ploc/PlocSupvUartMan.h
|
||||
13621;0x3535;SUPV_ACK_FAILURE_REPORT;LOW;Supervisor received acknowledgment failure report P1: Internal state of supervisor helper;linux/devices/ploc/PlocSupvUartMan.h
|
||||
13622;0x3536;SUPV_EXE_FAILURE_REPORT;LOW;Execution report failure P1:;linux/devices/ploc/PlocSupvUartMan.h
|
||||
13623;0x3537;SUPV_ACK_INVALID_APID;LOW;Supervisor expected acknowledgment report but received space packet with other apid P1: Apid of received space packet P2: Internal state of supervisor helper;linux/devices/ploc/PlocSupvUartMan.h
|
||||
13624;0x3538;SUPV_EXE_INVALID_APID;LOW;Supervisor helper expected execution report but received space packet with other apid P1: Apid of received space packet P2: Internal state of supervisor helper;linux/devices/ploc/PlocSupvUartMan.h
|
||||
13625;0x3539;ACK_RECEPTION_FAILURE;LOW;Failed to receive acknowledgment report P1: Return value P2: Apid of command for which the reception of the acknowledgment report failed;linux/devices/ploc/PlocSupvUartMan.h
|
||||
13626;0x353a;EXE_RECEPTION_FAILURE;LOW;Failed to receive execution report P1: Return value P2: Apid of command for which the reception of the execution report failed;linux/devices/ploc/PlocSupvUartMan.h
|
||||
13627;0x353b;WRITE_MEMORY_FAILED;LOW;Update procedure failed when sending packet. P1: First byte percent, third and fourth byte Sequence Count, P2: Bytes written;linux/devices/ploc/PlocSupvUartMan.h
|
||||
13628;0x353c;SUPV_REPLY_SIZE_MISSMATCH;LOW;;linux/devices/ploc/PlocSupvUartMan.h
|
||||
13629;0x353d;SUPV_REPLY_CRC_MISSMATCH;LOW;;linux/devices/ploc/PlocSupvUartMan.h
|
||||
13630;0x353e;SUPV_UPDATE_PROGRESS;INFO;Will be triggered every 5 percent of the update progress. P1: First byte percent, third and fourth byte Sequence Count, P2: Bytes written;linux/devices/ploc/PlocSupvUartMan.h
|
||||
13631;0x353f;HDLC_FRAME_REMOVAL_ERROR;INFO;;linux/devices/ploc/PlocSupvUartMan.h
|
||||
13632;0x3540;HDLC_CRC_ERROR;INFO;;linux/devices/ploc/PlocSupvUartMan.h
|
||||
13700;0x3584;ALLOC_FAILURE;MEDIUM;;bsp_q7s/core/CoreController.h
|
||||
13701;0x3585;REBOOT_SW;MEDIUM; Software reboot occurred. Can also be a systemd reboot. P1: Current Chip, P2: Current Copy;bsp_q7s/core/CoreController.h
|
||||
13702;0x3586;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
|
||||
|
||||
|
@ -1,7 +1,7 @@
|
||||
/**
|
||||
* @brief Auto-generated event translation file. Contains 234 translations.
|
||||
* @brief Auto-generated event translation file. Contains 239 translations.
|
||||
* @details
|
||||
* Generated on: 2022-11-14 17:10:10
|
||||
* Generated on: 2022-11-16 15:25:08
|
||||
*/
|
||||
#include "translateEvents.h"
|
||||
|
||||
@ -129,9 +129,12 @@ const char *RESET_OCCURED_STRING = "RESET_OCCURED";
|
||||
const char *BOOTING_FIRMWARE_FAILED_STRING = "BOOTING_FIRMWARE_FAILED";
|
||||
const char *BOOTING_BOOTLOADER_FAILED_STRING = "BOOTING_BOOTLOADER_FAILED";
|
||||
const char *SUPV_MEMORY_READ_RPT_CRC_FAILURE_STRING = "SUPV_MEMORY_READ_RPT_CRC_FAILURE";
|
||||
const char *SUPV_UNKNOWN_TM_STRING = "SUPV_UNKNOWN_TM";
|
||||
const char *SUPV_UNINIMPLEMENTED_TM_STRING = "SUPV_UNINIMPLEMENTED_TM";
|
||||
const char *SUPV_ACK_FAILURE_STRING = "SUPV_ACK_FAILURE";
|
||||
const char *SUPV_EXE_FAILURE_STRING = "SUPV_EXE_FAILURE";
|
||||
const char *SUPV_CRC_FAILURE_EVENT_STRING = "SUPV_CRC_FAILURE_EVENT";
|
||||
const char *SUPV_HELPER_EXECUTING_STRING = "SUPV_HELPER_EXECUTING";
|
||||
const char *SUPV_MPSOC_SHUWDOWN_BUILD_FAILED_STRING = "SUPV_MPSOC_SHUWDOWN_BUILD_FAILED";
|
||||
const char *SANITIZATION_FAILED_STRING = "SANITIZATION_FAILED";
|
||||
const char *MOUNTED_SD_CARD_STRING = "MOUNTED_SD_CARD";
|
||||
@ -222,6 +225,8 @@ const char *WRITE_MEMORY_FAILED_STRING = "WRITE_MEMORY_FAILED";
|
||||
const char *SUPV_REPLY_SIZE_MISSMATCH_STRING = "SUPV_REPLY_SIZE_MISSMATCH";
|
||||
const char *SUPV_REPLY_CRC_MISSMATCH_STRING = "SUPV_REPLY_CRC_MISSMATCH";
|
||||
const char *SUPV_UPDATE_PROGRESS_STRING = "SUPV_UPDATE_PROGRESS";
|
||||
const char *HDLC_FRAME_REMOVAL_ERROR_STRING = "HDLC_FRAME_REMOVAL_ERROR";
|
||||
const char *HDLC_CRC_ERROR_STRING = "HDLC_CRC_ERROR";
|
||||
const char *ALLOC_FAILURE_STRING = "ALLOC_FAILURE";
|
||||
const char *REBOOT_SW_STRING = "REBOOT_SW";
|
||||
const char *REBOOT_MECHANISM_TRIGGERED_STRING = "REBOOT_MECHANISM_TRIGGERED";
|
||||
@ -487,12 +492,18 @@ const char *translateEvents(Event event) {
|
||||
case (12001):
|
||||
return SUPV_MEMORY_READ_RPT_CRC_FAILURE_STRING;
|
||||
case (12002):
|
||||
return SUPV_ACK_FAILURE_STRING;
|
||||
return SUPV_UNKNOWN_TM_STRING;
|
||||
case (12003):
|
||||
return SUPV_EXE_FAILURE_STRING;
|
||||
return SUPV_UNINIMPLEMENTED_TM_STRING;
|
||||
case (12004):
|
||||
return SUPV_CRC_FAILURE_EVENT_STRING;
|
||||
return SUPV_ACK_FAILURE_STRING;
|
||||
case (12005):
|
||||
return SUPV_EXE_FAILURE_STRING;
|
||||
case (12006):
|
||||
return SUPV_CRC_FAILURE_EVENT_STRING;
|
||||
case (12007):
|
||||
return SUPV_HELPER_EXECUTING_STRING;
|
||||
case (12008):
|
||||
return SUPV_MPSOC_SHUWDOWN_BUILD_FAILED_STRING;
|
||||
case (12100):
|
||||
return SANITIZATION_FAILED_STRING;
|
||||
@ -672,6 +683,10 @@ const char *translateEvents(Event event) {
|
||||
return SUPV_REPLY_CRC_MISSMATCH_STRING;
|
||||
case (13630):
|
||||
return SUPV_UPDATE_PROGRESS_STRING;
|
||||
case (13631):
|
||||
return HDLC_FRAME_REMOVAL_ERROR_STRING;
|
||||
case (13632):
|
||||
return HDLC_CRC_ERROR_STRING;
|
||||
case (13700):
|
||||
return ALLOC_FAILURE_STRING;
|
||||
case (13701):
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
* @brief Auto-generated object translation file.
|
||||
* @details
|
||||
* Contains 148 translations.
|
||||
* Generated on: 2022-11-14 17:10:10
|
||||
* Generated on: 2022-11-16 15:25:08
|
||||
*/
|
||||
#include "translateObjects.h"
|
||||
|
||||
|
||||
@ -9,4 +9,4 @@ if(EIVE_ADD_LINUX_FSFWCONFIG)
|
||||
add_subdirectory(fsfwconfig)
|
||||
endif()
|
||||
|
||||
target_sources(${OBSW_NAME} PUBLIC ObjectFactory.cpp InitMission.cpp)
|
||||
target_sources(${OBSW_NAME} PUBLIC ObjectFactory.cpp scheduling.cpp)
|
||||
|
||||
@ -98,18 +98,11 @@ ReturnValue_t ScexUartReader::initializeInterface(CookieIF *cookie) {
|
||||
}
|
||||
// Setting up UART parameters
|
||||
tty.c_cflag &= ~PARENB; // Clear parity bit
|
||||
if (uartCookie->getStopBits() == StopBits::TWO_STOP_BITS) {
|
||||
// Use two stop bits
|
||||
tty.c_cflag |= CSTOPB;
|
||||
} else {
|
||||
// Clear stop field, only one stop bit used in communication
|
||||
tty.c_cflag &= ~CSTOPB;
|
||||
}
|
||||
|
||||
tty.c_cflag &= ~CSIZE; // Clear all the size bits
|
||||
tty.c_cflag |= CS8; // 8 bits per byte
|
||||
tty.c_cflag &= ~CRTSCTS; // Disable RTS/CTS hardware flow control
|
||||
tty.c_cflag |= CREAD | CLOCAL; // Turn on READ & ignore ctrl lines (CLOCAL = 1)
|
||||
uart::setStopbits(tty, uartCookie->getStopBits());
|
||||
uart::setBitsPerWord(tty, BitsPerWord::BITS_8);
|
||||
tty.c_cflag &= ~CRTSCTS; // Disable RTS/CTS hardware flow control
|
||||
uart::enableRead(tty);
|
||||
uart::ignoreCtrlLines(tty);
|
||||
|
||||
// Use non-canonical mode and clear echo flag
|
||||
tty.c_lflag &= ~(ICANON | ECHO);
|
||||
|
||||
@ -1,6 +1,7 @@
|
||||
#ifndef MPSOC_RETURN_VALUES_IF_H_
|
||||
#define MPSOC_RETURN_VALUES_IF_H_
|
||||
|
||||
#include "eive/resultClassIds.h"
|
||||
#include "fsfw/returnvalues/returnvalue.h"
|
||||
|
||||
class MPSoCReturnValuesIF {
|
||||
|
||||
@ -153,7 +153,7 @@ class TcBase : public ploc::SpTcBase, public MPSoCReturnValuesIF {
|
||||
*/
|
||||
TcBase(ploc::SpTcParams params, uint16_t apid, uint16_t sequenceCount)
|
||||
: ploc::SpTcBase(params, apid, sequenceCount) {
|
||||
spParams.setDataFieldLen(INIT_LENGTH);
|
||||
spParams.setFullPayloadLen(INIT_LENGTH);
|
||||
}
|
||||
|
||||
ReturnValue_t buildPacket() { return buildPacket(nullptr, 0); }
|
||||
@ -181,7 +181,7 @@ class TcBase : public ploc::SpTcBase, public MPSoCReturnValuesIF {
|
||||
if (res != returnvalue::OK) {
|
||||
return res;
|
||||
}
|
||||
return calcCrc();
|
||||
return calcAndSetCrc();
|
||||
}
|
||||
|
||||
protected:
|
||||
@ -206,7 +206,7 @@ class TcMemRead : public TcBase {
|
||||
*/
|
||||
TcMemRead(ploc::SpTcParams params, uint16_t sequenceCount)
|
||||
: TcBase(params, apid::TC_MEM_READ, sequenceCount) {
|
||||
spParams.setPayloadLen(COMMAND_LENGTH);
|
||||
spParams.setFullPayloadLen(COMMAND_LENGTH + CRC_SIZE);
|
||||
}
|
||||
|
||||
uint16_t getMemLen() const { return memLen; }
|
||||
@ -267,7 +267,7 @@ class TcMemWrite : public TcBase {
|
||||
}
|
||||
uint16_t memLen =
|
||||
*(commandData + MEM_ADDRESS_SIZE) << 8 | *(commandData + MEM_ADDRESS_SIZE + 1);
|
||||
spParams.setPayloadLen(MIN_FIXED_PAYLOAD_LENGTH + memLen * 4);
|
||||
spParams.setFullPayloadLen(MIN_FIXED_PAYLOAD_LENGTH + memLen * 4 + CRC_SIZE);
|
||||
result = checkPayloadLen();
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
@ -313,7 +313,7 @@ class FlashFopen : public ploc::SpTcBase {
|
||||
ReturnValue_t createPacket(std::string filename, char accessMode_) {
|
||||
accessMode = accessMode_;
|
||||
size_t nameSize = filename.size();
|
||||
spParams.setPayloadLen(nameSize + sizeof(NULL_TERMINATOR) + sizeof(accessMode));
|
||||
spParams.setFullPayloadLen(nameSize + sizeof(NULL_TERMINATOR) + sizeof(accessMode) + CRC_SIZE);
|
||||
ReturnValue_t result = checkPayloadLen();
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
@ -322,7 +322,7 @@ class FlashFopen : public ploc::SpTcBase {
|
||||
*(spParams.buf + nameSize) = NULL_TERMINATOR;
|
||||
std::memcpy(payloadStart + nameSize + sizeof(NULL_TERMINATOR), &accessMode, sizeof(accessMode));
|
||||
updateSpFields();
|
||||
return calcCrc();
|
||||
return calcAndSetCrc();
|
||||
}
|
||||
|
||||
private:
|
||||
@ -339,14 +339,14 @@ class FlashFclose : public ploc::SpTcBase {
|
||||
|
||||
ReturnValue_t createPacket(std::string filename) {
|
||||
size_t nameSize = filename.size();
|
||||
spParams.setPayloadLen(nameSize + sizeof(NULL_TERMINATOR));
|
||||
spParams.setFullPayloadLen(nameSize + sizeof(NULL_TERMINATOR) + CRC_SIZE);
|
||||
ReturnValue_t result = checkPayloadLen();
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
}
|
||||
std::memcpy(payloadStart, filename.c_str(), nameSize);
|
||||
*(payloadStart + nameSize) = NULL_TERMINATOR;
|
||||
return calcCrc();
|
||||
return calcAndSetCrc();
|
||||
}
|
||||
};
|
||||
|
||||
@ -365,7 +365,7 @@ class TcFlashWrite : public ploc::SpTcBase {
|
||||
sif::debug << "FlashWrite::createPacket: Command data too big" << std::endl;
|
||||
return returnvalue::FAILED;
|
||||
}
|
||||
spParams.setPayloadLen(static_cast<uint16_t>(writeLen) + 4);
|
||||
spParams.setFullPayloadLen(static_cast<uint16_t>(writeLen) + 4 + CRC_SIZE);
|
||||
result = checkPayloadLen();
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
@ -382,7 +382,7 @@ class TcFlashWrite : public ploc::SpTcBase {
|
||||
if (res != returnvalue::OK) {
|
||||
return res;
|
||||
}
|
||||
return calcCrc();
|
||||
return calcAndSetCrc();
|
||||
}
|
||||
|
||||
private:
|
||||
@ -399,7 +399,7 @@ class TcFlashDelete : public ploc::SpTcBase {
|
||||
|
||||
ReturnValue_t buildPacket(std::string filename) {
|
||||
size_t nameSize = filename.size();
|
||||
spParams.setPayloadLen(nameSize + sizeof(NULL_TERMINATOR));
|
||||
spParams.setFullPayloadLen(nameSize + sizeof(NULL_TERMINATOR) + CRC_SIZE);
|
||||
auto res = checkPayloadLen();
|
||||
if (res != returnvalue::OK) {
|
||||
return res;
|
||||
@ -412,7 +412,7 @@ class TcFlashDelete : public ploc::SpTcBase {
|
||||
if (res != returnvalue::OK) {
|
||||
return res;
|
||||
}
|
||||
return calcCrc();
|
||||
return calcAndSetCrc();
|
||||
}
|
||||
};
|
||||
|
||||
@ -439,7 +439,7 @@ class TcReplayStart : public TcBase {
|
||||
protected:
|
||||
ReturnValue_t initPacket(const uint8_t* commandData, size_t commandDataLen) override {
|
||||
ReturnValue_t result = returnvalue::OK;
|
||||
spParams.setPayloadLen(commandDataLen);
|
||||
spParams.setFullPayloadLen(commandDataLen + CRC_SIZE);
|
||||
result = lengthCheck(commandDataLen);
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
@ -500,7 +500,7 @@ class TcDownlinkPwrOn : public TcBase {
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
}
|
||||
spParams.setPayloadLen(commandDataLen + sizeof(MAX_AMPLITUDE));
|
||||
spParams.setFullPayloadLen(commandDataLen + sizeof(MAX_AMPLITUDE) + CRC_SIZE);
|
||||
result = checkPayloadLen();
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
@ -571,7 +571,7 @@ class TcReplayWriteSeq : public TcBase {
|
||||
protected:
|
||||
ReturnValue_t initPacket(const uint8_t* commandData, size_t commandDataLen) override {
|
||||
ReturnValue_t result = returnvalue::OK;
|
||||
spParams.setPayloadLen(commandDataLen + sizeof(NULL_TERMINATOR));
|
||||
spParams.setFullPayloadLen(commandDataLen + sizeof(NULL_TERMINATOR) + CRC_SIZE);
|
||||
result = lengthCheck(commandDataLen);
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
@ -657,7 +657,8 @@ class TcCamcmdSend : public TcBase {
|
||||
return INVALID_LENGTH;
|
||||
}
|
||||
uint16_t dataLen = static_cast<uint16_t>(commandDataLen + sizeof(CARRIAGE_RETURN));
|
||||
spParams.setPayloadLen(sizeof(dataLen) + commandDataLen + sizeof(CARRIAGE_RETURN));
|
||||
spParams.setFullPayloadLen(sizeof(dataLen) + commandDataLen + sizeof(CARRIAGE_RETURN) +
|
||||
CRC_SIZE);
|
||||
auto res = checkPayloadLen();
|
||||
if (res != returnvalue::OK) {
|
||||
return res;
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,61 +0,0 @@
|
||||
#ifndef SUPV_RETURN_VALUES_IF_H_
|
||||
#define SUPV_RETURN_VALUES_IF_H_
|
||||
|
||||
#include "fsfw/returnvalues/returnvalue.h"
|
||||
|
||||
class SupvReturnValuesIF {
|
||||
public:
|
||||
static const uint8_t INTERFACE_ID = CLASS_ID::SUPV_RETURN_VALUES_IF;
|
||||
|
||||
//! [EXPORT] : [COMMENT] Space Packet received from PLOC supervisor has invalid CRC
|
||||
static const ReturnValue_t CRC_FAILURE = MAKE_RETURN_CODE(0xA0);
|
||||
//! [EXPORT] : [COMMENT] Received ACK failure reply from PLOC supervisor
|
||||
static const ReturnValue_t RECEIVED_ACK_FAILURE = MAKE_RETURN_CODE(0xA1);
|
||||
//! [EXPORT] : [COMMENT] Received execution failure reply from PLOC supervisor
|
||||
static const ReturnValue_t RECEIVED_EXE_FAILURE = MAKE_RETURN_CODE(0xA2);
|
||||
//! [EXPORT] : [COMMENT] Received space packet with invalid APID from PLOC supervisor
|
||||
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] 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(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(0xA6);
|
||||
//! [EXPORT] : [COMMENT] Received latchup config command with invalid latchup ID
|
||||
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(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(0xA9);
|
||||
//! [EXPORT] : [COMMENT] Returned when scanning for MRAM dump packets failed.
|
||||
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(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(0xAC);
|
||||
//! [EXPORT] : [COMMENT] Path to PLOC directory on SD card does not exist
|
||||
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(0xAE);
|
||||
//! [EXPORT] : [COMMENT] Received action command has invalid length
|
||||
static const ReturnValue_t INVALID_LENGTH = MAKE_RETURN_CODE(0xAF);
|
||||
//! [EXPORT] : [COMMENT] Filename too long
|
||||
static const ReturnValue_t FILENAME_TOO_LONG = MAKE_RETURN_CODE(0xB0);
|
||||
//! [EXPORT] : [COMMENT] Received update status report with invalid packet length field
|
||||
static const ReturnValue_t UPDATE_STATUS_REPORT_INVALID_LENGTH = MAKE_RETURN_CODE(0xB1);
|
||||
//! [EXPORT] : [COMMENT] Update status report does not contain expected CRC. There might be a bit
|
||||
//! flip in the update memory region.
|
||||
static const ReturnValue_t UPDATE_CRC_FAILURE = MAKE_RETURN_CODE(0xB2);
|
||||
//! [EXPORT] : [COMMENT] Supervisor helper task ist currently executing a command (wait until
|
||||
//! helper tas has finished or interrupt by sending the terminate command)
|
||||
static const ReturnValue_t SUPV_HELPER_EXECUTING = MAKE_RETURN_CODE(0xB3);
|
||||
};
|
||||
|
||||
#endif /* SUPV_RETURN_VALUES_IF_H_ */
|
||||
@ -1,4 +1,4 @@
|
||||
target_sources(
|
||||
${OBSW_NAME}
|
||||
PRIVATE PlocSupervisorHandler.cpp PlocMemoryDumper.cpp PlocMPSoCHandler.cpp
|
||||
PlocMPSoCHelper.cpp PlocSupvHelper.cpp)
|
||||
PlocMPSoCHelper.cpp PlocSupvUartMan.cpp)
|
||||
|
||||
@ -5,7 +5,12 @@
|
||||
#include <linux/devices/devicedefinitions/PlocSupervisorDefinitions.h>
|
||||
|
||||
#include "OBSWConfig.h"
|
||||
|
||||
#ifdef XIPHOS_Q7S
|
||||
#include "bsp_q7s/fs/SdCardManager.h"
|
||||
#endif
|
||||
|
||||
#include "eive/eventSubsystemIds.h"
|
||||
#include "fsfw/action/ActionHelper.h"
|
||||
#include "fsfw/action/CommandActionHelper.h"
|
||||
#include "fsfw/action/CommandsActionsIF.h"
|
||||
@ -13,7 +18,7 @@
|
||||
#include "fsfw/objectmanager/SystemObject.h"
|
||||
#include "fsfw/returnvalues/returnvalue.h"
|
||||
#include "fsfw/tasks/ExecutableObjectIF.h"
|
||||
#include "linux/fsfwconfig/objects/systemObjectList.h"
|
||||
#include "objects/systemObjectList.h"
|
||||
|
||||
/**
|
||||
* @brief Because the buffer of the linux tty driver is limited to 2 x 65535 bytes, this class is
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,9 +1,9 @@
|
||||
#ifndef MISSION_DEVICES_PLOCSUPERVISORHANDLER_H_
|
||||
#define MISSION_DEVICES_PLOCSUPERVISORHANDLER_H_
|
||||
|
||||
#include <linux/devices/ploc/PlocSupvUartMan.h>
|
||||
|
||||
#include "OBSWConfig.h"
|
||||
#include "PlocSupvHelper.h"
|
||||
#include "bsp_q7s/fs/SdCardManager.h"
|
||||
#include "devices/powerSwitcherList.h"
|
||||
#include "fsfw/devicehandlers/DeviceHandlerBase.h"
|
||||
#include "fsfw/timemanager/Countdown.h"
|
||||
@ -11,7 +11,12 @@
|
||||
#include "fsfw_hal/linux/gpio/LinuxLibgpioIF.h"
|
||||
#include "fsfw_hal/linux/serial/SerialComIF.h"
|
||||
#include "linux/devices/devicedefinitions/PlocSupervisorDefinitions.h"
|
||||
#include "linux/devices/devicedefinitions/SupvReturnValuesIF.h"
|
||||
|
||||
#ifdef XIPHOS_Q7S
|
||||
#include "bsp_q7s/fs/SdCardManager.h"
|
||||
#endif
|
||||
|
||||
using supv::ExecutionReport;
|
||||
|
||||
/**
|
||||
* @brief This is the device handler for the supervisor of the PLOC which is programmed by
|
||||
@ -27,9 +32,8 @@
|
||||
*/
|
||||
class PlocSupervisorHandler : public DeviceHandlerBase {
|
||||
public:
|
||||
PlocSupervisorHandler(object_id_t objectId, object_id_t uartComIFid, CookieIF* comCookie,
|
||||
Gpio uartIsolatorSwitch, power::Switch_t powerSwitch,
|
||||
PlocSupvHelper* supvHelper);
|
||||
PlocSupervisorHandler(object_id_t objectId, CookieIF* comCookie, Gpio uartIsolatorSwitch,
|
||||
power::Switch_t powerSwitch, PlocSupvUartManager& supvHelper);
|
||||
virtual ~PlocSupervisorHandler();
|
||||
|
||||
virtual ReturnValue_t initialize() override;
|
||||
@ -48,7 +52,6 @@ class PlocSupervisorHandler : public DeviceHandlerBase {
|
||||
ReturnValue_t scanForReply(const uint8_t* start, size_t remainingSize, DeviceCommandId_t* foundId,
|
||||
size_t* foundLen) override;
|
||||
ReturnValue_t interpretDeviceReply(DeviceCommandId_t id, const uint8_t* packet) override;
|
||||
void setNormalDatapoolEntriesInvalid() override;
|
||||
uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override;
|
||||
ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
|
||||
LocalDataPoolManager& poolManager) override;
|
||||
@ -64,18 +67,21 @@ class PlocSupervisorHandler : public DeviceHandlerBase {
|
||||
|
||||
//! [EXPORT] : [COMMENT] PLOC supervisor crc failure in telemetry packet
|
||||
static const Event SUPV_MEMORY_READ_RPT_CRC_FAILURE = MAKE_EVENT(1, severity::LOW);
|
||||
//! [EXPORT] : [COMMENT] Unhandled event. P1: APID, P2: Service ID
|
||||
static constexpr Event SUPV_UNKNOWN_TM = MAKE_EVENT(2, severity::LOW);
|
||||
static constexpr Event SUPV_UNINIMPLEMENTED_TM = MAKE_EVENT(3, severity::LOW);
|
||||
//! [EXPORT] : [COMMENT] PLOC supervisor received acknowledgment failure report
|
||||
static const Event SUPV_ACK_FAILURE = MAKE_EVENT(2, severity::LOW);
|
||||
static const Event SUPV_ACK_FAILURE = MAKE_EVENT(4, severity::LOW);
|
||||
//! [EXPORT] : [COMMENT] PLOC received execution failure report
|
||||
//! P1: ID of command for which the execution failed
|
||||
//! P2: Status code sent by the supervisor handler
|
||||
static const Event SUPV_EXE_FAILURE = MAKE_EVENT(3, severity::LOW);
|
||||
static const Event SUPV_EXE_FAILURE = MAKE_EVENT(5, severity::LOW);
|
||||
//! [EXPORT] : [COMMENT] PLOC supervisor reply has invalid crc
|
||||
static const Event SUPV_CRC_FAILURE_EVENT = MAKE_EVENT(4, severity::LOW);
|
||||
static const Event SUPV_CRC_FAILURE_EVENT = MAKE_EVENT(6, severity::LOW);
|
||||
//! [EXPORT] : [COMMENT] Supervisor helper currently executing a command
|
||||
static const Event SUPV_HELPER_EXECUTING = MAKE_EVENT(5, severity::LOW);
|
||||
static const Event SUPV_HELPER_EXECUTING = MAKE_EVENT(7, severity::LOW);
|
||||
//! [EXPORT] : [COMMENT] Failed to build the command to shutdown the MPSoC
|
||||
static const Event SUPV_MPSOC_SHUWDOWN_BUILD_FAILED = MAKE_EVENT(5, severity::LOW);
|
||||
static const Event SUPV_MPSOC_SHUWDOWN_BUILD_FAILED = MAKE_EVENT(8, severity::LOW);
|
||||
|
||||
static const uint16_t APID_MASK = 0x7FF;
|
||||
static const uint16_t PACKET_SEQUENCE_COUNT_MASK = 0x3FFF;
|
||||
@ -101,7 +107,7 @@ class PlocSupervisorHandler : public DeviceHandlerBase {
|
||||
|
||||
uint8_t commandBuffer[supv::MAX_COMMAND_SIZE];
|
||||
SpacePacketCreator creator;
|
||||
ploc::SpTcParams spParams = ploc::SpTcParams(creator);
|
||||
supv::TcParams spParams = supv::TcParams(creator);
|
||||
|
||||
/**
|
||||
* This variable is used to store the id of the next reply to receive. This is necessary
|
||||
@ -121,8 +127,9 @@ class PlocSupervisorHandler : public DeviceHandlerBase {
|
||||
supv::AdcReport adcReport;
|
||||
|
||||
const power::Switch_t powerSwitch = power::NO_SWITCH;
|
||||
supv::TmBase tmReader;
|
||||
|
||||
PlocSupvHelper* supvHelper = nullptr;
|
||||
PlocSupvUartManager& uartManager;
|
||||
MessageQueueIF* eventQueue = nullptr;
|
||||
|
||||
/** Number of expected replies following the MRAM dump command */
|
||||
@ -136,9 +143,9 @@ class PlocSupervisorHandler : public DeviceHandlerBase {
|
||||
/** This buffer is used to concatenate space packets received in two different read steps */
|
||||
uint8_t spacePacketBuffer[supv::MAX_PACKET_SIZE];
|
||||
|
||||
#ifndef TE0720_1CFA
|
||||
#ifdef XIPHOS_Q7S
|
||||
SdCardManager* sdcMan = nullptr;
|
||||
#endif /* BOARD_TE0720 == 0 */
|
||||
#endif
|
||||
|
||||
// Path to supervisor specific files on SD card
|
||||
std::string supervisorFilePath = "ploc/supervisor";
|
||||
@ -210,7 +217,8 @@ class PlocSupervisorHandler : public DeviceHandlerBase {
|
||||
ReturnValue_t handleBootStatusReport(const uint8_t* data);
|
||||
|
||||
ReturnValue_t handleLatchupStatusReport(const uint8_t* data);
|
||||
ReturnValue_t handleLoggingReport(const uint8_t* data);
|
||||
void handleBadApidServiceCombination(Event result, unsigned int apid, unsigned int serviceId);
|
||||
// ReturnValue_t handleLoggingReport(const uint8_t* data);
|
||||
ReturnValue_t handleAdcReport(const uint8_t* data);
|
||||
|
||||
/**
|
||||
@ -229,13 +237,13 @@ class PlocSupervisorHandler : public DeviceHandlerBase {
|
||||
* @param dataSize Size of telemetry in bytes.
|
||||
* @param replyId Id of the reply. This will be added to the ActionMessage.
|
||||
*/
|
||||
void handleDeviceTM(const uint8_t* data, size_t dataSize, DeviceCommandId_t replyId);
|
||||
void handleDeviceTm(const uint8_t* data, size_t dataSize, DeviceCommandId_t replyId);
|
||||
|
||||
/**
|
||||
* @brief This function prepares a space packet which does not transport any data in the
|
||||
* packet data field apart from the crc.
|
||||
*/
|
||||
ReturnValue_t prepareEmptyCmd(uint16_t apid);
|
||||
ReturnValue_t prepareEmptyCmd(uint16_t apid, uint8_t serviceId);
|
||||
|
||||
/**
|
||||
* @brief This function initializes the space packet to select the boot image of the MPSoC.
|
||||
@ -258,6 +266,8 @@ class PlocSupervisorHandler : public DeviceHandlerBase {
|
||||
|
||||
ReturnValue_t prepareRestartTriesCmd(const uint8_t* commandData);
|
||||
|
||||
ReturnValue_t prepareFactoryResetCmd(const uint8_t* commandData, size_t len);
|
||||
|
||||
/**
|
||||
* @brief This function fills the command buffer with the packet to enable or disable the
|
||||
* watchdogs on the PLOC.
|
||||
@ -278,11 +288,11 @@ class PlocSupervisorHandler : public DeviceHandlerBase {
|
||||
ReturnValue_t prepareSetAdcThresholdCmd(const uint8_t* commandData);
|
||||
ReturnValue_t prepareRunAutoEmTest(const uint8_t* commandData);
|
||||
ReturnValue_t prepareWipeMramCmd(const uint8_t* commandData);
|
||||
ReturnValue_t prepareDumpMramCmd(const uint8_t* commandData);
|
||||
// ReturnValue_t prepareDumpMramCmd(const uint8_t* commandData);
|
||||
ReturnValue_t prepareSetGpioCmd(const uint8_t* commandData);
|
||||
ReturnValue_t prepareReadGpioCmd(const uint8_t* commandData);
|
||||
ReturnValue_t prepareLoggingRequest(const uint8_t* commandData, size_t commandDataLen);
|
||||
ReturnValue_t prepareEnableNvmsCommand(const uint8_t* commandData);
|
||||
// ReturnValue_t prepareLoggingRequest(const uint8_t* commandData, size_t commandDataLen);
|
||||
// ReturnValue_t prepareEnableNvmsCommand(const uint8_t* commandData);
|
||||
|
||||
/**
|
||||
* @brief Copies the content of a space packet to the command buffer.
|
||||
@ -317,7 +327,7 @@ class PlocSupervisorHandler : public DeviceHandlerBase {
|
||||
* @brief Function is called in scanForReply and fills the spacePacketBuffer with the read
|
||||
* data until a full packet has been received.
|
||||
*/
|
||||
ReturnValue_t parseMramPackets(const uint8_t* packet, size_t remainingSize, size_t* foundlen);
|
||||
// ReturnValue_t parseMramPackets(const uint8_t* packet, size_t remainingSize, size_t* foundlen);
|
||||
|
||||
/**
|
||||
* @brief This function generates the Service 8 packets for the MRAM dump data.
|
||||
@ -335,7 +345,7 @@ class PlocSupervisorHandler : public DeviceHandlerBase {
|
||||
* @brief Function checks if the packet written to the space packet buffer is really a
|
||||
* MRAM dump packet.
|
||||
*/
|
||||
ReturnValue_t checkMramPacketApid();
|
||||
// ReturnValue_t checkMramPacketApid();
|
||||
|
||||
/**
|
||||
* @brief Writes the data of the MRAM dump to a file. The file will be created when receiving
|
||||
@ -373,8 +383,8 @@ class PlocSupervisorHandler : public DeviceHandlerBase {
|
||||
supv::UpdateParams& params);
|
||||
ReturnValue_t eventSubscription();
|
||||
|
||||
ReturnValue_t handleExecutionSuccessReport(const uint8_t* data);
|
||||
void handleExecutionFailureReport(uint16_t statusCode);
|
||||
ReturnValue_t handleExecutionSuccessReport(ExecutionReport& report);
|
||||
void handleExecutionFailureReport(ExecutionReport& report);
|
||||
|
||||
void printAckFailureInfo(uint16_t statusCode, DeviceCommandId_t commandId);
|
||||
};
|
||||
|
||||
@ -1,803 +0,0 @@
|
||||
#include "PlocSupvHelper.h"
|
||||
|
||||
#include <etl/crc16_ccitt.h>
|
||||
#include <fsfw/filesystem/HasFileSystemIF.h>
|
||||
|
||||
#include <cmath>
|
||||
#include <filesystem>
|
||||
#include <fstream>
|
||||
|
||||
#include "OBSWConfig.h"
|
||||
#ifdef XIPHOS_Q7S
|
||||
#include "bsp_q7s/fs/FilesystemHelper.h"
|
||||
#include "bsp_q7s/fs/SdCardManager.h"
|
||||
#endif
|
||||
|
||||
#include "fsfw/tasks/TaskFactory.h"
|
||||
#include "fsfw/timemanager/Countdown.h"
|
||||
#include "mission/utility/Filenaming.h"
|
||||
#include "mission/utility/ProgressPrinter.h"
|
||||
#include "mission/utility/Timestamp.h"
|
||||
|
||||
PlocSupvHelper::PlocSupvHelper(object_id_t objectId) : SystemObject(objectId) {
|
||||
spParams.maxSize = sizeof(commandBuffer);
|
||||
resetSpParams();
|
||||
}
|
||||
|
||||
PlocSupvHelper::~PlocSupvHelper() {}
|
||||
|
||||
ReturnValue_t PlocSupvHelper::initialize() {
|
||||
#ifdef XIPHOS_Q7S
|
||||
sdcMan = SdCardManager::instance();
|
||||
if (sdcMan == nullptr) {
|
||||
sif::warning << "PlocSupvHelper::initialize: Invalid SD Card Manager" << std::endl;
|
||||
return returnvalue::FAILED;
|
||||
}
|
||||
#endif
|
||||
return returnvalue::OK;
|
||||
}
|
||||
|
||||
ReturnValue_t PlocSupvHelper::performOperation(uint8_t operationCode) {
|
||||
ReturnValue_t result = returnvalue::OK;
|
||||
semaphore.acquire();
|
||||
while (true) {
|
||||
switch (internalState) {
|
||||
case InternalState::IDLE: {
|
||||
semaphore.acquire();
|
||||
break;
|
||||
}
|
||||
case InternalState::UPDATE: {
|
||||
result = executeUpdate();
|
||||
if (result == returnvalue::OK) {
|
||||
triggerEvent(SUPV_UPDATE_SUCCESSFUL, result);
|
||||
} else if (result == PROCESS_TERMINATED) {
|
||||
// Event already triggered
|
||||
} else {
|
||||
triggerEvent(SUPV_UPDATE_FAILED, result);
|
||||
}
|
||||
internalState = InternalState::IDLE;
|
||||
break;
|
||||
}
|
||||
case InternalState::CHECK_MEMORY: {
|
||||
executeFullCheckMemoryCommand();
|
||||
internalState = InternalState::IDLE;
|
||||
break;
|
||||
}
|
||||
case InternalState::CONTINUE_UPDATE: {
|
||||
result = continueUpdate();
|
||||
if (result == returnvalue::OK) {
|
||||
triggerEvent(SUPV_CONTINUE_UPDATE_SUCCESSFUL, result);
|
||||
} else if (result == PROCESS_TERMINATED) {
|
||||
// Event already triggered
|
||||
} else {
|
||||
triggerEvent(SUPV_CONTINUE_UPDATE_FAILED, result);
|
||||
}
|
||||
internalState = InternalState::IDLE;
|
||||
break;
|
||||
}
|
||||
case InternalState::REQUEST_EVENT_BUFFER: {
|
||||
result = performEventBufferRequest();
|
||||
if (result == returnvalue::OK) {
|
||||
triggerEvent(SUPV_EVENT_BUFFER_REQUEST_SUCCESSFUL, result);
|
||||
} else if (result == PROCESS_TERMINATED) {
|
||||
// Event already triggered
|
||||
break;
|
||||
} else {
|
||||
triggerEvent(SUPV_EVENT_BUFFER_REQUEST_FAILED, result);
|
||||
}
|
||||
internalState = InternalState::IDLE;
|
||||
break;
|
||||
}
|
||||
default:
|
||||
sif::debug << "PlocSupvHelper::performOperation: Invalid state" << std::endl;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
ReturnValue_t PlocSupvHelper::setComIF(SerialComIF* uartComIF_) {
|
||||
if (uartComIF_ == nullptr) {
|
||||
sif::warning << "PlocSupvHelper::initialize: Provided invalid uart com if" << std::endl;
|
||||
return returnvalue::FAILED;
|
||||
}
|
||||
uartComIF = uartComIF_;
|
||||
return returnvalue::OK;
|
||||
}
|
||||
|
||||
void PlocSupvHelper::setComCookie(CookieIF* comCookie_) { comCookie = comCookie_; }
|
||||
|
||||
ReturnValue_t PlocSupvHelper::startUpdate(std::string file, uint8_t memoryId,
|
||||
uint32_t startAddress) {
|
||||
supv::UpdateParams params;
|
||||
params.file = file;
|
||||
params.memId = memoryId;
|
||||
params.startAddr = startAddress;
|
||||
params.bytesWritten = 0;
|
||||
params.seqCount = 1;
|
||||
params.deleteMemory = true;
|
||||
return performUpdate(params);
|
||||
}
|
||||
|
||||
ReturnValue_t PlocSupvHelper::performUpdate(const supv::UpdateParams& params) {
|
||||
ReturnValue_t result = returnvalue::OK;
|
||||
#ifdef XIPHOS_Q7S
|
||||
result = FilesystemHelper::checkPath(params.file);
|
||||
if (result != returnvalue::OK) {
|
||||
sif::warning << "PlocSupvHelper::startUpdate: File " << params.file << " does not exist"
|
||||
<< std::endl;
|
||||
return result;
|
||||
}
|
||||
result = FilesystemHelper::fileExists(params.file);
|
||||
if (result != returnvalue::OK) {
|
||||
sif::warning << "PlocSupvHelper::startUpdate: The file " << params.file << " does not exist"
|
||||
<< std::endl;
|
||||
return result;
|
||||
}
|
||||
#endif
|
||||
#ifdef TE0720_1CFA
|
||||
if (not std::filesystem::exists(file)) {
|
||||
sif::warning << "PlocSupvHelper::startUpdate: The file " << file << " does not exist"
|
||||
<< std::endl;
|
||||
return returnvalue::FAILED;
|
||||
}
|
||||
#endif
|
||||
update.file = params.file;
|
||||
update.fullFileSize = getFileSize(update.file);
|
||||
if (params.bytesWritten > update.fullFileSize) {
|
||||
sif::warning << "Invalid start bytes counter " << params.bytesWritten
|
||||
<< ", smaller than full file length" << update.fullFileSize << std::endl;
|
||||
return returnvalue::FAILED;
|
||||
}
|
||||
update.length = update.fullFileSize - params.bytesWritten;
|
||||
update.memoryId = params.memId;
|
||||
update.startAddress = params.startAddr;
|
||||
update.progressPercent = 0;
|
||||
update.bytesWritten = params.bytesWritten;
|
||||
update.crcShouldBeChecked = true;
|
||||
update.packetNum = 1;
|
||||
update.deleteMemory = params.deleteMemory;
|
||||
update.sequenceCount = params.seqCount;
|
||||
internalState = InternalState::UPDATE;
|
||||
uartComIF->flushUartTxAndRxBuf(comCookie);
|
||||
semaphore.release();
|
||||
return result;
|
||||
}
|
||||
|
||||
ReturnValue_t PlocSupvHelper::performMemCheck(std::string file, uint8_t memoryId,
|
||||
uint32_t startAddress) {
|
||||
update.file = file;
|
||||
update.fullFileSize = getFileSize(file);
|
||||
return performMemCheck(memoryId, startAddress, getFileSize(update.file), true);
|
||||
}
|
||||
|
||||
ReturnValue_t PlocSupvHelper::performMemCheck(uint8_t memoryId, uint32_t startAddress,
|
||||
size_t sizeToCheck, bool checkCrc) {
|
||||
update.memoryId = memoryId;
|
||||
update.startAddress = startAddress;
|
||||
update.length = sizeToCheck;
|
||||
update.crcShouldBeChecked = checkCrc;
|
||||
internalState = InternalState::CHECK_MEMORY;
|
||||
uartComIF->flushUartTxAndRxBuf(comCookie);
|
||||
semaphore.release();
|
||||
return returnvalue::OK;
|
||||
}
|
||||
|
||||
void PlocSupvHelper::initiateUpdateContinuation() {
|
||||
internalState = InternalState::CONTINUE_UPDATE;
|
||||
semaphore.release();
|
||||
}
|
||||
|
||||
ReturnValue_t PlocSupvHelper::startEventbBufferRequest(std::string path) {
|
||||
#ifdef XIPHOS_Q7S
|
||||
ReturnValue_t result = FilesystemHelper::checkPath(path);
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
}
|
||||
#endif
|
||||
if (not std::filesystem::exists(path)) {
|
||||
return PATH_NOT_EXISTS;
|
||||
}
|
||||
eventBufferReq.path = path;
|
||||
internalState = InternalState::REQUEST_EVENT_BUFFER;
|
||||
uartComIF->flushUartTxAndRxBuf(comCookie);
|
||||
semaphore.release();
|
||||
return returnvalue::OK;
|
||||
}
|
||||
|
||||
void PlocSupvHelper::stopProcess() { terminate = true; }
|
||||
|
||||
void PlocSupvHelper::executeFullCheckMemoryCommand() {
|
||||
ReturnValue_t result;
|
||||
if (update.crcShouldBeChecked) {
|
||||
sif::info << "PLOC SUPV Mem Check: Calculating Image CRC" << std::endl;
|
||||
result = calcImageCrc();
|
||||
if (result != returnvalue::OK) {
|
||||
triggerEvent(SUPV_MEM_CHECK_FAIL, result);
|
||||
return;
|
||||
}
|
||||
}
|
||||
sif::info << "PLOC SUPV Mem Check: Selecting Memory" << std::endl;
|
||||
result = selectMemory();
|
||||
if (result != returnvalue::OK) {
|
||||
triggerEvent(SUPV_MEM_CHECK_FAIL, result);
|
||||
return;
|
||||
}
|
||||
sif::info << "PLOC SUPV Mem Check: Preparing Update" << std::endl;
|
||||
result = prepareUpdate();
|
||||
if (result != returnvalue::OK) {
|
||||
triggerEvent(SUPV_MEM_CHECK_FAIL, result);
|
||||
return;
|
||||
}
|
||||
sif::info << "PLOC SUPV Mem Check: Memory Check" << std::endl;
|
||||
result = handleCheckMemoryCommand();
|
||||
if (result == returnvalue::OK) {
|
||||
triggerEvent(SUPV_MEM_CHECK_OK, result);
|
||||
} else {
|
||||
triggerEvent(SUPV_MEM_CHECK_FAIL, result);
|
||||
}
|
||||
}
|
||||
|
||||
ReturnValue_t PlocSupvHelper::executeUpdate() {
|
||||
ReturnValue_t result = returnvalue::OK;
|
||||
sif::info << "PLOC SUPV Update MPSoC: Calculating Image CRC" << std::endl;
|
||||
result = calcImageCrc();
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
}
|
||||
sif::info << "PLOC SUPV Update MPSoC: Selecting Memory" << std::endl;
|
||||
result = selectMemory();
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
}
|
||||
sif::info << "PLOC SUPV Update MPSoC: Preparing Update" << std::endl;
|
||||
result = prepareUpdate();
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
}
|
||||
if (update.deleteMemory) {
|
||||
sif::info << "PLOC SUPV Update MPSoC: Erasing Memory" << std::endl;
|
||||
result = eraseMemory();
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
}
|
||||
}
|
||||
return updateOperation();
|
||||
}
|
||||
|
||||
ReturnValue_t PlocSupvHelper::continueUpdate() {
|
||||
ReturnValue_t result = prepareUpdate();
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
}
|
||||
return updateOperation();
|
||||
}
|
||||
|
||||
ReturnValue_t PlocSupvHelper::updateOperation() {
|
||||
sif::info << "PlocSupvHelper::performUpdate: Writing Update Packets" << std::endl;
|
||||
auto result = writeUpdatePackets();
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
}
|
||||
sif::info << "PlocSupvHelper::performUpdate: Memory Check" << std::endl;
|
||||
return handleCheckMemoryCommand();
|
||||
}
|
||||
|
||||
ReturnValue_t PlocSupvHelper::writeUpdatePackets() {
|
||||
ReturnValue_t result = returnvalue::OK;
|
||||
#if OBSW_DEBUG_PLOC_SUPERVISOR == 1
|
||||
ProgressPrinter progressPrinter("Supervisor update", update.fullFileSize,
|
||||
ProgressPrinter::HALF_PERCENT);
|
||||
#endif /* OBSW_DEBUG_PLOC_SUPERVISOR == 1 */
|
||||
uint8_t tempData[supv::WriteMemory::CHUNK_MAX + 1]{};
|
||||
std::ifstream file(update.file, std::ifstream::binary);
|
||||
uint16_t dataLength = 0;
|
||||
ccsds::SequenceFlags seqFlags;
|
||||
while (update.bytesWritten < update.fullFileSize) {
|
||||
if (terminate) {
|
||||
terminate = false;
|
||||
triggerEvent(TERMINATED_UPDATE_PROCEDURE);
|
||||
return PROCESS_TERMINATED;
|
||||
}
|
||||
size_t remainingSize = update.fullFileSize - update.bytesWritten;
|
||||
bool lastSegment = false;
|
||||
if (remainingSize > supv::WriteMemory::CHUNK_MAX) {
|
||||
dataLength = supv::WriteMemory::CHUNK_MAX;
|
||||
} else {
|
||||
lastSegment = true;
|
||||
dataLength = static_cast<uint16_t>(remainingSize);
|
||||
}
|
||||
if (file.is_open()) {
|
||||
file.seekg(update.bytesWritten, std::ios::beg);
|
||||
file.read(reinterpret_cast<char*>(tempData), dataLength);
|
||||
if (!file) {
|
||||
sif::warning << "PlocSupvHelper::performUpdate: Read only " << file.gcount() << " of "
|
||||
<< dataLength << " bytes" << std::endl;
|
||||
sif::info << "PlocSupvHelper::performUpdate: Failed when trying to read byte "
|
||||
<< update.bytesWritten << std::endl;
|
||||
}
|
||||
} else {
|
||||
return FILE_CLOSED_ACCIDENTALLY;
|
||||
}
|
||||
if (update.bytesWritten == 0) {
|
||||
seqFlags = ccsds::SequenceFlags::FIRST_SEGMENT;
|
||||
} else if (lastSegment) {
|
||||
seqFlags = ccsds::SequenceFlags::LAST_SEGMENT;
|
||||
} else {
|
||||
seqFlags = ccsds::SequenceFlags::CONTINUATION;
|
||||
}
|
||||
resetSpParams();
|
||||
float progress = static_cast<float>(update.bytesWritten) / update.fullFileSize;
|
||||
uint8_t progPercent = std::floor(progress * 100);
|
||||
if (progPercent > update.progressPercent) {
|
||||
update.progressPercent = progPercent;
|
||||
if (progPercent % 5 == 0) {
|
||||
// Useful to allow restarting the update
|
||||
triggerEvent(SUPV_UPDATE_PROGRESS, buildProgParams1(progPercent, update.sequenceCount),
|
||||
update.bytesWritten);
|
||||
}
|
||||
}
|
||||
supv::WriteMemory packet(spParams);
|
||||
result = packet.buildPacket(seqFlags, update.sequenceCount, update.memoryId,
|
||||
update.startAddress + update.bytesWritten, dataLength, tempData);
|
||||
if (result != returnvalue::OK) {
|
||||
triggerEvent(WRITE_MEMORY_FAILED, buildProgParams1(progPercent, update.sequenceCount),
|
||||
update.bytesWritten);
|
||||
return result;
|
||||
}
|
||||
result = handlePacketTransmission(packet);
|
||||
if (result != returnvalue::OK) {
|
||||
triggerEvent(WRITE_MEMORY_FAILED, buildProgParams1(progPercent, update.sequenceCount),
|
||||
update.bytesWritten);
|
||||
return result;
|
||||
}
|
||||
update.sequenceCount++;
|
||||
update.packetNum += 1;
|
||||
update.bytesWritten += dataLength;
|
||||
|
||||
#if OBSW_DEBUG_PLOC_SUPERVISOR == 1
|
||||
progressPrinter.print(update.bytesWritten);
|
||||
#endif /* OBSW_DEBUG_PLOC_SUPERVISOR == 1 */
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
uint32_t PlocSupvHelper::buildProgParams1(uint8_t percent, uint16_t seqCount) {
|
||||
return (static_cast<uint32_t>(percent) << 24) | static_cast<uint32_t>(seqCount);
|
||||
}
|
||||
|
||||
ReturnValue_t PlocSupvHelper::performEventBufferRequest() {
|
||||
using namespace supv;
|
||||
ReturnValue_t result = returnvalue::OK;
|
||||
resetSpParams();
|
||||
RequestLoggingData packet(spParams);
|
||||
result = packet.buildPacket(RequestLoggingData::Sa::REQUEST_EVENT_BUFFERS);
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
}
|
||||
result = sendCommand(packet);
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
}
|
||||
result = handleAck();
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
}
|
||||
result =
|
||||
handleTmReception(ccsds::HEADER_LEN, tmBuf.data(), supv::recv_timeout::UPDATE_STATUS_REPORT);
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
}
|
||||
ploc::SpTmReader spReader(tmBuf.data(), tmBuf.size());
|
||||
bool exeAlreadyReceived = false;
|
||||
if (spReader.getApid() == supv::APID_EXE_FAILURE) {
|
||||
exeAlreadyReceived = true;
|
||||
result = handleRemainingExeReport(spReader);
|
||||
} else if (spReader.getApid() == supv::APID_MRAM_DUMP_TM) {
|
||||
result = handleEventBufferReception(spReader);
|
||||
}
|
||||
|
||||
if (not exeAlreadyReceived) {
|
||||
result = handleExe();
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
ReturnValue_t PlocSupvHelper::handleRemainingExeReport(ploc::SpTmReader& reader) {
|
||||
size_t remBytes = reader.getPacketDataLen() + 1;
|
||||
ReturnValue_t result = handleTmReception(remBytes, tmBuf.data() + ccsds::HEADER_LEN);
|
||||
if (result != returnvalue::OK) {
|
||||
sif::warning << "Reading exe failure report failed" << std::endl;
|
||||
}
|
||||
result = exeReportHandling();
|
||||
if (result != returnvalue::OK) {
|
||||
sif::warning << "Handling exe report failed" << std::endl;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
ReturnValue_t PlocSupvHelper::selectMemory() {
|
||||
ReturnValue_t result = returnvalue::OK;
|
||||
resetSpParams();
|
||||
supv::MPSoCBootSelect packet(spParams);
|
||||
result = packet.buildPacket(update.memoryId);
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
}
|
||||
result = handlePacketTransmission(packet);
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
}
|
||||
return returnvalue::OK;
|
||||
}
|
||||
|
||||
ReturnValue_t PlocSupvHelper::prepareUpdate() {
|
||||
ReturnValue_t result = returnvalue::OK;
|
||||
resetSpParams();
|
||||
supv::ApidOnlyPacket packet(spParams, supv::APID_PREPARE_UPDATE);
|
||||
result = packet.buildPacket();
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
}
|
||||
result = handlePacketTransmission(packet, PREPARE_UPDATE_EXECUTION_REPORT);
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
}
|
||||
return returnvalue::OK;
|
||||
}
|
||||
|
||||
ReturnValue_t PlocSupvHelper::eraseMemory() {
|
||||
ReturnValue_t result = returnvalue::OK;
|
||||
resetSpParams();
|
||||
supv::EraseMemory eraseMemory(spParams);
|
||||
result = eraseMemory.buildPacket(update.memoryId, update.startAddress + update.bytesWritten,
|
||||
update.length);
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
}
|
||||
result = handlePacketTransmission(eraseMemory, supv::recv_timeout::ERASE_MEMORY);
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
}
|
||||
return returnvalue::OK;
|
||||
}
|
||||
|
||||
ReturnValue_t PlocSupvHelper::handlePacketTransmission(ploc::SpTcBase& packet,
|
||||
uint32_t timeoutExecutionReport) {
|
||||
ReturnValue_t result = returnvalue::OK;
|
||||
result = sendCommand(packet);
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
}
|
||||
result = handleAck();
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
}
|
||||
result = handleExe(timeoutExecutionReport);
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
}
|
||||
return returnvalue::OK;
|
||||
}
|
||||
|
||||
ReturnValue_t PlocSupvHelper::sendCommand(ploc::SpTcBase& packet) {
|
||||
ReturnValue_t result = returnvalue::OK;
|
||||
rememberApid = packet.getApid();
|
||||
result = uartComIF->sendMessage(comCookie, packet.getFullPacket(), packet.getFullPacketLen());
|
||||
if (result != returnvalue::OK) {
|
||||
sif::warning << "PlocSupvHelper::sendCommand: Failed to send command" << std::endl;
|
||||
triggerEvent(SUPV_SENDING_COMMAND_FAILED, result, static_cast<uint32_t>(internalState));
|
||||
return result;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
ReturnValue_t PlocSupvHelper::handleAck() {
|
||||
ReturnValue_t result = returnvalue::OK;
|
||||
|
||||
result = handleTmReception(supv::SIZE_ACK_REPORT);
|
||||
if (result != returnvalue::OK) {
|
||||
triggerEvent(ACK_RECEPTION_FAILURE, result, static_cast<uint32_t>(rememberApid));
|
||||
sif::warning << "PlocSupvHelper::handleAck: Error in reception of acknowledgment report"
|
||||
<< std::endl;
|
||||
return result;
|
||||
}
|
||||
supv::AcknowledgmentReport ackReport(tmBuf.data(), tmBuf.size());
|
||||
result = checkReceivedTm(ackReport);
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
}
|
||||
result = ackReport.checkApid();
|
||||
if (result != returnvalue::OK) {
|
||||
if (result == SupvReturnValuesIF::RECEIVED_ACK_FAILURE) {
|
||||
triggerEvent(SUPV_ACK_FAILURE_REPORT, static_cast<uint32_t>(ackReport.getRefApid()));
|
||||
} else if (result == SupvReturnValuesIF::INVALID_APID) {
|
||||
triggerEvent(SUPV_ACK_INVALID_APID, static_cast<uint32_t>(rememberApid));
|
||||
}
|
||||
return result;
|
||||
}
|
||||
return returnvalue::OK;
|
||||
}
|
||||
|
||||
ReturnValue_t PlocSupvHelper::handleExe(uint32_t timeout) {
|
||||
ReturnValue_t result = returnvalue::OK;
|
||||
|
||||
result = handleTmReception(supv::SIZE_EXE_REPORT, tmBuf.data(), timeout);
|
||||
if (result != returnvalue::OK) {
|
||||
triggerEvent(EXE_RECEPTION_FAILURE, result, static_cast<uint32_t>(rememberApid));
|
||||
sif::warning << "PlocSupvHelper::handleExe: Error in reception of execution report"
|
||||
<< std::endl;
|
||||
return result;
|
||||
}
|
||||
|
||||
return exeReportHandling();
|
||||
}
|
||||
|
||||
ReturnValue_t PlocSupvHelper::exeReportHandling() {
|
||||
supv::ExecutionReport exeReport(tmBuf.data(), tmBuf.size());
|
||||
|
||||
ReturnValue_t result = checkReceivedTm(exeReport);
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
}
|
||||
result = exeReport.checkApid();
|
||||
if (result != returnvalue::OK) {
|
||||
if (result == SupvReturnValuesIF::RECEIVED_EXE_FAILURE) {
|
||||
triggerEvent(SUPV_EXE_FAILURE_REPORT, static_cast<uint32_t>(exeReport.getRefApid()));
|
||||
} else if (result == SupvReturnValuesIF::INVALID_APID) {
|
||||
triggerEvent(SUPV_EXE_INVALID_APID, static_cast<uint32_t>(rememberApid));
|
||||
}
|
||||
return result;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
ReturnValue_t PlocSupvHelper::handleTmReception(size_t remainingBytes, uint8_t* readBuf,
|
||||
uint32_t timeout) {
|
||||
ReturnValue_t result = returnvalue::OK;
|
||||
size_t readBytes = 0;
|
||||
size_t currentBytes = 0;
|
||||
Countdown countdown(timeout);
|
||||
if (readBuf == nullptr) {
|
||||
readBuf = tmBuf.data();
|
||||
}
|
||||
while (!countdown.hasTimedOut()) {
|
||||
result = receive(readBuf + readBytes, ¤tBytes, remainingBytes);
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
}
|
||||
readBytes += currentBytes;
|
||||
remainingBytes = remainingBytes - currentBytes;
|
||||
if (remainingBytes == 0) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (remainingBytes != 0) {
|
||||
sif::warning << "PlocSupvHelper::handleTmReception: Failed to read " << std::dec
|
||||
<< remainingBytes << " remaining bytes" << std::endl;
|
||||
return returnvalue::FAILED;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
ReturnValue_t PlocSupvHelper::checkReceivedTm(ploc::SpTmReader& reader) {
|
||||
ReturnValue_t result = reader.checkSize();
|
||||
if (result != returnvalue::OK) {
|
||||
triggerEvent(SUPV_REPLY_SIZE_MISSMATCH, rememberApid);
|
||||
return result;
|
||||
}
|
||||
result = reader.checkCrc();
|
||||
if (result != returnvalue::OK) {
|
||||
triggerEvent(SUPV_REPLY_CRC_MISSMATCH, rememberApid);
|
||||
return result;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
ReturnValue_t PlocSupvHelper::receive(uint8_t* data, size_t* readBytes, size_t requestBytes) {
|
||||
ReturnValue_t result = returnvalue::OK;
|
||||
uint8_t* buffer = nullptr;
|
||||
result = uartComIF->requestReceiveMessage(comCookie, requestBytes);
|
||||
if (result != returnvalue::OK) {
|
||||
sif::warning << "PlocSupvHelper::receive: Failed to request reply" << std::endl;
|
||||
triggerEvent(SUPV_HELPER_REQUESTING_REPLY_FAILED, result,
|
||||
static_cast<uint32_t>(static_cast<uint32_t>(internalState)));
|
||||
return returnvalue::FAILED;
|
||||
}
|
||||
result = uartComIF->readReceivedMessage(comCookie, &buffer, readBytes);
|
||||
if (result != returnvalue::OK) {
|
||||
sif::warning << "PlocSupvHelper::receive: Failed to read received message" << std::endl;
|
||||
triggerEvent(SUPV_HELPER_READING_REPLY_FAILED, result, static_cast<uint32_t>(internalState));
|
||||
return returnvalue::FAILED;
|
||||
}
|
||||
if (*readBytes > 0) {
|
||||
std::memcpy(data, buffer, *readBytes);
|
||||
} else {
|
||||
TaskFactory::delayTask(40);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
ReturnValue_t PlocSupvHelper::calcImageCrc() {
|
||||
ReturnValue_t result = returnvalue::OK;
|
||||
if (update.fullFileSize == 0) {
|
||||
return returnvalue::FAILED;
|
||||
}
|
||||
#ifdef XIPHOS_Q7S
|
||||
result = FilesystemHelper::checkPath(update.file);
|
||||
if (result != returnvalue::OK) {
|
||||
sif::warning << "PlocSupvHelper::calcImageCrc: File " << update.file << " does not exist"
|
||||
<< std::endl;
|
||||
return result;
|
||||
}
|
||||
#endif
|
||||
|
||||
auto crc16Calcer = etl::crc16_ccitt();
|
||||
std::ifstream file(update.file, std::ifstream::binary);
|
||||
std::array<uint8_t, 1025> crcBuf{};
|
||||
#if OBSW_DEBUG_PLOC_SUPERVISOR == 1
|
||||
ProgressPrinter progress("Supervisor update crc calculation", update.fullFileSize,
|
||||
ProgressPrinter::ONE_PERCENT);
|
||||
#endif /* OBSW_DEBUG_PLOC_SUPERVISOR == 1 */
|
||||
uint32_t byteCount = 0;
|
||||
size_t bytesToRead = 1024;
|
||||
while (byteCount < update.fullFileSize) {
|
||||
size_t remLen = update.fullFileSize - byteCount;
|
||||
if (remLen < 1024) {
|
||||
bytesToRead = remLen;
|
||||
} else {
|
||||
bytesToRead = 1024;
|
||||
}
|
||||
file.seekg(byteCount, file.beg);
|
||||
file.read(reinterpret_cast<char*>(crcBuf.data()), bytesToRead);
|
||||
crc16Calcer.add(crcBuf.begin(), crcBuf.begin() + bytesToRead);
|
||||
|
||||
#if OBSW_DEBUG_PLOC_SUPERVISOR == 1
|
||||
progress.print(byteCount);
|
||||
#endif /* OBSW_DEBUG_PLOC_SUPERVISOR == 1 */
|
||||
byteCount += bytesToRead;
|
||||
}
|
||||
#if OBSW_DEBUG_PLOC_SUPERVISOR == 1
|
||||
progress.print(byteCount);
|
||||
#endif /* OBSW_DEBUG_PLOC_SUPERVISOR == 1 */
|
||||
update.crc = crc16Calcer.value();
|
||||
return result;
|
||||
}
|
||||
|
||||
ReturnValue_t PlocSupvHelper::handleCheckMemoryCommand() {
|
||||
ReturnValue_t result = returnvalue::OK;
|
||||
resetSpParams();
|
||||
// Will hold status report for later processing
|
||||
std::array<uint8_t, 32> statusReportBuf{};
|
||||
supv::UpdateStatusReport updateStatusReport(tmBuf.data(), tmBuf.size());
|
||||
// Verification of update write procedure
|
||||
supv::CheckMemory packet(spParams);
|
||||
result = packet.buildPacket(update.memoryId, update.startAddress, update.fullFileSize);
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
}
|
||||
result = sendCommand(packet);
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
}
|
||||
result = handleAck();
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
}
|
||||
|
||||
bool exeAlreadyHandled = false;
|
||||
uint32_t timeout = std::max(CRC_EXECUTION_TIMEOUT, supv::recv_timeout::UPDATE_STATUS_REPORT);
|
||||
result = handleTmReception(ccsds::HEADER_LEN, tmBuf.data(), timeout);
|
||||
ploc::SpTmReader spReader(tmBuf.data(), tmBuf.size());
|
||||
if (spReader.getApid() == supv::APID_EXE_FAILURE) {
|
||||
exeAlreadyHandled = true;
|
||||
result = handleRemainingExeReport(spReader);
|
||||
} else if (spReader.getApid() == supv::APID_UPDATE_STATUS_REPORT) {
|
||||
size_t remBytes = spReader.getPacketDataLen() + 1;
|
||||
result = handleTmReception(remBytes, tmBuf.data() + ccsds::HEADER_LEN,
|
||||
supv::recv_timeout::UPDATE_STATUS_REPORT);
|
||||
if (result != returnvalue::OK) {
|
||||
sif::warning
|
||||
<< "PlocSupvHelper::handleCheckMemoryCommand: Failed to receive update status report"
|
||||
<< std::endl;
|
||||
return result;
|
||||
}
|
||||
result = updateStatusReport.checkCrc();
|
||||
if (result != returnvalue::OK) {
|
||||
sif::warning << "PlocSupvHelper::handleCheckMemoryCommand: CRC check failed" << std::endl;
|
||||
return result;
|
||||
}
|
||||
// Copy into other buffer because data will be overwritten when reading execution report
|
||||
std::memcpy(statusReportBuf.data(), tmBuf.data(), updateStatusReport.getNominalSize());
|
||||
}
|
||||
|
||||
if (not exeAlreadyHandled) {
|
||||
result = handleExe(CRC_EXECUTION_TIMEOUT);
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
}
|
||||
}
|
||||
|
||||
// Now process the status report
|
||||
updateStatusReport.setData(statusReportBuf.data(), statusReportBuf.size());
|
||||
result = updateStatusReport.parseDataField();
|
||||
if (result != returnvalue::OK) {
|
||||
return result;
|
||||
}
|
||||
if (update.crcShouldBeChecked) {
|
||||
result = updateStatusReport.verifycrc(update.crc);
|
||||
if (result != returnvalue::OK) {
|
||||
sif::warning << "PlocSupvHelper::handleCheckMemoryCommand: CRC failure. Expected CRC 0x"
|
||||
<< std::setfill('0') << std::hex << std::setw(4)
|
||||
<< static_cast<uint16_t>(update.crc) << " but received CRC 0x" << std::setw(4)
|
||||
<< updateStatusReport.getCrc() << std::dec << std::endl;
|
||||
return result;
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
uint32_t PlocSupvHelper::getFileSize(std::string filename) {
|
||||
std::ifstream file(filename, std::ifstream::binary);
|
||||
file.seekg(0, file.end);
|
||||
uint32_t size = file.tellg();
|
||||
file.close();
|
||||
return size;
|
||||
}
|
||||
|
||||
ReturnValue_t PlocSupvHelper::handleEventBufferReception(ploc::SpTmReader& reader) {
|
||||
ReturnValue_t result = returnvalue::OK;
|
||||
#ifdef XIPHOS_Q7S
|
||||
if (not sdcMan->getActiveSdCard()) {
|
||||
return HasFileSystemIF::FILESYSTEM_INACTIVE;
|
||||
}
|
||||
#endif
|
||||
std::string filename = Filenaming::generateAbsoluteFilename(
|
||||
eventBufferReq.path, eventBufferReq.filename, timestamping);
|
||||
std::ofstream file(filename, std::ios_base::app | std::ios_base::out);
|
||||
uint32_t packetsRead = 0;
|
||||
size_t requestLen = 0;
|
||||
bool firstPacket = true;
|
||||
for (packetsRead = 0; packetsRead < NUM_EVENT_BUFFER_PACKETS; packetsRead++) {
|
||||
if (terminate) {
|
||||
triggerEvent(SUPV_EVENT_BUFFER_REQUEST_TERMINATED, packetsRead - 1);
|
||||
file.close();
|
||||
return PROCESS_TERMINATED;
|
||||
}
|
||||
if (packetsRead == NUM_EVENT_BUFFER_PACKETS - 1) {
|
||||
requestLen = SIZE_EVENT_BUFFER_LAST_PACKET;
|
||||
} else {
|
||||
requestLen = SIZE_EVENT_BUFFER_FULL_PACKET;
|
||||
}
|
||||
if (firstPacket) {
|
||||
firstPacket = false;
|
||||
requestLen -= 6;
|
||||
}
|
||||
result = handleTmReception(requestLen);
|
||||
if (result != returnvalue::OK) {
|
||||
sif::debug << "PlocSupvHelper::handleEventBufferReception: Failed while trying to read packet"
|
||||
<< " " << packetsRead + 1 << std::endl;
|
||||
file.close();
|
||||
return result;
|
||||
}
|
||||
ReturnValue_t result = reader.checkCrc();
|
||||
if (result != returnvalue::OK) {
|
||||
triggerEvent(SUPV_REPLY_CRC_MISSMATCH, rememberApid);
|
||||
return result;
|
||||
}
|
||||
uint16_t apid = reader.getApid();
|
||||
if (apid != supv::APID_MRAM_DUMP_TM) {
|
||||
sif::warning << "PlocSupvHelper::handleEventBufferReception: Did not expect space packet "
|
||||
<< "with APID 0x" << std::hex << apid << std::endl;
|
||||
file.close();
|
||||
return EVENT_BUFFER_REPLY_INVALID_APID;
|
||||
}
|
||||
file.write(reinterpret_cast<const char*>(reader.getPacketData()),
|
||||
reader.getPayloadDataLength());
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
void PlocSupvHelper::resetSpParams() { spParams.buf = commandBuffer; }
|
||||
1160
linux/devices/ploc/PlocSupvUartMan.cpp
Normal file
1160
linux/devices/ploc/PlocSupvUartMan.cpp
Normal file
File diff suppressed because it is too large
Load Diff
@ -1,9 +1,13 @@
|
||||
#ifndef BSP_Q7S_DEVICES_PLOCSUPVHELPER_H_
|
||||
#define BSP_Q7S_DEVICES_PLOCSUPVHELPER_H_
|
||||
|
||||
#include <fsfw/container/SimpleRingBuffer.h>
|
||||
#include <termios.h>
|
||||
|
||||
#include <string>
|
||||
|
||||
#include "OBSWConfig.h"
|
||||
#include "fsfw/container/FIFO.h"
|
||||
#include "fsfw/devicehandlers/CookieIF.h"
|
||||
#include "fsfw/objectmanager/SystemObject.h"
|
||||
#include "fsfw/osal/linux/BinarySemaphore.h"
|
||||
@ -11,6 +15,7 @@
|
||||
#include "fsfw/tasks/ExecutableObjectIF.h"
|
||||
#include "fsfw_hal/linux/serial/SerialComIF.h"
|
||||
#include "linux/devices/devicedefinitions/PlocSupervisorDefinitions.h"
|
||||
#include "tas/crc.h"
|
||||
|
||||
#ifdef XIPHOS_Q7S
|
||||
#include "bsp_q7s/fs/SdCardManager.h"
|
||||
@ -21,8 +26,21 @@
|
||||
* the supervisor and the OBC.
|
||||
* @author J. Meier
|
||||
*/
|
||||
class PlocSupvHelper : public SystemObject, public ExecutableObjectIF {
|
||||
class PlocSupvUartManager : public DeviceCommunicationIF,
|
||||
public SystemObject,
|
||||
public ExecutableObjectIF {
|
||||
public:
|
||||
static const uint8_t INTERFACE_ID = CLASS_ID::PLOC_SUPV_HELPER;
|
||||
|
||||
//! [EXPORT] : [COMMENT] File accidentally close
|
||||
static const ReturnValue_t FILE_CLOSED_ACCIDENTALLY = MAKE_RETURN_CODE(0xA0);
|
||||
//! [EXPORT] : [COMMENT] Process has been terminated by command
|
||||
static const ReturnValue_t PROCESS_TERMINATED = MAKE_RETURN_CODE(0xA1);
|
||||
//! [EXPORT] : [COMMENT] Received command with invalid pathname
|
||||
static const ReturnValue_t PATH_NOT_EXISTS = MAKE_RETURN_CODE(0xA2);
|
||||
//! [EXPORT] : [COMMENT] Expected event buffer TM but received space packet with other APID
|
||||
static const ReturnValue_t EVENT_BUFFER_REPLY_INVALID_APID = MAKE_RETURN_CODE(0xA3);
|
||||
|
||||
static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PLOC_SUPV_HELPER;
|
||||
|
||||
//! [EXPORT] : [COMMENT] update failed
|
||||
@ -97,16 +115,15 @@ class PlocSupvHelper : public SystemObject, public ExecutableObjectIF {
|
||||
//! [EXPORT] : [COMMENT] Will be triggered every 5 percent of the update progress.
|
||||
//! P1: First byte percent, third and fourth byte Sequence Count, P2: Bytes written
|
||||
static constexpr Event SUPV_UPDATE_PROGRESS = MAKE_EVENT(30, severity::INFO);
|
||||
static constexpr Event HDLC_FRAME_REMOVAL_ERROR = MAKE_EVENT(31, severity::INFO);
|
||||
static constexpr Event HDLC_CRC_ERROR = MAKE_EVENT(32, severity::INFO);
|
||||
|
||||
PlocSupvHelper(object_id_t objectId);
|
||||
virtual ~PlocSupvHelper();
|
||||
PlocSupvUartManager(object_id_t objectId);
|
||||
virtual ~PlocSupvUartManager();
|
||||
|
||||
ReturnValue_t initialize() override;
|
||||
ReturnValue_t performOperation(uint8_t operationCode = 0) override;
|
||||
|
||||
ReturnValue_t setComIF(SerialComIF* uartComfIF_);
|
||||
void setComCookie(CookieIF* comCookie_);
|
||||
|
||||
/**
|
||||
* @brief Starts update procedure
|
||||
*
|
||||
@ -119,38 +136,41 @@ class PlocSupvHelper : public SystemObject, public ExecutableObjectIF {
|
||||
ReturnValue_t performUpdate(const supv::UpdateParams& params);
|
||||
ReturnValue_t startUpdate(std::string file, uint8_t memoryId, uint32_t startAddress);
|
||||
|
||||
ReturnValue_t performMemCheck(uint8_t memoryId, uint32_t startAddress, size_t sizeToCheck,
|
||||
bool checkCrc);
|
||||
ReturnValue_t performMemCheck(std::string file, uint8_t memoryId, uint32_t startAddress,
|
||||
size_t sizeToCheck, bool checkCrc);
|
||||
ReturnValue_t performMemCheck(std::string file, uint8_t memoryId, uint32_t startAddress);
|
||||
|
||||
/**
|
||||
* @brief This initiate the continuation of a failed update.
|
||||
*/
|
||||
void initiateUpdateContinuation();
|
||||
ReturnValue_t initiateUpdateContinuation();
|
||||
|
||||
/**
|
||||
* @brief Calling this function will initiate the procedure to request the event buffer
|
||||
*/
|
||||
ReturnValue_t startEventbBufferRequest(std::string path);
|
||||
// ReturnValue_t startEventBufferRequest(std::string path);
|
||||
|
||||
/**
|
||||
* @brief Can be used to interrupt a running data transfer.
|
||||
* @brief Can be used to stop the UART reception and put the task to sleep
|
||||
*/
|
||||
void stopProcess();
|
||||
void stop();
|
||||
|
||||
/**
|
||||
* @brief Can be used to start the UART reception
|
||||
*/
|
||||
void start();
|
||||
|
||||
static uint32_t buildProgParams1(uint8_t percent, uint16_t seqCount);
|
||||
static uint32_t buildApidServiceParam1(uint8_t apid, uint8_t serviceId);
|
||||
|
||||
private:
|
||||
static const uint8_t INTERFACE_ID = CLASS_ID::PLOC_SUPV_HELPER;
|
||||
|
||||
//! [EXPORT] : [COMMENT] File accidentally close
|
||||
static const ReturnValue_t FILE_CLOSED_ACCIDENTALLY = MAKE_RETURN_CODE(0xA0);
|
||||
//! [EXPORT] : [COMMENT] Process has been terminated by command
|
||||
static const ReturnValue_t PROCESS_TERMINATED = MAKE_RETURN_CODE(0xA1);
|
||||
//! [EXPORT] : [COMMENT] Received command with invalid pathname
|
||||
static const ReturnValue_t PATH_NOT_EXISTS = MAKE_RETURN_CODE(0xA2);
|
||||
//! [EXPORT] : [COMMENT] Expected event buffer TM but received space packet with other APID
|
||||
static const ReturnValue_t EVENT_BUFFER_REPLY_INVALID_APID = MAKE_RETURN_CODE(0xA3);
|
||||
static constexpr ReturnValue_t REQUEST_DONE = returnvalue::makeCode(1, 0);
|
||||
static constexpr ReturnValue_t NO_PACKET_FOUND = returnvalue::makeCode(1, 1);
|
||||
static constexpr ReturnValue_t DECODE_BUF_TOO_SMALL = returnvalue::makeCode(1, 2);
|
||||
static constexpr ReturnValue_t POSSIBLE_PACKET_LOSS_CONSECUTIVE_START =
|
||||
returnvalue::makeCode(1, 3);
|
||||
static constexpr ReturnValue_t POSSIBLE_PACKET_LOSS_CONSECUTIVE_END = returnvalue::makeCode(1, 4);
|
||||
static constexpr ReturnValue_t HDLC_ERROR = returnvalue::makeCode(1, 5);
|
||||
|
||||
static const uint16_t CRC16_INIT = 0xFFFF;
|
||||
// Event buffer reply will carry 24 space packets with 1016 bytes and one space packet with
|
||||
@ -158,19 +178,22 @@ class PlocSupvHelper : public SystemObject, public ExecutableObjectIF {
|
||||
static const uint8_t NUM_EVENT_BUFFER_PACKETS = 25;
|
||||
static const size_t SIZE_EVENT_BUFFER_FULL_PACKET = 1024;
|
||||
static const size_t SIZE_EVENT_BUFFER_LAST_PACKET = 200;
|
||||
static const uint32_t CRC_EXECUTION_TIMEOUT = 60000;
|
||||
static const uint32_t PREPARE_UPDATE_EXECUTION_REPORT = 2000;
|
||||
|
||||
static constexpr uint8_t MAX_STORED_DECODED_PACKETS = 4;
|
||||
static constexpr uint8_t HDLC_START_MARKER = 0x7E;
|
||||
static constexpr uint8_t HDLC_END_MARKER = 0x7C;
|
||||
|
||||
struct Update {
|
||||
uint8_t memoryId;
|
||||
uint32_t startAddress;
|
||||
// Absolute name of file containing update data
|
||||
std::string file;
|
||||
// Length of full file
|
||||
size_t fullFileSize;
|
||||
size_t fullFileSize = 0;
|
||||
// Size of update
|
||||
uint32_t length;
|
||||
uint32_t crc;
|
||||
uint32_t length = 0;
|
||||
uint32_t crc = 0;
|
||||
bool crcShouldBeChecked = true;
|
||||
size_t bytesWritten;
|
||||
uint32_t packetNum;
|
||||
@ -181,6 +204,13 @@ class PlocSupvHelper : public SystemObject, public ExecutableObjectIF {
|
||||
|
||||
struct Update update;
|
||||
|
||||
SemaphoreIF* semaphore;
|
||||
MutexIF* lock;
|
||||
MutexIF* ipcLock;
|
||||
supv::TmBase tmReader;
|
||||
int serialPort = 0;
|
||||
struct termios tty = {};
|
||||
|
||||
struct EventBufferRequest {
|
||||
std::string path = "";
|
||||
// Default name of file where event buffer data will be written to. Timestamp will be added to
|
||||
@ -190,54 +220,64 @@ class PlocSupvHelper : public SystemObject, public ExecutableObjectIF {
|
||||
|
||||
EventBufferRequest eventBufferReq;
|
||||
|
||||
enum class InternalState { IDLE, UPDATE, CONTINUE_UPDATE, REQUEST_EVENT_BUFFER, CHECK_MEMORY };
|
||||
enum class InternalState { SLEEPING, DEFAULT, DEDICATED_REQUEST, GO_TO_SLEEP };
|
||||
|
||||
InternalState internalState = InternalState::IDLE;
|
||||
enum class Request {
|
||||
DEFAULT,
|
||||
UPDATE,
|
||||
CONTINUE_UPDATE,
|
||||
REQUEST_EVENT_BUFFER,
|
||||
CHECK_MEMORY,
|
||||
};
|
||||
InternalState state = InternalState::SLEEPING;
|
||||
Request request = Request::DEFAULT;
|
||||
|
||||
BinarySemaphore semaphore;
|
||||
#ifdef XIPHOS_Q7S
|
||||
SdCardManager* sdcMan = nullptr;
|
||||
#endif
|
||||
uint8_t commandBuffer[supv::MAX_COMMAND_SIZE]{};
|
||||
SimpleRingBuffer recRingBuf;
|
||||
std::array<uint8_t, 1200> cmdBuf = {};
|
||||
std::array<uint8_t, 2048> encodedSendBuf = {};
|
||||
std::array<uint8_t, 2048> recBuf = {};
|
||||
std::array<uint8_t, 2048> encodedBuf = {};
|
||||
std::array<uint8_t, 1200> decodedBuf = {};
|
||||
std::array<uint8_t, 1200> ipcBuffer = {};
|
||||
SimpleRingBuffer decodedRingBuf;
|
||||
FIFO<size_t, MAX_STORED_DECODED_PACKETS> decodedQueue;
|
||||
SimpleRingBuffer ipcRingBuf;
|
||||
FIFO<size_t, MAX_STORED_DECODED_PACKETS> ipcQueue;
|
||||
|
||||
SpacePacketCreator creator;
|
||||
ploc::SpTcParams spParams = ploc::SpTcParams(creator);
|
||||
supv::TcParams spParams = supv::TcParams(creator);
|
||||
|
||||
std::array<uint8_t, supv::MAX_COMMAND_SIZE> tmBuf{};
|
||||
|
||||
bool terminate = false;
|
||||
|
||||
/**
|
||||
* Communication interface responsible for data transactions between OBC and Supervisor.
|
||||
*/
|
||||
SerialComIF* uartComIF = nullptr;
|
||||
// Communication cookie. Must be set by the supervisor Handler
|
||||
CookieIF* comCookie = nullptr;
|
||||
|
||||
bool debugMode = false;
|
||||
bool timestamping = true;
|
||||
|
||||
// Remembers APID to know at which command a procedure failed
|
||||
uint16_t rememberApid = 0;
|
||||
|
||||
ReturnValue_t handleRunningLongerRequest();
|
||||
bool handleUartReception();
|
||||
void addHdlcFraming(const uint8_t* src, size_t slen, uint8_t* dst, size_t* dlen, size_t maxDest);
|
||||
int removeHdlcFramingWithCrcCheck(const uint8_t* src, size_t slen, uint8_t* dst, size_t* dlen);
|
||||
|
||||
ReturnValue_t encodeAndSendPacket(const uint8_t* sendData, size_t sendLen);
|
||||
void executeFullCheckMemoryCommand();
|
||||
|
||||
ReturnValue_t tryHdlcParsing();
|
||||
ReturnValue_t parseRecRingBufForHdlc(size_t& readSize, size_t& decodedLen);
|
||||
ReturnValue_t executeUpdate();
|
||||
ReturnValue_t continueUpdate();
|
||||
ReturnValue_t updateOperation();
|
||||
ReturnValue_t writeUpdatePackets();
|
||||
ReturnValue_t performEventBufferRequest();
|
||||
ReturnValue_t handlePacketTransmission(ploc::SpTcBase& packet,
|
||||
uint32_t timeoutExecutionReport = 60000);
|
||||
ReturnValue_t sendCommand(ploc::SpTcBase& packet);
|
||||
/**
|
||||
* @brief Function which reads form the communication interface
|
||||
*
|
||||
* @param data Pointer to buffer where read data will be written to
|
||||
* @param raedBytes Actual number of bytes read
|
||||
* @param requestBytes Number of bytes to read
|
||||
*/
|
||||
ReturnValue_t receive(uint8_t* data, size_t* readBytes, size_t requestBytes);
|
||||
ReturnValue_t handleAck();
|
||||
ReturnValue_t handleExe(uint32_t timeout = 1000);
|
||||
// ReturnValue_t performEventBufferRequest();
|
||||
ReturnValue_t handlePacketTransmissionNoReply(supv::TcBase& packet,
|
||||
uint32_t timeoutExecutionReport = 60000);
|
||||
int handleAckReception(supv::TcBase& tc, uint8_t serviceId, size_t packetLen);
|
||||
int handleExeAckReception(supv::TcBase& tc, uint8_t serviceId, size_t packetLen);
|
||||
|
||||
/**
|
||||
* @brief Handles reading of TM packets from the communication interface
|
||||
*
|
||||
@ -250,7 +290,7 @@ class PlocSupvHelper : public SystemObject, public ExecutableObjectIF {
|
||||
*/
|
||||
ReturnValue_t handleTmReception(size_t remainingBytes, uint8_t* readBuf = nullptr,
|
||||
uint32_t timeout = 70000);
|
||||
ReturnValue_t checkReceivedTm(ploc::SpTmReader& reader);
|
||||
ReturnValue_t checkReceivedTm();
|
||||
|
||||
ReturnValue_t selectMemory();
|
||||
ReturnValue_t prepareUpdate();
|
||||
@ -272,6 +312,61 @@ class PlocSupvHelper : public SystemObject, public ExecutableObjectIF {
|
||||
ReturnValue_t handleRemainingExeReport(ploc::SpTmReader& reader);
|
||||
|
||||
void resetSpParams();
|
||||
void pushIpcData(const uint8_t* data, size_t len);
|
||||
|
||||
/**
|
||||
* @brief Device specific initialization, using the cookie.
|
||||
* @details
|
||||
* The cookie is already prepared in the factory. If the communication
|
||||
* interface needs to be set up in some way and requires cookie information,
|
||||
* this can be performed in this function, which is called on device handler
|
||||
* initialization.
|
||||
* @param cookie
|
||||
* @return
|
||||
* - @c returnvalue::OK if initialization was successfull
|
||||
* - Everything else triggers failure event with returnvalue as parameter 1
|
||||
*/
|
||||
ReturnValue_t initializeInterface(CookieIF* cookie) override;
|
||||
|
||||
/**
|
||||
* Called by DHB in the SEND_WRITE doSendWrite().
|
||||
* This function is used to send data to the physical device
|
||||
* by implementing and calling related drivers or wrapper functions.
|
||||
* @param cookie
|
||||
* @param data
|
||||
* @param len If this is 0, nothing shall be sent.
|
||||
* @return
|
||||
* - @c returnvalue::OK for successfull send
|
||||
* - Everything else triggers failure event with returnvalue as parameter 1
|
||||
*/
|
||||
ReturnValue_t sendMessage(CookieIF* cookie, const uint8_t* sendData, size_t sendLen) override;
|
||||
/**
|
||||
* Called by DHB in the GET_WRITE doGetWrite().
|
||||
* Get send confirmation that the data in sendMessage() was sent successfully.
|
||||
* @param cookie
|
||||
* @return
|
||||
* - @c returnvalue::OK if data was sent successfully but a reply is expected
|
||||
* - NO_REPLY_EXPECTED if data was sent successfully and no reply is expected
|
||||
* - Everything else to indicate failure
|
||||
*/
|
||||
ReturnValue_t getSendSuccess(CookieIF* cookie) override;
|
||||
/**
|
||||
* Called by DHB in the SEND_WRITE doSendRead().
|
||||
* It is assumed that it is always possible to request a reply
|
||||
* from a device. If a requestLen of 0 is supplied, no reply was enabled
|
||||
* and communication specific action should be taken (e.g. read nothing
|
||||
* or read everything).
|
||||
*
|
||||
* @param cookie
|
||||
* @param requestLen Size of data to read
|
||||
* @return - @c returnvalue::OK to confirm the request for data has been sent.
|
||||
* - Everything else triggers failure event with
|
||||
* returnvalue as parameter 1
|
||||
*/
|
||||
ReturnValue_t requestReceiveMessage(CookieIF* cookie, size_t requestLen) override;
|
||||
ReturnValue_t readReceivedMessage(CookieIF* cookie, uint8_t** buffer, size_t* size) override;
|
||||
|
||||
void performUartShutdown();
|
||||
};
|
||||
|
||||
#endif /* BSP_Q7S_DEVICES_PLOCSUPVHELPER_H_ */
|
||||
@ -1,6 +1,7 @@
|
||||
#ifndef BSP_Q7S_DEVICES_ARCSECDATALINKLAYER_H_
|
||||
#define BSP_Q7S_DEVICES_ARCSECDATALINKLAYER_H_
|
||||
|
||||
#include "eive/resultClassIds.h"
|
||||
#include "fsfw/returnvalues/returnvalue.h"
|
||||
#include "linux/devices/devicedefinitions/StarTrackerDefinitions.h"
|
||||
|
||||
|
||||
@ -5,6 +5,7 @@
|
||||
#include <fstream>
|
||||
#include <nlohmann/json.hpp>
|
||||
|
||||
#include "eive/resultClassIds.h"
|
||||
#include "fsfw/returnvalues/returnvalue.h"
|
||||
#include "linux/devices/devicedefinitions/StarTrackerDefinitions.h"
|
||||
|
||||
|
||||
@ -1591,7 +1591,7 @@ void StarTrackerHandler::preparePowerRequest() {
|
||||
|
||||
void StarTrackerHandler::prepareSwitchToBootloaderCmd() {
|
||||
uint32_t length = 0;
|
||||
struct RebootActionRequest rebootReq;
|
||||
struct RebootActionRequest rebootReq {};
|
||||
arc_pack_reboot_action_req(&rebootReq, commandBuffer, &length);
|
||||
dataLinkLayer.encodeFrame(commandBuffer, length);
|
||||
rawPacket = dataLinkLayer.getEncodedFrame();
|
||||
|
||||
@ -1 +0,0 @@
|
||||
#include "addresses.h"
|
||||
@ -1,7 +1,7 @@
|
||||
/**
|
||||
* @brief Auto-generated event translation file. Contains 234 translations.
|
||||
* @brief Auto-generated event translation file. Contains 239 translations.
|
||||
* @details
|
||||
* Generated on: 2022-11-14 17:10:10
|
||||
* Generated on: 2022-11-16 15:25:08
|
||||
*/
|
||||
#include "translateEvents.h"
|
||||
|
||||
@ -129,9 +129,12 @@ const char *RESET_OCCURED_STRING = "RESET_OCCURED";
|
||||
const char *BOOTING_FIRMWARE_FAILED_STRING = "BOOTING_FIRMWARE_FAILED";
|
||||
const char *BOOTING_BOOTLOADER_FAILED_STRING = "BOOTING_BOOTLOADER_FAILED";
|
||||
const char *SUPV_MEMORY_READ_RPT_CRC_FAILURE_STRING = "SUPV_MEMORY_READ_RPT_CRC_FAILURE";
|
||||
const char *SUPV_UNKNOWN_TM_STRING = "SUPV_UNKNOWN_TM";
|
||||
const char *SUPV_UNINIMPLEMENTED_TM_STRING = "SUPV_UNINIMPLEMENTED_TM";
|
||||
const char *SUPV_ACK_FAILURE_STRING = "SUPV_ACK_FAILURE";
|
||||
const char *SUPV_EXE_FAILURE_STRING = "SUPV_EXE_FAILURE";
|
||||
const char *SUPV_CRC_FAILURE_EVENT_STRING = "SUPV_CRC_FAILURE_EVENT";
|
||||
const char *SUPV_HELPER_EXECUTING_STRING = "SUPV_HELPER_EXECUTING";
|
||||
const char *SUPV_MPSOC_SHUWDOWN_BUILD_FAILED_STRING = "SUPV_MPSOC_SHUWDOWN_BUILD_FAILED";
|
||||
const char *SANITIZATION_FAILED_STRING = "SANITIZATION_FAILED";
|
||||
const char *MOUNTED_SD_CARD_STRING = "MOUNTED_SD_CARD";
|
||||
@ -222,6 +225,8 @@ const char *WRITE_MEMORY_FAILED_STRING = "WRITE_MEMORY_FAILED";
|
||||
const char *SUPV_REPLY_SIZE_MISSMATCH_STRING = "SUPV_REPLY_SIZE_MISSMATCH";
|
||||
const char *SUPV_REPLY_CRC_MISSMATCH_STRING = "SUPV_REPLY_CRC_MISSMATCH";
|
||||
const char *SUPV_UPDATE_PROGRESS_STRING = "SUPV_UPDATE_PROGRESS";
|
||||
const char *HDLC_FRAME_REMOVAL_ERROR_STRING = "HDLC_FRAME_REMOVAL_ERROR";
|
||||
const char *HDLC_CRC_ERROR_STRING = "HDLC_CRC_ERROR";
|
||||
const char *ALLOC_FAILURE_STRING = "ALLOC_FAILURE";
|
||||
const char *REBOOT_SW_STRING = "REBOOT_SW";
|
||||
const char *REBOOT_MECHANISM_TRIGGERED_STRING = "REBOOT_MECHANISM_TRIGGERED";
|
||||
@ -487,12 +492,18 @@ const char *translateEvents(Event event) {
|
||||
case (12001):
|
||||
return SUPV_MEMORY_READ_RPT_CRC_FAILURE_STRING;
|
||||
case (12002):
|
||||
return SUPV_ACK_FAILURE_STRING;
|
||||
return SUPV_UNKNOWN_TM_STRING;
|
||||
case (12003):
|
||||
return SUPV_EXE_FAILURE_STRING;
|
||||
return SUPV_UNINIMPLEMENTED_TM_STRING;
|
||||
case (12004):
|
||||
return SUPV_CRC_FAILURE_EVENT_STRING;
|
||||
return SUPV_ACK_FAILURE_STRING;
|
||||
case (12005):
|
||||
return SUPV_EXE_FAILURE_STRING;
|
||||
case (12006):
|
||||
return SUPV_CRC_FAILURE_EVENT_STRING;
|
||||
case (12007):
|
||||
return SUPV_HELPER_EXECUTING_STRING;
|
||||
case (12008):
|
||||
return SUPV_MPSOC_SHUWDOWN_BUILD_FAILED_STRING;
|
||||
case (12100):
|
||||
return SANITIZATION_FAILED_STRING;
|
||||
@ -672,6 +683,10 @@ const char *translateEvents(Event event) {
|
||||
return SUPV_REPLY_CRC_MISSMATCH_STRING;
|
||||
case (13630):
|
||||
return SUPV_UPDATE_PROGRESS_STRING;
|
||||
case (13631):
|
||||
return HDLC_FRAME_REMOVAL_ERROR_STRING;
|
||||
case (13632):
|
||||
return HDLC_CRC_ERROR_STRING;
|
||||
case (13700):
|
||||
return ALLOC_FAILURE_STRING;
|
||||
case (13701):
|
||||
|
||||
@ -45,10 +45,8 @@ enum sourceObjects : uint32_t {
|
||||
ARDUINO_COM_IF = 0x49000000,
|
||||
CSP_COM_IF = 0x49050001,
|
||||
I2C_COM_IF = 0x49040002,
|
||||
UART_COM_IF = 0x49030003,
|
||||
SPI_MAIN_COM_IF = 0x49020004,
|
||||
GPIO_IF = 0x49010005,
|
||||
SCEX_UART_READER = 0x49010006,
|
||||
|
||||
/* Custom device handler */
|
||||
SPI_RW_COM_IF = 0x49020005,
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
* @brief Auto-generated object translation file.
|
||||
* @details
|
||||
* Contains 148 translations.
|
||||
* Generated on: 2022-11-14 17:10:10
|
||||
* Generated on: 2022-11-16 15:25:08
|
||||
*/
|
||||
#include "translateObjects.h"
|
||||
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
#include "InitMission.h"
|
||||
#include "scheduling.h"
|
||||
|
||||
#include <fsfw/devicehandlers/DeviceHandlerIF.h>
|
||||
#include <fsfw/tasks/PeriodicTaskIF.h>
|
||||
@ -10,7 +10,7 @@
|
||||
|
||||
void scheduling::schedulingScex(TaskFactory& factory, PeriodicTaskIF*& scexDevHandler,
|
||||
PeriodicTaskIF*& scexReaderTask) {
|
||||
using namespace initmission;
|
||||
using namespace scheduling;
|
||||
ReturnValue_t result = returnvalue::OK;
|
||||
#if OBSW_PRINT_MISSED_DEADLINES == 1
|
||||
void (*missedDeadlineFunc)(void) = TaskFactory::printMissedDeadline;
|
||||
@ -37,6 +37,17 @@ void scheduling::schedulingScex(TaskFactory& factory, PeriodicTaskIF*& scexDevHa
|
||||
printAddObjectError("SCEX_DEV", objects::SCEX);
|
||||
}
|
||||
result = scexDevHandler->addComponent(objects::SCEX, DeviceHandlerIF::GET_READ);
|
||||
if (result != returnvalue::OK) {
|
||||
printAddObjectError("SCEX_DEV", objects::SCEX);
|
||||
}
|
||||
result = scexDevHandler->addComponent(objects::SCEX, DeviceHandlerIF::SEND_READ);
|
||||
if (result != returnvalue::OK) {
|
||||
printAddObjectError("SCEX_DEV", objects::SCEX);
|
||||
}
|
||||
result = scexDevHandler->addComponent(objects::SCEX, DeviceHandlerIF::GET_READ);
|
||||
if (result != returnvalue::OK) {
|
||||
printAddObjectError("SCEX_DEV", objects::SCEX);
|
||||
}
|
||||
|
||||
result = returnvalue::OK;
|
||||
scexReaderTask = factory.createPeriodicTask(
|
||||
@ -50,17 +61,17 @@ void scheduling::schedulingScex(TaskFactory& factory, PeriodicTaskIF*& scexDevHa
|
||||
void scheduling::addMpsocSupvHandlers(PeriodicTaskIF* plTask) {
|
||||
#if OBSW_ADD_PLOC_SUPERVISOR == 1
|
||||
plTask->addComponent(objects::PLOC_SUPERVISOR_HANDLER, DeviceHandlerIF::PERFORM_OPERATION);
|
||||
plTask->addComponent(objects::PLOC_SUPERVISOR_HANDLER, DeviceHandlerIF::SEND_READ);
|
||||
plTask->addComponent(objects::PLOC_SUPERVISOR_HANDLER, DeviceHandlerIF::GET_READ);
|
||||
plTask->addComponent(objects::PLOC_SUPERVISOR_HANDLER, DeviceHandlerIF::SEND_WRITE);
|
||||
plTask->addComponent(objects::PLOC_SUPERVISOR_HANDLER, DeviceHandlerIF::GET_WRITE);
|
||||
plTask->addComponent(objects::PLOC_SUPERVISOR_HANDLER, DeviceHandlerIF::SEND_READ);
|
||||
plTask->addComponent(objects::PLOC_SUPERVISOR_HANDLER, DeviceHandlerIF::GET_READ);
|
||||
#endif
|
||||
|
||||
#if OBSW_ADD_PLOC_MPSOC == 1
|
||||
plTask->addComponent(objects::PLOC_MPSOC_HANDLER, DeviceHandlerIF::PERFORM_OPERATION);
|
||||
plTask->addComponent(objects::PLOC_MPSOC_HANDLER, DeviceHandlerIF::SEND_READ);
|
||||
plTask->addComponent(objects::PLOC_MPSOC_HANDLER, DeviceHandlerIF::GET_READ);
|
||||
plTask->addComponent(objects::PLOC_MPSOC_HANDLER, DeviceHandlerIF::SEND_WRITE);
|
||||
plTask->addComponent(objects::PLOC_MPSOC_HANDLER, DeviceHandlerIF::GET_WRITE);
|
||||
plTask->addComponent(objects::PLOC_MPSOC_HANDLER, DeviceHandlerIF::SEND_READ);
|
||||
plTask->addComponent(objects::PLOC_MPSOC_HANDLER, DeviceHandlerIF::GET_READ);
|
||||
#endif
|
||||
}
|
||||
@ -1,9 +1,9 @@
|
||||
#pragma once
|
||||
|
||||
#include <fsfw/tasks/TaskFactory.h>
|
||||
|
||||
namespace scheduling {
|
||||
void schedulingScex(TaskFactory& factory, PeriodicTaskIF*& scexDevHandler,
|
||||
PeriodicTaskIF*& scexReaderTask);
|
||||
void addMpsocSupvHandlers(PeriodicTaskIF* task);
|
||||
|
||||
} // namespace scheduling
|
||||
@ -99,12 +99,12 @@ void ObjectFactory::produceGenericObjects(HealthTableIF** healthTable_, PusTmFun
|
||||
|
||||
#if OBSW_ADD_TCPIP_BRIDGE == 1
|
||||
#if OBSW_USE_TMTC_TCP_BRIDGE == 0
|
||||
auto tcpIpTmtcBridge = new UdpTmTcBridge(objects::TMTC_BRIDGE, objects::CCSDS_PACKET_DISTRIBUTOR);
|
||||
auto tmtcBridge = new UdpTmTcBridge(objects::TMTC_BRIDGE, objects::CCSDS_PACKET_DISTRIBUTOR);
|
||||
new UdpTcPollingTask(objects::TMTC_POLLING_TASK, objects::TMTC_BRIDGE);
|
||||
sif::info << "Created UDP server for TMTC commanding with listener port "
|
||||
<< udpBridge->getUdpPort() << std::endl;
|
||||
<< tmtcBridge->getUdpPort() << std::endl;
|
||||
#else
|
||||
auto tcpIpTmtcBridge = new TcpTmTcBridge(objects::TMTC_BRIDGE, objects::CCSDS_PACKET_DISTRIBUTOR);
|
||||
auto tmtcBridge = new TcpTmTcBridge(objects::TMTC_BRIDGE, objects::CCSDS_PACKET_DISTRIBUTOR);
|
||||
auto tcpServer = new TcpTmTcServer(objects::TMTC_POLLING_TASK, objects::TMTC_BRIDGE);
|
||||
// TCP is stream based. Use packet ID as start marker when parsing for space packets
|
||||
tcpServer->setSpacePacketParsingOptions({common::PUS_PACKET_ID, common::CFDP_PACKET_ID});
|
||||
@ -114,7 +114,7 @@ void ObjectFactory::produceGenericObjects(HealthTableIF** healthTable_, PusTmFun
|
||||
tcpServer->enableWiretapping(true);
|
||||
#endif /* OBSW_TCP_SERVER_WIRETAPPING == 1 */
|
||||
#endif /* OBSW_USE_TMTC_TCP_BRIDGE == 0 */
|
||||
tcpIpTmtcBridge->setMaxNumberOfPacketsStored(150);
|
||||
tmtcBridge->setMaxNumberOfPacketsStored(150);
|
||||
#endif /* OBSW_ADD_TCPIP_BRIDGE == 1 */
|
||||
|
||||
auto* ccsdsDistrib =
|
||||
@ -124,8 +124,8 @@ void ObjectFactory::produceGenericObjects(HealthTableIF** healthTable_, PusTmFun
|
||||
*cfdpFunnel = new CfdpTmFunnel(objects::CFDP_TM_FUNNEL, config::EIVE_CFDP_APID, *tmStore, 50);
|
||||
*pusFunnel = new PusTmFunnel(objects::PUS_TM_FUNNEL, *timeStamper, *tmStore, 80);
|
||||
#if OBSW_ADD_TCPIP_BRIDGE == 1
|
||||
(*cfdpFunnel)->addDestination(*tcpIpTmtcBridge, 0);
|
||||
(*pusFunnel)->addDestination(*tcpIpTmtcBridge, 0);
|
||||
(*cfdpFunnel)->addDestination(*tmtcBridge, 0);
|
||||
(*pusFunnel)->addDestination(*tmtcBridge, 0);
|
||||
#endif
|
||||
// Every TM packet goes through this funnel
|
||||
new TmFunnelHandler(objects::TM_FUNNEL, **pusFunnel, **cfdpFunnel);
|
||||
|
||||
@ -14,43 +14,46 @@ struct SpTcParams {
|
||||
SpTcParams(SpacePacketCreator& creator, uint8_t* buf, size_t maxSize)
|
||||
: creator(creator), buf(buf), maxSize(maxSize) {}
|
||||
|
||||
void setPayloadLen(size_t payloadLen_) { dataFieldLen = payloadLen_ + 2; }
|
||||
|
||||
void setDataFieldLen(size_t dataFieldLen_) { dataFieldLen = dataFieldLen_; }
|
||||
void setFullPayloadLen(size_t fullPayloadLen_) { fullPayloadLen = fullPayloadLen_; }
|
||||
|
||||
SpacePacketCreator& creator;
|
||||
uint8_t* buf = nullptr;
|
||||
size_t maxSize = 0;
|
||||
size_t dataFieldLen = 0;
|
||||
size_t fullPayloadLen = 0;
|
||||
};
|
||||
|
||||
class SpTcBase {
|
||||
public:
|
||||
SpTcBase(SpTcParams params) : spParams(params) {
|
||||
payloadStart = spParams.buf + ccsds::HEADER_LEN;
|
||||
updateSpFields();
|
||||
}
|
||||
SpTcBase(SpTcParams params) : SpTcBase(params, 0x00, 1, 0) {}
|
||||
|
||||
SpTcBase(SpTcParams params, uint16_t apid, uint16_t seqCount) : spParams(params) {
|
||||
SpTcBase(SpTcParams params, uint16_t apid, size_t payloadLen)
|
||||
: SpTcBase(params, apid, payloadLen, 0) {}
|
||||
|
||||
SpTcBase(SpTcParams params, uint16_t apid, size_t payloadLen, uint16_t seqCount)
|
||||
: spParams(params) {
|
||||
spParams.creator.setApid(apid);
|
||||
spParams.creator.setSeqCount(seqCount);
|
||||
payloadStart = spParams.buf + ccsds::HEADER_LEN;
|
||||
spParams.fullPayloadLen = payloadLen;
|
||||
updateSpFields();
|
||||
}
|
||||
|
||||
void updateSpFields() {
|
||||
spParams.creator.setDataLenField(spParams.dataFieldLen - 1);
|
||||
updateLenFromParams();
|
||||
spParams.creator.setPacketType(ccsds::PacketType::TC);
|
||||
}
|
||||
|
||||
void updateLenFromParams() { spParams.creator.setDataLenField(spParams.fullPayloadLen - 1); }
|
||||
const uint8_t* getFullPacket() const { return spParams.buf; }
|
||||
|
||||
size_t getFullPacketLen() const { return spParams.creator.getFullPacketLen(); }
|
||||
|
||||
uint16_t getApid() const { return spParams.creator.getApid(); }
|
||||
|
||||
uint16_t getSeqCount() const { return spParams.creator.getSequenceCount(); }
|
||||
|
||||
ReturnValue_t checkPayloadLen() {
|
||||
if (ccsds::HEADER_LEN + spParams.dataFieldLen > spParams.maxSize) {
|
||||
if (ccsds::HEADER_LEN + spParams.fullPayloadLen > spParams.maxSize) {
|
||||
return SerializeIF::BUFFER_TOO_SHORT;
|
||||
}
|
||||
|
||||
@ -71,7 +74,7 @@ class SpTcBase {
|
||||
return serializeHeader();
|
||||
}
|
||||
|
||||
ReturnValue_t calcCrc() {
|
||||
ReturnValue_t calcAndSetCrc() {
|
||||
/* Calculate crc */
|
||||
uint16_t crc = CRC::crc16ccitt(spParams.buf, getFullPacketLen() - 2);
|
||||
|
||||
@ -101,12 +104,7 @@ class SpTmReader : public SpacePacketReader {
|
||||
return setReadOnlyData(buf, maxSize);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Returns the payload data length (data field length without CRC)
|
||||
*/
|
||||
uint16_t getPayloadDataLength() { return getPacketDataLen() - 2; }
|
||||
|
||||
ReturnValue_t checkCrc() {
|
||||
ReturnValue_t checkCrc() const {
|
||||
if (CRC::crc16ccitt(getFullData(), getFullPacketLen()) != 0) {
|
||||
return returnvalue::FAILED;
|
||||
}
|
||||
|
||||
@ -3,7 +3,7 @@
|
||||
#include <fsfw/objectmanager/SystemObjectIF.h>
|
||||
#include <fsfw/serviceinterface/ServiceInterface.h>
|
||||
|
||||
namespace initmission {
|
||||
namespace scheduling {
|
||||
|
||||
static void printAddObjectError(const char* name, object_id_t objectId) {
|
||||
#if FSFW_CPP_OSTREAM_ENABLED == 1
|
||||
@ -16,4 +16,4 @@ static void printAddObjectError(const char* name, object_id_t objectId) {
|
||||
#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
|
||||
}
|
||||
|
||||
} // namespace initmission
|
||||
} // namespace scheduling
|
||||
|
||||
4
thirdparty/CMakeLists.txt
vendored
4
thirdparty/CMakeLists.txt
vendored
@ -1 +1,5 @@
|
||||
if(EIVE_ADD_LINUX_FILES)
|
||||
add_subdirectory(tas)
|
||||
endif()
|
||||
|
||||
add_subdirectory(rapidcsv)
|
||||
|
||||
9
thirdparty/tas/CMakeLists.txt
vendored
Normal file
9
thirdparty/tas/CMakeLists.txt
vendored
Normal file
@ -0,0 +1,9 @@
|
||||
target_sources(${OBSW_NAME} PRIVATE
|
||||
hdlc.c
|
||||
uart.c
|
||||
crc.c
|
||||
)
|
||||
|
||||
target_include_directories(${OBSW_NAME} PRIVATE
|
||||
${CMAKE_CURRENT_SOURCE_DIR}
|
||||
)
|
||||
195
thirdparty/tas/crc.c
vendored
Normal file
195
thirdparty/tas/crc.c
vendored
Normal file
@ -0,0 +1,195 @@
|
||||
/***************************************************************************************
|
||||
* \copyright: 2020-2022 Thales Alenia Space Deutschland GmbH
|
||||
* \project: multiMIND
|
||||
* \file: crc.c
|
||||
* \date: 22.02.2022
|
||||
* \author: David Woodward
|
||||
* \brief: CRC algorithms
|
||||
***************************************************************************************/
|
||||
|
||||
#include <stddef.h>
|
||||
#include "tas/crc.h"
|
||||
|
||||
|
||||
const uint16_t crc16_0x1021_table[256] = {
|
||||
0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7,
|
||||
0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF,
|
||||
0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6,
|
||||
0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE,
|
||||
0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485,
|
||||
0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D,
|
||||
0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4,
|
||||
0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC,
|
||||
0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823,
|
||||
0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B,
|
||||
0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12,
|
||||
0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A,
|
||||
0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41,
|
||||
0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49,
|
||||
0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70,
|
||||
0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78,
|
||||
0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F,
|
||||
0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067,
|
||||
0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E,
|
||||
0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256,
|
||||
0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D,
|
||||
0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
|
||||
0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C,
|
||||
0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634,
|
||||
0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB,
|
||||
0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3,
|
||||
0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A,
|
||||
0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92,
|
||||
0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9,
|
||||
0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1,
|
||||
0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8,
|
||||
0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0
|
||||
};
|
||||
|
||||
const uint16_t crc16_0x1021_table_reverse[256] =
|
||||
{
|
||||
0x0000, 0x1189, 0x2312, 0x329B, 0x4624, 0x57AD, 0x6536, 0x74BF,
|
||||
0x8C48, 0x9DC1, 0xAF5A, 0xBED3, 0xCA6C, 0xDBE5, 0xE97E, 0xF8F7,
|
||||
0x1081, 0x0108, 0x3393, 0x221A, 0x56A5, 0x472C, 0x75B7, 0x643E,
|
||||
0x9CC9, 0x8D40, 0xBFDB, 0xAE52, 0xDAED, 0xCB64, 0xF9FF, 0xE876,
|
||||
0x2102, 0x308B, 0x0210, 0x1399, 0x6726, 0x76AF, 0x4434, 0x55BD,
|
||||
0xAD4A, 0xBCC3, 0x8E58, 0x9FD1, 0xEB6E, 0xFAE7, 0xC87C, 0xD9F5,
|
||||
0x3183, 0x200A, 0x1291, 0x0318, 0x77A7, 0x662E, 0x54B5, 0x453C,
|
||||
0xBDCB, 0xAC42, 0x9ED9, 0x8F50, 0xFBEF, 0xEA66, 0xD8FD, 0xC974,
|
||||
0x4204, 0x538D, 0x6116, 0x709F, 0x0420, 0x15A9, 0x2732, 0x36BB,
|
||||
0xCE4C, 0xDFC5, 0xED5E, 0xFCD7, 0x8868, 0x99E1, 0xAB7A, 0xBAF3,
|
||||
0x5285, 0x430C, 0x7197, 0x601E, 0x14A1, 0x0528, 0x37B3, 0x263A,
|
||||
0xDECD, 0xCF44, 0xFDDF, 0xEC56, 0x98E9, 0x8960, 0xBBFB, 0xAA72,
|
||||
0x6306, 0x728F, 0x4014, 0x519D, 0x2522, 0x34AB, 0x0630, 0x17B9,
|
||||
0xEF4E, 0xFEC7, 0xCC5C, 0xDDD5, 0xA96A, 0xB8E3, 0x8A78, 0x9BF1,
|
||||
0x7387, 0x620E, 0x5095, 0x411C, 0x35A3, 0x242A, 0x16B1, 0x0738,
|
||||
0xFFCF, 0xEE46, 0xDCDD, 0xCD54, 0xB9EB, 0xA862, 0x9AF9, 0x8B70,
|
||||
0x8408, 0x9581, 0xA71A, 0xB693, 0xC22C, 0xD3A5, 0xE13E, 0xF0B7,
|
||||
0x0840, 0x19C9, 0x2B52, 0x3ADB, 0x4E64, 0x5FED, 0x6D76, 0x7CFF,
|
||||
0x9489, 0x8500, 0xB79B, 0xA612, 0xD2AD, 0xC324, 0xF1BF, 0xE036,
|
||||
0x18C1, 0x0948, 0x3BD3, 0x2A5A, 0x5EE5, 0x4F6C, 0x7DF7, 0x6C7E,
|
||||
0xA50A, 0xB483, 0x8618, 0x9791, 0xE32E, 0xF2A7, 0xC03C, 0xD1B5,
|
||||
0x2942, 0x38CB, 0x0A50, 0x1BD9, 0x6F66, 0x7EEF, 0x4C74, 0x5DFD,
|
||||
0xB58B, 0xA402, 0x9699, 0x8710, 0xF3AF, 0xE226, 0xD0BD, 0xC134,
|
||||
0x39C3, 0x284A, 0x1AD1, 0x0B58, 0x7FE7, 0x6E6E, 0x5CF5, 0x4D7C,
|
||||
0xC60C, 0xD785, 0xE51E, 0xF497, 0x8028, 0x91A1, 0xA33A, 0xB2B3,
|
||||
0x4A44, 0x5BCD, 0x6956, 0x78DF, 0x0C60, 0x1DE9, 0x2F72, 0x3EFB,
|
||||
0xD68D, 0xC704, 0xF59F, 0xE416, 0x90A9, 0x8120, 0xB3BB, 0xA232,
|
||||
0x5AC5, 0x4B4C, 0x79D7, 0x685E, 0x1CE1, 0x0D68, 0x3FF3, 0x2E7A,
|
||||
0xE70E, 0xF687, 0xC41C, 0xD595, 0xA12A, 0xB0A3, 0x8238, 0x93B1,
|
||||
0x6B46, 0x7ACF, 0x4854, 0x59DD, 0x2D62, 0x3CEB, 0x0E70, 0x1FF9,
|
||||
0xF78F, 0xE606, 0xD49D, 0xC514, 0xB1AB, 0xA022, 0x92B9, 0x8330,
|
||||
0x7BC7, 0x6A4E, 0x58D5, 0x495C, 0x3DE3, 0x2C6A, 0x1EF1, 0x0F78
|
||||
};
|
||||
|
||||
// CRC-32 calculation from original implementation (Sarthak)
|
||||
// The used algorithm is (most likely) CRC32/BZIP2, as found here:
|
||||
// https://www.cl.cam.ac.uk/research/srg/projects/fairisle/bluebook/21/crc/node6.html
|
||||
uint32_t Crc32(const uint8_t *msg, int numBytes, uint32_t remainder) {
|
||||
|
||||
int byte;
|
||||
unsigned char bit;
|
||||
|
||||
// Perform modulo-2 division, a byte at a time.
|
||||
for (byte = 0; byte < numBytes; ++byte)
|
||||
{
|
||||
// Bring the next byte into the remainder.
|
||||
remainder ^= (*(msg + byte) << 16);
|
||||
|
||||
// Perform modulo-2 division, a bit at a time.
|
||||
for (bit = 8; bit > 0; --bit) {
|
||||
|
||||
// Try to divide the current data bit.
|
||||
if (remainder & CRC32_TOPBIT) {
|
||||
remainder = (remainder << 1) ^ CRC32_POLYNOMIAL;
|
||||
}
|
||||
else {
|
||||
remainder = (remainder << 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// The final remainder is the CRC result.
|
||||
return remainder;
|
||||
}
|
||||
|
||||
// ref.: CRC-16/CCITT-FALSE, alias: CRC-16/AUTOSAR
|
||||
// https://reveng.sourceforge.io/crc-catalogue/16.htm#crc.cat.crc-16-xmodem
|
||||
// initial: 0xFFFF, xorOut: 0x0000, RefIn: false, RefOut: false, polynomial: 0x1021
|
||||
uint16_t calc_crc16_unreflected(const uint8_t *data, uint32_t len, uint16_t remainder, uint16_t final_xor)
|
||||
{
|
||||
uint16_t crc = remainder;
|
||||
uint16_t temp;
|
||||
|
||||
// unreflected
|
||||
while (len-- != 0)
|
||||
{
|
||||
temp = (*data++ ^ (crc >> 8)) & 0xff;
|
||||
crc = crc16_0x1021_table[temp] ^ (crc << 8);
|
||||
}
|
||||
|
||||
crc ^= final_xor;
|
||||
|
||||
return crc;
|
||||
}
|
||||
|
||||
void calc_crc16_byte_unreflected(uint16_t *crc16, uint8_t bt)
|
||||
{
|
||||
uint16_t temp;
|
||||
temp = *crc16;
|
||||
|
||||
// unreflected
|
||||
*crc16 = crc16_0x1021_table[((temp >> 8) ^ bt) & 0xff] ^ (temp << 8);
|
||||
}
|
||||
|
||||
// initial: 0xFFFF, xorOut: 0x0000, RefIn: false, RefOut: false, polynomial: 0x1021
|
||||
uint16_t calc_crc16_buff_unreflected(uint8_t *data, uint16_t len)
|
||||
{
|
||||
uint16_t crc16 = 0xFFFF;
|
||||
|
||||
// unreflected
|
||||
while (len-- != 0)
|
||||
{
|
||||
crc16 = crc16_0x1021_table[((crc16 >> 8) ^ *data++) & 0xff] ^ (crc16 << 8);
|
||||
}
|
||||
|
||||
return crc16;
|
||||
}
|
||||
|
||||
// ref.: CRC-16/X25
|
||||
// initial: 0xFFFF, xorOut: 0xFFFF, RefIn: true, RefOut: true, polynomial: 0x1021
|
||||
uint16_t calc_crc16_reflected(const uint8_t *data, uint32_t len, uint16_t remainder, uint16_t final_xor)
|
||||
{
|
||||
uint16_t crc16 = remainder;
|
||||
|
||||
// reflected
|
||||
while (len-- != 0)
|
||||
{
|
||||
crc16 = crc16_0x1021_table_reverse[(crc16 ^ *data++) & 0xff] ^ (crc16 >> 8);
|
||||
}
|
||||
|
||||
return (crc16 ^ final_xor);
|
||||
}
|
||||
|
||||
void calc_crc16_byte_reflected(uint16_t *crc16, uint8_t bt)
|
||||
{
|
||||
uint16_t temp;
|
||||
temp = *crc16;
|
||||
|
||||
// reflected
|
||||
*crc16 = crc16_0x1021_table_reverse[(temp ^ bt) & 0xff] ^ (temp >> 8);
|
||||
}
|
||||
|
||||
// initial: 0xFFFF, xorOut: 0xFFFF, RefIn: true, RefOut: true, polynomial: 0x1021
|
||||
uint16_t calc_crc16_buff_reflected(const uint8_t *data, uint16_t len)
|
||||
{
|
||||
uint16_t crc16 = 0xFFFF;
|
||||
|
||||
// reflected
|
||||
while (len-- != 0)
|
||||
{
|
||||
crc16 = crc16_0x1021_table_reverse[(crc16 ^ *data++) & 0xff] ^ (crc16 >> 8);
|
||||
}
|
||||
|
||||
return (crc16 ^ 0xFFFF);
|
||||
}
|
||||
90
thirdparty/tas/hdlc.c
vendored
Normal file
90
thirdparty/tas/hdlc.c
vendored
Normal file
@ -0,0 +1,90 @@
|
||||
//**************************************************************************************
|
||||
/*! \copyright: 2020-2021 Thales Alenia Space Deutschland GmbH
|
||||
* \project: multiMIND
|
||||
* \file: (name of source file: hdlc.c)
|
||||
* \date: (09.02.2022)
|
||||
* \author: (Stelios Filippopoulos)
|
||||
* \brief: (hdlc functions)
|
||||
* \language: (C)
|
||||
**************************************************************************************
|
||||
*/
|
||||
|
||||
#include "tas/hdlc.h"
|
||||
#include "tas/crc.h"
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
void hdlc_add_byte(uint8_t ch, uint8_t *buff, size_t *pos)
|
||||
{
|
||||
size_t templen = *pos;
|
||||
|
||||
if ((ch == 0x7E) ||
|
||||
(ch == 0x7D) ||
|
||||
(ch == 0x7C))
|
||||
{
|
||||
buff[templen++] = 0x7D;
|
||||
ch ^= 0x20;
|
||||
}
|
||||
buff[templen++] = ch;
|
||||
|
||||
*pos = templen;
|
||||
}
|
||||
|
||||
void hdlc_add_framing(const uint8_t *src, size_t slen, uint8_t *dst, size_t *dlen)
|
||||
{
|
||||
size_t tlen = 0;
|
||||
uint16_t ii;
|
||||
uint16_t crc16;
|
||||
uint8_t bt;
|
||||
|
||||
// calc crc16
|
||||
crc16 = calc_crc16_buff_reflected( src, slen );
|
||||
|
||||
dst[tlen++] = 0x7E;
|
||||
for (ii = 0; ii < slen; ii++)
|
||||
{
|
||||
bt = *src++;
|
||||
hdlc_add_byte(bt, dst, &tlen);
|
||||
}
|
||||
|
||||
// hdlc crc16 is in little endian format
|
||||
// WARNING: This is not portable code! Bytes need to be swapped on a big
|
||||
// endian system
|
||||
// TODO: Fix
|
||||
hdlc_add_byte((uint8_t) (crc16 & 0xFF), dst, &tlen);
|
||||
hdlc_add_byte((uint8_t) ((crc16 >> 8) & 0xFF), dst, &tlen);
|
||||
|
||||
dst[tlen++] = 0x7C;
|
||||
*dlen = tlen;
|
||||
}
|
||||
|
||||
int hdlc_remove_framing_with_crc_check(const uint8_t *src, size_t slen, uint8_t *dst, size_t *dlen)
|
||||
{
|
||||
uint16_t tlen = 0;
|
||||
uint16_t ii;
|
||||
uint8_t bt;
|
||||
|
||||
*dlen = 0;
|
||||
if (slen < 4) return -1;
|
||||
if ((src[tlen] != 0x7E) && (src[slen-1] != 0x7C)) return -2;
|
||||
src++;
|
||||
for (ii = 1; ii < slen-1; ii++)
|
||||
{
|
||||
bt = *src++;
|
||||
|
||||
if (bt == 0x7D)
|
||||
{
|
||||
bt = *src++ ^ 0x20;
|
||||
ii++;
|
||||
}
|
||||
dst[tlen++] = bt;
|
||||
}
|
||||
// calc crc16
|
||||
if(calc_crc16_buff_reflected( dst, tlen ) != 0x0f47) {
|
||||
return 1;
|
||||
}
|
||||
*dlen = tlen - 2;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
116
thirdparty/tas/tas/crc.h
vendored
Normal file
116
thirdparty/tas/tas/crc.h
vendored
Normal file
@ -0,0 +1,116 @@
|
||||
/***************************************************************************************
|
||||
* \copyright: 2020-2022 Thales Alenia Space Deutschland GmbH
|
||||
* \project: multiMIND
|
||||
* \file: crc.c
|
||||
* \date: 22.02.2022
|
||||
* \author: David Woodward
|
||||
* \brief: CRC algorithms
|
||||
***************************************************************************************/
|
||||
|
||||
#ifndef TAS_D_C_CRC_H
|
||||
#define TAS_D_C_CRC_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
// NOTE: These defines are in the header as some are needed for (initial) crc function calls
|
||||
//CRC-32/BZIP2
|
||||
#define CRC32_TOPBIT (1UL<<31)
|
||||
#define CRC32_POLYNOMIAL 0x04C11DB7
|
||||
#define CRC32_INITIAL_REMAINDER 0xFFFFFFFF
|
||||
#define CRC32_FINAL_XOR_VALUE 0xFFFFFFFF
|
||||
|
||||
// CRC-16/CCITT-FALSE
|
||||
#define CRC16_INITIAL_REMAINDER 0xFFFF
|
||||
#define CRC16_FINAL_XOR_VALUE 0x0
|
||||
|
||||
extern const uint16_t crc16_0x1021_table[256];
|
||||
|
||||
extern const uint16_t crc16_0x1021_table_reverse[256];
|
||||
|
||||
/**
|
||||
* \brief CRC-32/BZIP2 algorithm
|
||||
*/
|
||||
uint32_t Crc32(const uint8_t *msg, int numBytes, uint32_t remainder);
|
||||
|
||||
|
||||
/**
|
||||
* \brief CRC-16/CCITT-FALSE (alias CRC-16/AUTOSAR) algorithm,
|
||||
// initial: 0xFFFF, xorOut: 0x0000, RefIn: false, RefOut: false, polynomial: 0x1021
|
||||
* using a lookup table
|
||||
* \param data Data
|
||||
* \param len Data length
|
||||
* \param remainder Remainder to be used,
|
||||
* use initial remainder for non coherent/standalone calculations
|
||||
* \param final_xor The value that the final result will be xored
|
||||
* \return CRC result
|
||||
*/
|
||||
uint16_t calc_crc16_unreflected(const uint8_t *data, uint32_t len, uint16_t remainder, uint16_t final_xor);
|
||||
|
||||
/**
|
||||
* generates a 16-bit CRC for the said data
|
||||
*
|
||||
* @param data input data for CRC
|
||||
* @param len length of the data
|
||||
* @return crc Generated 16-bit CRC
|
||||
*/
|
||||
void calc_crc16_byte_unreflected(uint16_t *crc16, uint8_t bt);
|
||||
|
||||
/**
|
||||
* \brief CRC-16/CCITT-FALSE (alias CRC-16/AUTOSAR) algorithm,
|
||||
* polynomial: 0x1021, initial: 0xFFFF, final xor: 0x0,
|
||||
* using a lookup table
|
||||
* \param data Data
|
||||
* \param len Data length
|
||||
* \param remainder Remainder to be used,
|
||||
* use initial remainder for non coherent/standalone calculations
|
||||
* \param final_xor The value that the final result will be xored
|
||||
* \return CRC result
|
||||
*/
|
||||
uint16_t calc_crc16_buff_unreflected(uint8_t *data, uint16_t len);
|
||||
|
||||
/**
|
||||
* \brief CRC-16/X25 algorithm,
|
||||
* initial: 0xFFFF, xorOut: 0xFFFF, RefIn: true, RefOut: true, polynomial: 0x1021
|
||||
* using a lookup table
|
||||
* \param data Data
|
||||
* \param len Data length
|
||||
* \param remainder Remainder to be used,
|
||||
* use initial remainder for non coherent/standalone calculations
|
||||
* \param final_xor The value that the final result will be xored
|
||||
* \return CRC result
|
||||
*/
|
||||
uint16_t calc_crc16_reflected(const uint8_t *data, uint32_t len, uint16_t remainder, uint16_t final_xor);
|
||||
|
||||
/**
|
||||
* \brief CRC-16/X25 algorithm,
|
||||
* calculates the crc16 for the next byte, given an already calculated crc16
|
||||
*
|
||||
* @param *crc16 : calculated crc16 - the value will be updated
|
||||
* @param bt : next byte for crc16 calculation
|
||||
* @return none
|
||||
*/
|
||||
void calc_crc16_byte_reflected(uint16_t *crc16, uint8_t bt);
|
||||
|
||||
/**
|
||||
* \brief CRC-16/X25 algorithm,
|
||||
* initial: 0xFFFF, xorOut: 0xFFFF, RefIn: true, RefOut: true, polynomial: 0x1021
|
||||
* using a lookup table
|
||||
* \param data Data
|
||||
* \param len Data length
|
||||
* \param remainder Remainder to be used,
|
||||
* use initial remainder for non coherent/standalone calculations
|
||||
* \param final_xor The value that the final result will be xored
|
||||
* \return CRC result
|
||||
*/
|
||||
uint16_t calc_crc16_buff_reflected(const uint8_t *data, uint16_t len);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
52
thirdparty/tas/tas/hdlc.h
vendored
Normal file
52
thirdparty/tas/tas/hdlc.h
vendored
Normal file
@ -0,0 +1,52 @@
|
||||
//**************************************************************************************
|
||||
/*! \copyright: 2020-2021 Thales Alenia Space Deutschland GmbH
|
||||
* \project: multiMIND
|
||||
* \file: (name of source file: hdlc.h)
|
||||
* \date: (09.02.2022)
|
||||
* \author: (Stelios Filippopoulos)
|
||||
* \brief: (hdlc header file)
|
||||
* \language: (C)
|
||||
**************************************************************************************
|
||||
*/
|
||||
|
||||
#ifndef LIB_HDLC_H_
|
||||
#define LIB_HDLC_H_
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stddef.h>
|
||||
|
||||
#define HDLC_ENABLE
|
||||
|
||||
#define HDLC_START_BYTE (0x7Eu)
|
||||
#define HDLC_ESC_BYTE (0x7Du)
|
||||
#define HDLC_END_BYTE (0x7Cu)
|
||||
#define HDLC_ESCAPE_CHAR (0x20u)
|
||||
|
||||
void hdlc_add_byte(uint8_t ch, uint8_t *buff, size_t *pos);
|
||||
|
||||
void hdlc_add_framing(const uint8_t *src, size_t slen, uint8_t *dst, size_t *dlen);
|
||||
|
||||
/**
|
||||
* Decode a HDLC frame, including CRC check and CRC removal in addition
|
||||
* to the removal of the frame markers.
|
||||
* @param src
|
||||
* @param slen
|
||||
* @param dst
|
||||
* @param dlen
|
||||
* @return
|
||||
* -1 Invalid source length
|
||||
* -2 No start marker at first byte or end marker at slen - 1
|
||||
* 1 Invalid CRC
|
||||
* 0 CRC OK, framing and CRC removed
|
||||
*/
|
||||
int hdlc_remove_framing_with_crc_check(const uint8_t *src, size_t slen, uint8_t *dst, size_t *dlen);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* LIB_HDLC_H_ */
|
||||
124
thirdparty/tas/tas/uart.h
vendored
Normal file
124
thirdparty/tas/tas/uart.h
vendored
Normal file
@ -0,0 +1,124 @@
|
||||
//**************************************************************************************
|
||||
/*! \copyright: 2020-2021 Thales Alenia Space Deutschland GmbH
|
||||
* \project: multiMIND
|
||||
* \file: (name of source file: uart.h)
|
||||
* \date: (20.05.2021)
|
||||
* \author: (Sarthak Kelapure)
|
||||
* \brief: (UART thread to collect data on serial interface)
|
||||
* \language: (C)
|
||||
**************************************************************************************
|
||||
*/
|
||||
#ifndef LIB_UART_H
|
||||
#define LIB_UART_H
|
||||
|
||||
#define BUFF_SIZE 512
|
||||
#define POLL_TIMEOUT 2000
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stdbool.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/stat.h>
|
||||
#include <termios.h>
|
||||
#include <fcntl.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include <unistd.h>
|
||||
#include <pthread.h>
|
||||
#include <signal.h>
|
||||
#include <poll.h>
|
||||
#include <errno.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
|
||||
typedef struct serial_s serial_t;
|
||||
|
||||
/**
|
||||
* Destroy the serial structure
|
||||
*/
|
||||
void uart_destroy(serial_t* s);
|
||||
|
||||
/**
|
||||
* Initializes the serial connection
|
||||
* @param device - serial device name.
|
||||
* @param baud - baud rate for connection.
|
||||
* @return serial structure.
|
||||
*/
|
||||
serial_t* uart_init(char device[], int baud);
|
||||
|
||||
/**
|
||||
* Send data.
|
||||
* @param s - serial structure.
|
||||
* @param data - character array to transmit.
|
||||
* @param length - size of the data array.
|
||||
*/
|
||||
uint32_t uart_length_send(serial_t* s, uint8_t data[], int length);
|
||||
|
||||
/**
|
||||
* Send a single character.
|
||||
* @param s - serial structure.
|
||||
* @param data - single character to be sent.
|
||||
*/
|
||||
void uart_send(serial_t* s, uint8_t data);
|
||||
|
||||
/**
|
||||
* Determine how much data is available
|
||||
* in the serial buffer.
|
||||
* @param s - serial structure.
|
||||
* @return number of characters available.
|
||||
*/
|
||||
int uart_available(serial_t* s);
|
||||
|
||||
/**
|
||||
* Fetch one char from the serial buffer.
|
||||
* @param s - serial structure.
|
||||
* @return character. Null if empty.
|
||||
*/
|
||||
char uart_get(serial_t* s);
|
||||
|
||||
/**
|
||||
* Fetch length of chars from the serial buffer.
|
||||
* @param s - serial structure.
|
||||
* @param buff - readback storage
|
||||
* @param len - length to get
|
||||
* @return length. zero if empty.
|
||||
*/
|
||||
int uart_length_get(serial_t* s, char* buff, int len, bool start_of_packet);
|
||||
|
||||
uint16_t uart_get_hdlc_packet(serial_t* s, uint8_t *buff, uint16_t buff_len);
|
||||
|
||||
/**
|
||||
* Fetch one char from the serial buffer.
|
||||
* Blocks until data becomes available.
|
||||
* @param s - serial structure.
|
||||
* @return character.
|
||||
*/
|
||||
char uart_blocking_get(serial_t* s);
|
||||
|
||||
/**
|
||||
* Clear the serial buffer.
|
||||
* @param s - serial structure.
|
||||
*/
|
||||
void uart_clear(serial_t* s);
|
||||
|
||||
/**
|
||||
* Close the serial port.
|
||||
* @param s - serial structure.
|
||||
* @return value of close().
|
||||
*/
|
||||
int uart_close(serial_t* s);
|
||||
|
||||
/**
|
||||
* Deinitializes the UART
|
||||
* @param s - serial structure.
|
||||
*/
|
||||
void uart_deinit(serial_t* s);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif //LIB_UART_H
|
||||
603
thirdparty/tas/uart.c
vendored
Normal file
603
thirdparty/tas/uart.c
vendored
Normal file
@ -0,0 +1,603 @@
|
||||
//**************************************************************************************
|
||||
/*! \copyright: 2020-2021 Thales Alenia Space Deutschland GmbH
|
||||
* \project: multiMIND
|
||||
* \file: (name of source file: uart.c)
|
||||
* \date: (20.05.2021)
|
||||
* \author: (Sarthak Kelapure)
|
||||
* \brief: (UART thread to collect data on serial interface)
|
||||
* \language: (C)
|
||||
**************************************************************************************
|
||||
*/
|
||||
|
||||
#include "tas/uart.h"
|
||||
#include "tas/hdlc.h"
|
||||
|
||||
#ifdef HDLC_ENABLE
|
||||
#define HDLC_RX_STATE_IDLE (0u)
|
||||
#define HDLC_RX_STATE_RECEIVING (1u)
|
||||
#define HDLC_RX_STATE_ESCAPE (2u)
|
||||
#endif
|
||||
|
||||
/**
|
||||
* @struct Serial device structure.
|
||||
* Encapsulates a serial connection.
|
||||
*/
|
||||
struct serial_s {
|
||||
int fd; //>! Connection file descriptor.
|
||||
int state; //>! Signifies connection state.
|
||||
int running; //>! Signifies thread state.
|
||||
|
||||
char rxbuff[BUFF_SIZE]; //>! Buffer for RX data.
|
||||
int start, end; //>! Pointers to start and end of buffer.
|
||||
|
||||
pthread_t rx_thread; //>! Listening thread.
|
||||
};
|
||||
|
||||
// --------------- Internal Functions ---------------
|
||||
|
||||
/**
|
||||
* Connect to a serial device.
|
||||
* @param s - serial structure.
|
||||
* @param device - serial device name.
|
||||
* @param baud - baud rate for connection.
|
||||
* @return -ve on error, 0 on success.
|
||||
*/
|
||||
static int serial_connect(serial_t* s, char device[], int baud);
|
||||
|
||||
/**
|
||||
* Create the serial structure.
|
||||
* Convenience method to allocate memory
|
||||
* and instantiate objects.
|
||||
* @return serial structure.
|
||||
*/
|
||||
static serial_t* serial_create();
|
||||
|
||||
static int serial_resolve_baud(int baud);
|
||||
|
||||
/**
|
||||
* Recieve data.
|
||||
* Retrieves data from the serial device.
|
||||
* @param s - serial structure.
|
||||
* @param data - pointer to a buffer to read data into.
|
||||
* @param maxLength - size of input buffer.
|
||||
* @return amount of data recieved.
|
||||
*/
|
||||
static int serial_recieve(serial_t* obj, uint8_t data[], int maxLength);
|
||||
|
||||
/**
|
||||
* @brief Serial Listener Thread.
|
||||
* This blocks waiting for data to be recieved from the serial device,
|
||||
* and calls the serial_callback method with appropriate context when
|
||||
* data is recieved.
|
||||
* Exits when close method is called, or serial error occurs.
|
||||
* @param param - context passed from thread instantiation.
|
||||
*/
|
||||
static void *serial_data_listener(void *param);
|
||||
|
||||
/**
|
||||
* @brief Start the serial threads.
|
||||
* This spawns the listening and transmitting threads
|
||||
* if they are not already running.
|
||||
* @param s - serial structure.
|
||||
* @return 0 on success, or -1 on error.
|
||||
*/
|
||||
static int serial_start(serial_t* s);
|
||||
|
||||
/**
|
||||
* Stop serial listener thread.
|
||||
* @param s - serial structure.
|
||||
* @return 0;
|
||||
*/
|
||||
static int serial_stop(serial_t* s);
|
||||
|
||||
/**
|
||||
* Callback to handle recieved data.
|
||||
* Puts recieved data into the rx buffer.
|
||||
* @param s - serial structure.
|
||||
* @param data - data to be stored.
|
||||
* @param length - length of recieved data.
|
||||
*/
|
||||
static void serial_rx_callback(serial_t* s, char data[], int length);
|
||||
|
||||
// Put character in rx buffer.
|
||||
static int buffer_put(serial_t* s, char c)
|
||||
{
|
||||
//if there is space in the buffer
|
||||
if ( s->end != ((s->start + BUFF_SIZE - 1) % BUFF_SIZE)) {
|
||||
s->rxbuff[s->end] = c;
|
||||
s->end ++;
|
||||
s->end = s->end % BUFF_SIZE;
|
||||
//printf("Put: %x start: %d, end: %d\r\n", c, s->start, s->end);
|
||||
return 0; //No error
|
||||
} else {
|
||||
//buffer is full, this is a bad state
|
||||
return -1; //Report error
|
||||
}
|
||||
}
|
||||
|
||||
// Get character from rx buffer.
|
||||
static char buffer_get(serial_t* s)
|
||||
{
|
||||
char c = (char)0;
|
||||
//if there is data to process
|
||||
if (s->end != s->start) {
|
||||
c = (s->rxbuff[s->start]);
|
||||
s->start ++;
|
||||
//wrap around
|
||||
s->start = s->start % BUFF_SIZE;
|
||||
} else {
|
||||
}
|
||||
//printf("Get: %x start: %d, end: %d\r\n", c, s->start, s->end);
|
||||
return c;
|
||||
}
|
||||
|
||||
//Get data available in the rx buffer.
|
||||
static int buffer_available(serial_t* s)
|
||||
{
|
||||
return (s->end - s->start + BUFF_SIZE) % BUFF_SIZE;
|
||||
}
|
||||
|
||||
// --------------- External Functions ---------------
|
||||
|
||||
//Create serial object.
|
||||
serial_t* serial_create()
|
||||
{
|
||||
//Allocate serial object.
|
||||
serial_t* s = malloc(sizeof(serial_t));
|
||||
//Reconfigure buffer object.
|
||||
s->start = 0;
|
||||
s->end = 0;
|
||||
//Return pointer.
|
||||
return s;
|
||||
}
|
||||
|
||||
|
||||
void uart_destroy(serial_t* s)
|
||||
{
|
||||
free(s);
|
||||
}
|
||||
|
||||
|
||||
//Connect to serial device.
|
||||
int serial_connect(serial_t* s, char device[], int baud)
|
||||
{
|
||||
struct termios oldtio;
|
||||
|
||||
// Resolve baud.
|
||||
int speed = serial_resolve_baud(baud);
|
||||
if (speed < 0) {
|
||||
printf("Error: Baud rate not recognized.\r\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
//Open device.
|
||||
s->fd = open(device, O_RDWR | O_NOCTTY);
|
||||
//Catch file open error.
|
||||
if (s->fd < 0) {
|
||||
perror(device);
|
||||
return -2;
|
||||
}
|
||||
//Retrieve settings.
|
||||
tcgetattr(s->fd, &oldtio);
|
||||
//Set baud rate.
|
||||
cfsetspeed(&oldtio, speed);
|
||||
//Flush cache.
|
||||
tcflush(s->fd, TCIFLUSH);
|
||||
|
||||
//Set UART settings, standard ones. 8N1
|
||||
oldtio.c_cflag = (oldtio.c_cflag & ~CSIZE) | CS8; // 8-bit chars
|
||||
// disable IGNBRK for mismatched speed tests; otherwise receive break
|
||||
// as \000 chars
|
||||
oldtio.c_iflag &= ~IGNBRK; // disable break processing
|
||||
oldtio.c_lflag = 0; // no signaling chars, no echo,
|
||||
// no canonical processing
|
||||
oldtio.c_oflag = 0; // no remapping, no delays
|
||||
oldtio.c_cc[VMIN] = 0; // read doesn't block
|
||||
oldtio.c_cc[VTIME] = 5; // 0.5 seconds read timeout
|
||||
|
||||
oldtio.c_iflag &= ~(IXON | IXOFF | IXANY); // shut off xon/xoff ctrl
|
||||
oldtio.c_iflag &= ~(IGNCR | ICRNL | INLCR); // CR and LF characters are not affected
|
||||
|
||||
oldtio.c_cflag |= (CLOCAL | CREAD);// ignore modem controls,
|
||||
// enable reading
|
||||
oldtio.c_cflag &= ~(PARENB | PARODD); // shut off parity
|
||||
oldtio.c_cflag |= 0;
|
||||
oldtio.c_cflag &= ~CSTOPB;
|
||||
oldtio.c_cflag &= ~(020000000000);
|
||||
//Apply settings.
|
||||
if(tcsetattr(s->fd, TCSANOW, &oldtio) !=0){
|
||||
printf("ERROR: serial settings failed\r\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
//Start listener thread.
|
||||
int res = serial_start(s);
|
||||
//Catch error.
|
||||
if (res < 0) {
|
||||
printf("Error: serial thread could not be spawned\r\n");
|
||||
return -3;
|
||||
}
|
||||
|
||||
//Indicate connection was successful.
|
||||
s->state = 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
serial_t* uart_init(char device[], int baud)
|
||||
{
|
||||
serial_t* s = serial_create();
|
||||
if(serial_connect(s, device, baud)< 0)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
return s;
|
||||
}
|
||||
|
||||
//Send data.
|
||||
uint32_t uart_length_send(serial_t* s, uint8_t data[], int length)
|
||||
{
|
||||
// uint16_t ii;
|
||||
// int res;
|
||||
// for (ii = 0; ii < length; ii++)
|
||||
// {
|
||||
// res = write(s->fd, &data[ii], 1);
|
||||
// }
|
||||
int res = write(s->fd, data, length);
|
||||
return res;
|
||||
}
|
||||
|
||||
void uart_send(serial_t* s, uint8_t data)
|
||||
{
|
||||
char arr[1];
|
||||
arr[0] = data;
|
||||
write(s->fd, arr, 1);
|
||||
}
|
||||
|
||||
//Determine characters available.
|
||||
int uart_available(serial_t* s)
|
||||
{
|
||||
return buffer_available(s);
|
||||
}
|
||||
|
||||
//Fetch a character.
|
||||
char uart_get(serial_t* s)
|
||||
{
|
||||
char c = buffer_get(s);
|
||||
|
||||
return c;
|
||||
}
|
||||
|
||||
int uart_length_get(serial_t* s, char* buff, int len, bool start_of_packet)
|
||||
{
|
||||
int ret = 0;
|
||||
if (len > 0 && len < BUFF_SIZE)
|
||||
{
|
||||
#ifdef HDLC_ENABLE
|
||||
uint8_t ch;
|
||||
uint8_t hdlc_rx_state;
|
||||
int rxb = 0;
|
||||
|
||||
if (start_of_packet)
|
||||
hdlc_rx_state = HDLC_RX_STATE_IDLE;
|
||||
else
|
||||
hdlc_rx_state = HDLC_RX_STATE_RECEIVING;
|
||||
|
||||
while (rxb < len)
|
||||
{
|
||||
ch = uart_blocking_get(s);
|
||||
|
||||
switch (hdlc_rx_state)
|
||||
{
|
||||
case HDLC_RX_STATE_IDLE:
|
||||
if (ch == HDLC_START_BYTE)
|
||||
{
|
||||
rxb = 0;
|
||||
ret = 0;
|
||||
hdlc_rx_state = HDLC_RX_STATE_RECEIVING;
|
||||
}
|
||||
break;
|
||||
case HDLC_RX_STATE_RECEIVING:
|
||||
if (ch == HDLC_START_BYTE)
|
||||
{
|
||||
rxb = 0;
|
||||
ret = 0;
|
||||
break;
|
||||
}
|
||||
if (ch == HDLC_ESC_BYTE)
|
||||
{
|
||||
hdlc_rx_state = HDLC_RX_STATE_ESCAPE;
|
||||
break;
|
||||
}
|
||||
buff[rxb++] = ch;
|
||||
ret++;
|
||||
break;
|
||||
case HDLC_RX_STATE_ESCAPE:
|
||||
if (ch == HDLC_START_BYTE)
|
||||
{
|
||||
rxb = 0;
|
||||
ret = 0;
|
||||
break;
|
||||
}
|
||||
buff[rxb++] = ch ^ HDLC_ESCAPE_CHAR;
|
||||
ret++;
|
||||
hdlc_rx_state = HDLC_RX_STATE_RECEIVING;
|
||||
break;
|
||||
}
|
||||
}
|
||||
#else
|
||||
for (int i=0;i<len;i++)
|
||||
{
|
||||
buff[i] = uart_blocking_get(s);
|
||||
ret++;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
uint16_t uart_get_hdlc_packet(serial_t* s, uint8_t *buff, uint16_t buff_len)
|
||||
{
|
||||
uint8_t hdlc_rx_state = HDLC_RX_STATE_IDLE;
|
||||
uint8_t ch;
|
||||
uint16_t buff_pos = 0u;
|
||||
|
||||
while (1)
|
||||
{
|
||||
ch = uart_blocking_get(s);
|
||||
|
||||
switch (hdlc_rx_state)
|
||||
{
|
||||
case HDLC_RX_STATE_IDLE:
|
||||
if (ch == HDLC_START_BYTE)
|
||||
{
|
||||
buff_pos = 0u;
|
||||
hdlc_rx_state = HDLC_RX_STATE_RECEIVING;
|
||||
}
|
||||
break;
|
||||
|
||||
case HDLC_RX_STATE_RECEIVING:
|
||||
if (ch == HDLC_START_BYTE)
|
||||
{
|
||||
buff_pos = 0u;
|
||||
break;
|
||||
}
|
||||
if (ch == HDLC_END_BYTE)
|
||||
{
|
||||
if (buff_pos > 2u) // do not include HDLC CRC16
|
||||
{
|
||||
return buff_pos;
|
||||
}
|
||||
buff_pos = 0u;
|
||||
hdlc_rx_state = HDLC_RX_STATE_IDLE;
|
||||
break;
|
||||
}
|
||||
if (ch == HDLC_ESC_BYTE)
|
||||
{
|
||||
hdlc_rx_state = HDLC_RX_STATE_ESCAPE;
|
||||
break;
|
||||
}
|
||||
if (buff_pos >= buff_len)
|
||||
{
|
||||
hdlc_rx_state = HDLC_RX_STATE_RECEIVING;
|
||||
break;
|
||||
}
|
||||
buff[buff_pos++] = ch;
|
||||
break;
|
||||
|
||||
case HDLC_RX_STATE_ESCAPE:
|
||||
if ((ch == HDLC_START_BYTE) || (ch == HDLC_END_BYTE))
|
||||
{
|
||||
buff_pos = 0;
|
||||
hdlc_rx_state = HDLC_RX_STATE_RECEIVING;
|
||||
break;
|
||||
}
|
||||
if (buff_pos >= buff_len)
|
||||
{
|
||||
hdlc_rx_state = HDLC_RX_STATE_RECEIVING;
|
||||
break;
|
||||
}
|
||||
buff[buff_pos++] = ch ^ HDLC_ESCAPE_CHAR;
|
||||
hdlc_rx_state = HDLC_RX_STATE_RECEIVING;
|
||||
break;
|
||||
|
||||
default:
|
||||
buff_pos = 0u;
|
||||
hdlc_rx_state = HDLC_RX_STATE_IDLE;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
char uart_blocking_get(serial_t* s)
|
||||
{
|
||||
while (uart_available(s) == 0);
|
||||
return uart_get(s);
|
||||
}
|
||||
|
||||
void uart_clear(serial_t* s)
|
||||
{
|
||||
//Clear the buffer.
|
||||
while (buffer_available(s)) {
|
||||
buffer_get(s);
|
||||
}
|
||||
tcflush(s->fd, TCIFLUSH);
|
||||
}
|
||||
|
||||
//Close serial port.
|
||||
int uart_close(serial_t* s)
|
||||
{
|
||||
//Stop thread.
|
||||
serial_stop(s);
|
||||
return 0;
|
||||
}
|
||||
|
||||
void uart_deinit(serial_t* s){
|
||||
uart_clear(s);
|
||||
uart_close(s);
|
||||
uart_destroy(s);
|
||||
}
|
||||
|
||||
// --------------- Internal Functions --------------
|
||||
|
||||
//Stop serial listener thread.
|
||||
static int serial_stop(serial_t* s)
|
||||
{
|
||||
s->running = 0;
|
||||
return close(s->fd);
|
||||
}
|
||||
|
||||
// Resolves standard baud rates to linux constants.
|
||||
static int serial_resolve_baud(int baud)
|
||||
{
|
||||
int speed;
|
||||
// Switch common baud rates to temios constants.
|
||||
switch (baud) {
|
||||
case 9600:
|
||||
speed = B9600;
|
||||
break;
|
||||
case 19200:
|
||||
speed = B19200;
|
||||
break;
|
||||
case 38400:
|
||||
speed = B38400;
|
||||
break;
|
||||
case 57600:
|
||||
speed = B57600;
|
||||
break;
|
||||
case 115200:
|
||||
speed = B115200;
|
||||
break;
|
||||
case 230400:
|
||||
speed = B230400;
|
||||
break;
|
||||
case 460800:
|
||||
speed = B460800;
|
||||
break;
|
||||
case 500000:
|
||||
speed = B500000;
|
||||
break;
|
||||
case 576000:
|
||||
speed = B576000;
|
||||
break;
|
||||
case 921600:
|
||||
speed = B921600;
|
||||
break;
|
||||
case 1000000:
|
||||
speed = B1000000;
|
||||
break;
|
||||
case 1152000:
|
||||
speed = B1152000;
|
||||
break;
|
||||
case 1500000:
|
||||
speed = B1500000;
|
||||
break;
|
||||
case 2000000:
|
||||
speed = B2000000;
|
||||
break;
|
||||
case 3000000:
|
||||
speed = B3000000;
|
||||
break;
|
||||
default:
|
||||
speed = -1;
|
||||
break;
|
||||
}
|
||||
// Return.
|
||||
return speed;
|
||||
}
|
||||
|
||||
// Start serial listener.
|
||||
static int serial_start(serial_t* s)
|
||||
{
|
||||
//Only start if it is not currently running.
|
||||
if (s->running != 1) {
|
||||
//Set running.
|
||||
s->running = 1;
|
||||
//Spawn thread.
|
||||
int res;
|
||||
res = pthread_create(&s->rx_thread, NULL, serial_data_listener, (void*) s);
|
||||
if (res != 0) {
|
||||
return -2;
|
||||
}
|
||||
//Return result.
|
||||
return 0;
|
||||
} else {
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
//Recieve data.
|
||||
static int serial_recieve(serial_t* s, uint8_t data[], int maxLength)
|
||||
{
|
||||
return read(s->fd, data, maxLength);
|
||||
}
|
||||
|
||||
//Callback to store data in buffer.
|
||||
static void serial_rx_callback(serial_t* s, char data[], int length)
|
||||
{
|
||||
//Put data into buffer.
|
||||
int i;
|
||||
//Put data into buffer.
|
||||
for (i = 0; i < length; i++) {
|
||||
buffer_put(s, data[i]);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
//Serial data listener thread.
|
||||
static void *serial_data_listener(void *param)
|
||||
{
|
||||
int res = 0;
|
||||
int err = 0;
|
||||
struct pollfd ufds;
|
||||
uint8_t buff[BUFF_SIZE];
|
||||
|
||||
//Retrieve paramaters and store locally.
|
||||
serial_t* serial = (serial_t*) param;
|
||||
int fd = serial->fd;
|
||||
|
||||
//Set up poll file descriptors.
|
||||
ufds.fd = fd; //Attach socket to watch.
|
||||
ufds.events = POLLIN; //Set events to notify on.
|
||||
|
||||
//Run until ended.
|
||||
while (serial->running != 0) {
|
||||
//Poll socket for data.
|
||||
res = poll(&ufds, 1, POLL_TIMEOUT);
|
||||
//If data was recieved.
|
||||
if (res > 0) {
|
||||
//Fetch the data.
|
||||
int count = serial_recieve(serial, buff, BUFF_SIZE - 1);
|
||||
//If data was recieved.
|
||||
if (count > 0) {
|
||||
//Pad end of buffer to ensure there is a termination symbol.
|
||||
buff[count] = '\0';
|
||||
// Call the serial callback.
|
||||
serial_rx_callback(serial, (char *)buff, count);
|
||||
//If an error occured.
|
||||
} else if (count < 0) {
|
||||
//Inform user and exit thread.
|
||||
printf("Error: Serial disconnect\r\n");
|
||||
err = 1;
|
||||
break;
|
||||
}
|
||||
//If there was an error.
|
||||
} else if (res < 0) {
|
||||
//Inform user and exit thread.
|
||||
printf("Error: Polling error in serial thread");
|
||||
err = 1;
|
||||
break;
|
||||
}
|
||||
//Otherwise, keep going around.
|
||||
}
|
||||
//If there was an error, close socket.
|
||||
if (err) {
|
||||
uart_close(serial);
|
||||
//raise(SIGLOST);
|
||||
}
|
||||
//Close file.
|
||||
res = close(serial->fd);
|
||||
|
||||
return NULL;
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user