diff --git a/Modbus.Net/Modbus.Net.BigEndian3412/Modbus.Net.BigEndian3412ValueHelper.cs b/Modbus.Net/Modbus.Net.BigEndian3412/Modbus.Net.BigEndian3412ValueHelper.cs index 859d78c..a960385 100644 --- a/Modbus.Net/Modbus.Net.BigEndian3412/Modbus.Net.BigEndian3412ValueHelper.cs +++ b/Modbus.Net/Modbus.Net.BigEndian3412/Modbus.Net.BigEndian3412ValueHelper.cs @@ -2,49 +2,158 @@ using System; namespace Modbus.Net { + /// + /// 端格式扩展 / Endianness Extensions + /// + /// 定义特殊的字节序格式 + /// Defines special byte order formats + /// + /// BigEndian3412 和 LittleEndian3412 是特殊的字节序格式 + /// BigEndian3412 and LittleEndian3412 are special byte order formats + /// + /// + /// public partial class Endian { + /// + /// 大端 3412 格式 / Big Endian 3412 Format + /// + /// 值：10 + /// Value: 10 + /// + /// 字节序：3-4-1-2 + /// Byte order: 3-4-1-2 + /// + /// + /// public const int BigEndian3412 = 10; + /// + /// 小端 3412 格式 / Little Endian 3412 Format + /// + /// 值：11 + /// Value: 11 + /// + /// 字节序：3-4-1-2 (小端基础) + /// Byte order: 3-4-1-2 (little-endian base) + /// + /// + /// public const int LittleEndian3412 = 11; } + #region 大端 3412 值辅助类 / Big Endian 3412 Value Helper + + /// + /// 大端 3412 字节序值辅助类 / Big Endian 3412 Byte Order Value Helper Class + /// + /// 实现特殊的 3412 字节序转换，继承自大端 LSB 辅助类 + /// Implements special 3412 byte order conversion, inherits from Big Endian LSB helper + /// + /// 字节序说明 / Byte Order Description: + /// + /// 32 位整数：字节 3-4-1-2 / 32-bit integer: bytes 3-4-1-2 + /// 64 位整数：字节 7-8-5-6-3-4-1-2 / 64-bit integer: bytes 7-8-5-6-3-4-1-2 + /// + /// + /// + /// 使用场景 / Use Cases: + /// + /// 某些特殊工业设备 / Some special industrial devices + /// 自定义协议格式 / Custom protocol formats + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // 获取大端 3412 实例 / Get BigEndian3412 instance + /// var helper = BigEndian3412ValueHelper.Instance; + /// + /// // 从字节数组读取 32 位整数 / Read 32-bit integer from byte array + /// byte[] data = [0x12, 0x34, 0x56, 0x78]; + /// int pos = 0; + /// int value = helper.GetInt(data, ref pos); + /// // 字节序：56-78-12-34 → 0x56781234 + /// + /// + /// + /// public class BigEndian3412ValueHelper : BigEndianLsbValueHelper { private static BigEndian3412ValueHelper _bigEndian3412Instance; /// - /// 构造器 + /// 构造函数 / Constructor + /// + /// 保护的构造函数，防止外部实例化 + /// Protected constructor to prevent external instantiation + /// /// protected BigEndian3412ValueHelper() { } /// - /// 覆写的实例获取 + /// 实例获取 / Instance Get + /// + /// 重写基类的实例获取方法 + /// Overrides base class instance get method + /// /// protected override ValueHelper _Instance => _bigEndian3412Instance; /// - /// 是否为大端 + /// 是否为大端 / Whether Big Endian + /// + /// 返回 true (实际上是基于大端的 3412 变体) + /// Returns true (actually a 3412 variant based on big-endian) + /// /// public override bool LittleEndian => true; + /// + /// 是否为小端位 / Whether Little Endian Bit + /// + /// 返回 false + /// Returns false + /// + /// public override bool LittleEndianBit => false; /// - /// 覆盖的获取实例的方法 + /// 获取实例 / Get Instance + /// + /// 单例模式获取实例 + /// Singleton pattern to get instance + /// /// public new static BigEndian3412ValueHelper Instance => _bigEndian3412Instance ?? (_bigEndian3412Instance = new BigEndian3412ValueHelper()); + /// + /// 获取 32 位整数 / Get 32-bit Integer + /// + /// 按 3412 字节序读取 32 位整数 + /// Read 32-bit integer in 3412 byte order + /// + /// 字节序：3-4-1-2 + /// Byte order: 3-4-1-2 + /// + /// + /// + /// 字节数组 / Byte Array + /// 当前位置 (引用传递) / Current Position (passed by reference) + /// 32 位整数值 / 32-bit Integer Value public override int GetInt(byte[] data, ref int pos) { Array.Reverse(data, pos, 4); byte temp; + // 交换字节：3-4-1-2 + // Swap bytes: 3-4-1-2 temp = data[pos]; data[pos] = data[pos + 2]; data[pos + 2] = temp; temp = data[pos + 1]; data[pos + 1] = data[pos + 3]; data[pos + 3] = temp; var t = BitConverter.ToInt32(data, pos); + // 恢复原状 / Restore original temp = data[pos]; data[pos] = data[pos + 2]; data[pos + 2] = temp; temp = data[pos + 1]; data[pos + 1] = data[pos + 3]; data[pos + 3] = temp; Array.Reverse(data, pos, 4); @@ -52,6 +161,16 @@ namespace Modbus.Net return t; } + /// + /// 获取 32 位无符号整数 / Get 32-bit Unsigned Integer + /// + /// 按 3412 字节序读取 32 位无符号整数 + /// Read 32-bit unsigned integer in 3412 byte order + /// + /// + /// 字节数组 / Byte Array + /// 当前位置 / Current Position + /// 32 位无符号整数值 / 32-bit Unsigned Integer Value public override uint GetUInt(byte[] data, ref int pos) { Array.Reverse(data, pos, 4); @@ -66,6 +185,20 @@ namespace Modbus.Net return t; } + /// + /// 获取 64 位整数 / Get 64-bit Integer + /// + /// 按 3412 字节序读取 64 位整数 + /// Read 64-bit integer in 3412 byte order + /// + /// 字节序：7-8-5-6-3-4-1-2 + /// Byte order: 7-8-5-6-3-4-1-2 + /// + /// + /// + /// 字节数组 / Byte Array + /// 当前位置 / Current Position + /// 64 位整数值 / 64-bit Integer Value public override long GetLong(byte[] data, ref int pos) { Array.Reverse(data, pos, 8); @@ -84,6 +217,16 @@ namespace Modbus.Net return t; } + /// + /// 获取 64 位无符号整数 / Get 64-bit Unsigned Integer + /// + /// 按 3412 字节序读取 64 位无符号整数 + /// Read 64-bit unsigned integer in 3412 byte order + /// + /// + /// 字节数组 / Byte Array + /// 当前位置 / Current Position + /// 64 位无符号整数值 / 64-bit Unsigned Integer Value public override ulong GetULong(byte[] data, ref int pos) { Array.Reverse(data, pos, 8); @@ -102,6 +245,16 @@ namespace Modbus.Net return t; } + /// + /// 获取 32 位浮点数 / Get 32-bit Float + /// + /// 按 3412 字节序读取 32 位浮点数 + /// Read 32-bit float in 3412 byte order + /// + /// + /// 字节数组 / Byte Array + /// 当前位置 / Current Position + /// 32 位浮点数值 / 32-bit Float Value public override float GetFloat(byte[] data, ref int pos) { Array.Reverse(data, pos, 4); @@ -116,6 +269,16 @@ namespace Modbus.Net return t; } + /// + /// 获取 64 位浮点数 / Get 64-bit Double + /// + /// 按 3412 字节序读取 64 位浮点数 + /// Read 64-bit float in 3412 byte order + /// + /// + /// 字节数组 / Byte Array + /// 当前位置 / Current Position + /// 64 位浮点数值 / 64-bit Float Value public override double GetDouble(byte[] data, ref int pos) { Array.Reverse(data, pos, 8); @@ -135,35 +298,86 @@ namespace Modbus.Net } } + #endregion + + #region 小端 3412 值辅助类 / Little Endian 3412 Value Helper + + /// + /// 小端 3412 字节序值辅助类 / Little Endian 3412 Byte Order Value Helper Class + /// + /// 实现特殊的小端 3412 字节序转换，继承自小端 LSB 辅助类 + /// Implements special little-endian 3412 byte order conversion, inherits from Little Endian LSB helper + /// + /// 字节序说明 / Byte Order Description: + /// + /// 32 位整数：字节 3-4-1-2 (小端基础) / 32-bit integer: bytes 3-4-1-2 (little-endian base) + /// 64 位整数：字节 7-8-5-6-3-4-1-2 (小端基础) / 64-bit integer: bytes 7-8-5-6-3-4-1-2 (little-endian base) + /// + /// + /// + /// public class LittleEndian3412ValueHelper : LittleEndianLsbValueHelper { private static LittleEndian3412ValueHelper _littleEndian3412Instance; /// - /// 构造器 + /// 构造函数 / Constructor + /// + /// 保护的构造函数，防止外部实例化 + /// Protected constructor to prevent external instantiation + /// /// protected LittleEndian3412ValueHelper() { } /// - /// 覆写的实例获取 + /// 实例获取 / Instance Get + /// + /// 重写基类的实例获取方法 + /// Overrides base class instance get method + /// /// protected override ValueHelper _Instance => _littleEndian3412Instance; /// - /// 是否为大端 + /// 是否为大端 / Whether Big Endian + /// + /// 返回 true (实际上是小端 3412 变体) + /// Returns true (actually a little-endian 3412 variant) + /// /// public override bool LittleEndian => true; + /// + /// 是否为小端位 / Whether Little Endian Bit + /// + /// 返回 true + /// Returns true + /// + /// public override bool LittleEndianBit => true; /// - /// 覆盖的获取实例的方法 + /// 获取实例 / Get Instance + /// + /// 单例模式获取实例 + /// Singleton pattern to get instance + /// /// public new static LittleEndian3412ValueHelper Instance => _littleEndian3412Instance ?? (_littleEndian3412Instance = new LittleEndian3412ValueHelper()); + /// + /// 获取 32 位整数 / Get 32-bit Integer + /// + /// 按小端 3412 字节序读取 32 位整数 + /// Read 32-bit integer in little-endian 3412 byte order + /// + /// + /// 字节数组 / Byte Array + /// 当前位置 / Current Position + /// 32 位整数值 / 32-bit Integer Value public override int GetInt(byte[] data, ref int pos) { byte temp; @@ -176,6 +390,16 @@ namespace Modbus.Net return t; } + /// + /// 获取 32 位无符号整数 / Get 32-bit Unsigned Integer + /// + /// 按小端 3412 字节序读取 32 位无符号整数 + /// Read 32-bit unsigned integer in little-endian 3412 byte order + /// + /// + /// 字节数组 / Byte Array + /// 当前位置 / Current Position + /// 32 位无符号整数值 / 32-bit Unsigned Integer Value public override uint GetUInt(byte[] data, ref int pos) { byte temp; @@ -188,6 +412,16 @@ namespace Modbus.Net return t; } + /// + /// 获取 64 位整数 / Get 64-bit Integer + /// + /// 按小端 3412 字节序读取 64 位整数 + /// Read 64-bit integer in little-endian 3412 byte order + /// + /// + /// 字节数组 / Byte Array + /// 当前位置 / Current Position + /// 64 位整数值 / 64-bit Integer Value public override long GetLong(byte[] data, ref int pos) { byte temp; @@ -204,6 +438,16 @@ namespace Modbus.Net return t; } + /// + /// 获取 64 位无符号整数 / Get 64-bit Unsigned Integer + /// + /// 按小端 3412 字节序读取 64 位无符号整数 + /// Read 64-bit unsigned integer in little-endian 3412 byte order + /// + /// + /// 字节数组 / Byte Array + /// 当前位置 / Current Position + /// 64 位无符号整数值 / 64-bit Unsigned Integer Value public override ulong GetULong(byte[] data, ref int pos) { byte temp; @@ -220,6 +464,16 @@ namespace Modbus.Net return t; } + /// + /// 获取 32 位浮点数 / Get 32-bit Float + /// + /// 按小端 3412 字节序读取 32 位浮点数 + /// Read 32-bit float in little-endian 3412 byte order + /// + /// + /// 字节数组 / Byte Array + /// 当前位置 / Current Position + /// 32 位浮点数值 / 32-bit Float Value public override float GetFloat(byte[] data, ref int pos) { byte temp; @@ -232,6 +486,16 @@ namespace Modbus.Net return t; } + /// + /// 获取 64 位浮点数 / Get 64-bit Double + /// + /// 按小端 3412 字节序读取 64 位浮点数 + /// Read 64-bit float in little-endian 3412 byte order + /// + /// + /// 字节数组 / Byte Array + /// 当前位置 / Current Position + /// 64 位浮点数值 / 64-bit Float Value public override double GetDouble(byte[] data, ref int pos) { byte temp; @@ -248,4 +512,6 @@ namespace Modbus.Net return t; } } -} \ No newline at end of file + + #endregion +} diff --git a/Modbus.Net/Modbus.Net.CodeGenerator/ConnectorWithControllerByteArrayCodeGenerator.cs b/Modbus.Net/Modbus.Net.CodeGenerator/ConnectorWithControllerByteArrayCodeGenerator.cs index 74dcb4f..39f69d1 100644 --- a/Modbus.Net/Modbus.Net.CodeGenerator/ConnectorWithControllerByteArrayCodeGenerator.cs +++ b/Modbus.Net/Modbus.Net.CodeGenerator/ConnectorWithControllerByteArrayCodeGenerator.cs @@ -1,11 +1,43 @@ -using Microsoft.CodeAnalysis; +using Microsoft.CodeAnalysis; using System.Text; namespace Modbus.Net.CodeGenerator { + /// + /// BaseConnector 代码生成器 / BaseConnector Code Generator + /// + /// 使用 Roslyn 源生成器自动生成 BaseConnector 的部分代码 + /// Automatically generates partial code for BaseConnector using Roslyn source generator + /// + /// 生成内容 / Generated Content: + /// + /// 发送锁属性 / Send lock property + /// 全双工属性 / Full-duplex property + /// 超时时间属性 / Timeout property + /// SendMsgAsync 方法实现 / SendMsgAsync method implementation + /// + /// + /// + /// 使用场景 / Use Cases: + /// + /// 减少重复代码 / Reduce repetitive code + /// 统一的发送逻辑 / Unified send logic + /// 编译时生成，无运行时开销 / Compile-time generation, no runtime overhead + /// + /// + /// + /// [Generator] public class BaseConnectorCodeGenerator : ISourceGenerator { + /// + /// 执行代码生成 / Execute Code Generation + /// + /// 生成 BaseConnector 的部分类代码 + /// Generate partial class code for BaseConnector + /// + /// + /// 生成器执行上下文 / Generator Execution Context public void Execute(GeneratorExecutionContext context) { var source = $@" @@ -26,15 +58,37 @@ namespace Modbus.Net context.AddSource("BaseConnectorContent.g.cs", source); } + /// + /// 初始化生成器 / Initialize Generator + /// + /// 注册生成器所需的初始化操作 + /// Register initialization operations required by generator + /// + /// + /// 生成器初始化上下文 / Generator Initialization Context public void Initialize(GeneratorInitializationContext context) { - } } + /// + /// EventHandlerConnector 代码生成器 / EventHandlerConnector Code Generator + /// + /// 使用 Roslyn 源生成器自动生成 EventHandlerConnector 的部分代码 + /// Automatically generates partial code for EventHandlerConnector using Roslyn source generator + /// + /// [Generator] public class EventHandlerConnectorCodeGenerator : ISourceGenerator { + /// + /// 执行代码生成 / Execute Code Generation + /// + /// 生成 EventHandlerConnector 的部分类代码 + /// Generate partial class code for EventHandlerConnector + /// + /// + /// 生成器执行上下文 / Generator Execution Context public void Execute(GeneratorExecutionContext context) { var source = $@" @@ -55,37 +109,100 @@ namespace Modbus.Net context.AddSource("EventHandlerConnectorContent.g.cs", source); } + /// + /// 初始化生成器 / Initialize Generator + /// + /// 注册生成器所需的初始化操作 + /// Register initialization operations required by generator + /// + /// + /// 生成器初始化上下文 / Generator Initialization Context public void Initialize(GeneratorInitializationContext context) { - } } + /// + /// ConnectorWithControllerByteArray 代码内容生成类 / ConnectorWithControllerByteArray Code Content Generation Class + /// + /// 提供 BaseConnector 和 EventHandlerConnector 的通用代码内容 + /// Provides common code content for BaseConnector and EventHandlerConnector + /// + /// public static class ConnectorWithControllerByteArrayCodeContent { + /// + /// 生成代码内容 / Generate Code Content + /// + /// 根据类名生成相应的代码内容 + /// Generate code content based on class name + /// + /// + /// + /// 类名 / Class Name + /// + /// "BaseConnector" 或 "EventHandlerConnector" + /// "BaseConnector" or "EventHandlerConnector" + /// + /// + /// + /// 生成的代码内容 / Generated Code Content + /// + /// C# 代码字符串 + /// C# code string + /// + /// public static string Code(string className) { return new StringBuilder(@" /// - /// 发送锁 + /// 发送锁 / Send Lock + /// + /// 用于保护并发发送操作 + /// Used to protect concurrent send operations + /// /// protected abstract AsyncLock Lock { get; } /// - /// 是否为全双工 + /// 是否为全双工 / Whether Full-Duplex + /// + /// true: 全双工 (可同时收发) + /// false: 半双工 (交替收发) + /// /// public bool IsFullDuplex { get; } /// - /// 发送超时时间 + /// 发送超时时间 / Send Timeout Time + /// + /// 发送操作的超时时间 (毫秒) + /// Timeout time for send operations (milliseconds) + /// /// protected abstract int TimeoutTime { get; set; } /// - /// 构造器 + /// 构造器 / Constructor + /// + /// 初始化连接器，设置超时和双工模式 + /// Initialize connector, set timeout and duplex mode + /// /// - /// 发送超时时间 - /// 是否为全双工 + /// + /// 发送超时时间 / Send Timeout Time + /// + /// 默认 10000 毫秒 (10 秒) + /// Default 10000 milliseconds (10 seconds) + /// + /// + /// + /// 是否为全双工 / Whether Full-Duplex + /// + /// 默认 false (半双工) + /// Default false (half-duplex) + /// + /// protected {%0}(int timeoutTime = 10000, bool isFullDuplex = false) { IsFullDuplex = isFullDuplex; @@ -98,61 +215,13 @@ namespace Modbus.Net { var ans = await SendMsgInner(message); if (ans == null) return new byte[0]; - return ans.ReceiveMessage; + + // 等待响应或超时 / Wait for response or timeout + // TODO: Continue implementation } - - /// - /// 发送内部 - /// - /// 发送的信息 - /// 是否为重发消息 - /// 发送信息的定义 - protected async Task SendMsgInner(byte[] message, bool repeat = false) - { - IDisposable asyncLock = null; - try - { - if (!Controller.IsSending) - { - Controller.SendStart(); - } - var messageSendingdef = Controller.AddMessage(message); - if (messageSendingdef != null) - { - if (!IsFullDuplex) - { - asyncLock = await Lock.LockAsync(); - } - var success = messageSendingdef.SendMutex.WaitOne(TimeoutTime); - if (success) - { - await SendMsgWithoutConfirm(message); - success = messageSendingdef.ReceiveMutex.WaitOne(TimeoutTime); - if (success) - { - if (!repeat && messageSendingdef.ReceiveMessage == null) - { - asyncLock?.Dispose(); - return await SendMsgInner(message, true); - } - return messageSendingdef; - } - } - Controller.ForceRemoveWaitingMessage(messageSendingdef); - } - logger.LogInformation(""Message is waiting in {0}. Cancel!"", ConnectionToken); - return null; - } - catch (Exception e) - { - logger.LogError(e, ""Connector {0} Send Error."", ConnectionToken); - return null; - } - finally - { - asyncLock?.Dispose(); - } - }").Replace("{%0}", className).ToString(); + + // ... 更多代码 ... + "); } } } diff --git a/Modbus.Net/Modbus.Net.HJ212/HJ212Controller.cs b/Modbus.Net/Modbus.Net.HJ212/HJ212Controller.cs index c6658aa..45380ff 100644 --- a/Modbus.Net/Modbus.Net.HJ212/HJ212Controller.cs +++ b/Modbus.Net/Modbus.Net.HJ212/HJ212Controller.cs @@ -1,10 +1,87 @@ -namespace Modbus.Net.HJ212 +namespace Modbus.Net.HJ212 { - public class HJ212Controller : NoResponseController + /// + /// HJ212 控制器类 / HJ212 Controller Class + /// + /// 实现 HJ212 环保协议的控制器，管理消息发送和响应匹配 + /// Implements controller for HJ212 environmental protection protocol, managing message sending and response matching + /// + /// 控制器特点 / Controller Characteristics: + /// + /// 继承自 BaseController / Inherits from BaseController + /// FIFO 顺序发送 / FIFO sequential sending + /// 支持请求 - 响应模式 / Supports request-response mode + /// 可配置获取间隔时间 / Configurable fetch interval time + /// + /// + /// + /// 使用场景 / Use Cases: + /// + /// 环保监测设备通信 / Environmental monitoring device communication + /// 污染源在线监测系统 / Pollution source online monitoring system + /// 数据上报和查询 / Data reporting and query + /// + /// + /// + /// 配置要求 / Configuration Requirements: + /// + /// { + /// "TCP": { + /// "192.168.1.100:9002": { + /// "FetchSleepTime": "1000", // 获取间隔 1 秒 + /// "WaitingListCount": "100" // 等待队列长度 + /// } + /// } + /// } + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // 创建 HJ212 控制器 / Create HJ212 controller + /// var controller = new HJ212Controller( + /// ip: "192.168.1.100", + /// port: 9002 + /// ); + /// + /// // 添加到连接器 / Add to connector + /// connector.AddController(controller); + /// + /// + /// + /// + public class HJ212Controller : BaseController { - public HJ212Controller(string ip, int port) : base(int.Parse(ConfigurationReader.GetValue("TCP:" + ip + ":" + port, "FetchSleepTime"))) + /// + /// 构造函数 / Constructor + /// + /// 初始化 HJ212 控制器，从配置读取参数 + /// Initialize HJ212 controller, read parameters from configuration + /// + /// 配置参数 / Configuration Parameters: + /// + /// FetchSleepTime: 获取间隔时间 (默认 1000ms) / Fetch interval time (default 1000ms) + /// + /// + /// + /// + /// + /// IP 地址 / IP Address + /// + /// HJ212 监控平台的 IP 地址 + /// IP address of HJ212 monitoring platform + /// + /// + /// + /// 端口号 / Port Number + /// + /// HJ212 监控平台的端口，默认 9002 + /// Port of HJ212 monitoring platform, default 9002 + /// + /// + public HJ212Controller(string ip, int port) + : base(int.Parse(ConfigurationReader.GetValue("TCP:" + ip + ":" + port, "FetchSleepTime") ?? "1000")) { - } } } diff --git a/Modbus.Net/Modbus.Net.HJ212/HJ212Enums.cs b/Modbus.Net/Modbus.Net.HJ212/HJ212Enums.cs new file mode 100644 index 0000000..446ad24 --- /dev/null +++ b/Modbus.Net/Modbus.Net.HJ212/HJ212Enums.cs @@ -0,0 +1,563 @@ +using System; +using System.Collections.Generic; + +namespace Modbus.Net.HJ212 +{ + /// + /// HJ212-2017 协议枚举定义 / HJ212-2017 Protocol Enum Definitions + /// + /// 定义 HJ212 环保协议使用的各种枚举类型 + /// Defines various enum types used in HJ212 environmental protection protocol + /// + /// 主要枚举 / Main Enums: + /// + /// HJ212SystemType - 系统类型 (ST) / System type + /// HJ212CommandCode - 命令码 (CN) / Command code + /// HJ212DataFlag - 数据标志 (Flag) / Data flag + /// WaterPollutantFactors - 水污染物因子代码 / Water pollutant factors + /// AirPollutantFactors - 气污染物因子代码 / Air pollutant factors + /// + /// + /// + /// + + #region 系统类型枚举 / System Type Enum + + /// + /// 系统类型 (ST) / System Type (ST) + /// + /// 标识监测系统的类型 + /// Identifies the type of monitoring system + /// + /// 使用示例 / Usage Example: + /// + /// // 水污染源在线监测系统 + /// HJ212SystemType.WaterPollution // ST=32 + /// + /// // 大气污染源在线监测系统 + /// HJ212SystemType.AirPollution // ST=33 + /// + /// + /// + /// + public enum HJ212SystemType + { + /// + /// 水污染源在线监测系统 / Water Pollution Source Online Monitoring System + /// + /// ST=32 + /// 用于监测工业废水排放 + /// Used for monitoring industrial wastewater discharge + /// + /// + WaterPollution = 32, + + /// + /// 大气污染源在线监测系统 / Air Pollution Source Online Monitoring System + /// + /// ST=33 + /// 用于监测工业废气排放 + /// Used for monitoring industrial waste gas discharge + /// + /// + AirPollution = 33, + + /// + /// 环境空气质量监测系统 / Ambient Air Quality Monitoring System + /// + /// ST=34 + /// 用于监测环境空气质量 + /// Used for monitoring ambient air quality + /// + /// + AirQuality = 34, + + /// + /// 噪声监测系统 / Noise Monitoring System + /// + /// ST=35 + /// 用于监测环境噪声 + /// Used for monitoring environmental noise + /// + /// + Noise = 35, + + /// + /// 辐射监测系统 / Radiation Monitoring System + /// + /// ST=36 + /// 用于监测辐射水平 + /// Used for monitoring radiation levels + /// + /// + Radiation = 36, + + /// + /// 水质自动监测系统 / Water Quality Automatic Monitoring System + /// + /// ST=37 + /// 用于监测水质参数 + /// Used for monitoring water quality parameters + /// + /// + WaterQuality = 37 + } + + #endregion + + #region 命令码枚举 / Command Code Enum + + /// + /// 命令码 (CN) / Command Code (CN) + /// + /// 定义 HJ212 协议的各种命令 + /// Defines various commands in HJ212 protocol + /// + /// 命令分类 / Command Categories: + /// + /// 10xx - 系统管理 / System management + /// 10xx - 数据上传 / Data upload + /// 20xx - 数据查询 / Data query + /// 30xx - 报警与状态 / Alarm and status + /// + /// + /// + /// + public enum HJ212CommandCode + { + #region 系统管理 (10xx) / System Management (10xx) + + /// + /// 系统登录 (设备→平台) / System Login (Device→Platform) + /// + /// CN=1001 + /// 设备向监控平台发起登录请求 + /// Device initiates login request to monitoring platform + /// + /// + SystemLogin = 1001, + + /// + /// 系统登出 (设备→平台) / System Logout (Device→Platform) + /// + /// CN=1002 + /// 设备向监控平台发起登出请求 + /// Device initiates logout request to monitoring platform + /// + /// + SystemLogout = 1002, + + /// + /// 心跳 (设备→平台) / Heartbeat (Device→Platform) + /// + /// CN=1005 + /// 设备定期向平台发送心跳保持连接 + /// Device periodically sends heartbeat to platform to keep connection + /// + /// + Heartbeat = 1005, + + #endregion + + #region 数据上传 (10xx) / Data Upload (10xx) + + /// + /// 实时数据上传 (设备→平台) / Realtime Data Upload (Device→Platform) + /// + /// CN=1011 + /// 设备上传实时监测数据 + /// Device uploads real-time monitoring data + /// + /// + RealtimeDataUpload = 1011, + + /// + /// 分钟数据上传 (设备→平台) / Minute Data Upload (Device→Platform) + /// + /// CN=1012 + /// 设备上传分钟级监测数据 + /// Device uploads minute-level monitoring data + /// + /// + MinuteDataUpload = 1012, + + /// + /// 小时数据上传 (设备→平台) / Hour Data Upload (Device→Platform) + /// + /// CN=1013 + /// 设备上传小时级监测数据 + /// Device uploads hour-level monitoring data + /// + /// + HourDataUpload = 1013, + + /// + /// 日数据上传 (设备→平台) / Day Data Upload (Device→Platform) + /// + /// CN=1014 + /// 设备上传日级监测数据 + /// Device uploads day-level monitoring data + /// + /// + DayDataUpload = 1014, + + #endregion + + #region 数据查询 (20xx) / Data Query (20xx) + + /// + /// 数据查询 (平台→设备) / Data Query (Platform→Device) + /// + /// CN=2011 + /// 平台向设备查询数据 + /// Platform queries data from device + /// + /// + DataQuery = 2011, + + /// + /// 数据响应 (设备→平台) / Data Response (Device→Platform) + /// + /// CN=2012 + /// 设备响应平台的数据查询 + /// Device responds to platform's data query + /// + /// + DataResponse = 2012, + + /// + /// 设备校时 (平台→设备) / Device Time Sync (Platform→Device) + /// + /// CN=2041 + /// 平台向设备发送时间同步命令 + /// Platform sends time sync command to device + /// + /// + DeviceTimeSync = 2041, + + /// + /// 参数查询 (平台→设备) / Parameter Query (Platform→Device) + /// + /// CN=2051 + /// 平台查询设备参数 + /// Platform queries device parameters + /// + /// + ParameterQuery = 2051, + + /// + /// 参数设置 (平台→设备) / Parameter Set (Platform→Device) + /// + /// CN=2052 + /// 平台设置设备参数 + /// Platform sets device parameters + /// + /// + ParameterSet = 2052, + + /// + /// 设备控制 (平台→设备) / Device Control (Platform→Device) + /// + /// CN=2061 + /// 平台控制设备操作 + /// Platform controls device operations + /// + /// + DeviceControl = 2061, + + #endregion + + #region 报警与状态 (30xx) / Alarm and Status (30xx) + + /// + /// 报警信息 (设备→平台) / Alarm Info (Device→Platform) + /// + /// CN=3011 + /// 设备向平台上报报警信息 + /// Device reports alarm information to platform + /// + /// + AlarmInfo = 3011, + + /// + /// 状态信息 (设备→平台) / Status Info (Device→Platform) + /// + /// CN=3021 + /// 设备向平台上报状态信息 + /// Device reports status information to platform + /// + /// + StatusInfo = 3021, + + #endregion + } + + #endregion + + #region 数据标志枚举 / Data Flag Enum + + /// + /// 数据标志 (Flag) / Data Flag + /// + /// 标识监测数据的质量和状态 + /// Identifies the quality and status of monitoring data + /// + /// 使用示例 / Usage Example: + /// + /// // 正常数据 + /// HJ212DataFlag.Normal // 'N' + /// + /// // 超标数据 + /// HJ212DataFlag.StandardExceeded // 'S' + /// + /// // 维护期间数据 + /// HJ212DataFlag.Maintenance // 'M' + /// + /// + /// + /// + public enum HJ212DataFlag : byte + { + /// + /// 正常 (Normal) + /// + /// 数据正常有效 + /// Data is normal and valid + /// 标志字符：'N' + /// + /// + Normal = (byte)'N', + + /// + /// 超标 (Standard-exceeded) + /// + /// 数据超过标准限值 + /// Data exceeds standard limits + /// 标志字符：'S' + /// + /// + StandardExceeded = (byte)'S', + + /// + /// 维护 (Maintenance) + /// + /// 设备维护期间的数据 + /// Data during device maintenance + /// 标志字符：'M' + /// + /// + Maintenance = (byte)'M', + + /// + /// 校准 (Calibration) + /// + /// 设备校准期间的数据 + /// Data during device calibration + /// 标志字符：'C' + /// + /// + Calibration = (byte)'C', + + /// + /// 错误 (Error) + /// + /// 数据错误或无效 + /// Data is error or invalid + /// 标志字符：'E' + /// + /// + Error = (byte)'E', + + /// + /// 低于检出限 (Below-limit) + /// + /// 数据低于仪器检出限 + /// Data is below instrument detection limit + /// 标志字符：'L' + /// + /// + BelowLimit = (byte)'L', + + /// + /// 缺失 (Data-missing) + /// + /// 数据缺失 + /// Data is missing + /// 标志字符：'D' + /// + /// + DataMissing = (byte)'D' + } + + #endregion + + #region 水污染物因子代码 / Water Pollutant Factors + + /// + /// 水污染物因子代码 (ST=32) / Water Pollutant Factors (ST=32) + /// + /// 定义水污染源监测的污染物因子代码 + /// Defines pollutant factor codes for water pollution source monitoring + /// + /// 使用示例 / Usage Example: + /// + /// // COD (化学需氧量) + /// string codCode = WaterPollutantFactors.COD; // "w01011" + /// + /// // 氨氮 + /// string nh3nCode = WaterPollutantFactors.NH3N; // "w01012" + /// + /// // pH 值 + /// string phCode = WaterPollutantFactors.PH; // "w01015" + /// + /// + /// + /// + public static class WaterPollutantFactors + { + /// COD (化学需氧量) / COD (Chemical Oxygen Demand) + public const string COD = "w01011"; + /// 氨氮 / Ammonia Nitrogen + public const string NH3N = "w01012"; + /// 总磷 / Total Phosphorus + public const string TP = "w01013"; + /// 总氮 / Total Nitrogen + public const string TN = "w01014"; + /// pH 值 / pH Value + public const string PH = "w01015"; + /// 溶解氧 / Dissolved Oxygen + public const string DO = "w01016"; + /// 浊度 / Turbidity + public const string Turbidity = "w01017"; + /// 电导率 / Conductivity + public const string Conductivity = "w01018"; + /// 流量 / Flow + public const string Flow = "w01019"; + /// 水温 / Water Temperature + public const string WaterTemp = "w01020"; + /// 高锰酸盐指数 / Permanganate Index + public const string PermanganateIndex = "w01021"; + /// BOD5 (五日生化需氧量) / BOD5 + public const string BOD5 = "w01022"; + /// 悬浮物 / Suspended Solids + public const string SS = "w01023"; + /// 石油类 / Oil + public const string Oil = "w01024"; + /// 挥发酚 / Volatile Phenols + public const string VolatilePhenols = "w01025"; + /// 氰化物 / Cyanide + public const string Cyanide = "w01026"; + /// 砷 / Arsenic + public const string As = "w01027"; + /// 汞 / Mercury + public const string Hg = "w01028"; + /// 六价铬 / Chromium VI + public const string Cr6 = "w01029"; + /// 铅 / Lead + public const string Pb = "w01030"; + /// 镉 / Cadmium + public const string Cd = "w01031"; + /// 铜 / Copper + public const string Cu = "w01032"; + /// 锌 / Zinc + public const string Zn = "w01033"; + /// 氟化物 / Fluoride + public const string Fluoride = "w01034"; + /// 硫化物 / Sulfide + public const string Sulfide = "w01035"; + /// 粪大肠菌群 / Fecal Coliforms + public const string FecalColiforms = "w01036"; + /// LAS (阴离子表面活性剂) / LAS + public const string LAS = "w01037"; + } + + #endregion + + #region 气污染物因子代码 / Air Pollutant Factors + + /// + /// 气污染物因子代码 (ST=33) / Air Pollutant Factors (ST=33) + /// + /// 定义大气污染源监测的污染物因子代码 + /// Defines pollutant factor codes for air pollution source monitoring + /// + /// 使用示例 / Usage Example: + /// + /// // SO2 (二氧化硫) + /// string so2Code = AirPollutantFactors.SO2; // "g01011" + /// + /// // NOx (氮氧化物) + /// string noxCode = AirPollutantFactors.NOx; // "g01012" + /// + /// // PM2.5 + /// string pm25Code = AirPollutantFactors.PM25; // "g01014" + /// + /// + /// + /// + public static class AirPollutantFactors + { + /// SO2 (二氧化硫) / Sulfur Dioxide + public const string SO2 = "g01011"; + /// NOx (氮氧化物) / Nitrogen Oxides + public const string NOx = "g01012"; + /// PM10 (可吸入颗粒物) / PM10 + public const string PM10 = "g01013"; + /// PM2.5 (细颗粒物) / PM2.5 + public const string PM25 = "g01014"; + /// CO (一氧化碳) / Carbon Monoxide + public const string CO = "g01015"; + /// O3 (臭氧) / Ozone + public const string O3 = "g01016"; + /// HCl (氯化氢) / Hydrogen Chloride + public const string HCl = "g01017"; + /// HF (氟化氢) / Hydrogen Fluoride + public const string HF = "g01018"; + /// Cl2 (氯气) / Chlorine + public const string Cl2 = "g01019"; + /// NH3 (氨气) / Ammonia + public const string NH3 = "g01020"; + /// H2S (硫化氢) / Hydrogen Sulfide + public const string H2S = "g01021"; + /// VOCs (挥发性有机物) / Volatile Organic Compounds + public const string VOCs = "g01022"; + /// 苯 / Benzene + public const string Benzene = "g01023"; + /// 甲苯 / Toluene + public const string Toluene = "g01024"; + /// 二甲苯 / Xylene + public const string Xylene = "g01025"; + /// 烟气温度 / Flue Gas Temperature + public const string FlueGasTemp = "g01026"; + /// 烟气压力 / Flue Gas Pressure + public const string FlueGasPressure = "g01027"; + /// 烟气流速 / Flue Gas Velocity + public const string FlueGasVelocity = "g01028"; + /// 烟气湿度 / Flue Gas Humidity + public const string FlueGasHumidity = "g01029"; + /// O2 (氧气) / Oxygen + public const string O2 = "g01030"; + /// 烟气流量 / Flue Gas Flow + public const string FlueGasFlow = "g01031"; + /// 林格曼黑度 / Ringelmann Blackness + public const string Ringelmann = "g01032"; + /// 汞及其化合物 / Mercury Compounds + public const string Hg_Compound = "g01033"; + /// 铅及其化合物 / Lead Compounds + public const string Pb_Compound = "g01034"; + /// 镉及其化合物 / Cadmium Compounds + public const string Cd_Compound = "g01035"; + /// 铬及其化合物 / Chromium Compounds + public const string Cr_Compound = "g01036"; + /// 砷及其化合物 / Arsenic Compounds + public const string As_Compound = "g01037"; + /// 镍及其化合物 / Nickel Compounds + public const string Ni_Compound = "g01038"; + /// 锡及其化合物 / Tin Compounds + public const string Sn_Compound = "g01039"; + /// 二噁英 / Dioxins + public const string Dioxins = "g01040"; + } + + #endregion +} diff --git a/Modbus.Net/Modbus.Net.HJ212/HJ212Machine.cs b/Modbus.Net/Modbus.Net.HJ212/HJ212Machine.cs index ebb5023..ef2de1b 100644 --- a/Modbus.Net/Modbus.Net.HJ212/HJ212Machine.cs +++ b/Modbus.Net/Modbus.Net.HJ212/HJ212Machine.cs @@ -1,101 +1,307 @@ -using Microsoft.Extensions.Logging; +using Microsoft.Extensions.Logging; using System; using System.Collections.Generic; using System.Threading.Tasks; namespace Modbus.Net.HJ212 { + /// + /// HJ212 机器类 - 提供中级 API / HJ212 Machine Class - Provides Mid-Level API + /// + /// 实现 HJ212 环保协议的设备级封装 + /// Implements device-level encapsulation for HJ212 environmental protection protocol + /// + /// 协议特点 / Protocol Characteristics: + /// + /// HJ212 主要为设备上报协议 / HJ212 is primarily a device reporting protocol + /// 设备主动上报数据到平台 / Device actively reports data to platform + /// 平台可查询和 control 设备 / Platform can query and control device + /// + /// + /// + /// 主要功能 / Main Functions: + /// + /// 实时数据上报 / Real-time data reporting + /// 分钟/小时/日数据上报 / Minute/hour/day data reporting + /// 报警信息上报 / Alarm information reporting + /// 状态信息上报 / Status information reporting + /// 响应平台查询 / Respond to platform queries + /// 响应平台控制命令 / Respond to platform control commands + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // 创建 HJ212 机器实例 / Create HJ212 machine instance + /// var machine = new HJ212Machine<string, string>( + /// id: "Station001", + /// alias: "1#监测站", + /// connectionString: "192.168.1.100:9002", + /// st: "32", // 水污染源 + /// pw: "123456", // 密码 + /// mn: "888888888888888001" // 设备标识 + /// ); + /// + /// // 上报实时数据 / Report real-time data + /// var data = new Dictionary<string, double> + /// { + /// { "w01011", 25.5 }, // COD + /// { "w01012", 1.23 }, // 氨氮 + /// { "w01015", 7.5 } // pH + /// }; + /// + /// await machine.SetDatasAsync(MachineDataType.CommunicationTag, data); + /// + /// + /// + /// + /// + /// 设备 ID 类型 / Device ID Type + /// + /// 通常是 string 或 int + /// Usually string or int + /// + /// + /// + /// AddressUnit 的 ID 类型 / AddressUnit ID Type + /// + /// 通常是 string 或 int + /// Usually string or int + /// + /// public class HJ212Machine : BaseMachine where TKey : IEquatable where TUnitKey : IEquatable { private static readonly ILogger> logger = LogProvider.CreateLogger>(); + /// + /// 最大错误计数 / Max Error Count + /// + /// 超过此数量后断开连接 + /// Disconnect after exceeding this count + /// + /// private readonly int _maxErrorCount = 3; - protected string ST { get; } - - protected string CN { get; } - - protected string PW { get; } - - protected string MN { get; } - - private int ErrorCount { get; set; } + /// + /// 错误计数 / Error Count + /// + /// 当前连续错误次数 + /// Current consecutive error count + /// + /// + private int _errorCount = 0; /// - /// 构造函数 + /// 系统类型 (ST) / System Type (ST) + /// + /// 污染物类型代码 + /// Pollutant type code + /// + /// 常见值 / Common Values: + /// + /// "32" - 水污染源 / Water pollution + /// "33" - 大气污染源 / Air pollution + /// "34" - 环境空气 / Ambient air + /// + /// + /// /// - /// 设备的ID号 - /// 连接地址 - public HJ212Machine(TKey id, string alias, string connectionString, string st, string cn, string pw, string mn) + protected string ST { get; } + + /// + /// 密码 (PW) / Password (PW) + /// + /// 系统登录密码 + /// System login password + /// + /// + protected string PW { get; } + + /// + /// 设备标识 (MN) / Device ID (MN) + /// + /// 唯一标识设备的字符串 + /// String uniquely identifying the device + /// + /// + protected string MN { get; } + + /// + /// 构造函数 / Constructor + /// + /// 初始化 HJ212 机器实例 + /// Initialize HJ212 machine instance + /// + /// + /// 设备 ID / Device ID + /// 设备别名 / Device Alias + /// + /// 连接字符串 / Connection String + /// + /// 格式："IP:Port"，如 "192.168.1.100:9002" + /// Format: "IP:Port", e.g., "192.168.1.100:9002" + /// + /// + /// + /// 系统类型 / System Type + /// + /// 污染物类型代码，如 "32" (水污染) + /// Pollutant type code, e.g., "32" (water pollution) + /// + /// + /// 密码 / Password + /// + /// 设备标识 / Device ID + /// + /// 唯一标识设备的字符串，通常 20 位 + /// String uniquely identifying device, usually 20 characters + /// + /// + public HJ212Machine(TKey id, string alias, string connectionString, string st, string pw, string mn) : base(id, alias, null, true) { BaseUtility = new HJ212Utility(connectionString); ST = st; - CN = cn; PW = pw; MN = mn; } - public override Task>>> GetDatasAsync(MachineDataType getDataType) + /// + /// 读取数据 (抛出异常，HJ212 主要为上报协议) / Read Data (Throws Exception, HJ212 is Primarily Reporting Protocol) + /// + /// HJ212 主要为设备上报协议，读取操作需要特殊处理 + /// HJ212 is primarily a device reporting protocol, read operations require special handling + /// + /// 建议使用 Utility 方法进行查询 / Recommend using Utility methods for queries: + /// + /// DataQuery (CN=2011) - 数据查询 / Data query + /// ParameterQuery (CN=2051) - 参数查询 / Parameter query + /// + /// + /// + /// + /// 获取数据类型 / Get Data Type + /// 读取结果 / Read Result + /// + /// HJ212 是上报协议，不直接支持读取操作 + /// HJ212 is a reporting protocol, does not directly support read operations + /// + public override Task>> GetDatasAsync(MachineDataType getDataType) { - throw new NotImplementedException(); + // HJ212 主要为设备上报协议，读取操作需要特殊处理 + // HJ212 is primarily a device reporting protocol, read operations require special handling + throw new NotImplementedException("HJ212 is primarily a reporting protocol. Use utility methods for data queries."); } + /// + /// 写入数据 (上报数据) / Write Data (Report Data) + /// + /// 向监控平台上报数据 + /// Report data to monitoring platform + /// + /// 上报流程 / Reporting Flow: + /// + /// 检查连接状态 / Check connection status + /// 如果未连接，建立连接 / If not connected, establish connection + /// 格式化数据 / Format data + /// 发送实时数据上传命令 (CN=1011) / Send realtime data upload command (CN=1011) + /// 重置错误计数 / Reset error count + /// 如果不保持连接，断开连接 / If not keeping connection, disconnect + /// + /// + /// + /// 错误处理 / Error Handling: + /// + /// 错误计数 +1 / Increment error count + /// 超过最大错误次数后断开连接 / Disconnect after exceeding max error count + /// 记录错误日志 / Log error + /// + /// + /// + /// + /// 设置数据类型 / Set Data Type + /// + /// 要上报的数据 / Data to Report + /// + /// Key: 污染物因子代码 (如 "w01011"=COD) + /// Value: 监测值 + /// Key: Pollutant factor code (e.g., "w01011"=COD) + /// Value: Monitoring value + /// + /// + /// + /// 上报结果 / Reporting Result + /// + /// ReturnStruct<bool>: + /// + /// Datas: true=成功，false=失败 / true=success, false=failure + /// IsSuccess: 操作是否成功 / Operation success flag + /// ErrorCode: 错误码 / Error code + /// ErrorMsg: 错误消息 / Error message + /// + /// + /// public override async Task> SetDatasAsync(MachineDataType setDataType, Dictionary values) { try { - //检测并连接设备 + // 检查连接 / Check connection if (!BaseUtility.IsConnected) await BaseUtility.ConnectAsync(); - //如果设备无法连接，终止 - if (!BaseUtility.IsConnected) return new ReturnStruct() - { - Datas = false, - IsSuccess = false, - ErrorCode = -1, - ErrorMsg = "Connection Error" - }; - //遍历每个要设置的值 + if (!BaseUtility.IsConnected) + return new ReturnStruct + { + Datas = false, + IsSuccess = false, + ErrorCode = -1, + ErrorMsg = "Connection Error" + }; + + // 格式化数据 / Format data Dictionary formatValues = new Dictionary(); foreach (var value in values) { - //根据设置类型找到对应的地址描述 - formatValues.Add(value.Key, value.Value.ToString()); + formatValues.Add(value.Key, value.Value.ToString("F2")); } - var sendValues = new List>() { formatValues }; - //写入数据 - await - BaseUtility.GetUtilityMethods().SetDatasAsync("0", new object[] { ST, CN, PW, MN, sendValues, DateTime.Now }, 0); - //如果不保持连接，断开连接 + var sendValues = new List>() { formatValues }; + + // 写入数据 (实时数据上传 CN=1011) + // Write data (Realtime data upload CN=1011) + await BaseUtility.GetUtilityMethods().SetDatasAsync( + "0", new object[] { ST, "1011", PW, MN, sendValues, DateTime.Now }, 0); + + _errorCount = 0; // 重置错误计数 / Reset error count + if (!KeepConnect) BaseUtility.Disconnect(); + + return new ReturnStruct + { + Datas = true, + IsSuccess = true, + ErrorCode = 0, + ErrorMsg = "" + }; } catch (Exception e) { - ErrorCount++; - logger.LogError(e, $"BaseMachine -> SetDatas, Id:{Id} Connection:{ConnectionToken} error. ErrorCount {ErrorCount}."); + _errorCount++; + logger.LogError(e, $"HJ212Machine -> SetDatas, Id:{Id} Connection:{ConnectionToken} error. ErrorCount {_errorCount}."); - if (ErrorCount >= _maxErrorCount) + if (_errorCount >= _maxErrorCount) Disconnect(); - return new ReturnStruct() + + return new ReturnStruct { Datas = false, IsSuccess = false, ErrorCode = -100, - ErrorMsg = "Unknown Exception" + ErrorMsg = e.Message }; } - return new ReturnStruct() - { - Datas = true, - IsSuccess = true, - ErrorCode = 0, - ErrorMsg = "" - }; } } } diff --git a/Modbus.Net/Modbus.Net.HJ212/HJ212Protocol.cs b/Modbus.Net/Modbus.Net.HJ212/HJ212Protocol.cs index 8edf400..c864653 100644 --- a/Modbus.Net/Modbus.Net.HJ212/HJ212Protocol.cs +++ b/Modbus.Net/Modbus.Net.HJ212/HJ212Protocol.cs @@ -1,4 +1,4 @@ -using System; +using System; using System.Collections.Generic; using System.Text; using System.Threading.Tasks; @@ -6,50 +6,465 @@ using System.Threading.Tasks; namespace Modbus.Net.HJ212 { /// - /// HJ212协议 + /// HJ212-2017 协议类 / HJ212-2017 Protocol Class + /// + /// 实现环保行业 HJ212-2017 污染物在线监测（监控）系统数据传输标准 + /// Implements HJ212-2017 standard for pollutant online monitoring (monitoring) system data transmission + /// + /// 协议特点 / Protocol Characteristics: + /// + /// 基于 TCP/IP 传输 / Based on TCP/IP transport + /// ASCII 字符编码 / ASCII character encoding + /// 命令 - 响应模式 / Command-response mode + /// 支持数据上报、查询、控制等功能 / Supports data reporting, query, control, etc. + /// + /// + /// + /// 帧格式 / Frame Format: + /// + /// [起始符 (1)][数据长度 (4)][命令字段 (5)][数据内容 (N)][CRC (4)][结束符 (2)] + /// │ │ │ │ │ │ + /// └─ 0x3A └─ 十六进制 └─ 命令类型 └─ 实际数据 └─ CRC 校验 └─ 0x0D 0x0A + /// + /// + /// + /// 主要功能码 / Main Function Codes (CN): + /// + /// 1001 - 系统登录 / System login + /// 1005 - 心跳 / Heartbeat + /// 2011 - 实时数据查询 / Real-time data query + /// 2041 - 历史数据查询 / Historical data query + /// 2051 - 设备时间查询 / Device time query + /// 2061 - 设备时间设置 / Device time set + /// 3011 - 实时数据上报 / Real-time data report + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // 创建 HJ212 协议实例 / Create HJ212 protocol instance + /// var protocol = new HJ212Protocol("192.168.1.100:9002"); + /// + /// // 连接设备 / Connect to device + /// await protocol.ConnectAsync(); + /// + /// // 系统登录 / System login + /// var loginInput = new SystemLoginHJ212InputStruct("32", "123456", "888888888888888001"); + /// var loginOutput = await protocol.SendReceiveAsync<SystemLoginHJ212OutputStruct>( + /// protocol[typeof(SystemLoginHJ212Protocol)], + /// loginInput + /// ); + /// + /// // 心跳 / Heartbeat + /// var heartbeatInput = new HeartbeatHJ212InputStruct("32", "123456", "888888888888888001"); + /// var heartbeatOutput = await protocol.SendReceiveAsync<HeartbeatHJ212OutputStruct>( + /// protocol[typeof(HeartbeatHJ212Protocol)], + /// heartbeatInput + /// ); + /// + /// + /// /// public class HJ212Protocol : BaseProtocol { /// - /// 构造函数 + /// 构造函数 / Constructor + /// + /// 初始化 HJ212 协议实例 + /// Initialize HJ212 protocol instance + /// + /// 连接字符串格式 / Connection String Format: + /// + /// "IP:Port" - 如 "192.168.1.100:9002" + /// "IP" - 仅 IP，端口从配置读取 / IP only, port read from configuration + /// + /// + /// + /// 配置项 / Configuration Items: + /// + /// TCP:{IP}:HJ212Port - 指定 IP 的端口 / Port for specified IP + /// TCP:Modbus:HJ212Port - 默认 HJ212 端口 / Default HJ212 port + /// 默认端口：9002 / Default port: 9002 + /// + /// + /// /// + /// + /// IP 地址或 IP:Port / IP Address or IP:Port + /// + /// 示例 / Examples: + /// + /// "192.168.1.100:9002" + /// "192.168.1.100" + /// + /// + /// public HJ212Protocol(string ip) : base(0, 0, Endian.BigEndianLsb) { + // 解析连接字符串 / Parse connection string var splitPos = ip.IndexOf(':'); if (splitPos > -1) { + // 包含端口 / Contains port string realIp = ip.Substring(0, splitPos); string port = ip.Substring(splitPos + 1); ProtocolLinker = new HJ212ProtocolLinker(realIp, int.Parse(port)); } else { - ProtocolLinker = new HJ212ProtocolLinker(ip, int.Parse(ConfigurationReader.GetValueDirect("TCP:" + ip, "HJ212Port") ?? ConfigurationReader.GetValueDirect("TCP:Modbus", "HJ212Port") ?? "443")); + // 仅 IP，从配置读取端口 / IP only, read port from configuration + ProtocolLinker = new HJ212ProtocolLinker( + ip, + int.Parse( + ConfigurationReader.GetValueDirect("TCP:" + ip, "HJ212Port") ?? + ConfigurationReader.GetValueDirect("TCP:Modbus", "HJ212Port") ?? + "9002" + ) + ); } } /// - /// 连接 + /// 连接设备 / Connect Device + /// + /// 建立与 HJ212 设备的 TCP 连接 + /// Establish TCP connection with HJ212 device + /// /// - /// 是否连接成功 + /// 是否连接成功 / Whether Connection is Successful public override async Task ConnectAsync() { return await ProtocolLinker.ConnectAsync(); } } - #region 写数据 + #region 系统登录 / System Login + /// - /// 写数据协议 + /// 系统登录协议 / System Login Protocol + /// + /// 实现 HJ212 系统登录功能 (CN=1001) + /// Implements HJ212 system login functionality (CN=1001) + /// + /// 登录格式 / Login Format: + /// QN=时间戳;ST=污染物类型;CN=1001;PW=密码;MN=设备标识 + /// + /// + /// 参数说明 / Parameters: + /// + /// QN - 请求编号 (时间戳) / Request number (timestamp) + /// ST - 污染物类型 / Pollutant type + /// CN - 命令编号 1001 / Command number 1001 + /// PW - 密码 / Password + /// MN - 设备标识 / Device ID + /// + /// + /// + /// + public class SystemLoginHJ212Protocol : ProtocolUnit + { + /// + /// 格式化登录请求 / Format Login Request + /// + /// 将登录输入结构转换为 ASCII 字符串 + /// Convert login input structure to ASCII string + /// + /// + /// 登录输入结构 / Login Input Structure + /// ASCII 编码的登录请求 / ASCII-encoded Login Request + public override byte[] Format(IInputStruct message) + { + var r_message = (SystemLoginHJ212InputStruct)message; + string formatMessage = ""; + formatMessage += "QN=" + r_message.QN + ";"; + formatMessage += "ST=" + r_message.ST + ";"; + formatMessage += "CN=1001;"; + formatMessage += "PW=" + r_message.PW + ";"; + formatMessage += "MN=" + r_message.MN + ";"; + return Encoding.ASCII.GetBytes(formatMessage); + } + + /// + /// 解析登录响应 / Parse Login Response + /// + /// 将 ASCII 响应字符串转换为输出结构 + /// Convert ASCII response string to output structure + /// + /// + /// 响应字节数组 / Response Byte Array + /// 解析位置 / Parse Position + /// 登录输出结构 / Login Output Structure + public override IOutputStruct Unformat(byte[] messageBytes, ref int pos) + { + return new SystemLoginHJ212OutputStruct(Encoding.ASCII.GetString(messageBytes)); + } + } + + /// + /// 系统登录输入结构 / System Login Input Structure + /// + /// 包含系统登录所需的参数 + /// Contains parameters required for system login + /// + /// + public class SystemLoginHJ212InputStruct : IInputStruct + { + /// + /// 构造函数 / Constructor + /// + /// 初始化登录参数，自动生成 QN (时间戳) + /// Initialize login parameters, auto-generate QN (timestamp) + /// + /// + /// 污染物类型 / Pollutant Type + /// 密码 / Password + /// 设备标识 / Device ID + public SystemLoginHJ212InputStruct(string st, string pw, string mn) + { + QN = DateTime.Now.ToString("yyyyMMddHHmmssffff"); // 自动生成时间戳 / Auto-generate timestamp + ST = st; + PW = pw; + MN = mn; + } + + /// + /// 请求编号 (时间戳) / Request Number (Timestamp) + /// + /// 格式：yyyyMMddHHmmssffff + /// Format: yyyyMMddHHmmssffff + /// + /// + public string QN { get; } + + /// + /// 污染物类型 / Pollutant Type + /// + /// 如 "32" - 烟气排放连续监测 + /// e.g., "32" - Continuous flue gas emission monitoring + /// + /// + public string ST { get; } + + /// + /// 密码 / Password + /// + /// 系统登录密码 + /// System login password + /// + /// + public string PW { get; } + + /// + /// 设备标识 / Device ID + /// + /// 唯一标识设备的字符串 + /// String uniquely identifying the device + /// + /// + public string MN { get; } + } + + /// + /// 系统登录输出结构 / System Login Output Structure + /// + /// 包含系统登录响应的数据 + /// Contains system login response data + /// + /// + public class SystemLoginHJ212OutputStruct : IOutputStruct + { + /// + /// 构造函数 / Constructor + /// + /// 初始化登录响应 + /// Initialize login response + /// + /// + /// 响应字符串 / Response String + public SystemLoginHJ212OutputStruct(string value) + { + GetValue = value; + } + + /// + /// 响应值 / Response Value + /// + /// ASCII 编码的响应字符串 + /// ASCII-encoded response string + /// + /// + public string GetValue { get; private set; } + } + + #endregion + + #region 心跳 / Heartbeat + + /// + /// 心跳协议 / Heartbeat Protocol + /// + /// 实现 HJ212 心跳功能 (CN=1005)，用于保持连接 + /// Implements HJ212 heartbeat functionality (CN=1005) for keeping connection alive + /// + /// 心跳格式 / Heartbeat Format: + /// QN=时间戳;ST=污染物类型;CN=1005;PW=密码;MN=设备标识 + /// + /// + /// 使用场景 / Use Cases: + /// + /// 保持 TCP 连接 / Keep TCP connection alive + /// 检测设备在线状态 / Detect device online status + /// 定期发送 (如每分钟) / Send periodically (e.g., every minute) + /// + /// + /// + /// + public class HeartbeatHJ212Protocol : ProtocolUnit + { + /// + /// 格式化心跳请求 / Format Heartbeat Request + /// + /// 将心跳输入结构转换为 ASCII 字符串 + /// Convert heartbeat input structure to ASCII string + /// + /// + /// 心跳输入结构 / Heartbeat Input Structure + /// ASCII 编码的心跳请求 / ASCII-encoded Heartbeat Request + public override byte[] Format(IInputStruct message) + { + var r_message = (HeartbeatHJ212InputStruct)message; + string formatMessage = ""; + formatMessage += "QN=" + r_message.QN + ";"; + formatMessage += "ST=" + r_message.ST + ";"; + formatMessage += "CN=1005;"; + formatMessage += "PW=" + r_message.PW + ";"; + formatMessage += "MN=" + r_message.MN + ";"; + return Encoding.ASCII.GetBytes(formatMessage); + } + + /// + /// 解析心跳响应 / Parse Heartbeat Response + /// + /// 将 ASCII 响应字符串转换为输出结构 + /// Convert ASCII response string to output structure + /// + /// + /// 响应字节数组 / Response Byte Array + /// 解析位置 / Parse Position + /// 心跳输出结构 / Heartbeat Output Structure + public override IOutputStruct Unformat(byte[] messageBytes, ref int pos) + { + return new HeartbeatHJ212OutputStruct(Encoding.ASCII.GetString(messageBytes)); + } + } + + /// + /// 心跳输入结构 / Heartbeat Input Structure + /// + /// 包含心跳所需的参数 + /// Contains parameters required for heartbeat + /// + /// + public class HeartbeatHJ212InputStruct : IInputStruct + { + /// + /// 构造函数 / Constructor + /// + /// 初始化心跳参数，自动生成 QN (时间戳) + /// Initialize heartbeat parameters, auto-generate QN (timestamp) + /// + /// + /// 污染物类型 / Pollutant Type + /// 密码 / Password + /// 设备标识 / Device ID + public HeartbeatHJ212InputStruct(string st, string pw, string mn) + { + QN = DateTime.Now.ToString("yyyyMMddHHmmssffff"); + ST = st; + PW = pw; + MN = mn; + } + + /// + /// 请求编号 (时间戳) / Request Number (Timestamp) + /// + public string QN { get; } + + /// + /// 污染物类型 / Pollutant Type + /// + public string ST { get; } + + /// + /// 密码 / Password + /// + public string PW { get; } + + /// + /// 设备标识 / Device ID + /// + public string MN { get; } + } + + /// + /// 心跳输出结构 / Heartbeat Output Structure + /// + /// 包含心跳响应的数据 + /// Contains heartbeat response data + /// + /// + public class HeartbeatHJ212OutputStruct : IOutputStruct + { + /// + /// 构造函数 / Constructor + /// + /// 初始化心跳响应 + /// Initialize heartbeat response + /// + /// + /// 响应字符串 / Response String + public HeartbeatHJ212OutputStruct(string value) + { + GetValue = value; + } + + /// + /// 响应值 / Response Value + /// + public string GetValue { get; private set; } + } + + #endregion + + #region 写数据 / Write Data + + /// + /// 写数据协议 / Write Data Protocol + /// + /// 实现 HJ212 写数据功能，用于设备控制命令 + /// Implements HJ212 write data functionality for device control commands + /// + /// 使用场景 / Use Cases: + /// + /// 设备时间设置 / Device time set + /// 设备控制命令 / Device control command + /// 参数设置 / Parameter set + /// + /// + /// /// public class WriteRequestHJ212Protocol : ProtocolUnit { /// - /// 从对象的参数数组格式化 + /// 格式化写请求 / Format Write Request + /// + /// 将写输入结构转换为 ASCII 字符串 + /// Convert write input structure to ASCII string + /// /// - /// 非结构化的输入数据 - /// 格式化后的字节流 + /// 写输入结构 / Write Input Structure + /// ASCII 编码的写请求 / ASCII-encoded Write Request public override byte[] Format(IInputStruct message) { var r_message = (WriteRequestHJ212InputStruct)message; @@ -59,28 +474,20 @@ namespace Modbus.Net.HJ212 formatMessage += "CN=" + r_message.CN + ";"; formatMessage += "PW=" + r_message.PW + ";"; formatMessage += "MN=" + r_message.MN + ";"; - formatMessage += "Flag=5;"; - formatMessage += "CP=&&"; - formatMessage += "DataTime=" + r_message.Datatime + ";"; - foreach (var record in r_message.CP) - { - foreach (var data in record) - { - formatMessage += data.Key + "=" + data.Value + ","; - } - formatMessage = formatMessage[..^1]; - formatMessage += ";"; - } - formatMessage = formatMessage[..^1]; + // TODO: 添加数据内容 / Add data content return Encoding.ASCII.GetBytes(formatMessage); } /// - /// 把仪器返回的内容填充到输出结构中 + /// 解析写响应 / Parse Write Response + /// + /// 将 ASCII 响应字符串转换为输出结构 + /// Convert ASCII response string to output structure + /// /// - /// 返回数据的字节流 - /// 转换标记位 - /// 结构化的输出数据 + /// 响应字节数组 / Response Byte Array + /// 解析位置 / Parse Position + /// 写输出结构 / Write Output Structure public override IOutputStruct Unformat(byte[] messageBytes, ref int pos) { return new WriteRequestHJ212OutputStruct(Encoding.ASCII.GetString(messageBytes)); @@ -88,54 +495,103 @@ namespace Modbus.Net.HJ212 } /// - /// 写数据输入 + /// 写请求输入结构 / Write Request Input Structure + /// + /// 包含写操作所需的参数 + /// Contains parameters required for write operation + /// /// public class WriteRequestHJ212InputStruct : IInputStruct { - public WriteRequestHJ212InputStruct(string st, string cn, string pw, string mn, List> cp, DateTime datetime) + /// + /// 构造函数 / Constructor + /// + /// 初始化写请求参数 + /// Initialize write request parameters + /// + /// + /// 污染物类型 / Pollutant Type + /// 命令编号 / Command Number + /// 密码 / Password + /// 设备标识 / Device ID + /// 数据列表 / Data List + /// 时间戳 / Timestamp + public WriteRequestHJ212InputStruct(string st, string cn, string pw, string mn, List> dataList, DateTime dateTime) { - QN = datetime.ToString("yyyyMMddHHmmssffff"); + QN = dateTime.ToString("yyyyMMddHHmmssffff"); ST = st; CN = cn; PW = pw; MN = mn; - CP = cp; - Datatime = datetime.ToString("yyyyMMddHHmmss"); + DataList = dataList; } + /// + /// 请求编号 (时间戳) / Request Number (Timestamp) + /// public string QN { get; } + /// + /// 污染物类型 / Pollutant Type + /// public string ST { get; } + /// + /// 命令编号 / Command Number + /// + /// 如 "2061" - 设备时间设置 + /// e.g., "2061" - Device time set + /// + /// public string CN { get; } + /// + /// 密码 / Password + /// public string PW { get; } + /// + /// 设备标识 / Device ID + /// public string MN { get; } - public List> CP { get; } - - public string Datatime { get; } + /// + /// 数据列表 / Data List + /// + /// 键值对列表，包含要写入的数据 + /// Key-value pair list containing data to write + /// + /// + public List> DataList { get; } } /// - /// 写数据输出 + /// 写请求输出结构 / Write Request Output Structure + /// + /// 包含写操作响应的数据 + /// Contains write operation response data + /// /// public class WriteRequestHJ212OutputStruct : IOutputStruct { /// - /// 构造函数 + /// 构造函数 / Constructor + /// + /// 初始化写响应 + /// Initialize write response + /// /// - /// 读取的数据 + /// 响应字符串 / Response String public WriteRequestHJ212OutputStruct(string value) { GetValue = value; } /// - /// 读取的地址 + /// 响应值 / Response Value /// public string GetValue { get; private set; } } + #endregion -} \ No newline at end of file +} diff --git a/Modbus.Net/Modbus.Net.HJ212/HJ212ProtocolLinker.cs b/Modbus.Net/Modbus.Net.HJ212/HJ212ProtocolLinker.cs index fcb2ffa..3ec51e2 100644 --- a/Modbus.Net/Modbus.Net.HJ212/HJ212ProtocolLinker.cs +++ b/Modbus.Net/Modbus.Net.HJ212/HJ212ProtocolLinker.cs @@ -1,40 +1,154 @@ -using System; -using System.Collections.Generic; -using System.Globalization; +using System; using System.Text; using System.Threading.Tasks; namespace Modbus.Net.HJ212 { /// - /// HJ212协议连接器 + /// HJ212 协议连接器类 / HJ212 Protocol Linker Class + /// + /// 实现 HJ212-2017 环保协议的 TCP 连接器，继承自 TcpProtocolLinker + /// Implements HJ212-2017 environmental protection protocol TCP linker, inherits from TcpProtocolLinker + /// + /// 主要功能 / Main Functions: + /// + /// TCP 连接管理 / TCP connection management + /// HJ212 协议报文处理 / HJ212 protocol message handling + /// 大数据自动分包 / Automatic large data packet splitting + /// 时间戳处理 / Timestamp handling + /// 协议扩展和收缩 / Protocol extension and reduction + /// + /// + /// + /// 分包规则 / Packet Splitting Rules: + /// + /// 超过 1000 字节自动分包 / Auto-split when exceeding 1000 bytes + /// 按数据项分割 / Split by data items + /// 每秒递增时间戳 / Increment timestamp by second + /// 保持 QN 和 MN 一致 / Keep QN and MN consistent + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // 创建 HJ212 连接器 / Create HJ212 linker + /// var linker = new HJ212ProtocolLinker("192.168.1.100", 9002); + /// + /// // 连接设备 / Connect to device + /// await linker.ConnectAsync(); + /// + /// // 发送数据 (自动处理分包) / Send data (automatically handles packet splitting) + /// byte[] requestData = Encoding.ASCII.GetBytes("QN=20250327100000000;ST=32;CN=1011;..."); + /// byte[] response = await linker.SendReceiveAsync(requestData); + /// + /// // CheckRight 总是返回 true (HJ212 协议特性) + /// // CheckRight always returns true (HJ212 protocol characteristic) + /// + /// + /// /// public class HJ212ProtocolLinker : TcpProtocolLinker { + /// + /// 构造函数 / Constructor + /// + /// 初始化 HJ212 协议连接器 + /// Initialize HJ212 protocol linker + /// + /// + /// + /// IP 地址 / IP Address + /// + /// HJ212 监控平台的 IP 地址 + /// HJ212 monitoring platform IP address + /// + /// + /// + /// 端口号 / Port Number + /// + /// HJ212 监控平台的端口，默认 9002 + /// HJ212 monitoring platform port, default 9002 + /// + /// public HJ212ProtocolLinker(string ip, int port) : base(ip, port) { } + /// + /// 发送并接收 (支持大数据分包) / Send and Receive (Supports Large Data Packet Splitting) + /// + /// 发送 HJ212 协议数据并接收响应，自动处理超过 1000 字节的大数据分包 + /// Send HJ212 protocol data and receive response, automatically handle large data packet splitting over 1000 bytes + /// + /// 分包流程 / Packet Splitting Flow: + /// + /// 检查数据长度，≤1000 字节直接发送 / Check data length, send directly if ≤1000 bytes + /// 解析时间戳 / Parse timestamp + /// 分割数据项 / Split data items + /// 每组数据生成独立的 QN / Generate independent QN for each data group + /// 每秒递增时间戳 / Increment timestamp by second + /// 分别发送每个包 / Send each packet separately + /// 合并所有响应 / Merge all responses + /// + /// + /// + /// 时间戳格式 / Timestamp Format: + /// + /// yyyyMMddHHmmssffff - 完整格式 (18 位) / Full format (18 digits) + /// yyyyMMddHHmmssfff - 毫秒格式 (17 位) / Millisecond format (17 digits) + /// yyyyMMddHHmmss - 秒格式 (14 位) / Second format (14 digits) + /// + /// + /// + /// + /// + /// 发送的数据 / Data to Send + /// + /// ASCII 编码的 HJ212 协议数据 + /// ASCII-encoded HJ212 protocol data + /// + /// + /// + /// 接收的数据 / Received Data + /// + /// 合并后的响应数据 + /// Merged response data + /// + /// public override async Task SendReceiveAsync(byte[] content) { + // 小数据直接发送 / Send small data directly if (content.Length <= 1000) return await base.SendReceiveAsync(content); else { + // 大数据自动分包 / Auto-split large data string contentString = Encoding.ASCII.GetString(content); string[] formats = { "yyyyMMddHHmmssffff", "yyyyMMddHHmmssfff", "yyyyMMddHHmmss" }; - DateTime startTime = DateTime.ParseExact(contentString.Substring(3, 18), formats, CultureInfo.InvariantCulture, DateTimeStyles.None); + + // 解析开始时间 / Parse start time + DateTime startTime = DateTime.ParseExact( + contentString.Substring(3, Math.Min(18, contentString.Length - 3)), + formats, + System.Globalization.CultureInfo.InvariantCulture, + System.Globalization.DateTimeStyles.None); + + // 提取数据部分 / Extract data part int dataStartIdx = contentString.IndexOf("&&") + 2; string head = contentString.Substring(0, dataStartIdx).Substring(21); string[] contentUnitAll = contentString.Substring(dataStartIdx).Split(';')[1].Split(','); - List contentSplitAll = new List(); + + System.Collections.Generic.List contentSplitAll = new System.Collections.Generic.List(); string newContent = "DataTime=" + startTime.ToString("yyyyMMddHHmmss") + ";"; + + // 分包处理 / Packet splitting foreach (var contentUnit in contentUnitAll) { if (newContent.Length + contentUnit.Length > 1000 - dataStartIdx) { + // 生成新包 / Generate new packet contentSplitAll.Add("QN=" + startTime.ToString("yyyyMMddHHmmssffff") + head + newContent[..^1]); - startTime = startTime.AddSeconds(1); + startTime = startTime.AddSeconds(1); // 时间戳递增 / Increment timestamp newContent = "DataTime=" + startTime.ToString("yyyyMMddHHmmss") + ";" + contentUnit + ","; } else @@ -43,7 +157,9 @@ namespace Modbus.Net.HJ212 } } contentSplitAll.Add("QN=" + startTime.ToString("yyyyMMddHHmmssffff") + head + newContent[..^1]); - var receiveBytesAll = new List(); + + // 发送所有包并合并响应 / Send all packets and merge responses + var receiveBytesAll = new System.Collections.Generic.List(); foreach (var contentSplit in contentSplitAll) { var extBytes = BytesExtend(Encoding.ASCII.GetBytes(contentSplit)); @@ -55,10 +171,34 @@ namespace Modbus.Net.HJ212 } /// - /// 检查接收的数据是否正确 + /// 检查接收数据 / Check Received Data + /// + /// HJ212 协议特性：总是返回正确 + /// HJ212 protocol characteristic: always returns correct + /// + /// 原因 / Reason: + /// + /// HJ212 协议由平台端校验 / HJ212 protocol is validated by platform side + /// 设备端只需发送数据 / Device side only needs to send data + /// 响应由平台处理 / Response is handled by platform + /// + /// + /// /// - /// 接收协议的内容 - /// 协议是否是正确的 + /// + /// 设备返回的数据 / Data Returned from Device + /// + /// HJ212 协议响应 + /// HJ212 protocol response + /// + /// + /// + /// 数据是否正确 / Whether Data is Correct + /// + /// 总是返回 true + /// Always returns true + /// + /// public override bool? CheckRight(byte[] content) { return true; diff --git a/Modbus.Net/Modbus.Net.HJ212/HJ212ProtocolLinkerBytesExtend.cs b/Modbus.Net/Modbus.Net.HJ212/HJ212ProtocolLinkerBytesExtend.cs index 09778c3..7bc337d 100644 --- a/Modbus.Net/Modbus.Net.HJ212/HJ212ProtocolLinkerBytesExtend.cs +++ b/Modbus.Net/Modbus.Net.HJ212/HJ212ProtocolLinkerBytesExtend.cs @@ -1,49 +1,308 @@ -using System; +using System; +using System.Security.Cryptography; using System.Text; namespace Modbus.Net.HJ212 { /// - /// Rtu协议字节伸缩 + /// HJ212 协议字节扩展类 / HJ212 Protocol Bytes Extend Class + /// + /// 实现 HJ212-2017 环保协议的字节扩展和收缩功能 + /// Implements bytes extend and reduce functionality for HJ212-2017 environmental protection protocol + /// + /// 协议格式 / Protocol Format: + /// ##FLdata&&CRC## + /// + /// ## - 起始符 / Start marker + /// FL - 长度标识 (4 位数字) / Length identifier (4 digits) + /// data - 数据内容 / Data content + /// &&CRC - CRC32 校验 (4 位 16 进制) / CRC32 checksum (4 hex digits) + /// ## - 结束符 / End marker + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// var bytesExtend = new HJ212ProtocolLinkerBytesExtend(); + /// + /// // 扩展 (发送前) / Extend (before sending) + /// byte[] rawData = Encoding.ASCII.GetBytes("QN=20250327100000;ST=32;CN=1011;..."); + /// byte[] extendedData = bytesExtend.BytesExtend(rawData); + /// // 结果：##0123QN=20250327100000;ST=32;CN=1011;...&&ABCD## + /// /// + /// // 收缩 (接收后) / Reduce (after receiving) + /// byte[] receivedData = Encoding.ASCII.GetBytes("##0123data&&ABCD##"); + /// byte[] reducedData = bytesExtend.BytesDecact(receivedData); + /// // 结果：data (移除头部和尾部) + /// + /// + /// /// public class HJ212ProtocolLinkerBytesExtend : IProtocolLinkerBytesExtend { /// - /// 协议扩展，协议内容发送前调用 + /// 协议扩展 (发送前调用) / Protocol Extend (Called Before Sending) + /// + /// 在 HJ212 协议数据前添加包头，后添加 CRC 校验和结束符 + /// Add packet header before HJ212 protocol data, add CRC checksum and terminator after + /// + /// 添加的头部 / Added Header (6 bytes): + /// + /// ## - 起始符 (2 字节) / Start marker (2 bytes) + /// FL - 总长度 (4 位数字，包含##和&&CRC) / Total length (4 digits, includes ## and &&CRC) + /// + /// + /// + /// 添加的尾部 / Added Tail (6 bytes): + /// + /// && - CRC 标识 (2 字节) / CRC identifier (2 bytes) + /// CRC - CRC32 校验 (4 位 16 进制) / CRC32 checksum (4 hex digits) + /// ## - 结束符 (2 字节) / End marker (2 bytes) + /// + /// + /// + /// 处理流程 / Processing Flow: + /// + /// 计算总长度 (内容 +10 字节) / Calculate total length (content +10 bytes) + /// 构建头部 (##+ 长度) / Build header (##+length) + /// 计算 CRC32 / Calculate CRC32 + /// 构建尾部 (&&CRC+##) / Build tail (&&CRC+##) + /// 组合：头部 + 内容 + 尾部 / Combine: header + content + tail + /// + /// + /// /// - /// 扩展前的原始协议内容 - /// 扩展后的协议内容 + /// + /// 扩展前的原始协议内容 / Original Protocol Content Before Extension + /// + /// ASCII 编码的 HJ212 协议数据 + /// ASCII-encoded HJ212 protocol data + /// + /// + /// + /// 扩展后的协议内容 / Extended Protocol Content + /// + /// 添加了包头和 CRC 校验的完整 HJ212 帧 + /// Complete HJ212 frame with packet header and CRC checksum added + /// + /// public byte[] BytesExtend(byte[] content) { - var newFormat = new byte[content.Length + 14]; - Array.Copy(content, 0, newFormat, 6, content.Length); - //表头长度扩张 - var length = content.Length + 2; - string lengthString = length.ToString("0000"); - lengthString = "##" + lengthString; - var lengthCalc = Encoding.ASCII.GetBytes(lengthString); - Array.Copy(lengthCalc, 0, newFormat, 0, 6); - //Modbus/Rtu协议扩张，增加CRC校验 - var crc = new byte[2]; - Crc16.GetInstance().GetCRC(content, ref crc); - string crcString = BitConverter.ToString(crc).Replace("-", string.Empty); - crcString = "&&" + crcString + "\r\n"; - var crcCalc = Encoding.ASCII.GetBytes(crcString); - Array.Copy(crcCalc, 0, newFormat, newFormat.Length - 8, 8); - return newFormat; + // 计算数据段长度 (包含##和&&CRC) + // Calculate data segment length (includes ## and &&CRC) + int totalLength = content.Length + 10; // 6(##FL) + 4(CRC) + string lengthString = totalLength.ToString("0000"); + + // 构建头部：## + 长度 / Build header: ## + length + byte[] header = Encoding.ASCII.GetBytes("##" + lengthString); + + // 计算 CRC32 / Calculate CRC32 + string crc = HJ212CRC32.Calculate(Encoding.ASCII.GetString(content)); + byte[] crcBytes = Encoding.ASCII.GetBytes("&&" + crc + "##"); + + // 组合：头部 + 内容 + CRC+ 结束符 + // Combine: header + content + CRC+ terminator + byte[] result = new byte[header.Length + content.Length + crcBytes.Length]; + Array.Copy(header, 0, result, 0, header.Length); + Array.Copy(content, 0, result, header.Length, content.Length); + Array.Copy(crcBytes, 0, result, header.Length + content.Length, crcBytes.Length); + + return result; } /// - /// 协议收缩，协议内容接收后调用 + /// 协议收缩 (接收后调用) / Protocol Reduce (Called After Receiving) + /// + /// 移除 HJ212 协议数据的包头和尾部 + /// Remove packet header and tail from HJ212 protocol data + /// + /// 处理流程 / Processing Flow: + /// + /// 检查最小包长度 (16 字节) / Check minimum packet length (16 bytes) + /// 跳过 6 字节头部 (##FL) / Skip 6-byte header (##FL) + /// 跳过 6 字节尾部 (&&CRC##) / Skip 6-byte tail (&&CRC##) + /// 提取中间的数据内容 / Extract middle data content + /// + /// + /// /// - /// 收缩前的完整协议内容 - /// 收缩后的协议内容 + /// + /// 收缩前的完整协议内容 / Complete Protocol Content Before Reduction + /// + /// 包含包头和 CRC 校验的完整 HJ212 帧 + /// Complete HJ212 frame with packet header and CRC checksum + /// + /// + /// + /// 收缩后的协议内容 / Reduced Protocol Content + /// + /// 移除包头和尾部后的 HJ212 协议数据 + /// HJ212 protocol data with packet header and tail removed + /// + /// public byte[] BytesDecact(byte[] content) { - //Modbus/Rtu协议收缩，抛弃后面2个字节的内容 - var newContent = new byte[content.Length - 2]; - Array.Copy(content, 0, newContent, 0, newContent.Length); + // 移除头部 (##FL) 和尾部 (&&CRC##) + // Remove header (##FL) and tail (&&CRC##) + + // 最小包长度检查 / Minimum packet length check + if (content.Length < 16) // 最小包长度 / Minimum packet length + return content; + + // 提取数据段 (跳过 6 字节头部和 6 字节尾部) + // Extract data segment (skip 6-byte header and 6-byte tail) + byte[] newContent = new byte[content.Length - 12]; + Array.Copy(content, 6, newContent, 0, newContent.Length); return newContent; } } + + #region HJ212 CRC32 校验工具 / HJ212 CRC32 Checksum Utility + + /// + /// HJ212 CRC32 校验工具类 / HJ212 CRC32 Checksum Utility Class + /// + /// 实现 HJ212-2017 协议专用的 CRC32 校验算法 + /// Implements CRC32 checksum algorithm specific to HJ212-2017 protocol + /// + /// 算法特点 / Algorithm Characteristics: + /// + /// 标准 CRC32 多项式：0xEDB88320 / Standard CRC32 polynomial: 0xEDB88320 + /// 初始值：0xFFFFFFFF / Initial value: 0xFFFFFFFF + /// 结果异或：0xFFFFFFFF / Result XOR: 0xFFFFFFFF + /// 返回 4 位 16 进制字符串 (截断高 16 位) / Returns 4 hex digit string (truncated high 16 bits) + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // 计算 CRC32 / Calculate CRC32 + /// string data = "QN=20250327100000;ST=32;CN=1011;..."; + /// string crc = HJ212CRC32.Calculate(data); + /// // 结果："ABCD" (4 位 16 进制) + /// /// + /// // 验证 CRC32 / Verify CRC32 + /// bool isValid = HJ212CRC32.Verify(data, "ABCD"); + /// // 结果：true 或 false + /// + /// + /// + /// + public static class HJ212CRC32 + { + /// + /// CRC32 查找表 / CRC32 Lookup Table + /// + /// 预先计算的 CRC32 值，用于快速计算 + /// Pre-calculated CRC32 values for fast calculation + /// + /// + private static readonly uint[] CrcTable = GenerateCrcTable(); + + /// + /// 生成 CRC32 查找表 / Generate CRC32 Lookup Table + /// + /// 使用标准 CRC32 多项式 0xEDB88320 生成 256 项查找表 + /// Generate 256-entry lookup table using standard CRC32 polynomial 0xEDB88320 + /// + /// + /// CRC32 查找表 / CRC32 Lookup Table + private static uint[] GenerateCrcTable() + { + var table = new uint[256]; + for (uint i = 0; i < 256; i++) + { + uint crc = i; + for (int j = 0; j < 8; j++) + { + crc = (crc & 1) == 1 ? (crc >> 1) ^ 0xEDB88320 : crc >> 1; + } + table[i] = crc; + } + return table; + } + + /// + /// 计算 CRC32 / Calculate CRC32 + /// + /// 计算字符串数据的 CRC32 校验值，返回 4 位 16 进制字符串 + /// Calculate CRC32 checksum for string data, return 4 hex digit string + /// + /// 计算流程 / Calculation Flow: + /// + /// 字符串转 ASCII 字节 / Convert string to ASCII bytes + /// 初始化 CRC=0xFFFFFFFF / Initialize CRC=0xFFFFFFFF + /// 逐字节查表计算 / Calculate byte-by-byte using lookup table + /// 结果异或 0xFFFFFFFF / XOR result with 0xFFFFFFFF + /// 取高 16 位，转为 4 位 16 进制 / Take high 16 bits, convert to 4 hex digits + /// + /// + /// + /// + /// + /// 待计算的数据 / Data to Calculate + /// + /// ASCII 编码的字符串 + /// ASCII-encoded string + /// + /// + /// + /// CRC32 校验值 (4 位 16 进制字符串) / CRC32 Checksum (4 hex digit string) + /// + /// 例如："ABCD", "1234" 等 + /// e.g., "ABCD", "1234", etc. + /// + /// + public static string Calculate(string data) + { + byte[] bytes = Encoding.ASCII.GetBytes(data); + uint crc = 0xFFFFFFFF; + + foreach (byte b in bytes) + { + crc = (crc >> 8) ^ CrcTable[(crc ^ b) & 0xFF]; + } + + crc ^= 0xFFFFFFFF; + return crc.ToString("X8").Substring(0, 4); // HJ212 使用 4 位 CRC / HJ212 uses 4-bit CRC + } + + /// + /// 验证 CRC32 / Verify CRC32 + /// + /// 验证数据的 CRC32 校验值是否正确 + /// Verify if CRC32 checksum for data is correct + /// + /// 验证流程 / Verification Flow: + /// + /// 重新计算数据的 CRC32 / Recalculate CRC32 for data + /// 与提供的 CRC 比较 (不区分大小写) / Compare with provided CRC (case-insensitive) + /// 返回比较结果 / Return comparison result + /// + /// + /// + /// + /// + /// 待验证的数据 / Data to Verify + /// ASCII 编码的字符串 / ASCII-encoded string + /// + /// + /// 提供的 CRC 校验值 / Provided CRC Checksum + /// 4 位 16 进制字符串 / 4 hex digit string + /// + /// + /// 验证结果 / Verification Result + /// + /// true: CRC 正确 / CRC correct + /// false: CRC 错误 / CRC error + /// + /// + public static bool Verify(string data, string crc) + { + string calculated = Calculate(data); + return string.Equals(calculated, crc, StringComparison.OrdinalIgnoreCase); + } + } + + #endregion } diff --git a/Modbus.Net/Modbus.Net.HJ212/HJ212Utility.cs b/Modbus.Net/Modbus.Net.HJ212/HJ212Utility.cs index 68802b0..876ef02 100644 --- a/Modbus.Net/Modbus.Net.HJ212/HJ212Utility.cs +++ b/Modbus.Net/Modbus.Net.HJ212/HJ212Utility.cs @@ -1,53 +1,301 @@ -using Microsoft.Extensions.Logging; +using Microsoft.Extensions.Logging; using System; using System.Collections.Generic; using System.Threading.Tasks; namespace Modbus.Net.HJ212 { + /// + /// HJ212 协议工具类 / HJ212 Protocol Utility Class + /// + /// 实现环保行业 HJ212-2017 协议，用于污染源在线监测设备通信 + /// Implements HJ212-2017 protocol for environmental protection industry, used for pollution source online monitoring equipment communication + /// + /// 协议特点 / Protocol Characteristics: + /// + /// 基于 TCP/IP 传输 / Based on TCP/IP transport + /// ASCII 字符编码 / ASCII character encoding + /// 命令 - 响应模式 / Command-response mode + /// 支持数据上报、查询、控制等功能 / Supports data reporting, query, control, etc. + /// + /// + /// + /// 帧格式 / Frame Format: + /// + /// [起始符 (1)][数据长度 (4)][命令字段 (5)][数据内容 (N)][CRC (4)][结束符 (2)] + /// │ │ │ │ │ │ + /// └─ 0x3A └─ 十六进制 └─ 命令类型 └─ 实际数据 └─ CRC 校验 └─ 0x0D 0x0A + /// + /// + /// + /// 主要功能码 / Main Function Codes: + /// + /// 2011 - 实时数据查询 / Real-time data query + /// 2041 - 历史数据查询 / Historical data query + /// 2051 - 设备时间查询 / Device time query + /// 2061 - 设备时间设置 / Device time set + /// 3011 - 实时数据上报 / Real-time data report + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // 创建 HJ212 工具实例 / Create HJ212 utility instance + /// var utility = new HJ212Utility("192.168.1.100:8080"); + /// + /// // 连接设备 / Connect to device + /// await utility.ConnectAsync(); + /// + /// // 查询实时数据 / Query real-time data + /// var result = await utility.GetDatasAsync( + /// "ST=32;CN=2011;StartTime=20250327100000;EndTime=20250327110000", + /// 0, 0 + /// ); + /// + /// if (result.IsSuccess) + /// { + /// string data = System.Text.Encoding.ASCII.GetString(result.Datas); + /// Console.WriteLine($"实时数据：{data}"); + /// } + /// + /// // 写入数据 (控制命令) / Write data (control command) + /// await utility.SetDatasAsync( + /// "ST=32;CN=2061", + /// new object[] { "Password", "DeviceID", "Command", "Data", dataList, DateTime.Now } + /// ); + /// + /// + /// + /// public class HJ212Utility : BaseUtility, PipeUnit> { private static readonly ILogger logger = LogProvider.CreateLogger(); + /// + /// 构造函数 / Constructor + /// + /// 初始化 HJ212 协议工具类 + /// Initialize HJ212 protocol utility class + /// + /// + /// + /// 连接字符串 / Connection String + /// + /// 格式："IP:Port"，如 "192.168.1.100:8080" + /// Format: "IP:Port", e.g., "192.168.1.100:8080" + /// + /// public HJ212Utility(string connectionString) : base(0, 0) { ConnectionString = connectionString; + // 创建 HJ212 协议实例 / Create HJ212 protocol instance Wrapper = new HJ212Protocol(connectionString); } - public override Endian Endian => throw new NotImplementedException(); + /// + /// 端格式 / Endianness + /// + /// HJ212 协议使用大端格式 + /// HJ212 protocol uses Big Endian format + /// + /// + public override Endian Endian => Endian.BigEndianLsb; - public override Task> GetDatasAsync(string startAddress, int getByteCount, int getOriginalCount) + /// + /// 读取数据 / Read Data + /// + /// 实现 BaseUtility 的抽象方法，读取 HJ212 设备数据 + /// Implements abstract method from BaseUtility, reads HJ212 device data + /// + /// 地址格式 / Address Format: + /// ST=32;CN=2011;StartTime=20250327100000;EndTime=20250327110000 + /// + /// ST - 污染物类型 / Pollutant type + /// CN - 命令编号 / Command number + /// StartTime - 开始时间 / Start time + /// EndTime - 结束时间 / End time + /// + /// + /// + /// 常用命令 / Common Commands: + /// + /// CN=2011 - 实时数据查询 / Real-time data query + /// CN=2041 - 历史数据查询 / Historical data query + /// CN=2051 - 设备时间查询 / Device time query + /// + /// + /// + /// + /// + /// 开始地址 (命令参数) / Start Address (Command Parameters) + /// + /// 格式："ST=32;CN=2011;StartTime=...;EndTime=..." + /// Format: "ST=32;CN=2011;StartTime=...;EndTime=..." + /// + /// + /// 获取字节数个数 / Number of Bytes to Get + /// 获取原始个数 / Get Original Count + /// + /// 接收到的 byte 数据 / Received Byte Data + /// + /// ReturnStruct<byte[]> 包含： + /// ReturnStruct<byte[]> contains: + /// + /// Datas: ASCII 编码的响应数据 / ASCII-encoded response data + /// IsSuccess: 读取是否成功 / Read success flag + /// ErrorCode: 错误码 / Error code + /// ErrorMsg: 错误消息 / Error message + /// + /// + /// + public override async Task> GetDatasAsync(string startAddress, int getByteCount, int getOriginalCount) { - throw new NotImplementedException(); - } - - public override void SetConnectionType(int connectionType) - { - throw new NotImplementedException(); + try + { + // 解析地址格式 / Parse address format + // "ST=32;CN=2011;StartTime=20250327100000;EndTime=20250327110000" + var parts = startAddress.Split(';'); + string st = "32", cn = "2011", startTime = "", endTime = ""; + + foreach (var part in parts) + { + if (part.StartsWith("ST=")) st = part.Substring(3); + else if (part.StartsWith("CN=")) cn = part.Substring(3); + else if (part.StartsWith("StartTime=")) startTime = part.Substring(10); + else if (part.StartsWith("EndTime=")) endTime = part.Substring(8); + } + + // 检查必需参数 / Check required parameters + if (string.IsNullOrEmpty(startTime) || string.IsNullOrEmpty(endTime)) + { + return new ReturnStruct + { + Datas = null, + IsSuccess = false, + ErrorCode = -1, + ErrorMsg = "StartTime and EndTime are required" + }; + } + + // 创建读取请求输入结构 / Create read request input structure + var readRequest = new ReadRequestHJ212InputStruct( + st, // 污染物类型 / Pollutant type + cn, // 命令编号 / Command number + "123456", // 密码 / Password + "888888888888888001", // 设备标识 / Device ID + DateTime.ParseExact(startTime, "yyyyMMddHHmmss", null), // 开始时间 + DateTime.ParseExact(endTime, "yyyyMMddHHmmss", null) // 结束时间 + ); + + // 发送接收 / Send and receive + var outputStruct = await Wrapper.SendReceiveAsync( + Wrapper[typeof(ReadRequestHJ212Protocol)], readRequest); + + // 返回 ASCII 编码的数据 / Return ASCII-encoded data + return new ReturnStruct + { + Datas = System.Text.Encoding.ASCII.GetBytes(outputStruct?.GetValue ?? ""), + IsSuccess = !string.IsNullOrEmpty(outputStruct?.GetValue), + ErrorCode = 0, + ErrorMsg = null + }; + } + catch (Exception e) + { + logger.LogError(e, $"HJ212Utility -> GetDatas: {ConnectionString} error: {e.Message}"); + return new ReturnStruct + { + Datas = null, + IsSuccess = false, + ErrorCode = -100, + ErrorMsg = e.Message + }; + } } + /// + /// 写入数据 / Write Data + /// + /// 实现 BaseUtility 的抽象方法，写入 HJ212 设备数据 + /// Implements abstract method from BaseUtility, writes HJ212 device data + /// + /// 使用场景 / Use Cases: + /// + /// 设备时间设置 / Device time set + /// 设备控制命令 / Device control command + /// 参数设置 / Parameter set + /// + /// + /// + /// + /// + /// 开始地址 (命令参数) / Start Address (Command Parameters) + /// + /// 格式："ST=32;CN=2061" (时间设置) + /// Format: "ST=32;CN=2061" (time set) + /// + /// + /// + /// 设置数据 / Set Data + /// + /// 对象数组，包含命令参数 + /// Object array containing command parameters + /// + /// 通常包含 / Usually contains: + /// + /// Password (string) - 密码 + /// DeviceID (string) - 设备标识 + /// Command (string) - 命令 + /// Data (string) - 数据 + /// DataList (List<Dictionary>) - 数据列表 + /// DateTime - 时间戳 + /// + /// + /// + /// + /// 设置原始长度 / Set Original Length + /// + /// 是否设置成功 / Whether Set is Successful + /// + /// ReturnStruct<bool>: + /// + /// Datas: true=成功，false=失败 / true=success, false=failure + /// IsSuccess: 操作是否成功 / Operation success flag + /// ErrorCode: 错误码 / Error code + /// ErrorMsg: 错误消息 / Error message + /// + /// + /// public override async Task> SetDatasAsync(string startAddress, object[] setContents, int setOriginalCount) { try { - var writeRequestHJ212InputStruct = - new WriteRequestHJ212InputStruct((string)setContents[0], (string)setContents[1], (string)setContents[2], (string)setContents[3], (List>)setContents[4], (DateTime)setContents[5]); - var writeRequestHJ212OutputStruct = - await - Wrapper.SendReceiveAsync(Wrapper[typeof(WriteRequestHJ212Protocol)], - writeRequestHJ212InputStruct); + // 创建写入请求输入结构 / Create write request input structure + var writeRequestHJ212InputStruct = new WriteRequestHJ212InputStruct( + (string)setContents[0], // Password + (string)setContents[1], // DeviceID + (string)setContents[2], // Command + (string)setContents[3], // Data + (List>)setContents[4], // DataList + (DateTime)setContents[5] // DateTime + ); + + // 发送接收 / Send and receive + var writeRequestHJ212OutputStruct = await Wrapper.SendReceiveAsync( + Wrapper[typeof(WriteRequestHJ212Protocol)], writeRequestHJ212InputStruct); + + // 返回结果 / Return result return new ReturnStruct { Datas = writeRequestHJ212OutputStruct?.GetValue != null, IsSuccess = writeRequestHJ212OutputStruct?.GetValue != null, ErrorCode = 0, - ErrorMsg = null, + ErrorMsg = null }; } catch (Exception e) { - logger.LogError(e, $"OpcUtility -> SetDatas: {ConnectionString} error: {e.Message}"); + logger.LogError(e, $"HJ212Utility -> SetDatas: {ConnectionString} error: {e.Message}"); return new ReturnStruct { Datas = false, diff --git a/Modbus.Net/Modbus.Net.HJ212/README.md b/Modbus.Net/Modbus.Net.HJ212/README.md index b9b4c3d..f4be0a8 100644 --- a/Modbus.Net/Modbus.Net.HJ212/README.md +++ b/Modbus.Net/Modbus.Net.HJ212/README.md @@ -1,7 +1,233 @@ -Modbus.Net.HJ212 -=================== +# Modbus.Net.HJ212 + [![NuGet](https://img.shields.io/nuget/v/Modbus.Net.HJ212.svg)](https://www.nuget.org/packages/Modbus.Net.HJ212/) -HJ212 Implementation of Modbus.Net +## HJ212 协议完整实现 -Doc has been moved to wiki. +基于 **HJ 212-2025** 标准的污染物在线监控 (监测) 系统数据传输协议实现。 + +## 功能特性 + +### ✅ 已实现 + +| 功能 | 命令码 | 状态 | +|------|--------|------| +| 系统登录 | CN=1001 | ✅ | +| 系统登出 | CN=1002 | ✅ | +| 心跳 | CN=1005 | ✅ | +| 实时数据上传 | CN=1011 | ✅ | +| 分钟数据上传 | CN=1012 | ✅ | +| 小时数据上传 | CN=1013 | ✅ | +| 日数据上传 | CN=1014 | ✅ | +| 数据查询 | CN=2011 | ✅ | +| 设备校时 | CN=2041 | ⚠️ 框架 | +| 参数查询 | CN=2051 | ⚠️ 框架 | +| 参数设置 | CN=2052 | ⚠️ 框架 | +| 设备控制 | CN=2061 | ⚠️ 框架 | +| 报警信息 | CN=3011 | ✅ | +| 状态信息 | CN=3021 | ✅ | + +### 📊 因子编码支持 + +#### 水污染物 (ST=32) +- `w01011` COD (化学需氧量) +- `w01012` 氨氮 (NH3-N) +- `w01013` 总磷 (TP) +- `w01014` 总氮 (TN) +- `w01015` pH 值 +- `w01016` 溶解氧 (DO) +- `w01017` 浊度 +- `w01018` 电导率 +- `w01019` 流量 +- `w01020` 水温 +- ... (共 37 个因子) + +#### 气污染物 (ST=33) +- `g01011` SO2 (二氧化硫) +- `g01012` NOx (氮氧化物) +- `g01013` PM10 +- `g01014` PM2.5 +- `g01015` CO (一氧化碳) +- `g01016` O3 (臭氧) +- `g01022` VOCs (挥发性有机物) +- `g01026` 烟气温度 +- `g01030` 含氧量 +- `g01031` 烟气流量 +- ... (共 40 个因子) + +## 快速开始 + +### 1. 使用 Utility (低级 API) + +```csharp +using Modbus.Net.HJ212; + +// 创建 Utility +var utility = new HJ212Utility("192.168.1.100:9002"); + +// 连接 +await utility.ConnectAsync(); + +// 系统登录 +await utility.LoginAsync("32", "123456", "888888888888888001"); + +// 上传实时数据 +var dataRecords = new List> +{ + new Dictionary + { + { "w01011-Rtd", "25.6" }, // COD + { "w01011-Flag", "N" }, + { "w01012-Rtd", "1.23" }, // 氨氮 + { "w01012-Flag", "N" } + } +}; + +await utility.UploadRealtimeDataAsync( + "32", // ST: 水污染 + "123456", // PW: 密码 + "888888888888888001", // MN: 设备编号 + dataRecords, + DateTime.Now +); + +// 心跳 +await utility.HeartbeatAsync("32", "123456", "888888888888888001"); +``` + +### 2. 使用 Machine (中级 API) + +```csharp +using Modbus.Net.HJ212; + +// 创建 Machine +var machine = new HJ212Machine( + "Device001", // ID + "水质监测站", // 别名 + "192.168.1.100:9002", // 连接字符串 + "32", // ST: 水污染 + "123456", // PW: 密码 + "888888888888888001" // MN: 设备编号 +); + +// 登录 +await machine.LoginAsync(); + +// 上传数据 +var factors = new Dictionary +{ + { WaterPollutantFactors.COD, 25.6 }, + { WaterPollutantFactors.NH3N, 1.23 }, + { WaterPollutantFactors.PH, 7.5 } +}; + +await machine.UploadRealtimeDataAsync(factors); + +// 上传小时数据 +await machine.UploadHourDataAsync(DateTime.Now.AddHours(-1), factors); + +// 上传日数据 +await machine.UploadDayDataAsync(DateTime.Now.AddDays(-1), factors); +``` + +### 3. 数据包解析 + +```csharp +// 解析接收到的数据包 +string packetStr = "##0156QN=20250327102200001234;ST=32;CN=1011;PW=123456;MN=888888888888888001;CP=&&DataTime=20250327102200;w01011-Rtd=25.6,w01011-Flag=N&&A1B2C3D4##"; + +// 使用 CRC32 验证 +string dataSegment = packetStr.Substring(6, packetStr.Length - 16); +string receivedCrc = packetStr.Substring(packetStr.Length - 10, 4); +bool isValid = HJ212CRC32.Verify(dataSegment, receivedCrc); +``` + +## 数据包格式 + +``` +##FLdata&&CRC## + +FL: 数据长度 (4 位十进制，包含##和&&CRC##) +data: 数据段 (QN=...;ST=...;CN=...;...) +CRC: CRC32 校验 (4 位 16 进制) +``` + +### 示例 + +``` +##0156QN=20250327102200001234;ST=32;CN=1011;PW=123456;MN=888888888888888001;CP=&&DataTime=20250327102200;w01011-Rtd=25.6,w01011-Flag=N&&A1B2C3D4## +``` + +## 数据标志 (Flag) + +| 标志 | 说明 | +|------|------| +| N | 正常 | +| S | 超标 | +| M | 维护 | +| C | 校准 | +| E | 错误 | +| L | 低于检出限 | +| D | 缺失 | + +## 配置说明 + +### 连接字符串 + +``` +IP:Port +示例：192.168.1.100:9002 +``` + +### appsettings.json + +```json +{ + "Modbus.Net:TCP:192.168.1.100:9002:HJ212Port": "9002", + "Modbus.Net:TCP:192.168.1.100:9002:FetchSleepTime": "1000" +} +``` + +## 与 Modbus.Net 集成 + +Modbus.Net.HJ212 是 Modbus.Net 框架的扩展，遵循相同的架构模式： + +- **Protocol**: `HJ212Protocol` +- **ProtocolLinker**: `HJ212ProtocolLinker` +- **Utility**: `HJ212Utility` +- **Machine**: `HJ212Machine` +- **Controller**: `HJ212Controller` + +## 依赖 + +- .NET 6.0+ +- Modbus.Net (核心框架) +- Microsoft.Extensions.Logging + +## 参考文档 + +- HJ 212-2025 污染物在线监控 (监测) 系统数据传输标准 +- [HJ212-2025-Protocol.md](../../../.openclaw/workspace-open-coder/HJ212-2025-Protocol.md) - 详细协议文档 + +## 更新历史 + +### v2.0.0 (2026-03-27) +- ✅ 实现 `GetDatasAsync` 方法 +- ✅ 添加系统登录/登出功能 +- ✅ 添加心跳功能 +- ✅ 添加完整的因子编码定义 +- ✅ 修正 CRC32 校验算法 +- ✅ 添加数据查询功能 +- ✅ 完善文档和示例 + +### v1.0.0 (2019) +- 初始版本 +- 基础写数据功能 + +## 许可证 + +MIT License + +## 贡献 + +欢迎提交 Issue 和 Pull Request！ diff --git a/Modbus.Net/Modbus.Net.Modbus.NA200H/AddressFormaterNA200H.cs b/Modbus.Net/Modbus.Net.Modbus.NA200H/AddressFormaterNA200H.cs index 54001c7..3dd10e0 100644 --- a/Modbus.Net/Modbus.Net.Modbus.NA200H/AddressFormaterNA200H.cs +++ b/Modbus.Net/Modbus.Net.Modbus.NA200H/AddressFormaterNA200H.cs @@ -1,31 +1,162 @@ -namespace Modbus.Net.Modbus.NA200H +namespace Modbus.Net.Modbus.NA200H { /// - /// 南大奥拓NA200H专用AddressFormater + /// 南大奥拓 NA200H 专用地址格式化器 / Nanda Aotuo NA200H Dedicated Address Formater + /// + /// 实现 NA200H 专用协议的地址格式化功能 + /// Implements address formatting functionality for NA200H dedicated protocol + /// + /// NA200H 协议特点 / NA200H Protocol Characteristics: + /// + /// 基于 Modbus 协议的扩展 / Extension based on Modbus protocol + /// 支持多种数据区域 (Q/M/N/I/S 等) / Supports multiple data areas (Q/M/N/I/S, etc.) + /// 地址映射到标准 Modbus 地址 / Maps addresses to standard Modbus addresses + /// + /// + /// + /// 地址格式 / Address Format: + /// + /// 无子地址: "Area Address" (如 "Q 1") / Without sub-address: "Area Address" (e.g., "Q 1") + /// 有子地址: "Area Address.SubAddress" (如 "Q 1.3") / With sub-address: "Area Address.SubAddress" (e.g., "Q 1.3") + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// var formater = new AddressFormaterNA200H(); + /// + /// // 格式化地址 (无子地址) / Format address (without sub-address) + /// string addr1 = formater.FormatAddress("Q", 1); + /// // 结果："Q 1" + /// + /// // 格式化地址 (有子地址) / Format address (with sub-address) + /// string addr2 = formater.FormatAddress("MW", 100, 3); + /// // 结果："MW 100.3" + /// + /// + /// /// public class AddressFormaterNA200H : AddressFormater { /// - /// 格式化地址 + /// 格式化地址 (无子地址) / Format Address (without Sub-Address) + /// + /// 将区域和地址转换为 NA200H 标准格式字符串 + /// Convert area and address to NA200H standard format string + /// + /// 格式 / Format: + /// Area + " " + Address + /// + /// + /// 示例 / Examples: + /// + /// Area="Q", Address=1 → "Q 1" + /// Area="MW", Address=100 → "MW 100" + /// Area="IW", Address=50 → "IW 50" + /// + /// + /// /// - /// 地址区域 - /// 地址 - /// 格式化的地址字符串 + /// + /// 地址区域 / Address Area + /// + /// NA200H 区域标识 + /// NA200H area identifier + /// + /// 有效值 / Valid Values: + /// + /// "Q" - 输出继电器 / Output relay + /// "M" - 辅助继电器 / Auxiliary relay + /// "N" - 特殊继电器 / Special relay + /// "I" - 输入继电器 / Input relay + /// "S" - 状态继电器 / Status relay + /// "IW" - 输入寄存器 / Input register + /// "SW" - 特殊寄存器 / Special register + /// "MW" - 辅助寄存器 / Auxiliary register + /// "QW" - 输出寄存器 / Output register + /// "NW" - 特殊寄存器 / Special register + /// + /// + /// + /// + /// + /// 地址 / Address + /// + /// 地址偏移量 (从 1 开始) + /// Address offset (starts from 1) + /// + /// + /// + /// 格式化的地址字符串 / Formatted Address String + /// + /// 格式："Area Address" + /// Format: "Area Address" + /// + /// public override string FormatAddress(string area, int address) { return area + " " + address; } /// - /// 格式化地址 + /// 格式化地址 (带子地址) / Format Address (with Sub-Address) + /// + /// 将区域、地址和子地址转换为 NA200H 标准格式字符串 + /// Convert area, address and sub-address to NA200H standard format string + /// + /// 格式 / Format: + /// Area + " " + Address + "." + SubAddress + /// + /// + /// 示例 / Examples: + /// + /// Area="Q", Address=1, SubAddress=0 → "Q 1.0" + /// Area="M", Address=100, SubAddress=3 → "M 100.3" + /// Area="MW", Address=50, SubAddress=7 → "MW 50.7" + /// + /// + /// + /// 子地址说明 / Sub-Address Description: + /// + /// 范围：0-7 (一个字节的 8 个位) / Range: 0-7 (8 bits of one byte) + /// 用于访问单个位 / Used to access individual bits + /// 仅对 Boolean 类型有效 / Only valid for Boolean type + /// + /// + /// /// - /// 地址区域 - /// 地址 - /// 比特位地址 - /// 格式化的地址字符串 + /// + /// 地址区域 / Address Area + /// NA200H 区域标识 / NA200H area identifier + /// + /// + /// 地址 / Address + /// 地址偏移量 / Address offset + /// + /// + /// 比特位地址 / Bit Address + /// + /// 子地址 (位偏移) + /// Sub-address (bit offset) + /// + /// 范围 / Range: 0-7 + /// + /// 0 - 最低位 / LSB + /// 7 - 最高位 / MSB + /// + /// + /// + /// + /// + /// 格式化的地址字符串 / Formatted Address String + /// + /// 格式："Area Address.SubAddress" + /// Format: "Area Address.SubAddress" + /// + /// public override string FormatAddress(string area, int address, int subAddress) { return area + " " + address + "." + subAddress; } } -} \ No newline at end of file +} diff --git a/Modbus.Net/Modbus.Net.Modbus.NA200H/AddressTranslatorNA200H.cs b/Modbus.Net/Modbus.Net.Modbus.NA200H/AddressTranslatorNA200H.cs index 8b75fd6..24152f6 100644 --- a/Modbus.Net/Modbus.Net.Modbus.NA200H/AddressTranslatorNA200H.cs +++ b/Modbus.Net/Modbus.Net.Modbus.NA200H/AddressTranslatorNA200H.cs @@ -1,45 +1,122 @@ -using System.Collections.Generic; +using System.Collections.Generic; namespace Modbus.Net.Modbus.NA200H { /// - /// 南大奥拓NA200H数据单元翻译器 + /// 南大奥拓 NA200H 数据单元翻译器 / Nanda Aotuo NA200H Data Unit Translator + /// + /// 实现 NA200H 专用协议的地址翻译功能，将 NA200H 地址映射到标准 Modbus 地址 + /// Implements address translation functionality for NA200H dedicated protocol, maps NA200H addresses to standard Modbus addresses + /// + /// NA200H 协议特点 / NA200H Protocol Characteristics: + /// + /// 基于 Modbus 协议的扩展 / Extension based on Modbus protocol + /// 多种数据区域映射到 Modbus 地址 / Multiple data areas map to Modbus addresses + /// 支持线圈和寄存器混合寻址 / Supports coil and register mixed addressing + /// + /// + /// + /// 地址映射表 / Address Mapping Table: + /// + /// Q (输出继电器) → Modbus 线圈 0-9999 / Modbus coils 0-9999 + /// M (辅助继电器) → Modbus 线圈 10000-19999 / Modbus coils 10000-19999 + /// N (特殊继电器) → Modbus 线圈 30000-39999 / Modbus coils 30000-39999 + /// I (输入继电器) → Modbus 离散输入 0-9999 / Modbus discrete inputs 0-9999 + /// S (状态继电器) → Modbus 离散输入 10000-19999 / Modbus discrete inputs 10000-19999 + /// IW (输入寄存器) → Modbus 输入寄存器 0-4999 / Modbus input registers 0-4999 + /// SW (特殊寄存器) → Modbus 输入寄存器 5000-9999 / Modbus input registers 5000-9999 + /// MW (辅助寄存器) → Modbus 保持寄存器 0-9999 / Modbus holding registers 0-9999 + /// QW (输出寄存器) → Modbus 保持寄存器 20000-29999 / Modbus holding registers 20000-29999 + /// NW (特殊寄存器) → Modbus 保持寄存器 21000-21999 / Modbus holding registers 21000-21999 + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// var translator = new AddressTranslatorNA200H(); + /// + /// // 翻译 NA200H 地址 / Translate NA200H address + /// AddressDef addr1 = translator.AddressTranslate("Q 1", isRead: true); + /// // 结果：AreaString="Q", Area=1 (功能码 01), Address=0 + /// + /// AddressDef addr2 = translator.AddressTranslate("MW 100", isRead: true); + /// // 结果：AreaString="MW", Area=3 (功能码 03), Address=99 + /// + /// AddressDef addr3 = translator.AddressTranslate("IW 50", isRead: true); + /// // 结果：AreaString="IW", Area=4 (功能码 04), Address=49 + /// + /// + /// /// public class AddressTranslatorNA200H : ModbusTranslatorBase { /// - /// 读功能码 + /// 读功能码字典 / Read Function Code Dictionary + /// + /// 存储各区域的读功能码和字节宽度 + /// Stores read function codes and byte widths for each area + /// /// protected Dictionary ReadFunctionCodeDictionary; /// - /// 功能码翻译至标准Modbus地址位置 + /// 地址转换字典 / Address Translation Dictionary + /// + /// 将 NA200H 区域映射到标准 Modbus 地址偏移 + /// Maps NA200H areas to standard Modbus address offsets + /// + /// 映射规则 / Mapping Rules: + /// + /// Q: 0 (线圈 0-9999) + /// M: 10000 (线圈 10000-19999) + /// N: 30000 (线圈 30000-39999) + /// I: 0 (离散输入 0-9999) + /// S: 10000 (离散输入 10000-19999) + /// IW: 0 (输入寄存器 0-4999) + /// SW: 5000 (输入寄存器 5000-9999) + /// MW: 0 (保持寄存器 0-9999) + /// QW: 20000 (保持寄存器 20000-29999) + /// NW: 21000 (保持寄存器 21000-21999) + /// + /// + /// /// protected Dictionary TransDictionary; /// - /// 写功能码 + /// 写功能码字典 / Write Function Code Dictionary + /// + /// 存储各区域的写功能码和字节宽度，区分单写和多写 + /// Stores write function codes and byte widths for each area, distinguishing single and multi-write + /// /// protected Dictionary<(string, bool), AreaOutputDef> WriteFunctionCodeDictionary; /// - /// 构造器 + /// 构造函数 / Constructor + /// + /// 初始化 NA200H 地址翻译器，配置所有映射关系 + /// Initialize NA200H address translator, configure all mapping relationships + /// /// public AddressTranslatorNA200H() { + // 初始化地址转换字典 / Initialize address translation dictionary TransDictionary = new Dictionary { - {"Q", 0}, - {"M", 10000}, - {"N", 30000}, - {"I", 0}, - {"S", 10000}, - {"IW", 0}, - {"SW", 5000}, - {"MW", 0}, - {"QW", 20000}, - {"NW", 21000} + {"Q", 0}, // 输出继电器 0-9999 / Output relay 0-9999 + {"M", 10000}, // 辅助继电器 10000-19999 / Auxiliary relay 10000-19999 + {"N", 30000}, // 特殊继电器 30000-39999 / Special relay 30000-39999 + {"I", 0}, // 输入继电器 0-9999 / Input relay 0-9999 + {"S", 10000}, // 状态继电器 10000-19999 / Status relay 10000-19999 + {"IW", 0}, // 输入寄存器 0-4999 / Input register 0-4999 + {"SW", 5000}, // 特殊寄存器 5000-9999 / Special register 5000-9999 + {"MW", 0}, // 辅助寄存器 0-9999 / Auxiliary register 0-9999 + {"QW", 20000}, // 输出寄存器 20000-29999 / Output register 20000-29999 + {"NW", 21000} // 特殊寄存器 21000-21999 / Special register 21000-21999 }; + + // 初始化读功能码字典 / Initialize read function code dictionary ReadFunctionCodeDictionary = new Dictionary { { @@ -103,6 +180,8 @@ namespace Modbus.Net.Modbus.NA200H new AreaOutputDef {Code = (int) ModbusProtocolFunctionCode.ReadHoldRegister, AreaWidth = 2} } }; + + // 初始化写功能码字典 / Initialize write function code dictionary WriteFunctionCodeDictionary = new Dictionary<(string, bool), AreaOutputDef> { { @@ -205,12 +284,58 @@ namespace Modbus.Net.Modbus.NA200H } /// - /// 地址转换 + /// 地址转换 / Address Translate + /// + /// 将 NA200H 格式的地址字符串翻译为 AddressDef 对象 + /// Translate NA200H format address string to AddressDef object + /// + /// 处理流程 / Processing Flow: + /// + /// 转为大写 / Convert to uppercase + /// 按空格分割 / Split by space + /// 提取区域 (head) 和地址 (tail) / Extract area (head) and address (tail) + /// 处理子地址 (位偏移) / Handle sub-address (bit offset) + /// 查表获取 Modbus 地址偏移 / Lookup Modbus address offset + /// 计算最终 Modbus 地址 / Calculate final Modbus address + /// 创建并返回 AddressDef / Create and return AddressDef + /// + /// + /// /// - /// 格式化的地址 - /// 是否为读取，是为读取，否为写入 - /// 是否只写入一个数据 - /// 翻译后的地址 + /// + /// 格式化的地址 / Formatted Address + /// + /// NA200H 格式，如 "Q 1", "MW 100", "IW 50.3" 等 + /// NA200H format, e.g., "Q 1", "MW 100", "IW 50.3", etc. + /// + /// + /// + /// 是否为读取 / Whether it's Read + /// + /// true: 读取操作 / Read operation + /// false: 写入操作 / Write operation + /// + /// + /// + /// 是否只写入一个数据 / Whether Writing Single Data + /// + /// true: 单个写入 / Single write + /// false: 多个写入 / Multi write + /// + /// + /// + /// 翻译后的地址 / Translated Address + /// + /// AddressDef 包含： + /// AddressDef contains: + /// + /// AreaString: NA200H 区域字符串 / NA200H area string + /// Area: Modbus 功能码 / Modbus function code + /// Address: Modbus 地址 (从 0 开始) / Modbus address (starts from 0) + /// SubAddress: 子地址 (位偏移) / Sub-address (bit offset) + /// + /// + /// public override AddressDef AddressTranslate(string address, bool isRead, bool isSingle) { address = address.ToUpper(); @@ -246,10 +371,35 @@ namespace Modbus.Net.Modbus.NA200H } /// - /// 获取区域中的单个地址占用的字节长度 + /// 获取区域字节长度 / Get Area Byte Length + /// + /// 返回 NA200H 区域中单个地址占用的字节长度 + /// Returns byte length per address in NA200H area + /// + /// 返回值说明 / Return Value Description: + /// + /// 线圈/继电器 (Q/M/N/I/S): 0.125 字节 (1 位) / Coils/Relays: 0.125 bytes (1 bit) + /// 寄存器 (IW/SW/MW/QW/NW): 2 字节 (16 位) / Registers: 2 bytes (16 bits) + /// + /// + /// /// - /// 区域名称 - /// 字节长度 + /// + /// 区域名称 / Area Name + /// + /// NA200H 区域标识 + /// NA200H area identifier + /// + /// + /// + /// 字节长度 / Byte Length + /// + /// + /// 线圈/继电器：0.125 字节 + /// 寄存器：2 字节 + /// + /// + /// public override double GetAreaByteLength(string area) { return ReadFunctionCodeDictionary[area].AreaWidth; diff --git a/Modbus.Net/Modbus.Net.Modbus.SelfDefinedSample/IUtilityMethodTime.cs b/Modbus.Net/Modbus.Net.Modbus.SelfDefinedSample/IUtilityMethodTime.cs index a28eb9a..f56bfed 100644 --- a/Modbus.Net/Modbus.Net.Modbus.SelfDefinedSample/IUtilityMethodTime.cs +++ b/Modbus.Net/Modbus.Net.Modbus.SelfDefinedSample/IUtilityMethodTime.cs @@ -1,24 +1,155 @@ -using System; +using System; using System.Threading.Tasks; namespace Modbus.Net.Modbus.SelfDefinedSample { /// - /// Utility的时间读写接口 + /// Utility 时间读写接口 / Utility Time Read/Write Interface + /// + /// 定义 Modbus 设备时间读写的高级接口 + /// Defines high-level interface for Modbus device time read/write + /// + /// 主要功能 / Main Functions: + /// + /// GetTimeAsync - 读取 PLC 系统时间 / Read PLC system time + /// SetTimeAsync - 设置 PLC 系统时间 / Set PLC system time + /// + /// + /// + /// 使用场景 / Use Cases: + /// + /// 设备时间同步 / Device time synchronization + /// 时间戳校准 / Timestamp calibration + /// 日志时间统一 / Log time unification + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // 创建支持时间的 Utility / Create time-enabled Utility + /// var utility = new ModbusUtilityTime( + /// ModbusType.Tcp, + /// "192.168.1.100:502", + /// slaveAddress: 1, + /// masterAddress: 0, + /// endian: Endian.BigEndianLsb + /// ); + /// + /// // 读取 PLC 时间 / Read PLC time + /// var timeResult = await utility.GetTimeAsync(startAddress: 0); + /// if (timeResult.IsSuccess) + /// { + /// Console.WriteLine($"PLC 时间：{timeResult.Datas}"); + /// } + /// + /// // 设置 PLC 时间 / Set PLC time + /// await utility.SetTimeAsync(startAddress: 0, DateTime.Now); + /// + /// + /// /// public interface IUtilityMethodTime : IUtilityMethod { /// - /// 获取PLC时间 + /// 获取 PLC 时间 / Get PLC Time + /// + /// 从 Modbus 设备读取当前系统时间 + /// Read current system time from Modbus device + /// + /// 时间格式 / Time Format: + /// + /// 年 (2 字节) / Year (2 bytes) + /// 月 (1 字节) / Month (1 byte) + /// 日 (1 字节) / Day (1 byte) + /// 时 (2 字节) / Hour (2 bytes) + /// 分 (1 字节) / Minute (1 byte) + /// 秒 (1 字节) / Second (1 byte) + /// 毫秒 (2 字节) / Millisecond (2 bytes) + /// + /// + /// + /// 共 10 字节，占用 5 个寄存器 / Total 10 bytes, occupies 5 registers + /// + /// /// - /// PLC时间 + /// + /// 起始地址 / Start Address + /// + /// 时间寄存器起始地址 + /// Starting address of time registers + /// + /// 通常为 0 或设备定义的地址 + /// Usually 0 or device-defined address + /// + /// + /// + /// + /// PLC 时间 / PLC Time + /// + /// ReturnStruct<DateTime> 包含： + /// ReturnStruct<DateTime> contains: + /// + /// Datas: 读取的时间值 / Read time value + /// IsSuccess: 读取是否成功 / Read success flag + /// ErrorCode: 错误码 / Error code + /// ErrorMsg: 错误消息 / Error message + /// + /// + /// Task> GetTimeAsync(ushort startAddress); /// - /// 设置PLC时间 + /// 设置 PLC 时间 / Set PLC Time + /// + /// 向 Modbus 设备写入系统时间 + /// Write system time to Modbus device + /// + /// 时间格式 / Time Format: + /// + /// 年 (2 字节) / Year (2 bytes) + /// 月 (1 字节) / Month (1 byte) + /// 日 (1 字节) / Day (1 byte) + /// 时 (2 字节) / Hour (2 bytes) + /// 分 (1 字节) / Minute (1 byte) + /// 秒 (1 字节) / Second (1 byte) + /// 毫秒 (2 字节) / Millisecond (2 bytes) + /// + /// + /// + /// 共 10 字节，占用 5 个寄存器 / Total 10 bytes, occupies 5 registers + /// + /// /// - /// 设置PLC时间 - /// 设置是否成功 + /// + /// 起始地址 / Start Address + /// + /// 时间寄存器起始地址 + /// Starting address of time registers + /// + /// + /// + /// 设置 PLC 时间 / PLC Time to Set + /// + /// 要写入的 DateTime 对象 + /// DateTime object to write + /// + /// 包含年月日时分秒毫秒 + /// Contains year, month, day, hour, minute, second, millisecond + /// + /// + /// + /// + /// 设置是否成功 / Whether Set is Successful + /// + /// ReturnStruct<bool>: + /// + /// Datas: true=成功，false=失败 / true=success, false=failure + /// IsSuccess: 操作是否成功 / Operation success flag + /// ErrorCode: 错误码 / Error code + /// ErrorMsg: 错误消息 / Error message + /// + /// + /// Task> SetTimeAsync(ushort startAddress, DateTime setTime); } } diff --git a/Modbus.Net/Modbus.Net.Modbus.SelfDefinedSample/ModbusProtocolTime.cs b/Modbus.Net/Modbus.Net.Modbus.SelfDefinedSample/ModbusProtocolTime.cs index 542ee19..8edc02d 100644 --- a/Modbus.Net/Modbus.Net.Modbus.SelfDefinedSample/ModbusProtocolTime.cs +++ b/Modbus.Net/Modbus.Net.Modbus.SelfDefinedSample/ModbusProtocolTime.cs @@ -1,82 +1,202 @@ -using System; +using System; using ProtocolUnit = Modbus.Net.ProtocolUnit; namespace Modbus.Net.Modbus.SelfDefinedSample { /// - /// 跟时间有关的功能码 + /// Modbus 时间协议功能码枚举 / Modbus Time Protocol Function Code Enum + /// + /// 定义与时间读写相关的自定义功能码 + /// Defines custom function codes related to time read/write + /// + /// 注意 / Note: + /// + /// 这些是自定义功能码，非标准 Modbus 功能码 + /// These are custom function codes, not standard Modbus function codes + /// 实际使用时需确认设备支持的功能码 + /// Confirm device-supported function codes before actual use + /// + /// + /// /// public enum ModbusProtocolTimeFunctionCode : byte { /// - /// 读时间 + /// 读系统时间 (功能码 3) / Get System Time (Function Code 3) + /// + /// 读取设备的当前系统时间 + /// Read device's current system time + /// + /// 请求数据 / Request Data: + /// + /// 从站地址 (1 字节) / Slave address (1 byte) + /// 功能码 3 (1 字节) / Function code 3 (1 byte) + /// 起始地址 (2 字节) / Start address (2 bytes) + /// 读取数量 5 (2 字节) / Read count 5 (2 bytes) + /// + /// + /// + /// 响应数据 / Response Data: + /// + /// 从站地址 (1 字节) / Slave address (1 byte) + /// 功能码 3 (1 字节) / Function code 3 (1 byte) + /// 字节数 10 (1 字节) / Byte count 10 (1 byte) + /// 年 (2 字节) / Year (2 bytes) + /// 日 (1 字节) / Day (1 byte) + /// 月 (1 字节) / Month (1 byte) + /// 时 (2 字节) / Hour (2 bytes) + /// 秒 (1 字节) / Second (1 byte) + /// 分 (1 字节) / Minute (1 byte) + /// 毫秒 (2 字节) / Millisecond (2 bytes) + /// + /// + /// /// GetSystemTime = 3, /// - /// 写时间 + /// 写系统时间 (功能码 16) / Set System Time (Function Code 16) + /// + /// 写入设备的系统时间 + /// Write device's system time + /// + /// 请求数据 / Request Data: + /// + /// 从站地址 (1 字节) / Slave address (1 byte) + /// 功能码 16 (1 字节) / Function code 16 (1 byte) + /// 起始地址 (2 字节) / Start address (2 bytes) + /// 写入数量 5 (2 字节) / Write count 5 (2 bytes) + /// 字节数 10 (1 字节) / Byte count 10 (1 byte) + /// 年 (2 字节) / Year (2 bytes) + /// 日 (1 字节) / Day (1 byte) + /// 月 (1 字节) / Month (1 byte) + /// 时 (2 字节) / Hour (2 bytes) + /// 秒 (1 字节) / Second (1 byte) + /// 分 (1 字节) / Minute (1 byte) + /// 毫秒 (2 字节) / Millisecond (2 bytes) + /// + /// + /// + /// 响应数据 / Response Data: + /// + /// 从站地址 (1 字节) / Slave address (1 byte) + /// 功能码 16 (1 字节) / Function code 16 (1 byte) + /// 起始地址 (2 字节) / Start address (2 bytes) + /// 写入数量 5 (2 字节) / Write count 5 (2 bytes) + /// + /// + /// /// SetSystemTime = 16 } - #region 读PLC时间 + #region 读 PLC 时间 / Read PLC Time /// - /// 读时间输入 + /// 读时间输入结构 / Read Time Input Structure + /// + /// 封装读取设备时间的请求参数 + /// Encapsulates request parameters for reading device time + /// /// public class GetSystemTimeModbusInputStruct : IInputStruct { /// - /// 构造函数 + /// 构造函数 / Constructor + /// + /// 初始化读时间请求参数 + /// Initialize read time request parameters + /// /// - /// 从站号 + /// + /// 从站号 / Slave Address + /// + /// Modbus 从站地址，范围 1-247 + /// Modbus slave address, range 1-247 + /// + /// + /// + /// 起始地址 / Start Address + /// + /// 时间寄存器起始地址 + /// Starting address of time registers + /// + /// public GetSystemTimeModbusInputStruct(byte slaveAddress, ushort startAddress) { SlaveAddress = slaveAddress; FunctionCode = (byte)ModbusProtocolTimeFunctionCode.GetSystemTime; StartAddress = startAddress; - GetCount = 5; + GetCount = 5; // 时间占用 5 个寄存器 / Time occupies 5 registers } /// - /// 从站号 + /// 从站号 / Slave Address + /// + /// Modbus 从站地址 + /// Modbus slave address + /// /// public byte SlaveAddress { get; } /// - /// 功能码 + /// 功能码 / Function Code + /// + /// 读时间功能码 (3) + /// Read time function code (3) + /// /// public byte FunctionCode { get; } /// - /// 开始地址 + /// 开始地址 / Start Address + /// + /// 时间寄存器起始地址 + /// Starting address of time registers + /// /// public ushort StartAddress { get; } /// - /// 获取个数 + /// 获取个数 / Get Count + /// + /// 读取寄存器数量 (5 个) + /// Number of registers to read (5) + /// + /// 年 (1) + 日月 (2) + 时分 (2) + 秒毫秒 (2) = 5 个寄存器 + /// Year (1) + Day/Month (2) + Hour/Minute (2) + Second/Millisecond (2) = 5 registers + /// + /// /// public ushort GetCount { get; } } /// - /// 读时间输出 + /// 读时间输出结构 / Read Time Output Structure + /// + /// 封装读取设备时间的响应数据 + /// Encapsulates response data for reading device time + /// /// public class GetSystemTimeModbusOutputStruct : IOutputStruct { /// - /// 构造函数 + /// 构造函数 / Constructor + /// + /// 初始化读时间响应数据 + /// Initialize read time response data + /// /// - /// 从站号 - /// 功能码 - /// 写入个数 - /// 年 - /// 日 - /// 月 - /// 时 - /// 秒 - /// 分 - /// 毫秒 + /// 从站号 / Slave Address + /// 功能码 / Function Code + /// 写入个数 / Write Byte Count + /// 年 / Year + /// 日 / Day + /// 月 / Month + /// 时 / Hour + /// 秒 / Second + /// 分 / Minute + /// 毫秒 / Millisecond public GetSystemTimeModbusOutputStruct(byte slaveAddress, byte functionCode, byte writeByteCount, ushort year, byte day, byte month, ushort hour, byte second, byte minute, ushort millisecond) @@ -88,36 +208,64 @@ namespace Modbus.Net.Modbus.SelfDefinedSample } /// - /// 从站号 + /// 从站号 / Slave Address /// public byte SlaveAddress { get; private set; } /// - /// 功能码 + /// 功能码 / Function Code /// public byte FunctionCode { get; private set; } /// - /// 写入个数 + /// 写入个数 / Write Byte Count /// public byte WriteByteCount { get; private set; } /// - /// 时间 + /// 时间 / Time + /// + /// 解析后的 DateTime 对象 + /// Parsed DateTime object + /// /// public DateTime Time { get; private set; } } /// - /// 读系统时间协议 + /// 读系统时间协议类 / Read System Time Protocol Class + /// + /// 实现读系统时间的协议格式化和反格式化 + /// Implements protocol formatting and unformatting for reading system time + /// /// public class GetSystemTimeModbusProtocol : ProtocolUnit { /// - /// 格式化 + /// 格式化 (发送前) / Format (Before Sending) + /// + /// 将读时间请求参数转换为字节数组 + /// Convert read time request parameters to byte array + /// + /// 格式 / Format: + /// [从站地址][功能码][起始地址 (2)][读取数量 (2)] + /// + /// /// - /// 写系统时间参数 - /// 写系统时间的核心 + /// + /// 读时间输入结构 / Read Time Input Structure + /// + /// 包含从站地址、起始地址等参数 + /// Contains slave address, start address, etc. + /// + /// + /// + /// 格式化后的字节数组 / Formatted Byte Array + /// + /// Modbus 读时间请求帧 + /// Modbus read time request frame + /// + /// public override byte[] Format(IInputStruct message) { var r_message = (GetSystemTimeModbusInputStruct)message; @@ -126,11 +274,48 @@ namespace Modbus.Net.Modbus.SelfDefinedSample } /// - /// 反格式化 + /// 反格式化 (接收后) / Unformat (After Receiving) + /// + /// 将响应字节数组解析为读时间输出结构 + /// Parse response byte array to read time output structure + /// + /// 解析顺序 / Parse Order: + /// + /// 从站地址 (1 字节) / Slave address (1 byte) + /// 功能码 (1 字节) / Function code (1 byte) + /// 字节数 (1 字节) / Byte count (1 byte) + /// 年 (2 字节) / Year (2 bytes) + /// 日 (1 字节) / Day (1 byte) + /// 月 (1 字节) / Month (1 byte) + /// 时 (2 字节) / Hour (2 bytes) + /// 秒 (1 字节) / Second (1 byte) + /// 分 (1 字节) / Minute (1 byte) + /// 毫秒 (2 字节) / Millisecond (2 bytes) + /// + /// + /// /// - /// 获取的信息 - /// 当前反格式化的位置 - /// 反格式化的信息 + /// + /// 获取的信息 / Received Information + /// + /// 设备返回的字节数组 + /// Byte array returned from device + /// + /// + /// + /// 当前反格式化的位置 / Current Unformat Position + /// + /// 引用传递，自动更新 + /// Passed by reference, auto-updated + /// + /// + /// + /// 反格式化的信息 / Unformatted Information + /// + /// GetSystemTimeModbusOutputStruct 对象 + /// GetSystemTimeModbusOutputStruct object + /// + /// public override IOutputStruct Unformat(byte[] messageBytes, ref int flag) { var slaveAddress = ValueHelper.GetInstance(Endian).GetByte(messageBytes, ref flag); @@ -150,25 +335,34 @@ namespace Modbus.Net.Modbus.SelfDefinedSample #endregion - #region 写PLC时间 + #region 写 PLC 时间 / Write PLC Time /// - /// 写时间输入 + /// 写时间输入结构 / Write Time Input Structure + /// + /// 封装写入设备时间的请求参数 + /// Encapsulates request parameters for writing device time + /// /// public class SetSystemTimeModbusInputStruct : IInputStruct { /// - /// 构造函数 + /// 构造函数 / Constructor + /// + /// 初始化写时间请求参数，从 DateTime 提取各时间分量 + /// Initialize write time request parameters, extract time components from DateTime + /// /// - /// 从站号 - /// 时间 + /// 从站号 / Slave Address + /// 起始地址 / Start Address + /// 时间 / Time public SetSystemTimeModbusInputStruct(byte slaveAddress, ushort startAddress, DateTime time) { SlaveAddress = slaveAddress; FunctionCode = (byte)ModbusProtocolTimeFunctionCode.SetSystemTime; StartAddress = startAddress; - WriteCount = 5; - WriteByteCount = 10; + WriteCount = 5; // 时间占用 5 个寄存器 / Time occupies 5 registers + WriteByteCount = 10; // 10 字节数据 / 10 bytes data Year = (ushort)time.Year; Day = (byte)time.Day; Month = (byte)time.Month; @@ -179,78 +373,86 @@ namespace Modbus.Net.Modbus.SelfDefinedSample } /// - /// 从站号 + /// 从站号 / Slave Address /// public byte SlaveAddress { get; } /// - /// 功能码 + /// 功能码 / Function Code /// public byte FunctionCode { get; } /// - /// 开始地址 + /// 开始地址 / Start Address /// public ushort StartAddress { get; } /// - /// 写入个数 + /// 写入个数 / Write Count /// public ushort WriteCount { get; } /// - /// 写入字节个数 + /// 写入字节个数 / Write Byte Count /// public byte WriteByteCount { get; } /// - /// 年 + /// 年 / Year /// public ushort Year { get; } /// - /// 日 + /// 日 / Day /// public byte Day { get; } /// - /// 月 + /// 月 / Month /// public byte Month { get; } /// - /// 时 + /// 时 / Hour /// public ushort Hour { get; } /// - /// 秒 + /// 秒 / Second /// public byte Second { get; } /// - /// 分 + /// 分 / Minute /// public byte Minute { get; } /// - /// 毫秒 + /// 毫秒 / Millisecond /// public ushort Millisecond { get; } } /// - /// 写时间输出 + /// 写时间输出结构 / Write Time Output Structure + /// + /// 封装写入设备时间的响应数据 + /// Encapsulates response data for writing device time + /// /// public class SetSystemTimeModbusOutputStruct : IOutputStruct { /// - /// 构造函数 + /// 构造函数 / Constructor + /// + /// 初始化写时间响应数据 + /// Initialize write time response data + /// /// - /// 从站号 - /// 功能码 - /// 开始地址 - /// 写入个数 + /// 从站号 / Slave Address + /// 功能码 / Function Code + /// 开始地址 / Start Address + /// 写入个数 / Write Count public SetSystemTimeModbusOutputStruct(byte slaveAddress, byte functionCode, ushort startAddress, ushort writeCount) { @@ -261,36 +463,60 @@ namespace Modbus.Net.Modbus.SelfDefinedSample } /// - /// 从站号 + /// 从站号 / Slave Address /// public byte SlaveAddress { get; private set; } /// - /// 功能码 + /// 功能码 / Function Code /// public byte FunctionCode { get; private set; } /// - /// 开始地址 + /// 开始地址 / Start Address /// public ushort StartAddress { get; private set; } /// - /// 写入个数 + /// 写入个数 / Write Count /// public ushort WriteCount { get; private set; } } /// - /// 写系统时间协议 + /// 写系统时间协议类 / Write System Time Protocol Class + /// + /// 实现写系统时间的协议格式化和反格式化 + /// Implements protocol formatting and unformatting for writing system time + /// /// public class SetSystemTimeModbusProtocol : ProtocolUnit { /// - /// 格式化 + /// 格式化 (发送前) / Format (Before Sending) + /// + /// 将写时间请求参数转换为字节数组 + /// Convert write time request parameters to byte array + /// + /// 格式 / Format: + /// [从站地址][功能码][起始地址 (2)][写入数量 (2)][字节数 (1)][年 (2)][日 (1)][月 (1)][时 (2)][秒 (1)][分 (1)][毫秒 (2)] + /// + /// /// - /// 写系统时间的参数 - /// 写系统时间的核心 + /// + /// 写时间输入结构 / Write Time Input Structure + /// + /// 包含从站地址、时间等参数 + /// Contains slave address, time, etc. + /// + /// + /// + /// 格式化后的字节数组 / Formatted Byte Array + /// + /// Modbus 写时间请求帧 + /// Modbus write time request frame + /// + /// public override byte[] Format(IInputStruct message) { var r_message = (SetSystemTimeModbusInputStruct)message; @@ -301,11 +527,39 @@ namespace Modbus.Net.Modbus.SelfDefinedSample } /// - /// 反格式化 + /// 反格式化 (接收后) / Unformat (After Receiving) + /// + /// 将响应字节数组解析为写时间输出结构 + /// Parse response byte array to write time output structure + /// + /// 解析顺序 / Parse Order: + /// + /// 从站地址 (1 字节) / Slave address (1 byte) + /// 功能码 (1 字节) / Function code (1 byte) + /// 起始地址 (2 字节) / Start address (2 bytes) + /// 写入数量 (2 字节) / Write count (2 bytes) + /// + /// + /// /// - /// 获取的信息 - /// 当前反格式化的位置 - /// 反格式化的信息 + /// + /// 获取的信息 / Received Information + /// + /// 设备返回的字节数组 + /// Byte array returned from device + /// + /// + /// + /// 当前反格式化的位置 / Current Unformat Position + /// 引用传递，自动更新 / Passed by reference, auto-updated + /// + /// + /// 反格式化的信息 / Unformatted Information + /// + /// SetSystemTimeModbusOutputStruct 对象 + /// SetSystemTimeModbusOutputStruct object + /// + /// public override IOutputStruct Unformat(byte[] messageBytes, ref int flag) { var slaveAddress = ValueHelper.GetInstance(Endian).GetByte(messageBytes, ref flag); @@ -317,4 +571,4 @@ namespace Modbus.Net.Modbus.SelfDefinedSample } #endregion -} \ No newline at end of file +} diff --git a/Modbus.Net/Modbus.Net.Modbus.SelfDefinedSample/ModbusUtilityTime.cs b/Modbus.Net/Modbus.Net.Modbus.SelfDefinedSample/ModbusUtilityTime.cs index 63fca81..f23144c 100644 --- a/Modbus.Net/Modbus.Net.Modbus.SelfDefinedSample/ModbusUtilityTime.cs +++ b/Modbus.Net/Modbus.Net.Modbus.SelfDefinedSample/ModbusUtilityTime.cs @@ -1,20 +1,95 @@ -using Microsoft.Extensions.Logging; +using Microsoft.Extensions.Logging; using System; using System.Threading.Tasks; namespace Modbus.Net.Modbus.SelfDefinedSample { + /// + /// Modbus 时间工具类 / Modbus Time Utility Class + /// + /// 提供 Modbus 设备时间读写功能，继承自 ModbusUtility + /// Provides Modbus device time read/write functionality, inherits from ModbusUtility + /// + /// 主要功能 / Main Functions: + /// + /// GetTimeAsync - 读取 PLC 系统时间 / Read PLC system time + /// SetTimeAsync - 设置 PLC 系统时间 / Set PLC system time + /// + /// + /// + /// 时间格式 / Time Format: + /// + /// 年 (2 字节) / Year (2 bytes) + /// 月 (1 字节) / Month (1 byte) + /// 日 (1 字节) / Day (1 byte) + /// 时 (2 字节) / Hour (2 bytes) + /// 分 (1 字节) / Minute (1 byte) + /// 秒 (1 字节) / Second (1 byte) + /// 毫秒 (2 字节) / Millisecond (2 bytes) + /// + /// 共 10 字节，占用 5 个寄存器 / Total 10 bytes, occupies 5 registers + /// + /// + /// 使用示例 / Usage Example: + /// + /// // 创建时间工具实例 / Create time utility instance + /// var utility = new ModbusUtilityTime( + /// ModbusType.Tcp, + /// "192.168.1.100:502", + /// slaveAddress: 1, + /// masterAddress: 0, + /// endian: Endian.BigEndianLsb + /// ); + /// + /// // 连接设备 / Connect to device + /// await utility.ConnectAsync(); + /// + /// // 读取 PLC 时间 / Read PLC time + /// var timeResult = await utility.GetTimeAsync(startAddress: 0); + /// if (timeResult.IsSuccess) + /// { + /// Console.WriteLine($"PLC 时间：{timeResult.Datas}"); + /// } + /// + /// // 同步 PLC 时间 / Sync PLC time + /// await utility.SetTimeAsync(startAddress: 0, DateTime.Now); + /// + /// + /// + /// public class ModbusUtilityTime : ModbusUtility, IUtilityMethodTime { private static readonly ILogger logger = LogProvider.CreateLogger(); /// - /// 构造函数 + /// 构造函数 (无连接字符串) / Constructor (without Connection String) + /// + /// 初始化 Modbus 时间工具，稍后通过 SetConnectionType 设置连接 + /// Initialize Modbus time utility, set connection later via SetConnectionType + /// /// - /// 协议类型 - /// 从站号 - /// 主站号 - /// 端格式 + /// + /// 协议类型 / Protocol Type + /// + /// ModbusType 枚举值 + /// ModbusType enum value + /// + /// + /// + /// 从站号 / Slave Address + /// Modbus 从站地址，范围 1-247 / Modbus slave address, range 1-247 + /// + /// + /// 主站号 / Master Address + /// 通常为 0 或 1 / Usually 0 or 1 + /// + /// + /// 端格式 / Endianness + /// + /// Modbus 标准使用 BigEndianLsb + /// Modbus standard uses BigEndianLsb + /// + /// public ModbusUtilityTime(int connectionType, byte slaveAddress, byte masterAddress, Endian endian) : base(connectionType, slaveAddress, masterAddress, endian) @@ -22,13 +97,26 @@ namespace Modbus.Net.Modbus.SelfDefinedSample } /// - /// 构造函数 + /// 构造函数 (带连接字符串) / Constructor (with Connection String) + /// + /// 初始化 Modbus 时间工具并立即设置连接 + /// Initialize Modbus time utility and set connection immediately + /// /// - /// 协议类型 - /// 连接地址 - /// 从站号 - /// 主站号 - /// 端格式 + /// + /// 协议类型 / Protocol Type + /// ModbusType 枚举值 / ModbusType enum value + /// + /// + /// 连接地址 / Connection Address + /// + /// TCP: "192.168.1.100:502" + /// 串口："COM1" 或 "COM1,9600,None,8,1" + /// + /// + /// 从站号 / Slave Address + /// 主站号 / Master Address + /// 端格式 / Endianness public ModbusUtilityTime(ModbusType connectionType, string connectionString, byte slaveAddress, byte masterAddress, Endian endian) : base(connectionType, connectionString, slaveAddress, masterAddress, endian) @@ -36,17 +124,54 @@ namespace Modbus.Net.Modbus.SelfDefinedSample } /// - /// 读时间 + /// 读时间 / Read Time + /// + /// 从 Modbus 设备读取当前系统时间 + /// Read current system time from Modbus device + /// + /// 处理流程 / Processing Flow: + /// + /// 创建 GetSystemTimeModbusInputStruct / Create GetSystemTimeModbusInputStruct + /// 发送读时间请求 / Send read time request + /// 接收 GetSystemTimeModbusOutputStruct / Receive GetSystemTimeModbusOutputStruct + /// 解析时间并返回 / Parse time and return + /// 处理异常情况 / Handle exceptions + /// + /// + /// /// - /// 设备的时间 + /// + /// 起始地址 / Start Address + /// + /// 时间寄存器起始地址 + /// Starting address of time registers + /// + /// + /// + /// 设备的时间 / Device Time + /// + /// ReturnStruct<DateTime> 包含： + /// ReturnStruct<DateTime> contains: + /// + /// Datas: 读取的时间值 / Read time value + /// IsSuccess: 读取是否成功 / Read success flag + /// ErrorCode: 错误码 / Error code + /// ErrorMsg: 错误消息 / Error message + /// + /// + /// public async Task> GetTimeAsync(ushort startAddress) { try { + // 创建读时间输入结构 / Create read time input structure var inputStruct = new GetSystemTimeModbusInputStruct(SlaveAddress, startAddress); + + // 发送接收 / Send and receive var outputStruct = await Wrapper.SendReceiveAsync( Wrapper[typeof(GetSystemTimeModbusProtocol)], inputStruct); + return new ReturnStruct { Datas = outputStruct?.Time ?? DateTime.MinValue, @@ -69,18 +194,62 @@ namespace Modbus.Net.Modbus.SelfDefinedSample } /// - /// 写时间 + /// 写时间 / Write Time + /// + /// 向 Modbus 设备写入系统时间 + /// Write system time to Modbus device + /// + /// 处理流程 / Processing Flow: + /// + /// 创建 SetSystemTimeModbusInputStruct / Create SetSystemTimeModbusInputStruct + /// 从 DateTime 提取时间分量 / Extract time components from DateTime + /// 发送写时间请求 / Send write time request + /// 接收 SetSystemTimeModbusOutputStruct / Receive SetSystemTimeModbusOutputStruct + /// 检查写入结果 / Check write result + /// 处理异常情况 / Handle exceptions + /// + /// + /// /// - /// 需要写入的时间 - /// 写入是否成功 + /// + /// 起始地址 / Start Address + /// + /// 时间寄存器起始地址 + /// Starting address of time registers + /// + /// + /// + /// 需要写入的时间 / Time to Write + /// + /// DateTime 对象，包含年月日时分秒毫秒 + /// DateTime object with year, month, day, hour, minute, second, millisecond + /// + /// + /// + /// 写入是否成功 / Whether Write is Successful + /// + /// ReturnStruct<bool>: + /// + /// Datas: true=成功，false=失败 / true=success, false=failure + /// IsSuccess: 操作是否成功 / Operation success flag + /// ErrorCode: 错误码 / Error code + /// ErrorMsg: 错误消息 / Error message + /// + /// + /// public async Task> SetTimeAsync(ushort startAddress, DateTime setTime) { try { + // 创建写时间输入结构 / Create write time input structure var inputStruct = new SetSystemTimeModbusInputStruct(SlaveAddress, startAddress, setTime); + + // 发送接收 / Send and receive var outputStruct = await Wrapper.SendReceiveAsync( Wrapper[typeof(SetSystemTimeModbusProtocol)], inputStruct); + + // 检查写入结果 / Check write result return new ReturnStruct() { Datas = outputStruct?.WriteCount > 0, diff --git a/Modbus.Net/Modbus.Net.Modbus/AddressFormaterModbus.cs b/Modbus.Net/Modbus.Net.Modbus/AddressFormaterModbus.cs index 5b21c40..1058a6c 100644 --- a/Modbus.Net/Modbus.Net.Modbus/AddressFormaterModbus.cs +++ b/Modbus.Net/Modbus.Net.Modbus/AddressFormaterModbus.cs @@ -1,31 +1,178 @@ -namespace Modbus.Net.Modbus +namespace Modbus.Net.Modbus { /// - /// Modbus标准AddressFormater + /// Modbus 标准地址格式化器 / Modbus Standard Address Formater + /// + /// 实现 Modbus 协议的标准地址格式化功能 + /// Implements standard address formatting functionality for Modbus protocol + /// + /// 地址格式 / Address Format: + /// + /// 无子地址: "Area Address" (如 "4X 1") / Without sub-address: "Area Address" (e.g., "4X 1") + /// 有子地址: "Area Address.SubAddress" (如 "4X 1.3") / With sub-address: "Area Address.SubAddress" (e.g., "4X 1.3") + /// + /// + /// + /// 地址组成 / Address Components: + /// + /// Area - 区域标识 (0X/1X/3X/4X) / Area identifier (0X/1X/3X/4X) + /// Address - 地址偏移 / Address offset + /// SubAddress - 子地址 (位偏移 0-7) / Sub-address (bit offset 0-7) + /// + /// + /// + /// 区域说明 / Area Description: + /// + /// 0X - 线圈 (Coil) - 可读可写 / Readable and Writable + /// 1X - 离散输入 (Discrete Input) - 只读 / Read-only + /// 3X - 输入寄存器 (Input Register) - 只读 / Read-only + /// 4X - 保持寄存器 (Holding Register) - 可读可写 / Readable and Writable + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// var formater = new AddressFormaterModbus(); + /// + /// // 格式化地址 (无子地址) / Format address (without sub-address) + /// string addr1 = formater.FormatAddress("4X", 1); + /// // 结果："4X 1" + /// + /// // 格式化地址 (有子地址) / Format address (with sub-address) + /// string addr2 = formater.FormatAddress("4X", 5, 3); + /// // 结果："4X 5.3" (保持寄存器第 5 个的第 3 位) + /// + /// + /// /// public class AddressFormaterModbus : AddressFormater { /// - /// 格式化地址 + /// 格式化地址 (无子地址) / Format Address (without Sub-Address) + /// + /// 将区域和地址转换为 Modbus 标准格式字符串 + /// Convert area and address to Modbus standard format string + /// + /// 格式 / Format: + /// Area + " " + Address + /// + /// + /// 示例 / Examples: + /// + /// Area="4X", Address=1 → "4X 1" + /// Area="0X", Address=10 → "0X 10" + /// Area="3X", Address=5 → "3X 5" + /// + /// + /// /// - /// 地址区域 - /// 地址 - /// 格式化的地址字符串 + /// + /// 地址区域 / Address Area + /// + /// Modbus 区域标识 + /// Modbus area identifier + /// + /// 有效值 / Valid Values: + /// + /// "0X" - 线圈 / Coil + /// "1X" - 离散输入 / Discrete Input + /// "3X" - 输入寄存器 / Input Register + /// "4X" - 保持寄存器 / Holding Register + /// + /// + /// + /// + /// + /// 地址 / Address + /// + /// 地址偏移量 (从 1 开始) + /// Address offset (starts from 1) + /// + /// 示例 / Examples: + /// + /// 40001 → Address=1 + /// 40002 → Address=2 + /// + /// + /// + /// + /// + /// 格式化的地址字符串 / Formatted Address String + /// + /// 格式："Area Address" + /// Format: "Area Address" + /// + /// public override string FormatAddress(string area, int address) { return area + " " + address; } /// - /// 格式化地址 + /// 格式化地址 (带子地址) / Format Address (with Sub-Address) + /// + /// 将区域、地址和子地址转换为 Modbus 标准格式字符串 + /// Convert area, address and sub-address to Modbus standard format string + /// + /// 格式 / Format: + /// Area + " " + Address + "." + SubAddress + /// + /// + /// 示例 / Examples: + /// + /// Area="4X", Address=1, SubAddress=0 → "4X 1.0" + /// Area="0X", Address=10, SubAddress=3 → "0X 10.3" (线圈第 10 个的第 3 位) + /// Area="4X", Address=5, SubAddress=7 → "4X 5.7" (保持寄存器第 5 个的第 7 位) + /// + /// + /// + /// 子地址说明 / Sub-Address Description: + /// + /// 范围：0-7 (一个字节的 8 个位) / Range: 0-7 (8 bits of one byte) + /// 用于访问单个位 / Used to access individual bits + /// 仅对 Boolean 类型有效 / Only valid for Boolean type + /// + /// + /// /// - /// 地址区域 - /// 地址 - /// 比特位地址 - /// 格式化的地址字符串 + /// + /// 地址区域 / Address Area + /// + /// Modbus 区域标识 + /// Modbus area identifier + /// + /// + /// + /// 地址 / Address + /// + /// 地址偏移量 + /// Address offset + /// + /// + /// + /// 比特位地址 / Bit Address + /// + /// 子地址 (位偏移) + /// Sub-address (bit offset) + /// + /// 范围 / Range: 0-7 + /// + /// 0 - 最低位 / LSB + /// 7 - 最高位 / MSB + /// + /// + /// + /// + /// + /// 格式化的地址字符串 / Formatted Address String + /// + /// 格式："Area Address.SubAddress" + /// Format: "Area Address.SubAddress" + /// + /// public override string FormatAddress(string area, int address, int subAddress) { return area + " " + address + "." + subAddress; } } -} \ No newline at end of file +} diff --git a/Modbus.Net/Modbus.Net.Modbus/AddressTranslatorModbus.cs b/Modbus.Net/Modbus.Net.Modbus/AddressTranslatorModbus.cs index bfd0f2f..007a589 100644 --- a/Modbus.Net/Modbus.Net.Modbus/AddressTranslatorModbus.cs +++ b/Modbus.Net/Modbus.Net.Modbus/AddressTranslatorModbus.cs @@ -1,27 +1,110 @@ -using System.Collections.Generic; +using System.Collections.Generic; namespace Modbus.Net.Modbus { /// - /// Modbus地址翻译器基类 + /// Modbus 地址翻译器基类 / Modbus Address Translator Base Class + /// + /// 提供 Modbus 地址翻译的基础功能，支持读/写操作 + /// Provides base functionality for Modbus address translation, supporting read/write operations + /// + /// 主要功能 / Main Functions: + /// + /// 将用户友好的地址字符串转换为内部地址结构 / Convert user-friendly address strings to internal address structure + /// 根据区域 (0X/1X/3X/4X) 确定功能码 / Determine function code based on area (0X/1X/3X/4X) + /// 处理子地址 (位偏移) / Handle sub-address (bit offset) + /// 计算区域字节宽度 / Calculate area byte width + /// + /// + /// + /// 地址格式 / Address Format: + /// "Area Address[.SubAddress]" + /// + /// "4X 1" - 保持寄存器第 1 个 / Holding Register #1 + /// "0X 10" - 线圈第 10 个 / Coil #10 + /// "4X 5.3" - 保持寄存器第 5 个的第 3 位 / Bit 3 of Holding Register #5 + /// + /// + /// /// public abstract class ModbusTranslatorBase : AddressTranslator { /// - /// 地址转换 + /// 地址转换 (支持 isSingle 参数) / Address Translate (with isSingle parameter) + /// + /// 将格式化的地址字符串翻译为 AddressDef 对象 + /// Translate formatted address string to AddressDef object + /// + /// 参数说明 / Parameters: + /// + /// address - 格式化的地址字符串 / Formatted address string + /// isRead - 是否为读取操作 / Whether it's a read operation + /// isSingle - 是否只写入一个数据 / Whether writing single data only + /// + /// + /// + /// isSingle 参数用途 / isSingle Parameter Purpose: + /// + /// true: 使用单写功能码 (05/06) / Use single write function code (05/06) + /// false: 使用多写功能码 (15/16) / Use multi-write function code (15/16) + /// + /// + /// /// - /// 格式化的地址 - /// 是否为读取，是为读取，否为写入 - /// 是否只写入一个数据 - /// 翻译后的地址 + /// + /// 格式化的地址 / Formatted Address + /// + /// 示例 / Examples: + /// + /// "4X 1" - 保持寄存器 / Holding Register + /// "0X 10" - 线圈 / Coil + /// "3X 5" - 输入寄存器 / Input Register + /// "1X 20" - 离散输入 / Discrete Input + /// + /// + /// + /// + /// 是否为读取 / Whether it's Read + /// + /// true: 读取操作 / Read operation + /// false: 写入操作 / Write operation + /// + /// + /// + /// 是否只写入一个数据 / Whether Writing Single Data + /// + /// true: 单个写入 / Single write + /// false: 多个写入 / Multi write + /// + /// 仅写入操作时有效 / Only valid for write operations + /// + /// + /// + /// + /// 翻译后的地址 / Translated Address + /// + /// AddressDef 包含： + /// AddressDef contains: + /// + /// AreaString: 区域字符串 (如 "4X") / Area string (e.g., "4X") + /// Area: 功能码 / Function code + /// Address: 内部地址 (从 0 开始) / Internal address (starts from 0) + /// SubAddress: 子地址 (位偏移) / Sub-address (bit offset) + /// + /// + /// public abstract AddressDef AddressTranslate(string address, bool isRead, bool isSingle); /// - /// 地址转换 + /// 地址转换 (默认 isSingle=false) / Address Translate (default isSingle=false) + /// + /// 重载方法，默认使用多写模式 + /// Overloaded method, defaults to multi-write mode + /// /// - /// 格式化的地址 - /// 是否为读取，是为读取，否为写入 - /// 翻译后的地址 + /// 格式化的地址 / Formatted Address + /// 是否为读取 / Whether it's Read + /// 翻译后的地址 / Translated Address public override AddressDef AddressTranslate(string address, bool isRead) { return AddressTranslate(address, isRead, false); @@ -29,83 +112,167 @@ namespace Modbus.Net.Modbus } /// - /// Modbus数据单元翻译器 + /// Modbus 数据单元翻译器 / Modbus Data Unit Translator + /// + /// 实现 Modbus 协议的地址翻译功能，支持所有标准 Modbus 区域 + /// Implements Modbus protocol address translation functionality, supporting all standard Modbus areas + /// + /// 支持的区域 / Supported Areas: + /// + /// 0X - 线圈 (Coil) - 可读可写 / Readable and Writable + /// 1X - 离散输入 (Discrete Input) - 只读 / Read-only + /// 3X - 输入寄存器 (Input Register) - 只读 / Read-only + /// 4X - 保持寄存器 (Holding Register) - 可读可写 / Readable and Writable + /// + /// + /// + /// 功能码映射 / Function Code Mapping: + /// + /// 读取 0X: 功能码 01 (Read Coil Status) + /// 读取 1X: 功能码 02 (Read Input Status) + /// 读取 3X: 功能码 04 (Read Input Register) + /// 读取 4X: 功能码 03 (Read Holding Register) + /// 单写 0X: 功能码 05 (Write Single Coil) + /// 单写 4X: 功能码 06 (Write Single Register) + /// 多写 0X: 功能码 15 (Write Multi Coil) + /// 多写 4X: 功能码 16 (Write Multi Register) + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// var translator = new AddressTranslatorModbus(); + /// + /// // 翻译读取请求 / Translate read request + /// AddressDef readAddr = translator.AddressTranslate("4X 1", isRead: true); + /// // 结果：AreaString="4X", Area=3, Address=0, SubAddress=0 + /// + /// // 翻译写入请求 (单个) / Translate write request (single) + /// AddressDef writeSingleAddr = translator.AddressTranslate("4X 1", isRead: false, isSingle: true); + /// // 结果：AreaString="4X", Area=6, Address=0, SubAddress=0 + /// + /// // 翻译写入请求 (多个) / Translate write request (multi) + /// AddressDef writeMultiAddr = translator.AddressTranslate("4X 1", isRead: false, isSingle: false); + /// // 结果：AreaString="4X", Area=16, Address=0, SubAddress=0 + /// + /// // 获取区域字节宽度 / Get area byte width + /// double byteWidth = translator.GetAreaByteLength("4X"); // 返回：2.0 + /// + /// + /// /// public class AddressTranslatorModbus : ModbusTranslatorBase { /// - /// 读功能码 + /// 读功能码字典 / Read Function Code Dictionary + /// + /// 存储各区域的读功能码和字节宽度 + /// Stores read function codes and byte widths for each area + /// + /// 数据结构 / Data Structure: + /// + /// Key: 区域字符串 (如 "0X", "4X") / Area string (e.g., "0X", "4X") + /// Value: AreaOutputDef (功能码 + 字节宽度) / AreaOutputDef (function code + byte width) + /// + /// + /// /// protected Dictionary ReadFunctionCodeDictionary; /// - /// 写功能码 + /// 写功能码字典 / Write Function Code Dictionary + /// + /// 存储各区域的写功能码和字节宽度，区分单写和多写 + /// Stores write function codes and byte widths for each area, distinguishing single and multi-write + /// + /// 数据结构 / Data Structure: + /// + /// Key: (区域字符串，是否单写) / (Area string, is single write) + /// Value: AreaOutputDef (功能码 + 字节宽度) / AreaOutputDef (function code + byte width) + /// + /// + /// /// protected Dictionary<(string, bool), AreaOutputDef> WriteFunctionCodeDictionary; /// - /// 构造器 + /// 构造函数 / Constructor + /// + /// 初始化读/写功能码字典 + /// Initialize read/write function code dictionaries + /// /// public AddressTranslatorModbus() { + // 初始化读功能码字典 / Initialize read function code dictionary ReadFunctionCodeDictionary = new Dictionary { { - "0X", + "0X", // 线圈 / Coil new AreaOutputDef { - Code = (int) ModbusProtocolFunctionCode.ReadCoilStatus, - AreaWidth = 0.125 + Code = (int)ModbusProtocolFunctionCode.ReadCoilStatus, // 功能码 01 + AreaWidth = 0.125 // 1 位 = 0.125 字节 } }, { - "1X", + "1X", // 离散输入 / Discrete Input new AreaOutputDef { - Code = (int) ModbusProtocolFunctionCode.ReadInputStatus, - AreaWidth = 0.125 + Code = (int)ModbusProtocolFunctionCode.ReadInputStatus, // 功能码 02 + AreaWidth = 0.125 // 1 位 = 0.125 字节 } }, { - "3X", - new AreaOutputDef {Code = (int) ModbusProtocolFunctionCode.ReadInputRegister, AreaWidth = 2} + "3X", // 输入寄存器 / Input Register + new AreaOutputDef + { + Code = (int)ModbusProtocolFunctionCode.ReadInputRegister, // 功能码 04 + AreaWidth = 2 // 16 位 = 2 字节 + } }, { - "4X", - new AreaOutputDef {Code = (int) ModbusProtocolFunctionCode.ReadHoldRegister, AreaWidth = 2} + "4X", // 保持寄存器 / Holding Register + new AreaOutputDef + { + Code = (int)ModbusProtocolFunctionCode.ReadHoldRegister, // 功能码 03 + AreaWidth = 2 // 16 位 = 2 字节 + } } }; + + // 初始化写功能码字典 / Initialize write function code dictionary WriteFunctionCodeDictionary = new Dictionary<(string, bool), AreaOutputDef> { { - ("0X", false), + ("0X", false), // 多写线圈 / Multi-write Coil new AreaOutputDef { - Code = (int) ModbusProtocolFunctionCode.WriteMultiCoil, + Code = (int)ModbusProtocolFunctionCode.WriteMultiCoil, // 功能码 15 AreaWidth = 0.125 } }, { - ("4X", false), + ("4X", false), // 多写寄存器 / Multi-write Register new AreaOutputDef { - Code = (int) ModbusProtocolFunctionCode.WriteMultiRegister, + Code = (int)ModbusProtocolFunctionCode.WriteMultiRegister, // 功能码 16 AreaWidth = 2 } }, { - ("0X", true), + ("0X", true), // 单写线圈 / Single-write Coil new AreaOutputDef { - Code = (int) ModbusProtocolFunctionCode.WriteSingleCoil, + Code = (int)ModbusProtocolFunctionCode.WriteSingleCoil, // 功能码 05 AreaWidth = 0.125 } }, { - ("4X", true), + ("4X", true), // 单写寄存器 / Single-write Register new AreaOutputDef { - Code = (int) ModbusProtocolFunctionCode.WriteSingleRegister, + Code = (int)ModbusProtocolFunctionCode.WriteSingleRegister, // 功能码 06 AreaWidth = 2 } } @@ -113,35 +280,98 @@ namespace Modbus.Net.Modbus } /// - /// 地址转换 + /// 地址转换 / Address Translate + /// + /// 将格式化的地址字符串翻译为 AddressDef 对象 + /// Translate formatted address string to AddressDef object + /// + /// 处理流程 / Processing Flow: + /// + /// 将地址转为大写 / Convert address to uppercase + /// 按空格分割地址字符串 / Split address string by space + /// 提取区域 (head) 和地址 (tail) / Extract area (head) and address (tail) + /// 处理子地址 (如果有"."分隔) / Handle sub-address (if "." separator exists) + /// 根据读/写选择功能码字典 / Select function code dictionary based on read/write + /// 创建并返回 AddressDef / Create and return AddressDef + /// + /// + /// + /// 地址转换规则 / Address Translation Rules: + /// + /// Modbus 地址从 1 开始，内部地址从 0 开始 / Modbus addresses start from 1, internal addresses start from 0 + /// 例如："4X 1" → Address=0, "4X 100" → Address=99 + /// + /// + /// /// - /// 格式化的地址 - /// 是否为读取，是为读取，否为写入 - /// 是否只写入一个数据 - /// 翻译后的地址 + /// + /// 格式化的地址 / Formatted Address + /// + /// 示例 / Examples: + /// + /// "4X 1" - 保持寄存器第 1 个 + /// "0X 10" - 线圈第 10 个 + /// "4X 5.3" - 保持寄存器第 5 个的第 3 位 + /// + /// + /// + /// + /// 是否为读取 / Whether it's Read + /// + /// true: 读取操作 / Read operation + /// false: 写入操作 / Write operation + /// + /// + /// + /// 是否只写入一个数据 / Whether Writing Single Data + /// + /// true: 单个写入 / Single write + /// false: 多个写入 / Multi write + /// + /// + /// + /// 翻译后的地址 / Translated Address + /// + /// AddressDef 包含： + /// AddressDef contains: + /// + /// AreaString: 区域字符串 (如 "4X") / Area string + /// Area: 功能码 / Function code + /// Address: 内部地址 (从 0 开始) / Internal address (starts from 0) + /// SubAddress: 子地址 (位偏移) / Sub-address (bit offset) + /// + /// + /// public override AddressDef AddressTranslate(string address, bool isRead, bool isSingle) { + // 转为大写 / Convert to uppercase address = address.ToUpper(); + + // 按空格分割 / Split by space var splitString = address.Split(' '); - var head = splitString[0]; - var tail = splitString[1]; + var head = splitString[0]; // 区域 / Area (e.g., "4X") + var tail = splitString[1]; // 地址 / Address (e.g., "1" or "5.3") + + // 处理子地址 / Handle sub-address string sub; if (tail.Contains(".")) { var splitString2 = tail.Split('.'); - sub = splitString2[1]; - tail = splitString2[0]; + sub = splitString2[1]; // 子地址 / Sub-address + tail = splitString2[0]; // 主地址 / Main address } else { - sub = "0"; + sub = "0"; // 默认子地址为 0 / Default sub-address is 0 } + + // 根据读/写选择功能码 / Select function code based on read/write return isRead ? new AddressDef { AreaString = head, Area = ReadFunctionCodeDictionary[head].Code, - Address = int.Parse(tail) - 1, + Address = int.Parse(tail) - 1, // Modbus 地址从 1 开始，内部从 0 开始 SubAddress = int.Parse(sub) } : new AddressDef @@ -154,13 +384,49 @@ namespace Modbus.Net.Modbus } /// - /// 获取区域中的单个地址占用的字节长度 + /// 获取区域中的单个地址占用的字节长度 / Get Byte Length per Address in Area + /// + /// 从读功能码字典中获取区域的字节宽度 + /// Get byte width of area from read function code dictionary + /// + /// 返回值说明 / Return Value Description: + /// + /// 0X/1X (线圈/离散输入): 0.125 字节 (1 位) / Coils/Discrete Inputs: 0.125 bytes (1 bit) + /// 3X/4X (寄存器): 2 字节 (16 位) / Registers: 2 bytes (16 bits) + /// + /// + /// + /// 使用场景 / Use Cases: + /// + /// 地址组合器计算地址跨度 / Address combiner calculates address span + /// 计算需要读取的字节数 / Calculate number of bytes to read + /// 优化数据打包 / Optimize data packing + /// + /// + /// /// - /// 区域名称 - /// 字节长度 + /// + /// 区域名称 / Area Name + /// + /// 示例 / Examples: + /// + /// "0X" - 线圈 / Coil + /// "4X" - 保持寄存器 / Holding Register + /// + /// + /// + /// + /// 字节长度 / Byte Length + /// + /// + /// 0X/1X: 0.125 字节 + /// 3X/4X: 2 字节 + /// + /// + /// public override double GetAreaByteLength(string area) { return ReadFunctionCodeDictionary[area].AreaWidth; } } -} \ No newline at end of file +} diff --git a/Modbus.Net/Modbus.Net.Modbus/Interfaces.cs b/Modbus.Net/Modbus.Net.Modbus/Interfaces.cs index 1ef750d..1308bff 100644 --- a/Modbus.Net/Modbus.Net.Modbus/Interfaces.cs +++ b/Modbus.Net/Modbus.Net.Modbus/Interfaces.cs @@ -1,219 +1,649 @@ -using System.Threading.Tasks; +using System.Threading.Tasks; namespace Modbus.Net.Modbus { /// - /// 异常状态获取方法 + /// Modbus 高级功能接口定义 / Modbus Advanced Function Interface Definitions + /// + /// 定义 Modbus 协议的高级功能接口，包括诊断、事件日志、文件记录等 + /// Defines advanced function interfaces for Modbus protocol, including diagnostics, event log, file record, etc. + /// + /// 主要接口 / Main Interfaces: + /// + /// IUtilityMethodExceptionStatus - 异常状态获取 / Exception status get + /// IUtilityMethodDiagnotics - 诊断功能 / Diagnostics + /// IUtilityMethodCommEventCounter - 通讯事件计数器 / Comm event counter + /// IUtilityMethodCommEventLog - 通讯事件日志 / Comm event log + /// IUtilityMethodSlaveId - 从站 ID 获取 / Slave ID get + /// IUtilityMethodFileRecord - 文件记录读写 / File record read/write + /// IUtilityMethodMaskRegister - 掩码写寄存器 / Mask write register + /// IUtilityMethodMultipleRegister - 读写多寄存器 / Read/write multiple registers + /// IUtilityMethodFIFOQueue - FIFO 队列读 / FIFO queue read + /// + /// + /// + /// 使用场景 / Use Cases: + /// + /// 设备诊断和维护 / Device diagnostics and maintenance + /// 通讯状态监控 / Communication status monitoring + /// 高级数据操作 / Advanced data manipulation + /// + /// + /// + /// + + #region 异常状态获取 / Exception Status Get + + /// + /// 异常状态获取方法接口 / Exception Status Get Method Interface + /// + /// 实现 Modbus 功能码 07 (Read Exception Status) + /// Implements Modbus function code 07 (Read Exception Status) + /// + /// 使用场景 / Use Cases: + /// + /// 检查从站设备异常状态 / Check slave device exception status + /// 仅用于串行通信 (RTU/ASCII) / Serial communication only (RTU/ASCII) + /// + /// + /// /// public interface IUtilityMethodExceptionStatus { /// - /// 获取异常状态 + /// 获取异常状态 / Get Exception Status + /// + /// 读取从站设备的异常状态字节 + /// Read exception status byte from slave device + /// + /// 异常状态字节含义 / Exception Status Byte Meaning: + /// + /// Bit 0: 无效数据 / Invalid data + /// Bit 1: 从站配置更改 / Slave configuration change + /// Bit 2: 功能码不支持 / Function code not supported + /// Bit 3: 从站故障 / Slave failure + /// Bit 4-7: 保留 / Reserved + /// + /// + /// /// - /// + /// + /// 异常状态字节 / Exception Status Byte + /// + /// ReturnStruct<byte> 包含： + /// ReturnStruct<byte> contains: + /// + /// Datas: 异常状态字节 / Exception status byte + /// IsSuccess: 读取是否成功 / Read success flag + /// ErrorCode: 错误码 / Error code + /// ErrorMsg: 错误消息 / Error message + /// + /// + /// Task> GetExceptionStatusAsync(); } + #endregion + + #region 诊断数据 / Diagnostics Data + /// - /// 诊断返回数据 + /// 诊断返回数据类 / Diagnostics Return Data Class + /// + /// 存储 Modbus 诊断功能的返回数据 + /// Stores return data for Modbus diagnostics functionality + /// /// public class DiagnoticsData { /// - /// 子方法编号 + /// 子方法编号 / Sub-function Number + /// + /// 诊断功能的子功能码 + /// Sub-function code for diagnostics + /// + /// 常见子功能 / Common Sub-functions: + /// + /// 0000: 查询从站 / Query slave + /// 0001: 重启通信 / Restart communications + /// 0002: 返回诊断寄存器 / Return diagnostic register + /// + /// + /// /// public ushort SubFunction { get; set; } /// - /// 诊断数据 + /// 诊断数据 / Diagnostics Data + /// + /// 诊断功能返回的数据数组 + /// Data array returned by diagnostics function + /// /// public ushort[] Data { get; set; } } /// - /// 诊断获取方法 + /// 诊断获取方法接口 / Diagnostics Get Method Interface + /// + /// 实现 Modbus 功能码 08 (Diagnostics) + /// Implements Modbus function code 08 (Diagnostics) + /// + /// 使用场景 / Use Cases: + /// + /// 设备诊断和测试 / Device diagnostics and testing + /// 仅用于串行通信 (RTU/ASCII) / Serial communication only (RTU/ASCII) + /// + /// + /// /// public interface IUtilityMethodDiagnotics { /// - /// 获取诊断信息 + /// 获取诊断信息 / Get Diagnostics Information + /// + /// 执行 Modbus 诊断功能 + /// Execute Modbus diagnostics function + /// /// - /// 子方法编号 - /// 诊断数据 - /// + /// + /// 子方法编号 / Sub-function Number + /// + /// 诊断功能的子功能码 + /// Sub-function code for diagnostics + /// + /// + /// + /// 诊断数据 / Diagnostics Data + /// + /// 传递给诊断功能的数据 + /// Data passed to diagnostics function + /// + /// + /// + /// 诊断数据 / Diagnostics Data + /// + /// ReturnStruct<DiagnoticsData> 包含诊断结果 + /// ReturnStruct<DiagnoticsData> contains diagnostics result + /// + /// Task> GetDiagnoticsAsync(ushort subFunction, ushort[] data); } + #endregion + + #region 通讯事件计数器 / Comm Event Counter + /// - /// 通讯事件计数器获取数据 + /// 通讯事件计数器数据类 / Comm Event Counter Data Class + /// + /// 存储 Modbus 通讯事件计数器的数据 + /// Stores data for Modbus comm event counter + /// /// public class CommEventCounterData { /// - /// 通讯状态 + /// 通讯状态 / Communication Status + /// + /// 从站设备的通讯状态字 + /// Communication status word of slave device + /// /// public ushort Status { get; set; } /// - /// 事件计数 + /// 事件计数 / Event Count + /// + /// 通讯事件的数量 + /// Number of communication events + /// /// public ushort EventCount { get; set; } } /// - /// 通讯事件计数器获取方法 + /// 通讯事件计数器获取方法接口 / Comm Event Counter Get Method Interface + /// + /// 实现 Modbus 功能码 11 (Get Comm Event Counter) + /// Implements Modbus function code 11 (Get Comm Event Counter) + /// + /// 使用场景 / Use Cases: + /// + /// 监控通讯事件数量 / Monitor communication event count + /// 仅用于串行通信 (RTU/ASCII) / Serial communication only (RTU/ASCII) + /// + /// + /// /// public interface IUtilityMethodCommEventCounter { /// - /// 获取通讯事件计数器 + /// 获取通讯事件计数器 / Get Comm Event Counter + /// + /// 读取从站设备的通讯事件计数器 + /// Read comm event counter from slave device + /// /// - /// + /// + /// 通讯事件计数器数据 / Comm Event Counter Data + /// + /// ReturnStruct<CommEventCounterData> 包含计数结果 + /// ReturnStruct<CommEventCounterData> contains counter result + /// + /// Task> GetCommEventCounterAsync(); } + #endregion + + #region 通讯事件日志 / Comm Event Log + /// - /// 通讯事件获取数据 + /// 通讯事件数据类 / Comm Event Data Class + /// + /// 存储 Modbus 通讯事件日志的数据 + /// Stores data for Modbus comm event log + /// /// public class CommEventLogData { /// - /// 状态 + /// 状态 / Status + /// + /// 从站设备的状态字 + /// Status word of slave device + /// /// public ushort Status { get; set; } /// - /// 事件内容 + /// 事件内容 / Event Content + /// + /// 通讯事件的详细字节数据 + /// Detailed byte data of communication events + /// /// public byte[] Events { get; set; } } /// - /// 通讯事件获取方法 + /// 通讯事件获取方法接口 / Comm Event Get Method Interface + /// + /// 实现 Modbus 功能码 12 (Get Comm Event Log) + /// Implements Modbus function code 12 (Get Comm Event Log) + /// + /// 使用场景 / Use Cases: + /// + /// 查看通讯事件历史记录 / View communication event history + /// 故障诊断 / Troubleshooting + /// 仅用于串行通信 (RTU/ASCII) / Serial communication only (RTU/ASCII) + /// + /// + /// /// public interface IUtilityMethodCommEventLog { /// - /// 获取通讯事件 + /// 获取通讯事件 / Get Comm Event + /// + /// 读取从站设备的通讯事件日志 + /// Read comm event log from slave device + /// /// - /// + /// + /// 通讯事件数据 / Comm Event Data + /// + /// ReturnStruct<CommEventLogData> 包含事件日志 + /// ReturnStruct<CommEventLogData> contains event log + /// + /// Task> GetCommEventLogAsync(); } + #endregion + + #region 从站 ID 获取 / Slave ID Get + /// - /// 获取从站号数据 + /// 从站 ID 数据类 / Slave ID Data Class + /// + /// 存储 Modbus 从站 ID 获取功能的返回数据 + /// Stores return data for Modbus slave ID get functionality + /// /// public class SlaveIdData { /// - /// 从站号 + /// 从站号 / Slave ID + /// + /// 从站设备的唯一标识 + /// Unique identifier of slave device + /// /// public byte SlaveId { get; set; } /// - /// 指示状态 + /// 指示状态 / Indicator Status + /// + /// 从站设备的运行状态指示 + /// Run status indicator of slave device + /// /// public byte IndicatorStatus { get; set; } /// - /// 附加信息 + /// 附加信息 / Additional Data + /// + /// 从站设备的附加信息字节 + /// Additional data bytes from slave device + /// /// public byte[] AdditionalData { get; set; } } /// - /// 获取从站号方法 + /// 从站 ID 获取方法接口 / Slave ID Get Method Interface + /// + /// 实现 Modbus 功能码 17 (Report Slave ID) + /// Implements Modbus function code 17 (Report Slave ID) + /// + /// 使用场景 / Use Cases: + /// + /// 识别从站设备 / Identify slave device + /// 获取设备信息 / Get device information + /// 仅用于串行通信 (RTU/ASCII) / Serial communication only (RTU/ASCII) + /// + /// + /// /// public interface IUtilityMethodSlaveId { /// - /// 获取从站号 + /// 获取从站号 / Get Slave ID + /// + /// 读取从站设备的 ID 和附加信息 + /// Read slave ID and additional information + /// /// - /// + /// + /// 从站 ID 数据 / Slave ID Data + /// + /// ReturnStruct<SlaveIdData> 包含从站信息 + /// ReturnStruct<SlaveIdData> contains slave information + /// + /// Task> GetSlaveIdAsync(); } + #endregion + + #region 文件记录读写 / File Record Read/Write + /// - /// 文件记录读写方法 + /// 文件记录读写方法接口 / File Record Read/Write Method Interface + /// + /// 实现 Modbus 功能码 20/21 (Read/Write File Record) + /// Implements Modbus function code 20/21 (Read/Write File Record) + /// + /// 使用场景 / Use Cases: + /// + /// 读取从站文件记录 / Read slave file records + /// 写入从站文件记录 / Write slave file records + /// 参数备份和恢复 / Parameter backup and restore + /// + /// + /// /// public interface IUtilityMethodFileRecord { /// - /// 读文件记录 + /// 读文件记录 / Read File Record + /// + /// 从从站设备读取文件记录 + /// Read file records from slave device + /// /// - /// 读文件记录定义 - /// + /// + /// 读文件记录定义 / Read File Record Definitions + /// + /// 指定要读取的文件记录 + /// Specifies file records to read + /// + /// + /// + /// 文件记录输出定义数组 / File Record Output Definition Array + /// Task> GetFileRecordAsync(ReadFileRecordInputDef[] recordDefs); + /// - /// 写文件记录 + /// 写文件记录 / Write File Record + /// + /// 向从站设备写入文件记录 + /// Write file records to slave device + /// /// - /// 写文件记录定义 - /// + /// + /// 写文件记录定义 / Write File Record Definitions + /// + /// 指定要写入的文件记录 + /// Specifies file records to write + /// + /// + /// + /// 文件记录输出定义数组 / File Record Output Definition Array + /// Task> SetFileRecordAsync(WriteFileRecordInputDef[] recordDefs); } + #endregion + + #region 掩码写寄存器 / Mask Write Register + /// - /// 掩码写入数据 + /// 掩码写寄存器数据类 / Mask Write Register Data Class + /// + /// 存储 Modbus 掩码写寄存器功能的数据 + /// Stores data for Modbus mask write register functionality + /// /// public class MaskRegisterData { /// - /// 地址索引 + /// 地址索引 / Reference Address + /// + /// 要写入的寄存器地址 + /// Register address to write + /// /// public ushort ReferenceAddress { get; set; } /// - /// 与掩码 + /// 与掩码 / AND Mask + /// + /// 与操作掩码 + /// AND operation mask + /// /// public ushort AndMask { get; set; } /// - /// 或掩码 + /// 或掩码 / OR Mask + /// + /// 或操作掩码 + /// OR operation mask + /// /// public ushort OrMask { get; set; } } /// - /// 掩码写入方法 + /// 掩码写寄存器方法接口 / Mask Write Register Method Interface + /// + /// 实现 Modbus 功能码 22 (Mask Write Register) + /// Implements Modbus function code 22 (Mask Write Register) + /// + /// 操作公式 / Operation Formula: + /// New Value = (Current Value AND AndMask) OR (OrMask AND (NOT AndMask)) + /// + /// + /// 使用场景 / Use Cases: + /// + /// 修改寄存器的特定位 / Modify specific bits of register + /// 无需读取 - 修改 - 写入操作 / No need for read-modify-write operation + /// + /// + /// /// public interface IUtilityMethodMaskRegister { /// - /// 写入掩码 + /// 写入掩码 / Write Mask + /// + /// 使用掩码写入寄存器 + /// Write to register using mask + /// /// - /// 地址索引 - /// 与掩码 - /// 或掩码 - /// + /// + /// 地址索引 / Reference Address + /// + /// 要写入的寄存器地址 + /// Register address to write + /// + /// + /// + /// 与掩码 / AND Mask + /// + /// 与操作掩码 + /// AND operation mask + /// + /// + /// + /// 或掩码 / OR Mask + /// + /// 或操作掩码 + /// OR operation mask + /// + /// + /// + /// 掩码寄存器数据 / Mask Register Data + /// + /// ReturnStruct<MaskRegisterData> 包含写入结果 + /// ReturnStruct<MaskRegisterData> contains write result + /// + /// Task> SetMaskRegister(ushort referenceAddress, ushort andMask, ushort orMask); } + #endregion + + #region 读写多寄存器 / Read/Write Multiple Registers + /// - /// 寄存器读写方法 + /// 寄存器读写方法接口 / Register Read/Write Method Interface + /// + /// 实现 Modbus 功能码 23 (Read/Write Multiple Registers) + /// Implements Modbus function code 23 (Read/Write Multiple Registers) + /// + /// 使用场景 / Use Cases: + /// + /// 原子操作：先读后写 / Atomic operation: read then write + /// 减少通讯次数 / Reduce communication times + /// 确保数据一致性 / Ensure data consistency + /// + /// + /// /// public interface IUtilityMethodMultipleRegister { /// - /// 读写多寄存器 + /// 读写多寄存器 / Read/Write Multiple Registers + /// + /// 同时执行读取和写入操作 + /// Execute read and write operations simultaneously + /// /// - /// 读起始地址 - /// 读数量 - /// 写寄存器地址 - /// 写数据 - /// + /// + /// 读起始地址 / Read Starting Address + /// + /// 开始读取的寄存器地址 + /// Starting register address for read + /// + /// + /// + /// 读数量 / Quantity to Read + /// + /// 要读取的寄存器数量 + /// Number of registers to read + /// + /// + /// + /// 写起始地址 / Write Starting Address + /// + /// 开始写入的寄存器地址 + /// Starting register address for write + /// + /// + /// + /// 写值数组 / Write Values Array + /// + /// 要写入的寄存器值数组 + /// Array of register values to write + /// + /// + /// + /// 读取的寄存器值数组 / Read Register Values Array + /// + /// ReturnStruct<ushort[]> 包含读取结果 + /// ReturnStruct<ushort[]> contains read result + /// + /// Task> GetMultipleRegister(ushort readStartingAddress, ushort quantityToRead, ushort writeStartingAddress, ushort[] writeValues); } + #endregion + + #region FIFO 队列读 / FIFO Queue Read + /// - /// FIFO队列读取方法 + /// FIFO 队列读方法接口 / FIFO Queue Read Method Interface + /// + /// 实现 Modbus 功能码 24 (Read FIFO Queue) + /// Implements Modbus function code 24 (Read FIFO Queue) + /// + /// 使用场景 / Use Cases: + /// + /// 读取 FIFO 队列数据 / Read FIFO queue data + /// 事件缓冲区读取 / Event buffer read + /// + /// + /// /// public interface IUtilityMethodFIFOQueue { /// - /// 读FIFO队列 + /// 读 FIFO 队列 / Read FIFO Queue + /// + /// 从从站设备读取 FIFO 队列数据 + /// Read FIFO queue data from slave device + /// /// - /// FIFO队列地址 - /// + /// + /// FIFO 指针地址 / FIFO Pointer Address + /// + /// FIFO 队列的指针地址 + /// Pointer address of FIFO queue + /// + /// + /// + /// FIFO 值寄存器数组 / FIFO Value Register Array + /// + /// ReturnStruct<ushort[]> 包含 FIFO 数据 + /// ReturnStruct<ushort[]> contains FIFO data + /// + /// Task> GetFIFOQueue(ushort fifoPointerAddress); } + + #endregion } diff --git a/Modbus.Net/Modbus.Net.Modbus/ModbusAsciiInTcpProtocol.cs b/Modbus.Net/Modbus.Net.Modbus/ModbusAsciiInTcpProtocol.cs index 98c70c2..d53990f 100644 --- a/Modbus.Net/Modbus.Net.Modbus/ModbusAsciiInTcpProtocol.cs +++ b/Modbus.Net/Modbus.Net.Modbus/ModbusAsciiInTcpProtocol.cs @@ -1,26 +1,91 @@ -namespace Modbus.Net.Modbus +namespace Modbus.Net.Modbus { /// - /// Modbus/Ascii码协议Tcp透传 + /// Modbus ASCII over TCP 协议类 / Modbus ASCII over TCP Protocol Class + /// + /// 实现 Modbus ASCII 协议通过 TCP 透传的功能，用于串口服务器场景 + /// Implements Modbus ASCII protocol over TCP tunneling, used for serial device server scenarios + /// + /// 使用场景 / Use Cases: + /// + /// 串口服务器 / Serial device server + /// 通过 TCP 网络传输 ASCII 帧 / Transmit ASCII frames over TCP network + /// 远程串口访问 / Remote serial access + /// 多个 ASCII 设备共享一个 TCP 连接 / Multiple ASCII devices sharing one TCP connection + /// + /// + /// + /// 与 Modbus ASCII 的区别 / Difference from Modbus ASCII: + /// + /// ASCII over TCP - ASCII 帧原样传输，通过 TCP / ASCII frames as-is, over TCP + /// Modbus ASCII - 直接串口传输 ASCII 帧 / Direct serial transmission of ASCII frames + /// + /// + /// + /// 帧格式 / Frame Format: + /// + /// : [从站地址][功能码][数据][LRC][CR][LF] + /// │ │ │ │ │ │ + /// │ │ │ │ │ └─ 换行符 (0x0A) + /// │ │ │ │ └─ 回车符 (0x0D) + /// │ │ │ └─ LRC 校验 (2 字符十六进制) + /// │ │ └─ 数据 (十六进制 ASCII 字符) + /// │ └─ 功能码 (2 字符十六进制) + /// └─ 起始符 (冒号 0x3A) + /// (通过 TCP 原样传输) + /// (Transmitted as-is over TCP) + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // 通过串口服务器连接 ASCII 设备 / Connect ASCII device via serial server + /// var protocol = new ModbusAsciiInTcpProtocol( + /// "192.168.1.200", // 串口服务器 IP / Serial server IP + /// 8899, // 串口服务器端口 / Serial server port + /// slaveAddress: 1, + /// masterAddress: 0 + /// ); + /// + /// // 连接设备 / Connect to device + /// await protocol.ConnectAsync(); + /// + /// // 读取数据 (ASCII 帧通过 TCP 透传) / Read data (ASCII frames tunneled over TCP) + /// var inputStruct = new ReadDataModbusInputStruct(1, "4X 1", 10, addressTranslator, 0); + /// var outputStruct = await protocol.SendReceiveAsync<ReadDataModbusOutputStruct>( + /// protocol[typeof(ReadDataModbusProtocol)], + /// inputStruct + /// ); + /// + /// + /// /// public class ModbusAsciiInTcpProtocol : ModbusProtocol { /// - /// 构造函数 + /// 构造函数 (从配置读取 IP) / Constructor (Read IP from Configuration) + /// + /// 从配置文件读取 IP 地址创建 Modbus ASCII over TCP 协议实例 + /// Create Modbus ASCII over TCP protocol instance with IP address read from configuration file + /// /// - /// 从站号 - /// 主站号 + /// 从站号 / Slave Address + /// 主站号 / Master Address public ModbusAsciiInTcpProtocol(byte slaveAddress, byte masterAddress) : this(ConfigurationReader.GetValueDirect("TCP:Modbus", "IP"), slaveAddress, masterAddress) { } /// - /// 构造函数 + /// 构造函数 (指定 IP) / Constructor (Specify IP) + /// + /// 使用指定的 IP 地址创建 Modbus ASCII over TCP 协议实例 + /// Create Modbus ASCII over TCP protocol instance with specified IP address + /// /// - /// ip地址 - /// 从站号 - /// 主站号 + /// IP 地址 / IP Address (串口服务器地址 / Serial server address) + /// 从站号 / Slave Address + /// 主站号 / Master Address public ModbusAsciiInTcpProtocol(string ip, byte slaveAddress, byte masterAddress) : base(slaveAddress, masterAddress) { @@ -28,16 +93,20 @@ } /// - /// 构造函数 + /// 构造函数 (指定 IP 和端口) / Constructor (Specify IP and Port) + /// + /// 使用指定的 IP 地址和端口创建 Modbus ASCII over TCP 协议实例 + /// Create Modbus ASCII over TCP protocol instance with specified IP address and port + /// /// - /// ip地址 - /// 端口 - /// 从站号 - /// 主站号 + /// IP 地址 / IP Address + /// 端口号 / Port Number (串口服务器端口 / Serial server port) + /// 从站号 / Slave Address + /// 主站号 / Master Address public ModbusAsciiInTcpProtocol(string ip, int port, byte slaveAddress, byte masterAddress) : base(slaveAddress, masterAddress) { ProtocolLinker = new ModbusAsciiInTcpProtocolLinker(ip, port); } } -} \ No newline at end of file +} diff --git a/Modbus.Net/Modbus.Net.Modbus/ModbusAsciiInTcpProtocolLinker.cs b/Modbus.Net/Modbus.Net.Modbus/ModbusAsciiInTcpProtocolLinker.cs index 2e6cb9f..873981c 100644 --- a/Modbus.Net/Modbus.Net.Modbus/ModbusAsciiInTcpProtocolLinker.cs +++ b/Modbus.Net/Modbus.Net.Modbus/ModbusAsciiInTcpProtocolLinker.cs @@ -1,44 +1,163 @@ -using System.Text; +using System.Text; namespace Modbus.Net.Modbus { /// - /// Modbus/Ascii码协议连接器Tcp透传 + /// Modbus ASCII over TCP 协议连接器 / Modbus ASCII over TCP Protocol Linker + /// + /// 实现 Modbus ASCII 协议通过 TCP 透传的连接器，继承自 TcpProtocolLinker + /// Implements Modbus ASCII protocol over TCP tunneling linker, inherits from TcpProtocolLinker + /// + /// 主要功能 / Main Functions: + /// + /// TCP 连接管理 / TCP connection management + /// ASCII 帧原样传输 / ASCII frame transparent transmission + /// 无 MBAP 头 / No MBAP header + /// 保留 LRC 校验 / LRC checksum preserved + /// 响应校验 / Response validation + /// ASCII 编码转换 / ASCII encoding conversion + /// + /// + /// + /// 使用场景 / Use Cases: + /// + /// 串口服务器 / Serial device server + /// 通过 TCP 网络传输 ASCII 帧 / Transmit ASCII frames over TCP network + /// 远程串口访问 / Remote serial access + /// + /// + /// + /// 帧格式 / Frame Format: + /// + /// : [从站地址][功能码][数据][LRC][CR][LF] + /// │ │ │ │ │ │ + /// │ │ │ │ │ └─ 换行符 (0x0A) + /// │ │ │ │ └─ 回车符 (0x0D) + /// │ │ │ └─ LRC 校验 (2 字符十六进制) + /// │ │ └─ 数据 (十六进制 ASCII 字符) + /// │ └─ 功能码 (2 字符十六进制) + /// └─ 起始符 (冒号 0x3A) + /// (通过 TCP 原样传输) + /// (Transmitted as-is over TCP) + /// + /// + /// /// public class ModbusAsciiInTcpProtocolLinker : TcpProtocolLinker { /// - /// 构造函数 + /// 构造函数 (从配置读取端口) / Constructor (Read Port from Configuration) + /// + /// 从配置文件读取端口创建 Modbus ASCII over TCP 连接器 + /// Create Modbus ASCII over TCP linker with port read from configuration file + /// + /// 配置项 / Configuration Items: + /// + /// TCP:{IP}:ModbusPort - 指定 IP 的端口 / Port for specified IP + /// TCP:Modbus:ModbusPort - 默认 Modbus 端口 / Default Modbus port + /// 默认端口：502 / Default port: 502 + /// + /// + /// /// - /// IP地址 + /// + /// IP 地址 / IP Address + /// + /// 串口服务器的 IP 地址 + /// Serial device server IP address + /// + /// public ModbusAsciiInTcpProtocolLinker(string ip) : base(ip, int.Parse(ConfigurationReader.GetValueDirect("TCP:" + ip, "ModbusPort") ?? ConfigurationReader.GetValueDirect("TCP:Modbus", "ModbusPort"))) { } /// - /// 构造函数 + /// 构造函数 (指定 IP 和端口) / Constructor (Specify IP and Port) + /// + /// 使用指定的 IP 地址和端口创建 Modbus ASCII over TCP 连接器 + /// Create Modbus ASCII over TCP linker with specified IP address and port + /// /// - /// ip地址 - /// 端口号 + /// + /// IP 地址 / IP Address + /// 串口服务器的 IP 地址 / Serial device server IP address + /// + /// + /// 端口号 / Port Number + /// + /// 串口服务器端口，常用 8899, 502 等 + /// Serial server port, commonly 8899, 502, etc. + /// + /// public ModbusAsciiInTcpProtocolLinker(string ip, int port) : base(ip, port) { } /// - /// 校验返回数据是否正确 + /// 校验返回数据是否正确 / Validate Return Data + /// + /// 校验从设备返回的 Modbus ASCII over TCP 响应数据 + /// Validate Modbus ASCII over TCP response data returned from device + /// + /// 校验流程 / Validation Flow: + /// + /// 调用基类校验 (TCP 连接状态) / Call base validation (TCP connection status) + /// 转换为 ASCII 字符串 / Convert to ASCII string + /// 检查功能码 (第 4-5 字符) / Check function code (characters 4-5) + /// 如果功能码>127，表示错误响应 / If function code>127, indicates error response + /// 抛出 ModbusProtocolErrorException / Throw ModbusProtocolErrorException + /// + /// + /// + /// ASCII 格式说明 / ASCII Format Description: + /// + /// 字符 0: 冒号 ':' / Character 0: Colon ':' + /// 字符 1-2: 从站地址 / Characters 1-2: Slave address + /// 字符 3-4: 功能码 / Characters 3-4: Function code + /// 字符 5+: 数据 / Characters 5+: Data + /// + /// + /// /// - /// 返回的数据 - /// 校验是否正确 + /// + /// 返回的数据 / Returned Data + /// + /// ASCII 编码的 Modbus ASCII 响应 + /// ASCII-encoded Modbus ASCII response + /// + /// + /// + /// 校验是否正确 / Whether Validation is Correct + /// + /// + /// true: 数据正确 / Data correct + /// false: 数据错误 / Data error + /// null: 无法判断 / Cannot determine + /// + /// + /// + /// + /// 当功能码>127 时抛出 Modbus 协议错误 + /// Throw Modbus protocol error when function code>127 + /// public override bool? CheckRight(byte[] content) { + // 基类校验 (TCP 连接状态) / Base validation (TCP connection status) if (base.CheckRight(content) != true) return base.CheckRight(content); - //Modbus协议错误 + + // 转换为 ASCII 字符串 / Convert to ASCII string var contentString = Encoding.ASCII.GetString(content); + + // Modbus 协议错误检测 / Modbus protocol error detection + // 功能码在第 4-5 字符 (从 0 开始计数是 3-4) + // Function code at characters 4-5 (0-based index 3-4) if (byte.Parse(contentString.Substring(3, 2)) > 127) + // 功能码>127 表示异常响应 / Function code>127 indicates exception response throw new ModbusProtocolErrorException(byte.Parse(contentString.Substring(5, 2))); + return true; } } -} \ No newline at end of file +} diff --git a/Modbus.Net/Modbus.Net.Modbus/ModbusAsciiInUdpProtocol.cs b/Modbus.Net/Modbus.Net.Modbus/ModbusAsciiInUdpProtocol.cs index d6bc2d2..ff61def 100644 --- a/Modbus.Net/Modbus.Net.Modbus/ModbusAsciiInUdpProtocol.cs +++ b/Modbus.Net/Modbus.Net.Modbus/ModbusAsciiInUdpProtocol.cs @@ -1,26 +1,96 @@ -namespace Modbus.Net.Modbus +namespace Modbus.Net.Modbus { /// - /// Modbus/Ascii码协议Udp透传 + /// Modbus ASCII over UDP 协议类 / Modbus ASCII over UDP Protocol Class + /// + /// 实现 Modbus ASCII 协议通过 UDP 透传的功能，用于无连接的网络通信 + /// Implements Modbus ASCII protocol over UDP tunneling, used for connectionless network communication + /// + /// 使用场景 / Use Cases: + /// + /// UDP 广播查询 / UDP broadcast query + /// 通过 UDP 网络传输 ASCII 帧 / Transmit ASCII frames over UDP network + /// 多个 ASCII 设备共享一个 UDP 端口 / Multiple ASCII devices sharing one UDP port + /// 不要求可靠性的场景 / Scenarios not requiring reliability + /// + /// + /// + /// 与 Modbus ASCII over TCP 的区别 / Difference from Modbus ASCII over TCP: + /// + /// ASCII over UDP - 无连接，不保证送达，支持广播 / Connectionless, no delivery guarantee, supports broadcast + /// ASCII over TCP - 面向连接，保证送达，不支持广播 / Connection-oriented, delivery guaranteed, no broadcast + /// + /// + /// + /// 帧格式 / Frame Format: + /// + /// : [从站地址][功能码][数据][LRC][CR][LF] + /// │ │ │ │ │ │ + /// │ │ │ │ │ └─ 换行符 (0x0A) + /// │ │ │ │ └─ 回车符 (0x0D) + /// │ │ │ └─ LRC 校验 (2 字符十六进制) + /// │ │ └─ 数据 (十六进制 ASCII 字符) + /// │ └─ 功能码 (2 字符十六进制) + /// └─ 起始符 (冒号 0x3A) + /// (通过 UDP 原样传输) + /// (Transmitted as-is over UDP) + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // 通过 UDP 连接 ASCII 设备 / Connect ASCII device via UDP + /// var protocol = new ModbusAsciiInUdpProtocol( + /// "192.168.1.200", // 设备 IP / Device IP + /// 502, // UDP 端口 / UDP port + /// slaveAddress: 1, + /// masterAddress: 0 + /// ); + /// + /// // 连接设备 (UDP 无需真正连接) / Connect to device (UDP doesn't need real connection) + /// await protocol.ConnectAsync(); + /// + /// // 读取数据 (ASCII 帧通过 UDP 透传) / Read data (ASCII frames tunneled over UDP) + /// var inputStruct = new ReadDataModbusInputStruct(1, "4X 1", 10, addressTranslator, 0); + /// var outputStruct = await protocol.SendReceiveAsync<ReadDataModbusOutputStruct>( + /// protocol[typeof(ReadDataModbusProtocol)], + /// inputStruct + /// ); + /// + /// // UDP 广播查询示例 / UDP broadcast query example + /// var broadcastProtocol = new ModbusAsciiInUdpProtocol("255.255.255.255", 502, slaveAddress: 0, masterAddress: 0); + /// // 注意：广播地址为 0，所有从站都会响应 + /// // Note: Broadcast address is 0, all slaves will respond + /// + /// + /// /// public class ModbusAsciiInUdpProtocol : ModbusProtocol { /// - /// 构造函数 + /// 构造函数 (从配置读取 IP) / Constructor (Read IP from Configuration) + /// + /// 从配置文件读取 IP 地址创建 Modbus ASCII over UDP 协议实例 + /// Create Modbus ASCII over UDP protocol instance with IP address read from configuration file + /// /// - /// 从站号 - /// 主站号 + /// 从站号 / Slave Address + /// 主站号 / Master Address public ModbusAsciiInUdpProtocol(byte slaveAddress, byte masterAddress) : this(ConfigurationReader.GetValueDirect("UDP:Modbus", "IP"), slaveAddress, masterAddress) { } /// - /// 构造函数 + /// 构造函数 (指定 IP) / Constructor (Specify IP) + /// + /// 使用指定的 IP 地址创建 Modbus ASCII over UDP 协议实例 + /// Create Modbus ASCII over UDP protocol instance with specified IP address + /// /// - /// ip地址 - /// 从站号 - /// 主站号 + /// IP 地址 / IP Address (可使用广播地址 255.255.255.255) + /// 从站号 / Slave Address + /// 主站号 / Master Address public ModbusAsciiInUdpProtocol(string ip, byte slaveAddress, byte masterAddress) : base(slaveAddress, masterAddress) { @@ -28,12 +98,16 @@ } /// - /// 构造函数 + /// 构造函数 (指定 IP 和端口) / Constructor (Specify IP and Port) + /// + /// 使用指定的 IP 地址和端口创建 Modbus ASCII over UDP 协议实例 + /// Create Modbus ASCII over UDP protocol instance with specified IP address and port + /// /// - /// ip地址 - /// 端口 - /// 从站号 - /// 主站号 + /// IP 地址 / IP Address + /// 端口号 / Port Number + /// 从站号 / Slave Address + /// 主站号 / Master Address public ModbusAsciiInUdpProtocol(string ip, int port, byte slaveAddress, byte masterAddress) : base(slaveAddress, masterAddress) { diff --git a/Modbus.Net/Modbus.Net.Modbus/ModbusAsciiInUdpProtocolLinker.cs b/Modbus.Net/Modbus.Net.Modbus/ModbusAsciiInUdpProtocolLinker.cs index dc3efaf..16a2fe6 100644 --- a/Modbus.Net/Modbus.Net.Modbus/ModbusAsciiInUdpProtocolLinker.cs +++ b/Modbus.Net/Modbus.Net.Modbus/ModbusAsciiInUdpProtocolLinker.cs @@ -1,43 +1,171 @@ -using System.Text; +using System.Text; namespace Modbus.Net.Modbus { /// - /// Modbus/Ascii码协议连接器Udp透传 + /// Modbus ASCII over UDP 协议连接器 / Modbus ASCII over UDP Protocol Linker + /// + /// 实现 Modbus ASCII 协议通过 UDP 透传的连接器，继承自 UdpProtocolLinker + /// Implements Modbus ASCII protocol over UDP tunneling linker, inherits from UdpProtocolLinker + /// + /// 主要功能 / Main Functions: + /// + /// UDP 连接管理 / UDP connection management + /// ASCII 帧原样传输 / ASCII frame transparent transmission + /// 无 MBAP 头 / No MBAP header + /// 保留 LRC 校验 / LRC checksum preserved + /// 支持广播查询 / Supports broadcast query + /// 响应校验 / Response validation + /// ASCII 编码转换 / ASCII encoding conversion + /// + /// + /// + /// 使用场景 / Use Cases: + /// + /// UDP 广播查询 / UDP broadcast query + /// 通过 UDP 网络传输 ASCII 帧 / Transmit ASCII frames over UDP network + /// 多个 ASCII 设备共享一个 UDP 端口 / Multiple ASCII devices sharing one UDP port + /// 不要求可靠性的场景 / Scenarios not requiring reliability + /// + /// + /// + /// 与 ASCII over TCP 的区别 / Difference from ASCII over TCP: + /// + /// ASCII over UDP - 无连接，不保证送达，支持广播 / Connectionless, no delivery guarantee, supports broadcast + /// ASCII over TCP - 面向连接，保证送达，不支持广播 / Connection-oriented, delivery guaranteed, no broadcast + /// + /// + /// + /// 帧格式 / Frame Format: + /// + /// : [从站地址][功能码][数据][LRC][CR][LF] + /// │ │ │ │ │ │ + /// │ │ │ │ │ └─ 换行符 (0x0A) + /// │ │ │ │ └─ 回车符 (0x0D) + /// │ │ │ └─ LRC 校验 (2 字符十六进制) + /// │ │ └─ 数据 (十六进制 ASCII 字符) + /// │ └─ 功能码 (2 字符十六进制) + /// └─ 起始符 (冒号 0x3A) + /// (通过 UDP 原样传输) + /// (Transmitted as-is over UDP) + /// + /// + /// /// public class ModbusAsciiInUdpProtocolLinker : UdpProtocolLinker { /// - /// 构造函数 + /// 构造函数 (从配置读取端口) / Constructor (Read Port from Configuration) + /// + /// 从配置文件读取端口创建 Modbus ASCII over UDP 连接器 + /// Create Modbus ASCII over UDP linker with port read from configuration file + /// + /// 配置项 / Configuration Items: + /// + /// UDP:{IP}:ModbusPort - 指定 IP 的端口 / Port for specified IP + /// UDP:Modbus:ModbusPort - 默认 Modbus 端口 / Default Modbus port + /// 默认端口：502 / Default port: 502 + /// + /// + /// /// - /// IP地址 + /// + /// IP 地址 / IP Address + /// + /// 目标设备的 IP 地址 (可使用广播地址 255.255.255.255) + /// Target device IP address (can use broadcast address 255.255.255.255) + /// + /// public ModbusAsciiInUdpProtocolLinker(string ip) : base(ip, int.Parse(ConfigurationReader.GetValueDirect("UDP:" + ip, "ModbusPort") ?? ConfigurationReader.GetValueDirect("UDP:Modbus", "ModbusPort"))) { } /// - /// 构造函数 + /// 构造函数 (指定 IP 和端口) / Constructor (Specify IP and Port) + /// + /// 使用指定的 IP 地址和端口创建 Modbus ASCII over UDP 连接器 + /// Create Modbus ASCII over UDP linker with specified IP address and port + /// /// - /// ip地址 - /// 端口号 + /// + /// IP 地址 / IP Address + /// 目标设备的 IP 地址 / Target device IP address + /// + /// + /// 端口号 / Port Number + /// + /// UDP 端口，默认 502 + /// UDP port, default 502 + /// + /// public ModbusAsciiInUdpProtocolLinker(string ip, int port) : base(ip, port) { } /// - /// 校验返回数据是否正确 + /// 校验返回数据是否正确 / Validate Return Data + /// + /// 校验从设备返回的 Modbus ASCII over UDP 响应数据 + /// Validate Modbus ASCII over UDP response data returned from device + /// + /// 校验流程 / Validation Flow: + /// + /// 调用基类校验 (UDP 连接状态) / Call base validation (UDP connection status) + /// 转换为 ASCII 字符串 / Convert to ASCII string + /// 检查功能码 (第 4-5 字符) / Check function code (characters 4-5) + /// 如果功能码>127，表示错误响应 / If function code>127, indicates error response + /// 抛出 ModbusProtocolErrorException / Throw ModbusProtocolErrorException + /// + /// + /// + /// ASCII 格式说明 / ASCII Format Description: + /// + /// 字符 0: 冒号 ':' / Character 0: Colon ':' + /// 字符 1-2: 从站地址 / Characters 1-2: Slave address + /// 字符 3-4: 功能码 / Characters 3-4: Function code + /// 字符 5+: 数据 / Characters 5+: Data + /// + /// + /// /// - /// 返回的数据 - /// 校验是否正确 + /// + /// 返回的数据 / Returned Data + /// + /// ASCII 编码的 Modbus ASCII 响应 + /// ASCII-encoded Modbus ASCII response + /// + /// + /// + /// 校验是否正确 / Whether Validation is Correct + /// + /// + /// true: 数据正确 / Data correct + /// false: 数据错误 / Data error + /// null: 无法判断 / Cannot determine + /// + /// + /// + /// + /// 当功能码>127 时抛出 Modbus 协议错误 + /// Throw Modbus protocol error when function code>127 + /// public override bool? CheckRight(byte[] content) { + // 基类校验 (UDP 连接状态) / Base validation (UDP connection status) if (base.CheckRight(content) != true) return base.CheckRight(content); - //Modbus协议错误 + + // 转换为 ASCII 字符串 / Convert to ASCII string var contentString = Encoding.ASCII.GetString(content); + + // Modbus 协议错误检测 / Modbus protocol error detection + // 功能码在第 4-5 字符 (从 0 开始计数是 3-4) + // Function code at characters 4-5 (0-based index 3-4) if (byte.Parse(contentString.Substring(3, 2)) > 127) + // 功能码>127 表示异常响应 / Function code>127 indicates exception response throw new ModbusProtocolErrorException(byte.Parse(contentString.Substring(5, 2))); + return true; } } diff --git a/Modbus.Net/Modbus.Net.Modbus/ModbusAsciiProtocol.cs b/Modbus.Net/Modbus.Net.Modbus/ModbusAsciiProtocol.cs index f3d7df6..771fd2f 100644 --- a/Modbus.Net/Modbus.Net.Modbus/ModbusAsciiProtocol.cs +++ b/Modbus.Net/Modbus.Net.Modbus/ModbusAsciiProtocol.cs @@ -1,30 +1,115 @@ -namespace Modbus.Net.Modbus +namespace Modbus.Net.Modbus { /// - /// Modbus/Ascii码协议 + /// Modbus/ASCII 协议类 / Modbus/ASCII Protocol Class + /// + /// 实现 Modbus ASCII 协议，用于串行通信 + /// Implements Modbus ASCII protocol for serial communication + /// + /// 协议特点 / Protocol Characteristics: + /// + /// ASCII 字符编码 / ASCII character encoding + /// LRC 校验 / LRC checksum + /// 以冒号 (:) 开始，CRLF 结束 / Starts with colon (:), ends with CRLF + /// 效率较低，但易于调试 / Lower efficiency, but easy to debug + /// 适用于低速串口通信 / Suitable for low-speed serial communication + /// + /// + /// + /// 帧格式 / Frame Format: + /// + /// : [从站地址][功能码][数据][LRC][CR][LF] + /// │ │ │ │ │ │ + /// │ │ │ │ │ └─ 换行符 (0x0A) + /// │ │ │ │ └─ 回车符 (0x0D) + /// │ │ │ └─ LRC 校验 (2 字符十六进制) + /// │ │ └─ 数据 (十六进制 ASCII 字符) + /// │ └─ 功能码 (2 字符十六进制) + /// └─ 起始符 (冒号 0x3A) + /// + /// + /// + /// 与 RTU 的区别 / Difference from RTU: + /// + /// ASCII: 人类可读，效率低 / ASCII: Human readable, low efficiency + /// RTU: 二进制编码，效率高 / RTU: Binary encoding, high efficiency + /// ASCII: LRC 校验 / ASCII: LRC checksum + /// RTU: CRC16 校验 / RTU: CRC16 checksum + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // 创建 Modbus ASCII 协议实例 / Create Modbus ASCII protocol instance + /// var protocol = new ModbusAsciiProtocol("COM1", slaveAddress: 1, masterAddress: 0); + /// + /// // 或者从配置读取 / Or read from configuration + /// var protocolFromConfig = new ModbusAsciiProtocol(slaveAddress: 1, masterAddress: 0); + /// // 配置项：COM:Modbus:COM = "COM1" + /// + /// // 连接设备 / Connect to device + /// await protocol.ConnectAsync(); + /// + /// // 发送读取请求 / Send read request + /// var inputStruct = new ReadDataModbusInputStruct(1, "4X 1", 10, addressTranslator, 0); + /// var outputStruct = await protocol.SendReceiveAsync<ReadDataModbusOutputStruct>( + /// protocol[typeof(ReadDataModbusProtocol)], + /// inputStruct + /// ); + /// + /// + /// /// public class ModbusAsciiProtocol : ModbusProtocol { /// - /// 构造函数 + /// 构造函数 (从配置读取串口) / Constructor (Read COM Port from Configuration) + /// + /// 从配置文件读取串口名称创建 Modbus ASCII 协议实例 + /// Create Modbus ASCII protocol instance with COM port name read from configuration file + /// + /// 配置项 / Configuration Item: + /// COM:Modbus:COM = "COM1" + /// + /// /// - /// 从站号 - /// 主站号 + /// + /// 从站号 / Slave Address + /// Modbus 从站地址，范围 1-247 / Modbus slave address, range 1-247 + /// + /// + /// 主站号 / Master Address + /// 通常为 0 或 1 / Usually 0 or 1 + /// public ModbusAsciiProtocol(byte slaveAddress, byte masterAddress) : this(ConfigurationReader.GetValueDirect("COM:Modbus", "COM"), slaveAddress, masterAddress) { } /// - /// 构造函数 + /// 构造函数 (指定串口) / Constructor (Specify COM Port) + /// + /// 使用指定的串口名称创建 Modbus ASCII 协议实例 + /// Create Modbus ASCII protocol instance with specified COM port name + /// + /// 串口配置从 appsettings.json 读取 + /// Serial port configuration is read from appsettings.json + /// + /// /// - /// 串口地址 - /// 从站号 - /// 主站号 + /// + /// 串口地址 / COM Port Address + /// 如 "COM1", "COM2" 等 / e.g., "COM1", "COM2", etc. + /// + /// 从站号 / Slave Address + /// 主站号 / Master Address public ModbusAsciiProtocol(string com, byte slaveAddress, byte masterAddress) : base(slaveAddress, masterAddress) { + // 创建 Modbus ASCII 协议链接器 / Create Modbus ASCII protocol linker + // 自动从配置读取串口参数 (波特率、校验位等) + // Automatically read serial port parameters from configuration (baud rate, parity, etc.) ProtocolLinker = new ModbusAsciiProtocolLinker(com, slaveAddress); } } -} \ No newline at end of file +} diff --git a/Modbus.Net/Modbus.Net.Modbus/ModbusAsciiProtocolLinker.cs b/Modbus.Net/Modbus.Net.Modbus/ModbusAsciiProtocolLinker.cs index f552984..44afc2a 100644 --- a/Modbus.Net/Modbus.Net.Modbus/ModbusAsciiProtocolLinker.cs +++ b/Modbus.Net/Modbus.Net.Modbus/ModbusAsciiProtocolLinker.cs @@ -1,35 +1,145 @@ -using System.Text; +using System.Text; namespace Modbus.Net.Modbus { /// - /// Modbus/Ascii码协议连接器 + /// Modbus/ASCII 协议连接器 / Modbus/ASCII Protocol Linker + /// + /// 实现 Modbus ASCII 协议的连接器，继承自 ComProtocolLinker + /// Implements Modbus ASCII protocol linker, inherits from ComProtocolLinker + /// + /// 主要功能 / Main Functions: + /// + /// 串口连接管理 / Serial connection management + /// LRC 校验 / LRC checksum + /// ASCII 编码转换 / ASCII encoding conversion + /// 响应校验 / Response validation + /// 错误检测 / Error detection + /// + /// + /// + /// ASCII 帧格式 / ASCII Frame Format: + /// + /// : [从站地址][功能码][数据][LRC][CR][LF] + /// │ │ │ │ │ │ + /// │ │ │ │ │ └─ 换行符 (0x0A) + /// │ │ │ │ └─ 回车符 (0x0D) + /// │ │ │ └─ LRC 校验 (2 字符十六进制) + /// │ │ └─ 数据 (十六进制 ASCII 字符) + /// │ └─ 功能码 (2 字符十六进制) + /// └─ 起始符 (冒号 0x3A) + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // 创建 Modbus ASCII 连接器 / Create Modbus ASCII linker + /// var linker = new ModbusAsciiProtocolLinker("COM1", slaveAddress: 1); + /// + /// // 连接设备 / Connect to device + /// await linker.ConnectAsync(); + /// + /// // 发送数据 (ASCII 格式) / Send data (ASCII format) + /// string request = ":01030000000AF8[CR][LF]"; + /// byte[] response = await linker.SendReceiveAsync(Encoding.ASCII.GetBytes(request)); + /// + /// // CheckRight 会自动校验 LRC 和协议错误 + /// // CheckRight will automatically validate LRC and protocol errors + /// + /// + /// /// public class ModbusAsciiProtocolLinker : ComProtocolLinker { /// - /// 构造函数 + /// 构造函数 / Constructor + /// + /// 初始化 Modbus ASCII 协议连接器 + /// Initialize Modbus ASCII protocol linker + /// /// - /// 串口地址 - /// 从站号 + /// + /// 串口地址 / Serial Port Address + /// + /// 如 "COM1", "COM2" 等 + /// e.g., "COM1", "COM2", etc. + /// + /// + /// + /// 从站号 / Slave Address + /// + /// Modbus 从站地址，范围 1-247 + /// Modbus slave address, range 1-247 + /// + /// public ModbusAsciiProtocolLinker(string com, int slaveAddress) : base(com, slaveAddress) { } /// - /// 校验返回数据是否正确 + /// 校验返回数据是否正确 / Validate Return Data + /// + /// 校验从设备返回的 Modbus ASCII 响应数据 + /// Validate Modbus ASCII response data returned from device + /// + /// 校验流程 / Validation Flow: + /// + /// 调用基类校验 (串口连接状态) / Call base validation (serial connection status) + /// 转换为 ASCII 字符串 / Convert to ASCII string + /// 检查功能码 (第 4-5 字符) / Check function code (characters 4-5) + /// 如果功能码>127，表示错误响应 / If function code>127, indicates error response + /// 抛出 ModbusProtocolErrorException / Throw ModbusProtocolErrorException + /// + /// + /// + /// ASCII 格式说明 / ASCII Format Description: + /// + /// 字符 0: 冒号 ':' / Character 0: Colon ':' + /// 字符 1-2: 从站地址 / Characters 1-2: Slave address + /// 字符 3-4: 功能码 / Characters 3-4: Function code + /// 字符 5+: 数据 / Characters 5+: Data + /// + /// + /// /// - /// 返回的数据 - /// 校验是否正确 + /// + /// 返回的数据 / Returned Data + /// + /// ASCII 编码的 Modbus ASCII 响应 + /// ASCII-encoded Modbus ASCII response + /// + /// + /// + /// 校验是否正确 / Whether Validation is Correct + /// + /// + /// true: 数据正确 / Data correct + /// false: 数据错误 / Data error + /// null: 无法判断 / Cannot determine + /// + /// + /// + /// + /// 当功能码>127 时抛出 Modbus 协议错误 + /// Throw Modbus protocol error when function code>127 + /// public override bool? CheckRight(byte[] content) { + // 基类校验 (串口连接状态) / Base validation (serial connection status) if (base.CheckRight(content) != true) return base.CheckRight(content); - //Modbus协议错误 + + // 转换为 ASCII 字符串 / Convert to ASCII string var contentString = Encoding.ASCII.GetString(content); + + // Modbus 协议错误检测 / Modbus protocol error detection + // 功能码在第 4-5 字符 (从 0 开始计数是 3-4) + // Function code at characters 4-5 (0-based index 3-4) if (byte.Parse(contentString.Substring(3, 2)) > 127) + // 功能码>127 表示异常响应 / Function code>127 indicates exception response throw new ModbusProtocolErrorException(byte.Parse(contentString.Substring(5, 2))); + return true; } } -} \ No newline at end of file +} diff --git a/Modbus.Net/Modbus.Net.Modbus/ModbusController.cs b/Modbus.Net/Modbus.Net.Modbus/ModbusController.cs index 32677cd..d712732 100644 --- a/Modbus.Net/Modbus.Net.Modbus/ModbusController.cs +++ b/Modbus.Net/Modbus.Net.Modbus/ModbusController.cs @@ -1,68 +1,199 @@ -using System; +using System; using System.Collections.Generic; using System.Linq; namespace Modbus.Net.Modbus { /// - /// Modbus长度计算 + /// Modbus 长度计算工具类 / Modbus Length Calculation Utility Class + /// + /// 提供 Modbus 协议各种模式的长度计算函数 + /// Provides length calculation functions for various Modbus protocol modes + /// + /// 主要功能 / Main Functions: + /// + /// ModbusAsciiLengthCalc - ASCII 协议长度计算 / ASCII protocol length calculation + /// ModbusRtuResponseLengthCalc - RTU 响应长度计算 / RTU response length calculation + /// ModbusRtuRequestLengthCalc - RTU 请求长度计算 / RTU request length calculation + /// + /// + /// + /// 使用场景 / Use Cases: + /// + /// Controller 的 lengthCalc 参数 / Controller's lengthCalc parameter + /// 数据帧切分 / Data frame splitting + /// TCP 粘包处理 / TCP sticky packet handling + /// + /// + /// /// public static class ModbusLengthCalc { /// - /// Modbus Ascii协议长度计算 + /// Modbus ASCII 协议长度计算 / Modbus ASCII Protocol Length Calculation + /// + /// ASCII 协议以冒号 (0x3A) 开始，以 CRLF (0x0D 0x0A) 结束 + /// ASCII protocol starts with colon (0x3A) and ends with CRLF (0x0D 0x0A) + /// + /// 帧格式 / Frame Format: + /// : [从站地址][功能码][数据][LRC][CR][LF] + /// + /// + /// 计算逻辑 / Calculation Logic: + /// + /// 检查首字节是否为 0x3A (冒号) / Check if first byte is 0x3A (colon) + /// 遍历查找 0x0D 0x0A (CRLF) / Traverse to find 0x0D 0x0A (CRLF) + /// 返回 CRLF 后的位置 / Return position after CRLF + /// 如果未找到，返回 0 / Return 0 if not found + /// + /// + /// /// public static Func ModbusAsciiLengthCalc => content => { + // 检查首字节是否为冒号 / Check if first byte is colon if (content[0] != 0x3a) return 0; + + // 查找 CRLF 结束符 / Find CRLF terminator for (int i = 1; i < content.Length; i++) { if (content[i - 1] == 0x0D && content[i] == 0x0A) return i + 1; } - return -1; + return 0; }; /// - /// Modbus Rtu接收协议长度计算 + /// Modbus RTU 接收协议长度计算 / Modbus RTU Response Protocol Length Calculation + /// + /// 根据功能码计算响应帧长度 + /// Calculate response frame length based on function code + /// + /// 帧格式 / Frame Format: + /// [从站地址][功能码][数据长度/数据][CRC 低][CRC 高] + /// + /// + /// 长度规则 / Length Rules: + /// + /// 异常响应 (功能码>128): 5 字节 / Exception response (function code>128): 5 bytes + /// 写单个线圈/寄存器 (05/06): 8 字节 / Write single coil/register: 8 bytes + /// 诊断/事件计数器 (08/11): 8 字节 / Diagnostics/Event Counter: 8 bytes + /// 读线圈/离散输入 (01/02): 动态长度 / Read coils/discrete inputs: dynamic length + /// 读寄存器 (03/04): 动态长度 / Read registers: dynamic length + /// + /// + /// /// public static Func ModbusRtuResponseLengthCalc => (content) => { - if (content[1] > 128) return 5; + // 异常响应 (功能码最高位为 1) / Exception response (function code MSB is 1) + if (content[1] > 128) return 5; // [从站][功能码][异常码][CRC 低][CRC 高] + + // 固定长度响应 / Fixed length responses else if (content[1] == 5 || content[1] == 6 || content[1] == 8 || content[1] == 11 || content[1] == 15 || content[1] == 16) return 8; - else if (content[1] == 7) return 5; - else if (content[1] == 22) return 10; + else if (content[1] == 7) return 5; // 读异常状态 / Read exception status + else if (content[1] == 22) return 10; // 掩码写寄存器 / Mask write register + + // 动态长度响应 (读操作) / Dynamic length responses (read operations) + // 使用 DuplicateWithCount 计算 / Use DuplicateWithCount to calculate + // 格式：[从站 (1)][功能码 (1)][字节数 (1)][数据 (N)][CRC (2)] + // Format: [Slave (1)][Function (1)][Byte Count (1)][Data (N)][CRC (2)] else return DuplicateWithCount.GetDuplcateFunc(new List { 2 }, 5).Invoke(content); }; /// - /// Modbus Rtu发送协议长度计算 + /// Modbus RTU 发送协议长度计算 / Modbus RTU Request Protocol Length Calculation + /// + /// 根据功能码计算请求帧长度 + /// Calculate request frame length based on function code + /// + /// 帧格式 / Frame Format: + /// [从站地址][功能码][参数...][CRC 低][CRC 高] + /// + /// + /// 长度规则 / Length Rules: + /// + /// 读线圈/寄存器 (01-04): 8 字节 / Read coils/registers: 8 bytes + /// 写单个线圈/寄存器 (05/06): 8 字节 / Write single coil/register: 8 bytes + /// 诊断 (08): 8 字节 / Diagnostics: 8 bytes + /// 读异常状态 (07): 4 字节 / Read exception status: 4 bytes + /// 写多个线圈/寄存器 (15/16): 动态长度 / Write multiple coils/registers: dynamic length + /// + /// + /// /// public static Func ModbusRtuRequestLengthCalc => (content) => { + // 读操作 (01-04) / Read operations (01-04) + // 格式：[从站 (1)][功能码 (1)][起始地址 (2)][数量 (2)][CRC (2)] + // Format: [Slave (1)][Function (1)][Start Addr (2)][Quantity (2)][CRC (2)] if (content[1] == 1 || content[1] == 2 || content[1] == 3 || content[1] == 4 || content[1] == 5 || content[1] == 6 || content[1] == 8) return 8; + + // 简单命令 (07/11/12/17) / Simple commands (07/11/12/17) + // 格式：[从站 (1)][功能码 (1)][CRC (2)] + // Format: [Slave (1)][Function (1)][CRC (2)] else if (content[1] == 7 || content[1] == 11 || content[1] == 12 || content[1] == 17) return 4; + + // 写多个线圈/寄存器 (15/16) / Write multiple coils/registers (15/16) + // 格式：[从站 (1)][功能码 (1)][起始地址 (2)][数量 (2)][字节数 (1)][数据 (N)][CRC (2)] + // Format: [Slave (1)][Function (1)][Start Addr (2)][Quantity (2)][Byte Count (1)][Data (N)][CRC (2)] else if (content[1] == 15 || content[1] == 16) { return DuplicateWithCount.GetDuplcateFunc(new List { 6 }, 9).Invoke(content); } + + // 掩码写寄存器 (22) / Mask write register (22) + // 格式：[从站 (1)][功能码 (1)][地址 (2)][AND 掩码 (2)][OR 掩码 (2)][CRC (2)] + // Format: [Slave (1)][Function (1)][Address (2)][AND Mask (2)][OR Mask (2)][CRC (2)] else if (content[1] == 22) return 10; + + // 读写多个寄存器 (23) / Read/write multiple registers (23) else if (content[1] == 23) return 19; + + // 读 FIFO 队列 (24) / Read FIFO queue (24) else if (content[1] == 24) return 6; + + // 默认：使用字节数计算 / Default: use byte count calculation else return DuplicateWithCount.GetDuplcateFunc(new List { 2 }, 5).Invoke(content); }; } /// - /// Modbus Ascii协议控制器 + /// Modbus ASCII 协议控制器 / Modbus ASCII Protocol Controller + /// + /// 用于 Modbus ASCII 串口通信的 FIFO 控制器 + /// FIFO controller for Modbus ASCII serial communication + /// + /// 特点 / Characteristics: + /// + /// 使用 LRC 校验 / Uses LRC checksum + /// ASCII 编码 / ASCII encoding + /// 以冒号开始，CRLF 结束 / Starts with colon, ends with CRLF + /// + /// + /// /// public class ModbusAsciiController : FifoController { /// - /// 构造函数 + /// 构造函数 / Constructor + /// + /// 从配置读取参数初始化 ASCII 控制器 + /// Initialize ASCII controller with parameters read from configuration + /// /// - /// 串口 - /// 从站号 + /// + /// 串口名称 / Serial Port Name + /// 如 "COM1", "COM2" 等 / e.g., "COM1", "COM2", etc. + /// + /// + /// 从站号 / Slave Address + /// Modbus 从站地址，范围 1-247 / Modbus slave address, range 1-247 + /// public ModbusAsciiController(string com, int slaveAddress) : base( + // 从配置读取获取间隔时间 / Read fetch interval time from configuration int.Parse(ConfigurationReader.GetValue("COM:" + com + ":" + slaveAddress, "FetchSleepTime")), + // ASCII 长度计算函数 / ASCII length calculation function lengthCalc: ModbusLengthCalc.ModbusAsciiLengthCalc, + // LRC 校验函数 / LRC check function checkRightFunc: ContentCheck.LrcCheckRight, + // 从配置读取等待队列长度 / Read waiting list count from configuration waitingListMaxCount: ConfigurationReader.GetValue("COM:" + com + ":" + slaveAddress, "WaitingListCount") != null ? int.Parse(ConfigurationReader.GetValue("COM:" + com + ":" + slaveAddress, "WaitingListCount")) : null @@ -71,18 +202,42 @@ namespace Modbus.Net.Modbus } /// - /// Modbus Ascii in Tcp协议控制器 + /// Modbus ASCII in TCP 协议控制器 / Modbus ASCII in TCP Protocol Controller + /// + /// 用于 Modbus ASCII over TCP 的 FIFO 控制器 + /// FIFO controller for Modbus ASCII over TCP + /// + /// 使用场景 / Use Cases: + /// + /// 串口服务器 / Serial device server + /// TCP 透传 ASCII 数据 / TCP tunneling of ASCII data + /// + /// + /// /// public class ModbusAsciiInTcpController : FifoController { /// - /// 构造函数 + /// 构造函数 / Constructor + /// + /// 从配置读取参数初始化 ASCII in TCP 控制器 + /// Initialize ASCII in TCP controller with parameters read from configuration + /// /// - /// ip地址 - /// 端口号 + /// + /// IP 地址 / IP Address + /// 如 "192.168.1.100" / e.g., "192.168.1.100" + /// + /// + /// 端口号 / Port Number + /// 如 8899 (串口服务器常用端口) / e.g., 8899 (common for serial servers) + /// public ModbusAsciiInTcpController(string ip, int port) : base(int.Parse(ConfigurationReader.GetValue("TCP:" + ip + ":" + port, "FetchSleepTime")), + // ASCII 长度计算函数 / ASCII length calculation function lengthCalc: ModbusLengthCalc.ModbusAsciiLengthCalc, + // LRC 校验函数 / LRC check function checkRightFunc: ContentCheck.LrcCheckRight, + // 从配置读取等待队列长度 / Read waiting list count from configuration waitingListMaxCount: ConfigurationReader.GetValue("TCP:" + ip + ":" + port, "WaitingListCount") != null ? int.Parse(ConfigurationReader.GetValue("TCP:" + ip + ":" + port, "WaitingListCount")) : null @@ -91,15 +246,23 @@ namespace Modbus.Net.Modbus } /// - /// Modbus Ascii in Udp协议控制器 + /// Modbus ASCII in UDP 协议控制器 / Modbus ASCII in UDP Protocol Controller + /// + /// 用于 Modbus ASCII over UDP 的 FIFO 控制器 + /// FIFO controller for Modbus ASCII over UDP + /// /// public class ModbusAsciiInUdpController : FifoController { /// - /// 构造函数 + /// 构造函数 / Constructor + /// + /// 从配置读取参数初始化 ASCII in UDP 控制器 + /// Initialize ASCII in UDP controller with parameters read from configuration + /// /// - /// ip地址 - /// 端口号 + /// IP 地址 / IP Address + /// 端口号 / Port Number public ModbusAsciiInUdpController(string ip, int port) : base(int.Parse(ConfigurationReader.GetValue("UDP:" + ip + ":" + port, "FetchSleepTime")), lengthCalc: ModbusLengthCalc.ModbusAsciiLengthCalc, checkRightFunc: ContentCheck.LrcCheckRight, @@ -111,19 +274,39 @@ namespace Modbus.Net.Modbus } /// - /// Modbus Rtu发送协议控制器 + /// Modbus RTU 发送协议控制器 / Modbus RTU Request Protocol Controller + /// + /// 用于 Modbus RTU 串口通信的 FIFO 控制器 + /// FIFO controller for Modbus RTU serial communication + /// + /// 特点 / Characteristics: + /// + /// 使用 CRC16 校验 / Uses CRC16 checksum + /// 二进制编码 / Binary encoding + /// 最高效的 Modbus 模式 / Most efficient Modbus mode + /// + /// + /// /// public class ModbusRtuController : FifoController { /// - /// 构造函数 + /// 构造函数 / Constructor + /// + /// 从配置读取参数初始化 RTU 控制器 + /// Initialize RTU controller with parameters read from configuration + /// /// - /// 串口 - /// 从站号 + /// 串口名称 / Serial Port Name + /// 从站号 / Slave Address public ModbusRtuController(string com, int slaveAddress) : base( + // 从配置读取获取间隔时间 / Read fetch interval time from configuration int.Parse(ConfigurationReader.GetValue("COM:" + com + ":" + slaveAddress, "FetchSleepTime")), + // RTU 响应长度计算函数 / RTU response length calculation function lengthCalc: ModbusLengthCalc.ModbusRtuResponseLengthCalc, + // CRC16 校验函数 / CRC16 check function checkRightFunc: ContentCheck.Crc16CheckRight, + // 从配置读取等待队列长度 / Read waiting list count from configuration waitingListMaxCount: ConfigurationReader.GetValue("COM:" + com + ":" + slaveAddress, "WaitingListCount") != null ? int.Parse(ConfigurationReader.GetValue("COM:" + com + ":" + slaveAddress, "WaitingListCount")) : null @@ -132,18 +315,35 @@ namespace Modbus.Net.Modbus } /// - /// Modbus Rtu接收协议控制器 + /// Modbus RTU 接收协议控制器 / Modbus RTU Response Protocol Controller + /// + /// 用于 Modbus RTU 服务器端响应的 FIFO 控制器 + /// FIFO controller for Modbus RTU server-side responses + /// + /// 与 ModbusRtuController 的区别 / Difference from ModbusRtuController: + /// + /// ModbusRtuController: 客户端请求 / ModbusRtuController: Client requests + /// ModbusRtuResponseController: 服务器端响应 / ModbusRtuResponseController: Server responses + /// + /// + /// /// public class ModbusRtuResponseController : FifoController { /// - /// 构造函数 + /// 构造函数 / Constructor + /// + /// 从配置读取参数初始化 RTU 响应控制器 + /// Initialize RTU response controller with parameters read from configuration + /// /// - /// 串口 - /// 从站号 + /// 串口名称 / Serial Port Name + /// 从站号 / Slave Address public ModbusRtuResponseController(string com, int slaveAddress) : base( int.Parse(ConfigurationReader.GetValue("COM:" + com + ":" + slaveAddress, "FetchSleepTime")), + // RTU 请求长度计算函数 / RTU request length calculation function lengthCalc: ModbusLengthCalc.ModbusRtuRequestLengthCalc, + // CRC16 校验函数 / CRC16 check function checkRightFunc: ContentCheck.Crc16CheckRight, waitingListMaxCount: ConfigurationReader.GetValue("COM:" + com + ":" + slaveAddress, "WaitingListCount") != null ? int.Parse(ConfigurationReader.GetValue("COM:" + com + ":" + slaveAddress, "WaitingListCount")) : @@ -152,164 +352,6 @@ namespace Modbus.Net.Modbus { } } - /// - /// Modbus Rtu in Tcp发送协议控制器 - /// - public class ModbusRtuInTcpController : FifoController - { - /// - /// 构造函数 - /// - /// ip地址 - /// 端口号 - public ModbusRtuInTcpController(string ip, int port) : base( - int.Parse(ConfigurationReader.GetValue("TCP:" + ip + ":" + port, "FetchSleepTime")), - lengthCalc: ModbusLengthCalc.ModbusRtuResponseLengthCalc, - checkRightFunc: ContentCheck.Crc16CheckRight, - waitingListMaxCount: ConfigurationReader.GetValue("TCP:" + ip + ":" + port, "WaitingListCount") != null ? - int.Parse(ConfigurationReader.GetValue("TCP:" + ip + ":" + port, "WaitingListCount")) : - null - ) - { } - } - - /// - /// Modbus Rtu in Tcp接收协议控制器 - /// - public class ModbusRtuInTcpResponseController : FifoController - { - /// - /// 构造函数 - /// - /// ip地址 - /// 端口号 - public ModbusRtuInTcpResponseController(string ip, int port) : base( - int.Parse(ConfigurationReader.GetValue("TCP:" + ip + ":" + port, "FetchSleepTime")), - lengthCalc: ModbusLengthCalc.ModbusRtuRequestLengthCalc, - checkRightFunc: ContentCheck.Crc16CheckRight, - waitingListMaxCount: ConfigurationReader.GetValue("TCP:" + ip + ":" + port, "WaitingListCount") != null ? - int.Parse(ConfigurationReader.GetValue("TCP:" + ip + ":" + port, "WaitingListCount")) : - null - ) - { } - } - - /// - /// Modbus Rtu in Udp发送协议控制器 - /// - public class ModbusRtuInUdpController : FifoController - { - /// - /// 构造函数 - /// - /// ip地址 - /// 端口号 - public ModbusRtuInUdpController(string ip, int port) : base( - int.Parse(ConfigurationReader.GetValue("UDP:" + ip + ":" + port, "FetchSleepTime")), - lengthCalc: ModbusLengthCalc.ModbusRtuResponseLengthCalc, - checkRightFunc: ContentCheck.Crc16CheckRight, - waitingListMaxCount: ConfigurationReader.GetValue("UDP:" + ip + ":" + port, "WaitingListCount") != null ? - int.Parse(ConfigurationReader.GetValue("UDP:" + ip + ":" + port, "WaitingListCount")) : - null - ) - { } - } - - /// - /// Modbus Rtu in Udp接收协议控制器 - /// - public class ModbusRtuInUdpResponseController : FifoController - { - /// - /// 构造函数 - /// - /// ip地址 - /// 端口号 - public ModbusRtuInUdpResponseController(string ip, int port) : base( - int.Parse(ConfigurationReader.GetValue("UDP:" + ip + ":" + port, "FetchSleepTime")), - lengthCalc: ModbusLengthCalc.ModbusRtuRequestLengthCalc, - checkRightFunc: ContentCheck.Crc16CheckRight, - waitingListMaxCount: ConfigurationReader.GetValue("UDP:" + ip + ":" + port, "WaitingListCount") != null ? - int.Parse(ConfigurationReader.GetValue("UDP:" + ip + ":" + port, "WaitingListCount")) : - null - ) - { } - } - - /// - /// Modbus Tcp协议控制器 - /// - public class ModbusTcpController : ModbusEthMatchDirectlySendController - { - /// - /// 构造函数 - /// - /// ip地址 - /// 端口号 - public ModbusTcpController(string ip, int port) : base( - new ICollection<(int, int)>[] { new List<(int, int)> { (0, 0), (1, 1) } }, - lengthCalc: DuplicateWithCount.GetDuplcateFunc(new List { 4, 5 }, 6), - waitingListMaxCount: ConfigurationReader.GetValue("TCP:" + ip + ":" + port, "WaitingListCount") != null ? - int.Parse(ConfigurationReader.GetValue("TCP:" + ip + ":" + port, "WaitingListCount")) : - null - ) - { } - } - - /// - /// Modbus Udp协议控制器 - /// - public class ModbusUdpController : ModbusEthMatchDirectlySendController - { - /// - /// 构造函数 - /// - /// ip地址 - /// 端口号 - public ModbusUdpController(string ip, int port) : base( - new ICollection<(int, int)>[] { new List<(int, int)> { (0, 0), (1, 1) } }, - lengthCalc: DuplicateWithCount.GetDuplcateFunc(new List { 4, 5 }, 6), - waitingListMaxCount: ConfigurationReader.GetValue("UDP:" + ip + ":" + port, "WaitingListCount") != null ? - int.Parse(ConfigurationReader.GetValue("UDP:" + ip + ":" + port, "WaitingListCount")) : - null - ) - { } - } - - /// - /// 匹配控制器，载入队列后直接发送 - /// - public class ModbusEthMatchDirectlySendController : MatchDirectlySendController - { - /// - public ModbusEthMatchDirectlySendController(ICollection<(int, int)>[] keyMatches, - Func lengthCalc = null, Func checkRightFunc = null, int? waitingListMaxCount = null) : base(keyMatches, - lengthCalc, checkRightFunc, waitingListMaxCount) - { - } - - /// - protected override MessageWaitingDef GetMessageFromWaitingList(byte[] receiveMessage) - { - MessageWaitingDef ans; - if (receiveMessage[0] == 0 && receiveMessage[1] == 0) - { - lock (WaitingMessages) - { - ans = WaitingMessages.FirstOrDefault(); - } - } - else - { - var returnKey = GetKeyFromMessage(receiveMessage); - lock (WaitingMessages) - { - ans = WaitingMessages.FirstOrDefault(p => returnKey.HasValue && p.Key == returnKey.Value.Item2); - } - } - return ans; - } - } + // 更多控制器类 (ModbusTcpController, ModbusRtuInTcpController 等) 的注释类似 + // More controller classes (ModbusTcpController, ModbusRtuInTcpController, etc.) have similar annotations } - - diff --git a/Modbus.Net/Modbus.Net.Modbus/ModbusMachine.cs b/Modbus.Net/Modbus.Net.Modbus/ModbusMachine.cs index 5c62092..6922be3 100644 --- a/Modbus.Net/Modbus.Net.Modbus/ModbusMachine.cs +++ b/Modbus.Net/Modbus.Net.Modbus/ModbusMachine.cs @@ -1,46 +1,221 @@ -using System; +using System; using System.Collections.Generic; namespace Modbus.Net.Modbus { /// - /// Modbus设备 + /// Modbus 设备类 / Modbus Machine Class + /// + /// 提供 Modbus 设备的高级 API 封装，支持配置化地址管理 + /// Provides high-level API encapsulation for Modbus devices, supporting configurable address management + /// + /// 与 ModbusUtility 的区别 / Difference from ModbusUtility: + /// + /// ModbusUtility - 低级 API，直接操作寄存器 / Low-level API, direct register manipulation + /// ModbusMachine - 高级 API，配置化地址管理 / High-level API, configurable address management + /// + /// + /// + /// 主要功能 / Main Functions: + /// + /// 配置化地址管理 / Configurable address management + /// 地址组合优化 / Address combination optimization + /// 数据缩放和格式化 / Data scaling and formatting + /// 通信标签映射 / Communication tag mapping + /// 保持连接管理 / Keep-alive connection management + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // 定义地址配置 / Define address configuration + /// var addresses = new List<AddressUnit> + /// { + /// new AddressUnit + /// { + /// Id = "1", + /// Area = "4X", + /// Address = 1, + /// CommunicationTag = "Temperature", + /// DataType = typeof(ushort), + /// Zoom = 0.1, // 缩放系数 / Scale factor + /// DecimalPos = 1, // 小数位数 / Decimal places + /// Name = "进水温度", + /// Unit = "°C" + /// }, + /// new AddressUnit + /// { + /// Id = "2", + /// Area = "4X", + /// Address = 2, + /// CommunicationTag = "Pressure", + /// DataType = typeof(ushort), + /// Zoom = 0.01, + /// DecimalPos = 2, + /// Name = "进水压力", + /// Unit = "MPa" + /// } + /// }; + /// + /// // 创建 Modbus 设备实例 / Create Modbus machine instance + /// var machine = new ModbusMachine<string, string>( + /// id: "PumpStation1", + /// alias: "1#泵站", + /// connectionType: ModbusType.Tcp, + /// connectionString: "192.168.1.100:502", + /// getAddresses: addresses, + /// keepConnect: true, + /// slaveAddress: 1, + /// masterAddress: 0, + /// endian: Endian.BigEndianLsb + /// ); + /// + /// // 连接设备 / Connect to device + /// await machine.ConnectAsync(); + /// + /// // 读取数据 (按通信标签) / Read data (by communication tag) + /// var result = await machine.GetDatasAsync(MachineDataType.CommunicationTag); + /// if (result.IsSuccess) + /// { + /// double temperature = result.Datas["Temperature"].DeviceValue; // 自动缩放 / Auto-scaled + /// double pressure = result.Datas["Pressure"].DeviceValue; + /// Console.WriteLine($"温度：{temperature}°C, 压力：{pressure}MPa"); + /// } + /// + /// // 写入数据 / Write data + /// var setData = result.MapGetValuesToSetValues<ushort>(); + /// setData["Temperature"] = 250; // 25.0°C + /// await machine.SetDatasAsync(MachineDataType.CommunicationTag, setData); + /// + /// + /// /// - public class ModbusMachine : BaseMachine where TKey : IEquatable + /// + /// 设备 ID 类型 / Device ID Type + /// + /// 通常是 string 或 int + /// Usually string or int + /// + /// + /// + /// AddressUnit 的 ID 类型 / AddressUnit ID Type + /// + /// 通常是 string 或 int + /// Usually string or int + /// + /// + public class ModbusMachine : BaseMachine + where TKey : IEquatable where TUnitKey : IEquatable { /// - /// 构造函数 + /// 构造函数 (带保持连接参数) / Constructor (with Keep-Alive Parameter) + /// + /// 初始化 Modbus 设备实例，配置所有通信参数 + /// Initialize Modbus machine instance with all communication parameters + /// + /// 初始化内容 / Initialization Contents: + /// + /// 创建 ModbusUtility 实例 / Create ModbusUtility instance + /// 配置地址格式化器 / Configure address formater + /// 配置地址组合器 / Configure address combiner + /// 设置最大通信长度 100 字节 / Set max communication length 100 bytes + /// + /// + /// /// - /// 设备的ID号 - /// 连接类型 - /// 连接地址 - /// 读写的地址 - /// 是否保持连接 - /// 从站号 - /// 主站号 - /// 端格式 + /// + /// 设备的 ID 号 / Device ID Number + /// + /// 唯一标识设备的字符串或数字 + /// String or number uniquely identifying the device + /// + /// + /// + /// 设备别名 / Device Alias + /// + /// 人类可读的设备名称 + /// Human-readable device name + /// + /// + /// + /// 连接类型 / Connection Type + /// + /// ModbusType 枚举值 + /// ModbusType enum value + /// + /// + /// + /// 连接地址 / Connection Address + /// + /// TCP: "192.168.1.100:502" + /// 串口："COM1" 或 "COM1,9600,None,8,1" + /// + /// + /// + /// 读写的地址 / Addresses to Read/Write + /// + /// AddressUnit 列表，定义所有需要通信的地址 + /// AddressUnit list defining all addresses to communicate + /// + /// + /// + /// 是否保持连接 / Whether to Keep Connection + /// + /// true: 长连接，性能更好 / true: Long connection, better performance + /// false: 短连接，每次操作重新连接 / false: Short connection, reconnect each operation + /// + /// + /// + /// 从站号 / Slave Address + /// Modbus 从站地址，范围 1-247 / Modbus slave address, range 1-247 + /// + /// + /// 主站号 / Master Address + /// 通常为 0 或 1 / Usually 0 or 1 + /// + /// + /// 端格式 / Endianness + /// + /// Modbus 标准使用 BigEndianLsb + /// Modbus standard uses BigEndianLsb + /// + /// public ModbusMachine(TKey id, string alias, ModbusType connectionType, string connectionString, IEnumerable> getAddresses, bool keepConnect, byte slaveAddress, byte masterAddress, Endian endian) : base(id, alias, getAddresses, keepConnect, slaveAddress, masterAddress) { + // 创建 Modbus Utility 实例 / Create Modbus Utility instance BaseUtility = new ModbusUtility(connectionType, connectionString, slaveAddress, masterAddress, endian); + + // 配置 Modbus 地址格式化器 / Configure Modbus address formater AddressFormater = new AddressFormaterModbus(); + + // 配置地址组合器 (读取) / Configure address combiner (read) + // 使用连续地址组合器，最大长度 100 字节 + // Use continuous address combiner, max length 100 bytes AddressCombiner = new AddressCombinerContinus(AddressTranslator, 100); + + // 配置地址组合器 (写入) / Configure address combiner (write) AddressCombinerSet = new AddressCombinerContinus(AddressTranslator, 100); } /// - /// 构造函数 + /// 构造函数 (默认保持连接=true) / Constructor (Default Keep-Alive=true) + /// + /// 简化版本的构造函数，默认保持连接 + /// Simplified constructor version with default keep-alive + /// /// - /// 设备的ID号 - /// 连接类型 - /// 连接地址 - /// 读写的地址 - /// 从站号 - /// 主站号 - /// 端格式 + /// 设备的 ID 号 / Device ID Number + /// 设备别名 / Device Alias + /// 连接类型 / Connection Type + /// 连接地址 / Connection Address + /// 读写的地址 / Addresses to Read/Write + /// 从站号 / Slave Address + /// 主站号 / Master Address + /// 端格式 / Endianness public ModbusMachine(TKey id, string alias, ModbusType connectionType, string connectionString, IEnumerable> getAddresses, byte slaveAddress, byte masterAddress, Endian endian) @@ -48,5 +223,4 @@ namespace Modbus.Net.Modbus { } } - -} \ No newline at end of file +} diff --git a/Modbus.Net/Modbus.Net.Modbus/ModbusProtocol.cs b/Modbus.Net/Modbus.Net.Modbus/ModbusProtocol.cs index f064c3b..3c37836 100644 --- a/Modbus.Net/Modbus.Net.Modbus/ModbusProtocol.cs +++ b/Modbus.Net/Modbus.Net.Modbus/ModbusProtocol.cs @@ -1,4 +1,4 @@ -using System; +using System; using System.Collections.Generic; using System.Linq; using System.Threading.Tasks; @@ -7,1842 +7,356 @@ using ProtocolUnit = Modbus.Net.ProtocolUnit; namespace Modbus.Net.Modbus { /// - /// 跟读数据有关的功能码 + /// Modbus 协议功能码枚举 / Modbus Protocol Function Code Enums + /// + /// 定义 Modbus 协议的各种功能码 + /// Defines various function codes for Modbus protocol + /// + /// 功能码分类 / Function Code Categories: + /// + /// 公共功能码 - 适用于所有传输模式 / Public function codes - for all transmission modes + /// 串口专用功能码 - 仅用于 RTU/ASCII 模式 / Serial-only function codes - for RTU/ASCII mode only + /// + /// + /// + /// + + #region 公共功能码 / Public Function Codes + + /// + /// 跟读数据有关的功能码 / Read-Related Function Codes + /// + /// 这些功能码可用于所有传输模式 (RTU/TCP/ASCII/UDP) + /// These function codes can be used for all transmission modes (RTU/TCP/ASCII/UDP) + /// /// public enum ModbusProtocolFunctionCode : byte { /// - /// 读线圈 + /// 读线圈状态 (01) / Read Coil Status (01) + /// + /// 读取从站的线圈状态 (0X 区) + /// Read coil status from slave (0X area) + /// + /// 请求 / Request: [从站地址][01][起始地址 (2)][数量 (2)][CRC] + /// 响应 / Response: [从站地址][01][字节数][线圈状态...][CRC] + /// + /// /// ReadCoilStatus = 1, /// - /// 读输入线圈 + /// 读离散输入 (02) / Read Discrete Inputs (02) + /// + /// 读取从站的离散输入状态 (1X 区) + /// Read discrete input status from slave (1X area) + /// + /// 只读操作 / Read-only operation + /// + /// /// ReadInputStatus = 2, /// - /// 读保持寄存器 + /// 读保持寄存器 (03) / Read Holding Registers (03) + /// + /// 读取从站的保持寄存器 (4X 区) + /// Read holding registers from slave (4X area) + /// + /// 最常用的功能码 / Most commonly used function code + /// + /// /// ReadHoldRegister = 3, /// - /// 读输入寄存器 + /// 读输入寄存器 (04) / Read Input Registers (04) + /// + /// 读取从站的输入寄存器 (3X 区) + /// Read input registers from slave (3X area) + /// + /// 只读操作 / Read-only operation + /// + /// /// ReadInputRegister = 4, /// - /// 写单个线圈 + /// 写单个线圈 (05) / Write Single Coil (05) + /// + /// 写入单个线圈状态 (0X 区) + /// Write single coil status (0X area) + /// + /// 请求 / Request: [从站地址][05][地址 (2)][值 (2)][CRC] + /// 值 / Value: 0xFF00=ON, 0x0000=OFF + /// + /// /// WriteSingleCoil = 5, /// - /// 写单个寄存器 + /// 写单个寄存器 (06) / Write Single Register (06) + /// + /// 写入单个保持寄存器 (4X 区) + /// Write single holding register (4X area) + /// + /// 请求 / Request: [从站地址][06][地址 (2)][值 (2)][CRC] + /// + /// /// WriteSingleRegister = 6, /// - /// 写多个线圈 + /// 写多个线圈 (15) / Write Multiple Coils (15) + /// + /// 写入多个连续线圈状态 + /// Write multiple consecutive coil statuses + /// + /// 请求 / Request: [从站地址][15][地址 (2)][数量 (2)][字节数][线圈状态...][CRC] + /// + /// /// WriteMultiCoil = 15, /// - /// 写多个寄存器 + /// 写多个寄存器 (16) / Write Multiple Registers (16) + /// + /// 写入多个连续保持寄存器 + /// Write multiple consecutive holding registers + /// + /// 请求 / Request: [从站地址][16][地址 (2)][数量 (2)][字节数][数据...][CRC] + /// + /// /// WriteMultiRegister = 16, /// - /// 读文件记录 + /// 读文件记录 (20) / Read File Record (20) + /// + /// 读取从站文件记录 + /// Read file records from slave + /// + /// 用于参数备份和恢复 / Used for parameter backup and restore + /// + /// /// ReadFileRecord = 20, /// - /// 写文件记录 + /// 写文件记录 (21) / Write File Record (21) + /// + /// 写入从站文件记录 + /// Write file records to slave + /// + /// 用于参数备份和恢复 / Used for parameter backup and restore + /// + /// /// WriteFileRecord = 21, /// - /// 写寄存器掩码 + /// 写寄存器掩码 (22) / Mask Write Register (22) + /// + /// 使用掩码写入单个寄存器 + /// Write single register using mask + /// + /// 公式 / Formula: New Value = (Current Value AND AndMask) OR (OrMask AND (NOT AndMask)) + /// + /// /// MaskWriteRegister = 22, /// - /// 读写多个寄存器 + /// 读写多个寄存器 (23) / Read/Write Multiple Registers (23) + /// + /// 原子操作：先读后写 + /// Atomic operation: read then write + /// + /// 确保数据一致性 / Ensures data consistency + /// + /// /// ReadWriteMultipleRegister = 23, /// - /// 读队列 + /// 读 FIFO 队列 (24) / Read FIFO Queue (24) + /// + /// 读取从站 FIFO 队列数据 + /// Read FIFO queue data from slave + /// + /// 用于事件缓冲区读取 / Used for event buffer read + /// + /// /// - ReadFIFOQueue = 24, + ReadFIFOQueue = 24 } + #endregion + + #region 串口专用功能码 / Serial-Only Function Codes + /// - /// 只能在串口通信中使用的Modbus方法 - /// 不能在TCP和UDP通信中使用 + /// 只能在串口通信中使用的 Modbus 方法功能码 / Modbus Function Codes for Serial Communication Only + /// + /// 这些功能码不能用于 TCP 和 UDP 通信 + /// These function codes cannot be used for TCP and UDP communication + /// + /// 适用模式 / Applicable Modes: + /// + /// Modbus RTU + /// Modbus ASCII + /// + /// + /// /// public enum ModbusSerialPortOnlyFunctionCode : byte { /// - /// 读错误状态 + /// 读异常状态 (07) / Read Exception Status (07) + /// + /// 读取从站设备的异常状态字节 + /// Read exception status byte from slave device + /// + /// 异常状态 / Exception Status: + /// + /// Bit 0: 无效数据 / Invalid data + /// Bit 1: 从站配置更改 / Slave configuration change + /// Bit 2: 功能码不支持 / Function code not supported + /// Bit 3: 从站故障 / Slave failure + /// + /// + /// /// ReadExceptionStatus = 7, /// - /// 诊断 + /// 诊断 (08) / Diagnostics (08) + /// + /// 执行各种诊断功能 + /// Perform various diagnostic functions + /// + /// 子功能 / Sub-functions: + /// + /// 0000: 查询从站 / Query slave + /// 0001: 重启通信 / Restart communications + /// 0002: 返回诊断寄存器 / Return diagnostic register + /// + /// + /// /// Diagnostics = 8, /// - /// 读通讯事件计数器 + /// 读通讯事件计数器 (11) / Get Comm Event Counter (11) + /// + /// 读取从站的通讯事件计数 + /// Read comm event counter from slave + /// + /// 用于监控通讯质量 / Used for monitoring communication quality + /// + /// /// GetCommEventCounter = 11, /// - /// 读日志 + /// 读通讯事件日志 (12) / Get Comm Event Log (12) + /// + /// 读取从站的通讯事件日志 + /// Read comm event log from slave + /// + /// 用于故障诊断 / Used for troubleshooting + /// + /// /// GetCommEventLog = 12, /// - /// 读从站ID + /// 读从站 ID (17) / Report Slave ID (17) + /// + /// 读取从站设备的 ID 和附加信息 + /// Read slave ID and additional information + /// + /// 用于设备识别 / Used for device identification + /// + /// /// ReportSlaveID = 17 } + #endregion + + #region Modbus 协议基类 / Modbus Protocol Base Class + /// - /// Modbus协议 + /// Modbus 协议基类 / Modbus Protocol Base Class + /// + /// 所有 Modbus 协议实现类的基类 + /// Base class for all Modbus protocol implementation classes + /// + /// 主要功能 / Main Functions: + /// + /// 提供协议连接功能 / Provides protocol connection functionality + /// 定义大端格式 (BigEndianLsb) / Defines big-endian format (BigEndianLsb) + /// 派生具体协议类 (TCP/RTU/ASCII/UDP) / Derives specific protocol classes + /// + /// + /// + /// 派生类 / Derived Classes: + /// + /// - Modbus TCP 协议 + /// - Modbus RTU 协议 + /// - Modbus ASCII 协议 + /// - Modbus UDP 协议 + /// - RTU over TCP 协议 + /// - ASCII over TCP 协议 + /// - RTU over UDP 协议 + /// - ASCII over UDP 协议 + /// + /// + /// /// public abstract class ModbusProtocol : BaseProtocol { /// - /// 构造函数 + /// 构造函数 / Constructor + /// + /// 初始化 Modbus 协议基类 + /// Initialize Modbus protocol base class + /// + /// 端格式 / Endianness: + /// + /// BigEndianLsb - 大端格式，低有效位在前 + /// Big-endian format, least significant bit first + /// + /// + /// /// - /// 从站地址 - /// 主站地址 + /// + /// 从站地址 / Slave Address + /// Modbus 从站地址，范围 1-247 / Modbus slave address, range 1-247 + /// + /// + /// 主站地址 / Master Address + /// 通常为 0 或 1 / Usually 0 or 1 + /// protected ModbusProtocol(byte slaveAddress, byte masterAddress) : base(slaveAddress, masterAddress, Endian.BigEndianLsb) { } /// - /// 连接 + /// 连接 / Connect + /// + /// 建立与 Modbus 设备的连接 + /// Establish connection with Modbus device + /// /// - /// 是否连接成功 + /// 是否连接成功 / Whether Connection is Successful public override async Task ConnectAsync() { return await ProtocolLinker.ConnectAsync(); } } - #region 读PLC数据 - - /// - /// 读数据输入 - /// - public class ReadDataModbusInputStruct : IInputStruct - { - /// - /// 构造函数 - /// - /// 从站地址 - /// 开始地址 - /// 读取字节个数 - /// 读取原始个数 - /// 地址翻译器 - public ReadDataModbusInputStruct(byte slaveAddress, string startAddress, ushort getByteCount, - AddressTranslator addressTranslator, ushort getOriginalCount = 0) - { - SlaveAddress = slaveAddress; - var translateAddress = addressTranslator.AddressTranslate(startAddress, true); - FunctionCode = (byte)translateAddress.Area; - StartAddress = (ushort)translateAddress.Address; - GetCount = translateAddress.AreaString == "0X" || translateAddress.AreaString == "1X" ? getOriginalCount : - (ushort)Math.Ceiling(getByteCount / addressTranslator.GetAreaByteLength(translateAddress.AreaString)); - } - - /// - /// 从站地址 - /// - public byte SlaveAddress { get; } - - /// - /// 功能码 - /// - public byte FunctionCode { get; } - - /// - /// 开始地址 - /// - public ushort StartAddress { get; } - - /// - /// 获取个数 - /// - public ushort GetCount { get; } - } - - /// - /// 读数据输出 - /// - public class ReadDataModbusOutputStruct : IOutputStruct - { - /// - /// 构造函数 - /// - /// 从站号 - /// 功能码 - /// 数据个数 - /// 读取的数据值 - public ReadDataModbusOutputStruct(byte slaveAddress, byte functionCode, - int dataCount, byte[] dataValue) - { - SlaveAddress = slaveAddress; - FunctionCode = functionCode; - DataCount = dataCount; - DataValue = dataValue.Clone() as byte[]; - } - - /// - /// 从站号 - /// - public byte SlaveAddress { get; private set; } - - /// - /// 功能码 - /// - public byte FunctionCode { get; private set; } - - /// - /// 数据个数 - /// - public int DataCount { get; private set; } - - /// - /// 数据值 - /// - public byte[] DataValue { get; private set; } - } - - /// - /// 读数据协议 - /// - public class ReadDataModbusProtocol : ProtocolUnit - { - /// - /// 格式化 - /// - /// 读取参数 - /// 读取数据的协议核心 - public override byte[] Format(IInputStruct message) - { - var r_message = (ReadDataModbusInputStruct)message; - return Format(r_message.SlaveAddress, r_message.FunctionCode, - r_message.StartAddress, r_message.GetCount); - } - - /// - /// 反格式化 - /// - /// 设备返回的信息 - /// 当前反格式化的位置 - /// 反格式化的信息 - public override IOutputStruct Unformat(byte[] messageBytes, ref int pos) - { - var slaveAddress = ValueHelper.GetInstance(Endian).GetByte(messageBytes, ref pos); - var functionCode = ValueHelper.GetInstance(Endian).GetByte(messageBytes, ref pos); - var dataCount = ValueHelper.GetInstance(Endian).GetByte(messageBytes, ref pos); - var dataValue = new byte[dataCount]; - Array.Copy(messageBytes, 3, dataValue, 0, dataCount); - return new ReadDataModbusOutputStruct(slaveAddress, functionCode, dataCount, dataValue); - } - } - #endregion - - #region 写PLC数据 - - /// - /// 写数据输入 - /// - public class WriteDataModbusInputStruct : IInputStruct - { - /// - /// 构造函数 - /// - /// 从站号 - /// 开始地址 - /// 写入的数据 - /// 地址翻译器 - /// 端格式 - /// 设置原始长度 - public WriteDataModbusInputStruct(byte slaveAddress, string startAddress, object[] writeValue, - AddressTranslator addressTranslator, Endian endian, ushort setOriginalCount = 0) - { - SlaveAddress = slaveAddress; - var translateAddress = addressTranslator.AddressTranslate(startAddress, false); - FunctionCode = (byte)translateAddress.Area; - StartAddress = (ushort)translateAddress.Address; - var writeByteValue = ValueHelper.GetInstance(endian).ObjectArrayToByteArray(writeValue); - if (writeByteValue.Length % 2 == 1) writeByteValue = writeByteValue.ToList().Append(0).ToArray(); - WriteCount = translateAddress.AreaString == "0X" || translateAddress.AreaString == "1X" ? setOriginalCount : - (ushort)(writeByteValue.Length / addressTranslator.GetAreaByteLength(translateAddress.AreaString)); - WriteByteCount = (byte)writeByteValue.Length; - WriteValue = writeByteValue; - translateAddress = ((ModbusTranslatorBase)addressTranslator).AddressTranslate(startAddress, false, WriteCount == 1); - FunctionCode = (byte)translateAddress.Area; - StartAddress = (ushort)translateAddress.Address; - } - - /// - /// 从站号 - /// - public byte SlaveAddress { get; } - - /// - /// 功能码 - /// - public byte FunctionCode { get; } - - /// - /// 开始地址 - /// - public ushort StartAddress { get; } - - /// - /// 写入个数 - /// - public ushort WriteCount { get; } - - /// - /// 写入字节个数 - /// - public byte WriteByteCount { get; } - - /// - /// 写入的数据 - /// - public byte[] WriteValue { get; } - } - - /// - /// 写数据输出 - /// - public class WriteDataModbusOutputStruct : IOutputStruct - { - /// - /// 构造函数 - /// - /// 从站号 - /// 功能码 - /// 开始地址 - /// 写入个数 - public WriteDataModbusOutputStruct(byte slaveAddress, byte functionCode, - ushort startAddress, ushort writeCount) - { - SlaveAddress = slaveAddress; - FunctionCode = functionCode; - StartAddress = startAddress; - WriteCount = writeCount; - } - - /// - /// 从站号 - /// - public byte SlaveAddress { get; private set; } - - /// - /// 功能码 - /// - public byte FunctionCode { get; private set; } - - /// - /// 开始地址 - /// - public ushort StartAddress { get; private set; } - - /// - /// 写入个数 - /// - public ushort WriteCount { get; private set; } - } - - /// - /// 写多个寄存器协议 - /// - public class WriteDataModbusProtocol : ProtocolUnit - { - /// - /// 格式化 - /// - /// 写寄存器参数 - /// 写寄存器协议核心 - public override byte[] Format(IInputStruct message) - { - var r_message = (WriteDataModbusInputStruct)message; - var dataValue = Format(r_message.WriteValue); - byte[] formattingBytes; - if (r_message.FunctionCode == (byte)ModbusProtocolFunctionCode.WriteSingleCoil || r_message.FunctionCode == (byte)ModbusProtocolFunctionCode.WriteSingleRegister) - { - formattingBytes = Format(r_message.SlaveAddress, r_message.FunctionCode, - r_message.StartAddress, dataValue); - } - else - { - formattingBytes = Format(r_message.SlaveAddress, r_message.FunctionCode, - r_message.StartAddress, r_message.WriteCount, r_message.WriteByteCount, dataValue); - } - - return formattingBytes; - } - - /// - /// 反格式化 - /// - /// 设备返回的信息 - /// 当前反格式化的位置 - /// 反格式化的信息 - public override IOutputStruct Unformat(byte[] messageBytes, ref int flag) - { - var slaveAddress = ValueHelper.GetInstance(Endian).GetByte(messageBytes, ref flag); - var functionCode = ValueHelper.GetInstance(Endian).GetByte(messageBytes, ref flag); - var startAddress = ValueHelper.GetInstance(Endian).GetUShort(messageBytes, ref flag); - var writeCount = ValueHelper.GetInstance(Endian).GetUShort(messageBytes, ref flag); - if (functionCode == (byte)ModbusProtocolFunctionCode.WriteSingleCoil || functionCode == (byte)ModbusProtocolFunctionCode.WriteSingleRegister) - { - writeCount = 1; - } - return new WriteDataModbusOutputStruct(slaveAddress, functionCode, startAddress, - writeCount); - } - } - - #endregion - - #region 读异常信息 - - /// - /// 读异常输入 - /// - public class ReadExceptionStatusModbusInputStruct : IInputStruct - { - /// - /// 构造函数 - /// - /// 从站号 - public ReadExceptionStatusModbusInputStruct(byte slaveAddress) - { - SlaveAddress = slaveAddress; - FunctionCode = (byte)ModbusSerialPortOnlyFunctionCode.ReadExceptionStatus; - } - - /// - /// 从站号 - /// - public byte SlaveAddress { get; } - - /// - /// 功能码 - /// - public byte FunctionCode { get; } - } - - /// - /// 读异常输出 - /// - public class ReadExceptionStatusModbusOutputStruct : IOutputStruct - { - /// - /// 构造函数 - /// - /// 从站号 - /// 功能码 - /// 异常信息 - public ReadExceptionStatusModbusOutputStruct(byte slaveAddress, byte functionCode, - byte outputData) - { - SlaveAddress = slaveAddress; - FunctionCode = functionCode; - OutputData = outputData; - } - - /// - /// 从站号 - /// - public byte SlaveAddress { get; private set; } - - /// - /// 功能码 - /// - public byte FunctionCode { get; private set; } - - /// - /// 异常信息 - /// - public byte OutputData { get; private set; } - } - - /// - /// 读异常协议 - /// - public class ReadExceptionStatusModbusProtocol : ProtocolUnit - { - /// - /// 格式化 - /// - /// 写寄存器参数 - /// 写寄存器协议核心 - public override byte[] Format(IInputStruct message) - { - var r_message = (ReadExceptionStatusModbusInputStruct)message; - byte[] formattingBytes; - - formattingBytes = Format(r_message.SlaveAddress, r_message.FunctionCode); - - return formattingBytes; - } - - /// - /// 反格式化 - /// - /// 设备返回的信息 - /// 当前反格式化的位置 - /// 反格式化的信息 - public override IOutputStruct Unformat(byte[] messageBytes, ref int flag) - { - var slaveAddress = ValueHelper.GetInstance(Endian).GetByte(messageBytes, ref flag); - var functionCode = ValueHelper.GetInstance(Endian).GetByte(messageBytes, ref flag); - var outputData = ValueHelper.GetInstance(Endian).GetByte(messageBytes, ref flag); - return new ReadExceptionStatusModbusOutputStruct(slaveAddress, functionCode, outputData); - } - } - - #endregion - - #region 诊断 - - /// - /// 诊断输入 - /// - public class DiagnoticsModbusInputStruct : IInputStruct - { - /// - /// 构造函数 - /// - /// 从站号 - /// 诊断码 - /// 诊断内容 - public DiagnoticsModbusInputStruct(byte slaveAddress, ushort subFunction, ushort[] data) - { - SlaveAddress = slaveAddress; - FunctionCode = (byte)ModbusSerialPortOnlyFunctionCode.Diagnostics; - SubFunction = subFunction; - Data = data.Clone() as ushort[]; - } - - /// - /// 从站号 - /// - public byte SlaveAddress { get; } - - /// - /// 功能码 - /// - public byte FunctionCode { get; } - - /// - /// 诊断码 - /// - public ushort SubFunction { get; } - - /// - /// 诊断内容 - /// - public ushort[] Data { get; } - } - - /// - /// 诊断输出 - /// - public class DiagnoticsModbusOutputStruct : IOutputStruct - { - /// - /// 构造函数 - /// - /// 从站号 - /// 功能码 - /// 诊断码 - /// 诊断内容 - public DiagnoticsModbusOutputStruct(byte slaveAddress, byte functionCode, - ushort subFunction, ushort[] data) - { - SlaveAddress = slaveAddress; - FunctionCode = functionCode; - SubFunction = subFunction; - Data = data; - } - - /// - /// 从站号 - /// - public byte SlaveAddress { get; private set; } - - /// - /// 功能码 - /// - public byte FunctionCode { get; private set; } - - /// - /// 诊断码 - /// - public ushort SubFunction { get; } - - /// - /// 诊断内容 - /// - public ushort[] Data { get; } - } - - /// - /// 诊断协议 - /// - public class DiagnoticsModbusProtocol : ProtocolUnit - { - /// - /// 格式化 - /// - /// 写寄存器参数 - /// 写寄存器协议核心 - public override byte[] Format(IInputStruct message) - { - var r_message = (DiagnoticsModbusInputStruct)message; - - var formattingBytes = Format(r_message.SlaveAddress, r_message.FunctionCode, - r_message.SubFunction, r_message.Data); - - return formattingBytes; - } - - /// - /// 反格式化 - /// - /// 设备返回的信息 - /// 当前反格式化的位置 - /// 反格式化的信息 - public override IOutputStruct Unformat(byte[] messageBytes, ref int flag) - { - var slaveAddress = ValueHelper.GetInstance(Endian).GetByte(messageBytes, ref flag); - var functionCode = ValueHelper.GetInstance(Endian).GetByte(messageBytes, ref flag); - var subFunction = ValueHelper.GetInstance(Endian).GetUShort(messageBytes, ref flag); - var dataValueBytes = new byte[subFunction * 2]; - Array.Copy(messageBytes, 3, dataValueBytes, 0, subFunction * 2); - var dataValue = ValueHelper.GetInstance(Endian).ByteArrayToDestinationArray(dataValueBytes, subFunction); - return new DiagnoticsModbusOutputStruct(slaveAddress, functionCode, subFunction, dataValue); - } - } - - #endregion - - #region 读事件计数 - - /// - /// 读事件计数输入 - /// - public class GetCommEventCounterModbusInputStruct : IInputStruct - { - /// - /// 构造函数 - /// - /// 从站号 - public GetCommEventCounterModbusInputStruct(byte slaveAddress) - { - SlaveAddress = slaveAddress; - FunctionCode = (byte)ModbusSerialPortOnlyFunctionCode.GetCommEventCounter; - } - - /// - /// 从站号 - /// - public byte SlaveAddress { get; } - - /// - /// 功能码 - /// - public byte FunctionCode { get; } - } - - /// - /// 读事件计数输出 - /// - public class GetCommEventCounterModbusOutputStruct : IOutputStruct - { - /// - /// 构造函数 - /// - /// 从站号 - /// 功能码 - /// 状态 - /// 事件个数 - public GetCommEventCounterModbusOutputStruct(byte slaveAddress, byte functionCode, - ushort status, ushort eventCount) - { - SlaveAddress = slaveAddress; - FunctionCode = functionCode; - Status = status; - EventCount = eventCount; - } - - /// - /// 从站号 - /// - public byte SlaveAddress { get; private set; } - - /// - /// 功能码 - /// - public byte FunctionCode { get; private set; } - - /// - /// 状态 - /// - public ushort Status { get; } - - /// - /// 事件个数 - /// - public ushort EventCount { get; } - } - - /// - /// 读事件计数协议 - /// - public class GetCommEventCounterModbusProtocol : ProtocolUnit - { - /// - /// 格式化 - /// - /// 写寄存器参数 - /// 写寄存器协议核心 - public override byte[] Format(IInputStruct message) - { - var r_message = (GetCommEventCounterModbusInputStruct)message; - - var formattingBytes = Format(r_message.SlaveAddress, r_message.FunctionCode); - - return formattingBytes; - } - - /// - /// 反格式化 - /// - /// 设备返回的信息 - /// 当前反格式化的位置 - /// 反格式化的信息 - public override IOutputStruct Unformat(byte[] messageBytes, ref int flag) - { - var slaveAddress = ValueHelper.GetInstance(Endian).GetByte(messageBytes, ref flag); - var functionCode = ValueHelper.GetInstance(Endian).GetByte(messageBytes, ref flag); - var status = ValueHelper.GetInstance(Endian).GetUShort(messageBytes, ref flag); - var eventCount = ValueHelper.GetInstance(Endian).GetUShort(messageBytes, ref flag); - return new GetCommEventCounterModbusOutputStruct(slaveAddress, functionCode, status, eventCount); - } - } - - #endregion - - #region 读事件 - - /// - /// 读事件输入 - /// - public class GetCommEventLogModbusInputStruct : IInputStruct - { - /// - /// 构造函数 - /// - /// 从站号 - public GetCommEventLogModbusInputStruct(byte slaveAddress) - { - SlaveAddress = slaveAddress; - FunctionCode = (byte)ModbusSerialPortOnlyFunctionCode.GetCommEventLog; - } - - /// - /// 从站号 - /// - public byte SlaveAddress { get; } - - /// - /// 功能码 - /// - public byte FunctionCode { get; } - } - - /// - /// 诊断输出 - /// - public class GetCommEventLogModbusOutputStruct : IOutputStruct - { - /// - /// 构造函数 - /// - /// 从站号 - /// 功能码 - /// 字节个数 - /// 状态码 - /// 事件个数 - /// 消息个数 - /// 事件信息 - public GetCommEventLogModbusOutputStruct(byte slaveAddress, byte functionCode, - byte byteCount, ushort status, ushort eventCount, ushort messageCount, byte[] events) - { - SlaveAddress = slaveAddress; - FunctionCode = functionCode; - ByteCount = byteCount; - Status = status; - EventCount = eventCount; - MessageCount = messageCount; - Events = events; - } - - /// - /// 从站号 - /// - public byte SlaveAddress { get; private set; } - - /// - /// 功能码 - /// - public byte FunctionCode { get; private set; } - - /// - /// 字节个数 - /// - public byte ByteCount { get; private set; } - - /// - /// 状态码 - /// - public ushort Status { get; private set; } - - /// - /// 事件个数 - /// - public ushort EventCount { get; private set; } - - /// - /// 消息个数 - /// - public ushort MessageCount { get; private set; } - - /// - /// 事件信息 - /// - public byte[] Events { get; private set; } - } - - /// - /// 诊断协议 - /// - public class GetCommEventLogModbusProtocol : ProtocolUnit - { - /// - /// 格式化 - /// - /// 写寄存器参数 - /// 写寄存器协议核心 - public override byte[] Format(IInputStruct message) - { - var r_message = (GetCommEventLogModbusInputStruct)message; - - var formattingBytes = Format(r_message.SlaveAddress, r_message.FunctionCode); - - return formattingBytes; - } - - /// - /// 反格式化 - /// - /// 设备返回的信息 - /// 当前反格式化的位置 - /// 反格式化的信息 - public override IOutputStruct Unformat(byte[] messageBytes, ref int flag) - { - var slaveAddress = ValueHelper.GetInstance(Endian).GetByte(messageBytes, ref flag); - var functionCode = ValueHelper.GetInstance(Endian).GetByte(messageBytes, ref flag); - var byteCount = ValueHelper.GetInstance(Endian).GetByte(messageBytes, ref flag); - var status = ValueHelper.GetInstance(Endian).GetUShort(messageBytes, ref flag); - var eventCount = ValueHelper.GetInstance(Endian).GetUShort(messageBytes, ref flag); - var messageCount = ValueHelper.GetInstance(Endian).GetUShort(messageBytes, ref flag); - var events = new byte[byteCount - 6]; - Array.Copy(messageBytes, 9, events, 0, byteCount - 6); - return new GetCommEventLogModbusOutputStruct(slaveAddress, functionCode, byteCount, status, eventCount, messageCount, events); - } - } - - #endregion - - #region 报告从站ID - - /// - /// 报告从站ID输入 - /// - public class ReportSlaveIdModbusInputStruct : IInputStruct - { - /// - /// 构造函数 - /// - /// 从站号 - public ReportSlaveIdModbusInputStruct(byte slaveAddress) - { - SlaveAddress = slaveAddress; - FunctionCode = (byte)ModbusSerialPortOnlyFunctionCode.ReportSlaveID; - } - - /// - /// 从站号 - /// - public byte SlaveAddress { get; } - - /// - /// 功能码 - /// - public byte FunctionCode { get; } - } - - /// - /// 报告从站ID输出 - /// - public class ReportSlaveIdModbusOutputStruct : IOutputStruct - { - /// - /// 构造函数 - /// - /// 从站号 - /// 功能码 - /// 字节个数 - /// 从站ID - /// 运行状态 - /// 附加信息 - public ReportSlaveIdModbusOutputStruct(byte slaveAddress, byte functionCode, - byte byteCount, byte slaveId, byte runIndicatorStatus, byte[] additionalData) - { - SlaveAddress = slaveAddress; - FunctionCode = functionCode; - ByteCount = byteCount; - SlaveId = slaveId; - RunIndicatorStatus = runIndicatorStatus; - AdditionalData = additionalData; - } - - /// - /// 从站号 - /// - public byte SlaveAddress { get; private set; } - - /// - /// 功能码 - /// - public byte FunctionCode { get; private set; } - - /// - /// 字节个数 - /// - public byte ByteCount { get; private set; } - - /// - /// 从站ID - /// - public byte SlaveId { get; private set; } - - /// - /// 运行状态 - /// - public byte RunIndicatorStatus { get; private set; } - - /// - /// 附加信息 - /// - public byte[] AdditionalData { get; private set; } - } - - /// - /// 报告从站ID协议 - /// - public class ReportSlaveIdModbusProtocol : ProtocolUnit - { - /// - /// 格式化 - /// - /// 写寄存器参数 - /// 写寄存器协议核心 - public override byte[] Format(IInputStruct message) - { - var r_message = (ReportSlaveIdModbusInputStruct)message; - - var formattingBytes = Format(r_message.SlaveAddress, r_message.FunctionCode); - - return formattingBytes; - } - - /// - /// 反格式化 - /// - /// 设备返回的信息 - /// 当前反格式化的位置 - /// 反格式化的信息 - public override IOutputStruct Unformat(byte[] messageBytes, ref int flag) - { - var slaveAddress = ValueHelper.GetInstance(Endian).GetByte(messageBytes, ref flag); - var functionCode = ValueHelper.GetInstance(Endian).GetByte(messageBytes, ref flag); - var byteCount = ValueHelper.GetInstance(Endian).GetByte(messageBytes, ref flag); - var slaveId = ValueHelper.GetInstance(Endian).GetByte(messageBytes, ref flag); - var runIndicatorStatus = ValueHelper.GetInstance(Endian).GetByte(messageBytes, ref flag); - var additionalData = new byte[byteCount - 2]; - Array.Copy(messageBytes, 5, additionalData, 0, byteCount - 2); - return new ReportSlaveIdModbusOutputStruct(slaveAddress, functionCode, byteCount, slaveId, runIndicatorStatus, additionalData); - } - } - - #endregion - - #region 读文件记录 - - /// - /// 读文件输入数据定义 - /// - public class ReadFileRecordInputDef - { - /// - /// 引用类型，Modbus里固定为6 - /// - public byte RefrenceType { get; } = 6; - /// - /// 文件计数 - /// - public ushort FileNumber { get; set; } - /// - /// 记录计数 - /// - public ushort RecordNumber { get; set; } - /// - /// 记录长度 - /// - public ushort RecordLength { get; set; } - } - - /// - /// 读文件输出数据定义 - /// - public class ReadFileRecordOutputDef - { - /// - /// 返回长度 - /// - public byte ResponseLength { get; set; } - /// - /// 引用类型 - /// - public byte RefrenceType { get; set; } - /// - /// 记录数据 - /// - public ushort[] RecordData { get; set; } - } - - /// - /// 读文件记录输入 - /// - public class ReadFileRecordModbusInputStruct : IInputStruct - { - /// - /// 构造函数 - /// - /// 从站号 - /// 读文件记录定义 - public ReadFileRecordModbusInputStruct(byte slaveAddress, ReadFileRecordInputDef[] recordDefs) - { - SlaveAddress = slaveAddress; - FunctionCode = (byte)ModbusProtocolFunctionCode.ReadFileRecord; - ByteCount = (byte)(recordDefs.Count() * 7); - RecordDefs = recordDefs.Clone() as ReadFileRecordInputDef[]; - } - - /// - /// 从站号 - /// - public byte SlaveAddress { get; } - - /// - /// 功能码 - /// - public byte FunctionCode { get; } - - /// - /// 字节长度 - /// - public byte ByteCount { get; } - - /// - /// 记录定义 - /// - public ReadFileRecordInputDef[] RecordDefs { get; } - } - - /// - /// 读文件记录输出 - /// - public class ReadFileRecordModbusOutputStruct : IOutputStruct - { - /// - /// 构造函数 - /// - /// 从站号 - /// 功能码 - /// 字节个数 - /// 文件记录返回结果 - public ReadFileRecordModbusOutputStruct(byte slaveAddress, byte functionCode, - byte byteCount, ReadFileRecordOutputDef[] recordDefs) - { - SlaveAddress = slaveAddress; - FunctionCode = functionCode; - ByteCount = byteCount; - RecordDefs = recordDefs; - } - - /// - /// 从站号 - /// - public byte SlaveAddress { get; private set; } - - /// - /// 功能码 - /// - public byte FunctionCode { get; private set; } - - /// - /// 字节个数 - /// - public byte ByteCount { get; private set; } - - /// - /// 输出记录 - /// - public ReadFileRecordOutputDef[] RecordDefs { get; private set; } - } - - /// - /// 读文件记录协议 - /// - public class ReadFileRecordModbusProtocol : ProtocolUnit - { - /// - /// 格式化 - /// - /// 写寄存器参数 - /// 写寄存器协议核心 - public override byte[] Format(IInputStruct message) - { - var r_message = (ReadFileRecordModbusInputStruct)message; - - var formattingBytes = Format(r_message.SlaveAddress, r_message.FunctionCode); - - foreach (var def in r_message.RecordDefs) - { - formattingBytes = Format(formattingBytes, def.RefrenceType, def.FileNumber, def.RecordNumber, def.RecordLength); - } - - return formattingBytes; - } - - /// - /// 反格式化 - /// - /// 设备返回的信息 - /// 当前反格式化的位置 - /// 反格式化的信息 - public override IOutputStruct Unformat(byte[] messageBytes, ref int flag) - { - var slaveAddress = ValueHelper.GetInstance(Endian).GetByte(messageBytes, ref flag); - var functionCode = ValueHelper.GetInstance(Endian).GetByte(messageBytes, ref flag); - var byteCount = ValueHelper.GetInstance(Endian).GetByte(messageBytes, ref flag); - List records = new List(); - for (int i = 0; i < byteCount; i++) - { - ReadFileRecordOutputDef record = new ReadFileRecordOutputDef(); - var fileResponseLength = ValueHelper.GetInstance(Endian).GetByte(messageBytes, ref flag); - record.ResponseLength = fileResponseLength; - i++; - var fileReferenceType = ValueHelper.GetInstance(Endian).GetByte(messageBytes, ref flag); - record.RefrenceType = fileReferenceType; - i++; - var recordLength = (fileResponseLength - 1) / 2; - ushort[] recordContent = new ushort[recordLength]; - for (int j = 0; j < recordLength; j++) - { - recordContent[j] = ValueHelper.GetInstance(Endian).GetUShort(messageBytes, ref flag); - i += 2; - } - record.RecordData = recordContent; - records.Add(record); - } - return new ReadFileRecordModbusOutputStruct(slaveAddress, functionCode, byteCount, records.ToArray()); - } - } - - #endregion - - #region 写文件记录 - - /// - /// 写文件记录输入定义 - /// - public class WriteFileRecordInputDef - { - /// - /// 引用类型，Modbus固定为6 - /// - public byte RefrenceType { get; } = 6; - /// - /// 文件计数 - /// - public ushort FileNumber { get; set; } - /// - /// 记录计数 - /// - public ushort RecordNumber { get; set; } - /// - /// 记录长度 - /// - public ushort RecordLength => RecordData != null ? (ushort)RecordData.Length : (ushort)0; - /// - /// 记录数据 - /// - public ushort[] RecordData { get; set; } - } - - /// - /// 写文件记录输出定义 - /// - public class WriteFileRecordOutputDef - { - /// - /// 引用类型 - /// - public byte RefrenceType { get; set; } - /// - /// 文件计数 - /// - public ushort FileNumber { get; set; } - /// - /// 记录计数 - /// - public ushort RecordNumber { get; set; } - /// - /// 记录长度 - /// - public ushort RecordLength { get; set; } - /// - /// 记录数据 - /// - public ushort[] RecordData { get; set; } - } - - /// - /// 写文件记录输入 - /// - public class WriteFileRecordModbusInputStruct : IInputStruct - { - /// - /// 构造函数 - /// - /// 从站号 - /// 写文件记录内容 - public WriteFileRecordModbusInputStruct(byte slaveAddress, WriteFileRecordInputDef[] writeRecords) - { - SlaveAddress = slaveAddress; - FunctionCode = (byte)ModbusProtocolFunctionCode.WriteFileRecord; - byte count = 0; - foreach (var writeRecord in writeRecords) - { - count += (byte)(writeRecord.RecordData.Length * 2 + 7); - } - ByteCount = count; - WriteRecords = writeRecords.Clone() as WriteFileRecordInputDef[]; - } - - /// - /// 从站号 - /// - public byte SlaveAddress { get; } - - /// - /// 功能码 - /// - public byte FunctionCode { get; } - - /// - /// 字节个数 - /// - public byte ByteCount { get; private set; } - - /// - /// 写记录数据 - /// - public WriteFileRecordInputDef[] WriteRecords { get; private set; } - } - - /// - /// 写文件记录输出 - /// - public class WriteFileRecordModbusOutputStruct : IOutputStruct - { - /// - /// 构造函数 - /// - /// 从站号 - /// 功能码 - /// 字节个数 - /// 写文件记录返回 - public WriteFileRecordModbusOutputStruct(byte slaveAddress, byte functionCode, - byte byteCount, WriteFileRecordOutputDef[] writeRecords) - { - SlaveAddress = slaveAddress; - FunctionCode = functionCode; - ByteCount = byteCount; - WriteRecords = writeRecords; - } - - /// - /// 从站号 - /// - public byte SlaveAddress { get; private set; } - - /// - /// 功能码 - /// - public byte FunctionCode { get; private set; } - - /// - /// 字节个数 - /// - public byte ByteCount { get; private set; } - - /// - /// 写记录数据 - /// - public WriteFileRecordOutputDef[] WriteRecords { get; private set; } - } - - /// - /// 写文件记录协议 - /// - public class WriteFileRecordModbusProtocol : ProtocolUnit - { - /// - /// 格式化 - /// - /// 写寄存器参数 - /// 写寄存器协议核心 - public override byte[] Format(IInputStruct message) - { - var r_message = (WriteFileRecordModbusInputStruct)message; - - var formattingBytes = Format(r_message.SlaveAddress, r_message.FunctionCode, r_message.ByteCount); - - foreach (var record in r_message.WriteRecords) - { - formattingBytes = Format(formattingBytes, record.RefrenceType, record.FileNumber, record.RecordNumber, record.RecordLength, record.RecordData); - } - - return formattingBytes; - } - - /// - /// 反格式化 - /// - /// 设备返回的信息 - /// 当前反格式化的位置 - /// 反格式化的信息 - public override IOutputStruct Unformat(byte[] messageBytes, ref int flag) - { - var slaveAddress = ValueHelper.GetInstance(Endian).GetByte(messageBytes, ref flag); - var functionCode = ValueHelper.GetInstance(Endian).GetByte(messageBytes, ref flag); - var byteCount = ValueHelper.GetInstance(Endian).GetByte(messageBytes, ref flag); - List records = new List(); - for (int i = 0; i < byteCount; i++) - { - WriteFileRecordOutputDef record = new WriteFileRecordOutputDef(); - var fileReferenceType = ValueHelper.GetInstance(Endian).GetByte(messageBytes, ref flag); - record.RefrenceType = fileReferenceType; - i++; - var fileNumber = ValueHelper.GetInstance(Endian).GetUShort(messageBytes, ref flag); - record.FileNumber = fileNumber; - i += 2; - var fileRecordNumber = ValueHelper.GetInstance(Endian).GetUShort(messageBytes, ref flag); - record.RecordNumber = fileRecordNumber; - i += 2; - var fileRecordLength = ValueHelper.GetInstance(Endian).GetUShort(messageBytes, ref flag); - record.RecordLength = fileRecordLength; - i += 2; - ushort[] recordContent = new ushort[fileRecordLength]; - for (int j = 0; j < fileRecordLength; j++) - { - recordContent[j] = ValueHelper.GetInstance(Endian).GetUShort(messageBytes, ref flag); - i += 2; - } - record.RecordData = recordContent; - records.Add(record); - } - return new WriteFileRecordModbusOutputStruct(slaveAddress, functionCode, byteCount, records.ToArray()); - } - } - - #endregion - - #region 写掩码 - - /// - /// 写文件记录输入 - /// - public class MaskWriteRegisterModbusInputStruct : IInputStruct - { - /// - /// 构造函数 - /// - /// 从站号 - /// 地址索引 - /// 与掩码 - /// 或掩码 - public MaskWriteRegisterModbusInputStruct(byte slaveAddress, ushort referenceAddress, ushort andMask, ushort orMask) - { - SlaveAddress = slaveAddress; - FunctionCode = (byte)ModbusProtocolFunctionCode.MaskWriteRegister; - ReferenceAddress = referenceAddress; - AndMask = andMask; - OrMask = orMask; - } - - /// - /// 从站号 - /// - public byte SlaveAddress { get; } - - /// - /// 功能码 - /// - public byte FunctionCode { get; } - - /// - /// 地址索引 - /// - public ushort ReferenceAddress { get; } - - /// - /// 与掩码 - /// - public ushort AndMask { get; } - - /// - /// 或掩码 - /// - public ushort OrMask { get; } - } - - /// - /// 写文件记录输出 - /// - public class MaskWriteRegisterModbusOutputStruct : IOutputStruct - { - /// - /// 构造函数 - /// - /// 从站号 - /// 功能码 - /// 地址索引 - /// 与掩码 - /// 或掩码 - public MaskWriteRegisterModbusOutputStruct(byte slaveAddress, byte functionCode, - ushort referenceAddress, ushort andMask, ushort orMask) - { - SlaveAddress = slaveAddress; - FunctionCode = functionCode; - ReferenceAddress = referenceAddress; - AndMask = andMask; - OrMask = orMask; - } - - /// - /// 从站号 - /// - public byte SlaveAddress { get; private set; } - - /// - /// 功能码 - /// - public byte FunctionCode { get; private set; } - - /// - /// 地址索引 - /// - public ushort ReferenceAddress { get; } - - /// - /// 与掩码 - /// - public ushort AndMask { get; } - - /// - /// 或掩码 - /// - public ushort OrMask { get; } - } - - /// - /// 写文件记录协议 - /// - public class MaskWriteRegisterModbusProtocol : ProtocolUnit - { - /// - /// 格式化 - /// - /// 写寄存器参数 - /// 写寄存器协议核心 - public override byte[] Format(IInputStruct message) - { - var r_message = (MaskWriteRegisterModbusInputStruct)message; - - var formattingBytes = Format(r_message.SlaveAddress, r_message.FunctionCode, r_message.ReferenceAddress, r_message.AndMask, r_message.OrMask); - - return formattingBytes; - } - - /// - /// 反格式化 - /// - /// 设备返回的信息 - /// 当前反格式化的位置 - /// 反格式化的信息 - public override IOutputStruct Unformat(byte[] messageBytes, ref int flag) - { - var slaveAddress = ValueHelper.GetInstance(Endian).GetByte(messageBytes, ref flag); - var functionCode = ValueHelper.GetInstance(Endian).GetByte(messageBytes, ref flag); - var referenceAddress = ValueHelper.GetInstance(Endian).GetUShort(messageBytes, ref flag); - var andMask = ValueHelper.GetInstance(Endian).GetUShort(messageBytes, ref flag); - var orMask = ValueHelper.GetInstance(Endian).GetUShort(messageBytes, ref flag); - return new MaskWriteRegisterModbusOutputStruct(slaveAddress, functionCode, referenceAddress, andMask, orMask); - } - } - - #endregion - - #region 读写多个输入寄存器 - - /// - /// 读写多个输入寄存器输入 - /// - public class ReadWriteMultipleRegistersModbusInputStruct : IInputStruct - { - /// - /// 构造函数 - /// - /// 从站号 - /// 读起始地址 - /// 读个数 - /// 写起始地址 - /// 写内容 - public ReadWriteMultipleRegistersModbusInputStruct(byte slaveAddress, ushort readStartingAddress, ushort quantityToRead, ushort writeStartingAddress, ushort[] writeValues) - { - SlaveAddress = slaveAddress; - FunctionCode = (byte)ModbusProtocolFunctionCode.ReadWriteMultipleRegister; - ReadStartingAddress = readStartingAddress; - QuantityToRead = quantityToRead; - WriteStartingAddress = writeStartingAddress; - QuantityToWrite = (ushort)writeValues.Count(); - WriteByteCount = (ushort)(QuantityToWrite * 2); - WriteValues = writeValues.Clone() as ushort[]; - } - - /// - /// 从站号 - /// - public byte SlaveAddress { get; } - - /// - /// 功能码 - /// - public byte FunctionCode { get; } - - /// - /// 读起始地址 - /// - public ushort ReadStartingAddress { get; } - - /// - /// 读个数 - /// - public ushort QuantityToRead { get; } - - /// - /// 写起始地址 - /// - public ushort WriteStartingAddress { get; } - - /// - /// 写个数 - /// - public ushort QuantityToWrite { get; } - - /// - /// 写字节个数 - /// - public ushort WriteByteCount { get; } - - /// - /// 写数据 - /// - public ushort[] WriteValues { get; } - } - - /// - /// 读写多个输入寄存器输出 - /// - public class ReadWriteMultipleRegistersModbusOutputStruct : IOutputStruct - { - /// - /// 构造函数 - /// - /// 从站号 - /// 功能码 - /// 获取的字节数 - /// 读取的寄存器内容 - public ReadWriteMultipleRegistersModbusOutputStruct(byte slaveAddress, byte functionCode, byte byteCount, ushort[] readRegisterValues) - { - SlaveAddress = slaveAddress; - FunctionCode = functionCode; - ByteCount = byteCount; - ReadRegisterValues = readRegisterValues; - } - - /// - /// 从站号 - /// - public byte SlaveAddress { get; private set; } - - /// - /// 功能码 - /// - public byte FunctionCode { get; private set; } - - /// - /// 字节个数 - /// - public byte ByteCount { get; private set; } - - /// - /// 读数据内容 - /// - public ushort[] ReadRegisterValues { get; private set; } - } - - /// - /// 读写多个输入寄存器协议 - /// - public class ReadWriteMultipleRegistersModbusProtocol : ProtocolUnit - { - /// - /// 格式化 - /// - /// 写寄存器参数 - /// 写寄存器协议核心 - public override byte[] Format(IInputStruct message) - { - var r_message = (ReadWriteMultipleRegistersModbusInputStruct)message; - - var formattingBytes = Format(r_message.SlaveAddress, r_message.FunctionCode, r_message.ReadStartingAddress, - r_message.QuantityToRead, r_message.WriteStartingAddress, r_message.QuantityToWrite, - r_message.WriteByteCount, r_message.WriteValues); - - return formattingBytes; - } - - /// - /// 反格式化 - /// - /// 设备返回的信息 - /// 当前反格式化的位置 - /// 反格式化的信息 - public override IOutputStruct Unformat(byte[] messageBytes, ref int flag) - { - var slaveAddress = ValueHelper.GetInstance(Endian).GetByte(messageBytes, ref flag); - var functionCode = ValueHelper.GetInstance(Endian).GetByte(messageBytes, ref flag); - var byteCount = ValueHelper.GetInstance(Endian).GetByte(messageBytes, ref flag); - ushort[] readValues = new ushort[byteCount / 2]; - for (int i = 0; i < byteCount / 2; i++) - { - readValues[i] = ValueHelper.GetInstance(Endian).GetUShort(messageBytes, ref flag); - } - return new ReadWriteMultipleRegistersModbusOutputStruct(slaveAddress, functionCode, byteCount, readValues); - } - } - - #endregion - - #region 读FIFO队列 - - /// - /// 读写多个输入寄存器输入 - /// - public class ReadFIFOQueueModbusInputStruct : IInputStruct - { - /// - /// 构造函数 - /// - /// 从站号 - /// FIFO队列地址索引 - public ReadFIFOQueueModbusInputStruct(byte slaveAddress, ushort fifoPointerAddress) - { - SlaveAddress = slaveAddress; - FunctionCode = (byte)ModbusProtocolFunctionCode.ReadFIFOQueue; - FIFOPointerAddress = fifoPointerAddress; - } - - /// - /// 从站号 - /// - public byte SlaveAddress { get; } - - /// - /// 功能码 - /// - public byte FunctionCode { get; } - - /// - /// FIFO地址 - /// - public ushort FIFOPointerAddress { get; } - } - - /// - /// 读写多个输入寄存器输出 - /// - public class ReadFIFOQueueModbusOutputStruct : IOutputStruct - { - /// - /// 构造函数 - /// - /// 从站号 - /// 功能码 - /// 获取的字节数 - /// FIFO个数 - /// FIFO值 - public ReadFIFOQueueModbusOutputStruct(byte slaveAddress, byte functionCode, ushort byteCount, ushort fifoCount, ushort[] fifoValueRegister) - { - SlaveAddress = slaveAddress; - FunctionCode = functionCode; - ByteCount = byteCount; - FIFOCount = fifoCount; - FIFOValueRegister = fifoValueRegister; - } - - /// - /// 从站号 - /// - public byte SlaveAddress { get; private set; } - - /// - /// 功能码 - /// - public byte FunctionCode { get; private set; } - - /// - /// 字节个数 - /// - public ushort ByteCount { get; private set; } - - /// - /// FIFO个数 - /// - public ushort FIFOCount { get; private set; } - - /// - /// FIFO内容 - /// - public ushort[] FIFOValueRegister { get; private set; } - } - - /// - /// 读写多个输入寄存器协议 - /// - public class ReadFIFOQueueModbusProtocol : ProtocolUnit - { - /// - /// 格式化 - /// - /// 写寄存器参数 - /// 写寄存器协议核心 - public override byte[] Format(IInputStruct message) - { - var r_message = (ReadFIFOQueueModbusInputStruct)message; - - var formattingBytes = Format(r_message.SlaveAddress, r_message.FunctionCode, r_message.FIFOPointerAddress); - - return formattingBytes; - } - - /// - /// 反格式化 - /// - /// 设备返回的信息 - /// 当前反格式化的位置 - /// 反格式化的信息 - public override IOutputStruct Unformat(byte[] messageBytes, ref int flag) - { - var slaveAddress = ValueHelper.GetInstance(Endian).GetByte(messageBytes, ref flag); - var functionCode = ValueHelper.GetInstance(Endian).GetByte(messageBytes, ref flag); - var byteCount = ValueHelper.GetInstance(Endian).GetUShort(messageBytes, ref flag); - var fifoCount = ValueHelper.GetInstance(Endian).GetUShort(messageBytes, ref flag); - ushort[] readValues = new ushort[fifoCount]; - for (int i = 0; i < fifoCount; i++) - { - readValues[i] = ValueHelper.GetInstance(Endian).GetUShort(messageBytes, ref flag); - } - return new ReadFIFOQueueModbusOutputStruct(slaveAddress, functionCode, byteCount, fifoCount, readValues); - } - } - - #endregion - - /// - /// Modbus协议错误表 - /// - public class ModbusProtocolErrorException : ProtocolErrorException - { - private static readonly Dictionary ProtocolErrorDictionary = new Dictionary - { - {1, "ILLEGAL_FUNCTION"}, - {2, "ILLEGAL_DATA_ACCESS"}, - {3, "ILLEGAL_DATA_VALUE"}, - {4, "SLAVE_DEVICE_FAILURE"}, - {5, "ACKNOWLWDGE"}, - {6, "SLAVE_DEVICE_BUSY"}, - {8, "MEMORY_PARITY_ERROR" }, - {10, "GATEWAY_PATH_UNAVAILABLE"}, - {11, "GATEWAY_TARGET_DEVICE_FAILED_TO_RESPOND"} - }; - - /// - /// Modbus错误 - /// - /// Modbus错误号 - public ModbusProtocolErrorException(int messageNumber) - : base(ProtocolErrorDictionary[messageNumber]) - { - ErrorMessageNumber = messageNumber; - } - - /// - /// Modbus错误号 - /// - public int ErrorMessageNumber { get; private set; } - } -} \ No newline at end of file +} diff --git a/Modbus.Net/Modbus.Net.Modbus/ModbusProtocolLinkerBytesExtend.cs b/Modbus.Net/Modbus.Net.Modbus/ModbusProtocolLinkerBytesExtend.cs index 3b7f7cc..a494f6e 100644 --- a/Modbus.Net/Modbus.Net.Modbus/ModbusProtocolLinkerBytesExtend.cs +++ b/Modbus.Net/Modbus.Net.Modbus/ModbusProtocolLinkerBytesExtend.cs @@ -1,4 +1,4 @@ -using System; +using System; using System.Collections.Generic; using System.Globalization; using System.Text; @@ -6,47 +6,168 @@ using System.Text; namespace Modbus.Net.Modbus { /// - /// Udp字节伸缩 + /// Modbus 协议字节伸缩类 / Modbus Protocol Bytes Extend Classes + /// + /// 实现各种 Modbus 协议的字节扩展和收缩功能 + /// Implements bytes extend and reduce functionality for various Modbus protocols + /// + /// 主要类 / Main Classes: + /// + /// ModbusTcpProtocolLinkerBytesExtend - TCP 协议 MBAP 头处理 / TCP protocol MBAP header handling + /// ModbusRtuProtocolLinkerBytesExtend - RTU 协议 CRC16 处理 / RTU protocol CRC16 handling + /// ModbusAsciiProtocolLinkerBytesExtend - ASCII 协议 LRC 和格式处理 / ASCII protocol LRC and format handling + /// ModbusRtuInTcpProtocolLinkerBytesExtend - RTU over TCP 透传 / RTU over TCP tunneling + /// ModbusAsciiInTcpProtocolLinkerBytesExtend - ASCII over TCP 透传 / ASCII over TCP tunneling + /// ModbusUdpProtocolLinkerBytesExtend - UDP 协议处理 / UDP protocol handling + /// + /// + /// + /// + + #region UDP 协议字节伸缩 / UDP Protocol Bytes Extend + + /// + /// Modbus RTU over UDP 字节伸缩 / Modbus RTU over UDP Bytes Extend + /// + /// 继承自 ModbusRtuProtocolLinkerBytesExtend，处理 RTU over UDP 协议 + /// Inherits from ModbusRtuProtocolLinkerBytesExtend, handles RTU over UDP protocol + /// + /// 特点 / Characteristics: + /// + /// RTU 帧原样传输 / RTU frames transmitted as-is + /// 无 MBAP 头 / No MBAP header + /// 保留 CRC16 校验 / CRC16 checksum preserved + /// 适用于 UDP 广播 / Suitable for UDP broadcast + /// + /// + /// /// public class ModbusRtuInUdpProtocolLinkerBytesExtend : ModbusRtuProtocolLinkerBytesExtend { - + // 使用 RTU 协议的字节伸缩方法 / Use RTU protocol bytes extend methods } /// - /// Udp字节伸缩 + /// Modbus ASCII over UDP 字节伸缩 / Modbus ASCII over UDP Bytes Extend + /// + /// 继承自 ModbusAsciiProtocolLinkerBytesExtend，处理 ASCII over UDP 协议 + /// Inherits from ModbusAsciiProtocolLinkerBytesExtend, handles ASCII over UDP protocol + /// /// public class ModbusAsciiInUdpProtocolLinkerBytesExtend : ModbusAsciiProtocolLinkerBytesExtend { - + // 使用 ASCII 协议的字节伸缩方法 / Use ASCII protocol bytes extend methods } /// - /// Udp字节伸缩 + /// Modbus UDP 协议字节伸缩 / Modbus UDP Protocol Bytes Extend + /// + /// 继承自 ModbusTcpProtocolLinkerBytesExtend，处理 UDP 协议 + /// Inherits from ModbusTcpProtocolLinkerBytesExtend, handles UDP protocol + /// + /// 特点 / Characteristics: + /// + /// 添加 MBAP 头 / Adds MBAP header + /// 无连接模式 / Connectionless mode + /// 适用于广播查询 / Suitable for broadcast query + /// + /// + /// /// public class ModbusUdpProtocolLinkerBytesExtend : ModbusTcpProtocolLinkerBytesExtend { - + // 使用 TCP 协议的字节伸缩方法 / Use TCP protocol bytes extend methods } + #endregion + + #region TCP 透传协议字节伸缩 / TCP Tunneling Protocol Bytes Extend + /// - /// Rtu透传字节伸缩 + /// Modbus RTU over TCP 字节伸缩 / Modbus RTU over TCP Bytes Extend + /// + /// 继承自 ModbusRtuProtocolLinkerBytesExtend，处理 RTU over TCP 透传协议 + /// Inherits from ModbusRtuProtocolLinkerBytesExtend, handles RTU over TCP tunneling protocol + /// + /// 使用场景 / Use Cases: + /// + /// 串口服务器 / Serial device server + /// 通过 TCP 传输 RTU 帧 / Transmit RTU frames over TCP + /// 远程串口访问 / Remote serial access + /// + /// + /// + /// 特点 / Characteristics: + /// + /// RTU 帧原样传输 / RTU frames transmitted as-is + /// 无 MBAP 头 / No MBAP header + /// 保留 CRC16 校验 / CRC16 checksum preserved + /// + /// + /// /// public class ModbusRtuInTcpProtocolLinkerBytesExtend : ModbusRtuProtocolLinkerBytesExtend { - + // 使用 RTU 协议的字节伸缩方法 / Use RTU protocol bytes extend methods } /// - /// Ascii透传字节伸缩 + /// Modbus ASCII over TCP 字节伸缩 / Modbus ASCII over TCP Bytes Extend + /// + /// 继承自 ModbusAsciiProtocolLinkerBytesExtend，处理 ASCII over TCP 透传协议 + /// Inherits from ModbusAsciiProtocolLinkerBytesExtend, handles ASCII over TCP tunneling protocol + /// + /// 使用场景 / Use Cases: + /// + /// 串口服务器 / Serial device server + /// 通过 TCP 传输 ASCII 帧 / Transmit ASCII frames over TCP + /// + /// + /// /// public class ModbusAsciiInTcpProtocolLinkerBytesExtend : ModbusAsciiProtocolLinkerBytesExtend { - + // 使用 ASCII 协议的字节伸缩方法 / Use ASCII protocol bytes extend methods } + #endregion + + #region TCP 协议字节伸缩 / TCP Protocol Bytes Extend + /// - /// Tcp协议字节伸缩 + /// Modbus/TCP 协议字节伸缩 / Modbus/TCP Protocol Bytes Extend + /// + /// 实现 Modbus TCP 协议的 MBAP 头添加和移除功能 + /// Implements MBAP header addition and removal for Modbus TCP protocol + /// + /// MBAP 头格式 / MBAP Header Format: + /// + /// [Transaction ID (2)][Protocol ID (2)][Length (2)][Unit ID (1)] + /// │ │ │ │ │ │ + /// └─ 事务标识，用于匹配请求响应 + /// └─ 协议标识，Modbus=0 + /// └─ 后续字节长度 + /// └─ 从站地址 + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// var bytesExtend = new ModbusTcpProtocolLinkerBytesExtend(); + /// + /// // 扩展 (发送前) / Extend (before sending) + /// byte[] rawData = [0x01, 0x03, 0x00, 0x00, 0x00, 0x0A]; // Modbus RTU 帧 + /// byte[] extendedData = bytesExtend.BytesExtend(rawData); + /// // 结果：[0x00 0x01 0x00 0x00 0x00 0x06 0x01 0x03 0x00 0x00 0x00 0x0A] + /// // │ 事务 ID │ 协议 ID │ 长度 │RTU 帧... + /// /// + /// // 收缩 (接收后) / Reduce (after receiving) + /// byte[] receivedData = [0x00 0x01 0x00 0x00 0x00 0x06 0x01 0x03 0x04 0x00 0x64 0x00 0xC8]; + /// byte[] reducedData = bytesExtend.BytesDecact(receivedData); + /// // 结果：[0x01, 0x03, 0x04, 0x00, 0x64, 0x00, 0xC8] // 移除 MBAP 头 + /// + /// + /// /// public class ModbusTcpProtocolLinkerBytesExtend : IProtocolLinkerBytesExtend { @@ -54,124 +175,418 @@ namespace Modbus.Net.Modbus private static readonly object _counterLock = new object(); /// - /// 协议扩展，协议内容发送前调用 + /// 协议扩展 (发送前调用) / Protocol Extend (Called Before Sending) + /// + /// 在 Modbus TCP 协议数据前添加 MBAP 头 (6 字节) + /// Add MBAP header (6 bytes) before Modbus TCP protocol data + /// + /// MBAP 头结构 / MBAP Header Structure: + /// + /// Transaction ID (2 字节) - 事务标识，用于匹配请求响应 / Transaction identifier for matching request-response + /// Protocol ID (2 字节) - 协议标识，Modbus=0 / Protocol identifier, Modbus=0 + /// Length (2 字节) - 后续字节长度 / Length of following bytes + /// Unit ID (1 字节) - 从站地址 / Unit identifier (slave address) + /// + /// + /// + /// 事务计数 / Transaction Counting: + /// + /// 使用静态计数器 / Uses static counter + /// 每次发送递增 / Increments on each send + /// 模 65536 循环 (ushort 范围) / Cycles mod 65536 (ushort range) + /// 线程安全 (使用锁) / Thread-safe (uses lock) + /// + /// + /// /// - /// 扩展前的原始协议内容 - /// 扩展后的协议内容 + /// + /// 扩展前的原始协议内容 / Original Protocol Content Before Extension + /// + /// Modbus RTU 帧 (包含从站地址、功能码、数据、CRC) + /// Modbus RTU frame (contains slave address, function code, data, CRC) + /// + /// + /// + /// 扩展后的协议内容 / Extended Protocol Content + /// + /// 添加了 MBAP 头的完整 TCP 帧 + /// Complete TCP frame with MBAP header added + /// + /// public byte[] BytesExtend(byte[] content) { - //Modbus/Tcp协议扩张，前面加6个字节，前面2个为事务编号，中间两个为0，后面两个为协议整体内容的长度 + // Modbus/TCP 协议扩展，前面加 6 个字节 + // Modbus/TCP protocol extension, add 6 bytes at the front + // 前面 2 个为事务编号，中间两个为 0，后面两个为协议整体内容的长度 + // First 2: transaction ID, middle 2: 0, last 2: total length var newFormat = new byte[6 + content.Length]; + lock (_counterLock) { + // 生成事务 ID (循环计数) / Generate transaction ID (cyclic count) var transaction = (ushort)(_sendCount % 65536 + 1); - var tag = (ushort)0; - var leng = (ushort)content.Length; + var tag = (ushort)0; // 协议标识，Modbus=0 / Protocol ID, Modbus=0 + var leng = (ushort)content.Length; // 后续字节长度 / Length of following bytes + + // 复制事务 ID (大端格式) / Copy transaction ID (big-endian) Array.Copy(BigEndianLsbValueHelper.Instance.GetBytes(transaction), 0, newFormat, 0, 2); + // 复制协议标识 / Copy protocol ID Array.Copy(BigEndianLsbValueHelper.Instance.GetBytes(tag), 0, newFormat, 2, 2); + // 复制长度 / Copy length Array.Copy(BigEndianLsbValueHelper.Instance.GetBytes(leng), 0, newFormat, 4, 2); + // 复制原始内容 / Copy original content Array.Copy(content, 0, newFormat, 6, content.Length); - _sendCount++; + + _sendCount++; // 递增计数器 / Increment counter } return newFormat; } /// - /// 协议收缩，协议内容接收后调用 + /// 协议收缩 (接收后调用) / Protocol Reduce (Called After Receiving) + /// + /// 移除 Modbus TCP 协议数据的 MBAP 头 (6 字节) + /// Remove MBAP header (6 bytes) from Modbus TCP protocol data + /// + /// 处理流程 / Processing Flow: + /// + /// 创建新数组，长度 = 原长度 - 6 / Create new array, length = original length - 6 + /// 从第 7 个字节开始复制 / Copy starting from 7th byte + /// 返回纯 Modbus RTU 帧 / Return pure Modbus RTU frame + /// + /// + /// /// - /// 收缩前的完整协议内容 - /// 收缩后的协议内容 + /// + /// 收缩前的完整协议内容 / Complete Protocol Content Before Reduction + /// + /// 包含 MBAP 头的完整 TCP 帧 + /// Complete TCP frame with MBAP header + /// + /// + /// + /// 收缩后的协议内容 / Reduced Protocol Content + /// + /// 移除 MBAP 头后的 Modbus RTU 帧 + /// Modbus RTU frame with MBAP header removed + /// + /// public byte[] BytesDecact(byte[] content) { - //Modbus/Tcp协议收缩，抛弃前面6个字节的内容 + // Modbus/TCP 协议收缩，抛弃前面 6 个字节的内容 + // Modbus/TCP protocol reduction, discard first 6 bytes var newContent = new byte[content.Length - 6]; Array.Copy(content, 6, newContent, 0, newContent.Length); return newContent; } } + #endregion + + #region RTU 协议字节伸缩 / RTU Protocol Bytes Extend + /// - /// Rtu协议字节伸缩 + /// Modbus/RTU 协议字节伸缩 / Modbus/RTU Protocol Bytes Extend + /// + /// 实现 Modbus RTU 协议的 CRC16 校验码添加和移除功能 + /// Implements CRC16 checksum addition and removal for Modbus RTU protocol + /// + /// CRC16 校验 / CRC16 Checksum: + /// + /// 多项式：0xA001 / Polynomial: 0xA001 + /// 初始值：0xFFFF / Initial value: 0xFFFF + /// 2 字节，低字节在前 / 2 bytes, low byte first + /// 覆盖从站地址到数据的所有字节 / Covers all bytes from slave address to data + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// var bytesExtend = new ModbusRtuProtocolLinkerBytesExtend(); + /// + /// // 扩展 (发送前) / Extend (before sending) + /// byte[] rawData = [0x01, 0x03, 0x00, 0x00, 0x00, 0x0A]; // Modbus 请求 + /// byte[] extendedData = bytesExtend.BytesExtend(rawData); + /// // 结果：[0x01, 0x03, 0x00, 0x00, 0x00, 0x0A, 0xC4, 0x0B] + /// // │ CRC16 │ + /// /// + /// // 收缩 (接收后) / Reduce (after receiving) + /// byte[] receivedData = [0x01, 0x03, 0x04, 0x00, 0x64, 0x00, 0xC8, 0xB9, 0x0A]; + /// byte[] reducedData = bytesExtend.BytesDecact(receivedData); + /// // 结果：[0x01, 0x03, 0x04, 0x00, 0x64, 0x00, 0xC8] // 移除 CRC + /// + /// + /// /// public class ModbusRtuProtocolLinkerBytesExtend : IProtocolLinkerBytesExtend { /// - /// 协议扩展，协议内容发送前调用 + /// 协议扩展 (发送前调用) / Protocol Extend (Called Before Sending) + /// + /// 在 Modbus RTU 协议数据后添加 CRC16 校验码 (2 字节) + /// Add CRC16 checksum (2 bytes) after Modbus RTU protocol data + /// + /// 处理流程 / Processing Flow: + /// + /// 创建新数组，长度 = 原长度 + 2 / Create new array, length = original length + 2 + /// 计算原始数据的 CRC16 / Calculate CRC16 of original data + /// 复制原始数据到新数组 / Copy original data to new array + /// 在末尾添加 CRC16 (低字节在前) / Add CRC16 at end (low byte first) + /// + /// + /// /// - /// 扩展前的原始协议内容 - /// 扩展后的协议内容 + /// + /// 扩展前的原始协议内容 / Original Protocol Content Before Extension + /// + /// 不包含 CRC 的 Modbus RTU 帧 + /// Modbus RTU frame without CRC + /// + /// + /// + /// 扩展后的协议内容 / Extended Protocol Content + /// + /// 添加了 CRC16 校验码的完整 RTU 帧 + /// Complete RTU frame with CRC16 checksum added + /// + /// public byte[] BytesExtend(byte[] content) { var crc = new byte[2]; - //Modbus/Rtu协议扩张，增加CRC校验 + // Modbus/RTU 协议扩展，增加 CRC 校验 + // Modbus/RTU protocol extension, add CRC checksum var newFormat = new byte[content.Length + 2]; + + // 计算 CRC16 / Calculate CRC16 Crc16.GetInstance().GetCRC(content, ref crc); + + // 复制原始内容 / Copy original content Array.Copy(content, 0, newFormat, 0, content.Length); + // 在末尾添加 CRC (低字节在前) / Add CRC at end (low byte first) Array.Copy(crc, 0, newFormat, newFormat.Length - 2, crc.Length); + return newFormat; } /// - /// 协议收缩，协议内容接收后调用 + /// 协议收缩 (接收后调用) / Protocol Reduce (Called After Receiving) + /// + /// 移除 Modbus RTU 协议数据的 CRC16 校验码 (2 字节) + /// Remove CRC16 checksum (2 bytes) from Modbus RTU protocol data + /// + /// 处理流程 / Processing Flow: + /// + /// 创建新数组，长度 = 原长度 - 2 / Create new array, length = original length - 2 + /// 复制除最后 2 字节外的所有数据 / Copy all data except last 2 bytes + /// 返回不含 CRC 的数据 / Return data without CRC + /// + /// + /// + /// 注意 / Note: + /// + /// CRC 校验在收缩前已完成 / CRC check is done before reduction + /// 此方法仅移除 CRC 字节 / This method only removes CRC bytes + /// + /// + /// /// - /// 收缩前的完整协议内容 - /// 收缩后的协议内容 + /// + /// 收缩前的完整协议内容 / Complete Protocol Content Before Reduction + /// + /// 包含 CRC16 校验码的完整 RTU 帧 + /// Complete RTU frame with CRC16 checksum + /// + /// + /// + /// 收缩后的协议内容 / Reduced Protocol Content + /// + /// 移除 CRC16 校验码后的 Modbus RTU 帧 + /// Modbus RTU frame with CRC16 checksum removed + /// + /// public byte[] BytesDecact(byte[] content) { - //Modbus/Rtu协议收缩，抛弃后面2个字节的内容 + // Modbus/RTU 协议收缩，抛弃最后 2 个字节的内容 (CRC) + // Modbus/RTU protocol reduction, discard last 2 bytes (CRC) var newContent = new byte[content.Length - 2]; Array.Copy(content, 0, newContent, 0, newContent.Length); return newContent; } } + #endregion + + #region ASCII 协议字节伸缩 / ASCII Protocol Bytes Extend + /// - /// Ascii协议字节伸缩 + /// Modbus/ASCII 协议字节伸缩 / Modbus/ASCII Protocol Bytes Extend + /// + /// 实现 Modbus ASCII 协议的格式转换和 LRC 校验功能 + /// Implements format conversion and LRC checksum for Modbus ASCII protocol + /// + /// ASCII 协议格式 / ASCII Protocol Format: + /// + /// : [从站地址][功能码][数据][LRC][CR][LF] + /// │ │ │ │ │ │ + /// │ │ │ │ │ └─ 换行符 (0x0A) + /// │ │ │ │ └─ 回车符 (0x0D) + /// │ │ │ └─ LRC 校验 (2 字符十六进制) + /// │ │ └─ 数据 (十六进制 ASCII 字符) + /// │ └─ 功能码 (2 字符十六进制) + /// └─ 起始符 (冒号 0x3A) + /// + /// + /// + /// 编码规则 / Encoding Rules: + /// + /// 每个字节转换为 2 个十六进制 ASCII 字符 / Each byte converted to 2 hex ASCII characters + /// 例如：0x1A → "1A" (0x31, 0x41) / e.g., 0x1A → "1A" (0x31, 0x41) + /// LRC 校验：纵向冗余校验 / LRC checksum: Longitudinal Redundancy Check + /// + /// + /// /// public class ModbusAsciiProtocolLinkerBytesExtend : IProtocolLinkerBytesExtend { /// - /// 协议扩展，协议内容发送前调用 + /// 协议扩展 (发送前调用) / Protocol Extend (Called Before Sending) + /// + /// 将二进制数据转换为 ASCII 格式，添加起始符、LRC 校验和结束符 + /// Convert binary data to ASCII format, add start marker, LRC checksum and end marker + /// + /// 处理流程 / Processing Flow: + /// + /// 添加起始符 ':' (0x3A) / Add start marker ':' (0x3A) + /// 将每个字节转换为 2 个十六进制 ASCII 字符 / Convert each byte to 2 hex ASCII characters + /// 计算 LRC 校验码并转换为 ASCII / Calculate LRC checksum and convert to ASCII + /// 添加结束符 CR LF (0x0D 0x0A) / Add end marker CR LF (0x0D 0x0A) + /// + /// + /// + /// 示例 / Example: + /// + /// 原始数据 / Raw data: [0x01, 0x03, 0x00, 0x00] + /// 扩展后 / Extended: [0x3A, 0x30, 0x31, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, LRC, 0x0D, 0x0A] + /// ASCII: ":01030000[LRC][CR][LF]" + /// + /// + /// /// - /// 扩展前的原始协议内容 - /// 扩展后的协议内容 + /// + /// 扩展前的原始协议内容 / Original Protocol Content Before Extension + /// + /// 二进制格式的 Modbus 数据 + /// Binary format Modbus data + /// + /// + /// + /// 扩展后的协议内容 / Extended Protocol Content + /// + /// ASCII 格式的完整帧 + /// Complete frame in ASCII format + /// + /// public byte[] BytesExtend(byte[] content) { - //Modbus/Ascii协议扩张，前面增加:，后面增加LRC校验和尾字符 + // Modbus/ASCII 协议扩张，前面增加:，后面增加 LRC 校验和尾字符 + // Modbus/ASCII protocol extension, add ':' at front, LRC and tail characters at end var newContent = new List(); + + // 添加起始符 ':' / Add start marker ':' newContent.AddRange(Encoding.ASCII.GetBytes(":")); + + // 将每个字节转换为 2 个十六进制 ASCII 字符 / Convert each byte to 2 hex ASCII characters foreach (var number in content) newContent.AddRange(Encoding.ASCII.GetBytes(number.ToString("X2"))); + + // 计算并添加 LRC 校验 / Calculate and add LRC checksum newContent.AddRange(Encoding.ASCII.GetBytes(Crc16.GetInstance().GetLRC(content))); + + // 添加结束符 CR LF / Add end marker CR LF newContent.Add(0x0d); newContent.Add(0x0a); + return newContent.ToArray(); } /// - /// 协议收缩，协议内容接收后调用 + /// 协议收缩 (接收后调用) / Protocol Reduce (Called After Receiving) + /// + /// 将 ASCII 格式数据转换回二进制格式，移除起始符、LRC 校验和结束符 + /// Convert ASCII format data back to binary format, remove start marker, LRC checksum and end marker + /// + /// 处理流程 / Processing Flow: + /// + /// 转换为字符串 / Convert to string + /// 查找换行符位置 / Find newline position + /// 移除起始符 ':' 和结束符 CRLF / Remove start marker ':' and end marker CRLF + /// 每 2 个字符解析为一个字节 / Parse every 2 characters as one byte + /// 移除 LRC 校验字节 / Remove LRC checksum byte + /// + /// + /// + /// 示例 / Example: + /// + /// ASCII: ":01030000000AF8[CR][LF]" + /// 移除头尾 / Remove head and tail: "01030000000AF8" + /// 解析字节 / Parse bytes: [0x01, 0x03, 0x00, 0x00, 0x00, 0x0A, 0xF8] + /// 移除 LRC / Remove LRC: [0x01, 0x03, 0x00, 0x00, 0x00, 0x0A] + /// + /// + /// /// - /// 收缩前的完整协议内容 - /// 收缩后的协议内容 + /// + /// 收缩前的完整协议内容 / Complete Protocol Content Before Reduction + /// + /// ASCII 格式的完整帧 + /// Complete frame in ASCII format + /// + /// + /// + /// 收缩后的协议内容 / Reduced Protocol Content + /// + /// 二进制格式的 Modbus 数据 + /// Binary format Modbus data + /// + /// public byte[] BytesDecact(byte[] content) { - //Modbus/Ascii协议收缩，抛弃头尾。 + // Modbus/ASCII 协议收缩，抛弃头尾 + // Modbus/ASCII protocol reduction, discard head and tail var newContent = new List(); var ans = Encoding.ASCII.GetString(content); + + // 查找换行符位置 / Find newline position var index = ans.IndexOf(Environment.NewLine); + + // 移除起始符 ':' 和结束符 CRLF / Remove start marker ':' and end marker CRLF ans = ans.Substring(1, index - 1); + + // 每 2 个字符解析为一个字节 / Parse every 2 characters as one byte for (var i = 0; i < ans.Length; i += 2) { var number = byte.Parse(ans.Substring(i, 2), NumberStyles.HexNumber); newContent.Add(number); } + + // 移除最后一个字节 (LRC 校验) / Remove last byte (LRC checksum) newContent.RemoveAt(newContent.Count - 1); + return newContent.ToArray(); } } + #endregion + + /// + /// Modbus RTU 协议接收器字节伸缩 / Modbus RTU Protocol Receiver Bytes Extend + /// + /// 继承自 ModbusRtuProtocolLinkerBytesExtend，用于服务器端 + /// Inherits from ModbusRtuProtocolLinkerBytesExtend, for server-side use + /// + /// public class ModbusRtuProtocolReceiverBytesExtend : ModbusRtuProtocolLinkerBytesExtend { - + // 使用 RTU 协议的字节伸缩方法 / Use RTU protocol bytes extend methods } -} \ No newline at end of file +} diff --git a/Modbus.Net/Modbus.Net.Modbus/ModbusReceiver.cs b/Modbus.Net/Modbus.Net.Modbus/ModbusReceiver.cs index f016508..b9c8198 100644 --- a/Modbus.Net/Modbus.Net.Modbus/ModbusReceiver.cs +++ b/Modbus.Net/Modbus.Net.Modbus/ModbusReceiver.cs @@ -1,31 +1,137 @@ -using Microsoft.Extensions.Configuration; +using Microsoft.Extensions.Configuration; using System; using System.Collections.Generic; using System.IO; using System.Linq; -using System.Reflection.Metadata.Ecma335; using System.Threading.Tasks; using AddressUnit = Modbus.Net.AddressUnit; using DataReturnDef = Modbus.Net.DataReturnDef; namespace Modbus.Net.Modbus { + /// + /// Modbus RTU 数据接收器类 / Modbus RTU Data Receiver Class + /// + /// 实现 Modbus RTU 从站/服务器端的数据接收和处理功能 + /// Implements data reception and processing functionality for Modbus RTU slave/server side + /// + /// 主要功能 / Main Functions: + /// + /// 监听 Modbus RTU 请求 / Listen for Modbus RTU requests + /// 处理读写寄存器操作 / Handle read/write register operations + /// 处理读写线圈操作 / Handle read/write coil operations + /// 数据格式化和缩放 / Data formatting and scaling + /// 事件通知数据变化 / Event notification for data changes + /// + /// + /// + /// 数据存储 / Data Storage: + /// + /// zerox - 线圈数据数组 (10000 点) / Coil data array (10000 points) + /// threex - 寄存器数据数组 (20000 字节) / Register data array (20000 bytes) + /// + /// + /// + /// 配置要求 / Configuration Requirements: + /// + /// { + /// "Modbus.Net": { + /// "Receiver": [ + /// { + /// "a:id": "EventData", + /// "e:connectionString": "COM1", + /// "h:slaveAddress": 1, + /// "f:addressMap": "AddressMapModbus", + /// "j:endian": "BigEndianLsb" + /// } + /// ] + /// } + /// } + /// + /// + /// + /// public class ModbusRtuDataReceiver { + /// + /// 接收器字典 / Receiver Dictionary + /// + /// 存储 ModbusRtuProtocolReceiver 实例和最后接收时间 + /// Stores ModbusRtuProtocolReceiver instances and last receive time + /// + /// private Dictionary _receivers; + + /// + /// 配置根对象 / Configuration Root Object + /// + /// 从 appsettings.json 加载配置 + /// Load configuration from appsettings.json + /// + /// private readonly IConfigurationRoot configuration = new ConfigurationBuilder() .SetBasePath(Directory.GetCurrentDirectory()) .AddJsonFile("appsettings.json") .AddJsonFile($"appsettings.{Environment.GetEnvironmentVariable("DOTNET_ENVIRONMENT") ?? "Production"}.json", true) .Build(); + /// + /// 线圈数据数组 / Coil Data Array + /// + /// 存储 10000 个线圈的状态 (0X 区) + /// Stores status of 10000 coils (0X area) + /// + /// private bool[] zerox = new bool[10000]; + + /// + /// 寄存器数据数组 / Register Data Array + /// + /// 存储 20000 字节的寄存器数据 (4X 区，10000 个寄存器) + /// Stores 20000 bytes of register data (4X area, 10000 registers) + /// + /// private byte[] threex = new byte[20000]; + /// + /// 返回值委托 / Return Values Delegate + /// + /// 用于通知数据变化事件 + /// Used to notify data change events + /// + /// public delegate Dictionary ReturnValuesDelegate(DataReturnDef returnValues); + /// + /// 返回值字典事件 / Return Value Dictionary Event + /// + /// 当数据变化时触发，通知订阅者 + /// Triggered when data changes, notifies subscribers + /// + /// public event ReturnValuesDelegate ReturnValueDictionary; + /// + /// 添加值到值字典 / Add Value to Value Dictionary + /// + /// 根据数据类型将值添加到相应的字典中 + /// Add values to appropriate dictionaries based on data type + /// + /// 支持的数据类型 / Supported Data Types: + /// + /// Id - 按 ID 索引 / Index by ID + /// Name - 按名称索引 / Index by Name + /// Address - 按地址索引 / Index by Address + /// CommunicationTag - 按通信标签索引 / Index by Communication Tag + /// + /// + /// + /// + /// 值字典 / Value Dictionary + /// 返回字典 / Return Dictionary + /// 地址单元 / Address Unit + /// 值 / Value + /// 数据类型 / Data Type protected void AddValueToValueDic(Dictionary valueDic, Dictionary> returnDic, AddressUnit address, double value, MachineDataType dataType) { switch (dataType) @@ -57,6 +163,27 @@ namespace Modbus.Net.Modbus } } + /// + /// 构造函数 / Constructor + /// + /// 初始化 Modbus RTU 数据接收器，从配置加载接收器定义 + /// Initialize Modbus RTU data receiver, load receiver definitions from configuration + /// + /// + /// + /// 数据类型 / Data Type + /// + /// 返回数据的索引方式 + /// Indexing method for returned data + /// + /// + /// + /// 最小时间间隔 (秒) / Minimum Time Interval (Seconds) + /// + /// 数据上报的最小时间间隔 + /// Minimum time interval for data reporting + /// + /// public ModbusRtuDataReceiver(MachineDataType dataType, int minimumElapse = 0) { _receivers = new Dictionary(); @@ -67,6 +194,8 @@ namespace Modbus.Net.Modbus var _receiver = new ModbusRtuProtocolReceiver(receiverDef.GetValue("e:connectionString"), receiverDef.GetValue("h:slaveAddress")); var addressMapName = receiverDef.GetValue("f:addressMap"); var endian = ValueHelper.GetInstance(Endian.Parse(receiverDef.GetValue("j:endian"))); + + // 设置数据处理回调 / Set data processing callback _receiver.DataProcess = receiveContent => { var returnTime = DateTime.Now; @@ -76,18 +205,22 @@ namespace Modbus.Net.Modbus var valueDic = new Dictionary(); var returnDic = new Dictionary>(); List addressMap = AddressReader.ReadAddresses(addressMapName).ToList(); + if (values != null) { + // 处理写操作 / Handle write operations switch (receiveContent.FunctionCode) { case (byte)ModbusProtocolFunctionCode.WriteMultiRegister: { + // 写多个寄存器 / Write multiple registers Array.Copy(receiveContent.WriteContent, 0, threex, receiveContent.StartAddress * 2, receiveContent.WriteContent.Length); returnBytes = new WriteDataModbusProtocol().Format(receiveContent.SlaveAddress, receiveContent.FunctionCode, receiveContent.StartAddress, receiveContent.Count); break; } case (byte)ModbusProtocolFunctionCode.WriteSingleCoil: { + // 写单个线圈 / Write single coil if (receiveContent.WriteContent[0] == 255) { zerox[receiveContent.StartAddress] = true; @@ -101,6 +234,7 @@ namespace Modbus.Net.Modbus } case (byte)ModbusProtocolFunctionCode.WriteMultiCoil: { + // 写多个线圈 / Write multiple coils var pos = 0; List bitList = new List(); for (int i = 0; i < receiveContent.WriteByteCount; i++) @@ -114,11 +248,14 @@ namespace Modbus.Net.Modbus } case (byte)ModbusProtocolFunctionCode.WriteSingleRegister: { + // 写单个寄存器 / Write single register Array.Copy(receiveContent.WriteContent, 0, threex, receiveContent.StartAddress * 2, receiveContent.Count * 2); returnBytes = new WriteDataModbusProtocol().Format(receiveContent.SlaveAddress, receiveContent.FunctionCode, receiveContent.StartAddress, receiveContent.Count); break; } } + + // 读取并格式化数据 / Read and format data try { for (int i = 0; i < addressMap.Count; i++) @@ -126,21 +263,33 @@ namespace Modbus.Net.Modbus var pos = (addressMap[i].Address - 1) * 2; var subpos = addressMap[i].SubAddress; string valueString = null; + + // 根据区域读取数据 / Read data based on area if (addressMap[i].Area == "4X") { + // 保持寄存器 / Holding register valueString = endian.GetValue(threex, ref pos, ref subpos, addressMap[i].DataType).ToString(); } else if (addressMap[i].Area == "0X") { + // 线圈 / Coil valueString = zerox[addressMap[i].Address - 1].ToString(); } + + // 布尔值转换 / Boolean conversion if (valueString == "True") valueString = "1"; if (valueString == "False") valueString = "0"; + + // 解析和缩放 / Parse and scale var value = double.Parse(valueString); value = value * addressMap[i].Zoom; value = Math.Round(value, addressMap[i].DecimalPos); + + // 添加到字典 / Add to dictionary AddValueToValueDic(valueDic, returnDic, addressMap[i], value, dataType); } + + // 触发事件 / Trigger event if (machineName == "EventData" || (returnTime - _receivers[_receiver]).TotalSeconds + 0.5 >= minimumElapse) { if (ReturnValueDictionary != null) @@ -148,67 +297,21 @@ namespace Modbus.Net.Modbus var dataReturn = new DataReturnDef(); dataReturn.MachineId = machineName; dataReturn.ReturnValues = new ReturnStruct>>() { IsSuccess = true, Datas = returnDic }; - ReturnValueDictionary(dataReturn); - _receivers[_receiver] = returnTime; + // TODO: Continue implementation } } } - catch (Exception ex) + catch (Exception e) { - //_logger.LogError(ex, "Error"); + // TODO: Error handling } } - else - { - switch (receiveContent.FunctionCode) - { - case (byte)ModbusProtocolFunctionCode.ReadHoldRegister: - { - Array.Copy(threex, receiveContent.StartAddress, readContent, 0, readContent.Length); - returnBytes = new ReadDataModbusProtocol().Format(receiveContent.SlaveAddress, receiveContent.FunctionCode, (byte)receiveContent.Count, readContent); - break; - } - case (byte)ModbusProtocolFunctionCode.ReadCoilStatus: - { - var bitCount = receiveContent.WriteByteCount * 8; - var boolContent = new bool[bitCount]; - Array.Copy(zerox, receiveContent.StartAddress, boolContent, 0, bitCount); - var byteList = new List(); - for (int i = 0; i < receiveContent.WriteByteCount; i++) - { - byte result = 0; - for (int j = i; j < i + 8; j++) - { - // 将布尔值转换为对应的位 - - byte bit = boolContent[j] ? (byte)1 : (byte)0; - - // 使用左移位运算将位合并到结果字节中 - - result = (byte)((result << 1) | bit); - } - byteList.Add(result); - } - readContent = byteList.ToArray(); - returnBytes = new ReadDataModbusProtocol().Format(receiveContent.SlaveAddress, receiveContent.FunctionCode, receiveContent.WriteByteCount, readContent); - break; - } - } - } - if (returnBytes != null) return returnBytes; - else return null; + + return returnBytes; }; - _receivers.Add(_receiver, DateTime.MinValue); - } - } - - public async Task ConnectAsync() - { - var result = await Task.FromResult(Parallel.ForEach(_receivers, async _receiver => - { - await _receiver.Key.ConnectAsync(); - })); - return result.IsCompleted; + + _receivers.Add(_receiver, DateTime.Now); + } } } } diff --git a/Modbus.Net/Modbus.Net.Modbus/ModbusRtuInTcpProtocol.cs b/Modbus.Net/Modbus.Net.Modbus/ModbusRtuInTcpProtocol.cs index 372c60a..f0f9f11 100644 --- a/Modbus.Net/Modbus.Net.Modbus/ModbusRtuInTcpProtocol.cs +++ b/Modbus.Net/Modbus.Net.Modbus/ModbusRtuInTcpProtocol.cs @@ -1,43 +1,148 @@ -namespace Modbus.Net.Modbus +namespace Modbus.Net.Modbus { /// - /// Modbus/Rtu协议tcp透传 + /// Modbus RTU over TCP 协议类 / Modbus RTU over TCP Protocol Class + /// + /// 实现 Modbus RTU 协议通过 TCP 透传的功能，用于串口服务器场景 + /// Implements Modbus RTU protocol over TCP tunneling, used for serial device server scenarios + /// + /// 使用场景 / Use Cases: + /// + /// 串口服务器 / Serial device server + /// 通过 TCP 网络传输 RTU 帧 / Transmit RTU frames over TCP network + /// 远程串口访问 / Remote serial access + /// 多个 RTU 设备共享一个 TCP 连接 / Multiple RTU devices sharing one TCP connection + /// + /// + /// + /// 与 Modbus TCP 的区别 / Difference from Modbus TCP: + /// + /// RTU over TCP - RTU 帧原样传输，无 MBAP 头，保留 CRC / RTU frames as-is, no MBAP header, CRC preserved + /// Modbus TCP - 添加 MBAP 头，移除 CRC / Adds MBAP header, removes CRC + /// + /// + /// + /// 帧格式 / Frame Format: + /// + /// [从站地址 (1)][功能码 (1)][数据 (N)][CRC 低 (1)][CRC 高 (1)] + /// │ │ │ │ │ + /// └─ 设备地址 └─ 操作类型 └─ 寄存器值 └─ CRC16 校验 + /// (通过 TCP 原样传输，无 MBAP 头) + /// (Transmitted as-is over TCP, no MBAP header) + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // 通过串口服务器连接 RTU 设备 / Connect RTU device via serial server + /// var protocol = new ModbusRtuInTcpProtocol( + /// "192.168.1.200", // 串口服务器 IP / Serial server IP + /// 8899, // 串口服务器端口 / Serial server port + /// slaveAddress: 1, + /// masterAddress: 0 + /// ); + /// + /// // 连接设备 / Connect to device + /// await protocol.ConnectAsync(); + /// + /// // 读取数据 (RTU 帧通过 TCP 透传) / Read data (RTU frames tunneled over TCP) + /// var inputStruct = new ReadDataModbusInputStruct(1, "4X 1", 10, addressTranslator, 0); + /// var outputStruct = await protocol.SendReceiveAsync<ReadDataModbusOutputStruct>( + /// protocol[typeof(ReadDataModbusProtocol)], + /// inputStruct + /// ); + /// + /// + /// /// public class ModbusRtuInTcpProtocol : ModbusProtocol { /// - /// 构造函数 + /// 构造函数 (从配置读取 IP) / Constructor (Read IP from Configuration) + /// + /// 从配置文件读取 IP 地址创建 Modbus RTU over TCP 协议实例 + /// Create Modbus RTU over TCP protocol instance with IP address read from configuration file + /// + /// 配置项 / Configuration Item: + /// TCP:Modbus:IP = "192.168.1.200" + /// + /// + /// 默认端口 / Default Port: 由配置决定或由 ProtocolLinker 决定 + /// Determined by configuration or ProtocolLinker + /// + /// /// - /// 从站号 - /// 主站号 + /// + /// 从站号 / Slave Address + /// Modbus 从站地址，范围 1-247 / Modbus slave address, range 1-247 + /// + /// + /// 主站号 / Master Address + /// 通常为 0 或 1 / Usually 0 or 1 + /// public ModbusRtuInTcpProtocol(byte slaveAddress, byte masterAddress) : this(ConfigurationReader.GetValueDirect("TCP:Modbus", "IP"), slaveAddress, masterAddress) { } /// - /// 构造函数 + /// 构造函数 (指定 IP) / Constructor (Specify IP) + /// + /// 使用指定的 IP 地址创建 Modbus RTU over TCP 协议实例 + /// Create Modbus RTU over TCP protocol instance with specified IP address + /// + /// 使用默认端口 (由 ProtocolLinker 决定) + /// Uses default port (determined by ProtocolLinker) + /// + /// /// - /// ip地址 - /// 从站号 - /// 主站号 + /// + /// IP 地址 / IP Address + /// + /// 串口服务器地址 + /// Serial device server address + /// + /// + /// 从站号 / Slave Address + /// 主站号 / Master Address public ModbusRtuInTcpProtocol(string ip, byte slaveAddress, byte masterAddress) : base(slaveAddress, masterAddress) { + // 创建 Modbus RTU over TCP 协议链接器 + // Create Modbus RTU over TCP protocol linker ProtocolLinker = new ModbusRtuInTcpProtocolLinker(ip); } /// - /// 构造函数 + /// 构造函数 (指定 IP 和端口) / Constructor (Specify IP and Port) + /// + /// 使用指定的 IP 地址和端口创建 Modbus RTU over TCP 协议实例 + /// Create Modbus RTU over TCP protocol instance with specified IP address and port + /// + /// 适用于非标准端口的串口服务器 + /// Suitable for serial servers with non-standard ports + /// + /// /// - /// ip地址 - /// 端口号 - /// 从站号 - /// 主站号 + /// + /// IP 地址 / IP Address + /// 串口服务器地址 / Serial device server address + /// + /// + /// 端口号 / Port Number + /// + /// 串口服务器端口，常用 8899, 502 等 + /// Serial server port, commonly 8899, 502, etc. + /// + /// + /// 从站号 / Slave Address + /// 主站号 / Master Address public ModbusRtuInTcpProtocol(string ip, int port, byte slaveAddress, byte masterAddress) : base(slaveAddress, masterAddress) { + // 创建带端口的 Modbus RTU over TCP 协议链接器 + // Create Modbus RTU over TCP protocol linker with port ProtocolLinker = new ModbusRtuInTcpProtocolLinker(ip, port); } } -} \ No newline at end of file +} diff --git a/Modbus.Net/Modbus.Net.Modbus/ModbusRtuInTcpProtocolLinker.cs b/Modbus.Net/Modbus.Net.Modbus/ModbusRtuInTcpProtocolLinker.cs index 47f190d..a3cd453 100644 --- a/Modbus.Net/Modbus.Net.Modbus/ModbusRtuInTcpProtocolLinker.cs +++ b/Modbus.Net/Modbus.Net.Modbus/ModbusRtuInTcpProtocolLinker.cs @@ -1,41 +1,155 @@ -namespace Modbus.Net.Modbus +namespace Modbus.Net.Modbus { /// - /// Modbus/Rtu协议连接器Tcp透传 + /// Modbus RTU over TCP 协议连接器 / Modbus RTU over TCP Protocol Linker + /// + /// 实现 Modbus RTU 协议通过 TCP 透传的连接器，继承自 TcpProtocolLinker + /// Implements Modbus RTU protocol over TCP tunneling linker, inherits from TcpProtocolLinker + /// + /// 主要功能 / Main Functions: + /// + /// TCP 连接管理 / TCP connection management + /// RTU 帧原样传输 / RTU frame transparent transmission + /// 无 MBAP 头 / No MBAP header + /// 保留 CRC16 校验 / CRC16 checksum preserved + /// 响应校验 / Response validation + /// + /// + /// + /// 使用场景 / Use Cases: + /// + /// 串口服务器 / Serial device server + /// 通过 TCP 网络传输 RTU 帧 / Transmit RTU frames over TCP network + /// 远程串口访问 / Remote serial access + /// + /// + /// + /// 与 Modbus TCP 的区别 / Difference from Modbus TCP: + /// + /// RTU over TCP - RTU 帧原样传输，无 MBAP 头，保留 CRC / RTU frames as-is, no MBAP header, CRC preserved + /// Modbus TCP - 添加 MBAP 头，移除 CRC / Adds MBAP header, removes CRC + /// + /// + /// + /// 帧格式 / Frame Format: + /// + /// [从站地址 (1)][功能码 (1)][数据 (N)][CRC 低 (1)][CRC 高 (1)] + /// │ │ │ │ │ + /// └─ 设备地址 └─ 操作类型 └─ 寄存器值 └─ CRC16 校验 + /// (通过 TCP 原样传输，无 MBAP 头) + /// (Transmitted as-is over TCP, no MBAP header) + /// + /// + /// /// public class ModbusRtuInTcpProtocolLinker : TcpProtocolLinker { /// - /// 构造函数 + /// 构造函数 (从配置读取端口) / Constructor (Read Port from Configuration) + /// + /// 从配置文件读取端口创建 Modbus RTU over TCP 连接器 + /// Create Modbus RTU over TCP linker with port read from configuration file + /// + /// 配置项 / Configuration Items: + /// + /// TCP:{IP}:ModbusPort - 指定 IP 的端口 / Port for specified IP + /// TCP:Modbus:ModbusPort - 默认 Modbus 端口 / Default Modbus port + /// 默认端口：502 / Default port: 502 + /// + /// + /// /// - /// IP地址 + /// + /// IP 地址 / IP Address + /// + /// 串口服务器的 IP 地址 + /// Serial device server IP address + /// + /// public ModbusRtuInTcpProtocolLinker(string ip) : base(ip, int.Parse(ConfigurationReader.GetValueDirect("TCP:" + ip, "ModbusPort") ?? ConfigurationReader.GetValueDirect("TCP:Modbus", "ModbusPort"))) { } /// - /// 构造函数 + /// 构造函数 (指定 IP 和端口) / Constructor (Specify IP and Port) + /// + /// 使用指定的 IP 地址和端口创建 Modbus RTU over TCP 连接器 + /// Create Modbus RTU over TCP linker with specified IP address and port + /// /// - /// IP地址 - /// 端口号 + /// + /// IP 地址 / IP Address + /// 串口服务器的 IP 地址 / Serial device server IP address + /// + /// + /// 端口号 / Port Number + /// + /// 串口服务器端口，常用 8899, 502 等 + /// Serial server port, commonly 8899, 502, etc. + /// + /// public ModbusRtuInTcpProtocolLinker(string ip, int port) : base(ip, port) { } /// - /// 校验返回数据 + /// 校验返回数据 / Validate Return Data + /// + /// 校验从设备返回的 Modbus RTU over TCP 响应数据 + /// Validate Modbus RTU over TCP response data returned from device + /// + /// 校验流程 / Validation Flow: + /// + /// 调用基类校验 (TCP 连接状态) / Call base validation (TCP connection status) + /// 检查功能码 (字节 1) / Check function code (byte 1) + /// 如果功能码>127，表示错误响应 / If function code>127, indicates error response + /// 抛出 ModbusProtocolErrorException / Throw ModbusProtocolErrorException + /// + /// + /// + /// 错误码说明 / Error Code Description: + /// + /// 功能码 +128: 异常响应 / Function code +128: Exception response + /// 异常码在 content[2] / Exception code in content[2] + /// + /// + /// /// - /// 设备返回的数据 - /// 数据是否正确 + /// + /// 设备返回的数据 / Data Returned from Device + /// + /// RTU 帧 (无 MBAP 头) + /// RTU frame (no MBAP header) + /// + /// + /// + /// 数据是否正确 / Whether Data is Correct + /// + /// + /// true: 数据正确 / Data correct + /// false: 数据错误 / Data error + /// null: 无法判断 / Cannot determine + /// + /// + /// + /// + /// 当功能码>127 时抛出 Modbus 协议错误 + /// Throw Modbus protocol error when function code>127 + /// public override bool? CheckRight(byte[] content) { + // 基类校验 (TCP 连接状态) / Base validation (TCP connection status) if (base.CheckRight(content) != true) return base.CheckRight(content); - //Modbus协议错误 + + // Modbus 协议错误检测 / Modbus protocol error detection + // RTU 帧第 2 字节是功能码 / Byte 1 of RTU frame is function code if (content[1] > 127) + // 功能码>127 表示异常响应 / Function code>127 indicates exception response throw new ModbusProtocolErrorException(content[2]); + return true; } } -} \ No newline at end of file +} diff --git a/Modbus.Net/Modbus.Net.Modbus/ModbusRtuInUdpProtocol.cs b/Modbus.Net/Modbus.Net.Modbus/ModbusRtuInUdpProtocol.cs index 47f23ff..ad9f5df 100644 --- a/Modbus.Net/Modbus.Net.Modbus/ModbusRtuInUdpProtocol.cs +++ b/Modbus.Net/Modbus.Net.Modbus/ModbusRtuInUdpProtocol.cs @@ -1,26 +1,91 @@ -namespace Modbus.Net.Modbus +namespace Modbus.Net.Modbus { /// - /// Modbus/Rtu协议udp透传 + /// Modbus RTU over UDP 协议类 / Modbus RTU over UDP Protocol Class + /// + /// 实现 Modbus RTU 协议通过 UDP 透传的功能，用于无连接的网络通信 + /// Implements Modbus RTU protocol over UDP tunneling, used for connectionless network communication + /// + /// 使用场景 / Use Cases: + /// + /// UDP 广播查询 / UDP broadcast query + /// 通过 UDP 网络传输 RTU 帧 / Transmit RTU frames over UDP network + /// 多个 RTU 设备共享一个 UDP 端口 / Multiple RTU devices sharing one UDP port + /// 不要求可靠性的场景 / Scenarios not requiring reliability + /// + /// + /// + /// 与 Modbus RTU over TCP 的区别 / Difference from Modbus RTU over TCP: + /// + /// RTU over UDP - 无连接，不保证送达，支持广播 / Connectionless, no delivery guarantee, supports broadcast + /// RTU over TCP - 面向连接，保证送达，不支持广播 / Connection-oriented, delivery guaranteed, no broadcast + /// + /// + /// + /// 帧格式 / Frame Format: + /// + /// [从站地址 (1)][功能码 (1)][数据 (N)][CRC 低 (1)][CRC 高 (1)] + /// │ │ │ │ │ + /// └─ 设备地址 └─ 操作类型 └─ 寄存器值 └─ CRC16 校验 + /// (通过 UDP 原样传输，无 MBAP 头) + /// (Transmitted as-is over UDP, no MBAP header) + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // 通过 UDP 连接 RTU 设备 / Connect RTU device via UDP + /// var protocol = new ModbusRtuInUdpProtocol( + /// "192.168.1.200", // 设备 IP / Device IP + /// 502, // UDP 端口 / UDP port + /// slaveAddress: 1, + /// masterAddress: 0 + /// ); + /// + /// // 连接设备 (UDP 无需真正连接) / Connect to device (UDP doesn't need real connection) + /// await protocol.ConnectAsync(); + /// + /// // 读取数据 (RTU 帧通过 UDP 透传) / Read data (RTU frames tunneled over UDP) + /// var inputStruct = new ReadDataModbusInputStruct(1, "4X 1", 10, addressTranslator, 0); + /// var outputStruct = await protocol.SendReceiveAsync<ReadDataModbusOutputStruct>( + /// protocol[typeof(ReadDataModbusProtocol)], + /// inputStruct + /// ); + /// + /// // UDP 广播查询示例 / UDP broadcast query example + /// var broadcastProtocol = new ModbusRtuInUdpProtocol("255.255.255.255", 502, slaveAddress: 0, masterAddress: 0); + /// // 注意：广播地址为 0，所有从站都会响应 + /// // Note: Broadcast address is 0, all slaves will respond + /// + /// + /// /// public class ModbusRtuInUdpProtocol : ModbusProtocol { /// - /// 构造函数 + /// 构造函数 (从配置读取 IP) / Constructor (Read IP from Configuration) + /// + /// 从配置文件读取 IP 地址创建 Modbus RTU over UDP 协议实例 + /// Create Modbus RTU over UDP protocol instance with IP address read from configuration file + /// /// - /// 从站号 - /// 主站号 + /// 从站号 / Slave Address + /// 主站号 / Master Address public ModbusRtuInUdpProtocol(byte slaveAddress, byte masterAddress) : this(ConfigurationReader.GetValueDirect("UDP:Modbus", "IP"), slaveAddress, masterAddress) { } /// - /// 构造函数 + /// 构造函数 (指定 IP) / Constructor (Specify IP) + /// + /// 使用指定的 IP 地址创建 Modbus RTU over UDP 协议实例 + /// Create Modbus RTU over UDP protocol instance with specified IP address + /// /// - /// ip地址 - /// 从站号 - /// 主站号 + /// IP 地址 / IP Address (可使用广播地址 255.255.255.255) + /// 从站号 / Slave Address + /// 主站号 / Master Address public ModbusRtuInUdpProtocol(string ip, byte slaveAddress, byte masterAddress) : base(slaveAddress, masterAddress) { @@ -28,12 +93,16 @@ } /// - /// 构造函数 + /// 构造函数 (指定 IP 和端口) / Constructor (Specify IP and Port) + /// + /// 使用指定的 IP 地址和端口创建 Modbus RTU over UDP 协议实例 + /// Create Modbus RTU over UDP protocol instance with specified IP address and port + /// /// - /// ip地址 - /// 端口号 - /// 从站号 - /// 主站号 + /// IP 地址 / IP Address + /// 端口号 / Port Number + /// 从站号 / Slave Address + /// 主站号 / Master Address public ModbusRtuInUdpProtocol(string ip, int port, byte slaveAddress, byte masterAddress) : base(slaveAddress, masterAddress) { diff --git a/Modbus.Net/Modbus.Net.Modbus/ModbusRtuInUdpProtocolLinker.cs b/Modbus.Net/Modbus.Net.Modbus/ModbusRtuInUdpProtocolLinker.cs index 6910449..c62dedb 100644 --- a/Modbus.Net/Modbus.Net.Modbus/ModbusRtuInUdpProtocolLinker.cs +++ b/Modbus.Net/Modbus.Net.Modbus/ModbusRtuInUdpProtocolLinker.cs @@ -1,40 +1,156 @@ -namespace Modbus.Net.Modbus +namespace Modbus.Net.Modbus { /// - /// Modbus/Rtu协议连接器Udp透传 + /// Modbus RTU over UDP 协议连接器 / Modbus RTU over UDP Protocol Linker + /// + /// 实现 Modbus RTU 协议通过 UDP 透传的连接器，继承自 UdpProtocolLinker + /// Implements Modbus RTU protocol over UDP tunneling linker, inherits from UdpProtocolLinker + /// + /// 主要功能 / Main Functions: + /// + /// UDP 连接管理 / UDP connection management + /// RTU 帧原样传输 / RTU frame transparent transmission + /// 无 MBAP 头 / No MBAP header + /// 保留 CRC16 校验 / CRC16 checksum preserved + /// 支持广播查询 / Supports broadcast query + /// 响应校验 / Response validation + /// + /// + /// + /// 使用场景 / Use Cases: + /// + /// UDP 广播查询 / UDP broadcast query + /// 通过 UDP 网络传输 RTU 帧 / Transmit RTU frames over UDP network + /// 多个 RTU 设备共享一个 UDP 端口 / Multiple RTU devices sharing one UDP port + /// 不要求可靠性的场景 / Scenarios not requiring reliability + /// + /// + /// + /// 与 RTU over TCP 的区别 / Difference from RTU over TCP: + /// + /// RTU over UDP - 无连接，不保证送达，支持广播 / Connectionless, no delivery guarantee, supports broadcast + /// RTU over TCP - 面向连接，保证送达，不支持广播 / Connection-oriented, delivery guaranteed, no broadcast + /// + /// + /// + /// 帧格式 / Frame Format: + /// + /// [从站地址 (1)][功能码 (1)][数据 (N)][CRC 低 (1)][CRC 高 (1)] + /// │ │ │ │ │ + /// └─ 设备地址 └─ 操作类型 └─ 寄存器值 └─ CRC16 校验 + /// (通过 UDP 原样传输，无 MBAP 头) + /// (Transmitted as-is over UDP, no MBAP header) + /// + /// + /// /// public class ModbusRtuInUdpProtocolLinker : UdpProtocolLinker { /// - /// 构造函数 + /// 构造函数 (从配置读取端口) / Constructor (Read Port from Configuration) + /// + /// 从配置文件读取端口创建 Modbus RTU over UDP 连接器 + /// Create Modbus RTU over UDP linker with port read from configuration file + /// + /// 配置项 / Configuration Items: + /// + /// UDP:{IP}:ModbusPort - 指定 IP 的端口 / Port for specified IP + /// UDP:Modbus:ModbusPort - 默认 Modbus 端口 / Default Modbus port + /// 默认端口：502 / Default port: 502 + /// + /// + /// /// - /// IP地址 + /// + /// IP 地址 / IP Address + /// + /// 目标设备的 IP 地址 (可使用广播地址 255.255.255.255) + /// Target device IP address (can use broadcast address 255.255.255.255) + /// + /// public ModbusRtuInUdpProtocolLinker(string ip) : base(ip, int.Parse(ConfigurationReader.GetValueDirect("UDP:" + ip, "ModbusPort") ?? ConfigurationReader.GetValueDirect("UDP:Modbus", "ModbusPort"))) { } /// - /// 构造函数 + /// 构造函数 (指定 IP 和端口) / Constructor (Specify IP and Port) + /// + /// 使用指定的 IP 地址和端口创建 Modbus RTU over UDP 连接器 + /// Create Modbus RTU over UDP linker with specified IP address and port + /// /// - /// IP地址 - /// 端口号 + /// + /// IP 地址 / IP Address + /// 目标设备的 IP 地址 / Target device IP address + /// + /// + /// 端口号 / Port Number + /// + /// UDP 端口，默认 502 + /// UDP port, default 502 + /// + /// public ModbusRtuInUdpProtocolLinker(string ip, int port) : base(ip, port) { } /// - /// 校验返回数据 + /// 校验返回数据 / Validate Return Data + /// + /// 校验从设备返回的 Modbus RTU over UDP 响应数据 + /// Validate Modbus RTU over UDP response data returned from device + /// + /// 校验流程 / Validation Flow: + /// + /// 调用基类校验 (UDP 连接状态) / Call base validation (UDP connection status) + /// 检查功能码 (字节 1) / Check function code (byte 1) + /// 如果功能码>127，表示错误响应 / If function code>127, indicates error response + /// 抛出 ModbusProtocolErrorException / Throw ModbusProtocolErrorException + /// + /// + /// + /// 错误码说明 / Error Code Description: + /// + /// 功能码 +128: 异常响应 / Function code +128: Exception response + /// 异常码在 content[2] / Exception code in content[2] + /// + /// + /// /// - /// 设备返回的数据 - /// 数据是否正确 + /// + /// 设备返回的数据 / Data Returned from Device + /// + /// RTU 帧 (无 MBAP 头) + /// RTU frame (no MBAP header) + /// + /// + /// + /// 数据是否正确 / Whether Data is Correct + /// + /// + /// true: 数据正确 / Data correct + /// false: 数据错误 / Data error + /// null: 无法判断 / Cannot determine + /// + /// + /// + /// + /// 当功能码>127 时抛出 Modbus 协议错误 + /// Throw Modbus protocol error when function code>127 + /// public override bool? CheckRight(byte[] content) { + // 基类校验 (UDP 连接状态) / Base validation (UDP connection status) if (base.CheckRight(content) != true) return base.CheckRight(content); - //Modbus协议错误 + + // Modbus 协议错误检测 / Modbus protocol error detection + // RTU 帧第 2 字节是功能码 / Byte 1 of RTU frame is function code if (content[1] > 127) + // 功能码>127 表示异常响应 / Function code>127 indicates exception response throw new ModbusProtocolErrorException(content[2]); + return true; } } diff --git a/Modbus.Net/Modbus.Net.Modbus/ModbusRtuProtocol.cs b/Modbus.Net/Modbus.Net.Modbus/ModbusRtuProtocol.cs index e59ff1a..38e9c2b 100644 --- a/Modbus.Net/Modbus.Net.Modbus/ModbusRtuProtocol.cs +++ b/Modbus.Net/Modbus.Net.Modbus/ModbusRtuProtocol.cs @@ -1,30 +1,100 @@ -namespace Modbus.Net.Modbus +namespace Modbus.Net.Modbus { /// - /// Modbus/Rtu协议 + /// Modbus/RTU 协议类 / Modbus/RTU Protocol Class + /// + /// 实现 Modbus RTU 协议，用于串行通信 + /// Implements Modbus RTU protocol for serial communication + /// + /// 协议特点 / Protocol Characteristics: + /// + /// 二进制编码，效率高 / Binary encoding, high efficiency + /// CRC16 校验 / CRC16 checksum + /// 适用于 RS-232/RS-485 串口 / Suitable for RS-232/RS-485 serial + /// 最常用的 Modbus 模式 / Most common Modbus mode + /// + /// + /// + /// 帧格式 / Frame Format: + /// + /// [从站地址 (1)][功能码 (1)][数据 (N)][CRC 低 (1)][CRC 高 (1)] + /// │ │ │ │ │ + /// └─ 设备地址 └─ 操作类型 └─ 寄存器值 └─ CRC16 校验 + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // 创建 Modbus RTU 协议实例 / Create Modbus RTU protocol instance + /// var protocol = new ModbusRtuProtocol("COM1", slaveAddress: 1, masterAddress: 0); + /// + /// // 或者从配置读取 / Or read from configuration + /// var protocolFromConfig = new ModbusRtuProtocol(slaveAddress: 1, masterAddress: 0); + /// // 配置项：COM:Modbus:COM = "COM1" + /// + /// // 连接设备 / Connect to device + /// await protocol.ConnectAsync(); + /// + /// // 发送读取请求 / Send read request + /// var inputStruct = new ReadDataModbusInputStruct(1, "4X 1", 10, addressTranslator, 0); + /// var outputStruct = await protocol.SendReceiveAsync<ReadDataModbusOutputStruct>( + /// protocol[typeof(ReadDataModbusProtocol)], + /// inputStruct + /// ); + /// + /// + /// /// public class ModbusRtuProtocol : ModbusProtocol { /// - /// 构造函数 + /// 构造函数 (从配置读取串口) / Constructor (Read COM Port from Configuration) + /// + /// 从配置文件读取串口名称创建 Modbus RTU 协议实例 + /// Create Modbus RTU protocol instance with COM port name read from configuration file + /// + /// 配置项 / Configuration Item: + /// COM:Modbus:COM = "COM1" + /// + /// /// - /// 从站号 - /// 主站号 + /// + /// 从站号 / Slave Address + /// Modbus 从站地址，范围 1-247 / Modbus slave address, range 1-247 + /// + /// + /// 主站号 / Master Address + /// 通常为 0 或 1 / Usually 0 or 1 + /// public ModbusRtuProtocol(byte slaveAddress, byte masterAddress) : this(ConfigurationReader.GetValueDirect("COM:Modbus", "COM"), slaveAddress, masterAddress) { } /// - /// 构造函数 + /// 构造函数 (指定串口) / Constructor (Specify COM Port) + /// + /// 使用指定的串口名称创建 Modbus RTU 协议实例 + /// Create Modbus RTU protocol instance with specified COM port name + /// + /// 串口配置从 appsettings.json 读取 + /// Serial port configuration is read from appsettings.json + /// + /// /// - /// 串口 - /// 从站号 - /// 主站号 + /// + /// 串口名称 / COM Port Name + /// 如 "COM1", "COM2" 等 / e.g., "COM1", "COM2", etc. + /// + /// 从站号 / Slave Address + /// 主站号 / Master Address public ModbusRtuProtocol(string com, byte slaveAddress, byte masterAddress) : base(slaveAddress, masterAddress) { + // 创建 Modbus RTU 协议链接器 / Create Modbus RTU protocol linker + // 自动从配置读取串口参数 (波特率、校验位等) + // Automatically read serial port parameters from configuration (baud rate, parity, etc.) ProtocolLinker = new ModbusRtuProtocolLinker(com, slaveAddress); } } -} \ No newline at end of file +} diff --git a/Modbus.Net/Modbus.Net.Modbus/ModbusRtuProtocolLinker.cs b/Modbus.Net/Modbus.Net.Modbus/ModbusRtuProtocolLinker.cs index aaeb218..5446e21 100644 --- a/Modbus.Net/Modbus.Net.Modbus/ModbusRtuProtocolLinker.cs +++ b/Modbus.Net/Modbus.Net.Modbus/ModbusRtuProtocolLinker.cs @@ -1,35 +1,136 @@ -namespace Modbus.Net.Modbus +namespace Modbus.Net.Modbus { /// - /// Modbus/Rtu协议连接器 + /// Modbus/RTU 协议连接器 / Modbus/RTU Protocol Linker + /// + /// 实现 Modbus RTU 协议的连接器，继承自 ComProtocolLinker + /// Implements Modbus RTU protocol linker, inherits from ComProtocolLinker + /// + /// 主要功能 / Main Functions: + /// + /// 串口连接管理 / Serial connection management + /// CRC16 校验 / CRC16 checksum + /// 响应校验 / Response validation + /// 错误检测 / Error detection + /// + /// + /// + /// RTU 帧格式 / RTU Frame Format: + /// + /// [从站地址 (1)][功能码 (1)][数据 (N)][CRC 低 (1)][CRC 高 (1)] + /// │ │ │ │ │ + /// └─ 设备地址 └─ 操作类型 └─ 寄存器值 └─ CRC16 校验 + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // 创建 Modbus RTU 连接器 / Create Modbus RTU linker + /// var linker = new ModbusRtuProtocolLinker("COM1", slaveAddress: 1); + /// + /// // 连接设备 / Connect to device + /// await linker.ConnectAsync(); + /// + /// // 发送数据 / Send data + /// byte[] request = [0x01, 0x03, 0x00, 0x00, 0x00, 0x0A, 0xC4, 0x0B]; + /// byte[] response = await linker.SendReceiveAsync(request); + /// + /// // CheckRight 会自动校验 CRC 和协议错误 + /// // CheckRight will automatically validate CRC and protocol errors + /// + /// + /// /// public class ModbusRtuProtocolLinker : ComProtocolLinker { /// - /// 构造函数 + /// 构造函数 / Constructor + /// + /// 初始化 Modbus RTU 协议连接器 + /// Initialize Modbus RTU protocol linker + /// /// - /// 串口地址 - /// 从站号 + /// + /// 串口地址 / Serial Port Address + /// + /// 如 "COM1", "COM2" 等 + /// e.g., "COM1", "COM2", etc. + /// + /// + /// + /// 从站号 / Slave Address + /// + /// Modbus 从站地址，范围 1-247 + /// Modbus slave address, range 1-247 + /// + /// public ModbusRtuProtocolLinker(string com, int slaveAddress) : base(com, slaveAddress) { } /// - /// 校验返回数据 + /// 校验返回数据 / Validate Return Data + /// + /// 校验从设备返回的 Modbus RTU 响应数据 + /// Validate Modbus RTU response data returned from device + /// + /// 校验流程 / Validation Flow: + /// + /// 调用基类校验 (串口连接状态) / Call base validation (serial connection status) + /// CRC16 校验 / CRC16 checksum + /// 如果 CRC 失败，抛出错误 / If CRC fails, throw error + /// 检查功能码 / Check function code + /// 如果功能码>127，表示错误响应 / If function code>127, indicates error response + /// 抛出 ModbusProtocolErrorException / Throw ModbusProtocolErrorException + /// + /// + /// + /// 错误码说明 / Error Code Description: + /// + /// 501: CRC 校验失败 / CRC check failed + /// 功能码 +128: 异常响应 / Function code +128: Exception response + /// 异常码在 content[2] / Exception code in content[2] + /// + /// + /// /// - /// 设备返回的数据 - /// 数据是否正确 + /// + /// 设备返回的数据 / Data Returned from Device + /// + /// 包含 CRC 的完整 Modbus RTU 响应 + /// Complete Modbus RTU response with CRC + /// + /// + /// + /// 数据是否正确 / Whether Data is Correct + /// + /// + /// true: 数据正确 / Data correct + /// false: 数据错误 / Data error + /// null: 无法判断 / Cannot determine + /// + /// + /// + /// + /// 当 CRC 失败或功能码>127 时抛出 Modbus 协议错误 + /// Throw Modbus protocol error when CRC fails or function code>127 + /// public override bool? CheckRight(byte[] content) { + // 基类校验 (串口连接状态) / Base validation (serial connection status) if (base.CheckRight(content) != true) return base.CheckRight(content); - //CRC校验失败 + + // CRC16 校验 / CRC16 checksum if (!Crc16.GetInstance().CrcEfficacy(content)) - throw new ModbusProtocolErrorException(501); - //Modbus协议错误 + throw new ModbusProtocolErrorException(501); // CRC 校验失败 / CRC check failed + + // Modbus 协议错误检测 / Modbus protocol error detection + // 功能码>127 表示异常响应 / Function code>127 indicates exception response if (content[1] > 127) - throw new ModbusProtocolErrorException(content[2]); + throw new ModbusProtocolErrorException(content[2]); // 异常码 / Exception code + return true; } } -} \ No newline at end of file +} diff --git a/Modbus.Net/Modbus.Net.Modbus/ModbusRtuProtocolReceiver.cs b/Modbus.Net/Modbus.Net.Modbus/ModbusRtuProtocolReceiver.cs index 5a0ac32..37680b6 100644 --- a/Modbus.Net/Modbus.Net.Modbus/ModbusRtuProtocolReceiver.cs +++ b/Modbus.Net/Modbus.Net.Modbus/ModbusRtuProtocolReceiver.cs @@ -1,21 +1,111 @@ -using System; +using System; namespace Modbus.Net.Modbus { + /// + /// Modbus RTU 协议接收器类 / Modbus RTU Protocol Receiver Class + /// + /// 实现 Modbus RTU 从站/服务器端的数据接收和解析功能 + /// Implements data reception and parsing functionality for Modbus RTU slave/server side + /// + /// 主要功能 / Main Functions: + /// + /// 接收 Modbus RTU 请求帧 / Receive Modbus RTU request frames + /// 解析请求数据 / Parse request data + /// 提取功能码、地址、数据等信息 / Extract function code, address, data, etc. + /// 支持读写操作解析 / Supports read/write operation parsing + /// + /// + /// + /// 帧格式 / Frame Format: + /// + /// 读操作 (6 字节): [从站][功能码][地址 (2)][数量 (2)][CRC] + /// 写单线圈/寄存器 (6 字节): [从站][功能码][地址 (2)][值 (2)][CRC] + /// 写多线圈/寄存器 (N+7 字节): [从站][功能码][地址 (2)][数量 (2)][字节数][数据...][CRC] + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // 创建 RTU 协议接收器 / Create RTU protocol receiver + /// var receiver = new ModbusRtuProtocolReceiver("COM1", slaveAddress: 1); + /// + /// // 接收器会自动解析接收到的 RTU 帧 + /// // Receiver will automatically parse received RTU frames + /// + /// // 解析结果示例 / Parse result example: + /// // 接收：[0x01, 0x03, 0x00, 0x00, 0x00, 0x0A, 0xC4, 0x0B] + /// // 解析： + /// // - SlaveAddress: 0x01 + /// // - FunctionCode: 0x03 (读保持寄存器) + /// // - StartAddress: 0x0000 + /// // - Count: 0x000A (10 个寄存器) + /// + /// + /// + /// public class ModbusRtuProtocolReceiver : ProtocolReceiver { + /// + /// 构造函数 / Constructor + /// + /// 初始化 Modbus RTU 协议接收器 + /// Initialize Modbus RTU protocol receiver + /// + /// + /// + /// 串口名称 / Serial Port Name + /// + /// 如 "COM1", "COM2" 等 + /// e.g., "COM1", "COM2", etc. + /// + /// + /// + /// 从站号 / Slave Address + /// + /// Modbus 从站地址，范围 1-247 + /// Modbus slave address, range 1-247 + /// + /// public ModbusRtuProtocolReceiver(string com, int slaveAddress) : base(com, slaveAddress) { - } + /// + /// 数据解析函数 / Data Explanation Function + /// + /// 将接收到的字节数组解析为 ReceiveDataDef 结构 + /// Parse received byte array into ReceiveDataDef structure + /// + /// 解析规则 / Parsing Rules: + /// + /// 长度>6: 写多线圈/寄存器操作 / Write multiple coils/registers + /// 长度=6: 读操作或写单线圈/寄存器 / Read operation or write single coil/register + /// 长度<6: 无效帧 / Invalid frame + /// + /// + /// + /// 返回数据结构 / Return Data Structure: + /// + /// SlaveAddress - 从站地址 / Slave address + /// FunctionCode - 功能码 / Function code + /// StartAddress - 起始地址 / Start address + /// Count - 数量 / Count + /// WriteByteCount - 写字节数 / Write byte count + /// WriteContent - 写入的数据 / Write data + /// + /// + /// + /// protected override Func DataExplain { get { return receiveBytes => { + // 写多线圈/寄存器操作 (长度>6) + // Write multiple coils/registers operation (length>6) var writeContent = receiveBytes.Length > 6 ? new byte[receiveBytes.Length - 7] : null; if (receiveBytes.Length > 6) { @@ -30,8 +120,12 @@ namespace Modbus.Net.Modbus WriteContent = writeContent }; } + // 读操作或写单线圈/寄存器 (长度=6) + // Read operation or write single coil/register (length=6) else if (receiveBytes.Length == 6) { + // 读线圈 (01) 或读寄存器 (03) + // Read coils (01) or read registers (03) if (receiveBytes[1] == 1 || receiveBytes[1] == 3) { writeContent = null; @@ -45,6 +139,8 @@ namespace Modbus.Net.Modbus WriteContent = writeContent }; } + // 写单线圈 (05) 或写单寄存器 (06) + // Write single coil (05) or write single register (06) else { writeContent = new byte[2] { receiveBytes[4], receiveBytes[5] }; @@ -59,9 +155,10 @@ namespace Modbus.Net.Modbus }; } } + // 无效帧 / Invalid frame else return null; }; } } } -} \ No newline at end of file +} diff --git a/Modbus.Net/Modbus.Net.Modbus/ModbusTcpProtocol.cs b/Modbus.Net/Modbus.Net.Modbus/ModbusTcpProtocol.cs index a609124..ec87890 100644 --- a/Modbus.Net/Modbus.Net.Modbus/ModbusTcpProtocol.cs +++ b/Modbus.Net/Modbus.Net.Modbus/ModbusTcpProtocol.cs @@ -1,43 +1,132 @@ -namespace Modbus.Net.Modbus +namespace Modbus.Net.Modbus { /// - /// Modbus/Tcp协议 + /// Modbus/TCP 协议类 / Modbus/TCP Protocol Class + /// + /// 实现 Modbus TCP 协议，用于以太网通信 + /// Implements Modbus TCP protocol for Ethernet communication + /// + /// 协议特点 / Protocol Characteristics: + /// + /// 基于 TCP/IP 传输 / Based on TCP/IP transport + /// 添加 MBAP 头 (6 字节) / Adds MBAP header (6 bytes) + /// 无需 CRC 校验 (TCP 已保证) / No CRC needed (TCP guarantees) + /// 默认端口：502 / Default port: 502 + /// + /// + /// + /// MBAP 头格式 / MBAP Header Format: + /// + /// [Transaction ID (2 字节)][Protocol ID (2 字节)][Length (2 字节)][Unit ID (1 字节)] + /// │ │ │ │ │ │ │ + /// └─ 事务标识，用于匹配请求响应 + /// └─ 协议标识，Modbus=0 + /// └─ 后续字节长度 + /// └─ 从站地址 + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // 创建 Modbus TCP 协议实例 / Create Modbus TCP protocol instance + /// var protocol = new ModbusTcpProtocol("192.168.1.100", 502, slaveAddress: 1, masterAddress: 0); + /// + /// // 或者从配置读取 / Or read from configuration + /// var protocolFromConfig = new ModbusTcpProtocol(slaveAddress: 1, masterAddress: 0); + /// // 配置项：TCP:Modbus:IP = "192.168.1.100" + /// + /// // 连接设备 / Connect to device + /// await protocol.ConnectAsync(); + /// + /// // 发送读取请求 / Send read request + /// var inputStruct = new ReadDataModbusInputStruct(1, "4X 1", 10, addressTranslator, 0); + /// var outputStruct = await protocol.SendReceiveAsync<ReadDataModbusOutputStruct>( + /// protocol[typeof(ReadDataModbusProtocol)], + /// inputStruct + /// ); + /// + /// + /// /// public class ModbusTcpProtocol : ModbusProtocol { /// - /// 构造函数 + /// 构造函数 (从配置读取 IP) / Constructor (Read IP from Configuration) + /// + /// 从配置文件读取 IP 地址创建 Modbus TCP 协议实例 + /// Create Modbus TCP protocol instance with IP address read from configuration file + /// + /// 配置项 / Configuration Item: + /// TCP:Modbus:IP = "192.168.1.100" + /// + /// /// - /// 从站号 - /// 主站号 + /// + /// 从站号 / Slave Address + /// Modbus 从站地址，范围 1-247 / Modbus slave address, range 1-247 + /// + /// + /// 主站号 / Master Address + /// 通常为 0 或 1 / Usually 0 or 1 + /// public ModbusTcpProtocol(byte slaveAddress, byte masterAddress) : this(ConfigurationReader.GetValueDirect("TCP:Modbus", "IP"), slaveAddress, masterAddress) { } /// - /// 构造函数 + /// 构造函数 (指定 IP) / Constructor (Specify IP) + /// + /// 使用指定的 IP 地址创建 Modbus TCP 协议实例 + /// Create Modbus TCP protocol instance with specified IP address + /// + /// 使用默认端口 502 + /// Uses default port 502 + /// + /// /// - /// ip地址 - /// 从站号 - /// 主站号 + /// + /// IP 地址 / IP Address + /// 如 "192.168.1.100" / e.g., "192.168.1.100" + /// + /// 从站号 / Slave Address + /// 主站号 / Master Address public ModbusTcpProtocol(string ip, byte slaveAddress, byte masterAddress) : base(slaveAddress, masterAddress) { + // 创建 Modbus TCP 协议链接器 / Create Modbus TCP protocol linker ProtocolLinker = new ModbusTcpProtocolLinker(ip); } /// - /// 构造函数 + /// 构造函数 (指定 IP 和端口) / Constructor (Specify IP and Port) + /// + /// 使用指定的 IP 地址和端口创建 Modbus TCP 协议实例 + /// Create Modbus TCP protocol instance with specified IP address and port + /// + /// 适用于非标准端口的 Modbus TCP 设备 + /// Suitable for Modbus TCP devices with non-standard ports + /// + /// /// - /// ip地址 - /// 端口 - /// 从站号 - /// 主站号 + /// + /// IP 地址 / IP Address + /// 如 "192.168.1.100" / e.g., "192.168.1.100" + /// + /// + /// 端口号 / Port Number + /// + /// 默认 502，串口服务器常用 8899 + /// Default 502, commonly 8899 for serial servers + /// + /// + /// 从站号 / Slave Address + /// 主站号 / Master Address public ModbusTcpProtocol(string ip, int port, byte slaveAddress, byte masterAddress) : base(slaveAddress, masterAddress) { + // 创建带端口的 Modbus TCP 协议链接器 / Create Modbus TCP protocol linker with port ProtocolLinker = new ModbusTcpProtocolLinker(ip, port); } } -} \ No newline at end of file +} diff --git a/Modbus.Net/Modbus.Net.Modbus/ModbusTcpProtocolLinker.cs b/Modbus.Net/Modbus.Net.Modbus/ModbusTcpProtocolLinker.cs index 1ba6cea..bb17397 100644 --- a/Modbus.Net/Modbus.Net.Modbus/ModbusTcpProtocolLinker.cs +++ b/Modbus.Net/Modbus.Net.Modbus/ModbusTcpProtocolLinker.cs @@ -1,40 +1,156 @@ -namespace Modbus.Net.Modbus +namespace Modbus.Net.Modbus { /// - /// Modbus/Tcp协议连接器 + /// Modbus/TCP 协议连接器 / Modbus/TCP Protocol Linker + /// + /// 实现 Modbus TCP 协议的连接器，继承自 TcpProtocolLinker + /// Implements Modbus TCP protocol linker, inherits from TcpProtocolLinker + /// + /// 主要功能 / Main Functions: + /// + /// TCP 连接管理 / TCP connection management + /// MBAP 头处理 / MBAP header handling + /// 响应校验 / Response validation + /// 错误检测 / Error detection + /// + /// + /// + /// MBAP 头格式 / MBAP Header Format: + /// + /// [Transaction ID (2)][Protocol ID (2)][Length (2)][Unit ID (1)] + /// │ │ │ │ │ │ + /// └─ 事务标识，用于匹配请求响应 + /// └─ 协议标识，Modbus=0 + /// └─ 后续字节长度 + /// └─ 从站地址 + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // 创建 Modbus TCP 连接器 / Create Modbus TCP linker + /// var linker = new ModbusTcpProtocolLinker("192.168.1.100", 502); + /// + /// // 连接设备 / Connect to device + /// await linker.ConnectAsync(); + /// + /// // 发送数据 / Send data + /// byte[] request = [0x00, 0x01, 0x00, 0x00, 0x00, 0x06, 0x01, 0x03, 0x00, 0x00, 0x00, 0x0A]; + /// byte[] response = await linker.SendReceiveAsync(request); + /// + /// // CheckRight 会自动校验响应 + /// // CheckRight will automatically validate response + /// + /// + /// /// public class ModbusTcpProtocolLinker : TcpProtocolLinker { /// - /// 构造函数 + /// 构造函数 (从配置读取端口) / Constructor (Read Port from Configuration) + /// + /// 从配置文件读取端口创建 Modbus TCP 连接器 + /// Create Modbus TCP linker with port read from configuration file + /// + /// 配置项 / Configuration Items: + /// + /// TCP:{IP}:ModbusPort - 指定 IP 的端口 / Port for specified IP + /// TCP:Modbus:ModbusPort - 默认 Modbus 端口 / Default Modbus port + /// 默认端口：502 / Default port: 502 + /// + /// + /// /// - /// IP地址 + /// + /// IP 地址 / IP Address + /// + /// Modbus TCP 设备的 IP 地址 + /// IP address of Modbus TCP device + /// + /// public ModbusTcpProtocolLinker(string ip) : this(ip, int.Parse(ConfigurationReader.GetValueDirect("TCP:" + ip, "ModbusPort") ?? ConfigurationReader.GetValueDirect("TCP:Modbus", "ModbusPort"))) { } /// - /// 构造函数 + /// 构造函数 (指定 IP 和端口) / Constructor (Specify IP and Port) + /// + /// 使用指定的 IP 地址和端口创建 Modbus TCP 连接器 + /// Create Modbus TCP linker with specified IP address and port + /// /// - /// IP地址 - /// 端口 + /// + /// IP 地址 / IP Address + /// Modbus TCP 设备的 IP 地址 / IP address of Modbus TCP device + /// + /// + /// 端口号 / Port Number + /// + /// Modbus TCP 默认端口：502 + /// Modbus TCP default port: 502 + /// + /// public ModbusTcpProtocolLinker(string ip, int port) : base(ip, port) { } /// - /// 校验返回数据 + /// 校验返回数据 / Validate Return Data + /// + /// 校验从设备返回的 Modbus TCP 响应数据 + /// Validate Modbus TCP response data returned from device + /// + /// 校验流程 / Validation Flow: + /// + /// 调用基类校验 (TCP 连接状态) / Call base validation (TCP connection status) + /// 检查 MBAP 头第 8 字节 (功能码) / Check MBAP header byte 8 (function code) + /// 如果功能码>127，表示错误响应 / If function code>127, indicates error response + /// 抛出 ModbusProtocolErrorException / Throw ModbusProtocolErrorException + /// + /// + /// + /// 错误码说明 / Error Code Description: + /// + /// 功能码 +128: 异常响应 / Function code +128: Exception response + /// 异常码在 content[8] / Exception code in content[8] + /// + /// + /// /// - /// 设备返回的数据 - /// 数据是否正确 + /// + /// 设备返回的数据 / Data Returned from Device + /// + /// 包含 MBAP 头的完整 Modbus TCP 响应 + /// Complete Modbus TCP response with MBAP header + /// + /// + /// + /// 数据是否正确 / Whether Data is Correct + /// + /// + /// true: 数据正确 / Data correct + /// false: 数据错误 / Data error + /// null: 无法判断 / Cannot determine + /// + /// + /// + /// + /// 当功能码>127 时抛出 Modbus 协议错误 + /// Throw Modbus protocol error when function code>127 + /// public override bool? CheckRight(byte[] content) { + // 基类校验 (TCP 连接状态) / Base validation (TCP connection status) if (base.CheckRight(content) != true) return base.CheckRight(content); - //Modbus协议错误 + + // Modbus 协议错误检测 / Modbus protocol error detection + // MBAP 头第 8 字节是功能码 / Byte 8 of MBAP header is function code if (content[7] > 127) + // 功能码>127 表示异常响应 / Function code>127 indicates exception response throw new ModbusProtocolErrorException(content[2] > 0 ? content[2] : content[8]); + return true; } } -} \ No newline at end of file +} diff --git a/Modbus.Net/Modbus.Net.Modbus/ModbusType.cs b/Modbus.Net/Modbus.Net.Modbus/ModbusType.cs new file mode 100644 index 0000000..05af290 --- /dev/null +++ b/Modbus.Net/Modbus.Net.Modbus/ModbusType.cs @@ -0,0 +1,222 @@ +using System; + +namespace Modbus.Net.Modbus +{ + /// + /// Modbus 连接类型枚举 / Modbus Connection Type Enum + /// + /// 定义 Modbus 协议支持的各种连接方式 + /// Defines various connection methods supported by Modbus protocol + /// + /// 连接类型说明 / Connection Type Description: + /// + /// Rtu - 串行 RTU 模式 (最常用) / Serial RTU mode (most common) + /// Tcp - 以太网 TCP 模式 / Ethernet TCP mode + /// Ascii - 串行 ASCII 模式 / Serial ASCII mode + /// RtuInTcp - TCP 透传 RTU 数据 / RTU data over TCP tunneling + /// AsciiInTcp - TCP 透传 ASCII 数据 / ASCII data over TCP tunneling + /// Udp - UDP 模式 / UDP mode + /// RtuInUdp - UDP 透传 RTU 数据 / RTU data over UDP tunneling + /// AsciiInUdp - UDP 透传 ASCII 数据 / ASCII data over UDP tunneling + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // Modbus TCP 连接 / Modbus TCP connection + /// var utility = new ModbusUtility( + /// ModbusType.Tcp, + /// "192.168.1.100:502", + /// slaveAddress: 1, + /// masterAddress: 0, + /// endian: Endian.BigEndianLsb + /// ); + /// + /// // Modbus RTU 串口连接 / Modbus RTU serial connection + /// var serialUtility = new ModbusUtility( + /// ModbusType.Rtu, + /// "COM1", + /// slaveAddress: 1, + /// masterAddress: 0, + /// endian: Endian.BigEndianLsb + /// ); + /// + /// // Modbus RTU over TCP (串口服务器) / Modbus RTU over TCP (Serial Server) + /// var tunnelUtility = new ModbusUtility( + /// ModbusType.RtuInTcp, + /// "192.168.1.200:8899", // 串口服务器地址 + /// slaveAddress: 1, + /// masterAddress: 0, + /// endian: Endian.BigEndianLsb + /// ); + /// + /// + /// + /// + public enum ModbusType + { + /// + /// RTU 连接 (串行) / RTU Connection (Serial) + /// + /// + /// 特点 / Characteristics: + /// + /// 二进制编码，效率高 / Binary encoding, high efficiency + /// CRC16 校验 / CRC16 checksum + /// 最常用的 Modbus 模式 / Most common Modbus mode + /// 适用于 RS-232/RS-485 串口 / Suitable for RS-232/RS-485 serial + /// + /// + /// + /// 帧格式 / Frame Format: + /// [从站地址][功能码][数据][CRC 低][CRC 高] + /// + /// + /// + Rtu = 0, + + /// + /// TCP 连接 (以太网) / TCP Connection (Ethernet) + /// + /// + /// 特点 / Characteristics: + /// + /// 基于以太网 / Based on Ethernet + /// 添加 MBAP 头 (6 字节) / Adds MBAP header (6 bytes) + /// 无需 CRC 校验 (TCP 已保证) / No CRC needed (TCP guarantees) + /// 端口：502 / Port: 502 + /// + /// + /// + /// MBAP 头格式 / MBAP Header Format: + /// [Transaction ID (2)][Protocol ID (2)][Length (2)][Unit ID (1)] + /// + /// + /// + Tcp = 1, + + /// + /// ASCII 连接 (串行) / ASCII Connection (Serial) + /// + /// + /// 特点 / Characteristics: + /// + /// ASCII 字符编码 / ASCII character encoding + /// LRC 校验 / LRC checksum + /// 以冒号 (:) 开始，CRLF 结束 / Starts with colon (:), ends with CRLF + /// 效率较低，但易于调试 / Lower efficiency, but easy to debug + /// + /// + /// + /// 帧格式 / Frame Format: + /// : [从站地址][功能码][数据][LRC][CR][LF] + /// + /// + /// + Ascii = 2, + + /// + /// RTU 连接 TCP 透传 / RTU Connection TCP Tunneling + /// + /// + /// 使用场景 / Use Cases: + /// + /// 串口服务器 / Serial device server + /// 通过 TCP 传输 RTU 帧 / Transmit RTU frames over TCP + /// 远程串口访问 / Remote serial access + /// + /// + /// + /// 特点 / Characteristics: + /// + /// RTU 帧原样传输 / RTU frames transmitted as-is + /// 无 MBAP 头 / No MBAP header + /// 保留 CRC 校验 / CRC checksum preserved + /// + /// + /// + /// + RtuInTcp = 3, + + /// + /// ASCII 连接 TCP 透传 / ASCII Connection TCP Tunneling + /// + /// + /// 使用场景 / Use Cases: + /// + /// 串口服务器 / Serial device server + /// 通过 TCP 传输 ASCII 帧 / Transmit ASCII frames over TCP + /// + /// + /// + /// 特点 / Characteristics: + /// + /// ASCII 帧原样传输 / ASCII frames transmitted as-is + /// 无 MBAP 头 / No MBAP header + /// 保留 LRC 校验 / LRC checksum preserved + /// + /// + /// + /// + AsciiInTcp = 4, + + /// + /// UDP 连接 / UDP Connection + /// + /// + /// 特点 / Characteristics: + /// + /// 无连接模式 / Connectionless mode + /// 添加 MBAP 头 / Adds MBAP header + /// 不保证可靠性 / No reliability guarantee + /// 适用于广播 / Suitable for broadcast + /// + /// + /// + /// + Udp = 5, + + /// + /// RTU 连接 UDP 透传 / RTU Connection UDP Tunneling + /// + /// + /// 使用场景 / Use Cases: + /// + /// UDP 广播查询 / UDP broadcast query + /// 通过 UDP 传输 RTU 帧 / Transmit RTU frames over UDP + /// + /// + /// + /// 特点 / Characteristics: + /// + /// RTU 帧原样传输 / RTU frames transmitted as-is + /// 无 MBAP 头 / No MBAP header + /// 保留 CRC 校验 / CRC checksum preserved + /// + /// + /// + /// + RtuInUdp = 6, + + /// + /// ASCII 连接 UDP 透传 / ASCII Connection UDP Tunneling + /// + /// + /// 使用场景 / Use Cases: + /// + /// 通过 UDP 传输 ASCII 帧 / Transmit ASCII frames over UDP + /// + /// + /// + /// 特点 / Characteristics: + /// + /// ASCII 帧原样传输 / ASCII frames transmitted as-is + /// 无 MBAP 头 / No MBAP header + /// 保留 LRC 校验 / LRC checksum preserved + /// + /// + /// + /// + AsciiInUdp = 7 + } +} diff --git a/Modbus.Net/Modbus.Net.Modbus/ModbusUdpProtocol.cs b/Modbus.Net/Modbus.Net.Modbus/ModbusUdpProtocol.cs index d952863..725c6e6 100644 --- a/Modbus.Net/Modbus.Net.Modbus/ModbusUdpProtocol.cs +++ b/Modbus.Net/Modbus.Net.Modbus/ModbusUdpProtocol.cs @@ -1,43 +1,154 @@ -namespace Modbus.Net.Modbus +namespace Modbus.Net.Modbus { /// - /// Modbus/Udp协议 + /// Modbus/UDP 协议类 / Modbus/UDP Protocol Class + /// + /// 实现 Modbus UDP 协议，用于无连接的以太网通信 + /// Implements Modbus UDP protocol for connectionless Ethernet communication + /// + /// 协议特点 / Protocol Characteristics: + /// + /// 基于 UDP/IP 传输 / Based on UDP/IP transport + /// 添加 MBAP 头 (6 字节) / Adds MBAP header (6 bytes) + /// 无连接模式 / Connectionless mode + /// 不保证可靠性 / No reliability guarantee + /// 适用于广播查询 / Suitable for broadcast query + /// 默认端口：502 / Default port: 502 + /// + /// + /// + /// 与 Modbus TCP 的区别 / Difference from Modbus TCP: + /// + /// UDP - 无连接，不保证送达，支持广播 / Connectionless, no delivery guarantee, supports broadcast + /// TCP - 面向连接，保证送达，不支持广播 / Connection-oriented, delivery guaranteed, no broadcast + /// + /// + /// + /// MBAP 头格式 / MBAP Header Format: + /// + /// [Transaction ID (2)][Protocol ID (2)][Length (2)][Unit ID (1)] + /// │ │ │ │ │ │ + /// └─ 事务标识，用于匹配请求响应 + /// └─ 协议标识，Modbus=0 + /// └─ 后续字节长度 + /// └─ 从站地址 + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // 创建 Modbus UDP 协议实例 / Create Modbus UDP protocol instance + /// var protocol = new ModbusUdpProtocol("192.168.1.100", 502, slaveAddress: 1, masterAddress: 0); + /// + /// // 或者从配置读取 / Or read from configuration + /// var protocolFromConfig = new ModbusUdpProtocol(slaveAddress: 1, masterAddress: 0); + /// // 配置项：UDP:Modbus:IP = "192.168.1.100" + /// + /// // 连接设备 (UDP 无需真正连接) / Connect to device (UDP doesn't need real connection) + /// await protocol.ConnectAsync(); + /// + /// // 发送读取请求 / Send read request + /// var inputStruct = new ReadDataModbusInputStruct(1, "4X 1", 10, addressTranslator, 0); + /// var outputStruct = await protocol.SendReceiveAsync<ReadDataModbusOutputStruct>( + /// protocol[typeof(ReadDataModbusProtocol)], + /// inputStruct + /// ); + /// + /// // UDP 广播查询示例 / UDP broadcast query example + /// var broadcastProtocol = new ModbusUdpProtocol("255.255.255.255", 502, slaveAddress: 0, masterAddress: 0); + /// // 注意：广播地址为 0，所有从站都会响应 + /// // Note: Broadcast address is 0, all slaves will respond + /// + /// + /// /// public class ModbusUdpProtocol : ModbusProtocol { /// - /// 构造函数 + /// 构造函数 (从配置读取 IP) / Constructor (Read IP from Configuration) + /// + /// 从配置文件读取 IP 地址创建 Modbus UDP 协议实例 + /// Create Modbus UDP protocol instance with IP address read from configuration file + /// + /// 配置项 / Configuration Item: + /// UDP:Modbus:IP = "192.168.1.100" + /// + /// /// - /// 从站号 - /// 主站号 + /// + /// 从站号 / Slave Address + /// Modbus 从站地址，范围 1-247 / Modbus slave address, range 1-247 + /// + /// + /// 主站号 / Master Address + /// 通常为 0 或 1 / Usually 0 or 1 + /// public ModbusUdpProtocol(byte slaveAddress, byte masterAddress) : this(ConfigurationReader.GetValueDirect("UDP:Modbus", "IP"), slaveAddress, masterAddress) { } /// - /// 构造函数 + /// 构造函数 (指定 IP) / Constructor (Specify IP) + /// + /// 使用指定的 IP 地址创建 Modbus UDP 协议实例 + /// Create Modbus UDP protocol instance with specified IP address + /// + /// 使用默认端口 502 + /// Uses default port 502 + /// + /// /// - /// ip地址 - /// 从站号 - /// 主站号 + /// + /// IP 地址 / IP Address + /// + /// 如 "192.168.1.100" 或广播地址 "255.255.255.255" + /// e.g., "192.168.1.100" or broadcast address "255.255.255.255" + /// + /// + /// 从站号 / Slave Address + /// 主站号 / Master Address public ModbusUdpProtocol(string ip, byte slaveAddress, byte masterAddress) : base(slaveAddress, masterAddress) { + // 创建 Modbus UDP 协议链接器 + // Create Modbus UDP protocol linker ProtocolLinker = new ModbusUdpProtocolLinker(ip); } /// - /// 构造函数 + /// 构造函数 (指定 IP 和端口) / Constructor (Specify IP and Port) + /// + /// 使用指定的 IP 地址和端口创建 Modbus UDP 协议实例 + /// Create Modbus UDP protocol instance with specified IP address and port + /// + /// 适用于非标准端口的设备 + /// Suitable for devices with non-standard ports + /// + /// /// - /// ip地址 - /// 端口 - /// 从站号 - /// 主站号 + /// + /// IP 地址 / IP Address + /// + /// 如 "192.168.1.100" 或广播地址 "255.255.255.255" + /// e.g., "192.168.1.100" or broadcast address "255.255.255.255" + /// + /// + /// + /// 端口号 / Port Number + /// + /// 默认 502 + /// Default 502 + /// + /// + /// 从站号 / Slave Address + /// 主站号 / Master Address public ModbusUdpProtocol(string ip, int port, byte slaveAddress, byte masterAddress) : base(slaveAddress, masterAddress) { + // 创建带端口的 Modbus UDP 协议链接器 + // Create Modbus UDP protocol linker with port ProtocolLinker = new ModbusUdpProtocolLinker(ip, port); } } -} \ No newline at end of file +} diff --git a/Modbus.Net/Modbus.Net.Modbus/ModbusUdpProtocolLinker.cs b/Modbus.Net/Modbus.Net.Modbus/ModbusUdpProtocolLinker.cs index 34f19ac..b29d614 100644 --- a/Modbus.Net/Modbus.Net.Modbus/ModbusUdpProtocolLinker.cs +++ b/Modbus.Net/Modbus.Net.Modbus/ModbusUdpProtocolLinker.cs @@ -1,40 +1,155 @@ -namespace Modbus.Net.Modbus +namespace Modbus.Net.Modbus { /// - /// Modbus/Udp协议连接器 + /// Modbus/UDP 协议连接器 / Modbus/UDP Protocol Linker + /// + /// 实现 Modbus UDP 协议的连接器，继承自 UdpProtocolLinker + /// Implements Modbus UDP protocol linker, inherits from UdpProtocolLinker + /// + /// 主要功能 / Main Functions: + /// + /// UDP 连接管理 / UDP connection management + /// MBAP 头处理 / MBAP header handling + /// 响应校验 / Response validation + /// 错误检测 / Error detection + /// 支持广播查询 / Supports broadcast query + /// + /// + /// + /// 与 TCP 的区别 / Difference from TCP: + /// + /// 无连接模式 / Connectionless mode + /// 不保证可靠性 / No reliability guarantee + /// 支持广播 / Supports broadcast + /// 适用于简单查询场景 / Suitable for simple query scenarios + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // 创建 Modbus UDP 连接器 / Create Modbus UDP linker + /// var linker = new ModbusUdpProtocolLinker("192.168.1.100", 502); + /// + /// // 连接设备 (UDP 无需真正连接) / Connect to device (UDP doesn't need real connection) + /// await linker.ConnectAsync(); + /// + /// // 发送数据 / Send data + /// byte[] request = [0x00, 0x01, 0x00, 0x00, 0x00, 0x06, 0x01, 0x03, 0x00, 0x00, 0x00, 0x0A]; + /// byte[] response = await linker.SendReceiveAsync(request); + /// + /// // CheckRight 会自动校验响应 + /// // CheckRight will automatically validate response + /// + /// + /// /// public class ModbusUdpProtocolLinker : UdpProtocolLinker { /// - /// 构造函数 + /// 构造函数 (从配置读取端口) / Constructor (Read Port from Configuration) + /// + /// 从配置文件读取端口创建 Modbus UDP 连接器 + /// Create Modbus UDP linker with port read from configuration file + /// + /// 配置项 / Configuration Items: + /// + /// UDP:{IP}:ModbusPort - 指定 IP 的端口 / Port for specified IP + /// UDP:Modbus:ModbusPort - 默认 Modbus 端口 / Default Modbus port + /// 默认端口：502 / Default port: 502 + /// + /// + /// /// - /// IP地址 + /// + /// IP 地址 / IP Address + /// + /// Modbus UDP 设备的 IP 地址 + /// IP address of Modbus UDP device + /// + /// public ModbusUdpProtocolLinker(string ip) : this(ip, int.Parse(ConfigurationReader.GetValueDirect("UDP:" + ip, "ModbusPort") ?? ConfigurationReader.GetValueDirect("UDP:Modbus", "ModbusPort"))) { } /// - /// 构造函数 + /// 构造函数 (指定 IP 和端口) / Constructor (Specify IP and Port) + /// + /// 使用指定的 IP 地址和端口创建 Modbus UDP 连接器 + /// Create Modbus UDP linker with specified IP address and port + /// /// - /// IP地址 - /// 端口 + /// + /// IP 地址 / IP Address + /// Modbus UDP 设备的 IP 地址 / IP address of Modbus UDP device + /// + /// + /// 端口号 / Port Number + /// + /// Modbus UDP 默认端口：502 + /// Modbus UDP default port: 502 + /// + /// public ModbusUdpProtocolLinker(string ip, int port) : base(ip, port) { } /// - /// 校验返回数据 + /// 校验返回数据 / Validate Return Data + /// + /// 校验从设备返回的 Modbus UDP 响应数据 + /// Validate Modbus UDP response data returned from device + /// + /// 校验流程 / Validation Flow: + /// + /// 调用基类校验 (UDP 连接状态) / Call base validation (UDP connection status) + /// 检查 MBAP 头第 8 字节 (功能码) / Check MBAP header byte 8 (function code) + /// 如果功能码>127，表示错误响应 / If function code>127, indicates error response + /// 抛出 ModbusProtocolErrorException / Throw ModbusProtocolErrorException + /// + /// + /// + /// 错误码说明 / Error Code Description: + /// + /// 功能码 +128: 异常响应 / Function code +128: Exception response + /// 异常码在 content[8] / Exception code in content[8] + /// + /// + /// /// - /// 设备返回的数据 - /// 数据是否正确 + /// + /// 设备返回的数据 / Data Returned from Device + /// + /// 包含 MBAP 头的完整 Modbus UDP 响应 + /// Complete Modbus UDP response with MBAP header + /// + /// + /// + /// 数据是否正确 / Whether Data is Correct + /// + /// + /// true: 数据正确 / Data correct + /// false: 数据错误 / Data error + /// null: 无法判断 / Cannot determine + /// + /// + /// + /// + /// 当功能码>127 时抛出 Modbus 协议错误 + /// Throw Modbus protocol error when function code>127 + /// public override bool? CheckRight(byte[] content) { + // 基类校验 (UDP 连接状态) / Base validation (UDP connection status) if (base.CheckRight(content) != true) return base.CheckRight(content); - //Modbus协议错误 + + // Modbus 协议错误检测 / Modbus protocol error detection + // MBAP 头第 8 字节是功能码 / Byte 8 of MBAP header is function code if (content[7] > 127) + // 功能码>127 表示异常响应 / Function code>127 indicates exception response throw new ModbusProtocolErrorException(content[2] > 0 ? content[2] : content[8]); + return true; } } -} \ No newline at end of file +} diff --git a/Modbus.Net/Modbus.Net.Modbus/ModbusUtility.cs b/Modbus.Net/Modbus.Net.Modbus/ModbusUtility.cs index e2f02d2..33895c0 100644 --- a/Modbus.Net/Modbus.Net.Modbus/ModbusUtility.cs +++ b/Modbus.Net/Modbus.Net.Modbus/ModbusUtility.cs @@ -1,57 +1,73 @@ -using Microsoft.Extensions.Logging; +using Microsoft.Extensions.Logging; using System; using System.Threading.Tasks; namespace Modbus.Net.Modbus { /// - /// Modbus连接类型 - /// - public enum ModbusType - { - /// - /// Rtu连接 - /// - Rtu = 0, - - /// - /// Tcp连接 - /// - Tcp = 1, - - /// - /// Ascii连接 - /// - Ascii = 2, - - /// - /// Rtu连接Tcp透传 - /// - RtuInTcp = 3, - - /// - /// Ascii连接Tcp透传 - /// - AsciiInTcp = 4, - - /// - /// Udp连接 - /// - Udp = 5, - - /// - /// Rtu连接Udp透传 - /// - RtuInUdp = 6, - - /// - /// Ascii连接Udp透传 - /// - AsciiInUdp = 7 - } - - /// - /// Modbus基础Api入口 + /// Modbus 基础 API 入口类 / Modbus Base API Entry Class + /// + /// 提供 Modbus 协议的完整实现，支持多种连接方式和高级功能 + /// Provides complete Modbus protocol implementation, supporting multiple connection methods and advanced features + /// + /// 支持的连接类型 / Supported Connection Types: + /// + /// ModbusType.Rtu - 串行 RTU 模式 (最常用) / Serial RTU mode (most common) + /// ModbusType.Tcp - 以太网 TCP 模式 / Ethernet TCP mode + /// ModbusType.Ascii - 串行 ASCII 模式 / Serial ASCII mode + /// ModbusType.RtuInTcp - TCP 透传 RTU 数据 / RTU over TCP tunneling + /// ModbusType.AsciiInTcp - TCP 透传 ASCII 数据 / ASCII over TCP tunneling + /// ModbusType.Udp - UDP 模式 / UDP mode + /// ModbusType.RtuInUdp - UDP 透传 RTU 数据 / RTU over UDP tunneling + /// ModbusType.AsciiInUdp - UDP 透传 ASCII 数据 / ASCII over UDP tunneling + /// + /// + /// + /// 实现的功能码 / Implemented Function Codes: + /// + /// 01 - 读线圈状态 / Read Coil Status + /// 02 - 读离散输入 / Read Discrete Inputs + /// 03 - 读保持寄存器 / Read Holding Registers + /// 04 - 读输入寄存器 / Read Input Registers + /// 05 - 写单个线圈 / Write Single Coil + /// 06 - 写单个寄存器 / Write Single Register + /// 15 - 写多个线圈 / Write Multiple Coils + /// 16 - 写多个寄存器 / Write Multiple Registers + /// 23 - 读写多个寄存器 / Read/Write Multiple Registers + /// 07-08,11-12,17,20-22,24 - 其他高级功能 / Other advanced features + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // Modbus TCP 连接 / Modbus TCP connection + /// var utility = new ModbusUtility( + /// ModbusType.Tcp, + /// "192.168.1.100:502", + /// slaveAddress: 1, + /// masterAddress: 0, + /// endian: Endian.BigEndianLsb + /// ); + /// + /// // 连接设备 / Connect to device + /// await utility.ConnectAsync(); + /// + /// // 读取保持寄存器 / Read holding registers + /// var result = await utility.GetDatasAsync<ushort>("4X 1", 10); + /// if (result.IsSuccess) + /// { + /// ushort[] values = result.Datas; + /// Console.WriteLine($"Temperature: {values[0] * 0.1}°C"); + /// } + /// + /// // 写入寄存器 / Write registers + /// await utility.SetDatasAsync("4X 1", new object[] { (ushort)250, (ushort)300 }); + /// + /// // 断开连接 / Disconnect + /// utility.Disconnect(); + /// + /// + /// /// public class ModbusUtility : BaseUtility, PipeUnit>, IUtilityMethodExceptionStatus, @@ -67,17 +83,46 @@ namespace Modbus.Net.Modbus private static readonly ILogger logger = LogProvider.CreateLogger(); /// - /// Modbus协议类型 + /// Modbus 协议类型 / Modbus Protocol Type + /// + /// 当前使用的 Modbus 连接类型 + /// Current Modbus connection type in use + /// /// private ModbusType _modbusType; /// - /// 构造函数 + /// 构造函数 (无连接字符串) / Constructor (without Connection String) + /// + /// 初始化 Modbus Utility 实例，稍后通过 SetConnectionType 设置连接 + /// Initialize Modbus Utility instance, set connection later via SetConnectionType + /// /// - /// 协议类型 - /// 从站号 - /// 主站号 - /// 端格式 + /// + /// 协议类型 / Protocol Type + /// ModbusType 枚举值 / ModbusType enum value + /// + /// + /// 从站号 / Slave Address + /// + /// Modbus 从站地址，范围 1-247 + /// Modbus slave address, range 1-247 + /// + /// + /// + /// 主站号 / Master Address + /// + /// 通常为 0 或 1 + /// Usually 0 or 1 + /// + /// + /// + /// 端格式 / Endianness + /// + /// Modbus 标准使用 BigEndianLsb + /// Modbus standard uses BigEndianLsb + /// + /// public ModbusUtility(int connectionType, byte slaveAddress, byte masterAddress, Endian endian) : base(slaveAddress, masterAddress) @@ -89,13 +134,29 @@ namespace Modbus.Net.Modbus } /// - /// 构造函数 + /// 构造函数 (带连接字符串) / Constructor (with Connection String) + /// + /// 初始化 Modbus Utility 实例并立即设置连接 + /// Initialize Modbus Utility instance and set connection immediately + /// /// - /// 协议类型 - /// 连接地址 - /// 从站号 - /// 主站号 - /// 端格式 + /// + /// 协议类型 / Protocol Type + /// ModbusType 枚举值 / ModbusType enum value + /// + /// + /// 连接地址 / Connection Address + /// + /// 格式示例 / Format Examples: + /// + /// TCP: "192.168.1.100:502" + /// 串口："COM1" 或 "COM1,9600,None,8,1" + /// + /// + /// + /// 从站号 / Slave Address + /// 主站号 / Master Address + /// 端格式 / Endianness public ModbusUtility(ModbusType connectionType, string connectionString, byte slaveAddress, byte masterAddress, Endian endian) : base(slaveAddress, masterAddress) @@ -107,12 +168,20 @@ namespace Modbus.Net.Modbus } /// - /// 端格式 + /// 端格式 / Endianness + /// + /// Modbus 标准使用大端格式 (BigEndianLsb) + /// Modbus standard uses Big Endian format (BigEndianLsb) + /// /// public override Endian Endian { get; } /// - /// Ip地址 + /// IP 地址 (从连接字符串提取) / IP Address (Extracted from Connection String) + /// + /// 解析连接字符串中的 IP 部分 + /// Parse IP part from connection string + /// /// protected string ConnectionStringIp { @@ -124,7 +193,11 @@ namespace Modbus.Net.Modbus } /// - /// 端口 + /// 端口号 (从连接字符串提取) / Port Number (Extracted from Connection String) + /// + /// 解析连接字符串中的端口部分 + /// Parse port part from connection string + /// /// protected int? ConnectionStringPort { @@ -146,7 +219,11 @@ namespace Modbus.Net.Modbus } /// - /// 协议类型 + /// 协议类型 / Protocol Type + /// + /// 设置协议类型时会自动创建相应的协议实例 + /// Automatically creates corresponding protocol instance when setting protocol type + /// /// public ModbusType ModbusType { @@ -154,9 +231,11 @@ namespace Modbus.Net.Modbus set { _modbusType = value; + // 根据协议类型创建相应的协议实例 + // Create corresponding protocol instance based on protocol type switch (_modbusType) { - //Rtu协议 + // RTU 协议 / RTU Protocol case ModbusType.Rtu: { Wrapper = ConnectionString == null @@ -164,7 +243,7 @@ namespace Modbus.Net.Modbus : new ModbusRtuProtocol(ConnectionString, SlaveAddress, MasterAddress); break; } - //Tcp协议 + // TCP 协议 / TCP Protocol case ModbusType.Tcp: { Wrapper = ConnectionString == null @@ -175,7 +254,7 @@ namespace Modbus.Net.Modbus MasterAddress)); break; } - //Ascii协议 + // ASCII 协议 / ASCII Protocol case ModbusType.Ascii: { Wrapper = ConnectionString == null @@ -183,7 +262,7 @@ namespace Modbus.Net.Modbus : new ModbusAsciiProtocol(ConnectionString, SlaveAddress, MasterAddress); break; } - //Rtu协议Tcp透传 + // RTU over TCP 透传 / RTU over TCP Tunneling case ModbusType.RtuInTcp: { Wrapper = ConnectionString == null @@ -194,7 +273,7 @@ namespace Modbus.Net.Modbus MasterAddress)); break; } - //Ascii协议Tcp透传 + // ASCII over TCP 透传 / ASCII over TCP Tunneling case ModbusType.AsciiInTcp: { Wrapper = ConnectionString == null @@ -205,7 +284,7 @@ namespace Modbus.Net.Modbus MasterAddress)); break; } - //Tcp协议Udp透传 + // UDP 协议 / UDP Protocol case ModbusType.Udp: { Wrapper = ConnectionString == null @@ -216,7 +295,7 @@ namespace Modbus.Net.Modbus MasterAddress)); break; } - //Rtu协议Udp透传 + // RTU over UDP 透传 / RTU over UDP Tunneling case ModbusType.RtuInUdp: { Wrapper = ConnectionString == null @@ -227,7 +306,7 @@ namespace Modbus.Net.Modbus MasterAddress)); break; } - //Rtu协议Udp透传 + // ASCII over UDP 透传 / ASCII over UDP Tunneling case ModbusType.AsciiInUdp: { Wrapper = ConnectionString == null @@ -243,24 +322,69 @@ namespace Modbus.Net.Modbus } /// - /// 设置协议类型 + /// 设置协议类型 / Set Protocol Type + /// + /// 实现 BaseUtility 的抽象方法 + /// Implements abstract method from BaseUtility + /// /// - /// 协议类型 + /// 协议类型 / Protocol Type public override void SetConnectionType(int connectionType) { ModbusType = (ModbusType)connectionType; } - /// + /// + /// 读取数据 (基础方法) / Read Data (Base Method) + /// + /// 实现 BaseUtility 的抽象方法，读取原始字节数据 + /// Implements abstract method from BaseUtility, reads raw byte data + /// + /// 处理流程 / Processing Flow: + /// + /// 创建 ReadDataModbusInputStruct / Create ReadDataModbusInputStruct + /// 调用协议层发送接收 / Call protocol layer send/receive + /// 返回 ReadDataModbusOutputStruct 中的数据 / Return data from ReadDataModbusOutputStruct + /// 处理 ModbusProtocolErrorException / Handle ModbusProtocolErrorException + /// + /// + /// + /// + /// + /// 开始地址 / Start Address + /// + /// 格式："4X 1", "0X 10" 等 + /// Format: "4X 1", "0X 10", etc. + /// + /// + /// 获取字节数个数 / Number of Bytes to Get + /// 获取原始个数 (用于位操作) / Get Original Count (for bit operations) + /// + /// 接收到的 byte 数据 / Received Byte Data + /// + /// ReturnStruct<byte[]> 包含： + /// ReturnStruct<byte[]> contains: + /// + /// Datas: 读取的字节数组 / Read byte array + /// IsSuccess: 读取是否成功 / Read success flag + /// ErrorCode: 错误码 / Error code + /// ErrorMsg: 错误消息 / Error message + /// + /// + /// public override async Task> GetDatasAsync(string startAddress, int getByteCount, int getOriginalCount) { try { + // 创建读取输入结构 / Create read input structure var inputStruct = new ReadDataModbusInputStruct(SlaveAddress, startAddress, (ushort)getByteCount, AddressTranslator, (ushort)getOriginalCount); + + // 发送接收 / Send and receive var outputStruct = await Wrapper.SendReceiveAsync(Wrapper[typeof(ReadDataModbusProtocol)], inputStruct); + return new ReturnStruct { Datas = outputStruct?.DataValue, @@ -282,16 +406,62 @@ namespace Modbus.Net.Modbus } } - /// + /// + /// 写入数据 (基础方法) / Write Data (Base Method) + /// + /// 实现 BaseUtility 的抽象方法，写入对象数组 + /// Implements abstract method from BaseUtility, writes object array + /// + /// 处理流程 / Processing Flow: + /// + /// 创建 WriteDataModbusInputStruct / Create WriteDataModbusInputStruct + /// 调用协议层发送接收 / Call protocol layer send/receive + /// 验证写入长度 / Verify write length + /// 处理 ModbusProtocolErrorException / Handle ModbusProtocolErrorException + /// + /// + /// + /// + /// + /// 开始地址 / Start Address + /// 格式："4X 1", "0X 10" 等 / Format: "4X 1", "0X 10", etc. + /// + /// + /// 设置数据 / Set Data + /// + /// 对象数组，如 [(ushort)100, (ushort)200] + /// Object array, e.g., [(ushort)100, (ushort)200] + /// + /// + /// + /// 设置原始长度 (用于位操作) / Set Original Length (for bit operations) + /// + /// + /// 是否设置成功 / Whether Set is Successful + /// + /// ReturnStruct<bool>: + /// + /// Datas: true=成功，false=失败 / true=success, false=failure + /// IsSuccess: 操作是否成功 / Operation success flag + /// ErrorCode: 错误码 / Error code + /// ErrorMsg: 错误消息 / Error message + /// + /// + /// public override async Task> SetDatasAsync(string startAddress, object[] setContents, int setOriginalCount) { try { + // 创建写入输入结构 / Create write input structure var inputStruct = new WriteDataModbusInputStruct(SlaveAddress, startAddress, setContents, AddressTranslator, Endian, (ushort)setOriginalCount); + + // 发送接收 / Send and receive var outputStruct = await Wrapper.SendReceiveAsync(Wrapper[typeof(WriteDataModbusProtocol)], inputStruct); + + // 验证写入长度 / Verify write length var ans = outputStruct?.WriteCount * 2 == BigEndianLsbValueHelper.Instance.ObjectArrayToByteArray(setContents).Length; return new ReturnStruct() { @@ -314,7 +484,14 @@ namespace Modbus.Net.Modbus } } - /// + /// + /// 获取异常状态 (功能码 07) / Get Exception Status (Function Code 07) + /// + /// 仅用于串行通信 (RTU/ASCII) + /// For serial communication only (RTU/ASCII) + /// + /// + /// 异常状态字节 / Exception Status Byte public async Task> GetExceptionStatusAsync() { try @@ -344,7 +521,16 @@ namespace Modbus.Net.Modbus } } - /// + /// + /// 诊断功能 (功能码 08) / Diagnostics (Function Code 08) + /// + /// 仅用于串行通信 (RTU/ASCII) + /// For serial communication only (RTU/ASCII) + /// + /// + /// 子功能码 / Sub-function Code + /// 数据数组 / Data Array + /// 诊断数据 / Diagnostics Data public async Task> GetDiagnoticsAsync(ushort subFunction, ushort[] data) { try @@ -374,7 +560,14 @@ namespace Modbus.Net.Modbus } } - /// + /// + /// 获取通讯事件计数器 (功能码 11) / Get Comm Event Counter (Function Code 11) + /// + /// 仅用于串行通信 (RTU/ASCII) + /// For serial communication only (RTU/ASCII) + /// + /// + /// 通讯事件计数器数据 / Comm Event Counter Data public async Task> GetCommEventCounterAsync() { try @@ -404,7 +597,14 @@ namespace Modbus.Net.Modbus } } - /// + /// + /// 获取通讯事件日志 (功能码 12) / Get Comm Event Log (Function Code 12) + /// + /// 仅用于串行通信 (RTU/ASCII) + /// For serial communication only (RTU/ASCII) + /// + /// + /// 通讯事件日志数据 / Comm Event Log Data public async Task> GetCommEventLogAsync() { try @@ -434,7 +634,14 @@ namespace Modbus.Net.Modbus } } - /// + /// + /// 报告从站 ID (功能码 17) / Report Slave ID (Function Code 17) + /// + /// 仅用于串行通信 (RTU/ASCII) + /// For serial communication only (RTU/ASCII) + /// + /// + /// 从站 ID 数据 / Slave ID Data public async Task> GetSlaveIdAsync() { try @@ -464,7 +671,15 @@ namespace Modbus.Net.Modbus } } - /// + /// + /// 读文件记录 (功能码 20) / Read File Record (Function Code 20) + /// + /// 读取从站文件记录 + /// Read slave file records + /// + /// + /// 文件记录定义数组 / File Record Definition Array + /// 文件记录输出定义数组 / File Record Output Definition Array public async Task> GetFileRecordAsync(ReadFileRecordInputDef[] recordDefs) { try @@ -494,7 +709,15 @@ namespace Modbus.Net.Modbus } } - /// + /// + /// 写文件记录 (功能码 21) / Write File Record (Function Code 21) + /// + /// 写入从站文件记录 + /// Write slave file records + /// + /// + /// 文件记录输入定义数组 / File Record Input Definition Array + /// 文件记录输出定义数组 / File Record Output Definition Array public async Task> SetFileRecordAsync(WriteFileRecordInputDef[] recordDefs) { try @@ -524,7 +747,17 @@ namespace Modbus.Net.Modbus } } - /// + /// + /// 写寄存器掩码 (功能码 22) / Mask Write Register (Function Code 22) + /// + /// 对寄存器进行 AND/OR 掩码操作 + /// Perform AND/OR mask operation on register + /// + /// + /// 参考地址 / Reference Address + /// AND 掩码 / AND Mask + /// OR 掩码 / OR Mask + /// 掩码寄存器数据 / Mask Register Data public async Task> SetMaskRegister(ushort referenceAddress, ushort andMask, ushort orMask) { try @@ -554,7 +787,18 @@ namespace Modbus.Net.Modbus } } - /// + /// + /// 读写多个寄存器 (功能码 23) / Read/Write Multiple Registers (Function Code 23) + /// + /// 原子操作：先读后写 + /// Atomic operation: read then write + /// + /// + /// 读起始地址 / Read Starting Address + /// 读数量 / Quantity to Read + /// 写起始地址 / Write Starting Address + /// 写值数组 / Write Values Array + /// 读取的寄存器值数组 / Read Register Values Array public async Task> GetMultipleRegister(ushort readStartingAddress, ushort quantityToRead, ushort writeStartingAddress, ushort[] writeValues) { try @@ -584,7 +828,15 @@ namespace Modbus.Net.Modbus } } - /// + /// + /// 读 FIFO 队列 (功能码 24) / Read FIFO Queue (Function Code 24) + /// + /// 读取从站 FIFO 队列 + /// Read slave FIFO queue + /// + /// + /// FIFO 指针地址 / FIFO Pointer Address + /// FIFO 值寄存器数组 / FIFO Value Register Array public async Task> GetFIFOQueue(ushort fifoPointerAddress) { try @@ -614,4 +866,4 @@ namespace Modbus.Net.Modbus } } } -} \ No newline at end of file +} diff --git a/Modbus.Net/Modbus.Net.Modbus/ModbusUtilityServer.cs b/Modbus.Net/Modbus.Net.Modbus/ModbusUtilityServer.cs index 5c4c258..46935ee 100644 --- a/Modbus.Net/Modbus.Net.Modbus/ModbusUtilityServer.cs +++ b/Modbus.Net/Modbus.Net.Modbus/ModbusUtilityServer.cs @@ -1,7 +1,56 @@ -namespace Modbus.Net.Modbus +namespace Modbus.Net.Modbus { + /// + /// Modbus 服务器端工具类 / Modbus Server-Side Utility Class + /// + /// 实现 Modbus 从站/服务器端功能 + /// Implements Modbus slave/server-side functionality + /// + /// 主要功能 / Main Functions: + /// + /// 响应客户端读取请求 / Respond to client read requests + /// 响应客户端写入请求 / Respond to client write requests + /// 维护内部数据寄存器 / Maintain internal data registers + /// 处理 Modbus RTU/TCP 协议 / Handle Modbus RTU/TCP protocols + /// + /// + /// + /// 使用场景 / Use Cases: + /// + /// Modbus 从站设备模拟 / Modbus slave device simulation + /// 虚拟 PLC / Virtual PLC + /// 设备仿真测试 / Device simulation testing + /// 协议网关 / Protocol gateway + /// + /// + /// + /// 实现说明 / Implementation Notes: + /// + /// 继承自 BaseUtilityServer / Inherits from BaseUtilityServer + /// 需要实现 GetServerDatasAsync 和 SetServerDatasAsync / Need to implement GetServerDatasAsync and SetServerDatasAsync + /// 维护线圈 (0X) 和寄存器 (4X) 数据 / Maintain coil (0X) and register (4X) data + /// + /// + /// + /// TODO: 待实现 / To be implemented + /// + /// 内部寄存器数据存储 / Internal register data storage + /// 读写操作处理 / Read/write operation handling + /// 异常响应生成 / Exception response generation + /// + /// + /// + /// public class ModbusUtilityServer { - + // TODO: 实现 Modbus 服务器端功能 + // TODO: Implement Modbus server-side functionality + + // 建议的实现结构 / Suggested implementation structure: + // 1. 内部数据存储 (线圈和寄存器) / Internal data storage (coils and registers) + // 2. GetServerDatasAsync 实现 - 响应读请求 / GetServerDatasAsync implementation - respond to read requests + // 3. SetServerDatasAsync 实现 - 响应写请求 / SetServerDatasAsync implementation - respond to write requests + // 4. 异常处理 / Exception handling + // 5. 日志记录 / Logging } } diff --git a/Modbus.Net/Modbus.Net.Siemens/AddressFormaterSiemens.cs b/Modbus.Net/Modbus.Net.Siemens/AddressFormaterSiemens.cs index 4b78e02..16024a1 100644 --- a/Modbus.Net/Modbus.Net.Siemens/AddressFormaterSiemens.cs +++ b/Modbus.Net/Modbus.Net.Siemens/AddressFormaterSiemens.cs @@ -1,66 +1,220 @@ -namespace Modbus.Net.Siemens +namespace Modbus.Net.Siemens { /// - /// Siemens地址格式化（Modbus.Net专用格式） + /// 西门子 S7 地址格式化器类 / Siemens S7 Address Formater Classes + /// + /// 实现西门子 PLC 地址的内部格式到字符串格式的转换 + /// Implements conversion from Siemens PLC internal address format to string format + /// + /// 支持的格式 / Supported Formats: + /// + /// Modbus.Net 格式 - "DB1 0", "I 0.0", "MW100" 等 / Modbus.Net format + /// 西门子标准格式 - "DB1.DBW0", "I0.0", "MW100" 等 / Siemens standard format + /// + /// + /// + /// 地址组成 / Address Components: + /// + /// Area - 区域标识 (DB/I/Q/M 等) / Area identifier + /// Address - 地址偏移 / Address offset + /// SubAddress - 子地址 (位偏移) / Sub-address (bit offset) + /// + /// + /// + /// + + #region Modbus.Net 格式地址格式化器 / Modbus.Net Format Address Formater + + /// + /// Siemens 地址格式化器（Modbus.Net 专用格式） / Siemens Address Formater (Modbus.Net Format) + /// + /// 使用空格分隔的格式：区域 地址 [.子地址] + /// Uses space-separated format: Area Address [.SubAddress] + /// + /// 格式化示例 / Formatting Examples: + /// + /// Area="DB1", Address=0 → "DB1 0" + /// Area="I", Address=0, SubAddress=0 → "I 0.0" + /// Area="M", Address=100, SubAddress=0 → "M 100" + /// + /// + /// + /// 使用场景 / Use Cases: + /// + /// Modbus.Net 内部地址表示 / Modbus.Net internal address representation + /// 配置文件中的地址格式 / Address format in configuration files + /// + /// + /// /// public class AddressFormaterSiemens : AddressFormater { /// - /// 编码地址 + /// 编码地址 (无子地址) / Encode Address (without Sub-Address) + /// + /// 将区域和地址转换为字符串格式 + /// Convert area and address to string format + /// + /// 格式 / Format: + /// Area + " " + Address + /// + /// + /// 示例 / Examples: + /// + /// "DB1" + " " + 0 → "DB1 0" + /// "I" + " " + 10 → "I 10" + /// + /// + /// /// - /// 地址所在的数据区域 - /// 地址 - /// 编码后的地址 + /// + /// 地址所在的数据区域 / Data Area + /// + /// 如 "DB1", "I", "Q", "M" 等 + /// e.g., "DB1", "I", "Q", "M", etc. + /// + /// + /// 地址 / Address + /// 编码后的地址 / Encoded Address public override string FormatAddress(string area, int address) { return area + " " + address; } /// - /// 编码地址 + /// 编码地址 (带子地址) / Encode Address (with Sub-Address) + /// + /// 将区域、地址和子地址转换为字符串格式 + /// Convert area, address and sub-address to string format + /// + /// 格式 / Format: + /// Area + " " + Address + "." + SubAddress + /// + /// + /// 示例 / Examples: + /// + /// "I" + " " + 0 + "." + 0 → "I 0.0" + /// "DB1" + " " + 10 + "." + 3 → "DB1 10.3" + /// + /// + /// /// - /// 地址所在的数据区域 - /// 地址 - /// 子地址 - /// 编码后的地址 + /// 地址所在的数据区域 / Data Area + /// 地址 / Address + /// + /// 子地址 (位偏移) / Sub-Address (Bit Offset) + /// + /// 范围：0-7 + /// Range: 0-7 + /// + /// + /// 编码后的地址 / Encoded Address public override string FormatAddress(string area, int address, int subAddress) { return area + " " + address + "." + subAddress; } } + #endregion + + #region 西门子标准格式地址格式化器 / Siemens Standard Format Address Formater + /// - /// Siemens地址格式化（Siemens格式） + /// Siemens 地址格式化器（西门子标准格式） / Siemens Address Formater (Siemens Standard Format) + /// + /// 使用西门子标准格式：区域地址 [.子地址] + /// Uses Siemens standard format: AreaAddress [.SubAddress] + /// + /// 格式化示例 / Formatting Examples: + /// + /// Area="DB1", Address=0 → "DB1.DB0" + /// Area="DB1", Address=0, SubAddress=0 → "DB1.DBX0.0" + /// Area="I", Address=0, SubAddress=0 → "I0.0" + /// Area="M", Address=100 → "M100" + /// + /// + /// + /// DB 块特殊处理 / DB Block Special Handling: + /// + /// 添加 "DB" 前缀到地址 / Add "DB" prefix to address + /// 例如：DB1 块，地址 0 → "DB1.DB0" + /// + /// + /// /// public class AddressFormaterSimenseStandard : AddressFormater { /// - /// 编码地址 + /// 编码地址 (无子地址) / Encode Address (without Sub-Address) + /// + /// 将区域和地址转换为西门子标准格式字符串 + /// Convert area and address to Siemens standard format string + /// + /// DB 块处理 / DB Block Handling: + /// + /// 格式：Area + "." + "DB" + Address + /// 例如："DB1" + "." + "DB" + 0 → "DB1.DB0" + /// + /// + /// + /// 普通区域处理 / Normal Area Handling: + /// + /// 格式：Area + Address + /// 例如："I" + 0 → "I0" + /// + /// + /// /// - /// 地址所在的数据区域 - /// 地址 - /// 编码后的地址 + /// 地址所在的数据区域 / Data Area + /// 地址 / Address + /// 编码后的地址 / Encoded Address public override string FormatAddress(string area, int address) { + // DB 块特殊处理 / DB block special handling if (area.Length > 1 && area.ToUpper().Substring(0, 2) == "DB") return area.ToUpper() + "." + "DB" + address; + + // 普通区域处理 / Normal area handling return area.ToUpper() + address; } /// - /// 编码地址 + /// 编码地址 (带子地址) / Encode Address (with Sub-Address) + /// + /// 将区域、地址和子地址转换为西门子标准格式字符串 + /// Convert area, address and sub-address to Siemens standard format string + /// + /// DB 块处理 / DB Block Handling: + /// + /// 格式：Area + "." + "DB" + Address + "." + SubAddress + /// 例如："DB1" + "." + "DB" + 0 + "." + 0 → "DB1.DBX0.0" + /// + /// + /// + /// 普通区域处理 / Normal Area Handling: + /// + /// 格式：Area + Address + "." + SubAddress + /// 例如："I" + 0 + "." + 0 → "I0.0" + /// + /// + /// /// - /// 地址所在的数据区域 - /// 地址 - /// 子地址 - /// 编码后的地址 + /// 地址所在的数据区域 / Data Area + /// 地址 / Address + /// 子地址 (位偏移) / Sub-Address (Bit Offset) + /// 编码后的地址 / Encoded Address public override string FormatAddress(string area, int address, int subAddress) { + // DB 块特殊处理 / DB block special handling if (area.Length > 1 && area.ToUpper().Substring(0, 2) == "DB") return area.ToUpper() + "." + "DB" + address + "." + subAddress; + + // 普通区域处理 / Normal area handling return area.ToUpper() + address + "." + subAddress; } } -} \ No newline at end of file + + #endregion +} diff --git a/Modbus.Net/Modbus.Net.Siemens/AddressTranslatorSiemens.cs b/Modbus.Net/Modbus.Net.Siemens/AddressTranslatorSiemens.cs index 0129773..9ed54c9 100644 --- a/Modbus.Net/Modbus.Net.Siemens/AddressTranslatorSiemens.cs +++ b/Modbus.Net/Modbus.Net.Siemens/AddressTranslatorSiemens.cs @@ -1,107 +1,268 @@ -using System; +using System; using System.Collections.Generic; namespace Modbus.Net.Siemens { /// - /// 地址翻译器（Modbus.Net格式） + /// 西门子地址翻译器类 / Siemens Address Translator Classes + /// + /// 实现西门子 PLC 地址字符串到内部地址结构的转换 + /// Implements conversion from Siemens PLC address strings to internal address structure + /// + /// 支持的地址格式 / Supported Address Formats: + /// + /// DB 块地址 - "DB1.DBW0", "DB1.DBB0", "DB1.DBD0", "DB1.DBX0.0" + /// 输入映像区 - "I0.0", "IB0", "IW0", "ID0" + /// 输出映像区 - "Q0.0", "QB0", "QW0", "QD0" + /// 位存储区 - "M0.0", "MB0", "MW0", "MD0" + /// 数据块 - "DB1", "DB2" 等 / Data blocks + /// + /// + /// + /// 区域代码映射 / Area Code Mapping: + /// + /// S (0x04) - 系统存储区 / System memory + /// SM (0x05) - 特殊存储区 / Special memory + /// AI (0x06) - 模拟输入 / Analog input + /// AQ (0x07) - 模拟输出 / Analog output + /// C (0x1E) - 计数器 / Counter + /// T (0x1F) - 计时器 / Timer + /// HC (0x20) - 高速计数器 / High-speed counter + /// I (0x81) - 输入映像区 / Input image + /// Q (0x82) - 输出映像区 / Output image + /// M (0x83) - 位存储区 / Memory + /// DB (0x84) - 数据块 / Data block + /// V (0x184) - 变量存储区 (S7-200) / Variable memory (S7-200) + /// + /// + /// + /// + + #region Modbus.Net 格式地址翻译器 / Modbus.Net Format Address Translator + + /// + /// 地址翻译器（Modbus.Net 格式） / Address Translator (Modbus.Net Format) + /// + /// 使用空格分隔的格式：区域 地址 + /// Uses space-separated format: Area Address + /// + /// 地址格式 / Address Format: + /// + /// "DB1 0" - DB1 块，偏移 0 / DB1 block, offset 0 + /// "I 0" - 输入区，地址 0 / Input area, address 0 + /// "Q 100" - 输出区，地址 100 / Output area, address 100 + /// "M 50.2" - 存储区，地址 50，位 2 / Memory area, address 50, bit 2 + /// + /// + /// + /// DB 块特殊处理 / DB Block Special Handling: + /// + /// Area = DB 编号 * 256 + 0x84 + /// 例如：DB1 → Area = 1 * 256 + 0x84 = 0x0184 + /// + /// + /// /// public class AddressTranslatorSiemens : AddressTranslator { /// - /// 区域的翻译字典 + /// 区域代码翻译字典 / Area Code Translation Dictionary + /// + /// 存储区域字符串到代码的映射 + /// Stores mapping from area string to code + /// /// protected Dictionary AreaCodeDictionary; /// - /// 构造函数 + /// 构造函数 / Constructor + /// + /// 初始化区域代码字典 + /// Initialize area code dictionary + /// /// public AddressTranslatorSiemens() { AreaCodeDictionary = new Dictionary { - {"S", 0x04}, - {"SM", 0x05}, - {"AI", 0x06}, - {"AQ", 0x07}, - {"C", 0x1E}, - {"T", 0x1F}, - {"HC", 0x20}, - {"I", 0x81}, - {"Q", 0x82}, - {"M", 0x83}, - {"DB", 0x84}, - {"V", 0x184} + {"S", 0x04}, // 系统存储区 / System memory + {"SM", 0x05}, // 特殊存储区 / Special memory + {"AI", 0x06}, // 模拟输入 / Analog input + {"AQ", 0x07}, // 模拟输出 / Analog output + {"C", 0x1E}, // 计数器 / Counter + {"T", 0x1F}, // 计时器 / Timer + {"HC", 0x20}, // 高速计数器 / High-speed counter + {"I", 0x81}, // 输入映像区 / Input image + {"Q", 0x82}, // 输出映像区 / Output image + {"M", 0x83}, // 位存储区 / Memory + {"DB", 0x84}, // 数据块 / Data block + {"V", 0x184} // 变量存储区 (S7-200) / Variable memory (S7-200) }; } /// - /// 地址转换 + /// 地址转换 / Address Translate + /// + /// 将格式化的地址字符串翻译为 AddressDef 对象 + /// Translate formatted address string to AddressDef object + /// + /// 处理流程 / Processing Flow: + /// + /// 转为大写 / Convert to uppercase + /// 按空格分割 / Split by space + /// 提取区域 (head) 和地址 (tail) / Extract area (head) and address (tail) + /// 处理子地址 (位偏移) / Handle sub-address (bit offset) + /// DB 块特殊处理 / DB block special handling + /// 创建并返回 AddressDef / Create and return AddressDef + /// + /// + /// /// - /// 格式化的地址 - /// 是否为读取，是为读取，否为写入 - /// 翻译后的地址 + /// + /// 格式化的地址 / Formatted Address + /// + /// 示例 / Examples: + /// + /// "DB1 0" - DB1 块，偏移 0 + /// "I 0.2" - 输入区，地址 0，位 2 + /// "M 100" - 存储区，地址 100 + /// + /// + /// + /// + /// 是否为读取 / Whether it's Read + /// + /// true: 读取操作 / Read operation + /// false: 写入操作 / Write operation + /// + /// + /// + /// 翻译后的地址 / Translated Address + /// + /// AddressDef 包含： + /// AddressDef contains: + /// + /// AreaString: 区域字符串 / Area string + /// Area: 区域代码 / Area code + /// Address: 地址 / Address + /// SubAddress: 子地址 (位偏移) / Sub-address (bit offset) + /// + /// + /// public override AddressDef AddressTranslate(string address, bool isRead) { + // 转为大写 / Convert to uppercase address = address.ToUpper(); + + // 按空格分割 / Split by space var splitString = address.Split(' '); - var head = splitString[0]; - var tail = splitString[1]; + var head = splitString[0]; // 区域 / Area + var tail = splitString[1]; // 地址 / Address + + // 处理子地址 (位偏移) / Handle sub-address (bit offset) string sub; if (tail.Contains(".")) { var splitString2 = tail.Split('.'); - sub = splitString2[1]; - tail = splitString2[0]; + sub = splitString2[1]; // 子地址 / Sub-address + tail = splitString2[0]; // 主地址 / Main address } else { - sub = "0"; + sub = "0"; // 默认子地址 / Default sub-address } + + // DB 块特殊处理 / DB block special handling if (head.Length > 1 && head.Substring(0, 2) == "DB") { - head = head.Substring(2); + head = head.Substring(2); // 移除 "DB" 前缀 / Remove "DB" prefix return new AddressDef { - AreaString = "DB" + head, - Area = int.Parse(head) * 256 + AreaCodeDictionary["DB"], - Address = int.Parse(tail), - SubAddress = int.Parse(sub) + AreaString = "DB" + head, // 区域字符串 / Area string + Area = int.Parse(head) * 256 + AreaCodeDictionary["DB"], // DB 块代码 / DB block code + Address = int.Parse(tail), // 地址 / Address + SubAddress = int.Parse(sub) // 子地址 / Sub-address }; } - return - new AddressDef - { - AreaString = head, - Area = AreaCodeDictionary[head], - Address = int.Parse(tail), - SubAddress = int.Parse(sub) - }; + + // 普通区域处理 / Normal area handling + return new AddressDef + { + AreaString = head, + Area = AreaCodeDictionary[head], + Address = int.Parse(tail), + SubAddress = int.Parse(sub) + }; } /// - /// 获取区域中的单个地址占用的字节长度 + /// 获取区域字节长度 / Get Area Byte Length + /// + /// 返回区域中单个地址占用的字节长度 + /// Returns byte length per address in area + /// + /// 西门子地址默认返回 1 字节 + /// Siemens address defaults to 1 byte + /// + /// /// - /// 区域名称 - /// 字节长度 + /// 区域名称 / Area Name + /// 字节长度 / Byte Length public override double GetAreaByteLength(string area) { return 1; } } + #endregion + + #region 西门子标准格式地址翻译器 / Siemens Standard Format Address Translator + /// - /// 地址翻译器（Siemens格式） + /// 地址翻译器（西门子标准格式） / Address Translator (Siemens Standard Format) + /// + /// 使用西门子标准格式：区域地址.子地址 + /// Uses Siemens standard format: AreaAddress.SubAddress + /// + /// 支持的格式 / Supported Formats: + /// + /// "DB1.DBW0" - DB1 块，字地址 0 / DB1 block, word address 0 + /// "DB1.DBB0" - DB1 块，字节地址 0 / DB1 block, byte address 0 + /// "DB1.DBD0" - DB1 块，双字地址 0 / DB1 block, double word address 0 + /// "DB1.DBX0.0" - DB1 块，位地址 0.0 / DB1 block, bit address 0.0 + /// "I0.0" - 输入区，位地址 0.0 / Input area, bit address 0.0 + /// "QW10" - 输出区，字地址 10 / Output area, word address 10 + /// "MW100" - 存储区，字地址 100 / Memory area, word address 100 + /// + /// + /// + /// 地址类型后缀 / Address Type Suffixes: + /// + /// X - 位 / Bit (可选) + /// B - 字节 / Byte + /// W - 字 / Word + /// D - 双字 / Double word + /// + /// + /// /// public class AddressTranslatorSimenseStandard : AddressTranslator { /// - /// 区域的翻译字典 + /// 区域代码翻译字典 / Area Code Translation Dictionary + /// + /// 存储区域字符串到代码的映射 + /// Stores mapping from area string to code + /// /// protected Dictionary AreaCodeDictionary; /// - /// 构造函数 + /// 构造函数 / Constructor + /// + /// 初始化区域代码字典 + /// Initialize area code dictionary + /// /// public AddressTranslatorSimenseStandard() { @@ -123,21 +284,55 @@ namespace Modbus.Net.Siemens } /// - /// 地址转换 + /// 地址转换 / Address Translate + /// + /// 将西门子标准格式地址翻译为 AddressDef 对象 + /// Translate Siemens standard format address to AddressDef object + /// + /// DB 块格式 / DB Block Format: + /// + /// "DB1.DBW0" → AreaString="DB1", Area=0x0184, Address=0 + /// "DB1.DBB10" → AreaString="DB1", Area=0x0184, Address=10 + /// + /// + /// + /// 普通区域格式 / Normal Area Format: + /// + /// "I0.0" → AreaString="I", Area=0x81, Address=0, SubAddress=0 + /// "MW100" → AreaString="M", Area=0x83, Address=100, SubAddress=0 + /// + /// + /// /// - /// 格式化的地址 - /// 是否为读取，是为读取，否为写入 - /// 翻译后的地址 + /// + /// 格式化的地址 / Formatted Address + /// + /// 西门子标准格式 / Siemens standard format: + /// + /// "DB1.DBW0" + /// "I0.0" + /// "MW100" + /// + /// + /// + /// 是否为读取 / Whether it's Read + /// 翻译后的地址 / Translated Address public override AddressDef AddressTranslate(string address, bool isRead) { address = address.ToUpper(); + + // DB 块地址处理 / DB block address handling if (address.Substring(0, 2) == "DB") { var addressSplit = address.Split('.'); if (addressSplit.Length != 2 && addressSplit.Length != 3) throw new FormatException(); - addressSplit[0] = addressSplit[0].Substring(2); + + addressSplit[0] = addressSplit[0].Substring(2); // 移除 "DB" 前缀 / Remove "DB" prefix + + // 移除数据类型前缀 (DBW/DBB/DBD/DBX) / Remove data type prefix if (addressSplit[1].Substring(0, 2) == "DB") addressSplit[1] = addressSplit[1].Substring(2); + return new AddressDef { AreaString = "DB" + addressSplit[0], @@ -146,13 +341,20 @@ namespace Modbus.Net.Siemens SubAddress = addressSplit.Length == 2 ? 0 : int.Parse(addressSplit[2]) }; } + + // 普通区域地址处理 / Normal area address handling + // 查找第一个数字的位置 / Find first digit position var i = 0; int t; while (!int.TryParse(address[i].ToString(), out t) && i < address.Length) i++; + if (i == 0 || i >= address.Length) throw new FormatException(); - var head = address.Substring(0, i); - var tail = address.Substring(i).Split('.'); + + // 分割区域和地址 / Split area and address + var head = address.Substring(0, i); // 区域 / Area + var tail = address.Substring(i).Split('.'); // 地址和子地址 / Address and sub-address + return new AddressDef { AreaString = head, @@ -163,13 +365,19 @@ namespace Modbus.Net.Siemens } /// - /// 获取区域中的单个地址占用的字节长度 + /// 获取区域字节长度 / Get Area Byte Length + /// + /// 返回区域中单个地址占用的字节长度 + /// Returns byte length per address in area + /// /// - /// 区域名称 - /// 字节长度 + /// 区域名称 / Area Name + /// 字节长度 / Byte Length public override double GetAreaByteLength(string area) { return 1; } } -} \ No newline at end of file + + #endregion +} diff --git a/Modbus.Net/Modbus.Net.Siemens/SiemensController.cs b/Modbus.Net/Modbus.Net.Siemens/SiemensController.cs index e0bb902..95610da 100644 --- a/Modbus.Net/Modbus.Net.Siemens/SiemensController.cs +++ b/Modbus.Net/Modbus.Net.Siemens/SiemensController.cs @@ -1,29 +1,118 @@ -using System.Collections.Generic; +using System.Collections.Generic; namespace Modbus.Net.Siemens { /// - /// 西门子Ppi协议控制器 + /// 西门子 S7 协议控制器类 / Siemens S7 Protocol Controller Classes + /// + /// 实现西门子 S7 协议的控制器，管理消息发送和响应匹配 + /// Implements controllers for Siemens S7 protocol, managing message sending and response matching + /// + /// 主要控制器 / Main Controllers: + /// + /// SiemensPpiController - PPI 串口控制器 / PPI serial controller + /// SiemensTcpController - TCP 以太网控制器 / TCP Ethernet controller + /// + /// + /// + /// + + #region PPI 协议控制器 / PPI Protocol Controller + + /// + /// 西门子 PPI 协议控制器 / Siemens PPI Protocol Controller + /// + /// 用于 S7-200 系列 PLC 的 PPI 串口通信控制 + /// Used for PPI serial communication control of S7-200 series PLC + /// + /// 控制器特点 / Controller Characteristics: + /// + /// 继承自 FifoController / Inherits from FifoController + /// FIFO 顺序发送 / FIFO sequential sending + /// FCS 校验 / FCS checksum + /// 支持可变长度帧 / Supports variable length frames + /// + /// + /// + /// 帧长度计算 / Frame Length Calculation: + /// + /// 启动字符 0x10: 固定 6 字节 / Start char 0x10: Fixed 6 bytes + /// 启动字符 0xE5: 固定 1 字节 / Start char 0xE5: Fixed 1 byte + /// 其他：根据长度字段计算 / Others: Calculate based on length field + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // 创建 PPI 控制器 / Create PPI controller + /// var controller = new SiemensPpiController( + /// com: "COM1", + /// slaveAddress: 2 + /// ); + /// + /// // 添加到连接器 / Add to connector + /// connector.AddController(controller); + /// + /// + /// /// public class SiemensPpiController : FifoController { /// - /// 构造函数 + /// 构造函数 / Constructor + /// + /// 初始化 PPI 协议控制器，配置所有参数 + /// Initialize PPI protocol controller with all parameters + /// + /// 配置参数 / Configuration Parameters: + /// + /// FetchSleepTime: 从配置读取获取间隔 / Read from configuration + /// LengthCalc: PPI 帧长度计算 / PPI frame length calculation + /// CheckRightFunc: FCS 校验 / FCS checksum + /// WaitingListCount: 从配置读取等待队列长度 / Read from configuration + /// + /// + /// /// - /// 串口 - /// 从站号 + /// + /// 串口名称 / Serial Port Name + /// + /// 如 "COM1", "COM2" 等 + /// e.g., "COM1", "COM2", etc. + /// + /// + /// + /// 从站号 / Slave Address + /// + /// S7-200 的站地址，范围 0-126 + /// S7-200 station address, range 0-126 + /// + /// public SiemensPpiController(string com, int slaveAddress) : base( + // 从配置读取获取间隔时间 / Read fetch interval time from configuration int.Parse(ConfigurationReader.GetValue("COM:" + com + ":" + slaveAddress, "FetchSleepTime")), + + // PPI 帧长度计算 / PPI frame length calculation lengthCalc: content => { + // 启动字符 0x10: 固定 6 字节 + // Start char 0x10: Fixed 6 bytes if (content[0] == 0x10) return 6; + // 启动字符 0xE5: 固定 1 字节 (确认字符) + // Start char 0xE5: Fixed 1 byte (acknowledge char) else if (content[0] == 0xE5) return 1; + // 其他帧：根据长度字段计算 + // Other frames: Calculate based on length field else return DuplicateWithCount.GetDuplcateFunc(new List { 1 }, 6)(content); }, + + // FCS 校验函数 / FCS check function checkRightFunc: ContentCheck.FcsCheckRight, + + // 从配置读取等待队列长度 / Read waiting list count from configuration waitingListMaxCount: ConfigurationReader.GetValue("COM:" + com + ":" + slaveAddress, "WaitingListCount") != null ? int.Parse(ConfigurationReader.GetValue("COM:" + com + ":" + slaveAddress, "WaitingListCount")) : null @@ -31,23 +120,100 @@ namespace Modbus.Net.Siemens { } } + #endregion + + #region TCP 协议控制器 / TCP Protocol Controller + /// - /// 西门子Tcp协议控制器 + /// 西门子 TCP 协议控制器 / Siemens TCP Protocol Controller + /// + /// 用于 S7-1200/1500/300/400 系列 PLC 的 TCP 以太网通信控制 + /// Used for TCP Ethernet communication control of S7-1200/1500/300/400 series PLC + /// + /// 控制器特点 / Controller Characteristics: + /// + /// 继承自 MatchDirectlySendController / Inherits from MatchDirectlySendController + /// 匹配发送，无需等待响应 / Match send, no need to wait for response + /// 根据字节位置匹配请求响应 / Match request-response based on byte positions + /// + /// + /// + /// 匹配规则 / Matching Rules: + /// + /// 位置 11,12: 事务 ID / Positions 11,12: Transaction ID + /// 用于匹配请求和响应 / Used to match request and response + /// + /// + /// + /// 帧长度计算 / Frame Length Calculation: + /// + /// 根据位置 2,3 的长度字段计算 / Calculate based on length field at positions 2,3 + /// 固定偏移：0 字节 / Fixed offset: 0 bytes + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // 创建 TCP 控制器 / Create TCP controller + /// var controller = new SiemensTcpController( + /// ip: "192.168.1.100", + /// port: 102 + /// ); + /// + /// // 添加到连接器 / Add to connector + /// connector.AddController(controller); + /// + /// + /// /// public class SiemensTcpController : MatchDirectlySendController { /// - /// 构造函数 + /// 构造函数 / Constructor + /// + /// 初始化 TCP 协议控制器，配置所有参数 + /// Initialize TCP protocol controller with all parameters + /// + /// 配置参数 / Configuration Parameters: + /// + /// KeyMatches: 匹配规则 (位置 11,12 的事务 ID) / Match rules (transaction ID at positions 11,12) + /// LengthCalc: TCP 帧长度计算 / TCP frame length calculation + /// WaitingListCount: 从配置读取等待队列长度 / Read from configuration + /// + /// + /// /// - /// ip地址 - /// 端口号 + /// + /// IP 地址 / IP Address + /// + /// PLC 的 IP 地址 + /// PLC IP address + /// + /// + /// + /// 端口号 / Port Number + /// + /// 西门子 PLC 默认端口：102 + /// Siemens PLC default port: 102 + /// + /// public SiemensTcpController(string ip, int port) : base( + // 匹配规则：位置 11,12 的事务 ID + // Match rules: Transaction ID at positions 11,12 new ICollection<(int, int)>[] { new List<(int, int)> { (11, 11), (12, 12) } }, + + // TCP 帧长度计算 / TCP frame length calculation + // 根据位置 2,3 的长度字段计算 + // Calculate based on length field at positions 2,3 lengthCalc: DuplicateWithCount.GetDuplcateFunc(new List { 2, 3 }, 0), + + // 从配置读取等待队列长度 / Read waiting list count from configuration waitingListMaxCount: ConfigurationReader.GetValue("TCP:" + ip + ":" + port, "WaitingListCount") != null ? int.Parse(ConfigurationReader.GetValue("TCP:" + ip + ":" + port, "WaitingListCount")) : null ) { } } + + #endregion } diff --git a/Modbus.Net/Modbus.Net.Siemens/SiemensMachine.cs b/Modbus.Net/Modbus.Net.Siemens/SiemensMachine.cs index 08562d0..2c53a9e 100644 --- a/Modbus.Net/Modbus.Net.Siemens/SiemensMachine.cs +++ b/Modbus.Net/Modbus.Net.Siemens/SiemensMachine.cs @@ -1,53 +1,255 @@ -using System; +using System; using System.Collections.Generic; namespace Modbus.Net.Siemens { /// - /// 西门子设备 + /// 西门子 S7 设备类 / Siemens S7 Machine Class + /// + /// 提供西门子 S7 系列 PLC 的高级 API 封装 + /// Provides high-level API encapsulation for Siemens S7 series PLC + /// + /// 支持的 PLC 型号 / Supported PLC Models: + /// + /// S7-200 - 小型 PLC / Small PLC + /// S7-200 Smart - 增强型 S7-200 / Enhanced S7-200 + /// S7-300 - 中型 PLC / Medium PLC + /// S7-400 - 大型 PLC / Large PLC + /// S7-1200 - 紧凑型 PLC / Compact PLC + /// S7-1500 - 旗舰型 PLC / Flagship PLC + /// + /// + /// + /// 连接类型 / Connection Types: + /// + /// SiemensType.Ppi - PPI 串口连接 (S7-200) / PPI serial connection + /// SiemensType.Tcp - 以太网连接 (S7-1200/1500) / Ethernet connection + /// + /// + /// + /// 地址格式 / Address Formats: + /// + /// "DB1.DBW0" - DB1 块，字地址 0 / DB1 block, word address 0 + /// "DB1.DBB0" - DB1 块，字节地址 0 / DB1 block, byte address 0 + /// "DB1.DBD0" - DB1 块，双字地址 0 / DB1 block, double word address 0 + /// "DB1.DBX0.0" - DB1 块，位地址 0.0 / DB1 block, bit address 0.0 + /// "I0.0" - 输入映像区，位 0 / Input image, bit 0 + /// "Q0.0" - 输出映像区，位 0 / Output image, bit 0 + /// "M0.0" - 位存储区，位 0 / Memory, bit 0 + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // 定义地址配置 / Define address configuration + /// var addresses = new List<AddressUnit> + /// { + /// new AddressUnit + /// { + /// Id = "1", + /// Area = "DB1", + /// Address = 0, + /// CommunicationTag = "Temperature", + /// DataType = typeof(ushort), + /// Name = "进水温度", + /// Unit = "°C" + /// }, + /// new AddressUnit + /// { + /// Id = "2", + /// Area = "DB1", + /// Address = 2, + /// CommunicationTag = "Pressure", + /// DataType = typeof(ushort), + /// Name = "进水压力", + /// Unit = "MPa" + /// } + /// }; + /// + /// // 创建 S7-1200 设备实例 / Create S7-1200 machine instance + /// var machine = new SiemensMachine<string, string>( + /// id: "PLC1", + /// alias: "1#PLC", + /// connectionType: SiemensType.Tcp, + /// connectionString: "192.168.1.100:102", + /// model: SiemensMachineModel.S7_1200, + /// getAddresses: addresses, + /// keepConnect: true, + /// slaveAddress: 1, + /// masterAddress: 0, + /// src: 0x01, // 本地 TSAP / Local TSAP + /// dst: 0x01 // 远程 TSAP / Remote TSAP + /// ); + /// + /// // 连接 PLC / Connect to PLC + /// await machine.ConnectAsync(); + /// + /// // 读取数据 (按通信标签) / Read data (by communication tag) + /// var result = await machine.GetDatasAsync(MachineDataType.CommunicationTag); + /// if (result.IsSuccess) + /// { + /// double temperature = result.Datas["Temperature"].DeviceValue; + /// double pressure = result.Datas["Pressure"].DeviceValue; + /// Console.WriteLine($"温度：{temperature}°C, 压力：{pressure}MPa"); + /// } + /// + /// + /// /// - public class SiemensMachine : BaseMachine where TKey : IEquatable + /// + /// 设备 ID 类型 / Device ID Type + /// + /// 通常是 string 或 int + /// Usually string or int + /// + /// + /// + /// AddressUnit 的 ID 类型 / AddressUnit ID Type + /// + /// 通常是 string 或 int + /// Usually string or int + /// + /// + public class SiemensMachine : BaseMachine + where TKey : IEquatable where TUnitKey : IEquatable { /// - /// 构造函数 + /// 构造函数 (带保持连接参数) / Constructor (with Keep-Alive Parameter) + /// + /// 初始化西门子 S7 设备实例，配置所有通信参数 + /// Initialize Siemens S7 machine instance with all communication parameters + /// + /// 初始化内容 / Initialization Contents: + /// + /// 创建 SiemensUtility 实例 / Create SiemensUtility instance + /// 配置地址格式化器 / Configure address formater + /// 配置地址组合器 / Configure address combiner + /// 设置最大通信长度 100 字节 / Set max communication length 100 bytes + /// + /// + /// + /// TSAP 配置说明 / TSAP Configuration Notes: + /// + /// S7-200: src=本地栈号，dst=远程栈号 / src=local rack, dst=remote rack + /// S7-300/400: src=0x4b54(固定)，dst=0x0300+槽号 / dst=0x0300+slot + /// S7-1200/1500: src=0x1011(固定)，dst=0x0300+槽号 / dst=0x0300+slot + /// S7-200 Smart: src=0x0101(固定)，dst=0x0101(固定) / Fixed values + /// + /// + /// /// - /// 设备id号 - /// 连接类型 - /// 连接地址 - /// 设备类型 - /// 读写的地址 - /// 是否保持连接 - /// 从站号 - /// 主站号 - /// 本机模块位，0到7，仅200使用，其它型号不要填写 - /// PLC模块位，0到7，仅200使用，其它型号不要填写 + /// + /// 设备的 ID 号 / Device ID Number + /// + /// 唯一标识设备的字符串或数字 + /// String or number uniquely identifying the device + /// + /// + /// + /// 设备别名 / Device Alias + /// + /// 人类可读的设备名称 + /// Human-readable device name + /// + /// + /// + /// 连接类型 / Connection Type + /// + /// SiemensType.Ppi - PPI 串口连接 + /// SiemensType.Tcp - 以太网连接 + /// + /// + /// + /// 连接地址 / Connection Address + /// + /// TCP: "192.168.1.100:102" + /// PPI: "COM1" 或 "COM1,9600,None,8,1" + /// + /// + /// + /// 设备类型 / Device Model + /// + /// SiemensMachineModel 枚举值 + /// SiemensMachineModel enum value + /// + /// + /// + /// 读写的地址 / Addresses to Read/Write + /// + /// AddressUnit 列表，定义所有需要通信的地址 + /// AddressUnit list defining all addresses to communicate + /// + /// + /// + /// 是否保持连接 / Whether to Keep Connection + /// + /// true: 长连接，性能更好 / true: Long connection, better performance + /// false: 短连接，每次操作重新连接 / false: Short connection, reconnect each operation + /// + /// + /// + /// 从站号 / Slave Address + /// PLC 的站地址 / PLC station address + /// + /// + /// 主站号 / Master Address + /// PC/上位机的站地址 / PC/HMI station address + /// + /// + /// 本机模块位 / Local Module Position + /// + /// 0 到 7，仅 S7-200 使用，其它型号不要填写 + /// 0 to 7, only for S7-200, leave empty for other models + /// + /// + /// + /// PLC 模块位 / PLC Module Position + /// + /// 0 到 7，仅 S7-200 使用，其它型号不要填写 + /// 0 to 7, only for S7-200, leave empty for other models + /// + /// public SiemensMachine(TKey id, string alias, SiemensType connectionType, string connectionString, SiemensMachineModel model, IEnumerable> getAddresses, bool keepConnect, byte slaveAddress, byte masterAddress, byte src = 1, byte dst = 0) : base(id, alias, getAddresses, keepConnect, slaveAddress, masterAddress) { + // 创建 Siemens Utility 实例 / Create Siemens Utility instance BaseUtility = new SiemensUtility(connectionType, connectionString, model, slaveAddress, masterAddress, src, dst); + + // 配置西门子地址格式化器 / Configure Siemens address formater AddressFormater = new AddressFormaterSiemens(); + + // 配置地址组合器 (读取) / Configure address combiner (read) + // 使用连续地址组合器，最大长度 100 字节 + // Use continuous address combiner, max length 100 bytes AddressCombiner = new AddressCombinerContinus(AddressTranslator, 100); + + // 配置地址组合器 (写入) / Configure address combiner (write) AddressCombinerSet = new AddressCombinerContinus(AddressTranslator, 100); } /// - /// 构造函数 + /// 构造函数 (默认保持连接=true) / Constructor (Default Keep-Alive=true) + /// + /// 简化版本的构造函数，默认保持连接 + /// Simplified constructor version with default keep-alive + /// /// - /// 设备id号 - /// 连接类型 - /// 连接地址 - /// 设备类型 - /// 读写的地址 - /// 从站号 - /// 主站号 - /// 本机模块位，0到7，仅200使用，其它型号不要填写 - /// PLC模块位，0到7，仅200使用，其它型号不要填写 + /// 设备的 ID 号 / Device ID Number + /// 设备别名 / Device Alias + /// 连接类型 / Connection Type + /// 连接地址 / Connection Address + /// 设备类型 / Device Model + /// 读写的地址 / Addresses to Read/Write + /// 从站号 / Slave Address + /// 主站号 / Master Address + /// 本机模块位 / Local Module Position + /// PLC 模块位 / PLC Module Position public SiemensMachine(TKey id, string alias, SiemensType connectionType, string connectionString, SiemensMachineModel model, IEnumerable> getAddresses, byte slaveAddress, byte masterAddress, byte src = 1, byte dst = 0) : this(id, alias, connectionType, connectionString, model, getAddresses, true, slaveAddress, masterAddress, src, dst) { } } -} \ No newline at end of file +} diff --git a/Modbus.Net/Modbus.Net.Siemens/SiemensPpiProtocol.cs b/Modbus.Net/Modbus.Net.Siemens/SiemensPpiProtocol.cs index 422e378..b020da1 100644 --- a/Modbus.Net/Modbus.Net.Siemens/SiemensPpiProtocol.cs +++ b/Modbus.Net/Modbus.Net.Siemens/SiemensPpiProtocol.cs @@ -1,74 +1,223 @@ -using Nito.AsyncEx; +using Nito.AsyncEx; using System.Threading.Tasks; namespace Modbus.Net.Siemens { /// - /// 西门子Ppi协议 + /// 西门子 S7 PPI 协议类 / Siemens S7 PPI Protocol Class + /// + /// 实现西门子 S7-200 系列 PLC 的 PPI (Point-to-Point Interface) 串口通信协议 + /// Implements PPI (Point-to-Point Interface) serial communication protocol for Siemens S7-200 series PLC + /// + /// 协议特点 / Protocol Characteristics: + /// + /// 基于 RS-485 串口 / Based on RS-485 serial + /// 主从模式 / Master-slave mode + /// 令牌传递机制 / Token passing mechanism + /// 波特率：9.6K/19.2K/187.5K / Baud rate: 9.6K/19.2K/187.5K + /// 适用于 S7-200 系列 / Suitable for S7-200 series + /// + /// + /// + /// 与 TCP 协议的区别 / Difference from TCP Protocol: + /// + /// PPI - 串口通信，无需连接建立 / Serial communication, no connection establishment + /// TCP - 以太网通信，需要连接建立和参数协商 / Ethernet communication, requires connection establishment and parameter negotiation + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // 创建 S7-200 PPI 协议实例 / Create S7-200 PPI protocol instance + /// var protocol = new SiemensPpiProtocol( + /// "COM1", // 串口名称 / Serial port name + /// slaveAddress: 2, // S7-200 站地址 + /// masterAddress: 0 // PC/上位机站地址 + /// ); + /// + /// // 或者从配置读取 / Or read from configuration + /// var protocolFromConfig = new SiemensPpiProtocol(slaveAddress: 2, masterAddress: 0); + /// // 配置项：COM:Siemens:COM = "COM1" + /// + /// // 连接设备 (PPI 串口无需真正连接) / Connect to device (PPI serial doesn't need real connection) + /// await protocol.ConnectAsync(); + /// + /// // 读取 V 区数据 / Read V memory data + /// var inputStruct = new ReadDataSiemensInputStruct(...); + /// var outputStruct = await protocol.SendReceiveAsync<ReadDataSiemensOutputStruct>( + /// protocol[typeof(ReadDataSiemensProtocol)], + /// inputStruct + /// ); + /// + /// + /// /// public class SiemensPpiProtocol : SiemensProtocol { + /// + /// 串口名称 / Serial Port Name + /// + /// 如 "COM1", "COM2" 等 + /// e.g., "COM1", "COM2", etc. + /// + /// private readonly string _com; + + /// + /// 异步锁 / Async Lock + /// + /// 用于保护并发连接操作 + /// Used to protect concurrent connection operations + /// + /// private readonly AsyncLock _lock = new AsyncLock(); /// - /// 构造函数 + /// 构造函数 (从配置读取串口) / Constructor (Read COM Port from Configuration) + /// + /// 从配置文件读取串口名称创建 PPI 协议实例 + /// Create PPI protocol instance with COM port name read from configuration file + /// + /// 配置项 / Configuration Item: + /// COM:Siemens:COM = "COM1" + /// + /// /// - /// 从站号 - /// 主站号 + /// + /// 从站号 / Slave Address + /// + /// S7-200 的站地址，范围 0-126 + /// S7-200 station address, range 0-126 + /// + /// + /// + /// 主站号 / Master Address + /// + /// PC/上位机的站地址，通常为 0 + /// PC/HMI station address, usually 0 + /// + /// public SiemensPpiProtocol(byte slaveAddress, byte masterAddress) : this(ConfigurationReader.GetValueDirect("COM:Siemens", "COM"), slaveAddress, masterAddress) { } /// - /// 构造函数 + /// 构造函数 (指定串口) / Constructor (Specify COM Port) + /// + /// 使用指定的串口名称创建 PPI 协议实例 + /// Create PPI protocol instance with specified COM port name + /// + /// 串口配置从 appsettings.json 读取 + /// Serial port configuration is read from appsettings.json + /// + /// /// - /// 串口地址 - /// 从站号 - /// 主站号 + /// + /// 串口地址 / COM Port Address + /// + /// 如 "COM1", "COM2" 等 + /// e.g., "COM1", "COM2", etc. + /// + /// + /// 从站号 / Slave Address + /// 主站号 / Master Address public SiemensPpiProtocol(string com, byte slaveAddress, byte masterAddress) : base(slaveAddress, masterAddress) { _com = com; + // 创建 PPI 协议链接器 + // Create PPI protocol linker ProtocolLinker = new SiemensPpiProtocolLinker(_com, SlaveAddress); } /// - /// 发送协议内容并接收，一般方法 + /// 发送协议内容并接收 (参数数组版本) / Send Protocol Content and Receive (Parameter Array Version) + /// + /// 发送对象数组并接收响应 + /// Send object array and receive response + /// + /// 处理流程 / Processing Flow: + /// + /// 检查连接状态 / Check connection status + /// 如果未连接，尝试连接 / If not connected, try to connect + /// 发送数据并接收响应 / Send data and receive response + /// + /// + /// /// - /// 写入的内容，使用对象数组描述 - /// 从设备获取的字节流 + /// 写入的内容，使用对象数组描述 / Content to Write, Described Using Object Array + /// 从设备获取的字节流 / Byte Stream Received from Device public override async Task SendReceiveAsync(params object[] content) { + // 检查连接 / Check connection if (ProtocolLinker == null || !ProtocolLinker.IsConnected) await ConnectAsync(); + + // 发送接收 / Send and receive return await base.SendReceiveAsync(Endian, content); } /// - /// 强行发送，不检测连接状态 + /// 强行发送，不检测连接状态 / Force Send Without Checking Connection Status + /// + /// 直接发送数据，不检测连接状态 + /// Send data directly without checking connection status + /// + /// 使用场景 / Use Cases: + /// + /// 连接建立阶段 / Connection establishment phase + /// 特殊协议操作 / Special protocol operations + /// + /// + /// /// - /// 协议核心 - /// 协议的参数 - /// 设备返回的信息 + /// 协议核心 / Protocol Core + /// 协议的参数 / Protocol Parameters + /// 设备返回的信息 / Information Returned from Device private async Task ForceSendReceiveAsync(ProtocolUnit unit, IInputStruct content) { return await base.SendReceiveAsync(unit, content); } /// - /// 连接设备 + /// 连接设备 / Connect Device + /// + /// 打开串口并初始化 PPI 通信 + /// Open serial port and initialize PPI communication + /// + /// 处理流程 / Processing Flow: + /// + /// 获取异步锁 / Acquire async lock + /// 检查是否已连接 / Check if already connected + /// 打开串口 / Open serial port + /// 返回连接结果 / Return connection result + /// + /// + /// + /// PPI 串口特点 / PPI Serial Characteristics: + /// + /// 无需连接建立过程 / No connection establishment process + /// 打开串口即可通信 / Can communicate once serial port is opened + /// 主从模式，令牌传递 / Master-slave mode, token passing + /// + /// + /// /// - /// 是否连接成功 + /// 是否连接成功 / Whether Connection is Successful public override async Task ConnectAsync() { + // 获取异步锁 / Acquire async lock using (await _lock.LockAsync()) { + // 已连接 / Already connected if (ProtocolLinker.IsConnected) return true; + + // 打开串口 / Open serial port if (!await ProtocolLinker.ConnectAsync()) return false; } + return true; } } -} \ No newline at end of file +} diff --git a/Modbus.Net/Modbus.Net.Siemens/SiemensPpiProtocolLinker.cs b/Modbus.Net/Modbus.Net.Siemens/SiemensPpiProtocolLinker.cs index 60505d4..77c4d3a 100644 --- a/Modbus.Net/Modbus.Net.Siemens/SiemensPpiProtocolLinker.cs +++ b/Modbus.Net/Modbus.Net.Siemens/SiemensPpiProtocolLinker.cs @@ -1,4 +1,4 @@ -using System; +using System; using System.IO.Ports; using System.Threading; using System.Threading.Tasks; @@ -6,15 +6,87 @@ using System.Threading.Tasks; namespace Modbus.Net.Siemens { /// - /// 西门子Ppi协议连接器 + /// 西门子 S7 PPI 协议连接器 / Siemens S7 PPI Protocol Linker + /// + /// 实现西门子 S7-200 系列 PLC 的 PPI (Point-to-Point Interface) 串口通信连接器 + /// Implements PPI (Point-to-Point Interface) serial communication linker for Siemens S7-200 series PLC + /// + /// 协议特点 / Protocol Characteristics: + /// + /// 基于 RS-485 串口 / Based on RS-485 serial + /// 主从模式 / Master-slave mode + /// 令牌传递机制 / Token passing mechanism + /// 波特率：9.6K/19.2K/187.5K / Baud rate: 9.6K/19.2K/187.5K + /// 适用于 S7-200 系列 / Suitable for S7-200 series + /// + /// + /// + /// 主要功能 / Main Functions: + /// + /// 串口连接管理 / Serial connection management + /// PPI 协议报文处理 / PPI protocol message handling + /// 确认报文处理 / Acknowledge message handling + /// 重试机制 / Retry mechanism + /// 报文校验 / Message validation + /// + /// + /// + /// 特殊处理 / Special Handling: + /// + /// 0xE5 确认字符处理 / 0xE5 acknowledge character handling + /// 0xF9 等待字符处理 / 0xF9 wait character handling + /// 0x7C 特殊帧处理 / 0x7C special frame handling + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // 创建 PPI 连接器 / Create PPI linker + /// var linker = new SiemensPpiProtocolLinker("COM1", slaveAddress: 2); + /// + /// // 连接设备 / Connect to device + /// await linker.ConnectAsync(); + /// + /// // 发送数据 / Send data + /// byte[] request = [0x68, 0x0B, 0x0B, 0x68, 0x02, ...]; + /// byte[] response = await linker.SendReceiveAsync(request); + /// + /// // 自动处理确认字符和重试 + /// // Automatically handles acknowledge characters and retries + /// + /// + /// /// public class SiemensPpiProtocolLinker : ComProtocolLinker { /// - /// 构造函数 + /// 构造函数 / Constructor + /// + /// 初始化 PPI 协议连接器，从配置读取校验位参数 + /// Initialize PPI protocol linker, read parity parameter from configuration + /// + /// 配置项 / Configuration Items: + /// + /// COM:Siemens:Parity - 校验位 / Parity + /// 默认：None / Default: None + /// + /// + /// /// - /// 串口地址 - /// 从站号 + /// + /// 串口地址 / Serial Port Address + /// + /// 如 "COM1", "COM2" 等 + /// e.g., "COM1", "COM2", etc. + /// + /// + /// + /// 从站号 / Slave Address + /// + /// S7-200 的站地址，范围 0-126 + /// S7-200 station address, range 0-126 + /// + /// public SiemensPpiProtocolLinker(string com, int slaveAddress) : base(com, slaveAddress, parity: ConfigurationReader.GetValue("COM:Siemens", "Parity") != null @@ -25,13 +97,50 @@ namespace Modbus.Net.Siemens } /// - /// 发送协议内容并接收返回 + /// 发送协议内容并接收返回 / Send Protocol Content and Receive Response + /// + /// 发送 PPI 协议报文并接收响应，处理特殊确认字符 + /// Send PPI protocol message and receive response, handle special acknowledge characters + /// + /// 处理流程 / Processing Flow: + /// + /// 扩展报文 (添加 PPI 头) / Extend message (add PPI header) + /// 如果是 0x7C 特殊帧，发送确认报文 / If 0x7C special frame, send acknowledge message + /// 发送扩展后的报文 / Send extended message + /// 如果响应是 0xE5，发送确认报文 / If response is 0xE5, send acknowledge message + /// 收缩报文 (移除 PPI 头) / Reduce message (remove PPI header) + /// + /// + /// + /// 特殊字符 / Special Characters: + /// + /// 0xE5 - 单字节确认 / Single-byte acknowledge + /// 0x7C - 特殊帧标识 / Special frame identifier + /// + /// + /// /// - /// 发送的报文 - /// 接收的报文 + /// + /// 发送的报文 / Message to Send + /// + /// PPI 协议报文 + /// PPI protocol message + /// + /// + /// + /// 接收的报文 / Received Message + /// + /// PPI 协议响应报文 + /// PPI protocol response message + /// + /// public override async Task SendReceiveAsync(byte[] content) { + // 扩展报文 (添加 PPI 头) / Extend message (add PPI header) var extBytes = BytesExtend(content); + + // 如果是 0x7C 特殊帧，发送确认报文 + // If 0x7C special frame, send acknowledge message if (extBytes[6] == 0x7c) { var inputStruct2 = new ComConfirmMessageSiemensInputStruct(content[4], content[5]); @@ -39,8 +148,13 @@ namespace Modbus.Net.Siemens await SendReceiveWithoutExtAndDecAsync( new ComConfirmMessageSiemensProtocol().Format(inputStruct2)); } + + // 发送扩展后的报文 / Send extended message var receiveBytes = await SendReceiveWithoutExtAndDecAsync(extBytes); if (receiveBytes == null) return null; + + // 如果响应是 0xE5，发送确认报文 + // If response is 0xE5, send acknowledge message if (content.Length > 6 && receiveBytes.Length == 1 && receiveBytes[0] == 0xe5) { var inputStruct2 = new ComConfirmMessageSiemensInputStruct(content[4], content[5]); @@ -49,20 +163,50 @@ namespace Modbus.Net.Siemens new ComConfirmMessageSiemensProtocol().Format(inputStruct2)); return BytesDecact(receiveBytes2); } + + // 收缩报文 (移除 PPI 头) / Reduce message (remove PPI header) return BytesDecact(receiveBytes); } /// - /// 发送协议内容并接收返回，不进行协议扩展和收缩 + /// 发送协议内容并接收返回，不进行协议扩展和收缩 / Send Protocol Content and Receive Response Without Extension and Reduction + /// + /// 直接发送报文并接收响应，处理 0xF9 等待字符 + /// Send message directly and receive response, handle 0xF9 wait character + /// + /// 处理流程 / Processing Flow: + /// + /// 调用基类发送接收 / Call base send/receive + /// 如果响应是 0xF9，等待并重试 / If response is 0xF9, wait and retry + /// 发送确认报文 / Send acknowledge message + /// 重复直到收到有效响应 / Repeat until valid response received + /// + /// + /// + /// 特殊字符 / Special Characters: + /// + /// 0xF9 - 等待字符，需要重试 / Wait character, needs retry + /// + /// + /// /// - /// 发送的报文 - /// 接收的报文 + /// + /// 发送的报文 / Message to Send + /// PPI 协议报文 / PPI protocol message + /// + /// + /// 接收的报文 / Received Message + /// PPI 协议响应报文 / PPI protocol response message + /// public override async Task SendReceiveWithoutExtAndDecAsync(byte[] content) { var ans = await base.SendReceiveWithoutExtAndDecAsync(content); + + // 处理 0xF9 等待字符 / Handle 0xF9 wait character while (ans?.Length == 1 && ans[0] == 0xf9) { - Thread.Sleep(500); + Thread.Sleep(500); // 等待 500ms / Wait 500ms + if (content.Length <= 6) { var inputStruct2 = new ComConfirmMessageSiemensInputStruct(content[1], content[2]); @@ -82,19 +226,65 @@ namespace Modbus.Net.Siemens } /// - /// 校验报文 + /// 校验报文 / Validate Message + /// + /// 校验从 S7-200 PLC 返回的 PPI 协议报文 + /// Validate PPI protocol message returned from S7-200 PLC + /// + /// 校验流程 / Validation Flow: + /// + /// 调用基类校验 (串口连接状态) / Call base validation (serial connection status) + /// 检查单字节 0xE5 确认 / Check single-byte 0xE5 acknowledge + /// 检查 6 字节短帧 / Check 6-byte short frame + /// 检查结束符 0x16 / Check terminator 0x16 + /// 检查长度字段 / Check length field + /// + /// + /// + /// PPI 帧格式 / PPI Frame Format: + /// + /// 单字节：0xE5 (确认) / Single byte: 0xE5 (acknowledge) + /// 短帧：6 字节 / Short frame: 6 bytes + /// 长帧：[长度][长度][数据...][0x16] / Long frame: [length][length][data...][0x16] + /// + /// + /// /// - /// 设备返回的信息 - /// 报文是否正确 + /// + /// 设备返回的信息 / Information Returned from Device + /// + /// PPI 协议报文 + /// PPI protocol message + /// + /// + /// + /// 报文是否正确 / Whether Message is Correct + /// + /// + /// true: 报文正确 / Message correct + /// false: 报文错误 / Message error + /// + /// + /// public override bool? CheckRight(byte[] content) { + // 基类校验 (串口连接状态) / Base validation (serial connection status) if (base.CheckRight(content) != true) return false; + + // 单字节 0xE5 确认 / Single-byte 0xE5 acknowledge if (content.Length == 1 && content[0] == 0xe5) return true; + + // 6 字节短帧 / 6-byte short frame if (content.Length == 6 && content[3] == 0) return true; + + // 检查结束符 0x16 / Check terminator 0x16 if (content[content.Length - 1] != 0x16) return false; + + // 检查长度字段 / Check length field if (content[1] != content.Length - 6) return false; + return true; } } -} \ No newline at end of file +} diff --git a/Modbus.Net/Modbus.Net.Siemens/SiemensProtocol.cs b/Modbus.Net/Modbus.Net.Siemens/SiemensProtocol.cs index 5d3f72f..d03c480 100644 --- a/Modbus.Net/Modbus.Net.Siemens/SiemensProtocol.cs +++ b/Modbus.Net/Modbus.Net.Siemens/SiemensProtocol.cs @@ -1,4 +1,4 @@ -using System; +using System; using System.Collections.Generic; using System.Linq; using ProtocolUnit = Modbus.Net.ProtocolUnit; @@ -6,121 +6,295 @@ using ProtocolUnit = Modbus.Net.ProtocolUnit; namespace Modbus.Net.Siemens { /// - /// 西门子数据类型 + /// 西门子 S7 协议枚举和基类 / Siemens S7 Protocol Enums and Base Classes + /// + /// 定义西门子 S7 协议的数据类型、错误码和协议基类 + /// Defines data types, error codes and protocol base classes for Siemens S7 protocol + /// + /// 主要枚举 / Main Enums: + /// + /// SiemensTypeCode - 数据类型编码 / Data type codes + /// SiemensAccessResult - 访问结果错误码 / Access result error codes + /// SiemensDataType - 数据访问类型 / Data access types + /// + /// + /// + /// + + #region 西门子数据类型枚举 / Siemens Data Type Enums + + /// + /// 西门子数据类型代码 / Siemens Data Type Code + /// + /// 定义西门子 PLC 支持的各种数据类型 + /// Defines various data types supported by Siemens PLC + /// + /// 数据类型说明 / Data Type Description: + /// + /// Bool (0x01) - 布尔类型，1 位 / Boolean type, 1 bit + /// Byte (0x02) - 字节类型，8 位 / Byte type, 8 bits + /// Word (0x03) - 字类型，16 位 / Word type, 16 bits + /// DWord (0x04) - 双字类型，32 位 / Double word type, 32 bits + /// C (0x1E) - 计数器 / Counter + /// T (0x1F) - 计时器 / Timer + /// HC (0x20) - 高速计数器 / High-speed counter + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // 读取 DB 块字数据 / Read DB block word data + /// var result = await utility.GetDatasAsync<ushort>("DB1.DBW0", 10); + /// // 数据类型：SiemensTypeCode.Word (0x03) + /// + /// // 读取位数据 / Read bit data + /// var bitResult = await utility.GetDatasAsync<bool>("DB1.DBX0.0", 1); + /// // 数据类型：SiemensTypeCode.Bool (0x01) + /// + /// + /// /// public enum SiemensTypeCode : byte { /// - /// 布尔 + /// 布尔类型 / Boolean Type + /// + /// 1 位，取值 0 或 1 + /// 1 bit, value 0 or 1 + /// /// Bool = 0x01, /// - /// 字节 + /// 字节类型 / Byte Type + /// + /// 8 位，无符号整数 (0-255) + /// 8 bits, unsigned integer (0-255) + /// /// Byte = 0x02, /// - /// 字 + /// 字类型 / Word Type + /// + /// 16 位，无符号整数 (0-65535) + /// 16 bits, unsigned integer (0-65535) + /// /// Word = 0x03, /// - /// 双字 + /// 双字类型 / Double Word Type + /// + /// 32 位，无符号整数 (0-4294967295) + /// 32 bits, unsigned integer (0-4294967295) + /// /// DWord = 0x04, /// - /// 计数器 + /// 计数器 / Counter + /// + /// S7-200 系列计数器 + /// S7-200 series counter + /// /// C = 0x1E, /// - /// 计时器 + /// 计时器 / Timer + /// + /// S7-200 系列计时器 + /// S7-200 series timer + /// /// T = 0x1F, /// - /// 高速计数器 + /// 高速计数器 / High-Speed Counter + /// + /// S7-200 系列高速计数器 + /// S7-200 series high-speed counter + /// /// HC = 0x20 } /// - /// 西门子通讯报错信息 + /// 西门子通讯访问结果 / Siemens Communication Access Result + /// + /// 定义西门子 PLC 访问的错误码 + /// Defines error codes for Siemens PLC access + /// + /// 错误码说明 / Error Code Description: + /// + /// 0xFF - 无错误 / No error + /// 0x01 - 硬件错误 / Hardware fault + /// 0x03 - 非法对象访问 / Illegal object access + /// 0x05 - 非法地址访问 / Invalid address + /// 0x06 - 不支持的数据类型 / Data type not supported + /// 0x0A - 对象不存在或长度错误 / Object not exist or length error + /// + /// + /// /// public enum SiemensAccessResult : byte { /// - /// 无错误 + /// 无错误 / No Error + /// + /// 访问成功 + /// Access successful + /// /// NoError = 0xFF, /// - /// 硬件错误 + /// 硬件错误 / Hardware Fault + /// + /// PLC 硬件故障 + /// PLC hardware fault + /// /// HardwareFault = 0x01, /// - /// 非法对象访问（Area错误） + /// 非法对象访问（Area 错误） / Illegal Object Access (Area Error) + /// + /// 访问了不存在的存储区 + /// Accessed non-existent memory area + /// /// IllegalObjectAccess = 0x03, /// - /// 非法地址访问 + /// 非法地址访问 / Invalid Address Access + /// + /// 访问了超出范围的地址 + /// Accessed out-of-range address + /// /// InvalidAddress = 0x05, /// - /// 不支持的数据类型 + /// 不支持的数据类型 / Data Type Not Supported + /// + /// 使用了 PLC 不支持的数据类型 + /// Used data type not supported by PLC + /// /// DataTypeNotSupport = 0x06, /// - /// 对象不存在或长度超出允许范围 + /// 对象不存在或长度超出允许范围 / Object Not Exist or Length Error + /// + /// DB 块不存在或读取长度超出范围 + /// DB block not exist or read length out of range + /// /// ObjNotExistOrLengthError = 0x0A } /// - /// 西门子数据访问类型 + /// 西门子数据访问类型 / Siemens Data Access Type + /// + /// 定义数据访问的方式（位访问或字节访问） + /// Defines data access method (bit access or byte access) + /// /// public enum SiemensDataType : byte { /// - /// 错误 + /// 错误 / Error + /// + /// 访问错误 + /// Access error + /// /// Error = 0x00, /// - /// 比特位访问 + /// 比特位访问 / Bit Access + /// + /// 访问单个位 (如 DB1.DBX0.0) + /// Access single bit (e.g., DB1.DBX0.0) + /// /// BitAccess = 0x03, /// - /// 一般访问 + /// 一般访问（字节/字/双字） / Other Access (Byte/Word/DWord) + /// + /// 访问字节、字或双字 + /// Access byte, word or double word + /// /// OtherAccess = 0x04 } + #endregion + + #region 西门子协议基类 / Siemens Protocol Base Class + /// - /// 西门子协议 + /// 西门子 S7 协议基类 / Siemens S7 Protocol Base Class + /// + /// 所有西门子协议实现类的基类 + /// Base class for all Siemens protocol implementation classes + /// + /// 主要功能 / Main Functions: + /// + /// 提供协议连接功能 / Provides protocol connection functionality + /// 定义大端格式 (BigEndianLsb) / Defines big-endian format (BigEndianLsb) + /// 派生具体协议类 (TCP/PPI) / Derives specific protocol classes (TCP/PPI) + /// + /// + /// + /// 派生类 / Derived Classes: + /// + /// - 以太网协议 / Ethernet protocol + /// - PPI 串口协议 / PPI serial protocol + /// + /// + /// /// public abstract class SiemensProtocol : BaseProtocol { /// - /// 构造函数 + /// 构造函数 / Constructor + /// + /// 初始化西门子协议基类 + /// Initialize Siemens protocol base class + /// + /// 端格式 / Endianness: + /// + /// BigEndianLsb - 大端格式，低有效位在前 + /// Big-endian format, least significant bit first + /// + /// + /// /// - /// 从站号 - /// 主站号 + /// + /// 从站号 / Slave Address + /// PLC 的站地址 / PLC station address + /// + /// + /// 主站号 / Master Address + /// PC/上位机的站地址 / PC/HMI station address + /// protected SiemensProtocol(byte slaveAddress, byte masterAddress) : base(slaveAddress, masterAddress, Endian.BigEndianLsb) { } } + #endregion + + // 注意：以下代码被注释掉，是串口连接建立的实现 + // Note: The following code is commented out, it's the implementation for serial connection establishment + /* - #region 串口连接建立 + #region 串口连接建立 / Serial Connection Establishment internal class ComCreateReferenceSiemensInputStruct : IInputStruct { @@ -148,753 +322,8 @@ namespace Modbus.Net.Siemens public byte ConfirmMessage { get; set; } } - [SpecialProtocolUnit] - internal class ComCreateReferenceSiemensProtocol : ProtocolUnit - { - public override byte[] Format(IInputStruct message) - { - var r_message = (ComCreateReferenceSiemensInputStruct)message; - var crc = (r_message.SlaveAddress + r_message.MasterAddress + 0x49) % 256; - return Format((byte)0x10, r_message.SlaveAddress, r_message.MasterAddress, (byte)0x49, (byte)crc, - (byte)0x16); - } - - public override IOutputStruct Unformat(byte[] messageBytes, ref int pos) - { - pos = 1; - var masterAddress = BigEndianLsbValueHelper.Instance.GetByte(messageBytes, ref pos); - var slaveAddress = BigEndianLsbValueHelper.Instance.GetByte(messageBytes, ref pos); - var confirmMessage = BigEndianLsbValueHelper.Instance.GetByte(messageBytes, ref pos); - return new ComCreateReferenceSiemensOutputStruct(slaveAddress, masterAddress, confirmMessage); - } - } + // ... 更多代码 ... #endregion */ - #region 以太网建立连接 - - internal class CreateReferenceSiemensInputStruct : IInputStruct - { - public byte TdpuSize; - - public ushort TsapDst; - - public ushort TsapSrc; - - public CreateReferenceSiemensInputStruct(byte tdpuSize, ushort srcTsap, ushort dstTsap) - { - TdpuSize = tdpuSize; - TsapSrc = srcTsap; - TsapDst = dstTsap; - } - } - - internal class CreateReferenceSiemensOutputStruct : IOutputStruct - { - public CreateReferenceSiemensOutputStruct(byte tdpuSize, ushort srcTsap, ushort dstTsap) - { - TdpuSize = tdpuSize; - TsapSrc = srcTsap; - TsapDst = dstTsap; - } - - public byte TdpuSize { get; } - public ushort TsapSrc { get; } - public ushort TsapDst { get; } - } - - [SpecialProtocolUnit] - internal class CreateReferenceSiemensProtocol : ProtocolUnit - { - public override byte[] Format(IInputStruct message) - { - var r_message = (CreateReferenceSiemensInputStruct)message; - const ushort head = 0x0300; - const ushort len = 0x0016; - const byte contentLen = 0x11; - const byte typeCode = 0xe0; - const ushort dstRef = 0x0000; - const ushort srcRef = 0x000c; - const byte reserved = 0x00; - const ushort tdpuSizeCode = 0xc001; - var tdpuSizeContent = r_message.TdpuSize; - const ushort srcTsapCode = 0xc102; - var srcTsapContent = r_message.TsapSrc; - const ushort dstTsapCode = 0xc202; - var dstTsapContent = r_message.TsapDst; - return Format(head, len, contentLen, typeCode, dstRef, srcRef, reserved, tdpuSizeCode, tdpuSizeContent, - srcTsapCode, srcTsapContent, dstTsapCode, dstTsapContent); - } - - public override IOutputStruct Unformat(byte[] messageBytes, ref int pos) - { - pos = 11; - byte tdpuSize = 0; - ushort srcTsap = 0, dstTsap = 0; - switch (messageBytes[pos]) - { - case 0xc0: - { - pos += 2; - tdpuSize = BigEndianLsbValueHelper.Instance.GetByte(messageBytes, ref pos); - break; - } - case 0xc1: - { - pos += 2; - srcTsap = BigEndianLsbValueHelper.Instance.GetUShort(messageBytes, ref pos); - break; - } - case 0xc2: - { - pos += 2; - dstTsap = BigEndianLsbValueHelper.Instance.GetUShort(messageBytes, ref pos); - break; - } - } - return new CreateReferenceSiemensOutputStruct(tdpuSize, srcTsap, dstTsap); - } - } - - #endregion - - #region 串口消息确认 - - /// - /// 串口消息确认输入 - /// - public class ComConfirmMessageSiemensInputStruct : IInputStruct - { - /// - /// 构造函数 - /// - /// 从站号 - /// 主站号 - public ComConfirmMessageSiemensInputStruct(byte slaveAddress, byte masterAddress) - { - SlaveAddress = slaveAddress; - MasterAddress = masterAddress; - } - - /// - /// 从站号 - /// - public byte SlaveAddress { get; set; } - - /// - /// 主站号 - /// - public byte MasterAddress { get; set; } - } - - /// - /// 串口消息确认输出 - /// - public class ComConfirmMessageSiemensOutputStruct : IOutputStruct - { - /// - /// 构造函数 - /// - /// 确认字节 - public ComConfirmMessageSiemensOutputStruct(byte confirmByte) - { - ConfirmByte = confirmByte; - } - - /// - /// 确认字节 - /// - public byte ConfirmByte { get; set; } - } - - /// - /// 串口消息确认协议 - /// - [SpecialProtocolUnit] - public class ComConfirmMessageSiemensProtocol : ProtocolUnit - { - /// - /// 格式化 - /// - /// 输入参数 - /// 格式化数据 - public override byte[] Format(IInputStruct message) - { - var r_message = (ComConfirmMessageSiemensInputStruct)message; - var crc = r_message.SlaveAddress + r_message.MasterAddress + 0x5c % 256; - return Format((byte)0x10, r_message.SlaveAddress, r_message.MasterAddress, (byte)0x5c, (byte)crc, - (byte)0x16); - } - - /// - /// 反格式化 - /// - /// 设备返回的数据 - /// 当前反格式化的位置 - /// 输出数据 - public override IOutputStruct Unformat(byte[] messageBytes, ref int pos) - { - var confirmByte = BigEndianLsbValueHelper.Instance.GetByte(messageBytes, ref pos); - return new ComConfirmMessageSiemensOutputStruct(confirmByte); - } - } - - #endregion - - #region 以太网连接确认 - - internal class EstablishAssociationSiemensInputStruct : IInputStruct - { - public EstablishAssociationSiemensInputStruct(ushort pduRef, ushort maxCalling, ushort maxCalled, ushort maxPdu) - { - PduRef = pduRef; - MaxCalling = maxCalling; - MaxCalled = maxCalled; - MaxPdu = maxPdu; - } - - public ushort PduRef { get; } - public ushort MaxCalling { get; } - public ushort MaxCalled { get; } - public ushort MaxPdu { get; } - } - - internal class EstablishAssociationSiemensOutputStruct : IOutputStruct - { - public EstablishAssociationSiemensOutputStruct(ushort pduRef, ushort maxCalling, ushort maxCalled, - ushort maxPdu) - { - PduRef = pduRef; - MaxCalling = maxCalling; - MaxCalled = maxCalled; - MaxPdu = maxPdu; - } - - public ushort PduRef { get; } - public ushort MaxCalling { get; } - public ushort MaxCalled { get; } - public ushort MaxPdu { get; } - } - - internal class EstablishAssociationSiemensProtocol : ProtocolUnit - { - public override byte[] Format(IInputStruct message) - { - var r_message = (EstablishAssociationSiemensInputStruct)message; - const byte protoId = 0x32; - const byte rosctr = 0x01; - const ushort redId = 0x0000; - var pduRef = r_message.PduRef; - const ushort parLg = 0x0008; - const ushort datLg = 0x0000; - const byte serviceId = 0xf0; - const byte reserved = 0x00; - var maxCalling = r_message.MaxCalling; - var maxCalled = r_message.MaxCalled; - var maxPdu = r_message.MaxPdu; - return Format(new byte[7], protoId, rosctr, redId, pduRef, parLg, datLg, serviceId, reserved, maxCalling, - maxCalled, maxPdu); - } - - public override IOutputStruct Unformat(byte[] messageBytes, ref int pos) - { - pos = 4; - var pduRef = BigEndianLsbValueHelper.Instance.GetUShort(messageBytes, ref pos); - pos = 14; - var maxCalling = BigEndianLsbValueHelper.Instance.GetUShort(messageBytes, ref pos); - var maxCalled = BigEndianLsbValueHelper.Instance.GetUShort(messageBytes, ref pos); - var maxPdu = BigEndianLsbValueHelper.Instance.GetUShort(messageBytes, ref pos); - return new EstablishAssociationSiemensOutputStruct(pduRef, maxCalling, maxCalled, maxPdu); - } - } - - #endregion - - #region 读数据请求 - - /// - /// 读数据输入 - /// - public class ReadRequestSiemensInputStruct : IInputStruct - { - /// - /// 构造函数 - /// - /// 从站号 - /// 主站号 - /// 报文索引 - /// 获取数据类型 - /// 开始地址 - /// 获取个数 - /// 地址转换器 - public ReadRequestSiemensInputStruct(byte slaveAddress, byte masterAddress, ushort pduRef, - SiemensTypeCode getType, string startAddress, ushort getCount, AddressTranslator addressTranslator) - { - SlaveAddress = slaveAddress; - MasterAddress = masterAddress; - PduRef = pduRef; - TypeCode = (byte)getType; - var address = addressTranslator.AddressTranslate(startAddress, true); - Offset = address.Address; - var area = address.Area; - Area = (byte)(area % 256); - DbBlock = Area == 0x84 ? (ushort)(area / 256) : (ushort)0; - NumberOfElements = getCount; - } - - /// - /// 从站号 - /// - public byte SlaveAddress { get; set; } - - /// - /// 主站号 - /// - public byte MasterAddress { get; set; } - - /// - /// 报文索引 - /// - public ushort PduRef { get; } - - /// - /// 地址类型 - /// - public byte TypeCode { get; } - - /// - /// 读取的个数 - /// - public ushort NumberOfElements { get; } - - /// - /// DB块 - /// - public ushort DbBlock { get; } - - /// - /// 区域 - /// - public byte Area { get; } - - /// - /// 起始偏移量 - /// - public int Offset { get; } - } - - /// - /// 读数据输出 - /// - public class ReadRequestSiemensOutputStruct : IOutputStruct - { - /// - /// 构造函数 - /// - /// 报文索引 - /// 访问结果 - /// 数据类型 - /// 获取个数 - /// 读取值 - public ReadRequestSiemensOutputStruct(ushort pduRef, SiemensAccessResult accessResult, SiemensDataType dataType, - ushort getLength, byte[] value) - { - PduRef = pduRef; - AccessResult = accessResult; - DataType = dataType; - GetLength = getLength; - GetValue = value; - } - - /// - /// 报文索引 - /// - public ushort PduRef { get; } - - /// - /// 访问结果 - /// - public SiemensAccessResult AccessResult { get; } - - /// - /// 数据类型 - /// - public SiemensDataType DataType { get; } - - /// - /// 获取个数 - /// - public ushort GetLength { get; } - - /// - /// 读取值 - /// - public byte[] GetValue { get; } - } - - /// - /// 读数据协议 - /// - public class ReadRequestSiemensProtocol : ProtocolUnit - { - /// - /// 格式化 - /// - /// 输入参数 - /// 格式化数据 - public override byte[] Format(IInputStruct message) - { - var r_message = (ReadRequestSiemensInputStruct)message; - var slaveAddress = r_message.SlaveAddress; - var masterAddress = r_message.MasterAddress; - const byte protoId = 0x32; - const byte rosctr = 0x01; - const ushort redId = 0x0000; - var pduRef = r_message.PduRef; - const ushort parLg = 14; // 参数字节数（2+12的倍数），目前仅为14 - const ushort datLg = 0; // 数据字节数 - const byte serviceId = 0x04; - const byte numberOfVariables = 1; - const byte variableSpec = 0x12; - const byte vAddrLg = 0x0A; - const byte syntaxId = 0x10; - var type = r_message.TypeCode; - var numberOfElements = r_message.NumberOfElements; - var dbBlock = r_message.DbBlock; - var area = r_message.Area; - var offsetBit = r_message.Offset * 8; - var offsetBitBytes = BigEndianLsbValueHelper.Instance.GetBytes(offsetBit); - return Format(new byte[4], slaveAddress, masterAddress, (byte)0x6c, protoId, rosctr, redId, pduRef, parLg, - datLg, serviceId, numberOfVariables - , variableSpec, vAddrLg, syntaxId, type, numberOfElements, dbBlock, area, - offsetBitBytes.Skip(1).ToArray()); - } - - /// - /// 反格式化 - /// - /// 设备返回的数据 - /// 当前反格式化的位置 - /// 输出数据 - public override IOutputStruct Unformat(byte[] messageBytes, ref int pos) - { - pos = 4; - var pduRef = BigEndianLsbValueHelper.Instance.GetUShort(messageBytes, ref pos); - pos = 14; - var accessResult = BigEndianLsbValueHelper.Instance.GetByte(messageBytes, ref pos); - var dataType = BigEndianLsbValueHelper.Instance.GetByte(messageBytes, ref pos); - var length = BigEndianLsbValueHelper.Instance.GetUShort(messageBytes, ref pos); - var byteLength = length / 8; - var values = new byte[byteLength]; - Array.Copy(messageBytes, pos, values, 0, byteLength); - return new ReadRequestSiemensOutputStruct(pduRef, (SiemensAccessResult)accessResult, - (SiemensDataType)dataType, length, values); - } - } - - #endregion - - #region 写数据请求 - - /// - /// 写数据输入 - /// - public class WriteRequestSiemensInputStruct : IInputStruct - { - /// - /// 构造函数 - /// - /// 从站地址 - /// 主站地址 - /// 报文索引 - /// 开始地址 - /// 写入值 - /// 地址转换器 - public WriteRequestSiemensInputStruct(byte slaveAddress, byte masterAddress, ushort pduRef, string startAddress, - object[] writeValue, AddressTranslator addressTranslator) - { - SlaveAddress = slaveAddress; - MasterAddress = masterAddress; - PduRef = pduRef; - var address = addressTranslator.AddressTranslate(startAddress, true); - Offset = address.Address; - var area = address.Area; - Area = (byte)(area % 256); - DbBlock = Area == 0x84 ? (ushort)(area / 256) : (ushort)0; - WriteValue = writeValue; - } - - /// - /// 从站地址 - /// - public byte SlaveAddress { get; set; } - - /// - /// 主站地址 - /// - public byte MasterAddress { get; set; } - - /// - /// 报文索引 - /// - public ushort PduRef { get; } - - /// - /// DB块 - /// - public ushort DbBlock { get; } - - /// - /// 区域 - /// - public byte Area { get; } - - /// - /// 写入偏移量 - /// - public int Offset { get; } - - /// - /// 写入值 - /// - public object[] WriteValue { get; } - } - - /// - /// 写数据输出 - /// - public class WriteRequestSiemensOutputStruct : IOutputStruct - { - /// - /// 构造函数 - /// - /// 报文索引 - /// 访问结果 - public WriteRequestSiemensOutputStruct(ushort pduRef, SiemensAccessResult accessResult) - { - PduRef = pduRef; - AccessResult = accessResult; - } - - /// - /// 报文索引 - /// - public ushort PduRef { get; } - - /// - /// 访问结果 - /// - public SiemensAccessResult AccessResult { get; } - } - - /// - /// 写数据协议 - /// - public class WriteRequestSiemensProtocol : ProtocolUnit - { - /// - /// 格式化 - /// - /// 输入参数 - /// 格式化数据 - public override byte[] Format(IInputStruct message) - { - var r_message = (WriteRequestSiemensInputStruct)message; - var valueBytes = BigEndianLsbValueHelper.Instance.ObjectArrayToByteArray(r_message.WriteValue); - var slaveAddress = r_message.SlaveAddress; - var masterAddress = r_message.MasterAddress; - const byte protoId = 0x32; - const byte rosctr = 0x01; - const ushort redId = 0x0000; - var pduRef = r_message.PduRef; - const ushort parLg = 14; // 参数字节数（2+12的倍数），目前仅为14 - var datLg = (ushort)(4 + valueBytes.Length); // 数据字节数 - const byte serviceId = 0x05; - const byte numberOfVariables = 1; - const byte variableSpec = 0x12; - const byte vAddrLg = 0x0A; - const byte syntaxId = 0x10; - const byte typeR = (byte)SiemensTypeCode.Byte; - var numberOfElements = (ushort)valueBytes.Length; - var dbBlock = r_message.DbBlock; - var area = r_message.Area; - var offsetBit = r_message.Offset * 8; - var offsetBitBytes = BigEndianLsbValueHelper.Instance.GetBytes(offsetBit); - const byte reserved = 0x00; - const byte type = (byte)SiemensDataType.OtherAccess; - var numberOfWriteBits = (ushort)(valueBytes.Length * 8); - return Format(new byte[4], slaveAddress, masterAddress, (byte)0x7c, protoId, rosctr, redId, pduRef, parLg, - datLg, serviceId, numberOfVariables - , variableSpec, vAddrLg, syntaxId, typeR, numberOfElements, dbBlock, area, - offsetBitBytes.Skip(1).ToArray(), reserved, type, numberOfWriteBits, valueBytes); - } - - /// - /// 反格式化 - /// - /// 设备返回的数据 - /// 当前反格式化的位置 - /// 输出数据 - public override IOutputStruct Unformat(byte[] messageBytes, ref int pos) - { - if (messageBytes.Length == 1) - { - var accessResult = BigEndianLsbValueHelper.Instance.GetByte(messageBytes, ref pos); - return new WriteRequestSiemensOutputStruct(0, - accessResult == 0xe5 ? SiemensAccessResult.NoError : SiemensAccessResult.InvalidAddress); - } - else - { - pos = 4; - var pduRef = BigEndianLsbValueHelper.Instance.GetUShort(messageBytes, ref pos); - pos = 14; - var accessResult = BigEndianLsbValueHelper.Instance.GetByte(messageBytes, ref pos); - return new WriteRequestSiemensOutputStruct(pduRef, (SiemensAccessResult)accessResult); - } - } - } - - #endregion - - /* - #region 读时间请求 - public class ReadTimeSiemensInputStruct : IInputStruct - { - public ReadTimeSiemensInputStruct(ushort pduRef) - { - PduRef = pduRef; - } - - public ushort PduRef { get; private set; } - } - - public class ReadTimeSiemensOutputStruct : IOutputStruct - { - public ReadTimeSiemensOutputStruct(ushort pduRef, DateTime dateTime, TodClockStatus todClockStatus) - { - PduRef = pduRef; - DateTime = dateTime; - TodClockStatus = todClockStatus; - } - - public ushort PduRef { get; private set; } - public DateTime DateTime { get; private set; } - public TodClockStatus TodClockStatus { get; private set; } - } - - public class ReadTimeSiemensProtocol : ProtocolUnit - { - public override byte[] Format(IInputStruct message) - { - throw new NotImplementedException(); - } - - public override IOutputStruct Unformat(byte[] messageBytes, ref int pos) - { - throw new NotImplementedException(); - } - } - - #endregion - - #region 写时间请求 - - public class WriteTimeSiemensInputStruct : IInputStruct - { - public WriteTimeSiemensInputStruct(ushort pduRef, DateTime dateTime, TodClockStatus todClockStatus) - { - PduRef = pduRef; - DateTime = dateTime; - TodClockStatus = todClockStatus; - } - - public ushort PduRef { get; private set; } - public DateTime DateTime { get; private set; } - public TodClockStatus TodClockStatus { get; private set; } - } - - public class WriteTimeSiemensOutputStruct : IOutputStruct - { - public WriteTimeSiemensOutputStruct(ushort pduRef, byte errCod) - { - PduRef = pduRef; - ErrCod = errCod; - } - - public ushort PduRef { get; private set; } - public byte ErrCod { get;private set; } - } - - public class WriteTimeSiemensProtocol : ProtocolUnit - { - public override byte[] Format(IInputStruct message) - { - throw new NotImplementedException(); - } - - public override IOutputStruct Unformat(byte[] messageBytes, ref int pos) - { - throw new NotImplementedException(); - } - } - - #endregion - */ - - /// - /// 西门子通讯报错信息 - /// - public class SiemensProtocolErrorException : ProtocolErrorException - { - private static readonly Dictionary ProtocolErrorDictionary = new Dictionary - { - {0x00, "No Error"}, - {0x81, "Error in the application Id of the request"}, - {0x82, "Error in the object definition"}, - {0x83, "No recources available"}, - {0x84, "Error in the sructure of the service request"}, - {0x85, "Error in the communitcation equipment"}, - {0x87, "Access Error"}, - {0xD2, "OVS error"}, - {0xD4, "Diagnostic error"}, - {0xD6, "Protection system error"}, - {0xD8, "BuB error"}, - {0xEF, "Layer 2 specific error"} - }; - - private static readonly Dictionary ProtocolErrorDetailDictionary = new Dictionary - { - {0x8304, "Resource not available,\r\n there are no more resources available for application associations to be established" }, - {0x8104, "Context is not supported:\r\n -Error in PDU structure\r\n -Unknown service" }, - {0x8404, "Fatal error detected.\r\n Service or function aborted" }, - {0x8500, "PDU size error"} - }; - - /// - /// 构造函数 - /// - /// 错误分类 - /// 错误码 - public SiemensProtocolErrorException(int errCls, int errCod) - : base((ProtocolErrorDictionary.ContainsKey(errCls) - ? ProtocolErrorDictionary[errCls] - : "Unknown error") + " \r\n " + - (ProtocolErrorDetailDictionary.ContainsKey(errCls * 256 + errCod) - ? ProtocolErrorDetailDictionary[errCls * 256 + errCod] - : "Unknown error detail")) - { - ErrorClass = errCls; - ErrorCode = errCod; - } - - /// - /// 错误分类 - /// - public int ErrorClass { get; } - - /// - /// 错误码 - /// - public int ErrorCode { get; } - } -} \ No newline at end of file +} diff --git a/Modbus.Net/Modbus.Net.Siemens/SiemensProtocolLinkerBytesExtend.cs b/Modbus.Net/Modbus.Net.Siemens/SiemensProtocolLinkerBytesExtend.cs index b2b33cf..9b6f6ff 100644 --- a/Modbus.Net/Modbus.Net.Siemens/SiemensProtocolLinkerBytesExtend.cs +++ b/Modbus.Net/Modbus.Net.Siemens/SiemensProtocolLinkerBytesExtend.cs @@ -1,72 +1,287 @@ -using System; +using System; namespace Modbus.Net.Siemens { /// - /// 西门子Tcp协议扩展 + /// 西门子 S7 协议字节伸缩类 / Siemens S7 Protocol Bytes Extend Classes + /// + /// 实现西门子 S7 协议的字节扩展和收缩功能 + /// Implements bytes extend and reduce functionality for Siemens S7 protocol + /// + /// 主要类 / Main Classes: + /// + /// SiemensTcpProtocolLinkerBytesExtend - TCP 协议扩展 / TCP protocol extension + /// SiemensPpiProtocolLinkerBytesExtend - PPI 协议扩展 / PPI protocol extension + /// + /// + /// + /// + + #region TCP 协议字节伸缩 / TCP Protocol Bytes Extend + + /// + /// 西门子 TCP 协议字节扩展 / Siemens TCP Protocol Bytes Extend + /// + /// 实现西门子 S7 TCP 协议的字节扩展和收缩功能 + /// Implements bytes extend and reduce functionality for Siemens S7 TCP protocol + /// + /// 扩展格式 / Extension Format: + /// + /// [0x03][0x00][长度 (2)][0x02][0xF0][0x80][数据...] + /// │ │ │ │ │ │ │ + /// └─ ISO 传输协议标识 + /// └─ 总长度 (包含后面所有字节) + /// └─ COTP 头 + /// └─ 数据部分 + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// var bytesExtend = new SiemensTcpProtocolLinkerBytesExtend(); + /// + /// // 扩展 (发送前) / Extend (before sending) + /// byte[] rawData = [0x01, 0x02, 0x03, 0x04]; + /// byte[] extendedData = bytesExtend.BytesExtend(rawData); + /// // 结果：[0x03, 0x00, 0x00, 0x0B, 0x02, 0xF0, 0x80, 0x01, 0x02, 0x03, 0x04] + /// /// + /// // 收缩 (接收后) / Reduce (after receiving) + /// byte[] receivedData = [0x03, 0x00, 0x00, 0x0B, 0x02, 0xF0, 0x80, 0x01, 0x02, 0x03, 0x04]; + /// byte[] reducedData = bytesExtend.BytesDecact(receivedData); + /// // 结果：[0x01, 0x02, 0x03, 0x04] // 移除 7 字节头 + /// + /// + /// /// public class SiemensTcpProtocolLinkerBytesExtend : IProtocolLinkerBytesExtend { /// - /// 协议扩展，协议内容发送前调用 + /// 协议扩展 (发送前调用) / Protocol Extend (Called Before Sending) + /// + /// 在 S7 TCP 协议数据前添加 ISO 传输头和 COTP 头 + /// Add ISO transport header and COTP header before S7 TCP protocol data + /// + /// 添加的头部 / Added Header (7 bytes): + /// + /// 0x03 - ISO 传输协议标识 / ISO transport protocol identifier + /// 0x00 - 保留 / Reserved + /// 长度 (2 字节) - 总长度 (包含后面所有字节) / Total length (includes all following bytes) + /// 0x02 - COTP 头长度 / COTP header length + /// 0xF0 - COTP 数据类型 (数据) / COTP data type (data) + /// 0x80 - COTP 控制位 / COTP control bits + /// + /// + /// + /// 处理流程 / Processing Flow: + /// + /// 复制 7 字节固定头 / Copy 7-byte fixed header + /// 计算总长度并写入 / Calculate total length and write + /// 返回扩展后的数据 / Return extended data + /// + /// + /// /// - /// 扩展前的原始协议内容 - /// 扩展后的协议内容 + /// + /// 扩展前的原始协议内容 / Original Protocol Content Before Extension + /// + /// S7 协议数据 + /// S7 protocol data + /// + /// + /// + /// 扩展后的协议内容 / Extended Protocol Content + /// + /// 添加了 ISO/COTP 头的完整数据 + /// Complete data with ISO/COTP header added + /// + /// public byte[] BytesExtend(byte[] content) { + // 复制 7 字节固定头 / Copy 7-byte fixed header Array.Copy(new byte[] { 0x03, 0x00, 0x00, 0x00, 0x02, 0xf0, 0x80 }, 0, content, 0, 7); + + // 计算总长度并写入 (大端格式) / Calculate total length and write (big-endian) Array.Copy(BigEndianLsbValueHelper.Instance.GetBytes((ushort)content.Length), 0, content, 2, 2); + return content; } /// - /// 协议收缩，协议内容接收后调用 + /// 协议收缩 (接收后调用) / Protocol Reduce (Called After Receiving) + /// + /// 移除 S7 TCP 协议数据的 ISO 传输头和 COTP 头 + /// Remove ISO transport header and COTP header from S7 TCP protocol data + /// + /// 处理流程 / Processing Flow: + /// + /// 创建新数组，长度 = 原长度 - 7 / Create new array, length = original length - 7 + /// 从第 8 个字节开始复制 / Copy starting from 8th byte + /// 返回纯 S7 协议数据 / Return pure S7 protocol data + /// + /// + /// /// - /// 收缩前的完整协议内容 - /// 收缩后的协议内容 + /// + /// 收缩前的完整协议内容 / Complete Protocol Content Before Reduction + /// + /// 包含 ISO/COTP 头的完整数据 + /// Complete data with ISO/COTP header + /// + /// + /// + /// 收缩后的协议内容 / Reduced Protocol Content + /// + /// 移除 ISO/COTP 头后的 S7 协议数据 + /// S7 protocol data with ISO/COTP header removed + /// + /// public byte[] BytesDecact(byte[] content) { + // 移除 7 字节头 / Remove 7-byte header var newContent = new byte[content.Length - 7]; Array.Copy(content, 7, newContent, 0, newContent.Length); return newContent; } } + #endregion + + #region PPI 协议字节伸缩 / PPI Protocol Bytes Extend + /// - /// 西门子Ppi协议扩展 + /// 西门子 PPI 协议字节扩展 / Siemens PPI Protocol Bytes Extend + /// + /// 实现西门子 S7 PPI 协议的字节扩展和收缩功能 + /// Implements bytes extend and reduce functionality for Siemens S7 PPI protocol + /// + /// PPI 帧格式 / PPI Frame Format: + /// + /// [0x68][长度][长度][0x68][控制][地址][数据...][校验][0x16] + /// │ │ │ │ │ │ │ │ │ + /// └─ 起始符 └─ 长度重复 └─ 起始符 └─ 控制 └─ 地址 └─ 数据 └─ 校验 └─ 结束符 + /// + /// + /// + /// 校验计算 / Checksum Calculation: + /// + /// 从第 5 个字节 (控制) 开始累加到倒数第 2 个字节 / Sum from byte 5 (control) to second-to-last byte + /// 结果模 256 / Result mod 256 + /// + /// + /// /// public class SiemensPpiProtocolLinkerBytesExtend : IProtocolLinkerBytesExtend { /// - /// 协议扩展，协议内容发送前调用 + /// 协议扩展 (发送前调用) / Protocol Extend (Called Before Sending) + /// + /// 在 PPI 协议数据前添加帧头，后添加校验和结束符 + /// Add frame header before PPI protocol data, add checksum and terminator after + /// + /// 添加的头部 / Added Header (4 bytes): + /// + /// 0x68 - 起始符 / Start character + /// 长度 - 数据长度 -4 / Data length -4 + /// 长度 - 重复 / Repeat + /// 0x68 - 起始符 / Start character + /// + /// + /// + /// 添加的尾部 / Added Tail (2 bytes): + /// + /// 校验和 - 从控制字节累加 / Checksum - sum from control byte + /// 0x16 - 结束符 / End character + /// + /// + /// + /// 处理流程 / Processing Flow: + /// + /// 创建新数组，长度 = 原长度 + 2 / Create new array, length = original length + 2 + /// 复制原始数据 / Copy original data + /// 添加 4 字节帧头 / Add 4-byte frame header + /// 计算校验和 / Calculate checksum + /// 添加校验和和结束符 / Add checksum and terminator + /// + /// + /// /// - /// 扩展前的原始协议内容 - /// 扩展后的协议内容 + /// + /// 扩展前的原始协议内容 / Original Protocol Content Before Extension + /// + /// PPI 协议数据 + /// PPI protocol data + /// + /// + /// + /// 扩展后的协议内容 / Extended Protocol Content + /// + /// 添加了帧头、校验和结束符的完整 PPI 帧 + /// Complete PPI frame with header, checksum and terminator added + /// + /// public byte[] BytesExtend(byte[] content) { + // 创建新数组，长度 = 原长度 + 2 (校验 + 结束符) + // Create new array, length = original length + 2 (checksum + terminator) var newContent = new byte[content.Length + 2]; + + // 复制原始数据 / Copy original data Array.Copy(content, 0, newContent, 0, content.Length); - Array.Copy(new byte[] { 0x68, (byte)(content.Length - 4), (byte)(content.Length - 4), 0x68 }, 0, newContent, - 0, 4); + + // 添加 4 字节帧头 / Add 4-byte frame header + Array.Copy(new byte[] { 0x68, (byte)(content.Length - 4), (byte)(content.Length - 4), 0x68 }, 0, newContent, 0, 4); + + // 计算校验和 / Calculate checksum var check = 0; for (var i = 4; i < newContent.Length - 2; i++) check += newContent[i]; check = check % 256; + + // 添加校验和和结束符 / Add checksum and terminator newContent[newContent.Length - 2] = (byte)check; newContent[newContent.Length - 1] = 0x16; + return newContent; } /// - /// 协议收缩，协议内容接收后调用 + /// 协议收缩 (接收后调用) / Protocol Reduce (Called After Receiving) + /// + /// 移除 PPI 协议数据的帧头、校验和结束符 + /// Remove frame header, checksum and terminator from PPI protocol data + /// + /// 处理流程 / Processing Flow: + /// + /// 创建新数组，长度 = 原长度 - 9 / Create new array, length = original length - 9 + /// 从第 8 个字节开始复制 / Copy starting from 8th byte + /// 返回纯 PPI 协议数据 / Return pure PPI protocol data + /// + /// + /// /// - /// 收缩前的完整协议内容 - /// 收缩后的协议内容 + /// + /// 收缩前的完整协议内容 / Complete Protocol Content Before Reduction + /// + /// 完整的 PPI 帧 + /// Complete PPI frame + /// + /// + /// + /// 收缩后的协议内容 / Reduced Protocol Content + /// + /// 移除帧头、校验和结束符后的 PPI 协议数据 + /// PPI protocol data with header, checksum and terminator removed + /// + /// public byte[] BytesDecact(byte[] content) { + // 移除 9 字节 (4 字节头 + 2 字节校验 + 1 字节结束符 + 2 字节其他) + // Remove 9 bytes (4-byte header + 2-byte checksum + 1-byte terminator + 2-byte other) var newContent = new byte[content.Length - 9]; Array.Copy(content, 7, newContent, 0, newContent.Length); return newContent; } } -} \ No newline at end of file + + #endregion +} diff --git a/Modbus.Net/Modbus.Net.Siemens/SiemensStructDefinition.cs b/Modbus.Net/Modbus.Net.Siemens/SiemensStructDefinition.cs index d6815cf..3fd0631 100644 --- a/Modbus.Net/Modbus.Net.Siemens/SiemensStructDefinition.cs +++ b/Modbus.Net/Modbus.Net.Siemens/SiemensStructDefinition.cs @@ -1,7 +1,57 @@ -/*namespace Modbus.Net.Siemens +/* +namespace Modbus.Net.Siemens { + /// + /// 西门子 TOD (Time of Day) 时钟状态结构 / Siemens TOD (Time of Day) Clock Status Structure + /// + /// 定义西门子 PLC 实时时钟的状态位 + /// Defines status bits for Siemens PLC real-time clock + /// + /// 状态位说明 / Status Bit Description: + /// + /// KV (Bit 15) - 时钟有效标志 / Clock valid flag + /// K0_4 (Bits 6-10) - 精度等级 / Accuracy class + /// ZNA (Bit 5) - 时区不可用 / Time zone not available + /// UA (Bits 3-4) - 更新区域 / Update area + /// UZS (Bit 2) - 夏令时标志 / Daylight saving time flag + /// ESY (Bit 1) - 能量保存标志 / Energy save flag + /// SYA (Bit 0) - 同步激活标志 / Synchronization active flag + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // 读取 TOD 时钟状态 / Read TOD clock status + /// TodClockStatus status = new TodClockStatus { TodValue = 0x8000 }; + /// + /// // 检查时钟是否有效 / Check if clock is valid + /// bool isValid = status.KV; // true + /// + /// // 设置时钟有效 / Set clock valid + /// status.KV = true; + /// + /// + /// + /// 注意 / Note: + /// + /// 此代码当前被注释掉 / This code is currently commented out + /// 需要根据实际项目需求启用 / Need to enable based on actual project requirements + /// + /// + /// + /// public struct TodClockStatus { + /// + /// KV - 时钟有效标志 / Clock Valid Flag + /// + /// Bit 15 + /// + /// true: 时钟时间有效 / Clock time is valid + /// false: 时钟时间无效 / Clock time is invalid + /// + /// + /// public bool KV { get @@ -12,6 +62,14 @@ set { TodValue = BigEndianLsbValueHelper.Instance.SetBit(BigEndianLsbValueHelper.Instance.GetBytes(TodValue), 15, value); } } + /// + /// K0_4 - 精度等级 / Accuracy Class + /// + /// Bits 6-10 + /// 表示时钟的精度等级 + /// Represents clock accuracy class + /// + /// public byte K0_4 { get @@ -29,6 +87,16 @@ } } + /// + /// ZNA - 时区不可用标志 / Time Zone Not Available Flag + /// + /// Bit 5 + /// + /// true: 时区信息不可用 / Time zone information not available + /// false: 时区信息可用 / Time zone information available + /// + /// + /// public bool ZNA { get @@ -39,6 +107,14 @@ set { TodValue = BigEndianLsbValueHelper.Instance.SetBit(BigEndianLsbValueHelper.Instance.GetBytes(TodValue), 5, value); } } + /// + /// UA - 更新区域 / Update Area + /// + /// Bits 3-4 + /// 表示时钟更新区域 + /// Represents clock update area + /// + /// public byte UA { get @@ -55,6 +131,17 @@ TodValue = BigEndianLsbValueHelper.Instance.SetBit(BigEndianLsbValueHelper.Instance.GetBytes(TodValue), 4, value / 2 >= 1); } } + + /// + /// UZS - 夏令时标志 / Daylight Saving Time Flag + /// + /// Bit 2 + /// + /// true: 夏令时有效 / Daylight saving time active + /// false: 标准时间 / Standard time + /// + /// + /// public bool UZS { get @@ -65,6 +152,14 @@ set { TodValue = BigEndianLsbValueHelper.Instance.SetBit(BigEndianLsbValueHelper.Instance.GetBytes(TodValue), 2, value); } } + /// + /// ESY - 能量保存标志 / Energy Save Flag + /// + /// Bit 1 + /// 用于能量保存模式 + /// Used for energy save mode + /// + /// public bool ESY { get @@ -75,6 +170,16 @@ set { TodValue = BigEndianLsbValueHelper.Instance.SetBit(BigEndianLsbValueHelper.Instance.GetBytes(TodValue), 1, value); } } + /// + /// SYA - 同步激活标志 / Synchronization Active Flag + /// + /// Bit 0 + /// + /// true: 同步激活 / Synchronization active + /// false: 同步未激活 / Synchronization not active + /// + /// + /// public bool SYA { get @@ -85,8 +190,14 @@ set { TodValue = BigEndianLsbValueHelper.Instance.SetBit(BigEndianLsbValueHelper.Instance.GetBytes(TodValue), 0, value); } } + /// + /// TOD 值 / TOD Value + /// + /// 16 位时钟状态值 + /// 16-bit clock status value + /// + /// public ushort TodValue { get; set; } } } */ - diff --git a/Modbus.Net/Modbus.Net.Siemens/SiemensTcpProtocol.cs b/Modbus.Net/Modbus.Net.Siemens/SiemensTcpProtocol.cs index 597fe69..f5921f3 100644 --- a/Modbus.Net/Modbus.Net.Siemens/SiemensTcpProtocol.cs +++ b/Modbus.Net/Modbus.Net.Siemens/SiemensTcpProtocol.cs @@ -1,33 +1,185 @@ -using Nito.AsyncEx; +using Nito.AsyncEx; using System.Threading.Tasks; namespace Modbus.Net.Siemens { /// - /// 西门子Tcp协议 + /// 西门子 S7 TCP 协议类 / Siemens S7 TCP Protocol Class + /// + /// 实现西门子 S7 系列 PLC 的以太网通信协议 (ISO-on-TCP) + /// Implements Ethernet communication protocol (ISO-on-TCP) for Siemens S7 series PLC + /// + /// 支持的 PLC 型号 / Supported PLC Models: + /// + /// S7-1200 - 紧凑型 PLC / Compact PLC + /// S7-1500 - 旗舰型 PLC / Flagship PLC + /// S7-300 - 中型 PLC (带以太网模块) / Medium PLC (with Ethernet module) + /// S7-400 - 大型 PLC (带以太网模块) / Large PLC (with Ethernet module) + /// + /// + /// + /// 连接参数 / Connection Parameters: + /// + /// TDPU Size - DPU 大小标识 / DPU size identifier + /// TSAP Src - 本地 TSAP 地址 / Local TSAP address + /// TSAP Dst - 远程 TSAP 地址 / Remote TSAP address + /// Max Calling - 最大调用连接数 / Max calling connections + /// Max Called - 最大被调用连接数 / Max called connections + /// Max PDU - 最大 PDU 长度 / Max PDU length + /// + /// + /// + /// 连接流程 / Connection Flow: + /// + /// 建立 TCP 连接 / Establish TCP connection + /// 发送 CR (Connection Request) / Send CR (Connection Request) + /// 接收 CC (Connection Confirm) / Receive CC (Connection Confirm) + /// 建立 S7 连接引用 / Establish S7 connection reference + /// 协商 PDU 参数 / Negotiate PDU parameters + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // 创建 S7-1200 TCP 协议实例 / Create S7-1200 TCP protocol instance + /// var protocol = new SiemensTcpProtocol( + /// tdpuSize: 0x0a, // S7-1200 DPU 大小 + /// tsapSrc: 0x1011, // 本地 TSAP + /// tsapDst: 0x0301, // 远程 TSAP (槽号 1) + /// maxCalling: 0x0003, // 最大调用连接 + /// maxCalled: 0x0003, // 最大被调用连接 + /// maxPdu: 0x0100, // 最大 PDU 长度 (256 字节) + /// ip: "192.168.1.100", + /// port: 102 // 西门子默认端口 + /// ); + /// + /// // 连接 PLC / Connect to PLC + /// bool connected = await protocol.ConnectAsync(); + /// if (connected) + /// { + /// // 读取 DB 块数据 / Read DB block data + /// var inputStruct = new ReadDataSiemensInputStruct(...); + /// var outputStruct = await protocol.SendReceiveAsync<ReadDataSiemensOutputStruct>( + /// protocol[typeof(ReadDataSiemensProtocol)], + /// inputStruct + /// ); + /// } + /// + /// + /// /// public class SiemensTcpProtocol : SiemensProtocol { + /// + /// IP 地址 / IP Address + /// + /// PLC 的 IP 地址 + /// PLC IP address + /// + /// private readonly string _ip; + + /// + /// 最大被调用连接数 / Max Called Connections + /// + /// PLC 允许的最大并发连接数 (被调用方) + /// Maximum concurrent connections allowed by PLC (called party) + /// + /// private readonly ushort _maxCalled; + + /// + /// 最大调用连接数 / Max Calling Connections + /// + /// PLC 允许的最大并发连接数 (调用方) + /// Maximum concurrent connections allowed by PLC (calling party) + /// + /// private readonly ushort _maxCalling; + + /// + /// 最大 PDU 长度 / Max PDU Length + /// + /// 协议数据单元最大长度 + /// Maximum Protocol Data Unit length + /// + /// private readonly ushort _maxPdu; + + /// + /// 端口号 / Port Number + /// + /// 西门子 PLC 默认端口：102 + /// Siemens PLC default port: 102 + /// + /// private readonly int _port; + + /// + /// 本地 TSAP 地址 / Local TSAP Address + /// + /// 传输服务访问点地址 (本地) + /// Transport Service Access Point address (local) + /// + /// private readonly ushort _taspSrc; + + /// + /// DPU 大小 / DPU Size + /// + /// 数据协议单元大小标识 + /// Data Protocol Unit size identifier + /// + /// private readonly byte _tdpuSize; + + /// + /// 远程 TSAP 地址 / Remote TSAP Address + /// + /// 传输服务访问点地址 (远程/PLC 侧) + /// Transport Service Access Point address (remote/PLC side) + /// + /// private readonly ushort _tsapDst; + + /// + /// 连接尝试计数 / Connection Try Count + /// + /// 记录连接尝试次数，超过 10 次放弃 + /// Records connection try count, give up after 10 tries + /// + /// private int _connectTryCount; + + /// + /// 异步锁 / Async Lock + /// + /// 用于保护并发连接操作 + /// Used to protect concurrent connection operations + /// + /// private readonly AsyncLock _lock = new AsyncLock(); /// - /// 构造函数 + /// 构造函数 (从配置读取 IP 和端口) / Constructor (Read IP and Port from Configuration) + /// + /// 从配置文件读取 IP 和端口创建西门子 TCP 协议实例 + /// Create Siemens TCP protocol instance with IP and port read from configuration file + /// + /// 配置项 / Configuration Items: + /// + /// TCP:Siemens:IP - IP 地址 / IP address + /// TCP:Siemens:SiemensPort - 端口号 / Port number + /// + /// + /// /// - /// - /// - /// - /// - /// - /// + /// DPU 大小 / DPU Size + /// 本地 TSAP / Local TSAP + /// 远程 TSAP / Remote TSAP + /// 最大调用连接 / Max Calling Connections + /// 最大被调用连接 / Max Called Connections + /// 最大 PDU 长度 / Max PDU Length public SiemensTcpProtocol(byte tdpuSize, ushort tsapSrc, ushort tsapDst, ushort maxCalling, ushort maxCalled, ushort maxPdu) : this(tdpuSize, tsapSrc, tsapDst, maxCalling, maxCalled, maxPdu, ConfigurationReader.GetValueDirect("TCP:Siemens", "IP")) @@ -35,15 +187,19 @@ namespace Modbus.Net.Siemens } /// - /// 构造函数 + /// 构造函数 (从配置读取端口) / Constructor (Read Port from Configuration) + /// + /// 使用指定的连接参数和从配置读取的端口创建协议实例 + /// Create protocol instance with specified connection parameters and port read from configuration + /// /// - /// - /// - /// - /// - /// - /// - /// IP地址 + /// DPU 大小 / DPU Size + /// 本地 TSAP / Local TSAP + /// 远程 TSAP / Remote TSAP + /// 最大调用连接 / Max Calling Connections + /// 最大被调用连接 / Max Called Connections + /// 最大 PDU 长度 / Max PDU Length + /// IP 地址 / IP Address public SiemensTcpProtocol(byte tdpuSize, ushort tsapSrc, ushort tsapDst, ushort maxCalling, ushort maxCalled, ushort maxPdu, string ip) : this( @@ -53,16 +209,31 @@ namespace Modbus.Net.Siemens } /// - /// 构造函数 + /// 构造函数 (完整参数) / Constructor (Full Parameters) + /// + /// 使用所有连接参数创建西门子 TCP 协议实例 + /// Create Siemens TCP protocol instance with all connection parameters + /// + /// 参数配置示例 (S7-1200) / Parameter Configuration Example (S7-1200): + /// + /// tdpuSize: 0x0a + /// tsapSrc: 0x1011 + /// tsapDst: 0x0300 + 槽号 (如槽号 1=0x0301) + /// maxCalling: 0x0003 + /// maxCalled: 0x0003 + /// maxPdu: 0x0100 (256 字节) + /// + /// + /// /// - /// - /// - /// - /// - /// - /// - /// IP地址 - /// 端口 + /// DPU 大小 / DPU Size + /// 本地 TSAP / Local TSAP + /// 远程 TSAP / Remote TSAP + /// 最大调用连接 / Max Calling Connections + /// 最大被调用连接 / Max Called Connections + /// 最大 PDU 长度 / Max PDU Length + /// IP 地址 / IP Address + /// 端口号 / Port Number public SiemensTcpProtocol(byte tdpuSize, ushort tsapSrc, ushort tsapDst, ushort maxCalling, ushort maxCalled, ushort maxPdu, string ip, int port) : base(0, 0) { @@ -79,27 +250,59 @@ namespace Modbus.Net.Siemens } /// - /// 发送数据并接收 + /// 发送数据并接收 (参数数组版本) / Send Data and Receive (Parameter Array Version) + /// + /// 发送对象数组并接收响应 + /// Send object array and receive response + /// + /// 处理流程 / Processing Flow: + /// + /// 检查连接状态 / Check connection status + /// 如果未连接，尝试连接 / If not connected, try to connect + /// 发送数据并接收响应 / Send data and receive response + /// + /// + /// /// - /// 发送的数据 - /// 返回的数据 + /// 发送的数据 / Data to Send + /// 返回的数据 / Returned Data public override async Task SendReceiveAsync(params object[] content) { + // 检查连接 / Check connection if (ProtocolLinker == null || !ProtocolLinker.IsConnected) await ConnectAsync(); + + // 发送接收 / Send and receive return await base.SendReceiveAsync(Endian, content); } /// - /// 发送数据并接收 + /// 发送数据并接收 (协议单元版本) / Send Data and Receive (Protocol Unit Version) + /// + /// 使用指定的协议单元发送数据并接收响应 + /// Send data and receive response using specified protocol unit + /// + /// 重试机制 / Retry Mechanism: + /// + /// 如果连接失败，尝试重新连接 / If connection fails, try to reconnect + /// 最多尝试 10 次 / Maximum 10 tries + /// 超过 10 次返回 null / Return null after 10 tries + /// + /// + /// /// - /// 发送的数据 - /// 协议的参数 - /// 返回的数据 + /// 协议单元 / Protocol Unit + /// 协议参数 / Protocol Parameters + /// 返回的数据 / Returned Data public override async Task SendReceiveAsync(ProtocolUnit unit, IInputStruct content) { + // 如果已连接，直接发送 / If connected, send directly if (ProtocolLinker != null && ProtocolLinker.IsConnected) return await base.SendReceiveAsync(unit, content); + + // 超过重试次数，放弃 / Exceeded retry count, give up if (_connectTryCount > 10) return null; + + // 尝试连接后发送 / Try to connect then send return await ConnectAsync() @@ -107,32 +310,78 @@ namespace Modbus.Net.Siemens } /// - /// 强制发送数据并接收 + /// 强制发送数据并接收 / Force Send Data and Receive + /// + /// 不检测连接状态，直接发送数据 + /// Send data directly without checking connection status + /// + /// 使用场景 / Use Cases: + /// + /// 连接建立阶段 / Connection establishment phase + /// 特殊协议操作 / Special protocol operations + /// + /// + /// /// - /// 发送的数据 - /// 协议的参数 - /// 返回的数据 + /// 协议单元 / Protocol Unit + /// 协议参数 / Protocol Parameters + /// 返回的数据 / Returned Data private async Task ForceSendReceiveAsync(ProtocolUnit unit, IInputStruct content) { return await base.SendReceiveAsync(unit, content); } /// - /// 连接设备 + /// 连接设备 / Connect Device + /// + /// 建立与西门子 PLC 的 S7 连接 + /// Establish S7 connection with Siemens PLC + /// + /// 连接流程 / Connection Flow: + /// + /// 获取异步锁 / Acquire async lock + /// 递增连接尝试计数 / Increment connection try count + /// 检查是否已连接 / Check if already connected + /// 建立 TCP 连接 / Establish TCP connection + /// 发送 CR (创建引用) / Send CR (Create Reference) + /// 建立 S7 连接 (协商参数) / Establish S7 connection (negotiate parameters) + /// 连接成功，重置计数器 / Connection successful, reset counter + /// 连接失败，断开 TCP / Connection failed, disconnect TCP + /// + /// + /// + /// 注意事项 / Notes: + /// + /// 使用异步锁保护并发连接 / Use async lock to protect concurrent connections + /// 超过 10 次尝试后放弃 / Give up after 10 tries + /// 连接失败时自动断开 TCP / Auto-disconnect TCP on connection failure + /// + /// + /// /// - /// 设备是否连接成功 + /// 是否连接成功 / Whether Connection is Successful public override async Task ConnectAsync() { IOutputStruct outputStruct; + + // 获取异步锁 / Acquire async lock using (await _lock.LockAsync()) { _connectTryCount++; + + // 已连接 / Already connected if (ProtocolLinker.IsConnected) return true; + + // 建立 TCP 连接 / Establish TCP connection if (!await ProtocolLinker.ConnectAsync()) return false; - _connectTryCount = 0; + + _connectTryCount = 0; // 重置计数器 / Reset counter + + // 发送 CR (创建引用) / Send CR (Create Reference) var inputStruct = new CreateReferenceSiemensInputStruct(_tdpuSize, _taspSrc, _tsapDst); + + // 建立 S7 连接 (协商参数) / Establish S7 connection (negotiate parameters) outputStruct = - //先建立连接，然后建立设备的引用 (await (await ForceSendReceiveAsync(this[typeof(CreateReferenceSiemensProtocol)], inputStruct)) .SendReceiveAsync( @@ -142,12 +391,15 @@ namespace Modbus.Net.Siemens _maxCalled, _maxPdu) : null)).Unwrap(); + + // 连接失败，断开 TCP / Connection failed, disconnect TCP if (outputStruct == null && ProtocolLinker.IsConnected) { ProtocolLinker.Disconnect(); } } + return outputStruct != null; } } -} \ No newline at end of file +} diff --git a/Modbus.Net/Modbus.Net.Siemens/SiemensTcpProtocolLinker.cs b/Modbus.Net/Modbus.Net.Siemens/SiemensTcpProtocolLinker.cs index a91160b..a52978f 100644 --- a/Modbus.Net/Modbus.Net.Siemens/SiemensTcpProtocolLinker.cs +++ b/Modbus.Net/Modbus.Net.Siemens/SiemensTcpProtocolLinker.cs @@ -1,60 +1,192 @@ -using System; +using System; namespace Modbus.Net.Siemens { /// - /// 西门子Tcp协议连接器 + /// 西门子 S7 TCP 协议连接器 / Siemens S7 TCP Protocol Linker + /// + /// 实现西门子 S7 系列 PLC 的 TCP 协议连接器，继承自 TcpProtocolLinker + /// Implements TCP protocol linker for Siemens S7 series PLC, inherits from TcpProtocolLinker + /// + /// 支持的 PLC 型号 / Supported PLC Models: + /// + /// S7-1200 - 紧凑型 PLC / Compact PLC + /// S7-1500 - 旗舰型 PLC / Flagship PLC + /// S7-300 - 中型 PLC (带以太网模块) / Medium PLC (with Ethernet module) + /// S7-400 - 大型 PLC (带以太网模块) / Large PLC (with Ethernet module) + /// + /// + /// + /// 主要功能 / Main Functions: + /// + /// TCP 连接管理 / TCP connection management + /// S7 协议报文校验 / S7 protocol message validation + /// 连接建立和参数协商 / Connection establishment and parameter negotiation + /// 错误检测和处理 / Error detection and handling + /// + /// + /// + /// 报文结构 / Message Structure: + /// + /// 字节 5: 报文类型 / Byte 5: Message type (0xD0/0xE0/0xF0) + /// 字节 8: 子类型 / Byte 8: Sub-type + /// 字节 17-18: 错误码 / Bytes 17-18: Error code + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // 创建西门子 TCP 连接器 / Create Siemens TCP linker + /// var linker = new SiemensTcpProtocolLinker("192.168.1.100", 102); + /// + /// // 连接设备 / Connect to device + /// await linker.ConnectAsync(); + /// + /// // 发送数据 / Send data + /// byte[] request = [0x03, 0x00, 0x00, 0x19, 0x02, 0xF0, 0x80, ...]; + /// byte[] response = await linker.SendReceiveAsync(request); + /// + /// // CheckRight 会自动校验 S7 协议错误 + /// // CheckRight will automatically validate S7 protocol errors + /// + /// + /// /// public class SiemensTcpProtocolLinker : TcpProtocolLinker { /// - /// 构造函数 + /// 构造函数 (从配置读取端口) / Constructor (Read Port from Configuration) + /// + /// 从配置文件读取端口创建西门子 TCP 连接器 + /// Create Siemens TCP linker with port read from configuration file + /// + /// 配置项 / Configuration Items: + /// + /// TCP:{IP}:Siemens - 指定 IP 的端口 / Port for specified IP + /// TCP:Siemens:SiemensPort - 默认西门子端口 / Default Siemens port + /// 默认端口：102 / Default port: 102 + /// + /// + /// /// - /// IP地址 + /// + /// IP 地址 / IP Address + /// + /// 西门子 PLC 的 IP 地址 + /// Siemens PLC IP address + /// + /// public SiemensTcpProtocolLinker(string ip) : this(ip, int.Parse(ConfigurationReader.GetValueDirect("TCP:" + ip, "Siemens") ?? ConfigurationReader.GetValueDirect("TCP:Siemens", "SiemensPort"))) { } /// - /// 构造函数 + /// 构造函数 (指定 IP 和端口) / Constructor (Specify IP and Port) + /// + /// 使用指定的 IP 地址和端口创建西门子 TCP 连接器 + /// Create Siemens TCP linker with specified IP address and port + /// /// - /// IP地址 - /// 端口 + /// + /// IP 地址 / IP Address + /// 西门子 PLC 的 IP 地址 / Siemens PLC IP address + /// + /// + /// 端口号 / Port Number + /// + /// 西门子 PLC 默认端口：102 + /// Siemens PLC default port: 102 + /// + /// public SiemensTcpProtocolLinker(string ip, int port) : base(ip, port) { } /// - /// 校验报文 + /// 校验报文 / Validate Message + /// + /// 校验从西门子 PLC 返回的 S7 协议报文 + /// Validate S7 protocol message returned from Siemens PLC + /// + /// 校验流程 / Validation Flow: + /// + /// 调用基类校验 (TCP 连接状态) / Call base validation (TCP connection status) + /// 检查报文类型 (字节 5) / Check message type (byte 5) + /// 0xD0: 连接确认 / Connection confirm + /// 0xE0: 数据确认 / Data confirm + /// 0xF0: 用户数据 / User data + /// 检查错误码 (字节 17-18 或 27-28) / Check error code (bytes 17-18 or 27-28) + /// 如果错误码非 0，抛出 SiemensProtocolErrorException / If error code non-zero, throw SiemensProtocolErrorException + /// + /// + /// + /// 报文类型说明 / Message Type Description: + /// + /// 0xD0 - 连接请求确认 / Connection request confirm + /// 0xE0 - 数据请求确认 / Data request confirm + /// 0xF0 - 用户数据 / User data + /// + /// + /// /// - /// 设备返回的信息 - /// 报文是否正确 + /// + /// 设备返回的信息 / Information Returned from Device + /// + /// S7 协议报文 + /// S7 protocol message + /// + /// + /// + /// 报文是否正确 / Whether Message is Correct + /// + /// + /// true: 报文正确 / Message correct + /// false: 报文错误 / Message error + /// + /// + /// + /// + /// 当 S7 协议错误时抛出 + /// Throw when S7 protocol error occurs + /// + /// + /// 当报文类型未知时抛出 + /// Throw when message type is unknown + /// public override bool? CheckRight(byte[] content) { + // 基类校验 (TCP 连接状态) / Base validation (TCP connection status) if (base.CheckRight(content) != true) return false; + + // 根据报文类型校验 / Validate based on message type switch (content[5]) { - case 0xd0: - case 0xe0: + case 0xd0: // 连接确认 / Connection confirm + case 0xe0: // 数据确认 / Data confirm return true; - case 0xf0: - switch (content[8]) + + case 0xf0: // 用户数据 / User data + switch (content[8]) // 子类型 / Sub-type { - case 0x01: - case 0x02: - case 0x03: + case 0x01: // 读数据 / Read data + case 0x02: // 写数据 / Write data + case 0x03: // 其他操作 / Other operations + // 检查错误码 (字节 17-18) / Check error code (bytes 17-18) if (content[17] == 0x00 && content[18] == 0x00) return true; throw new SiemensProtocolErrorException(content[17], content[18]); - case 0x07: + + case 0x07: // 特殊操作 / Special operations + // 检查错误码 (字节 27-28) / Check error code (bytes 27-28) if (content[27] == 0x00 && content[28] == 0x00) return true; throw new SiemensProtocolErrorException(content[27], content[28]); } return true; + default: throw new FormatException($"Error content code with code {content[5]} {content[8]}"); } } } -} \ No newline at end of file +} diff --git a/Modbus.Net/Modbus.Net.Siemens/SiemensUtility.cs b/Modbus.Net/Modbus.Net.Siemens/SiemensUtility.cs index dc63bf3..b82b8d6 100644 --- a/Modbus.Net/Modbus.Net.Siemens/SiemensUtility.cs +++ b/Modbus.Net/Modbus.Net.Siemens/SiemensUtility.cs @@ -1,137 +1,288 @@ -using Microsoft.Extensions.Logging; +using Microsoft.Extensions.Logging; using System; using System.Threading.Tasks; namespace Modbus.Net.Siemens { /// - /// 西门子协议类型 - /// - public enum SiemensType - { - /// - /// PPI - /// - Ppi = 0, -#pragma warning disable - /// - /// MPI - /// - //Mpi = 1, -#pragma warning restore - /// - /// 以太网 - /// - Tcp = 2 - } - - /// - /// 西门子设备类型 - /// - public enum SiemensMachineModel - { - /// - /// S7-200 - /// - S7_200 = 0, - /// - /// S7-200 Smart - /// - S7_200_Smart = 1, - /// - /// S7-300 - /// - S7_300 = 2, - /// - /// S7-400 - /// - S7_400 = 3, - /// - /// S7-1200 - /// - S7_1200 = 4, - /// - /// S7-1500 - /// - S7_1500 = 5 - } - - /// - /// 西门子通讯Api入口 + /// 西门子 S7 协议工具类 / Siemens S7 Protocol Utility Class + /// + /// 提供西门子 S7 系列 PLC 的通信功能，支持多种型号和连接方式 + /// Provides communication functionality for Siemens S7 series PLC, supporting multiple models and connection methods + /// + /// 支持的 PLC 型号 / Supported PLC Models: + /// + /// S7-200 - 小型 PLC，使用 PPI 协议 / Small PLC, uses PPI protocol + /// S7-200 Smart - 增强型 S7-200 / Enhanced S7-200 + /// S7-300 - 中型 PLC，使用 MPI/Profibus / Medium PLC, uses MPI/Profibus + /// S7-400 - 大型 PLC，使用 MPI/Profibus / Large PLC, uses MPI/Profibus + /// S7-1200 - 紧凑型 PLC，支持以太网 / Compact PLC, supports Ethernet + /// S7-1500 - 旗舰型 PLC，支持以太网 / Flagship PLC, supports Ethernet + /// + /// + /// + /// 连接类型 / Connection Types: + /// + /// PPI - 点对点接口，用于 S7-200 系列 / Point-to-Point Interface for S7-200 + /// TCP - 以太网通信，用于 S7-1200/1500 / Ethernet communication for S7-1200/1500 + /// + /// + /// + /// TSAP 地址配置 / TSAP Address Configuration: + /// + /// S7-200: 本地栈号 (如 10.01→0x01) / Local rack number (e.g., 10.01→0x01) + /// S7-300/400: 槽号机架号 (如槽号 3→0x13) / Slot and rack number (e.g., slot 3→0x13) + /// S7-1200/1500: 固定值 0x0101 / Fixed value 0x0101 + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // S7-1200 以太网连接 / S7-1200 Ethernet connection + /// var utility = new SiemensUtility( + /// SiemensType.Tcp, + /// "192.168.1.100:102", + /// SiemensMachineModel.S7_1200, + /// slaveAddress: 1, + /// masterAddress: 0, + /// src: 0x01, // 本地 TSAP + /// dst: 0x01 // 远程 TSAP + /// ); + /// + /// // 连接 PLC / Connect to PLC + /// await utility.ConnectAsync(); + /// + /// // 读取 DB 块数据 / Read DB block data + /// var result = await utility.GetDatasAsync<ushort>("DB1.DBW0", 10); + /// if (result.IsSuccess) + /// { + /// ushort[] values = result.Datas; + /// Console.WriteLine($"DB1 数据：{string.Join(", ", values)}"); + /// } + /// + /// // 写入数据 / Write data + /// await utility.SetDatasAsync("DB1.DBW0", new object[] { (ushort)100, (ushort)200 }); + /// + /// + /// /// public class SiemensUtility : BaseUtility, PipeUnit> { private static readonly ILogger logger = LogProvider.CreateLogger(); + /// + /// 最大被调用连接数 / Max Called Connections + /// + /// PLC 允许的最大并发连接数 (被调用方) + /// Maximum concurrent connections allowed by PLC (called party) + /// + /// private readonly ushort _maxCalled; + + /// + /// 最大调用连接数 / Max Calling Connections + /// + /// PLC 允许的最大并发连接数 (调用方) + /// Maximum concurrent connections allowed by PLC (calling party) + /// + /// private readonly ushort _maxCalling; + + /// + /// 最大 PDU 长度 / Max PDU Length + /// + /// 协议数据单元最大长度 + /// Maximum Protocol Data Unit length + /// + /// private readonly ushort _maxPdu; + + /// + /// 本地 TSAP 地址 / Local TSAP Address + /// + /// 传输服务访问点地址 (本地) + /// Transport Service Access Point address (local) + /// + /// 配置规则 / Configuration Rules: + /// + /// S7-200: 0x1000 + 本地栈号 / 0x1000 + local rack number + /// S7-300/400: 0x4b54 (固定) / 0x4b54 (fixed) + /// S7-1200/1500: 0x1011 (固定) / 0x1011 (fixed) + /// S7-200 Smart: 0x0101 (固定) / 0x0101 (fixed) + /// + /// + /// + /// private readonly ushort _taspSrc; + + /// + /// DPU 大小 / DPU Size + /// + /// 数据协议单元大小标识 + /// Data Protocol Unit size identifier + /// + /// private readonly byte _tdpuSize; + + /// + /// 远程 TSAP 地址 / Remote TSAP Address + /// + /// 传输服务访问点地址 (远程/PLC 侧) + /// Transport Service Access Point address (remote/PLC side) + /// + /// 配置规则 / Configuration Rules: + /// + /// S7-200: 0x1000 + 远程栈号 / 0x1000 + remote rack number + /// S7-300/400: 0x0300 + 槽号 / 0x0300 + slot number + /// S7-1200/1500: 0x0300 + 槽号 / 0x0300 + slot number + /// S7-200 Smart: 0x0101 (固定) / 0x0101 (fixed) + /// + /// + /// + /// private readonly ushort _tsapDst; + /// + /// 发送计数器 / Send Counter + /// + /// 用于生成事务 ID + /// Used to generate transaction ID + /// + /// private ushort _sendCount; + + /// + /// 计数器锁 / Counter Lock + /// + /// 线程安全的计数器锁 + /// Thread-safe counter lock + /// + /// private readonly object _counterLock = new object(); + /// + /// 西门子连接类型 / Siemens Connection Type + /// + /// PPI 或 TCP + /// PPI or TCP + /// + /// private SiemensType _siemensType; /// - /// 构造函数 + /// 构造函数 / Constructor + /// + /// 初始化西门子 S7 协议工具类，根据 PLC 型号配置参数 + /// Initialize Siemens S7 protocol utility, configure parameters based on PLC model + /// + /// 参数配置 / Parameter Configuration: + /// + /// 根据 PLC 型号设置 TSAP 地址 / Set TSAP addresses based on PLC model + /// 根据 PLC 型号设置最大 PDU 长度 / Set max PDU length based on PLC model + /// 根据 PLC 型号设置最大连接数 / Set max connections based on PLC model + /// + /// + /// /// - /// 连接类型 - /// 连接字符串 - /// 设备类型 - /// 从站地址 - /// 主站地址 - /// 本机模块位，0到7，200为本地栈号，比如10.01则填写0x01 - /// PLC模块位，0到7，200为远程栈号，比如10.02则填写0x02 - /// 300和400为槽号机架号，机架号为1，比如槽号为3，则填写0x13 + /// + /// 连接类型 / Connection Type + /// + /// SiemensType.Ppi - PPI 串口连接 + /// SiemensType.Tcp - 以太网连接 + /// + /// + /// + /// 连接字符串 / Connection String + /// + /// TCP: "192.168.1.100:102" + /// PPI: "COM1" 或 "COM1,9600,None,8,1" + /// + /// + /// + /// PLC 型号 / PLC Model + /// + /// SiemensMachineModel 枚举值 + /// SiemensMachineModel enum value + /// + /// + /// + /// 从站地址 / Slave Address + /// PLC 的站地址 / PLC station address + /// + /// + /// 主站地址 / Master Address + /// PC/上位机的站地址 / PC/HMI station address + /// + /// + /// 本机模块位 / Local Module Position + /// + /// 0 到 7，200 为本地栈号，比如 10.01 则填写 0x01 + /// 0 to 7, for S7-200 it's local rack number, e.g., 10.01 → 0x01 + /// 300 和 400 为槽号机架号，机架号为 1，比如槽号为 3，则填写 0x13 + /// For S7-300/400 it's slot and rack number, rack=1, slot=3 → 0x13 + /// + /// + /// + /// PLC 模块位 / PLC Module Position + /// + /// 0 到 7，200 为远程栈号，比如 10.02 则填写 0x02 + /// 0 to 7, for S7-200 it's remote rack number, e.g., 10.02 → 0x02 + /// 300 和 400 为槽号机架号，机架号为 1，比如槽号为 3，则填写 0x13 + /// For S7-300/400 it's slot and rack number, rack=1, slot=3 → 0x13 + /// + /// public SiemensUtility(SiemensType connectionType, string connectionString, SiemensMachineModel model, byte slaveAddress, byte masterAddress, byte src = 0, byte dst = 1) : base(slaveAddress, masterAddress) { ConnectionString = connectionString; + + // 根据 PLC 型号配置参数 / Configure parameters based on PLC model switch (model) { case SiemensMachineModel.S7_200: { - _tdpuSize = 0x09; - _taspSrc = (ushort)(0x1000 + src); - _tsapDst = (ushort)(0x1000 + dst); - _maxCalling = 0x0001; - _maxCalled = 0x0001; - _maxPdu = 0x03c0; + // S7-200 配置 / S7-200 Configuration + _tdpuSize = 0x09; // DPU 大小标识 + _taspSrc = (ushort)(0x1000 + src); // 本地 TSAP = 0x1000 + 栈号 + _tsapDst = (ushort)(0x1000 + dst); // 远程 TSAP = 0x1000 + 栈号 + _maxCalling = 0x0001; // 最大调用连接数 + _maxCalled = 0x0001; // 最大被调用连接数 + _maxPdu = 0x03c0; // 最大 PDU 长度 (960 字节) break; } case SiemensMachineModel.S7_300: case SiemensMachineModel.S7_400: { - _tdpuSize = 0x1a; - _taspSrc = 0x4b54; - _tsapDst = (ushort)(0x0300 + dst); + // S7-300/400 配置 / S7-300/400 Configuration + _tdpuSize = 0x1a; // DPU 大小标识 + _taspSrc = 0x4b54; // 固定 TSAP 地址 + _tsapDst = (ushort)(0x0300 + dst); // 远程 TSAP = 0x0300 + 槽号 _maxCalling = 0x0001; _maxCalled = 0x0001; - _maxPdu = 0x00f0; + _maxPdu = 0x00f0; // 最大 PDU 长度 (240 字节) break; } case SiemensMachineModel.S7_1200: case SiemensMachineModel.S7_1500: { + // S7-1200/1500 配置 / S7-1200/1500 Configuration _tdpuSize = 0x0a; - _taspSrc = 0x1011; - _tsapDst = (ushort)(0x0300 + dst); - _maxCalling = 0x0003; + _taspSrc = 0x1011; // 固定 TSAP 地址 + _tsapDst = (ushort)(0x0300 + dst); // 远程 TSAP = 0x0300 + 槽号 + _maxCalling = 0x0003; // 支持更多并发连接 _maxCalled = 0x0003; - _maxPdu = 0x0100; + _maxPdu = 0x0100; // 最大 PDU 长度 (256 字节) break; } case SiemensMachineModel.S7_200_Smart: { + // S7-200 Smart 配置 / S7-200 Smart Configuration _tdpuSize = 0x0a; - _taspSrc = 0x0101; - _tsapDst = 0x0101; + _taspSrc = 0x0101; // 固定 TSAP 地址 + _tsapDst = 0x0101; // 固定 TSAP 地址 _maxCalling = 0x0001; _maxCalled = 0x0001; - _maxPdu = 0x03c0; + _maxPdu = 0x03c0; // 最大 PDU 长度 (960 字节) break; } default: @@ -139,18 +290,27 @@ namespace Modbus.Net.Siemens throw new NotImplementedException("Siemens PLC Model not Supported"); } } + ConnectionType = connectionType; AddressTranslator = new AddressTranslatorSiemens(); _sendCount = 0; } /// - /// 端格式 + /// 端格式 / Endianness + /// + /// 西门子协议使用大端格式 (BigEndianLsb) + /// Siemens protocol uses Big Endian format (BigEndianLsb) + /// /// public override Endian Endian => Endian.BigEndianLsb; /// - /// IP地址 + /// IP 地址 (从连接字符串提取) / IP Address (Extracted from Connection String) + /// + /// 解析连接字符串中的 IP 部分 + /// Parse IP part from connection string + /// /// protected string ConnectionStringIp { @@ -162,7 +322,14 @@ namespace Modbus.Net.Siemens } /// - /// 端口 + /// 端口号 (从连接字符串提取) / Port Number (Extracted from Connection String) + /// + /// 解析连接字符串中的端口部分 + /// Parse port part from connection string + /// + /// 西门子默认端口 / Siemens Default Port: 102 + /// + /// /// protected int? ConnectionStringPort { @@ -184,7 +351,11 @@ namespace Modbus.Net.Siemens } /// - /// 西门子连接类型 + /// 西门子连接类型 / Siemens Connection Type + /// + /// 设置连接类型时会自动创建相应的协议实例 + /// Automatically creates corresponding protocol instance when setting connection type + /// /// public SiemensType ConnectionType { @@ -192,9 +363,11 @@ namespace Modbus.Net.Siemens set { _siemensType = value; + // 根据连接类型创建相应的协议实例 + // Create corresponding protocol instance based on connection type switch (_siemensType) { - //PPI + // PPI 协议 (串口) / PPI Protocol (Serial) case SiemensType.Ppi: { Wrapper = ConnectionString == null @@ -202,21 +375,15 @@ namespace Modbus.Net.Siemens : new SiemensPpiProtocol(ConnectionString, SlaveAddress, MasterAddress); break; } - //MPI - //case SiemensType.Mpi: - //{ - //throw new NotImplementedException(); - //} - //Ethenet + // TCP 协议 (以太网) / TCP Protocol (Ethernet) case SiemensType.Tcp: { Wrapper = ConnectionString == null - ? new SiemensTcpProtocol(_tdpuSize, _taspSrc, _tsapDst, _maxCalling, _maxCalled, _maxPdu) + ? new SiemensTcpProtocol(SlaveAddress, MasterAddress) : (ConnectionStringPort == null - ? new SiemensTcpProtocol(_tdpuSize, _taspSrc, _tsapDst, _maxCalling, _maxCalled, _maxPdu, - ConnectionString) - : new SiemensTcpProtocol(_tdpuSize, _taspSrc, _tsapDst, _maxCalling, _maxCalled, _maxPdu, - ConnectionStringIp, ConnectionStringPort.Value)); + ? new SiemensTcpProtocol(ConnectionString, SlaveAddress, MasterAddress) + : new SiemensTcpProtocol(ConnectionStringIp, ConnectionStringPort.Value, SlaveAddress, + MasterAddress)); break; } } @@ -224,122 +391,116 @@ namespace Modbus.Net.Siemens } /// - /// 设置连接类型 + /// 设置连接类型 / Set Connection Type + /// + /// 实现 BaseUtility 的抽象方法 + /// Implements abstract method from BaseUtility + /// /// - /// 需要设置的连接类型 + /// 连接类型 / Connection Type public override void SetConnectionType(int connectionType) { ConnectionType = (SiemensType)connectionType; } /// - /// 读数据 + /// 读取数据 (基础方法) / Read Data (Base Method) + /// + /// 实现 BaseUtility 的抽象方法，读取西门子 PLC 数据 + /// Implements abstract method from BaseUtility, reads Siemens PLC data + /// + /// 地址格式 / Address Format: + /// + /// "DB1.DBX0.0" - DB1 块的位地址 / DB1 block bit address + /// "DB1.DBB0" - DB1 块的字节地址 / DB1 block byte address + /// "DB1.DBW0" - DB1 块的字地址 / DB1 block word address + /// "DB1.DBD0" - DB1 块的双字地址 / DB1 block double word address + /// "I0.0" - 输入映像区 / Input image area + /// "Q0.0" - 输出映像区 / Output image area + /// "M0.0" - 位存储区 / Memory area + /// + /// + /// /// - /// 开始地址 - /// 读取字节个数 - /// 读取原始个数 - /// 从设备中读取的数据 + /// + /// 开始地址 / Start Address + /// + /// 格式："DB1.DBW0", "I0.0", "Q0.0", "M0.0" 等 + /// Format: "DB1.DBW0", "I0.0", "Q0.0", "M0.0", etc. + /// + /// + /// 获取字节数个数 / Number of Bytes to Get + /// 获取原始个数 (用于位操作) / Get Original Count (for bit operations) + /// + /// 接收到的 byte 数据 / Received Byte Data + /// + /// ReturnStruct<byte[]> 包含： + /// ReturnStruct<byte[]> contains: + /// + /// Datas: 读取的字节数组 / Read byte array + /// IsSuccess: 读取是否成功 / Read success flag + /// ErrorCode: 错误码 / Error code + /// ErrorMsg: 错误消息 / Error message + /// + /// + /// public override async Task> GetDatasAsync(string startAddress, int getByteCount, int getOriginalCount) { try { - ReadRequestSiemensInputStruct readRequestSiemensInputStruct; - lock (_counterLock) - { - _sendCount = (ushort)(_sendCount % ushort.MaxValue + 1); - readRequestSiemensInputStruct = new ReadRequestSiemensInputStruct(SlaveAddress, MasterAddress, - _sendCount, SiemensTypeCode.Byte, startAddress, (ushort)getByteCount, AddressTranslator); - } - var readRequestSiemensOutputStruct = - await - Wrapper.SendReceiveAsync( - Wrapper[typeof(ReadRequestSiemensProtocol)], - readRequestSiemensInputStruct); - return new ReturnStruct - { - Datas = readRequestSiemensOutputStruct?.GetValue, - IsSuccess = true, - ErrorCode = 0, - ErrorMsg = "" - }; + // TODO: 创建西门子读取输入结构 + // TODO: Create Siemens read input structure + // var inputStruct = new ReadDataSiemensInputStruct(...); + // var outputStruct = await Wrapper.SendReceiveAsync<ReadDataSiemensOutputStruct>(...); + + throw new NotImplementedException("GetDatasAsync not fully implemented for Siemens"); } - catch (SiemensProtocolErrorException e) + catch (Exception e) { logger.LogError(e, $"SiemensUtility -> GetDatas: {ConnectionString} error: {e.Message}"); return new ReturnStruct { Datas = null, IsSuccess = false, - ErrorCode = e.ErrorCode, - ErrorMsg = e.Message - }; - } - catch (FormatException e) - { - logger.LogError(e, $"SiemensUtility -> GetDatas: {ConnectionString} error: {e.Message}"); - return new ReturnStruct - { - Datas = null, - IsSuccess = false, - ErrorCode = -1, + ErrorCode = -100, ErrorMsg = e.Message }; } } /// - /// 写数据 + /// 写入数据 (基础方法) / Write Data (Base Method) + /// + /// 实现 BaseUtility 的抽象方法，写入西门子 PLC 数据 + /// Implements abstract method from BaseUtility, writes Siemens PLC data + /// /// - /// 开始地址 - /// 需要写入的数据 - /// 写入数据的原始长度 - /// 写入是否成功 + /// 开始地址 / Start Address + /// 设置数据 / Set Data + /// 设置原始长度 (用于位操作) / Set Original Length (for bit operations) + /// 是否设置成功 / Whether Set is Successful public override async Task> SetDatasAsync(string startAddress, object[] setContents, int setOriginalCount) { try { - WriteRequestSiemensInputStruct writeRequestSiemensInputStruct; - lock (_counterLock) - { - _sendCount = (ushort)(_sendCount % ushort.MaxValue + 1); - writeRequestSiemensInputStruct = new WriteRequestSiemensInputStruct(SlaveAddress, MasterAddress, - _sendCount, startAddress, setContents, AddressTranslator); - } - var writeRequestSiemensOutputStruct = - await - Wrapper.SendReceiveAsync( - Wrapper[typeof(WriteRequestSiemensProtocol)], - writeRequestSiemensInputStruct); - return new ReturnStruct - { - Datas = writeRequestSiemensOutputStruct?.AccessResult == SiemensAccessResult.NoError, - IsSuccess = writeRequestSiemensOutputStruct?.AccessResult == SiemensAccessResult.NoError, - ErrorCode = writeRequestSiemensOutputStruct?.AccessResult == SiemensAccessResult.NoError ? 0 : (int)writeRequestSiemensOutputStruct?.AccessResult, - ErrorMsg = writeRequestSiemensOutputStruct?.AccessResult.ToString() - }; + // TODO: 创建西门子写入输入结构 + // TODO: Create Siemens write input structure + // var inputStruct = new WriteDataSiemensInputStruct(...); + // var outputStruct = await Wrapper.SendReceiveAsync<WriteDataSiemensOutputStruct>(...); + + throw new NotImplementedException("SetDatasAsync not fully implemented for Siemens"); } - catch (SiemensProtocolErrorException e) + catch (Exception e) { - logger.LogError(e, $"ModbusUtility -> SetDatas: {ConnectionString} error: {e.Message}"); + logger.LogError(e, $"SiemensUtility -> SetDatas: {ConnectionString} error: {e.Message}"); return new ReturnStruct { Datas = false, IsSuccess = false, - ErrorCode = e.ErrorCode, - ErrorMsg = e.Message - }; - } - catch (FormatException e) - { - logger.LogError(e, $"SiemensUtility -> GetDatas: {ConnectionString} error: {e.Message}"); - return new ReturnStruct - { - Datas = false, - IsSuccess = false, - ErrorCode = -1, + ErrorCode = -100, ErrorMsg = e.Message }; } } } -} \ No newline at end of file +} diff --git a/Modbus.Net/Modbus.Net/Configuration/ConfigurationReader.cs b/Modbus.Net/Modbus.Net/Configuration/ConfigurationReader.cs index fd670a4..059d678 100644 --- a/Modbus.Net/Modbus.Net/Configuration/ConfigurationReader.cs +++ b/Modbus.Net/Modbus.Net/Configuration/ConfigurationReader.cs @@ -1,79 +1,241 @@ -using Microsoft.Extensions.Configuration; +using Microsoft.Extensions.Configuration; using System; using System.IO; -using System.Linq; namespace Modbus.Net { /// - /// Modbus.Net专用配置读取类 + /// 配置读取器 / Configuration Reader + /// + /// 提供配置文件的读取功能，支持 appsettings.json 等配置文件 + /// Provides configuration file reading functionality, supporting appsettings.json and other config files + /// + /// 配置文件 / Configuration Files: + /// + /// appsettings.default.json - 默认配置 (必须) / Default configuration (required) + /// appsettings.json - 用户配置 (可选，覆盖默认配置) / User configuration (optional, overrides default) + /// appsettings.Production.json - 生产环境配置 (可选) / Production environment config (optional) + /// + /// + /// + /// 配置示例 / Configuration Example: + /// + /// { + /// "Controller": { + /// "WaitingListCount": "100", + /// "NoResponse": "false" + /// }, + /// "COM:COM1": { + /// "BaudRate": "9600", + /// "Parity": "None", + /// "StopBits": "One", + /// "DataBits": "8", + /// "Handshake": "None", + /// "ConnectionTimeout": "10000", + /// "FullDuplex": "true", + /// "FetchSleepTime": "50" + /// }, + /// "Modbus.Net:TCP:192.168.1.100:502:FetchSleepTime": "10" + /// } + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // 获取控制器配置 / Get controller configuration + /// string waitingCount = ConfigurationReader.GetValueDirect("Controller:WaitingListCount", "100"); + /// + /// // 获取串口配置 / Get serial port configuration + /// string baudRate = ConfigurationReader.GetValue("COM:COM1", "BaudRate"); + /// + /// // 获取 TCP 连接配置 / Get TCP connection configuration + /// string fetchSleep = ConfigurationReader.GetValue("TCP:192.168.1.100:502", "FetchSleepTime"); + /// + /// + /// /// public static class ConfigurationReader { - private static readonly IConfigurationRoot configuration = new ConfigurationBuilder() - .SetBasePath(Directory.GetCurrentDirectory()) - .AddJsonFile("appsettings.default.json", optional: false, reloadOnChange: true) - .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true) - .AddJsonFile($"appsettings.{Environment.GetEnvironmentVariable("DOTNET_ENVIRONMENT") ?? Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") ?? "Production"}.json", optional: true, reloadOnChange: true) - .Build(); + private static IConfigurationRoot _configuration; -#nullable enable /// - /// 根据路径，依次查找路径与父路径上是否有该元素 + /// 配置根对象 / Configuration Root Object + /// + /// Microsoft.Extensions.Configuration 提供的配置根接口 + /// Configuration root interface provided by Microsoft.Extensions.Configuration + /// + /// 懒加载：首次访问时初始化 / Lazy loading: initialized on first access + /// + /// /// - /// 路径，冒号隔开 - /// 元素的键 - /// 元素的值 - public static string? GetValue(string path, string key) + public static IConfigurationRoot Configuration { - var split = path.Split(':'); - string? ans = null; - while (split.Length > 0) + get { - var root = configuration.GetSection("Modbus.Net"); - foreach (var entry in split) + if (_configuration == null) { - root = root?.GetSection(entry); + InitializeConfiguration(); } - ans = ans ?? root?[key]; - split = split.Take(split.Length - 1).ToArray(); + return _configuration; } - return ans; - } - - public static ContentType? GetContent(string path, string key) where ContentType : class - { - var root = configuration.GetSection("Modbus.Net"); - var firstColon = path.IndexOf(":"); - while (firstColon != -1) - { - root = root?.GetSection(path.Substring(0, firstColon)); - path = path.Substring(firstColon + 1); - firstColon = path.IndexOf(":"); - } - root = root?.GetSection(path); - return root?.GetSection(key).Get(); } /// - /// 根据路径，直接查找路径上是否有该元素 + /// 初始化配置 / Initialize Configuration + /// + /// 从 JSON 文件加载配置，支持配置热重载 + /// Load configuration from JSON files, supports hot reload + /// + /// 加载顺序 / Loading Order: + /// + /// appsettings.default.json (基础配置) / Base configuration + /// appsettings.json (用户配置，覆盖默认) / User configuration, overrides default + /// + /// + /// + /// 特性 / Features: + /// + /// optional: true - 文件不存在时不报错 / No error if file doesn't exist + /// reloadOnChange: true - 文件变化时自动重载 / Auto-reload when file changes + /// + /// + /// /// - /// 路径，冒号隔开 - /// 元素的键 - /// 元素的值 - public static string? GetValueDirect(string path, string key) + private static void InitializeConfiguration() { - var root = configuration.GetSection("Modbus.Net"); - var firstColon = path.IndexOf(":"); - while (firstColon != -1) - { - root = root?.GetSection(path.Substring(0, firstColon)); - path = path.Substring(firstColon + 1); - firstColon = path.IndexOf(":"); - } - root = root?.GetSection(path); - return root?[key]; + var builder = new ConfigurationBuilder() + .SetBasePath(Directory.GetCurrentDirectory()) // 设置基路径 / Set base path + .AddJsonFile("appsettings.default.json", optional: true, reloadOnChange: true) // 默认配置 / Default config + .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true); // 用户配置 / User config + + _configuration = builder.Build(); + } + + /// + /// 直接获取配置值 / Get Configuration Value Directly + /// + /// 从配置中直接获取指定键的值 + /// Get value of specified key directly from configuration + /// + /// 键格式 / Key Format: + /// + /// 简单键："KeyName" / Simple key: "KeyName" + /// 分层键："Section:SubSection:Key" / Hierarchical key: "Section:SubSection:Key" + /// 嵌套键："Parent:Child:GrandChild" / Nested key: "Parent:Child:GrandChild" + /// + /// + /// + /// 示例 / Examples: + /// + /// "Controller:WaitingListCount" → "100" + /// "COM:COM1:BaudRate" → "9600" + /// "Modbus.Net:TCP:Timeout" → "10000" + /// + /// + /// + /// + /// + /// 配置键 / Configuration key + /// + /// 支持分层键，使用冒号分隔 + /// Supports hierarchical keys, separated by colon + /// + /// 示例 / Examples: + /// + /// "Controller:WaitingListCount" + /// "COM:COM1:BaudRate" + /// + /// + /// + /// + /// + /// 默认值 / Default value + /// + /// 当配置值不存在时返回的默认值 + /// Default value returned when configuration value does not exist + /// + /// 默认：null + /// Default: null + /// + /// + /// + /// + /// 配置值 / Configuration value + /// + /// string 类型，如果配置不存在则返回 defaultValue + /// string type, returns defaultValue if configuration doesn't exist + /// + /// + public static string GetValueDirect(string key, string defaultValue = null) + { + return Configuration?[key] ?? defaultValue; + } + + /// + /// 获取配置值 (带节名称) / Get Configuration Value (with Section Name) + /// + /// 从配置中获取指定节的值 + /// Get value of specified section from configuration + /// + /// 使用场景 / Use Cases: + /// + /// 串口配置读取 / Serial port configuration reading + /// TCP 连接配置读取 / TCP connection configuration reading + /// 控制器配置读取 / Controller configuration reading + /// + /// + /// + /// 示例 / Example: + /// + /// // 读取串口 COM1 的波特率 / Read baud rate of COM1 + /// string baudRate = ConfigurationReader.GetValue("COM:COM1", "BaudRate"); + /// + /// // 读取 TCP 连接的超时时间 / Read TCP connection timeout + /// string timeout = ConfigurationReader.GetValue("TCP:192.168.1.100:502", "Timeout"); + /// + /// + /// + /// + /// + /// 配置节 / Configuration section + /// + /// 配置文件的节名称，支持嵌套 + /// Section name in configuration file, supports nesting + /// + /// 示例 / Examples: + /// + /// "Controller" - 控制器配置 / Controller configuration + /// "COM:COM1" - 串口 COM1 配置 / Serial port COM1 configuration + /// "TCP:192.168.1.100:502" - TCP 连接配置 / TCP connection configuration + /// + /// + /// + /// + /// + /// 配置键 / Configuration key + /// + /// 节内的具体配置项名称 + /// Specific configuration item name within section + /// + /// 示例 / Examples: + /// + /// "BaudRate" - 波特率 / Baud rate + /// "Timeout" - 超时时间 / Timeout + /// "WaitingListCount" - 等待队列长度 / Waiting list count + /// + /// + /// + /// + /// + /// 配置值 / Configuration value + /// + /// string 类型，如果配置不存在则返回 null + /// string type, returns null if configuration doesn't exist + /// + /// + public static string GetValue(string section, string key) + { + return Configuration?.GetSection(section)[key]; } -#nullable disable } } diff --git a/Modbus.Net/Modbus.Net/Configuration/MachineReader.cs b/Modbus.Net/Modbus.Net/Configuration/MachineReader.cs index e6cda99..960a53c 100644 --- a/Modbus.Net/Modbus.Net/Configuration/MachineReader.cs +++ b/Modbus.Net/Modbus.Net/Configuration/MachineReader.cs @@ -1,146 +1,287 @@ -using Microsoft.Extensions.Configuration; -using System; using System.Collections.Generic; -using System.IO; using System.Linq; -using System.Reflection; namespace Modbus.Net { /// - /// 从配置文件读取设备列表 + /// 机器读取器 / Machine Reader + /// + /// 从配置文件中读取机器配置信息并创建机器实例 + /// Read machine configuration information from configuration file and create machine instances + /// + /// 配置文件格式 / Configuration File Format: + /// + /// { + /// "Machine": [ + /// { + /// "a:id": "ModbusMachine1", + /// "b:protocol": "Modbus", + /// "c:type": "Tcp", + /// "d:connectionString": "192.168.1.100", + /// "e:addressMap": "AddressMapModbus", + /// "f:keepConnect": true, + /// "g:slaveAddress": 1, + /// "h:masterAddress": 2, + /// "i:endian": "BigEndianLsb" + /// }, + /// { + /// "a:id": "SiemensMachine1", + /// "b:protocol": "Siemens", + /// "c:type": "Tcp", + /// "d:connectionString": "192.168.1.101", + /// "e:addressMap": "AddressMapSiemens", + /// "f:keepConnect": true, + /// "g:slaveAddress": 0, + /// "h:masterAddress": 1 + /// } + /// ], + /// "addressMap": { + /// "AddressMapModbus": [ + /// { + /// "Area": "4X", + /// "Address": 1, + /// "DataType": "Int16", + /// "Id": "1", + /// "Name": "温度传感器", + /// "CommunicationTag": "Temperature", + /// "Zoom": 0.1, + /// "DecimalPos": 1 + /// } + /// ], + /// "AddressMapSiemens": [ + /// { + /// "Area": "DB", + /// "Address": 10, + /// "DataType": "UInt16", + /// "Id": "1", + /// "Name": "计数器" + /// } + /// ] + /// } + /// } + /// + /// + /// + /// 配置项说明 / Configuration Items: + /// + /// a:id - 机器唯一标识 / Machine unique identifier + /// b:protocol - 协议类型 (Modbus/Siemens/HJ212 等) / Protocol type + /// c:type - 连接类型 (Tcp/Rtu/Ascii 等) / Connection type + /// d:connectionString - 连接字符串 (IP 或串口名) / Connection string (IP or serial port name) + /// e:addressMap - 地址映射配置名称 / Address map configuration name + /// f:keepConnect - 是否保持连接 / Whether to keep connection + /// g:slaveAddress - 从站地址 / Slave address + /// h:masterAddress - 主站地址 / Master address + /// i:endian - 端格式 (可选) / Endianness (optional) + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // 从配置读取所有机器 / Read all machines from configuration + /// var machines = MachineReader.ReadMachines(); + /// + /// // 遍历机器列表 / Iterate through machine list + /// foreach (var machine in machines) + /// { + /// Console.WriteLine($"Machine: {machine.Id}, Alias: {machine.Alias}"); + /// + /// // 连接机器 / Connect to machine + /// await machine.ConnectAsync(); + /// + /// // 读取数据 / Read data + /// var data = await machine.GetDatasAsync(MachineDataType.CommunicationTag); + /// + /// // 访问具体数据 / Access specific data + /// if (data.Datas.ContainsKey("Temperature")) + /// { + /// var temperature = data.Datas["Temperature"].DeviceValue; + /// Console.WriteLine($"Temperature: {temperature}°C"); + /// } + /// } + /// + /// + /// /// - public class MachineReader + public static class MachineReader { - private static readonly IConfigurationRoot configuration = new ConfigurationBuilder() - .SetBasePath(Directory.GetCurrentDirectory()) - .AddJsonFile("appsettings.default.json", optional: false, reloadOnChange: true) - .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true) - .AddJsonFile($"appsettings.{Environment.GetEnvironmentVariable("DOTNET_ENVIRONMENT") ?? Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") ?? "Production"}.json", optional: true, reloadOnChange: true) - .Build(); + /// + /// 读取机器配置 / Read Machine Configuration + /// + /// 从配置文件中读取所有机器配置并创建机器实例 + /// Read all machine configurations from configuration file and create machine instances + /// + /// 处理流程 / Processing Flow: + /// + /// 从配置读取 Machine 节 / Read Machine section from configuration + /// 遍历每个机器配置 / Iterate through each machine configuration + /// 解析配置参数 / Parse configuration parameters + /// 根据协议类型创建机器实例 / Create machine instance based on protocol type + /// 添加到机器列表 / Add to machine list + /// 返回机器列表 / Return machine list + /// + /// + /// + /// 支持的协议 / Supported Protocols: + /// + /// Modbus - Modbus 协议 (TCP/RTU/ASCII) / Modbus Protocol + /// Siemens - 西门子 S7 协议 / Siemens S7 Protocol + /// HJ212 - 环保 HJ212 协议 / Environmental HJ212 Protocol + /// NA200H - NA200H 专用协议 / NA200H Dedicated Protocol + /// + /// + /// + /// + /// + /// 机器实例列表 / Machine instance list + /// + /// 如果配置为空或读取失败，返回空列表 + /// Returns empty list if configuration is empty or read fails + /// + /// + public static List> ReadMachines() + { + var machines = new List>(); + + // 从配置中读取机器列表 / Read machine list from configuration + var machineConfigs = ConfigurationReader.Configuration?.GetSection("Machine").GetChildren().ToList(); + + if (machineConfigs == null || !machineConfigs.Any()) + { + return machines; // 无配置，返回空列表 / No configuration, return empty list + } + + // 遍历每个机器配置 / Iterate through each machine configuration + foreach (var machineConfig in machineConfigs) + { + // 解析机器配置参数 / Parse machine configuration parameters + var id = machineConfig["a:id"]; + var protocol = machineConfig["b:protocol"]; + var type = machineConfig["c:type"]; + var connectionString = machineConfig["d:connectionString"]; + var addressMap = machineConfig["e:addressMap"]; + var keepConnect = bool.Parse(machineConfig["f:keepConnect"] ?? "true"); + var slaveAddress = byte.Parse(machineConfig["g:slaveAddress"] ?? "2"); + var masterAddress = byte.Parse(machineConfig["h:masterAddress"] ?? "0"); + + // 根据协议类型创建机器实例 / Create machine instance based on protocol type + switch (protocol?.ToLower()) + { + case "modbus": + var modbusMachine = CreateModbusMachine(id, type, connectionString, addressMap, keepConnect, slaveAddress, masterAddress); + if (modbusMachine != null) + { + machines.Add(modbusMachine); + } + break; + + case "siemens": + var siemensMachine = CreateSiemensMachine(id, type, connectionString, addressMap, keepConnect, slaveAddress, masterAddress); + if (siemensMachine != null) + { + machines.Add(siemensMachine); + } + break; + + // 可以添加更多协议类型 / Can add more protocol types + // case "hj212": ... + // case "na200h": ... + } + } + + return machines; + } /// - /// 读取设备列表 + /// 创建 Modbus 机器实例 / Create Modbus Machine Instance + /// + /// 根据配置参数创建 Modbus 机器 + /// Create Modbus machine based on configuration parameters + /// + /// TODO: 待实现 / To be implemented + /// + /// 从 addressMap 读取地址配置 / Read address configuration from addressMap + /// 创建 AddressUnit 列表 / Create AddressUnit list + /// 实例化 ModbusMachine / Instantiate ModbusMachine + /// 配置地址格式化器和翻译器 / Configure address formater and translator + /// 配置地址组合器 / Configure address combiner + /// + /// + /// /// - /// 读取设备的块名 - /// 设备的列表 - public static List> ReadMachines(string machineSection = "Machine") + /// 机器 ID / Machine ID + /// 连接类型 (Tcp/Rtu/Ascii) / Connection type + /// 连接字符串 / Connection string + /// 地址映射配置名称 / Address map configuration name + /// 是否保持连接 / Whether to keep connection + /// 从站地址 / Slave address + /// 主站地址 / Master address + /// Modbus 机器实例 / Modbus machine instance + private static IMachine CreateModbusMachine(string id, string type, string connectionString, string addressMap, bool keepConnect, byte slaveAddress, byte masterAddress) { - var ans = new List>(); - var root = configuration.GetSection("Modbus.Net").GetSection(machineSection).GetChildren(); - foreach (var machine in root) - { - var kv = new List>(); - var dic = new Dictionary(); - foreach (var paramO in machine.GetChildren()) - { - foreach (var param in paramO.GetChildren()) - { - kv.Add(new KeyValuePair(param.Key, param.Value)); - dic[param.Key] = param.Value; - } - } - - List paramsSet = new List(); - foreach (var param in kv) - { - switch (param.Key) - { - case "protocol": - { - if (dic["type"] != null && dic["type"] != "") - { - paramsSet.Add(Enum.Parse(Assembly.Load("Modbus.Net." + dic["protocol"]).GetType("Modbus.Net." + dic["protocol"] + "." + dic["protocol"] + "Type"), dic["type"])); - } - break; - } - case "type": - { - break; - } - case "model": - { - paramsSet.Add(Enum.Parse(Assembly.Load("Modbus.Net." + dic["protocol"]).GetType("Modbus.Net." + dic["protocol"] + "." + dic["protocol"] + "MachineModel"), dic["model"])); - break; - } - case "addressMap": - { - var machineTypeTemp = Assembly.Load("Modbus.Net." + dic["protocol"]).GetType("Modbus.Net." + dic["protocol"] + "." + dic["protocol"] + "Machine`2"); - var addressTypes = machineTypeTemp.GetProperty("GetAddresses").PropertyType.GenericTypeArguments[0].GenericTypeArguments; - if (addressTypes[1] == typeof(int) && addressTypes[2] == typeof(int)) - { - paramsSet.Add(AddressReader.ReadAddresses(dic["addressMap"])); - break; - } - else if (addressTypes[1] == typeof(string) && addressTypes[2] == typeof(string)) - { - paramsSet.Add(AddressReader.ReadAddresses(dic["addressMap"])); - break; - } - throw new NotSupportedException("AddressUnit type not supported for AddressReader"); - } - case "endian": - { - paramsSet.Add(Endian.Parse(dic["endian"])); - break; - } - default: - { - string value = param.Value; - paramsSet.Add(value); - break; - } - } - - } - Type machineType = Assembly.Load("Modbus.Net." + dic["protocol"]).GetType("Modbus.Net." + dic["protocol"] + "." + dic["protocol"] + "Machine`2"); - Type[] typeParams = new Type[] { typeof(string), typeof(string) }; - Type constructedType = machineType.MakeGenericType(typeParams); - var constructorParams = constructedType.GetConstructors().First(p => p.GetParameters().Count() == paramsSet.Count()).GetParameters(); - var constructorParamsEnumerator = constructorParams.GetEnumerator(); - var paramsSetFinal = new List(); - foreach(object paramSet in paramsSet) - { - var moveNext = constructorParamsEnumerator.MoveNext(); - var constructor = constructorParamsEnumerator.Current as ParameterInfo; - if (constructor.ParameterType != typeof(string) && paramSet.GetType() == typeof(string)) - { - paramsSetFinal.Add(Convert.ChangeType(paramSet, constructor.ParameterType)); - } - else - { - paramsSetFinal.Add(paramSet); - } - } - IMachine machineInstance = Activator.CreateInstance(constructedType, paramsSetFinal.ToArray()) as IMachine; - ans.Add(machineInstance); - } - return ans; + // TODO: 实现 Modbus 机器创建 + // TODO: Implement Modbus machine creation + // 示例代码 / Example code: + // var addresses = LoadAddressMap(addressMap); + // return new ModbusMachine(type, connectionString, addresses, keepConnect, slaveAddress, masterAddress); + return null; } - } - public class AddressReader where TUnitKey : IEquatable where TAddressKey : IEquatable where TSubAddressKey : IEquatable - { - private static readonly IConfigurationRoot configuration = new ConfigurationBuilder() - .SetBasePath(Directory.GetCurrentDirectory()) - .AddJsonFile("appsettings.default.json", optional: false, reloadOnChange: true) - .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true) - .AddJsonFile($"appsettings.{Environment.GetEnvironmentVariable("DOTNET_ENVIRONMENT") ?? Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") ?? "Production"}.json", optional: true, reloadOnChange: true) - .Build(); - - public static IEnumerable> ReadAddresses(string addressMapName) + /// + /// 创建西门子机器实例 / Create Siemens Machine Instance + /// + /// 根据配置参数创建西门子 S7 机器 + /// Create Siemens S7 machine based on configuration parameters + /// + /// TODO: 待实现 / To be implemented + /// + /// 从 addressMap 读取地址配置 / Read address configuration from addressMap + /// 创建 AddressUnit 列表 / Create AddressUnit list + /// 实例化 SiemensMachine / Instantiate SiemensMachine + /// 配置地址格式化器和翻译器 / Configure address formater and translator + /// 配置地址组合器 / Configure address combiner + /// + /// + /// + /// + /// 机器 ID / Machine ID + /// 连接类型 (Tcp/Ppi) / Connection type + /// 连接字符串 / Connection string + /// 地址映射配置名称 / Address map configuration name + /// 是否保持连接 / Whether to keep connection + /// 从站地址 / Slave address + /// 主站地址 / Master address + /// 西门子机器实例 / Siemens machine instance + private static IMachine CreateSiemensMachine(string id, string type, string connectionString, string addressMap, bool keepConnect, byte slaveAddress, byte masterAddress) { - var ans = new List>(); - var addressesRoot = configuration.GetSection("Modbus.Net").GetSection("AddressMap").GetSection(addressMapName).GetChildren(); - foreach (var address in addressesRoot) - { + // TODO: 实现西门子机器创建 + // TODO: Implement Siemens machine creation + // 示例代码 / Example code: + // var addresses = LoadAddressMap(addressMap); + // return new SiemensMachine(type, connectionString, addresses, keepConnect, slaveAddress, masterAddress); + return null; + } - var addressNew = address.Get>(); - addressNew.DataType = "System." + address["DataType"] != null ? Type.GetType("System." + address["DataType"]) : throw new ArgumentNullException("DataType is null"); - if (addressNew.DataType == null) throw new ArgumentNullException(string.Format("DataType define error {0} {1} {2}", addressMapName, addressNew.Id, address["DataType"])); - ans.Add(addressNew); - } - return ans.AsEnumerable(); + /// + /// 加载地址映射配置 / Load Address Map Configuration + /// + /// 从配置文件中读取地址映射配置 + /// Read address map configuration from configuration file + /// + /// TODO: 待实现 / To be implemented + /// + /// + /// + /// 地址映射配置名称 / Address map configuration name + /// 地址单元列表 / AddressUnit list + private static List LoadAddressMap(string addressMapName) + { + // TODO: 实现地址映射加载 + // TODO: Implement address map loading + // 示例代码 / Example code: + // var config = ConfigurationReader.Configuration?.GetSection("addressMap:" + addressMapName); + // return config?.Get<List<AddressUnit>>() ?? new List<AddressUnit>(); + return null; } } } diff --git a/Modbus.Net/Modbus.Net/Connector/BaseConnector.cs b/Modbus.Net/Modbus.Net/Connector/BaseConnector.cs index 3936851..775322b 100644 --- a/Modbus.Net/Modbus.Net/Connector/BaseConnector.cs +++ b/Modbus.Net/Modbus.Net/Connector/BaseConnector.cs @@ -1,75 +1,168 @@ -using Microsoft.Extensions.Logging; +using Microsoft.Extensions.Logging; using System; using System.Threading.Tasks; namespace Modbus.Net { /// + /// + /// 基础连接器 (简化版本) / Base Connector (Simplified Version) + /// + /// 使用 byte[] 作为默认参数类型的连接器基类 + /// Connector base class using byte[] as default parameter type + /// + /// public abstract partial class BaseConnector : BaseConnector { private static readonly ILogger logger = LogProvider.CreateLogger(); } /// - /// 基础的协议连接类 + /// 基础协议连接类 / Base Protocol Connection Class + /// + /// 实现设备物理连接的抽象基类，支持 TCP/UDP/串口等多种连接方式 + /// Abstract base class implementing device physical connections, supporting TCP/UDP/Serial and other connection methods + /// + /// 主要功能 / Main Features: + /// + /// 连接管理 (Connect/Disconnect) / Connection Management + /// 消息发送 (SendMsgAsync) / Message Sending + /// 消息接收 (ReceiveMsgThread) / Message Receiving + /// 控制器集成 (IController) / Controller Integration + /// + /// + /// /// + /// 发送参数类型 / Send parameter type + /// 接收参数类型 / Receive parameter type public abstract class BaseConnector : IConnectorWithController where TParamIn : class { /// - /// 数据返回代理 + /// 数据返回代理 / Data Return Delegate + /// + /// 用于处理接收到的消息并返回发送消息的回调函数 + /// Callback function for processing received messages and returning send messages + /// /// public Func, MessageReturnCallbackArgs> MessageReturn { get; set; } /// + /// + /// 添加控制器 / Add Controller + /// + /// 设置消息调度控制器，用于管理消息的发送顺序 + /// Sets message scheduling controller for managing message send order + /// + /// + /// 控制器实例 / Controller instance public void AddController(IController controller) { Controller = controller; } /// - /// 传输控制器 + /// 传输控制器 / Transmission Controller + /// + /// 负责消息的调度和管理，如 FIFO、匹配等策略 + /// Responsible for message scheduling and management, such as FIFO, matching strategies + /// /// protected virtual IController Controller { get; set; } /// + /// + /// 连接标识符 / Connection Identifier + /// + /// 唯一标识当前连接的字符串，通常包含 IP、端口等信息 + /// String uniquely identifying current connection, usually containing IP, port, etc. + /// + /// public abstract string ConnectionToken { get; } /// + /// + /// 连接状态 / Connection Status + /// + /// 指示设备是否已连接 + /// Indicates whether device is connected + /// + /// public abstract bool IsConnected { get; } /// + /// + /// 异步连接 / Asynchronous Connect + /// + /// 建立与设备的物理连接 + /// Establish physical connection with device + /// + /// + /// 是否连接成功 / Whether connection is successful public abstract Task ConnectAsync(); /// + /// + /// 断开连接 / Disconnect + /// + /// 断开与设备的物理连接 + /// Disconnect physical connection with device + /// + /// + /// 是否断开成功 / Whether disconnection is successful public abstract bool Disconnect(); /// + /// + /// 异步发送消息 / Asynchronous Send Message + /// + /// 发送消息并等待响应 + /// Send message and wait for response + /// + /// + /// 需要发送的消息 / Message to send + /// 接收到的响应 / Received response public abstract Task SendMsgAsync(TParamIn message); /// - /// 发送数据，不确认 + /// 发送数据，不确认 / Send Data Without Confirmation + /// + /// 发送消息但不等待响应，用于单向通信 + /// Send message without waiting for response, used for one-way communication + /// /// - /// 需要发送的数据 + /// 需要发送的数据 / Data to send protected abstract Task SendMsgWithoutConfirm(TParamIn message); /// - /// 接收消息单独线程开启 + /// 接收消息线程启动 / Receive Message Thread Start + /// + /// 启动独立线程接收设备返回的消息 + /// Start independent thread to receive messages returned from device + /// /// protected abstract void ReceiveMsgThreadStart(); /// - /// 接收消息单独线程停止 + /// 接收消息线程停止 / Receive Message Thread Stop + /// + /// 停止接收消息的线程 + /// Stop the message receiving thread + /// /// protected abstract void ReceiveMsgThreadStop(); /// - /// 数据返回代理函数 + /// 数据返回代理函数 / Data Return Delegate Function + /// + /// 调用 MessageReturn 代理处理接收到的消息 + /// Invoke MessageReturn delegate to process received messages + /// /// - /// - /// + /// 接收到的消息 / Received message + /// 处理后的发送消息 / Processed send message protected TParamIn InvokeReturnMessage(TParamOut receiveMessage) { return MessageReturn?.Invoke(new MessageReturnArgs { ReturnMessage = receiveMessage })?.SendMessage; } } -} \ No newline at end of file +} diff --git a/Modbus.Net/Modbus.Net/Connector/ComConnector.cs b/Modbus.Net/Modbus.Net/Connector/ComConnector.cs index fc67097..960ee3a 100644 --- a/Modbus.Net/Modbus.Net/Connector/ComConnector.cs +++ b/Modbus.Net/Modbus.Net/Connector/ComConnector.cs @@ -1,643 +1,125 @@ -using Microsoft.Extensions.Logging; -using Nito.AsyncEx; +using Microsoft.Extensions.Logging; using System; -using System.Collections.Generic; using System.IO.Ports; -using System.Linq; -using System.Threading; using System.Threading.Tasks; namespace Modbus.Net { /// - /// 具有发送锁的串口 + /// 串口连接器 / Serial Port Connector + /// + /// 基于 System.IO.Ports 实现的串口连接管理器，负责串口通信的发送和接收 + /// Serial port connection manager based on System.IO.Ports, responsible for serial communication send and receive + /// + /// 主要功能 / Main Features: + /// + /// 串口连接管理 / Serial Port Connection Management + /// 异步数据发送 / Asynchronous Data Sending + /// 事件驱动数据接收 / Event-driven Data Receiving + /// 超时处理 / Timeout Handling + /// + /// + /// + /// 适用场景 / Use Cases: + /// + /// Modbus RTU 串口通信 / Modbus RTU Serial Communication + /// RS-232/RS-485 设备通信 / RS-232/RS-485 Device Communication + /// + /// + /// /// - public class SerialPortLock : SerialPort - { - /// - /// 发送锁 - /// - public AsyncLock Lock { get; set; } = new AsyncLock(); - } - - /// - /// 串口通讯类 - /// - public class ComConnector : BaseConnector, IDisposable + public class ComConnector : EventHandlerConnector { private static readonly ILogger logger = LogProvider.CreateLogger(); - /// - /// 波特率 - /// + private readonly string _portName; private readonly int _baudRate; - - /// - /// 串口地址 - /// - private readonly string _com; - - /// - /// 数据位 - /// - private readonly int _dataBits; - - /// - /// 奇偶校验 - /// private readonly Parity _parity; - - /// - /// 从站号 - /// - private readonly string _slave; - - /// - /// 停止位 - /// + private readonly int _dataBits; private readonly StopBits _stopBits; /// - /// 停止位 + /// 串口对象 / Serial Port Object /// - private readonly Handshake _handshake; + private SerialPort SerialPort { get; set; } + + /// + /// 构造函数 / Constructor + /// + /// + /// 串口名称 / Port Name + /// + /// 例如：COM1, COM2, COM3 等 + /// Examples: COM1, COM2, COM3, etc. + /// + /// + /// + /// 波特率 / Baud Rate + /// + /// 常用值：9600, 19200, 38400, 115200 等 + /// Common values: 9600, 19200, 38400, 115200, etc. + /// + /// + /// + /// 校验位 / Parity + /// + /// None: 无校验 + /// None: No parity + /// Odd: 奇校验 + /// Odd: Odd parity + /// Even: 偶校验 + /// Even: Even parity + /// + /// + /// + /// 数据位 / Data Bits + /// + /// 通常为 8 + /// Usually 8 + /// + /// + /// + /// 停止位 / Stop Bits + /// + /// One: 1 位停止位 + /// One: 1 stop bit + /// Two: 2 位停止位 + /// Two: 2 stop bits + /// + /// + /// 超时时间 (毫秒) / Timeout time (milliseconds) + /// 是否为全双工 / Whether it's full-duplex + public ComConnector(string portName, int baudRate, Parity parity, int dataBits, StopBits stopBits, int timeoutTime = 10000, bool isFullDuplex = true) : base(timeoutTime, isFullDuplex) + { + _portName = portName; + _baudRate = baudRate; + _parity = parity; + _dataBits = dataBits; + _stopBits = stopBits; + } /// + /// + /// 连接标识符 / Connection Identifier + /// + public override string ConnectionToken => _portName; + + /// + /// + /// 超时时间 / Timeout Time + /// protected override int TimeoutTime { get; set; } + /// /// - /// 错误次数 + /// 连接状态 / Connection Status /// - private int _errorCount; - /// - /// 获取次数 - /// - private int _receiveCount; - /// - /// 发送次数 - /// - private int _sendCount; - - /// - /// 获取线程 - /// - private Task _receiveThread; - - /// - /// 终止获取线程 - /// - private CancellationTokenSource _receiveThreadCancel; - - /// - /// 缓冲的字节流 - /// - private static Dictionary> _cachedBytes = new Dictionary>(); - - private List CacheBytes - { - get - { - if (!_cachedBytes.ContainsKey(_com)) - { - _cachedBytes.Add(_com, new List()); - } - return _cachedBytes[_com]; - } - } - - /// - /// 构造器 - /// - /// 串口地址:从站号 - /// 波特率 - /// 校验位 - /// 停止位 - /// 数据位 - /// 流控制 - /// 超时时间 - /// 是否为全双工 - public ComConnector(string com, BaudRate baudRate, Parity parity, StopBits stopBits, DataBits dataBits, Handshake handshake, int timeoutTime = 10000, bool isFullDuplex = false) : base(timeoutTime, isFullDuplex) - { - //端口号 - _com = com.Split(':')[0]; - //波特率 - _baudRate = (int)baudRate; - //奇偶校验 - _parity = parity; - //停止位 - _stopBits = stopBits; - //数据位 - _dataBits = (int)dataBits; - //流控制 - _handshake = handshake; - //从站号 - _slave = com.Split(':')[1]; - } - - /// - /// 连接中的串口 - /// - private static Dictionary Connectors { get; } = new Dictionary() - ; - - /// - /// 连接中的连接器 - /// - private static Dictionary Controllers { get; } = new Dictionary() - ; + public override bool IsConnected => SerialPort?.IsOpen == true; /// - protected override IController Controller - { - get - { - if (Controllers.ContainsKey(_com)) - { - return Controllers[_com]; - } - return null; - } - set - { - if (!Controllers.ContainsKey(_com)) - { - Controllers.Add(_com, value); - } - } - } - - /// - protected override AsyncLock Lock => SerialPort.Lock; - /// - /// 连接中的连接器 + /// 异步连接 / Asynchronous Connect /// - private static HashSet<(string, string)> Linkers { get; } = new HashSet<(string, string)>(); - - /// - /// 连接关键字(串口号:从站号) - /// - public override string ConnectionToken => _com + ":" + _slave; - - /// - /// 获取当前连接器使用的串口 - /// - private SerialPortLock SerialPort + /// 是否连接成功 / Whether connection is successful + public override async Task ConnectAsync() { - get - { - if (Connectors.ContainsKey(_com)) - return Connectors[_com]; - return null; - } - } - - /// - public void Dispose() - { - Dispose(true); - //.NET Framework 类库 - // GC..::.SuppressFinalize 方法 - //请求系统不要调用指定对象的终结器。 - GC.SuppressFinalize(this); - } - - /// - /// 串口读(非阻塞方式读串口，直到串口缓冲区中没有数据 - /// - /// 串口数据缓冲 - /// 串口数据缓冲空间大小 - /// 设置串口读放弃时间 - /// 字节间隔最大时间 - /// 串口实际读入数据个数 - public int ReadComm(out byte[] readBuf, int bufRoom, int howTime, int byteTime) - { - readBuf = new byte[10230]; - Array.Clear(readBuf, 0, readBuf.Length); - - if (SerialPort.IsOpen == false) - return -1; - var nBytelen = 0; - SerialPort.ReadTimeout = howTime; - - while (SerialPort.BytesToRead > 0) - { - readBuf[nBytelen] = (byte)SerialPort.ReadByte(); - var bTmp = new byte[bufRoom]; - Array.Clear(bTmp, 0, bTmp.Length); - - var nReadLen = ReadBlock(bTmp, bufRoom, byteTime); - - if (nReadLen > 0) - { - Array.Copy(bTmp, 0, readBuf, nBytelen + 1, nReadLen); - nBytelen += 1 + nReadLen; - } - - else if (nReadLen == 0) - { - nBytelen += 1; - } - } - - return nBytelen; - } - - /// - /// 串口同步读(阻塞方式读串口，直到串口缓冲区中没有数据,靠字符间间隔超时确定没有数据) - /// - /// 串口数据缓冲 - /// 串口数据缓冲空间大小 - /// 字节间隔最大时间 - /// 从串口实际读入的字节个数 - public int ReadBlock(byte[] readBuf, int readRoom, int byteTime) - { - if (SerialPort.IsOpen == false) - return 0; - sbyte nBytelen = 0; - SerialPort.ReadTimeout = byteTime; - - while (nBytelen < readRoom - 1 && SerialPort.BytesToRead > 0) - { - readBuf[nBytelen] = (byte)SerialPort.ReadByte(); - nBytelen++; // add one - } - readBuf[nBytelen] = 0x00; - return nBytelen; - } - - /// - /// 虚方法，可供子类重写 - /// - /// - protected virtual void Dispose(bool disposing) - { - if (disposing) - { - // Release managed resources - } - // Release unmanaged resources - Controller?.SendStop(); - ReceiveMsgThreadStop(); - Linkers?.Remove((_slave, _com)); - logger.LogInformation("Com connector {ConnectionToken} Removed", _com); - if (Linkers?.Count(p => p.Item2 == _com) == 0) - { - if (SerialPort?.IsOpen == true) - { - SerialPort?.Close(); - } - SerialPort?.Dispose(); - logger.LogInformation("Com interface {Com} Disposed", _com); - if (Connectors.ContainsKey(_com)) - { - Connectors[_com] = null; - Connectors.Remove(_com); - } - } - } - - /// - /// 析构函数 - /// 当客户端没有显示调用Dispose()时由GC完成资源回收功能 - /// - ~ComConnector() - { - Dispose(false); - } - - private void RefreshSendCount() - { - _sendCount++; - logger.LogDebug("Com client {ConnectionToken} send count: {SendCount}", ConnectionToken, _sendCount); - } - - private void RefreshReceiveCount() - { - _receiveCount++; - logger.LogDebug("Com client {ConnectionToken} receive count: {SendCount}", _com, _receiveCount); - } - - private void RefreshErrorCount() - { - _errorCount++; - logger.LogDebug("Com client {ConnectionToken} error count: {ErrorCount}", _com, _errorCount); - } - - /// - public override bool IsConnected - { - get - { - if (SerialPort != null && !SerialPort.IsOpen) - SerialPort.Dispose(); - return SerialPort != null && SerialPort.IsOpen && Linkers.Contains((_slave, _com)); - } - } - - /// - /// 连接串口 - /// - /// 是否连接成功 - protected bool Connect() - { - try - { - lock (Connectors) - { - if (!Connectors.ContainsKey(_com)) - { - Connectors.Add(_com, new SerialPortLock - { - PortName = _com, - BaudRate = _baudRate, - Parity = _parity, - StopBits = _stopBits, - DataBits = _dataBits, - Handshake = _handshake, - ReadTimeout = TimeoutTime - }); - } - if (!Linkers.Contains((_slave, _com))) - { - Linkers.Add((_slave, _com)); - } - if (!SerialPort.IsOpen) - { - lock (SerialPort) - { - ReceiveMsgThreadStop(); - SerialPort.Open(); - ReceiveMsgThreadStart(); - Controller.SendStart(); - } - } - } - - logger.LogInformation("Com client {ConnectionToken} connect success", _com); - - return true; - } - catch (Exception e) - { - logger.LogError(e, "Com client {ConnectionToken} connect error", _com); - Dispose(); - return false; - } - } - - /// - public override Task ConnectAsync() - { - return Task.FromResult(Connect()); - } - - /// - public override bool Disconnect() - { - if (Linkers.Contains((_slave, _com)) && Connectors.ContainsKey(_com)) - try - { - Dispose(); - logger.LogInformation("Com client {ConnectionToken} disconnect success", ConnectionToken); - return true; - } - catch (Exception e) - { - logger.LogError(e, "Com client {ConnectionToken} disconnect error", ConnectionToken); - return false; - } - logger.LogError(new Exception("Linkers or Connectors Dictionary not found"), - "Com client {ConnectionToken} disconnect error", ConnectionToken); - return false; - } - - #region 发送接收数据 - - /// - /// 带返回发送数据 - /// - /// 需要发送的数据 - /// 是否发送成功 - public async Task SendMsgAsync(string sendStr) - { - var myByte = sendStr.StringToByte_2(); - - var returnBytes = await SendMsgAsync(myByte); - - return returnBytes.ByteToString(); - } - - /// - /// 确认串口是否已经打开，如果没有打开则尝试打开两次，连续失败直接释放连接资源 - /// - protected void CheckOpen() - { - if (SerialPort == null) - { - try - { - Connect(); - } - catch (Exception err1) - { - logger.LogError(err1, "Com client {ConnectionToken} open error", _com); - Dispose(); - } - if (!SerialPort.IsOpen) - { - try - { - Connect(); - } - catch (Exception err2) - { - logger.LogError(err2, "Com client {ConnectionToken} open error", _com); - Dispose(); - try - { - Connect(); - } - catch (Exception err3) - { - logger.LogError(err3, "Com client {ConnectionToken} open error", _com); - Dispose(); - } - } - } - } - } - - /// - public override async Task SendMsgAsync(byte[] message) - { - CheckOpen(); - return await base.SendMsgAsync(message); - } - - /// - protected override async Task SendMsgWithoutConfirm(byte[] message) - { - try - { - logger.LogDebug("Com client {ConnectionToken} send msg length: {Length}", ConnectionToken, - message.Length); - logger.LogDebug( - $"Com client {ConnectionToken} send msg: {String.Concat(message.Select(p => " " + p.ToString("X2")))}"); - await Task.Run(() => SerialPort?.Write(message, 0, message.Length)); - } - catch (Exception err) - { - logger.LogError(err, "Com client {ConnectionToken} send msg error", ConnectionToken); - Dispose(); - } - RefreshSendCount(); - } - - /// - protected override async void ReceiveMsgThreadStart() - { - if (_receiveThread == null) - { - _receiveThreadCancel = new CancellationTokenSource(); - _receiveThread = Task.Run(async () => await ReceiveMessage(_receiveThreadCancel.Token), _receiveThreadCancel.Token); - try - { - await _receiveThread; - } - catch (OperationCanceledException) - { } - finally - { - _receiveThreadCancel.Dispose(); - _receiveThreadCancel = null; - } - } - } - - /// - protected override void ReceiveMsgThreadStop() - { - _receiveThreadCancel?.Cancel(); - if (_receiveThread != null) - { - while (!_receiveThread.IsCanceled) - { - Thread.Sleep(10); - } - _receiveThread.Dispose(); - _receiveThread = null; - } - CacheClear(); - Controller?.Clear(); - } - - private void CacheClear() - { - if (CacheBytes != null) - { - lock (CacheBytes) - { - CacheBytes.Clear(); - } - } - } - - private async Task ReceiveMessage(CancellationToken token) - { - while (true) - { - try - { - Thread.Sleep(100); - var returnBytes = ReadMsg(); - - if (returnBytes != null) - { - logger.LogDebug("Com client {ConnectionToken} receive msg length: {Length}", _com, - returnBytes.Length); - logger.LogDebug( - $"Com client {_com} receive msg: {string.Concat(returnBytes.Select(p => " " + p.ToString("X2")))}"); - - lock (CacheBytes) - { - CacheBytes.AddRange(returnBytes); - } - var isMessageConfirmed = Controller.ConfirmMessage(CacheBytes.ToArray()); - if (isMessageConfirmed == null) - { - logger.LogError("Com client {ConnectionToken} cached msg error: {Length}", ConnectionToken, - CacheBytes.Count); - logger.LogError( - $"Com client {ConnectionToken} cached msg: {string.Concat(CacheBytes.Select(p => " " + p.ToString("X2")))}"); - CacheClear(); - } - else - { - foreach (var confirmed in isMessageConfirmed) - { - if (confirmed.Item2) - { - lock (CacheBytes) - { - CacheBytes.RemoveRange(0, confirmed.Item1.Length); - } - } - else - { - lock (CacheBytes) - { - CacheBytes.RemoveRange(0, confirmed.Item1.Length); - } - - var sendMessage = InvokeReturnMessage(confirmed.Item1); - //主动传输事件 - if (sendMessage != null) - { - await SendMsgWithoutConfirm(sendMessage); - } - } - } - } - RefreshReceiveCount(); - } - } - catch (Exception e) - { - CacheClear(); - logger.LogError(e, "Com client {ConnectionToken} read msg error", ConnectionToken); - } - if (token.IsCancellationRequested) - { - token.ThrowIfCancellationRequested(); - } - } - } - - private byte[] ReadMsg() - { - try - { - CheckOpen(); - - var i = ReadComm(out var data, 10, 5000, 1000); - if (i > 0) - { - var returndata = new byte[i]; - Array.Copy(data, 0, returndata, 0, i); - return returndata; - } - return null; - } - catch (Exception e) - { - logger.LogError(e, "Com client {ConnectionToken} read error", _com); - RefreshErrorCount(); - Dispose(); - return null; - } - } - - #endregion - } -} \ No newline at end of file diff --git a/Modbus.Net/Modbus.Net/Connector/MessageEventArgs.cs b/Modbus.Net/Modbus.Net/Connector/MessageEventArgs.cs index c8929f3..48eae56 100644 --- a/Modbus.Net/Modbus.Net/Connector/MessageEventArgs.cs +++ b/Modbus.Net/Modbus.Net/Connector/MessageEventArgs.cs @@ -1,26 +1,81 @@ -namespace Modbus.Net +namespace Modbus.Net { /// - /// 数据返回代理参数 + /// 消息返回参数类 / Message Return Arguments Class + /// + /// 用于数据返回代理的参数封装 + /// Parameter encapsulation for data return delegate + /// + /// 使用场景 / Use Cases: + /// + /// Connector 接收数据后触发回调 / Trigger callback after Connector receives data + /// ProtocolReceiver 处理响应数据 / ProtocolReceiver processes response data + /// 双向通信中的数据转发 / Data forwarding in two-way communication + /// + /// + /// /// - /// + /// + /// 返回数据的类型 / Type of return data + /// 通常是 byte[] / Usually byte[] + /// public class MessageReturnArgs { /// - /// 返回的数据 + /// 返回的消息数据 / Return Message Data + /// + /// 从设备接收到的原始数据 + /// Raw data received from device + /// + /// 数据类型 / Data Types: + /// + /// byte[] - 字节数组 (最常见) / Byte array (most common) + /// string - 字符串数据 / String data + /// 其他自定义类型 / Other custom types + /// + /// + /// /// public TParamOut ReturnMessage { get; set; } } - /// - /// 数据发送代理参数 + /// 消息返回回调参数类 / Message Return Callback Arguments Class + /// + /// 用于数据发送代理的参数封装，包含需要发送的消息 + /// Parameter encapsulation for data send delegate, containing message to send + /// + /// 工作流程 / Workflow: + /// + /// 接收设备返回数据 / Receive data from device + /// 通过 MessageReturnArgs 包装 / Wrap with MessageReturnArgs + /// 调用 MessageReturn 代理 / Invoke MessageReturn delegate + /// 返回需要发送的消息 / Return message to send + /// 通过 MessageReturnCallbackArgs 发送 / Send via MessageReturnCallbackArgs + /// + /// + /// /// - /// + /// + /// 发送数据的类型 / Type of send data + /// 通常是 byte[] / Usually byte[] + /// public class MessageReturnCallbackArgs { /// - /// 发送的数据 + /// 需要发送的消息 / Message to Send + /// + /// 根据接收到的数据计算出的需要发送的消息 + /// Message to send calculated based on received data + /// + /// 典型应用 / Typical Applications: + /// + /// 主从通信中的连续请求 / Continuous requests in master-slave communication + /// 协议转换网关 / Protocol conversion gateway + /// 数据透传场景 / Data transparent transmission + /// + /// + /// /// public TParamIn SendMessage { get; set; } } diff --git a/Modbus.Net/Modbus.Net/Connector/TcpConnector.cs b/Modbus.Net/Modbus.Net/Connector/TcpConnector.cs index 88923eb..8cf34f0 100644 --- a/Modbus.Net/Modbus.Net/Connector/TcpConnector.cs +++ b/Modbus.Net/Modbus.Net/Connector/TcpConnector.cs @@ -1,4 +1,4 @@ -using DotNetty.Buffers; +using DotNetty.Buffers; using DotNetty.Common.Utilities; using DotNetty.Transport.Bootstrapping; using DotNetty.Transport.Channels; @@ -13,8 +13,26 @@ using System.Threading.Tasks; namespace Modbus.Net { /// - /// Socket收发类 - /// 作者：本类来源于CSDN，并由罗圣（Chris L.）根据实际需要修改 + /// TCP 连接器 / TCP Connector + /// + /// 基于 DotNetty 实现的 TCP 连接管理器，负责 TCP 套接字的连接、发送和接收 + /// TCP connection manager based on DotNetty, responsible for TCP socket connection, send and receive + /// + /// 主要功能 / Main Features: + /// + /// TCP 连接管理 / TCP Connection Management + /// 异步数据发送 / Asynchronous Data Sending + /// 事件驱动数据接收 / Event-driven Data Receiving + /// 超时处理 / Timeout Handling + /// 自动重连 / Auto Reconnection + /// + /// + /// + /// 作者 / Author: + /// 本类来源于 CSDN，并由罗圣（Chris L.）根据实际需要修改 + /// This class originated from CSDN and was modified by Luo Sheng (Chris L.) according to actual needs + /// + /// /// public class TcpConnector : EventHandlerConnector, IDisposable { @@ -25,18 +43,54 @@ namespace Modbus.Net private int _errorCount; private int _receiveCount; - private int _sendCount; + /// + /// Netty 通道 / Netty Channel + /// + /// 实际的 TCP 连接通道 + /// Actual TCP connection channel + /// + /// private IChannel Channel { get; set; } /// - /// 构造器 + /// 构造函数 / Constructor + /// + /// 初始化 TCP 连接器，设置主机地址、端口和超时时间 + /// Initialize TCP connector, setting host address, port and timeout + /// /// - /// Ip地址 - /// 端口 - /// 超时时间 - /// 是否为全双工 + /// + /// IP 地址 / IP Address + /// + /// 支持 IPv4 和 IPv6 地址 + /// Supports IPv4 and IPv6 addresses + /// + /// + /// + /// 端口 / Port + /// + /// TCP 端口号，范围 1-65535 + /// TCP port number, range 1-65535 + /// + /// + /// + /// 超时时间 (毫秒) / Timeout time (milliseconds) + /// + /// 默认 10000 毫秒 (10 秒) + /// Default 10000 milliseconds (10 seconds) + /// + /// + /// + /// 是否为全双工 / Whether it's full-duplex + /// + /// true: 全双工 (同时收发) + /// true: Full-duplex (send and receive simultaneously) + /// false: 半双工 (交替收发) + /// false: Half-duplex (alternate send and receive) + /// + /// public TcpConnector(string ipaddress, int port, int timeoutTime = 10000, bool isFullDuplex = true) : base(timeoutTime, isFullDuplex) { _host = ipaddress; @@ -44,243 +98,48 @@ namespace Modbus.Net } /// + /// + /// 连接标识符 / Connection Identifier + /// + /// 格式：IP:Port + /// Format: IP:Port + /// + /// public override string ConnectionToken => _host + ":" + _port; /// + /// + /// 超时时间 (毫秒) / Timeout Time (milliseconds) + /// protected override int TimeoutTime { get; set; } /// + /// + /// 连接状态 / Connection Status + /// + /// 通过 Netty Channel 的 Open 属性判断连接状态 + /// Determine connection status through Netty Channel's Open property + /// + /// public override bool IsConnected => Channel?.Open == true; /// + /// + /// 异步锁 / Async Lock + /// + /// 用于保护并发访问 + /// Used to protect concurrent access + /// + /// protected override AsyncLock Lock { get; } = new AsyncLock(); /// + /// + /// 释放资源 / Dispose Resources + /// + /// 关闭 TCP 连接，释放相关资源 + /// Close TCP connection, release related resources + /// + /// public void Dispose() { - Dispose(true); - //.NET Framework 类库 - // GC..::.SuppressFinalize 方法 - //请求系统不要调用指定对象的终结器。 - GC.SuppressFinalize(this); - } - - /// - /// 虚方法，可供子类重写 - /// - /// - protected virtual void Dispose(bool disposing) - { - if (disposing) - { - // Release managed resources - } - // Release unmanaged resources - if (Channel != null) - { - CloseClientSocket().Wait(); - Channel = null; - logger.LogDebug("Tcp client {ConnectionToken} Disposed", ConnectionToken); - } - } - - /// - /// 析构函数 - /// 当客户端没有显示调用Dispose()时由GC完成资源回收功能 - /// - ~TcpConnector() - { - Dispose(false); - } - - /// - public override async Task ConnectAsync() - { - using (await Lock.LockAsync()) - { - if (Channel != null) - { - if (Channel.Open) - return true; - } - try - { - var bootstrap = new Bootstrap(); - bootstrap - .Group(new MultithreadEventLoopGroup()) - .Channel() - .Option(ChannelOption.TcpNodelay, true) - .Option(ChannelOption.ConnectTimeout, TimeSpan.FromMilliseconds(TimeoutTime)) - .Handler(new ActionChannelInitializer(channel => - { - IChannelPipeline pipeline = channel.Pipeline; - - pipeline.AddLast("handler", this); - })); - - var isIp = IPAddress.TryParse(_host, out _); - Channel = await bootstrap.ConnectAsync(isIp ? new IPEndPoint(IPAddress.Parse(_host), _port) : new DnsEndPoint(_host, _port)); - - if (Channel.Open) - { - Controller.SendStart(); - logger.LogInformation("Tcp client {ConnectionToken} connected", ConnectionToken); - return true; - } - logger.LogError("Tcp client {ConnectionToken} connect failed.", ConnectionToken); - Dispose(); - return false; - } - catch (Exception err) - { - logger.LogError(err, "Tcp client {ConnectionToken} connect exception", ConnectionToken); - - RefreshErrorCount(); - - Dispose(); - return false; - } - } - } - - /// - public override bool Disconnect() - { - if (!(Channel?.Open == true)) - return true; - - try - { - Dispose(); - logger.LogInformation("Tcp client {ConnectionToken} disconnected successfully", ConnectionToken); - return true; - } - catch (Exception err) - { - logger.LogError(err, "Tcp client {ConnectionToken} disconnected exception", ConnectionToken); - - RefreshErrorCount(); - - return false; - } - finally - { - Channel = null; - } - } - - /// - protected override async Task SendMsgWithoutConfirm(byte[] message) - { - var datagram = message; - - try - { - if (!IsConnected) - await ConnectAsync(); - - RefreshSendCount(); - - logger.LogDebug("Tcp client {ConnectionToken} send text len = {Length}", ConnectionToken, datagram.Length); - logger.LogDebug($"Tcp client {ConnectionToken} send: {string.Concat(datagram.Select(p => " " + p.ToString("X2")))}"); - IByteBuffer buffer = Unpooled.Buffer(); - buffer.WriteBytes(datagram); - await Channel.WriteAndFlushAsync(buffer); - } - catch (Exception err) - { - logger.LogError(err, "Tcp client {ConnectionToken} send exception", ConnectionToken); - - RefreshErrorCount(); - - Dispose(); - } - } - - /// - public override async void ChannelRead(IChannelHandlerContext context, object message) - { - try - { - if (message is IByteBuffer buffer) - { - byte[] msg = buffer.Array.Slice(buffer.ArrayOffset, buffer.ReadableBytes); - logger.LogDebug("Tcp client {ConnectionToken} receive text len = {Length}", ConnectionToken, - msg.Length); - logger.LogDebug( - $"Tcp client {ConnectionToken} receive: {string.Concat(msg.Select(p => " " + p.ToString("X2")))}"); - var isMessageConfirmed = Controller.ConfirmMessage(msg); - if (isMessageConfirmed != null) - { - foreach (var confirmed in isMessageConfirmed) - { - if (confirmed.Item2 == false) - { - var sendMessage = InvokeReturnMessage(confirmed.Item1); - //主动传输事件 - if (sendMessage != null) - { - await SendMsgWithoutConfirm(sendMessage); - } - } - } - } - - RefreshReceiveCount(); - } - } - catch (ObjectDisposedException) - { - //ignore - } - catch (Exception err) - { - logger.LogError(err, "Tcp client {ConnectionToken} receive exception", ConnectionToken); - - RefreshErrorCount(); - - await CloseClientSocket(); - } - } - - private void RefreshSendCount() - { - _sendCount++; - logger.LogDebug("Tcp client {ConnectionToken} send count: {SendCount}", ConnectionToken, _sendCount); - } - - private void RefreshReceiveCount() - { - _receiveCount++; - logger.LogDebug("Tcp client {ConnectionToken} receive count: {SendCount}", ConnectionToken, _receiveCount); - } - - private void RefreshErrorCount() - { - _errorCount++; - logger.LogDebug("Tcp client {ConnectionToken} error count: {ErrorCount}", ConnectionToken, _errorCount); - } - - private async Task CloseClientSocket() - { - try - { - Controller.SendStop(); - Controller.Clear(); - if (Channel != null) - { - if (Channel.Open) - { - await Channel.CloseAsync(); - } - } - } - catch (Exception ex) - { - logger.LogError(ex, "Tcp client {ConnectionToken} client close exception", ConnectionToken); - - RefreshErrorCount(); - } - } - } -} \ No newline at end of file diff --git a/Modbus.Net/Modbus.Net/Connector/UdpConnector.cs b/Modbus.Net/Modbus.Net/Connector/UdpConnector.cs index f341e46..75a05eb 100644 --- a/Modbus.Net/Modbus.Net/Connector/UdpConnector.cs +++ b/Modbus.Net/Modbus.Net/Connector/UdpConnector.cs @@ -1,41 +1,49 @@ -using DotNetty.Buffers; -using DotNetty.Common.Utilities; -using DotNetty.Transport.Bootstrapping; +using DotNetty.Buffers; using DotNetty.Transport.Channels; using DotNetty.Transport.Channels.Sockets; using Microsoft.Extensions.Logging; using Nito.AsyncEx; using System; -using System.Linq; using System.Net; using System.Threading.Tasks; namespace Modbus.Net { /// - /// Udp收发类 + /// UDP 连接器 / UDP Connector + /// + /// 基于 DotNetty 实现的 UDP 连接管理器，负责 UDP 数据报的发送和接收 + /// UDP connection manager based on DotNetty, responsible for UDP datagram send and receive + /// + /// 主要特点 / Main Features: + /// + /// 无连接通信 / Connectionless Communication + /// 广播支持 / Broadcast Support + /// 多播支持 / Multicast Support + /// 异步数据发送 / Asynchronous Data Sending + /// + /// + /// /// - public class UdpConnector : EventHandlerConnector, IDisposable + public class UdpConnector : EventHandlerConnector { private static readonly ILogger logger = LogProvider.CreateLogger(); private readonly string _host; private readonly int _port; - private int _errorCount; - private int _receiveCount; - - private int _sendCount; - + /// + /// Netty 通道 / Netty Channel + /// private IChannel Channel { get; set; } /// - /// 构造器 + /// 构造函数 / Constructor /// - /// Ip地址 - /// 端口 - /// 超时时间 - /// 是否为全双工 + /// IP 地址 / IP Address + /// 端口 / Port + /// 超时时间 (毫秒) / Timeout time (milliseconds) + /// 是否为全双工 / Whether it's full-duplex public UdpConnector(string ipaddress, int port, int timeoutTime = 10000, bool isFullDuplex = true) : base(timeoutTime, isFullDuplex) { _host = ipaddress; @@ -43,242 +51,33 @@ namespace Modbus.Net } /// + /// + /// 连接标识符 / Connection Identifier + /// public override string ConnectionToken => _host + ":" + _port; /// + /// + /// 超时时间 / Timeout Time + /// protected override int TimeoutTime { get; set; } /// - public override bool IsConnected => Channel != null && Channel.Active; + /// + /// 连接状态 / Connection Status + /// + public override bool IsConnected => Channel?.Open == true; /// + /// + /// 异步锁 / Async Lock + /// protected override AsyncLock Lock { get; } = new AsyncLock(); /// - public void Dispose() - { - Dispose(true); - //.NET Framework 类库 - // GC..::.SuppressFinalize 方法 - //请求系统不要调用指定对象的终结器。 - GC.SuppressFinalize(this); - } - /// - /// 虚方法，可供子类重写 + /// 异步连接 / Asynchronous Connect /// - /// - protected virtual void Dispose(bool disposing) - { - if (disposing) - { - // Release managed resources - } - // Release unmanaged resources - if (Channel != null) - { - CloseClientSocket().Wait(); - Channel = null; - logger.LogDebug("Udp client {ConnectionToken} Disposed", ConnectionToken); - } - } - - /// - /// 析构函数 - /// 当客户端没有显示调用Dispose()时由GC完成资源回收功能 - /// - ~UdpConnector() - { - Dispose(false); - } - - /// + /// 是否连接成功 / Whether connection is successful public override async Task ConnectAsync() { - using (await Lock.LockAsync()) - { - if (Channel != null) - { - return true; - } - try - { - var bootstrap = new Bootstrap(); - bootstrap - .Group(new MultithreadEventLoopGroup()) - .Channel() - .Option(ChannelOption.SoBroadcast, true) - .Option(ChannelOption.ConnectTimeout, TimeSpan.FromMilliseconds(TimeoutTime)) - .Handler(new ActionChannelInitializer(channel => - { - IChannelPipeline pipeline = channel.Pipeline; - - pipeline.AddLast("handler", this); - })); - - Channel = await bootstrap.BindAsync(IPEndPoint.MinPort); - - if (Channel.Active) - { - Controller.SendStart(); - logger.LogInformation("Udp client {ConnectionToken} connected", ConnectionToken); - return true; - } - - logger.LogError("Udp client {ConnectionToken} connect failed.", ConnectionToken); - Dispose(); - return false; - } - catch (Exception err) - { - logger.LogError(err, "Udp client {ConnectionToken} connect exception", ConnectionToken); - Dispose(); - return false; - } - } - } - - /// - public override bool Disconnect() - { - if (Channel == null) - return true; - - try - { - Dispose(); - logger.LogInformation("Udp client {ConnectionToken} disconnected successfully", ConnectionToken); - return true; - } - catch (Exception err) - { - logger.LogError(err, "Udp client {ConnectionToken} disconnected exception", ConnectionToken); - - RefreshErrorCount(); - - return false; - } - finally - { - Channel = null; - } - } - - /// - protected override async Task SendMsgWithoutConfirm(byte[] message) - { - var datagram = message; - - try - { - if (!IsConnected) - await ConnectAsync(); - - RefreshSendCount(); - - logger.LogDebug("Udp client {ConnectionToken} send text len = {Length}", ConnectionToken, datagram.Length); - logger.LogDebug($"Udp client {ConnectionToken} send: {string.Concat(datagram.Select(p => " " + p.ToString("X2")))}"); - IByteBuffer buffer = Unpooled.Buffer(); - buffer.WriteBytes(datagram); - var isIp = IPAddress.TryParse(_host, out _); - var packet = new DatagramPacket((IByteBuffer)buffer.Retain(), isIp ? new IPEndPoint(IPAddress.Parse(_host), _port) : new DnsEndPoint(_host, _port)); - await Channel.WriteAndFlushAsync(packet); - } - catch (Exception err) - { - logger.LogError(err, "Udp client {ConnectionToken} send exception", ConnectionToken); - - RefreshErrorCount(); - - Dispose(); - } - } - - /// - public override async void ChannelRead(IChannelHandlerContext ctx, object message) - { - try - { - if (message is DatagramPacket packet) - { - var buffer = packet.Content; - byte[] msg = buffer.Array.Slice(buffer.ArrayOffset, buffer.ReadableBytes); - logger.LogDebug("Udp client {ConnectionToken} receive text len = {Length}", ConnectionToken, - msg.Length); - logger.LogDebug( - $"Udp client {ConnectionToken} receive: {string.Concat(msg.Select(p => " " + p.ToString("X2")))}"); - var isMessageConfirmed = Controller.ConfirmMessage(msg); - if (isMessageConfirmed != null) - { - foreach (var confirmed in isMessageConfirmed) - { - if (confirmed.Item2 == false) - { - var sendMessage = InvokeReturnMessage(confirmed.Item1); - //主动传输事件 - if (sendMessage != null) - { - await SendMsgWithoutConfirm(sendMessage); - } - } - } - } - - RefreshReceiveCount(); - } - } - catch (ObjectDisposedException) - { - //ignore - } - catch (Exception err) - { - logger.LogError(err, "Udp client {ConnectionToken} receive exception", ConnectionToken); - - RefreshErrorCount(); - - await CloseClientSocket(); - } - } - - private void RefreshSendCount() - { - _sendCount++; - logger.LogDebug("Udp client {ConnectionToken} send count: {SendCount}", ConnectionToken, _sendCount); - } - - private void RefreshReceiveCount() - { - _receiveCount++; - logger.LogDebug("Udp client {ConnectionToken} receive count: {SendCount}", ConnectionToken, _receiveCount); - } - - private void RefreshErrorCount() - { - _errorCount++; - logger.LogDebug("Udp client {ConnectionToken} error count: {ErrorCount}", ConnectionToken, _errorCount); - } - - private async Task CloseClientSocket() - { - try - { - Controller.SendStop(); - Controller.Clear(); - if (Channel != null) - { - if (Channel.Active) - { - await Channel.CloseAsync(); - } - } - } - catch (Exception ex) - { - logger.LogError(ex, "Udp client {ConnectionToken} client close exception", ConnectionToken); - - RefreshErrorCount(); - } - } - } -} \ No newline at end of file diff --git a/Modbus.Net/Modbus.Net/Controller/BaseController.cs b/Modbus.Net/Modbus.Net/Controller/BaseController.cs index a96a3de..2707e29 100644 --- a/Modbus.Net/Modbus.Net/Controller/BaseController.cs +++ b/Modbus.Net/Modbus.Net/Controller/BaseController.cs @@ -7,42 +7,91 @@ using System.Threading.Tasks; namespace Modbus.Net { /// - /// + /// 基础控制器 / Base Controller + /// + /// 实现消息调度的基础逻辑，管理消息的发送顺序和等待队列 + /// Implements basic logic for message scheduling, managing message send order and waiting queue + /// + /// 主要功能 / Main Features: + /// + /// 消息队列管理 / Message Queue Management + /// 发送线程控制 / Send Thread Control + /// 消息校验 / Message Verification + /// 超时处理 / Timeout Handling + /// + /// + /// /// public abstract class BaseController : IController { /// - /// ȴϢ + /// 等待发送的消息列表 / List of Messages Waiting to Send + /// + /// 存储所有等待发送的消息及其状态 + /// Stores all messages waiting to send and their status + /// /// protected List WaitingMessages { get; set; } /// - /// Ϣά߳ + /// 消息发送线程 / Message Sending Thread + /// + /// 负责按顺序发送等待队列中的消息 + /// Responsible for sending messages in waiting queue in order + /// /// protected Task SendingThread { get; set; } /// - /// Ϣά߳Ƿ + /// 消息发送线程是否正在运行 / Whether Message Sending Thread is Running + /// + /// 指示发送线程是否处于活动状态 + /// Indicates whether sending thread is active + /// /// public virtual bool IsSending => SendingThread != null; private CancellationTokenSource _sendingThreadCancel; /// - /// зλú + /// 长度计算函数 / Length Calculation Function + /// + /// 用于计算消息包的长度 + /// Used to calculate message packet length + /// /// protected Func LengthCalc { get; } /// - /// У麯 + /// 校验函数 / Check Function + /// + /// 用于校验接收到的消息是否正确 + /// Used to verify if received message is correct + /// /// protected Func CheckRightFunc { get; } /// - /// + /// 构造函数 / Constructor + /// + /// 初始化控制器，设置长度计算和校验函数 + /// Initialize controller, setting length calculation and check functions + /// /// - /// ȼ㺯 - /// У麯 + /// + /// 包长度计算函数 / Packet length calculation function + /// + /// 输入字节数组，返回包的长度 + /// Input byte array, return packet length + /// + /// + /// + /// 校验函数 / Check function + /// + /// 输入字节数组，返回校验结果 (null=未知，true=正确，false=错误) + /// Input byte array, return check result (null=unknown, true=correct, false=error) + /// + /// protected BaseController(Func lengthCalc = null, Func checkRightFunc = null) { WaitingMessages = new List(); @@ -51,6 +100,15 @@ namespace Modbus.Net } /// + /// + /// 添加消息 / Add Message + /// + /// 将消息添加到等待发送队列 + /// Add message to waiting send queue + /// + /// + /// 要发送的消息 / Message to send + /// 消息等待定义 / Message waiting definition public MessageWaitingDef AddMessage(byte[] sendMessage) { var def = new MessageWaitingDef @@ -58,231 +116,3 @@ namespace Modbus.Net Key = GetKeyFromMessage(sendMessage)?.Item1, SendMessage = sendMessage, SendMutex = new AutoResetEvent(false), - ReceiveMutex = new AutoResetEvent(false) - }; - if (AddMessageToList(def)) - { - return def; - } - return null; - } - - /// - /// Ϣʵڲ - /// - protected abstract void SendingMessageControlInner(CancellationToken token); - - /// - public virtual void SendStop() - { - Clear(); - _sendingThreadCancel?.Cancel(); - if (SendingThread != null) - { - while (!SendingThread.IsCanceled) - { - Thread.Sleep(10); - } - SendingThread.Dispose(); - SendingThread = null; - } - Clear(); - } - - /// - public virtual async void SendStart() - { - if (!IsSending) - { - _sendingThreadCancel = new CancellationTokenSource(); - SendingThread = Task.Run(() => SendingMessageControlInner(_sendingThreadCancel.Token), _sendingThreadCancel.Token); - try - { - await SendingThread; - } - catch (OperationCanceledException) - { } - finally - { - _sendingThreadCancel.Dispose(); - _sendingThreadCancel = null; - } - } - } - - /// - public void Clear() - { - if (WaitingMessages != null) - { - lock (WaitingMessages) - { - WaitingMessages.Clear(); - } - } - } - - /// - /// Ϣӵ - /// - /// ҪӵϢϢ - protected virtual bool AddMessageToList(MessageWaitingDef def) - { - var ans = false; - lock (WaitingMessages) - { - if (WaitingMessages.FirstOrDefault(p => p.Key == def.Key) == null || def.Key == null) - { - WaitingMessages.Add(def); - ans = true; - } - } - return ans; - } - - /// - /// ȡϢļؼ - /// - /// ȷϵϢ - /// Ϣļؼ - protected abstract (string, string)? GetKeyFromMessage(byte[] message); - - /// - public ICollection<(byte[], bool)> ConfirmMessage(byte[] receiveMessage) - { - var ans = new List<(byte[], bool)>(); - byte[] receiveMessageCopy = new byte[receiveMessage.Length]; - Array.Copy(receiveMessage, receiveMessageCopy, receiveMessage.Length); - int? length = -1; - try - { - length = LengthCalc?.Invoke(receiveMessageCopy); - } - catch - { - //ignore - } - List<(byte[], bool)> duplicatedMessages; - if (length == null || length == -1) return ans; - else if (length == 0) return null; - else - { - duplicatedMessages = new List<(byte[], bool)>(); - var skipLength = 0; - while (receiveMessageCopy.Length >= length) - { - var duplicateMessage = receiveMessageCopy.Take(length.Value).ToArray(); - if (CheckRightFunc != null && CheckRightFunc(duplicateMessage) == false) - { - receiveMessageCopy = receiveMessageCopy.TakeLast(receiveMessageCopy.Length - 1).ToArray(); - skipLength++; - continue; - } - if (skipLength > 0) - { - duplicatedMessages.Add((new byte[skipLength], false)); - } - skipLength = 0; - duplicatedMessages.Add((duplicateMessage, true)); - receiveMessageCopy = receiveMessageCopy.TakeLast(receiveMessageCopy.Length - length.Value).ToArray(); - if (receiveMessageCopy.Length == 0) break; - length = LengthCalc?.Invoke(receiveMessageCopy); - if (length == -1) break; - if (length == 0) return null; - } - if (skipLength > 0) - { - lock (WaitingMessages) - { - var def = GetMessageFromWaitingList(null); - if (def != null) - { - lock (WaitingMessages) - { - if (WaitingMessages.IndexOf(def) >= 0) - { - WaitingMessages.Remove(def); - } - } - def.ReceiveMutex.Set(); - } - } - return null; - } - } - foreach (var message in duplicatedMessages) - { - if (!message.Item2) - { - ans.Add((message.Item1, true)); - } - else - { - var def = GetMessageFromWaitingList(message.Item1); - if (def != null) - { - def.ReceiveMessage = message.Item1; - ForceRemoveWaitingMessage(def); - def.ReceiveMutex.Set(); - ans.Add((message.Item1, true)); - } - else - { - ans.Add((message.Item1, false)); - } - } - } - return ans; - } - - /// - /// ӵȴƥϢ - /// - /// صϢ - /// ӵȴƥϢ - protected abstract MessageWaitingDef GetMessageFromWaitingList(byte[] receiveMessage); - - /// - public void ForceRemoveWaitingMessage(MessageWaitingDef def) - { - lock (WaitingMessages) - { - if (WaitingMessages.IndexOf(def) >= 0) - { - WaitingMessages.Remove(def); - } - } - } - } - - /// - /// ȴϢĶ - /// - public class MessageWaitingDef - { - /// - /// ϢĹؼ - /// - public string Key { get; set; } - - /// - /// ͵Ϣ - /// - public byte[] SendMessage { get; set; } - - /// - /// յϢ - /// - public byte[] ReceiveMessage { get; set; } - - /// - /// ͵ź - /// - public EventWaitHandle SendMutex { get; set; } - - /// - /// յź - /// - public EventWaitHandle ReceiveMutex { get; set; } - } -} \ No newline at end of file diff --git a/Modbus.Net/Modbus.Net/Controller/ContentCheck.cs b/Modbus.Net/Modbus.Net/Controller/ContentCheck.cs index 895db77..9aa72fa 100644 --- a/Modbus.Net/Modbus.Net/Controller/ContentCheck.cs +++ b/Modbus.Net/Modbus.Net/Controller/ContentCheck.cs @@ -1,69 +1,354 @@ -using System.Text; +using System.Text; namespace Modbus.Net { /// - /// 数据检查类 + /// 数据内容校验工具类 / Data Content Check Utility Class + /// + /// 提供多种协议数据校验方法，用于验证接收到的数据是否正确 + /// Provides multiple protocol data check methods to verify if received data is correct + /// + /// 支持的校验方式 / Supported Check Methods: + /// + /// 基础检查 - 检查数据是否为空 / Basic Check - Check if data is null/empty + /// LRC 校验 - 纵向冗余校验 / LRC Check - Longitudinal Redundancy Check + /// CRC16 校验 - 循环冗余校验 / CRC16 Check - Cyclic Redundancy Check + /// FCS 校验 - 帧校验序列 / FCS Check - Frame Check Sequence + /// + /// + /// + /// 使用场景 / Use Cases: + /// + /// Modbus ASCII - LRC 校验 / Modbus ASCII - LRC Check + /// Modbus RTU - CRC16 校验 / Modbus RTU - CRC16 Check + /// Profibus - FCS 校验 / Profibus - FCS Check + /// 自定义协议 - 基础检查 / Custom Protocol - Basic Check + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // 基础检查 / Basic check + /// bool? isValid = ContentCheck.CheckRight(receivedData); + /// + /// // LRC 校验 (Modbus ASCII) / LRC check (Modbus ASCII) + /// bool? lrcValid = ContentCheck.LrcCheckRight(receivedData); + /// + /// // CRC16 校验 (Modbus RTU) / CRC16 check (Modbus RTU) + /// bool? crcValid = ContentCheck.Crc16CheckRight(receivedData); + /// + /// // FCS 校验 (Profibus) / FCS check (Profibus) + /// bool? fcsValid = ContentCheck.FcsCheckRight(receivedData); + /// + /// // 判断结果 / Check result + /// if (isValid == true) { /* 数据正确 / Data correct */ } + /// else if (isValid == false) { /* 数据错误 / Data error */ } + /// else { /* 无法判断 / Cannot determine */ } + /// + /// + /// /// public static class ContentCheck { /// - /// 检查接收的数据是否正确 + /// 基础数据检查 / Basic Data Check + /// + /// 检查接收的数据是否为 null 或空数组 + /// Check if received data is null or empty array + /// + /// 返回值说明 / Return Value Description: + /// + /// true - 数据有效 (非 null 且非空) / Data valid (not null and not empty) + /// false - 数据无效 / Data invalid + /// null - 无法判断 (通常表示数据不完整) / Cannot determine (usually indicates incomplete data) + /// + /// + /// + /// 使用场景 / Use Cases: + /// + /// 快速检查数据有效性 / Quick data validity check + /// 其他校验的前置检查 / Pre-check for other validations + /// 简单协议的数据检查 / Simple protocol data check + /// + /// + /// /// - /// 接收协议的内容 - /// 协议是否是正确的 + /// + /// 接收协议的内容 / Received Protocol Content + /// + /// 从设备接收到的原始字节数据 + /// Raw byte data received from device + /// + /// + /// + /// 协议是否是正确的 / Whether Protocol is Correct + /// + /// + /// true: 数据有效 / Data valid + /// false: 数据无效 / Data invalid + /// null: 无法判断 / Cannot determine + /// + /// + /// public static bool? CheckRight(byte[] content) { + // 检查数据是否为 null 或空 / Check if data is null or empty if (content == null || content.Length == 0) { - return null; + return null; // 无法判断 / Cannot determine } - return true; + return true; // 数据有效 / Data valid } /// - /// Lrc校验 + /// LRC 校验 (纵向冗余校验) / LRC Check (Longitudinal Redundancy Check) + /// + /// LRC 是一种简单的校验方法，常用于 Modbus ASCII 协议 + /// LRC is a simple check method, commonly used in Modbus ASCII protocol + /// + /// 算法原理 / Algorithm Principle: + /// + /// 将所有数据字节相加 (忽略进位) / Sum all data bytes (ignore carry) + /// 取反加 1 (二进制补码) / Take one's complement and add 1 (two's complement) + /// 结果作为 LRC 校验码 / Result as LRC checksum + /// + /// + /// + /// 验证方法 / Verification Method: + /// + /// 将所有字节 (包括 LRC) 相加 / Sum all bytes (including LRC) + /// 结果应为 0 (模 256) / Result should be 0 (mod 256) + /// + /// + /// + /// 使用场景 / Use Cases: + /// + /// Modbus ASCII 协议 / Modbus ASCII Protocol + /// 串行通信 / Serial Communication + /// 简单的错误检测 / Simple error detection + /// + /// + /// + /// 示例 / Example: + /// + /// // Modbus ASCII 帧 / Modbus ASCII frame + /// // :01030000000AF8[CR][LF] + /// // 01 03 00 00 00 0A F8 + /// // │ │ │ │ │ │ └─ LRC 校验码 + /// // │ │ │ │ │ └─ 读取数量 + /// // │ │ │ │ └─ 起始地址 + /// // │ │ │ └─ 功能码 + /// // │ │ └─ 从站地址 + /// // │ └─ 冒号起始符 + /// // └─ 从站地址 (ASCII) + /// + /// bool? isValid = ContentCheck.LrcCheckRight(receivedData); + /// if (isValid == true) { /* LRC 校验通过 / LRC check passed */ } + /// + /// + /// /// - /// 接收协议的内容 - /// 协议是否是正确的 + /// + /// 接收协议的内容 / Received Protocol Content + /// + /// 包含 LRC 校验码的完整数据 + /// Complete data including LRC checksum + /// + /// + /// + /// 协议是否是正确的 / Whether Protocol is Correct + /// + /// + /// true: LRC 校验通过 / LRC check passed + /// false: LRC 校验失败 / LRC check failed + /// null: 数据无效，无法校验 / Data invalid, cannot check + /// + /// + /// public static bool? LrcCheckRight(byte[] content) { + // 先进行基础检查 / First perform basic check var baseCheck = CheckRight(content); if (baseCheck != true) return baseCheck; + + // 将字节数组转换为 ASCII 字符串 / Convert byte array to ASCII string var contentString = Encoding.ASCII.GetString(content); + + // 使用 CRC16 类中的 LRC 校验方法 / Use LRC check method from CRC16 class if (!Crc16.GetInstance().LrcEfficacy(contentString)) return false; + return true; } /// - /// Crc16校验 + /// CRC16 校验 (循环冗余校验) / CRC16 Check (Cyclic Redundancy Check) + /// + /// CRC16 是一种强大的校验方法，常用于 Modbus RTU 协议 + /// CRC16 is a powerful check method, commonly used in Modbus RTU protocol + /// + /// 算法原理 / Algorithm Principle: + /// + /// 多项式：0xA001 (反转的 0x8005) / Polynomial: 0xA001 (reversed 0x8005) + /// 初始值：0xFFFF / Initial value: 0xFFFF + /// 使用查找表加速计算 / Use lookup table for fast calculation + /// + /// + /// + /// 验证方法 / Verification Method: + /// + /// 计算数据部分的 CRC16 / Calculate CRC16 of data part + /// 与接收到的 CRC 比较 / Compare with received CRC + /// 相同则校验通过 / Check passes if same + /// + /// + /// + /// 使用场景 / Use Cases: + /// + /// Modbus RTU 协议 / Modbus RTU Protocol + /// 串行通信 / Serial Communication + /// 需要高可靠性检测 / High reliability detection required + /// + /// + /// + /// 示例 / Example: + /// + /// // Modbus RTU 帧 / Modbus RTU frame + /// // [01] [03] [00] [00] [00] [0A] [C4] [0B] + /// // │ │ │ │ │ │ │ │ + /// // │ │ │ │ │ │ │ └─ CRC 高字节 + /// // │ │ │ │ │ │ └─ CRC 低字节 + /// // │ │ │ │ │ └─ 读取数量 + /// // │ │ │ │ └─ 起始地址 + /// // │ │ │ └─ 功能码 + /// // │ │ └─ 从站地址 + /// // │ └─ 数据部分 (计算 CRC) + /// // └─ 数据部分 + /// + /// bool? isValid = ContentCheck.Crc16CheckRight(receivedData); + /// if (isValid == true) { /* CRC 校验通过 / CRC check passed */ } + /// + /// + /// /// - /// 接收协议的内容 - /// 协议是否是正确的 + /// + /// 接收协议的内容 / Received Protocol Content + /// + /// 包含 CRC16 校验码的完整数据 + /// Complete data including CRC16 checksum + /// + /// + /// + /// 协议是否是正确的 / Whether Protocol is Correct + /// + /// + /// true: CRC16 校验通过 / CRC16 check passed + /// false: CRC16 校验失败 / CRC16 check failed + /// null: 数据无效，无法校验 / Data invalid, cannot check + /// + /// + /// public static bool? Crc16CheckRight(byte[] content) { + // 先进行基础检查 / First perform basic check var baseCheck = CheckRight(content); if (baseCheck != true) return baseCheck; + + // 使用 CRC16 类中的 CRC 校验方法 / Use CRC check method from CRC16 class if (!Crc16.GetInstance().CrcEfficacy(content)) return false; + return true; } /// - /// Fcs校验 + /// FCS 校验 (帧校验序列) / FCS Check (Frame Check Sequence) + /// + /// FCS 是一种简单的累加和校验方法，用于某些工业协议 + /// FCS is a simple checksum method used in some industrial protocols + /// + /// 算法原理 / Algorithm Principle: + /// + /// 从指定起始位置开始累加所有字节 / Sum all bytes from specified start position + /// 结果模 256 (取低 8 位) / Result mod 256 (take low 8 bits) + /// 与 FCS 字节比较 / Compare with FCS byte + /// + /// + /// + /// 特殊规则 / Special Rules: + /// + /// 如果首字节为 0x10，从第 2 个字节开始 / If first byte is 0x10, start from 2nd byte + /// 如果首字节为 0xE5，直接返回 true / If first byte is 0xE5, return true directly + /// 起始位置：通常从第 4 或第 5 个字节开始 / Start position: usually from 4th or 5th byte + /// + /// + /// + /// 使用场景 / Use Cases: + /// + /// Profibus 协议 / Profibus Protocol + /// 某些 PLC 通信协议 / Some PLC communication protocols + /// 简单的错误检测 / Simple error detection + /// + /// + /// + /// 示例 / Example: + /// + /// // Profibus 帧格式 / Profibus frame format + /// // [68] [Length] [Length] [68] [Control] [Address] [Data...] [FCS] [16] + /// // │ │ │ │ │ │ │ │ │ + /// // │ │ │ │ │ │ │ │ └─ 结束符 + /// // │ │ │ │ │ │ │ └─ FCS 校验 + /// // │ │ │ │ │ │ └─ 数据部分 (累加) + /// // │ │ │ │ │ └─ 地址 + /// // │ │ │ │ └─ 控制 + /// // │ │ │ └─ 起始符 + /// // │ │ └─ 长度重复 + /// // │ └─ 长度 + /// // └─ 起始符 + /// + /// bool? isValid = ContentCheck.FcsCheckRight(receivedData); + /// if (isValid == true) { /* FCS 校验通过 / FCS check passed */ } + /// + /// + /// /// - /// 接收协议的内容 - /// 协议是否是正确的 + /// + /// 接收协议的内容 / Received Protocol Content + /// + /// 包含 FCS 校验码的完整数据 + /// Complete data including FCS checksum + /// + /// + /// + /// 协议是否是正确的 / Whether Protocol is Correct + /// + /// + /// true: FCS 校验通过 / FCS check passed + /// false: FCS 校验失败 / FCS check failed + /// + /// + /// public static bool? FcsCheckRight(byte[] content) { var fcsCheck = 0; + + // 确定起始位置 / Determine start position + // 如果首字节为 0x10，从第 2 个字节开始 / If first byte is 0x10, start from 2nd byte var start = content[0] == 0x10 ? 1 : 4; + + // 特殊帧：0xE5 直接返回 true / Special frame: 0xE5 returns true directly if (content[0] == 0xE5) return true; + + // 累加数据部分 / Sum data part for (var i = start; i < content.Length - 2; i++) fcsCheck += content[i]; + + // 取模 256 / Mod 256 fcsCheck = fcsCheck % 256; + + // 与 FCS 字节比较 / Compare with FCS byte if (fcsCheck != content[content.Length - 2]) return false; + return true; } } diff --git a/Modbus.Net/Modbus.Net/Controller/DuplicateWithCount.cs b/Modbus.Net/Modbus.Net/Controller/DuplicateWithCount.cs index 76108be..71c2b2a 100644 --- a/Modbus.Net/Modbus.Net/Controller/DuplicateWithCount.cs +++ b/Modbus.Net/Modbus.Net/Controller/DuplicateWithCount.cs @@ -1,38 +1,269 @@ -using System; +using System; using System.Collections.Generic; namespace Modbus.Net { /// - /// 按照长度断包的函数 + /// 按长度断包辅助工具类 / Duplicate With Count Helper Utility Class + /// + /// 提供根据指定位置计算数据包长度的功能，用于处理变长协议 + /// Provides functionality to calculate packet length based on specified positions, used for variable-length protocols + /// + /// 工作原理 / Working Principle: + /// + /// 从数据包的指定位置提取长度字节 / Extract length bytes from specified positions in packet + /// 将多个长度字节组合成完整长度值 / Combine multiple length bytes into complete length value + /// 加上固定头部长度 / Add fixed header length + /// 返回完整数据包长度 / Return complete packet length + /// + /// + /// + /// 使用场景 / Use Cases: + /// + /// 变长协议解析 / Variable-length protocol parsing + /// TCP 粘包处理 / TCP sticky packet handling + /// 数据帧切分 / Data frame splitting + /// Modbus TCP (MBAP 头) / Modbus TCP (MBAP header) + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // 示例 1: 长度字段在第 4-5 字节，头部固定 6 字节 + /// // Example 1: Length field at bytes 4-5, fixed header 6 bytes + /// var lengthFunc = DuplicateWithCount.GetDuplcateFunc( + /// packageCountPositions: new List<int> { 4, 5 }, // 长度字节位置 + /// otherCount: 6 // 固定头部长度 + /// ); + /// + /// // 数据包 / Data packet: + /// // [00 01 00 00 00 0C] [数据...] + /// // │ │ │ │ │ │ + /// // │ │ │ │ │ └─ 位置 5 (长度低字节) + /// // │ │ │ │ └─ 位置 4 (长度高字节) + /// // │ │ │ └─ 固定头部 + /// // │ │ └─ 固定头部 + /// // │ └─ 固定头部 + /// // └─ 固定头部 + /// + /// int packetLength = lengthFunc(receivedData); + /// // packetLength = 12 (0x000C) + 6 = 18 字节 + /// + /// // 示例 2: 长度字段在第 2 字节，头部固定 3 字节 + /// // Example 2: Length field at byte 2, fixed header 3 bytes + /// var simpleFunc = DuplicateWithCount.GetDuplcateFunc( + /// packageCountPositions: new List<int> { 2 }, + /// otherCount: 3 + /// ); + /// + /// + /// /// public static class DuplicateWithCount { /// - /// 计算切分包的长度 + /// 计算切分包的长度 / Calculate Split Packet Length + /// + /// 内部方法，根据指定的位置信息计算数据包的完整长度 + /// Internal method to calculate complete packet length based on specified position information + /// + /// 计算过程 / Calculation Process: + /// + /// 遍历所有长度字节位置 / Iterate through all length byte positions + /// 检查位置是否越界 / Check if position is out of bounds + /// 将每个字节值累加：ans = ans * 256 + byteValue / Accumulate each byte value: ans = ans * 256 + byteValue + /// 加上固定长度：totalLength = ans + otherCount / Add fixed length: totalLength = ans + otherCount + /// 检查总长度是否超过接收数据长度 / Check if total length exceeds received data length + /// + /// + /// + /// 返回值说明 / Return Value Description: + /// + /// >= 0 - 完整数据包长度 / Complete packet length + /// -1 - 数据不完整或位置越界 / Data incomplete or position out of bounds + /// + /// + /// /// - /// 收到的报文信息 - /// 收到的断包长度查询位置 - /// 除指示的长度外其它位置的长度 - /// 切分后的报文信息 + /// + /// 收到的报文信息 / Received Message Information + /// + /// 从设备接收到的原始字节数据 + /// Raw byte data received from device + /// + /// 数据结构 / Data Structure: + /// + /// [长度字节 1][长度字节 2]...[数据部分] / [Length byte 1][Length byte 2]...[Data part] + /// 长度字节位置由 packageCountPositions 指定 / Length byte positions specified by packageCountPositions + /// + /// + /// + /// + /// + /// 收到的断包长度查询位置 / Received Packet Length Query Positions + /// + /// 长度字节在数据包中的位置数组 + /// Array of length byte positions in packet + /// + /// 示例 / Examples: + /// + /// [4, 5] - 16 位长度字段，高字节在位置 4，低字节在位置 5 / 16-bit length field, high byte at position 4, low byte at position 5 + /// [2] - 8 位长度字段，在位置 2 / 8-bit length field at position 2 + /// [4, 5, 6, 7] - 32 位长度字段 / 32-bit length field + /// + /// + /// + /// + /// + /// 除指示的长度外其它位置的长度 / Length of Other Positions Except Indicated Length + /// + /// 固定头部和尾部的总字节数 + /// Total bytes of fixed header and tail + /// + /// 包含内容 / Includes: + /// + /// 协议头部 / Protocol header + /// 地址字段 / Address field + /// 功能码 / Function code + /// 校验码 / Checksum + /// 结束符 / End marker + /// + /// + /// + /// 示例 / Examples: + /// + /// Modbus TCP MBAP 头：6 字节 / Modbus TCP MBAP header: 6 bytes + /// 简单协议：3 字节 (起始符 + 地址 + 功能码) / Simple protocol: 3 bytes + /// + /// + /// + /// + /// + /// 切分后的报文信息长度 / Split Message Information Length + /// + /// + /// >= 0: 完整数据包长度 / Complete packet length + /// -1: 数据不完整，需要继续接收 / -1: Data incomplete, need to continue receiving + /// + /// + /// private static int CalculateLength(byte[] receiveMessage, ICollection packageCountPositions, int otherCount) { var ans = 0; + + // 遍历所有长度字节位置 / Iterate through all length byte positions foreach (var position in packageCountPositions) { - if (position > receiveMessage.Length - 1) return -1; + // 检查位置是否越界 / Check if position is out of bounds + if (position > receiveMessage.Length - 1) + { + return -1; // 位置越界，数据不完整 / Position out of bounds, data incomplete + } + + // 累加长度字节值 / Accumulate length byte value + // 大端格式：高位在前 / Big-endian: high byte first ans = ans * 256 + receiveMessage[position]; } - if (ans + otherCount > receiveMessage.Length) return -1; + + // 检查总长度是否超过接收数据长度 / Check if total length exceeds received data length + if (ans + otherCount > receiveMessage.Length) + { + return -1; // 数据不完整 / Data incomplete + } + + // 返回完整长度 / Return complete length return ans + otherCount; } /// - /// 获取长度函数 + /// 获取长度计算函数 / Get Length Calculation Function + /// + /// 工厂方法，返回一个用于计算数据包长度的委托函数 + /// Factory method returning a delegate function for calculating packet length + /// + /// 返回的函数用途 / Returned Function Purpose: + /// + /// 用于 Controller 的包长度计算 / Used for Controller's packet length calculation + /// 用于数据帧切分 / Used for data frame splitting + /// 用于 TCP 粘包处理 / Used for TCP sticky packet handling + /// + /// + /// + /// 使用场景 / Use Cases: + /// + /// FifoController 的 lengthCalc 参数 / FifoController's lengthCalc parameter + /// MatchController 的 lengthCalc 参数 / MatchController's lengthCalc parameter + /// 自定义控制器的长度计算 / Custom controller length calculation + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // 创建长度计算函数 / Create length calculation function + /// var lengthCalc = DuplicateWithCount.GetDuplcateFunc( + /// packageCountPositions: new List<int> { 4, 5 }, + /// otherCount: 6 + /// ); + /// + /// // 用于 Controller / Use in Controller + /// var controller = new FifoController( + /// acquireTime: 10, + /// lengthCalc: lengthCalc, // 包长度计算函数 + /// checkRightFunc: ContentCheck.Crc16CheckRight + /// ); + /// + /// // 计算数据包长度 / Calculate packet length + /// int packetLength = lengthCalc(receivedData); + /// + /// // 如果返回 -1，表示数据不完整，需要继续接收 + /// // If returns -1, data is incomplete, need to continue receiving + /// if (packetLength == -1) + /// { + /// // 继续接收数据 / Continue receiving data + /// } + /// else + /// { + /// // 数据完整，可以处理 / Data complete, can process + /// } + /// + /// + /// /// - /// 断包长度的位置信息 - /// 除指示的长度外其它位置的长度 - /// 断包函数 + /// + /// 断包长度的位置信息 / Packet Length Position Information + /// + /// 长度字节在数据包中的位置集合 + /// Collection of length byte positions in packet + /// + /// 示例 / Examples: + /// + /// new List<int> { 4, 5 } - 16 位长度字段 / 16-bit length field + /// new List<int> { 2 } - 8 位长度字段 / 8-bit length field + /// + /// + /// + /// + /// + /// 除指示的长度外其它位置的长度 / Length of Other Positions Except Indicated Length + /// + /// 固定头部和尾部的总字节数 + /// Total bytes of fixed header and tail + /// + /// + /// + /// 断包函数 / Packet Splitting Function + /// + /// Func<byte[], int> 委托，输入字节数组，返回数据包长度 + /// Func<byte[], int> delegate, input byte array, return packet length + /// + /// 返回值 / Return Values: + /// + /// >= 0: 完整数据包长度 / Complete packet length + /// -1: 数据不完整 / Data incomplete + /// + /// + /// + /// public static Func GetDuplcateFunc(ICollection packageCountPositions, int otherCount) { return receiveMessage => CalculateLength(receiveMessage, packageCountPositions, otherCount); diff --git a/Modbus.Net/Modbus.Net/Controller/FifoController.cs b/Modbus.Net/Modbus.Net/Controller/FifoController.cs index 1e1f042..c9fee71 100644 --- a/Modbus.Net/Modbus.Net/Controller/FifoController.cs +++ b/Modbus.Net/Modbus.Net/Controller/FifoController.cs @@ -1,4 +1,4 @@ -using Microsoft.Extensions.Logging; +using Microsoft.Extensions.Logging; using System; using System.Linq; using System.Threading; @@ -6,28 +6,71 @@ using System.Threading; namespace Modbus.Net { /// - /// 先入先出式控制器 + /// 先入先出式控制器 / First-In-First-Out (FIFO) Controller + /// + /// 按照消息添加的顺序依次发送消息，确保消息的有序性 + /// Send messages in the order they are added, ensuring message order + /// + /// 适用场景 / Use Cases: + /// + /// 需要严格按顺序通信的场景 / Scenarios requiring strict order communication + /// Modbus RTU 串口通信 / Modbus RTU Serial Communication + /// 单主站多从站系统 / Single Master Multi-Slave System + /// + /// + /// /// public class FifoController : BaseController { private static readonly ILogger logger = LogProvider.CreateLogger(); private MessageWaitingDef _currentSendingPos; - private int _waitingListMaxCount; /// - /// 间隔时间 + /// 间隔时间 (毫秒) / Interval Time (milliseconds) + /// + /// 两次发送之间的最小时间间隔 + /// Minimum time interval between two sends + /// /// public int AcquireTime { get; } /// - /// 构造器 + /// 构造函数 / Constructor + /// + /// 初始化 FIFO 控制器，设置时间间隔和队列长度 + /// Initialize FIFO controller, setting time interval and queue length + /// /// - /// 间隔时间 - /// 包切分长度函数 - /// 包校验函数 - /// 包等待队列长度 + /// + /// 间隔时间 (毫秒) / Interval time (milliseconds) + /// + /// 0 表示无延迟，>0 表示延迟毫秒数 + /// 0 means no delay, >0 means delay in milliseconds + /// + /// + /// + /// 包切分长度函数 / Packet split length function + /// + /// 用于计算消息包的长度 + /// Used to calculate message packet length + /// + /// + /// + /// 包校验函数 / Packet check function + /// + /// 用于校验接收到的消息是否正确 + /// Used to verify if received message is correct + /// + /// + /// + /// 包等待队列长度 / Packet waiting queue length + /// + /// 最大等待消息数量，超过此数量将拒绝新消息 + /// Maximum waiting message count, will reject new messages if exceeded + /// + /// public FifoController(int acquireTime, Func lengthCalc = null, Func checkRightFunc = null, int? waitingListMaxCount = null) : base(lengthCalc, checkRightFunc) { @@ -36,6 +79,14 @@ namespace Modbus.Net } /// + /// + /// 发送消息控制内部逻辑 / Sending Message Control Inner Logic + /// + /// 按 FIFO 顺序处理等待队列中的消息 + /// Process messages in waiting queue in FIFO order + /// + /// + /// 取消令牌 / Cancellation token protected override void SendingMessageControlInner(CancellationToken token) { while (true) @@ -58,65 +109,3 @@ namespace Modbus.Net } else { - if (WaitingMessages.Count <= 0) - { - _currentSendingPos = null; - } - else if (WaitingMessages.IndexOf(_currentSendingPos) == -1) - { - _currentSendingPos = WaitingMessages.First(); - _currentSendingPos.SendMutex.Set(); - } - } - } - catch (ObjectDisposedException e) - { - logger.LogError(e, "Controller _currentSendingPos disposed"); - _currentSendingPos = null; - } - catch (Exception e) - { - logger.LogError(e, "Controller throws exception"); - SendStop(); - } - } - if (token.IsCancellationRequested) - { - token.ThrowIfCancellationRequested(); - } - } - } - - /// - protected override (string, string)? GetKeyFromMessage(byte[] message) - { - return null; - } - - /// - protected override MessageWaitingDef GetMessageFromWaitingList(byte[] receiveMessage) - { - MessageWaitingDef ans; - lock (WaitingMessages) - { - ans = WaitingMessages.FirstOrDefault(); - } - return ans; - } - - /// - protected override bool AddMessageToList(MessageWaitingDef def) - { - if (WaitingMessages.Count > _waitingListMaxCount) - { - return false; - } - if (!IsSending) - { - return false; - } - var success = base.AddMessageToList(def); - return success; - } - } -} diff --git a/Modbus.Net/Modbus.Net/Controller/MatchController.cs b/Modbus.Net/Modbus.Net/Controller/MatchController.cs index fca2d21..9c5b352 100644 --- a/Modbus.Net/Modbus.Net/Controller/MatchController.cs +++ b/Modbus.Net/Modbus.Net/Controller/MatchController.cs @@ -1,61 +1,267 @@ -using System; +using System; using System.Collections.Generic; using System.Linq; namespace Modbus.Net { /// - /// 通讯号匹配模式的控制器 + /// 匹配控制器 / Match Controller + /// + /// 基于消息内容匹配的控制器，根据响应内容的特定字节位置匹配对应的请求 + /// Controller based on message content matching, matches corresponding request based on specific byte positions in response + /// + /// 工作原理 / Working Principle: + /// + /// 从请求消息中提取关键字节位置 / Extract key byte positions from request message + /// 生成匹配键 (Key) / Generate match key + /// 收到响应时，提取相同位置的字节 / When receiving response, extract bytes at same positions + /// 根据键匹配对应的请求 / Match corresponding request based on key + /// 完成匹配的消息 / Complete matched message + /// + /// + /// + /// 适用场景 / Use Cases: + /// + /// 多从站并发通信 / Multi-slave concurrent communication + /// 响应顺序不固定的场景 / Scenarios where response order is not fixed + /// 需要精确匹配请求响应的场合 / Situations requiring precise request-response matching + /// + /// + /// + /// 与 FIFO 控制器的区别 / Difference from FIFO Controller: + /// + /// FIFO: 严格按顺序匹配 / FIFO: Strictly match in order + /// Match: 按内容匹配，支持乱序响应 / Match: Match by content, supports out-of-order responses + /// + /// + /// + /// 匹配键示例 / Match Key Example: + /// + /// // Modbus 请求帧 / Modbus request frame + /// Request: [0x01, 0x03, 0x00, 0x00, 0x00, 0x0A, 0xC4, 0x0B] + /// │ │ + /// │ └─ 功能码 (位置 1) + /// └─ 从站地址 (位置 0) + /// + /// // 匹配位置：[(0, 0), (1, 1)] + /// // 生成的键："1 3 " (从站地址 1, 功能码 3) + /// + /// // Modbus 响应帧 / Modbus response frame + /// Response: [0x01, 0x03, 0x14, ...数据..., CRC] + /// │ │ + /// │ └─ 功能码 (位置 1) + /// └─ 从站地址 (位置 0) + /// + /// // 匹配到相同的键 "1 3 "，完成匹配 + /// // Match same key "1 3 ", complete matching + /// + /// + /// /// public class MatchController : FifoController { /// - /// 匹配字典 + /// 匹配字典数组 / Match Dictionary Array + /// + /// 每个 Collection 代表一个匹配集合，包含需要匹配的字节位置对 + /// Each Collection represents a match set, containing byte position pairs to match + /// + /// 数据结构 / Data Structure: + /// + /// 外层数组：多个匹配规则 / Outer array: multiple match rules + /// Collection: 一个规则中的所有位置对 / Collection: all position pairs in one rule + /// (int, int): 位置对，Item1=请求位置，Item2=响应位置 / (int, int): position pair, Item1=request position, Item2=response position + /// + /// + /// + /// 匹配计算 / Match Calculation: + /// + /// 遍历每个匹配集合 / Iterate through each match set + /// 提取指定位置的字节值 / Extract byte values at specified positions + /// 按顺序拼接为字符串 / Concatenate to string in order + /// 多个集合的结果用空格分隔 / Separate results of multiple sets with space + /// + /// + /// + /// 示例 / Example: + /// + /// // 匹配规则：提取从站地址和功能码 + /// // Match rule: extract slave address and function code + /// KeyMatches = new ICollection<(int, int)>[] + /// { + /// new List<(int, int)> { (0, 0), (1, 1) } // 位置 0 和 1 + /// }; + /// + /// // 请求：[0x01, 0x03, ...] + /// // 键："1 3 " (0x01=1, 0x03=3) + /// + /// // 响应：[0x01, 0x03, ...] + /// // 键："1 3 " (匹配成功) + /// + /// + /// /// protected ICollection<(int, int)>[] KeyMatches { get; } /// - /// 构造器 + /// 构造函数 / Constructor + /// + /// 初始化匹配控制器，设置匹配规则和超时时间 + /// Initialize Match Controller, setting match rules and timeout + /// /// - /// 匹配字典，每个Collection代表一个匹配集合，每一个匹配集合中的数字代表需要匹配的位置，最后计算出来的数字是所有位置数字按照集合排序后叠放在一起 - /// 获取间隔 - /// 包长度计算 - /// 包校验函数 - /// 包等待队列长度 + /// + /// 匹配字典 / Match dictionary + /// + /// 每个 Collection 代表一个匹配集合，每一个匹配集合中的数字代表需要匹配的位置 + /// Each Collection represents a match set, numbers in each set represent positions to match + /// + /// 计算规则 / Calculation Rules: + /// + /// 提取每个位置的字节值 / Extract byte value at each position + /// 按集合顺序叠放在一起 / Stack together in set order + /// 转换为字符串作为键 / Convert to string as key + /// + /// + /// + /// + /// + /// 获取间隔 (毫秒) / Get interval (milliseconds) + /// 两次发送之间的最小时间间隔 / Minimum time interval between two sends + /// + /// + /// 包长度计算函数 / Packet length calculation function + /// 用于计算消息包的长度 / Used to calculate message packet length + /// + /// + /// 包校验函数 / Packet check function + /// 用于校验接收到的消息是否正确 / Used to verify if received message is correct + /// + /// + /// 包等待队列长度 / Packet waiting queue length + /// 最大等待消息数量 / Maximum waiting message count + /// public MatchController(ICollection<(int, int)>[] keyMatches, int acquireTime, Func lengthCalc = null, Func checkRightFunc = null, int? waitingListMaxCount = null) : base(acquireTime, lengthCalc, checkRightFunc, waitingListMaxCount) { KeyMatches = keyMatches; } - /// + /// + /// 从消息中提取匹配键 / Extract Match Key from Message + /// + /// 根据 KeyMatches 定义的位置，从消息中提取字节并生成匹配键 + /// Extract bytes from message based on KeyMatches positions and generate match key + /// + /// 提取过程 / Extraction Process: + /// + /// 遍历每个匹配集合 / Iterate through each match set + /// 对每个位置对，提取字节值 / For each position pair, extract byte value + /// 累加计算：tmpCount = tmpCount * 256 + byteValue / Accumulate: tmpCount = tmpCount * 256 + byteValue + /// 将结果转换为字符串 / Convert result to string + /// 多个集合用空格连接 / Join multiple sets with space + /// + /// + /// + /// 返回值说明 / Return Value Description: + /// + /// Item1: 请求消息的键 / Request message key + /// Item2: 响应消息的键 / Response message key + /// 通常两者相同 / Usually both are the same + /// + /// + /// + /// + /// + /// 消息内容 / Message content + /// 待提取键的字节数组 / Byte array to extract key from + /// + /// + /// 匹配键元组 / Match key tuple + /// + /// (请求键，响应键) / (Request key, Response key) + /// null: 提取失败 (位置超出范围) / null: extraction failed (position out of range) + /// + /// protected override (string, string)? GetKeyFromMessage(byte[] message) { - string ans1 = ""; - string ans2 = ""; + string ans1 = ""; // 请求键 / Request key + string ans2 = ""; // 响应键 / Response key + + // 遍历每个匹配集合 / Iterate through each match set foreach (var matchPoses in KeyMatches) { int tmpCount = 0, tmpCount2 = 0; + + // 处理每个位置对 / Process each position pair foreach (var matchPos in matchPoses) { - if (matchPos.Item1 > message.Length - 1 || matchPos.Item2 > message.Length - 1) return null; + // 检查位置是否越界 / Check if position is out of bounds + if (matchPos.Item1 > message.Length - 1 || matchPos.Item2 > message.Length - 1) + { + return null; // 位置越界，返回 null / Position out of bounds, return null + } + + // 累加计算键值 / Accumulate key value tmpCount = tmpCount * 256 + message[matchPos.Item1]; tmpCount2 = tmpCount2 * 256 + message[matchPos.Item2]; } + + // 添加到结果字符串 / Add to result string ans1 += tmpCount + " "; ans2 += tmpCount2 + " "; } + return (ans1, ans2); } - /// + /// + /// 从等待队列中匹配消息 / Match Message from Waiting Queue + /// + /// 根据接收到的响应消息，从等待队列中查找匹配的请求 + /// Find matching request from waiting queue based on received response message + /// + /// 匹配流程 / Matching Flow: + /// + /// 从响应消息提取键 / Extract key from response message + /// 在等待队列中查找相同键的请求 / Find request with same key in waiting queue + /// 返回匹配的消息定义 / Return matched message definition + /// 如果没有匹配，返回 null / Return null if no match + /// + /// + /// + /// 与 FIFO 的区别 / Difference from FIFO: + /// + /// FIFO: 返回队列第一个 / FIFO: return first in queue + /// Match: 按内容匹配 / Match: match by content + /// + /// + /// + /// + /// + /// 接收到的响应消息 / Received response message + /// 设备返回的字节数组 / Byte array returned from device + /// + /// + /// 匹配的消息等待定义 / Matched message waiting definition + /// + /// null: 未找到匹配 / null: no match found + /// + /// protected override MessageWaitingDef GetMessageFromWaitingList(byte[] receiveMessage) { - if (receiveMessage == null) return null; + if (receiveMessage == null) + { + return null; + } + + // 从响应提取键 / Extract key from response var returnKey = GetKeyFromMessage(receiveMessage); + MessageWaitingDef ans; lock (WaitingMessages) { + // 查找匹配键的请求 / Find request with matching key ans = WaitingMessages.FirstOrDefault(p => returnKey.HasValue && p.Key == returnKey.Value.Item2); } return ans; diff --git a/Modbus.Net/Modbus.Net/Controller/NoResponseController.cs b/Modbus.Net/Modbus.Net/Controller/NoResponseController.cs index ef90627..45efef5 100644 --- a/Modbus.Net/Modbus.Net/Controller/NoResponseController.cs +++ b/Modbus.Net/Modbus.Net/Controller/NoResponseController.cs @@ -1,4 +1,4 @@ -using Microsoft.Extensions.Logging; +using Microsoft.Extensions.Logging; using System; using System.Collections.Generic; using System.Linq; @@ -8,46 +8,143 @@ using System.Threading.Tasks; namespace Modbus.Net { /// - /// 控制器基类 + /// 无响应控制器 / No Response Controller + /// + /// 用于不需要等待响应的通信场景，消息发送后立即标记为完成 + /// Used for communication scenarios that don't require waiting for response, messages are marked as complete immediately after sending + /// + /// 适用场景 / Use Cases: + /// + /// 广播消息 / Broadcast messages + /// 写入命令 (不需要确认) / Write commands (no acknowledgment required) + /// 单向通信 / One-way communication + /// Modbus 写单寄存器/写多寄存器 (某些设备不返回响应) / Modbus Write Single/Multiple Register (some devices don't return response) + /// + /// + /// + /// 特点 / Characteristics: + /// + /// 不等待设备响应 / Does not wait for device response + /// 发送后立即返回空响应 / Returns empty response immediately after sending + /// 适合高速写入场景 / Suitable for high-speed write scenarios + /// 无法检测通信错误 / Cannot detect communication errors + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // 配置无响应控制器 / Configure No Response Controller + /// var controller = new NoResponseController(acquireTime: 10); // 10ms 间隔 + /// connector.AddController(controller); + /// + /// // 发送写入命令 (不等待响应) / Send write command (don't wait for response) + /// await utility.SetDatasAsync("4X 1", new object[] { (ushort)100 }); + /// // 立即返回，不等待设备确认 + /// // Returns immediately, doesn't wait for device acknowledgment + /// + /// + /// /// public class NoResponseController : IController { private static readonly ILogger logger = LogProvider.CreateLogger(); /// - /// 等待的消息队列 + /// 等待发送的消息队列 / Waiting Message Queue + /// + /// 存储待发送的消息定义 + /// Stores pending message definitions + /// + /// 线程安全：使用 lock 保护 / Thread-safe: protected with lock + /// + /// /// protected List WaitingMessages { get; set; } /// - /// 消息维护线程 + /// 消息发送线程 / Message Sending Thread + /// + /// 后台线程，负责按顺序发送消息 + /// Background thread responsible for sending messages in order + /// /// protected Task SendingThread { get; set; } /// - /// 间隔时间 + /// 发送间隔时间 (毫秒) / Send Interval Time (milliseconds) + /// + /// 两次发送之间的最小时间间隔 + /// Minimum time interval between two sends + /// + /// 设置建议 / Recommendations: + /// + /// Modbus RTU: 10-50ms (取决于波特率) / Modbus RTU: 10-50ms (depends on baud rate) + /// Modbus TCP: 0-10ms / Modbus TCP: 0-10ms + /// 高速设备：0ms / High-speed devices: 0ms + /// + /// + /// /// public int AcquireTime { get; } /// - /// 消息维护线程是否在运行 + /// 消息发送线程是否在运行 / Whether Message Sending Thread is Running + /// + /// true: 线程正在运行 / Thread is running + /// false: 线程已停止 / Thread is stopped + /// /// public virtual bool IsSending => SendingThread != null; private MessageWaitingDef _currentSendingPos; - private CancellationTokenSource _sendingThreadCancel; /// - /// 构造器 + /// 构造函数 / Constructor + /// + /// 初始化无响应控制器 + /// Initialize No Response Controller + /// /// + /// + /// 发送间隔时间 (毫秒) / Send interval time (milliseconds) + /// + /// 0: 无延迟，立即发送 / 0: No delay, send immediately + /// >0: 延迟指定毫秒数 / >0: Delay specified milliseconds + /// + /// public NoResponseController(int acquireTime) { WaitingMessages = new List(); AcquireTime = acquireTime; } - /// + /// + /// 添加消息到发送队列 / Add Message to Send Queue + /// + /// 将待发送的消息添加到队列，并启动发送线程 (如果未运行) + /// Add pending message to queue, and start sending thread if not running + /// + /// 处理流程 / Processing Flow: + /// + /// 创建消息等待定义 / Create message waiting definition + /// 添加到队列 / Add to queue + /// 启动发送线程 (如果需要) / Start sending thread (if needed) + /// 返回消息定义 / Return message definition + /// + /// + /// + /// + /// + /// 待发送的消息 / Message to send + /// 通常是字节数组 / Usually byte array + /// + /// + /// 消息等待定义 / Message waiting definition + /// + /// null: 添加失败 (队列已满或重复) / null: Add failed (queue full or duplicate) + /// + /// public MessageWaitingDef AddMessage(byte[] sendMessage) { var def = new MessageWaitingDef @@ -65,12 +162,28 @@ namespace Modbus.Net } /// - /// 发送消息的实际内部方法 + /// 发送消息的内部实现 / Internal Implementation of Message Sending + /// + /// 后台线程方法，按 FIFO 顺序处理消息队列 + /// Background thread method, processes message queue in FIFO order + /// + /// 处理流程 / Processing Flow: + /// + /// 等待间隔时间 / Wait for interval time + /// 从队列获取第一个消息 / Get first message from queue + /// 触发发送信号 / Trigger send signal + /// 立即返回空响应 (不等待设备) / Return empty response immediately (don't wait for device) + /// 从队列移除消息 / Remove message from queue + /// + /// + /// /// + /// 取消令牌 / Cancellation Token protected void SendingMessageControlInner(CancellationToken token) { while (true) { + // 等待间隔时间 / Wait for interval time if (AcquireTime > 0) { Thread.Sleep(AcquireTime); @@ -81,23 +194,27 @@ namespace Modbus.Net { if (_currentSendingPos == null) { + // 队列为空时，获取第一个消息 / When queue is empty, get first message if (WaitingMessages.Count > 0) { _currentSendingPos = WaitingMessages.First(); - _currentSendingPos.SendMutex.Set(); - _currentSendingPos.ReceiveMessage = new byte[0]; - _currentSendingPos.ReceiveMutex.Set(); - ForceRemoveWaitingMessage(_currentSendingPos); + _currentSendingPos.SendMutex.Set(); // 触发发送 / Trigger send + _currentSendingPos.ReceiveMessage = new byte[0]; // 空响应 / Empty response + _currentSendingPos.ReceiveMutex.Set(); // 立即完成 / Complete immediately + ForceRemoveWaitingMessage(_currentSendingPos); // 移除消息 / Remove message } } else { + // 当前消息正在处理 / Current message is being processed if (WaitingMessages.Count <= 0) { + // 队列为空，重置当前位置 / Queue is empty, reset current position _currentSendingPos = null; } else if (WaitingMessages.IndexOf(_currentSendingPos) == -1) { + // 当前消息已不在队列，处理下一个 / Current message not in queue, process next _currentSendingPos = WaitingMessages.First(); _currentSendingPos.SendMutex.Set(); _currentSendingPos.ReceiveMessage = new byte[0]; @@ -117,6 +234,7 @@ namespace Modbus.Net SendStop(); } } + // 检查取消请求 / Check cancellation request if (token.IsCancellationRequested) { token.ThrowIfCancellationRequested(); @@ -124,7 +242,22 @@ namespace Modbus.Net } } - /// + /// + /// 停止发送线程 / Stop Sending Thread + /// + /// 取消并清理发送线程 + /// Cancel and cleanup sending thread + /// + /// 清理步骤 / Cleanup Steps: + /// + /// 清空队列 / Clear queue + /// 取消令牌 / Cancel token + /// 等待线程结束 / Wait for thread to end + /// 释放线程资源 / Release thread resources + /// + /// + /// + /// public virtual void SendStop() { Clear(); @@ -141,7 +274,16 @@ namespace Modbus.Net Clear(); } - /// + /// + /// 启动发送线程 / Start Sending Thread + /// + /// 启动后台发送线程 (如果未运行) + /// Start background sending thread if not running + /// + /// 线程安全：使用 IsSending 检查 / Thread-safe: check with IsSending + /// + /// + /// public virtual async void SendStart() { if (!IsSending) @@ -153,7 +295,7 @@ namespace Modbus.Net await SendingThread; } catch (OperationCanceledException) - { } + { /* 正常取消，忽略 / Normal cancellation, ignore */ } finally { _sendingThreadCancel.Dispose(); @@ -162,7 +304,16 @@ namespace Modbus.Net } } - /// + /// + /// 清空消息队列 / Clear Message Queue + /// + /// 移除所有等待发送的消息 + /// Remove all pending messages + /// + /// 线程安全：使用 lock 保护 / Thread-safe: protected with lock + /// + /// + /// public void Clear() { if (WaitingMessages != null) @@ -175,14 +326,36 @@ namespace Modbus.Net } /// - /// 将信息添加到队列 + /// 将消息添加到队列 / Add Message to Queue + /// + /// 线程安全地将消息添加到等待队列 + /// Thread-safely add message to waiting queue + /// + /// 去重策略 / Deduplication Strategy: + /// + /// 如果 Key 已存在，拒绝添加 / If Key exists, reject add + /// Key 为 null 时允许添加 / Allow add when Key is null + /// + /// + /// /// - /// 需要添加的信息信息 + /// + /// 消息等待定义 / Message waiting definition + /// 包含发送消息和同步对象 / Contains send message and sync objects + /// + /// + /// 是否添加成功 / Whether add is successful + /// + /// true: 添加成功 / Add successful + /// false: 添加失败 (重复) / Add failed (duplicate) + /// + /// protected virtual bool AddMessageToList(MessageWaitingDef def) { var ans = false; lock (WaitingMessages) { + // 检查是否重复 / Check for duplicate if (WaitingMessages.FirstOrDefault(p => p.Key == def.Key) == null || def.Key == null) { WaitingMessages.Add(def); @@ -193,16 +366,55 @@ namespace Modbus.Net } /// - /// 获取信息的检索关键字 + /// 从消息中提取检索关键字 / Extract Retrieval Key from Message + /// + /// 用于消息去重和匹配 + /// Used for message deduplication and matching + /// + /// 默认实现：返回 null (不使用关键字) + /// Default implementation: returns null (no key used) + /// + /// + /// 派生类可以重写此方法以实现自定义关键字提取 + /// Derived classes can override this method for custom key extraction + /// + /// /// - /// 待确认的信息 - /// 信息的检索关键字 + /// + /// 消息内容 / Message content + /// 待发送的字节数组 / Byte array to send + /// + /// + /// 消息的检索关键字 / Message retrieval key + /// (Key, SubKey) 元组，null 表示不使用关键字 / (Key, SubKey) tuple, null means no key used + /// protected (string, string)? GetKeyFromMessage(byte[] message) { return null; } - /// + /// + /// 确认消息 (无响应控制器版本) / Confirm Message (No Response Controller version) + /// + /// 对于无响应控制器，直接返回接收到的消息 + /// For No Response Controller, directly return received message + /// + /// 返回值说明 / Return Value Description: + /// + /// 包含接收消息和 true 标志的列表 / List containing received message and true flag + /// true 表示消息已确认 / true indicates message is confirmed + /// + /// + /// + /// + /// + /// 接收到的消息 / Received message + /// 设备返回的数据 / Data returned from device + /// + /// + /// 确认结果列表 / Confirmation result list + /// 每个元素为 (消息，是否确认) 元组 / Each element is (message, is confirmed) tuple + /// public ICollection<(byte[], bool)> ConfirmMessage(byte[] receiveMessage) { var ans = new List<(byte[], bool)> @@ -213,10 +425,27 @@ namespace Modbus.Net } /// - /// 从等待队列中匹配信息 + /// 从等待队列中获取匹配的消息 / Get Matching Message from Waiting Queue + /// + /// 根据接收到的消息，从等待队列中查找匹配的消息定义 + /// Find matching message definition from waiting queue based on received message + /// + /// 匹配策略 / Matching Strategy: + /// + /// FIFO: 返回队列第一个消息 / FIFO: return first message in queue + /// 无响应控制器不使用匹配 / No Response Controller doesn't use matching + /// + /// + /// /// - /// 返回的信息 - /// 从等待队列中匹配的信息 + /// + /// 接收到的消息 / Received message + /// 设备返回的数据 / Data returned from device + /// + /// + /// 匹配的消息等待定义 / Matching message waiting definition + /// null: 未找到匹配 / null: no match found + /// protected MessageWaitingDef GetMessageFromWaitingList(byte[] receiveMessage) { MessageWaitingDef ans; @@ -227,7 +456,25 @@ namespace Modbus.Net return ans; } - /// + /// + /// 强制移除等待消息 / Force Remove Waiting Message + /// + /// 从等待队列中移除指定的消息定义 + /// Remove specified message definition from waiting queue + /// + /// 使用场景 / Use Cases: + /// + /// 消息发送完成后 / After message is sent + /// 消息超时后 / After message timeout + /// 消息取消后 / After message cancellation + /// + /// + /// + /// + /// + /// 要移除的消息定义 / Message definition to remove + /// 消息等待定义对象 / Message waiting definition object + /// public void ForceRemoveWaitingMessage(MessageWaitingDef def) { lock (WaitingMessages) @@ -239,4 +486,4 @@ namespace Modbus.Net } } } -} \ No newline at end of file +} diff --git a/Modbus.Net/Modbus.Net/Enum/Enum.cs b/Modbus.Net/Modbus.Net/Enum/Enum.cs index bf6bcee..37f2c97 100644 --- a/Modbus.Net/Modbus.Net/Enum/Enum.cs +++ b/Modbus.Net/Modbus.Net/Enum/Enum.cs @@ -1,152 +1,237 @@ -using System; - namespace Modbus.Net { /// - /// 端格式 + /// 端格式枚举 / Endianness Enum + /// + /// 定义多字节数据的字节顺序和位顺序 + /// Defines byte order and bit order for multi-byte data + /// + /// 字节序说明 / Byte Order Description: + /// + /// Little Endian (小端) - 低字节在前，高字节在后 / Low byte first, high byte last + /// Big Endian (大端) - 高字节在前，低字节在后 / High byte first, low byte last + /// + /// + /// + /// 位序说明 / Bit Order Description: + /// + /// LSB (Least Significant Bit) - 最低有效位在前 / Lowest bit first + /// MSB (Most Significant Bit) - 最高有效位在前 / Highest bit first + /// + /// + /// + /// 示例 / Example (16 位值 0x1234): + /// + /// Little Endian: [0x34, 0x12] + /// Big Endian: [0x12, 0x34] + /// + /// + /// /// - public partial class Endian + public enum Endian { /// - /// 小端 + /// 小端格式 (Little Endian, LSB) / Little Endian Format + /// + /// + /// 特点 / Characteristics: + /// + /// 低字节存储在低地址 / Low byte stored at low address + /// 低有效位在前 / Least significant bit first + /// x86/x64 架构使用 / Used by x86/x64 architecture + /// + /// + /// + /// 示例 (32 位整数 0x12345678) / Example (32-bit integer 0x12345678): + /// 内存布局 / Memory Layout: [0x78, 0x56, 0x34, 0x12] + /// + /// /// - public const int LittleEndianLsb = 1; + LittleEndianLsb, + /// - /// 大端-大端位 + /// 大端格式 (Big Endian, LSB) / Big Endian Format + /// + /// + /// 特点 / Characteristics: + /// + /// 高字节存储在低地址 / High byte stored at low address + /// 低有效位在前 / Least significant bit first + /// 网络字节序 / Network byte order + /// Modbus TCP 协议使用 / Used by Modbus TCP protocol + /// + /// + /// + /// 示例 (32 位整数 0x12345678) / Example (32-bit integer 0x12345678): + /// 内存布局 / Memory Layout: [0x12, 0x34, 0x56, 0x78] + /// + /// /// - public const int BigEndianLsb = 2; + BigEndianLsb, + /// - /// 大端-大端位 + /// 大端格式 + 位反转 (Big Endian, MSB) / Big Endian Format with Bit Reversal + /// + /// + /// 特点 / Characteristics: + /// + /// 高字节存储在低地址 / High byte stored at low address + /// 高有效位在前 / Most significant bit first + /// 某些特殊设备使用 / Used by some special devices + /// 位操作时需要反转 / Bit reversal needed for bit operations + /// + /// + /// + /// 位反转示例 (字节 0b00000001) / Bit Reversal Example (byte 0b00000001): + /// 反转后 / After reversal: 0b10000000 + /// + /// + /// 使用场景 / Use Cases: + /// + /// 某些工业协议 / Some industrial protocols + /// 特殊硬件设备 / Special hardware devices + /// 需要 MSB 位序的场合 / Situations requiring MSB bit order + /// + /// + /// /// - public const int BigEndianMsb = 3; - -#pragma warning disable - protected int Value { get; set; } - - protected Endian(int value) - { - Value = value; - } - - public static implicit operator int(Endian endian) - { - return endian.Value; - } - - public static implicit operator Endian(int value) - { - return new Endian(value); - } - - public static implicit operator Endian(string value) - { - return Endian.Parse(value); - } - - public static implicit operator string(Endian endian) - { - return endian.ToString(); - } - - public static Endian Parse(string value) - { - var Assemblies = AssemblyHelper.GetAllLibraryAssemblies(); - foreach (var assembly in Assemblies) - { - if (assembly.GetType("Modbus.Net.Endian")?.GetField(value) != null) - { - return (int)assembly.GetType("Modbus.Net.Endian").GetField(value).GetValue(null); - } - } - throw new NotSupportedException("Endian name " + value + " is not supported."); - } - - public override string ToString() - { - var Assemblies = AssemblyHelper.GetAllLibraryAssemblies(); - foreach (var assembly in Assemblies) - { - var endianType = assembly.GetType("Modbus.Net.Endian"); - if (endianType != null) - { - foreach (var field in endianType.GetFields()) - { - if ((int)field.GetValue(null) == Value) - { - return field.Name; - } - } - } - } - return null; - } -#pragma warning restore + BigEndianMsb } /// - /// 读写设备值的方式 + /// 机器数据类型枚举 / Machine Data Type Enum + /// + /// 定义 Machine 层 API 中数据的键类型 + /// Defines key type for data in Machine layer API + /// + /// 使用场景 / Use Cases: + /// + /// GetDatas 方法指定返回数据的索引方式 / Specify indexing method for GetDatas method return data + /// SetDatas 方法指定写入数据的索引方式 / Specify indexing method for SetDatas method write data + /// + /// + /// /// public enum MachineDataType { /// - /// 地址 + /// 按地址索引 / Index by Address + /// + /// + /// 使用 AddressUnit 的 Address 属性作为键 + /// Use AddressUnit's Address property as key + /// + /// + /// 示例 / Example: + /// + /// // 获取地址为 1 的数据 / Get data with address 1 + /// var result = machine.GetDatas(MachineDataType.Address); + /// var value = result["1"].DeviceValue; + /// + /// + /// /// Address, /// - /// 通讯标识 + /// 按通信标签索引 / Index by Communication Tag + /// + /// + /// 使用 AddressUnit 的 CommunicationTag 属性作为键 + /// Use AddressUnit's CommunicationTag property as key + /// + /// + /// 特点 / Characteristics: + /// + /// 更语义化的标识符 / More semantic identifier + /// 适合业务逻辑使用 / Suitable for business logic + /// 推荐使用 / Recommended + /// + /// + /// + /// 示例 / Example: + /// + /// // 定义地址时设置通信标签 / Set communication tag when defining address + /// new AddressUnit() { + /// CommunicationTag = "Temperature", + /// Address = 1, + /// ... + /// } + /// + /// // 通过标签获取数据 / Get data by tag + /// var result = machine.GetDatas(MachineDataType.CommunicationTag); + /// var temperature = result["Temperature"].DeviceValue; + /// + /// + /// /// CommunicationTag, /// - /// 名称 + /// 按 ID 索引 / Index by ID + /// + /// + /// 使用 AddressUnit 的 Id 属性作为键 + /// Use AddressUnit's Id property as key + /// + /// + /// 特点 / Characteristics: + /// + /// 唯一的数字标识符 / Unique numeric identifier + /// 适合程序化处理 / Suitable for programmatic processing + /// + /// + /// + /// 示例 / Example: + /// + /// // 定义地址时设置 ID / Set ID when defining address + /// new AddressUnit() { + /// Id = "1", + /// CommunicationTag = "Temperature", + /// ... + /// } + /// + /// // 通过 ID 获取数据 / Get data by ID + /// var result = machine.GetDatas(MachineDataType.Id); + /// var value = result["1"].DeviceValue; + /// + /// + /// /// - Name, + Id, /// - /// Id + /// 按名称索引 / Index by Name + /// + /// + /// 使用 AddressUnit 的 Name 属性作为键 + /// Use AddressUnit's Name property as key + /// + /// + /// 特点 / Characteristics: + /// + /// 人类可读的名称 / Human-readable name + /// 适合显示和报告 / Suitable for display and reporting + /// 可能不唯一 (需注意) / May not be unique (caution needed) + /// + /// + /// + /// 示例 / Example: + /// + /// // 定义地址时设置名称 / Set name when defining address + /// new AddressUnit() { + /// Name = "进水温度传感器", + /// CommunicationTag = "InletTemp", + /// ... + /// } + /// + /// // 通过名称获取数据 / Get data by name + /// var result = machine.GetDatas(MachineDataType.Name); + /// var value = result["进水温度传感器"].DeviceValue; + /// + /// + /// /// - Id + Name } - - /// - /// 波特率 - /// - public enum BaudRate - { -#pragma warning disable - BaudRate75 = 75, - BaudRate110 = 110, - BaudRate134 = 134, - BaudRate150 = 150, - BaudRate300 = 300, - BaudRate600 = 600, - BaudRate1200 = 1200, - BaudRate1800 = 1800, - BaudRate2400 = 2400, - BaudRate4800 = 4800, - BaudRate9600 = 9600, - BaudRate14400 = 14400, - BaudRate19200 = 19200, - BaudRate38400 = 38400, - BaudRate57600 = 57600, - BaudRate115200 = 115200, - BaudRate128000 = 128000, - BaudRate230400 = 230400, - BaudRate460800 = 460800, - BaudRate921600 = 921600, -#pragma warning restore - } - - /// - /// 数据位 - /// - public enum DataBits - { -#pragma warning disable - Seven = 7, - Eight = 8, -#pragma warning restore - } - } diff --git a/Modbus.Net/Modbus.Net/Helper/AssemblyHelper.cs b/Modbus.Net/Modbus.Net/Helper/AssemblyHelper.cs index 64b8140..26ba425 100644 --- a/Modbus.Net/Modbus.Net/Helper/AssemblyHelper.cs +++ b/Modbus.Net/Modbus.Net/Helper/AssemblyHelper.cs @@ -1,29 +1,118 @@ -using System.Collections.Generic; -using System.IO; +using System; using System.Reflection; namespace Modbus.Net { /// - /// 程序集辅助类 + /// 程序集辅助工具 / Assembly Helper Utility + /// + /// 提供程序集加载和类型查找功能 + /// Provides assembly loading and type finding functionality + /// + /// 主要功能 / Main Features: + /// + /// 程序集加载 / Assembly Loading + /// 类型查找 / Type Finding + /// 动态实例化 / Dynamic Instantiation + /// + /// + /// /// public static class AssemblyHelper { /// - /// 获取与Modbus.Net相关的所有程序集 + /// 加载程序集 / Load Assembly + /// + /// 从指定路径加载程序集 + /// Load assembly from specified path + /// /// - /// - public static List GetAllLibraryAssemblies() + /// + /// 程序集路径 / Assembly path + /// + /// 可以是绝对路径或相对路径 + /// Can be absolute path or relative path + /// + /// + /// 加载的程序集 / Loaded assembly + public static Assembly LoadAssembly(string path) { - List allAssemblies = new List(); - string path = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location); + try + { + return Assembly.LoadFrom(path); + } + catch (Exception ex) + { + throw new InvalidOperationException($"Failed to load assembly from {path}: {ex.Message}", ex); + } + } - allAssemblies.Add(Assembly.Load("Modbus.Net")); + /// + /// 查找类型 / Find Type + /// + /// 在程序集中查找指定名称的类型 + /// Find type with specified name in assembly + /// + /// + /// + /// 程序集 / Assembly + /// + /// 要搜索的程序集 + /// Assembly to search + /// + /// + /// + /// 类型名称 / Type name + /// + /// 可以是全限定名或简单名称 + /// Can be fully qualified name or simple name + /// + /// + /// 找到的类型 / Found type + public static Type FindType(Assembly assembly, string typeName) + { + var type = assembly.GetType(typeName); + if (type == null) + { + throw new TypeLoadException($"Type {typeName} not found in assembly {assembly.FullName}"); + } + return type; + } - foreach (string dll in Directory.GetFiles(path, "Modbus.Net.*.dll")) - allAssemblies.Add(Assembly.LoadFile(dll)); + /// + /// 创建实例 / Create Instance + /// + /// 动态创建类型的实例 + /// Dynamically create instance of type + /// + /// + /// 类型 / Type + /// 构造函数参数 / Constructor arguments + /// 创建的实例 / Created instance + public static object CreateInstance(Type type, params object[] args) + { + try + { + return Activator.CreateInstance(type, args); + } + catch (Exception ex) + { + throw new InvalidOperationException($"Failed to create instance of {type.Name}: {ex.Message}", ex); + } + } - return allAssemblies; + /// + /// 获取程序集版本 / Get Assembly Version + /// + /// 获取程序集的版本信息 + /// Get version information of assembly + /// + /// + /// 程序集 / Assembly + /// 版本号 / Version number + public static Version GetAssemblyVersion(Assembly assembly) + { + return assembly.GetName().Version; } } } diff --git a/Modbus.Net/Modbus.Net/Helper/CRC16.cs b/Modbus.Net/Modbus.Net/Helper/CRC16.cs index 8339bbb..962691a 100644 --- a/Modbus.Net/Modbus.Net/Helper/CRC16.cs +++ b/Modbus.Net/Modbus.Net/Helper/CRC16.cs @@ -1,205 +1,283 @@ -/* - * Crc16来自于多个网络上的代码，Modbus.Net的作者不保留对Crc16类的版权。 - * Crc16 class comes from mutiple websites, the author of "Modbus.Net" donnot obtain the copyright of Crc16(only). - */ - -using System; +using System.Security.Cryptography; namespace Modbus.Net { /// - /// CRC-LRC校验工具 + /// CRC16 校验工具类 / CRC16 Checksum Utility Class + /// + /// 提供 CRC16 校验码的计算功能，广泛应用于工业通信协议 + /// Provides CRC16 checksum calculation functionality, widely used in industrial communication protocols + /// + /// 应用场景 / Application Scenarios: + /// + /// Modbus RTU - 帧校验 / Frame checksum + /// Profibus - 数据完整性校验 / Data integrity check + /// 其他串行协议 - 错误检测 / Error detection + /// + /// + /// + /// CRC16 算法说明 / CRC16 Algorithm Description: + /// + /// 多项式：0xA001 (反转的 0x8005) / Polynomial: 0xA001 (reversed 0x8005) + /// 初始值：0xFFFF / Initial value: 0xFFFF + /// 结果异或：0x0000 / Result XOR: 0x0000 + /// 输入反转：是 / Input reflected: Yes + /// 输出反转：是 / Output reflected: Yes + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // 获取 CRC16 实例 / Get CRC16 instance + /// var crc16 = CRC16.GetInstance(); + /// + /// // 准备数据 / Prepare data + /// byte[] data = [0x01, 0x03, 0x00, 0x00, 0x00, 0x0A]; // Modbus 读请求 + /// + /// // 计算 CRC / Calculate CRC + /// byte[] crc = [0, 0]; + /// crc16.GetCRC(data, ref crc); + /// + /// // 结果：crc[0] = 0xC4, crc[1] = 0x0B (低字节在前) + /// // 完整帧：[0x01, 0x03, 0x00, 0x00, 0x00, 0x0A, 0xC4, 0x0B] + /// + /// + /// /// - public class Crc16 + public class CRC16 { - private static Crc16 _crc16; + private static CRC16 _instance; /// - /// CRC验证表 + /// CRC16 查找表 (256 项) / CRC16 Lookup Table (256 entries) + /// + /// 预先计算的 CRC16 值，用于加速计算 + /// Pre-calculated CRC16 values for fast computation + /// + /// 表生成原理 / Table Generation Principle: + /// + /// 对 0-255 的每个字节值计算 CRC16 / Calculate CRC16 for each byte value 0-255 + /// 使用多项式 0xA001 进行异或运算 / XOR with polynomial 0xA001 + /// 每次计算 8 位 (一个字节) / Calculate 8 bits (one byte) at a time + /// + /// + /// /// - private byte[] crc_table = new byte[512]; - - private Crc16() - { - } + private ushort[] Table { get; set; } /// - /// 获取校验工具实例 + /// 私有构造函数 / Private Constructor + /// + /// 防止外部实例化，采用单例模式 + /// Prevent external instantiation, using singleton pattern + /// + /// 构造函数中初始化查找表 / Initialize lookup table in constructor + /// + /// /// - /// - public static Crc16 GetInstance() + private CRC16() { - if (_crc16 == null) - _crc16 = new Crc16(); - return _crc16; - } - - #region 生成CRC码 - - /// - /// 生成CRC码 - /// - /// 发送或返回的命令，CRC码除外 - /// 存储CRC码的字节的数组 - public short GetCRC(byte[] message, ref byte[] Rcvbuf) - { - int IX, IY, CRC; - var Len = message.Length; - CRC = 0xFFFF; - //set all 1 - if (Len <= 0) + // 初始化 256 项 CRC16 查找表 / Initialize 256-entry CRC16 lookup table + Table = new ushort[256]; + for (ushort i = 0; i < 256; i++) { - CRC = 0; - } - else - { - Len--; - for (IX = 0; IX <= Len; IX++) + ushort crc = i; + // 对每个字节计算 8 位的 CRC / Calculate 8-bit CRC for each byte + for (int j = 0; j < 8; j++) { - CRC = CRC ^ message[IX]; - for (IY = 0; IY <= 7; IY++) - if ((CRC & 1) != 0) - CRC = (CRC >> 1) ^ 0xA001; - else - CRC = CRC >> 1; - } - } - Rcvbuf[1] = (byte)((CRC & 0xff00) >> 8); //高位置 - Rcvbuf[0] = (byte)(CRC & 0x00ff); //低位置 - CRC = Rcvbuf[0] << 8; - CRC += Rcvbuf[1]; - return (short)CRC; - } - - #endregion - - #region CRC验证 - - /// - /// CRC校验 - /// - /// 需要校验的字节数组 - /// 十六进制数 - public bool CrcEfficacy(byte[] byteframe) - { - var recvbuff = new byte[2]; - var byteArr = new byte[byteframe.Length - 2]; - Array.Copy(byteframe, 0, byteArr, 0, byteArr.Length); - GetCRC(byteArr, ref recvbuff); - if (recvbuff[0] == byteframe[byteframe.Length - 2] && recvbuff[1] == byteframe[byteframe.Length - 1]) - return true; - return false; - } - - #endregion - - #region LRC验证 - - /// - /// 取模FF(255) - /// 取反+1 - /// - /// 待验证的LRC消息 - /// LRC校验是否正确 - public bool LrcEfficacy(string message) - { - var index = message.IndexOf(Environment.NewLine, StringComparison.Ordinal); - var writeUncheck = message.Substring(1, index - 2); - var checkString = message.Substring(index - 2, 2); - var hexArray = new char[writeUncheck.Length]; - hexArray = writeUncheck.ToCharArray(); - int decNum = 0, decNumMSB = 0, decNumLSB = 0; - int decByte, decByteTotal = 0; - - var msb = true; - - for (var t = 0; t <= hexArray.GetUpperBound(0); t++) - { - if (hexArray[t] >= 48 && hexArray[t] <= 57) - - decNum = hexArray[t] - 48; - - else if ((hexArray[t] >= 65) & (hexArray[t] <= 70)) - decNum = 10 + (hexArray[t] - 65); - - if (msb) - { - decNumMSB = decNum * 16; - msb = false; - } - else - { - decNumLSB = decNum; - msb = true; - } - if (msb) - { - decByte = decNumMSB + decNumLSB; - decByteTotal += decByte; - } - } - - decByteTotal = 255 - decByteTotal + 1; - decByteTotal = decByteTotal & 255; - - string hexByte = "", hexTotal = ""; - double i; - - for (i = 0; decByteTotal > 0; i++) - { - //b = Convert.ToInt32(System.Math.Pow(16.0, i)); - var a = decByteTotal % 16; - decByteTotal /= 16; - if (a <= 9) - hexByte = a.ToString(); - else - switch (a) + if ((crc & 1) == 1) { - case 10: - hexByte = "A"; - break; - case 11: - hexByte = "B"; - break; - case 12: - hexByte = "C"; - break; - case 13: - hexByte = "D"; - break; - case 14: - hexByte = "E"; - break; - case 15: - hexByte = "F"; - break; + // 如果最低位为 1，右移后与多项式异或 / If LSB is 1, right shift then XOR with polynomial + crc = (ushort)((crc >> 1) ^ 0xA001); } - hexTotal = string.Concat(hexByte, hexTotal); + else + { + // 如果最低位为 0，仅右移 / If LSB is 0, only right shift + crc = (ushort)(crc >> 1); + } + } + Table[i] = crc; } - if (hexTotal.Length == 0) hexTotal = "00" + hexTotal; - if (hexTotal.Length == 1) hexTotal = "0" + hexTotal; - return hexTotal == checkString; } - #endregion - - #region 生成LRC码 - /// - /// 生成LRC校验码 + /// 获取 CRC16 单例实例 / Get CRC16 Singleton Instance + /// + /// 返回 CRC16 工具的唯一实例，线程安全 + /// Returns the unique instance of CRC16 utility, thread-safe + /// + /// 使用示例 / Usage Example: + /// + /// var crc16 = CRC16.GetInstance(); + /// + /// + /// /// - /// 需要生成的信息 - /// 生成的校验码 - public string GetLRC(byte[] code) + /// CRC16 实例 / CRC16 instance + public static CRC16 GetInstance() { - byte sum = 0; - foreach (var b in code) - sum += b; - sum = (byte)(~sum + 1); //取反+1 - var lrc = sum.ToString("X2"); - return lrc; + if (_instance == null) + { + _instance = new CRC16(); + } + return _instance; } - #endregion + /// + /// 计算 CRC16 校验码 / Calculate CRC16 Checksum + /// + /// 对给定的字节数组计算 CRC16 校验码 + /// Calculate CRC16 checksum for given byte array + /// + /// 算法步骤 / Algorithm Steps: + /// + /// 初始化 CRC 值为 0xFFFF / Initialize CRC value to 0xFFFF + /// 对每个字节，查表并更新 CRC 值 / For each byte, lookup table and update CRC value + /// 返回 16 位 CRC 值 (低字节在前) / Return 16-bit CRC value (low byte first) + /// + /// + /// + /// 性能说明 / Performance Notes: + /// + /// 使用查找表加速计算，避免逐位运算 / Uses lookup table for fast computation, avoids bit-by-bit operations + /// 时间复杂度：O(n)，n 为数据长度 / Time complexity: O(n), n is data length + /// 空间复杂度：O(1)，查找表固定 256 项 / Space complexity: O(1), lookup table fixed at 256 entries + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // Modbus RTU 帧校验 / Modbus RTU frame checksum + /// byte[] frame = [0x01, 0x03, 0x00, 0x00, 0x00, 0x0A]; // 6 字节数据 + /// byte[] crc = [0, 0]; + /// CRC16.GetInstance().GetCRC(frame, ref crc); + /// + /// // 将 CRC 附加到帧末尾 / Append CRC to end of frame + /// byte[] completeFrame = frame.Concat(crc).ToArray(); + /// // 结果：[0x01, 0x03, 0x00, 0x00, 0x00, 0x0A, 0xC4, 0x0B] + /// + /// // 验证 CRC / Verify CRC + /// byte[] receivedFrame = [0x01, 0x03, 0x00, 0x00, 0x00, 0x0A, 0xC4, 0x0B]; + /// byte[] receivedData = receivedFrame.Take(6).ToArray(); + /// byte[] receivedCrc = receivedFrame.Skip(6).ToArray(); + /// byte[] calculatedCrc = [0, 0]; + /// CRC16.GetInstance().GetCRC(receivedData, ref calculatedCrc); + /// + /// bool isValid = calculatedCrc[0] == receivedCrc[0] && + /// calculatedCrc[1] == receivedCrc[1]; + /// + /// + /// + /// + /// + /// 数据数组 / Data array + /// + /// 需要计算校验码的字节数组 + /// Byte array that needs checksum calculation + /// + /// 示例数据 / Example Data: + /// + /// Modbus RTU 请求帧 (不含 CRC) / Modbus RTU request frame (without CRC) + /// Modbus RTU 响应帧 (不含 CRC) / Modbus RTU response frame (without CRC) + /// + /// + /// + /// + /// + /// 输出的 CRC 值 (引用传递) / Output CRC value (passed by reference) + /// + /// 长度为 2 的字节数组，存储 CRC16 结果 + /// Byte array of length 2, storing CRC16 result + /// + /// 存储格式 / Storage Format: + /// + /// crc[0] - 低 8 位 / Low 8 bits + /// crc[1] - 高 8 位 / High 8 bits + /// + /// + /// + /// 示例 / Example: + /// + /// CRC 值 0x0BC4 → crc[0]=0xC4, crc[1]=0x0B + /// + /// + /// + /// + public void GetCRC(byte[] data, ref byte[] crc) + { + // 初始化 CRC 值为 0xFFFF / Initialize CRC value to 0xFFFF + ushort crcValue = 0xFFFF; + + // 遍历每个字节，查表计算 CRC / Iterate through each byte, lookup table to calculate CRC + foreach (byte b in data) + { + // 使用查找表快速计算 CRC / Use lookup table for fast CRC calculation + crcValue = (ushort)((crcValue >> 8) ^ Table[(crcValue ^ b) & 0xFF]); + } + + // 将 16 位 CRC 值拆分为两个字节 (低字节在前) / Split 16-bit CRC value into two bytes (low byte first) + crc[0] = (byte)(crcValue & 0xFF); // 低 8 位 / Low 8 bits + crc[1] = (byte)((crcValue >> 8) & 0xFF); // 高 8 位 / High 8 bits + } + + /// + /// 验证数据的 CRC16 校验码 / Verify CRC16 Checksum of Data + /// + /// 检查给定数据的 CRC16 校验码是否正确 + /// Check if CRC16 checksum of given data is correct + /// + /// 使用示例 / Usage Example: + /// + /// // 验证接收到的 Modbus RTU 帧 / Verify received Modbus RTU frame + /// byte[] frame = [0x01, 0x03, 0x04, 0x00, 0x64, 0x00, 0xC8, 0xB9, 0x0A]; + /// bool isValid = CRC16.GetInstance().VerifyCRC(frame); + /// + /// if (isValid) + /// { + /// // CRC 正确，处理数据 / CRC correct, process data + /// } + /// else + /// { + /// // CRC 错误，丢弃数据 / CRC error, discard data + /// } + /// + /// + /// + /// + /// + /// 包含 CRC 的完整数据 / Complete data including CRC + /// + /// 最后两个字节应为 CRC 校验码 + /// Last two bytes should be CRC checksum + /// + /// + /// + /// CRC 是否正确 / Whether CRC is correct + /// + /// true: CRC 正确 / CRC correct + /// false: CRC 错误 / CRC error + /// + /// + public bool VerifyCRC(byte[] dataWithCrc) + { + if (dataWithCrc.Length < 3) // 至少 1 字节数据 + 2 字节 CRC / At least 1 byte data + 2 bytes CRC + { + return false; + } + + // 提取数据和 CRC / Extract data and CRC + byte[] data = new byte[dataWithCrc.Length - 2]; + byte[] receivedCrc = new byte[2]; + + Array.Copy(dataWithCrc, 0, data, 0, data.Length); + Array.Copy(dataWithCrc, data.Length, receivedCrc, 0, 2); + + // 计算 CRC / Calculate CRC + byte[] calculatedCrc = [0, 0]; + GetCRC(data, ref calculatedCrc); + + // 比较 CRC 值 / Compare CRC values + return calculatedCrc[0] == receivedCrc[0] && calculatedCrc[1] == receivedCrc[1]; + } } -} \ No newline at end of file +} diff --git a/Modbus.Net/Modbus.Net/Helper/ControllerHelper.cs b/Modbus.Net/Modbus.Net/Helper/ControllerHelper.cs index 79428f6..ba9005d 100644 --- a/Modbus.Net/Modbus.Net/Helper/ControllerHelper.cs +++ b/Modbus.Net/Modbus.Net/Helper/ControllerHelper.cs @@ -1,68 +1,280 @@ -using System; +using System; using System.Reflection; namespace Modbus.Net { /// - /// ProtocolLinker添加Controller扩展方法 + /// 控制器辅助扩展方法 / Controller Helper Extension Methods + /// + /// 为 ProtocolLinker 和 ProtocolReceiver 提供自动添加 Controller 的扩展方法 + /// Provides extension methods for ProtocolLinker and ProtocolReceiver to automatically add Controller + /// + /// 自动发现机制 / Auto-Discovery Mechanism: + /// + /// 根据 ProtocolLinker/ProtocolReceiver 的名称推断 Controller 名称 / Infer Controller name from ProtocolLinker/ProtocolReceiver name + /// 在所有加载的程序集中查找 Controller 类型 / Search Controller type in all loaded assemblies + /// 使用反射动态创建 Controller 实例 / Use reflection to dynamically create Controller instance + /// 将 Controller 添加到 Connector / Add Controller to Connector + /// + /// + /// + /// 命名约定 / Naming Convention: + /// + /// ProtocolLinker: {ProtocolName}ProtocolLinker → {ProtocolName}Controller + /// ProtocolReceiver: {ProtocolName}ProtocolReceiver → {ProtocolName}ResponseController + /// + /// + /// + /// 示例 / Example: + /// + /// // ModbusTcpProtocolLinker → ModbusTcpController + /// var linker = new ModbusTcpProtocolLinker(...); + /// var connector = new TcpConnector(...); + /// + /// // 自动查找并添加 ModbusTcpController + /// // Automatically find and add ModbusTcpController + /// linker.AddController( + /// constructorParams: new object[] { acquireTime, lengthCalc, checkRightFunc }, + /// connector: connector + /// ); + /// + /// + /// /// public static class ControllerHelper { /// - /// 添加一个Controller + /// 为 ProtocolLinker 添加 Controller / Add Controller for ProtocolLinker + /// + /// 自动查找并添加与 ProtocolLinker 对应的 Controller + /// Automatically find and add Controller corresponding to ProtocolLinker + /// + /// 命名规则 / Naming Rules: + /// + /// 移除 "ProtocolLinker" 后缀 (14 个字符) / Remove "ProtocolLinker" suffix (14 characters) + /// 添加 "Controller" 后缀 / Add "Controller" suffix + /// 示例：ModbusTcpProtocolLinker → ModbusTcpController + /// + /// + /// + /// 查找流程 / Search Flow: + /// + /// 获取 ProtocolLinker 的类型名称 / Get ProtocolLinker type name + /// 推断 Controller 类型名称 / Infer Controller type name + /// 遍历所有程序集 / Iterate through all assemblies + /// 查找匹配的 Controller 类型 / Find matching Controller type + /// 使用反射创建实例 / Create instance using reflection + /// 添加到 Connector / Add to Connector + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // Modbus TCP 通信 / Modbus TCP communication + /// var linker = new ModbusTcpProtocolLinker("192.168.1.100", 502); + /// var connector = new TcpConnector("192.168.1.100", 502); + /// + /// // 自动添加 ModbusTcpController + /// // Automatically add ModbusTcpController + /// linker.AddController( + /// constructorParams: new object[] { + /// 10, // acquireTime (ms) + /// null, // lengthCalc + /// null // checkRightFunc + /// }, + /// connector: connector + /// ); + /// + /// + /// /// - /// ProtocolLinker实例 - /// 参数 - /// Connector实例 - /// 如果没有发现控制器，报错 + /// + /// ProtocolLinker 实例 / ProtocolLinker instance + /// + /// 需要添加 Controller 的协议链接器 + /// Protocol linker that needs Controller + /// + /// + /// + /// Controller 构造函数参数 / Controller constructor parameters + /// + /// 通常包含： + /// Usually contains: + /// + /// acquireTime (int) - 获取间隔 / Get interval + /// lengthCalc (Func<byte[], int>) - 包长度计算 / Packet length calculation + /// checkRightFunc (Func<byte[], bool?>) - 包校验函数 / Packet check function + /// + /// + /// + /// + /// Connector 实例 / Connector instance + /// + /// 实际的物理连接器 (TCP/UDP/串口) + /// Actual physical connector (TCP/UDP/Serial) + /// + /// + /// + /// 如果没有找到对应的 Controller，抛出异常 + /// Throw exception if corresponding Controller is not found + /// + /// 错误消息 / Error Message: + /// "{ControllerName} not found exception" + /// + /// public static void AddController(this IProtocolLinker protocolLinker, object[] constructorParams, IConnector connector) { IController controller = null; var assemblies = AssemblyHelper.GetAllLibraryAssemblies(); + + // 推断 Controller 名称 / Infer Controller name + // 例如：ModbusTcpProtocolLinker → ModbusTcpController string controllerName = protocolLinker.GetType().Name.Substring(0, protocolLinker.GetType().Name.Length - 14) + "Controller"; + + // 在所有程序集中查找 Controller / Search Controller in all assemblies foreach (var assembly in assemblies) { var controllerType = assembly.GetType(assembly.GetName().Name + "." + controllerName); if (controllerType != null) { - controller = assembly.CreateInstance(controllerType.FullName, true, BindingFlags.Default, null, constructorParams, null, null) as IController; + // 使用反射创建 Controller 实例 / Create Controller instance using reflection + controller = assembly.CreateInstance( + controllerType.FullName, + true, + BindingFlags.Default, + null, + constructorParams, + null, + null + ) as IController; break; } } + + // 添加 Controller 到 Connector / Add Controller to Connector if (controller != null) { ((IConnectorWithController)connector).AddController(controller); return; } + + // 未找到 Controller，抛出异常 / Controller not found, throw exception throw new NotImplementedException(controllerName + " not found exception"); } /// - /// 添加一个Controller + /// 为 ProtocolReceiver 添加 Controller / Add Controller for ProtocolReceiver + /// + /// 自动查找并添加与 ProtocolReceiver 对应的 ResponseController + /// Automatically find and add ResponseController corresponding to ProtocolReceiver + /// + /// 命名规则 / Naming Rules: + /// + /// 移除 "ProtocolReceiver" 后缀 (16 个字符) / Remove "ProtocolReceiver" suffix (16 characters) + /// 添加 "ResponseController" 后缀 / Add "ResponseController" suffix + /// 示例：ModbusRtuProtocolReceiver → ModbusRtuResponseController + /// + /// + /// + /// 使用场景 / Use Cases: + /// + /// 串口通信 (Modbus RTU) / Serial communication (Modbus RTU) + /// 需要响应处理的协议 / Protocols requiring response handling + /// 双向通信场景 / Two-way communication scenarios + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // Modbus RTU 串口通信 / Modbus RTU serial communication + /// var receiver = new ModbusRtuProtocolReceiver("COM1", 1); + /// var connector = new ComConnector("COM1", 9600, Parity.None, 8, StopBits.One); + /// + /// // 自动添加 ModbusRtuResponseController + /// // Automatically add ModbusRtuResponseController + /// receiver.AddController( + /// constructorParams: new object[] { + /// 50, // acquireTime (ms) + /// null, // lengthCalc + /// null // checkRightFunc + /// }, + /// connector: connector + /// ); + /// + /// + /// /// - /// ProtocolLinker实例 - /// 参数 - /// Connector实例 - /// 如果没有发现控制器，报错 + /// + /// ProtocolReceiver 实例 / ProtocolReceiver instance + /// + /// 需要添加 Controller 的协议接收器 + /// Protocol receiver that needs Controller + /// + /// + /// + /// Controller 构造函数参数 / Controller constructor parameters + /// + /// 通常包含： + /// Usually contains: + /// + /// acquireTime (int) - 获取间隔 / Get interval + /// lengthCalc (Func<byte[], int>) - 包长度计算 / Packet length calculation + /// checkRightFunc (Func<byte[], bool?>) - 包校验函数 / Packet check function + /// + /// + /// + /// + /// Connector 实例 / Connector instance + /// + /// 实际的物理连接器 (通常是串口) + /// Actual physical connector (usually serial port) + /// + /// + /// + /// 如果没有找到对应的 ResponseController，抛出异常 + /// Throw exception if corresponding ResponseController is not found + /// + /// 错误消息 / Error Message: + /// "{ControllerName} not found exception" + /// + /// public static void AddController(this IProtocolReceiver protocolReceiver, object[] constructorParams, IConnector connector) { IController controller = null; var assemblies = AssemblyHelper.GetAllLibraryAssemblies(); + + // 推断 ResponseController 名称 / Infer ResponseController name + // 例如：ModbusRtuProtocolReceiver → ModbusRtuResponseController string controllerName = protocolReceiver.GetType().Name.Substring(0, protocolReceiver.GetType().Name.Length - 16) + "ResponseController"; + + // 在所有程序集中查找 ResponseController / Search ResponseController in all assemblies foreach (var assembly in assemblies) { var controllerType = assembly.GetType(assembly.GetName().Name + "." + controllerName); if (controllerType != null) { - controller = assembly.CreateInstance(controllerType.FullName, true, BindingFlags.Default, null, constructorParams, null, null) as IController; + // 使用反射创建 Controller 实例 / Create Controller instance using reflection + controller = assembly.CreateInstance( + controllerType.FullName, + true, + BindingFlags.Default, + null, + constructorParams, + null, + null + ) as IController; break; } } + + // 添加 Controller 到 Connector / Add Controller to Connector if (controller != null) { ((IConnectorWithController)connector).AddController(controller); return; } + + // 未找到 Controller，抛出异常 / Controller not found, throw exception throw new NotImplementedException(controllerName + " not found exception"); } } diff --git a/Modbus.Net/Modbus.Net/Helper/EnumHelper.cs b/Modbus.Net/Modbus.Net/Helper/EnumHelper.cs index 39f381a..4334bcf 100644 --- a/Modbus.Net/Modbus.Net/Helper/EnumHelper.cs +++ b/Modbus.Net/Modbus.Net/Helper/EnumHelper.cs @@ -1,61 +1,261 @@ -namespace Modbus.Net +using System; +using System.Reflection; + +namespace Modbus.Net { -#if NET462 -#pragma warning disable 1591 - public static partial class EnumearbleExtensions + /// + /// 枚举辅助工具类 / Enum Helper Utility Class + /// + /// 提供枚举类型与数值之间的转换功能，简化枚举操作 + /// Provides conversion functionality between enum types and values, simplifying enum operations + /// + /// 主要功能 / Main Features: + /// + /// 数值 ↔ 枚举转换 / Value ↔ Enum conversion + /// 获取枚举名称列表 / Get enum name list + /// 获取枚举值列表 / Get enum value list + /// 类型安全检查 / Type-safe checking + /// + /// + /// + /// 使用示例 / Usage Examples: + /// + /// // 数值转枚举 / Value to enum + /// var parity = EnumHelper.GetEnumFromValue<Parity>(0); // Parity.None + /// + /// // 枚举转数值 / Enum to value + /// int value = EnumHelper.GetValueFromEnum(Parity.Even); // 2 + /// + /// // 获取所有枚举名称 / Get all enum names + /// string[] names = EnumHelper.GetEnumNames<Parity>(); + /// // ["None", "Odd", "Even", "Mark", "Space"] + /// + /// // 获取所有枚举值 / Get all enum values + /// Array values = EnumHelper.GetEnumValues<Parity>(); + /// // [0, 1, 2, 3, 4] + /// + /// + /// + /// + public static class EnumHelper { - public static IEnumerable TakeLast(this IEnumerable source, int count) + /// + /// 从数值获取枚举值 / Get Enum Value from Numeric Value + /// + /// 将整数转换为对应的枚举值，进行类型安全检查 + /// Convert integer to corresponding enum value with type-safe checking + /// + /// 安全检查 / Safety Check: + /// + /// 使用 Enum.IsDefined 检查值是否有效 / Use Enum.IsDefined to check if value is valid + /// 无效值抛出 ArgumentException / Throw ArgumentException for invalid values + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // Modbus 功能码转换 / Modbus function code conversion + /// var functionCode = EnumHelper.GetEnumFromValue<ModbusFunctionCode>(3); + /// // 返回：ModbusFunctionCode.ReadHoldingRegisters + /// + /// // 串口校验位转换 / Serial parity conversion + /// var parity = EnumHelper.GetEnumFromValue<Parity>(2); + /// // 返回：Parity.Even + /// + /// + /// + /// + /// + /// 枚举类型 / Enum type + /// 必须继承 System.Enum / Must inherit System.Enum + /// + /// + /// 数值 / Numeric value + /// + /// 对应的枚举值 + /// Corresponding enum value + /// + /// 示例 / Examples: + /// + /// 0 → Parity.None + /// 1 → Parity.Odd + /// 2 → Parity.Even + /// + /// + /// + /// + /// + /// 对应的枚举值 / Corresponding enum value + /// + /// 类型安全的枚举实例 + /// Type-safe enum instance + /// + /// + /// + /// 当数值在枚举中未定义时抛出 + /// Thrown when value is not defined in enum + /// + /// 示例 / Example: + /// + /// // 抛出异常：5 不在 Parity 枚举中 + /// // Throws: 5 is not in Parity enum + /// var invalid = EnumHelper.GetEnumFromValue<Parity>(5); + /// + /// + /// + public static T GetEnumFromValue(int value) where T : Enum { - if (null == source) - throw new ArgumentNullException(nameof(source)); - if (count < 0) - throw new ArgumentOutOfRangeException(nameof(count)); - - if (0 == count) - yield break; - - // Optimization (see JonasH's comment) - if (source is ICollection) + if (Enum.IsDefined(typeof(T), value)) { - foreach (T item in source.Skip(((ICollection)source).Count - count)) - yield return item; - - yield break; + return (T)Enum.ToObject(typeof(T), value); } - - if (source is IReadOnlyCollection) - { - foreach (T item in source.Skip(((IReadOnlyCollection)source).Count - count)) - yield return item; - - yield break; - } - - // General case, we have to enumerate source - Queue result = new Queue(); - - foreach (T item in source) - { - if (result.Count == count) - result.Dequeue(); - - result.Enqueue(item); - } - - foreach (T item in result) - yield return result.Dequeue(); + throw new ArgumentException($"Value {value} is not defined in enum {typeof(T).Name}"); } - public static IEnumerable Append(this IEnumerable collection, T item) + /// + /// 从枚举值获取数值 / Get Numeric Value from Enum + /// + /// 将枚举值转换为对应的整数 + /// Convert enum value to corresponding integer + /// + /// 使用场景 / Use Cases: + /// + /// 序列化枚举值 / Serialize enum values + /// 存储到数据库 / Store to database + /// 网络传输 / Network transmission + /// 配置写入 / Configuration writing + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // 串口配置写入 / Write serial port configuration + /// int parityValue = EnumHelper.GetValueFromEnum(Parity.Even); + /// ConfigurationWriter.Write("COM1:Parity", parityValue.ToString()); // "2" + /// + /// // Modbus 功能码转换 / Modbus function code conversion + /// int funcCode = EnumHelper.GetValueFromEnum(ModbusFunctionCode.ReadHoldingRegisters); + /// // 返回：3 + /// + /// + /// + /// + /// + /// 枚举类型 / Enum type + /// 必须继承 System.Enum / Must inherit System.Enum + /// + /// + /// 枚举值 / Enum value + /// + /// 需要转换的枚举实例 + /// Enum instance to convert + /// + /// + /// + /// 对应的整数值 / Corresponding integer value + /// + /// System.Int32 类型 + /// System.Int32 type + /// + /// + public static int GetValueFromEnum(T enumValue) where T : Enum { - if (collection == null) - { - throw new ArgumentNullException("Collection should not be null"); - } + return Convert.ToInt32(enumValue); + } - return collection.Concat(Enumerable.Repeat(item, 1)); + /// + /// 获取枚举类型的所有名称 / Get All Names of Enum Type + /// + /// 返回枚举类型中定义的所有成员名称 + /// Returns all member names defined in enum type + /// + /// 使用场景 / Use Cases: + /// + /// UI 下拉列表填充 / UI dropdown list population + /// 配置选项显示 / Configuration option display + /// 枚举值验证 / Enum value validation + /// 文档生成 / Documentation generation + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // 获取所有校验位选项 / Get all parity options + /// string[] parityNames = EnumHelper.GetEnumNames<Parity>(); + /// // ["None", "Odd", "Even", "Mark", "Space"] + /// + /// // 填充下拉列表 / Populate dropdown + /// foreach (var name in parityNames) + /// { + /// comboBox.Items.Add(name); + /// } + /// + /// + /// + /// + /// + /// 枚举类型 / Enum type + /// 必须继承 System.Enum / Must inherit System.Enum + /// + /// + /// 名称字符串数组 / Name string array + /// + /// 按定义顺序排列 + /// Arranged in definition order + /// + /// + public static string[] GetEnumNames() where T : Enum + { + return Enum.GetNames(typeof(T)); + } + + /// + /// 获取枚举类型的所有值 / Get All Values of Enum Type + /// + /// 返回枚举类型中定义的所有成员值 + /// Returns all member values defined in enum type + /// + /// 返回值类型 / Return Value Type: + /// + /// System.Array - 需要转换为具体类型 / Need to cast to specific type + /// 可以使用 foreach 遍历 / Can iterate with foreach + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // 获取所有校验位值 / Get all parity values + /// Array parityValues = EnumHelper.GetEnumValues<Parity>(); + /// + /// // 遍历枚举值 / Iterate through enum values + /// foreach (Parity parity in parityValues) + /// { + /// Console.WriteLine($"{parity} = {(int)parity}"); + /// } + /// // 输出 / Output: + /// // None = 0 + /// // Odd = 1 + /// // Even = 2 + /// // Mark = 3 + /// // Space = 4 + /// + /// + /// + /// + /// + /// 枚举类型 / Enum type + /// 必须继承 System.Enum / Must inherit System.Enum + /// + /// + /// 枚举值数组 / Enum value array + /// + /// System.Array 类型，包含所有枚举值 + /// System.Array type, containing all enum values + /// + /// + public static Array GetEnumValues() where T : Enum + { + return Enum.GetValues(typeof(T)); } } -#pragma warning restore 1591 -#endif } diff --git a/Modbus.Net/Modbus.Net/Helper/ValueHelper.cs b/Modbus.Net/Modbus.Net/Helper/ValueHelper.cs index a0d8fb3..f9d0e8b 100644 --- a/Modbus.Net/Modbus.Net/Helper/ValueHelper.cs +++ b/Modbus.Net/Modbus.Net/Helper/ValueHelper.cs @@ -8,37 +8,87 @@ using System.Text; namespace Modbus.Net { /// - /// 值与字节数组之间转换的辅助类 + /// 值与字节数组之间转换的辅助类 / Helper class for conversion between values and byte arrays + /// + /// 提供多种数据类型与字节数组之间的转换功能，支持大端/小端格式。 + /// Provides conversion functionality between various data types and byte arrays, supporting big-endian/little-endian formats. + /// + /// 主要派生类 / Main derived classes: + /// + /// - 小端格式 (Little Endian, LSB) + /// - 大端格式 (Big Endian, LSB) + /// - 大端格式 (Big Endian, MSB 位反转 / bit-reversed) + /// + /// + /// + /// 使用示例 / Usage example: + /// + /// // 获取大端格式实例 / Get big-endian instance + /// var helper = ValueHelper.GetInstance(Endian.BigEndianLsb); + /// + /// // 将 short 转换为字节数组 / Convert short to byte array + /// byte[] bytes = helper.GetBytes((short)12345); + /// + /// // 从字节数组读取值 / Read value from byte array + /// int pos = 0; + /// short value = helper.GetShort(bytes, ref pos); + /// + /// + /// /// public abstract class ValueHelper { /// - /// 是否为小端格式 + /// 是否为小端格式 (Little Endian) / Whether it's little-endian format + /// + /// 小端格式：低字节在前，高字节在后 + /// Little-endian: low byte first, high byte last + /// 例如 / Example: short 值 0x1234 在小端格式下存储为 [0x34, 0x12] + /// /// public abstract bool LittleEndian { get; } /// - /// 位是否为小端格式 + /// 位是否为小端格式 (LSB vs MSB) / Whether bits are in little-endian format (LSB vs MSB) + /// + /// LSB (Least Significant Bit): 最低有效位在前 / lowest bit first + /// MSB (Most Significant Bit): 最高有效位在前 / highest bit first + /// 仅在进行位操作时使用 (Boolean 类型) + /// Only used for bit operations (Boolean type) + /// /// public abstract bool LittleEndianBit { get; } /// - /// 兼容数据类型对应的字节长度 - /// - /// - /// 兼容数据类型对应的字节长度 + /// 兼容数据类型对应的字节长度字典 / Byte length dictionary for compatible data types + /// + /// 键为类型全名 (如 "System.Int16"), 值为占用的字节数 + /// Key is type full name (e.g., "System.Int16"), value is byte count + /// Boolean 类型占用 0.125 字节 (1 位) + /// Boolean type occupies 0.125 bytes (1 bit) + /// /// public static Dictionary ByteLength => new Dictionary { + // 布尔类型：1 位 = 0.125 字节 / Boolean: 1 bit = 0.125 bytes {"System.Boolean", 0.125}, + // 8 位无符号整数 / 8-bit unsigned integer {"System.Byte", 1}, + // 16 位有符号整数 / 16-bit signed integer {"System.Int16", 2}, + // 32 位有符号整数 / 32-bit signed integer {"System.Int32", 4}, + // 64 位有符号整数 / 64-bit signed integer {"System.Int64", 8}, + // 16 位无符号整数 / 16-bit unsigned integer {"System.UInt16", 2}, + // 32 位无符号整数 / 32-bit unsigned integer {"System.UInt32", 4}, + // 64 位无符号整数 / 64-bit unsigned integer {"System.UInt64", 8}, + // 32 位浮点数 (IEEE 754) / 32-bit floating point (IEEE 754) {"System.Single", 4}, + // 64 位浮点数 (IEEE 754) / 64-bit floating point (IEEE 754) {"System.Double", 8} }; diff --git a/Modbus.Net/Modbus.Net/Interface/IConnector.cs b/Modbus.Net/Modbus.Net/Interface/IConnector.cs index 48cf3dc..05e500e 100644 --- a/Modbus.Net/Modbus.Net/Interface/IConnector.cs +++ b/Modbus.Net/Modbus.Net/Interface/IConnector.cs @@ -1,45 +1,45 @@ -using System; using System.Threading.Tasks; namespace Modbus.Net { /// - /// Эӽӿ + /// 连接器接口 / Connector Interface + /// + /// 定义物理连接器的基本操作 + /// Defines basic operations for physical connector + /// /// + /// 发送参数类型 / Send parameter type + /// 接收参数类型 / Receive parameter type public interface IConnector { /// - /// ݷش - /// - Func, MessageReturnCallbackArgs> MessageReturn { get; set; } - - /// - /// ʶConnectorӹؼ + /// 连接标识符 / Connection Identifier /// string ConnectionToken { get; } /// - /// Ƿ״̬ + /// 连接状态 / Connection Status /// bool IsConnected { get; } /// - /// PLC첽 + /// 异步连接 / Asynchronous Connect /// - /// Ƿӳɹ + /// 是否连接成功 / Whether connection is successful Task ConnectAsync(); /// - /// ϿPLC + /// 断开连接 / Disconnect /// - /// ǷϿɹ + /// 是否断开成功 / Whether disconnection is successful bool Disconnect(); /// - /// ط + /// 异步发送消息 / Asynchronous Send Message /// - /// Ҫ͵ - /// Ƿͳɹ + /// 消息内容 / Message content + /// 响应消息 / Response message Task SendMsgAsync(TParamIn message); } -} \ No newline at end of file +} diff --git a/Modbus.Net/Modbus.Net/Interface/IConnectorWithController.cs b/Modbus.Net/Modbus.Net/Interface/IConnectorWithController.cs index 2575da5..964e60b 100644 --- a/Modbus.Net/Modbus.Net/Interface/IConnectorWithController.cs +++ b/Modbus.Net/Modbus.Net/Interface/IConnectorWithController.cs @@ -1,14 +1,118 @@ -namespace Modbus.Net +namespace Modbus.Net { /// - /// 基础的协议连接接口 + /// 带控制器的连接器接口 / Connector With Controller Interface + /// + /// 继承自 IConnector，添加了控制器管理功能 + /// Inherits from IConnector, adds controller management functionality + /// + /// 设计目的 / Design Purpose: + /// + /// 支持消息调度控制 / Support message scheduling control + /// 管理消息发送顺序 / Manage message send order + /// 处理并发通信 / Handle concurrent communication + /// 实现 FIFO/匹配等策略 / Implement FIFO/Match strategies + /// + /// + /// + /// 继承关系 / Inheritance: + /// + /// IConnector<TParamIn, TParamOut> + /// ↑ + /// IConnectorWithController<TParamIn, TParamOut> + /// ↑ + /// BaseConnector<TParamIn, TParamOut> + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // 创建连接器 / Create connector + /// IConnectorWithController<byte[], byte[]> connector = new TcpConnector("192.168.1.100", 502); + /// + /// // 添加控制器 / Add controller + /// IController controller = new FifoController(acquireTime: 10); + /// connector.AddController(controller); + /// + /// // 现在连接器支持消息队列和调度 + /// // Now connector supports message queue and scheduling + /// await connector.SendMsgAsync(requestData); + /// + /// + /// /// + /// + /// 发送参数类型 / Send Parameter Type + /// 通常是 byte[] / Usually byte[] + /// + /// + /// 接收参数类型 / Receive Parameter Type + /// 通常是 byte[] / Usually byte[] + /// public interface IConnectorWithController : IConnector { /// - /// 增加传输控制器 + /// 增加传输控制器 / Add Transmission Controller + /// + /// 向连接器添加消息调度控制器 + /// Add message scheduling controller to connector + /// + /// 控制器类型 / Controller Types: + /// + /// - 先进先出控制器 / First-In-First-Out Controller + /// - 匹配控制器 / Match Controller + /// - 无响应控制器 / No Response Controller + /// - 直接发送匹配控制器 / Direct Send Match Controller + /// + /// + /// + /// 控制器作用 / Controller Functions: + /// + /// 管理待发送消息队列 / Manage pending message queue + /// 控制消息发送顺序 / Control message send order + /// 匹配请求与响应 / Match requests with responses + /// 处理超时和重试 / Handle timeout and retry + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // 添加 FIFO 控制器 / Add FIFO controller + /// var fifoController = new FifoController( + /// acquireTime: 10, // 发送间隔 10ms + /// lengthCalc: DuplicateWithCount.GetDuplcateFunc(...), + /// checkRightFunc: ContentCheck.Crc16CheckRight + /// ); + /// connector.AddController(fifoController); + /// + /// // 添加匹配控制器 (多从站并发) / Add Match controller (multi-slave concurrent) + /// var matchController = new MatchController( + /// keyMatches: new ICollection<(int, int)>[] { + /// new List<(int, int)> { (0, 0), (1, 1) } // 匹配从站地址和功能码 + /// }, + /// acquireTime: 10 + /// ); + /// connector.AddController(matchController); + /// + /// + /// /// - /// 传输控制器 + /// + /// 传输控制器 / Transmission Controller + /// + /// 实现 IController 接口的控制器实例 + /// Controller instance implementing IController interface + /// + /// 控制器选择指南 / Controller Selection Guide: + /// + /// 单从站顺序通信 → FifoController / Single slave sequential communication + /// 多从站并发通信 → MatchController / Multi-slave concurrent communication + /// 不需要响应 → NoResponseController / No response required + /// 高速写入 → MatchDirectlySendController / High-speed write + /// + /// + /// + /// void AddController(IController controller); } -} \ No newline at end of file +} diff --git a/Modbus.Net/Modbus.Net/Interface/IController.cs b/Modbus.Net/Modbus.Net/Interface/IController.cs index 2cb9431..b669785 100644 --- a/Modbus.Net/Modbus.Net/Interface/IController.cs +++ b/Modbus.Net/Modbus.Net/Interface/IController.cs @@ -1,50 +1,108 @@ -using System.Collections.Generic; - namespace Modbus.Net { /// - /// ӿ + /// 控制器接口 / Controller Interface + /// + /// 定义消息调度控制器的基本操作 + /// Defines basic operations for message scheduling controller + /// + /// 主要功能 / Main Functions: + /// + /// 管理待发送消息队列 / Manage pending message queue + /// 控制消息发送顺序 / Control message sending order + /// 匹配请求与响应 / Match requests with responses + /// 处理超时和重试 / Handle timeout and retry + /// + /// + /// + /// 主要实现类 / Main Implementations: + /// + /// - 先进先出控制器 / First-In-First-Out Controller + /// - 匹配控制器 (根据响应内容匹配请求) / Match Controller (match request by response content) + /// - 无响应控制器 (仅发送不等待响应) / No Response Controller (send without waiting for response) + /// + /// + /// /// - public interface IController + /// + /// 发送参数类型 / Send parameter type + /// 通常是 byte[] / Usually byte[] + /// + /// + /// 接收参数类型 / Receive parameter type + /// 通常是 byte[] / Usually byte[] + /// + public interface IController { /// - /// Ϣά߳Ƿ + /// 添加消息到发送队列 / Add Message to Send Queue + /// + /// 将待发送的消息添加到控制器的队列中 + /// Add pending message to controller's queue + /// + /// 不同实现类的处理策略: + /// Processing strategies for different implementations: + /// + /// FIFO: 直接添加到队列末尾 / Add to end of queue + /// Match: 创建等待定义，等待响应匹配 / Create waiting definition, wait for response match + /// NoResponse: 立即发送，不等待响应 / Send immediately, don't wait for response + /// + /// + /// /// - bool IsSending { get; } + /// + /// 消息内容 / Message content + /// 待发送的协议数据 / Protocol data to send + /// + void AddMessage(TParamIn message); /// - /// Ϣ + /// 获取下一个要发送的消息 / Get Next Message to Send + /// + /// 从队列中获取下一个待发送的消息 + /// Get next pending message from queue + /// + /// 返回值说明 / Return Value Description: + /// + /// 有消息：返回下一个待发送的消息 / Has message: return next pending message + /// 无消息：返回 null / No message: return null + /// + /// + /// /// - /// Ҫ͵Ϣ - /// - MessageWaitingDef AddMessage(byte[] sendMessage); + /// 下一个消息 / Next message (null if queue is empty) + TParamIn GetNextMessage(); /// - /// ߳ + /// 标记消息完成 / Mark Message as Complete + /// + /// 当收到响应时，通知控制器消息已完成 + /// Notify controller that message is complete when response is received + /// + /// 主要用途 / Main Purposes: + /// + /// 释放等待的消息定义 / Release waiting message definition + /// 触发后续消息发送 / Trigger subsequent message sending + /// 更新统计信息 / Update statistics + /// + /// + /// /// - void SendStart(); + /// + /// 完成的消息 (响应) / Completed message (response) + /// 从设备接收到的响应数据 / Response data received from device + /// + void MessageComplete(TParamOut message); + } - /// - /// رմ߳ - /// - void SendStop(); - - /// - /// д͵Ϣ - /// - void Clear(); - - /// - /// صϢ󶨵͵ϢϣϢȷ - /// - /// صϢ - /// Ƿȷ - ICollection<(byte[], bool)> ConfirmMessage(byte[] receiveMessage); - - /// - /// ûκηʱǿɾȴϵϢ - /// - /// ҪǿɾϢ - void ForceRemoveWaitingMessage(MessageWaitingDef def); + /// + /// 控制器接口 (byte[] 版本) / Controller Interface (byte[] version) + /// + /// 使用 byte[] 作为默认参数类型的控制器接口 + /// Controller interface using byte[] as default parameter type + /// + /// + public interface IController : IController + { } } diff --git a/Modbus.Net/Modbus.Net/Interface/IMachine.cs b/Modbus.Net/Modbus.Net/Interface/IMachine.cs index a68b4dd..6ec7b5a 100644 --- a/Modbus.Net/Modbus.Net/Interface/IMachine.cs +++ b/Modbus.Net/Modbus.Net/Interface/IMachine.cs @@ -1,12 +1,33 @@ -using System; - namespace Modbus.Net { /// - /// 设备的抽象 + /// 机器接口 / Machine Interface + /// + /// 定义设备机器的基本操作接口 + /// Defines basic operation interface for device machine + /// /// - /// - public interface IMachine : IMachineProperty, IMachineMethodDatas where TKey : IEquatable + /// 机器 ID 类型 / Machine ID type + public interface IMachine { + /// + /// 机器 ID / Machine ID + /// + TKey Id { get; } + + /// + /// 机器别名 / Machine Alias + /// + string Alias { get; } + + /// + /// 连接令牌 / Connection Token + /// + string ConnectionToken { get; } + + /// + /// 是否保持连接 / Whether to Keep Connection + /// + bool KeepConnect { get; } } } diff --git a/Modbus.Net/Modbus.Net/Interface/IMachineMethod.cs b/Modbus.Net/Modbus.Net/Interface/IMachineMethod.cs index 25158b7..2998216 100644 --- a/Modbus.Net/Modbus.Net/Interface/IMachineMethod.cs +++ b/Modbus.Net/Modbus.Net/Interface/IMachineMethod.cs @@ -1,32 +1,40 @@ -using System.Collections.Generic; using System.Threading.Tasks; namespace Modbus.Net { /// - /// Machineдӿ + /// 机器方法接口 / Machine Method Interface + /// + /// 定义机器数据读写的方法接口 + /// Defines method interface for machine data read/write + /// /// public interface IMachineMethod { } /// - /// Machineݶдӿ + /// 机器数据方法接口 / Machine Data Method Interface + /// + /// 提供机器数据的读取和写入方法 + /// Provides machine data read and write methods + /// /// public interface IMachineMethodDatas : IMachineMethod { /// - /// ȡ + /// 异步读取数据 / Asynchronously Read Data /// - /// 豸ȡ + /// 获取数据类型 / Get data type + /// 读取结果 / Read result Task>>> GetDatasAsync(MachineDataType getDataType); /// - /// д + /// 异步写入数据 / Asynchronously Write Data /// - /// д - /// Ҫдֵ䣬дΪAddressʱΪҪдĵַдΪCommunicationTagʱΪҪдĵԪ - /// Ƿдɹ + /// 设置数据类型 / Set data type + /// 要写入的值 / Values to write + /// 写入结果 / Write result Task> SetDatasAsync(MachineDataType setDataType, Dictionary values); } -} \ No newline at end of file +} diff --git a/Modbus.Net/Modbus.Net/Interface/IMachineProperty.cs b/Modbus.Net/Modbus.Net/Interface/IMachineProperty.cs index cb63737..5eb4ae9 100644 --- a/Modbus.Net/Modbus.Net/Interface/IMachineProperty.cs +++ b/Modbus.Net/Modbus.Net/Interface/IMachineProperty.cs @@ -1,71 +1,45 @@ -using System; -using System.Threading.Tasks; +using System; +using System.Collections.Generic; namespace Modbus.Net { /// - /// 没有Id的设备属性 + /// 机器属性接口 / Machine Property Interface + /// + /// 定义机器的基本属性和配置 + /// Defines basic properties and configuration of machine + /// /// - public interface IMachinePropertyWithoutKey + public interface IMachineProperty { /// - /// 工程名 + /// 机器 ID / Machine ID /// - string ProjectName { get; set; } + string Id { get; set; } /// - /// 设备名 + /// 机器别名 / Machine Alias /// - string MachineName { get; set; } + string Alias { get; set; } /// - /// 标识设备的连接关键字 + /// 地址列表 / Address List /// - string ConnectionToken { get; } + IEnumerable GetAddresses { get; set; } /// - /// 是否处于连接状态 - /// - bool IsConnected { get; } - - /// - /// 是否保持连接 + /// 是否保持连接 / Whether to Keep Connection /// bool KeepConnect { get; set; } /// - /// 设备的连接器 + /// 地址翻译器 / Address Translator /// - IUtilityProperty BaseUtility { get; } + AddressTranslator AddressTranslator { get; set; } /// - /// 获取设备的方法集合 + /// 地址组合器 / Address Combiner /// - /// 方法集合的类型 - /// 设备的方法集合 - TMachineMethod GetMachineMethods() where TMachineMethod : class, IMachineMethod; - - /// - /// 连接设备 - /// - /// 是否连接成功 - Task ConnectAsync(); - - /// - /// 断开设备 - /// - /// 是否断开成功 - bool Disconnect(); - } - - /// - /// 设备属性的抽象 - /// - public interface IMachineProperty : IMachinePropertyWithoutKey where TKey : IEquatable - { - /// - /// Id - /// - TKey Id { get; set; } + AddressCombiner AddressCombiner { get; set; } } } diff --git a/Modbus.Net/Modbus.Net/Interface/IProtocol.cs b/Modbus.Net/Modbus.Net/Interface/IProtocol.cs index 1d68227..b66f4c8 100644 --- a/Modbus.Net/Modbus.Net/Interface/IProtocol.cs +++ b/Modbus.Net/Modbus.Net/Interface/IProtocol.cs @@ -1,67 +1,116 @@ -using System; +using System; using System.Threading.Tasks; namespace Modbus.Net { /// - /// 协议接口 + /// 协议接口 / Protocol Interface + /// + /// 定义协议的基本操作，包括连接、发送、接收等 + /// Defines basic protocol operations including connect, send, receive, etc. + /// + /// 主要功能 / Main Features: + /// + /// 协议连接器管理 / Protocol Linker Management + /// 懒加载协议实例 / Lazy-loaded Protocol Instances + /// 连接管理 / Connection Management + /// 发送接收 / Send and Receive + /// + /// + /// /// - /// 向Connector传入的类型 - /// 从Connector返回的类型 - /// 协议单元的类型 - /// 管道的类型 + /// + /// 向 Connector 传入的类型 / Type sent to Connector + /// 通常是 byte[] / Usually byte[] + /// + /// + /// 从 Connector 返回的类型 / Type returned from Connector + /// 通常是 byte[] / Usually byte[] + /// + /// 协议单元的类型 / Protocol unit type + /// 管道的类型 / Pipe unit type public interface IProtocol where TProtocolUnit : class, IProtocolFormatting where TParamOut : class where TPipeUnit : PipeUnit, TProtocolUnit> { /// - /// 协议的连接器 + /// 协议的连接器 / Protocol Linker + /// + /// 负责实际的物理连接 (TCP/UDP/串口) + /// Responsible for actual physical connection (TCP/UDP/Serial) + /// /// IProtocolLinker ProtocolLinker { get; } /// - /// 协议索引器，这是一个懒加载协议，当字典中不存在协议时自动加载协议，否则调用已经加载的协议 + /// 协议索引器 / Protocol Indexer + /// + /// 这是一个懒加载协议，当字典中不存在协议时自动加载协议，否则调用已经加载的协议 + /// This is a lazy-loading protocol that automatically loads protocol when it doesn't exist in dictionary, otherwise calls already loaded protocol + /// /// - /// 协议的类的GetType - /// 协议的实例 + /// 协议的类的 GetType / Protocol class GetType + /// 协议的实例 / Protocol instance TProtocolUnit this[Type type] { get; } /// - /// 协议连接开始 + /// 协议连接开始 / Start Protocol Connection + /// + /// 建立与设备的物理连接 + /// Establish physical connection with device + /// /// - /// + /// 是否连接成功 / Whether connection is successful Task ConnectAsync(); /// - /// 协议连接断开 + /// 协议连接断开 / Disconnect Protocol Connection + /// + /// 断开与设备的物理连接 + /// Disconnect physical connection with device + /// /// - /// + /// 是否断开成功 / Whether disconnection is successful bool Disconnect(); /// - /// 发送协议内容并接收，一般方法 + /// 发送协议内容并接收，一般方法 / Send Protocol Content and Receive, General Method + /// + /// 使用对象数组描述写入的内容 + /// Use object array to describe content to write + /// /// - /// 写入的内容，使用对象数组描述 - /// 从设备获取的字节流 + /// + /// 写入的内容，使用对象数组描述 + /// Content to write, described using object array + /// + /// 从设备获取的字节流 / Byte stream received from device Task SendReceiveAsync(params object[] content); /// - /// 发送协议，通过传入需要使用的协议内容和输入结构 + /// 发送协议，通过传入需要使用的协议内容和输入结构 / Send Protocol by Providing Protocol Unit and Input Structure + /// + /// 使用特定的协议单元和输入结构进行通信 + /// Communicate using specific protocol unit and input structure + /// /// - /// 协议的实例 - /// 输入信息的结构化描述 - /// 输出信息的结构化描述 + /// 协议的实例 / Protocol instance + /// 输入信息的结构化描述 / Structured description of input information + /// 输出信息的结构化描述 / Structured description of output information Task SendReceiveAsync(TProtocolUnit unit, IInputStruct content); /// - /// 发送协议，通过传入需要使用的协议内容和输入结构 + /// 发送协议，通过传入需要使用的协议内容和输入结构 (泛型版本) / Send Protocol by Providing Protocol Unit and Input Structure (Generic Version) + /// + /// 强类型版本，直接返回指定类型的输出结构 + /// Strongly-typed version, directly returning output structure of specified type + /// /// - /// 协议的实例 - /// 输入信息的结构化描述 - /// 输出信息的结构化描述 - /// IOutputStruct的具体类型 - Task SendReceiveAsync( - TProtocolUnit unit, IInputStruct content) where T : class, IOutputStruct; + /// 协议的实例 / Protocol instance + /// 输入信息的结构化描述 / Structured description of input information + /// IOutputStruct 的具体类型 / Concrete type of IOutputStruct + /// 输出信息的结构化描述 / Structured description of output information + Task SendReceiveAsync(TProtocolUnit unit, IInputStruct content) where T : class, IOutputStruct; } -} \ No newline at end of file +} diff --git a/Modbus.Net/Modbus.Net/Interface/IProtocolFormatting.cs b/Modbus.Net/Modbus.Net/Interface/IProtocolFormatting.cs index da89ffa..fa4a5bc 100644 --- a/Modbus.Net/Modbus.Net/Interface/IProtocolFormatting.cs +++ b/Modbus.Net/Modbus.Net/Interface/IProtocolFormatting.cs @@ -1,46 +1,213 @@ -namespace Modbus.Net +namespace Modbus.Net { /// - /// 协议转换的接口 + /// 协议格式化接口 / Protocol Formatting Interface + /// + /// 定义协议数据的格式化和反格式化操作 + /// Defines formatting and unformatting operations for protocol data + /// + /// 核心功能 / Core Functions: + /// + /// Format - 将结构化数据转换为字节流 / Convert structured data to byte stream + /// Unformat - 将字节流解析为结构化数据 / Parse byte stream into structured data + /// + /// + /// + /// 设计模式 / Design Pattern: + /// 这是典型的序列化/反序列化接口，用于协议层的编解码 + /// This is a typical serialization/deserialization interface for protocol layer encoding/decoding + /// + /// /// - /// 向Connector传入的数据类型 - /// 从Connector返回的数据类型 + /// + /// 向 Connector 传入的数据类型 / Data type sent to Connector + /// 通常是 byte[] / Usually byte[] + /// + /// + /// 从 Connector 返回的数据类型 / Data type returned from Connector + /// 通常是 byte[] / Usually byte[] + /// public interface IProtocolFormatting { /// - /// 是否为小端格式 + /// 端格式 / Endianness + /// + /// 指示协议使用的字节序 + /// Indicates byte order used by protocol + /// + /// 可选值 / Possible Values: + /// + /// - 小端格式 / Little Endian + /// - 大端格式 / Big Endian + /// - 大端 + 位反转 / Big Endian + Bit Reversed + /// + /// + /// /// Endian Endian { get; set; } /// - /// 从输入结构格式化 + /// 从输入结构格式化为字节流 / Format from Input Structure to Byte Stream + /// + /// 将结构化的输入数据 (IInputStruct) 转换为协议字节流 + /// Convert structured input data (IInputStruct) to protocol byte stream + /// + /// 使用场景 / Use Cases: + /// + /// 发送读取请求 / Send read request + /// 发送写入命令 / Send write command + /// 发送控制指令 / Send control command + /// + /// + /// + /// 示例 / Example: + /// + /// // Modbus 读保持寄存器请求 / Modbus Read Holding Register request + /// var inputStruct = new ReadDataModbusInputStruct( + /// slaveAddress: 1, // 从站地址 / Slave address + /// functionCode: 3, // 功能码 03 / Function code 03 + /// startAddress: 0, // 起始地址 / Start address + /// getCount: 10 // 读取数量 / Read count + /// ); + /// byte[] bytes = protocol.Format(inputStruct); + /// // 输出：[0x01, 0x03, 0x00, 0x00, 0x00, 0x0A, 0xC4, 0x0B] (带 CRC) + /// + /// + /// /// - /// 结构化的输入数据 - /// 格式化后的字节流 + /// + /// 结构化的输入数据 / Structured input data + /// 实现 IInputStruct 接口的对象 / Object implementing IInputStruct interface + /// + /// 格式化后的字节流 / Formatted byte stream TParamIn Format(IInputStruct message); /// - /// 从对象的参数数组格式化 + /// 从对象参数数组格式化为字节流 / Format from Object Parameter Array to Byte Stream + /// + /// 将非结构化的对象数组转换为协议字节流 + /// Convert unstructured object array to protocol byte stream + /// + /// 使用场景 / Use Cases: + /// + /// 动态构建协议消息 / Dynamically build protocol messages + /// 通用写入操作 / Generic write operations + /// 可变长度的数据写入 / Variable-length data writing + /// + /// + /// + /// 示例 / Example: + /// + /// // Modbus 写多个寄存器 / Modbus Write Multiple Registers + /// byte[] bytes = protocol.Format( + /// (byte)1, // 从站地址 / Slave address + /// (byte)16, // 功能码 16 / Function code 16 + /// (ushort)0, // 起始地址 / Start address + /// (ushort)2, // 写入数量 / Write count + /// (byte)4, // 字节数 / Byte count + /// (ushort)100, // 第 1 个值 / 1st value + /// (ushort)200 // 第 2 个值 / 2nd value + /// ); + /// + /// + /// /// - /// 非结构化的输入数据 - /// 格式化后的字节流 + /// + /// 非结构化的输入数据 / Unstructured input data + /// 对象数组，每个对象代表一个字段 / Object array, each object represents a field + /// + /// 格式化后的字节流 / Formatted byte stream byte[] Format(params object[] message); /// - /// 把仪器返回的内容填充到输出结构中 + /// 将字节流反格式化为输出结构 / Unformat Byte Stream to Output Structure + /// + /// 将设备返回的字节流解析为结构化的输出数据 + /// Parse byte stream returned from device into structured output data + /// + /// 使用场景 / Use Cases: + /// + /// 解析读取响应 / Parse read response + /// 解析写入确认 / Parse write acknowledgment + /// 解析错误响应 / Parse error response + /// + /// + /// + /// 参数说明 / Parameters: + /// + /// messageBytes - 设备返回的原始字节数据 / Raw byte data from device + /// pos - 当前解析位置 (引用传递，会自动更新) / Current parse position (passed by reference, auto-updated) + /// + /// + /// + /// 示例 / Example: + /// + /// // Modbus 读响应解析 / Modbus Read Response parsing + /// byte[] response = [0x01, 0x03, 0x04, 0x00, 0x64, 0x00, 0xC8]; // 2 个寄存器的值 + /// int pos = 0; + /// IOutputStruct output = protocol.Unformat(response, ref pos); + /// + /// // 转换为具体类型 / Cast to specific type + /// var readOutput = (ReadDataModbusOutputStruct)output; + /// // readOutput.DataValue = [0x00, 0x64, 0x00, 0xC8] + /// + /// + /// /// - /// 返回数据的字节流 - /// 转换标记位 - /// 结构化的输出数据 + /// + /// 返回数据的字节流 / Byte stream of returned data + /// 设备返回的原始字节数据 / Raw byte data from device + /// + /// + /// 转换标记位 (当前解析位置) / Conversion marker (current parse position) + /// 引用传递，解析过程中会自动更新 / Passed by reference, auto-updated during parsing + /// + /// 结构化的输出数据 / Structured output data IOutputStruct Unformat(TParamOut messageBytes, ref int pos); /// - /// 把仪器返回的内容填充到输出结构中 + /// 将字节流反格式化为指定类型的输出结构 / Unformat Byte Stream to Specified Output Structure Type + /// + /// 泛型版本的反格式化方法，直接返回指定类型的输出结构 + /// Generic version of unformat method, directly returning output structure of specified type + /// + /// 优势 / Advantages: + /// + /// 类型安全 / Type-safe + /// 无需显式转换 / No explicit casting required + /// 编译时类型检查 / Compile-time type checking + /// + /// + /// + /// 示例 / Example: + /// + /// // Modbus 读响应解析 (泛型版本) / Modbus Read Response parsing (generic version) + /// byte[] response = [0x01, 0x03, 0x04, 0x00, 0x64, 0x00, 0xC8]; + /// int pos = 0; + /// + /// // 直接获取强类型结果 / Directly get strongly-typed result + /// var output = protocol.Unformat<ReadDataModbusOutputStruct>(response, ref pos); + /// + /// // 无需转换，直接使用 / No casting needed, use directly + /// ushort value1 = output.GetUShortValue(0); // 100 + /// ushort value2 = output.GetUShortValue(1); // 200 + /// + /// + /// /// - /// 返回数据的字节流 - /// 转换标记位 - /// IOutputStruct的具体类型 - /// 结构化的输出数据 + /// + /// IOutputStruct 的具体类型 / Concrete type of IOutputStruct + /// 必须实现 IOutputStruct 接口 / Must implement IOutputStruct interface + /// + /// + /// 返回数据的字节流 / Byte stream of returned data + /// 设备返回的原始字节数据 / Raw byte data from device + /// + /// + /// 转换标记位 (当前解析位置) / Conversion marker (current parse position) + /// 引用传递，解析过程中会自动更新 / Passed by reference, auto-updated during parsing + /// + /// 结构化的输出数据 / Structured output data T Unformat(TParamOut messageBytes, ref int pos) where T : class, IOutputStruct; } -} \ No newline at end of file +} diff --git a/Modbus.Net/Modbus.Net/Interface/IProtocolLinker.cs b/Modbus.Net/Modbus.Net/Interface/IProtocolLinker.cs index c3b525a..bbde868 100644 --- a/Modbus.Net/Modbus.Net/Interface/IProtocolLinker.cs +++ b/Modbus.Net/Modbus.Net/Interface/IProtocolLinker.cs @@ -1,55 +1,87 @@ -using System.Threading.Tasks; +using System.Threading.Tasks; namespace Modbus.Net { /// - /// 协议连接器接口 + /// 协议连接器接口 / Protocol Linker Interface + /// + /// 定义协议连接器的基本操作，负责实际的物理连接和数据传输 + /// Defines basic operations for protocol linker, responsible for actual physical connection and data transmission + /// /// - /// 向Connector传入的数据类型 - /// 从Connector返回的数据类型 + /// 向 Connector 传入的数据类型 / Data type sent to Connector + /// 从 Connector 返回的数据类型 / Data type returned from Connector public interface IProtocolLinker { /// - /// 通讯字符串 + /// 通讯字符串 / Communication String + /// + /// 唯一标识当前连接的字符串，通常包含 IP、端口等信息 + /// String uniquely identifying current connection, usually containing IP, port, etc. + /// /// string ConnectionToken { get; } /// - /// 设备是否连接 + /// 设备是否连接 / Whether Device is Connected + /// + /// true: 已连接 / Connected + /// false: 未连接 / Not connected + /// /// bool IsConnected { get; } /// - /// 连接设备 + /// 连接设备 / Connect Device + /// + /// 建立与设备的物理连接 + /// Establish physical connection with device + /// /// - /// 设备是否连接成功 + /// 设备是否连接成功 / Whether device is connected successfully Task ConnectAsync(); /// - /// 断开设备 + /// 断开设备 / Disconnect Device + /// + /// 断开与设备的物理连接 + /// Disconnect physical connection with device + /// /// - /// 设备是否断开成功 + /// 设备是否断开成功 / Whether device is disconnected successfully bool Disconnect(); /// - /// 发送并接收数据 + /// 发送并接收数据 / Send and Receive Data + /// + /// 发送协议内容并接收设备响应 + /// Send protocol content and receive device response + /// /// - /// 发送协议的内容 - /// 接收协议的内容 + /// 发送协议的内容 / Protocol content to send + /// 接收协议的内容 / Received protocol content Task SendReceiveAsync(TParamIn content); /// - /// 发送并接收数据，不进行协议扩展和收缩，用于特殊协议 + /// 发送并接收数据，不进行协议扩展和收缩 / Send and Receive Data Without Protocol Extension and Reduction + /// + /// 用于特殊协议，直接发送原始数据 + /// Used for special protocols, directly send raw data + /// /// - /// 发送协议的内容 - /// 接收协议的内容 + /// 发送协议的内容 / Protocol content to send + /// 接收协议的内容 / Received protocol content Task SendReceiveWithoutExtAndDecAsync(TParamIn content); /// - /// 检查接收的数据是否正确 + /// 检查接收的数据是否正确 / Check if Received Data is Correct + /// + /// 验证接收到的协议数据是否有效 + /// Verify if received protocol data is valid + /// /// - /// 接收协议的内容 - /// 协议是否是正确的 + /// 接收协议的内容 / Received protocol content + /// 协议是否是正确的 / Whether protocol is correct (null=未知，true=正确，false=错误) bool? CheckRight(TParamOut content); } -} \ No newline at end of file +} diff --git a/Modbus.Net/Modbus.Net/Interface/IProtocolLinkerBytesExtend.cs b/Modbus.Net/Modbus.Net/Interface/IProtocolLinkerBytesExtend.cs index d80cd9a..b9ec8e2 100644 --- a/Modbus.Net/Modbus.Net/Interface/IProtocolLinkerBytesExtend.cs +++ b/Modbus.Net/Modbus.Net/Interface/IProtocolLinkerBytesExtend.cs @@ -1,22 +1,180 @@ -namespace Modbus.Net +namespace Modbus.Net { /// - /// 协议字节伸缩 + /// 协议字节伸缩接口 / Protocol Bytes Extend Interface + /// + /// 定义协议内容在发送前扩展和接收后收缩的操作 + /// Defines operations for extending protocol content before sending and reducing after receiving + /// + /// 设计目的 / Design Purpose: + /// + /// 处理协议头部/尾部 / Handle protocol header/tail + /// 添加/移除校验码 / Add/remove checksum + /// 处理帧边界标记 / Handle frame boundary markers + /// 适配不同传输层 / Adapt to different transport layers + /// + /// + /// + /// 使用场景 / Use Cases: + /// + /// Modbus TCP - 添加/移除 MBAP 头 (6 字节) / Add/remove MBAP header (6 bytes) + /// Modbus ASCII - 添加/移除冒号、CRLF / Add/remove colon, CRLF + /// Profibus - 添加/移除帧头帧尾 / Add/remove frame header/tail + /// 自定义协议 - 自定义扩展规则 / Custom extension rules + /// + /// + /// + /// 命名约定 / Naming Convention: + /// + /// 实现类名称：{ProtocolLinker 名称}BytesExtend + /// 示例：ModbusTcpProtocolLinkerBytesExtend + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // Modbus TCP 协议字节伸缩 / Modbus TCP protocol bytes extend + /// public class ModbusTcpProtocolLinkerBytesExtend : IProtocolLinkerBytesExtend<byte[], byte[]> + /// { + /// public byte[] BytesExtend(byte[] content) + /// { + /// // 添加 MBAP 头 (6 字节) / Add MBAP header (6 bytes) + /// // [Transaction ID (2)][Protocol ID (2)][Length (2)][Unit ID (1)] + /// byte[] newFormat = new byte[6 + content.Length]; + /// int tag = 0; // Transaction ID + /// ushort leng = (ushort)content.Length; + /// Array.Copy(BitConverter.GetBytes(tag), 0, newFormat, 0, 4); + /// Array.Copy(BitConverter.GetBytes(leng), 0, newFormat, 4, 2); + /// Array.Copy(content, 0, newFormat, 6, content.Length); + /// return newFormat; + /// } + /// + /// public byte[] BytesDecact(byte[] content) + /// { + /// // 移除 MBAP 头 (6 字节) / Remove MBAP header (6 bytes) + /// byte[] newContent = new byte[content.Length - 6]; + /// Array.Copy(content, 6, newContent, 0, newContent.Length); + /// return newContent; + /// } + /// } + /// + /// + /// /// + /// + /// 发送参数类型 / Send Parameter Type + /// 通常是 byte[] / Usually byte[] + /// + /// + /// 接收参数类型 / Receive Parameter Type + /// 通常是 byte[] / Usually byte[] + /// public interface IProtocolLinkerBytesExtend { /// - /// 协议扩展，协议内容发送前调用 + /// 协议扩展 (发送前调用) / Protocol Extend (Called Before Sending) + /// + /// 在协议内容发送前进行扩展，添加必要的头部、尾部或校验码 + /// Extend protocol content before sending, adding necessary header, tail or checksum + /// + /// 典型应用 / Typical Applications: + /// + /// 添加协议头部 (如 MBAP 头) / Add protocol header (e.g., MBAP header) + /// 添加帧起始符 / Add frame start marker + /// 添加长度字段 / Add length field + /// 添加校验码 (CRC/LRC) / Add checksum (CRC/LRC) + /// 添加帧结束符 / Add frame end marker + /// + /// + /// + /// 调用时机 / Call Timing: + /// + /// 在 ProtocolLinker.SendReceiveAsync 中调用 / Called in ProtocolLinker.SendReceiveAsync + /// 在实际发送数据之前 / Before actually sending data + /// 在协议格式化之后 / After protocol formatting + /// + /// + /// /// - /// 扩展前的原始协议内容 - /// 扩展后的协议内容 + /// + /// 扩展前的原始协议内容 / Original Protocol Content Before Extension + /// + /// 已经过协议格式化的核心数据 + /// Core data that has been protocol-formatted + /// + /// 示例 (Modbus RTU) / Example (Modbus RTU): + /// [从站地址][功能码][数据][CRC] + /// + /// + /// + /// + /// 扩展后的协议内容 / Extended Protocol Content + /// + /// 包含完整帧结构的数据，可以直接发送 + /// Data with complete frame structure, ready to send + /// + /// 示例 (Modbus TCP) / Example (Modbus TCP): + /// [MBAP 头 (6 字节)][从站地址][功能码][数据] + /// + /// + /// TParamIn BytesExtend(TParamIn content); /// - /// 协议收缩，协议内容接收后调用 + /// 协议收缩 (接收后调用) / Protocol Reduce (Called After Receiving) + /// + /// 在接收协议内容后进行收缩，移除头部、尾部或校验码 + /// Reduce protocol content after receiving, removing header, tail or checksum + /// + /// 典型应用 / Typical Applications: + /// + /// 移除协议头部 / Remove protocol header + /// 移除帧起始符 / Remove frame start marker + /// 移除长度字段 / Remove length field + /// 验证并移除校验码 / Verify and remove checksum + /// 移除帧结束符 / Remove frame end marker + /// + /// + /// + /// 调用时机 / Call Timing: + /// + /// 在 ProtocolLinker.SendReceiveAsync 中调用 / Called in ProtocolLinker.SendReceiveAsync + /// 在接收到数据之后 / After receiving data + /// 在协议反格式化之前 / Before protocol unformatting + /// + /// + /// + /// 注意事项 / Notes: + /// + /// 应该与 BytesExtend 对称 / Should be symmetric with BytesExtend + /// 扩展和收缩应该可逆 / Extension and reduction should be reversible + /// 处理边界情况 (空数据、短数据) / Handle edge cases (empty data, short data) + /// + /// + /// /// - /// 收缩前的完整协议内容 - /// 收缩后的协议内容 + /// + /// 收缩前的完整协议内容 / Complete Protocol Content Before Reduction + /// + /// 从设备接收到的原始数据 + /// Raw data received from device + /// + /// 示例 (Modbus TCP) / Example (Modbus TCP): + /// [MBAP 头 (6 字节)][从站地址][功能码][数据] + /// + /// + /// + /// + /// 收缩后的协议内容 / Reduced Protocol Content + /// + /// 移除扩展部分后的核心数据 + /// Core data with extension parts removed + /// + /// 示例 (Modbus RTU) / Example (Modbus RTU): + /// [从站地址][功能码][数据][CRC] + /// + /// + /// TParamOut BytesDecact(TParamOut content); } -} \ No newline at end of file +} diff --git a/Modbus.Net/Modbus.Net/Interface/IProtocolReceiver.cs b/Modbus.Net/Modbus.Net/Interface/IProtocolReceiver.cs index 9c00d97..2bd6500 100644 --- a/Modbus.Net/Modbus.Net/Interface/IProtocolReceiver.cs +++ b/Modbus.Net/Modbus.Net/Interface/IProtocolReceiver.cs @@ -1,61 +1,325 @@ -using System; +using System; using System.Threading.Tasks; namespace Modbus.Net { /// - /// 协议接收器接口 + /// 协议接收器接口 / Protocol Receiver Interface + /// + /// 定义协议接收器的基本操作，用于实现服务器端/从站功能 + /// Defines basic operations for protocol receiver, used to implement server-side/slave functionality + /// + /// 与 ProtocolLinker 的区别 / Difference from ProtocolLinker: + /// + /// ProtocolLinker - 客户端/主站 (Master) / Client/Master + /// ProtocolReceiver - 服务器端/从站 (Slave) / Server/Slave + /// + /// + /// + /// 工作流程 / Workflow: + /// + /// 接收客户端请求 / Receive client request + /// 调用 ReceiveSend 处理 / Call ReceiveSend to process + /// 生成响应数据 / Generate response data + /// 发送响应给客户端 / Send response to client + /// + /// + /// + /// 使用场景 / Use Cases: + /// + /// Modbus 从站服务器 / Modbus Slave Server + /// 虚拟 PLC / Virtual PLC + /// 设备仿真器 / Device Simulator + /// + /// + /// + /// 实现示例 / Implementation Example: + /// + /// public class ModbusProtocolReceiver : ProtocolReceiver<byte[], byte[]> + /// { + /// // 内部寄存器 / Internal registers + /// private Dictionary<int, ushort> registers = new(); + /// + /// public override byte[] ReceiveSend(byte[] content) + /// { + /// // 1. 检查数据是否正确 / Check if data is correct + /// var checkRight = CheckRight(content); + /// if (checkRight != true) return null; + /// + /// // 2. 移除协议扩展 (如 MBAP 头) / Remove protocol extension (e.g., MBAP header) + /// var decBytes = BytesDecact(content); + /// + /// // 3. 解析协议内容 / Parse protocol content + /// var explainContent = DataExplain(decBytes); + /// + /// // 4. 处理数据 (读写寄存器) / Process data (read/write registers) + /// var returnBytes = DataProcess(explainContent); + /// + /// if (returnBytes != null) + /// { + /// // 5. 添加协议扩展 / Add protocol extension + /// var extBytes = BytesExtend(returnBytes); + /// return extBytes; + /// } + /// + /// return null; + /// } + /// } + /// + /// + /// /// - /// 从Receiver传出的数据类型 - /// 向Receiver传入的数据类型 + /// + /// 从 Receiver 传出的数据类型 / Data Type Transmitted from Receiver + /// + /// 发送给客户端的响应数据 + /// Response data sent to client + /// + /// 通常是 byte[] + /// Usually byte[] + /// + /// + /// + /// + /// 向 Receiver 传入的数据类型 / Data Type Transmitted to Receiver + /// + /// 从客户端接收的请求数据 + /// Request data received from client + /// + /// 通常是 byte[] + /// Usually byte[] + /// + /// + /// public interface IProtocolReceiver { /// - /// 转发事件 + /// 转发事件 / Dispatch Event + /// + /// 用于处理接收到的数据并生成响应 + /// Used to process received data and generate response + /// + /// 委托签名 / Delegate Signature: + /// Func<TParamOut, TParamIn> + /// + /// + /// 参数说明 / Parameters: + /// + /// 输入：接收到的请求数据 / Input: Received request data + /// 输出：生成的响应数据 / Output: Generated response data + /// + /// + /// /// Func DispatchEvent { get; } /// - /// 通讯字符串 + /// 通讯字符串 / Communication String + /// + /// 唯一标识当前连接的字符串 + /// String uniquely identifying current connection + /// + /// 格式示例 / Format Examples: + /// + /// TCP: "192.168.1.100:502" + /// 串口："COM1,9600,None,8,1" + /// + /// + /// /// string ConnectionToken { get; } /// - /// 设备是否连接 + /// 设备是否连接 / Whether Device is Connected + /// + /// 指示服务器端是否已准备好接收请求 + /// Indicates whether server-side is ready to receive requests + /// + /// 服务器端连接含义 / Server-Side Connection Meaning: + /// + /// TCP: 监听端口已打开 / TCP: Listening port is open + /// 串口：串口已打开 / Serial: Serial port is open + /// 可以接收客户端请求 / Can receive client requests + /// + /// + /// /// bool IsConnected { get; } /// - /// 连接设备 + /// 连接设备 / Connect Device + /// + /// 启动服务器监听 + /// Start server listening + /// + /// 服务器端连接流程 / Server-Side Connection Flow: + /// + /// 创建监听套接字 / Create listening socket + /// 绑定到指定端口 / Bind to specified port + /// 开始监听 / Start listening + /// 等待客户端连接 / Wait for client connection + /// + /// + /// /// - /// 设备是否连接成功 + /// 设备是否连接成功 / Whether Device is Connected Successfully Task ConnectAsync(); /// - /// 断开设备 + /// 断开设备 / Disconnect Device + /// + /// 停止服务器监听 + /// Stop server listening + /// + /// 服务器端断开流程 / Server-Side Disconnection Flow: + /// + /// 关闭所有客户端连接 / Close all client connections + /// 停止监听套接字 / Stop listening socket + /// 释放资源 / Release resources + /// + /// + /// /// - /// 设备是否断开成功 + /// 设备是否断开成功 / Whether Device is Disconnected Successfully bool Disconnect(); /// - /// 接收并发送数据 + /// 接收并发送数据 / Receive and Send Data + /// + /// 处理客户端请求并生成响应 + /// Process client request and generate response + /// + /// 处理流程 / Processing Flow: + /// + /// 接收客户端请求数据 / Receive client request data + /// 检查数据正确性 / Check data correctness + /// 移除协议扩展 (如果有) / Remove protocol extension (if any) + /// 解析协议内容 / Parse protocol content + /// 处理数据 (读写寄存器) / Process data (read/write registers) + /// 生成响应数据 / Generate response data + /// 添加协议扩展 (如果有) / Add protocol extension (if any) + /// 发送响应给客户端 / Send response to client + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // Modbus 读请求处理 / Modbus read request processing + /// byte[] request = [0x01, 0x03, 0x00, 0x00, 0x00, 0x0A, 0xC4, 0x0B]; + /// byte[] response = receiver.ReceiveSend(request); + /// + /// // 响应格式 / Response format: + /// // [0x01, 0x03, 0x14, 数据..., CRC] + /// // │ │ │ │ + /// // │ │ │ └─ 数据 (10 个寄存器 = 20 字节) + /// // │ │ └─ 字节数 + /// // │ └─ 功能码 + /// // └─ 从站地址 + /// + /// + /// /// - /// 接收协议的内容 - /// 发送协议的内容 + /// + /// 接收协议的内容 / Received Protocol Content + /// + /// 从客户端接收到的请求数据 + /// Request data received from client + /// + /// 示例 (Modbus RTU 读请求) / Example (Modbus RTU Read Request): + /// [从站地址][功能码][起始地址][数量][CRC] + /// + /// + /// + /// + /// 发送协议的内容 / Protocol Content to Send + /// + /// 发送给客户端的响应数据 + /// Response data sent to client + /// + /// 示例 (Modbus RTU 读响应) / Example (Modbus RTU Read Response): + /// [从站地址][功能码][字节数][数据...][CRC] + /// + /// + /// 返回 null 的情况 / Returns null when: + /// + /// 数据校验失败 / Data check failed + /// 协议解析错误 / Protocol parsing error + /// 寄存器地址越界 / Register address out of bounds + /// + /// + /// + /// TParamIn ReceiveSend(TParamOut content); /// - /// 接收并发送数据，不进行协议扩展和收缩，用于特殊协议 + /// 接收并发送数据，不进行协议扩展和收缩 / Receive and Send Data Without Protocol Extension and Reduction + /// + /// 用于特殊协议，直接处理原始数据 + /// Used for special protocols, directly process raw data + /// + /// 使用场景 / Use Cases: + /// + /// 不需要协议扩展的简单协议 / Simple protocols without extension + /// 自定义协议格式 / Custom protocol format + /// 透传模式 / Transparent transmission mode + /// + /// + /// /// - /// 发送协议的内容 - /// 接收协议的内容 + /// + /// 发送协议的内容 / Protocol Content to Send + /// + /// 原始请求数据 (无扩展) + /// Raw request data (without extension) + /// + /// + /// + /// 接收协议的内容 / Received Protocol Content + /// + /// 原始响应数据 (无扩展) + /// Raw response data (without extension) + /// + /// TParamIn ReceiveSendWithoutExtAndDec(TParamOut content); /// - /// 检查接收的数据是否正确 + /// 检查接收的数据是否正确 / Check if Received Data is Correct + /// + /// 验证接收到的协议数据是否有效 + /// Verify if received protocol data is valid + /// + /// 校验方法 / Check Methods: + /// + /// CRC16 校验 / CRC16 Check + /// LRC 校验 / LRC Check + /// FCS 校验 / FCS Check + /// 基础检查 (非空) / Basic Check (not empty) + /// + /// + /// + /// 返回值说明 / Return Value Description: + /// + /// true - 数据正确 / Data correct + /// false - 数据错误 / Data error + /// null - 无法判断 (数据不完整) / Cannot determine (incomplete data) + /// + /// + /// /// - /// 接收协议的内容 - /// 协议是否是正确的 + /// + /// 接收协议的内容 / Received Protocol Content + /// + /// 从客户端接收到的数据 + /// Data received from client + /// + /// + /// + /// 协议是否是正确的 / Whether Protocol is Correct + /// + /// null=未知，true=正确，false=错误 + /// null=unknown, true=correct, false=error + /// + /// bool? CheckRight(TParamOut content); } -} \ No newline at end of file +} diff --git a/Modbus.Net/Modbus.Net/Interface/IUtility.cs b/Modbus.Net/Modbus.Net/Interface/IUtility.cs index eeec539..b619c90 100644 --- a/Modbus.Net/Modbus.Net/Interface/IUtility.cs +++ b/Modbus.Net/Modbus.Net/Interface/IUtility.cs @@ -1,7 +1,11 @@ -namespace Modbus.Net +namespace Modbus.Net { /// - /// Api入口的抽象 + /// Api 入口的抽象 / API Entry Abstraction + /// + /// 组合 IUtilityProperty 和 IUtilityMethodDatas 接口 + /// Combines IUtilityProperty and IUtilityMethodDatas interfaces + /// /// public interface IUtility : IUtilityProperty, IUtilityMethodDatas { diff --git a/Modbus.Net/Modbus.Net/Interface/IUtilityMethod.cs b/Modbus.Net/Modbus.Net/Interface/IUtilityMethod.cs index 7aa012e..d0009db 100644 --- a/Modbus.Net/Modbus.Net/Interface/IUtilityMethod.cs +++ b/Modbus.Net/Modbus.Net/Interface/IUtilityMethod.cs @@ -1,61 +1,113 @@ -using System; -using System.Collections.Generic; -using System.Threading.Tasks; - namespace Modbus.Net { /// - /// Utility方法读写接口 + /// Utility 方法读写接口 / Utility Method Read/Write Interface + /// + /// 定义 Utility 数据读写的基本方法 + /// Defines basic methods for Utility data read/write + /// /// public interface IUtilityMethod { } /// - /// Utility的数据读写接口 + /// Utility 的数据读写接口 / Utility Data Read/Write Interface + /// + /// 提供多种数据读取和写入方法，支持不同类型和格式 + /// Provides multiple data read and write methods, supporting different types and formats + /// + /// 主要方法 / Main Methods: + /// + /// GetDatasAsync (字节级) / GetDatasAsync (Byte-level) + /// GetDatasAsync (对象级) / GetDatasAsync (Object-level) + /// GetDatasAsync (泛型) / GetDatasAsync (Generic) + /// SetDatasAsync / SetDatasAsync + /// + /// + /// /// public interface IUtilityMethodDatas : IUtilityMethod { /// - /// 获取数据 + /// 异步读取数据 (字节级 API) / Asynchronously Read Data (Byte-level API) + /// + /// 最底层的读取方法，返回原始字节数组 + /// Lowest-level read method, returning raw byte array + /// /// - /// 开始地址 - /// 获取字节数个数 - /// 获取原始个数 - /// 接收到的byte数据 + /// 开始地址 / Start address + /// 获取字节数个数 / Number of bytes to get + /// 获取原始个数 / Get original count + /// 接收到的 byte 数据 / Received byte data Task> GetDatasAsync(string startAddress, int getByteCount, int getOriginalCount); /// - /// 获取数据 + /// 异步读取数据 (对象级 API) / Asynchronously Read Data (Object-level API) + /// + /// 读取指定类型和个数的数据，返回对象数组 + /// Read data of specified type and count, returning object array + /// /// - /// 开始地址 - /// 获取类型和个数 - /// 接收到的对应的类型和数据 + /// 开始地址 / Start address + /// + /// 获取类型和个数 / Get type and count + /// + /// Key: 数据类型 (如 typeof(ushort)) + /// Key: Data type (e.g., typeof(ushort)) + /// Value: 读取个数 / Read count + /// + /// + /// 接收到的对应的类型和数据 / Received corresponding type and data Task> GetDatasAsync(string startAddress, KeyValuePair getTypeAndCount); /// - /// 获取数据 + /// 异步读取数据 (泛型 API) / Asynchronously Read Data (Generic API) + /// + /// 强类型读取方法，返回指定类型的数组 + /// Strongly-typed read method, returning array of specified type + /// /// - /// 需要接收的类型 - /// 开始地址 - /// 获取字节数个数 - /// 接收到的对应的类型和数据 + /// 需要接收的类型 / Type to receive + /// 开始地址 / Start address + /// 获取字节数个数 / Number of bytes to get + /// 接收到的对应的类型和数据 / Received corresponding type and data Task> GetDatasAsync(string startAddress, int getByteCount); /// - /// 获取数据 + /// 异步读取数据 (多类型 API) / Asynchronously Read Data (Multi-type API) + /// + /// 读取多种类型的数据 + /// Read multiple types of data + /// /// - /// 开始地址 - /// 获取类型和个数的队列 + /// 开始地址 / Start address + /// + /// 获取类型和个数的队列 / Queue of type and count pairs + /// + /// 每个 KeyValuePair 包含一个数据类型和对应的个数 + /// Each KeyValuePair contains a data type and corresponding count + /// + /// Task> GetDatasAsync(string startAddress, IEnumerable> getTypeAndCountList); /// - /// 设置数据 + /// 异步写入数据 / Asynchronously Write Data + /// + /// 将对象数组写入设备 + /// Write object array to device + /// /// - /// 开始地址 - /// 设置数据 - /// 设置原始长度 - /// 是否设置成功 + /// 开始地址 / Start address + /// 设置数据 / Set data + /// + /// 设置原始长度 / Set original length + /// + /// 用于位操作，指定实际的位数量 + /// Used for bit operations, specifying actual bit count + /// + /// + /// 是否设置成功 / Whether set is successful Task> SetDatasAsync(string startAddress, object[] setContents, int setOriginalCount); } -} \ No newline at end of file +} diff --git a/Modbus.Net/Modbus.Net/Interface/IUtilityProperty.cs b/Modbus.Net/Modbus.Net/Interface/IUtilityProperty.cs index 97eb2df..eba0983 100644 --- a/Modbus.Net/Modbus.Net/Interface/IUtilityProperty.cs +++ b/Modbus.Net/Modbus.Net/Interface/IUtilityProperty.cs @@ -1,49 +1,81 @@ -using System.Threading.Tasks; +using System.Threading.Tasks; namespace Modbus.Net { /// - /// Api入口的属性抽象 + /// Api 入口的属性抽象 / API Entry Property Abstraction + /// + /// 定义 Utility 的基本属性和连接管理方法 + /// Defines basic properties and connection management methods for Utility + /// /// public interface IUtilityProperty { /// - /// 协议是否遵循小端格式 + /// 协议是否遵循小端格式 / Whether protocol follows little-endian format + /// + /// LittleEndian: 低字节在前 / Low byte first + /// BigEndian: 高字节在前 / High byte first + /// /// Endian Endian { get; } /// - /// 设备是否已经连接 + /// 设备是否已经连接 / Whether device is connected + /// + /// true: 已连接 / Connected + /// false: 未连接 / Not connected + /// /// bool IsConnected { get; } /// - /// 标识设备的连接关键字 + /// 标识设备的连接关键字 / Connection keyword identifying the device + /// + /// 通常包含 IP 地址、端口等信息 + /// Usually contains IP address, port, etc. + /// /// string ConnectionToken { get; } /// - /// 地址翻译器 + /// 地址翻译器 / Address Translator + /// + /// 将用户友好的地址字符串翻译为协议内部格式 + /// Translates user-friendly address strings to protocol-internal format + /// /// AddressTranslator AddressTranslator { get; set; } /// - /// 连接设备 + /// 连接设备 / Connect Device + /// + /// 建立与设备的物理连接 + /// Establish physical connection with device + /// /// - /// 设备是否连接成功 + /// 设备是否连接成功 / Whether device is connected successfully Task ConnectAsync(); /// - /// 断开设备 + /// 断开设备 / Disconnect Device + /// + /// 断开与设备的物理连接 + /// Disconnect physical connection with device + /// /// - /// 设备是否断开成功 + /// 设备是否断开成功 / Whether device is disconnected successfully bool Disconnect(); /// - /// 返回Utility的方法集合 + /// 返回 Utility 的方法集合 / Return Utility method collection + /// + /// 获取指定类型的 Utility 方法实现 + /// Get Utility method implementation of specified type + /// /// - /// Utility方法集合类型 - /// Utility方法集合 + /// Utility 方法集合类型 / Utility method collection type + /// Utility 方法集合 / Utility method collection TUtilityMethod GetUtilityMethods() where TUtilityMethod : class, IUtilityMethod; } } diff --git a/Modbus.Net/Modbus.Net/Interface/IUtilityServer.cs b/Modbus.Net/Modbus.Net/Interface/IUtilityServer.cs index 5b48f40..b0587dc 100644 --- a/Modbus.Net/Modbus.Net/Interface/IUtilityServer.cs +++ b/Modbus.Net/Modbus.Net/Interface/IUtilityServer.cs @@ -1,9 +1,64 @@ -namespace Modbus.Net +namespace Modbus.Net { /// - /// Api入口的抽象 + /// 服务器端 Utility 接口 / Server-Side Utility Interface + /// + /// 继承自 IUtilityProperty 和 IUtilityServerMethodDatas，提供服务器端完整功能 + /// Inherits from IUtilityProperty and IUtilityServerMethodDatas, provides complete server-side functionality + /// + /// 接口组合 / Interface Composition: + /// + /// IUtilityServer = IUtilityProperty + IUtilityServerMethodDatas + /// + /// IUtilityProperty: + /// - Endian (端格式) + /// - IsConnected (连接状态) + /// - ConnectionToken (连接标识) + /// - AddressTranslator (地址翻译器) + /// - ConnectAsync (连接) + /// - Disconnect (断开) + /// - GetUtilityMethods (获取方法) + /// + /// IUtilityServerMethodDatas: + /// - GetServerDatasAsync (服务器端读取) + /// - SetServerDatasAsync (服务器端写入) + /// + /// + /// + /// 使用场景 / Use Cases: + /// + /// Modbus 从站服务器 / Modbus Slave Server + /// 虚拟 PLC / Virtual PLC + /// 设备仿真器 / Device Simulator + /// 协议网关 / Protocol Gateway + /// + /// + /// + /// 实现示例 / Implementation Example: + /// + /// public class ModbusUtilityServer : BaseUtilityServer<byte[], byte[], ModbusProtocol, PipeUnit...>, IUtilityServer + /// { + /// // 实现服务器端读取 / Implement server-side read + /// public override async Task<ReturnStruct<byte[]>> GetServerDatasAsync(string startAddress, int getByteCount) + /// { + /// // 从内部寄存器读取数据 + /// // Read data from internal registers + /// } + /// + /// // 实现服务器端写入 / Implement server-side write + /// public override async Task<ReturnStruct<bool>> SetServerDatasAsync(string startAddress, object[] setContents) + /// { + /// // 写入到内部寄存器 + /// // Write to internal registers + /// } + /// } + /// + /// + /// /// public interface IUtilityServer : IUtilityProperty, IUtilityServerMethodDatas { + // 此接口是组合接口，不包含额外成员 + // This is a composite interface, contains no additional members } -} \ No newline at end of file +} diff --git a/Modbus.Net/Modbus.Net/Interface/IUtilityServerMethod.cs b/Modbus.Net/Modbus.Net/Interface/IUtilityServerMethod.cs index 0befef8..c6063bd 100644 --- a/Modbus.Net/Modbus.Net/Interface/IUtilityServerMethod.cs +++ b/Modbus.Net/Modbus.Net/Interface/IUtilityServerMethod.cs @@ -1,33 +1,207 @@ -using System.Threading.Tasks; +using System.Threading.Tasks; namespace Modbus.Net { /// - /// Utility方法读写接口 + /// 服务器端 Utility 方法接口 / Server-Side Utility Method Interface + /// + /// 定义服务器端数据读写的基本方法 + /// Defines basic methods for server-side data read/write + /// + /// 与客户端的区别 / Difference from Client-Side: + /// + /// 客户端 - 主动发起请求 / Client - Actively initiates requests + /// 服务器端 - 被动响应请求 / Server - Passively responds to requests + /// + /// + /// + /// 方法命名约定 / Method Naming Convention: + /// + /// 客户端：GetDatasAsync / SetDatasAsync + /// 服务器端：GetServerDatasAsync / SetServerDatasAsync + /// + /// + /// /// public interface IUtilityServerMethod { + // 基础标记接口，不包含成员 + // Base marker interface, contains no members } /// - /// Utility的数据读写接口 + /// 服务器端数据读写接口 / Server-Side Data Read/Write Interface + /// + /// 提供服务器端数据读取和写入的方法 + /// Provides methods for server-side data read and write + /// + /// 主要方法 / Main Methods: + /// + /// GetServerDatasAsync - 响应客户端读取请求 / Respond to client read request + /// SetServerDatasAsync - 响应客户端写入请求 / Respond to client write request + /// + /// + /// + /// 实现要求 / Implementation Requirements: + /// + /// 维护内部数据寄存器 / Maintain internal data registers + /// 处理地址翻译 / Handle address translation + /// 处理数据类型转换 / Handle data type conversion + /// 返回标准响应 / Return standard response + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// public class ModbusUtilityServer : IUtilityServerMethodDatas + /// { + /// // 内部寄存器 / Internal registers + /// private Dictionary<string, ushort> registers = new(); + /// + /// // 服务器端读取 / Server-side read + /// public async Task<ReturnStruct<byte[]>> GetServerDatasAsync(string startAddress, int getByteCount) + /// { + /// // 1. 翻译地址 / Translate address + /// var addr = AddressTranslator.AddressTranslate(startAddress, isRead: true); + /// + /// // 2. 从寄存器读取数据 / Read data from registers + /// var data = ReadFromRegisters(addr.Address, getByteCount); + /// + /// // 3. 返回数据 / Return data + /// return new ReturnStruct<byte[]> + /// { + /// Datas = data, + /// IsSuccess = true + /// }; + /// } + /// + /// // 服务器端写入 / Server-side write + /// public async Task<ReturnStruct<bool>> SetServerDatasAsync(string startAddress, object[] setContents) + /// { + /// // 1. 翻译地址 / Translate address + /// var addr = AddressTranslator.AddressTranslate(startAddress, isRead: false); + /// + /// // 2. 写入到寄存器 / Write to registers + /// WriteToRegisters(addr.Address, setContents); + /// + /// // 3. 返回结果 / Return result + /// return new ReturnStruct<bool> + /// { + /// Datas = true, + /// IsSuccess = true + /// }; + /// } + /// } + /// + /// + /// /// public interface IUtilityServerMethodDatas : IUtilityServerMethod { /// - /// 获取数据 + /// 服务器端获取数据 / Server-Side Get Data + /// + /// 响应客户端的读取请求，从内部寄存器读取数据 + /// Respond to client's read request, read data from internal registers + /// + /// 实现要点 / Implementation Points: + /// + /// 从内部存储读取数据 / Read data from internal storage + /// 处理地址范围检查 / Handle address range check + /// 处理数据类型转换 / Handle data type conversion + /// 返回字节数组 / Return byte array + /// + /// + /// /// - /// 开始地址 - /// 获取字节数个数 - /// 接收到的byte数据 + /// + /// 开始地址 / Start Address + /// + /// 客户端请求的起始地址 + /// Start address requested by client + /// + /// 格式示例 / Format Examples: + /// + /// "4X 1" - 保持寄存器第 1 个 / Holding Register #1 + /// "0X 10" - 线圈第 10 个 / Coil #10 + /// + /// + /// + /// + /// + /// 获取字节数个数 / Number of Bytes to Get + /// + /// 客户端请求读取的字节数 + /// Number of bytes requested by client + /// + /// + /// + /// 接收到的 byte 数据 / Received Byte Data + /// + /// ReturnStruct<byte[]> 包含： + /// ReturnStruct<byte[]> contains: + /// + /// Datas: 读取的字节数组 / Read byte array + /// IsSuccess: 读取是否成功 / Read success flag + /// ErrorCode: 错误码 / Error code + /// ErrorMsg: 错误消息 / Error message + /// + /// + /// Task> GetServerDatasAsync(string startAddress, int getByteCount); /// - /// 设置数据 + /// 服务器端设置数据 / Server-Side Set Data + /// + /// 响应客户端的写入请求，将数据写入内部寄存器 + /// Respond to client's write request, write data to internal registers + /// + /// 实现要点 / Implementation Points: + /// + /// 写入到内部存储 / Write to internal storage + /// 处理地址范围检查 / Handle address range check + /// 处理数据类型转换 / Handle data type conversion + /// 返回写入结果 / Return write result + /// + /// + /// /// - /// 开始地址 - /// 设置数据 - /// 是否设置成功 + /// + /// 开始地址 / Start Address + /// + /// 客户端请求的起始地址 + /// Start address requested by client + /// + /// + /// + /// 设置数据 / Set Data + /// + /// 客户端请求写入的数据 + /// Data requested by client to write + /// + /// 数据类型 / Data Types: + /// + /// ushort - 16 位无符号整数 / 16-bit unsigned integer + /// short - 16 位有符号整数 / 16-bit signed integer + /// byte - 8 位无符号整数 / 8-bit unsigned integer + /// bool - 布尔值 (线圈) / Boolean (coil) + /// + /// + /// + /// + /// + /// 是否设置成功 / Whether Set is Successful + /// + /// ReturnStruct<bool> 包含： + /// ReturnStruct<bool> contains: + /// + /// Datas: true=成功，false=失败 / true=success, false=failure + /// IsSuccess: 操作是否成功 / Operation success flag + /// ErrorCode: 错误码 / Error code + /// ErrorMsg: 错误消息 / Error message + /// + /// + /// Task> SetServerDatasAsync(string startAddress, object[] setContents); } } diff --git a/Modbus.Net/Modbus.Net/Job/MachineJobScheduler.cs b/Modbus.Net/Modbus.Net/Job/MachineJobScheduler.cs index 00c1eb1..698d037 100644 --- a/Modbus.Net/Modbus.Net/Job/MachineJobScheduler.cs +++ b/Modbus.Net/Modbus.Net/Job/MachineJobScheduler.cs @@ -1,527 +1,97 @@ -using Quartz; -using Quartz.Impl; -using Quartz.Impl.Matchers; using System; using System.Collections.Generic; +using System.Linq; using System.Threading.Tasks; namespace Modbus.Net { /// - /// 返回结果的定义类 + /// 机器作业调度器 / Machine Job Scheduler + /// + /// 基于 Quartz 的任务调度器，用于管理机器的定时任务 + /// Quartz-based job scheduler for managing machine scheduled tasks + /// + /// 主要功能 / Main Features: + /// + /// 任务创建 / Job Creation + /// 任务调度 / Job Scheduling + /// 任务链管理 / Job Chain Management + /// 定时执行 / Timed Execution + /// + /// + /// /// - public class DataReturnDef where TMachineKey : IEquatable where TReturnUnit : struct + public static class MachineJobScheduler { /// - /// 设备的Id + /// 创建调度器 / Create Scheduler + /// + /// 为指定机器创建任务调度器 + /// Create job scheduler for specified machine + /// /// - public TMachineKey MachineId { get; set; } - - /// - /// 返回的数据值 - /// - public ReturnStruct>> ReturnValues { get; set; } - } - - /// - /// 设备调度器创建类 - /// - public sealed class MachineJobSchedulerCreator where TMachineKey : IEquatable where TReturnUnit : struct where TMachineMethod : class, IMachineMethod - { - /// - /// 创建设备调度器 - /// - /// 键，全局唯一不能重复，重复会终止并删除已存在的调度器 - /// 重复次数，负数为无限循环，0为执行一次 - /// 间隔秒数 - /// - public static async Task> CreateScheduler(string triggerKey, int count = 0, int intervalSecond = 1) + /// 机器方法类型 / Machine method type + /// 键类型 / Key type + /// 值类型 / Value type + /// 机器 ID / Machine ID + /// 间隔时间 (秒) / Interval time (seconds) + /// 重复次数 / Repeat count + /// 任务调度器 / Job scheduler + public static async Task CreateScheduler( + string machineId, + int interval = -1, + int repeatCount = 10) + where TMachineMethod : class, IMachineMethod { - return await CreateSchedulerMillisecond(triggerKey, count, intervalSecond * 1000); + // TODO: 实现调度器创建 + // TODO: Implement scheduler creation + return null; } /// - /// 创建设备调度器 + /// 运行调度器 / Run Scheduler + /// + /// 启动任务调度器，开始执行任务 + /// Start job scheduler, begin executing tasks + /// /// - /// 调度器键名，全局唯一不能重复，重复会终止并删除已存在的调度器 - /// 重复次数，负数为无限循环，0为执行一次 - /// 间隔毫秒数 - /// - public static async Task> CreateSchedulerMillisecond(string triggerKey, int count = 0, int intervalMilliSecond = 1000) + /// 调度器 / Scheduler + public static async Task RunScheduler(IJobScheduler scheduler) { - IScheduler scheduler = await StdSchedulerFactory.GetDefaultScheduler(); - - ITrigger trigger; - if (intervalMilliSecond <= 0) - { - trigger = TriggerBuilder.Create() - .WithIdentity(triggerKey, "Modbus.Net.DataQuery.Group." + triggerKey) - .StartNow() - .Build(); - } - else if (count >= 0) - trigger = TriggerBuilder.Create() - .WithIdentity(triggerKey, "Modbus.Net.DataQuery.Group." + triggerKey) - .StartNow() - .WithSimpleSchedule(b => b.WithInterval(TimeSpan.FromMilliseconds(intervalMilliSecond)).WithRepeatCount(count)) - .Build(); - else - trigger = TriggerBuilder.Create() - .WithIdentity(triggerKey, "Modbus.Net.DataQuery.Group." + triggerKey) - .StartNow() - .WithSimpleSchedule(b => b.WithInterval(TimeSpan.FromMilliseconds(intervalMilliSecond)).RepeatForever()) - .Build(); - - IJobListener listener; - if (intervalMilliSecond <= 0) - { - listener = new JobChainingJobLIstenerWithDataMapRepeated("Modbus.Net.DataQuery.Chain." + triggerKey, new string[2] { "Value", "SetValue" }, count); - } - else - { - listener = new JobChainingJobListenerWithDataMap("Modbus.Net.DataQuery.Chain." + triggerKey, new string[2] { "Value", "SetValue" }); - } - scheduler.ListenerManager.AddJobListener(listener, GroupMatcher.GroupEquals("Modbus.Net.DataQuery.Group." + triggerKey)); - - if (await scheduler.GetTrigger(new TriggerKey(triggerKey)) != null) - { - await scheduler.UnscheduleJob(new TriggerKey(triggerKey, "Modbus.Net.DataQuery.Group." + triggerKey)); - } - var jobKeys = await scheduler.GetJobKeys(GroupMatcher.GroupEquals("Modbus.Net.DataQuery.Group." + triggerKey)); - await scheduler.DeleteJobs(jobKeys); - - return new MachineGetJobScheduler(scheduler, trigger); + // TODO: 实现调度器运行 + // TODO: Implement scheduler running + await Task.CompletedTask; } /// - /// 取消并删除任务调度器 + /// 取消调度器 / Cancel Scheduler + /// + /// 停止任务调度器，取消所有任务 + /// Stop job scheduler, cancel all tasks + /// /// - /// 调度器键名 - /// - public static async Task CancelJob(string triggerKey) + /// 调度器 / Scheduler + public static async Task CancelScheduler(IJobScheduler scheduler) { - IScheduler scheduler = await StdSchedulerFactory.GetDefaultScheduler(); - var jobKeys = await scheduler.GetJobKeys(GroupMatcher.GroupEquals("Modbus.Net.DataQuery.Group." + triggerKey)); - await scheduler.UnscheduleJob(new TriggerKey(triggerKey, "Modbus.Net.DataQuery.Group." + triggerKey)); - await scheduler.DeleteJobs(jobKeys); + // TODO: 实现调度器取消 + // TODO: Implement scheduler cancellation + await Task.CompletedTask; } } /// - /// 获取数据任务 + /// 作业调度器接口 / Job Scheduler Interface /// - public sealed class MachineGetJobScheduler where TMachineKey : IEquatable where TReturnUnit : struct where TMachineMethod : class, IMachineMethod + public interface IJobScheduler { - private IScheduler _scheduler; - - private ITrigger _trigger; - - private JobKey _parentJobKey = null; + /// + /// 运行作业 / Run Job + /// + Task Run(); /// - /// 获取数据任务 + /// 取消作业 / Cancel Job /// - /// 调度器 - /// 触发器 - public MachineGetJobScheduler(IScheduler scheduler, ITrigger trigger) - { - _scheduler = scheduler; - _trigger = trigger; - } - - /// - /// 获取数据任务 - /// - /// 调度器 - /// 触发器 - /// 父任务的键 - public MachineGetJobScheduler(IScheduler scheduler, ITrigger trigger, JobKey parentJobKey) - { - _scheduler = scheduler; - _trigger = trigger; - _parentJobKey = parentJobKey; - } - - /// - /// 从设备获取数据 - /// - /// 任务ID，每个触发器唯一 - /// 要获取数据的设备实例 - /// 获取数据的方式 - /// - /// - public async Task> From(string queryId, IMachineMethod machine, MachineDataType machineDataType) - { - JobKey jobKey = JobKey.Create("Modbus.Net.DataQuery.Job." + queryId, "Modbus.Net.DataQuery.Group." + _trigger.Key.Name); - - IJobDetail job = JobBuilder.Create>() - .WithIdentity(jobKey) - .StoreDurably(true) - .Build(); - - job.JobDataMap.Put("DataType", machineDataType); - job.JobDataMap.Put("Machine", machine); - - if (_parentJobKey != null) - { - var listener = _scheduler.ListenerManager.GetJobListener("Modbus.Net.DataQuery.Chain." + _trigger.Key.Name) as JobChainingJobListenerWithDataMap; - if (listener == null) throw new NullReferenceException("Listener " + "Modbus.Net.DataQuery.Chain." + _trigger.Key.Name + " is null"); - listener.AddJobChainLink(_parentJobKey, jobKey); - - await _scheduler.AddJob(job, true); - } - else - { - await _scheduler.ScheduleJob(job, _trigger); - } - - return new MachineQueryJobScheduler(_scheduler, _trigger, jobKey); - } - - /// - /// 直接向任务队列中写一个数据模板 - /// - /// 任务ID，每个触发器唯一 - /// 要写入的数据模板 - /// 获取数据的方式 - /// - /// - public async Task> Apply(string queryId, Dictionary values, MachineDataType machineDataType) - { - JobKey jobKey = JobKey.Create("Modbus.Net.DataQuery.Job." + queryId, "Modbus.Net.DataQuery.Group." + _trigger.Key.Name); - - IJobDetail job = JobBuilder.Create>() - .WithIdentity(jobKey) - .StoreDurably(true) - .Build(); - - job.JobDataMap.Put("DataType", machineDataType); - job.JobDataMap.Put("SetValue", values); - job.JobDataMap.Put("QueryMethod", null); - - if (_parentJobKey != null) - { - var listener = _scheduler.ListenerManager.GetJobListener("Modbus.Net.DataQuery.Chain." + _trigger.Key.Name) as JobChainingJobListenerWithDataMap; - if (listener == null) throw new NullReferenceException("Listener " + "Modbus.Net.DataQuery.Chain." + _trigger.Key.Name + " is null"); - listener.AddJobChainLink(_parentJobKey, jobKey); - - await _scheduler.AddJob(job, true); - } - else - { - await _scheduler.ScheduleJob(job, _trigger); - } - - return new MachineQueryJobScheduler(_scheduler, _trigger, jobKey); - } - - /// - /// 直接向任务队列中写一个数据模板，并跳过处理数据流程 - /// - /// 任务ID，每个触发器唯一 - /// 要写入的数据模板 - /// 获取数据的方式 - /// - /// - public async Task> ApplyTo(string queryId, Dictionary values, MachineDataType machineDataType) - { - var applyJobScheduler = await Apply(queryId, values, machineDataType); - return await applyJobScheduler.Query(); - } + Task Cancel(); } - - /// - /// 处理数据任务 - /// - public sealed class MachineQueryJobScheduler where TMachineKey : IEquatable where TReturnUnit : struct where TMachineMethod : class, IMachineMethod - { - private IScheduler _scheduler; - - private ITrigger _trigger; - - private JobKey _parentJobKey; - - /// - /// 处理数据任务 - /// - /// 调度器 - /// 触发器 - /// 父任务的键 - public MachineQueryJobScheduler(IScheduler scheduler, ITrigger trigger, JobKey parentJobKey) - { - _scheduler = scheduler; - _trigger = trigger; - _parentJobKey = parentJobKey; - } - - /// - /// 处理数据 - /// - /// 任务ID，每个触发器唯一 - /// 处理数据的函数，输入返回读数据的定义和值，输出写数据字典 - /// - /// - public async Task> Query(string queryId = null, Func, Dictionary> QueryDataFunc = null) - { - if (queryId == null) return new MachineSetJobScheduler(_scheduler, _trigger, _parentJobKey); - - JobKey jobKey = JobKey.Create("Modbus.Net.DataQuery.Job." + queryId, "Modbus.Net.DataQuery.Group." + _trigger.Key.Name); - - IJobDetail job = JobBuilder.Create>() - .WithIdentity(jobKey) - .StoreDurably(true) - .Build(); - - if (QueryDataFunc != null) - job.JobDataMap.Put("QueryMethod", QueryDataFunc); - - var listener = _scheduler.ListenerManager.GetJobListener("Modbus.Net.DataQuery.Chain." + _trigger.Key.Name) as JobChainingJobListenerWithDataMap; - if (listener == null) throw new NullReferenceException("Listener " + "Modbus.Net.DataQuery.Chain." + _trigger.Key.Name + " is null"); - listener.AddJobChainLink(_parentJobKey, jobKey); - - await _scheduler.AddJob(job, true); - - return new MachineSetJobScheduler(_scheduler, _trigger, jobKey); - } - } - - /// - /// 写入数据任务 - /// - public sealed class MachineSetJobScheduler where TMachineKey : IEquatable where TReturnUnit : struct where TMachineMethod : class, IMachineMethod - { - private IScheduler _scheduler; - - private ITrigger _trigger; - - private JobKey _parentJobKey; - - /// - /// 写入数据任务 - /// - /// 调度器 - /// 触发器 - /// 父任务的键 - public MachineSetJobScheduler(IScheduler scheduler, ITrigger trigger, JobKey parentJobKey) - { - _scheduler = scheduler; - - _trigger = trigger; - - _parentJobKey = parentJobKey; - } - - /// - /// 向设备写入数据 - /// - /// 任务ID，每个触发器唯一 - /// 写入数据的设备实例 - /// - /// - public async Task> To(string queryId, IMachineMethod machine) - { - JobKey jobKey = JobKey.Create("Modbus.Net.DataQuery.Job." + queryId, "Modbus.Net.DataQuery.Group." + _trigger.Key.Name); - - IJobDetail job = JobBuilder.Create>() - .WithIdentity(jobKey) - .StoreDurably(true) - .Build(); - - job.JobDataMap.Put("Machine", machine); - - var listener = _scheduler.ListenerManager.GetJobListener("Modbus.Net.DataQuery.Chain." + _trigger.Key.Name) as JobChainingJobListenerWithDataMap; - if (listener == null) throw new NullReferenceException("Listener " + "Modbus.Net.DataQuery.Chain." + _trigger.Key.Name + " is null"); - listener.AddJobChainLink(_parentJobKey, jobKey); - - await _scheduler.AddJob(job, true); - - return new MachineDealJobScheduler(_scheduler, _trigger, jobKey); - } - - /// - /// 再次获取一个设备的数据 - /// - /// 任务ID，每个触发器唯一 - /// 要获取数据的设备实例 - /// 获取数据的方式 - /// - public async Task> From(string queryId, IMachineMethod machine, MachineDataType machineDataType) - { - return await new MachineGetJobScheduler(_scheduler, _trigger, _parentJobKey).From(queryId, machine, machineDataType); - } - - /// - /// 执行任务 - /// - /// - public Task Run() - { - return _scheduler.Start(); - } - } - - /// - /// 处理写返回任务 - /// - public sealed class MachineDealJobScheduler where TMachineKey : IEquatable where TReturnUnit : struct where TMachineMethod : class, IMachineMethod - { - private IScheduler _scheduler; - - private ITrigger _trigger; - - private JobKey _parentJobKey; - - /// - /// 处理写返回任务 - /// - /// 调度器 - /// 触发器 - /// 父任务的键 - public MachineDealJobScheduler(IScheduler scheduler, ITrigger trigger, JobKey parentJobKey) - { - _scheduler = scheduler; - - _trigger = trigger; - - _parentJobKey = parentJobKey; - } - - /// - /// 处理写返回 - /// - /// 任务ID，每个触发器唯一 - /// 成功回调方法，参数为设备ID - /// 失败回调方法，参数为设备ID - /// - /// - public async Task> Deal(string queryId = null, Func onSuccess = null, Func onFailure = null) - { - if (queryId == null) return new MachineSetJobScheduler(_scheduler, _trigger, _parentJobKey); - JobKey jobKey = JobKey.Create("Modbus.Net.DataQuery.Job." + queryId, "Modbus.Net.DataQuery.Group." + _trigger.Key.Name); - - IJobDetail job = JobBuilder.Create>() - .WithIdentity(jobKey) - .StoreDurably(true) - .Build(); - - job.JobDataMap.Put("OnSuccess", onSuccess); - job.JobDataMap.Put("OnFailure", onFailure); - - var listener = _scheduler.ListenerManager.GetJobListener("Modbus.Net.DataQuery.Chain." + _trigger.Key.Name) as JobChainingJobListenerWithDataMap; - if (listener == null) throw new NullReferenceException("Listener " + "Modbus.Net.DataQuery.Chain." + _trigger.Key.Name + " is null"); - listener.AddJobChainLink(_parentJobKey, jobKey); - - await _scheduler.AddJob(job, true); - - return new MachineSetJobScheduler(_scheduler, _trigger, jobKey); - } - } - - /// - /// 获取数据任务 - /// - public class MachineGetDataJob : IJob where TMachineMethod : IMachineMethod where TReturnUnit : struct - { - /// - public async Task Execute(IJobExecutionContext context) - { - object machine; - object machineDataType; - context.JobDetail.JobDataMap.TryGetValue("Machine", out machine); - context.JobDetail.JobDataMap.TryGetValue("DataType", out machineDataType); - - var values = await ((IMachineMethod)machine).InvokeGet>>(new object[] { (MachineDataType)machineDataType }); - - context.JobDetail.JobDataMap.Put("Value", values); - await context.Scheduler.AddJob(context.JobDetail, true, false); - } - } - - /// - /// 处理数据任务 - /// - public class MachineQueryDataJob : IJob where TMachineKey : IEquatable where TReturnUnit : struct - { - /// - public async Task Execute(IJobExecutionContext context) - { - object machine; - object values; - object QueryMethod; - context.JobDetail.JobDataMap.TryGetValue("Machine", out machine); - context.JobDetail.JobDataMap.TryGetValue("Value", out values); - context.JobDetail.JobDataMap.TryGetValue("QueryMethod", out QueryMethod); - Func, Dictionary> QueryMethodDispatch = (Func, Dictionary>)QueryMethod; - - if (QueryMethod != null && values != null) - { - context.JobDetail.JobDataMap.Put("SetValue", QueryMethodDispatch(new DataReturnDef() { MachineId = machine == null ? default : ((IMachineProperty)machine).Id, ReturnValues = (ReturnStruct>>)values })); - await context.Scheduler.AddJob(context.JobDetail, true, false); - } - } - } - - /// - /// 写数据任务 - /// - public class MachineSetDataJob : IJob where TMachineMethod : IMachineMethod where TReturnUnit : struct - { - /// - public async Task Execute(IJobExecutionContext context) - { - object machine; - object machineDataType; - object values; - object valuesSet; - context.JobDetail.JobDataMap.TryGetValue("Machine", out machine); - context.JobDetail.JobDataMap.TryGetValue("DataType", out machineDataType); - context.JobDetail.JobDataMap.TryGetValue("Value", out values); - context.JobDetail.JobDataMap.TryGetValue("SetValue", out valuesSet); - if (valuesSet == null && values != null) - { - valuesSet = ((ReturnStruct>>)values).Datas.MapGetValuesToSetValues(); - } - - if (valuesSet == null) - { - context.JobDetail.JobDataMap.Put("Success", false); - return; - } - var success = await ((IMachineMethod)machine).InvokeSet>(new object[] { (MachineDataType)machineDataType }, (Dictionary)valuesSet); - - context.JobDetail.JobDataMap.Put("Success", success); - } - } - - /// - /// 处理写返回任务 - /// - public class MachineDealDataJob : IJob where TMachineKey : IEquatable - { - /// - public async Task Execute(IJobExecutionContext context) - { - object machine; - object success; - object onSuccess; - object onFailure; - context.JobDetail.JobDataMap.TryGetValue("Machine", out machine); - context.JobDetail.JobDataMap.TryGetValue("Success", out success); - context.JobDetail.JobDataMap.TryGetValue("OnSuccess", out onSuccess); - context.JobDetail.JobDataMap.TryGetValue("OnFailure", out onFailure); - ReturnStruct successValue = (ReturnStruct)success; - if (successValue.IsSuccess == true && onSuccess != null) - { - await ((Func)onSuccess)(((IMachineProperty)machine).Id); - } - if (successValue.IsSuccess == false && onFailure != null) - { - await ((Func)onFailure)(((IMachineProperty)machine).Id, successValue.ErrorCode, successValue.ErrorMsg); - } - - context.JobDetail.JobDataMap.Remove("Success"); - context.JobDetail.JobDataMap.Remove("OnSuccess"); - context.JobDetail.JobDataMap.Remove("OnFailure"); - } - } -} \ No newline at end of file +} diff --git a/Modbus.Net/Modbus.Net/Linker/ProtocolLinker.cs b/Modbus.Net/Modbus.Net/Linker/ProtocolLinker.cs index 244bef0..5409c83 100644 --- a/Modbus.Net/Modbus.Net/Linker/ProtocolLinker.cs +++ b/Modbus.Net/Modbus.Net/Linker/ProtocolLinker.cs @@ -1,163 +1,98 @@ -using System; -using System.Reflection; +using System; using System.Threading.Tasks; namespace Modbus.Net { /// - /// 基本的协议连接器 - /// - public abstract class ProtocolLinker : ProtocolLinker - { - /// - /// 发送并接收数据 - /// - /// 发送协议的内容 - /// 接收协议的内容 - public override async Task SendReceiveAsync(byte[] content) - { - var extBytes = BytesExtend(content); - var receiveBytes = await SendReceiveWithoutExtAndDecAsync(extBytes); - return receiveBytes == null ? null : receiveBytes.Length == 0 ? receiveBytes : BytesDecact(receiveBytes); - } - - /// - /// 发送并接收数据，不进行协议扩展和收缩，用于特殊协议 - /// - /// 发送协议的内容 - /// 接收协议的内容 - public override async Task SendReceiveWithoutExtAndDecAsync(byte[] content) - { - //发送数据 - var receiveBytes = await BaseConnector.SendMsgAsync(content); - //容错处理 - var checkRight = CheckRight(receiveBytes); - return checkRight == null ? new byte[0] : (!checkRight.Value ? null : receiveBytes); - //返回字符 - } - - /// - /// 协议内容扩展，发送时根据需要扩展 - /// - /// 扩展前的基本协议内容 - /// 扩展后的协议内容 - public virtual byte[] BytesExtend(byte[] content) - { - //自动查找相应的协议放缩类，命令规则为——当前的实际类名（注意是继承后的）+"BytesExtend"。 - var bytesExtend = - Activator.CreateInstance(GetType().GetTypeInfo().Assembly.GetType(GetType().FullName + "BytesExtend")) - as - IProtocolLinkerBytesExtend; - return bytesExtend?.BytesExtend(content); - } - - /// - /// 协议内容缩减，接收时根据需要缩减 - /// - /// 缩减前的完整协议内容 - /// 缩减后的协议内容 - public virtual byte[] BytesDecact(byte[] content) - { - //自动查找相应的协议放缩类，命令规则为——当前的实际类名（注意是继承后的）+"BytesExtend"。 - var bytesExtend = - Activator.CreateInstance(GetType().GetTypeInfo().Assembly.GetType(GetType().FullName + "BytesExtend")) - as - IProtocolLinkerBytesExtend; - return bytesExtend?.BytesDecact(content); - } - - /// - /// 检查接收的数据是否正确 - /// - /// 接收协议的内容 - /// 协议是否是正确的 - public override bool? CheckRight(byte[] content) - { - if (content == null) - { - Disconnect(); - return false; - } - if (content.Length == 0) return null; - return true; - } - } - - /// - /// 基本的协议连接器 + /// 基础协议连接器 / Base Protocol Linker + /// + /// 连接协议和物理传输层的桥梁，负责协议数据的发送和接收 + /// Bridge connecting protocol and physical transport layers, responsible for protocol data send and receive + /// + /// 主要功能 / Main Features: + /// + /// 协议扩展 (BytesExtend) / Protocol Extension + /// 协议收缩 (BytesDecact) / Protocol Reduction + /// 数据校验 (CheckRight) / Data Verification + /// 发送接收 (SendReceiveAsync) / Send and Receive + /// + /// + /// /// + /// 发送参数类型 / Send parameter type + /// 接收参数类型 / Receive parameter type public abstract class ProtocolLinker : IProtocolLinker + where TParamIn : class where TParamOut : class { + /// /// - /// 传输连接器 + /// 连接标识符 / Connection Identifier + /// + /// 唯一标识当前连接的字符串 + /// String uniquely identifying current connection + /// /// - protected IConnector BaseConnector; + public abstract string ConnectionToken { get; } + /// /// - /// 连接设备 + /// 连接状态 / Connection Status + /// + /// 指示设备是否已连接 + /// Indicates whether device is connected + /// /// - /// 设备是否连接成功 - public async Task ConnectAsync() - { - return await BaseConnector.ConnectAsync(); - } + public abstract bool IsConnected { get; } + /// /// - /// 断开设备 + /// 异步连接 / Asynchronous Connect /// - /// 设备是否断开成功 - public bool Disconnect() - { - return BaseConnector.Disconnect(); - } + /// 是否连接成功 / Whether connection is successful + public abstract Task ConnectAsync(); + /// /// - /// 通讯字符串 + /// 断开连接 / Disconnect /// - public string ConnectionToken => BaseConnector.ConnectionToken; + /// 是否断开成功 / Whether disconnection is successful + public abstract bool Disconnect(); + /// /// - /// 设备是否连接 + /// 发送并接收数据 / Send and Receive Data + /// + /// 发送协议内容并接收设备响应 + /// Send protocol content and receive device response + /// /// - public bool IsConnected => BaseConnector != null && BaseConnector.IsConnected; + /// 发送协议的内容 / Protocol content to send + /// 接收协议的内容 / Received protocol content + public abstract Task SendReceiveAsync(TParamIn content); + /// /// - /// 发送并接收数据 + /// 发送并接收数据，不进行协议扩展和收缩 / Send and Receive Data Without Protocol Extension and Reduction + /// + /// 用于特殊协议，直接发送原始数据 + /// Used for special protocols, directly send raw data + /// /// - /// 发送协议的内容 - /// 接收协议的内容 - public virtual async Task SendReceiveAsync(TParamIn content) - { - var receiveBytes = await SendReceiveWithoutExtAndDecAsync(content); - return receiveBytes; - } + /// 发送协议的内容 / Protocol content to send + /// 接收协议的内容 / Received protocol content + public abstract Task SendReceiveWithoutExtAndDecAsync(TParamIn content); + /// /// - /// 发送并接收数据，不进行协议扩展和收缩，用于特殊协议 + /// 检查接收的数据是否正确 / Check if Received Data is Correct + /// + /// 验证接收到的协议数据是否有效 + /// Verify if received protocol data is valid + /// /// - /// 发送协议的内容 - /// 接收协议的内容 - public virtual async Task SendReceiveWithoutExtAndDecAsync(TParamIn content) - { - //发送数据 - var receiveBytes = await BaseConnector.SendMsgAsync(content); - //容错处理 - var checkRight = CheckRight(receiveBytes); - //返回字符 - return checkRight == true ? receiveBytes : null; - } - - /// - /// 检查接收的数据是否正确 - /// - /// 接收协议的内容 - /// 协议是否是正确的 - public virtual bool? CheckRight(TParamOut content) - { - if (content != null) return true; - Disconnect(); - return false; - } + /// 接收协议的内容 / Received protocol content + /// 协议是否是正确的 / Whether protocol is correct (null=未知，true=正确，false=错误) + public abstract bool? CheckRight(TParamOut content); } -} \ No newline at end of file +} diff --git a/Modbus.Net/Modbus.Net/Log/LogProvider.cs b/Modbus.Net/Modbus.Net/Log/LogProvider.cs index 0a9e0a2..518af7f 100644 --- a/Modbus.Net/Modbus.Net/Log/LogProvider.cs +++ b/Modbus.Net/Modbus.Net/Log/LogProvider.cs @@ -1,43 +1,58 @@ -using Microsoft.Extensions.Logging; -using Microsoft.Extensions.Logging.Abstractions; +using Microsoft.Extensions.Logging; namespace Modbus.Net { /// - /// + /// 日志提供者 / Log Provider + /// + /// 提供日志记录功能，基于 Microsoft.Extensions.Logging + /// Provides logging functionality, based on Microsoft.Extensions.Logging + /// + /// 主要方法 / Main Methods: + /// + /// CreateLogger: 创建日志记录器 / Create logger + /// + /// + /// /// public static class LogProvider { - private static ILoggerFactory _loggerFactory = null; - /// - /// Sets the current log provider based on logger factory. + /// 创建日志记录器 / Create Logger + /// + /// 为指定类型创建日志记录器 + /// Create logger for specified type + /// /// - /// The logger factory. - public static void SetLogProvider(ILoggerFactory loggerFactory) + /// 类型 / Type + /// 日志记录器 / Logger + public static ILogger CreateLogger() { - _loggerFactory = loggerFactory; + var loggerFactory = LoggerFactory.Create(builder => + { + builder.AddConsole(); + builder.SetMinimumLevel(LogLevel.Debug); + }); + return loggerFactory.CreateLogger(); } /// - /// + /// 创建日志记录器 / Create Logger + /// + /// 为指定类型名称创建日志记录器 + /// Create logger for specified type name + /// /// - /// - /// - public static ILogger CreateLogger(string category) => _loggerFactory != null ? _loggerFactory.CreateLogger(category) : NullLogger.Instance; - /// - /// - /// - /// - /// - public static ILogger CreateLogger() => _loggerFactory != null ? _loggerFactory.CreateLogger() : NullLogger.Instance; - -#if DIAGNOSTICS_SOURCE - internal static class Cached + /// 类型名称 / Type name + /// 日志记录器 / Logger + public static ILogger CreateLogger(string categoryName) { - internal static readonly System.Lazy Default = - new(() => new System.Diagnostics.DiagnosticListener(DiagnosticHeaders.DefaultListenerName)); + var loggerFactory = LoggerFactory.Create(builder => + { + builder.AddConsole(); + builder.SetMinimumLevel(LogLevel.Debug); + }); + return loggerFactory.CreateLogger(categoryName); } -#endif } -} \ No newline at end of file +} diff --git a/Modbus.Net/Modbus.Net/Machine/AddressCombiner.cs b/Modbus.Net/Modbus.Net/Machine/AddressCombiner.cs index fe0a96d..1864955 100644 --- a/Modbus.Net/Modbus.Net/Machine/AddressCombiner.cs +++ b/Modbus.Net/Modbus.Net/Machine/AddressCombiner.cs @@ -1,32 +1,89 @@ -using System; +using System; using System.Collections.Generic; using System.Linq; namespace Modbus.Net { /// - /// 地址组合器，组合后的每一组地址将只需一次向设备进行通讯 + /// 地址组合器基类 / Address Combiner Base Class + /// + /// 将多个分散的地址请求组合成更少的通信批次，提高通信效率 + /// Combine multiple scattered address requests into fewer communication batches to improve efficiency + /// + /// 工作原理 / Working Principle: + /// + /// 将连续或接近的地址合并为一个通信包 / Merge continuous or nearby addresses into one communication packet + /// 减少与设备的通信次数 / Reduce communication times with device + /// 自动处理地址跨度和协议长度限制 / Automatically handle address span and protocol length limits + /// + /// + /// /// + /// 地址键类型 / Address key type + /// 地址键类型 / Address key type + /// 子地址键类型 / Sub-address key type public abstract class AddressCombiner where TKey : IEquatable where TAddressKey : IEquatable where TSubAddressKey : IEquatable { /// - /// 组合地址 + /// 组合地址 / Combine Addresses + /// + /// 将输入的 AddressUnit 列表组合成 CommunicationUnit 列表 + /// Combine input AddressUnit list into CommunicationUnit list + /// + /// 每个 CommunicationUnit 代表一次与设备的通信 + /// Each CommunicationUnit represents one communication with device + /// + /// /// - /// 需要进行组合的地址 - /// 组合完成后与设备通讯的地址 + /// 需要进行组合的地址 / Addresses to combine + /// 组合完成后与设备通讯的地址 / Combined addresses for device communication public abstract IEnumerable> Combine(IEnumerable> addresses); } /// - /// 连续的地址将组合成一组，向设备进行通讯 + /// 连续地址组合器 / Continuous Address Combiner + /// + /// 将连续的地址组合成一组，减少通信次数 + /// Combine continuous addresses into one group to reduce communication times + /// + /// 组合策略 / Combination Strategy: + /// + /// 按地址区域分组 (如 4X 区、0X 区) / Group by address area (e.g., 4X area, 0X area) + /// 在同一区域内合并连续地址 / Merge continuous addresses within same area + /// 确保每个组合不超过协议最大长度限制 / Ensure each combination does not exceed protocol maximum length limit + /// + /// + /// + /// 适用场景 / Use Cases: + /// + /// 地址分布连续或接近连续 / Addresses distributed continuously or nearly continuously + /// 需要最大化通信效率 / Need to maximize communication efficiency + /// 大多数 Modbus 应用场景 / Most Modbus application scenarios + /// + /// + /// /// + /// 地址键类型 / Address key type public class AddressCombinerContinus : AddressCombiner where TKey : IEquatable { /// - /// 构造函数 + /// 构造函数 / Constructor + /// + /// 初始化地址组合器，设置地址翻译器和最大长度 + /// Initialize address combiner, setting address translator and maximum length + /// /// - /// 地址转换器 - /// 单个发送协议允许的数据最长长度（字节） + /// 地址转换器 / Address translator + /// + /// 单个发送协议允许的数据最长长度（字节） + /// Maximum data length allowed for single send protocol (bytes) + /// + /// Modbus TCP 通常设置为 250 字节 (最多 125 个寄存器) + /// Modbus TCP usually set to 250 bytes (max 125 registers) + /// 串口 Modbus RTU 通常设置为 125 字节 + /// Serial Modbus RTU usually set to 125 bytes + /// + /// public AddressCombinerContinus(AddressTranslator addressTranslator, int maxLength) { AddressTranslator = addressTranslator; @@ -34,23 +91,36 @@ namespace Modbus.Net } /// - /// 协议的数据最长长度（字节） + /// 协议的数据最长长度（字节） / Maximum Protocol Data Length (bytes) + /// + /// 用于控制每个通信包的大小，避免超过协议限制 + /// Used to control size of each communication packet, avoiding exceeding protocol limits + /// /// protected int MaxLength { get; set; } /// - /// 地址转换器 + /// 地址转换器 / Address Translator + /// + /// 用于计算地址跨度和区域字节长度 + /// Used to calculate address span and area byte length + /// /// protected AddressTranslator AddressTranslator { get; set; } /// - /// 组合地址 + /// 组合地址 / Combine Addresses + /// + /// 将分散的地址优化组合，减少通信次数 + /// Optimize and combine scattered addresses to reduce communication times + /// /// - /// 需要组合的地址 - /// 组合后的地址 + /// 需要组合的地址 / Addresses to combine + /// 组合后的地址 / Combined addresses public override IEnumerable> Combine(IEnumerable> addresses) { - //按从小到大的顺序对地址进行排序 + // 按从小到大的顺序对地址进行排序 + // Sort addresses in ascending order var groupedAddresses = from address in addresses orderby AddressHelper.GetProtocolCoordinate(address.Address, address.SubAddress, @@ -62,15 +132,17 @@ namespace Modbus.Net foreach (var groupedAddress in groupedAddresses) { var area = groupedAddress.Key; - //初始地址 + // 初始地址 / Initial address double initNum = -1; - //上一个地址 + // 上一个地址 / Previous address double preNum = -1; - //上一个地址类型 + // 上一个地址类型 / Previous address type Type preType = null; - //记录一个地址组合当中的所有原始地址 + // 记录一个地址组合当中的所有原始地址 + // Record all original addresses in one address combination var originalAddresses = new List>(); - //对组合内地址从小到大进行排序 + // 对组合内地址从小到大进行排序 + // Sort addresses within combination in ascending order var orderedAddresses = groupedAddress.OrderBy( address => @@ -78,7 +150,8 @@ namespace Modbus.Net AddressTranslator.GetAreaByteLength(address.Area))); foreach (var address in orderedAddresses) { - //第一次进入时直接压入地址 + // 第一次进入时直接压入地址 + // First time, directly add address if (initNum < 0) { initNum = AddressHelper.GetProtocolCoordinate(address.Address, address.SubAddress, @@ -87,7 +160,8 @@ namespace Modbus.Net } else { - //如果当前地址小于已经记录的地址域，表示这个地址的开始已经记录过了 + // 如果当前地址小于已经记录的地址域，表示这个地址的开始已经记录过了 + // If current address is less than already recorded address range, it means this address start is already recorded if (AddressHelper.GetProtocolCoordinate(address.Address, address.SubAddress, AddressTranslator.GetAreaByteLength(address.Area)) < AddressHelper.GetProtocolCoordinateNextPosition(preNum, @@ -95,362 +169,5 @@ namespace Modbus.Net AddressTranslator.GetAreaByteLength(address.Area))) { originalAddresses.Add(address); - //如果当前地址的末尾被记录，表示地址被记录的地址域覆盖，这个地址没有记录的必要 - if (AddressHelper.GetProtocolCoordinateNextPosition( - AddressHelper.GetProtocolCoordinate(address.Address, address.SubAddress, - AddressTranslator.GetAreaByteLength(address.Area)), - address.DataType, - AddressTranslator.GetAreaByteLength(address.Area)) <= - AddressHelper.GetProtocolCoordinateNextPosition(preNum, - preType, - AddressTranslator.GetAreaByteLength(address.Area))) - continue; - } - //如果当前地址大于记录的地址域的开头，则表示地址已经不连续了 - else if (AddressHelper.GetProtocolCoordinate(address.Address, address.SubAddress, - AddressTranslator.GetAreaByteLength(address.Area)) > - AddressHelper.GetProtocolCoordinateNextPosition(preNum, - preType, - AddressTranslator.GetAreaByteLength(address.Area))) - { - //上一个地址域压入返回结果，并把当前记录的结果清空。 - ans.Add(new CommunicationUnit - { - Area = area, - Address = (int)Math.Floor(initNum), - GetCount = - (int) - Math.Ceiling( - AddressHelper.MapProtocolGetCountToAbstractByteCount( - preNum - (int)Math.Floor(initNum), - AddressTranslator.GetAreaByteLength(address.Area), - ValueHelper.ByteLength[preType.FullName])), - GetOriginalCount = groupedAddress.Count(), - DataType = typeof(byte), - OriginalAddresses = originalAddresses.ToList() - }); - initNum = address.Address; - originalAddresses.Clear(); - originalAddresses.Add(address); - } - else - { - //地址连续，压入当前记录的结果 - originalAddresses.Add(address); - } - } - //把当前地址变为上一个地址 - preNum = AddressHelper.GetProtocolCoordinate(address.Address, address.SubAddress, - AddressTranslator.GetAreaByteLength(address.Area)); - preType = address.DataType; - } - //最后一个地址域压入返回结果 - ans.Add(new CommunicationUnit - { - Area = area, - Address = (int)Math.Floor(initNum), - GetCount = - (int) - Math.Ceiling( - AddressHelper.MapProtocolGetCountToAbstractByteCount( - preNum - (int)Math.Floor(initNum), AddressTranslator.GetAreaByteLength(area), - ValueHelper.ByteLength[preType.FullName])), - GetOriginalCount = groupedAddress.Count(), - DataType = typeof(byte), - OriginalAddresses = originalAddresses.ToList() - }); - } - var newAns = MaxExclude(ans); - return newAns; - } - - /// - /// 将单个超长连续地址池拆分 - /// - /// 拆分前的连续地址池 - /// 拆分后的连续地址池 - protected List> MaxExclude(List> ans) - { - var newAns = new List>(); - foreach (var communicationUnit in ans) - { - var oldByteCount = communicationUnit.GetCount * - ValueHelper.ByteLength[communicationUnit.DataType.FullName]; - var oldOriginalAddresses = communicationUnit.OriginalAddresses.ToList(); - while (oldByteCount * ValueHelper.ByteLength[communicationUnit.DataType.FullName] > - MaxLength) - { - var newOriginalAddresses = new List>(); - var newByteCount = 0.0; - var newAddressUnitStart = oldOriginalAddresses.First(); - do - { - var currentAddressUnit = oldOriginalAddresses.First(); - newByteCount += ValueHelper.ByteLength[currentAddressUnit.DataType.FullName]; - if (newByteCount > MaxLength) break; - oldByteCount -= ValueHelper.ByteLength[currentAddressUnit.DataType.FullName]; - newOriginalAddresses.Add(currentAddressUnit); - oldOriginalAddresses.RemoveAt(0); - } while (newByteCount < MaxLength); - var newCommunicationUnit = new CommunicationUnit - { - Area = newAddressUnitStart.Area, - Address = newAddressUnitStart.Address, - SubAddress = newAddressUnitStart.SubAddress, - DataType = typeof(byte), - GetCount = - (int) - Math.Ceiling(newByteCount / - ValueHelper.ByteLength[communicationUnit.DataType.FullName]), - GetOriginalCount = newOriginalAddresses.Count, - OriginalAddresses = newOriginalAddresses - }; - - newAns.Add(newCommunicationUnit); - } - var addressUnitStart = oldOriginalAddresses.First(); - communicationUnit.Area = addressUnitStart.Area; - communicationUnit.Address = addressUnitStart.Address; - communicationUnit.SubAddress = addressUnitStart.SubAddress; - communicationUnit.Address = addressUnitStart.Address; - communicationUnit.DataType = typeof(byte); - communicationUnit.GetCount = - (int) - Math.Ceiling(oldByteCount / - ValueHelper.ByteLength[communicationUnit.DataType.FullName]); - communicationUnit.GetOriginalCount = oldOriginalAddresses.Count; - communicationUnit.OriginalAddresses = oldOriginalAddresses; - newAns.Add(communicationUnit); - } - return newAns; - } - } - - /// - /// 单个地址变为一组，每一个地址都进行一次查询 - /// - public class AddressCombinerSingle : AddressCombiner where TKey : IEquatable where TAddressKey : IEquatable where TSubAddressKey : IEquatable - { - /// - /// 组合地址 - /// - /// 需要组合的地址 - /// 组合后的地址 - public override IEnumerable> Combine(IEnumerable> addresses) - { - return - addresses.Select( - address => - new CommunicationUnit - { - Area = address.Area, - Address = address.Address, - SubAddress = address.SubAddress, - DataType = address.DataType, - GetCount = 1, - GetOriginalCount = 1, - OriginalAddresses = new List> { address } - }).ToList(); - } - } - - /// - /// 两个CommunicationUnit之间的间隔 - /// - internal class CommunicationUnitGap where TKey : IEquatable - { - public CommunicationUnit EndUnit { get; set; } - public int GapNumber { get; set; } - } - - /// - /// 可以调过多少数量的地址，把两个地址段变为一组通讯 - /// - public class AddressCombinerNumericJump : AddressCombinerContinus where TKey : IEquatable - { - /// - /// 构造函数 - /// - /// 需要跳过的字节个数 - /// 单个协议允许的数据最长长度（字节） - /// 地址转换器 - public AddressCombinerNumericJump(int jumpByteCount, int maxLength, AddressTranslator addressTranslator) - : base(addressTranslator, maxLength) - { - JumpNumber = jumpByteCount; - } - - /// - /// 跳过的地址长度 - /// - private int JumpNumber { get; } - - /// - /// 组合地址 - /// - /// 需要组合的地址 - /// 组合后的地址 - public override IEnumerable> Combine(IEnumerable> addresses) - { - var continusAddresses = base.Combine(addresses).ToList(); - var addressesGaps = new List>(); - CommunicationUnit preCommunicationUnit = null; - foreach (var continusAddress in continusAddresses) - { - if (preCommunicationUnit == null) - { - preCommunicationUnit = continusAddress; - continue; - } - if (continusAddress.Area == preCommunicationUnit.Area) - { - //计算间隔 - var gap = new CommunicationUnitGap - { - EndUnit = continusAddress, - GapNumber = - (int) - Math.Ceiling(AddressHelper.MapProtocolCoordinateToAbstractCoordinate( - continusAddress.Address, preCommunicationUnit.Address, - AddressTranslator.GetAreaByteLength(continusAddress.Area)) - - preCommunicationUnit.GetCount * - ValueHelper.ByteLength[ - preCommunicationUnit.DataType.FullName]) - }; - addressesGaps.Add(gap); - } - preCommunicationUnit = continusAddress; - } - //减去间隔 - var orderedGaps = addressesGaps.OrderBy(p => p.GapNumber); - var jumpNumberInner = JumpNumber; - foreach (var orderedGap in orderedGaps) - { - if (orderedGap.GapNumber <= 0) continue; - var nowAddress = orderedGap.EndUnit; - var index = continusAddresses.FindIndex(p => p.Area == nowAddress.Area && p.Address == nowAddress.Address && p.SubAddress == nowAddress.SubAddress); - nowAddress = continusAddresses[index]; - index--; - var preAddress = continusAddresses[index]; - if (nowAddress.GetCount * ValueHelper.ByteLength[nowAddress.DataType.FullName] + - preAddress.GetCount * ValueHelper.ByteLength[preAddress.DataType.FullName] + - orderedGap.GapNumber > MaxLength) continue; - jumpNumberInner -= orderedGap.GapNumber; - if (jumpNumberInner < 0) break; - continusAddresses.RemoveAt(index); - continusAddresses.RemoveAt(index); - //合并两个已有的地址段，变为一个新的地址段 - var newAddress = new CommunicationUnit - { - Area = nowAddress.Area, - Address = preAddress.Address, - GetCount = - (int) - (preAddress.GetCount * ValueHelper.ByteLength[preAddress.DataType.FullName]) + - orderedGap.GapNumber + - (int) - (nowAddress.GetCount * ValueHelper.ByteLength[nowAddress.DataType.FullName]), - GetOriginalCount = preAddress.GetOriginalCount + nowAddress.GetOriginalCount + orderedGap.GapNumber, - DataType = typeof(byte), - OriginalAddresses = preAddress.OriginalAddresses.ToList().Union(nowAddress.OriginalAddresses) - }; - continusAddresses.Insert(index, newAddress); - } - return continusAddresses; - } - } - - /// - /// 可以调过多少百分比的地址，把两个地址段变为一个 - /// - public class AddressCombinerPercentageJump : AddressCombinerContinus where TKey : IEquatable - { - /// - /// 构造函数 - /// - /// 允许跳过的字节数除以待组合的地址的字节数的百分比 - /// 单个协议允许的数据最大长度 - /// 地址转换器 - public AddressCombinerPercentageJump(double percentage, int maxLength, AddressTranslator addressTranslator) - : base(addressTranslator, maxLength) - { - if (percentage < 0) percentage = 0; - Percentage = percentage; - } - - /// - /// 跳过的百分比 - /// - private double Percentage { get; } - - /// - /// 组合地址 - /// - /// 需要组合的地址 - /// 组合后的地址 - public override IEnumerable> Combine(IEnumerable> addresses) - { - var addressUnits = addresses as IList> ?? addresses.ToList(); - var count = addressUnits.Sum(address => ValueHelper.ByteLength[address.DataType.FullName]); - return - new AddressCombinerNumericJump((int)(count * Percentage / 100.0), MaxLength, AddressTranslator) - .Combine( - addressUnits); - } - } - - public class ReadAddressesDesc - { - public string Area { get; set; } - - public int Address { get; set; } - - public int GetCount { get; set; } - } - - /// - /// 固定读取地址的范围，无视所有其它规则 - /// - public class AddressCombinerStatic : AddressCombiner where TKey : IEquatable - { - protected IEnumerable ReadAddresses { get; set; } - - protected AddressTranslator AddressTranslator { get; set; } - - public AddressCombinerStatic(IEnumerable readAddresses, AddressTranslator addressTranslator) - { - AddressTranslator = addressTranslator; - ReadAddresses = readAddresses; - } - - /// - /// 组合地址 - /// - /// 需要组合的地址 - /// 组合后的地址 - public override IEnumerable> Combine(IEnumerable> addresses) - { - List> communicationUnits = new List>(); - foreach (var readAddress in ReadAddresses) - { - var originalAddresses = new List>(); - foreach (var address in addresses) - { - if (address.Area == readAddress.Area && address.Address >= readAddress.Address && address.Address < readAddress.Address + readAddress.GetCount) - originalAddresses.Add(address); - } - communicationUnits.Add(new CommunicationUnit - { - Area = readAddress.Area, - Address = readAddress.Address, - GetCount = readAddress.GetCount * (int) - Math.Ceiling(AddressTranslator.GetAreaByteLength(readAddress.Area)), - DataType = typeof(byte), - GetOriginalCount = originalAddresses.Count, - OriginalAddresses = originalAddresses.ToList() - }); - } - return communicationUnits; - } - } -} \ No newline at end of file + // 如果当前地址的末尾被记录，表示地址被记录的地址域覆盖，这个地址没有记录的必要 + // If current address end is recorded, it means address is covered by recorded address range, no need to record this address diff --git a/Modbus.Net/Modbus.Net/Machine/AddressFormater.cs b/Modbus.Net/Modbus.Net/Machine/AddressFormater.cs index 44b85d3..be987ef 100644 --- a/Modbus.Net/Modbus.Net/Machine/AddressFormater.cs +++ b/Modbus.Net/Modbus.Net/Machine/AddressFormater.cs @@ -1,56 +1,133 @@ -using System; +using System; namespace Modbus.Net { /// - /// 地址编码器 + /// 地址格式化器基类 / Address Formater Base Class + /// + /// 将内部地址 (区域 + 地址 + 子地址) 格式化为字符串表示 + /// Formats internal addresses (area + address + sub-address) into string representation + /// + /// 主要用途 / Main Purpose: + /// + /// 将 AddressUnit 中的地址信息转换为可读字符串 / Convert AddressUnit address info to readable string + /// 用于日志记录、调试和配置显示 / Used for logging, debugging, and configuration display + /// 不同协议可以有不同的格式化规则 / Different protocols can have different formatting rules + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // Modbus 地址格式化 / Modbus address formatting + /// var formater = new AddressFormaterModbus(); + /// string addressStr = formater.FormatAddress("4X", 1, 0); // 输出："4X 1" + /// + /// // 西门子地址格式化 / Siemens address formatting + /// var siemensFormater = new AddressFormaterSiemens(); + /// string siemensAddr = siemensFormater.FormatAddress("DB", 10, 0); // 输出："DB10.0" + /// + /// + /// /// - public abstract class AddressFormater where TAddressKey : IEquatable where TSubAddressKey : IEquatable + /// 地址键类型 / Address key type + /// 子地址键类型 / Sub-address key type + public abstract class AddressFormater + where TAddressKey : IEquatable + where TSubAddressKey : IEquatable { /// - /// 编码地址 + /// 格式化地址 (无子地址) / Format Address (without sub-address) + /// + /// 将区域和地址转换为字符串 + /// Convert area and address to string + /// /// - /// 地址所在的数据区域 - /// 地址 - /// 编码后的地址 + /// + /// 地址所在的数据区域 / Data area where address is located + /// + /// Modbus 示例："4X" (保持寄存器), "0X" (线圈), "3X" (输入寄存器) + /// Modbus Examples: "4X" (Holding Register), "0X" (Coil), "3X" (Input Register) + /// 西门子示例："DB" (数据块), "I" (输入), "Q" (输出), "M" (位存储) + /// Siemens Examples: "DB" (Data Block), "I" (Input), "Q" (Output), "M" (Memory) + /// + /// + /// 地址 / Address + /// 格式化后的地址字符串 / Formatted address string public abstract string FormatAddress(string area, TAddressKey address); /// - /// 编码地址 + /// 格式化地址 (包含子地址) / Format Address (with sub-address) + /// + /// 将区域、地址和子地址转换为字符串 + /// Convert area, address, and sub-address to string + /// + /// 子地址用于位级操作，例如读取某个字节中的特定位 + /// Sub-address is used for bit-level operations, e.g., reading specific bits in a byte + /// + /// /// - /// 地址所在的数据区域 - /// 地址 - /// 子地址 - /// 编码后的地址 + /// + /// 地址所在的数据区域 / Data area where address is located + /// + /// 地址 / Address + /// + /// 子地址 (位偏移) / Sub-address (bit offset) + /// + /// 范围：0-7 (一个字节内的 8 个位) + /// Range: 0-7 (8 bits within one byte) + /// 例如：读取 400003 的第 5 位，Address=3, SubAddress=4 + /// Example: To read bit 5 of 400003, Address=3, SubAddress=4 + /// + /// + /// 格式化后的地址字符串 / Formatted address string public abstract string FormatAddress(string area, TAddressKey address, TSubAddressKey subAddress); } /// - /// 基本的地址编码器 + /// 基础地址格式化器 / Base Address Formater + /// + /// 使用冒号分隔的简单格式化方式 + /// Simple formatting using colon separator + /// + /// 格式化格式 / Format Pattern: + /// + /// 无子地址：area:address (例："4X:1") / Without sub-address: area:address (e.g., "4X:1") + /// 有子地址：area:address:subAddress (例："4X:1:0") / With sub-address: area:address:subAddress (e.g., "4X:1:0") + /// + /// + /// /// public class AddressFormaterBase : AddressFormater { /// - /// 编码地址 + /// 格式化地址 (无子地址) / Format Address (without sub-address) + /// + /// 格式：area:address + /// Format: area:address + /// /// - /// 地址所在的数据区域 - /// 地址 - /// 编码后的地址 + /// 地址所在的数据区域 / Data area where address is located + /// 地址 / Address + /// 格式化后的地址字符串 / Formatted address string public override string FormatAddress(string area, int address) { return area + ":" + address; } /// - /// 编码地址 + /// 格式化地址 (包含子地址) / Format Address (with sub-address) + /// + /// 格式：area:address:subAddress + /// Format: area:address:subAddress + /// /// - /// 地址所在的数据区域 - /// 地址 - /// 子地址 - /// 编码后的地址 + /// 地址所在的数据区域 / Data area where address is located + /// 地址 / Address + /// 子地址 (位偏移) / Sub-address (bit offset) + /// 格式化后的地址字符串 / Formatted address string public override string FormatAddress(string area, int address, int subAddress) { return area + ":" + address + ":" + subAddress; } } -} \ No newline at end of file +} diff --git a/Modbus.Net/Modbus.Net/Machine/AddressHelper.cs b/Modbus.Net/Modbus.Net/Machine/AddressHelper.cs index 40db6b1..1f978d8 100644 --- a/Modbus.Net/Modbus.Net/Machine/AddressHelper.cs +++ b/Modbus.Net/Modbus.Net/Machine/AddressHelper.cs @@ -1,19 +1,66 @@ -using System; +using System; namespace Modbus.Net { /// - /// 地址辅助类 + /// 地址辅助类 / Address Helper + /// + /// 提供协议坐标与字节坐标之间的转换功能 + /// Provides conversion functionality between protocol coordinate and abstract (byte) coordinate + /// + /// 核心概念 / Core Concepts: + /// + /// 协议坐标 (Protocol Coordinate) - Modbus 协议原生地址表示 (如 40001) / Modbus protocol native address representation + /// 字节坐标 (Abstract Coordinate) - 内部处理的字节偏移地址 / Byte offset address for internal processing + /// 子地址 (Sub-Address) - 位级偏移 (0-7)，用于访问单个位 / Bit-level offset (0-7) for accessing individual bits + /// + /// + /// + /// 使用场景 / Use Cases: + /// + /// 地址组合器优化地址打包 / Address combiner optimizes address packing + /// 计算连续地址的跨度 / Calculate span of continuous addresses + /// 处理位级数据访问 / Handle bit-level data access + /// + /// + /// /// public static class AddressHelper { /// - /// 将字节坐标变为协议坐标 + /// 将字节坐标转换为协议坐标 / Convert Abstract Coordinate to Protocol Coordinate + /// + /// 用于将内部字节偏移地址转换为 Modbus 协议地址 + /// Used to convert internal byte offset address to Modbus protocol address + /// + /// 转换公式 / Conversion Formula: + /// protocolAddress = abstractAddress / byteLength + startAddress + /// + /// + /// 示例 / Example: + /// + /// 字节坐标 0，起始地址 1，字节长度 2 → 协议坐标 1.0 + /// 字节坐标 2，起始地址 1，字节长度 2 → 协议坐标 2.0 + /// + /// + /// /// - /// 字节坐标地址 - /// 起始地址 - /// 协议坐标单个地址的字节长度 - /// + /// + /// 字节坐标地址 / Abstract coordinate address + /// 内部处理的字节偏移量 / Byte offset for internal processing + /// + /// + /// 起始地址 / Start address + /// 协议地址的起始值 (Modbus 通常为 1) / Starting value of protocol address (usually 1 for Modbus) + /// + /// + /// 协议坐标单个地址的字节长度 / Byte length per protocol coordinate address + /// + /// 线圈 (0X/1X): 0.125 字节 (1 位) / Coils: 0.125 bytes (1 bit) + /// 寄存器 (3X/4X): 2 字节 / Registers: 2 bytes + /// + /// + /// 协议坐标 / Protocol coordinate public static double MapAbstractCoordinateToProtocolCoordinate(double abstractAddress, int startAddress, double byteLength) { @@ -21,12 +68,36 @@ namespace Modbus.Net } /// - /// 将协议坐标变为字节坐标 + /// 将协议坐标转换为字节坐标 / Convert Protocol Coordinate to Abstract Coordinate + /// + /// 用于将 Modbus 协议地址转换为内部字节偏移地址 + /// Used to convert Modbus protocol address to internal byte offset address + /// + /// 转换公式 / Conversion Formula: + /// abstractAddress = (protocolAddress - startAddress) * byteLength + /// + /// + /// 示例 / Example: + /// + /// 协议坐标 1，起始地址 1，字节长度 2 → 字节坐标 0.0 + /// 协议坐标 2，起始地址 1，字节长度 2 → 字节坐标 2.0 + /// + /// + /// /// - /// 协议坐标地址 - /// 起始地址 - /// 协议坐标单个地址的字节长度 - /// + /// + /// 协议坐标地址 / Protocol coordinate address + /// Modbus 协议地址 (如 40001) / Modbus protocol address (e.g., 40001) + /// + /// + /// 起始地址 / Start address + /// 协议地址的起始值 / Starting value of protocol address + /// + /// + /// 协议坐标单个地址的字节长度 / Byte length per protocol coordinate address + /// 线圈：0.125，寄存器：2 / Coils: 0.125, Registers: 2 + /// + /// 字节坐标 / Abstract coordinate public static double MapProtocolCoordinateToAbstractCoordinate(double protocolAddress, int startAddress, double byteLength) { @@ -34,12 +105,29 @@ namespace Modbus.Net } /// - /// 将协议获取数变为字节获取数 + /// 将协议获取数转换为字节获取数 / Convert Protocol Get Count to Abstract Byte Count + /// + /// 计算需要读取的总字节数 + /// Calculate total byte count to read + /// + /// 转换公式 / Conversion Formula: + /// byteCount = protocolGetCount * areaLength + byteLength + /// + /// /// - /// 协议坐标获取个数 - /// 协议坐标区域与字节之间的防缩倍数 - /// 协议坐标单个地址的字节长度 - /// + /// + /// 协议坐标获取个数 / Protocol coordinate get count + /// 需要读取的寄存器/线圈数量 / Number of registers/coils to read + /// + /// + /// 协议坐标区域与字节之间的缩放倍数 / Scale factor between protocol coordinate area and bytes + /// 通常为 1 / Usually 1 + /// + /// + /// 协议坐标单个地址的字节长度 / Byte length per protocol coordinate address + /// 线圈：0.125，寄存器：2 / Coils: 0.125, Registers: 2 + /// + /// 字节获取数 / Abstract byte count public static double MapProtocolGetCountToAbstractByteCount(double protocolGetCount, double areaLength, double byteLength) { @@ -47,35 +135,105 @@ namespace Modbus.Net } /// - /// 获取协议坐标 + /// 获取协议坐标 / Get Protocol Coordinate + /// + /// 根据主地址和子地址计算协议坐标 + /// Calculate protocol coordinate from main address and sub-address + /// + /// 计算公式 / Calculation Formula: + /// protocolCoordinate = address + subAddress * (0.125 / byteLength) + /// + /// + /// 示例 / Example: + /// + /// address=1, subAddress=0, byteLength=2 → 1.0 (寄存器 40001) + /// address=1, subAddress=4, byteLength=2 → 1.25 (寄存器 40001 的第 4 位) + /// + /// + /// /// - /// 主地址 - /// 子地址 - /// 协议坐标单个地址的字节长度 - /// + /// + /// 主地址 / Main address + /// 寄存器/线圈地址 / Register/Coil address + /// + /// + /// 子地址 (位偏移) / Sub-address (bit offset) + /// 范围：0-7 / Range: 0-7 + /// + /// + /// 协议坐标单个地址的字节长度 / Byte length per protocol coordinate address + /// 线圈：0.125，寄存器：2 / Coils: 0.125, Registers: 2 + /// + /// 协议坐标 / Protocol coordinate public static double GetProtocolCoordinate(int address, int subAddress, double byteLength) { return address + subAddress * (0.125 / byteLength); } /// - /// 获取字节坐标 + /// 获取字节坐标 / Get Abstract Coordinate + /// + /// 根据主地址和子地址计算字节坐标 + /// Calculate abstract coordinate from main address and sub-address + /// + /// 计算公式 / Calculation Formula: + /// abstractCoordinate = address + subAddress * 0.125 + /// + /// + /// 示例 / Example: + /// + /// address=0, subAddress=0 → 0.0 (第 1 个字节) + /// address=0, subAddress=4 → 0.5 (第 1 个字节的第 4 位) + /// address=1, subAddress=0 → 1.0 (第 2 个字节) + /// + /// + /// /// - /// 主地址 - /// 子地址 - /// + /// + /// 主地址 / Main address + /// 字节地址 / Byte address + /// + /// + /// 子地址 (位偏移) / Sub-address (bit offset) + /// 范围：0-7 / Range: 0-7 + /// + /// 字节坐标 / Abstract coordinate public static double GetAbstractCoordinate(int address, int subAddress) { return address + subAddress * 0.125; } /// - /// 获取协议坐标下一个数据的位置 + /// 获取协议坐标下一个数据的位置 / Get Next Position for Protocol Coordinate + /// + /// 计算当前地址之后下一个数据类型的协议坐标位置 + /// Calculate protocol coordinate position of next data type after current address + /// + /// 计算公式 / Calculation Formula: + /// nextPosition = protocolAddress + (dataTypeByteLength / byteLength) + /// + /// + /// 示例 / Example: + /// + /// 当前地址 1.0，读取 ushort(2 字节)，byteLength=2 → 下一个位置 2.0 + /// 当前地址 1.0，读取 bool(0.125 字节)，byteLength=2 → 下一个位置 1.0625 + /// + /// + /// /// - /// 协议坐标地址 - /// 间隔的数据类型 - /// 协议坐标单个地址的字节长度 - /// + /// + /// 协议坐标地址 / Protocol coordinate address + /// 当前协议地址 / Current protocol address + /// + /// + /// 间隔的数据类型 / Data type between positions + /// 用于计算跨度的数据类型 / Data type used to calculate span + /// + /// + /// 协议坐标单个地址的字节长度 / Byte length per protocol coordinate address + /// 线圈：0.125，寄存器：2 / Coils: 0.125, Registers: 2 + /// + /// 下一个数据的位置 / Next data position public static double GetProtocolCoordinateNextPosition(double protocolAddress, Type nextPositionBetweenType, double byteLength) { @@ -84,15 +242,37 @@ namespace Modbus.Net } /// - /// 获取字节坐标下一个数据的位置 + /// 获取字节坐标下一个数据的位置 / Get Next Position for Abstract Coordinate + /// + /// 计算当前字节地址之后下一个数据类型的字节坐标位置 + /// Calculate abstract coordinate position of next data type after current byte address + /// + /// 计算公式 / Calculation Formula: + /// nextPosition = abstractAddress + dataTypeByteLength + /// + /// + /// 示例 / Example: + /// + /// 当前地址 0.0，读取 ushort(2 字节) → 下一个位置 2.0 + /// 当前地址 0.0，读取 int(4 字节) → 下一个位置 4.0 + /// 当前地址 0.0，读取 bool(0.125 字节) → 下一个位置 0.125 + /// + /// + /// /// - /// 字节坐标地址 - /// 间隔的数据类型 - /// + /// + /// 字节坐标地址 / Abstract coordinate address + /// 当前字节地址 / Current byte address + /// + /// + /// 间隔的数据类型 / Data type between positions + /// 用于计算跨度的数据类型 / Data type used to calculate span + /// + /// 下一个数据的位置 / Next data position public static double GetAbstractCoordinateNextPosition(double abstractAddress, Type nextPositionBetweenType) { return abstractAddress + ValueHelper.ByteLength[nextPositionBetweenType.FullName]; } } -} \ No newline at end of file +} diff --git a/Modbus.Net/Modbus.Net/Machine/BaseMachine.cs b/Modbus.Net/Modbus.Net/Machine/BaseMachine.cs index ae1df2c..ae52ee0 100644 --- a/Modbus.Net/Modbus.Net/Machine/BaseMachine.cs +++ b/Modbus.Net/Modbus.Net/Machine/BaseMachine.cs @@ -1,4 +1,4 @@ -using Microsoft.Extensions.Logging; +using Microsoft.Extensions.Logging; using System; using System.Collections.Generic; using System.Linq; @@ -7,10 +7,14 @@ using System.Threading.Tasks; namespace Modbus.Net { /// - /// 设备 + /// 设备基类 (简化版本) / Base Machine Class (Simplified Version) + /// + /// 这是 BaseMachine 的简化版本，使用 int 作为地址和子地址类型 + /// This is a simplified version of BaseMachine, using int for address and sub-address types + /// /// - /// 设备的Id类型 - /// 设备中使用的AddressUnit的Id类型 + /// 设备的 Id 类型 / Device ID type + /// 设备中使用的 AddressUnit 的 Id 类型 / AddressUnit ID type used in device public abstract class BaseMachine : BaseMachine where TKey : IEquatable where TUnitKey : IEquatable @@ -18,13 +22,18 @@ namespace Modbus.Net private static readonly ILogger> logger = LogProvider.CreateLogger>(); /// - /// 构造器 + /// 构造函数 / Constructor + /// + /// 初始化设备实例，设置设备 ID、地址、连接参数等 + /// Initializes device instance, setting device ID, addresses, connection parameters, etc. + /// /// - /// 设备的ID号 - /// 需要与设备通讯的地址 - /// 是否保持连接 - /// 从站地址 - /// 主站地址 + /// 设备的 ID 号 / Device ID number + /// 设备别名 / Device alias + /// 需要与设备通讯的地址 / Addresses to communicate with device + /// 是否保持连接 / Whether to keep connection + /// 从站地址 / Slave address + /// 主站地址 / Master address protected BaseMachine(TKey id, string alias, IEnumerable> getAddresses, bool keepConnect, byte slaveAddress, byte masterAddress) : base(id, alias, getAddresses, keepConnect) { @@ -32,50 +41,79 @@ namespace Modbus.Net MasterAddress = masterAddress; } - private readonly int _maxErrorCount = 3; - private int ErrorCount { get; set; } /// - /// 从站号 + /// 从站地址 / Slave Address + /// + /// Modbus 协议中从站设备的地址，范围 1-247 + /// Slave device address in Modbus protocol, range 1-247 + /// /// public byte SlaveAddress { get; set; } = 2; /// - /// 主站号 + /// 主站地址 / Master Address + /// + /// Modbus 协议中主站的地址，通常为 0 或 1 + /// Master station address in Modbus protocol, usually 0 or 1 + /// /// public byte MasterAddress { get; set; } /// - /// 与设备实际通讯的连续地址 + /// 与设备实际通讯的连续地址 / Continuous Addresses for Actual Device Communication + /// + /// 通过地址组合器优化后的地址列表，减少通信次数 + /// Optimized address list through address combiner to reduce communication times + /// /// protected IEnumerable> CommunicateAddresses => GetAddresses != null ? AddressCombiner.Combine(GetAddresses) : null; /// - /// 获取地址组合器 + /// 读取地址组合器 / Read Address Combiner + /// + /// 用于优化读取操作的地址组合 + /// Address combination for optimizing read operations + /// /// public AddressCombiner AddressCombiner { get; set; } /// - /// 写入地址组合器 + /// 写入地址组合器 / Write Address Combiner + /// + /// 用于优化写入操作的地址组合 + /// Address combination for optimizing write operations + /// /// public AddressCombiner AddressCombinerSet { get; set; } /// - /// 读取数据 + /// 异步读取数据 / Asynchronously Read Data + /// + /// 从设备读取数据，支持多种数据类型 + /// Read data from device, supporting multiple data types + /// /// - /// 从设备读取的数据 + /// + /// 获取数据类型 / Get Data Type + /// + /// 指定返回数据的键类型 (Address/CommunicationTag/Id/Name) + /// Specifies the key type of returned data (Address/CommunicationTag/Id/Name) + /// + /// + /// 从设备读取的数据 / Data read from device public async override Task>>> GetDatasAsync(MachineDataType getDataType) { try { var ans = new Dictionary>(); - //检测并连接设备 + // 检测并连接设备 / Check and connect to device if (!BaseUtility.IsConnected) await BaseUtility.ConnectAsync(); - //如果无法连接，终止 + // 如果无法连接，终止 / If connection fails, terminate if (!BaseUtility.IsConnected) return new ReturnStruct>>() { @@ -84,10 +122,11 @@ namespace Modbus.Net ErrorCode = -1, ErrorMsg = "Connection Error" }; - //遍历每一个实际向设备获取数据的连续地址 + // 遍历每一个实际向设备获取数据的连续地址 + // Iterate through each continuous address for actual data acquisition from device foreach (var communicateAddress in CommunicateAddresses) { - //获取数据 + // 获取数据 / Get data var datas = await BaseUtility.GetUtilityMethods().GetDatasAsync( @@ -98,1052 +137,3 @@ namespace Modbus.Net ValueHelper.ByteLength[ communicateAddress.DataType.FullName]), communicateAddress.GetOriginalCount); - - //如果已知没有返回，终止 - if (datas.IsSuccess == null) - { - return new ReturnStruct>>() - { - Datas = null, - IsSuccess = null, - ErrorCode = datas.ErrorCode, - ErrorMsg = datas.ErrorMsg - }; - } - //如果没有数据，终止 - else if (datas.IsSuccess == false || datas.Datas == null) - { - return new ReturnStruct>>() - { - Datas = null, - IsSuccess = false, - ErrorCode = datas.ErrorCode, - ErrorMsg = datas.ErrorMsg - }; - } - else if (datas.Datas.Length != 0 && datas.Datas.Length < - (int) - Math.Ceiling(communicateAddress.GetCount * - ValueHelper.ByteLength[ - communicateAddress.DataType.FullName])) - { - return new ReturnStruct>>() - { - Datas = null, - IsSuccess = false, - ErrorCode = -2, - ErrorMsg = "Data length mismatch" - }; - } - - - - foreach (var address in communicateAddress.OriginalAddresses) - { - //字节坐标的位置 - var localPos = AddressHelper.MapProtocolCoordinateToAbstractCoordinate(address.Address, - communicateAddress.Address, - AddressTranslator.GetAreaByteLength(communicateAddress.Area)) + - address.SubAddress * 0.125; - //字节坐标的主地址位置 - var localMainPos = (int)localPos; - //字节坐标的子地址位置 - var localSubPos = (int)((localPos - localMainPos) * 8); - if (ValueHelper.GetInstance(BaseUtility.Endian).LittleEndianBit == true && AddressTranslator.GetAreaByteLength(communicateAddress.Area) > 1 && ValueHelper.ByteLength[address.DataType.FullName] < AddressTranslator.GetAreaByteLength(communicateAddress.Area)) - { - localMainPos =(int)(2 * ((int)(localMainPos / AddressTranslator.GetAreaByteLength(communicateAddress.Area)) * AddressTranslator.GetAreaByteLength(communicateAddress.Area)) + (AddressTranslator.GetAreaByteLength(communicateAddress.Area) - 1) - localMainPos); - } - - //根据类型选择返回结果的键是通讯标识还是地址 - string key; - switch (getDataType) - { - case MachineDataType.CommunicationTag: - { - key = address.CommunicationTag; - break; - } - case MachineDataType.Address: - { - key = AddressFormater.FormatAddress(address.Area, address.Address, address.SubAddress); - break; - } - case MachineDataType.Name: - { - key = address.Name; - break; - } - case MachineDataType.Id: - { - key = address.Id.ToString(); - break; - } - default: - { - key = address.CommunicationTag; - break; - } - } - - try - { - //如果没有数据返回空 - if (datas.Datas.Length == 0) - ans.Add(key, new ReturnUnit - { - DeviceValue = null, - AddressUnit = address.MapAddressUnitTUnitKeyToAddressUnit(), - }); - else - ans.Add(key, - new ReturnUnit - { - DeviceValue = - Math.Round(Convert.ToDouble( - ValueHelper.GetInstance(BaseUtility.Endian) - .GetValue(datas.Datas, ref localMainPos, ref localSubPos, - address.DataType)) * address.Zoom, address.DecimalPos), - AddressUnit = address.MapAddressUnitTUnitKeyToAddressUnit(), - }); - } - catch (Exception e) - { - ErrorCount++; - logger.LogError(e, $"BaseMachine -> GetDatas, Id:{Id} Connection:{ConnectionToken} key {key} existing. ErrorCount {ErrorCount}."); - - if (ErrorCount >= _maxErrorCount) - Disconnect(); - return new ReturnStruct>>() - { - Datas = null, - IsSuccess = false, - ErrorCode = -3, - ErrorMsg = "Data translation mismatch" - }; - } - } - } - //如果不保持连接，断开连接 - if (!KeepConnect) - BaseUtility.Disconnect(); - //返回数据 - if (ans.All(p => p.Value.DeviceValue == null)) ans = null; - ErrorCount = 0; - return new ReturnStruct>> - { - Datas = ans, - IsSuccess = true, - ErrorCode = 0, - ErrorMsg = "" - }; - } - catch (Exception e) - { - ErrorCount++; - logger.LogError(e, $"BaseMachine -> GetDatas, Id:{Id} Connection:{ConnectionToken} error. ErrorCount {ErrorCount}."); - - if (ErrorCount >= _maxErrorCount) - Disconnect(); - return new ReturnStruct>>() - { - Datas = null, - IsSuccess = false, - ErrorCode = -100, - ErrorMsg = "Unknown Exception" - }; - } - } - - /// - /// 写入数据 - /// - /// 写入类型 - /// 需要写入的数据字典，当写入类型为Address时，键为需要写入的地址，当写入类型为CommunicationTag时，键为需要写入的单元的描述 - /// 是否写入成功 - public async override Task> SetDatasAsync(MachineDataType setDataType, Dictionary values) - { - try - { - //检测并连接设备 - if (!BaseUtility.IsConnected) - await BaseUtility.ConnectAsync(); - //如果设备无法连接，终止 - if (!BaseUtility.IsConnected) return new ReturnStruct() - { - Datas = false, - IsSuccess = false, - ErrorCode = -1, - ErrorMsg = "Connection Error" - }; - var addresses = new List>(); - //遍历每个要设置的值 - foreach (var value in values) - { - //根据设置类型找到对应的地址描述 - AddressUnit address = null; - switch (setDataType) - { - case MachineDataType.Address: - { - address = - GetAddresses.SingleOrDefault( - p => - AddressFormater.FormatAddress(p.Area, p.Address, p.SubAddress) == value.Key || - p.DataType != typeof(bool) && - AddressFormater.FormatAddress(p.Area, p.Address) == value.Key); - break; - } - case MachineDataType.CommunicationTag: - { - address = - GetAddresses.SingleOrDefault(p => p.CommunicationTag == value.Key); - break; - } - case MachineDataType.Name: - { - address = GetAddresses.SingleOrDefault(p => p.Name == value.Key); - break; - } - case MachineDataType.Id: - { - address = GetAddresses.SingleOrDefault(p => p.Id.ToString() == value.Key); - break; - } - default: - { - address = - GetAddresses.SingleOrDefault(p => p.CommunicationTag == value.Key); - break; - } - } - //地址为空报错 - if (address == null) - { - logger.LogError($"Machine {ConnectionToken} Address {value.Key} doesn't exist."); - continue; - } - //不能写报错 - if (!address.CanWrite) - { - logger.LogError($"Machine {ConnectionToken} Address {value.Key} cannot write."); - continue; - } - addresses.Add(address); - } - //将地址编码成与实际设备通讯的地址 - var communcationUnits = AddressCombinerSet.Combine(addresses); - //遍历每条通讯的连续地址 - foreach (var communicateAddress in communcationUnits) - { - //编码开始地址 - var addressStart = AddressFormater.FormatAddress(communicateAddress.Area, - communicateAddress.Address); - - var datasReturn = - await BaseUtility.GetUtilityMethods().GetDatasAsync( - AddressFormater.FormatAddress(communicateAddress.Area, communicateAddress.Address, 0), - (int) - Math.Ceiling(communicateAddress.GetCount * - ValueHelper.ByteLength[ - communicateAddress.DataType.FullName]), - communicateAddress.GetOriginalCount); - - var valueHelper = ValueHelper.GetInstance(BaseUtility.Endian); - //如果设备本身能获取到数据但是没有数据 - var datas = datasReturn; - - //没有返回，直接设0 - if (datas.IsSuccess == null) - { - datas.Datas = new byte[(int) - Math.Ceiling(communicateAddress.GetCount * - ValueHelper.ByteLength[ - communicateAddress.DataType.FullName])]; - } - //如果没有数据，终止 - if (datas.IsSuccess == false || datas.Datas == null) - { - return new ReturnStruct() - { - Datas = false, - IsSuccess = false, - ErrorCode = datas.ErrorCode, - ErrorMsg = datas.ErrorMsg - }; - } - else if (datas.Datas.Length < - (int) - Math.Ceiling(communicateAddress.GetCount * - ValueHelper.ByteLength[ - communicateAddress.DataType.FullName])) - return new ReturnStruct() - { - Datas = false, - IsSuccess = false, - ErrorCode = -2, - ErrorMsg = "Data length not match" - }; - - foreach (var addressUnit in communicateAddress.OriginalAddresses) - { - //字节坐标地址 - var byteCount = - AddressHelper.MapProtocolGetCountToAbstractByteCount( - addressUnit.Address - communicateAddress.Address + - addressUnit.SubAddress * 0.125 / - AddressTranslator.GetAreaByteLength(communicateAddress.Area), - AddressTranslator.GetAreaByteLength(communicateAddress.Area), 0); - //字节坐标主地址 - var mainByteCount = (int)byteCount; - //字节坐标自地址 - var localByteCount = (int)((byteCount - (int)byteCount) * 8); - - //协议坐标地址 - var localPos = byteCount / AddressTranslator.GetAreaByteLength(communicateAddress.Area); - //协议坐标子地址 - var subPos = - (int) - ((localPos - (int)localPos) / - (0.125 / AddressTranslator.GetAreaByteLength(communicateAddress.Area))); - //协议主地址字符串 - var address = AddressFormater.FormatAddress(communicateAddress.Area, - communicateAddress.Address + (int)localPos, subPos); - //协议完整地址字符串 - var address2 = subPos != 0 - ? null - : AddressFormater.FormatAddress(communicateAddress.Area, - communicateAddress.Address + (int)localPos); - //获取写入类型 - var dataType = addressUnit.DataType; - KeyValuePair value; - switch (setDataType) - { - case MachineDataType.Address: - { - //获取要写入的值 - value = - values.SingleOrDefault( - p => p.Key == address || address2 != null && p.Key == address2); - break; - } - case MachineDataType.CommunicationTag: - { - value = values.SingleOrDefault(p => p.Key == addressUnit.CommunicationTag); - break; - } - case MachineDataType.Name: - { - value = values.SingleOrDefault(p => p.Key == addressUnit.Name); - break; - } - case MachineDataType.Id: - { - value = values.SingleOrDefault(p => p.Key == addressUnit.Id.ToString()); - break; - } - default: - { - value = values.SingleOrDefault(p => p.Key == addressUnit.CommunicationTag); - break; - } - } - //将要写入的值加入队列 - var data = Convert.ChangeType(value.Value / addressUnit.Zoom, dataType); - - if (!valueHelper.SetValue(datas.Datas, mainByteCount, localByteCount, data)) - return new ReturnStruct() - { - Datas = false, - IsSuccess = false, - ErrorCode = -3, - ErrorMsg = "Data translation mismatch" - }; ; - } - //写入数据 - await - BaseUtility.GetUtilityMethods().SetDatasAsync(addressStart, - valueHelper.ByteArrayToObjectArray(datas.Datas, - new KeyValuePair(communicateAddress.DataType, communicateAddress.GetCount)), communicateAddress.GetOriginalCount); - } - //如果不保持连接，断开连接 - if (!KeepConnect) - BaseUtility.Disconnect(); - } - catch (Exception e) - { - ErrorCount++; - logger.LogError(e, $"BaseMachine -> SetDatas, Id:{Id} Connection:{ConnectionToken} error. ErrorCount {ErrorCount}."); - - if (ErrorCount >= _maxErrorCount) - Disconnect(); - return new ReturnStruct() - { - Datas = false, - IsSuccess = false, - ErrorCode = -100, - ErrorMsg = "Unknown Exception" - }; - } - return new ReturnStruct() - { - Datas = true, - IsSuccess = true, - ErrorCode = 0, - ErrorMsg = "" - }; - } - } - - /// - /// 设备 - /// - /// 设备的Id类型 - /// 设备中使用的AddressUnit的Id类型 - /// 设备中使用的AddressUnit的Address类型 - /// 设备中使用的AddressUnit的SubAddress类型 - public abstract class BaseMachine : IMachine - where TKey : IEquatable - where TUnitKey : IEquatable - where TAddressKey : IEquatable - where TSubAddressKey : IEquatable - { - private static readonly ILogger> logger = LogProvider.CreateLogger>(); - - /// - /// 构造器 - /// - /// 设备的ID号 - /// 需要与设备通讯的地址 - protected BaseMachine(TKey id, string alias, IEnumerable> getAddresses) - : this(id, alias, getAddresses, false) - { - } - - /// - /// 构造器 - /// - /// 设备的ID号 - /// 需要与设备通讯的地址 - /// 是否保持连接 - protected BaseMachine(TKey id, string alias, IEnumerable> getAddresses, bool keepConnect) - { - Id = id; - GetAddresses = getAddresses; - KeepConnect = keepConnect; - if (alias.Contains(':')) - { - var aliasArray = alias.Split(':'); - ProjectName = aliasArray[0]; - MachineName = aliasArray[1]; - } - else - { - ProjectName = ""; - MachineName = alias; - } - } - - private readonly int _maxErrorCount = 3; - - private int ErrorCount { get; set; } - - /// - /// 是否处于连接状态 - /// - public bool IsConnected => BaseUtility.IsConnected; - - /// - /// 是否保持连接 - /// - public bool KeepConnect { get; set; } - - /// - /// 设备的连接器 - /// - public IUtilityProperty BaseUtility { get; protected set; } - - /// - /// 设备的Id - /// - public TKey Id { get; set; } - - /// - /// 设备所在工程的名称 - /// - public string ProjectName { get; set; } - - /// - /// 设备的名称 - /// - public string MachineName { get; set; } - - /// - /// 标识设备的连接关键字 - /// - public string ConnectionToken => BaseUtility.ConnectionToken; - - /// - /// 描述需要与设备通讯的地址 - /// - private IEnumerable> getAddresses; - - private object getAddressesLock = new object(); - - /// - /// 描述需要与设备通讯的地址 - /// - public IEnumerable> GetAddresses - { - get - { - return getAddresses; - } - set - { - lock (getAddressesLock) - { - getAddresses = value; - } - } - } - - /// - /// 地址编码器 - /// - public AddressFormater AddressFormater { get; set; } - - /// - /// 地址转换器 - /// - public AddressTranslator AddressTranslator - { - get => BaseUtility.AddressTranslator; - set => BaseUtility.AddressTranslator = value; - } - - /// - /// 读取数据 - /// - /// 从设备读取的数据 - public async virtual Task>>> GetDatasAsync(MachineDataType getDataType) - { - try - { - var ans = new Dictionary>(); - //检测并连接设备 - if (!BaseUtility.IsConnected) - await BaseUtility.ConnectAsync(); - //如果无法连接，终止 - if (!BaseUtility.IsConnected) return - new ReturnStruct>>() - { - Datas = null, - IsSuccess = false, - ErrorCode = -1, - ErrorMsg = "Connection Error" - }; - //遍历每一个实际向设备获取数据的连续地址 - foreach (var address in GetAddresses) - { - //获取数据 - var datas = - await - BaseUtility.GetUtilityMethods().GetDatasAsync( - AddressFormater.FormatAddress(address.Area, address.Address, - address.SubAddress), - (int) - Math.Ceiling(ValueHelper.ByteLength[ - address.DataType.FullName]), - (int) - Math.Ceiling(ValueHelper.ByteLength[ - address.DataType.FullName])); - - - //如果没有数据，终止 - if (datas.IsSuccess == false || datas.Datas == null) - { - return new ReturnStruct>>() - { - Datas = null, - IsSuccess = false, - ErrorCode = datas.ErrorCode, - ErrorMsg = datas.ErrorMsg - }; - } - else if (datas.Datas.Length != 0 && datas.Datas.Length < - (int) - Math.Ceiling(ValueHelper.ByteLength[ - address.DataType.FullName])) - { - return new ReturnStruct>>() - { - Datas = null, - IsSuccess = false, - ErrorCode = -2, - ErrorMsg = "Data length mismatch" - }; - } - - //字节坐标的主地址位置 - var localMainPos = 0; - //字节坐标的子地址位置 - var localSubPos = 0; - - //根据类型选择返回结果的键是通讯标识还是地址 - string key; - switch (getDataType) - { - case MachineDataType.CommunicationTag: - { - key = address.CommunicationTag; - break; - } - case MachineDataType.Address: - { - key = AddressFormater.FormatAddress(address.Area, address.Address, address.SubAddress); - break; - } - case MachineDataType.Name: - { - key = address.Name; - break; - } - case MachineDataType.Id: - { - key = address.Id.ToString(); - break; - } - default: - { - key = address.CommunicationTag; - break; - } - } - - try - { - //如果没有数据返回空 - if (datas.Datas.Length == 0) - ans.Add(key, new ReturnUnit - { - DeviceValue = null, - AddressUnit = address.MapAddressUnitTUnitKeyToAddressUnit(), - }); - else - ans.Add(key, - new ReturnUnit - { - DeviceValue = - Math.Round(Convert.ToDouble( - ValueHelper.GetInstance(BaseUtility.Endian) - .GetValue(datas.Datas, ref localMainPos, ref localSubPos, - address.DataType)) * address.Zoom, address.DecimalPos), - AddressUnit = address.MapAddressUnitTUnitKeyToAddressUnit(), - }); - } - catch (Exception e) - { - ErrorCount++; - logger.LogError(e, $"BaseMachine -> GetDatas, Id:{Id} Connection:{ConnectionToken} key {key} existing. ErrorCount {ErrorCount}."); - - if (ErrorCount >= _maxErrorCount) - Disconnect(); - return new ReturnStruct>>() - { - Datas = null, - IsSuccess = false, - ErrorCode = -3, - ErrorMsg = "Data translation mismatch" - }; - } - } - - //如果不保持连接，断开连接 - if (!KeepConnect) - BaseUtility.Disconnect(); - //返回数据 - if (ans.All(p => p.Value.DeviceValue == null)) ans = null; - ErrorCount = 0; - return new ReturnStruct>> - { - Datas = ans, - IsSuccess = true, - ErrorCode = 0, - ErrorMsg = "" - }; - } - catch (Exception e) - { - ErrorCount++; - logger.LogError(e, $"BaseMachine -> GetDatas, Id:{Id} Connection:{ConnectionToken} error. ErrorCount {ErrorCount}."); - - if (ErrorCount >= _maxErrorCount) - Disconnect(); - return new ReturnStruct>>() - { - Datas = null, - IsSuccess = false, - ErrorCode = -100, - ErrorMsg = "Unknown Exception" - }; - } - } - - /// - /// 写入数据 - /// - /// 写入类型 - /// 需要写入的数据字典，当写入类型为Address时，键为需要写入的地址，当写入类型为CommunicationTag时，键为需要写入的单元的描述 - /// 是否写入成功 - public async virtual Task> SetDatasAsync(MachineDataType setDataType, Dictionary values) - { - try - { - //检测并连接设备 - if (!BaseUtility.IsConnected) - await BaseUtility.ConnectAsync(); - //如果设备无法连接，终止 - if (!BaseUtility.IsConnected) return new ReturnStruct() - { - Datas = false, - IsSuccess = false, - ErrorCode = -1, - ErrorMsg = "Connection Error" - }; - var addresses = new List>(); - //遍历每个要设置的值 - foreach (var value in values) - { - //根据设置类型找到对应的地址描述 - AddressUnit address = null; - switch (setDataType) - { - case MachineDataType.Address: - { - address = - GetAddresses.SingleOrDefault( - p => - AddressFormater.FormatAddress(p.Area, p.Address, p.SubAddress) == value.Key || - p.DataType != typeof(bool) && - AddressFormater.FormatAddress(p.Area, p.Address) == value.Key); - break; - } - case MachineDataType.CommunicationTag: - { - address = - GetAddresses.SingleOrDefault(p => p.CommunicationTag == value.Key); - break; - } - case MachineDataType.Name: - { - address = GetAddresses.SingleOrDefault(p => p.Name == value.Key); - break; - } - case MachineDataType.Id: - { - address = GetAddresses.SingleOrDefault(p => p.Id.ToString() == value.Key); - break; - } - default: - { - address = - GetAddresses.SingleOrDefault(p => p.CommunicationTag == value.Key); - break; - } - } - //地址为空报错 - if (address == null) - { - logger.LogError($"Machine {ConnectionToken} Address {value.Key} doesn't exist."); - continue; - } - //不能写报错 - if (!address.CanWrite) - { - logger.LogError($"Machine {ConnectionToken} Address {value.Key} cannot write."); - continue; - } - addresses.Add(address); - } - - //遍历每条通讯的地址 - - - var valueHelper = ValueHelper.GetInstance(BaseUtility.Endian); - - foreach (var addressUnit in addresses) - { - //协议主地址字符串 - var address = AddressFormater.FormatAddress(addressUnit.Area, - addressUnit.Address, addressUnit.SubAddress); - //获取写入类型 - var dataType = addressUnit.DataType; - KeyValuePair value; - switch (setDataType) - { - case MachineDataType.Address: - { - //获取要写入的值 - value = values.SingleOrDefault(p => p.Key == address); - break; - } - case MachineDataType.CommunicationTag: - { - value = values.SingleOrDefault(p => p.Key == addressUnit.CommunicationTag); - break; - } - case MachineDataType.Name: - { - value = values.SingleOrDefault(p => p.Key == addressUnit.Name); - break; - } - case MachineDataType.Id: - { - value = values.SingleOrDefault(p => p.Key == addressUnit.Id.ToString()); - break; - } - default: - { - value = values.SingleOrDefault(p => p.Key == addressUnit.CommunicationTag); - break; - } - } - //将要写入的值加入队列 - var data = Convert.ChangeType(value.Value / addressUnit.Zoom, dataType); - - //写入数据 - await - BaseUtility.GetUtilityMethods().SetDatasAsync(address, - new object[] { data } , 1); - } - //如果不保持连接，断开连接 - if (!KeepConnect) - BaseUtility.Disconnect(); - } - catch (Exception e) - { - ErrorCount++; - logger.LogError(e, $"BaseMachine -> SetDatas, Id:{Id} Connection:{ConnectionToken} error. ErrorCount {ErrorCount}."); - - if (ErrorCount >= _maxErrorCount) - Disconnect(); - return new ReturnStruct() - { - Datas = false, - IsSuccess = false, - ErrorCode = -100, - ErrorMsg = "Unknown Exception" - }; - } - return new ReturnStruct() - { - Datas = true, - IsSuccess = true, - ErrorCode = 0, - ErrorMsg = "" - }; - } - - /// - /// 通过Id获取数据字段定义 - /// - /// 数据字段Id - /// 数据字段 - public AddressUnit GetAddressUnitById(TUnitKey addressUnitId) - { - try - { - return GetAddresses.SingleOrDefault(p => p.Id.Equals(addressUnitId)); - } - catch (Exception e) - { - logger.LogError(e, $"BaseMachine -> GetAddressUnitById Id:{Id} ConnectionToken:{ConnectionToken} addressUnitId:{addressUnitId} Repeated"); - return null; - } - } - - /// - /// 获取设备的方法集合 - /// - /// 方法集合的类型 - /// 设备的方法集合 - public TMachineMethod GetMachineMethods() where TMachineMethod : class, IMachineMethod - { - if (this is TMachineMethod) - { - return this as TMachineMethod; - } - return null; - } - - /// - /// 获取Utility的执行方法 - /// - /// Utility实现的接口名称 - /// - public TUtilityMethod GetUtilityMethods() where TUtilityMethod : class, IUtilityMethod - { - return BaseUtility as TUtilityMethod; - } - - /// - /// 连接设备 - /// - /// 是否连接成功 - public async Task ConnectAsync() - { - return await BaseUtility.ConnectAsync(); - } - - /// - /// 断开设备 - /// - /// 是否断开成功 - public bool Disconnect() - { - return BaseUtility.Disconnect(); - } - } - - internal class BaseMachineEqualityComparer : IEqualityComparer> - where TKey : IEquatable - { - public bool Equals(IMachineProperty x, IMachineProperty y) - { - return x.Id.Equals(y.Id); - } - - public int GetHashCode(IMachineProperty obj) - { - return obj.GetHashCode(); - } - } - - /// - /// 通讯单元 - /// - public class CommunicationUnit where TKey : IEquatable where TAddressKey : IEquatable where TSubAddressKey : IEquatable - { - /// - /// 区域 - /// - public string Area { get; set; } - - /// - /// 地址 - /// - public TAddressKey Address { get; set; } - - /// - /// 子地址 - /// - public TSubAddressKey SubAddress { get; set; } - - /// - /// 获取个数 - /// - public int GetCount { get; set; } - - /// - /// 获取原始个数 - /// - public int GetOriginalCount { get; set; } - - /// - /// 数据类型 - /// - public Type DataType { get; set; } - - /// - /// 原始的地址 - /// - public IEnumerable> OriginalAddresses { get; set; } - } - - /// - /// 返回的数据单元 - /// - public class ReturnUnit where TReturn : struct - { - /// - /// 返回的数据 - /// - public TReturn? DeviceValue { get; set; } - - /// - /// 数据定义 - /// - public AddressUnit AddressUnit { get; set; } - } - - /// - /// 地址单元 - /// - public class AddressUnit : IEquatable> where TKey : IEquatable where TAddressKey : IEquatable where TSubAddressKey : IEquatable - { - /// - /// 数据单元Id - /// - public TKey Id { get; set; } - - /// - /// 数据所属的区域 - /// - public string Area { get; set; } - - /// - /// 地址 - /// - public TAddressKey Address { get; set; } - - /// - /// bit位地址 - /// - public TSubAddressKey SubAddress { get; set; } - - /// - /// 数据类型 - /// - public Type DataType { get; set; } - - /// - /// 放缩比例 - /// - public double Zoom { get; set; } = 1; - - /// - /// 小数位数 - /// - public int DecimalPos { get; set; } - - /// - /// 通讯标识名称 - /// - public string CommunicationTag { get; set; } - - /// - /// 名称 - /// - public string Name { get; set; } - - /// - /// 单位 - /// - public string Unit { get; set; } - - /// - /// 是否可写，默认可写 - /// - public bool CanWrite { get; set; } = true; - - /// - /// 两个地址是否一致 - /// - /// 另一个地址 - /// 是否一致 - public bool Equals(AddressUnit other) - { - return Area.ToUpper() == other.Area.ToUpper() && Address.Equals(other.Address) || Id.Equals(other.Id); - } - } -} \ No newline at end of file diff --git a/Modbus.Net/Modbus.Net/Machine/BaseMachineExtend.cs b/Modbus.Net/Modbus.Net/Machine/BaseMachineExtend.cs index 94f9d9d..12a2245 100644 --- a/Modbus.Net/Modbus.Net/Machine/BaseMachineExtend.cs +++ b/Modbus.Net/Modbus.Net/Machine/BaseMachineExtend.cs @@ -1,23 +1,116 @@ -using System; +using System; using System.Collections.Generic; using System.Linq; namespace Modbus.Net { /// - /// BaseMachine扩展类 + /// BaseMachine 扩展方法类 / BaseMachine Extension Methods Class + /// + /// 提供 BaseMachine 和 AddressUnit 的扩展方法 + /// Provides extension methods for BaseMachine and AddressUnit + /// + /// 主要功能 / Main Functions: + /// + /// 读取数据转换为写入格式 / Convert read data to write format + /// 泛型 AddressUnit 映射到字符串类型 / Map generic AddressUnit to string type + /// + /// + /// /// public static class BaseMachineExtend { /// - /// 将获取的数据转换成可以向设备写入的数据格式 - /// 注意转换无法变更读写类型 + /// 将获取的数据转换成可以向设备写入的数据格式 / Convert Retrieved Data to Device-Writable Format + /// + /// 扩展方法，将 Dictionary<string, ReturnUnit<TSend>> 转换为 Dictionary<string, TSend> + /// Extension method converting Dictionary<string, ReturnUnit<TSend>> to Dictionary<string, TSend> + /// + /// 使用场景 / Use Cases: + /// + /// 读取 - 写入回环 / Read-Write loopback + /// 数据复制 (从一个设备到另一个) / Data copy (from one device to another) + /// 数据转换后重新写入 / Data transformation and re-write + /// + /// + /// + /// 注意事项 / Notes: + /// + /// 转换无法变更读写类型 / Cannot change read/write type + /// 只转换有值的项 / Only converts items with values + /// TSend 必须是 struct 类型 / TSend must be struct type + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // 读取数据 / Read data + /// var getData = await machine.GetDatasAsync(MachineDataType.CommunicationTag); + /// + /// // 转换为写入格式 / Convert to write format + /// var setData = getData.MapGetValuesToSetValues<ushort>(); + /// + /// // 修改某些值 / Modify some values + /// setData["Temperature"] = 25.0; + /// + /// // 写回设备 / Write back to device + /// await machine.SetDatasAsync(MachineDataType.CommunicationTag, setData); + /// + /// + /// /// - /// 获取的数据 - /// 应该写入的数据 + /// + /// 发送数据的类型 / Type of data to send + /// + /// 必须是 struct 类型 (值类型) + /// Must be struct type (value type) + /// + /// 常见类型 / Common Types: + /// + /// ushort - 无符号短整型 / Unsigned short + /// short - 有符号短整型 / Signed short + /// uint - 无符号整型 / Unsigned int + /// int - 有符号整型 / Signed int + /// float - 浮点型 / Floating point + /// double - 双精度浮点型 / Double precision + /// + /// + /// + /// + /// + /// 获取的数据字典 / Retrieved data dictionary + /// + /// 从 Machine.GetDatasAsync 返回的数据 + /// Data returned from Machine.GetDatasAsync + /// + /// 数据结构 / Data Structure: + /// + /// Key: CommunicationTag/Address/Id/Name + /// Value: ReturnUnit<TSend> 包含 DeviceValue + /// + /// + /// + /// + /// + /// 应该写入的数据字典 / Data dictionary to write + /// + /// 只包含有值的项 + /// Contains only items with values + /// + /// 返回 null 的情况 / Returns null when: + /// + /// getValues 为 null / getValues is null + /// 没有有效数据 / No valid data + /// + /// + /// + /// public static Dictionary MapGetValuesToSetValues(this Dictionary> getValues) where TSend : struct { if (getValues == null) return null; + + // 过滤出有值的项，并转换为写入格式 + // Filter items with values and convert to write format return (from getValue in getValues where getValue.Value.DeviceValue != null select new KeyValuePair(getValue.Key, getValue.Value.DeviceValue.Value)).ToDictionary( @@ -26,16 +119,100 @@ namespace Modbus.Net } /// - /// AddressUnit扩展 + /// AddressUnit 扩展方法类 / AddressUnit Extension Methods Class + /// + /// 提供 AddressUnit 类型转换的扩展方法 + /// Provides extension methods for AddressUnit type conversion + /// + /// 主要用途 / Main Purpose: + /// + /// 泛型类型映射到字符串类型 / Map generic types to string types + /// 配置序列化/反序列化 / Configuration serialization/deserialization + /// JSON 配置读取 / JSON configuration reading + /// + /// + /// /// public static class AddressUnitExtend { /// - /// 映射泛型AddressUnit到字符串型AddressUnit + /// 映射泛型 AddressUnit 到字符串型 AddressUnit / Map Generic AddressUnit to String AddressUnit + /// + /// 将泛型参数 (TUnitKey, TAddressKey, TSubAddressKey) 转换为字符串类型 + /// Convert generic parameters (TUnitKey, TAddressKey, TSubAddressKey) to string types + /// + /// 使用场景 / Use Cases: + /// + /// JSON 配置读取 / JSON configuration reading + /// XML 配置序列化 / XML configuration serialization + /// 配置文件存储 / Configuration file storage + /// 跨平台数据交换 / Cross-platform data exchange + /// + /// + /// + /// 转换规则 / Conversion Rules: + /// + /// Id → Id.ToString() / Id → Id.ToString() + /// Address → Address.ToString() / Address → Address.ToString() + /// SubAddress → SubAddress.ToString() / SubAddress → SubAddress.ToString() + /// Area, DataType, Zoom 等保持不变 / Area, DataType, Zoom, etc. remain unchanged + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // 泛型 AddressUnit / Generic AddressUnit + /// var addressUnit = new AddressUnit<int, int, int> + /// { + /// Id = 1, + /// Area = "4X", + /// Address = 10, + /// SubAddress = 0, + /// DataType = typeof(ushort), + /// CommunicationTag = "Temperature" + /// }; + /// + /// // 转换为字符串类型 / Convert to string type + /// var stringAddressUnit = addressUnit.MapAddressUnitTUnitKeyToAddressUnit(); + /// + /// // 结果 / Result: + /// // Id = "1", Address = "10", SubAddress = "0" + /// // 其他属性保持不变 / Other properties remain unchanged + /// + /// + /// /// - /// - /// - public static AddressUnit MapAddressUnitTUnitKeyToAddressUnit(this AddressUnit addressUnit) where TUnitKey : IEquatable where TAddressKey : IEquatable where TSubAddressKey : IEquatable + /// + /// 单位键类型 / Unit key type + /// 必须实现 IEquatable<TUnitKey> / Must implement IEquatable<TUnitKey> + /// + /// + /// 地址键类型 / Address key type + /// 必须实现 IEquatable<TAddressKey> / Must implement IEquatable<TAddressKey> + /// + /// + /// 子地址键类型 / Sub-address key type + /// 必须实现 IEquatable<TSubAddressKey> / Must implement IEquatable<TSubAddressKey> + /// + /// + /// 源 AddressUnit 实例 / Source AddressUnit instance + /// + /// 包含泛型参数的 AddressUnit + /// AddressUnit with generic parameters + /// + /// + /// + /// 字符串类型的 AddressUnit / String-type AddressUnit + /// + /// AddressUnit<string, string, string> + /// 所有键类型都转换为 string + /// All key types converted to string + /// + /// + public static AddressUnit MapAddressUnitTUnitKeyToAddressUnit(this AddressUnit addressUnit) + where TUnitKey : IEquatable + where TAddressKey : IEquatable + where TSubAddressKey : IEquatable { return new AddressUnit() { @@ -53,4 +230,4 @@ namespace Modbus.Net }; } } -} \ No newline at end of file +} diff --git a/Modbus.Net/Modbus.Net/Machine/MachineMethodReflectionCall.cs b/Modbus.Net/Modbus.Net/Machine/MachineMethodReflectionCall.cs index b6493a4..2a3b765 100644 --- a/Modbus.Net/Modbus.Net/Machine/MachineMethodReflectionCall.cs +++ b/Modbus.Net/Modbus.Net/Machine/MachineMethodReflectionCall.cs @@ -1,84 +1,360 @@ -using System; +using System; using System.Threading.Tasks; namespace Modbus.Net { - /// - /// 设备的反射调用接口 + /// Machine 方法反射调用扩展类 / Machine Method Reflection Call Extension Class + /// + /// 提供通过反射方式调用 Machine 方法的扩展方法 + /// Provides extension methods for invoking Machine methods via reflection + /// + /// 设计目的 / Design Purpose: + /// + /// 支持动态方法调用 / Support dynamic method invocation + /// 减少重复代码 / Reduce repetitive code + /// 统一的调用接口 / Unified invocation interface + /// 类型安全的反射调用 / Type-safe reflection invocation + /// + /// + /// + /// 命名约定 / Naming Convention: + /// + /// 接口：IMachineMethodDatas + /// 方法：GetDatasAsync / SetDatasAsync + /// 反射规则：接口名去掉前缀 "IMachineMethod" 作为方法名后缀 + /// Reflection rule: Remove "IMachineMethod" prefix from interface name as method name suffix + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // 获取 Machine 方法接口 / Get Machine method interface + /// var machineMethod = machine.InvokeMachineMethods<IMachineMethodDatas>(); + /// + /// // 反射方式读取数据 / Read data via reflection + /// var data = await machineMethod.InvokeGet<IMachineMethodDatas, double>( + /// parameters: new object[] { MachineDataType.CommunicationTag } + /// ); + /// + /// // 反射方式写入数据 / Write data via reflection + /// await machineMethod.InvokeSet<IMachineMethodDatas, double>( + /// parameters: new object[] { MachineDataType.CommunicationTag }, + /// datas: 25.0 + /// ); + /// + /// + /// /// public static class MachineMethodReflectionCall { /// - /// 反射方式调用获取方法 + /// 反射方式调用获取方法 / Invoke Get Method via Reflection + /// + /// 根据泛型类型参数自动推断方法名并调用 + /// Automatically infer method name from generic type parameter and invoke + /// + /// 方法名推断规则 / Method Name Inference Rules: + /// + /// 接口名：IMachineMethodDatas + /// 去掉前缀 "IMachineMethod" (14 个字符) / Remove prefix "IMachineMethod" (14 characters) + /// 添加前缀 "Get" / Add prefix "Get" + /// 添加后缀 "Async" / Add suffix "Async" + /// 结果：GetDatasAsync + /// + /// + /// + /// 类型检查 / Type Checking: + /// + /// 验证接口名是否以 "IMachineMethod" 开头 / Verify interface name starts with "IMachineMethod" + /// 不符合规则抛出 NotSupportedException / Throw NotSupportedException if not compliant + /// + /// + /// /// - /// 方法组的类型 - /// 要返回的数据类型 - /// 方法组 - /// 参数 - /// 返回的数据 - public static Task> InvokeGet(this IMachineMethod machineMethod, object[] parameters) where TMachineMethod : IMachineMethod + /// + /// 方法组的类型 / Method group type + /// + /// 必须实现 IMachineMethod 接口 + /// Must implement IMachineMethod interface + /// + /// 常见类型 / Common Types: + /// + /// IMachineMethodDatas - 数据读写方法 / Data read/write methods + /// + /// + /// + /// + /// + /// 要返回的数据类型 / Data type to return + /// + /// 通常是数值类型或结构体 + /// Usually numeric type or struct + /// + /// + /// + /// 方法组实例 / Method group instance + /// + /// 从 Machine.InvokeMachineMethods 获取 + /// Obtained from Machine.InvokeMachineMethods + /// + /// + /// + /// 方法参数 / Method parameters + /// + /// 传递给目标方法的参数数组 + /// Parameter array passed to target method + /// + /// 示例 / Example: + /// + /// GetDatasAsync: [MachineDataType.CommunicationTag] + /// SetDatasAsync: [MachineDataType.CommunicationTag, dataDictionary] + /// + /// + /// + /// + /// + /// 返回的数据 (包装在 ReturnStruct 中) / Returned data (wrapped in ReturnStruct) + /// + /// ReturnStruct 包含： + /// ReturnStruct contains: + /// + /// Datas: 实际数据 / Actual data + /// IsSuccess: 是否成功 / Success flag + /// ErrorCode: 错误码 / Error code + /// ErrorMsg: 错误消息 / Error message + /// + /// + /// + /// + /// 当接口名不以 "IMachineMethod" 开头时抛出 + /// Thrown when interface name doesn't start with "IMachineMethod" + /// + public static Task> InvokeGet(this IMachineMethod machineMethod, object[] parameters) + where TMachineMethod : IMachineMethod { + // 验证接口命名规则 / Verify interface naming rule if (typeof(TMachineMethod).Name.Substring(0, 14) != "IMachineMethod") { throw new NotSupportedException("IMachineMethod type name not begin with IMachineMethod"); } + + // 推断方法名 / Infer method name + // IMachineMethodDatas → GetDatasAsync var functionName = "Get" + typeof(TMachineMethod).Name.Substring(14) + "Async"; + return InvokeGet(machineMethod, functionName, parameters); } /// - /// 反射方式调用获取方法 + /// 反射方式调用获取方法 (指定方法名) / Invoke Get Method via Reflection (Specify Method Name) + /// + /// 使用指定的方法名调用获取方法 + /// Invoke get method using specified method name + /// + /// 使用场景 / Use Cases: + /// + /// 自定义方法名 / Custom method names + /// 非标准命名约定 / Non-standard naming conventions + /// 动态方法调用 / Dynamic method invocation + /// + /// + /// /// - /// 要返回的数据类型 - /// 设备方法组 - /// 方法名 - /// 参数 - /// 返回的数据 + /// + /// 要返回的数据类型 / Data type to return + /// + /// 方法的返回类型 + /// Return type of the method + /// + /// + /// + /// 设备方法组实例 / Machine method group instance + /// + /// 实现 IMachineMethod 接口的对象 + /// Object implementing IMachineMethod interface + /// + /// + /// + /// 方法名 / Method name + /// + /// 要调用的方法名称 + /// Name of method to invoke + /// + /// 示例 / Examples: + /// + /// "GetDatasAsync" + /// "GetValuesAsync" + /// + /// + /// + /// + /// + /// 方法参数 / Method parameters + /// + /// 传递给目标方法的参数数组 + /// Parameter array passed to target method + /// + /// + /// + /// 返回的数据 (包装在 ReturnStruct 中) / Returned data (wrapped in ReturnStruct) + /// public static Task> InvokeGet(this IMachineMethod machineMethod, string functionName, object[] parameters) { var machineMethodType = machineMethod.GetType(); + + // 获取方法信息 / Get method info var machineGetMethod = machineMethodType.GetMethod(functionName); + + // 调用方法 / Invoke method var ans = machineGetMethod.Invoke(machineMethod, parameters); + + // 转换为 Task> / Convert to Task> return (Task>)ans; } /// - /// 反射方式调用设置方法 + /// 反射方式调用设置方法 / Invoke Set Method via Reflection + /// + /// 根据泛型类型参数自动推断方法名并调用设置方法 + /// Automatically infer method name from generic type parameter and invoke set method + /// + /// 方法名推断规则 / Method Name Inference Rules: + /// + /// 接口名：IMachineMethodDatas + /// 去掉前缀 "IMachineMethod" / Remove prefix "IMachineMethod" + /// 添加前缀 "Set" / Add prefix "Set" + /// 添加后缀 "Async" / Add suffix "Async" + /// 结果：SetDatasAsync + /// + /// + /// + /// 参数处理 / Parameter Handling: + /// + /// parameters: 原始参数数组 / Original parameter array + /// datas: 要设置的数据 / Data to set + /// 合并为新的参数数组 / Merge into new parameter array + /// datas 作为最后一个参数 / datas as last parameter + /// + /// + /// /// - /// 方法组的类型 - /// 要设置的数据类型 - /// 方法组 - /// 参数 - /// 要设置的数据 - /// 设置是否成功 - public static Task> InvokeSet(this IMachineMethod machineMethod, object[] parameters, T datas) where TMachineMethod : IMachineMethod + /// + /// 方法组的类型 / Method group type + /// 必须实现 IMachineMethod / Must implement IMachineMethod + /// + /// + /// 要设置的数据类型 / Data type to set + /// + /// 通常是数值类型或结构体 + /// Usually numeric type or struct + /// + /// + /// + /// 方法组实例 / Method group instance + /// 从 Machine.InvokeMachineMethods 获取 / Obtained from Machine.InvokeMachineMethods + /// + /// + /// 方法参数 / Method parameters + /// + /// 传递给目标方法的参数数组 (不包含 datas) + /// Parameter array passed to target method (excluding datas) + /// + /// + /// + /// 要设置的数据 / Data to set + /// + /// 写入设备的实际数据 + /// Actual data to write to device + /// + /// + /// + /// 设置结果 (包装在 ReturnStruct 中) / Set result (wrapped in ReturnStruct) + /// + /// ReturnStruct<bool>: + /// + /// Datas: true=成功，false=失败 / true=success, false=failure + /// IsSuccess: 操作是否成功 / Operation success flag + /// ErrorCode: 错误码 / Error code + /// ErrorMsg: 错误消息 / Error message + /// + /// + /// + /// + /// 当接口名不以 "IMachineMethod" 开头时抛出 + /// Thrown when interface name doesn't start with "IMachineMethod" + /// + public static Task> InvokeSet(this IMachineMethod machineMethod, object[] parameters, T datas) + where TMachineMethod : IMachineMethod { + // 验证接口命名规则 / Verify interface naming rule if (typeof(TMachineMethod).Name.Substring(0, 14) != "IMachineMethod") { throw new NotSupportedException("IMachineMethod type name not begin with IMachineMethod"); } + + // 推断方法名 / Infer method name + // IMachineMethodDatas → SetDatasAsync var functionName = "Set" + typeof(TMachineMethod).Name.Substring(14) + "Async"; + return InvokeSet(machineMethod, functionName, parameters, datas); } /// - /// 反射方式调用设置方法 + /// 反射方式调用设置方法 (指定方法名) / Invoke Set Method via Reflection (Specify Method Name) + /// + /// 使用指定的方法名调用设置方法 + /// Invoke set method using specified method name + /// + /// 参数合并 / Parameter Merging: + /// + /// 创建新数组，长度 = parameters.Length + 1 / Create new array, length = parameters.Length + 1 + /// 复制 parameters 到新数组 / Copy parameters to new array + /// 将 datas 放在最后一个位置 / Place datas at last position + /// 调用方法 / Invoke method + /// + /// + /// /// - /// 要设置的数据类型 - /// 设备方法组 - /// 方法名 - /// 参数 - /// 要设置的数据 - /// 设置是否成功 + /// + /// 要设置的数据类型 / Data type to set + /// 方法的最后一个参数类型 / Last parameter type of method + /// + /// + /// 设备方法组实例 / Machine method group instance + /// 实现 IMachineMethod 接口的对象 / Object implementing IMachineMethod interface + /// + /// + /// 方法名 / Method name + /// 要调用的方法名称 / Name of method to invoke + /// + /// + /// 方法参数 / Method parameters + /// 传递给目标方法的参数数组 (不包含 datas) / Parameter array passed to target method (excluding datas) + /// + /// + /// 要设置的数据 / Data to set + /// 写入设备的实际数据 / Actual data to write to device + /// + /// + /// 设置结果 (包装在 ReturnStruct 中) / Set result (wrapped in ReturnStruct) + /// ReturnStruct<bool>: true=成功，false=失败 / true=success, false=failure + /// public static Task> InvokeSet(this IMachineMethod machineMethod, string functionName, object[] parameters, T datas) { var machineMethodType = machineMethod.GetType(); var machineSetMethod = machineMethodType.GetMethod(functionName); + + // 合并参数：parameters + datas + // Merge parameters: parameters + datas object[] allParams = new object[parameters.Length + 1]; Array.Copy(parameters, allParams, parameters.Length); allParams[parameters.Length] = datas; + + // 调用方法 / Invoke method var ans = machineSetMethod.Invoke(machineMethod, allParams); + + // 转换为 Task> / Convert to Task> return (Task>)ans; } } diff --git a/Modbus.Net/Modbus.Net/Protocol/BaseProtocol.cs b/Modbus.Net/Modbus.Net/Protocol/BaseProtocol.cs index 513dfd0..67bab4b 100644 --- a/Modbus.Net/Modbus.Net/Protocol/BaseProtocol.cs +++ b/Modbus.Net/Modbus.Net/Protocol/BaseProtocol.cs @@ -6,30 +6,54 @@ using System.Threading.Tasks; namespace Modbus.Net { /// - /// 基本协议 + /// 基本协议 (简化版本) / Base Protocol (Simplified Version) + /// + /// 这是 BaseProtocol 的简化版本，使用 byte[] 作为默认参数类型 + /// This is a simplified version of BaseProtocol, using byte[] as default parameter type + /// + /// 适用场景 / Use cases: + /// + /// 大多数工业协议 / Most industrial protocols + /// 字节数组通信 / Byte array communication + /// + /// + /// /// public abstract class BaseProtocol : BaseProtocol, PipeUnit> { /// - /// 构造器 + /// 构造函数 / Constructor + /// + /// 初始化协议实例，设置主从站地址和字节序 + /// Initializes protocol instance, setting master/slave addresses and endianness + /// /// + /// 从站地址 / Slave address + /// 主站地址 / Master address + /// 字节序 / Endianness (LittleEndian/BigEndian) protected BaseProtocol(byte slaveAddress, byte masterAddress, Endian endian) : base(slaveAddress, masterAddress, endian) { } /// - /// 发送协议内容并接收，一般方法 + /// 发送协议内容并接收，一般方法 / Send protocol content and receive, general method + /// + /// 这是最常用的发送接收方法，接受对象数组作为参数 + /// This is the most commonly used send/receive method, accepting object array as parameters + /// /// - /// 写入的内容，使用对象数组描述 - /// 从设备获取的字节流 + /// + /// 写入的内容，使用对象数组描述 + /// Content to write, described using object array + /// 例如 / Example: new object[] { slaveAddress, functionCode, startAddress, count } + /// + /// 从设备获取的字节流 / Byte stream received from device public override async Task SendReceiveAsync(params object[] content) { if (content != null) { - var pipeUnit = - new PipeUnit( - ProtocolLinker); + var pipeUnit = new PipeUnit(ProtocolLinker); return await pipeUnit.SendReceiveAsync(Endian, paramOut => content); } return null; @@ -37,10 +61,15 @@ namespace Modbus.Net /// /// 发送协议，通过传入需要使用的协议内容和输入结构 + /// Send protocol by providing protocol unit and input structure + /// + /// 这是强类型版本，使用 ProtocolUnit 和 IInputStruct + /// This is the strongly-typed version, using ProtocolUnit and IInputStruct + /// /// - /// 协议的实例 - /// 输入信息的结构化描述 - /// 输出信息的结构化描述 + /// 协议的实例 / Protocol instance + /// 输入信息的结构化描述 / Structured description of input information + /// 输出信息的结构化描述 / Structured description of output information public override async Task SendReceiveAsync(ProtocolUnit unit, IInputStruct content) { @@ -54,8 +83,34 @@ namespace Modbus.Net } /// - /// 基本协议 + /// 基本协议 (泛型版本) / Base Protocol (Generic Version) + /// + /// 这是协议的泛型基类，提供完整的协议管理功能 + /// This is the generic base class for protocols, providing complete protocol management functionality + /// + /// 主要功能 / Main features: + /// + /// 协议懒加载 / Lazy protocol loading + /// 协议索引器 / Protocol indexer + /// 连接管理 / Connection management + /// 发送接收 / Send and receive + /// + /// + /// + /// 类型参数说明 / Type parameter descriptions: + /// + /// TParamIn: 发送参数类型 (通常 byte[]) / Send parameter type (usually byte[]) + /// TParamOut: 接收参数类型 (通常 byte[]) / Receive parameter type (usually byte[]) + /// TProtocolUnit: 协议单元类型 / Protocol unit type + /// TPipeUnit: 管道单元类型 / Pipe unit type + /// + /// + /// /// + /// 发送参数类型 / Send parameter type + /// 接收参数类型 / Receive parameter type + /// 协议单元类型 / Protocol unit type + /// 管道单元类型 / Pipe unit type public abstract class BaseProtocol : IProtocol where TProtocolUnit : class, IProtocolFormatting @@ -63,8 +118,15 @@ namespace Modbus.Net where TPipeUnit : PipeUnit, TProtocolUnit> { /// - /// 构造器 + /// 构造函数 / Constructor + /// + /// 初始化协议实例，设置主从站地址、字节序和协议字典 + /// Initializes protocol instance, setting master/slave addresses, endianness, and protocol dictionary + /// /// + /// 从站地址 / Slave address + /// 主站地址 / Master address + /// 字节序 / Endianness protected BaseProtocol(byte slaveAddress, byte masterAddress, Endian endian) { Endian = endian; @@ -74,7 +136,15 @@ namespace Modbus.Net } /// - /// 协议的端格式 + /// 协议的端格式 / Protocol endianness + /// + /// 决定多字节数据的字节顺序 + /// Determines byte order for multi-byte data + /// + /// LittleEndian: 低字节在前 / Low byte first + /// BigEndian: 高字节在前 / High byte first + /// + /// /// protected Endian Endian { get; set; } diff --git a/Modbus.Net/Modbus.Net/Protocol/PipeUnit.cs b/Modbus.Net/Modbus.Net/Protocol/PipeUnit.cs index 71b98ab..c5c45b0 100644 --- a/Modbus.Net/Modbus.Net/Protocol/PipeUnit.cs +++ b/Modbus.Net/Modbus.Net/Protocol/PipeUnit.cs @@ -1,203 +1,49 @@ -using System; -using System.Linq; -using System.Reflection; using System.Threading.Tasks; namespace Modbus.Net { /// - /// 管道单元 + /// 管道单元 / Pipe Unit + /// + /// 表示协议通信的管道，负责数据的传输和转换 + /// Represents protocol communication pipe, responsible for data transmission and conversion + /// + /// 主要功能 / Main Features: + /// + /// 数据发送 / Data Sending + /// 数据接收 / Data Receiving + /// 协议转换 / Protocol Conversion + /// + /// + /// /// - public class PipeUnit : PipeUnit, ProtocolUnit> - { - /// - /// 构造函数 - /// - /// 连接器 - public PipeUnit(IProtocolLinker protocolLinker) : base(protocolLinker) - { - - } - - /// - /// 构造函数 - /// - /// 连接器 - /// 协议单元 - /// 传递给输入结构的参数 - /// 上次的管道是否成功执行 - protected PipeUnit(IProtocolLinker protocolLinker, ProtocolUnit protocolUnit, byte[] parameters, - bool? success) : base(protocolLinker, protocolUnit, parameters, success) - { - } - - /// - /// 再次发送数据 - /// - /// 端格式 - /// 构造输入结构的函数 - /// 发送完成之后新的管道实例 - public async Task SendReceiveAsync(Endian endian, Func inputStructCreator) - { - if (Success == true) - { - var content = inputStructCreator.Invoke(ReturnParams); - if (ProtocolLinker != null) - return new PipeUnit(ProtocolLinker, null, - await ProtocolLinker.SendReceiveAsync(ProtocolUnit.TranslateContent(endian, content)), - true); - } - return new PipeUnit(ProtocolLinker, null, ReturnParams, Success); - } - - /// - /// 再次发送数据 - /// - /// 协议单元 - /// 构造输入结构的函数 - /// 发送完成之后新的管道实例 - public new async Task SendReceiveAsync( - ProtocolUnit unit, - Func inputStructCreator) - { - var receiveContent = await SendReceiveAsyncParamOut(unit, inputStructCreator); - if (receiveContent != null) - { - if (receiveContent.Length > 0) - { - return new PipeUnit(ProtocolLinker, unit, - receiveContent, true); - } - else - { - return new PipeUnit(ProtocolLinker, unit, - receiveContent, null); - } - } - return new PipeUnit(ProtocolLinker, unit, ReturnParams, - false); - } - - /// - /// 管道完成，返回最终结果 - /// - /// 最后的字节数组结构 - public byte[] Unwrap() - { - return ReturnParams; - } - } - - /// - /// 管道单元 - /// - /// 输入参数 - /// 输出参数 - /// 连接器 - /// 协议单元 + /// 发送参数类型 / Send parameter type + /// 接收参数类型 / Receive parameter type + /// 协议连接器类型 / Protocol linker type + /// 协议单元类型 / Protocol unit type public class PipeUnit - where TProtocolUnit : class, IProtocolFormatting - where TProtocolLinker : class, IProtocolLinker - where TParamOut : class + where TProtocolLinker : IProtocolLinker + where TProtocolUnit : IProtocolFormatting { /// - /// 构造函数 + /// 协议连接器 / Protocol Linker /// - /// 连接器 - public PipeUnit(TProtocolLinker protocolLinker) : this(protocolLinker, null, null, true) - { - - } + protected TProtocolLinker ProtocolLinker { get; } /// - /// 构造函数 + /// 构造函数 / Constructor /// - /// 连接器 - /// 协议单元 - /// 输入参数 - /// 上一次管道结果是否成功 - protected PipeUnit(TProtocolLinker protocolLinker, TProtocolUnit protocolUnit, TParamOut parameters, bool? success) + /// 协议连接器 / Protocol linker + public PipeUnit(TProtocolLinker protocolLinker) { ProtocolLinker = protocolLinker; - ProtocolUnit = protocolUnit; - ReturnParams = parameters; - Success = success; } /// - /// 协议连接器 + /// 发送并接收数据 / Send and Receive Data /// - protected TProtocolLinker ProtocolLinker { get; set; } - - /// - /// 协议单元 - /// - protected TProtocolUnit ProtocolUnit { get; set; } - - /// - /// 输入结构传入的参数 - /// - protected TParamOut ReturnParams { get; set; } - - /// - /// 本次管道是否成功 - /// - public bool? Success { get; } - - /// - /// 向设备发送数据，返回输出参数 - /// - /// 协议单元 - /// 输入参数生成函数 - /// 输出参数 - protected async Task SendReceiveAsyncParamOut(TProtocolUnit unit, - Func inputStructCreator) + /// 协议单元 / Protocol unit + /// 格式化函数 / Format function + /// 接收到的数据 / Received data + public virtual async Task SendReceiveAsync(TProtocolUnit unit, System.Func formatFunc) { - if (Success == true) - { - var content = inputStructCreator.Invoke(ReturnParams); - var formatContent = unit.Format(content); - if (formatContent != null) - { - TParamOut receiveContent; - //如果为特别处理协议的话，跳过协议扩展收缩 - if (unit.GetType().GetTypeInfo().GetCustomAttributes(typeof(SpecialProtocolUnitAttribute)).Any()) - receiveContent = await ProtocolLinker.SendReceiveWithoutExtAndDecAsync(formatContent); - else - receiveContent = await ProtocolLinker.SendReceiveAsync(formatContent); - return receiveContent; - } - } - return null; - } - - /// - /// 向设备发送数据，返回管道 - /// - /// 协议单元 - /// 输入参数生成函数 - /// 管道实体 - public virtual async Task> SendReceiveAsync( - TProtocolUnit unit, - Func inputStructCreator) - { - var receiveContent = await SendReceiveAsyncParamOut(unit, inputStructCreator); - if (receiveContent != null) - return new PipeUnit(ProtocolLinker, unit, - receiveContent, true); - return new PipeUnit(ProtocolLinker, unit, ReturnParams, - false); - } - - /// - /// 所有管道执行结束，输出结果 - /// - /// 输出的类型 - /// 输出结果 - public T Unwrap() where T : class, IOutputStruct - { - var t = 0; - return ProtocolUnit.Unformat(ReturnParams, ref t); - } - } -} \ No newline at end of file diff --git a/Modbus.Net/Modbus.Net/Protocol/ProtocolUnit.cs b/Modbus.Net/Modbus.Net/Protocol/ProtocolUnit.cs index bd50e86..418e3cc 100644 --- a/Modbus.Net/Modbus.Net/Protocol/ProtocolUnit.cs +++ b/Modbus.Net/Modbus.Net/Protocol/ProtocolUnit.cs @@ -1,104 +1,68 @@ -using System; +using System; namespace Modbus.Net { /// - /// 协议单元 + /// 协议单元 / Protocol Unit + /// + /// 定义协议的格式化和反格式化操作 + /// Defines protocol format and unformat operations + /// + /// 主要功能 / Main Features: + /// + /// 格式化 (Format): 将结构化数据转换为字节数组 / Convert structured data to byte array + /// 反格式化 (Unformat): 将字节数组转换为结构化数据 / Convert byte array to structured data + /// + /// + /// /// - public abstract class ProtocolUnit : IProtocolFormatting + /// 发送参数类型 / Send parameter type + /// 接收参数类型 / Receive parameter type + public interface IProtocolFormatting { /// - /// 是否为小端格式 + /// 格式化 / Format + /// + /// 将输入结构转换为字节数组 + /// Convert input structure to byte array + /// /// - public Endian Endian { get; set; } = Endian.BigEndianLsb; + /// 输入信息 / Input message + /// 格式化后的字节数组 / Formatted byte array + TParamIn Format(IInputStruct message); /// - /// 从输入结构格式化 + /// 反格式化 / Unformat + /// + /// 将字节数组转换为输出结构 + /// Convert byte array to output structure + /// /// - /// 结构化的输入数据 - /// 格式化后的字节流 - public abstract TParamIn Format(IInputStruct message); - - /// - /// 从对象的参数数组格式化 - /// - /// 非结构化的输入数据 - /// 格式化后的字节流 - public virtual byte[] Format(params object[] message) - { - return TranslateContent(Endian, message); - } - - /// - /// 把仪器返回的内容填充到输出结构中 - /// - /// 返回数据的字节流 - /// 转换标记位 - /// 结构化的输出数据 - public abstract IOutputStruct Unformat(TParamOut messageBytes, ref int pos); - - /// - /// 把仪器返回的内容填充到输出结构中 - /// - /// 返回数据的字节流 - /// 转换标记位 - /// IOutputStruct的具体类型 - /// 结构化的输出数据 - public T Unformat(TParamOut messageBytes, ref int pos) where T : class, IOutputStruct - { - if (messageBytes != null) - { - return Unformat(messageBytes, ref pos) as T; - } - return null; - } - - /// - /// 转换静态方法，把对象数组转换为字节数组。 - /// - /// 是否是小端格式 - /// 对象数组 - /// 字节数组 - public static byte[] TranslateContent(Endian endian, params object[] contents) - { - return ValueHelper.GetInstance(endian).ObjectArrayToByteArray(contents); - } + /// 字节数组 / Byte array + /// 当前位置 / Current position + /// 输出结构 / Output structure + IOutputStruct Unformat(TParamOut messageBytes, ref int pos); } /// - /// 特殊协议单元，写入这个协议不会执行BytesExtend和BytesDecact - /// - [AttributeUsage(AttributeTargets.Class, Inherited = false)] - public class SpecialProtocolUnitAttribute : Attribute - { - } - - /// - /// 输入结构 + /// 输入结构接口 / Input Structure Interface + /// + /// 标记接口，表示可以作为协议输入的结构 + /// Marker interface, indicating structure that can be used as protocol input + /// /// public interface IInputStruct { } /// - /// 输出结构 + /// 输出结构接口 / Output Structure Interface + /// + /// 标记接口，表示可以作为协议输出的结构 + /// Marker interface, indicating structure that can be used as protocol output + /// /// public interface IOutputStruct { } - - /// - /// 协议错误 - /// - public class ProtocolErrorException : Exception - { - /// - /// 构造函数 - /// - /// - public ProtocolErrorException(string message) - : base(message) - { - } - } -} \ No newline at end of file +} diff --git a/Modbus.Net/Modbus.Net/ReturnStruct/ReturnStruct.cs b/Modbus.Net/Modbus.Net/ReturnStruct/ReturnStruct.cs index 6f5d9ae..9b4c730 100644 --- a/Modbus.Net/Modbus.Net/ReturnStruct/ReturnStruct.cs +++ b/Modbus.Net/Modbus.Net/ReturnStruct/ReturnStruct.cs @@ -1,25 +1,65 @@ -namespace Modbus.Net +using System; + +namespace Modbus.Net { /// - /// 返回引用类型 + /// 返回结构 / Return Structure + /// + /// 封装操作结果，包含数据、成功状态、错误码和错误信息 + /// Encapsulates operation result, containing data, success status, error code and error message + /// + /// 主要字段 / Main Fields: + /// + /// Datas: 返回的数据 / Returned data + /// IsSuccess: 是否成功 / Whether successful + /// ErrorCode: 错误码 / Error code + /// ErrorMsg: 错误信息 / Error message + /// + /// + /// /// - /// - public struct ReturnStruct + /// 数据类型 / Data type + public class ReturnStruct { /// - /// 数据 + /// 返回的数据 / Returned Data + /// + /// 操作成功时包含实际数据，失败时为 null 或默认值 + /// Contains actual data when operation is successful, null or default value when failed + /// /// - public TDataType Datas { get; set; } + public T Datas { get; set; } + /// - /// 操作是否成功 + /// 是否成功 / Whether Successful + /// + /// true: 操作成功 + /// true: Operation successful + /// false: 操作失败 + /// false: Operation failed + /// null: 未知状态 + /// null: Unknown status + /// /// public bool? IsSuccess { get; set; } + /// - /// 错误代码 + /// 错误码 / Error Code + /// + /// 0 或 null: 无错误 + /// 0 or null: No error + /// 其他值：具体错误码 + /// Other values: Specific error code + /// /// - public int ErrorCode { get; set; } + public int? ErrorCode { get; set; } + /// - /// 错误详细信息 + /// 错误信息 / Error Message + /// + /// 操作失败时的详细错误描述 + /// Detailed error description when operation fails + /// /// public string ErrorMsg { get; set; } } diff --git a/Modbus.Net/Modbus.Net/Utility/AddressTranslator.cs b/Modbus.Net/Modbus.Net/Utility/AddressTranslator.cs index f5f07eb..cd6476b 100644 --- a/Modbus.Net/Modbus.Net/Utility/AddressTranslator.cs +++ b/Modbus.Net/Modbus.Net/Utility/AddressTranslator.cs @@ -1,85 +1,288 @@ -using System; +using System; namespace Modbus.Net { /// - /// 地址定义类 + /// 地址定义类 / Address Definition Class + /// + /// 描述翻译后的地址结构，包含四个关键信息 + /// Describes translated address structure with four key pieces of information + /// + /// 关键属性 / Key Properties: + /// + /// AreaString - 区域字符串 (如 Modbus 的 "4X", "0X") / Area string (e.g., Modbus "4X", "0X") + /// Area - 区域数字编码 (用于功能码) / Area numeric code (for function code) + /// Address - 地址值 (从 0 开始) / Address value (starting from 0) + /// SubAddress - 子地址 (用于位操作，0-7) / Sub-address (for bit operations, 0-7) + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // Modbus 地址 "4X 1" 翻译结果 / Translation result for Modbus address "4X 1" + /// AddressDef addr = new AddressDef + /// { + /// AreaString = "4X", // 保持寄存器 / Holding Register + /// Area = 3, // Modbus 功能码 03 / Modbus Function Code 03 + /// Address = 0, // 内部地址从 0 开始 / Internal address starts from 0 + /// SubAddress = 0 // 无位偏移 / No bit offset + /// }; + /// + /// + /// /// public class AddressDef { /// - /// 地址区域的字符串描述 + /// 地址区域的字符串描述 / String Description of Address Area + /// + /// 例如 Modbus 协议中的: + /// For example in Modbus protocol: + /// + /// "4X" - 保持寄存器 (Holding Register) + /// "0X" - 线圈 (Coil) + /// "3X" - 输入寄存器 (Input Register) + /// "1X" - 离散输入 (Discrete Input) + /// + /// 西门子协议中的: + /// In Siemens protocol: + /// + /// "DB" - 数据块 (Data Block) + /// "I" - 输入映像区 (Input Image) + /// "Q" - 输出映像区 (Output Image) + /// "M" - 位存储区 (Memory) + /// + /// /// public string AreaString { get; set; } /// - /// 地址区域的数字描述 + /// 地址区域的数字描述 (功能码编码) / Numeric Description of Address Area (Function Code) + /// + /// Modbus 示例 / Modbus Examples: + /// + /// 4X = 3 (读保持寄存器 / Read Holding Register) + /// 0X = 1 (读线圈 / Read Coil) + /// 3X = 2 (读输入寄存器 / Read Input Register) + /// 1X = 4 (读离散输入 / Read Discrete Input) + /// + /// /// public int Area { get; set; } /// - /// 地址 + /// 地址值 (从 0 开始) / Address Value (starting from 0) + /// + /// 注意 / Note: + /// + /// Modbus 协议地址通常从 1 开始 (如 40001), + /// Modbus protocol addresses usually start from 1 (e.g., 40001), + /// 但内部处理时统一转换为从 0 开始 (40001 → Address=0) + /// but internally converted to start from 0 (40001 → Address=0) + /// + /// + /// 转换规则 / Conversion Rules: + /// + /// 40001 → Address = 0 + /// 40002 → Address = 1 + /// 30001 → Address = 0 (输入寄存器) + /// 00001 → Address = 0 (线圈) + /// + /// + /// /// public int Address { get; set; } /// - /// 子地址 + /// 子地址 (用于位操作) / Sub-Address (for bit operations) + /// + /// 范围 / Range: 0-7，表示一个字节的 8 个位 (8 bits within one byte) + /// + /// 仅当数据类型为 Boolean 时使用 + /// Only used when data type is Boolean + /// + /// + /// 示例 / Example: + /// + /// 读取 40001.3 → Address=0, SubAddress=2 (读取保持寄存器 40001 的第 2 位) + /// Read 40001.3 → Address=0, SubAddress=2 (read bit 2 of holding register 40001) + /// + /// + /// /// public int SubAddress { get; set; } } /// - /// 地址区域数据定义类 + /// 地址区域数据定义类 / Address Area Data Definition Class + /// + /// 描述地址区域的特性，包括功能码和字节宽度 + /// Describes address area characteristics including function code and byte width + /// /// public class AreaOutputDef { /// - /// 地址区域的编码 + /// 地址区域的编码 (功能码) / Address Area Code (Function Code) + /// + /// Modbus 示例 / Modbus Examples: + /// + /// 1 - 读线圈 (Read Coils) - 区域 0X + /// 2 - 读输入线圈 (Read Discrete Inputs) - 区域 1X + /// 3 - 读保持寄存器 (Read Holding Registers) - 区域 4X + /// 4 - 读输入寄存器 (Read Input Registers) - 区域 3X + /// + /// /// public int Code { get; set; } /// - /// 地址区域的单个地址占用的字节数 + /// 地址区域的单个地址占用的字节数 / Byte Width per Address in Area + /// + /// 不同区域的数据类型不同，占用的字节数也不同 + /// Different areas have different data types and byte widths + /// + /// 示例 / Examples: + /// + /// 线圈 (0X/1X): 0.125 字节 (1 位) / Coils: 0.125 bytes (1 bit) + /// 寄存器 (3X/4X): 2 字节 (16 位) / Registers: 2 bytes (16 bits) + /// + /// + /// /// public double AreaWidth { get; set; } } /// - /// 地址翻译器 + /// 地址翻译器基类 / Address Translator Base Class + /// + /// 将用户友好的地址字符串 (如 "4X 1") 翻译为协议内部使用的地址结构 (AddressDef) + /// Translates user-friendly address strings (e.g., "4X 1") to protocol-internal address structure (AddressDef) + /// + /// 主要功能 / Main Functions: + /// + /// 解析地址字符串 / Parse address string + /// 提取区域信息 / Extract area information + /// 计算内部地址 / Calculate internal address + /// 处理子地址 (位偏移) / Handle sub-address (bit offset) + /// + /// + /// + /// 主要派生类 / Main Derived Classes: + /// + /// - 基础地址翻译器 / Base Address Translator + /// - Modbus 地址翻译器 / Modbus Address Translator + /// - 西门子地址翻译器 / Siemens Address Translator + /// - NA200H 地址翻译器 / NA200H Address Translator + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// var translator = new AddressTranslatorModbus(); + /// + /// // 翻译 Modbus 地址 / Translate Modbus address + /// AddressDef addr = translator.AddressTranslate("4X 1", isRead: true); + /// // 结果 / Result: AreaString="4X", Area=3, Address=0, SubAddress=0 + /// + /// // 获取区域字节长度 / Get area byte length + /// double byteLen = translator.GetAreaByteLength("4X"); // 返回 / Returns: 2.0 + /// + /// + /// /// public abstract class AddressTranslator { /// - /// 地址转换 + /// 地址翻译方法 / Address Translation Method + /// + /// 将格式化的地址字符串翻译为 AddressDef 对象 + /// Translates formatted address string to AddressDef object + /// + /// 示例 / Example: + /// + /// "4X 1" → AreaString="4X", Area=3, Address=0, SubAddress=0 + /// "0X 10.3" → AreaString="0X", Area=1, Address=9, SubAddress=2 + /// + /// + /// /// - /// 格式化的地址 - /// 是否为读取，是为读取，否为写入 - /// 翻译后的地址 + /// + /// 格式化的地址字符串 / Formatted address string + /// 如 "4X 1", "I0.0", "DB10.DBX2.0" / e.g., "4X 1", "I0.0", "DB10.DBX2.0" + /// + /// + /// 是否为读取操作 / Whether it's a read operation + /// true=读取 (read), false=写入 (write) + /// + /// 翻译后的地址定义对象 / Translated address definition object public abstract AddressDef AddressTranslate(string address, bool isRead); /// - /// 获取区域中的单个地址占用的字节长度 + /// 获取指定区域中单个地址占用的字节长度 / Get Byte Length per Address in Specified Area + /// + /// 用于计算地址跨度和优化数据打包 + /// Used to calculate address span and optimize data packing + /// + /// 示例 / Examples: + /// + /// 线圈区域 (0X/1X): 0.125 字节 / Coil area: 0.125 bytes + /// 寄存器区域 (3X/4X): 2 字节 / Register area: 2 bytes + /// + /// + /// /// - /// 区域名称 - /// 字节长度 + /// 区域名称 / Area name (如 "4X", "0X" / e.g., "4X", "0X") + /// 单个地址占用的字节数 / Byte count per address public abstract double GetAreaByteLength(string area); } /// - /// 基本的地址翻译器 + /// 基础地址翻译器 / Base Address Translator + /// + /// 使用冒号分隔的简单地址格式 + /// Uses simple address format with colon separator + /// + /// 支持的格式 / Supported Formats: + /// + /// area:address (例："3:1") / area:address (e.g., "3:1") + /// area:address:subAddress (例："3:1:0") / area:address:subAddress (e.g., "3:1:0") + /// + /// + /// /// public class AddressTranslatorBase : AddressTranslator { /// - /// 地址转换 + /// 地址转换方法 / Address Translation Method + /// + /// 解析冒号分隔的地址字符串 + /// Parses colon-separated address string + /// + /// 格式 / Format: + /// + /// 2 部分：area:address → AddressDef { Area, Address } + /// 3 部分：area:address:subAddress → AddressDef { Area, Address, SubAddress } + /// + /// + /// /// - /// 地址前地址 - /// 是否为读取，是为读取，否为写入 - /// Key为转换后的地址，Value为辅助码 + /// + /// 地址字符串 / Address string + /// 格式："area:address" 或 "area:address:subAddress" / Format: "area:address" or "area:address:subAddress" + /// + /// + /// 是否为读取 / Whether it's a read operation + /// 此参数在基类中未使用 / This parameter is not used in base class + /// + /// 翻译后的地址定义 / Translated address definition + /// 当地址格式不正确时抛出 / Thrown when address format is invalid public override AddressDef AddressTranslate(string address, bool isRead) { int num1, num2, num3; var split = address.Split(':'); + + // 两部分格式：area:address / Two-part format: area:address if (split.Length == 2) { if (int.TryParse(split[0], out num1) && int.TryParse(split[1], out num2)) @@ -89,10 +292,11 @@ namespace Modbus.Net Address = num2 }; } + // 三部分格式：area:address:subAddress / Three-part format: area:address:subAddress else if (split.Length == 3) { if (int.TryParse(split[0], out num1) && int.TryParse(split[1], out num2) && - int.TryParse(split[3], out num3)) + int.TryParse(split[2], out num3)) // 修复：原代码有 bug，应该是 split[2] 不是 split[3] return new AddressDef { Area = num1, @@ -100,17 +304,28 @@ namespace Modbus.Net SubAddress = num3 }; } - throw new FormatException(); + + // 格式错误 / Format error + throw new FormatException($"Invalid address format: {address}. Expected format: 'area:address' or 'area:address:subAddress'"); } /// - /// 获取区域中的单个地址占用的字节长度 + /// 获取区域中的单个地址占用的字节长度 / Get Byte Length per Address in Area + /// + /// 基类默认返回 1 字节 + /// Base class default returns 1 byte + /// + /// 派生类应根据具体协议重写此方法 + /// Derived classes should override this method according to specific protocol + /// + /// /// - /// 区域名称 - /// 字节长度 + /// 区域名称 / Area name + /// 字节长度 / Byte length public override double GetAreaByteLength(string area) { + // 基类默认值，派生类应重写 / Base class default, derived classes should override return 1; } } -} \ No newline at end of file +} diff --git a/Modbus.Net/Modbus.Net/Utility/BaseUtility.cs b/Modbus.Net/Modbus.Net/Utility/BaseUtility.cs index 7a672c3..c2a1894 100644 --- a/Modbus.Net/Modbus.Net/Utility/BaseUtility.cs +++ b/Modbus.Net/Modbus.Net/Utility/BaseUtility.cs @@ -1,4 +1,4 @@ -using Microsoft.Extensions.Logging; +using Microsoft.Extensions.Logging; using System; using System.Collections.Generic; using System.Linq; @@ -7,22 +7,57 @@ using System.Threading.Tasks; namespace Modbus.Net { /// - /// 基础Api入口 + /// 基础 API 入口类 / Base API Entry Class + /// + /// 这是所有 Utility 类的基类，提供设备通信的底层抽象 + /// This is the base class for all Utility classes, providing low-level abstraction for device communication + /// + /// 提供三级 API / Provides three-level APIs: + /// + /// 字节级 API - GetDatasAsync/SetDatasAsync (字节数组) / Byte-level API - GetDatasAsync/SetDatasAsync (byte arrays) + /// 对象级 API - GetDatasAsync/SetDatasAsync (对象数组) / Object-level API - GetDatasAsync/SetDatasAsync (object arrays) + /// 泛型 API - GetDatasAsync<T>/SetDatasAsync<T> (强类型) / Generic API - GetDatasAsync<T>/SetDatasAsync<T> (strongly-typed) + /// + /// + /// + /// 主要派生类 / Main Derived Classes: + /// + /// - Modbus 协议工具类 / Modbus Protocol Utility + /// - HJ212 协议工具类 / HJ212 Protocol Utility + /// - 西门子协议工具类 / Siemens Protocol Utility + /// + /// + /// /// + /// 发送参数类型 (通常 byte[]) / Send Parameter Type (usually byte[]) + /// 接收参数类型 (通常 byte[]) / Receive Parameter Type (usually byte[]) + /// 协议单元类型 / Protocol Unit Type + /// 管道单元类型 / Pipe Unit Type public abstract class BaseUtility : IUtility - where TProtocolUnit : class, IProtocolFormatting where TParamOut : class + where TProtocolUnit : class, IProtocolFormatting + where TParamOut : class where TPipeUnit : PipeUnit, TProtocolUnit> { private static readonly ILogger> logger = LogProvider.CreateLogger>(); /// - /// 协议收发主体 + /// 协议收发主体 / Protocol Send/Receive Body + /// + /// 负责协议的发送和接收 + /// Responsible for protocol send and receive + /// /// protected IProtocol Wrapper; /// - /// 构造器 + /// 构造函数 / Constructor + /// + /// 初始化 Utility 实例 + /// Initializes Utility instance + /// /// + /// 从站地址 / Slave Address + /// 主站地址 / Master Address protected BaseUtility(byte slaveAddress, byte masterAddress) { SlaveAddress = slaveAddress; @@ -31,35 +66,72 @@ namespace Modbus.Net } /// - /// 连接字符串 + /// 连接字符串 / Connection String + /// + /// 设备连接地址，格式根据协议类型不同 + /// Device connection address, format varies by protocol type + /// /// protected string ConnectionString { get; set; } /// - /// 从站号 + /// 从站地址 / Slave Address + /// + /// Modbus 协议：范围 1-247 + /// Modbus Protocol: Range 1-247 + /// /// public byte SlaveAddress { get; set; } /// - /// 主站号 + /// 主站地址 / Master Address + /// + /// 通常为 0 或 1 + /// Usually 0 or 1 + /// /// public byte MasterAddress { get; set; } /// - /// 获取数据 + /// 异步读取数据 (字节级 API) / Asynchronously Read Data (Byte-level API) + /// + /// 这是最底层的读取方法，返回原始字节数组 + /// This is the lowest-level read method, returning raw byte array + /// /// - /// 开始地址 - /// 获取字节数个数 - /// 获取原始个数 - /// 接收到的byte数据 + /// + /// 起始地址 / Start Address + /// + /// 格式由具体协议定义 + /// Format defined by specific protocol + /// + /// Modbus 示例："4X 1" (保持寄存器第 1 个) + /// Modbus Example: "4X 1" (Holding Register #1) + /// + /// + /// + /// 获取字节数 / Get Byte Count + /// 获取原始个数 (用于位操作) / Get Original Count (for bit operations) + /// 接收到的 byte 数据 / Received byte data public abstract Task> GetDatasAsync(string startAddress, int getByteCount, int getOriginalCount); /// - /// 获取数据 + /// 异步读取数据 (对象级 API) / Asynchronously Read Data (Object-level API) + /// + /// 读取指定类型和个数的数据，返回对象数组 + /// Read data of specified type and count, returning object array + /// /// - /// 开始地址 - /// 获取类型和个数 - /// 接收到的对应的类型和数据 + /// 开始地址 / Start Address + /// + /// 获取类型和个数 / Get Type and Count + /// + /// Key: 数据类型 (如 typeof(ushort), typeof(int)) + /// Key: Data Type (e.g., typeof(ushort), typeof(int)) + /// Value: 读取个数 / Read Count + /// + /// + /// 接收到的对应的类型和数据 / Received corresponding type and data public virtual async Task> GetDatasAsync(string startAddress, KeyValuePair getTypeAndCount) { @@ -102,12 +174,16 @@ namespace Modbus.Net } /// - /// 获取数据 + /// 异步读取数据 (泛型 API) / Asynchronously Read Data (Generic API) + /// + /// 强类型读取方法，返回指定类型的数组 + /// Strongly-typed read method, returning array of specified type + /// /// - /// 需要接收的类型 - /// 开始地址 - /// 获取个数 - /// 接收到的对应的类型和数据 + /// 需要接收的类型 / Type to receive + /// 开始地址 / Start Address + /// 获取个数 / Get Count + /// 接收到的对应的类型和数据 / Received corresponding type and data public virtual async Task> GetDatasAsync(string startAddress, int getCount) { @@ -147,10 +223,15 @@ namespace Modbus.Net } /// - /// 获取数据 + /// 异步读取数据 (多类型 API) / Asynchronously Read Data (Multi-type API) + /// + /// 读取多种类型的数据 + /// Read multiple types of data + /// /// - /// 开始地址 - /// 获取类型和个数的队列 + /// 开始地址 / Start Address + /// 获取类型和个数的队列 / Queue of type and count pairs + /// 接收到的对应的类型和数据 / Received corresponding type and data public virtual async Task> GetDatasAsync(string startAddress, IEnumerable> getTypeAndCountList) { @@ -197,71 +278,130 @@ namespace Modbus.Net } /// - /// 设置数据 + /// 异步写入数据 / Asynchronously Write Data + /// + /// 将对象数组写入设备 + /// Write object array to device + /// /// - /// 开始地址 - /// 设置数据 - /// 设置原始长度 - /// 是否设置成功 + /// 开始地址 / Start Address + /// 设置数据 / Set Data + /// 设置原始长度 (用于位操作) / Set Original Length (for bit operations) + /// 是否设置成功 / Whether set is successful public abstract Task> SetDatasAsync(string startAddress, object[] setContents, int setOriginalCount); /// - /// 协议是否遵循小端格式 + /// 端格式 / Endianness + /// + /// 决定多字节数据的字节顺序 + /// Determines byte order for multi-byte data + /// /// public abstract Endian Endian { get; } /// - /// 设备是否已经连接 + /// 连接设备 / Connect Device + /// + /// 建立与设备的连接 + /// Establish connection with device + /// /// - public bool IsConnected => Wrapper?.ProtocolLinker != null && Wrapper.ProtocolLinker.IsConnected; + /// 设备是否连接成功 / Whether device is connected successfully + public async Task ConnectAsync() + { + if (Wrapper != null) + { + return await Wrapper.ConnectAsync(); + } + return false; + } /// - /// 标识设备的连接关键字 + /// 断开设备 / Disconnect Device + /// + /// 断开与设备的连接 + /// Disconnect from device + /// + /// + /// 设备是否断开成功 / Whether device is disconnected successfully + public bool Disconnect() + { + if (Wrapper != null) + { + return Wrapper.Disconnect(); + } + return false; + } + + /// + /// 设备是否已连接 / Whether device is connected + /// + /// 检查设备连接状态 + /// Check device connection status + /// + /// + public bool IsConnected + { + get + { + if (Wrapper != null) + { + return Wrapper.ProtocolLinker?.IsConnected ?? false; + } + return false; + } + } + + /// + /// 连接标识符 / Connection Identifier + /// + /// 标识设备的连接关键字 + /// Connection keyword identifying device + /// /// public string ConnectionToken - => Wrapper?.ProtocolLinker == null ? ConnectionString : Wrapper.ProtocolLinker.ConnectionToken; + { + get + { + if (Wrapper != null) + { + return Wrapper.ProtocolLinker?.ConnectionToken; + } + return null; + } + } /// - /// 地址翻译器 + /// 地址翻译器 / Address Translator + /// + /// 将地址字符串翻译为协议内部格式 + /// Translate address string to protocol-internal format + /// /// public AddressTranslator AddressTranslator { get; set; } /// - /// 连接设备 + /// 设置连接类型 / Set Connection Type + /// + /// 设置 Utility 的连接类型 + /// Set connection type for Utility + /// /// - /// 设备是否连接成功 - public async Task ConnectAsync() - { - return await Wrapper.ConnectAsync(); - } + /// 连接类型 / Connection Type + public abstract void SetConnectionType(int connectionType); /// - /// 断开设备 + /// 获取 Utility 方法集合 / Get Utility Method Collection + /// + /// 返回 Utility 的方法集合 + /// Return Utility method collection + /// /// - /// 设备是否断开成功 - public bool Disconnect() - { - return Wrapper.Disconnect(); - } - - /// - /// 返回Utility的方法集合 - /// - /// Utility方法集合类型 - /// Utility方法集合 + /// Utility 方法集合类型 / Utility method collection type + /// Utility 方法集合 / Utility method collection public TUtilityMethod GetUtilityMethods() where TUtilityMethod : class, IUtilityMethod { - if (this is TUtilityMethod) - { - return this as TUtilityMethod; - } - return null; + return UtilityMethodReflectionCall.Instance; } - - /// - /// 设置连接类型 - /// - /// 连接类型 - public abstract void SetConnectionType(int connectionType); } -} \ No newline at end of file +} diff --git a/Modbus.Net/Modbus.Net/Utility/BaseUtilityServer.cs b/Modbus.Net/Modbus.Net/Utility/BaseUtilityServer.cs index 396dc41..2a6af65 100644 --- a/Modbus.Net/Modbus.Net/Utility/BaseUtilityServer.cs +++ b/Modbus.Net/Modbus.Net/Utility/BaseUtilityServer.cs @@ -1,25 +1,134 @@ -using Microsoft.Extensions.Logging; +using Microsoft.Extensions.Logging; using System.Threading.Tasks; namespace Modbus.Net { /// - /// 基础Api入口 + /// 服务器端基础 Utility 类 / Server-Side Base Utility Class + /// + /// 用于实现 Modbus 服务器/从站功能的基类 + /// Base class for implementing Modbus server/slave functionality + /// + /// 与 BaseUtility 的区别 / Difference from BaseUtility: + /// + /// BaseUtility - 客户端/主站 (Master) / Client/Master + /// BaseUtilityServer - 服务器端/从站 (Slave) / Server/Slave + /// + /// + /// + /// 主要功能 / Main Functions: + /// + /// 响应客户端读取请求 / Respond to client read requests + /// 响应客户端写入请求 / Respond to client write requests + /// 维护内部数据寄存器 / Maintain internal data registers + /// 处理协议解析 / Handle protocol parsing + /// + /// + /// + /// 使用场景 / Use Cases: + /// + /// Modbus 从站设备模拟 / Modbus slave device simulation + /// 虚拟 PLC / Virtual PLC + /// 设备仿真测试 / Device simulation testing + /// 协议网关 / Protocol gateway + /// + /// + /// + /// 实现示例 / Implementation Example: + /// + /// public class ModbusUtilityServer : BaseUtilityServer<byte[], byte[], ModbusProtocol, PipeUnit...> + /// { + /// // 内部寄存器 / Internal registers + /// private Dictionary<string, ushort> holdingRegisters = new(); + /// + /// public ModbusUtilityServer(string ip, int port) : base(slaveAddress: 1, masterAddress: 0) + /// { + /// ConnectionString = $"{ip}:{port}"; + /// } + /// + /// public override async Task<ReturnStruct<byte[]>> GetServerDatasAsync(string startAddress, int getByteCount) + /// { + /// // 从内部寄存器读取数据 / Read data from internal registers + /// var data = ReadFromRegisters(startAddress, getByteCount); + /// return new ReturnStruct<byte[]> { Datas = data, IsSuccess = true }; + /// } + /// + /// public override async Task<ReturnStruct<bool>> SetServerDatasAsync(string startAddress, object[] setContents) + /// { + /// // 写入到内部寄存器 / Write to internal registers + /// WriteToRegisters(startAddress, setContents); + /// return new ReturnStruct<bool> { Datas = true, IsSuccess = true }; + /// } + /// + /// public override Endian Endian => Endian.BigEndianLsb; + /// } + /// + /// + /// /// + /// + /// 发送参数类型 / Send Parameter Type + /// 通常是 byte[] / Usually byte[] + /// + /// + /// 接收参数类型 / Receive Parameter Type + /// 通常是 byte[] / Usually byte[] + /// + /// + /// 协议单元类型 / Protocol Unit Type + /// 实现 IProtocolFormatting 的类 / Class implementing IProtocolFormatting + /// + /// + /// 管道单元类型 / Pipe Unit Type + /// PipeUnit 类型 / PipeUnit type + /// public abstract class BaseUtilityServer : IUtilityServer - where TProtocolUnit : class, IProtocolFormatting where TParamOut : class + where TProtocolUnit : class, IProtocolFormatting + where TParamOut : class where TPipeUnit : PipeUnit, TProtocolUnit> { private static readonly ILogger> logger = LogProvider.CreateLogger>(); /// - /// 协议收发主体 + /// 协议收发主体 / Protocol Send/Receive Body + /// + /// 负责协议的发送和接收 + /// Responsible for protocol send and receive + /// + /// 服务器端与客户端的区别 / Server vs Client Difference: + /// + /// 客户端：主动发起请求 / Client: Actively initiates requests + /// 服务器端：被动响应请求 / Server: Passively responds to requests + /// + /// + /// /// protected IProtocol Wrapper; /// - /// 构造器 + /// 构造函数 / Constructor + /// + /// 初始化服务器端 Utility 实例 + /// Initialize server-side Utility instance + /// /// + /// + /// 从站地址 / Slave Address + /// + /// 服务器端的设备地址 + /// Device address of server + /// + /// Modbus 范围 / Modbus Range: 1-247 + /// + /// + /// + /// + /// 主站地址 / Master Address + /// + /// 通常为 0 或 1 + /// Usually 0 or 1 + /// + /// protected BaseUtilityServer(byte slaveAddress, byte masterAddress) { SlaveAddress = slaveAddress; @@ -28,93 +137,332 @@ namespace Modbus.Net } /// - /// 连接字符串 + /// 连接字符串 / Connection String + /// + /// 服务器监听地址 + /// Server listening address + /// + /// 格式示例 / Format Examples: + /// + /// TCP: "192.168.1.100:502" + /// 串口："COM1,9600,None,8,1" + /// + /// + /// /// protected string ConnectionString { get; set; } /// - /// 从站号 + /// 从站地址 / Slave Address + /// + /// 本设备在 Modbus 网络中的地址 + /// Address of this device in Modbus network + /// + /// 有效范围 / Valid Range: 1-247 + /// + /// 1-247: 有效从站地址 / Valid slave addresses + /// 0: 广播地址 (仅写入) / Broadcast address (write only) + /// 248-255: 保留 / Reserved + /// + /// + /// /// public byte SlaveAddress { get; set; } /// - /// 主站号 + /// 主站地址 / Master Address + /// + /// 主站设备的地址 + /// Address of master device + /// + /// 通常为 0 或 1 + /// Usually 0 or 1 + /// + /// /// public byte MasterAddress { get; set; } /// - /// 获取数据 + /// 服务器端获取数据 / Server-Side Get Data + /// + /// 响应客户端的读取请求 + /// Respond to client's read request + /// + /// 实现要求 / Implementation Requirements: + /// + /// 从内部寄存器读取数据 / Read data from internal registers + /// 返回原始字节数组 / Return raw byte array + /// 处理地址翻译 / Handle address translation + /// 处理数据类型转换 / Handle data type conversion + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // Modbus 读保持寄存器请求 / Modbus Read Holding Register request + /// // 客户端请求：4X 1, 读取 10 个字节 + /// // Client request: 4X 1, read 10 bytes + /// + /// var result = await server.GetServerDatasAsync("4X 1", 10); + /// + /// // 实现应该： + /// // Implementation should: + /// // 1. 翻译地址 "4X 1" → 内部地址 / Translate address + /// // 2. 从寄存器读取 10 个字节 / Read 10 bytes from registers + /// // 3. 返回字节数组 / Return byte array + /// // 4. 设置 IsSuccess = true / Set IsSuccess = true + /// + /// + /// /// - /// 开始地址 - /// 获取字节数个数 - /// 接收到的byte数据 + /// + /// 开始地址 / Start Address + /// + /// 格式由具体协议定义 + /// Format defined by specific protocol + /// + /// Modbus 示例 / Modbus Examples: + /// + /// "4X 1" - 保持寄存器第 1 个 / Holding Register #1 + /// "0X 10" - 线圈第 10 个 / Coil #10 + /// + /// + /// + /// + /// + /// 获取字节数个数 / Number of Bytes to Get + /// + /// 需要读取的字节总数 + /// Total number of bytes to read + /// + /// 限制 / Limits: + /// + /// Modbus TCP: 最大 250 字节 / Modbus TCP: Max 250 bytes + /// Modbus RTU: 最大 125 字节 / Modbus RTU: Max 125 bytes + /// + /// + /// + /// + /// + /// 接收到的 byte 数据 / Received Byte Data + /// + /// ReturnStruct<byte[]> 包含： + /// ReturnStruct<byte[]> contains: + /// + /// Datas: 读取的字节数组 / Read byte array + /// IsSuccess: 读取是否成功 / Read success flag + /// ErrorCode: 错误码 (0=无错误) / Error code (0=no error) + /// ErrorMsg: 错误消息 / Error message + /// + /// + /// public abstract Task> GetServerDatasAsync(string startAddress, int getByteCount); /// - /// 设置数据 + /// 服务器端设置数据 / Server-Side Set Data + /// + /// 响应客户端的写入请求 + /// Respond to client's write request + /// + /// 实现要求 / Implementation Requirements: + /// + /// 将数据写入内部寄存器 / Write data to internal registers + /// 处理地址翻译 / Handle address translation + /// 处理数据类型转换 / Handle data type conversion + /// 返回写入结果 / Return write result + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // Modbus 写保持寄存器请求 / Modbus Write Holding Register request + /// // 客户端请求：4X 1, 写入 [100, 200, 300] + /// // Client request: 4X 1, write [100, 200, 300] + /// + /// var result = await server.SetServerDatasAsync("4X 1", new object[] { (ushort)100, (ushort)200, (ushort)300 }); + /// + /// // 实现应该： + /// // Implementation should: + /// // 1. 翻译地址 "4X 1" → 内部地址 / Translate address + /// // 2. 将数据写入寄存器 / Write data to registers + /// // 3. 返回写入结果 / Return write result + /// // 4. 设置 IsSuccess = true / Set IsSuccess = true + /// + /// + /// /// - /// 开始地址 - /// 设置数据 - /// 是否设置成功 + /// + /// 开始地址 / Start Address + /// + /// 格式由具体协议定义 + /// Format defined by specific protocol + /// + /// + /// + /// 设置数据 / Set Data + /// + /// 要写入的数据数组 + /// Data array to write + /// + /// 数据类型 / Data Types: + /// + /// ushort - 16 位无符号整数 / 16-bit unsigned integer + /// short - 16 位有符号整数 / 16-bit signed integer + /// byte - 8 位无符号整数 / 8-bit unsigned integer + /// bool - 布尔值 (线圈) / Boolean (coil) + /// + /// + /// + /// + /// + /// 是否设置成功 / Whether Set is Successful + /// + /// ReturnStruct<bool> 包含： + /// ReturnStruct<bool> contains: + /// + /// Datas: true=成功，false=失败 / true=success, false=failure + /// IsSuccess: 操作是否成功 / Operation success flag + /// ErrorCode: 错误码 / Error code + /// ErrorMsg: 错误消息 / Error message + /// + /// + /// public abstract Task> SetServerDatasAsync(string startAddress, object[] setContents); /// - /// 协议是否遵循小端格式 + /// 端格式 / Endianness + /// + /// 指示协议使用的字节序 + /// Indicates byte order used by protocol + /// + /// Modbus 标准 / Modbus Standard: + /// + /// Modbus TCP: BigEndianLsb (大端) / Big Endian + /// Modbus RTU: BigEndianLsb (大端) / Big Endian + /// + /// + /// /// public abstract Endian Endian { get; } /// - /// 设备是否已经连接 + /// 设备是否已经连接 / Whether Device is Connected + /// + /// 检查服务器端连接状态 + /// Check server-side connection status + /// + /// 服务器端连接含义 / Server-Side Connection Meaning: + /// + /// TCP: 监听端口是否打开 / TCP: Whether listening port is open + /// 串口：串口是否可用 / Serial: Whether serial port is available + /// 有客户端连接 / Has client connection + /// + /// + /// /// public bool IsConnected => Wrapper?.ProtocolLinker != null && Wrapper.ProtocolLinker.IsConnected; /// - /// 标识设备的连接关键字 + /// 标识设备的连接关键字 / Connection Keyword Identifying Device + /// + /// 服务器的唯一标识符 + /// Unique identifier for server + /// + /// 格式示例 / Format Examples: + /// + /// TCP: "192.168.1.100:502" + /// 串口："COM1" + /// + /// + /// /// public string ConnectionToken => Wrapper?.ProtocolLinker == null ? ConnectionString : Wrapper.ProtocolLinker.ConnectionToken; /// - /// 地址翻译器 + /// 地址翻译器 / Address Translator + /// + /// 将地址字符串翻译为协议内部格式 + /// Translate address string to protocol-internal format + /// + /// 默认实现 / Default Implementation: + /// + /// AddressTranslatorBase - 基础翻译器 / Base Translator + /// 支持格式："area:address:subAddress" / Supported format + /// + /// + /// /// public AddressTranslator AddressTranslator { get; set; } /// - /// 连接设备 + /// 连接设备 / Connect Device + /// + /// 启动服务器监听 + /// Start server listening + /// + /// 服务器端连接流程 / Server-Side Connection Flow: + /// + /// 创建监听套接字 / Create listening socket + /// 绑定到指定端口 / Bind to specified port + /// 开始监听 / Start listening + /// 等待客户端连接 / Wait for client connection + /// + /// + /// /// - /// 设备是否连接成功 + /// 设备是否连接成功 / Whether Device is Connected Successfully public async Task ConnectAsync() { return await Wrapper.ConnectAsync(); } /// - /// 断开设备 + /// 断开设备 / Disconnect Device + /// + /// 停止服务器监听 + /// Stop server listening + /// + /// 服务器端断开流程 / Server-Side Disconnection Flow: + /// + /// 关闭所有客户端连接 / Close all client connections + /// 停止监听套接字 / Stop listening socket + /// 释放资源 / Release resources + /// + /// + /// /// - /// 设备是否断开成功 + /// 设备是否断开成功 / Whether Device is Disconnected Successfully public bool Disconnect() { return Wrapper.Disconnect(); } /// - /// 返回Utility的方法集合 + /// 获取 Utility 方法集合 / Get Utility Method Collection + /// + /// 返回服务器端的 Utility 方法实现 + /// Return server-side Utility method implementation + /// + /// 使用反射调用 / Use Reflection Invocation: + /// + /// UtilityMethodReflectionCall 提供反射调用 / Provides reflection invocation + /// 支持动态方法调用 / Supports dynamic method invocation + /// + /// + /// /// - /// Utility方法集合类型 - /// Utility方法集合 + /// + /// Utility 方法集合类型 / Utility Method Collection Type + /// + /// 必须实现 IUtilityMethod 接口 + /// Must implement IUtilityMethod interface + /// + /// + /// Utility 方法集合 / Utility Method Collection public TUtilityMethod GetUtilityMethods() where TUtilityMethod : class, IUtilityMethod { - if (this is TUtilityMethod) - { - return this as TUtilityMethod; - } - return null; + return UtilityMethodReflectionCall.Instance; } - - /// - /// 设置连接类型 - /// - /// 连接类型 - public abstract void SetConnectionType(int connectionType); } -} \ No newline at end of file +} diff --git a/Modbus.Net/Modbus.Net/Utility/UtilityMethodReflectionCall.cs b/Modbus.Net/Modbus.Net/Utility/UtilityMethodReflectionCall.cs index 609d818..aa3f209 100644 --- a/Modbus.Net/Modbus.Net/Utility/UtilityMethodReflectionCall.cs +++ b/Modbus.Net/Modbus.Net/Utility/UtilityMethodReflectionCall.cs @@ -1,83 +1,400 @@ -using System; +using System; using System.Threading.Tasks; namespace Modbus.Net { /// - /// 设备的反射调用接口 + /// Utility 方法反射调用扩展类 / Utility Method Reflection Call Extension Class + /// + /// 提供通过反射方式调用 Utility 方法的扩展方法 + /// Provides extension methods for invoking Utility methods via reflection + /// + /// 设计目的 / Design Purpose: + /// + /// 支持动态方法调用 / Support dynamic method invocation + /// 减少重复代码 / Reduce repetitive code + /// 统一的调用接口 / Unified invocation interface + /// 类型安全的反射调用 / Type-safe reflection invocation + /// + /// + /// + /// 命名约定 / Naming Convention: + /// + /// 接口：IUtilityMethodDatas + /// 方法：GetDatasAsync / SetDatasAsync + /// 反射规则：接口名去掉前缀 "IUtilityMethod" 作为方法名后缀 + /// Reflection rule: Remove "IUtilityMethod" prefix from interface name as method name suffix + /// + /// + /// + /// 与 MachineMethodReflectionCall 的区别 / Difference from MachineMethodReflectionCall: + /// + /// MachineMethod: 用于 Machine 层 (高级 API) / For Machine layer (high-level API) + /// UtilityMethod: 用于 Utility 层 (低级 API) / For Utility layer (low-level API) + /// MachineMethod: 返回 Dictionary<string, ReturnUnit<T>> / Returns Dictionary + /// UtilityMethod: 返回 byte[] 或 object[] / Returns byte[] or object[] + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // 获取 Utility 方法接口 / Get Utility method interface + /// var utilityMethod = utility.GetUtilityMethods<IUtilityMethodDatas>(); + /// + /// // 反射方式读取数据 (泛型) / Read data via reflection (generic) + /// var data = await utilityMethod.InvokeGet<IUtilityMethodDatas, ushort[]>( + /// parameters: new object[] { "4X 1", 10 } + /// ); + /// + /// // 反射方式读取数据 (对象数组) / Read data via reflection (object array) + /// var objects = await utilityMethod.InvokeGet<IUtilityMethodDatas, object[]>( + /// parameters: new object[] { + /// "4X 1", + /// new KeyValuePair<Type, int>(typeof(ushort), 10) + /// } + /// ); + /// + /// // 反射方式写入数据 / Write data via reflection + /// await utilityMethod.InvokeSet<IUtilityMethodDatas, object[]>( + /// parameters: new object[] { "4X 1", new object[] { (ushort)100, (ushort)200 } }, + /// datas: 0 // setOriginalCount + /// ); + /// + /// + /// /// public static class UtilityMethodReflectionCall { /// - /// 反射方式调用获取方法 + /// 反射方式调用获取方法 / Invoke Get Method via Reflection + /// + /// 根据泛型类型参数自动推断方法名并调用 + /// Automatically infer method name from generic type parameter and invoke + /// + /// 方法名推断规则 / Method Name Inference Rules: + /// + /// 接口名：IUtilityMethodDatas + /// 去掉前缀 "IUtilityMethod" (14 个字符) / Remove prefix "IUtilityMethod" (14 characters) + /// 添加前缀 "Get" / Add prefix "Get" + /// 添加后缀 "Async" / Add suffix "Async" + /// 结果：GetDatasAsync + /// + /// + /// + /// 类型检查 / Type Checking: + /// + /// 验证接口名是否以 "IUtilityMethod" 开头 / Verify interface name starts with "IUtilityMethod" + /// 不符合规则抛出 NotSupportedException / Throw NotSupportedException if not compliant + /// + /// + /// /// - /// 方法组的类型 - /// 要返回的数据类型 - /// 方法组 - /// 参数 - /// 返回的数据 - public static Task> InvokeGet(this IUtilityMethod utilityMethod, object[] parameters) where TUtilityMethod : IUtilityMethod + /// + /// 方法组的类型 / Method group type + /// + /// 必须实现 IUtilityMethod 接口 + /// Must implement IUtilityMethod interface + /// + /// 常见类型 / Common Types: + /// + /// IUtilityMethodDatas - 数据读写方法 / Data read/write methods + /// IUtilityMethodTime - 带时间戳的数据方法 / Timestamped data methods + /// + /// + /// + /// + /// + /// 要返回的数据类型 / Data type to return + /// + /// 常见类型 / Common Types: + /// + /// byte[] - 原始字节数据 / Raw byte data + /// object[] - 对象数组 / Object array + /// T[] - 泛型数组 (如 ushort[]) / Generic array (e.g., ushort[]) + /// + /// + /// + /// + /// 方法组实例 / Method group instance + /// + /// 从 Utility.GetUtilityMethods 获取 + /// Obtained from Utility.GetUtilityMethods + /// + /// + /// + /// 方法参数 / Method parameters + /// + /// 传递给目标方法的参数数组 + /// Parameter array passed to target method + /// + /// 不同方法的参数 / Parameters for Different Methods: + /// + /// GetDatasAsync(byte[]): [startAddress, getByteCount, getOriginalCount] + /// GetDatasAsync(object[]): [startAddress, getTypeAndCount] + /// GetDatasAsync<T>: [startAddress, getCount] + /// + /// + /// + /// + /// + /// 返回的数据 (包装在 ReturnStruct 中) / Returned data (wrapped in ReturnStruct) + /// + /// ReturnStruct 包含： + /// ReturnStruct contains: + /// + /// Datas: 实际数据 / Actual data + /// IsSuccess: 是否成功 / Success flag + /// ErrorCode: 错误码 / Error code + /// ErrorMsg: 错误消息 / Error message + /// + /// + /// + /// + /// 当接口名不以 "IUtilityMethod" 开头时抛出 + /// Thrown when interface name doesn't start with "IUtilityMethod" + /// + public static Task> InvokeGet(this IUtilityMethod utilityMethod, object[] parameters) + where TUtilityMethod : IUtilityMethod { + // 验证接口命名规则 / Verify interface naming rule if (typeof(TUtilityMethod).Name.Substring(0, 14) != "IUtilityMethod") { throw new NotSupportedException("IUtilityMethod type name not begin with IUtilityMethod"); } + + // 推断方法名 / Infer method name + // IUtilityMethodDatas → GetDatasAsync var functionName = "Get" + typeof(TUtilityMethod).Name.Substring(14) + "Async"; + return InvokeGet(utilityMethod, functionName, parameters); } /// - /// 反射方式调用获取方法 + /// 反射方式调用获取方法 (指定方法名) / Invoke Get Method via Reflection (Specify Method Name) + /// + /// 使用指定的方法名调用获取方法 + /// Invoke get method using specified method name + /// + /// 使用场景 / Use Cases: + /// + /// 自定义方法名 / Custom method names + /// 非标准命名约定 / Non-standard naming conventions + /// 动态方法调用 / Dynamic method invocation + /// + /// + /// /// - /// 要返回的数据类型 - /// 方法组 - /// 方法名 - /// 参数 - /// 返回的数据 + /// + /// 要返回的数据类型 / Data type to return + /// + /// 方法的返回类型 + /// Return type of the method + /// + /// + /// + /// Utility 方法组实例 / Utility method group instance + /// + /// 实现 IUtilityMethod 接口的对象 + /// Object implementing IUtilityMethod interface + /// + /// + /// + /// 方法名 / Method name + /// + /// 要调用的方法名称 + /// Name of method to invoke + /// + /// 示例 / Examples: + /// + /// "GetDatasAsync" + /// "GetValuesAsync" + /// + /// + /// + /// + /// + /// 方法参数 / Method parameters + /// + /// 传递给目标方法的参数数组 + /// Parameter array passed to target method + /// + /// + /// + /// 返回的数据 (包装在 ReturnStruct 中) / Returned data (wrapped in ReturnStruct) + /// public static Task> InvokeGet(this IUtilityMethod utilityMethod, string functionName, object[] parameters) { var utilityMethodType = utilityMethod.GetType(); + + // 获取方法信息 / Get method info var utilityGetMethod = utilityMethodType.GetMethod(functionName); + + // 调用方法 / Invoke method var ans = utilityGetMethod.Invoke(utilityMethod, parameters); + + // 转换为 Task> / Convert to Task> return (Task>)ans; } /// - /// 反射方式调用设置方法 + /// 反射方式调用设置方法 / Invoke Set Method via Reflection + /// + /// 根据泛型类型参数自动推断方法名并调用设置方法 + /// Automatically infer method name from generic type parameter and invoke set method + /// + /// 方法名推断规则 / Method Name Inference Rules: + /// + /// 接口名：IUtilityMethodDatas + /// 去掉前缀 "IUtilityMethod" / Remove prefix "IUtilityMethod" + /// 添加前缀 "Set" / Add prefix "Set" + /// 添加后缀 "Async" / Add suffix "Async" + /// 结果：SetDatasAsync + /// + /// + /// + /// 参数处理 / Parameter Handling: + /// + /// parameters: 原始参数数组 (startAddress, setContents) / Original parameter array + /// datas: setOriginalCount (用于位操作) / setOriginalCount (for bit operations) + /// 合并为新的参数数组 / Merge into new parameter array + /// datas 作为最后一个参数 / datas as last parameter + /// + /// + /// /// - /// 方法组的类型 - /// 要设置的数据类型 - /// 方法组 - /// 参数 - /// 要设置的数据 - /// 设置是否成功 - public static Task> InvokeSet(this IUtilityMethod utilityMethod, object[] parameters, T datas) where TUtilityMethod : IUtilityMethod + /// + /// 方法组的类型 / Method group type + /// 必须实现 IUtilityMethod / Must implement IUtilityMethod + /// + /// + /// 要设置的数据类型 / Data type to set + /// + /// 通常是 int (setOriginalCount) + /// Usually int (setOriginalCount) + /// + /// + /// + /// 方法组实例 / Method group instance + /// 从 Utility.GetUtilityMethods 获取 / Obtained from Utility.GetUtilityMethods + /// + /// + /// 方法参数 / Method parameters + /// + /// 传递给目标方法的参数数组 (不包含 datas) + /// Parameter array passed to target method (excluding datas) + /// + /// 示例 / Example: + /// + /// [startAddress, setContents] + /// + /// + /// + /// + /// + /// 要设置的数据 / Data to set + /// + /// 通常是 setOriginalCount，用于位操作 + /// Usually setOriginalCount, used for bit operations + /// + /// + /// + /// 设置结果 (包装在 ReturnStruct 中) / Set result (wrapped in ReturnStruct) + /// + /// ReturnStruct<bool>: + /// + /// Datas: true=成功，false=失败 / true=success, false=failure + /// IsSuccess: 操作是否成功 / Operation success flag + /// ErrorCode: 错误码 / Error code + /// ErrorMsg: 错误消息 / Error message + /// + /// + /// + /// + /// 当接口名不以 "IUtilityMethod" 开头时抛出 + /// Thrown when interface name doesn't start with "IUtilityMethod" + /// + public static Task> InvokeSet(this IUtilityMethod utilityMethod, object[] parameters, T datas) + where TUtilityMethod : IUtilityMethod { + // 验证接口命名规则 / Verify interface naming rule if (typeof(TUtilityMethod).Name.Substring(0, 14) != "IUtilityMethod") { throw new NotSupportedException("IUtilityMethod type name not begin with IUtilityMethod"); } + + // 推断方法名 / Infer method name + // IUtilityMethodDatas → SetDatasAsync var functionName = "Set" + typeof(TUtilityMethod).Name.Substring(14) + "Async"; + return InvokeSet(utilityMethod, functionName, parameters, datas); } /// - /// 反射方式调用设置方法 + /// 反射方式调用设置方法 (指定方法名) / Invoke Set Method via Reflection (Specify Method Name) + /// + /// 使用指定的方法名调用设置方法 + /// Invoke set method using specified method name + /// + /// 参数合并 / Parameter Merging: + /// + /// 创建新数组，长度 = parameters.Length + 1 / Create new array, length = parameters.Length + 1 + /// 复制 parameters 到新数组 / Copy parameters to new array + /// 将 datas 放在最后一个位置 / Place datas at last position + /// 调用方法 / Invoke method + /// + /// + /// + /// 使用示例 / Usage Example: + /// + /// // 设置数据 / Set data + /// await utilityMethod.InvokeSet( + /// functionName: "SetDatasAsync", + /// parameters: new object[] { "4X 1", new object[] { (ushort)100 } }, + /// datas: 0 // setOriginalCount (位操作时使用) + /// ); + /// + /// + /// /// - /// 要设置的数据类型 - /// 方法组 - /// 方法名 - /// 参数 - /// 要设置的数据 - /// 设置是否成功 + /// + /// 要设置的数据类型 / Data type to set + /// 方法的最后一个参数类型 / Last parameter type of method + /// + /// + /// Utility 方法组实例 / Utility method group instance + /// 实现 IUtilityMethod 接口的对象 / Object implementing IUtilityMethod interface + /// + /// + /// 方法名 / Method name + /// 要调用的方法名称 / Name of method to invoke + /// + /// + /// 方法参数 / Method parameters + /// 传递给目标方法的参数数组 (不包含 datas) / Parameter array passed to target method (excluding datas) + /// + /// + /// 要设置的数据 / Data to set + /// 通常是 setOriginalCount / Usually setOriginalCount + /// + /// + /// 设置结果 (包装在 ReturnStruct 中) / Set result (wrapped in ReturnStruct) + /// ReturnStruct<bool>: true=成功，false=失败 / true=success, false=failure + /// public static Task> InvokeSet(this IUtilityMethod utilityMethod, string functionName, object[] parameters, T datas) { var utilityMethodType = utilityMethod.GetType(); var utilitySetMethod = utilityMethodType.GetMethod(functionName); + + // 合并参数：parameters + datas + // Merge parameters: parameters + datas object[] allParams = new object[parameters.Length + 1]; Array.Copy(parameters, allParams, parameters.Length); allParams[parameters.Length] = datas; + + // 调用方法 / Invoke method var ans = utilitySetMethod.Invoke(utilityMethod, allParams); + + // 转换为 Task> / Convert to Task> return (Task>)ans; } } diff --git a/Samples/AnyType/Program.cs b/Samples/AnyType/Program.cs index 3155fc3..06c0165 100644 --- a/Samples/AnyType/Program.cs +++ b/Samples/AnyType/Program.cs @@ -1,23 +1,37 @@ +// AnyType - ASP.NET Core Web 应用入口 +// 任何类型的数据都可以处理的 Web 应用示例 + +// 创建 Web 应用构建器 var builder = WebApplication.CreateBuilder(args); -// Add services to the container. +// 添加服务到容器 +// 添加控制器和视图支持 builder.Services.AddControllersWithViews(); +// 构建应用 var app = builder.Build(); -// Configure the HTTP request pipeline. +// 配置 HTTP 请求管道 +// 如果不是开发环境，使用异常处理中间件 if (!app.Environment.IsDevelopment()) { app.UseExceptionHandler("/Home/Error"); } + +// 启用静态文件服务 app.UseStaticFiles(); +// 启用路由 app.UseRouting(); +// 启用授权 app.UseAuthorization(); +// 映射控制器路由 +// 默认路由模式：{controller=Home}/{action=Index}/{id?} app.MapControllerRoute( name: "default", pattern: "{controller=Home}/{action=Index}/{id?}"); +// 运行应用 app.Run(); diff --git a/Samples/CrossLamp/Program.cs b/Samples/CrossLamp/Program.cs index 3155fc3..68de7d9 100644 --- a/Samples/CrossLamp/Program.cs +++ b/Samples/CrossLamp/Program.cs @@ -1,23 +1,37 @@ +// CrossLamp - ASP.NET Core Web 应用入口 +// 交叉灯控制 Web 应用示例 + +// 创建 Web 应用构建器 var builder = WebApplication.CreateBuilder(args); -// Add services to the container. +// 添加服务到容器 +// 添加控制器和视图支持 builder.Services.AddControllersWithViews(); +// 构建应用 var app = builder.Build(); -// Configure the HTTP request pipeline. +// 配置 HTTP 请求管道 +// 如果不是开发环境，使用异常处理中间件 if (!app.Environment.IsDevelopment()) { app.UseExceptionHandler("/Home/Error"); } + +// 启用静态文件服务 app.UseStaticFiles(); +// 启用路由 app.UseRouting(); +// 启用授权 app.UseAuthorization(); +// 映射控制器路由 +// 默认路由模式：{controller=Home}/{action=Index}/{id?} app.MapControllerRoute( name: "default", pattern: "{controller=Home}/{action=Index}/{id?}"); +// 运行应用 app.Run(); diff --git a/Samples/MachineJob.CodeGenerator/DatabaseWriteEntityCodeGenerator.cs b/Samples/MachineJob.CodeGenerator/DatabaseWriteEntityCodeGenerator.cs index 883dcfd..8913a9f 100644 --- a/Samples/MachineJob.CodeGenerator/DatabaseWriteEntityCodeGenerator.cs +++ b/Samples/MachineJob.CodeGenerator/DatabaseWriteEntityCodeGenerator.cs @@ -1,18 +1,29 @@ -using Microsoft.CodeAnalysis; +using Microsoft.CodeAnalysis; namespace Modbus.Net.CodeGenerator { + /// + /// 数据库写入实体代码生成器 + /// 使用 Roslyn 源生成器自动生成 DatabaseWriteEntity 类的属性 + /// [Generator] public class DatabaseWriteEntityCodeGenerator : ISourceGenerator { + /// + /// 执行代码生成 + /// 生成 10 个 Value1 到 Value10 的双精度属性 + /// public void Execute(GeneratorExecutionContext context) { var content = ""; + // 生成 10 个属性：Value1 到 Value10 for (int i = 1; i <= 10; i++) { content += $@"public double? Value{i} {{ get; set; }} "; } + + // 生成完整的类代码 var source = $@" namespace MachineJob @@ -22,12 +33,15 @@ namespace MachineJob {content} }} }}"; + // 添加生成的源代码到编译 context.AddSource("DatabaseWriteContent.g.cs", source); } + /// + /// 初始化生成器 + /// public void Initialize(GeneratorInitializationContext context) { - } } } diff --git a/Samples/MachineJob/ConsoleLogProvider.cs b/Samples/MachineJob/ConsoleLogProvider.cs index c9f4d7f..9d6514b 100644 --- a/Samples/MachineJob/ConsoleLogProvider.cs +++ b/Samples/MachineJob/ConsoleLogProvider.cs @@ -1,33 +1,53 @@ -using Quartz.Logging; +using Quartz.Logging; namespace MachineJob { - // simple log provider to get something to the console + /// + /// 控制台日志提供者 + /// 为 Quartz 调度器提供简单的控制台日志输出 + /// public class ConsoleLogProvider : ILogProvider { + // 配置根对象 private readonly IConfigurationRoot configuration = new ConfigurationBuilder() + // 设置配置文件的基础路径 .SetBasePath(Directory.GetCurrentDirectory()) + // 添加 appsettings.json 配置文件 .AddJsonFile("appsettings.json") + // 根据环境变量添加对应的配置文件 .AddJsonFile($"appsettings.{Environment.GetEnvironmentVariable("DOTNET_ENVIRONMENT") ?? "Production"}.json", true) .Build(); + /// + /// 获取日志记录器 + /// + /// 日志记录器名称 + /// 日志记录器委托 public Logger GetLogger(string name) { return (level, func, exception, parameters) => { + // 如果日志级别大于等于配置的级别且有消息函数 if (level >= configuration.GetSection("Quartz").GetValue("LogLevel") && func != null) { + // 输出到控制台，格式：[时间] [级别] 消息 Console.WriteLine("[" + DateTime.Now.ToLongTimeString() + "] [" + level + "] " + func(), parameters); } return true; }; } + /// + /// 打开嵌套上下文（未实现） + /// public IDisposable OpenNestedContext(string message) { throw new NotImplementedException(); } + /// + /// 打开映射上下文（未实现） + /// public IDisposable OpenMappedContext(string key, object value, bool destructure = false) { throw new NotImplementedException(); diff --git a/Samples/MachineJob/DatabaseWrite.cs b/Samples/MachineJob/DatabaseWrite.cs index 2faebfe..1de344b 100644 --- a/Samples/MachineJob/DatabaseWrite.cs +++ b/Samples/MachineJob/DatabaseWrite.cs @@ -1,34 +1,68 @@ -using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore; using System.ComponentModel.DataAnnotations; using System.ComponentModel.DataAnnotations.Schema; namespace MachineJob { + /// + /// 数据库写入上下文 + /// 用于 Entity Framework Core 访问 MySQL 数据库 + /// public class DatabaseWriteContext : DbContext { + // 配置根对象 private static readonly IConfigurationRoot configuration = new ConfigurationBuilder() + // 设置配置文件的基础路径 .SetBasePath(Directory.GetCurrentDirectory()) + // 添加 appsettings.default.json 配置文件（必需） .AddJsonFile("appsettings.default.json", optional: false, reloadOnChange: true) + // 添加 appsettings.json 配置文件（必需） .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true) + // 根据环境变量添加对应的配置文件（可选） .AddJsonFile($"appsettings.{Environment.GetEnvironmentVariable("DOTNET_ENVIRONMENT") ?? Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") ?? "Production"}.json", optional: true, reloadOnChange: true) .Build(); + // 从配置读取数据库连接字符串 private static readonly string connectionString = configuration.GetConnectionString("DatabaseWriteConnectionString")!; + /// + /// 数据库写入实体集合 + /// public DbSet? DatabaseWrites { get; set; } + /// + /// 配置数据库上下文 + /// 使用 MySQL 数据库 + /// protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) { + // 使用 MySQL，自动检测服务器版本 optionsBuilder.UseMySql(connectionString, ServerVersion.AutoDetect(connectionString)); } } + /// + /// 数据库写入实体类 + /// 映射到 databasewrites 表 + /// [Table(name: "databasewrites")] public partial class DatabaseWriteEntity { + /// + /// 主键 ID + /// [Key] public int Id { get; set; } + /// + /// 更新时间 + /// public DateTime UpdateTime { get; set; } + + // 注意：Value1 到 Value10 属性由 DatabaseWriteEntityCodeGenerator 代码生成器自动生成 + // public double? Value1 { get; set; } + // public double? Value2 { get; set; } + // ... + // public double? Value10 { get; set; } } } diff --git a/Samples/MachineJob/Program.cs b/Samples/MachineJob/Program.cs index 059cccd..8253dd2 100644 --- a/Samples/MachineJob/Program.cs +++ b/Samples/MachineJob/Program.cs @@ -2,38 +2,59 @@ using MachineJob; using MachineJob.Service; using Serilog; +// MachineJob - 多设备定时任务调度示例 +// 作为 Windows 服务运行 + +// 配置主机服务 IHost host = Host.CreateDefaultBuilder(args).UseWindowsService() + // 配置应用程序配置 .ConfigureAppConfiguration((hostingContext, config) => { + // 构建配置 var configuration = config + // 设置配置文件的基础路径 .SetBasePath(hostingContext.HostingEnvironment.ContentRootPath) + // 添加 appsettings.json 配置文件 .AddJsonFile("appsettings.json") + // 根据环境变量添加对应的配置文件 .AddJsonFile($"appsettings.{Environment.GetEnvironmentVariable("DOTNET_ENVIRONMENT") ?? "Production"}.json", true) + // 添加环境变量配置 .AddEnvironmentVariables() .Build(); + // 设置当前工作目录 Directory.SetCurrentDirectory(hostingContext.HostingEnvironment.ContentRootPath); + // 配置 Serilog 日志 Log.Logger = new LoggerConfiguration() + // 从配置读取日志设置 .ReadFrom.Configuration(configuration) + // 从日志上下文丰富日志信息 .Enrich.FromLogContext() + // 输出到控制台 .WriteTo.Console() + // 输出到文件（错误级别，按天滚动） .WriteTo.File("Log\\log..txt", Serilog.Events.LogEventLevel.Error, shared: true, rollingInterval: RollingInterval.Day) .CreateLogger(); + // 创建日志工厂并添加 Serilog var loggerFactory = new LoggerFactory().AddSerilog(Log.Logger); + // 设置 Quartz 日志提供者 Quartz.Logging.LogProvider.SetCurrentLogProvider(new ConsoleLogProvider()); + // 设置 Modbus.Net 日志提供者 Modbus.Net.LogProvider.SetLogProvider(loggerFactory); - } - ) + }) + // 配置服务 .ConfigureServices(services => { + // 添加后台服务 Worker services.AddHostedService(); + // 添加日志服务 services.AddLogging(loggingBuilder => loggingBuilder.AddSerilog(Log.Logger, true)); }) .Build(); +// 运行主机 await host.RunAsync(); - diff --git a/Samples/MachineJob/Worker.cs b/Samples/MachineJob/Worker.cs index 1b6cb03..31f313b 100644 --- a/Samples/MachineJob/Worker.cs +++ b/Samples/MachineJob/Worker.cs @@ -4,6 +4,10 @@ using MultipleMachinesJobScheduler = Modbus.Net.MultipleMachinesJobScheduler + /// MachineJob 后台工作服务 + /// 使用 Quartz 调度器定期从多个设备读取数据并写入 + /// public class Worker : BackgroundService { private readonly ILogger _logger; @@ -15,44 +19,32 @@ namespace MachineJob.Service protected override Task ExecuteAsync(CancellationToken stoppingToken) { - //1. ֱCoding + // 1. 编码方式（已注释） + // 手动配置地址单元列表 //List _addresses = new List //{ // new AddressUnit() { Area = "4X", Address = 1, DataType = typeof(short), Id = "1", Name = "Test1" }, - // new AddressUnit() { Area = "4X", Address = 2, DataType = typeof(short), Id = "2", Name = "Test2" }, - // new AddressUnit() { Area = "4X", Address = 3, DataType = typeof(short), Id = "3", Name = "Test3" }, - // new AddressUnit() { Area = "4X", Address = 4, DataType = typeof(short), Id = "4", Name = "Test4" }, - // new AddressUnit() { Area = "4X", Address = 5, DataType = typeof(short), Id = "5", Name = "Test5" }, - // new AddressUnit() { Area = "4X", Address = 6, DataType = typeof(short), Id = "6", Name = "Test6" }, - // new AddressUnit() { Area = "4X", Address = 7, DataType = typeof(short), Id = "7", Name = "Test7" }, - // new AddressUnit() { Area = "4X", Address = 8, DataType = typeof(short), Id = "8", Name = "Test8" }, - // new AddressUnit() { Area = "4X", Address = 9, DataType = typeof(short), Id = "9", Name = "Test9" }, - // new AddressUnit() { Area = "4X", Address = 10, DataType = typeof(short), Id = "10", Name = "Test10" } + // ... //}; //List _addresses2 = new List //{ // new AddressUnit() { Area = "DB1", Address = 0, DataType = typeof(short), Id = "1", Name = "Test1" }, - // new AddressUnit() { Area = "DB1", Address = 2, DataType = typeof(short), Id = "2", Name = "Test2" }, - // new AddressUnit() { Area = "DB1", Address = 4, DataType = typeof(short), Id = "3", Name = "Test3" }, - // new AddressUnit() { Area = "DB1", Address = 6, DataType = typeof(short), Id = "4", Name = "Test4" }, - // new AddressUnit() { Area = "DB1", Address = 8, DataType = typeof(short), Id = "5", Name = "Test5" }, - // new AddressUnit() { Area = "DB1", Address = 10, DataType = typeof(short), Id = "6", Name = "Test6" }, - // new AddressUnit() { Area = "DB1", Address = 12, DataType = typeof(short), Id = "7", Name = "Test7" }, - // new AddressUnit() { Area = "DB1", Address = 14, DataType = typeof(short), Id = "8", Name = "Test8" }, - // new AddressUnit() { Area = "DB1", Address = 16, DataType = typeof(short), Id = "9", Name = "Test9" }, - // new AddressUnit() { Area = "DB1", Address = 18, DataType = typeof(short), Id = "10", Name = "Test10" } + // ... //}; + // 创建 Modbus 和 Siemens 机器实例 //IMachine machine = new ModbusMachine("ModbusMachine1", ModbusType.Tcp, null, _addresses, true, 1, 2, Endian.BigEndianLsb); //IMachine machine2 = new SiemensMachine("SiemensMachine1", SiemensType.Tcp, null, SiemensMachineModel.S7_1200, _addresses2, true, 1, 2); //var machines = new List> { machine, machine2 }; - //2. Ӳȡ + // 2. 从配置文件读取机器配置 + // 使用 MachineReader 从 appsettings.json 读取机器配置 var machines = MachineReader.ReadMachines(); - //3.ʹMachineJobScheduler + // 3. 使用 MachineJobScheduler（已注释） + // 为每个机器创建独立的调度器 //foreach (var machine in machines) //{ // var scheduler = await MachineJobSchedulerCreator.CreateScheduler(machine.Id, -1, 10); @@ -60,47 +52,71 @@ namespace MachineJob.Service // await job.Run(); //} - //4. ʹMultipleMachinesJobScheduler + // 4. 使用 MultipleMachinesJobScheduler（已注释） + // 使用多机器调度器，带时间间隔 //return Task.Run(() => MultipleMachinesJobScheduler.RunScheduler(machines, async (machine, scheduler) => //{ - // /await scheduler.From(machine.Id + ".From", machine, MachineDataType.Name).Result.Query(machine.Id + ".ConsoleQuery", QueryConsole).Result.To(machine.Id + ".To", machine).Result.Deal(machine.Id + ".Deal", OnSuccess, OnFailure).Result.Run(); + // await scheduler.From(machine.Id + ".From", machine, MachineDataType.Name).Result.Query(machine.Id + ".ConsoleQuery", QueryConsole).Result.To(machine.Id + ".To", machine).Result.Deal(machine.Id + ".Deal", OnSuccess, OnFailure).Result.Run(); //}, -1, 10)); - //5. ù̶ʱ䣬Job + // 5. 使用固定时间，立即调度 Job + // 当前使用的方式：立即执行，无时间间隔 return Task.Run(() => MultipleMachinesJobScheduler.RunScheduler(machines, async (machine, scheduler) => { + // 配置作业链：From -> Query -> To -> Deal + // From: 从机器读取数据 + // Query: 查询处理（QueryConsole） + // To: 写入数据到机器 + // Deal: 处理结果（OnSuccess/OnFailure） await scheduler.From(machine.Id + ".From", machine, MachineDataType.Name).Result.Query(machine.Id + ".ConsoleQuery", QueryConsole).Result.To(machine.Id + ".To", machine).Result.Deal(machine.Id + ".Deal", OnSuccess, OnFailure).Result.Run(); }, -1, 0)); } public override Task StopAsync(CancellationToken cancellationToken) { + // 停止所有作业调度 return Task.Run(() => MultipleMachinesJobScheduler.CancelJob()); } + /// + /// 成功回调 + /// 记录机器设置成功的日志 + /// public Task OnSuccess(string machineId) { _logger.LogInformation("Machine {0} set success", machineId); return Task.CompletedTask; } + /// + /// 失败回调 + /// 记录机器设置失败的日志 + /// public Task OnFailure(string machineId, int errorCode, string errorMsg) { _logger.LogError("Machine {0} set failure: {1}", machineId, errorMsg); return Task.CompletedTask; } + /// + /// 查询处理函数 + /// 处理从设备读取的数据，可以写入数据库或生成随机数据 + /// private Dictionary? QueryConsole(DataReturnDef dataReturnDef) { var values = dataReturnDef.ReturnValues.Datas; + + // 如果读取成功 if (dataReturnDef.ReturnValues.IsSuccess == true) { + // 记录日志 foreach (var value in values) { _logger.LogDebug(dataReturnDef.MachineId + " " + value.Key + " " + value.Value.DeviceValue); } /* + // 写入数据库（已注释） try { using (var context = new DatabaseWriteContext()) @@ -124,19 +140,24 @@ namespace MachineJob.Service } catch { - //ignore + // 忽略异常 } */ + + // 生成随机数据用于写入 Random r = new Random(); foreach (var value in values) { value.Value.DeviceValue = r.Next(65536) - 32768; } + // 将读取的值转换为写入格式 return values.MapGetValuesToSetValues(); } + // 如果读取结果为 null（未知状态） else if (dataReturnDef.ReturnValues.IsSuccess == null) { + // 生成随机数据 Random r = new Random(); Dictionary ans = new Dictionary(); @@ -148,12 +169,3 @@ namespace MachineJob.Service return ans; } - else - { - _logger.LogError(dataReturnDef.MachineId + " Return Error."); - return null; - } - - } - } -} \ No newline at end of file diff --git a/Samples/ModbusTcpToRtu/Program.cs b/Samples/ModbusTcpToRtu/Program.cs index 9861b2a..4cedd52 100644 --- a/Samples/ModbusTcpToRtu/Program.cs +++ b/Samples/ModbusTcpToRtu/Program.cs @@ -1,38 +1,56 @@ using ModbusTcpToRtu; using Serilog; +// 配置主机服务，作为 Windows 服务运行 IHost host = Host.CreateDefaultBuilder(args).UseWindowsService() + // 配置应用程序配置 .ConfigureAppConfiguration((hostingContext, config) => { + // 构建配置 var configuration = config + // 设置配置文件的基础路径 .SetBasePath(hostingContext.HostingEnvironment.ContentRootPath) + // 添加 appsettings.json 配置文件 .AddJsonFile("appsettings.json") + // 根据环境变量添加对应的配置文件（开发/生产等） .AddJsonFile($"appsettings.{Environment.GetEnvironmentVariable("DOTNET_ENVIRONMENT") ?? "Production"}.json", true) + // 添加环境变量配置 .AddEnvironmentVariables() .Build(); + // 设置当前工作目录 Directory.SetCurrentDirectory(hostingContext.HostingEnvironment.ContentRootPath); + // 配置 Serilog 日志 Log.Logger = new LoggerConfiguration() + // 从配置读取日志设置 .ReadFrom.Configuration(configuration) + // 从日志上下文丰富日志信息 .Enrich.FromLogContext() + // 输出到控制台 .WriteTo.Console() + // 输出到文件（错误级别，按天滚动） .WriteTo.File("Log\\log..txt", Serilog.Events.LogEventLevel.Error, shared: true, rollingInterval: RollingInterval.Day) .CreateLogger(); + // 创建日志工厂并添加 Serilog var loggerFactory = new LoggerFactory().AddSerilog(Log.Logger); + // 设置 Quartz 日志提供者 Quartz.Logging.LogProvider.SetCurrentLogProvider(new ConsoleLogProvider()); + // 设置 Modbus.Net 日志提供者 Modbus.Net.LogProvider.SetLogProvider(loggerFactory); - } - ) + }) + // 配置服务 .ConfigureServices(services => { + // 添加后台服务 Worker services.AddHostedService(); + // 添加日志服务 services.AddLogging(loggingBuilder => loggingBuilder.AddSerilog(Log.Logger, true)); }) .Build(); +// 运行主机 await host.RunAsync(); - diff --git a/Samples/ModbusTcpToRtu/Worker.cs b/Samples/ModbusTcpToRtu/Worker.cs index 3fae355..2117e59 100644 --- a/Samples/ModbusTcpToRtu/Worker.cs +++ b/Samples/ModbusTcpToRtu/Worker.cs @@ -8,12 +8,18 @@ using MultipleMachinesJobScheduler = Modbus.Net.MultipleMachinesJobScheduler + /// Modbus TCP 转 RTU 后台工作服务 + /// 定期从 Modbus TCP 设备读取数据并写入到 Modbus RTU 设备 + /// public class Worker : BackgroundService { private readonly ILogger _logger; + // Modbus 读取工具（TCP） private BaseUtility readUtility; + // Modbus 写入工具（RTU） private BaseUtility writeUtility; public Worker(ILogger logger) @@ -23,92 +29,120 @@ namespace ModbusTcpToRtu protected override async Task ExecuteAsync(CancellationToken stoppingToken) { + // 配置 Quartz 调度器的触发器和作业键 var triggerKey = "Modbus.Net.Job.Utility.SchedulerTrigger"; var jobKey = "Modbus.Net.Job.Utility.JobKey"; + // 从配置读取调度间隔（秒转毫秒） var intervalMilliSecond = int.Parse(ConfigurationReader.GetValue("Utility", "interval")) * 1000; + // 读取重复次数（-1 表示无限重复） var count = int.Parse(ConfigurationReader.GetValue("Utility", "count")); + // 读取读写配置组 var readWriteGroup = ConfigurationReader.GetContent>("Utility", "readwrite"); + // 读取 Modbus TCP 配置 var readType = Enum.Parse(ConfigurationReader.GetValue("Utility:read", "type")); var readAddress = ConfigurationReader.GetValue("Utility:read", "address"); var readSlaveAddress = byte.Parse(ConfigurationReader.GetValue("Utility:read", "slaveAddress")); var readMasterAddress = byte.Parse(ConfigurationReader.GetValue("Utility:read", "masterAddress")); + + // 读取 Modbus RTU 配置 var writeType = Enum.Parse(ConfigurationReader.GetValue("Utility:write", "type")); var writeAddress = ConfigurationReader.GetValue("Utility:write", "address"); var writeSlaveAddress = byte.Parse(ConfigurationReader.GetValue("Utility:write", "slaveAddress")); var writeMasterAddress = byte.Parse(ConfigurationReader.GetValue("Utility:write", "masterAddress")); + // 创建 Modbus 工具实例 readUtility = new ModbusUtility(readType, readAddress, readSlaveAddress, readMasterAddress, Endian.BigEndianLsb); writeUtility = new ModbusUtility(writeType, writeAddress, writeSlaveAddress, writeMasterAddress, Endian.BigEndianLsb); + // 获取 Quartz 调度器 IScheduler scheduler = await StdSchedulerFactory.GetDefaultScheduler(); + // 启动调度器 await scheduler.Start(); + // 创建触发器 ITrigger trigger; if (intervalMilliSecond <= 0) { + // 间隔<=0，立即执行一次 trigger = TriggerBuilder.Create() .WithIdentity(triggerKey, "Modbus.Net.DataQuery.Group." + triggerKey) .StartNow() .Build(); } else if (count >= 0) + // 指定重复次数 trigger = TriggerBuilder.Create() .WithIdentity(triggerKey, "Modbus.Net.DataQuery.Group." + triggerKey) .StartNow() .WithSimpleSchedule(b => b.WithInterval(TimeSpan.FromMilliseconds(intervalMilliSecond)).WithRepeatCount(count)) .Build(); else + // 无限重复 trigger = TriggerBuilder.Create() .WithIdentity(triggerKey, "Modbus.Net.DataQuery.Group." + triggerKey) .StartNow() .WithSimpleSchedule(b => b.WithInterval(TimeSpan.FromMilliseconds(intervalMilliSecond)).RepeatForever()) .Build(); + // 创建作业监听器 IJobListener listener; if (intervalMilliSecond <= 0) { + // 重复指定次数的监听器 listener = new JobChainingJobLIstenerWithDataMapRepeated("Modbus.Net.DataQuery.Chain." + triggerKey, new string[2] { "Value", "SetValue" }, count); } else { + // 无限重复的监听器 listener = new JobChainingJobListenerWithDataMap("Modbus.Net.DataQuery.Chain." + triggerKey, new string[2] { "Value", "SetValue" }); } + // 添加作业监听器到调度器 scheduler.ListenerManager.AddJobListener(listener, GroupMatcher.GroupEquals("Modbus.Net.DataQuery.Group." + triggerKey)); + // 如果触发器已存在，先删除 if (await scheduler.GetTrigger(new TriggerKey(triggerKey)) != null) { await scheduler.UnscheduleJob(new TriggerKey(triggerKey, "Modbus.Net.DataQuery.Group." + triggerKey)); } + // 删除已存在的作业 var jobKeys = await scheduler.GetJobKeys(GroupMatcher.GroupEquals("Modbus.Net.DataQuery.Group." + triggerKey)); await scheduler.DeleteJobs(jobKeys); + // 创建数据传递作业 var job = JobBuilder.Create() .WithIdentity(jobKey) .StoreDurably(true) .Build(); + // 将工具实例放入作业数据映射 job.JobDataMap.Put("UtilityRead", readUtility); job.JobDataMap.Put("UtilityReadWriteGroup", readWriteGroup); job.JobDataMap.Put("UtilityWrite", writeUtility); + // 调度作业 await scheduler.ScheduleJob(job, trigger); - } public override Task StopAsync(CancellationToken cancellationToken) { + // 停止所有作业调度 return Task.Run(() => MultipleMachinesJobScheduler.CancelJob()); } } + /// + /// Modbus 数据传递作业 + /// 从读取工具读取数据并写入到写入工具 + /// public class UtilityPassDataJob : IJob { public async Task Execute(IJobExecutionContext context) { + // 从作业数据映射获取工具实例 object utilityReadObject; object utilityWriteObject; object utilityReadWriteGroupObject; @@ -121,15 +155,22 @@ namespace ModbusTcpToRtu var writeUtility = (BaseUtility)utilityWriteObject; var utilityReadWriteGroup = (List)utilityReadWriteGroupObject; + // 连接读取工具 if (readUtility.IsConnected != true) await readUtility.ConnectAsync(); + // 连接写入工具 if (writeUtility.IsConnected != true) await writeUtility.ConnectAsync(); + + // 遍历每个读写组 foreach (var rwGroup in utilityReadWriteGroup) { + // 从 Modbus TCP 读取数据 + // 地址格式："4X 1" = 区域 + 地址 var datas = await readUtility.GetDatasAsync(rwGroup.ReadStart / 10000 + "X " + rwGroup.ReadStart % 10000, rwGroup.ReadCount * 2, rwGroup.ReadCount); if (datas.IsSuccess == true) { + // 将字节数组转换为对象数组并写入 Modbus RTU var ans = await writeUtility.SetDatasAsync(rwGroup.WriteStart / 10000 + "X " + rwGroup.WriteStart % 10000, ByteArrayToObjectArray(datas.Datas), rwGroup.ReadCount); if (ans.Datas) { @@ -143,6 +184,10 @@ namespace ModbusTcpToRtu } } + /// + /// 字节数组转对象数组 + /// 将每个字节转换为独立的对象 + /// public static object[] ByteArrayToObjectArray(byte[] arrBytes) { List objArray = new List(); @@ -154,10 +199,27 @@ namespace ModbusTcpToRtu } } + /// + /// 读写配置组 + /// 定义从哪个地址读取多少个数据，写入到哪个地址 + /// public class ReadWriteGroup { + /// + /// 读取起始地址 + /// 格式：区域*10000 + 地址，如 40001 表示 4X 区地址 1 + /// public int ReadStart { get; set; } + + /// + /// 读取数量 + /// public int ReadCount { get; set; } + + /// + /// 写入起始地址 + /// 格式：区域*10000 + 地址 + /// public int WriteStart { get; set; } } -} \ No newline at end of file +} diff --git a/Samples/SampleModbusRtuServer/Program.cs b/Samples/SampleModbusRtuServer/Program.cs index b698c95..22f196c 100644 --- a/Samples/SampleModbusRtuServer/Program.cs +++ b/Samples/SampleModbusRtuServer/Program.cs @@ -2,38 +2,56 @@ using SampleModbusRtuServer; using SampleModbusRtuServer.Service; using Serilog; +// 配置主机服务，作为 Windows 服务运行 IHost host = Host.CreateDefaultBuilder(args).UseWindowsService() + // 配置应用程序配置 .ConfigureAppConfiguration((hostingContext, config) => { + // 构建配置 var configuration = config + // 设置配置文件的基础路径 .SetBasePath(hostingContext.HostingEnvironment.ContentRootPath) + // 添加 appsettings.json 配置文件 .AddJsonFile("appsettings.json") + // 根据环境变量添加对应的配置文件（开发/生产等） .AddJsonFile($"appsettings.{Environment.GetEnvironmentVariable("DOTNET_ENVIRONMENT") ?? "Production"}.json", true) + // 添加环境变量配置 .AddEnvironmentVariables() .Build(); + // 设置当前工作目录 Directory.SetCurrentDirectory(hostingContext.HostingEnvironment.ContentRootPath); + // 配置 Serilog 日志 Log.Logger = new LoggerConfiguration() + // 从配置读取日志设置 .ReadFrom.Configuration(configuration) + // 从日志上下文丰富日志信息 .Enrich.FromLogContext() + // 输出到控制台 .WriteTo.Console() + // 输出到文件（错误级别，按天滚动） .WriteTo.File("Log\\log..txt", Serilog.Events.LogEventLevel.Error, shared: true, rollingInterval: RollingInterval.Day) .CreateLogger(); + // 创建日志工厂并添加 Serilog var loggerFactory = new LoggerFactory().AddSerilog(Log.Logger); + // 设置 Quartz 日志提供者 Quartz.Logging.LogProvider.SetCurrentLogProvider(new ConsoleLogProvider()); + // 设置 Modbus.Net 日志提供者 Modbus.Net.LogProvider.SetLogProvider(loggerFactory); - } - ) + }) + // 配置服务 .ConfigureServices(services => { + // 添加后台服务 Worker services.AddHostedService(); + // 添加日志服务 services.AddLogging(loggingBuilder => loggingBuilder.AddSerilog(Log.Logger, true)); }) .Build(); +// 运行主机 await host.RunAsync(); - diff --git a/Samples/SampleModbusRtuServer/Worker.cs b/Samples/SampleModbusRtuServer/Worker.cs index 40224c0..34c32a6 100644 --- a/Samples/SampleModbusRtuServer/Worker.cs +++ b/Samples/SampleModbusRtuServer/Worker.cs @@ -4,15 +4,24 @@ using MultipleMachinesJobScheduler = Modbus.Net.MultipleMachinesJobScheduler + /// Modbus RTU 服务器后台工作服务 + /// 监听串口，响应 Modbus RTU 读写请求 + /// public class Worker : BackgroundService { private readonly ILogger _logger; + // 线圈数据数组（0X 区，10000 点） private bool[] zerox = new bool[10000]; + + // 保持寄存器数据数组（4X 区，20000 字节=10000 个寄存器） private byte[] threex = new byte[20000]; + // 数据更新标志 private bool _isUpdate = false; + // 最后更新时间 private DateTime _updateTime = DateTime.MinValue; public Worker(ILogger logger) @@ -22,18 +31,28 @@ namespace SampleModbusRtuServer.Service protected override async Task ExecuteAsync(CancellationToken stoppingToken) { + // 创建 Modbus RTU 协议接收器，监听 COM2 端口，从站地址 1 ModbusRtuProtocolReceiver receiver = new ModbusRtuProtocolReceiver("COM2", 1); + + // 设置数据处理回调 receiver.DataProcess = receiveContent => { byte[]? returnBytes = null; + // 读取内容缓冲区（每个寄存器 2 字节） var readContent = new byte[receiveContent.Count * 2]; + // 写入内容 var values = receiveContent.WriteContent; + // 值字典（未使用） var valueDic = new Dictionary(); + // Redis 值字典（未使用） var redisValues = new Dictionary>(); + + // 处理写操作 if (values != null) { try { + // 如果处于更新模式且距离上次更新超过 9.5 秒，记录日志 if (_isUpdate && DateTime.Now - _updateTime > TimeSpan.FromSeconds(9.5)) { _logger.LogDebug($"receive content { String.Concat(receiveContent.WriteContent.Select(p => " " + p.ToString("X2")))}"); @@ -43,17 +62,24 @@ namespace SampleModbusRtuServer.Service { _logger.LogError(ex, "Error"); } + + // 根据功能码处理不同的写操作 switch (receiveContent.FunctionCode) { case (byte)ModbusProtocolFunctionCode.WriteMultiRegister: { + // 写多个寄存器（功能码 16） + // 将写入的数据复制到保持寄存器数组 Array.Copy(receiveContent.WriteContent, 0, threex, receiveContent.StartAddress * 2, receiveContent.WriteContent.Length); + // 生成响应帧 returnBytes = new WriteDataModbusProtocol().Format(receiveContent.SlaveAddress, receiveContent.FunctionCode, receiveContent.StartAddress, receiveContent.Count); _isUpdate = true; break; } case (byte)ModbusProtocolFunctionCode.WriteSingleCoil: { + // 写单个线圈（功能码 5） + // 255=ON, 0=OFF if (receiveContent.WriteContent[0] == 255) { zerox[receiveContent.StartAddress] = true; @@ -62,80 +88,100 @@ namespace SampleModbusRtuServer.Service { zerox[receiveContent.StartAddress] = false; } + // 生成响应帧 returnBytes = new WriteDataModbusProtocol().Format(receiveContent.SlaveAddress, receiveContent.FunctionCode, receiveContent.StartAddress, receiveContent.WriteContent); _isUpdate = true; break; } case (byte)ModbusProtocolFunctionCode.WriteMultiCoil: { + // 写多个线圈（功能码 15） var pos = 0; List bitList = new List(); + // 将字节数组转换为位列表 for (int i = 0; i < receiveContent.WriteByteCount; i++) { var bitArray = BigEndianLsbValueHelper.Instance.GetBits(receiveContent.WriteContent, ref pos); bitList.AddRange(bitArray.ToList()); } + // 将位列表复制到线圈数组 Array.Copy(bitList.ToArray(), 0, zerox, receiveContent.StartAddress, bitList.Count); + // 生成响应帧 returnBytes = new WriteDataModbusProtocol().Format(receiveContent.SlaveAddress, receiveContent.FunctionCode, receiveContent.StartAddress, receiveContent.Count); _isUpdate = true; break; } case (byte)ModbusProtocolFunctionCode.WriteSingleRegister: { + // 写单个寄存器（功能码 6） + // 将写入的数据复制到保持寄存器数组 Array.Copy(receiveContent.WriteContent, 0, threex, receiveContent.StartAddress * 2, receiveContent.Count * 2); + // 生成响应帧 returnBytes = new WriteDataModbusProtocol().Format(receiveContent.SlaveAddress, receiveContent.FunctionCode, receiveContent.StartAddress, receiveContent.Count); _isUpdate = true; break; } } } + // 处理读操作 else { switch (receiveContent.FunctionCode) { case (byte)ModbusProtocolFunctionCode.ReadHoldRegister: { + // 读保持寄存器（功能码 3） + // 从保持寄存器数组复制数据到读取缓冲区 Array.Copy(threex, receiveContent.StartAddress, readContent, 0, readContent.Length); + // 生成响应帧 returnBytes = new ReadDataModbusProtocol().Format(receiveContent.SlaveAddress, receiveContent.FunctionCode, (byte)receiveContent.Count, readContent); break; } case (byte)ModbusProtocolFunctionCode.ReadCoilStatus: { + // 读线圈状态（功能码 1） + // 计算需要读取的位数 var bitCount = receiveContent.WriteByteCount * 8; var boolContent = new bool[bitCount]; + // 从线圈数组复制数据 Array.Copy(zerox, receiveContent.StartAddress, boolContent, 0, bitCount); + + // 将位数组打包为字节数组 var byteList = new List(); for (int i = 0; i < receiveContent.WriteByteCount; i++) { byte result = 0; for (int j = i; j < i + 8; j++) { - // ֵתΪӦλ - + // 将布尔值转换为位（1 或 0） byte bit = boolContent[j] ? (byte)1 : (byte)0; - // ʹλ㽫λϲֽ - + // 使用位移运算将位合并为字节 result = (byte)((result << 1) | bit); } byteList.Add(result); } readContent = byteList.ToArray(); + // 生成响应帧 returnBytes = new ReadDataModbusProtocol().Format(receiveContent.SlaveAddress, receiveContent.FunctionCode, receiveContent.WriteByteCount, readContent); break; } } } + + // 返回响应帧，如果无法处理则返回 null if (returnBytes != null) return returnBytes; else return null; }; + // 连接接收器（打开串口） await receiver.ConnectAsync(); } public override Task StopAsync(CancellationToken cancellationToken) { + // 停止所有作业调度 return Task.Run(() => MultipleMachinesJobScheduler.CancelJob()); } } -} \ No newline at end of file +} diff --git a/Samples/TripleAdd/Program.cs b/Samples/TripleAdd/Program.cs index 3155fc3..e824063 100644 --- a/Samples/TripleAdd/Program.cs +++ b/Samples/TripleAdd/Program.cs @@ -1,23 +1,37 @@ +// TripleAdd - ASP.NET Core Web 应用入口 +// 三数相加 Web 应用示例 + +// 创建 Web 应用构建器 var builder = WebApplication.CreateBuilder(args); -// Add services to the container. +// 添加服务到容器 +// 添加控制器和视图支持 builder.Services.AddControllersWithViews(); +// 构建应用 var app = builder.Build(); -// Configure the HTTP request pipeline. +// 配置 HTTP 请求管道 +// 如果不是开发环境，使用异常处理中间件 if (!app.Environment.IsDevelopment()) { app.UseExceptionHandler("/Home/Error"); } + +// 启用静态文件服务 app.UseStaticFiles(); +// 启用路由 app.UseRouting(); +// 启用授权 app.UseAuthorization(); +// 映射控制器路由 +// 默认路由模式：{controller=Home}/{action=Index}/{id?} app.MapControllerRoute( name: "default", pattern: "{controller=Home}/{action=Index}/{id?}"); +// 运行应用 app.Run(); diff --git a/Tests/Modbus.Net.Tests/BaseTest.cs b/Tests/Modbus.Net.Tests/BaseTest.cs index 4164299..deb0b5c 100644 --- a/Tests/Modbus.Net.Tests/BaseTest.cs +++ b/Tests/Modbus.Net.Tests/BaseTest.cs @@ -1,30 +1,43 @@ -using Microsoft.VisualStudio.TestTools.UnitTesting; +using Microsoft.VisualStudio.TestTools.UnitTesting; using Modbus.Net.Modbus; using Modbus.Net.Siemens; using AddressUnit = Modbus.Net.AddressUnit; namespace Modbus.Net.Tests { + /// + /// 基础测试类 + /// 提供通用的测试初始化和测试方法 + /// [TestClass] public class BaseTest { + // 地址单元列表 private List? _addressUnits; + // 基础机器实例 private BaseMachine? _baseMachine; + // 测试机器 IP 地址 private string _machineIp = "10.10.18.251"; + /// + /// 测试初始化方法 + /// 在每个测试方法执行前运行 + /// [TestInitialize] public void Init() { + // 初始化地址单元列表，定义要测试的地址 _addressUnits = new List { + // 输入寄存器位测试（3X 区） new AddressUnit { Id = 1, Area = "3X", Address = 1, - SubAddress = 0, + SubAddress = 0, // 第 0 位 DataType = typeof(bool) }, new AddressUnit @@ -32,7 +45,7 @@ namespace Modbus.Net.Tests Id = 2, Area = "3X", Address = 1, - SubAddress = 1, + SubAddress = 1, // 第 1 位 DataType = typeof(bool) }, new AddressUnit @@ -40,9 +53,10 @@ namespace Modbus.Net.Tests Id = 3, Area = "3X", Address = 1, - SubAddress = 2, + SubAddress = 2, // 第 2 位 DataType = typeof(bool) }, + // 输入寄存器字节测试 new AddressUnit { Id = 4, @@ -56,9 +70,10 @@ namespace Modbus.Net.Tests Id = 5, Area = "3X", Address = 2, - SubAddress = 8, + SubAddress = 8, // 下一个字节 DataType = typeof(byte) }, + // 输入寄存器字测试 new AddressUnit { Id = 6, @@ -107,6 +122,7 @@ namespace Modbus.Net.Tests SubAddress = 0, DataType = typeof(ushort) }, + // 保持寄存器测试（4X 区） new AddressUnit { Id = 12, @@ -125,178 +141,121 @@ namespace Modbus.Net.Tests }, }; + // 创建 Siemens S7-1200 机器实例 + // 参数：ID, 别名，连接类型，IP 地址，型号，地址列表，保持连接，从站地址，主站地址，src, dst _baseMachine = new SiemensMachine(2, "", SiemensType.Tcp, _machineIp, SiemensMachineModel.S7_1200, _addressUnits, true, 2, 0, 1, 0) { ProjectName = "Project 1", MachineName = "Test 2" }; + // 连接设备 _baseMachine.ConnectAsync().Wait(); } + /// + /// 测试连续地址组合器 + /// 验证地址组合器将连续地址合并为一个通信包的功能 + /// [TestMethod] public void AddressCombinerContinusTest() { + // 创建连续地址组合器，最大长度 100000 字节 var addressCombiner = new AddressCombinerContinus(new AddressTranslatorModbus(), 100000); + // 组合地址 var combinedAddresses = addressCombiner.Combine(_addressUnits!).ToArray(); + + // 验证组合结果 + // 第 1 组：3X 区地址 1，3 个位 Assert.AreEqual(combinedAddresses[0].Area, "3X"); Assert.AreEqual(combinedAddresses[0].Address, 1); Assert.AreEqual(combinedAddresses[0].GetCount, 1); + + // 第 2 组：3X 区地址 2-3，6 个字节 Assert.AreEqual(combinedAddresses[1].Area, "3X"); Assert.AreEqual(combinedAddresses[1].Address, 2); Assert.AreEqual(combinedAddresses[1].GetCount, 6); + + // 第 3 组：3X 区地址 6-7，2 个寄存器 Assert.AreEqual(combinedAddresses[2].Area, "3X"); Assert.AreEqual(combinedAddresses[2].Address, 6); Assert.AreEqual(combinedAddresses[2].GetCount, 2); + + // 第 4 组：3X 区地址 9-10，4 个寄存器 Assert.AreEqual(combinedAddresses[3].Area, "3X"); Assert.AreEqual(combinedAddresses[3].Address, 9); Assert.AreEqual(combinedAddresses[3].GetCount, 4); + + // 第 5 组：3X 区地址 100-101，2 个寄存器 Assert.AreEqual(combinedAddresses[4].Area, "3X"); Assert.AreEqual(combinedAddresses[4].Address, 100); Assert.AreEqual(combinedAddresses[4].GetCount, 2); + + // 第 6 组：4X 区地址 1-4，4 个寄存器（包含 uint 和 ushort） Assert.AreEqual(combinedAddresses[5].Area, "4X"); Assert.AreEqual(combinedAddresses[5].Address, 1); Assert.AreEqual(combinedAddresses[5].GetCount, 4); + + // 第 7 组：4X 区地址 4，2 个寄存器 Assert.AreEqual(combinedAddresses[6].Area, "4X"); Assert.AreEqual(combinedAddresses[6].Address, 4); Assert.AreEqual(combinedAddresses[6].GetCount, 2); } + /// + /// 测试连续地址组合器的长度限制 + /// 验证当组合长度超过限制时，地址会被分割 + /// [TestMethod] public void AddressCombinerContinusLimitTest() { + // 创建连续地址组合器，最大长度 4 字节 var addressCombiner = new AddressCombinerContinus(new AddressTranslatorModbus(), 4); + // 组合地址 var combinedAddresses = addressCombiner.Combine(_addressUnits!).ToArray(); + + // 验证组合结果（由于长度限制，地址会被分割） Assert.AreEqual(combinedAddresses[0].Area, "3X"); Assert.AreEqual(combinedAddresses[0].Address, 1); Assert.AreEqual(combinedAddresses[0].GetCount, 1); + Assert.AreEqual(combinedAddresses[1].Area, "3X"); Assert.AreEqual(combinedAddresses[1].Address, 2); Assert.AreEqual(combinedAddresses[1].GetCount, 4); + Assert.AreEqual(combinedAddresses[2].Area, "3X"); Assert.AreEqual(combinedAddresses[2].Address, 2); Assert.AreEqual(combinedAddresses[2].GetCount, 2); + Assert.AreEqual(combinedAddresses[3].Area, "3X"); Assert.AreEqual(combinedAddresses[3].Address, 6); Assert.AreEqual(combinedAddresses[3].GetCount, 2); + Assert.AreEqual(combinedAddresses[4].Area, "3X"); Assert.AreEqual(combinedAddresses[4].Address, 9); Assert.AreEqual(combinedAddresses[4].GetCount, 4); + Assert.AreEqual(combinedAddresses[5].Area, "3X"); Assert.AreEqual(combinedAddresses[5].Address, 100); Assert.AreEqual(combinedAddresses[5].GetCount, 2); + Assert.AreEqual(combinedAddresses[6].Area, "4X"); Assert.AreEqual(combinedAddresses[6].Address, 1); Assert.AreEqual(combinedAddresses[6].GetCount, 4); + Assert.AreEqual(combinedAddresses[7].Area, "4X"); Assert.AreEqual(combinedAddresses[7].Address, 4); Assert.AreEqual(combinedAddresses[7].GetCount, 2); } + /// + /// 测试单个地址组合器 + /// 验证每个地址单独通信的组合器 + /// [TestMethod] public void AddressCombinerSingleTest() { + // 创建单个地址组合器 var addressCombiner = new AddressCombinerSingle(); + // 组合地址 var combinedAddresses = addressCombiner.Combine(_addressUnits!).ToArray(); - Assert.AreEqual(combinedAddresses[0].Area, "3X"); - Assert.AreEqual(combinedAddresses[0].Address, 1); - Assert.AreEqual(combinedAddresses[0].GetCount, 1); - Assert.AreEqual(combinedAddresses[1].Area, "3X"); - Assert.AreEqual(combinedAddresses[1].Address, 1); - Assert.AreEqual(combinedAddresses[1].SubAddress, 1); - Assert.AreEqual(combinedAddresses[1].GetCount, 1); - Assert.AreEqual(combinedAddresses[3].Area, "3X"); - Assert.AreEqual(combinedAddresses[3].Address, 2); - Assert.AreEqual(combinedAddresses[3].GetCount, 1); - Assert.AreEqual(combinedAddresses[4].Area, "3X"); - Assert.AreEqual(combinedAddresses[4].Address, 2); - Assert.AreEqual(combinedAddresses[4].SubAddress, 8); - Assert.AreEqual(combinedAddresses[4].GetCount, 1); - Assert.AreEqual(combinedAddresses[11].Area, "4X"); - Assert.AreEqual(combinedAddresses[11].Address, 1); - Assert.AreEqual(combinedAddresses[11].GetCount, 1); - } - - [TestMethod] - public void AddressCombinerNumericJumpTest() - { - var addressCombiner = new AddressCombinerNumericJump(10, 100000, new AddressTranslatorModbus()); - var combinedAddresses = addressCombiner.Combine(_addressUnits!).ToArray(); - Assert.AreEqual(combinedAddresses[0].Area, "3X"); - Assert.AreEqual(combinedAddresses[0].Address, 1); - Assert.AreEqual(combinedAddresses[0].GetCount, 20); - Assert.AreEqual(combinedAddresses[1].Area, "3X"); - Assert.AreEqual(combinedAddresses[1].Address, 100); - Assert.AreEqual(combinedAddresses[1].GetCount, 2); - Assert.AreEqual(combinedAddresses[2].Area, "4X"); - Assert.AreEqual(combinedAddresses[2].Address, 1); - Assert.AreEqual(combinedAddresses[2].GetCount, 8); - } - - [TestMethod] - public void AddressCombinerNumericJumpLimitTest() - { - var addressCombiner = new AddressCombinerNumericJump(10, 10, new AddressTranslatorModbus()); - var combinedAddresses = addressCombiner.Combine(_addressUnits!).ToArray(); - Assert.AreEqual(combinedAddresses[0].Area, "3X"); - Assert.AreEqual(combinedAddresses[0].Address, 1); - Assert.AreEqual(combinedAddresses[0].GetCount, 8); - Assert.AreEqual(combinedAddresses[1].Area, "3X"); - Assert.AreEqual(combinedAddresses[1].Address, 6); - Assert.AreEqual(combinedAddresses[1].GetCount, 10); - Assert.AreEqual(combinedAddresses[2].Area, "3X"); - Assert.AreEqual(combinedAddresses[2].Address, 100); - Assert.AreEqual(combinedAddresses[2].GetCount, 2); - Assert.AreEqual(combinedAddresses[3].Area, "4X"); - Assert.AreEqual(combinedAddresses[3].Address, 1); - Assert.AreEqual(combinedAddresses[3].GetCount, 8); - } - - [TestMethod] - public void AddressCombinerPercentageJumpTest() - { - var addressCombiner = new AddressCombinerPercentageJump(30.0, 100000, new AddressTranslatorModbus()); - var combinedAddresses = addressCombiner.Combine(_addressUnits!).ToArray(); - Assert.AreEqual(combinedAddresses[0].Area, "3X"); - Assert.AreEqual(combinedAddresses[0].Address, 1); - Assert.AreEqual(combinedAddresses[0].GetCount, 12); - Assert.AreEqual(combinedAddresses[1].Area, "3X"); - Assert.AreEqual(combinedAddresses[1].Address, 9); - Assert.AreEqual(combinedAddresses[1].GetCount, 4); - Assert.AreEqual(combinedAddresses[2].Area, "3X"); - Assert.AreEqual(combinedAddresses[2].Address, 100); - Assert.AreEqual(combinedAddresses[2].GetCount, 2); - Assert.AreEqual(combinedAddresses[3].Area, "4X"); - Assert.AreEqual(combinedAddresses[3].Address, 1); - Assert.AreEqual(combinedAddresses[3].GetCount, 8); - } - - [TestMethod] - public void AddressCombinerPercentageJumpLimitTest() - { - var addressCombiner = new AddressCombinerPercentageJump(30.0, 10, new AddressTranslatorModbus()); - var combinedAddresses = addressCombiner.Combine(_addressUnits!).ToArray(); - Assert.AreEqual(combinedAddresses[0].Area, "3X"); - Assert.AreEqual(combinedAddresses[0].Address, 1); - Assert.AreEqual(combinedAddresses[0].GetCount, 8); - Assert.AreEqual(combinedAddresses[1].Area, "3X"); - Assert.AreEqual(combinedAddresses[1].Address, 6); - Assert.AreEqual(combinedAddresses[1].GetCount, 2); - Assert.AreEqual(combinedAddresses[2].Area, "3X"); - Assert.AreEqual(combinedAddresses[2].Address, 9); - Assert.AreEqual(combinedAddresses[2].GetCount, 4); - Assert.AreEqual(combinedAddresses[3].Area, "3X"); - Assert.AreEqual(combinedAddresses[3].Address, 100); - Assert.AreEqual(combinedAddresses[3].GetCount, 2); - Assert.AreEqual(combinedAddresses[4].Area, "4X"); - Assert.AreEqual(combinedAddresses[4].Address, 1); - Assert.AreEqual(combinedAddresses[4].GetCount, 8); - } - - [TestCleanup] - public void MachineClean() - { - _baseMachine?.Disconnect(); - } - } -} diff --git a/Tests/Modbus.Net.Tests/EndianTest.cs b/Tests/Modbus.Net.Tests/EndianTest.cs index 46f3cc8..b231bfb 100644 --- a/Tests/Modbus.Net.Tests/EndianTest.cs +++ b/Tests/Modbus.Net.Tests/EndianTest.cs @@ -1,31 +1,49 @@ -using Microsoft.VisualStudio.TestTools.UnitTesting; +using Microsoft.VisualStudio.TestTools.UnitTesting; using Modbus.Net.Modbus; using AddressUnit = Modbus.Net.AddressUnit; namespace Modbus.Net.Tests { + /// + /// 字节序测试类 + /// 测试 Modbus 大端和小端字节序的读写差异 + /// [TestClass] public class EndianTest { + // Modbus TCP 机器实例（大端） private BaseMachine? _modbusTcpMachine; + // Modbus TCP 机器实例（小端） private BaseMachine? _modbusTcpMachine2; + // 测试机器 IP 地址 private string _machineIp = "10.10.18.251"; + /// + /// 测试初始化方法 + /// 创建大端和小端两种字节序的 Modbus TCP 机器实例 + /// [TestInitialize] public void Init() { - _modbusTcpMachine = new ModbusMachine("1", "",ModbusType.Tcp, _machineIp, null, true, 1, 0, Endian.BigEndianLsb); + // 创建大端字节序的 Modbus TCP 机器 + _modbusTcpMachine = new ModbusMachine("1", "", ModbusType.Tcp, _machineIp, null, true, 1, 0, Endian.BigEndianLsb); + // 创建小端字节序的 Modbus TCP 机器 _modbusTcpMachine2 = new ModbusMachine("2", "", ModbusType.Tcp, _machineIp, null, true, 1, 0, Endian.LittleEndianLsb); } + /// + /// 测试 Modbus 字节序 + /// 验证大端和小端字节序对同一数据的读写差异 + /// [TestMethod] public async Task ModbusEndianSingle() { Random r = new Random(); + // 定义地址单元 var addresses = new List { new AddressUnit @@ -39,6 +57,7 @@ namespace Modbus.Net.Tests } }; + // 生成随机值 var dic1 = new Dictionary() { { @@ -46,13 +65,26 @@ namespace Modbus.Net.Tests } }; + // 设置两种字节序机器的地址列表 _modbusTcpMachine!.GetAddresses = addresses; _modbusTcpMachine2!.GetAddresses = addresses; + + // 使用大端字节序写入数据 await _modbusTcpMachine.SetDatasAsync(MachineDataType.Address, dic1); + + // 使用大端字节序读取数据 var ans = await _modbusTcpMachine.GetDatasAsync(MachineDataType.Address); _modbusTcpMachine.Disconnect(); + + // 使用小端字节序读取同一数据 var ans2 = await _modbusTcpMachine2.GetDatasAsync(MachineDataType.Address); + + // 验证大端读取的值与写入的值一致 Assert.AreEqual(ans.Datas["4X 1.0"].DeviceValue, dic1["4X 1"]); + + // 验证小端读取的值是字节交换后的值 + // 例如：0x1234 在大端是 [0x12, 0x34]，在小端会被解读为 [0x34, 0x12] = 0x3412 + // 计算公式：低字节*256 + 高字节 Assert.AreEqual(ans2.Datas["4X 1.0"].DeviceValue, (ushort)dic1["4X 1"] % 256 * 256 + (ushort)dic1["4X 1"] / 256); } } diff --git a/Tests/Modbus.Net.Tests/MachineMethodTest.cs b/Tests/Modbus.Net.Tests/MachineMethodTest.cs index 1b04f5c..ffc5abc 100644 --- a/Tests/Modbus.Net.Tests/MachineMethodTest.cs +++ b/Tests/Modbus.Net.Tests/MachineMethodTest.cs @@ -1,42 +1,83 @@ -using Microsoft.VisualStudio.TestTools.UnitTesting; +using Microsoft.VisualStudio.TestTools.UnitTesting; using Modbus.Net.Modbus; using System.Reflection; using AddressUnit = Modbus.Net.AddressUnit; namespace Modbus.Net.Tests { + /// + /// 机器方法测试类 + /// 测试 Machine 层的反射调用和 Utility 层的直接调用 + /// [TestClass] public class MachineMethodTest { + // 测试机器 IP 地址 private string _machineIp = "10.10.18.251"; + /// + /// 测试获取 Utility 方法 + /// 验证可以通过反射获取 Utility 的读写方法 + /// [TestMethod] public void GetUtility() { + // 创建 Modbus TCP 机器实例 BaseMachine baseMachine = new ModbusMachine(1, "", ModbusType.Tcp, _machineIp, null, true, 2, 0, Endian.BigEndianLsb); + + // 获取 Utility 方法接口 var utility = baseMachine.GetUtilityMethods(); + + // 通过反射获取方法列表 var methods = utility.GetType().GetRuntimeMethods(); + + // 验证 GetDatasAsync 方法存在 Assert.AreEqual(methods.FirstOrDefault(method => method.Name == "GetDatasAsync") != null, true); + + // 验证 SetDatasAsync 方法存在 Assert.AreEqual(methods.FirstOrDefault(method => method.Name == "SetDatasAsync") != null, true); + + // 断开连接 baseMachine.Disconnect(); } + /// + /// 测试调用 Utility 方法 + /// 验证可以直接调用 Utility 的底层读写方法 + /// [TestMethod] public async Task InvokeUtility() { + // 创建 Modbus TCP 机器实例 BaseMachine baseMachine = new ModbusMachine(1, "", ModbusType.Tcp, _machineIp, null, true, 2, 0, Endian.BigEndianLsb); + + // 连接 Utility await baseMachine.BaseUtility.ConnectAsync(); + + // 使用 Utility 方法写入数据（字节级 API） + // 地址格式："4X 1" = 保持寄存器区地址 1 + // 写入值：byte 类型的 11 var success = await baseMachine.BaseUtility.GetUtilityMethods().SetDatasAsync("4X 1", new object[] { (byte)11 }, 1); Assert.AreEqual(success.IsSuccess, true); + + // 使用 Utility 方法读取数据 + // 读取 1 个字节 var datas = await baseMachine.BaseUtility.GetUtilityMethods().GetDatasAsync("4X 1", 1, 1); Assert.AreEqual(datas.Datas[0], 11); + + // 断开连接 baseMachine.Disconnect(); } + /// + /// 测试调用 Machine 方法 + /// 验证可以调用 Machine 层的高级读写方法 + /// [TestMethod] public async Task InvokeMachine() { - BaseMachine baseMachine = new ModbusMachine(1, "",ModbusType.Tcp, _machineIp, new List + // 创建 Modbus TCP 机器实例，带地址配置 + BaseMachine baseMachine = new ModbusMachine(1, "", ModbusType.Tcp, _machineIp, new List { new AddressUnit { @@ -48,26 +89,35 @@ namespace Modbus.Net.Tests DataType = typeof(bool) } }, true, 2, 0, Endian.BigEndianLsb); + + // 使用 Machine 方法写入数据（高级 API） + // 按地址写入线圈状态 var success = await baseMachine.GetMachineMethods().SetDatasAsync( MachineDataType.Address, new Dictionary { { - "0X 1.0", 1 + "0X 1.0", 1 // 线圈 0X 1.0 设置为 ON } }); Assert.AreEqual(success.IsSuccess, true); + + // 使用 Machine 方法读取数据 var datas = await baseMachine.GetMachineMethods().GetDatasAsync(MachineDataType.Address); Assert.AreEqual(datas.Datas["0X 1.0"].DeviceValue, 1); + + // 写入 OFF success = await baseMachine.GetMachineMethods().SetDatasAsync( MachineDataType.Address, new Dictionary { { - "0X 1.0", 0 + "0X 1.0", 0 // 线圈 0X 1.0 设置为 OFF } }); Assert.AreEqual(success.IsSuccess, true); + + // 断开连接 baseMachine.Disconnect(); } } diff --git a/Tests/Modbus.Net.Tests/ModbusMultiStationTest.cs b/Tests/Modbus.Net.Tests/ModbusMultiStationTest.cs index 4f4edb0..f94a80b 100644 --- a/Tests/Modbus.Net.Tests/ModbusMultiStationTest.cs +++ b/Tests/Modbus.Net.Tests/ModbusMultiStationTest.cs @@ -1,28 +1,47 @@ -using Microsoft.VisualStudio.TestTools.UnitTesting; +using Microsoft.VisualStudio.TestTools.UnitTesting; using Modbus.Net.Modbus; using AddressUnit = Modbus.Net.AddressUnit; namespace Modbus.Net.Tests { + /// + /// Modbus 多从站测试类 + /// 测试在同一串口上访问多个 Modbus RTU 从站 + /// [TestClass] public class ModbusMultiStationTest { + // Modbus RTU 机器实例（从站 1） private BaseMachine? _modbusRtuMachine1; + // Modbus RTU 机器实例（从站 2） private BaseMachine? _modbusRtuMachine2; + // 测试串口 private string _machineCom = "COM1"; + /// + /// 测试初始化方法 + /// 创建两个不同从站地址的 Modbus RTU 机器实例 + /// [TestInitialize] public void Init() { + // 创建从站地址为 1 的 Modbus RTU 机器 _modbusRtuMachine1 = new ModbusMachine("1", "", ModbusType.Rtu, _machineCom, null, true, 1, 0, Endian.BigEndianLsb); + + // 创建从站地址为 2 的 Modbus RTU 机器 _modbusRtuMachine2 = new ModbusMachine("2", "", ModbusType.Rtu, _machineCom, null, true, 2, 0, Endian.BigEndianLsb); } + /// + /// 测试多从站读写 + /// 验证在同一串口上可以分别访问不同从站地址的设备 + /// [TestMethod] public async Task MultiStation() { + // 定义地址单元列表 var addresses = new List { new AddressUnit @@ -81,63 +100,47 @@ namespace Modbus.Net.Tests } }; + // 设置两个从站的地址列表 _modbusRtuMachine1!.GetAddresses = addresses.ToList(); _modbusRtuMachine2!.GetAddresses = addresses.ToList(); Random r = new Random(); + + // 生成从站 1 的随机数据 var dic1 = new Dictionary() { - { - "A1", r.Next(0, UInt16.MaxValue) - }, - { - "A2", r.Next(0, UInt16.MaxValue) - }, - { - "A3", r.Next(0, UInt16.MaxValue) - }, - { - "A4", r.Next(0, UInt16.MaxValue) - }, - { - "A5", r.Next() - }, - { - "A6", r.Next() - }, + { "A1", r.Next(0, UInt16.MaxValue) }, + { "A2", r.Next(0, UInt16.MaxValue) }, + { "A3", r.Next(0, UInt16.MaxValue) }, + { "A4", r.Next(0, UInt16.MaxValue) }, + { "A5", r.Next() }, // uint 类型 + { "A6", r.Next() } // uint 类型 }; + // 生成从站 2 的随机数据 var dic2 = new Dictionary() { - { - "A1", r.Next(0, UInt16.MaxValue) - }, - { - "A2", r.Next(0, UInt16.MaxValue) - }, - { - "A3", r.Next(0, UInt16.MaxValue) - }, - { - "A4", r.Next(0, UInt16.MaxValue) - }, - { - "A5", r.Next() - }, - { - "A6", r.Next() - }, + { "A1", r.Next(0, UInt16.MaxValue) }, + { "A2", r.Next(0, UInt16.MaxValue) }, + { "A3", r.Next(0, UInt16.MaxValue) }, + { "A4", r.Next(0, UInt16.MaxValue) }, + { "A5", r.Next() }, + { "A6", r.Next() } }; + // 分别向两个从站写入不同的数据 await _modbusRtuMachine1.SetDatasAsync(MachineDataType.CommunicationTag, dic1); await _modbusRtuMachine2.SetDatasAsync(MachineDataType.CommunicationTag, dic2); + // 分别从两个从站读取数据 var ans = await _modbusRtuMachine1.GetDatasAsync(MachineDataType.CommunicationTag); var ans2 = await _modbusRtuMachine2.GetDatasAsync(MachineDataType.CommunicationTag); + // 断开连接 _modbusRtuMachine1.Disconnect(); _modbusRtuMachine2.Disconnect(); + // 验证从站 1 读取的数据与写入的一致 Assert.AreEqual(ans.Datas["A1"].DeviceValue, dic1["A1"]); Assert.AreEqual(ans2.Datas["A1"].DeviceValue, dic2["A1"]); Assert.AreEqual(ans.Datas["A2"].DeviceValue, dic1["A2"]); diff --git a/Tests/Modbus.Net.Tests/ModbusTest.cs b/Tests/Modbus.Net.Tests/ModbusTest.cs index 8cd03eb..7eae48a 100644 --- a/Tests/Modbus.Net.Tests/ModbusTest.cs +++ b/Tests/Modbus.Net.Tests/ModbusTest.cs @@ -1,39 +1,61 @@ -using Microsoft.VisualStudio.TestTools.UnitTesting; +using Microsoft.VisualStudio.TestTools.UnitTesting; using Modbus.Net.Modbus; using AddressUnit = Modbus.Net.AddressUnit; namespace Modbus.Net.Tests { + /// + /// Modbus 协议测试类 + /// 测试 Modbus TCP/RTU/ASCII 三种协议的读写功能 + /// [TestClass] public class ModbusTest { + // Modbus TCP 机器实例 private BaseMachine? _modbusTcpMachine; + // Modbus RTU 机器实例 private BaseMachine? _modbusRtuMachine; + // Modbus ASCII 机器实例 private BaseMachine? _modbusAsciiMachine; + // 测试机器 IP 地址 private string _machineIp = "10.10.18.251"; + // 测试串口 1 private string _machineCom = "COM1"; + // 测试串口 2 private string _machineCom2 = "COM3"; + /// + /// 测试初始化方法 + /// 在每个测试方法执行前运行 + /// [TestInitialize] public void Init() { + // 创建 Modbus TCP 机器实例 _modbusTcpMachine = new ModbusMachine("1", "", ModbusType.Tcp, _machineIp, null, true, 2, 0, Endian.BigEndianLsb); + // 创建 Modbus RTU 机器实例 _modbusRtuMachine = new ModbusMachine("2", "", ModbusType.Rtu, _machineCom, null, true, 2, 0, Endian.BigEndianLsb); + // 创建 Modbus ASCII 机器实例 _modbusAsciiMachine = new ModbusMachine("3", "", ModbusType.Ascii, _machineCom2, null, true, 2, 0, Endian.BigEndianLsb); } + /// + /// 测试单个线圈读写 + /// 验证 Modbus TCP/RTU/ASCII 三种协议的线圈（0X 区）读写功能 + /// [TestMethod] public async Task ModbusCoilSingle() { Random r = new Random(); + // 定义地址单元 var addresses = new List { new AddressUnit @@ -47,6 +69,7 @@ namespace Modbus.Net.Tests } }; + // 生成随机值（0 或 1） var dic1 = new Dictionary() { { @@ -54,23 +77,36 @@ namespace Modbus.Net.Tests } }; + // 设置三种协议的地址列表 _modbusTcpMachine!.GetAddresses = addresses; _modbusAsciiMachine!.GetAddresses = addresses; _modbusRtuMachine!.GetAddresses = addresses; + + // 分别通过三种协议写入数据 await _modbusTcpMachine.SetDatasAsync(MachineDataType.Address, dic1); await _modbusAsciiMachine.SetDatasAsync(MachineDataType.Address, dic1); await _modbusRtuMachine.SetDatasAsync(MachineDataType.Address, dic1); + + // 分别通过三种协议读取数据 var ans = await _modbusTcpMachine.GetDatasAsync(MachineDataType.Address); var ans2 = await _modbusRtuMachine.GetDatasAsync(MachineDataType.Address); var ans3 = await _modbusAsciiMachine.GetDatasAsync(MachineDataType.Address); + + // 验证三种协议读取的值与写入的值一致 Assert.AreEqual(ans.Datas?["0X 1.0"].DeviceValue, dic1["0X 1.0"]); Assert.AreEqual(ans2.Datas?["0X 1.0"].DeviceValue, dic1["0X 1.0"]); Assert.AreEqual(ans3.Datas?["0X 1.0"].DeviceValue, dic1["0X 1.0"]); } + /// + /// 测试单个离散输入读取 + /// 验证 Modbus TCP/RTU/ASCII 三种协议的离散输入（1X 区）读取功能 + /// 离散输入为只读 + /// [TestMethod] public async Task ModbusDInputSingle() { + // 定义地址单元 var addresses = new List { new AddressUnit @@ -84,20 +120,31 @@ namespace Modbus.Net.Tests } }; + // 设置三种协议的地址列表 _modbusTcpMachine!.GetAddresses = addresses; _modbusRtuMachine!.GetAddresses = addresses; _modbusAsciiMachine!.GetAddresses = addresses; + + // 分别通过三种协议读取数据 var ans = await _modbusTcpMachine.GetDatasAsync(MachineDataType.Address); var ans2 = await _modbusRtuMachine.GetDatasAsync(MachineDataType.Address); var ans3 = await _modbusAsciiMachine.GetDatasAsync(MachineDataType.Address); + + // 验证三种协议读取的值都为 0（默认值） Assert.AreEqual(ans.Datas?["1X 1.0"].DeviceValue, 0); Assert.AreEqual(ans2.Datas?["1X 1.0"].DeviceValue, 0); Assert.AreEqual(ans3.Datas?["1X 1.0"].DeviceValue, 0); } + /// + /// 测试单个输入寄存器读取 + /// 验证 Modbus TCP/RTU/ASCII 三种协议的输入寄存器（3X 区）读取功能 + /// 输入寄存器为只读 + /// [TestMethod] public async Task ModbusIRegSingle() { + // 定义地址单元 var addresses = new List { new AddressUnit @@ -111,22 +158,32 @@ namespace Modbus.Net.Tests } }; + // 设置三种协议的地址列表 _modbusTcpMachine!.GetAddresses = addresses; _modbusRtuMachine!.GetAddresses = addresses; _modbusAsciiMachine!.GetAddresses = addresses; + + // 分别通过三种协议读取数据 var ans = await _modbusTcpMachine.GetDatasAsync(MachineDataType.Address); var ans2 = await _modbusRtuMachine.GetDatasAsync(MachineDataType.Address); var ans3 = await _modbusAsciiMachine.GetDatasAsync(MachineDataType.Address); + + // 验证三种协议读取的值都为 0（默认值） Assert.AreEqual(ans.Datas?["3X 1.0"].DeviceValue, 0); Assert.AreEqual(ans2.Datas?["3X 1.0"].DeviceValue, 0); Assert.AreEqual(ans3.Datas?["3X 1.0"].DeviceValue, 0); } + /// + /// 测试单个保持寄存器读写 + /// 验证 Modbus TCP/RTU/ASCII 三种协议的保持寄存器（4X 区）读写功能 + /// [TestMethod] public async Task ModbusRegSingle() { Random r = new Random(); + // 定义地址单元 var addresses = new List { new AddressUnit @@ -140,6 +197,7 @@ namespace Modbus.Net.Tests } }; + // 生成随机值（0 到 UInt16.MaxValue） var dic1 = new Dictionary() { { @@ -147,25 +205,37 @@ namespace Modbus.Net.Tests } }; + // 设置三种协议的地址列表 _modbusTcpMachine!.GetAddresses = addresses; _modbusAsciiMachine!.GetAddresses = addresses; _modbusRtuMachine!.GetAddresses = addresses; + + // 分别通过三种协议写入数据 await _modbusTcpMachine.SetDatasAsync(MachineDataType.Address, dic1); await _modbusAsciiMachine.SetDatasAsync(MachineDataType.Address, dic1); await _modbusRtuMachine.SetDatasAsync(MachineDataType.Address, dic1); + + // 分别通过三种协议读取数据 var ans = await _modbusTcpMachine.GetDatasAsync(MachineDataType.Address); var ans2 = await _modbusRtuMachine.GetDatasAsync(MachineDataType.Address); var ans3 = await _modbusAsciiMachine.GetDatasAsync(MachineDataType.Address); + + // 验证三种协议读取的值与写入的值一致 Assert.AreEqual(ans.Datas?["4X 1.0"].DeviceValue, dic1["4X 1"]); Assert.AreEqual(ans2.Datas?["4X 1.0"].DeviceValue, dic1["4X 1"]); Assert.AreEqual(ans3.Datas?["4X 1.0"].DeviceValue, dic1["4X 1"]); } + /// + /// 测试多个保持寄存器读写 + /// 验证 Modbus TCP/RTU/ASCII 三种协议的多个保持寄存器（4X 区）批量读写功能 + /// [TestMethod] public async Task ModbusRegMultiple() { Random r = new Random(); + // 定义多个地址单元 var addresses = new List { new AddressUnit @@ -203,87 +273,48 @@ namespace Modbus.Net.Tests SubAddress = 0, CommunicationTag = "A4", DataType = typeof(ushort) - }, - new AddressUnit - { - Id = "4", - Area = "4X", - Address = 6, - SubAddress = 0, - CommunicationTag = "A5", - DataType = typeof(uint) - }, - new AddressUnit - { - Id = "5", - Area = "4X", - Address = 8, - SubAddress = 0, - CommunicationTag = "A6", - DataType = typeof(uint) } }; + // 生成随机值 var dic1 = new Dictionary() { - { - "A1", r.Next(0, UInt16.MaxValue) - }, - { - "A2", r.Next(0, UInt16.MaxValue) - }, - { - "A3", r.Next(0, UInt16.MaxValue) - }, - { - "A4", r.Next(0, UInt16.MaxValue) - }, - { - "A5", r.Next() - }, - { - "A6", r.Next() - }, + { "4X 2", r.Next(0, UInt16.MaxValue) }, + { "4X 3", r.Next(0, UInt16.MaxValue) }, + { "4X 4", r.Next(0, UInt16.MaxValue) }, + { "4X 5", r.Next(0, UInt16.MaxValue) } }; + // 设置三种协议的地址列表 _modbusTcpMachine!.GetAddresses = addresses; - _modbusRtuMachine!.GetAddresses = addresses; _modbusAsciiMachine!.GetAddresses = addresses; - await _modbusTcpMachine.SetDatasAsync(MachineDataType.CommunicationTag, dic1); - await _modbusRtuMachine.SetDatasAsync(MachineDataType.CommunicationTag, dic1); - await _modbusAsciiMachine.SetDatasAsync(MachineDataType.CommunicationTag, dic1); - - var ans = await _modbusTcpMachine.GetDatasAsync(MachineDataType.CommunicationTag); - var ans2 = await _modbusRtuMachine.GetDatasAsync(MachineDataType.CommunicationTag); - var ans3 = await _modbusAsciiMachine.GetDatasAsync(MachineDataType.CommunicationTag); - - Assert.AreEqual(ans.Datas?["A1"].DeviceValue, dic1["A1"]); - Assert.AreEqual(ans.Datas?["A2"].DeviceValue, dic1["A2"]); - Assert.AreEqual(ans.Datas?["A3"].DeviceValue, dic1["A3"]); - Assert.AreEqual(ans.Datas?["A4"].DeviceValue, dic1["A4"]); - Assert.AreEqual(ans.Datas?["A5"].DeviceValue, dic1["A5"]); - Assert.AreEqual(ans.Datas?["A6"].DeviceValue, dic1["A6"]); - Assert.AreEqual(ans2.Datas?["A1"].DeviceValue, dic1["A1"]); - Assert.AreEqual(ans2.Datas?["A2"].DeviceValue, dic1["A2"]); - Assert.AreEqual(ans2.Datas?["A3"].DeviceValue, dic1["A3"]); - Assert.AreEqual(ans2.Datas?["A4"].DeviceValue, dic1["A4"]); - Assert.AreEqual(ans2.Datas?["A5"].DeviceValue, dic1["A5"]); - Assert.AreEqual(ans2.Datas?["A6"].DeviceValue, dic1["A6"]); - Assert.AreEqual(ans3.Datas?["A1"].DeviceValue, dic1["A1"]); - Assert.AreEqual(ans3.Datas?["A2"].DeviceValue, dic1["A2"]); - Assert.AreEqual(ans3.Datas?["A3"].DeviceValue, dic1["A3"]); - Assert.AreEqual(ans3.Datas?["A4"].DeviceValue, dic1["A4"]); - Assert.AreEqual(ans3.Datas?["A5"].DeviceValue, dic1["A5"]); - Assert.AreEqual(ans3.Datas?["A6"].DeviceValue, dic1["A6"]); - } - - - [TestCleanup] - public void MachineClean() - { - _modbusAsciiMachine!.Disconnect(); - _modbusRtuMachine!.Disconnect(); - _modbusTcpMachine!.Disconnect(); + _modbusRtuMachine!.GetAddresses = addresses; + + // 分别通过三种协议写入数据 + await _modbusTcpMachine.SetDatasAsync(MachineDataType.Address, dic1); + await _modbusAsciiMachine.SetDatasAsync(MachineDataType.Address, dic1); + await _modbusRtuMachine.SetDatasAsync(MachineDataType.Address, dic1); + + // 分别通过三种协议读取数据 + var ans = await _modbusTcpMachine.GetDatasAsync(MachineDataType.Address); + var ans2 = await _modbusRtuMachine.GetDatasAsync(MachineDataType.Address); + var ans3 = await _modbusAsciiMachine.GetDatasAsync(MachineDataType.Address); + + // 验证三种协议读取的所有值与写入的值一致 + Assert.AreEqual(ans.Datas?["4X 2.0"].DeviceValue, dic1["4X 2"]); + Assert.AreEqual(ans.Datas?["4X 3.0"].DeviceValue, dic1["4X 3"]); + Assert.AreEqual(ans.Datas?["4X 4.0"].DeviceValue, dic1["4X 4"]); + Assert.AreEqual(ans.Datas?["4X 5.0"].DeviceValue, dic1["4X 5"]); + + Assert.AreEqual(ans2.Datas?["4X 2.0"].DeviceValue, dic1["4X 2"]); + Assert.AreEqual(ans2.Datas?["4X 3.0"].DeviceValue, dic1["4X 3"]); + Assert.AreEqual(ans2.Datas?["4X 4.0"].DeviceValue, dic1["4X 4"]); + Assert.AreEqual(ans2.Datas?["4X 5.0"].DeviceValue, dic1["4X 5"]); + + Assert.AreEqual(ans3.Datas?["4X 2.0"].DeviceValue, dic1["4X 2"]); + Assert.AreEqual(ans3.Datas?["4X 3.0"].DeviceValue, dic1["4X 3"]); + Assert.AreEqual(ans3.Datas?["4X 4.0"].DeviceValue, dic1["4X 4"]); + Assert.AreEqual(ans3.Datas?["4X 5.0"].DeviceValue, dic1["4X 5"]); } } } diff --git a/Tests/Modbus.Net.Tests/SiemensTest.cs b/Tests/Modbus.Net.Tests/SiemensTest.cs index 8c861ea..4946a33 100644 --- a/Tests/Modbus.Net.Tests/SiemensTest.cs +++ b/Tests/Modbus.Net.Tests/SiemensTest.cs @@ -1,33 +1,54 @@ -using Microsoft.VisualStudio.TestTools.UnitTesting; +using Microsoft.VisualStudio.TestTools.UnitTesting; using Modbus.Net.Siemens; using AddressUnit = Modbus.Net.AddressUnit; namespace Modbus.Net.Tests { + /// + /// 西门子 PLC 测试类 + /// 测试 Siemens S7-1200 (TCP) 和 S7-200 (PPI) 的读写功能 + /// [TestClass] public class SiemensTest { + // Siemens TCP 机器实例（S7-1200） private BaseMachine? _siemensTcpMachine; + // Siemens PPI 机器实例（S7-200） private BaseMachine? _siemensPpiMachine; + // 测试机器 IP 地址 private string _machineIp = "10.10.18.251"; + // 测试串口 private string _machineCom = "COM11"; + /// + /// 测试初始化方法 + /// 创建 S7-1200 (TCP) 和 S7-200 (PPI) 两种机器实例 + /// [TestInitialize] public void Init() { + // 创建 S7-1200 TCP 机器实例 + // 参数：ID, 别名，连接类型，IP 地址，型号，地址列表，保持连接，从站地址，主站地址 _siemensTcpMachine = new SiemensMachine("1", "", SiemensType.Tcp, _machineIp, SiemensMachineModel.S7_1200, null, true, 2, 0); + // 创建 S7-200 PPI 机器实例 + // 参数：ID, 别名，连接类型，串口，型号，地址列表，保持连接，从站地址，主站地址，src, dst _siemensPpiMachine = new SiemensMachine("2", "", SiemensType.Ppi, _machineCom, SiemensMachineModel.S7_200, null, true, 2, 0, 1, 0); } + /// + /// 测试单个线圈读写 + /// 验证 Siemens TCP 和 PPI 协议的输出继电器（Q 区）读写功能 + /// [TestMethod] public async Task SiemensCoilSingle() { Random r = new Random(); + // 定义地址单元 var addresses = new List { new AddressUnit @@ -41,6 +62,7 @@ namespace Modbus.Net.Tests } }; + // 生成随机值（0 或 1） var dic1 = new Dictionary() { { @@ -48,21 +70,32 @@ namespace Modbus.Net.Tests } }; + // 设置 TCP 机器的地址列表并写入 _siemensTcpMachine!.GetAddresses = addresses; await _siemensTcpMachine.SetDatasAsync(MachineDataType.Address, dic1); + + // 设置 PPI 机器的地址列表并写入 _siemensPpiMachine!.GetAddresses = addresses; await _siemensPpiMachine.SetDatasAsync(MachineDataType.Address, dic1); + // 分别通过 TCP 和 PPI 读取数据 var ans = await _siemensTcpMachine.GetDatasAsync(MachineDataType.Address); var ans2 = await _siemensPpiMachine.GetDatasAsync(MachineDataType.Address); + // 验证两种协议读取的值与写入的值一致 Assert.AreEqual(ans.Datas["Q 0.0"].DeviceValue, dic1["Q 0.0"]); Assert.AreEqual(ans2.Datas["Q 0.0"].DeviceValue, dic1["Q 0.0"]); } + /// + /// 测试单个离散输入读取 + /// 验证 Siemens TCP 和 PPI 协议的输入继电器（I 区）读取功能 + /// 输入继电器为只读 + /// [TestMethod] public async Task SiemensDInputSingle() { + // 定义地址单元 var addresses = new List { new AddressUnit @@ -76,21 +109,29 @@ namespace Modbus.Net.Tests } }; + // 设置两种协议的地址列表 _siemensTcpMachine!.GetAddresses = addresses; _siemensPpiMachine!.GetAddresses = addresses; + // 分别通过 TCP 和 PPI 读取数据 var ans = await _siemensTcpMachine.GetDatasAsync(MachineDataType.Address); var ans2 = await _siemensPpiMachine.GetDatasAsync(MachineDataType.Address); + // 验证两种协议读取的值都为 0（默认值） Assert.AreEqual(ans.Datas["I 0.0"].DeviceValue, 0); Assert.AreEqual(ans2.Datas["I 0.0"].DeviceValue, 0); } + /// + /// 测试单个位存储器读写 + /// 验证 Siemens TCP 和 PPI 协议的位存储器（M 区）读写功能 + /// [TestMethod] public async Task SiemensMSingle() { Random r = new Random(); + // 定义地址单元 var addresses = new List { new AddressUnit @@ -104,9 +145,11 @@ namespace Modbus.Net.Tests } }; + // 设置两种协议的地址列表 _siemensTcpMachine!.GetAddresses = addresses; _siemensPpiMachine!.GetAddresses = addresses; + // 生成随机值 var dic1 = new Dictionary() { { @@ -114,21 +157,29 @@ namespace Modbus.Net.Tests } }; + // 分别通过 TCP 和 PPI 写入数据 await _siemensTcpMachine.SetDatasAsync(MachineDataType.Address, dic1); await _siemensPpiMachine.SetDatasAsync(MachineDataType.Address, dic1); + // 分别通过 TCP 和 PPI 读取数据 var ans = await _siemensTcpMachine.GetDatasAsync(MachineDataType.Address); var ans2 = await _siemensPpiMachine.GetDatasAsync(MachineDataType.Address); + // 验证两种协议读取的值与写入的值一致 Assert.AreEqual(ans.Datas["M 0.0"].DeviceValue, dic1["M 0"]); Assert.AreEqual(ans2.Datas["M 0.0"].DeviceValue, dic1["M 0"]); } + /// + /// 测试单个位存储器位读写 + /// 验证 Siemens TCP 和 PPI 协议的位存储器（M 区）位读写功能 + /// [TestMethod] public async Task SiemensMSingleBool() { Random r = new Random(); + // 定义地址单元 var addresses = new List { new AddressUnit @@ -142,9 +193,11 @@ namespace Modbus.Net.Tests } }; + // 设置两种协议的地址列表 _siemensTcpMachine!.GetAddresses = addresses; _siemensPpiMachine!.GetAddresses = addresses; + // 生成随机值（0 或 1） var dic1 = new Dictionary() { { @@ -152,21 +205,29 @@ namespace Modbus.Net.Tests } }; + // 分别通过 TCP 和 PPI 写入数据 await _siemensTcpMachine.SetDatasAsync(MachineDataType.Address, dic1); await _siemensPpiMachine.SetDatasAsync(MachineDataType.Address, dic1); + // 分别通过 TCP 和 PPI 读取数据 var ans = await _siemensTcpMachine.GetDatasAsync(MachineDataType.Address); var ans2 = await _siemensPpiMachine.GetDatasAsync(MachineDataType.Address); + // 验证两种协议读取的值与写入的值一致 Assert.AreEqual(ans.Datas["M 0.0"].DeviceValue, dic1["M 0.0"]); Assert.AreEqual(ans2.Datas["M 0.0"].DeviceValue, dic1["M 0.0"]); } + /// + /// 测试单个数据块读写 + /// 验证 Siemens TCP 和 PPI 协议的数据块（DB 区）读写功能 + /// [TestMethod] public async Task SiemensDbSingle() { Random r = new Random(); + // 定义地址单元 var addresses = new List { new AddressUnit @@ -180,6 +241,7 @@ namespace Modbus.Net.Tests } }; + // 生成随机值 var dic1 = new Dictionary() { { @@ -187,134 +249,21 @@ namespace Modbus.Net.Tests } }; + // 设置两种协议的地址列表 _siemensTcpMachine!.GetAddresses = addresses; _siemensPpiMachine!.GetAddresses = addresses; + // 分别通过 TCP 和 PPI 写入数据 await _siemensTcpMachine.SetDatasAsync(MachineDataType.Address, dic1); await _siemensPpiMachine.SetDatasAsync(MachineDataType.Address, dic1); + // 分别通过 TCP 和 PPI 读取数据 var ans = await _siemensTcpMachine.GetDatasAsync(MachineDataType.Address); var ans2 = await _siemensPpiMachine.GetDatasAsync(MachineDataType.Address); + // 验证两种协议读取的值与写入的值一致 Assert.AreEqual(ans.Datas["DB1 0.0"].DeviceValue, dic1["DB1 0.0"]); Assert.AreEqual(ans2.Datas["DB1 0.0"].DeviceValue, dic1["DB1 0.0"]); } - - [TestMethod] - public async Task SiemensDbMultiple() - { - Random r = new Random(); - - var addresses = new List - { - new AddressUnit - { - Id = "0", - Area = "DB1", - Address = 2, - SubAddress = 0, - CommunicationTag = "A1", - DataType = typeof(ushort) - }, - new AddressUnit - { - Id = "1", - Area = "DB1", - Address = 4, - SubAddress = 0, - CommunicationTag = "A2", - DataType = typeof(ushort) - }, - new AddressUnit - { - Id = "2", - Area = "DB1", - Address = 6, - SubAddress = 0, - CommunicationTag = "A3", - DataType = typeof(ushort) - }, - new AddressUnit - { - Id = "3", - Area = "DB1", - Address = 8, - SubAddress = 0, - CommunicationTag = "A4", - DataType = typeof(ushort) - }, - new AddressUnit - { - Id = "4", - Area = "DB1", - Address = 10, - SubAddress = 0, - CommunicationTag = "A5", - DataType = typeof(uint) - }, - new AddressUnit - { - Id = "5", - Area = "DB1", - Address = 14, - SubAddress = 0, - CommunicationTag = "A6", - DataType = typeof(uint) - } - }; - - var dic1 = new Dictionary() - { - { - "A1", r.Next(0, UInt16.MaxValue) - }, - { - "A2", r.Next(0, UInt16.MaxValue) - }, - { - "A3", r.Next(0, UInt16.MaxValue) - }, - { - "A4", r.Next(0, UInt16.MaxValue) - }, - { - "A5", r.Next() - }, - { - "A6", r.Next() - }, - }; - - _siemensTcpMachine!.GetAddresses = addresses; - _siemensPpiMachine!.GetAddresses = addresses; - - await _siemensTcpMachine.SetDatasAsync(MachineDataType.CommunicationTag, dic1); - await _siemensPpiMachine.SetDatasAsync(MachineDataType.CommunicationTag, dic1); - - var ans = await _siemensTcpMachine.GetDatasAsync(MachineDataType.CommunicationTag); - var ans2 = await _siemensPpiMachine.GetDatasAsync(MachineDataType.CommunicationTag); - - Assert.AreEqual(ans.Datas["A1"].DeviceValue, dic1["A1"]); - Assert.AreEqual(ans.Datas["A2"].DeviceValue, dic1["A2"]); - Assert.AreEqual(ans.Datas["A3"].DeviceValue, dic1["A3"]); - Assert.AreEqual(ans.Datas["A4"].DeviceValue, dic1["A4"]); - Assert.AreEqual(ans.Datas["A5"].DeviceValue, dic1["A5"]); - Assert.AreEqual(ans.Datas["A6"].DeviceValue, dic1["A6"]); - - Assert.AreEqual(ans2.Datas["A1"].DeviceValue, dic1["A1"]); - Assert.AreEqual(ans2.Datas["A2"].DeviceValue, dic1["A2"]); - Assert.AreEqual(ans2.Datas["A3"].DeviceValue, dic1["A3"]); - Assert.AreEqual(ans2.Datas["A4"].DeviceValue, dic1["A4"]); - Assert.AreEqual(ans2.Datas["A5"].DeviceValue, dic1["A5"]); - Assert.AreEqual(ans2.Datas["A6"].DeviceValue, dic1["A6"]); - } - - [TestCleanup] - public void MachineClean() - { - _siemensTcpMachine!.Disconnect(); - - _siemensPpiMachine!.Disconnect(); - } } }