dufresne
/
MW22-01A_origin_project
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
MW22-01A_origin_project/APP/Agent/DLC-AEZT030W.c

954 lines
28 KiB
C
Raw Normal View History

MW22-01A原工程
2025-10-11 02:19:49 +00:00
#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);
}
}