-> The Command zdo match_desc 0xfffd 0xfffd 0xc05e 1 0 0 is Entered in the teraterm this function taking the input from those command by using argc and argv
-> our plan is to this command( zdo match_desc 0xfffd 0xfffd 0xc05e 1 0 0) is to be given in manually in the code
-> Sir how to make manually given these command in code ????
Sir Please Suggest me How to make it in this function ?
Because our plan is t o no need to enter the commands .
/**
* @brief Send match descriptor request.
*
* @code
* zdo match_desc <h:16-bit destination address>
<h:requested address/type> <h:profile ID>
<d:number of input clusters> [<h:input cluster IDs> ...]
<d:number of output clusters> [<h:output cluster IDs> ...]
[-t | --timeout <n seconds>]
*
* @endcode
*
* Send Match Descriptor Request to the `dst_addr` node that is a
* query about the `req_addr` node of the `prof_id` profile ID,
* which must have at least one of `n_input_clusters`(whose IDs are listed in `{...}`)
* or `n_output_clusters` (whose IDs are listed in `{...}`).
* The IDs can be either decimal values or hexadecimal strings.
* Set the timeout of request with `-t` of `--timeout` optional parameter.
*
* Example:
* @code
* zdo match_desc 0xfffd 0xfffd 0x0104 1 6 0
* @endcode
*
* In this example, the command sends a Match Descriptor Request to all non-sleeping
* nodes regarding all non-sleeping nodes that have 1 input cluster ON/OFF (ID 6) and 0 output clusters.
*
*/
static void cmd_zb_match_desc(nrf_cli_t const * p_cli, size_t argc, char **argv)
{
zb_zdo_match_desc_param_t * p_req;
zdo_tsn_ctx_t * p_tsn_cli;
zb_buf_t * p_buf;
uint16_t * p_cluster_list = NULL;
uint8_t len = sizeof(p_req->cluster_list);
zb_ret_t zb_err_code;
zb_bool_t use_timeout = ZB_FALSE;
zb_uint16_t timeout = ZIGBEE_CLI_MATCH_DESC_RESP_TIMEOUT;
int timeout_offset;
zb_uint16_t temp;
// We use p_cluster_list for calls to ZBOSS API but we're not using
// p_cluster_list value in any way.
UNUSED_VARIABLE(p_cluster_list);
if ((argc == 1) || (nrf_cli_help_requested(p_cli)))
{
print_usage(p_cli, argv[0],
"<h:16-bit destination address>\r\n"
"<h:requested address/type> <h:profile ID>\r\n"
"<d:number of input clusters> [<h:input cluster IDs> ...]\r\n"
"<d:number of output clusters> [<h:output cluster IDs> ...]\r\n"
"[--timeout d:number of seconds to wait for answers]\r\n");
return;
}
if (!strcmp(argv[1], "-t") || !strcmp(argv[1], "--timeout"))
{
print_error(p_cli, "Place option 'timeout' at the end of input parameters");
return;
}
if (argc < 6)
{
print_error(p_cli, "Incorrect number of arguments");
return;
}
p_buf = ZB_GET_OUT_BUF();
if (!p_buf)
{
print_error(p_cli, "Failed to execute command (buf alloc failed)");
return;
}
ZB_BUF_INITIAL_ALLOC(p_buf, sizeof(*p_req), p_req);
if (!parse_hex_u16(argv[1], &temp))
{
print_error(p_cli, "Incorrect network address");
goto error;
}
p_req->nwk_addr = temp;
if (!parse_hex_u16(argv[2], &temp))
{
print_error(p_cli, "Incorrect address of interest");
goto error;
}
p_req->addr_of_interest = temp;
if (!parse_hex_u16(argv[3], &temp))
{
print_error(p_cli, "Incorrect profile id");
goto error;
}
p_req->profile_id = temp;
// The following functions don't perform any checks on the cluster list
// assuming that the CLI isn't abused. In practice the list length is limited
// by @p NRF_CLI_ARGC_MAX which defaults to 12 arguments.
if (!sscan_uint8(argv[4], &(p_req->num_in_clusters)))
{
print_error(p_cli, "Incorrect number of input clusters");
goto error;
}
if (p_req->num_in_clusters)
{
// Allocate additional space for cluster IDs. Space for 1 one cluster ID
// is already in the structure, hence we subtract len.
ZB_BUF_ALLOC_RIGHT(p_buf,
p_req->num_in_clusters * sizeof(uint16_t) - len,
p_cluster_list);
// We have used the space, set to 0 so that space for output clusters
// is calculated correctly.
len = 0;
// Use p_req->cluster_list as destination rather that p_cluster_list which
// points to the second element.
if (!sscan_cluster_list(argv + 5, p_req->num_in_clusters, (uint16_t *)p_req->cluster_list))
{
print_error(p_cli, "Failed to parse input cluster list");
goto error;
}
}
if (!sscan_uint8(argv[5 + p_req->num_in_clusters], &(p_req->num_out_clusters)))
{
print_error(p_cli, "Incorrect number of output clusters");
goto error;
}
if (p_req->num_out_clusters)
{
ZB_BUF_ALLOC_RIGHT(p_buf,
p_req->num_out_clusters * sizeof(uint16_t) - len,
p_cluster_list);
if (!sscan_cluster_list(argv + 5 + p_req->num_in_clusters + 1,
p_req->num_out_clusters,
(uint16_t *)p_req->cluster_list + p_req->num_in_clusters))
{
print_error(p_cli, "Failed to parse output cluster list");
goto error;
}
}
// Now let's check for timeout option
timeout_offset = 6 + p_req->num_in_clusters + p_req->num_out_clusters;
if (argc == timeout_offset + 2)
{
if (!strcmp(argv[timeout_offset], "-t") || !strcmp(argv[timeout_offset], "--timeout"))
{
use_timeout = ZB_TRUE;
if (sscanf(argv[timeout_offset + 1], "%hd", &timeout) != 1)
{
/* Let's set the timeout to default in this case. */
timeout = ZIGBEE_CLI_MATCH_DESC_RESP_TIMEOUT;
nrf_cli_fprintf(p_cli, NRF_CLI_WARNING, "Could not parse the timeout value, setting to default.");
}
nrf_cli_fprintf(p_cli, NRF_CLI_NORMAL, "Timeout set to %d.\r\n", timeout);
}
}
p_tsn_cli = get_free_ctx();
if (!p_tsn_cli)
{
print_error(p_cli, "Too many ZDO transactions");
goto error;
}
p_tsn_cli->p_cli = p_cli;
p_tsn_cli->is_broadcast = ZB_NWK_IS_ADDRESS_BROADCAST(p_req->nwk_addr);
nrf_cli_fprintf(p_cli, NRF_CLI_NORMAL, "Sending %s request.\r\n", p_tsn_cli->is_broadcast ? "broadcast" : "unicast");
p_tsn_cli->tsn = zb_zdo_match_desc_req(ZB_REF_FROM_BUF(p_buf),
cmd_zb_match_desc_cb);
if (p_tsn_cli->tsn == ZB_ZDO_INVALID_TSN)
{
print_error(p_cli, "Failed to send match descriptor request");
goto error;
}
if (use_timeout || !p_tsn_cli->is_broadcast)
{
/* In case of unicast we schedule callback to merely print the 'Done' thing if the response never comes.
* The stack calls the callback function indicating the timeout only in case of broadcasts.
* In case of unicast, we can treat the command as finished either when the timeout has elapsed, or when
* the response has been received. With this in mind, we schedule the alarm with the timeout, which checks the context.
* If the context has been deleted, then it means that it has been already freed by the response reception callback.
*/
zb_err_code = ZB_SCHEDULE_ALARM(cmd_zb_match_desc_timeout,
p_tsn_cli->tsn,
timeout * ZB_TIME_ONE_SECOND);
if (zb_err_code != RET_OK)
{
print_error(p_cli, "Unable to schedule timeout timer");
invalidate_ctx(p_tsn_cli);
}
}
return;
error:
ZB_FREE_BUF(p_buf);
}
