public void WriteBool( )
{
#region WriteBool
MelsecMcNet melsec_net = new MelsecMcNet("192.168.0.100", 6000);
// 以下是简单的写入，没有仔细校验的方式
melsec_net.Write("M100", true);
melsec_net.Write("M100", new bool[] { true, false, true, false });
// 如果需要判断是否读取成功
OperateResult write1 = melsec_net.Write("M100", true);
if (write1.IsSuccess)
{
// success
}
else
{
// failed
}
OperateResult write2 = melsec_net.Write("M100", new bool[] { true, false, true, false });
if (write2.IsSuccess)
{
// success
}
else
{
// failed
}
#endregion
}
public void ReadUInt64Array( )
{
#region ReadUInt64Array
MelsecMcNet melsec_net = new MelsecMcNet("192.168.0.100", 6000);
// 以下是简单的读取，没有仔细校验的方式
ulong[] d100_139 = melsec_net.ReadUInt64("D100", 10).Content;
// 如果需要判断是否读取成功
OperateResult <ulong[]> R_d100_139 = melsec_net.ReadUInt64("D100", 10);
if (R_d100_139.IsSuccess)
{
ulong value_d100 = R_d100_139.Content[0];
ulong value_d104 = R_d100_139.Content[1];
ulong value_d108 = R_d100_139.Content[2];
ulong value_d112 = R_d100_139.Content[3];
ulong value_d116 = R_d100_139.Content[4];
ulong value_d120 = R_d100_139.Content[5];
ulong value_d124 = R_d100_139.Content[6];
ulong value_d128 = R_d100_139.Content[7];
ulong value_d132 = R_d100_139.Content[8];
ulong value_d136 = R_d100_139.Content[9];
}
else
{
// failed
}
#endregion
}
public void ReadInt16Array( )
{
#region ReadInt16Array
MelsecMcNet melsec_net = new MelsecMcNet("192.168.0.100", 6000);
// 以下是简单的读取，没有仔细校验的方式
short[] d100_109_value = melsec_net.ReadInt16("D100", 10).Content;
// 如果需要判断是否读取成功
OperateResult <short[]> R_d100_109_value = melsec_net.ReadInt16("D100", 10);
if (R_d100_109_value.IsSuccess)
{
// success
short value_d100 = R_d100_109_value.Content[0];
short value_d101 = R_d100_109_value.Content[1];
short value_d102 = R_d100_109_value.Content[2];
short value_d103 = R_d100_109_value.Content[3];
short value_d104 = R_d100_109_value.Content[4];
short value_d105 = R_d100_109_value.Content[5];
short value_d106 = R_d100_109_value.Content[6];
short value_d107 = R_d100_109_value.Content[7];
short value_d108 = R_d100_109_value.Content[8];
short value_d109 = R_d100_109_value.Content[9];
}
else
{
// failed
}
#endregion
}
public void ConnectServer( )
{
MelsecMcNet client = new MelsecMcNet( );
#region Connect1
// client为设备的连接对象，简单的启动连接
client.ConnectServer( );
#endregion
#region Connect2
// client为设备的连接对象，如果想知道是否连接成功
OperateResult connect = client.ConnectServer( );
if (connect.IsSuccess)
{
Console.WriteLine("connect success");
}
else
{
// do something
Console.WriteLine("connect failed");
}
#endregion
}
public void ReadFloatArray( )
{
#region ReadFloatArray
MelsecMcNet melsec_net = new MelsecMcNet("192.168.0.100", 6000);
// 以下是简单的读取，没有仔细校验的方式
float[] d100_119 = melsec_net.ReadFloat("D100", 10).Content;
// 如果需要判断是否读取成功
OperateResult <float[]> R_d100_119 = melsec_net.ReadFloat("D100", 10);
if (R_d100_119.IsSuccess)
{
float value_d100 = R_d100_119.Content[0];
float value_d102 = R_d100_119.Content[1];
float value_d104 = R_d100_119.Content[2];
float value_d106 = R_d100_119.Content[3];
float value_d108 = R_d100_119.Content[4];
float value_d110 = R_d100_119.Content[5];
float value_d112 = R_d100_119.Content[6];
float value_d114 = R_d100_119.Content[7];
float value_d116 = R_d100_119.Content[8];
float value_d118 = R_d100_119.Content[9];
}
else
{
// failed
}
#endregion
}
/// <summary>
/// 构造函数重载
/// </summary>
/// <param name="port"></param>
public PortPLC_MITHls(int port)
{
NameClass = "PLC_MITHis";
//新建实例
Melsec_net = new MelsecMcNet(ParSetPLC.P_I.IP, port);
}
/// <summary>
/// 实例化一个三菱的设备对象，从配置信息创建
/// </summary>
/// <param name="element">配置信息</param>
public DeviceMelsecMc(XElement element)
{
var nodeMelsec = new NodeMelsecMc();
nodeMelsec.LoadByXmlElement(element);
LoadRequest(element);
if (nodeMelsec.IsBinary)
{
protocol = 1;
melsecMcNet = new MelsecMcNet(nodeMelsec.IpAddress, nodeMelsec.Port);
melsecMcNet.NetworkNumber = nodeMelsec.NetworkNumber;
melsecMcNet.NetworkStationNumber = nodeMelsec.NetworkStationNumber;
melsecMcNet.ConnectTimeOut = nodeMelsec.ConnectTimeOut;
ByteTransform = melsecMcNet.ByteTransform;
ReadWriteDevice = melsecMcNet;
UniqueId = melsecMcNet.ConnectionId;
}
else
{
melsecMcAscii = new MelsecMcAsciiNet(nodeMelsec.IpAddress, nodeMelsec.Port);
melsecMcAscii.NetworkNumber = nodeMelsec.NetworkNumber;
melsecMcAscii.NetworkStationNumber = nodeMelsec.NetworkStationNumber;
melsecMcAscii.ConnectTimeOut = nodeMelsec.ConnectTimeOut;
ByteTransform = melsecMcAscii.ByteTransform;
ReadWriteDevice = melsecMcAscii;
UniqueId = melsecMcAscii.ConnectionId;
}
TypeName = "三菱设备";
}
public void ConnectServer2( )
{
MelsecMcNet client = new MelsecMcNet( );
AlienSession session = new AlienSession( );
#region AlienConnect1
// session对象由 NetworkAlienClient 类创建
client.ConnectServer(session);
#endregion
#region AlienConnect2
// session对象由 NetworkAlienClient 类创建
OperateResult connect = client.ConnectServer(session);
if (connect.IsSuccess)
{
Console.WriteLine("connect success");
}
else
{
// do something
Console.WriteLine("connect failed");
}
#endregion
}
public void WriteCustomerExample( )
{
#region WriteCustomerExample
MelsecMcNet melsec = new MelsecMcNet("192.168.0.100", 6000);
DataMy dataMy = new DataMy( );
dataMy.temperature = 20;
dataMy.press = 123.456f;
dataMy.others = 1234232132;
OperateResult write = melsec.WriteCustomer("D1000", dataMy);
if (write.IsSuccess)
{
// success
Console.WriteLine("写入成功！");
}
else
{
// failed
Console.WriteLine("读取失败：" + write.Message);
}
#endregion
}
public void ReadExample( )
{
#region ReadExample1
MelsecMcNet melsec_net = new MelsecMcNet("192.168.0.100", 6000);
// 此处以D寄存器作为示例
short short_D1000 = melsec_net.ReadInt16("D1000").Content; // 读取D1000的short值
ushort ushort_D1000 = melsec_net.ReadUInt16("D1000").Content; // 读取D1000的ushort值
int int_D1000 = melsec_net.ReadInt32("D1000").Content; // 读取D1000-D1001组成的int数据
uint uint_D1000 = melsec_net.ReadUInt32("D1000").Content; // 读取D1000-D1001组成的uint数据
float float_D1000 = melsec_net.ReadFloat("D1000").Content; // 读取D1000-D1001组成的float数据
long long_D1000 = melsec_net.ReadInt64("D1000").Content; // 读取D1000-D1003组成的long数据
ulong ulong_D1000 = melsec_net.ReadUInt64("D1000").Content; // 读取D1000-D1003组成的long数据
double double_D1000 = melsec_net.ReadDouble("D1000").Content; // 读取D1000-D1003组成的double数据
string str_D1000 = melsec_net.ReadString("D1000", 10).Content; // 读取D1000-D1009组成的条码数据
// 读取数组
short[] short_D1000_array = melsec_net.ReadInt16("D1000", 10).Content; // 读取D1000的short值
ushort[] ushort_D1000_array = melsec_net.ReadUInt16("D1000", 10).Content; // 读取D1000的ushort值
int[] int_D1000_array = melsec_net.ReadInt32("D1000", 10).Content; // 读取D1000-D1001组成的int数据
uint[] uint_D1000_array = melsec_net.ReadUInt32("D1000", 10).Content; // 读取D1000-D1001组成的uint数据
float[] float_D1000_array = melsec_net.ReadFloat("D1000", 10).Content; // 读取D1000-D1001组成的float数据
long[] long_D1000_array = melsec_net.ReadInt64("D1000", 10).Content; // 读取D1000-D1003组成的long数据
ulong[] ulong_D1000_array = melsec_net.ReadUInt64("D1000", 10).Content; // 读取D1000-D1003组成的long数据
double[] double_D1000_array = melsec_net.ReadDouble("D1000", 10).Content; // 读取D1000-D1003组成的double数据
#endregion
}
public void WriteExample2( )
{
#region WriteExample2
MelsecMcNet melsec_net = new MelsecMcNet("192.168.0.100", 6000);
// 拼凑数据，这样的话，一次通讯就完成数据的全部写入
byte[] buffer = new byte[8];
melsec_net.ByteTransform.TransByte((short)1234).CopyTo(buffer, 0);
melsec_net.ByteTransform.TransByte((short)2100).CopyTo(buffer, 2);
melsec_net.ByteTransform.TransByte(12353423).CopyTo(buffer, 4);
OperateResult write = melsec_net.Write("D100", buffer);
if (write.IsSuccess)
{
// success
}
else
{
// failed
}
// 上面的功能等同于三个数据分别写入，下面的性能更差点，因为进行了三次通讯，而且每次还要判断是否写入成功
//melsec_net.Write( "D100", (short)1234 );
//melsec_net.Write( "D100", (short)2100 );
//melsec_net.Write( "D100", 12353423 );
#endregion
}
public void WriteExample( )
{
#region WriteExample1
MelsecMcNet melsec_net = new MelsecMcNet("192.168.0.100", 6000);
// 此处以D寄存器作为示例
melsec_net.Write("D1000", (short)1234); // 写入D1000 short值 ,W3C0,R3C0 效果是一样的
melsec_net.Write("D1000", (ushort)45678); // 写入D1000 ushort值
melsec_net.Write("D1000", 1234566); // 写入D1000 int值
melsec_net.Write("D1000", (uint)1234566); // 写入D1000 uint值
melsec_net.Write("D1000", 123.456f); // 写入D1000 float值
melsec_net.Write("D1000", 123.456d); // 写入D1000 double值
melsec_net.Write("D1000", 123456661235123534L); // 写入D1000 long值
melsec_net.Write("D1000", 523456661235123534UL); // 写入D1000 ulong值
melsec_net.Write("D1000", "K123456789"); // 写入D1000 string值
// 读取数组
melsec_net.Write("D1000", new short[] { 123, 3566, -123 }); // 写入D1000 short值 ,W3C0,R3C0 效果是一样的
melsec_net.Write("D1000", new ushort[] { 12242, 42321, 12323 }); // 写入D1000 ushort值
melsec_net.Write("D1000", new int[] { 1234312312, 12312312, -1237213 }); // 写入D1000 int值
melsec_net.Write("D1000", new uint[] { 523123212, 213, 13123 }); // 写入D1000 uint值
melsec_net.Write("D1000", new float[] { 123.456f, 35.3f, -675.2f }); // 写入D1000 float值
melsec_net.Write("D1000", new double[] { 12343.542312d, 213123.123d, -231232.53432d }); // 写入D1000 double值
melsec_net.Write("D1000", new long[] { 1231231242312, 34312312323214, -1283862312631823 }); // 写入D1000 long值
melsec_net.Write("D1000", new ulong[] { 1231231242312, 34312312323214, 9731283862312631823 }); // 写入D1000 ulong值
#endregion
}
public void LogNetExample( )
{
#region LogNetExample1
// 设备连接对象的日志
MelsecMcNet melsec = new MelsecMcNet("192.168.0.100", 6000);
// 举例实现日志文件为单日志文件
melsec.LogNet = new HslCommunication.LogNet.LogNetSingle("D://123.txt");
#endregion
#region LogNetExample2
// 一般服务器对象的
NetSimplifyServer simplifyServer = new NetSimplifyServer( );
simplifyServer.LogNet = new HslCommunication.LogNet.LogNetSingle("D://log.txt");
simplifyServer.ReceiveStringEvent += (HslCommunication.Core.Net.AppSession session, HslCommunication.NetHandle handle, string data) =>
{
simplifyServer.SendMessage(session, handle, "Back:" + data);
};
simplifyServer.ServerStart(45678);
#endregion
}
/// <summary>
/// 连接
/// </summary>
/// <returns></returns>
public bool Connect()
{
if (string.IsNullOrEmpty(_ip))
{
return(false);
}
if (melseNet != null)
{
try
{
melseNet.ConnectClose();
melseNet.Dispose();
}
catch (Exception err)
{
if (OnError != null)
{
OnError(this, new IOErrorEventArgs(this.ID, err.Message));
}
}
}
melseNet = new MelsecMcNet();
melseNet.IpAddress = _ip;
melseNet.Port = _port;
melseNet.ReceiveTimeOut = _timeout;
var result = melseNet.ConnectServer();
return(_connected = true);
}
public void ConnectCloseExample( )
{
MelsecMcNet client = new MelsecMcNet( );
#region ConnectCloseExample
client.ConnectClose( );
#endregion
}
public void InitializationOnConnectExample( )
{
MelsecMcNet client = new MelsecMcNet( );
#region InitializationOnConnectExample
#endregion
}
public void ClassTest( )
{
#region Usage
// 实例化对象，指定PLC的ip地址和端口号
MelsecMcNet melsecMc = new MelsecMcNet("192.168.1.110", 6000);
// 举例读取D100的值
short D100 = melsecMc.ReadInt16("D100").Content;
#endregion
}
public void MelsecUnitTest( )
{
MelsecMcNet plc = new MelsecMcNet("192.168.8.13", 6001);
if (!plc.ConnectServer( ).IsSuccess)
{
Console.WriteLine("无法连接PLC，将跳过单元测试。等待网络正常时，再进行测试");
return;
}
// 开始单元测试
}
public void LogNetExample( )
{
MelsecMcNet obj = new MelsecMcNet("192.168.0.100", 6000);
#region LogNetExample
// obj 为NetworkBase所有的派生类对象
// 举例实现日志文件为单日志文件
obj.LogNet = new HslCommunication.LogNet.LogNetSingle("D://123.txt");
#endregion
}
public void ReceiveTimeOutExample( )
{
MelsecMcNet client = new MelsecMcNet( );
#region ReceiveTimeOutExample
// 设置反馈的超时时间，单位 毫秒
client.ReceiveTimeOut = 1000;
// 1秒没有接收到就自动返回失败，此处的地址示例是modbus的地址，对于读取也是一样的
OperateResult write = client.Write("100", 123);
#endregion
}
public void ConnectTimeOutExample( )
{
MelsecMcNet client = new MelsecMcNet( );
#region ConnectTimeOutExample
// 设置连接的超时时间，单位 毫秒
client.ConnectTimeOut = 1000;
// 1秒没有连接上的时候就自动返回失败
client.ConnectServer( );
#endregion
}
// 写设备的值
public bool WriteValue(Common.PlcDevice plcDevice, object value)
{
bool IsOk = false;
try
{
Config.PlcDataItem devData = this.GetPlcDataItem(plcDevice);
Config.PlcTypeItem devType = this.GetPlcTypeItem(devData.DeviceName);
switch (devType.DevType)
{
//Keyence
case Common.DeviceType.Keyence:
KeyenceMcNet kPlcClient = (KeyenceMcNet)devType.Tag;
IsOk = this.WriteSieTcpValue(devType, devData, kPlcClient, value);
break;
//Melsec
case Common.DeviceType.Qseries:
MelsecMcNet mPlcClient = (MelsecMcNet)devType.Tag;
IsOk = this.WriteSieTcpValue(devType, devData, mPlcClient, value);
break;
case Common.DeviceType.S1200:
case Common.DeviceType.S300:
case Common.DeviceType.S400:
case Common.DeviceType.S1500:
case Common.DeviceType.S200Smart:
case Common.DeviceType.S200:
SiemensS7Net sPlcClient = (SiemensS7Net)devType.Tag;
IsOk = this.WriteSieTcpValue(devType, devData, sPlcClient, value);
break;
case Common.DeviceType.ModbusTcp:
ModbusTcpNet mTcpClient = (ModbusTcpNet)devType.Tag;
IsOk = this.WriteModTcpValue(devType, devData, mTcpClient, value);
break;
case Common.DeviceType.ModbusRtu:
ModbusRtu mRtuClinet = (ModbusRtu)devType.Tag;
IsOk = this.WriteModRtuValue(devType, devData, mRtuClinet, value);
break;
default:
break;
}
}
catch { }
return(IsOk);
}
public Form1()
{
InitializeComponent();
melsec_net = new MelsecMcNet();
LampXInput.Add(PBX0); LampYOutput.Add(PBY0);
LampXInput.Add(PBX1); LampYOutput.Add(PBY1);
LampXInput.Add(PBX2); LampYOutput.Add(PBY2);
LampXInput.Add(PBX3); LampYOutput.Add(PBY3);
LampXInput.Add(PBX4); LampYOutput.Add(PBY4);
LampXInput.Add(PBX5); LampYOutput.Add(PBY5);
LampXInput.Add(PBX6); LampYOutput.Add(PBY6);
LampXInput.Add(PBX7); LampYOutput.Add(PBY7);
}
public override void DeviceConn(MelsecBinaryConfig config)
{
MelsecMcNet melsecMc = new MelsecMcNet();
melsecMc.IpAddress = config.IP;
melsecMc.Port = config.Port;
melsecMc.ConnectTimeOut = config.ConnTimeOut;
NetworkDevice = melsecMc;
OperateResult connect = melsecMc.ConnectServerAsync().Result;
if (!connect.IsSuccess)
{
throw new Exception("Connect Failed");
}
}
public void ByteTransformExample( )
{
MelsecMcNet client = new MelsecMcNet( );
#region ByteTransform
// 假设buffer是client从设备读取的数据内容
byte[] buffer = new byte[8];
// 转化为4个short
short[] short_value = client.ByteTransform.TransInt16(buffer, 0, 4);
// 转化为2个float
float[] float_value = client.ByteTransform.TransSingle(buffer, 0, 2);
// 其他的类型转换是类似的
#endregion
}
public void SetPersistentConnectionExample( )
{
MelsecMcNet client = new MelsecMcNet( );
#region SetPersistentConnectionExample
client.SetPersistentConnection( ); // 设置长连接，但是不立即连接，等到第一次读写的时候再启动连接。
System.Threading.Thread.Sleep(10000); // 休眠10秒
// 调用write时才是真正的启动连接，后续的读写操作重复利用该连接，此处的地址示例是modbus的地址，对于读取也是一样的
OperateResult write = client.Write("100", 123);
#endregion
}
private void Connect()
{
// specify plc ip address and port
melsec_net = new MelsecMcNet(txtIP.Text, Decimal.ToInt32(nudPort.Value));
OperateResult connect = melsec_net.ConnectServer();
if (connect.IsSuccess)
{
// success
lblStatus.Text = "Connected";
}
else
{
// failed
lblStatus.Text = "DisConnected";
}
}
public CcsmDeviceApi(string serviceName, string ipAddress, int port)
{
_serviceName = serviceName;
_ipAddress = ipAddress;
_port = port;
_deviceApi = new MelsecMcNet(_ipAddress, _port);
if (_deviceApi != null)
{
Logger.Main.Info($"[{_serviceName}]初始化设备成功: {_ipAddress}:{_port}");
// ConnectStatus = true;
}
else
{
Logger.Main.Info($"[{_serviceName}]初始化设备失败: {_ipAddress}:{_port}");
}
}
public void ReadBool( )
{
#region ReadBool
MelsecMcNet melsec_net = new MelsecMcNet("192.168.0.100", 6000);
// 以下是简单的读取，没有仔细校验的方式
bool X1 = melsec_net.ReadBool("X1").Content;
bool[] X1_10 = melsec_net.ReadBool("X1", 10).Content;
// 如果需要判断是否读取成功
OperateResult <bool> R_X1 = melsec_net.ReadBool("X1");
if (R_X1.IsSuccess)
{
// success
bool value = R_X1.Content;
}
else
{
// failed
}
OperateResult <bool[]> R_X1_10 = melsec_net.ReadBool("X1", 10);
if (R_X1_10.IsSuccess)
{
// success
bool x1 = R_X1_10.Content[0];
bool x2 = R_X1_10.Content[1];
bool x3 = R_X1_10.Content[2];
bool x4 = R_X1_10.Content[3];
bool x5 = R_X1_10.Content[4];
bool x6 = R_X1_10.Content[5];
bool x7 = R_X1_10.Content[6];
bool x8 = R_X1_10.Content[7];
bool x9 = R_X1_10.Content[8];
bool xa = R_X1_10.Content[9];
}
else
{
// failed
}
#endregion
}
public override bool LoadFromConfig(XmlNode node)
{
XmlElement level1_item = (XmlElement)node;
string IP = level1_item.GetAttribute("IP");
string Port = level1_item.GetAttribute("Port");
PLC = new MelsecMcNet();
try
{
PLC.IpAddress = IP;
PLC.Port = Convert.ToInt32(Port);
PLC.ConnectTimeOut = 2000;
}
catch { }
return(base.LoadFromConfig(node));
}
