public MessageReceiverRegistration(DeviceAddress source, DeviceAddress destination, MessageReceiver callback, MatchType match)
{
Source = source;
Destination = destination;
Callback = callback;
Match = match;
}
public InternalMessage(DeviceAddress device, string description, params byte[] data)
: base((byte)device, (byte)((data.Length + 2) >> 8), data)
{
if (!device.IsInternal())
{
throw new Exception("Internal messages are for internal devices only.");
}
if (PacketLength > 1024) // TODO try up to 0xFFFF length
{
throw new Exception("Message packet length exceeds 1024 bytes.");
}
}
public Message(DeviceAddress source, DeviceAddress destination, string description, params byte[] data)
{
if (source == DeviceAddress.Unset || source == DeviceAddress.Unknown)
{
throw new ArgumentException("Wrong source device");
}
if (destination == DeviceAddress.Unset || destination == DeviceAddress.Unknown)
{
throw new ArgumentException("Wrong destination device");
}
init((byte)source, (byte)destination, data, description);
sourceDevice = source;
destinationDevice = destination;
}
public DBusMessage(DeviceAddress device, string description, params byte[] data)
: base(device, DeviceAddress.Diagnostic, description, data)
{
// packet = device + length + data + chksum
// | ===== length ===== |
var packetLength = data.Length + 3;
byte check = 0x00;
check ^= (byte)device;
check ^= (byte)packetLength;
foreach (byte b in data)
{
check ^= b;
}
init((byte)device, (byte)DeviceAddress.Diagnostic, data, packetLength, check, description);
}
public static void AddMessageReceiverForSourceDevice(DeviceAddress source, MessageReceiver callback)
{
MessageReceiverList.Add(new MessageReceiverRegistration(source, DeviceAddress.Unset, callback, MessageReceiverRegistration.MatchType.Source));
}
public static bool FindDevice(DeviceAddress device, int timeout)
{
if (foundDevices.Contains(device))
{
return true;
}
lock (foundDevices)
{
findDevice = device;
findDeviceSync.Reset();
AfterMessageReceived += SaveFoundDevice;
EnqueueMessage(new Message(DeviceAddress.Diagnostic, device, MessageRegistry.DataPollRequest));
findDeviceSync.WaitOne(timeout, true);
AfterMessageReceived -= SaveFoundDevice;
return foundDevices.Contains(device);
}
}
public InternalMessage(DeviceAddress device, string data)
: this(device, data, data)
{
}
public InternalMessage(DeviceAddress device, params byte[] data)
: this(device, null, data)
{
}
public Item <TResult>[] ReadDatas <TResult>(DeviceAddress deviceAddress, ushort length)
{
throw new NotImplementedException();
}
public int WriteString(DeviceAddress address, string value)
{
return(_plcReader.Poke(_mapping[(short)address.Start], value));
}
/// <summary>
/// B[1]~B[2]: 03 00 固定报文头
/// B[3] ~B[4]: 整个读取回复报文长度：25+读取长度;
/// B[5] ~B[11]: 02 F0 80 32 03 00 00 固定6个字节,和读取请求相同的位置几乎一样，就 B[9] = 0x03; A[9]=0x01;
/// B[12] ~B[13]: 两个字节，标识序列号，回复报文相同位置和这个完全一样；范围是0 ~65535；
/// B[14] ~B[15]: 两个字节，固定为00 02；对应读取位置是 00 0E；正好 02+0E=10 ;有点补码的感觉，其实不需要关注规律，反正是固定的；
/// B[16] ~B[17]:两个字节，=请求读取的字节数+4；
/// B[18] ~B[23]:6个字节，固定为:00 00 04 01 FF 04 ;
/// B[24] ~B[25]:两个字节, 请求访问的byte个数*8 ；其实就是以二进制为单位的个数；由此可以看出，一口气最多访问的地址个数是8192；
/// B[26] ~最后一个 ：以offset作为首地址，所对应的各个byte的值；
/// 程序设计的时候，其实只要关注两个信息：
/// 1.校验B[3] ~B[4]:校验长度正确；
/// 2.B[26] ~最后一个 :获取对应的值；
/// 到这里读的处理就算结束了；
/// 几个小注意点:
/// 1.对于不同信号的PLC,除了初始化的CPUSolt不同；正常读/写指令是一样的；
/// 2.读的时候，都是以byte为单位的，如果程序只需要bit，那么还是以Byte为单位去读，将读出的部分按bit再去分解；
/// 3.flag类型到底是什么，不是很清楚，有点类似三菱里的M点；这个也不需要去深究，一般项目里主要就是用DB块；
/// 4.读取的长度如果是N(以byte为单位)，那么返回的长度就是N*8(以bit为单位）；怎么判断长度是否要*8；主要看后面是不是紧挨着数据，如果是数据，就需要*8；offset都是以bit为单位的；
/// 5.正常读的操作都是DB块，所以在A[26] ~A[27]这个字节写入DB块的编号，但是对于input,output,flags这三个类型，是不需要数据块编号的不过我们可以随便写一个DB编号；
/// </summary>
/// <param name="address"></param>
/// <param name="length"></param>
/// <returns></returns>
private byte[] readyBytes(DeviceAddress address, int length)
{
try
{
if (IsConnect)
{
if (address.FuctionCode == 0x81 || address.FuctionCode == 0x82 || address.FuctionCode == 0x83 || address.FuctionCode == 0x84)
{
lock (_async)
{
_handler++;
if (_handler > 65535)
{
_handler = 0;
}
byte[] sendBytes = createReadHeader(address, _handler, length);
byte[] receiveBytes = new byte[25 + length];
byte[] dataBytes = new byte[length];
_log.ByteSteamLog(ActionType.SEND, sendBytes);
_socket.Send(sendBytes, sendBytes.Length, SocketFlags.None);
//Thread.Sleep(10);
int readNumber = 0;
_socket.Receive(receiveBytes, 4, SocketFlags.None);
_socket.Receive(receiveBytes, 4, receiveBytes[3] - 4, SocketFlags.None);
readNumber = receiveBytes[3];
//报文数据记录
var logBytes = new byte[readNumber];
Array.Copy(receiveBytes, 0, logBytes, 0, readNumber);
_log.ByteSteamLog(ActionType.RECEIVE, logBytes);
if (readNumber == receiveBytes.Length)
{
Array.Copy(receiveBytes, 25, dataBytes, 0, length);
return(dataBytes);
}
else
{
_log.ErrorLog("S7Comm read data error:" + Convert.ToString(receiveBytes));
return(null);
}
}
}
else
{
_log.ErrorLog("S7Comm read function error:" + address.FuctionCode);
return(null);
}
}
else
{
_log.ErrorLog("S7Comm read data error:" + "No connect");
return(null);
}
}
catch (Exception ex)
{
DisConnect();
Log.ErrorLog(string.Format("S7Comm {0} ", ex.Message));
return(null);
}
}
int WriteMultipleInternal(DeviceAddress[] addrArr, object[] buffer)
{
lock (_async)
{
if (dc == null)
{
return(-1);
}
int len = addrArr.Length;
libnodave.PDU p2 = dc.prepareWriteRequest();
for (int i = 0; i < len; i++)
{
try
{
DeviceAddress addr = addrArr[i];
byte[] b;
switch (addr.VarType)
{
case DataType.BOOL:
bool bl = Convert.ToBoolean(buffer[i]);
b = new byte[] { (byte)(bl ? 1 : 0) };
p2.addBitVarToWriteRequest(addr.Area, addr.DBNumber, addr.Start * 8 + addr.Bit, 1, b);
break;
case DataType.BYTE:
b = BitConverter.GetBytes(Convert.ToByte(buffer[i]));
p2.addVarToWriteRequest(addr.Area, addr.DBNumber, addr.Start, 1, b);
break;
case DataType.WORD:
b = BitConverter.GetBytes(Convert.ToUInt16(buffer[i])); Array.Reverse(b);
p2.addVarToWriteRequest(addr.Area, addr.DBNumber, addr.Start, 2, b);
break;
case DataType.SHORT:
b = BitConverter.GetBytes(Convert.ToInt16(buffer[i])); Array.Reverse(b);
p2.addVarToWriteRequest(addr.Area, addr.DBNumber, addr.Start, 2, b);
break;
case DataType.DWORD:
b = BitConverter.GetBytes(Convert.ToUInt32(buffer[i])); Array.Reverse(b);
p2.addVarToWriteRequest(addr.Area, addr.DBNumber, addr.Start, 4, b);
break;
case DataType.INT:
b = BitConverter.GetBytes(Convert.ToInt32(buffer[i])); Array.Reverse(b);
p2.addVarToWriteRequest(addr.Area, addr.DBNumber, addr.Start, 4, b);
break;
case DataType.FLOAT:
b = BitConverter.GetBytes(Convert.ToSingle(buffer[i])); Array.Reverse(b);
p2.addVarToWriteRequest(addr.Area, addr.DBNumber, addr.Start, 4, b);
break;
case DataType.STR:
{
b = Encoding.ASCII.GetBytes(buffer[i].ToString());
var b1 = new byte[2 + b.Length];
b1[0] = (byte)addrArr[i].DataSize;
b1[1] = (byte)b.Length;
b.CopyTo(b1, 2);
p2.addVarToWriteRequest(addr.Area, addr.DBNumber, addr.Start, addr.DataSize, b1);
}
break;
}
}
catch (Exception err)
{
if (OnClose != null)
{
OnClose(this, new ShutdownRequestEventArgs(err.Message)); //可考虑把相应地址和数值加入
}
}
}
libnodave.resultSet rs = new libnodave.resultSet();
return(dc.execWriteRequest(p2, rs));
}
}
public int WriteBools(DeviceAddress deviceAddress, bool[] datas)
{
throw new NotImplementedException();
}
public int WriteDatas <T>(DeviceAddress deviceAddress, T[] datas)
{
throw new NotImplementedException();
}
/// B[1] ~B[2]: 03 00 固定报文头；
/// B[22]: FF 标识写入正常；
private int writedata(DeviceAddress deviceAddress, byte[] source)
{
try
{
if (IsConnect)
{
if (deviceAddress.FuctionCode == 0x81 || deviceAddress.FuctionCode == 0x82 || deviceAddress.FuctionCode == 0x83 || deviceAddress.FuctionCode == 0x84)
{
//_handler++;
//if (_handler > 65535)
// _handler = 0;
//byte[] sendBytes = createWriteHeader(deviceAddress, _handler, datas);
byte[] receiveBytes = new byte[22];
_log.ByteSteamLog(ActionType.SEND, source);
_socket.Send(source, source.Length, SocketFlags.None);
//Thread.Sleep(10);
int readNumber = 0;
_socket.Receive(receiveBytes, 4, SocketFlags.None);
_socket.Receive(receiveBytes, 4, receiveBytes[3] - 4, SocketFlags.None);
readNumber = receiveBytes[3];
//报文数据记录
var logBytes = new byte[readNumber];
Array.Copy(receiveBytes, 0, logBytes, 0, readNumber);
_log.ByteSteamLog(ActionType.RECEIVE, logBytes);
if (readNumber == receiveBytes.Length)
{
if (receiveBytes[21] == 0xFF)
{
return(1);
}
else
{
return(-1);
}
}
else
{
string byteSteamString = "";
foreach (byte bt in receiveBytes)
{
byteSteamString += string.Format("{0:x2}", bt) + " ";
}
_log.ErrorLog("S7Comm write data error: receive byte " + byteSteamString);
return(-1);
}
}
else
{
_log.ErrorLog("S7Comm write function error:" + deviceAddress.FuctionCode);
return(-1);
}
}
else
{
_log.ErrorLog("S7Comm write data error:" + "No connect");
return(-1);
}
}
catch (Exception ex)
{
DisConnect();
Log.ErrorLog(string.Format("S7Comm {0} ", ex.Message));
return(-1);
}
}
public Item <string>[] ReadStrings(DeviceAddress deviceAddress, ushort length)
{
throw new NotImplementedException();
}
public Item <string> ReadString(DeviceAddress deviceAddress)
{
throw new NotImplementedException();
}
public Item <byte>[] ReadBytes(DeviceAddress deviceAddress, ushort length)
{
var datas = readyBytes(deviceAddress, length);
return(NetConvert.ToItems(datas, 0, length));
}
public ITag FindItemByAddress(DeviceAddress addr)
{
return(null);
}
public int WriteStrings(DeviceAddress deviceAddress, string[] datas)
{
throw new NotImplementedException();
}
public Item <TResult> ReadData <TResult>(DeviceAddress deviceAddress)
{
throw new NotImplementedException();
}
ItemData <Storage>[] ReadMultipleInternal(DeviceAddress[] addrsArr)
{
int len = addrsArr.Length;
if (len <= Limit)
{
lock (_async)
{
if (dc == null)
{
return(null);
}
libnodave.PDU p = dc.prepareReadRequest();
for (int i = 0; i < len; i++)
{
DeviceAddress addr = addrsArr[i];
if (addr.VarType == DataType.BOOL)
{
p.addBitVarToReadRequest(addr.Area, addr.DBNumber, addr.Start, addr.DataSize);
}
else
{
p.addVarToReadRequest(addr.Area, addr.DBNumber, addr.Start, addr.DataSize);
}
}
libnodave.resultSet rs = new libnodave.resultSet();
int res = dc.execReadRequest(p, rs);
ItemData <Storage>[] itemArr = new ItemData <Storage> [len];
for (int i = 0; i < len; i++)
{
res = dc.useResult(rs, i);
if (res > 0)
{
itemArr[i].Quality = QUALITIES.QUALITY_GOOD;
switch (addrsArr[i].VarType)
{
case DataType.BOOL:
itemArr[i].Value.Boolean = dc.getU8() > 0; //需测试
break;
case DataType.BYTE:
itemArr[i].Value.Byte = (byte)dc.getU8();
break;
case DataType.WORD:
itemArr[i].Value.Word = (ushort)dc.getS16();
break;
case DataType.SHORT:
itemArr[i].Value.Int16 = (short)dc.getS16();
break;
case DataType.DWORD:
itemArr[i].Value.DWord = (uint)dc.getS32();
break;
case DataType.INT:
itemArr[i].Value.Int32 = dc.getS32();
break;
case DataType.FLOAT:
itemArr[i].Value.Single = dc.getFloat();
break;
}
}
}
return(itemArr);
}
}
else
{
return(this.PLCReadMultiple(new NetByteCacheReader(), addrsArr));
}
}
public DeviceAddress GetDeviceAddress(string address)
{
DeviceAddress dv = DeviceAddress.Empty;
if (string.IsNullOrEmpty(address))
{
return(dv);
}
switch (address[0])
{
case '0':
{
dv.Area = Modbus.fctReadCoil;
int st;
int.TryParse(address, out st);
dv.Bit = (byte)(st % 16);
st /= 16;
dv.Start = st;
}
break;
case '1':
{
dv.Area = Modbus.fctReadDiscreteInputs;
int st;
int.TryParse(address.Substring(1), out st);
dv.Bit = (byte)(st % 16);
st /= 16;
dv.Start = st;
}
break;
case '4':
{
int index = address.IndexOf('.');
dv.Area = Modbus.fctReadHoldingRegister;
if (index > 0)
{
dv.Start = int.Parse(address.Substring(1, index - 1));
dv.Bit = byte.Parse(address.Substring(index + 1));
}
else
{
dv.Start = int.Parse(address.Substring(1));
}
dv.Start--;
}
break;
case '3':
{
int index = address.IndexOf('.');
dv.Area = Modbus.fctReadInputRegister;
if (index > 0)
{
dv.Start = int.Parse(address.Substring(1, index - 1));
dv.Bit = byte.Parse(address.Substring(index + 1));
}
else
{
dv.Start = int.Parse(address.Substring(1));
}
dv.Start--;
}
break;
}
return(dv);
}
public bool AddItems(IList <TagMetaData> items)
{
int count = items.Count;
if (_items == null)
{
_items = new List <ITag>(count);
_mapping = new Dictionary <short, string>(count);
}
lock (_server.SyncRoot)
{
for (int i = 0; i < count; i++)
{
ITag dataItem = null;
TagMetaData meta = items[i];
if (meta.GroupID == this._id)
{
DeviceAddress addr = new DeviceAddress {
Start = meta.ID, DataSize = meta.Size, VarType = meta.DataType
};
switch (meta.DataType)
{
case DataType.BOOL:
dataItem = new BoolTag(meta.ID, addr, this);
break;
case DataType.BYTE:
dataItem = new ByteTag(meta.ID, addr, this);
break;
case DataType.WORD:
case DataType.SHORT:
dataItem = new ShortTag(meta.ID, addr, this);
break;
case DataType.DWORD:
case DataType.INT:
dataItem = new IntTag(meta.ID, addr, this);
break;
case DataType.FLOAT:
dataItem = new FloatTag(meta.ID, addr, this);
break;
case DataType.STR:
dataItem = new StringTag(meta.ID, addr, this);
break;
}
if (dataItem != null)
{
//dataItem.Active = meta.Active;
_items.Add(dataItem);
_plcReader.TransactItem(meta.Name);
_mapping.Add(meta.ID, meta.Address);
_server.AddItemIndex(meta.Name, dataItem);
}
}
}
return(true);
}
}
public ItemData <short> ReadInt16(DeviceAddress address)
{
byte[] bit = ReadBytes(address, 1);
return(bit == null ? new ItemData <short>(0, 0, QUALITIES.QUALITY_BAD) :
new ItemData <short>(BitConverter.ToInt16(bit, 0), 0, QUALITIES.QUALITY_GOOD));
}
public int WriteUInt16(DeviceAddress address, ushort value)
{
return(_plcReader.Poke(_mapping[(short)address.Start], value.ToString()));
}
public ItemData <byte> ReadByte(DeviceAddress address)
{
byte[] bit = ReadBytes(address, 1);
return(bit == null ? new ItemData <byte>(0, 0, QUALITIES.QUALITY_BAD) :
new ItemData <byte>(bit[0], 0, QUALITIES.QUALITY_GOOD));
}
public int WriteBits(DeviceAddress address, byte value)
{
return(_plcReader.Poke(_mapping[(short)address.Start], value.ToString()));
}
public ItemData <string> ReadString(DeviceAddress address, ushort size)
{
byte[] bit = ReadBytes(address, size);
return(bit == null ? new ItemData <string>(string.Empty, 0, QUALITIES.QUALITY_BAD) :
new ItemData <string>(Encoding.ASCII.GetString(bit), 0, QUALITIES.QUALITY_GOOD));
}
public InternalMessage(DeviceAddress device, string data, string description)
: this(device, description, Encoding.UTF8.GetBytes(data))
{
}
public ItemData <float> ReadFloat(DeviceAddress address)
{
byte[] bit = ReadBytes(address, 2);
return(bit == null ? new ItemData <float>(0f, 0, QUALITIES.QUALITY_BAD) :
new ItemData <float>(BitConverter.ToSingle(bit, 0), 0, QUALITIES.QUALITY_GOOD));
}
public ItemData <bool> ReadBit(DeviceAddress address)
{
byte[] bit = ReadBytes(address, 1);
return(bit == null ? new ItemData <bool>(false, 0, QUALITIES.QUALITY_BAD) :
new ItemData <bool>((bit[0] & (1 << (address.Bit))) > 0, 0, QUALITIES.QUALITY_GOOD));
}
protected override unsafe int Poll()
{
short[] cache = (short[])_cacheReader.Cache;
int k = 0;
foreach (PDUArea area in _rangeList)
{
byte[] rcvBytes = _plcReader.ReadBytes(area.Start, (ushort)area.Len);//从PLC读取数据
if (rcvBytes == null)
{
_plcReader.Connect();
return(-1);
}
else
{
int len = rcvBytes.Length / 2;
fixed(byte *p1 = rcvBytes)
{
short *prcv = (short *)p1;
int index = area.StartIndex;//index指向_items中的Tag元数据
int count = index + area.Count;
while (index < count)
{
DeviceAddress addr = _items[index].Address;
int iShort = addr.CacheIndex;
int iShort1 = iShort - k;
if (addr.VarType == DataType.BOOL)
{
int tmp = prcv[iShort1] ^ cache[iShort];
DeviceAddress next = addr;
if (tmp != 0)
{
while (addr.Start == next.Start)
{
if ((tmp & (1 << next.Bit)) > 0)
{
_changedList.Add(index);
}
if (++index < count)
{
next = _items[index].Address;
}
else
{
break;
}
}
}
else
{
while (addr.Start == next.Start && ++index < count)
{
next = _items[index].Address;
}
}
}
else
{
if (addr.DataSize <= 2)
{
if (prcv[iShort1] != cache[iShort])
{
_changedList.Add(index);
}
}
else
{
int size = addr.DataSize / 2;
for (int i = 0; i < size; i++)
{
if (prcv[iShort1 + i] != cache[iShort + i])
{
_changedList.Add(index);
break;
}
}
}
index++;
}
}
for (int j = 0; j < len; j++)
{
cache[j + k] = prcv[j];
}//将PLC读取的数据写入到CacheReader中
}
k += len;
}
}
return(1);
}
public static bool FindDevice(DeviceAddress device)
{
return FindDevice(device, findDeviceTimeout);
}
public string GetAddress(DeviceAddress address)
{
return(string.Empty);
}
public static void AddMessageReceiverForDestinationDevice(DeviceAddress destination, MessageReceiver callback)
{
MessageReceiverList.Add(new MessageReceiverRegistration(DeviceAddress.Unset, destination, callback, MessageReceiverRegistration.MatchType.Destination));
}
public DeviceAddress GetDeviceAddress(string address)
{
DeviceAddress plcAddr = new DeviceAddress();
if (string.IsNullOrEmpty(address) || address.Length < 2)
{
return(plcAddr);
}
if (address.Substring(0, 2) == "DB")
{
int index = 2;
for (int i = index; i < address.Length; i++)
{
if (!char.IsDigit(address[i]))
{
index = i; break;
}
}
plcAddr.Area = libnodave.daveDB;
plcAddr.DBNumber = ushort.Parse(address.Substring(2, index - 2));
string str = address.Substring(index + 1);
if (!char.IsDigit(str[0]))
{
for (int i = 1; i < str.Length; i++)
{
if (char.IsDigit(str[i]))
{
index = i; break;
}
}
if (str[2] == 'W')
{
int index1 = str.IndexOf('.');
if (index1 > 0)
{
int start = int.Parse(str.Substring(3, index1 - 3));
byte bit = byte.Parse(str.RightFrom(index1));
plcAddr.Start = bit > 8 ? start : start + 1;
plcAddr.Bit = (byte)(bit > 7 ? bit - 8 : bit);
return(plcAddr);
}
}
str = str.Substring(index);
}
index = str.IndexOf('.');
if (index < 0)
{
plcAddr.Start = int.Parse(str);
}
else
{
plcAddr.Start = int.Parse(str.Substring(0, index));
plcAddr.Bit = byte.Parse(str.RightFrom(index));
}
}
else
{
plcAddr.DBNumber = 0;
char chr = address[0];
if (dict.ContainsKey(chr))
{
plcAddr.Area = dict[chr];
int index = address.IndexOf('.');
if (address[1] == 'W')
{
if (index > 0)
{
int start = int.Parse(address.Substring(2, index - 2));
byte bit = byte.Parse(address.RightFrom(index));
plcAddr.Start = bit > 8 ? start : start + 1;
plcAddr.Bit = (byte)(bit > 7 ? bit - 8 : bit);
}
else
{
plcAddr.Start = int.Parse(address.Substring(2));
}
}
else
{
if (index > 0)
{
plcAddr.Start = int.Parse(address.Substring(1, index - 1));
plcAddr.Bit = byte.Parse(address.RightFrom(index));
}
else
{
plcAddr.Start = int.Parse(address.Substring(1));
}
}
}
}
return(plcAddr);
}
public static void AddMessageReceiverForSourceOrDestinationDevice(DeviceAddress source, DeviceAddress destination, MessageReceiver callback)
{
MessageReceiverList.Add(new MessageReceiverRegistration(source, destination, callback, MessageReceiverRegistration.MatchType.SourceOrDestination));
}
public ItemData <object> ReadValue(DeviceAddress address)
{
return(this.ReadValueEx(address));
}
public Message(DeviceAddress source, DeviceAddress destination, params byte[] data)
: this(source, destination, null, data)
{
}
public int WriteValue(DeviceAddress address, object value)
{
return(this.WriteValueEx(address, value));
}
public DBusMessage(DeviceAddress device, params byte[] data)
: this(device, null, data)
{
}
public string GetAddress(DeviceAddress deviceAddress)
{
throw new NotImplementedException();
}
