refactor: 分文件重构,新建protocols文件夹,三个协议分文件存放:modbustcpslave/finsudpmaster/slmptcpmaster,结构更清晰

This commit is contained in:
claw committed 2026-04-02 22:35:56 +08:00
1 parent 99fa72eaa0
commit e3519bf1f4
8 files changed
+852 -741

No files matched your search

+265
View File
@@ -0,0 +1,265 @@
/*
* slmptcpmaster.c
* 三菱SLMP TCP通信主站
* 轮询方式: slmp_idx 0~9轮转, 奇数索引读(readST), 偶数索引写(writeST)
* 和FINS完全相同的架构
*/
#include "slmptcpmaster.h"
#include "socket.h"
#include "wizchip_conf.h"
#include "rtuMaster.h"
#include "main.h"
#include <string.h>
// 24位小端存储结构体 (SLMP使用)
typedef union {
uint8_t bytes[3];
struct {
uint8_t byte0; // 最低字节
uint8_t byte1; // 中间字节
uint8_t byte2; // 最高字节
};
} slmp_uint24_t;
// 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; // 读写点数
} frameStruct;
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; // 当前读写点数
static SLMPFrame slmp_frame = {
.frameStruct.header = 0x0050,
.frameStruct.target = 0xff00,
.frameStruct.index = 0x03FF,
.frameStruct.subIdx = 0x00,
.frameStruct.timeout = 0x0004,
.frameStruct.subCmd = 0x0000,
.frameStruct.dm = 0xA8
};
// 32位转换为SLMP 24位小端
static slmp_uint24_t u32_to_slmp24(uint32_t val) {
slmp_uint24_t r;
r.byte0 = val & 0xFF;
r.byte1 = (val >> 8) & 0xFF;
r.byte2 = (val >> 16) & 0xFF;
return r;
}
// 处理SLMP接收到的响应
// 返回1: 处理成功,0: 不是有效响应
_Bool slmp_handle_recv(uint16_t size) {
// 只有读响应需要处理数据,写响应不需要存储
// 比对读响应头确认
if (memcmp(slmp_rxbuf, slmp_read_resp_header, 7) != 0) {
return 0; // 不是读响应,直接忽略
}
// 找到上一次发送对应的索引 (发送后索引+1,响应对应前一个)
uint16_t prevIdx;
if (slmp_idx == 0) {
prevIdx = 9;
} else {
prevIdx = slmp_idx - 1;
}
// 读使用奇数索引,验证一下
if (prevIdx % 2 != 1) {
return 0; // 不匹配,丢弃
}
uint16_t thisSize = get_register(readST[prevIdx].size);
// 大小检查 + 边界保护 (最大20个寄存器)
if (thisSize > 20 || thisSize * 2 + 11 != size) {
return 0;
}
// SLMP使用小端序: 低字节在前,高字节在后
for (int i = 0; i < thisSize; 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) + 偏移
set_register(1200 + (20 * prevIdx) + i, value);
}
return 1;
}
// 构建SLMP请求,返回发送长度
uint16_t slmp_build_send(void) {
uint16_t sendsize = 0;
uint16_t slave_id;
uint16_t plc_address;
uint16_t size;
// 奇数索引 -> 读操作 (和FINS一致,读使用readST)
if (slmp_idx % 2 == 1) {
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);
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];
}
}
} else {
// 偶数索引 -> 写操作 (和FINS一致,写使用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);
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;
}
// 构建写请求帧
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;
// 填充数据,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; // 高字节在后
}
// 拷贝帧头到发送缓冲区
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一致)
void update_timeout_slmp(void) {
if (slmpTimegap < 0xffff) {
slmpTimegap++;
}
}
// SLMP TCP客户端主函数 (和FINS相同结构)
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;
switch (getSn_SR(sn)) {
case SOCK_ESTABLISHED:
if (getSn_IR(sn) & Sn_IR_CON) {
setSn_IR(sn, Sn_IR_CON);
}
// 接收响应
if ((size = getSn_RX_RSR(sn)) > 0) {
// 边界保护,不超过缓冲区大小
if (size > sizeof(slmp_rxbuf)) {
size = sizeof(slmp_rxbuf);
}
ret = recv(sn, slmp_rxbuf, size);
if (ret <= 0) {
return ret;
} else {
comm_count++;
slmp_handle_recv(ret);
slmpTimegap = 900; // 重置超时
}
}
// 超时到了,发送下一个请求
size = 0;
if (slmpTimegap > 1000) {
size = slmp_build_send();
if (size == 0) {
slmpTimegap = 1000;
}
}
// 发送请求
sentsize = 0;
while (size != 0 && sentsize != size) {
ret = send(sn, slmp_txbuf + sentsize, size - sentsize);
if (ret < 0) {
close(sn);
return ret;
}
sentsize += ret;
}
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;
case SOCK_CLOSED:
close(sn);
// 端口绕回处理 (和FINS一致)
if (any_port == 0xffff) {
any_port = 50000;
}
if ((ret = socket(sn, Sn_MR_TCP, any_port++, SF_IO_NONBLOCK)) != sn) {
return ret;
}
break;
default:
break;
}
return 1;
}