Merge pull request 'PLOC SUPV Update to newer firmware' (#316) from mueller/tas_ploc_supv_update into develop
All checks were successful
EIVE/eive-obsw/pipeline/head This commit looks good

Reviewed-on: #316
This commit is contained in:
Robin Müller 2022-11-18 14:27:10 +01:00
commit 30f020bff3
58 changed files with 5419 additions and 2788 deletions

View File

@ -10,6 +10,11 @@ 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

View File

@ -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

View File

@ -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

View File

@ -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)

View File

@ -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_ */

View File

@ -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@

View File

@ -6,11 +6,13 @@
#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 +49,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 +78,35 @@ void ObjectFactory::produce(void* args) {
CfdpTmFunnel* cfdpFunnel;
ObjectFactory::produceGenericObjects(nullptr, &pusFunnel, &cfdpFunnel);
DummyGpioIF* dummyGpioIF = new DummyGpioIF();
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();
new ThermalController(objects::THERMAL_CONTROLLER);
new TestTask(objects::TEST_TASK);
}

View File

@ -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";
}

View File

@ -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_ */

View File

@ -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:

View File

@ -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_ */

View File

@ -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.

View File

@ -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
View File

@ -0,0 +1,6 @@
#pragma once
namespace scheduling {
void initMission();
void initTasks();
}; // namespace scheduling

View File

@ -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@

View File

@ -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

View File

@ -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);

View File

@ -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 {

View File

@ -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"

View File

@ -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,

View File

@ -25,6 +25,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() {

View File

@ -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 Event ID (dec) Event ID (hex) Name Severity Description File Path
123 11901 0x2e7d BOOTING_FIRMWARE_FAILED LOW Failed to boot firmware linux/devices/startracker/StarTrackerHandler.h
124 11902 0x2e7e BOOTING_BOOTLOADER_FAILED LOW Failed to boot star tracker into bootloader mode linux/devices/startracker/StarTrackerHandler.h
125 12001 0x2ee1 SUPV_MEMORY_READ_RPT_CRC_FAILURE LOW PLOC supervisor crc failure in telemetry packet linux/devices/ploc/PlocSupervisorHandler.h
126 12002 0x2ee2 SUPV_ACK_FAILURE SUPV_UNKNOWN_TM LOW PLOC supervisor received acknowledgment failure report Unhandled event. P1: APID, P2: Service ID linux/devices/ploc/PlocSupervisorHandler.h
127 12003 0x2ee3 SUPV_EXE_FAILURE SUPV_UNINIMPLEMENTED_TM 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
128 12004 0x2ee4 SUPV_CRC_FAILURE_EVENT SUPV_ACK_FAILURE LOW PLOC supervisor reply has invalid crc PLOC supervisor received acknowledgment failure report linux/devices/ploc/PlocSupervisorHandler.h
129 12005 0x2ee5 SUPV_MPSOC_SHUWDOWN_BUILD_FAILED SUPV_EXE_FAILURE LOW Failed to build the command to shutdown the MPSoC 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
130 12006 0x2ee6 SUPV_CRC_FAILURE_EVENT LOW PLOC supervisor reply has invalid crc linux/devices/ploc/PlocSupervisorHandler.h
131 12007 0x2ee7 SUPV_HELPER_EXECUTING LOW Supervisor helper currently executing a command linux/devices/ploc/PlocSupervisorHandler.h
132 12008 0x2ee8 SUPV_MPSOC_SHUWDOWN_BUILD_FAILED LOW Failed to build the command to shutdown the MPSoC linux/devices/ploc/PlocSupervisorHandler.h
133 12100 0x2f44 SANITIZATION_FAILED LOW bsp_q7s/fs/SdCardManager.h
134 12101 0x2f45 MOUNTED_SD_CARD INFO bsp_q7s/fs/SdCardManager.h
135 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
198 13200 0x3390 P60_BOOT_COUNT INFO P60 boot count is broadcasted once at SW startup. P1: Boot count mission/devices/P60DockHandler.h
199 13201 0x3391 BATT_MODE INFO Battery mode is broadcasted at startup. P1: Mode mission/devices/P60DockHandler.h
200 13202 0x3392 BATT_MODE_CHANGED MEDIUM Battery mode has changed. P1: Old mode. P2: New mode mission/devices/P60DockHandler.h
201 13600 0x3520 SUPV_UPDATE_FAILED LOW update failed linux/devices/ploc/PlocSupvHelper.h linux/devices/ploc/PlocSupvUartMan.h
202 13601 0x3521 SUPV_UPDATE_SUCCESSFUL LOW update successful linux/devices/ploc/PlocSupvHelper.h linux/devices/ploc/PlocSupvUartMan.h
203 13602 0x3522 SUPV_CONTINUE_UPDATE_FAILED LOW Continue update command failed linux/devices/ploc/PlocSupvHelper.h linux/devices/ploc/PlocSupvUartMan.h
204 13603 0x3523 SUPV_CONTINUE_UPDATE_SUCCESSFUL LOW Continue update command successful linux/devices/ploc/PlocSupvHelper.h linux/devices/ploc/PlocSupvUartMan.h
205 13604 0x3524 TERMINATED_UPDATE_PROCEDURE LOW Terminated update procedure by command linux/devices/ploc/PlocSupvHelper.h linux/devices/ploc/PlocSupvUartMan.h
206 13605 0x3525 SUPV_EVENT_BUFFER_REQUEST_SUCCESSFUL LOW Requesting event buffer was successful linux/devices/ploc/PlocSupvHelper.h linux/devices/ploc/PlocSupvUartMan.h
207 13606 0x3526 SUPV_EVENT_BUFFER_REQUEST_FAILED LOW Requesting event buffer failed linux/devices/ploc/PlocSupvHelper.h linux/devices/ploc/PlocSupvUartMan.h
208 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 linux/devices/ploc/PlocSupvUartMan.h
209 13608 0x3528 SUPV_MEM_CHECK_OK INFO linux/devices/ploc/PlocSupvHelper.h linux/devices/ploc/PlocSupvUartMan.h
210 13609 0x3529 SUPV_MEM_CHECK_FAIL INFO linux/devices/ploc/PlocSupvHelper.h linux/devices/ploc/PlocSupvUartMan.h
211 13616 0x3530 SUPV_SENDING_COMMAND_FAILED LOW linux/devices/ploc/PlocSupvHelper.h linux/devices/ploc/PlocSupvUartMan.h
212 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 linux/devices/ploc/PlocSupvUartMan.h
213 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 linux/devices/ploc/PlocSupvUartMan.h
214 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 linux/devices/ploc/PlocSupvUartMan.h
215 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 linux/devices/ploc/PlocSupvUartMan.h
216 13621 0x3535 SUPV_ACK_FAILURE_REPORT LOW Supervisor received acknowledgment failure report P1: Internal state of supervisor helper linux/devices/ploc/PlocSupvHelper.h linux/devices/ploc/PlocSupvUartMan.h
217 13622 0x3536 SUPV_EXE_FAILURE_REPORT LOW Execution report failure P1: linux/devices/ploc/PlocSupvHelper.h linux/devices/ploc/PlocSupvUartMan.h
218 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 linux/devices/ploc/PlocSupvUartMan.h
219 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 linux/devices/ploc/PlocSupvUartMan.h
220 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 linux/devices/ploc/PlocSupvUartMan.h
221 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 linux/devices/ploc/PlocSupvUartMan.h
222 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 linux/devices/ploc/PlocSupvUartMan.h
223 13628 0x353c SUPV_REPLY_SIZE_MISSMATCH LOW linux/devices/ploc/PlocSupvHelper.h linux/devices/ploc/PlocSupvUartMan.h
224 13629 0x353d SUPV_REPLY_CRC_MISSMATCH LOW linux/devices/ploc/PlocSupvHelper.h linux/devices/ploc/PlocSupvUartMan.h
225 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 linux/devices/ploc/PlocSupvUartMan.h
226 13631 0x353f HDLC_FRAME_REMOVAL_ERROR INFO linux/devices/ploc/PlocSupvUartMan.h
227 13632 0x3540 HDLC_CRC_ERROR INFO linux/devices/ploc/PlocSupvUartMan.h
228 13700 0x3584 ALLOC_FAILURE MEDIUM bsp_q7s/core/CoreController.h
229 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
230 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

View File

@ -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):

View File

@ -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"

View File

@ -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)

View File

@ -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);

View File

@ -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 {

View File

@ -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

View File

@ -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_ */

View File

@ -1,4 +1,4 @@
target_sources(
${OBSW_NAME}
PRIVATE PlocSupervisorHandler.cpp PlocMemoryDumper.cpp PlocMPSoCHandler.cpp
PlocMPSoCHelper.cpp PlocSupvHelper.cpp)
PlocMPSoCHelper.cpp PlocSupvUartMan.cpp)

View File

@ -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

View File

@ -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);
};

View File

@ -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, &currentBytes, 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; }

File diff suppressed because it is too large Load Diff

View File

@ -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_ */

View File

@ -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"

View File

@ -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"

View File

@ -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();

View File

@ -1 +0,0 @@
#include "addresses.h"

View File

@ -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):

View File

@ -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,

View File

@ -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"

View File

@ -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;
@ -50,17 +50,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
}

View File

@ -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

View File

@ -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);

View File

@ -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;
}

View File

@ -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

View File

@ -1 +1,5 @@
if(EIVE_ADD_LINUX_FILES)
add_subdirectory(tas)
endif()
add_subdirectory(rapidcsv)

9
thirdparty/tas/CMakeLists.txt vendored Normal file
View 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
View 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
View 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
View 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
View 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
View 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
View 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;
}