diff --git a/src/fsfw/datapool/PoolDataSetBase.cpp b/src/fsfw/datapool/PoolDataSetBase.cpp index 362aeef6..f7a21392 100644 --- a/src/fsfw/datapool/PoolDataSetBase.cpp +++ b/src/fsfw/datapool/PoolDataSetBase.cpp @@ -8,10 +8,12 @@ #include "fsfw/serviceinterface/ServiceInterface.h" PoolDataSetBase::PoolDataSetBase(PoolVariableIF** registeredVariablesArray, - const size_t maxFillCount) - : registeredVariables(registeredVariablesArray), maxFillCount(maxFillCount) {} + const size_t maxFillCount, bool serializeWithValidityBlob) + : registeredVariables(registeredVariablesArray), + maxFillCount(maxFillCount), + serializeWithValidityBlob(serializeWithValidityBlob) {} -PoolDataSetBase::~PoolDataSetBase() {} +PoolDataSetBase::~PoolDataSetBase() = default; ReturnValue_t PoolDataSetBase::registerVariable(PoolVariableIF* variable) { if (registeredVariables == nullptr) { @@ -174,6 +176,9 @@ ReturnValue_t PoolDataSetBase::unlockDataPool() { return returnvalue::OK; } ReturnValue_t PoolDataSetBase::serialize(uint8_t** buffer, size_t* size, const size_t maxSize, SerializeIF::Endianness streamEndianness) const { + if (this->serializeWithValidityBlob) { + return doSerializeWithValidityBlob(buffer, size, maxSize, streamEndianness); + } ReturnValue_t result = returnvalue::FAILED; for (uint16_t count = 0; count < fillCount; count++) { result = registeredVariables[count]->serialize(buffer, size, maxSize, streamEndianness); @@ -184,7 +189,7 @@ ReturnValue_t PoolDataSetBase::serialize(uint8_t** buffer, size_t* size, const s return result; } -ReturnValue_t PoolDataSetBase::serializeWithValidityBlob( +ReturnValue_t PoolDataSetBase::doSerializeWithValidityBlob( uint8_t** buffer, size_t* size, const size_t maxSize, SerializeIF::Endianness streamEndianness) const { ReturnValue_t result = returnvalue::FAILED; @@ -204,7 +209,7 @@ ReturnValue_t PoolDataSetBase::serializeWithValidityBlob( uint8_t validBufferIndexBit = 0; for (uint16_t count = 0; count < fillCount; count++) { if (registeredVariables[count]->isValid()) { - /* Set bit at correct position */ + // Set bit at correct position bitutil::set(validityPtr + validBufferIndex, validBufferIndexBit); } if (validBufferIndexBit == 7) { diff --git a/src/fsfw/datapool/PoolDataSetBase.h b/src/fsfw/datapool/PoolDataSetBase.h index bfe20954..6f4ee475 100644 --- a/src/fsfw/datapool/PoolDataSetBase.h +++ b/src/fsfw/datapool/PoolDataSetBase.h @@ -41,7 +41,8 @@ class PoolDataSetBase : public PoolDataSetIF, public SerializeIF { * supply a pointer to this dataset to PoolVariable * initializations to register pool variables. */ - PoolDataSetBase(PoolVariableIF** registeredVariablesArray, size_t maxFillCount); + PoolDataSetBase(PoolVariableIF** registeredVariablesArray, size_t maxFillCount, + bool serializeWithValidityBlob); /* Forbidden for now */ PoolDataSetBase(const PoolDataSetBase& otherSet) = delete; @@ -115,15 +116,15 @@ class PoolDataSetBase : public PoolDataSetIF, public SerializeIF { [[nodiscard]] uint16_t getFillCount() const override; - /* SerializeIF implementations */ + // SerializeIF implementations ReturnValue_t serialize(uint8_t** buffer, size_t* size, const size_t maxSize, SerializeIF::Endianness streamEndianness) const override; [[nodiscard]] size_t getSerializedSize() const override; ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size, SerializeIF::Endianness streamEndianness) override; - ReturnValue_t serializeWithValidityBlob(uint8_t** buffer, size_t* size, const size_t maxSize, - SerializeIF::Endianness streamEndianness) const; + ReturnValue_t doSerializeWithValidityBlob(uint8_t** buffer, size_t* size, const size_t maxSize, + SerializeIF::Endianness streamEndianness) const; /** * Can be used to individually protect every read and commit call. * @param protectEveryReadCommit @@ -165,6 +166,7 @@ class PoolDataSetBase : public PoolDataSetIF, public SerializeIF { */ PoolVariableIF** registeredVariables = nullptr; const size_t maxFillCount = 0; + bool serializeWithValidityBlob = false; void setContainer(PoolVariableIF** variablesContainer); PoolVariableIF** getContainer() const; diff --git a/src/fsfw/datapool/SharedSet.cpp b/src/fsfw/datapool/SharedSet.cpp index 3150e2f3..6c661be2 100644 --- a/src/fsfw/datapool/SharedSet.cpp +++ b/src/fsfw/datapool/SharedSet.cpp @@ -2,14 +2,17 @@ using namespace dp; -SharedSet::SharedSet(dp::SharedPool& sharedPool, uint32_t setId, const size_t maxNumberOfVariables) - : SharedSetBase(sharedPool, setId, nullptr, maxNumberOfVariables), +SharedSet::SharedSet(dp::SharedPool& sharedPool, uint32_t setId, const size_t maxNumberOfVariables, + bool serializeWithValídityBlob) + : SharedSetBase(sharedPool, setId, nullptr, maxNumberOfVariables, serializeWithValidityBlob), poolVarList(maxNumberOfVariables) { this->setContainer(poolVarList.data()); } -SharedSet::SharedSet(dp::structure_id_t sid, const size_t maxNumberOfVariables) - : SharedSetBase(sid, nullptr, maxNumberOfVariables), poolVarList(maxNumberOfVariables) { +SharedSet::SharedSet(dp::structure_id_t sid, const size_t maxNumberOfVariables, + bool serializeWithValidityBlob) + : SharedSetBase(sid, nullptr, maxNumberOfVariables, serializeWithValidityBlob), + poolVarList(maxNumberOfVariables) { this->setContainer(poolVarList.data()); } diff --git a/src/fsfw/datapool/SharedSet.h b/src/fsfw/datapool/SharedSet.h index f7d516c9..faac6949 100644 --- a/src/fsfw/datapool/SharedSet.h +++ b/src/fsfw/datapool/SharedSet.h @@ -21,9 +21,9 @@ namespace datapool { */ class SharedSet : public SharedSetBase { public: - SharedSet(SharedPool& sharedPool, uint32_t setId, size_t maxSize); + SharedSet(SharedPool& sharedPool, uint32_t setId, size_t maxSize, bool serializeWithValidityBlob); - SharedSet(sid_t sid, size_t maxSize); + SharedSet(sid_t sid, size_t maxSize, bool serializeWithValidityBlob); ~SharedSet() override; diff --git a/src/fsfw/datapool/SharedSetBase.cpp b/src/fsfw/datapool/SharedSetBase.cpp index 82b21459..cda80a05 100644 --- a/src/fsfw/datapool/SharedSetBase.cpp +++ b/src/fsfw/datapool/SharedSetBase.cpp @@ -14,8 +14,9 @@ using namespace datapool; SharedSetBase::SharedSetBase(SharedPool &sharedPool, uint32_t setId, PoolVariableIF **registeredVariablesArray, - const size_t maxNumberOfVariables) - : base(registeredVariablesArray, maxNumberOfVariables), sharedPool(&sharedPool) { + const size_t maxNumberOfVariables, bool serializeWithValidityBlob) + : base(registeredVariablesArray, maxNumberOfVariables, serializeWithValidityBlob), + sharedPool(&sharedPool) { mutexIfSingleDataCreator = sharedPool.getPoolMutex(); this->sid.objectId = sharedPool.getOwnerId(); @@ -23,8 +24,8 @@ SharedSetBase::SharedSetBase(SharedPool &sharedPool, uint32_t setId, } SharedSetBase::SharedSetBase(structure_id_t sid, PoolVariableIF **registeredVariablesArray, - const size_t maxNumberOfVariables) - : base(registeredVariablesArray, maxNumberOfVariables) { + const size_t maxNumberOfVariables, bool serializeWithValidityBlob) + : base(registeredVariablesArray, maxNumberOfVariables, serializeWithValidityBlob) { auto *hkOwner = ObjectManager::instance()->get(sid.objectId); if (hkOwner != nullptr) { sharedPool = hkOwner->getOptionalSharedPool(); @@ -37,8 +38,9 @@ SharedSetBase::SharedSetBase(structure_id_t sid, PoolVariableIF **registeredVari } SharedSetBase::SharedSetBase(PoolVariableIF **registeredVariablesArray, - const size_t maxNumberOfVariables, bool protectEveryReadCommitCall) - : base(registeredVariablesArray, maxNumberOfVariables) { + const size_t maxNumberOfVariables, bool protectEveryReadCommitCall, + bool serializeWithValidityBlob) + : base(registeredVariablesArray, maxNumberOfVariables, serializeWithValidityBlob) { base.setReadCommitProtectionBehaviour(protectEveryReadCommitCall); } @@ -103,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, SerializeIF::Endianness streamEndianness) const { + if (serializeWithValidityBlob) { + return base.doSerializeWithValidityBlob(buffer, size, maxSize, streamEndianness); + } return base.serialize(buffer, size, maxSize, streamEndianness); } @@ -112,11 +117,6 @@ ReturnValue_t SharedSetBase::serialize(uint8_t **buffer, size_t *size, size_t ma return SerializeIF::serialize(buffer, serLen, maxSize, streamEndianness); } -[[nodiscard]] ReturnValue_t SharedSetBase::serializeWithValidityBlob( - uint8_t **buffer, size_t *size, size_t maxSize, Endianness streamEndianness) const { - return base.serializeWithValidityBlob(buffer, size, maxSize, streamEndianness); -} - void SharedSetBase::setReportingEnabled(bool reportingEnabled) { this->reportingEnabled = reportingEnabled; } diff --git a/src/fsfw/datapool/SharedSetBase.h b/src/fsfw/datapool/SharedSetBase.h index 9ef878f7..28e72614 100644 --- a/src/fsfw/datapool/SharedSetBase.h +++ b/src/fsfw/datapool/SharedSetBase.h @@ -48,7 +48,7 @@ class SharedSetBase : public SerializeIF, public PoolDataSetIF { * periodic handling. */ SharedSetBase(SharedPool& sharedPool, uint32_t setId, PoolVariableIF** registeredVariablesArray, - size_t maxNumberOfVariables); + size_t maxNumberOfVariables, bool serializeWithValidityBlob); /** * @brief Constructor for users of the local pool data, which need @@ -61,7 +61,8 @@ class SharedSetBase : public SerializeIF, public PoolDataSetIF { * @param registeredVariablesArray * @param maxNumberOfVariables */ - SharedSetBase(sid_t sid, PoolVariableIF** registeredVariablesArray, size_t maxNumberOfVariables); + SharedSetBase(sid_t sid, PoolVariableIF** registeredVariablesArray, size_t maxNumberOfVariables, + bool serializeWithValidityBlob); /** * @brief Simple constructor, if the dataset is not the owner by @@ -82,7 +83,7 @@ class SharedSetBase : public SerializeIF, public PoolDataSetIF { * commit calls separately. */ SharedSetBase(PoolVariableIF** registeredVariablesArray, size_t maxNumberOfVariables, - bool protectEveryReadCommitCall = true); + bool serializeWithValidityBlob, bool protectEveryReadCommitCall = true); /** * @brief The destructor automatically manages writing the valid @@ -116,10 +117,6 @@ class SharedSetBase : public SerializeIF, public PoolDataSetIF { virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size, Endianness streamEndianness) override; - [[nodiscard]] virtual ReturnValue_t serializeWithValidityBlob(uint8_t** buffer, size_t* size, - size_t maxSize, - Endianness streamEndianness) const; - [[nodiscard]] dp::sid_t getStructureId() const; [[nodiscard]] size_t getSerializedSize() const override; @@ -162,6 +159,12 @@ class SharedSetBase : public SerializeIF, public PoolDataSetIF { */ void setChildrenValidity(bool valid); + /** + * If the valid state of a dataset is always relevant to the whole + * data set we can use this flag. + */ + bool serializeWithValidityBlob = false; + protected: PoolDataSetBase base; @@ -176,12 +179,6 @@ class SharedSetBase : public SerializeIF, public PoolDataSetIF { void initializePeriodicHelper(float collectionInterval, dur_millis_t minimumPeriodicInterval); - /** - * If the valid state of a dataset is always relevant to the whole - * data set we can use this flag. - */ - bool valid = false; - /** * @brief This is a small helper function to facilitate locking * the global data pool. diff --git a/src/fsfw/datapool/StaticSharedSet.h b/src/fsfw/datapool/StaticSharedSet.h index 7c96010f..13a2fd4a 100644 --- a/src/fsfw/datapool/StaticSharedSet.h +++ b/src/fsfw/datapool/StaticSharedSet.h @@ -28,8 +28,8 @@ class StaticSharedSet : public datapool::SharedSetBase { * @param sharedPool Shared pool this dataset will read from or write to. * @param setId */ - StaticSharedSet(SharedPool& sharedPool, const uint32_t setId) - : SharedSetBase(sharedPool, setId, nullptr, NUM_VARIABLES) { + StaticSharedSet(SharedPool& sharedPool, const uint32_t setId, bool serializeWithValidityBlob) + : SharedSetBase(sharedPool, setId, nullptr, NUM_VARIABLES, serializeWithValidityBlob) { this->setContainer(poolVarList.data()); } @@ -37,7 +37,8 @@ class StaticSharedSet : public datapool::SharedSetBase { * Constructor used by data users like controllers. * @param sid */ - explicit StaticSharedSet(const structure_id_t sid) : SharedSetBase(sid, nullptr, NUM_VARIABLES) { + explicit StaticSharedSet(const structure_id_t sid, bool serializeWithValidityBlob) + : SharedSetBase(sid, nullptr, NUM_VARIABLES, serializeWithValidityBlob) { this->setContainer(poolVarList.data()); } diff --git a/src/fsfw/devicehandlers/DeviceHandlerThermalSet.h b/src/fsfw/devicehandlers/DeviceHandlerThermalSet.h index cf384694..2c1dd159 100644 --- a/src/fsfw/devicehandlers/DeviceHandlerThermalSet.h +++ b/src/fsfw/devicehandlers/DeviceHandlerThermalSet.h @@ -13,7 +13,7 @@ class DeviceHandlerThermalSet : public dp::StaticSharedSet<2> { : DeviceHandlerThermalSet(hkOwner->getObjectId(), cfg) {} DeviceHandlerThermalSet(object_id_t deviceHandler, ThermalStateCfg cfg) - : StaticSharedSet(dp::structure_id_t(deviceHandler, cfg.thermalSetId)), + : StaticSharedSet(dp::structure_id_t(deviceHandler, cfg.thermalSetId), true), thermalStatePoolId(cfg.thermalStatePoolId), heaterRequestPoolId(cfg.thermalRequestPoolId) {} diff --git a/src/fsfw/housekeeping/Dataset.h b/src/fsfw/housekeeping/Dataset.h index b2a6118f..619c8b3c 100644 --- a/src/fsfw/housekeeping/Dataset.h +++ b/src/fsfw/housekeeping/Dataset.h @@ -28,9 +28,9 @@ class Dataset : public SerializeIF { [[nodiscard]] size_t getNumberOfSerializables() const { return serializables.size(); } - [[nodiscard]] ReturnValue_t serializeWithValidityBlob(uint8_t **buffer, size_t *size, - size_t maxSize, - Endianness streamEndianness) const { + [[nodiscard]] ReturnValue_t doSerializeWithValidityBlob(uint8_t **buffer, size_t *size, + size_t maxSize, + Endianness streamEndianness) const { ReturnValue_t result = returnvalue::FAILED; const uint8_t validityMaskSize = std::ceil(static_cast(serializables.size()) / 8.0); uint8_t *validityPtr = nullptr; @@ -76,6 +76,9 @@ class Dataset : public SerializeIF { [[nodiscard]] ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize, Endianness streamEndianness) const override { + if (serializeWithValidityBlob) { + return doSerializeWithValidityBlob(buffer, size, maxSize, streamEndianness); + } ReturnValue_t result = returnvalue::OK; for (auto &serializable : serializables) { result = serializable.get().serialize(buffer, size, maxSize, streamEndianness); @@ -111,6 +114,8 @@ class Dataset : public SerializeIF { return result; } + bool serializeWithValidityBlob = false; + private: dp::structure_id_t sid; std::vector> serializables; diff --git a/src/fsfw/internalerror/InternalErrorDataset.h b/src/fsfw/internalerror/InternalErrorDataset.h index 41347917..97b1e75e 100644 --- a/src/fsfw/internalerror/InternalErrorDataset.h +++ b/src/fsfw/internalerror/InternalErrorDataset.h @@ -10,15 +10,16 @@ class InternalErrorDataset : public dp::StaticSharedSet<4> { public: static constexpr uint8_t ERROR_SET_ID = 0; - InternalErrorDataset(dp::SharedPool& sharedPool) : StaticSharedSet(sharedPool, ERROR_SET_ID) {} + InternalErrorDataset(dp::SharedPool& sharedPool) + : StaticSharedSet(sharedPool, ERROR_SET_ID, false) {} InternalErrorDataset(object_id_t objectId) - : StaticSharedSet(dp::structure_id_t(objectId, ERROR_SET_ID)) {} + : StaticSharedSet(dp::structure_id_t(objectId, ERROR_SET_ID), false) {} + dp::var_t valid = dp::var_t(sid.objectId, VALID, this); dp::var_t tmHits = dp::var_t(sid.objectId, TM_HITS, this); dp::var_t queueHits = dp::var_t(sid.objectId, QUEUE_HITS, this); dp::var_t storeHits = dp::var_t(sid.objectId, STORE_HITS, this); - dp::var_t valid = dp::var_t(sid.objectId, VALID, this); }; #endif /* FSFW_INTERNALERROR_INTERNALERRORDATASET_H_ */ diff --git a/src/fsfw/power/Fuse.h b/src/fsfw/power/Fuse.h index ee2a523b..fbf3f5b3 100644 --- a/src/fsfw/power/Fuse.h +++ b/src/fsfw/power/Fuse.h @@ -29,9 +29,9 @@ class FuseSet : public datapool::StaticSharedSet<6> { public: static constexpr uint8_t FUSE_SET_ID = 0; - FuseSet(dp::SharedPool &sharedPool) : StaticSharedSet(sharedPool, FUSE_SET_ID) {} + FuseSet(dp::SharedPool &sharedPool) : StaticSharedSet(sharedPool, FUSE_SET_ID, true) {} - FuseSet(object_id_t objectId) : StaticSharedSet(dp::sid_t(objectId, FUSE_SET_ID)) {} + FuseSet(object_id_t objectId) : StaticSharedSet(dp::sid_t(objectId, FUSE_SET_ID), true) {} dp::f32_t voltage = dp::f32_t(sid.objectId, FusePoolId::VOLTAGE, this); dp::f32_t current = dp::f32_t(sid.objectId, FusePoolId::CURRENT, this); diff --git a/src/fsfw/power/PowerSensor.h b/src/fsfw/power/PowerSensor.h index 7c0dfa78..54f0840e 100644 --- a/src/fsfw/power/PowerSensor.h +++ b/src/fsfw/power/PowerSensor.h @@ -21,10 +21,11 @@ class PowerSensorSet : public dp::StaticSharedSet<6> { public: static constexpr uint8_t POWER_SENSOR_SET_ID = 0; - PowerSensorSet(dp::SharedPool &sharedPool) : StaticSharedSet(sharedPool, POWER_SENSOR_SET_ID) {} + PowerSensorSet(dp::SharedPool &sharedPool) + : StaticSharedSet(sharedPool, POWER_SENSOR_SET_ID, true) {} PowerSensorSet(object_id_t objectId) - : StaticSharedSet(dp::sid_t(objectId, POWER_SENSOR_SET_ID)) {} + : StaticSharedSet(dp::sid_t(objectId, POWER_SENSOR_SET_ID), true) {} dp::f32_t current{sid.objectId, PowerSensorPoolId::CURRENT, this}; dp::f32_t voltage{sid.objectId, PowerSensorPoolId::VOLTAGE, this}; diff --git a/unittests/datapool/testDataset.cpp b/unittests/datapool/testDataset.cpp index 5bc7bcd8..3138bfc1 100644 --- a/unittests/datapool/testDataset.cpp +++ b/unittests/datapool/testDataset.cpp @@ -61,8 +61,9 @@ TEST_CASE("Pool Dataset Test", "[datapool]") { dataset.test1.setValid(true); size_t serLen = 0; uint8_t* dataPtr = buf; - CHECK(dataset.serializeWithValidityBlob(&dataPtr, &serLen, sizeof(buf), - SerializeIF::Endianness::NETWORK) == returnvalue::OK); + dataset.serializeWithValidityBlob = true; + CHECK(dataset.serialize(&dataPtr, &serLen, sizeof(buf), SerializeIF::Endianness::NETWORK) == + returnvalue::OK); CHECK(buf[5] == 0b11000000); } @@ -72,8 +73,9 @@ TEST_CASE("Pool Dataset Test", "[datapool]") { datasetLarge.setAllChildrenValidity(true); size_t serLen = 0; uint8_t* dataPtr = buf; - CHECK(datasetLarge.serializeWithValidityBlob( - &dataPtr, &serLen, sizeof(buf), SerializeIF::Endianness::NETWORK) == returnvalue::OK); + datasetLarge.serializeWithValidityBlob = true; + CHECK(datasetLarge.serialize(&dataPtr, &serLen, sizeof(buf), + SerializeIF::Endianness::NETWORK) == returnvalue::OK); CHECK(serLen == 32); CHECK(buf[30] == 0b11111111); CHECK(buf[31] == 0b10000000); diff --git a/unittests/datapool/testSharedSet.cpp b/unittests/datapool/testSharedSet.cpp index 34faf602..2a3cee5b 100644 --- a/unittests/datapool/testSharedSet.cpp +++ b/unittests/datapool/testSharedSet.cpp @@ -138,7 +138,7 @@ TEST_CASE("DataSetTest", "[datapool]") { SECTION("SharedDataSet") { object_id_t sharedSetId = objects::SHARED_SET_ID; - SharedSet sharedSet(poolOwner.sharedPool, sharedSetId, 5); + SharedSet sharedSet(poolOwner.sharedPool, sharedSetId, 5, false); localSet.localPoolVarUint8.setReadWriteMode(pool_rwm_t::VAR_WRITE); localSet.localPoolUint16Vec.setReadWriteMode(pool_rwm_t::VAR_WRITE); CHECK(sharedSet.registerVariable(&localSet.localPoolVarUint8) == returnvalue::OK); @@ -156,6 +156,7 @@ TEST_CASE("DataSetTest", "[datapool]") { } SECTION("Serialize with Validity Blob") { + localSet.serializeWithValidityBlob = true; CHECK(!localSet.localPoolVarUint8.isValid()); CHECK(!localSet.localPoolUint16Vec.isValid()); CHECK(!localSet.localPoolVarFloat.isValid()); @@ -169,6 +170,7 @@ TEST_CASE("DataSetTest", "[datapool]") { uint8_t* buffPtr = buffer; CHECK(localSet.serialize(&buffPtr, &serSize, sizeof(buffer), SerializeIF::Endianness::MACHINE) == returnvalue::OK); + CHECK(serSize == 12); CHECK(buffer[11] == 0b11100000); } } diff --git a/unittests/mock/poolDefinitions.h b/unittests/mock/poolDefinitions.h index 0df455e1..c24b2688 100644 --- a/unittests/mock/poolDefinitions.h +++ b/unittests/mock/poolDefinitions.h @@ -45,9 +45,10 @@ class Dataset : public List { class StaticTestDataset : public StaticSharedSet<3> { public: - StaticTestDataset() : StaticSharedSet(lpool::testSid1) {} + StaticTestDataset() : StaticSharedSet(lpool::testSid1, false) {} - StaticTestDataset(SharedPool& sharedPool, uint32_t setId) : StaticSharedSet(sharedPool, setId) {} + StaticTestDataset(SharedPool& sharedPool, uint32_t setId) + : StaticSharedSet(sharedPool, setId, false) {} u8_t localPoolVarUint8{lpool::uint8VarGpid, this}; f32_t localPoolVarFloat{lpool::floatVarGpid, this}; @@ -58,10 +59,10 @@ class StaticTestDataset : public StaticSharedSet<3> { class TestDataset : public SharedSet { public: - TestDataset() : SharedSet(lpool::testSid2, lpool::dataSetMaxVariables) {} + TestDataset() : SharedSet(lpool::testSid2, lpool::dataSetMaxVariables, false) {} TestDataset(SharedPool& sharedPool, uint32_t setId) - : SharedSet(sharedPool, setId, lpool::dataSetMaxVariables) {} + : SharedSet(sharedPool, setId, lpool::dataSetMaxVariables, false) {} u8_t localPoolVarUint8{lpool::uint8VarGpid, this}; f32_t localPoolVarFloat{lpool::floatVarGpid, this};