KSat/fsfw
19
6
Fork 0
forked from fsfw/fsfw
Code Issues Pull Requests 1 Releases Wiki Activity

start fixing integration tests

Browse Source
This commit is contained in:
Robin Müller
2024-11-11 12:12:59 +01:00
parent 5864b1cb59
commit efbeca6e05
7 changed files with 66 additions and 159 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/fsfw/housekeeping/PeriodicHkHelper.cpp
View File

@ -348,9 +348,9 @@ void PeriodicHelper::printWarningOrError(sif::OutputTypes outputType, const char
} }
} else if (error == QUEUE_OR_DESTINATION_INVALID) { } else if (error == QUEUE_OR_DESTINATION_INVALID) {
errorPrint = "Queue or destination not set"; errorPrint = "Queue or destination not set";
} else if (error == localpool::POOL_ENTRY_TYPE_CONFLICT) { } else if (error == dp::POOL_ENTRY_TYPE_CONFLICT) {
errorPrint = "Pool entry type conflict"; errorPrint = "Pool entry type conflict";
} else if (error == localpool::POOL_ENTRY_NOT_FOUND) { } else if (error == dp::POOL_ENTRY_NOT_FOUND) {
errorPrint = "Pool entry not found"; errorPrint = "Pool entry not found";
} else { } else {
errorPrint = "Unknown error"; errorPrint = "Unknown error";

1
src/fsfw/timemanager/TimeReaderIF.h
View File

@ -3,6 +3,7 @@
#include <cstdio> #include <cstdio>
#include <cstdlib> #include <cstdlib>
#include <ctime>
#include "fsfw/platform.h" #include "fsfw/platform.h"

27
src/fsfw_tests/integration/controller/TestController.cpp
View File

@ -9,29 +9,28 @@ TestController::TestController(object_id_t objectId, size_t commandQueueDepth)
TestController::~TestController() {} TestController::~TestController() {}
ReturnValue_t TestController::handleCommandMessage(CommandMessage *message) { ReturnValue_t TestController::handleCommandMessage(CommandMessage* message) {
return returnvalue::OK; return returnvalue::OK;
} }
void TestController::performControlOperation(uint8_t opCode) {} void TestController::performControlOperation(uint8_t opCode) {}
void TestController::handleChangedDataset(sid_t sid, store_address_t storeId, bool *clearMessage) {}
void TestController::handleChangedPoolVariable(gp_id_t globPoolId, store_address_t storeId,
bool *clearMessage) {}
LocalPoolDataSetBase *TestController::getDataSetHandle(sid_t sid) { return nullptr; }
ReturnValue_t TestController::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
LocalDataPoolManager &poolManager) {
return returnvalue::OK;
}
ReturnValue_t TestController::initializeAfterTaskCreation() { ReturnValue_t TestController::initializeAfterTaskCreation() {
return ExtendedControllerBase::initializeAfterTaskCreation(); return ExtendedControllerBase::initializeAfterTaskCreation();
} }
ReturnValue_t TestController::checkModeCommand(Mode_t mode, Submode_t submode, ReturnValue_t TestController::checkModeCommand(Mode_t mode, Submode_t submode,
uint32_t *msToReachTheMode) { uint32_t* msToReachTheMode) {
return returnvalue::OK;
}
datapool::SharedPool* TestController::getOptionalSharedPool() { return nullptr; }
ReturnValue_t TestController::serializeHkDataset(dp::sid_t structureId, uint8_t* buf,
size_t maxSize) {
return returnvalue::OK;
}
ReturnValue_t TestController::specifyHkDatasets(std::vector<hk::SetSpecification>& setList) {
return returnvalue::OK; return returnvalue::OK;
} }

11
src/fsfw_tests/integration/controller/TestController.h
View File

@ -16,14 +16,11 @@ class TestController : public ExtendedControllerBase {
void performControlOperation(uint8_t opCode) override; void performControlOperation(uint8_t opCode) override;
// HasLocalDatapoolIF callbacks // HasLocalDatapoolIF callbacks
virtual void handleChangedDataset(sid_t sid, store_address_t storeId, datapool::SharedPool* getOptionalSharedPool() override;
bool* clearMessage) override;
virtual void handleChangedPoolVariable(gp_id_t globPoolId, store_address_t storeId,
bool* clearMessage) override;
LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override; ReturnValue_t serializeHkDataset(dp::sid_t structureId, uint8_t* buf, size_t maxSize) override;
ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
LocalDataPoolManager& poolManager) override; ReturnValue_t specifyHkDatasets(std::vector<hk::SetSpecification>& setList) override;
ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode, ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
uint32_t* msToReachTheMode) override; uint32_t* msToReachTheMode) override;

162
src/fsfw_tests/integration/devices/TestDeviceHandler.cpp
View File

@ -10,7 +10,6 @@ TestDevice::TestDevice(object_id_t objectId, object_id_t comIF, CookieIF* cookie
bool changingDataset) bool changingDataset)
: DeviceHandlerBase(objectId, comIF, cookie), : DeviceHandlerBase(objectId, comIF, cookie),
deviceIdx(deviceIdx), deviceIdx(deviceIdx),
dataset(this),
fullInfoPrintout(fullInfoPrintout) {} fullInfoPrintout(fullInfoPrintout) {}
TestDevice::~TestDevice() = default; TestDevice::~TestDevice() = default;
@ -158,46 +157,6 @@ ReturnValue_t TestDevice::buildCommandFromCommand(DeviceCommandId_t deviceComman
result = buildTestCommand1(deviceCommand, commandData, commandDataLen); result = buildTestCommand1(deviceCommand, commandData, commandDataLen);
break; break;
} }
case (TEST_NOTIF_SNAPSHOT_VAR): {
if (changingDatasets) {
changingDatasets = false;
}
PoolReadGuard readHelper(&dataset.testUint8Var);
if (deviceIdx == testdevice::DeviceIndex::DEVICE_0) {
/* This will trigger a variable notification to the demo controller */
dataset.testUint8Var = 220;
dataset.testUint8Var.setValid(true);
} else if (deviceIdx == testdevice::DeviceIndex::DEVICE_1) {
/* This will trigger a variable snapshot to the demo controller */
dataset.testUint8Var = 30;
dataset.testUint8Var.setValid(true);
}
break;
}
case (TEST_NOTIF_SNAPSHOT_SET): {
if (changingDatasets) {
changingDatasets = false;
}
PoolReadGuard readHelper(&dataset.testFloat3Vec);
if (deviceIdx == testdevice::DeviceIndex::DEVICE_0) {
/* This will trigger a variable notification to the demo controller */
dataset.testFloat3Vec.value[0] = 60;
dataset.testFloat3Vec.value[1] = 70;
dataset.testFloat3Vec.value[2] = 55;
dataset.testFloat3Vec.setValid(true);
} else if (deviceIdx == testdevice::DeviceIndex::DEVICE_1) {
/* This will trigger a variable notification to the demo controller */
dataset.testFloat3Vec.value[0] = -60;
dataset.testFloat3Vec.value[1] = -70;
dataset.testFloat3Vec.value[2] = -55;
dataset.testFloat3Vec.setValid(true);
}
break;
}
default: default:
result = DeviceHandlerIF::COMMAND_NOT_SUPPORTED; result = DeviceHandlerIF::COMMAND_NOT_SUPPORTED;
} }
@ -313,7 +272,7 @@ void TestDevice::passOnCommand(DeviceCommandId_t command, const uint8_t* command
void TestDevice::fillCommandAndReplyMap() { void TestDevice::fillCommandAndReplyMap() {
namespace td = testdevice; namespace td = testdevice;
insertInCommandAndReplyMap(testdevice::TEST_NORMAL_MODE_CMD, 5, &dataset); insertInCommandAndReplyMap(testdevice::TEST_NORMAL_MODE_CMD, 5);
insertInCommandAndReplyMap(testdevice::TEST_COMMAND_0, 5); insertInCommandAndReplyMap(testdevice::TEST_COMMAND_0, 5);
insertInCommandAndReplyMap(testdevice::TEST_COMMAND_1, 5); insertInCommandAndReplyMap(testdevice::TEST_COMMAND_1, 5);
@ -444,74 +403,48 @@ ReturnValue_t TestDevice::interpretDeviceReply(DeviceCommandId_t id, const uint8
ReturnValue_t TestDevice::interpretingNormalModeReply() { ReturnValue_t TestDevice::interpretingNormalModeReply() {
CommandMessage directReplyMessage; CommandMessage directReplyMessage;
if (changingDatasets) { if (changingDatasets) {
PoolReadGuard readHelper(&dataset); if (dataset.testU8.get() == 0) {
if (dataset.testUint8Var.value == 0) { dataset.testU8 = 10;
dataset.testUint8Var.value = 10; dataset.testU32 = 777;
dataset.testUint32Var.value = 777; dataset.testFloat3Vec[0] = 2.5;
dataset.testFloat3Vec.value[0] = 2.5; dataset.testFloat3Vec[1] = -2.5;
dataset.testFloat3Vec.value[1] = -2.5; dataset.testFloat3Vec[2] = 2.5;
dataset.testFloat3Vec.value[2] = 2.5;
dataset.setValidity(true, true);
} else { } else {
dataset.testUint8Var.value = 0; dataset.testU8 = 0;
dataset.testUint32Var.value = 0; dataset.testU32 = 0;
dataset.testFloat3Vec.value[0] = 0.0; dataset.testFloat3Vec[0] = 0;
dataset.testFloat3Vec.value[1] = 0.0; dataset.testFloat3Vec[1] = 0;
dataset.testFloat3Vec.value[2] = 0.0; dataset.testFloat3Vec[2] = 0;
dataset.setValidity(false, true);
} }
return returnvalue::OK; return returnvalue::OK;
} } else if (dataset.testU8.get() > 128) {
// If the value is greater than 0, it will be decremented in a linear way
PoolReadGuard readHelper(&dataset);
if (dataset.testUint8Var.value == 0) {
/* Reset state */
dataset.testUint8Var.value = 128;
} else if (dataset.testUint8Var.value > 200) {
if (not resetAfterChange) {
/* This will trigger an update notification to the controller */
dataset.testUint8Var.setChanged(true);
resetAfterChange = true;
/* Decrement by 30 automatically. This will prevent any additional notifications. */
dataset.testUint8Var.value -= 30;
}
}
/* If the value is greater than 0, it will be decremented in a linear way */
else if (dataset.testUint8Var.value > 128) {
size_t sizeToDecrement = 0; size_t sizeToDecrement = 0;
if (dataset.testUint8Var.value > 128 + 30) { if (dataset.testU8.get() > 128 + 30) {
sizeToDecrement = 30; sizeToDecrement = 30;
} else { } else {
sizeToDecrement = dataset.testUint8Var.value - 128; sizeToDecrement = dataset.testU8.get() - 128;
resetAfterChange = false; resetAfterChange = false;
} }
dataset.testUint8Var.value -= sizeToDecrement; dataset.testU8 = dataset.testU8.get() - sizeToDecrement;
} else if (dataset.testUint8Var.value < 50) { } else if (dataset.testU8.get() < 50) {
if (not resetAfterChange) { // Increment by 30 automatically.
/* This will trigger an update snapshot to the controller */ dataset.testU8 = dataset.testU8.get() + 30;
dataset.testUint8Var.setChanged(true); } else if (dataset.testU8.get() < 128) {
resetAfterChange = true; // Increment in linear way
} else {
/* Increment by 30 automatically. */
dataset.testUint8Var.value += 30;
}
}
/* Increment in linear way */
else if (dataset.testUint8Var.value < 128) {
size_t sizeToIncrement = 0; size_t sizeToIncrement = 0;
if (dataset.testUint8Var.value < 128 - 20) { if (dataset.testU8.get() < 128 - 20) {
sizeToIncrement = 20; sizeToIncrement = 20;
} else { } else {
sizeToIncrement = 128 - dataset.testUint8Var.value; sizeToIncrement = 128 - dataset.testU8.get();
resetAfterChange = false; resetAfterChange = false;
} }
dataset.testUint8Var.value += sizeToIncrement; dataset.testU8 = dataset.testU8.get() + sizeToIncrement;
} }
/* TODO: Same for vector */ /* TODO: Same for vector */
float vectorMean = (dataset.testFloat3Vec.value[0] + dataset.testFloat3Vec.value[1] + float vectorMean =
dataset.testFloat3Vec.value[2]) / (dataset.testFloat3Vec[0] + dataset.testFloat3Vec[1] + dataset.testFloat3Vec[2]) / 3.0;
3.0;
/* Lambda (private local function) */ /* Lambda (private local function) */
auto sizeToAdd = [](bool tooHigh, float currentVal) { auto sizeToAdd = [](bool tooHigh, float currentVal) {
@ -532,37 +465,35 @@ ReturnValue_t TestDevice::interpretingNormalModeReply() {
if (vectorMean > 20.0 and std::abs(vectorMean - 20.0) > 1.0) { if (vectorMean > 20.0 and std::abs(vectorMean - 20.0) > 1.0) {
if (not resetAfterChange) { if (not resetAfterChange) {
dataset.testFloat3Vec.setChanged(true);
resetAfterChange = true; resetAfterChange = true;
} else { } else {
float sizeToDecrementVal0 = 0; float sizeToDecrementVal0 = 0;
float sizeToDecrementVal1 = 0; float sizeToDecrementVal1 = 0;
float sizeToDecrementVal2 = 0; float sizeToDecrementVal2 = 0;
sizeToDecrementVal0 = sizeToAdd(true, dataset.testFloat3Vec.value[0]); sizeToDecrementVal0 = sizeToAdd(true, dataset.testFloat3Vec[0]);
sizeToDecrementVal1 = sizeToAdd(true, dataset.testFloat3Vec.value[1]); sizeToDecrementVal1 = sizeToAdd(true, dataset.testFloat3Vec[1]);
sizeToDecrementVal2 = sizeToAdd(true, dataset.testFloat3Vec.value[2]); sizeToDecrementVal2 = sizeToAdd(true, dataset.testFloat3Vec[2]);
dataset.testFloat3Vec.value[0] += sizeToDecrementVal0; dataset.testFloat3Vec[0] += sizeToDecrementVal0;
dataset.testFloat3Vec.value[1] += sizeToDecrementVal1; dataset.testFloat3Vec[1] += sizeToDecrementVal1;
dataset.testFloat3Vec.value[2] += sizeToDecrementVal2; dataset.testFloat3Vec[2] += sizeToDecrementVal2;
} }
} else if (vectorMean < -20.0 and std::abs(vectorMean + 20.0) < 1.0) { } else if (vectorMean < -20.0 and std::abs(vectorMean + 20.0) < 1.0) {
if (not resetAfterChange) { if (not resetAfterChange) {
dataset.testFloat3Vec.setChanged(true);
resetAfterChange = true; resetAfterChange = true;
} else { } else {
float sizeToDecrementVal0 = 0; float sizeToDecrementVal0 = 0;
float sizeToDecrementVal1 = 0; float sizeToDecrementVal1 = 0;
float sizeToDecrementVal2 = 0; float sizeToDecrementVal2 = 0;
sizeToDecrementVal0 = sizeToAdd(false, dataset.testFloat3Vec.value[0]); sizeToDecrementVal0 = sizeToAdd(false, dataset.testFloat3Vec[0]);
sizeToDecrementVal1 = sizeToAdd(false, dataset.testFloat3Vec.value[1]); sizeToDecrementVal1 = sizeToAdd(false, dataset.testFloat3Vec[1]);
sizeToDecrementVal2 = sizeToAdd(false, dataset.testFloat3Vec.value[2]); sizeToDecrementVal2 = sizeToAdd(false, dataset.testFloat3Vec[2]);
dataset.testFloat3Vec.value[0] += sizeToDecrementVal0; dataset.testFloat3Vec[0] += sizeToDecrementVal0;
dataset.testFloat3Vec.value[1] += sizeToDecrementVal1; dataset.testFloat3Vec[1] += sizeToDecrementVal1;
dataset.testFloat3Vec.value[2] += sizeToDecrementVal2; dataset.testFloat3Vec[2] += sizeToDecrementVal2;
} }
} else { } else {
if (resetAfterChange) { if (resetAfterChange) {
@ -779,17 +710,4 @@ ReturnValue_t TestDevice::getParameter(uint8_t domainId, uint8_t uniqueId,
return INVALID_IDENTIFIER_ID; return INVALID_IDENTIFIER_ID;
} }
return returnvalue::OK; return returnvalue::OK;
} }
LocalPoolObjectBase* TestDevice::getPoolObjectHandle(lp_id_t localPoolId) {
namespace td = testdevice;
if (localPoolId == td::PoolIds::TEST_UINT8_ID) {
return &dataset.testUint8Var;
} else if (localPoolId == td::PoolIds::TEST_UINT32_ID) {
return &dataset.testUint32Var;
} else if (localPoolId == td::PoolIds::TEST_FLOAT_VEC_3_ID) {
return &dataset.testFloat3Vec;
} else {
return nullptr;
}
}

4
src/fsfw_tests/integration/devices/TestDeviceHandler.h
View File

@ -85,10 +85,6 @@ class TestDevice : public DeviceHandlerBase {
virtual void doTransition(Mode_t modeFrom, Submode_t subModeFrom) override; virtual void doTransition(Mode_t modeFrom, Submode_t subModeFrom) override;
virtual ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
LocalDataPoolManager& poolManager) override;
virtual LocalPoolObjectBase* getPoolObjectHandle(lp_id_t localPoolId) override;
/* HasParametersIF overrides */ /* HasParametersIF overrides */
virtual ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueId, virtual ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueId,
ParameterWrapper* parameterWrapper, ParameterWrapper* parameterWrapper,

16
src/fsfw_tests/integration/devices/devicedefinitions/testDeviceDefinitions.h
View File

@ -3,6 +3,8 @@
#include <fsfw/datapool.h> #include <fsfw/datapool.h>
#include <fsfw/devicehandlers/DeviceHandlerIF.h> #include <fsfw/devicehandlers/DeviceHandlerIF.h>
#include <fsfw/serialize/SerializableList.h>
#include <fsfw/serialize/SerializableListElement.h>
namespace testdevice { namespace testdevice {
@ -71,17 +73,11 @@ enum PoolIds : dp::id_t { TEST_UINT8_ID = 0, TEST_UINT32_ID = 1, TEST_FLOAT_VEC_
static constexpr uint8_t TEST_SET_ID = TEST_NORMAL_MODE_CMD; static constexpr uint8_t TEST_SET_ID = TEST_NORMAL_MODE_CMD;
class TestDataSet : public dp::StaticSharedSet<3> { class TestDataSet : public serialize::List {
public: public:
TestDataSet(dp::SharedPool& owner) : StaticSharedSet(owner, TEST_SET_ID) {} serialize::LE<uint8_t> testU8{*this};
TestDataSet(object_id_t owner) : StaticSharedSet(dp::sid_t(owner, TEST_SET_ID)) {} serialize::LE<uint32_t> testU32{*this};
serialize::LAE<float, 3> testFloat3Vec{*this};
dp::var_t<uint8_t> testUint8Var =
dp::var_t<uint8_t>(dp::g_id_t(this->getCreatorObjectId(), PoolIds::TEST_UINT8_ID), this);
dp::var_t<uint32_t> testUint32Var =
dp::var_t<uint32_t>(dp::g_id_t(this->getCreatorObjectId(), PoolIds::TEST_UINT32_ID), this);
dp::vec_t<float, 3> testFloat3Vec = dp::vec_t<float, 3>(
dp::g_id_t(this->getCreatorObjectId(), PoolIds::TEST_FLOAT_VEC_3_ID), this);
}; };
} // namespace testdevice } // namespace testdevice