Update to upstream rs-matter-stack which features inband persistence (#43)

* Update to upstream rs-matter

* Swoitch to the blocking KvBlobStore trait as per upstream

* Example with persistent storage

* Option to reset the Matter state

Author: ivmarkov

Cargo.toml

@@ -8,9 +8,11 @@ exclude = ["examples"]
 
 [patch.crates-io]
 #rs-matter = { git = "https://github.com/project-chip/rs-matter" }
-rs-matter = { git = "https://github.com/sysgrok/rs-matter", branch = "next" }
+#rs-matter = { git = "https://github.com/sysgrok/rs-matter", branch = "next" }
+rs-matter = { git = "https://github.com/sysgrok/rs-matter", branch = "inband-persistence" }
 #rs-matter = { path = "../../rs-matter/rs-matter" }
-rs-matter-stack = { git = "https://github.com/ivmarkov/rs-matter-stack.git", branch = "next" }
+#rs-matter-stack = { git = "https://github.com/ivmarkov/rs-matter-stack.git", branch = "next" }
+rs-matter-stack = { git = "https://github.com/ivmarkov/rs-matter-stack.git", branch = "inband-persistence" }
 #rs-matter-stack = { path = "../../rs-matter-stack" }
 openthread = { git = "https://github.com/sysgrok/openthread.git", branch = "next" }
 #openthread = { path = "../../../openthread/openthread" }

examples/esp/.cargo/config.toml

@@ -20,3 +20,5 @@ build-std = ["core", "alloc", "panic_abort"]
 [env]
 DEFMT_LOG="info"
 ESP_LOG="info"
+# Uncomment and change this if you change the partition table offset (relevant for the light_wifi_persistent example)
+#ESP_BOOTLOADER_ESP_IDF_CONFIG_PARTITION_TABLE_OFFSET="0x8000"

examples/esp/Cargo.toml

@@ -9,6 +9,11 @@ name = "light_wifi"
 required-features = ["wifi"]
 harness = false
 
+[[bin]]
+name = "light_wifi_persistent"
+required-features = ["wifi"]
+harness = false
+
 [[bin]]
 name = "light_eth"
 required-features = ["wifi"]
@@ -30,9 +35,11 @@ required-features = ["thread"]
 harness = false
 
 [patch.crates-io]
-rs-matter = { git = "https://github.com/sysgrok/rs-matter", branch = "next" }
+#rs-matter = { git = "https://github.com/sysgrok/rs-matter", branch = "next" }
+rs-matter = { git = "https://github.com/sysgrok/rs-matter", branch = "inband-persistence" }
 #rs-matter = { path = "../../../rs-matter/rs-matter" }
-rs-matter-stack = { git = "https://github.com/sysgrok/rs-matter-stack.git", branch = "next" }
+#rs-matter-stack = { git = "https://github.com/sysgrok/rs-matter-stack.git", branch = "next" }
+rs-matter-stack = { git = "https://github.com/ivmarkov/rs-matter-stack.git", branch = "inband-persistence" }
 #rs-matter-stack = { path = "../../../rs-matter-stack" }
 openthread = { git = "https://github.com/sysgrok/openthread.git", branch = "next" }
 #openthread = { path = "../../../openthread/openthread" }
@@ -42,6 +49,7 @@ esp-hal = { git = "https://github.com/esp-rs/esp-hal", rev = "e156b5453a8adc123b
 esp-rtos = { git = "https://github.com/esp-rs/esp-hal", rev = "e156b5453a8adc123b7a8b6aa08e0698ec87dfe8" }
 esp-alloc = { git = "https://github.com/esp-rs/esp-hal", rev = "e156b5453a8adc123b7a8b6aa08e0698ec87dfe8" }
 esp-println = { git = "https://github.com/esp-rs/esp-hal", rev = "e156b5453a8adc123b7a8b6aa08e0698ec87dfe8" }
+esp-storage = { git = "https://github.com/esp-rs/esp-hal", rev = "e156b5453a8adc123b7a8b6aa08e0698ec87dfe8" }
 esp-bootloader-esp-idf = { git = "https://github.com/esp-rs/esp-hal", rev = "e156b5453a8adc123b7a8b6aa08e0698ec87dfe8" }
 esp-metadata-generated = { git = "https://github.com/esp-rs/esp-hal", rev = "e156b5453a8adc123b7a8b6aa08e0698ec87dfe8" }
 #esp-radio = { path = "../../../esp-hal/esp-radio" }
@@ -56,7 +64,7 @@ esp-metadata-generated = { git = "https://github.com/esp-rs/esp-hal", rev = "e15
 [profile.dev]
 # Rust debug is too slow.
 # For debug builds always builds with some optimization
-opt-level = "z"
+opt-level = "s"
 
 [profile.release]
 codegen-units = 1 # LLVM can perform better optimizations using a single thread
@@ -67,24 +75,26 @@ overflow-checks = false
 
 [features]
 default = ["esp32c6"]
-esp32 = ["esp-rtos/esp32", "esp-hal/esp32", "esp-backtrace/esp32", "esp-println/esp32", "esp-radio/esp32", "esp-bootloader-esp-idf/esp32", "esp-metadata-generated/esp32", "portable-atomic/critical-section", "wifi"]
-esp32c2 = ["esp-rtos/esp32c2", "esp-hal/esp32c2", "esp-backtrace/esp32c2", "esp-println/esp32c2", "esp-radio/esp32c2", "esp-bootloader-esp-idf/esp32c2", "esp-metadata-generated/esp32c2", "portable-atomic/critical-section", "wifi"]
-esp32c3 = ["esp-rtos/esp32c3", "esp-hal/esp32c3", "esp-backtrace/esp32c3", "esp-println/esp32c3", "esp-radio/esp32c3", "esp-bootloader-esp-idf/esp32c3", "esp-metadata-generated/esp32c3", "portable-atomic/unsafe-assume-single-core", "wifi"]
-esp32c6 = ["esp-rtos/esp32c6", "esp-hal/esp32c6", "esp-backtrace/esp32c6", "esp-println/esp32c6", "esp-radio/esp32c6", "esp-bootloader-esp-idf/esp32c6", "esp-metadata-generated/esp32c6", "portable-atomic/critical-section"]
-esp32s3 = ["esp-rtos/esp32s3", "esp-hal/esp32s3", "esp-backtrace/esp32s3", "esp-println/esp32s3", "esp-radio/esp32s3", "esp-bootloader-esp-idf/esp32s3", "esp-metadata-generated/esp32s3", "portable-atomic/critical-section", "wifi"]
-esp32h2 = ["esp-rtos/esp32h2", "esp-hal/esp32h2", "esp-backtrace/esp32h2", "esp-println/esp32h2", "esp-radio/esp32h2", "esp-bootloader-esp-idf/esp32h2", "esp-metadata-generated/esp32h2", "portable-atomic/critical-section", "thread"]
+esp32 = ["esp-rtos/esp32", "esp-hal/esp32", "esp-backtrace/esp32", "esp-println/esp32", "esp-radio/esp32", "esp-storage/esp32", "esp-bootloader-esp-idf/esp32", "esp-metadata-generated/esp32", "portable-atomic/critical-section", "wifi"]
+esp32c2 = ["esp-rtos/esp32c2", "esp-hal/esp32c2", "esp-backtrace/esp32c2", "esp-println/esp32c2", "esp-radio/esp32c2", "esp-storage/esp32c2", "esp-bootloader-esp-idf/esp32c2", "esp-metadata-generated/esp32c2", "portable-atomic/critical-section", "wifi"]
+esp32c3 = ["esp-rtos/esp32c3", "esp-hal/esp32c3", "esp-backtrace/esp32c3", "esp-println/esp32c3", "esp-radio/esp32c3", "esp-storage/esp32c3", "esp-bootloader-esp-idf/esp32c3", "esp-metadata-generated/esp32c3", "portable-atomic/unsafe-assume-single-core", "wifi"]
+esp32c6 = ["esp-rtos/esp32c6", "esp-hal/esp32c6", "esp-backtrace/esp32c6", "esp-println/esp32c6", "esp-radio/esp32c6", "esp-storage/esp32c6", "esp-bootloader-esp-idf/esp32c6", "esp-metadata-generated/esp32c6", "portable-atomic/critical-section"]
+esp32s3 = ["esp-rtos/esp32s3", "esp-hal/esp32s3", "esp-backtrace/esp32s3", "esp-println/esp32s3", "esp-radio/esp32s3", "esp-storage/esp32s3", "esp-bootloader-esp-idf/esp32s3", "esp-metadata-generated/esp32s3", "portable-atomic/critical-section", "wifi"]
+esp32h2 = ["esp-rtos/esp32h2", "esp-hal/esp32h2", "esp-backtrace/esp32h2", "esp-println/esp32h2", "esp-radio/esp32h2", "esp-storage/esp32h2", "esp-bootloader-esp-idf/esp32h2", "esp-metadata-generated/esp32h2", "portable-atomic/critical-section", "thread"]
 wifi = ["rs-matter-embassy/embassy-net"]
 thread = ["rs-matter-embassy/openthread"]
 
 [dependencies]
 log = "0.4"
 embassy-executor = "0.9"
+embassy-embedded-hal = "0.3"
 esp-backtrace = { version = "0.18.1", features = ["panic-handler", "println"] }
 esp-hal = { version = "1", features = ["log-04", "unstable", "exception-handler"] }
 esp-rtos = { version = "0.2", features = ["esp-radio", "embassy"] }
 esp-alloc = { version = "0.9" }
 esp-println = { version = "0.16", features = ["log-04"] }
 esp-radio = { version = "0.17", features = ["ble", "log-04", "unstable"] }
+esp-storage = "0.8"
 esp-bootloader-esp-idf = { version = "0.4", features = ["log-04"] }
 esp-metadata-generated = "0.3"
 rs-matter-embassy = { path = "../../rs-matter-embassy", features = ["esp", "log"] }

examples/esp/src/bin/light_eth.rs

@@ -37,10 +37,10 @@ use rs_matter_embassy::matter::dm::devices::test::{
 };
 use rs_matter_embassy::matter::dm::devices::DEV_TYPE_ON_OFF_LIGHT;
 use rs_matter_embassy::matter::dm::{Async, Dataver, EmptyHandler, Endpoint, EpClMatcher, Node};
+use rs_matter_embassy::matter::persist::DummyKvBlobStore;
 use rs_matter_embassy::matter::utils::init::InitMaybeUninit;
 use rs_matter_embassy::matter::utils::select::Coalesce;
 use rs_matter_embassy::matter::{clusters, devices};
-use rs_matter_embassy::stack::persist::DummyKvBlobStore;
 use rs_matter_embassy::stack::rand::reseeding_csprng;
 use rs_matter_embassy::stack::utils::futures::IntoFaillble;
 
@@ -151,13 +151,14 @@ async fn main(_s: Spawner) {
             Async(desc::DescHandler::new(Dataver::new_rand(&mut weak_rand)).adapt()),
         );
 
-    // Create the persister & load any previously saved state
-    // `EmbassyPersist`+`EmbassyKvBlobStore` saves to a user-supplied NOR Flash region
-    // However, for this demo and for simplicity, we use a dummy persister that does nothing
-    let persist = stack
-        .create_persist_with_comm_window(&crypto, DummyKvBlobStore)
-        .await
-        .unwrap();
+    // Create a KV BLOB store and load any previously saved state of `rs-matter`
+    // `SeqMapKvBlobStore` saves to a user-supplied NOR Flash region
+    // However, for this demo and for simplicity, we use a dummy KV BLOB store that does nothing
+    let mut kv = DummyKvBlobStore;
+    stack.startup(&crypto, &mut kv).await.unwrap();
+
+    // Wrap the KV BLOB store as a shared reference, so that it can be used both by `rs-matter` and the user
+    let kv = stack.create_shared_kv(kv).unwrap();
 
     // Run the Matter stack with our handler
     // Using `pin!` is completely optional, but reduces the size of the final future
@@ -168,12 +169,12 @@ async fn main(_s: Spawner) {
             weak_rand,
             stack,
         ),
-        // The Matter stack needs a persister to store its state
-        &persist,
         // The crypto provider
         &crypto,
         // Our `AsyncHandler` + `AsyncMetadata` impl
         (NODE, handler),
+        // The Matter stack needs a blob store to store its state
+        &kv,
         // No user future to run
         (),
     ));

examples/esp/src/bin/light_eth2.rs

@@ -36,14 +36,14 @@ use rs_matter_embassy::matter::dm::devices::test::{
 };
 use rs_matter_embassy::matter::dm::devices::DEV_TYPE_ON_OFF_LIGHT;
 use rs_matter_embassy::matter::dm::{Async, Dataver, EmptyHandler, Endpoint, EpClMatcher, Node};
+use rs_matter_embassy::matter::persist::DummyKvBlobStore;
 use rs_matter_embassy::matter::utils::init::InitMaybeUninit;
 use rs_matter_embassy::matter::utils::select::Coalesce;
 use rs_matter_embassy::matter::{clusters, devices, BasicCommData};
 use rs_matter_embassy::ot::openthread::esp::EspRadio;
 use rs_matter_embassy::ot::openthread::{OpenThread, RamSettings};
 use rs_matter_embassy::ot::{OtMatterResources, OtMdns, OtNetStack, OtNetif};
 use rs_matter_embassy::stack::eth::EthMatterStack;
-use rs_matter_embassy::stack::persist::DummyKvBlobStore;
 use rs_matter_embassy::stack::rand::{reseeding_csprng, RngAdaptor};
 
 use tinyrlibc as _;
@@ -189,13 +189,14 @@ async fn main(_s: Spawner) {
             Async(desc::DescHandler::new(Dataver::new_rand(&mut weak_rand)).adapt()),
         );
 
-    // Create the persister & load any previously saved state
-    // `EmbassyPersist`+`EmbassyKvBlobStore` saves to a user-supplied NOR Flash region
-    // However, for this demo and for simplicity, we use a dummy persister that does nothing
-    let persist = stack
-        .create_persist_with_comm_window(&crypto, DummyKvBlobStore)
-        .await
-        .unwrap();
+    // Create a KV BLOB store and load any previously saved state of `rs-matter`
+    // `SeqMapKvBlobStore` saves to a user-supplied NOR Flash region
+    // However, for this demo and for simplicity, we use a dummy KV BLOB store that does nothing
+    let mut kv = DummyKvBlobStore;
+    stack.startup(&crypto, &mut kv).await.unwrap();
+
+    // Wrap the KV BLOB store as a shared reference, so that it can be used both by `rs-matter` and the user
+    let kv = stack.create_shared_kv(kv).unwrap();
 
     // Run the Matter stack with our handler
     // Using `pin!` is completely optional, but reduces the size of the final future
@@ -206,12 +207,12 @@ async fn main(_s: Spawner) {
         OtNetif::new(ot.clone()),
         // The Matter stack needs an mDNS instance to run
         OtMdns::new(ot.clone()),
-        // The Matter stack needs a persister to store its state
-        &persist,
         // The crypto provider
         &crypto,
         // Our `AsyncHandler` + `AsyncMetadata` impl
         (NODE, handler),
+        // The Matter stack needs a blob store to store its state
+        &kv,
         // No user future to run
         (),
     ));

examples/esp/src/bin/light_thread.rs

@@ -33,9 +33,9 @@ use rs_matter_embassy::matter::dm::devices::test::{
 };
 use rs_matter_embassy::matter::dm::devices::DEV_TYPE_ON_OFF_LIGHT;
 use rs_matter_embassy::matter::dm::{Async, Dataver, EmptyHandler, Endpoint, EpClMatcher, Node};
+use rs_matter_embassy::matter::persist::DummyKvBlobStore;
 use rs_matter_embassy::matter::utils::init::InitMaybeUninit;
 use rs_matter_embassy::matter::{clusters, devices, BasicCommData};
-use rs_matter_embassy::stack::persist::DummyKvBlobStore;
 use rs_matter_embassy::stack::rand::reseeding_csprng;
 use rs_matter_embassy::wireless::esp::EspThreadDriver;
 use rs_matter_embassy::wireless::{EmbassyThread, EmbassyThreadMatterStack};
@@ -157,13 +157,14 @@ async fn main(_s: Spawner) {
             Async(desc::DescHandler::new(Dataver::new_rand(&mut weak_rand)).adapt()),
         );
 
-    // Create the persister & load any previously saved state
-    // `EmbassyPersist`+`EmbassyKvBlobStore` saves to a user-supplied NOR Flash region
-    // However, for this demo and for simplicity, we use a dummy persister that does nothing
-    let persist = stack
-        .create_persist_with_comm_window(&crypto, DummyKvBlobStore)
-        .await
-        .unwrap();
+    // Create a KV BLOB store and load any previously saved state of `rs-matter`
+    // `SeqMapKvBlobStore` saves to a user-supplied NOR Flash region
+    // However, for this demo and for simplicity, we use a dummy KV BLOB store that does nothing
+    let mut kv = DummyKvBlobStore;
+    stack.startup(&crypto, &mut kv).await.unwrap();
+
+    // Wrap the KV BLOB store as a shared reference, so that it can be used both by `rs-matter` and the user
+    let kv = stack.create_shared_kv(kv).unwrap();
 
     // Run the Matter stack with our handler
     // Using `pin!` is completely optional, but reduces the size of the final future
@@ -175,16 +176,16 @@ async fn main(_s: Spawner) {
             EspThreadDriver::new(peripherals.IEEE802154, peripherals.BT),
             crypto.rand().unwrap(),
             ieee_eui64,
-            persist.store(),
+            &kv,
             stack,
             true, // Use a random BLE address
         ),
-        // The Matter stack needs a persister to store its state
-        &persist,
         // The crypto provider
         &crypto,
         // Our `AsyncHandler` + `AsyncMetadata` impl
         (NODE, handler),
+        // The Matter stack needs a blob store to store its state
+        &kv,
         // No user future to run
         (),
     ));

examples/esp/src/bin/light_thread_coex.rs

@@ -34,9 +34,9 @@ use rs_matter_embassy::matter::dm::devices::test::{
 };
 use rs_matter_embassy::matter::dm::devices::DEV_TYPE_ON_OFF_LIGHT;
 use rs_matter_embassy::matter::dm::{Async, Dataver, EmptyHandler, Endpoint, EpClMatcher, Node};
+use rs_matter_embassy::matter::persist::DummyKvBlobStore;
 use rs_matter_embassy::matter::utils::init::InitMaybeUninit;
 use rs_matter_embassy::matter::{clusters, devices, BasicCommData};
-use rs_matter_embassy::stack::persist::DummyKvBlobStore;
 use rs_matter_embassy::stack::rand::reseeding_csprng;
 use rs_matter_embassy::wireless::esp::EspThreadDriver;
 use rs_matter_embassy::wireless::{EmbassyThread, EmbassyThreadMatterStack};
@@ -158,13 +158,14 @@ async fn main(_s: Spawner) {
             Async(desc::DescHandler::new(Dataver::new_rand(&mut weak_rand)).adapt()),
         );
 
-    // Create the persister & load any previously saved state
-    // `EmbassyPersist`+`EmbassyKvBlobStore` saves to a user-supplied NOR Flash region
-    // However, for this demo and for simplicity, we use a dummy persister that does nothing
-    let persist = stack
-        .create_persist_with_comm_window(&crypto, DummyKvBlobStore)
-        .await
-        .unwrap();
+    // Create a KV BLOB store and load any previously saved state of `rs-matter`
+    // `SeqMapKvBlobStore` saves to a user-supplied NOR Flash region
+    // However, for this demo and for simplicity, we use a dummy KV BLOB store that does nothing
+    let mut kv = DummyKvBlobStore;
+    stack.startup(&crypto, &mut kv).await.unwrap();
+
+    // Wrap the KV BLOB store as a shared reference, so that it can be used both by `rs-matter` and the user
+    let kv = stack.create_shared_kv(kv).unwrap();
 
     // Run the Matter stack with our handler
     // Using `pin!` is completely optional, but reduces the size of the final future
@@ -176,16 +177,16 @@ async fn main(_s: Spawner) {
             EspThreadDriver::new(peripherals.IEEE802154, peripherals.BT),
             crypto.rand().unwrap(),
             ieee_eui64,
-            persist.store(),
+            &kv,
             stack,
             true, // Use a random BLE address
         ),
-        // The Matter stack needs a persister to store its state
-        &persist,
         // The crypto provider
         &crypto,
         // Our `AsyncHandler` + `AsyncMetadata` impl
         (NODE, handler),
+        // The Matter stack needs a blob store to store its state
+        &kv,
         // No user future to run
         (),
     ));

examples/esp/src/bin/light_wifi.rs

@@ -36,9 +36,9 @@ use rs_matter_embassy::matter::dm::devices::test::{
 };
 use rs_matter_embassy::matter::dm::devices::DEV_TYPE_ON_OFF_LIGHT;
 use rs_matter_embassy::matter::dm::{Async, Dataver, EmptyHandler, Endpoint, EpClMatcher, Node};
+use rs_matter_embassy::matter::persist::DummyKvBlobStore;
 use rs_matter_embassy::matter::utils::init::InitMaybeUninit;
 use rs_matter_embassy::matter::{clusters, devices};
-use rs_matter_embassy::stack::persist::DummyKvBlobStore;
 use rs_matter_embassy::stack::rand::reseeding_csprng;
 use rs_matter_embassy::wireless::esp::EspWifiDriver;
 use rs_matter_embassy::wireless::{EmbassyWifi, EmbassyWifiMatterStack};
@@ -143,13 +143,14 @@ async fn main(_s: Spawner) {
             Async(desc::DescHandler::new(Dataver::new_rand(&mut weak_rand)).adapt()),
         );
 
-    // Create the persister & load any previously saved state
-    // `EmbassyPersist`+`EmbassyKvBlobStore` saves to a user-supplied NOR Flash region
-    // However, for this demo and for simplicity, we use a dummy persister that does nothing
-    let persist = stack
-        .create_persist_with_comm_window(&crypto, DummyKvBlobStore)
-        .await
-        .unwrap();
+    // Create a KV BLOB store and load any previously saved state of `rs-matter`
+    // `SeqMapKvBlobStore` saves to a user-supplied NOR Flash region
+    // However, for this demo and for simplicity, we use a dummy KV BLOB store that does nothing
+    let mut kv = DummyKvBlobStore;
+    stack.startup(&crypto, &mut kv).await.unwrap();
+
+    // Wrap the KV BLOB store as a shared reference, so that it can be used both by `rs-matter` and the user
+    let kv = stack.create_shared_kv(kv).unwrap();
 
     // Run the Matter stack with our handler
     // Using `pin!` is completely optional, but reduces the size of the final future
@@ -163,12 +164,12 @@ async fn main(_s: Spawner) {
             true, // Use a random BLE address
             stack,
         ),
-        // The Matter stack needs a persister to store its state
-        &persist,
         // The crypto provider
         &crypto,
         // Our `AsyncHandler` + `AsyncMetadata` impl
         (NODE, handler),
+        // The Matter stack needs a blob store to store its state
+        &kv,
         // No user future to run
         (),
     ));