Writing a function block

Why a block, not a function

Every motor in the plant needs the same things: a seal-in, a check that the contactor auxiliary came back, a latched fault, and an acknowledge. The check needs a timer, the timer needs memory, and memory means a function block, not a function.

Write it once, use it for thirty motors.

Declaring one

FUNCTION_BLOCK FB_Motor
VAR_INPUT
  Start    : BOOL;   (* start pulse *)
  Stop     : BOOL;   (* stop pulse, always wins *)
  Feedback : BOOL;   (* contactor auxiliary contact *)
  Ack      : BOOL;   (* fault acknowledge *)
  FbTime   : TIME;   (* how long to wait for feedback *)
END_VAR
VAR_OUTPUT
  Run   : BOOL;      (* to the contactor *)
  Alarm : BOOL;      (* latched fault *)
END_VAR
VAR
  FbTimer : TON;     (* memory, private to each instance *)
END_VAR

(* Seal-in; stop and fault both win *)
Run := (Start OR Run) AND NOT Stop AND NOT Alarm;

(* Commanded to run but no feedback within the allowed time *)
FbTimer(IN := Run AND NOT Feedback, PT := FbTime);

IF FbTimer.Q THEN
  Alarm := TRUE;     (* latched: it holds after the cause clears *)
END_IF;

IF Ack THEN
  Alarm := FALSE;
END_IF;

END_FUNCTION_BLOCK

The instance is the whole point

VAR
  M101 : FB_Motor;
  M102 : FB_Motor;
  M103 : FB_Motor;
END_VAR

M101(Start := Btn1, Stop := StopAll, Feedback := Aux1, Ack := AckBtn, FbTime := T#2s);
M102(Start := Btn2, Stop := StopAll, Feedback := Aux2, Ack := AckBtn, FbTime := T#2s);
M103(Start := Btn3, Stop := StopAll, Feedback := Aux3, Ack := AckBtn, FbTime := T#5s);

K101     := M101.Run;
K102     := M102.Run;
AnyFault := M101.Alarm OR M102.Alarm OR M103.Alarm;

Three instances, each with its own timer and its own fault latch. Fix the logic once in the block and all thirty motors are fixed.

Call every instance every scan

An instance only advances when it is called. Put M101(...) inside an IF that is sometimes skipped and its internal timer freezes, leaving the fault stuck on a stale state. Call all instances every scan and steer behaviour through the inputs.

Read the outputs after the call

M101(Start := Btn1, ...);
K101 := M101.Run;      (* correct: this scan's value *)

Read M101.Run before the call and you get last scan's value. Not always wrong, but a one-scan lag that is painful to explain inside a sequence.

VAR_IN_OUT

VAR_INPUT copies a value in, VAR_OUTPUT copies one out. VAR_IN_OUT gives the block the variable itself: it reads and writes it, and the change shows up in the original.

FUNCTION_BLOCK FB_RunHours
VAR_INPUT
  Running : BOOL;
END_VAR
VAR_IN_OUT
  Hours : REAL;      (* an hours counter the program owns and the block updates *)
END_VAR

Use it when the block must update something large or retained that lives outside it: a run-hours total, a logging buffer. Do not use it to save a line. A plain output is clearer, and VAR_IN_OUT hides who writes what.

Not runnable in the lab

The lab does not support declaring a FUNCTION_BLOCK. The lab program below writes the same logic inline with a TON for a single motor, so you can watch the seal-in, the feedback check and the fault latch work.