MelsecMcUdp 类

public class MelsecMcUdp : NetworkUdpDeviceBase, 
	IReadWriteMc, IReadWriteDevice, IReadWriteNet

Public Class MelsecMcUdp
	Inherits NetworkUdpDeviceBase
	Implements IReadWriteMc, IReadWriteDevice, IReadWriteNet

public ref class MelsecMcUdp : public NetworkUdpDeviceBase, 
	IReadWriteMc, IReadWriteDevice, IReadWriteNet

type MelsecMcUdp =  
    class
        inherit NetworkUdpDeviceBase
        interface IReadWriteMc
        interface IReadWriteDevice
        interface IReadWriteNet
    end

// 实例化对象，指定PLC的ip地址和端口号
MelsecMcNet melsecMc = new MelsecMcNet( "192.168.1.110", 6000 );
// 举例读取D100的值
short D100 = melsecMc.ReadInt16( "D100" ).Content;

// 实例化对象，指定PLC的ip地址和端口号
MelsecMcNet melsecMc = new MelsecMcNet( "192.168.1.110", 6000 );

// 如果网络不太理想，配置了两个端口，一个有问题，立即切换另一个的话，可以配置如下的代码
// melsecMc.GetPipeSocket( ).SetMultiPorts( new int[] { 6000, 6001 } );

// 连接对象
OperateResult connect = melsecMc.ConnectServer( );
if (!connect.IsSuccess)
{
    Console.WriteLine( "connect failed:" + connect.Message );
    return;
}

// 举例读取D100的值
short D100 = melsecMc.ReadInt16( "D100" ).Content;

// 实际上所有的读写都是返回是否成功的标记的，在实际的开发中，需要严格的判定，怎么判定呢？如下的代码
// In fact, all reads and writes return the flags of success. In actual development, strict judgment is required. How to judge? The following code
OperateResult<short> readD100 = melsecMc.ReadInt16( "D100" );
if (readD100.IsSuccess)
{
    // 读取成功，这时候获取Content才是正确的值
    // The reading is successful, and the Content is the correct value at this time.
    short value = readD100.Content;
}
else
{
    // 读取失败，如果仍然坚持去获取Content的值，就为0
    // Failed to read, if it still persists to get the value of Content, it is 0
}

// 读写是否成功的情况，应用于几乎所有的读写代码，只要看清楚返回的数据类型即可
// Whether the reading and writing is successful is applied to almost all reading and writing codes, as long as the type of data returned is clear

melsecMc.ConnectClose( );

MelsecMcNet melsec_net = new MelsecMcNet( "192.168.0.100", 6000 );
melsec_net.SetPersistentConnection( );                                           // 设置长连接的操作

// 此处以D寄存器作为示例，此处没有判断是否读写成功，所以是有风险的，如果通讯失败，所有的值都不是正确的
// The D register is used as an example here. There is no judgment whether the read or write is successful, so it is risky. 
// If the communication fails, all values are incorrect
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数据

// 正常的安全的操作如下，每一行都需要转变下面的代码
// The normal and safe operation is as follows, each line needs to change the following code
OperateResult<short> resultD1000 = melsec_net.ReadInt16( "D1000" );
if (resultD1000.IsSuccess)
{
    Console.WriteLine( resultD1000.Content );
}

MelsecMcNet melsec_net = new MelsecMcNet( "192.168.0.100", 6000 );

// 下面演示读取连续的地址的数据，实际中连续的地址，存储的数据类型不一样，可能既有short，又有int，又有float，还可能有倍数计算的关系
// 所以此处假设，
// D100存储的short，10倍的温度值，例如值为 1234，实际表示 123.4℃
// D101存储的short，100倍的压力值，例如值为 456, 实际表示 4.56 Mpa
// D102存储的int，生产产量计数
// D104-D108 共计5个D存储了10个字符，表示条码
OperateResult<byte[]> read = melsec_net.Read( "D100", 10 );  // 读出来20个字节长度的结果
if(read.IsSuccess)
{
    float temp = melsec_net.ByteTransform.TransInt16( read.Content, 0 ) / 10f;
    float press = melsec_net.ByteTransform.TransInt16( read.Content, 2 ) / 100f;
    int count = melsec_net.ByteTransform.TransInt32( read.Content, 4 );
    string barcode = melsec_net.ByteTransform.TransString( read.Content, 8, 10, Encoding.ASCII );
    // do something
}
else
{
    // failed
}

 // 随机读取的示例，所谓的随机读取，就是跨地址读取数据

// 下面我们举个例子，我们读取D100的值，D200的值，M32的值，W100的值，如何一次就读取出来呢？
MelsecMcNet melsec_net = new MelsecMcNet( "192.168.0.100", 6000 );

OperateResult<byte[]> read = melsec_net.ReadRandom( new string[] { "D100", "D200", "M32", "W100" } );
if (read.IsSuccess)
{
    short d100 = melsec_net.ByteTransform.TransInt16( read.Content, 0 );
    short d200 = melsec_net.ByteTransform.TransInt16( read.Content, 2 );
    short w100 = melsec_net.ByteTransform.TransInt16( read.Content, 6 );

    // M是位地址，提取稍微麻烦一点点
    bool[] array = HslCommunication.BasicFramework.SoftBasic.ByteToBoolArray( melsec_net.ByteTransform.TransByte( read.Content, 4, 2 ) );
    bool m32 = array[0];
    bool m33 = array[1];
    bool m34 = array[2];
    bool m35 = array[3];
    // 等等，按照规律操作就可以

    // do something
}
else
{
    // failed
}

// 随机读取的示例，所谓的随机读取，就是跨地址读取数据

// 下面我们举个例子，我们读取D100-D104的值，D200-D209的值，M32-M47的值，W100-W104的值，如何一次就读取出来呢？
MelsecMcNet melsec_net = new MelsecMcNet( "192.168.0.100", 6000 );

OperateResult<byte[]> read = melsec_net.ReadRandom( new string[] { "D100", "D200", "M32", "W100" }, new ushort[] { 5, 10, 1, 5 } );
if (read.IsSuccess)
{
    short d100 = melsec_net.ByteTransform.TransInt16( read.Content, 0 );
    short d101 = melsec_net.ByteTransform.TransInt16( read.Content, 2 );
    short d102 = melsec_net.ByteTransform.TransInt16( read.Content, 4 );
    short d103 = melsec_net.ByteTransform.TransInt16( read.Content, 6 );
    short d104 = melsec_net.ByteTransform.TransInt16( read.Content, 8 );
    short d200 = melsec_net.ByteTransform.TransInt16( read.Content, 10 );
    short d201 = melsec_net.ByteTransform.TransInt16( read.Content, 12 );
    // 等等
    short w100 = melsec_net.ByteTransform.TransInt16( read.Content, 32 );
    short w101 = melsec_net.ByteTransform.TransInt16( read.Content, 34 );
    short w102 = melsec_net.ByteTransform.TransInt16( read.Content, 36 );
    short w103 = melsec_net.ByteTransform.TransInt16( read.Content, 38 );
    short w104 = melsec_net.ByteTransform.TransInt16( read.Content, 40 );

    // M是位地址，提取稍微麻烦一点点
    bool[] array = HslCommunication.BasicFramework.SoftBasic.ByteToBoolArray( melsec_net.ByteTransform.TransByte( read.Content, 30, 2 ) );
    bool m32 = array[0];
    bool m33 = array[1];
    bool m34 = array[2];
    bool m35 = array[3];
    // 等等，按照规律操作就可以

    // do something
}
else
{
    // failed
}