添加项目文件。

2026-07-29 13:12:27 +08:00
parent d6da766e2d
commit 8cf45d36b9
297 changed files with 35814 additions and 0 deletions
--- a/DeviceCommand/Flexible/FModbusRTU.cs
+++ b/DeviceCommand/Flexible/FModbusRTU.cs
@@ -0,0 +1,193 @@
+using Common.Attributes;
+using NModbus;
+using NModbus.Serial;
+using System;
+using System.IO.Ports;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace DeviceCommand.Flexible
+{
+    [ACPCommand]
+    public static class FModbusRTU
+    {
+        private static readonly SemaphoreSlim _commLock = new(1, 1);
+
+        private static SerialPort CreatePort(
+            string portName,
+            int baudRate,
+            int dataBits,
+            StopBits stopBits,
+            Parity parity,
+            int readTimeout,
+            int writeTimeout)
+        {
+            return new SerialPort(portName, baudRate, parity, dataBits, stopBits)
+            {
+                ReadTimeout = readTimeout > 0 ? readTimeout : SerialPort.InfiniteTimeout,
+                WriteTimeout = writeTimeout > 0 ? writeTimeout : SerialPort.InfiniteTimeout
+            };
+        }
+
+        private static IModbusMaster CreateMaster(SerialPort port)
+        {
+            return new ModbusFactory().CreateRtuMaster(port);
+        }
+
+        #region Holding Register
+
+        public static async Task<ushort[]> ReadHoldingRegistersAsync(
+            string portName,
+            int baudRate,
+            byte slaveAddress,
+            ushort startAddress,
+            ushort numberOfPoints,
+            int dataBits = 8,
+            StopBits stopBits = StopBits.One,
+            Parity parity = Parity.None,
+            int readTimeout = 3000,
+            int writeTimeout = 3000,
+            CancellationToken ct = default)
+        {
+            await _commLock.WaitAsync(ct);
+            try
+            {
+                using var port = CreatePort(
+                    portName, baudRate, dataBits, stopBits, parity, readTimeout, writeTimeout);
+
+                port.Open();
+
+                var master = CreateMaster(port);
+
+                using var cts = CancellationTokenSource.CreateLinkedTokenSource(ct);
+                if (readTimeout > 0)
+                    cts.CancelAfter(readTimeout);
+
+                return await master
+                    .ReadHoldingRegistersAsync(slaveAddress, startAddress, numberOfPoints)
+                    .WaitAsync(TimeSpan.FromMilliseconds(readTimeout),cts.Token);
+            }
+            finally
+            {
+                _commLock.Release();
+            }
+        }
+
+        public static async Task WriteSingleRegisterAsync(
+            string portName,
+            int baudRate,
+            byte slaveAddress,
+            ushort registerAddress,
+            ushort value,
+            int dataBits = 8,
+            StopBits stopBits = StopBits.One,
+            Parity parity = Parity.None,
+            int readTimeout = 3000,
+            int writeTimeout = 3000,
+            CancellationToken ct = default)
+        {
+            await _commLock.WaitAsync(ct);
+            try
+            {
+                using var port = CreatePort(
+                    portName, baudRate, dataBits, stopBits, parity, readTimeout, writeTimeout);
+
+                port.Open();
+
+                var master = CreateMaster(port);
+
+                using var cts = CancellationTokenSource.CreateLinkedTokenSource(ct);
+                if (writeTimeout > 0)
+                    cts.CancelAfter(writeTimeout);
+
+                await master
+                    .WriteSingleRegisterAsync(slaveAddress, registerAddress, value)
+                    .WaitAsync(TimeSpan.FromMilliseconds(writeTimeout),cts.Token);
+            }
+            finally
+            {
+                _commLock.Release();
+            }
+        }
+
+        #endregion
+
+        #region Coil
+
+        public static async Task<bool[]> ReadCoilsAsync(
+            string portName,
+            int baudRate,
+            byte slaveAddress,
+            ushort startAddress,
+            ushort numberOfPoints,
+            int dataBits = 8,
+            StopBits stopBits = StopBits.One,
+            Parity parity = Parity.None,
+            int readTimeout = 3000,
+            int writeTimeout = 3000,
+            CancellationToken ct = default)
+        {
+            await _commLock.WaitAsync(ct);
+            try
+            {
+                using var port = CreatePort(
+                    portName, baudRate, dataBits, stopBits, parity, readTimeout, writeTimeout);
+
+                port.Open();
+
+                var master = CreateMaster(port);
+
+                using var cts = CancellationTokenSource.CreateLinkedTokenSource(ct);
+                if (readTimeout > 0)
+                    cts.CancelAfter(readTimeout);
+
+                return await master
+                    .ReadCoilsAsync(slaveAddress, startAddress, numberOfPoints)
+                    .WaitAsync(TimeSpan.FromMilliseconds(readTimeout),cts.Token);
+            }
+            finally
+            {
+                _commLock.Release();
+            }
+        }
+
+        public static async Task WriteSingleCoilAsync(
+            string portName,
+            int baudRate,
+            byte slaveAddress,
+            ushort coilAddress,
+            bool value,
+            int dataBits = 8,
+            StopBits stopBits = StopBits.One,
+            Parity parity = Parity.None,
+            int readTimeout = 3000,
+            int writeTimeout = 3000,
+            CancellationToken ct = default)
+        {
+            await _commLock.WaitAsync(ct);
+            try
+            {
+                using var port = CreatePort(
+                    portName, baudRate, dataBits, stopBits, parity, readTimeout, writeTimeout);
+
+                port.Open();
+
+                var master = CreateMaster(port);
+
+                using var cts = CancellationTokenSource.CreateLinkedTokenSource(ct);
+                if (writeTimeout > 0)
+                    cts.CancelAfter(writeTimeout);
+
+                await master
+                    .WriteSingleCoilAsync(slaveAddress, coilAddress, value)
+                    .WaitAsync(TimeSpan.FromMilliseconds(writeTimeout), cts.Token);
+            }
+            finally
+            {
+                _commLock.Release();
+            }
+        }
+
+        #endregion
+    }
+}