using HslCommunication;
|
using System.ComponentModel;
|
using System.Reflection;
|
using WIDESEAWCS_Communicator;
|
using WIDESEAWCS_QuartzJob.DeviceBase;
|
using WIDESEAWCS_QuartzJob.DTO;
|
using WIDESEAWCS_QuartzJob.StackerCrane;
|
using WIDESEAWCS_QuartzJob.StackerCrane.Enum;
|
|
namespace WIDESEAWCS_QuartzJob
|
{
|
/// <summary>
|
/// 自定义堆垛机
|
/// </summary>
|
[Description("化成分容堆垛机")]
|
public class SpeFormationStackerCrane : IStackerCrane
|
{
|
#region Private Member
|
|
/// <summary>
|
/// 堆垛机通讯对象
|
/// </summary>
|
private BaseCommunicator _communicator;
|
|
/// <summary>
|
/// 堆垛机协议信息
|
/// </summary>
|
private readonly List<DeviceProDTO> _deviceProDTOs;
|
|
/// <summary>
|
/// 堆垛机协议明细信息
|
/// </summary>
|
private readonly List<DeviceProtocolDetailDTO> _deviceProtocolDetailDTOs;
|
|
/// <summary>
|
/// 设备编号
|
/// </summary>
|
public readonly string _deviceCode;
|
|
/// <summary>
|
/// 设备名称
|
/// </summary>
|
public readonly string _deviceName;
|
|
/// <summary>
|
/// 上一次任务号
|
/// </summary>
|
private int _lastTaskNum;
|
|
private bool _isChecked = false;
|
|
private bool _heartStart = true;
|
|
private bool _isConnected = true;
|
|
#endregion Private Member
|
|
#region Public Member
|
|
/// <summary>
|
/// 通讯对象
|
/// </summary>
|
public BaseCommunicator Communicator => _communicator;
|
|
/// <summary>
|
/// 通讯协议信息
|
/// </summary>
|
public List<DeviceProDTO> DeviceProDTOs => _deviceProDTOs;
|
|
/// <summary>
|
/// 通讯协议明细信息
|
/// </summary>
|
public List<DeviceProtocolDetailDTO> DeviceProtocolDetailDTOs => _deviceProtocolDetailDTOs;
|
|
public FormationStackerCraneTaskCompletionStatus StackerCraneCompletionValue => GetStackerCraneCompletionStatus();
|
|
/// <summary>
|
/// 堆垛机状态
|
/// </summary>
|
public FormationStackerCraneRunStatus StackerCraneStatusValue => GetStackerCraneStatus();
|
|
/// <summary>
|
/// 堆垛机状态中文说明
|
/// </summary>
|
public string StackerCraneStatusDes => GetEnumDes(StackerCraneStatusValue);
|
|
/// <summary>
|
/// 作业状态
|
/// </summary>
|
public FormationStackerCraneOperationStatus StackerCraneWorkStatusValue => GetStackerCraneWorkStatus();
|
|
/// <summary>
|
/// 作业状态中文说明
|
/// </summary>
|
public string StackerCraneWorkStatusDes => GetEnumDes(StackerCraneWorkStatusValue);
|
|
/// <summary>
|
/// 上一次执行的任务号
|
/// </summary>
|
public int LastTaskNum => _lastTaskNum;
|
|
/// <summary>
|
/// 当前正在执行的任务号
|
/// </summary>
|
public int CurrentTaskNum => GetCurrentTaskNum();
|
|
/// <summary>
|
/// 上一次执行的任务类型
|
/// </summary>
|
public int? LastTaskType { get; set; } = null;
|
|
/// <summary>
|
/// 设备编号
|
/// </summary>
|
public string DeviceCode => _deviceCode;
|
|
/// <summary>
|
/// 设备名称
|
/// </summary>
|
public string DeviceName => _deviceName;
|
|
/// <summary>
|
/// 设备是否已连接
|
/// </summary>
|
public bool IsConnected => Communicator.IsConnected && _isConnected;
|
|
/// <summary>
|
/// 堆垛机任务命令
|
/// </summary>
|
public object StackerCraneTaskCommand { get; set; }
|
|
/// <summary>
|
/// 堆垛机任务完成事件
|
/// </summary>
|
public event EventHandler<StackerCraneTaskCompletedEventArgs> StackerCraneTaskCompletedEventHandler;
|
|
/// <summary>
|
/// 堆垛机完成事件是否已订阅
|
/// </summary>
|
public bool IsEventSubscribed => StackerCraneTaskCompletedEventHandler != null;
|
|
#endregion Public Member
|
|
#region Constructor Function
|
|
/// <summary>
|
/// 构造函数
|
/// </summary>
|
/// <param name="communicator">堆垛机通讯对象</param>
|
/// <param name="deviceProDTOs">堆垛机协议信息</param>
|
/// <param name="deviceProtocolDetailDTOs">堆垛机协议明细信息</param>
|
/// <param name="deviceCode">设备编号</param>
|
/// <param name="deviceName">设备名称</param>
|
public SpeFormationStackerCrane(BaseCommunicator communicator, List<DeviceProDTO> deviceProDTOs, List<DeviceProtocolDetailDTO> deviceProtocolDetailDTOs, string deviceCode, string deviceName)
|
{
|
_communicator = communicator;
|
_deviceProDTOs = deviceProDTOs;
|
_deviceProtocolDetailDTOs = deviceProtocolDetailDTOs;
|
_deviceCode = deviceCode;
|
_deviceName = deviceName;
|
CheckConnect();
|
}
|
|
#endregion Constructor Function
|
|
#region Private Method
|
|
private object GetStatus(string protocolParamType)
|
{
|
if (!Communicator.IsConnected)
|
{
|
return StackerCraneStatus.Unkonw.ToString();
|
}
|
|
List<DeviceProDTO> devicePros = _deviceProDTOs.Where(x => x.DeviceProParamType == protocolParamType).ToList();
|
if (devicePros.Count == 0)
|
{
|
throw new Exception($"未获取到协议信息，协议参数类型：{protocolParamType}");
|
}
|
|
foreach (var devicePro in devicePros)
|
{
|
object readStatus = Communicator.ReadAsObj(devicePro.DeviceProAddress, devicePro.DeviceDataType);
|
|
DeviceProtocolDetailDTO? deviceProtocolDetail = _deviceProtocolDetailDTOs.FirstOrDefault(
|
x => x.DeviceProParamName == devicePro.DeviceProParamType
|
&& x.ProtocalDetailValue.Equals(readStatus.ToString()));
|
|
if (deviceProtocolDetail != null)
|
{
|
return Convert.ToInt32(readStatus);
|
}
|
}
|
|
return StackerCraneStatus.Unkonw.ToString();
|
}
|
|
/// <summary>
|
/// 获取堆垛机设备状态
|
/// </summary>
|
/// <returns></returns>
|
private FormationStackerCraneRunStatus GetStackerCraneStatus()
|
{
|
return (FormationStackerCraneRunStatus)GetStatus(nameof(FormationStackerCraneRunStatus));
|
}
|
|
/// <summary>
|
/// 获取堆垛机工作状态
|
/// </summary>
|
/// <returns></returns>
|
private FormationStackerCraneOperationStatus GetStackerCraneWorkStatus()
|
{
|
return (FormationStackerCraneOperationStatus)GetStatus(nameof(FormationStackerCraneOperationStatus));
|
}
|
|
private FormationStackerCraneTaskCompletionStatus GetStackerCraneCompletionStatus()
|
{
|
return (FormationStackerCraneTaskCompletionStatus)GetStatus(nameof(FormationStackerCraneTaskCompletionStatus));
|
}
|
|
/// <summary>
|
/// 获取枚举说明
|
/// </summary>
|
/// <typeparam name="T">枚举泛型</typeparam>
|
/// <param name="value"></param>
|
/// <returns></returns>
|
private string GetEnumDes<T>(T value) where T : Enum
|
{
|
FieldInfo? fieldInfo = typeof(T).GetField(value.ToString());
|
if (fieldInfo != null)
|
{
|
DescriptionAttribute? descriptionAttribute = fieldInfo.GetCustomAttribute<DescriptionAttribute>();
|
if (descriptionAttribute != null)
|
{
|
return descriptionAttribute.Description;
|
}
|
return "未定义";
|
}
|
return "未知";
|
}
|
|
private int GetCurrentTaskNum()
|
{
|
DeviceProDTO? devicePro = _deviceProDTOs.FirstOrDefault(x => x.DeviceProParamName == nameof(CurrentTaskNum));
|
return devicePro == null ? throw new Exception($"读取当前任务号错误,未获取到协议信息,请检查配置参数名称是否配置,且配置为{nameof(CurrentTaskNum)}") : (int)Communicator.ReadAsObj(devicePro.DeviceProAddress, devicePro.DeviceDataType);
|
}
|
|
private void CheckConnect()
|
{
|
Task.Run(() =>
|
{
|
while (_heartStart)
|
{
|
try
|
{
|
DeviceProDTO? devicePro = _deviceProDTOs.FirstOrDefault();
|
if (devicePro == null)
|
{
|
_isConnected = false;
|
}
|
else
|
{
|
Communicator.ReadAsObj(devicePro.DeviceProAddress, devicePro.DeviceDataType);
|
_isConnected = true;
|
}
|
}
|
catch (Exception ex)
|
{
|
_isConnected = false;
|
}
|
Thread.Sleep(500);
|
}
|
});
|
}
|
|
#endregion Private Method
|
|
#region Public Method
|
|
/// <summary>
|
/// 获取堆垛机状态
|
/// </summary>
|
public T GetStackerCraneStatus<T>() where T : notnull, Enum
|
{
|
return (T)GetStatus(typeof(T).Name);
|
}
|
|
/// <summary>
|
/// 释放对象
|
/// </summary>
|
public void Dispose()
|
{
|
_heartStart = false;
|
_communicator.Dispose();
|
GC.SuppressFinalize(this);
|
}
|
|
/// <summary>
|
/// 根据参数名称读取堆垛机对应的数据。
|
/// </summary>
|
/// <typeparam name="TEnum">参数名称枚举类型。</typeparam>
|
/// <typeparam name="TResult">读取结果的返回值类型。</typeparam>
|
/// <param name="value">参数名称。</param>
|
/// <returns>返回读取到的数据。</returns>
|
/// <exception cref="Exception"></exception>
|
public TResult GetValue<TEnum, TResult>(TEnum value) where TEnum : Enum
|
{
|
if (!IsConnected) throw new Exception($"通讯连接错误，请检查网络");
|
DeviceProDTO? devicePro = _deviceProDTOs.FirstOrDefault(x => x.DeviceProParamName == value.ToString());
|
return devicePro == null ? throw new Exception($"读取数据错误,未在协议信息里面找到参数{value.ToString()}") : (TResult)Communicator.ReadAsObj(devicePro.DeviceProAddress, devicePro.DeviceDataType);
|
}
|
|
/// <summary>
|
/// 心跳
|
/// </summary>
|
public void Heartbeat()
|
{
|
}
|
|
/// <summary>
|
/// 发送任务命令
|
/// </summary>
|
/// <param name="command">任务命令</param>
|
/// <returns></returns>
|
public bool SendCommand<T>(T command) where T : IDataTransfer, new()
|
{
|
if (Communicator is SiemensS7)
|
{
|
if (!IsConnected) throw new Exception($"通讯连接错误，请检查网络");
|
DeviceProDTO? devicePro = _deviceProDTOs.Where(x => x.DeviceProParamType == nameof(DeviceCommand)).OrderBy(x => x.DeviceProOffset).FirstOrDefault();
|
if (devicePro == null)
|
{
|
return false;
|
}
|
if (Communicator.WriteCustomer(devicePro.DeviceProAddress, command))
|
{
|
StackerCraneTaskCommand = command;
|
//CheckStackerCraneTaskCompleted();
|
return true;
|
}
|
return false;
|
}
|
else
|
{
|
throw new Exception("暂不支持除西门子之外的PLC");
|
}
|
}
|
|
/// <summary>
|
/// 监测堆垛机任务是否完成(防止任务完成事件监测超时，定义手动触发功能)
|
/// </summary>
|
public void CheckStackerCraneTaskCompleted()
|
{
|
if (_isChecked)
|
return;
|
|
Task.Run(() =>
|
{
|
_isChecked = true;
|
try
|
{
|
DeviceProDTO? devicePro = _deviceProDTOs.FirstOrDefault(x => x.DeviceProParamName == nameof(FormationStackerCraneTaskCompletionStatus));
|
if (devicePro == null)
|
return;
|
|
DeviceProtocolDetailDTO? deviceProtocolDetail = _deviceProtocolDetailDTOs.FirstOrDefault(
|
x => x.DeviceProParamName == devicePro.DeviceProParamName
|
&& x.ProtocolDetailType == FormationStackerCraneTaskCompletionStatus.NormalCompleted.ToString());
|
|
if (deviceProtocolDetail == null)
|
return;
|
|
OperateResult<TimeSpan> operateResult = WaitForCompletion(devicePro, deviceProtocolDetail);
|
|
if (operateResult.IsSuccess)
|
{
|
int taskNum = CurrentTaskNum;
|
StackerCraneTaskCompletedEventArgs args = new(taskNum);
|
StackerCraneTaskCompletedEventHandler?.Invoke(this, args);
|
_lastTaskNum = taskNum;
|
}
|
}
|
catch (Exception ex)
|
{
|
// TODO: 添加日志记录
|
}
|
finally
|
{
|
_isChecked = false;
|
}
|
});
|
}
|
|
/// <summary>
|
/// 等待任务完成信号
|
/// </summary>
|
private OperateResult<TimeSpan> WaitForCompletion(DeviceProDTO devicePro, DeviceProtocolDetailDTO deviceProtocolDetail)
|
{
|
TypeCode typeCode = SiemensDBDataType.GetTypeCode(devicePro.DeviceDataType);
|
|
return typeCode switch
|
{
|
TypeCode.Boolean => Communicator.Wait(devicePro.DeviceProAddress, 500, 10 * 6000,
|
Convert.ToBoolean(deviceProtocolDetail.ProtocalDetailValue)),
|
|
TypeCode.Byte => Communicator.Wait(devicePro.DeviceProAddress, 500, 10 * 6000,
|
Convert.ToByte(deviceProtocolDetail.ProtocalDetailValue)),
|
|
TypeCode.Int16 => Communicator.Wait(devicePro.DeviceProAddress, 500, 10 * 6000,
|
Convert.ToInt16(deviceProtocolDetail.ProtocalDetailValue)),
|
|
TypeCode.Int32 => Communicator.Wait(devicePro.DeviceProAddress, 500, 10 * 6000,
|
Convert.ToInt32(deviceProtocolDetail.ProtocalDetailValue)),
|
|
TypeCode.UInt16 => Communicator.Wait(devicePro.DeviceProAddress, 500, 10 * 6000,
|
Convert.ToUInt16(deviceProtocolDetail.ProtocalDetailValue)),
|
|
TypeCode.UInt32 => Communicator.Wait(devicePro.DeviceProAddress, 500, 10 * 6000,
|
Convert.ToUInt32(deviceProtocolDetail.ProtocalDetailValue)),
|
|
_ => new OperateResult<TimeSpan>()
|
};
|
}
|
|
/// <summary>
|
/// 根据参数名称写入堆垛机对应的数据。
|
/// </summary>
|
/// <typeparam name="TEnum">参数名称枚举类型。</typeparam>
|
/// <typeparam name="TValue">要写入的数据类型。</typeparam>
|
/// <param name="enum">参数名称。</param>
|
/// <param name="value">要写入的数据。</param>
|
/// <returns>返回写入成功或失败</returns>
|
/// <exception cref="Exception"></exception>
|
public bool SetValue<TEnum, TValue>(TEnum @enum, TValue value)
|
where TEnum : Enum
|
where TValue : notnull
|
{
|
if (!IsConnected) throw new Exception($"通讯连接错误，请检查网络");
|
DeviceProDTO? devicePro = _deviceProDTOs.FirstOrDefault(x => x.DeviceProParamName == @enum.ToString());
|
return devicePro == null ? throw new Exception($"写入数据错误,未在协议信息里面找到参数{value.ToString()}") : Communicator.WriteObj(devicePro.DeviceProAddress, devicePro.DeviceDataType, value);
|
}
|
|
#endregion Public Method
|
}
|
}
|
