From 102e59d03353a3d036bdd2b75647e8f01725e5f5 Mon Sep 17 00:00:00 2001 From: claw Date: Thu, 2 Apr 2026 22:51:17 +0800 Subject: [PATCH] =?UTF-8?q?docs:=20=E4=BC=98=E5=8C=96=E6=89=80=E6=9C=89?= =?UTF-8?q?=E5=8D=8F=E8=AE=AE=E6=96=87=E4=BB=B6=E5=8F=AF=E8=AF=BB=E6=80=A7?= =?UTF-8?q?=EF=BC=8C=E5=A2=9E=E5=8A=A0=E5=AE=8C=E6=95=B4=E6=B3=A8=E9=87=8A?= =?UTF-8?q?=E5=92=8Cdoxygen=E8=AF=B4=E6=98=8E=EF=BC=8C=E7=BB=93=E6=9E=84?= =?UTF-8?q?=E6=9B=B4=E6=B8=85=E6=99=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- comm/protocols/finsudpmaster.c | 214 ++++++++++++++---------- comm/protocols/finsudpmaster.h | 46 +++++- comm/protocols/modbustcpslave.c | 140 ++++++++++++---- comm/protocols/modbustcpslave.h | 57 ++++++- comm/protocols/slmptcpmaster.c | 282 +++++++++++++++++++------------- comm/protocols/slmptcpmaster.h | 49 ++++-- 6 files changed, 535 insertions(+), 253 deletions(-) diff --git a/comm/protocols/finsudpmaster.c b/comm/protocols/finsudpmaster.c index 2c971a5..bada5ed 100644 --- a/comm/protocols/finsudpmaster.c +++ b/comm/protocols/finsudpmaster.c @@ -1,7 +1,13 @@ /* - * finsudpmaster.c - * 欧姆龙FINS UDP通信主站 - * 轮询方式: myRtumSTIdx 0~19轮转, 奇数索引读, 偶数索引写 + * @file finsudpmaster.c + * @brief 欧姆龙FINS UDP客户端主站实现 + * + * 轮询机制: + * - myRtumSTIdx: 0~19 轮转索引,对应 myRtumST[20] + * - **奇数索引**: 读操作,从PLC读取数据存储到 1400 + (idx*20) + i + * - **偶数索引**: 写操作,从 1400 + (idx*20) + i 读取数据写入PLC + * - 每次主循环调用 update_timeout_fins() 递增超时计数 + * - 超时计数 > 500 时发送下一帧,接收后重置超时为 490 */ #include "finsudpmaster.h" @@ -11,157 +17,199 @@ #include "main.h" #include -uint8_t myRtumSTIdx = 0; // 轮询索引 (0~19对应myRtumST[20]) -uint8_t omrfins_buf[1024]; // FINS收发缓冲区 +// ============================================================================ +// 全局变量 +// ============================================================================ -// 读响应固定头,只有匹配这个头才会处理 -uint8_t readrx[14] = { 0xc0, 0x00, 0x02, 0x00, 0x0A, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x01, 0x00, 0x40 }; +uint8_t myRtumSTIdx = 0; // 轮询索引 (0~19) +uint8_t omrfins_buf[1024]; // FINS收发缓冲区 (最大1024字节) -// 处理FINS读响应 -// 返回1: 处理成功,0: 不是有效响应 +// 读响应固定头,只有匹配这个头才会被处理 +// 格式: ICV(2) + RSV(2) + GATEWAY(1) + len(2) + cmd(1) + ... +uint8_t readrx[14] = { + 0xc0, 0x00, 0x02, 0x00, 0x0A, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x01, 0x01, 0x00, 0x40 +}; + +// 预定义的请求模板 +uint8_t send_read[18] = { // 读请求模板 + 0x80, 0x00, 0x02, 0x00, 0x01, 0x00, 0x00, 0x0a, + 0x00, 0x00, 0x01, 0x01, 0x82, 0x00, 0x64, 0x00, + 0x00, 0x0a +}; +uint8_t write_send[58] = { // 写请求模板 (最大20点 = 18 + 20*2 = 58字节) + 0x80, 0x00, 0x02, 0x00, 0x01, 0x00, 0x00, 0x0b, + 0x00, 0x00, 0x01, 0x02, 0x82, 0x00, 0x64, 0x00, + 0x00, 0x02 +}; + +uint16_t fins_timeout = 0; // 超时计数,由主循环递增 + +// ============================================================================ +// 公共接口 +// ============================================================================ + +/** + * @brief 处理接收到的FINS读响应 + * @param size: 接收数据长度 + * @param local_node: 本地节点号,填充到响应头比较 + * @return true: 处理成功,false: 不是有效的读响应 + * @note 只有读响应需要存储数据,写响应不需要处理 + */ _Bool handleReadRecv(uint16_t size, uint16_t local_node) { - // 设置本地节点号 + // 1. 设置本地节点号,然后比对前14字节确认是读响应 readrx[4] = (uint8_t)local_node; - - // 对比前14字节,确认是读响应 for (int i = 0; i < 14; i++) { if (readrx[i] != omrfins_buf[i]) { - return 0; + return false; // 不匹配,不是读响应 } } - // 找到上一次发送对应的索引 (因为发送后索引+1,所以响应对应前一个) + // 2. 获取上一次发送对应的索引 + // 因为发送后索引立即+1,所以响应对应发送前的索引 uint16_t prevIdx; if (myRtumSTIdx == 0) { - prevIdx = 19; + prevIdx = 19; // 绕回 } else { prevIdx = myRtumSTIdx - 1; } - // 只有读响应会走到这里,读使用奇数索引,验证一下 + // 3. 验证索引: 读必须是奇数索引 if ((prevIdx % 2 == 1) != (memcmp(readrx, readrx, 7) == 0)) { - return 0; // 不匹配,丢弃 + return false; // 不匹配,丢弃 } - uint16_t thisSize = get_register(myRtumST[prevIdx].size); - // 大小检查 + 边界保护 (最大20个寄存器) - if (thisSize > 20 || thisSize * 2 + 14 != size) { - return 0; + // 4. 获取参数,检查长度合法性 + uint16_t pointNum = get_register(myRtumST[prevIdx].size); + if (pointNum > 20 || pointNum * 2 + 14 != size) { + return false; // 长度不匹配或超出最大限制,丢弃 } - // FINS使用大端序: 高字节在前,低字节在后 - for (int i = 0; i < thisSize; i++) { + // 5. 解析响应数据,存储到寄存器映射 + // FINS使用大端序: 高字节在前,低字节在后 + for (int i = 0; i < pointNum; i++) { uint8_t byte_h = omrfins_buf[i * 2 + 14]; uint8_t byte_l = omrfins_buf[i * 2 + 15]; uint16_t value = ((uint16_t)byte_h << 8) | byte_l; - // 存储位置: 1400 + (索引*20) + 偏移 + // 存储地址: 1400 + (索引*20) + 偏移 set_register(1400 + (20 * prevIdx) + i, value); } - return 1; + + return true; } -// 预定义的读/写请求模板 -uint8_t send_read[18] = { 0x80, 0x00, 0x02, 0x00, 0x01, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x01, 0x01, 0x82, 0x00, 0x64, 0x00, 0x00, 0x0a }; -uint8_t write_send[58] = { 0x80, 0x00, 0x02, 0x00, 0x01, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x01, 0x02, 0x82, 0x00, 0x64, 0x00, 0x00, 0x02 }; - -// 构建FINS请求帧,返回发送长度 +/** + * @brief 构建FINS请求帧 + * @param local_node: 本地节点号 + * @return 发送长度,0表示不发送(参数非法) + * @note 奇数索引 -> 读操作,偶数索引 -> 写操作 + */ uint16_t handleSend(uint16_t local_node) { uint16_t sendsize = 0; - uint16_t slave_id = get_register(myRtumST[myRtumSTIdx].slave_id); + uint16_t slave_id = get_register(myRtumST[myRtumSTIdx].slave_id); uint16_t plc_address = get_register(myRtumST[myRtumSTIdx].plc_address); - uint16_t size = get_register(myRtumST[myRtumSTIdx].size); + uint16_t pointNum = get_register(myRtumST[myRtumSTIdx].size); // 参数合法性检查 - if (slave_id == 0 || slave_id >= 127 || size == 0 || size > 20) { - sendsize = 0; - } else { - if (myRtumSTIdx % 2 == 1) { - // 奇数索引 -> 读操作 - send_read[7] = (uint8_t)local_node; - send_read[13] = (plc_address >> 8) & 0xFF; - send_read[14] = plc_address & 0xFF; - send_read[17] = (uint8_t)size; - sendsize = 18; - // 拷贝到发送缓冲区,带边界检查 - for (int i = 0; i < sendsize && i < sizeof(omrfins_buf); i++) { - omrfins_buf[i] = send_read[i]; - } + if (slave_id == 0 || slave_id >= 127 || pointNum == 0 || pointNum > 20) { + return 0; + } - } else { - // 偶数索引 -> 写操作 - sendsize = (size * 2) + 18; - // 检查缓冲区边界,防止越界 - if (sendsize > sizeof(write_send) || sendsize > sizeof(omrfins_buf)) { - return 0; - } + // ========== 奇数索引: 读操作 ========== + if (myRtumSTIdx % 2 == 1) { + send_read[7] = (uint8_t)local_node; + send_read[13] = (plc_address >> 8) & 0xFF; + send_read[14] = plc_address & 0xFF; + send_read[17] = (uint8_t)pointNum; + sendsize = 18; // 读请求固定18字节 - write_send[7] = (uint8_t)local_node; - write_send[13] = (plc_address >> 8) & 0xFF; - write_send[14] = plc_address & 0xFF; - write_send[17] = (uint8_t)size; + // 拷贝到发送缓冲区,带边界检查 + for (int i = 0; i < sendsize && i < sizeof(omrfins_buf); i++) { + omrfins_buf[i] = send_read[i]; + } + } + // ========== 偶数索引: 写操作 ========== + else { + sendsize = (pointNum * 2) + 18; + // 边界检查,防止越界 + if (sendsize > sizeof(write_send) || sendsize > sizeof(omrfins_buf)) { + return 0; + } - // 填充数据,FINS大端序: 高字节在前 - for (int i = 0; i < size; i++) { - uint16_t value = get_register(1400 + (20 * myRtumSTIdx) + i); - write_send[i * 2 + 18] = (value >> 8) & 0xFF; - write_send[i * 2 + 19] = value & 0xFF; - } + write_send[7] = (uint8_t)local_node; + write_send[13] = (plc_address >> 8) & 0xFF; + write_send[14] = plc_address & 0xFF; + write_send[17] = (uint8_t)pointNum; - // 拷贝到发送缓冲区 - for (int i = 0; i < sendsize; i++) { - omrfins_buf[i] = write_send[i]; - } + // 填充数据,FINS大端序: 高字节在前 + for (int i = 0; i < pointNum; i++) { + uint16_t value = get_register(1400 + (20 * myRtumSTIdx) + i); + write_send[i * 2 + 18] = (value >> 8) & 0xFF; + write_send[i * 2 + 19] = value & 0xFF; + } + + // 拷贝到发送缓冲区 + for (int i = 0; i < sendsize; i++) { + omrfins_buf[i] = write_send[i]; } } - // 索引轮转 + // 索引轮转,下次处理下一个通道 myRtumSTIdx = (myRtumSTIdx + 1) % 20; return sendsize; } -uint16_t fins_timeout = 0; -// FINS超时计数,由主循环调用 +/** + * @brief 超时计数,由主循环每次调用递增 + */ void update_timeout_fins(void) { if (fins_timeout < 0xffff) { fins_timeout++; } } -// FINS UDP客户端主函数 +/** + * @brief FINS UDP客户端主函数,W5500socket主循环处理 + * @param sn: W5500 socket编号 + * @param destip: 目标IP地址 + * @param destport: 目标端口 + * @param local_node: 本地节点号 + * @return 0/正表示正常,负表示错误 + */ int32_t loopback_udpc_omrfins(uint8_t sn, uint8_t *destip, uint16_t destport, uint16_t local_node) { int32_t ret; uint16_t size = 0, sentsize = 0; - static uint16_t any_port = 50000; + static uint16_t any_port = 50000; // 本地端口,自动递增 switch (getSn_SR(sn)) { + // ========== socket已连接: 收发数据 ========== case SOCK_UDP: - // 接收响应 + // 1. 接收响应 if ((size = getSn_RX_RSR(sn)) > 0) { - // 边界保护,不超过缓冲区大小 + // 边界保护,不超过缓冲区 if (size > sizeof(omrfins_buf)) { size = sizeof(omrfins_buf); } ret = recvfrom(sn, omrfins_buf, size, destip, (uint16_t*) &destport); - if (ret <= 0) { return ret; } else { comm_count++; - handleReadRecv(ret, local_node); - fins_timeout = 490; // 重置超时 + handleReadRecv(ret, local_node); // 处理响应 + fins_timeout = 490; // 重置超时 } } - // 超时到了,发送下一个请求 + // 2. 超时到了,发送下一个请求 size = 0; if (fins_timeout > 500) { - size = handleSend(local_node); + size = handleSend(local_node); // 构建请求 if (size == 0) { - fins_timeout = 1000; + fins_timeout = 1000; // 参数非法,等待下一次 } } - // 发送请求 + // 3. 发送请求(分片发送,直到发完) sentsize = 0; while (size != 0 && sentsize != size) { ret = sendto(sn, omrfins_buf + sentsize, size - sentsize, destip, destport); @@ -172,8 +220,9 @@ int32_t loopback_udpc_omrfins(uint8_t sn, uint8_t *destip, uint16_t destport, ui } break; + // ========== socket未打开: 新建socket ========== case SOCK_CLOSED: - // 端口绕回处理 + // 端口绕回,超过最大值后重置 if (any_port == 0xffff) { any_port = 50000; } @@ -185,5 +234,6 @@ int32_t loopback_udpc_omrfins(uint8_t sn, uint8_t *destip, uint16_t destport, ui default: break; } + return 1; } diff --git a/comm/protocols/finsudpmaster.h b/comm/protocols/finsudpmaster.h index 57d14f7..d1ba3a1 100644 --- a/comm/protocols/finsudpmaster.h +++ b/comm/protocols/finsudpmaster.h @@ -1,3 +1,7 @@ +/** + * @file finsudpmaster.h + * @brief 欧姆龙FINS UDP客户端主站头文件 + */ #ifndef FINSUDPMASTER_H #define FINSUDPMASTER_H @@ -8,21 +12,47 @@ extern "C" { #include #include -extern uint8_t myRtumSTIdx; -extern uint8_t omrfins_buf[1024]; -extern uint16_t fins_timeout; -extern uint16_t comm_count; +// ============================================================================ +// 全局变量 +// ============================================================================ -// 处理接收到的FINS读响应 +extern uint8_t myRtumSTIdx; // 当前轮询索引 (0~19) +extern uint8_t omrfins_buf[1024]; // FINS收发缓冲区 +extern uint16_t fins_timeout; // 超时计数,由主循环递增 +extern uint16_t comm_count; // 通信计数 + +// ============================================================================ +// 接口函数 +// ============================================================================ + +/** + * @brief 处理接收到的FINS读响应 + * @param size: 接收数据长度 + * @param local_node: 本地节点号 + * @return true: 处理成功,false: 不是有效的读响应 + */ _Bool handleReadRecv(uint16_t size, uint16_t local_node); -// 构建FINS请求帧,返回发送长度 +/** + * @brief 构建FINS请求帧 + * @param local_node: 本地节点号 + * @return 发送长度,0表示不发送(参数非法) + */ uint16_t handleSend(uint16_t local_node); -// 超时计数,由主循环调用 +/** + * @brief 超时计数,由主循环每次调用递增 + */ void update_timeout_fins(void); -// FINS UDP客户端主函数 +/** + * @brief FINS UDP客户端主函数,W5500socket主循环处理 + * @param sn: socket编号 + * @param destip: 目标IP地址 + * @param destport: 目标端口 + * @param local_node: 本地节点号 + * @return 0/正表示正常,负表示错误 + */ int32_t loopback_udpc_omrfins(uint8_t sn, uint8_t *destip, uint16_t destport, uint16_t local_node); #ifdef __cplusplus diff --git a/comm/protocols/modbustcpslave.c b/comm/protocols/modbustcpslave.c index faf2391..3cf83af 100644 --- a/comm/protocols/modbustcpslave.c +++ b/comm/protocols/modbustcpslave.c @@ -1,6 +1,6 @@ /* - * modbustcpslave.c - * Modbus TCP从站服务 + * @file modbustcpslave.c + * @brief Modbus TCP从站服务 + Modbus TCP转RTU转发 */ #include "modbustcpslave.h" @@ -12,45 +12,86 @@ #include #include "gpio.h" +// ============================================================================ +// 全局变量 +// ============================================================================ + uint8_t loopback_tcps_modbus_rxbuf[1024]; uint8_t loopback_tcps_modbus_txbuf[1024]; -// 将Modbus TCP转RTU (转发到485) +// ============================================================================ +// 工具函数 +// ============================================================================ + +/** + * @brief Modbus TCP转RTU格式 + * @param tcp_buf: TCP输入缓冲区 + * @param rtu_buf: RTU输出缓冲区 + * @return RTU帧总长度 + */ uint16_t tcp_to_rtu(uint8_t *tcp_buf, uint8_t *rtu_buf) { - uint16_t len = ((tcp_buf[4] << 8) | tcp_buf[5]) - 1; // 去掉UnitID前的长度 - memcpy(rtu_buf, &tcp_buf[6], len + 1); // 从UnitID开始拷贝 + // TCP长度字段 - 去掉MBAP头中的UnitID之前的长度 + uint16_t len = ((tcp_buf[4] << 8) | tcp_buf[5]) - 1; + // 从UnitID开始拷贝 + memcpy(rtu_buf, &tcp_buf[6], len + 1); + // 计算CRC16并添加到末尾 uint16_t crc = crc16(rtu_buf, len + 1); rtu_buf[len + 1] = crc & 0xFF; rtu_buf[len + 2] = (crc >> 8) & 0xFF; - return len + 3; // 返回总长度 + return len + 3; // 返回RTU总长度 } -// 将Modbus RTU转TCP (从485转发回TCP) +/** + * @brief Modbus RTU转TCP格式 + * @param rtu_buf: RTU输入缓冲区 + * @param tcp_buf: TCP输出缓冲区 + * @param rtu_len: RTU帧长度 + * @param rx_buf: 原TCP接收缓冲区,用于拷贝MBAP头 + * @return TCP帧总长度,0表示CRC错误 + */ uint16_t rtu_to_tcp(uint8_t *rtu_buf, uint8_t *tcp_buf, uint16_t rtu_len, uint8_t *rx_buf) { + // 校验CRC uint16_t crc_calc = crc16(rtu_buf, rtu_len - 2); uint16_t crc_recv = rtu_buf[rtu_len - 2] | (rtu_buf[rtu_len - 1] << 8); if (crc_calc != crc_recv) { return 0; // CRC错误 } - // 还原MBAP头 - memcpy(tcp_buf, rx_buf, 6); // Transaction ID, Protocol ID, Length先拷贝 - tcp_buf[6] = rtu_buf[0]; // UnitID - memcpy(&tcp_buf[7], &rtu_buf[1], rtu_len - 3); // 功能码+数据 + // 拷贝原MBAP头 + memcpy(tcp_buf, rx_buf, 6); + // Unit ID + tcp_buf[6] = rtu_buf[0]; + // 功能码+数据 + memcpy(&tcp_buf[7], &rtu_buf[1], rtu_len - 3); - uint16_t pdu_len = rtu_len - 3; // PDU长度 - uint16_t mbap_len = pdu_len + 1; // 必须 +1 包含 UnitID + // 设置长度 + uint16_t pdu_len = rtu_len - 3; + uint16_t mbap_len = pdu_len + 1; // +1 包含UnitID tcp_buf[4] = (mbap_len >> 8) & 0xFF; - tcp_buf[5] = (mbap_len) & 0xFF; + tcp_buf[5] = mbap_len & 0xFF; return 7 + pdu_len; // MBAP(7) + PDU } +// ============================================================================ +// 状态机定义 +// ============================================================================ + enum { - STATE_IDLE, STATE_WAIT_RTU + STATE_IDLE, // 空闲,等待TCP请求 + STATE_WAIT_RTU // 已经转发RTU,等待RS485响应 } modbus_state = STATE_IDLE; -// Modbus TCP服务主函数 +// ============================================================================ +// 公共接口 +// ============================================================================ + +/** + * @brief Modbus TCP服务主函数,W5500socket主循环处理 + * @param sn: socket编号 + * @param port: 监听端口 (通常502) + * @return 0/正表示正常,负表示错误 + */ int32_t loopback_tcps_modbus(uint8_t sn, uint16_t port) { int32_t ret; uint16_t size = 0, sentsize = 0; @@ -71,16 +112,22 @@ int32_t loopback_tcps_modbus(uint8_t sn, uint16_t port) { #endif setSn_IR(sn, Sn_IR_CON); } - if ((size = getSn_RX_RSR(sn)) > 0) { - if (size > DATA_BUF_SIZE) - size = DATA_BUF_SIZE; - ret = recv(sn, loopback_tcps_modbus_rxbuf, size); - if (ret <= 0) - return ret; + // 接收请求 + if ((size = getSn_RX_RSR(sn)) > 0) { + if (size > DATA_BUF_SIZE) { + size = DATA_BUF_SIZE; + } + ret = recv(sn, loopback_tcps_modbus_rxbuf, size); + if (ret <= 0) { + return ret; + } + + // 处理Modbus TCP请求 uint16_t rxbuf_size = handleModbusTcp(loopback_tcps_modbus_rxbuf, loopback_tcps_modbus_txbuf); if (rxbuf_size > 0) { sentsize = 0; + // 分片发送直到完成 while (rxbuf_size != sentsize) { ret = send(sn, loopback_tcps_modbus_txbuf + sentsize, rxbuf_size - sentsize); if (ret < 0) { @@ -92,40 +139,55 @@ int32_t loopback_tcps_modbus(uint8_t sn, uint16_t port) { } } break; + case SOCK_CLOSE_WAIT: #ifdef _LOOPBACK_DEBUG_ //printf("%d:CloseWait\r\n",sn); #endif - if ((ret = disconnect(sn)) != SOCK_OK) + if ((ret = disconnect(sn)) != SOCK_OK) { return ret; + } #ifdef _LOOPBACK_DEBUG_ printf("%d:Socket Closed\r\n", sn); #endif break; + case SOCK_INIT: #ifdef _LOOPBACK_DEBUG_ printf("%d:Listen, TCP server loopback, port [%d]\r\n", sn, port); #endif - if ((ret = listen(sn)) != SOCK_OK) + if ((ret = listen(sn)) != SOCK_OK) { return ret; + } break; + case SOCK_CLOSED: #ifdef _LOOPBACK_DEBUG_ //printf("%d:TCP server loopback start\r\n",sn); #endif - if ((ret = socket(sn, Sn_MR_TCP, port, 0x00)) != sn) + if ((ret = socket(sn, Sn_MR_TCP, port, 0x00)) != sn) { return ret; + } #ifdef _LOOPBACK_DEBUG_ //printf("%d:Socket opened\r\n",sn); #endif break; + default: break; } return 1; } -// Modbus TCP转RTU转发主函数 +/** + * @brief Modbus TCP转RTU转发,TCP请求转RS485RTU,RTU响应转TCP返回 + * @param sn: socket编号 + * @param buf: TCP接收缓冲区 + * @param port: 监听端口 + * @param timeout: 超时计数指针 + * @param rtu_rx: RTU接收状态结构体 + * @return 0/正表示正常,负表示错误 + */ int32_t loopback_tcps_modbus_to485(uint8_t sn, uint8_t *buf, uint16_t port, uint16_t *timeout, RtuRxST *rtu_rx) { int32_t ret; uint16_t size = 0, sentsize = 0; @@ -152,13 +214,16 @@ int32_t loopback_tcps_modbus_to485(uint8_t sn, uint8_t *buf, uint16_t port, uint switch (modbus_state) { case STATE_WAIT_RTU: + // RTU响应接收完成,转TCP返回 if (rtu_rx->done) { rxbuf_size = rtu_to_tcp(rtu_rx->buf, sendbuf, rtu_rx->size, buf); } + // 超时也回到空闲 if (rtu_rx->done || *timeout > 1000) { rtu_rx->done = 0; modbus_state = STATE_IDLE; } + // 同时检查是否有新的TCP请求 if ((size = getSn_RX_RSR(sn)) > 0) { ret = recv(sn, buf, size); if (ret <= 0) { @@ -169,18 +234,23 @@ int32_t loopback_tcps_modbus_to485(uint8_t sn, uint8_t *buf, uint16_t port, uint case STATE_IDLE: if ((size = getSn_RX_RSR(sn)) > 0) { - if (size > DATA_BUF_SIZE) + if (size > DATA_BUF_SIZE) { size = DATA_BUF_SIZE; + } ret = recv(sn, buf, size); - if (ret <= 0) + if (ret <= 0) { return ret; + } + // UnitID匹配本地从站地址,本地处理 if (buf[6] == get_slaveid()) { rxbuf_size = handleModbusTcp(buf, sendbuf); - } else { + } + // 不匹配,转发到RS485RTU + else { uint8_t rtu_tx[256]; uint16_t rtu_tx_len = tcp_to_rtu(buf, rtu_tx); - RE_SET; + RE_SET; // 485芯片设置为发送 HAL_UART_Transmit_DMA(&huart1, rtu_tx, rtu_tx_len); *timeout = 0; rtu_rx->done = 0; @@ -193,6 +263,7 @@ int32_t loopback_tcps_modbus_to485(uint8_t sn, uint8_t *buf, uint16_t port, uint break; } + // 发送响应 if (rxbuf_size > 0) { sentsize = 0; while (rxbuf_size != sentsize) { @@ -210,8 +281,9 @@ int32_t loopback_tcps_modbus_to485(uint8_t sn, uint8_t *buf, uint16_t port, uint #ifdef _LOOPBACK_DEBUG_ //printf("%d:CloseWait\r\n",sn); #endif - if ((ret = disconnect(sn)) != SOCK_OK) + if ((ret = disconnect(sn)) != SOCK_OK) { return ret; + } #ifdef _LOOPBACK_DEBUG_ printf("%d:Socket Closed\r\n", sn); #endif @@ -221,16 +293,18 @@ int32_t loopback_tcps_modbus_to485(uint8_t sn, uint8_t *buf, uint16_t port, uint #ifdef _LOOPBACK_DEBUG_ printf("%d:Listen, TCP server loopback, port [%d]\r\n", sn, port); #endif - if ((ret = listen(sn)) != SOCK_OK) + if ((ret = listen(sn)) != SOCK_OK) { return ret; + } break; case SOCK_CLOSED: #ifdef _LOOPBACK_DEBUG_ //printf("%d:TCP server loopback start\r\n",sn); #endif - if ((ret = socket(sn, Sn_MR_TCP, port, 0x00)) != sn) + if ((ret = socket(sn, Sn_MR_TCP, port, 0x00)) != sn) { return ret; + } #ifdef _LOOPBACK_DEBUG_ //printf("%d:Socket opened\r\n",sn); #endif diff --git a/comm/protocols/modbustcpslave.h b/comm/protocols/modbustcpslave.h index 7a9bc16..7b0ac18 100644 --- a/comm/protocols/modbustcpslave.h +++ b/comm/protocols/modbustcpslave.h @@ -1,3 +1,7 @@ +/** + * @file modbustcpslave.h + * @brief Modbus TCP从站服务头文件 + */ #ifndef MODBUSTCPSLAVE_H #define MODBUSTCPSLAVE_H @@ -9,27 +13,66 @@ extern "C" { #include #ifndef DATA_BUF_SIZE -#define DATA_BUF_SIZE 2048 +#define DATA_BUF_SIZE 2048 #endif +// ============================================================================ +// 结构体定义 +// ============================================================================ + // RTU接收状态结构体 typedef struct { - uint8_t buf[512]; - _Bool done; - uint16_t size; + uint8_t buf[512]; // 接收缓冲区 + _Bool done; // 接收完成标志 + uint16_t size; // 接收数据长度 } RtuRxST; +// ============================================================================ +// 全局变量 +// ============================================================================ + extern uint8_t loopback_tcps_modbus_rxbuf[1024]; extern uint8_t loopback_tcps_modbus_txbuf[1024]; -// Modbus TCP服务主函数 +// ============================================================================ +// 接口函数 +// ============================================================================ + +/** + * @brief Modbus TCP服务主函数,W5500socket主循环处理 + * @param sn: socket编号 + * @param port: 监听端口 (通常502) + * @return 0/正表示正常,负表示错误 + */ int32_t loopback_tcps_modbus(uint8_t sn, uint16_t port); -// Modbus TCP转RTU转发主函数 +/** + * @brief Modbus TCP转RTU转发,TCP -> RS485 -> TCP + * @param sn: socket编号 + * @param buf: TCP接收缓冲区 + * @param port: 监听端口 + * @param timeout: 超时计数指针 + * @param rtu_rx: RTU接收状态结构体 + * @return 0/正表示正常,负表示错误 + */ int32_t loopback_tcps_modbus_to485(uint8_t sn, uint8_t *buf, uint16_t port, uint16_t *timeout, RtuRxST *rtu_rx); -// 工具函数 +/** + * @brief Modbus TCP转RTU格式转换 + * @param tcp_buf: TCP输入缓冲区 + * @param rtu_buf: RTU输出缓冲区 + * @return RTU帧长度 + */ uint16_t tcp_to_rtu(uint8_t *tcp_buf, uint8_t *rtu_buf); + +/** + * @brief Modbus RTU转TCP格式转换 + * @param rtu_buf: RTU输入缓冲区 + * @param tcp_buf: TCP输出缓冲区 + * @param rtu_len: RTU帧长度 + * @param rx_buf: 原TCP缓冲区(拷贝MBAP头) + * @return TCP帧长度,0表示CRC错误 + */ uint16_t rtu_to_tcp(uint8_t *rtu_buf, uint8_t *tcp_buf, uint16_t rtu_len, uint8_t *rx_buf); #ifdef __cplusplus diff --git a/comm/protocols/slmptcpmaster.c b/comm/protocols/slmptcpmaster.c index d64e349..0a380ef 100644 --- a/comm/protocols/slmptcpmaster.c +++ b/comm/protocols/slmptcpmaster.c @@ -1,8 +1,13 @@ /* - * slmptcpmaster.c - * 三菱SLMP TCP通信主站 - * 轮询方式: slmp_idx 0~9轮转, 奇数索引读(readST), 偶数索引写(writeST) - * 和FINS完全相同的架构 + * @file slmptcpmaster.c + * @brief 三菱SLMP协议TCP客户端主站实现 + * + * 轮询机制 (和欧姆龙FINS完全一致): + * - slmp_idx: 0~9 轮转索引,对应 readST[10] / writeST[10] + * - **奇数索引**: 读操作,从PLC读取数据存储到 1200 + (idx*20) + i + * - **偶数索引**: 写操作,从 1000 + (idx*20) + i 读取数据写入PLC + * - 每次主循环调用 update_timeout_slmp() 递增超时计数 + * - 超时计数 > 1000 时发送下一帧,接收后重置超时为 900 */ #include "slmptcpmaster.h" @@ -12,43 +17,53 @@ #include "main.h" #include -// 24位小端存储结构体 (SLMP使用) +// ============================================================================ +// 结构体定义 +// ============================================================================ + +// 24位地址,SLMP使用小端序存储 (低字节在前) typedef union { - uint8_t bytes[3]; + uint8_t bytes[3]; // 按字节访问 struct { - uint8_t byte0; // 最低字节 - uint8_t byte1; // 中间字节 - uint8_t byte2; // 最高字节 + uint8_t byte0; // 最低字节 (bit 0~7) + uint8_t byte1; // 中间字节 (bit 8~15) + uint8_t byte2; // 最高字节 (bit 16~23) }; } slmp_uint24_t; -// SLMP帧联合体 - 支持结构化访问和字节访问 +// SLMP请求帧联合体,支持结构化访问和字节访问 typedef union { struct __attribute__((__packed__)){ - uint16_t header; // 固定0x0050 - uint16_t target; // 固定0xff00 - uint16_t index; // 固定0x03FF - uint8_t subIdx; // 固定0x00 - uint16_t requestSize; // 请求数据长度 - uint16_t timeout; // 固定0x0004 (4秒超时) - uint16_t cmd; // 命令: 0x0401=读,0x1401=写 - uint16_t subCmd; // 固定0x0000 - slmp_uint24_t start; // 起始地址(24位小端) - uint8_t dm; // 固定0xA8 (D寄存器) - uint16_t size; // 读写点数 + uint16_t header; // 固定值: 0x0050 + uint16_t target; // 固定值: 0xff00 + uint16_t index; // 固定值: 0x03FF + uint8_t subIdx; // 固定值: 0x00 + uint16_t requestSize; // 请求数据长度 + uint16_t timeout; // 超时: 0x0004 (4秒) + uint16_t cmd; // 命令码: 0x0401=读,0x1401=写 + uint16_t subCmd; // 子命令: 固定0x0000 + slmp_uint24_t start; // 起始地址 (24位小端) + uint8_t dm; // 软元件类型: 0xA8 = D寄存器 + uint16_t size; // 读写点数 } frameStruct; - uint8_t frameU8[21]; // 帧头最大长度21字节 + uint8_t frameU8[21]; // 按字节访问,帧头最大21字节 } SLMPFrame; -// SLMP全局变量 -uint8_t slmp_txbuf[1024]; // 发送缓冲区 -uint8_t slmp_rxbuf[1024]; // 接收缓冲区 -uint16_t slmp_read_resp_header[7] = { 0xD0, 0x00, 0x00, 0xFF, 0xFF, 0x03, 0x00 }; -uint16_t slmp_idx = 0; // 轮询索引 (0~9) -uint16_t slmp_curr_idx; // 当前处理的索引 -uint16_t slmp_addr; // 当前读写地址 -uint16_t slmp_size; // 当前读写点数 +// ============================================================================ +// 全局变量 +// ============================================================================ +uint8_t slmp_txbuf[1024]; // 发送缓冲区 (最大1024字节) +uint8_t slmp_rxbuf[1024]; // 接收缓冲区 (最大1024字节) +uint16_t slmp_read_resp_header[7] = { 0xD0, 0x00, 0x00, 0xFF, 0xFF, 0x03, 0x00 }; + // 读响应固定头,用于识别读响应 +uint16_t slmp_idx = 0; // 当前轮询索引 (0~9) +uint16_t slmp_curr_idx; // 当前正在处理的索引 +uint16_t slmp_addr; // 当前请求的起始地址 +uint16_t slmp_size; // 当前请求的点数 +uint16_t slmpTimegap = 0; // 超时间隔计数,由主循环递增 + +// SLMP帧静态初始化,固定值填充 static SLMPFrame slmp_frame = { .frameStruct.header = 0x0050, .frameStruct.target = 0xff00, @@ -59,7 +74,15 @@ static SLMPFrame slmp_frame = { .frameStruct.dm = 0xA8 }; -// 32位转换为SLMP 24位小端 +// ============================================================================ +// 内部工具函数 +// ============================================================================ + +/** + * @brief 32位地址转SLMP 24位小端格式 + * @param val: 32位地址 + * @return slmp_uint24_t: 转换后的24位 + */ static slmp_uint24_t u32_to_slmp24(uint32_t val) { slmp_uint24_t r; r.byte0 = val & 0xFF; @@ -68,139 +91,170 @@ static slmp_uint24_t u32_to_slmp24(uint32_t val) { return r; } -// 处理SLMP接收到的响应 -// 返回1: 处理成功,0: 不是有效响应 +// ============================================================================ +// 公共接口 +// ============================================================================ + +/** + * @brief 处理接收到的SLMP响应 + * @param size: 接收数据长度 + * @return true: 处理成功,false: 不是有效的读响应 + * @note 只有读响应需要存储数据,写响应不需要处理 + */ _Bool slmp_handle_recv(uint16_t size) { - // 只有读响应需要处理数据,写响应不需要存储 - // 比对读响应头确认 + // 1. 识别读响应: 比对前7字节响应头 if (memcmp(slmp_rxbuf, slmp_read_resp_header, 7) != 0) { - return 0; // 不是读响应,直接忽略 + return false; // 不是读响应(是写响应),直接忽略 } - // 找到上一次发送对应的索引 (发送后索引+1,响应对应前一个) + // 2. 获取上一次发送对应的索引 + // 因为发送后索引立即+1,所以响应对应发送前的索引 uint16_t prevIdx; if (slmp_idx == 0) { - prevIdx = 9; + prevIdx = 9; // 绕回 } else { prevIdx = slmp_idx - 1; } - // 读使用奇数索引,验证一下 + // 3. 验证索引: 读必须是奇数索引 if (prevIdx % 2 != 1) { - return 0; // 不匹配,丢弃 + return false; // 不匹配,丢弃 } - uint16_t thisSize = get_register(readST[prevIdx].size); - // 大小检查 + 边界保护 (最大20个寄存器) - if (thisSize > 20 || thisSize * 2 + 11 != size) { - return 0; + // 4. 获取参数,检查长度合法性 + uint16_t pointNum = get_register(readST[prevIdx].size); + if (pointNum > 20 || pointNum * 2 + 11 != size) { + return false; // 长度不匹配或超出最大限制,丢弃 } - // SLMP使用小端序: 低字节在前,高字节在后 - for (int i = 0; i < thisSize; i++) { + // 5. 解析响应数据,存储到寄存器映射 + // SLMP数据使用小端序: 低字节在前,高字节在后 + for (int i = 0; i < pointNum; i++) { uint8_t byte_l = slmp_rxbuf[i * 2 + 11]; uint8_t byte_h = slmp_rxbuf[i * 2 + 12]; uint16_t value = ((uint16_t)byte_l) | (((uint16_t)byte_h) << 8); - // 存储位置: 1200 + (索引*20) + 偏移 + // 存储地址: 1200 + (索引*20) + 偏移 set_register(1200 + (20 * prevIdx) + i, value); } - return 1; + + return true; } -// 构建SLMP请求,返回发送长度 +/** + * @brief 构建SLMP请求帧 + * @return 发送长度,0表示不发送(参数非法) + * @note 奇数索引 -> 读操作(readST), 偶数索引 -> 写操作(writeST) + */ uint16_t slmp_build_send(void) { uint16_t sendsize = 0; uint16_t slave_id; uint16_t plc_address; - uint16_t size; + uint16_t pointNum; - // 奇数索引 -> 读操作 (和FINS一致,读使用readST) + // ========== 奇数索引: 读操作 ========== if (slmp_idx % 2 == 1) { - slave_id = get_register(readST[slmp_idx].slave_id); + // 从readST获取参数 + slave_id = get_register(readST[slmp_idx].slave_id); plc_address = get_register(readST[slmp_idx].plc_address); - size = get_register(readST[slmp_idx].size); + pointNum = get_register(readST[slmp_idx].size); - if (slave_id < 0x01 || slave_id > 0xF7 || size == 0 || size > 20) { - sendsize = 0; - } else if ((plc_address + size) >= 8000) { - sendsize = 0; - } else { - // 构建读请求帧 - slmp_frame.frameStruct.cmd = 0x0401; // 读命令 - slmp_frame.frameStruct.requestSize = 0x000C; // 请求长度固定12字节 - slmp_frame.frameStruct.start = u32_to_slmp24(plc_address); - slmp_frame.frameStruct.size = size; - sendsize = 21; // 帧头长度固定21字节,无额外数据 - // 拷贝到发送缓冲区,带边界检查 - for (int i = 0; i < sendsize && i < sizeof(slmp_txbuf); i++) { - slmp_txbuf[i] = slmp_frame.frameU8[i]; - } + // 参数合法性检查 + if (slave_id < 0x01 || slave_id > 0xF7 || pointNum == 0 || pointNum > 20) { + return 0; + } + if ((plc_address + pointNum) >= 8000) { + return 0; // 地址越界 } - } else { - // 偶数索引 -> 写操作 (和FINS一致,写使用writeST) - slave_id = get_register(writeST[slmp_idx].slave_id); + // 构建读请求帧 + slmp_frame.frameStruct.cmd = 0x0401; // 读命令码 + slmp_frame.frameStruct.requestSize = 0x000C; // 请求长度固定12字节 + slmp_frame.frameStruct.start = u32_to_slmp24(plc_address); + slmp_frame.frameStruct.size = pointNum; + sendsize = 21; // 读请求只有帧头,固定21字节 + + // 拷贝帧头到发送缓冲区,带边界检查 + for (int i = 0; i < sendsize && i < sizeof(slmp_txbuf); i++) { + slmp_txbuf[i] = slmp_frame.frameU8[i]; + } + } + // ========== 偶数索引: 写操作 ========== + else { + // 从writeST获取参数 + slave_id = get_register(writeST[slmp_idx].slave_id); plc_address = get_register(writeST[slmp_idx].plc_address); - size = get_register(writeST[slmp_idx].size); + pointNum = get_register(writeST[slmp_idx].size); - if (slave_id < 0x01 || slave_id > 0xF7 || size == 0 || size > 20) { - sendsize = 0; - } else if ((plc_address + size) >= 8000) { - sendsize = 0; - } else { - sendsize = 21 + (size * 2); // 帧头 + 数据 - // 检查缓冲区边界,防止越界 - if (sendsize > sizeof(slmp_txbuf)) { - return 0; - } + // 参数合法性检查 + if (slave_id < 0x01 || slave_id > 0xF7 || pointNum == 0 || pointNum > 20) { + return 0; + } + if ((plc_address + pointNum) >= 8000) { + return 0; // 地址越界 + } - // 构建写请求帧 - slmp_frame.frameStruct.cmd = 0x1401; // 写命令 - slmp_frame.frameStruct.requestSize = 0x000C + (size * 2); - slmp_frame.frameStruct.start = u32_to_slmp24(plc_address); - slmp_frame.frameStruct.size = size; + sendsize = 21 + (pointNum * 2); // 帧头21字节 + 数据2字节*点数 + if (sendsize > sizeof(slmp_txbuf)) { + return 0; // 超出缓冲区,安全保护 + } - // 填充数据,SLMP小端序: 低字节在前 - for (int i = 0; i < size; i++) { - uint16_t value = get_register(1000 + (20 * slmp_idx) + i); - slmp_txbuf[i * 2 + 21] = value & 0xFF; // 低字节在前 - slmp_txbuf[i * 2 + 22] = (value >> 8) & 0xFF; // 高字节在后 - } + // 构建写请求帧 + slmp_frame.frameStruct.cmd = 0x1401; // 写命令码 + slmp_frame.frameStruct.requestSize = 0x000C + (pointNum * 2); + slmp_frame.frameStruct.start = u32_to_slmp24(plc_address); + slmp_frame.frameStruct.size = pointNum; - // 拷贝帧头到发送缓冲区 - for (int i = 0; i < 21 && i < sizeof(slmp_txbuf); i++) { - slmp_txbuf[i] = slmp_frame.frameU8[i]; - } + // 填充数据: SLMP小端序,低字节在前 + for (int i = 0; i < pointNum; i++) { + uint16_t value = get_register(1000 + (20 * slmp_idx) + i); + slmp_txbuf[i * 2 + 21] = value & 0xFF; // 低字节在前 + slmp_txbuf[i * 2 + 22] = (value >> 8) & 0xFF; // 高字节在后 + } + + // 拷贝帧头到发送缓冲区 + for (int i = 0; i < 21 && i < sizeof(slmp_txbuf); i++) { + slmp_txbuf[i] = slmp_frame.frameU8[i]; } } - // 索引轮转 (0~9对应10个通道) + // 索引轮转,下次处理下一个通道 slmp_idx = (slmp_idx + 1) % 10; return sendsize; } -// SLMP超时计数,由主循环调用 (和FINS一致) +/** + * @brief 超时计数,由主循环每次调用递增 + * @note 和FINS完全一致 + */ void update_timeout_slmp(void) { if (slmpTimegap < 0xffff) { slmpTimegap++; } } -// SLMP TCP客户端主函数 (和FINS相同结构) +/** + * @brief SLMP TCP客户端主函数,由顶层loopback_comm调用 + * @param sn: W5500 socket编号 + * @param destip: 目标IP地址 + * @param destport: 目标端口 + * @return int32_t: 0/正表示正常,负表示错误 + */ int32_t loopback_tcpc_slmp(uint8_t sn, uint8_t *destip, uint16_t destport) { int32_t ret; uint16_t size = 0, sentsize = 0; - static uint16_t any_port = 50000; + static uint16_t any_port = 50000; // 本地端口,自动递增 - switch (getSn_SR(sn)) { + uint8_t sr_status = getSn_SR(sn); + switch (sr_status) { + // ========== 连接已建立: 收发数据 ========== case SOCK_ESTABLISHED: if (getSn_IR(sn) & Sn_IR_CON) { - setSn_IR(sn, Sn_IR_CON); + setSn_IR(sn, Sn_IR_CON); // 清连接中断标志 } - // 接收响应 + // 1. 接收响应 if ((size = getSn_RX_RSR(sn)) > 0) { - // 边界保护,不超过缓冲区大小 + // 边界保护,不超过缓冲区 if (size > sizeof(slmp_rxbuf)) { size = sizeof(slmp_rxbuf); } @@ -209,21 +263,21 @@ int32_t loopback_tcpc_slmp(uint8_t sn, uint8_t *destip, uint16_t destport) { return ret; } else { comm_count++; - slmp_handle_recv(ret); - slmpTimegap = 900; // 重置超时 + slmp_handle_recv(ret); // 处理响应 + slmpTimegap = 900; // 重置超时 } } - // 超时到了,发送下一个请求 + // 2. 超时到了,发送下一个请求 size = 0; if (slmpTimegap > 1000) { - size = slmp_build_send(); + size = slmp_build_send(); // 构建请求 if (size == 0) { - slmpTimegap = 1000; + slmpTimegap = 1000; // 参数非法,等待下一次 } } - // 发送请求 + // 3. 发送请求(分片发送,直到发完) sentsize = 0; while (size != 0 && sentsize != size) { ret = send(sn, slmp_txbuf + sentsize, size - sentsize); @@ -235,21 +289,24 @@ int32_t loopback_tcpc_slmp(uint8_t sn, uint8_t *destip, uint16_t destport) { } break; + // ========== 对方关闭连接 ========== case SOCK_CLOSE_WAIT: if ((ret = disconnect(sn)) != SOCK_OK) { return ret; } break; + // ========== 初始化: 发起连接 ========== case SOCK_INIT: if ((ret = connect(sn, destip, destport)) != SOCK_OK) { return ret; } break; + // ========== socket未打开: 新建socket ========== case SOCK_CLOSED: close(sn); - // 端口绕回处理 (和FINS一致) + // 端口绕回,超过最大值后重置 if (any_port == 0xffff) { any_port = 50000; } @@ -261,5 +318,6 @@ int32_t loopback_tcpc_slmp(uint8_t sn, uint8_t *destip, uint16_t destport) { default: break; } + return 1; } diff --git a/comm/protocols/slmptcpmaster.h b/comm/protocols/slmptcpmaster.h index 69e14e6..fbd263c 100644 --- a/comm/protocols/slmptcpmaster.h +++ b/comm/protocols/slmptcpmaster.h @@ -1,3 +1,7 @@ +/** + * @file slmptcpmaster.h + * @brief 三菱SLMP协议TCP客户端主站头文件 + */ #ifndef SLMPTCPMASTER_H #define SLMPTCPMASTER_H @@ -8,24 +12,47 @@ extern "C" { #include #include -extern uint8_t slmp_txbuf[1024]; -extern uint8_t slmp_rxbuf[1024]; -extern uint16_t slmp_idx; -extern uint16_t slmp_addr; -extern uint16_t slmp_size; -extern uint16_t slmpTimegap; -extern uint16_t comm_count; +// ============================================================================ +// 全局变量 +// ============================================================================ -// 处理接收到的SLMP响应 +extern uint8_t slmp_txbuf[1024]; // 发送缓冲区 +extern uint8_t slmp_rxbuf[1024]; // 接收缓冲区 +extern uint16_t slmp_idx; // 当前轮询索引 (0~9) +extern uint16_t slmp_addr; // 当前请求起始地址 +extern uint16_t slmp_size; // 当前请求点数 +extern uint16_t slmpTimegap; // 超时计数,由主循环递增 +extern uint16_t comm_count; // 通信计数 + +// ============================================================================ +// 接口函数 +// ============================================================================ + +/** + * @brief 处理接收到的SLMP响应 + * @param size: 接收数据长度 + * @return true: 处理成功,false: 不是有效的读响应 + */ _Bool slmp_handle_recv(uint16_t size); -// 构建SLMP请求,返回发送长度 +/** + * @brief 构建SLMP请求帧 + * @return 发送长度,0表示不发送(参数非法) + */ uint16_t slmp_build_send(void); -// 超时计数,由主循环调用 +/** + * @brief 超时计数,由主循环每次调用递增 + */ void update_timeout_slmp(void); -// SLMP TCP客户端主函数 +/** + * @brief SLMP TCP客户端主函数,W5500socket主循环处理 + * @param sn: socket编号 + * @param destip: 目标IP地址 + * @param destport: 目标端口 + * @return 0/正表示正常,负表示错误 + */ int32_t loopback_tcpc_slmp(uint8_t sn, uint8_t *destip, uint16_t destport); #ifdef __cplusplus