samples: matter: closure: persistent storage

Added persistent storage to the closure sample
The open percentage is saved and restored after reboot

Signed-off-by: Adam Maciuga <[email protected]>

Author: Adam-Maciuga

samples/matter/closure/CMakeLists.txt

@@ -37,6 +37,7 @@ target_sources(app PRIVATE
   src/closure_manager.cpp
   src/closure_control_endpoint.cpp
   src/garage_door_impl.cpp
+  src/persistent_percent.cpp
 )
 
 ncs_configure_data_model()

samples/matter/closure/prj.conf

@@ -52,3 +52,6 @@ CONFIG_USE_SEGGER_RTT=n
 # Enable Factory Data feature
 CONFIG_CHIP_FACTORY_DATA=y
 CONFIG_CHIP_FACTORY_DATA_BUILD=y
+
+#Enable Persistent Storage
+CONFIG_NCS_SAMPLE_MATTER_PERSISTENT_STORAGE=y

samples/matter/closure/prj_release.conf

@@ -69,3 +69,6 @@ CONFIG_NCS_SAMPLE_MATTER_WATCHDOG=y
 # Enable LTO to decrease the flash usage.
 CONFIG_LTO=y
 CONFIG_ISR_TABLES_LOCAL_DECLARATION=y
+
+#Enable Persistent Storage
+CONFIG_NCS_SAMPLE_MATTER_PERSISTENT_STORAGE=y

samples/matter/closure/src/app_task.cpp

@@ -21,6 +21,8 @@
 #include <app/util/attribute-storage.h>
 #include <setup_payload/OnboardingCodesUtil.h>
 
+#include <persistent_storage/persistent_storage.h>
+
 #include <zephyr/logging/log.h>
 
 LOG_MODULE_DECLARE(app, CONFIG_CHIP_APP_LOG_LEVEL);
@@ -59,6 +61,10 @@ CHIP_ERROR AppTask::Init()
 
 	ReturnErrorOnFailure(sIdentifyCluster.Init());
 
+	if (Nrf::GetPersistentStorage().NonSecureInit(&mRootNode) != Nrf::PSErrorCode::Success) {
+		return CHIP_ERROR_PERSISTED_STORAGE_FAILED;
+	}
+
 	ReturnErrorOnFailure(mClosureManager.Init());
 	return CHIP_NO_ERROR;
 }

samples/matter/closure/src/app_task.h

@@ -6,6 +6,7 @@
 #pragma once
 #include "closure_manager.h"
 #include "garage_door_impl.h"
+#include <persistent_storage/persistent_storage_common.h>
 
 class AppTask {
 public:
@@ -20,6 +21,8 @@ class AppTask {
 	CHIP_ERROR StartApp();
 
 private:
+	constexpr static auto kAccessPrefix = "cs";
+	Nrf::PersistentStorageNode mRootNode{ kAccessPrefix, strlen(kAccessPrefix) };
 	GarageDoorImpl mPhysicalDevice;
 	ClosureManager mClosureManager;
 };

samples/matter/closure/src/closure_manager.cpp

@@ -35,15 +35,15 @@ static Nrf::FiniteMap<TargetPositionEnum, uint16_t, 5> sPositionMapTarget = { {
 	{ TargetPositionEnum::kMoveToFullyOpen, 0 },
 	{ TargetPositionEnum::kMoveToPedestrianPosition, 0 },
 	{ TargetPositionEnum::kMoveToSignaturePosition, 0 },
-	{ TargetPositionEnum::kMoveToVentilationPosition, 7500 },
+	{ TargetPositionEnum::kMoveToVentilationPosition, 8000 },
 } };
 
 static Nrf::FiniteMap<CurrentPositionEnum, uint16_t, 5> sPositionMapCurr = { {
 	{ CurrentPositionEnum::kFullyClosed, 10000 },
 	{ CurrentPositionEnum::kFullyOpened, 0 },
 	{ CurrentPositionEnum::kOpenedForPedestrian, 0 },
 	{ CurrentPositionEnum::kOpenedAtSignature, 0 },
-	{ CurrentPositionEnum::kOpenedForVentilation, 7500 },
+	{ CurrentPositionEnum::kOpenedForVentilation, 8000 },
 } };
 
 static Nrf::FiniteMap<Clusters::Globals::ThreeLevelAutoEnum, uint16_t, 4> sSpeedMap = { {
@@ -91,8 +91,8 @@ ClosureManager::ClosureManager(IPhysicalDevice &device, chip::EndpointId closure
 
 CHIP_ERROR ClosureManager::Init()
 {
-	ReturnErrorOnFailure(mPhysicalDevice.Init());
 	mPhysicalDevice.SetObserver(this);
+	ReturnErrorOnFailure(mPhysicalDevice.Init());
 	DeviceLayer::StackLock lock;
 
 	/* Closure endpoints initialization */
@@ -159,6 +159,10 @@ void ClosureManager::OnMovementStopped(uint16_t currentPosition)
 		LOG_DBG("Attributes updated on movement stopped");
 	}
 }
+void ClosureManager::OnSetup(uint16_t currentPosition)
+{
+	mCurrentState.position = MakeOptional(ExactPos2Enum(currentPosition));
+}
 
 void ClosureManager::OnMovementUpdate(uint16_t currentPosition, uint16_t timeLeft, bool justStarted)
 {

samples/matter/closure/src/closure_manager.h

@@ -77,6 +77,7 @@ class ClosureManager : public IPhysicalDeviceObserver {
 	chip::Protocols::InteractionModel::Status OnStopCommand();
 
 	void OnMovementStopped(uint16_t currentPosition) override;
+	void OnSetup(uint16_t currentPosition) override;
 	void OnMovementUpdate(uint16_t currentPosition, uint16_t timeLeft, bool justStarted = false) override;
 
 	ElapsedS GetMoveCountdownTime() { return mMoveCountdownTime; }

samples/matter/closure/src/garage_door_impl.cpp

@@ -16,14 +16,21 @@ using namespace chip::DeviceLayer;
 
 static constexpr uint32_t kMoveIntervalMs = 100;
 
-GarageDoorImpl::GarageDoorImpl(const pwm_dt_spec *spec) : mSpec(spec) {}
+GarageDoorImpl::GarageDoorImpl(const pwm_dt_spec *spec) : mSpec(spec), mCurrentPosition("cp") {}
 
 CHIP_ERROR GarageDoorImpl::Init()
 {
+	ReturnErrorOnFailure(mCurrentPosition.Load());
+	mObserver->OnSetup(mCurrentPosition.Get());
+
 	if (mPhysicalIndicator.Init(mSpec, 0, 255) != 0) {
 		LOG_ERR("Cannot initialize the physical indicator");
 		return CHIP_ERROR_INCORRECT_STATE;
 	}
+	uint8_t brightness =
+		static_cast<uint8_t>((static_cast<uint32_t>(mCurrentPosition.Get()) * 255U + 5000U) / 10000U);
+	mPhysicalIndicator.InitiateAction(Nrf::PWMDevice::LEVEL_ACTION, 0, &brightness);
+
 	return CHIP_NO_ERROR;
 }
 
@@ -43,7 +50,7 @@ CHIP_ERROR GarageDoorImpl::Stop()
 {
 	SystemLayer().CancelTimer(TimerTimeoutCallback, this);
 	LOG_DBG("Movement stopped");
-	mObserver->OnMovementStopped(mCurrentPosition);
+	mObserver->OnMovementStopped(mCurrentPosition.Get());
 	return CHIP_NO_ERROR;
 }
 
@@ -60,25 +67,26 @@ void GarageDoorImpl::HandleTimer()
 	uint32_t movePerTick32 = (static_cast<uint32_t>(mSpeed) * kMoveIntervalMs) / 1000U;
 	uint16_t movePerTick = static_cast<uint16_t>(std::min<uint32_t>(movePerTick32, UINT16_MAX));
 	uint16_t distanceLeft = 0;
-	if (mCurrentPosition <= mTargetPosition) {
-		distanceLeft = mTargetPosition - mCurrentPosition;
+
+	if (mCurrentPosition.Get() <= mTargetPosition) {
+		distanceLeft = mTargetPosition - mCurrentPosition.Get();
 		if (movePerTick >= distanceLeft) {
 			finished = true;
-			mCurrentPosition = mTargetPosition;
+			mCurrentPosition.Set(mTargetPosition, true);
 		} else {
-			mCurrentPosition += movePerTick;
+			mCurrentPosition.Set(mCurrentPosition.Get() + movePerTick);
 		}
 	} else {
-		distanceLeft = mCurrentPosition - mTargetPosition;
+		distanceLeft = mCurrentPosition.Get() - mTargetPosition;
 		if (movePerTick >= distanceLeft) {
 			finished = true;
-			mCurrentPosition = mTargetPosition;
+			mCurrentPosition.Set(mTargetPosition, true);
 		} else {
-			mCurrentPosition -= movePerTick;
+			mCurrentPosition.Set(mCurrentPosition.Get() - movePerTick);
 		}
 	}
-
-	uint8_t brightness = static_cast<uint8_t>((static_cast<uint32_t>(mCurrentPosition) * 255U + 5000U) / 10000U);
+	uint8_t brightness =
+		static_cast<uint8_t>((static_cast<uint32_t>(mCurrentPosition.Get()) * 255U + 5000U) / 10000U);
 
 	mPhysicalIndicator.InitiateAction(Nrf::PWMDevice::LEVEL_ACTION, 0, &brightness);
 
@@ -87,7 +95,7 @@ void GarageDoorImpl::HandleTimer()
 	} else {
 		uint32_t timeLeftMs = (static_cast<uint32_t>(distanceLeft) * kMoveIntervalMs) / movePerTick;
 		uint16_t timeLeftS = static_cast<uint16_t>((timeLeftMs + 999) / 1000); /*ceil*/
-		mObserver->OnMovementUpdate(mCurrentPosition, timeLeftS, mJustStarted);
+		mObserver->OnMovementUpdate(mCurrentPosition.Get(), timeLeftS, mJustStarted);
 		mJustStarted = false;
 		auto err = SystemLayer().StartTimer(System::Clock::Milliseconds32(kMoveIntervalMs),
 						    TimerTimeoutCallback, this);

samples/matter/closure/src/garage_door_impl.h

@@ -6,6 +6,7 @@
 
 #pragma once
 
+#include "persistent_percent.h"
 #include "physical_device.h"
 #include "physical_device_observer.h"
 #include "pwm/pwm_device.h"
@@ -30,6 +31,6 @@ class GarageDoorImpl : public IPhysicalDevice {
 	const pwm_dt_spec *mSpec;
 	bool mJustStarted = false;
 	uint16_t mSpeed;
-	uint16_t mCurrentPosition;
+	PersistentPercent mCurrentPosition;
 	uint16_t mTargetPosition;
 };

samples/matter/closure/src/persistent_percent.cpp

@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2025 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
+ */
+
+#include "persistent_percent.h"
+
+#include <cstdlib>
+#include <cstring>
+#include <persistent_storage/persistent_storage.h>
+#include <platform/CHIPDeviceLayer.h>
+
+#include <zephyr/logging/log.h>
+
+LOG_MODULE_DECLARE(persistent_percent, CONFIG_CHIP_APP_LOG_LEVEL);
+
+using namespace chip;
+using namespace chip::DeviceLayer;
+
+CHIP_ERROR PersistentPercent::Set(uint16_t newValue, bool forceStore)
+{
+	mValue = newValue;
+	uint16_t rounded = RoundToStep(newValue);
+
+	if (forceStore) {
+		ReturnErrorOnFailure(Store(mValue));
+	} else if (rounded != mStored) {
+		ReturnErrorOnFailure(Store(rounded));
+	}
+	return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR PersistentPercent::Store(uint16_t val)
+{
+	Nrf::PersistentStorageNode node{ mKey.c_str(), mKey.size() + 1 };
+	auto err = Nrf::GetPersistentStorage().NonSecureStore(&node, &val, sizeof(val));
+
+	if (err == Nrf::PSErrorCode::Success) {
+		mStored = val;
+		return CHIP_NO_ERROR;
+	}
+	return CHIP_ERROR_PERSISTED_STORAGE_FAILED;
+}
+
+CHIP_ERROR PersistentPercent::Load()
+{
+	Nrf::PersistentStorageNode node{ mKey.c_str(), mKey.size() + 1 };
+	size_t outSize = 0;
+	auto err = Nrf::GetPersistentStorage().NonSecureLoad(&node, &mValue, sizeof(mValue), outSize);
+
+	if (err == Nrf::PSErrorCode::Success) {
+		mStored = mValue;
+		return CHIP_NO_ERROR;
+	}
+	// Not found, store default
+	return Store(mValue);
+}
+
+uint16_t PersistentPercent::RoundToStep(uint16_t v)
+{
+	uint16_t best = allowed[0];
+	uint16_t bestDiff = std::abs((int)allowed[0] - (int)v);
+
+	for (uint16_t a : allowed) {
+		uint16_t diff = std::abs((int)a - (int)v);
+		if (diff < bestDiff) {
+			best = a;
+			bestDiff = diff;
+		}
+	}
+	return best;
+}