gaoro-xiao/TCP2UART
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 3 Wiki Activity

fix(mux): 修复MUX半帧丢失与发送路径静默失败

Browse Source
This commit is contained in:
😍
2026-04-18 18:48:38 +08:00
parent a0b27d34a0
commit 495fbe4298
4 changed files with 225 additions and 78 deletions
Download Patch File Download Diff File Expand all files Collapse all files
App/tcp_client.c
+9
View File
@@ -239,14 +239,23 @@ int tcp_client_send(uint8_t instance, const uint8_t *data, uint16_t len)
return -1;
}
if (tcp_sndbuf(ctx->pcb) < len) {
ctx->status.errors++;
return 0;
}
err = tcp_write(ctx->pcb, data, len, TCP_WRITE_FLAG_COPY);
if (err == ERR_MEM) {
ctx->status.errors++;
return 0;
}
if (err != ERR_OK) {
ctx->status.errors++;
return -1;
}
err = tcp_output(ctx->pcb);
if (err == ERR_MEM) {
ctx->status.errors++;
return 0;
}
if (err != ERR_OK) {
ctx->status.errors++;
return -1;
App/tcp_server.c
+9
View File
@@ -228,15 +228,24 @@ int tcp_server_send(uint8_t instance, const uint8_t *data, uint16_t len)
return -1;
}
if (tcp_sndbuf(ctx->client_pcb) < len) {
ctx->status.errors++;
return 0;
}
err = tcp_write(ctx->client_pcb, data, len, TCP_WRITE_FLAG_COPY);
if (err == ERR_MEM) {
ctx->status.errors++;
return 0;
}
if (err != ERR_OK) {
ctx->status.errors++;
return -1;
}
err = tcp_output(ctx->client_pcb);
if (err == ERR_MEM) {
ctx->status.errors++;
return 0;
}
if (err != ERR_OK) {
ctx->status.errors++;
return -1;
App/uart_trans.c
+112 -42
View File
@@ -43,6 +43,52 @@ static uint16_t ring_free(uint16_t head, uint16_t tail, uint16_t size)
return (uint16_t)(size - ring_used(head, tail, size) - 1u);
}
static bool ring_peek_byte(const uart_channel_ctx_t *ctx, uint16_t offset, uint8_t *out)
{
uint16_t head;
uint16_t tail;
if (ctx == NULL || out == NULL) {
return false;
}
head = ctx->rx_head;
tail = ctx->rx_tail;
if (offset >= ring_used(head, tail, UART_RX_RING_BUFFER_SIZE)) {
return false;
}
*out = ctx->rx_ring[(tail + offset) % UART_RX_RING_BUFFER_SIZE];
return true;
}
static bool ring_peek_span(const uart_channel_ctx_t *ctx, uint16_t offset, uint8_t *data, uint16_t len)
{
if (ctx == NULL || data == NULL) {
return false;
}
for (uint16_t i = 0u; i < len; ++i) {
if (!ring_peek_byte(ctx, (uint16_t)(offset + i), &data[i])) {
return false;
}
}
return true;
}
static void ring_drop_bytes(uart_channel_ctx_t *ctx, uint16_t len)
{
if (ctx == NULL) {
return;
}
while (len > 0u && ctx->rx_tail != ctx->rx_head) {
ctx->rx_tail = (uint16_t)((ctx->rx_tail + 1u) % UART_RX_RING_BUFFER_SIZE);
--len;
}
}
static int apply_uart_config(uart_channel_t channel)
{
uart_channel_ctx_t *ctx = &g_channels[channel];
@@ -297,63 +343,87 @@ void uart_trans_tx_cplt_handler(uart_channel_t channel)
bool uart_mux_try_extract_frame(uart_channel_t channel, uart_mux_frame_t *frame)
{
uint8_t sync_byte;
uart_channel_ctx_t *ctx;
uint8_t header[4];
uint8_t tail_byte;
uint16_t available;
uint16_t payload_len;
uint16_t sync_offset;
uint16_t total_len;
if (channel >= UART_CHANNEL_MAX || frame == NULL) {
return false;
}
available = uart_trans_rx_available(channel);
if (available < 6u) {
return false;
}
ctx = &g_channels[channel];
/* Scan for SYNC byte (0x7E) — discard non-matching bytes one at a time */
if (uart_trans_read(channel, &sync_byte, 1u) != 1u) {
return false;
}
if (sync_byte != UART_MUX_SYNC) {
return false;
}
/* Need at least: 2(len) + 1(src) + 1(dst) + payload + 1(tail) = 5 + payload */
available = uart_trans_rx_available(channel);
if (available < 4u) {
return false;
}
if (uart_trans_read(channel, header, sizeof(header)) != sizeof(header)) {
return false;
}
payload_len = (uint16_t)(((uint16_t)header[0] << 8) | header[1]);
if (payload_len > sizeof(frame->payload)) {
return false;
}
if (uart_trans_rx_available(channel) < (uint16_t)(payload_len + 1u)) {
return false;
}
frame->src_id = header[2];
frame->dst_mask = header[3];
frame->payload_len = payload_len;
if (payload_len > 0u) {
if (uart_trans_read(channel, frame->payload, payload_len) != payload_len) {
for (;;) {
available = uart_trans_rx_available(channel);
if (available < 6u) {
return false;
}
}
{
uint8_t tail = 0u;
if (uart_trans_read(channel, &tail, 1u) != 1u || tail != UART_MUX_TAIL) {
sync_offset = available;
for (uint16_t i = 0u; i < available; ++i) {
uint8_t byte = 0u;
if (!ring_peek_byte(ctx, i, &byte)) {
return false;
}
if (byte == UART_MUX_SYNC) {
sync_offset = i;
break;
}
}
if (sync_offset == available) {
ring_drop_bytes(ctx, available);
return false;
}
}
return true;
if (sync_offset > 0u) {
ring_drop_bytes(ctx, sync_offset);
available = (uint16_t)(available - sync_offset);
}
if (available < 6u) {
return false;
}
if (!ring_peek_span(ctx, 1u, header, sizeof(header))) {
return false;
}
payload_len = (uint16_t)(((uint16_t)header[0] << 8) | header[1]);
if (payload_len > sizeof(frame->payload)) {
ring_drop_bytes(ctx, 1u);
continue;
}
total_len = (uint16_t)(payload_len + 6u);
if (available < total_len) {
return false;
}
if (!ring_peek_byte(ctx, (uint16_t)(total_len - 1u), &tail_byte)) {
return false;
}
if (tail_byte != UART_MUX_TAIL) {
ring_drop_bytes(ctx, 1u);
continue;
}
frame->src_id = header[2];
frame->dst_mask = header[3];
frame->payload_len = payload_len;
if (payload_len > 0u) {
if (!ring_peek_span(ctx, 5u, frame->payload, payload_len)) {
return false;
}
}
ring_drop_bytes(ctx, total_len);
return true;
}
}
bool uart_mux_encode_frame(uint8_t src_id,