Enabled the Sleepy End Device API , but cannot be able to commission the device

RE: Enabled the Sleepy End Device API , but cannot be able to commission the device

Franshee — Mon, 27 Feb 2023 04:47:47 GMT

1. What I'm trying to do is set a matter device as a sleepy end device, my device as in I'm using a nrf52840dk as my matter device.

Also, I am using nrf connect sdk v2.1.1, visual studio IDE

I choose the template sample and followed the steps in the documentation to make the device work as a temperature sensor which send random data. I edited the prj file to set my device as a sleepy end device "CONFIG_OPENTHREAD_MTD_SED=y".

I was able to see that my device was configured as a sleepy end device from the device log upon boot up.

But I was not able to commission the device. I changed the device type to minimal end device type and was able to commission the device. And again to sleepy end device, I couldn't commission it.

I am using a google nest hub as border router and am using the google home app to commission my device.

The log of the device after I tried commissioning is shown below;

devzone.nordicsemi.com/.../terminal_5F00_output_5F00_2023_2D00_03_2D00_02T12_2D00_10_2D00_04.360Z.txt

2. Yes I have read all the documentation pertaining to this.

3. My configuration looks like:

- Phone: Redmi

- Android version: 11

- Home App version: 2.63.1.12 (using in public preview mode)

- BR: google nest hub(v47.9.4.447810048)

- Chromecast version: v1.56.324896

- There are no other things in the network currently.

Thank you for your time in advance.

EDIT: I would also like to add i tried to commission the light switch sample in which it is configured as sleepy end device and couldnt do so. Is there anything else to do other than set the device type as sleepy end device? Please help

RE: Enabled the Sleepy End Device API , but cannot be able to commission the device

AHaug — Fri, 24 Feb 2023 09:14:47 GMT

Hi,

Can you explain what you're trying to do?
Have you seen this guide written by one of our Matter developers? Matter: Testing the nRF Connect platform with Apple, Google and Samsung ecosystems Here you may see how to use our Matter samples in a Google Ecosystem and I recommend you to read and to follow this guide when testing our samples in a commercial Matter ecosystem.
In addition, since you're using the Matter template, did you follow the documentation for how to use the sample https://developer.nordicsemi.com/nRF_Connect_SDK/doc/latest/nrf/samples/matter/template/README.html?
Did you see how to customize the sample? developer.nordicsemi.com/.../adding_clusters.html
In addition, I would like to recommend you to use the insert code functionality on Devzone when pasting code or to upload the project in a .zip instead of pasting the raw text directly in a reply
Can you answer how what your configuration looks like?
1. Phone?
2. Android version?
3. Home App Version?
4. What hub/OpenThread router are you using?
5. Software Version?
6. Chromecast firmware version?
7. Other things in your network?
Can you answer the other questions I started with as well?

Kind regards,
Andreas

RE: Enabled the Sleepy End Device API , but cannot be able to commission the device

Franshee — Fri, 24 Feb 2023 03:57:30 GMT

This is the firmware I have flashed into the device and couldn't be able to commission through Google Home Assistant.

* SPDX-License-Identifier: LicenseRef-Nordic-5-Clause

#include "app_task.h"

#include "app_config.h"

#include "led_util.h"

#ifdef CONFIG_NET_L2_OPENTHREAD

#include "thread_util.h"

#endif

#include <platform/CHIPDeviceLayer.h>

#include "board_util.h"

#include <app/server/OnboardingCodesUtil.h>

#include <app/server/Server.h>

#include <credentials/DeviceAttestationCredsProvider.h>

#include <credentials/examples/DeviceAttestationCredsExample.h>

#include <lib/support/CHIPMem.h>

#include <lib/support/CodeUtils.h>

#include <system/SystemError.h>

#ifdef CONFIG_CHIP_WIFI

#include <app/clusters/network-commissioning/network-commissioning.h>

#include <platform/nrfconnect/wifi/NrfWiFiDriver.h>

#endif

#ifdef CONFIG_CHIP_OTA_REQUESTOR

#include "ota_util.h"

#endif

#include <dk_buttons_and_leds.h>

#include <zephyr/logging/log.h>

#include <zephyr/zephyr.h>

#include <zephyr.h>

#include <device.h>

#include <drivers/gpio.h>

#include <sys/util.h>

#include <sys/printk.h>

#include <inttypes.h>

#include <app-common/zap-generated/attribute-id.h>

#include <app-common/zap-generated/attribute-type.h>

#include <app-common/zap-generated/attributes/Accessors.h>

#include <app-common/zap-generated/cluster-id.h>

#include <zephyr/pm/pm.h>

#include <zephyr/pm/device.h>

#include <zephyr/pm/policy.h>

#include <soc.h>

#include <hal/nrf_gpio.h>

* Get button configuration from the devicetree sw0 alias. This is mandatory.

#define SENSOR_NODE DT_ALIAS(senpin) //button 1

#if !DT_NODE_HAS_STATUS(SENSOR_NODE, okay)

#error "Unsupported board: sw0 devicetree alias is not defined"

#endif

#define LED_NODE DT_ALIAS(led1) //led2

#if !DT_NODE_HAS_STATUS(LED_NODE, okay)

#error "Unsupported board: led devicetree alias is not defined"

#endif

static const struct gpio_dt_spec sensor_det = GPIO_DT_SPEC_GET(SENSOR_NODE, gpios);

static const struct gpio_dt_spec led_det = GPIO_DT_SPEC_GET(LED_NODE, gpios);

static struct gpio_callback button_cb_data;

LOG_MODULE_DECLARE(app, CONFIG_MATTER_LOG_LEVEL);

using namespace ::chip;

using namespace ::chip::app;

using namespace ::chip::Credentials;

using namespace ::chip::DeviceLayer;

namespace

{

constexpr EndpointId kSensorEndpointId_1 = 1;

constexpr size_t kAppEventQueueSize = 10;

constexpr uint32_t kFactoryResetTriggerTimeout = 6000;

K_MSGQ_DEFINE(sAppEventQueue, sizeof(AppEvent), kAppEventQueueSize, alignof(AppEvent));

k_timer sFunctionTimer;

LEDWidget sStatusLED;

#if NUMBER_OF_LEDS == 2

FactoryResetLEDsWrapper<1> sFactoryResetLEDs{ { FACTORY_RESET_SIGNAL_LED } };

#else

FactoryResetLEDsWrapper<3> sFactoryResetLEDs{ { FACTORY_RESET_SIGNAL_LED, FACTORY_RESET_SIGNAL_LED1,

FACTORY_RESET_SIGNAL_LED2 } };

#endif

bool sIsNetworkProvisioned = false;

bool sIsNetworkEnabled = false;

bool sHaveBLEConnections = false;

} /* namespace */

namespace LedConsts

{

namespace StatusLed

{

namespace Unprovisioned

{

constexpr uint32_t kOn_ms{ 100 };

constexpr uint32_t kOff_ms{ kOn_ms };

} /* namespace Unprovisioned */

namespace Provisioned

{

constexpr uint32_t kOn_ms{ 50 };

constexpr uint32_t kOff_ms{ 950 };

} /* namespace Provisioned */

} /* namespace StatusLed */

} /* namespace LedConsts */

#ifdef CONFIG_CHIP_WIFI

app::Clusters::NetworkCommissioning::Instance

sWiFiCommissioningInstance(0, &(NetworkCommissioning::NrfWiFiDriver::Instance()));

#endif

CHIP_ERROR AppTask::Init()

{

/* Initialize CHIP stack */

LOG_INF("Init CHIP stack");

CHIP_ERROR err = chip::Platform::MemoryInit();

if (err != CHIP_NO_ERROR) {

LOG_ERR("Platform::MemoryInit() failed");

return err;

}

err = PlatformMgr().InitChipStack();

if (err != CHIP_NO_ERROR) {

LOG_ERR("PlatformMgr().InitChipStack() failed");

return err;

}

#if defined(CONFIG_NET_L2_OPENTHREAD)

err = ThreadStackMgr().InitThreadStack();

if (err != CHIP_NO_ERROR) {

LOG_ERR("ThreadStackMgr().InitThreadStack() failed: %s", ErrorStr(err));

return err;

}

#ifdef CONFIG_OPENTHREAD_MTD_SED

err = ConnectivityMgr().SetThreadDeviceType(ConnectivityManager::kThreadDeviceType_SleepyEndDevice);

#elif CONFIG_OPENTHREAD_MTD

err = ConnectivityMgr().SetThreadDeviceType(ConnectivityManager::kThreadDeviceType_MinimalEndDevice);

#else

err = ConnectivityMgr().SetThreadDeviceType(ConnectivityManager::kThreadDeviceType_Router);

#endif /* CONFIG_OPENTHREAD_MTD_SED */

if (err != CHIP_NO_ERROR) {

LOG_ERR("ConnectivityMgr().SetThreadDeviceType() failed: %s", ErrorStr(err));

return err;

}

#ifdef CONFIG_OPENTHREAD_DEFAULT_TX_POWER

err = SetDefaultThreadOutputPower();

if (err != CHIP_NO_ERROR) {

LOG_ERR("Cannot set default Thread output power");

return err;

}

#endif /* CONFIG_OPENTHREAD_DEFAULT_TX_POWER */

#elif defined(CONFIG_CHIP_WIFI)

sWiFiCommissioningInstance.Init();

#else

return CHIP_ERROR_INTERNAL;

#endif /* CONFIG_NET_L2_OPENTHREAD */

/* Initialize LEDs */

LEDWidget::InitGpio();

LEDWidget::SetStateUpdateCallback(LEDStateUpdateHandler);

sStatusLED.Init(SYSTEM_STATE_LED);

UpdateStatusLED();

/* Initialize buttons */

int ret = dk_buttons_init(ButtonEventHandler);

if (ret) {

LOG_ERR("dk_buttons_init() failed");

return chip::System::MapErrorZephyr(ret);

}

/* Initialize function timer */

k_timer_init(&sFunctionTimer, &AppTask::FunctionTimerTimeoutCallback, nullptr);

k_timer_user_data_set(&sFunctionTimer, this);

ret = sensor_init();

if(ret)

{

printk("Sensor config failed\n");

return chip::System::MapErrorZephyr(ret);

}

/* Initialize CHIP server */

#if CONFIG_CHIP_FACTORY_DATA

ReturnErrorOnFailure(mFactoryDataProvider.Init());

SetDeviceInstanceInfoProvider(&mFactoryDataProvider);

SetDeviceAttestationCredentialsProvider(&mFactoryDataProvider);

SetCommissionableDataProvider(&mFactoryDataProvider);

#else

SetDeviceAttestationCredentialsProvider(Examples::GetExampleDACProvider());

#endif

static chip::CommonCaseDeviceServerInitParams initParams;

(void)initParams.InitializeStaticResourcesBeforeServerInit();

ReturnErrorOnFailure(chip::Server::GetInstance().Init(initParams));

ConfigurationMgr().LogDeviceConfig();

PrintOnboardingCodes(chip::RendezvousInformationFlags(chip::RendezvousInformationFlag::kBLE));

* Add CHIP event handler and start CHIP thread.

* Note that all the initialization code should happen prior to this point to avoid data races

* between the main and the CHIP threads.

PlatformMgr().AddEventHandler(ChipEventHandler, 0);

err = PlatformMgr().StartEventLoopTask();

if (err != CHIP_NO_ERROR) {

LOG_ERR("PlatformMgr().StartEventLoopTask() failed");

return err;

}

return CHIP_NO_ERROR;

}

CHIP_ERROR AppTask::StartApp()

{

ReturnErrorOnFailure(Init());

AppEvent event = {};

while (true) {

k_msgq_get(&sAppEventQueue, &event, K_FOREVER);

DispatchEvent(event);

}

return CHIP_NO_ERROR;

}

void AppTask::ButtonEventHandler(uint32_t buttonState, uint32_t hasChanged)

{

AppEvent button_event;

button_event.Type = AppEventType::Button;

if (FUNCTION_BUTTON_MASK & hasChanged) {

button_event.ButtonEvent.PinNo = FUNCTION_BUTTON;

button_event.ButtonEvent.Action =

static_cast<uint8_t>((FUNCTION_BUTTON_MASK & buttonState) ? AppEventType::ButtonPushed :

AppEventType::ButtonReleased);

button_event.Handler = FunctionHandler;

PostEvent(button_event);

}

void AppTask::FunctionTimerTimeoutCallback(k_timer *timer)

{

if (!timer) {

return;

}

AppEvent event;

event.Type = AppEventType::Timer;

event.TimerEvent.Context = k_timer_user_data_get(timer);

event.Handler = FunctionTimerEventHandler;

PostEvent(event);

}

void AppTask::FunctionTimerEventHandler(const AppEvent &)

{

if (Instance().mFunction == FunctionEvent::FactoryReset) {

Instance().mFunction = FunctionEvent::NoneSelected;

LOG_INF("Factory Reset triggered");

sStatusLED.Set(true);

sFactoryResetLEDs.Set(true);

chip::Server::GetInstance().ScheduleFactoryReset();

}

void AppTask::FunctionHandler(const AppEvent &event)

{

if (event.ButtonEvent.PinNo != FUNCTION_BUTTON)

return;

if (event.ButtonEvent.Action == static_cast<uint8_t>(AppEventType::ButtonPushed)) {

Instance().StartTimer(kFactoryResetTriggerTimeout);

Instance().mFunction = FunctionEvent::FactoryReset;

} else if (event.ButtonEvent.Action == static_cast<uint8_t>(AppEventType::ButtonReleased)) {

if (Instance().mFunction == FunctionEvent::FactoryReset) {

sFactoryResetLEDs.Set(false);

UpdateStatusLED();

Instance().CancelTimer();

Instance().mFunction = FunctionEvent::NoneSelected;

LOG_INF("Factory Reset has been Canceled");

}

void AppTask::LEDStateUpdateHandler(LEDWidget &ledWidget)

{

AppEvent event;

event.Type = AppEventType::UpdateLedState;

event.Handler = UpdateLedStateEventHandler;

event.UpdateLedStateEvent.LedWidget = &ledWidget;

PostEvent(event);

}

void AppTask::UpdateLedStateEventHandler(const AppEvent &event)

{

if (event.Type == AppEventType::UpdateLedState) {

event.UpdateLedStateEvent.LedWidget->UpdateState();

}

void AppTask::UpdateStatusLED()

{

/* Update the status LED.

* If IPv6 networking and service provisioned, keep the LED On constantly.

* If the system has BLE connection(s) uptill the stage above, THEN blink the LED at an even

* rate of 100ms.

* Otherwise, blink the LED for a very short time. */

if (sIsNetworkProvisioned && sIsNetworkEnabled) {

sStatusLED.Set(true);

} else if (sHaveBLEConnections) {

sStatusLED.Blink(LedConsts::StatusLed::Unprovisioned::kOn_ms,

LedConsts::StatusLed::Unprovisioned::kOff_ms);

} else {

sStatusLED.Blink(LedConsts::StatusLed::Provisioned::kOn_ms, LedConsts::StatusLed::Provisioned::kOff_ms);

}

void AppTask::ChipEventHandler(const ChipDeviceEvent *event, intptr_t /* arg */)

{

switch (event->Type) {

case DeviceEventType::kCHIPoBLEAdvertisingChange:

sHaveBLEConnections = ConnectivityMgr().NumBLEConnections() != 0;

UpdateStatusLED();

break;

#if defined(CONFIG_NET_L2_OPENTHREAD)

case DeviceEventType::kDnssdPlatformInitialized:

#if CONFIG_CHIP_OTA_REQUESTOR

InitBasicOTARequestor();

#endif /* CONFIG_CHIP_OTA_REQUESTOR */

break;

case DeviceEventType::kThreadStateChange:

sIsNetworkProvisioned = ConnectivityMgr().IsThreadProvisioned();

sIsNetworkEnabled = ConnectivityMgr().IsThreadEnabled();

#elif defined(CONFIG_CHIP_WIFI)

case DeviceEventType::kWiFiConnectivityChange:

sIsNetworkProvisioned = ConnectivityMgr().IsWiFiStationProvisioned();

sIsNetworkEnabled = ConnectivityMgr().IsWiFiStationEnabled();

#if CONFIG_CHIP_OTA_REQUESTOR

if (event->WiFiConnectivityChange.Result == kConnectivity_Established) {

InitBasicOTARequestor();

}

#endif /* CONFIG_CHIP_OTA_REQUESTOR */

#endif

UpdateStatusLED();

break;

default:

break;

}

void AppTask::CancelTimer()

{

k_timer_stop(&sFunctionTimer);

}

void AppTask::StartTimer(uint32_t timeoutInMs)

{

k_timer_start(&sFunctionTimer, K_MSEC(timeoutInMs), K_NO_WAIT);

}

void AppTask::PostEvent(const AppEvent &event)

{

if (k_msgq_put(&sAppEventQueue, &event, K_NO_WAIT) != 0) {

LOG_INF("Failed to post event to app task event queue");

}

void AppTask::DispatchEvent(const AppEvent &event)

{

if (event.Handler) {

event.Handler(event);

} else {

LOG_INF("Event received with no handler. Dropping event.");

}

void AppTask::UpdateClusterState(bool flag)

{

SystemLayer().ScheduleLambda([=] {

/* write the new on/off value */

EmberAfStatus status =

Clusters::BooleanState::Attributes::StateValue::Set(kSensorEndpointId_1, flag);

if (status != EMBER_ZCL_STATUS_SUCCESS) {

LOG_ERR("Updating BooleanState cluster failed: %x", status);

}

});

AppTask::Instance().GetClusterState();

}

void AppTask::GetClusterState()

{

SystemLayer().ScheduleLambda([=] {

/* write the new on/off value */

bool flag = false;

EmberAfStatus status =

Clusters::BooleanState::Attributes::StateValue::Get(kSensorEndpointId_1, &flag);

if (status != EMBER_ZCL_STATUS_SUCCESS) {

LOG_ERR("Updating BooleanState cluster failed: %x", status);

}

});

}

// struct pm_state_info info = {

// .state = PM_STATE_SOFT_OFF,

// .min_residency_us = 0,

// .exit_latency_us = 0

// };

// static int disable_ds_1(const struct device *dev)

// {

// ARG_UNUSED(dev);

// pm_policy_state_lock_get(PM_STATE_SOFT_OFF, PM_ALL_SUBSTATES);

// return 0;

// }

// SYS_INIT(disable_ds_1, PRE_KERNEL_2, 0);

// static void power_down()

// {

// printk("Power down\r\n");

// // pm_state_force(0u, &(struct pm_state_info){PM_STATE_SOFT_OFF, 0, 0});

// pm_state_force(0u, &info);

// k_sleep(K_SECONDS(2U));

// }

// static void prepare_wake_up()

// {

// printk("Preparing wake up\r\n");

// nrf_gpio_cfg_input(NRF_DT_GPIOS_TO_PSEL(DT_ALIAS(senpin), gpios), NRF_GPIO_PIN_PULLUP);

// nrf_gpio_cfg_sense_set(NRF_DT_GPIOS_TO_PSEL(DT_ALIAS(senpin), gpios), NRF_GPIO_PIN_SENSE_LOW);

// }

void button_pressed(const struct device *dev, struct gpio_callback *cb, uint32_t pins)

{

if(gpio_pin_get_dt(&sensor_det))

{

printk("Door Close\n");

AppTask::Instance().UpdateClusterState(true);

gpio_pin_set_dt(&led_det, false);

}

else

{

printk("Door Open\n");

AppTask::Instance().UpdateClusterState(false);

gpio_pin_set_dt(&led_det, true);

// prepare_wake_up();

// power_down();

}

int AppTask::sensor_init()

{

int ret;

if (!device_is_ready(sensor_det.port))

{

printk("Error: Device %s is not ready\n",sensor_det.port->name);

return 1;

}

ret = gpio_pin_configure_dt(&sensor_det, GPIO_INPUT); //sensor configuration

if (ret != 0)

{

printk("Failed to configure\n");

return 1;

}

ret = gpio_pin_interrupt_configure_dt(&sensor_det, GPIO_INT_EDGE_BOTH );

if (ret != 0)

{

return 1;

}

// rc = pm_device_action_run(sensor_det.port,PM_DEVICE_ACTION_SUSPEND);

// rc = pm_device_action_run(sensor_det.port,PM_DEVICE_ACTION_RESUME);

gpio_init_callback(&button_cb_data, button_pressed, BIT(sensor_det.pin));

gpio_add_callback(sensor_det.port, &button_cb_data);

// __WFI();

// printk("Entered the mode\n");

return 0;

}

RE: Enabled the Sleepy End Device API , but cannot be able to commission the device

Franshee — Fri, 24 Feb 2023 03:52:35 GMT

I am using nrf52840 board .In matter template sample ,I have enabled

err = ConnectivityMgr().SetThreadDeviceType(ConnectivityManager::kThreadDeviceType_SleepyEndDevice); I could able to build and flash the code into the device but couuldn't be able to commission the device using Google Home Assistant.

RE: Enabled the Sleepy End Device API , but cannot be able to commission the device

AHaug — Thu, 23 Feb 2023 12:49:49 GMT

Hi,

We could use some more information about your situation. Could you answer the following.

What SDK are you using?
What device are you developing for?
Are you testing a Nordic sample? If so, which sample?
Are you able to build your firmware?
Do you have any build logs?
How are you trying to commission the device? Do you follow any guides/documentation? What do you commission it with?
Are you able to log anything that indicates where in the commissioning process it fails?

Let me know about this and other relevant information regarding your project, and we will do our best to see if we can spot what is wrong.

Kind regards,
Andreas