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

applied auto-formatter
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 16:04:24 +01:00
parent 3250a9f489
commit 9456dc1a00
No known key found for this signature in database
GPG Key ID: 71B58F8A3CDFA9AC
7 changed files with 38 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
bsp_q7s/core/InitMission.cpp
View File

@ -350,8 +350,8 @@ void initmission::createPusTasks(TaskFactory& factory,
void initmission::createTestTasks(TaskFactory& factory, 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 || OBSW_ADD_I2C_TEST_CODE == 1 || \
OBSW_ADD_I2C_TEST_CODE == 1 || (BOARD_TE0720 == 1 && OBSW_TEST_LIBGPIOD == 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(

3
bsp_q7s/core/ObjectFactory.cpp
View File

@ -1,6 +1,7 @@
#include <linux/boardtest/I2cTestClass.h>
#include "ObjectFactory.h" #include "ObjectFactory.h"
#include <linux/boardtest/I2cTestClass.h>
#include <sstream> #include <sstream>
#include "OBSWConfig.h" #include "OBSWConfig.h"

31
linux/boardtest/I2cTestClass.cpp
View File

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

12
linux/boardtest/I2cTestClass.h
View File

@ -3,9 +3,10 @@
#include <test/testtasks/TestTask.h> #include <test/testtasks/TestTask.h>
#include "mission/devices/devicedefinitions/BpxBatteryDefinitions.h"
#include <string>
#include <array> #include <array>
#include <string>
#include "mission/devices/devicedefinitions/BpxBatteryDefinitions.h"
class I2cTestClass : public TestTask { class I2cTestClass : public TestTask {
public: public:
@ -15,10 +16,7 @@ class I2cTestClass : public TestTask {
ReturnValue_t performPeriodicAction() override; ReturnValue_t performPeriodicAction() override;
private: private:
enum TestModes { enum TestModes { NONE, BPX_BATTERY };
NONE,
BPX_BATTERY
};
struct I2cInfo { struct I2cInfo {
int addr = 0; int addr = 0;
int fd = 0; int fd = 0;
@ -28,7 +26,7 @@ class I2cTestClass : public TestTask {
void battInit(); void battInit();
void battPeriodic(); void battPeriodic();
I2cInfo bpxInfo = { .addr = 0x07, .fd = 0 }; I2cInfo bpxInfo = {.addr = 0x07, .fd = 0};
std::string i2cdev; std::string i2cdev;
size_t sendLen = 0; size_t sendLen = 0;
size_t recvLen = 0; size_t recvLen = 0;

6
linux/boardtest/UartTestClass.cpp
View File

@ -24,12 +24,10 @@ ReturnValue_t UartTestClass::initialize() {
return HasReturnvaluesIF::RETURN_OK; return HasReturnvaluesIF::RETURN_OK;
} }
ReturnValue_t UartTestClass::performOneShotAction() { ReturnValue_t UartTestClass::performOneShotAction() { return HasReturnvaluesIF::RETURN_OK; }
return HasReturnvaluesIF::RETURN_OK;
}
ReturnValue_t UartTestClass::performPeriodicAction() { ReturnValue_t UartTestClass::performPeriodicAction() {
if(mode == TestModes::GPS) { if (mode == TestModes::GPS) {
gpsPeriodic(); gpsPeriodic();
} }
return HasReturnvaluesIF::RETURN_OK; return HasReturnvaluesIF::RETURN_OK;

6
mission/devices/BpxBatteryHandler.cpp
View File

@ -46,7 +46,7 @@ void BpxBatteryHandler::fillCommandAndReplyMap() {
insertInCommandAndReplyMap(GET_HK, 1, &hkSet, GET_HK_REPLY_LEN); insertInCommandAndReplyMap(GET_HK, 1, &hkSet, GET_HK_REPLY_LEN);
insertInCommandAndReplyMap(BpxBattery::PING, 1, nullptr, PING_REPLY_LEN); insertInCommandAndReplyMap(BpxBattery::PING, 1, nullptr, PING_REPLY_LEN);
insertInCommandAndReplyMap(BpxBattery::REBOOT, 1, nullptr, 0); insertInCommandAndReplyMap(BpxBattery::REBOOT, 1, nullptr, 0);
insertInCommandAndReplyMap(BpxBattery::RESET_COUNTERS, 1, nullptr,EMPTY_REPLY_LEN); insertInCommandAndReplyMap(BpxBattery::RESET_COUNTERS, 1, nullptr, EMPTY_REPLY_LEN);
insertInCommandAndReplyMap(BpxBattery::CONFIG_CMD, 1, nullptr, EMPTY_REPLY_LEN); insertInCommandAndReplyMap(BpxBattery::CONFIG_CMD, 1, nullptr, EMPTY_REPLY_LEN);
insertInCommandAndReplyMap(BpxBattery::CONFIG_GET, 1, &cfgSet, CONFIG_GET_REPLY_LEN); insertInCommandAndReplyMap(BpxBattery::CONFIG_GET, 1, &cfgSet, CONFIG_GET_REPLY_LEN);
} }
@ -214,7 +214,7 @@ ReturnValue_t BpxBatteryHandler::interpretDeviceReply(DeviceCommandId_t id, cons
} }
case (BpxBattery::PING): { case (BpxBattery::PING): {
if (packet[2] != 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;
@ -242,7 +242,7 @@ ReturnValue_t BpxBatteryHandler::interpretDeviceReply(DeviceCommandId_t id, cons
cfgSet.setValidity(true, true); cfgSet.setValidity(true, true);
break; break;
} }
case(BpxBattery::REBOOT): { case (BpxBattery::REBOOT): {
break; break;
} }
default: { default: {

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

@ -4,10 +4,10 @@
#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>
#include "fsfw/devicehandlers/DeviceHandlerIF.h"
namespace BpxBattery { namespace BpxBattery {
enum LocalPoolIds { enum LocalPoolIds {
@ -186,24 +186,18 @@ class BpxBatteryHk : public StaticLocalDataSet<BpxBattery::HK_ENTRIES> {
lp_var_t<uint16_t>(sid.objectId, BpxBattery::HEATER_CURRENT, this); lp_var_t<uint16_t>(sid.objectId, BpxBattery::HEATER_CURRENT, this);
//! Battery voltage in mV //! Battery voltage in mV
lp_var_t<uint16_t> battVoltage = lp_var_t<uint16_t> battVoltage = lp_var_t<uint16_t>(sid.objectId, BpxBattery::BATT_VOLTAGE, this);
lp_var_t<uint16_t>(sid.objectId, BpxBattery::BATT_VOLTAGE, this);
//! Battery temperature 1 in degC //! Battery temperature 1 in degC
lp_var_t<int16_t> battTemp1 = lp_var_t<int16_t> battTemp1 = lp_var_t<int16_t>(sid.objectId, BpxBattery::BATT_TEMP_1, this);
lp_var_t<int16_t>(sid.objectId, BpxBattery::BATT_TEMP_1, this);
//! Battery temperature 2 in degC //! Battery temperature 2 in degC
lp_var_t<int16_t> battTemp2 = lp_var_t<int16_t> battTemp2 = lp_var_t<int16_t>(sid.objectId, BpxBattery::BATT_TEMP_2, this);
lp_var_t<int16_t>(sid.objectId, BpxBattery::BATT_TEMP_2, this);
//! Battery temperature 3 in degC //! Battery temperature 3 in degC
lp_var_t<int16_t> battTemp3 = lp_var_t<int16_t> battTemp3 = lp_var_t<int16_t>(sid.objectId, BpxBattery::BATT_TEMP_3, this);
lp_var_t<int16_t>(sid.objectId, BpxBattery::BATT_TEMP_3, this);
//! Battery temperature 4 in degC //! Battery temperature 4 in degC
lp_var_t<int16_t> battTemp4 = lp_var_t<int16_t> battTemp4 = lp_var_t<int16_t>(sid.objectId, BpxBattery::BATT_TEMP_4, this);
lp_var_t<int16_t>(sid.objectId, BpxBattery::BATT_TEMP_4, this);
lp_var_t<uint32_t> rebootCounter = lp_var_t<uint32_t> rebootCounter =
lp_var_t<uint32_t>(sid.objectId, BpxBattery::REBOOT_COUNTER, this); lp_var_t<uint32_t>(sid.objectId, BpxBattery::REBOOT_COUNTER, this);
lp_var_t<uint8_t> bootcause = lp_var_t<uint8_t> bootcause = lp_var_t<uint8_t>(sid.objectId, BpxBattery::BOOTCAUSE, this);
lp_var_t<uint8_t>(sid.objectId, BpxBattery::BOOTCAUSE, this);
private: private:
friend class BpxBatteryHandler; friend class BpxBatteryHandler;