借助网络配置,控制Modbus工具的日志显示,避免卡死界面
智能大石头 authored at 2021-12-11 22:09:19
17.43 KiB
XCoder
using System.Collections.ObjectModel;
using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;
using NewLife;
using NewLife.Data;
using NewLife.IoT.Protocols;
using NewLife.Log;
using NewLife.Messaging;
using NewLife.Net;
using NewLife.Security;
using NewLife.Threading;
using NewLife.XCoder.Tools.Modbus;
using NewLife.XCoder.Models;

using NewLife.XCoder.Services;

namespace NewLife.XCoder.ViewModels;

/// <summary>Modbus TCP 主站/从站模式</summary>
public enum ModbusTcpMode
{
    /// <summary>主站(Master)</summary>
    Master,

    /// <summary>从站(Slave)</summary>
    Slave
}

/// <summary>寄存器单元</summary>
public class RegisterUnit
{
    /// <summary>寄存器地址</summary>
    public Int32 Address { get; set; }

    /// <summary>寄存器数值</summary>
    public UInt16 Value { get; set; }

    /// <summary>十六进制显示</summary>
    public String Hex => Value.GetBytes(false).ToHex();
}

/// <summary>线圈单元</summary>
public class CoilUnit
{
    /// <summary>线圈地址</summary>
    public Int32 Address { get; set; }

    /// <summary>线圈数值</summary>
    public Byte Value { get; set; }
}

/// <summary>Modbus TCP 工具 ViewModel</summary>
public partial class ModbusTcpViewModel : ObservableObject, IDisposable
{
    #region 属性
    private ModbusTcp? _modbus;
    private NetServer? _server;
    private ModbusSlaveService? _slaveService;
    private TimerX? _timer;
    private List<RegisterUnit> _regs = [];
    private List<CoilUnit> _coils = [];

    /// <summary>功能码列表</summary>
    public ObservableCollection<String> FuncCodeOptions { get; } =
    [
        LocalizationService.T("01 读线圈"),
        LocalizationService.T("02 读离散量输入"),
        LocalizationService.T("03 读保持寄存器"),
        LocalizationService.T("04 读输入寄存器"),
        LocalizationService.T("05 写单线圈"),
        LocalizationService.T("06 写单寄存器"),
        LocalizationService.T("0F 写多线圈"),
        LocalizationService.T("10 写多寄存器"),
    ];

    /// <summary>工作模式列表</summary>
    public ObservableCollection<String> ModeOptions { get; } = [LocalizationService.T("主站(Master)"), LocalizationService.T("从站(Slave)")];

    /// <summary>寄存器数据模式列表</summary>
    public ObservableCollection<String> DataModeOptions { get; } = ["0x0000", "0x7777", "0xFFFF", LocalizationService.T("递增"), LocalizationService.T("静态随机"), LocalizationService.T("动态随机")];

    /// <summary>工作模式(0=Master, 1=Slave)</summary>
    [ObservableProperty]
    private Int32 _selectedMode;

    /// <summary>服务器地址</summary>
    [ObservableProperty]
    private String _serverAddress = "127.0.0.1";

    /// <summary>端口</summary>
    [ObservableProperty]
    private Int32 _port = 502;

    /// <summary>从站地址</summary>
    [ObservableProperty]
    private Byte _slaveAddress = 1;

    /// <summary>功能码索引</summary>
    [ObservableProperty]
    private Int32 _functionCodeIndex;

    /// <summary>起始地址</summary>
    [ObservableProperty]
    private UInt16 _startAddress;

    /// <summary>读取数量</summary>
    [ObservableProperty]
    private UInt16 _readCount = 10;

    /// <summary>写入值</summary>
    [ObservableProperty]
    private String _writeValue = "0";

    /// <summary>是否已连接</summary>
    [ObservableProperty]
    private Boolean _isConnected;

    /// <summary>连接按钮文本</summary>
    [ObservableProperty]
    private String _connectButtonText = LocalizationService.T("打开");

    /// <summary>读取结果</summary>
    [ObservableProperty]
    private String _readResult = "";

    /// <summary>从站数据模式索引</summary>
    [ObservableProperty]
    private Int32 _dataModeIndex;

    /// <summary>从站数据地址</summary>
    [ObservableProperty]
    private UInt16 _slaveDataAddress;

    /// <summary>从站数据数量</summary>
    [ObservableProperty]
    private UInt16 _slaveDataCount = 100;

    /// <summary>寄存器列表(从站模式)</summary>
    public ObservableCollection<RegisterUnit> Registers { get; } = [];

    /// <summary>线圈列表(从站模式)</summary>
    public ObservableCollection<CoilUnit> Coils { get; } = [];

    /// <summary>是否从站模式</summary>
    public Boolean IsSlaveMode => SelectedMode == 1;

    /// <summary>是否主站模式</summary>
    public Boolean IsMasterMode => SelectedMode == 0;

    /// <summary>日志文本</summary>
    [ObservableProperty]
    private String _log = "";

    /// <summary>轮询间隔(毫秒)</summary>
    [ObservableProperty]
    private Int32 _pollInterval = 1000;

    /// <summary>是否正在轮询</summary>
    [ObservableProperty]
    private Boolean _isPolling;

    /// <summary>轮询按钮文本</summary>
    [ObservableProperty]
    private String _pollButtonText = LocalizationService.T("开始轮询");

    /// <summary>轮询次数</summary>
    [ObservableProperty]
    private Int32 _pollCount;

    /// <summary>日志回调</summary>
    public Action<String>? OnLog { get; set; }
    #endregion

    #region 连接/断开
    /// <summary>切换连接/断开</summary>
    [RelayCommand]
    private void ToggleConnect()
    {
        if (IsConnected)
            Disconnect();
        else
            Connect();
    }

    private void Connect()
    {
        try
        {
            if (SelectedMode == 0)
                ConnectMaster();
            else
                ConnectSlave();
        }
        catch (Exception ex)
        {
            WriteLog($"连接失败:{ex.Message}", LogKind.Error);
        }
    }

    private void ConnectMaster()
    {
        // 自研 MBAP 主站(短连接、每帧一请求),不依赖带会话状态的驱动
        IsConnected = true;
        ConnectButtonText = LocalizationService.T("断开");

        WriteLog($"Modbus TCP 主站已就绪 {ServerAddress}:{Port}", LogKind.System);
    }

    private void ConnectSlave()
    {
        _slaveService?.Dispose();

        // 用真实从站服务响应 03/04/06/16,界面负责给它填寄存器初值
        var svc = new ModbusSlaveService(Port) { Unit = SlaveAddress };
        svc.Log += msg => WriteLog(msg);
        FillSlaveRegisters(svc.Registers);
        svc.Start();

        _slaveService = svc;
        _regs = [];
        _coils = [];
        Registers.Clear();
        Coils.Clear();

        RefreshSlaveTable();

        IsConnected = true;
        ConnectButtonText = LocalizationService.T("停止");

        WriteLog($"Modbus TCP 从站已启动,监听 127.0.0.1:{svc.Port},站号 {svc.Unit}", LogKind.System);
    }

    private void Disconnect()
    {
        _modbus?.TryDispose();
        _modbus = null;

        _server?.TryDispose();
        _server = null;

        _slaveService?.TryDispose();
        _slaveService = null;

        _timer.TryDispose();
        _timer = null;
        IsPolling = false;
        PollButtonText = LocalizationService.T("开始轮询");

        IsConnected = false;
        ConnectButtonText = LocalizationService.T("打开");

        WriteLog("连接已关闭", LogKind.System);
    }
    #endregion

    #region 主站操作
    /// <summary>执行读写操作</summary>
    [RelayCommand]
    private void Execute()
    {
        if (!IsConnected || SelectedMode != 0)
        {
            WriteLog("主站未连接", LogKind.Warning);
            return;
        }

        var host = ServerAddress;
        var port = Port;
        var unit = SlaveAddress;
        var address = StartAddress;
        var code = FunctionCodeIndex;

        try
        {
            switch (code)
            {
                case 0: // 01 读线圈
                case 1: // 02 读离散量输入
                    {
                        var response = Run(ModbusMasterService.ReadCoilsAsync(host, port, unit, address, ReadCount, code == 1));
                        Report(response.IsError, $"读{(code == 1 ? "离散量输入" : "线圈")}");

                        var bits = ReadResult;
                        if (bits.IsNullOrEmpty()) ReadResult = response.Values.Count == 0 ? "无返回数据" : String.Join(", ", response.Values);
                        break;
                    }
                case 2: // 03 读保持寄存器
                case 3: // 04 读输入寄存器
                    {
                        var response = Run(ModbusMasterService.ReadAsync(host, port, unit, address, ReadCount,
                            code == 2 ? MbFunction.ReadHolding : MbFunction.ReadInput));
                        Report(response.IsError, $"读{(code == 2 ? "保持寄存器" : "输入寄存器")}");

                        var text = String.Join(", ", response.Values);
                        WriteLog($"[{response.Values.Count}个] {text}", LogKind.Rx);
                        ReadResult = text;
                        break;
                    }
                case 4: // 05 写单线圈
                    {
                        var on = WriteValue.ToInt() > 0;
                        var response = Run(ModbusMasterService.WriteCoilAsync(host, port, unit, address, on));
                        Report(response.IsError, "写单线圈");

                        ReadResult = response.IsError ? ReadResult : $"写入成功:地址={address} 值={(on ? "ON" : "OFF")}";
                        if (!response.IsError) WriteLog(ReadResult, LogKind.Rx);
                        break;
                    }
                case 5: // 06 写单寄存器
                    {
                        var value = (UInt16)WriteValue.ToInt();
                        var response = Run(ModbusMasterService.WriteSingleAsync(host, port, unit, address, value));
                        Report(response.IsError, "写单寄存器");

                        ReadResult = response.IsError ? ReadResult : $"写入成功:地址={address} 值=0x{value:X4}";
                        if (!response.IsError) WriteLog(ReadResult, LogKind.Rx);
                        break;
                    }
                case 6: // 0F 写多线圈
                    {
                        var values = new UInt16[ReadCount];
                        for (var i = 0; i < values.Length; i++) values[i] = 0xFF00;

                        var response = Run(ModbusMasterService.WriteMultipleAsync(host, port, unit, address, values));
                        Report(response.IsError, "写多线圈");

                        ReadResult = response.IsError ? ReadResult : $"写入成功:地址={address} 数量={values.Length}";
                        if (!response.IsError) WriteLog(ReadResult, LogKind.Rx);
                        break;
                    }
                case 7: // 10 写多寄存器
                    {
                        var values = new UInt16[ReadCount];
                        var start = WriteValue.ToInt();
                        for (var i = 0; i < values.Length; i++) values[i] = (UInt16)(start + i);

                        var response = Run(ModbusMasterService.WriteMultipleAsync(host, port, unit, address, values));
                        Report(response.IsError, "写多寄存器");

                        ReadResult = response.IsError ? ReadResult : $"写入成功:地址={address} 数量={values.Length}";
                        if (!response.IsError) WriteLog(ReadResult, LogKind.Rx);
                        break;
                    }
            }
        }
        catch (Exception ex)
        {
            WriteLog($"操作失败:{ex.Message}", LogKind.Error);
            ReadResult = $"操作失败:{ex.Message}";
        }
    }

    /// <summary>同步等待异步调用结果</summary>
    /// <typeparam name="T">结果类型</typeparam>
    /// <param name="task">任务</param>
    /// <returns>结果</returns>
    private static T Run<T>(Task<T> task) => task.ConfigureAwait(false).GetAwaiter().GetResult();

    /// <summary>记录异常响应</summary>
    /// <param name="isError">是否异常响应</param>
    /// <param name="action">操作名</param>
    private void Report(Boolean isError, String action)
    {
        if (isError)
        {
            ReadResult = $"{action}异常响应";
            WriteLog($"{action}:从站返回异常帧", LogKind.Error);
        }
    }
    #endregion

    #region 从站操作
    /// <summary>按当前数据模式填充从站寄存器表</summary>
    /// <param name="registers">从站寄存器数组</param>
    private void FillSlaveRegisters(UInt16[] registers)
    {
        for (var i = 0; i < SlaveDataCount; i++)
        {
            var addr = SlaveDataAddress + i;
            if (addr >= registers.Length) break;

            registers[addr] = DataModeIndex switch
            {
                1 => (UInt16)0x7777,
                2 => (UInt16)0xFFFF,
                3 => (UInt16)(addr % 65536),
                4 => (UInt16)Rand.Next(65536),
                _ => (UInt16)0,
            };
        }
    }

    /// <summary>刷新从站数据(重新生成寄存器并同步到从站服务)</summary>
    [RelayCommand]
    private void RefreshSlaveData()
    {
        RefreshSlaveTable();

        if (_slaveService != null) FillSlaveRegisters(_slaveService.Registers);

        WriteLog($"从站数据已刷新:起始 {SlaveDataAddress},数量 {SlaveDataCount}", LogKind.Info);
    }

    /// <summary>刷新界面表格,与服务寄存器保持一致</summary>
    private void RefreshSlaveTable()
    {
        Registers.Clear();
        Coils.Clear();

        _regs = [];
        _coils = [];

        for (var i = 0; i < SlaveDataCount; i++)
        {
            var addr = SlaveDataAddress + i;
            var value = _slaveService != null && addr < _slaveService.Registers.Length
                ? _slaveService.Registers[addr]
                : DataModeIndex switch
                {
                    1 => (UInt16)0x7777,
                    2 => (UInt16)0xFFFF,
                    3 => (UInt16)(addr % 65536),
                    4 => (UInt16)Rand.Next(65536),
                    _ => (UInt16)0,
                };

            _regs.Add(new RegisterUnit { Address = addr, Value = value });
            Registers.Add(new RegisterUnit { Address = addr, Value = value });
            _coils.Add(new CoilUnit { Address = addr, Value = (Byte)(addr % 2) });
            Coils.Add(new CoilUnit { Address = addr, Value = (Byte)(addr % 2) });
        }
    }
    #endregion

    #region 轮询
    /// <summary>开关周期轮询(主站模式下按间隔读取)</summary>
    [RelayCommand]
    private void TogglePoll()
    {
        if (IsPolling)
        {
            _timer.TryDispose();
            _timer = null;
            IsPolling = false;
            PollButtonText = LocalizationService.T("开始轮询");
            WriteLog($"轮询已停止,共 {PollCount} 次", LogKind.System);
            return;
        }

        if (!IsConnected || SelectedMode != 0)
        {
            WriteLog("请先以主站身份连接后再轮询", LogKind.Warning);
            return;
        }

        var interval = PollInterval < 100 ? 100 : PollInterval;
        PollCount = 0;
        _timer = new TimerX(DoPoll, null, 0, interval) { Async = true };
        IsPolling = true;
        PollButtonText = LocalizationService.T("停止轮询");
        WriteLog($"开始轮询,间隔 {interval} ms,读 {ReadCount} 个寄存器 @ {StartAddress}", LogKind.Info);
    }

    /// <summary>定时读取保持寄存器并记录结果</summary>
    /// <param name="state">忽略</param>
    public void DoPoll(Object? state)
    {
        if (!IsConnected) return;

        try
        {
            var response = ModbusMasterService.ReadAsync(ServerAddress, Port, SlaveAddress, StartAddress, ReadCount)
                .ConfigureAwait(false).GetAwaiter().GetResult();
            PollCount++;

            var text = response.Values.Count == 0 ? "无数据" : String.Join(", ", response.Values);
            ReadResult = text;
            WriteLog($"[轮询 {PollCount}] {text}", LogKind.Rx);
        }
        catch (Exception ex)
        {
            PollCount++;
            WriteLog($"[轮询 {PollCount}] 失败:{ex.Message}", LogKind.Error);
        }
    }
    #endregion

    #region 日志
    /// <summary>清空日志</summary>
    [RelayCommand]
    private void ClearLog()
    {
        WriteLog("__CLEAR__");
    }

    /// <summary>彩色日志条目</summary>
    public ObservableCollection<LogEntry> LogEntries { get; } = [];

    private void WriteLog(String msg, LogKind kind = LogKind.Info)
    {
        msg = LocalizationService.Translate(msg);
        OnLog?.Invoke(msg);
        if (msg == "__CLEAR__")
            Log = "";
        else
            Log += msg + "\r\n";

        LogBuffer.Post(LogEntries, msg, kind);
    }

    private class ModbusTcpLog : Logger
    {
        private readonly ModbusTcpViewModel _vm;
        public ModbusTcpLog(ModbusTcpViewModel vm) => _vm = vm;
        protected override void OnWrite(LogLevel level, String format, params Object?[] args)
        {
            var msg = args is { Length: > 0 } ? String.Format(format, args) : format;
            var kind = level switch
            {
                LogLevel.Error or LogLevel.Fatal => LogKind.Error,
                LogLevel.Warn => LogKind.Warning,
                _ => LogKind.Info,
            };
            _vm.WriteLog(msg, kind);
        }
    }
    #endregion

    #region IDisposable
    /// <summary>释放资源</summary>
    public void Dispose()
    {
        Disconnect();
        GC.SuppressFinalize(this);
    }
    #endregion
}