Gemini3 炸裂全网，搞个PLC编程岂不是So easy！

INTERFACE I_Actuator
(* 暴露给外部调用的公共方法和属性 *)
METHOD 
  MoveWork : BOOL
END_METHOD
METHOD
  MoveHome : BOOL
END_METHOD
METHOD 
  ResetError : BOOL
END_METHOD

PROPERTY ErrorID : UDINT END_PROPERTY
PROPERTY IsBusy : BOOL END_PROPERTY
PROPERTY IsAtWork : BOOL END_PROPERTY
PROPERTY IsAtHome : BOOL END_PROPERTY

FUNCTION_BLOCK ABSTRACT FB_ActuatorBase IMPLEMENTS I_Actuator
VAR
    (* 状态机枚举 *)
    _eState : (IDLE, MOVING_WORK, MOVING_HOME, ERROR) := IDLE;
    (* 内部变量，使用下划线前缀区分 *)
    _fbTimeoutTimer : TON;
    _tTimeoutLimit  : TIME := T#5S;
    _nErrorID       : UDINT := 0;
END_VAR
(* === 接口属性实现 (只读) === *)
PROPERTY ErrorID : UDINT
    GET
        ErrorID := _nErrorID;
    END_GET
END_PROPERTY
PROPERTY IsBusy : BOOL
    GET
        IsBusy := (_eState = MOVING_WORK) OR (_eState = MOVING_HOME);
    END_GET
END_PROPERTY
(* === 抽象方法 (强制子类必须实现具体的硬件读写) === *)
(* 子类用来设置物理输出 *)
METHOD PROTECTED ABSTRACT SetOutputs
    VAR_INPUT
        bWorkCmd : BOOL;
        bHomeCmd : BOOL;
    END_VAR
END_METHOD
(* 子类用来读取物理反馈 *)
METHOD PROTECTED ABSTRACT ReadInputs
END_METHOD
(* === 核心逻辑周期调用方法 === *)
METHOD PUBLIC Execute
    (* 读取子类映射的传感器状态 *)
    ReadInputs();
    (* 状态机逻辑 *)
    CASE _eState OF
        IDLE:
            _fbTimeoutTimer(IN := FALSE);
        MOVING_WORK:
            SetOutputs(TRUE, FALSE);
            _fbTimeoutTimer(IN := TRUE, PT := _tTimeoutLimit);
            (* 使用 THIS^ 访问通过接口/虚方法获取的状态 *)
            IF THIS^.IsAtWork THEN
                _eState := IDLE;
            ELSIF _fbTimeoutTimer.Q THEN
                _nErrorID := 101; 
            (* 例如: 动作超时 *)
                _eState := ERROR;
            END_IF
        MOVING_HOME:
            SetOutputs(FALSE, TRUE);
            _fbTimeoutTimer(IN := TRUE, PT := _tTimeoutLimit);
            IF THIS^.IsAtHome THEN
                _eState := IDLE;
            ELSIF _fbTimeoutTimer.Q THEN
                _nErrorID := 102;
                _eState := ERROR;
            END_IF
        ERROR:
            SetOutputs(FALSE, FALSE); (* 安全保护 *)
    END_CASE
END_METHOD
(* === 接口方法实现 === *)
METHOD MoveWork : BOOL
    IF _eState <> ERROR THEN
        _eState := MOVING_WORK;
        MoveWork := TRUE;
    END_IF
END_METHOD
METHOD MoveHome : BOOL
    IF _eState <> ERROR THEN
        _eState := MOVING_HOME;
        MoveHome := TRUE;
    END_IF
END_METHOD
METHOD ResetError : BOOL
    _nErrorID := 0;
    _eState := IDLE;
    ResetError := TRUE;
END_METHOD

FUNCTION_BLOCK FB_PneumaticCylinder EXTENDS FB_ActuatorBase
VAR_INPUT
    bSensorWork : BOOL; (* 物理输入 *)
    bSensorHome : BOOL;
END_VAR
VAR_OUTPUT
    bValveWork  : BOOL; (* 物理输出 *)
    bValveHome  : BOOL;
END_VAR
(* === 实现基类的抽象属性 === *)
PROPERTY IsAtWork : BOOL
    GET
        IsAtWork := bSensorWork;
    END_GET
END_PROPERTY
PROPERTY IsAtHome : BOOL
    GET
        IsAtHome := bSensorHome;
    END_GET
END_PROPERTY
(* === 实现基类的抽象方法 === *)
METHOD PROTECTED SetOutputs
    VAR_INPUT
        bWorkCmd : BOOL;
        bHomeCmd : BOOL;
    END_VAR
    (* 具体的硬件逻辑，例如这里是双电控 *)
    bValveWork := bWorkCmd;
    bValveHome := bHomeCmd;
END_METHOD
METHOD PROTECTED ReadInputs
    (* 如果需要复杂的滤波或防抖，在这里写 *)
    ;
END_METHOD

PROGRAM MAIN
VAR
    (* 实例化具体的气缸 *)
    fbCylinderA : FB_PneumaticCylinder;
    (* 定义测试变量 *)
    bUserBtnExtend : BOOL;
    bUserBtnRetract : BOOL;
    bUserBtnReset   : BOOL;
    (* 接口指针，用于演示多态性 *)
    iMyActuator : I_Actuator; 
END_VAR
(* 1. 硬件 IO 映射 (模拟) *)
fbCylinderA.bSensorWork:= HwInputs.I0_0;
fbCylinderA.bSensorHome:= HwInputs.I0_1;
(* 2. 逻辑控制 - 通过接口操作，实现解耦 *)
iMyActuator := fbCylinderA; (* 将具体实例赋值给接口 *)
(* 此时，我们只通过 iMyActuator 操作，不关心具体是双电控还是单电控 *)
IF bUserBtnExtend THEN
    iMyActuator.MoveWork();
END_IF
IF bUserBtnRetract THEN
    iMyActuator.MoveHome();
END_IF
IF bUserBtnReset THEN
    iMyActuator.ResetError();
END_IF
(* 3. 周期性执行核心逻辑 *)
(* 注意：必须调用实例的 Execute 方法来驱动内部状态机 *)
fbCylinderA.Execute();
(* 4. 输出映射 *)
HwOutputs.Q0_0:= fbCylinderA.bValveWork;
HwOutputs.Q0_1:= fbCylinderA.bValveHome;