/*
 * Copyright (C) 2019-2025 SGCC Holding Limited
 */

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#include "infra_config.h"
#include "infra_types.h"
#include "infra_defs.h"
#include "infra_compat.h"
#include "infra_state.h"
#include "dev_model_api.h"
#include "wrappers.h"
#include "cJSON.h"

#ifdef ATM_ENABLED
#include "at_api.h"
#endif

#include "protocol.h"
#include "interface.h"

#ifdef DYNAMIC_REGISTER
#include "dynreg_api.h"
#endif

#ifdef HTTP2_COMM_ENABLED
#include "http2_upload_api.h"
#define UPLOAD_RETRY_TIME 50
#define HTTP2_ONLINE_SERVER_URL "a1IgnOND7vI.iot-as-http2.cn-shanghai.aliyuncs.com"
#define HTTP2_ONLINE_SERVER_PORT 443
#endif

static int upload_result = 1;
static char g_upload_id[50] = {0};
static unsigned char is_connected = 0;
static int main_loop_step = EVS_LINKKIT_OPEN;

#if defined(PLATFORM_IS_DEBUG)
#define PROTOCOL_TRACE(...)                                     \
    do                                                          \
    {                                                           \
        HAL_Printf("\033[1;32;40m%s.%d: ", __func__, __LINE__); \
        HAL_Printf(__VA_ARGS__);                                \
        HAL_Printf("\033[0m\r\n");                              \
    } while (0)
#else
#define PROTOCOL_TRACE(...)
#endif

#define EVS_YIELD_TIMEOUT_MS (200)

unsigned int strtoint(char s[])
{
    unsigned int i;
    unsigned int num = 0;
    for (i = 0; s[i] >= '0' && s[i] <= '9'; i++)
    {
        num = 10 * num + (s[i] - '0');
    }
    return num;
}

void bcd2str(unsigned char byte[], char str[], int len)
{
    int i, index = 0;
    for (i = 0; i < len; i++)
    {
        char hex1;
        char hex2;
        int value = byte[i];
        int v1 = value / 16;
        int v2 = value % 16;
        if (v1 >= 0 && v1 <= 9)
            hex1 = (char)(48 + v1);
        else
            hex1 = (char)(55 + v1);
        if (v2 >= 0 && v2 <= 9)
            hex2 = (char)(48 + v2);
        else
            hex2 = (char)(55 + v2);

        str[index++] = hex1;
        str[index++] = hex2;
    }
}

int stringToHex(char *str, unsigned char *hex)
{
    char *p = NULL;
    char High = 0;
    char Low = 0;
    int Len = 0;
    int count = 0;

    p = str;
    Len = strlen(p);

    while (count < (Len / 2))
    {
        High = ((*p > '9') && ((*p <= 'F') || (*p <= 'f'))) ? *p - 48 - 7 : *p - 48;
        Low = (*(++p) > '9' && ((*p <= 'F') || (*p <= 'f'))) ? *p - 48 - 7 : *p - 48;
        hex[count] = ((High & 0x0f) << 4 | (Low & 0x0f));
        p++;
        count++;
    }

    if (0 != Len % 2)
    {
        hex[count++] = ((*p > '9') && ((*p <= 'F') || (*p <= 'f'))) ? *p - 48 - 7 : *p - 48;
    }

    return Len / 2 + Len % 2;
}

typedef struct
{
    int master_devid;
    int cloud_connected;
    int master_initialized;
} evs_user_ctx_t;

static evs_user_ctx_t evs_g_user_ctx;
iotx_linkkit_dev_meta_info_t master_meta_info;

typedef struct
{
    unsigned char gunNo;
    unsigned char getTerminalFlag;
    unsigned char getServerAuthFlag;
    unsigned char getAuthChargeFlag;
    unsigned char PKid;
    unsigned char MAC1[4];
    unsigned char MAC2[4];
    unsigned char TAC[4];
    unsigned char randomC[4];
    unsigned char cardBalance[4];
    unsigned char tradeSn[2];
    unsigned char tradeTime[7];
    unsigned char terminalSn[6];
    unsigned char authVer;
    unsigned char authFlag;
    unsigned char usr_id[10];
    unsigned char psy_id[8];
    unsigned char usrId[8];
} evs_smart_gun_auth_process_data;

static evs_smart_gun_auth_process_data gun_auth_process_data[EVS_MAX_PORT_NUM];

/**
 * @brief 瑙ｆ瀽鎵€鏈夊睘鎬э拷?锟界疆鐨勶拷?
 * @param request 鎸囧悜灞炴€э拷?锟界疆璇锋眰payload鐨勬寚锟�?
 * @param request_len 灞炴€э拷?锟界疆璇锋眰鐨刾ayload闀垮害
 * @return 瑙ｆ瀽鎴愬姛: 0, 瑙ｆ瀽澶辫触: <0
 */
int app_parse_property(const char *request, unsigned int request_len)
{
    cJSON *structcnt = NULL;

    cJSON *req = cJSON_Parse(request);
    if (req == NULL || !cJSON_IsObject(req))
    {
        return STATE_DEV_MODEL_WRONG_JSON_FORMAT;
    }

    structcnt = cJSON_GetObjectItem(req, "structCnt");
    if (structcnt != NULL && cJSON_IsObject(structcnt))
    {
        PROTOCOL_TRACE("struct property id: structCnt");
    }

    cJSON_Delete(req);
    return 0;
}

void upload_file_result(const char *file_path, int result, const char *store_id, void *user_data)
{
    upload_result = result;

    PROTOCOL_TRACE("=========== file_path = %s, result = %d ===========", file_path, upload_result);
}

void upload_id_received_handle(const char *file_path, const char *upload_id, void *user_data)
{
    PROTOCOL_TRACE("=========== file_path = %s, upload_id = %s ===========", file_path, upload_id);

    if (upload_id != NULL)
    {
        memset(g_upload_id, 0, sizeof(g_upload_id));
        strncpy(g_upload_id, upload_id, sizeof(g_upload_id) - 1);
    }
}

/** http寤虹珛杩炴垚鍔熶簨浠跺洖锟�? */
static void _on_http2_reconnect(void)
{
    PROTOCOL_TRACE("http2 reconnected");

    is_connected = 1;
}

/** http锟�?寮€杩炴帴浜嬩欢鍥炶皟 */
static void _on_http2_disconnect(void)
{
    PROTOCOL_TRACE("http2 disconnected");

    is_connected = 0;
}

/** IOT寤虹珛杩炴垚鍔熶簨浠跺洖锟�? */
static int user_connected_event_handler(void)
{
    void *callback;
    evs_g_user_ctx.cloud_connected = 1;
    callback = evs_service_callback(EVS_CONNECT_SUCC);
    if (callback)
    {
        ((int (*)(void))callback)();
    }
    return 0;
}

/** IOT锟�?寮€杩炴帴浜嬩欢鍥炶皟 */
static int user_disconnected_event_handler(void)
{
    void *callback;
    evs_g_user_ctx.cloud_connected = 0;
    callback = evs_service_callback(EVS_DISCONNECTED);
    if (callback)
    {
        ((int (*)(void))callback)();
    }
    return 0;
}

/* 璁撅拷?锟藉垵濮嬪寲鎴愬姛浜嬩欢鍥炶皟 */
static int user_initialized(const int devid)
{
    evs_g_user_ctx.master_initialized = 1;
    return 0;
}

/** 浜嬩欢鍥炶皟锛氭帴鏀跺埌浜戯拷??鍥烇拷?锟藉睘鎬т笂鎶ュ簲锟�? **/
static int user_report_reply_event_handler(const int devid, const int msgid, const int code, const char *reply,
                                           const int reply_len)
{
    void *callback;

    callback = evs_service_callback(EVS_REPORT_REPLY);
    if (callback)
    {
        ((int (*)(const int msgid, const int code, const char *reply,
                  const int reply_len))callback)(msgid, code, reply, reply_len);
    }
    return 0;
}

/** 浜嬩欢鍥炶皟锛氭帴鏀跺埌浜戯拷??鍥烇拷?锟界殑浜嬩欢涓婃姤搴旂瓟 **/
static int user_trigger_event_reply_event_handler(const int devid, const int msgid, const int code, const char *eventid,
                                                  const int eventid_len, const char *message, const int message_len)
{
    void *callback;

    callback = evs_service_callback(EVS_TRIGGER_EVENT_REPLY);
    if (callback)
    {
        ((int (*)(const int msgid, const int code, const char *eventid,
                  const int eventid_len, const char *message, const int message_len))callback)(msgid, code, eventid, eventid_len, message, message_len);
    }
    return 0;
}

/** 浜嬩欢鍥炶皟锛氭帴鏀跺埌浜戯拷??涓嬪彂鐨勫睘鎬э拷?锟界疆 **/
static int user_property_set_event_handler(const int devid, const char *request, const int request_len)
{
    int res = 0;
    PROTOCOL_TRACE("Property Set Received, Request: %s", request);

    app_parse_property(request, request_len);

    res = IOT_Linkkit_Report(evs_g_user_ctx.master_devid, ITM_MSG_POST_PROPERTY,
                             (unsigned char *)request, request_len);
    PROTOCOL_TRACE("Post Property return: %d", res);

    return res;
}

/** 浜嬩欢鍥炶皟锛氭帴鏀跺埌浜戯拷??鍥烇拷?锟界殑鏃堕棿锟�? **/
static int user_timestamp_reply_event_handler(const char *timestamp)
{
    PROTOCOL_TRACE("Current Timestamp: %s", timestamp);

    char time_buf[11] = {0};
    memcpy(time_buf, timestamp, sizeof(time_buf) - 1);

    unsigned int time = strtoint(time_buf);

    void *callback;
    callback = evs_service_callback(EVS_TIME_SYNC);
    if (callback)
    {
        ((int (*)(unsigned int))callback)(time);
    }
    return 0;
}

/** FOTA浜嬩欢鍥炶皟澶勭悊 **/
static int user_fota_event_handler(int type, const char *version)
{

    /* 0 - new firmware exist, query the new firmware */
    if (type == 0)
    {
        PROTOCOL_TRACE("-------2. New Firmware Version: %s", version);
		
		memcpy(&new_firmware_version[0], version, strlen(version));
		HAL_Printf("-------2. New Firmware Version: %s-------\n", new_firmware_version);	//version);
		
        void *callback;
        callback = evs_service_callback(EVS_OTA_UPDATE);
        if (callback)
        {
            ((int (*)(const char *))callback)(version);
        }
    }
    return 0;
}

/** 浜嬩欢鍥炶皟锛氭帴鏀跺埌浜戯拷??閿欙拷??淇℃伅 **/
static int user_cloud_error_handler(const int code, const char *data, const char *detail)
{
    PROTOCOL_TRACE("code =%d ,data=%s, detail=%s", code, data, detail);
    return 0;
}

/** 浜嬩欢鍥炶皟锛氶€氳繃鍔ㄦ€佹敞鍐岃幏鍙栧埌DeviceSecret **/
static int dynreg_device_secret(const char *device_secret)
{
    PROTOCOL_TRACE("device secret: %s", device_secret);
    return 0;
}

/** 浜嬩欢鍥炶皟: SDK鍐呴儴杩愶拷?锟界姸鎬佹墦锟�? **/
static int user_sdk_state_dump(int ev, const char *msg)
{
    void *callback;
    PROTOCOL_TRACE("received state event, -0x%04x(%s)\n", -ev, msg);
    callback = evs_service_callback(EVS_STATE_EVERYTHING);
    if (callback)
    {
        ((int (*)(int ev, const char *msg))callback)(ev, msg);
    }
    return 0;
}

static int evs_service_get_config_handler(const char *request, char **response, int *response_len)
{
    void *callback;
    int i = 0;
    evs_data_dev_config service_dev_feedback_config_data;

    callback = evs_service_callback(EVS_CONF_GET_SRV);
    if (callback)
    {
        ((int (*)(const evs_data_dev_config *))callback)(&service_dev_feedback_config_data);
    }

    cJSON *response_root = cJSON_CreateObject();
    cJSON *qrCodeArray;

    cJSON_AddNumberToObject(response_root, "equipParamFreq", service_dev_feedback_config_data.equipParamFreq);
    cJSON_AddNumberToObject(response_root, "gunElecFreq", service_dev_feedback_config_data.gunElecFreq);
    cJSON_AddNumberToObject(response_root, "nonElecFreq", service_dev_feedback_config_data.nonElecFreq);
    cJSON_AddNumberToObject(response_root, "faultWarnings", service_dev_feedback_config_data.faultWarnings);
    cJSON_AddNumberToObject(response_root, "acMeterFreq", service_dev_feedback_config_data.acMeterFreq);
    cJSON_AddNumberToObject(response_root, "dcMeterFreq", service_dev_feedback_config_data.dcMeterFreq);
    cJSON_AddNumberToObject(response_root, "offlinChaLen", service_dev_feedback_config_data.offlinChaLen);
    cJSON_AddNumberToObject(response_root, "grndLock", service_dev_feedback_config_data.grndLock);
    cJSON_AddNumberToObject(response_root, "doorLock", service_dev_feedback_config_data.doorLock);

    cJSON_AddItemToObject(response_root, "qrCode", qrCodeArray = cJSON_CreateArray());
    for (i = 0; i < EVS_MAX_PORT_NUM; i++)
    {
        // cJSON_AddStringToArray(qrCodeArray, service_dev_feedback_config_data.qrCode[i]);
        cJSON_AddItemToArray(qrCodeArray, cJSON_CreateString(service_dev_feedback_config_data.qrCode[i]));
    }

    cJSON_AddNumberToObject(response_root, "s2CloseTime", service_dev_feedback_config_data.s2CloseTime);
    cJSON_AddNumberToObject(response_root, "s2OpenTime", service_dev_feedback_config_data.s2OpenTime);

    *response = cJSON_PrintUnformatted(response_root);
    if (*response == NULL)
    {
        PROTOCOL_TRACE("Json Not Exist!");
        return -1;
    }
    else
    {
        *response_len = strlen(*response);
    }

    cJSON_Delete(response_root);

    return 0;
}
static int evs_service_get_Maintain_handler(const char *request, char **response, int *response_len)
{
    void *callback;
    evs_service_feedback_maintain_query service_feedback_maintain_status;

    callback = evs_service_callback(EVS_MAINTAIN_RESULT_SRV);
    if (callback)
    {
        ((int (*)(const evs_service_feedback_maintain_query *))callback)(&service_feedback_maintain_status);
    }

    cJSON *response_root = cJSON_CreateObject();

    cJSON_AddNumberToObject(response_root, "ctrlType", service_feedback_maintain_status.ctrlType);
    cJSON_AddNumberToObject(response_root, "result", service_feedback_maintain_status.result);

    *response = cJSON_PrintUnformatted(response_root);
    if (*response == NULL)
    {
        PROTOCOL_TRACE("Json Not Exist!");
        return -1;
    }
    else
    {
        *response_len = strlen(*response);
    }

    cJSON_Delete(response_root);

    return 0;
}
static int evs_service_update_config_handler(const char *request, char **response, int *response_len)
{
    void *callback;
    cJSON *root = cJSON_Parse(request);
    if (root == NULL || !cJSON_IsObject(root))
    {
        PROTOCOL_TRACE("JSON Parse Error");
        return -1;
    }

    evs_data_dev_config service_dev_config_data;
    int feedback_data;
    int i = 0;
    memset(&service_dev_config_data, 0, sizeof(service_dev_config_data));
    cJSON *item_equipParamFreq = cJSON_GetObjectItem(root, "equipParamFreq");
    if (item_equipParamFreq != NULL && cJSON_IsNumber(item_equipParamFreq))
    {
        service_dev_config_data.equipParamFreq = item_equipParamFreq->valueint;
    }

    cJSON *item_gunElecFeeq = cJSON_GetObjectItem(root, "gunElecFreq");
    if (item_gunElecFeeq != NULL && cJSON_IsNumber(item_gunElecFeeq))
    {
        service_dev_config_data.gunElecFreq = item_gunElecFeeq->valueint;
    }

    cJSON *item_nonElecFreq = cJSON_GetObjectItem(root, "nonElecFreq");
    if (item_nonElecFreq != NULL && cJSON_IsNumber(item_nonElecFreq))
    {
        service_dev_config_data.nonElecFreq = item_nonElecFreq->valueint;
    }

    cJSON *item_faultWarnings = cJSON_GetObjectItem(root, "faultWarnings");
    if (item_faultWarnings != NULL && cJSON_IsNumber(item_faultWarnings))
    {
        service_dev_config_data.faultWarnings = item_faultWarnings->valueint;
    }

    cJSON *item_acMeterFreq = cJSON_GetObjectItem(root, "acMeterFreq");
    if (item_acMeterFreq != NULL && cJSON_IsNumber(item_acMeterFreq))
    {
        service_dev_config_data.acMeterFreq = item_acMeterFreq->valueint;
    }

    cJSON *item_dcMeterFreq = cJSON_GetObjectItem(root, "dcMeterFreq");
    if (item_dcMeterFreq != NULL && cJSON_IsNumber(item_dcMeterFreq))
    {
        service_dev_config_data.dcMeterFreq = item_dcMeterFreq->valueint;
    }

    cJSON *item_offlinChaLen = cJSON_GetObjectItem(root, "offlinChaLen");
    if (item_offlinChaLen != NULL && cJSON_IsNumber(item_offlinChaLen))
    {
        service_dev_config_data.offlinChaLen = item_offlinChaLen->valueint;
    }

    cJSON *item_grndLock = cJSON_GetObjectItem(root, "grndLock");
    if (item_grndLock != NULL && cJSON_IsNumber(item_grndLock))
    {
        service_dev_config_data.grndLock = item_grndLock->valueint;
    }

    cJSON *item_doorLock = cJSON_GetObjectItem(root, "doorLock");
    if (item_doorLock != NULL && cJSON_IsNumber(item_doorLock))
    {
        service_dev_config_data.doorLock = item_doorLock->valueint;
    }

    cJSON *item_qrCode = cJSON_GetObjectItem(root, "qrCode");
    if (item_qrCode != NULL && cJSON_IsArray(item_qrCode))
    {
        cJSON *item_arrayData;
        int qrcode_len = 0;
        int qrcode_num = cJSON_GetArraySize(item_qrCode);
        qrcode_num = (qrcode_num <= EVS_MAX_PORT_NUM) ? qrcode_num : EVS_MAX_PORT_NUM;

        for (i = 0; i < qrcode_num; i++)
        {
            item_arrayData = cJSON_GetArrayItem(item_qrCode, i);
            qrcode_len = strlen(item_arrayData->valuestring);
            if (qrcode_len < EVS_MAX_QRCODE_LEN)
            {
                memcpy(service_dev_config_data.qrCode[i], item_arrayData->valuestring, qrcode_len);
            }
            else
            {
                PROTOCOL_TRACE("QRCode is too big!");
            }
        }
    }

    cJSON *item_s2CloseTime = cJSON_GetObjectItem(root, "s2CloseTime");
    if (item_s2CloseTime != NULL && cJSON_IsNumber(item_s2CloseTime))
    {
        service_dev_config_data.s2CloseTime = item_s2CloseTime->valueint;
    }

    cJSON *item_s2OpenTime = cJSON_GetObjectItem(root, "s2OpenTime");
    if (item_s2OpenTime != NULL && cJSON_IsNumber(item_s2OpenTime))
    {
        service_dev_config_data.s2OpenTime = item_s2OpenTime->valueint;
    }

    callback = evs_service_callback(EVS_CONF_UPDATE_SRV);
    if (callback)
    {
        ((int (*)(const evs_data_dev_config *, int *))callback)(&service_dev_config_data, &feedback_data);
    }

    cJSON *response_root = cJSON_CreateObject();
    if ((feedback_data != 10) && (feedback_data != 11)) // 蹇呴』澶勭悊杩斿洖鍊硷紝骞惰繑鍥炵粨鏋滐紝榛橈拷?锟藉洖澶嶅け锟�?
    {
        cJSON_AddNumberToObject(response_root, "resCode", 11);
    }
    else
    {
        cJSON_AddNumberToObject(response_root, "resCode", feedback_data);
    }

    *response = cJSON_PrintUnformatted(response_root);

    if (*response == NULL)
    {
        PROTOCOL_TRACE("Json Not Exist!");
        return -1;
    }
    else
    {
        *response_len = strlen(*response);
    }

    cJSON_Delete(root);
    cJSON_Delete(response_root);

    return 0;
}

static int evs_service_issue_feeModel_handler(const char *request, char **response, int *response_len)
{
    void *callback;
    cJSON *root = cJSON_Parse(request);
    if (root == NULL || !cJSON_IsObject(root))
    {
        PROTOCOL_TRACE("JSON Parse Error");
        return -1;
    }

    evs_service_issue_feeModel service_feeModel_data;
    evs_service_feedback_feeModel service_feedback_feeModel_data;
    int i = 0;
    memset(&service_feeModel_data, 0, sizeof(service_feeModel_data));
    cJSON *item_feeModelId = cJSON_GetObjectItem(root, "feeModelId");
    if (item_feeModelId != NULL && cJSON_IsString(item_feeModelId))
    {
        char *feeModelId = item_feeModelId->valuestring;
        memcpy(service_feeModel_data.feeModelId, feeModelId, strlen(feeModelId));
    }

    cJSON *item_eleTimeNum = cJSON_GetObjectItem(root, "timeNum");
    if (item_eleTimeNum != NULL && cJSON_IsNumber(item_eleTimeNum))
    {
        service_feeModel_data.timeNum = item_eleTimeNum->valueint;
    }

    cJSON *item_TimeSeg = cJSON_GetObjectItem(root, "timeSeg");
    cJSON *array_timeSeg = NULL;
    if (item_TimeSeg != NULL && cJSON_IsArray(item_TimeSeg))
    {

        for (i = 0; i < service_feeModel_data.timeNum; i++)
        {
            array_timeSeg = cJSON_GetArrayItem(item_TimeSeg, i);
            memcpy(service_feeModel_data.timeSeg[i], array_timeSeg->valuestring, strlen(array_timeSeg->valuestring));
        }
    }

    cJSON *item_chargeFee = cJSON_GetObjectItem(root, "chargeFee");
    cJSON *arrary_chargeFee = NULL;
    if (item_chargeFee != NULL && cJSON_IsArray(item_chargeFee))
    {
        for (i = 0; i < service_feeModel_data.timeNum; i++)
        {
            arrary_chargeFee = cJSON_GetArrayItem(item_chargeFee, i);
            service_feeModel_data.chargeFee[i] = arrary_chargeFee->valueint;
        }
    }

    cJSON *item_serviceFee = cJSON_GetObjectItem(root, "serviceFee");
    cJSON *arrary_serviceFee = NULL;
    if (item_serviceFee != NULL && cJSON_IsArray(item_serviceFee))
    {
        for (i = 0; i < service_feeModel_data.timeNum; i++)
        {
            arrary_serviceFee = cJSON_GetArrayItem(item_serviceFee, i);
            service_feeModel_data.serviceFee[i] = arrary_serviceFee->valueint;
        }
    }

    callback = evs_service_callback(EVS_FEE_MODEL_UPDATE_SRV);
    if (callback)
    {
        ((int (*)(const evs_service_issue_feeModel *, evs_service_feedback_feeModel *))callback)(&service_feeModel_data, &service_feedback_feeModel_data);
    }
    cJSON *response_root = cJSON_CreateObject();
    cJSON_AddStringToObject(response_root, "feeModelId", service_feedback_feeModel_data.feeModelId);
    cJSON_AddNumberToObject(response_root, "result", service_feedback_feeModel_data.result);

    *response = cJSON_PrintUnformatted(response_root);

    if (*response == NULL)
    {
        PROTOCOL_TRACE("Json Not Exist!");
        return -1;
    }
    else
    {
        *response_len = strlen(*response);
    }

    cJSON_Delete(root);
    cJSON_Delete(response_root);

    return 0;
}

static int evs_service_startCharge_handler(const char *request, char **response, int *response_len)
{
    void *callback;
    cJSON *root = cJSON_Parse(request);
    if (root == NULL || !cJSON_IsObject(root))
    {
        PROTOCOL_TRACE("JSON Parse Error");
        return -1;
    }
    evs_service_startCharge service_charge_data;
    evs_service_feedback_startCharge service_feedback_startCharge_data;
    memset(&service_charge_data, 0, sizeof(service_charge_data));
    /* Parse json */
    cJSON *item_gunNo = cJSON_GetObjectItem(root, "gunNo");
    if (item_gunNo != NULL && cJSON_IsNumber(item_gunNo))
    {
        service_charge_data.gunNo = item_gunNo->valueint;
    }

    cJSON *item_preTradeNo = cJSON_GetObjectItem(root, "preTradeNo");
    if (item_preTradeNo != NULL && cJSON_IsString(item_preTradeNo))
    {
        memcpy(service_charge_data.preTradeNo, item_preTradeNo->valuestring, strlen(item_preTradeNo->valuestring));
    }

    cJSON *item_startType = cJSON_GetObjectItem(root, "startType");
    if (item_startType != NULL && cJSON_IsNumber(item_startType))
    {
        service_charge_data.startType = item_startType->valueint;
    }

    cJSON *item_chargeMode = cJSON_GetObjectItem(root, "chargeMode");
    if (item_chargeMode != NULL && cJSON_IsNumber(item_chargeMode))
    {
        service_charge_data.chargeMode = item_chargeMode->valueint;
    }

    cJSON *item_limitData = cJSON_GetObjectItem(root, "limitData");
    if (item_limitData != NULL && cJSON_IsNumber(item_limitData))
    {
        service_charge_data.limitData = item_limitData->valueint;
    }

    cJSON *item_stopCode = cJSON_GetObjectItem(root, "stopCode");
    if (item_stopCode != NULL && cJSON_IsNumber(item_stopCode))
    {
        service_charge_data.stopCode = item_stopCode->valueint;
    }

    cJSON *item_startMode = cJSON_GetObjectItem(root, "startMode");
    if (item_startMode != NULL && cJSON_IsNumber(item_startMode))
    {
        service_charge_data.startMode = item_startMode->valueint;
    }

    cJSON *item_insertGunTime = cJSON_GetObjectItem(root, "insertGunTime");
    if (item_insertGunTime != NULL && cJSON_IsNumber(item_insertGunTime))
    {
        service_charge_data.insertGunTime = item_insertGunTime->valueint;
    }

    callback = evs_service_callback(EVS_START_CHARGE_SRV);
    if (callback)
    {
        ((int (*)(const evs_service_startCharge *, evs_service_feedback_startCharge *))callback)(&service_charge_data, &service_feedback_startCharge_data);
    }

    cJSON *response_root = cJSON_CreateObject();
    cJSON_AddStringToObject(response_root, "preTradeNo", service_feedback_startCharge_data.preTradeNo);
    cJSON_AddStringToObject(response_root, "tradeNo", service_feedback_startCharge_data.tradeNo);
    cJSON_AddNumberToObject(response_root, "gunNo", service_feedback_startCharge_data.gunNo);

    *response = cJSON_PrintUnformatted(response_root);

    if (*response == NULL)
    {
        PROTOCOL_TRACE("Json Not Exist!");
        return -1;
    }
    else
    {
        *response_len = strlen(*response);
    }

    cJSON_Delete(root);
    cJSON_Delete(response_root);

    return 0;
}

static int evs_service_authCharge_handler(const char *request, char **response, int *response_len)
{
    void *callback;
    cJSON *root = cJSON_Parse(request);
    if (root == NULL || !cJSON_IsObject(root))
    {
        PROTOCOL_TRACE("JSON Parse Error");
        return -1;
    }
    evs_service_authCharge service_authCharge_data;
    evs_service_feedback_authCharge service_feedback_authCharge_data;

    memset(&service_authCharge_data, 0, sizeof(service_authCharge_data));

    cJSON *item_gunNo = cJSON_GetObjectItem(root, "gunNo");
    if (item_gunNo != NULL && cJSON_IsNumber(item_gunNo))
    {
        service_authCharge_data.gunNo = item_gunNo->valueint;
        gun_auth_process_data[service_authCharge_data.gunNo - 1].getAuthChargeFlag = 1;
    }

    cJSON *item_preTradeNo = cJSON_GetObjectItem(root, "preTradeNo");
    if (item_preTradeNo != NULL && cJSON_IsString(item_preTradeNo))
    {
        char *tradeNo = item_preTradeNo->valuestring;
        memcpy(service_authCharge_data.preTradeNo, tradeNo, strlen(tradeNo));
    }

    cJSON *item_tradeNo = cJSON_GetObjectItem(root, "tradeNo");
    if (item_tradeNo != NULL && cJSON_IsString(item_tradeNo))
    {
        char *devTradeNo = item_tradeNo->valuestring;
        memcpy(service_authCharge_data.tradeNo, devTradeNo, strlen(devTradeNo));
    }

    cJSON *item_startType = cJSON_GetObjectItem(root, "startType");
    if (item_startType != NULL && cJSON_IsNumber(item_startType))
    {
        service_authCharge_data.startType = item_startType->valueint;
    }

    cJSON *item_authCode = cJSON_GetObjectItem(root, "authCode");
    if (item_authCode != NULL && cJSON_IsString(item_authCode))
    {
        char *authCode = item_authCode->valuestring;
        memcpy(service_authCharge_data.authCode, authCode, strlen(authCode));
    }

    cJSON *item_result = cJSON_GetObjectItem(root, "result");
    if (item_result != NULL && cJSON_IsNumber(item_result))
    {
        service_authCharge_data.result = item_result->valueint;
    }

    cJSON *item_chargeMode = cJSON_GetObjectItem(root, "chargeMode");
    if (item_chargeMode != NULL && cJSON_IsNumber(item_chargeMode))
    {
        service_authCharge_data.chargeMode = item_chargeMode->valueint;
    }

    cJSON *item_limitData = cJSON_GetObjectItem(root, "limitData");
    if (item_limitData != NULL && cJSON_IsNumber(item_limitData))
    {
        service_authCharge_data.limitData = item_limitData->valueint;
    }

    cJSON *item_stopCode = cJSON_GetObjectItem(root, "stopCode");
    if (item_stopCode != NULL && cJSON_IsNumber(item_stopCode))
    {
        service_authCharge_data.stopCode = item_stopCode->valueint;
    }

    cJSON *item_startMode = cJSON_GetObjectItem(root, "startMode");
    if (item_startMode != NULL && cJSON_IsNumber(item_startMode))
    {
        service_authCharge_data.startMode = item_startMode->valueint;
    }

    cJSON *item_insertGunTime = cJSON_GetObjectItem(root, "insertGunTime");
    if (item_insertGunTime != NULL && cJSON_IsNumber(item_insertGunTime))
    {
        service_authCharge_data.insertGunTime = item_insertGunTime->valueint;
    }

    callback = evs_service_callback(EVS_AUTH_RESULT_SRV);
    if (callback)
    {
        ((int (*)(const evs_service_authCharge *, evs_service_feedback_authCharge *))callback)(&service_authCharge_data, &service_feedback_authCharge_data);
    }
    cJSON *response_root = cJSON_CreateObject();
    cJSON_AddStringToObject(response_root, "preTradeNo", service_feedback_authCharge_data.preTradeNo);
    cJSON_AddStringToObject(response_root, "tradeNo", service_feedback_authCharge_data.tradeNo);
    cJSON_AddNumberToObject(response_root, "gunNo", service_feedback_authCharge_data.gunNo);

    *response = cJSON_PrintUnformatted(response_root);

    if (*response == NULL)
    {
        PROTOCOL_TRACE("Json Not Exist!");
        return -1;
    }
    else
    {
        *response_len = strlen(*response);
    }

    cJSON_Delete(root);
    cJSON_Delete(response_root);

    return 0;
}

static int evs_service_stopCharge_handler(const char *request, char **response, int *response_len)
{
    void *callback;
    cJSON *root = cJSON_Parse(request);
    if (root == NULL || !cJSON_IsObject(root))
    {
        PROTOCOL_TRACE("JSON Parse Error");
        return -1;
    }

    evs_service_stopCharge service_stopCharge_data;
    evs_service_feedback_stopCharge service_feedback_stopCharge_data;

    memset(&service_stopCharge_data, 0, sizeof(service_stopCharge_data));

    cJSON *item_gunNo = cJSON_GetObjectItem(root, "gunNo");
    if (item_gunNo != NULL && cJSON_IsNumber(item_gunNo))
    {
        service_stopCharge_data.gunNo = item_gunNo->valueint;
    }

    cJSON *item_preTradeNo = cJSON_GetObjectItem(root, "preTradeNo");
    if (item_preTradeNo != NULL && cJSON_IsString(item_preTradeNo))
    {
        char *tradeNo = item_preTradeNo->valuestring;
        memcpy(service_stopCharge_data.preTradeNo, tradeNo, strlen(tradeNo));
    }

    cJSON *item_tradeNo = cJSON_GetObjectItem(root, "tradeNo");
    if (item_tradeNo != NULL && cJSON_IsString(item_tradeNo))
    {
        char *devTradeNo = item_tradeNo->valuestring;
        memcpy(service_stopCharge_data.tradeNo, devTradeNo, strlen(devTradeNo));
    }

    cJSON *item_stopReason = cJSON_GetObjectItem(root, "stopReason");
    if (item_stopReason != NULL && cJSON_IsNumber(item_stopReason))
    {
        service_stopCharge_data.stopReason = item_stopReason->valueint;
    }

    callback = evs_service_callback(EVS_STOP_CHARGE_SRV);
    if (callback)
    {
        ((int (*)(const evs_service_stopCharge *, evs_service_feedback_stopCharge *))callback)(&service_stopCharge_data, &service_feedback_stopCharge_data);
    }
    cJSON *response_root = cJSON_CreateObject();
    cJSON_AddStringToObject(response_root, "preTradeNo", service_feedback_stopCharge_data.preTradeNo);
    cJSON_AddStringToObject(response_root, "tradeNo", service_feedback_stopCharge_data.tradeNo);
    cJSON_AddNumberToObject(response_root, "gunNo", service_feedback_stopCharge_data.gunNo);

    *response = cJSON_PrintUnformatted(response_root);

    if (*response == NULL)
    {
        PROTOCOL_TRACE("Json Not Exist!");
        return -1;
    }
    else
    {
        *response_len = strlen(*response);
    }

    cJSON_Delete(root);
    cJSON_Delete(response_root);

    return 0;
}

static int evs_service_confirmTrade_handler(const char *request, char **response, int *response_len)
{
    void *callback;
    cJSON *root = cJSON_Parse(request);
    if (root == NULL || !cJSON_IsObject(root))
    {
        PROTOCOL_TRACE("JSON Parse Error");
        return -1;
    }
    evs_service_confirmTrade service_confirmTrade_data;

    memset(&service_confirmTrade_data, 0, sizeof(service_confirmTrade_data));

    cJSON *item_gunNo = cJSON_GetObjectItem(root, "gunNo");
    if (item_gunNo != NULL && cJSON_IsNumber(item_gunNo))
    {
        service_confirmTrade_data.gunNo = item_gunNo->valueint;
    }

    cJSON *item_preTradeNo = cJSON_GetObjectItem(root, "preTradeNo");
    if (item_preTradeNo != NULL && cJSON_IsString(item_preTradeNo))
    {
        char *tradeNo = item_preTradeNo->valuestring;
        memcpy(service_confirmTrade_data.preTradeNo, tradeNo, strlen(tradeNo));
    }

    cJSON *item_tradeNo = cJSON_GetObjectItem(root, "tradeNo");
    if (item_tradeNo != NULL && cJSON_IsString(item_tradeNo))
    {
        char *devTradeNo = item_tradeNo->valuestring;
        memcpy(service_confirmTrade_data.tradeNo, devTradeNo, strlen(devTradeNo));
    }

    cJSON *item_errcode = cJSON_GetObjectItem(root, "errcode");
    if (item_errcode != NULL && cJSON_IsNumber(item_errcode))
    {
        service_confirmTrade_data.errcode = item_errcode->valueint;
    }

    callback = evs_service_callback(EVS_ORDER_CHECK_SRV);
    if (callback)
    {
        ((int (*)(const evs_service_confirmTrade *, void *))callback)(&service_confirmTrade_data, NULL);
    }

    cJSON_Delete(root);

    return 0;
}

static int evs_service_query_log_handler(const char *request, char **response, int *response_len)
{
    void *callback;
    cJSON *root = cJSON_Parse(request);
    if (root == NULL || !cJSON_IsObject(root))
    {
        PROTOCOL_TRACE("JSON Parse Error");
        return -1;
    }
    evs_service_query_log service_query_log_data;
    evs_service_feedback_query_log feedback_query_log_data;
    char temp[16] = {0};

    memset(&service_query_log_data, 0, sizeof(service_query_log_data));

    cJSON *item_gunNo = cJSON_GetObjectItem(root, "gunNo");
    if (item_gunNo != NULL && cJSON_IsNumber(item_gunNo))
    {
        service_query_log_data.gunNo = item_gunNo->valueint;
    }

    cJSON *item_startDate = cJSON_GetObjectItem(root, "startDate");
    if (item_startDate != NULL && cJSON_IsString(item_startDate))
    {
        char *startDate = item_startDate->valuestring;
        service_query_log_data.startDate = strtoint(startDate);
    }

    cJSON *item_stopDate = cJSON_GetObjectItem(root, "stopDate");
    if (item_stopDate != NULL && cJSON_IsString(item_stopDate))
    {
        char *stopDate = item_stopDate->valuestring;
        service_query_log_data.stopDate = strtoint(stopDate);
    }

    cJSON *item_askType = cJSON_GetObjectItem(root, "askType");
    if (item_askType != NULL && cJSON_IsNumber(item_askType))
    {
        service_query_log_data.askType = item_askType->valueint;
    }

    cJSON *item_logQueryNo = cJSON_GetObjectItem(root, "logQueryNo");
    if (item_logQueryNo != NULL && cJSON_IsString(item_logQueryNo))
    {
        char *logQueryNo = item_logQueryNo->valuestring;
        memcpy(service_query_log_data.logQueryNo, logQueryNo, strlen(logQueryNo));
    }

    callback = evs_service_callback(EVS_QUE_DATA_SRV);
    if (callback)
    {
        ((int (*)(const evs_service_query_log *, evs_service_feedback_query_log *))callback)(&service_query_log_data, &feedback_query_log_data);
    }
    cJSON *response_root = cJSON_CreateObject();
    cJSON_AddNumberToObject(response_root, "gunNo", feedback_query_log_data.gunNo);

    sprintf(temp, "%d", feedback_query_log_data.startDate);
    cJSON_AddStringToObject(response_root, "startDate", temp);

    sprintf(temp, "%d", feedback_query_log_data.stopDate);
    cJSON_AddStringToObject(response_root, "stopDate", temp);

    cJSON_AddNumberToObject(response_root, "askType", feedback_query_log_data.askType);
    cJSON_AddNumberToObject(response_root, "result", feedback_query_log_data.result);
    cJSON_AddStringToObject(response_root, "logQueryNo", feedback_query_log_data.logQueryNo);

    *response = cJSON_PrintUnformatted(response_root);

    if (*response == NULL)
    {
        PROTOCOL_TRACE("Json Not Exist!");
        return -1;
    }
    else
    {
        *response_len = strlen(*response);
    }

    cJSON_Delete(root);
    cJSON_Delete(response_root);

    return 0;
}

static int evs_service_gateLock_ctrl_handler(const char *request, char **response, int *response_len)
{

    void *callback;
    cJSON *root = cJSON_Parse(request);
    if (root == NULL || !cJSON_IsObject(root))
    {
        PROTOCOL_TRACE("JSON Parse Error");
        return -1;
    }

    evs_service_gateLock_ctrl service_gateLock_ctrl_data;
    evs_service_feedback_gateLock_ctrl service_feedback_gateLock_ctrl_data;

    memset(&service_gateLock_ctrl_data, 0, sizeof(service_gateLock_ctrl_data));

    cJSON *item_lockNo = cJSON_GetObjectItem(root, "lockNo");
    if (item_lockNo != NULL && cJSON_IsNumber(item_lockNo))
    {
        service_gateLock_ctrl_data.lockNo = item_lockNo->valueint;
    }

    cJSON *item_ctrlFlag = cJSON_GetObjectItem(root, "ctrlFlag");
    if (item_ctrlFlag != NULL && cJSON_IsNumber(item_ctrlFlag))
    {
        service_gateLock_ctrl_data.ctrlFlag = item_ctrlFlag->valueint;
    }

    callback = evs_service_callback(EVS_GATE_LOCK_SRV);
    if (callback)
    {
        ((int (*)(const evs_service_gateLock_ctrl *, evs_service_feedback_gateLock_ctrl *))callback)(&service_gateLock_ctrl_data, &service_feedback_gateLock_ctrl_data);
    }

    cJSON *response_root = cJSON_CreateObject();
    cJSON_AddNumberToObject(response_root, "lockNo", service_feedback_gateLock_ctrl_data.lockNo);
    cJSON_AddNumberToObject(response_root, "result", service_feedback_gateLock_ctrl_data.result);

    *response = cJSON_PrintUnformatted(response_root);

    if (*response == NULL)
    {
        PROTOCOL_TRACE("Json Not Exist!");
        return -1;
    }
    else
    {
        *response_len = strlen(*response);
    }

    cJSON_Delete(root);
    cJSON_Delete(response_root);

    return 0;
}

static int evs_service_groundLock_ctrl_handler(const char *request, char **response, int *response_len)
{
    void *callback;
    cJSON *root = cJSON_Parse(request);
    if (root == NULL || !cJSON_IsObject(root))
    {
        PROTOCOL_TRACE("JSON Parse Error");
        return -1;
    }

    evs_service_groundLock_ctrl service_groundLock_ctrl_data;
    evs_service_feedback_groundLock_ctrl service_feedback_groundLock_ctrl_data;

    memset(&service_groundLock_ctrl_data, 0, sizeof(service_groundLock_ctrl_data));

    cJSON *item_gunNo = cJSON_GetObjectItem(root, "gunNo");
    if (item_gunNo != NULL && cJSON_IsNumber(item_gunNo))
    {
        service_groundLock_ctrl_data.gunNo = item_gunNo->valueint;
    }

    cJSON *item_ctrlFlag = cJSON_GetObjectItem(root, "ctrlFlag");
    if (item_ctrlFlag != NULL && cJSON_IsNumber(item_ctrlFlag))
    {
        service_groundLock_ctrl_data.ctrlFlag = item_ctrlFlag->valueint;
    }

    callback = evs_service_callback(EVS_GROUND_LOCK_SRV);
    if (callback)
    {
        ((int (*)(const evs_service_groundLock_ctrl *, evs_service_feedback_groundLock_ctrl *))callback)(&service_groundLock_ctrl_data, &service_feedback_groundLock_ctrl_data);
    }
    cJSON *response_root = cJSON_CreateObject();
    cJSON_AddNumberToObject(response_root, "gunNo", service_feedback_groundLock_ctrl_data.gunNo);
    cJSON_AddNumberToObject(response_root, "reason", service_feedback_groundLock_ctrl_data.reason);
    cJSON_AddNumberToObject(response_root, "result", service_feedback_groundLock_ctrl_data.result);

    *response = cJSON_PrintUnformatted(response_root);

    if (*response == NULL)
    {
        PROTOCOL_TRACE("Json Not Exist!");
        return -1;
    }
    else
    {
        *response_len = strlen(*response);
    }

    cJSON_Delete(root);
    cJSON_Delete(response_root);

    return 0;
}

static int evs_service_lockCtrl_handler(const char *request, char **response, int *response_len)
{
    void *callback;
    cJSON *root = cJSON_Parse(request);
    if (root == NULL || !cJSON_IsObject(root))
    {
        PROTOCOL_TRACE("JSON Parse Error");
        return -1;
    }

    evs_service_lockCtrl service_lockCtrl_data;

    memset(&service_lockCtrl_data, 0, sizeof(service_lockCtrl_data));

    cJSON *item_gunNo = cJSON_GetObjectItem(root, "gunNo");
    if (item_gunNo != NULL && cJSON_IsNumber(item_gunNo))
    {
        service_lockCtrl_data.gunNo = item_gunNo->valueint;
    }

    cJSON *item_lockParam = cJSON_GetObjectItem(root, "lockParam");
    if (item_lockParam != NULL && cJSON_IsNumber(item_lockParam))
    {
        service_lockCtrl_data.lockParam = item_lockParam->valueint;
    }

    callback = evs_service_callback(EVS_CTRL_LOCK_SRV);
    if (callback)
    {
        ((int (*)(const evs_service_lockCtrl *))callback)(&service_lockCtrl_data);
    }

    cJSON_Delete(root);
    return 0;
}

static int evs_service_dev_maintain_handler(const char *request, char **response, int *response_len)
{
    void *callback;
    cJSON *root = cJSON_Parse(request);
    if (root == NULL || !cJSON_IsObject(root))
    {
        PROTOCOL_TRACE("JSON Parse Error");
        return -1;
    }

    evs_service_dev_maintain service_dev_maintain;

    memset(&service_dev_maintain, 0, sizeof(service_dev_maintain));

    cJSON *item_gunNo = cJSON_GetObjectItem(root, "gunNo");
    if (item_gunNo != NULL && cJSON_IsNumber(item_gunNo))
    {
        service_dev_maintain.gunNo = item_gunNo->valueint;
    }

    cJSON *item_ctrlType = cJSON_GetObjectItem(root, "ctrlType");
    if (item_ctrlType != NULL && cJSON_IsNumber(item_ctrlType))
    {
        service_dev_maintain.ctrlType = item_ctrlType->valueint;
    }

    callback = evs_service_callback(EVS_DEV_MAINTAIN_SRV);
    if (callback)
    {
        ((int (*)(const evs_service_dev_maintain *))callback)(&service_dev_maintain);
    }

    cJSON_Delete(root);
    return 0;
}

static int evs_service_orderCharge_handler(const char *request, char **response, int *response_len)
{
    void *callback;
    cJSON *root = cJSON_Parse(request);
    if (root == NULL || !cJSON_IsObject(root))
    {
        PROTOCOL_TRACE("JSON Parse Error");
        return -1;
    }
    evs_service_orderCharge service_oderCharge_data;
    evs_service_feedback_orderCharge service_feedback_oderCharge_data;

    memset(&service_oderCharge_data, 0, sizeof(service_oderCharge_data));

    cJSON *item_preTradeNo = cJSON_GetObjectItem(root, "preTradeNo");
    if (item_preTradeNo != NULL && cJSON_IsString(item_preTradeNo))
    {
        char *tradeNo = item_preTradeNo->valuestring;
        memcpy(service_oderCharge_data.preTradeNo, tradeNo, strlen(tradeNo));
    }

    cJSON *item_validTime = cJSON_GetObjectItem(root, "validTime");
    if (item_validTime != NULL && cJSON_IsArray(item_validTime))
    {
        int item_num = cJSON_GetArraySize(item_validTime);
        if ((item_num > 0))
        {
            if (item_num <= EVS_MAX_SEG_LEN)
            {
                service_oderCharge_data.num = item_num;
            }
            else
            {
                service_oderCharge_data.num = EVS_MAX_SEG_LEN;
            }
            cJSON *array_validTime = NULL;
            int i = 0;
            for (i = 0; i < service_oderCharge_data.num; i++)
            {
                array_validTime = cJSON_GetArrayItem(item_validTime, i);
                memcpy(service_oderCharge_data.validTime[i], array_validTime->valuestring, strlen(array_validTime->valuestring));
            }

            cJSON *item_kw = cJSON_GetObjectItem(root, "kw");
            cJSON *array_kw;
            if (item_kw != NULL && cJSON_IsArray(item_kw))
            {
                for (i = 0; i < service_oderCharge_data.num; i++)
                {
                    array_kw = cJSON_GetArrayItem(item_kw, i);
                    service_oderCharge_data.kw[i] = array_kw->valueint;
                }
            }
        }
    }

    callback = evs_service_callback(EVS_ORDERLY_CHARGE_SRV);
    if (callback)
    {
        ((int (*)(const evs_service_orderCharge *, evs_service_feedback_orderCharge *))callback)(&service_oderCharge_data, &service_feedback_oderCharge_data);
    }
    cJSON *response_root = cJSON_CreateObject();
    cJSON_AddStringToObject(response_root, "preTradeNo", service_feedback_oderCharge_data.preTradeNo);
    cJSON_AddNumberToObject(response_root, "reason", service_feedback_oderCharge_data.reason);
    cJSON_AddNumberToObject(response_root, "result", service_feedback_oderCharge_data.result);

    *response = cJSON_PrintUnformatted(response_root);

    if (*response == NULL)
    {
        PROTOCOL_TRACE("Json Not Exist!");
        return -1;
    }
    else
    {
        *response_len = strlen(*response);
    }

    cJSON_Delete(root);
    cJSON_Delete(response_root);

    return 0;
}

static int evs_service_terminalSn_handler(const char *request, char **response, int *response_len)
{
    const char *response_fmt = "{\"result\": %d}";
    char terminalStr[13] = {0};

    int gunNo = 0;

    cJSON *root = cJSON_Parse(request);
    if (root == NULL || !cJSON_IsObject(root))
    {
        PROTOCOL_TRACE("JSON Parse Error");
        return -1;
    }

    cJSON *item_gunNo = cJSON_GetObjectItem(root, "gunNo");
    if (item_gunNo != NULL && cJSON_IsNumber(item_gunNo))
    {
        gunNo = item_gunNo->valueint;
    }
    else
    {
        PROTOCOL_TRACE("JSON Parse 'gunNo' Error");
        cJSON_Delete(root);
        return -1;
    }

    cJSON *item_terminalSn = cJSON_GetObjectItem(root, "terminalSn");
    if (item_terminalSn != NULL && cJSON_IsString(item_terminalSn))
    {
        memcpy(terminalStr, item_terminalSn->valuestring, sizeof(terminalStr));
        stringToHex(terminalStr, gun_auth_process_data[gunNo - 1].terminalSn);
    }
    else
    {
        PROTOCOL_TRACE("JSON Parse 'terminalSn' Error");
        cJSON_Delete(root);
        return -1;
    }

    gun_auth_process_data[gunNo - 1].getTerminalFlag = 1;

    /* 鏈嶅姟搴旂瓟鏁版嵁锛屾暟锟�?闀垮害閫氳繃response锛宺esponse_len鍙傛暟浼犵粰SDK */
    *response_len = strlen(response_fmt) + 10 + 1;
    *response = (char *)HAL_Malloc(*response_len);

    if (*response == NULL)
    {
        PROTOCOL_TRACE("Memory Not Enough");
        return -1;
    }

    memset(*response, 0, *response_len);
    HAL_Snprintf(*response, *response_len, response_fmt, 10);
    *response_len = strlen(*response);

    cJSON_Delete(root);

    return 0;
}

static int evs_service_srvAuthCode_handler(const char *request, char **response, int *response_len)
{

    char tv[15] = {0};
    char strMac2[9] = {0};
    int gunNo = 0;

    const char *response_fmt = "{\"result\": %d}";

    cJSON *root = cJSON_Parse(request);
    if (root == NULL || !cJSON_IsObject(root))
    {
        PROTOCOL_TRACE("JSON Parse Error");
        return -1;
    }

    cJSON *item_gunNo = cJSON_GetObjectItem(root, "gunNo");
    if (item_gunNo != NULL && cJSON_IsNumber(item_gunNo))
    {
        gunNo = item_gunNo->valueint;
    }
    else
    {
        PROTOCOL_TRACE("JSON Parse 'gunNo' Error");
        cJSON_Delete(root);
        return -1;
    }

    cJSON *item_timeStr = cJSON_GetObjectItem(root, "timeStr");
    if (item_timeStr != NULL && cJSON_IsString(item_timeStr))
    {
        memcpy(tv, item_timeStr->valuestring, sizeof(tv));
        stringToHex(tv, gun_auth_process_data[gunNo - 1].tradeTime);
    }
    else
    {
        PROTOCOL_TRACE("JSON Parse 'timeStr' Error");
        cJSON_Delete(root);
        return -1;
    }

    cJSON *item_mac2 = cJSON_GetObjectItem(root, "tradeMac2");
    if (item_mac2 != NULL && cJSON_IsString(item_mac2))
    {
        memcpy(strMac2, item_mac2->valuestring, sizeof(strMac2));
        stringToHex(strMac2, gun_auth_process_data[gunNo - 1].MAC2);
    }
    else
    {
        PROTOCOL_TRACE("JSON Parse 'tradeMac2' Error");
        cJSON_Delete(root);
        return -1;
    }

    gun_auth_process_data[gunNo - 1].getServerAuthFlag = 1;

    /* 鏈嶅姟搴旂瓟鏁版嵁锛屾暟锟�?闀垮害閫氳繃response锛宺esponse_len鍙傛暟浼犵粰SDK */
    *response_len = strlen(response_fmt) + 10 + 1;
    *response = (char *)HAL_Malloc(*response_len);

    if (*response == NULL)
    {
        PROTOCOL_TRACE("Memory Not Enough");
        return -1;
    }

    memset(*response, 0, *response_len);
    HAL_Snprintf(*response, *response_len, response_fmt, 10);

    *response_len = strlen(*response);

    cJSON_Delete(root);

    return 0;
}

static int evs_service_update_fun_config_handler(const char *request, char **response, int *response_len)
{
    void *callback;
    cJSON *root = cJSON_Parse(request);
    evs_service_feedback_dev_fun_config feedback_data = {0};

    if (root == NULL || !cJSON_IsObject(root))
    {
        PROTOCOL_TRACE("JSON Parse Error");
        return -1;
    }

    evs_service_dev_fun_config service_dev_fun_config_data;
    memset(&service_dev_fun_config_data, 0, sizeof(service_dev_fun_config_data));

    cJSON *item_funCode = cJSON_GetObjectItem(root, "funCode");
    if (item_funCode != NULL && cJSON_IsNumber(item_funCode))
    {
        service_dev_fun_config_data.funCode = item_funCode->valueint;
    }
    else
    {
        PROTOCOL_TRACE("JSON Parse 'funCode' Error");
        cJSON_Delete(root);
        return -1;
    }

    if (service_dev_fun_config_data.funCode == 12 || service_dev_fun_config_data.funCode == 13 || service_dev_fun_config_data.funCode == 20 ||
        service_dev_fun_config_data.funCode == 22)
    {
        cJSON *item_confString = cJSON_GetObjectItem(root, "confString");
        if (item_confString != NULL && cJSON_IsString(item_confString))
        {
            char *confString = item_confString->valuestring;
            memcpy(service_dev_fun_config_data.confString, confString, strlen(confString));
        }
        else
        {
            PROTOCOL_TRACE("JSON Parse 'confString' Error");
            cJSON_Delete(root);
            return -1;
        }
    }
    else
    {
        cJSON *item_confInt = cJSON_GetObjectItem(root, "confInt");
        if (item_confInt != NULL && cJSON_IsNumber(item_confInt))
        {
            service_dev_fun_config_data.confInt = item_confInt->valueint;
        }
        else
        {
            PROTOCOL_TRACE("JSON Parse 'confInt' Error");
            cJSON_Delete(root);
            return -1;
        }
    }

    cJSON *item_optSn = cJSON_GetObjectItem(root, "optSn");
    if (item_optSn != NULL && cJSON_IsString(item_optSn))
    {
        char *optString = item_optSn->valuestring;
        memcpy(service_dev_fun_config_data.optSn, optString, strlen(optString));
    }
    else
    {
        PROTOCOL_TRACE("JSON Parse 'optSn' Error");
        cJSON_Delete(root);
        return -1;
    }

    callback = evs_service_callback(EVS_FUN_CONF_UPDATE_SRV);
    if (callback)
    {
        ((int (*)(const evs_service_dev_fun_config *, evs_service_feedback_dev_fun_config *))callback)(&service_dev_fun_config_data, &feedback_data);
    }

    cJSON *response_root = cJSON_CreateObject();
    if ((feedback_data.resCode != 10) && (feedback_data.resCode != 11)) // 蹇呴』澶勭悊杩斿洖鍊硷紝骞惰繑鍥炵粨鏋滐紝榛橈拷?锟藉洖澶嶅け锟�?
    {
        cJSON_AddNumberToObject(response_root, "resCode", 11);
    }
    else
    {
        cJSON_AddNumberToObject(response_root, "resCode", feedback_data.resCode);
    }

    cJSON_AddNumberToObject(response_root, "funCode", feedback_data.funCode);
    cJSON_AddStringToObject(response_root, "optSn", feedback_data.optSn);

    *response = cJSON_PrintUnformatted(response_root);

    if (*response == NULL)
    {
        PROTOCOL_TRACE("Json Not Exist!");
        return -1;
    }
    else
    {
        *response_len = strlen(*response);
    }

    cJSON_Delete(root);
    cJSON_Delete(response_root);

    return 0;
}

static int evs_service_get_fun_config_handler(const char *request, char **response, int *response_len)
{
    void *callback;
    cJSON *root = cJSON_Parse(request);
    evs_service_get_dev_fun_config service_get_fun_config_data;
    evs_service_dev_fun_config service_dev_feedback_fun_config_data;

    memset(&service_get_fun_config_data, 0, sizeof(service_get_fun_config_data));
    memset(&service_dev_feedback_fun_config_data, 0, sizeof(service_dev_feedback_fun_config_data));

    cJSON *item_funCode = cJSON_GetObjectItem(root, "funCode");
    if (item_funCode != NULL && cJSON_IsNumber(item_funCode))
    {
        service_get_fun_config_data.funCode = item_funCode->valueint;
    }
    else
    {
        PROTOCOL_TRACE("JSON Parse 'funCode' Error");
        cJSON_Delete(root);
        return -1;
    }

    callback = evs_service_callback(EVS_FUN_CONF_GET_SRV);
    if (callback)
    {
        ((int (*)(const evs_service_get_dev_fun_config *, evs_service_dev_fun_config *))callback)(&service_get_fun_config_data, &service_dev_feedback_fun_config_data);
    }

    cJSON *response_root = cJSON_CreateObject();

    cJSON_AddNumberToObject(response_root, "funCode", service_dev_feedback_fun_config_data.funCode);
    cJSON_AddNumberToObject(response_root, "confInt", service_dev_feedback_fun_config_data.confInt);
    cJSON_AddStringToObject(response_root, "confString", service_dev_feedback_fun_config_data.confString);

    *response = cJSON_PrintUnformatted(response_root);
    if (*response == NULL)
    {
        PROTOCOL_TRACE("Json Not Exist!");
        return -1;
    }
    else
    {
        *response_len = strlen(*response);
    }

    cJSON_Delete(response_root);

    return 0;
}

static int evs_service_feeModel_query_handler(const char *request, char **response, int *response_len)
{
    void *callback = NULL;
    cJSON *root = cJSON_Parse(request);
    cJSON *TimeSegArray, *chargeFeeArray, *serviceFeeArray;
    int i = 0;
    if (root == NULL || !cJSON_IsObject(root))
    {
        PROTOCOL_TRACE("JSON Parse Error");
        return -1;
    }

    evs_service_feedback_feeModel_qurey service_feedback_feeModel_query_data;
    memset(&service_feedback_feeModel_query_data, 0, sizeof(service_feedback_feeModel_query_data));

    callback = evs_service_callback(EVS_FEE_MODEL_QUERY_SRV);
    if (callback)
    {
        ((int (*)(evs_service_feedback_feeModel_qurey *))callback)(&service_feedback_feeModel_query_data);
    }
    cJSON *response_root = cJSON_CreateObject();

    cJSON_AddStringToObject(response_root, "feeModelId", service_feedback_feeModel_query_data.feeModelId);
    cJSON_AddNumberToObject(response_root, "timeNum", service_feedback_feeModel_query_data.timeNum);

    cJSON_AddItemToObject(response_root, "timeSeg", TimeSegArray = cJSON_CreateArray());
    for (i = 0; i < service_feedback_feeModel_query_data.timeNum; i++)
    {
        cJSON_AddItemToArray(TimeSegArray, cJSON_CreateString(service_feedback_feeModel_query_data.timeSeg[i]));
    }

    cJSON_AddItemToObject(response_root, "chargeFee", chargeFeeArray = cJSON_CreateArray());
    for (i = 0; i < service_feedback_feeModel_query_data.timeNum; i++)
    {
        cJSON_AddItemToArray(chargeFeeArray, cJSON_CreateNumber(service_feedback_feeModel_query_data.chargeFee[i]));
    }

    cJSON_AddItemToObject(response_root, "serviceFee", serviceFeeArray = cJSON_CreateArray());
    for (i = 0; i < service_feedback_feeModel_query_data.timeNum; i++)
    {
        cJSON_AddItemToArray(serviceFeeArray, cJSON_CreateNumber(service_feedback_feeModel_query_data.serviceFee[i]));
    }

    *response = cJSON_PrintUnformatted(response_root);

    if (*response == NULL)
    {
        PROTOCOL_TRACE("Json Not Exist!");
        return -1;
    }
    else
    {
        *response_len = strlen(*response);
    }

    cJSON_Delete(root);
    cJSON_Delete(response_root);

    return 0;
}

static int evs_service_reserve_charge_handler(const char *request, char **response, int *response_len)
{
    void *callback;
    cJSON *root = cJSON_Parse(request);
    if (root == NULL || !cJSON_IsObject(root))
    {
        PROTOCOL_TRACE("JSON Parse Error");
        return -1;
    }

    evs_service_rsvCharge service_reserve_charge_data;
    evs_service_feedback_rsvCharge service_feedback_reserve_charge_data;
    memset(&service_reserve_charge_data, 0, sizeof(service_reserve_charge_data));

    cJSON *item_gunNo = cJSON_GetObjectItem(root, "gunNo");
    if (item_gunNo != NULL && cJSON_IsNumber(item_gunNo))
    {
        service_reserve_charge_data.gunNo = item_gunNo->valueint;
    }
    else
    {
        PROTOCOL_TRACE("JSON Parse 'gunNo' Error");
        cJSON_Delete(root);
        return -1;
    }

    cJSON *item_appoMethod = cJSON_GetObjectItem(root, "appoMethod");
    if (item_appoMethod != NULL && cJSON_IsNumber(item_appoMethod))
    {
        service_reserve_charge_data.appoMethod = item_appoMethod->valueint;
    }
    else
    {
        PROTOCOL_TRACE("JSON Parse 'appoMethod' Error");
        cJSON_Delete(root);
        return -1;
    }

    cJSON *item_appoDelay = cJSON_GetObjectItem(root, "appoDelay");
    if (item_appoDelay != NULL && cJSON_IsNumber(item_appoDelay))
    {
        service_reserve_charge_data.appoDelay = item_appoDelay->valueint;
    }
    else
    {
        PROTOCOL_TRACE("JSON Parse 'appoDelay' Error");
        cJSON_Delete(root);
        return -1;
    }

    cJSON *item_appoData = cJSON_GetObjectItem(root, "appoData");
    if (item_appoData != NULL && cJSON_IsNumber(item_appoDelay))
    {
        service_reserve_charge_data.appoData = item_appoData->valueint;
    }
    else
    {
        PROTOCOL_TRACE("JSON Parse 'appoData' Error");
        cJSON_Delete(root);
        return -1;
    }

    cJSON *item_startChargeTime = cJSON_GetObjectItem(root, "startChargeTime");
    if (item_startChargeTime != NULL && cJSON_IsString(item_startChargeTime))
    {
        char *startChargeTime = item_startChargeTime->valuestring;
        service_reserve_charge_data.startChargeTime = strtoint(startChargeTime);
    }
    else
    {
        PROTOCOL_TRACE("JSON Parse 'startChargeTime' Error");
        cJSON_Delete(root);
        return -1;
    }

    cJSON *item_stopChargeTime = cJSON_GetObjectItem(root, "stopChargeTime");
    if (item_stopChargeTime != NULL && cJSON_IsString(item_stopChargeTime))
    {
        char *stopChargeTime = item_stopChargeTime->valuestring;
        service_reserve_charge_data.stopChargeTime = strtoint(stopChargeTime);
    }
    else
    {
        PROTOCOL_TRACE("JSON Parse 'stopChargeTime' Error");
        cJSON_Delete(root);
        return -1;
    }

    callback = evs_service_callback(EVS_RSV_CHARGE_SRV);
    if (callback)
    {
        ((int (*)(const evs_service_rsvCharge *, evs_service_feedback_rsvCharge *))callback)(&service_reserve_charge_data, &service_feedback_reserve_charge_data);
    }
    cJSON *response_root = cJSON_CreateObject();

    cJSON_AddNumberToObject(response_root, "gunNo", service_feedback_reserve_charge_data.gunNo);
    cJSON_AddNumberToObject(response_root, "appoMethod", service_feedback_reserve_charge_data.appoMethod);
    cJSON_AddNumberToObject(response_root, "result", service_feedback_reserve_charge_data.result);

    *response = cJSON_PrintUnformatted(response_root);

    if (*response == NULL)
    {
        PROTOCOL_TRACE("Json Not Exist!");
        return -1;
    }
    else
    {
        *response_len = strlen(*response);
    }

    cJSON_Delete(root);
    cJSON_Delete(response_root);

    return 0;
}

static int evs_service_ble_secret_update_handler(const char *request, char **response, int *response_len)
{
    void *callback;
    cJSON *root = cJSON_Parse(request);
    if (root == NULL || !cJSON_IsObject(root))
    {
        PROTOCOL_TRACE("JSON Parse Error");
        return -1;
    }

    evs_service_blesecret_update service_ble_secret_data;
    evs_service_feedback_blesecret_update service_feedback_ble_secret_data;
    memset(&service_ble_secret_data, 0, sizeof(service_ble_secret_data));
    memset(&service_feedback_ble_secret_data, 0, sizeof(service_feedback_ble_secret_data));

    cJSON *item_bleSecretKey = cJSON_GetObjectItem(root, "bleSecretKey");
    if (item_bleSecretKey != NULL && cJSON_IsString(item_bleSecretKey))
    {
        char *bleSecretKey = item_bleSecretKey->valuestring;
        memcpy(service_ble_secret_data.bleSecretKey, bleSecretKey, strlen(bleSecretKey));
    }
    else
    {
        PROTOCOL_TRACE("JSON Parse 'bleSecretKey' Error");
        cJSON_Delete(root);
        return -1;
    }

    cJSON *item_updateTime = cJSON_GetObjectItem(root, "updateTime");
    if (item_updateTime != NULL && cJSON_IsString(item_updateTime))
    {
        char *updateTime = item_updateTime->valuestring;
        service_ble_secret_data.updateTime = strtoint(updateTime);
    }
    else
    {
        PROTOCOL_TRACE("JSON Parse 'updateTime' Error");
        cJSON_Delete(root);
        return -1;
    }

    callback = evs_service_callback(EVS_BLE_SECRET_UPDATE_SRV);
    if (callback)
    {
        ((int (*)(const evs_service_blesecret_update *, evs_service_feedback_blesecret_update *))callback)(&service_ble_secret_data, &service_feedback_ble_secret_data);
    }
    cJSON *response_root = cJSON_CreateObject();

    cJSON_AddStringToObject(response_root, "bleSecretKey", service_feedback_ble_secret_data.bleSecretKey);
    cJSON_AddNumberToObject(response_root, "result", service_feedback_ble_secret_data.result);

    *response = cJSON_PrintUnformatted(response_root);

    if (*response == NULL)
    {
        PROTOCOL_TRACE("Json Not Exist!");
        return -1;
    }
    else
    {
        *response_len = strlen(*response);
    }

    cJSON_Delete(root);
    cJSON_Delete(response_root);

    return 0;
}

static int evs_service_ble_auth_list_get_handler(const char *request, char **response, int *response_len)
{
    void *callback;
    cJSON *root = cJSON_Parse(request);
    cJSON *macListArray = NULL;
    int i = 0;

    if (root == NULL || !cJSON_IsObject(root))
    {
        PROTOCOL_TRACE("JSON Parse Error");
        return -1;
    }

    evs_event_ble_plug_charge_info service_feedback_ble_plugchg_data;
    memset(&service_feedback_ble_plugchg_data, 0, sizeof(service_feedback_ble_plugchg_data));

    callback = evs_service_callback(EVS_BLE_PLUG_CHG_INFO_GET_SRV);
    if (callback)
    {
        ((int (*)(evs_event_ble_plug_charge_info *))callback)(&service_feedback_ble_plugchg_data);
    }
    cJSON *response_root = cJSON_CreateObject();

    cJSON_AddNumberToObject(response_root, "plugChgStatus", service_feedback_ble_plugchg_data.plugChgStatus);
    cJSON_AddNumberToObject(response_root, "macNum", service_feedback_ble_plugchg_data.macNum);

    cJSON_AddItemToObject(response_root, "macList", macListArray = cJSON_CreateArray());
    for (i = 0; i < service_feedback_ble_plugchg_data.macNum; i++)
    {
        cJSON_AddItemToArray(macListArray, cJSON_CreateString(service_feedback_ble_plugchg_data.macList[i]));
    }

    *response = cJSON_PrintUnformatted(response_root);

    if (*response == NULL)
    {
        PROTOCOL_TRACE("Json Not Exist!");
        return -1;
    }
    else
    {
        *response_len = strlen(*response);
    }

    cJSON_Delete(root);
    cJSON_Delete(response_root);

    return 0;
}

static int evs_service_ble_auth_list_confirm_handler(const char *request, char **response, int *response_len)
{
    void *callback;
    cJSON *root = cJSON_Parse(request);

    if (root == NULL || !cJSON_IsObject(root))
    {
        PROTOCOL_TRACE("JSON Parse Error");
        return -1;
    }

    evs_service_ble_plug_charge_info_conf service_ble_plugchg_confirm;
    memset(&service_ble_plugchg_confirm, 0, sizeof(service_ble_plugchg_confirm));

    cJSON *item_macNum = cJSON_GetObjectItem(root, "macNum");
    if (item_macNum != NULL && cJSON_IsNumber(item_macNum))
    {
        service_ble_plugchg_confirm.macNum = item_macNum->valueint;
    }
    else
    {
        PROTOCOL_TRACE("JSON Parse 'macNum' Error");
        cJSON_Delete(root);
        return -1;
    }

    callback = evs_service_callback(EVS_BLE_PLUG_CHG_INFO_CONF_SRV);
    if (callback)
    {
        ((int (*)(evs_service_ble_plug_charge_info_conf *))callback)(&service_ble_plugchg_confirm);
    }

    cJSON_Delete(root);

    return 0;
}

static int evs_service_ble_auth_list_clean_handler(const char *request, char **response, int *response_len)
{
    void *callback;
    cJSON *root = cJSON_Parse(request);

    if (root == NULL || !cJSON_IsObject(root))
    {
        PROTOCOL_TRACE("JSON Parse Error");
        return -1;
    }

    evs_service_blelist_clean service_blelist_clean_data;
    evs_service_feedback_blelist_clean service_feedback_blelist_clean_data;
    memset(&service_blelist_clean_data, 0, sizeof(service_blelist_clean_data));
    memset(&service_feedback_blelist_clean_data, 0, sizeof(service_feedback_blelist_clean_data));

    cJSON *item_cleanType = cJSON_GetObjectItem(root, "cleanType");
    if (item_cleanType != NULL && cJSON_IsNumber(item_cleanType))
    {
        service_blelist_clean_data.cleanType = item_cleanType->valueint;
    }
    else
    {
        PROTOCOL_TRACE("JSON Parse 'cleanType' Error");
        cJSON_Delete(root);
        return -1;
    }

    cJSON *item_macInfo = cJSON_GetObjectItem(root, "macInfo");
    if (item_macInfo != NULL && cJSON_IsString(item_macInfo))
    {
        char *macInfo = item_macInfo->valuestring;
        memcpy(service_blelist_clean_data.macInfo, macInfo, strlen(macInfo));
    }
    else
    {
        PROTOCOL_TRACE("JSON Parse 'macInfo' Error");
        cJSON_Delete(root);
        return -1;
    }

    callback = evs_service_callback(EVS_BLE_AUTH_LIST_CLEAN_SRV);
    if (callback)
    {
        ((int (*)(const evs_service_blelist_clean *, evs_service_feedback_blelist_clean *))callback)(&service_blelist_clean_data, &service_feedback_blelist_clean_data);
    }

    cJSON *response_root = cJSON_CreateObject();

    cJSON_AddNumberToObject(response_root, "cleanType", service_feedback_blelist_clean_data.cleanType);
    cJSON_AddNumberToObject(response_root, "result", service_feedback_blelist_clean_data.result);

    *response = cJSON_PrintUnformatted(response_root);

    if (*response == NULL)
    {
        PROTOCOL_TRACE("Json Not Exist!");
        return -1;
    }
    else
    {
        *response_len = strlen(*response);
    }
    cJSON_Delete(root);
    cJSON_Delete(response_root);

    return 0;
}

static int evs_service_ble_reset_handler(const char *request, char **response, int *response_len)
{
    void *callback;

    evs_service_feedback_ble_reset service_feedback_ble_reset_data;
    memset(&service_feedback_ble_reset_data, 0, sizeof(service_feedback_ble_reset_data));

    callback = evs_service_callback(EVS_BLE_RESET_SRV);
    if (callback)
    {
        ((int (*)(evs_service_feedback_ble_reset *))callback)(&service_feedback_ble_reset_data);
    }
    cJSON *response_root = cJSON_CreateObject();

    cJSON_AddNumberToObject(response_root, "result", service_feedback_ble_reset_data.result);

    *response = cJSON_PrintUnformatted(response_root);

    if (*response == NULL)
    {
        PROTOCOL_TRACE("Json Not Exist!");
        return -1;
    }
    else
    {
        *response_len = strlen(*response);
    }

    cJSON_Delete(response_root);

    return 0;
}

static int evs_service_get_parts_config_handler(const char *request, char **response, int *response_len)
{

    void *callback;
    cJSON *root = cJSON_Parse(request);
    evs_service_parts_config_get service_parts_config_data;
    evs_service_feedback_config_parts_get service_feedback_get_config_data;

    memset(&service_parts_config_data, 0, sizeof(service_parts_config_data));
    memset(&service_feedback_get_config_data, 0, sizeof(service_feedback_get_config_data));

    cJSON *item_gunNo = cJSON_GetObjectItem(root, "gunNo");
    if (item_gunNo != NULL && cJSON_IsNumber(item_gunNo))
    {
        service_parts_config_data.gunNo = item_gunNo->valueint;
    }
    else
    {
        PROTOCOL_TRACE("JSON Parse 'gunNo' Error");
        cJSON_Delete(root);
        return -1;
    }

    cJSON *item_partsType = cJSON_GetObjectItem(root, "partsType");
    if (item_partsType != NULL && cJSON_IsNumber(item_partsType))
    {
        service_parts_config_data.partsType = item_partsType->valueint;
    }
    else
    {
        PROTOCOL_TRACE("JSON Parse 'partsType' Error");
        cJSON_Delete(root);
        return -1;
    }

    cJSON *item_funCode = cJSON_GetObjectItem(root, "funCode");
    if (item_funCode != NULL && cJSON_IsNumber(item_funCode))
    {
        service_parts_config_data.funCode = item_funCode->valueint;
    }
    else
    {
        PROTOCOL_TRACE("JSON Parse 'funCode' Error");
        cJSON_Delete(root);
        return -1;
    }

    callback = evs_service_callback(EVS_PILE_PARTS_CONF_GET_SRV);
    if (callback)
    {
        ((int (*)(const evs_service_parts_config_get *, evs_service_feedback_config_parts_get *))callback)(&service_parts_config_data, &service_feedback_get_config_data);
    }

    cJSON *response_root = cJSON_CreateObject();

    cJSON_AddNumberToObject(response_root, "result", service_feedback_get_config_data.result);
    cJSON_AddNumberToObject(response_root, "confInt", service_feedback_get_config_data.confInt);
    cJSON_AddStringToObject(response_root, "confString", service_feedback_get_config_data.confString);

    *response = cJSON_PrintUnformatted(response_root);
    if (*response == NULL)
    {
        PROTOCOL_TRACE("Json Not Exist!");
        return -1;
    }
    else
    {
        *response_len = strlen(*response);
    }

    cJSON_Delete(response_root);

    return 0;
}

static int evs_service_parts_config_handler(const char *request, char **response, int *response_len)
{
    PROTOCOL_TRACE("recv parts config");
    void *callback;

    cJSON *root = cJSON_Parse(request);

    if (root == NULL || !cJSON_IsObject(root))
    {
        PROTOCOL_TRACE("JSON Parse Error");
        return -1;
    }

    evs_service_config_parts service_parts_config_data;
    evs_service_feedback_config_parts result = {0};
    memset(&service_parts_config_data, 0, sizeof(evs_service_config_parts));

    cJSON *item_gunNo = cJSON_GetObjectItem(root, "gunNo");
    if (item_gunNo != NULL && cJSON_IsNumber(item_gunNo))
    {
        service_parts_config_data.gunNo = item_gunNo->valueint;
    }
    else
    {
        PROTOCOL_TRACE("JSON Parse 'gunNo' Error");
        cJSON_Delete(root);
        return -1;
    }

    cJSON *item_opSn = cJSON_GetObjectItem(root, "optSn");
    if (item_opSn != NULL && cJSON_IsString(item_opSn))
    {
        memcpy(service_parts_config_data.optSn, item_opSn->valuestring, strlen(item_opSn->valuestring));
    }
    else
    {
        PROTOCOL_TRACE("JSON Parse 'optSn' Error");
        cJSON_Delete(root);
        return -1;
    }

    cJSON *item_funCode = cJSON_GetObjectItem(root, "funCode");
    if (item_funCode != NULL && cJSON_IsNumber(item_funCode))
    {
        service_parts_config_data.funCode = item_funCode->valueint;
    }
    else
    {
        PROTOCOL_TRACE("JSON Parse 'funCode' Error");
        cJSON_Delete(root);
        return -1;
    }

    // cJSON *item_conf = cJSON_GetObjectItem(root, "confInfo");
    // if (item_conf != NULL && cJSON_IsObject(item_conf))
    // {
    //     cJSON *item_power = cJSON_GetObjectItem(item_conf, "powerAlloc");
    //     if (item_power != NULL && cJSON_IsNumber(item_power))
    //     {
    //         service_parts_config_data.powerAlloc = item_power->valueint;
    //     }

    //     cJSON *item_partsType = cJSON_GetObjectItem(item_conf, "partsType");
    //     if (item_partsType != NULL && cJSON_IsNumber(item_partsType))
    //     {
    //         service_parts_config_data.partsType = item_partsType->valueint;
    //     }

    //     cJSON *item_sendMode = cJSON_GetObjectItem(item_conf, "sendMode");
    //     if (item_sendMode != NULL && cJSON_IsNumber(item_sendMode))
    //     {
    //         service_parts_config_data.sendMode = item_sendMode->valueint;
    //     }

    //     cJSON *item_ccuPeriod = cJSON_GetObjectItem(item_conf, "ccuPeriod");
    //     if (item_ccuPeriod != NULL && cJSON_IsNumber(item_ccuPeriod))
    //     {
    //         service_parts_config_data.ccuPeriod = item_ccuPeriod->valueint;
    //     }

    //     cJSON *item_tcuPeriod = cJSON_GetObjectItem(item_conf, "tcuPeriod");
    //     if (item_tcuPeriod != NULL && cJSON_IsNumber(item_tcuPeriod))
    //     {
    //         service_parts_config_data.tcuPeriod = item_tcuPeriod->valueint;
    //     }
    // }
    // else
    // {
    //     PROTOCOL_TRACE("JSON Parse 'confInfo' Error");
    //     cJSON_Delete(root);
    //     return -1;
    // }

    if (service_parts_config_data.funCode == 11)
    {
        cJSON *item_confString = cJSON_GetObjectItem(root, "confString");
        if (item_confString != NULL && cJSON_IsString(item_confString))
        {
            char *confString = item_confString->valuestring;
            memcpy(service_parts_config_data.confString, confString, strlen(confString));
        }
        else
        {
            PROTOCOL_TRACE("JSON Parse 'confString' Error");
            cJSON_Delete(root);
            return -1;
        }
    }
    else if (service_parts_config_data.funCode == 10)
    {
        cJSON *item_confInt = cJSON_GetObjectItem(root, "confInt");
        if (item_confInt != NULL && cJSON_IsNumber(item_confInt))
        {
            service_parts_config_data.confInt = item_confInt->valueint;
        }
        else
        {
            PROTOCOL_TRACE("JSON Parse 'confInt' Error");
            cJSON_Delete(root);
            return -1;
        }
    }

    callback = evs_service_callback(EVS_PILE_PARTS_CONF_SRV);
    if (callback)
    {
        ((int (*)(const evs_service_config_parts *, evs_service_feedback_config_parts *))callback)(&service_parts_config_data, &result);
    }

    cJSON *response_root = cJSON_CreateObject();
    cJSON_AddNumberToObject(response_root, "resCode", result.resCode);
    cJSON_AddStringToObject(response_root, "optSn", result.optSn);
    cJSON_AddNumberToObject(response_root, "funCode", result.funCode);

    *response = cJSON_PrintUnformatted(response_root);

    if (*response == NULL)
    {
        PROTOCOL_TRACE("Json Not Exist!");
        return -1;
    }
    else
    {
        *response_len = strlen(*response);
    }

    cJSON_Delete(root);
    cJSON_Delete(response_root);

    return 0;
}

static int evs_service_vin_whitelist_handler(const char *request, char **response, int *response_len)
{
    void *callback;
    cJSON *root = cJSON_Parse(request);
    if (root == NULL || !cJSON_IsObject(root))
    {
        PROTOCOL_TRACE("JSON Parse Error");
        return -1;
    }

    evs_service_vinList_update service_vinList_data;
    evs_service_feedback_vinList_update service_feedback_vinList_data;
    int i = 0;
    memset(&service_vinList_data, 0, sizeof(evs_service_vinList_update));

    cJSON *item_updateSN = cJSON_GetObjectItem(root, "updateSN");
    if (item_updateSN != NULL && cJSON_IsString(item_updateSN))
    {
        char *updateSN = item_updateSN->valuestring;
        memcpy(service_vinList_data.updateSN, updateSN, strlen(updateSN));
    }

    cJSON *item_optType = cJSON_GetObjectItem(root, "optType");
    if (item_optType != NULL && cJSON_IsNumber(item_optType))
    {
        service_vinList_data.optType = item_optType->valueint;
    }

    cJSON *item_num = cJSON_GetObjectItem(root, "totalVINCnt");
    if (item_num != NULL && cJSON_IsNumber(item_num))
    {
        service_vinList_data.totalVINCnt = item_num->valueint;
    }

    item_num = cJSON_GetObjectItem(root, "packTotalCnt");
    if (item_num != NULL && cJSON_IsNumber(item_num))
    {
        service_vinList_data.packTotalCnt = item_num->valueint;
    }

    item_num = cJSON_GetObjectItem(root, "packCnt");
    if (item_num != NULL && cJSON_IsNumber(item_num))
    {
        service_vinList_data.packCnt = item_num->valueint;
    }

    item_num = cJSON_GetObjectItem(root, "packVINCnt");
    if (item_num != NULL && cJSON_IsNumber(item_num))
    {
        service_vinList_data.packVINCnt = item_num->valueint;
    }

    cJSON *item_vinList = cJSON_GetObjectItem(root, "vinList");
    cJSON *array_vinList = NULL;
    if (item_vinList != NULL && cJSON_IsArray(item_vinList))
    {

        for (i = 0; i < service_vinList_data.packVINCnt; i++)
        {
            array_vinList = cJSON_GetArrayItem(array_vinList, i);
            memcpy(service_vinList_data.vinList[i], array_vinList->valuestring, strlen(array_vinList->valuestring));
        }
    }

    callback = evs_service_callback(EVS_VIN_LIST_UPDATE_SRV);
    if (callback)
    {
        ((int (*)(const evs_service_vinList_update *, evs_service_feedback_vinList_update *))callback)(&service_vinList_data, &service_feedback_vinList_data);
    }

    cJSON *response_root = cJSON_CreateObject();
    cJSON_AddStringToObject(response_root, "updateSN", service_feedback_vinList_data.updateSN);
    cJSON_AddNumberToObject(response_root, "optType", service_feedback_vinList_data.optType);
    cJSON_AddNumberToObject(response_root, "result", service_feedback_vinList_data.result);

    *response = cJSON_PrintUnformatted(response_root);

    if (*response == NULL)
    {
        PROTOCOL_TRACE("Json Not Exist!");
        return -1;
    }
    else
    {
        *response_len = strlen(*response);
    }

    cJSON_Delete(root);
    cJSON_Delete(response_root);

    return 0;
}

static int evs_service_get_trade_handler(const char *request, char **response, int *response_len)
{

    void *callback;
    cJSON *root = cJSON_Parse(request);
    evs_service_trade_get service_get_trade_data;
    evs_service_feedback_trade_get service_dev_feedback_trade_data;

    memset(&service_get_trade_data, 0, sizeof(service_get_trade_data));
    memset(&service_dev_feedback_trade_data, 0, sizeof(service_dev_feedback_trade_data));

    cJSON *item_gunNo = cJSON_GetObjectItem(root, "gunNo");
    if (item_gunNo != NULL && cJSON_IsNumber(item_gunNo))
    {
        service_get_trade_data.gunNo = item_gunNo->valueint;
    }

    cJSON *item_askType = cJSON_GetObjectItem(root, "askType");
    if (item_askType != NULL && cJSON_IsNumber(item_askType))
    {
        service_get_trade_data.askType = item_askType->valueint;
    }

    cJSON *item_preTradeNo = cJSON_GetObjectItem(root, "preTradeNo");
    if (item_preTradeNo != NULL && cJSON_IsString(item_preTradeNo))
    {
        char *tradeNo = item_preTradeNo->valuestring;
        memcpy(service_get_trade_data.preTradeNo, tradeNo, strlen(tradeNo));
    }

    cJSON *item_tradeNo = cJSON_GetObjectItem(root, "tradeNo");
    if (item_tradeNo != NULL && cJSON_IsString(item_tradeNo))
    {
        char *tradeNo = item_tradeNo->valuestring;
        memcpy(service_get_trade_data.tradeNo, tradeNo, strlen(tradeNo));
    }

    cJSON *item_startDate = cJSON_GetObjectItem(root, "startDate");
    if (item_startDate != NULL && cJSON_IsString(item_startDate))
    {
        char *startDate = item_startDate->valuestring;
        memcpy(service_get_trade_data.startDate, startDate, strlen(startDate));
    }

    cJSON *item_stopDate = cJSON_GetObjectItem(root, "stopDate");
    if (item_stopDate != NULL && cJSON_IsString(item_stopDate))
    {
        char *stopDate = item_stopDate->valuestring;
        memcpy(service_get_trade_data.stopDate, stopDate, strlen(stopDate));
    }

    callback = evs_service_callback(EVS_ORDER_ASK_SRV);
    if (callback)
    {
        ((int (*)(const evs_service_trade_get *, evs_service_feedback_trade_get *))callback)(&service_get_trade_data, &service_dev_feedback_trade_data);
    }

    cJSON *response_root = cJSON_CreateObject();

    cJSON_AddNumberToObject(response_root, "gunNo", service_dev_feedback_trade_data.gunNo);
    cJSON_AddNumberToObject(response_root, "askType", service_dev_feedback_trade_data.askType);
    cJSON_AddStringToObject(response_root, "preTradeNo", service_dev_feedback_trade_data.preTradeNo);
    cJSON_AddStringToObject(response_root, "tradeNo", service_dev_feedback_trade_data.tradeNo);
    cJSON_AddStringToObject(response_root, "startDate", service_dev_feedback_trade_data.startDate);
    cJSON_AddStringToObject(response_root, "stopDate", service_dev_feedback_trade_data.stopDate);
    cJSON_AddNumberToObject(response_root, "askResult", service_dev_feedback_trade_data.askResult);
    cJSON_AddNumberToObject(response_root, "tradeCnt", service_dev_feedback_trade_data.tradeCnt);

    *response = cJSON_PrintUnformatted(response_root);
    if (*response == NULL)
    {
        PROTOCOL_TRACE("Json Not Exist!");
        return -1;
    }
    else
    {
        *response_len = strlen(*response);
    }

    cJSON_Delete(response_root);

    return 0;
}

static int evs_service_get_meter_handler(const char *request, char **response, int *response_len)
{

    void *callback;
    cJSON *root = cJSON_Parse(request);
    evs_service_meter_get service_get_meter_data;
    evs_service_feedback_meter_get service_dev_feedback_meter_data;

    memset(&service_get_meter_data, 0, sizeof(service_get_meter_data));
    memset(&service_dev_feedback_meter_data, 0, sizeof(service_dev_feedback_meter_data));

    cJSON *item_gunNo = cJSON_GetObjectItem(root, "gunNo");
    if (item_gunNo != NULL && cJSON_IsNumber(item_gunNo))
    {
        service_get_meter_data.gunNo = item_gunNo->valueint;
    }

    cJSON *item_askDate = cJSON_GetObjectItem(root, "askDate");
    if (item_askDate != NULL && cJSON_IsString(item_askDate))
    {
        char *askDate = item_askDate->valuestring;
        memcpy(service_get_meter_data.askDate, askDate, strlen(askDate));
    }

    cJSON *item_askType = cJSON_GetObjectItem(root, "askType");
    if (item_askType != NULL && cJSON_IsNumber(item_askType))
    {
        service_get_meter_data.askType = item_askType->valueint;
    }

    callback = evs_service_callback(EVS_Meter_ASK_SRV);
    if (callback)
    {
        ((int (*)(const evs_service_meter_get *, evs_service_feedback_meter_get *))callback)(&service_get_meter_data, &service_dev_feedback_meter_data);
    }

    cJSON *response_root = cJSON_CreateObject();

    cJSON_AddNumberToObject(response_root, "gunNo", service_dev_feedback_meter_data.gunNo);
    cJSON_AddStringToObject(response_root, "askDate", service_dev_feedback_meter_data.askDate);
    cJSON_AddNumberToObject(response_root, "askType", service_dev_feedback_meter_data.askType);
    cJSON_AddNumberToObject(response_root, "askResult", service_dev_feedback_meter_data.askResult);

    *response = cJSON_PrintUnformatted(response_root);
    if (*response == NULL)
    {
        PROTOCOL_TRACE("Json Not Exist!");
        return -1;
    }
    else
    {
        *response_len = strlen(*response);
    }

    cJSON_Delete(response_root);

    return 0;
}

static int evs_service_time_sync_handler(const char *request, char **response, int *response_len)
{
    char time_buf[20] = {0};
    cJSON *root = cJSON_Parse(request);

    cJSON *item_time = cJSON_GetObjectItem(root, "srvTime");
    if (item_time != NULL && cJSON_IsString(item_time))
    {
        memcpy(time_buf, item_time->valuestring, strlen(item_time->valuestring));
    }

    PROTOCOL_TRACE("Current Timestamp: %s", time_buf);
    unsigned int time = strtoint(time_buf);

    void *callback;
    callback = evs_service_callback(EVS_TIME_SYNC);
    if (callback)
    {
        ((int (*)(unsigned int))callback)(time);
    }

    return 0;
}

/** 浜嬩欢鍥炶皟锛氭帴鏀跺埌浜戯拷??涓嬪彂鐨勬湇鍔★拷?锟芥眰 **/
static int user_service_request_event_handler(const int devid, const char *serviceid, const int serviceid_len,
                                              const char *request, const int request_len,
                                              char **response, int *response_len)
{
    int add_result = 0;

    const char *response_fmt = "{\"Result\": %d}";

    PROTOCOL_TRACE("Service Request Received, Service ID: %.*s, Payload: %s", serviceid_len, serviceid, request);

    if (strlen("feeModelTwUpdateSrv") == serviceid_len && memcmp("feeModelTwUpdateSrv", serviceid, serviceid_len) == 0)
    {
        evs_service_issue_feeModel_handler(request, response, response_len);
    }
    if (strlen("startChargeSrv") == serviceid_len && memcmp("startChargeSrv", serviceid, serviceid_len) == 0)
    {
        evs_service_startCharge_handler(request, response, response_len);
    }

    if (strlen("authResultSrv") == serviceid_len && memcmp("authResultSrv", serviceid, serviceid_len) == 0)
    {
        evs_service_authCharge_handler(request, response, response_len);
    }

    if (strlen("stopChargeSrv") == serviceid_len && memcmp("stopChargeSrv", serviceid, serviceid_len) == 0)
    {
        evs_service_stopCharge_handler(request, response, response_len);
    }

    if (strlen("orderCheckSrv") == serviceid_len && memcmp("orderCheckSrv", serviceid, serviceid_len) == 0)
    {
        evs_service_confirmTrade_handler(request, response, response_len);
    }
    if (strlen("queDataSrv") == serviceid_len && memcmp("queDataSrv", serviceid, serviceid_len) == 0)
    {
        evs_service_query_log_handler(request, response, response_len);
    }
    if (strlen("gateLockSrv") == serviceid_len && memcmp("gateLockSrv", serviceid, serviceid_len) == 0)
    {
        evs_service_gateLock_ctrl_handler(request, response, response_len);
    }
    if (strlen("groundLockSrv") == serviceid_len && memcmp("groundLockSrv", serviceid, serviceid_len) == 0)
    {
        evs_service_groundLock_ctrl_handler(request, response, response_len);
    }
    if (strlen("ctrlLockSrv") == serviceid_len && memcmp("ctrlLockSrv", serviceid, serviceid_len) == 0)
    {
        evs_service_lockCtrl_handler(request, response, response_len);
    }
    if (strlen("devMaintainCtrlSrv") == serviceid_len && memcmp("devMaintainCtrlSrv", serviceid, serviceid_len) == 0)
    {
        evs_service_dev_maintain_handler(request, response, response_len);
    }
    if (strlen("acOrderlyChargeSrv") == serviceid_len && memcmp("acOrderlyChargeSrv", serviceid, serviceid_len) == 0)
    {
        evs_service_orderCharge_handler(request, response, response_len);
    }
    if (strlen("dcOrderlyChargeSrv") == serviceid_len && memcmp("dcOrderlyChargeSrv", serviceid, serviceid_len) == 0)
    {
        evs_service_orderCharge_handler(request, response, response_len);
    }
    if (strlen("confUpdateCtrlSrv") == serviceid_len && memcmp("confUpdateCtrlSrv", serviceid, serviceid_len) == 0)
    {
        evs_service_update_config_handler(request, response, response_len);
    }
    if (strlen("getDevConfSrv") == serviceid_len && memcmp("getDevConfSrv", serviceid, serviceid_len) == 0)
    {
        evs_service_get_config_handler(request, response, response_len);
    }
    if (strlen("devMaintainQuerySrv") == serviceid_len && memcmp("devMaintainQuerySrv", serviceid, serviceid_len) == 0)
    {
        evs_service_get_Maintain_handler(request, response, response_len);
    }
    if (strlen("srvAuthCodeSrv") == serviceid_len && memcmp("srvAuthCodeSrv", serviceid, serviceid_len) == 0)
    {
        evs_service_srvAuthCode_handler(request, response, response_len);
    }
    if (strlen("termSnSrv") == serviceid_len && memcmp("termSnSrv", serviceid, serviceid_len) == 0)
    {
        evs_service_terminalSn_handler(request, response, response_len);
    }
    if (strlen("funConfUpdateDataSrv") == serviceid_len && memcmp("funConfUpdateDataSrv", serviceid, serviceid_len) == 0)
    {
        evs_service_update_fun_config_handler(request, response, response_len);
    }
    if (strlen("getFunConfSrv") == serviceid_len && memcmp("getFunConfSrv", serviceid, serviceid_len) == 0)
    {
        evs_service_get_fun_config_handler(request, response, response_len);
    }
    if (strlen("feeModelTwQuerySrv") == serviceid_len && memcmp("feeModelTwQuerySrv", serviceid, serviceid_len) == 0)
    {
        evs_service_feeModel_query_handler(request, response, response_len);
    }
    if (strlen("rsvChargeSrv") == serviceid_len && memcmp("rsvChargeSrv", serviceid, serviceid_len) == 0)
    {
        evs_service_reserve_charge_handler(request, response, response_len);
    }
    if (strlen("bleSecretUpdateSrv") == serviceid_len && memcmp("bleSecretUpdateSrv", serviceid, serviceid_len) == 0)
    {
        evs_service_ble_secret_update_handler(request, response, response_len);
    }
    if (strlen("getBlePlugChgInfoSrv") == serviceid_len && memcmp("getBlePlugChgInfoSrv", serviceid, serviceid_len) == 0)
    {
        evs_service_ble_auth_list_get_handler(request, response, response_len);
    }
    if (strlen("blePlugChgConfSrv") == serviceid_len && memcmp("blePlugChgConfSrv", serviceid, serviceid_len) == 0)
    {
        evs_service_ble_auth_list_confirm_handler(request, response, response_len);
    }
    if (strlen("bleAuthListCleanSrv") == serviceid_len && memcmp("bleAuthListCleanSrv", serviceid, serviceid_len) == 0)
    {
        evs_service_ble_auth_list_clean_handler(request, response, response_len);
    }
    if (strlen("bleResetSrv") == serviceid_len && memcmp("bleResetSrv", serviceid, serviceid_len) == 0)
    {
        evs_service_ble_reset_handler(request, response, response_len);
    }

    if (strlen("partsConfUpdateSrv") == serviceid_len && memcmp("partsConfUpdateSrv", serviceid, serviceid_len) == 0)
    {
        evs_service_parts_config_handler(request, response, response_len);
    }

    if (strlen("getPartsConfSrv") == serviceid_len && memcmp("getPartsConfSrv", serviceid, serviceid_len) == 0)
    {
        evs_service_get_parts_config_handler(request, response, response_len);
    }

    if (strlen("vinListUpdateSrv") == serviceid_len && memcmp("vinListUpdateSrv", serviceid, serviceid_len) == 0)
    {
        evs_service_vin_whitelist_handler(request, response, response_len);
    }

    if (strlen("tradeRecordAskSrv") == serviceid_len && memcmp("tradeRecordAskSrv", serviceid, serviceid_len) == 0)
    {
        evs_service_get_trade_handler(request, response, response_len);
    }

    if (strlen("meterRecordAskSrv") == serviceid_len && memcmp("meterRecordAskSrv", serviceid, serviceid_len) == 0)
    {
        evs_service_get_meter_handler(request, response, response_len);
    }

    if (strlen("timeSyncSrv") == serviceid_len && memcmp("timeSyncSrv", serviceid, serviceid_len) == 0)
    {
        evs_service_time_sync_handler(request, response, response_len);
    }

    if (*response == NULL)
    {
        *response_len = strlen(response_fmt) + 10 + 1;
        *response = (char *)HAL_Malloc(*response_len);
        memset(*response, 0, *response_len);
        HAL_Snprintf(*response, *response_len, response_fmt, add_result);
        *response_len = strlen(*response);
    }

    return 0;
}

static int send_property_dcPile(evs_property_dcPile *data)
{
    int res = 0;
    char *payload = NULL;
    cJSON *root = NULL;
    cJSON *body = NULL;

    root = cJSON_CreateObject();

    cJSON_AddItemToObject(root, "dcDeRealItyTwData", body = cJSON_CreateObject());

    cJSON_AddNumberToObject(body, "netType", data->netType);
    cJSON_AddNumberToObject(body, "sigVal", data->sigVal);

    cJSON_AddNumberToObject(body, "netId", data->netId);

    cJSON_AddNumberToObject(body, "acVolA", data->acVolA);
    cJSON_AddNumberToObject(body, "acCurA", data->acCurA);

    cJSON_AddNumberToObject(body, "acVolB", data->acVolB);
    cJSON_AddNumberToObject(body, "acCurB", data->acCurB);

    cJSON_AddNumberToObject(body, "acVolC", data->acVolC);
    cJSON_AddNumberToObject(body, "acCurC", data->acCurC);

    cJSON_AddNumberToObject(body, "caseTemp", data->caseTemp);

    cJSON_AddStringToObject(body, "feeModelId", data->feeModelId);

    cJSON_AddNumberToObject(body, "outletTemp", data->outletTemp);
    cJSON_AddNumberToObject(body, "inletTemp", data->inletTemp);

    cJSON_AddNumberToObject(body, "caseHumidity", data->caseHumidity);
    cJSON_AddNumberToObject(body, "totalRam", data->totalRam);
    cJSON_AddNumberToObject(body, "ramUseRate", data->ramUseRate);

    cJSON_AddNumberToObject(body, "totalRom", data->totalRom);
    cJSON_AddNumberToObject(body, "romUseRate", data->romUseRate);

    cJSON_AddNumberToObject(body, "cpuUseRate", data->cpuUseRate);

    // sprintf(time, "%d", data->sysStartTime);
    // cJSON_AddStringToObject(body, "sysStartTime", time);
    cJSON_AddNumberToObject(body, "sysStartTime", data->sysStartTime);
    cJSON_AddNumberToObject(body, "sysWorkTime", data->sysWorkTime);

    payload = cJSON_PrintUnformatted(root);

    res = IOT_Linkkit_Report(evs_g_user_ctx.master_devid, ITM_MSG_POST_PROPERTY, (unsigned char *)payload, strlen(payload));
    if (root != NULL)
    {
        cJSON_Delete(root);
    }

    if (payload != NULL)
    {
        HAL_Free(payload);
    }

    PROTOCOL_TRACE("Post Property Message ID: %d", res);
    if (res < 0)
    {
        return -1;
    }
    return res;
}

static int send_property_acPile(evs_property_acPile *data)
{
    int res = 0;
    char *payload = NULL;
    cJSON *root = NULL;
    cJSON *body = NULL;

    root = cJSON_CreateObject();
    cJSON_AddItemToObject(root, "acDeRealItyData", body = cJSON_CreateObject());

    cJSON_AddNumberToObject(body, "netType", data->netType);
    cJSON_AddNumberToObject(body, "sigVal", data->sigVal);
    cJSON_AddNumberToObject(body, "netId", data->netId);

    cJSON_AddNumberToObject(body, "acVolA", data->acVolA);
    cJSON_AddNumberToObject(body, "acCurA", data->acCurA);

    cJSON_AddNumberToObject(body, "acVolB", data->acVolB);
    cJSON_AddNumberToObject(body, "acCurB", data->acCurB);

    cJSON_AddNumberToObject(body, "acVolC", data->acVolC);
    cJSON_AddNumberToObject(body, "acCurC", data->acCurC);

    cJSON_AddNumberToObject(body, "caseTemp", data->caseTemp);

    cJSON_AddStringToObject(body, "feeModelId", data->feeModelId);

    cJSON_AddNumberToObject(body, "totalRam", data->totalRam);
    cJSON_AddNumberToObject(body, "ramUseRate", data->ramUseRate);
    cJSON_AddNumberToObject(body, "totalRom", data->totalRom);
    cJSON_AddNumberToObject(body, "romUseRate", data->romUseRate);
    cJSON_AddNumberToObject(body, "cpuUseRate", data->cpuUseRate);

    cJSON_AddStringToObject(body, "netSigQua", data->netSigQua);
    cJSON_AddStringToObject(body, "devRunSampVal", data->devRunSampVal);

    payload = cJSON_PrintUnformatted(root);

    res = IOT_Linkkit_Report(evs_g_user_ctx.master_devid, ITM_MSG_POST_PROPERTY, (unsigned char *)payload, strlen(payload));
    if (root != NULL)
    {
        cJSON_Delete(root);
    }

    if (payload != NULL)
    {
        HAL_Free(payload);
    }

    PROTOCOL_TRACE("Post Property Message ID: %d", res);
    if (res < 0)
    {
        return -1;
    }
    return res;
}

// 浜ゆ祦闈炲厖鐢佃繃绋嬪疄鏃剁洃娴嬪睘锟�?
static int send_property_ac_nonwork(evs_property_ac_nonWork *data)
{
    int res = 0;
    char *payload = NULL;
    char Temp[20] = {0};
    cJSON *root = NULL;
    cJSON *body = NULL;

    root = cJSON_CreateObject();
    cJSON_AddItemToObject(root, "acGunIdleItyData", body = cJSON_CreateObject());
    cJSON_AddNumberToObject(body, "gunNo", data->gunNo);
    cJSON_AddNumberToObject(body, "workStatus", data->workStatus);

    cJSON_AddNumberToObject(body, "conStatus", data->conStatus);
    cJSON_AddNumberToObject(body, "outRelayStatus", data->outRelayStatus);
    cJSON_AddNumberToObject(body, "eLockStatus", data->eLockStatus);
    cJSON_AddNumberToObject(body, "gunTemp", data->gunTemp);

    cJSON_AddNumberToObject(body, "acVolA", data->acVolA);
    cJSON_AddNumberToObject(body, "acCurA", data->acCurA);

    cJSON_AddNumberToObject(body, "acVolB", data->acVolB);
    cJSON_AddNumberToObject(body, "acCurB", data->acCurB);

    cJSON_AddNumberToObject(body, "acVolC", data->acVolC);
    cJSON_AddNumberToObject(body, "acCurC", data->acCurC);

    sprintf(Temp, "%lld", data->sumMeter);
    cJSON_AddStringToObject(body, "sumMeter", Temp);

    payload = cJSON_PrintUnformatted(root);
    res = IOT_Linkkit_Report(evs_g_user_ctx.master_devid, ITM_MSG_POST_PROPERTY, (unsigned char *)payload, strlen(payload));
    if (root != NULL)
    {
        cJSON_Delete(root);
    }

    if (payload != NULL)
    {
        HAL_Free(payload);
    }

    PROTOCOL_TRACE("Post Property Message ID: %d", res);
    if (res < 0)
    {
        return -1;
    }
    return res;
}

// 浜ゆ祦鍏呯數杩囩▼瀹炴椂鐩戞祴灞烇拷?
static int send_property_ac_work(evs_property_ac_work *data)
{
    int res = 0;
    int i = 0;
    char *payload = NULL;
    char Temp[20] = {0};
    cJSON *root = NULL;
    cJSON *body = NULL;

    root = cJSON_CreateObject();
    cJSON_AddItemToObject(root, "acGunRunItyData", body = cJSON_CreateObject());

    cJSON_AddNumberToObject(body, "gunNo", data->gunNo);
    cJSON_AddNumberToObject(body, "workStatus", data->workStatus);
    cJSON_AddNumberToObject(body, "conStatus", data->conStatus);
    cJSON_AddNumberToObject(body, "eLockStatus", data->eLockStatus);
    cJSON_AddNumberToObject(body, "outRelayStatus", data->outRelayStatus);
    cJSON_AddNumberToObject(body, "gunTemp", data->gunTemp);

    cJSON_AddNumberToObject(body, "acVolA", data->acVolA);
    cJSON_AddNumberToObject(body, "acCurA", data->acCurA);

    cJSON_AddNumberToObject(body, "acVolB", data->acVolB);
    cJSON_AddNumberToObject(body, "acCurB", data->acCurB);

    cJSON_AddNumberToObject(body, "acVolC", data->acVolC);
    cJSON_AddNumberToObject(body, "acCurC", data->acCurC);

    cJSON_AddStringToObject(body, "preTradeNo", data->preTradeNo);
    cJSON_AddStringToObject(body, "tradeNo", data->tradeNo);

    cJSON_AddNumberToObject(body, "realPower", data->realPower);
    cJSON_AddNumberToObject(body, "chgTime", data->chgTime);

    cJSON_AddNumberToObject(body, "PwmDutyRadio", data->PwmDutyRadio);
    cJSON_AddNumberToObject(body, "s2SwhActNum", data->s2SwhActNum);

    memset(Temp, 0, 20);
    sprintf(Temp, "%lld", data->meterStartVal);
    cJSON_AddStringToObject(body, "meterStartVal", Temp);

    memset(Temp, 0, 20);
    sprintf(Temp, "%lld", data->meterRealVal);
    cJSON_AddStringToObject(body, "meterRealVal", Temp);

    cJSON_AddNumberToObject(body, "totalElect", data->totalElect);
    cJSON_AddNumberToObject(body, "totalCost", data->totalCost);
    cJSON_AddNumberToObject(body, "totalPowerCost", data->totalPowerCost);
    cJSON_AddNumberToObject(body, "totalServCost", data->totalServCost);

    cJSON_AddNumberToObject(body, "timeNum", data->timeNum);

    int segCnt = data->timeNum;
    if (segCnt > 0 && segCnt < EVS_MAX_MODEL_DEVSEG + 1)
    {
        int str_len = 0;

        char *tempTarriff = (char *)HAL_Malloc(8 * segCnt);
        memset(tempTarriff, 0, 8 * segCnt);

        for (i = 0; i < segCnt; i++)
        {
            sprintf(tempTarriff + str_len, "%d,", data->partElect[i]);
            str_len = strlen(tempTarriff);
        }

        tempTarriff[str_len - 1] = '\0';
        cJSON_AddStringToObject(body, "partElect", tempTarriff);

        str_len = 0;
        memset(tempTarriff, 0, 8 * segCnt);
        for (i = 0; i < segCnt; i++)
        {
            sprintf(tempTarriff + str_len, "%d,", data->chargeFee[i]);
            str_len = strlen(tempTarriff);
        }

        tempTarriff[str_len - 1] = '\0';
        cJSON_AddStringToObject(body, "chargeFee", tempTarriff);

        str_len = 0;
        memset(tempTarriff, 0, 8 * segCnt);
        for (i = 0; i < segCnt; i++)
        {
            sprintf(tempTarriff + str_len, "%d,", data->serviceFee[i]);
            str_len = strlen(tempTarriff);
        }

        tempTarriff[str_len - 1] = '\0';
        cJSON_AddStringToObject(body, "serviceFee", tempTarriff);

        HAL_Free(tempTarriff);
    }

    cJSON_AddNumberToObject(body, "startPoint", data->startPoint);
    cJSON_AddNumberToObject(body, "crossPoints", data->crossPoints);

    int pointCnt = data->crossPoints;
    if (pointCnt > 0 && pointCnt < EVS_MAX_MODEL_DEVSEG + 1)
    {
        int str_len = 0;

        char *tempPoint = (char *)HAL_Malloc(8 * pointCnt);
        memset(tempPoint, 0, 8 * pointCnt);

        for (i = 0; i < pointCnt; i++)
        {
            sprintf(tempPoint + str_len, "%d,", data->pointsElect[i]);
            str_len = strlen(tempPoint);
        }

        tempPoint[str_len - 1] = '\0';
        cJSON_AddStringToObject(body, "pointsElect", tempPoint);

        HAL_Free(tempPoint);
    }

    payload = cJSON_PrintUnformatted(root);
    res = IOT_Linkkit_Report(evs_g_user_ctx.master_devid, ITM_MSG_POST_PROPERTY, (unsigned char *)payload, strlen(payload));
    if (root != NULL)
    {
        cJSON_Delete(root);
    }

    if (payload != NULL)
    {
        HAL_Free(payload);
    }

    PROTOCOL_TRACE("Post Property Message ID: %d", res);
    if (res < 0)
    {
        return -1;
    }
    return res;
}

// 鐩存祦鍏呯數杩囩▼BMS瀹炴椂鐩戞祴灞烇拷?
static int send_property_bms(evs_property_BMS *data)
{
    int res = 0;
    char *payload = NULL;
    cJSON *root = NULL;
    cJSON *body = NULL;

    root = cJSON_CreateObject();

    cJSON_AddItemToObject(root, "dcBmsRunItyData", body = cJSON_CreateObject());

    cJSON_AddNumberToObject(body, "gunNo", data->gunNo);
    cJSON_AddStringToObject(body, "preTradeNo", data->preTradeNo);
    cJSON_AddStringToObject(body, "tradeNo", data->tradeNo);

    cJSON_AddNumberToObject(body, "socVal", data->socVal);
    cJSON_AddNumberToObject(body, "BMSVer", data->BMSVer);

    cJSON_AddNumberToObject(body, "BMSMaxVol", data->BMSMaxVol);
    cJSON_AddNumberToObject(body, "batType", data->batType);
    cJSON_AddNumberToObject(body, "batRatedCap", data->batRatedCap);

    cJSON_AddNumberToObject(body, "batRatedTotalVol", data->batRatedTotalVol);
    cJSON_AddNumberToObject(body, "singlBatMaxAllowVol", data->singlBatMaxAllowVol);

    cJSON_AddNumberToObject(body, "maxAllowCur", data->maxAllowCur);
    cJSON_AddNumberToObject(body, "battotalEnergy", data->battotalEnergy);

    cJSON_AddNumberToObject(body, "maxVol", data->maxVol);
    cJSON_AddNumberToObject(body, "maxTemp", data->maxTemp);
    cJSON_AddNumberToObject(body, "batCurVol", data->batCurVol);

    cJSON_AddStringToObject(body, "batManu", data->batManufacturer);
    cJSON_AddStringToObject(body, "batSN", data->batSN);

    cJSON_AddStringToObject(body, "batMadeDay", data->batMadeDay);
    cJSON_AddNumberToObject(body, "chargeTimes", data->chargeTimes);
    cJSON_AddNumberToObject(body, "batProperty", data->batProperty);
    cJSON_AddStringToObject(body, "bmsSoftVer", data->bmsSoftVer);

    payload = cJSON_PrintUnformatted(root);
    res = IOT_Linkkit_Report(evs_g_user_ctx.master_devid, ITM_MSG_POST_PROPERTY, (unsigned char *)payload, strlen(payload));
    if (root != NULL)
    {
        cJSON_Delete(root);
    }

    if (payload != NULL)
    {
        HAL_Free(payload);
    }

    PROTOCOL_TRACE("Post Property Message ID: %d", res);
    if (res < 0)
    {
        return -1;
    }
    return res;
}

// 鐩存祦闈炲厖鐢佃繃绋嬪疄鏃剁洃娴嬪睘锟�?
static int send_property_dc_nonwork(evs_property_dc_nonWork *data)
{
    int res = 0;
    char *payload = NULL;
    char Temp[20] = {0};
    cJSON *root = NULL;
    cJSON *body = NULL;

    root = cJSON_CreateObject();

    cJSON_AddItemToObject(root, "dcGunIdleItyFoData", body = cJSON_CreateObject());

    cJSON_AddNumberToObject(body, "gunNo", data->gunNo);
    cJSON_AddNumberToObject(body, "workStatus", data->workStatus);

    cJSON_AddNumberToObject(body, "gunStatus", data->gunStatus);
    cJSON_AddNumberToObject(body, "eLockStatus", data->eLockStatus);
    cJSON_AddNumberToObject(body, "DCK1Status", data->DCK1Status);
    cJSON_AddNumberToObject(body, "DCK2Status", data->DCK2Status);

    cJSON_AddNumberToObject(body, "DCPlusFuseStatus", data->DCPlusFuseStatus);
    cJSON_AddNumberToObject(body, "DCMinusFuseStatus", data->DCMinusFuseStatus);

    cJSON_AddNumberToObject(body, "conTemp1", data->conTemp1);
    cJSON_AddNumberToObject(body, "conTemp2", data->conTemp2);

    cJSON_AddNumberToObject(body, "dcVol", data->dcVol);
    cJSON_AddNumberToObject(body, "dcCur", data->dcCur);

    cJSON_AddNumberToObject(body, "chargeCnt", data->chargeCnt);
    cJSON_AddNumberToObject(body, "chargeTime", data->chargeTime);

    cJSON_AddNumberToObject(body, "k1Cnt", data->k1Cnt);
    cJSON_AddNumberToObject(body, "k2Cnt", data->k2Cnt);
    cJSON_AddNumberToObject(body, "acContactorStatus", data->acContactorState);

    cJSON_AddNumberToObject(body, "guidanceVal", data->guidanceVal);
    cJSON_AddNumberToObject(body, "auxiliaryPowerStatus", data->auxiliaryPowerStatus);
    cJSON_AddNumberToObject(body, "eLockCtrlStatus", data->elockCtrlState);
    cJSON_AddNumberToObject(body, "fanSwitchCtrlStatus", data->fanSwitchCtrlStatus);

    sprintf(Temp, "%lld", data->sumMeter);
    cJSON_AddStringToObject(body, "sumMeter", Temp);

    payload = cJSON_PrintUnformatted(root);
    res = IOT_Linkkit_Report(evs_g_user_ctx.master_devid, ITM_MSG_POST_PROPERTY, (unsigned char *)payload, strlen(payload));
    if (root != NULL)
    {
        cJSON_Delete(root);
    }

    if (payload != NULL)
    {
        HAL_Free(payload);
    }

    PROTOCOL_TRACE("Post Property Message ID: %d", res);
    if (res < 0)
    {
        return -1;
    }
    return res;
}

// 鐩存祦鍏呯數杩囩▼瀹炴椂鐩戞祴灞烇拷?
static int send_property_dc_work(evs_property_dc_work *data)
{
    int res = 0;
    int i = 0;
    char *payload = NULL;
    cJSON *root = NULL;
    cJSON *body = NULL;

    const char *ctrlState_fmt = "%d,%d,%d,%d,%d,%d";
    char temp[512];

    root = cJSON_CreateObject();

    cJSON_AddItemToObject(root, "dcGunRunItyTwData", body = cJSON_CreateObject());

    cJSON_AddNumberToObject(body, "gunNo", data->gunNo);
    cJSON_AddNumberToObject(body, "workStatus", data->workStatus);

    cJSON_AddNumberToObject(body, "gunStatus", data->gunStatus);
    cJSON_AddNumberToObject(body, "eLockStatus", data->eLockStatus);

    cJSON_AddNumberToObject(body, "DCK1Status", data->DCK1Status);
    cJSON_AddNumberToObject(body, "DCK2Status", data->DCK2Status);

    cJSON_AddNumberToObject(body, "DCPlusFuseStatus", data->DCPlusFuseStatus);
    cJSON_AddNumberToObject(body, "DCMinusFuseStatus", data->DCMinusFuseStatus);

    cJSON_AddNumberToObject(body, "conTemp1", data->conTemp1);
    cJSON_AddNumberToObject(body, "conTemp2", data->conTemp2);

    cJSON_AddNumberToObject(body, "dcVol", data->dcVol);
    cJSON_AddNumberToObject(body, "dcCur", data->dcCur);
    cJSON_AddStringToObject(body, "preTradeNo", data->preTradeNo);
    cJSON_AddStringToObject(body, "tradeNo", data->tradeNo);

    cJSON_AddNumberToObject(body, "chgType", data->chgType);

    cJSON_AddNumberToObject(body, "realPower", data->realPower);
    cJSON_AddNumberToObject(body, "chgTime", data->chgTime);
    cJSON_AddNumberToObject(body, "remainT", data->remainT);

    cJSON_AddNumberToObject(body, "socVal", data->socVal);

    cJSON_AddNumberToObject(body, "needVol", data->needVol);
    cJSON_AddNumberToObject(body, "needCur", data->needCur);

    cJSON_AddNumberToObject(body, "chargeMode", data->chargeMode);

    cJSON_AddNumberToObject(body, "bmsVol", data->bmsVol);
    cJSON_AddNumberToObject(body, "bmsCur", data->bmsCur);

    cJSON_AddNumberToObject(body, "SingleMHV", data->SingleMHV);
    cJSON_AddNumberToObject(body, "SingleMLV", data->SingleMLV);

    cJSON_AddNumberToObject(body, "MHTemp", data->MHTemp);
    cJSON_AddNumberToObject(body, "MLTemp", data->MLTemp);

    cJSON_AddNumberToObject(body, "SingleMHVNo", data->SingleMHVNo);

    cJSON_AddNumberToObject(body, "MHTempNo", data->MHTempNo);
    cJSON_AddNumberToObject(body, "MLTempNo", data->MLTempNo);

    cJSON_AddNumberToObject(body, "acContactorStatus", data->acInputContactorState);

    cJSON_AddNumberToObject(body, "guidanceVal", data->guidanceVol);

    HAL_Snprintf(temp, sizeof(temp), ctrlState_fmt, data->k1CtrlState, data->k2CtrlState, data->acInputContactorCtrlState, data->apsSwtichCtrlState, data->elockCtrlState, data->carbinFanCtrlState);
    cJSON_AddStringToObject(body, "componentsCtrlStatus", temp);

    memset(temp, 0, 20);
    sprintf(temp, "%lld", data->meterStartVal);
    cJSON_AddStringToObject(body, "meterStartVal", temp);

    memset(temp, 0, 20);
    sprintf(temp, "%lld", data->meterRealVal);
    cJSON_AddStringToObject(body, "meterRealVal", temp);

    cJSON_AddNumberToObject(body, "totalElect", data->totalElect);
    cJSON_AddNumberToObject(body, "totalCost", data->totalCost);
    cJSON_AddNumberToObject(body, "totalPowerCost", data->totalPowerCost);
    cJSON_AddNumberToObject(body, "totalServCost", data->totalServCost);

    cJSON_AddNumberToObject(body, "timeNum", data->timeNum);

    int segCnt = data->timeNum;
    if (segCnt > 0 && segCnt < EVS_MAX_MODEL_DEVSEG + 1)
    {
        int str_len = 0;

        char *tempTarriff = (char *)HAL_Malloc(8 * segCnt);
        memset(tempTarriff, 0, 8 * segCnt);

        for (i = 0; i < segCnt; i++)
        {
            sprintf(tempTarriff + str_len, "%d,", data->partElect[i]);
            str_len = strlen(tempTarriff);
        }

        tempTarriff[str_len - 1] = '\0';
        cJSON_AddStringToObject(body, "partElect", tempTarriff);

        str_len = 0;
        memset(tempTarriff, 0, 8 * segCnt);
        for (i = 0; i < segCnt; i++)
        {
            sprintf(tempTarriff + str_len, "%d,", data->chargeFee[i]);
            str_len = strlen(tempTarriff);
        }

        tempTarriff[str_len - 1] = '\0';
        cJSON_AddStringToObject(body, "chargeFee", tempTarriff);

        str_len = 0;
        memset(tempTarriff, 0, 8 * segCnt);
        for (i = 0; i < segCnt; i++)
        {
            sprintf(tempTarriff + str_len, "%d,", data->serviceFee[i]);
            str_len = strlen(tempTarriff);
        }

        tempTarriff[str_len - 1] = '\0';
        cJSON_AddStringToObject(body, "serviceFee", tempTarriff);

        HAL_Free(tempTarriff);
    }

    cJSON_AddNumberToObject(body, "startPoint", data->startPoint);
    cJSON_AddNumberToObject(body, "crossPoints", data->crossPoints);

    int pointCnt = data->crossPoints;
    if (pointCnt > 0 && pointCnt < EVS_MAX_MODEL_DEVSEG + 1)
    {
        int str_len = 0;

        char *tempPoint = (char *)HAL_Malloc(8 * pointCnt);
        memset(tempPoint, 0, 8 * pointCnt);

        for (i = 0; i < pointCnt; i++)
        {
            sprintf(tempPoint + str_len, "%d,", data->pointsElect[i]);
            str_len = strlen(tempPoint);
        }

        tempPoint[str_len - 1] = '\0';
        cJSON_AddStringToObject(body, "pointsElect", tempPoint);

        HAL_Free(tempPoint);
    }

    payload = cJSON_PrintUnformatted(root);

    res = IOT_Linkkit_Report(evs_g_user_ctx.master_devid, ITM_MSG_POST_PROPERTY, (unsigned char *)payload, strlen(payload));
    if (root != NULL)
    {
        cJSON_Delete(root);
    }

    if (payload != NULL)
    {
        HAL_Free(payload);
    }

    PROTOCOL_TRACE("Post Property Message ID: %d", res);
    if (res < 0)
    {
        return -1;
    }
    return res;
}

// 鐩存祦鍏呯數璁撅拷?锟戒氦娴佽緭鍏ョ數琛ㄥ簳鍊肩洃娴嬪睘鎬ц〃
static int send_property_dc_input_meter(evs_property_dc_input_meter *data)
{
    int res = 0;
    char *payload = NULL;
    char Temp[20] = {0};
    cJSON *root = NULL;
    cJSON *body = NULL;

    root = cJSON_CreateObject();
    cJSON_AddItemToObject(root, "dcSysMeterItyData", body = cJSON_CreateObject());
    cJSON_AddNumberToObject(body, "gunNo", data->gunNo);

    cJSON_AddStringToObject(body, "acqTime", data->acqTime);

    bcd2str(data->mailAddr, Temp, sizeof(data->mailAddr));
    cJSON_AddStringToObject(body, "mailAddr", Temp);

    bcd2str(data->meterNo, Temp, sizeof(data->meterNo));
    cJSON_AddStringToObject(body, "meterNo", Temp);
    cJSON_AddStringToObject(body, "assetId", data->assetId);

    sprintf(Temp, "%lld", data->sumMeter);
    cJSON_AddStringToObject(body, "sumMeter", Temp);
    sprintf(Temp, "%d", data->ApElect);
    cJSON_AddStringToObject(body, "ApElect", Temp);
    sprintf(Temp, "%d", data->BpElect);
    cJSON_AddStringToObject(body, "BpElect", Temp);
    sprintf(Temp, "%d", data->CpElect);
    cJSON_AddStringToObject(body, "CpElect", Temp);

    payload = cJSON_PrintUnformatted(root);

    res = IOT_Linkkit_Report(evs_g_user_ctx.master_devid, ITM_MSG_POST_PROPERTY, (unsigned char *)payload, strlen(payload));
    if (root != NULL)
    {
        cJSON_Delete(root);
    }

    if (payload != NULL)
    {
        HAL_Free(payload);
    }

    PROTOCOL_TRACE("Post Property Message ID: %d", res);
    if (res < 0)
    {
        return -1;
    }
    return res;
}

// 鍏呯數璁撅拷?锟借緭鍑虹數琛ㄥ簳鍊肩洃娴嬪睘鎬ц〃
static int send_property_dc_outmeter(evs_property_meter *data)
{
    int res = 0;
    char *payload = NULL;
    char Temp[20] = {0};
    cJSON *root = NULL;
    cJSON *body = NULL;

    root = cJSON_CreateObject();
    cJSON_AddItemToObject(root, "dcOutMeterIty", body = cJSON_CreateObject());
    cJSON_AddNumberToObject(body, "gunNo", data->gunNo);

    cJSON_AddStringToObject(body, "acqTime", data->acqTime);

    bcd2str(data->mailAddr, Temp, sizeof(data->mailAddr));
    cJSON_AddStringToObject(body, "mailAddr", Temp);

    bcd2str(data->meterNo, Temp, sizeof(data->meterNo));
    cJSON_AddStringToObject(body, "meterNo", Temp);

    cJSON_AddStringToObject(body, "assetId", data->assetId);

    sprintf(Temp, "%lld", data->sumMeter);
    cJSON_AddStringToObject(body, "sumMeter", Temp);

    cJSON_AddStringToObject(body, "lastTrade", data->lastTrade);
    cJSON_AddNumberToObject(body, "power", data->elec);

    payload = cJSON_PrintUnformatted(root);

    res = IOT_Linkkit_Report(evs_g_user_ctx.master_devid, ITM_MSG_POST_PROPERTY, (unsigned char *)payload, strlen(payload));
    if (root != NULL)
    {
        cJSON_Delete(root);
    }

    if (payload != NULL)
    {
        HAL_Free(payload);
    }

    PROTOCOL_TRACE("Post Property Message ID: %d", res);
    if (res < 0)
    {
        return -1;
    }
    return res;
}

// 鍏呯數璁撅拷?锟借緭鍑虹數琛ㄥ簳鍊肩洃娴嬪睘鎬ц〃
static int send_property_ac_outmeter(evs_property_meter *data)
{
    int res = 0;
    char *payload = NULL;
    char Temp[20] = {0};
    cJSON *root = NULL;
    cJSON *body = NULL;

    root = cJSON_CreateObject();
    cJSON_AddItemToObject(root, "acOutMeterItyData", body = cJSON_CreateObject());
    cJSON_AddNumberToObject(body, "gunNo", data->gunNo);

    cJSON_AddStringToObject(body, "acqTime", data->acqTime);

    bcd2str(data->mailAddr, Temp, sizeof(data->mailAddr));
    cJSON_AddStringToObject(body, "mailAddr", Temp);

    bcd2str(data->meterNo, Temp, sizeof(data->meterNo));
    cJSON_AddStringToObject(body, "meterNo", Temp);

    cJSON_AddStringToObject(body, "assetId", data->assetId);

    sprintf(Temp, "%lld", data->sumMeter);
    cJSON_AddStringToObject(body, "sumMeter", Temp);

    cJSON_AddStringToObject(body, "lastTrade", data->lastTrade);
    cJSON_AddNumberToObject(body, "power", data->elec);

    payload = cJSON_PrintUnformatted(root);
    res = IOT_Linkkit_Report(evs_g_user_ctx.master_devid, ITM_MSG_POST_PROPERTY, (unsigned char *)payload, strlen(payload));
    if (root != NULL)
    {
        cJSON_Delete(root);
    }

    if (payload != NULL)
    {
        HAL_Free(payload);
    }

    PROTOCOL_TRACE("Post Property Message ID: %d", res);
    if (res < 0)
    {
        return -1;
    }
    return res;
}

static int send_event_firmware_info(evs_event_firmware_info *data)
{
    int res = 0;
    char *payload = NULL;
    char meterAddr[13] = {0};
    char meter[EVS_MAX_METER_ADDR_LEN] = {0};
    cJSON *root = NULL;
    cJSON *inMeterArray = NULL;
    cJSON *outMeterArray = NULL;

    unsigned char i = 0, j = 0, k = 0;

    root = cJSON_CreateObject();
    cJSON_AddStringToObject(root, "simNo", data->simNo);
    cJSON_AddStringToObject(root, "feeModelId", data->feeModelId);
    cJSON_AddStringToObject(root, "stakeModel", data->stakeModel);
    cJSON_AddStringToObject(root, "devSn", data->devSn);

    cJSON_AddStringToObject(root, "simMac", data->simMac);
    cJSON_AddStringToObject(root, "btMac", data->btMac);

    cJSON_AddNumberToObject(root, "vendorCode", data->vendorCode);
    cJSON_AddNumberToObject(root, "devType", data->devType);
    cJSON_AddNumberToObject(root, "portNum", data->portNum);

    cJSON_AddNumberToObject(root, "longitude", data->longitude);
    cJSON_AddNumberToObject(root, "latitude", data->latitude);
    cJSON_AddNumberToObject(root, "height", data->height);

    cJSON_AddNumberToObject(root, "gridType", data->gridType);
    cJSON_AddNumberToObject(root, "meaType", data->meaType);
    cJSON_AddNumberToObject(root, "otRate", data->otRate);

    cJSON_AddNumberToObject(root, "otMinVol", data->otMinVol);
    //cJSON_AddNumberToObject(root, "otMinCur", data->otMinCur);
    cJSON_AddNumberToObject(root, "otMaxVol", data->otMaxVol);
    //cJSON_AddNumberToObject(root, "otMaxCur", data->otMaxCur);
    cJSON_AddNumberToObject(root, "otCur", data->otMaxCur);

    cJSON_AddNumberToObject(root, "CT", data->CT);
    cJSON_AddNumberToObject(root, "isGateLock", data->isGateLock);
    cJSON_AddNumberToObject(root, "isGroundLock", data->isGroundLock);
    cJSON_AddNumberToObject(root, "mutliChargingMode", data->mutliChargingMode);

    cJSON_AddItemToObject(root, "inMeter", inMeterArray = cJSON_CreateArray());
    for (i = 0; i < EVS_MAX_INPUT_METER_NUM; i++)
    {
        if (memcmp(data->inMeter[i], meter, EVS_MAX_METER_ADDR_LEN) != 0)
        {
            for (j = 0, k = 0; j < EVS_MAX_METER_ADDR_LEN; k++, j++)
            {
                meterAddr[k] = ((data->inMeter[i][j] >> 4) + '0');
                meterAddr[++k] = (data->inMeter[i][j] & 0x0f) + '0';
            }
            // cJSON_AddStringToArray(inMeterArray, meterAddr);
            cJSON_AddItemToArray(inMeterArray, cJSON_CreateString(meterAddr));
        }
    }

    cJSON_AddItemToObject(root, "outMeter", outMeterArray = cJSON_CreateArray());
    for (i = 0; i < EVS_MAX_PORT_NUM; i++)
    {
        if (memcmp(data->outMeter[i], meter, EVS_MAX_METER_ADDR_LEN) != 0)
        {
            for (j = 0, k = 0; j < EVS_MAX_METER_ADDR_LEN; k++, j++)
            {
                meterAddr[k] = ((data->outMeter[i][j] >> 4) + '0');
                meterAddr[++k] = (data->outMeter[i][j] & 0x0f) + '0';
            }
            // cJSON_AddStringToArray(outMeterArray, meterAddr);
            cJSON_AddItemToArray(outMeterArray, cJSON_CreateString(meterAddr));
        }
    }

    payload = cJSON_PrintUnformatted(root);
    //logMsg("0122= %s\n",payload);
    res = IOT_Linkkit_TriggerEvent(evs_g_user_ctx.master_devid, "firmwareTwEvt", strlen("firmwareTwEvt"), (char *)payload, strlen(payload));
    
    if (root != NULL)
    {
        cJSON_Delete(root);
    }

    if (payload != NULL)
    {
        HAL_Free(payload);
    }

    PROTOCOL_TRACE("Post Event Message ID: %d", res);
    if (res < 0)
    {
        return -1;
    }
    return res;
}

static int send_event_ver_info(evs_event_ver_info *data)
{
    int res = 0;
    char *payload = NULL;
    cJSON *root = NULL;

    root = cJSON_CreateObject();
    cJSON_AddNumberToObject(root, "devRegMethod", data->devRegMethod);
    cJSON_AddStringToObject(root, "pileSoftwareVer", data->pileSoftwareVer);
    cJSON_AddStringToObject(root, "pileHardwareVer", data->pileHardwareVer);
    cJSON_AddStringToObject(root, "sdkVer", "SDK_v1.1.10");

    payload = cJSON_PrintUnformatted(root);
    res = IOT_Linkkit_TriggerEvent(evs_g_user_ctx.master_devid, "verInfoEvt", strlen("verInfoEvt"), (char *)payload, strlen(payload));

    if (root != NULL)
    {
        cJSON_Delete(root);
    }

    if (payload != NULL)
    {
        HAL_Free(payload);
    }

    PROTOCOL_TRACE("Post Event Message ID: %d", res);
    if (res < 0)
    {
        return -1;
    }
    return res;
}

static int send_event_dev_maintain_result(evs_event_feedback_dev_maintain *data)
{
    int res = 0;
    char *payload = NULL;
    cJSON *root = NULL;

    root = cJSON_CreateObject();

    cJSON_AddNumberToObject(root, "ctrlType", data->ctrlType);
    cJSON_AddNumberToObject(root, "reason", data->reason);

    payload = cJSON_PrintUnformatted(root);
    res = IOT_Linkkit_TriggerEvent(evs_g_user_ctx.master_devid, "devMaintainRetEvt", strlen("devMaintainRetEvt"), (char *)payload, strlen(payload));

    if (root != NULL)
    {
        cJSON_Delete(root);
    }

    if (payload != NULL)
    {
        HAL_Free(payload);
    }

    PROTOCOL_TRACE("Post Event Message ID: %d", res);
    if (res < 0)
    {
        return -1;
    }
    return res;
}

static int send_event_lock_ctrl_result(evs_event_feedback_lockCtrl *data)
{
    int res = 0;
    char *payload = NULL;
    cJSON *root = NULL;

    root = cJSON_CreateObject();

    cJSON_AddNumberToObject(root, "gunNo", data->gunNo);
    cJSON_AddNumberToObject(root, "lockStatus", data->lockStatus);
    cJSON_AddNumberToObject(root, "resCode", data->resCode);

    payload = cJSON_PrintUnformatted(root);
    res = IOT_Linkkit_TriggerEvent(evs_g_user_ctx.master_devid, "ctrlLockRetEvt", strlen("ctrlLockRetEvt"), (char *)payload, strlen(payload));

    if (root != NULL)
    {
        cJSON_Delete(root);
    }

    if (payload != NULL)
    {
        HAL_Free(payload);
    }

    PROTOCOL_TRACE("Post Event Message ID: %d", res);
    if (res < 0)
    {
        return -1;
    }
    return res;
}

static int send_event_logquery_result(evs_event_logQuery_Result *data)
{
    int res = 0;
    int i = 0;
    char *payload = NULL;
    char temp[20] = {0};

    cJSON *root = cJSON_CreateObject();

    cJSON_AddNumberToObject(root, "gunNo", data->gunNo);

    sprintf(temp, "%d", data->startDate);
    cJSON_AddStringToObject(root, "startDate", temp);

    sprintf(temp, "%d", data->stopDate);
    cJSON_AddStringToObject(root, "stopDate", temp);

    cJSON_AddNumberToObject(root, "askType", data->askType);
    cJSON_AddNumberToObject(root, "result", data->result);
    cJSON_AddStringToObject(root, "logQueryNo", data->logQueryNo);
    cJSON_AddNumberToObject(root, "retType", data->retType);
    cJSON_AddNumberToObject(root, "logQueryEvtSum", data->logQueryEvtSum);
    cJSON_AddNumberToObject(root, "logQueryEvtNo", data->logQueryEvtNo);

    if (data->retType == 10)
    {
        if (data->askType == 10) // 浜ゆ槗璁板綍
        {
            cJSON *partElecArray = NULL;
            cJSON *partChargeFeeArray = NULL;
            cJSON *partServiceFeeArray = NULL;
            cJSON *pointElecArray = NULL;

            cJSON *tradeRoot = cJSON_CreateObject();
            cJSON_AddNumberToObject(tradeRoot, "gunNo", data->dataArea.tradeInfo.gunNo);

            cJSON_AddStringToObject(tradeRoot, "preTradeNo", data->dataArea.tradeInfo.preTradeNo);
            cJSON_AddStringToObject(tradeRoot, "tradeNo", data->dataArea.tradeInfo.tradeNo);
            cJSON_AddStringToObject(tradeRoot, "vinCode", data->dataArea.tradeInfo.vinCode);

            cJSON_AddNumberToObject(tradeRoot, "timeDivType", data->dataArea.tradeInfo.timeDivType);

            sprintf(temp, "%d", data->dataArea.tradeInfo.chargeStartTime);
            cJSON_AddStringToObject(tradeRoot, "chargeStartTime", temp);
            sprintf(temp, "%d", data->dataArea.tradeInfo.chargeEndTime);
            cJSON_AddStringToObject(tradeRoot, "chargeEndTime", temp);

            cJSON_AddNumberToObject(tradeRoot, "startSoc", data->dataArea.tradeInfo.startSoc);
            cJSON_AddNumberToObject(tradeRoot, "endSoc", data->dataArea.tradeInfo.endSoc);
            cJSON_AddNumberToObject(tradeRoot, "reason", data->dataArea.tradeInfo.reason);

            cJSON_AddNumberToObject(tradeRoot, "totalElect", data->dataArea.tradeInfo.totalElect);
            cJSON_AddStringToObject(tradeRoot, "feeModelId", data->dataArea.tradeInfo.feeModelId);

            sprintf(temp, "%lld", data->dataArea.tradeInfo.sumStart);
            cJSON_AddStringToObject(tradeRoot, "sumStart", temp);
            sprintf(temp, "%lld", data->dataArea.tradeInfo.sumEnd);
            cJSON_AddStringToObject(tradeRoot, "sumEnd", temp);

            cJSON_AddNumberToObject(tradeRoot, "totalElect", data->dataArea.tradeInfo.totalElect);
            cJSON_AddNumberToObject(tradeRoot, "totalPowerCost", data->dataArea.tradeInfo.totalPowerCost);
            cJSON_AddNumberToObject(tradeRoot, "totalServCost", data->dataArea.tradeInfo.totalServCost);
            cJSON_AddNumberToObject(tradeRoot, "timeNum", data->dataArea.tradeInfo.timeNum);

            int segCnt = data->dataArea.tradeInfo.timeNum;
            if (segCnt > 0 && segCnt < EVS_MAX_MODEL_DEVSEG + 1)
            {
                cJSON_AddItemToObject(tradeRoot, "partElect", partElecArray = cJSON_CreateArray());
                cJSON_AddItemToObject(tradeRoot, "chargeFee", partChargeFeeArray = cJSON_CreateArray());
                cJSON_AddItemToObject(tradeRoot, "serviceFee", partServiceFeeArray = cJSON_CreateArray());

                for (i = 0; i < segCnt; i++)
                {
                    cJSON_AddItemToArray(partElecArray, cJSON_CreateNumber(data->dataArea.tradeInfo.partElect[i]));
                    cJSON_AddItemToArray(partChargeFeeArray, cJSON_CreateNumber(data->dataArea.tradeInfo.chargeFee[i]));
                    cJSON_AddItemToArray(partServiceFeeArray, cJSON_CreateNumber(data->dataArea.tradeInfo.serviceFee[i]));
                }
            }

            cJSON_AddNumberToObject(tradeRoot, "startPoint", data->dataArea.tradeInfo.startPoint);
            cJSON_AddNumberToObject(tradeRoot, "crossPoints", data->dataArea.tradeInfo.crossPoints);

            int pointCnt = data->dataArea.tradeInfo.crossPoints;
            if (pointCnt > 0 && pointCnt < EVS_MAX_MODEL_DEVSEG + 1)
            {
                cJSON_AddItemToObject(tradeRoot, "pointsElect", pointElecArray = cJSON_CreateArray());
                for (i = 0; i < pointCnt; i++)
                {
                    cJSON_AddItemToArray(pointElecArray, cJSON_CreateNumber(data->dataArea.tradeInfo.partElect[i]));
                }
            }

            char *tradePayload = cJSON_PrintUnformatted(tradeRoot);
            cJSON_AddStringToObject(root, "dataArea", tradePayload);

            if (tradeRoot != NULL)
            {
                cJSON_Delete(tradeRoot);
            }

            if (tradePayload != NULL)
            {
                HAL_Free(tradePayload);
            }
        }
        else if (data->askType == 11) // 鐢佃〃搴曪拷?
        {
            cJSON *meterRoot, *body;

            meterRoot = cJSON_CreateObject();
            cJSON_AddItemToObject(meterRoot, "outMeterItyData", body = cJSON_CreateObject());
            cJSON_AddNumberToObject(body, "gunNo", data->dataArea.meterData.gunNo);

            cJSON_AddStringToObject(body, "acqTime", data->dataArea.meterData.acqTime);

            bcd2str(data->dataArea.meterData.mailAddr, temp, 6);
            cJSON_AddStringToObject(body, "mailAddr", temp);

            bcd2str(data->dataArea.meterData.meterNo, temp, 6);
            cJSON_AddStringToObject(body, "meterNo", temp);

            cJSON_AddStringToObject(body, "assetId", data->dataArea.meterData.assetId);

            sprintf(temp, "%lld", data->dataArea.meterData.sumMeter);
            cJSON_AddStringToObject(body, "sumMeter", temp);

            cJSON_AddStringToObject(body, "lastTrade", data->dataArea.meterData.lastTrade);
            cJSON_AddNumberToObject(body, "power", data->dataArea.meterData.elec);

            char *meterPayload = cJSON_PrintUnformatted(meterRoot);

            cJSON_AddStringToObject(root, "dataArea", meterPayload);

            if (meterRoot != NULL)
            {
                cJSON_Delete(meterRoot);
            }

            if (meterPayload != NULL)
            {
                HAL_Free(meterPayload);
            }
        }
        else if (data->askType == 14) // BMS灞烇拷?
        {
            cJSON *BMSRoot, *body;

            BMSRoot = cJSON_CreateObject();
            cJSON_AddItemToObject(BMSRoot, "dcBmsRunIty", body = cJSON_CreateObject());
            cJSON_AddNumberToObject(body, "gunNo", data->dataArea.BMSData.gunNo);
            cJSON_AddStringToObject(body, "preTradeNo", data->dataArea.BMSData.preTradeNo);
            cJSON_AddStringToObject(body, "tradeNo", data->dataArea.BMSData.tradeNo);

            cJSON_AddNumberToObject(body, "socVal", data->dataArea.BMSData.socVal);
            cJSON_AddNumberToObject(body, "BMSVer", data->dataArea.BMSData.BMSVer);

            cJSON_AddNumberToObject(body, "BMSMaxVol", data->dataArea.BMSData.BMSMaxVol);
            cJSON_AddNumberToObject(body, "batType", data->dataArea.BMSData.batType);
            cJSON_AddNumberToObject(body, "batRatedCap", data->dataArea.BMSData.batRatedCap);

            cJSON_AddNumberToObject(body, "batRatedTotalVol", data->dataArea.BMSData.batRatedTotalVol);
            cJSON_AddNumberToObject(body, "singlBatMaxAllowVol", data->dataArea.BMSData.singlBatMaxAllowVol);

            cJSON_AddNumberToObject(body, "maxAllowCur", data->dataArea.BMSData.maxAllowCur);
            cJSON_AddNumberToObject(body, "battotalEnergy", data->dataArea.BMSData.battotalEnergy);

            cJSON_AddNumberToObject(body, "maxVol", data->dataArea.BMSData.maxVol);
            cJSON_AddNumberToObject(body, "maxTemp", data->dataArea.BMSData.maxTemp);
            cJSON_AddNumberToObject(body, "batCurVol", data->dataArea.BMSData.batCurVol);

            cJSON_AddStringToObject(body, "batManufacturer", data->dataArea.BMSData.batManufacturer);
            cJSON_AddStringToObject(body, "batSN", data->dataArea.BMSData.batSN);
            cJSON_AddStringToObject(body, "batMadeDay", data->dataArea.BMSData.batMadeDay);
            cJSON_AddNumberToObject(body, "chargeTimes", data->dataArea.BMSData.chargeTimes);
            cJSON_AddNumberToObject(body, "batProperty", data->dataArea.BMSData.batProperty);
            cJSON_AddStringToObject(body, "bmsSoftVer", data->dataArea.BMSData.bmsSoftVer);

            char *BMSPayload = cJSON_PrintUnformatted(BMSRoot);
            cJSON_AddStringToObject(root, "dataArea", BMSPayload);

            if (BMSRoot != NULL)
            {
                cJSON_Delete(BMSRoot);
            }

            if (BMSPayload != NULL)
            {
                HAL_Free(BMSPayload);
            }
        }
        else
        {
            cJSON_AddStringToObject(root, "dataArea", data->dataArea.rawData);
        }
    }
    else
    {
        cJSON_AddStringToObject(root, "dataArea", "");
    }

    payload = cJSON_PrintUnformatted(root);
    res = IOT_Linkkit_TriggerEvent(evs_g_user_ctx.master_devid, "logQueryEvt", strlen("logQueryEvt"), (char *)payload, strlen(payload));

    if (root != NULL)
    {
        cJSON_Delete(root);
    }

    if (payload != NULL)
    {
        HAL_Free(payload);
    }

    PROTOCOL_TRACE("Post Event Message ID: %d", res);
    if (res < 0)
    {
        return -1;
    }
    return res;
}

static int send_event_ask_feeModel(evs_event_ask_feeModel *data)
{
    int res = 0;
    char *payload = NULL;

    cJSON *root = cJSON_CreateObject();
    cJSON_AddStringToObject(root, "feeModelId", data->feeModelId);

    payload = cJSON_PrintUnformatted(root);

    res = IOT_Linkkit_TriggerEvent(evs_g_user_ctx.master_devid, "askFeeModelTwEvt", strlen("askFeeModelTwEvt"), (char *)payload, strlen(payload));

    if (root != NULL)
    {
        cJSON_Delete(root);
    }

    if (payload != NULL)
    {
        HAL_Free(payload);
    }

    PROTOCOL_TRACE("Post Event Message ID: %d", res);
    if (res < 0)
    {
        return -1;
    }
    return res;
}

static int send_event_start_result(evs_event_startResult *data)
{
    int res = 0;
    char *payload = NULL;

    cJSON *root = cJSON_CreateObject();
    cJSON_AddNumberToObject(root, "gunNo", data->gunNo);
    cJSON_AddNumberToObject(root, "startResult", data->startResult);
    cJSON_AddNumberToObject(root, "faultCode", data->faultCode);
    cJSON_AddStringToObject(root, "preTradeNo", data->preTradeNo);
    cJSON_AddStringToObject(root, "tradeNo", data->tradeNo);
    cJSON_AddStringToObject(root, "vinCode", data->vinCode);

    payload = cJSON_PrintUnformatted(root);

    res = IOT_Linkkit_TriggerEvent(evs_g_user_ctx.master_devid, "startChaResEvt", strlen("startChaResEvt"), (char *)payload, strlen(payload));

    if (root != NULL)
    {
        cJSON_Delete(root);
    }

    if (payload != NULL)
    {
        HAL_Free(payload);
    }

    PROTOCOL_TRACE("Post Event Message ID: %d", res);
    if (res < 0)
    {
        return -1;
    }
    return res;
}

static int send_event_auth_start(evs_event_startCharge *data)
{
    int res = 0;
    char *payload = NULL;

    cJSON *root = cJSON_CreateObject();
    cJSON_AddNumberToObject(root, "gunNo", data->gunNo);
    cJSON_AddNumberToObject(root, "startType", data->startType);

    cJSON_AddStringToObject(root, "preTradeNo", data->preTradeNo);
    cJSON_AddStringToObject(root, "tradeNo", data->tradeNo);
    cJSON_AddStringToObject(root, "authCode", data->authCode);

    cJSON_AddNumberToObject(root, "batterySOC", data->batterySOC);
    cJSON_AddNumberToObject(root, "batteryCap", data->batteryCap);

    cJSON_AddNumberToObject(root, "chargeTimes", data->chargeTimes);

    cJSON_AddNumberToObject(root, "batteryVol", data->batteryVol);

    payload = cJSON_PrintUnformatted(root);

    res = IOT_Linkkit_TriggerEvent(evs_g_user_ctx.master_devid, "startChargeAuthEvt", strlen("startChargeAuthEvt"), (char *)payload, strlen(payload));

    if (root != NULL)
    {
        cJSON_Delete(root);
    }

    if (payload != NULL)
    {
        HAL_Free(payload);
    }

    PROTOCOL_TRACE("Post Event Message ID: %d", res);
    if (res < 0)
    {
        return -1;
    }
    return res;
}

static int send_event_stopCharge(evs_event_stopCharge *data)
{
    int res = 0;
    char *payload = NULL;

    cJSON *root = cJSON_CreateObject();
    cJSON_AddNumberToObject(root, "gunNo", data->gunNo);
    cJSON_AddNumberToObject(root, "stopResult", data->stopResult);
    cJSON_AddNumberToObject(root, "resultCode", data->resultCode);
    cJSON_AddStringToObject(root, "preTradeNo", data->preTradeNo);
    cJSON_AddStringToObject(root, "tradeNo", data->tradeNo);
    cJSON_AddNumberToObject(root, "stopFailReson", data->stopFailReson);

    payload = cJSON_PrintUnformatted(root);

    res = IOT_Linkkit_TriggerEvent(evs_g_user_ctx.master_devid, "stopChaResEvt", strlen("stopChaResEvt"), (char *)payload, strlen(payload));

    if (root != NULL)
    {
        cJSON_Delete(root);
    }

    if (payload != NULL)
    {
        HAL_Free(payload);
    }

    PROTOCOL_TRACE("Post Event Message ID: %d", res);
    if (res < 0)
    {
        return -1;
    }
    return res;
}

static int send_event_groundLock_change(evs_event_groundLock_change *data)
{
    int res = 0;
    char *payload = NULL;

    cJSON *root = cJSON_CreateObject();
    cJSON_AddNumberToObject(root, "gunNo", data->gunNo);
    cJSON_AddNumberToObject(root, "lockState", data->lockState);
    cJSON_AddNumberToObject(root, "powerType", data->powerType);
    cJSON_AddNumberToObject(root, "cellState", data->cellState);
    cJSON_AddNumberToObject(root, "lockerState", data->lockerState);
    cJSON_AddNumberToObject(root, "lockerForced", data->lockerForced);
    cJSON_AddNumberToObject(root, "lowPower", data->lowPower);
    cJSON_AddNumberToObject(root, "soc", data->soc);
    cJSON_AddNumberToObject(root, "openCnt", data->openCnt);

    payload = cJSON_PrintUnformatted(root);

    res = IOT_Linkkit_TriggerEvent(evs_g_user_ctx.master_devid, "groundLockEvt", strlen("groundLockEvt"), (char *)payload, strlen(payload));

    if (root != NULL)
    {
        cJSON_Delete(root);
    }

    if (payload != NULL)
    {
        HAL_Free(payload);
    }

    PROTOCOL_TRACE("Post Event Message ID: %d", res);
    if (res < 0)
    {
        return -1;
    }
    return res;
}

static int send_event_gateLock_change(evs_event_gateLock_change *data)
{
    int res = 0;
    char *payload = NULL;

    cJSON *root = cJSON_CreateObject();
    cJSON_AddNumberToObject(root, "lockNo", data->lockNo);
    cJSON_AddNumberToObject(root, "lockState", data->lockState);

    payload = cJSON_PrintUnformatted(root);

    res = IOT_Linkkit_TriggerEvent(evs_g_user_ctx.master_devid, "smartLockEvent", strlen("smartLockEvent"), (char *)payload, strlen(payload));

    if (root != NULL)
    {
        cJSON_Delete(root);
    }

    if (payload != NULL)
    {
        HAL_Free(payload);
    }

    PROTOCOL_TRACE("Post Event Message ID: %d", res);
    if (res < 0)
    {
        return -1;
    }
    return res;
}

static int send_event_tradeInfo(evs_event_tradeInfo *data)
{
    int res = 0;
    int i = 0;
    char *payload = NULL;
    char time[16] = {0};
    char sumPower[20] = {0};
    cJSON *root = NULL;
    cJSON *partElecArray = NULL;
    cJSON *partChargeFeeArray = NULL;
    cJSON *partServiceFeeArray = NULL;
    cJSON *pointElecArray = NULL;

    root = cJSON_CreateObject();
    cJSON_AddNumberToObject(root, "gunNo", data->gunNo);

    cJSON_AddStringToObject(root, "preTradeNo", data->preTradeNo);
    cJSON_AddStringToObject(root, "tradeNo", data->tradeNo);
    cJSON_AddStringToObject(root, "vinCode", data->vinCode);

    cJSON_AddNumberToObject(root, "timeDivType", data->timeDivType);
    cJSON_AddNumberToObject(root, "startType", data->startType);

    sprintf(time, "%d", data->chargeStartTime);
    cJSON_AddStringToObject(root, "chargeStartTime", time);
    sprintf(time, "%d", data->chargeEndTime);
    cJSON_AddStringToObject(root, "chargeEndTime", time);

    cJSON_AddNumberToObject(root, "startSoc", data->startSoc);
    cJSON_AddNumberToObject(root, "endSoc", data->endSoc);
    cJSON_AddNumberToObject(root, "reason", data->reason);

    cJSON_AddStringToObject(root, "feeModelId", data->feeModelId);

    sprintf(sumPower, "%lld", data->sumStart);
    cJSON_AddStringToObject(root, "sumStart", sumPower);
    sprintf(sumPower, "%lld", data->sumEnd);
    cJSON_AddStringToObject(root, "sumEnd", sumPower);

    cJSON_AddNumberToObject(root, "totalElect", data->totalElect);
    cJSON_AddNumberToObject(root, "totalPowerCost", data->totalPowerCost);
    cJSON_AddNumberToObject(root, "totalServCost", data->totalServCost);
    cJSON_AddNumberToObject(root, "totalCost", data->totalCost);

    cJSON_AddNumberToObject(root, "timeNum", data->timeNum);

    int segCnt = data->timeNum;
    if (segCnt > 0 && segCnt < EVS_MAX_MODEL_DEVSEG + 1)
    {
        cJSON_AddItemToObject(root, "partElect", partElecArray = cJSON_CreateArray());
        cJSON_AddItemToObject(root, "chargeFee", partChargeFeeArray = cJSON_CreateArray());
        cJSON_AddItemToObject(root, "serviceFee", partServiceFeeArray = cJSON_CreateArray());

        for (i = 0; i < segCnt; i++)
        {
            cJSON_AddItemToArray(partElecArray, cJSON_CreateNumber(data->partElect[i]));
            cJSON_AddItemToArray(partChargeFeeArray, cJSON_CreateNumber(data->chargeFee[i]));
            cJSON_AddItemToArray(partServiceFeeArray, cJSON_CreateNumber(data->serviceFee[i]));
        }
    }

    cJSON_AddNumberToObject(root, "startPoint", data->startPoint);
    cJSON_AddNumberToObject(root, "crossPoints", data->crossPoints);

    int pointCnt = data->crossPoints;
    if (pointCnt > 0 && pointCnt < EVS_MAX_MODEL_DEVSEG + 1)
    {
        cJSON_AddItemToObject(root, "pointsElect", pointElecArray = cJSON_CreateArray());
        for (i = 0; i < pointCnt; i++)
        {
            cJSON_AddItemToArray(pointElecArray, cJSON_CreateNumber(data->pointsElect[i]));
        }
    }

    payload = cJSON_PrintUnformatted(root);

    res = IOT_Linkkit_TriggerEvent(evs_g_user_ctx.master_devid, "orderTwUpdateEvt", strlen("orderTwUpdateEvt"), (char *)payload, strlen(payload));

    if (root != NULL)
    {
        cJSON_Delete(root);
    }

    if (payload != NULL)
    {
        HAL_Free(payload);
    }

    PROTOCOL_TRACE("Post Event Message ID: %d", res);
    if (res < 0)
    {
        return -1;
    }
    return res;
}

static int send_event_alarm(evs_event_alarm *data)
{
    int res = 0;
    char *payload = NULL;
    cJSON *root = NULL;
    cJSON *faultArray = NULL;
    cJSON *warnArray = NULL;
    unsigned char i = 0;

    root = cJSON_CreateObject();
    cJSON_AddNumberToObject(root, "gunNo", data->gunNo);
    cJSON_AddNumberToObject(root, "faultSum", data->faultSum);
    cJSON_AddNumberToObject(root, "warnSum", data->warnSum);

    cJSON_AddItemToObject(root, "faultValue", faultArray = cJSON_CreateArray());
    for (i = 0; i < data->faultSum; i++)
    {
        // cJSON_AddNumberToArray(faultArray, data->faultValue[i]);
        cJSON_AddItemToArray(faultArray, cJSON_CreateNumber(data->faultValue[i]));
    }
    cJSON_AddItemToObject(root, "warnValue", warnArray = cJSON_CreateArray());
    for (i = 0; i < data->warnSum; i++)
    {
        // cJSON_AddNumberToArray(warnArray, data->warnValue[i]);
        cJSON_AddItemToArray(warnArray, cJSON_CreateNumber(data->warnValue[i]));
    }
    payload = cJSON_PrintUnformatted(root);

    res = IOT_Linkkit_TriggerEvent(evs_g_user_ctx.master_devid, "totalFaultEvt", strlen("totalFaultEvt"), (char *)payload, strlen(payload));

    if (root != NULL)
    {
        cJSON_Delete(root);
    }

    if (payload != NULL)
    {
        HAL_Free(payload);
    }

    PROTOCOL_TRACE("Post Event Message ID: %d", res);
    if (res < 0)
    {
        return -1;
    }
    return res;
}

static int send_event_ask_dev_config(void)
{
    int res = 0;
    char payload[6] = "{}";

    res = IOT_Linkkit_TriggerEvent(evs_g_user_ctx.master_devid, "askConfigEvt", strlen("askConfigEvt"), (char *)payload, strlen(payload));

    PROTOCOL_TRACE("Post Event Message ID: %d", res);
    if (res < 0)
    {
        return -1;
    }
    return res;
}

static int send_event_acPile_change(evs_event_pile_stutus_change *data)
{
    int res = 0;
    char *payload = NULL;
    char time[16] = {0};
    cJSON *root = NULL;

    sprintf(time, "%d", data->yxOccurTime);

    root = cJSON_CreateObject();
    cJSON_AddNumberToObject(root, "gunNo", data->gunNo);
    cJSON_AddStringToObject(root, "yxOccurTime", time);
    cJSON_AddNumberToObject(root, "connCheckStatus", data->connCheckStatus);

    payload = cJSON_PrintUnformatted(root);

    res = IOT_Linkkit_TriggerEvent(evs_g_user_ctx.master_devid, "acStChEvt", strlen("acStChEvt"), (char *)payload, strlen(payload));

    if (root != NULL)
    {
        cJSON_Delete(root);
    }

    if (payload != NULL)
    {
        HAL_Free(payload);
    }

    PROTOCOL_TRACE("Post Event Message ID: %d", res);
    if (res < 0)
    {
        return -1;
    }
    return res;
}

static int send_event_raw(char *data)
{
    int res = 0;
    char *eventName = NULL;
    char *payload = NULL;

    if (data == NULL)
        return -1;

    cJSON *root = cJSON_Parse(data);
    if (root == NULL || !cJSON_IsObject(root))
    {
        PROTOCOL_TRACE("JSON Parse Error");
        return -1;
    }

    cJSON *item_partsType = cJSON_GetObjectItem(root, "partsType");
    if (item_partsType != NULL && cJSON_IsNumber(item_partsType))
    {

        // 0x01锛氱洿娴佸厖鐢垫帶鍒跺櫒锛堝厖鐢垫帶鍒舵ā鍧楋級
        // 0x02锛氫氦娴佸厖鐢垫帶鍒跺櫒
        // 0x03锛氬姛鐜囨帶鍒舵ā锟�?
        // 0x04锛氬厖鐢垫ā锟�?
        // 0x05锛氬紑鍏虫ā锟�?
        // 0x06锛氱幆澧冧俊锟�?閲囬泦妯″潡
        // 0x07锛氬厖鐢垫ā鍧楄繍琛屼俊锟�?缁燂拷?锟芥暟锟�?

        int partsType = item_partsType->valueint;
        switch (partsType)
        {
        case 1:
            eventName = "ccuInfoEvt";
            break;
        case 2:
            /* code */
            break;
        case 3:
            eventName = "pcuInfoEvt";
            break;
        case 4:
            eventName = "cuInfoEvt";
            break;
        case 5:
            eventName = "switchInfoEvt";
            break;
        case 6:
            eventName = "evInfoEvt";
            break;
        case 7:
            eventName = "cuWorkInfoEvt";
            break;
        default:
            break;
        }
    }

    cJSON *item_partsInfo = cJSON_GetObjectItem(root, "partsInfo");
    if (item_partsInfo != NULL && cJSON_IsObject(item_partsInfo))
    {
        payload = cJSON_PrintUnformatted(item_partsInfo);
    }

    if (eventName != NULL)
        res = IOT_Linkkit_TriggerEvent(evs_g_user_ctx.master_devid, eventName, strlen(eventName), (char *)payload, strlen(payload));

    PROTOCOL_TRACE("Post Event Message ID: %d", res);

    if (root != NULL)
    {
        cJSON_Delete(root);
    }

    if (payload != NULL)
    {
        HAL_Free(payload);
    }

    if (res < 0)
    {
        return -1;
    }
    return res;
}

static int send_event_dcPile_change(evs_event_pile_stutus_change *data)
{
    int res = 0;
    char *payload = NULL;
    char time[16] = {0};
    cJSON *root = NULL;

    sprintf(time, "%d", data->yxOccurTime);

    root = cJSON_CreateObject();
    cJSON_AddNumberToObject(root, "gunNo", data->gunNo);
    cJSON_AddStringToObject(root, "yxOccurTime", time);
    cJSON_AddNumberToObject(root, "connCheckStatus", data->connCheckStatus);

    payload = cJSON_PrintUnformatted(root);

    res = IOT_Linkkit_TriggerEvent(evs_g_user_ctx.master_devid, "dcStChEvt", strlen("dcStChEvt"), (char *)payload, strlen(payload));

    if (root != NULL)
    {
        cJSON_Delete(root);
    }

    if (payload != NULL)
    {
        HAL_Free(payload);
    }

    PROTOCOL_TRACE("Post Event Message ID: %d", res);
    if (res < 0)
    {
        return -1;
    }
    return res;
}

static int send_event_car_info(evs_event_car_info *data)
{
    int res = 0;
    cJSON *root = NULL;
    char *payload = NULL;

    root = cJSON_CreateObject();
    cJSON_AddNumberToObject(root, "gunNo", data->gunNo);
    cJSON_AddNumberToObject(root, "batterySOC", data->batterySOC);
    cJSON_AddNumberToObject(root, "batteryCap", data->batteryCap);
    cJSON_AddStringToObject(root, "vinCode", data->vinCode);
    cJSON_AddNumberToObject(root, "state", data->state);

    payload = cJSON_PrintUnformatted(root);

    res = IOT_Linkkit_TriggerEvent(evs_g_user_ctx.master_devid, "acCarInfoEvt", strlen("acCarInfoEvt"), (char *)payload, strlen(payload));

    if (root != NULL)
    {
        cJSON_Delete(root);
    }

    if (payload != NULL)
    {
        HAL_Free(payload);
    }

    PROTOCOL_TRACE("Post Event Message ID: %d", res);
    if (res < 0)
    {
        return -1;
    }
    return res;
}

static int send_event_card_info(evs_event_card_info *data)
{
    int res = 0;
    char *payload = NULL;
    cJSON *root = NULL;

    bcd2str(gun_auth_process_data[data->gunNo - 1].psy_id, data->cardPsySn, sizeof(gun_auth_process_data[data->gunNo - 1].psy_id));
    bcd2str(gun_auth_process_data[data->gunNo - 1].usrId, data->cardSn, sizeof(gun_auth_process_data[data->gunNo - 1].usrId));

    root = cJSON_CreateObject();
    cJSON_AddNumberToObject(root, "gunNo", data->gunNo);
    cJSON_AddStringToObject(root, "cardSn", data->cardSn);
    cJSON_AddStringToObject(root, "cardPsySn", data->cardPsySn);
    cJSON_AddNumberToObject(root, "startMode", data->startMode);

    payload = cJSON_PrintUnformatted(root);
    res = IOT_Linkkit_TriggerEvent(evs_g_user_ctx.master_devid, "tagCardInfoEvt", strlen("tagCardInfoEvt"), (char *)payload, strlen(payload));

    if (root != NULL)
    {
        cJSON_Delete(root);
    }

    if (payload != NULL)
    {
        HAL_Free(payload);
    }

    PROTOCOL_TRACE("Post Event Message ID: %d", res);
    if (res < 0)
    {
        return -1;
    }

    return res;
}

static int send_event_card_auth(evs_event_card_auth *data)
{
    int res = 0;
    char *payload = NULL;
    cJSON *root = NULL;

    bcd2str(gun_auth_process_data[data->gunNo - 1].randomC, data->randomC, sizeof(gun_auth_process_data[data->gunNo - 1].randomC));
    bcd2str(gun_auth_process_data[data->gunNo - 1].cardBalance, data->cardBalance, sizeof(gun_auth_process_data[data->gunNo - 1].cardBalance));
    bcd2str(gun_auth_process_data[data->gunNo - 1].tradeSn, data->cardTradeSn, sizeof(gun_auth_process_data[data->gunNo - 1].tradeSn));
    bcd2str(&gun_auth_process_data[data->gunNo - 1].authVer, data->keyVer, sizeof(gun_auth_process_data[data->gunNo - 1].authVer));
    bcd2str(&gun_auth_process_data[data->gunNo - 1].authFlag, data->keyFlag, sizeof(gun_auth_process_data[data->gunNo - 1].authFlag));
    bcd2str(gun_auth_process_data[data->gunNo - 1].MAC1, data->tradeMac1, sizeof(gun_auth_process_data[data->gunNo - 1].MAC1));

    root = cJSON_CreateObject();
    cJSON_AddNumberToObject(root, "gunNo", data->gunNo);
    cJSON_AddStringToObject(root, "randomC", data->randomC);
    cJSON_AddStringToObject(root, "cardBalance", data->cardBalance);
    cJSON_AddStringToObject(root, "cardTradeSn", data->cardTradeSn);
    cJSON_AddStringToObject(root, "keyVer", data->keyVer);
    cJSON_AddStringToObject(root, "keyFlag", data->keyFlag);
    cJSON_AddStringToObject(root, "tradeMac1", data->tradeMac1);

    payload = cJSON_PrintUnformatted(root);
    res = IOT_Linkkit_TriggerEvent(evs_g_user_ctx.master_devid, "devAuthCodeEvt", strlen("devAuthCodeEvt"), (char *)payload, strlen(payload));

    if (root != NULL)
    {
        cJSON_Delete(root);
    }

    if (payload != NULL)
    {
        HAL_Free(payload);
    }

    PROTOCOL_TRACE("Post Event Message ID: %d", res);
    if (res < 0)
    {
        return -1;
    }
    return res;
}

static int send_event_card_auth_result(evs_event_card_auth_result *data)
{
    int res = 0;
    char *payload = NULL;
    cJSON *root = NULL;

    bcd2str(gun_auth_process_data[data->gunNo - 1].TAC, data->tradeTac, sizeof(gun_auth_process_data[data->gunNo - 1].TAC));
    root = cJSON_CreateObject();
    cJSON_AddNumberToObject(root, "gunNo", data->gunNo);
    cJSON_AddStringToObject(root, "preTradeNo", data->preTradeNo);
    cJSON_AddStringToObject(root, "tradeNo", data->tradeNo);
    cJSON_AddStringToObject(root, "tradeTac", data->tradeTac);

    payload = cJSON_PrintUnformatted(root);
    res = IOT_Linkkit_TriggerEvent(evs_g_user_ctx.master_devid, "srvAuthConfirmEvt", strlen("srvAuthConfirmEvt"), (char *)payload, strlen(payload));

    if (root != NULL)
    {
        cJSON_Delete(root);
    }

    if (payload != NULL)
    {
        HAL_Free(payload);
    }

    PROTOCOL_TRACE("Post Event Message ID: %d", res);
    if (res < 0)
    {
        return -1;
    }
    return res;
}

static int send_event_card_check_error(evs_event_card_check_error *data)
{
    int res = 0;
    char *payload = NULL;
    cJSON *root = NULL;

    root = cJSON_CreateObject();

    bcd2str(gun_auth_process_data[data->gunNo - 1].psy_id, data->cardPsySn, sizeof(gun_auth_process_data[data->gunNo - 1].psy_id));
    bcd2str(gun_auth_process_data[data->gunNo - 1].usrId, data->cardSn, sizeof(gun_auth_process_data[data->gunNo - 1].usrId));

    cJSON_AddNumberToObject(root, "gunNo", data->gunNo);
    cJSON_AddStringToObject(root, "cardSn", data->cardSn);
    cJSON_AddStringToObject(root, "cardPsySn", data->cardPsySn);
    cJSON_AddNumberToObject(root, "faultValue", data->faultValue);

    payload = cJSON_PrintUnformatted(root);
    res = IOT_Linkkit_TriggerEvent(evs_g_user_ctx.master_devid, "cardCheckErrorEvt", strlen("cardCheckErrorEvt"), (char *)payload, strlen(payload));

    if (root != NULL)
    {
        cJSON_Delete(root);
    }

    if (payload != NULL)
    {
        HAL_Free(payload);
    }

    PROTOCOL_TRACE("Post Event Message ID: %d", res);
    if (res < 0)
    {
        return -1;
    }
    return res;
}

static int send_event_devmdu_info(evs_event_devmdu_info *data)
{
    int res = 0, i = 0;
    cJSON *root = NULL;
    char *payload = NULL;
    cJSON *mduInfoIntArray = NULL;
    cJSON *mduInfoStringArray = NULL;

    root = cJSON_CreateObject();

    cJSON_AddStringToObject(root, "netMduInfo", data->netMduInfo);
    cJSON_AddStringToObject(root, "netMduSoftVer", data->netMduSoftVer);
    cJSON_AddStringToObject(root, "netMduImei", data->netMduImei);
    cJSON_AddNumberToObject(root, "smartGun", data->smartGun);

    cJSON_AddItemToObject(root, "mduInfoInt", mduInfoIntArray = cJSON_CreateArray());
    for (i = 0; i < EVS_MAX_MDUINT_NUM; i++)
    {
        cJSON_AddItemToArray(mduInfoIntArray, cJSON_CreateNumber(data->mduInfoInt[i]));
    }
    cJSON_AddItemToObject(root, "mduInfoString", mduInfoStringArray = cJSON_CreateArray());
    for (i = 0; i < EVS_MAX_MDUSTRING_NUM; i++)
    {
        cJSON_AddItemToArray(mduInfoStringArray, cJSON_CreateString(data->mduInfoString[i]));
    }

    payload = cJSON_PrintUnformatted(root);
    res = IOT_Linkkit_TriggerEvent(evs_g_user_ctx.master_devid, "devMduInfoEvt", strlen("devMduInfoEvt"), (char *)payload, strlen(payload));
    
    if (root != NULL)
    {
        cJSON_Delete(root);
    }

    if (payload != NULL)
    {
        HAL_Free(payload);
    }

    PROTOCOL_TRACE("Post Event Message ID: %d", res);
    if (res < 0)
    {
        return -1;
    }
    return res;
}

static int send_event_charge_connect(evs_event_charge_connect_change *data)
{
    int res = 0;
    cJSON *root = NULL;
    char *payload = NULL;
    char time[16] = {0};

    root = cJSON_CreateObject();

    sprintf(time, "%d", data->yxOccurTime);

    cJSON_AddNumberToObject(root, "gunNo", data->gunNo);
    cJSON_AddNumberToObject(root, "cpStatus", data->cpStatus);
    cJSON_AddNumberToObject(root, "cpVolt", data->cpVolt);
    cJSON_AddNumberToObject(root, "s3Status", data->s3Status);
    cJSON_AddStringToObject(root, "yxOccurTime", time);

    payload = cJSON_PrintUnformatted(root);
    res = IOT_Linkkit_TriggerEvent(evs_g_user_ctx.master_devid, "acCarConChEvt", strlen("acCarConChEvt"), (char *)payload, strlen(payload));

    if (root != NULL)
    {
        cJSON_Delete(root);
    }

    if (payload != NULL)
    {
        HAL_Free(payload);
    }

    PROTOCOL_TRACE("Post Event Message ID: %d", res);
    if (res < 0)
    {
        return -1;
    }
    return res;
}

static int send_event_ble_plug_chg_info(evs_event_ble_plug_charge_info *data)
{
    int res = 0;
    cJSON *root = NULL;
    cJSON *macList = NULL;
    char *payload = NULL;
    int i = 0;

    root = cJSON_CreateObject();

    cJSON_AddNumberToObject(root, "plugChgStatus", data->plugChgStatus);
    cJSON_AddNumberToObject(root, "macNum", data->macNum);
    cJSON_AddItemToObject(root, "macList", macList = cJSON_CreateArray());
    for (i = 0; i < data->macNum; i++)
    {
        cJSON_AddItemToArray(macList, cJSON_CreateString(data->macList[i]));
    }

    payload = cJSON_PrintUnformatted(root);
    res = IOT_Linkkit_TriggerEvent(evs_g_user_ctx.master_devid, "blePlugChgInfoEvt", strlen("blePlugChgInfoEvt"), (char *)payload, strlen(payload));

    if (root != NULL)
    {
        cJSON_Delete(root);
    }

    if (payload != NULL)
    {
        HAL_Free(payload);
    }

    PROTOCOL_TRACE("Post Event Message ID: %d", res);
    if (res < 0)
    {
        return -1;
    }
    return res;
}

static int send_event_ble_conn_change(evs_event_ble_conn_change *data)
{
    int res = 0;
    cJSON *root = NULL;
    char *payload = NULL;
    char time[16] = {0};

    root = cJSON_CreateObject();

    sprintf(time, "%d", data->yxOccurTime);

    cJSON_AddStringToObject(root, "yxOccurTime", time);
    cJSON_AddNumberToObject(root, "connCheckStatus", data->connCheckStatus);
    cJSON_AddStringToObject(root, "macInfo", data->macInfo);

    payload = cJSON_PrintUnformatted(root);
    res = IOT_Linkkit_TriggerEvent(evs_g_user_ctx.master_devid, "bleConnChEvt", strlen("bleConnChEvt"), (char *)payload, strlen(payload));

    if (root != NULL)
    {
        cJSON_Delete(root);
    }

    if (payload != NULL)
    {
        HAL_Free(payload);
    }

    PROTOCOL_TRACE("Post Event Message ID: %d", res);
    if (res < 0)
    {
        return -1;
    }
    return res;
}

static int send_event_pile_parts_ccu_info(evs_event_ccu_info *data)
{
    int res = 0;
    int i = 0;
    cJSON *root = NULL;
    char *payload = NULL;

    root = cJSON_CreateObject();

    cJSON_AddNumberToObject(root, "partsAddr", data->partsAddr);
    cJSON_AddNumberToObject(root, "residualLife", data->residualLife);
    cJSON_AddNumberToObject(root, "workTime", data->workTime);
    cJSON_AddNumberToObject(root, "alarmTimes", data->alarmTimes);
    cJSON_AddNumberToObject(root, "faultTimes", data->faultTimes);
    cJSON_AddNumberToObject(root, "k1Cnt", data->k1Cnt);
    cJSON_AddNumberToObject(root, "k2Cnt", data->k2Cnt);
    cJSON_AddNumberToObject(root, "reliefCircuitCnt", data->reliefCircuitCnt);
    cJSON_AddNumberToObject(root, "gunPlugCnt", data->gunPlugCnt);
    cJSON_AddNumberToObject(root, "gunLockCnt", data->gunLockCnt);
    cJSON_AddNumberToObject(root, "totalChargeCnt", data->totalChargeCnt);
    cJSON_AddNumberToObject(root, "totalChargeTime", data->totalChargeTime);

    payload = cJSON_PrintUnformatted(root);
    res = IOT_Linkkit_TriggerEvent(evs_g_user_ctx.master_devid, "ccuInfoEvt", strlen("ccuInfoEvt"), (char *)payload, strlen(payload));

    if (root != NULL)
    {
        cJSON_Delete(root);
    }

    if (payload != NULL)
    {
        HAL_Free(payload);
    }

    PROTOCOL_TRACE("Post Event Message ID: %d", res);
    if (res < 0)
    {
        return -1;
    }
    return res;
}

static int send_event_pile_parts_pcu_info(evs_event_pcu_info *data)
{
    int res = 0;
    int i = 0;
    cJSON *root = NULL;
    char *payload = NULL;

    root = cJSON_CreateObject();

    cJSON_AddNumberToObject(root, "partsAddr", data->partsAddr);
    cJSON_AddNumberToObject(root, "residualLife", data->residualLife);
    cJSON_AddNumberToObject(root, "workTime", data->workTime);
    cJSON_AddNumberToObject(root, "alarmTimes", data->alarmTimes);
    cJSON_AddNumberToObject(root, "faultTimes", data->faultTimes);

    payload = cJSON_PrintUnformatted(root);
    res = IOT_Linkkit_TriggerEvent(evs_g_user_ctx.master_devid, "pcuInfoEvt", strlen("pcuInfoEvt"), (char *)payload, strlen(payload));

    if (root != NULL)
    {
        cJSON_Delete(root);
    }

    if (payload != NULL)
    {
        HAL_Free(payload);
    }

    PROTOCOL_TRACE("Post Event Message ID: %d", res);
    if (res < 0)
    {
        return -1;
    }
    return res;
}

static int send_event_pile_parts_cu_info(evs_event_cu_info *data)
{
    int res = 0;
    int i = 0;
    cJSON *root = NULL;
    char *payload = NULL;

    root = cJSON_CreateObject();

    cJSON_AddNumberToObject(root, "partsAddr", data->partsAddr);
    cJSON_AddStringToObject(root, "devSN", data->devSN);
    cJSON_AddStringToObject(root, "devType", data->devType);
    cJSON_AddNumberToObject(root, "residualLife", data->residualLife);
    cJSON_AddNumberToObject(root, "workTime", data->workTime);
    cJSON_AddNumberToObject(root, "alarmTimes", data->alarmTimes);
    cJSON_AddNumberToObject(root, "faultTimes", data->faultTimes);
    cJSON_AddNumberToObject(root, "upTimes", data->upTimes);
    cJSON_AddNumberToObject(root, "pfcTemper", data->pfcTemper);
    cJSON_AddNumberToObject(root, "transformerTemper", data->transformerTemper);
    cJSON_AddNumberToObject(root, "frontFanTemper", data->frontFanTemper);
    cJSON_AddNumberToObject(root, "backFanTemper", data->backFanTemper);
    cJSON_AddNumberToObject(root, "inletTemer", data->inletTemer);
    cJSON_AddNumberToObject(root, "phaseVa", data->phaseVa);
    cJSON_AddNumberToObject(root, "phaseVb", data->phaseVb);
    cJSON_AddNumberToObject(root, "phaseVc", data->phaseVc);
    cJSON_AddNumberToObject(root, "status", data->status);

    cJSON_AddNumberToObject(root, "outputVol", data->outputVol);
    cJSON_AddNumberToObject(root, "outputCur", data->outputCur);
    cJSON_AddNumberToObject(root, "currentGID", data->currentGID);
    cJSON_AddNumberToObject(root, "alarm1", data->alarm1);
    cJSON_AddNumberToObject(root, "alarm2", data->alarm2);
    cJSON_AddNumberToObject(root, "alarm3", data->alarm3);

    payload = cJSON_PrintUnformatted(root);
    res = IOT_Linkkit_TriggerEvent(evs_g_user_ctx.master_devid, "cuInfoEvt", strlen("cuInfoEvt"), (char *)payload, strlen(payload));

    if (root != NULL)
    {
        cJSON_Delete(root);
    }

    if (payload != NULL)
    {
        HAL_Free(payload);
    }

    PROTOCOL_TRACE("Post Event Message ID: %d", res);
    if (res < 0)
    {
        return -1;
    }
    return res;
}

static int send_event_pile_parts_switch_info(evs_event_switch_info *data)
{
    int res = 0;
    int i = 0;
    cJSON *root = NULL;
    char *payload = NULL;

    root = cJSON_CreateObject();

    cJSON *switchAnodeState = NULL;
    cJSON *switchAnodeInfo = NULL;
    cJSON *switchCathodeInfo = NULL;
    cJSON_AddNumberToObject(root, "partsAddr", data->partsAddr);
    cJSON_AddNumberToObject(root, "residualLife", data->residualLife);
    cJSON_AddNumberToObject(root, "workTime", data->workTime);
    cJSON_AddNumberToObject(root, "alarmTimes", data->alarmTimes);
    cJSON_AddNumberToObject(root, "faultTimes", data->faultTimes);
    cJSON_AddNumberToObject(root, "switchType", data->switchType);
    cJSON_AddNumberToObject(root, "commState", data->commState);

    cJSON_AddItemToObject(root, "switchAnodeState", switchAnodeState = cJSON_CreateArray());
    for (i = 0; i < EVS_MAX_PARTS_SWITCH_NUM; i++)
        cJSON_AddItemToArray(switchAnodeState, cJSON_CreateNumber(data->switchAnodeState[i]));

    cJSON_AddItemToObject(root, "switchAnodeActCnt", switchAnodeInfo = cJSON_CreateArray());
    for (i = 0; i < EVS_MAX_PARTS_SWITCH_NUM; i++)
        cJSON_AddItemToArray(switchAnodeInfo, cJSON_CreateNumber(data->switchAnodeActCnt[i]));

    cJSON_AddItemToObject(root, "switchCathodeActCnt", switchCathodeInfo = cJSON_CreateArray());
    for (i = 0; i < EVS_MAX_PARTS_SWITCH_NUM; i++)
        cJSON_AddItemToArray(switchCathodeInfo, cJSON_CreateNumber(data->switchCathodeActCnt[i]));

    payload = cJSON_PrintUnformatted(root);
    res = IOT_Linkkit_TriggerEvent(evs_g_user_ctx.master_devid, "switchInfoEvt", strlen("switchInfoEvt"), (char *)payload, strlen(payload));

    if (root != NULL)
    {
        cJSON_Delete(root);
    }

    if (payload != NULL)
    {
        HAL_Free(payload);
    }

    PROTOCOL_TRACE("Post Event Message ID: %d", res);
    if (res < 0)
    {
        return -1;
    }
    return res;
}

static int send_event_pile_parts_edas_info(evs_event_edas_info *data)
{
    int res = 0;
    int i = 0;
    cJSON *root = NULL;
    char *payload = NULL;

    root = cJSON_CreateObject();

    cJSON_AddNumberToObject(root, "partsAddr", data->partsAddr);
    cJSON_AddNumberToObject(root, "residualLife", data->residualLife);
    cJSON_AddNumberToObject(root, "workTime", data->workTime);
    cJSON_AddNumberToObject(root, "alarmTimes", data->alarmTimes);
    cJSON_AddNumberToObject(root, "faultTimes", data->faultTimes);

    payload = cJSON_PrintUnformatted(root);
    res = IOT_Linkkit_TriggerEvent(evs_g_user_ctx.master_devid, "evInfoEvt", strlen("evInfoEvt"), (char *)payload, strlen(payload));

    if (root != NULL)
    {
        cJSON_Delete(root);
    }

    if (payload != NULL)
    {
        HAL_Free(payload);
    }

    PROTOCOL_TRACE("Post Event Message ID: %d", res);
    if (res < 0)
    {
        return -1;
    }
    return res;
}

static int send_event_pile_parts_cu_work_info(evs_event_cu_work_info *data)
{
    int res = 0;
    int i = 0;
    cJSON *root = NULL;
    char *payload = NULL;

    root = cJSON_CreateObject();

    cJSON_AddNumberToObject(root, "gunNo", data->gunNo);
    cJSON_AddNumberToObject(root, "sumModul", data->sumModul);
    cJSON_AddNumberToObject(root, "ratedPower", data->ratedPower);
    cJSON_AddNumberToObject(root, "workModulCnt", data->workModulCnt);
    cJSON_AddNumberToObject(root, "faultModulCnt", data->faultModulCnt);
    cJSON_AddNumberToObject(root, "portWorkModulCnt", data->portWorkModulCnt);

    payload = cJSON_PrintUnformatted(root);
    res = IOT_Linkkit_TriggerEvent(evs_g_user_ctx.master_devid, "cuWorkInfoEvt", strlen("cuWorkInfoEvt"), (char *)payload, strlen(payload));

    if (root != NULL)
    {
        cJSON_Delete(root);
    }

    if (payload != NULL)
    {
        HAL_Free(payload);
    }

    PROTOCOL_TRACE("Post Event Message ID: %d", res);
    if (res < 0)
    {
        return -1;
    }
    return res;
}

static int send_event_vin_list_result(evs_event_vinList_result *data)
{
    int res = 0, i = 0;
    cJSON *root = NULL;
    char *payload = NULL;

    root = cJSON_CreateObject();

    cJSON_AddStringToObject(root, "updateSN", data->updateSN);
    cJSON_AddNumberToObject(root, "packCnt", data->packCnt);
    cJSON_AddNumberToObject(root, "packTotalCnt", data->packTotalCnt);
    cJSON_AddNumberToObject(root, "totalVINCnt", data->totalVINCnt);
    cJSON_AddNumberToObject(root, "packVINCnt", data->packVINCnt);

    if (data->packVINCnt > 0)
    {
        cJSON *vinListArray = NULL;
        cJSON_AddItemToObject(root, "vinList", vinListArray = cJSON_CreateArray());
        for (i = 0; i < data->packVINCnt; i++)
        {
            cJSON_AddItemToArray(vinListArray, cJSON_CreateString(data->vinList[i]));
        }
    }

    payload = cJSON_PrintUnformatted(root);
    res = IOT_Linkkit_TriggerEvent(evs_g_user_ctx.master_devid, "vinListCheckEvt", strlen("vinListCheckEvt"), (char *)payload, strlen(payload));

    if (root != NULL)
    {
        cJSON_Delete(root);
    }

    if (payload != NULL)
    {
        HAL_Free(payload);
    }

    PROTOCOL_TRACE("Post Event Message ID: %d", res);
    if (res < 0)
    {
        return -1;
    }
    return res;
}

static int send_event_time_sync_result(evs_event_time_sync_result *data)
{
    int res = 0, i = 0;
    cJSON *root = NULL;
    char *payload = NULL;

    root = cJSON_CreateObject();

    cJSON_AddStringToObject(root, "srvTime", data->srvTime);
    cJSON_AddStringToObject(root, "devTime", data->devTime);
    cJSON_AddNumberToObject(root, "resCode", data->resCode);

    payload = cJSON_PrintUnformatted(root);
    res = IOT_Linkkit_TriggerEvent(evs_g_user_ctx.master_devid, "timeSyncRetEvt", strlen("timeSyncRetEvt"), (char *)payload, strlen(payload));

    if (root != NULL)
    {
        cJSON_Delete(root);
    }

    if (payload != NULL)
    {
        HAL_Free(payload);
    }

    PROTOCOL_TRACE("Post Event Message ID: %d", res);
    if (res < 0)
    {
        return -1;
    }
    return res;
}

int evs_linkkit_time_sync(void)
{
    int ret = 0;

    ret = IOT_Linkkit_Query(evs_g_user_ctx.master_devid, ITM_MSG_QUERY_TIMESTAMP, NULL, 0);
    if (ret)
    {
        PROTOCOL_TRACE("Linkkit Qurey Time Stamp Failed %d ", ret);
        return 1;
    }

    return 0;
}

int evs_linkkit_fota(unsigned char *buffer, int buffer_length)
{
    int ret = 0;

    ret = IOT_Linkkit_Query(evs_g_user_ctx.master_devid, ITM_MSG_QUERY_FOTA_DATA, buffer, buffer_length);
    if (ret)
    {
        PROTOCOL_TRACE("Linkkit Qurey Image Failed %d ", ret);
        return 1;
    }

    return 0;
}

#ifdef HTTP2_COMM_ENABLED
int evs_linkkit_file_upload(char *filePath)
{
    http2_upload_conn_info_t conn_info;
    http2_status_cb_t status_cb;
    http2_upload_result_cb_t result_cb;
    void *handle;
    unsigned int retry_time = 0;
    int ret;
    char url[250] = {0};

    memset(&conn_info, 0, sizeof(http2_upload_conn_info_t));

    sprintf(url, "%s.iot-as-http2.cn-shanghai.aliyuncs.com", master_meta_info.product_key); // mark锟�? need to confirm is master_meta_info.product_key or master_meta_info.devicename
    conn_info.product_key = master_meta_info.product_key;
    conn_info.device_name = master_meta_info.device_name;
    conn_info.device_secret = master_meta_info.device_secret;
    conn_info.url = url;
    conn_info.port = HTTP2_ONLINE_SERVER_PORT;

    memset(&status_cb, 0, sizeof(http2_status_cb_t));
    status_cb.on_reconnect_cb = _on_http2_reconnect;
    status_cb.on_disconnect_cb = _on_http2_disconnect;

    memset(&result_cb, 0, sizeof(http2_upload_result_cb_t));
    result_cb.upload_completed_cb = upload_file_result;
    result_cb.upload_id_received_cb = upload_id_received_handle;

    handle = IOT_HTTP2_UploadFile_Connect(&conn_info, &status_cb);
    if (handle == NULL)
    {
        return -1;
    }
    is_connected = 1;

    http2_upload_params_t fs_params;
    memset(&fs_params, 0, sizeof(fs_params));
    fs_params.file_path = filePath;
    fs_params.opt_bit_map = UPLOAD_FILE_OPT_BIT_OVERWRITE;

    ret = IOT_HTTP2_UploadFile_Request(handle, &fs_params, &result_cb, NULL);
    if (ret < 0)
    {
        return -1;
    }

    /* wait until upload end */
    while (upload_result == 1)
    {
        HAL_SleepMs(200);
    }

    /* check the result */
    if (upload_result == UPLOAD_SUCCESS)
    {
        PROTOCOL_TRACE("upload succeed");
        ret = IOT_HTTP2_UploadFile_Disconnect(handle);
        PROTOCOL_TRACE("close connect %d\n", ret);
        return 0;
    }
    else
    {
        /* check if upload_id receivced */
        if (g_upload_id[0] == '\0')
        {
            PROTOCOL_TRACE("upload id is NULL, resume is impossible!");
            return -1;
        }
    }

    /* into resume routine */
    do
    {
        /* TODO: assume that http2 disconnected */
        if (upload_result < 0 && is_connected == 1)
        {
            HAL_SleepMs(30000);
        }

        /* wait until connected */
        while (is_connected == 0)
        {
            HAL_SleepMs(200);
        }

        /* reset upload result */
        upload_result = 1;

        /* use resume option to upload file */
        fs_params.file_path = filePath;
        fs_params.upload_len = 0;
        fs_params.upload_id = g_upload_id;
        fs_params.opt_bit_map = UPLOAD_FILE_OPT_BIT_RESUME; /* resume option used */
        ret = IOT_HTTP2_UploadFile_Request(handle, &fs_params, &result_cb, NULL);
        if (ret < 0)
        {
            PROTOCOL_TRACE("upload file request error");
            return -1;
        }

        while (upload_result == 1)
        {
            HAL_SleepMs(200);
        }

    } while (upload_result != UPLOAD_SUCCESS && (++retry_time < UPLOAD_RETRY_TIME));

    PROTOCOL_TRACE("upload succeed %d\n", ret);

    ret = IOT_HTTP2_UploadFile_Disconnect(handle);
    PROTOCOL_TRACE("close connect %d\n", ret);
    return 0;
}
#endif
extern void IOT_SetRootCA(int type);
int evs_linkkit_new(const int evs_access, const int is_device_uid)
{

#ifdef DYNAMIC_REGISTER
    int DeviceSecretLength = 0;
    int regCodeLenth = 0;
    iotx_http_region_types_t region = IOTX_HTTP_REGION_CUSTOM;
    int res = 0;
    iotx_dev_meta_info_t dev_reg_meta;
    char reg_code[IOTX_DEVICE_REG_CODE_LEN + 1] = "";
    char device_uid[IOTX_DEVICE_UID_LEN + 1] = "";

    IOT_Ioctl(IOTX_IOCTL_SET_REGISTER_REGION, (void *)&evs_access);
#endif

    int custom_port = 0;

    if (evs_access == ACCESS_IS_FORMAL)
    {
        custom_port = 18883;
        IOT_SetLogLevel(IOT_LOG_ERROR);
    }
    else
    {
        custom_port = 30183; //add at 2025.7.15
        IOT_SetLogLevel(IOT_LOG_DEBUG);
    }

    main_loop_step = 0;
    void *callback;
    int dynamic_register = 0, post_reply_need = 0;
    evs_device_meta evs_dev_meta;
    memset(&evs_g_user_ctx, 0, sizeof(evs_g_user_ctx));
    int ret = 0;

#ifdef ATM_ENABLED
    if (IOT_ATM_Init() < 0)
    {
        PROTOCOL_TRACE("IOT_ATM_Init failed!");
        return -1;
    }
#endif

#ifdef DYNAMIC_REGISTER
    memset(&dev_reg_meta, 0, sizeof(dev_reg_meta));
    memset(&evs_dev_meta, 0, sizeof(evs_dev_meta));
    callback = evs_service_callback(EVS_CERT_GET);
    if (callback)
    {
        ret = ((int (*)(evs_device_meta *meta))callback)(&evs_dev_meta);
    }

    DeviceSecretLength = strlen(evs_dev_meta.device_secret);

    // 濡傛灉娌℃湁璇佷功
    if ((DeviceSecretLength <= 5) || (DeviceSecretLength > IOTX_DEVICE_SECRET_LEN) || (ret < 0))
    {
        if (is_device_uid != 0)
        {
            callback = evs_service_callback(EVS_DEVICE_UID_GET);
            if (callback)
            {
                regCodeLenth = ((int (*)(char *device_uid))callback)(device_uid);
                memcpy(dev_reg_meta.device_asset, device_uid, sizeof(device_uid));
            }
            IOT_Get_Regcode(region, &dev_reg_meta);
            PROTOCOL_TRACE("IOT_Get_Regcode dev_reg_meta.device_reg_code is %s\n",dev_reg_meta.device_reg_code);
            regCodeLenth = strlen(dev_reg_meta.device_reg_code);
        }
        else
        {
            callback = evs_service_callback(EVS_DEVICE_REG_CODE_GET);
            if (callback)
            {

                regCodeLenth = ((int (*)(char *device_reg_code))callback)(reg_code);
                memcpy(dev_reg_meta.device_reg_code, reg_code, sizeof(reg_code));
            }
        }
        // regCodeLenth = HAL_GetDeviceRegCode(g_device_reg_code);
        // 鍒ゆ柇娉ㄥ唽鐮侊紝濡傛灉娌℃湁娉ㄥ唽鐮侊紝鍒欏湪姝ゅ惊锟�?
        // PROTOCOL_TRACE("dev_reg_meta.device_reg_code length is %d\n",regCodeLenth);
        // PROTOCOL_TRACE("dev_reg_meta.device_reg_code is %s\n",dev_reg_meta.device_reg_code);
        if ((regCodeLenth < 5) || (regCodeLenth > IOTX_DEVICE_REG_CODE_LEN))
        {
            PROTOCOL_TRACE("Get RegCode failed");
            return -1;
        }
        res = IOT_Dynamic_Register(region, &dev_reg_meta);
        if (res < 0)
        {
            PROTOCOL_TRACE("IOT_Dynamic_Register failed");
            return -2;
        }
        // HAL_Printf("\nProduct Key: %s\n", dev_reg_meta.product_key);
        memcpy(evs_dev_meta.product_key, dev_reg_meta.product_key, strlen(dev_reg_meta.product_key));
        // HAL_Printf("\nDevice Name: %s\n", dev_reg_meta.device_name);
        memcpy(evs_dev_meta.device_name, dev_reg_meta.device_name, strlen(dev_reg_meta.device_name));
        // HAL_Printf("\nDevice Secret: %s\n", dev_reg_meta.device_secret);
        memcpy(evs_dev_meta.device_secret, dev_reg_meta.device_secret, strlen(dev_reg_meta.device_secret));

        memcpy(evs_dev_meta.device_reg_code, dev_reg_meta.device_reg_code, strlen(dev_reg_meta.device_reg_code));

        callback = evs_service_callback(EVS_CERT_SET);
        if (callback)
        {
            ((int (*)(const evs_device_meta meta))callback)(evs_dev_meta);
        }
    }
#endif

    callback = evs_service_callback(EVS_CERT_GET);
    if (callback)
    {
        if (((int (*)(evs_device_meta *))callback)(&evs_dev_meta) != 0)
        {
            PROTOCOL_TRACE("Get cert failed");
            return -3;
        }
    }

    memset(&master_meta_info, 0, sizeof(iotx_linkkit_dev_meta_info_t));
    memcpy(master_meta_info.product_key, evs_dev_meta.product_key, strlen(evs_dev_meta.product_key));
    memcpy(master_meta_info.device_name, evs_dev_meta.device_name, strlen(evs_dev_meta.device_name));
    memcpy(master_meta_info.device_secret, evs_dev_meta.device_secret, strlen(evs_dev_meta.device_secret));

    /* 娉ㄥ唽鍥炶皟鍑芥暟 */
    IOT_RegisterCallback(ITE_STATE_EVERYTHING, user_sdk_state_dump);
    IOT_RegisterCallback(ITE_CONNECT_SUCC, user_connected_event_handler);
    IOT_RegisterCallback(ITE_DISCONNECTED, user_disconnected_event_handler);
    IOT_RegisterCallback(ITE_SERVICE_REQUEST, user_service_request_event_handler);
    IOT_RegisterCallback(ITE_PROPERTY_SET, user_property_set_event_handler);
    IOT_RegisterCallback(ITE_REPORT_REPLY, user_report_reply_event_handler);
    IOT_RegisterCallback(ITE_TRIGGER_EVENT_REPLY, user_trigger_event_reply_event_handler);
    IOT_RegisterCallback(ITE_TIMESTAMP_REPLY, user_timestamp_reply_event_handler);
    IOT_RegisterCallback(ITE_INITIALIZE_COMPLETED, user_initialized);
    IOT_RegisterCallback(ITE_FOTA, user_fota_event_handler);
    IOT_RegisterCallback(ITE_CLOUD_ERROR, user_cloud_error_handler);
    IOT_RegisterCallback(ITE_DYNREG_DEVICE_SECRET, dynreg_device_secret);

    /* 閫夋嫨涓婄嚎鏂瑰紡锛堟槸鍚︿娇鐢ㄥ姩鎬佹敞鍐岋級 */
    dynamic_register = 0;
    IOT_Ioctl(IOTX_IOCTL_SET_DYNAMIC_REGISTER, (void *)&dynamic_register);

    /* 锟�?鍚﹂渶鐢ㄥ睘鎬с€佷簨浠朵笂锟�?(璁剧疆)搴旂瓟 */
    post_reply_need = 1;
    IOT_Ioctl(IOTX_IOCTL_RECV_EVENT_REPLY, (void *)&post_reply_need);

    if (evs_access == ACCESS_IS_FORMAL)
    {
        //IOT_Ioctl(IOTX_IOCTL_SET_MQTT_DOMAIN, (void *)"10.111.186.1");
        IOT_Ioctl(IOTX_IOCTL_SET_MQTT_DOMAIN, (void *)"10.111.186.1");
        IOT_Ioctl(IOTX_IOCTL_SET_MQTT_PORT, (void *)&custom_port);
    }
    else
    {   //add at 2025.5.13
        IOT_Ioctl(IOTX_IOCTL_SET_MQTT_DOMAIN, (void *)"47.114.190.246");
        IOT_Ioctl(IOTX_IOCTL_SET_MQTT_PORT, (void *)&custom_port);
    }

    return 0;
}

int evs_linkkit_free()
{
    IOT_Linkkit_Close(evs_g_user_ctx.master_devid);
    IOT_SetLogLevel(IOT_LOG_NONE);
    main_loop_step = -1;
    return 0;
}

void evs_set_firmware_version(const char *verion)
{
    HAL_SetFirmwareVersion(verion);
}

int evs_mainloop()
{
    int res = 0;
    switch (main_loop_step)
    {
    case EVS_LINKKIT_OPEN:
    {
        evs_g_user_ctx.master_devid = IOT_Linkkit_Open(IOTX_LINKKIT_DEV_TYPE_MASTER, &master_meta_info);
        if (evs_g_user_ctx.master_devid >= 0)
        {
            main_loop_step = EVS_LINKKIT_CONNECT;
        }
        else
        {
            PROTOCOL_TRACE("IOT_Linkkit_Open failed!\n");
            return EVS_LINKKIT_OPEN_FAULT;
        }
    }

    case EVS_LINKKIT_CONNECT:
    {
        res = IOT_Linkkit_Connect(evs_g_user_ctx.master_devid);
        if (res >= 0)
        {
            main_loop_step = EVS_LINKKIT_POLL;
        }
        else
        {
            PROTOCOL_TRACE("IOT_Linkkit_Connect failed!\n");
            return EVS_LINKKIT_CONNECT_FAULT;
        }
    }

    case EVS_LINKKIT_POLL:
        IOT_Linkkit_Yield(EVS_YIELD_TIMEOUT_MS);
        break;
    default:
        break;
    }
    return 0;
}

/**
 * @brief Send pile event data to SDK.
 *---
 * @param [in] event_type: @n the event you want to send.
 * @param [in] param: @n the event data will be written.
 * @return failed -1 success 0.
 * @see None.
 * @note None.
 */

void evs_send_event(evs_cmd_event_enum event_type, void *param)
{
    switch (event_type)
    {
    case EVS_CMD_EVENT_FIRMWARE_INFO:
        send_event_firmware_info((evs_event_firmware_info *)param);
        break;
    case EVS_CMD_EVENT_ASK_FEEMODEL:
        send_event_ask_feeModel((evs_event_ask_feeModel *)param);
        break;
    case EVS_CMD_EVENT_STARTCHARGE:
        send_event_auth_start((evs_event_startCharge *)param);
        break;
    case EVS_CMD_EVENT_STARTRESULT:
        send_event_start_result((evs_event_startResult *)param);
        break;
    case EVS_CMD_EVENT_STOPCHARGE:
        send_event_stopCharge((evs_event_stopCharge *)param);
        break;
    case EVS_CMD_EVENT_TRADEINFO:
        send_event_tradeInfo((evs_event_tradeInfo *)param);
        break;
    case EVS_CMD_EVENT_ALARM:
        send_event_alarm((evs_event_alarm *)param);
        break;
    case EVS_CMD_EVENT_ACPILE_CHANGE:
        send_event_acPile_change((evs_event_pile_stutus_change *)param);
        break;
    case EVS_CMD_EVENT_DCPILE_CHANGE:
        send_event_dcPile_change((evs_event_pile_stutus_change *)param);
        break;
    case EVS_CMD_EVENT_GROUNDLOCK_CHANGE:
        send_event_groundLock_change((evs_event_groundLock_change *)param);
        break;
    case EVS_CMD_EVENT_GATELOCK_CHANGE:
        send_event_gateLock_change((evs_event_gateLock_change *)param);
        break;
    case EVS_CMD_EVENT_ASK_DEV_CONFIG:
        send_event_ask_dev_config();
        break;
    case EVS_CMD_EVENT_CAR_INFO:
        send_event_car_info((evs_event_car_info *)param);
        break;
    case EVS_CMD_EVENT_VER_INFO:
        send_event_ver_info((evs_event_ver_info *)param);
        break;
    case EVS_CMD_EVENT_LOGQUERY_RESULT:
        send_event_logquery_result((evs_event_logQuery_Result *)param);
        break;
    case EVS_CMD_EVENT_CARD_INFO:
        send_event_card_info((evs_event_card_info *)param);
        break;
    case EVS_CMD_EVENT_CARD_AUTH:
        send_event_card_auth((evs_event_card_auth *)param);
        break;
    case EVS_CMD_EVENT_CARD_AUTH_RESULT:
        send_event_card_auth_result((evs_event_card_auth_result *)param);
        break;
    case EVS_CMD_EVENT_CARD_CHECK_ERROR:
        send_event_card_check_error((evs_event_card_check_error *)param);
        break;
    case EVS_CMD_EVENT_DEVMDU_INFO:
        send_event_devmdu_info((evs_event_devmdu_info *)param);
        break;
    case EVS_CMD_EVENT_CHARGE_CONNECT:
        send_event_charge_connect((evs_event_charge_connect_change *)param);
        break;
    case EVS_CMD_EVENT_BLE_PLUG_CHARGE_INFO:
        send_event_ble_plug_chg_info((evs_event_ble_plug_charge_info *)param);
        break;
    case EVS_CMD_EVENT_BLE_CONN_CHANGE:
        send_event_ble_conn_change((evs_event_ble_conn_change *)param);
        break;
    case EVS_CMD_EVENT_VIN_CHECK_RESULT:
        send_event_vin_list_result((evs_event_vinList_result *)param);
        break;
    case EVS_CMD_EVENT_PILE_PARTS_CCU_INFO:
        send_event_pile_parts_ccu_info((evs_event_ccu_info *)param);
        break;
    case EVS_CMD_EVENT_PILE_PARTS_PCU_INFO:
        send_event_pile_parts_pcu_info((evs_event_pcu_info *)param);
        break;
    case EVS_CMD_EVENT_PILE_PARTS_CU_INFO:
        send_event_pile_parts_cu_info((evs_event_cu_info *)param);
        break;
    case EVS_CMD_EVENT_PILE_PARTS_SWITCH_INFO:
        send_event_pile_parts_switch_info((evs_event_switch_info *)param);
        break;
    case EVS_CMD_EVENT_PILE_PARTS_EDAS_INFO:
        send_event_pile_parts_edas_info((evs_event_edas_info *)param);
        break;
    case EVS_CMD_EVENT_PILE_PARTS_CU_WORK_INFO:
        send_event_pile_parts_cu_work_info((evs_event_cu_work_info *)param);
        break;
    case EVS_CMD_EVENT_RAW_DATA:
        send_event_raw((char *)param);
        break;
    case EVS_CMD_EVENT_DEV_MAINTAIN_RESULT:
        send_event_dev_maintain_result((evs_event_feedback_dev_maintain *)param);
        break;
    case EVS_CMD_EVENT_LOCK_CTRL_RESULT:
        send_event_lock_ctrl_result((evs_event_feedback_lockCtrl *)param);
        break;
    case EVS_CMD_EVENT_TIME_SYNC_RESULT:
        send_event_time_sync_result((evs_event_time_sync_result *)param);
        break;
    default:
        break;
    }
}

/**
聽*
聽* 鍑芥暟 evs_send_property() SDK鍐呴儴瀹炵幇鐨勪簨浠跺彂閫佹帴锟�?, 渚涗娇鐢ㄨ€呰皟鐢拷?
聽* ---
聽* Interface of evs_send_property() implemented by SDK锟�? provide for user of SDK.
聽*
聽*聽
聽*/
/**
 * @brief Send pile porperty data to SDK.
 *---
 * @param [in] event_type: @n the property you want to send.
 * @param [in] param: @n the property data will be written.
 * @return failed -1 success 0.
 * @see None.
 * @note None.
 */

void evs_send_property(evs_cmd_property_enum property_type, void *param)
{
    switch (property_type)
    {
    case EVS_CMD_PROPERTY_DCPILE:
        send_property_dcPile((evs_property_dcPile *)param);
        break;
    case EVS_CMD_PROPERTY_ACPILE:
        send_property_acPile((evs_property_acPile *)param);
        break;
    case EVS_CMD_PROPERTY_AC_WORK:
        send_property_ac_work((evs_property_ac_work *)param);
        break;
    case EVS_CMD_PROPERTY_AC_NONWORK:
        send_property_ac_nonwork((evs_property_ac_nonWork *)param);
        break;
    case EVS_CMD_PROPERTY_BMS:
        send_property_bms((evs_property_BMS *)param);
        break;
    case EVS_CMD_PROPERTY_DC_INPUT_METER:
        send_property_dc_input_meter((evs_property_dc_input_meter *)param);
        break;
    case EVS_CMD_PROPERTY_AC_OUTMETER:
        send_property_ac_outmeter((evs_property_meter *)param);
        break;
    case EVS_CMD_PROPERTY_DC_OUTMETER:
        send_property_dc_outmeter((evs_property_meter *)param);
        break;
    case EVS_CMD_PROPERTY_DC_WORK:
        send_property_dc_work((evs_property_dc_work *)param);
        break;
    case EVS_CMD_PROPERTY_DC_NONWORK:
        send_property_dc_nonwork((evs_property_dc_nonWork *)param);
        break;
    default:
        break;
    }
}

/*--------------------------------------鏅鸿兘锟�?-----------------------------------------------*/

/*------------------------------------------------------------------------------------------------
* 鍚戯拷?锟藉崱鍣ㄥ彂閫佹暟锟�?骞舵帴鏀舵暟锟�?杩斿洖
------------------------------------------------------------------------------------------------*/
static void evs_card_exchange_data(int fd, int send_count, unsigned char *send_buf, int *recv_count, unsigned char *reply_buf, int opCnt)
{
    int n = 0, nCount = 0, dataCount = 0;
    int reply_count = 128;
    int ret = 0, send_err_time = 0;
    char buf[128] = {0};

    for (n = 0; n < opCnt; n++)
    {
        nCount = 0;

        ret = HAL_Write(fd, send_buf, send_count);
        if (ret != send_count)
        {
            send_err_time++;
            if (send_err_time == 3)
            {
                PROTOCOL_TRACE("Send To Reader Failed");
                break;
            }
            continue;
        }

        memset(buf, 0, sizeof(buf));

        HAL_SleepMs(200);
        while ((nCount = HAL_Read(fd, buf, reply_count)) > 0)
        {
            if (nCount == (((buf[1] << 8) + buf[2]) + 5))
            {
                memcpy(reply_buf, buf, nCount);
                *recv_count = nCount;
                return;
            }
            else
            {
                dataCount = (((buf[1] << 8) + buf[2]) + 5);
                if (dataCount > 0)
                {
                    if ((buf[0] == 0x02) && (buf[dataCount - 1] == 0x03))
                    {
                        memcpy(reply_buf, buf, dataCount);
                        *recv_count = dataCount;
                        return;
                    }
                }
            }
        }
    }

    *recv_count = 0;
    return;
}

/*
static void evs_card_exchange_data(int fd, int send_count, unsigned char *send_buf, int *recv_count, unsigned char *reply_buf, int opCnt)
{
    int n = 0, nCount = 0, sleepCnt = 0;
    int ret = 0, send_err_time = 0, recv_err_time = 0;
    int reciev_data = 0, framLen = 0;
    int bufLen = *recv_count;

    for (n = 0; n < opCnt; n++)
    {
        sleepCnt = 100;
        nCount = 0;
        reciev_data = 0;
        memset(reply_buf, 0, sizeof(bufLen));

        ret = HAL_Write(fd, send_buf, send_count);
        if (ret != send_count)
        {
            send_err_time++;
            if (send_err_time == 3)
            {
                PROTOCOL_TRACE("Send To Reader Failed");
                break;
            }
            continue;
        }

        while (1)
        {
            HAL_SleepMs(sleepCnt);
            reciev_data = HAL_Read(fd, (reply_buf + nCount), bufLen);
            if (reciev_data > 0)
            {
                nCount += reciev_data;
                framLen = (reply_buf[1] << 8) + reply_buf[2] + 5;

                if (framLen > bufLen)
                {
                    nCount = 0;
                    memset(reply_buf, 0, sizeof(bufLen));
                }
                else
                {
                    if (nCount >= framLen)
                    {
                        if (reply_buf[0] == 0x2 && reply_buf[framLen - 1] == 0x3)
                        {
                            PROTOCOL_TRACE("Recv Reader %d Bytes", nCount);
                            *recv_count = nCount;
                            return;
                        }
                        else
                        {
                            nCount = 0;
                            memset(reply_buf, 0, sizeof(bufLen));
                        }
                    }
                }
            }
            else //绛夊緟鏁版嵁
            {
                sleepCnt = 10;
                recv_err_time++;
                if (recv_err_time > 10)
                {
                    PROTOCOL_TRACE("Read From Reader Failed");
                    break;
                }
            }
        }
    }

    *recv_count = 0;
    return;
}
*/

/*------------------------------------------------------------------------------------------------
* 鍏抽棴灏勶拷??
------------------------------------------------------------------------------------------------*/
static int evs_card_ctrl_rf_close(int fd)
{
    unsigned char order_buf[7];
    unsigned char reply_buf[128];
    int nCount = 0;

    memset(order_buf, 0, sizeof(order_buf));
    memset(reply_buf, 0, sizeof(reply_buf));

    order_buf[0] = 0x2;
    order_buf[1] = 0x0;
    order_buf[2] = 0x2;
    order_buf[3] = 0x31;
    order_buf[4] = 0x91;
    order_buf[5] = order_buf[3] ^ order_buf[4];
    order_buf[6] = 0x3;

    nCount = sizeof(reply_buf);

    evs_card_exchange_data(fd, sizeof(order_buf), order_buf, &nCount, reply_buf, 3);
    if (nCount == 0)
    {
        PROTOCOL_TRACE("Get Data Failed");
        return -1;
    }

    if ((reply_buf[3] == 0) && (reply_buf[4] == 0))
        return EVS_OPT_READER_SUCCESS;
    else
        return EVS_CLOSE_RF_FAIL;
}

/*------------------------------------------------------------------------------------------------
* 鎵撳紑灏勶拷??
------------------------------------------------------------------------------------------------*/
static int evs_card_ctrl_rf_open(int fd)
{
    unsigned char order_buf[7];
    unsigned char reply_buf[128];
    int nCount = 0;

    memset(order_buf, 0, sizeof(order_buf));
    memset(reply_buf, 0, sizeof(reply_buf));

    order_buf[0] = 0x2;
    order_buf[1] = 0x0;
    order_buf[2] = 0x2;
    order_buf[3] = 0x31;
    order_buf[4] = 0x90;
    order_buf[5] = (order_buf[3] ^ order_buf[4]);
    order_buf[6] = 0x3;

    nCount = sizeof(reply_buf);

    evs_card_exchange_data(fd, sizeof(order_buf), order_buf, &nCount, reply_buf, 3);
    if (nCount == 0)
    {
        PROTOCOL_TRACE("Get Data Failed");
        return -1;
    }

    if ((reply_buf[3] == 0) && (reply_buf[4] == 0))
        return EVS_OPT_READER_SUCCESS;
    else
        return EVS_OPEN_RF_FAIL;
}

/**-----------------------------------------------------------------------------------------------
* 瀵诲崱
------------------------------------------------------------------------------------------------*/
static int evs_card_ctrl_found(int fd, int gunNo)
{
    unsigned char order_buf[9];
    unsigned char reply_buf[512];
    int i = 0;
    int nCount = 0, err = -1;

    memset(order_buf, 0, sizeof(order_buf));
    memset(reply_buf, 0, sizeof(reply_buf));
    memset(gun_auth_process_data[gunNo - 1].usrId, 0, sizeof(gun_auth_process_data[gunNo - 1].usrId));

    order_buf[0] = 0x2;
    order_buf[1] = 0x0;
    order_buf[2] = 0x04;
    order_buf[3] = 0x32;
    order_buf[4] = 0x24;
    order_buf[5] = 0x00;
    order_buf[6] = 0xc3;
    order_buf[7] = (order_buf[3] ^ order_buf[4] ^ order_buf[5] ^ order_buf[6]);
    order_buf[8] = 0x3;

    nCount = sizeof(reply_buf);

    unsigned int startTime = HAL_UptimeMs();
    while (1)
    {
        if ((HAL_UptimeMs() - startTime) < 10 * 1000)
        {
            evs_card_exchange_data(fd, sizeof(order_buf), order_buf, &nCount, reply_buf, 3);
            if (nCount == 0)
            {
                PROTOCOL_TRACE("Get Data Failed");
                return -1;
            }

            err = ((reply_buf[3] << 8) + reply_buf[4]);
            if (err == 0)
            {
                for (i = 0; i < 8; i++)
                {
                    gun_auth_process_data[gunNo - 1].usrId[i] = reply_buf[18 + i];
                }
            }
            else
            {
                PROTOCOL_TRACE("Activity Card Failed!");
            }
            break;
        }
        else
        {
            PROTOCOL_TRACE("Found Card Timeout!");
            break;
        }
    }
    return err;
}

/*------------------------------------------------------------------------------------------------
* 璁剧疆璇诲崱鍣ㄦ尝鐗圭巼
------------------------------------------------------------------------------------------------*/
static int evs_card_set_baudRate(int fd, int baud)
{
    unsigned char order_buf[8];
    unsigned char reply_buf[128];
    int nCount = 0;

    memset(order_buf, 0, sizeof(order_buf));
    memset(reply_buf, 0, sizeof(reply_buf));

    order_buf[0] = 0x02;
    order_buf[1] = 0x00;
    order_buf[2] = 0x03;
    order_buf[3] = 0x30;
    order_buf[4] = 0x01;
    order_buf[5] = baud;
    order_buf[6] = order_buf[3] ^ order_buf[4] ^ order_buf[5];
    order_buf[7] = 0x03;

    nCount = sizeof(reply_buf);

    evs_card_exchange_data(fd, sizeof(order_buf), order_buf, &nCount, reply_buf, 3);
    if (nCount == 0)
    {
        PROTOCOL_TRACE("Get Data Failed");
        return -1;
    }

    if ((reply_buf[3] == 0) && (reply_buf[4] == 0))
        return EVS_OPT_READER_SUCCESS;
    else
        return EVS_SET_READER_BAUD_FAIL;
}

/**-----------------------------------------------------------------------------------------------
* 鑾峰彇鐢ㄦ埛鍗′俊锟�?
------------------------------------------------------------------------------------------------*/
static int evs_card_get_cardSn(int fd)
{
    unsigned char order_buf[15];
    unsigned char reply_buf[128];
    unsigned char usr_id[10] = {0};
    unsigned char usr_version = 0;
    int i = 0;
    int nCount = 0;
    int nPos = 0;

    memset(order_buf, 0, sizeof(order_buf));
    memset(reply_buf, 0, sizeof(reply_buf));

    order_buf[0] = 0x2;
    order_buf[1] = 0x0;
    order_buf[2] = 0xa;
    order_buf[3] = 0x32;
    order_buf[4] = 0x26;
    order_buf[5] = 0xff;
    order_buf[6] = 0x0;
    order_buf[7] = 0xA4;
    order_buf[8] = 0x00;
    order_buf[9] = 0x00;
    order_buf[10] = 0x02;
    order_buf[11] = 0xDF;
    order_buf[12] = 0x02;
    order_buf[13] = (order_buf[3] ^ order_buf[4] ^ order_buf[5] ^ order_buf[6] ^ order_buf[7] ^ order_buf[8] ^ order_buf[9] ^ order_buf[10] ^ order_buf[11] ^ order_buf[12]);
    order_buf[14] = 0x3;

    nCount = sizeof(reply_buf);

    evs_card_exchange_data(fd, sizeof(order_buf), order_buf, &nCount, reply_buf, 3);
    if (nCount == 0)
    {
        PROTOCOL_TRACE("Get Data Failed");
        return -1;
    }

    if ((reply_buf[nCount - 4] == 0x90) && (reply_buf[nCount - 3] == 0x00))
    {
        for (i = 0; i < nCount - 1; i++)
        {
            if (reply_buf[i] == 0x9f && reply_buf[i + 1] == 0x0c)
            {
                usr_version = reply_buf[i + 12];
                nPos = i + 13;
                break;
            }
        }
    }

    if (nPos == 0)
    {
        return ((reply_buf[nCount - 4] << 8) + reply_buf[nCount - 3]);
    }

    for (i = 0; i < 10; i++)
    {
        usr_id[i] = reply_buf[nPos + i];
    }

    return ((reply_buf[nCount - 4] << 8) + reply_buf[nCount - 3]);
}

static int evs_card_check_pin(int fd)
{
    unsigned char order_buf[16];
    unsigned char reply_buf[128];
    int nCount = 0;

    memset(order_buf, 0, sizeof(order_buf));
    memset(reply_buf, 0, sizeof(reply_buf));

    order_buf[0] = 0x2;
    order_buf[1] = 0x0;
    order_buf[2] = 0xb;
    order_buf[3] = 0x32;
    order_buf[4] = 0x26;
    order_buf[5] = 0xff;
    order_buf[6] = 0x0;
    order_buf[7] = 0x20;
    order_buf[8] = 0x00;
    order_buf[9] = 0x00;
    order_buf[10] = 0x03;
    // 榛橈拷?锟界敤鎴峰崱瀵嗙爜
    order_buf[11] = 0x12;
    order_buf[12] = 0x34;
    order_buf[13] = 0x56;

    order_buf[14] = (order_buf[3] ^ order_buf[4] ^ order_buf[5] ^ order_buf[6] ^ order_buf[7] ^ order_buf[8] ^ order_buf[9] ^ order_buf[10] ^ order_buf[11] ^ order_buf[12] ^ order_buf[13]);
    order_buf[15] = 0x3;

    nCount = sizeof(reply_buf);

    evs_card_exchange_data(fd, sizeof(order_buf), order_buf, &nCount, reply_buf, 3);
    if (nCount == 0)
    {
        PROTOCOL_TRACE("Get Data Failed");
        return -1;
    }

    if (((reply_buf[nCount - 4] << 8) + reply_buf[nCount - 3]) != 0x9000)
    {
        PROTOCOL_TRACE("Check PIN Failed!");
    }
    return ((reply_buf[nCount - 4] << 8) + reply_buf[nCount - 3]);
}

static int evs_card_get_keyInfo(int fd, int gunNo)
{
    unsigned char order_buf[13];
    unsigned char reply_buf[128];
    int nCount = 0;

    memset(order_buf, 0, sizeof(order_buf));
    memset(reply_buf, 0, sizeof(reply_buf));

    order_buf[0] = 0x2;
    order_buf[1] = 0x0;
    order_buf[2] = 0x8;
    order_buf[3] = 0x32;
    order_buf[4] = 0x26;
    order_buf[5] = 0xff;
    order_buf[6] = 0x0;
    order_buf[7] = 0xB0;
    order_buf[8] = 0x95;
    order_buf[9] = 0x09;
    order_buf[10] = 0x01;
    order_buf[11] = (order_buf[3] ^ order_buf[4] ^ order_buf[5] ^ order_buf[6] ^ order_buf[7] ^ order_buf[8] ^ order_buf[9] ^ order_buf[10]);
    order_buf[12] = 0x3;

    nCount = sizeof(reply_buf);

    evs_card_exchange_data(fd, sizeof(order_buf), order_buf, &nCount, reply_buf, 3);
    if (nCount == 0)
    {
        PROTOCOL_TRACE("Get Data Failed");
        return -1;
    }

    if (((reply_buf[nCount - 4] << 8) + reply_buf[nCount - 3]) == 0x9000)
    {
        gun_auth_process_data[gunNo - 1].PKid = reply_buf[5];
    }
    else
    {
        PROTOCOL_TRACE("Get Pkey Failed");
    }
    return ((reply_buf[nCount - 4] << 8) + reply_buf[nCount - 3]);
}

/**-----------------------------------------------------------------------------------------------
* 楠岃瘉骞冲彴涓嬪彂鐨凪AC2
------------------------------------------------------------------------------------------------*/
static int evs_card_trade_confirm(int fd, int gunNo)
{
    unsigned char order_buf[25] = {0};
    unsigned char reply_buf[128] = {0};
    int nCount = 0;

    memset(gun_auth_process_data[gunNo - 1].TAC, 0, sizeof(gun_auth_process_data[gunNo - 1].TAC));

    order_buf[0] = 0x2;
    order_buf[1] = 0x0;
    order_buf[2] = 0x14;
    order_buf[3] = 0x32;
    order_buf[4] = 0x26;
    order_buf[5] = 0xff;
    order_buf[6] = 0x80;
    order_buf[7] = 0x52;
    order_buf[8] = 0x00;
    order_buf[9] = 0x00;
    order_buf[10] = 0x0B;

    /***************************trade date start***************************************/
    order_buf[11] = gun_auth_process_data[gunNo - 1].tradeTime[0];
    order_buf[12] = gun_auth_process_data[gunNo - 1].tradeTime[1];
    order_buf[13] = gun_auth_process_data[gunNo - 1].tradeTime[2];
    order_buf[14] = gun_auth_process_data[gunNo - 1].tradeTime[3];
    order_buf[15] = gun_auth_process_data[gunNo - 1].tradeTime[4];
    order_buf[16] = gun_auth_process_data[gunNo - 1].tradeTime[5];
    order_buf[17] = gun_auth_process_data[gunNo - 1].tradeTime[6];
    /*****************************trade date end***************************************/

    /*********************************MAC2 start***************************************/
    order_buf[18] = gun_auth_process_data[gunNo - 1].MAC2[0];
    order_buf[19] = gun_auth_process_data[gunNo - 1].MAC2[1];
    order_buf[20] = gun_auth_process_data[gunNo - 1].MAC2[2];
    order_buf[21] = gun_auth_process_data[gunNo - 1].MAC2[3];
    /*********************************MAC2 end*****************************************/
    order_buf[22] = 0x04;

    order_buf[23] = (order_buf[3] ^ order_buf[4] ^ order_buf[5] ^ order_buf[6] ^ order_buf[7] ^ order_buf[8] ^ order_buf[9] ^ order_buf[10] ^ order_buf[11] ^ order_buf[12] ^ order_buf[13] ^ order_buf[14] ^ order_buf[15] ^ order_buf[16] ^ order_buf[17] ^ order_buf[18] ^ order_buf[19] ^ order_buf[20] ^ order_buf[21] ^ order_buf[22]);
    order_buf[24] = 0x3;

    nCount = sizeof(reply_buf);

    evs_card_exchange_data(fd, sizeof(order_buf), order_buf, &nCount, reply_buf, 3);
    if (nCount == 0)
    {
        PROTOCOL_TRACE("Get Data Failed");
        return -1;
    }

    if (((reply_buf[nCount - 4] << 8) + reply_buf[nCount - 3]) == 0x9000)
    {
        gun_auth_process_data[gunNo - 1].TAC[0] = reply_buf[5];
        gun_auth_process_data[gunNo - 1].TAC[1] = reply_buf[6];
        gun_auth_process_data[gunNo - 1].TAC[2] = reply_buf[7];
        gun_auth_process_data[gunNo - 1].TAC[3] = reply_buf[8];
    }
    else
    {
        PROTOCOL_TRACE("Trade Confirm Failed");
    }

    return ((reply_buf[nCount - 4] << 8) + reply_buf[nCount - 3]);
}

/**-----------------------------------------------------------------------------------------------
* 鑾峰彇鍗＄墖闅忔満鏁板強MAC1绛変俊锟�?
------------------------------------------------------------------------------------------------*/
static int evs_card_get_authCode(int fd, int gunNo)
{
    unsigned char order_buf[25];
    unsigned char reply_buf[128];
    int nCount = 0;

    gun_auth_process_data[gunNo - 1].authVer = 0;
    gun_auth_process_data[gunNo - 1].authFlag = 0;
    memset(order_buf, 0, sizeof(order_buf));
    memset(reply_buf, 0, sizeof(reply_buf));

    memset(gun_auth_process_data[gunNo - 1].cardBalance, 0, sizeof(gun_auth_process_data[gunNo - 1].cardBalance));
    memset(gun_auth_process_data[gunNo - 1].tradeSn, 0, sizeof(gun_auth_process_data[gunNo - 1].tradeSn));

    memset(gun_auth_process_data[gunNo - 1].randomC, 0, sizeof(gun_auth_process_data[gunNo - 1].randomC));
    memset(gun_auth_process_data[gunNo - 1].MAC1, 0, sizeof(gun_auth_process_data[gunNo - 1].MAC1));

    order_buf[0] = 0x2;
    order_buf[1] = 0x0;
    order_buf[2] = 0x14;
    order_buf[3] = 0x32;
    order_buf[4] = 0x26;
    order_buf[5] = 0xff;
    order_buf[6] = 0x80;
    order_buf[7] = 0x50;
    order_buf[8] = 0x00;
    order_buf[9] = 0x01;
    order_buf[10] = 0x0B;

    order_buf[11] = gun_auth_process_data[gunNo - 1].PKid;
    order_buf[12] = 0x00;
    order_buf[13] = 0x00;
    order_buf[14] = 0x00;
    order_buf[15] = 0x00;

    order_buf[16] = gun_auth_process_data[gunNo - 1].terminalSn[0];
    order_buf[17] = gun_auth_process_data[gunNo - 1].terminalSn[1];
    order_buf[18] = gun_auth_process_data[gunNo - 1].terminalSn[2];
    order_buf[19] = gun_auth_process_data[gunNo - 1].terminalSn[3];
    order_buf[20] = gun_auth_process_data[gunNo - 1].terminalSn[4];
    order_buf[21] = gun_auth_process_data[gunNo - 1].terminalSn[5];

    order_buf[22] = 0x10;

    order_buf[23] = (order_buf[3] ^ order_buf[4] ^ order_buf[5] ^ order_buf[6] ^ order_buf[7] ^ order_buf[8] ^ order_buf[9] ^ order_buf[10] ^ order_buf[11] ^ order_buf[12] ^ order_buf[13] ^ order_buf[14] ^ order_buf[15] ^ order_buf[16] ^ order_buf[17] ^ order_buf[18] ^ order_buf[19] ^ order_buf[20] ^ order_buf[21] ^ order_buf[22]);
    order_buf[24] = 0x3;

    nCount = sizeof(reply_buf);

    evs_card_exchange_data(fd, sizeof(order_buf), order_buf, &nCount, reply_buf, 3);
    if (nCount == 0)
    {
        PROTOCOL_TRACE("Get Data Failed");
        return -1;
    }

    if (((reply_buf[nCount - 4] << 8) + reply_buf[nCount - 3]) == 0x9000)
    {
        gun_auth_process_data[gunNo - 1].cardBalance[0] = reply_buf[5];
        gun_auth_process_data[gunNo - 1].cardBalance[1] = reply_buf[6];
        gun_auth_process_data[gunNo - 1].cardBalance[2] = reply_buf[7];
        gun_auth_process_data[gunNo - 1].cardBalance[3] = reply_buf[8];

        gun_auth_process_data[gunNo - 1].tradeSn[0] = reply_buf[9];
        gun_auth_process_data[gunNo - 1].tradeSn[1] = reply_buf[10];

        gun_auth_process_data[gunNo - 1].authVer = reply_buf[11];
        gun_auth_process_data[gunNo - 1].authFlag = reply_buf[12];

        gun_auth_process_data[gunNo - 1].randomC[0] = reply_buf[13];
        gun_auth_process_data[gunNo - 1].randomC[1] = reply_buf[14];
        gun_auth_process_data[gunNo - 1].randomC[2] = reply_buf[15];
        gun_auth_process_data[gunNo - 1].randomC[3] = reply_buf[16];

        gun_auth_process_data[gunNo - 1].MAC1[0] = reply_buf[17];
        gun_auth_process_data[gunNo - 1].MAC1[1] = reply_buf[18];
        gun_auth_process_data[gunNo - 1].MAC1[2] = reply_buf[19];
        gun_auth_process_data[gunNo - 1].MAC1[3] = reply_buf[20];
    }
    else
    {
        PROTOCOL_TRACE("Get Auth Info Failed");
    }

    return ((reply_buf[nCount - 4] << 8) + reply_buf[nCount - 3]);
}

/*----------------------------------------------------------------
* 妫€鏌ワ拷?锟藉崱鍣ㄧ姸锟�?
---------------------------------------------------------------*/
static int evs_card_check_reader(int fd)
{
    unsigned char order_buf[7];
    unsigned char reply_buf[128];
    int nCount = 0;

    memset(reply_buf, 0, sizeof(reply_buf));
    order_buf[0] = 0x2;
    order_buf[1] = 0x0;
    order_buf[2] = 0x2;

    order_buf[3] = 0x31;
    order_buf[4] = 0x11;

    order_buf[5] = order_buf[3] ^ order_buf[4];
    order_buf[6] = 0x3;

    nCount = sizeof(reply_buf);

    evs_card_exchange_data(fd, sizeof(order_buf), order_buf, &nCount, reply_buf, 3);
    if (nCount == 0)
    {
        PROTOCOL_TRACE("Get Data Failed");
        return -1;
    }

    if ((reply_buf[3] == 0) && (reply_buf[4] == 0))
        return EVS_OPT_READER_SUCCESS;
    else
        return EVS_CHECK_READER_FAIL;
}

/**-----------------------------------------------------------------------------------------------
* 鑾峰彇鐗╃悊鍗″彿鍙婂瘑鐮佹爣锟�?
------------------------------------------------------------------------------------------------*/
static int evs_card_get_psyInfo(int fd, int gunNo)
{
    unsigned char order_buf[13];
    unsigned char reply_buf[128];
    unsigned char Enabled = 0;
    unsigned char usr_type = 0;
    unsigned char card_type = 0;
    unsigned char pin_flage = 0;
    int i = 0;
    int nCount = 0;

    memset(order_buf, 0, sizeof(order_buf));
    memset(reply_buf, 0, sizeof(reply_buf));

    order_buf[0] = 0x2;
    order_buf[1] = 0x0;
    order_buf[2] = 0x8;
    order_buf[3] = 0x32;
    order_buf[4] = 0x26;
    order_buf[5] = 0xff;
    order_buf[6] = 0x0;
    order_buf[7] = 0xB0;
    order_buf[8] = 0x85;
    order_buf[9] = 0x00;
    order_buf[10] = 0x15;

    order_buf[11] = (order_buf[3] ^ order_buf[4] ^ order_buf[5] ^ order_buf[6] ^ order_buf[7] ^ order_buf[8] ^ order_buf[9] ^ order_buf[10]);
    order_buf[12] = 0x3;

    nCount = sizeof(reply_buf);

    evs_card_exchange_data(fd, sizeof(order_buf), order_buf, &nCount, reply_buf, 3);
    if (nCount == 0)
    {
        PROTOCOL_TRACE("Get Data Failed");
        return -1;
    }

    if (((reply_buf[nCount - 4] << 8) + reply_buf[nCount - 3]) == 0x9000)
    {
        Enabled = reply_buf[5]; // 锟�?鍚﹀惎鐢ㄥ崱锟�?

        for (i = 0; i < 8; i++)
        {
            gun_auth_process_data[gunNo - 1].psy_id[i] = reply_buf[6 + i]; // 鐗╃悊鍗″彿
        }

        usr_type = reply_buf[14];  // 鐢ㄦ埛绫诲瀷
        card_type = reply_buf[15]; // 鍗＄被锟�?
        pin_flage = reply_buf[16]; // 瀵嗙爜鏍囪瘑
    }
    else
    {
        PROTOCOL_TRACE("Get Psy Info Failed");
    }

    return ((reply_buf[nCount - 4] << 8) + reply_buf[nCount - 3]);
}

int evs_card_ctrl_init(int fd)
{
    int err = 0;
    err = evs_card_set_baudRate(fd, 3);
    if (err != 0)
    {
        PROTOCOL_TRACE("Set Baud Ratio Failed!");
        return EVS_SET_READER_BAUD_FAIL;
    }

    HAL_SleepMs(100);

    err = evs_card_check_reader(fd);
    if (err != 0)
    {
        PROTOCOL_TRACE("Check Reader Failed!");
        return EVS_CHECK_READER_FAIL;
    }

    HAL_SleepMs(100);

    return err;
}

/*------------------------------------------------------------------------------------------------
* 璇诲崱鍣ㄦ搷锟�?
------------------------------------------------------------------------------------------------*/
static int evs_ctrl_reader(evs_cmd_card_enum ctrl_cmd, int fd, int gunNo)
{
    int ret = 0;
    switch (ctrl_cmd)
    {
    case EVS_CMD_READER_INIT:
        ret = evs_card_ctrl_init(fd);
        break;
    case EVS_CMD_READER_CHECK:
        ret = evs_card_check_reader(fd);
        break;
    case EVS_CMD_OPEN_RF:
        ret = evs_card_ctrl_rf_open(fd);
        break;
    case EVS_CMD_FOUND_CARD:
        ret = evs_card_ctrl_found(fd, gunNo);
        break;
    case EVS_CMD_CHECK_PIN:
        ret = evs_card_check_pin(fd);
        break;
    case EVS_CMD_GET_KEY_VER:
        ret = evs_card_get_keyInfo(fd, gunNo);
        break;
    case EVS_CMD_GET_USER_ID:
        ret = evs_card_get_cardSn(fd);
        break;
    case EVS_CMD_GET_PSY_ID:
        ret = evs_card_get_psyInfo(fd, gunNo);
        break;
    case EVS_CMD_GET_CARD_AUTH:
        ret = evs_card_get_authCode(fd, gunNo);
        break;
    case EVS_CMD_CONFIRM_AUTHCODE_S:
        ret = evs_card_trade_confirm(fd, gunNo);
        break;
    case EVS_CMD_CLOSE_RF:
        ret = evs_card_ctrl_rf_close(fd);
        break;
    default:
        break;
    }

    return ret;
}

static int evs_card_info_get(int fd, int gunNo)
{
    static int loop = 0;
    int err = 0;

    switch (loop)
    {
    case 0:
        err = evs_ctrl_reader(EVS_CMD_OPEN_RF, fd, gunNo);
        if (err != 0)
        {
            err = EVS_CARD_ERROR_OPEN_RF;
            break;
        }
        HAL_SleepMs(100);
        loop++;
    case 1:
        err = evs_ctrl_reader(EVS_CMD_FOUND_CARD, fd, gunNo);
        if (err != 0)
        {
            err = EVS_CARD_ERROR_FOUND_CARD;
            loop = 0;
            break;
        }
        HAL_SleepMs(100);
        loop++;
    case 2:
        err = evs_ctrl_reader(EVS_CMD_GET_USER_ID, fd, gunNo);
        if (err != 0x9000)
        {
            err = EVS_CARD_ERROR_GET_USER_ID;
            loop = 0;
            break;
        }
        HAL_SleepMs(100);
        loop++;
    case 3:
        err = evs_ctrl_reader(EVS_CMD_GET_PSY_ID, fd, gunNo);
        if (err != 0x9000)
        {
            err = EVS_CARD_ERROR_GET_PSY_ID;
            loop = 0;
            break;
        }
        HAL_SleepMs(100);
        loop++;
    case 4:
        err = evs_ctrl_reader(EVS_CMD_CHECK_PIN, fd, gunNo);
        if (err != 0x9000)
        {
            err = EVS_CARD_ERROR_CHECK_PIN;
            loop = 0;
            break;
        }
        HAL_SleepMs(100);
        loop++;
    case 5:
        err = evs_ctrl_reader(EVS_CMD_GET_KEY_VER, fd, gunNo);
        if (err != 0x9000)
            err = EVS_CARD_ERROR_GET_KEY_VER;
        loop = 0;
        break;
    default:
        break;
    }

    return err;
}

int evs_card_handle(int fd, evs_smart_gun_auth_param *param)
{
    static unsigned char step = 0;
    static unsigned int authTime;
    static unsigned char sendCnt = 0;
    int authResult = 0;
	int ret = 0;

    if (param->gunNo < 1 || param->gunNo > EVS_MAX_PORT_NUM)
    {
        authResult = EVS_HANDLE_GUN_NUM_WRONG;
        HAL_Printf("param->gunNo is over range: %d", param->gunNo);
        return authResult;
    }

    evs_event_card_info card_info = {0};
    card_info.gunNo = param->gunNo;
    card_info.startMode = param->startMode;

    evs_event_card_auth card_auth = {0};
    card_auth.gunNo = param->gunNo;
    evs_event_card_auth_result card_auth_result = {0};
    card_auth_result.gunNo = param->gunNo;
    memcpy(card_auth_result.tradeNo, param->tradeNo, EVS_MAX_TRADE_LEN);

    evs_event_card_check_error card_error = {0};
    card_error.gunNo = param->gunNo;

    switch (step)
    {
    case 0:
        authResult = EVS_HANDLE_AUTHING;
        sendCnt = 0;
        memset(&gun_auth_process_data[param->gunNo - 1], 0, sizeof(evs_smart_gun_auth_process_data));
        gun_auth_process_data[param->gunNo - 1].gunNo = param->gunNo;

        ret = evs_card_info_get(fd, param->gunNo);
        if (ret != 0x9000)
        {

            card_error.faultValue = ret;
            authResult = EVS_HANDLE_CARD_FAILED;
            evs_send_event(EVS_CMD_EVENT_CARD_CHECK_ERROR, &card_error);
            break;
        }
        else
        {
            step++;
            authTime = HAL_UptimeMs();
            evs_send_event(EVS_CMD_EVENT_CARD_INFO, &card_info);
        }

    case 1:
        if (gun_auth_process_data[param->gunNo - 1].getTerminalFlag == 1)
        {
            gun_auth_process_data[param->gunNo - 1].getTerminalFlag = 0;
            step++;
            sendCnt = 0;
        }
        else
        {
            if ((HAL_UptimeMs() - authTime) > 10 * 1000)
            {
                if (sendCnt < 2)
                {
                    evs_send_event(EVS_CMD_EVENT_CARD_INFO, &card_info);
                    sendCnt++;
                    authTime = HAL_UptimeMs();
                }
                else
                {
                    card_error.faultValue = EVS_CARD_ERROR_TERMINAL_TIMEOUT; // get terminal number failed
                    authResult = EVS_HANDLE_TERMINAL_TIMEOUT;
                    evs_send_event(EVS_CMD_EVENT_CARD_CHECK_ERROR, &card_error);
                }
            }
            break;
        }

    case 2:
        if (evs_ctrl_reader(EVS_CMD_GET_CARD_AUTH, fd, param->gunNo) != 0x9000)
        {
            card_error.faultValue = EVS_CARD_ERROR_GET_MAC1; // get mac1 failed
            authResult = EVS_HANDLE_GET_MAC1;
            evs_send_event(EVS_CMD_EVENT_CARD_CHECK_ERROR, &card_error);
            break;
        }
        else
        {
            step++;
            authTime = HAL_UptimeMs();
            evs_send_event(EVS_CMD_EVENT_CARD_AUTH, &card_auth);
        }

    case 3:
        if (gun_auth_process_data[param->gunNo - 1].getServerAuthFlag == 1)
        {
            gun_auth_process_data[param->gunNo - 1].getServerAuthFlag = 0;
            step++;
            sendCnt = 0;
        }
        else
        {
            if ((HAL_UptimeMs() - authTime) > 10 * 1000)
            {
                if (sendCnt < 2)
                {
                    evs_send_event(EVS_CMD_EVENT_CARD_AUTH, &card_auth);
                    sendCnt++;
                    authTime = HAL_UptimeMs();
                }
                else
                {
                    card_error.faultValue = EVS_CARD_ERROR_CHECK_MAC1_TIMEOUT; // confirm card's mac1 or genarate mac2 failed!
                    authResult = EVS_HANDLE_AUTHCODE_TIMEOUT;
                    evs_send_event(EVS_CMD_EVENT_CARD_CHECK_ERROR, &card_error);
                }
            }
            break;
        }
    case 4:
        if (evs_ctrl_reader(EVS_CMD_CONFIRM_AUTHCODE_S, fd, param->gunNo) != 0x9000)
        {
            card_error.faultValue = EVS_CARD_ERROR_CHECK_MAC2; // check mac2 failed
            authResult = EVS_HANDLE_CHECK_MAC2;
            evs_send_event(EVS_CMD_EVENT_CARD_CHECK_ERROR, &card_error);
            break;
        }
        else
        {
            step++;
            authTime = HAL_UptimeMs();
            evs_ctrl_reader(EVS_CMD_CLOSE_RF, fd, param->gunNo);
            evs_send_event(EVS_CMD_EVENT_CARD_AUTH_RESULT, &card_auth_result);
        }

    case 5:
        if (gun_auth_process_data[param->gunNo - 1].getAuthChargeFlag == 1)
        {
            gun_auth_process_data[param->gunNo - 1].getAuthChargeFlag = 0;
            authResult = EVS_HANDLE_AUTH_SUCCESS;
        }
        else
        {
            if ((HAL_UptimeMs() - authTime) > 10 * 1000)
            {
                if (sendCnt < 2)
                {
                    evs_send_event(EVS_CMD_EVENT_CARD_AUTH_RESULT, &card_auth_result);
                    sendCnt++;
                    authTime = HAL_UptimeMs();
                }
                else
                {
                    card_error.faultValue = EVS_CARD_ERROR_AUTH_TIMEOUT; // authentication result timeout
                    authResult = EVS_HANDLE_AUTH_RESULT_TIMEOUT;
                    evs_send_event(EVS_CMD_EVENT_CARD_CHECK_ERROR, &card_error);
                }
            }
            break;
        }
    default:
        break;
    }

    if (!param->gunIsReady && authResult == 0) // 宸叉嫈锟�?涓旈壌鏉冩湭瀹屾垚
    {
        card_error.faultValue = EVS_CARD_ERROR_GUN_PULL_OUT; // 閴存潈杩囩▼锟�?鐢ㄦ埛鎷旀灙
        authResult = EVS_HANDLE_GUN_PULL_OUT;
        evs_send_event(EVS_CMD_EVENT_CARD_CHECK_ERROR, &card_error);
    }
    if (authResult != 0)
    {
        step = 0;
        evs_ctrl_reader(EVS_CMD_CLOSE_RF, fd, param->gunNo); // 鍏冲皠锟�?
    }

    return authResult;
}