RE: Zigbee communication failure

Marjeris Romero — Tue, 04 May 2021 20:10:17 GMT

Hi,

I am sorry I didn't come back to you on this one.

[quote user="mazis"]I have to avoid the ZCL callback because it wasn't intercepting other commands such as Set Pin Code, Clear Pin Code and Get Pin Code and others. So I switched to an Endpoint Handler which effectively intercepts all commands. [/quote]

Do you still need help registering your ZCL command handler override cb?

There is a small guide on how to intercept ZCL commands and overriding the handling of ZCL commands in the infocenter:
https://infocenter.nordicsemi.com/topic/sdk_tz_v4.1.0/using_zigbee__z_c_l.html?cp=7_3_3_4_1_8_1#process_zcl_cmd_implementing

Perhaps this will provide you with some help?

Best regards,

Marjeris

RE: Zigbee communication failure

mazis — Fri, 26 Feb 2021 13:02:34 GMT

Hello!

Yes, I have checked the door_lock_nus example. In fact I am using it as a base for my code and I have modified a lot the example.

I have to avoid the ZCL callback because it wasn't intercepting other commands such as Set Pin Code, Clear Pin Code and Get Pin Code and others. So I switched to an Endpoint Handler which effectively intercepts all commands.

Anyway, I could use the ZCL callback but I would need to add some more callbacks, for the previous commands (set, clear and get). Is there any way to add more application callbacks for other commands?

The callback code is looking something similar to this:

b_uint8_t ep_cb(zb_uint8_t param)
{
    zb_bufid_t zigbeeBuffer = param;
    zb_zcl_parsed_hdr_t *cmd_info = ZB_BUF_GET_PARAM(zigbeeBuffer, zb_zcl_parsed_hdr_t);
    zb_bool_t cmd_processed = ZB_FALSE;
    zb_uint8_t cmd_length = zb_buf_len(zigbeeBuffer);
    zb_uint8_t *payload = (zb_uint8_t*) zb_buf_begin(zigbeeBuffer);

    zb_uint8_t status = ZB_ZCL_STATUS_SUCCESS;
    //zb_bufid_t* bufferRespuesta = zb_buf_get_out();

    switch( cmd_info -> cluster_id )
    {
        case ZB_ZCL_CLUSTER_ID_DOOR_LOCK:
            if( cmd_info->is_common_command )
            {
                TRACE_MSG(TRACE_ZCL2, "Skip general command %hd", (FMT__H, cmd_info->cmd_id));
            }
            else
            {
                if (cmd_info -> cmd_direction == ZB_ZCL_FRAME_DIRECTION_TO_SRV)
                {
                    if (ZB_ZCL_PARSED_HDR_SHORT_DATA(cmd_info).source.u.short_addr == 0x0000)
                    {
                       coordinadorInfo.short_address = ZB_ZCL_PARSED_HDR_SHORT_DATA(cmd_info).source.u.short_addr;
                       coordinadorInfo.source_endpoint = ZB_ZCL_PARSED_HDR_SHORT_DATA(cmd_info).src_endpoint;
                       coordinadorInfo.destination_endpoint = ZB_ZCL_PARSED_HDR_SHORT_DATA(cmd_info).dst_endpoint;
                       coordinadorInfo.profile_id = cmd_info -> profile_id;
                    }
                    switch (cmd_info->cmd_id) {
                        case ZB_ZCL_CMD_DOOR_LOCK_LOCK_DOOR:
                            bsp_board_led_off(LED_AUXILIAR);
                            set_estado_cerradura(ZB_ZCL_ATTR_DOOR_LOCK_LOCK_STATE_LOCKED);

                            // MANDAMOS LA RESPUESTA DEL COMANDO
                            ZB_ZCL_DOOR_LOCK_SEND_LOCK_DOOR_RES(zigbeeBuffer,
                                                               coordinadorInfo.short_address,
                                                               ZB_APS_ADDR_MODE_16_ENDP_PRESENT,
                                                               coordinadorInfo.source_endpoint,
                                                               coordinadorInfo.destination_endpoint,
                                                               coordinadorInfo.profile_id,
                                                               cmd_info->seq_number,
                                                               status,
                                                               false);
                            cmd_processed = ZB_TRUE;
                            zb_buf_free(zigbeeBuffer);
                            //zb_buf_free(param);
                            // zb_buf_free(bufferRespuesta);
                            return ZB_TRUE;
                            break;

                        case ZB_ZCL_CMD_DOOR_LOCK_UNLOCK_DOOR:
                            bsp_board_led_off(LED_AUXILIAR);
                            set_estado_cerradura(ZB_ZCL_ATTR_DOOR_LOCK_LOCK_STATE_UNLOCKED);

                            // MANDAMOS LA RESPUESTA DEL COMANDO
                            ZB_ZCL_DOOR_LOCK_SEND_UNLOCK_DOOR_RES(zigbeeBuffer,
                                                                 coordinadorInfo.short_address,
                                                                 ZB_APS_ADDR_MODE_16_ENDP_PRESENT,
                                                                 coordinadorInfo.source_endpoint,
                                                                 coordinadorInfo.destination_endpoint,
                                                                 coordinadorInfo.profile_id,
                                                                 cmd_info->seq_number,
                                                                 status,
                                                                 false);
                            cmd_processed = ZB_TRUE;
                            zb_buf_free(zigbeeBuffer);
                            //zb_buf_free(param);
                            // zb_buf_free(bufferRespuesta);
                            return ZB_TRUE;
                            break;

                        case ZB_ZCL_CMD_DOOR_LOCK_SET_PIN_CODE:
                            bsp_board_led_off(LED_AUXILIAR);
                            // LEEMOS EL PAYLOAD DEL MENSAJE Y LO GUARDAMOS EN UNA CREDENCIAL TEMPORAL
                            tempCredencial.user_ID = (payload[1] << 8) + payload[0];
                            tempCredencial.user_status = payload[2];
                            tempCredencial.user_type = payload[3];
                            for (int i = 0; i < payload[4]; i++)
                            {
                                tempCredencial.pin_code = (tempCredencial.pin_code << 8) + payload[5 + i];
                            }
                            // SETEAMOS EL USUARIO QUE HEMOS LEIDO
                            set_pin_code(tempCredencial.user_ID,
                                         tempCredencial.user_status,
                                         tempCredencial.user_type,
                                         tempCredencial.pin_code);

                            // MANDAMOS LA RESPUESTA DEL COMANDO
                            ZB_ZCL_DOOR_LOCK_SET_PIN_CODE_RES(zigbeeBuffer,
                                                               coordinadorInfo.short_address,
                                                               ZB_APS_ADDR_MODE_16_ENDP_PRESENT,
                                                               coordinadorInfo.source_endpoint,
                                                               coordinadorInfo.destination_endpoint,
                                                               coordinadorInfo.profile_id,
                                                              cmd_info->seq_number,
                                                              status,
                                                              false);
                            cmd_processed = ZB_TRUE;
                            zb_buf_free(zigbeeBuffer);
                            //zb_buf_free(param);
                            // zb_buf_free(bufferRespuesta);
                            return ZB_TRUE;
                            break;

                        case ZB_ZCL_CMD_DOOR_LOCK_GET_PIN_CODE:
                            bsp_board_led_on(LED_AUXILIAR);
                            tempCredencial.user_ID = (payload[1] << 8) + payload[0];
                            tempCredencial.pin_code = get_pin_code(tempCredencial.user_ID).pin_code;
                            // FIXME: HAY QUE PROBARLO
                            // RESPONDEMOS CON ESTA FUNCION
                            ZB_ZCL_DOOR_LOCK_GET_PIN_CODE_RES(zigbeeBuffer,
                                                               coordinadorInfo.short_address,
                                                               ZB_APS_ADDR_MODE_16_ENDP_PRESENT,
                                                               coordinadorInfo.source_endpoint,
                                                               coordinadorInfo.destination_endpoint,
                                                               coordinadorInfo.profile_id,
                                                              tempCredencial.user_ID,
                                                              tempCredencial.user_status,
                                                              tempCredencial.user_type,
                                                              tempCredencial.pin_code,
                                                              false);
                            cmd_processed = ZB_TRUE;
                            zb_buf_free(zigbeeBuffer);
                            //zb_buf_free(param);
                            // zb_buf_free(bufferRespuesta);
                            return ZB_TRUE;
                            break;

                        case ZB_ZCL_CMD_DOOR_LOCK_CLEAR_PIN_CODE:
                            bsp_board_led_off(LED_AUXILIAR);
                            // LEEMOS EL PAYLOAD Y LO GUARDAMOS COMO USER_ID
                            tempCredencial.user_ID = (payload[1] << 8) + payload[0];
                            clear_pin_code(tempCredencial.user_ID);
                            ZB_ZCL_DOOR_LOCK_CLEAR_PIN_CODE_RES(zigbeeBuffer,
                                                               coordinadorInfo.short_address,
                                                               ZB_APS_ADDR_MODE_16_ENDP_PRESENT,
                                                               coordinadorInfo.source_endpoint,
                                                               coordinadorInfo.destination_endpoint,
                                                               coordinadorInfo.profile_id,
                                                                cmd_info->seq_number,
                                                                status,
                                                                false);
                            cmd_processed = ZB_TRUE;
                            zb_buf_free(zigbeeBuffer);
                            //zb_buf_free(param);
                            // zb_buf_free(bufferRespuesta);
                            return ZB_TRUE;
                            break;

                        default:
                            //TRACE_MSG(TRACE_ZCL2, "Cluster command %hd, skip it", (FMT__H, cmd_info->cmd_id));
                            break;
                    }
                }
            }
            break;

        default:
            break;
    }
    //if (cmd_processed == ZB_TRUE)
    //{
    //    zb_buf_free(zigbeeBuffer);
    //    zb_buf_free(param);
    //}
    //zb_buf_free(bufferRespuesta);
    return cmd_processed;
}

The code has a lot of commented lines because I am terribly lost and I have been testing different approaches.

Cheers!

RE: Zigbee communication failure

Marjeris Romero — Fri, 26 Feb 2021 12:48:54 GMT

Hi,

Are you implementing a door lock with the door lock server cluster on the nRF side? Have you taken a look at our BLE/Zigbee door lock example? https://infocenter.nordicsemi.com/topic/sdk_tz_v4.1.0/zigbee_multi_dynamic_door_lock_nus_example.html

See how the ZCL callback function is implemented in the example:

/**@brief Callback function for handling ZCL commands.
 *
 * @param[in]   bufid   Reference to Zigbee stack buffer used to pass received data.
 */
static zb_void_t zcl_device_cb(zb_bufid_t bufid)
{
    zb_zcl_device_callback_param_t * p_device_cb_param = ZB_BUF_GET_PARAM(bufid, zb_zcl_device_callback_param_t);

    /* Set default response value. */
    p_device_cb_param->status = RET_OK;

    switch (p_device_cb_param->device_cb_id)
    {
        case ZB_ZCL_DOOR_LOCK_UNLOCK_DOOR_CB_ID:
            set_lock_state(ZB_ZCL_ATTR_DOOR_LOCK_LOCK_STATE_UNLOCKED);
            break;

        case ZB_ZCL_DOOR_LOCK_LOCK_DOOR_CB_ID:
            set_lock_state(ZB_ZCL_ATTR_DOOR_LOCK_LOCK_STATE_LOCKED);
            break;

        default:
            p_device_cb_param->status = RET_ERROR;
            break;
    }
}

The only thing you should need to do is to intercept the command to set the status of the lock in your application, the response to the command should be send by the stack, see ZB_ZCL_DOOR_LOCK_LOCK_DOOR_CB_ID and ZB_ZCL_DOOR_LOCK_UNLOCK_DOOR_CB_ID application callbacks.

BR,

Marjeris