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
}
|