andy/kunlun
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
a1a8f76b8caacdfd7d371d9acc86fd0b3d12a41d
kunlun/app/chargepile/iot_cp_task.c
andy c756587541 初始提交
2024-09-28 14:24:04 +08:00

4280 lines
144 KiB
C
Executable File
Raw Blame History

/****************************************************************************
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_ship header files */
#include "os_task_api.h"
#include "os_event_api.h"
#include "os_timer_api.h"
#include "os_utils_api.h"
/* iot common header files */
#include "iot_io_api.h"
#include "iot_module_api.h"
#include "iot_errno_api.h"
#include "iot_task_api.h"
#include "iot_pkt_api.h"
#include "iot_board_api.h"
#include "iot_oem_api.h"
#include "iot_plc_api.h"
#include "iot_version.h"
#include "iot_version_api.h"
#include "iot_rtc_api.h"
#include "iot_gpio_api.h"
#include "iot_grapp.h"
#include "iot_proto_common.h"
#include "iot_gr_upgrade.h"
#include "iot_proto_ge.h"
#include "iot_cp_task.h"
#include "iot_cp_socket.h"
#if (USE_N11_GPRS == 1)
#include "n11_gprs.h"
#endif
#if (CP_ZC_ENABLE == 1)
#include "iot_bitmap_api.h"
#include "cpl_types_api.h"
#include "iot_gptmr_api.h"
#endif
#if IOT_CP_TASK_ENABLE
#define IOT_CP_TASK_MSG_QUEUE (0)
#define IOT_CP_TASK_UART_BUF_SIZE (512 + 64)
#define IOT_CP_TASK_MSG_POOL_SIZE (128)
#define IOT_CP_YEAR_START_FROM (2000)
#ifndef IOT_CP_SEVER_WR_EN
#define IOT_CP_SEVER_WR_EN (1)
#endif
#if (IOT_CP_SEVER_WR_EN == 1)
/* store the respons infor for 60H, when 40H received */
static cp_rpt_charg_abort_fn60_t resp_cmd_60h[IOT_CP_MAX_PLUG_CNT] = {0};
/* bitmap for indcation whether 60h should be sent or not */
static uint8_t is_wr_on = 0;
/* report counter for every plug */
static uint8_t rpt_60h_cnt[IOT_CP_MAX_PLUG_CNT] = {0};
/* counter of interval for reporting retry */
static uint8_t wr_invtl_cnt[IOT_CP_MAX_PLUG_CNT] = {0};
/* indicate how many report pkt should be sent for each plug */
#define IOT_CP_MAX_WR_60H_CNT (3)
#endif
#ifndef CP_TASK_DEBUG
#define CP_TASK_DEBUG (0)
#endif
static cp_flash_info_t *flash_info;
/* set default threshold value */
const cp_plug_threshold_info_t def_cp_th = {
/* the current threshold when charge full, unit:1mA (1~1000) */
.full_chg_cur_th = CP_DEFAULT_CFG_CHG_FULL_CURRENT,
/* threshold current timer for full charging */
.full_chg_cur_tm_th = 0,
/* the current threshold when leak,unit:1 mA (1~255) */
.leak_cur_protc_th = CP_DEFAULT_CFG_LEAK_CURRENT,
/* threshold of leakage current protection time */
.leak_cur_protc_tm_th = 0,
/* the current threshold when load is over, unit:0.1A (1~160) */
.over_load_th = CP_DEFAULT_CFG_OVERLOAD_CURRENT,
/* threshold of overload protection time */
.over_load_tm_th = 0,
/* threshold of charging timeout */
.charg_timeout_th = 0,
/* time of charge started */
.charg_start_tm = 0,
/* open circurt current without load, uint:mA */
.discon_cur_th = CP_DEFAULT_OPEN_CIRCUIT_CURRENT,
/* the rated voltage, such as 110V or 220v, unit: 1V */
.rated_volt = CP_DEFAULT_CFG_RATED_VOLT,
/* fault status */
.alarm.alarm_en_data = ALARM_EN_VALUE,
};
#if USE_N11_GPRS
static uint32_t iot_grapp_sendto_mainboard_gprs_fn(iot_pkt_t *data)
{
if (NULL == data) {
return ERR_INVAL;
}
int32_t ret = iot_n11_gprs_send(data, 0);
return ret;
}
#endif
/* The command handle. */
typedef void(*cp_cmd_meter_handle_t)(cp_socket_cmd_arg_t *arg);
/* the table of plctxrx commands. */
typedef struct _cp_cmd_list_t
{
cp_cmd_meter_handle_t *handle;
} cp_cmd_list_t;
typedef struct _cp_command_t
{
/* current command's infor: include CID and op_code */
cp_socket_hdr_t cur_cid;
/* indication the command is running or not */
bool_t cmd_running;
/* indication current cmd need response cfm or not */
bool_t need_ack;
/* list of command handle */
cp_cmd_list_t list;
} cp_command_t;
void iot_cp_task_msg_post(uint16_t msg_type, uint16_t msg_id,
iot_pkt_t *data, uint32_t dir);
typedef struct _iot_plc_context {
/* task handle */
iot_task_h task;
/* uart handler */
iot_uart_h uart_h;
/* timer handle for waiting grapp initialized */
timer_id_t appinit_timer;
/* timer handle for command handling timeout */
timer_id_t cmdresp_expire_timer;
/* timer handle for local status updating */
timer_id_t status_update_timer;
/* local device type see IOT_CP_DEV_CODE_XXX */
uint8_t dev_type;
/* local mac address. */
uint8_t local_mac[IOT_MAC_ADDR_LEN];
/* cco mac */
uint8_t cco_mac[IOT_MAC_ADDR_LEN];
/* module started */
uint8_t module_started;
/* plc state : inited,online,offine */
uint8_t plc_state;
/* work role*/
uint8_t work_role;
/**/
cp_task_cb cp_task_cb;
}iot_plc_context;
typedef struct _iot_cp_context_task {
/* present time */
cp_date_t rtc_time;
/* working mode, 0--maintain, 1--normal */
uint8_t work_mode;
/* plugs' infor */
cp_plug_info_t plug_info[IOT_CP_MAX_PLUG_CNT];
/* flash info */
cp_flash_info_t flash_info;
/* software information */
uint32_t sw_info;
/* hardware information */
uint32_t hw_info;
/* current command handling*/
cp_command_t command;
/* communication is normal*/
uint8_t is_communication_ok;
/* interval counter of querring RTC */
uint16_t query_rtc_cnt;
/* count of rtc reporting to platform */
uint8_t rtc_report_cnt;
/* interval counter of status reporting to platform */
uint16_t rpt_intvl_cnt[IOT_CP_MAX_PLUG_CNT];
/* sequnce number for sending cmd*/
uint32_t send_signal_sn;
/* sequnce number for received cmd*/
uint32_t recv_signal_sn;
#if (CP_ZC_ENABLE == 1)
/* relay info for zc control */
cp_relay_zc_ctrl_t relay_ctrl;
#endif
} iot_cp_context;
static iot_cp_context cp_context;
static iot_plc_context plc_context;
#define IOT_CUS_TASK_DATA_DUMP
#ifdef IOT_CUS_TASK_DATA_DUMP
static char dump_buf[512 + 16];
void iot_cp_task_data_dump_inner(void * buf, uint32_t len, uint32_t line)
{
char *p = buf, *q = dump_buf;
uint32_t i, buf_len;
buf_len = iot_sprintf(q, "DUMP(%03d):", len);
for (i = 0; i < len && buf_len < sizeof(dump_buf) - 13; i++, p++) {
buf_len += iot_sprintf(q + buf_len, " %02X", ((int)*p) & 0xFF);
}
iot_cus_printf("\n[cp_task@%04d]:%s\n", line, dump_buf);
return;
}
#define iot_cp_task_data_dump(buf, len) \
iot_cp_task_data_dump_inner(buf, len, __LINE__)
#else
#define iot_cp_task_data_dump(buf, len)
#endif
static void iot_cp_send_relay_state_to_meter_task(uint8_t plug_id,
bool_t state);
static void iot_cp_set_charge_switch(uint8_t plug_id, bool_t is_on);
static void iot_cp_set_threshold_value(cp_plug_threshold_info_t *th_info,
uint8_t id);
static void iot_cp_send_param_cmd_to_meter_task(uint8_t op_code,
uint8_t plug_id);
static iot_pkt_t *iot_cp_alloc_ge_data_frm_pkt( uint16_t data_len);
static void iot_cp_frame_fill(uint8_t fn, uint8_t *cp_frm,
uint16_t data_len, uint8_t dir);
static void iot_cp_send_pkt(uint8_t *dst_mac, iot_pkt_t *ge_pkt, uint8_t dir);
#if IOT_CP_SEVER_WR_EN
/* for cco: report data to uart once error aborting happened fn: 60H
* for sta: report data to uart and cco
*/
static void iot_cp_report_err_abort_for_wr(uint8_t plug_num )
{
cp_rpt_charg_abort_fn60_t *rsp_cmd;
ge_frame_data_send_set_subfn160_t *ge_data_frame = NULL;
iot_pkt_t *rsp_pkt = NULL;
uint8_t data_len = 0;
uint8_t frame_len = 0;
uint8_t dir;
if (plug_num >= IOT_CP_MAX_PLUG_CNT) {
goto out;
}
if (!(is_wr_on & (1 << plug_num))) {
goto out;
}
if (rpt_60h_cnt[plug_num] >= IOT_CP_MAX_WR_60H_CNT) {
is_wr_on &= ~(1 << plug_num);
wr_invtl_cnt[plug_num] = 0;
goto out;
}
wr_invtl_cnt[plug_num]++;
if (wr_invtl_cnt[plug_num] < IOT_CP_TASK_REPORT_INTVL_CNT) {
goto out;
}
iot_cus_printf("%s rpt_bm %d, plug id %d\n",__FUNCTION__, is_wr_on, plug_num);
wr_invtl_cnt[plug_num] = 0;
frame_len = sizeof(*rsp_cmd) + CP_GE_DATA_FRM_MIN_SIZE;
rsp_pkt = iot_cp_alloc_ge_data_frm_pkt(frame_len);
if (rsp_pkt != NULL) {
ge_data_frame =
(ge_frame_data_send_set_subfn160_t *)iot_pkt_data(rsp_pkt);
rsp_cmd = (cp_rpt_charg_abort_fn60_t *)(ge_data_frame->data +
IOT_MAC_ADDR_LEN);
os_mem_cpy(rsp_cmd, &resp_cmd_60h[plug_num], sizeof(*rsp_cmd));
data_len = sizeof(*rsp_cmd) - CP_FRM_MIN_LEN;
/* send to uart */
if (plc_context.work_role == CP_PLC_ROLE_CCO) {
dir = IOT_CP_TRANS_DIR_UART;
} else {
dir = IOT_CP_TRANS_DIR_PLC;
}
iot_cp_frame_fill(IOT_CP_CMD_RPT_ERR_ABORT, (uint8_t *)rsp_cmd,
data_len, dir);
iot_cp_send_pkt(plc_context.cco_mac, rsp_pkt, dir);
rpt_60h_cnt[plug_num]++;
}
out:
return;
}
#else
static void iot_cp_report_err_abort_for_wr(uint8_t plug_num)
{
(void)plug_num;
}
#endif
#if (CP_ZC_ENABLE == 1)
/* get relay state in bitmap */
static bool_t iot_cp_bm_get_relay_state(uint8_t plug_id)
{
bool_t relay_on = true;
uint8_t bm_relay = cp_context.relay_ctrl.bm_relay_state;
if (iot_bitmap_is_set(&bm_relay, 1, plug_id)) {
relay_on = true;
} else {
relay_on = false;
}
return relay_on;
}
/* set bitmap for relay state */
static void iot_cp_bm_set_relay_state(uint8_t plug_id, bool_t is_on)
{
uint8_t bm_relay = cp_context.relay_ctrl.bm_relay_state;
if (true == is_on) {
iot_bitmap_set(&bm_relay, 1, plug_id);
} else {
iot_bitmap_clear(&bm_relay, 1, plug_id);
}
}
/* get request of relay state changing in bitmap */
static bool_t iot_cp_bm_get_relay_state_change_req(uint8_t plug_id)
{
bool_t req_on = true;
uint8_t bm_req = cp_context.relay_ctrl.bm_req;
if (iot_bitmap_is_set(&bm_req, 1, plug_id)) {
req_on = true;
} else {
req_on = false;
}
return req_on;
}
/* set bitmap for relay state change request */
static void iot_cp_bm_set_relay_state_change_req(uint8_t plug_id, bool_t is_on)
{
uint8_t bm_req = cp_context.relay_ctrl.bm_req;
if (true == is_on) {
iot_bitmap_set(&bm_req, 1, plug_id);
} else {
iot_bitmap_clear(&bm_req, 1, plug_id);
}
}
/* set relay's state change request and new state*/
static void iot_cp_set_switch_change_req(uint8_t plug_id, bool_t is_on)
{
iot_cp_bm_set_relay_state_change_req(plug_id, is_on);
iot_cp_bm_set_relay_state(plug_id, is_on);
}
/* caculate the zc period */
static uint32_t iot_cp_zc_period_cal(uint8_t *buf, uint8_t len)
{
uint8_t i, j;
uint32_t temp;
/* reorder the data buffer: ranking from small to large */
for (i = 0; i < (len - 1); i++) {
for (j = 0; j < (len - 1 - i); j++) {
if (buf[j] > buf[j + 1]) {
temp = buf[j];
buf[j] = buf[j + 1];
buf[j + 1] = temp;
}
}
}
/* delete some max and min, the total number of
* max and min is IOT_PLC_HW_DELETE_CNT
*/
i = IOT_CP_ZC_DISCARD_DATA_CNT;
j = IOT_CP_ZC_SAMPLE_CNT;
temp = 0;
i >>= 1;
j -= i;
/* calculate the period of sinusoidal wave */
for (; i < j; i++) {
temp += buf[i];
}
j = IOT_CP_ZC_SAMPLE_CNT - IOT_CP_ZC_DISCARD_DATA_CNT;
return (temp / j);
}
/* get zc infor in gpio's ISR */
static uint32_t iot_cp_zc_info_get(void)
{
uint8_t reason = 0;
uint8_t ret = ERR_OK;
uint32_t trig_tick, delta_tick = 0;
cp_zc_info_t *zc_info = &cp_context.relay_ctrl.zc_info;
/* make sure the interrupt is trigged at the falling edge */
if (!iot_gpio_value_get(zc_info->zc_gpio)) {
reason = 1;
goto out;
}
trig_tick = iot_gpio_get_trigger_ticks(zc_info->zc_gpio);
if (zc_info->zc_tick_vaild == 0) {
/* first time, record counter and set flag */
zc_info->pre_triger_ticks = trig_tick;
zc_info->zc_tick_vaild = 1;
reason = 2;
goto out;
} else {
delta_tick = trig_tick - zc_info->pre_triger_ticks;
if (trig_tick > zc_info->pre_triger_ticks) {
delta_tick = trig_tick - zc_info->pre_triger_ticks;
} else {
delta_tick = 0xffffffff - zc_info->pre_triger_ticks + trig_tick;
}
if ((delta_tick > IOT_CP_ZC_PERIOD_LIMIT_UPPER) ||
(delta_tick < IOT_CP_ZC_PERIOD_LIMIT_LOWER)) {
reason = 3;
goto out;
}
}
zc_info->zc_buf[zc_info->buf_indx] = delta_tick;
zc_info->buf_indx++;
if (zc_info->buf_indx >= IOT_CP_ZC_SAMPLE_CNT) {
zc_info->buf_indx = 0;
zc_info->zc_period = iot_cp_zc_period_cal(zc_info->zc_buf,
IOT_CP_ZC_SAMPLE_CNT);
/* check validity of the zc period */
if ((zc_info->zc_period > IOT_CP_ZC_PERIOD_LIMIT_UPPER) ||
(zc_info->zc_period < IOT_CP_ZC_PERIOD_LIMIT_LOWER)) {
zc_info->zc_period_vaild = false;
} else {
zc_info->zc_period_vaild = true;
}
}
zc_info->pre_triger_ticks = trig_tick;
out:
if (reason != 0) {
ret = ERR_FAIL;
}
iot_cus_printf("%s reason %d\n", __FUNCTION__, reason);
return ret;
}
static void iot_cp_gp_timer_start(uint32_t period)
{
iot_gp_timer_set(cp_context.relay_ctrl.gp_timer_id, period, 0);
iot_gp_timer_start(cp_context.relay_ctrl.gp_timer_id);
cp_context.relay_ctrl.timer_running = true;
iot_cus_printf("[cp]gp timer will fire up in %lu us\n", period);
}
/* caculate the GP timer's period then start it */
static void iot_cp_zc_gp_timer_period_cal_and_set(void)
{
uint8_t reason = 0;
uint32_t cur_ts, delta_ts;
uint32_t gp_period = 0;;
cp_zc_info_t *zc_info = &cp_context.relay_ctrl.zc_info;
if (!zc_info->zc_period_vaild) {
reason = 1;
goto out;
}
/* no relay control quest, go out */
if (cp_context.relay_ctrl.bm_req == 0) {
reason = 2;
goto out;
}
cur_ts = iot_gp_timer_get_curr_ts();
if (cur_ts > zc_info->pre_triger_ticks) {
delta_ts = cur_ts - zc_info->pre_triger_ticks;
} else {
delta_ts = 0xffffffff - zc_info->pre_triger_ticks + cur_ts;
}
if (delta_ts > zc_info->zc_period) {
reason = 3;
goto out;
}
gp_period = zc_info->zc_period - delta_ts;
out:
if (reason != 0) {
iot_cus_printf("Get GP timer period failed, reason %d\n", reason);
} else {
if (reason > 2) {
iot_cp_gp_timer_start(gp_period);
}
}
}
/* update the relay's status after gp timer's ISR */
static void iot_cp_relay_ctrl_update_handle(iot_addrword_t data)
{
(void)data;
cp_relay_zc_ctrl_t *relay = &cp_context.relay_ctrl;
uint8_t indx;
if (relay->bm_req == 0) {
return ;
}
for (indx = 0; indx < CP_SOCKET_ID_MAX; indx++) {
if (true == iot_cp_bm_get_relay_state_change_req(indx)) {
/* inform th lower layer task once relay state changed */
if (true == iot_cp_bm_get_relay_state(indx)) {
iot_cp_send_relay_state_to_meter_task(indx, true);
} else {
iot_cp_send_relay_state_to_meter_task(indx, false);
}
/* clear requst flag in bitmap */
iot_cp_bm_set_relay_state_change_req(indx, false);
}
}
return ;
}
/* ISR of GP timer: set the gpio status to on or off */
uint8_t iot_cp_relay_ctrl_isr_handle(iot_addrword_t data)
{
uint8_t indx;
cp_relay_zc_ctrl_t *relay = &cp_context.relay_ctrl;
(void)data;
for (indx = 0; indx < CP_SOCKET_ID_MAX; indx++) {
if (true == iot_cp_bm_get_relay_state_change_req(indx)) {
/* set relays to on or off state */
if (true == iot_cp_bm_get_relay_state(indx)) {
iot_cp_set_charge_switch(indx, true);
} else {
iot_cp_set_charge_switch(indx, false);
}
}
}
relay->timer_running = false;
return ERR_OK;
}
static void iot_cp_zc_gpio_isr_handle(int arg)
{
(void)arg;
iot_cp_zc_info_get();
iot_cp_zc_gp_timer_period_cal_and_set();
return;
}
/* initialize GPIO for ZC_in */
static uint8_t iot_cp_zc_gpio_init()
{
uint8_t ret = ERR_OK;
uint8_t zc_gpio = 0xff;
uint8_t reason = 0;
zc_gpio = cp_context.relay_ctrl.zc_info.zc_gpio;
if (zc_gpio == 0xFF) {
reason = 1;
goto out;
}
if (iot_gpio_open_as_interrupt(zc_gpio)) {
reason = 2;
goto out;
}
if (iot_gpio_interrupt_config(zc_gpio, GPIO_INT_EDGE_RAISING,
iot_cp_zc_gpio_isr_handle, 0, GPIO_INT_FUNC_GET_TICKS)) {
reason = 3;
goto out;
}
if (iot_gpio_interrupt_enable(zc_gpio, 1)) {
reason = 4;
goto out;
}
out:
if (reason != 1) {
ret = ERR_FAIL;
}
iot_cus_printf("Init ZC gpio%d %s reason %d\n", zc_gpio,
ret ? "failed" : "successfully", reason);
return ret;
}
static uint8_t iot_cp_zc_hw_init(void)
{
uint8_t reason = 0;
uint8_t ret = 0;
uint8_t timer_id = cp_context.relay_ctrl.gp_timer_id;
timer_id = iot_gp_timer_create(0x0, iot_cp_relay_ctrl_update_handle,
iot_cp_relay_ctrl_isr_handle, 0);
if (timer_id >= GP_TIMER_COUNT) {
timer_id = IOT_CP_GP_TIMER_INVALID_ID;
reason = 1;
} else {
if(ERR_OK != iot_cp_zc_gpio_init()) {
reason = 2;
}
}
if (reason != 0) {
ret = ERR_FAIL;
}
iot_cus_printf("Init ZC hardware %s reason %d\n",
ret ? "failed" : "successfully", reason);
return ret;
}
static void iot_cp_delay_time(uint32_t delay)
{
(void)delay;
}
static void iot_cp_set_moc(uint8_t plug_id, int32_t hi_low)
{
(void)plug_id;
(void)hi_low;
}
#else /* CP_ZC_ENABLE == 1 */
static void iot_cp_delay_time(uint32_t delay)
{
os_delay(delay);
}
/**
* @brief iot_cp_set_moc: set moc gpio hi_low
* @param plug_id: socket port id, see CP_SOCKET_IDXX
* @param hi_low: gpio hi low state, see IOT_CP_GPIO_OUPUT_XX
*/
static void iot_cp_set_moc(uint8_t plug_id, int32_t hi_low)
{
if (plug_id == CP_SOCKET_ID_0 || plug_id == CP_SOCKET_ID_ALL)
iot_gpio_value_set(IOT_CP_GPIO_MOC1, hi_low);
if (plug_id == CP_SOCKET_ID_1 || plug_id == CP_SOCKET_ID_ALL)
iot_gpio_value_set(IOT_CP_GPIO_MOC2, hi_low);
if (plug_id == CP_SOCKET_ID_2 || plug_id == CP_SOCKET_ID_ALL)
iot_gpio_value_set(IOT_CP_GPIO_MOC3, hi_low);
if (plug_id == CP_SOCKET_ID_3 || plug_id == CP_SOCKET_ID_ALL)
iot_gpio_value_set(IOT_CP_GPIO_MOC4, hi_low);
}
#endif /* CP_ZC_ENABLE == 0 */
static uint32_t iot_cp_get_send_signal_sn(void)
{
cp_context.send_signal_sn++;
if (cp_context.send_signal_sn == 0) {
cp_context.send_signal_sn = 1;
}
iot_cus_printf("new signal SN alloc: %lu\n", cp_context.send_signal_sn);
return cp_context.send_signal_sn;
}
static void iot_cp_send_relay_state_to_meter_task(uint8_t plug_id,
bool_t state);
/**
* @briefiot_cp_calc_cs: calculate checksum
* @param data: data need to calculate checksum
* @param len: the data length to calculate checksum
* @retval: return the checksum calculated
*/
static uint8_t iot_cp_calc_cs(uint8_t *data, uint16_t len)
{
uint16_t i;
uint8_t cs = data[0];
IOT_ASSERT(data && len);
for (i = 1; i < len; i++) {
cs += data[i];
}
return cs;
}
/**
* @brief iot_cp_frame_fill: fill cp frame header, checksum and tail field.
* @param fn: cp's fucntion code
* @param cp_frm: pointer of data field
* @param data_len: length of data field
*/
static void iot_cp_frame_fill(uint8_t fn, uint8_t *cp_frm,
uint16_t data_len, uint8_t dir)
{
cp_rsp_frame_t *frame_h= NULL;
uint8_t *data_ptr = NULL;
uint8_t cal_crc;
frame_h = (cp_rsp_frame_t *)cp_frm;
frame_h->hdr.preamble = CP_FRM_PREAMBLE_CODE;
frame_h->hdr.fn = fn;
frame_h->hdr.data_len = data_len;
cal_crc = iot_cp_calc_cs(cp_frm, sizeof(*frame_h) + data_len);
data_ptr = frame_h->data + data_len;
*(data_ptr++) = cal_crc;
*data_ptr = CP_FRM_TAIL_CODE;
if (dir == IOT_CP_TRANS_DIR_PLC) {
frame_h->hdr.preamble = CP_FRM_PREAMBLE_REPLY_CODE;
}
}
/**
* @brief iot_get_cpcmd_hdr: find a CP frame and return the frame header
* @param data: data to be queried
* @param in_len: data length of the query
* @param vaild_len: if a frame is found to return virtual length
* @retval: return cp frame header if find cp frame.
*/
static cp_frm_hdr_t *iot_get_cpcmd_hdr(uint8_t *data, uint16_t in_len,
uint8_t *vaild_len)
{
cp_frm_hdr_t *hdr = NULL;
uint8_t *ptr = NULL;
uint8_t t_crc = 0;
uint8_t cal_crc = 0;
uint8_t frm_len = 0;
uint8_t is_reply = false;
uint16_t i = 0;
if ((NULL == data) || (in_len < CP_FRM_MIN_LEN)) {
*vaild_len = 0;
iot_cus_printf("[cp]:cp frame check err\n");
return hdr;
}
for (i = 0; i < in_len; i++) {
data += i;
//a reply frame
if (CP_FRM_PREAMBLE_REPLY_CODE == (*data)) {
iot_cus_printf("[cp]reply frame found\n");
(*data) = CP_FRM_PREAMBLE_CODE;
is_reply = true;
}
if (CP_FRM_PREAMBLE_CODE == (*data)) {
ptr = data + CP_FRM_DATA_LEN_OFFSET;
frm_len = sizeof(cp_frm_hdr_t) + (*ptr) + CP_FRAME_TAIL_SIZE;
ptr = ptr + (*ptr);
ptr++;
t_crc = (*ptr);
cal_crc = iot_cp_calc_cs(data, frm_len - CP_FRAME_TAIL_SIZE);
if ((CP_FRM_TAIL_CODE == *(ptr+1)) && (t_crc == cal_crc)) {
hdr = (cp_frm_hdr_t *)data;
*vaild_len = frm_len;
if (is_reply) {
hdr->preamble = CP_FRM_PREAMBLE_REPLY_CODE;
}
return hdr;
} else {
iot_cus_printf("[cp][err]cp frame CS err\n");
}
}
}
return hdr;
}
/**
* @brief iot_cp_ge_frm_check: find a GE frame and return the frame header
* @param data : data to be queried
* @param in_len : data length of the query
* @param vaild_len: if a frame is found to return virtual length
* @retval: return ge frame header if find ge frame in data
*/
static ge_extend_fn_hdr_t *iot_cp_ge_frm_check(uint8_t *data,
uint16_t in_len, uint16_t *vaild_len)
{
ge_extend_fn_hdr_t *head = NULL;
uint16_t pre_code = 0;
uint16_t payload_len = 0;
uint8_t *ptr = NULL;
uint16_t cal_crc = 0;
uint16_t frm_crc = 0;
uint16_t len_t, i = 0;
uint8_t *data_s = NULL;
uint16_t t_len = 0;
*vaild_len = 0;
if ((NULL == data) || (in_len < GE_FRM_MIN_LEN)) {
return head;
}
iot_cus_printf("[cp]iot_cp_ge_frm_check inlen=%d\n", in_len);
for (i = 0, len_t = in_len; i < in_len; i++) {
if (i + 1 >= in_len) {
break;
}
/* check frame preamble coed */
pre_code = (data[i] << 8) + data[i+1];
if (pre_code == GE_FRM_PREAMBLE_CODE) {
data_s = data + i;
}
len_t--;
if ((data_s == NULL) || (len_t < GE_FRM_MIN_LEN)) {
/* left cmd length is not enought */
break;
}
head = (ge_extend_fn_hdr_t *)data_s;
/* check fn and sunfn for command */
if (head->hdr.fn == PROTO_UPGRADE_DL || head->hdr.fn == PROTO_UPGRADE_UL) {
if (head->hdr.fn == PROTO_UPGRADE_DL &&
head->subfn == PROTO_UPGRADE_DATA) {
/* calc upgrade data len */
if (head->hdr.data_len == GREE_UPGRADE_DATA_CONTROL &&
len_t > GREE_UPGRADE_DATA_FRM_LEN_HIG_BYTE) {
payload_len = GREE_UPGRADE_DATA_FRM_CTL_LEN +
data_s[GREE_UPGRADE_DATA_FRM_LEN_HIG_BYTE] * 256 +
data_s[GREE_UPGRADE_DATA_FRM_LEN_LOW_BYTE];
} else {
return NULL;
}
} else {
/* calc other upgrade command length */
payload_len = head->hdr.data_len;
if (payload_len > GREE_UPGRADE_CMD_CONTROL_MIN) {
payload_len -= GREE_UPGRADE_CMD_CONTROL_MIN;
}
}
} else {
payload_len = head->hdr.data_len;
}
ptr = data_s + GE_FRM_NORMAL_SEQ_POS + payload_len;
frm_crc = *ptr + (*(ptr + 1) << 8);
ptr += GE_FRM_CHECKSUM_FIELD_LEN;
if (*ptr != GE_FRM_TAIL_CODE) {
iot_cus_printf("[cp]ge_frm_check tail check error\n");
continue;
}
/* calc frame length, exclude checksum and tail */
t_len = GE_FRM_MIN_LEN + payload_len - GE_FRM_CHECKSUM_FIELD_LEN -
GE_FRM_TAIL_FILED_LEN;
/* checksum check */
cal_crc = ge_frm_checksum_calc(data_s, t_len );
if (cal_crc != frm_crc) {
iot_cus_printf("[cp]ge_frm_check crc check c_crc:%x != f_crc:%x\n",
cal_crc, frm_crc);
continue;
} else {
/* total frame length */
t_len += GE_FRM_CHECKSUM_FIELD_LEN + GE_FRM_TAIL_FILED_LEN;
*vaild_len = t_len;
return head;
}
}
return NULL;
}
uint8_t iot_cp_task_post_uart_cmd(uint8_t * data, uint16_t len, uint32_t param)
{
iot_pkt_t* send_pkt = NULL;
(void)param;
send_pkt = iot_pkt_alloc(len, IOT_CP_TASK_ID);
if (send_pkt) {
/* copy data from buf to data packet */
os_mem_cpy(iot_pkt_put(send_pkt, len), data, len);
/* alloc message to insert proto task msg queue */
iot_cp_task_msg_post(IOT_CP_TASK_MT_APPDATA,
IOT_CP_TASK_MSG_ID_CMD_HANDLE, send_pkt, IOT_CP_TRANS_DIR_UART);
return ERR_OK;
} else {
iot_cus_printf("[cp][err]no mem, frame len:%d\n", len);
return ERR_FAIL;
}
}
/**
* @brief iot_cp_check_order_closed - check order whether closed
*/
static void iot_cp_check_order_closed(void)
{
uint8_t plug_id;
for (plug_id = 0; plug_id < CP_SOCKET_ID_ALL; plug_id++) {
iot_cus_printf("%s %d checked=%d end_type=%d\n", __FUNCTION__, plug_id,
flash_info->his_info[plug_id].checked,
flash_info->his_info[plug_id].end_type);
if (flash_info->his_info[plug_id].checked == IOT_CP_ORDER_UNCHECK &&
(flash_info->his_info[plug_id].end_type == 0 ||
flash_info->his_info[plug_id].end_type != IOT_CP_END_TPYE_END_PO)) {
/* report close order */
cp_context.plug_info[plug_id].rpt_bitmap |= CP_REPORT_ERR_ON;
cp_context.plug_info[plug_id].rpt_data =
flash_info->his_info[plug_id].end_type | (plug_id << 6);
iot_cp_task_msg_post(IOT_CP_TASK_MT_REPORT,
IOT_CP_CMD_RPT_ERR_ABORT, NULL,
cp_context.plug_info[plug_id].rpt_data);
}
}
}
static uint8_t iot_cp_default_param_init(void)
{
uint8_t plug_num;
flash_info = &cp_context.flash_info;
/* load flash information */
iot_proto_custom_pib_info_load((void*)flash_info, sizeof(cp_flash_info_t));
/* set to cp socket */
if (flash_info->th_eigenvalue != CP_THESHOLD_EIGENVALUE) {
/* set default threshold value to cp socket */
iot_cp_set_threshold_value((cp_plug_threshold_info_t*)&def_cp_th,
CP_SOCKET_ID_ALL);
}
for (plug_num = 0; plug_num < CP_SOCKET_ID_ALL; plug_num++) {
iot_cp_send_param_cmd_to_meter_task(CP_SOCKET_OP_CONFIG, plug_num);
}
iot_cp_check_order_closed();
return ERR_OK;
}
/* initialize GPIO hardware */
static uint8_t iot_cp_gpio_init(void)
{
#if USE_N11_GPRS == 0
if (ERR_OK != iot_gpio_open_as_output(IOT_CP_GPIO_RELAY1)) {
iot_cus_printf("[cp]open gpio%lu as output fail\n", IOT_CP_GPIO_RELAY1);
}
if (ERR_OK != iot_gpio_open_as_output(IOT_CP_GPIO_MOC1)) {
iot_cus_printf("[cp]open gpio%lu as output fail\n", IOT_CP_GPIO_MOC1);
}
if (ERR_OK != iot_gpio_open_as_output(IOT_CP_GPIO_RELAY2)) {
iot_cus_printf("[cp]open gpio%lu as output fail\n", IOT_CP_GPIO_RELAY1);
}
if (ERR_OK != iot_gpio_open_as_output(IOT_CP_GPIO_MOC2)) {
iot_cus_printf("[cp]open gpio%lu as output fail\n", IOT_CP_GPIO_MOC1);
}
if (ERR_OK != iot_gpio_open_as_output(IOT_CP_GPIO_RELAY3)) {
iot_cus_printf("[cp]open gpio%lu as output fail\n", IOT_CP_GPIO_RELAY1);
}
if (ERR_OK != iot_gpio_open_as_output(IOT_CP_GPIO_MOC3)) {
iot_cus_printf("[cp]open gpio%lu as output fail\n", IOT_CP_GPIO_MOC1);
}
if (ERR_OK != iot_gpio_open_as_output(IOT_CP_GPIO_RELAY4)) {
iot_cus_printf("[cp]open gpio%lu as output fail\n", IOT_CP_GPIO_RELAY1);
}
if (ERR_OK != iot_gpio_open_as_output(IOT_CP_GPIO_MOC4)) {
iot_cus_printf("[cp]open gpio%lu as output fail\n", IOT_CP_GPIO_MOC1);
}
if (ERR_OK != iot_gpio_open_as_output(IOT_CP_GPIO_NRESET)) {
iot_cus_printf("[cp]open gpio%lu as output fail\n", IOT_CP_GPIO_NRESET);
}
if (ERR_OK != iot_gpio_open_as_output(IOT_CP_GPIO_PKEY)) {
iot_cus_printf("[cp]open gpio%lu as output fail\n", IOT_CP_GPIO_PKEY);
}
if (ERR_OK != iot_gpio_open_as_output(IOT_CP_GPIO_LED)) {
iot_cus_printf("[cp]open gpio%lu as output fail\n", IOT_CP_GPIO_LED);
}
iot_cp_delay_time(IOT_CP_SWITCH_DELAY*2);
iot_gpio_value_set(IOT_CP_GPIO_NRESET, IOT_CP_GPIO_OUPUT_LOW);
iot_gpio_value_set(IOT_CP_GPIO_PKEY, IOT_CP_GPIO_OUPUT_LOW);
iot_cp_delay_time(IOT_CP_SWITCH_DELAY*2);
iot_gpio_value_set(IOT_CP_GPIO_MOC1, IOT_CP_GPIO_OUPUT_LOW);
iot_gpio_value_set(IOT_CP_GPIO_RELAY1, IOT_CP_GPIO_OUPUT_LOW);
iot_gpio_value_set(IOT_CP_GPIO_MOC2, IOT_CP_GPIO_OUPUT_LOW);
iot_gpio_value_set(IOT_CP_GPIO_RELAY2, IOT_CP_GPIO_OUPUT_LOW);
iot_gpio_value_set(IOT_CP_GPIO_MOC3, IOT_CP_GPIO_OUPUT_LOW);
iot_gpio_value_set(IOT_CP_GPIO_RELAY3, IOT_CP_GPIO_OUPUT_LOW);
iot_gpio_value_set(IOT_CP_GPIO_MOC4, IOT_CP_GPIO_OUPUT_LOW);
iot_gpio_value_set(IOT_CP_GPIO_RELAY4, IOT_CP_GPIO_OUPUT_LOW);
iot_gpio_value_set(IOT_CP_GPIO_PKEY, IOT_CP_GPIO_OUPUT_HI);
iot_gpio_value_set(IOT_CP_GPIO_LED, IOT_CP_GPIO_OUPUT_HI);
iot_cp_delay_time(IOT_CP_SWITCH_DELAY*2);
iot_gpio_value_set(IOT_CP_GPIO_LED, IOT_CP_GPIO_OUPUT_LOW);
iot_gpio_value_set(IOT_CP_GPIO_PKEY, IOT_CP_GPIO_OUPUT_LOW);
#endif
return ERR_OK;
}
/**
* @brief iot_cp_set_charge_switch: set charge state, start or stop
* @param plug_id: socket port id, see CP_SOCKET_IDXX,
* @param flag: start or stop flag,
* if set true, start charging,
* if set false, stop charging.
*/
static void iot_cp_set_charge_switch(uint8_t plug_id, bool_t is_on)
{
int32_t hi_low = IOT_CP_GPIO_OUPUT_LOW;
if (is_on) {
hi_low = IOT_CP_GPIO_OUPUT_HI;
} else {
hi_low = IOT_CP_GPIO_OUPUT_LOW;
}
iot_cp_set_moc(plug_id, IOT_CP_GPIO_OUPUT_HI);
iot_cp_delay_time(IOT_CP_SWITCH_DELAY);
if (plug_id == CP_SOCKET_ID_0 || plug_id == CP_SOCKET_ID_ALL)
iot_gpio_value_set(IOT_CP_GPIO_RELAY1, hi_low);
if (plug_id == CP_SOCKET_ID_1 || plug_id == CP_SOCKET_ID_ALL)
iot_gpio_value_set(IOT_CP_GPIO_RELAY2, hi_low);
if (plug_id == CP_SOCKET_ID_2 || plug_id == CP_SOCKET_ID_ALL)
iot_gpio_value_set(IOT_CP_GPIO_RELAY3, hi_low);
if (plug_id == CP_SOCKET_ID_3 || plug_id == CP_SOCKET_ID_ALL)
iot_gpio_value_set(IOT_CP_GPIO_RELAY4, hi_low);
iot_cp_delay_time(IOT_CP_SWITCH_DELAY);
iot_cp_set_moc(plug_id, IOT_CP_GPIO_OUPUT_LOW);
#if (CP_ZC_ENABLE == 0)
/* if zc disabled, inform the lower task immediately, otherwise,
* infor the lower task after the gp timer's ISR handled */
iot_cp_send_relay_state_to_meter_task(plug_id, is_on);
#endif
}
static void iot_cp_start_charging(uint8_t plug_id)
{
iot_cus_printf("plug %d start charging...\n", plug_id);
#if (CP_ZC_ENABLE == 1)
iot_cp_set_switch_change_req(plug_id, true);
#else
iot_cp_set_charge_switch(plug_id, true);
#endif
}
static void iot_cp_stop_charging(uint8_t plug_id)
{
#if (CP_ZC_ENABLE == 1)
iot_cp_set_switch_change_req(plug_id, false);
#else
iot_cp_set_charge_switch(plug_id, false);
#endif
iot_cus_printf("plug %d stop charging...\n", plug_id);
}
/* set RTC */
static void cp_rtc_set(cp_sub_date_t *tm)
{
iot_time_tm_t rtc_tm;
rtc_tm.tm_year = IOT_CP_YEAR_START_FROM + tm->year;
os_mem_cpy(&rtc_tm.tm_mon, &tm->month, sizeof(cp_sub_date_t) -1);
iot_rtc_set(&rtc_tm);
}
/* get RTC */
static void cp_rtc_get(cp_sub_date_t *tm)
{
iot_time_tm_t rtc_tm;
iot_rtc_get(&rtc_tm);
tm->year = (rtc_tm.tm_year - IOT_CP_YEAR_START_FROM) & 0xFF;
os_mem_cpy(&tm->month, &rtc_tm.tm_mon, sizeof(cp_sub_date_t) -1);
}
/**
* @brief cp_calc_weekday() - use Zeller's Rule to calc weekDay on any date
* @param y : year of the date, two digits, year start from 20 century
* @param m : month of the date
* @param d : day of the date
* @return : weekday from 0 to 6
*/
static uint8_t cp_calc_weekday(uint32_t y, uint8_t m, uint8_t d)
{
uint8_t weekday = 0;
/* use Zeller's Rule: Day on any date in the calendar
W=(Y+[Y/4]+[C/4]-2C+[26(M+1)/10]+d-1)%7
W:weekday, C:century, Y:year(two digits), M:month, d:day
*/
weekday = (uint8_t)(y+y/4+20/4-2*20+26*(m+1)/10+d-1)%7;
return weekday;
}
static void cp_rtc_init(void)
{
/* set the RTC to default value: 2019-05-01 00:00:00 wed. */
cp_context.rtc_time.sub_date_t.year = 19;
cp_context.rtc_time.sub_date_t.month = 5;
cp_context.rtc_time.sub_date_t.date = 1;
cp_context.rtc_time.sub_date_t.hour = 0;
cp_context.rtc_time.sub_date_t.min = 0;
cp_context.rtc_time.sub_date_t.sec = 0;
cp_context.rtc_time.week = 3;
cp_rtc_set(&cp_context.rtc_time.sub_date_t);
}
/* initialize the plug's working state*/
static void iot_cp_reinit_work_state(uint8_t plug_id)
{
cp_plug_info_t *plug_info;
plug_info = (cp_plug_info_t*)(&cp_context.plug_info[plug_id]);
if (plug_info->plug_state.plug_in == 0) {
plug_info->plug_state.work_state = IOT_CP_WORK_STATE_IDLE;
} else {
plug_info->plug_state.work_state = IOT_CP_WORK_STATE_OCCUPIED;
}
}
static void iot_cp_stop_charging_due_to_reason(uint8_t plug_id, uint8_t reason)
{
cp_plug_info_t *plug_info;
cp_plug_history_info_t *his_info;
uint32_t cur_ts;
cp_sub_date_t date = { 0 };
uint8_t his_last = 0;
if (plug_id >= CP_SOCKET_ID_MAX) {
return;
}
plug_info = (cp_plug_info_t*)(&cp_context.plug_info[plug_id]);
iot_cus_printf("[cp]plug %d stop_charging, reason:%d\n", plug_id, reason);
if (plug_info->plug_state.work_state != IOT_CP_WORK_STATE_CHARGING) {
if (reason == IOT_CP_END_TPYE_EMERG) {
/* emergence happend, under maintaince */
plug_info->plug_state.work_state = IOT_CP_WORK_STATE_MAINTAIN;
}
iot_cus_printf("[cp][err]plug %d not in charging mode\n", plug_id);
return;
}
if (reason == IOT_CP_END_TPYE_EMERG) {
/* emergence happend, under maintaince */
plug_info->plug_state.work_state = IOT_CP_WORK_STATE_MAINTAIN;
}
if (reason == IOT_CP_END_TPYE_FAULT) {
plug_info->plug_state.work_state = IOT_CP_WORK_STATE_FAULT;
} else if (reason == IOT_CP_END_TPYE_DISCONN) {
/* socket plug out, change state to idle */
plug_info->plug_state.work_state = IOT_CP_WORK_STATE_IDLE;
} else if ((reason == IOT_CP_END_TPYE_CHARGED) ||
(reason == IOT_CP_END_TPYE_END_PO)) {
/* charged over */
plug_info->plug_state.work_state = IOT_CP_WORK_STATE_CHARGED;
}
cur_ts = (uint32_t)(os_boot_time64() / IOT_SECOND_TO_MICROSECOND);
if (cur_ts >= plug_info->new_po_ts) {
plug_info->charg_time = (uint16_t)((cur_ts - plug_info->new_po_ts));
} else {
plug_info->charg_time = (uint16_t)((0xFFFFFFFF -
plug_info->new_po_ts + cur_ts));
}
/* change to minutes */
plug_info->charg_time = plug_info->charg_time / IOT_MINUTE_TO_SECOND;
if (plug_info->plug_state.work_state == IOT_CP_WORK_STATE_CHARGED) {
cp_rtc_get(&plug_info->date_charged) ;
}
if ((plug_info->his_last + 1) >= IOT_CP_MAX_HIS_INFO_CNT) {
plug_info->his_last = 0;
his_last = plug_info->his_last;
} else {
plug_info->his_last++;
his_last = plug_info->his_last;
}
his_info = &cp_context.flash_info.his_info[plug_id];
if (reason == IOT_CP_END_TPYE_END_PO) {
his_info->checked = IOT_CP_ORDER_CHECKED;
}
his_info->record_sn = his_last;
his_info->end_type = reason;
his_info->work_state = plug_info->plug_state.work_state;
his_info->elect_cur = plug_info->elect_cur;
his_info->charg_time = plug_info->charg_time;
his_info->fault_t = plug_info->plug_state.fault_t;
his_info->fault_data = plug_info->plug_state.fault_data;
cp_rtc_get(&date);
cp_context.rtc_time.week = cp_calc_weekday(date.year +
IOT_CP_YEAR_START_FROM, date.month, date.date);
his_info->end_date_t.week = cp_context.rtc_time.week;
os_mem_cpy(&his_info->end_date_t.sub_date_t, &date, sizeof(date));
iot_proto_custom_pib_info_save((void*)flash_info, sizeof(cp_flash_info_t));
plug_info->rpt_cnt = 0 ;
plug_info->rpt_cnt_down = IOT_CP_TASK_REPORT_INTVL_CNT;
if (reason == IOT_CP_END_TPYE_END_PO) {
plug_info->plug_state.work_state = IOT_CP_WORK_STATE_OCCUPIED;
}
plug_info->rpt_data = reason + (plug_id << 6);
/* if ending po cmd received, report msg 60H should not be sent */
if (reason != IOT_CP_END_TPYE_END_PO) {
if (cp_context.is_communication_ok) {
plug_info->rpt_bitmap |= CP_REPORT_ERR_ON;
} else {
//plug_info->rpt_bitmap |= CP_REPORT_HISTORY_ON;
plug_info->rpt_bitmap |= CP_REPORT_ERR_ON;
}
iot_cp_task_msg_post(IOT_CP_TASK_MT_REPORT, IOT_CP_CMD_RPT_ERR_ABORT,
NULL, plug_info->rpt_data);
} else {
plug_info->rpt_bitmap &= CP_REPORT_ERR_OFF;
}
/* switch off the reply */
iot_cp_task_msg_post(IOT_CP_TASK_MT_CHARG_SWITCH,
IOT_CP_TASK_MSG_ID_CHARGE_STOP, NULL, plug_id);
}
static void iot_cp_send_param_cmd_to_meter_task(uint8_t op_code,
uint8_t plug_id)
{
cp_socket_cmd_arg_t *set_cmd = NULL;
cp_socket_cmd_query_param_t *q_param = NULL;
cp_socket_cmd_cfg_param_t *cfg_param = NULL;
uint8_t pkt_len;
iot_pkt_t *t_pkt;
cp_plug_threshold_info_t *th_info;
if ((plug_id >= CP_SOCKET_ID_MAX) || (op_code > CP_SOCKET_OP_MAX)) {
iot_cus_printf("[cp][err]invalid op_code %d or plug_id %d",
op_code, plug_id);
return;
}
pkt_len = sizeof(*set_cmd) + sizeof(*cfg_param);
t_pkt = iot_pkt_alloc(pkt_len, IOT_CP_TASK_ID);
if (NULL == t_pkt) {
iot_cus_printf("[cp][err]alloc pkt failed\n");
IOT_ASSERT(0);
}
iot_pkt_put(t_pkt, sizeof(*set_cmd));
set_cmd = (cp_socket_cmd_arg_t *)iot_pkt_data(t_pkt);
set_cmd->hdr.cid = CP_SOCKET_CID_CONFIG;
set_cmd->hdr.opcode = op_code;
set_cmd->need_ack = 1;
switch (op_code) {
case CP_SOCKET_OP_CONFIG:
{
th_info = &cp_context.flash_info.plug_th[plug_id];
set_cmd->dlen = sizeof(*cfg_param);
cfg_param = (cp_socket_cmd_cfg_param_t *)set_cmd->arg;
cfg_param->plug_id = plug_id;
cfg_param->rated_volt = th_info->rated_volt;
cfg_param->charge_full_i_th = th_info->full_chg_cur_th;
cfg_param->overload_i_th = th_info->over_load_th;
cfg_param->leak_i_th = th_info->leak_cur_protc_th;
cfg_param->discon_cur_th = th_info->discon_cur_th;
cfg_param->alarm.alarm_en_data = th_info->alarm.alarm_en_data;
break;
}
case CP_SOCKET_OP_QUERY:
{
set_cmd->dlen = sizeof(*q_param);
q_param = (cp_socket_cmd_query_param_t *)set_cmd->arg;
q_param->plug_id = plug_id;
break;
}
default:
IOT_ASSERT(0);
}
iot_pkt_put(t_pkt, set_cmd->dlen);
cp_socket_cmd_send_mssage(t_pkt);
}
static void iot_cp_send_cfm_cmd_to_meter_task(uint8_t cid,
uint8_t result, uint8_t reason)
{
cp_socket_cmd_arg_t *set_cmd = NULL;
cp_socket_cmd_confirm_t *cfm = NULL;
uint8_t pkt_len;
iot_pkt_t *t_pkt;
pkt_len = sizeof(*set_cmd) + sizeof(*cfm);
t_pkt = iot_pkt_alloc(pkt_len, IOT_CP_TASK_ID);
if (NULL == t_pkt) {
iot_cus_printf("[cp][err]alloc pkt failed\n");
IOT_ASSERT(0);
}
iot_pkt_put(t_pkt, pkt_len);
set_cmd = (cp_socket_cmd_arg_t *)iot_pkt_data(t_pkt);
set_cmd->dlen = sizeof(*cfm);
set_cmd->hdr.cid = cid;
set_cmd->hdr.opcode = CP_SOCKET_OP_CFM;
set_cmd->need_ack = 0;
cfm = (cp_socket_cmd_confirm_t *)set_cmd->arg;
cfm->result = result;
cfm->reason = reason;
cp_socket_cmd_send_mssage(t_pkt);
}
static void iot_cp_send_relay_state_to_meter_task(uint8_t plug_id,
bool_t state)
{
cp_socket_cmd_arg_t *set_cmd = NULL;
cp_relay_state_t *p_socket;
uint8_t pkt_len;
iot_pkt_t *t_pkt;
if ((plug_id > CP_SOCKET_ID_MAX)) {
iot_cus_printf("[cp][err]invalid plug_id %d", plug_id);
return;
}
pkt_len = sizeof(*set_cmd) + sizeof(*p_socket);
t_pkt = iot_pkt_alloc(pkt_len, IOT_CP_TASK_ID);
if (NULL == t_pkt) {
iot_cus_printf("[cp][err]alloc pkt failed\n");
IOT_ASSERT(0);
}
iot_pkt_put(t_pkt, pkt_len);
set_cmd = (cp_socket_cmd_arg_t *)iot_pkt_data(t_pkt);
set_cmd->hdr.cid = CP_SOCKET_CID_RELAY_STATE;
set_cmd->hdr.opcode = CP_SOCKET_OP_CONFIG;
set_cmd->need_ack = 0;
set_cmd->dlen = sizeof(*p_socket);
p_socket = (cp_relay_state_t *)set_cmd->arg;
p_socket->plug_id = plug_id;
p_socket->relay_state = state;
cp_socket_cmd_send_mssage(t_pkt);
}
/**
* @brief iot_cp_alloc_ge_data_frm_pkt: alloc ge data frame, put the data length
* @param data_len: ge frame total length, fraom head to tail
* @retral: pkt alloced
*/
static iot_pkt_t *iot_cp_alloc_ge_data_frm_pkt( uint16_t data_len)
{
iot_pkt_t *p_pkt = NULL;
ge_frame_data_send_set_subfn160_t *ge_data_frame = NULL;
p_pkt = iot_pkt_alloc(data_len, IOT_CP_TASK_ID);
if (p_pkt != NULL) {
iot_pkt_put(p_pkt, data_len);
ge_data_frame =
(ge_frame_data_send_set_subfn160_t *)iot_pkt_data(p_pkt);
iot_mac_addr_cpy(ge_data_frame->data, plc_context.local_mac);
} else {
iot_cus_printf("[cp]alloc ge160 pkt failed.\n");
IOT_ASSERT(0);
}
return p_pkt;
}
/**
* @brief iot_cp_send_pkt: sending pkt to plc or uart depends on the direction
* @param dst_mac: destination address
* @param ge_pkt: pointer of a GE package
* @param data_len: length of data field
* @param dir: the direction of transmission, PLC or UART or booth
*/
static void iot_cp_send_pkt(uint8_t *dst_mac, iot_pkt_t *ge_pkt, uint8_t dir)
{
ge_frame_data_send_set_subfn160_t *cmd = NULL;
uint8_t *data_ptr = NULL;
uint16_t cal_crc;
uint16_t data_len;
if (!iot_mac_addr_valid (dst_mac)) {
iot_cus_printf("%s invalid dst mac, pkt dropped\n", __FUNCTION__);
iot_pkt_free(ge_pkt);
return;
}
cmd = (ge_frame_data_send_set_subfn160_t *)iot_pkt_data(ge_pkt);
cmd->hdr.hdr.preamble = GE_FRM_PREAMBLE_CODE;
cmd->hdr.hdr.fn = PROTO_GE_PLC_SET_CMD;
cmd->hdr.subfn = PROTO_GE_DATA_CMD;
cmd->hdr.hdr.data_len = iot_pkt_data_len(ge_pkt) + IOT_MAC_ADDR_LEN
- sizeof(ge_frame_data_send_set_subfn160_t) - GE_FRAME_CRC_TAIL_SIZE;
iot_mac_addr_cpy(cmd->dest_mac, dst_mac);
data_len = iot_pkt_data_len(ge_pkt) - GE_FRAME_CRC_TAIL_SIZE;
data_ptr = (uint8_t *)cmd + data_len;
cal_crc = ge_frm_checksum_calc((uint8_t *)cmd, data_len);
*data_ptr++ = (uint8_t)cal_crc;
*data_ptr++ = (uint8_t)(cal_crc >> 8);
*data_ptr = GE_FRM_TAIL_CODE;
iot_cp_task_data_dump(iot_pkt_data(ge_pkt), iot_pkt_data_len(ge_pkt));
/* send data to plc*/
if (dir == IOT_CP_TRANS_DIR_PLC) {
iot_cus_printf("[cp_context]post to GE.\n");
iot_cus_task_message_to_ge(iot_pkt_data(ge_pkt),
iot_pkt_data_len(ge_pkt));
iot_pkt_free(ge_pkt);
/* send data to Uart*/
} else {
iot_cus_printf("[cp_context]post to UART.\n");
#if USE_N11_GPRS
iot_grapp_sendto_mainboard_gprs_fn(ge_pkt);
#else
iot_uart_send(plc_context.uart_h, ge_pkt, NULL);
#endif
}
}
/**
* @brief iot_cp_cmd_set_paramtr_hdl: set charging pile param value.fn:0x01.
* @param data: point to the charging pile command frame.
* @param dir: data from UART and GE needto be handled separately
*/
static void iot_cp_cmd_set_paramtr_hdl(uint8_t *data,uint8_t dir)
{
cp_param_cfg_fn01_t *cmd;
cp_rsp_param_cfg_fn01_t *rsp_cmd;
ge_frame_data_send_set_subfn160_t *ge_data_frame = NULL;
cp_plug_threshold_info_t *th_info;
iot_pkt_t *rsp_pkt = NULL;
uint8_t *cp_data = NULL;
uint8_t *data_ptr = NULL;
uint8_t data_len = 0;
uint8_t plug_num = 0;
uint8_t frame_len = 0;
uint16_t tmp_alarm = 0;
iot_cus_printf("%s, dir:%d\n", __FUNCTION__, dir);
cp_data = data + IOT_MAC_ADDR_LEN ;
cmd = (cp_param_cfg_fn01_t *)cp_data;
if ((cmd->hdr.data_len + CP_FRM_MIN_LEN) != (sizeof(*cmd))) {
iot_cus_printf("%s, cmd len err%d\n", __FUNCTION__, cmd->hdr.data_len);
return;
}
plug_num = cmd->plug_num;
if (plug_num >= IOT_CP_MAX_PLUG_CNT) {
iot_cus_printf("%s, plug_num err%d\n", __FUNCTION__, plug_num);
return;
}
th_info = &flash_info->plug_th[plug_num];
th_info->full_chg_cur_th = cmd->full_chg_cur_th;
data_ptr = (uint8_t *)(&th_info->full_chg_cur_th);
iot_data_reverse(data_ptr, sizeof(th_info->full_chg_cur_th));
th_info->full_chg_cur_tm_th = cmd->full_chg_cur_tm_th;
th_info->over_load_th = cmd->over_load_th;
data_ptr = (uint8_t *)(&th_info->over_load_th);
iot_data_reverse(data_ptr, sizeof(th_info->over_load_th));
th_info->over_load_tm_th = cmd->over_load_tm_th;
data_ptr = (uint8_t *)(&th_info->over_load_tm_th);
iot_data_reverse(data_ptr, sizeof(th_info->over_load_tm_th));
os_mem_cpy(&th_info->leak_cur_protc_th,
&cmd->sub_info.leak_cur_protc_th, sizeof(cp_sub_info_t));
th_info->rated_volt = cmd->rated_volt;
data_ptr = (uint8_t *)(&th_info->rated_volt);
iot_data_reverse(data_ptr, sizeof(th_info->rated_volt));
tmp_alarm = cmd->alarm;
data_ptr = (uint8_t *)(&tmp_alarm);
iot_data_reverse(data_ptr, sizeof(tmp_alarm));
os_mem_cpy(&th_info->alarm, &tmp_alarm, sizeof(uint16_t));
iot_cus_printf("[%s][%d], plug_num:%d rated_volt:%d full_chg_cur_th:%d"
" over_load_th:%d\n", __FUNCTION__, __LINE__,
plug_num, th_info->rated_volt, th_info->full_chg_cur_th,
th_info->over_load_th);
iot_proto_custom_pib_info_save((void*)flash_info, sizeof(cp_flash_info_t));
iot_cp_send_param_cmd_to_meter_task(CP_SOCKET_OP_CONFIG, plug_num);
frame_len = sizeof(*rsp_cmd) + CP_GE_DATA_FRM_MIN_SIZE;
rsp_pkt = iot_cp_alloc_ge_data_frm_pkt(frame_len);
if (rsp_pkt != NULL) {
ge_data_frame =
(ge_frame_data_send_set_subfn160_t *)iot_pkt_data(rsp_pkt);
rsp_cmd = (cp_rsp_param_cfg_fn01_t *)(ge_data_frame->data +
IOT_MAC_ADDR_LEN);
rsp_cmd->result = IOT_RESULT_CONFIG_SUCCESS;
rsp_cmd->plug_num = cmd->plug_num;
rsp_cmd->signal_sn = cmd->signal_sn;
data_len = sizeof(*rsp_cmd) - CP_FRM_MIN_LEN;
iot_cp_frame_fill(cmd->hdr.fn, (uint8_t *)rsp_cmd, data_len, dir);
iot_cp_send_pkt(data, rsp_pkt, dir);
}
}
/**
* @brief iot_cp_cmd_set_rtc_time_hdl: set rtc time fn:0x02
* @param data: point to the charging pile command frame.
* @param dir: data from UART and GE needto be handled separately
*/
static void iot_cp_cmd_set_rtc_time_hdl(uint8_t *data,uint8_t dir)
{
cp_time_cfg_fn02_t *cmd;
cp_rsp_time_cfg_fn02_t *rsp_cmd;
ge_frame_data_send_set_subfn160_t *ge_data_frame = NULL;
iot_pkt_t *rsp_pkt = NULL;
uint8_t *cp_data = NULL;
uint8_t data_len = 0;
uint8_t frame_len = 0;
iot_cus_printf("%s, dir:%d\n", __FUNCTION__, dir);
cp_data = data + IOT_MAC_ADDR_LEN;
cmd = (cp_time_cfg_fn02_t *)cp_data;
if ((cmd->hdr.data_len + CP_FRM_MIN_LEN) != (sizeof(*cmd))) {
iot_cus_printf("%s, cmd len err%d\n", __FUNCTION__, cmd->hdr.data_len);
return;
}
os_mem_cpy(&cp_context.rtc_time, &cmd->date_t, sizeof(cp_date_t));
cp_rtc_set(&cp_context.rtc_time.sub_date_t);
frame_len = sizeof(*rsp_cmd) + CP_GE_DATA_FRM_MIN_SIZE;
rsp_pkt = iot_cp_alloc_ge_data_frm_pkt(frame_len);
if (rsp_pkt != NULL) {
ge_data_frame =
(ge_frame_data_send_set_subfn160_t *)iot_pkt_data(rsp_pkt);
rsp_cmd = (cp_rsp_time_cfg_fn02_t *)(ge_data_frame->data +
IOT_MAC_ADDR_LEN);
rsp_cmd->result = IOT_RESULT_RTC_SUCCESS;
rsp_cmd->signal_sn = cmd->signal_sn;
data_len = sizeof(*rsp_cmd) - CP_FRM_MIN_LEN;
iot_cp_frame_fill(cmd->hdr.fn, (uint8_t *)rsp_cmd, data_len, dir);
iot_cp_send_pkt(data, rsp_pkt, dir);
}
}
/**
* @brief iot_cp_cmd_set_work_mode_hdl: set work mode fn:0x03
* @param data: point to the charging pile command frame.
* @param dir: data from UART and GE needto be handled separately
*/
static void iot_cp_cmd_set_work_mode_hdl(uint8_t *data,uint8_t dir)
{
cp_mode_cfg_fn03_t *cmd;
cp_rsp_mode_cfg_fn03_t *rsp_cmd;
ge_frame_data_send_set_subfn160_t *ge_data_frame = NULL;
iot_pkt_t *rsp_pkt = NULL;
uint8_t *cp_data = NULL;
uint8_t data_len = 0;
uint8_t frame_len = 0;
uint8_t plug_id;
uint8_t result = IOT_RESULT_CONFIG_SUCCESS;
iot_cus_printf("%s, dir:%d\n", __FUNCTION__, dir);
cp_data = data + IOT_MAC_ADDR_LEN;
cmd = (cp_mode_cfg_fn03_t *)cp_data;
if ((cmd->hdr.data_len + CP_FRM_MIN_LEN) != (sizeof(*cmd))) {
iot_cus_printf("%s, cmd len err%d\n", __FUNCTION__, cmd->hdr.data_len);
return;
}
if (cmd->work_mode >= IOT_CP_WORK_MODE_MAX) {
result = IOT_RESULT_RET_ERR_DATA;
} else {
result = IOT_RESULT_CONFIG_SUCCESS;
if (cp_context.work_mode != cmd->work_mode) {
for (plug_id = 0; plug_id < CP_SOCKET_ID_MAX; plug_id++) {
if (cmd->work_mode == IOT_CP_MAINTENANCE_MODE) {
/* stop charging once the cmd received, then send cfm frame */
iot_cp_stop_charging_due_to_reason(plug_id,
IOT_CP_END_TPYE_EMERG);
} else {
iot_cp_reinit_work_state(plug_id);
}
}
cp_context.work_mode = cmd->work_mode;
}
}
frame_len = sizeof(*rsp_cmd) + CP_GE_DATA_FRM_MIN_SIZE;
rsp_pkt = iot_cp_alloc_ge_data_frm_pkt(frame_len);
if (rsp_pkt != NULL) {
ge_data_frame =
(ge_frame_data_send_set_subfn160_t *)iot_pkt_data(rsp_pkt);
rsp_cmd = (cp_rsp_mode_cfg_fn03_t *)(ge_data_frame->data +
IOT_MAC_ADDR_LEN);
rsp_cmd->result = result;
rsp_cmd->signal_sn = cmd->signal_sn;
data_len = sizeof(*rsp_cmd) - CP_FRM_MIN_LEN;
iot_cp_frame_fill(cmd->hdr.fn, (uint8_t *)rsp_cmd, data_len, dir);
iot_cp_send_pkt(data, rsp_pkt, dir);
}
}
/**
* @brief iot_cp_cmd_set_new_po_hdl: set charging pile order fn:0x40
* @param data: point to the charging pile command frame.
* @param dir: data from UART and GE needto be handled separately
*/
static void iot_cp_cmd_set_new_po_hdl(uint8_t *data,uint8_t dir)
{
iot_pkt_t *rsp_pkt = NULL;
cp_plug_info_t *plug_info = NULL;
cp_new_po_cfg_fn40_t *cmd;
cp_plug_history_info_t *his_info = NULL;
cp_rsp_new_po_cfg_fn40_t *rsp_cmd;
ge_frame_data_send_set_subfn160_t *ge_data_frame = NULL;
uint8_t *cp_data = NULL;
uint8_t *data_ptr = NULL;
uint8_t plug_num = 0;
uint8_t data_len = 0;
uint8_t frame_len = 0;
uint8_t reason = IOT_CP_CFG_PO_RET_SUCCESS;
iot_cus_printf("%s, dir:%d\n", __FUNCTION__, dir);
cp_data = data + IOT_MAC_ADDR_LEN;
cmd = (cp_new_po_cfg_fn40_t *)cp_data;
if ((cmd->hdr.data_len + CP_FRM_MIN_LEN) != (sizeof(*cmd))) {
iot_cus_printf("%s, cmd len err%d\n", __FUNCTION__, cmd->hdr.data_len);
return;
}
plug_num = cmd->plug_num;
/* only plugin and no fault happened, setting new po can be successful */
if (cp_context.work_mode == IOT_CP_MAINTENANCE_MODE) {
return;
} else if (plug_num >= IOT_CP_MAX_PLUG_CNT) {
reason = IOT_CP_CFG_PO_RET_ERR_DATA;
} else {
plug_info = (cp_plug_info_t *)(&cp_context.plug_info[plug_num]);
his_info = &cp_context.flash_info.his_info[plug_num];
iot_cus_printf("[cp]his[%d] checked=%d end_type=%d\n", plug_num,
his_info->checked, his_info->end_type);
switch (plug_info->plug_state.work_state) {
case IOT_CP_WORK_STATE_CHARGING:
case IOT_CP_WORK_STATE_MAINTAIN:
{
reason = IOT_CP_CFG_PO_RET_BUSY;
break;
}
case IOT_CP_WORK_STATE_FAULT:
{
reason = IOT_CP_CFG_PO_RET_DEV_FAULT;
break;
}
case IOT_CP_WORK_STATE_IDLE:
{
reason = IOT_CP_CFG_PO_RET_PLUG_OUT;
break;
}
case IOT_CP_WORK_STATE_OCCUPIED:
{
if (his_info->checked == IOT_CP_ORDER_UNCHECK) {
plug_info->rpt_bitmap &= CP_REPORT_ERR_OFF;
his_info->checked = IOT_CP_ORDER_CHECKED;
}
if ((cmd->charge_mode == IOT_CP_CHARGE_MODE_FIX_TIME) ||
(cmd->charge_mode == IOT_CP_CHARGE_MODE_POWER)) {
if (cmd->charge_data == 0) {
reason = IOT_CP_CFG_PO_RET_ERR_DATA;
/* end the po once new po cmd received,
* then save flag to flash */
iot_proto_custom_pib_info_save((void*)flash_info,
sizeof(cp_flash_info_t));
}
}
break;
}
default:
break;
}
iot_cus_printf("%s, now state: %d, return reason:%d\n",
__FUNCTION__, plug_info->plug_state.work_state, reason);
}
frame_len = sizeof(*rsp_cmd) + CP_GE_DATA_FRM_MIN_SIZE;
rsp_pkt = iot_cp_alloc_ge_data_frm_pkt(frame_len);
if (rsp_pkt != NULL) {
ge_data_frame =
(ge_frame_data_send_set_subfn160_t *)iot_pkt_data(rsp_pkt);
rsp_cmd = (cp_rsp_new_po_cfg_fn40_t*)(ge_data_frame->data +
IOT_MAC_ADDR_LEN);
os_mem_cpy(rsp_cmd->po_num, cmd->po_num, CP_PO_NUMBER_SIZE);
rsp_cmd->result = reason;
if (plug_info == NULL) {
rsp_cmd->fault = 0;
} else {
os_mem_cpy(&rsp_cmd->fault, &plug_info->plug_state.fault_t,
sizeof(uint16_t));
data_ptr = (uint8_t *)(&rsp_cmd->fault);
iot_data_reverse(data_ptr, sizeof(rsp_cmd->fault));
}
rsp_cmd->plug_num = cmd->plug_num;
rsp_cmd->signal_sn = cmd->signal_sn;
data_len = sizeof(*rsp_cmd) - CP_FRM_MIN_LEN;
iot_cp_frame_fill(cmd->hdr.fn, (uint8_t *)rsp_cmd, data_len, dir);
iot_cp_send_pkt(data, rsp_pkt, dir);
if (plug_num >= IOT_CP_MAX_PLUG_CNT) {
/* plug num is too big */
return;
}
}
if (reason == IOT_CP_CFG_PO_RET_SUCCESS) {
os_mem_set(his_info, 0 , sizeof(*his_info));
os_mem_cpy(plug_info->po_num, cmd->po_num, CP_PO_NUMBER_SIZE);
plug_info->charge_mode = cmd->charge_mode;
plug_info->charge_data = cmd->charge_data;
data_ptr = (uint8_t *)(&plug_info->charge_data);
iot_data_reverse(data_ptr, sizeof(plug_info->charge_data));
/* record the date when the new po rececived */
cp_rtc_get(&plug_info->date_t);
cp_context.rtc_time.week = cp_calc_weekday(
cp_context.rtc_time.sub_date_t.year + IOT_CP_YEAR_START_FROM,
cp_context.rtc_time.sub_date_t.month,
cp_context.rtc_time.sub_date_t.date);
os_mem_cpy(&his_info->po_num, cmd->po_num, CP_PO_NUMBER_SIZE);
his_info->checked = IOT_CP_ORDER_UNCHECK;
his_info->start_date_t.week = cp_context.rtc_time.week;
os_mem_cpy(&his_info->start_date_t.sub_date_t,
&cp_context.rtc_time.sub_date_t, sizeof(cp_sub_date_t));
his_info->elect_last = plug_info->elect_cur;
iot_proto_custom_pib_info_save(flash_info, sizeof(cp_flash_info_t));
/*timestamp unit is seconds */
plug_info->new_po_ts = (uint32_t)(os_boot_time64() /
IOT_SECOND_TO_MICROSECOND);
plug_info->elect_last = plug_info->elect_cur;
plug_info->elect_cur = 0;
plug_info->early_charg_time = plug_info->charg_time;
plug_info->charg_time = 0;
plug_info->early_elect_last = plug_info->early_elect_cur;
plug_info->early_elect_cur = 0;
iot_cp_task_msg_post(IOT_CP_TASK_MT_CHARG_SWITCH,
IOT_CP_TASK_MSG_ID_CHARGE_START, NULL, plug_num);
plug_info->plug_state.work_state = IOT_CP_WORK_STATE_CHARGING;
}
#if (IOT_CP_SEVER_WR_EN == 1)
else {
os_mem_set(&resp_cmd_60h[plug_num], 0,
sizeof(cp_rpt_charg_abort_fn60_t));
os_mem_cpy(&resp_cmd_60h[plug_num].po_num, cmd->po_num,
CP_PO_NUMBER_SIZE);
resp_cmd_60h[plug_num].signal_sn = cmd->signal_sn;
switch (reason) {
case IOT_CP_CFG_PO_RET_DEV_FAULT:
{
resp_cmd_60h[plug_num].end_type = IOT_CP_END_TPYE_FAULT;
os_mem_cpy(&resp_cmd_60h[plug_num].fault_t,
&plug_info->plug_state.fault_t, sizeof(cp_fault_t));
resp_cmd_60h[plug_num].fault_data =
plug_info->plug_state.fault_data;
break;
}
case IOT_CP_CFG_PO_RET_PLUG_OUT:
{
resp_cmd_60h[plug_num].end_type = IOT_CP_END_TPYE_DISCONN;
break;
}
default:
resp_cmd_60h[plug_num].end_type = IOT_CP_END_TPYE_CHARGED;
break;
}
resp_cmd_60h[plug_num].work_state = plug_info->plug_state.work_state;
resp_cmd_60h[plug_num].plug_num = cmd->plug_num;
rpt_60h_cnt[plug_num] = 0;
is_wr_on |= (1 << plug_num);
iot_cus_printf("[cp]wr enabled %d plug id %d\n", is_wr_on, plug_num);
iot_cp_report_err_abort_for_wr(plug_num);
}
#endif
}
/**
* @brief iot_cp_cmd_set_end_po_hdl: close charging pile order fn:0x41.
* @param data: point to the charging pile command frame.
* @param dir: data from UART and GE needto be handled separately
*/
static void iot_cp_cmd_set_end_po_hdl(uint8_t *data,uint8_t dir)
{
iot_pkt_t *rsp_pkt = NULL;
cp_end_po_cfg_fn41_t *cmd;
cp_plug_history_info_t *his_info = NULL;
cp_rsp_end_po_cfg_fn41_t *rsp_cmd;
ge_frame_data_send_set_subfn160_t *ge_data_frame = NULL;
uint8_t *data_ptr = NULL;
uint8_t *cp_data = NULL;
uint8_t plug_num = 0;
uint8_t data_len = 0;
uint8_t frame_len = 0;
uint8_t result = 0;
iot_cus_printf("%s, dir:%d\n", __FUNCTION__, dir);
if (cp_context.work_mode == IOT_CP_MAINTENANCE_MODE) {
iot_cus_printf("[cp]In maintaince mode, cmd discard!\n");
return;
}
cp_data = data + IOT_MAC_ADDR_LEN;
cmd = (cp_end_po_cfg_fn41_t*)cp_data;
if ((cmd->hdr.data_len + CP_FRM_MIN_LEN) != (sizeof(*cmd))) {
iot_cus_printf("%s, cmd len err%d\n", __FUNCTION__, cmd->hdr.data_len);
return;
}
plug_num = cmd->plug_num ;
if (plug_num >= IOT_CP_MAX_PLUG_CNT){
iot_cus_printf("%s, plug num %d is large than %d\n", __FUNCTION__,
cmd->plug_num, IOT_CP_MAX_PLUG_CNT);
result = IOT_CP_CFG_PO_RET_ERR_DATA;
} else {
his_info = &cp_context.flash_info.his_info[plug_num];
if (0 != os_mem_cmp(his_info->po_num, cmd->po_num, CP_PO_NUMBER_SIZE)) {
result = IOT_CP_CFG_PO_RET_NO_PO;
} else {
result = IOT_CP_CFG_PO_RET_SUCCESS;
iot_cp_stop_charging_due_to_reason(plug_num, IOT_CP_END_TPYE_END_PO);
}
}
frame_len = sizeof(*rsp_cmd) + CP_GE_DATA_FRM_MIN_SIZE;
rsp_pkt = iot_cp_alloc_ge_data_frm_pkt(frame_len);
if (rsp_pkt != NULL) {
ge_data_frame =
(ge_frame_data_send_set_subfn160_t *)iot_pkt_data(rsp_pkt);
rsp_cmd = (cp_rsp_end_po_cfg_fn41_t*)(ge_data_frame->data +
IOT_MAC_ADDR_LEN);
os_mem_cpy(rsp_cmd->po_num, cmd->po_num, CP_PO_NUMBER_SIZE);
rsp_cmd->result = result;
if (his_info == NULL) {
rsp_cmd->early_elect_cur = 0;
rsp_cmd->early_elect_last = 0;
rsp_cmd->early_charg_time = 0;
} else {
rsp_cmd->early_elect_cur = his_info->elect_cur;
data_ptr = (uint8_t *)(&rsp_cmd->early_elect_cur);
iot_data_reverse(data_ptr, sizeof(rsp_cmd->early_elect_cur));
rsp_cmd->early_elect_last = his_info->elect_last;
data_ptr = (uint8_t *)(&rsp_cmd->early_elect_last);
iot_data_reverse(data_ptr, sizeof(rsp_cmd->early_elect_last));
rsp_cmd->early_charg_time = his_info->charg_time;
data_ptr = (uint8_t *)(&rsp_cmd->early_charg_time);
iot_data_reverse(data_ptr, sizeof(rsp_cmd->early_charg_time));
}
rsp_cmd->plug_num = cmd->plug_num;
rsp_cmd->signal_sn = cmd->signal_sn;
data_len = sizeof(*rsp_cmd) - CP_FRM_MIN_LEN;
iot_cp_frame_fill(cmd->hdr.fn, (uint8_t *)rsp_cmd, data_len, dir);
iot_cp_send_pkt(data, rsp_pkt, dir);
}
}
/**
* @brief iot_cp_cmd_set_find_free_hdl: check plug port is free or not, fn:0x42.
* @param data: point to the charging pile command frame.
* @param dir: data from UART and GE needto be handled separately
*/
static void iot_cp_cmd_set_find_free_hdl(uint8_t *data, uint8_t dir)
{
iot_pkt_t *rsp_pkt = NULL;
cp_plug_info_t *plug_info;
cp_search_idle_fn42_t *cmd;
cp_rsp_search_idle_fn42_t *rsp_cmd;
ge_frame_data_send_set_subfn160_t *ge_data_frame = NULL;
uint8_t *cp_data = NULL;
uint8_t plug_num = 0;
uint8_t data_len = 0;
uint8_t frame_len = 0;
iot_cus_printf("%s, dir:%d\n", __FUNCTION__, dir);
cp_data = data + IOT_MAC_ADDR_LEN;
cmd = (cp_search_idle_fn42_t *)cp_data;
if ((cmd->hdr.data_len + CP_FRM_MIN_LEN) != (sizeof(*cmd))) {
iot_cus_printf("%s, cmd len err%d\n", __FUNCTION__, cmd->hdr.data_len);
return;
}
plug_num = cmd->plug_num;
plug_info = (cp_plug_info_t *)(&cp_context.plug_info[plug_num]);
frame_len = sizeof(*rsp_cmd) + CP_GE_DATA_FRM_MIN_SIZE;
rsp_pkt = iot_cp_alloc_ge_data_frm_pkt(frame_len);
if (rsp_pkt != NULL) {
ge_data_frame =
(ge_frame_data_send_set_subfn160_t *)iot_pkt_data(rsp_pkt);
rsp_cmd = (cp_rsp_search_idle_fn42_t *)(ge_data_frame->data +
IOT_MAC_ADDR_LEN);
if (plug_info->plug_state.work_state == IOT_CP_WORK_STATE_IDLE) {
rsp_cmd->result = IOT_RESULT_FIND_FREE_SUCCESS;
} else {
rsp_cmd->result = IOT_RESULT_FIND_FREE_ERR;
}
rsp_cmd->plug_num = cmd->plug_num;
rsp_cmd->signal_sn = cmd->signal_sn;
data_len = sizeof(*rsp_cmd) - CP_FRM_MIN_LEN;
iot_cp_frame_fill(cmd->hdr.fn, (uint8_t *)rsp_cmd, data_len, dir);
iot_cp_send_pkt(data, rsp_pkt, dir);
}
}
/**
* @brief iot_cp_cmd_set_emergent_stop_hdl: stop charging due emergency fn:0x66
* @param data: point to the charging pile command frame.
* @param dir: data from UART and GE needto be handled separately
*/
static void iot_cp_cmd_set_emergent_stop_hdl(uint8_t *data, uint8_t dir)
{
/* stop charging once the cmd received, no response is needed */
cp_rsp_emergency_stop_fn66_t * rsp_cmd;
cp_set_emergency_stop_fn66_t *cmd;
ge_frame_data_send_set_subfn160_t *ge_data_frame;
uint16_t frm_len;
uint8_t data_len;
uint8_t plug_id;
iot_pkt_t *rsp_pkt;
cmd = (cp_set_emergency_stop_fn66_t *)(data + IOT_MAC_ADDR_LEN);
if ((cmd->hdr.data_len + CP_FRM_MIN_LEN) != (sizeof(*cmd))) {
iot_cus_printf("%s, cmd len err%d\n", __FUNCTION__, cmd->hdr.data_len);
return;
}
for (plug_id = 0; plug_id < CP_SOCKET_ID_MAX; plug_id++) {
iot_cp_stop_charging_due_to_reason(plug_id, IOT_CP_END_TPYE_EMERG);
}
cp_context.work_mode = IOT_CP_MAINTENANCE_MODE;
frm_len = sizeof(*rsp_cmd) + CP_GE_DATA_FRM_MIN_SIZE;
rsp_pkt = iot_cp_alloc_ge_data_frm_pkt(frm_len);
if (rsp_pkt != NULL) {
ge_data_frame =
(ge_frame_data_send_set_subfn160_t *)iot_pkt_data(rsp_pkt);
rsp_cmd = (cp_rsp_emergency_stop_fn66_t *)(ge_data_frame->data +
IOT_MAC_ADDR_LEN);
rsp_cmd->result = IOT_RESULT_CONFIG_SUCCESS;
rsp_cmd->signal_sn = cmd->signal_sn;
data_len = sizeof(*rsp_cmd) - CP_FRM_MIN_LEN;
iot_cp_frame_fill(cmd->hdr.fn, (uint8_t *)rsp_cmd, data_len, dir);
iot_cp_send_pkt(data, rsp_pkt, dir);
}
}
/**
* @brief iot_cp_cmd_query_status_hdl: query charging pile status,fn:0x20
* @param data: point to the charging pile command frame.
* @param dir: data from UART and GE needto be handled separately
*/
static void iot_cp_cmd_query_status_hdl(uint8_t *data, uint8_t dir)
{
iot_pkt_t *rsp_pkt = NULL;
cp_plug_info_t *plug_info = NULL;
cp_rsp_sta_status_fn20_t *rsp_cmd;
cp_query_sta_status_fn20_t *cmd;
ge_frame_data_send_set_subfn160_t *ge_data_frame = NULL;
uint8_t *cp_data = NULL;
uint8_t *data_ptr = NULL;
uint8_t data_len = 0;
uint8_t plug_num = 0;
uint8_t frame_len = 0;
iot_cus_printf("%s, dir:%d\n", __FUNCTION__, dir);
cp_data = data + IOT_MAC_ADDR_LEN;
cmd = (cp_query_sta_status_fn20_t *)cp_data;
if ((cmd->hdr.data_len + CP_FRM_MIN_LEN) != (sizeof(*cmd))) {
iot_cus_printf("%s, cmd len err%d\n", __FUNCTION__, cmd->hdr.data_len);
return;
}
plug_num = cmd->plug_num;
if (plug_num < CP_SOCKET_ID_MAX) {
plug_info = (cp_plug_info_t *)(&cp_context.plug_info[plug_num]);
}
frame_len = sizeof(*rsp_cmd) + CP_GE_DATA_FRM_MIN_SIZE;
rsp_pkt = iot_cp_alloc_ge_data_frm_pkt(frame_len);
if (rsp_pkt != NULL) {
ge_data_frame =
(ge_frame_data_send_set_subfn160_t *)iot_pkt_data(rsp_pkt);
rsp_cmd = (cp_rsp_sta_status_fn20_t *)(ge_data_frame->data +
IOT_MAC_ADDR_LEN);
if (plug_info == NULL) {
rsp_cmd->work_state = IOT_CP_WORK_STATE_NOT_SUPPORT;
rsp_cmd->plug_in = 0;
os_mem_set(&rsp_cmd->fault_t, 0, sizeof(cp_fault_t));
} else {
rsp_cmd->work_state = plug_info->plug_state.work_state;
rsp_cmd->plug_in = plug_info->plug_state.plug_in;
data_ptr = (uint8_t *)(&rsp_cmd->plug_in);
iot_data_reverse(data_ptr, sizeof(rsp_cmd->plug_in));
rsp_cmd->fault_t = plug_info->plug_state.fault_t;
data_ptr = (uint8_t *)(&rsp_cmd->fault_t);
iot_data_reverse(data_ptr, sizeof(rsp_cmd->fault_t));
}
rsp_cmd->plug_num = cmd->plug_num;
rsp_cmd->signal_sn = cmd->signal_sn;
data_len = sizeof(*rsp_cmd) - CP_FRM_MIN_LEN;
iot_cp_frame_fill(cmd->hdr.fn, (uint8_t *)rsp_cmd, data_len, dir);
iot_cp_send_pkt(data, rsp_pkt, dir);
}
}
/**
* @brief iot_cp_cmd_query_devic_data_hdl: query charging pile device charging
* data,fn:0x21
* @param data: point to the charging pile command frame.
* @param dir: data from UART and GE needto be handled separately
*/
static void iot_cp_cmd_query_devic_data_hdl(uint8_t *data, uint8_t dir)
{
iot_pkt_t *rsp_pkt = NULL;
cp_plug_info_t *plug_info;
cp_plug_history_info_t *his_info;
cp_rsp_charg_data_fn21_t *rsp_cmd;
cp_query_charg_data_fn21_t *cmd;
ge_frame_data_send_set_subfn160_t *ge_data_frame = NULL;
uint8_t *data_ptr = NULL;
uint8_t *cp_data = NULL;
uint8_t data_len = 0;
uint8_t plug_num = 0;
uint8_t frame_len = 0;
iot_cus_printf("%s, dir:%d\n", __FUNCTION__, dir);
cp_data = data + IOT_MAC_ADDR_LEN;
cmd = (cp_query_charg_data_fn21_t*)cp_data;
if ((cmd->hdr.data_len + CP_FRM_MIN_LEN) != (sizeof(*cmd))) {
iot_cus_printf("%s, cmd len err%d\n", __FUNCTION__, cmd->hdr.data_len);
return;
}
plug_num = cmd->plug_num;
plug_info = (cp_plug_info_t*)(&cp_context.plug_info[plug_num]);
his_info = &cp_context.flash_info.his_info[plug_num];
frame_len = sizeof(*rsp_cmd) + CP_GE_DATA_FRM_MIN_SIZE;
rsp_pkt = iot_cp_alloc_ge_data_frm_pkt(frame_len);
if (rsp_pkt != NULL) {
ge_data_frame =
(ge_frame_data_send_set_subfn160_t *)iot_pkt_data(rsp_pkt);
rsp_cmd = (cp_rsp_charg_data_fn21_t*)(ge_data_frame->data +
IOT_MAC_ADDR_LEN);
os_mem_cpy(rsp_cmd->po_num, his_info->po_num, CP_PO_NUMBER_SIZE);
rsp_cmd->dev_type = plc_context.dev_type;
rsp_cmd->tmperature = plug_info->tmperature;
rsp_cmd->volt = plug_info->volt;
data_ptr = (uint8_t *)(&rsp_cmd->volt);
iot_data_reverse(data_ptr, sizeof(rsp_cmd->volt));
rsp_cmd->current = plug_info->current;
data_ptr = (uint8_t *)(&rsp_cmd->current);
iot_data_reverse(data_ptr, sizeof(rsp_cmd->current));
rsp_cmd->power = plug_info->power;
data_ptr = (uint8_t *)(&rsp_cmd->power);
iot_data_reverse(data_ptr, sizeof(rsp_cmd->power));
rsp_cmd->leak_current= plug_info->leak_current;
data_ptr = (uint8_t *)(&rsp_cmd->leak_current);
iot_data_reverse(data_ptr, sizeof(rsp_cmd->leak_current));
rsp_cmd->freq = plug_info->freq;
data_ptr = (uint8_t *)(&rsp_cmd->freq);
iot_data_reverse(data_ptr, sizeof(rsp_cmd->freq));
rsp_cmd->factor = plug_info->factor;
if(plug_info->plug_state.work_state != IOT_CP_WORK_STATE_CHARGING) {
rsp_cmd->elect_cur = his_info->elect_cur;
data_ptr = (uint8_t *)(&rsp_cmd->elect_cur);
iot_data_reverse(data_ptr, sizeof(rsp_cmd->elect_cur));
rsp_cmd->elect_last = his_info->elect_last;
data_ptr = (uint8_t *)(&rsp_cmd->elect_last);
iot_data_reverse(data_ptr, sizeof(rsp_cmd->elect_last));
rsp_cmd->charg_time = his_info->charg_time;
data_ptr = (uint8_t *)(&rsp_cmd->charg_time);
iot_data_reverse(data_ptr, sizeof(rsp_cmd->charg_time));
os_mem_cpy(&rsp_cmd->sub_date_t.year,
&his_info->end_date_t.sub_date_t.year,sizeof(cp_sub_date_t));
} else {
rsp_cmd->elect_cur = plug_info->elect_cur;
data_ptr = (uint8_t *)(&rsp_cmd->elect_cur);
iot_data_reverse(data_ptr, sizeof(rsp_cmd->elect_cur));
rsp_cmd->elect_last = plug_info->elect_last;
data_ptr = (uint8_t *)(&rsp_cmd->elect_last);
iot_data_reverse(data_ptr, sizeof(rsp_cmd->elect_last));
rsp_cmd->charg_time = plug_info->charg_time;
data_ptr = (uint8_t *)(&rsp_cmd->charg_time);
iot_data_reverse(data_ptr, sizeof(rsp_cmd->charg_time));
cp_rtc_get(&cp_context.rtc_time.sub_date_t);
cp_context.rtc_time.week = cp_calc_weekday(
cp_context.rtc_time.sub_date_t.year + IOT_CP_YEAR_START_FROM,
cp_context.rtc_time.sub_date_t.month,
cp_context.rtc_time.sub_date_t.date);
os_mem_cpy(&rsp_cmd->sub_date_t.year,
&cp_context.rtc_time.sub_date_t.year, sizeof(cp_sub_date_t));
}
rsp_cmd->plug_num = cmd->plug_num;
rsp_cmd->signal_sn = cmd->signal_sn;
data_len = sizeof(*rsp_cmd) - CP_FRM_MIN_LEN;
iot_cp_frame_fill(cmd->hdr.fn, (uint8_t *)rsp_cmd, data_len, dir);
iot_cp_send_pkt(data, rsp_pkt, dir);
}
}
/**
* @brief iot_cp_cmd_query_ver_info_hdl: query charging pile device
* version info,fn:0x22
* @param data: point to the charging pile command frame.
* @param dir: data from UART and GE needto be handled separately
*/
static void iot_cp_cmd_query_ver_info_hdl(uint8_t *data, uint8_t dir)
{
iot_pkt_t *rsp_pkt = NULL;
cp_rsp_ver_info_fn22_t *rsp_cmd;
cp_query_ver_info_fn22_t *cmd;
ge_frame_data_send_set_subfn160_t *ge_data_frame = NULL;
uint8_t *cp_data = NULL;
uint8_t data_len = 0;
uint8_t frame_len = 0;
iot_cus_printf("%s, dir:%d\n", __FUNCTION__, dir);
cp_data = data + IOT_MAC_ADDR_LEN;
cmd = (cp_query_ver_info_fn22_t *)cp_data;
if ((cmd->hdr.data_len + CP_FRM_MIN_LEN) != (sizeof(*cmd))) {
iot_cus_printf("%s, cmd len err%d\n", __FUNCTION__, cmd->hdr.data_len);
return;
}
frame_len = sizeof(*rsp_cmd) + CP_GE_DATA_FRM_MIN_SIZE;
rsp_pkt = iot_cp_alloc_ge_data_frm_pkt(frame_len);
if (rsp_pkt != NULL) {
ge_data_frame =
(ge_frame_data_send_set_subfn160_t *)iot_pkt_data(rsp_pkt);
rsp_cmd = (cp_rsp_ver_info_fn22_t *)(ge_data_frame->data +
IOT_MAC_ADDR_LEN);
rsp_cmd->sw_info = cp_context.sw_info;
rsp_cmd->hw_info = cp_context.hw_info;
rsp_cmd->signal_sn = cmd->signal_sn;
data_len = sizeof(*rsp_cmd) - CP_FRM_MIN_LEN;
iot_cp_frame_fill(cmd->hdr.fn, (uint8_t *)rsp_cmd, data_len, dir);
iot_cp_send_pkt(data, rsp_pkt, dir);
}
}
/**
* @brief iot_cp_cmd_query_paramtr_hdl: query charging pile param, fn:0x23
* @param data: point to the charging pile command frame.
* @param dir: data from UART and GE needto be handled separately
*/
static void iot_cp_cmd_query_paramtr_hdl(uint8_t *data, uint8_t dir)
{
iot_pkt_t *rsp_pkt = NULL;
cp_rsp_cfg_param_fn23_t *rsp_cmd;
cp_query_cfg_param_fn23_t *cmd;
ge_frame_data_send_set_subfn160_t *ge_data_frame = NULL;
cp_plug_threshold_info_t *th_info;
uint8_t *cp_data = NULL;
uint8_t *data_ptr = NULL;
uint8_t plug_num = 0;
uint8_t data_len = 0;
uint8_t frame_len = 0;
iot_cus_printf("%s, dir:%d\n", __FUNCTION__, dir);
cp_data = data + IOT_MAC_ADDR_LEN;
cmd = (cp_query_cfg_param_fn23_t *)cp_data;
if ((cmd->hdr.data_len + CP_FRM_MIN_LEN) != (sizeof(*cmd))) {
iot_cus_printf("%s, cmd len err%d\n", __FUNCTION__, cmd->hdr.data_len);
return;
}
plug_num = cmd->plug_num;
if (plug_num >= IOT_CP_MAX_PLUG_CNT) {
iot_cus_printf("%s, plug_num err%d\n", __FUNCTION__, plug_num);
return;
}
th_info = &flash_info->plug_th[plug_num];
frame_len = sizeof(*rsp_cmd) + CP_GE_DATA_FRM_MIN_SIZE;
rsp_pkt = iot_cp_alloc_ge_data_frm_pkt(frame_len);
if (rsp_pkt != NULL) {
ge_data_frame =
(ge_frame_data_send_set_subfn160_t *)iot_pkt_data(rsp_pkt);
rsp_cmd = (cp_rsp_cfg_param_fn23_t *)(ge_data_frame->data +
IOT_MAC_ADDR_LEN);
rsp_cmd->full_chg_cur_th = th_info->full_chg_cur_th;
data_ptr = (uint8_t *)(&rsp_cmd->full_chg_cur_th);
iot_data_reverse(data_ptr, sizeof(rsp_cmd->full_chg_cur_th));
rsp_cmd->full_chg_cur_tm_th = th_info->full_chg_cur_tm_th;
rsp_cmd->over_load_th = th_info->over_load_th;
data_ptr = (uint8_t *)(&rsp_cmd->over_load_th);
iot_data_reverse(data_ptr, sizeof(rsp_cmd->over_load_th));
rsp_cmd->over_load_tm_th = th_info->over_load_tm_th;
data_ptr = (uint8_t *)(&rsp_cmd->over_load_tm_th);
iot_data_reverse(data_ptr, sizeof(rsp_cmd->over_load_tm_th));
os_mem_cpy(&rsp_cmd->sub_info.leak_cur_protc_th,
&th_info->leak_cur_protc_th, sizeof(cp_sub_info_t));
rsp_cmd->rated_volt = th_info->rated_volt;
data_ptr = (uint8_t *)(&rsp_cmd->rated_volt);
iot_data_reverse(data_ptr, sizeof(rsp_cmd->rated_volt));
//rsp_cmd->alarm = th_info->alarm;
os_mem_cpy(&rsp_cmd->alarm, &th_info->alarm, sizeof(uint16_t));
data_ptr = (uint8_t *)(&rsp_cmd->alarm);
iot_data_reverse(data_ptr, sizeof(rsp_cmd->alarm));
rsp_cmd->plug_num = cmd->plug_num;
rsp_cmd->signal_sn = cmd->signal_sn;
data_len = sizeof(*rsp_cmd) - CP_FRM_MIN_LEN;
iot_cp_frame_fill(cmd->hdr.fn, (uint8_t *)rsp_cmd, data_len, dir);
iot_cp_send_pkt(data, rsp_pkt, dir);
}
}
/**
* @brief iot_cp_cmd_query_time_hdl: query charging pile time, fn:0x24
* @param data: point to the charging pile command frame.
* @param dir: data from UART and GE needto be handled separately
*/
static void iot_cp_cmd_query_time_hdl(uint8_t *data, uint8_t dir)
{
iot_pkt_t *rsp_pkt = NULL;
cp_rsp_sta_time_fn24_t *rsp_cmd;
cp_query_sta_time_fn24_t *cmd;
ge_frame_data_send_set_subfn160_t *ge_data_frame = NULL;
uint8_t *cp_data = NULL;
uint8_t data_len = 0 ;
uint8_t frame_len = 0;
iot_cus_printf("%s, dir:%d\n", __FUNCTION__, dir);
cp_data = data + IOT_MAC_ADDR_LEN;
cmd = (cp_query_sta_time_fn24_t*)cp_data;
if ((cmd->hdr.data_len + CP_FRM_MIN_LEN) != (sizeof(*cmd))) {
iot_cus_printf("%s, cmd len err%d\n", __FUNCTION__, cmd->hdr.data_len);
return;
}
frame_len = sizeof(*rsp_cmd) + CP_GE_DATA_FRM_MIN_SIZE;
rsp_pkt = iot_cp_alloc_ge_data_frm_pkt(frame_len);
if (rsp_pkt != NULL) {
ge_data_frame =
(ge_frame_data_send_set_subfn160_t *)iot_pkt_data(rsp_pkt);
rsp_cmd = (cp_rsp_sta_time_fn24_t*)(ge_data_frame->data +
IOT_MAC_ADDR_LEN);
cp_rtc_get(&cp_context.rtc_time.sub_date_t);
cp_context.rtc_time.week = cp_calc_weekday(
cp_context.rtc_time.sub_date_t.year + IOT_CP_YEAR_START_FROM,
cp_context.rtc_time.sub_date_t.month,
cp_context.rtc_time.sub_date_t.date);
os_mem_cpy(&rsp_cmd->date_t.week, &cp_context.rtc_time.week,
sizeof(cp_date_t));
rsp_cmd->signal_sn = cmd->signal_sn;
data_len = sizeof(*rsp_cmd) - CP_FRM_MIN_LEN;
iot_cp_frame_fill(cmd->hdr.fn, (uint8_t *)rsp_cmd, data_len, dir);
iot_cp_send_pkt(data, rsp_pkt, dir);
}
}
/**
* @brief iot_cp_cmd_query_chag_record_hdl: query charging record history
* charging order data, fn:0x25
* @param data: point to the charging pile command frame.
* @param dir: data from UART and GE needto be handled separately
*/
static void iot_cp_cmd_query_chag_record_hdl(uint8_t *data, uint8_t dir)
{
iot_pkt_t *rsp_pkt = NULL;
cp_plug_info_t *plug_info;
cp_plug_history_info_t *his_info;
cp_rsp_charg_record_fn25_t *rsp_cmd;
cp_query_charg_record_fn25_t *cmd;
ge_frame_data_send_set_subfn160_t *ge_data_frame = NULL;
uint8_t *data_ptr = NULL;
uint8_t *cp_data = NULL;
uint8_t plug_num = 0;
uint8_t data_len = 0;
uint8_t frame_len = 0;
uint8_t record_index;
iot_cus_printf("%s, dir:%d\n", __FUNCTION__, dir);
cp_data = data + IOT_MAC_ADDR_LEN;
cmd = (cp_query_charg_record_fn25_t *)cp_data;
if ((cmd->hdr.data_len + CP_FRM_MIN_LEN) != (sizeof(*cmd))) {
iot_cus_printf("%s, cmd len err%d\n", __FUNCTION__, cmd->hdr.data_len);
return;
}
plug_num = cmd->plug_num;
plug_info = (cp_plug_info_t *)(&cp_context.plug_info[plug_num]);
if (plug_info->his_last > cmd->record_sn) {
record_index = plug_info->his_last - cmd->record_sn;
} else {
record_index = IOT_CP_MAX_HIS_INFO_CNT - cmd->record_sn
+ plug_info->his_last;
}
if (record_index >= IOT_CP_MAX_HIS_INFO_CNT) {
record_index = plug_info->his_last;
}
his_info = &cp_context.flash_info.his_info[plug_num];
frame_len = sizeof(*rsp_cmd) + CP_GE_DATA_FRM_MIN_SIZE;
rsp_pkt = iot_cp_alloc_ge_data_frm_pkt(frame_len);
if (rsp_pkt != NULL) {
ge_data_frame =
(ge_frame_data_send_set_subfn160_t *)iot_pkt_data(rsp_pkt);
rsp_cmd = (cp_rsp_charg_record_fn25_t *)(ge_data_frame->data +
IOT_MAC_ADDR_LEN);
rsp_cmd->record_sn = cmd->record_sn;
os_mem_cpy(rsp_cmd->po_num , his_info->po_num, CP_PO_NUMBER_SIZE);
rsp_cmd->end_type = his_info->end_type;
rsp_cmd->work_state = his_info->work_state;
rsp_cmd->elect_cur = his_info->elect_cur;
data_ptr = (uint8_t *)(&rsp_cmd->elect_cur);
iot_data_reverse(data_ptr, sizeof(rsp_cmd->elect_cur));
rsp_cmd->elect_last = his_info->elect_last;
data_ptr = (uint8_t *)(&rsp_cmd->elect_last);
iot_data_reverse(data_ptr, sizeof(rsp_cmd->elect_last));
rsp_cmd->charg_time = his_info->charg_time;
data_ptr = (uint8_t *)(&rsp_cmd->charg_time);
iot_data_reverse(data_ptr, sizeof(rsp_cmd->charg_time));
rsp_cmd->fault_t = his_info->fault_t ;
data_ptr = (uint8_t *)(&rsp_cmd->fault_t);
iot_data_reverse(data_ptr, sizeof(rsp_cmd->fault_t));
rsp_cmd->fault_data = his_info->fault_data;
data_ptr = (uint8_t *)(&rsp_cmd->fault_data);
iot_data_reverse(data_ptr, sizeof(rsp_cmd->fault_data));
rsp_cmd->plug_num = cmd->plug_num;
rsp_cmd->signal_sn = cmd->signal_sn;
data_len = sizeof(*rsp_cmd) - CP_FRM_MIN_LEN;
iot_cp_frame_fill(cmd->hdr.fn, (uint8_t *)rsp_cmd, data_len, dir);
iot_cp_send_pkt(data, rsp_pkt, dir);
}
}
/**
* @brief iot_cp_cmd_concent_query_data_hdl: concentrator query charging data fn:0x65
* @param data: point to the charging pile command frame.
* @param dir: data from UART and GE needto be handled separately
*/
static void iot_cp_cmd_concent_query_data_hdl(uint8_t *data, uint8_t dir)
{
iot_pkt_t *rsp_pkt = NULL;
cp_plug_info_t *plug_info;
cp_concentrator_query_data_fn65_t *cmd;
ge_frame_data_send_set_subfn160_t *ge_data_frame = NULL;
cp_rsp_concentrator_query_data_fn65_t *rsp_cmd;
uint8_t *data_ptr = NULL;
uint8_t *cp_data = NULL;
uint8_t plug_num = 0;
uint8_t data_len = 0;
uint8_t frame_len = 0;
iot_cus_printf("%s, dir:%d\n", __FUNCTION__, dir);
cp_data = data + IOT_MAC_ADDR_LEN;
cmd = (cp_concentrator_query_data_fn65_t*)cp_data;
if ((cmd->hdr.data_len + CP_FRM_MIN_LEN) != (sizeof(*cmd))) {
iot_cus_printf("%s, cmd len err%d\n", __FUNCTION__, cmd->hdr.data_len);
return;
}
plug_num = cmd->plug_num;
plug_info = (cp_plug_info_t*)(&cp_context.plug_info[plug_num]);
frame_len = sizeof(*rsp_cmd) + CP_GE_DATA_FRM_MIN_SIZE;
rsp_pkt = iot_cp_alloc_ge_data_frm_pkt(frame_len);
if (rsp_pkt != NULL) {
ge_data_frame =
(ge_frame_data_send_set_subfn160_t *)iot_pkt_data(rsp_pkt);
rsp_cmd = (cp_rsp_concentrator_query_data_fn65_t *)(ge_data_frame->data
+ IOT_MAC_ADDR_LEN);
os_mem_cpy(rsp_cmd->po_num , plug_info->po_num, CP_PO_NUMBER_SIZE);
rsp_cmd->dev_type = plc_context.dev_type;;
rsp_cmd->tmperature = plug_info->tmperature;
rsp_cmd->volt = plug_info->volt;
data_ptr = (uint8_t *)(&rsp_cmd->volt);
iot_data_reverse(data_ptr, sizeof(rsp_cmd->volt));
rsp_cmd->current = plug_info->current;
data_ptr = (uint8_t *)(&rsp_cmd->current);
iot_data_reverse(data_ptr, sizeof(rsp_cmd->current));
rsp_cmd->power = plug_info->power;
data_ptr = (uint8_t *)(&rsp_cmd->power);
iot_data_reverse(data_ptr, sizeof(rsp_cmd->power));
rsp_cmd->elect_cur = plug_info->elect_cur;
data_ptr = (uint8_t *)(&rsp_cmd->elect_cur);
iot_data_reverse(data_ptr, sizeof(rsp_cmd->elect_cur));
rsp_cmd->elect_last = plug_info->elect_last;
data_ptr = (uint8_t *)(&rsp_cmd->elect_last);
iot_data_reverse(data_ptr, sizeof(rsp_cmd->elect_last));
rsp_cmd->charg_time = plug_info->charg_time;
data_ptr = (uint8_t *)(&rsp_cmd->charg_time);
iot_data_reverse(data_ptr, sizeof(rsp_cmd->charg_time));
rsp_cmd->leak_current = plug_info->leak_current ;
data_ptr = (uint8_t *)(&rsp_cmd->leak_current);
iot_data_reverse(data_ptr, sizeof(rsp_cmd->leak_current));
rsp_cmd->freq = plug_info->freq;
data_ptr = (uint8_t *)(&rsp_cmd->freq);
iot_data_reverse(data_ptr, sizeof(rsp_cmd->freq));
rsp_cmd->factor = plug_info->factor;
rsp_cmd->plug_num = cmd->plug_num;
rsp_cmd->signal_sn = cmd->signal_sn;
data_len = sizeof(*rsp_cmd) - CP_FRM_MIN_LEN;
iot_cp_frame_fill(cmd->hdr.fn, (uint8_t *)rsp_cmd, data_len, dir);
iot_cp_send_pkt(data, rsp_pkt, dir);
}
}
/**
* @brief iot_cp_cmd_query_meter_data_hdl: query merter data fn:0x80
* @param data: point to the charging pile command frame.
* @param dir: data from UART and GE needto be handled separately
*/
static void iot_cp_cmd_query_meter_data_hdl(uint8_t *data, uint8_t dir)
{
iot_pkt_t *rsp_pkt = NULL;
cp_plug_info_t *plug_info;
cp_query_meter_data_fn80_t *cmd;
ge_frame_data_send_set_subfn160_t *ge_data_frame = NULL;
cp_rsp_meter_data_fn80 *rsp_cmd;
uint8_t *cp_data = NULL;
uint8_t plug_num = 0;
uint8_t data_len = 0;
uint8_t frame_len = 0;
uint8_t *data_ptr = NULL;
iot_cus_printf("%s, dir:%d\n", __FUNCTION__, dir);
cp_data = data + IOT_MAC_ADDR_LEN;
cmd = (cp_query_meter_data_fn80_t*)cp_data;
if ((cmd->hdr.data_len + CP_FRM_MIN_LEN) != (sizeof(*cmd))) {
iot_cus_printf("%s, cmd len err%d\n", __FUNCTION__, cmd->hdr.data_len);
return;
}
plug_num = CP_SOCKET_ID_0;
plug_info = (cp_plug_info_t*)(&cp_context.plug_info[plug_num]);
frame_len = sizeof(*rsp_cmd) + CP_GE_DATA_FRM_MIN_SIZE;
rsp_pkt = iot_cp_alloc_ge_data_frm_pkt(frame_len);
if (rsp_pkt != NULL) {
ge_data_frame =
(ge_frame_data_send_set_subfn160_t *)iot_pkt_data(rsp_pkt);
rsp_cmd = (cp_rsp_meter_data_fn80 *)(ge_data_frame->data
+ IOT_MAC_ADDR_LEN);
rsp_cmd->signal_sn = cmd->signal_sn;
rsp_cmd->volt = plug_info->volt;
data_ptr = (uint8_t *)&rsp_cmd->volt;
iot_data_reverse(data_ptr, sizeof(rsp_cmd->volt));
rsp_cmd->leak_i = plug_info->leak_current;
data_ptr = (uint8_t *)&rsp_cmd->leak_i;
iot_data_reverse(data_ptr, sizeof(rsp_cmd->leak_i));
rsp_cmd->freq = plug_info->freq;
data_ptr = (uint8_t *)&rsp_cmd->freq;
iot_data_reverse(data_ptr, sizeof(rsp_cmd->freq));
for (plug_num = 0; plug_num < CP_SOCKET_ID_MAX; plug_num++) {
plug_info = (cp_plug_info_t*)(&cp_context.plug_info[plug_num]);
rsp_cmd->em_info[plug_num].current = plug_info->current;
data_ptr = (uint8_t *)&rsp_cmd->em_info[plug_num].current;
iot_data_reverse(data_ptr,
sizeof(rsp_cmd->em_info[plug_num].current));
rsp_cmd->em_info[plug_num].power = plug_info->power;
data_ptr = (uint8_t *)&rsp_cmd->em_info[plug_num].power;
iot_data_reverse(data_ptr,
sizeof(rsp_cmd->em_info[plug_num].power));
rsp_cmd->em_info[plug_num].factor = plug_info->factor;
rsp_cmd->em_info[plug_num].incumbent_v =
plug_info->plug_state.incumbent_v;
data_ptr = (uint8_t *)&rsp_cmd->em_info[plug_num].incumbent_v;
iot_data_reverse(data_ptr,
sizeof(rsp_cmd->em_info[plug_num].incumbent_v));
rsp_cmd->em_info[plug_num].work_state =
plug_info->plug_state.work_state;
rsp_cmd->em_info[plug_num].plug_state =
plug_info->plug_state.plug_in;
rsp_cmd->em_info[plug_num].fault = plug_info->plug_state.fault_t;
data_ptr = (uint8_t *)&rsp_cmd->em_info[plug_num].fault;
iot_data_reverse(data_ptr,
sizeof(rsp_cmd->em_info[plug_num].fault));
}
data_len = sizeof(*rsp_cmd) - CP_FRM_MIN_LEN;
iot_cp_frame_fill(cmd->hdr.fn, (uint8_t *)rsp_cmd, data_len, dir);
iot_cp_send_pkt(data, rsp_pkt, dir);
}
}
/**
* @param data: point to the charging pile command frame.
* @param dir: data from UART and GE needto be handled separately
*/
/* report data to monitor once error aborting happened fn=0x60*/
static void iot_cp_cmd_rpt_err_abort_hdl(uint8_t *data, uint8_t dir)
{
cp_plug_info_t *plug_info;
cp_ack_charg_abort_fn60_t *cmd;
uint8_t * cp_data;
cp_data = data + IOT_MAC_ADDR_LEN;
cmd = (cp_ack_charg_abort_fn60_t *)cp_data;
if ((cmd->hdr.data_len + CP_FRM_MIN_LEN) != (sizeof(*cmd))) {
iot_cus_printf("%s, cmd len err%d\n", __FUNCTION__, cmd->hdr.data_len);
return;
}
plug_info = (cp_plug_info_t *)(&cp_context.plug_info[cmd->plug_num]);
if (cmd->result == IOT_RESULT_RET_ERR_DATA) {
iot_cus_printf("report err \n");
} else {
iot_cus_printf("report success plug_info : %d\n", cmd->plug_num);
if (plug_info->plug_state.work_state == IOT_CP_WORK_STATE_CHARGED) {
plug_info->plug_state.work_state = IOT_CP_WORK_STATE_OCCUPIED;
}
/* save checked to falsh */
cp_context.flash_info.his_info[cmd->plug_num].checked =
IOT_CP_ORDER_CHECKED;
iot_proto_custom_pib_info_save((void*)flash_info,
sizeof(cp_flash_info_t));
plug_info->rpt_bitmap &= CP_REPORT_ERR_OFF;
}
}
/**
* @param data: point to the charging pile command frame.
* @param dir: data from UART and GE needto be handled separately
*/
/* report correcting time fn:0x61*/
static void iot_cp_cmd_rpt_query_rtc_hdl(uint8_t *data, uint8_t dir)
{
cp_ack_query_sta_time_fn61_t *cmd;
uint8_t * cp_data;
cp_data = data + IOT_MAC_ADDR_LEN;
cmd = (cp_ack_query_sta_time_fn61_t*)cp_data;
if ((cmd->hdr.data_len + CP_FRM_MIN_LEN) != (sizeof(*cmd))) {
iot_cus_printf("%s, cmd len err%d\n", __FUNCTION__, cmd->hdr.data_len);
return;
}
os_mem_cpy(&cp_context.rtc_time.week, &cmd->date_t.week,
sizeof(cp_date_t));
cp_rtc_set(&cp_context.rtc_time.sub_date_t);
cp_context.rtc_report_cnt = 0;
}
/**
* @param data: point to the charging pile command frame.
* @param dir: data from UART and GE needto be handled separately
*/
/* report node's history info ack fn:0x63 */
static void iot_cp_cmd_rpt_history_data_hdl(uint8_t *data,
uint8_t dir)
{
cp_plug_info_t *plug_info;
cp_ack_history_data_fn63_t *cmd;
uint8_t * cp_data;
cp_data = data + IOT_MAC_ADDR_LEN;
cmd = (cp_ack_history_data_fn63_t *)cp_data;
if ((cmd->hdr.data_len + CP_FRM_MIN_LEN) != (sizeof(*cmd))) {
iot_cus_printf("%s, cmd len err%d\n", __FUNCTION__, cmd->hdr.data_len);
return;
}
plug_info = (cp_plug_info_t *)(&cp_context.plug_info[cmd->plug_num]);
if (cmd->result == IOT_RESULT_RET_ERR_DATA) {
iot_cus_printf("report err \n");
} else {
iot_cus_printf("report success plug_info %d: \n", cmd->plug_num);
plug_info->rpt_bitmap &= CP_REPORT_HISTORY_OFF;
}
}
/**
* @param data: point to the charging pile command frame.
* @param dir: data from UART and GE needto be handled separately
*/
/* query node's parameter fn:0x64*/
static void iot_cp_cmd_rpt_status_change_hdl(uint8_t *data,
uint8_t dir)
{
cp_ack_status_change_fn64_t *cmd;
cmd = (cp_ack_status_change_fn64_t *)(data + IOT_MAC_ADDR_LEN);
if ((cmd->hdr.data_len + CP_FRM_MIN_LEN) != (sizeof(*cmd))) {
iot_cus_printf("%s, cmd len err%d\n", __FUNCTION__, cmd->hdr.data_len);
return;
}
if (cmd->result == IOT_RESULT_RET_ERR_DATA) {
iot_cus_printf("report err\n");
} else {
iot_cus_printf("report success\n");
}
}
/*command handle*/
static iot_cp_handle_t iot_cp_cmd_handle_list[] = {
/* config node's parameter */
{IOT_CP_CMD_SET_PARAMTR, iot_cp_cmd_set_paramtr_hdl},
/* config node's time */
{IOT_CP_CMD_SET_RTC_TIME, iot_cp_cmd_set_rtc_time_hdl},
/* config node's working mode */
{IOT_CP_CMD_SET_WORK_MODE, iot_cp_cmd_set_work_mode_hdl},
/* set up a new order */
{IOT_CP_CMD_SET_NEW_PO, iot_cp_cmd_set_new_po_hdl},
/* close an order */
{IOT_CP_CMD_SET_END_PO, iot_cp_cmd_set_end_po_hdl},
/* find free nodes */
{IOT_CP_CMD_SET_FIND_FREE, iot_cp_cmd_set_find_free_hdl},
/* stop charging due to emergency */
{IOT_CP_CMD_SET_EMERGENT_STOP, iot_cp_cmd_set_emergent_stop_hdl},
/* query node's status */
{IOT_CP_CMD_QUERY_STATUS, iot_cp_cmd_query_status_hdl},
/* query data of charging device */
{IOT_CP_CMD_QUERY_DEVIC_DATA, iot_cp_cmd_query_devic_data_hdl},
/* query node's version info */
{IOT_CP_CMD_QUERY_VER_INFO, iot_cp_cmd_query_ver_info_hdl},
/* query node's parameter */
{IOT_CP_CMD_QUERY_PARAMTR, iot_cp_cmd_query_paramtr_hdl},
/* query node's time */
{IOT_CP_CMD_QUERY_TIME, iot_cp_cmd_query_time_hdl},
/*query the historical charging order*/
{IOT_CP_CMD_QUERY_CHAG_RECORD, iot_cp_cmd_query_chag_record_hdl},
/* concentrator query node's charging data */
{IOT_CP_CMD_CONCENT_QUERY_DATA, iot_cp_cmd_concent_query_data_hdl},
/* query node's meter data */
{IOT_CP_CMD_QUERY_METER_DATA, iot_cp_cmd_query_meter_data_hdl},
/* report data to monitor once error aborting happened */
{IOT_CP_CMD_RPT_ERR_ABORT, iot_cp_cmd_rpt_err_abort_hdl},
/* query correcting time */
{IOT_CP_CMD_RPT_QUERY_RTC, iot_cp_cmd_rpt_query_rtc_hdl},
/* query node's history info */
{IOT_CP_CMD_RPT_HISTORY_DATA, iot_cp_cmd_rpt_history_data_hdl},
/* query node's parameter */
{IOT_CP_CMD_RPT_STATUS_CHANGE, iot_cp_cmd_rpt_status_change_hdl},
};
#define iot_cp_list_size() (sizeof(iot_cp_cmd_handle_list) /\
sizeof(iot_cp_cmd_handle_list[0]))
/*gets the command handle*/
static iot_cp_fn_t iot_cp_cmd_handler_get(uint16_t cmd) {
uint8_t index;
iot_cp_fn_t handle = NULL;
for (index = 0; index < iot_cp_list_size(); index++) {
if (iot_cp_cmd_handle_list[index].cmd == cmd) {
iot_cus_printf("[cp]:Get the handle\n");
handle = iot_cp_cmd_handle_list[index].fn_cmd;
break;
}
}
if (handle == NULL) {
iot_cus_printf("[cp]:No command found\n");
}
/* return NULL if no command found. */
return handle;
}
/* for cco: report data to uart once error aborting happened fn: 60H
* for sta: report data to uart and cco
*/
static void iot_cp_report_err_abort_hdl(uint8_t *data , uint8_t fn)
{
cp_plug_info_t *plug_info;
cp_plug_history_info_t *history_info;
cp_rpt_charg_abort_fn60_t *rsp_cmd;
ge_frame_data_send_set_subfn160_t *ge_data_frame = NULL;
iot_pkt_t *rsp_pkt = NULL;
uint8_t *data_ptr = NULL;
uint8_t data_len = 0;
uint8_t frame_len = 0;
uint8_t plug_num = 0;
uint8_t dir;
plug_num = (*data >> 6) & 0xFF;
iot_cus_printf("%s, plug_id %d, abord reason %d, fn:%d\n", __FUNCTION__,
plug_num, *data, fn);
frame_len = sizeof(*rsp_cmd) + CP_GE_DATA_FRM_MIN_SIZE;
rsp_pkt = iot_cp_alloc_ge_data_frm_pkt(frame_len);
if (rsp_pkt != NULL) {
ge_data_frame =
(ge_frame_data_send_set_subfn160_t *)iot_pkt_data(rsp_pkt);
rsp_cmd = (cp_rpt_charg_abort_fn60_t *)(ge_data_frame->data +
IOT_MAC_ADDR_LEN);
plug_info = (cp_plug_info_t*)(&cp_context.plug_info[plug_num]);
history_info = &cp_context.flash_info.his_info[plug_num];
if(plug_info->rpt_cnt == 0){
rsp_cmd->signal_sn = iot_cp_get_send_signal_sn();
plug_info->send_signal_sn[CP_SIGNAL_REPORT_ERR] =
rsp_cmd->signal_sn;
plug_info->send_signal_sn[CP_SIGNAL_REPORT_HISTORY] =
iot_cp_get_send_signal_sn();
} else {
rsp_cmd->signal_sn =
plug_info->send_signal_sn[CP_SIGNAL_REPORT_ERR];
}
os_mem_cpy(rsp_cmd->po_num, history_info->po_num, CP_PO_NUMBER_SIZE);
rsp_cmd->end_type = *data & 0x3F;
rsp_cmd->work_state = history_info->work_state;
rsp_cmd->elect_cur = history_info->elect_cur;
data_ptr = (uint8_t *)(&rsp_cmd->elect_cur);
iot_data_reverse(data_ptr, sizeof(rsp_cmd->elect_cur));
rsp_cmd->elect_last = history_info->elect_last;
data_ptr = (uint8_t *)(&rsp_cmd->elect_last);
iot_data_reverse(data_ptr, sizeof(rsp_cmd->elect_last));
rsp_cmd->charg_time = history_info->charg_time;
data_ptr = (uint8_t *)(&rsp_cmd->charg_time);
iot_data_reverse(data_ptr, sizeof(rsp_cmd->charg_time));
rsp_cmd->fault_t = history_info->fault_t;
data_ptr = (uint8_t *)(&rsp_cmd->fault_t);
iot_data_reverse(data_ptr,sizeof(rsp_cmd->fault_t));
rsp_cmd->fault_data = history_info->fault_data;
data_ptr = (uint8_t *)(&rsp_cmd->fault_data);
iot_data_reverse(data_ptr, sizeof(rsp_cmd->fault_data));
rsp_cmd->plug_num = plug_num;
data_len = sizeof(*rsp_cmd) - CP_FRM_MIN_LEN;
/* send to uart */
if (plc_context.work_role == CP_PLC_ROLE_CCO) {
dir = IOT_CP_TRANS_DIR_UART;
} else {
dir = IOT_CP_TRANS_DIR_PLC;
}
iot_cp_frame_fill(fn, (uint8_t *)rsp_cmd, data_len, dir);
iot_cp_send_pkt(plc_context.cco_mac, rsp_pkt, dir);
}
}
/* query correcting time fn: 61H */
static void iot_cp_report_query_rtc_hdl(uint8_t *data , uint8_t fn)
{
iot_pkt_t *rsp_pkt = NULL;
cp_rpt_query_sta_time_fn61_t *rsp_cmd;
ge_frame_data_send_set_subfn160_t *ge_data_frame = NULL;
uint8_t data_len = 0;
uint8_t frame_len = 0;
uint8_t dir;
(void)data;
iot_cus_printf("%s, fn:%d\n", __FUNCTION__, fn);
frame_len = sizeof(*rsp_cmd) + CP_GE_DATA_FRM_MIN_SIZE;
rsp_pkt = iot_cp_alloc_ge_data_frm_pkt(frame_len);
if (rsp_pkt != NULL) {
ge_data_frame =
(ge_frame_data_send_set_subfn160_t *)iot_pkt_data(rsp_pkt);
iot_cus_printf("query_rtc ge_data_frame2=%X\n", ge_data_frame);
rsp_cmd = (cp_rpt_query_sta_time_fn61_t *)(ge_data_frame->data +
IOT_MAC_ADDR_LEN);
rsp_cmd->signal_sn = iot_cp_get_send_signal_sn();
data_len = sizeof(*rsp_cmd) - CP_FRM_MIN_LEN;
if (plc_context.work_role == CP_PLC_ROLE_CCO) {
dir = IOT_CP_TRANS_DIR_UART;
} else {
dir = IOT_CP_TRANS_DIR_PLC;
}
iot_cp_frame_fill(fn, (uint8_t *)rsp_cmd, data_len, dir);
iot_cp_send_pkt(plc_context.cco_mac, rsp_pkt, dir);
cp_context.rtc_report_cnt++;
}
}
/* report history data fn: 63H */
static void iot_cp_report_history_data_hdl(uint8_t *data ,uint8_t fn)
{
#if 0
iot_pkt_t *rsp_pkt = NULL;
cp_plug_info_t *plug_info;
cp_plug_history_info_t *his_info;
cp_rpt_history_data_fn63_t *rsp_cmd;
ge_frame_data_send_set_subfn160_t *ge_data_frame = NULL;
uint8_t *data_ptr = NULL;
uint8_t plug_num = 0;
uint8_t data_len = 0;
uint8_t frame_len = 0;
uint8_t dir;
plug_num = (*data >> 6) & 0xFF;
iot_cus_printf("%s, fn:%d\n", __FUNCTION__, fn);
plug_info = (cp_plug_info_t *)(&cp_context.plug_info[plug_num]);
his_info = &cp_context.flash_info.his_info[plug_num];
frame_len = sizeof(*rsp_cmd) + CP_GE_DATA_FRM_MIN_SIZE;
rsp_pkt = iot_cp_alloc_ge_data_frm_pkt(frame_len);
if (rsp_pkt != NULL) {
ge_data_frame =
(ge_frame_data_send_set_subfn160_t *)iot_pkt_data(rsp_pkt);
rsp_cmd = (cp_rpt_history_data_fn63_t*)(ge_data_frame->data +
IOT_MAC_ADDR_LEN);
rsp_cmd->signal_sn =
plug_info->send_signal_sn[CP_SIGNAL_REPORT_HISTORY];
os_mem_cpy(rsp_cmd->po_num, his_info->po_num, CP_PO_NUMBER_SIZE);
rsp_cmd->end_type = his_info->end_type;
rsp_cmd->charg_time = his_info->charg_time;
data_ptr = (uint8_t *)(&rsp_cmd->charg_time);
iot_data_reverse(data_ptr, sizeof(rsp_cmd->charg_time));
rsp_cmd->elect_cur = his_info->elect_cur;
data_ptr = (uint8_t *)(&rsp_cmd->elect_cur);
iot_data_reverse(data_ptr, sizeof(rsp_cmd->elect_cur));
rsp_cmd->elect_last = his_info->elect_last;
data_ptr = (uint8_t *)(&rsp_cmd->elect_last);
iot_data_reverse(data_ptr, sizeof(rsp_cmd->elect_last));
os_mem_cpy(&his_info->start_date_t.sub_date_t.year,
&plug_info->date_t.year,sizeof(cp_sub_date_t));
os_mem_cpy(&rsp_cmd->date_t.year,
&his_info->start_date_t.sub_date_t.year, sizeof(cp_sub_date_t));
rsp_cmd->plug_num = plug_num;
data_len = sizeof(*rsp_cmd) - CP_FRM_MIN_LEN;
if (plc_context.work_role == CP_PLC_ROLE_CCO) {
dir = IOT_CP_TRANS_DIR_UART;
} else {
dir = IOT_CP_TRANS_DIR_PLC;
}
iot_cp_frame_fill(fn, (uint8_t *)rsp_cmd, data_len, dir);
iot_cp_send_pkt(plc_context.cco_mac, rsp_pkt, dir);
}
#endif
}
/* report status change fn : 64H */
static void iot_cp_report_status_change_hdl(uint8_t *data ,uint8_t fn)
{
iot_pkt_t *rsp_pkt = NULL;
cp_plug_info_t *plug_info;
cp_rpt_status_change_fn64_t *rsp_cmd;
ge_frame_data_send_set_subfn160_t *ge_data_frame = NULL;
uint8_t *data_ptr = NULL;
uint8_t plug_num = 0;
uint8_t data_len = 0;
uint8_t frame_len = 0;
uint8_t dir;
(void)data;
iot_cus_printf("%s, plug_id %d, fn:%d\n", __FUNCTION__, *data, fn);
plug_num = *data;
/*TODO: get plug_num*/
plug_info = (cp_plug_info_t*)(&cp_context.plug_info[plug_num]);
frame_len = sizeof(*rsp_cmd) + CP_GE_DATA_FRM_MIN_SIZE;
rsp_pkt = iot_cp_alloc_ge_data_frm_pkt(frame_len);
if (rsp_pkt != NULL) {
ge_data_frame =
(ge_frame_data_send_set_subfn160_t *)iot_pkt_data(rsp_pkt);
rsp_cmd = (cp_rpt_status_change_fn64_t*)(ge_data_frame->data +
IOT_MAC_ADDR_LEN);
rsp_cmd->signal_sn = iot_cp_get_send_signal_sn();
rsp_cmd->work_state = plug_info->plug_state.work_state;
rsp_cmd->fault_t = plug_info->plug_state.fault_t;
rsp_cmd->plug_num = plug_num;
data_ptr = (uint8_t *)(&rsp_cmd->fault_t);
iot_data_reverse(data_ptr, sizeof(rsp_cmd->fault_t));
if (plug_info->plug_state.work_state == IOT_CP_WORK_STATE_CHARGING) {
os_mem_cpy(rsp_cmd->po_num, plug_info->po_num, CP_PO_NUMBER_SIZE);
} else {
os_mem_set(rsp_cmd->po_num, 0, CP_PO_NUMBER_SIZE);
}
data_len = sizeof(*rsp_cmd) - CP_FRM_MIN_LEN;
if (plc_context.work_role == CP_PLC_ROLE_CCO) {
dir = IOT_CP_TRANS_DIR_UART;
} else {
dir = IOT_CP_TRANS_DIR_PLC;
}
iot_cp_frame_fill(fn,(uint8_t *)rsp_cmd, data_len, dir);
iot_cp_send_pkt(plc_context.cco_mac, rsp_pkt, dir);
}
}
static iot_cp_handle_t iot_cp_report_handle_list[] = {
/* report data to monitor once error aborting happened */
{IOT_CP_CMD_RPT_ERR_ABORT, iot_cp_report_err_abort_hdl},
/* query correcting time */
{IOT_CP_CMD_RPT_QUERY_RTC, iot_cp_report_query_rtc_hdl},
/* query node's history info */
{IOT_CP_CMD_RPT_HISTORY_DATA, iot_cp_report_history_data_hdl},
/* query node's parameter */
{IOT_CP_CMD_RPT_STATUS_CHANGE, iot_cp_report_status_change_hdl},
};
#define iot_cp_report_list_size() (sizeof(iot_cp_report_handle_list) /\
sizeof(iot_cp_report_handle_list[0]))
/*gets the report handle*/
static iot_cp_fn_t iot_cp_report_handler_get(uint16_t cmd) {
uint8_t index;
iot_cp_fn_t handle = NULL;
for (index = 0; index < iot_cp_report_list_size(); index++) {
if (iot_cp_report_handle_list[index].cmd == cmd) {
iot_cus_printf("[cp]:Get the report handle\n");
handle = iot_cp_report_handle_list[index].fn_cmd;
break;
}
}
if (handle == NULL) {
iot_cus_printf("[cp]:No report found\n");
}
/* return NULL if no found. */
return handle;
}
static void iot_cp_task_handle_report_msg(iot_cp_task_msg_t *msg)
{
iot_cp_fn_t handler = NULL;
iot_cus_printf("get report message fn:%d\n",msg->task_msg.id);
handler = iot_cp_report_handler_get(msg->task_msg.id);
if (NULL != handler) {
handler((uint8_t *)&msg->data2, msg->task_msg.id);
}
return ;
}
/**
* CP frame Check:
* if the CP frame is local , a handle is executed
* if not, it will be sent to UART or PLC.
* @param pkt:
* @param dir: where the frame come from
*/
static void iot_cp_cmd_handle(iot_pkt_t *pkt, uint32_t dir)
{
uint16_t data_len;
uint16_t cp_data_len;
uint8_t vaild_len = 0;
uint8_t *data;
uint8_t *cp_data;
uint8_t dst_mac[IOT_MAC_ADDR_LEN] = { 0 };
iot_cp_fn_t handler = NULL;
cp_frm_hdr_t *hdr = NULL;
iot_pkt_t *p_pkt = NULL;
ge_frame_data_send_set_subfn160_t *frame = NULL;
data = iot_pkt_data(pkt);
data_len = (uint16_t)iot_pkt_data_len(pkt) ;
if ((data_len - IOT_MAC_ADDR_LEN * 2) < CP_FRM_MIN_LEN) {
iot_pkt_free(pkt);
iot_cus_printf("[cp][err]:get CP handle err\n");
return;
}
iot_mac_addr_cpy(dst_mac, data);
data += IOT_MAC_ADDR_LEN;
data_len -= IOT_MAC_ADDR_LEN;
/* CP frame data offest*/
cp_data = data + IOT_MAC_ADDR_LEN;
cp_data_len = data_len - IOT_MAC_ADDR_LEN;
hdr = iot_get_cpcmd_hdr(cp_data, cp_data_len, &vaild_len);
if (NULL != hdr) {
iot_cp_task_data_dump(iot_pkt_data(pkt), iot_pkt_data_len(pkt));
/* check reply frame */
if (hdr->preamble == CP_FRM_PREAMBLE_REPLY_CODE) {
iot_cus_printf("[cp]reply frame found\n");
hdr->preamble = CP_FRM_PREAMBLE_CODE;
vaild_len = data_len + CP_GE_DATA_FRM_MIN_SIZE - IOT_MAC_ADDR_LEN;
/* a reply frame trans to UART */
p_pkt = iot_cp_alloc_ge_data_frm_pkt(vaild_len);
if (p_pkt != NULL) {
frame =
(ge_frame_data_send_set_subfn160_t *)iot_pkt_data(p_pkt);
os_mem_cpy(frame->data, data, data_len);
iot_cp_send_pkt(dst_mac, p_pkt, IOT_CP_TRANS_DIR_UART);
}
} else {
/* the CP frame is local, a handle will execute */
iot_cus_printf("[cp]data frame's target is local module\n");
handler = iot_cp_cmd_handler_get(hdr->fn);
if (NULL != handler) {
cp_context.is_communication_ok = true;
handler((uint8_t *)data, dir);
}
}
} else {
iot_cus_printf("[cp]cp frame not found \n");
}
iot_pkt_free(pkt);
}
void iot_cp_send_ge_cmd_to_uart(uint8_t *data, uint16_t len)
{
iot_pkt_t *pkt = iot_pkt_alloc(len, IOT_CP_TASK_ID);
if (pkt) {
iot_pkt_put(pkt, len);
os_mem_cpy(iot_pkt_data(pkt), data, len);
iot_cus_printf("[cp]iot_cp_send_ge_cmd_to_uart\n");
#if USE_N11_GPRS
iot_grapp_sendto_mainboard_gprs_fn(pkt);
#else
iot_uart_send(plc_context.uart_h, pkt, NULL);
#endif
} else {
iot_cus_printf("[cp]alloc mem error\n");
}
}
/**
* process GE command frame :
* if it is a GE command frame, STA will record the CC0 MAC
* @param data : queried frames
* @param in_len : length of the queried frame
*/
static void iot_cp_handle_control_cmd_from_ge(uint8_t *data, uint16_t len)
{
ge_frame_conn_ind_rpt_set_subfn9_t *join_ind = NULL;
ge_extend_fn_hdr_t *frm_hdr;
ge_frame_boot_ready_id_set_subfn24_t *get_local_addr =NULL;
bool_t report_to_uart = true;
frm_hdr = (ge_extend_fn_hdr_t *)data;
if (frm_hdr->hdr.fn == PROTO_GE_PLC_SET_CMD) {
switch (frm_hdr->subfn) {
case PROTO_CONN_IND_RPT_CMD:
{
// handle sta join in
if (plc_context.work_role == CP_PLC_ROLE_STA) {
join_ind = (ge_frame_conn_ind_rpt_set_subfn9_t *)data;
iot_mac_addr_cpy(plc_context.cco_mac, join_ind->mac);
plc_context.plc_state = CP_NET_STATUS_ONLINE;
if (cp_context.is_communication_ok == false) {
cp_context.is_communication_ok = true;
}
}
break;
}
case PROTO_DISCONN_IND_RPT_CMD:
{
if (plc_context.work_role == CP_PLC_ROLE_STA) {
plc_context.plc_state = CP_NET_STATUS_OFFLINE;
}
break;
}
case PROTO_BOOT_READY_ID_CMD:
{
get_local_addr = (ge_frame_boot_ready_id_set_subfn24_t *)data;
if (iot_mac_addr_valid(get_local_addr->local_mac)) {
iot_mac_addr_cpy(plc_context.local_mac,
get_local_addr->local_mac);
}
if (plc_context.work_role == CP_PLC_ROLE_CCO) {
iot_mac_addr_cpy(plc_context.cco_mac,
get_local_addr->local_mac);
} else {
if (iot_mac_addr_valid(get_local_addr->cco_mac)) {
iot_mac_addr_cpy(plc_context.cco_mac,
get_local_addr->cco_mac);
}
}
iot_cp_task_msg_post(IOT_CP_TASK_MT_REPORT,
IOT_CP_CMD_RPT_QUERY_RTC, NULL, 0);
break;
}
default:
break;
}
} else if (frm_hdr->hdr.fn == PROTO_GE_PLC_RESP_CMD) {
switch (frm_hdr->subfn) {
case PROTO_LOCAL_MAC_RESP_CMD:
{
ge_frame_local_mac_resp_subfn1_t *local_mac_resp =
(ge_frame_local_mac_resp_subfn1_t *)data;
iot_mac_addr_cpy(plc_context.local_mac, local_mac_resp->mac);
break;
}
case PROTO_MODULE_INFO_RESP_CMD:
{
ge_frame_module_info_resp_subfn18_t *module_info_resp =
(ge_frame_module_info_resp_subfn18_t *)data;
iot_mac_addr_cpy(plc_context.local_mac, module_info_resp->mac);
break;
}
default:
break;
}
}
if (report_to_uart) {
iot_cp_send_ge_cmd_to_uart(data, len);
}
}
/**
* @brief iot_cp_task_plc_msg_process() - post msg to handle GE frame from PLC.
* @p_pkt_frame : pointer of frame data.
*/
uint32_t iot_cp_task_plc_msg_process(iot_pkt_t *p_pkt_frame)
{
iot_cp_task_msg_post(IOT_CP_TASK_MT_APPDATA,
IOT_CP_TASK_MSG_ID_CMD_HANDLE, p_pkt_frame, IOT_CP_TRANS_DIR_PLC);
return ERR_OK;
}
static void iot_cp_task_handle_status_update(void)
{
uint8_t i;
uint32_t cur_ts;
cp_plug_info_t *plug_info;
static uint8_t led_cnt = 0;
static bool_t led_on = 0;
led_cnt++;
if (led_cnt >= 3) {
led_cnt = 0;
if (led_on == true) {
iot_gpio_value_set(IOT_CP_GPIO_LED, IOT_CP_GPIO_OUPUT_HI);
led_on = false;
} else {
iot_gpio_value_set(IOT_CP_GPIO_LED, IOT_CP_GPIO_OUPUT_LOW);
led_on = true;
}
}
cp_context.query_rtc_cnt++;
/* query RTC every 100*IOT_CP_TASK_QUERY_RTC_INTVL_CNT ms*/
if (cp_context.query_rtc_cnt >= IOT_CP_TASK_QUERY_RTC_INTVL_CNT) {
if(cp_context.rtc_report_cnt == IOT_CP_TASK_RPT_RTC_MAX_CNT){
//cp_context.communication_states = false;
cp_context.rtc_report_cnt = 0;
}
iot_cp_task_msg_post(IOT_CP_TASK_MT_REPORT,IOT_CP_CMD_RPT_QUERY_RTC,
NULL, 0 );
cp_context.query_rtc_cnt = 0;
}
for (i = 0; i < CP_SOCKET_ID_ALL; i++) {
iot_cp_report_err_abort_for_wr(i);
plug_info = (cp_plug_info_t *)(&cp_context.plug_info[i]);
if (plug_info->plug_state.work_state == IOT_CP_WORK_STATE_CHARGING) {
cur_ts = (uint32_t)(os_boot_time64() / IOT_SECOND_TO_MICROSECOND);
if (cur_ts >= plug_info->new_po_ts) {
plug_info->charg_time = (uint16_t)(cur_ts -
plug_info->new_po_ts);
} else {
plug_info->charg_time = (uint16_t)(0xFFFFFFFF -
plug_info->new_po_ts + cur_ts);
}
/* change to minutes */
plug_info->charg_time =
plug_info->charg_time / IOT_MINUTE_TO_SECOND;
}
cp_context.flash_info.his_info[i].charg_time = plug_info->charg_time;
cp_context.flash_info.his_info[i].elect_cur = plug_info->elect_cur;
/* check the charging mode */
switch (plug_info->charge_mode) {
case IOT_CP_CHARGE_MODE_TIME:
case IOT_CP_CHARGE_MODE_FIX_TIME:
{
if ((plug_info->charg_time >= plug_info->charge_data) &&
(plug_info->plug_state.work_state ==
IOT_CP_WORK_STATE_CHARGING)) {
iot_cus_printf("mode %d chag data:%d, state: %d, time %d\n",
plug_info->charge_mode, plug_info->charge_data,
plug_info->plug_state.work_state, plug_info->charg_time);
iot_cp_stop_charging_due_to_reason(i, IOT_CP_END_TPYE_CHARGED);
}
break;
}
case IOT_CP_CHARGE_MODE_POWER:
{
if (plug_info->elect_cur >= plug_info->charge_data) {
iot_cp_stop_charging_due_to_reason(i, IOT_CP_END_TPYE_CHARGED);
}
break;
}
case IOT_CP_CHARGE_MODE_FULL_CHARG:
{
//TODO:
break;
}
default:
break;
}
/* check the plug status, report it to platform at regular time or after
* an event happened
*/
cp_context.rpt_intvl_cnt[i]++;
if (plug_info->plug_state.pre_work_state !=
plug_info->plug_state.work_state) {
iot_cus_printf("state changed: pre state %d, new state %d\n",
plug_info->plug_state.pre_work_state,
plug_info->plug_state.work_state);
iot_cp_task_msg_post(IOT_CP_TASK_MT_REPORT,
IOT_CP_CMD_RPT_STATUS_CHANGE, NULL, i);
plug_info->plug_state.pre_work_state =
plug_info->plug_state.work_state;
cp_context.rpt_intvl_cnt[i] = 0;
} else if (cp_context.rpt_intvl_cnt[i] >
IOT_CP_TASK_RPT_STATUS_INTVL_CNT) {
if (plug_info->plug_state.work_state == IOT_CP_WORK_STATE_CHARGING) {
iot_cp_task_msg_post(IOT_CP_TASK_MT_REPORT,
IOT_CP_CMD_RPT_STATUS_CHANGE, NULL, i);
}
cp_context.rpt_intvl_cnt[i] = 0;
/* make some delay for next plug's report */
if (i < CP_SOCKET_ID_3) {
cp_context.rpt_intvl_cnt[i+1] -= os_rand() % 5;
}
}
if ((plug_info->rpt_bitmap != 0) && cp_context.is_communication_ok) {
if (!(plug_info->rpt_cnt_down--)) {
plug_info->rpt_cnt++;
if (plug_info->rpt_bitmap & CP_REPORT_ERR_ON) {
iot_cp_task_msg_post(IOT_CP_TASK_MT_REPORT,
IOT_CP_CMD_RPT_ERR_ABORT, NULL, plug_info->rpt_data);
}
if (plug_info->rpt_bitmap & CP_REPORT_HISTORY_ON) {
iot_cp_task_msg_post(IOT_CP_TASK_MT_REPORT,
IOT_CP_CMD_RPT_HISTORY_DATA, NULL, plug_info->rpt_data);
}
if (plug_info->rpt_cnt == IOT_CP_TASK_RPT_RETRY_MAX_CNT) {
if (plug_info->rpt_bitmap & CP_REPORT_ERR_ON) {
//plug_info->rpt_bitmap |= CP_REPORT_HISTORY_ON;
//plug_info->rpt_bitmap &= CP_REPORT_ERR_OFF;
plug_info->rpt_bitmap |= CP_REPORT_ERR_ON;
}
plug_info->rpt_cnt = 1;
cp_context.is_communication_ok = false;
}
plug_info->rpt_cnt_down = IOT_CP_TASK_REPORT_INTVL_CNT;
}
}
}
}
/**
* @brief iot_cp_task_handle_timer_msg() - process data from local timer.
* @msg : message.
*/
static void iot_cp_task_handle_timer_msg(iot_cp_task_msg_t *msg)
{
switch (msg->task_msg.id) {
case IOT_CP_TASK_MSG_ID_TMR_TIMEOUT:
{
if (plc_context.module_started == false &&
iot_grapp_init_success()) {
plc_context.module_started = true;
os_stop_timer(plc_context.appinit_timer);
iot_grapp_reg_fn_receive_from_ge(HOST_PORT_CUSTOM_TASK,
iot_cp_task_plc_msg_process);
/* start timer for updating local status */
os_start_timer(plc_context.status_update_timer,
IOT_CP_TASK_TIMER_UPDATE_PERIOD);
/* init threshold param */
iot_cp_default_param_init();
/* initialize GPIO hardware*/
iot_cp_gpio_init();
}
break;
}
case IOT_CP_TASK_MSG_ID_TMR_PERIOD:
{
iot_cp_task_handle_status_update();
break;
}
default:
{
iot_cus_printf("[cp_task]unknown timer message id #%d.\n",
msg->task_msg.id);
break;
}
}
return;
}
/**
* @brief iot_cp_process_appdata() - handle app data from uart or plc.
* @p_cp_msg : message.
*/
static uint8_t iot_cp_process_appdata(iot_cp_task_msg_t *p_cp_msg)
{
uint8_t ret = ERR_OK;
iot_pkt_t *p_pkt_frame;
iot_pkt_t *t_pkt;
iot_pkt_t *p_pkt;
ge_extend_fn_hdr_t *ge_hdr;
ge_frame_data_send_set_subfn160_t *frame;
ge_frame_data_send_set_subfn160_t *rep_frame = NULL;
uint8_t *data;
uint8_t *p_buffer;
uint8_t dir;
uint16_t fe_cnt;
uint16_t len = 0;
uint16_t vaild_len = 0;
uint16_t data_len = 0;
uint8_t is_local = true;
p_pkt_frame = (iot_pkt_t *)p_cp_msg->data;
dir = p_cp_msg->data2;
len = (uint16_t)iot_pkt_block_len(p_pkt_frame, IOT_PKT_BLOCK_DATA);
data = iot_pkt_block_ptr(p_pkt_frame, IOT_PKT_BLOCK_DATA);
again:
ge_hdr = iot_cp_ge_frm_check(data, len, &vaild_len);
if (NULL != ge_hdr) {
/* GE data frame (FE-A0) */
if ((ge_hdr->hdr.fn == PROTO_GE_PLC_SET_CMD) &&
(ge_hdr->subfn == PROTO_GE_DATA_CMD)) {
frame = (ge_frame_data_send_set_subfn160_t *)ge_hdr;
if ((frame->hdr.hdr.data_len <= IOT_MAC_ADDR_LEN * 2)) {
iot_cus_printf("[cp]GE data find failed\n");
return ERR_FAIL;
}
iot_cus_printf("[cp]GE data frame found\n");
/* note a local frame trans to GE */
if (dir == IOT_CP_TRANS_DIR_UART) {
if ((!iot_mac_addr_cmp(frame->dest_mac, plc_context.local_mac))
&& (!iot_mac_is_bcast(frame->dest_mac))) {
iot_cus_printf("[cp]:isn't a local frame\n");
is_local = false;
p_pkt = iot_cp_alloc_ge_data_frm_pkt(vaild_len);
if (p_pkt != NULL) {
rep_frame = (ge_frame_data_send_set_subfn160_t *)
iot_pkt_data(p_pkt);
os_mem_cpy(rep_frame->data, frame->data,
frame->hdr.hdr.data_len);
iot_cp_send_pkt(frame->dest_mac, p_pkt,
IOT_CP_TRANS_DIR_PLC);
} else {
iot_cus_printf("[cp]alloc pkt failed @%d.\n" ,__LINE__);
}
}
}
if (is_local) {
data_len = frame->hdr.hdr.data_len;
t_pkt = iot_pkt_alloc(data_len, IOT_CP_TASK_ID);
if (NULL == t_pkt) {
iot_cus_printf("[cp]alloc pkt failed @%d.\n" ,__LINE__);
return ERR_FAIL;
}
p_buffer = iot_pkt_put(t_pkt, data_len);
os_mem_cpy(p_buffer, frame->dest_mac, data_len);
/* get command handler */
iot_cp_cmd_handle(t_pkt, dir);
}
} else {
/* GE command frame */
if (dir == IOT_CP_TRANS_DIR_PLC) {
iot_cp_handle_control_cmd_from_ge((uint8_t *)ge_hdr, vaild_len);
} else if (dir == IOT_CP_TRANS_DIR_UART) {
iot_cus_task_message_to_ge((uint8_t *)ge_hdr, vaild_len);
}
}
fe_cnt = (uint16_t)((uint8_t *)ge_hdr - data);
data = vaild_len + (uint8_t *)ge_hdr;
} else {
iot_cus_printf("[cp]no GE cmd found\n");
goto out;
}
len = len - vaild_len - fe_cnt;
if (len) {
goto again;
}
out:
iot_pkt_free(p_pkt_frame);
return ret;
}
/**
* @brief iot_cp_task_update_state_for_err_event: refesh mster data event post
* by cp socket
* @param plug_id: plug port id
* @param is_err: plug port error happen or resume
*/
static void iot_cp_task_update_state_for_err_event(uint8_t plug_id, bool_t is_err)
{
cp_plug_info_t *pt_info = &cp_context.plug_info[plug_id];
if (is_err) {
if (pt_info->plug_state.work_state == IOT_CP_WORK_STATE_CHARGING) {
iot_cp_stop_charging_due_to_reason(plug_id, IOT_CP_END_TPYE_FAULT);
pt_info->plug_state.restore_state = IOT_CP_END_TPYE_CHARGED;
} else if (pt_info->plug_state.work_state != IOT_CP_WORK_STATE_FAULT) {
pt_info->plug_state.restore_state =
pt_info->plug_state.work_state;
pt_info->plug_state.work_state = IOT_CP_WORK_STATE_FAULT;
}
} else if (pt_info->plug_state.work_state == IOT_CP_WORK_STATE_FAULT) {
pt_info->plug_state.work_state = pt_info->plug_state.restore_state;
}
iot_cus_printf("%s plug id %d, is err %d, new state %d\n", __FUNCTION__,
plug_id, is_err, pt_info->plug_state.work_state);
}
/**
* @briefiot_cp_task_refesh_meter_data_on_event: refesh mster data event post by
* cp socket
* @param plug_id: plug port id
* @param meter_data: socket plug meter data
*/
static void iot_cp_task_refesh_meter_data_on_event(uint8_t plug_id,
cp_socket_plug_meter_data_t *meter_data)
{
cp_plug_info_t *pt_info;
uint8_t reason = ERR_OK;
pt_info = &cp_context.plug_info[plug_id];
if (plug_id > CP_SOCKET_ID_ALL) {
iot_cus_printf("[cp][err]invalid plug id\n");
return;
}
if (reason != ERR_OK) {
iot_cus_printf("%s plug id %d, on state %d, operation canceled for "
"reason %d!\n", __FUNCTION__, plug_id,
pt_info->plug_state.work_state, reason);
return;
}
pt_info->current = meter_data->charging_i;
pt_info->factor = meter_data->pwr_factor;
pt_info->power = meter_data->power_rate;
pt_info->elect_total = meter_data->pwr_consum;
if (pt_info->plug_state.work_state == IOT_CP_WORK_STATE_CHARGING) {
if (meter_data->pwr_consum >= pt_info->elect_init) {
pt_info->elect_cur = meter_data->pwr_consum -
pt_info->elect_init;
} else {
pt_info->elect_cur = 0xFFFFFFFF - pt_info->elect_init +
meter_data->pwr_consum;
}
}
}
/* handle parameter query/set/setting confirm */
void cp_meter_cmd_handle_param(cp_socket_cmd_arg_t *cmd_arg)
{
cp_socket_cmd_confirm_t *cfm;
switch(cmd_arg->hdr.opcode) {
case CP_SOCKET_OP_CFM:
{
cfm = (cp_socket_cmd_confirm_t *)cmd_arg->arg;
if (cfm->result != 0) {
iot_cus_printf("[cp][err]config parameter failed, reason %d\n",
cfm->reason);
}
break;
}
default:
iot_cus_printf("[cp][err]opcode[%d] is not supported\n",
cmd_arg->hdr.opcode);
break;
}
}
/**
* @brief cp_meter_cmd_handle_plug_info: plug info command handle
* @param cmd_arg: argument for charging pile socket command handle
*/
void cp_meter_cmd_handle_plug_info(cp_socket_cmd_arg_t *cmd_arg)
{
cp_socket_cmd_plug_info_resp_t *rsp;
uint8_t plug_cnt, i;
cp_plug_info_t *pt_info = NULL;
cp_socket_plug_info_t *pt_plug = NULL;
uint8_t charg_timeout;
switch(cmd_arg->hdr.opcode) {
case CP_SOCKET_OP_RESPONSE:
{
rsp = (cp_socket_cmd_plug_info_resp_t *)cmd_arg;
plug_cnt = rsp->plug_cnt;
for (i = 0; i < plug_cnt; i++) {
pt_plug = &rsp->plug_info[i];
pt_info = &cp_context.plug_info[pt_plug->plug_id];
pt_info->freq = rsp->freq;
pt_info->volt = rsp->volt;
pt_info->leak_current = rsp->leak_i;
pt_info->factor = pt_plug->meter_data.pwr_factor;
pt_info->current = pt_plug->meter_data.charging_i;
pt_info->power = pt_plug->meter_data.power_rate;
pt_info->plug_state.plug_in = pt_plug->is_plug_in;
if (pt_info->plug_state.fault_t.charg_timeout) {
charg_timeout = 1;
} else {
charg_timeout = 0;
}
os_mem_cpy((uint8_t *)&pt_info->plug_state.fault_t,
(uint8_t *)&pt_plug->fault_status, sizeof(uint16_t));
if (charg_timeout) {
pt_info->plug_state.fault_t.charg_timeout = 1;
} else {
pt_info->plug_state.fault_t.charg_timeout = 0;
}
}
break;
}
default:
iot_cus_printf("[cp][err]opcode[%d] is not supported\n",
cmd_arg->hdr.opcode);
break;
}
}
/**
* @brief cp_meter_cmd_handle_plug_io_indication: plug info command handle
* @param cmd_arg: argument for charging pile socket command handle
*/
void cp_meter_cmd_handle_plug_io_indication(uint8_t plug_id, bool_t is_plug_in,
cp_socket_fault_t *fault_src)
{
bool_t charg_timeout = 0;
cp_plug_info_t *pt_info = &cp_context.plug_info[plug_id];
if (pt_info->plug_state.plug_in != is_plug_in) {
iot_cus_printf("old pulg status %d, new status %d, "
" work state %d\n",pt_info->plug_state.plug_in,
is_plug_in, pt_info->plug_state.work_state);
if (is_plug_in == false) {
switch (pt_info->plug_state.work_state) {
case IOT_CP_WORK_STATE_CHARGING:
{
iot_cp_stop_charging_due_to_reason(plug_id,
IOT_CP_END_TPYE_DISCONN);
break;
}
case IOT_CP_WORK_STATE_CHARGED:
case IOT_CP_WORK_STATE_OCCUPIED:
{
pt_info->plug_state.work_state = IOT_CP_WORK_STATE_IDLE;
break;
}
default:
break;
}
} else {
if (pt_info->plug_state.work_state == IOT_CP_WORK_STATE_IDLE) {
pt_info->plug_state.work_state = IOT_CP_WORK_STATE_OCCUPIED;
} else {
iot_cus_printf("[cp][err]status err\n");
}
}
pt_info->plug_state.plug_in = is_plug_in;
}
charg_timeout = (bool_t)pt_info->plug_state.fault_t.charg_timeout;
os_mem_cpy((uint8_t *)&pt_info->plug_state.fault_t,
(uint8_t *)fault_src, sizeof(uint16_t));
pt_info->plug_state.fault_t.charg_timeout = charg_timeout;
}
void cp_meter_cmd_handle_status_event(cp_socket_cmd_arg_t *cmd_arg)
{
cp_socket_cmd_event_status_t *event =
(cp_socket_cmd_event_status_t *)cmd_arg->arg;
cp_plug_info_t *pt_info;
uint8_t plug_indx;
uint8_t result = ERR_OK;
uint8_t reason = CP_SOCKET_NO_FAIL;
cp_fault_t *p_fault;
bool_t is_err;
uint8_t i;
if (NULL == cmd_arg) {
iot_cus_printf("[cp][err]Invalid arg: NULL!\n");
return;
}
iot_cus_printf("%s opcode %d, evet_id %d, plug id %d\n", __FUNCTION__,
cmd_arg->hdr.opcode, event->event_id, event->plug_id);
switch(cmd_arg->hdr.opcode) {
case CP_SOCKET_OP_INDICATION:
{
for (plug_indx = 0; plug_indx < CP_SOCKET_ID_ALL; plug_indx++) {
if (event->plug_id != CP_SOCKET_ID_ALL &&
event->plug_id != plug_indx) {
continue;
}
pt_info = &cp_context.plug_info[plug_indx];
pt_info->volt = event->volt;
pt_info->leak_current = event->leak_i;
pt_info->plug_state.incumbent_v = (uint16_t)event->incumbent_v;
iot_cp_task_refesh_meter_data_on_event(plug_indx,
&event->meter_data);
switch(event->event_id) {
case CP_SOCKET_EVENT_ID_CHARG_START_CFM:
{
iot_cus_printf("[cp]start charging cmd excuted!\n");
break;
}
case CP_SOCKET_EVENT_ID_CHARG_STOP_CFM:
{
if (pt_info->plug_state.work_state ==
IOT_CP_WORK_STATE_CHARGING &&
pt_info->charge_mode != IOT_CP_CHARGE_MODE_FIX_TIME) {
iot_cp_stop_charging_due_to_reason(plug_indx,
IOT_CP_END_TPYE_CHARGED);
}
break;
}
case CP_SOCKET_EVENT_ID_PLUG_IO:
{
iot_cus_printf("[cp]PLUG_IO plug_indx=%d is_plug_in=%d\n",
plug_indx, event->is_plug_in);
cp_meter_cmd_handle_plug_io_indication(plug_indx,
event->is_plug_in, &event->fault_src);
break;
}
case CP_SOCKET_EVENT_ID_ABNORM_VOLT:
{
p_fault = &pt_info->plug_state.fault_t;
pt_info->volt = event->volt;
p_fault->overvolt = event->fault_src.overvolt;
p_fault->undervolt = event->fault_src.undervolt;
pt_info->current = event->meter_data.charging_i;
pt_info->plug_state.fault_data = pt_info->volt;
iot_cus_printf("[cp]ABNORM_VOLT volt=%d overvolt=%d "
"undervolt=%d current= %d\n", pt_info->volt,
p_fault->overvolt, p_fault->undervolt, pt_info->current);
// send indication to CCO, then stop charging
is_err = (p_fault->undervolt || p_fault->overvolt) ? 1 : 0 ;
for (i = 0; i < CP_SOCKET_ID_ALL; i++) {
iot_cp_task_update_state_for_err_event(i, is_err);
}
break;
}
case CP_SOCKET_EVENT_ID_ABNORM_CURR:
{
p_fault = &pt_info->plug_state.fault_t;
p_fault->overcur = event->fault_src.overcur;
p_fault->overload = event->fault_src.overload;
pt_info->current = event->meter_data.charging_i;
pt_info->power = event->meter_data.power_rate;
if (p_fault->overcur)
pt_info->plug_state.fault_data = pt_info->current;
else if (p_fault->overload) {
pt_info->plug_state.fault_data = pt_info->power;
}
iot_cus_printf("[cp]ABNORM_CURR current=%d power=%d overcur=%d "
"overload=%d\n", pt_info->current, pt_info->power,
p_fault->overcur, p_fault->overload);
/* send indication to CCO, then stop charging. */
is_err = (p_fault->overcur || p_fault->overload) ? 1 : 0 ;
iot_cp_task_update_state_for_err_event(plug_indx, is_err);
break;
}
case CP_SOCKET_EVENT_ID_LEAKAGE:
{
p_fault = &pt_info->plug_state.fault_t;
p_fault->leak_cur_protec = event->fault_src.leak_cur_protec;
pt_info->plug_state.fault_data = pt_info->leak_current;
iot_cus_printf("[cp]LEAKAGE leak_cur_protec=%d\n",
p_fault->leak_cur_protec);
is_err = (p_fault->leak_cur_protec) ? 1 : 0 ;
for (i = 0; i < CP_SOCKET_ID_ALL; i++) {
iot_cp_task_update_state_for_err_event(i, is_err);
}
break;
}
case CP_SOCKET_EVENT_ID_GROUND_ERR:
{
break;
}
default:
result = ERR_FAIL;
reason = CP_SOCKET_FAIL_OPC_NOT_SUPPORT;
break;
}
pt_info++;
}
iot_cp_send_cfm_cmd_to_meter_task(cmd_arg->hdr.cid, result, reason);
break;
}
default:
iot_cus_printf("[cp][err]opcode[%d] is not supported\n",
cmd_arg->hdr.opcode);
break;
}
}
void cp_meter_cmd_handle_data_event(cp_socket_cmd_arg_t *cmd_arg)
{
uint8_t i;
bool_t charg_timeout;
cp_socket_cmd_event_data_rpt_t *rpt;
cp_plug_info_t *pt_info = NULL;
cp_socket_plug_info_t *pt_plug = NULL;
switch(cmd_arg->hdr.opcode) {
case CP_SOCKET_OP_INDICATION:
{
rpt = (cp_socket_cmd_event_data_rpt_t *)cmd_arg->arg;
for (i = 0; i < rpt->plug_cnt; i++) {
pt_plug = &rpt->plug_info[i];
pt_info = &cp_context.plug_info[pt_plug->plug_id];
pt_info->freq = rpt->freq;
pt_info->volt = rpt->volt;
pt_info->leak_current = rpt->leak_i;
pt_info->plug_state.incumbent_v = (uint16_t)pt_plug->incumbent_v;
iot_cp_task_refesh_meter_data_on_event(pt_plug->plug_id,
&pt_plug->meter_data);
#if CP_TASK_DEBUG
iot_cus_printf("[cp_task] %s receive data: freq=%d, volt=%d,"
"leak_current=%d, factor=%d, current=%d, power=%d, plug_in=%d, "
"elect_cur=%d.\n", __FUNCTION__, pt_info->freq,
pt_info->rated_volt, pt_info->leak_current,
pt_info->factor, pt_info->current, pt_info->power,
pt_info->plug_state.plug_in, pt_info->elect_cur);
#endif
charg_timeout = (bool_t)pt_info->plug_state.fault_t.charg_timeout;
os_mem_cpy((uint8_t *)&pt_info->plug_state.fault_t,
(uint8_t *)&pt_plug->fault_status, sizeof(uint16_t));
pt_info->plug_state.fault_t.charg_timeout = charg_timeout;
}
break;
}
default:
break;
}
}
/* The table of energy meter adapter layer command. */
static cp_cmd_meter_handle_t meter_cmd_handle_list[CP_SOCKET_CID_MAX] =
{
cp_meter_cmd_handle_param, /* CP_CID_PARAM */
cp_meter_cmd_handle_plug_info, /* CP_CID_PLUG_INFO */
cp_meter_cmd_handle_status_event, /* CP_CID_STATUS_EVENT */
cp_meter_cmd_handle_data_event, /* CP_CID_DATA_EVENT */
};
static void iot_cp_process_merter_data(iot_cp_task_msg_t *p_cp_msg)
{
uint8_t cid = 0;
if ((NULL == p_cp_msg) || (NULL == p_cp_msg->data)) {
iot_cus_printf("iot_cp_process_merter_data assert\n");
IOT_ASSERT(0);
return;
}
iot_pkt_t *t_pkt = (iot_pkt_t *)p_cp_msg->data;
cp_socket_cmd_arg_t *arg = (cp_socket_cmd_arg_t *)iot_pkt_data(t_pkt);
cid = arg->hdr.cid;
iot_cus_printf("[cp]cmd received: cid=%d, op_code=%d\n", cid,
arg->hdr.opcode);
if (cid >= CP_SOCKET_CID_MAX) {
IOT_ASSERT(0);
return;
}
/* check if cmd_running is false. */
if (cp_context.command.cmd_running == false) {
cp_context.command.cur_cid = arg->hdr;
cp_context.command.cmd_running = true;
cp_context.command.need_ack = (bool_t)arg->need_ack;
cp_context.command.list.handle[cid](arg);
cp_context.command.cmd_running = false;
} else {
iot_cus_printf("[cp][war]pre-cmd is running, new cmd is dropped\n");
}
if (NULL != t_pkt) {
iot_pkt_free(t_pkt);
}
}
static void iot_cp_process_charge_switch(iot_cp_task_msg_t *p_cp_msg)
{
IOT_ASSERT(p_cp_msg);
switch (p_cp_msg->task_msg.id) {
case IOT_CP_TASK_MSG_ID_CHARGE_START:
{
iot_cp_start_charging(p_cp_msg->data2);
break;
}
case IOT_CP_TASK_MSG_ID_CHARGE_STOP:
{
iot_cp_stop_charging(p_cp_msg->data2);;
break;
}
default:
{
iot_pkt_free(p_cp_msg->data);
iot_cus_printf("[cp_task]unknown timer message type #%d.\n",
p_cp_msg->task_msg.type);
break;
}
}
}
/**
* @brief iot_cp_task_msg_exe_func() - messages handle function.
* @param task_h: handle of task.
* @param p_msg: message that will be processed.
*/
void iot_cp_task_msg_exe_func(iot_task_h task_h, iot_task_msg_t *p_msg)
{
iot_cp_task_msg_t *p_cp_msg = (iot_cp_task_msg_t *)p_msg;
switch (p_cp_msg->task_msg.type) {
case IOT_CP_TASK_MT_TIMER:
{
iot_cp_task_handle_timer_msg(p_cp_msg);
break;
}
/* process the data frame */
case IOT_CP_TASK_MT_APPDATA:
{
iot_cp_process_appdata(p_cp_msg);
break;
}
case IOT_CP_TASK_MT_METER:
{
iot_cp_process_merter_data(p_cp_msg);
break;
}
case IOT_CP_TASK_MT_REPORT:
{
iot_cp_task_handle_report_msg(p_cp_msg);
break;
}
case IOT_CP_TASK_MT_CHARG_SWITCH:
{
iot_cp_process_charge_switch(p_cp_msg);
break;
}
default:
{
iot_pkt_free(p_cp_msg->data);
iot_cus_printf("[cp_task]unknown timer message type #%d.\n",
p_cp_msg->task_msg.type);
break;
}
}
iot_task_free_msg(task_h, p_msg);
return;
}
/**
* @brief iot_cp_task_msg_cancel_func() - pull back messages that sent to this
* task.
* @param task_h: handle of task.
* @param p_msg: message that will be pull back.
*/
void iot_cp_task_msg_cancel_func(iot_task_h task_h, iot_task_msg_t *p_msg)
{
iot_cp_task_msg_t *p_cp_msg = (iot_cp_task_msg_t *)p_msg;
switch(p_cp_msg->task_msg.type) {
case IOT_CP_TASK_MT_TIMER:
case IOT_CP_TASK_MT_APPDATA:
{
iot_pkt_free(p_cp_msg->data);
break;
}
default:
{
iot_cus_printf("[cp_task]unknown timer message type #%d.\n",
p_cp_msg->task_msg.type);
break;
}
}
iot_task_free_msg(task_h, p_msg);
return;
}
/* throw out the data frame message */
void iot_cp_task_msg_post(uint16_t msg_type, uint16_t msg_id,
iot_pkt_t *data, uint32_t dir)
{
iot_task_msg_t *msg;
iot_cp_task_msg_t *task_msg;
msg = iot_task_alloc_msg_with_reserved(plc_context.task, 0);
if (NULL == msg) {
if (NULL != data) {
iot_pkt_free(data);
}
iot_cus_printf("[cp]alloc pkt failed @%d.\n" ,__LINE__);
return;
}
task_msg = (iot_cp_task_msg_t*)msg;
task_msg->task_msg.type = msg_type;
task_msg->task_msg.id = msg_id;
task_msg->data = (void*)data;
task_msg->data2 = dir;
iot_task_queue_msg(plc_context.task, &task_msg->task_msg, 0);
return;
}
/**
* @brief iot_cp_task_uart_receive_func() - Uart driver callback function
* when data received.
* @param buffer: pointer of data buffer.
* @param buffer_len: length of data received.
* @param is_full_frame: tell if this is a whole frame in this buffer.
* @param invalid_data_len: length of invalid data received. we ignore this.
*/
void iot_cp_task_uart_receive_func(uint8_t* p_buffer, uint32_t buffer_len,
bool_t is_full_frame, uint32_t invalid_data_len)
{
(void)is_full_frame;
(void)invalid_data_len;
iot_cp_task_data_dump((void*)p_buffer, buffer_len);
if (p_buffer && buffer_len > 0) {
/* parser ge command and post to task */
iot_proto_data_parse_and_post(p_buffer, buffer_len,
iot_cp_task_post_uart_cmd, 0);
}
return;
}
#if USE_N11_GPRS
uint8_t iot_grapp_n11_message_to_ge(uint8_t *mq_str, uint16_t str_len)
{
iot_cp_task_uart_receive_func(mq_str, str_len, true, 0);
return ERR_OK;
}
#endif
/**
* @brief iot_led_ctrl_task_timer_exe() - timer timeout callback function.
* @timer_id : timer id with that timer who causes this api-call.
* @arg : param past to this callback api.
*/
void iot_cp_task_task_timer_exe(timer_id_t timer_id, void * arg)
{
(void)timer_id;
(void)arg;
iot_cp_task_msg_post(IOT_CP_TASK_MT_TIMER,
IOT_CP_TASK_MSG_ID_TMR_TIMEOUT, NULL,0);
return;
}
/**
* @brief iot_cp_task_task_period_timer_exe() - timer timeout callback function.
* @timer_id : timer id with that timer who causes this api-call.
* @arg : param past to this callback api.
*/
void iot_cp_task_task_period_timer_exe(timer_id_t timer_id, void * arg)
{
(void)timer_id;
(void)arg;
iot_cp_task_msg_post(IOT_CP_TASK_MT_TIMER, IOT_CP_TASK_MSG_ID_TMR_PERIOD,
NULL,0);
return;
}
/* send pkt to uart port */
uint32_t iot_cp_task_uart_send(iot_pkt_t *p_pkt)
{
uint32_t ret;
#if USE_N11_GPRS
ret = iot_grapp_sendto_mainboard_gprs_fn(p_pkt);
#else
ret = iot_uart_send(plc_context.task, p_pkt, NULL);
#endif
return (ERR_OK == ret) ? ERR_OK : ERR_FAIL;
}
/*
* TODO: meter adapt-task should call this func to registor its callback
* function
*/
uint32_t iot_cp_task_callback_reg_meter_task(cp_task_cb cb)
{
uint32_t ret = ERR_FAIL;
if (cb) {
plc_context.cp_task_cb = cb;
ret = ERR_OK;
}
return ret;
}
/* TODO: cp-task should regist this funciton on to
* meter adap-task's callback funtion
*/
static uint32_t iot_cp_meter_adap_task_cb_handle(iot_pkt_t * data_pkt)
{
// TODO: post a message to handle meter infor from meter adapt-task
iot_cp_task_msg_post(IOT_CP_TASK_MT_METER, IOT_CP_TASK_MSG_ID_MERTER_DATA,
data_pkt, 0);
return ERR_OK;
}
/**
* @brief iot_cp_set_threshold_value() - set threshold_info to cp socket
* @param th_info : point to threshold_info data
* @param id : save plug id, see CP_SOCKET_ID_XXX
*/
static void iot_cp_set_threshold_value(cp_plug_threshold_info_t *th_info,
uint8_t id)
{
uint8_t plug_id;
if (id > IOT_CP_MAX_PLUG_CNT) {
iot_cus_printf("[cp]set_threshold id err %d\n", id);
return;
}
/* if id equal to IOT_CP_MAX_PLUG_CNT, th_info will be set to all port */
for (plug_id = 0; plug_id < IOT_CP_MAX_PLUG_CNT; plug_id++) {
if (id == plug_id || id == IOT_CP_MAX_PLUG_CNT) {
os_mem_cpy(&flash_info->plug_th[plug_id], th_info,
sizeof(cp_plug_threshold_info_t));
iot_cp_send_param_cmd_to_meter_task(CP_SOCKET_OP_CONFIG, plug_id);
}
}
flash_info->th_eigenvalue = CP_THESHOLD_EIGENVALUE;
iot_proto_custom_pib_info_save((void*)flash_info, sizeof(cp_flash_info_t));
}
/**
* @brief iot_cp_task_init() - The main entry to initialize our customer task.
*/
uint32_t iot_cp_task_init(void)
{
iot_task_config_t task_cfg;
os_mem_set(&cp_context, 0, sizeof(iot_cp_context));
os_mem_set(&plc_context, 0, sizeof(iot_plc_context));
/* create task */
os_mem_set(&task_cfg, 0x0, sizeof(task_cfg));
task_cfg.stack_size = IOT_CP_TASK_TASK_STACK_SIZE;
task_cfg.task_prio = IOT_CP_TASK_PROTO_TASK_PRIO;
task_cfg.msg_size = sizeof(iot_cp_task_msg_t);
task_cfg.msg_cnt = IOT_CP_TASK_TASK_POOL_SIZE;
task_cfg.queue_cnt = 1;
task_cfg.queue_cfg[0].quota = 0;
task_cfg.msg_exe_func = iot_cp_task_msg_exe_func;
task_cfg.msg_cancel_func = iot_cp_task_msg_cancel_func;
#if USE_N11_GPRS != 1
plc_context.uart_h = iot_uart_open(iot_board_get_uart(UART_METER_PORT),
iot_cp_task_uart_receive_func, IOT_CP_TASK_UART_BUF_SIZE, NULL);
#endif
plc_context.task = iot_task_create(IOT_CP_TASK_ID, &task_cfg);
if (NULL == plc_context.task) {
iot_cus_printf("[cp_task]create task failed.\n");
return ERR_FAIL;
}
plc_context.dev_type = IOT_CP_DEV_CODE_2200W_PLC;
plc_context.appinit_timer = os_create_timer(IOT_CP_TASK_ID, true,
iot_cp_task_task_timer_exe, NULL);
os_start_timer(plc_context.appinit_timer, IOT_CP_TASK_TIMER_PERIOD);
if (0 == plc_context.appinit_timer) {
iot_cus_printf("[cp_task]create timer failed.\n");
iot_task_delete(plc_context.task);
return ERR_FAIL;
}
plc_context.status_update_timer = os_create_timer(IOT_CP_TASK_ID, true,
iot_cp_task_task_period_timer_exe, NULL);
if (0 == plc_context.status_update_timer) {
iot_cus_printf("[cp_task]create periodic timer failed.\n");
iot_task_delete(plc_context.task);
return ERR_FAIL;
}
cp_socket_task_init();
cp_socket_register(iot_cp_meter_adap_task_cb_handle);
cp_context.command.list.handle = meter_cmd_handle_list;
/* get a random initial value for sending SN */
cp_context.send_signal_sn = os_rand();
#if PLC_SUPPORT_CCO_ROLE
plc_context.work_role = CP_PLC_ROLE_CCO;
plc_context.plc_state = CP_NET_STATUS_INVALID;
#else
plc_context.work_role = CP_PLC_ROLE_STA;
plc_context.plc_state = CP_NET_STATUS_INVALID;
#endif
cp_context.sw_info = iot_version_hex();
cp_context.hw_info = iot_board_hw_version_hex();
cp_context.work_mode = IOT_CP_NORMAL_MODE;
/* init RTC */
cp_rtc_init();
#if USE_N11_GPRS
iot_n11_gprs_init();
iot_n11_gprs_register_call_back((void *)iot_grapp_n11_message_to_ge);
#endif
#if (CP_ZC_ENABLE == 1)
iot_cp_zc_hw_init();
#endif
iot_cus_printf("[cp_task]task create successfully.\n");
return ERR_OK;
}
uint32_t app_cp_task_entry()
{
uint32_t ret = ERR_PENDING;
if (ERR_OK == iot_cp_task_init())
{
ret = ERR_OK;
}
return ret;
}
#endif /* IOT_CP_TASK_ENABLE */
Reference in New Issue View Git Blame Copy Permalink