intro_acl
The Accelerator Command Language (ACL) is a simple scripting
language for reading and setting ACNET devices. This is intended
to be very simple to use, and as a result there are many synonyms
for commands as well as qualifiers. Hopefully, if you enter
commands that make sense to you, they will make sense to ACL.
Devices are specified by their names with a couple of additions.
You can specify the property with the second character in the name.
A colon (:) or question mark (?) indicates the reading property,
while an underscore (_) indicates the setting property, a pipe (|)
character indicates basic status, an ampersand (&) character
indicates basic control, an at (@) character indicates the analog
alarm, and a dollar sign ($) character indicates the digital alarm
property. An array index can be specified by appending the value
to the end of the device name enclosed in square brackets "[n]".
The array index value can be an integer constant, a variable,
a symbol, or a device reading. A range of array elements can be
specified in a similar way with the notation "[start:end]". If the
ending array index is omitted, the maximum array element for that
property is used. You can also specify what portion of a property
you want in bytes with the notation "{offset:length}". You can
further specify a device with the use of qualifiers.
Examples of device qualifiers:
/property=reading -> select the reading property (default)
/reading -> select the reading property (default)
/ftd=ftd_1hz -> set the reading frequency to 1 Hz
/ftd_1hz -> set the reading frequency to 1 Hz
/ftd_oneshot -> request a one shot reading
/ftd=evt02 -> request data on TCLK event 02
/ftd=2hz -> request data at a 2 Hz frequency
/raw_ftd=60 -> request data at a 1 Hz frequency
/event='p,1000,true' -> request data at a 1 Hz frequency
/period=2 -> request data every 2 seconds
/period_msec=500 -> request data every 500 milliseconds
/frequency=2 -> request data at a 2 Hz frequency
/length=n -> request n bytes of data
/num_elements=n -> request n array elements of data
/num_values=n -> request n array elements of data
/atomic_size -> request the atomic size for that property
/all -> request the maximum size for that property
/maximum_size -> request the maximum size for that property
/offset=n -> request data starting at a byte offset of n
/index=n -> request array element n (starts at 0)
/array_index=n -> request array element n (starts at 0)
/raw -> request raw (binary) data
/scaled -> request scaled data (default)
/primary -> request data in primary units
/volts -> request data in primary units
/common -> request scaled data (default)
/string -> request string data
/name -> request device name text
/text -> request device descriptive text
/bit_status -> request device bitwise status
/state -> request state text data (state devices only)
/state_text -> request state text data (state devices only)
/date -> request date string (raw data assumed to be
local time in seconds since Jan 1, 1970)
/date_gmt -> request date string (raw data assumed to be
GMT (UTC) time in seconds since Jan 1, 1970)
/date_clinks -> request date string (raw data assumed to be
local time in seconds since Jan 1, 1972)
/acnet_error -> request ACNET error string (raw data assumed
to be an ACNET error code)
/node -> request ACNET node string (raw data assumed
to be an ACNET node value)
/ip_address -> request IP address string
/ip_name -> request IP name string
/source=dp -> display data from the accelerator (default)
/source=db -> display data from the database
/source=sr:1 -> display data from save/restore file 1
/source=sda:1:"Inject Protons":1:ColliderShot -> display data from SDA
file 1, case Inject Protons,
subcase (set) 1,
usage ColliderShot
/source=dl:"01-JAN-2000 01:00" -> display data from a Lumberjack at
January 1, 2000 at 0100
/source=memory -> display data from a memory pool
Valid property strings:
reading -> reading property
read -> reading property
prread -> reading property
setting -> setting property
set -> setting property
prset -> setting property
basic_status -> basic status property
status -> basic status property
sts -> basic status property
prbsts -> basic status property
basic_control -> basic control property
control -> basic control property
cntl -> basic control property
prbctl -> basic control property
analog_alarm -> analog alarm property
analog -> analog alarm property
aa -> analog alarm property
pranab -> analog alarm property
digital_alarm -> digital alarm property
digital -> digital alarm property
da -> digital alarm property
prdabl -> digital alarm property
The fields of analog and digital alarm blocks can be
referenced through standard C structure notation with a
dot ('.') separating the device name and the alarm block
field name.
Valid alarm block field names:
.min[imum] -> analog alarm minimum value
.max[imum] -> analog alarm maximum value
.analog_nominal -> analog alarm nominal value
.tol[erance] -> analog alarm tolerance value
.nom[inal] -> digital alarm nominal value
.mask -> digital alarm mask value
.alarm_enable -> alarm enable status
.alarm_status -> alarm good/bad status
.tries_needed -> alarm tries needed
.tries_now -> alarm tries now
.alarm_ftd -> alarm scan rate
.abort -> alarm abort capability
.abort_inhibit -> alarm abort inhibit status
.limit_type -> analog alarm limit type
.flags -> alarm flags field
Some commands allow the caller to access multiple devices
through the specification of a family device or through the
use a list specifiers. List specifiers can be either an
ASCII text file name or a device database search specifier.
Valid list specifiers:
file={file name} -> read devices from ASCII file
db={table name} -> read devices from a database table
containing device indices
dbname={table name} -> read devices from a database table
containing device names
dbquery={SQL string} -> list all devices from an
arbitrary database query
on tables containing device
indices
dbqueryname={SQL string} -> list all devices from an
arbitrary database query
on tables containing device
names
devices='{device},{device}' -> access an explicit list of devices
node={node name} -> access all devices from the
requested node
node={wildcard node name} -> access all devices from nodes whose
names match the requested string
node={node}/crate={crate} -> access all devices from the
requested crate
node={node}/crate={crate}/slot={slot} -> access all devices from the
requested slot
node={node}/madc={madc number} -> access all devices from the
requested MADC
node={node}/property={property} -> access all devices from a node which
have the requested property
trunk={trunk number} -> access all devices from the
requested ACNET trunk
name={string} -> access all devices containing a
particular string in their name
full_name={string} -> access all devices containing a
particular string in their full name
name={string}/type={type} -> access all devices containing a
particular string in their name
with a given device type
family={string} -> access all devices in a family device
text={string} -> access all devices containing a
particular string in their
descriptive text
full_text={string} -> access all devices containing a
particular string in their
full descriptive text
device_type={type} -> access all devices with the
requested device type
device_type={type}/node={node} -> access all devices with the
requested device type from a
given node
device_type={type}/name={string} -> access all devices with the
requested device type which
a given string in their name
device_class={class} -> access all devices with the
requested device class
device_class={class}/node={node} -> access all devices with the
requested device class from
a given node
save_list={list} -> access all devices from the
requested save list
user_save_list={list} -> access all devices from the
requested user save list (usl)
driver={driver} -> access all devices with the
requested CAMAC driver type
driver={driver}/node={node} -> access all devices with the
requested CAMAC driver type
from a given node
virtual_machine={device} -> access all devices related to
a requested state device
units={units_text} -> access all devices having a given
units text
alarm_list={list} -> access all devices from the
requested alarm list
user_alarm_list={system[\list]} -> access all devices from the
requested user alarm list (ual)
alarm_handler={handler} -> access all devices having a
given alarm handler
controlling_device={device} -> access all devices controlled by
a given device
expr[ession]={string} -> access all devices containing
a given string in its
reading expression
expr_device={device} -> access all devices containing
a given device in its
reading expression
ssdn={SSDN pattern} -> access all devices having an SSDN
matching a pattern
download_list={node}[\{crate}] -> access all devices from the
requested node download list (dl)
save_file={file_number} -> list all devices saved in a
particular save file (sf)
sda_case={usage}[:{case}] -> list all devices configured for a
particular SDA case
sda_set={file}:{case}:{set} -> list all devices saved in a
particular SDA set
logger_list={node}[:{list}] -> list all devices on a given
data logger list
siblings={device} -> list all siblings descended from
a given device
param_page={page}[:{subpage}] -> list all devices on a given
parameter page
wg_list={list_name} -> list all devices from a
waveform generator list (I14/I15)
console_class={class} -> list all devices which are
settable by a console class
user={user name} -> list all devices modified by a
given user
user_created={user name} -> list all devices created
by a given user
Generic device names can also be entered wherever a valid ACNET
device name can be. These names have the form "G:DEVnnn". When
the code is parsed, the generic device names are replaced with
actual ACNET device names which are passed by the caller to
the parsing routine. The "nnn" is the index (starting at 0) of
the name in the caller's device list that should be used to
take the place of that generic device name.
Lists of devices can also be established with the device_list
command. These lists can be accessed through pseudo device
names of the form "Q:xxxxxx" where xxxxxx is the name given
the list.
There is also the concept of a "changeable" device. A changeable
device has a name of the form "G:CDVnn". The actual device that
is accessed by one of these pseudo devices can be set by the
"change_device" command.
Generic strings can also be entered for values in most commands.
These replacement strings are similar to the replacement device
names and have the form "stringnnn". The "nnn" is the index
(starting at 0) of the string in the caller' substitute string
list that should be used to take the place of that generic string.
This supports more generic scripts which have parameters that can
be changed from one execution of the script to the next. If a
replacement string is to be interpreted as a string by the script,
it should be enclosed in a string() function (ex. string(string0)).
Values in the script can be stored in either variables which are
destroyed when the script has completed or symbols which exist
across script executions until they are deleted by a call to
'acl_delete_symbol' or the calling program exits. Symbol values
can be read by the calling program through the routine
'acl_read_symbol_c' and set through 'acl_set_symbol_c'. Symbols
must begin with a "$" character. There are sixteen special symbols
which are created and updated by ACL itself. The symbol "$_value"
typically contains the value of the last assignment. The symbol
"$_status" typically contains the status of the last ACL command
executed. The "$_string" symbol contains the last string produced
by one of the string manipulation commands. The symbol
"$_error_string" contains the current verbose error string that will
ultimately be returned to the ACL caller unless an error handler is
invoked. The symbol named "$_error_status" is only updated when an
error handler is called and contains the error that caused the error
handler to be invoked. The symbol $_last_error_status is also
updated in an error handler and stores the last error status seen.
The symbol "$_error_device" contains the device index for the last
device having a read, set, or database access error. The symbol
$_last_error_device contains the device index for the previous
device having a read, set, or database access error. The symbol
$_error_count indicates how many times the current device has
returned the present error status. The symbol $_pending_count
indicates how many consecutive times the last read device has
returned a status of pending. The symbol named $_return_value
contains the value returned by the last return statement. This
symbol is only valid during the execution of the statement following
the return. The symbol named $_eof is a logical value indicating
whether or not the most recent input request resulted in an end of
file error. The symbol named $_proc_status contains the status from
the last call_proc statement. The symbol named "$_num_device_args"
contains the number of device arguments passed to the current script.
The symbol named "$_num_string_args" contains the number of string
arguments passed to the current script. The symbol "$_num_devices"
contains the number of devices processed by the last command.
Finally, the symbol named "$_script_name" contains the name of the
currently running script. Both variables and symbols contain single
values by default, but arrays of both types can be created through
the use of the "declare" command. Array indices use the common
square bracket style used by C. Array indices can be specified by
integer constants, variables, symbols, or device values.
Multiple commands can be entered on a single line by separating
them with semicolons (;) or a a single command may span several
lines by inserting a back slash (\) at the end of each line to
be continued. Otherwise, it is assumed that each source line
defines one command. In any case, a single command line cannot
exceed 256 characters including white spaces. Comments can be
inserted anywhere in a line indicated by an exclamation point (!)
or a pound (#) character. All text in a line following a comment
character is ignored.
Several commands plus some data source specifications take
dates as arguments. The default format for dates is
"dd-mmm-yyyy[ hh:mm]". There are also several special
formats. The "past" format specifies a time a certain
interval before the present time (e.g. "past_30min"). The
"store" format indicates the date that a particular shot
was started (e.g. "store_1000"). The "event" format indicates
the last time a given event occurred (e.g. "event_4e").
There are also various special date keywords. These include
"now" (present time), "today" (the start of the present day),
"yesterday" (midnight yesterday), "tomorrow" (midnight
tomorrow), "this_hour" (start of the present hour), "last_hour"
(start of the last hour), "this_week" (the start of this week),
"this_year" (the start of this year), plus several others.
There are also a few reserved strings that have special
interpretations:
console_number -> returns the caller's console number
slot -> returns the caller's console slot
node_name -> returns the caller's ACNET node name
node_number -> returns the caller's ACNET node (integer)
my_node_number -> returns the caller's ACNET node number
my_trunk -> returns the caller's ACNET trunk number
console_class -> returns the caller's console class mask
is_mcr_class -> returns 1 if the console is MCR class
user_name -> returns the current user name
process_name -> returns the current process name
executable_name -> returns the current executable image name
full_executable_name -> returns the current executable image name
including the path
program_name -> returns the current program name
generic_program_name -> returns the generic name of the
current program
page -> returns the current page name
clib_date -> returns the date of the current CLIB
{console color strings} -> return the corresponding color value
date (now) -> returns the current date
time -> returns the current time of day
current_time -> returns the current time of day
clinks[_now] -> returns the current date in clinks
ctime_now -> returns the current date in C time
gmt_now -> returns the current date in GMT (UTC) seconds
today -> returns the time for today at midnight
yesterday -> returns the time for yesterday at midnight
tomorrow -> returns the time for tommorow at midnight
this_minute -> returns the time for the start of the
present minute
last_minute -> returns the time for the start of the
last minute
next_minute -> returns the time for the start of the
next minute
this_hour -> returns the time for the start of the
present hour
last_hour -> returns the time for the start of the
last hour
next_hour -> returns the time for the start of the
next hour
this_shift -> returns the time for the start of the
present shift
last_shift -> returns the time for the start of the
last shift
next_shift -> returns the time for the start of the
next shift
this_week -> returns the time for the start of the
present week
last_week -> returns the time for the start of the
last week
next_week -> returns the time for the start of the
next week
this_month -> returns the time for the start of the
present month
last_month -> returns the time for the start of the
last month
next_month -> returns the time for the start of the
next month
this_year -> returns the time for the start of the
present year
last_year -> returns the time for the start of the
last year
next_year -> returns the time for the start of the
next year
script_time -> returns the total script execution time
delta_script_time -> returns the script execution time since
the last reference to 'delta_script_time'
{ACNET error strings} -> return the corresponding ACNET error value
version -> returns the current ACL version
last_big_save -> last big save file number
last_shot_save -> last shot save file number
last_circular_save -> last circular save file number
current_store -> current store number
last_store -> last store number
current_pbar_shot -> current pbar shot number
last_pbar_shot -> last pbar shot number
current_recycler_shot -> current Recycler shot number
last_recycler_shot -> last Recycler shot number
mdat_time -> current time transmitted over MDAT
newline -> newline string (useful in print command)
tab -> tab string (useful in print command)
current_output -> returns the value of standard output
current_error -> returns the value of standard error
on_linux -> returns a value of 1 if ACL is being
executed on Linux, and value of 0 otherwise
ACL expressions contain values which may be constants, variables
or symbols, and device values. They support operators which
include the normal arithmetic operators (+, -, *, and /) as well
as '^' for exponentiation and '%' for integer modulus. They also
support logical operators '||' or 'or' and '&&' or 'and'. They
support the bitwise operators '|', '&', and 'xor'. In addition,
the special device-related operators 'is', 'is not', 'has', and
'doesnt have' are also supported. A number of instrinsic functions
which are listed below are also supported. Expressions are used
in the assignment, if, elseif, while, and do_while commands.
Arithmetic operators:
addition : '+', 'plus'
increment : '++'
subtraction : '-', 'minus'
decrement : '--'
multiplication : '*', 'times'
division : '/'
integer modulus: '%'
remainder : '%%'
exponentiation : '^', '**'
left shift : '<<'
right shift : '>>'
Bitwise operators:
or : '|', 'bitor'
exclusive or : 'xor'
and : '&', 'bitand'
invert : '~', 'compl', 'complement'
Logical operators:
or : '||', 'or', '.or.'
exclusive or : '.xor.'
and : '&&', 'and', '.and.'
negate : '!', 'not', '.not.'
Comparison operators:
equals : '=', '==', 'equals', 'eq', '.eq.', 'is equal to'
not equal : '!=', '<>', 'ne', '.ne.', 'is not equal to', 'does not equal'
greater than : '>', 'gt', '.gt.', 'greater than'
greater/equal : '>=', 'ge', '.ge.', 'greater than or equal to'
less than : '<', 'lt', '.lt.', 'less than'
less/equal : '<=', 'le', '.le.', 'less than or equal to'
Special device operators:
is : device is in a particular status (on, off, etc.)
is not : device is NOT in a particular status (on, off, etc.)
has : device has a particular type of database information
doesnt have : device doesn't have a particular type of database information
Intrinsic functions:
Arithmetic functions:
log : base 10 log
ln : natural log
sqrt : square root
sin : sine
cos : cosine
tan : tangent
asin : arc sine
acos : arc cosine
atan : arc tangent
atan2 : arc tangent of the quotient of the arguments
sinh : hyperbolic sine
cosh : hyperbolic cosine
tanh : hyperbolic tangent
hypot : square root of the sum of the squares of the arguments
round : round
ceil : smallest integer greater than or equal to its argument
floor : largest integer less than or equal to its argument
trunc : truncate
fmod : remainder of the arguments
fract : fractional component
abs : absolute value
min : minimum of two values
max : maximum of two values
exp : base e exponentiation (e^n)
Bitwise functions:
or : bitwise or
and : bitwise and
xor : bitwise exclusive or
lshft : circular left shift
rshft : circular right shift
bit : bit test
Array value functions:
sum : sum of an array of values
mean : mean of an array of values
median : median of an array of values
minimum : minimum of an array of values
maximum : maximum of an array of values
range : range of an array of values
stddev : standard deviation of an array of values
rms : RMS of an array of values
variance : varianace of an array of values
identical : checks to see if all values in an array are identical
String funcions:
head : returns the beginning of a string
tail : returns the end of a string
substring : returns a substring of a string
strncmp : compares the first n characters of two strings
trim : removes leading and trailing blanks from a string
toupper : converts a string to upper case
tolower : converts a string to lower case
capitalize : capitalizes the first character in each word of a string
tostring : converts a value to its corresponding string
to_trimmed_string: converts a value to a string with no spaces
string_length : returns the length of a string
pos : pads with spaces/truncates a string to a specified
length
pad : pads a string with a specified character to a specified
length
hex : returns a value as a hexadecimal string
Miscellaneous functions:
exists : determines if a device or variable/symbol exists
sizeof : returns the number of elements in a device or variable
condif : returns the second argument if the first has a value
of true or the third argument if it has a value of false
scondif : returns the second argument as a string if the first
has a value of true or the third argument as a string
if it has a value of false
lor : logical or
land : logical and
random : returns pseudo random numbers from 0 to 2^31 - 1
prec : output precision (eg. prec(value,fraction_digits))
event_occurred : determines if a clock event has occurred
time_since_event: returns the elapsed time since an event has occurred
event_date : returns the date in clinks when an event last occurred
timer : returns the current value of a timer
node : converts a node name to a value
error : converts an ACNET error string to a value
device : converts an ACNET device to a value
name : returns a device name string
full_name : returns a device full name string
text : returns a device descriptive text string
full_text : returns a device full descriptive text string
units : returns a device units string
state_text : returns the text for the current state of a state device
bit_text : returns the descriptive text for a specified bit
bit_data_text : returns the data text for a specified bit
analog_alarm_text : returns the analog alarm text for a device
analog_alarm_priority : returns the analog alarm priority for a device
digital_alarm_text : returns the digital alarm text for a device
user_alarm_list: returns the state of a user alarm list
(enabled, bypassed, or empty) and can be used in an
"is" expression
settings_are_enabled : determines if settings are enabled
(supports optional device name argument)
A block of code can be marked so that it is always executed
regardless of errors or program execution flow. This is called
an "always" block. It must be situated at the end of the script,
and it is started with a label statement of "always". The always
block cannot contain on_error, exit, gosub, goto, or return
commands. The always block never affects the overall returned
status from the script.
-------------------------------------------------------------------------------
Alphabetic list of ACL commands:
-------------------------------------------------------------------------------
acnet_request - send an ACNET request
activate - activate a device
alarm_limit - read or set analog alarm limits
alarm_log - display alarm history log
assignment - assign a value to a variable or symbol
beam_switch - read the status of a beam switch
break - jump out of a simple program loop
bypass - bypass an alarm
call_proc - execute a non-ACL procedure
camac - execute individual CAMAC commands
ch13_message - display the current channel 13 message
change_device - change the device that a changeable device refers to
check_status - check the basic status of devices
clib_info - display CLIB information
cnswin - move, resize, or iconify a console window
cns_message - send a console message
comment_char - disable a comment character
compare - compare device readings
console_info - display console information
continue - jump to the bottom of a simple program loop
copy - copy one device to another
copy_variable - copy a value or an array of values into a variable
cpld_log - display CPLD program log entries
crate - access CAMAC crate information
data_event - set the default data event for future data requests
data_source - establish a data source for future data requests
dbset - set the database setting record for an ACNET device
deactivate - deactivate a device
declare - declare a variable or symbol
decrement - decrement an ACNET device
delete - delete cached database information or a file
delete_cache - delete cached database information
delta_set - apply a delta to the setting of an ACNET device
device_arg - specify a description and/or default value for a device
device_list - specify a list of devices for processing
digital_control - send a basic control command to a device
disable - disable a device, a clock event, or another parameter
download - download the most recent database setting for a device
downtime_log - display downtime log entries
do_while - begin a do/while loop
else - implement default case for a an if/elseif block
elseif - execute simple nested conditional structure
enable - enable a device, a clock event, or another parameter
endif - end a simple conditional structure
endloop - end a simple program loop
endwhile - end a simple while loop
end_do_while - end a do/while loop
error_text - display ACNET error text
event_info - display clock event information
event_log - display event log entries
exit - end the script
exitloop - jump out of a simple program loop
fft - perform an FFT on a set of points
file_info - display flat file information
fill - fill a device setting with a value
find_program - find running instances of a program
fit - perform a polynomial, exponential, or Gaussian fit on a set of points
fshare_info - display Filesharing file information
ftd - set the default Frequency Time Descriptor for future data requests
ftp - copy a file or files using file transfer protocol (FTP)
ftp_read - read ACNET device using the fast time plot protocol
gas - read or write GAS commands
gosub - jump to a labeled subroutine
goto - jump to a given label
gpib - execute GPIB commands
host_request - pass a request to the host program
if - execute simple conditional structure
image_draw - display a graphic image
increment - increment an ACNET device
input - define a data input
list - list device parameters
list_strings - displays control system lists of strings
lock - lock a script
logger_get - read datalogger values
log_device - log a device value
loop - execute a simple program loop
madc - access MADC information
mail - mail a file to a user
mdat_info - display MDAT frame information
negative - set an ACNET device to negative polarity
node - perform operations on an ACNET node
node_info - display ACNET node information
nominal_mask - read or set digital alarm nominals/masks
off - turn off an ACNET device
off_list - turn off a list of ACNET devices
on - turn on an ACNET device
on_error - establish an error handling routine
on_list - turn on a list of ACNET devices
output - define the output for future commands
path - set the default file path
polarity - set the polarity of an ACNET device
positive - set an ACNET device to positive polarity
print - print a line of output
program_info - display program information
program_log - display program (shared) log entries
program_status - retrieve the status of a program instance
ramp - ramp a setting to a desired value
read - read an ACNET device and display the value
read_dir - read the contents of a file directory
read_field - read an individual field from an ACNET device
read_file - read all or part of a file
read_struct - read an ACNET device structure
reboot - reboot an ACNET node
reset - reset an ACNET device
reset_list - reset a list of ACNET devices
resize - resize (reallocate) an array variable or symbol
restore - restore an ACNET device setting
retry - retry a command which has invoked an error handler
return - return from a subroutine or error handler
run - run a program
save - save devices in a save/restore file
sda_config - display SDA configuration information
sda_dir - display SDA directory information
search - search device readings for a pattern
set - set an ACNET device
set_field - set an individual field in an ACNET device
set_list - set a list of ACNET devices
set_struct - set an ACNET device structure
setting_log - display setting log entries
shot_log - make an entry in the Shot Scrapbook
show - display database information for a device
slot - access CAMAC slot information
snap_read - read ACNET device using the snapshot plot protocol
sort - sort an array of values or an array device
sql - send a database modification command or read database values
sr_dir - display save/restore file directory information
sr_set - set the value for an ACNET device in a save file
state_log - display state log entries
stats - perform simple statistics on device readings or a variable
step_motor - set a stepping motor
string_arg - specify a description and/or default value for a string
str_case - change the case of a string
str_cat - concatenate two strings together
str_compare - compare two strings
str_convert - convert a string value
str_copy - copy one string to another
str_find - search for one string in another
str_format - build a formatted string
str_length - return the length of a string
str_replace - replace a substring with another
str_split - split a string into substrings
str_tail - extract the tail of a string
str_trim - trim spaces from a string
substring - extract a substring from a string
switch_info - display network switch information
system - execute a system command
table_device - read or set table device values
tcp_request - send a TCP/IP request
timeout - set data acquisition timeout values
timer - determine time intervals
timer_event - read or set timer events
tlg_info - read information about events generated by the TLG
toggle - toggle a status attribute of an ACNET device
trigger - trigger a clock event
turn - turn an ACNET device on or off
unescape - replace escape characters in a string
unlock - unlock a script
url_display - display a URL in a web browser
user_info - display console user or console node information
version - display the version of ACL that is being run
wait - wait for a period of time, an event, a state, or a device
web_log - make an entry in a web-based log book
while - execute simple while loop
-------------------------------------------------------------------------------
ACL Command help:
-------------------------------------------------------------------------------
read : read an ACNET device and display the value
read[/{qualifier...}][/output={spec}] {device}{[n]}[/{qualifier...}]
This command outputs the name of the requested device, it's current
value, and the corresponding units text. One or more elements of
an array device can be displayed. Note that a device index can be
supplied rather than a device name. This command also supports
an array index notation which allows you to specify the beginning
and ending array indices (ex. read t:ha11[3:5]). This command
also supports family devices and list specifiers (see above).
Examples of reading command qualifiers:
scaled -> read the scaled data (default)
raw -> read the raw data in hex
raw_bs -> read the raw data in hex (byte swapped)
raw_ws -> read the raw data in hex (word swapped)
dec[imal] -> read the raw data in decimal
dec_bs -> read the raw data in decimal (byte swapped)
dec_ws -> read the raw data in decimal (word swapped)
primary -> read the data in primary units (volts)
string (ascii) -> read raw data as a string (ASCII)
string_bs -> read raw data as a string (ASCII)
and byte swap it
ascii_no_nulls -> read raw data as a string with embedded
(but not trailing) nulls replaced with
a pipe (|) character
state -> read raw data and display as state text
date -> read raw data and display as a date string
(raw data assumed to be local time in
seconds since Jan 1, 1970)
date_gmt -> read raw data and display as a date string
(raw data assumed to be GMT (UTC) time in
seconds since Jan 1, 1970)
date_clinks -> read raw data and display as a date string
(raw data assumed to be local time in
seconds since Jan 1, 1972)
acnet_error -> read raw data and display as an ACNET
error string
node -> request ACNET node string (raw data assumed
to be an ACNET node value)
property=analog_alarm -> read whether or not the device is in alarm
setting -> read the setting value
ftd_oneshot -> request a one shot reading
length=2 -> request 2 bytes of data
atomic_size -> request the atomic size for this property
maximum_size -> request the maximum size for this property
num_elements=4 -> request 4 values
num_values=4 -> request 4 values
num_elements=all -> request all values for this property
all_elements -> request all values for this property
offset=0 -> request data starting at a byte offset of 0
index=2 -> request data starting at array index 2
array_index=2 -> request data starting at array index 2
bit_status -> request device bitwise status
state_text -> request state text data (state devices only)
source=dp -> display data from the accelerator (default)
source=db -> display data from the database
source=sr:1 -> display data from save/restore file 1
source=sda:1:"Inject Protons":1:ColliderShot -> display data from SDA
file 1, case Inject Protons,
subcase (set) 1,
usage ColliderShot
source=dl:"01-JAN-2000 01:00" -> display data from a Lumberjack at
January 1, 2000 at 0100
source=memory -> display data from a memory pool
family -> read an entire family
whole(all) -> indicates that you want to read the whole
property (only valid when used with 'family')
row -> display values in a single row
column -> display values in a single column
no_name -> don't display device name(s)
nodisplay -> don't display the reading, only errors
waitnew -> wait for a new value to be returned (default)
nowaitnew -> don't wait for a new value to be returned
pendwait -> wait for a nonpending status
ignore_errors -> display the data even if it is in error
num_values={variable} -> saves the number of values read in a variable
values={array variable} -> saves the values read in a variable
dynamic[_arrays] -> dynamically reallocate output value variable
to match the number of values read
output={spec} -> specify output destination
Examples of output specifications:
mail:{user_name} -> send mail to a user
file:{file_name} -> send output to a file
binary:{file_name} -> send output to a binary file
variable:{variable_name} -> send output to a variable
symbol:{symbol_name} -> send output to a symbol
The supported properties for this command are:
reading, setting, basic status, analog alarm, digital alarm
Examples:
read z:acltst
read z:acltst/output=symbol:symbol1
read z:acltst/raw
read z:acltst/source=db
read 27235 ! make reading from device index
read v:cldrst/state
read g:0b29v0/string/all
read t_ha11[3:5] ! read elements 3, 4, and 5
read z:acltst[] ! read an entire array device
read/family/all z:acltsz ! read a family device
read node=tev/crate=A1/prread
read/pendwait m:outtmp/ftd=evt02 ! wait for data on event 02
read m:outtmp/src=sr:last_big_save ! read from last big save
read m:outtmp/src=dl:"01-JAN-2000 01:00" ! read from data logger
read m:outtmp/src=sda:1:"Inject Protons":1:ColliderShot
read m:outtmp.min ! read alarm minimum
Related commands:
set, alarm_limit, nominal_mask, list, show, compare
data_event, ftd, data_source, device_list
-------------------------------------------------------------------------------
set : set an ACNET device
set[/{qualifier}] {device}{[n]}[/{qualifier...}] {constant|variable|symbol}
The constant value is either a numeric constant in the case
of the setting property or a basic control string in the case
of the basic control property. For the setting property,
multiple scaled or raw values can be supplied. If multiple
values are entered, they should be separated by spaces or
commas. If a string value is supplied, it should be enclosed
in either single or double quotes. Setting values can also be
supplied in a delimited text file. This command also supports
an array index notation which allows you to specify the beginning
and ending array indices (ex. set z:acltst[1:2]=13,3.5). This
command also supports family devices and list specifiers (see above).
Use of this command may require special privileges. See Brian
Hendricks (hendricks@fnal.gov) for more information.
Examples of setting command qualifiers:
scaled (common) -> make a scaled (common) setting (default)
raw -> make a raw setting
primary (volts) -> make a setting in primary (volts) units
string -> make a setting with a string
state -> make a setting with state text
(state devices only)
length=2 -> set 2 bytes of data
atomic_size -> set the atomic size for this property
maximum_size -> set the maximum size for this property
num_elements=4 -> set 4 values
num_values=4 -> set 4 values
all -> set all values for this property
all_elements -> set all values for this property
offset=0 -> set data starting at a byte offset of 0
index=2 -> set data starting at array index 2
array_index=2 -> set data starting at array index 2
source=memory -> set data in a memory pool
[alarm_]minimum -> set the analog alarm minimum
[alarm_]maximum -> set the analog alarm maximum
min_max -> set the analog alarm minimum and maximum
analog_nominal -> set the analog alarm nominal
analog_alarm_nominal -> set the analog alarm nominal
[alarm_]tolerance -> set the analog alarm tolerance
nom_tol -> set the analog alarm nominal and tolerance
[alarm_]nominal -> set the digital alarm nominal
[alarm_]mask -> set the digital alarm mask
[alarm_]tries -> set the number of alarm tries
[alarm_]ftd -> set the alarm scan rate (for MOOC devices)
limit_type -> set analog alarm limit type
init_alarm_flags -> initialize alarm display/logging flags
motor -> set a motor device
hex -> setting value is in hexadecimal
decimal -> setting value is in decimal (default)
file -> read setting values from a file
(default file extension is ".dat")
byte_swap -> used with a raw setting to swap the setting
bytes on word boundaries
word_swap -> used with a raw setting to swap the setting
words
family -> set an entire family
Examples of control strings:
reset -> reset device
on -> turn on device
off -> turn off device
toggle_onoff -> toggle on/off status
positive -> set the device to positive polarity
negative -> set the device to negative polarity
toggle_polarity -> toggle polarity
ramp -> set the device to ramp mode
dc -> set the device to DC mode
toggle_rampdc -> toggle ramp/DC mode
enable_alarm -> enable an alarm
bypass_alarm -> bypass an alarm
enable_abort -> enable an alarm abort flag
abort_inhibit -> disable an alarm abort flag
enable_display -> enable an alarm display flag
disable_display -> disable an alarm display flag
enable -> enable a device (frig FSMs and loops only)
disable -> disable a device (frig FSMs and loops only)
activate -> activate a device (frig and GFSDA FSMs only)
deactivate -> deactivate a device (frig and GFSDA FSMs only)
Examples:
set z:acltst 5
set z:acltst $symbol1
set z:acltst/raw 0xA9
set z:acltst=1,2,3,4
set z:acltst[2]/raw 3 4
set z:acltst[3] 'abcd'
set t:ha11 reset
set t:ha11 on
set m@outtmp enable_alarm ! enable analog alarm
set m@outtmp/minimum 32 ! set alarm minimum
set m@outtmp/maximum 100 ! set alarm maximum
set v:cdfmod/state 'Colliding Beams On'
set z:acltst[1:2]=16,3.5
set z:acltst[]=0,16,3.5,11 ! set an entire array
set z:acltst[2:3]=z:aclts3[1:2] ! set multiple array elements
set z:acltst[2:3]=array[1] ! set multiple array elements
set/family z:acltsz[1:2] = 16, 17.5 ! set a family device
set m:outtmp.min = 20 ! set alarm minimum
Related commands:
read, enable, disable, bypass, activate, deactivate
turn, reset, toggle, alarm_limit, nominal_mask
fill, copy, decrement, increment, delta_set, set_field,
device_list
-------------------------------------------------------------------------------
change_device : change the device that a changeable device refers to
change_device[/{qualifier}] {changeable device} [to] {new device}
This command allows the caller to change which actual device
that a "changeable" device actually points to. A changeable
device has a name of the form "G:CDVnn".
Examples of change_device command qualifiers:
{property} -> set the property for the device
property={property} -> set the property for the device
verbose -> display verbose output
Examples:
change_device g:cdv0 to z:acltst
declare str string="m:outtmp"
change_device g:cdv0 to str
Related commands:
device_list, read, set
-------------------------------------------------------------------------------
decrement : decrement an ACNET device
decrement {device}{[n]}{/qualifier...} {constant|variable|symbol}
This command decrements a device's setting by a specified amount.
This command is only valid for a device's setting property.
This command also supports family devices and list specifiers
(see above). Use of this command may require special privileges.
See Brian Hendricks (hendricks@fnal.gov) for more information.
Examples of decrement command qualifiers:
family -> decrement an entire family
verbose -> generate verbose output
Examples:
decrement z:acltst 2
decrement z:acltst $symbol1
decrement name=z:aclts% .1
Pseudonyms: dec
Related commands:
increment, delta_set, set, device_list
-------------------------------------------------------------------------------
delete_cache : delete cached database information
delete_cache [{device}]
This command will delete cached database information. If a
device name is specified, only information for that device
will be deleted. Otherwise, all cached database information
will be deleted.
(Note: Arguments enclosed in square brackets are optional.)
Examples:
delete_cache
delete_cache z:acltst
Related commands:
delete
-------------------------------------------------------------------------------
delta_set : apply a delta to the setting of an ACNET device
delta_set {device}{[n]}{/qualifier...} {constant|variable|symbol}
This command applies a specified delta to a device's setting.
This command is only valid for a device's setting property.
This command also supports family devices and list specifiers
(see above). Use of this command may require special privileges.
See Brian Hendricks (hendricks@fnal.gov) for more information.
Examples of delta_set command qualifiers:
family -> apply a delta to an entire family
verbose -> generate verbose output
Examples:
delta_set z:acltst 2
delta_set z:acltst $symbol1
delta_set name=z:aclts% -.1
Pseudonyms: deltaset
Related commands:
increment, decrement, set, device_list
-------------------------------------------------------------------------------
device_list : specify a list of devices for processing
device_list/[/{qualifier}] {name} [{list}={list_specifier}]
This command allows the user to specify a list of devices
which can later be accessed one at a time through a pseudo
device name of "Q:xxxxxx" where xxxxxx is the name given
to the list. The lists of devices are established through
the use of any of the standard ACL list specifiers. List
names must consist of from 1 to 6 characters. This command
also allows the caller to increment or decrement through
the list. Care should be taken in the use of device lists
to make sure to specify property values in the event that
the list is used in a context where properties must be
specified. Either specify the property explicitly in this
command or choose the mutable_property option so that the
property can be selected by the context.
Examples of device_list qualifiers:
create -> creates a device list
inc[rement] -> increments to point to the next device
in the list
dec[rement] -> decrements to point to the previous device
in the list
rewind -> resets the list pointer to the beginning
of the list
set_index={index} -> sets the list pointer to a specific index
size (length) -> outputs the number of devices in the list
delete -> deletes an existing device list
{property} -> specifies the default property for devices
in the list
property={property} -> specifies the default property for devices
in the list
event={event value} -> specifies a time since event timer
autoinc -> specifies that the list pointer should be
automatically incremented each time the
list is accessed
dont_cull -> don't cull devices from the list which
don't have the requested property
cache={prop1,prop2,...} -> establish properties which should have
their database information cached for
more efficient execution
sort={sort type} -> sort the devices in a particular order
(name_asc, name_desc, di_asc, or di_desc)
output={spec} -> specify output destination
Special device qualifiers for device_list:
mutable_property -> indicates that the properties used for
the devices can be changed at use time
mutable_length_offset -> indicates that the lengths and/or offsets
used for the devices can be changed at
use time
mutable_data_source -> indicates that the data source used for
the devices can be changed at use time
mutable_access_type -> indicates that the access type used for
the devices can be changed at use time
Examples:
device_list/create fg devices='z_aclts2,z_aclts3' ! create list
loop 2 cnt=0
print name(q:fg) ' = ' q:fg
device_list/inc fg
endloop
device_list/create/read fg name=m:out% ! create list
device_list/size/output=variable:list_length fg
loop list_length
logger_get/start=thismin/node=fastest q:fg
device_list/inc fg
endloop
device_list/create/read fg file=device_file.txt ! create list from file
Related commands:
read, set, show, logger_get, ramp
-------------------------------------------------------------------------------
download : download the most recent database setting for a device
download[/{qualifier}] {device}{[n]}[/{qualifier...}]
This command will restore a setting value to the value it
has in the settings database. This command can be used for the
setting, analog alarm, and digital alarm properties. This command
also supports an array index notation which allows you to specify
the beginning and ending array indices (ex. download z:acltst[1:2]).
This command also supports family devices and list specifiers
(see above). Use of this command may require special privileges.
See Brian Hendricks (hendricks@fnal.gov) for more information.
Examples of download command qualifiers:
family -> download an entire family
verbose -> generate verbose output
init -> initial download (used for alarm blocks only to
make sure that they start out disabled and with
display enabled)
Examples:
download z:acltst ! download the entire property
download z:acltst[1:2]
download m@outtmp ! download an analog alarm block
download node=pnut01
download/init m@outtmp ! download initialized analog alarm
download/init t$ha11 ! download initialized digital alarm
Related commands:
restore, set, device_list
-------------------------------------------------------------------------------
increment : increment an ACNET device
increment {device}{[n]}{/qualifier...} {constant|variable|symbol}
This command increments a device's setting by a specified amount.
This command is only valid for a device's setting property.
This command also supports family devices and list specifiers
(see above). Use of this command may require special privileges.
See Brian Hendricks (hendricks@fnal.gov) for more information.
Examples of increment command qualifiers:
family -> increment an entire family
verbose -> generate verbose output
Examples:
increment z:acltst 2
increment z:acltst $symbol1
increment name=z:aclts% .1
Pseudonyms: inc
Related commands:
decrement, delta_set, set, device_list
-------------------------------------------------------------------------------
fill : fill a device setting with a value
fill[/{qualifier}] {device}{[n]}[/{qualifier...}] {constant|variable|symbol}
This command will fill the requested number of values in a
setting property with the same value. This command also supports
an array index notation which allows you to specify the beginning
and ending array indices (ex. fill z:acltst[1:2]=16.1).
This command also supports family devices and list specifiers
(see above). Use of this command may require special privileges.
See Brian Hendricks (hendricks@fnal.gov) for more information.
Examples of fill command qualifiers:
scaled (common) -> make a scaled (common) setting (default)
raw -> make a raw setting
primary (volts) -> make a setting in primary (volts) units
length=2 -> set 2 bytes of data
atomic_size -> set the atomic size for this property
maximum_size -> set the maximum size for this property
num_elements=4 -> set 4 values
num_values=4 -> set 4 values
all -> set all values for this property
all_elements -> set all values for this property
offset=0 -> set data starting at a byte offset of 0
index=2 -> set data starting at array index 2
array_index=2 -> set data starting at array index 2
hex -> setting value is in hexadecimal
decimal -> setting value is in decimal (default)
Examples:
fill z:acltst 5
fill z:acltst $symbol1
fill z:acltst/raw 0xA9
fill z:acltst[2]/raw 3
fill z:acltst[2]/num_values=2 16
fill z:acltst[1:2]=16.1
Related commands:
set, copy
-------------------------------------------------------------------------------
digital_control : send a basic control command to a device
digital_control[/{qualifier}] {device|devicelist} {command}
This command supports sending any basic control command to
one or more devices. It is only valid for a device's basic
control property. This command also supports family devices
and list specifiers (see above). Use of this command may
require special privileges. See Brian Hendricks
(hendricks@fnal.gov) for more information.
Examples of digital_control command qualifiers:
family -> turn on an entire family
verbose -> generate verbose output
Examples:
digital_control i:q701 on
Related commands:
on, on_list, off, off_list, reset, reset_list, positive, negative,
polarity, set, turn, toggle, device_list
-------------------------------------------------------------------------------
negative : set an ACNET device to negative polarity
negative[/{qualifier}] {device}{[n]}{/qualifier...}
This command supports setting one or more devices to negative
polarity. It is only valid for a device's basic control property.
This command also supports family devices and list specifiers
(see above). Use of this command may require special privileges.
See Brian Hendricks (hendricks@fnal.gov) for more information.
Examples of negative command qualifiers:
check[_status] -> only set the device to a negative polarity
if it's not already in negative polarity
family -> set an entire family to negative polarity
verbose -> generate verbose output
Examples:
negative i:q701
Related commands:
polarity, positive, on, off, reset, set, turn, toggle, digital_control,
device_list
-------------------------------------------------------------------------------
off : turn off an ACNET device
off[/{qualifier}] {device}{[n]}{/qualifier...}
This command supports turning off one or more devices. It is only
valid for a device's basic control property. This command also
supports family devices and list specifiers (see above).
Use of this command may require special privileges. See Brian
Hendricks (hendricks@fnal.gov) for more information.
Examples of off command qualifiers:
check[_status] -> only turn off the device if it's not off
family -> turn off an entire family
verbose -> generate verbose output
Examples:
off i:q701
Related commands:
off_list, on, on_list, reset, reset_list, positive, negative,
polarity, set, turn, toggle, digital_control, device_list
-------------------------------------------------------------------------------
off_list : turn off a list of ACNET devices
off_list[/{qualifier}] {device}|device_list={list}{[n]}{/qualifier...}
This command supports turning off one or more devices. This command
supports family devices and list specifiers (see above). Use of this
command may require special privileges. See Brian Hendricks
(hendricks@fnal.gov) for more information.
Examples of off_list command qualifiers:
family -> turn on an entire family
verbose -> generate verbose output
Examples:
device_list/create devs devices='z:acltst,z:aclts5,z:aclts6'/control
off_list device_list=devs
Related commands:
off, on, on_list, reset_list, positive, negative, polarity, set,
turn, toggle, digital_control, device_list
-------------------------------------------------------------------------------
on : turn on an ACNET device
on[/{qualifier}] {device}{[n]}{/qualifier...}
This command supports turning on one or more devices. It is only
valid for a device's basic control property. This command also
supports family devices and list specifiers (see above).
Use of this command may require special privileges. See Brian
Hendricks (hendricks@fnal.gov) for more information.
Examples of on command qualifiers:
check[_status] -> only turn on the device if it's not on
reset -> reset the device before giving it an on command
family -> turn on an entire family
verbose -> generate verbose output
Examples:
on i:q701
Related commands:
on_list, off, off_list, reset, reset_list, positive, negative,
polarity, set, turn, toggle, digital_control, device_list
-------------------------------------------------------------------------------
on_list : turn on a list of ACNET devices
on_list[/{qualifier}] {device}|device_list={list}{[n]}{/qualifier...}
This command supports turning on one or more devices. This command
supports family devices and list specifiers (see above). Use of this
command may require special privileges. See Brian Hendricks
(hendricks@fnal.gov) for more information.
Examples of on_list command qualifiers:
reset -> reset the device before giving it an on command
family -> turn on an entire family
verbose -> generate verbose output
Examples:
device_list/create devs devices='z:acltst,z:aclts5,z:aclts6'/control
on_list device_list=devs
Related commands:
on, off, off_list, reset_list, positive, negative, polarity, set,
turn, toggle, digital_control, device_list
-------------------------------------------------------------------------------
polarity : set the polarity of an ACNET device
polarity[/{qualifier}] {pos|neg} {device}{[n]}{/qualifier...} {pos|neg}
This command supports setting the polarity of one or more devices.
The specific command value can be placed before or after the device.
This command is only valid for a device's basic control property.
This command also supports family devices and list specifiers
(see above). Use of this command may require special privileges.
See Brian Hendricks (hendricks@fnal.gov) for more information.
Examples of polarity command qualifiers:
toggle -> toggle the polarity
family -> control an entire family
verbose -> generate verbose output
Examples:
polarity t:ozf positive
polarity positive t:ozf
polarity t:ozf negative
polarity negative t:ozf
polarity toggle t:ozf
Related commands:
positive, negative, turn, on, off, set, toggle, reset, digital_control,
device_list
-------------------------------------------------------------------------------
positive : set an ACNET device to positive polarity
positive[/{qualifier}] {device}{[n]}{/qualifier...}
This command supports setting one or more devices to positive
polarity. It is only valid for a device's basic control property.
This command also supports family devices and list specifiers
(see above). Use of this command may require special privileges.
See Brian Hendricks (hendricks@fnal.gov) for more information.
Examples of positive command qualifiers:
check[_status] -> only set the device to a positive polarity
if it's not already in positive polarity
family -> set an entire family to positive polarity
verbose -> generate verbose output
Examples:
positive i:q701
Related commands:
polarity, negative, on, off, reset, set, turn, toggle, digital_control,
device_list
-------------------------------------------------------------------------------
ramp : ramp a setting to a desired value
ramp[/time={secs}] {device}{[n]}[/{qualifier...}] {constant|variable|symbol}
This command will ramp a setting value from its present value
to the requested value. If no ramp duration is specified,
a ramp duration of zero will be used. In this case, the ramp
command functions like the set command. This command can also
be used to ramp a setting using a fixed step size and delay
between settings. This command can also be configured for
ramping back to the original value. Use of this command may
require special privileges. See Brian Hendricks (hendricks@fnal.gov)
for more information.
Examples of ramp command qualifiers:
time={secs} -> ramp duration in seconds
duration={secs} -> ramp duration in seconds
step_size={size} -> constant ramp step size
step_delay={msecs} -> delay between successive settings in
milliseconds
flattop_length={secs} -> number of seconds to wait before ramping
back to the original setting value
ramp_back -> ramp back to the original setting value
max_step_size={maxstep} -> maximum allowable step size
(only used in ramp by time method)
monitor_device={device} -> device to monitor the status of the ramp
(primarily useful for certain types of
stepper motor devices)
scaled (common) -> make a scaled (common) setting (default)
raw -> make a raw setting
primary (volts) -> make a setting in primary (volts) units
offset=0 -> set data starting at a byte offset of 0
index=2 -> set data starting at array index 2
array_index=2 -> set data starting at array index 2
Examples:
ramp/time=2 z:acltst 5
ramp/time=2 z:acltst to 5
ramp z:acltst = 5 /time=2
ramp/time=2 z:acltst $symbol1
ramp/duration=2 z:acltst/raw 0xA9
ramp/duration=2 z:acltst[2] 16
ramp/duration=2/flattop_length=1 z:acltst[2] 16
ramp/step_size=0.01 z:aclts3 to 2
Related commands:
increment, decrement, delta_set, set, device_list
-------------------------------------------------------------------------------
read_field : read an individual field from an ACNET device
read_field[/{qualifier}] {device}{[n]}[/{qualifier...}]
This command is primarily used to read fields in a device's
setting property that are otherwise indivisible by the control
system. An example of this would be a time table entry in a
waveform generator. This command discards the portion of the
setting field that is not being read. This command also supports
an array index notation which allows you to specify the beginning
and ending array indices (ex. read_field z:acltst[1:2]). This
command also supports family devices and list specifiers (see above).
Examples of read_field command qualifiers:
scaled (common) -> make a scaled (common) reading
(default and only available if field offset
is zero))
raw -> make a raw reading
(default if field offset is nonzero)
primary (volts) -> make a reading in primary (volts) units
offset={offset} -> field offset in bytes
length={length} -> field length in bytes
source=memory -> read data in a memory pool
hex -> display values in hexadecimal
dec[imal] -> display values in decimal (default)
byte_swap -> used with a raw reading to swap the reading
bytes on word boundaries
word_swap -> used with a raw reading to swap the reading
words
family -> read an entire family
row -> display values in a single row
column -> display values in a single column
nodisplay -> don't display the reading, only errors
waitnew -> wait for a new value to be returned (default)
nowaitnew -> don't wait for a new value to be returned
pendwait -> wait for a nonpending status
timeout={seconds} -> set reading timeout in seconds
ignore_errors -> display the data even if it is in error
read_value={variable} -> variable to hold reading data
dynamic[_arrays] -> dynamically reallocate output data variables
to match the number of values read
output={spec} -> specify output destination
Examples:
read_field/length=2 s_4530t[2]
read_field/offset=2/dec s_4530t[2]
read_field/offset=2/dec s_4530t[2:3] ! read two values
Related commands:
set_field, read, read_struct, set, device_list
-------------------------------------------------------------------------------
read_struct : read an ACNET device structure
read_struct[/{qualifier}] {device}{[n]}[/{qualifier...}]
This command is used to read back ACNET device data as a structure.
The structure of the data can be explicitly defined in the command
itself or a named structure can be specified. This command also
supports an array index notation which allows you to specify the
beginning and ending array indices (ex. read_struct z:acltst[1:2]).
This command also supports family devices and list specifiers
(see above).
Examples of read_struct command qualifiers:
struct[ure]={name} -> specify a named structure
reading={type}={value},... -> reading structure specification
read_string -> read data as a string
reading_length={bytes} -> specified the number of bytes to read
source=memory -> read data in a memory pool
ieee_to_dec -> convert IEEE floats to DEC
hex -> display values in hexadecimal
dec[imal] -> display values in decimal (default)
byte_swap -> used with a raw reading to swap the
reading bytes on word boundaries
word_swap -> used with a raw reading to swap the
reading words
family -> read an entire family
nodisplay -> don't display the reading,
only errors
waitnew -> wait for a new value to be returned
(default)
nowaitnew -> don't wait for a new value to be
returned
pendwait -> wait for a nonpending status
timeout={seconds} -> set reading timeout in seconds
ignore_errors -> display the data even if it is
in error
read_values={var,...} -> variable(s) to hold reading data
(one per field of the structure)
dynamic[_arrays] -> dynamically reallocate output data
variables to match the number
of values read
output={spec} -> specify output destination
Examples:
read_struct/struct=bpm_data r:bp1cov
Related commands:
read_field, read, device_list, set_struct
-------------------------------------------------------------------------------
restore : restore an ACNET device setting
restore {device}{[n]}[/{qualifier...}] [from] {source}[:{arg1}:{arg2}:{arg3}:{arg4}]
This command will restore a setting value to the value it
had in either the database, a save/restore file, an SDA file,
a data logger (Lumberjack), or a memory pool. If no length or
offset is specified, the entire property will be restored.
This command can be used for the setting, basic status,
analog alarm, and digital alarm properties. This command also
supports an array index notation which allows you to specify
the beginning and ending array indices
(e.g.. restore z:acltst[1:2] from db). This command also supports
family devices and list specifiers (see above). Use of this
command may require special privileges. See Brian Hendricks
(hendricks@fnal.gov) for more information.
Type Syntax
---- ------
database db
save/restore sr:{file number}
SDA sda:{file number}:{case}[:{subcase}:{usage}]
data logger dl:{start date}[:{node}:{accuracy in seconds}]
memory memory[:{pool_name|pool_id}]
(Note: Arguments enclosed in square brackets are optional.)
Examples of restore command qualifiers:
family -> restore an entire family
verbose -> generate verbose output
props=all -> restore all restorable properties
props=prop1:prop2:prop3:prop4 -> restore specific properties
save_properties_only -> used in conjunction with "props"
to limit each device to properties
that are indicated in its save
property
motor -> restore a motor's position
ignore_save_info -> ignore any database save information
and perform a default restore
Relevant special constants:
last_linac_save -> newest Linac save file
last_booster_save -> newest Booster save file
last_mi_save -> newest Main Injector save file
last_tev_save -> newest Tevatron save file
last_extbeams_save -> newest external beams save file
last_pbar_save -> newest Pbar save file
last_recycler_save -> newest Recycler save file
last_misc_save -> newest miscellaneous save file
last_big_save -> newest big save file
last_shot_save -> newest shot save file
last_circular_save -> newest circular save file
last_miniboone_save -> newest MiniBooNE save file
Examples:
restore z:acltst from db
restore z:acltst sr:1
restore z:acltst from sda:1:"Inject Protons":1:ColliderShot
restore z:acltst dl:"01-Jan-2000 00:00":fastest:3600
restore z:acltst[1:2] from sr:1
restore/props=all node=pnut01 from sr:last_big_save
restore/props=setting:status node=pnut01 from sr:last_big_save
Related commands:
save, download, copy, set, fill, device_list
-------------------------------------------------------------------------------
save : save devices in a save/restore file
save[/{qualifier}] {file number} ['{title}'] {parameters to save}
This command will save devices in a save/restore file or in a
memory pool. Individual devices, family devices, and/or any of
the list specifications (see above) that ACL supports can be saved.
If there are multiple items to be saved, they should be separated
by commas. Specific save files in the 900, 1100, and 1200 ranges
can not be selected since file numbers in these ranges are
automatically selected by the BIGSAV and SCHSAV processes. If a
title is not specified, a generic title will be used. Use of this
command may require special privileges. See Brian Hendricks
(hendricks@fnal.gov) for more information.
Examples of save command qualifiers:
verbose -> generate verbose output
operator -> save file with operator protection
file={file number} -> specify save file number
title="{title}" -> specify file title
items={item1,item2,...} -> specify items to save
protect={protection} -> specify file protection
(none (default), operator, archive)
memory[={pool}|{id}] -> save values in a memory pool
props=all -> save all savable properties
(memory saves only)
props=prop1:prop2:prop3:prop4 -> save specific properties
(memory saves only)
save_properties_only -> used in conjunction with "props"
to limit each device to properties
that are indicated in its save
property
node={node} -> node to send save request to
wait_for_save -> wait for current save to complete
if one is in progress
no_send -> inhibit the actual save
check_status -> check to see if a save is in progress
($_value will be to a value of 1 if
a save is in progress or a value of
0 otherwise.)
cancel -> cancel the current save
verbose -> display verbose command status
Relevant special constants:
oldest_linac_file -> oldest Linac save file
oldest_booster_file -> oldest Booster save file
oldest_mi_file -> oldest Main Injector save file
oldest_tev_file -> oldest Tevatron save file
oldest_extbeams_file -> oldest external beams save file
oldest_pbar_file -> oldest Pbar save file
oldest_recycler_file -> oldest Recycler save file
oldest_misc_file -> oldest miscellaneous save file
oldest_miniboone_file -> oldest MiniBooNE save file
Examples:
save 821 "test save" z:acltst,z:aclts2
save oldest_booster_file "test save" user_save_list=booster\400_mev\vert
save 821 "test save" node=baker,node=ap1001
save 821 "test save" query=name="m:out%"
save/file=821/title="test save"/items="family=t:horzfg,query='name=t:h*'"
save/memory query='name=t:ha*'
Related commands:
restore, download, set
-------------------------------------------------------------------------------
set_field : set an individual field in an ACNET device
set_field[/{qualifier}] {device}{[n]}[/{qualifier...}] {constant|variable|symbol}
This command is primarily used to set fields in a device's
setting property that are otherwise indivisible by the control
system. An example of this would be a time table entry in a
waveform generator. This command preserves the portion of the
setting field that is not being changed. Multiple scaled or
raw values can be supplied for the setting. If multiple
values are entered, they should be separated by spaces or
commas. Setting values can also be supplied in a delimited
text file. This command also supports an array index notation
which allows you to specify the beginning and ending array indices
(ex. set z:acltst[1:2]=13,3.5). This command also supports family
devices and list specifiers (see above). Use of this command may
require special privileges. See Brian Hendricks (hendricks@fnal.gov)
for more information.
Examples of set_field command qualifiers:
scaled (common) -> make a scaled (common) setting
(default and only available if field offset
is zero))
raw -> make a raw setting
(default if field offset is nonzero)
primary (volts) -> make a setting in primary (volts) units
offset={offset} -> field offset in bytes
length={length} -> field length in bytes
source=memory -> set data in a memory pool
hex -> setting value is in hexadecimal
dec[imal] -> setting value is in decimal (default)
file -> read setting values from a file
(default file extension is ".dat")
byte_swap -> used with a raw setting to swap the setting
bytes on word boundaries
word_swap -> used with a raw setting to swap the setting
words
family -> set an entire family
Examples:
set_field/length=2 s:4530t[2] 5
set_field/offset=2/dec s:4530t[2] 100
set_field/offset=2/dec s:4530t[2] 100, 100 ! set two values
set_field/length=2 s:4530t[2] $symbol1
Related commands:
read_field, set, read, enable, disable, bypass, activate, deactivate
turn, reset, toggle, alarm_limit, nominal_mask
fill, copy, decrement, increment, delta_set, device_list
-------------------------------------------------------------------------------
set_list : set a list of ACNET devices
set_list[/{qualifier}] {device}{[n]}[/{qualifier...}] {constant|variable|symbol}
This command permits the setting of a list of devices
simultaneously. Multiple values (either scaled or raw)
can be set for each device. If multiple values are entered,
they should be separated by spaces or commas. Setting values
can also be supplied in a delimited text file. This command
also supports an array index notation which allows you to
specify the beginning and ending array indices. This command
also supports family devices and list specifiers (see above).
Use of this command may require special privileges. See Brian
Hendricks (hendricks@fnal.gov) for more information.
Examples of set_list command qualifiers:
scaled (common) -> make a scaled (common) setting (default)
raw -> make a raw setting
primary (volts) -> make a setting in primary (volts) units
values_per_device={num} -> specify the number of values to set for
each device
values={val,...} -> specify the setting values
hex -> setting value is in hexadecimal
decimal -> setting value is in decimal (default)
file -> read setting values from a file
(default file extension is ".dat")
byte_swap -> used with a raw setting to swap the setting
bytes on word boundaries
word_swap -> used with a raw setting to swap the setting
words
Examples:
device_list/create devs devices='z:aclts5,z:aclts6,z:aclts7'
declare vals={1,2,3}
set_list device_list=devs vals
device_list/create devs devices='z:aclts5,z:aclts6,z:aclts7'
set_list device_list=devs 1,2,3
Related commands:
set, set_field, read, device_list, declare, fill, copy,
decrement, increment, delta_set
-------------------------------------------------------------------------------
set_struct : set an ACNET device structure
set_struct[/{qualifier}] {device}{[n]}[/{qualifier...}]={{type}={value},...}
This command is used to set ACNET device data as a structure.
The structure of the data can be explicitly defined in the command
itself or a named structure can be specified. This command also
supports an array index notation which allows you to specify the
beginning array index (ex. set_struct r_bp1acq[1]).
This command also supports family devices and list specifiers
(see above).
Examples of set_struct command qualifiers:
struct[ure]={name} -> specify a named structure
setting={{type}={value},...} -> setting structure specification
fill={fill method} -> can be used with a named structure
to initialize the setting buffer
from the device reading or from the
structure default values
reading_fill -> initialize the setting buffer
from the device reading
default_fill -> initialize the setting buffer
from the structure default values
file -> read structure information from
a file
ieee_to_dec -> convert IEEE floats to DEC
dec_to_ieee -> convert DEC floats to IEEE
byte_swap -> swap the setting bytes on word
boundaries
word_swap -> swap the setting words on longword
boundaries
family -> set an entire family
output={spec} -> specify output destination
Examples:
set_struct/struct='recycler bpm acquisition spec'/ieee/word_swap\
/reading_fill g_dev0 = {'arm event'=0x29,'trigger event'=0xda}
set_struct/ieee/word_swap g_dev0 = \
{int=0,int=1,int=2,int=0,int=0,int=0x29,int=0xda,int=0,int=100,\
int=0,float=0.0,int=300} ! use specified data types and values
Related commands:
set_field, set, device_list, read_struct
-------------------------------------------------------------------------------
sort : sort an array of values or an array device
sort[/{qualifier}] {variable|device}{[n]}[/{qualifier...}]
This command is used to sort the values in an array variable or
the values in an array device. Sorts can be either ascending or
descending. For some data types such as device index, node, error,
and event, the sorts can even be done on the ASCII form of the
values (e.g. 27235 -> M:OUTTMP). The sorts are done in place for
variables. For sorts of both variables and devices, the sorted
array can be output to another array variable. This command
also supports an array index notation which allows you to specify
the beginning and ending array indices (ex. sort z:acltst[0:3]).
This command also supports family devices and list specifiers
(see above).
Examples of sort command qualifiers:
asc[ending] -> ascending sort (default)
ascii_asc[ending] -> ascending ASCII sort
desc[ending] -> descending sort
ascii_desc[ending] -> descending ASCII sort
num_values={variable} -> returned number of values value
values={values} -> either the input array variable
or the returned sorted device values
family -> read an entire family
waitnew -> wait for a new value to be returned (default)
nowaitnew -> don't wait for a new value to be returned
pendwait -> wait for a nonpending status
timeout={seconds} -> set reading timeout in seconds
dynamic[_arrays] -> dynamically reallocate output data variables
to match the number of values read
verbose -> verbose output
output={spec} -> specify output destination
Examples:
declare strings string[3]="bob","al","kevin"
sort strings ! array of strings
declare floats float[3]=2,3,1
sort/desc strings ! array of floats
declare floats float[1]
sort/desc/dynamic/values=floats z:acltst ! array device
Related commands:
stats, fit, read
-------------------------------------------------------------------------------
stats : perform simple statistics on device readings or a variable
stats[/{qualifier}] [{device|identifier}{[n]}[/{qualifier...}]]
This command is used to perform simple statistics on device readings
from either the reading or setting property or an array variable.
Device readings can either come from a list of devices or from a
single array device. The resultant values are displayed by default.
They can also optionally be deposited into variables. This command
also supports an array index notation which allows you to specify
the beginning and ending array indices (ex. stats z:acltst[1:2]).
This command also supports family devices and list specifiers
(see above).
Examples of stats command qualifiers:
num_values={variable} -> returned number of values value
values={values} -> either the input array variable
or the returned device values used
in the calculations
sum={variable} -> returned sum value
mean={variable} -> returned mean value
median={variable} -> returned median value
stddev={variable} -> returned standard deviation value
rms={variable} -> returned RMS value
minimum={variable} -> returned minimum value
maximum={variable} -> returned maximum value
range={variable} -> returned range value
variance={variable} -> returned variance value
family -> read an entire family
nodisplay -> don't display the reading, only errors
waitnew -> wait for a new value to be returned (default)
nowaitnew -> don't wait for a new value to be returned
pendwait -> wait for a nonpending status
timeout={seconds} -> set reading timeout in seconds
ignore_errors -> display the data even if it is in error
dynamic[_arrays] -> dynamically reallocate output data variables
to match the number of values read
verbose -> verbose output
output={spec} -> specify output destination
Examples:
stats name=m:out% ! list of devices
stats t:beamcb ! single array device
stats/mean=var1 name=m:out% ! list of devices
stats/min=var1/max=var2 t:beamcb ! single array device
declare vals float[3]=2,5,11
stats/values=vals ! perform statistics on
! array variable
Related commands:
fit, read
-------------------------------------------------------------------------------
table_device : read or set table device values
table_device/table_type={type}[/{qualifier}] {device} [{settings}]
This command supports reading or setting of tables contained
in table devices. These are most commonly waveform generator
devices which provide ramps for power supplies. The device to
read or set can be specified in one of two ways. You can either
enter the explicit component device of interest, or the generic
device for that card can be entered along with a desired table
type. This command supports an array index notation which allows
you to specify the beginning and ending array indices
(ex. table_device t_ha11t[1:5]). This command supports family
devices and list specifiers (see above). Use of this command may
require special privileges. See Brian Hendricks (hendricks@fnal.gov)
for more information.
Examples of table_device command qualifiers:
read -> read table values
(default if no values specified)
set -> set table values
(default if values are specified)
scaled (common) -> make a scaled (common) reading
raw -> make a raw reading
hex -> display values in hexadecimal
dec[imal] -> display values in decimal (default)
row -> display values in a single row
column -> display values in a single column
type={table_type} -> type of table to access
(time, g_table, h_table, gi_table, hi_table,
clock, scale_factor, sf_pointer,
ramp_pointer, mdat_pointer, archive_data,
clock_int_history, diag_counters, version,
mdat_selection_table, offset_table,
offset_pointer, delay_table,
frequency_table, frequency_pointer,
phase_table, phase_pointer)
number={table_number} -> table number to access
start_slot=(slot} -> starting slot number
num_slots={num_slots} -> number of slots to access
slot_type={type} -> type of slot access
(whole, independent (x), dependent (y))
x_scaling={scale_type} -> X coordinate scaling type
(seconds, milliseconds, summary_secs,
summary_msec)
x_values={val1,...} -> specify X coordinate setting values
y_values={val1,...} -> specify Y coordinate setting values
ft_tables={tbl1,...} -> specify f(t) table numbers
gi_tables={tbl1,...} -> specify g(i) table numbers
hi_tables={tbl1,...} -> specify h(i) table numbers
ft_sf_ptrs={ptr1,...} -> specify f(t) scale factor pointer numbers
gi_sf_ptrs={ptr1,...} -> specify g(i) scale factor pointer numbers
hi_sf_ptrs={ptr1,...} -> specify h(i) scale factor pointer numbers
ft_mdat_ptrs={ptr1,...} -> specify f(t) MDAT pointer numbers
gi_mdat_ptrs={ptr1,...} -> specify g(i) MDAT pointer numbers
hi_mdat_ptrs={ptr1,...} -> specify h(i) MDAT pointer numbers
file -> read setting values from a file
(default file extension is ".dat")
trigger_level={level} -> manually trigger a level (waveform)
add_event={event} -> add an event to the clock table
level={level (0-n)} -> clock table level to add a clock event
add_event_to_event={evt}-> add an event to the clock table on the
same level as a requested event
remove_event={event} -> remove an event from the clock table
replace_event={event} -> replace an event in the clock table
new_event={event} -> replacement event
find_event={event} -> find an event in the clock table
check_for_errors -> check a card for errors
clear_diag_counters -> clear diagnostic counters
read_value={variable} -> variable to hold reading data
read_value_2={variable} -> variable to hold Y reading data
dynamic[_arrays] -> dynamically reallocate output data variables
to match the number of values read
family -> operate on an entire family
nodisplay -> don't display the reading, only errors
waitnew -> wait for a new value to be returned (default)
nowaitnew -> don't wait for a new value to be returned
pendwait -> wait for a nonpending status
ignore_errors -> display the data even if it is in error
verbose -> display verbose output
Examples of output specifications:
mail:{user_name} -> send mail to a user
file:{file_name} -> send output to a file
Examples:
table_device i_h100t[] ! read time table 0
table_device/time i_h100[] ! read time table 0
table_device i_h100[2]={1.0,2.0,3.0} ! set G(I) table values
table_device/ft_tables={1,2}/hi_tables={1,1} s:466m[4]
table_device/ft_sf_ptrs={2,2}/hi_sf_ptrs={1,1} s:466m[4]
table_device/add_event=c2/level=3 s:465
table_device/find_event=c2/return_level=level s:465
table_device/remove_event=c2 s:465
table_device/mdat_selection_table s:4530
table_device/mdat_selection_table s:4530=m30,m31
Related commands:
read, set, read_field, set_field, ftd, data_source, device_list
-------------------------------------------------------------------------------
turn : turn an ACNET device on or off
turn[/{qualifier}] {on|off} {device}{[n]}{/qualifier...} {on|off}
This command supports turning one or more devices either on or off.
The specific command value can be placed before or after the device.
This command is only valid for a device's basic control property.
This command also supports family devices and list specifiers
(see above). Use of this command may require special privileges.
See Brian Hendricks (hendricks@fnal.gov) for more information.
Examples of turn command qualifiers:
toggle -> toggle the on/off status
family -> control an entire family
verbose -> generate verbose output
Examples:
turn i:q701 on
turn on i:q701
turn i:q701 off
turn off i:q701
turn i:q701 toggle_onoff
Related commands:
on, on_list, off, off_list, set, toggle, reset, reset_list, polarity,
positive, negative, digital_control, device_list
-------------------------------------------------------------------------------
reset : reset an ACNET device
reset[/{qualifier}] {device}{[n]}{/qualifier...}
This command supports reseting one or more devices. It is only
valid for a device's basic control property. This command also
supports family devices and list specifiers (see above).
Use of this command may require special privileges. See Brian
Hendricks (hendricks@fnal.gov) for more information.
Examples of reset command qualifiers:
family -> reset an entire family
verbose -> generate verbose output
Examples:
reset i:q701
Related commands:
reset_list, on, on_list, off, off_list, set, turn, toggle, device_list
-------------------------------------------------------------------------------
reset_list : reset a list of ACNET devices
reset_list[/{qualifier}] {device}|device_list={list}{[n]}{/qualifier...}
This command supports resetting one or more devices. This command
supports family devices and list specifiers (see above). Use of this
command may require special privileges. See Brian Hendricks
(hendricks@fnal.gov) for more information.
Examples of reset_list command qualifiers:
family -> turn on an entire family
verbose -> generate verbose output
Examples:
device_list/create devs devices='z:acltst,z:aclts5,z:aclts6'/control
reset_list device_list=devs
Related commands:
reset, on, on_list, off, off_list, positive, negative, polarity, set,
turn, toggle, digital_control, device_list
-------------------------------------------------------------------------------
toggle : toggle a status attribute of an ACNET device
toggle {onoff|polarity|rampdc} {device}{[n]}{/qualifier...} {onoff|polarity|rampdc}
The specific command value can be placed before or after the device.
This command is only valid for a device's basic control property.
This command also supports family devices and list specifiers
(see above). Use of this command may require special privileges.
See Brian Hendricks (hendricks@fnal.gov) for more information.
Examples of toggle command qualifiers:
on_off -> toggle on/off status
onoff -> toggle on/off status
polarity -> toggle polarity status
ramp_dc -> toggle ramp/DC status
rampdc -> toggle ramp/DC status
enable_disable -> toggle enable/disable status
(If an alarm property is selected, the
alarm status will be toggled.)
enabledisable -> toggle enable/disable status
(If an alarm property is selected, the
alarm status will be toggled.)
Examples:
toggle i:q701 onoff
toggle onoff i:q701
toggle m@outtmp enable_disable
Related commands:
turn, set, reset, on, off, polarity, positive, negative, device_list
-------------------------------------------------------------------------------
enable : enable a device, a clock event, or another parameter
enable [identifier|device{[n]}{/qualifier...}] {[constant|identifier]}
This command can be used to enable devices belonging to certain
device types as well as analog and digital alarms of any device
type. It can also be used to enable clock events and the
notification of stale data. This command also supports family
devices and list specifiers (see above). Use of this command
may require special privileges. See Brian Hendricks
(hendricks@fnal.gov) for more information.
Examples of enable command identifiers:
stale_errors -> enable stale data notification
exit_on_error -> enable errors to cause the script to exit
dst_handling -> enable daylight savings time corrections
for clink calculations
event -> enable a clock event
{event string} -> enable a clock event
tclk -> enable a TCLK event
mibs -> enable an MIBS event
rrbs -> enable an RRBS event
tvbs -> enable a TVBS event
analog_alarm -> enable an analog alarm
digital_alarm -> enable a digital alarm
alarm -> enable alarm indicated by property
analog_abort -> enable an analog alarm abort flag
digital_abort -> enable a digital alarm abort flag
abort -> enable an alarm abort flag
analog_display -> enable an analog alarm display flag
digital_display -> enable a digital alarm display flag
alarm_display -> enable an alarm display flag
analog_logging -> enable an analog alarm logging flag
digital_logging -> enable a digital alarm logging flag
alarm_logging -> enable an alarm logging flag
analog_alarm_used -> mark analog alarm as having been used
digital_alarm_used -> mark digital alarm as having been used
alarm_used -> mark alarm as having been used
dbnews -> enable database change notification
obsolete_devices -> allow access to obsolete devices
family -> enable an entire family
Examples:
enable stale_errors
enable s:ssbrst
enable m:outtmp analog_alarm
enable event EVENT_TEV_SUDDEN_LOSS
enable EVENT_TEV_SUDDEN_LOSS
enable/clock=mibs 7B
Related commands:
disable, bypass, set, activate, deactivate, device_list
-------------------------------------------------------------------------------
disable : disable a device, a clock event, or another parameter
disable [identifier|device{[n]}{/qualifier...}] {[constant|identifier]}
This command can be used to disable devices belonging to certain
device types as well as analog and digital alarms of any device
type. It can also be used to disable clock events and the
notification of stale data. This command also supports family
devices and list specifiers (see above). Use of this command may
require special privileges. See Brian Hendricks (hendricks@fnal.gov)
for more information.
Examples of disable command identifiers:
stale_errors -> disable stale data notification
exit_on_error -> disable errors from causing the script
to exit
dst_handling -> disable daylight savings time corrections
for clink calculations
event -> disable a clock event
{event string} -> disable a clock event
tclk -> disable a TCLK event
mibs -> disable an MIBS event
rrbs -> disable an RRBS event
tvbs -> disable a TVBS event
analog_alarm -> disable an analog alarm
digital_alarm -> disable a digital alarm
alarm -> disable alarm indicated by device property
analog_abort -> disable an analog alarm abort flag
digital_abort -> disable a digital alarm abort flag
abort -> disable an alarm abort flag
analog_display -> disable an analog alarm display flag
digital_display -> disable a digital alarm display flag
alarm_display -> disable an alarm display flag
analog_logging -> disable an analog alarm logging flag
digital_logging -> disable a digital alarm logging flag
alarm_logging -> disable an alarm logging flag
analog_alarm_used -> mark analog alarm as never having been used
digital_alarm_used -> mark digital alarm as never having been used
alarm_used -> mark alarm as never having been used
family -> disable an entire family
Examples:
disable stale_errors
disable s:ssbrst
disable m:outtmp analog_alarm
disable event EVENT_TEV_SUDDEN_LOSS
disable EVENT_TEV_SUDDEN_LOSS
disable/clock=mibs 7B
Related commands:
bypass, enable, set, activate, deactivate, device_list
-------------------------------------------------------------------------------
bypass : bypass an alarm
bypass {device|identifier}[[n]][/{qualifier}...]
This command can be used to bypass analog and digital alarms.
This command also supports family devices and list specifiers
(see above). Use of this command may require special privileges.
See Brian Hendricks (hendricks@fnal.gov) for more information.
Examples of bypass command identifiers:
family -> bypass an entire family
verbose -> display verbose output
Examples:
bypass m:outtmp
bypass/verbose user_alarm_list=booster\sparks
Related commands:
disable, enable, set, device_list
-------------------------------------------------------------------------------
trigger : trigger a clock event
trigger[/clock={clock_type}] {constant|variable|symbol}
This command will trigger a clock event. You can also trigger beam
synch events by specifying the type of event. Use of this command
may require special privileges. See Brian Hendricks
(hendricks@fnal.gov) for more information.
Examples of trigger command identifiers:
tclk -> trigger a TCLK event (default)
mibs -> trigger an MIBS event
rrbs -> trigger an RRBS event
tvbs -> trigger a TVBS event
Examples:
trigger D9
trigger EVENT_TEV_SUDDEN_LOSS
trigger/clock=mibs 7B
-------------------------------------------------------------------------------
activate : activate a device
activate device{[n]}{/qualifier...}
This command can be used to activate devices belonging to certain
device types. Use of this command may require special privileges.
See Brian Hendricks (hendricks@fnal.gov) for more information.
Examples:
activate t:a1fs00
Related commands:
deactivate, set, enable, disable
-------------------------------------------------------------------------------
deactivate : deactivate a device
deactivate device{[n]}{/qualifier...}
This command can be used to deactivate devices belonging to certain
device types. Use of this command may require special privileges.
See Brian Hendricks (hendricks@fnal.gov) for more information.
Examples:
deactivate t:a1fs00
Related commands:
activate, set, disable, enable
-------------------------------------------------------------------------------
check_status : check the basic status of devices
check_status[/{qualifier}] {device}{[n]}[/{qualifier...}] {status_type}
This command will check the basic status of a device or a list
of devices to see if they match a particular status. The status
values that can be tested for include on, off, ready, tripped,
remote, local, positive, negative, ramping, and DC.
This command also supports family devices and list specifiers
(see above). This command sets the global symbol, $_value, to
a value of true (1) if all devices checked match the requested
status and a value of false (0) otherwise.
Examples of check_status command qualifiers:
status={status value} -> status to check for (on, off, etc.)
on -> check for a status of on
off -> check for a status of off
ready -> check for a status of ready
tripped -> check for a status of tripped
remote -> check for a status of remote
local -> check for a status of local
positive -> check for a status of positive
negative -> check for a status of negative
ramp[ing] -> check for a status of ramping
dc -> check for a status of DC
family -> compare an entire family
verbose -> display verbose output
value={variable} -> specify a variable to hold the final
command status (true (matched)/false)
suppress_errors -> suppress the error if a mismatch is found
Examples:
check_status z:acltst on ! check if on
check_status/family t:horzfg ready ! check if family is ready
Related commands:
compare, read, device_list
-------------------------------------------------------------------------------
compare : compare device readings
compare {device}{[n]}[/{qualifier...}] [to] {source}[:{arg1}:{arg2}:{arg3}:{arg4}]
This command will compare reading values for a device from
two different data sources (accelerator, database, a
save/restore file, an SDA file, a data logger (Lumberjack), or
a memory pool). If no length or offset is specified, the entire
property will be compared. If the "device" qualifier is used,
it can also be used to compare two different devices. This
command can be used for the reading, setting, basic status,
analog alarm, and digital alarm properties. This command also
supports an array index notation which allows you to specify the
beginning and ending array indices
(e.g. compare z:acltst[1:2] to sr:last_big_save).
This command also supports family devices and list specifiers
(see above). If no tolerance is specified, a tolerance of zero
is assumed, and a raw data comparison is made. If a nonzero
tolerance is specified, scaled values are compared. This command
sets the global symbol, $_value, to a value of true (1) if the
compare is successful and a value of false (0) otherwise.
Type Syntax
---- ------
database db
save/restore sr:{file number}
SDA sda:{file number}:{case}[:{subcase}:{usage}]
data logger dl:{start date}[:{node}:{accuracy in seconds}]
memory memory[:{pool_name}|{pool_id}]
(Note: Arguments enclosed in square brackets are optional.)
Examples of compare command qualifiers:
tol(erance)={tolerance} -> absolute tolerance (scaled data comparison)
%tol={percent tolerance} -> percent tolerance (scaled data comparison)
mask={mask value} -> mask to apply to data before comparison
(raw comparison)
scaled -> perform a comparison of scaled data
(default if tolerance is not zero)
raw -> perform a comparison of raw data
(default if tolerance is zero)
on_off -> compare on/off status only
ready_tripped -> compare ready/tripped status only
remote_local -> compare remote/local status only
polarity -> compare polarity status only
ramp_dc -> compare ramp/DC status only
family -> compare an entire family
verbose -> display verbose output
device -> compares one device to another
value={variable} -> specify a variable to hold the final
command status (true (matched)/false)
suppress_errors -> suppress the error if a mismatch is found
Examples:
compare z:acltst sr:1 ! raw data comparison
compare/value=status z:acltst sr:1 ! raw data comparison
compare/tol=1.5 z:acltst sr:1 ! scaled data comparison
compare/%tol=10 z:acltst sr:1 ! scaled data comparison
compare z:acltst to sda:1:"Inject Protons":1:ColliderShot
compare z:acltst dl:"01-Jan-2000 00:00":fastest:3600
compare z:acltst[1:2] to sr:1
compare node=tev/crate=A1/prset to sr:last_big_save
Related commands:
read, search, device_list
-------------------------------------------------------------------------------
copy : copy one device to another
copy {src_device}{[n]}[/{qualifier...}] [to] {dest_device}{[n]}[/{qualifier...}]
This command will copy setting values from one device to another.
If no length or offset is specified, the entire property will be
copied. This command can be used for the setting, basic status,
analog alarm, and digital alarm properties. This command also
supports an array index notation which allows you to specify the
beginning and ending array indices
(ex. copy z:acltst[1:2]/src=sr:last_big_save to z:aclts3[2:3]).
This command also supports family devices and list specifiers
(see above) so that one device can be copies to many devices.
Use of this command may require special privileges. See Brian
Hendricks (hendricks@fnal.gov) for more information.
Examples of copy command qualifiers:
scaled -> copy scaled data (default is raw)
family -> copy to an entire family
verbose -> display verbose output
Examples:
copy z:acltst/src=sr:1 to z:aclts3 ! copy entire array device
copy z:acltst to z:aclts3 ! copy entire array device
copy z:acltst[1:2] to z:aclts3[2:3]
copy/family t_ha11 to t:horzfg
Related commands:
set, fill, restore, download, device_list
-------------------------------------------------------------------------------
copy_variable : copy a value or an array of values into a variable
copy_variable[/{qualifier}] {variable} {copy_value} [{num_values}]
This command copies values or arrays of values to a variable
whether or not they are of the same type. If the "overlay"
option is selected, this command can do a "one to many" or
"many to one" mapping. This is particularly useful when
parsing or building byte buffers. The output variable will
be created by this command if it doesn't already exist.
Examples of copy_variable command qualifiers:
overlay -> allow a simple memory overlay which will
support "many to one" and "one to many"
mappings
{value_type} -> value type to use if the output variable
must be created
verbose -> display verbose output
output -> specify output
Examples:
declare val int[4]=1,2,3,4
copyvar val2[0] val[0] 4 # simple array copy
declare val int[4]=1,2,3,4
copyvar/string val2[2] val[0] 2 # copy to another data type
readfile/binary/maxbytes=128/values=rawdata/byte \
'/usr/local/xaps/clg/utility_1.fmt'
copyvar/overlay/string str rawdata[0:117] #many to one
copyvar/overlay/int maxrecords rawdata[118:121] #many to one
copyvar/overlay/short recordsize rawdata[122:123] #many to one
Pseudonyms: copy_var, copyvar
Related commands:
str_copy
-------------------------------------------------------------------------------
search : search device readings for a pattern
search {device}{[n]}[/{qualifier...}] [for] {value 1}[ {value 2} ... {value n}]
This command will search reading values for a device for a
specific pattern. If no length or offset is specified, the entire
property will be searched. This command can be used for the
reading, setting, basic status, analog alarm, and digital
alarm properties. For basic status, analog alarm, and digital
alarm properties only raw data searches are supported. This command
also supports an array index notation which allows you to specify
the beginning and ending array indices (ex. search z:acltst[1:2] for 1,2).
This command also supports family devices and list specifiers
(see above). If no tolerance is specified for a scaled search,
a tolerance of zero is assumed. Values to be searched can be
entered directly on the command line or can be supplied in a
delimited text file. This command sets the global symbol, $_value,
to a value of true (1) if the search is successful and a value of
false (0) otherwise.
Examples of search command qualifiers:
tol(erance)={tolerance} -> absolute tolerance (scaled data comparison)
raw -> perform a raw search (default)
auto -> treat search values as the default data
type for the device being searched (default)
byte -> treat the search values as bytes
word -> treat the search values as words
long -> treat the search values as longwords
scaled -> perform a comparison of scaled data
(default if tolerance is not zero)
family -> search an entire family
file -> read search values from a file
(default file extension is ".dat")
verbose -> display verbose output
value={variable} -> specify a variable to hold the final
command status (true/false)
index={variable} -> specify a variable to hold the match
index value (-1 if no match)
Examples:
search i_34rc5c for 2b fe ! raw data search
search name=i_34rc*c for 2b fe
search/file/verbose name=i_34rc*c for search_values.dat
search i_34rc5c[1:2] for 2b
search/scaled z:acltst for 1.5 ! scaled data search
search/scaled/value=status z:acltst for 1.5
search/scaled/tol=1.5 z:acltst for 1.5
Related commands:
read, compare
-------------------------------------------------------------------------------
show : display database information for a device
show[/output={spec}] {device}{[n]}[/{qualifier...}] {/parameter...}
Multiple parameters can be specified so that multiple types of
database information can be displayed together. Note that a
device index can be supplied rather than a device name.
Examples of show command qualifiers:
block=2 -> request alarm block starting at array index 2
start_block=2 -> request alarm block starting at array index 2
block=active -> request active alarm block index
num_blocks=4 -> request 4 alarm blocks
source=dp -> display data from the accelerator (default)
source=db -> display data from the database
source=sr:1 -> display data from save/restore file 1
source=sda:1:"Inject Protons":1:ColliderShot -> display data from SDA
file 1, case Inject Protons,
subcase (set) 1,
usage ColliderShot
source=dl:"01-JAN-2000 01:00" -> display data from a Lumberjack at
January 1, 2000 at 0100
source=memory -> display data from a memory pool
obsolete -> support handling of obsolete devices
verbose -> display verbose output
noheader -> suppress device name header
nodisplay -> don't display the data, only errors
status={var|symbol} -> returns the retrieval status in a variable
output={spec} -> specify output destination
Examples of parameters are:
/name -> display device's name
/device_index -> display device index
/full_name -> display device's full name
/fermi_name -> display FermiName(s) for a device
/fermi_index -> display FermiName atom indices for a device
/text -> display device's descriptive text
/full_text -> display device's full descriptive text
/node -> display device's source node
/property -> display individual property information
/property_info -> display individual property information
/ssdn -> display individual property SSDN
/sizes -> display individual property sizes
/location -> display device's location information
/alarm_block -> display alarm block information from the front end
/db_alarm_block -> display alarm block information from the database
/alarm_flags -> display alarm display and logging enabled flags
/alarm_handling -> display alarm handling information
/dbset -> display saved database setting values
/dbset_raw -> display raw saved database setting values
/audit -> display device's audit history
/created -> display device creator and creation date
/last_modified -> display last device modifier and modify date
/bitnames -> display bit descriptions for the status property
/extended_text -> display bit descriptions for the status property
/bit_status -> display current bit status text
/status_text -> display current bit status text
/save -> display save/restore information
/save_info -> display save/restore information
/save_list -> display save/restore list information
/user_save_lists -> displays all user save lists which contain
this device
/device_type -> display device's type (database type)
/live_device_type -> display device's type (calculated)
/analog_text -> display analog alarm text
/digital_text -> display digital alarm text
/alarm_text -> display analog or digital alarm text depending
on the selected property
/scaling -> display scaling information
/scaling_info -> display scaling information
/digital_control -> display digital control information
/units -> units text
/primary_units -> primary units text
/status_attr -> display basic status attributes
/status_attributes -> display basic status attributes
/control_attr -> display basic control attributes
/control_attributes -> display basic control attributes
/virtual_machine -> display virtual machine information
/setting_protection -> display setting protection information
/controlled_set -> display controlled setting status
/emc -> display EMC information
/data_type -> display property data type information
/sibling -> display sibling information
/family -> display family information (family devices only)
/state_text -> display state text (state devices only)
/out_of_service -> display out of service (broken) information
/oos(broken) -> display out of service (broken) information
/plot_class -> display FTP and snapshot plot class information
/alarm_list -> display alarm list information
/alarm_lists -> display alarm lists containing the device
/properties -> list the existing properties for a device
/download -> display device download information
/download_props -> display device download properties
/families -> list the families that a device is a member of
/composites -> list the composite devices that a device is a
member of
/ssdr -> display SSDR (SubSystem Device Record) data
/extrema -> displays the minimum and maximum scaled values
for a property
/controlling_device -> displays the device which controls the
requested device
/controlled_devices -> displays the list of devices which the
requested device controls
/help -> displays the help for the device
/url -> displays the help URL for a device
/expr[ession] -> displays device reading expression
(for calculational devices only)
/logger_lists -> displays all data logger list entries for
the device
/param_pages -> displays all parameter pages containing the
device
Examples of output specifications:
mail:{user_name} -> send mail to a user
file:{file_name} -> send output to a file
Examples:
show m:outtmp/name/analog_text
show t:ha11/name/digital_text/status_attr/control_attr/property_info
Related commands:
read, delete_cache, list, device_list
-------------------------------------------------------------------------------
list : list device parameters
list {device{[n]}{/qualifier...}|tag=value|file} [/option={value}]
{format_string} [/output={spec}]
This command produces a formatted listing of parameters for one
or more devices. Note that a device index can be supplied rather
than a device name.
Examples of the tag=value pairs:
file={file} -> list all devices from an ASCII file
dbdi={table} -> list all devices specified by the column
named "di" (int) in a DB table
dbname={table} -> list all devices specified by the column
named "name" (char(8)) in a DB table
devices={dev1,dev2,...} -> list devices from an explicit delimited
list of names
node=tev -> list all devices from the Tevatron front end
name=t:ha% -> list all devices whose names start with
"T:HA"
family=t:ha11z -> list all devices in the family T:HA11Z
text=ha% -> list all devices whose descriptive text
starts with "HA"
save_list=1 -> list all devices attached to save/restore
list number 1
sul=booster\400_mev\vert -> list all devices in a user save list
save_code=1 -> list all devices having a save/restore
save code of 1
type=377 -> list all C377 devices
type='CAMAC C377' -> list all C377 devices
class=dio_camac_device -> list all CAMAC devices
transform=2 -> list all devices using common transform 2
crate=a1,node=tev -> list all devices from Tev crate A1
slot=1,crate=a1,node=tev -> list all devices from Tev crate A1, slot 1
madc=1,node=tev -> list all devices from Tev MADC #1
driver=0xD -> list all devices with driver code 0D
vm=v:falma1 -> list all devices belonging to virtual
machine V:FALMA1
units="sec " -> list all devices having units text of "sec "
alarm_list=FixTgt -> list all devices from alarm list "FixTgt"
aul=booster\sparks -> list all devices from a user alarm list
ah=Normal -> list all devices having a given alarm
handler
cd={device} -> list all devices controlled by a given
device
expr[ession]=%t:rn% -> list all devices containing a given string
in its reading expression
expr_device=t:rn000a -> list all devices containing a given device
in its reading expression
download_list=baker -> list all download devices for node BAKER
save_file=821 -> list all devices saved in save file 821
sda_set=1587:2:1 -> list all devices saved in SDA file 1587,
case 2, set 1
console_class={class} -> list all devices which are settable
by a given console class
Examples of options are:
/title=yes -> display a default title (default)
/title=no -> don't display a title
/notitle -> don't display a title
/title="My Title" -> display a specific title
/headings=yes -> display column headings (default)
/headings=no -> don't display column headings
/noheadings -> don't display column headings
/summary -> display the number of devices listed
/comment="This is a comment."
/skipbad -> skips invalid entries in a device file
/filter=analog_alarm -> only display devices in alarm (analog)
/filter=digital_alarm -> only display devices in alarm (digital)
/filter=broken -> only display devices marked as out of service
/filter=analog_bypassed -> only display devices with analog alarm bypassed
/filter=digital_bypassed -> only display devices with digital alarm bypassed
/filter=read_array -> only display devices with an array reading property
/filter=set_array -> only display devices with an array setting property
/filter=status_array -> only display devices with an array status property
/filter=read_size_mismatch -> only display devices with a reading size mismatch
/filter=set_size_mismatch -> only display devices with a setting size mismatch
/filter=has_reading -> only display devices having a reading property
/filter=has_setting -> only display devices having a setting property
/filter=has_status -> only display devices having a status property
/filter=has_control -> only display devices having a control property
/filter=has_analog_alarm -> only display devices having an analog alarm property
/filter=has_digital_alarm -> only display devices having a digital alarm property
/source=dp -> display data from the accelerator (default)
/source=db -> display data from the database
/source=sr:1 -> display data from save/restore file 1
/source=sda:1:"Inject Protons":1:ColliderShot -> display data from SDA
file 1, case Inject Protons,
subcase (set) 1,
usage ColliderShot
/source=dl:"01-JAN-2000 01:00" -> display data from a Lumberjack at
January 1, 2000 at 0100
/source=memory -> display data from a memory pool
/output={spec} -> specify output destination
/num_strings={variable} -> saves the number of strings in a variable
/strings={array} -> saves the output strings in a variable
/dynamic[_arrays] -> dynamically reallocate output data string
to match the number of output strings
Examples of format specifiers:
%nm -> display device name
%di -> display device index
%tx -> display device descriptive text
%fn -> display device FermiName
%fi -> display device FermiName atom index
%nd[_p] -> display device source node
%tn[_p] -> display device source trunk and node
%type_p -> display device type
%type_long_p -> display device type (long description)
%class_p -> display device class
%rd -> display current device reading
%rd_units -> display reading units
%set -> display current device setting
%set_units -> display device setting units
%sts -> display current device basic status
%raw_p -> display a raw reading value
%primary_p -> display a reading value in primary units
%aa -> display analog alarm
%aa_min -> display analog alarm minimum
%aa_max -> display analog alarm maximum
%aa_nom -> display analog alarm nominal
%aa_tol -> display analog alarm tolerance
%aa_ll -> display analog alarm limit length
%aa_lt -> display analog alarm limit type
%aa_ldt -> display analog alarm limit data type
%aa_status -> display analog alarm status
%aa_hl -> display analog alarm high/low status
%aa_ena -> display analog alarm enable status
%aa_abort -> display analog alarm abort status
%aa_abtena -> display analog alarm abort enable status
%aa_pri -> display analog alarm priority
%aa_text -> display analog alarm text
%aa_display -> display analog alarm display enable status
%aa_logging -> display analog alarm logging enable status
%aa_tries_needed -> display analog alarm tries needed
%aa_tries_now -> display analog alarm tries now
%aa_evt1 -> display analog alarm event 1
%aa_evt2 -> display analog alarm event 2
%aa_ftd -> display analog alarm FTD
%aa_pm -> display analog alarm post method
%aa_data -> display analog alarm special data
%aa_flags -> display analog alarm flags word
%da -> display digital alarm
%da_nom -> display digital alarm nominal
%da_mask -> display digital alarm mask
%da_ll -> display digital alarm limit length
%da_status -> display digital alarm status
%da_status -> display digital alarm status
%da_ena -> display digital alarm enable status
%da_abort -> display digital alarm abort status
%da_abtena -> display digital alarm abort enable status
%da_display -> display digital alarm display enable status
%da_logging -> display digital alarm logging enable status
%da_tries_needed -> display digital alarm tries needed
%da_tries_now -> display digital alarm tries now
%da_evt1 -> display digital alarm event 1
%da_evt2 -> display digital alarm event 2
%da_ftd -> display digital alarm FTD
%da_pm -> display digital alarm post method
%da_data -> display digital alarm special data
%da_flags -> display digital alarm flags word
%dbset_p -> display saved database setting values
%dbset_raw_p -> display raw saved database setting values
%units_p -> display common units text
%pt_p -> display primary transform (text)
%pt_index_p -> display primary transform (number)
%ct_p -> display common transform (text)
%ct_index_p -> display common transform (number)
%const_p(_n) -> display scaling constants (If "n" is specified,
only the corresponding constant will be displayed.)
%dl_p -> display scaled display length
%df_p -> display scaled display format
%ps -> display previous sibling
%ns -> display next sibling
%sl -> display save/restore save list
%sln -> display save/restore save list number
%sc -> display save/restore save code
%dc -> display save/restore display code
%sp -> display save properties
%sm -> display save property mask
%pm -> display device setting protection mask
%vm -> display device virtual machine information
%oos -> display device out of service (broken) status
%ssdn_p(_n) -> display device SSDN (If "n" is specified, only
the corresponding word will be displayed.)
%ds_p -> display device default size
%as_p -> display device atomic size
%ms_p -> display device maximum size
%ss_p -> display device scaling size
%ne_p -> display device number of elements
%emc_p -> display device EMC
%cr_p -> display device crate
%slt_p -> display device slot
%ch_p -> display device MADC channel
%madc_ch_p -> display device MADC channel
%madc_num_p -> display device MADC number
%ftd_p -> display device default FTD
%fa_date -> display first audit date
%fa_author -> display first audit author
%la_date -> display last audit date
%la_author -> display last audit author
%state_value -> display state value text (sv)
%fermi_name -> display FermiName for device
%ftp_class -> display FTP (Fast Time Plot) class (text)
%ftp_class_index -> display FTP (Fast Time Plot) class (number)
%snp_class -> display SNP (Snapshot) class (text)
%snp_class_index -> display SNP (Snapshot) class (number)
%cs -> display controlled setting status
%is_cntrl_set -> display controlled setting status
%is_motor -> display motor controller status
%data_type_id_p -> display device data type ID
%al -> display alarm list
%aln -> display alarm list number
%acl -> display alarm control list
%ah_p -> display alarm handler
%ahn_p -> display alarm handler number
%asid_p -> display alarm sound ID
%aspid_p -> display alarm speech ID
%cd -> display controlling device
%expr -> display expression used to calculate
the device's reading value
%cnv_device_driver_p -> display device driver value
(Suffixes of "_p" mean that a property string should be inserted in
place of the "p". The property strings for this are "rd", "set",
"sts", "ctl", "aa", and "da".)
(for more help see the help for the CLIB routine 'device_listing_c')
Examples of output specifications:
mail:{user_name} -> send mail to a user
file:{file_name} -> send output to a file
Examples:
list m:outtmp "%nm %tx %set %rd %rd_units %sts"
list transform=38 "%nm"
list data_file.txt "%nm %la_date %la_author"
list 27235 "%nm" ! get device name from device index
Related commands:
read, show, alarm_limit, nominal_mask, device_list
-------------------------------------------------------------------------------
alarm_limit : read or set analog alarm limits
alarm_limit[/{qualifier}] {device|identifier}[[n]][=][{minimum},{maximum}]
This command supports reading or setting of analog alarm limits.
One or more blocks of multiple alarm block devices can be displayed
or set. This command supports an array index notation which allows
you to specify the beginning and ending alarm blocks
(ex. alarm_limit t:a1spwe[3:5]). This command also supports family
devices and list specifiers (see above). Use of this command may
require special privileges. See Brian Hendricks (hendricks@fnal.gov)
for more information.
Examples of alarm_limit command qualifiers:
read -> read alarm limits
(default if no limits specified)
set -> set alarm limits
(default if one or both limits are specified)
minmax -> treat limits as minimum/maximum
(default for setting)
nomtol -> treat limits as nominal/tolerance
min[imum]={minimum} -> specifies minimum value for setting mode
max[imum]={maximum} -> specifies maximum value for setting mode
nominal={nominal} -> specifies nominal value for setting mode
tolerance={tolerance} -> specifie