RD Controls Design No. 87.0

An Overview of the Epicure Alarm Subsystem

D.S. Baddorf, E.J. Dambik, F.J. Nagy, T.M. Watts

Introduction:

Alarm Control Program:

• A control program will be provided which will allow a user to specify a device to be monitored, a min/max readback value (or nominal/tolerance), and an FTD at which the monitoring is to take place.
• The control program will allow for a list of devices whose monitoring can be turned on or off together. Lists will also be able to reference other lists (lists of lists).
• The control program will communicate these setup values in alarm state blocks (see section ) to the actual Alarm Manager Process (AMP) using normal DAR calls.
• Any programs which wish to read alarm information can access the alarm state blocks via normal DAR calls.

Alarm Display Program:

• A display program will be provided to display alarms on supported terminals and workstations.
• The Alarm Display Program will be customizable by alarm category field, to allow the user to display only those alarm categories of concern to him.

Alarm Manager Process (AMP):

• The AMP is a VAX process, perhaps to be run on a dedicated Front End node. It supervises alarm monitoring in the Alarm Monitoring Task (AMT).
• The AMP maintains a disk file of current alarm state blocks as sent by the alarm control program, and sends the needed part of the alarm state block down to the appropriate AMT.
• The AMP receives ``raw'' alarm report from AMTs.
• The AMP passes ``raw'' alarm reports on to a Master ARD which resides on the same node as the AMP.
• Cryo Front Ends will each have an AMP.
• The AMP will talk to the AMT in the Data Acquisition Engine using QVI and Common Memory, with separate queues from those used for the normal data acquisition system (future implementation).

Alarm Monitoring Task (AMT):

• The AMT performs the actual alarm monitoring.
• Alarms will initially be monitored by an AMT subtask on the VAX within the AMP (first implementation).
• AMT tasks will eventually be shared with lower level devices or processes (DAE 386, smart module?).
• Synthetic devices will be always handled by a VAX based AMT subtask, in both current and future implementations.
• A VAX based AMT acquires data via normal DAR/DAS channels.
• A ``raw'' alarm report is issued whenever a monitored device (analog or digital) changes state. Alarm reports indicate either a going-bad alarm or a going-good alarm. There is a field in the alarm report which indicates which case is occurring (see section ).

Alarm Report Distributor (ARD):

• Master ARDs run on any node with an AMP. They perform master processing on all ``raw'' alarm/event reports before shipping them out to Secondary ARDs.
• Secondary ARDs run on every node which wishes to display alarm reports. They communicate with the application programs displaying alarms on that node.

Master ARD:

• A Master ARD receives ``raw'' alarm reports from the AMP with which it shares a node.
• A Master ARD receives ``raw'' event reports from many sources (VAX level, other program error messages, etc).
• A Master ARD processes these ``raw'' alarm and event reports further. It ``cooks'' them. It talks to the OA Database, and adds to the reports:
  • device name
  • logging enable flag
  • display text
  • category number
  • priority
  • override (DI,PI)
• A Master ARD breaks down digital alarm reports into one alarm report for each bit which has changed state. One ``raw'' alarm report will come in when the current status bitstring (ANDed with a mask of those bits which are to be monitored) does not match the same masked bitstring from the previous state (i.e. some bit of status has changed). The Master ARD sends out a ``cooked'' alarm report for each bit which has changed state (and is being monitored). In this way, the display text sent with the ``cooked'' report can be specific to each bit.
• A Master ARD sends ``cooked'' alarm reports to the ARD process on every other node which is interested in alarms. These are Secondary ARDs, and other Master ARDs.
• All Master ARDs are interconnected and pass messages among themselves.
• ``Cooked'' alarm reports are sent out in groups (packetized) in order to ease network traffic.

Secondary ARDs:

• A master ARD also acts as a secondary ARD for any display tasks running on the same node with it.
• Secondary ARDs receive ``cooked'' alarm reports asynchronously, via DECNET.
• Secondary ARDs maintain a mailbox link with any display tasks on its node, and use these mailboxes to pass ``cooked'' alarm reports to requesting applications.
• Secondary ARDs can perform filtering of the alarm reports by category field, sending to each application only those reports which fall within its field of interest.
• ``Cooked'' alarm reports, which are received by the Secondary ARD in packets of several at a time, are separated and sent individually to display applications.

Alarm Structures:

Alarm State Blocks are used to control and record the state of the alarm monitoring of any device. Alarm Report Blocks are used to report devices which are going into or out of an alarm condition. The include file containing these structures, ALARM.H, follows.

/* ALARMS.H
 Definitions of alarm message formats to be passed between the various parts
 of the alarm system.
 */
#ifndef FTD_K_IMMEDIATE     
#include "epicure_inc:ftd.h"
#endif
#ifndef DB_M_DISPLAY_LOG
#include "epicure_inc:dbuser.h"
#endif

/* 
 ALARM REPORT BLOCK HEADER - alarm signal report block header
 for a device reading or event.
 */

struct ARBhdr {
    unsigned short length;		/* Length in bytes */
    variant_union {
	unsigned short flags;		/* Flag bits */
	variant_struct {
	    unsigned hi	: 1;		/* Readback > Max */
	    unsigned lo	: 1;		/* Readback < Min */
	    unsigned bad : 1;		/* Device in alarm */
	    unsigned cooked : 1;	/* Cooked report */
	    unsigned event : 1;		/* Event report */
	    } flag_bit_fields;
	} flag_bits_overlay;
    int clinks;				/* Time of alarm */
    variant_union {
	unsigned int dipi;		/* Device index/Property index */
        variant_struct {
	    unsigned di : 24;		/* Device index */
	    unsigned pi : 8;		/* Property index */
	    } di_pi_fields;
	} dev_descrip_overlay;
    };

/* 
 ALARM REPORT BLOCK for an ANALOG VALUE - communication block signalling a
 condition change (going into or out of tolerance) for an analog device reading
 or event. 
 */

struct ARB_ANALOG_VALUE {
    struct ARBhdr header;		/* Report header information */
    variant_union {
	int raw;			/* Current unscaled reading */
	float scaled;			/* Current scaled reading */
	} reading;
    struct DB_DISPLAY display;		/* DB display info for cooked reports */
    };

/*  
 ALARM REPORT BLOCK for a BINARY STATUS - communication block signalling
 a condition change (state of a scanned bit) for an digital device reading or
 event. 
 */

struct ARB_BINARY_STATUS {
    struct ARBhdr header;		/* Report header information */
    variant_union {
	struct {			/* RAW state information */
	    unsigned int current[2];	/* Current digital reading */
	    unsigned int previous[2];	/* Previous state digital reading */
	    } raw_state;
	struct {			/* COOKED state information */
	    unsigned int bitno;		/* Bit number for changed state */
	    struct DB_DISPLAY display;	/* DB display info for cooked reports */
	    } cooked_state;
	} states_overlay;
    };

/*  
 ALARM STATE BLOCK ANALOG - alarm monitoring state block header 
 for a device reading or event. 
 */

struct ASBhdr {
    variant_union {
	unsigned int dipi;		/* Device index/Property index */
        variant_struct {
	    unsigned di : 24;		/* Device index */
	    unsigned pi : 8;		/* Property index */
	    } di_pi_fields;
	} devdescrip_overlay;
    struct FTD ftd;			/* Time of alarm scan */
    variant_union {
	unsigned short flags;		/* Flag bits */
	variant_struct {
	    unsigned hi	: 1;		/* Readback > Max */
	    unsigned lo	: 1;		/* Readback < Min */
	    unsigned bad : 1;		/* Device in alarm */
	    unsigned clear : 1;		/* Clear alarm state */
	    unsigned scanned : 1;	/* Enable alarm scan */
	    } flag_bit_fields;
	} flag_bits_overlay;
    struct {
	unsigned char needed;		/* Failures needed to report alarm */
	unsigned char now;		/* Current number of failures */
	} tries;			/* Number of reading failures */
    };

/*   
 ALARM STATE BLOCK for ANALOG READING - communication block used to read
 or set the state of alarm monitoring for an analog device reading or event.  
 */

struct ASB_ANALOG_VALUE {
    struct ASBhdr header;		/* Alarm state header information */
    struct {
	unsigned int min;		/* Minimum (lo) raw value to scan for */
	unsigned int max;		/* Maximum (hi) raw value to scan for */
	} value;
    };

/*  
 ALARM STATE BLOCK for a BINARY STATUS - communication block used to
 read or set the state of alarm monitoring for an digital device reading 
 or event. 
 */

struct ASB_BINARY_STATUS {
    struct ASBhdr header;		/* Alarm state header information */
	struct {			/* RAW state information */
	    unsigned int nominal[2];	/* Normal digital reading bit states */
	    unsigned int scanned[2];	/* Bit mask to OR out relevant bits */
	    } state;
    };

Keywords: defaults, logical

Distribution: normal