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.