zhaowei.huang/StandardSence
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

init commit

Browse Source
This commit is contained in:
zhaowei.huang
2026-06-14 11:19:15 +08:00
parent e79a3815a5
commit c8e540d272
174 changed files with 60830 additions and 39 deletions
Download Patch File Download Diff File Expand all files Collapse all files
StandardScene.Devices/Door/ModbusDoorController.cs
+412
View File
@@ -0,0 +1,412 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using StandardScene.Utils;
using SimpleCore.Library;
namespace StandardScene.ExtendDevice.Door
{
/// <summary>
/// Modbus 门控制器实现
/// </summary>
[DoorType("ModbusDoorController")]
public class ModbusDoorController : BasicDoorController
{
/// <summary>
/// Modbus TCP 客户端
/// </summary>
private ModbusRtu _modbusClient;
/// <summary>
/// 同步锁
/// </summary>
private readonly object _syncLock = new object();
/// <summary>
/// 是否已启动
/// </summary>
private bool _isStarted = false;
/// <summary>
/// 最近一次已下发的门控制状态，键为门索引
/// </summary>
private readonly Dictionary<int, bool> _lastSentControl = new Dictionary<int, bool>();
/// <summary>
/// 定时读取任务取消令牌
/// </summary>
private CancellationTokenSource _cancellationTokenSource;
/// <summary>
/// 定时读取任务
/// </summary>
private Task _readTask;
/// <summary>
/// 读取间隔（毫秒），默认1000ms
/// </summary>
public int ReadInterval { get; set; } = 1000;
/// <summary>
/// 重连间隔（毫秒），默认3000ms
/// </summary>
public int ReconnectInterval { get; set; } = 3000;
/// <summary>
/// 上次重连尝试时间
/// </summary>
private DateTime _lastReconnectAttempt = DateTime.MinValue;
/// <summary>
/// Modbus 从站地址，默认1
/// </summary>
public byte SlaveAddress { get; set; } = 1;
/// <summary>
/// 设置门的目标控制状态（线程安全实现）
/// 仅修改内存字段，不直接进行通信，实际通信在内部线程中完成
/// </summary>
/// <param name="doorIndex">门索引</param>
/// <param name="open">true=打开，false=关闭</param>
public override void SetDoorControlTarget(int doorIndex, bool open)
{
lock (_syncLock)
{
base.SetDoorControlTarget(doorIndex, open);
}
}
/// <summary>
/// 连接门控制器
/// </summary>
public override void Connect()
{
lock (_syncLock)
{
if (_isStarted)
{
return;
}
try
{
UpdateState(DoorControllerState.Connecting);
// 根据配置的门初始化门状态
var doorIndices = DoorConfigs.Keys.OrderBy(k => k).ToList();
InitializeDoors(doorIndices);
// 初始化最近一次已下发的控制状态
_lastSentControl.Clear();
foreach (var index in doorIndices)
{
_lastSentControl[index] = false;
if (!DoorControlTargets.ContainsKey(index))
{
DoorControlTargets[index] = false;
}
}
// 尝试连接 Modbus TCP 客户端
try
{
_modbusClient = new ModbusRtu();
_modbusClient.StartTcpRtu(Ip, Port);
UpdateState(DoorControllerState.Online);
}
catch (Exception connectEx)
{
UpdateState(DoorControllerState.Connecting);
Diagnosis.Log($"ModbusDoorController[{Index}] 初次连接失败，将在后台持续重连: {ExceptionFormatter.FormatEx(connectEx)}", "ModbusDoorController", true);
}
// 启动定时读取任务
_cancellationTokenSource = new CancellationTokenSource();
_readTask = Task.Run(() => ReadDoorStatesLoop(_cancellationTokenSource.Token));
_isStarted = true;
}
catch (Exception ex)
{
UpdateState(DoorControllerState.Error, $"初始化失败: {ex.Message}");
_isStarted = false;
Diagnosis.Log($"ModbusDoorController[{Index}] 初始化失败: {ExceptionFormatter.FormatEx(ex)}", "ModbusDoorController", true);
}
}
}
/// <summary>
/// 断开连接
/// </summary>
public override void Disconnect()
{
lock (_syncLock)
{
if (!_isStarted)
{
return;
}
try
{
// 停止读取任务
_cancellationTokenSource?.Cancel();
_readTask?.Wait(1000);
// 关闭 Modbus 连接
_modbusClient?.Close();
_modbusClient = null;
_isStarted = false;
UpdateState(DoorControllerState.Offline);
}
catch (Exception ex)
{
UpdateState(DoorControllerState.Error, $"断开连接失败: {ex.Message}");
Diagnosis.Log($"ModbusDoorController[{Index}] 断开连接失败: {ExceptionFormatter.FormatEx(ex)}", "ModbusDoorController", true);
}
}
}
/// <summary>
/// 定时读取门状态循环
/// </summary>
private void ReadDoorStatesLoop(CancellationToken cancellationToken)
{
while (!cancellationToken.IsCancellationRequested)
{
try
{
if (!_isStarted)
{
break;
}
// 检查连接状态
bool isConnected = _modbusClient?.modbusRtu?.Connected ?? false;
if (_modbusClient == null || !isConnected)
{
UpdateState(DoorControllerState.Connecting);
// 控制重连频率
var timeSinceLastReconnect = (DateTime.Now - _lastReconnectAttempt).TotalMilliseconds;
if (timeSinceLastReconnect >= ReconnectInterval)
{
_lastReconnectAttempt = DateTime.Now;
TryReconnect();
}
isConnected = _modbusClient?.modbusRtu?.Connected ?? false;
if (_modbusClient == null || !isConnected)
{
Thread.Sleep(ReadInterval);
continue;
}
}
// 读取所有门的状态
ReadAllDoorStates();
// 根据目标控制状态下发控制指令
ApplyDoorControlTargets();
// 更新在线状态
UpdateState(DoorControllerState.Online);
}
catch (Exception ex)
{
Diagnosis.Log($"ModbusDoorController[{Index}] 读取状态失败: {ExceptionFormatter.FormatEx(ex)}", "ModbusDoorController", true);
UpdateState(DoorControllerState.Error, $"读取状态失败: {ex.Message}");
// 如果连接失败，尝试重连
TryReconnect();
}
// 等待指定间隔
Thread.Sleep(ReadInterval);
}
}
/// <summary>
/// 尝试重连 Modbus TCP 连接
/// </summary>
private void TryReconnect()
{
ModbusRtu oldClient = null;
try
{
// 安全关闭旧连接
if (_modbusClient != null)
{
oldClient = _modbusClient;
_modbusClient = null;
try
{
oldClient.Close();
}
catch
{
// 忽略关闭时的异常
}
finally
{
oldClient = null;
}
}
// 创建新连接
_modbusClient = new ModbusRtu();
_modbusClient.StartTcpRtu(Ip, Port);
Diagnosis.Log($"ModbusDoorController[{Index}] 重连成功", "ModbusDoorController", false);
}
catch (Exception ex)
{
// 重连失败，确保资源释放
if (_modbusClient != null)
{
try
{
_modbusClient.Close();
}
catch
{
// 忽略关闭异常
}
_modbusClient = null;
}
Diagnosis.Log($"ModbusDoorController[{Index}] 重连失败: {ExceptionFormatter.FormatEx(ex)}", "ModbusDoorController", false);
}
}
/// <summary>
/// 读取所有门的状态
/// </summary>
private void ReadAllDoorStates()
{
lock (_syncLock)
{
foreach (var doorConfig in DoorConfigs.Values)
{
try
{
var state = ReadDoorState(doorConfig.Index);
UpdateDoorState(doorConfig.Index, state ? DoorState.Open : DoorState.Closed);
}
catch (Exception ex)
{
Diagnosis.Log($"ModbusDoorController[{Index}] 读取门{doorConfig.Index}状态失败: {ExceptionFormatter.FormatEx(ex)}", "ModbusDoorController", true);
}
}
}
}
/// <summary>
/// 根据 DoorControlTargets 中的目标状态，下发门控制指令
/// </summary>
private void ApplyDoorControlTargets()
{
lock (_syncLock)
{
foreach (var doorConfig in DoorConfigs.Values)
{
var doorIndex = doorConfig.Index;
// 获取目标控制状态，默认false
bool target = false;
DoorControlTargets.TryGetValue(doorIndex, out target);
// 如果门配置为不允许发送任何控制指令，则跳过（既不打开也不关闭）
if (doorConfig.NoControl)
{
continue;
}
// 获取上一次已下发的状态
bool last;
var hasLast = _lastSentControl.TryGetValue(doorIndex, out last);
// 如果没有记录或状态发生变化，则下发控制
if (!hasLast || last != target)
{
try
{
WriteDoorControl(doorIndex, target);
_lastSentControl[doorIndex] = target;
}
catch (Exception ex)
{
Diagnosis.Log($"ModbusDoorController[{Index}] 下发门{doorIndex}控制指令失败: {ExceptionFormatter.FormatEx(ex)}", "ModbusDoorController", true);
}
}
}
}
}
/// <summary>
/// 读取门状态（开到位信号）
/// </summary>
/// <param name="doorIndex">门索引</param>
/// <returns>true=打开，false=关闭</returns>
public override bool ReadDoorState(int doorIndex)
{
lock (_syncLock)
{
if (!DoorConfigs.TryGetValue(doorIndex, out var doorConfig))
{
throw new ArgumentException($"门{doorIndex}不存在");
}
if (_modbusClient == null || !_modbusClient.modbusRtu.Connected)
{
throw new InvalidOperationException("Modbus连接未建立");
}
// 读取开到位信号
var data = _modbusClient.ReadDiscreteInputs_02(SlaveAddress, doorConfig.OpenStatusAddress, 1);
return data != null && data.Length > 0 && data[0];
}
}
/// <summary>
/// 写入门控制信号（开关控制）
/// </summary>
/// <param name="doorIndex">门索引</param>
/// <param name="open">true=打开，false=关闭</param>
public override void WriteDoorControl(int doorIndex, bool open)
{
lock (_syncLock)
{
if (!DoorConfigs.TryGetValue(doorIndex, out var doorConfig))
{
throw new ArgumentException($"门{doorIndex}不存在");
}
if (_modbusClient == null || !_modbusClient.modbusRtu.Connected)
{
// 尝试重连
TryReconnect();
if (_modbusClient == null || !_modbusClient.modbusRtu.Connected)
{
throw new InvalidOperationException("Modbus连接未建立");
}
}
// 写入开关控制信号（线圈）
_modbusClient.WriteMultipleCoils_15(SlaveAddress, doorConfig.ControlAddress, [open]);
}
}
/// <summary>
/// 析构函数，确保资源释放
/// </summary>
~ModbusDoorController()
{
Disconnect();
}
}
}