BeckhoffAdsNet 类

public class BeckhoffAdsNet : DeviceTcpNet

Public Class BeckhoffAdsNet
	Inherits DeviceTcpNet

public ref class BeckhoffAdsNet : public DeviceTcpNet

type BeckhoffAdsNet =  
    class
        inherit DeviceTcpNet
    end

private BeckhoffAdsNet beckhoff;

private void Sample1( )
{
    // 主要分为两种实例化方式，手动的NETID赋值，和自动的方式，先说明手动的方式
    beckhoff = new BeckhoffAdsNet( "127.0.0.1", 48898 );    // IP地址是TWINCAT 软件所在的电脑的IP，端口固定
    beckhoff.SetTargetAMSNetId( "192.168.64.1.1.1:851" );
    beckhoff.SetSenderAMSNetId( "192.168.64.1.1.1:35086" );
    beckhoff.UseTagCache = true;          // 启用标签符号缓存

    // 我们再来看看自动的方式是什么
    beckhoff = new BeckhoffAdsNet( "127.0.0.1", 48898 );   // IP地址是TWINCAT 软件所在的电脑的IP，端口固定
    beckhoff.AmsPort = 851;
    beckhoff.UseAutoAmsNetID = true;      // 自动AMS
    beckhoff.UseTagCache = true;          // 启用标签符号缓存
}

private void Connect( )
{
    OperateResult connect = beckhoff.ConnectServer( );
    if (connect.IsSuccess)
    {
        // 连接成功
    }
    else
    {
        // 连接失败
    }

}

private void Read( )
{
    // 演示简单的单个读取操作
    OperateResult<short> read = beckhoff.ReadInt16( "M100" );
    if (read.IsSuccess)
    {
        Console.WriteLine( "M00: " + read.Content );
    }
    else
    {
        Console.WriteLine( "Read failed: " + read.ToMessageShowString( ) );
    }

    // 如果是读取变量信息，比如 MIAN.dd  如果是全局变量，则不需要输入MAIN.
    OperateResult<float> read_dd = beckhoff.ReadFloat( "s=MAIN.dd" );
    if (read_dd.IsSuccess)
    {
        Console.WriteLine( "MAIN.dd: " + read_dd.Content );
    }
    else
    {
        Console.WriteLine( "Read failed: " + read_dd.ToMessageShowString( ) );
    }

    // 写入也是同理的。
    beckhoff.Write( "M100", (short)123 );
    beckhoff.Write( "s=MAIN.dd", 1.23f );

    // 其他类型都是同理，我们看下数据的情况，如果在PLC里，有个变量 MIAN.ee 是 bool数组，ee: ARRAY[0..10] OF BOOL;
    OperateResult<bool[]> read_bool = beckhoff.ReadBool( "s=MAIN.ee", 11 );
    if (read_bool.IsSuccess)
    {
        // 一次性全部读回来，写入同理
    }

    // 如果要读取数组中的某个值
    OperateResult<bool> read_bool2 = beckhoff.ReadBool( "s=MAIN.ee[2]" );
    if (read_bool2.IsSuccess)
    {
        // 读取了索引2的值，注意，读取某个值的时候，只能读取1个数据
    }
    // 写入同理
    beckhoff.Write( "s=MAIN.ee[7]", true );
}

public void Sample4( )
{
    // 此处演示批量读取，读取数组可以一定程度的提高效率，如果还想要提供效率，可以使用 批量读取。
    // 我们假设要读取4个数据
    // 1. M100           的short数据
    // 2. s=MAIN.dd      的flaot数据  PLC上显示REAL类型
    // 3. s=MAIN.a       的short数据  PLC上显示INT类型
    // 4. s=MAIN.ee      的bool数组类型，读5个bool

    OperateResult<byte[]> read = beckhoff.Read(
        new string[] {
            "M100",
            "s=MAIN.dd",
            "s=MAIN.a",
            "s=MAIN.ee"
        },
        new ushort[]
        {
            2,
            4,
            2,
            5
        } );
    if (read.IsSuccess)
    {
        // 读取成功，开始提取数据信息，总计回复 2 + 4 + 2 + 5 = 13个字节数据
        short m100 = beckhoff.ByteTransform.TransInt16( read.Content, 0 );
        float dd   = beckhoff.ByteTransform.TransSingle( read.Content, 2 );
        short a    = beckhoff.ByteTransform.TransInt16( read.Content, 6 );
        bool[] ee  = read.Content.SelectMiddle( 8, 5 ).Select( m => m != 0x00 ).ToArray( );  // 示例  01 00 01 00 01  为00 就是false，01就是true，其他不可识别
    }

    // 特别说明，如果存在符号地址，第一次读取会慢一点，因为还需要读取符号地址对应的内存地址，后续的读取就会很快
    // In particular, if there is a symbolic address, the first read will be slower, because the memory address corresponding to the symbolic address needs to be read, and subsequent reads will be very fast
}

// 此处演示类型读取，读取类型也可以一定程度的提高效率，还方便的支持自动的解析。
// 我们假设要读取5个数据
// The type reading is demonstrated here. Reading the type can also improve the efficiency to a certain extent, and it is also convenient to support automatic parsing.

// 1. s=MAIN.a       的short数据  PLC上显示INT类型                 INT type displayed on PLC
// 2. s=MAIN.cc      的int数据    PLC上显示DINT类型                Display DINT type on PLC
// 3. s=MAIN.dd      的flaot数据  PLC上显示REAL类型                REAL type displayed on PLC
// 4. s=MAIN.ee      的bool数组类型，PLC显示11个长度的bool数组      The bool array type, PLC displays a bool array of 11 lengths
// 5. s=MAIN.ff      的int数组， PLC显示3个长度的INT数组            The int array, the PLC displays an int array of 3 lengths

// 定义类对象，类名及属性名可以自定义                               Define class objects, class names and attribute names can be customized
public class MyData
{
    [HslCommunication.Reflection.HslDeviceAddress("s=MAIN.a")]
    public short A { get; set; }

    [HslCommunication.Reflection.HslDeviceAddress( "s=MAIN.cc" )]
    public int CC { get; set; }

    [HslCommunication.Reflection.HslDeviceAddress( "s=MAIN.dd" )]
    public float DD { get; set; }

    [HslCommunication.Reflection.HslDeviceAddress( "s=MAIN.ee", 11 )]
    public bool[] EE { get; set; }

    [HslCommunication.Reflection.HslDeviceAddress( "s=MAIN.ff", 3 )]
    public short[] FF { get; set; }
}

// 然后下面方法演示读取示例
public void Sample5( )
{
    OperateResult<MyData> read = beckhoff.Read<MyData>( );
    if (read.IsSuccess)
    {
        // 读取成功，打印出来看看                                         Read successfully, print it out to see
        Console.WriteLine( "A: "  + read.Content.A );
        Console.WriteLine( "CC: " + read.Content.CC );
        Console.WriteLine( "DD: " + read.Content.DD );
        Console.WriteLine( "EE: " + read.Content.EE.ToArrayString( ) );
        Console.WriteLine( "FF: " + read.Content.FF.ToArrayString( ) );
    }

    // 特别说明，如果存在符号地址，第一次读取会慢一点，因为还需要读取符号地址对应的内存地址，后续的读取就会很快
    // In particular, if there is a symbolic address, the first read will be slower, because the memory address corresponding to the symbolic address needs to be read, and subsequent reads will be very fast
}