RE: NRF connect: 2.6.1 zigbee - Binding OnOff cluster via Home assistant - how to send 'on' command?

Edvin — Fri, 05 Jul 2024 22:37:00 GMT

Hello,

I am sorry, but I am not able to decrypt your trace without the network key.

I see that there are some packets from 0x2727 to destination 0x0000 later, such as 288, but I am not able to tell what it is (without decrypting).

You may not want to upload your network key in a public ticket. I suggest that you create a private ticket, where you can link to this ticket, where you upload your trace and your network key, so that we can have a look.

Best regards,

Edvin

RE: NRF connect: 2.6.1 zigbee - Binding OnOff cluster via Home assistant - how to send 'on' command?

Joeri_ — Fri, 05 Jul 2024 20:58:34 GMT

Hi Edvin,

I assumed that the sniffers showed every message send over the network.
I just tried again:

Use Zigbee2mqtt in HomeAssistant I first bound endpoint 11 with OnOff attribute to the coördinator. After that I bound it to a light bulb. You can see the wireshark log when binding to the coördinator.

those messages I see. My device is '0x2727'.

Further there are no messages from or to my device regarding the onOff attribute.

RE: NRF connect: 2.6.1 zigbee - Binding OnOff cluster via Home assistant - how to send 'on' command?

Edvin — Fri, 05 Jul 2024 20:31:04 GMT

Hello,

[quote user="Joeri_"]Here is the snippet I used to set the attribute, and also the rest of the code. My zigbee sniffer shows no signal after setting the attribute.[/quote]

Did you bind the attribute to your coordinator before capturing the sniffer trace? If not, then the device has nowhere to send the update, so in that case, I don't think you will see it in a sniffer trace.

Best regards,

Edvin

RE: NRF connect: 2.6.1 zigbee - Binding OnOff cluster via Home assistant - how to send 'on' command?

Joeri_ — Thu, 04 Jul 2024 09:23:21 GMT

Hello Edvin,

Thank you for the reply. I find it awesome that I got a notification that "an engineer had been assigned".

Unfortunatelu I have not found out how to make your suggestion work.

Here is the snippet I used to set the attribute, and also the rest of the code. My zigbee sniffer shows no signal after setting the attribute.

void light_switch_send_on_off(int onOff)
{
	if(onOff){LOG_INF("Send on command:");}
	else{LOG_INF("send off command:");}
	

	ZB_ZCL_SET_ATTRIBUTE(
		ON_OFF_SWITCH_ENDPOINT,
		ZB_ZCL_CLUSTER_ID_ON_OFF,
		ZB_ZCL_CLUSTER_ANY_ROLE,
		ZB_ZCL_ATTR_ON_OFF_ON_OFF_ID,
		onOff,
		false);
}

/*
 * Copyright (c) 2021 Nordic Semiconductor ASA
 *
 * SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
 */

/** @file
 *
 * @brief Zigbee application template.
 */

#include <zephyr/kernel.h>
#include <zephyr/logging/log.h>
#include <dk_buttons_and_leds.h>

#include <zboss_api.h>
#include <zboss_api_addons.h>
#include <zigbee/zigbee_error_handler.h>
#include <zigbee/zigbee_app_utils.h>
#include <zigbee/zigbee_zcl_scenes.h>
#include <zb_nrf_platform.h>
#include "zb_range_extender.h"
#include <stdio.h>
#include <zboss_api_aps.h>
#include <zb_zcl_common.h>

/* Device endpoint, used to receive ZCL commands. */
#define APP_TEMPLATE_ENDPOINT 10

/* Device endpoint, used for on/off switch. */
#define ON_OFF_SWITCH_ENDPOINT 11

/* Version of the application software (1 byte). */
#define REMOTE_INIT_BASIC_APP_VERSION 01

/* Version of the implementation of the Zigbee stack (1 byte). */
#define REMOTE_INIT_BASIC_STACK_VERSION 10

/* Version of the hardware of the device (1 byte). */
#define REMOTE_INIT_BASIC_HW_VERSION 11

/* Manufacturer name (32 bytes). */
#define REMOTE_INIT_BASIC_MANUF_NAME "DIY"

/* Model number assigned by manufacturer (32-bytes long string). */
#define REMOTE_INIT_BASIC_MODEL_ID "Light_Controller_v0.2"

/* First 8 bytes specify the date of manufacturer of the device
 * in ISO 8601 format (YYYYMMDD). The rest (8 bytes) are manufacturer specific.
 */
#define REMOTE_INIT_BASIC_DATE_CODE "20240629"

/* Type of power sources available for the device.
 * For possible values see section 3.2.2.2.8 of ZCL specification.
 */
#define REMOTE_INIT_BASIC_POWER_SOURCE ZB_ZCL_BASIC_POWER_SOURCE_DC_SOURCE

/* Describes the physical location of the device (16 bytes).
 * May be modified during commissioning process.
 */
#define REMOTE_INIT_BASIC_LOCATION_DESC "general"

/* Describes the type of physical environment.
 * For possible values see section 3.2.2.2.10 of ZCL specification.
 */
#define REMOTE_INIT_BASIC_PH_ENV ZB_ZCL_BASIC_ENV_UNSPECIFIED

/* LED indicating that device successfully joined Zigbee network. */
#define ZIGBEE_NETWORK_STATE_LED DK_LED3

/* LED used for device identification. */
#define IDENTIFY_LED DK_LED4

/* Button used to enter the Identify mode. */
#define IDENTIFY_MODE_BUTTON DK_BTN4_MSK

/* Button to start Factory Reset */
#define FACTORY_RESET_BUTTON IDENTIFY_MODE_BUTTON

LOG_MODULE_REGISTER(app, LOG_LEVEL_INF);

/* Main application customizable context.
 * Stores all settings and static values.
 */
struct zb_device_ctx
{
	zb_zcl_basic_attrs_ext_t basic_attr;   // Should always be there
	zb_zcl_identify_attrs_t identify_attr; // Should always be there
	zb_uint8_t on_off_switch_type_attr;	   // for this device
	zb_uint8_t on_off_switch_actions_attr; // for this device
};

/* Zigbee device application context storage. */
static struct zb_device_ctx dev_ctx;

ZB_ZCL_DECLARE_IDENTIFY_ATTRIB_LIST(
	identify_attr_list,
	&dev_ctx.identify_attr.identify_time);

ZB_ZCL_DECLARE_BASIC_ATTRIB_LIST_EXT(
	basic_attr_list,
	&dev_ctx.basic_attr.zcl_version,
	&dev_ctx.basic_attr.app_version,
	&dev_ctx.basic_attr.stack_version,
	&dev_ctx.basic_attr.hw_version,
	dev_ctx.basic_attr.mf_name,
	dev_ctx.basic_attr.model_id,
	dev_ctx.basic_attr.date_code,
	&dev_ctx.basic_attr.power_source,
	dev_ctx.basic_attr.location_id,
	&dev_ctx.basic_attr.ph_env,
	dev_ctx.basic_attr.sw_ver);

ZB_ZCL_DECLARE_ON_OFF_SWITCH_CONFIGURATION_ATTRIB_LIST(
	on_off_switch_attr_list,
	&dev_ctx.on_off_switch_type_attr,
	&dev_ctx.on_off_switch_actions_attr);

ZB_HA_DECLARE_ON_OFF_SWITCH_CLUSTER_LIST(
	on_off_switch_clusters,
	on_off_switch_attr_list,
	basic_attr_list,
	identify_attr_list);

ZB_HA_DECLARE_ON_OFF_SWITCH_EP(
	on_off_switch_ep,
	ON_OFF_SWITCH_ENDPOINT,
	on_off_switch_clusters);

ZB_DECLARE_RANGE_EXTENDER_CLUSTER_LIST(
	app_template_clusters,
	basic_attr_list,
	identify_attr_list);

ZB_DECLARE_RANGE_EXTENDER_EP(
	app_template_ep,
	APP_TEMPLATE_ENDPOINT,
	app_template_clusters);

ZBOSS_DECLARE_DEVICE_CTX_2_EP( // This is a macro to declare 2 endpoints
	app_template_ctx,
	on_off_switch_ep,
	app_template_ep);

/**@brief Function for initializing all clusters attributes. */
static void app_clusters_attr_init(void)
{
	/* Basic cluster attributes data */
	dev_ctx.basic_attr.zcl_version = ZB_ZCL_VERSION;
	dev_ctx.basic_attr.app_version = REMOTE_INIT_BASIC_APP_VERSION;
	dev_ctx.basic_attr.stack_version = REMOTE_INIT_BASIC_STACK_VERSION;
	dev_ctx.basic_attr.hw_version = REMOTE_INIT_BASIC_HW_VERSION;

	/* Use ZB_ZCL_SET_STRING_VAL to set strings, because the first byte
	 * should contain string length without trailing zero.
	 *
	 * For example "test" string will be encoded as:
	 *   [(0x4), 't', 'e', 's', 't']
	 */
	ZB_ZCL_SET_STRING_VAL(
		dev_ctx.basic_attr.mf_name,
		REMOTE_INIT_BASIC_MANUF_NAME,
		ZB_ZCL_STRING_CONST_SIZE(REMOTE_INIT_BASIC_MANUF_NAME));

	ZB_ZCL_SET_STRING_VAL(
		dev_ctx.basic_attr.model_id,
		REMOTE_INIT_BASIC_MODEL_ID,
		ZB_ZCL_STRING_CONST_SIZE(REMOTE_INIT_BASIC_MODEL_ID));

	ZB_ZCL_SET_STRING_VAL(
		dev_ctx.basic_attr.date_code,
		REMOTE_INIT_BASIC_DATE_CODE,
		ZB_ZCL_STRING_CONST_SIZE(REMOTE_INIT_BASIC_DATE_CODE));

	dev_ctx.basic_attr.power_source = REMOTE_INIT_BASIC_POWER_SOURCE;

	ZB_ZCL_SET_STRING_VAL(
		dev_ctx.basic_attr.location_id,
		REMOTE_INIT_BASIC_LOCATION_DESC,
		ZB_ZCL_STRING_CONST_SIZE(REMOTE_INIT_BASIC_LOCATION_DESC));

	dev_ctx.basic_attr.ph_env = REMOTE_INIT_BASIC_PH_ENV;

	/* Identify cluster attributes data. */
	dev_ctx.identify_attr.identify_time =
		ZB_ZCL_IDENTIFY_IDENTIFY_TIME_DEFAULT_VALUE;
}

/**@brief Function for sending ON/OFF requests to the binded light bulb.
 *
 * 
 */
void light_switch_send_on_off()
{
	LOG_INF("Send OFF command:");

	ZB_ZCL_SET_ATTRIBUTE(
		ON_OFF_SWITCH_ENDPOINT,
		ZB_ZCL_CLUSTER_ID_ON_OFF,
		ZB_ZCL_CLUSTER_ANY_ROLE,
		ZB_ZCL_ATTR_ON_OFF_ON_OFF_ID,
		ZB_ZCL_ON_OFF_IS_OFF,
		true);

			ZB_ZCL_SET_ATTRIBUTE(
		ON_OFF_SWITCH_ENDPOINT,
		ZB_ZCL_CLUSTER_ID_ON_OFF,
		ZB_ZCL_CLUSTER_ANY_ROLE,
		ZB_ZCL_ATTR_ON_OFF_ON_OFF_ID,
		ZB_ZCL_ON_OFF_IS_ON,
		true);
}


/**@brief Function to toggle the identify LED
 *
 * @param  bufid  Unused parameter, required by ZBOSS scheduler API.
 */
static void toggle_identify_led(zb_bufid_t bufid)
{
	static int blink_status;

	dk_set_led(IDENTIFY_LED, (++blink_status) % 2);
	ZB_SCHEDULE_APP_ALARM(toggle_identify_led, bufid, ZB_MILLISECONDS_TO_BEACON_INTERVAL(100));
	
}

/**@brief Function to handle identify notification events on the first endpoint.
 *
 * @param  bufid  Unused parameter, required by ZBOSS scheduler API.
 */
static void identify_cb(zb_bufid_t bufid)
{
	zb_ret_t zb_err_code;

	if (bufid)
	{
		/* Schedule a self-scheduling function that will toggle the LED */
		ZB_SCHEDULE_APP_CALLBACK(toggle_identify_led, bufid);
	}
	else
	{
		/* Cancel the toggling function alarm and turn off LED */
		zb_err_code = ZB_SCHEDULE_APP_ALARM_CANCEL(toggle_identify_led, ZB_ALARM_ANY_PARAM);
		ZVUNUSED(zb_err_code);

		dk_set_led(IDENTIFY_LED, 0);
	}
}

/**@brief Starts identifying the device.
 *
 * @param  bufid  Unused parameter, required by ZBOSS scheduler API.
 */
static void start_identifying(zb_bufid_t bufid)
{
	ZVUNUSED(bufid);

	if (ZB_JOINED())
	{
		/* Check if endpoint is in identifying mode,
		 * if not put desired endpoint in identifying mode.
		 */
		if (dev_ctx.identify_attr.identify_time ==
			ZB_ZCL_IDENTIFY_IDENTIFY_TIME_DEFAULT_VALUE)
		{

			zb_ret_t zb_err_code = zb_bdb_finding_binding_target(
				APP_TEMPLATE_ENDPOINT);

			if (zb_err_code == RET_OK)
			{
				LOG_INF("Enter identify mode");
			}
			else if (zb_err_code == RET_INVALID_STATE)
			{
				LOG_WRN("RET_INVALID_STATE - Cannot enter identify mode");
			}
			else
			{
				ZB_ERROR_CHECK(zb_err_code);
			}
		}
		else
		{
			LOG_INF("Cancel identify mode");
			zb_bdb_finding_binding_target_cancel();
		}
	}
	else
	{
		LOG_WRN("Device not in a network - cannot enter identify mode");
	}
}

/**@brief Callback for button events.
 *
 * @param[in]   button_state  Bitmask containing buttons state.
 * @param[in]   has_changed   Bitmask containing buttons
 *                            that have changed their state.
 */
static void button_changed(uint32_t button_state, uint32_t has_changed)
{
	if (IDENTIFY_MODE_BUTTON & has_changed)
	{
		light_switch_send_on_off();
		if (IDENTIFY_MODE_BUTTON & button_state)
		{
			/* Button changed its state to pressed */
		}
		else
		{
			/* Button changed its state to released */
			if (was_factory_reset_done())
			{
				/* The long press was for Factory Reset */
				LOG_DBG("After Factory Reset - ignore button release");
			}
			else
			{
				/* Button released before Factory Reset */

				/* Start identification mode */
				ZB_SCHEDULE_APP_CALLBACK(start_identifying, 0);
			}
		}
	}

	check_factory_reset_button(button_state, has_changed);
}

/**@brief Function for initializing LEDs and Buttons. */
static void configure_gpio(void)
{
	int err;

	err = dk_buttons_init(button_changed);
	if (err)
	{
		LOG_ERR("Cannot init buttons (err: %d)", err);
	}

	err = dk_leds_init();
	if (err)
	{
		LOG_ERR("Cannot init LEDs (err: %d)", err);
	}
}

/**@brief Zigbee stack event handler.
 *
 * @param[in]   bufid   Reference to the Zigbee stack buffer
 *                      used to pass signal.
 */
void zboss_signal_handler(zb_bufid_t bufid)
{
	/* Update network status LED. */
	zigbee_led_status_update(bufid, ZIGBEE_NETWORK_STATE_LED);

	/* No application-specific behavior is required.
	 * Call default signal handler.
	 */
	ZB_ERROR_CHECK(zigbee_default_signal_handler(bufid));

	/* All callbacks should either reuse or free passed buffers.
	 * If bufid == 0, the buffer is invalid (not passed).
	 */
	if (bufid)
	{
		zb_buf_free(bufid);
	}
}

void print_ieee_addr(zb_ieee_addr_t addr)
{
	for (int i = 0; i < 8; i++)
	{
		printf("%02X", addr[i]);
		if (i < 7)
			printf(":");
	}
}

static void GetBindingTable(void)
{ // hierdoor crasht alles. dus nog niet de oplossing
	// So far this seems to be needed to controll a device that is binded through Home Assistant.
	// But outside a shell command this function seems unavailabe.
	// ZB_NVRAM_APS_BINDING_DATA Binding data wordt opgeslagen in de zb_nvram

	zb_zdo_binding_table_record_t buffer;
	// zb_nvram_read_data(1, ZB_NVRAM_APS_BINDING_DATA, buffer,1000 );
	zb_ret_t ret;
	ret = zb_nvram_read_data(1, ZB_NVRAM_APS_BINDING_DATA, (zb_uint8_t *)&buffer, 200);

	if (ret == 0)
	{ // Assuming 0 is success
		printf("Source Address: ");
		print_ieee_addr(buffer.src_address);
		printf("\n");

		printf("Source Endpoint: %d\n", buffer.src_endp);
		printf("Cluster ID: 0x%04X\n", buffer.cluster_id);
		printf("Destination Address Mode: %d\n", buffer.dst_addr_mode);

		printf("Destination Address: ");
		if (buffer.dst_addr_mode == 2)
		{ // Assuming 2 means IEEE address
			print_ieee_addr(buffer.dst_address.addr_long);
		}
		else
		{
			printf("0x%04X", buffer.dst_address.addr_short);
		}
		printf("\n");

		if (buffer.dst_addr_mode == 2)
		{ // Only if 64-bit extended address
			printf("Destination Endpoint: %d\n", buffer.dst_endp);
		}
	}
	else
	{
		printf("Failed to read data from NVRAM\n");
	}
}



int main(void)
{
	LOG_INF("Starting Zigbee application template example");

	/* Initialize */
	configure_gpio();
	register_factory_reset_button(FACTORY_RESET_BUTTON);

	/* Register device context (endpoints). */
	ZB_AF_REGISTER_DEVICE_CTX(&app_template_ctx);

	app_clusters_attr_init();

	/* Register handlers to identify notifications */
	ZB_AF_SET_IDENTIFY_NOTIFICATION_HANDLER(APP_TEMPLATE_ENDPOINT, identify_cb);

	/* Start Zigbee default thread */
	zigbee_enable();

	LOG_INF("Zigbee application template started");


	

	return 0;
}

RE: NRF connect: 2.6.1 zigbee - Binding OnOff cluster via Home assistant - how to send 'on' command?

Edvin — Wed, 03 Jul 2024 13:42:27 GMT

Hello,

Sorry for the late reply.

Please see this ticket:

Trying to send from a switch to a coordinator

Try using ZB_ZCL_SET_ATTRIBUTE instead of ZB_ZCL_ON_OFF_SEND_REQ(). Then you can bind the cluster to the coordinator (from the coordinator side), and I believe that is it. Give it a go and let me know if it works.

Best regards,

Edvin