ABB PC SDK 开发指南：机器人编程控制

ABB PC SDK 开发指南：机器人编程控制 | 极客日志

RobotController

目录名称	功能描述
`\bin`	存放所有编译后的 DLL 核心库文件，如 `ABB.Robotics.Controllers.dll`, `ABB.Robotics.Math.dll` 等
`\doc`	包含 CHM 格式的帮助文档和 API 参考手册
`\examples`	提供多种 C# 示例项目，覆盖连接管理、运动控制、信号读写等场景
`\redist`	第三方再发行组件，如特定版本的 VC++ 运行库
`\tools`	辅助工具，如证书管理器、日志查看器等

// 示例：引用核心命名空间
using ABB.Robotics.Controllers;
using ABB.Robotics.Controllers.Discovery;

gacutil -l | findstr "ABB"

SDK 版本	推荐 .NET Framework	支持的 Visual Studio 版本	是否支持 .NET Core/.NET 5+
v5.x	4.0 ~ 4.5	VS 2010 ~ 2015	否
v6.0	4.6.1	VS 2015 Update 3 ~ 2017	否
v6.1+	4.7.2	VS 2017 ~ 2022	部分支持（需适配包装层）

<!-- 在 .csproj 文件中声明 -->
<PropertyGroup>
    <TargetFrameworkVersion>v4.7.2</TargetFrameworkVersion>
</PropertyGroup>

graph TD
A[用户选择 SDK 版本] --> B{是否 >= v6.1?}
B -- 是 --> C[安装 .NET Framework 4.7.2+]
B -- 否 --> D[安装 .NET Framework 4.6.1]
C --> E[选择 VS 2017 或更新版本]
D --> F[选择 VS 2015 或兼容版本]
E --> G[创建新项目并设置 TargetFramework]
F --> G
G --> H[添加 SDK DLL 引用]

$sdkPath = "C:\Program Files\ABB\PC SDK\bin"
$currentPath = [Environment]::GetEnvironmentVariable("PATH", "Machine")
if ($currentPath -notlike "*$sdkPath*") {
    [Environment]::SetEnvironmentVariable("PATH", "$currentPath;$sdkPath", "Machine")
    Write-Host "SDK 路径已添加至系统 PATH"
} else {
    Write-Host "SDK 路径已在 PATH 中"
}

regasm ABB.Robotics.Controllers.dll /tlb

<!-- 在项目属性中启用本地调试符号 -->
<PropertyGroup>
    <DebugSymbols>true</DebugSymbols>
    <DebugType>full</DebugType>
</PropertyGroup>

<PackageReference Include="ABB.PC.SDK" Version="6.1.3" />

try {
    var controller = RobotController.CreateFromIPAddress("192.168.125.1", 6510);
    Console.WriteLine("控制器连接成功");
} catch (DllNotFoundException ex) {
    Console.WriteLine($"缺少依赖库：{ex.Message}");
} catch (TypeInitializationException ex) {
    Console.WriteLine($"类型初始化失败：{ex.InnerException?.Message}");
}

<ItemGroup>
    <Content Include="..\ABB SDK\bin\*.dll">
        <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </Content>
</ItemGroup>

AppDomain.CurrentDomain.AssemblyResolve += (sender, args) => {
    string assemblyPath = Path.Combine(sdkBinPath, new AssemblyName(args.Name).Name + ".dll");
    return File.Exists(assemblyPath) ? Assembly.LoadFrom(assemblyPath) : null;
};

设备	IP 地址	子网掩码	默认网关
PC 主机	192.168.125.10	255.255.255.0	192.168.125.1
IRC5 控制器	192.168.125.1	255.255.255.0	192.168.125.1

ping 192.168.125.1

telnet 192.168.125.1 6510

New-NetFirewallRule -DisplayName "Allow ABB SDK Port 6510" `
 -Direction Outbound `
 -Protocol TCP `
 -RemotePort 6510 `
 -Action Allow

TASK T_ROB1 PERS COMMUNICATION_ACCESS pc_access := ENABLED; ENDTASK

var ep = new IPEndPoint(IPAddress.Parse("192.168.125.1"), 6510);
using (var client = new TcpClient()) {
    try {
        await client.ConnectAsync(ep.Address, ep.Port);
        Console.WriteLine("TCP 连接成功");
    } catch (Exception ex) {
        Console.WriteLine($"连接失败：{ex.Message}");
    }
}

属性名称	数据类型	描述
`Name`	string	控制器名称，通常与硬件标签一致，便于识别
`IpAddress`	string	当前连接的控制器 IP 地址
`State`	ControllerState	枚举值，表示控制器运行状态（Running, Stopped, Motors Off 等）
`Model`	string	控制器型号（如 IRC5 Compact）
`SwVersion`	string	RobotWare 版本号
`Tasks`	TaskCollection	所有 RAPID 任务的集合，支持遍历和调用
`Identity`	Identity	包含序列号、制造商等唯一标识信息

robotController.StateChanged += (sender, args) => {
    Console.WriteLine($"Controller state changed from {args.OldValue} to {args.NewValue}");
};

classDiagram
class RobotController {
    +string Name
    +string IpAddress
    +ControllerState State
    +string Model
    +string SwVersion
    +TaskCollection Tasks
    +Identity Identity
    +Connect() void
    +Disconnect() void
    +Login(UserInfo) void
}
class TaskCollection {
    +IEnumerable<Task> Items
    +Task this[string name]
}
class ControllerState {
    <<enumeration>>
    MotorsOff
    MotorsOn
    AutoMode
    ManualMode
    Stopped
}
RobotController --> TaskCollection : contains
RobotController --> ControllerState : reflects

using ABB.Robotics.Controllers;
using ABB.Robotics.Controllers.Discovery;

// 发现局域网内可用控制器（可选）
var controllerFinder = new ControllerFinder();
var controllers = controllerFinder.Find();

// 选择第一个控制器
RobotController robotController = controllers[0];

try {
    // 建立连接
    robotController.Connect();
    if (robotController.IsConnected) {
        Console.WriteLine($"Successfully connected to {robotController.Name}");
        Console.WriteLine($"Current state: {robotController.State}");
    }
} catch (ConnectionException ex) {
    Console.WriteLine($"Connection failed: {ex.Message}");
} finally {
    // 断开连接并释放资源
    if (robotController.IsConnected) {
        robotController.Disconnect();
    }
}

var robotController = new RobotController("192.168.12.100");

// 设置连接超时时间为 5 秒
var connectionParams = new ConnectionParams {
    Timeout = TimeSpan.FromSeconds(5),
    RetryCount = 3
};

try {
    await robotController.ConnectAsync(connectionParams);
    Console.WriteLine("Async connection established.");
} catch (TimeoutException) {
    Console.WriteLine("Connection timed out after 5 seconds.");
} catch (ConnectionException ex) {
    Console.WriteLine($"Failed to connect: {ex.InnerException?.Message}");
}

参数	类型	作用
`Timeout`	TimeSpan	单次连接尝试的最大等待时间
`RetryCount`	int	失败后重试次数，适用于短暂网络抖动场景
`UseSsl`	bool	是否启用加密通信（需 RobotWare 支持）

stateDiagram-v2
[*] --> Idle
Idle --> Connecting: ConnectAsync()
Connecting --> Connected: Success within Timeout
Connecting --> Retrying: Failure & RetryCount > 0
Retrying --> Connecting: Decrement RetryCount
Connecting --> Failed: Final failure
Failed --> [*]
Connected --> [*]: Disconnect()

public class MultiRobotManager : IDisposable {
    private readonly Dictionary<string, RobotController> _controllers;
    private readonly object _lock = new object();

    public MultiRobotManager() {
        _controllers = new Dictionary<string, RobotController>();
    }

    public async Task<bool> AddControllerAsync(string name, string ip) {
        var controller = new RobotController(ip) { Name = name };
        try {
            await controller.ConnectAsync(new ConnectionParams { Timeout = TimeSpan.FromSeconds(3) });
            lock (_lock) {
                _controllers[name] = controller;
            }
            Console.WriteLine($"✅ Connected to robot: {name} ({ip})");
            return true;
        } catch {
            Console.WriteLine($"❌ Failed to connect to {name}");
            return false;
        }
    }

    public RobotController GetController(string name) {
        lock (_lock) {
            return _controllers.TryGetValue(name, out var ctrl) ? ctrl : null;
        }
    }

    public void Dispose() {
        foreach (var kv in _controllers) {
            if (kv.Value.IsConnected) kv.Value.Disconnect();
            kv.Value.Dispose();
        }
        _controllers.Clear();
    }
}

var manager = new MultiRobotManager();
await manager.AddControllerAsync("LoaderBot", "192.168.12.100");
await manager.AddControllerAsync("AssemblyBot", "192.168.12.101");
var loader = manager.GetController("LoaderBot");
if (loader?.State == ControllerState.MotorsOn) {
    // 执行动作...
}

private async Task StartHealthCheck(RobotController ctrl, TimeSpan interval) {
    while (true) {
        try {
            if (!ctrl.IsConnected || ctrl.State == ControllerState.Unknown) {
                Console.WriteLine($"⚠️ Connection lost for {ctrl.Name}, attempting reconnect...");
                await ctrl.DisconnectAsync();
                await Task.Delay(2000); // 避免频繁重连
                await ctrl.ConnectAsync(new ConnectionParams { Timeout = TimeSpan.FromSeconds(5) });
                if (ctrl.IsConnected) {
                    Console.WriteLine($"🔁 Reconnected to {ctrl.Name}");
                }
            }
        } catch (Exception ex) {
            Console.WriteLine($"Reconnect error: {ex.Message}");
        }
        await Task.Delay(interval);
    }
}

foreach (var ctrl in manager._controllers.Values) {
    _ = StartHealthCheck(ctrl, TimeSpan.FromSeconds(10));
}

AppDomain.CurrentDomain.UnhandledException += (sender, args) => {
    manager?.Dispose(); // 兜底释放
    Environment.Exit(1);
};

var userInfo = new UserInfo { UserName = "Operator", Password = "robotics123" };
try {
    robotController.Login(userInfo);
    Console.WriteLine("🔐 Authentication successful.");
} catch (AuthorizationException) {
    Console.WriteLine("❌ Invalid credentials or insufficient privileges.");
}

操作	所需权限
读取当前坐标	Default User
启动 RAPID 程序	Operator
修改 RobTarget 数据	Maintenance
下载新模块	Maintenance
格式化硬盘	Administrator

private async Task KeepSessionAlive(RobotController ctrl, string user, string pwd) {
    while (true) {
        await Task.Delay(TimeSpan.FromMinutes(25)); // 每 25 分钟重新登录
        try {
            if (ctrl.IsConnected) {
                ctrl.Logout();
                ctrl.Login(new UserInfo { UserName = user, Password = pwd });
                Console.WriteLine($"🔄 Session renewed for {ctrl.Name}");
            }
        } catch {
            /* 忽略，下次再试 */
        }
    }
}

坐标系类型	描述	应用场景
世界坐标系	全局静止参考系	多机器人协同、视觉系统集成
基座坐标系	机器人本体原点	内部运动解算基础
工具坐标系	TCP 定义点	精确轨迹控制、力控操作
工件坐标系	零件相对坐标	路径编程简化、批量生产

graph TD
A[世界坐标系] --> B[基座坐标系]
B --> C[工具坐标系]
C --> D[TCP 位置输出]
A --> E[工件坐标系]
E --> F[目标路径定义]
F --> G[逆运动学求解]
G --> H[关节指令生成]

// 示例代码：定义两个目标点并选择不同运动模式
var target1 = new RobTarget(
    new Pos(0, 0, 300), // X=0, Y=0, Z=300 mm
    new Orient(1, 0, 0, 0), // 默认姿态
    new RobotCfg(), // 机器人配置
    new ExtAxis() // 外部轴数据
);
var target2 = new RobTarget(
    new Pos(200, 100, 300),
    new Orient(1, 0, 0, 0),
    new RobotCfg(),
    new ExtAxis()
);

// 使用 MoveJ —— 关节空间运动
motionGroup.MoveJ(target1, speedData, zoneData);
Thread.Sleep(1000);
motionGroup.MoveJ(target2, speedData, zoneData);
// 可能不是直线

// 使用 MoveL —— 笛卡尔空间运动
motionGroup.MoveL(target1, speedData, zoneData);
Thread.Sleep(1000);
motionGroup.MoveL(target2, speedData, zoneData);
// 强制直线路径

参数	含义	影响
SpeedData	运动速度设定（mm/s 或 deg/s）	决定最大进给速率
ZoneData	转弯区大小（fine, z1-z100）	控制路径逼近精度与连续性
AccSet	加速度百分比设置	影响启停柔顺性
RampIn/RampOut	斜坡过渡时间	减少冲击振动

SpeedData speedData = SpeedData.FromVelocity(200); // 200 mm/s
ZoneData zoneData = ZoneData.Z50; // 中等精度转弯区
AccSet accSet = new AccSet(80, 80); // 加速/减速均为 80%
robotController.MotionSystem.ActiveSpeed = speedData;
robotController.MotionSystem.SetAcceleration(accSet);

sequenceDiagram
participant User as 用户程序
participant SDK as PC SDK
participant Controller as IRC5 控制器
participant Trajectory as 轨迹发生器
User->>SDK: 发送 MoveL(RobTarget)
SDK->>Controller: 序列化请求并发送
Controller->>Trajectory: 解析目标点 + 速度/区域参数
Trajectory->>Trajectory: 执行逆运动学求解
Trajectory->>Trajectory: 生成 4ms 周期插补点
Trajectory->>Servo: 下发关节角度指令
Servo->>Motor: 驱动电机运行

RAPID 指令	SDK 对应方法	功能描述
MoveJ	`IMotionGroup.MoveJ()`	快速关节运动
MoveL	`IMotionGroup.MoveL()`	直线插补运动
MoveC	`IMotionGroup.MoveC()`	圆弧插补运动
WaitTime	`ITask.WaitTime()`	延时等待

// 获取主运动组（通常是"MotionGroupe0"）
IMotionGroup motionGroup = robotController.MotionSystem.ActiveMotionGroup;

// 执行 MoveJ 指令
motionGroup.MoveJ(target, speedData, zoneData);

// 定义工件坐标系引用
WorkObject wobj = WorkObject.New("wobj1");
wobj.Origin = new Pos(100, 50, 0);
wobj.Orientation = new Orient(1, 0, 0, 0);

// 在 RobTarget 中关联工件坐标系
RobTarget targetWithWObj = new RobTarget(
    new Pos(0, 0, 200),
    new Orient(1, 0, 0, 0),
    new RobotCfg(),
    new ExtAxis(),
    wobj // 显式绑定工件坐标系
);

public RobTarget(Pos pos, Orient orient, RobotL redbot, ExtJoint extax, WorkObject wobj = null)

参数	类型	说明
`pos`	`Pos`	TCP 在工件坐标系中的 XYZ 坐标（单位：mm）
`orient`	`Orient`	四元数表示的姿态（qw, qx, qy, qz）
`redbot`	`RobotL`	机器人配置标志（如左右手、肘部前后、翻转状态）
`extax`	`ExtJoint`	外部轴角度（E1-E6）
`wobj`	`WorkObject`	所属工件坐标系（可选）

public static RobTarget CreateTarget(double x, double y, double z, double rx, double ry, double rz, string wobjName = "default") {
    // 四元数转换（欧拉角 → 四元数）
    var quat = EulerToQuaternion(rx, ry, rz);
    var pos = new Pos(x, y, z);
    var orient = new Orient(quat.W, quat.X, quat.Y, quat.Z);
    var robotConfig = new RobotL(); // 自动求解配置
    var extAxes = new ExtJoint(0, 0, 0, 0, 0, 0);
    var wobj = WorkObject.Get(wobjName); // 从缓存获取
    return new RobTarget(pos, orient, robotConfig, extAxes, wobj);
}

private static Quaternion EulerToQuaternion(double rx, double ry, double rz) {
    double cx = Math.Cos(rx * 0.5);
    double sx = Math.Sin(rx * 0.5);
    double cy = Math.Cos(ry * 0.5);
    double sy = Math.Sin(ry * 0.5);
    double cz = Math.Cos(rz * 0.5);
    double sz = Math.Sin(rz * 0.5);
    return new Quaternion { W = cx * cy * cz + sx * sy * sz, X = sx * cy * cz - cx * sy * sz, Y = cx * sy * cz + sx * cy * sz, Z = cx * cy * sz - sx * sy * cz };
}

// 方式一：基于速度值
SpeedData speedFast = SpeedData.FromVelocity(500); // 500 mm/s
SpeedData speedPrecise = SpeedData.FromVelocity(50); // 50 mm/s

// 方式二：完整自定义
SpeedData customSpeed = new SpeedData(
    v_tcp: 300, // TCP 线速度
    v_ori: 30, // 姿态变化速度 (deg/s)
    v_leax: 200, // 外部线性轴速度
    v_reax: 100 // 外部旋转轴速度
);

ZoneData	允许偏差	应用场景
fine	0 mm	精确定位、点胶起始点
z1	~1 mm	高精度焊接
z10	~10 mm	搬运过渡点
z100	~100 mm	高速空行程

ZoneData preciseZone = ZoneData.Create(0.3, 0.3, 0.03); // 自定义精细区

// 设置加速度为默认值的 60%
robotController.MotionSystem.SetAcceleration(new AccSet(60, 60));

// 恢复默认
robotController.MotionSystem.SetAcceleration(AccSet.Default);

pie title 运动参数组合推荐
    "高速搬运" : 35
    "精密定位" : 25
    "连续轨迹" : 30
    "避障机动" : 10

// 示例：检测到障碍后绕行
List<RobTarget> waypoints = GenerateDetourPath(currentPosition, obstaclePos);
foreach (var wp in waypoints) {
    try {
        motionGroup.MoveL(wp, slowSpeed, fineZone);
        Thread.Sleep(50); // 留出执行时间
    } catch (ExecutionException ex) {
        Log.Error($"路径执行失败：{ex.Message}");
        break;
    }
}

// 假设每 100ms 接收一次修正量
Timer sensorTimer = new Timer(async _ => {
    var correction = await GetVisionOffset(); // 获取Δx, Δy, Δz
    AdjustCurrentTarget(correction);
}, null, 0, 100);

void AdjustCurrentTarget(Pos delta) {
    currentTarget.Pos.X += delta.X;
    currentTarget.Pos.Y += delta.Y;
    currentTarget.Pos.Z += delta.Z;
    // 触发微调运动
    motionGroup.MoveL(currentTarget, fineSpeed, fineZone);
}

// 使用 MultiMove 功能（需控制器支持）
using (var multiMove = new MultiMoveSession(robotControllers)) {
    multiMove.Add(motionGroup1, target1);
    multiMove.Add(motionGroup2, target2);
    multiMove.StartSynchronized();
}

gantt title 多机器人同步运动时序
dateFormat HH:mm:ss
section 机器人 A
MoveL 到点 1 :a1, 00:00:00, 2s
MoveL 到点 2 :a2, after a1, 2s
section 机器人 B
MoveL 到点 1 :b1, 00:00:00, 2s
MoveL 到点 2 :b2, after b1, 2s

using ABB.Robotics.Controllers;
using ABB.Robotics.Controllers.IO;

// 假设已建立连接的 RobotController 实例
RobotController controller = RobotController.GetInstance();

// 获取 IO 系统服务
IoDomain ioSystem = controller.IoSystem;

// 获取名为'DO_VisionTrigger'的数字输出信号
Signal doSignal = ioSystem.GetSignal("DO_VisionTrigger");

// 写入高电平（True 表示 ON）
doSignal.Value = true;

// 读取当前信号值
bool currentValue = (bool)doSignal.Value;

信号类型	数据类型	典型用途	示例信号名
数字输入（DI）	bool	检测传感器状态	DI_SensorReady
数字输出（DO）	bool	控制气缸、灯光	DO_GripperOpen
模拟输入（AI）	double	接收压力/温度值	AI_PressureValue
模拟输出（AO）	double	调节变频器速度	AO_SpeedRef

graph TD
A[PC Application] --> B{Connect to Controller}
B --> C[Retrieve IoSystem Service]
C --> D[Get Signal by Name]
D --> E{Is Signal Valid?}
E -->|Yes| F[Read/Write Value]
E -->|No| G[Throw Exception]
F --> H[Synchronize with Hardware]

// 获取信号对象
Signal sensorReady = controller.IoSystem.GetSignal("DI_SensorReady");

// 注册事件处理器
sensorReady.SignalValueChanged += OnSensorStateChanged;

// 回调函数定义
private void OnSensorStateChanged(object sender, ValueChangedEventArgs e) {
    Signal sig = (Signal)sender;
    bool newValue = (bool)e.NewValue;
    Console.WriteLine($"[{DateTime.Now}] Signal {sig.Name} changed to {newValue}");
    if (newValue && IsRobotIdle()) {
        StartPickOperation();
    }
}

sensorReady.SignalValueChanged -= OnSensorStateChanged;

特性	周期性轮询	事件驱动
实时性	中等（受限于扫描周期）	高（接近硬件响应速度）
CPU 占用率	持续消耗（定时器循环）	动态波动（仅事件发生时）
编程复杂度	简单直观	需处理异步回调线程安全
可靠性	易遗漏瞬时信号	可捕获每一个变化
适用场景	批量状态采集、非关键信号	安全联锁、触发信号

// 后台轮询任务示例
Task.Run(async () => {
    while (isRunning) {
        try {
            var statusLight = (bool)controller.IoSystem.GetSignal("DO_StatusLight").Value;
            UpdateUiIndicator(statusLight);
            await Task.Delay(500); // 半秒刷新一次 UI
        } catch (Exception ex) {
            LogError(ex.Message);
        }
    }
});

public async Task<bool> RequestCycleStart() {
    var requestSig = controller.IoSystem.GetSignal("DO_RequestStart");
    var permitSig = controller.IoSystem.GetSignal("DI_RunPermit");
    requestSig.Value = true;
    DateTime startTime = DateTime.Now;
    while ((bool)permitSig.Value == false) {
        if ((DateTime.Now - startTime).TotalSeconds > 5) {
            requestSig.Value = false;
            return false; // 超时未响应
        }
        await Task.Delay(50);
    }
    return true; // 成功获得许可
}

var estopSignal = controller.IoSystem.GetSignal("DI_EStop");
estopSignal.SignalValueChanged += (s, e) => {
    if ((bool)e.NewValue == false) // 断开即触发
    {
        EmergencyStopAllMotors();
        SetSystemState(SafetyState.EStopped);
        PlayAlarmSound();
    }
};

// 在 MoveJ 指令发出后启动延时任务
Task.Delay(800).ContinueWith(_ => {
    controller.IoSystem.GetSignal("DO_GripperOpen").Value = true;
});

stateDiagram-v2
[*] --> Idle
Idle --> WaitingForWorkpiece : DI_WorkPresent == true
WaitingForWorkpiece --> Gripping : DO_GrabCommand == true
Gripping --> MovingToProcess : MotorPower On
MovingToProcess --> Processing : Reach Target
Processing --> Releasing : ProcessComplete
Releasing --> Idle : DO_GripperClosed == true

// 在运动指令后插入触发逻辑
motionGroup.MoveL(previewTarget);
Task.Delay(150).Wait(); // 等待接近目标
controller.IoSystem.GetSignal("DO_CameraTrigger").Value = true;
Task.Delay(30).Wait(); // 维持高电平 30ms
controller.IoSystem.GetSignal("DO_CameraTrigger").Value = false;

// 收到视觉就绪信号后读取坐标
if ((bool)ioSystem.GetSignal("DI_VisionReady").Value) {
    double[] offset = ReceiveOffsetFromVisionServer();
    UpdateWorkObjectOffset("WObj_Calibrated", offset[0], offset[1], 0);
}

// 模拟高速信号捕获（实际需搭配专用驱动）
highSpeedReader.OnRisingEdge += () => {
    var robotPos = GetCurrentRobTarget();
    LogPositionAtTimestamp(robotPos, DateTime.Now);
    TriggerLaserPulse();
};

模块	功能职责	所用 SDK 组件
机器人控制模块	建立连接、运动控制、状态监控	`RobotController`, `Motion`
I/O 通信模块	读写数字信号、触发相机、接收 PLC 状态	`Signal`, `IoDomain`
数据交换模块	接收视觉数据、传递坐标修正值	`DataExchange`, TCP Socket
状态管理模块	实现系统运行状态机（待机、运行、暂停、故障）	自定义 State Pattern
日志与诊断模块	记录操作日志、异常堆栈、性能指标	`EventLog`, 自定义 Logger

stateDiagram-v2
[*] --> Idle
Idle --> Running: StartCommand
Running --> Paused: PauseSignal
Paused --> Running: ResumeCommand
Running --> Fault: ErrorCode != 0
Fault --> Recovering: AcknowledgeFault
Recovering --> Idle: RecoverySuccess
Fault --> Shutdown: CriticalFailure

public class RobotControllerManager {
    private RobotController _controller;
    private Signal _startSignal, _stopSignal, _autoModeSignal;
    private CancellationTokenSource _cts;

    public async Task InitializeAsync(string ipAddress) {
        // 创建控制器实例
        _controller = new RobotController(ipAddress);
        // 设置连接超时时间为 10 秒
        _controller.ConnectionTimeout = TimeSpan.FromSeconds(10);
        try {
            await _controller.ConnectAsync();
            Console.WriteLine("机器人连接成功");
            // 获取 I/O 信号对象
            var ioSystem = _controller.GetIoSystem();
            _startSignal = ioSystem.GetSignal("DI_Start");
            _stopSignal = ioSystem.GetSignal("DI_Stop");
            _autoModeSignal = ioSystem.GetSignal("DI_AutoMode");
            // 订阅启动信号上升沿
            _startSignal.RisingEdge += OnStartSignalReceived;
            _stopSignal.FallingEdge += OnStopSignalReceived;
            // 启动状态监听任务
            _cts = new CancellationTokenSource();
            _ = Task.Run(MonitorRobotState, _cts.Token);
        } catch (Exception ex) {
            LogError($"连接失败：{ex.Message}");
            throw;
        }
    }

    private void OnStartSignalReceived(object sender, SignalRoutedEventArgs e) {
        if (_autoModeSignal.DigitalValue == 1) // 判断是否处于自动模式
        {
            _controller.Motion.Start(); // 启动 RAPID 程序
            LogInfo("机器人启动命令已发送");
        }
    }

    private void OnStopSignalReceived(object sender, SignalRoutedEventArgs e) {
        _controller.Motion.Stop(MotionStop.Circular);
        LogInfo("机器人停止命令已发送");
    }

    private async Task MonitorRobotState() {
        while (!_cts.Token.IsCancellationRequested) {
            try {
                var state = await _controller.GetExecutionStatusAsync();
                UpdateUiStatus(state); // 更新 UI 界面状态
                await Task.Delay(500, _cts.Token); // 每 500ms 检查一次
            } catch (OperationFailedException ofEx) {
                LogError($"状态获取失败：{ofEx.ErrorCode}");
                HandleErrorCode(ofEx.ErrorCode);
            }
        }
    }
}

// 定义与 RAPID 程序中一致的结构体
[DataContract]
public class WorkpieceOffset {
    [DataMember]
    public double X { get; set; }
    [DataMember]
    public double Y { get; set; }
    [DataMember]
    public double Z { get; set; }
}

// 在 PC 端发送偏移数据
var dataExchange = _controller.GetDataExchange();
var offset = new WorkpieceOffset { X = 2.3, Y = -1.8, Z = 0.5 };
await dataExchange.WriteAsync("pc_to_robot_offset", offset);
Console.WriteLine("视觉偏移数据已发送至机器人");

PERS struct pc_to_robot_offset := [x:=0,y:=0,z:=0];

public static class Logger {
    public static void LogInfo(string message) {
        WriteLog("INFO", message);
    }

    public static void LogError(string message) {
        WriteLog("ERROR", message);
    }

    private static void WriteLog(string level, string msg) {
        var logEntry = $"{DateTime.Now:yyyy-MM-dd HH:mm:ss} [{level}] {msg}";
        File.AppendAllText("robot_control.log", logEntry + Environment.NewLine);
        // 可扩展：发送至远程日志服务器或数据库
    }
}

错误码	含义	处理建议
1001	连接超时	重试 3 次，间隔 2s，失败则告警
1005	权限不足	检查用户登录凭证与 RAPID 权限设置
2003	目标点不可达	调整路径或检查机械干涉
3007	I/O 信号未定义	核对信号名称拼写与 IO 配置表
4012	DataExchange 变量不存在	确保 RAPID 侧已声明同名变量

var sw = Stopwatch.StartNew();
await _controller.Motion.MoveL(target, speed, zone);
sw.Stop();
if (sw.ElapsedMilliseconds > 200) LogWarning($"MoveL 执行过慢：{sw.ElapsedMilliseconds}ms");

{
    "Robot": {
        "IpAddress": "192.168.1.20",
        "UserName": "Default User",
        "Password": "robot"
    },
    "Signals": {
        "Start": "DI_Start",
        "CameraTrigger": "DO_CamTrig"
    }
}

ABB PC SDK 开发指南：机器人编程控制

ABB PC SDK 概述与应用场景

1. ABB PC SDK 核心定位与技术架构

2. 开发环境搭建与配置（Windows 平台）

2.1 ABB PC SDK 的安装流程与组件解析

2.1.1 SDK 安装包结构与核心库文件说明

2.1.2 .NET Framework 与 Visual Studio 版本兼容性要求

2.1.3 环境变量设置与依赖项注册

关键环境变量

2.2 Windows 平台下的开发工具链配置

2.2.1 Visual Studio 集成开发环境配置指南

2.2.2 C# 项目创建与 SDK 引用方式

方式一：直接文件引用（推荐用于生产环境）

方式二：通过 NuGet 包管理（未来趋势）

2.2.3 动态链接库（DLL）加载机制与路径管理

2.3 网络通信准备与机器人控制器连接前置条件

2.3.1 控制器 IP 地址配置与网络连通性测试

2.3.2 防火墙策略调整与端口开放建议

2.3.3 RAPID 运行模式与 PC 通信权限设置

3. RobotController 类的使用与机器人连接管理

3.1 RobotController 类的核心功能与对象模型

3.1.1 类结构解析与主要属性介绍

对象模型关系图（Mermaid）

3.1.2 Connect、Disconnect 方法调用逻辑

典型连接流程代码示例：

逐行逻辑分析：

3.1.3 异步连接机制与超时处理策略

异步连接与超时配置示例：

参数说明：

异步连接状态机（Mermaid 流程图）：

3.2 多机器人系统中的控制器实例管理

3.2.1 多实例并发连接的设计模式

示例：多机器人连接管理器

使用方式：

逻辑分析：

3.2.2 连接状态监控与自动重连机制实现

定时轮询与事件回调结合方案：

3.2.3 资源释放与异常断开后的清理操作

推荐做法：

3.3 用户权限认证与安全连接实践

3.3.1 登录凭证配置与身份验证流程

示例代码：

3.3.2 操作权限分级控制在 SDK 中的体现

3.3.3 安全会话生命周期管理

自动续期机制：

4. Motion 模块路径规划与运动控制实现

4.1 运动控制基础理论与坐标系理解

4.1.1 ABB 机器人坐标系统（世界、基座、工具、工件）

4.1.2 关节空间与笛卡尔空间运动差异分析

4.1.3 路径插补原理与轨迹生成机制

4.2 Motion 指令在 PC SDK 中的封装与调用

4.2.1 MoveL、MoveJ 等常用指令的参数映射关系

4.2.2 目标点位定义（RobTarget）的数据构造方法

4.2.3 速度、加速度与转弯区参数的精细调节

SpeedData 构造方式

ZoneData 精度等级对照表

AccSet 设置加减速特性

4.3 实际应用中的路径优化与避障策略

4.3.1 动态路径重构技术实现方案

4.3.2 基于传感器反馈的实时运动调整

4.3.3 多轴协同运动平滑性保障措施

5. I/O 信号处理与外部设备集成

5.1 数字与模拟 I/O 信号的基本操作

5.1.1 输入输出信号读写接口详解

代码逻辑逐行分析：

5.1.2 Signal 对象的获取与状态监听设置

参数说明与逻辑解析：

5.1.3 周期性轮询与事件驱动模式对比

5.2 外部设备联动控制架构设计

5.2.1 与 PLC、传送带、夹具的信号交互协议

逻辑分析：

5.2.2 安全门、急停按钮等安全信号接入方案

5.2.3 同步时序控制与联锁逻辑编程实践

5.3 高级 I/O 应用场景：视觉触发与定位协同

5.3.1 触发相机拍摄的精准时机控制

5.3.2 接收外部测量数据并更新工件坐标系

5.3.3 基于 I/O 中断的快速响应机制实现

6. ABB 机器人 PC 端控制系统完整开发实战

6.1 典型自动化产线集成需求分析

6.2 核心功能代码实现与关键问题解决