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

bpx handler now working
All checks were successful
EIVE/eive-obsw/pipeline/head This commit looks good
Details

Browse Source
This commit is contained in:
Robin Müller 2022-02-03 13:37:48 +01:00
parent 6440567585
commit e142408bb8
No known key found for this signature in database
GPG Key ID: 71B58F8A3CDFA9AC
15 changed files with 678 additions and 514 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
bsp_q7s/core/InitMission.cpp
View File

@ -248,6 +248,8 @@ void initmission::createPstTasks(TaskFactory& factory,
sif::error << "InitMission::initTasks: Creating PST failed!" << std::endl; sif::error << "InitMission::initTasks: Creating PST failed!" << std::endl;
} }
taskVec.push_back(gpioPst); taskVec.push_back(gpioPst);
#if OBSW_ADD_I2C_TEST_CODE == 0
FixedTimeslotTaskIF* i2cPst = factory.createFixedTimeslotTask( FixedTimeslotTaskIF* i2cPst = factory.createFixedTimeslotTask(
"I2C_PST", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 0.2, missedDeadlineFunc); "I2C_PST", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 0.2, missedDeadlineFunc);
result = pst::pstI2c(i2cPst); result = pst::pstI2c(i2cPst);
@ -255,6 +257,7 @@ void initmission::createPstTasks(TaskFactory& factory,
sif::error << "InitMission::initTasks: Creating PST failed!" << std::endl; sif::error << "InitMission::initTasks: Creating PST failed!" << std::endl;
} }
taskVec.push_back(i2cPst); taskVec.push_back(i2cPst);
#endif
FixedTimeslotTaskIF* gomSpacePstTask = factory.createFixedTimeslotTask( FixedTimeslotTaskIF* gomSpacePstTask = factory.createFixedTimeslotTask(
"GS_PST_TASK", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 1.0, missedDeadlineFunc); "GS_PST_TASK", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 1.0, missedDeadlineFunc);
@ -348,7 +351,7 @@ void initmission::createTestTasks(TaskFactory& factory,
TaskDeadlineMissedFunction missedDeadlineFunc, TaskDeadlineMissedFunction missedDeadlineFunc,
std::vector<PeriodicTaskIF*>& taskVec) { std::vector<PeriodicTaskIF*>& taskVec) {
#if OBSW_ADD_TEST_TASK == 1 || OBSW_ADD_SPI_TEST_CODE == 1 || \ #if OBSW_ADD_TEST_TASK == 1 || OBSW_ADD_SPI_TEST_CODE == 1 || \
(BOARD_TE0720 == 1 && OBSW_TEST_LIBGPIOD == 1) OBSW_ADD_I2C_TEST_CODE == 1 || (BOARD_TE0720 == 1 && OBSW_TEST_LIBGPIOD == 1)
ReturnValue_t result = HasReturnvaluesIF::RETURN_OK; ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
#endif #endif
PeriodicTaskIF* testTask = factory.createPeriodicTask( PeriodicTaskIF* testTask = factory.createPeriodicTask(
@ -366,6 +369,12 @@ void initmission::createTestTasks(TaskFactory& factory,
initmission::printAddObjectError("SPI_TEST", objects::SPI_TEST); initmission::printAddObjectError("SPI_TEST", objects::SPI_TEST);
} }
#endif #endif
#if OBSW_ADD_I2C_TEST_CODE == 1
result = testTask->addComponent(objects::I2C_TEST);
if (result != HasReturnvaluesIF::RETURN_OK) {
initmission::printAddObjectError("I2C_TEST", objects::I2C_TEST);
}
#endif
#if BOARD_TE0720 == 1 && OBSW_TEST_LIBGPIOD == 1 #if BOARD_TE0720 == 1 && OBSW_TEST_LIBGPIOD == 1
result = testTask->addComponent(objects::LIBGPIOD_TEST); result = testTask->addComponent(objects::LIBGPIOD_TEST);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {

4
bsp_q7s/core/ObjectFactory.cpp
View File

@ -1,3 +1,4 @@
#include <linux/boardtest/I2cTestClass.h>
#include "ObjectFactory.h" #include "ObjectFactory.h"
#include <sstream> #include <sstream>
@ -1130,4 +1131,7 @@ void ObjectFactory::createTestComponents(LinuxLibgpioIF* gpioComIF) {
#if OBSW_ADD_SPI_TEST_CODE == 1 #if OBSW_ADD_SPI_TEST_CODE == 1
new SpiTestClass(objects::SPI_TEST, gpioComIF); new SpiTestClass(objects::SPI_TEST, gpioComIF);
#endif #endif
#if OBSW_ADD_I2C_TEST_CODE == 1
new I2cTestClass(objects::I2C_TEST, q7s::I2C_DEFAULT_DEV);
#endif
} }

2
fsfw

@ -1 +1 @@
Subproject commit fca48257b7a156f4563d5a5a6ca71b0ab98bb9fc Subproject commit b3151a0ba033e7c72c3ead1e8958d7be596baa45

101
linux/boardtest/I2cTestClass.cpp
View File

@ -1,5 +1,100 @@
#include <linux/boardtest/I2cTestClass.h> #include "I2cTestClass.h"
#include <fsfw_hal/linux/UnixFileGuard.h>
#include "fsfw/serviceinterface.h"
#include "fsfw/globalfunctions/arrayprinter.h"
I2cTestClass::I2cTestClass(object_id_t objectId) : TestTask(objectId) {} #include <sys/ioctl.h>
#include <errno.h>
#include <linux/i2c-dev.h>
ReturnValue_t I2cTestClass::performPeriodicAction() { return HasReturnvaluesIF::RETURN_OK; } I2cTestClass::I2cTestClass(object_id_t objectId, std::string i2cdev)
: TestTask(objectId), i2cdev(i2cdev) {
mode = TestModes::BPX_BATTERY;
}
ReturnValue_t I2cTestClass::initialize() {
if(mode == TestModes::BPX_BATTERY) {
battInit();
}
return HasReturnvaluesIF::RETURN_OK;
}
ReturnValue_t I2cTestClass::performPeriodicAction() {
if(mode == TestModes::BPX_BATTERY) {
battPeriodic();
}
return HasReturnvaluesIF::RETURN_OK;
}
void I2cTestClass::battInit() {
sif::info << "I2cTestClass: BPX Initialization" << std::endl;
UnixFileGuard fileHelper(i2cdev, &bpxInfo.fd, O_RDWR, "I2cTestClass::sendMessage");
if (fileHelper.getOpenResult() != HasReturnvaluesIF::RETURN_OK) {
sif::error << "Opening I2C device" << i2cdev << " failed" << std::endl;
return;
}
if(ioctl(bpxInfo.fd, I2C_SLAVE, bpxInfo.addr) < 0) {
sif::error << "Failed to acquire bus access and/or talk to slave" << std::endl;
}
cmdBuf[0] = BpxBattery::PORT_PING;
cmdBuf[1] = 0x42;
sendLen = 2;
ReturnValue_t result = i2cWrite(bpxInfo.fd, cmdBuf.data(), sendLen);
if(result != HasReturnvaluesIF::RETURN_OK) {
return;
}
// Receive back port, error byte and ping reply
recvLen = 3;
result = i2cRead(bpxInfo.fd, replyBuf.data(), recvLen);
if(result != HasReturnvaluesIF::RETURN_OK) {
return;
}
sif::info << "Ping reply:" << std::endl;
arrayprinter::print(replyBuf.data(), recvLen);
if(replyBuf[2] != 0x42) {
sif::warning << "Received ping reply not expected value 0x42" << std::endl;
}
}
void I2cTestClass::battPeriodic() {
UnixFileGuard fileHelper(i2cdev, &bpxInfo.fd, O_RDWR, "I2cTestClass::sendMessage");
if (fileHelper.getOpenResult() != HasReturnvaluesIF::RETURN_OK) {
sif::error << "Opening I2C device" << i2cdev << " failed" << std::endl;
return;
}
if(ioctl(bpxInfo.fd, I2C_SLAVE, bpxInfo.addr) < 0) {
sif::error << "Failed to acquire bus access and/or talk to slave" << std::endl;
}
cmdBuf[0] = BpxBattery::PORT_GET_HK;
sendLen = 1;
ReturnValue_t result = i2cWrite(bpxInfo.fd, cmdBuf.data(), sendLen);
if(result != HasReturnvaluesIF::RETURN_OK) {
return;
}
// Receive back HK set
recvLen = 23;
result = i2cRead(bpxInfo.fd, replyBuf.data(), recvLen);
if(result != HasReturnvaluesIF::RETURN_OK) {
return;
}
sif::info << "HK reply:" << std::endl;
arrayprinter::print(replyBuf.data(), recvLen);
}
ReturnValue_t I2cTestClass::i2cWrite(int fd, uint8_t* data, size_t len) {
if (write(fd, data, len) != static_cast<ssize_t>(len)) {
sif::error << "Failed to write to I2C bus" << std::endl;
sif::error << "Error " << errno << ": " << strerror(errno) << std::endl;
return HasReturnvaluesIF::RETURN_FAILED;
}
return HasReturnvaluesIF::RETURN_OK;
}
ReturnValue_t I2cTestClass::i2cRead(int fd, uint8_t* data, size_t len) {
if( read (fd, data, len) != static_cast<ssize_t>(len)) {
sif::error << "Failed to read from I2C bus" << std::endl;
sif::error << "Error " << errno << ": " << strerror(errno) << std::endl;
return HasReturnvaluesIF::RETURN_FAILED;
}
return HasReturnvaluesIF::RETURN_OK;
}

29
linux/boardtest/I2cTestClass.h
View File

@ -3,13 +3,40 @@
#include <test/testtasks/TestTask.h> #include <test/testtasks/TestTask.h>
#include "mission/devices/devicedefinitions/BpxBatteryDefinitions.h"
#include <string>
#include <array>
class I2cTestClass : public TestTask { class I2cTestClass : public TestTask {
public: public:
I2cTestClass(object_id_t objectId); I2cTestClass(object_id_t objectId, std::string i2cdev);
ReturnValue_t initialize() override;
ReturnValue_t performPeriodicAction() override; ReturnValue_t performPeriodicAction() override;
private: private:
enum TestModes {
NONE,
BPX_BATTERY
};
struct I2cInfo {
int addr = 0;
int fd = 0;
};
TestModes mode = TestModes::NONE;
void battInit();
void battPeriodic();
I2cInfo bpxInfo = { .addr = 0x07, .fd = 0 };
std::string i2cdev;
size_t sendLen = 0;
size_t recvLen = 0;
std::array<uint8_t, 64> cmdBuf = {};
std::array<uint8_t, 64> replyBuf = {};
ReturnValue_t i2cWrite(int fd, uint8_t* data, size_t len);
ReturnValue_t i2cRead(int fd, uint8_t* data, size_t len);
}; };
#endif /* LINUX_BOARDTEST_I2CTESTCLASS_H_ */ #endif /* LINUX_BOARDTEST_I2CTESTCLASS_H_ */

29
linux/boardtest/UartTestClass.cpp
View File

@ -17,6 +17,25 @@
UartTestClass::UartTestClass(object_id_t objectId) : TestTask(objectId) {} UartTestClass::UartTestClass(object_id_t objectId) : TestTask(objectId) {}
ReturnValue_t UartTestClass::initialize() { ReturnValue_t UartTestClass::initialize() {
if (mode == TestModes::GPS) {
gpsInit();
}
return HasReturnvaluesIF::RETURN_OK;
}
ReturnValue_t UartTestClass::performOneShotAction() {
return HasReturnvaluesIF::RETURN_OK;
}
ReturnValue_t UartTestClass::performPeriodicAction() {
if(mode == TestModes::GPS) {
gpsPeriodic();
}
return HasReturnvaluesIF::RETURN_OK;
}
void UartTestClass::gpsInit() {
#if RPI_TEST_GPS_DEVICE == 1 #if RPI_TEST_GPS_DEVICE == 1
int result = lwgps_init(&gpsData); int result = lwgps_init(&gpsData);
if (result == 0) { if (result == 0) {
@ -62,16 +81,9 @@ ReturnValue_t UartTestClass::initialize() {
// Flush received and unread data. Those are old NMEA strings which are not relevant anymore // Flush received and unread data. Those are old NMEA strings which are not relevant anymore
tcflush(serialPort, TCIFLUSH); tcflush(serialPort, TCIFLUSH);
#endif #endif
return HasReturnvaluesIF::RETURN_OK;
} }
ReturnValue_t UartTestClass::performOneShotAction() { void UartTestClass::gpsPeriodic() {
#if RPI_TEST_GPS_DEVICE == 1
#endif
return HasReturnvaluesIF::RETURN_OK;
}
ReturnValue_t UartTestClass::performPeriodicAction() {
#if RPI_TEST_GPS_DEVICE == 1 #if RPI_TEST_GPS_DEVICE == 1
int bytesRead = 0; int bytesRead = 0;
do { do {
@ -107,5 +119,4 @@ ReturnValue_t UartTestClass::performPeriodicAction() {
} }
} while (bytesRead > 0); } while (bytesRead > 0);
#endif #endif
return HasReturnvaluesIF::RETURN_OK;
} }

9
linux/boardtest/UartTestClass.h
View File

@ -17,6 +17,15 @@ class UartTestClass : public TestTask {
ReturnValue_t performPeriodicAction() override; ReturnValue_t performPeriodicAction() override;
private: private:
enum TestModes {
GPS,
// Solar Cell Experiment
SCE
};
void gpsInit();
void gpsPeriodic();
TestModes mode = TestModes::GPS;
lwgps_t gpsData = {}; lwgps_t gpsData = {};
struct termios tty = {}; struct termios tty = {};
int serialPort = 0; int serialPort = 0;

1
linux/fsfwconfig/FSFWConfig.h.in
View File

@ -73,6 +73,7 @@ static constexpr size_t FSFW_MAX_TM_PACKET_SIZE = 2048;
} }
#define FSFW_HAL_SPI_WIRETAPPING 0 #define FSFW_HAL_SPI_WIRETAPPING 0
#define FSFW_HAL_I2C_WIRETAPPING 0
#define FSFW_DEV_HYPERION_GPS_CREATE_NMEA_CSV 0 #define FSFW_DEV_HYPERION_GPS_CREATE_NMEA_CSV 0
#define FSFW_HAL_L3GD20_GYRO_DEBUG 0 #define FSFW_HAL_L3GD20_GYRO_DEBUG 0

4
linux/fsfwconfig/OBSWConfig.h.in
View File

@ -66,9 +66,11 @@ debugging. */
#define OBSW_SWITCH_TO_NORMAL_MODE_AFTER_STARTUP 1 #define OBSW_SWITCH_TO_NORMAL_MODE_AFTER_STARTUP 1
#define OBSW_PRINT_MISSED_DEADLINES 1 #define OBSW_PRINT_MISSED_DEADLINES 1
// If this is enabled, all other SPI code should be disabled
#define OBSW_ADD_TEST_CODE 0 #define OBSW_ADD_TEST_CODE 0
// If this is enabled, all other SPI code should be disabled
#define OBSW_ADD_SPI_TEST_CODE 0 #define OBSW_ADD_SPI_TEST_CODE 0
// If this is enabled, all other I2C code should be disabled
#define OBSW_ADD_I2C_TEST_CODE 0
#define OBSW_ADD_TEST_PST 0 #define OBSW_ADD_TEST_PST 0
#define OBSW_ADD_TEST_TASK 0 #define OBSW_ADD_TEST_TASK 0
#define OBSW_TEST_LIBGPIOD 0 #define OBSW_TEST_LIBGPIOD 0

476
linux/fsfwconfig/events/translateEvents.cpp
View File

@ -122,242 +122,242 @@ 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_SENDING_PACKET_FAILED_STRING = "STR_HELPER_SENDING_PACKET_FAILED";
const char *STR_HELPER_REQUESTING_MSG_FAILED_STRING = "STR_HELPER_REQUESTING_MSG_FAILED"; const char *STR_HELPER_REQUESTING_MSG_FAILED_STRING = "STR_HELPER_REQUESTING_MSG_FAILED";
const char * translateEvents(Event event) { const char *translateEvents(Event event) {
switch( (event & 0xffff) ) { switch ((event & 0xffff)) {
case(2201): case (2201):
return STORE_WRITE_FAILED_STRING; return STORE_WRITE_FAILED_STRING;
case(2203): case (2203):
return STORE_READ_FAILED_STRING; return STORE_READ_FAILED_STRING;
case(2205): case (2205):
return STORING_FAILED_STRING; return STORING_FAILED_STRING;
case(2208): case (2208):
return STORE_INIT_EMPTY_STRING; return STORE_INIT_EMPTY_STRING;
case(2211): case (2211):
return INIT_DONE_STRING; return INIT_DONE_STRING;
case(2212): case (2212):
return DUMP_FINISHED_STRING; return DUMP_FINISHED_STRING;
case(2213): case (2213):
return DELETION_FINISHED_STRING; return DELETION_FINISHED_STRING;
case(2214): case (2214):
return DELETION_FAILED_STRING; return DELETION_FAILED_STRING;
case(2600): case (2600):
return GET_DATA_FAILED_STRING; return GET_DATA_FAILED_STRING;
case(2601): case (2601):
return STORE_DATA_FAILED_STRING; return STORE_DATA_FAILED_STRING;
case(2800): case (2800):
return DEVICE_BUILDING_COMMAND_FAILED_STRING; return DEVICE_BUILDING_COMMAND_FAILED_STRING;
case(2801): case (2801):
return DEVICE_SENDING_COMMAND_FAILED_STRING; return DEVICE_SENDING_COMMAND_FAILED_STRING;
case(2802): case (2802):
return DEVICE_REQUESTING_REPLY_FAILED_STRING; return DEVICE_REQUESTING_REPLY_FAILED_STRING;
case(2803): case (2803):
return DEVICE_READING_REPLY_FAILED_STRING; return DEVICE_READING_REPLY_FAILED_STRING;
case(2804): case (2804):
return DEVICE_INTERPRETING_REPLY_FAILED_STRING; return DEVICE_INTERPRETING_REPLY_FAILED_STRING;
case(2805): case (2805):
return DEVICE_MISSED_REPLY_STRING; return DEVICE_MISSED_REPLY_STRING;
case(2806): case (2806):
return DEVICE_UNKNOWN_REPLY_STRING; return DEVICE_UNKNOWN_REPLY_STRING;
case(2807): case (2807):
return DEVICE_UNREQUESTED_REPLY_STRING; return DEVICE_UNREQUESTED_REPLY_STRING;
case(2808): case (2808):
return INVALID_DEVICE_COMMAND_STRING; return INVALID_DEVICE_COMMAND_STRING;
case(2809): case (2809):
return MONITORING_LIMIT_EXCEEDED_STRING; return MONITORING_LIMIT_EXCEEDED_STRING;
case(2810): case (2810):
return MONITORING_AMBIGUOUS_STRING; return MONITORING_AMBIGUOUS_STRING;
case(2811): case (2811):
return DEVICE_WANTS_HARD_REBOOT_STRING; return DEVICE_WANTS_HARD_REBOOT_STRING;
case(4201): case (4201):
return FUSE_CURRENT_HIGH_STRING; return FUSE_CURRENT_HIGH_STRING;
case(4300): case (4300):
return SWITCH_WENT_OFF_STRING; return SWITCH_WENT_OFF_STRING;
case(5000): case (5000):
return HEATER_ON_STRING; return HEATER_ON_STRING;
case(5001): case (5001):
return HEATER_OFF_STRING; return HEATER_OFF_STRING;
case(5002): case (5002):
return HEATER_TIMEOUT_STRING; return HEATER_TIMEOUT_STRING;
case(5003): case (5003):
return HEATER_STAYED_ON_STRING; return HEATER_STAYED_ON_STRING;
case(5004): case (5004):
return HEATER_STAYED_OFF_STRING; return HEATER_STAYED_OFF_STRING;
case(5200): case (5200):
return TEMP_SENSOR_HIGH_STRING; return TEMP_SENSOR_HIGH_STRING;
case(5201): case (5201):
return TEMP_SENSOR_LOW_STRING; return TEMP_SENSOR_LOW_STRING;
case(5202): case (5202):
return TEMP_SENSOR_GRADIENT_STRING; return TEMP_SENSOR_GRADIENT_STRING;
case(5901): case (5901):
return COMPONENT_TEMP_LOW_STRING; return COMPONENT_TEMP_LOW_STRING;
case(5902): case (5902):
return COMPONENT_TEMP_HIGH_STRING; return COMPONENT_TEMP_HIGH_STRING;
case(5903): case (5903):
return COMPONENT_TEMP_OOL_LOW_STRING; return COMPONENT_TEMP_OOL_LOW_STRING;
case(5904): case (5904):
return COMPONENT_TEMP_OOL_HIGH_STRING; return COMPONENT_TEMP_OOL_HIGH_STRING;
case(5905): case (5905):
return TEMP_NOT_IN_OP_RANGE_STRING; return TEMP_NOT_IN_OP_RANGE_STRING;
case(7102): case (7102):
return FDIR_STARTS_RECOVERY_STRING; return FDIR_STARTS_RECOVERY_STRING;
case(7103): case (7103):
return FDIR_TURNS_OFF_DEVICE_STRING; return FDIR_TURNS_OFF_DEVICE_STRING;
case(7201): case (7201):
return MONITOR_CHANGED_STATE_STRING; return MONITOR_CHANGED_STATE_STRING;
case(7202): case (7202):
return VALUE_BELOW_LOW_LIMIT_STRING; return VALUE_BELOW_LOW_LIMIT_STRING;
case(7203): case (7203):
return VALUE_ABOVE_HIGH_LIMIT_STRING; return VALUE_ABOVE_HIGH_LIMIT_STRING;
case(7204): case (7204):
return VALUE_OUT_OF_RANGE_STRING; return VALUE_OUT_OF_RANGE_STRING;
case(7401): case (7401):
return MODE_INFO_STRING; return MODE_INFO_STRING;
case(7402): case (7402):
return FALLBACK_FAILED_STRING; return FALLBACK_FAILED_STRING;
case(7403): case (7403):
return MODE_TRANSITION_FAILED_STRING; return MODE_TRANSITION_FAILED_STRING;
case(7404): case (7404):
return CANT_KEEP_MODE_STRING; return CANT_KEEP_MODE_STRING;
case(7406): case (7406):
return FORCING_MODE_STRING; return FORCING_MODE_STRING;
case(7506): case (7506):
return HEALTH_INFO_STRING; return HEALTH_INFO_STRING;
case(7507): case (7507):
return CHILD_CHANGED_HEALTH_STRING; return CHILD_CHANGED_HEALTH_STRING;
case(7508): case (7508):
return CHILD_PROBLEMS_STRING; return CHILD_PROBLEMS_STRING;
case(7512): case (7512):
return RECOVERY_DONE_STRING; return RECOVERY_DONE_STRING;
case(7900): case (7900):
return RF_AVAILABLE_STRING; return RF_AVAILABLE_STRING;
case(7901): case (7901):
return RF_LOST_STRING; return RF_LOST_STRING;
case(7902): case (7902):
return BIT_LOCK_STRING; return BIT_LOCK_STRING;
case(7903): case (7903):
return BIT_LOCK_LOST_STRING; return BIT_LOCK_LOST_STRING;
case(7905): case (7905):
return FRAME_PROCESSING_FAILED_STRING; return FRAME_PROCESSING_FAILED_STRING;
case(9700): case (9700):
return TEST_STRING; return TEST_STRING;
case(10600): case (10600):
return CHANGE_OF_SETUP_PARAMETER_STRING; return CHANGE_OF_SETUP_PARAMETER_STRING;
case(10900): case (10900):
return GPIO_PULL_HIGH_FAILED_STRING; return GPIO_PULL_HIGH_FAILED_STRING;
case(10901): case (10901):
return GPIO_PULL_LOW_FAILED_STRING; return GPIO_PULL_LOW_FAILED_STRING;
case(10902): case (10902):
return SWITCH_ALREADY_ON_STRING; return SWITCH_ALREADY_ON_STRING;
case(10903): case (10903):
return SWITCH_ALREADY_OFF_STRING; return SWITCH_ALREADY_OFF_STRING;
case(10904): case (10904):
return MAIN_SWITCH_TIMEOUT_STRING; return MAIN_SWITCH_TIMEOUT_STRING;
case(11000): case (11000):
return MAIN_SWITCH_ON_TIMEOUT_STRING; return MAIN_SWITCH_ON_TIMEOUT_STRING;
case(11001): case (11001):
return MAIN_SWITCH_OFF_TIMEOUT_STRING; return MAIN_SWITCH_OFF_TIMEOUT_STRING;
case(11002): case (11002):
return DEPLOYMENT_FAILED_STRING; return DEPLOYMENT_FAILED_STRING;
case(11003): case (11003):
return DEPL_SA1_GPIO_SWTICH_ON_FAILED_STRING; return DEPL_SA1_GPIO_SWTICH_ON_FAILED_STRING;
case(11004): case (11004):
return DEPL_SA2_GPIO_SWTICH_ON_FAILED_STRING; return DEPL_SA2_GPIO_SWTICH_ON_FAILED_STRING;
case(11201): case (11201):
return SELF_TEST_I2C_FAILURE_STRING; return SELF_TEST_I2C_FAILURE_STRING;
case(11202): case (11202):
return SELF_TEST_SPI_FAILURE_STRING; return SELF_TEST_SPI_FAILURE_STRING;
case(11203): case (11203):
return SELF_TEST_ADC_FAILURE_STRING; return SELF_TEST_ADC_FAILURE_STRING;
case(11204): case (11204):
return SELF_TEST_PWM_FAILURE_STRING; return SELF_TEST_PWM_FAILURE_STRING;
case(11205): case (11205):
return SELF_TEST_TC_FAILURE_STRING; return SELF_TEST_TC_FAILURE_STRING;
case(11206): case (11206):
return SELF_TEST_MTM_RANGE_FAILURE_STRING; return SELF_TEST_MTM_RANGE_FAILURE_STRING;
case(11207): case (11207):
return SELF_TEST_COIL_CURRENT_FAILURE_STRING; return SELF_TEST_COIL_CURRENT_FAILURE_STRING;
case(11208): case (11208):
return INVALID_ERROR_BYTE_STRING; return INVALID_ERROR_BYTE_STRING;
case(11301): case (11301):
return ERROR_STATE_STRING; return ERROR_STATE_STRING;
case(11501): case (11501):
return SUPV_MEMORY_READ_RPT_CRC_FAILURE_STRING; return SUPV_MEMORY_READ_RPT_CRC_FAILURE_STRING;
case(11502): case (11502):
return SUPV_ACK_FAILURE_STRING; return SUPV_ACK_FAILURE_STRING;
case(11503): case (11503):
return SUPV_EXE_FAILURE_STRING; return SUPV_EXE_FAILURE_STRING;
case(11504): case (11504):
return SUPV_CRC_FAILURE_EVENT_STRING; return SUPV_CRC_FAILURE_EVENT_STRING;
case(11600): case (11600):
return SANITIZATION_FAILED_STRING; return SANITIZATION_FAILED_STRING;
case(11700): case (11700):
return UPDATE_FILE_NOT_EXISTS_STRING; return UPDATE_FILE_NOT_EXISTS_STRING;
case(11701): case (11701):
return ACTION_COMMANDING_FAILED_STRING; return ACTION_COMMANDING_FAILED_STRING;
case(11702): case (11702):
return UPDATE_AVAILABLE_FAILED_STRING; return UPDATE_AVAILABLE_FAILED_STRING;
case(11703): case (11703):
return UPDATE_TRANSFER_FAILED_STRING; return UPDATE_TRANSFER_FAILED_STRING;
case(11704): case (11704):
return UPDATE_VERIFY_FAILED_STRING; return UPDATE_VERIFY_FAILED_STRING;
case(11705): case (11705):
return UPDATE_FINISHED_STRING; return UPDATE_FINISHED_STRING;
case(11800): case (11800):
return SEND_MRAM_DUMP_FAILED_STRING; return SEND_MRAM_DUMP_FAILED_STRING;
case(11801): case (11801):
return MRAM_DUMP_FAILED_STRING; return MRAM_DUMP_FAILED_STRING;
case(11802): case (11802):
return MRAM_DUMP_FINISHED_STRING; return MRAM_DUMP_FINISHED_STRING;
case(11901): case (11901):
return INVALID_TC_FRAME_STRING; return INVALID_TC_FRAME_STRING;
case(11902): case (11902):
return INVALID_FAR_STRING; return INVALID_FAR_STRING;
case(11903): case (11903):
return CARRIER_LOCK_STRING; return CARRIER_LOCK_STRING;
case(11904): case (11904):
return BIT_LOCK_PDEC_STRING; return BIT_LOCK_PDEC_STRING;
case(12000): case (12000):
return IMAGE_UPLOAD_FAILED_STRING; return IMAGE_UPLOAD_FAILED_STRING;
case(12001): case (12001):
return IMAGE_DOWNLOAD_FAILED_STRING; return IMAGE_DOWNLOAD_FAILED_STRING;
case(12002): case (12002):
return IMAGE_UPLOAD_SUCCESSFUL_STRING; return IMAGE_UPLOAD_SUCCESSFUL_STRING;
case(12003): case (12003):
return IMAGE_DOWNLOAD_SUCCESSFUL_STRING; return IMAGE_DOWNLOAD_SUCCESSFUL_STRING;
case(12004): case (12004):
return FLASH_WRITE_SUCCESSFUL_STRING; return FLASH_WRITE_SUCCESSFUL_STRING;
case(12005): case (12005):
return FLASH_READ_SUCCESSFUL_STRING; return FLASH_READ_SUCCESSFUL_STRING;
case(12006): case (12006):
return FLASH_WRITE_FAILED_STRING; return FLASH_WRITE_FAILED_STRING;
case(12007): case (12007):
return FLASH_READ_FAILED_STRING; return FLASH_READ_FAILED_STRING;
case(12008): case (12008):
return FPGA_DOWNLOAD_SUCCESSFUL_STRING; return FPGA_DOWNLOAD_SUCCESSFUL_STRING;
case(12009): case (12009):
return FPGA_DOWNLOAD_FAILED_STRING; return FPGA_DOWNLOAD_FAILED_STRING;
case(12010): case (12010):
return FPGA_UPLOAD_SUCCESSFUL_STRING; return FPGA_UPLOAD_SUCCESSFUL_STRING;
case(12011): case (12011):
return FPGA_UPLOAD_FAILED_STRING; return FPGA_UPLOAD_FAILED_STRING;
case(12012): case (12012):
return STR_HELPER_READING_REPLY_FAILED_STRING; return STR_HELPER_READING_REPLY_FAILED_STRING;
case(12013): case (12013):
return STR_HELPER_COM_ERROR_STRING; return STR_HELPER_COM_ERROR_STRING;
case(12014): case (12014):
return STR_HELPER_NO_REPLY_STRING; return STR_HELPER_NO_REPLY_STRING;
case(12015): case (12015):
return STR_HELPER_DEC_ERROR_STRING; return STR_HELPER_DEC_ERROR_STRING;
case(12016): case (12016):
return POSITION_MISMATCH_STRING; return POSITION_MISMATCH_STRING;
case(12017): case (12017):
return STR_HELPER_FILE_NOT_EXISTS_STRING; return STR_HELPER_FILE_NOT_EXISTS_STRING;
case(12018): case (12018):
return STR_HELPER_SENDING_PACKET_FAILED_STRING; return STR_HELPER_SENDING_PACKET_FAILED_STRING;
case(12019): case (12019):
return STR_HELPER_REQUESTING_MSG_FAILED_STRING; return STR_HELPER_REQUESTING_MSG_FAILED_STRING;
default: default:
return "UNKNOWN_EVENT"; return "UNKNOWN_EVENT";
} }
return 0; return 0;
} }

2
linux/fsfwconfig/events/translateEvents.h
View File

@ -3,6 +3,6 @@
#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_ */ #endif /* FSFWCONFIG_EVENTS_TRANSLATEEVENTS_H_ */

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

@ -62,6 +62,7 @@ enum sourceObjects : uint32_t {
LIBGPIOD_TEST = 0x54123456, LIBGPIOD_TEST = 0x54123456,
SPI_TEST = 0x54000010, SPI_TEST = 0x54000010,
UART_TEST = 0x54000020, UART_TEST = 0x54000020,
I2C_TEST = 0x54000030,
DUMMY_INTERFACE = 0x5400CAFE, DUMMY_INTERFACE = 0x5400CAFE,
DUMMY_HANDLER = 0x5400AFFE, DUMMY_HANDLER = 0x5400AFFE,
P60DOCK_TEST_TASK = 0x00005060, P60DOCK_TEST_TASK = 0x00005060,

452
linux/fsfwconfig/objects/translateObjects.cpp
View File

@ -117,230 +117,230 @@ const char *TM_FUNNEL_STRING = "TM_FUNNEL";
const char *CCSDS_IP_CORE_BRIDGE_STRING = "CCSDS_IP_CORE_BRIDGE"; const char *CCSDS_IP_CORE_BRIDGE_STRING = "CCSDS_IP_CORE_BRIDGE";
const char *NO_OBJECT_STRING = "NO_OBJECT"; const char *NO_OBJECT_STRING = "NO_OBJECT";
const char* translateObject(object_id_t object) { const char *translateObject(object_id_t object) {
switch( (object & 0xFFFFFFFF) ) { switch ((object & 0xFFFFFFFF)) {
case 0x00005060: case 0x00005060:
return P60DOCK_TEST_TASK_STRING; return P60DOCK_TEST_TASK_STRING;
case 0x43000003: case 0x43000003:
return CORE_CONTROLLER_STRING; return CORE_CONTROLLER_STRING;
case 0x43100002: case 0x43100002:
return ACS_CONTROLLER_STRING; return ACS_CONTROLLER_STRING;
case 0x43400001: case 0x43400001:
return THERMAL_CONTROLLER_STRING; return THERMAL_CONTROLLER_STRING;
case 0x44120006: case 0x44120006:
return MGM_0_LIS3_HANDLER_STRING; return MGM_0_LIS3_HANDLER_STRING;
case 0x44120010: case 0x44120010:
return GYRO_0_ADIS_HANDLER_STRING; return GYRO_0_ADIS_HANDLER_STRING;
case 0x44120032: case 0x44120032:
return SUS_1_STRING; return SUS_1_STRING;
case 0x44120033: case 0x44120033:
return SUS_2_STRING; return SUS_2_STRING;
case 0x44120034: case 0x44120034:
return SUS_3_STRING; return SUS_3_STRING;
case 0x44120035: case 0x44120035:
return SUS_4_STRING; return SUS_4_STRING;
case 0x44120036: case 0x44120036:
return SUS_5_STRING; return SUS_5_STRING;
case 0x44120037: case 0x44120037:
return SUS_6_STRING; return SUS_6_STRING;
case 0x44120038: case 0x44120038:
return SUS_7_STRING; return SUS_7_STRING;
case 0x44120039: case 0x44120039:
return SUS_8_STRING; return SUS_8_STRING;
case 0x44120040: case 0x44120040:
return SUS_9_STRING; return SUS_9_STRING;
case 0x44120041: case 0x44120041:
return SUS_10_STRING; return SUS_10_STRING;
case 0x44120042: case 0x44120042:
return SUS_11_STRING; return SUS_11_STRING;
case 0x44120043: case 0x44120043:
return SUS_12_STRING; return SUS_12_STRING;
case 0x44120044: case 0x44120044:
return SUS_13_STRING; return SUS_13_STRING;
case 0x44120047: case 0x44120047:
return RW1_STRING; return RW1_STRING;
case 0x44120107: case 0x44120107:
return MGM_1_RM3100_HANDLER_STRING; return MGM_1_RM3100_HANDLER_STRING;
case 0x44120111: case 0x44120111:
return GYRO_1_L3G_HANDLER_STRING; return GYRO_1_L3G_HANDLER_STRING;
case 0x44120148: case 0x44120148:
return RW2_STRING; return RW2_STRING;
case 0x44120208: case 0x44120208:
return MGM_2_LIS3_HANDLER_STRING; return MGM_2_LIS3_HANDLER_STRING;
case 0x44120212: case 0x44120212:
return GYRO_2_ADIS_HANDLER_STRING; return GYRO_2_ADIS_HANDLER_STRING;
case 0x44120249: case 0x44120249:
return RW3_STRING; return RW3_STRING;
case 0x44120309: case 0x44120309:
return MGM_3_RM3100_HANDLER_STRING; return MGM_3_RM3100_HANDLER_STRING;
case 0x44120313: case 0x44120313:
return GYRO_3_L3G_HANDLER_STRING; return GYRO_3_L3G_HANDLER_STRING;
case 0x44120350: case 0x44120350:
return RW4_STRING; return RW4_STRING;
case 0x44130001: case 0x44130001:
return STAR_TRACKER_STRING; return STAR_TRACKER_STRING;
case 0x44130045: case 0x44130045:
return GPS_CONTROLLER_STRING; return GPS_CONTROLLER_STRING;
case 0x44140014: case 0x44140014:
return IMTQ_HANDLER_STRING; return IMTQ_HANDLER_STRING;
case 0x442000A1: case 0x442000A1:
return PCDU_HANDLER_STRING; return PCDU_HANDLER_STRING;
case 0x44250000: case 0x44250000:
return P60DOCK_HANDLER_STRING; return P60DOCK_HANDLER_STRING;
case 0x44250001: case 0x44250001:
return PDU1_HANDLER_STRING; return PDU1_HANDLER_STRING;
case 0x44250002: case 0x44250002:
return PDU2_HANDLER_STRING; return PDU2_HANDLER_STRING;
case 0x44250003: case 0x44250003:
return ACU_HANDLER_STRING; return ACU_HANDLER_STRING;
case 0x44260000: case 0x44260000:
return BPX_BATT_HANDLER_STRING; return BPX_BATT_HANDLER_STRING;
case 0x443200A5: case 0x443200A5:
return RAD_SENSOR_STRING; return RAD_SENSOR_STRING;
case 0x44330000: case 0x44330000:
return PLOC_UPDATER_STRING; return PLOC_UPDATER_STRING;
case 0x44330001: case 0x44330001:
return PLOC_MEMORY_DUMPER_STRING; return PLOC_MEMORY_DUMPER_STRING;
case 0x44330002: case 0x44330002:
return STR_HELPER_STRING; return STR_HELPER_STRING;
case 0x44330015: case 0x44330015:
return PLOC_MPSOC_HANDLER_STRING; return PLOC_MPSOC_HANDLER_STRING;
case 0x44330016: case 0x44330016:
return PLOC_SUPERVISOR_HANDLER_STRING; return PLOC_SUPERVISOR_HANDLER_STRING;
case 0x444100A2: case 0x444100A2:
return SOLAR_ARRAY_DEPL_HANDLER_STRING; return SOLAR_ARRAY_DEPL_HANDLER_STRING;
case 0x444100A4: case 0x444100A4:
return HEATER_HANDLER_STRING; return HEATER_HANDLER_STRING;
case 0x44420004: case 0x44420004:
return TMP1075_HANDLER_1_STRING; return TMP1075_HANDLER_1_STRING;
case 0x44420005: case 0x44420005:
return TMP1075_HANDLER_2_STRING; return TMP1075_HANDLER_2_STRING;
case 0x44420016: case 0x44420016:
return RTD_IC_3_STRING; return RTD_IC_3_STRING;
case 0x44420017: case 0x44420017:
return RTD_IC_4_STRING; return RTD_IC_4_STRING;
case 0x44420018: case 0x44420018:
return RTD_IC_5_STRING; return RTD_IC_5_STRING;
case 0x44420019: case 0x44420019:
return RTD_IC_6_STRING; return RTD_IC_6_STRING;
case 0x44420020: case 0x44420020:
return RTD_IC_7_STRING; return RTD_IC_7_STRING;
case 0x44420021: case 0x44420021:
return RTD_IC_8_STRING; return RTD_IC_8_STRING;
case 0x44420022: case 0x44420022:
return RTD_IC_9_STRING; return RTD_IC_9_STRING;
case 0x44420023: case 0x44420023:
return RTD_IC_10_STRING; return RTD_IC_10_STRING;
case 0x44420024: case 0x44420024:
return RTD_IC_11_STRING; return RTD_IC_11_STRING;
case 0x44420025: case 0x44420025:
return RTD_IC_12_STRING; return RTD_IC_12_STRING;
case 0x44420026: case 0x44420026:
return RTD_IC_13_STRING; return RTD_IC_13_STRING;
case 0x44420027: case 0x44420027:
return RTD_IC_14_STRING; return RTD_IC_14_STRING;
case 0x44420028: case 0x44420028:
return RTD_IC_15_STRING; return RTD_IC_15_STRING;
case 0x44420029: case 0x44420029:
return RTD_IC_16_STRING; return RTD_IC_16_STRING;
case 0x44420030: case 0x44420030:
return RTD_IC_17_STRING; return RTD_IC_17_STRING;
case 0x44420031: case 0x44420031:
return RTD_IC_18_STRING; return RTD_IC_18_STRING;
case 0x445300A3: case 0x445300A3:
return SYRLINKS_HK_HANDLER_STRING; return SYRLINKS_HK_HANDLER_STRING;
case 0x49000000: case 0x49000000:
return ARDUINO_COM_IF_STRING; return ARDUINO_COM_IF_STRING;
case 0x49010005: case 0x49010005:
return GPIO_IF_STRING; return GPIO_IF_STRING;
case 0x49020004: case 0x49020004:
return SPI_COM_IF_STRING; return SPI_COM_IF_STRING;
case 0x49030003: case 0x49030003:
return UART_COM_IF_STRING; return UART_COM_IF_STRING;
case 0x49040002: case 0x49040002:
return I2C_COM_IF_STRING; return I2C_COM_IF_STRING;
case 0x49050001: case 0x49050001:
return CSP_COM_IF_STRING; return CSP_COM_IF_STRING;
case 0x50000100: case 0x50000100:
return CCSDS_PACKET_DISTRIBUTOR_STRING; return CCSDS_PACKET_DISTRIBUTOR_STRING;
case 0x50000200: case 0x50000200:
return PUS_PACKET_DISTRIBUTOR_STRING; return PUS_PACKET_DISTRIBUTOR_STRING;
case 0x50000300: case 0x50000300:
return TMTC_BRIDGE_STRING; return TMTC_BRIDGE_STRING;
case 0x50000400: case 0x50000400:
return TMTC_POLLING_TASK_STRING; return TMTC_POLLING_TASK_STRING;
case 0x50000500: case 0x50000500:
return FILE_SYSTEM_HANDLER_STRING; return FILE_SYSTEM_HANDLER_STRING;
case 0x50000600: case 0x50000600:
return PTME_STRING; return PTME_STRING;
case 0x50000700: case 0x50000700:
return PDEC_HANDLER_STRING; return PDEC_HANDLER_STRING;
case 0x50000800: case 0x50000800:
return CCSDS_HANDLER_STRING; return CCSDS_HANDLER_STRING;
case 0x51000500: case 0x51000500:
return PUS_SERVICE_6_STRING; return PUS_SERVICE_6_STRING;
case 0x53000000: case 0x53000000:
return FSFW_OBJECTS_START_STRING; return FSFW_OBJECTS_START_STRING;
case 0x53000001: case 0x53000001:
return PUS_SERVICE_1_VERIFICATION_STRING; return PUS_SERVICE_1_VERIFICATION_STRING;
case 0x53000002: case 0x53000002:
return PUS_SERVICE_2_DEVICE_ACCESS_STRING; return PUS_SERVICE_2_DEVICE_ACCESS_STRING;
case 0x53000003: case 0x53000003:
return PUS_SERVICE_3_HOUSEKEEPING_STRING; return PUS_SERVICE_3_HOUSEKEEPING_STRING;
case 0x53000005: case 0x53000005:
return PUS_SERVICE_5_EVENT_REPORTING_STRING; return PUS_SERVICE_5_EVENT_REPORTING_STRING;
case 0x53000008: case 0x53000008:
return PUS_SERVICE_8_FUNCTION_MGMT_STRING; return PUS_SERVICE_8_FUNCTION_MGMT_STRING;
case 0x53000009: case 0x53000009:
return PUS_SERVICE_9_TIME_MGMT_STRING; return PUS_SERVICE_9_TIME_MGMT_STRING;
case 0x53000017: case 0x53000017:
return PUS_SERVICE_17_TEST_STRING; return PUS_SERVICE_17_TEST_STRING;
case 0x53000020: case 0x53000020:
return PUS_SERVICE_20_PARAMETERS_STRING; return PUS_SERVICE_20_PARAMETERS_STRING;
case 0x53000200: case 0x53000200:
return PUS_SERVICE_200_MODE_MGMT_STRING; return PUS_SERVICE_200_MODE_MGMT_STRING;
case 0x53000201: case 0x53000201:
return PUS_SERVICE_201_HEALTH_STRING; return PUS_SERVICE_201_HEALTH_STRING;
case 0x53001000: case 0x53001000:
return CFDP_PACKET_DISTRIBUTOR_STRING; return CFDP_PACKET_DISTRIBUTOR_STRING;
case 0x53010000: case 0x53010000:
return HEALTH_TABLE_STRING; return HEALTH_TABLE_STRING;
case 0x53010100: case 0x53010100:
return MODE_STORE_STRING; return MODE_STORE_STRING;
case 0x53030000: case 0x53030000:
return EVENT_MANAGER_STRING; return EVENT_MANAGER_STRING;
case 0x53040000: case 0x53040000:
return INTERNAL_ERROR_REPORTER_STRING; return INTERNAL_ERROR_REPORTER_STRING;
case 0x534f0100: case 0x534f0100:
return TC_STORE_STRING; return TC_STORE_STRING;
case 0x534f0200: case 0x534f0200:
return TM_STORE_STRING; return TM_STORE_STRING;
case 0x534f0300: case 0x534f0300:
return IPC_STORE_STRING; return IPC_STORE_STRING;
case 0x53500010: case 0x53500010:
return TIME_STAMPER_STRING; return TIME_STAMPER_STRING;
case 0x53ffffff: case 0x53ffffff:
return FSFW_OBJECTS_END_STRING; return FSFW_OBJECTS_END_STRING;
case 0x54000010: case 0x54000010:
return SPI_TEST_STRING; return SPI_TEST_STRING;
case 0x54000020: case 0x54000020:
return UART_TEST_STRING; return UART_TEST_STRING;
case 0x5400AFFE: case 0x5400AFFE:
return DUMMY_HANDLER_STRING; return DUMMY_HANDLER_STRING;
case 0x5400CAFE: case 0x5400CAFE:
return DUMMY_INTERFACE_STRING; return DUMMY_INTERFACE_STRING;
case 0x54123456: case 0x54123456:
return LIBGPIOD_TEST_STRING; return LIBGPIOD_TEST_STRING;
case 0x54694269: case 0x54694269:
return TEST_TASK_STRING; return TEST_TASK_STRING;
case 0x73000100: case 0x73000100:
return TM_FUNNEL_STRING; return TM_FUNNEL_STRING;
case 0x73500000: case 0x73500000:
return CCSDS_IP_CORE_BRIDGE_STRING; return CCSDS_IP_CORE_BRIDGE_STRING;
case 0xFFFFFFFF: case 0xFFFFFFFF:
return NO_OBJECT_STRING; return NO_OBJECT_STRING;
default: default:
return "UNKNOWN_OBJECT"; return "UNKNOWN_OBJECT";
} }
return 0; return 0;
} }

68
mission/devices/BpxBatteryHandler.cpp
View File

@ -1,11 +1,11 @@
#include "BpxBatteryHandler.h" #include "BpxBatteryHandler.h"
#include "OBSWConfig.h"
#include <fsfw/datapool/PoolReadGuard.h> #include <fsfw/datapool/PoolReadGuard.h>
#include "OBSWConfig.h"
BpxBatteryHandler::BpxBatteryHandler(object_id_t objectId, object_id_t comIF, CookieIF* comCookie) BpxBatteryHandler::BpxBatteryHandler(object_id_t objectId, object_id_t comIF, CookieIF* comCookie)
: DeviceHandlerBase(objectId, comIF, comCookie), hkSet(this), cfgSet(this) { : DeviceHandlerBase(objectId, comIF, comCookie), hkSet(this), cfgSet(this) {}
}
BpxBatteryHandler::~BpxBatteryHandler() {} BpxBatteryHandler::~BpxBatteryHandler() {}
@ -34,7 +34,7 @@ ReturnValue_t BpxBatteryHandler::buildNormalDeviceCommand(DeviceCommandId_t* id)
} }
ReturnValue_t BpxBatteryHandler::buildTransitionDeviceCommand(DeviceCommandId_t* id) { ReturnValue_t BpxBatteryHandler::buildTransitionDeviceCommand(DeviceCommandId_t* id) {
if(state == States::CHECK_COM) { if (state == States::CHECK_COM) {
*id = BpxBattery::PING; *id = BpxBattery::PING;
return buildCommandFromCommand(*id, nullptr, 0); return buildCommandFromCommand(*id, nullptr, 0);
} }
@ -42,18 +42,23 @@ ReturnValue_t BpxBatteryHandler::buildTransitionDeviceCommand(DeviceCommandId_t*
} }
void BpxBatteryHandler::fillCommandAndReplyMap() { void BpxBatteryHandler::fillCommandAndReplyMap() {
insertInCommandAndReplyMap(BpxBattery::GET_HK, 1, &hkSet); insertInCommandAndReplyMap(BpxBattery::GET_HK, 1, &hkSet, 23);
insertInCommandAndReplyMap(BpxBattery::PING, 1); insertInCommandAndReplyMap(BpxBattery::PING, 1, nullptr, 3);
insertInCommandAndReplyMap(BpxBattery::REBOOT, 1); insertInCommandAndReplyMap(BpxBattery::REBOOT, 1);
insertInCommandAndReplyMap(BpxBattery::RESET_COUNTERS, 1); insertInCommandAndReplyMap(BpxBattery::RESET_COUNTERS, 1);
insertInCommandAndReplyMap(BpxBattery::CONFIG_CMD, 1); insertInCommandAndReplyMap(BpxBattery::CONFIG_CMD, 1);
insertInCommandAndReplyMap(BpxBattery::CONFIG_GET, 1, &cfgSet); insertInCommandAndReplyMap(BpxBattery::CONFIG_GET, 1, &cfgSet, 3);
} }
ReturnValue_t BpxBatteryHandler::buildCommandFromCommand(DeviceCommandId_t deviceCommand, ReturnValue_t BpxBatteryHandler::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
const uint8_t* commandData, const uint8_t* commandData,
size_t commandDataLen) { size_t commandDataLen) {
switch (deviceCommand) { switch (deviceCommand) {
case (BpxBattery::GET_HK): {
cmdBuf[0] = BpxBattery::PORT_GET_HK;
this->rawPacketLen = 1;
break;
}
case (BpxBattery::PING): { case (BpxBattery::PING): {
if (commandDataLen == 1 and commandData != nullptr) { if (commandDataLen == 1 and commandData != nullptr) {
sentPingByte = commandData[0]; sentPingByte = commandData[0];
@ -137,42 +142,40 @@ ReturnValue_t BpxBatteryHandler::scanForReply(const uint8_t* start, size_t remai
DeviceCommandId_t* foundId, size_t* foundLen) { DeviceCommandId_t* foundId, size_t* foundLen) {
switch (lastCmd) { switch (lastCmd) {
case (BpxBattery::GET_HK): { case (BpxBattery::GET_HK): {
if (remainingSize != 21) { if (remainingSize != 23) {
return DeviceHandlerIF::LENGTH_MISSMATCH; return DeviceHandlerIF::LENGTH_MISSMATCH;
} }
*foundLen = 21;
break; break;
} }
case (BpxBattery::PING): case (BpxBattery::PING):
case (BpxBattery::MAN_HEAT_ON): case (BpxBattery::MAN_HEAT_ON):
case (BpxBattery::MAN_HEAT_OFF): { case (BpxBattery::MAN_HEAT_OFF): {
if (remainingSize != 1) { if (remainingSize != 3) {
return DeviceHandlerIF::LENGTH_MISSMATCH; return DeviceHandlerIF::LENGTH_MISSMATCH;
} }
*foundLen = 1;
break; break;
} }
case (BpxBattery::REBOOT): case (BpxBattery::REBOOT):
case (BpxBattery::RESET_COUNTERS): case (BpxBattery::RESET_COUNTERS):
case (BpxBattery::CONFIG_CMD): case (BpxBattery::CONFIG_CMD):
case (BpxBattery::CONFIG_SET): { case (BpxBattery::CONFIG_SET): {
if (remainingSize != 0) { if (remainingSize != 2) {
return DeviceHandlerIF::LENGTH_MISSMATCH; return DeviceHandlerIF::LENGTH_MISSMATCH;
} }
*foundLen = 0;
break; break;
} }
case (BpxBattery::CONFIG_GET): { case (BpxBattery::CONFIG_GET): {
if (remainingSize != 3) { if (remainingSize != 5) {
return DeviceHandlerIF::LENGTH_MISSMATCH; return DeviceHandlerIF::LENGTH_MISSMATCH;
} }
*foundLen = 3;
break; break;
} }
default: { default: {
return DeviceHandlerIF::UNKNOWN_DEVICE_REPLY; return DeviceHandlerIF::UNKNOWN_DEVICE_REPLY;
} }
} }
*foundLen = remainingSize;
*foundId = lastCmd; *foundId = lastCmd;
return HasReturnvaluesIF::RETURN_OK; return HasReturnvaluesIF::RETURN_OK;
} }
@ -181,30 +184,30 @@ ReturnValue_t BpxBatteryHandler::interpretDeviceReply(DeviceCommandId_t id, cons
switch (id) { switch (id) {
case (BpxBattery::GET_HK): { case (BpxBattery::GET_HK): {
PoolReadGuard rg(&hkSet); PoolReadGuard rg(&hkSet);
ReturnValue_t result = hkSet.parseRawHk(packet, 21); ReturnValue_t result = hkSet.parseRawHk(packet + 2, 21);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
#if OBSW_DEBUG_BPX_BATT == 1 #if OBSW_DEBUG_BPX_BATT == 1
sif::info << "BPX Battery HK output:" << std::endl; sif::info << "BPX Battery HK output:" << std::endl;
sif::info << "Charge current [mA]: " << hkSet.chargeCurrent << std::endl; sif::info << "Charge current [mA]: " << hkSet.chargeCurrent << std::endl;
sif::info << "Discharge current [mA]; " << hkSet.dischargeCurrent << std::endl; sif::info << "Discharge current [mA]: " << hkSet.dischargeCurrent << std::endl;
sif::info << "Heater current [mA]: " << hkSet.heaterCurrent << std::endl; sif::info << "Heater current [mA]: " << hkSet.heaterCurrent << std::endl;
sif::info << "Battery voltage [mV]: " << hkSet.battVoltage << std::endl; sif::info << "Battery voltage [mV]: " << hkSet.battVoltage << std::endl;
sif::info << "Battery Temperature 1 [C]: " << hkSet.battTemp1 << std::endl; sif::info << "Battery Temperature 1 [C]: " << hkSet.battTemp1 << std::endl;
sif::info << "Battery Temperature 2 [C]: " << hkSet.battTemp2 << std::endl; sif::info << "Battery Temperature 2 [C]: " << hkSet.battTemp2 << std::endl;
sif::info << "Battery Temperature 3 [C]: " << hkSet.battTemp3 << std::endl; sif::info << "Battery Temperature 3 [C]: " << hkSet.battTemp3 << std::endl;
sif::info << "Battery Temperature 4 [C]: " << hkSet.battTemp4 << std::endl; sif::info << "Battery Temperature 4 [C]: " << hkSet.battTemp4 << std::endl;
sif::info << "Battery Reboot Counter: " << hkSet.rebootCounter << std::endl; sif::info << "Battery Reboot Counter: " << hkSet.rebootCounter << std::endl;
sif::info << "Battery Boot Cause: " << hkSet.bootcause << std::endl; sif::info << "Battery Boot Cause: " << static_cast<int>(hkSet.bootcause.value) << std::endl;
#endif #endif
break; break;
} }
case (BpxBattery::PING): { case (BpxBattery::PING): {
if (packet[0] != sentPingByte) { if (packet[2] != sentPingByte) {
return DeviceHandlerIF::INVALID_DATA; return DeviceHandlerIF::INVALID_DATA;
} }
if(mode == _MODE_START_UP) { if (mode == _MODE_START_UP) {
commandExecuted = true; commandExecuted = true;
} }
break; break;
@ -216,14 +219,14 @@ ReturnValue_t BpxBatteryHandler::interpretDeviceReply(DeviceCommandId_t id, cons
} }
case (BpxBattery::MAN_HEAT_ON): case (BpxBattery::MAN_HEAT_ON):
case (BpxBattery::MAN_HEAT_OFF): { case (BpxBattery::MAN_HEAT_OFF): {
if (packet[0] != 0x01) { if (packet[2] != 0x01) {
return DeviceHandlerIF::DEVICE_DID_NOT_EXECUTE; return DeviceHandlerIF::DEVICE_DID_NOT_EXECUTE;
} }
break; break;
} }
case (BpxBattery::CONFIG_GET): { case (BpxBattery::CONFIG_GET): {
PoolReadGuard rg(&cfgSet); PoolReadGuard rg(&cfgSet);
ReturnValue_t result = cfgSet.parseRawHk(packet, 3); ReturnValue_t result = cfgSet.parseRawHk(packet + 2, 3);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
@ -250,6 +253,7 @@ ReturnValue_t BpxBatteryHandler::initializeLocalDataPool(localpool::DataPool& lo
localDataPoolMap.emplace(BpxBattery::HkPoolIds::BATT_VOLTAGE, &battVolt); localDataPoolMap.emplace(BpxBattery::HkPoolIds::BATT_VOLTAGE, &battVolt);
localDataPoolMap.emplace(BpxBattery::HkPoolIds::REBOOT_COUNTER, &rebootCounter); localDataPoolMap.emplace(BpxBattery::HkPoolIds::REBOOT_COUNTER, &rebootCounter);
localDataPoolMap.emplace(BpxBattery::HkPoolIds::BOOTCAUSE, &bootCause); localDataPoolMap.emplace(BpxBattery::HkPoolIds::BOOTCAUSE, &bootCause);
poolManager.subscribeForPeriodicPacket(hkSet.getSid(), false, 1.0, false);
return HasReturnvaluesIF::RETURN_OK; return HasReturnvaluesIF::RETURN_OK;
} }

3
mission/devices/devicedefinitions/BpxBatteryDefinitions.h
View File

@ -4,6 +4,8 @@
#include <fsfw/datapoollocal/StaticLocalDataSet.h> #include <fsfw/datapoollocal/StaticLocalDataSet.h>
#include <fsfw/serialize/SerialLinkedListAdapter.h> #include <fsfw/serialize/SerialLinkedListAdapter.h>
#include "fsfw/devicehandlers/DeviceHandlerIF.h"
#include <cstdint> #include <cstdint>
namespace BpxBattery { namespace BpxBattery {
@ -197,7 +199,6 @@ class BpxBatteryHk : public StaticLocalDataSet<BpxBattery::HK_ENTRIES> {
lp_var_t<uint8_t>(sid.objectId, BpxBattery::HkPoolIds::BOOTCAUSE, this); lp_var_t<uint8_t>(sid.objectId, BpxBattery::HkPoolIds::BOOTCAUSE, this);
private: private:
friend class BpxBatteryHandler; friend class BpxBatteryHandler;
/** /**
* Constructor for data creator * Constructor for data creator