using Bro.Common.Base;
|
using Bro.Common.Helper;
|
using Bro.Common.Interface;
|
using Bro.Common.Model;
|
using System;
|
using System.Collections.Generic;
|
using System.Diagnostics;
|
using System.IO.Ports;
|
using System.Linq;
|
using System.Text;
|
using System.Threading;
|
using System.Threading.Tasks;
|
using static Bro.Common.Helper.EnumHelper;
|
|
namespace Bro.Device.DAMModule
|
{
|
[Device("DAMModule", "DAM模块", EnumHelper.DeviceAttributeType.Device)]
|
public class DAMDriver : DeviceBase, IMonitor
|
{
|
#region IMonitor
|
public List<int> InputIOs { get; set; } = new List<int>();
|
public List<int> OutputIOs { get; set; } = new List<int>();
|
|
public event Action<DateTime, string, IDevice, MonitorSet> OnMonitorInvoke;
|
public event Action<DateTime, IDevice, WarningSet> OnMonitorAlarm;
|
|
public void Monitor()
|
{
|
while (CurrentState == EnumHelper.DeviceState.DSOpen)
|
{
|
if (!IConfig.IsEnableMonitor)
|
return;
|
|
_writeHandle.WaitOne();
|
|
lock (_writeLock)
|
{
|
sp.Write(byteReadAllInput, 0, byteReadAllInput.Length);
|
Thread.Sleep(IConfig.ReadWaitTime);
|
byte[] recBuffer = new byte[2048];
|
int recNum = sp.Read(recBuffer, 0, recBuffer.Length);
|
if (recNum > 0)
|
{
|
var data = AnalysisRcv(recBuffer.Take(recNum).ToArray()).ToList();
|
List<int> temp = new List<int>();
|
data.ForEach(d =>
|
{
|
for (int i = 0; i < 8; i++)
|
{
|
temp.Add((d >> i) & 1);
|
}
|
});
|
|
if (temp.Count() == InputIOs.Count())
|
{
|
MonitorCheckAndInvoke(temp, new List<int>(InputIOs));
|
}
|
|
InputIOs = new List<int>(temp);
|
}
|
|
if (IConfig.IsMonitorOutput)
|
{
|
sp.Write(byteReadAllOutput, 0, byteReadAllOutput.Length);
|
Thread.Sleep(IConfig.ReadWaitTime);
|
recBuffer = new byte[2048];
|
recNum = sp.Read(recBuffer, 0, recBuffer.Length);
|
if (recNum > 0)
|
{
|
var data = AnalysisRcv(recBuffer.Take(recNum).ToArray()).ToList();
|
List<int> temp = new List<int>();
|
data.ForEach(d =>
|
{
|
for (int i = 0; i < 8; i++)
|
{
|
temp.Add((d >> i) & 1);
|
}
|
});
|
|
OutputIOs = new List<int>(temp);
|
}
|
}
|
}
|
|
if (IConfig.MonitorInterval > 0)
|
Thread.Sleep(IConfig.MonitorInterval);
|
}
|
}
|
|
private async void MonitorCheckAndInvoke(List<int> tempNew, List<int> tempOld)
|
{
|
await Task.Run(() =>
|
{
|
Parallel.ForEach(IConfig.MonitorSetCollection, set =>
|
{
|
MonitorSet monitorSet = set as MonitorSet;
|
if (monitorSet.TriggerIndex < 0 || monitorSet.TriggerIndex >= tempNew.Count)
|
{
|
return;
|
}
|
|
int newValue = tempNew[monitorSet.TriggerIndex];
|
int oldValue = tempOld[monitorSet.TriggerIndex];
|
|
if (newValue != oldValue)
|
{
|
if (monitorSet.TriggerValue == -999 || newValue == monitorSet.TriggerValue)
|
{
|
if (monitorSet.OpConfig == null)
|
{
|
monitorSet.OpConfig = new OperationConfigBase();
|
}
|
|
monitorSet.OpConfig.InputPara = monitorSet.InputDataIndex.ConvertAll(index =>
|
{
|
return tempNew[index];
|
}).ToList();
|
|
OnMonitorInvoke?.BeginInvoke(DateTime.Now, monitorSet.InvokeDevice, this, monitorSet, OnMethodInvoked, monitorSet);
|
}
|
}
|
});
|
});
|
}
|
|
private void OnMethodInvoked(IAsyncResult ar)
|
{
|
MonitorSet monitorSet = ar.AsyncState as MonitorSet;
|
|
ProcessResponse resValues = monitorSet.Response;
|
|
if (resValues.ResultValue == (int)PLCReplyValue.IGNORE)
|
{
|
return;
|
}
|
|
Stopwatch sw = new Stopwatch();
|
sw.Start();
|
|
//if (monitorSet.ReplyDataAddress != -1 && resValues.DataList.Count > 0)
|
//{
|
// PLCItem item = new PLCItem
|
// {
|
// ItemLength = resValues.DataList.Count,
|
// Address = monitorSet.ReplyDataAddress.ToString(),
|
// ItemValues = resValues.DataList.ConvertAll(s => int.Parse(s.ToString())).ToList()
|
// };
|
// WriteItem(item, false);
|
//}
|
|
if (monitorSet.NoticeAddress != -1)
|
{
|
int repeatTime = 5;
|
|
do
|
{
|
try
|
{
|
WriteOutput(monitorSet.NoticeAddress, resValues.ResultValue == 1);
|
repeatTime = 0;
|
}
|
catch (Exception ex)
|
{
|
repeatTime--;
|
|
if (repeatTime <= 0)
|
{
|
new ProcessException($"{Name}反馈写入异常", ex, ExceptionLevel.Warning);
|
}
|
}
|
} while (repeatTime > 0);
|
}
|
|
sw.Stop();
|
LogAsync(DateTime.Now, $"{Name}反馈完成，耗时{sw.ElapsedMilliseconds}ms", $"{resValues.GetDisplayText()}");
|
}
|
|
private byte[] AnalysisRcv(byte[] src)
|
{
|
if (src.Length < 6) return null;
|
if (src[0] != Convert.ToInt16(IConfig.UnitNum)) return null;
|
|
switch (src[1])
|
{
|
case 0x01:
|
if (CMBRTU.CalculateCrc(src, src[2] + 5) == 0x00)
|
{
|
byte[] dst = new byte[src[2]];
|
for (int i = 0; i < src[2]; i++)
|
dst[i] = src[3 + i];
|
return dst;
|
}
|
break;
|
case 0x02:
|
if (CMBRTU.CalculateCrc(src, src[2] + 5) == 0x00)
|
{
|
byte[] dst = new byte[src[2]];
|
for (int i = 0; i < src[2]; i++)
|
dst[i] = src[3 + i];
|
return dst;
|
}
|
break;
|
case 0x04:
|
if (CMBRTU.CalculateCrc(src, src[2] + 5) == 0x00)
|
{
|
byte[] dst = new byte[src[2]];
|
for (int i = 0; i < src[2]; i++)
|
dst[i] = src[3 + i];
|
return dst;
|
}
|
break;
|
case 0x05:
|
if (CMBRTU.CalculateCrc(src, 8) == 0x00)
|
{
|
byte[] dst = new byte[1];
|
dst[0] = src[4];
|
return dst;
|
}
|
break;
|
case 0x0f:
|
if (CMBRTU.CalculateCrc(src, 8) == 0x00)
|
{
|
byte[] dst = new byte[1];
|
dst[0] = 1;
|
return dst;
|
}
|
break;
|
}
|
return null;
|
}
|
|
public void ResetAlarm()
|
{
|
|
}
|
|
ManualResetEvent _writeHandle = new ManualResetEvent(true);
|
object _writeLock = new object();
|
public void WriteOutput(int index, bool isOpen, bool isShortSingal = true, int elaspedTime = 0)
|
{
|
_writeHandle.Reset();
|
lock (_writeLock)
|
{
|
try
|
{
|
if (index < 0 || index > IConfig.OutputNums)
|
{
|
LogAsync(DateTime.Now, $"写入索引{index}超限，写入失败", "");
|
}
|
|
byte[] byteData = CModbusDll.WriteDO(IConfig.UnitNum, index, isOpen);
|
sp.Write(byteData, 0, byteData.Length);
|
|
if (isShortSingal)
|
{
|
if (elaspedTime == 0)
|
{
|
elaspedTime = IConfig.SignalElasped;
|
}
|
|
Thread.Sleep(elaspedTime);
|
byteData = CModbusDll.WriteDO(IConfig.UnitNum, index, !isOpen);
|
sp.Write(byteData, 0, byteData.Length);
|
}
|
|
Thread.Sleep(IConfig.ReadWaitTime);
|
sp.ReadExisting();
|
}
|
catch (Exception ex)
|
{
|
throw ex;
|
}
|
finally
|
{
|
_writeHandle.Set();
|
}
|
}
|
}
|
#endregion
|
|
#region DeviceBase
|
SerialPort sp = null;
|
byte[] byteCloseAll = null;
|
byte[] byteOpenAll = null;
|
byte[] byteReadAllOutput = null;
|
byte[] byteReadAllInput = null;
|
|
DAMInitialConfig IConfig
|
{
|
get => InitialConfig as DAMInitialConfig;
|
}
|
|
protected override void Init()
|
{
|
sp = new SerialPort(IConfig.PortName);
|
sp.BaudRate = int.Parse(IConfig.BaudRate);
|
sp.Parity = IConfig.Parity;
|
sp.DataBits = IConfig.DataBits;
|
sp.StopBits = IConfig.StopBits;
|
|
byteCloseAll = CModbusDll.WriteAllDO(IConfig.UnitNum, IConfig.OutputNums, false);
|
byteOpenAll = CModbusDll.WriteAllDO(IConfig.UnitNum, IConfig.OutputNums, true);
|
byteReadAllOutput = CModbusDll.ReadDO(IConfig.UnitNum, IConfig.OutputNums);
|
byteReadAllInput = CModbusDll.ReadDI(IConfig.UnitNum, IConfig.InputNums);
|
}
|
|
protected override void Pause()
|
{
|
}
|
|
protected override void Resume()
|
{
|
}
|
|
protected override void Start()
|
{
|
sp.Open();
|
_writeHandle = new ManualResetEvent(true);
|
}
|
|
protected override void Stop()
|
{
|
if (sp != null && sp.IsOpen)
|
{
|
sp.Close();
|
}
|
|
_writeHandle.Set();
|
_writeHandle.Dispose();
|
}
|
#endregion
|
}
|
}
|
