ao.cam.crt
SYNTAX:
ao.cam.crt <state>
Where:
<state> is one of "on", "stop" or "off"
FUNCTION:
Either report the current state of the RS-170 output or change the state
of the RS-170. With no arguments the state of the RS-170 is returned. Otherwise
the RS-170 is turned on, off, or stopped based on the value of the argument
EXAMPLE:
ao.cam.crt on
ao.cam.crt
ON
ao.cam.crt stop
ao.cam.crt
STOPPED
ao.cam.crt off
ao.cam.crt
OFF
ao.cam.crtgain
SYNTAX:
ao.cam.crtgain <gain>
Where:
<gain> is 0-4
FUNCTION:
Either report the current gain of the RS-170 output or set the gain to a new value. With no arguments the gain of the RS-170 is returned. Otherwise the RS-170 gain is set if the parameter is between 0 and 4
EXAMPLE:
ao.cam.crtgain 3
ao.cam.crtgain
3
ao.cam.framerate
SYNTAX:
ao.cam.framerate <rate>
Where:
<rate> is the frame rate, 100-1292
FUNCTION:
Either report the current frame rate of the LLCCD or set the rate to a new value. With no arguments the frame rate of the LLCCD is returned. Otherwise the frame rate is set if the parameter is valid
EXAMPLE:
ao.cam.framerate 1200
ao.cam.framerate
1200
ao.cam.gain
SYNTAX:
ao.cam.gain <gain>
Where:
<gain> is 1 or 2
FUNCTION:
Either report the current gain of the LLCCD or set the gain to a new value. With no arguments the gain of the LLCCD is returned. Otherwise the gain is set if the parameter is 1 or 2
EXAMPLE:
ao.cam.gain 2
ao.cam.gain
2
ao.cam.init
SYNTAX:
ao.cam.init
FUNCTION:
Initialze the LLCCD camera. This command is typically unnecessary as the camera is initialzed when the VxWorks chassis boots.
EXAMPLE:
ao.cam.init
ao.cam.send.buffer
SYNTAX:
ao.cam.send.buffer <nframes>
Where:
<nframes> is the number of frames to send, 1-32
FUNCTION:
Send the last <nframes> from the camera buffer to the DSP. This can be used to test the LLCCD->DSP data transfer
EXAMPLE:
ao.cam.send.buffer 16
ao.cam.start
SYNTAX:
ao.cam.start
FUNCTION:
Start the LLCCD camera framing. The camera will output to its high-speed port to the DPS interface at the current frame rate. ao.cam.stop should be used to stop the camera framing.
EXAMPLE:
ao.cam.start
ao.cam.stop
SYNTAX:
ao.cam.stop
FUNCTION:
Stop the LLCCD camera.
EXAMPLE:
ao.cam.stop
ao.cam.te
SYNTAX:
ao.cam.te <state>
Where:
<state> is either "on" or "off"
FUNCTION:
Either turn the TE cooler ON or OFF or report the current state. With no arguments the state of the TE cooler is returned. Otherwise the TE cooler is turned on or off based on the value of the argument
EXAMPLE:
ao.cam.te on
ao.cam.te
ON
ao.cam.te off
ao.cam.te
OFF
ao.cam.te.temp
SYNTAX:
ao.cam.te.temp
FUNCTION:
Report the current, voltage and temperature (in Celsius) of the TE cooler.
EXAMPLE:
ao.cam.te.temp
0.0 0.0 26.7
ao.cam.test.buffer
SYNTAX:
ao.cam.test.buffer
FUNCTION:
Test the camera frame buffer
EXAMPLE:
ao.cam.test.buffer
PASSED
ao.capture
SYNTAX:
ao.capture <N frames>
Where: <N frames> is the number of frames to capture
FUNCTION:
This procedure requests the AO system to capture the next N frames of data. The data can then be uploaded using the ao.upload.* procedures. The next call to ao.capture will overwrite any previously captured data
EXAMPLE:
ao.capture 2
ao.client.set.host
SYNTAX:
ao.client.set.host <host>
Where
<host> is the hostname of the AO server
FUNCTION:
This procedure sets the name of the server host. It will be used when the client connection is started
EXAMPLE:
ao.client.set.host 199.93.217.48
ao.client.set.port
SYNTAX:
ao.client.set.port <port>
Where
<port> is the port number of the AO server
FUNCTION:
This procedure sets the port to use on the server host. It will be used when the client connection is started
EXAMPLE:
ao.client.set.port 7400
ao. client.start
SYNTAX:
ao.client.start This procedure establishes the connection to the AO server.
FUNCTION:
If the system is already connected then no action is taken. The current setting for the host and port number are used. Changing these parameters while the system is connected will have no effect. The system must be disconnected with "ao.client.stop" and the restarted.
EXAMPLE:
ao.client.start
Status of AO server connection:
Connection: NOT CONNECTED
Host Name: 199.93.217.49
Port Number: 7501
ao. client.stop
SYNTAX:
ao.client.stop This procedure terminates the connection to the AO server.
FUNCTION:
If the system is not connected then no action is taken.
The system can be restarted with a call to"ao.client.stop"
EXAMPLE:
ao.client.stop
ao. close.loop
SYNTAX:
ao.close.loop
FUNCTION:
Close the AO loop.
EXAMPLE:
ao.close.loop
ao. control.alpha
SYNTAX:
ao.control.alpha <alpha>
Where:
<alpha> is the proportional zero of the control system
FUNCTION:
Either report the current controller alpha or set the
alpha to a new value. With no arguments the alpha of the control system
is returned. Otherwise the alpha is set if the parameter is valid
EXAMPLE:
ao.control.alpha 2.0
ao.control.alpha
2.0
ao. control.coeffs
SYNTAX:
ao.control.coeffs <a> <b>
Where:
<a> and <b> are 3 element coefficient arrays for the control system
FUNCTION:
Either report the current controller coeffs or set the
coeffs to a new values.
EXAMPLE:
ao.control.coeffs af bf
ao.control.coeffs
0.1 0.2 0.3 1.1 2.2 3.3
ao. control.gain
SYNTAX:
ao.control.gain <gain>
Where:
<gain> is the gain of the control system
FUNCTION:
Either report the current controller gain or set the
gain to a new value. With no arguments the gain of the control system
is returned. Otherwise the gain is set if the parameter is valid
EXAMPLE:
ao.control.gain 2.0
ao.control.gain
2.0
ao. control.limit
SYNTAX:
ao.control.limit <limit>
Where:
<limit> is the limit of the control system
FUNCTION:
Either report the current controller limit or set the
limit to a new value. With no arguments the limit of the control system
is returned. Otherwise the limit is set if the parameter is valid
EXAMPLE:
ao.control.limit 130.0
ao.control.limit
130.0
ao. diag
SYNTAX:
ao.diag
FUNCTION:
Start system diagnostics. After completion PASS/FAIL will
be returned
EXAMPLE:
ao.diagnostic
ao. dm.base.poke
SYNTAX:
ao.dm.base.poke <act> <poke> <base>
Where:
<act> is the actuator to poke, 0-96
<poke> is the voltage for the poked actuator, 0-65535
<base> is the voltage for all other actuators, 0-65535
FUNCTION:
Poke an actuator the specified voltage. All other actuators are
set to the base voltage
EXAMPLE:
ao.dm.base.poke 45 60000 5000
ao. dm.clear
SYNTAX:
ao.dm.clear
FUNCTION:
Set all actuator values to NULL, +32768.
EXAMPLE:
ao.dm.clear
ao. dm.index.to.pos
SYNTAX:
ao.dm.index.to.pos <iarray> = <parray>
Where
<iarray> is an index array with 97 elements
<parray> is the position array, 11x11 elements
FUNCTION:
This procedure converts from a linear ordering of DM actuator
values to a (x,y) position array
EXAMPLE:
ao.dm.index.to.pos LinActVal = DMArray
id.set.arrary id DMArray
ao. dm.map.to.index
SYNTAX:
ao.dm.map.to.index <col> <row>
Where
<col> is the column, 0-10
<row> is the row, 0-10
FUNCTION:
Map a (col,row) position on the DM to its index in the linear
ordering of DM actuator values, 0-96. If the position is an actuator
that is not mapped onto the DM, i.e. one of the corner positions, then
-1 is returned
EXAMPLE:
ao.dm.map.to.index 6 7
42
ao. dm.map.to.pos
SYNTAX:
ao.dm.map.to.pos <index>
Where
<index> is the actuator index, 0-96
FUNCTION:
Map an index in the linear ordering of DM actuator values, 0-96 to
a (col,row) position on the DM
EXAMPLE:
ao.dm.map.to.pos 89
8 5
ao. dm.poke
SYNTAX:
ao.dm.poke <act> <poke>
Where:
<act> is the actuator to poke, 0-96
<poke> is the voltage for the poked actuator, 0-65535
FUNCTION:
Poke an actuator the specified voltage. All other actuators are
set to the NULL voltage, +32768
EXAMPLE:
ao.dm.poke 45 60000
ao. dm.pos.to.index
SYNTAX:
ao.dm.pos.to.index <parray> = <iarray>
Where
<parray> is a position array, 11x11 elements
<iarray> is the index array with 97 elements
FUNCTION:
This procedure converts from an (x,y) position array to a linear
ordering of DM actuator values
EXAMPLE:
ao.dm.pos.to.index DMArray = LinActVal
a.info LinActVal
97 elements of type f (32-bit floating), 388 bytes total data
1 dimensions
97 columns
ao. dm.stop
SYNTAX:
ao.dm.stop
FUNCTION:
Stop the DM when it is test mode and continuously outputting to
the DM. This is typically used after a call to ao.dm.write.
EXAMPLE:
ao.dm.stop
ao. dm.write
SYNTAX:
ao.dm.write <pattern> <nreps> <udelay>
Where:
<pattern> is an array containing the pattern to write
<nreps> is the number of repetitions
<udelay> is the delay between frames in microseconds
FUNCTION:
Write the given pattern to the DM. The array must be 1-dimensional
and contain 97 elements or be 2-dimensional and have 97 columns.
If the array is 2-D then each 97 element column will be written
to the DM. Each frame is written with 'udelay' microseconds between
frames. 'udelay' defaults to 0 for no delay. The set
of frames will be cycled 'nreps' times. If 'nreps' is 0 the
frames will be output continuously, use ao.dm.stop to stop the DM
in this case.
EXAMPLE:
ao.dm.write test
ao.dm.write test 0 1000000 # Output continuously at 1Hz
ao. get.op.mode
SYNTAX:
ao.get.op.mode
FUNCTION:
Returns the operational mode of the AO system
EXAMPLE:
ao.get.op.mode
NORMAL
ao. get.op.state
SYNTAX:
ao.get.op.state
FUNCTION:
Returns the state of the AO system.
EXAMPLE:
ao.get.op.state
RUN CLOSED LOOP
ao. help
SYNTAX:
ao.help
FUNCTION:
Returns list of ao.xxx functions.
EXAMPLE:
ao.help
The following commands affect the AO subsystem:
ao.cam.init Initialize the LLCCD camera
ao.cam.crt Start/stop/disable or report the RS-170
ao.cam.crtgain Set or report the gain for the RS-170
ao.cam.framerate Get/set the framerate
ao.cam.gain Get/set the camera gain
ao.cam.start Start the camera
ao.cam.stop Stop the camera
ao.cam.te Turn on/off or report the TE cooler
ao.cam.te.temp Get the temperature of the TE cooler
ao.cam.test.buffer Test the frame buffer
ao.cam.send.buffer Send test data from the frame buffer
ao.capture Trigger the capture of data
ao.client.set.host Set the AO server host
ao.client.set.port Set the AO server port
ao.client.start Connect to the AO server
ao.client.status Get the status of the connection
ao.client.stop Disconnect from the AO server
ao.close.loop Close the AO loop
ao.control.gain Set the gain of the control system
ao.control.limit Set the limit of the control system
ao.control.alpha Set the alpha of the control system
ao.control.coeffs Set the coefficients of the control system
ao.dm.base.poke Poke one DM actuator
ao.dm.clear Write a zero pattern to the DM
ao.dm.index.to.pos Convert from a DM index order array to (x,y) position array
ao.dm.pos.to.index Convert from a DM (x,y) position array to index order array
ao.dm.map.to.index Convert a DM (x,y) position to an index
ao.dm.map.to.pos Convert a DM index order to an (x,y) position
ao.dm.poke Poke one DM actuator
ao.dm.stop Stop the output to the DM in test mode
ao.dm.write Write a pattern to the DM
ao.diag Setup for diagnostic mode
ao.get.op.mode Get the current mode of operation
ao.get.op.state Get the current loop state
ao.help Print short description of the ao procs
ao.init Initialize the AO system (VxWorks side)
ao.open.loop Open the AO loop
ao.reset.loop Reset the AO loop
ao.set.wpa Set wfs mode to WPA
ao.set.spot.fit Set wfs mode to spot fitting
ao.setup.collect Setup for gradient collection mode
ao.setup.grab Setup for image acquisition
ao.setup.loop Setup for closed-loop mode
ao.start Start the AO system in the current mode
ao.stop Stop the AO system
ao.term Terminate the AO system (VxWorks side)
ao.upload.drive.signals Upload DM drive signals
ao.upload.gradients Upload wavefront gradients
ao.upload.modes Upload wavefront modes
ao.upload.intensity Upload average pixel intensity
ao.upload.raw.image Upload raw LLCCD camera images
ao. init
SYNTAX:
ao.init
FUNCTION:
Initialize the AO subsystem. The digital signal processors are
reset and their code downloaded. The LLCCD camera and Xinetics DM
are placed in an idle state. This routine must be called before anyother AO subsystem routine. If the initialization fails the DSP's
are reset and the system is not initialized. Calling this procedure
after initialization will effectively reset the AO system
EXAMPLE:
ao.init
ao. open.loop
SYNTAX:
ao.open.loop
FUNCTION:
Open the AO loop. The current set of controller signals is
held and output until the the loop is closed or reset. The
integrators are not zeroed
EXAMPLE:
ao.open.loop
ao. reset.loop
SYNTAX:
ao.reset.loop
FUNCTION:
Reset the AO loop. The controller signals and integrators are
zeroed and the loop is opened
EXAMPLE:
ao.reset.loop
ao. .set.spot.fit
SYNTAX:
ao.set.spot.fit
FUNCTION:
Sets the WFS mode to spot fitting
EXAMPLE:
ao.set.spot.fit
ao. set.wpa
SYNTAX:
ao.set.wpa
FUNCTION:
Sets the WFS mode to WPA
EXAMPLE:
ao.set.wpa
ao. setup.collect
SYNTAX:
ao.setup.collect <dir>
Where: <dir> is the directory containing the configuration files
FUNCTION:
Setup the system for collection. The configuration and
parameter files are read from the configuration directory supplied.
The tables are downloaded, up to wavefront sensing, to the DSP's and
the system is made ready to operate in collection mode. The loop is
started/stopped by ao.start and ao.stop respectively.
EXAMPLE:
ao.setup.collect /data/hbar/config/collect
ao. setup.grab
SYNTAX:
ao.setup.grab
FUNCTION:
Setup the system for LLCCD image acquisition. This command is
unnecessary as ao.grab.image will setup the system if it has not
already been done. During acquisition mode the LLCCD is framing and
images are sent to the interface DSP. These images can be uploaded
using ao.grab.image. The camera will remain framing until ao.stop
or ao.term is issued.
EXAMPLE:
ao.setup.grab
ao.grab.image spots
ao. setup.loop
SYNTAX:
ao.setup.loop <dir>
Where: <dir> is the directory containing the configuration files
FUNCTION:
Setup the system for closed loop operation. The configuration and
parameter files are read from the configuration directory specified.
The tables are downloaded to the DSP's and the system is made ready
to operate in closed-loop mode. The loop is started/stopped by
ao.start and ao.stop respectively.
EXAMPLE:
ao.setup.loop /data/hbar/config/123
ao. start
SYNTAX:
ao.start Start the system. The mode of operation is determined by the last
FUNCTION:
call to one of the AO_Setup* functions. The system needs to be started
in order to do any operations such as uploading a camera image or
writing to the DM.
EXAMPLE:
ao.start
ao. stop
SYNTAX:
ao.stop The system is stopped. The DSP's return to their idle loops and the
FUNCTION:
LLCCD camera and DM are stopped. If there is a failure during the stop
the system is terminated as a precaution. The system can be started
again by calling ao.start
EXAMPLE:
ao.stop
ao. term
SYNTAX:
ao.term
FUNCTION:
Terminate the AO subsystem. The DSP's are reset and the LLCCD camera
and Xinetics DM are stopped.
EXAMPLE:
ao.term
ao. upload.drive.signals
SYNTAX:
ao.upload.drive.signals = <ARRAY>
ao.upload.drive.signals <start frame> = <ARRAY>
ao.upload.drive.signals <start frame> <N frames> = <ARRAY>
Where:
<ARRAY> is the name of the array to hold the data
<start frame> is the first frame to upload from
<N frames> is the number of frames to capture
FUNCTION:
This procedure uploads one or more frames of drive signals from the
DM. By default only the first frame is uploaded. The array
returned is in floating-point format
EXAMPLE:
ao.upload.drive.signals = signal
ao.upload.drive.signals 1 = signal
ao.upload.drive.signals 1 10 = signal
ao. upload.gradients
SYNTAX:
ao.upload.gradients = <ARRAY>
ao.upload.gradients <start frame> = <ARRAY>
ao.upload.gradients <start frame> <N frames> = <ARRAY>
Where:
<ARRAY> is the name of the array to hold the data
<start frame> is the first frame to upload from
<N frames> is the number of frames to capture
FUNCTION:
This procedure uploads one or more gradients sets from the
WFS. By default only the first frame is uploaded. The array
returned is in VECTOR4 format
EXAMPLE:
ao.upload.gradients = grads
ao.upload.gradients 2 = grads
ao.upload.gradients 2 100 = grads
ao. upload.intensity
SYNTAX:
ao.upload.intensity = <ARRAY>
ao.upload.intensity
Where:
<ARRAY> is the name of the array to hold the data
FUNCTION:
This procedure uploads the average pixel intensity.
The value returned is in floating-point format
EXAMPLE:
ao.upload.intensity = AveInt
ao. upload.modes
SYNTAX:
ao.upload.modes
ao.upload.modes = <ARRAY>
ao.upload.modes <start frame> = <ARRAY>
ao.upload.modes <start frame> <N frames> = <ARRAY>
Where:
<ARRAY> is the name of the array to hold the data
<start frame> is the first frame to upload from
<N frames> is the number of frames to capture
FUNCTION:
This procedure uploads one or more reconstructor modes from the
controller. By default only the first frame is uploaded. The array
returned is in floating-point format
EXAMPLE:
ao.upload.modes = modes
ao.upload.modes 1 = modes
ao.upload.modes 1 10 = modes
ao.upload.raw.image
SYNTAX:
ao.upload.raw.image
ao.upload.raw.image = <ARRAY>
ao.upload.raw.image <start frame> = <ARRAY>
ao.upload.raw.image <start frame> <N frames> = <ARRAY>
Where:
<ARRAY> is the name of the array to hold the data
<start frame> is the first frame to upload from
<N frames> is the number of frames to capture
FUNCTION:
This procedure uploads one or more raw image frames from the
LLCCD camera interface. The data is formatted in raster order
(not LLCCD order). By default only the first frame is uploaded.
EXAMPLE:
ao.upload.raw.image = image
ao.upload.raw.image 3 = image
ao.upload.raw.image 3 4 = image
aoalog.console
SYNTAX:
aoalog.console <boolean>
Where:
<boolean> is On/True to enable or Off/False to disable
FUNCTION:
This procedure enables/disables logging to the screen (stderr).
The boolean value either turns logging on or off. If console logging
is enabled then event messages will be written to stderr.
EXAMPLE:
aoalog.console on
aoalog.console off
aoalog.debug
SYNTAX:
aoalog.debug <module> <message>
Where:
<module> is a numeric module number
<message> is an debugging message string
FUNCTION:
This procedure sends an debugging message to the event logger
The message is formatted and sent to all of the logging devices
EXAMPLE:
aoalog.info 0x0023 "Recieved 1024 bytes of data..."
aoalog.error
SYNTAX:
aoalog.error <error> <message>
Where:
<error> is a numeric error code
<message> is an error message string
FUNCTION:
This procedure sends an error message to the event logger
The message is formatted and sent to all of the logging devices
EXAMPLE:
aoalog.error 0x00230056 "Error detected..."
aoalog.file.disable
SYNTAX:
aoalog.file.disable
FUNCTION:
This procedure disables logging to the log file.
EXAMPLE:
aoalog.file.disable
aoalog.file.enable
SYNTAX:
aoalog.file.enable <file>
Where:
<file> is the name of the file to log messages to
FUNCTION:
This procedure enables logging to a file. All log messages
will be written to the specified file (in addition to the console
and/or remote host).
EXAMPLE:
aoalog.file.enable "/tmp/log"
aoalog.host.disable
SYNTAX:
aoalog.host.disable
FUNCTION:
This procedure disables logging to a remote host. The connection
to the host will be terminated. It can be restarted by calling
aoalog.host.enable
EXAMPLE:
aoalog.host.disable
aoalog.host.enable
SYNTAX:
aoalog.host.enable [host [port]]Where:
[host] is the optional host name
[port] is the optional port number
FUNCTION:
This procedure enables logging to a remote host. All log messages
will be sent to the AOA event logging daemon on the remote host
If the host and port are not specified then the default host and
port are used (compile-time constants). If only the host is
specified then the connection will be made to that host using
the default port.
EXAMPLE:
aoalog.host.enable
aoalog.host.enable 199.93.217.48
aoalog.host.enable 199.93.217.48 8200
aoalog.info
SYNTAX:
aoalog.info <module> <message>
Where:
<module> is a numeric module number
<message> is an informational string
FUNCTION:
This procedure sends an informational message to the event logger
The message is formatted and sent to all of the logging devices
EXAMPLE:
aoalog.info 0x0023 "Using default file..."
aoalog.status
SYNTAX:
aoalog.status
FUNCTION:
This procedure reports the status of the event logger. The state
of the logger, what devices will be logged to, ... will be written
to stdout
EXAMPLE:
aoalog.status
aoalog.warning
SYNTAX:
aoalog.warning <module> <message>
Where:
<module> is a numeric module number
<message> is an warning message string
FUNCTION:
This procedure sends a warning message to the event logger
The message is formatted and sent to all of the logging devices
EXAMPLE:
aoalog.warning 0x0023 "Unable to find configuration file..."
llcam.help
llcam.help
llcam help is available for the following 20 functions:
llcam.help llcam.ifmap llcam.ifmask llcam.ifmerge
llcam.ifmergeone llcam.ifsplit llcam.last.ind llcam.matsplit
llcam.ogmap llcam.ogmask llcam.ogmerge llcam.ogsplit
llcam.ogsplit.rect llcam.order llcam.pack llcam.rect.ind
llcam.rect.last llcam.unorder llcam.unpack llcam.xyweights
Type the function name without arguments for more information
about the function
llcam.ifmap
llcam.ifmap rectArray nogs = mapArray
Given an array of rectangles in VECTOR4 format, this routine will produce
a 2-D 64x64 Array of type I. Each pixel in the output will have a value
of -1, 0, 1, 2, ... to 'nogs'-1. These integers represent the mapping of a
64x64 input image to 'nogs' processing chips. The mapping tries to
divide the 4096 pixels in a 64x64 image evenly between 'nogs' processing
chips without dividing any rectangle between chips. A -1 indicates that
a pixel is in no rectangle. A 0 indicates the pixel will go to chip 0,
a 1 indicates the pixel will go to chip 1, etc. The output is in camera
raster order. The output should be passed through llcam.order to make
it ready to be downloaded to the camera interface chip.
llcam.ifmask
llcam.ifmask rectArray nogs = mask1Array mask2Array ...
or
rectArray nogs og = maskArray
The first version generates 'nogs' 64x64 mask Arrays which indicate the
pixels that will be sent to the individual OG chips. The second version
generates a single mask array for OG chip 'og'.
llcam.ifmerge
llcam.ifmerge splitArray1 splitArray2 ... splitArrayN rectArray nogs = imageArray
This is the inverse of llcam.ifsplit. It takes the splitArrays and combines the data to create the 'imageArray'. The split
Arrays should be in the same order that they were uploaded from the
DSP_CAM_OG chips. The resulting imageArray is in raster order.
llcam.ifmergeone
llcam.ifmergeone splitArray inImageArray rectArray nogs og = outImageArray
This is the inverse of llcam.ifsplit. It combines one split Array with
an existing image Array and puts the result in another image Array.
The split Array should be 1-D and the elements should be in the same
order that they were uploaded from the DSP_CAM_OG chips.
The resulting imageArrays are 2-D 64x64 in raster order.
llcam.ifsplit
llcam.ifsplit imageArray rectArray nogs = frag1Array frag2Array ...
or
imageArray rectArray nogs og = fragArray
The first version splits the input 'imageArray' into 'nogs' streams that
simulate the order in which the DSP_CAM_IF chip splits up the incomming
camera data to 'nogs' DSP_CAM_OG chips. The second version generates
the split up data for OG chip 'og'. The data in the fragment arrays is
ready to download to the DSP_CAM_OG chips.
llcam.last.ind
llcam.last.ind indArray = listArray
Given an array of subaperture rectangle indices in camera order, this
will produce a list of subaperture rectangle indices in the order in
which they are last mentioned. The output is purely a list of subap
indices that can be used to compile tables of reference positions or
other data associated with individual subaps.
llcam.matsplit
llcam.matsplit matrixArray rectArray nogs og nwfs wf = submatrixArray
Extracts 'submatrixArray' from 'matrixArray'. The submatrix is
customized to match the gradients output by WFS chip 'wf' fed by OG chip
'og'. The total number of OG chips is 'nogs', and the total number of
WFS chips fed by the OG chip is 'nwfs'. The number of rows of the
matrix must equal twice the number of rectangles in 'rectArray'. The
first row in the matrix corresponds to the X gradient produced by the
first subap rectangle in 'rectArray', the second row to the Y gradient,
the third row to the X gradient produced by the second subap, etc.
The first row of the output will correspond to the first X gradient
produced by the first subap calculated by the particular WFS chip. The
second row will go with the Y gradient of the subap, etc.
llcam.ogmap
llcam.ogmap rectArray nogs og nwfs = mapArray
Given an array of rectangles in VECTOR4 format, this routine will produce
a 2-D 64x64 Array of type I. Each pixel in the output will have a value
of -1, 0, 1, 2, ... to 'nwfs'-1. These integers represent the mapping of
the inputs to an offset gain chip to one of 'nwfs' wavefront sensor chips.
The mapping is customized for offset and gain (og) chip 'og'. The total
number of og chips is 'nogs'. A -1 indicates that
a pixel is in no rectangle. A 0 indicates the pixel will go to chip 0,
a 1 indicates the pixel will go to chip 1, etc. The output is in camera
raster order. The output should be passed through llcam.order to make
it ready to be downloaded to the camera offset and gain chip.
llcam.ogmask
llcam.ogmask rectArray nogs og nwfs = mask1Array mask2Array ...
Generates 'nwfs' 64x64 mask Arrays which indicate the pixels that will
be sent to each WFS chip from OG chip 'og'. The number of 'og' chips
is specified by 'nogs'.
llcam.ogmerge
llcam.ogmerge splitArray1 splitArray2 ... splitArrayN rectArray nogs og nwfs = imageArray
This is the inverse of llcam.ogsplit. It takes the split Arrays and
combines the data to create the 'imageArray'. The split Arrays should
be in the same order that they were uploaded from the DSP_WFS chips.
The resulting imageArray is in raster order.
llcam.ogsplit
llcam.ogsplit imageArray rectArray nogs og nwfs = frag1Array frag2Array ...
or
imageArray rectArray nogs og nwfs wf = fragArray
The first version splits the input 'imageArray' into 'nwfs' streams that
simulate the order in which the 'og' DSP_CAM_OG chip splits up the
incomming camera data to 'nwfs' DSP_WFS chips. The second version splits
up the input and produces only one fragment customized for WFS chip 'wf'.
The data in the fragment arrays is ready to download to the DSP_WFS chips
fed by the DSP_CAM_OG chip number 'og'.
llcam.ogsplit.rect
llcam.ogsplit.rect dataArray rectArray nogs og nwfs = frag1Array frag2Array ...
or
dataArray rectArray nogs og nwfs wf = fragArray
The first version splits the input 'dataArray' into 'nwfs' streams that
simulate the order in which the 'og' DSP_CAM_OG chip splits up the
incomming data to 'nwfs' DSP_WFS chips. The second version splits
up the input and produces only one fragment customized for WFS chip 'wf'.
The data in the fragment arrays is ready to download to the DSP_WFS chips
fed by the DSP_CAM_OG chip number 'og'. The input 'dataArray' must be
1-D and have as many columns as there are rectangles in 'rectArray'.
llcam.order
llcam.order imageArray [maskArray] = orderedArray
Converts a 64x64 input image (of any scalar type) to a 1-D array of
32-bit quantities. The output represents the order produced by
the Lincoln Labs camera. If the 'maskArray' is present, only those
pixels in the 'imageArray' that correspond to non-zero pixels in
'maskArray' are placed in the 'orderedArray'. If present, 'maskArray'
must also be 64x64. See also llcam.unorder. Input data of types
c uc s us i ui are converted to i. Input data of types f and d are
converted to f.
llcam.pack
llcam.pack imageArray = packedArray
Converts a 64x64 input image (of any scalar type) to a 1-D array of
2048 32-bit integers. The output represents the format produced by
the Lincoln Labs camera. See also llcam.unpack.
llcam.rect.ind
llcam.rect.ind rectArray = indArray
Given an array of rectangles in VECTOR4 format, this routine will produce
a 2-D 64x64 Array of type I. Each pixel in the output will have a value
of -1, 0, 1, 2, ... These integers represent the index of the subaperture
rectangle in which each pixel falls. If a pixel falls in no subaperture
rectangle, the value is -1. The output is in camera
raster order. The output should be passed through llcam.order to make
it ready to be downloaded.
llcam.rect.last
llcam.rect.last rectArray = indArray
Given an array of rectangles in VECTOR4 format, this routine will produce
a 2-D 64x64 Array of type I. Each pixel in the output will have a value
of -1, 0, 1, 2, ... Most pixels will have a value of -1. For each
subaperture rectangle, only one pixel in the output will have a value
of the index of that subaperture rectangle. That pixel is that last
pixel of that subaperture that is transmitted by the camera.
If a pixel falls in no subaperture or is not last the value is -1. The
output is in camera raster order. The output should be passed through
llcam.order to make it ready to be downloaded.
llcam.unorder
llcam.unorder orderedArray [maskArray] = imageArray
Converts an input 1-D array (of any scalar type) to a 2-D 64x64 array of
32-bit quantities. The input 'orderedArray' represents the order produced
by the Lincoln Labs camera. The output will be in raster order. If
present, non-zero values 'maskArray' indicate which pixels in a 64x64
image the elements of 'orderedArray' correspond to. Input data of types
c uc s us i ui are converted to i. Input data of types f and d are
converted to f. See also llcam.order.
llcam.unpack
llcam.unpack packedArray = imageArray
Converts a 1-D Array of 2048 32-bit integers to a 64x64 Array of signed
16 bit integers. The format of the input file should be that produced
by the Lincoln Labs 64x64 camera. See also llcam.pack.
llcam.xyweights
llcam.xyweights rectArray = xweightArray yweightArray
Given an array of rectangles in VECTOR4 format, this routine will produce
two 2-D 64x64 Arrays of type FLOAT. Each value in the 'xweightArray'
will represent the x weight used in the weighted pixel algorithm for each
of the rectangles. Similarly, each value in the 'yweightArray' will
represent the y weights for each rectangle. The outputs are in camera
raster order. The outputs should be passed through llcam.order with the
proper mask to make them ready to be downloaded to the WFS chips.
stage.client.set.host
SYNTAX:
stage.client.set.host <host>
Where
<host> is the IP number of the stage server host
FUNCTION:
Set the host to connect to for stage requests. This call will
not take effect until the connection is reset by calling
stage.client.stop and then stage.client.start
EXAMPLE:
stage.client.stop
stage.client.set.host 199.93.217.48
stage.client.start
stage.client.set.port
SYNTAX:
stage.client.set.port <port>
Where
<port> is the port number on the stage server host
FUNCTION:
Set the port to connect to for stage requests. This call will
not take effect until the connection is reset by calling
stage.client.stop and then stage.client.start
EXAMPLE:
stage.client.stop
stage.client.set.port 7500
stage.client.start
Status of Stage server connection:
Connection: CONNECTED
Host Name: 199.93.217.49
Port Number: 123
stage.client.stop
SYNTAX:
stage.client.stop
FUNCTION:
Terminate the connection to the stage server.
To terminate the connection call stage.client.stop
EXAMPLE:
stage.client.start
stage.client.stop
stage.find.encoderMark
SYNTAX:
stage.find.encoderMark <stage> <dir>
Where:
<stage> is the name of the stage
<dir> is the direction, 0 or 1
FUNCTION:
'f' command
Find the encoder mark in the given direction
EXAMPLE:
stage.find.encoderMark AOA:X 1
stage.find.home
SYNTAX:
stage.find.home <stage> <speed> <dir>
Where:
<stage> is the name of the stage
<speed> is the seek speed, 20-20000
<dir> is the direction, 0 or 1
FUNCTION:
'F' command
Find the home position using the given speed and initial direction
EXAMPLE:
stage.find.home AOA:X 200 1
stage.get.DriverId
SYNTAX:
stage.get.DriverId <stage>
Where:
<stage> is the name of the stage to query
FUNCTION:
Return the one letter ID of the IMS driver for this stage
EXAMPLE:
stage.get.DriverId AOA:X
stage.stage.get.acceleration
SYNTAX:
stage.get.acceleration <stage>
Where:
<stage> is the name of the stage to query
FUNCTION:
'K' command
Get the ramp slope acceleration
EXAMPLE:
stage.get.acceleration AOA:X
stage.get.deceleration
SYNTAX:
stage.get.deceleration <stage>
Where:
<stage> is the name of the stage to query
FUNCTION:
'K' command
Get the ramp slope deceleration
EXAMPLE:
stage.get.deceleration AOA:X
stage.get.divideFactor
SYNTAX:
stage.get.divideFactor <stage>
Where:
<stage> is the name of the stage to query
FUNCTION:
'D' command
Get the divide resolution factor
EXAMPLE:
stage.get.divideFactor AOA:X
stage.get.encoderDeadZone
SYNTAX:
stage.get.encoderDeadZone <stage>
Where:
<stage> is the name of the stage to query
FUNCTION:
'd' command
Return the encoder deadband in steps
EXAMPLE:
stage.get.encoderDeadZone AOA:X
stage.get.encoderPosition
SYNTAX:
stage.get.encoderPosition <stage>
Where:
<stage> is the name of the stage to query
FUNCTION:
Get the encoder position of the stage using the 'z' command.
EXAMPLE:
stage.get.encoderPosition AOA:X
stage.get.encoderPresent
SYNTAX:
stage.get.encoderPresent <stage>
Where:
<stage> is the name of the stage to query
FUNCTION:
Return TRUE if the stage has an encoder enabled, FALSE otherwise
EXAMPLE:
stage.get.encoderPresent AOA:X
stage.get.encoderResolution
SYNTAX:
stage.get.encoderResolution <stage>
Where:
<stage> is the name of the stage to query
FUNCTION:
'e' command
Return the encoder resolution in lines
EXAMPLE:
stage.get.encoderResolution AOA:X
stage.get.encoderStallFactor
SYNTAX:
stage.get.encoderStallFactor <stage>
Where:
<stage> is the name of the stage to query
FUNCTION:
's' command
Return the encoder count lag distance
EXAMPLE:
stage.get.encoderStallFactor AOA:X
stage.get.encoderStallInterval
SYNTAX:
stage.get.encoderStallInterval <stage>
Where:
<stage> is the name of the stage to query
FUNCTION:
't' command
Return the encoder stall test delta
EXAMPLE:
stage.get.encoderStallInterval AOA:X
stage.get.holdCurrent
SYNTAX:
stage.get.holdCurrent <stage>
Where:
<stage> is the name of the stage to query
FUNCTION:
'Y' command
Return the stage hold current (in percent)
EXAMPLE:
stage.get.holdCurrent AOA:X
stage.get.huntResolution
SYNTAX:
stage.get.huntResolution <stage>
Where:
<stage> is the name of the stage to query
FUNCTION:
'h' command
Return the motor micro step resolution
EXAMPLE:
stage.get.huntResolution AOA:X
stage.get.huntVelocity
SYNTAX:
FUNCTION:
stage.get.huntVelocity <stage>
Where:
<stage> is the name of the stage to query
'v' command
EXAMPLE:
stage.get.huntVelocity AOA:X
stage.get.hwreg
SYNTAX:
stage.get.hwreg <stage>
Where:
<stage> is the name of the stage to query
FUNCTION:
']1' command
Return the value of the hardware register
EXAMPLE:
stage.get.hwreg AOA:X
stage.get.inPort1
SYNTAX:
stage.get.inPort1 <stage>
Where:
<stage> is the name of the stage to query
FUNCTION:
'A' command
Get the current value of input port 1
EXAMPLE:
stage.get.inPort1 AOA:X
stage.get.inPort2
SYNTAX:
stage.get.inPort2 <stage>
Where:
<stage> is the name of the stage to query
FUNCTION:
'A' command
Get the current value of input port 2
EXAMPLE:
stage.get.inPort2 AOA:X
stage.get.inPort3
SYNTAX:
stage.get.inPort3 <stage>
Where:
<stage> is the name of the stage to query
FUNCTION:
'A' command
Get the current value of input port 1
EXAMPLE:
stage.get.inPort3 AOA:X
stage.get.initialVelocity
SYNTAX:
stage.get.initialVelocity <stage>
Where:
<stage> is the name of the stage to query
FUNCTION:
'I' command
Get intitial velocity
EXAMPLE:
stage.get.initialVelocity AOA:X
stage.get.jogFast
SYNTAX:
stage.get.jogFast <stage>
Where:
<stage> is the name of the stage to query
FUNCTION:
'B' command
Get the high jog speed
EXAMPLE:
stage.get.jogFast AOA:X
stage.get.jogSlow
SYNTAX:
stage.get.jogSlow <stage>
Where:
<stage> is the name of the stage to query
FUNCTION:
'B' command
Get the slow jog speed
EXAMPLE:
stage.get.jogSlow AOA:X
stage.get.limitPolarity
SYNTAX:
stage.get.limitPolarity <stage>
Where:
<stage> is the name of the stage to query
FUNCTION:
'l' command
Return the polarity of the limit switches
EXAMPLE:
stage.get.limitPolarity AOA:X
stage.get.limits
SYNTAX:
stage.get.limits <stage>
Where:
<stage> is the name of the stage to query
FUNCTION:
']0' command
Get values of stage limit switches
EXAMPLE:
stage.get.limits AOA:X
stage.get.motorPosition
SYNTAX:
stage.get.motorPosition <stage>
Where:
<stage> is the name of the stage to query
FUNCTION:
Get the motor position of the stage using the 'Z' command.
EXAMPLE:
stage.get.motorPosition AOA:X
stage.get.moving
SYNTAX:
stage.get.moving <stage>
Where:
<stage> is the name of the stage to query
FUNCTION:
Determine the moving status of the stage using the '^' command
EXAMPLE:
stage.get.moving AOA:X
stage.get.outPort1
SYNTAX:
stage.get.outPort1 <stage>
Where:
<stage> is the name of the stage to query
FUNCTION:
'A' command
Return the current value of output port 1
EXAMPLE:
stage.get.outPort1 AOA:X
stage.get.outPort2
SYNTAX:
stage.get.outPort2 <stage>
Where:
<stage> is the name of the stage to query
FUNCTION:
'A' command
Return the current value of output port 2
EXAMPLE:
stage.get.outPort2 AOA:X
stage.get.outPort3
SYNTAX:
stage.get.outPort3 <stage>
Where:
<stage> is the name of the stage to query
FUNCTION:
'A' command
Return the current value of output port 3
EXAMPLE:
stage.get.outPort3 AOA:X
stage.get.position
SYNTAX:
stage.get.position <stage>
Where:
<stage> is the name of the stage to query
FUNCTION:
Return the current position of the stage:
'z' command if encoder is enabled
'Z' command otherwise
EXAMPLE:
stage.get.position AOA:X
stage.get.resMode
SYNTAX:
stage.get.resMode <stage>
Where:
<stage> is the name of the stage to query
FUNCTION:
'H' command
Get the resolution mode, 0 = fixed, 1 = variable
EXAMPLE:
stage.get.resMode AOA:X
stage.get.retryCount
SYNTAX:
stage.get.retryCount <stage>
Where:
<stage> is the name of the stage to query
FUNCTION:
'r' command
Return the encoder stall retry count
EXAMPLE:
stage.get.retryCount AOA:X
stage.get.runCurrent
SYNTAX:
stage.get.runCurrent <stage>
Where:
<stage> is the name of the stage to query
FUNCTION:
'Y' command
Return the stage run current (in percent)
EXAMPLE:
stage.get.runCurrent AOA:X
stage.get.settlingDelay
SYNTAX:
stage.get.settlingDelay <stage>
Where:
<stage> is the name of the stage to query
FUNCTION:
'E' command
Get the settling time delay
EXAMPLE:
stage.get.settlingDelay AOA:X
stage.get.slewVelocity
SYNTAX:
stage.get.slewVelocity <stage>
Where:
<stage> is the name of the stage to query
FUNCTION:
'V' command
Return the stage slew velocity
EXAMPLE:
stage.get.slewVelocity AOA:X
stage.get.state
SYNTAX:
stage.get.state <stage>
Where:
<stage> is the name of the stage to query
FUNCTION:
Get the current state of the stage driver. A Tcl array is created
with the same name as the stage. The fields of the array are filled
in with the values of the IMS parameters
EXAMPLE:
stage.get.state AOA:X
stage.get.tripPoint
SYNTAX:
stage.get.tripPoint <stage>
Where:
<stage> is the name of the stage to query
FUNCTION:
'T' command
Return the trip point
EXAMPLE:
stage.get.tripPoint AOA:X
stage.get.tripVector
SYNTAX:
stage.get.tripVector <stage>
Where:
<stage> is the name of the stage to query
FUNCTION:
'T' command
Return the trip vector
EXAMPLE:
stage.get.tripVector AOA:X
stage.help
SYNTAX:
stage.help
FUNCTION:
Returns list of stage.xxx functions.
EXAMPLE:
stage.help
Available stage commands:
stage.client.set.host
stage.client.set.port
stage.client.start
stage.client.status
stage.client.stop
stage.find.encoderMark
stage.find.home
stage.get.DriverId
stage.get.acceleration
stage.get.deceleration
stage.get.divideFactor
stage.get.encoderDeadZone
stage.get.encoderPosition
stage.get.encoderPresent
stage.get.encoderResolution
stage.get.encoderStallFactor
stage.get.encoderStallInterval
stage.get.holdCurrent
stage.get.huntResolution
stage.get.huntVelocity
stage.get.hwreg
stage.get.inPort1
stage.get.inPort2
stage.get.inPort3
stage.get.initialVelocity
stage.get.jogFast
stage.get.jogSlow
stage.get.limitPolarity
stage.get.limits
stage.get.motorPosition
stage.get.moving
stage.get.outPort1
stage.get.outPort2
stage.get.outPort3
stage.get.position
stage.get.resMode
stage.get.retryCount
stage.get.runCurrent
stage.get.settlingDelay
stage.get.slewVelocity
stage.get.state
stage.get.tripPoint
stage.get.tripVector
stage.move.abs
stage.move.rel
stage.reset
stage.save
stage.set.acceleration
stage.set.current
stage.set.deceleration
stage.set.divideFactor
stage.set.encoderDeadZone
stage.set.encoderResolution
stage.set.encoderStallFactor
stage.set.encoderStallInterval
stage.set.holdCurrent
stage.set.huntResolution
stage.set.huntVelocity
stage.set.initVelocity
stage.set.jogFast
stage.set.jogSlow
stage.set.limitPolarity
stage.set.origin
stage.set.outPort1
stage.set.outPort2
stage.set.outPort3
stage.set.resMode
stage.set.retryCount
stage.set.runCurrent
stage.set.settlingDelay
stage.set.slewVelocity
stage.set.tripPoint
stage.setup
stage.update.position
stage.update.ioPort
stage.move.abs
SYNTAX:
stage.move.abs <stage> <position>
Where:
<stage> is the name of the stage to query
<position> is the position in steps to move to
FUNCTION:
'R' command
Move the stage to the given position relative to the origin
EXAMPLE:
stage.move.abs AOA:X 50000
stage.move.rel
SYNTAX:
stage.move.rel <stage> <index>
Where:
<stage> is the name of the stage to query
<index> is the number of steps +/- to move
FUNCTION:
'+/-' command
Move the stage the given number of steps
EXAMPLE:
stage.move.abs AOA:X -1000
stage.reset
SYNTAX:
stage.reset all
FUNCTION:
This procedures issues a global stage reset, ^C, to the
IMS driver. This will reset *ALL* stages to power-on state.
If this is really what you want then invoke the command as:
"stage.reset all"
stage.save
SYNTAX:
stage.save <stage>
Where:
<stage> is the name of the stage
FUNCTION:
This procedure saves the parameters currently in the IMS driver
to the NVRAM. The parameters will them be used when the stage
is powered up. The NVRAM has a finite life so this command should
not be issued frequently. Great care must be taken to ensure that
all parameters are set properly or damage to the stage may result
EXAMPLE:
stage.save AOA:X
stage.set.acceleration
SYNTAX:
stage.set.acceleration <stage> <value>
Where:
<stage> is the name of the stage to query
<value> is the value for the command
FUNCTION:
Set the ramp slope acceleration, first argument of the 'K' command
EXAMPLE:
stage.set.acceleration AOA:X 10
stage.set.current
SYNTAX:
stage.set.current <stage> <hold> <run>
Where:
<stage> is the name of the stage to query
<hold> is the hold current percent
<run> is the run current percent
FUNCTION:
'Y' command
Set the Hold and Run currents
EXAMPLE:
stage.set.current AOA:X 0 50
stage.set.deceleration
SYNTAX:
stage.set.deceleration <stage> <value>
Where:
<stage> is the name of the stage to query
<value> is the value for the command
FUNCTION:
Set the ramp slope deceleration, second argument of the 'K' command
EXAMPLE:
stage.set.deceleration AOA:X 10
stage.set.divideFactor
SYNTAX:
stage.set.divideFactor <stage> <res>
Where:
<stage> is the name of the stage to query
<res> is the resolution, 0-8
FUNCTION:
Set the divide resolution factor with the 'D' command. This is used
in fixed resolution mode. Consult the following table:
Res. Step Size Max RPM
0 full 6000
1 1/2 3000
2 1/4 1500
3 1/8 750
4 1/16 375
5 1/32 187
6 1/64 93
7 1/128 46
8 1/256 23
EXAMPLE:
stage.set.divideFactor AOA:X 3
stage.set.encoderDeadZone
SYNTAX:
stage.set.encoderDeadZone <stage> <value>
Where:
<stage> is the name of the stage to set
<value> is the deadband value in steps
FUNCTION:
'd' command
Set the encoder deadband
EXAMPLE:
stage.set.encoderDeadZone AOA:X 10
stage.set.encoderResolution
SYNTAX:
stage.set.encoderResolution <stage> <value>
Where:
<stage> is the name of the stage to set
<value> is the encoder resolution in lines
FUNCTION:
'e' command
Set the encoder resolution in lines
EXAMPLE:
stage.set.encoderResolution AOA:X 10
stage.set.encoderStallFactor
SYNTAX:
stage.set.encoderStallFactor <stage> <value>
Where:
<stage> is the name of the stage to set
<value> is the lag distance, 0-255
FUNCTION:
's' command
Set the encoder count lag distance
EXAMPLE:
stage.set.encoderStallFactor AOA:X 10
stage.set.encoderStallInterval
SYNTAX:
stage.set.encoderStallInterval <stage> <value>
Where:
<stage> is the name of the stage to set
<value> is the sample rate in steps
't' command
Set the encoder stall test delta
EXAMPLE:
stage.set.encoderStallInterval AOA:X 10
stage.set.holdCurrent
SYNTAX:
stage.set.holdCurrent <stage> <value>
Where:
<stage> is the name of the stage to set
<value> is the percent hold current
FUNCTION:
'Y' command
Set the stage Hold current percent (0-100)
EXAMPLE:
stage.set.holdCurrent AOA:X 0
stage.set.huntResolution
SYNTAX:
stage.set.huntResolution <stage> <value>
Where:
<stage> is the name of the stage to query
<value> is the value for the command
FUNCTION:
'h' command
Set the encoder hunt resolution
EXAMPLE:
stage.set.huntResolution AOA:X 10
stage.set.huntVelocity
SYNTAX:
stage.set.huntVelocity <stage> <value>
Where:
<stage> is the name of the stage to query
<value> is the value for the command
FUNCTION:
'v' command
Set the encoder hunt velocity
EXAMPLE:
stage.set.huntVelocity AOA:X 10
stage.set.initVelocity
SYNTAX:
stage.set.initVelocity <stage> <value>
Where:
<stage> is the name of the stage to query
<value> is the value for the command
FUNCTION:
'I' command
Set the initial velocity
EXAMPLE:
stage.set.initVelocity AOA:X 10
stage.set.jogFast
SYNTAX:
stage.set.jogFast <stage> <value>
Where:
<stage> is the name of the stage to query
<value> is high jog speed, 0-255
'B' command
Set the high jog speed
EXAMPLE:
stage.set.jogFast AOA:X 10
stage.set.jogSlow
SYNTAX:
stage.set.jogSlow <stage> <value>
Where:
<stage> is the name of the stage to query
<value> is the low jog speed, 0-255
FUNCTION:
'B' command
Set the slow jog speed
EXAMPLE:
stage.set.jogSlow AOA:X 10
stage.set.limitPolarity
SYNTAX:
stage.set.limitPolarity <stage> <value>
Where:
<stage> is the name of the stage to query
<value> is the value for the command
FUNCTION:
'l' command
Set the limit polarity
EXAMPLE:
stage.set.limitPolarity AOA:X 10
stage.set.origin
SYNTAX:
stage.set.origin <stage>
Where:
<stage> is the name of the stage to query
'O' command
Set the origin
EXAMPLE:
stage.set.origin AOA:X
stage.set.outPort1
SYNTAX:
stage.set.outPort1 <stage> <value>
Where:
<stage> is the name of the stage to query
<value> is the value for the command
FUNCTION:
'A' command
Set output port 1
EXAMPLE:
stage.set.outPort1 AOA:X 1
stage.set.outPort2
SYNTAX:
stage.set.outPort2 <stage> <value>
Where:
<stage> is the name of the stage to query
<value> is the value for the command
FUNCTION:
'A' command
Set output port 2
EXAMPLE:
stage.set.outPort2 AOA:X 1
stage.set.outPort3
SYNTAX:
stage.set.outPort3 <stage> <value>
Where:
<stage> is the name of the stage to query
<value> is the value for the command
FUNCTION:
'A' command
Set output port 3
EXAMPLE:
stage.set.outPort3 AOA:X 1
stage.set.resMode
SYNTAX:
stage.set.resMode <stage> <value>
Where:
<stage> is the name of the stage to query
<value> is the value for the command
FUNCTION:
'H' command
Set the resolution mode, 0 = fixed, 1 = variable
EXAMPLE:
stage.set.resMode AOA:X 1
stage.set.retryCount
SYNTAX:
stage.set.retryCount <stage> <value>
Where:
<stage> is the name of the stage to query
<value> is the value for the command
FUNCTION:
'r' command
Set the encoder stall retry count
EXAMPLE:
stage.set.retryCount AOA:X 10
stage.set.runCurrent
SYNTAX:
stage.set.runCurrent <stage> <value>
Where:
<stage> is the name of the stage to set
<value> is the run current in percent (0-100)
FUNCTION:
'Y' command
Set the Run current percent (0-100)
EXAMPLE:
stage.set.runCurrent AOA:X 40
stage.set.settlingDelay
SYNTAX:
stage.set.settlingDelay <stage> <delay>
Where:
<stage> is the name of the stage to query
<delay> is the settling delay in 10's of millisecs, 0-255
FUNCTION:
'E' command
Set the settling time delay. This is the delay in milliseconds
before the auto-power-down feature is activated after a motor index
EXAMPLE:
stage.set.settlingDelay AOA:X 10
stage.set.slewVelocity
SYNTAX:
stage.set.slewVelocity <stage> <value>
Where:
<stage> is the name of the stage to query
<value> is the value for the command
FUNCTION:
'V' command
Set the slew velocity
EXAMPLE:
stage.set.slewVelocity AOA:X 10
stage.set.tripPoint
SYNTAX:
stage.set.tripPoint <stage> <point> <vector>
Where:
<stage> is the name of the stage to query
<point> is the trip position
<vector> is the trip vector (0-255)
FUNCTION:
'T' command
Set the trip point and vector
EXAMPLE:
stage.set.tripPoint AOA:X 5000 1
stage.setup
SYNTAX:
stage.setup <stage> <id>
Where:
<stage> is the name of the stage
<id> is the IMS driver ID
FUNCTION:
Setup the IMS driver. This must be called before any other stage
commands
EXAMPLE:
stage.setup AOA:X b
stage.update.ioPort
SYNTAX:
stage.update.ioPort <stage>
Where:
<stage> is the name of the stage to query
FUNCTION:
Query the driver to get the current values of the digital I/O ports
It can be called before one of the stage.get.inPort's or outPorts
EXAMPLE:
stage.update.ioPort AOA:X
stage.get.inPort1 AOA:X
stage.get.inPort2 AOA:X
stage.get.outPort2 AOA:X
stage.update.position
SYNTAX:
stage.update.position <stage>
Where:
<stage> is the name of the stage to query
FUNCTION:
Query the driver to get the current position of the stage. The
driver automatically gets the latest position after any motion
command. This is only necessary to check for any stage movement.
It can be called before stage.get.position
EXAMPLE:
stage.update.position AOA:X
stage.get.position AOA:X