source: softGlue_examples/source/motor_accel_gate/index.rst @ 952

.. $Id: index.rst 951 2012-06-20 17:50:50Z mooney $

============================
Motor accel/decel pulse gate
============================

.. index:: !motor_accel_gate

This circuit shows a way to gate out motor pulses during the acceleration and
deceleration portions of a motor motion.

Circuit and documentation: Tim Mooney

Context, Description
---------------------

One common way to implement a fly scan is to trigger a detector with motor
pulses.  You might want the detector to acquire on every :math:`N^{th}` pulse,
for example, but to refrain from acquiring during the acceleration and
deceleration portions of a move.  That's what this circuit does.

If you know the number of steps a stepper motor will move during its
acceleration time, you can easily arrange to deliver motor pulses to some
external circuit only while the motor is moving at constant speed. For a stepper
motor controlled by the EPICS motor record, the number of
acceleration/deceleration steps, :math:`N_a` can be calculated as follows:

.. math:: N_a = ((VBAS + VELO)/2) \times (ACCL / MRES)

where, :math:`VBAS`, :math:`VELO`, :math:`ACCL`, and :math:`MRES` are
motorRecord fields.

The number of constant-speed steps, :math:`N_c`, is then

.. math:: N_c = ((VAL_{end}-VAL_{start})/MRES) - 2N_a

where :math:`VAL_{end}` and :math:`VAL_{start}` are the final and initial
values of the motorRecord ``VAL`` field.


Circuit
------------

.. image:: motor_accel_gate.gif
        :width: 100%

This circuit accepts negative-going motor pulses at input signal 1, inverts
them, gates out the first :math:`N_a` (the value of ``DnCntr-1_PRESET``), and
from then on sends pulses to a divide-by-N circuit, until a total of
:math:`N_a+N_c` (the value of ``DnCntr-2_PRESET``) have been sent. The
divide-by-N sends every :math:`N^{th}` rising edge to output pin 17.  Thus, the
detector would see only the :math:`(N_a+N_c)/N` divided pulses that occurred
while the motor was moving at constant speed.  The circuit is reset by writing
``1!`` (positive-going pulse) to the input of ``BUF-1``.

Down counter ``DnCntr-1``, and flipflop ``DFF-1``, together produce a gate
signal that is 0 after a reset, and that goes to 1 after ``DnCntr-1_PRESET``
motor pulses. Down counter ``DnCntr-2``, and flipflop ``DFF-2``, together
produce a gate signal that is 1 after a reset, and that goes to 0 after
``DnCntr-2_PRESET`` motor pulses. We load the number of acceleration steps into
``DnCntr-1_PRESET``, and the number of acceleration steps plus constant-speed steps
into ``DnCntr-2_PRESET``.

``AND-1`` combines the gate signals produced above into a signal that is 1 while
the motor is moving at constant speed.

``AND-2`` gates the negative-going motor pulses by inverting the ``motor``
signal before applying it to the gate.

        .. note::  Positive-going pulses can be gated with an AND gate, by applying the signal to one input of the AND gate, and setting the other input to 0(1) to deny(allow) passage through the gate.

                   Negative-going pulses can be gated with an OR gate, by applying the signal to one input of the OR gate, and setting the other input to 0(1) to allow(deny) passage through the gate.

Note that the down counters are clocked by (rising edges of) ``motor``, to
produce the signal used to gate ``motor*``. This choice avoids a race condition
between simultaneous rising edges of ``gateOut`` and ``motor``. (This circuit
gates negative-going motor pulses, so another way to make this point is to say
that the trailing edge of a motor pulse is used to produce a gate that will be
ready in plenty of time for the leading edge of the next motor pulse.)

The circuit includes some diagnostics, and a mechanism for testing:

``UpCntr-1`` counts all motor pulses; ``UpCntr-2`` counts gated motor pulses.
Both counters are reset by the same signal that resets the gate circuit. A
manual reset is implemented using ``BUF-1``. Writing ``1!`` to the input of
``BUF-1``, as shown, causes a short positive-going pulse to be applied to it,
and thus to its output, the signal named ``reset``.



EPICS support
-------------

Calculations for the circuit are shown in the following screen capture of a
transform record.

.. figure:: motor_accel_gate_calc.gif
        :width: 100%


Usage
-----

To load the circuit into softGlue:

1)      Download this `BURT <http://www.aps.anl.gov/epics/extensions/burt/index.php>`_ snapshot file :download:`motor_accel_gate.snap
        <motor_accel_gate.snap>`

2)      Edit the file to replace all occurrences of the string ``xxx:softGlue:`` with
        whatever value you specified for ``$(P)$(H)`` when you loaded softGlue into
        your IOC.

3)      Load the file with the command ``burtwb -f motor_accel_gate.snap``

To load the database :download:`motor_accel_gate_transform.db <motor_accel_gate_transform.db>`
into the IOC, add something like the following command to the IOC's st.cmd:

``dbLoadRecords("$(TOP)/xxxApp/Db/motor_accel_gate_transform.db","P=xxx:,H=softGlue:,M=m9")``



To use the circuit:

#) Connect negative-going motor step pulses to input 1.

#) Write the data-start and data-end motor positions to the transform record
   fields ``G`` and ``H``, respectively.

#) Move the motor to the data-start position.

#) Reset the circuit by writing ``1!`` to ``BUF-1``.

#) Move the motor to the data-end position.