1392 lines
47 KiB
C#
1392 lines
47 KiB
C#
using System;
|
||
using System.Collections.Generic;
|
||
using System.IO;
|
||
using System.Linq;
|
||
using System.Net.Sockets;
|
||
using System.Text;
|
||
using System.Threading;
|
||
using System.Threading.Tasks;
|
||
using static EasyModbus.TCPHandler;
|
||
|
||
namespace McProtocol.Mitsubishi
|
||
{
|
||
public class McProtocolTcp
|
||
{
|
||
/// <summary>
|
||
/// 使用的指令框架
|
||
/// </summary>
|
||
public McFrame CommandFrame { get; set; }
|
||
private McCommand Command { get; set; }
|
||
/// <summary>
|
||
/// 主机名或者IP地址
|
||
/// </summary>
|
||
public string HostName { get; set; }
|
||
/// <summary>
|
||
/// 端口号
|
||
/// </summary>
|
||
public int PortNumber { get; set; }
|
||
public int Device { private set; get; }
|
||
|
||
private const int BlockSize = 0x0010;
|
||
private TcpClient Client { get; set; }
|
||
private NetworkStream Stream { get; set; }
|
||
|
||
// 是否连接
|
||
public bool Connected
|
||
{
|
||
get
|
||
{
|
||
return Client.Connected;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 构造函数
|
||
/// </summary>
|
||
public McProtocolTcp() : this("", 0, McFrame.MC3E)
|
||
{
|
||
|
||
}
|
||
|
||
/// <summary>
|
||
/// 构造函数
|
||
/// </summary>
|
||
/// <param name="iHostName"></param>
|
||
/// <param name="iPortNumber"></param>
|
||
/// <param name="frame"></param>
|
||
public McProtocolTcp(string iHostName, int iPortNumber, McFrame frame)
|
||
{
|
||
CommandFrame = frame;
|
||
Client = new TcpClient();
|
||
|
||
//C70 = MC3E
|
||
HostName = iHostName;
|
||
PortNumber = iPortNumber;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 后处理
|
||
/// </summary>
|
||
public void Dispose()
|
||
{
|
||
TcpClient c = Client;
|
||
if (c.Connected)
|
||
{
|
||
c.Close();
|
||
}
|
||
}
|
||
|
||
public void Open()
|
||
{
|
||
if (!Client.Connected)
|
||
{
|
||
// 实现Keep Alive功能
|
||
var ka = new List<byte>(sizeof(uint) * 3);
|
||
ka.AddRange(BitConverter.GetBytes(1u));
|
||
ka.AddRange(BitConverter.GetBytes(45000u));
|
||
ka.AddRange(BitConverter.GetBytes(5000u));
|
||
Client.Client.IOControl(IOControlCode.KeepAliveValues, ka.ToArray(), null);
|
||
|
||
IAsyncResult asyncResult = Client.BeginConnect(HostName, PortNumber, null, null);
|
||
if (!asyncResult.AsyncWaitHandle.WaitOne(1000))
|
||
{
|
||
throw new Exception("连接超时");
|
||
}
|
||
Client.EndConnect(asyncResult);
|
||
Stream = Client.GetStream();
|
||
}
|
||
Command = new McCommand(CommandFrame);
|
||
}
|
||
|
||
|
||
public int SetBitDevice(string iDeviceName, int iSize, int[] iData)
|
||
{
|
||
PlcDeviceType type;
|
||
int addr;
|
||
GetDeviceCode(iDeviceName, out type, out addr);
|
||
return SetBitDevice(type, addr, iSize, iData);
|
||
}
|
||
|
||
public int SetBitDevice(PlcDeviceType iType, int iAddress, int iSize, int[] iData)
|
||
{
|
||
var type = iType;
|
||
var addr = iAddress;
|
||
var data = new List<byte>(6) { (byte)addr, (byte)(addr >> 8), (byte)(addr >> 16), (byte)type, (byte)iSize, (byte)(iSize >> 8) };
|
||
var d = (byte)iData[0];
|
||
var i = 0;
|
||
while (i < iData.Length)
|
||
{
|
||
if (i % 2 == 0)
|
||
{
|
||
d = (byte)iData[i];
|
||
d <<= 4;
|
||
}
|
||
else
|
||
{
|
||
d |= (byte)(iData[i] & 0x01);
|
||
data.Add(d);
|
||
}
|
||
++i;
|
||
}
|
||
if (i % 2 != 0)
|
||
{
|
||
data.Add(d);
|
||
}
|
||
int length = (int)Command.FrameType;// == McFrame.MC3E) ? 11 : 15;
|
||
byte[] sdCommand = Command.SetCommandMC3E(0x1401, 0x0001, data.ToArray());
|
||
byte[] rtResponse = TryExecution(sdCommand, length);
|
||
int rtCode = Command.SetResponse(rtResponse);
|
||
return rtCode;
|
||
}
|
||
|
||
public int GetBitDevice(string iDeviceName, int iSize, int[] oData)
|
||
{
|
||
PlcDeviceType type;
|
||
int addr;
|
||
GetDeviceCode(iDeviceName, out type, out addr);
|
||
return GetBitDevice(type, addr, iSize, oData);
|
||
}
|
||
|
||
public int GetBitDevice(PlcDeviceType iType, int iAddress, int iSize, int[] oData)
|
||
{
|
||
|
||
PlcDeviceType type = iType;
|
||
int addr = iAddress;
|
||
var data = new List<byte>(6) { (byte)addr, (byte)(addr >> 8), (byte)(addr >> 16), (byte)type, (byte)iSize, (byte)(iSize >> 8) };
|
||
byte[] sdCommand = Command.SetCommandMC3E(0x0401, 0x0001, data.ToArray());
|
||
int length = (Command.FrameType == McFrame.MC3E) ? 11 : 15;
|
||
byte[] rtResponse = TryExecution(sdCommand, length);
|
||
int rtCode = Command.SetResponse(rtResponse);
|
||
byte[] rtData = Command.Response;
|
||
for (int i = 0; i < iSize; ++i)
|
||
{
|
||
if (i % 2 == 0)
|
||
{
|
||
oData[i] = (rtCode == 0) ? ((rtData[i / 2] >> 4) & 0x01) : 0;
|
||
}
|
||
else
|
||
{
|
||
oData[i] = (rtCode == 0) ? (rtData[i / 2] & 0x01) : 0;
|
||
}
|
||
}
|
||
return rtCode;
|
||
}
|
||
|
||
public int WriteDeviceBlock(string iDeviceName, int iSize, ushort[] iData)
|
||
{
|
||
PlcDeviceType type;
|
||
int addr;
|
||
GetDeviceCode(iDeviceName, out type, out addr);
|
||
return WriteDeviceBlock(type, addr, iSize, iData);
|
||
}
|
||
|
||
public int WriteDeviceBlock(PlcDeviceType iType, int iAddress, int iSize, ushort[] iData)
|
||
{
|
||
PlcDeviceType type = iType;
|
||
int addr = iAddress;
|
||
List<byte> data;
|
||
List<byte> DeviceData = new List<byte>();
|
||
foreach (ushort t in iData)
|
||
{
|
||
byte[] value = BitConverter.GetBytes(t);
|
||
if (BitConverter.IsLittleEndian)
|
||
{
|
||
Array.Reverse(value);
|
||
}
|
||
DeviceData.AddRange(value);
|
||
}
|
||
byte[] sdCommand;
|
||
int length;
|
||
switch (CommandFrame)
|
||
{
|
||
case McFrame.MC3E:
|
||
data = new List<byte>(6) { (byte)addr, (byte)(addr >> 8), (byte)(addr >> 16), (byte)type, (byte)iSize, (byte)(iSize >> 8) };
|
||
data.AddRange(DeviceData.ToArray());
|
||
sdCommand = Command.SetCommandMC3E(0x1401, 0x0000, data.ToArray());
|
||
length = 11;
|
||
break;
|
||
case McFrame.MC4E:
|
||
data = new List<byte>(6) { (byte)addr, (byte)(addr >> 8), (byte)(addr >> 16), (byte)type, (byte)iSize, (byte)(iSize >> 8) };
|
||
data.AddRange(DeviceData.ToArray());
|
||
sdCommand = Command.SetCommandMC4E(0x1401, 0x0000, data.ToArray());
|
||
length = 15;
|
||
break;
|
||
case McFrame.MC1E:
|
||
data = new List<byte>(6) { (byte)addr, (byte)(addr >> 8), (byte)(addr >> 16), (byte)(addr >> 24), 0x20, 0x44, (byte)iSize, 0x00 };
|
||
data.AddRange(DeviceData.ToArray());
|
||
//Add data
|
||
sdCommand = Command.SetCommandMC1E(0x03, data.ToArray());
|
||
length = 2;
|
||
break;
|
||
default:
|
||
throw new Exception("Message frame not supported");
|
||
}
|
||
|
||
//TEST take care of the writing
|
||
byte[] rtResponse = TryExecution(sdCommand, length);
|
||
int rtCode = Command.SetResponse(rtResponse);
|
||
return rtCode;
|
||
}
|
||
|
||
public byte[] ReadDeviceBlock(string iDeviceName, int iSize, ushort[] oData)
|
||
{
|
||
PlcDeviceType type;
|
||
int addr;
|
||
GetDeviceCode(iDeviceName, out type, out addr);
|
||
return ReadDeviceBlock(type, addr, iSize, oData);
|
||
}
|
||
|
||
public byte[] ReadDeviceBlock(PlcDeviceType iType, int iAddress, int iSize, ushort[] oData)
|
||
{
|
||
|
||
PlcDeviceType type = iType;
|
||
int addr = iAddress;
|
||
List<byte> data;
|
||
byte[] sdCommand;
|
||
int length;
|
||
|
||
switch (CommandFrame)
|
||
{
|
||
case McFrame.MC3E:
|
||
data = new List<byte>(6) { (byte)addr, (byte)(addr >> 8), (byte)(addr >> 16), (byte)type, (byte)iSize, (byte)(iSize >> 8) };
|
||
sdCommand = Command.SetCommandMC3E(0x0401, 0x0000, data.ToArray());
|
||
length = 11;
|
||
break;
|
||
case McFrame.MC4E:
|
||
data = new List<byte>(6) { (byte)addr, (byte)(addr >> 8), (byte)(addr >> 16), (byte)type, (byte)iSize, (byte)(iSize >> 8) };
|
||
sdCommand = Command.SetCommandMC4E(0x0401, 0x0000, data.ToArray());
|
||
length = 15;
|
||
break;
|
||
case McFrame.MC1E:
|
||
data = new List<byte>(6) { (byte)addr, (byte)(addr >> 8), (byte)(addr >> 16), (byte)(addr >> 24), 0x20, 0x44, (byte)iSize, 0x00 };
|
||
sdCommand = Command.SetCommandMC1E(0x01, data.ToArray());
|
||
length = 2;
|
||
break;
|
||
default:
|
||
throw new Exception("Message frame not supported");
|
||
}
|
||
|
||
byte[] rtResponse = TryExecution(sdCommand, length);
|
||
int rtCode = Command.SetResponse(rtResponse);
|
||
byte[] rtData = Command.Response;
|
||
for (int i = 0; i < iSize; ++i)
|
||
{
|
||
if (rtCode == 0)
|
||
{
|
||
oData[i] = (ushort)(rtData[i * 2] << 8 | rtData[i * 2 + 1]);
|
||
}
|
||
//oData[i] = (rtCode == 0) ? BitConverter.ToUInt16(rtData, i * 2) : 0;
|
||
}
|
||
return rtData;
|
||
}
|
||
|
||
public int SetDevice(string iDeviceName, int iData)
|
||
{
|
||
PlcDeviceType type;
|
||
int addr;
|
||
GetDeviceCode(iDeviceName, out type, out addr);
|
||
return SetDevice(type, addr, iData);
|
||
}
|
||
|
||
public int SetDevice(PlcDeviceType iType, int iAddress, int iData)
|
||
{
|
||
PlcDeviceType type = iType;
|
||
int addr = iAddress;
|
||
var data = new List<byte>(6) { (byte)addr, (byte)(addr >> 8), (byte)(addr >> 16), (byte)type, 0x01, 0x00, (byte)iData, (byte)(iData >> 8) };
|
||
byte[] sdCommand = Command.SetCommandMC3E(0x1401, 0x0000, data.ToArray());
|
||
int length = (Command.FrameType == McFrame.MC3E) ? 11 : 15;
|
||
byte[] rtResponse = TryExecution(sdCommand, length);
|
||
int rtCode = Command.SetResponse(rtResponse);
|
||
return rtCode;
|
||
}
|
||
|
||
public int GetDevice(string iDeviceName)
|
||
{
|
||
PlcDeviceType type;
|
||
int addr;
|
||
GetDeviceCode(iDeviceName, out type, out addr);
|
||
return GetDevice(type, addr);
|
||
}
|
||
|
||
public int GetDevice(PlcDeviceType iType, int iAddress)
|
||
{
|
||
PlcDeviceType type = iType;
|
||
int addr = iAddress;
|
||
var data = new List<byte>(6) { (byte)addr, (byte)(addr >> 8), (byte)(addr >> 16), (byte)type, 0x01, 0x00 };
|
||
byte[] sdCommand = Command.SetCommandMC3E(0x0401, 0x0000, data.ToArray());
|
||
int length = (Command.FrameType == McFrame.MC3E) ? 11 : 15;
|
||
byte[] rtResponse = TryExecution(sdCommand, length);
|
||
int rtCode = Command.SetResponse(rtResponse);
|
||
if (0 < rtCode)
|
||
{
|
||
this.Device = 0;
|
||
}
|
||
else
|
||
{
|
||
byte[] rtData = Command.Response;
|
||
this.Device = BitConverter.ToInt16(rtData, 0);
|
||
}
|
||
return rtCode;
|
||
}
|
||
|
||
#region IPlcEx
|
||
/// <summary>
|
||
/// 得到字节数据
|
||
/// </summary>
|
||
/// <param name="iDeviceName">如：M1000</param>
|
||
/// <param name="iSize">读取长度：>0</param>
|
||
/// <returns>数据</returns>
|
||
public int[] GetBitDevice(string iDeviceName, int iSize = 1)
|
||
{
|
||
int[] oData = new int[iSize];
|
||
GetBitDevice(iDeviceName, iSize, oData);
|
||
return oData;
|
||
}
|
||
/// <summary>
|
||
/// 得到字节数据
|
||
/// </summary>
|
||
/// <param name="iType">设备类型，如：M</param>
|
||
/// <param name="iAddress">如：M1000</param>
|
||
/// <param name="iSize">读取长度：>0</param>
|
||
/// <returns>数据</returns>
|
||
public int[] GetBitDevice(PlcDeviceType iType, int iAddress, int iSize = 1)
|
||
{
|
||
int[] oData = new int[iSize];
|
||
GetBitDevice(iType, iAddress, iSize, oData);
|
||
return oData;
|
||
}
|
||
/// <summary>
|
||
/// 设置字节数据
|
||
/// </summary>
|
||
/// <param name="iDeviceName">如：M1000</param>
|
||
/// <param name="iData">设置的数据</param>
|
||
public void SetBitDevice(string iDeviceName, params int[] iData)
|
||
{
|
||
SetBitDevice(iDeviceName, iData.Length, iData);
|
||
}
|
||
/// <summary>
|
||
/// 设置字节数据
|
||
/// </summary>
|
||
/// <param name="iType">设备类型，如：M</param>
|
||
/// <param name="iAddress">如：M1000</param>
|
||
/// <param name="iData">设置的数据</param>
|
||
public void SetBitDevice(PlcDeviceType iType, int iAddress, params int[] iData)
|
||
{
|
||
SetBitDevice(iType, iAddress, iData.Length, iData);
|
||
}
|
||
/// <summary>
|
||
/// 得到数据块
|
||
/// </summary>
|
||
/// <param name="iDeviceName">如：D1000</param>
|
||
/// <param name="iSize">读取长度：>0</param>
|
||
/// <returns>数据</returns>
|
||
public ushort[] ReadDeviceBlock(string iDeviceName, int iSize = 1)
|
||
{
|
||
ushort[] oData = new ushort[iSize];
|
||
ReadDeviceBlock(iDeviceName, iSize, oData);
|
||
return oData;
|
||
}
|
||
/// <summary>
|
||
/// 得到数据块
|
||
/// </summary>
|
||
/// <param name="iType">设备类型，如：D</param>
|
||
/// <param name="iAddress">如：D1000</param>
|
||
/// <param name="iSize">读取长度：>0</param>
|
||
/// <returns>数据</returns>
|
||
public ushort[] ReadDeviceBlock(PlcDeviceType iType, int iAddress, int iSize = 1)
|
||
{
|
||
ushort[] oData = new ushort[iSize];
|
||
ReadDeviceBlock(iType, iAddress, iSize, oData);
|
||
return oData;
|
||
}
|
||
/// <summary>
|
||
/// 写入数据块
|
||
/// </summary>
|
||
/// <param name="iDeviceName">如：D1000</param>
|
||
/// <param name="iData">写入10进制数据</param>
|
||
public void WriteDeviceBlock(string iDeviceName, params ushort[] iData)
|
||
{
|
||
WriteDeviceBlock(iDeviceName, iData.Length, iData);
|
||
}
|
||
/// <summary>
|
||
/// 写入数据块
|
||
/// </summary>
|
||
/// <param name="iType">设备类型，如：D</param>
|
||
/// <param name="iAddress">如：D1000</param>
|
||
/// <param name="iData">写入10进制数据</param>
|
||
public void WriteDeviceBlock(PlcDeviceType iType, int iAddress, params ushort[] iData)
|
||
{
|
||
WriteDeviceBlock(iType, iAddress, iData.Length, iData);
|
||
}
|
||
#endregion
|
||
|
||
//public int GetCpuType(out string oCpuName, out int oCpuType)
|
||
//{
|
||
// int rtCode = Command.Execute(0x0101, 0x0000, new byte[0]);
|
||
// oCpuName = "dummy";
|
||
// oCpuType = 0;
|
||
// return rtCode;
|
||
//}
|
||
|
||
public PlcDeviceType GetDeviceType(string s)
|
||
{
|
||
return (s == "M") ? PlcDeviceType.M :
|
||
(s == "SM") ? PlcDeviceType.SM :
|
||
(s == "L") ? PlcDeviceType.L :
|
||
(s == "F") ? PlcDeviceType.F :
|
||
(s == "V") ? PlcDeviceType.V :
|
||
(s == "S") ? PlcDeviceType.S :
|
||
(s == "X") ? PlcDeviceType.X :
|
||
(s == "Y") ? PlcDeviceType.Y :
|
||
(s == "B") ? PlcDeviceType.B :
|
||
(s == "SB") ? PlcDeviceType.SB :
|
||
(s == "DX") ? PlcDeviceType.DX :
|
||
(s == "DY") ? PlcDeviceType.DY :
|
||
(s == "D") ? PlcDeviceType.D :
|
||
(s == "SD") ? PlcDeviceType.SD :
|
||
(s == "R") ? PlcDeviceType.R :
|
||
(s == "ZR") ? PlcDeviceType.ZR :
|
||
(s == "W") ? PlcDeviceType.W :
|
||
(s == "SW") ? PlcDeviceType.SW :
|
||
(s == "TC") ? PlcDeviceType.TC :
|
||
(s == "TS") ? PlcDeviceType.TS :
|
||
(s == "TN") ? PlcDeviceType.TN :
|
||
(s == "CC") ? PlcDeviceType.CC :
|
||
(s == "CS") ? PlcDeviceType.CS :
|
||
(s == "CN") ? PlcDeviceType.CN :
|
||
(s == "SC") ? PlcDeviceType.SC :
|
||
(s == "SS") ? PlcDeviceType.SS :
|
||
(s == "SN") ? PlcDeviceType.SN :
|
||
(s == "Z") ? PlcDeviceType.Z :
|
||
(s == "TT") ? PlcDeviceType.TT :
|
||
(s == "TM") ? PlcDeviceType.TM :
|
||
(s == "CT") ? PlcDeviceType.CT :
|
||
(s == "CM") ? PlcDeviceType.CM :
|
||
(s == "A") ? PlcDeviceType.A :
|
||
PlcDeviceType.Max;
|
||
}
|
||
|
||
public static bool IsBitDevice(PlcDeviceType type)
|
||
{
|
||
return !((type == PlcDeviceType.D) || (type == PlcDeviceType.SD) || (type == PlcDeviceType.Z) || (type == PlcDeviceType.ZR) || (type == PlcDeviceType.R) || (type == PlcDeviceType.W));
|
||
}
|
||
|
||
public bool IsHexDevice(PlcDeviceType type)
|
||
{
|
||
return (type == PlcDeviceType.X) || (type == PlcDeviceType.Y) || (type == PlcDeviceType.B) || (type == PlcDeviceType.W);
|
||
}
|
||
|
||
public void GetDeviceCode(string iDeviceName, out PlcDeviceType oType, out int oAddress)
|
||
{
|
||
string s = iDeviceName.ToUpper();
|
||
string strAddress;
|
||
|
||
// 1.取出一个字符
|
||
string strType = s.Substring(0, 1);
|
||
switch (strType)
|
||
{
|
||
case "A":
|
||
case "B":
|
||
case "D":
|
||
case "F":
|
||
case "L":
|
||
case "M":
|
||
case "R":
|
||
case "V":
|
||
case "W":
|
||
case "X":
|
||
case "Y":
|
||
// 2字母后面，它应该是一个数字，所以转换它
|
||
strAddress = s.Substring(1);
|
||
break;
|
||
case "Z":
|
||
// 再拿出一个字符
|
||
strType = s.Substring(0, 2);
|
||
// 对于文件寄存器 : 2
|
||
// 对于索引寄存器 : 1
|
||
strAddress = s.Substring(strType.Equals("ZR") ? 2 : 1);
|
||
break;
|
||
case "C":
|
||
// 再拿出一个字符
|
||
strType = s.Substring(0, 2);
|
||
switch (strType)
|
||
{
|
||
case "CC":
|
||
case "CM":
|
||
case "CN":
|
||
case "CS":
|
||
case "CT":
|
||
strAddress = s.Substring(2);
|
||
break;
|
||
default:
|
||
throw new Exception("Invalid format.");
|
||
}
|
||
break;
|
||
case "S":
|
||
// 再拿出一个字符
|
||
strType = s.Substring(0, 2);
|
||
switch (strType)
|
||
{
|
||
case "SD":
|
||
case "SM":
|
||
strAddress = s.Substring(2);
|
||
break;
|
||
default:
|
||
throw new Exception("Invalid format.");
|
||
}
|
||
break;
|
||
case "T":
|
||
// 再拿出一个字符
|
||
strType = s.Substring(0, 2);
|
||
switch (strType)
|
||
{
|
||
case "TC":
|
||
case "TM":
|
||
case "TN":
|
||
case "TS":
|
||
case "TT":
|
||
strAddress = s.Substring(2);
|
||
break;
|
||
default:
|
||
throw new Exception("Invalid format.");
|
||
}
|
||
break;
|
||
default:
|
||
throw new Exception("Invalid format.");
|
||
}
|
||
oType = GetDeviceType(strType);
|
||
oAddress = IsHexDevice(oType) ? Convert.ToInt32(strAddress, BlockSize) : Convert.ToInt32(strAddress);
|
||
}
|
||
|
||
|
||
private byte[] TryExecution(byte[] iCommand, int minlength)
|
||
{
|
||
byte[] rtResponse;
|
||
int tCount = 10;
|
||
do
|
||
{
|
||
rtResponse = Execute(iCommand);
|
||
--tCount;
|
||
if (tCount < 0)
|
||
{
|
||
throw new Exception("无法从 PLC 获取正确的值.");
|
||
}
|
||
} while (Command.IsIncorrectResponse(rtResponse, minlength));
|
||
return rtResponse;
|
||
}
|
||
|
||
// 表示用于通信的命令的内部类
|
||
class McCommand
|
||
{
|
||
public McFrame FrameType { get; private set; } // 框架类型
|
||
private uint SerialNumber { get; set; } // 序号
|
||
private uint NetworkNumber { get; set; } // 网络号码
|
||
private uint PcNumber { get; set; } // 电脑号码
|
||
private uint IoNumber { get; set; } // 请求单元 I/O 编号/O番号
|
||
private uint ChannelNumber { get; set; } // 请求单位站号
|
||
private uint CpuTimer { get; set; } // 中央处理器监控计时器
|
||
private int ResultCode { get; set; } // 退出代码
|
||
public byte[] Response { get; private set; } // 响应数据
|
||
|
||
// 构造 函数
|
||
public McCommand(McFrame iFrame)
|
||
{
|
||
FrameType = iFrame;
|
||
SerialNumber = 0x0001u;
|
||
NetworkNumber = 0x0000u;
|
||
PcNumber = 0x00FFu;
|
||
IoNumber = 0x03FFu;
|
||
ChannelNumber = 0x0000u;
|
||
CpuTimer = 0x0010u;
|
||
}
|
||
|
||
public byte[] SetCommandMC1E(byte Subheader, byte[] iData)
|
||
{
|
||
List<byte> ret = new List<byte>(iData.Length + 4);
|
||
ret.Add(Subheader);
|
||
ret.Add((byte)this.PcNumber);
|
||
ret.Add((byte)CpuTimer);
|
||
ret.Add((byte)(CpuTimer >> 8));
|
||
ret.AddRange(iData);
|
||
return ret.ToArray();
|
||
}
|
||
public byte[] SetCommandMC3E(uint iMainCommand, uint iSubCommand, byte[] iData)
|
||
{
|
||
var dataLength = (uint)(iData.Length + 6);
|
||
List<byte> ret = new List<byte>(iData.Length + 20);
|
||
uint frame = 0x0050u;
|
||
ret.Add((byte)frame);
|
||
ret.Add((byte)(frame >> 8));
|
||
ret.Add((byte)NetworkNumber);
|
||
ret.Add((byte)PcNumber);
|
||
ret.Add((byte)IoNumber);
|
||
ret.Add((byte)(IoNumber >> 8));
|
||
ret.Add((byte)ChannelNumber);
|
||
ret.Add((byte)dataLength);
|
||
ret.Add((byte)(dataLength >> 8));
|
||
ret.Add((byte)CpuTimer);
|
||
ret.Add((byte)(CpuTimer >> 8));
|
||
ret.Add((byte)iMainCommand);
|
||
ret.Add((byte)(iMainCommand >> 8));
|
||
ret.Add((byte)iSubCommand);
|
||
ret.Add((byte)(iSubCommand >> 8));
|
||
|
||
ret.AddRange(iData);
|
||
return ret.ToArray();
|
||
}
|
||
public byte[] SetCommandMC4E(uint iMainCommand, uint iSubCommand, byte[] iData)
|
||
{
|
||
var dataLength = (uint)(iData.Length + 6);
|
||
var ret = new List<byte>(iData.Length + 20);
|
||
uint frame = 0x0054u;
|
||
ret.Add((byte)frame);
|
||
ret.Add((byte)(frame >> 8));
|
||
ret.Add((byte)SerialNumber);
|
||
ret.Add((byte)(SerialNumber >> 8));
|
||
ret.Add(0x00);
|
||
ret.Add(0x00);
|
||
ret.Add((byte)NetworkNumber);
|
||
ret.Add((byte)PcNumber);
|
||
ret.Add((byte)IoNumber);
|
||
ret.Add((byte)(IoNumber >> 8));
|
||
ret.Add((byte)ChannelNumber);
|
||
ret.Add((byte)dataLength);
|
||
ret.Add((byte)(dataLength >> 8));
|
||
ret.Add((byte)CpuTimer);
|
||
ret.Add((byte)(CpuTimer >> 8));
|
||
ret.Add((byte)iMainCommand);
|
||
ret.Add((byte)(iMainCommand >> 8));
|
||
ret.Add((byte)iSubCommand);
|
||
ret.Add((byte)(iSubCommand >> 8));
|
||
ret.AddRange(iData);
|
||
return ret.ToArray();
|
||
}
|
||
public int SetResponse(byte[] iResponse)
|
||
{
|
||
int min;
|
||
switch (FrameType)
|
||
{
|
||
case McFrame.MC1E:
|
||
min = 2;
|
||
if (min <= iResponse.Length)
|
||
{
|
||
ResultCode = (int)iResponse[min - 2];
|
||
Response = new byte[iResponse.Length - 2];
|
||
Buffer.BlockCopy(iResponse, min, Response, 0, Response.Length);
|
||
}
|
||
break;
|
||
case McFrame.MC3E:
|
||
min = 11;
|
||
if (min <= iResponse.Length)
|
||
{
|
||
var btCount = new[] { iResponse[min - 4], iResponse[min - 3] };
|
||
var btCode = new[] { iResponse[min - 2], iResponse[min - 1] };
|
||
int rsCount = BitConverter.ToUInt16(btCount, 0);
|
||
ResultCode = BitConverter.ToUInt16(btCode, 0);
|
||
Response = new byte[rsCount - 2];
|
||
Buffer.BlockCopy(iResponse, min, Response, 0, Response.Length);
|
||
}
|
||
break;
|
||
case McFrame.MC4E:
|
||
min = 15;
|
||
if (min <= iResponse.Length)
|
||
{
|
||
var btCount = new[] { iResponse[min - 4], iResponse[min - 3] };
|
||
var btCode = new[] { iResponse[min - 2], iResponse[min - 1] };
|
||
int rsCount = BitConverter.ToUInt16(btCount, 0);
|
||
ResultCode = BitConverter.ToUInt16(btCode, 0);
|
||
Response = new byte[rsCount - 2];
|
||
Buffer.BlockCopy(iResponse, min, Response, 0, Response.Length);
|
||
}
|
||
break;
|
||
default:
|
||
throw new Exception("Frame type not supported.");
|
||
|
||
}
|
||
return ResultCode;
|
||
}
|
||
public bool IsIncorrectResponse(byte[] iResponse, int minLenght)
|
||
{
|
||
//TEST add 1E frame
|
||
switch (this.FrameType)
|
||
{
|
||
case McFrame.MC1E: return ((iResponse.Length < minLenght));
|
||
|
||
case McFrame.MC3E:
|
||
case McFrame.MC4E:
|
||
var btCount = new[] { iResponse[minLenght - 4], iResponse[minLenght - 3] };
|
||
var btCode = new[] { iResponse[minLenght - 2], iResponse[minLenght - 1] };
|
||
var rsCount = BitConverter.ToUInt16(btCount, 0) - 2;
|
||
var rsCode = BitConverter.ToUInt16(btCode, 0);
|
||
return (rsCode == 0 && rsCount != (iResponse.Length - minLenght));
|
||
|
||
default: throw new Exception("Type Not supported");
|
||
|
||
}
|
||
}
|
||
}
|
||
|
||
private readonly object balanceLock = new object();
|
||
protected byte[] Execute(byte[] iCommand)
|
||
{
|
||
lock (balanceLock)
|
||
{
|
||
List<byte> list = new List<byte>();
|
||
|
||
NetworkStream ns = Stream;
|
||
ns.Write(iCommand, 0, iCommand.Length);
|
||
ns.Flush();
|
||
|
||
using (var ms = new MemoryStream())
|
||
{
|
||
var buff = new byte[256];
|
||
do
|
||
{
|
||
int sz = ns.Read(buff, 0, buff.Length);
|
||
if (sz == 0)
|
||
{
|
||
throw new Exception("已断开连接");
|
||
}
|
||
ms.Write(buff, 0, sz);
|
||
}
|
||
while (ns.DataAvailable);
|
||
|
||
return ms.ToArray();
|
||
}
|
||
}
|
||
}
|
||
|
||
#region INT16
|
||
public short ReadInt16(string address)
|
||
{
|
||
try
|
||
{
|
||
return ReadInt16(address, 1)[0];
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
throw new Exception(e.Message);
|
||
}
|
||
}
|
||
|
||
|
||
public short[] ReadInt16(string address, int count = 1)
|
||
{
|
||
try
|
||
{
|
||
//地址解析
|
||
ushort[] value = ReadDeviceBlock(address, count);//一个地址2个字节
|
||
short[] values = new short[count];
|
||
for (int i = 0; i < count; i++)
|
||
{
|
||
byte[] data = BitConverter.GetBytes(value[i]);
|
||
if (BitConverter.IsLittleEndian)
|
||
{
|
||
Array.Reverse(data);
|
||
}
|
||
values[i] = BitConverter.ToInt16(data, 0);
|
||
}
|
||
return values;
|
||
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
throw new Exception(e.Message);
|
||
}
|
||
}
|
||
|
||
public void WriteInt16(string address, short value)
|
||
{
|
||
try
|
||
{
|
||
WriteInt16(address, new short[] { value });
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
throw new Exception(e.Message);
|
||
}
|
||
}
|
||
|
||
|
||
public void WriteInt16(string address, short[] value)
|
||
{
|
||
try
|
||
{
|
||
ushort[] values = new ushort[value.Length];
|
||
for (int i = 0; i < value.Length; i++)
|
||
{
|
||
byte[] data = BitConverter.GetBytes(value[i]);
|
||
if (BitConverter.IsLittleEndian)
|
||
{
|
||
Array.Reverse(data);
|
||
}
|
||
values[i] = BitConverter.ToUInt16(data, 0);
|
||
}
|
||
WriteDeviceBlock(address, values);
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
throw new Exception(e.Message);
|
||
}
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region UINT16
|
||
public ushort ReadUInt16(string address)
|
||
{
|
||
try
|
||
{
|
||
return ReadUInt16(address, 1)[0];
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
throw new Exception(e.Message);
|
||
}
|
||
}
|
||
|
||
|
||
public ushort[] ReadUInt16(string address, int count = 1)
|
||
{
|
||
try
|
||
{
|
||
//地址解析
|
||
ushort[] value = ReadDeviceBlock(address, count);//一个地址2个字节
|
||
ushort[] values = new ushort[count];
|
||
for (int i = 0; i < count; i++)
|
||
{
|
||
byte[] data = BitConverter.GetBytes(value[i]);
|
||
if (BitConverter.IsLittleEndian)
|
||
{
|
||
Array.Reverse(data);
|
||
}
|
||
values[i] = BitConverter.ToUInt16(data, 0);
|
||
}
|
||
return values;
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
throw new Exception(e.Message);
|
||
}
|
||
}
|
||
|
||
public void WriteUInt16(string address, ushort value)
|
||
{
|
||
try
|
||
{
|
||
WriteUInt16(address, new ushort[] { value });
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
throw new Exception(e.Message);
|
||
}
|
||
}
|
||
|
||
|
||
public void WriteUInt16(string address, ushort[] value)
|
||
{
|
||
try
|
||
{
|
||
ushort[] values = new ushort[value.Length];
|
||
for (int i = 0; i < value.Length; i++)
|
||
{
|
||
byte[] data = BitConverter.GetBytes(value[i]);
|
||
if (BitConverter.IsLittleEndian)
|
||
{
|
||
Array.Reverse(data);
|
||
}
|
||
values[i] = BitConverter.ToUInt16(data, 0);
|
||
}
|
||
WriteDeviceBlock(address, values);
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
throw new Exception(e.Message);
|
||
}
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region INT32
|
||
public int ReadInt32(string address)
|
||
{
|
||
try
|
||
{
|
||
return ReadInt32(address, 1)[0];
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
throw new Exception(e.Message);
|
||
}
|
||
}
|
||
|
||
|
||
public int[] ReadInt32(string address, int count = 1)
|
||
{
|
||
try
|
||
{
|
||
//地址解析
|
||
ushort[] value = ReadDeviceBlock(address, count * 2);//一个地址2个字节
|
||
int[] values = new int[count];
|
||
for (int i = 0; i < count; i++)
|
||
{
|
||
byte[] data1 = BitConverter.GetBytes(value[2 * i + 0]);
|
||
byte[] data2 = BitConverter.GetBytes(value[2 * i + 1]);
|
||
List<byte> list = new List<byte>();
|
||
list.AddRange(data1);
|
||
list.AddRange(data2);
|
||
byte[] data = list.ToArray();
|
||
if (BitConverter.IsLittleEndian)
|
||
{
|
||
Array.Reverse(data);
|
||
}
|
||
values[i] = BitConverter.ToInt32(data, 0);
|
||
}
|
||
return values;
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
throw new Exception(e.Message);
|
||
}
|
||
}
|
||
|
||
public void WriteInt32(string address, int value)
|
||
{
|
||
try
|
||
{
|
||
WriteInt32(address, new int[] { value });
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
throw new Exception(e.Message);
|
||
}
|
||
}
|
||
|
||
|
||
public void WriteInt32(string address, int[] value)
|
||
{
|
||
try
|
||
{
|
||
List<ushort> values = new List<ushort>();
|
||
for (int i = 0; i < value.Length; i++)
|
||
{
|
||
byte[] data = BitConverter.GetBytes(value[i]);
|
||
if (BitConverter.IsLittleEndian)
|
||
{
|
||
Array.Reverse(data);
|
||
}
|
||
ushort value1 = BitConverter.ToUInt16(data, 0);
|
||
ushort value2 = BitConverter.ToUInt16(data, 2);
|
||
values.Add(value1);
|
||
values.Add(value2);
|
||
}
|
||
WriteDeviceBlock(address, values.ToArray());
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
throw new Exception(e.Message);
|
||
}
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region UINT32
|
||
public uint ReadUInt32(string address)
|
||
{
|
||
try
|
||
{
|
||
return ReadUInt32(address, 1)[0];
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
throw new Exception(e.Message);
|
||
}
|
||
}
|
||
|
||
|
||
public uint[] ReadUInt32(string address, int count = 1)
|
||
{
|
||
try
|
||
{
|
||
//地址解析
|
||
ushort[] value = ReadDeviceBlock(address, count * 2);//一个地址2个字节
|
||
uint[] values = new uint[count];
|
||
for (int i = 0; i < count; i++)
|
||
{
|
||
byte[] data1 = BitConverter.GetBytes(value[2 * i + 0]);
|
||
byte[] data2 = BitConverter.GetBytes(value[2 * i + 1]);
|
||
List<byte> list = new List<byte>();
|
||
list.AddRange(data1);
|
||
list.AddRange(data2);
|
||
byte[] data = list.ToArray();
|
||
if (BitConverter.IsLittleEndian)
|
||
{
|
||
Array.Reverse(data);
|
||
}
|
||
values[i] = BitConverter.ToUInt32(data, 0);
|
||
}
|
||
return values;
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
throw new Exception(e.Message);
|
||
}
|
||
}
|
||
|
||
public void WriteUInt32(string address, uint value)
|
||
{
|
||
try
|
||
{
|
||
WriteUInt32(address, new uint[] { value });
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
throw new Exception(e.Message);
|
||
}
|
||
}
|
||
|
||
|
||
public void WriteUInt32(string address, uint[] value)
|
||
{
|
||
try
|
||
{
|
||
List<ushort> values = new List<ushort>();
|
||
for (int i = 0; i < value.Length; i++)
|
||
{
|
||
byte[] data = BitConverter.GetBytes(value[i]);
|
||
if (BitConverter.IsLittleEndian)
|
||
{
|
||
Array.Reverse(data);
|
||
}
|
||
ushort value1 = BitConverter.ToUInt16(data, 0);
|
||
ushort value2 = BitConverter.ToUInt16(data, 2);
|
||
values.Add(value1);
|
||
values.Add(value2);
|
||
}
|
||
WriteDeviceBlock(address, values.ToArray());
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
throw new Exception(e.Message);
|
||
}
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region FLOAT
|
||
public float ReadFloat(string address)
|
||
{
|
||
try
|
||
{
|
||
return ReadFloat(address, 1)[0];
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
throw new Exception(e.Message);
|
||
}
|
||
}
|
||
|
||
|
||
public float[] ReadFloat(string address, int count = 1)
|
||
{
|
||
try
|
||
{
|
||
//地址解析
|
||
ushort[] value = ReadDeviceBlock(address, count * 2);//一个地址2个字节
|
||
float[] values = new float[count];
|
||
for (int i = 0; i < count; i++)
|
||
{
|
||
byte[] data1 = BitConverter.GetBytes(value[2 * i + 0]);
|
||
byte[] data2 = BitConverter.GetBytes(value[2 * i + 1]);
|
||
List<byte> list = new List<byte>();
|
||
list.AddRange(data1);
|
||
list.AddRange(data2);
|
||
byte[] data = list.ToArray();
|
||
if (BitConverter.IsLittleEndian)
|
||
{
|
||
Array.Reverse(data);
|
||
}
|
||
values[i] = BitConverter.ToSingle(data, 0);
|
||
}
|
||
return values;
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
throw new Exception(e.Message);
|
||
}
|
||
}
|
||
|
||
public void WriteFloat(string address, float value)
|
||
{
|
||
try
|
||
{
|
||
WriteFloat(address, new float[] { value });
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
throw new Exception(e.Message);
|
||
}
|
||
}
|
||
|
||
|
||
public void WriteFloat(string address, float[] value)
|
||
{
|
||
try
|
||
{
|
||
List<ushort> values = new List<ushort>();
|
||
for (int i = 0; i < value.Length; i++)
|
||
{
|
||
byte[] data = BitConverter.GetBytes(value[i]);
|
||
if (BitConverter.IsLittleEndian)
|
||
{
|
||
Array.Reverse(data);
|
||
}
|
||
ushort value1 = BitConverter.ToUInt16(data, 0);
|
||
ushort value2 = BitConverter.ToUInt16(data, 2);
|
||
values.Add(value1);
|
||
values.Add(value2);
|
||
}
|
||
WriteDeviceBlock(address, values.ToArray());
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
throw new Exception(e.Message);
|
||
}
|
||
}
|
||
|
||
#endregion
|
||
|
||
|
||
#region Double
|
||
public double ReadDouble(string address)
|
||
{
|
||
try
|
||
{
|
||
return ReadDouble(address, 1)[0];
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
throw new Exception(e.Message);
|
||
}
|
||
}
|
||
|
||
|
||
public double[] ReadDouble(string address, int count = 1)
|
||
{
|
||
try
|
||
{
|
||
//地址解析
|
||
ushort[] value = ReadDeviceBlock(address, count * 4);
|
||
double[] values = new double[count];
|
||
for (int i = 0; i < count; i++)
|
||
{
|
||
byte[] data1 = BitConverter.GetBytes(value[4 * i + 0]);
|
||
byte[] data2 = BitConverter.GetBytes(value[4 * i + 1]);
|
||
byte[] data3 = BitConverter.GetBytes(value[4 * i + 2]);
|
||
byte[] data4 = BitConverter.GetBytes(value[4 * i + 3]);
|
||
List<byte> list = new List<byte>();
|
||
list.AddRange(data1);
|
||
list.AddRange(data2);
|
||
list.AddRange(data3);
|
||
list.AddRange(data4);
|
||
byte[] data = list.ToArray();
|
||
if (BitConverter.IsLittleEndian)
|
||
{
|
||
Array.Reverse(data);
|
||
}
|
||
values[i] = BitConverter.ToDouble(data, 0);
|
||
}
|
||
return values;
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
throw new Exception(e.Message);
|
||
}
|
||
}
|
||
|
||
public void WriteDouble(string address, double value)
|
||
{
|
||
try
|
||
{
|
||
WriteDouble(address, new double[] { value });
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
throw new Exception(e.Message);
|
||
}
|
||
}
|
||
|
||
|
||
public void WriteDouble(string address, double[] value)
|
||
{
|
||
try
|
||
{
|
||
List<ushort> values = new List<ushort>();
|
||
for (int i = 0; i < value.Length; i++)
|
||
{
|
||
byte[] data = BitConverter.GetBytes(value[i]);
|
||
if (BitConverter.IsLittleEndian)
|
||
{
|
||
Array.Reverse(data);
|
||
}
|
||
ushort value1 = BitConverter.ToUInt16(data, 0);
|
||
ushort value2 = BitConverter.ToUInt16(data, 2);
|
||
ushort value3 = BitConverter.ToUInt16(data, 4);
|
||
ushort value4 = BitConverter.ToUInt16(data, 6);
|
||
values.Add(value1);
|
||
values.Add(value2);
|
||
values.Add(value3);
|
||
values.Add(value4);
|
||
}
|
||
WriteDeviceBlock(address, values.ToArray());
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
throw new Exception(e.Message);
|
||
}
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region Int64
|
||
public long ReadInt64(string address)
|
||
{
|
||
try
|
||
{
|
||
return ReadInt64(address, 1)[0];
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
throw new Exception(e.Message);
|
||
}
|
||
}
|
||
|
||
|
||
public long[] ReadInt64(string address, int count = 1)
|
||
{
|
||
try
|
||
{
|
||
//地址解析
|
||
ushort[] value = ReadDeviceBlock(address, count * 4);
|
||
long[] values = new long[count];
|
||
for (int i = 0; i < count; i++)
|
||
{
|
||
byte[] data1 = BitConverter.GetBytes(value[4 * i + 0]);
|
||
byte[] data2 = BitConverter.GetBytes(value[4 * i + 1]);
|
||
byte[] data3 = BitConverter.GetBytes(value[4 * i + 2]);
|
||
byte[] data4 = BitConverter.GetBytes(value[4 * i + 3]);
|
||
List<byte> list = new List<byte>();
|
||
list.AddRange(data1);
|
||
list.AddRange(data2);
|
||
list.AddRange(data3);
|
||
list.AddRange(data4);
|
||
byte[] data = list.ToArray();
|
||
if (BitConverter.IsLittleEndian)
|
||
{
|
||
Array.Reverse(data);
|
||
}
|
||
values[i] = BitConverter.ToInt64(data, 0);
|
||
}
|
||
return values;
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
throw new Exception(e.Message);
|
||
}
|
||
}
|
||
|
||
public void WriteInt64(string address, long value)
|
||
{
|
||
try
|
||
{
|
||
WriteInt64(address, new long[] { value });
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
throw new Exception(e.Message);
|
||
}
|
||
}
|
||
|
||
|
||
public void WriteInt64(string address, long[] value)
|
||
{
|
||
try
|
||
{
|
||
List<ushort> values = new List<ushort>();
|
||
for (int i = 0; i < value.Length; i++)
|
||
{
|
||
byte[] data = BitConverter.GetBytes(value[i]);
|
||
if (BitConverter.IsLittleEndian)
|
||
{
|
||
Array.Reverse(data);
|
||
}
|
||
ushort value1 = BitConverter.ToUInt16(data, 0);
|
||
ushort value2 = BitConverter.ToUInt16(data, 2);
|
||
ushort value3 = BitConverter.ToUInt16(data, 4);
|
||
ushort value4 = BitConverter.ToUInt16(data, 6);
|
||
values.Add(value1);
|
||
values.Add(value2);
|
||
values.Add(value3);
|
||
values.Add(value4);
|
||
}
|
||
WriteDeviceBlock(address, values.ToArray());
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
throw new Exception(e.Message);
|
||
}
|
||
}
|
||
|
||
#endregion
|
||
|
||
}
|
||
public enum McFrame
|
||
{
|
||
MC1E = 4,
|
||
MC3E = 11,
|
||
MC4E = 15
|
||
}
|
||
|
||
/// <summary>
|
||
/// 定义 PLC 设备类型的枚举
|
||
/// </summary>
|
||
public enum PlcDeviceType
|
||
{
|
||
// PLC设备
|
||
M = 0x90
|
||
, SM = 0x91
|
||
, L = 0x92
|
||
, F = 0x93
|
||
, V = 0x94
|
||
, S = 0x98
|
||
, X = 0x9C
|
||
, Y = 0x9D
|
||
, B = 0xA0
|
||
, SB = 0xA1
|
||
, DX = 0xA2
|
||
, DY = 0xA3
|
||
, D = 0xA8
|
||
, SD = 0xA9
|
||
, R = 0xAF
|
||
, ZR = 0xB0
|
||
, W = 0xB4
|
||
, SW = 0xB5
|
||
, TC = 0xC0
|
||
, TS = 0xC1
|
||
, TN = 0xC2
|
||
, CC = 0xC3
|
||
, CS = 0xC4
|
||
, CN = 0xC5
|
||
, SC = 0xC6
|
||
, SS = 0xC7
|
||
, SN = 0xC8
|
||
, Z = 0xCC
|
||
, TT
|
||
, TM
|
||
, CT
|
||
, CM
|
||
, A
|
||
, Max
|
||
}
|
||
}
|