docs: 优化所有协议文件可读性,增加完整注释和doxygen说明,结构更清晰

This commit is contained in:
claw committed 2026-04-02 22:51:17 +08:00
1 parent e3519bf1f4
commit 102e59d033
6 files changed
+488 -206

No files matched your search

+108 -58
View File
@@ -1,7 +1,13 @@
/* /*
* finsudpmaster.c * @file finsudpmaster.c
* 欧姆龙FINS UDP通信主站 * @brief 欧姆龙FINS UDP客户端主站实现
* 轮询方式: myRtumSTIdx 0~19轮转, 奇数索引读, 偶数索引写 *
* 轮询机制:
* - myRtumSTIdx: 0~19 轮转索引,对应 myRtumST[20]
* - **奇数索引**: 读操作,从PLC读取数据存储到 1400 + (idx*20) + i
* - **偶数索引**: 写操作,从 1400 + (idx*20) + i 读取数据写入PLC
* - 每次主循环调用 update_timeout_fins() 递增超时计数
* - 超时计数 > 500 时发送下一帧,接收后重置超时为 490
*/ */
#include "finsudpmaster.h" #include "finsudpmaster.h"
@@ -11,86 +17,121 @@
#include "main.h" #include "main.h"
#include <string.h> #include <string.h>
uint8_t myRtumSTIdx = 0; // 轮询索引 (0~19对应myRtumST[20]) // ============================================================================
uint8_t omrfins_buf[1024]; // FINS收发缓冲区 // 全局变量
// ============================================================================
// 读响应固定头,只有匹配这个头才会处理 uint8_t myRtumSTIdx = 0; // 轮询索引 (0~19)
uint8_t readrx[14] = { 0xc0, 0x00, 0x02, 0x00, 0x0A, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x01, 0x00, 0x40 }; 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) { _Bool handleReadRecv(uint16_t size, uint16_t local_node) {
// 设置本地节点号 // 1. 设置本地节点号,然后比对前14字节确认是读响应
readrx[4] = (uint8_t)local_node; readrx[4] = (uint8_t)local_node;
// 对比前14字节,确认是读响应
for (int i = 0; i < 14; i++) { for (int i = 0; i < 14; i++) {
if (readrx[i] != omrfins_buf[i]) { if (readrx[i] != omrfins_buf[i]) {
return 0; return false; // 不匹配,不是读响应
} }
} }
// 找到上一次发送对应的索引 (因为发送后索引+1,所以响应对应前一个) // 2. 获取上一次发送对应的索引
// 因为发送后索引立即+1,所以响应对应发送前的索引
uint16_t prevIdx; uint16_t prevIdx;
if (myRtumSTIdx == 0) { if (myRtumSTIdx == 0) {
prevIdx = 19; prevIdx = 19; // 绕回
} else { } else {
prevIdx = myRtumSTIdx - 1; prevIdx = myRtumSTIdx - 1;
} }
// 只有读响应会走到这里,读使用奇数索引,验证一下 // 3. 验证索引: 读必须是奇数索引
if ((prevIdx % 2 == 1) != (memcmp(readrx, readrx, 7) == 0)) { if ((prevIdx % 2 == 1) != (memcmp(readrx, readrx, 7) == 0)) {
return 0; // 不匹配,丢弃 return false; // 不匹配,丢弃
} }
uint16_t thisSize = get_register(myRtumST[prevIdx].size); // 4. 获取参数,检查长度合法性
// 大小检查 + 边界保护 (最大20个寄存器) uint16_t pointNum = get_register(myRtumST[prevIdx].size);
if (thisSize > 20 || thisSize * 2 + 14 != size) { if (pointNum > 20 || pointNum * 2 + 14 != size) {
return 0; return false; // 长度不匹配或超出最大限制,丢弃
} }
// 5. 解析响应数据,存储到寄存器映射
// FINS使用大端序: 高字节在前,低字节在后 // FINS使用大端序: 高字节在前,低字节在后
for (int i = 0; i < thisSize; i++) { for (int i = 0; i < pointNum; i++) {
uint8_t byte_h = omrfins_buf[i * 2 + 14]; uint8_t byte_h = omrfins_buf[i * 2 + 14];
uint8_t byte_l = omrfins_buf[i * 2 + 15]; uint8_t byte_l = omrfins_buf[i * 2 + 15];
uint16_t value = ((uint16_t)byte_h << 8) | byte_l; uint16_t value = ((uint16_t)byte_h << 8) | byte_l;
// 存储位置: 1400 + (索引*20) + 偏移 // 存储地址: 1400 + (索引*20) + 偏移
set_register(1400 + (20 * prevIdx) + i, value); 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 }; * @brief 构建FINS请求帧
uint8_t write_send[58] = { 0x80, 0x00, 0x02, 0x00, 0x01, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x01, 0x02, 0x82, 0x00, 0x64, 0x00, 0x00, 0x02 }; * @param local_node: 本地节点号
* @return 发送长度,0表示不发送(参数非法)
// 构建FINS请求帧,返回发送长度 * @note 奇数索引 -> 读操作,偶数索引 -> 写操作
*/
uint16_t handleSend(uint16_t local_node) { uint16_t handleSend(uint16_t local_node) {
uint16_t sendsize = 0; 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 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) { if (slave_id == 0 || slave_id >= 127 || pointNum == 0 || pointNum > 20) {
sendsize = 0; return 0;
} else { }
// ========== 奇数索引: 读操作 ==========
if (myRtumSTIdx % 2 == 1) { if (myRtumSTIdx % 2 == 1) {
// 奇数索引 -> 读操作
send_read[7] = (uint8_t)local_node; send_read[7] = (uint8_t)local_node;
send_read[13] = (plc_address >> 8) & 0xFF; send_read[13] = (plc_address >> 8) & 0xFF;
send_read[14] = plc_address & 0xFF; send_read[14] = plc_address & 0xFF;
send_read[17] = (uint8_t)size; send_read[17] = (uint8_t)pointNum;
sendsize = 18; sendsize = 18; // 读请求固定18字节
// 拷贝到发送缓冲区,带边界检查 // 拷贝到发送缓冲区,带边界检查
for (int i = 0; i < sendsize && i < sizeof(omrfins_buf); i++) { for (int i = 0; i < sendsize && i < sizeof(omrfins_buf); i++) {
omrfins_buf[i] = send_read[i]; omrfins_buf[i] = send_read[i];
} }
}
} else { // ========== 偶数索引: 写操作 ==========
// 偶数索引 -> 写操作 else {
sendsize = (size * 2) + 18; sendsize = (pointNum * 2) + 18;
// 检查缓冲区边界,防止越界 // 边界检查,防止越界
if (sendsize > sizeof(write_send) || sendsize > sizeof(omrfins_buf)) { if (sendsize > sizeof(write_send) || sendsize > sizeof(omrfins_buf)) {
return 0; return 0;
} }
@@ -98,10 +139,10 @@ uint16_t handleSend(uint16_t local_node) {
write_send[7] = (uint8_t)local_node; write_send[7] = (uint8_t)local_node;
write_send[13] = (plc_address >> 8) & 0xFF; write_send[13] = (plc_address >> 8) & 0xFF;
write_send[14] = plc_address & 0xFF; write_send[14] = plc_address & 0xFF;
write_send[17] = (uint8_t)size; write_send[17] = (uint8_t)pointNum;
// 填充数据,FINS大端序: 高字节在前 // 填充数据,FINS大端序: 高字节在前
for (int i = 0; i < size; i++) { for (int i = 0; i < pointNum; i++) {
uint16_t value = get_register(1400 + (20 * myRtumSTIdx) + i); uint16_t value = get_register(1400 + (20 * myRtumSTIdx) + i);
write_send[i * 2 + 18] = (value >> 8) & 0xFF; write_send[i * 2 + 18] = (value >> 8) & 0xFF;
write_send[i * 2 + 19] = value & 0xFF; write_send[i * 2 + 19] = value & 0xFF;
@@ -112,56 +153,63 @@ uint16_t handleSend(uint16_t local_node) {
omrfins_buf[i] = write_send[i]; omrfins_buf[i] = write_send[i];
} }
} }
}
// 索引轮转 // 索引轮转,下次处理下一个通道
myRtumSTIdx = (myRtumSTIdx + 1) % 20; myRtumSTIdx = (myRtumSTIdx + 1) % 20;
return sendsize; return sendsize;
} }
uint16_t fins_timeout = 0; /**
// FINS超时计数,由主循环调用 * @brief 超时计数,由主循环每次调用递增
*/
void update_timeout_fins(void) { void update_timeout_fins(void) {
if (fins_timeout < 0xffff) { if (fins_timeout < 0xffff) {
fins_timeout++; 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 loopback_udpc_omrfins(uint8_t sn, uint8_t *destip, uint16_t destport, uint16_t local_node) {
int32_t ret; int32_t ret;
uint16_t size = 0, sentsize = 0; uint16_t size = 0, sentsize = 0;
static uint16_t any_port = 50000; static uint16_t any_port = 50000; // 本地端口,自动递增
switch (getSn_SR(sn)) { switch (getSn_SR(sn)) {
// ========== socket已连接: 收发数据 ==========
case SOCK_UDP: case SOCK_UDP:
// 接收响应 // 1. 接收响应
if ((size = getSn_RX_RSR(sn)) > 0) { if ((size = getSn_RX_RSR(sn)) > 0) {
// 边界保护,不超过缓冲区大小 // 边界保护,不超过缓冲区
if (size > sizeof(omrfins_buf)) { if (size > sizeof(omrfins_buf)) {
size = sizeof(omrfins_buf); size = sizeof(omrfins_buf);
} }
ret = recvfrom(sn, omrfins_buf, size, destip, (uint16_t*) &destport); ret = recvfrom(sn, omrfins_buf, size, destip, (uint16_t*) &destport);
if (ret <= 0) { if (ret <= 0) {
return ret; return ret;
} else { } else {
comm_count++; comm_count++;
handleReadRecv(ret, local_node); handleReadRecv(ret, local_node); // 处理响应
fins_timeout = 490; // 重置超时 fins_timeout = 490; // 重置超时
} }
} }
// 超时到了,发送下一个请求 // 2. 超时到了,发送下一个请求
size = 0; size = 0;
if (fins_timeout > 500) { if (fins_timeout > 500) {
size = handleSend(local_node); size = handleSend(local_node); // 构建请求
if (size == 0) { if (size == 0) {
fins_timeout = 1000; fins_timeout = 1000; // 参数非法,等待下一次
} }
} }
// 发送请求 // 3. 发送请求(分片发送,直到发完)
sentsize = 0; sentsize = 0;
while (size != 0 && sentsize != size) { while (size != 0 && sentsize != size) {
ret = sendto(sn, omrfins_buf + sentsize, size - sentsize, destip, destport); 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; break;
// ========== socket未打开: 新建socket ==========
case SOCK_CLOSED: case SOCK_CLOSED:
// 端口绕回处理 // 端口绕回,超过最大值后重置
if (any_port == 0xffff) { if (any_port == 0xffff) {
any_port = 50000; any_port = 50000;
} }
@@ -185,5 +234,6 @@ int32_t loopback_udpc_omrfins(uint8_t sn, uint8_t *destip, uint16_t destport, ui
default: default:
break; break;
} }
return 1; return 1;
} }
+38 -8
View File
@@ -1,3 +1,7 @@
/**
* @file finsudpmaster.h
* @brief 欧姆龙FINS UDP客户端主站头文件
*/
#ifndef FINSUDPMASTER_H #ifndef FINSUDPMASTER_H
#define FINSUDPMASTER_H #define FINSUDPMASTER_H
@@ -8,21 +12,47 @@ extern "C" {
#include <stdint.h> #include <stdint.h>
#include <stdbool.h> #include <stdbool.h>
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); _Bool handleReadRecv(uint16_t size, uint16_t local_node);
// 构建FINS请求帧,返回发送长度 /**
* @brief 构建FINS请求帧
* @param local_node: 本地节点号
* @return 发送长度,0表示不发送(参数非法)
*/
uint16_t handleSend(uint16_t local_node); uint16_t handleSend(uint16_t local_node);
// 超时计数,由主循环调用 /**
* @brief 超时计数,由主循环每次调用递增
*/
void update_timeout_fins(void); 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); int32_t loopback_udpc_omrfins(uint8_t sn, uint8_t *destip, uint16_t destport, uint16_t local_node);
#ifdef __cplusplus #ifdef __cplusplus
+107 -33
View File
@@ -1,6 +1,6 @@
/* /*
* modbustcpslave.c * @file modbustcpslave.c
* Modbus TCP从站服务 * @brief Modbus TCP从站服务 + Modbus TCP转RTU转发
*/ */
#include "modbustcpslave.h" #include "modbustcpslave.h"
@@ -12,45 +12,86 @@
#include <string.h> #include <string.h>
#include "gpio.h" #include "gpio.h"
// ============================================================================
// 全局变量
// ============================================================================
uint8_t loopback_tcps_modbus_rxbuf[1024]; uint8_t loopback_tcps_modbus_rxbuf[1024];
uint8_t loopback_tcps_modbus_txbuf[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 tcp_to_rtu(uint8_t *tcp_buf, uint8_t *rtu_buf) {
uint16_t len = ((tcp_buf[4] << 8) | tcp_buf[5]) - 1; // 去掉UnitID前的长度 // TCP长度字段 - 去掉MBAP头中的UnitID之前的长度
memcpy(rtu_buf, &tcp_buf[6], len + 1); // 从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); uint16_t crc = crc16(rtu_buf, len + 1);
rtu_buf[len + 1] = crc & 0xFF; rtu_buf[len + 1] = crc & 0xFF;
rtu_buf[len + 2] = (crc >> 8) & 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) { 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_calc = crc16(rtu_buf, rtu_len - 2);
uint16_t crc_recv = rtu_buf[rtu_len - 2] | (rtu_buf[rtu_len - 1] << 8); uint16_t crc_recv = rtu_buf[rtu_len - 2] | (rtu_buf[rtu_len - 1] << 8);
if (crc_calc != crc_recv) { if (crc_calc != crc_recv) {
return 0; // CRC错误 return 0; // CRC错误
} }
// 还原MBAP头 // 拷贝原MBAP头
memcpy(tcp_buf, rx_buf, 6); // Transaction ID, Protocol ID, Length先拷贝 memcpy(tcp_buf, rx_buf, 6);
tcp_buf[6] = rtu_buf[0]; // UnitID // Unit ID
memcpy(&tcp_buf[7], &rtu_buf[1], rtu_len - 3); // 功能码+数据 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[4] = (mbap_len >> 8) & 0xFF;
tcp_buf[5] = (mbap_len) & 0xFF; tcp_buf[5] = mbap_len & 0xFF;
return 7 + pdu_len; // MBAP(7) + PDU return 7 + pdu_len; // MBAP(7) + PDU
} }
// ============================================================================
// 状态机定义
// ============================================================================
enum { enum {
STATE_IDLE, STATE_WAIT_RTU STATE_IDLE, // 空闲,等待TCP请求
STATE_WAIT_RTU // 已经转发RTU,等待RS485响应
} modbus_state = STATE_IDLE; } 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 loopback_tcps_modbus(uint8_t sn, uint16_t port) {
int32_t ret; int32_t ret;
uint16_t size = 0, sentsize = 0; uint16_t size = 0, sentsize = 0;
@@ -71,16 +112,22 @@ int32_t loopback_tcps_modbus(uint8_t sn, uint16_t port) {
#endif #endif
setSn_IR(sn, Sn_IR_CON); 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); uint16_t rxbuf_size = handleModbusTcp(loopback_tcps_modbus_rxbuf, loopback_tcps_modbus_txbuf);
if (rxbuf_size > 0) { if (rxbuf_size > 0) {
sentsize = 0; sentsize = 0;
// 分片发送直到完成
while (rxbuf_size != sentsize) { while (rxbuf_size != sentsize) {
ret = send(sn, loopback_tcps_modbus_txbuf + sentsize, rxbuf_size - sentsize); ret = send(sn, loopback_tcps_modbus_txbuf + sentsize, rxbuf_size - sentsize);
if (ret < 0) { if (ret < 0) {
@@ -92,40 +139,55 @@ int32_t loopback_tcps_modbus(uint8_t sn, uint16_t port) {
} }
} }
break; break;
case SOCK_CLOSE_WAIT: case SOCK_CLOSE_WAIT:
#ifdef _LOOPBACK_DEBUG_ #ifdef _LOOPBACK_DEBUG_
//printf("%d:CloseWait\r\n",sn); //printf("%d:CloseWait\r\n",sn);
#endif #endif
if ((ret = disconnect(sn)) != SOCK_OK) if ((ret = disconnect(sn)) != SOCK_OK) {
return ret; return ret;
}
#ifdef _LOOPBACK_DEBUG_ #ifdef _LOOPBACK_DEBUG_
printf("%d:Socket Closed\r\n", sn); printf("%d:Socket Closed\r\n", sn);
#endif #endif
break; break;
case SOCK_INIT: case SOCK_INIT:
#ifdef _LOOPBACK_DEBUG_ #ifdef _LOOPBACK_DEBUG_
printf("%d:Listen, TCP server loopback, port [%d]\r\n", sn, port); printf("%d:Listen, TCP server loopback, port [%d]\r\n", sn, port);
#endif #endif
if ((ret = listen(sn)) != SOCK_OK) if ((ret = listen(sn)) != SOCK_OK) {
return ret; return ret;
}
break; break;
case SOCK_CLOSED: case SOCK_CLOSED:
#ifdef _LOOPBACK_DEBUG_ #ifdef _LOOPBACK_DEBUG_
//printf("%d:TCP server loopback start\r\n",sn); //printf("%d:TCP server loopback start\r\n",sn);
#endif #endif
if ((ret = socket(sn, Sn_MR_TCP, port, 0x00)) != sn) if ((ret = socket(sn, Sn_MR_TCP, port, 0x00)) != sn) {
return ret; return ret;
}
#ifdef _LOOPBACK_DEBUG_ #ifdef _LOOPBACK_DEBUG_
//printf("%d:Socket opened\r\n",sn); //printf("%d:Socket opened\r\n",sn);
#endif #endif
break; break;
default: default:
break; break;
} }
return 1; 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 loopback_tcps_modbus_to485(uint8_t sn, uint8_t *buf, uint16_t port, uint16_t *timeout, RtuRxST *rtu_rx) {
int32_t ret; int32_t ret;
uint16_t size = 0, sentsize = 0; 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) { switch (modbus_state) {
case STATE_WAIT_RTU: case STATE_WAIT_RTU:
// RTU响应接收完成,转TCP返回
if (rtu_rx->done) { if (rtu_rx->done) {
rxbuf_size = rtu_to_tcp(rtu_rx->buf, sendbuf, rtu_rx->size, buf); rxbuf_size = rtu_to_tcp(rtu_rx->buf, sendbuf, rtu_rx->size, buf);
} }
// 超时也回到空闲
if (rtu_rx->done || *timeout > 1000) { if (rtu_rx->done || *timeout > 1000) {
rtu_rx->done = 0; rtu_rx->done = 0;
modbus_state = STATE_IDLE; modbus_state = STATE_IDLE;
} }
// 同时检查是否有新的TCP请求
if ((size = getSn_RX_RSR(sn)) > 0) { if ((size = getSn_RX_RSR(sn)) > 0) {
ret = recv(sn, buf, size); ret = recv(sn, buf, size);
if (ret <= 0) { 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: case STATE_IDLE:
if ((size = getSn_RX_RSR(sn)) > 0) { if ((size = getSn_RX_RSR(sn)) > 0) {
if (size > DATA_BUF_SIZE) if (size > DATA_BUF_SIZE) {
size = DATA_BUF_SIZE; size = DATA_BUF_SIZE;
}
ret = recv(sn, buf, size); ret = recv(sn, buf, size);
if (ret <= 0) if (ret <= 0) {
return ret; return ret;
}
// UnitID匹配本地从站地址,本地处理
if (buf[6] == get_slaveid()) { if (buf[6] == get_slaveid()) {
rxbuf_size = handleModbusTcp(buf, sendbuf); rxbuf_size = handleModbusTcp(buf, sendbuf);
} else { }
// 不匹配,转发到RS485RTU
else {
uint8_t rtu_tx[256]; uint8_t rtu_tx[256];
uint16_t rtu_tx_len = tcp_to_rtu(buf, rtu_tx); 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); HAL_UART_Transmit_DMA(&huart1, rtu_tx, rtu_tx_len);
*timeout = 0; *timeout = 0;
rtu_rx->done = 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; break;
} }
// 发送响应
if (rxbuf_size > 0) { if (rxbuf_size > 0) {
sentsize = 0; sentsize = 0;
while (rxbuf_size != sentsize) { 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_ #ifdef _LOOPBACK_DEBUG_
//printf("%d:CloseWait\r\n",sn); //printf("%d:CloseWait\r\n",sn);
#endif #endif
if ((ret = disconnect(sn)) != SOCK_OK) if ((ret = disconnect(sn)) != SOCK_OK) {
return ret; return ret;
}
#ifdef _LOOPBACK_DEBUG_ #ifdef _LOOPBACK_DEBUG_
printf("%d:Socket Closed\r\n", sn); printf("%d:Socket Closed\r\n", sn);
#endif #endif
@@ -221,16 +293,18 @@ int32_t loopback_tcps_modbus_to485(uint8_t sn, uint8_t *buf, uint16_t port, uint
#ifdef _LOOPBACK_DEBUG_ #ifdef _LOOPBACK_DEBUG_
printf("%d:Listen, TCP server loopback, port [%d]\r\n", sn, port); printf("%d:Listen, TCP server loopback, port [%d]\r\n", sn, port);
#endif #endif
if ((ret = listen(sn)) != SOCK_OK) if ((ret = listen(sn)) != SOCK_OK) {
return ret; return ret;
}
break; break;
case SOCK_CLOSED: case SOCK_CLOSED:
#ifdef _LOOPBACK_DEBUG_ #ifdef _LOOPBACK_DEBUG_
//printf("%d:TCP server loopback start\r\n",sn); //printf("%d:TCP server loopback start\r\n",sn);
#endif #endif
if ((ret = socket(sn, Sn_MR_TCP, port, 0x00)) != sn) if ((ret = socket(sn, Sn_MR_TCP, port, 0x00)) != sn) {
return ret; return ret;
}
#ifdef _LOOPBACK_DEBUG_ #ifdef _LOOPBACK_DEBUG_
//printf("%d:Socket opened\r\n",sn); //printf("%d:Socket opened\r\n",sn);
#endif #endif
+49 -6
View File
@@ -1,3 +1,7 @@
/**
* @file modbustcpslave.h
* @brief Modbus TCP从站服务头文件
*/
#ifndef MODBUSTCPSLAVE_H #ifndef MODBUSTCPSLAVE_H
#define MODBUSTCPSLAVE_H #define MODBUSTCPSLAVE_H
@@ -12,24 +16,63 @@ extern "C" {
#define DATA_BUF_SIZE 2048 #define DATA_BUF_SIZE 2048
#endif #endif
// ============================================================================
// 结构体定义
// ============================================================================
// RTU接收状态结构体 // RTU接收状态结构体
typedef struct { typedef struct {
uint8_t buf[512]; uint8_t buf[512]; // 接收缓冲区
_Bool done; _Bool done; // 接收完成标志
uint16_t size; uint16_t size; // 接收数据长度
} RtuRxST; } RtuRxST;
// ============================================================================
// 全局变量
// ============================================================================
extern uint8_t loopback_tcps_modbus_rxbuf[1024]; extern uint8_t loopback_tcps_modbus_rxbuf[1024];
extern uint8_t loopback_tcps_modbus_txbuf[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); 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); 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); 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); uint16_t rtu_to_tcp(uint8_t *rtu_buf, uint8_t *tcp_buf, uint16_t rtu_len, uint8_t *rx_buf);
#ifdef __cplusplus #ifdef __cplusplus
+148 -90
View File
@@ -1,8 +1,13 @@
/* /*
* slmptcpmaster.c * @file slmptcpmaster.c
* 三菱SLMP TCP通信主站 * @brief 三菱SLMP协议TCP客户端主站实现
* 轮询方式: slmp_idx 0~9轮转, 奇数索引读(readST), 偶数索引写(writeST) *
* 和FINS完全相同的架构 * 轮询机制 (和欧姆龙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" #include "slmptcpmaster.h"
@@ -12,43 +17,53 @@
#include "main.h" #include "main.h"
#include <string.h> #include <string.h>
// 24位小端存储结构体 (SLMP使用) // ============================================================================
// 结构体定义
// ============================================================================
// 24位地址,SLMP使用小端序存储 (低字节在前)
typedef union { typedef union {
uint8_t bytes[3]; uint8_t bytes[3]; // 按字节访问
struct { struct {
uint8_t byte0; // 最低字节 uint8_t byte0; // 最低字节 (bit 0~7)
uint8_t byte1; // 中间字节 uint8_t byte1; // 中间字节 (bit 8~15)
uint8_t byte2; // 最高字节 uint8_t byte2; // 最高字节 (bit 16~23)
}; };
} slmp_uint24_t; } slmp_uint24_t;
// SLMP帧联合体 - 支持结构化访问和字节访问 // SLMP请求帧联合体,支持结构化访问和字节访问
typedef union { typedef union {
struct __attribute__((__packed__)){ struct __attribute__((__packed__)){
uint16_t header; // 固定0x0050 uint16_t header; // 固定值: 0x0050
uint16_t target; // 固定0xff00 uint16_t target; // 固定值: 0xff00
uint16_t index; // 固定0x03FF uint16_t index; // 固定值: 0x03FF
uint8_t subIdx; // 固定0x00 uint8_t subIdx; // 固定值: 0x00
uint16_t requestSize; // 请求数据长度 uint16_t requestSize; // 请求数据长度
uint16_t timeout; // 固定0x0004 (4秒超时) uint16_t timeout; // 超时: 0x0004 (4秒)
uint16_t cmd; // 命令: 0x0401=读,0x1401=写 uint16_t cmd; // 命令码: 0x0401=读,0x1401=写
uint16_t subCmd; // 固定0x0000 uint16_t subCmd; // 子命令: 固定0x0000
slmp_uint24_t start; // 起始地址 (24位小端) slmp_uint24_t start; // 起始地址 (24位小端)
uint8_t dm; // 固定0xA8 (D寄存器) uint8_t dm; // 软元件类型: 0xA8 = D寄存器
uint16_t size; // 读写点数 uint16_t size; // 读写点数
} frameStruct; } frameStruct;
uint8_t frameU8[21]; // 帧头最大长度21字节 uint8_t frameU8[21]; // 按字节访问,帧头最大21字节
} SLMPFrame; } 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 = { static SLMPFrame slmp_frame = {
.frameStruct.header = 0x0050, .frameStruct.header = 0x0050,
.frameStruct.target = 0xff00, .frameStruct.target = 0xff00,
@@ -59,7 +74,15 @@ static SLMPFrame slmp_frame = {
.frameStruct.dm = 0xA8 .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) { static slmp_uint24_t u32_to_slmp24(uint32_t val) {
slmp_uint24_t r; slmp_uint24_t r;
r.byte0 = val & 0xFF; r.byte0 = val & 0xFF;
@@ -68,100 +91,121 @@ static slmp_uint24_t u32_to_slmp24(uint32_t val) {
return r; return r;
} }
// 处理SLMP接收到的响应 // ============================================================================
// 返回1: 处理成功,0: 不是有效响应 // 公共接口
// ============================================================================
/**
* @brief 处理接收到的SLMP响应
* @param size: 接收数据长度
* @return true: 处理成功,false: 不是有效的读响应
* @note 只有读响应需要存储数据,写响应不需要处理
*/
_Bool slmp_handle_recv(uint16_t size) { _Bool slmp_handle_recv(uint16_t size) {
// 只有读响应需要处理数据,写响应不需要存储 // 1. 识别读响应: 比对前7字节响应头
// 比对读响应头确认
if (memcmp(slmp_rxbuf, slmp_read_resp_header, 7) != 0) { if (memcmp(slmp_rxbuf, slmp_read_resp_header, 7) != 0) {
return 0; // 不是读响应,直接忽略 return false; // 不是读响应(是写响应),直接忽略
} }
// 找到上一次发送对应的索引 (发送后索引+1,响应对应前一个) // 2. 获取上一次发送对应的索引
// 因为发送后索引立即+1,所以响应对应发送前的索引
uint16_t prevIdx; uint16_t prevIdx;
if (slmp_idx == 0) { if (slmp_idx == 0) {
prevIdx = 9; prevIdx = 9; // 绕回
} else { } else {
prevIdx = slmp_idx - 1; prevIdx = slmp_idx - 1;
} }
// 读使用奇数索引,验证一下 // 3. 验证索引: 读必须是奇数索引
if (prevIdx % 2 != 1) { if (prevIdx % 2 != 1) {
return 0; // 不匹配,丢弃 return false; // 不匹配,丢弃
} }
uint16_t thisSize = get_register(readST[prevIdx].size); // 4. 获取参数,检查长度合法性
// 大小检查 + 边界保护 (最大20个寄存器) uint16_t pointNum = get_register(readST[prevIdx].size);
if (thisSize > 20 || thisSize * 2 + 11 != size) { if (pointNum > 20 || pointNum * 2 + 11 != size) {
return 0; return false; // 长度不匹配或超出最大限制,丢弃
} }
// SLMP使用小端序: 低字节在前,高字节在后 // 5. 解析响应数据,存储到寄存器映射
for (int i = 0; i < thisSize; i++) { // SLMP数据使用小端序: 低字节在前,高字节在后
for (int i = 0; i < pointNum; i++) {
uint8_t byte_l = slmp_rxbuf[i * 2 + 11]; uint8_t byte_l = slmp_rxbuf[i * 2 + 11];
uint8_t byte_h = slmp_rxbuf[i * 2 + 12]; uint8_t byte_h = slmp_rxbuf[i * 2 + 12];
uint16_t value = ((uint16_t)byte_l) | (((uint16_t)byte_h) << 8); uint16_t value = ((uint16_t)byte_l) | (((uint16_t)byte_h) << 8);
// 存储位置: 1200 + (索引*20) + 偏移 // 存储地址: 1200 + (索引*20) + 偏移
set_register(1200 + (20 * prevIdx) + i, value); 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 slmp_build_send(void) {
uint16_t sendsize = 0; uint16_t sendsize = 0;
uint16_t slave_id; uint16_t slave_id;
uint16_t plc_address; uint16_t plc_address;
uint16_t size; uint16_t pointNum;
// 奇数索引 -> 读操作 (和FINS一致,读使用readST) // ========== 奇数索引: 读操作 ==========
if (slmp_idx % 2 == 1) { if (slmp_idx % 2 == 1) {
// 从readST获取参数
slave_id = get_register(readST[slmp_idx].slave_id); slave_id = get_register(readST[slmp_idx].slave_id);
plc_address = get_register(readST[slmp_idx].plc_address); 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 || pointNum == 0 || pointNum > 20) {
return 0;
}
if ((plc_address + pointNum) >= 8000) {
return 0; // 地址越界
}
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.cmd = 0x0401; // 读命令码
slmp_frame.frameStruct.requestSize = 0x000C; // 请求长度固定12字节 slmp_frame.frameStruct.requestSize = 0x000C; // 请求长度固定12字节
slmp_frame.frameStruct.start = u32_to_slmp24(plc_address); slmp_frame.frameStruct.start = u32_to_slmp24(plc_address);
slmp_frame.frameStruct.size = size; slmp_frame.frameStruct.size = pointNum;
sendsize = 21; // 帧头长度固定21字节,无额外数据 sendsize = 21; // 读请求只有帧头,固定21字节
// 拷贝到发送缓冲区,带边界检查
// 拷贝帧头到发送缓冲区,带边界检查
for (int i = 0; i < sendsize && i < sizeof(slmp_txbuf); i++) { for (int i = 0; i < sendsize && i < sizeof(slmp_txbuf); i++) {
slmp_txbuf[i] = slmp_frame.frameU8[i]; slmp_txbuf[i] = slmp_frame.frameU8[i];
} }
} }
// ========== 偶数索引: 写操作 ==========
} else { else {
// 偶数索引 -> 写操作 (和FINS一致,写使用writeST) // 从writeST获取参数
slave_id = get_register(writeST[slmp_idx].slave_id); slave_id = get_register(writeST[slmp_idx].slave_id);
plc_address = get_register(writeST[slmp_idx].plc_address); 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; if (slave_id < 0x01 || slave_id > 0xF7 || pointNum == 0 || pointNum > 20) {
} else if ((plc_address + size) >= 8000) {
sendsize = 0;
} else {
sendsize = 21 + (size * 2); // 帧头 + 数据
// 检查缓冲区边界,防止越界
if (sendsize > sizeof(slmp_txbuf)) {
return 0; return 0;
} }
if ((plc_address + pointNum) >= 8000) {
return 0; // 地址越界
}
sendsize = 21 + (pointNum * 2); // 帧头21字节 + 数据2字节*点数
if (sendsize > sizeof(slmp_txbuf)) {
return 0; // 超出缓冲区,安全保护
}
// 构建写请求帧 // 构建写请求帧
slmp_frame.frameStruct.cmd = 0x1401; // 写命令 slmp_frame.frameStruct.cmd = 0x1401; // 写命令码
slmp_frame.frameStruct.requestSize = 0x000C + (size * 2); slmp_frame.frameStruct.requestSize = 0x000C + (pointNum * 2);
slmp_frame.frameStruct.start = u32_to_slmp24(plc_address); slmp_frame.frameStruct.start = u32_to_slmp24(plc_address);
slmp_frame.frameStruct.size = size; slmp_frame.frameStruct.size = pointNum;
// 填充数据,SLMP小端序: 低字节在前 // 填充数据: SLMP小端序,低字节在前
for (int i = 0; i < size; i++) { for (int i = 0; i < pointNum; i++) {
uint16_t value = get_register(1000 + (20 * slmp_idx) + i); uint16_t value = get_register(1000 + (20 * slmp_idx) + i);
slmp_txbuf[i * 2 + 21] = value & 0xFF; // 低字节在前 slmp_txbuf[i * 2 + 21] = value & 0xFF; // 低字节在前
slmp_txbuf[i * 2 + 22] = (value >> 8) & 0xFF; // 高字节在后 slmp_txbuf[i * 2 + 22] = (value >> 8) & 0xFF; // 高字节在后
@@ -172,35 +216,45 @@ uint16_t slmp_build_send(void) {
slmp_txbuf[i] = slmp_frame.frameU8[i]; slmp_txbuf[i] = slmp_frame.frameU8[i];
} }
} }
}
// 索引轮转 (0~9对应10个通道) // 索引轮转,下次处理下一个通道
slmp_idx = (slmp_idx + 1) % 10; slmp_idx = (slmp_idx + 1) % 10;
return sendsize; return sendsize;
} }
// SLMP超时计数,由主循环调用 (和FINS一致) /**
* @brief 超时计数,由主循环每次调用递增
* @note 和FINS完全一致
*/
void update_timeout_slmp(void) { void update_timeout_slmp(void) {
if (slmpTimegap < 0xffff) { if (slmpTimegap < 0xffff) {
slmpTimegap++; 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 loopback_tcpc_slmp(uint8_t sn, uint8_t *destip, uint16_t destport) {
int32_t ret; int32_t ret;
uint16_t size = 0, sentsize = 0; 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: case SOCK_ESTABLISHED:
if (getSn_IR(sn) & Sn_IR_CON) { 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 = getSn_RX_RSR(sn)) > 0) {
// 边界保护,不超过缓冲区大小 // 边界保护,不超过缓冲区
if (size > sizeof(slmp_rxbuf)) { if (size > sizeof(slmp_rxbuf)) {
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; return ret;
} else { } else {
comm_count++; comm_count++;
slmp_handle_recv(ret); slmp_handle_recv(ret); // 处理响应
slmpTimegap = 900; // 重置超时 slmpTimegap = 900; // 重置超时
} }
} }
// 超时到了,发送下一个请求 // 2. 超时到了,发送下一个请求
size = 0; size = 0;
if (slmpTimegap > 1000) { if (slmpTimegap > 1000) {
size = slmp_build_send(); size = slmp_build_send(); // 构建请求
if (size == 0) { if (size == 0) {
slmpTimegap = 1000; slmpTimegap = 1000; // 参数非法,等待下一次
} }
} }
// 发送请求 // 3. 发送请求(分片发送,直到发完)
sentsize = 0; sentsize = 0;
while (size != 0 && sentsize != size) { while (size != 0 && sentsize != size) {
ret = send(sn, slmp_txbuf + sentsize, size - sentsize); 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; break;
// ========== 对方关闭连接 ==========
case SOCK_CLOSE_WAIT: case SOCK_CLOSE_WAIT:
if ((ret = disconnect(sn)) != SOCK_OK) { if ((ret = disconnect(sn)) != SOCK_OK) {
return ret; return ret;
} }
break; break;
// ========== 初始化: 发起连接 ==========
case SOCK_INIT: case SOCK_INIT:
if ((ret = connect(sn, destip, destport)) != SOCK_OK) { if ((ret = connect(sn, destip, destport)) != SOCK_OK) {
return ret; return ret;
} }
break; break;
// ========== socket未打开: 新建socket ==========
case SOCK_CLOSED: case SOCK_CLOSED:
close(sn); close(sn);
// 端口绕回处理 (和FINS一致) // 端口绕回,超过最大值后重置
if (any_port == 0xffff) { if (any_port == 0xffff) {
any_port = 50000; any_port = 50000;
} }
@@ -261,5 +318,6 @@ int32_t loopback_tcpc_slmp(uint8_t sn, uint8_t *destip, uint16_t destport) {
default: default:
break; break;
} }
return 1; return 1;
} }
+38 -11
View File
@@ -1,3 +1,7 @@
/**
* @file slmptcpmaster.h
* @brief 三菱SLMP协议TCP客户端主站头文件
*/
#ifndef SLMPTCPMASTER_H #ifndef SLMPTCPMASTER_H
#define SLMPTCPMASTER_H #define SLMPTCPMASTER_H
@@ -8,24 +12,47 @@ extern "C" {
#include <stdint.h> #include <stdint.h>
#include <stdbool.h> #include <stdbool.h>
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); _Bool slmp_handle_recv(uint16_t size);
// 构建SLMP请求,返回发送长度 /**
* @brief 构建SLMP请求帧
* @return 发送长度,0表示不发送(参数非法)
*/
uint16_t slmp_build_send(void); uint16_t slmp_build_send(void);
// 超时计数,由主循环调用 /**
* @brief 超时计数,由主循环每次调用递增
*/
void update_timeout_slmp(void); 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); int32_t loopback_tcpc_slmp(uint8_t sn, uint8_t *destip, uint16_t destport);
#ifdef __cplusplus #ifdef __cplusplus