954 lines
28 KiB
C
954 lines
28 KiB
C
#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);
|
||
}
|
||
} |