guiyang-fluorescent-line-lmes-backend/Infrastructure/Helper/SiemensS7Helper.cs

using HslCommunication;
using HslCommunication.Core;
using HslCommunication.Profinet.Siemens;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;

namespace RIZO.Infrastructure.Helper
{


    /// <summary>
    /// 西门子S7-1500 PLC通信帮助类（简化版）
    /// </summary>
    public class SiemensS7Helper : IDisposable
    {
        private SiemensS7Net _plc;
        private bool _isConnected = false;

        /// <summary>
        /// 连接状态
        /// </summary>
        public bool IsConnected => _isConnected;

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="ip">PLC IP地址</param>
        public SiemensS7Helper(string ip)
        {
            _plc = new SiemensS7Net(SiemensPLCS.S1500)
            {
                IpAddress = ip,
                Port = 102
            };
        }

        /// <summary>
        /// 连接PLC
        /// </summary>
        public async Task<bool> ConnectAsync(CancellationToken cancellationToken = default)
        {
            int maxRetries = 3;
            int retryDelayMs = 2000;
            int attempt = 0;

            while (attempt < maxRetries)
            {
                attempt++;

                var result = await Task.Run(() => _plc.ConnectServer());
                _isConnected = result.IsSuccess;
                if (!_isConnected)
                {

                    Console.WriteLine($"连接尝试 {attempt}/{maxRetries} 失败");

                    if (attempt < maxRetries)
                    {
                        Console.WriteLine($"{retryDelayMs / 1000}秒后重试...");
                        await Task.Delay(retryDelayMs, cancellationToken);
                    }
                    else
                    {
                        Console.WriteLine("无法建立PLC连接，请检查网络和设备状态");
                        _plc?.ConnectClose();
                        _plc = null;
                        return _isConnected;
                    }
                }
            }
            return false;
        }

        /// <summary>
        /// 断开连接
        /// </summary>
        public void Disconnect()
        {
            _plc?.ConnectClose();
            _isConnected = false;
        }

        /// <summary>
        /// 读取字符串（重点）
        /// </summary>
        /// <param name="address">地址，如 "DB1.DB_STRING10"</param>
        /// <param name="length">字符串长度</param>
        public async Task<string> ReadStringAsync(string address, ushort length = 50)
        {
            if (!_isConnected) return null;

            var result = await Task.Run(() => _plc.ReadString(address, length));
            return result.IsSuccess ? result.Content : null;
        }

        /// <summary>
        /// 写入字符串（重点）
        /// </summary>
        /// <param name="address">地址</param>
        /// <param name="value">字符串值</param>
        /// <param name="length">字符串长度</param>
        public async Task<bool> WriteStringAsync(string address, string value, ushort length = 50)
        {
            if (!_isConnected) return false;

            var result = await Task.Run(() => _plc.Write(address, value, length));
            return result.IsSuccess;
        }

        /// <summary>
        /// 读取布尔值
        /// </summary>
        public async Task<bool?> ReadBoolAsync(string address)
        {
            if (!_isConnected) return null;

            var result = await Task.Run(() => _plc.ReadBool(address));
            return result.IsSuccess ? result.Content : (bool?)null;
        }

        /// <summary>
        /// 写入布尔值
        /// </summary>
        public async Task<bool> WriteBoolAsync(string address, bool value)
        {
            if (!_isConnected) return false;

            var result = await Task.Run(() => _plc.Write(address, value));
            return result.IsSuccess;
        }

        /// <summary>
        /// 读取整数
        /// </summary>
        public async Task<int?> ReadIntAsync(string address)
        {
            if (!_isConnected) return null;

            var result = await Task.Run(() => _plc.ReadInt32(address));
            return result.IsSuccess ? result.Content : (int?)null;
        }

        /// <summary>
        /// 写入整数
        /// </summary>
        public async Task<bool> WriteIntAsync(string address, int value)
        {
            if (!_isConnected) return false;

            var result = await Task.Run(() => _plc.Write(address, value));
            return result.IsSuccess;
        }

        /// <summary>
        /// 读取浮点数
        /// </summary>
        public async Task<float?> ReadFloatAsync(string address)
        {
            if (!_isConnected) return null;

            var result = await Task.Run(() => _plc.ReadFloat(address));
            return result.IsSuccess ? result.Content : (float?)null;
        }

        /// <summary>
        /// 写入浮点数
        /// </summary>
        public async Task<bool> WriteFloatAsync(string address, float value)
        {
            if (!_isConnected) return false;

            var result = await Task.Run(() => _plc.Write(address, value));
            return result.IsSuccess;
        }

        /// <summary>
        /// 释放资源
        /// </summary>
        public void Dispose()
        {
            Disconnect();
            _plc?.Dispose();
        }
    }

}