Etusivu Tutki Apua
Kirjaudu sis盲盲n
leo
/
YZWater3
1
0
Fork 0
Tiedostot Ongelmat 0 Pull-pyynn枚t 0 Wiki
Puu: 82f3eadd15
Haarat Tagit
YZWater3
/
docs
/
瑗块棬瀛怱7閫氫俊鎸囧崡.md

瑗块棬瀛怱7閫氫俊鎸囧崡.md 55 KB
Historia Raaka

瑗块棬瀛 S7 PLC 閫氫俊鎸囧崡

鍩轰簬 HslCommunication 搴擄紝鎻愬彇鑷 YZWater3 椤圭洰锛屽彲鐩存帴澶嶇敤浜庡叾浠 .NET 椤圭洰銆

鐩綍

姒傝堪

鏈」鐩娇鐢 HslCommunication 宸ヤ笟閫氫俊搴撲笌瑗块棬瀛 S7 绯诲垪 PLC 杩涜閫氫俊銆

鏍稿績鐗规

  • 鏀寔 S7-200 / S7-200Smart / S7-300 / S7-400 / S7-1200 / S7-1500
  • 寮傛璇诲啓锛屾敮鎸 Float / Bool / byte[] 绛夋暟鎹被鍨
  • 鎵归噺璇诲彇浼樺寲锛堣繛缁湴鍧鍚堝苟锛
  • 鑷姩閲嶈繛鏈哄埗
  • 澶х搴/灏忕搴忚嚜鍔ㄨ浆鎹

鎺堟潈閰嶇疆

HslCommunication 鏄晢涓氭巿鏉冨簱锛屼娇鐢ㄥ墠闇瑕佽缃巿鏉冪爜銆

鎺堟潈鏂瑰紡

鏂瑰紡 璇存槑
鍏嶈垂璇曠敤 涓嶈缃巿鏉冪爜锛屽姛鑳藉彈闄愶紙闅忔満鏂紑銆侀儴鍒 API 涓嶅彲鐢級
姝ｅ紡鎺堟潈 璐拱鎺堟潈鐮佸悗閫氳繃 SetAuthorizationCode() 婵娲

璁剧疆鎺堟潈鐮

蹇呴』鍦ㄥ垱寤 PLC 閫氫俊瀵硅薄涔嬪墠璋冪敤锛屽缓璁湪绋嬪簭鍚姩鍏ュ彛锛堝 Main() 鎴 App.OnStartup()锛変腑璋冪敤锛

using HslCommunication;

// 鍦ㄧ▼搴忓惎鍔ㄦ椂璁剧疆鎺堟潈鐮侊紙蹇呴』鍦ㄤ娇鐢ㄤ换浣 PLC 鍔熻兘涔嬪墠璋冪敤锛
HslCommunication.Authorization.SetAuthorizationCode("浣犵殑鎺堟潈鐮");

鍦 Avalonia 涓殑搴旂敤绀轰緥

// App.axaml.cs
public class App : Application
{
    public override void OnFrameworkInitializationCompleted()
    {
        // 婵娲 HslCommunication 鎺堟潈锛堝湪鎵鏈 PLC 鎿嶄綔涔嬪墠锛
        HslCommunication.Authorization.SetAuthorizationCode(
            "c765bac7-2caf-446d-9619-f67e19d6624e");

        // 鍚庣画鍒濆鍖...
        base.OnFrameworkInitializationCompleted();
    }
}

鍦 WPF / WinForms 涓殑搴旂敤绀轰緥

// Program.cs 鎴 App.xaml.cs
[STAThread]
static void Main()
{
    // 鍦 Application 鍚姩鍓嶈缃
    HslCommunication.Authorization.SetAuthorizationCode("浣犵殑鎺堟潈鐮");

    App domain = new App();
    domain.InitializeComponent();
    domain.Run();
}

鎺堟潈鐩稿叧 API

// 妫鏌ユ巿鏉冪姸鎬
bool isAuthorized = HslCommunication.Authorization.IsAuthorized();

// 鑾峰彇鎺堟潈鍒版湡鏃堕棿
DateTime expireDate = HslCommunication.Authorization.GetExpireDate();

// 鑾峰彇鎺堟潈璁惧鏁伴噺闄愬埗
int deviceCount = HslCommunication.Authorization.GetDeviceCount();

鏈巿鏉冩椂鐨勮〃鐜

  • 杩炴帴浼氶殢鏈烘柇寮锛堜笉瀹氭椂涓㈠け杩炴帴锛
  • 閮ㄥ垎楂樼骇鍔熻兘涓嶅彲鐢
  • 鏁版嵁璇诲彇鍙兘鍑虹幇寮傚父

娉ㄦ剰锛氭湰椤圭洰浣跨敤鐨勬巿鏉冪爜 c765bac7-2caf-446d-9619-f67e19d6624e 浠呴檺鏈」鐩娇鐢ㄣ
鍏朵粬椤圭洰璇峰墠寰 HslCommunication 瀹樼綉 璐拱鎺堟潈銆

渚濊禆瀹夎

NuGet 鍖

<PackageReference Include="HslCommunication" Version="11.8.2" />

瀹夎鍛戒护

# Package Manager
Install-Package HslCommunication

# .NET CLI
dotnet add package HslCommunication

杩炴帴寤虹珛

鍩虹杩炴帴绫

using HslCommunication;
using HslCommunication.Profinet.Siemens;

public class SiemensPlcHelper
{
    private SiemensS7Net? _plc;
    private bool _isConnected;

    public bool IsConnected => _isConnected;

    /// <summary>
    /// 鍒濆鍖栧苟杩炴帴 PLC
    /// </summary>
    public async Task<bool> ConnectAsync(string ip, int port = 102, 
        SiemensPLCS series = SiemensPLCS.S200Smart)
    {
        _plc = new SiemensS7Net(series, ip)
        {
            Port = port,
            ConnectTimeOut = 3000,   // 杩炴帴瓒呮椂 3绉
            ReceiveTimeOut = 3000    // 鎺ユ敹瓒呮椂 3绉
        };

        var result = await _plc.ConnectServerAsync();
        _isConnected = result.IsSuccess;
        return _isConnected;
    }

    /// <summary>
    /// 鏂紑杩炴帴
    /// </summary>
    public void Disconnect()
    {
        _plc?.ConnectClose();
        _isConnected = false;
    }

    /// <summary>
    /// 閲婃斁璧勬簮
    /// </summary>
    public void Dispose()
    {
        Disconnect();
        _plc?.Dispose();
        _plc = null;
    }
}

杩炴帴鍙傛暟璇存槑

鍙傛暟 璇存槑 榛樿鍊
ip PLC 鐨 IP 鍦板潃 蹇呭～
port 绔彛鍙 102
series PLC 绯诲垪 SiemensPLCS.S200Smart
ConnectTimeOut 杩炴帴瓒呮椂锛堟绉掞級 3000
ReceiveTimeOut 鎺ユ敹瓒呮椂锛堟绉掞級 3000

鏁版嵁璇诲彇

璇诲彇娴偣鏁帮紙REAL锛

/// <summary>
/// 璇诲彇娴偣鏁 (4瀛楄妭 REAL)
/// </summary>
public async Task<float> ReadFloatAsync(string address)
{
    if (!_isConnected || _plc == null) return 0f;
    
    var result = await _plc.ReadFloatAsync(address);  // 濡 "VD100"
    return result.IsSuccess ? result.Content : 0f;
}

璇诲彇甯冨皵鍊硷紙浣嶏級

/// <summary>
/// 璇诲彇甯冨皵鍊 (鍗曚釜浣)
/// </summary>
public async Task<bool> ReadBoolAsync(string address)
{
    if (!_isConnected || _plc == null) return false;
    
    var result = await _plc.ReadBoolAsync(address);   // 濡 "M10.0"
    return result.IsSuccess ? result.Content : false;
}

鎵归噺璇诲彇瀛楄妭锛堥珮鎬ц兘锛

/// <summary>
/// 鎵归噺璇诲彇瀛楄妭鏁扮粍
/// </summary>
public async Task<byte[]?> ReadBytesAsync(string address, ushort length)
{
    if (!_isConnected || _plc == null) return null;
    
    var result = await _plc.ReadAsync(address, length);  // 濡 "V100", 20
    return result.IsSuccess ? result.Content : null;
}

// 浣跨敤绀轰緥锛氫竴娆¤鍙 5 涓繛缁殑娴偣鏁
var bytes = await ReadBytesAsync("V100", 20);  // 浠 V100 寮濮嬭 20 瀛楄妭
if (bytes != null)
{
    var value1 = ParseFloat(bytes, 0);   // VD100
    var value2 = ParseFloat(bytes, 4);   // VD104
    var value3 = ParseFloat(bytes, 8);   // VD108
    var value4 = ParseFloat(bytes, 12);  // VD112
    var value5 = ParseFloat(bytes, 16);  // VD116
}

璇诲彇鏁存暟绫诲瀷

/// <summary>
/// 璇诲彇鏁存暟锛圛NT/WORD/DINT/DWORD锛
/// </summary>
public async Task<int> ReadIntAsync(string address, string dataType = "INT")
{
    if (!_isConnected || _plc == null) return 0;
    
    ushort length = dataType switch
    {
        "INT" or "WORD" => 2,
        "DINT" or "DWORD" => 4,
        _ => 2
    };
    
    var result = await _plc.ReadAsync(address, length);
    if (!result.IsSuccess || result.Content == null) return 0;
    
    var bytes = result.Content;
    if (BitConverter.IsLittleEndian)
    {
        Array.Reverse(bytes);
    }
    
    return dataType switch
    {
        "INT" => BitConverter.ToInt16(bytes, 0),
        "WORD" => BitConverter.ToUInt16(bytes, 0),
        "DINT" => BitConverter.ToInt32(bytes, 0),
        "DWORD" => (int)BitConverter.ToUInt32(bytes, 0),
        _ => 0
    };
}

鏁版嵁鍐欏叆

鍐欏叆娴偣鏁

/// <summary>
/// 鍐欏叆娴偣鏁
/// </summary>
public async Task<bool> WriteFloatAsync(string address, float value)
{
    if (!_isConnected || _plc == null) return false;
    
    var result = await _plc.WriteAsync(address, value);  // 濡 "VD100", 123.45f
    return result.IsSuccess;
}

鍐欏叆甯冨皵鍊

/// <summary>
/// 鍐欏叆甯冨皵鍊
/// </summary>
public async Task<bool> WriteBoolAsync(string address, bool value)
{
    if (!_isConnected || _plc == null) return false;
    
    var result = await _plc.WriteAsync(address, value);  // 濡 "M10.0", true
    return result.IsSuccess;
}

鍐欏叆鏁存暟

/// <summary>
/// 鍐欏叆鏁存暟
/// </summary>
public async Task<bool> WriteIntAsync(string address, int value, string dataType = "INT")
{
    if (!_isConnected || _plc == null) return false;
    
    object data = dataType switch
    {
        "INT" => (short)value,
        "WORD" => (ushort)value,
        "DINT" => value,
        "DWORD" => (uint)value,
        _ => (short)value
    };
    
    var result = await _plc.WriteAsync(address, data);
    return result.IsSuccess;
}

瀛楄妭搴忓鐞

閲嶈锛氳タ闂ㄥ瓙 S7 PLC 浣跨敤 澶х搴忥紙Big-Endian锛锛岃 Windows 浣跨敤 灏忕搴忥紙Little-Endian锛锛岃鍙栧瓧鑺傚悗闇瑕佽繘琛岃浆鎹€

娴偣鏁拌В鏋

/// <summary>
/// 浠庡瓧鑺傛暟缁勮В鏋愭诞鐐规暟锛圫7 澶х搴 鈫 鏈湴灏忕搴忥級
/// </summary>
public static float ParseFloat(byte[] data, int offset)
{
    if (data == null || offset + 4 > data.Length) return 0f;
    
    if (BitConverter.IsLittleEndian)
    {
        // S7 鏄ぇ绔簭锛岄渶瑕佺炕杞瓧鑺
        var bytes = new byte[] { 
            data[offset + 3], data[offset + 2], 
            data[offset + 1], data[offset] 
        };
        return BitConverter.ToSingle(bytes, 0);
    }
    return BitConverter.ToSingle(data, offset);
}

浣嶈В鏋

/// <summary>
/// 浠庡瓧鑺備腑鎻愬彇鐗瑰畾浣
/// </summary>
public static bool ParseBit(byte[] data, int byteOffset, int bitOffset)
{
    if (data == null || byteOffset >= data.Length) return false;
    return (data[byteOffset] & (1 << bitOffset)) != 0;
}

鍦板潃閰嶇疆绠＄悊 PlcConfig

灏嗘墍鏈 PLC 鍦板潃闆嗕腑绠＄悊锛屾敮鎸佷粠閰嶇疆鏂囦欢瑕嗙洊锛岄伩鍏嶇‖缂栫爜鏁ｈ惤鍚勫銆

using System.Text.Json;

/// <summary>
/// PLC 鍦板潃閰嶇疆 - 鎵鏈夊湴鍧鏄犲皠闆嗕腑绠＄悊锛屾敮鎸侀厤缃枃浠惰鐩
/// </summary>
public static class PlcConfig
{
    // 鍦板潃瑕嗙洊琛紙浠庨厤缃枃浠跺姞杞斤級
    private static Dictionary<string, string> _overrides = new();

    /// <summary>
    /// 浠庨厤缃枃浠跺姞杞藉湴鍧瑕嗙洊
    /// </summary>
    public static void LoadFromConfig(string configPath = "plc-addresses.json")
    {
        if (File.Exists(configPath))
        {
            var json = File.ReadAllText(configPath);
            _overrides = JsonSerializer.Deserialize<Dictionary<string, string>>(json) ?? new();
        }
    }

    /// <summary>
    /// 鑾峰彇鍦板潃锛堜紭鍏堜娇鐢ㄩ厤缃鐩栧硷級
    /// </summary>
    private static string Addr(string tagName, string defaultAddr)
    {
        return _overrides.TryGetValue(tagName, out var addr) ? addr : defaultAddr;
    }

    // 鈺愨晲鈺 璇诲彇鍦板潃 鈺愨晲鈺

    // 姘寸娑蹭綅 (float, VD)
    public static string Tank1Level => Addr(nameof(Tank1Level), "VD100");
    public static string Tank2Level => Addr(nameof(Tank2Level), "VD104");
    public static string Tank3Level => Addr(nameof(Tank3Level), "VD108");
    public static string Tank4Level => Addr(nameof(Tank4Level), "VD112");

    // 娴侀噺 (float, VD)
    public static string InflowRate  => Addr(nameof(InflowRate),  "VD200");
    public static string OutflowRate => Addr(nameof(OutflowRate), "VD204");

    // 娉佃繍琛岀姸鎬 (bool, Q)
    public const string Pump1Run = "Q0.0";
    public const string Pump2Run = "Q0.1";
    public const string Pump3Run = "Q0.2";
    public const string Pump4Run = "Q0.3";
    public const string Pump5Run = "Q0.4";

    // 娉垫晠闅 (bool, I)
    public const string Pump1Fault = "I0.0";
    public const string Pump2Fault = "I0.1";
    public const string Pump3Fault = "I0.2";
    public const string Pump4Fault = "I0.3";
    public const string Pump5Fault = "I0.4";

    // 娉甸鐜 (float, VD)
    public static string Pump1Freq => Addr(nameof(Pump1Freq), "VD300");
    public static string Pump2Freq => Addr(nameof(Pump2Freq), "VD304");
    public static string Pump3Freq => Addr(nameof(Pump3Freq), "VD308");
    public static string Pump4Freq => Addr(nameof(Pump4Freq), "VD312");
    public static string Pump5Freq => Addr(nameof(Pump5Freq), "VD316");

    // 娉电數娴 (float, VD)
    public static string Pump1Current => Addr(nameof(Pump1Current), "VD320");
    public static string Pump2Current => Addr(nameof(Pump2Current), "VD324");
    public static string Pump3Current => Addr(nameof(Pump3Current), "VD328");
    public static string Pump4Current => Addr(nameof(Pump4Current), "VD332");
    public static string Pump5Current => Addr(nameof(Pump5Current), "VD336");

    // 椋庢満 (bool)
    public const string Fan1Run  = "Q0.5";
    public const string Fan2Run  = "Q0.6";
    public const string Fan1Fault = "I0.5";
    public const string Fan2Fault = "I0.6";

    // 闃闂ㄤ綅缃 (int, VD)
    public static string Valve1Position => Addr(nameof(Valve1Position), "VD500");
    public static string Valve2Position => Addr(nameof(Valve2Position), "VD504");
    public static string Valve3Position => Addr(nameof(Valve3Position), "VD508");
    public static string Valve4Position => Addr(nameof(Valve4Position), "VD512");

    // 绯荤粺妯″紡 (bool, M)
    public const string SystemMode = "M0.0";

    // 鈺愨晲鈺 鍐欏叆鍦板潃 鈺愨晲鈺

    // 娉靛惎鍋滄帶鍒 (bool, Q)
    public const string Pump1Start = "Q0.0";
    public const string Pump2Start = "Q0.1";
    public const string Pump3Start = "Q0.2";
    public const string Pump4Start = "Q0.3";
    public const string Pump5Start = "Q0.4";

    // 椋庢満鍚仠 (bool, Q)
    public const string Fan1Start = "Q0.5";
    public const string Fan2Start = "Q0.6";

    // 闃闂ㄦ帶鍒 (bool, Q)
    public const string Valve1Control = "Q1.0";
    public const string Valve2Control = "Q1.1";
    public const string Valve3Control = "Q1.2";
    public const string Valve4Control = "Q1.3";

    // 娉甸鐜囪瀹 (float, VD)
    public const string PumpFreqSetpoint = "VD600";

    // 鈺愨晲鈺 杈呭姪鏂规硶 鈺愨晲鈺

    public static string GetPumpRunAddress(int index) => index switch
    {
        0 => Pump1Run, 1 => Pump2Run, 2 => Pump3Run, 3 => Pump4Run, 4 => Pump5Run,
        _ => throw new ArgumentOutOfRangeException(nameof(index))
    };

    public static string GetPumpFaultAddress(int index) => index switch
    {
        0 => Pump1Fault, 1 => Pump2Fault, 2 => Pump3Fault, 3 => Pump4Fault, 4 => Pump5Fault,
        _ => throw new ArgumentOutOfRangeException(nameof(index))
    };

    public static string GetPumpFreqAddress(int index) => index switch
    {
        0 => Pump1Freq, 1 => Pump2Freq, 2 => Pump3Freq, 3 => Pump4Freq, 4 => Pump5Freq,
        _ => throw new ArgumentOutOfRangeException(nameof(index))
    };

    public static string GetPumpCurrentAddress(int index) => index switch
    {
        0 => Pump1Current, 1 => Pump2Current, 2 => Pump3Current, 3 => Pump4Current, 4 => Pump5Current,
        _ => throw new ArgumentOutOfRangeException(nameof(index))
    };

    public static string GetValveControlAddress(int index) => index switch
    {
        0 => Valve1Control, 1 => Valve2Control, 2 => Valve3Control, 3 => Valve4Control,
        _ => throw new ArgumentOutOfRangeException(nameof(index))
    };

    public static string GetValvePositionAddress(int index) => index switch
    {
        0 => Valve1Position, 1 => Valve2Position, 2 => Valve3Position, 3 => Valve4Position,
        _ => throw new ArgumentOutOfRangeException(nameof(index))
    };
}

鍦板潃瑕嗙洊閰嶇疆鏂囦欢锛坧lc-addresses.json锛

{
    "Tank1Level": "VD100",
    "Tank2Level": "VD104",
    "InflowRate": "VD200",
    "OutflowRate": "VD204",
    "Pump1Freq": "VD300",
    "Pump2Freq": "VD304",
    "Pump1Current": "VD320",
    "Pump2Current": "VD324",
    "Valve1Position": "VD500",
    "Valve2Position": "VD504"
}

S7 鍦板潃瑙ｆ瀽鍣紙鎵归噺璇诲彇浼樺寲锛

灏嗗垎鏁ｇ殑鍦板潃鑷姩鍒嗙粍涓鸿繛缁尯闂达紝鍑忓皯 PLC 閫氫俊娆℃暟锛堜粠 N 娆￠檷涓 G 娆★級銆

using System.Text.RegularExpressions;

/// <summary>
/// 瑗块棬瀛 S7 鍦板潃瑙ｆ瀽宸ュ叿
/// 鏀寔鏍煎紡: V/VB/VW/VD/M/MB/MW/MD/I/Q/IB/QB/IW/QW
/// </summary>
public static class S7AddressParser
{
    public enum AreaType
    {
        Input,     // I - 杈撳叆
        Output,    // Q - 杈撳嚭
        Marker,    // M - 鏍囧織浣
        Variable   // V - 鍙橀噺瀛樺偍鍖
    }

    public record ParsedAddress(
        AreaType Area,
        int ByteOffset,
        int BitIndex,
        int ByteLength,
        string OriginalAddress
    );

    /// <summary>
    /// 瑙ｆ瀽 S7 鍦板潃
    /// </summary>
    public static ParsedAddress? Parse(string address)
    {
        if (string.IsNullOrEmpty(address)) return null;

        address = address.Trim().ToUpper();

        var match = Regex.Match(address,
            @"^(I|Q|M|V|IB|QB|MB|VB|IW|QW|MW|VW|ID|QD|MD|VD)(\d+)(?:\.(\d))?$");
        if (!match.Success) return null;

        var prefix = match.Groups[1].Value;
        var byteOffset = int.Parse(match.Groups[2].Value);
        var bitIndex = match.Groups[3].Success ? int.Parse(match.Groups[3].Value) : -1;

        AreaType area;
        int length;

        switch (prefix)
        {
            case "I":  case "IB": area = AreaType.Input;    length = 1; break;
            case "IW":            area = AreaType.Input;    length = 2; break;
            case "ID":            area = AreaType.Input;    length = 4; break;
            case "Q":  case "QB": area = AreaType.Output;   length = 1; break;
            case "QW":            area = AreaType.Output;   length = 2; break;
            case "QD":            area = AreaType.Output;   length = 4; break;
            case "M":  case "MB": area = AreaType.Marker;   length = 1; break;
            case "MW":            area = AreaType.Marker;   length = 2; break;
            case "MD":            area = AreaType.Marker;   length = 4; break;
            case "V":  case "VB": area = AreaType.Variable; length = 1; break;
            case "VW":            area = AreaType.Variable; length = 2; break;
            case "VD":            area = AreaType.Variable; length = 4; break;
            default: return null;
        }

        return new ParsedAddress(area, byteOffset, bitIndex, length, address);
    }

    /// <summary>
    /// 鍦板潃缁勶紙鐢ㄤ簬鎵归噺璇诲彇锛
    /// </summary>
    public record AddressGroup(
        AreaType Area,
        int StartByte,
        int TotalBytes,
        List<(string Key, int Offset)> Items
    );

    /// <summary>
    /// 灏嗗湴鍧鍒楄〃鍒嗙粍涓鸿繛缁殑鎵归噺璇诲彇缁
    /// </summary>
    /// <param name="addresses">鍦板潃鍒楄〃 (key, address)</param>
    /// <param name="maxGroupBytes">鍗曚釜鎵规鐨勬渶澶у瓧鑺傛暟锛堥粯璁 200锛</param>
    public static List<AddressGroup> GroupConsecutiveAddresses(
        List<(string Key, string Address)> addresses,
        int maxGroupBytes = 200)
    {
        var groups = new List<AddressGroup>();

        // 鎸夊尯鍩熷垎缁
        var byArea = addresses
            .Select(a => (a.Key, Parsed: Parse(a.Address)))
            .Where(a => a.Parsed != null)
            .GroupBy(a => a.Parsed!.Area);

        foreach (var areaGroup in byArea)
        {
            var sorted = areaGroup
                .OrderBy(a => a.Parsed!.ByteOffset)
                .ToList();

            var currentGroup = new List<(string Key, int Offset)>();
            int groupStart = 0;
            int groupEnd = 0;

            foreach (var item in sorted)
            {
                var offset = item.Parsed!.ByteOffset;
                var length = item.Parsed.ByteLength;

                if (currentGroup.Count == 0)
                {
                    groupStart = offset;
                    groupEnd = offset + length;
                    currentGroup.Add((item.Key, offset - groupStart));
                }
                else if (offset + length <= groupStart + maxGroupBytes &&
                         offset <= groupEnd + 4) // 鍏佽鏈澶 4 瀛楄妭闂撮殧
                {
                    groupEnd = Math.Max(groupEnd, offset + length);
                    currentGroup.Add((item.Key, offset - groupStart));
                }
                else
                {
                    // 淇濆瓨褰撳墠缁勶紝寮濮嬫柊缁
                    if (currentGroup.Count > 0)
                    {
                        groups.Add(new AddressGroup(
                            areaGroup.Key,
                            groupStart,
                            groupEnd - groupStart,
                            currentGroup
                        ));
                    }
                    groupStart = offset;
                    groupEnd = offset + length;
                    currentGroup = new List<(string Key, int Offset)> { (item.Key, 0) };
                }
            }

            if (currentGroup.Count > 0)
            {
                groups.Add(new AddressGroup(
                    areaGroup.Key,
                    groupStart,
                    groupEnd - groupStart,
                    currentGroup
                ));
            }
        }

        return groups;
    }

    /// <summary>
    /// 灏嗗尯鍩熺被鍨嬭浆鎹负鍙瘑鍒殑鍦板潃鍓嶇紑
    /// </summary>
    public static string GetAddressPrefix(AreaType area, int byteLength)
    {
        var prefix = area switch
        {
            AreaType.Input    => "I",
            AreaType.Output   => "Q",
            AreaType.Marker   => "M",
            AreaType.Variable => "V",
            _ => "V"
        };

        return byteLength switch
        {
            1 => prefix,
            2 => $"{prefix}W",
            4 => $"{prefix}D",
            _ => prefix
        };
    }
}

鎵归噺璇诲彇浣跨敤绀轰緥

// 寰呰鍙栫殑鍦板潃鍒楄〃
var addresses = new List<(string key, string addr)>
{
    ("Tank1Level", "VD100"),
    ("Tank2Level", "VD104"),
    ("Tank3Level", "VD108"),
    ("Tank4Level", "VD112"),
    ("InflowRate", "VD200"),
    ("OutflowRate", "VD204"),
};

// 鑷姩鍒嗙粍
var groups = S7AddressParser.GroupConsecutiveAddresses(addresses);
// 缁撴灉锛
//   缁1: VD100-VD112 (4涓湴鍧, 16瀛楄妭) 鈫 涓娆¤鍙
//   缁2: VD200-VD204 (2涓湴鍧, 8瀛楄妭)  鈫 涓娆¤鍙
// 鍘熼渶 6 娆￠氫俊 鈫 浼樺寲涓 2 娆

// 閫愮粍鎵归噺璇诲彇
var results = new Dictionary<string, float>();
foreach (var group in groups)
{
    var prefix = S7AddressParser.GetAddressPrefix(group.Area, group.TotalBytes switch
    {
        >= 4 => 4, >= 2 => 2, _ => 1
    });
    var batchAddr = $"{prefix}{group.StartByte}";

    var bytes = await plc.ReadBytesAsync(batchAddr, (ushort)group.TotalBytes);
    if (bytes == null) continue;

    foreach (var (key, offset) in group.Items)
    {
        if (offset + 4 <= bytes.Length)
            results[key] = ParseFloat(bytes, offset);
    }
}

鏁版嵁妯″瀷 PlcDataModel

鍐呭瓨鏁版嵁蹇収锛孶I 閫氳繃姝ゆā鍨嬬粦瀹氭樉绀烘暟鎹

using System.Collections.Concurrent;
using CommunityToolkit.Mvvm.ComponentModel;

/// <summary>
/// PLC 鏁版嵁妯″瀷 - 鍐呭瓨鏁版嵁蹇収
/// </summary>
public partial class PlcDataModel : ObservableObject
{
    // 鈺愨晲鈺 姘寸娑蹭綅 鈺愨晲鈺
    [ObservableProperty] private float _tank1Level;
    [ObservableProperty] private float _tank2Level;
    [ObservableProperty] private float _tank3Level;
    [ObservableProperty] private float _tank4Level;

    // 鈺愨晲鈺 娴侀噺 鈺愨晲鈺
    [ObservableProperty] private float _inflowRate;
    [ObservableProperty] private float _outflowRate;
    [ObservableProperty] private float _flowDelta;

    // 鈺愨晲鈺 娉电姸鎬 (0-4) 鈺愨晲鈺
    [ObservableProperty] private bool _pump1Running;
    [ObservableProperty] private bool _pump2Running;
    [ObservableProperty] private bool _pump3Running;
    [ObservableProperty] private bool _pump4Running;
    [ObservableProperty] private bool _pump5Running;

    // 娉垫晠闅
    [ObservableProperty] private bool _pump1Fault;
    [ObservableProperty] private bool _pump2Fault;
    [ObservableProperty] private bool _pump3Fault;
    [ObservableProperty] private bool _pump4Fault;
    [ObservableProperty] private bool _pump5Fault;

    // 娉甸鐜
    [ObservableProperty] private float _pump1Freq;
    [ObservableProperty] private float _pump2Freq;
    [ObservableProperty] private float _pump3Freq;
    [ObservableProperty] private float _pump4Freq;
    [ObservableProperty] private float _pump5Freq;

    // 娉电數娴
    [ObservableProperty] private float _pump1Current;
    [ObservableProperty] private float _pump2Current;
    [ObservableProperty] private float _pump3Current;
    [ObservableProperty] private float _pump4Current;
    [ObservableProperty] private float _pump5Current;

    // 鈺愨晲鈺 椋庢満鐘舵 鈺愨晲鈺
    [ObservableProperty] private bool _fan1Running;
    [ObservableProperty] private bool _fan2Running;
    [ObservableProperty] private bool _fan1Fault;
    [ObservableProperty] private bool _fan2Fault;

    // 鈺愨晲鈺 闃闂ㄤ綅缃 (0-100, 0=鍏ㄥ叧, 100=鍏ㄥ紑) 鈺愨晲鈺
    [ObservableProperty] private int _valve1Position;
    [ObservableProperty] private int _valve2Position;
    [ObservableProperty] private int _valve3Position;
    [ObservableProperty] private int _valve4Position;

    // 鈺愨晲鈺 绯荤粺鐘舵 鈺愨晲鈺
    [ObservableProperty] private bool _isAutoMode;

    // 鈺愨晲鈺 鏁版嵁璐ㄩ噺 鈺愨晲鈺
    [ObservableProperty] private DateTime _lastReadTime;
    [ObservableProperty] private bool _isDataValid;
    [ObservableProperty] private bool _isPlcConnected;

    // 鈺愨晲鈺 鍔ㄦ佸瘎瀛樺櫒锛堢敱椤圭洰閰嶇疆椹卞姩锛 鈺愨晲鈺
    /// <summary>妯℃嫙閲忓姩鎬佸瘎瀛樺櫒锛堝悕绉 鈫 鍊硷級</summary>
    public ConcurrentDictionary<string, float> AnalogRegisters { get; } = new();

    /// <summary>鏁板瓧閲忓姩鎬佸瘎瀛樺櫒锛堝悕绉 鈫 鍊硷級</summary>
    public ConcurrentDictionary<string, bool> DigitalRegisters { get; } = new();

    public float GetAnalogRegister(string key, float defaultValue = 0)
        => AnalogRegisters.TryGetValue(key, out var value) ? value : defaultValue;

    public bool GetDigitalRegister(string key, bool defaultValue = false)
        => DigitalRegisters.TryGetValue(key, out var value) ? value : defaultValue;

    // 鈺愨晲鈺 璁＄畻灞炴 鈺愨晲鈺
    public int RunningPumpCount => (Pump1Running ? 1 : 0) + (Pump2Running ? 1 : 0) +
                                   (Pump3Running ? 1 : 0) + (Pump4Running ? 1 : 0) +
                                   (Pump5Running ? 1 : 0);

    public bool HasAnyFault => Pump1Fault || Pump2Fault || Pump3Fault || Pump4Fault ||
                               Pump5Fault || Fan1Fault || Fan2Fault;
}

杞鏈嶅姟妯℃澘锛堝畬鏁寸増锛

鍖呭惈锛骞跺彂鎺у埗銆姝诲尯杩囨护銆闄嶇骇妯″紡銆鎸囨暟閫閬块噸杩銆鎵归噺璇诲彇浼樺寲銆

using System.Collections.Concurrent;
using HslCommunication;
using HslCommunication.Profinet.Siemens;
using Microsoft.Extensions.Logging;

public class PlcPollingService : IDisposable
{
    private SiemensS7Net? _plc;
    private bool _isConnected;
    private CancellationTokenSource? _cts;
    private Task? _pollingTask;
    private readonly PlcDataModel _data = new();

    // PLC 璇诲彇骞跺彂闄愬埗锛堥槻姝㈠悓鏃跺彂璧疯繃澶氳姹傚鑷 PLC 杩囪浇锛
    private static readonly SemaphoreSlim _plcReadSemaphore = new(4, 4);

    private readonly ILogger? _logger;

    // 鈺愨晲鈺 閰嶇疆 鈺愨晲鈺
    public int PollingIntervalMs { get; set; } = 1000;
    public float DeadbandPercent { get; set; } = 0.5f;
    public int MaxReconnectAttempts { get; set; } = 10;
    public int ReconnectBaseDelayMs { get; set; } = 1000;

    // 鈺愨晲鈺 浜嬩欢 鈺愨晲鈺
    public event Action<PlcDataModel>? DataUpdated;
    public event Action<bool>? ConnectionStateChanged;
    public event Action<string>? ErrorOccurred;

    public PlcDataModel Data => _data;
    public bool IsConnected => _isConnected;

    public PlcPollingService(ILogger? logger = null)
    {
        _logger = logger;
    }

    /// <summary>鍚姩杞</summary>
    public void Start(string ip, int port = 102, SiemensPLCS series = SiemensPLCS.S200Smart)
    {
        if (_pollingTask != null && !_pollingTask.IsCompleted) return;

        _cts = new CancellationTokenSource();
        _pollingTask = Task.Run(() => PollingLoopAsync(ip, port, series, _cts.Token));
    }

    /// <summary>鍋滄杞</summary>
    public void Stop()
    {
        _cts?.Cancel();
        _pollingTask?.Wait(TimeSpan.FromSeconds(5));
        _cts?.Dispose();
        _cts = null;
        _pollingTask = null;
        Disconnect();
    }

    private void Disconnect()
    {
        _plc?.ConnectClose();
        _plc?.Dispose();
        _plc = null;
        _isConnected = false;
    }

    /// <summary>杞涓诲惊鐜</summary>
    private async Task PollingLoopAsync(string ip, int port, SiemensPLCS series, CancellationToken ct)
    {
        var reconnectAttempts = 0;
        var isInDegradedMode = false;
        const int degradedModeRetryIntervalMs = 30000;

        while (!ct.IsCancellationRequested)
        {
            try
            {
                // 1. 纭繚杩炴帴
                if (!_isConnected)
                {
                    var connected = await TryConnectWithRetryAsync(ip, port, series, reconnectAttempts, ct);
                    
                    if (!connected)
                    {
                        reconnectAttempts++;

                        // 杩涘叆鎴栦繚鎸佸湪闄嶇骇妯″紡
                        if (reconnectAttempts >= MaxReconnectAttempts)
                        {
                            if (!isInDegradedMode)
                            {
                                isInDegradedMode = true;
                                ErrorOccurred?.Invoke(
                                    $"PLC 杩炴帴澶辫触锛屽凡閲嶈瘯 {MaxReconnectAttempts} 娆★紝杩涘叆闄嶇骇妯″紡锛堟瘡 30 绉掗噸璇曪級");
                            }
                            await Task.Delay(degradedModeRetryIntervalMs, ct);
                            continue;
                        }

                        // 姝ｅ父妯″紡锛氭寚鏁伴閬
                        var delayMs = ReconnectBaseDelayMs * Math.Min(reconnectAttempts, 5);
                        await Task.Delay(delayMs, ct);
                        continue;
                    }

                    // 杩炴帴鎴愬姛
                    if (isInDegradedMode)
                    {
                        isInDegradedMode = false;
                        ErrorOccurred?.Invoke("PLC 杩炴帴宸叉仮澶");
                    }
                    reconnectAttempts = 0;
                }

                // 2. 璇诲彇鏁版嵁
                await ReadAllDataAsync(ct);

                // 3. 妫娴嬭繛鎺ョ姸鎬佸彉鍖
                ConnectionStateChanged?.Invoke(_isConnected);

                // 4. 鏁版嵁鏇存柊浜嬩欢
                DataUpdated?.Invoke(_data);

                // 5. 绛夊緟涓嬩竴鍛ㄦ湡
                var nextDelay = isInDegradedMode ? degradedModeRetryIntervalMs : PollingIntervalMs;
                await Task.Delay(nextDelay, ct);
            }
            catch (OperationCanceledException) { break; }
            catch (Exception ex)
            {
                _logger?.LogError(ex, "杞寮傚父");
                ErrorOccurred?.Invoke($"杞寮傚父: {ex.Message}");
                if (!_isConnected) _data.IsPlcConnected = false;
                await Task.Delay(PollingIntervalMs * 2, ct);
            }
        }
    }

    /// <summary>灏濊瘯杩炴帴锛堝甫閲嶈瘯锛</summary>
    private async Task<bool> TryConnectWithRetryAsync(
        string ip, int port, SiemensPLCS series, int attempt, CancellationToken ct)
    {
        for (int i = 0; i <= attempt && i < 3; i++)
        {
            if (ct.IsCancellationRequested) return false;

            var connected = await ConnectAsync(ip, port, series);
            if (connected)
            {
                _data.IsPlcConnected = true;
                ConnectionStateChanged?.Invoke(true);
                return true;
            }

            if (i < attempt)
                await Task.Delay(ReconnectBaseDelayMs * (i + 1), ct);
        }
        return false;
    }

    private async Task<bool> ConnectAsync(string ip, int port, SiemensPLCS series)
    {
        try
        {
            _plc = new SiemensS7Net(series, ip)
            {
                Port = port,
                ConnectTimeOut = 3000,
                ReceiveTimeOut = 3000
            };

            var result = await _plc.ConnectServerAsync();
            _isConnected = result.IsSuccess;
            
            if (_isConnected)
                _logger?.LogInformation("PLC 杩炴帴鎴愬姛: {Ip}:{Port}", ip, port);
            else
                _logger?.LogWarning("PLC 杩炴帴澶辫触: {Message}", result.Message);

            return _isConnected;
        }
        catch (Exception ex)
        {
            _logger?.LogError(ex, "PLC 杩炴帴寮傚父");
            return false;
        }
    }

    /// <summary>鎵归噺璇诲彇鎵鏈 PLC 鏁版嵁</summary>
    private async Task ReadAllDataAsync(CancellationToken ct)
    {
        if (ct.IsCancellationRequested) return;

        // 骞惰鍙戣捣鎵鏈夋壒閲忚鍙
        var tankTask  = ReadBytesAsync(PlcConfig.Tank1Level, 16);  // 4 floats: 姘寸娑蹭綅
        var flowTask  = ReadBytesAsync(PlcConfig.InflowRate, 8);   // 2 floats: 娴侀噺
        var freqTask  = ReadBytesAsync(PlcConfig.Pump1Freq, 20);   // 5 floats: 娉甸鐜
        var qTask     = ReadBytesAsync("Q0", 1);                   // 1 byte: 娉/椋庢満杩愯鐘舵
        var iTask     = ReadBytesAsync("I0", 1);                   // 1 byte: 娉/椋庢満鏁呴殰鐘舵
        var mTask     = ReadBytesAsync("M0", 1);                   // 1 byte: 绯荤粺妯″紡

        await Task.WhenAll(tankTask, flowTask, freqTask, qTask, iTask, mTask);

        if (ct.IsCancellationRequested) return;

        var tankData = tankTask.Result;
        var flowData = flowTask.Result;
        var freqData = freqTask.Result;
        var qData    = qTask.Result;
        var iData    = iTask.Result;
        var mData    = mTask.Result;

        // 浠讳竴鎵归噺璇诲彇澶辫触鍒欒烦杩囨湰鍛ㄦ湡
        if (tankData == null || flowData == null || freqData == null ||
            qData == null || iData == null || mData == null)
        {
            _data.IsDataValid = false;
            _data.IsPlcConnected = _isConnected;
            return;
        }

        // 瑙ｆ瀽姘寸娑蹭綅 (VD100-VD112, 4 floats)
        var tank1 = ParseFloat(tankData, 0);
        var tank2 = ParseFloat(tankData, 4);
        var tank3 = ParseFloat(tankData, 8);
        var tank4 = ParseFloat(tankData, 12);

        // 瑙ｆ瀽娴侀噺 (VD200-VD204, 2 floats)
        var inflow  = ParseFloat(flowData, 0);
        var outflow = ParseFloat(flowData, 4);

        // 瑙ｆ瀽娉甸鐜 (VD300-VD316, 5 floats)
        var f1 = ParseFloat(freqData, 0);
        var f2 = ParseFloat(freqData, 4);
        var f3 = ParseFloat(freqData, 8);
        var f4 = ParseFloat(freqData, 12);
        var f5 = ParseFloat(freqData, 16);

        // 瑙ｆ瀽 Q0 瀛楄妭: bit 0-4 = 娉佃繍琛, bit 5-6 = 椋庢満杩愯
        var p1   = ParseBit(qData, 0, 0);
        var p2   = ParseBit(qData, 0, 1);
        var p3   = ParseBit(qData, 0, 2);
        var p4   = ParseBit(qData, 0, 3);
        var p5   = ParseBit(qData, 0, 4);
        var fan1 = ParseBit(qData, 0, 5);
        var fan2 = ParseBit(qData, 0, 6);

        // 瑙ｆ瀽 I0 瀛楄妭: bit 0-4 = 娉垫晠闅, bit 5-6 = 椋庢満鏁呴殰
        var pf1   = ParseBit(iData, 0, 0);
        var pf2   = ParseBit(iData, 0, 1);
        var pf3   = ParseBit(iData, 0, 2);
        var pf4   = ParseBit(iData, 0, 3);
        var pf5   = ParseBit(iData, 0, 4);
        var fanf1 = ParseBit(iData, 0, 5);
        var fanf2 = ParseBit(iData, 0, 6);

        // 瑙ｆ瀽 M0 瀛楄妭: bit 0 = 绯荤粺妯″紡
        var autoMode = ParseBit(mData, 0, 0);

        // 搴旂敤姝诲尯杩囨护鍚庢洿鏂版暟鎹
        ApplyWithDeadband(_data.Tank1Level, tank1, v => _data.Tank1Level = v);
        ApplyWithDeadband(_data.Tank2Level, tank2, v => _data.Tank2Level = v);
        ApplyWithDeadband(_data.Tank3Level, tank3, v => _data.Tank3Level = v);
        ApplyWithDeadband(_data.Tank4Level, tank4, v => _data.Tank4Level = v);
        ApplyWithDeadband(_data.InflowRate, inflow,   v => _data.InflowRate = v);
        ApplyWithDeadband(_data.OutflowRate, outflow, v => _data.OutflowRate = v);

        _data.Pump1Running = p1;  _data.Pump2Running = p2;  _data.Pump3Running = p3;
        _data.Pump4Running = p4;  _data.Pump5Running = p5;

        _data.Pump1Fault = pf1;  _data.Pump2Fault = pf2;  _data.Pump3Fault = pf3;
        _data.Pump4Fault = pf4;  _data.Pump5Fault = pf5;

        _data.Pump1Freq = f1;  _data.Pump2Freq = f2;  _data.Pump3Freq = f3;
        _data.Pump4Freq = f4;  _data.Pump5Freq = f5;

        _data.Fan1Running = fan1;  _data.Fan2Running = fan2;
        _data.Fan1Fault = fanf1;   _data.Fan2Fault = fanf2;

        _data.IsAutoMode = autoMode;
        _data.LastReadTime = DateTime.Now;
        _data.IsDataValid = true;
        _data.IsPlcConnected = _isConnected;
        _data.FlowDelta = _data.InflowRate - _data.OutflowRate;
    }

    /// <summary>
    /// 甯﹀苟鍙戞帶鍒剁殑瀛楄妭璇诲彇
    /// </summary>
    private async Task<byte[]?> ReadBytesAsync(string address, ushort length)
    {
        if (!_isConnected || _plc == null) return null;

        await _plcReadSemaphore.WaitAsync();
        try
        {
            var result = await _plc.ReadAsync(address, length);
            if (!result.IsSuccess)
            {
                _isConnected = false;
                return null;
            }
            return result.Content;
        }
        catch
        {
            _isConnected = false;
            return null;
        }
        finally
        {
            _plcReadSemaphore.Release();
        }
    }

    /// <summary>
    /// 姝诲尯杩囨护锛氬彧鏈夊彉鍖栬秴杩囬槇鍊兼墠鏇存柊锛堝噺灏 UI 鏃犳晥鍒锋柊锛
    /// </summary>
    private void ApplyWithDeadband(float currentValue, float newValue, Action<float> setter)
    {
        if (Math.Abs(currentValue) < 0.001f && Math.Abs(newValue) < 0.001f)
            return; // 閮芥槸闆跺硷紝璺宠繃

        var threshold = Math.Abs(currentValue) * DeadbandPercent / 100.0f;
        if (Math.Abs(newValue - currentValue) > threshold || currentValue == 0)
        {
            setter(newValue);
        }
    }

    private static float ParseFloat(byte[] data, int offset)
    {
        if (data == null || offset + 4 > data.Length) return 0f;
        if (BitConverter.IsLittleEndian)
        {
            var bytes = new byte[] { 
                data[offset + 3], data[offset + 2], 
                data[offset + 1], data[offset] 
            };
            return BitConverter.ToSingle(bytes, 0);
        }
        return BitConverter.ToSingle(data, offset);
    }

    private static bool ParseBit(byte[] data, int byteOffset, int bitOffset)
    {
        if (data == null || byteOffset >= data.Length) return false;
        return (data[byteOffset] & (1 << bitOffset)) != 0;
    }

    public void Dispose() => Stop();
}

鍏抽敭鏈哄埗璇存槑

鏈哄埗 瀹炵幇鏂瑰紡 璇存槑
骞跺彂鎺у埗 SemaphoreSlim(4, 4) 闄愬埗鍚屾椂鍙戣捣鐨 PLC 璇诲彇璇锋眰鏁帮紝闃叉 PLC 杩囪浇
姝诲尯杩囨护 ApplyWithDeadband() 鏁版嵁鍙樺寲灏忎簬闃堝硷紙榛樿 0.5%锛夋椂涓嶆洿鏂帮紝鍑忓皯 UI 鏃犳晥鍒锋柊
闄嶇骇妯″紡 isInDegradedMode 杩炴帴澶辫触瓒呰繃 MaxReconnectAttempts 娆″悗杩涘叆锛岄噸璇曢棿闅斾粠 1s 寤堕暱鍒 30s
鎸囨暟閫閬 ReconnectBaseDelayMs * attempts 閲嶈繛闂撮殧閫愭澧炲姞锛屼笂闄 30s锛岄伩鍏嶉绻佸啿鍑 PLC
骞惰鎵归噺璇诲彇 Task.WhenAll() 澶氫釜鍦板潃娈靛苟琛屽彂璧疯鍙栵紝鍏呭垎鍒╃敤缃戠粶甯﹀

鍦板潃鏍煎紡鍙傝

瀛樺偍鍖哄煙

鍖哄煙 璇存槑 鍦板潃鍓嶇紑
V 鍙橀噺瀛樺偍鍖猴紙Variable锛 V / VB / VW / VD
M 鏍囧織浣嶏紙Marker锛 M / MB / MW / MD
I 杈撳叆鏄犲儚鍖猴紙Input锛 I / IB / IW / ID
Q 杈撳嚭鏄犲儚鍖猴紙Output锛 Q / QB / QW / QD

鏁版嵁绫诲瀷涓庡湴鍧鏍煎紡

鏁版嵁绫诲瀷 瀛楄妭闀垮害 鍦板潃鏍煎紡绀轰緥 璇存槑
Bool锛堜綅锛 1 bit M10.0, Q0.5 瀛楄妭鍋忕Щ.浣嶇储寮
Byte 1 VB100, MB10 鍗曞瓧鑺
Word/INT 2 VW100, MW10 16浣嶆暣鏁
DWord/REAL 4 VD100, MD10 32浣嶆诞鐐规暟
DWord/DINT 4 VD100, MD10 32浣嶆暣鏁

甯哥敤鍦板潃绀轰緥

// 娴偣鏁拌鍙
"VD100"   // V鍖虹100瀛楄妭寮濮嬬殑鍙屽瓧锛4瀛楄妭娴偣鏁帮級
"MD50"    // M鍖虹50瀛楄妭寮濮嬬殑鍙屽瓧

// 鏁存暟璇诲彇
"VW100"   // V鍖虹100瀛楄妭寮濮嬬殑瀛楋紙2瀛楄妭锛
"MW10"    // M鍖虹10瀛楄妭寮濮嬬殑瀛

// 甯冨皵鍊艰鍙
"M10.0"   // M鍖虹10瀛楄妭鐨勭0浣
"Q0.5"    // Q鍖虹0瀛楄妭鐨勭5浣
"V100.3"  // V鍖虹100瀛楄妭鐨勭3浣

// 瀛楄妭璇诲彇
"VB100"   // V鍖虹100瀛楄妭
"MB10"    // M鍖虹10瀛楄妭

閰嶇疆鏂囦欢缁撴瀯

椤圭洰浣跨敤 JSON 閰嶇疆鏂囦欢绠＄悊 PLC 杩炴帴鍙傛暟锛屾敮鎸佽繍琛屾椂淇敼銆

閰嶇疆鏂囦欢绀轰緥锛坹zwater-config.json锛

{
    "PlcIp": "192.168.2.100",
    "PlcPort": 102,
    "AutoConnect": true,
    "PlcProtocol": "SiemensS7",

    "LevelHighAlarm": 80.0,
    "LevelLowAlarm": 20.0,
    "FlowHighAlarm": 100.0,
    "FlowLowAlarm": 5.0,

    "PlcAddresses": {
        "Tank1Level": "VD100",
        "Tank2Level": "VD104",
        "InflowRate": "VD200",
        "OutflowRate": "VD204",
        "Pump1Freq": "VD300",
        "Pump1Current": "VD320"
    }
}

閰嶇疆妯″瀷绫

using System.Text.Json;
using System.Text.Json.Serialization;

public class SystemConfig
{
    // PLC 杩炴帴
    public string PlcIp { get; set; } = "192.168.2.100";
    public int PlcPort { get; set; } = 102;
    public bool AutoConnect { get; set; } = true;
    public string PlcProtocol { get; set; } = "SiemensS7";

    // 鎶ヨ闃堝
    public float LevelHighAlarm { get; set; } = 80f;
    public float LevelLowAlarm { get; set; } = 20f;
    public float FlowHighAlarm { get; set; } = 100f;
    public float FlowLowAlarm { get; set; } = 5f;

    // 鍦板潃瑕嗙洊
    public Dictionary<string, string>? PlcAddresses { get; set; }
}

public static class ConfigService
{
    private static SystemConfig? _config;
    private static readonly string ConfigPath = "yzwater-config.json";

    public static SystemConfig GetConfig()
    {
        if (_config == null) Load();
        return _config ?? new SystemConfig();
    }

    public static void Load()
    {
        if (File.Exists(ConfigPath))
        {
            var json = File.ReadAllText(ConfigPath);
            _config = JsonSerializer.Deserialize<SystemConfig>(json);
        }
        _config ??= new SystemConfig();
    }

    public static void Save()
    {
        if (_config == null) return;
        var options = new JsonSerializerOptions { WriteIndented = true };
        var json = JsonSerializer.Serialize(_config, options);
        File.WriteAllText(ConfigPath, json);
    }
}

閰嶇疆鍔犺浇椤哄簭

// 鍦ㄧ▼搴忓惎鍔ㄦ椂鎸夐『搴忓姞杞斤細

// 1. 鍔犺浇涓婚厤缃枃浠
ConfigService.Load();

// 2. 鍔犺浇鍦板潃瑕嗙洊锛堣鐩栭粯璁ょ‖缂栫爜鍦板潃锛
PlcConfig.LoadFromConfig();

// 3. 鍒濆鍖 PLC 鏈嶅姟
PlcService.Initialize();

椤圭洰鏂囦欢缁撴瀯

杩佺Щ鏃跺缓璁寜浠ヤ笅缁撴瀯缁勭粐鏂囦欢锛

YourProject/
鈹溾攢鈹 Services/
鈹   鈹溾攢鈹 Plc/
鈹   鈹   鈹溾攢鈹 SiemensPlcHelper.cs          # 鍩虹杩炴帴绫
鈹   鈹   鈹溾攢鈹 PlcPollingService.cs         # 杞鏈嶅姟锛堝畬鏁寸増锛
鈹   鈹   鈹溾攢鈹 PlcConfig.cs                 # 鍦板潃閰嶇疆绠＄悊
鈹   鈹   鈹斺攢鈹 S7AddressParser.cs           # 鍦板潃瑙ｆ瀽鍣
鈹   鈹
鈹   鈹溾攢鈹 ConfigService.cs                 # 閰嶇疆鏈嶅姟
鈹   鈹斺攢鈹 NotificationService.cs           # 閫氱煡鏈嶅姟锛堝彲閫夛級
鈹
鈹溾攢鈹 Models/
鈹   鈹溾攢鈹 SystemConfig.cs                  # 閰嶇疆妯″瀷
鈹   鈹斺攢鈹 PlcDataModel.cs                  # PLC 鏁版嵁妯″瀷
鈹
鈹溾攢鈹 ViewModels/                          # MVVM 椤圭洰
鈹   鈹斺攢鈹 MainViewModel.cs
鈹
鈹溾攢鈹 Views/                               # MVVM 椤圭洰
鈹   鈹斺攢鈹 MainWindow.axaml
鈹
鈹溾攢鈹 yzwater-config.json                  # 杩愯鏃堕厤缃
鈹溾攢鈹 plc-addresses.json                   # 鍦板潃瑕嗙洊锛堝彲閫夛級
鈹斺攢鈹 YourProject.csproj

NuGet 渚濊禆锛坈sproj锛

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net8.0</TargetFramework>
    <Nullable>enable</Nullable>
    <ImplicitUsings>enable</ImplicitUsings>
  </PropertyGroup>

  <ItemGroup>
    <!-- PLC 閫氫俊 -->
    <PackageReference Include="HslCommunication" Version="11.8.2" />
    
    <!-- MVVM锛堝彲閫夛紝WPF/Avalonia 椤圭洰锛 -->
    <PackageReference Include="CommunityToolkit.Mvvm" Version="8.2.2" />
    
    <!-- 鏃ュ織 -->
    <PackageReference Include="Serilog" Version="4.0.1" />
    <PackageReference Include="Serilog.Sinks.File" Version="6.0.0" />
    <PackageReference Include="Serilog.Sinks.Console" Version="6.0.0" />
    
    <!-- JSON 閰嶇疆 -->
    <PackageReference Include="System.Text.Json" Version="8.0.4" />
  </ItemGroup>
</Project>

浣跨敤绀轰緥

鍩虹浣跨敤

// 鍒涘缓杩炴帴
var plc = new SiemensPlcHelper();
var connected = await plc.ConnectAsync("192.168.0.150", 102);

if (connected)
{
    // 璇诲彇娴偣鏁
    var level = await plc.ReadFloatAsync("VD100");
    Console.WriteLine($"娑蹭綅: {level:F2}");

    // 璇诲彇甯冨皵鍊
    var pumpRun = await plc.ReadBoolAsync("M10.0");
    Console.WriteLine($"娉佃繍琛: {pumpRun}");

    // 鍐欏叆娴偣鏁
    await plc.WriteFloatAsync("VD200", 123.45f);

    // 鍐欏叆甯冨皵鍊
    await plc.WriteBoolAsync("M20.0", true);

    // 鎵归噺璇诲彇
    var bytes = await plc.ReadBytesAsync("V100", 20);
    if (bytes != null)
    {
        for (int i = 0; i < 5; i++)
        {
            var value = ParseFloat(bytes, i * 4);
            Console.WriteLine($"VD{100 + i * 4}: {value:F2}");
        }
    }
}

// 鏂紑杩炴帴
plc.Disconnect();

浣跨敤杞鏈嶅姟

// 鍒涘缓杞鏈嶅姟
var polling = new PlcPollingService();

// 璁㈤槄浜嬩欢
polling.DataUpdated += data => 
{
    Console.WriteLine($"娑蹭綅: {data.GetValueOrDefault("TankLevel"):F2}");
    Console.WriteLine($"娴侀噺: {data.GetValueOrDefault("FlowRate"):F2}");
};

polling.ConnectionStateChanged += connected =>
{
    Console.WriteLine(connected ? "PLC 宸茶繛鎺" : "PLC 宸叉柇寮");
};

polling.ErrorOccurred += error =>
{
    Console.WriteLine($"閿欒: {error}");
};

// 鍚姩锛圛P: 192.168.0.150, 绔彛: 102, S7-200Smart锛
polling.Start("192.168.0.150", 102, SiemensPLCS.S200Smart);

// 绋嬪簭閫鍑烘椂鍋滄
Console.WriteLine("鎸変换鎰忛敭鍋滄...");
Console.ReadKey();
polling.Stop();

澶氬崗璁┍鍔ㄦ娊璞★紙鍙夋墿灞曪級

濡傛灉椤圭洰鏈潵鍙兘闇瑕佸垏鎹 PLC 鍝佺墝锛堜笁鑿/娆у榫/Modbus 绛夛級锛屽彲浠ヤ娇鐢ㄧ粺涓鐨勯┍鍔ㄦ帴鍙ｆ娊璞°

IPlcDriver 鎺ュ彛

using HslCommunication;

/// <summary>
/// PLC 椹卞姩鎺ュ彛 - 缁熶竴鐨 PLC 閫氫俊鎶借薄
/// </summary>
public interface IPlcDriver : IDisposable
{
    string Name { get; }
    bool IsConnected { get; }

    Task<OperateResult> ConnectAsync();
    void Disconnect();

    Task<OperateResult<byte[]>> ReadBytesAsync(string address, ushort length);
    Task<OperateResult<float>> ReadFloatAsync(string address);
    Task<OperateResult<bool>> ReadBoolAsync(string address);

    Task<OperateResult> WriteAsync(string address, byte[] value);
    Task<OperateResult> WriteFloatAsync(string address, float value);
    Task<OperateResult> WriteBoolAsync(string address, bool value);
}

/// <summary>
/// PLC 鍗忚绫诲瀷
/// </summary>
public enum PlcProtocol
{
    SiemensS7,       // 瑗块棬瀛 S7
    MitsubishiMC,    // 涓夎彵 MC
    OmronFins,       // 娆у榫 Fins
    ModbusTcp,       // Modbus TCP
    AllenBradley     // AB EtherNet/IP
}

SiemensS7Driver 瀹炵幇

using HslCommunication;
using HslCommunication.Profinet.Siemens;

public class SiemensS7Driver : IPlcDriver
{
    private readonly SiemensS7Net _plc;
    private bool _disposed;
    private bool _isConnected;

    public string Name => "Siemens S7";
    public bool IsConnected => _isConnected && !_disposed;

    public SiemensS7Driver(SiemensPLCS plcSeries = SiemensPLCS.S200Smart)
    {
        _plc = new SiemensS7Net(plcSeries);
    }

    public void SetConnection(string ipAddress, int port = 102)
    {
        _plc.IpAddress = ipAddress;
        _plc.Port = port;
    }

    public async Task<OperateResult> ConnectAsync()
    {
        var result = await _plc.ConnectServerAsync();
        _isConnected = result.IsSuccess;
        return result;
    }

    public void Disconnect()
    {
        _plc.ConnectClose();
        _isConnected = false;
    }

    public async Task<OperateResult<byte[]>> ReadBytesAsync(string address, ushort length)
        => await _plc.ReadAsync(address, length);

    public async Task<OperateResult<float>> ReadFloatAsync(string address)
        => await _plc.ReadFloatAsync(address);

    public async Task<OperateResult<bool>> ReadBoolAsync(string address)
        => await _plc.ReadBoolAsync(address);

    public async Task<OperateResult> WriteAsync(string address, byte[] value)
        => await _plc.WriteAsync(address, value);

    public async Task<OperateResult> WriteFloatAsync(string address, float value)
        => await _plc.WriteAsync(address, value);

    public async Task<OperateResult> WriteBoolAsync(string address, bool value)
        => await _plc.WriteAsync(address, value);

    public void Dispose()
    {
        if (_disposed) return;
        _disposed = true;
        Disconnect();
        _plc.Dispose();
    }
}

PlcDriverFactory 宸ュ巶

public static class PlcDriverFactory
{
    public static IPlcDriver Create(PlcProtocol protocol, string ipAddress, int port)
    {
        IPlcDriver driver = protocol switch
        {
            PlcProtocol.SiemensS7 => CreateSiemensS7(ipAddress, port),
            // 鍙墿灞曞叾浠栧搧鐗...
            _ => throw new NotSupportedException($"涓嶆敮鎸佺殑 PLC 鍗忚: {protocol}")
        };
        return driver;
    }

    private static SiemensS7Driver CreateSiemensS7(string ipAddress, int port)
    {
        var driver = new SiemensS7Driver(SiemensPLCS.S200Smart);
        driver.SetConnection(ipAddress, port);
        return driver;
    }

    public static int GetDefaultPort(PlcProtocol protocol) => protocol switch
    {
        PlcProtocol.SiemensS7     => 102,
        PlcProtocol.MitsubishiMC  => 6000,
        PlcProtocol.OmronFins     => 9600,
        PlcProtocol.ModbusTcp     => 502,
        PlcProtocol.AllenBradley  => 44818,
        _ => throw new NotSupportedException($"涓嶆敮鎸佺殑 PLC 鍗忚: {protocol}")
    };
}

鏀寔鐨 PLC 绯诲垪

鏋氫妇鍊 PLC 鍨嬪彿 璇存槑
SiemensPLCS.S200 S7-200 鑰佸瀷鍙
SiemensPLCS.S200Smart S7-200 Smart 榛樿锛屽父鐢
SiemensPLCS.S300 S7-300 涓ぇ鍨
SiemensPLCS.S400 S7-400 澶у瀷
SiemensPLCS.S1200 S7-1200 鏂板瀷绱у噾鍨
SiemensPLCS.S1500 S7-1500 鏂板瀷楂樻ц兘

鎸囧畾 PLC 绯诲垪

// S7-1200
await plc.ConnectAsync("192.168.0.1", 102, SiemensPLCS.S1200);

// S7-1500
await plc.ConnectAsync("192.168.0.1", 102, SiemensPLCS.S1500);

// S7-300
await plc.ConnectAsync("192.168.0.1", 102, SiemensPLCS.S300);

甯歌闂

杩炴帴澶辫触

  1. 妫鏌 IP 鍦板潃鍜岀鍙ｆ槸鍚︽纭
  2. 纭 PLC 涓 PC 缃戠粶杩為氾紙ping 娴嬭瘯锛
  3. 妫鏌 PLC 鏄惁宸插惎鐢 PUT/GET 閫氫俊
  4. 纭闃茬伀澧欐湭闃绘 102 绔彛

璇诲彇鏁版嵁涓 0

  1. 纭鍦板潃鏍煎紡姝ｇ‘锛堝 VD100 鑰岄潪 V100锛
  2. 妫鏌ユ暟鎹被鍨嬫槸鍚﹀尮閰嶏紙娴偣鏁扮敤 VD锛屾暣鏁扮敤 VW锛
  3. 妫鏌ュ瓧鑺傚簭鏄惁姝ｇ‘锛堜娇鐢 ParseFloat 鏂规硶锛

璇诲彇鏁版嵁寮傚父

  1. 纭 PLC 绯诲垪閫夋嫨姝ｇ‘
  2. 妫鏌ュ湴鍧鑼冨洿鏄惁瓒呭嚭 PLC 瀹為檯閰嶇疆
  3. 浣跨敤 Wireshark 鎶撳寘鍒嗘瀽閫氫俊鏁版嵁

鎵归噺璇诲彇澶辫触

  1. 纭鍦板潃鍦ㄥ悓涓鍖哄煙鍐呰繛缁紙涓嶈兘璺ㄥ尯锛
  2. 璇诲彇闀垮害涓嶈瓒呰繃 PLC 闄愬埗锛圫7-200 鏈澶 240 瀛楄妭锛
  3. 浣跨敤 S7AddressParser.GroupConsecutiveAddresses() 鑷姩鍒嗙粍

杞鏈嶅姟 CPU 鍗犵敤楂

  1. 閫傚綋澧炲ぇ PollingIntervalMs锛堥粯璁 1000ms锛
  2. 澧炲ぇ DeadbandPercent 鍑忓皯 UI 鍒锋柊娆℃暟
  3. 浣跨敤鎵归噺璇诲彇鏇夸唬澶氭鍗曠嫭璇诲彇

鏃ュ織闆嗘垚锛圫erilog锛

using Serilog;

// 鍒濆鍖栨棩蹇楋紙绋嬪簭鍚姩鏃惰皟鐢ㄤ竴娆★級
public static void InitializeLogging()
{
    Log.Logger = new LoggerConfiguration()
        .MinimumLevel.Information()
        .WriteTo.Console()
        .WriteTo.File(
            path: "Logs/log-.txt",
            rollingInterval: RollingInterval.Day,
            outputTemplate: "{Timestamp:yyyy-MM-dd HH:mm:ss.fff} [{Level:u3}] {Message:lj}{NewLine}{Exception}")
        .CreateLogger();
}

// 鍦ㄧ▼搴忛鍑烘椂鍏抽棴
public static void CloseLogging()
{
    Log.CloseAndFlush();
}

鏃ュ織浣跨敤绀轰緥

Log.Information("PLC 杩炴帴鎴愬姛: {Ip}:{Port}", ip, port);
Log.Warning("PLC 杩炴帴澶辫触: {Message}", result.Message);
Log.Error(ex, "璇诲彇 PLC 鏁版嵁澶辫触锛屽湴鍧: {Address}", address);
Log.Debug("鎵归噺璇诲彇浼樺寲: {Count} 涓湴鍧鍚堝苟涓 {Groups} 娆¤鍙", count, groups);

蹇熻縼绉绘竻鍗

灏嗕互涓嬫枃浠跺鍒跺埌鏂伴」鐩嵆鍙畬鎴愯縼绉伙細

蹇呴渶鏂囦欢锛6 涓級

鏂囦欢 鍔熻兘 浣嶇疆
SiemensPlcHelper.cs 鍩虹杩炴帴绫 杩炴帴寤虹珛绔犺妭
PlcConfig.cs 鍦板潃閰嶇疆绠＄悊 鍦板潃閰嶇疆绠＄悊绔犺妭
S7AddressParser.cs 鍦板潃瑙ｆ瀽 + 鎵归噺浼樺寲 S7 鍦板潃瑙ｆ瀽鍣ㄧ珷鑺
PlcDataModel.cs 鏁版嵁妯″瀷 鏁版嵁妯″瀷绔犺妭
PlcPollingService.cs 杞鏈嶅姟锛堝畬鏁寸増锛 杞鏈嶅姟妯℃澘绔犺妭
ConfigService.cs + SystemConfig.cs 閰嶇疆鏈嶅姟 閰嶇疆鏂囦欢缁撴瀯绔犺妭

鍙夋枃浠

鏂囦欢 鍔熻兘
IPlcDriver.cs 澶氬崗璁┍鍔ㄦ帴鍙
SiemensS7Driver.cs S7 椹卞姩灏佽
PlcDriverFactory.cs 椹卞姩宸ュ巶
plc-addresses.json 鍦板潃瑕嗙洊閰嶇疆

NuGet 渚濊禆

<PackageReference Include="HslCommunication" Version="11.8.2" />
<PackageReference Include="CommunityToolkit.Mvvm" Version="8.2.2" />
<PackageReference Include="Serilog" Version="4.0.1" />
<PackageReference Include="Serilog.Sinks.File" Version="6.0.0" />
<PackageReference Include="Serilog.Sinks.Console" Version="6.0.0" />

鍚姩浠ｇ爜

// 绋嬪簭鍏ュ彛锛圥rogram.cs 鎴 App.OnStartup锛
public static async Task Main(string[] args)
{
    // 1. 鍒濆鍖栨棩蹇
    InitializeLogging();

    // 2. 璁剧疆 HslCommunication 鎺堟潈
    HslCommunication.Authorization.SetAuthorizationCode("浣犵殑鎺堟潈鐮");

    // 3. 鍔犺浇閰嶇疆
    ConfigService.Load();
    PlcConfig.LoadFromConfig();

    // 4. 鍚姩杞
    var polling = new PlcPollingService(Log.ForContext<PlcPollingService>());
    polling.DataUpdated += data => { /* 澶勭悊鏁版嵁鏇存柊 */ };
    polling.ConnectionStateChanged += connected => { /* 澶勭悊杩炴帴鐘舵 */ };
    polling.ErrorOccurred += error => { /* 澶勭悊閿欒 */ };

    var config = ConfigService.GetConfig();
    polling.Start(config.PlcIp, config.PlcPort);

    // 5. 绋嬪簭閫鍑烘椂
    // polling.Stop();
    // ConfigService.Save();
    // Log.CloseAndFlush();
}

璁稿彲璇

鏈枃妗ｅ熀浜 YZWater3 椤圭洰鎻愬彇锛屼粎渚涘弬鑰冧娇鐢ㄣ侶slCommunication 搴撹閬靛惊鍏跺畼鏂硅鍙瘉銆