568 lines
20 KiB
C
568 lines
20 KiB
C
|
/****************************************************************************
|
||
|
|
|
||
|
|
Copyright(c) 2019 by Aerospace C.Power (Chongqing) Microelectronics. ALL RIGHTS RESERVED.
|
||
|
|
|
||
|
|
This Information is proprietary to Aerospace C.Power (Chongqing) Microelectronics and MAY NOT
|
||
|
|
be copied by any method or incorporated into another program without
|
||
|
|
the express written consent of Aerospace C.Power. This Information or any portion
|
||
|
|
thereof remains the property of Aerospace C.Power. The Information contained herein
|
||
|
|
is believed to be accurate and Aerospace C.Power assumes no responsibility or
|
||
|
|
liability for its use in any way and conveys no license or title under
|
||
|
|
any patent or copyright and makes no representation or warranty that this
|
||
|
|
Information is free from patent or copyright infringement.
|
||
|
|
|
||
|
|
****************************************************************************/
|
||
|
|
/* os_shim header files */
|
||
|
|
#include "os_utils_api.h"
|
||
|
|
|
||
|
|
/* iot common header files */
|
||
|
|
#include "iot_io_api.h"
|
||
|
|
#include "iot_oem_api.h"
|
||
|
|
|
||
|
|
/* smart grid internal header files */
|
||
|
|
#include "iot_sg_fr.h"
|
||
|
|
#include "iot_sg.h"
|
||
|
|
#include "proto_645.h"
|
||
|
|
#include "proto_69845.h"
|
||
|
|
#include "iot_sg_sta_ext.h"
|
||
|
|
|
||
|
|
#if (IOT_SMART_GRID_EXT_NLI_FUNC_ENABLE)
|
||
|
|
|
||
|
|
static const uint32_t nli_645_07_di_list[] = {
|
||
|
|
PROTO_645_2007_DI_I_A,
|
||
|
|
PROTO_645_2007_DI_I_N,
|
||
|
|
PROTO_645_2007_DI_TIME,
|
||
|
|
PROTO_645_2007_DI_TIME_YMD,
|
||
|
|
PROTO_645_2007_DI_TIME_HMS,
|
||
|
|
};
|
||
|
|
|
||
|
|
void iot_sg_sta_ext_nli_info_reset(void)
|
||
|
|
{
|
||
|
|
iot_sg_sta_global_t *sta_glb = p_sg_glb->desc.sta;
|
||
|
|
iot_sg_sta_ext_info_t *ext_info = &sta_glb->ext_info;
|
||
|
|
|
||
|
|
ext_info->nli_info.di_idx = 0;
|
||
|
|
ext_info->nli_info.flag_resp = 0;
|
||
|
|
ext_info->nli_info.repeat_cnt = 0;
|
||
|
|
ext_info->nli_info.state = IOT_SG_STA_EXT_NLI_STATE_IDLE;
|
||
|
|
ext_info->nli_info.timeout_cnt = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static void iot_sg_sta_ext_nli_node_reset(void)
|
||
|
|
{
|
||
|
|
uint8_t i;
|
||
|
|
iot_sg_sta_global_t *sta_glb = p_sg_glb->desc.sta;
|
||
|
|
|
||
|
|
for (i = 0; i < IOT_SG_STA_SEC_NODE_MAX; i++) {
|
||
|
|
if (sta_glb->node_list[i] != NULL) {
|
||
|
|
sta_glb->node_list[i]->nli_detected = 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static void iot_sg_sta_ext_nli_rpt_info_reset(void)
|
||
|
|
{
|
||
|
|
iot_sg_sta_ext_info_t *ext_info = &p_sg_glb->desc.sta->ext_info;
|
||
|
|
iot_sg_sta_ext_nli_evt_rpt_info_t *rpt_info = &ext_info->nli_rpt_info;
|
||
|
|
|
||
|
|
if (rpt_info->pkt) {
|
||
|
|
iot_pkt_free(rpt_info->pkt);
|
||
|
|
}
|
||
|
|
os_mem_set(rpt_info, 0, sizeof(*rpt_info));
|
||
|
|
}
|
||
|
|
|
||
|
|
void iot_sg_sta_ext_nli_reset(void)
|
||
|
|
{
|
||
|
|
iot_sg_sta_global_t *sta_glb = p_sg_glb->desc.sta;
|
||
|
|
iot_sg_sta_ext_nli_info_t *nli_info = &sta_glb->ext_info.nli_info;
|
||
|
|
|
||
|
|
nli_info->next_time = 0;
|
||
|
|
iot_sg_sta_ext_nli_node_reset();
|
||
|
|
iot_sg_sta_ext_nli_info_reset();
|
||
|
|
iot_sg_sta_ext_nli_rpt_info_reset();
|
||
|
|
}
|
||
|
|
|
||
|
|
void iot_sg_sta_ext_nl_abnormal_detect_state_set(uint8_t enable)
|
||
|
|
{
|
||
|
|
uint8_t ref;
|
||
|
|
uint16_t ticket;
|
||
|
|
iot_sg_sta_app_info_t *sta_pib = iot_sg_sta_get_rw_pib();
|
||
|
|
|
||
|
|
if (sta_pib == NULL ||
|
||
|
|
iot_sg_sta_get_user_type() != USER_TYPE_STATE_GRID_XIAN) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
iot_sg_printf("%s - %lu\n", __FUNCTION__, enable);
|
||
|
|
if (sta_pib->ext_nli_valid) {
|
||
|
|
if (sta_pib->ext_nli_en == !!enable) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
iot_pib_acquire_app_commit_ref(&ref);
|
||
|
|
sta_pib->ext_nli_en = !!enable;
|
||
|
|
sta_pib->ext_nli_valid = 1;
|
||
|
|
iot_pib_release_app_commit_ref(&ref);
|
||
|
|
iot_pib_app_commit(&ticket);
|
||
|
|
iot_sg_sta_ext_nli_reset();
|
||
|
|
}
|
||
|
|
|
||
|
|
uint8_t iot_sg_sta_ext_nl_abnormal_detect_state_get(void)
|
||
|
|
{
|
||
|
|
uint8_t ret = 0;
|
||
|
|
iot_sg_sta_app_info_t *sta_pib = iot_sg_sta_get_rw_pib();
|
||
|
|
|
||
|
|
if (iot_sg_sta_get_user_type() == USER_TYPE_STATE_GRID_XIAN) {
|
||
|
|
if (sta_pib != NULL && sta_pib->ext_nli_valid == 1) {
|
||
|
|
ret = (uint8_t)sta_pib->ext_nli_en;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
|
||
|
|
static void iot_sg_sta_ext_nli_evt_node_add(
|
||
|
|
iot_sg_sta_ext_nli_evt_data_t *data)
|
||
|
|
{
|
||
|
|
uint32_t pkt_len = 0;
|
||
|
|
iot_sg_sta_ext_info_t *ext_info = &p_sg_glb->desc.sta->ext_info;
|
||
|
|
iot_sg_sta_ext_nli_evt_rpt_info_t *rpt_info = &ext_info->nli_rpt_info;
|
||
|
|
iot_sg_sta_ext_nli_evt_data_field_t *rpt_hdr = NULL;
|
||
|
|
iot_pkt_t *pkt = NULL;
|
||
|
|
|
||
|
|
if (rpt_info->pkt == NULL) {
|
||
|
|
/* if cache pkt is null, create a pkt that can store
|
||
|
|
* IOT_STA_EXT_NLI_EVT_PKT_PM_CNT_DEFAULT nodes.
|
||
|
|
*/
|
||
|
|
pkt_len = sizeof(*rpt_hdr) +
|
||
|
|
sizeof(*data) * IOT_STA_EXT_NLI_EVT_PKT_PM_CNT_DEFAULT;
|
||
|
|
rpt_info->pkt = iot_pkt_alloc(pkt_len, IOT_SMART_GRID_MID);
|
||
|
|
if (rpt_info->pkt == NULL) {
|
||
|
|
iot_sg_printf("%s err mem 1\n", __FUNCTION__);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
rpt_hdr = (iot_sg_sta_ext_nli_evt_data_field_t *)
|
||
|
|
iot_pkt_data(rpt_info->pkt);
|
||
|
|
iot_pkt_put(rpt_info->pkt, sizeof(*rpt_hdr));
|
||
|
|
} else if (iot_pkt_tail_len(rpt_info->pkt) < sizeof(*data)) {
|
||
|
|
/* if cache pkt is lack, expand the size of the cache pkt. */
|
||
|
|
pkt = iot_pkt_alloc(iot_pkt_data_len(rpt_info->pkt)
|
||
|
|
+ sizeof(*data), IOT_SMART_GRID_MID);
|
||
|
|
if (pkt == NULL) {
|
||
|
|
iot_sg_printf("%s err mem 2\n", __FUNCTION__);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
iot_pkt_cpy(pkt, rpt_info->pkt);
|
||
|
|
iot_pkt_free(rpt_info->pkt);
|
||
|
|
rpt_info->pkt = pkt;
|
||
|
|
}
|
||
|
|
rpt_hdr = (iot_sg_sta_ext_nli_evt_data_field_t *)
|
||
|
|
iot_pkt_data(rpt_info->pkt);
|
||
|
|
rpt_hdr->rpt_cnt++;
|
||
|
|
os_mem_cpy(iot_pkt_tail(rpt_info->pkt), data, sizeof(*data));
|
||
|
|
iot_pkt_put(rpt_info->pkt, sizeof(*data));
|
||
|
|
}
|
||
|
|
|
||
|
|
void iot_sg_sta_ext_nli_evt_ack_done(void)
|
||
|
|
{
|
||
|
|
iot_sg_sta_ext_nli_rpt_info_reset();
|
||
|
|
}
|
||
|
|
|
||
|
|
uint8_t iot_sg_sta_ext_nli_seq_check(uint16_t seq)
|
||
|
|
{
|
||
|
|
iot_sg_sta_ext_info_t *ext_info = &p_sg_glb->desc.sta->ext_info;
|
||
|
|
iot_sg_sta_ext_nli_evt_rpt_info_t *rpt_info = &ext_info->nli_rpt_info;
|
||
|
|
|
||
|
|
if (rpt_info->pkt && rpt_info->seq == seq) {
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static uint32_t iot_sg_sta_ext_nli_evt_rpt_start(void)
|
||
|
|
{
|
||
|
|
uint32_t ret = ERR_OK;
|
||
|
|
iot_sg_sta_ext_info_t *ext_info = &p_sg_glb->desc.sta->ext_info;
|
||
|
|
iot_sg_sta_ext_nli_evt_rpt_info_t *rpt_info = &ext_info->nli_rpt_info;
|
||
|
|
|
||
|
|
if (rpt_info->pkt) {
|
||
|
|
iot_sg_printf("%s start\n", __FUNCTION__);
|
||
|
|
rpt_info->report_cnt = 0;
|
||
|
|
rpt_info->timeout_cnt = IOT_SG_STA_EXT_NLI_EVT_RPT_START;
|
||
|
|
rpt_info->seq = 0;
|
||
|
|
}
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
|
||
|
|
void iot_sg_sta_ext_nli_rpt_refresh(void)
|
||
|
|
{
|
||
|
|
uint32_t ret;
|
||
|
|
iot_sg_sta_global_t *sta_glb = p_sg_glb->desc.sta;
|
||
|
|
iot_sg_sta_ext_nli_evt_rpt_info_t *rpt_info =
|
||
|
|
&sta_glb->ext_info.nli_rpt_info;
|
||
|
|
|
||
|
|
if (iot_sg_sta_get_user_type() != USER_TYPE_STATE_GRID_XIAN
|
||
|
|
|| rpt_info->pkt == NULL) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (rpt_info->timeout_cnt) {
|
||
|
|
rpt_info->timeout_cnt--;
|
||
|
|
if (!rpt_info->timeout_cnt) {
|
||
|
|
if (rpt_info->report_cnt < IOT_SG_STA_EXT_NLI_REPEAT_MAX) {
|
||
|
|
ret = iot_sg_sta_report_nli_event(
|
||
|
|
(iot_sg_sta_ext_nli_evt_data_field_t *)
|
||
|
|
iot_pkt_data(rpt_info->pkt));
|
||
|
|
if (ret == ERR_OK) {
|
||
|
|
rpt_info->report_cnt++;
|
||
|
|
rpt_info->timeout_cnt = IOT_SG_STA_EXT_NLI_REPORT_TIMEOUT;
|
||
|
|
iot_sg_printf("%s nli evt rpt %luth\n", __FUNCTION__,
|
||
|
|
rpt_info->report_cnt);
|
||
|
|
} else if (ret == ERR_NOSUPP) {
|
||
|
|
iot_sg_sta_ext_nli_evt_ack_done();
|
||
|
|
iot_sg_printf("%s nli evt rpt nosuppt\n", __FUNCTION__);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
iot_sg_sta_ext_nli_evt_ack_done();
|
||
|
|
iot_sg_printf("%s nli evt rpt failed\n", __FUNCTION__);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static iot_pkt_t *iot_sg_ext_nli_69845_mr_msg_build(uint8_t *addr)
|
||
|
|
{
|
||
|
|
uint8_t i, attribute;
|
||
|
|
uint32_t get_list_req_size, oad;
|
||
|
|
iot_pkt_t *pkt = NULL, *get_list_req = NULL;
|
||
|
|
proto_69845_app_get_list_req_info_t *req = NULL;
|
||
|
|
server_addr_info_t server = {0};
|
||
|
|
iot_sg_sta_ext_nli_info_t *nli_info = &p_sg_glb->desc.sta->ext_info.nli_info;
|
||
|
|
|
||
|
|
get_list_req_size = sizeof(proto_69845_app_oad_t) * 3 + sizeof(*req);
|
||
|
|
get_list_req = iot_pkt_alloc(get_list_req_size, IOT_SMART_GRID_MID);
|
||
|
|
if (!get_list_req) {
|
||
|
|
goto out;
|
||
|
|
}
|
||
|
|
req = (proto_69845_app_get_list_req_info_t *)iot_pkt_put(get_list_req,
|
||
|
|
get_list_req_size);
|
||
|
|
req->type = PROTO_69845_APP_GET_NORMALLIST;
|
||
|
|
req->piid.priority = PROTO_69845_APP_PIID_PRIORITY_GENERAL;
|
||
|
|
req->piid.sn = iot_sg_sta_ext_get_69845_apdu_sn();
|
||
|
|
|
||
|
|
for (i = 0; i <= IOT_SG_STA_EXT_NLI_READ_TIME; i++) {
|
||
|
|
oad = proto_645_di_to_698_oad(nli_645_07_di_list[i]);
|
||
|
|
if (oad != PROTO_69845_APP_OAD_INVALID) {
|
||
|
|
req->oad[i].oi = (uint16_t)(oad >> 16);
|
||
|
|
attribute = (oad >> 8) & 0xff;
|
||
|
|
req->oad[i].attribute_id = attribute & 0x1f;
|
||
|
|
req->oad[i].attribute_char = attribute >> 5;
|
||
|
|
req->oad[i].element_index = oad & 0xff;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
nli_info->di_idx = IOT_SG_STA_EXT_NLI_READ_TIME;
|
||
|
|
req->oad_cnt = IOT_SG_STA_EXT_NLI_READ_TIME + 1;
|
||
|
|
server.len = PROTO_69845_SA_LEN;
|
||
|
|
server.type = PROTO_69845_SA_TYPE_SIG;
|
||
|
|
iot_mac_addr_cpy(server.addr, addr);
|
||
|
|
pkt = proto_69845_build_get_req_msg_with_rn(req, &server);
|
||
|
|
iot_pkt_free(get_list_req);
|
||
|
|
out:
|
||
|
|
return pkt;
|
||
|
|
}
|
||
|
|
|
||
|
|
static void iot_sg_ext_nli_evt_check(uint8_t *addr)
|
||
|
|
{
|
||
|
|
uint32_t d_value = 0;
|
||
|
|
int32_t phase_a = 0, gnd_a = 0;
|
||
|
|
iot_pkt_t *pkt = NULL;
|
||
|
|
iot_sg_sta_ext_nli_evt_data_t *evt_node = NULL;
|
||
|
|
iot_sg_sta_global_t *sta_glb = p_sg_glb->desc.sta;
|
||
|
|
iot_sg_sta_ext_meter_data_t *data = &sta_glb->ext_info.meter_data;
|
||
|
|
|
||
|
|
if (!proto_645_bcd_data_check(data->a.a, PROTO_645_07_A_LEN, 1) ||
|
||
|
|
!proto_645_bcd_data_check(data->gnd_a, PROTO_645_07_A_LEN, 1)) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
phase_a = proto_645_bcd_to_integer(data->a.a, PROTO_645_07_A_LEN, 1);
|
||
|
|
gnd_a = proto_645_bcd_to_integer(data->gnd_a, PROTO_645_07_A_LEN, 1);
|
||
|
|
if (IOT_ABS(gnd_a) > IOT_ABS(phase_a)) {
|
||
|
|
/* If the neutral wire current is greater than the live wire
|
||
|
|
* current by more than 100mA, record the event.
|
||
|
|
*/
|
||
|
|
d_value = IOT_ABS(gnd_a) - IOT_ABS(phase_a);
|
||
|
|
if (d_value > IOT_STA_EXT_NLI_EVT_TRIGGER_VALUE) {
|
||
|
|
pkt = iot_pkt_alloc(sizeof(*evt_node), IOT_SMART_GRID_MID);
|
||
|
|
if (!pkt) {
|
||
|
|
iot_sg_printf("%s err mem\n", __FUNCTION__);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
evt_node = (iot_sg_sta_ext_nli_evt_data_t *)iot_pkt_data(pkt);
|
||
|
|
iot_mac_addr_cpy(evt_node->pm_addr, addr);
|
||
|
|
os_mem_cpy(evt_node->phase_electric,data->a.a,
|
||
|
|
GW_APP_ELECTRIC_CURRENT_LEN);
|
||
|
|
os_mem_cpy(evt_node->neutralwire_electric,data->gnd_a,
|
||
|
|
GW_APP_ELECTRIC_CURRENT_LEN);
|
||
|
|
proto_645_unsig_to_bcd(d_value, GW_APP_ELECTRIC_CURRENT_LEN,
|
||
|
|
evt_node->nl_electric);
|
||
|
|
evt_node->time[0] = data->time.second;
|
||
|
|
evt_node->time[1] = data->time.minute;
|
||
|
|
evt_node->time[2] = data->time.hour;
|
||
|
|
evt_node->time[3] = data->time.day;
|
||
|
|
evt_node->time[4] = data->time.month;
|
||
|
|
evt_node->time[5] = data->time.year;
|
||
|
|
iot_sg_sta_ext_nli_evt_node_add(evt_node);
|
||
|
|
iot_sg_printf("%s nli event happened\n", __FUNCTION__);
|
||
|
|
iot_pkt_free(pkt);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void iot_sg_sta_ext_nli_read_handle(uint16_t seq,
|
||
|
|
uint8_t data_type, uint8_t *resp_data, uint16_t resp_len,
|
||
|
|
uint8_t *req_data, uint16_t req_len)
|
||
|
|
{
|
||
|
|
uint32_t ret = ERR_INVAL;
|
||
|
|
uint8_t flag_nack = 0;
|
||
|
|
iot_sg_sta_global_t *sta_glb = p_sg_glb->desc.sta;
|
||
|
|
iot_sg_sta_ext_info_t *ext_info = &sta_glb->ext_info;
|
||
|
|
|
||
|
|
if (data_type == IOT_SG_STA_DATA_TYPE_69845) {
|
||
|
|
ret = iot_sg_ext_read_698_data_handle(seq, data_type, resp_data,
|
||
|
|
resp_len, req_data, req_len);
|
||
|
|
} else if (data_type == IOT_SG_STA_DATA_TYPE_645_07) {
|
||
|
|
ret = iot_sg_ext_read_645_07_data_handle(seq, data_type, resp_data,
|
||
|
|
resp_len, req_data, req_len, &flag_nack);
|
||
|
|
}
|
||
|
|
if (ret == ERR_OK || ret == ERR_TIMEOVER) {
|
||
|
|
if (ret == ERR_OK) {
|
||
|
|
ext_info->nli_info.flag_resp = !flag_nack;
|
||
|
|
ext_info->nli_info.repeat_cnt = 0;
|
||
|
|
}
|
||
|
|
ext_info->nli_info.timeout_cnt = 0;
|
||
|
|
iot_sg_sta_ext_sm_stop_action();
|
||
|
|
iot_sg_sta_ext_sm_next_action(IOT_SG_STA_EXT_SM_MIN_DELAY);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void iot_sg_sta_ext_nli_plc_link_state_change_handle(uint8_t linked)
|
||
|
|
{
|
||
|
|
if (!linked) {
|
||
|
|
iot_sg_sta_ext_nli_reset();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static uint8_t iot_sg_sta_ext_nli_detect_state_check(void)
|
||
|
|
{
|
||
|
|
uint8_t ret = IOT_SG_STA_EXT_NLI_DETECTED_STATE_IDLE;
|
||
|
|
uint8_t i, dct = 0, undct = 0;
|
||
|
|
iot_sg_sta_global_t *sta_glb = p_sg_glb->desc.sta;
|
||
|
|
|
||
|
|
for (i = 0; i < IOT_SG_STA_SEC_NODE_MAX; i++) {
|
||
|
|
if (sta_glb->node_list[i] != NULL) {
|
||
|
|
if (sta_glb->node_list[i]->nli_detected) {
|
||
|
|
dct++;
|
||
|
|
} else {
|
||
|
|
undct++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (dct == 0) {
|
||
|
|
/* if all power meter undetected, in IDLE */
|
||
|
|
ret = IOT_SG_STA_EXT_NLI_DETECTED_STATE_IDLE;
|
||
|
|
} else if (undct) {
|
||
|
|
/* if any one undetected, and some meter detected, in BUSY */
|
||
|
|
ret = IOT_SG_STA_EXT_NLI_DETECTED_STATE_BUSY;
|
||
|
|
} else {
|
||
|
|
/* if all power meter detected, in END */
|
||
|
|
ret = IOT_SG_STA_EXT_NLI_DETECTED_STATE_END;
|
||
|
|
}
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
|
||
|
|
static uint8_t iot_sg_sta_ext_nli_idle_handle(iot_sg_sta_node_desc_t *node)
|
||
|
|
{
|
||
|
|
uint8_t ret = IOT_SG_STA_EXT_NLI_STATE_END, state;
|
||
|
|
uint64_t time;
|
||
|
|
iot_sg_sta_global_t *sta_glb = p_sg_glb->desc.sta;
|
||
|
|
iot_sg_sta_ext_info_t *ext_info = &sta_glb->ext_info;
|
||
|
|
iot_sg_sta_ext_nli_info_t *nli_info = &ext_info->nli_info;
|
||
|
|
|
||
|
|
if (!p_sg_glb->plc_state.link_ready ||
|
||
|
|
!iot_sg_sta_ext_nl_abnormal_detect_state_get()) {
|
||
|
|
goto out;
|
||
|
|
}
|
||
|
|
if (node->nli_detected) {
|
||
|
|
goto out;
|
||
|
|
}
|
||
|
|
state = iot_sg_sta_ext_nli_detect_state_check();
|
||
|
|
if (state == IOT_SG_STA_EXT_NLI_DETECTED_STATE_IDLE) {
|
||
|
|
time = os_boot_time64();
|
||
|
|
if (time >= nli_info->next_time) {
|
||
|
|
nli_info->next_time = time + IOT_SG_STA_EXT_NLI_INTER;
|
||
|
|
ret = IOT_SG_STA_EXT_NLI_STATE_SEND;
|
||
|
|
}
|
||
|
|
} else if (state == IOT_SG_STA_EXT_NLI_DETECTED_STATE_BUSY) {
|
||
|
|
ret = IOT_SG_STA_EXT_NLI_STATE_SEND;
|
||
|
|
}
|
||
|
|
out:
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
|
||
|
|
static uint8_t iot_sg_sta_ext_nli_wait_handle(iot_sg_sta_node_desc_t *node,
|
||
|
|
uint8_t *flag_new)
|
||
|
|
{
|
||
|
|
uint8_t ret = IOT_SG_STA_EXT_NLI_STATE_WAIT;
|
||
|
|
iot_sg_sta_global_t *sta_glb = p_sg_glb->desc.sta;
|
||
|
|
iot_sg_sta_ext_info_t *ext_info = &sta_glb->ext_info;
|
||
|
|
iot_sg_sta_ext_nli_info_t *nli_info = &ext_info->nli_info;
|
||
|
|
|
||
|
|
if (nli_info->flag_resp) {
|
||
|
|
if (node->data_type == IOT_SG_STA_DATA_TYPE_69845) {
|
||
|
|
goto done;
|
||
|
|
} else {
|
||
|
|
if (nli_info->di_idx == IOT_SG_STA_EXT_NLI_READ_TIME ||
|
||
|
|
nli_info->di_idx == IOT_SG_STA_EXT_NLI_READ_TIME_HMS) {
|
||
|
|
/* 645 07 read timestamp or time succeed, deemed complete */
|
||
|
|
goto done;
|
||
|
|
} else {
|
||
|
|
nli_info->di_idx++;
|
||
|
|
*flag_new = 1;
|
||
|
|
ret = IOT_SG_STA_EXT_NLI_STATE_SEND;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
if (nli_info->timeout_cnt) {
|
||
|
|
nli_info->timeout_cnt--;
|
||
|
|
} else {
|
||
|
|
if (nli_info->repeat_cnt) {
|
||
|
|
nli_info->repeat_cnt--;
|
||
|
|
*flag_new = 0;
|
||
|
|
ret = IOT_SG_STA_EXT_NLI_STATE_SEND;
|
||
|
|
} else {
|
||
|
|
iot_sg_printf("%s read %lu faild\n", __FUNCTION__,
|
||
|
|
nli_info->di_idx);
|
||
|
|
if (node->data_type == IOT_SG_STA_DATA_TYPE_645_07 &&
|
||
|
|
nli_info->di_idx == IOT_SG_STA_EXT_NLI_READ_TIME) {
|
||
|
|
/* if the timestamp of 645_07 read failed, continue
|
||
|
|
* trying to read the date and time
|
||
|
|
*/
|
||
|
|
nli_info->di_idx++;
|
||
|
|
*flag_new = 1;
|
||
|
|
ret = IOT_SG_STA_EXT_NLI_STATE_SEND;
|
||
|
|
} else {
|
||
|
|
/* if other data reading fails, abandoned */
|
||
|
|
ret = IOT_SG_STA_EXT_NLI_STATE_END;
|
||
|
|
node->nli_detected = 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
goto out;
|
||
|
|
done:
|
||
|
|
ret = IOT_SG_STA_EXT_NLI_STATE_END;
|
||
|
|
node->nli_detected = 1;
|
||
|
|
iot_sg_ext_nli_evt_check(node->entry.addr);
|
||
|
|
out:
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
|
||
|
|
static uint8_t iot_sg_sta_ext_nli_send_handle(iot_sg_sta_node_desc_t *node,
|
||
|
|
uint8_t flag_new)
|
||
|
|
{
|
||
|
|
uint32_t tmp, di;
|
||
|
|
uint8_t ret = IOT_SG_STA_EXT_NLI_STATE_SEND;
|
||
|
|
iot_pkt_t *pkt = NULL;
|
||
|
|
iot_sg_sta_global_t *sta_glb = p_sg_glb->desc.sta;
|
||
|
|
iot_sg_sta_ext_info_t *ext_info = &sta_glb->ext_info;
|
||
|
|
iot_sg_sta_ext_nli_info_t *nli_info = &ext_info->nli_info;
|
||
|
|
|
||
|
|
if (node->data_type == IOT_SG_STA_DATA_TYPE_69845) {
|
||
|
|
iot_sg_printf("%s read 698\n", __FUNCTION__);
|
||
|
|
pkt = iot_sg_ext_nli_69845_mr_msg_build(node->entry.addr);
|
||
|
|
} else if (node->data_type == IOT_SG_STA_DATA_TYPE_645_07) {
|
||
|
|
if (nli_info->di_idx > sizeof(nli_645_07_di_list) /
|
||
|
|
sizeof(nli_645_07_di_list[0])) {
|
||
|
|
ret = IOT_SG_STA_EXT_NLI_STATE_END;
|
||
|
|
goto out;
|
||
|
|
}
|
||
|
|
di = nli_645_07_di_list[nli_info->di_idx];
|
||
|
|
iot_sg_printf("%s read 645 %.8X\n", __FUNCTION__, di);
|
||
|
|
pkt = proto_645_build_mr_msg(PROTO_645_2007_ID, node->entry.addr, di);
|
||
|
|
}
|
||
|
|
if (pkt) {
|
||
|
|
tmp = iot_sg_sta_add_mr_req(IOT_SG_STA_MR_SRC_ID_NLI_DETECT,
|
||
|
|
node->entry.addr, 0, node->data_type, iot_pkt_data(pkt),
|
||
|
|
(uint16_t)iot_pkt_data_len(pkt), IOT_SG_STA_EXT_DRV_READ_TIMEOUT);
|
||
|
|
if (tmp == ERR_OK) {
|
||
|
|
nli_info->flag_resp = 0;
|
||
|
|
ret = IOT_SG_STA_EXT_NLI_STATE_WAIT;
|
||
|
|
nli_info->timeout_cnt = IOT_SG_STA_EXT_READ_DATA_TIMEOUT;
|
||
|
|
if (flag_new) {
|
||
|
|
nli_info->repeat_cnt = 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
iot_pkt_free(pkt);
|
||
|
|
} else {
|
||
|
|
iot_sg_printf("%s err mem\n", __FUNCTION__);
|
||
|
|
}
|
||
|
|
out:
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
|
||
|
|
uint8_t iot_sg_sta_ext_nli_func(uint8_t *addr)
|
||
|
|
{
|
||
|
|
uint8_t complete = 0, flag_new = 0;
|
||
|
|
iot_sg_sta_global_t *sta_glb = p_sg_glb->desc.sta;
|
||
|
|
iot_sg_sta_ext_info_t *ext_info = &sta_glb->ext_info;
|
||
|
|
iot_sg_sta_ext_nli_info_t *nli_info = &ext_info->nli_info;
|
||
|
|
iot_sg_sta_node_desc_t *node = iot_sg_sta_node_find_by_addr(addr);
|
||
|
|
|
||
|
|
IOT_ASSERT(node);
|
||
|
|
switch (nli_info->state) {
|
||
|
|
case IOT_SG_STA_EXT_NLI_STATE_IDLE:
|
||
|
|
{
|
||
|
|
nli_info->state = iot_sg_sta_ext_nli_idle_handle(node);
|
||
|
|
if (nli_info->state == IOT_SG_STA_EXT_NLI_STATE_END) {
|
||
|
|
goto done;
|
||
|
|
}
|
||
|
|
/* else state is IOT_SG_STA_EXT_NLI_STATE_SEND,
|
||
|
|
* and enters the case of send.
|
||
|
|
*/
|
||
|
|
flag_new = 1;
|
||
|
|
}
|
||
|
|
case IOT_SG_STA_EXT_NLI_STATE_SEND:
|
||
|
|
{
|
||
|
|
send:
|
||
|
|
nli_info->state = iot_sg_sta_ext_nli_send_handle(node, flag_new);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case IOT_SG_STA_EXT_NLI_STATE_WAIT:
|
||
|
|
{
|
||
|
|
nli_info->state = iot_sg_sta_ext_nli_wait_handle(node, &flag_new);
|
||
|
|
if (nli_info->state == IOT_SG_STA_EXT_NLI_STATE_SEND) {
|
||
|
|
goto send;
|
||
|
|
} else if (nli_info->state == IOT_SG_STA_EXT_NLI_STATE_END) {
|
||
|
|
goto done;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case IOT_SG_STA_EXT_NLI_STATE_END:
|
||
|
|
{
|
||
|
|
done:
|
||
|
|
if (iot_sg_sta_ext_nli_detect_state_check() ==
|
||
|
|
IOT_SG_STA_EXT_NLI_DETECTED_STATE_END) {
|
||
|
|
/* All power meter has been detected neutralwire
|
||
|
|
* and livewire abnormal.
|
||
|
|
*/
|
||
|
|
iot_sg_sta_ext_nli_node_reset();
|
||
|
|
iot_sg_sta_ext_nli_evt_rpt_start();
|
||
|
|
}
|
||
|
|
complete = 1;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
default:
|
||
|
|
IOT_ASSERT(0);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
return complete;
|
||
|
|
}
|
||
|
|
|
||
|
|
#endif /* IOT_SMART_GRID_EXT_NLI_FUNC_ENABLE */
|