863 lines
25 KiB
C
863 lines
25 KiB
C
/* os_shim header files */
|
|
#include "os_types_api.h"
|
|
#include "os_utils_api.h"
|
|
|
|
/* common includes */
|
|
#include "iot_dbglog_api.h"
|
|
#include "iot_io_api.h"
|
|
#include "iot_version_api.h"
|
|
#include "iot_errno_api.h"
|
|
#include "iot_system_api.h"
|
|
#include "iot_oem_api.h"
|
|
|
|
/* smart grid internal header files */
|
|
#include "iot_sg_fr.h"
|
|
#include "iot_sg_cco_drv_api.h"
|
|
#include "iot_sg_cco_cmd.h"
|
|
#include "iot_cli_sg_api.h"
|
|
|
|
#if (IOT_SMART_GRID_ENABLE && PLC_SUPPORT_CCO_ROLE)
|
|
|
|
/* max count of mac address in a ul packet to CLI */
|
|
#define IOT_CLI_MAX_ADDR_COUNT (8)
|
|
|
|
/* default secondary node registration duration, in minute */
|
|
#define IOT_CLI_DEFAULT_SEC_NODE_REG_DUR (30)
|
|
|
|
/* defines secondary node registration time unit(1min), uint is 1s */
|
|
#define IOT_CLI_SEC_NODE_REG_TIME_UNIT_DUR (60)
|
|
|
|
typedef struct _cli_drv_data {
|
|
/* current meter reading power meter */
|
|
uint8_t cur_mr_pm[IOT_MAC_ADDR_LEN];
|
|
/* request sequence number */
|
|
uint8_t req_sn;
|
|
} cli_drv_data_t;
|
|
|
|
static cli_drv_data_t *cli_drv_data = NULL;
|
|
|
|
uint32_t cli_drv_init()
|
|
{
|
|
if (cli_drv_data) {
|
|
return 0;
|
|
}
|
|
|
|
cli_drv_data = os_mem_malloc(IOT_SMART_GRID_MID, sizeof(cli_drv_data_t));
|
|
|
|
if (!cli_drv_data) {
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void cli_drv_deinit()
|
|
{
|
|
if (cli_drv_data) {
|
|
os_mem_free(cli_drv_data);
|
|
cli_drv_data = NULL;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief iot_cli_drv_request_rt_mr_data() - request route meter reading data
|
|
* @param ul_data: request meter reading data up link
|
|
*/
|
|
static void iot_cli_drv_request_rt_mr_data(
|
|
const iot_cli_request_rt_mr_data_ul *ul_data)
|
|
{
|
|
iot_pkt_t *pkt = NULL;
|
|
uint16_t pkt_len = 0;
|
|
iot_cli_request_rt_mr_data_ul *des_data = NULL;
|
|
|
|
pkt_len = iot_cli_sg_get_headroom_req() + sizeof(*ul_data);
|
|
pkt = iot_pkt_alloc(pkt_len, IOT_SMART_GRID_MID);
|
|
IOT_ASSERT(pkt);
|
|
|
|
/* fill response info */
|
|
des_data = (iot_cli_request_rt_mr_data_ul*)iot_pkt_reserve(pkt,
|
|
iot_cli_sg_get_headroom_req());
|
|
os_mem_cpy(des_data, ul_data, sizeof(*ul_data));
|
|
iot_cli_sg_send_data_to_cli_interface(pkt,
|
|
IOT_CLI_SG_MSG_PRT_RT_REQ_MR_DATA, IOT_CLI_SG_REQ_ID_DEFAULT);
|
|
}
|
|
|
|
/**
|
|
* @brief iot_cli_drv_run_rt_mr_data() - send packet about the route meter
|
|
* reading data
|
|
* @param req: cli request route meter reading data down link
|
|
* @param pkt: iot_pkt_t containing the cli request pkt.
|
|
* @param consumed: 0 - iot_pkt is not consumed.
|
|
* otherwise - iot_pkt is consumed.
|
|
* @return: ERR_OK: success. others: fail
|
|
*/
|
|
static uint32_t iot_cli_drv_run_rt_mr_data(
|
|
iot_cli_sg_rpt_rt_mr_data_dl *req, iot_pkt_t *pkt, uint8_t *consumed)
|
|
{
|
|
iot_sg_wl_entry_info_t node_info = { 0 };
|
|
uint8_t cco_mac[IOT_MAC_ADDR_LEN] = {0};
|
|
uint32_t result = ERR_OK;
|
|
|
|
*consumed = 0;
|
|
if (iot_sg_cco_rt_mr_get_state() != IOT_SG_CCO_RT_AMR_STATE_RUN) {
|
|
return ERR_NOT_READY;
|
|
}
|
|
|
|
if (cli_drv_data->req_sn != req->sn) {
|
|
return ERR_INVAL;
|
|
}
|
|
|
|
switch (req->read_flag) {
|
|
case SG_READ_PM_FAILED:
|
|
{
|
|
if (iot_mac_addr_cmp(cli_drv_data->cur_mr_pm, req->mac)) {
|
|
os_mem_set(cli_drv_data->cur_mr_pm, 0, IOT_MAC_ADDR_LEN);
|
|
if (0 == ++cli_drv_data->req_sn) {
|
|
cli_drv_data->req_sn = 1;
|
|
}
|
|
iot_sg_route_control(IOT_SG_CALLER_TYPE_CLI,
|
|
IOT_SG_CCO_RT_CTRL_MR_FAILED);
|
|
}
|
|
break;
|
|
}
|
|
case SG_READ_PM_SUCCEED:
|
|
{
|
|
if (iot_mac_addr_cmp(cli_drv_data->cur_mr_pm, req->mac)) {
|
|
os_mem_set(cli_drv_data->cur_mr_pm, 0, IOT_MAC_ADDR_LEN);
|
|
if (0 == ++cli_drv_data->req_sn) {
|
|
cli_drv_data->req_sn = 1;
|
|
}
|
|
iot_sg_route_control(IOT_SG_CALLER_TYPE_CLI,
|
|
IOT_SG_CCO_RT_CTRL_MR_SUCCESS);
|
|
}
|
|
break;
|
|
}
|
|
case SG_MAY_READ_PM:
|
|
{
|
|
if (!iot_mac_addr_cmp(cli_drv_data->cur_mr_pm, req->mac)) {
|
|
return ERR_INVAL;
|
|
}
|
|
|
|
if (iot_sg_get_wl_entry_info_by_mac(req->mac, &node_info)) {
|
|
/* failed to get meter info */
|
|
return ERR_NOT_EXIST;
|
|
}
|
|
|
|
if (0 == ++cli_drv_data->req_sn) {
|
|
cli_drv_data->req_sn = 1;
|
|
}
|
|
|
|
iot_sg_get_cco_mac(cco_mac);
|
|
|
|
/* update pkt to have meter reading data in its data block */
|
|
iot_pkt_set_data(pkt, req->data);
|
|
iot_pkt_set_tail(pkt, req->data + req->data_len);
|
|
|
|
result = (uint8_t)iot_sg_cco_cache_sg_mr_cmd(IOT_SG_RMT_ROUTER,
|
|
req->sn, SG_AFN_RMT_ROUTER, req->proto_type, cco_mac, req->mac, pkt,
|
|
IOT_SG_CALLER_TYPE_CLI, IOT_SG_CCO_TASK_PRIO_3,
|
|
iot_sg_cco_get_mr_timeout(IOT_SG_CALLER_TYPE_CLI,
|
|
IOT_SG_RMT_ROUTER), 1, IOT_SG_INVALID_TASK_ID, 1, 0);
|
|
if (ERR_OK == result) {
|
|
*consumed = 1;
|
|
iot_sg_cco_enable_mr(IOT_SG_CALLER_TYPE_CLI);
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
result = ERR_INVAL;
|
|
break;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* @brief iot_cli_drv_route_mr_data() - running route meter
|
|
* reading data task
|
|
* @param req: cli request route meter reading data cmd down link
|
|
* @param pkt: iot_pkt_t containing the cli request pkt.
|
|
* @return 0 - iot_pkt is not consumed.
|
|
* otherwise - iot_pkt is consumed.
|
|
*/
|
|
static uint8_t iot_cli_drv_route_mr_data(iot_cli_sg_rpt_rt_mr_data_dl *req,
|
|
iot_pkt_t *pkt)
|
|
{
|
|
iot_pkt_t *buf_pkt = NULL;
|
|
iot_cli_sg_result_t *rsp = NULL;
|
|
uint16_t rsp_len;
|
|
uint8_t consumed = 0;
|
|
|
|
/* allocate buffer for response */
|
|
rsp_len = iot_cli_sg_get_headroom_req() +
|
|
sizeof(iot_cli_sg_result_t);
|
|
buf_pkt = iot_pkt_alloc(rsp_len, IOT_SMART_GRID_MID);
|
|
IOT_ASSERT(buf_pkt);
|
|
|
|
/* fill response info */
|
|
rsp = (iot_cli_sg_result_t*)iot_pkt_reserve(buf_pkt,
|
|
iot_cli_sg_get_headroom_req());
|
|
|
|
if (!iot_sg_cco_is_ready()) {
|
|
rsp->result = ERR_BUSY;
|
|
goto end;
|
|
}
|
|
|
|
if (iot_sg_get_rt_mr_state() & IOT_SG_CALLER_TYPE_CCTT) {
|
|
rsp->result = ERR_BUSY;
|
|
goto end;
|
|
}
|
|
if (!iot_sg_cco_get_power_status()) {
|
|
rsp->result = ERR_BUSY;
|
|
goto end;
|
|
}
|
|
|
|
if (!iot_sg_cco_get_online_sta_count()) {
|
|
rsp->result = ERR_BUSY;
|
|
goto end;
|
|
}
|
|
|
|
rsp->result = ERR_OK;
|
|
switch (req->action) {
|
|
case IOT_CLI_SG_RT_START_MR_CMD:
|
|
{
|
|
/* restart : router shall restart meter reading*/
|
|
iot_sg_route_control(IOT_SG_CALLER_TYPE_CLI,
|
|
IOT_SG_CCO_RT_CTRL_RESTART);
|
|
cli_drv_data->req_sn = 1;
|
|
break;
|
|
}
|
|
case IOT_CLI_SG_RT_STOP_MR_CMD:
|
|
{
|
|
iot_sg_route_control(IOT_SG_CALLER_TYPE_CLI,
|
|
IOT_SG_CCO_RT_CTRL_MR_STOP);
|
|
cli_drv_data->req_sn = 1;
|
|
break;
|
|
}
|
|
case IOT_CLI_SG_RT_RUNNING_MR_CMD:
|
|
{
|
|
rsp->result = iot_cli_drv_run_rt_mr_data(req, pkt, &consumed);
|
|
break;
|
|
}
|
|
default:
|
|
rsp->result = ERR_INVAL;
|
|
break;
|
|
}
|
|
end:
|
|
iot_cli_sg_send_data_to_cli_interface(buf_pkt,
|
|
IOT_CLI_SG_MSG_PRT_METER, 0);
|
|
return consumed;
|
|
}
|
|
|
|
/**
|
|
* @brief cli_drv_send_router_data_change - CCo to send router change msg
|
|
* @param sn: sequence number.
|
|
* @param mission_change: 1 - meter read finished
|
|
* 2 - search meter finished
|
|
* 3 - transformer detect finished
|
|
* @param intf_type: see IOT_SG_CALLER_TYPE_XXX
|
|
|
|
*/
|
|
static void cli_drv_send_router_data_change(uint8_t sn, uint8_t mission_change,
|
|
uint8_t intf_type)
|
|
{
|
|
(void)sn;
|
|
(void)intf_type;
|
|
|
|
if (IOT_SG_CCO_RT_CHG_STOP_SEARCH_METER == mission_change) {
|
|
iot_sg_printf("%s stop search meter \n", __FUNCTION__);
|
|
} else if (IOT_SG_CCO_RT_CHG_STOP_READ_METER == mission_change) {
|
|
iot_sg_printf("%s stop meter reading \n", __FUNCTION__);
|
|
} else if (IOT_SG_CCO_RT_CHG_STOP_TSFM_DETECT == mission_change) {
|
|
iot_sg_printf("%s stop transformer detect \n", __FUNCTION__);
|
|
} else {
|
|
iot_sg_printf("%s get error mission change \n", __FUNCTION__);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief - report cctt meter data from CCO module.
|
|
* @param data: report meter data
|
|
* @param len: length of the data
|
|
* @param afn: afn for meter reading
|
|
* @param sn: concentrator cmd sn
|
|
* @param proto_type: proto type of data
|
|
* @param mac_field: address field of meter
|
|
* @param mr_result: read meter result
|
|
* @param plc_cost: time cost in PLC in 1ms
|
|
* @param mr_type: meter read type, see IOT_SG_RMT_XXX
|
|
* @param intf_type: see IOT_SG_CALLER_TYPE_XXX
|
|
* @retval: 0 -- successful case
|
|
* @retval: otherwise -- failure case
|
|
*/
|
|
static uint32_t cli_drv_rpt_meter_data_handler(uint8_t *data, uint16_t len,
|
|
uint32_t afn, uint16_t sn, uint32_t proto_type, uint8_t *mac_field,
|
|
uint8_t mr_result, uint32_t plc_cost, uint8_t mr_type, uint8_t intf_type)
|
|
{
|
|
(void)afn;
|
|
(void)sn;
|
|
(void)mac_field;
|
|
(void)mr_result;
|
|
(void)plc_cost;
|
|
(void)mr_type;
|
|
(void)intf_type;
|
|
iot_cli_sg_rpt_mr_data_ul *rsp = NULL;
|
|
iot_pkt_t *pkt = NULL;
|
|
uint16_t pkt_len;
|
|
|
|
if (NULL == data) {
|
|
len = 0;
|
|
}
|
|
|
|
pkt_len = iot_cli_sg_get_headroom_req() + sizeof(*rsp) + len;
|
|
pkt = iot_pkt_alloc(pkt_len, IOT_SMART_GRID_MID);
|
|
IOT_ASSERT(pkt);
|
|
|
|
/* fill response info */
|
|
rsp = (iot_cli_sg_rpt_mr_data_ul*)iot_pkt_reserve(pkt,
|
|
iot_cli_sg_get_headroom_req());
|
|
rsp->result = ERR_OK;
|
|
rsp->proto_type = (uint8_t)proto_type;
|
|
rsp->sn = (uint8_t)sn;
|
|
os_mem_cpy(rsp->mac, mac_field, IOT_MAC_ADDR_LEN);
|
|
rsp->datalen = len;
|
|
if (len) {
|
|
os_mem_cpy(rsp->data, data, len);
|
|
}
|
|
iot_cli_sg_send_data_to_cli_interface(pkt,
|
|
IOT_CLI_SG_MSG_PRT_METER_DATA, IOT_CLI_SG_REQ_ID_DEFAULT);
|
|
|
|
return ERR_OK;
|
|
}
|
|
|
|
/**
|
|
* @brief cli_drv_rt_req_read_meter - router request meter reading.
|
|
* @param phase: power meter phase
|
|
* @param mac: power meter mac address, little-endian
|
|
* @param index: power meter index
|
|
* @param obj_type: communication object type, see PROTO_3762_FJ_OBJ_XXX
|
|
* @param intf_type: see IOT_SG_CALLER_TYPE_XXX
|
|
*/
|
|
void cli_drv_rt_req_read_meter(uint8_t phase, uint8_t *mac,
|
|
uint16_t index, uint8_t obj_type, uint8_t intf_type)
|
|
{
|
|
(void)obj_type;
|
|
(void)intf_type;
|
|
iot_cli_request_rt_mr_data_ul dec_data = { 0 };
|
|
|
|
iot_mac_addr_cpy(dec_data.mac_addr, mac);
|
|
dec_data.phase = phase;
|
|
dec_data.node_index = index;
|
|
dec_data.sn = cli_drv_data->req_sn;
|
|
/* request read meter */
|
|
dec_data.opt_flag = IOT_SG_RT_MR_REQUEST;
|
|
iot_cli_drv_request_rt_mr_data(&dec_data);
|
|
|
|
iot_mac_addr_cpy(cli_drv_data->cur_mr_pm, mac);
|
|
return;
|
|
}
|
|
|
|
static uint8_t iot_cli_drv_read_meter_data(iot_cli_sg_rpt_mr_data_dl *req,
|
|
uint8_t req_id, iot_pkt_t *pkt)
|
|
{
|
|
iot_pkt_t *buf_pkt = NULL;
|
|
iot_cli_sg_result_t *rsp =NULL;
|
|
uint16_t rsp_len;
|
|
uint8_t cco_mac[IOT_MAC_ADDR_LEN] = {0};
|
|
uint8_t consumed = 0;
|
|
uint8_t afn = 0;
|
|
uint8_t mr_result = 0;
|
|
uint32_t mr_count = 0;
|
|
|
|
/* allocate buffer for response */
|
|
rsp_len = iot_cli_sg_get_headroom_req() +
|
|
sizeof(iot_cli_sg_result_t);
|
|
buf_pkt = iot_pkt_alloc(rsp_len, IOT_SMART_GRID_MID);
|
|
IOT_ASSERT(buf_pkt);
|
|
|
|
/* fill response info */
|
|
rsp = (iot_cli_sg_result_t*)iot_pkt_reserve(buf_pkt,
|
|
iot_cli_sg_get_headroom_req());
|
|
|
|
if (!iot_sg_cco_is_ready()) {
|
|
rsp->result = ERR_BUSY;
|
|
goto end;
|
|
}
|
|
|
|
if (!iot_sg_cco_get_power_status()) {
|
|
rsp->result = ERR_BUSY;
|
|
goto end;
|
|
}
|
|
|
|
iot_mac_addr_reverse(req->mac);
|
|
|
|
if (iot_sg_cco_get_wl_cnt() &&
|
|
(!iot_sg_cco_wl_entry_exist(req->mac))) {
|
|
/* white list is not empty, */
|
|
/* meter to be read is not in white list. */
|
|
rsp->result = ERR_INVAL;
|
|
iot_sg_printf("cli mr data inval, meter mac error \n");
|
|
goto end;
|
|
}
|
|
|
|
if (IOT_SG_RMT_CCTT_CON == req->mr_type) {
|
|
mr_result = iot_sg_cco_check_exceed_con_cnt(req->mac);
|
|
rsp->result = mr_result;
|
|
if (ERR_OK != mr_result) {
|
|
rsp->result = EXCEED_DEV_MAX_CONCURRENT_COUNT;
|
|
goto end;
|
|
}
|
|
if ((req->proto_type == PROTO_TYPE_698_45 ||
|
|
req->proto_type == PROTO_TYPE_RAW_DATA) &&
|
|
req->data_len > IOT_SG_CON_MR_MAX_69845_LEN) {
|
|
/* data type is 698.45, and length exceed max length, send NACK */
|
|
rsp->result = EXCEED_DEV_PKT_COUNT;
|
|
goto end;
|
|
}
|
|
|
|
if (req->proto_type == PROTO_TYPE_645_1997 ||
|
|
req->proto_type == PROTO_TYPE_645_2007) {
|
|
mr_count = iot_sg_cco_get_645_pkt_cnt(req->data, req->data_len);
|
|
if (0 == mr_count) {
|
|
rsp->result = ERR_INVAL;
|
|
goto end;
|
|
}
|
|
if (mr_count > IOT_SG_CON_MR_MAX_645_CNT) {
|
|
/* data type is 645, and packet exceed max count, send NACK */
|
|
rsp->result = EXCEED_DEV_PKT_COUNT;
|
|
goto end;
|
|
}
|
|
}
|
|
|
|
if (iot_sg_cco_cache_has_sg_mr_cmd(req->mac)) {
|
|
rsp->result = ERR_EXIST;
|
|
goto end;
|
|
}
|
|
|
|
afn = SG_AFN_RMT_CCTT_CON;
|
|
} else if (IOT_SG_RMT_CCTT == req->mr_type) {
|
|
if (iot_sg_cco_cache_has_sg_mr_cmd_ex(req->mac, req->sn)) {
|
|
rsp->result = ERR_INVAL;
|
|
goto end;
|
|
}
|
|
|
|
afn = SG_AFN_RMT_CCTT;
|
|
} else {
|
|
rsp->result = ERR_INVAL;
|
|
goto end;
|
|
}
|
|
|
|
iot_sg_get_cco_mac(cco_mac);
|
|
|
|
/* update pkt to have meter reading data in its data block */
|
|
iot_pkt_set_data(pkt, req->data);
|
|
iot_pkt_set_tail(pkt, req->data + req->data_len);
|
|
|
|
rsp->result = (uint8_t)iot_sg_cco_cache_sg_mr_cmd(req->mr_type,
|
|
req->sn, afn, req->proto_type, cco_mac, req->mac, pkt,
|
|
IOT_SG_CALLER_TYPE_CLI, IOT_SG_CCO_TASK_PRIO_3,
|
|
iot_sg_cco_get_mr_timeout(IOT_SG_CALLER_TYPE_CLI, req->mr_type),
|
|
1, IOT_SG_INVALID_TASK_ID, 1, 0);
|
|
if (rsp->result == ERR_OK) {
|
|
consumed = 1;
|
|
iot_sg_cco_enable_mr(IOT_SG_CALLER_TYPE_CLI);
|
|
} else {
|
|
rsp->result = ERR_INVAL;
|
|
if (IOT_SG_RMT_CCTT_CON == req->mr_type) {
|
|
rsp->result = EXCEED_DEV_MAX_CONCURRENT_COUNT;
|
|
}
|
|
}
|
|
|
|
end:
|
|
iot_cli_sg_send_data_to_cli_interface(buf_pkt,
|
|
IOT_CLI_SG_MSG_PRT_METER, req_id);
|
|
return consumed;
|
|
}
|
|
|
|
static void iot_cli_start_get_meter_list(
|
|
iot_cli_sg_start_sec_node_reg_dl_t *data, uint8_t req_id)
|
|
{
|
|
uint32_t dur_s = 0;
|
|
iot_cli_sg_result_t *rsp;
|
|
iot_pkt_t *buf_pkt;
|
|
uint16_t rsp_len;
|
|
|
|
/* allocate buffer for response */
|
|
rsp_len = iot_cli_sg_get_headroom_req() + sizeof(iot_cli_sg_result_t);
|
|
buf_pkt = iot_pkt_alloc(rsp_len, IOT_SMART_GRID_MID);
|
|
IOT_ASSERT(buf_pkt);
|
|
|
|
/* fill response info */
|
|
rsp = (iot_cli_sg_result_t*)iot_pkt_reserve(buf_pkt,
|
|
iot_cli_sg_get_headroom_req());
|
|
if (!iot_sg_cco_get_router_sec_node_reg_allowed()) {
|
|
rsp->result = ERR_NOSUPP;
|
|
} else if (iot_sg_cco_get_tsfm_detect_status() !=
|
|
IOT_SG_CCO_TSFM_DETECT_DONE) {
|
|
rsp->result = ERR_BUSY;
|
|
} else {
|
|
if (data->duration == 0) {
|
|
data->duration = IOT_CLI_DEFAULT_SEC_NODE_REG_DUR;
|
|
}
|
|
dur_s = data->duration * IOT_CLI_SEC_NODE_REG_TIME_UNIT_DUR;
|
|
rsp->result = (uint8_t)iot_sg_start_sec_node_reg(
|
|
IOT_SG_CALLER_TYPE_CLI, dur_s, IOT_CLI_MAX_ADDR_COUNT, 1);
|
|
}
|
|
iot_cli_sg_send_data_to_cli_interface(buf_pkt,
|
|
IOT_CLI_SG_MSG_RPT_START_METER_LIST, req_id);
|
|
}
|
|
|
|
/**
|
|
* @brief: iot_cli_handle_report_ack - deal with ack data that from cli.
|
|
* @param pkt: iot_pkt is ack data form cli
|
|
* pkt is not consumed
|
|
*/
|
|
static void iot_cli_handle_report_ack(iot_pkt_t *pkt)
|
|
{
|
|
iot_cli_sg_rpt_ack_dl_t *report_ack = NULL;
|
|
uint8_t pre_sn = cli_drv_data->req_sn;
|
|
|
|
if (!pkt) {
|
|
return;
|
|
}
|
|
|
|
report_ack = (iot_cli_sg_rpt_ack_dl_t *)iot_pkt_block_ptr(pkt,
|
|
IOT_PKT_BLOCK_DATA);
|
|
|
|
iot_printf("%s get cli ack type: %d \n", __FUNCTION__, report_ack->type);
|
|
|
|
switch (report_ack->type) {
|
|
case IOT_CLI_SG_MR_DATA_RSP:
|
|
{
|
|
if (iot_sg_get_rt_mr_state() & IOT_SG_CALLER_TYPE_CLI) {
|
|
pre_sn = (0 == pre_sn ? 255 : (pre_sn - 1));
|
|
if (report_ack->sn == pre_sn) {
|
|
iot_sg_cco_recv_ack_to_report(1, report_ack->sn);
|
|
iot_sg_cco_rt_mr_result_ack(report_ack->sn);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case IOT_CLI_SG_SEC_NODE_REG_DATA_RSP:
|
|
{
|
|
iot_sg_cco_recv_ack_to_report(1, report_ack->sn);
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief: cli_drv_data_handler - handle data from CLI
|
|
* @param channel: data sources.
|
|
* @param pkt: iot_pkt containing data to be process
|
|
* @retval: 0-iot_pkt is not consumed
|
|
* @retval: otherwise iot_pkt is consumed
|
|
*/
|
|
static uint32_t cli_drv_data_handler(uint8_t channel, iot_pkt_t *pkt,
|
|
uint32_t ntb)
|
|
{
|
|
uint32_t consumed = 0;
|
|
iot_cli_sg_rpt_mr_data_dl *req;
|
|
iot_cli_sg_rpt_rt_mr_data_dl *rt_req;
|
|
iot_cli_sg_msg_header_t *hdr;
|
|
iot_cli_sg_start_sec_node_reg_dl_t *start_reg_req;
|
|
uint8_t* data_ptr = iot_pkt_block_ptr(pkt, IOT_PKT_BLOCK_DATA);
|
|
hdr = (iot_cli_sg_msg_header_t *)iot_pkt_block_ptr(pkt, IOT_PKT_BLOCK_HEAD);
|
|
|
|
(void)ntb;
|
|
(void)channel;
|
|
switch (hdr->msg_id) {
|
|
case IOT_CLI_SG_MSG_GET_METER:
|
|
{
|
|
/* handle con mr/cctt active mr */
|
|
req = (iot_cli_sg_rpt_mr_data_dl *)data_ptr;
|
|
consumed = iot_cli_drv_read_meter_data(req, hdr->req_id, pkt);
|
|
break;
|
|
}
|
|
case IOT_CLI_SG_MSG_GET_RT_METER:
|
|
{
|
|
/* handle router meter reading. */
|
|
rt_req = (iot_cli_sg_rpt_rt_mr_data_dl *)data_ptr;
|
|
consumed = iot_cli_drv_route_mr_data(rt_req, pkt);
|
|
break;
|
|
}
|
|
case IOT_CLI_SG_MSG_START_METER_LIST:
|
|
{
|
|
start_reg_req = (iot_cli_sg_start_sec_node_reg_dl_t *)data_ptr;
|
|
iot_cli_start_get_meter_list(start_reg_req, hdr->req_id);
|
|
break;
|
|
}
|
|
case IOT_CLI_SG_MSG_STOP_METER_LIST:
|
|
{
|
|
iot_sg_stop_sec_node_reg(IOT_SG_CALLER_TYPE_CLI,
|
|
IOT_SG_CCO_STOP_SEC_NODE_REG_CLI);
|
|
break;
|
|
}
|
|
case IOT_CLI_SG_MSG_GET_REPORT_ACK:
|
|
{
|
|
iot_cli_handle_report_ack(pkt);
|
|
break;
|
|
}
|
|
default:
|
|
iot_sg_printf("%s unable to handle msg id: 0n%d\n",
|
|
__FUNCTION__, hdr->msg_id);
|
|
break;
|
|
}
|
|
|
|
return consumed;
|
|
}
|
|
|
|
static uint32_t cli_drv_sec_node_info_handler(uint8_t sn, uint16_t index,
|
|
sec_node_query_t *sec_node_info)
|
|
{
|
|
iot_cli_sg_rpt_sec_node_info_ul_t *rsp = NULL;
|
|
uint16_t pkt_len = 0;
|
|
uint8_t cnt = 0, i = 0;
|
|
iot_pkt_t *pkt;
|
|
|
|
(void)index;
|
|
cnt = sec_node_info->contain_sec_node_count;
|
|
pkt_len = sizeof(*rsp) + sizeof(iot_cli_sg_sec_node_info_t) * cnt;
|
|
pkt_len += iot_cli_sg_get_headroom_req();
|
|
pkt = iot_pkt_alloc(pkt_len, IOT_SMART_GRID_MID);
|
|
if (pkt == NULL) {
|
|
return ERR_NOMEM;
|
|
}
|
|
|
|
/* fill response info */
|
|
rsp = (iot_cli_sg_rpt_sec_node_info_ul_t*)iot_pkt_reserve(pkt,
|
|
iot_cli_sg_get_headroom_req());
|
|
for (i = 0; i < sec_node_info->contain_sec_node_count; i++) {
|
|
rsp->node_info[i].proto_type =
|
|
sec_node_info->node_info[i].proto_type & 0x0F;
|
|
rsp->node_info->dev_type =
|
|
iot_sg_cco_get_node_cli_dev_type(sec_node_info->dev_type) & 0x0F;
|
|
iot_mac_addr_cpy(rsp->node_info[i].sta_mac, sec_node_info->sta_addr);
|
|
iot_mac_addr_cpy(rsp->node_info[i].meter_mac,
|
|
sec_node_info->node_info[i].mac);
|
|
}
|
|
rsp->sn = sn;
|
|
rsp->sec_node_count = 1;
|
|
rsp->rsp_sec_node_count = i;
|
|
iot_pkt_put(pkt, pkt_len - iot_cli_sg_get_headroom_req());
|
|
iot_cli_sg_send_data_to_cli_interface(pkt,
|
|
IOT_CLI_SG_MSG_PRT_SEARCH_METER_LIST, IOT_CLI_SG_REQ_ID_DEFAULT);
|
|
return ERR_OK;
|
|
}
|
|
|
|
static uint32_t cli_drv_rpt_event_data_handler(uint8_t sn, uint8_t *pm_addr,
|
|
uint8_t dev_type, uint32_t proto_type, uint8_t evt_type,
|
|
uint8_t *data, uint16_t len)
|
|
{
|
|
(void)sn;
|
|
(void)pm_addr;
|
|
(void)dev_type;
|
|
(void)proto_type;
|
|
(void)evt_type;
|
|
(void)data;
|
|
(void)len;
|
|
|
|
return ERR_OK;
|
|
}
|
|
|
|
static uint32_t cli_drv_rpt_topo_handler(
|
|
uint8_t req_id, iot_plc_nw_topo_rpt_t *rpt)
|
|
{
|
|
(void)rpt;
|
|
(void)req_id;
|
|
|
|
return ERR_OK;
|
|
}
|
|
|
|
static uint32_t cli_drv_rpt_neighbor_net_handler(uint8_t req_id,
|
|
iot_sg_nb_nw_rpt_t *req)
|
|
{
|
|
(void)req_id;
|
|
(void)req;
|
|
|
|
return ERR_OK;
|
|
}
|
|
|
|
static uint32_t cli_drv_rpt_freq_band_handler(uint8_t req_id,
|
|
iot_plc_freq_band_info_query_rpt_t *req)
|
|
{
|
|
(void)req_id;
|
|
(void)req;
|
|
|
|
return ERR_OK;
|
|
}
|
|
|
|
static uint32_t cli_drv_rpt_freq_band_set_result_handler(uint8_t req_id,
|
|
uint8_t result)
|
|
{
|
|
(void)result;
|
|
(void)req_id;
|
|
|
|
return ERR_OK;
|
|
}
|
|
|
|
static uint32_t cli_drv_rpt_rf_channel_set_result_handler(uint8_t req_id,
|
|
uint8_t result)
|
|
{
|
|
(void)result;
|
|
(void)req_id;
|
|
|
|
return ERR_OK;
|
|
}
|
|
|
|
static uint32_t cli_drv_rpt_tx_power_set_result_handler(uint8_t req_id,
|
|
uint8_t result)
|
|
{
|
|
(void)result;
|
|
(void)req_id;
|
|
|
|
return ERR_OK;
|
|
}
|
|
|
|
static void cli_drv_rpt_nw_info_handler(uint8_t req_id,
|
|
iot_plc_nw_info_query_rpt_t *rpt)
|
|
{
|
|
(void)req_id;
|
|
(void)rpt;
|
|
}
|
|
|
|
static void cli_drv_timer_handler()
|
|
{
|
|
|
|
}
|
|
|
|
static void cli_drv_log_to_flash_timer_handler()
|
|
{
|
|
|
|
}
|
|
|
|
static uint8_t cli_drv_sta_state_chg_handler(uint8_t state, uint8_t *sta_mac)
|
|
{
|
|
(void)sta_mac;
|
|
(void)state;
|
|
return 0;
|
|
}
|
|
|
|
static void cli_drv_rpt_tsfm_detect_ret_handler(uint8_t *pm_mac,
|
|
uint8_t *tsfm_addr, uint8_t tsfm_status, uint8_t dev_type)
|
|
{
|
|
(void)pm_mac;
|
|
(void)tsfm_addr;
|
|
(void)tsfm_status;
|
|
(void)dev_type;
|
|
}
|
|
|
|
static uint8_t cli_drv_mr_data_valid_handler(uint8_t mr_type, uint8_t *pm_addr)
|
|
{
|
|
(void)pm_addr;
|
|
(void)mr_type;
|
|
|
|
return 1;
|
|
}
|
|
|
|
static void cli_drv_tsfm_detect_done_handler(uint8_t tsfm_is_timeout)
|
|
{
|
|
(void)tsfm_is_timeout;
|
|
}
|
|
|
|
static void cli_drv_rpt_reject_join_handler(iot_plc_sta_join_rejected_t *node)
|
|
{
|
|
(void)node;
|
|
}
|
|
|
|
static void cli_drv_cco_state_chg_handler(uint8_t curr_state, uint8_t next_state,
|
|
uint8_t *cert_flag_chg)
|
|
{
|
|
(void)curr_state;
|
|
(void)next_state;
|
|
(void)cert_flag_chg;
|
|
}
|
|
|
|
static void cli_drv_rpt_node_info_handler(uint8_t req_id,
|
|
iot_plc_node_info_rpt_t *rpt)
|
|
{
|
|
(void)req_id;
|
|
(void)rpt;
|
|
}
|
|
|
|
static uint32_t cli_drv_data_to_cctt_handler(iot_pkt_t *pkt)
|
|
{
|
|
iot_pkt_free(pkt);
|
|
return ERR_OK;
|
|
}
|
|
|
|
static void cli_drv_nw_fmt_done_handler(void)
|
|
{
|
|
|
|
}
|
|
|
|
static void cli_drv_handle_node_state_chg_rpt(uint8_t sn,
|
|
sec_node_state_chg_t *node_chg)
|
|
{
|
|
(void)sn;
|
|
(void)node_chg;
|
|
}
|
|
|
|
static void cli_drv_neighbor_dev_rpt(uint8_t req_id,
|
|
iot_plc_neighbor_dev_rpt_t *rpt)
|
|
{
|
|
(void)req_id;
|
|
(void)rpt;
|
|
}
|
|
|
|
static void cli_drv_cco_info_rpt(uint8_t req_id, iot_sg_cco_info_rpt_t *rpt)
|
|
{
|
|
(void)req_id;
|
|
(void)rpt;
|
|
}
|
|
|
|
static void cli_drv_bcast_result_rpt(uint8_t done)
|
|
{
|
|
(void)done;
|
|
}
|
|
|
|
iot_sg_cco_drv_t iot_sg_cli_drv = {
|
|
.drv_id = IOT_SG_CCTT_DRV_ID_CLI,
|
|
.init = cli_drv_init,
|
|
.deinit = cli_drv_deinit,
|
|
.data_type_mask = 0xFFFF,
|
|
.headroom = 0,
|
|
.meter_data_report_cb = cli_drv_rpt_meter_data_handler,
|
|
.event_data_report_cb = cli_drv_rpt_event_data_handler,
|
|
.sec_node_report_cb = cli_drv_sec_node_info_handler,
|
|
.topo_report_cb = cli_drv_rpt_topo_handler,
|
|
.neighbour_net_report_cb = cli_drv_rpt_neighbor_net_handler,
|
|
.freq_band_report_cb = cli_drv_rpt_freq_band_handler,
|
|
.freq_band_set_result_report_cb = cli_drv_rpt_freq_band_set_result_handler,
|
|
.rf_channel_set_result_report_cb = cli_drv_rpt_rf_channel_set_result_handler,
|
|
.tx_power_set_result_report_cb = cli_drv_rpt_tx_power_set_result_handler,
|
|
.nw_info_rpt_cb = cli_drv_rpt_nw_info_handler,
|
|
.report_router_status_change = cli_drv_send_router_data_change,
|
|
.cctt_data_handler = cli_drv_data_handler,
|
|
.timer1_func = cli_drv_timer_handler,
|
|
.timer2_func = cli_drv_timer_handler,
|
|
.timer3_func = cli_drv_timer_handler,
|
|
.timer4_func = cli_drv_timer_handler,
|
|
.timer5_func = cli_drv_timer_handler,
|
|
.timer6_func = cli_drv_timer_handler,
|
|
.log_to_flash_timer_func = cli_drv_log_to_flash_timer_handler,
|
|
.sta_state_chg_cb = cli_drv_sta_state_chg_handler,
|
|
.rpt_tsfm_detect_ret_cb = cli_drv_rpt_tsfm_detect_ret_handler,
|
|
.cco_status_chg_cb = cli_drv_cco_state_chg_handler,
|
|
.mr_data_valid_cb = cli_drv_mr_data_valid_handler,
|
|
.node_info_rpt_cb = cli_drv_rpt_node_info_handler,
|
|
.rt_request_mr_cb = cli_drv_rt_req_read_meter,
|
|
.tsfm_detect_done_cb = cli_drv_tsfm_detect_done_handler,
|
|
.reject_join_cb = cli_drv_rpt_reject_join_handler,
|
|
.passthrough_to_cctt_cb = cli_drv_data_to_cctt_handler,
|
|
.nw_fmt_done_cb = cli_drv_nw_fmt_done_handler,
|
|
.node_state_chg_cb = cli_drv_handle_node_state_chg_rpt,
|
|
.neighbor_dev_report_cb = cli_drv_neighbor_dev_rpt,
|
|
.cco_info_report_cb = cli_drv_cco_info_rpt,
|
|
.cco_rpt_bcast_result_cb = cli_drv_bcast_result_rpt,
|
|
};
|
|
|
|
#endif /* IOT_SMART_GRID_ENABLE && PLC_SUPPORT_CCO_ROLE */
|
|
|