UT_EVENT_LOG — Event log: what happened, and when

Keeps the last N events (trips, stops, end reasons) with their time, newest
first, so a technician can read "what happened overnight" on the HMI or over SCADA,
also for the hours the comms were down. Feed it the records' stopReason,
lastFault and trips, or any event pulse of your own. It can keep the log over a
power cut.

An event is codes, not words: its stop reason (UT_STOP), its fault (UT_FAULT)
and a code of your own (INT). The HMI or SCADA shows the words
(UT_STOP_TEXT and UT_STATUS_TEXT give them for
a simple display). You size the storage: the block uses the Buffer and Sources
arrays you declare.

Pins

Record UT_EVENT_LOG_DATA

Slot UT_EVENT

UT_EVENT_SRC (code, stop, fault, count, newPrev, seen) is the block's
memory of each source; don't write it.

How it works

• Call it once per source per scan, all calls on the same instance, Buffer,
  Sources, Saved and Data, each with its own Src (as
  UT_MSG_QUEUE). Give each call its own unconditional rung in
  Ladder or FBD. The order of the calls is the order of events that come in the same
  scan.
• A call logs one event when, for its source:
  • New has a rising edge, or
  • Code changes to a value other than 0, Stop to a reason other than
    UT_STOP_NONE, or Fault to a fault other than UT_F_NONE, or
  • Count changes (a trip counter: every trip is logged, also the same one again).
• One of these in a call gives one event, with the call's Code, Stop and Fault.
• A pin a call leaves unwired never takes another call's value: the block sets its
  pins back to their defaults after each call.
• What a source shows at its first call after a power-up is its starting point,
  not an event (as a command never acts on the first scan). The power-up event
  (source 0, no codes) marks that moment.
• Newest first: the first element of Buffer is the newest event; a new one
  moves the others down, and a full log drops the oldest (counted in lost).
• Kept over a power cut (retained TRUE and saveEvery above 0): Saved gets
  a copy of the log. The first event after a quiet spell (no copy for saveEvery) is
  copied at once, with any others of the same scan; later ones wait until
  saveEvery has passed since that copy, so a burst of events writes the
  controller's storage once. The power-up event is copied at once and starts no
  wait (one copy per power-up), so the first trip after a power cut is kept at once
  too. At power-up the log is read back from Saved, with a new power-up event on top,
  and the running numbers carry on. With the default 12 h an event after the first
  of a busy spell can be lost by a power cut within 12 h; a shorter saveEvery keeps
  more but writes the storage more often (see
  conventions).
• Not kept (the default, or saveEvery T#0s): the log starts empty at every
  power-up (with the power-up event if logPowerUp), and Saved is not touched.
• cmdClear empties the log and, when kept, Saved at once.
• The block is called many times a scan; NewEvent stays on for the rest of the
  scan in which an event came, and cmdClear and the copy act once per scan.

Using it

(* Saved is declared RETAIN, the same size as Log *)
Ev(Code := 0, Stop := Pump1.stopReason, Src := 1, Clock := Sched.Data.localTime,
   Buffer := Log, Sources := EvSrc, Saved := LogSaved, Data := EvCfg);
Ev(Fault := Pump1.lastFault, Count := Pump1.trips, Src := 2, Clock := Sched.Data.localTime,
   Buffer := Log, Sources := EvSrc, Saved := LogSaved, Data := EvCfg);
Ev(Stop := Valve1.stopReason, Src := 3, Clock := Sched.Data.localTime,
   Buffer := Log, Sources := EvSrc, Saved := LogSaved, Data := EvCfg);

with Log : ARRAY[1..20] OF UT_EVENT; EvSrc : ARRAY[1..3] OF UT_EVENT_SRC; EvCfg : UT_EVENT_LOG_DATA := (retained := TRUE); and
VAR RETAIN LogSaved : ARRAY[1..20] OF UT_EVENT; END_VAR. Wire Code in at least
one call (0 when you have no code of your own): the editor's check wants a
block's first input assigned.