504 lines
14 KiB
Plaintext
504 lines
14 KiB
Plaintext
#*************************************************************************
|
|
# Copyright (c) 2002 The University of Chicago, as Operator of Argonne
|
|
# National Laboratory.
|
|
# Copyright (c) 2002 The Regents of the University of California, as
|
|
# Operator of Los Alamos National Laboratory.
|
|
# EPICS BASE is distributed subject to a Software License Agreement found
|
|
# in file LICENSE that is included with this distribution.
|
|
#*************************************************************************
|
|
|
|
=title Array Analog Output (aao)
|
|
|
|
The array analog output record type is used to write array data. The array data
|
|
can contain any of the supported data types. The record is in many ways similar to
|
|
the waveform record but outputs arrays instead of reading them. It also allows the
|
|
device support to allocate the array storage.
|
|
|
|
=recordtype aao
|
|
|
|
=cut
|
|
|
|
include "menuFtype.dbd"
|
|
|
|
menu(aaoPOST) {
|
|
choice(aaoPOST_Always,"Always")
|
|
choice(aaoPOST_OnChange,"On Change")
|
|
}
|
|
|
|
recordtype(aao) {
|
|
|
|
=head2 Parameter Fields
|
|
|
|
The record-specific fields are described below, grouped by functionality.
|
|
|
|
=head3 Scan Parameters
|
|
|
|
The array analog output record has the standard fields for specifying under what
|
|
circumstances the record will be processed. These fields are listed in L<Scan
|
|
Fields>. In addition, L<Scanning Specification> explains how these fields are
|
|
used. I/O event scanning is only available when supported by device support.
|
|
|
|
=head3 Write Parameters
|
|
|
|
These fields are configurable by the user to specify how and where to the record
|
|
writes its data. The OUT field determines where the array analog output writes its
|
|
output. It can be a hardware address, a channel access or database link, or a
|
|
constant. Only in records that use soft device support can the OUT field be a
|
|
channel access link, a database link, or a constant. Otherwise, the OUT field must
|
|
be a hardware address. See L<Address Specification> for information on the format
|
|
of hardware addresses and database links.
|
|
|
|
=head4 Fields related to array writing
|
|
|
|
The DTYP field must contain the name of the appropriate device support module. The
|
|
values in the array referenced by are written to the location specified in the OUT
|
|
field. (If the OUT link is a constant, no data are written.) NELM specifies the
|
|
maximum number of elements that the array can hold, while FTVL specifies the data
|
|
type of the elements.
|
|
|
|
=fields DTYP, OUT, NELM, FTVL
|
|
|
|
=head4 Possible data types for FTVL
|
|
|
|
=menu menuFtype
|
|
|
|
=head3 Operator Display Parameters
|
|
|
|
These parameters are used to present meaningful data to the operator. They
|
|
display the value and other parameters of the waveform either textually or
|
|
graphically.
|
|
|
|
=head4 Fields related to I<Operator Display>
|
|
|
|
EGU is a string of up to 16 characters describing the units that the array data
|
|
measures. It is retrieved by the C<<< get_units >>> record support routine.
|
|
|
|
The HOPR and LOPR fields set the upper and lower display limits for array
|
|
elements referenced by the VAL field. Both the C<<< get_graphic_double >>> and
|
|
C<<< get_control_double >>> record support routines retrieve these fields.
|
|
|
|
The PREC field determines the floating point precision with which to display the
|
|
array values. It is used whenever the C<<< get_precision >>> record support
|
|
routine is called.
|
|
|
|
See L<Fields Common to All Record Types> for more on the record name (NAME) and
|
|
description (DESC) fields.
|
|
|
|
=fields EGU, HOPR, LOPR, PREC, NAME, DESC
|
|
|
|
|
|
=head3 Alarm Parameters
|
|
|
|
The array analog output record has the alarm parameters common to all record
|
|
types.
|
|
|
|
=head3 Monitor Parameters
|
|
|
|
These parameters are used to determine when to send monitors placed on the VAL
|
|
field. The APST and MPST fields are a menu with choices "Always" and "On
|
|
Change". The default is "Always", thus monitors will normally be sent every time
|
|
the record processes. Selecting "On Change" causes a 32-bit hash of the VAL
|
|
field buffer to be calculated and compared with the previous hash value every
|
|
time the record processes; the monitor will only be sent if the hash is
|
|
different, indicating that the buffer has changed. Note that there is a small
|
|
chance that two different value buffers might result in the same hash value, so
|
|
for critical systems "Always" may be a better choice, even though it re-sends
|
|
duplicate data.
|
|
|
|
=head4 Record fields related to I<Monitor Parameters>
|
|
|
|
=fields APST, MPST, HASH
|
|
|
|
=head4 Menu choices for C<APST> and C<MPST> fields
|
|
|
|
=menu aaoPOST
|
|
|
|
=head3 Run-time Parameters
|
|
|
|
These parameters are used by the run-time code for processing the array analog
|
|
output record. They are not configured using a configuration tool. Only the VAL
|
|
field is modifiable at run-time.
|
|
|
|
VAL references the array where the array analog output record stores its data. The
|
|
BPTR field holds the address of the array.
|
|
|
|
The NORD field holds a counter of the number of elements that have been written to
|
|
the output,
|
|
|
|
=fields VAL, BPTR, NORD
|
|
|
|
The following fields are used to operate the array analog output record in the
|
|
simulation mode. See L<Simulation Mode> for more information on the simulation
|
|
mode fields.
|
|
|
|
=fields SIOL, SIML, SIMM, SIMS
|
|
|
|
=begin html
|
|
|
|
<br>
|
|
<hr>
|
|
<br>
|
|
|
|
=end html
|
|
|
|
=head2 Record Support
|
|
|
|
=head3 Record Support Routines
|
|
|
|
=head4 init_record
|
|
|
|
static long init_record(aaoRecord *prec, int pass)
|
|
|
|
If device support includes C<init_record()>, it is called.
|
|
|
|
Checks if device support allocated array space. If not, space for the array is
|
|
allocated using NELM and FTVL. The array address is stored in the record.
|
|
|
|
This routine initializes SIMM with the value of SIML if SIML type is CONSTANT
|
|
link or creates a channel access link if SIML type is PV_LINK. VAL is likewise
|
|
initialized if SIOL is CONSTANT or PV_LINK.
|
|
|
|
This routine next checks to see that device support is available and a device
|
|
support write routine is defined. If either does not exist, an error message is
|
|
issued and processing is terminated
|
|
|
|
=head4 process
|
|
|
|
static long process(aaoRecord *prec)
|
|
|
|
See L</"Record Processing"> section below.
|
|
|
|
=head4 cvt_dbaddr
|
|
|
|
static long cvt_dbaddr(DBADDR *paddr)
|
|
|
|
This is called by dbNameToAddr. It makes the dbAddr structure refer to the
|
|
actual buffer holding the result.
|
|
|
|
=head4 get_array_info
|
|
|
|
static long get_array_info(DBADDR *paddr, long *no_elements, long *offset)
|
|
|
|
Obtains values from the array referenced by VAL.
|
|
|
|
=head4 put_array_info
|
|
|
|
static long put_array_info(DBADDR *paddr, long nNew)
|
|
|
|
Writes values into the array referenced by VAL.
|
|
|
|
=head4 get_units
|
|
|
|
static long get_units(DBADDR *paddr, char *units)
|
|
|
|
Retrieves EGU.
|
|
|
|
=head4 get_prec
|
|
|
|
static long get_precision(DBADDR *paddr, long *precision)
|
|
|
|
Retrieves PREC if field is VAL field. Otherwise, calls C<<< recGblGetPrec() >>>.
|
|
|
|
=head4 get_graphic_double
|
|
|
|
static long get_graphic_double(DBADDR *paddr, struct dbr_grDouble *pgd)
|
|
|
|
Sets the upper display and lower display limits for a field. If the field is VAL
|
|
the limits are set to HOPR and LOPR, else if the field has upper and lower
|
|
limits defined they will be used, else the upper and lower maximum values for
|
|
the field type will be used.
|
|
|
|
Sets the following values:
|
|
|
|
upper_disp_limit = HOPR
|
|
lower_disp_limit = LOPR
|
|
|
|
=head4 get_control_double
|
|
|
|
static long get_control_double(DBADDR *paddr, struct dbr_ctrlDouble *pcd)
|
|
|
|
Sets the upper control and the lower control limits for a field. If the field is
|
|
VAL the limits are set to HOPR and LOPR, else if the field has upper and lower
|
|
limits defined they will be used, else the upper and lower maximum values for
|
|
the field type will be used.
|
|
|
|
Sets the following values
|
|
|
|
upper_ctrl_limit = HOPR
|
|
lower_ctrl_limit = LOPR
|
|
|
|
=head3 Record Processing
|
|
|
|
Routine process implements the following algorithm:
|
|
|
|
=over
|
|
|
|
=item 1.
|
|
|
|
Check to see that the appropriate device support module exists. If it doesn't,
|
|
an error message is issued and processing is terminated with the PACT field
|
|
still set to TRUE. This ensures that processes will no longer be called for this
|
|
record. Thus error storms will not occur.
|
|
|
|
=item 2.
|
|
|
|
Call device support write routine C<write_aao>.
|
|
|
|
=item 3.
|
|
|
|
If PACT has been changed to TRUE, the device support read routine has started
|
|
but has not completed writing the new value. In this case, the processing
|
|
routine merely returns, leaving PACT TRUE.
|
|
|
|
=item 4.
|
|
|
|
Check to see if monitors should be invoked.
|
|
|
|
=over
|
|
|
|
=item *
|
|
|
|
Alarm monitors are invoked if the alarm status or severity has changed.
|
|
|
|
=item *
|
|
|
|
Archive and value change monitors are invoked if APST or MPST are Always or if
|
|
the result of the hash calculation is different.
|
|
|
|
=item *
|
|
|
|
NSEV and NSTA are reset to 0.
|
|
|
|
=back
|
|
|
|
=item 5.
|
|
|
|
Scan forward link if necessary, set PACT FALSE, and return.
|
|
|
|
=back
|
|
|
|
=begin html
|
|
|
|
<br>
|
|
<hr>
|
|
<br>
|
|
|
|
=end html
|
|
|
|
=cut
|
|
|
|
include "dbCommon.dbd"
|
|
field(VAL,DBF_NOACCESS) {
|
|
prompt("Value")
|
|
asl(ASL0)
|
|
special(SPC_DBADDR)
|
|
pp(TRUE)
|
|
extra("void * val")
|
|
#=type DOUBLE[]
|
|
#=read Yes
|
|
#=write Yes
|
|
}
|
|
field(PREC,DBF_SHORT) {
|
|
prompt("Display Precision")
|
|
promptgroup("80 - Display")
|
|
interest(1)
|
|
prop(YES)
|
|
}
|
|
field(OUT,DBF_OUTLINK) {
|
|
prompt("Output Specification")
|
|
promptgroup("50 - Output")
|
|
interest(1)
|
|
}
|
|
field(EGU,DBF_STRING) {
|
|
prompt("Engineering Units")
|
|
promptgroup("80 - Display")
|
|
interest(1)
|
|
size(16)
|
|
prop(YES)
|
|
}
|
|
field(HOPR,DBF_DOUBLE) {
|
|
prompt("High Operating Range")
|
|
promptgroup("80 - Display")
|
|
interest(1)
|
|
prop(YES)
|
|
}
|
|
field(LOPR,DBF_DOUBLE) {
|
|
prompt("Low Operating Range")
|
|
promptgroup("80 - Display")
|
|
interest(1)
|
|
prop(YES)
|
|
}
|
|
field(NELM,DBF_ULONG) {
|
|
prompt("Number of Elements")
|
|
promptgroup("30 - Action")
|
|
special(SPC_NOMOD)
|
|
interest(1)
|
|
initial("1")
|
|
}
|
|
field(FTVL,DBF_MENU) {
|
|
prompt("Field Type of Value")
|
|
promptgroup("30 - Action")
|
|
special(SPC_NOMOD)
|
|
interest(1)
|
|
menu(menuFtype)
|
|
}
|
|
field(NORD,DBF_ULONG) {
|
|
prompt("Number elements read")
|
|
special(SPC_NOMOD)
|
|
}
|
|
field(BPTR,DBF_NOACCESS) {
|
|
prompt("Buffer Pointer")
|
|
special(SPC_NOMOD)
|
|
interest(4)
|
|
extra("void * bptr")
|
|
}
|
|
field(SIML,DBF_INLINK) {
|
|
prompt("Simulation Mode Link")
|
|
promptgroup("90 - Simulate")
|
|
interest(1)
|
|
}
|
|
field(SIMM,DBF_MENU) {
|
|
prompt("Simulation Mode")
|
|
special(SPC_MOD)
|
|
interest(1)
|
|
menu(menuYesNo)
|
|
}
|
|
field(SIMS,DBF_MENU) {
|
|
prompt("Simulation Mode Severity")
|
|
promptgroup("90 - Simulate")
|
|
interest(2)
|
|
menu(menuAlarmSevr)
|
|
}
|
|
field(SIOL,DBF_OUTLINK) {
|
|
prompt("Simulation Output Link")
|
|
promptgroup("90 - Simulate")
|
|
interest(1)
|
|
}
|
|
field(OLDSIMM,DBF_MENU) {
|
|
prompt("Prev. Simulation Mode")
|
|
special(SPC_NOMOD)
|
|
interest(4)
|
|
menu(menuSimm)
|
|
}
|
|
field(SSCN,DBF_MENU) {
|
|
prompt("Sim. Mode Scan")
|
|
promptgroup("90 - Simulate")
|
|
interest(1)
|
|
menu(menuScan)
|
|
initial("65535")
|
|
}
|
|
field(SDLY,DBF_DOUBLE) {
|
|
prompt("Sim. Mode Async Delay")
|
|
promptgroup("90 - Simulate")
|
|
interest(2)
|
|
initial("-1.0")
|
|
}
|
|
%#include "callback.h"
|
|
field(SIMPVT,DBF_NOACCESS) {
|
|
prompt("Sim. Mode Private")
|
|
special(SPC_NOMOD)
|
|
interest(4)
|
|
extra("epicsCallback *simpvt")
|
|
}
|
|
field(MPST,DBF_MENU) {
|
|
prompt("Post Value Monitors")
|
|
promptgroup("80 - Display")
|
|
interest(1)
|
|
menu(aaoPOST)
|
|
}
|
|
field(APST,DBF_MENU) {
|
|
prompt("Post Archive Monitors")
|
|
promptgroup("80 - Display")
|
|
interest(1)
|
|
menu(aaoPOST)
|
|
}
|
|
field(HASH,DBF_ULONG) {
|
|
prompt("Hash of OnChange data.")
|
|
interest(3)
|
|
}
|
|
}
|
|
|
|
=head2 Device Support
|
|
|
|
=head3 Fields Of Interest To Device Support
|
|
|
|
Each array analog output record record must have an associated set of device
|
|
support routines. The primary responsibility of the device support routines is to
|
|
write the array data value whenever C<write_aao()> is called. The device support
|
|
routines are primarily interested in the following fields:
|
|
|
|
=fields PACT, DPVT, NSEV, NSTA, OUT, NELM, FTVL, BPTR, NORD
|
|
|
|
=head3 Device Support Routines
|
|
|
|
Device support consists of the following routines:
|
|
|
|
=head4 report
|
|
|
|
long report(int level)
|
|
|
|
This optional routine is called by the IOC command C<dbior> and is passed the
|
|
report level that was requested by the user.
|
|
It should print a report on the state of the device support to stdout.
|
|
The C<level> parameter may be used to output increasingly more detailed
|
|
information at higher levels, or to select different types of information with
|
|
different levels.
|
|
Level zero should print no more than a small summary.
|
|
|
|
=head4 init
|
|
|
|
long init(int after)
|
|
|
|
This optional routine is called twice at IOC initialization time.
|
|
The first call happens before any of the C<init_record()> calls are made, with
|
|
the integer parameter C<after> set to 0.
|
|
The second call happens after all of the C<init_record()> calls have been made,
|
|
with C<after> set to 1.
|
|
|
|
=head4 init_record
|
|
|
|
init_record(dbCommon *precord)
|
|
|
|
This routine is optional. If provided, it is called by the record support
|
|
C<init_record()> routine.
|
|
|
|
=head4 get_ioint_info
|
|
|
|
long get_ioint_info(int cmd, dbCommon *precord, IOSCANPVT *ppvt)
|
|
|
|
This routine is called by the ioEventScan system each time the record is added
|
|
or deleted from an I/O event scan list. cmd has the value (0,1) if the
|
|
record is being (added to, deleted from) an I/O event list. It must be
|
|
provided for any device type that can use the ioEvent scanner.
|
|
|
|
=head4 write_aao
|
|
|
|
long write_aao(dbCommon *precord)
|
|
|
|
This routine must write the array data to output. It returns the following values:
|
|
|
|
=over
|
|
|
|
=item *
|
|
|
|
0: Success.
|
|
|
|
=item *
|
|
|
|
Other: Error.
|
|
|
|
=back
|
|
|
|
=head3 Device Support For Soft Records
|
|
|
|
The C<<< Soft Channel >>> device support module is provided to write values to
|
|
other records and store them in arrays. If OUT is a constant link, then
|
|
C<write_aao()> does nothing. In this case, the record can be used to hold arrays
|
|
written via dbPuts. If OUT is a database or channel access link, the array value
|
|
is written to the link. NORD is set to the number of items in the array.
|
|
|
|
|
|
If the OUT link type is constant, then NORD is set to zero.
|
|
|
|
=cut
|