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/ButtonBox/AzowieButtonBox.cs
+547
View File
@@ -0,0 +1,547 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using StandardScene.Utils;
using SimpleCore;
using SimpleCore.Library;
namespace StandardScene.ExtendDevice.ButtonBox
{
/// <summary>
/// Azowie 呼叫器按钮盒实现
/// 基于 Modbus TCP 协议
/// </summary>
public class AzowieButtonBox : BasicButtonBox
{
/// <summary>
/// Modbus TCP 客户端
/// </summary>
private ModbusRtu _modbusClient;
/// <summary>
/// 同步锁
/// </summary>
private readonly object _syncLock = new object();
/// <summary>
/// 是否已启动
/// </summary>
private bool _isStarted = false;
/// <summary>
/// 定时读取任务取消令牌
/// </summary>
private CancellationTokenSource _cancellationTokenSource;
/// <summary>
/// 定时读取任务
/// </summary>
private Task _readTask;
/// <summary>
/// 读取间隔（毫秒），默认500ms
/// </summary>
public int ReadInterval { get; set; } = 500;
/// <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>
public int DeviceId { get; private set; } = 0;
/// <summary>
/// 电池电量（0-100）
/// </summary>
public int BatteryLevel { get; private set; } = 0;
/// <summary>
/// 按钮灯状态字典
/// </summary>
public Dictionary<int, ButtonLightState> ButtonLightStates { get; private set; } = new Dictionary<int, ButtonLightState>();
/// <summary>
/// 按钮灯状态枚举
/// </summary>
public enum ButtonLightState
{
/// <summary>
/// 常灭
/// </summary>
Off = 0,
/// <summary>
/// 常亮
/// </summary>
On = 1,
/// <summary>
/// 快闪，间隔0.5秒
/// </summary>
FastBlink = 2,
/// <summary>
/// 慢闪，间隔2秒
/// </summary>
SlowBlink = 3
}
/// <summary>
/// 连接按钮盒
/// </summary>
public override void Connect()
{
lock (_syncLock)
{
if (_isStarted)
{
return;
}
try
{
UpdateState(ButtonBoxState.Connecting);
// 根据配置的按钮初始化按钮状态
var buttonIndices = ButtonConfigs.Keys.OrderBy(k => k).ToList();
if (buttonIndices.Count == 0)
{
// 如果没有配置，默认初始化按钮1-8
buttonIndices = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8 };
}
InitializeButtons(buttonIndices);
// 初始化按钮灯状态
foreach (var index in buttonIndices)
{
ButtonLightStates[index] = ButtonLightState.Off;
}
// 尝试连接 Modbus TCP 客户端
try
{
_modbusClient = new ModbusRtu();
_modbusClient.StartTcpRtu(Ip, Port);
UpdateState(ButtonBoxState.Online);
}
catch (Exception connectEx)
{
// 初次连接失败，但不阻止启动读取循环，循环中会持续重连
UpdateState(ButtonBoxState.Connecting);
Diagnosis.Log($"AzowieButtonBox[{Index}] 初次连接失败，将在后台持续重连: {ExceptionFormatter.FormatEx(connectEx)}", "AzowieButtonBox", true);
}
// 启动定时读取任务（即使连接失败也会启动，循环中会持续重连）
_cancellationTokenSource = new CancellationTokenSource();
_readTask = Task.Run(() => ReadButtonStatesLoop(_cancellationTokenSource.Token));
_isStarted = true;
}
catch (Exception ex)
{
UpdateState(ButtonBoxState.Error, $"初始化失败: {ex.Message}");
_isStarted = false;
Diagnosis.Log($"AzowieButtonBox[{Index}] 初始化失败: {ExceptionFormatter.FormatEx(ex)}", "AzowieButtonBox", true);
}
}
}
/// <summary>
/// 断开连接
/// </summary>
public override void Disconnect()
{
lock (_syncLock)
{
if (!_isStarted || _modbusClient == null)
{
return;
}
try
{
// 停止读取任务
_cancellationTokenSource?.Cancel();
_readTask?.Wait(1000);
// 关闭 Modbus 连接
_modbusClient?.Close();
_modbusClient = null;
_isStarted = false;
UpdateState(ButtonBoxState.Offline);
}
catch (Exception ex)
{
UpdateState(ButtonBoxState.Error, $"断开连接失败: {ex.Message}");
Diagnosis.Log($"AzowieButtonBox[{Index}] 断开连接失败: {ExceptionFormatter.FormatEx(ex)}", "AzowieButtonBox", true);
}
}
}
/// <summary>
/// 定时读取按钮状态循环
/// </summary>
private void ReadButtonStatesLoop(CancellationToken cancellationToken)
{
while (!cancellationToken.IsCancellationRequested)
{
try
{
if (!_isStarted)
{
break;
}
// 检查连接状态，如果未连接或连接断开，尝试重连
bool isConnected = _modbusClient?.modbusRtu?.Connected ?? false;
if (_modbusClient == null || !isConnected)
{
UpdateState(ButtonBoxState.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;
}
}
// 读取按钮状态（寄存器 01-04 对应按钮1-4，21-24 对应按钮5-8）
ReadButtonStates();
// 读取设备信息（每5秒读取一次）
//if (DateTime.Now.Second % 5 == 0)
//{
// ReadDeviceInfo();
//}
// 更新在线状态
UpdateState(ButtonBoxState.Online);
}
catch (Exception ex)
{
Diagnosis.Log($"AzowieButtonBox[{Index}] 读取状态失败: {ExceptionFormatter.FormatEx(ex)}", "AzowieButtonBox", true);
UpdateState(ButtonBoxState.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($"AzowieButtonBox[{Index}] 重连成功", "AzowieButtonBox", false);
}
catch (Exception ex)
{
// 重连失败，确保资源释放
if (_modbusClient != null)
{
try
{
_modbusClient.Close();
}
catch
{
// 忽略关闭异常
}
_modbusClient = null;
}
// 记录日志但不抛出异常，等待下次循环继续尝试
Diagnosis.Log($"AzowieButtonBox[{Index}] 重连失败: {ExceptionFormatter.FormatEx(ex)}", "AzowieButtonBox", false);
}
}
/// <summary>
/// 读取按钮状态
/// 根据配置的按钮数量和编号读取对应的寄存器
/// </summary>
private void ReadButtonStates()
{
try
{
// 获取配置的按钮索引列表
var configuredButtons = ButtonConfigs.Keys.OrderBy(k => k).ToList();
if (configuredButtons.Count == 0)
{
// 如果没有配置，默认读取按钮1-8
configuredButtons = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8 };
}
// 将按钮分为两组：按钮1-4（寄存器01-04）和按钮5-8（寄存器21-24）
var buttons1_4 = configuredButtons.Where(b => b >= 1 && b <= 4).OrderBy(b => b).ToList();
var buttons5_8 = configuredButtons.Where(b => b >= 5 && b <= 8).OrderBy(b => b).ToList();
// 读取按钮1-4的状态（寄存器地址 01-04）
// 按钮索引直接对应寄存器地址：按钮1->寄存器01，按钮2->寄存器02，按钮3->寄存器03，按钮4->寄存器04
if (buttons1_4.Count > 0)
{
// 计算需要读取的寄存器范围（从最小按钮索引到最大按钮索引）
var minButton = buttons1_4.Min();
var maxButton = buttons1_4.Max();
var startReg = (ushort)minButton; // 按钮索引直接对应寄存器地址
var count = maxButton - minButton + 1;
var buttonStates1_4 = _modbusClient.ReadRegisterBuffer_03(SlaveAddress, startReg, (ushort)count);
// 将读取结果映射到对应的按钮索引
foreach (var buttonIndex in buttons1_4)
{
// 计算该按钮在读取结果数组中的位置
var arrayIndex = buttonIndex - minButton;
if (arrayIndex >= 0 && arrayIndex < buttonStates1_4.Length)
{
var state = buttonStates1_4[arrayIndex];
UpdateButtonState(buttonIndex, state == 1 ? ButtonState.Pressed : ButtonState.Released);
}
}
}
// 读取按钮5-8的状态（寄存器地址 21-24）
// 按钮索引对应寄存器地址：按钮5->寄存器21，按钮6->寄存器22，按钮7->寄存器23，按钮8->寄存器24
// 寄存器地址 = 20 + 按钮索引
if (buttons5_8.Count > 0)
{
var minButton = buttons5_8.Min();
var maxButton = buttons5_8.Max();
var startReg = (ushort)(20 + minButton); // 按钮5对应寄存器21
var count = maxButton - minButton + 1;
var buttonStates5_8 = _modbusClient.ReadRegisterBuffer_03(SlaveAddress, startReg, (ushort)count);
// 将读取结果映射到对应的按钮索引
foreach (var buttonIndex in buttons5_8)
{
// 计算该按钮在读取结果数组中的位置
var arrayIndex = buttonIndex - minButton;
if (arrayIndex >= 0 && arrayIndex < buttonStates5_8.Length)
{
var state = buttonStates5_8[arrayIndex];
UpdateButtonState(buttonIndex, state == 1 ? ButtonState.Pressed : ButtonState.Released);
}
}
}
}
catch (Exception ex)
{
throw new Exception($"读取按钮状态失败: {ex.Message}", ex);
}
}
/// <summary>
/// 更新按钮配置信息
/// 当配置变化时，同步更新按钮状态和按钮灯状态字典
/// </summary>
/// <param name="buttonConfigs">按钮配置列表</param>
public override void UpdateButtonConfigs(List<ButtonModel> buttonConfigs)
{
lock (_syncLock)
{
// 保存旧的按钮索引列表
var oldButtonIndices = new HashSet<int>(ButtonConfigs.Keys);
// 调用基类方法更新配置
base.UpdateButtonConfigs(buttonConfigs);
// 获取新的按钮索引列表
var newButtonIndices = new HashSet<int>(ButtonConfigs.Keys);
// 如果配置发生变化，更新按钮状态和按钮灯状态字典
if (!oldButtonIndices.SetEquals(newButtonIndices))
{
// 移除已删除的按钮状态
var toRemove = oldButtonIndices.Where(k => !newButtonIndices.Contains(k)).ToList();
foreach (var index in toRemove)
{
ButtonStates.Remove(index);
ButtonLightStates.Remove(index);
}
// 添加新按钮的状态（初始化为未按下和常灭）
var toAdd = newButtonIndices.Where(k => !oldButtonIndices.Contains(k)).ToList();
foreach (var index in toAdd)
{
if (!ButtonStates.ContainsKey(index))
{
ButtonStates[index] = ButtonState.Released;
}
if (!ButtonLightStates.ContainsKey(index))
{
ButtonLightStates[index] = ButtonLightState.Off;
}
}
// 如果没有配置，默认初始化按钮1-8
if (newButtonIndices.Count == 0)
{
var defaultButtons = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8 };
InitializeButtons(defaultButtons);
foreach (var index in defaultButtons)
{
if (!ButtonLightStates.ContainsKey(index))
{
ButtonLightStates[index] = ButtonLightState.Off;
}
}
}
Diagnosis.Log($"AzowieButtonBox[{Index}] 按钮配置已更新: 旧配置{oldButtonIndices.Count}个按钮, 新配置{newButtonIndices.Count}个按钮", "AzowieButtonBox", false);
}
}
}
/// <summary>
/// 清零指定按钮的寄存器状态
/// </summary>
/// <param name="buttonIndex">按钮索引（1-8）</param>
public override void ClearButtonRegister(int buttonIndex)
{
lock (_syncLock)
{
if (!_isStarted)
{
return;
}
if (buttonIndex < 1 || buttonIndex > 8)
{
Diagnosis.Log($"AzowieButtonBox[{Index}] 按钮索引超出范围: {buttonIndex}", "AzowieButtonBox", true);
return;
}
try
{
// 检查连接状态，如果未连接则尝试重连
bool isConnected = _modbusClient?.modbusRtu?.Connected ?? false;
if (!isConnected)
{
// 尝试重连
TryReconnect();
isConnected = _modbusClient?.modbusRtu?.Connected ?? false;
// 如果重连失败，记录日志并返回
if (!isConnected)
{
Diagnosis.Log($"AzowieButtonBox[{Index}] 清零按钮{buttonIndex}寄存器失败: 连接未建立", "AzowieButtonBox", true);
return;
}
}
// 根据按钮索引确定寄存器地址
// 按钮1-4对应寄存器01-04，按钮5-8对应寄存器21-24
ushort buttonRegisterAddress;
if (buttonIndex >= 1 && buttonIndex <= 4)
{
buttonRegisterAddress = (ushort)buttonIndex; // 按钮索引直接对应寄存器地址
}
else
{
buttonRegisterAddress = (ushort)(20 + buttonIndex); // 按钮5-8对应寄存器21-24
}
// 清零按钮状态寄存器
_modbusClient.WriteSingleRegister_06(SlaveAddress, buttonRegisterAddress, 0);
// 清零对应的按钮灯状态寄存器
// 按钮灯1-4对应寄存器05-08（按钮索引 + 4），按钮灯5-8对应寄存器25-28（按钮索引 + 20）
ushort lightRegisterAddress;
if (buttonIndex is >= 1 and <= 4)
{
lightRegisterAddress = (ushort)(4 + buttonIndex); // 按钮灯寄存器 = 按钮索引 + 4
}
else
{
lightRegisterAddress = (ushort)(20 + buttonIndex); // 按钮灯寄存器 = 按钮索引 + 20
}
_modbusClient.WriteSingleRegister_06(SlaveAddress, lightRegisterAddress, 0);
// 更新本地按钮灯状态
if (ButtonLightStates.ContainsKey(buttonIndex))
{
ButtonLightStates[buttonIndex] = ButtonLightState.Off;
}
Diagnosis.Log($"AzowieButtonBox[{Index}] 清零按钮{buttonIndex}状态和灯光寄存器成功", "AzowieButtonBox", false);
}
catch (Exception ex)
{
Diagnosis.Log($"AzowieButtonBox[{Index}] 清零按钮{buttonIndex}寄存器失败: {ExceptionFormatter.FormatEx(ex)}", "AzowieButtonBox", true);
// 如果是因为连接问题导致的异常，尝试重连
bool isConnected = _modbusClient?.modbusRtu?.Connected ?? false;
if (!isConnected)
{
TryReconnect();
}
}
}
}
/// <summary>
/// 析构函数，确保资源释放
/// </summary>
~AzowieButtonBox()
{
Disconnect();
}
}
}
StandardScene.Devices/ButtonBox/LeegButtonBox.cs
+225
View File
@@ -0,0 +1,225 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using leegiot;
using SimpleCore;
using SimpleCore.Library;
namespace StandardScene.ExtendDevice.ButtonBox
{
public class LeegButtonBox : BasicButtonBox
{
/// <summary>
/// LeegKey设备实例
/// </summary>
private LeegKeyDevice _device;
/// <summary>
/// 同步锁
/// </summary>
private readonly object _syncLock = new object();
/// <summary>
/// 是否已启动
/// </summary>
private bool _isStarted = false;
/// <summary>
/// 连接按钮盒
/// </summary>
public override void Connect()
{
lock (_syncLock)
{
if (_isStarted)
{
return;
}
try
{
UpdateState(ButtonBoxState.Connecting);
// 创建LeegKey设备实例
_device = new LeegKeyDevice(Ip, Port);
// 设置事件回调，使用Index作为userData
_device.setEventCallback(OnLeegKeyEvent, Index);
_device.autoHeartbeatEnable(2,5);
// 启动设备
_device.start(true);
_isStarted = true;
UpdateState(ButtonBoxState.Online);
}
catch (Exception ex)
{
UpdateState(ButtonBoxState.Error, $"连接失败: {ex.Message}");
_isStarted = false;
}
}
}
/// <summary>
/// 断开连接
/// </summary>
public override void Disconnect()
{
lock (_syncLock)
{
if (!_isStarted || _device == null)
{
return;
}
try
{
_device.stop();
_device = null;
_isStarted = false;
UpdateState(ButtonBoxState.Offline);
}
catch (Exception ex)
{
UpdateState(ButtonBoxState.Error, $"断开连接失败: {ex.Message}");
}
}
}
/// <summary>
/// LeegKey事件回调
/// </summary>
private void OnLeegKeyEvent(LeegKeyEvent evt, object msg, object userData)
{
try
{
switch (evt)
{
case LeegKeyEvent.KEY_HIT:
HandleKeyHit((LeegKeyMsgKey)msg);
break;
case LeegKeyEvent.STATUS_REP:
HandleStatusReport((LeegKeyMsgStatus)msg);
break;
case LeegKeyEvent.TIME:
// 时间同步事件，可以用于保持连接状态
UpdateState(ButtonBoxState.Online);
break;
case LeegKeyEvent.LOG:
// 日志事件，可以用于调试
HandleLogEvent((LeegKeyMsgLog)msg);
break;
default:
break;
}
}
catch (Exception ex)
{
UpdateState(ButtonBoxState.Error, $"处理事件失败: {ex.Message}");
}
}
/// <summary>
/// 处理按键按下事件
/// </summary>
private void HandleKeyHit(LeegKeyMsgKey msg)
{
var keyTag= msg.content.keys[0].First();
var buttonIndexStr = keyTag.Key.Substring(3);
if(!int.TryParse(buttonIndexStr,out var buttonIndex))
return;
switch (keyTag.Value)
{
case "up":
UpdateButtonState(buttonIndex,ButtonState.Released);
break;
case "down":
UpdateButtonState(buttonIndex,ButtonState.Pressed);
break;
}
}
/// <summary>
/// 处理状态报告事件
/// </summary>
private void HandleStatusReport(LeegKeyMsgStatus msg)
{
// 状态报告表示设备在线
UpdateState(ButtonBoxState.Online);
}
/// <summary>
/// 处理日志事件
/// </summary>
private void HandleLogEvent(LeegKeyMsgLog msg)
{
// 可以根据日志内容更新状态
// 这里可以根据实际需求实现
}
/// <summary>
/// 设置按钮灯光
/// </summary>
/// <param name="buttonIndex">按钮索引</param>
/// <param name="rgb">RGB颜色值</param>
public void SetButtonLight(int buttonIndex, Rgb rgb)
{
lock (_syncLock)
{
if (!_isStarted || _device == null)
{
return;
}
try
{
_device.lightSet(rgb, buttonIndex);
}
catch (Exception ex)
{
Diagnosis.Log($"设置按钮灯光失败: {ExceptionFormatter.FormatEx(ex)}", "LeegButtonBox", true);
}
}
}
/// <summary>
/// 控制IO输出
/// </summary>
/// <param name="content">IO控制内容</param>
public void ControlIO(IoctrlContent content)
{
lock (_syncLock)
{
if (!_isStarted || _device == null)
{
return;
}
try
{
_device.ioctrl(content);
}
catch (Exception ex)
{
Diagnosis.Log($"控制IO失败: {ExceptionFormatter.FormatEx(ex)}", "LeegButtonBox", true);
}
}
}
/// <summary>
/// 析构函数，确保资源释放
/// </summary>
~LeegButtonBox()
{
Disconnect();
}
}
}
StandardScene.Devices/Charge/FLChargeStation.cs
+405
View File
@@ -0,0 +1,405 @@
using SimpleLite.RCS;
using SimpleLite.RCS.CarTypes;
using SimpleCore;
using SimpleCore.Library;
using SimpleCore.PropType;
using StandardScene.Charge;
using StandardScene.TCP;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
namespace StandardScene.ChargeStationType
{
public class FLChargeStation : AbstractChargeStation
{
private AsyncTcpClient Client;
private IPEndPoint _endPoint;
// 重连相关
private Timer _reconnectTimer;
private bool _isManualDisconnect = false; // 标识是否为手动断开
private int _reconnectAttempts = 0; // 重连尝试次数
private const int MAX_RECONNECT_ATTEMPTS = 5; // 最大重连次数
private const int RECONNECT_INTERVAL_MS = 3000; // 重连间隔（毫秒）
private readonly object _connectionLock = new object(); // 连接锁
private bool _isConnecting = false; // 是否正在连接中
// 连接状态
public bool IsConnected { get; private set; } = false;
public DateTime? LastConnectedTime { get; private set; }
public DateTime? LastDisconnectedTime { get; private set; }
/// <summary>
/// 关闭当前TCP连接
/// </summary>
public override void CloseCommunication()
{
lock (_connectionLock)
{
_isManualDisconnect = true; // 标记为手动断开，不触发自动重连
// 停止重连定时器
if (_reconnectTimer != null)
{
_reconnectTimer.Dispose();
_reconnectTimer = null;
}
_isConnecting = false;
if (Client != null)
{
try
{
// 取消订阅事件，避免内存泄漏
Client.PlaintextReceived -= OnPlaintextReceived;
Client.ServerConnected -= OnServerConnected;
Client.ServerDisconnected -= OnServerDisconnected;
// 关闭连接
Client.Close();
Client = null;
IsConnected = false;
LastDisconnectedTime = DateTime.Now;
Diagnosis.Log($"FLChargeStation[{SiteId}] TCP connection closed manually");
}
catch (Exception ex)
{
Diagnosis.Log($"ERR:FLChargeStation[{SiteId}] failed to close connection: {ex.Message}");
}
}
}
}
/// <summary>
/// 创建TCP连接
/// </summary>
public override void CreateCommunication(IPAddress ip, int port)
{
lock (_connectionLock)
{
// 先关闭旧连接
if (Client != null)
{
CloseCommunication();
}
_endPoint = new IPEndPoint(ip, port);
_isManualDisconnect = false; // 重置手动断开标记
_reconnectAttempts = 0; // 重置重连次数
ConnectInternal();
}
}
/// <summary>
/// 内部连接方法
/// </summary>
private void ConnectInternal()
{
if (_isConnecting)
{
Diagnosis.Log($"FLChargeStation[{SiteId}] is already connecting, skip");
return;
}
try
{
_isConnecting = true;
// 创建新的TCP客户端
Client = new AsyncTcpClient(_endPoint.Address, _endPoint.Port);
Client.PlaintextReceived += OnPlaintextReceived;
Client.ServerConnected += OnServerConnected;
Client.ServerDisconnected += OnServerDisconnected;
// 连接
Client.Connect();
if (Client.Connected)
{
Diagnosis.Log($"FLChargeStation[{SiteId}] connecting to {_endPoint.Address}:{_endPoint.Port}...");
}
else
{
_isConnecting = false;
Diagnosis.Log($"FLChargeStation[{SiteId}] connecting to {_endPoint.Address}:{_endPoint.Port}... 未建立连接");
}
}
catch (Exception ex)
{
Diagnosis.Log($"ERR:FLChargeStation[{SiteId}] failed to create connection: {ex.Message}");
_isConnecting = false;
// 触发重连
if (!_isManualDisconnect)
{
ScheduleReconnect();
}
}
}
/// <summary>
/// 手动触发重连
/// </summary>
public void Reconnect()
{
lock (_connectionLock)
{
Diagnosis.Log($"FLChargeStation[{SiteId}] manual reconnect triggered");
_isManualDisconnect = false;
_reconnectAttempts = 0;
// 关闭现有连接
if (Client != null)
{
try
{
Client.PlaintextReceived -= OnPlaintextReceived;
Client.ServerConnected -= OnServerConnected;
Client.ServerDisconnected -= OnServerDisconnected;
Client.Close();
Client = null;
}
catch { }
}
// 重新连接
ConnectInternal();
}
}
/// <summary>
/// 安排自动重连
/// </summary>
private void ScheduleReconnect()
{
if (_isManualDisconnect)
{
Diagnosis.Log($"FLChargeStation[{SiteId}] manual disconnect, skip auto reconnect");
return;
}
if (_reconnectAttempts >= MAX_RECONNECT_ATTEMPTS)
{
Diagnosis.Log($"ERR:FLChargeStation[{SiteId}] max reconnect attempts ({MAX_RECONNECT_ATTEMPTS}) reached, stop reconnecting");
return;
}
_reconnectAttempts++;
// 停止现有定时器
if (_reconnectTimer != null)
{
_reconnectTimer.Dispose();
}
Diagnosis.Log($"FLChargeStation[{SiteId}] scheduling reconnect attempt {_reconnectAttempts}/{MAX_RECONNECT_ATTEMPTS} in {RECONNECT_INTERVAL_MS}ms");
// 创建新的定时器
_reconnectTimer = new Timer(
callback: _ => AttemptReconnect(),
state: null,
dueTime: RECONNECT_INTERVAL_MS,
period: Timeout.Infinite
);
}
/// <summary>
/// 尝试重连
/// </summary>
private void AttemptReconnect()
{
lock (_connectionLock)
{
if (_isManualDisconnect || IsConnected)
{
return;
}
Diagnosis.Log($"FLChargeStation[{SiteId}] attempting to reconnect (attempt {_reconnectAttempts}/{MAX_RECONNECT_ATTEMPTS})...");
try
{
// 清理旧客户端
if (Client != null)
{
try
{
Client.PlaintextReceived -= OnPlaintextReceived;
Client.ServerConnected -= OnServerConnected;
Client.ServerDisconnected -= OnServerDisconnected;
Client.Close();
}
catch { }
Client = null;
}
// 重新连接
ConnectInternal();
}
catch (Exception ex)
{
Diagnosis.Log($"ERR:FLChargeStation[{SiteId}] reconnect failed: {ex.Message}");
// 继续安排下一次重连
if (!_isManualDisconnect && _reconnectAttempts < MAX_RECONNECT_ATTEMPTS)
{
ScheduleReconnect();
}
}
}
}
private void OnPlaintextReceived(object sender, TcpDatagramReceivedEventArgs<byte[]> e)
{
var messageService = CommunicationMessageService.Instance;
var recBytes = e.Datagram.Take(35).ToArray();
string IP = ((AsyncTcpClient)sender).RemoteIPEndPoint.Address.ToString();
Diagnosis.Post($"{string.Join(" ", recBytes.Select(p => $"{p:X2}"))}", $"{IP}", true);
IsSafe = recBytes[28] == 2;
messageService.AddReceiveMessage(_endPoint.Address.ToString(), _endPoint.Port, BitConverter.ToString(recBytes).Replace("-", " "), "FRLDTall");
}
/// <summary>
/// 服务器连接成功事件
/// </summary>
private void OnServerConnected(object sender, TcpServerConnectedEventArgs e)
{
lock (_connectionLock)
{
_isConnecting = false;
IsConnected = true;
LastConnectedTime = DateTime.Now;
_reconnectAttempts = 0; // 重置重连次数
Diagnosis.Log($"FLChargeStation[{SiteId}] TCP connected successfully to {_endPoint.Address}:{_endPoint.Port}");
// 停止重连定时器
if (_reconnectTimer != null)
{
_reconnectTimer.Dispose();
_reconnectTimer = null;
}
}
}
/// <summary>
/// 服务器断开连接事件
/// </summary>
private void OnServerDisconnected(object sender, TcpServerDisconnectedEventArgs e)
{
lock (_connectionLock)
{
_isConnecting = false;
IsConnected = false;
LastDisconnectedTime = DateTime.Now;
Diagnosis.Log($"WARN:FLChargeStation[{SiteId}] TCP disconnected from {_endPoint.Address}:{_endPoint.Port}");
}
}
/// <summary>
/// 发送充电指令到充电站
/// </summary>
public override void SendToChargeStation(int isCharge, Car car,Site site)
{
// 检查连接状态
if (!IsConnected || Client == null)
{
Diagnosis.Log($"WARN:FLChargeStation[{SiteId}] not connected, cannot send charge command");
return;
}
try
{
var messageService = CommunicationMessageService.Instance;
float soc = 0f, voltage = 0, electricCurrent = 0;
int carId = 0;
float setVoltage = 55.0f;
float setElectricCurrent = 50.0f;
//Site site = null;
if (car != null)
{
soc = float.Parse(Commons.GetCarStatus(car, "Soc"));
voltage = float.Parse(Commons.GetCarStatus(car, "Voltage"));
electricCurrent = float.Parse(Commons.GetCarStatus(car, "ElectricCurrent"));
carId = car.id;
//site = SimpleLib.GetSite(car.status.holdingLocks.FirstOrDefault());
}
if (site != null && site.fields.ContainsKey("setVoltage") && site.fields.ContainsKey("setElectricCurrent"))
{
setVoltage = float.Parse(site.fields["setVoltage"]);
setElectricCurrent = float.Parse(site.fields["setElectricCurrent"]);
}
var msg = GetSendBytes((byte)(isCharge),
setVoltage, setElectricCurrent, 1000,
Convert.ToSingle(carId), Convert.ToSingle(soc), Convert.ToSingle(electricCurrent), Convert.ToSingle(voltage));
messageService.AddSendMessage(_endPoint.Address.ToString(), _endPoint.Port, BitConverter.ToString(msg).Replace("-", " "), "FRLDTall", site?.name);
// 发送数据，带异常处理
try
{
Client.Send(msg);
Diagnosis.Post($"{string.Join(" ", msg.Select(d => $"{d:X2}"))}",
$"sendChargeSite: {SiteId}", true);
}
catch (ObjectDisposedException)
{
Diagnosis.Log($"ERR:FLChargeStation[{SiteId}] client disposed during send, triggering reconnect");
IsConnected = false;
}
catch (SocketException ex)
{
Diagnosis.Log($"ERR:FLChargeStation[{SiteId}] socket error during send: {ex.SocketErrorCode}, triggering reconnect");
IsConnected = false;
}
}
catch (Exception e)
{
Diagnosis.Post($"ERR:FLChargeStation[{SiteId}] SwitchCharge Fail: {ExceptionFormatter.FormatEx(e)}");
}
}
private byte[] GetSendBytes(byte startCharge, float chargeVoltage, float chargeElectricCurrent,
float chargeTimeSpan, float carId,
float carSoc, float carElectricCurrent, float carVoltage)
{
var sendByte = new byte[32];
try
{
//BB 01 42 48 00 00 42 5C 00 00 00 00 00 02 00 5D 41 B4 00 00 41 28 00 00 00 00 00 00 00 00 00 EE
sendByte = new byte[2] { 0xBB, startCharge }
.Concat(BitConverter.GetBytes(chargeElectricCurrent).AsEnumerable().Reverse())
.Concat(BitConverter.GetBytes(chargeVoltage).AsEnumerable().Reverse())
.Concat(BitConverter.GetBytes((ushort)chargeTimeSpan).AsEnumerable().Reverse())
.Concat(BitConverter.GetBytes((ushort)carId).AsEnumerable().Reverse())
.Concat(BitConverter.GetBytes((ushort)carSoc).AsEnumerable().Reverse())
.Concat(BitConverter.GetBytes(carElectricCurrent).AsEnumerable().Reverse())
.Concat(BitConverter.GetBytes(carVoltage).AsEnumerable().Reverse())
.Concat(new byte[] { 00, 00, 00, 00, 00, 00, 00, 0xEE }).ToArray();
}
catch (Exception ex)
{
Diagnosis.Post($"下发充电控制{(startCharge == 1 ? "启动" : "停止")}异常+ex:{ExceptionFormatter.FormatEx(ex)}", "error");
}
return sendByte;
}
}
}
StandardScene.Devices/Charge/MuXingChargeStation.cs
+456
View File
@@ -0,0 +1,456 @@
using SimpleLite.RCS;
using SimpleLite.RCS.CarTypes;
using SimpleCore;
using SimpleCore.Library;
using SimpleCore.PropType;
using StandardScene.Charge;
using StandardScene.TCP;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Timers;
using System.Windows.Forms;
namespace StandardScene.ChargeStationType
{
public class MuXingChargeStation : AbstractChargeStation
{
public static TcpListener tcpListener;
public static Thread listenerThread;
public static NetworkStream stream;
public static TcpClient client;
//public Dictionary<IPAddress, (TcpClient, NetworkStream)> chargeClient = new Dictionary<IPAddress, (TcpClient, NetworkStream)> { };
public System.Timers.Timer _Timer;
public bool reciveHeartBeat;
public bool running;
public byte[] IdBytes = new byte[] { 0x0f, 0x01 };
private static IPEndPoint _endPoint;
/// <summary>
/// 关闭当前TCP连接
/// </summary>
public override void CloseCommunication()
{
try
{
running = false;
// 停止定时器
if (_Timer != null)
{
_Timer.Stop();
_Timer.Dispose();
_Timer = null;
}
// 关闭流
if (stream != null)
{
stream.Close();
stream = null;
}
// 关闭客户端
if (client != null)
{
client.Close();
client = null;
}
// 停止监听器
if (tcpListener != null)
{
tcpListener.Stop();
tcpListener = null;
}
Diagnosis.Log($"MuXingChargeStation[{SiteId}] TCP connection closed");
}
catch (Exception ex)
{
Diagnosis.Log($"ERR:MuXingChargeStation[{SiteId}] failed to close connection: {ex.Message}");
}
}
public override void CreateCommunication(IPAddress ip, int port)
{
// 先关闭旧连接
CloseCommunication();
_endPoint = new IPEndPoint(ip, port);
reciveHeartBeat = false;
running = true;
int n = 0;
DateTime offlineTime = DateTime.Now;
try
{
tcpListener = new TcpListener(ip, port);
tcpListener.Start();
Diagnosis.Post($"AGV与牧星充电站通信已建立，监听 IP: {ip}, 端口: {port}");
client = tcpListener.AcceptTcpClient();
client.SendTimeout = 5000;
client.ReceiveTimeout = 5000;
stream = client.GetStream();
}
catch (Exception ex)
{
Console.WriteLine($"与充电站通信建立失败: {ExceptionFormatter.FormatEx(ex)}");
throw;
}
while (running)
{
try
{
if (client == null)
{
client = tcpListener.AcceptTcpClient();
client.SendTimeout = 5000;
client.ReceiveTimeout = 5000;
stream = client.GetStream();
}
var type = ReceiveMesageType();
//item1:byte0 帧头
//item2:byte11 命令字
//item3:byte12 动作码/故障码/状态码
//item4:byte5 设备ID 低
//item5:byte6 设备ID 高
//0x10 充电桩登录回复 1次
if (type.Item1 == 0xAA && type.Item2 == 0x10)
{
var timestampBytes = GetTimeStamp();
byte[] dataByte = new byte[16]
{
0, 0x0d,
0, 0, 0, 0, 0, 0, 0, 0, 0,
0x10,
0, 0,
0x00, 0x00
}; //长度必须大于10,与帧长度对应
dataByte = InitSendBytes(dataByte, type, timestampBytes);
byte[] mesSendByte =
CombineDataAndCRC(dataByte, CalculateCRC16(dataByte.Skip(1).ToArray())); //拼接crc（去掉包头）
Diagnosis.Post($"login => {string.Join(" ", mesSendByte.Select(d => $"{d:X2}"))}",
$"充电桩登录回复");
SendMessage(mesSendByte);
}
//0x12 充电桩对接完成回复 1次
else if (type.Item1 == 0xAA && type.Item2 == 0x12)
{
var timestampBytes = GetTimeStamp();
byte[] dataByte = new byte[12]
{
0, 0x09,
0, 0, 0, 0, 0, 0, 0, 0, 0,
0x12
};
;
dataByte = InitSendBytes(dataByte, type, timestampBytes);
byte[] sendByte =
CombineDataAndCRC(dataByte, CalculateCRC16(dataByte.Skip(1).ToArray())); //拼接crc（去掉包头）
Diagnosis.Post($"docking => {string.Join(" ", sendByte.Select(d => $"{d:X2}"))}",
$"充电桩对接完成回复");
SendMessage(sendByte);
}
//0x13 故障上报回复
else if (type.Item1 == 0xAA && type.Item2 == 0x13)
{
var timestampBytes = GetTimeStamp();
byte[] dataByte = new byte[13]
{
0, 0x0A,
0, 0, 0, 0, 0, 0, 0, 0, 0,
0x13,
type.Item3
};
dataByte = InitSendBytes(dataByte, type, timestampBytes);
byte[] sendByte =
CombineDataAndCRC(dataByte, CalculateCRC16(dataByte.Skip(1).ToArray())); //拼接crc（去掉包头）
Diagnosis.Post($"Error => {string.Join(" ", sendByte.Select(d => $"{d:X2}"))}",
$"故障上报回复");
SendMessage(sendByte);
}
//收到至少1次充电桩心跳包上传
if (type.Item1 == 0xAA && type.Item2 == 0xF0 && !reciveHeartBeat)
{
Diagnosis.Post($"收到充电桩心跳包上传", $"HeartBeatRecive");
reciveHeartBeat = true;
StartSendingHeartBeat();
}
//异常情况处理
//故障上报 故障码不为0 16 17 1
if (type.Item1 == 0xAA && type.Item2 == 0x13 &&
(type.Item3 != 0 && type.Item3 != 16 && type.Item3 != 17 && type.Item3 != 1))
{
//充电桩掉线
if ((type.Item3 & (1 << 3)) != 0 && reciveHeartBeat)
{
if (n == 0) offlineTime = DateTime.Now;
//充电桩掉线时间大于60s 重启WiFi模块
if ((DateTime.Now - offlineTime).TotalSeconds > 60)
{
var timestampBytes = GetTimeStamp();
//下发 命令码指令
byte[] dataByte = new byte[17]
{
0, 0x0E,
0, 0, 0, 0, 0, 0, 0, 0, 0,
0x15,
0x04, //重启WiFi模块
0x00, 0x00, 0x00, 0x00
};
dataByte = InitSendBytes(dataByte, type, timestampBytes);
byte[] sendChargeByte =
CombineDataAndCRC(dataByte, CalculateCRC16(dataByte.Skip(1).ToArray()));
Diagnosis.Post(
$"Restart => {string.Join(" ", sendChargeByte.Select(d => $"{d:X2}"))}",
$"重启WiFi模块");
SendMessage(sendChargeByte);
n = 0;
offlineTime = DateTime.Now;
}
n++;
}
else
{
n = 0;
offlineTime = DateTime.Now;
}
}
//if (!client.Connected)
//{
// Console.WriteLine("客户端断开连接，退出循环");
// running = false;
//}
}
catch (Exception ex)
{
Console.WriteLine($"充电桩通信异常：{ExceptionFormatter.FormatEx(ex)}");
running = false;
client.Close();
tcpListener.Stop();
stream.Close();
}
}
}
public override void SendToChargeStation(int isCharge, Car car,Site site)
{
var messageService = CommunicationMessageService.Instance;
float setVoltage = 55.0f;
float setElectricCurrent = 50.0f;
float voltage = 430;
// Site site = null;
if (car != null)
{
// site = SimpleLib.GetSite(car.status.holdingLocks.FirstOrDefault());
int carId = 0;
if (car != null && car.GetType() != typeof(DummyCar))
{
voltage = float.Parse(Commons.GetCarStatus(car, "Voltage")) * 10;
voltage = voltage > 430 ? voltage : 430;
carId = car.id;
}
}
if (site != null && site.fields.ContainsKey("setVoltage") && site.fields.ContainsKey("setElectricCurrent"))
{
setVoltage = float.Parse(site.fields["setVoltage"]);
setElectricCurrent = float.Parse(site.fields["setElectricCurrent"]);
}
var byte1 = BitConverter.GetBytes(voltage);
var type = ReceiveMesageType();
var openChargePort = isCharge == 1 ? 2 : 3;
//下发打开充电口指令
var timestampBytes = GetTimeStamp();
byte[] dataByte = new byte[18]
{
0, 0x0F,
0, 0, 0, 0, 0, 0, 0, 0, 0,
0x11,
(byte)openChargePort,//开始充电/结束充电
byte1[0], byte1[1],
0xc8, 0x00,//下发最大充电电流
0x02//电池种类
};
dataByte = InitSendBytes(dataByte, type, timestampBytes);
byte[] openCharge =
CombineDataAndCRC(dataByte, CalculateCRC16(dataByte.Skip(1).ToArray()));
if (client.Connected)
{
stream.WriteAsync(openCharge, 0, openCharge.Length);
stream.FlushAsync();
}
messageService.AddSendMessage(_endPoint.Address.ToString(), _endPoint.Port, BitConverter.ToString(openCharge).Replace("-", " "), site?.name, "MuXing");
Diagnosis.Post($"openCharge => {string.Join(" ", openCharge.Select(d => $"{d:X2}"))}",
$"下发开始充电");
}
public void StartSendingHeartBeat()
{
if (client == null)
{
Console.WriteLine("客户端为null，无法启动心跳包定时器");
return;
}
_Timer = new System.Timers.Timer(2000);
_Timer.Elapsed += SendHeartBeat;
_Timer.AutoReset = true; // 反复执行
_Timer.Enabled = true;
}
private void SendHeartBeat(Object item, ElapsedEventArgs e)
{
var timestampBytes = GetTimeStamp();
var type = ReceiveMesageType();
//下发心跳包报文
var rcs = new byte[]
{
0xBB, 0x09, 0x00, 0x03, 0x00,
IdBytes[0], IdBytes[1],
timestampBytes[0], timestampBytes[1], timestampBytes[2], timestampBytes[3],
0xF0
};
byte[] mesSendByte = CombineDataAndCRC(rcs, CalculateCRC16(rcs.Skip(1).ToArray()));
// 日志记录
Diagnosis.Post($"heartBeat => {string.Join(" ", mesSendByte.Select(d => $"{d:X2}"))}", $"下发心跳包");
// 发送心跳包
SendMessage(mesSendByte);
}
private byte[] GetTimeStamp()
{
// 获取当前时间戳（秒级别）
int timestamp = (int)DateTimeOffset.UtcNow.ToUnixTimeSeconds();
//将时间戳转换为字节数组，低字节在前
byte[] timestampBytes = BitConverter.GetBytes(timestamp);
return timestampBytes;
}
private static Tuple<byte, byte, byte, byte, byte> ReceiveMesageType()
{
byte[] message = new byte[1024];
int bytesRead = 0;
try
{
if (client != null && client.Connected && stream != null && stream.CanRead && client.Available > 0)
{
bytesRead = stream.Read(message, 0, 1024);
}
}
catch (Exception ex)
{
client = null;
stream = null;
Console.WriteLine($"Error reading message: {ex.Message}");
}
//message长度判断：至少需要 13 字节才能安全访问 message[12]
if (bytesRead >= 13)
{
string receivedMessage = BitConverter.ToString(message, 0, bytesRead);
Diagnosis.Post($"Received <= {string.Join(" ", message.Take(bytesRead).ToArray().Select(d => $"{d:X2}"))}", "读取报文");
Diagnosis.Post($"item1:{message[0]:x2},item2:{message[11]:x2},item3:{message[12]:x2},item4:{message[5]:x2},item5:{message[6]:x2},", "Tuple.Item");
var messageService = CommunicationMessageService.Instance;
messageService.AddReceiveMessage(_endPoint.Address.ToString(), _endPoint.Port, string.Join(",", message), "MuXing");
return Tuple.Create<byte, byte, byte, byte, byte>(message[0], message[11], message[12], message[5], message[6]);
}
return new Tuple<byte, byte, byte, byte, byte>(0, 0, 0, 0, 0);
}
public static byte[] CombineDataAndCRC(byte[] data, byte[] crc)
{
//byte[] crcBytes = BitConverter.GetBytes(crc);
// 合并数据和CRC
byte[] combined = new byte[data.Length + crc.Length];
Array.Copy(data, combined, data.Length);
Array.Copy(crc, 0, combined, data.Length, crc.Length);
return combined;
}
private static byte[] CalculateCRC16(byte[] data)
{
byte b = byte.MaxValue;
byte b2 = byte.MaxValue;
byte b3 = 1;
byte b4 = 160;
for (int i = 0; i < data.Length; i++)
{
b = (byte)(b ^ data[i]);
for (int j = 0; j <= 7; j++)
{
byte b5 = b2;
byte b6 = b;
b2 = (byte)(b2 >> 1);
b = (byte)(b >> 1);
if ((b5 & 1) == 1)
{
b = (byte)(b | 0x80u);
}
if ((b6 & 1) == 1)
{
b2 = (byte)(b2 ^ b4);
b = (byte)(b ^ b3);
}
}
}
return new byte[2]
{
b,b2
};
}
private void SendMessage(byte[] message)
{
try
{
if (client != null && stream != null)
{
stream.Write(message, 0, message.Length);
stream.Flush();
}
}
catch (Exception ex)
{
client = null;
Console.WriteLine($"Error sending message: {ExceptionFormatter.FormatEx(ex)}");
}
}
private byte[] InitSendBytes(byte[] sendBytes, Tuple<byte, byte, byte, byte, byte> type, byte[] timestampBytes)
{
sendBytes[0] = 0xBB; //帧头
sendBytes[2] = 0x00; //帧长 高
sendBytes[3] = 0x03; //设备类型 低
sendBytes[4] = 0x00; //设备类型 高
sendBytes[5] = IdBytes[0]; //设备ID 低
sendBytes[6] = IdBytes[1]; //设备ID 高
sendBytes[7] = timestampBytes[0]; //时间戳 低
sendBytes[8] = timestampBytes[1];
sendBytes[9] = timestampBytes[2];
sendBytes[10] = timestampBytes[3]; //时间戳 高
return sendBytes;
}
}
}
StandardScene.Devices/Charge/PCBChargeStation.cs
+147
View File
@@ -0,0 +1,147 @@
using SimpleLite.RCS;
using SimpleLite.RCS.CarTypes;
using SimpleCore;
using SimpleCore.Library;
using SimpleCore.PropType;
using StandardScene.Charge;
using System;
using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
using static SimpleCore.Traffic.TrafficControl;
namespace StandardScene.ChargeStationType
{
public class PCBChargeStation : AbstractChargeStation
{
private int _index = 0;
public int IndexReceive;
private IPEndPoint _endPoint;
public override void OnUdpMessage(byte[] message)
{
if (message != null && message.Length > 1)
IndexReceive = message[1];
}
public override void CreateCommunication(IPAddress ip, int port)
{
_endPoint = new IPEndPoint(ip, port);
}
public override void SendToChargeStation(int isCharge, Car car,Site site)
{
var messageService = CommunicationMessageService.Instance;
using (UdpClient udpClient = new UdpClient())
{
//float soc = 0f, voltage = 0, electricCurrent = 0, chargeTimeSpan = 30f;
float setVoltage = 29.2f;
float setElectricCurrent = 40.0f;
float soc = 0f, voltage = 0, electricCurrent = 0, chargeTimeSpan = 30f;
int carId = 0;
//Site site = null;
if (car != null)
{
carId = car.id;
soc = (float)Commons.CarValue(car, "Soc");
voltage = (float)Commons.CarValue(car, "Voltage");
electricCurrent = (float)Commons.CarValue(car, "ElectricCurrent");
//site = SimpleLib.GetSite(car.status.holdingLocks.FirstOrDefault());
}
if (site != null && site.fields.ContainsKey("setVoltage") && site.fields.ContainsKey("setElectricCurrent"))
{
setVoltage = float.Parse(site.fields["setVoltage"]);
setElectricCurrent = float.Parse(site.fields["setElectricCurrent"]);
}
var msg = GetSendBytes((byte)isCharge, setVoltage, setElectricCurrent, chargeTimeSpan,
carId, soc, electricCurrent, voltage);
messageService.AddSendMessage(_endPoint.Address.ToString(), _endPoint.Port, BitConverter.ToString(msg).Replace("-", " "), "FRLDShort", site?.name);
Diagnosis.Log($"ChargeStation ADD:[{BitConverter.ToString(msg).Replace("-", " ")}]", "UDP发送报文信息", true);
udpClient.SendAsync(msg, msg.Length, _endPoint);
Thread.Sleep(100);
}
}
private byte[] GetSendBytes(byte startCharge, float chargeVoltage, float chargeElectricCurrent, float chargeTimeSpan, int carId, float carSoc, float carElectricCurrent, float carVoltage)
{
var sendBytes = new byte[32];
var indexNo = (byte)GetIndexNo();
try
{
sendBytes = new byte[3] { 0xBB, indexNo, startCharge }
.Concat(BitConverter.GetBytes((int)chargeElectricCurrent * 10).AsEnumerable().Reverse())
.Concat(BitConverter.GetBytes((int)chargeVoltage * 10).AsEnumerable().Reverse())
.Concat(BitConverter.GetBytes((ushort)chargeTimeSpan).AsEnumerable().Reverse())
.Concat(BitConverter.GetBytes((ushort)carId).AsEnumerable().Reverse())
.Concat([(byte)carSoc])
.Concat(BitConverter.GetBytes((int)(carElectricCurrent * 10)).AsEnumerable().Reverse())
.Concat(BitConverter.GetBytes((int)(carVoltage * 10)).AsEnumerable().Reverse())
.Concat(new byte[] { 00, 00, 00, 00, 00, 00, 00, 0xEE }).ToArray();
var crcCode = GetCRC(sendBytes.Skip(1).Take(28).ToArray()).AsEnumerable().Reverse().ToArray();
sendBytes[29] = crcCode[0];
sendBytes[30] = crcCode[1];
}
catch (Exception ex)
{
Diagnosis.Log($"充电报文组包异常 ex => {ex.Message}", "充电", true);
}
return sendBytes;
}
private byte[] GetCRC(byte[] data)
{
byte b = byte.MaxValue;
byte b2 = byte.MaxValue;
byte b3 = 1;
byte b4 = 160;
for (int i = 0; i < data.Length; i++)
{
b = (byte)(b ^ data[i]);
for (int j = 0; j <= 7; j++)
{
byte b5 = b2;
byte b6 = b;
b2 = (byte)(b2 >> 1);
b = (byte)(b >> 1);
if ((b5 & 1) == 1)
{
b = (byte)(b | 0x80u);
}
if ((b6 & 1) == 1)
{
b2 = (byte)(b2 ^ b4);
b = (byte)(b ^ b3);
}
}
}
return new byte[2]
{
b,b2
};
}
private int GetIndexNo()
{
if (_index < 255)
{
_index = _index + 1;
}
else
{
_index = 0;
}
return _index;
}
}
}
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();
}
}
}
StandardScene.Devices/StandardScene.Devices.csproj
+54
View File
@@ -0,0 +1,54 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net8.0-windows</TargetFramework>
<OutputType>Library</OutputType>
<UseWindowsForms>true</UseWindowsForms>
<RootNamespace>StandardScene</RootNamespace>
<AssemblyName>StandardScene.Devices</AssemblyName>
<LangVersion>latest</LangVersion>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<Platforms>AnyCPU;x64</Platforms>
<PlatformTarget>x64</PlatformTarget>
<Deterministic>true</Deterministic>
<GenerateAssemblyInfo>false</GenerateAssemblyInfo>
<ImplicitUsings>disable</ImplicitUsings>
<Nullable>disable</Nullable>
<AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
<NoWarn>$(NoWarn);NU1701;CS0618;CS0612;MSB3277;CA1416</NoWarn>
<AssemblySearchPaths>{HintPathFromItem};{TargetFrameworkDirectory};{RawFileName};{GAC}</AssemblySearchPaths>
</PropertyGroup>
<!-- 插件清单：随 dll 输出，供 SimpleLite plugins 选择性加载（约定 <dll>.scene.json） -->
<ItemGroup>
<None Update="StandardScene.Devices.scene.json" CopyToOutputDirectory="PreserveNewest" />
</ItemGroup>
<!-- 基座：各设备抽象基类 + 注册特性 + 业务编排(Mission/Manager/UdpService) 均留 Core；本 dll 仅含具体驱动（门/充电桩/按钮盒） -->
<ItemGroup>
<ProjectReference Include="..\StandardScene.Core\StandardScene.Core.csproj" />
</ItemGroup>
<!-- 与 Core 一致的本地契约/工具 dll + Leeg 按钮盒 SDK（leegiot）；Modbus/TCP 经 Core 的 Utils/TCP 间接使用，无需 NuGet -->
<ItemGroup>
<Reference Include="SimpleLite">
<HintPath>E:\Work\Core\Simple-FR\Simple\SimpleLite\bin\Debug\SimpleLite.dll</HintPath>
</Reference>
<Reference Include="SimpleCore">
<HintPath>E:\Work\Core\Simple-FR\Simple\SimpleCore\bin\Debug\netstandard2.0\SimpleCore.dll</HintPath>
</Reference>
<Reference Include="CommonUsage">
<HintPath>D:\MDCS\Dependencies\Commons\CommonUsage.dll</HintPath>
</Reference>
<Reference Include="Topaz">
<HintPath>E:\Work\Core\Simple-FR\Simple\tools\Topaz.dll</HintPath>
</Reference>
<Reference Include="LessokajiWeaverUtilities">
<HintPath>E:\Work\Core\Simple-FR\Simple\SimpleLite\bin\Debug\LessokajiWeaverUtilities.dll</HintPath>
</Reference>
<Reference Include="leegKeys-sdk">
<HintPath>..\StandardScene.Core\Ref\leegKeys-sdk.dll</HintPath>
</Reference>
</ItemGroup>
</Project>
StandardScene.Devices/StandardScene.Devices.scene.json
+12
View File
@@ -0,0 +1,12 @@
{
"id": "scene.device",
"displayName": "设备驱动（门 / 充电桩 / 按钮盒）",
"assembly": "StandardScene.Devices.dll",
"coreVersion": ">=1.0.0",
"requiresCore": "StandardScene.dll",
"provides": {
"doorControllers": [ "ModbusDoorController" ],
"chargeStations": [ "FLChargeStation", "PCBChargeStation", "MuXingChargeStation" ],
"buttonBoxes": [ "LeegButtonBox", "AzowieButtonBox" ]
}
}