GKMLT通讯工具箱（WPF MVVM) - 07-倍福ADS通讯

1. 通讯协议概述

1.1 倍福ADS通讯简介

ADS（Automation Device Specification）是德国倍福（Beckhoff）公司开发的专用通讯协议，用于基于PC的控制系统通讯。ADS基于TCP/IP协议，提供了高效、实时的数据交换机制，主要用于与倍福TwinCAT PLC系统进行通讯。

1.2 主要特点

基于TCP/IP：利用标准以太网进行通讯
客户端/服务器模式：支持双向通讯
符号访问：可以直接通过变量名访问PLC数据
索引访问：支持通过索引组/索引偏移直接访问
高效数据传输：支持批量读写操作
实时性能：优化的通讯机制，适合实时数据交换
多客户端：支持多个客户端同时访问

1.3 AMS地址结构

复制代码

AMS网络ID格式：a.b.c.d.e.f
- a.b.c.d：IP地址
- e：端口（1-16）
- f：路由（通常为1）

示例：
192.168.1.10.1.1  - 本地PLC端口1
192.168.1.10.2.1  - 本地PLC端口2
192.168.1.11.1.1  - 远程PLC

2. 协议栈结构

2.1 分层架构

复制代码

┌─────────────────────────────────────┐
│   应用层 (Application Layer)         │
│   ADS Protocol (数据访问)            │
├─────────────────────────────────────┤
│   表示层 (Presentation Layer)        │
│   ADS数据封装 (序列化/反序列化)      │
├─────────────────────────────────────┤
│   会话层 (Session Layer)             │
│   AMS (AMS Address Resolution)       │
├─────────────────────────────────────┤
│   传输层 (Transport Layer)           │
│   TCP (Transmission Control Protocol)│
├─────────────────────────────────────┤
│   网络层 (Network Layer)             │
│   IP (Internet Protocol)             │
└─────────────────────────────────────┘

2.2 AMS路由机制

复制代码

┌──────────────┐         ┌──────────────┐
│   Client     │         │  TwinCAT PLC │
│              │         │              │
│  AMS Router  │◄───────►│  ADS Server  │
│              │  TCP/IP │              │
└──────────────┘         └──────────────┘
     │                           │
     │ 192.168.1.100.1.1         │ 192.168.1.10.1.1
     │                           │
     └───────┬───────────────────┘
             │
        Ethernet Switch

2.3 ADS数据类型映射

PLC类型	C#类型	大小（字节）	说明
BOOL	bool	1	布尔值
BYTE	byte	1	无符号字节
SINT	sbyte	1	有符号字节
USINT	byte	1	无符号字节
INT	short	2	有符号短整数
UINT	ushort	2	无符号短整数
DINT	int	4	有符号整数
UDINT	uint	4	无符号整数
LINT	long	8	有符号长整数
ULINT	ulong	8	无符号长整数
REAL	float	4	单精度浮点数
LREAL	double	8	双精度浮点数
STRING	string	变长	字符串

3. 报文格式详解

3.1 AMS报文头结构

cpp 复制代码

struct AMS_Header {
    uint16_t Length;           // AMS数据长度
    uint32_t Error;            // 错误码
    uint32_t InvokeId;         // 调用ID
    uint8_t  Flags;            // 标志位
    uint16_t DataLength;       // 数据长度
    uint8_t  ErrorCode;        // 错误代码
    uint32_t Blocks;           // 块数量
    
    // AMS网络ID
    AMS_NetId DestNetId;       // 目标网络ID
    AMS_NetId SrcNetId;        // 源网络ID
    uint16_t Port;             // 端口
    uint16_t Port;             // 端口
};

struct AMS_NetId {
    uint8_t b1, b2, b3, b4, b5, b6;  // 6字节网络ID
};

3.2 ADS报文结构

复制代码

┌──────────────┬──────────────────┬──────────────┐
│ AMS Header   │  ADS Request/    │   Data       │
│   (38 bytes) │    Response      │  (变长)       │
└──────────────┴──────────────────┴──────────────┘

3.3 ADS命令码

命令码	命令名称	说明
0x01	ReadDeviceInformation	读取设备信息
0x02	Read	读取数据
0x03	Write	写入数据
0x04	ReadState	读取状态
0x05	WriteControl	写入控制
0x06	AddDeviceNotification	添加设备通知
0x07	DeleteDeviceNotification	删除设备通知
0x08	DeviceNotification	设备通知
0x09	ReadWrite	读写操作
0x0A	Reserved	保留

3.4 索引组（Index Group）定义

索引组	说明	访问方式
0x0000	存储器访问	直接访问
0x4020	符号/变量名访问	符号名
0x4021	符号/变量名释放	符号名
0x4025	读写符号值	符号名
0xF000	PLC任务控制	任务控制
0xF003	系统服务	系统信息

3.5 读取请求报文格式

cpp 复制代码

struct ADS_Read_Request {
    AMS_Header amsHeader;           // AMS头
    uint32_t IndexGroup;            // 索引组
    uint32_t IndexOffset;           // 索引偏移
    uint32_t Length;                // 读取长度
};

实际读取示例：

复制代码

// 读取符号"Main.Counter"
IndexGroup: 0x4020 (符号访问)
IndexOffset: 符号句柄
Length: 4 (DINT类型)

3.6 写入请求报文格式

cpp 复制代码

struct ADS_Write_Request {
    AMS_Header amsHeader;           // AMS头
    uint32_t IndexGroup;            // 索引组
    uint32_t IndexOffset;           // 索引偏移
    uint32_t Length;                // 写入长度
    uint8_t  Data[];                // 写入数据
};

4. 通讯原理

4.1 连接建立过程

复制代码

Client (PC)                    TwinCAT PLC
    │                               │
    │─────── TCP SYN ──────────────>│
    │<────── TCP SYN+ACK ───────────│
    │─────── TCP ACK ──────────────>│
    │                               │
    │── ADS Connect (Port 851) ─────>│
    │<── ADS Connect Response ──────│
    │        连接已建立             │

4.2 符号访问流程

复制代码

Application    │    AdsClient          │    SymbolLoader    │    PLC
    │                │                    │                  │
    │ ReadSymbol     │                    │                  │
    │ "Main.Counter" │                    │                  │
    │──────────────>│                    │                  │
    │                │ Resolve Symbol     │                  │
    │                │ Get Symbol Handle  │                  │
    │                │───────────────────>│                  │
    │                │                    │─ Symbol Info ───>│
    │                │<────────────────────│                  │
    │                │                    │                  │
    │                │ Read by Index      │                  │
    │                │───────────────────>│── Read Data ───>│
    │                │<────────────────────│<─ Value ─────────│
    │<──────────────│                    │                  │
    │   Result       │                    │                  │

4.3 符号加载机制

树形模式（推荐）：

复制代码

PLC Symbol Tree
├── MAIN
│   ├── Counter (DINT)
│   ├── Temperature (REAL)
│   └── Status (BOOL)
├── Recipe
│   ├── SetPoint (REAL)
│   └── Tolerance (REAL)
└── Alarms
    ├── Alarm1 (BOOL)
    └── Alarm2 (BOOL)

平铺模式：

复制代码

Symbol List:
MAIN.Counter
MAIN.Temperature
MAIN.Status
Recipe.SetPoint
Recipe.Tolerance
Alarms.Alarm1
Alarms.Alarm2

5. 调用方法与API

5.1 AdsClient类主要属性

csharp 复制代码

public class AdsClient : IDisposable
{
    // 连接参数
    public string? AmsNetId { get; private set; }   // AMS网络ID
    public string LocalAmsNetId { get; set; }      // 本地AMS ID
    public bool IsConnected { get; }                // 是否已连接
    
    // 符号管理
    public TcAdsSymbolInfoLoader? SymbolLoader { get; }  // 符号加载器
    public ObservableCollection<AdsSymbolInfo> Symbols { get; }  // 符号集合
    
    // 统计信息
    public AdsStatistics Statistics { get; }        // 统计数据
    
    // 事件
    public event EventHandler<bool>? ConnectionStatusChanged;
    public event EventHandler<AdsSymbolValueChangedEventArgs>? SymbolValueChanged;
    public event EventHandler<AdsErrorEventArgs>? ErrorOccurred;
}

5.2 连接管理API

5.2.1 建立连接

csharp 复制代码

using NET8_ADS;

// 创建客户端实例
AdsClient client = new AdsClient();

// 设置AMS网络ID（格式：IP.端口.路由）
string amsNetId = "192.168.1.10.1.1";

// 建立连接
var result = await client.ConnectAsync(amsNetId, port: 851);

if (result.IsSuccess)
{
    // 连接成功
    Console.WriteLine($"已连接到PLC：{result.Message}");
    
    // 自动创建符号加载器
    await client.CreateSymbolLoaderAsync();
}
else
{
    // 连接失败
    Console.WriteLine($"连接失败：{result.Message}");
}

5.2.2 断开连接

csharp 复制代码

client.Disconnect();

5.3 符号管理API

5.3.1 加载符号（树形模式）

csharp 复制代码

// 树形模式：只加载根符号
var result = await client.LoadAllSymbolsAsync(flatMode: false);

if (result.IsSuccess)
{
    var symbols = result.Data;
    Console.WriteLine($"加载了{symbols.Count}个根符号");
    
    // 符号已自动填充到client.Symbols集合
    foreach (var symbol in symbols)
    {
        Console.WriteLine($"符号名：{symbol.Name}");
    }
}

5.3.2 加载符号（平铺模式）

csharp 复制代码

// 平铺模式：加载所有符号（最多10000个）
var result = await client.LoadAllSymbolsAsync(flatMode: true);

if (result.IsSuccess)
{
    var symbols = result.Data;
    Console.WriteLine($"加载了{symbols.Count}个符号");
}

5.3.3 查找符号

csharp 复制代码

// 根据名称查找符号
var result = await client.FindSymbolAsync("MAIN.Counter");

if (result.IsSuccess)
{
    var symbol = result.Data;
    Console.WriteLine($"找到符号：{symbol.Name}");
    Console.WriteLine($"索引组：{symbol.IndexGroup}");
    Console.WriteLine($"索引偏移：{symbol.IndexOffset}");
    Console.WriteLine($"大小：{symbol.Size}字节");
}

5.3.4 读取符号信息

csharp 复制代码

// 读取符号的详细信息
var result = await client.ReadSymbolInfoAsync("MAIN.Temperature");

if (result.IsSuccess)
{
    var symbolInfo = result.Data;
    // 可以获取符号的完整信息
}

5.4 数据读取API

5.4.1 按符号名读取

csharp 复制代码

// 读取符号值
var result = await client.ReadSymbolAsync("MAIN.Counter");

if (result.IsSuccess)
{
    object value = result.Data;
    
    // 根据实际类型转换
    if (value is int counterValue)
    {
        Console.WriteLine($"计数器值：{counterValue}");
    }
}
else
{
    Console.WriteLine($"读取失败：{result.Message}");
}

5.4.2 按索引读取

csharp 复制代码

// 通过索引组/索引偏移直接读取
// IndexGroup: 0x4020 (符号访问)
// IndexOffset: 实际偏移量
// DataLength: 读取长度

var result = await client.ReadByIndexAsync(
    indexGroup: 0x4020,
    indexOffset: 0x0000,
    dataLength: 4  // 读取4字节
);

if (result.IsSuccess)
{
    byte[] data = result.Data;
    int value = BitConverter.ToInt32(data, 0);
    Console.WriteLine($"读取值：{value}");
}

5.5 数据写入API

5.5.1 按符号名写入

csharp 复制代码

// 写入整数
var result = await client.WriteSymbolAsync("MAIN.Counter", 100);
if (result.IsSuccess)
{
    Console.WriteLine("写入成功");
}

// 写入浮点数
result = await client.WriteSymbolAsync("MAIN.Temperature", 25.5f);

// 写入布尔值
result = await client.WriteSymbolAsync("MAIN.StartCommand", true);

// 写入字符串（自动检测类型）
result = await client.WriteSymbolAsync("MAIN.Message", "System Started");

5.5.2 按索引写入

csharp 复制代码

// 准备写入数据
int valueToWrite = 12345;
byte[] data = BitConverter.GetBytes(valueToWrite);

// 通过索引写入
var result = await client.WriteByIndexAsync(
    indexGroup: 0x4020,
    indexOffset: 0x0000,
    data: data
);

if (result.IsSuccess)
{
    Console.WriteLine($"成功写入{result.Data}字节");
}

5.6 事件订阅

csharp 复制代码

// 连接状态变化事件
client.ConnectionStatusChanged += (sender, isConnected) =>
{
    Console.WriteLine($"连接状态：{(isConnected ? "已连接" : "已断开")}");
};

// 符号值变化事件
client.SymbolValueChanged += (sender, e) =>
{
    Console.WriteLine($"符号变化：{e.Symbol.Name} = {e.Value}");
};

// 错误事件
client.ErrorOccurred += (sender, e) =>
{
    Console.WriteLine($"错误：{e.Message}");
};

5.7 统计信息

csharp 复制代码

// 获取统计信息
var stats = client.Statistics;

Console.WriteLine($"读取成功：{stats.ReadSuccessCount}/{stats.TotalReadCount}");
Console.WriteLine($"写入成功：{stats.WriteSuccessCount}/{stats.TotalWriteCount}");
Console.WriteLine($"读取成功率：{stats.GetReadSuccessRate():F2}%");
Console.WriteLine($"写入成功率：{stats.GetWriteSuccessRate():F2}%");
Console.WriteLine($"最后错误：{stats.LastErrorMessage}");

// 重置统计
stats.Reset();

6. 实际应用示例

6.1 基础应用：PLC数据监控

csharp 复制代码

using NET8_ADS;

public class PlcMonitor
{
    private AdsClient _client;
    private Timer _monitorTimer;
    
    public async Task<bool> StartAsync(string amsNetId)
    {
        _client = new AdsClient();
        
        // 订阅事件
        _client.ConnectionStatusChanged += OnConnectionStatusChanged;
        _client.ErrorOccurred += OnError;
        
        // 连接PLC
        var result = await _client.ConnectAsync(amsNetId);
        if (!result.IsSuccess)
        {
            Console.WriteLine($"连接失败：{result.Message}");
            return false;
        }
        
        // 创建符号加载器
        await client.CreateSymbolLoaderAsync();
        
        // 启动定时监控
        _monitorTimer = new Timer(async _ => await MonitorDataAsync(), 
                                    null, 0, 1000);
        
        return true;
    }
    
    private async Task MonitorDataAsync()
    {
        if (!_client.IsConnected) return;
        
        // 监控的关键变量
        string[] tags = { 
            "MAIN.Temperature", 
            "MAIN.Pressure", 
            "MAIN.FlowRate",
            "MAIN.AlarmStatus"
        };
        
        foreach (var tag in tags)
        {
            var result = await _client.ReadSymbolAsync(tag);
            if (result.IsSuccess)
            {
                Console.WriteLine($"{tag} = {result.Data}");
            }
        }
    }
    
    private void OnConnectionStatusChanged(object? sender, bool isConnected)
    {
        Console.WriteLine($"连接状态：{(isConnected ? "已连接" : "已断开")}");
    }
    
    private void OnError(object? sender, AdsErrorEventArgs e)
    {
        Console.WriteLine($"错误：{e.Message}");
    }
    
    public void Stop()
    {
        _monitorTimer?.Dispose();
        _client?.Dispose();
    }
}

6.2 高级应用：配方管理系统

csharp 复制代码

public class RecipeManager
{
    private AdsClient _client;
    
    public async Task<bool> ConnectAsync(string amsNetId)
    {
        _client = new AdsClient();
        var result = await _client.ConnectAsync(amsNetId);
        return result.IsSuccess && await _client.CreateSymbolLoaderAsync().IsSuccess;
    }
    
    // 读取配方
    public async Task<RecipeData> ReadRecipeAsync(int recipeNumber)
    {
        string baseName = $"Recipe.Recipe_{recipeNumber}";
        
        // 并行读取配方参数
        var tasks = new[]
        {
            _client.ReadSymbolAsync($"{baseName}.Temperature"),
            _client.ReadSymbolAsync($"{baseName}.Pressure"),
            _client.ReadSymbolAsync($"{baseName}.Speed"),
            _client.ReadSymbolAsync($"{baseName}.Duration")
        };
        
        var results = await Task.WhenAll(tasks);
        
        return new RecipeData
        {
            RecipeID = recipeNumber,
            Temperature = (float)results[0].Data,
            Pressure = (float)results[1].Data,
            Speed = (float)results[2].Data,
            Duration = (int)results[3].Data
        };
    }
    
    // 写入配方
    public async Task<bool> WriteRecipeAsync(RecipeData recipe)
    {
        string baseName = $"Recipe.Recipe_{recipe.RecipeID}";
        
        // 批量写入配方参数
        var writeTasks = new[]
        {
            _client.WriteSymbolAsync($"{baseName}.Temperature", recipe.Temperature),
            _client.WriteSymbolAsync($"{baseName}.Pressure", recipe.Pressure),
            _client.WriteSymbolAsync($"{baseName}.Speed", recipe.Speed),
            _client.WriteSymbolAsync($"{baseName}.Duration", recipe.Duration)
        };
        
        var results = await Task.WhenAll(writeTasks);
        
        // 检查是否全部成功
        return results.All(r => r.IsSuccess);
    }
    
    // 选择配方
    public async Task<bool> SelectRecipeAsync(int recipeNumber)
    {
        var result = await _client.WriteSymbolAsync("Recipe.Selected_Recipe", recipeNumber);
        return result.IsSuccess;
    }
    
    // 启动配方
    public async Task<bool> StartRecipeAsync()
    {
        var result = await _client.WriteSymbolAsync("Recipe.Start_Command", true);
        return result.IsSuccess;
    }
}

public class RecipeData
{
    public int RecipeID { get; set; }
    public float Temperature { get; set; }
    public float Pressure { get; set; }
    public float Speed { get; set; }
    public int Duration { get; set; }
}

6.3 实际应用：数据采集系统

csharp 复制代码

public class DataAcquisitionSystem
{
    private AdsClient _client;
    private CancellationTokenSource _cancellationTokenSource;
    
    public async Task<bool> StartAsync(string amsNetId)
    {
        _client = new AdsClient();
        _cancellationTokenSource = new CancellationTokenSource();
        
        var result = await _client.ConnectAsync(amsNetId);
        if (!result.IsSuccess)
        {
            return false;
        }
        
        await _client.CreateSymbolLoaderAsync();
        
        // 启动数据采集任务
        Task.Run(() => AcquisitionLoopAsync(_cancellationTokenSource.Token));
        
        return true;
    }
    
    private async Task AcquisitionLoopAsync(CancellationToken cancellationToken)
    {
        while (!cancellationToken.IsCancellationRequested && _client.IsConnected)
        {
            try
            {
                // 采集生产数据
                var productionData = await ReadProductionDataAsync();
                
                // 保存到数据库
                await SaveToDatabaseAsync(productionData);
                
                // 等待下一个采集周期
                await Task.Delay(1000, cancellationToken);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"采集异常：{ex.Message}");
            }
        }
    }
    
    private async Task<ProductionData> ReadProductionDataAsync()
    {
        // 批量读取提高效率
        var tasks = new[]
        {
            _client.ReadSymbolAsync("MAIN.Product_Count"),
            _client.ReadSymbolAsync("MAIN.Temperature"),
            _client.ReadSymbolAsync("MAIN.Pressure"),
            _client.ReadSymbolAsync("MAIN.Speed"),
            _client.ReadSymbolAsync("MAIN.Status"),
            _client.ReadSymbolAsync("MAIN.Alarm_Code")
        };
        
        var results = await Task.WhenAll(tasks);
        
        return new ProductionData
        {
            Timestamp = DateTime.Now,
            ProductCount = Convert.ToInt32(results[0].Data),
            Temperature = Convert.ToSingle(results[1].Data),
            Pressure = Convert.ToSingle(results[2].Data),
            Speed = Convert.ToSingle(results[3].Data),
            Status = Convert.ToBoolean(results[4].Data),
            AlarmCode = Convert.ToInt32(results[5].Data)
        };
    }
    
    private async Task SaveToDatabaseAsync(ProductionData data)
    {
        // 实现数据库保存逻辑
        Console.WriteLine($"保存数据：{JsonSerializer.Serialize(data)}");
        await Task.CompletedTask;
    }
    
    public void Stop()
    {
        _cancellationTokenSource?.Cancel();
        _client?.Dispose();
    }
}

public class ProductionData
{
    public DateTime Timestamp { get; set; }
    public int ProductCount { get; set; }
    public float Temperature { get; set; }
    public float Pressure { get; set; }
    public float Speed { get; set; }
    public bool Status { get; set; }
    public int AlarmCode { get; set; }
}

7. 故障排除

7.1 常见问题与解决方案

7.1.1 连接失败

症状：ConnectAsync()返回失败

可能原因：

AMS网络ID格式错误
PLC未运行或TwinCAT未启动
网络不通
端口被占用或防火墙阻止
本地AMS ID冲突

解决方案：

csharp 复制代码

// 1. 验证AMS网络ID格式
string ValidateAmsNetId(string amsNetId)
{
    // 正确格式：192.168.1.10.1.1
    //            IP地址 . 端口 . 路由
    
    var parts = amsNetId.Split('.');
    if (parts.Length != 6)
    {
        throw new ArgumentException("AMS网络ID格式错误，应为a.b.c.d.e.f");
    }
    
    return amsNetId;
}

// 2. 检查网络连通性
using System.Net.NetworkInformation;

Ping ping = new Ping();
string ip = amsNetId.Substring(0, amsNetId.LastIndexOf('.'));
PingReply reply = await ping.SendPingAsync(ip);

if (reply.Status != IPStatus.Success)
{
    Console.WriteLine("网络不通，请检查IP地址和网络连接");
}

// 3. 尝试不同端口
for (int port = 851; port <= 867; port++)
{
    var testAmsId = $"192.168.1.10.{port}.1";
    var result = await _client.ConnectAsync(testAmsId);
    if (result.IsSuccess)
    {
        Console.WriteLine($"成功连接到端口：{port}");
        break;
    }
}

// 4. 设置本地AMS ID
_client.LocalAmsNetId = "192.168.1.100.1.1";

7.1.2 符号读取失败

症状：ReadSymbolAsync()返回失败

可能原因：

符号名称不存在
符号名称拼写错误
大小写不敏感但拼写错误
PLC程序未编译或未下载
符号访问权限不足

解决方案：

csharp 复制代码

// 1. 列出所有可用符号
await ListAllSymbolsAsync();

async Task ListAllSymbolsAsync()
{
    var result = await _client.LoadAllSymbolsAsync(flatMode: true);
    if (result.IsSuccess)
    {
        Console.WriteLine("可用的符号列表：");
        foreach (var symbol in result.Data)
        {
            Console.WriteLine($"  {symbol.Name} ({symbol.TypeName})");
        }
    }
}

// 2. 模糊搜索符号
async Task<AdsSymbolInfo?> FindSymbolByPatternAsync(string pattern)
{
    var result = await _client.LoadAllSymbolsAsync(flatMode: true);
    if (result.IsSuccess)
    {
        return result.Data.FirstOrDefault(s => 
            s.Name.IndexOf(pattern, StringComparison.OrdinalIgnoreCase) >= 0);
    }
    return null;
}

// 使用示例
var symbol = await FindSymbolByPatternAsync("Temp");
if (symbol != null)
{
    Console.WriteLine($"找到符号：{symbol.Name}");
}

// 3. 验证符号存在
async Task<bool> VerifySymbolExistsAsync(string symbolName)
{
    var result = await _client.FindSymbolAsync(symbolName);
    return result.IsSuccess;
}

7.1.3 数据类型错误

症状：读取的值类型不正确或转换失败

可能原因：

PLC数据类型与期望不符
符号大小判断错误
浮点数读取为整数导致精度丢失

解决方案：

csharp 复制代码

// 1. 检查符号信息
async Task PrintSymbolInfoAsync(string symbolName)
{
    var result = await _client.ReadSymbolInfoAsync(symbolName);
    if (result.IsSuccess)
    {
        var info = result.Data;
        Console.WriteLine($"符号名：{info.Name}");
        Console.WriteLine($"类型名：{info.TypeName}");
        Console.WriteLine($"大小：{info.Size}字节");
        Console.WriteLine($"索引组：{info.IndexGroup}");
        Console.WriteLine($"索引偏移：{info.IndexOffset}");
    }
}

// 2. 安全的类型转换
async Task<T?> SafeReadSymbolAsync<T>(string symbolName) where T : struct
{
    var result = await _client.ReadSymbolAsync(symbolName);
    if (result.IsSuccess && result.Data is T data)
    {
        return data;
    }
    return default(T);
}

// 使用示例
int? counterValue = await SafeReadSymbolAsync<int>("MAIN.Counter");
if (counterValue.HasValue)
{
    Console.WriteLine($"计数器值：{counterValue.Value}");
}

// 3. 处理REAL/LREAL类型
async Task<float?> ReadRealAsync(string symbolName)
{
    var result = await _client.ReadSymbolAsync(symbolName);
    if (result.IsSuccess)
    {
        // 自动处理REAL和LREAL类型
        if (result.Data is float f)
            return f;
        if (result.Data is double d)
            return (float)d;
    }
    return null;
}

7.1.4 平铺模式加载慢或卡死

症状：LoadAllSymbolsAsync(flatMode: true)响应慢或无响应

可能原因：

符号数量过多
网络延迟
符号信息复杂

解决方案：

csharp 复制代码

// 1. 使用树形模式（推荐）
var result = await _client.LoadAllSymbolsAsync(flatMode: false);

// 2. 分批加载符号
async Task<List<AdsSymbolInfo>> LoadSymbolsInBatchesAsync()
{
    var allSymbols = new List<AdsSymbolInfo>();
    
    // 先加载根符号
    var rootResult = await _client.LoadAllSymbolsAsync(flatMode: false);
    if (rootResult.IsSuccess)
    {
        allSymbols.AddRange(rootResult.Data);
        
        // 根据需要逐个展开子符号
        foreach (var rootSymbol in rootResult.Data)
        {
            // 只加载需要的分支
            if (ShouldExpand(rootSymbol.Name))
            {
                var children = await LoadChildSymbolsAsync(rootSymbol);
                allSymbols.AddRange(children);
            }
        }
    }
    
    return allSymbols;
}

// 3. 使用超时控制
async Task<AdsResult<List<AdsSymbolInfo>>> LoadWithTimeoutAsync()
{
    var timeoutTask = Task.Delay(5000);  // 5秒超时
    var loadTask = _client.LoadAllSymbolsAsync(flatMode: true);
    
    var completedTask = await Task.WhenAny(timeoutTask, loadTask);
    
    if (completedTask == timeoutTask)
    {
        Console.WriteLine("加载超时，符号过多");
        return AdsResult<List<AdsSymbolInfo>>.CreateFail("加载超时");
    }
    
    return await loadTask;
}

7.2 性能优化

7.2.1 批量读写优化

csharp 复制代码

// 不好的做法：多次单独读取
for (int i = 0; i < 100; i++)
{
    await _client.ReadSymbolAsync($"MAIN.Array[{i}]");
}

// 好的做法：使用索引批量读取
// 假设数组是连续的，可以通过索引读取整个数组
async Task<short[]> ReadArrayAsync(string arrayName, int length)
{
    // 先获取数组的索引信息
    var firstElement = await _client.ReadSymbolInfoAsync($"{arrayName}[0]");
    
    if (firstElement.IsSuccess)
    {
        var info = firstElement.Data;
        
        // 批量读取整个数组
        var result = await _client.ReadByIndexAsync(
            info.IndexGroup,
            info.IndexOffset,
            length * 2  // 每个元素2字节（INT类型）
        );
        
        if (result.IsSuccess)
        {
            // 转换为数组
            return Enumerable.Range(0, length)
                .Select(i => BitConverter.ToInt16(result.Data, i * 2))
                .ToArray();
        }
    }
    
    return Array.Empty<short>();
}

7.2.2 采集频率优化

csharp 复制代码

// 根据数据变化频率设置不同的采集周期
public class SmartDataCollector
{
    private Dictionary<string, int> _collectionIntervals;
    
    public SmartDataCollector()
    {
        _collectionIntervals = new Dictionary<string, int>
        {
            ["FAST_DATA"] = 100,      // 快速数据：100ms
            ["NORMAL_DATA"] = 1000,   // 普通数据：1秒
            ["SLOW_DATA"] = 5000      // 慢速数据：5秒
        };
    }
    
    public async Task StartSmartCollectionAsync()
    {
        // 为不同类型的数据创建不同的采集任务
        var fastTimer = new Timer(async _ => 
            await CollectDataAsync("FAST_DATA"), null, 0, 100);
        
        var normalTimer = new Timer(async _ => 
            await CollectDataAsync("NORMAL_DATA"), null, 0, 1000);
        
        var slowTimer = new Timer(async _ => 
            await CollectDataAsync("SLOW_DATA"), null, 0, 5000);
    }
    
    private async Task CollectDataAsync(string category)
    {
        // 根据类别采集相应的数据
        // ...
    }
}

7.2.3 符号缓存策略

csharp 复制代码

public class SymbolCache
{
    private Dictionary<string, AdsSymbolInfo> _symbolCache;
    private AdsClient _client;
    
    public SymbolCache(AdsClient client)
    {
        _client = client;
        _symbolCache = new Dictionary<string, AdsSymbolInfo>();
    }
    
    public async Task<AdsSymbolInfo?> GetSymbolAsync(string symbolName)
    {
        // 检查缓存
        if (_symbolCache.TryGetValue(symbolName, out var cachedSymbol))
        {
            return cachedSymbol;
        }
        
        // 缓存未命中，从PLC读取
        var result = await _client.ReadSymbolInfoAsync(symbolName);
        if (result.IsSuccess)
        {
            _symbolCache[symbolName] = result.Data;
            return result.Data;
        }
        
        return null;
    }
    
    public void ClearCache()
    {
        _symbolCache.Clear();
    }
}

8. 总结

倍福ADS通讯协议是专用于TwinCAT PLC系统的高效通讯方案，提供了符号级别的数据访问能力，极大简化了PLC数据交互。

关键要点：

AMS寻址：通过AMS网络ID精确定位PLC和端口
符号访问：支持直接通过变量名访问PLC数据
索引访问：提供高效的索引组/索引偏移访问方式
类型映射：智能的PLC类型到C#类型映射
双模式加载：树形模式和平铺模式满足不同需求
事件机制：连接状态和符号值变化事件通知

GKMLT通讯工具箱（WPF MVVM) - 07-倍福ADS通讯

目录

1. 通讯协议概述

1.1 倍福ADS通讯简介

1.2 主要特点

1.3 AMS地址结构

2. 协议栈结构

2.1 分层架构

2.2 AMS路由机制

2.3 ADS数据类型映射

3. 报文格式详解

3.1 AMS报文头结构

3.2 ADS报文结构

3.3 ADS命令码

3.4 索引组（Index Group）定义

3.5 读取请求报文格式

3.6 写入请求报文格式

4. 通讯原理

4.1 连接建立过程

4.2 符号访问流程

4.3 符号加载机制

5. 调用方法与API

5.1 AdsClient类主要属性

5.2 连接管理API

5.2.1 建立连接

5.2.2 断开连接

5.3 符号管理API

5.3.1 加载符号（树形模式）

5.3.2 加载符号（平铺模式）

5.3.3 查找符号

5.3.4 读取符号信息

5.4 数据读取API

5.4.1 按符号名读取

5.4.2 按索引读取

5.5 数据写入API

5.5.1 按符号名写入

5.5.2 按索引写入

5.6 事件订阅

5.7 统计信息

6. 实际应用示例

6.1 基础应用：PLC数据监控

6.2 高级应用：配方管理系统

6.3 实际应用：数据采集系统

7. 故障排除

7.1 常见问题与解决方案

7.1.1 连接失败

7.1.2 符号读取失败

7.1.3 数据类型错误

7.1.4 平铺模式加载慢或卡死

7.2 性能优化

7.2.1 批量读写优化

7.2.2 采集频率优化

7.2.3 符号缓存策略

8. 总结

关键要点：