PLC编程AI助手指南：OpenRouter等三大免费大模型方案实测

在当前的AI浪潮中，无论是开源还是闭源的大模型都找到了各自的商业定位和应用场景。对于工业自动化领域的PLC编程工程师而言，如何在众多选择中找到免费且实用的AI辅助工具，成为了一个实际需求。

在通用IT编程领域，Claude系列模型表现突出。但在PLC编程这个相对垂直的领域，目前并没有专用的“最强模型”。我们此前的社区调查也显示，开发者们使用的模型非常分散。

不过，排行榜上的顶尖模型大多能找到免费的替代或体验方案。对于PLC编程的日常辅助任务，这些免费模型的能力已经足够。更重要的是，我们始终认为，最适合特定领域的最强模型，最终需要基于领域数据训练而成。

本文将分享三个切实可用的免费大模型方案，并辅以实际的PLC编程测试，希望能帮助你找到合适的AI编程伙伴。

方案一：OpenRouter——模型聚合与比测平台

对于国内开发者，直接访问Claude、Google Gemini等国外模型可能存在网络限制。常见的解决方案是使用API中转服务，OpenRouter便是一个优秀的聚合平台，汇集了众多可免费使用的模型。

官网地址：https://openrouter.ai/

在OpenRouter上，你可以将同一个问题（例如编写PLC代码）同时提交给多个免费模型，直观地比较它们的输出质量和风格。

接下来，我们以“以交通灯为例写一段ST PLC代码，突出简洁性和专业性”为指令，看看不同模型的表现。

1. DeepSeek R1（0528）的输出

该模型生成了一段采用状态机结构的交叉路口交通灯控制代码，并附有详细的设计说明。

以下是一段简洁且专业的交通灯控制ST（结构化文本）PLC代码示例。代码采用状态机zhihu结构，突出可读性和可维护性：

```pascal
// Traffic Light Control System
// States: NS_Green, NS_Yellow, EW_Green, EW_Yellow
VAR
    ton: TON;               // Timer function block
    currentState: INT := 0; // 0=NS_Green, 1=NS_Yellow, 2=EW_Green, 3=EW_Yellow
END_VAR

// Output assignments (assuming digital outputs)
OUTPUT(
    NS_Red   := NOT(currentState IN {0,1}),   // North-South
    NS_Yellow := (currentState = 1),
    NS_Green  := (currentState = 0),
    EW_Red   := NOT(currentState IN {2,3}),   // East-West
    EW_Yellow := (currentState = 3),
    EW_Green  := (currentState = 2)
);

// State machine logic
CASE currentState OF
    0:  // NS_Green (North-South Green)
        ton(IN := TRUE, PT := T#30S);
        IF ton.Q THEN
            currentState := 1;
            ton(IN := FALSE);
        END_IF

    1:  // NS_Yellow
        ton(IN := TRUE, PT := T#5S);
        IF ton.Q THEN
            currentState := 2;
            ton(IN := FALSE);
        END_IF

    2:  // EW_Green (East-West Green)
        ton(IN := TRUE, PT := T#30S);
        IF ton.Q THEN
            currentState := 3;
            ton(IN := FALSE);
        END_IF

    3:  // EW_Yellow
        ton(IN := TRUE, PT := T#5S);
        IF ton.Q THEN
            currentState := 0;
            ton(IN := FALSE);
        END_IF
END_CASE
```

2. Aurora Alpha 的输出

该模型同样采用状态机，但提供了单组红黄绿灯的控制逻辑，代码结构清晰，注释详尽。

以下是一段 **简洁且专业** 的 **Structured Text（ST）** 代码示例，实现了一个基本的 **交通灯控制**（红‑黄‑绿）逻辑。代码采用了 **状态机** 的写法，结构清晰、易于维护，并且遵循 IEC 61131‑3 标准。

<details>
<summary>🟢 代码概览</summary>

```st
PROGRAM TrafficLight
VAR
    // 时间计数器（单位：毫秒）
    tTimer      : TIME := T#0ms;
    // 当前灯状态
    eState      : (Red, RedYellow, Green, Yellow);
    // 状态持续时间
    tRed        : TIME := T#5s;
    tRedYellow : TIME := T#2s;
    tGreen      : TIME := T#5s;
    tYellow     : TIME := T#2s;
END_VAR

// 主循环，每个 PLC 扫描周期执行一次
CASE eState OF
    Red:
        // 红灯保持
        IF tTimer >= tRed THEN
            tTimer := T#0ms;
            eState := RedYellow;
        END_IF;
    RedYellow:
        // 红黄灯保持
        IF tTimer >= tRedYellow THEN
            tTimer := T#0ms;
            eState := Green;
        END_IF;
    Green:
        // 绿灯保持
        IF tTimer >= tGreen THEN
            tTimer := T#0ms;
            eState := Yellow;
        END_IF;
    Yellow:
        // 黄灯保持
        IF tTimer >= tYellow THEN
            tTimer := T#0ms;
            eState := Red;
        END_IF;
END_CASE;

// 计时器递增（假设 PLC 扫描周期为 100 ms）
tTimer := tTimer + T#100ms;

// 输出映射：根据状态控制实际灯
RedLamp   := (eState = Red) OR (eState = RedYellow);
YellowLamp:= (eState = RedYellow) OR (eState = Yellow);
GreenLamp := (eState = Green);
```

</details>

3. GLM Air 4.5 的输出

这个模型输出了一个完整的函数块（FB），功能更为复杂，包含了绿灯和红灯的闪烁过渡阶段，模块化程度高。

# 交通灯控制 - ST PLC代码

```st
FUNCTION_BLOCK "Traffic_Light_Control"
{ S7_Optimized_Access := 'TRUE' }
VERSION : 0.1
   VAR_INPUT
        Run : Bool;           // 启动信号
        T_Green : Time := T#30S;    // 绿灯持续时间
        T_Yellow : Time := T#3S;    // 黄灯持续时间
        T_Red : Time := T#30S;      // 红灯持续时间
        Blink_Count : Int := 3;      // 闪烁次数
   END_VAR

   VAR_OUTPUT
        Q_Red : Bool;         // 红灯输出
        Q_Yellow : Bool;      // 黄灯输出
        Q_Green : Bool;       // 绿灯输出
   END_VAR

   VAR
        State : Int := 0;     // 状态机状态
        Blink_Timer : TON;   // 闪烁计时器
        Phase_Timer : TON;   // 阶段计时器
        Blink_Counter : Int := 0; // 闪烁计数器
   END_VAR

   // 状态机控制逻辑
   CASE State OF
       0: // 状态0: 绿灯亮
           Q_Green := TRUE;
           Phase_Timer(IN := Run, PT := T_Green);
           IF Phase_Timer.Q THEN
              State := 1;
              Phase_Timer(IN := FALSE);
           END_IF;

       1: // 状态1: 绿灯闪烁
           Blink_Timer(IN := TRUE, PT := T#1S);
           IF Blink_Timer.Q THEN
              Blink_Counter := Blink_Counter + 1;
              Blink_Timer(IN := FALSE);
              Q_Green := NOT Q_Green;

              IF Blink_Counter >= Blink_Count THEN
                 State := 2;
                 Blink_Counter := 0;
              END_IF;
           END_IF;

       2: // 状态2: 黄灯亮
           Q_Yellow := TRUE;
           Phase_Timer(IN := Run, PT := T_Yellow);
           IF Phase_Timer.Q THEN
              State := 3;
              Phase_Timer(IN := FALSE);
           END_IF;

       3: // 状态3: 红灯亮
           Q_Red := TRUE;
           Phase_Timer(IN := Run, PT := T_Red);
           IF Phase_Timer.Q THEN
              State := 4;
              Phase_Timer(IN := FALSE);
           END_IF;

       4: // 状态4: 红灯闪烁
           Blink_Timer(IN := TRUE, PT := T#1S);
           IF Blink_Timer.Q THEN
              Blink_Counter := Blink_Counter + 1;
              Blink_Timer(IN := FALSE);
              Q_Red := NOT Q_Red;

              IF Blink_Counter >= Blink_Count THEN
                 State := 0;
                 Blink_Counter := 0;
                 Q_Red := FALSE;
              END_IF;
           END_IF;

       ELSE: // 默认状态
           State := 0;
   END_CASE;

   // 当系统停止时复位所有输出
   IF NOT Run THEN
        Q_Red := FALSE;
        Q_Yellow := FALSE;
        Q_Green := FALSE;
        State := 0;
        Blink_Counter := 0;
        Phase_Timer(IN := FALSE);
        Blink_Timer(IN := FALSE);
   END_IF;

END_FUNCTION_BLOCK
```

此外，平台上还有一些支持图像输出的模型（如FLUX、Seedream），它们可以根据指令生成逻辑示意图或代码截图。

具体哪个模型更适合你的编程习惯和项目需求，还需要自己动手实践和比较。通过 OpenRouter 这样的平台，我们可以高效地对比各类开源实战项目的模型表现。

方案二：GitHub Copilot（VS Code 插件）

对于已经使用 Visual Studio Code 的开发者，GitHub Copilot 插件提供了一个便捷的免费通道。绑定 GitHub 账户后，可以在 VS Code 内直接使用多个指定的免费模型。

登录 GitHub：https://github.com/

在个人 Settings -> Developer Settings 中，可以管理 Personal access tokens (classic)。

将生成的 Token 配置到支持 Copilot 协议的客户端（例如某些开源代码助手）后，即可免费使用包括 GPT-4o mini 在内的模型。

基本上，拥有 GitHub 账户的用户就可以免费体验这几款模型，对于集成在开发环境中的辅助编程非常方便。

方案三：NVIDIA API 平台

另一个重量级的免费方案来自 NVIDIA。通过其 AI 构建平台，开发者可以获取 API Key 来调用一系列领先的人工智能模型。

首先访问官网：https://build.nvidia.com/

使用账户登录后，在控制台找到 API Keys 管理页面，创建一个新的 API Key。

请注意，这个 Key 需要妥善保管，避免暴露在公开场合。 获得 Key 后，将其填入你使用的编程环境或工具中，就可以调用 NVIDIA 平台上的丰富模型了。

例如，在配置了该 API 的代码助手中，你可以看到并选择诸如 GPT-OSS-120B 这样的模型。

我们再次用交通灯PLC代码的问题来测试 GPT-OSS-120B 模型。

模型生成了一段结构清晰、使用枚举类型定义状态的专业代码。

PROGRAM TrafficLightControl
VAR
    (* Enum for light states *)
    LightState : (Red, RedYellow, Green, Yellow) := Red;
    (* Timer for each phase, preset in ms *)
    PhaseTimer : TON;           (* Standard ON-delay timer *)
    PhaseTime  : TIME := T#5s;  (* Default duration, can be overridden per state *)
END_VAR
(*--------------------------------------------------------------*)
(* Main cyclic logic                                            *)
(*--------------------------------------------------------------*)
IF NOT PhaseTimer.IN THEN
    (* Start timer for current state *)
    PhaseTimer(IN := TRUE, PT := PhaseTime);
ELSE
    (* When timer elapsed, transition to next state *)
    IF PhaseTimer.Q THEN
        PhaseTimer(IN := FALSE);  (* Reset timer *)
        CASE LightState OF
            Red:        (* Red -> Red+Yellow *)
                LightState := RedYellow;
                PhaseTime := T#2s;    (* Short transition *)
            RedYellow:  (* Red+Yellow -> Green *)
                LightState := Green;
                PhaseTime := T#5s;    (* Green duration *)
            Green:      (* Green -> Yellow *)
                LightState := Yellow;
                PhaseTime := T#2s;    (* Yellow duration *)
            Yellow:     (* Yellow -> Red, cycle repeats *)
                LightState := Red;
                PhaseTime := T#5s;    (* Red duration *)
        END_CASE;
    END_IF;
END_IF;
(*--------------------------------------------------------------*)
(* Output assignments (example mapping to physical outputs)      *)
(*--------------------------------------------------------------*)
CASE LightState OF
    Red:
        RED_LIGHT    := TRUE;
        YELLOW_LIGHT := FALSE;
        GREEN_LIGHT  := FALSE;
    RedYellow:
        RED_LIGHT    := TRUE;
        YELLOW_LIGHT := TRUE;
        GREEN_LIGHT  := FALSE;
    Green:
        RED_LIGHT    := FALSE;
        YELLOW_LIGHT := FALSE;
        GREEN_LIGHT  := TRUE;
    Yellow:
        RED_LIGHT    := FALSE;
        YELLOW_LIGHT := TRUE;
        GREEN_LIGHT  := FALSE;
END_CASE;
END_PROGRAM

总结

以上介绍了三种获取和免费使用大模型辅助PLC编程的可行路径。从模型聚合平台OpenRouter，到集成在IDE中的GitHub Copilot，再到提供强大算力模型的NVIDIA平台，各有侧重。

在AI技术蓬勃发展的当下，建议工程师们从这些免费方案入手，亲身体验AI在代码生成、逻辑建议方面的能力。通过实际使用，逐步适应并掌握如何与AI协作，从而提升编程效率和质量。最终，结合领域知识筛选出最适合自己的工具，甚至为训练专有模型积累经验。希望这篇指南能为你提供清晰的入门参考，更多深入的技术文档和实践欢迎在技术社区交流探讨。

---

参考链接：

1. https://openrouter.ai/
2. https://github.com
3. https://build.nvidia.com/