1541 lines
48 KiB
C
1541 lines
48 KiB
C
/**
|
||
******************************************************************************
|
||
* @file tcp_server.c
|
||
* @brief TCP调试服务器实现
|
||
******************************************************************************
|
||
*/
|
||
|
||
#include "tcp_server.h"
|
||
#include "debug_link.h"
|
||
#include "tcp_protocol.h"
|
||
#include "debug_files.h"
|
||
#include <string.h>
|
||
#include <stdio.h>
|
||
#include "publicdata/public_define.h"
|
||
#include "publicdata/publicdata.h"
|
||
#include "FreeRTOS.h"
|
||
#include "task.h"
|
||
#include "semphr.h"
|
||
#include "cJSON.h"
|
||
|
||
#if BLE_DEBUG_EN
|
||
#include "ble_link/fc41d_ble.h"
|
||
#endif
|
||
|
||
#if TCP_DEBUG_EN
|
||
|
||
/* TCP服务器配置 */
|
||
#define TCP_LOCAL_PORT TCP_DEBUG_PORT
|
||
#define MAX_CLIENTS TCP_DEBUG_MAX_CLIENTS
|
||
|
||
/* 接收数据缓冲区（用于处理多包/残包） */
|
||
#define TCP_RX_BUF_NORMAL 1024U /* 常态：心跳/参数查询等 */
|
||
#define TCP_RX_BUF_UPGRADE 8192U /* 以太网固件升级拼包 */
|
||
#define TCP_RX_BUF_UPGRADE_BLE 2048U /* BLE：单包 1024B，JSON 约 1.6KB */
|
||
|
||
typedef struct {
|
||
uint8_t *buffer;
|
||
uint32_t cap;
|
||
uint32_t used;
|
||
uint32_t processed;
|
||
} tcp_rx_buffer_t;
|
||
|
||
/* 服务器状态结构体实例 */
|
||
static tcp_server_state_t server_state = {
|
||
.server_pcb = NULL,
|
||
.client_pcb = NULL,
|
||
.is_client_connected = 0,
|
||
.heartbeat_sequence = 0,
|
||
.system_info_sent = 0,
|
||
.tick_counter = 0,
|
||
.heartbeat_last_tick = 0,
|
||
.system_info_last_tick = 0,
|
||
.gun_data_last_tick = 0,
|
||
.last_heartbeat_received_tick = 0
|
||
};
|
||
|
||
/* 接收数据缓冲区（用于多包处理） */
|
||
static tcp_rx_buffer_t rx_buffer;
|
||
static SemaphoreHandle_t tcp_server_mutex = NULL; /* 服务器状态互斥锁 */
|
||
static SemaphoreHandle_t rx_buffer_mutex = NULL; /* 接收缓冲区互斥锁 */
|
||
|
||
/* 消息发送间隔（秒） */
|
||
#define HEARTBEAT_INTERVAL_SEC 10 /* 设备主动心跳（已关闭，仅保留供兼容） */
|
||
#define PERIODIC_REPORT_INTERVAL_SEC 2U /* SystemInfo + 双枪 GunInfo 周期 */
|
||
#define HEARTBEAT_TIMEOUT_SEC 30 /* 客户端心跳超时 30 秒 */
|
||
|
||
#define TCP_MSG_JSON_BUF_SIZE 768U /* GunInfo JSON 较长，预留 768 字节 */
|
||
/** 固件升级时 tcp_server_process 内追加 RX/抽帧轮次 */
|
||
#define TCP_UPGRADE_RX_BURST_PASSES 96U
|
||
|
||
/* 定时判断函数 */
|
||
static uint8_t tcp_should_send_message(uint32_t last_send_tick, uint32_t interval_sec);
|
||
|
||
/* 接收数据缓冲区操作函数（用于多包处理） */
|
||
static void tcp_rx_buffer_init(void);
|
||
static int tcp_rx_buffer_append(const uint8_t *data, uint16_t len);
|
||
static int tcp_rx_buffer_extract_json(char *output, uint32_t output_size, int *out_json_start);
|
||
static void tcp_rx_buffer_rollback_to(uint32_t pos);
|
||
static int s_tcp_json_is_heartbeat(const char *json);
|
||
static int s_tcp_fw_data_b64_incomplete(const char *json, int json_len);
|
||
static void s_tcp_log_rx_cache(const char *when);
|
||
static int s_tcp_diag_rx_trace(void);
|
||
static void tcp_rx_buffer_consume(uint32_t len);
|
||
static void tcp_rx_buffer_reset(void);
|
||
|
||
static int tcp_rx_buffer_set_cap(uint32_t cap)
|
||
{
|
||
uint8_t *new_buf;
|
||
uint32_t keep_used;
|
||
uint32_t keep_processed;
|
||
|
||
if (cap == 0U) {
|
||
return -1;
|
||
}
|
||
if ((rx_buffer.buffer != NULL) && (rx_buffer.cap == cap)) {
|
||
return 0;
|
||
}
|
||
|
||
keep_used = rx_buffer.used;
|
||
keep_processed = rx_buffer.processed;
|
||
|
||
new_buf = (uint8_t *)pvPortMalloc(cap);
|
||
if (new_buf == NULL) {
|
||
TCP_PRINT("RX buffer alloc failed (%u bytes)\r\n", (unsigned)cap);
|
||
return -1;
|
||
}
|
||
|
||
if ((rx_buffer.buffer != NULL) && (keep_used > 0U)) {
|
||
uint32_t copy_len = keep_used;
|
||
if (copy_len > cap) {
|
||
copy_len = cap;
|
||
keep_processed = 0U;
|
||
}
|
||
memcpy(new_buf, rx_buffer.buffer, copy_len);
|
||
keep_used = copy_len;
|
||
}
|
||
|
||
if (rx_buffer.buffer != NULL) {
|
||
vPortFree(rx_buffer.buffer);
|
||
}
|
||
rx_buffer.buffer = new_buf;
|
||
rx_buffer.cap = cap;
|
||
rx_buffer.used = keep_used;
|
||
rx_buffer.processed = keep_processed;
|
||
TCP_PRINT("RX buffer cap=%u bytes (used=%u)\r\n", (unsigned)cap, (unsigned)keep_used);
|
||
return 0;
|
||
}
|
||
|
||
static void tcp_rx_buffer_free(void)
|
||
{
|
||
if (rx_buffer.buffer != NULL) {
|
||
vPortFree(rx_buffer.buffer);
|
||
rx_buffer.buffer = NULL;
|
||
}
|
||
rx_buffer.cap = 0U;
|
||
rx_buffer.used = 0U;
|
||
rx_buffer.processed = 0U;
|
||
}
|
||
|
||
int tcp_server_rx_upgrade_begin(void)
|
||
{
|
||
#if BLE_DEBUG_EN
|
||
if (COMM_LINK_IS_BLE(comm_link_get_type())) {
|
||
if (comm_link_ble_rx_upgrade_begin() != 0) {
|
||
return -1;
|
||
}
|
||
return tcp_rx_buffer_set_cap(TCP_RX_BUF_UPGRADE_BLE);
|
||
}
|
||
#endif
|
||
return tcp_rx_buffer_set_cap(TCP_RX_BUF_UPGRADE);
|
||
}
|
||
|
||
int tcp_server_rx_upgrade_end(void)
|
||
{
|
||
tcp_rx_buffer_reset();
|
||
#if BLE_DEBUG_EN
|
||
if (COMM_LINK_IS_BLE(comm_link_get_type())) {
|
||
(void)comm_link_ble_rx_upgrade_end();
|
||
}
|
||
#endif
|
||
return tcp_rx_buffer_set_cap(TCP_RX_BUF_NORMAL);
|
||
}
|
||
|
||
void tcp_server_rx_clear_pending(void)
|
||
{
|
||
tcp_rx_buffer_reset();
|
||
}
|
||
|
||
/* 丢弃 processed 之前无 '{' 的残留字节（BLE 分片/心跳尾包） */
|
||
static int s_tcp_rx_has_partial_json(void)
|
||
{
|
||
int brace_count = 0;
|
||
int in_string = 0;
|
||
int escape_next = 0;
|
||
int partial = 0;
|
||
|
||
if (rx_buffer.used <= rx_buffer.processed) {
|
||
return 0;
|
||
}
|
||
|
||
if (rx_buffer_mutex != NULL) {
|
||
xSemaphoreTake(rx_buffer_mutex, portMAX_DELAY);
|
||
}
|
||
|
||
for (uint32_t i = rx_buffer.processed; i < rx_buffer.used; i++) {
|
||
char c = rx_buffer.buffer[i];
|
||
|
||
if (escape_next) {
|
||
escape_next = 0;
|
||
continue;
|
||
}
|
||
if (c == '"' && (i == rx_buffer.processed || rx_buffer.buffer[i - 1U] != '\\')) {
|
||
in_string = !in_string;
|
||
continue;
|
||
}
|
||
if (c == '\\' && in_string) {
|
||
escape_next = 1;
|
||
continue;
|
||
}
|
||
if (!in_string) {
|
||
if (c == '{') {
|
||
brace_count++;
|
||
} else if (c == '}') {
|
||
brace_count--;
|
||
}
|
||
}
|
||
}
|
||
|
||
partial = (brace_count > 0) ? 1 : 0;
|
||
|
||
if (rx_buffer_mutex != NULL) {
|
||
xSemaphoreGive(rx_buffer_mutex);
|
||
}
|
||
|
||
return partial;
|
||
}
|
||
|
||
static int s_tcp_diag_rx_trace(void)
|
||
{
|
||
return (system_filetransfer_is_active() != 0) ? 1 : 0;
|
||
}
|
||
|
||
static void s_tcp_log_rx_cache_locked(const char *when)
|
||
{
|
||
uint32_t pending;
|
||
|
||
pending = (rx_buffer.used > rx_buffer.processed) ?
|
||
(rx_buffer.used - rx_buffer.processed) : 0U;
|
||
tcp_firmware_upgrade_log_meta(when,
|
||
rx_buffer.used,
|
||
rx_buffer.processed,
|
||
rx_buffer.cap,
|
||
pending);
|
||
if (pending > 0U) {
|
||
tcp_firmware_upgrade_log_buf("TCP-CACHE-DATA",
|
||
(const uint8_t *)(rx_buffer.buffer + rx_buffer.processed),
|
||
pending);
|
||
}
|
||
}
|
||
|
||
static void s_tcp_log_rx_cache(const char *when)
|
||
{
|
||
if (s_tcp_diag_rx_trace() == 0) {
|
||
return;
|
||
}
|
||
if (rx_buffer_mutex != NULL) {
|
||
xSemaphoreTake(rx_buffer_mutex, portMAX_DELAY);
|
||
}
|
||
s_tcp_log_rx_cache_locked(when);
|
||
if (rx_buffer_mutex != NULL) {
|
||
xSemaphoreGive(rx_buffer_mutex);
|
||
}
|
||
}
|
||
|
||
static void tcp_rx_buffer_skip_leading_garbage(void)
|
||
{
|
||
uint32_t i;
|
||
int first_brace = -1;
|
||
|
||
if (rx_buffer.used <= rx_buffer.processed) {
|
||
return;
|
||
}
|
||
|
||
if (rx_buffer_mutex != NULL) {
|
||
xSemaphoreTake(rx_buffer_mutex, portMAX_DELAY);
|
||
}
|
||
|
||
for (i = rx_buffer.processed; i < rx_buffer.used; i++) {
|
||
if (rx_buffer.buffer[i] == '{') {
|
||
first_brace = (int)i;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (first_brace > (int)rx_buffer.processed) {
|
||
TCP_PRINT("Skip %u bytes before JSON '{'\r\n",
|
||
(unsigned)((uint32_t)first_brace - rx_buffer.processed));
|
||
rx_buffer.processed = (uint32_t)first_brace;
|
||
}
|
||
|
||
if (rx_buffer_mutex != NULL) {
|
||
xSemaphoreGive(rx_buffer_mutex);
|
||
}
|
||
}
|
||
|
||
/* 接收缓冲区处理函数 */
|
||
static void tcp_server_process_rx_buffer(void);
|
||
|
||
/* Socket API相关函数 */
|
||
static int tcp_server_socket_receive_data(void)
|
||
{
|
||
uint8_t temp_buffer[1024];
|
||
int received = 0;
|
||
int total = 0;
|
||
int link_error = 0;
|
||
|
||
for (;;) {
|
||
received = comm_link_receive_data(temp_buffer, sizeof(temp_buffer));
|
||
if (received < 0) {
|
||
link_error = received;
|
||
break;
|
||
}
|
||
if (received == 0) {
|
||
break;
|
||
}
|
||
|
||
if (tcp_rx_buffer_append(temp_buffer, (uint16_t)received) != 0) {
|
||
TCP_PRINT("Failed to append data to RX buffer from socket\r\n");
|
||
} else {
|
||
if (s_tcp_diag_rx_trace() != 0) {
|
||
if (system_filetransfer_is_active() != 0) {
|
||
system_filetransfer_touch_activity_on_rx();
|
||
}
|
||
tcp_firmware_upgrade_log_io("RX-LINK", (const char *)temp_buffer, (uint32_t)received);
|
||
}
|
||
TCP_PRINT("Added %d bytes to RX buffer from socket\r\n", received);
|
||
}
|
||
total += received;
|
||
if (s_tcp_diag_rx_trace() == 0) {
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (link_error < 0) {
|
||
TCP_PRINT("Socket receive error or connection closed: %d\r\n", link_error);
|
||
|
||
if (tcp_server_mutex != NULL) {
|
||
xSemaphoreTake(tcp_server_mutex, portMAX_DELAY);
|
||
}
|
||
|
||
server_state.is_client_connected = 0;
|
||
|
||
if (tcp_server_mutex != NULL) {
|
||
xSemaphoreGive(tcp_server_mutex);
|
||
}
|
||
|
||
tcp_rx_buffer_reset();
|
||
return link_error;
|
||
}
|
||
|
||
return total;
|
||
}
|
||
|
||
void upgrade_erase_yield(void)
|
||
{
|
||
#if BLE_DEBUG_EN
|
||
if (COMM_LINK_IS_BLE(comm_link_get_type())) {
|
||
comm_link_ble_process();
|
||
}
|
||
#endif
|
||
if (server_state.is_client_connected) {
|
||
uint8_t pass;
|
||
|
||
for (pass = 0U; pass < 4U; pass++) {
|
||
if (tcp_server_socket_receive_data() <= 0) {
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void tcp_server_link_rx_drain(void)
|
||
{
|
||
uint8_t pass;
|
||
|
||
if (!server_state.is_client_connected) {
|
||
return;
|
||
}
|
||
|
||
for (pass = 0U; pass < 32U; pass++) {
|
||
int got = tcp_server_socket_receive_data();
|
||
if (got <= 0) {
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @brief 发送数据到客户端（Socket API版本）
|
||
* @param data 要发送的数据
|
||
* @param len 数据长度
|
||
* @retval 发送的字节数，-1表示错误
|
||
*/
|
||
static int tcp_server_send_data_socket(const void *data, uint16_t len)
|
||
{
|
||
if (data == NULL || len == 0) {
|
||
return -1;
|
||
}
|
||
|
||
#if TCP_DEBUG_EN
|
||
if (s_tcp_diag_rx_trace() != 0) {
|
||
tcp_firmware_upgrade_log_io("TX-LINK", (const char *)data, (uint32_t)len);
|
||
}
|
||
#endif
|
||
|
||
/* 打印原始发送数据 */
|
||
TCP_PRINT_RAW_SEND((const uint8_t *)data, len);
|
||
|
||
/* 使用Socket API发送数据 */
|
||
return comm_link_send_data((const uint8_t *)data, len);
|
||
}
|
||
|
||
/**
|
||
* @brief 判断是否应该发送消息（基于时间间隔）
|
||
* @param last_send_tick 上次发送时的tick
|
||
* @param interval_sec 发送间隔（秒）
|
||
* @retval 1应该发送，0不应该发送
|
||
*/
|
||
static uint8_t tcp_should_send_message(uint32_t last_send_tick, uint32_t interval_sec)
|
||
{
|
||
uint32_t elapsed = server_state.tick_counter - last_send_tick;
|
||
return (elapsed >= interval_sec) ? 1 : 0;
|
||
}
|
||
|
||
/**
|
||
* @brief 初始化接收数据缓冲区
|
||
*/
|
||
static void tcp_rx_buffer_init(void)
|
||
{
|
||
rx_buffer_mutex = xSemaphoreCreateMutex();
|
||
if (rx_buffer_mutex == NULL) {
|
||
TCP_PRINT("Failed to create RX buffer mutex\r\n");
|
||
return;
|
||
}
|
||
|
||
rx_buffer.buffer = NULL;
|
||
rx_buffer.cap = 0U;
|
||
rx_buffer.used = 0U;
|
||
rx_buffer.processed = 0U;
|
||
if (tcp_rx_buffer_set_cap(TCP_RX_BUF_NORMAL) != 0) {
|
||
TCP_PRINT("RX buffer normal alloc failed\r\n");
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @brief 重置接收数据缓冲区
|
||
*/
|
||
static void tcp_rx_buffer_reset(void)
|
||
{
|
||
/* 获取接收缓冲区互斥锁 */
|
||
if (rx_buffer_mutex != NULL) {
|
||
xSemaphoreTake(rx_buffer_mutex, portMAX_DELAY);
|
||
}
|
||
|
||
rx_buffer.used = 0;
|
||
rx_buffer.processed = 0;
|
||
|
||
/* 释放接收缓冲区互斥锁 */
|
||
if (rx_buffer_mutex != NULL) {
|
||
xSemaphoreGive(rx_buffer_mutex);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @brief 将数据追加到接收缓冲区
|
||
* @param data 数据指针
|
||
* @param len 数据长度
|
||
* @retval 0成功，-1失败（缓冲区满）
|
||
*/
|
||
static int tcp_rx_buffer_append(const uint8_t *data, uint16_t len)
|
||
{
|
||
int result = -1;
|
||
|
||
if (data == NULL || len == 0) {
|
||
return -1;
|
||
}
|
||
|
||
/* 获取接收缓冲区互斥锁 */
|
||
if (rx_buffer_mutex != NULL) {
|
||
xSemaphoreTake(rx_buffer_mutex, portMAX_DELAY);
|
||
}
|
||
|
||
/* 检查缓冲区是否有足够空间 */
|
||
if (rx_buffer.buffer == NULL || rx_buffer.cap == 0U) {
|
||
result = -1;
|
||
} else if (rx_buffer.used + len > rx_buffer.cap) {
|
||
TCP_PRINT("RX buffer full! Used: %u, Adding: %u, Max: %u\r\n",
|
||
rx_buffer.used, len, rx_buffer.cap);
|
||
result = -1;
|
||
} else {
|
||
#if TCP_DEBUG_EN
|
||
if (s_tcp_diag_rx_trace() != 0) {
|
||
if ((len >= 12U) && (data[0] == (uint8_t)'{')) {
|
||
uint16_t peek = (len > 128U) ? 128U : len;
|
||
char head[129];
|
||
|
||
memcpy(head, data, peek);
|
||
head[peek] = '\0';
|
||
if ((strstr(head, CMD_FIRMWARE_UPGRADE) != NULL) &&
|
||
(s_tcp_rx_has_partial_json() != 0)) {
|
||
TCP_PRINT("Upgrade host retry: drop partial JSON (%u bytes)\r\n",
|
||
(unsigned)(rx_buffer.used - rx_buffer.processed));
|
||
rx_buffer.used = rx_buffer.processed;
|
||
}
|
||
}
|
||
}
|
||
#endif
|
||
/* 复制数据到缓冲区 */
|
||
memcpy(rx_buffer.buffer + rx_buffer.used, data, len);
|
||
rx_buffer.used += len;
|
||
|
||
TCP_PRINT("Added %u bytes to RX buffer, total: %u\r\n", len, rx_buffer.used);
|
||
result = 0;
|
||
#if TCP_DEBUG_EN
|
||
if (s_tcp_diag_rx_trace() != 0) {
|
||
s_tcp_log_rx_cache_locked("TCP-after-append");
|
||
}
|
||
#endif
|
||
}
|
||
|
||
/* 释放接收缓冲区互斥锁 */
|
||
if (rx_buffer_mutex != NULL) {
|
||
xSemaphoreGive(rx_buffer_mutex);
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* @brief 从缓冲区提取完整的JSON消息
|
||
* @param output 输出缓冲区
|
||
* @param output_size 输出缓冲区大小
|
||
* @param out_json_start 可选，返回本条 JSON 在缓冲中的起始下标（用于半包回退）
|
||
* @retval JSON消息长度，0表示没有完整消息，-1表示错误
|
||
*/
|
||
static int tcp_rx_buffer_extract_json(char *output, uint32_t output_size, int *out_json_start)
|
||
{
|
||
int brace_count = 0;
|
||
int json_start = -1;
|
||
int json_end = -1;
|
||
int in_string = 0;
|
||
int escape_next = 0;
|
||
int i;
|
||
int result = 0;
|
||
|
||
if (output == NULL || output_size == 0) {
|
||
return -1;
|
||
}
|
||
|
||
/* 获取接收缓冲区互斥锁 */
|
||
if (rx_buffer_mutex != NULL) {
|
||
xSemaphoreTake(rx_buffer_mutex, portMAX_DELAY);
|
||
}
|
||
|
||
/* 查找完整的JSON消息（通过括号匹配，忽略字符串内的括号） */
|
||
for (i = rx_buffer.processed; i < rx_buffer.used; i++) {
|
||
char c = rx_buffer.buffer[i];
|
||
|
||
/* 处理转义字符 */
|
||
if (escape_next) {
|
||
escape_next = 0;
|
||
continue;
|
||
}
|
||
|
||
/* 处理字符串开始/结束 */
|
||
if (c == '"' && (i == rx_buffer.processed || rx_buffer.buffer[i-1] != '\\')) {
|
||
in_string = !in_string;
|
||
continue;
|
||
}
|
||
|
||
/* 处理转义字符标记 */
|
||
if (c == '\\' && in_string) {
|
||
escape_next = 1;
|
||
continue;
|
||
}
|
||
|
||
/* 只有在不在字符串内时才计数括号 */
|
||
if (!in_string) {
|
||
if (c == '{') {
|
||
if (brace_count == 0) {
|
||
json_start = i; /* 记录JSON开始位置 */
|
||
}
|
||
brace_count++;
|
||
} else if (c == '}') {
|
||
brace_count--;
|
||
|
||
if (brace_count == 0 && json_start != -1) {
|
||
json_end = i; /* 记录JSON结束位置 */
|
||
break;
|
||
} else if (brace_count < 0) {
|
||
/* 括号不匹配，重置状态 */
|
||
brace_count = 0;
|
||
json_start = -1;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/* 检查是否找到完整的JSON消息 */
|
||
if (json_start != -1 && json_end != -1) {
|
||
int json_len = json_end - json_start + 1;
|
||
|
||
/* 检查输出缓冲区是否足够 */
|
||
if (json_len >= output_size) {
|
||
TCP_PRINT("JSON too large for output buffer: %d >= %u\r\n",
|
||
json_len, output_size);
|
||
result = -1;
|
||
} else {
|
||
/* 复制JSON消息到输出缓冲区 */
|
||
memcpy(output, rx_buffer.buffer + json_start, json_len);
|
||
output[json_len] = '\0';
|
||
|
||
if (out_json_start != NULL) {
|
||
*out_json_start = json_start;
|
||
}
|
||
|
||
/* 更新已处理位置 */
|
||
rx_buffer.processed = (uint32_t)(json_end + 1);
|
||
|
||
TCP_PRINT("Extracted JSON message (%d bytes)\r\n", json_len);
|
||
|
||
result = json_len;
|
||
}
|
||
} else {
|
||
/* 没有找到完整的JSON消息 */
|
||
if (rx_buffer.used - rx_buffer.processed > 0) {
|
||
TCP_PRINT("No complete JSON found. Buffer: remaining=%u bytes\r\n",
|
||
rx_buffer.used - rx_buffer.processed);
|
||
|
||
/* 调试：打印缓冲区的前200个字符 */
|
||
uint32_t remaining = rx_buffer.used - rx_buffer.processed;
|
||
if (remaining > 0) {
|
||
char debug_buf[256];
|
||
uint32_t copy_len = (remaining < 200) ? remaining : 200;
|
||
memcpy(debug_buf, rx_buffer.buffer + rx_buffer.processed, copy_len);
|
||
debug_buf[copy_len] = '\0';
|
||
TCP_PRINT("Buffer content (first %u bytes): %s\r\n", copy_len, debug_buf);
|
||
}
|
||
|
||
/* 检查是否有可能是JSON消息的一部分（但没有开头的'{'） */
|
||
/* 这种情况可能发生在JSON消息被TCP分割时 */
|
||
if (json_start == -1 && json_end == -1) {
|
||
/* 检查缓冲区中是否有JSON格式的字符 */
|
||
int has_json_chars = 0;
|
||
for (uint32_t j = rx_buffer.processed; j < rx_buffer.used; j++) {
|
||
char c = rx_buffer.buffer[j];
|
||
if (c == '"' || c == ':' || c == ',' || c == '[' || c == ']' ||
|
||
(c >= '0' && c <= '9') || (c >= 'a' && c <= 'z') ||
|
||
(c >= 'A' && c <= 'Z') || c == '.' || c == '-' || c == '+' || c == '=') {
|
||
has_json_chars = 1;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (has_json_chars) {
|
||
TCP_PRINT("Buffer contains JSON-like data but no complete JSON message found\r\n");
|
||
TCP_PRINT("This may be a partial JSON message (split by TCP)\r\n");
|
||
}
|
||
}
|
||
}
|
||
result = 0;
|
||
}
|
||
|
||
/* 释放接收缓冲区互斥锁 */
|
||
if (rx_buffer_mutex != NULL) {
|
||
xSemaphoreGive(rx_buffer_mutex);
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
static void tcp_rx_buffer_rollback_to(uint32_t pos)
|
||
{
|
||
if (rx_buffer_mutex != NULL) {
|
||
xSemaphoreTake(rx_buffer_mutex, portMAX_DELAY);
|
||
}
|
||
if (pos <= rx_buffer.used) {
|
||
rx_buffer.processed = pos;
|
||
}
|
||
if (rx_buffer_mutex != NULL) {
|
||
xSemaphoreGive(rx_buffer_mutex);
|
||
}
|
||
}
|
||
|
||
static int s_tcp_json_is_heartbeat(const char *json)
|
||
{
|
||
if (json == NULL) {
|
||
return 0;
|
||
}
|
||
return (strstr(json, "\"command\":\"Heartbeat\"") != NULL) ? 1 : 0;
|
||
}
|
||
|
||
static int s_tcp_fw_data_b64_incomplete(const char *json, int json_len)
|
||
{
|
||
const char *subcmd;
|
||
const char *p;
|
||
const char *end;
|
||
const char *pi;
|
||
uint32_t b64_len;
|
||
uint32_t pkt = 0U;
|
||
uint32_t expect = 0U;
|
||
uint32_t min_b64;
|
||
const char *b64_field = NULL;
|
||
|
||
if ((json == NULL) || (json_len <= 0)) {
|
||
return 0;
|
||
}
|
||
if (strstr(json, CMD_FIRMWARE_UPGRADE) == NULL) {
|
||
return 0;
|
||
}
|
||
subcmd = strstr(json, "\"subCommand\":\"Data\"");
|
||
if (subcmd == NULL) {
|
||
subcmd = strstr(json, "\"subCommand\": \"Data\"");
|
||
}
|
||
if (subcmd == NULL) {
|
||
return 0;
|
||
}
|
||
|
||
/* 在 data 对象内查找值为字符串的 "data" 字段（Base64 载荷，非外层 "data":{） */
|
||
p = json;
|
||
while ((p = strstr(p, "\"data\"")) != NULL) {
|
||
const char *col;
|
||
p += 6;
|
||
col = strchr(p, ':');
|
||
if (col == NULL) {
|
||
break;
|
||
}
|
||
col++;
|
||
while ((col < json + json_len) && (*col == ' ' || *col == '\t')) {
|
||
col++;
|
||
}
|
||
if (*col == '"') {
|
||
b64_field = col + 1;
|
||
break;
|
||
}
|
||
}
|
||
if (b64_field == NULL) {
|
||
return 1;
|
||
}
|
||
|
||
p = b64_field;
|
||
end = p;
|
||
while (end < json + json_len) {
|
||
if (*end == '"') {
|
||
break;
|
||
}
|
||
if ((*end == '\\') && (end + 1 < json + json_len)) {
|
||
end += 2;
|
||
} else {
|
||
end++;
|
||
}
|
||
}
|
||
if (*end != '"') {
|
||
return 1;
|
||
}
|
||
b64_len = (uint32_t)(end - p);
|
||
|
||
pi = strstr(json, "\"packetIndex\"");
|
||
if (pi != NULL) {
|
||
(void)sscanf(pi, "\"packetIndex\":%u", &pkt);
|
||
}
|
||
if (system_filetransfer_get_expected_packet_bytes(pkt, &expect) != 0 || expect == 0U) {
|
||
return 0;
|
||
}
|
||
min_b64 = ((expect + 2U) / 3U) * 4U;
|
||
return (b64_len < min_b64) ? 1 : 0;
|
||
}
|
||
|
||
/**
|
||
* @brief 消费已处理的数据（移动未处理数据到缓冲区开头）
|
||
* @param len 要消费的长度
|
||
*/
|
||
static void tcp_rx_buffer_consume(uint32_t len)
|
||
{
|
||
if (len == 0 || len > rx_buffer.processed) {
|
||
return;
|
||
}
|
||
|
||
/* 获取接收缓冲区互斥锁 */
|
||
if (rx_buffer_mutex != NULL) {
|
||
xSemaphoreTake(rx_buffer_mutex, portMAX_DELAY);
|
||
}
|
||
|
||
/* 移动未处理数据到缓冲区开头 */
|
||
uint32_t remaining = rx_buffer.used - rx_buffer.processed;
|
||
if (remaining > 0) {
|
||
memmove(rx_buffer.buffer,
|
||
rx_buffer.buffer + rx_buffer.processed,
|
||
remaining);
|
||
}
|
||
|
||
/* 更新缓冲区状态 */
|
||
rx_buffer.used = remaining;
|
||
rx_buffer.processed = 0;
|
||
|
||
TCP_PRINT("Consumed %u bytes from RX buffer, remaining: %u\r\n",
|
||
len, rx_buffer.used);
|
||
|
||
/* 如果缓冲区为空，重置状态 */
|
||
if (rx_buffer.used == 0) {
|
||
TCP_PRINT("RX buffer is empty, ready for new data\r\n");
|
||
}
|
||
|
||
/* 释放接收缓冲区互斥锁 */
|
||
if (rx_buffer_mutex != NULL) {
|
||
xSemaphoreGive(rx_buffer_mutex);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @brief 启动TCP服务器（Socket API版本）
|
||
* @retval err_t 错误码
|
||
*/
|
||
err_t tcp_server_start(void)
|
||
{
|
||
int result;
|
||
cJSON_Hooks hooks;
|
||
|
||
/* 初始化cJSON使用FreeRTOS内存分配器 */
|
||
hooks.malloc_fn = pvPortMalloc;
|
||
hooks.free_fn = vPortFree;
|
||
cJSON_InitHooks(&hooks);
|
||
|
||
/* 创建服务器状态互斥锁 */
|
||
tcp_server_mutex = xSemaphoreCreateMutex();
|
||
if (tcp_server_mutex == NULL) {
|
||
TCP_PRINT("Failed to create server mutex\r\n");
|
||
return ERR_MEM;
|
||
}
|
||
|
||
/* 初始化接收缓冲区（内部会创建接收缓冲区互斥锁） */
|
||
tcp_rx_buffer_init();
|
||
|
||
system_filetransfer_init();
|
||
|
||
/* 检查接收缓冲区互斥锁是否创建成功 */
|
||
if (rx_buffer_mutex == NULL) {
|
||
TCP_PRINT("Failed to create RX buffer mutex\r\n");
|
||
vSemaphoreDelete(tcp_server_mutex);
|
||
tcp_server_mutex = NULL;
|
||
return ERR_MEM;
|
||
}
|
||
|
||
/* 使用Socket API初始化TCP服务器 */
|
||
result = comm_link_start();
|
||
if (result != 0) {
|
||
TCP_PRINT("Failed to initialize socket server: %d\r\n", result);
|
||
vSemaphoreDelete(rx_buffer_mutex);
|
||
rx_buffer_mutex = NULL;
|
||
vSemaphoreDelete(tcp_server_mutex);
|
||
tcp_server_mutex = NULL;
|
||
return ERR_MEM;
|
||
}
|
||
|
||
/* 获取互斥锁保护状态变量 */
|
||
if (tcp_server_mutex != NULL) {
|
||
xSemaphoreTake(tcp_server_mutex, portMAX_DELAY);
|
||
}
|
||
|
||
/* 重置服务器状态 */
|
||
server_state.system_info_sent = 0;
|
||
server_state.heartbeat_last_tick = 0;
|
||
server_state.system_info_last_tick = 0;
|
||
server_state.gun_data_last_tick = 0;
|
||
server_state.last_heartbeat_received_tick = 0;
|
||
server_state.heartbeat_sequence = 0;
|
||
server_state.is_client_connected = 0;
|
||
server_state.client_pcb = NULL;
|
||
server_state.server_pcb = NULL;
|
||
|
||
/* 释放互斥锁 */
|
||
if (tcp_server_mutex != NULL) {
|
||
xSemaphoreGive(tcp_server_mutex);
|
||
}
|
||
|
||
if (comm_link_get_type() == COMM_LINK_TCP) {
|
||
TCP_PRINT("Debug server started, link=TCP port=%d\r\n", TCP_LOCAL_PORT);
|
||
} else {
|
||
TCP_PRINT("Debug server started, link=BLE (FC41D)\r\n");
|
||
}
|
||
return ERR_OK;
|
||
}
|
||
|
||
/**
|
||
* @brief 停止TCP服务器
|
||
*/
|
||
void tcp_server_stop(void)
|
||
{
|
||
/* 获取互斥锁保护状态变量 */
|
||
if (tcp_server_mutex != NULL) {
|
||
xSemaphoreTake(tcp_server_mutex, portMAX_DELAY);
|
||
}
|
||
|
||
/* 关闭客户端连接（使用Socket API） */
|
||
comm_link_close_client();
|
||
comm_link_stop();
|
||
|
||
/* 重置协议相关状态 */
|
||
server_state.system_info_sent = 0;
|
||
server_state.heartbeat_last_tick = 0;
|
||
server_state.system_info_last_tick = 0;
|
||
server_state.gun_data_last_tick = 0;
|
||
server_state.last_heartbeat_received_tick = 0;
|
||
server_state.heartbeat_sequence = 0;
|
||
server_state.is_client_connected = 0;
|
||
server_state.client_pcb = NULL;
|
||
server_state.server_pcb = NULL;
|
||
|
||
/* 释放互斥锁 */
|
||
if (tcp_server_mutex != NULL) {
|
||
xSemaphoreGive(tcp_server_mutex);
|
||
}
|
||
|
||
/* 删除服务器状态互斥锁 */
|
||
if (tcp_server_mutex != NULL) {
|
||
vSemaphoreDelete(tcp_server_mutex);
|
||
tcp_server_mutex = NULL;
|
||
}
|
||
|
||
/* 删除接收缓冲区互斥锁 */
|
||
if (rx_buffer_mutex != NULL) {
|
||
vSemaphoreDelete(rx_buffer_mutex);
|
||
rx_buffer_mutex = NULL;
|
||
}
|
||
|
||
/* 重置接收缓冲区 */
|
||
tcp_rx_buffer_reset();
|
||
|
||
TCP_PRINT("Server stopped (Socket API)\r\n");
|
||
}
|
||
|
||
/**
|
||
* @brief 发送指定类型的消息给客户端（Socket API版本）
|
||
* @param msg_type 消息类型（TCP_MSG_HEARTBEAT或TCP_MSG_SYSTEM_INFO）
|
||
*/
|
||
void tcp_server_send_message(tcp_msg_type_t msg_type)
|
||
{
|
||
char json_buffer[TCP_MSG_JSON_BUF_SIZE];
|
||
int json_len;
|
||
int sent;
|
||
|
||
if (system_filetransfer_is_active() != 0) {
|
||
return;
|
||
}
|
||
|
||
/* 检查客户端是否连接（使用Socket API） */
|
||
if (!comm_link_is_client_connected()) {
|
||
return;
|
||
}
|
||
|
||
switch (msg_type) {
|
||
case TCP_MSG_HEARTBEAT: {
|
||
/* 生成心跳JSON */
|
||
json_len = tcp_generate_heartbeat_json(server_state.heartbeat_sequence, "device", json_buffer, sizeof(json_buffer));
|
||
if (json_len <= 0) {
|
||
TCP_PRINT("Failed to generate heartbeat JSON\r\n");
|
||
return;
|
||
}
|
||
|
||
/* 发送JSON数据（使用Socket API） */
|
||
sent = tcp_server_send_data_socket(json_buffer, json_len);
|
||
if (sent > 0) {
|
||
server_state.heartbeat_sequence++; /* 序列号递增 */
|
||
TCP_PRINT("Sent heartbeat (seq=%u)\r\n", server_state.heartbeat_sequence - 1);
|
||
} else {
|
||
TCP_PRINT("Failed to send heartbeat: %d\r\n", sent);
|
||
}
|
||
break;
|
||
}
|
||
|
||
case TCP_MSG_SYSTEM_INFO: {
|
||
tcp_system_info_data_t system_info;
|
||
|
||
/* 获取默认系统信息 */
|
||
tcp_get_default_system_info(&system_info);
|
||
|
||
/* 生成系统信息JSON */
|
||
json_len = tcp_generate_system_info_json(&system_info, json_buffer, sizeof(json_buffer));
|
||
if (json_len <= 0) {
|
||
TCP_PRINT("Failed to generate system info JSON\r\n");
|
||
return;
|
||
}
|
||
|
||
/* 发送JSON数据（使用Socket API） */
|
||
sent = tcp_server_send_data_socket(json_buffer, json_len);
|
||
if (sent > 0) {
|
||
TCP_PRINT("Sent system info\r\n");
|
||
} else {
|
||
TCP_PRINT("Failed to send system info: %d\r\n", sent);
|
||
}
|
||
break;
|
||
}
|
||
|
||
case TCP_MSG_GUN_DATA: {
|
||
/* 发送各枪实时数据 */
|
||
for (uint8_t gun_num = 1; gun_num <= (uint8_t)GUN_MAX_CNT; gun_num++) {
|
||
tcp_gun_data_t gun_data;
|
||
|
||
tcp_get_default_gun_data(&gun_data, gun_num);
|
||
|
||
json_len = tcp_generate_gun_data_json(&gun_data, json_buffer, sizeof(json_buffer));
|
||
if (json_len <= 0) {
|
||
TCP_PRINT("Failed to generate gun data JSON for gun %u\r\n", (unsigned)gun_num);
|
||
#if BLE_DEBUG_EN
|
||
BT_PRINT("GunInfo JSON fail gun=%u\r\n", (unsigned)gun_num);
|
||
#endif
|
||
continue;
|
||
}
|
||
|
||
sent = tcp_server_send_data_socket(json_buffer, (uint16_t)json_len);
|
||
if (sent > 0) {
|
||
TCP_PRINT("Sent gun data for gun %u\r\n", (unsigned)gun_num);
|
||
} else {
|
||
TCP_PRINT("Failed to send gun data for gun %u: %d\r\n", (unsigned)gun_num, sent);
|
||
#if BLE_DEBUG_EN
|
||
BT_PRINT("GunInfo send fail gun=%u ret=%d\r\n", (unsigned)gun_num, sent);
|
||
#endif
|
||
}
|
||
|
||
#if BLE_DEBUG_EN
|
||
if (COMM_LINK_IS_BLE(comm_link_get_type())) {
|
||
vTaskDelay(pdMS_TO_TICKS(80));
|
||
} else
|
||
#endif
|
||
{
|
||
vTaskDelay(pdMS_TO_TICKS(10));
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
|
||
default:
|
||
TCP_PRINT("Unknown message type: %d\r\n", msg_type);
|
||
break;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @brief 发送JSON数据给客户端（Socket API版本）
|
||
* @param json_data JSON字符串
|
||
* @param len 数据长度
|
||
* @retval err_t 错误码
|
||
*/
|
||
err_t tcp_server_send_json(const char *json_data, uint16_t len)
|
||
{
|
||
int sent;
|
||
|
||
if (json_data == NULL || len == 0) {
|
||
return ERR_ARG;
|
||
}
|
||
|
||
/* 检查客户端是否连接（使用Socket API） */
|
||
if (!comm_link_is_client_connected()) {
|
||
TCP_PRINT("Cannot send JSON: no client connected\r\n");
|
||
return ERR_CONN;
|
||
}
|
||
|
||
/* 发送JSON数据（使用Socket API） */
|
||
sent = tcp_server_send_data_socket(json_data, len);
|
||
if (sent > 0) {
|
||
#if BLE_DEBUG_EN
|
||
if (!COMM_LINK_IS_BLE(comm_link_get_type())) {
|
||
(void)tcp_server_send_data_socket("\r\n", 2);
|
||
TCP_PRINT("Sent JSON data (%u bytes) + CRLF\r\n", len);
|
||
} else {
|
||
TCP_PRINT("Sent JSON data (%u bytes)\r\n", len);
|
||
}
|
||
#else
|
||
(void)tcp_server_send_data_socket("\r\n", 2);
|
||
TCP_PRINT("Sent JSON data (%u bytes) + CRLF\r\n", len);
|
||
#endif
|
||
return ERR_OK;
|
||
} else {
|
||
TCP_PRINT("Failed to send JSON data: %d\r\n", sent);
|
||
return ERR_IF;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @brief 处理接收缓冲区中的数据（提取并处理完整的JSON消息）
|
||
*/
|
||
static void tcp_server_process_rx_buffer(void)
|
||
{
|
||
char *json_buffer = NULL; /* 动态分配缓冲区以处理JSON消息 */
|
||
int json_len;
|
||
int processed_any = 0;
|
||
int has_partial_json = 0;
|
||
|
||
/* 动态分配JSON缓冲区 */
|
||
json_buffer = (char *)pvPortMalloc(rx_buffer.cap > 0U ? rx_buffer.cap : TCP_RX_BUF_NORMAL);
|
||
if (json_buffer == NULL) {
|
||
TCP_PRINT("Failed to allocate JSON buffer (%u bytes)\r\n",
|
||
(unsigned)(rx_buffer.cap > 0U ? rx_buffer.cap : TCP_RX_BUF_NORMAL));
|
||
return;
|
||
}
|
||
|
||
/* 检查是否有部分JSON消息（有'{'但没有匹配的'}'，或者有'}'但没有匹配的'{'） */
|
||
if (rx_buffer.used > rx_buffer.processed) {
|
||
int brace_count = 0;
|
||
int in_string = 0;
|
||
int escape_next = 0;
|
||
int has_open_brace = 0;
|
||
int has_close_brace = 0;
|
||
|
||
for (uint32_t i = rx_buffer.processed; i < rx_buffer.used; i++) {
|
||
char c = rx_buffer.buffer[i];
|
||
|
||
/* 处理转义字符 */
|
||
if (escape_next) {
|
||
escape_next = 0;
|
||
continue;
|
||
}
|
||
|
||
/* 处理字符串开始/结束 */
|
||
if (c == '"' && (i == rx_buffer.processed || rx_buffer.buffer[i-1] != '\\')) {
|
||
in_string = !in_string;
|
||
continue;
|
||
}
|
||
|
||
/* 处理转义字符标记 */
|
||
if (c == '\\' && in_string) {
|
||
escape_next = 1;
|
||
continue;
|
||
}
|
||
|
||
/* 只有在不在字符串内时才计数括号 */
|
||
if (!in_string) {
|
||
if (c == '{') {
|
||
brace_count++;
|
||
has_open_brace = 1;
|
||
} else if (c == '}') {
|
||
brace_count--;
|
||
has_close_brace = 1;
|
||
}
|
||
}
|
||
}
|
||
|
||
/* 如果有未匹配的'{'，说明有部分JSON消息（等待更多数据） */
|
||
if (brace_count > 0) {
|
||
has_partial_json = 1;
|
||
TCP_PRINT("Partial JSON detected in buffer (unmatched braces: %d)\r\n", brace_count);
|
||
}
|
||
/* 如果只有'}'没有'{'，可能是JSON消息被分割，开头部分在之前的数据包中 */
|
||
else if (has_close_brace && !has_open_brace) {
|
||
has_partial_json = 1;
|
||
TCP_PRINT("Partial JSON detected (only close brace found, waiting for more data)\r\n");
|
||
}
|
||
/* 如果缓冲区中有数据但没有括号，可能是JSON消息的一部分（如字符串中间） */
|
||
else if (rx_buffer.used - rx_buffer.processed > 0 && !has_open_brace && !has_close_brace) {
|
||
/* 检查缓冲区中是否有JSON格式的字符（如引号、冒号等） */
|
||
int has_json_chars = 0;
|
||
for (uint32_t i = rx_buffer.processed; i < rx_buffer.used; i++) {
|
||
char c = rx_buffer.buffer[i];
|
||
if (c == '"' || c == ':' || c == ',' || c == '[' || c == ']') {
|
||
has_json_chars = 1;
|
||
break;
|
||
}
|
||
}
|
||
if (has_json_chars) {
|
||
has_partial_json = 1;
|
||
TCP_PRINT("Partial JSON detected (JSON characters found, waiting for more data)\r\n");
|
||
}
|
||
}
|
||
}
|
||
|
||
/* 循环提取并处理所有完整的JSON消息 */
|
||
while (1) {
|
||
int json_start_pos = -1;
|
||
|
||
json_len = tcp_rx_buffer_extract_json(json_buffer,
|
||
rx_buffer.cap > 0U ? rx_buffer.cap : TCP_RX_BUF_NORMAL,
|
||
&json_start_pos);
|
||
|
||
if (json_len > 0) {
|
||
if (system_filetransfer_is_active() != 0) {
|
||
if (s_tcp_json_is_heartbeat(json_buffer) != 0) {
|
||
processed_any = 1;
|
||
continue;
|
||
}
|
||
if (s_tcp_fw_data_b64_incomplete(json_buffer, json_len) != 0) {
|
||
TCP_PRINT("Upgrade JSON incomplete b64, rollback\r\n");
|
||
s_tcp_log_rx_cache("TCP-b64-incomplete");
|
||
if (json_start_pos >= 0) {
|
||
tcp_rx_buffer_rollback_to((uint32_t)json_start_pos);
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
tcp_server_process_received_data(json_buffer, (uint16_t)json_len);
|
||
processed_any = 1;
|
||
#if TCP_DEBUG_EN
|
||
if (s_tcp_diag_rx_trace() != 0) {
|
||
s_tcp_log_rx_cache("TCP-after-json-ok");
|
||
}
|
||
#endif
|
||
} else if (json_len == 0) {
|
||
/* 没有完整的JSON消息 */
|
||
#if TCP_DEBUG_EN
|
||
if (s_tcp_diag_rx_trace() != 0) {
|
||
s_tcp_log_rx_cache("TCP-no-full-json");
|
||
}
|
||
#endif
|
||
break;
|
||
} else {
|
||
/* 错误 */
|
||
TCP_PRINT("Failed to extract JSON from RX buffer\r\n");
|
||
break;
|
||
}
|
||
}
|
||
|
||
/* 消费已处理的数据 */
|
||
if (rx_buffer.processed > 0) {
|
||
tcp_rx_buffer_consume(rx_buffer.processed);
|
||
#if TCP_DEBUG_EN
|
||
if (s_tcp_diag_rx_trace() != 0) {
|
||
s_tcp_log_rx_cache("TCP-after-consume");
|
||
}
|
||
#endif
|
||
} else if (rx_buffer.used > 0) {
|
||
/* 如果没有找到完整的JSON消息，但缓冲区中有数据 */
|
||
|
||
/* 检查缓冲区使用率是否过高 */
|
||
uint8_t buffer_usage_high = (rx_buffer.cap > 0U) &&
|
||
(rx_buffer.used > (rx_buffer.cap * 3U / 4U));
|
||
|
||
if (buffer_usage_high) {
|
||
/* 固件升级中保留半包 JSON，禁止丢弃（避免 Base64 被截断） */
|
||
if (system_filetransfer_is_active() != 0) {
|
||
TCP_PRINT("RX buffer high (%u/%u) during upgrade, keep partial JSON\r\n",
|
||
rx_buffer.used, rx_buffer.cap);
|
||
} else if (has_partial_json) {
|
||
/* 有部分JSON消息，但缓冲区快满了 */
|
||
/* 尝试查找缓冲区中是否有'{'字符，从那里开始保留数据 */
|
||
int first_brace_pos = -1;
|
||
|
||
/* 获取接收缓冲区互斥锁 */
|
||
if (rx_buffer_mutex != NULL) {
|
||
xSemaphoreTake(rx_buffer_mutex, portMAX_DELAY);
|
||
}
|
||
|
||
/* 查找第一个'{'字符 */
|
||
for (uint32_t i = 0; i < rx_buffer.used; i++) {
|
||
if (rx_buffer.buffer[i] == '{') {
|
||
first_brace_pos = i;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (first_brace_pos > 0) {
|
||
/* 找到'{'字符，清理之前的数据 */
|
||
TCP_PRINT("RX buffer high (%u/%u) with partial JSON, cleaning %u bytes before first '{'\r\n",
|
||
rx_buffer.used, rx_buffer.cap, first_brace_pos);
|
||
tcp_rx_buffer_consume(first_brace_pos);
|
||
} else if (first_brace_pos == -1) {
|
||
/* 没有找到'{'字符，清理一半的数据 */
|
||
TCP_PRINT("RX buffer high (%u/%u) with partial JSON but no '{', cleaning half of data\r\n",
|
||
rx_buffer.used, rx_buffer.cap);
|
||
uint32_t clean_len = rx_buffer.used / 2;
|
||
if (clean_len > 0) {
|
||
tcp_rx_buffer_consume(clean_len);
|
||
}
|
||
}
|
||
|
||
/* 释放接收缓冲区互斥锁 */
|
||
if (rx_buffer_mutex != NULL) {
|
||
xSemaphoreGive(rx_buffer_mutex);
|
||
}
|
||
} else {
|
||
/* 没有部分JSON消息，清理一半的数据 */
|
||
TCP_PRINT("RX buffer usage high (%u/%u), no partial JSON, cleaning half of data\r\n",
|
||
rx_buffer.used, rx_buffer.cap);
|
||
uint32_t clean_len = rx_buffer.used / 2;
|
||
if (clean_len > 0) {
|
||
tcp_rx_buffer_consume(clean_len);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if (json_buffer != NULL) {
|
||
vPortFree(json_buffer);
|
||
json_buffer = NULL;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @brief 处理接收到的数据
|
||
*/
|
||
void tcp_server_process_received_data(const char *data, uint16_t len)
|
||
{
|
||
tcp_message_t message;
|
||
//printf("tcp_message_t size is %d\r\n",sizeof(tcp_message_t));
|
||
if (data == NULL || len == 0) {
|
||
return;
|
||
}
|
||
|
||
/* 尝试解析JSON消息 */
|
||
if (tcp_parse_json_message(data, &message) == 0) {
|
||
#if TCP_DEBUG_EN
|
||
if (strcmp(message.command, CMD_FIRMWARE_UPGRADE) == 0) {
|
||
tcp_firmware_upgrade_log_io("RX", (const char *)data, (uint32_t)len);
|
||
}
|
||
if (system_filetransfer_is_active() != 0) {
|
||
if (strcmp(message.command, CMD_HEARTBEAT) == 0) {
|
||
tcp_free_message(&message);
|
||
return;
|
||
}
|
||
if (strcmp(message.command, CMD_FIRMWARE_UPGRADE) != 0) {
|
||
TCP_PRINT("Drop command '%s' during firmware upgrade\r\n", message.command);
|
||
tcp_free_message(&message);
|
||
return;
|
||
}
|
||
}
|
||
#endif
|
||
/* 解析成功，处理消息 */
|
||
tcp_process_received_message(&message);
|
||
|
||
/* 释放消息中动态分配的内存 */
|
||
tcp_free_message(&message);
|
||
|
||
/* 如果是心跳消息，更新最后收到心跳的时间 */
|
||
if (strcmp(message.command, CMD_HEARTBEAT) == 0) {
|
||
/* 获取互斥锁保护状态变量 */
|
||
if (tcp_server_mutex != NULL) {
|
||
xSemaphoreTake(tcp_server_mutex, portMAX_DELAY);
|
||
}
|
||
|
||
server_state.last_heartbeat_received_tick = server_state.tick_counter;
|
||
TCP_PRINT("Heartbeat received, updated last tick to %u\r\n", server_state.tick_counter);
|
||
|
||
/* 释放互斥锁 */
|
||
if (tcp_server_mutex != NULL) {
|
||
xSemaphoreGive(tcp_server_mutex);
|
||
}
|
||
}
|
||
} else {
|
||
/* 如果不是有效的JSON，打印原始数据 */
|
||
TCP_PRINT("Received raw data (%d bytes): %s\r\n", len, data);
|
||
}
|
||
}
|
||
|
||
static void tcp_server_send_ctrl(void)
|
||
{
|
||
uint8_t due = 0U;
|
||
|
||
if (system_filetransfer_is_active() != 0) {
|
||
return;
|
||
}
|
||
|
||
if (tcp_server_mutex != NULL) {
|
||
xSemaphoreTake(tcp_server_mutex, portMAX_DELAY);
|
||
}
|
||
|
||
if (server_state.is_client_connected) {
|
||
if (server_state.system_info_sent == 0U) {
|
||
due = 1U;
|
||
} else if (tcp_should_send_message(server_state.system_info_last_tick,
|
||
PERIODIC_REPORT_INTERVAL_SEC)) {
|
||
due = 1U;
|
||
}
|
||
|
||
if (due != 0U) {
|
||
server_state.system_info_sent = 1U;
|
||
server_state.system_info_last_tick = server_state.tick_counter;
|
||
server_state.gun_data_last_tick = server_state.tick_counter;
|
||
}
|
||
}
|
||
|
||
if (tcp_server_mutex != NULL) {
|
||
xSemaphoreGive(tcp_server_mutex);
|
||
}
|
||
|
||
if (due == 0U) {
|
||
return;
|
||
}
|
||
|
||
#if BLE_DEBUG_EN
|
||
if (COMM_LINK_IS_BLE(comm_link_get_type())) {
|
||
BT_PRINT("tcp_server: send SystemInfo+GunInfo\r\n");
|
||
}
|
||
#endif
|
||
|
||
tcp_server_send_message(TCP_MSG_SYSTEM_INFO);
|
||
|
||
#if BLE_DEBUG_EN
|
||
if (COMM_LINK_IS_BLE(comm_link_get_type())) {
|
||
vTaskDelay(pdMS_TO_TICKS(120));
|
||
} else
|
||
#endif
|
||
{
|
||
vTaskDelay(pdMS_TO_TICKS(20));
|
||
}
|
||
|
||
tcp_server_send_message(TCP_MSG_GUN_DATA);
|
||
}
|
||
/**
|
||
* @brief TCP服务器处理函数（周期性调用）- Socket API版本
|
||
*/
|
||
void tcp_server_process(void)
|
||
{
|
||
uint8_t should_check_heartbeat_timeout = 0;
|
||
static U32_T tick_counter = 0;
|
||
U32_T tick_counter_now = get_current_seconds();
|
||
|
||
comm_link_process();
|
||
|
||
/* 更新tick计数器 */
|
||
if (tcp_server_mutex != NULL) {
|
||
xSemaphoreTake(tcp_server_mutex, portMAX_DELAY);
|
||
}
|
||
|
||
if(tick_counter_now != tick_counter)
|
||
{
|
||
server_state.tick_counter++;
|
||
tick_counter = tick_counter_now;
|
||
}
|
||
|
||
/* 检查客户端连接状态（使用Socket API） */
|
||
int is_connected = comm_link_is_client_connected();
|
||
|
||
/* 更新服务器状态中的连接状态 */
|
||
if (server_state.is_client_connected != is_connected) {
|
||
server_state.is_client_connected = is_connected;
|
||
|
||
if (is_connected) {
|
||
/* 新客户端连接 */
|
||
server_state.system_info_sent = 0; /* 连接成功后需要第一时间发送系统信息 */
|
||
server_state.heartbeat_last_tick = 0;
|
||
server_state.system_info_last_tick = 0;
|
||
server_state.gun_data_last_tick = 0;
|
||
server_state.last_heartbeat_received_tick = 0;
|
||
TCP_PRINT("Client connected (Socket API)\r\n");
|
||
#if BLE_DEBUG_EN
|
||
if (COMM_LINK_IS_BLE(comm_link_get_type())) {
|
||
BT_PRINT("tcp_server: BLE client up, begin RX/TX\r\n");
|
||
}
|
||
#endif
|
||
} else {
|
||
/* 客户端断开连接 */
|
||
TCP_PRINT("Client disconnected (Socket API)\r\n");
|
||
/* 重置接收缓冲区 */
|
||
tcp_rx_buffer_reset();
|
||
}
|
||
}
|
||
|
||
/* 检查是否需要发送心跳 */
|
||
if (server_state.is_client_connected) {
|
||
/* 检查心跳超时（仅在收到过心跳后才检查） */
|
||
if (server_state.last_heartbeat_received_tick > 0) {
|
||
uint32_t heartbeat_timeout_elapsed = server_state.tick_counter - server_state.last_heartbeat_received_tick;
|
||
if (heartbeat_timeout_elapsed >= HEARTBEAT_TIMEOUT_SEC) {
|
||
should_check_heartbeat_timeout = 1;
|
||
TCP_PRINT("Heartbeat timeout detected! Elapsed: %u seconds\r\n", heartbeat_timeout_elapsed);
|
||
}
|
||
}
|
||
}
|
||
|
||
/* 释放互斥锁 */
|
||
if (tcp_server_mutex != NULL) {
|
||
xSemaphoreGive(tcp_server_mutex);
|
||
}
|
||
|
||
/* Socket API处理逻辑 */
|
||
|
||
/* 1. 接受新的客户端连接 */
|
||
if (!server_state.is_client_connected) {
|
||
int accept_result = comm_link_accept_client();
|
||
if (accept_result > 0) {
|
||
/* 新客户端连接成功 */
|
||
if (tcp_server_mutex != NULL) {
|
||
xSemaphoreTake(tcp_server_mutex, portMAX_DELAY);
|
||
}
|
||
server_state.is_client_connected = 1;
|
||
server_state.system_info_sent = 0;
|
||
server_state.heartbeat_last_tick = 0;
|
||
server_state.system_info_last_tick = 0;
|
||
server_state.gun_data_last_tick = 0;
|
||
server_state.last_heartbeat_received_tick = 0;
|
||
if (tcp_server_mutex != NULL) {
|
||
xSemaphoreGive(tcp_server_mutex);
|
||
}
|
||
}
|
||
}
|
||
|
||
/* 2. 接收数据（如果有客户端连接） */
|
||
if (server_state.is_client_connected) {
|
||
tcp_server_socket_receive_data();
|
||
}
|
||
|
||
/* 3. 处理接收缓冲区 */
|
||
if (system_filetransfer_is_active() != 0) {
|
||
tcp_rx_buffer_skip_leading_garbage();
|
||
}
|
||
tcp_server_process_rx_buffer();
|
||
if (system_filetransfer_is_active() != 0) {
|
||
uint8_t pass;
|
||
for (pass = 0U; pass < TCP_UPGRADE_RX_BURST_PASSES; pass++) {
|
||
comm_link_process();
|
||
(void)tcp_server_socket_receive_data();
|
||
tcp_server_process_rx_buffer();
|
||
}
|
||
}
|
||
|
||
/* 4. 处理心跳超时（固件升级期间不判心跳超时） */
|
||
system_filetransfer_poll_idle_timeout();
|
||
|
||
if (system_filetransfer_is_active() != 0) {
|
||
should_check_heartbeat_timeout = 0U;
|
||
}
|
||
|
||
if (should_check_heartbeat_timeout) {
|
||
TCP_PRINT("Disconnecting client due to heartbeat timeout\r\n");
|
||
|
||
/* 关闭客户端连接 */
|
||
comm_link_close_client();
|
||
|
||
/* 获取互斥锁保护状态变量 */
|
||
if (tcp_server_mutex != NULL) {
|
||
xSemaphoreTake(tcp_server_mutex, portMAX_DELAY);
|
||
}
|
||
|
||
server_state.is_client_connected = 0;
|
||
|
||
/* 释放互斥锁 */
|
||
if (tcp_server_mutex != NULL) {
|
||
xSemaphoreGive(tcp_server_mutex);
|
||
}
|
||
|
||
/* 重置接收缓冲区 */
|
||
tcp_rx_buffer_reset();
|
||
}
|
||
|
||
/* 5. 发送控制消息（心跳、系统信息等） */
|
||
tcp_server_send_ctrl();
|
||
}
|
||
|
||
|
||
|
||
#else /* TCP_DEBUG_EN */
|
||
|
||
/* 当TCP_DEBUG_EN未使能时，提供空实现以避免链接错误 */
|
||
err_t tcp_server_start(void) { return ERR_OK; }
|
||
void tcp_server_stop(void) { }
|
||
void tcp_server_process(void) { }
|
||
void tcp_server_send_heartbeat(void) { }
|
||
void tcp_server_send_system_info(void) { }
|
||
err_t tcp_server_send_json(const char *json_data, uint16_t len) { LWIP_UNUSED_ARG(json_data); LWIP_UNUSED_ARG(len); return ERR_OK; }
|
||
void tcp_server_process_received_data(const char *data, uint16_t len) { LWIP_UNUSED_ARG(data); LWIP_UNUSED_ARG(len); }
|
||
void tcp_server_task(void *arg) { LWIP_UNUSED_ARG(arg); }
|
||
|
||
void tcp_server_process(void) { /* CCU621_M compat stub */ }
|
||
#endif /* TCP_DEBUG_EN */ |