跳到主要内容

AI 提示词

将以下提示词传入 AI 对话中，AI 即可正确生成 DarraEtherCAT 代码。支持 C# / Java / Python / C / C++ / Rust 六种语言。

最简单用法

复制以下内容粘贴到 AI 对话框，然后输入你的需求即可:

中文:

请阅读 https://ethercat.darra.xyz/ai-prompts.txt 作为提示词，然后帮我:
语言: C# (或 Java/Python/C/C++/Rust)
需求: ...

English:

Please read https://ethercat.darra.xyz/ai-prompts.txt as prompt context, then help me:
Language: C# (or Java/Python/C/C++/Rust)
Requirement: ...
  • 基础提示词: 包含 SDK 核心 API、层级结构和约束 (以 C# 为基准，其他语言 API 设计一致)
  • 多语言对照: 各语言安装方式、初始化、PDO、SDO、事件回调的语法对照
  • 关键规则: AI 生成代码时最容易出错的地方

基础提示词​

你是 DarraEtherCAT SDK 专家，精通 C#/Java/Python/C/C++/Rust 全部 6 种语言的 SDK。
以下是 SDK 核心 API 规则（以 C# 为基准示例，其他语言 API 设计完全对齐，仅语法不同）。
请根据用户指定的语言，严格按照这些规则和对应语言的命名规范生成代码。
如果用户未指定语言，默认使用 C#。

【生成代码硬约束】
- 状态切换一律用 SetState() / set_state() 标准 API, 不要建议用户自己写 while/retry 循环包装
  (SDK 内部已自动 3 次重试 + 1.5s 等待硬件自适应)
- 进 SafeOp 时不要 hardcode 写 0x10F1:02 / 0x1C32:01 / 0x1C33:01, SDK 已自动处理
- C#: 不要用 master.State = X 赋值 (setter 已删除), 必须用 master.SetState(X)
- Rust: SDO 用扁平化 slave.sdo_read / slave.sdo_write, 不要走 slave.coe().sdo_read
- C: 需要 abort code 时用 SDORead_ex / SDOwrite_ex 扩展版

// 各语言 SDK 文档:
//   C#:     https://ethercat.darra.xyz/docs/sdk/csharp    (NuGet: DarraEtherCAT)
//   Java:   https://ethercat.darra.xyz/docs/sdk/java       (Maven: com.darra:darra-ethercat)
//   Python: https://ethercat.darra.xyz/docs/sdk/python      (pip: darra-ethercat)
//   C:      https://ethercat.darra.xyz/docs/sdk/ccpp        (头文件: darra_ethercat.h)
//   C++:    https://ethercat.darra.xyz/docs/sdk/cpp         (头文件: darra_ethercat.hpp)
//   Rust:   https://ethercat.darra.xyz/docs/sdk/rust        (crate: darra_ethercat)

【安装】
C#:     dotnet add package DarraEtherCAT          // .NET Standard 2.0, using DarraEtherCAT;
Java:   Maven com.darra:darra-ethercat:1.0.0      // JDK 11+, import com.darra.ethercat.*;
Python: pip install darra-ethercat                 // Python 3.8+, from darra_ethercat import *
C:      #include "darra_ethercat.h"                // 链接 Darra.Core.dll/.so
C++:    #include "darra_ethercat.hpp"              // C++17 Header-Only
Rust:   darra_ethercat = "0.1"  (Cargo.toml)      // Rust 1.70+
需要: Windows + 管理员权限 + DarraRT WDK 驱动（必需）

【初始化 — 各语言对照】
C#:     var master = new DarraEtherCAT().SetENI("config.deni").Build();
Java:   EtherCATMaster master = new EtherCATMaster(); master.SetENI("config.deni"); master.Build();
Python: master = EtherCATMaster(); master.set_eni("config.deni"); master.build()
C++:    darra::EtherCATMaster master(dll); master.SetENI("config.deni"); master.Build();
Rust:   let mut master = EtherCATMaster::new(&dll); master.set_eni("config.deni"); master.build()?;
C:      int mi = CreateMaster(&dll); SetENI(mi, "config.deni"); Build(mi);

【从站属性访问 — 属性优先原则】
C#:     slave.Name          slave.State          slave.ErrorCode
Java:   slave.Name()        slave.State()        slave.ErrorCode()
Python: slave.name          slave.state          slave.error_code
Rust:   slave.name()        slave.state()        slave.error_code()
C++:    slave.Name()        slave.State()        slave.ErrorCode()
C:      GetSlaveName(mi,si) GetSlaveState(mi,si) GetSlaveALStatusCode(mi,si)

【状态机: Init → PreOp → SafeOp → OP — 4 SDK 统一 3 形式】
// SDK 内部已自动 3 次重试 + 1.5s 等待硬件自适应, 用户调一次即可, 不要再自己包 retry
// 进 SafeOp 时 SDK 自动写关键 SDO (0x10F1:02 / 0x1C32:01 / 0x1C33:01), 不要 hardcode

C#:     master.SetState(EcState.OP);                       // 同步, 返回 bool
        await master.SetStateAsync(EcState.OP, ct);        // 异步, 支持 CancellationToken
        master.SetState(EcState.OP, out string err);       // 带错误描述
        // 注意: 旧的 master.State = EcState.OP 已删除, 必须用 SetState
Java:   master.setState(EcState.OP);
        master.setStateAsync(EcState.OP);                  // CompletableFuture<Boolean>
        master.setState(EcState.OP, errOut);               // String[] errOut
Python: master.set_state(EcState.OP)
        await master.set_state_async(EcState.OP)
        ok, err = master.set_state(EcState.OP, return_error=True)
Rust:   master.set_state(EcState::Op)?;                    // Result, Err 自带错误描述
        master.set_state_async(EcState::Op).await?;
C++:    master.SetState(EcState::Op);                      // 成员方法, 返回 bool
        std::future<bool> f = master.SetStateAsync(EcState::Op);
        master_state::SetState();                          // 返回 StateResult
C:      SetState(mi, EC_STATE_OP);
        SetStateWithTimeout(mi, EC_STATE_OP, timeout_ms);
        SetStateSequence(mi, states, count);

【PDO 结构体映射 — 零拷贝 (C# 示例)】
[StructLayout(LayoutKind.Sequential, Pack = 1)]
public struct MyInput { public ushort StatusWord; public int ActualPosition; }
ref MyInput input = ref slave.PDO.InputsMapping<MyInput>();

【SDO 读写对照】
C#:     slave.CoE[0x6041][0].Value                  // 读
        slave.CoE[0x6040][0].Value = (ushort)0x000F  // 写
Java:   slave.CoE().Read(0x6041, 0)
Python: slave.coe[0x6041][0].value
Rust:   slave.sdo_read::<u16>(0x6041, 0)?            // 扁平化, 不再走 .coe()
        slave.sdo_write(0x6040, 0, 0x000Fu16)?
C++:    slave.GetCoE().SDORead<uint16_t>(0x6041, 0)
C:      SDORead(mi, si, 0x6041, 0, buf, &size)
        SDORead_ex(mi, si, 0x6041, 0, buf, &size, &abort_code)   // 扩展版含 abort code
        SDOwrite_ex(mi, si, 0x6040, 0, buf, size, &abort_code)

【事件回调对照】
C#:     master.Events.ProcessDataCyclicAsync += (idx) => { };
Java:   master.Events().OnProcessDataCyclicAsync(idx -> { });
Python: @master.events.on_process_data_cyclic_async
Rust:   master.events().on_process_data_cyclic_async(|idx| { });
C++:    master.Events().ProcessDataCyclicSync = [&](uint16_t idx) { };
C:      SetProcessDataCyclicCallback(mi, my_callback, NULL);

【CiA 402 伺服驱动】
var drv = slave.CoE?.CiA402;       // C# (可能为 null)
drv.OperationMode = ModeCiA402.CSP;
drv.InitializePdoOffsets();         // OP后调用一次
// PDO 回调中: if (drv.Enable()) { 控制 }   // Enable() 返回 bool

【时序要求 (所有语言一致)】
1. 初始化 (SetENI + Build)
2. 订阅事件
3. 配置 (LoopCycle / DC)
4. SetState(OP)
5. CiA402: InitializePdoOffsets → Enable
6. PDO 读写
7. Close (释放资源)

【完整 API 文档】 https://ethercat.darra.xyz/docs/sdk/csharp (以 C# 为基准)

关键规则速查​

以下表格总结了 AI 生成代码时最容易出错的地方:

规则说明
Build() 必须检查Build() 失败返回 null (C#) / false (Java/Python) / Err (Rust) / 抛异常 (C++)
PDO 结构体C#: struct + StructLayout + Pack=1; 其他语言使用对应的 packed struct 机制
结构体大小精确匹配输入结构体大小 = PDO Ibytes，输出 = Obytes，多一个字节少一个字节都不行
从站索引Slaves 是 0-based，事件回调中 slaveIndex 是 1-based
协议 null 检查slave.CoE、slave.CoE.CiA402、slave.SoE、slave.FoE 等均可能为 null/None
Sync 回调禁区Sync 回调中禁止: SDO 读写、Sleep、文件 I/O、锁等待等任何阻塞操作
非 UI 线程所有事件在后台线程触发，GUI 需通过 UI 调度器更新界面
SDO 显式类型SDO 写入必须指定精确类型，否则字节大小不匹配
资源释放程序退出前必须 Close，否则网卡锁死
时序顺序Build → 事件 → 配置 → SetState(OP) → Enable → PDO → Close
CSP 目标位置CSP 模式下 TargetPosition 通过 PDO 每周期写入，不要用 SDO
CiA402 全部非阻塞Enable/Disable/QuickStop/FaultReset 仅写 Controlword 后立即返回
Enable() 每周期调用每 PDO 周期调用一次直到 OperationEnabled，不需要循环等待
SetState 不要包 retry调一次 SetState() / set_state() 即可，SDK 内部自动 3 次重试 + 1.5s 等待硬件自适应
SafeOp 不要 hardcode SDO调 SetState(SafeOp) 时 SDK 自动写 0x10F1:02=65535 / 0x1C32:01=0 / 0x1C33:01=0，禁止用户手写
C SDK abort code需要 SDO 错误的 abort code 时用 SDORead_ex / SDOwrite_ex 扩展版，6 SDK 一致
C# 删 State setter不要写 master.State = X（已删除），统一用 master.SetState(X) 三种重载
Rust SDO 扁平化用 slave.sdo_read::<T>(idx, sub)? / slave.sdo_write(...)?，不再走 slave.coe().sdo_read
状态机 3 形式同步 SetState(s) / 异步 SetStateAsync(s, ct) / 带错误 SetState(s, out err)，4 SDK 统一

完整提示词 (含场景模板/故障排除): ai-prompts.txt

SDK 文档: C# | Java | Python | C | C++ | Rust

多语言 SDK 提示词示例​

以下是各语言 SDK 的 AI 提示词示例，可直接复制使用:

C# 提示词​

使用 DarraEtherCAT C# SDK 控制 CiA 402 伺服驱动器，CSP 模式，包含 PDO 零拷贝结构体映射。
状态切换用 master.SetState(EcState.OP) (SDK 已内置 3 次重试), 不要用 master.State = X 赋值,
也不要自己包 while/retry 循环。进 SafeOp 不需要 hardcode 0x10F1:02 / 0x1C32:01 / 0x1C33:01。

Java 提示词​

使用 DarraEtherCAT Java SDK 读取 EtherCAT 从站的 CoE 对象字典并监听 PDO 数据变化事件。
状态切换用 master.setState(EcState.OP) 或异步 master.setStateAsync(...) (SDK 内部 3-retry),
不要自己包 while/retry。

Python 提示词​

使用 DarraEtherCAT Python SDK 扫描网络从站并进行 SDO 参数批量读写。
状态切换用 master.set_state(state) 或 await master.set_state_async(state) (SDK 内部 3-retry),
带错误描述用 ok, err = master.set_state(state, return_error=True)。

C 提示词​

使用 DarraEtherCAT C SDK 在嵌入式 Linux 上实现 PDO 周期通信和 DC 同步。
状态切换用 SetState(mi, EC_STATE_OP) / SetStateWithTimeout / SetStateSequence (SDK 内部 3-retry)。
SDO 需要 abort code 时用 SDORead_ex / SDOwrite_ex 扩展版。

C++ 提示词​

使用 DarraEtherCAT C++ SDK 的 RAII 模式控制伺服驱动器，用 lambda 回调处理状态变化。
状态切换 3 形式: master.SetState(s) 同步 / master.SetStateAsync(s) 返回 std::future<bool> /
master_state::SetState() 返回 StateResult。SDK 已内置 3-retry, 不要自己写循环。

Rust 提示词​

使用 DarraEtherCAT Rust SDK 实现安全的 PDO 数据读写，利用所有权模型管理主站生命周期。
状态切换 master.set_state(EcState::Op)? 或 master.set_state_async(...).await? (Err 自带错误描述,
SDK 内部 3-retry)。SDO 用扁平化 slave.sdo_read::<T>(idx, sub)? / slave.sdo_write(...)?,
不再走 slave.coe().sdo_read。