#include "DLC-AEZT030W.h"

#include "agent_hyt.h"
#include "includes.h"
#include "gd32f4xx.h"
#include "enet_to_udp.h"
#include "ptz_struct.h"
#include "Usart.h"
#include "device_dac_out.h"
#include "ptz_header_file.h"
#include "device_wdog.h"
#include "service_autoreturn.h"
#include "device_heatresistor.h"
#include "full_bridge.h"
#include "cJSON.h"

#include "mb85rc64.h"

/* tcp自动回传 */
//云台自动回传
typedef struct _PtzTcpAutoReturn_ {
    char swtich;                //自动回传开关
    unsigned short int time;    //自动回传间隔时间  
    unsigned int timer;         //自动回传间隔计时器
}PtzTcpAutoReturn;

PtzTcpAutoReturn m_tcp_auto_return = {
    .swtich = PTZ_AUTO_RETURN_OFF,
    .time   = 1000,
    .timer  = 0,
};

/* 解析情况 */
enum {
    wait = 0,
    packHead,
    packDataLen,
    deviceType,
    dataType,
    messageContent,
    success
};

/* 消息类型 */
enum {
    switchType      = 0x00,
    parameterType   = 0x0A,
};

/* 设备类型 */
enum {
    all         = 0x0A,
    rotattable  = 0x0D,
};

/* 工作状态 */
enum {
    standby = 0,
    startWork = 1,
    restart = 2,
};

/* 工作状态 */
static uint8_t workStatus = standby;
// static uint8_t workStatus = startWork;

static uint8_t infoType = switchType;

static BSP_OS_SEM tcp_send_data_mutex;
static BSP_OS_SEM tcp_data_mutex;

static int tcp_sock_fd;
// static volatile int tcp_accept_fd;
int ptz_tcp_communicaton = PTZ_CONNECT_STATE_DEAD;

struct sockaddr_in tcp_from;        //IP和端口
struct sockaddr_in tcp_local;       //本地IP和端口

cJSON *replyRoot;
// cJSON *replySwitch;
cJSON *SystemInfo;
cJSON *commondInfo;
cJSON *equipmentBase;
// cJSON *equipmentBase2;

//连接的服务器的端口号和ip地址
#define TCP_PORT 8020
#define TCP_IP "20.20.20.20"
//tcp的客户端使用端口号
#define TCP_CLIENT_PORT 6667

static unsigned char pack_head[4] = {0xAA, 0xBB, 0xCC, 0xDD};
static unsigned char pack_tail[4] = {0xCC, 0xDD, 0xEE, 0xFF};
static char tcp_send_buff[1500];
static char tcp_rece_buff[1500] = {0x00};
static int tcp_recvData_len = 0;

/*  */
static uint16_t Equipment_ID;
static uint8_t nodeNo;

#define TASK_PTZ_TCP_SERVER_PRIO                    51u                 //云台通过tcp接收指令分析，如果为38，会干扰转动
#define TASK_PTZ_TCP_SERVER_STK_SIZE                2000u
static OS_STK task_ptz_tcp_server_stk[TASK_PTZ_TCP_SERVER_STK_SIZE];

#define TASK_PTZ_TCP_AUTORETURN_PRIO                    50u
#define TASK_PTZ_TCP_AUTORETURN_STK_SIZE                800u
static OS_STK task_ptz_tcp_autoreturn_stk[TASK_PTZ_TCP_AUTORETURN_STK_SIZE];


void ptz_tcp_returnDataTask(void);
void send_tcp_data(char *data, int len);


// static int workState = standby;

static void sendJsonInit(void);

/**
  * @brief  设置云台的Equipment_ID
  * @param
  * @retval 
  */
void setEquipmentID(uint16_t address)
{
    if (address = 1) {
        Equipment_ID = 1011;
        nodeNo = 1;
    }
    else if (address = 2) {
        Equipment_ID = 1012;
        nodeNo = 2;
    }
    else if (address = 3) {
        Equipment_ID = 1013;
        nodeNo = 3;
    }
    else if (address = 4) {
        Equipment_ID = 1014;
        nodeNo = 4;
    }
    else if (address = 5) {
        Equipment_ID = 1015;
        nodeNo = 5;
    }
    else if (address = 6) {
        Equipment_ID = 1016;
        nodeNo = 6;
    }
    else if (address = 7) {
        Equipment_ID = 1017;
        nodeNo = 7;
    }
    else if (address = 8) {
        Equipment_ID = 1018;
        nodeNo = 8;
    }
    else if (address = 9) {
        Equipment_ID = 1019;
        nodeNo = 9;
    }
    else {
        Equipment_ID = 1011;
        nodeNo = 1;
    }
}

/**
  * @brief  crc32校验,除去CRC外报文所有内容的byte值相加
  * @param
  * @retval 1 验证成功
  *         0 验证失败
  */
uint8_t checkCrc32(char *data, uint count)
{
    uint crc = 0x00000000;
    uint8_t dataCrc[4];
    for (size_t i = 0; i < count; i++) {
        crc += data[i];
    }

    // pdebug(DEBUG_LEVEL_DEBUG, "crc32 %d\n", crc);

#if 1
    crc -= data[count - 5];
    crc -= data[count - 6];
    crc -= data[count - 7];
    crc -= data[count - 8];
#endif

    for (size_t i = 0; i < 4; i++) {
        dataCrc[i] = (crc >> (8 * i)) & 0xFF;
    }

    // if (dataCrc[0] == data[count + 3]
    //     && dataCrc[1] == data[count + 2]
    //     && dataCrc[2] == data[count + 1]
    //     && dataCrc[3] == data[count + 0]) {
    //     return 1;
    // }

    if (dataCrc[0] == data[count - 5]
        && dataCrc[1] == data[count - 6]
        && dataCrc[2] == data[count - 7]
        && dataCrc[3] == data[count - 8]) {
        return 1;
    }

    // pdebug(DEBUG_LEVEL_DEBUG, "dataCrc %x %x %x %x\n", dataCrc[0], dataCrc[1], dataCrc[2], dataCrc[3]);
    // pdebug(DEBUG_LEVEL_DEBUG, "data %x %x %x %x\n", data[count - 5], data[count - 6], data[count - 7], data[count - 8]);
    // pdebug(DEBUG_LEVEL_DEBUG, "dataUint %d\n", crc);

    return 0;
}

uint8_t *checkCrc32_1(char *data, uint count)
{
    uint crc = 0x00000000;
    uint8_t dataCrc[4];
    for (size_t i = 0; i < count; i++) {
        crc += data[i];
    }

    // pdebug(DEBUG_LEVEL_DEBUG, "crc32 %d\n", crc);

#if 1
    crc -= data[count - 5];
    crc -= data[count - 6];
    crc -= data[count - 7];
    crc -= data[count - 8];
#endif

    for (size_t i = 0; i < 4; i++) {
        dataCrc[i] = (crc >> (8 * i)) & 0xFF;
    }
    
    return dataCrc;
}

/**
  * @brief  解析json数据包
  * @param
  * @retval
  */
void ptz_tcp_json_process()
{
    memcpy(tcp_rece_buff, &tcp_rece_buff[10], sizeof(tcp_rece_buff));

    cJSON *jsonObj = cJSON_Parse(tcp_rece_buff);
    if (jsonObj == NULL) {
        pdebug(DEBUG_LEVEL_DEBUG, "Error parsing JSON\n");
        return;
    }

    BSP_OS_SemWait(&tcp_data_mutex, 0u);

    cJSON* item = cJSON_GetObjectItem(commondInfo, "ctrlID");
    item->valuestring = cJSON_GetObjectItem(jsonObj, "ctrlID")->valuestring;
    // pdebug(DEBUG_LEVEL_DEBUG, "down ctrlID %s\n", item->valuestring);
    // pdebug(DEBUG_LEVEL_DEBUG, "up ctrlID %s\n", cJSON_GetObjectItem(jsonObj, "ctrlID")->valuestring);

//     item = cJSON_GetObjectItem(commondInfo, "ctrlLog");
//     item->valuestring = "";


    uint16_t tempU16;
    tempU16 = cJSON_GetObjectItem(jsonObj, "equipmentType")->valueint;
    if (tempU16 != all
        && tempU16 != rotattable) {
        item = cJSON_GetObjectItem(commondInfo, "ctrlState");
        // item->valueint = 0;    
        cJSON_SetNumberValue(item, 0);
        goto err;
    }

    tempU16 = cJSON_GetObjectItem(jsonObj, "equipmentID")->valueint;
    if (tempU16 != Equipment_ID) {
        item = cJSON_GetObjectItem(commondInfo, "ctrlState");
        // item->valueint = 0;
        cJSON_SetNumberValue(item, 0);
        goto err;
    }

    item = cJSON_GetObjectItemCaseSensitive(jsonObj, "workState");
    if (item) {
        int workState = cJSON_GetObjectItem(jsonObj, "workState")->valueint;
        if (workState == restart) {
            // pdebug(DEBUG_LEVEL_DEBUG, "restart\n");
            workStatus = restart;
        }
        else if (workState == startWork) {
            // pdebug(DEBUG_LEVEL_DEBUG, "startWork\n");
            workStatus = startWork;
        }
        else if (workState == standby) {
            // pdebug(DEBUG_LEVEL_DEBUG, "standby\n");
            workStatus = standby;
        }
        else {
            item = cJSON_GetObjectItem(commondInfo, "ctrlState");
            cJSON_SetNumberValue(item, 0);
            // item->valueint = 0;
            goto err;
        }

        item = cJSON_GetObjectItem(commondInfo, "ctrlState");
        // item->valueint = 1;
        cJSON_SetNumberValue(item, 1);
    }

    else {
        if (workStatus != startWork) {
            item = cJSON_GetObjectItem(commondInfo, "ctrlState");            
            // item->valueint = 0;
            cJSON_SetNumberValue(item, 0);
            // pdebug(DEBUG_LEVEL_DEBUG, "ctrlState : %d\n",  cJSON_GetObjectItem(commondInfo, "ctrlState")->valueint);
            goto err;
        }
        
        float tempFloat = cJSON_GetObjectItem(jsonObj, "curHorSpeed")->valuedouble;
        g_ptz.hori_speed_control = tempFloat;
        tempFloat = cJSON_GetObjectItem(jsonObj, "curHorAngle")->valuedouble;        
        g_ptz.hori_angle_control = tempFloat;
        // pdebug(DEBUG_LEVEL_DEBUG, "hori speed:%f, angle:%f \n", g_ptz.hori_speed_control, g_ptz.hori_angle_actual);
        ptz_hori_rotate_plan(PTZ_VERT_ANGLE);
        g_ptz.hori_rotate_monitor_switch = PTZ_VERT_ANGLE;  
        
        tempFloat = cJSON_GetObjectItem(jsonObj, "curVerSpeed")->valuedouble;
        // g_ptz.vert_speed_control = tempFloat / 60.0f;
        g_ptz.vert_speed_control = tempFloat;
        tempFloat = cJSON_GetObjectItem(jsonObj, "curVerAngle")->valuedouble;
        g_ptz.vert_angle_control = tempFloat;
        // pdebug(DEBUG_LEVEL_DEBUG, "vert speed:%f, angle:%f \n", g_ptz.vert_speed_control, g_ptz.vert_angle_control);
        ptz_vert_rotate_plan(PTZ_VERT_ANGLE);
        g_ptz.vert_rotate_monitor_switch = PTZ_VERT_ANGLE;
        
        item = cJSON_GetObjectItem(commondInfo, "ctrlState");
        // item->valueint = 1;
        cJSON_SetNumberValue(item, 1);
    }

err:
    item = cJSON_GetObjectItem(equipmentBase, "spoofState");
    if (workStatus == restart) {
        item->valuestring = "初始化";
    }
    else if (workStatus == startWork) {
        item->valuestring = "工作中";
    }
    else if (workStatus == standby) {
        item->valuestring = "待机";
    }

    // pdebug(DEBUG_LEVEL_DEBUG, "ctrlState : %d\n",  cJSON_GetObjectItem(commondInfo, "ctrlState")->valueint);
    // item = cJSON_GetObjectItem(replySwitch, "commondInfo");
    // pdebug(DEBUG_LEVEL_DEBUG, "ctrlState : %d\n",  cJSON_GetObjectItem(item, "ctrlState")->valueint);
    char *json = cJSON_PrintUnformatted(replyRoot);
    // char *json = cJSON_PrintUnformatted(replyRoot);
    // char *json = cJSON_PrintUnformatted(commondInfo);
    // pdebug(DEBUG_LEVEL_DEBUG,"%s,%d\r\n", json, strlen(json));

    // sprintf(tcp_send_buff, "%s%s%s", pack_head, json, pack_tail);
    //包头
    int len = 0;
    // memcpy(tcp_send_buff + len, pack_head, 4);
    tcp_send_buff[0] = pack_head[0];
    tcp_send_buff[1] = pack_head[1];
    tcp_send_buff[2] = pack_head[2];
    tcp_send_buff[3] = pack_head[3];

    //信息长度
    len += 4;
    int datalen = strlen(json) + 18;
    tcp_send_buff[len] = (datalen >> 24) & 0xff;
    tcp_send_buff[len + 1] = (datalen >> 16) & 0xff;
    tcp_send_buff[len + 2] = (datalen >> 8) & 0xff;
    tcp_send_buff[len + 3] = (datalen >> 0) & 0xff;
    
    //设备类型
    len += 4;
    tcp_send_buff[len] = rotattable;
    
    //设备类型
    len += 1;
    tcp_send_buff[len] = infoType;

    //报文内容
    len += 1;
    memcpy(tcp_send_buff + len, json, strlen(json));

    //报文尾
    len += strlen(json);
    len += 4;
    // memcpy(tcp_send_buff + len, pack_tail, 4);
    tcp_send_buff[len + 0] = pack_tail[0];
    tcp_send_buff[len + 1] = pack_tail[1];
    tcp_send_buff[len + 2] = pack_tail[2];
    tcp_send_buff[len + 3] = pack_tail[3];

    //crc校验
    // len -= 4;
    uint8_t *crcData;
    crcData = checkCrc32_1(tcp_send_buff, len + 4);
    // memcpy(tcp_send_buff + len, crcData, 4);
    // tcp_send_buff[len + 0] = crcData[3];
    // tcp_send_buff[len + 1] = crcData[2];
    // tcp_send_buff[len + 2] = crcData[1];
    // tcp_send_buff[len + 3] = crcData[0];
        
    tcp_send_buff[len - 4] = crcData[3];
    tcp_send_buff[len - 3] = crcData[2];
    tcp_send_buff[len - 2] = crcData[1];
    tcp_send_buff[len - 1] = crcData[0];

    // len += 4;
    // tcp_send_buff[len] = '\r';
    len += 4;
    tcp_send_buff[len] = '\n';

    send_tcp_data(tcp_send_buff, len + 1);
    // tcp_send_buff[len] = '\n';

    // send_tcp_data(tcp_send_buff, len + 2);
    // pdebug(DEBUG_LEVEL_DEBUG,"%s\r\n", tcp_send_buff);
    
    cJSON_free(json);
    cJSON_Delete(jsonObj);

    BSP_OS_SemPost(&tcp_data_mutex);

    if (workStatus == restart) {
        OSTimeDlyHMSM(0u, 0u, 1u, 200u);
        NVIC_SystemReset();
        while(1);
    }
}

/**
  * @brief  通过该函数完成数据包解析
  * @param
  * @retval
  */
void ptz_tcp_data_pack_process(void)
{
    static uint8_t flag = wait;
    static int frameLength = 0;
    if (flag == wait) {
        if (tcp_recvData_len < 4) {
            return;
        }
        if (tcp_rece_buff[0] == pack_head[0]
            && tcp_rece_buff[1] == pack_head[1]
            && tcp_rece_buff[2] == pack_head[2]
            && tcp_rece_buff[3] == pack_head[3]) {
            flag = packHead;
        }
        else {
            tcp_recvData_len = 0;
            return;
        }
    }
    
    if (flag == packHead) {        
        if (tcp_recvData_len < 8) {
            return;
        }
        frameLength = (tcp_rece_buff[4] << 24) | (tcp_rece_buff[5] << 16)
                     | (tcp_rece_buff[6] << 8) | tcp_rece_buff[7];
        flag = packDataLen;
    }

    if (flag == packDataLen) {
        if (tcp_recvData_len < 9) {
            flag = wait;
            return;
        }
        if (tcp_rece_buff[8] == all
            || tcp_rece_buff[8] == rotattable) {
            flag = deviceType;
        }
        else {
            pdebug(DEBUG_LEVEL_INFO, "deviceType error 0x%x\n", tcp_rece_buff[8]);
            flag = wait;
            tcp_recvData_len = 0;
            return;
        }
    }

    if (flag == deviceType) {
        if (tcp_recvData_len < 10) {
            flag = wait;
            return;
        }

        if (tcp_rece_buff[9] == parameterType
            || tcp_rece_buff[9] == switchType) {
            infoType = tcp_rece_buff[9];
            flag = dataType;            
        }
        else {
            pdebug(DEBUG_LEVEL_INFO, "dataType error 0x%x\n", tcp_rece_buff[9]);
            flag = wait;
            tcp_recvData_len = 0;
            return;
        }        
    }
    

    if (flag == dataType) {
        if (tcp_recvData_len < frameLength - 8) {
            flag = wait;
            return;
        }
        flag = messageContent;
    }

    if (flag == messageContent) {
        if (tcp_recvData_len < frameLength) {
            flag = wait;
            return;
        }

        if (tcp_rece_buff[frameLength - 4] != pack_tail[0]
            || tcp_rece_buff[frameLength - 3] != pack_tail[1]
            || tcp_rece_buff[frameLength - 2] != pack_tail[2]
            || tcp_rece_buff[frameLength - 1] != pack_tail[3]) {
            flag = wait;
            tcp_recvData_len = 0;
            return;
        }

        if (!checkCrc32(tcp_rece_buff, frameLength)) {
            tcp_recvData_len = 0;
            flag = wait;
            return;
        }
        flag = success;
    }

    if (flag == success) {
        // tcp_recvData_len -= frameLength;
        ptz_tcp_json_process();
        
    }

    flag = wait;
}


void task_ptz_tcp_client(void)
{
    int ret_len;
    while (1) {
        if (ptz_tcp_communicaton == PTZ_CONNECT_STATE_DEAD) {
            tcp_sock_fd = socket(AF_INET, SOCK_STREAM, 0);
            if (tcp_sock_fd == -1) {
                OSTimeDlyHMSM(0u, 0u, 0u, 50u);
                continue;
            }

            // // 设置为非阻塞
            // int flags = fcntl(tcp_sock_fd, F_GETFL, 0);
            // fcntl(tcp_sock_fd, F_SETFL, flags | O_NONBLOCK);

            // struct sockaddr_in client_addr;
            // memset(&client_addr, 0, sizeof(struct sockaddr_in));
            // client_addr.sin_family = AF_INET;
            // client_addr.sin_port = htons(TCP_CLIENT_PORT); // 指定端口号
            // client_addr.sin_addr.s_addr = htonl(INADDR_ANY);
            // if (bind(tcp_sock_fd, (struct sockaddr *)&client_addr, sizeof(client_addr)) == -1) {
            //     OSTimeDlyHMSM(0u, 0u, 0u, 50u);
            //     close(tcp_sock_fd);
            //     continue;
            // }

            struct sockaddr_in saddr;
            memset(&saddr, 0, sizeof(struct sockaddr_in));
            saddr.sin_family = AF_INET;
            saddr.sin_port = htons(TCP_PORT);
            saddr.sin_addr.s_addr = inet_addr(TCP_IP);
            if (connect(tcp_sock_fd, (struct sockaddr*)&saddr, sizeof(saddr)) == -1) {
                OSTimeDlyHMSM(0u, 0u, 0u, 50u);
                close(tcp_sock_fd);
                continue;
            }

            m_tcp_auto_return.swtich = PTZ_AUTO_RETURN_ON;
            ptz_tcp_communicaton = PTZ_CONNECT_STATE_SUCCESS;

            // pdebug(DEBUG_LEVEL_DEBUG, "tcp connect success \n");
        }
        else if (ptz_tcp_communicaton == PTZ_CONNECT_STATE_SUCCESS) {
		    // // memset(tcp_rece_buff, 0x00, sizeof(tcp_rece_buff));//'\0'
			ret_len = recv(tcp_sock_fd, tcp_rece_buff, sizeof(tcp_rece_buff), 0);
            if (ret_len <= 0) {
                close(tcp_sock_fd);
                m_tcp_auto_return.swtich = PTZ_AUTO_RETURN_OFF;
                ptz_tcp_communicaton = PTZ_CONNECT_STATE_DEAD;
            }
            if (ret_len > 0) {
                tcp_recvData_len = ret_len;
                ptz_tcp_data_pack_process();
//                send_tcp_data(tcp_rece_buff, ret_len);
                ret_len = 0;
            }
        }
        
        OSTimeDlyHMSM(0u, 0u, 0u, 50u);
    }
}

/**
  * @brief  通过该函数完成tcp数据发送
  * @param
  * @retval
  */
void send_tcp_data(char *data, int len)
{
    BSP_OS_SemWait(&tcp_send_data_mutex, 0u);
    if(ptz_tcp_communicaton == PTZ_CONNECT_STATE_SUCCESS){
        int ret = send(tcp_sock_fd, data, len, 0);
        if (ret == -1) {
            ptz_tcp_communicaton = PTZ_CONNECT_STATE_FAILED;
            close(tcp_sock_fd);
        }
    }
    BSP_OS_SemPost(&tcp_send_data_mutex);
}

static void task_ptz_tcp_server()
{
#if 0
    ptz_tcp_communicaton == PTZ_CONNECT_STATE_DEAD;

    /* 初始化套接字 */
    while (1) {
        // ptz_sock_fd = CreateTCPClientSock();	
        tcp_sock_fd = socket(AF_INET, SOCK_STREAM, 0);
        if (tcp_sock_fd == -1) {
            // ptz_communicaton = PTZ_CONNECT_STATE_FAILED;
            // close(tcp_sock_fd);
            OSTimeDlyHMSM(0u, 0u, 0u, 50u);
            continue;
        }

        // // 设置为非阻塞
        // int flags = fcntl(tcp_sock_fd, F_GETFL, 0);
        // fcntl(tcp_sock_fd, F_SETFL, flags | O_NONBLOCK);

        // 设置服务器端ip和端口号
        memset(&tcp_local, 0, sizeof(struct sockaddr_in));
        tcp_local.sin_family = AF_INET;
        tcp_local.sin_port = htons(TCP_PORT);
        tcp_local.sin_addr.s_addr = INADDR_ANY;

        // 绑定本地信息
        if (-1 == bind(tcp_sock_fd, (struct sockaddr*)&tcp_local, sizeof(struct sockaddr_in))) {
            close(tcp_sock_fd);
            OSTimeDlyHMSM(0u, 0u, 0u, 50u);
            continue;
        }

        // 监听端口
        if (-1 == listen(tcp_sock_fd, 1)) {
            close(tcp_sock_fd);
            OSTimeDlyHMSM(0u, 0u, 0u, 50u);
            continue;
        }
        
        break;
    }

    while(1) {
        if (ptz_tcp_communicaton == PTZ_CONNECT_STATE_DEAD) {
            pdebug(DEBUG_LEVEL_INFO,"accept start\r\n");
            size_t client_len = sizeof(tcp_from);
            tcp_accept_fd = accept(tcp_sock_fd, (struct sockaddr*)&tcp_from, &client_len);

            if (tcp_accept_fd == -1) {
                pdebug(DEBUG_LEVEL_ERROR,"accept error\r\n");
                continue;
            }
            pdebug(DEBUG_LEVEL_INFO,"accept success\r\n");

            ptz_tcp_communicaton = PTZ_CONNECT_STATE_SUCCESS;
            m_tcp_auto_return.swtich = PTZ_AUTO_RETURN_ON;

        }
        else {
		    memset(tcp_rece_buff, 0x00, sizeof(tcp_rece_buff));//'\0'
			int ret_len = read(tcp_accept_fd, tcp_rece_buff, sizeof(tcp_rece_buff));


        }
        OSTimeDlyHMSM(0u, 0u, 0u, 10u);
    }
#endif
}

void tcpInit(void)
{
    setEquipmentID(g_ptz.address);
    sendJsonInit();

    BSP_OS_SemCreate(&tcp_send_data_mutex, 1u, "tcp_send_data_mutex");
    BSP_OS_SemCreate(&tcp_data_mutex, 1u, "tcp_data_mutex");
    
    CPU_INT08U  task_err;
    CPU_INT08U  name_err;

    task_err = OSTaskCreateExt((void (*)(void *)) task_ptz_tcp_client,
            (void           *) 0,
            (OS_STK         *)&task_ptz_tcp_server_stk[TASK_PTZ_TCP_SERVER_STK_SIZE - 1],
            (INT8U           ) TASK_PTZ_TCP_SERVER_PRIO,
            (INT16U          ) TASK_PTZ_TCP_SERVER_PRIO,
            (OS_STK         *)&task_ptz_tcp_server_stk[0],
            (INT32U          ) TASK_PTZ_TCP_SERVER_STK_SIZE,
            (void           *) 0,
            (INT16U          )(OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR));
#if (OS_TASK_NAME_EN > 0)
    OSTaskNameSet(TASK_PTZ_TCP_SERVER_PRIO, "task_ptz_tcp_server", &name_err);
#endif

    if ((task_err == OS_ERR_NONE) && (name_err == OS_ERR_NONE)) {
        pdebug(DEBUG_LEVEL_INFO,"create task_ptz_tcp_server success\r\n");
    } else {
        pdebug(DEBUG_LEVEL_FATAL,"create task_ptz_tcp_server failed\r\n");
    }

    task_err = OSTaskCreateExt((void (*)(void *)) ptz_tcp_returnDataTask,
            (void           *) 0,
            (OS_STK         *)&task_ptz_tcp_autoreturn_stk[TASK_PTZ_TCP_AUTORETURN_STK_SIZE - 1],
            (INT8U           ) TASK_PTZ_TCP_AUTORETURN_PRIO,
            (INT16U          ) TASK_PTZ_TCP_AUTORETURN_PRIO,
            (OS_STK         *)&task_ptz_tcp_autoreturn_stk[0],
            (INT32U          ) TASK_PTZ_TCP_AUTORETURN_STK_SIZE,
            (void           *) 0,
            (INT16U          )(OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR));
#if (OS_TASK_NAME_EN > 0)
    OSTaskNameSet(TASK_PTZ_TCP_AUTORETURN_PRIO, "task_ptz_tcp_autoReturn", &name_err);
#endif

    if ((task_err == OS_ERR_NONE) && (name_err == OS_ERR_NONE)) {
        pdebug(DEBUG_LEVEL_INFO,"create task_ptz_tcp_autoReturn success\r\n");
    } else {
        pdebug(DEBUG_LEVEL_FATAL,"create task_ptz_tcp_autoReturn failed\r\n");
    }
}


/**
  * @brief  初始化发送json
  * @param
  * @retval
  */
void sendJsonInit(void)
{
    replyRoot = cJSON_CreateObject();
    // replySwitch = cJSON_CreateObject();
    equipmentBase = cJSON_CreateObject();
    // equipmentBase2 = cJSON_CreateObject();
    commondInfo = cJSON_CreateObject();
    SystemInfo = cJSON_CreateObject();

    // cJSON_AddNumberToObject(equipmentBase1, "equipmentType", rotattable);
    // cJSON_AddNumberToObject(equipmentBase1, "equipmentID", Equipment_ID);
    // cJSON_AddNumberToObject(equipmentBase1, "nodeNo", nodeNo);
    // cJSON_AddStringToObject(equipmentBase1, "spoofState", "工作中");
    // cJSON_AddStringToObject(equipmentBase1, "errLog", "");

    cJSON_AddNumberToObject(equipmentBase, "equipmentType", rotattable);
    cJSON_AddNumberToObject(equipmentBase, "equipmentID", Equipment_ID);
    cJSON_AddNumberToObject(equipmentBase, "nodeNo", nodeNo);
    cJSON_AddStringToObject(equipmentBase, "spoofState", "工作中");
    cJSON_AddStringToObject(equipmentBase, "errLog", "");

    cJSON_AddStringToObject(commondInfo, "ctrlID", "xxxxxxxxxx");
    cJSON_AddNumberToObject(commondInfo, "ctrlState", 0x01);
    cJSON_AddStringToObject(commondInfo, "ctrlLog", "");

    // cJSON_AddNumberToObject(SystemInfo, "curHorAngle", g_ptz.hori_angle_actual);
    // cJSON_AddNumberToObject(SystemInfo, "curHorSpeed", g_ptz.hori_speed_actual);
    // cJSON_AddNumberToObject(SystemInfo, "curVerAngle", g_ptz.vert_angle_actual);
    // cJSON_AddNumberToObject(SystemInfo, "curVerSpeed", g_ptz.vert_speed_actual);
    
    cJSON_AddNumberToObject(SystemInfo, "curHorAngle", 0.0f);
    cJSON_AddNumberToObject(SystemInfo, "curHorSpeed", 0.0f);
    cJSON_AddNumberToObject(SystemInfo, "curVerAngle", 0.0f);
    cJSON_AddNumberToObject(SystemInfo, "curVerSpeed", 0.0f);

    cJSON_AddItemToObject(replyRoot, "equipmentBase", equipmentBase);
    cJSON_AddItemToObject(replyRoot, "SystemInfo", SystemInfo);
    cJSON_AddItemToObject(replyRoot, "commondInfo", commondInfo);
    
    // cJSON_AddItemToObject(replySwitch, "equipmentBase", equipmentBase2);
    // cJSON_AddItemToObject(replySwitch, "commondInfo", commondInfo);
}

/**
  * @brief  处理需要tcp返回的数据
  * @param
  * @retval
  */
static void ptz_tcp_returnData()
{
#if 0 
    cJSON* item = cJSON_GetObjectItem(root, "level_curAngle");
    if (item != NULL && cJSON_IsNumber(item)) {
        item->valuedouble = g_ptz.hori_angle_actual;
    }

    item = cJSON_GetObjectItem(root, "level_curSpeed");
    if (item != NULL && cJSON_IsNumber(item)) {
        item->valuedouble = g_ptz.hori_direction_actual;
    }

    item = cJSON_GetObjectItem(root, "pitch_curAngle");
    if (item != NULL && cJSON_IsNumber(item)) {
        item->valuedouble = g_ptz.vert_angle_actual;
    }

    item = cJSON_GetObjectItem(root, "level_curSpeed");
    if (item != NULL && cJSON_IsNumber(item)) {
        item->valuedouble = g_ptz.vert_speed_actual;
    }
#endif


BSP_OS_SemWait(&tcp_data_mutex, 0u);

#if 1
    cJSON* item = cJSON_GetObjectItem(SystemInfo, "curHorAngle");
    item->valuedouble = g_ptz.hori_angle_actual;

    item = cJSON_GetObjectItem(SystemInfo, "curHorSpeed");
    item->valuedouble = g_ptz.hori_speed_actual * 6.0f;

    item = cJSON_GetObjectItem(SystemInfo, "curVerAngle");
    item->valuedouble = g_ptz.vert_angle_actual;

    item = cJSON_GetObjectItem(SystemInfo, "curVerSpeed");
    item->valuedouble = g_ptz.vert_speed_actual * 6.0f;
#endif

    char *json = cJSON_PrintUnformatted(replyRoot);
    // char *json = cJSON_PrintUnformatted(SystemInfo);
    pdebug(DEBUG_LEVEL_DEBUG,"\n%s,%d\n", json, strlen(json));

    // sprintf(tcp_send_buff, "%s%s%s", pack_head, json, pack_tail);
    //包头
    int len = 0;
    // memcpy(tcp_send_buff + len, pack_head, 4);
    tcp_send_buff[0] = pack_head[0];
    tcp_send_buff[1] = pack_head[1];
    tcp_send_buff[2] = pack_head[2];
    tcp_send_buff[3] = pack_head[3];

    //信息长度
    len += 4;
    int datalen = strlen(json) + 18;
    tcp_send_buff[len] = (datalen >> 24) & 0xff;
    tcp_send_buff[len + 1] = (datalen >> 16) & 0xff;
    tcp_send_buff[len + 2] = (datalen >> 8) & 0xff;
    tcp_send_buff[len + 3] = (datalen >> 0) & 0xff;
    
    //设备类型
    len += 4;
    tcp_send_buff[len] = rotattable;

    //设备类型
    len += 1;
    tcp_send_buff[len] = infoType;

    //报文内容
    len += 1;
    memcpy(tcp_send_buff + len, json, strlen(json));

    //报文尾
    len += strlen(json);
    len += 4;
    // memcpy(tcp_send_buff + len, pack_tail, 4);
    tcp_send_buff[len + 0] = pack_tail[0];
    tcp_send_buff[len + 1] = pack_tail[1];
    tcp_send_buff[len + 2] = pack_tail[2];
    tcp_send_buff[len + 3] = pack_tail[3];

    //crc校验
    // len -= 4;
    uint8_t *crcData;
    crcData = checkCrc32_1(tcp_send_buff, len + 4);
    // memcpy(tcp_send_buff + len, crcData, 4);
    // tcp_send_buff[len + 0] = crcData[3];
    // tcp_send_buff[len + 1] = crcData[2];
    // tcp_send_buff[len + 2] = crcData[1];
    // tcp_send_buff[len + 3] = crcData[0];
        
    tcp_send_buff[len - 4] = crcData[3];
    tcp_send_buff[len - 3] = crcData[2];
    tcp_send_buff[len - 2] = crcData[1];
    tcp_send_buff[len - 1] = crcData[0];


    len += 4;
    // tcp_send_buff[len + 4] = '\r';
    tcp_send_buff[len] = '\n';

    // send_tcp_data(tcp_send_buff, len + 1);
    // pdebug(DEBUG_LEVEL_DEBUG,"%s\r\n", tcp_send_buff);

    cJSON_free(json);
    BSP_OS_SemPost(&tcp_data_mutex);
}

/**
  * @brief  通过tcp将数据自动返回
  * @param
  * @retval
  */
void ptz_tcp_autoReturn(void)
{
    if (m_tcp_auto_return.swtich == PTZ_AUTO_RETURN_ON) {
        m_tcp_auto_return.timer += PTZ_AUTO_RETURN_TASK_TIME;
        if (m_tcp_auto_return.timer >= m_tcp_auto_return.time &&
         m_tcp_auto_return.timer >= PTZ_CURRENT_AUTO_RETURN_TIME_MIN) {
            m_tcp_auto_return.timer = 0;
            // ptz_current_auto_return(PTZ_UDP);
            ptz_tcp_returnData();
            OSTimeDlyHMSM(0u, 0u, 0u, 1u);
        }
    }
}

void ptz_tcp_returnDataTask(void)
{
    while (1) {
        // ptz_tcp_autoReturn();    
        if (m_tcp_auto_return.swtich == PTZ_AUTO_RETURN_ON) {

            if (workStatus != startWork) {
                OSTimeDlyHMSM(0u, 0u, 0u, PTZ_AUTO_RETURN_TASK_TIME);
                continue;
            }

            m_tcp_auto_return.timer += PTZ_AUTO_RETURN_TASK_TIME;

            if (m_tcp_auto_return.timer >= m_tcp_auto_return.time &&
                    m_tcp_auto_return.timer >= PTZ_CURRENT_AUTO_RETURN_TIME_MIN) {
                m_tcp_auto_return.timer = 0;
                ptz_tcp_returnData();
            }
        }
        OSTimeDlyHMSM(0u, 0u, 0u, PTZ_AUTO_RETURN_TASK_TIME);
    }
}