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
+535 -253

No files matched your search

+132 -82
View File
@@ -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 <string.h>
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;
}