Compare commits

..

1 Commits

Author SHA1 Message Date
fc69f9da3e Update and clean up HK and Local Pool Modules 2024-12-12 16:29:48 +01:00
26 changed files with 68 additions and 125 deletions

View File

@ -26,7 +26,6 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
## Added ## Added
- FreeRTOS monotonic clock which is not subjected to time jumps of the system clock
- add CFDP subsystem ID - add CFDP subsystem ID
https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/742 https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/742
- `PusTmZcWriter` now exposes API to set message counter field. - `PusTmZcWriter` now exposes API to set message counter field.
@ -35,7 +34,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
## Changed ## Changed
- Complete overhaul of HK subsystem. Replaced local data pool manager by periodic HK - Complete refactoring of HK subsystem. Replaced local data pool manager by periodic HK
helper. The shared pool and the periodic HK generation are now distinct concepts. helper. The shared pool and the periodic HK generation are now distinct concepts.
- The local HK manager was replaced by a periodic HK helper which has reduced responsibilities. - The local HK manager was replaced by a periodic HK helper which has reduced responsibilities.
It takes care of tracking the HK generation using a set specification provided by the user.n It takes care of tracking the HK generation using a set specification provided by the user.n

View File

@ -142,7 +142,7 @@ if(FSFW_BUILD_TESTS)
configure_file(unittests/testcfg/TestsConfig.h.in tests/TestsConfig.h) configure_file(unittests/testcfg/TestsConfig.h.in tests/TestsConfig.h)
project(${FSFW_TEST_TGT} CXX C) project(${FSFW_TEST_TGT} CXX C)
add_executable(${FSFW_TEST_TGT}) add_executable(${FSFW_TEST_TGT} unittests/datapool/testDataset.cpp)
if(IPO_SUPPORTED AND FSFW_ENABLE_IPO) if(IPO_SUPPORTED AND FSFW_ENABLE_IPO)
set_property(TARGET ${FSFW_TEST_TGT} PROPERTY INTERPROCEDURAL_OPTIMIZATION set_property(TARGET ${FSFW_TEST_TGT} PROPERTY INTERPROCEDURAL_OPTIMIZATION
TRUE) TRUE)

View File

@ -34,12 +34,11 @@ class ExtendedControllerBase : public ControllerBase,
ActionHelper actionHelper; ActionHelper actionHelper;
// Periodic HK methods, default method assumes that no shared pool is required. // Periodic HK methods, default method assumes that no shared pool is required.
datapool::SharedPool* getOptionalSharedPool() override = 0; virtual datapool::SharedPool* getOptionalSharedPool() override;
// Periodic HK abstract methods. // Periodic HK abstract methods.
ReturnValue_t serializeHkDataset(dp::sid_t structureId, uint8_t* buf, ReturnValue_t serializeHkDataset(dp::sid_t structureId, uint8_t* buf, size_t maxSize) = 0;
size_t maxSize) override = 0; ReturnValue_t specifyHkDatasets(std::vector<hk::SetSpecification>& setList) = 0;
ReturnValue_t specifyHkDatasets(std::vector<hk::SetSpecification>& setList) override = 0;
/** /**
* Implemented by child class. Handle all command messages which are * Implemented by child class. Handle all command messages which are

View File

@ -48,14 +48,6 @@ PoolObjectBase::PoolObjectBase(object_id_t poolOwner, id_t poolId, DataSetIF* da
return; return;
} }
sharedPool = hkOwner->getOptionalSharedPool(); sharedPool = hkOwner->getOptionalSharedPool();
if (sharedPool == nullptr) {
#if FSFW_CPP_OSTREAM_ENABLED == 1
sif::error << "PoolObjectBase: HK owner 0x" << std::hex << poolOwner << std::dec
<< "does not have a shared pool " << std::endl;
#else
sif::printError("PoolObjectBase: HK owner 0x%08x does not have a shared pool\n", poolOwner);
#endif
}
if (dataSet != nullptr) { if (dataSet != nullptr) {
dataSet->registerVariable(this); dataSet->registerVariable(this);

View File

@ -9,9 +9,9 @@
PoolDataSetBase::PoolDataSetBase(PoolVariableIF** registeredVariablesArray, PoolDataSetBase::PoolDataSetBase(PoolVariableIF** registeredVariablesArray,
const size_t maxFillCount, bool serializeWithValidityBlob) const size_t maxFillCount, bool serializeWithValidityBlob)
: serializeWithValidityBlob(serializeWithValidityBlob), : registeredVariables(registeredVariablesArray),
registeredVariables(registeredVariablesArray), maxFillCount(maxFillCount),
maxFillCount(maxFillCount) {} serializeWithValidityBlob(serializeWithValidityBlob) {}
PoolDataSetBase::~PoolDataSetBase() = default; PoolDataSetBase::~PoolDataSetBase() = default;
@ -251,9 +251,6 @@ size_t PoolDataSetBase::getSerializedSize() const {
for (uint16_t count = 0; count < fillCount; count++) { for (uint16_t count = 0; count < fillCount; count++) {
size += registeredVariables[count]->getSerializedSize(); size += registeredVariables[count]->getSerializedSize();
} }
if (serializeWithValidityBlob) {
size += std::ceil(static_cast<float>(fillCount) / 8.0);
}
return size; return size;
} }

View File

@ -139,8 +139,6 @@ class PoolDataSetBase : public PoolDataSetIF, public SerializeIF {
*/ */
void setChildrenValidity(bool valid); void setChildrenValidity(bool valid);
bool serializeWithValidityBlob = false;
protected: protected:
/** /**
* @brief The fill_count attribute ensures that the variables * @brief The fill_count attribute ensures that the variables
@ -168,6 +166,7 @@ class PoolDataSetBase : public PoolDataSetIF, public SerializeIF {
*/ */
PoolVariableIF** registeredVariables = nullptr; PoolVariableIF** registeredVariables = nullptr;
const size_t maxFillCount = 0; const size_t maxFillCount = 0;
bool serializeWithValidityBlob = false;
void setContainer(PoolVariableIF** variablesContainer); void setContainer(PoolVariableIF** variablesContainer);
PoolVariableIF** getContainer() const; PoolVariableIF** getContainer() const;

View File

@ -20,9 +20,9 @@ class PoolReadGuard {
if (readResult != returnvalue::OK) { if (readResult != returnvalue::OK) {
#if FSFW_VERBOSE_LEVEL == 1 #if FSFW_VERBOSE_LEVEL == 1
#if FSFW_CPP_OSTREAM_ENABLED == 1 #if FSFW_CPP_OSTREAM_ENABLED == 1
sif::error << "PoolReadGuard: Read failed!" << std::endl; sif::error << "PoolReadHelper: Read failed!" << std::endl;
#else #else
sif::printError("PoolReadGuard: Read failed!\n"); sif::printError("PoolReadHelper: Read failed!\n");
#endif /* FSFW_PRINT_VERBOSITY_LEVEL == 1 */ #endif /* FSFW_PRINT_VERBOSITY_LEVEL == 1 */
#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */ #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
} }

View File

@ -210,7 +210,6 @@ inline ReturnValue_t PoolVariable<T>::readWithoutLock() {
} }
this->value = *(poolEntry->getDataPtr()); this->value = *(poolEntry->getDataPtr());
this->valid = poolEntry->getValid();
return returnvalue::OK; return returnvalue::OK;
} }
@ -242,7 +241,6 @@ ReturnValue_t PoolVariable<T>::commitWithoutLock() {
} }
*(poolEntry->getDataPtr()) = this->value; *(poolEntry->getDataPtr()) = this->value;
poolEntry->setValid(this->valid);
return returnvalue::OK; return returnvalue::OK;
} }

View File

@ -3,7 +3,7 @@
using namespace dp; using namespace dp;
SharedSet::SharedSet(dp::SharedPool& sharedPool, uint32_t setId, const size_t maxNumberOfVariables, SharedSet::SharedSet(dp::SharedPool& sharedPool, uint32_t setId, const size_t maxNumberOfVariables,
bool serializeWithValidityBlob) bool serializeWithValídityBlob)
: SharedSetBase(sharedPool, setId, nullptr, maxNumberOfVariables, serializeWithValidityBlob), : SharedSetBase(sharedPool, setId, nullptr, maxNumberOfVariables, serializeWithValidityBlob),
poolVarList(maxNumberOfVariables) { poolVarList(maxNumberOfVariables) {
this->setContainer(poolVarList.data()); this->setContainer(poolVarList.data());

View File

@ -105,6 +105,9 @@ ReturnValue_t SharedSetBase::deSerialize(const uint8_t **buffer, size_t *size,
ReturnValue_t SharedSetBase::serialize(uint8_t **buffer, size_t *size, size_t maxSize, ReturnValue_t SharedSetBase::serialize(uint8_t **buffer, size_t *size, size_t maxSize,
SerializeIF::Endianness streamEndianness) const { SerializeIF::Endianness streamEndianness) const {
if (serializeWithValidityBlob) {
return base.doSerializeWithValidityBlob(buffer, size, maxSize, streamEndianness);
}
return base.serialize(buffer, size, maxSize, streamEndianness); return base.serialize(buffer, size, maxSize, streamEndianness);
} }
@ -140,17 +143,10 @@ void SharedSetBase::setAllVariablesReadOnly() {
void SharedSetBase::printSet() { return; } void SharedSetBase::printSet() { return; }
ReturnValue_t SharedSetBase::read(MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) { ReturnValue_t SharedSetBase::read(MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
lockDataPool(timeoutType, timeoutMs); return base.read(timeoutType, timeoutMs);
ReturnValue_t result = base.read(timeoutType, timeoutMs);
unlockDataPool();
return result;
} }
ReturnValue_t SharedSetBase::commit(MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) { ReturnValue_t SharedSetBase::commit(MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
lockDataPool(timeoutType, timeoutMs); return base.commit(timeoutType, timeoutMs);
ReturnValue_t result = base.commit(timeoutType, timeoutMs);
unlockDataPool();
return result;
} }
uint16_t SharedSetBase::getFillCount() const { return base.getFillCount(); } uint16_t SharedSetBase::getFillCount() const { return base.getFillCount(); }
@ -162,8 +158,3 @@ void SharedSetBase::setContainer(PoolVariableIF **variablesContainer) {
return base.setContainer(variablesContainer); return base.setContainer(variablesContainer);
} }
PoolVariableIF **SharedSetBase::getContainer() const { return base.getContainer(); } PoolVariableIF **SharedSetBase::getContainer() const { return base.getContainer(); }
void SharedSetBase::updateValidityBlobSerialization(bool enable) {
base.serializeWithValidityBlob = enable;
}
bool SharedSetBase::getValidityBlobSerialization() const { return base.serializeWithValidityBlob; }

View File

@ -159,8 +159,11 @@ class SharedSetBase : public SerializeIF, public PoolDataSetIF {
*/ */
void setChildrenValidity(bool valid); void setChildrenValidity(bool valid);
void updateValidityBlobSerialization(bool enable); /**
bool getValidityBlobSerialization() const; * If the valid state of a dataset is always relevant to the whole
* data set we can use this flag.
*/
bool serializeWithValidityBlob = false;
protected: protected:
PoolDataSetBase base; PoolDataSetBase base;

View File

@ -148,6 +148,9 @@ class FreshDeviceHandlerBase : public SystemObject,
// System Object overrides. // System Object overrides.
ReturnValue_t initialize() override; ReturnValue_t initialize() override;
// Default implementation assumes that no optional shared pool is required.
datapool::SharedPool* getOptionalSharedPool() override;
/** /**
* This function is implemented to serialize a housekeeping packet when a HK message to * This function is implemented to serialize a housekeeping packet when a HK message to
* generate the packet is received, or periodic generation is necessary. The user should serialize * generate the packet is received, or periodic generation is necessary. The user should serialize
@ -161,11 +164,6 @@ class FreshDeviceHandlerBase : public SystemObject,
*/ */
ReturnValue_t specifyHkDatasets(std::vector<hk::SetSpecification>& setList) override = 0; ReturnValue_t specifyHkDatasets(std::vector<hk::SetSpecification>& setList) override = 0;
/*
* If this device handler has an optional pool, return it. Otherwise, nullptr can be returned.
*/
datapool::SharedPool* getOptionalSharedPool() override = 0;
/** /**
* Implemented by child class. Handle all command messages which are * Implemented by child class. Handle all command messages which are
* not health, mode, action or housekeeping messages. * not health, mode, action or housekeeping messages.

View File

@ -1,4 +1,9 @@
#pragma once #ifndef FSFW_INC_FSFW_HOUSEKEEPING_H_
#define FSFW_INC_FSFW_HOUSEKEEPING_H_
#include "fsfw/housekeeping/Dataset.h" #include "src/core/housekeeping/HousekeepingMessage.h"
#include "fsfw/housekeeping/DatasetElement.h" #include "src/core/housekeeping/HousekeepingPacketDownlink.h"
#include "src/core/housekeeping/HousekeepingSetPacket.h"
#include "src/core/housekeeping/HousekeepingSnapshot.h"
#endif /* FSFW_INC_FSFW_HOUSEKEEPING_H_ */

View File

@ -17,6 +17,12 @@ class Dataset : public SerializeIF {
[[nodiscard]] dp::structure_id_t getStructureId() const { return sid; } [[nodiscard]] dp::structure_id_t getStructureId() const { return sid; }
void setAllChildrenValidity(bool valid) {
for (auto &serializable : serializables) {
serializable.get().setValid(valid);
}
}
void addSerializable(const std::reference_wrapper<SerializableWithValidityIF> serializable) { void addSerializable(const std::reference_wrapper<SerializableWithValidityIF> serializable) {
serializables.push_back(serializable); serializables.push_back(serializable);
} }
@ -89,20 +95,11 @@ class Dataset : public SerializeIF {
return SerializeIF::serialize(buffer, serSize, maxSize, streamEndianness); return SerializeIF::serialize(buffer, serSize, maxSize, streamEndianness);
} }
void setChildrenValidity(bool valid) {
for (auto &serializable : serializables) {
serializable.get().setValid(true);
}
}
[[nodiscard]] size_t getSerializedSize() const override { [[nodiscard]] size_t getSerializedSize() const override {
size_t size = 0; size_t size = 0;
for (auto &serializable : serializables) { for (auto &serializable : serializables) {
size += serializable.get().getSerializedSize(); size += serializable.get().getSerializedSize();
} }
if (serializeWithValidityBlob) {
size += std::ceil(static_cast<float>(serializables.size()) / 8.0);
}
return size; return size;
} }

View File

@ -17,7 +17,7 @@ PeriodicHelper::PeriodicHelper(GeneratesPeriodicHkIF* owner, MessageQueueIF* que
MessageQueueId_t hkDestQueue) MessageQueueId_t hkDestQueue)
: hkDestinationId(hkDestQueue) { : hkDestinationId(hkDestQueue) {
if (owner == nullptr) { if (owner == nullptr) {
printWarningOrError(sif::OutputTypes::OUT_WARNING, "PeriodicHkHelper", returnvalue::FAILED, printWarningOrError(sif::OutputTypes::OUT_WARNING, "LocalDataPoolManager", returnvalue::FAILED,
"Invalid supplied owner"); "Invalid supplied owner");
return; return;
} }
@ -200,10 +200,11 @@ void PeriodicHelper::performPeriodicHkGeneration(SetSpecification& setSpec, time
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
// Configuration error // Configuration error
#if FSFW_CPP_OSTREAM_ENABLED == 1 #if FSFW_CPP_OSTREAM_ENABLED == 1
sif::warning << "hk::PeriodicHelper::performPeriodicHkOperation: HK generation failed." sif::warning << "LocalDataPoolManager::performPeriodicHkOperation: HK generation failed."
<< std::endl; << std::endl;
#else #else
sif::printWarning("hk::PeriodicHelper::performPeriodicHkOperation: HK generation failed.\n"); sif::printWarning(
"LocalDataPoolManager::performPeriodicHkOperation: HK generation failed.\n");
#endif #endif
return; return;
} }

View File

@ -5,7 +5,6 @@
#include "FreeRTOS.h" #include "FreeRTOS.h"
#include "fsfw/globalfunctions/timevalOperations.h" #include "fsfw/globalfunctions/timevalOperations.h"
#include "fsfw/serviceinterface/ServiceInterfacePrinter.h"
#include "fsfw/osal/freertos/Timekeeper.h" #include "fsfw/osal/freertos/Timekeeper.h"
#include "task.h" #include "task.h"
@ -48,8 +47,8 @@ ReturnValue_t Clock::getClock(timeval* time) {
} }
ReturnValue_t Clock::getClockMonotonic(timeval* time) { ReturnValue_t Clock::getClockMonotonic(timeval* time) {
*time = Timekeeper::instance()->getMonotonicClockOffset() + getUptime(); // TODO: I don't actually know if the timekeeper is monotonic..
return returnvalue::OK; return getClock_timeval(time);
} }
ReturnValue_t Clock::getUptime(timeval* uptime) { ReturnValue_t Clock::getUptime(timeval* uptime) {
@ -59,7 +58,7 @@ ReturnValue_t Clock::getUptime(timeval* uptime) {
} }
timeval Clock::getUptime() { timeval Clock::getUptime() {
TickType_t ticksSinceStart = Timekeeper::instance()->getTicks(); TickType_t ticksSinceStart = xTaskGetTickCount();
return Timekeeper::ticksToTimeval(ticksSinceStart); return Timekeeper::ticksToTimeval(ticksSinceStart);
} }

View File

@ -17,13 +17,7 @@ Timekeeper* Timekeeper::instance() {
return myinstance; return myinstance;
} }
void Timekeeper::setOffset(const timeval& offset) { void Timekeeper::setOffset(const timeval& offset) { this->offset = offset; }
if (not monotonicClockInitialized) {
this->monotonicClockOffset = offset;
monotonicClockInitialized = true;
}
this->offset = offset;
}
timeval Timekeeper::ticksToTimeval(TickType_t ticks) { timeval Timekeeper::ticksToTimeval(TickType_t ticks) {
timeval uptime; timeval uptime;
@ -39,7 +33,3 @@ timeval Timekeeper::ticksToTimeval(TickType_t ticks) {
} }
TickType_t Timekeeper::getTicks() { return xTaskGetTickCount(); } TickType_t Timekeeper::getTicks() { return xTaskGetTickCount(); }
const timeval Timekeeper::getMonotonicClockOffset() const {
return monotonicClockOffset;
}

View File

@ -18,14 +18,9 @@ class Timekeeper {
Timekeeper(); Timekeeper();
timeval offset; timeval offset;
// Set when offset is initialized the first time
timeval monotonicClockOffset;
bool monotonicClockInitialized = false;
static Timekeeper* myinstance; static Timekeeper* myinstance;
void setMonotonicClockOffset(const timeval& monotonicClockOffset);
public: public:
static Timekeeper* instance(); static Timekeeper* instance();
virtual ~Timekeeper(); virtual ~Timekeeper();
@ -39,7 +34,6 @@ class Timekeeper {
const timeval& getOffset() const; const timeval& getOffset() const;
void setOffset(const timeval& offset); void setOffset(const timeval& offset);
const timeval getMonotonicClockOffset() const;
}; };
#endif /* FRAMEWORK_OSAL_FREERTOS_TIMEKEEPER_H_ */ #endif /* FRAMEWORK_OSAL_FREERTOS_TIMEKEEPER_H_ */

View File

@ -49,7 +49,7 @@ class Service11TelecommandScheduling final : public PusServiceBase {
//! [EXPORT] : [COMMENT] Deletion of a TC from the map failed. //! [EXPORT] : [COMMENT] Deletion of a TC from the map failed.
//! P1: First 32 bit of request ID, P2. Last 32 bit of Request ID //! P1: First 32 bit of request ID, P2. Last 32 bit of Request ID
static constexpr Event TC_DELETION_FAILED = MAKE_EVENT(0, severity::MEDIUM); static constexpr Event TC_DELETION_FAILED = event::makeEvent(SUBSYSTEM_ID, 0, severity::MEDIUM);
// The types of PUS-11 subservices // The types of PUS-11 subservices
enum Subservice : uint8_t { enum Subservice : uint8_t {

View File

@ -53,17 +53,17 @@ void fsfwPrint(sif::PrintLevel printType, const char *fmt, va_list arg) {
#endif #endif
if (printType == sif::PrintLevel::INFO_LEVEL) { if (printType == sif::PrintLevel::INFO_LEVEL) {
len += sprintf(bufferPosition + len, "INFO "); len += sprintf(bufferPosition + len, "INFO");
} }
if (printType == sif::PrintLevel::DEBUG_LEVEL) { if (printType == sif::PrintLevel::DEBUG_LEVEL) {
len += sprintf(bufferPosition + len, "DEBUG "); len += sprintf(bufferPosition + len, "DEBUG");
} }
if (printType == sif::PrintLevel::WARNING_LEVEL) { if (printType == sif::PrintLevel::WARNING_LEVEL) {
len += sprintf(bufferPosition + len, "WARNING"); len += sprintf(bufferPosition + len, "WARNING");
} }
if (printType == sif::PrintLevel::ERROR_LEVEL) { if (printType == sif::PrintLevel::ERROR_LEVEL) {
len += sprintf(bufferPosition + len, "ERROR "); len += sprintf(bufferPosition + len, "ERROR");
} }
#if FSFW_COLORED_OUTPUT == 1 #if FSFW_COLORED_OUTPUT == 1
@ -75,7 +75,7 @@ void fsfwPrint(sif::PrintLevel printType, const char *fmt, va_list arg) {
/* /*
* Log current time to terminal if desired. * Log current time to terminal if desired.
*/ */
len += sprintf(bufferPosition + len, " | %02lu:%02lu:%02lu.%03lu | ", (unsigned long)now.hour, len += sprintf(bufferPosition + len, " | %lu:%02lu:%02lu.%03lu | ", (unsigned long)now.hour,
(unsigned long)now.minute, (unsigned long)now.second, (unsigned long)now.minute, (unsigned long)now.second,
(unsigned long)now.usecond / 1000); (unsigned long)now.usecond / 1000);

View File

@ -79,36 +79,22 @@ void SubsystemBase::executeTable(HybridIterator<ModeListEntry> tableIter, Submod
} }
if (healthHelper.healthTable->hasHealth(object)) { if (healthHelper.healthTable->hasHealth(object)) {
if (healthHelper.healthTable->isFaulty(object)) {
switch (healthHelper.healthTable->getHealth(object)) { ModeMessage::setModeMessage(&command, ModeMessage::CMD_MODE_COMMAND, HasModesIF::MODE_OFF,
case NEEDS_RECOVERY: SUBMODE_NONE);
case FAULTY: } else {
case PERMANENT_FAULTY: if (modeHelper.isForced()) {
ModeMessage::setModeMessage(&command, ModeMessage::CMD_MODE_COMMAND, HasModesIF::MODE_OFF, ModeMessage::setModeMessage(&command, ModeMessage::CMD_MODE_COMMAND_FORCED,
SUBMODE_NONE); tableIter.value->getMode(), submodeToCommand);
break; } else {
case HEALTHY: if (healthHelper.healthTable->isCommandable(object)) {
if (modeHelper.isForced()) {
ModeMessage::setModeMessage(&command, ModeMessage::CMD_MODE_COMMAND_FORCED,
tableIter.value->getMode(), submodeToCommand);
} else {
ModeMessage::setModeMessage(&command, ModeMessage::CMD_MODE_COMMAND, ModeMessage::setModeMessage(&command, ModeMessage::CMD_MODE_COMMAND,
tableIter.value->getMode(), submodeToCommand); tableIter.value->getMode(), submodeToCommand);
}
break;
case EXTERNAL_CONTROL:
if (modeHelper.isForced()) {
ModeMessage::setModeMessage(&command, ModeMessage::CMD_MODE_COMMAND_FORCED,
tableIter.value->getMode(), submodeToCommand);
} else { } else {
continue; continue;
} }
break; }
default:
// This never happens
break;
} }
} else { } else {
ModeMessage::setModeMessage(&command, ModeMessage::CMD_MODE_COMMAND, ModeMessage::setModeMessage(&command, ModeMessage::CMD_MODE_COMMAND,
tableIter.value->getMode(), submodeToCommand); tableIter.value->getMode(), submodeToCommand);

View File

@ -25,7 +25,7 @@ static constexpr ReturnValue_t INCORRECT_SECONDARY_HEADER = MAKE_RETURN_CODE(11)
static constexpr uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::TMTC_DISTRIBUTION; static constexpr uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::TMTC_DISTRIBUTION;
//! P1: Returnvalue, P2: 0 for TM issues, 1 for TC issues //! P1: Returnvalue, P2: 0 for TM issues, 1 for TC issues
static constexpr Event HANDLE_PACKET_FAILED = MAKE_EVENT(0, severity::LOW); static constexpr Event HANDLE_PACKET_FAILED = event::makeEvent(SUBSYSTEM_ID, 0, severity::LOW);
}; // namespace tmtcdistrib }; // namespace tmtcdistrib
#endif // FSFW_TMTCPACKET_DEFINITIONS_H #endif // FSFW_TMTCPACKET_DEFINITIONS_H

View File

@ -142,7 +142,7 @@ class TemperatureSensor : public AbstractTemperatureSensor {
deltaTime = (uptime.tv_sec + uptime.tv_usec / 1000000.) - deltaTime = (uptime.tv_sec + uptime.tv_usec / 1000000.) -
(uptimeOfOldTemperature.tv_sec + uptimeOfOldTemperature.tv_usec / 1000000.); (uptimeOfOldTemperature.tv_sec + uptimeOfOldTemperature.tv_usec / 1000000.);
deltaTemp = oldTemperature - outputTemperature.value; deltaTemp = oldTemperature - outputTemperature;
if (deltaTemp < 0) { if (deltaTemp < 0) {
deltaTemp = -deltaTemp; deltaTemp = -deltaTemp;
} }
@ -160,13 +160,13 @@ class TemperatureSensor : public AbstractTemperatureSensor {
outputTemperature.setValid(PoolVariableIF::INVALID); outputTemperature.setValid(PoolVariableIF::INVALID);
outputTemperature = thermal::INVALID_TEMPERATURE; outputTemperature = thermal::INVALID_TEMPERATURE;
} else { } else {
oldTemperature = outputTemperature.value; oldTemperature = outputTemperature;
uptimeOfOldTemperature = uptime; uptimeOfOldTemperature = uptime;
} }
} }
public: public:
float getTemperature() { return outputTemperature.value; } float getTemperature() { return outputTemperature; }
bool isValid() { return outputTemperature.isValid(); } bool isValid() { return outputTemperature.isValid(); }

View File

@ -192,8 +192,6 @@ class Clock {
static MutexIF *timeMutex; static MutexIF *timeMutex;
static uint16_t leapSeconds; static uint16_t leapSeconds;
static bool leapSecondsSet; static bool leapSecondsSet;
static bool monotonicClockInitialized;
static timeval monotonicClockOffset;
}; };
#endif /* FSFW_TIMEMANAGER_CLOCK_H_ */ #endif /* FSFW_TIMEMANAGER_CLOCK_H_ */

View File

@ -62,7 +62,6 @@ TEST_CASE("Pool Dataset Test", "[datapool]") {
size_t serLen = 0; size_t serLen = 0;
uint8_t* dataPtr = buf; uint8_t* dataPtr = buf;
dataset.serializeWithValidityBlob = true; dataset.serializeWithValidityBlob = true;
CHECK(dataset.getSerializedSize() == 6);
CHECK(dataset.serialize(&dataPtr, &serLen, sizeof(buf), SerializeIF::Endianness::NETWORK) == CHECK(dataset.serialize(&dataPtr, &serLen, sizeof(buf), SerializeIF::Endianness::NETWORK) ==
returnvalue::OK); returnvalue::OK);
CHECK(buf[5] == 0b11000000); CHECK(buf[5] == 0b11000000);
@ -71,7 +70,7 @@ TEST_CASE("Pool Dataset Test", "[datapool]") {
SECTION("Larger Pool Dataset Serialization With Validity") { SECTION("Larger Pool Dataset Serialization With Validity") {
uint8_t buf[64]{}; uint8_t buf[64]{};
TestDatasetLarger datasetLarge; TestDatasetLarger datasetLarge;
datasetLarge.setChildrenValidity(true); datasetLarge.setAllChildrenValidity(true);
size_t serLen = 0; size_t serLen = 0;
uint8_t* dataPtr = buf; uint8_t* dataPtr = buf;
datasetLarge.serializeWithValidityBlob = true; datasetLarge.serializeWithValidityBlob = true;

View File

@ -23,7 +23,6 @@ TEST_CASE("DataSetTest", "[datapool]") {
SECTION("BasicTest") { SECTION("BasicTest") {
/* Test some basic functions */ /* Test some basic functions */
CHECK(localSet.getReportingEnabled() == false); CHECK(localSet.getReportingEnabled() == false);
CHECK(localSet.getSerializedSize() == 11);
CHECK(localSet.getLocalPoolIdsSerializedSize() == 3 * sizeof(dp::id_t)); CHECK(localSet.getLocalPoolIdsSerializedSize() == 3 * sizeof(dp::id_t));
CHECK(localSet.getStructureId() == lpool::testSid1); CHECK(localSet.getStructureId() == lpool::testSid1);
CHECK(localSet.getCreatorObjectId() == objects::TEST_LOCAL_POOL_OWNER_BASE); CHECK(localSet.getCreatorObjectId() == objects::TEST_LOCAL_POOL_OWNER_BASE);
@ -157,7 +156,7 @@ TEST_CASE("DataSetTest", "[datapool]") {
} }
SECTION("Serialize with Validity Blob") { SECTION("Serialize with Validity Blob") {
localSet.updateValidityBlobSerialization(true); localSet.serializeWithValidityBlob = true;
CHECK(!localSet.localPoolVarUint8.isValid()); CHECK(!localSet.localPoolVarUint8.isValid());
CHECK(!localSet.localPoolUint16Vec.isValid()); CHECK(!localSet.localPoolUint16Vec.isValid());
CHECK(!localSet.localPoolVarFloat.isValid()); CHECK(!localSet.localPoolVarFloat.isValid());
@ -169,7 +168,6 @@ TEST_CASE("DataSetTest", "[datapool]") {
// Already reserve additional space for validity buffer, will be needed later // Already reserve additional space for validity buffer, will be needed later
uint8_t buffer[128]{}; uint8_t buffer[128]{};
uint8_t* buffPtr = buffer; uint8_t* buffPtr = buffer;
CHECK(localSet.getSerializedSize() == 12);
CHECK(localSet.serialize(&buffPtr, &serSize, sizeof(buffer), CHECK(localSet.serialize(&buffPtr, &serSize, sizeof(buffer),
SerializeIF::Endianness::MACHINE) == returnvalue::OK); SerializeIF::Endianness::MACHINE) == returnvalue::OK);
CHECK(serSize == 12); CHECK(serSize == 12);