1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
using S7.Net;
using System.Threading.Tasks;
using System.Windows; // WPF 示例

public partial class MainWindow : Window
{
    private Plc _siemensPlc;

    public MainWindow()
    {
        InitializeComponent();
        // 绑定窗口加载事件
        this.Loaded += MainWindow_Loaded; 
    }

    private async void MainWindow_Loaded(object sender, RoutedEventArgs e)
    {
        // UI 显示提示语
        lblStatus.Text = "正在连接设备...";
        
        // 初始化对象
        _siemensPlc = new Plc(CpuType.S71200, "192.168.0.10", 0, 1);

        try
        {
            // 使用 await 异步等待连接，避免界面假死
            await _siemensPlc.OpenAsync();
            
            if(_siemensPlc.IsConnected)
            {
                lblStatus.Text = "PLC 连接成功！";
                lblStatus.Foreground = System.Windows.Media.Brushes.Green;
                
                // 连接成功后，开启后台轮询数据的任务
                StartPollingData();
            }
        }
        catch (Exception ex)
        {
            lblStatus.Text = "连接失败，请检查网线！";
            lblStatus.Foreground = System.Windows.Media.Brushes.Red;
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
using S7.Net;
using S7.Net.Types; // 需要用到辅助转换类

// 开启一个后台死循环任务，用于监控产线数据
private void StartPollingData()
{
    Task.Run(async () =>
    {
        while (true)
        {
            try
            {
                // 一次性读取 DB10 中，从偏移量 0 开始的 100 字节数据
                byte[] buffer = _siemensPlc.ReadBytes(DataType.DataBlock, 10, 0, 100);

                // --- 开始在 C# 内存中高速解析 ---
                
                // 1. 解析 Bool (位): 假设需求是读取 DB10.DBX0.2 (系统启动信号)
                // SelectBit(2) 表示取第一个字节 (buffer[0]) 的第 2 个比特位
                bool isSystemRunning = buffer[0].SelectBit(2); 

                // 2. 解析 Int16 (短整型): 假设需求是读取 DB10.DBW2 (气缸压力值)
                // Skip(2).Take(2) 截取从字节 2 开始的连续 2 个字节
                // FromByteArray 负责处理西门子（大端）与 Windows（小端）的字节序翻转
                short airPressure = Int.FromByteArray(buffer.Skip(2).Take(2).ToArray());

                // 3. 解析 Float/Real (单精度浮点数): 假设需求读取 DB10.DBD4 (熔炉温度)
                // 截取连续 4 个字节，转换为浮点数
                float temperature = Real.FromByteArray(buffer.Skip(4).Take(4).ToArray());

                // --- 切换回 UI 线程刷新界面 ---
                Application.Current.Dispatcher.Invoke(() => 
                {
                    chkRunning.IsChecked = isSystemRunning;
                    txtPressure.Text = airPressure.ToString() + " Mpa";
                    txtTemp.Text = temperature.ToString("F2") + " ℃";
                });
            }
            catch(Exception)
            {
                // 通讯中断处理，可在此重连
            }

            // 严禁无限光速轮询，必须休眠，保护网卡与 CPU
            await Task.Delay(100); 
        }
    });
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
using gts;

private void FormMain_Load(object sender, EventArgs e)
{
    // 1. 尝试打开板卡，如果返回不是 0，说明驱动没装好或板卡没插稳
    short rtn = mc.GT_Open(0, 1);
    if (rtn != 0) 
    {
        MessageBox.Show("PCIe总线未检测到固高控制卡！错误码：" + rtn);
        return;
    }

    // 2. 深度复位
    mc.GT_Reset();

    // 3. 加载存放在程序根目录的机器配置文件
    rtn = mc.GT_LoadConfig("MachineConfig.cfg");
    if(rtn != 0)
    {
        MessageBox.Show("配置文件加载失败，请确认 MachineConfig.cfg 是否存在！");
        return;
    }

    // 4. 假设我们的设备是一个三轴系统 (X=1, Y=2, Z=3)
    // 我们需要循环清除每个轴的报警，并开启使能
    for (short axis = 1; axis <= 3; axis++)
    {
        mc.GT_ClrSts(1, axis); // 清除轴状态
        mc.GT_AxisOn(axis);    // 伺服通电，听到“哒”的一声继电器响，电机锁死
    }

    MessageBox.Show("机台底层伺服初始化完成，等待运动指令。");
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
// 键盘/鼠标【按下】事件 (开始正向转动)
private void btnXPositive_PreviewKeyDown(object sender, KeyEventArgs e)
{
    // 拦截长按键盘时产生的连续重复触发信号
    if (e.IsRepeat) return; 

    short axisX = 1; // 假设 X 轴映射在物理轴 1
    
    // 1. 设定为点动模式
    mc.GT_PrfJog(axisX);
    
    // 2. 配置点动参数
    mc.TJogPrm jogPrm;
    mc.GT_GetJogPrm(axisX, out jogPrm);
    // 【TJogPrm 结构体参数详解】
    // acc (double): 加速度，单位通常为 pulse/ms^2 (脉冲每平方毫秒)
    // dec (double): 减速度，单位为 pulse/ms^2
    // smooth (double): 平滑系数(0~1)，用于在加减速拐点做 S 型曲线平滑，值越大越平滑但跟随滞后越长
    jogPrm.acc = 0.5; 
    jogPrm.dec = 0.5; 
    jogPrm.smooth = 0.5; // 可选的平滑过渡
    mc.GT_SetJogPrm(axisX, ref jogPrm);

    // 3. 设定恒定速度 (假设 100 脉冲/毫秒，正数代表正向跑)
    mc.GT_SetVel(axisX, 100);

    // 4. 触发物理运行！(1 << (1-1) 即 1)
    mc.GT_Update(1 << (axisX - 1)); 
}

// 键盘【抬起】事件 (要求平滑停止)
private void btnXPositive_PreviewKeyUp(object sender, KeyEventArgs e)
{
    StopJogAxis(1);
}

// 【保命核心】控件或窗口失去焦点时，无条件强制刹车！
private void btnXPositive_LostFocus(object sender, RoutedEventArgs e)
{
    StopJogAxis(1); // 哪怕没有触发 KeyUp，失焦也立刻停机
}

// 独立的平滑停止函数
private void StopJogAxis(short axis)
{
    // 在 Jog 模式下，将目标速度设为 0 并 Update，电机就会根据设定的 dec (减速度) 完美平滑刹车
    mc.GT_SetVel(axis, 0);
    mc.GT_Update(1 << (axis - 1));
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public void MoveToAbsolutePosition(short axis, int targetPos)
{
    // 1. 设置该轴为梯形点位定位模式
    mc.GT_PrfTrap(axis);

    // 2. 灌入梯形结构体参数
    mc.TTrapPrm trapPrm;
    mc.GT_GetTrapPrm(axis, out trapPrm); // 先获取底层默认参数
    trapPrm.acc = 1.0;          // 设定加速度
    trapPrm.dec = 1.0;          // 设定减速度
    trapPrm.smoothTime = 25;    // 设定 25ms 的 S 型平滑过度，让起步如丝般顺滑
    mc.GT_SetTrapPrm(axis, ref trapPrm);

    // 3. 压入终点坐标与速度
    mc.GT_SetPos(axis, targetPos);
    mc.GT_SetVel(axis, 50.0); // 巡航速度设定为 50 pulse/ms

    // 4. 呼叫底层起跑
    mc.GT_Update(1 << (axis - 1));
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public void StartCustomPtCurve(short axis)
{
    // 1. 清空底层缓冲并设置为 PT 模式 (mode 1 指静态模式)
    mc.GT_PtClear(axis);
    mc.GT_PrfPt(axis, 1);

    // 2. 压入自定义数据
    // 假设我们要模拟一段正弦波振动，自行计算出每次 10ms 需要走的增量 posDelta
    for(int i = 0; i < 50; i++)
    {
        short space;
        mc.GT_PtSpace(axis, out space); // 查询剩余空间
        
        if (space > 0) // 确保板卡 FIFO 还没塞满
        {
            // 通过数学公式计算位移：一个周期波的增量
            double posDelta = Math.Sin(i * 0.1) * 100; 
            
            // 压入指令：强制驱动器花费恰好 10ms 走完 posDelta 的距离
            mc.GT_PtData(axis, posDelta, 10, mc.PT_MODE_STATIC);
        }
    }

    // 3. 开始严格按时间序列执行
    mc.GT_PtStart(1 << (axis - 1), 0);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
public void StartDispensingSquare()
{
    // 1. 构建一个二维坐标系配置
    mc.TCrdPrm crdPrm = new mc.TCrdPrm();
    crdPrm.dimension = 2;            // 我们需要联动两个轴 (X,Y)
    crdPrm.profile[0] = 1;           // 该坐标系的 X 绑定到物理轴 1
    crdPrm.profile[1] = 2;           // 该坐标系的 Y 绑定到物理轴 2
    
    // 初始化 1 号坐标系
    mc.GT_SetCrdPrm(1, ref crdPrm); 
    
    // 启动前必须清空 1 号坐标系的 0 号 FIFO 数据缓冲区
    mc.GT_CrdClear(1, 0);

    // 2. 依次推入矩形的四条边
    // 参数含义：坐标系1, X点, Y点, 合成速度100, 加速度1, 终点速度(50代表不停车滑过拐角), FIFO区号0
    
    // 走线段1: 到达 (10000, 0)
    mc.GT_LnXY(1, 10000, 0, 100, 1, 50, 0); 
    
    // 走线段2: 到达 (10000, 10000)
    mc.GT_LnXY(1, 10000, 10000, 100, 1, 50, 0); 
    
    // 走线段3: 到达 (0, 10000)
    mc.GT_LnXY(1, 0, 10000, 100, 1, 50, 0); 
    
    // 走线段4: 闭合回到起点 (0, 0)，此时要求停车，故终点速度给 0
    mc.GT_LnXY(1, 0, 0, 100, 1, 0, 0); 

    // 3. 所有路径下发完毕，呼叫底层的 DSP 插补引擎起跑！（掩码位1代表坐标系1）
    mc.GT_CrdStart(1, 0); 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
using csLTDMC; // 引用雷赛官方 C# 封装类

public void InitLeadshineCard()
{
    // 1. 初始化引擎，这步如果没插卡会卡住一小会，所以返回 <=0 代表失败
    short cardCount = LTDMC.dmc_board_init();
    if(cardCount <= 0) 
    {
        MessageBox.Show("未检测到任何雷赛控制卡在位！");
        return;
    }

    ushort cardNo = 0; // 板卡标识序号（第一张卡是 0）
    
    // 假设卡上接了 4 个电机轴 (索引 0~3)
    for (ushort axis = 0; axis < 4; axis++)
    {
        // 2. 发送 Servo 使能信号，1 表示强电吸合
        LTDMC.dmc_write_sevon_pin(cardNo, axis, 1); 
        
        // 3. 设置输出模式：1 代表“脉冲+方向”模式
        LTDMC.dmc_set_pulse_outmode(cardNo, axis, 1);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public void MoveToAssembleStation(ushort axis, int targetPulsePos)
{
    ushort card = 0;

    // 1. 配置梯形速度主骨架
    double startVel = 500;   // 刚起步瞬间的速度 (pulse/s)
    double maxVel = 50000;   // 允许飚到的最高速度 (pulse/s)
    double timeAcc = 0.2;    // 用 0.2 秒从 500 飚到 50000
    double timeDec = 0.2;    // 刹车时间
    LTDMC.dmc_set_profile(card, axis, startVel, maxVel, timeAcc, timeDec);

    // 2. 叠加 S 曲线柔化 (消除机械“点头”抖动)
    // s_mode 填 0 (时间模式)，0.05 代表 S 段柔化耗时占用 0.05 秒
    LTDMC.dmc_set_s_profile(card, axis, 0, 0.05); 

    // 3. 触发指令！参数 1 代表绝对运动，目标绝对位置为 targetPulsePos
    LTDMC.dmc_pmove(card, axis, targetPulsePos, 1); 

    // 4. 等待运动结束 (如果是基于 Task 的后台作业，在此处阻塞等待即可)
    // dmc_check_done 返回 1 代表轴彻底停稳了，返回 0 代表正在跑
    while(LTDMC.dmc_check_done(card, axis) == 0)
    {
        Thread.Sleep(10); // 【铁律】这里必须休眠释放 CPU 时间片，否则程序卡死
    }
    
    // 抵达工位后，触发后续的吹气阀、气缸等动作...
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public void SetupFlyCameraTrigger(ushort axis)
{
    ushort card = 0;
    ushort cmpChannel = 0; // 假定使用 0 号比较通道连接了相机

    // 1. 清空历史触发点
    LTDMC.dmc_compare_clear_points(card, cmpChannel);

    // 2. 设置比较参数配置: 绑定当前 axis，选择使用“规划位置”进行比较
    LTDMC.dmc_compare_set_config(card, cmpChannel, 1, axis, 0, 0);

    // 3. 我们在长条形流水线上，需要在 X 坐标为 10000, 20000, 30000 的地方进行高速无感抓拍
    int[] triggerPositions = new int[] { 10000, 20000, 30000 };
    
    foreach(var pos in triggerPositions)
    {
        // 向 DSP 压入触发点。
        // 参数含义: 卡号, 通道号, 触发位置pos, 方向(0=正向有效), 动作(1=输出有效脉冲), 动作保持时间(无视填0)
        LTDMC.dmc_compare_add_point(card, cmpChannel, pos, 0, 1, 0);
    }

    // 4. 激活监听
    LTDMC.dmc_compare_start(card, cmpChannel);

    // 设置完后，上位机只管让电机狂飙跑过这段路程，硬件板卡在路过时会自动电击相机触发快门
    LTDMC.dmc_pmove(card, axis, 50000, 1); 
}

1
2
3
4
5
6
7
8
9
10
// 固高：连续路径插补 —— 段间速度不归零
mc.GT_CrdClear(1, 0);

// velEnd 填非零值 → 告诉 DSP "不要在这个点停车，直接滑过去"
mc.GT_LnXY(1, 10000, 0,     100, 1, 50, 0);  // 第一段终点速度 50，不停
mc.GT_LnXY(1, 10000, 10000, 100, 1, 50, 0);  // 第二段终点速度 50，不停
mc.GT_LnXY(1, 0,     10000, 100, 1, 50, 0);  // 第三段终点速度 50，不停
mc.GT_LnXY(1, 0,     0,     100, 1, 0,  0);  // 最后一段终点速度 0，停车

mc.GT_CrdStart(1, 0); // 一键起跑，四段路径一气呵成

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// 雷赛：需要额外配置才能实现连续插补
ushort card = 0;

// 设置插补坐标系 (将轴 0 和轴 1 绑定为 XY 二维坐标系)
LTDMC.dmc_set_vector_profile_unit(card, 0, 500, 50000, 0.2, 0.2, 0);

// 默认模式：每段结束减速到零
LTDMC.dmc_line_unit(card, 0, new int[]{10000, 0}, 2, 0, 1);    // 走完就停
LTDMC.dmc_line_unit(card, 0, new int[]{10000, 10000}, 2, 0, 1); // 再起步再停

// 如果要实现连续不停，需要开启"连续插补"模式：
// dmc_conti_open_list → 压入路径 → dmc_conti_close_list → dmc_conti_start
LTDMC.dmc_conti_open_list(card, 0, 0);
LTDMC.dmc_conti_line_unit(card, 0, 0, new int[]{10000, 0}, 2, 0, 50000, 0);
LTDMC.dmc_conti_line_unit(card, 0, 0, new int[]{10000, 10000}, 2, 0, 50000, 0);
LTDMC.dmc_conti_close_list(card, 0);
LTDMC.dmc_conti_start(card, 0);