PVT mode provides much smoother motion than Galil’s old Contour Mode (also known as PT mode). In PT mode, trajectories are defined as a series of positions and times. The controller moves between the points at a constant velocity. Because each segment has its own velocity (the segment distance divided by the segment time), the controller has to ask for infinite acceleration between each segment. This leads to noisy motion, increased wear on components, and higher power consumption.

The two images below show the difference between PT and PVT modes. The image on the left shows PT mode. The quick changes in velocity can be seen at the transitions between trajectory segments. On the right, PVT mode is used to move through the same positions. As the image shows, PVT mode blends the velocity smoothly between motion segments, keeping the required acceleration as low as possible.

Galil added two commands to support PVT mode. The PV command is used to define the trajectory. Its format is PVn=p,v,t where n is the axis, p is the distance for the segment, v is the velocity for the end of the segment, and t is the time for the segment. The BT (Begin Trajectory) command operates just like standard BG command and is used to start motion on multiple axes at the same time.

For example:

PVA=5000,15000,512
PVA=5000,0,512
PVA=0,0,512
PVA=5000,0,200
PVA=0,0,0
PVB=5000,0,512
PVB=-5000,0,512
PVB=5000,0,512
PVB=0,0,200
PVB=0,0,0
BTAB
EN


You can read about this and other topics in the October issue of Galil’s ServoTrends newsletter.

The Galil language has always supported subroutines to help break complicated tasks into simpler, more reusable parts. For example, the code below puts the move code above into a routine called “MOVE”, and runs the move every time it sees digital input 1 go high.


#LOOP
AI 1;     ' Wait for input 1 to go high
JS #MOVE; ' Jump to the return subroutine (and return when it finishes)
JP #LOOP; ' Start loop all over again
#MOVE
PR 5000;  ' Set up a 5000 count relative move
BG;       ' Begin the move
AM;       ' Wait for the move to complete
SB 2;     ' Turn on digital output 2
EN

That works fine as long as you’re always going to move the same distance. But now imagine you want to move 5000 counts if digital input 1 goes high, and 10000 counts if digital input 2 goes high. One solution would be to write two different functions: MOVE1 and MOVE2 for example. With the new Accelera feature for subroutine parameters, there’s a better solution: write a subroutine that takes a parameter telling it how far to move. The code might look something like this:


#LOOP
JS #MOVE(5000), @IN[1]=1;  ' Move 5000 counts if input 1 is high
JS #MOVE(10000), @IN[2]=1; ' Move 10000 counts if input 2 is high
JP #LOOP;                  ' Keep on looping
#MOVE;  ' Move function. Parameter ^a is distance
PR ^a;  ' Set up a move based on the parameter passed to the function
BG;     ' Begin the move
AM;     ' Wait for the move to complete
SB 2;   ' Turn on digital output 2
EN


As the code shows, the subroutine’s parameters are named ^a, ^b, etc. Eight parameters are allowed (^a through ^h). If a ^a-^h variable isn’t used as a parameter, it can be used as a local variable that is only visible in that subroutine. Variables can be passed by value or by reference.

To read more about the new Accelera features, check out the April edition of Galil’s ServoTrends newsletter and the DMC-4000 command reference.

The machine uses two Galil motion controllers. A DMC-2183 eight axis motion controller handles motion control for the X, Y, Z, and theta axes of the two robot arms. Each robot arm moves independently in its own X-Y-Z-Theta coordinate space. A DMC-2143 four axis controller handles the tube decapper module. Galil’s AMP-20440 “sandwich” servo drives are attached directly to motion controllers, which minimizes space, reduces wiring, and saves cost.

Galil’s user-friendly software tools allowed for fast and intuitive software development. The basic motion is programmed on the controller using Galil’s simple two-letter command language. A host PC with a touch screen is used as the GUI/HMI. The PC software is programmed in C#, so Galil’s .NET API was used for seamless communication with the motion controllers, executing the motion programs depending on the system’s state and reading status variables for display to the user.

• List of Standard Options for Galil Controllers and Drives
• Alternative Feedback/Encoder Options such as SSI and Resolvers
• Options for Precise Laser Control
• Handling Coordinate Transformations with Galil Controllers

The Galil DMC-2153 controller takes commands from a CNC front-end running on a PC and handles tracing out the pattern with an XY gantry, water jet height, keeping the water stream tangent to the cut. The Galil controller provides smooth motion by applying linear and circular interpolation to a stream of commands sent every 4 ms by the PC.

Each compact RIO-471×0 is self contained with numerous analog and digital I/O points. Multiple RIO-471×0 units can be distributed on an Ethernet network, allowing I/O expansion.

The RIO-471×0 is fully programmable, making it much more than a remote I/O slave. With concurrent execution of up to four application programs, closed-loop PID control of analog process control loops, and the capability to control other devices as a Modbus master, the RIO-471×0 series brings Galil’s expertise in rapid and cost-effective development of motion control systems to the machine control world.

Standard features include:

• 10/100 Base-T Ethernet port
• RS232 port configurable for 115 or 19.2 kbaud
• 8 analog inputs and 8 analog outputs
• 16 optically isolated inputs
• 8 high-power, isolated outputs rated at 500 mA per output
• 8 isolated outputs rated at 25 mA max per output
• 2 analog process control loops controlled by Galil PID filter
• Concurrent execution of up to four application programs
• LED indicators for all digital I/O points
• Easy-to-use, 2-letter Galil programming language