831 lines
32 KiB
C#
831 lines
32 KiB
C#
using Cowain.Bake.Common.Core;
|
||
using Cowain.Bake.Communication.Interface;
|
||
using Cowain.Bake.Model.Entity;
|
||
using HslCommunication;
|
||
using HslCommunication.Core;
|
||
using Newtonsoft.Json;
|
||
using OpcUaHelper;
|
||
using Prism.Mvvm;
|
||
using Prism.Services.Dialogs;
|
||
using System;
|
||
using System.Collections.Generic;
|
||
using System.Collections.ObjectModel;
|
||
using System.Diagnostics;
|
||
using System.Linq;
|
||
using System.Reflection;
|
||
using System.Text;
|
||
using System.Text.RegularExpressions;
|
||
using System.Threading;
|
||
using System.Threading.Tasks;
|
||
using Unity;
|
||
using Cowain.Bake.Common.Models;
|
||
using Cowain.Bake.Model.Models;
|
||
using Cowain.Bake.Common;
|
||
using Opc.Ua;
|
||
using Cowain.Bake.BLL;
|
||
using Cowain.Bake.Common.Enums;
|
||
|
||
namespace Cowain.Bake.Communication.PLC
|
||
{
|
||
public abstract class PLCBase : BindableBase, IPLCDevice
|
||
{
|
||
protected IUnityContainer _unityContainer;
|
||
protected IDialogService _dialogService;
|
||
public virtual IReadWriteNet PLC { get; set; }
|
||
public OpcUaClient OPC { get; set; }
|
||
public IByteTransform ByteTransform { get; set; }
|
||
public virtual string IpAddress { get; set; } = "127.0.0.1";
|
||
public virtual int Port { get; set; }
|
||
public virtual byte Slot { get; set; }
|
||
public virtual string ConnectString { get; set; }
|
||
CancellationTokenSource cts = new CancellationTokenSource();
|
||
protected PLCBase(IUnityContainer unityContainer, IDialogService dialogService)
|
||
{
|
||
_unityContainer = unityContainer;
|
||
_dialogService = dialogService;
|
||
}
|
||
private int readUseTime;
|
||
public int ReadUseTime
|
||
{
|
||
get { return readUseTime; }
|
||
set { SetProperty(ref readUseTime, value); }
|
||
}
|
||
private bool isConnect;
|
||
public bool IsConnect
|
||
{
|
||
get { return isConnect; }
|
||
set { SetProperty(ref isConnect, value); }
|
||
}
|
||
public int Id { get; set; }
|
||
public string Name { get; set; }
|
||
public string DeviceName { get; set; }
|
||
public Dictionary<int, Variable> VariableDic { get; set; } = new Dictionary<int, Variable>();
|
||
public ObservableCollection<Variable> VariableList { get; set; } = new ObservableCollection<Variable>(); //数组遍历器
|
||
public List<TagEntity> TagList { get; set; } = new List<TagEntity>();
|
||
public List<StorageArea> Storages { get; set; } = new List<StorageArea>(); //1个PLC一个，首地址及所对应的标签信息
|
||
|
||
public abstract void Close();
|
||
public abstract void Connect();
|
||
public abstract void GetJsonParam(string param);
|
||
|
||
bool? lastConnect = null;
|
||
public virtual void StartRead()
|
||
{
|
||
Task.Run(async () =>
|
||
{
|
||
await Task.Delay(2000); //等待OPC初始化完成
|
||
Stopwatch sw = new Stopwatch();
|
||
while (true)
|
||
{
|
||
if (Global.AppExit)
|
||
{
|
||
return;
|
||
}
|
||
|
||
try
|
||
{
|
||
if (!IsConnect)
|
||
{
|
||
if (VariableList != null && VariableList.Count > 0)
|
||
{
|
||
foreach (var tag in VariableList)
|
||
{
|
||
tag.Quality = false;
|
||
}
|
||
}
|
||
Connect();
|
||
}
|
||
else
|
||
{
|
||
if (IsConnect)
|
||
{
|
||
sw.Restart();
|
||
ReadStorageArea();
|
||
sw.Stop();
|
||
ReadUseTime = (int)sw.ElapsedMilliseconds;
|
||
sw.Reset();
|
||
if (ReadUseTime > 3000)
|
||
{
|
||
LogHelper.Instance.Warn($"{ConnectString}:刷新所有数据时间:" + ReadUseTime + "ms");
|
||
}
|
||
}
|
||
}
|
||
}
|
||
catch(Exception ex)
|
||
{
|
||
LogHelper.Instance.Error($"全局读取数据失败:{ex.Message}");
|
||
}
|
||
|
||
if (lastConnect != IsConnect)
|
||
{
|
||
lastConnect = IsConnect;
|
||
//_unityContainer.Resolve<BasicInfoViewModel>().PLCStatus = IsConnect;
|
||
//_unityContainer.Resolve<DeviceConfigService>().UpdateStatus(this.Name, IsConnect);
|
||
_unityContainer.Resolve<DeviceConfigService>().UpdateStatus(this.Id, IsConnect);
|
||
}
|
||
|
||
// 触发 GC
|
||
GC.Collect();
|
||
GC.WaitForPendingFinalizers();
|
||
await Task.Delay(1000);
|
||
}
|
||
});
|
||
}
|
||
|
||
public virtual void Heartbeat()
|
||
{
|
||
Task.Run(async () =>
|
||
{
|
||
while (!cts.Token.IsCancellationRequested)
|
||
{
|
||
if (Global.AppExit)
|
||
{
|
||
return;
|
||
}
|
||
|
||
await Task.Delay(Global.HEARTBEAT_INTERVAL_TIME);
|
||
|
||
if (null == PLC || !IsConnect)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
var node = (from secondaryList in Storages
|
||
from item in secondaryList.VariableList
|
||
where item.VarDesc == "心跳"
|
||
select item).FirstOrDefault();
|
||
if (null == node)
|
||
{
|
||
LogHelper.Instance.Warn("查询心跳节点失败");
|
||
continue;
|
||
}
|
||
|
||
OperateResult result = Write<Int16>(node.Address + node.VarName, 1); //只写一个心跳就行了
|
||
if (!result.IsSuccess)
|
||
{
|
||
//LogHelper.Instance.Warn($"DeviceId:{Storages[0].DeviceId}：写心跳节点失败");
|
||
}
|
||
}
|
||
}, cts.Token);
|
||
}
|
||
public virtual int GetReadMaxLength(Variable variable)
|
||
{
|
||
return 101;
|
||
}
|
||
public virtual void AddressSplit(TagEntity tag)
|
||
{
|
||
//按modbus tcp解析 格式:x=3;0
|
||
string[] ss = tag.Address.Split(';');
|
||
if (ss.Length == 2)
|
||
{
|
||
VariableDic[(int)tag.Id].AddressType = ss[0];
|
||
VariableDic[(int)tag.Id].Address = ss[1];
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 赋值类型长度
|
||
/// </summary>
|
||
/// <param name="tag"></param>
|
||
public virtual void SetReadLength(TagEntity tag)
|
||
{
|
||
string varType = tag.VarType;
|
||
Match m = Regex.Match(tag.VarType, @"(?<=\[)([0-9]+)(?=\])", RegexOptions.Singleline);
|
||
if (m.Success)
|
||
{
|
||
//说明是数组[]
|
||
//VariableDic[tag.VarName].ReadLength = Convert.ToInt32(m.Value); 这是个BUG
|
||
VariableDic[(int)tag.Id].ArrayLength = Convert.ToInt32(m.Value);
|
||
Match mType = Regex.Match(tag.VarType, @"(.*)(?=\[)", RegexOptions.Singleline);
|
||
varType = mType.Value;
|
||
}
|
||
|
||
switch (varType)
|
||
{
|
||
case "BOOL":
|
||
case "BYTE":
|
||
case "INT16":
|
||
case "UINT16":
|
||
VariableDic[(int)tag.Id].ReadLength = 1;
|
||
break;
|
||
case "INT32":
|
||
case "UINT32":
|
||
case "FLOAT":
|
||
VariableDic[(int)tag.Id].ReadLength = 2;
|
||
break;
|
||
default:
|
||
LogHelper.Instance.Error("不支持的数据类型:" + tag.VarType);
|
||
break;
|
||
}
|
||
}
|
||
|
||
public virtual void AnalysisAddress()
|
||
{
|
||
foreach (var tag in TagList)
|
||
{
|
||
AddressSplit(tag);
|
||
SetReadLength(tag);
|
||
}
|
||
}
|
||
|
||
public virtual void GetStorageArea()
|
||
{
|
||
Storages.Clear();
|
||
var query = (from v in VariableList //query = List<IGrouping<string, Variable>> //按地址类型分组：如x=3一组
|
||
orderby Convert.ToInt16(v.Address), v.ReadLength
|
||
group v by v.AddressType into a
|
||
where a.Count() > 0
|
||
orderby a.Key
|
||
select a).ToList(); //modbus地址类型分组
|
||
/* modbus地址分类
|
||
0x01 读取线圈的操作，
|
||
0x02 读取离散的操作，
|
||
0x03 读取寄存器的值，
|
||
0x04 读取输入寄存器的值
|
||
0x05 写一个线圈操作，
|
||
0x06 写一个寄存器值，
|
||
0x0F 批量写线圈操作，
|
||
0x10 批量写寄存器值，
|
||
0x16 掩码写入的寄存器（大部分的modbus设备不支持）
|
||
*/
|
||
int k = query.Count;
|
||
foreach (var g in query)
|
||
{
|
||
int k1 = g.Count();
|
||
var first = g.First();//first:Variable,g:Dictionary<string,List<Variable>>
|
||
var totalLengthQuery1 = (from a in g //分块读数据
|
||
group a by (Convert.ToInt16(a.Address) - Convert.ToInt16(first.Address) + a.ReadLength) / GetReadMaxLength(a)).ToList();
|
||
|
||
var totalLengthQuery = (from a in g //分块读数据,100个数据分一组，在地址类型上，再按100为一组，分第二次组
|
||
group a by (Convert.ToInt16(a.Address) - Convert.ToInt16(first.Address) + a.ReadLength) / GetReadMaxLength(a) into b
|
||
select new
|
||
{
|
||
VarList = b, //Regex.Replace(a.VarType, @"\[.*\]", string.Empty)
|
||
Id = b.Key, //(Convert.ToInt16(a.Address) - Convert.ToInt16(first.Address) + a.ReadLength) / GetReadMaxLength(a)
|
||
AddressType = b.First().AddressType, //AddressType类型是Variable
|
||
StartAddress = b.First().Address,
|
||
GroupReadLength = (Convert.ToInt16(b.Last().Address) - Convert.ToInt16(b.First().Address) + b.Last().ReadLength)
|
||
}).ToList();
|
||
|
||
totalLengthQuery.ForEach(x =>
|
||
{
|
||
List<Variable> variables = x.VarList.ToList();
|
||
foreach (var variable in variables)
|
||
{
|
||
//计算offset,字节偏移
|
||
variable.Offset = (Convert.ToInt16(variable.Address) - Convert.ToInt16(x.StartAddress)) * 2;
|
||
}
|
||
Storages.Add(new StorageArea()
|
||
{
|
||
//Id = x.Id,
|
||
AddressType = x.AddressType,
|
||
StartAddress = x.StartAddress,
|
||
Len = x.GroupReadLength,
|
||
VariableList = variables
|
||
});
|
||
});
|
||
}
|
||
GetReadAddress();
|
||
}
|
||
|
||
public virtual void GetReadAddress()
|
||
{
|
||
foreach (var storage in Storages)
|
||
{
|
||
storage.ReadAddress = storage.AddressType + storage.StartAddress;
|
||
}
|
||
}
|
||
|
||
public virtual OperateResult<T> Read<T>(string tag)
|
||
{
|
||
return null;
|
||
}
|
||
|
||
public virtual OperateResult<T> GetValue<T>(string paramName)
|
||
{
|
||
return null;
|
||
}
|
||
|
||
public virtual OperateResult<T> GetValue<T>(string paramName, int machineId, int number = 0)
|
||
{
|
||
return null;
|
||
}
|
||
|
||
public virtual Variable GetVariable(string paramName, int machineId, int number = 0)
|
||
{
|
||
return null;
|
||
}
|
||
|
||
|
||
|
||
public virtual OperateResult Write<T>(string paramName, int machineId, int number, T data)
|
||
{
|
||
return null;
|
||
}
|
||
public virtual void ReadStorageArea()
|
||
{
|
||
try
|
||
{
|
||
foreach (var item in Storages)
|
||
{
|
||
bool readError = false;
|
||
for (int i = 0; i < Global.MAX_READS; i++)
|
||
{
|
||
var read = PLC.Read(item.ReadAddress, (ushort)item.Len);
|
||
if (read.IsSuccess)
|
||
{
|
||
IsConnect = true;
|
||
readError = false;
|
||
//读成功
|
||
if (item.VariableList != null)
|
||
{
|
||
foreach (var variable in item.VariableList)
|
||
{
|
||
AnalyseData(read.Content, variable);
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
else
|
||
{
|
||
foreach (var val in item.VariableList)
|
||
{
|
||
val.Quality = false;
|
||
}
|
||
LogHelper.Instance.Error($"读错误,,ErrorCode:{read.ErrorCode},失败:" + read.Message);
|
||
}
|
||
readError = true;
|
||
Thread.Sleep(30);
|
||
}
|
||
Thread.Sleep(30);
|
||
if (readError)
|
||
{
|
||
IsConnect = false;
|
||
}
|
||
}
|
||
}
|
||
catch(Exception ex)
|
||
{
|
||
IsConnect = false;
|
||
LogHelper.Instance.Error(ex.Message);
|
||
}
|
||
|
||
}
|
||
|
||
public virtual void AnalyseData(byte[] data, Variable variable)
|
||
{
|
||
if (data != null && data.Length > 0)
|
||
{
|
||
if (variable.ArrayLength > 1)
|
||
{
|
||
//说明是数组[]
|
||
//variable.ArrayLength = Convert.ToInt32(m.Value);
|
||
|
||
switch (variable.VarType)
|
||
{
|
||
case "BOOL":
|
||
variable.CurValue = ByteTransform.TransBool(data, variable.Offset);
|
||
variable.Quality = true;
|
||
break;
|
||
case "BYTE":
|
||
variable.CurValue = ByteTransform.TransByte(data, variable.Offset, variable.ArrayLength);
|
||
variable.Quality = true;
|
||
break;
|
||
case "INT16":
|
||
variable.CurValue = Array.ConvertAll(ByteTransform.TransInt16(data, variable.Offset, variable.ArrayLength), ele => ele.ToString());
|
||
variable.Quality = true;
|
||
break;
|
||
case "UINT16":
|
||
variable.CurValue = Array.ConvertAll(ByteTransform.TransUInt16(data, variable.Offset, variable.ArrayLength), ele => ele.ToString());
|
||
variable.Quality = true;
|
||
break;
|
||
case "INT32":
|
||
variable.CurValue = Array.ConvertAll(ByteTransform.TransInt32(data, variable.Offset, variable.ArrayLength), ele => ele.ToString());
|
||
variable.Quality = true;
|
||
break;
|
||
case "UINT32":
|
||
variable.Value = Array.ConvertAll(ByteTransform.TransUInt32(data, variable.Offset, variable.ArrayLength), ele => ele.ToString());
|
||
variable.Quality = true;
|
||
break;
|
||
case "FLOAT":
|
||
variable.Value = Array.ConvertAll(ByteTransform.TransSingle(data, variable.Offset, variable.ArrayLength), ele => ele.ToString());
|
||
variable.Quality = true;
|
||
break;
|
||
//case "STR":
|
||
// variable.CurValue = ByteTransform.TransString(data, variable.Offset, variable.ArrayLength, Encoding.Default);
|
||
// variable.Quality = true;
|
||
// break;
|
||
default:
|
||
LogHelper.Instance.Error("不支持的数据类型:" + variable.VarType);
|
||
break;
|
||
}
|
||
|
||
}
|
||
else
|
||
{
|
||
//值类型tostring不会装箱
|
||
switch (variable.VarType)
|
||
{
|
||
case "BOOL":
|
||
variable.CurValue = ByteTransform.TransBool(data, 1).ToString();
|
||
variable.Quality = true;
|
||
break;
|
||
case "BYTE":
|
||
variable.CurValue = ByteTransform.TransByte(data, variable.Offset).ToString();
|
||
variable.Quality = true;
|
||
break;
|
||
case "INT16":
|
||
variable.CurValue = ByteTransform.TransInt16(data, variable.Offset).ToString();
|
||
variable.Quality = true;
|
||
break;
|
||
case "UINT16":
|
||
data[0] = 33;
|
||
data[1] = 251;
|
||
variable.CurValue = ByteTransform.TransUInt16(data, variable.Offset).ToString();
|
||
variable.Quality = true;
|
||
break;
|
||
case "INT32":
|
||
variable.CurValue = ByteTransform.TransInt32(data, variable.Offset).ToString();
|
||
variable.Quality = true;
|
||
break;
|
||
case "UINT32":
|
||
variable.CurValue = ByteTransform.TransUInt32(data, variable.Offset).ToString();
|
||
variable.Quality = true;
|
||
break;
|
||
case "FLOAT":
|
||
float f = ByteTransform.TransSingle(data, variable.Offset);
|
||
variable.CurValue = ByteTransform.TransSingle(data, variable.Offset).ToString();
|
||
variable.Quality = true;
|
||
break;
|
||
default:
|
||
LogHelper.Instance.Error("不支持的数据类型:" + variable.VarType);
|
||
break;
|
||
}
|
||
//variable.Value = new string[] { variable.CurValue };
|
||
}
|
||
|
||
|
||
if (variable.TrigEnable)
|
||
{
|
||
dynamic d = JsonConvert.DeserializeObject<dynamic>(variable.TrigJson);
|
||
string fName = d.Func;
|
||
string vals = d.Value;
|
||
string key = d.Key;
|
||
string desc = d.Desc;
|
||
string serviceName = d.Service;
|
||
if (string.IsNullOrEmpty(serviceName))
|
||
{
|
||
serviceName = "TrigerService";
|
||
}
|
||
if (!string.IsNullOrEmpty(variable.OldValue.ToString()))
|
||
{
|
||
|
||
if (string.Equals(variable.OldValue, variable.CurValue))
|
||
{
|
||
|
||
if (vals == variable.CurValue.ToString())
|
||
{
|
||
//异步执行
|
||
//this.TrigServiceAsync(serviceName, fName, VariableDic[tag.VarName].FuncJson);
|
||
//int scriptId = variable.ScriptId;
|
||
//if (scriptId > 0)
|
||
//{
|
||
// var sm = _unityContainer.Resolve<IScriptManage>();
|
||
// var script = sm.ScriptList.Where(x => x.Id == scriptId).FirstOrDefault();
|
||
// if (script != null)
|
||
// {
|
||
// string funcJson = variable.Json;
|
||
// if (!string.IsNullOrEmpty(funcJson))
|
||
// {
|
||
// TrigScriptAsync(script, variable.Json);
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// LogHelper.Instance.Error($"脚本执行异常:没找到脚本-{scriptId}");
|
||
// }
|
||
//}
|
||
}
|
||
|
||
}
|
||
|
||
}
|
||
}
|
||
variable.OldValue = variable.CurValue;
|
||
}
|
||
}
|
||
|
||
//private void CopyBytes(byte[] data, Variable variable, int len)
|
||
//{
|
||
// variable.CurValue = new byte[len];
|
||
// Buffer.BlockCopy(data, variable.Offset, variable.CurValue, 0, len);
|
||
//}
|
||
public virtual OperateResult Writes(string[] tags, object[] values, int maxCount = Global.MAX_READS)
|
||
{
|
||
return null;
|
||
}
|
||
|
||
public virtual List<DataValue> Reads(NodeId[] nodeIds)
|
||
{
|
||
return null;
|
||
}
|
||
|
||
public abstract OperateResult Write<T>(string address, T data, int maxCount = 5);
|
||
public virtual OperateResult Write<T>(dynamic plc, string address, T data, int maxCount = 5)
|
||
{
|
||
var res = Write<T>(plc, address, data);
|
||
for (int i = 0; i < maxCount; i++)
|
||
{
|
||
if (res.IsSuccess)
|
||
{
|
||
break;
|
||
}
|
||
Thread.Sleep(15);
|
||
res = Write<T>(plc, address, data);
|
||
}
|
||
return res;
|
||
}
|
||
|
||
public virtual OperateResult Write<T>(dynamic plc, string address, T data)
|
||
{
|
||
if (!IsConnect)
|
||
{
|
||
return new OperateResult("未连接PLC");
|
||
}
|
||
|
||
Type type = typeof(T);
|
||
OperateResult resultdata = null;
|
||
try
|
||
{
|
||
if (type == typeof(short))
|
||
{
|
||
if (data is short one)
|
||
{
|
||
resultdata = plc.Write(address, one);
|
||
}
|
||
}
|
||
else if (type == typeof(ushort))
|
||
{
|
||
if (data is ushort one)
|
||
{
|
||
resultdata = plc.Write(address, one);
|
||
}
|
||
}
|
||
else if (type == typeof(int))
|
||
{
|
||
if (data is int one)
|
||
{
|
||
resultdata = plc.Write(address, one);
|
||
}
|
||
}
|
||
else if (type == typeof(uint))
|
||
{
|
||
if (data is uint one)
|
||
{
|
||
resultdata = plc.Write(address, one);
|
||
}
|
||
}
|
||
else if (type == typeof(long))
|
||
{
|
||
if (data is long one)
|
||
{
|
||
resultdata = plc.Write(address, one);
|
||
}
|
||
}
|
||
else if (type == typeof(ulong))
|
||
{
|
||
if (data is ulong one)
|
||
{
|
||
resultdata = plc.Write(address, one);
|
||
}
|
||
}
|
||
else if (type == typeof(float))
|
||
{
|
||
if (data is float one)
|
||
{
|
||
resultdata = plc.Write(address, one);
|
||
}
|
||
}
|
||
else if (type == typeof(double))
|
||
{
|
||
if (data is double one)
|
||
{
|
||
resultdata = plc.Write(address, one);
|
||
}
|
||
}
|
||
else if (type == typeof(bool))
|
||
{
|
||
if (data is bool state)
|
||
{
|
||
resultdata = plc.Write(address, state);
|
||
}
|
||
}
|
||
else if (type == typeof(short[]) || type == typeof(List<short>))
|
||
{
|
||
if (data is short[] arr)
|
||
{
|
||
resultdata = plc.Write(address, arr);
|
||
}
|
||
else if (data is List<short> list)
|
||
{
|
||
//list
|
||
resultdata = plc.Write(address, list.ToArray());
|
||
}
|
||
}
|
||
else if (type == typeof(ushort[]) || type == typeof(List<ushort>))
|
||
{
|
||
if (data is ushort[] arr)
|
||
{
|
||
resultdata = plc.Write(address, arr);
|
||
}
|
||
else if (data is List<ushort> list)
|
||
{
|
||
//list
|
||
resultdata = plc.Write(address, list.ToArray());
|
||
}
|
||
}
|
||
else if (type == typeof(int[]) || type == typeof(List<int>))
|
||
{
|
||
if (data is int[] arr)
|
||
{
|
||
resultdata = plc.Write(address, arr);
|
||
}
|
||
else if (data is List<int> list)
|
||
{
|
||
//list
|
||
resultdata = plc.Write(address, list.ToArray());
|
||
}
|
||
}
|
||
else if (type == typeof(uint[]) || type == typeof(List<uint>))
|
||
{
|
||
if (data is uint[] arr)
|
||
{
|
||
resultdata = plc.Write(address, arr);
|
||
}
|
||
else if (data is List<uint> list)
|
||
{
|
||
//list
|
||
resultdata = plc.Write(address, list.ToArray());
|
||
}
|
||
}
|
||
else if (type == typeof(long[]) || type == typeof(List<long>))
|
||
{
|
||
if (data is long[] arr)
|
||
{
|
||
resultdata = plc.Write(address, arr);
|
||
}
|
||
else if (data is List<long> list)
|
||
{
|
||
//list
|
||
resultdata = plc.Write(address, list.ToArray());
|
||
}
|
||
}
|
||
else if (type == typeof(ulong[]) || type == typeof(List<ulong>))
|
||
{
|
||
if (data is ulong[] arr)
|
||
{
|
||
resultdata = plc.Write(address, arr);
|
||
}
|
||
else if (data is List<ulong> list)
|
||
{
|
||
//list
|
||
resultdata = plc.Write(address, list.ToArray());
|
||
}
|
||
}
|
||
else if (type == typeof(float[]) || type == typeof(List<float>))
|
||
{
|
||
if (data is float[] arr)
|
||
{
|
||
resultdata = plc.Write(address, arr);
|
||
}
|
||
else if (data is List<float> list)
|
||
{
|
||
//list
|
||
resultdata = plc.Write(address, list.ToArray());
|
||
}
|
||
}
|
||
else if (type == typeof(double[]) || type == typeof(List<double>))
|
||
{
|
||
if (data is double[] arr)
|
||
{
|
||
resultdata = plc.Write(address, arr);
|
||
}
|
||
else if (data is List<double> list)
|
||
{
|
||
//list
|
||
resultdata = plc.Write(address, list.ToArray());
|
||
}
|
||
}
|
||
else if (type == typeof(bool[]) || type == typeof(List<bool>))
|
||
{
|
||
if (data is bool[] arrb)
|
||
{
|
||
resultdata = plc.Write(address, arrb);
|
||
}
|
||
else if (data is List<bool> listb)
|
||
{
|
||
resultdata = plc.Write(address, listb.ToArray());
|
||
}
|
||
}
|
||
else if (type == typeof(byte[]) || type == typeof(List<byte>))
|
||
{
|
||
if (data is byte[] arrby)
|
||
{
|
||
resultdata = plc.Write(address, arrby);
|
||
}
|
||
else if (data is List<byte> listb)
|
||
{
|
||
resultdata = plc.Write(address, listb.ToArray());
|
||
}
|
||
}
|
||
else if (type == typeof(string))
|
||
{
|
||
if (data is string str)
|
||
{
|
||
resultdata = plc.Write(address, str, Encoding.ASCII);
|
||
}
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
IsConnect = false;
|
||
LogHelper.Instance.Error($"写PLC数据失败:{address},{ex}");
|
||
}
|
||
if (!resultdata.IsSuccess)
|
||
{
|
||
LogHelper.Instance.Error("写PLC数据失败:" + address);
|
||
}
|
||
return resultdata;
|
||
}
|
||
|
||
|
||
public bool CheckBytesEquals(byte[] a, byte[] b)
|
||
{
|
||
if (a == null || b == null) return false;
|
||
if (a.Length != b.Length) return false;
|
||
for (int i = 0; i < a.Length; i++)
|
||
{
|
||
if (a[i] != b[i])
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
//public Task TrigScriptAsync(ScriptEntity script, string funcJson)
|
||
//{
|
||
// //return Task.Run(() =>
|
||
// //{
|
||
// // return RunSrcipt(script, funcJson);
|
||
// //});
|
||
//}
|
||
|
||
//private OperateResult RunSrcipt(ScriptEntity script, string funcJson)
|
||
//{
|
||
// Stopwatch watch = new Stopwatch();
|
||
// watch.Start();
|
||
// try
|
||
// {
|
||
// //OperateResult result = ScriptEngine.RunScript(_unityContainer, funcJson, script);
|
||
// //LogHelper.Instance.Info($"脚本【{script.Name}】执行用时：" + watch.ElapsedMilliseconds + "ms");
|
||
// return null;
|
||
// }
|
||
// catch (Exception ex)
|
||
// {
|
||
// LogHelper.Instance.Error("脚本执行异常", ex);
|
||
// return null;
|
||
// }
|
||
//}
|
||
|
||
//public Task TrigServiceAsync(string serviceName, string fName, string funcJson)
|
||
//{
|
||
// return Task.Run(() =>
|
||
// {
|
||
// TrigService(serviceName, fName, funcJson);
|
||
// });
|
||
//}
|
||
|
||
public void TrigService(string serviceName, string fName, string funcJson)
|
||
{
|
||
Assembly asm = Assembly.GetExecutingAssembly();
|
||
Type type = asm.GetType($"Cowain.Bake.Communication.Service.{serviceName}");
|
||
var ts = _unityContainer.Resolve(type);
|
||
object[] parameters = new object[1];
|
||
parameters[0] = funcJson;
|
||
try
|
||
{
|
||
MethodInfo mt = ts.GetType().GetMethod(fName);
|
||
if (mt != null)
|
||
{
|
||
mt.Invoke(ts, parameters);
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
LogHelper.Instance.Error($"TrigService：{ex}");
|
||
}
|
||
}
|
||
|
||
}
|
||
}
|
