Basic Motion Elements

From SoftMC-Wiki
Jump to: navigation, search
Language: English  • 中文(简体)‎



Element is a generic term used for both axes and groups. In MC-Basic, anything that can be moved is considered an element. Many properties and commands are common to both axes and groups.

Further abstractions of groups and axes are cartesian-groups and robots for groups and joints for axes.

Setting up Axes

This section explains how axes in the system are set up. It discusses units for position, velocity, and acceleration. It also covers the acceleration profile and setting limits for axes.

For step-by-step instructions and examples on defining axis parameters in the softMC controller, refer to Axis Setup Procedure.

Axis Definition

In the softMC, an axis is considered to be a combination of a drive, a motor, and some portions of the softMC.

Each axis has a set of properties defined by softMC. These properties are used for calculating position and velocity commands, monitoring limits, and storing configuration data for the axis. softMC sends commands to the drive and the drive controls the motor. Together these components form an axis of motion.

The diagram below shows a softMC axis:


Axis Name

softMC automatically sets up all your axes according to their addresses: A1, A2, A3, and so on until A32 (the maximum number of axes is limited by User Authorization Code by manufacturer). You can access axis properties by preceding the property name with the axis name and a period. For example, each axis has a property, VELOCITYFEEDBACK, which provides the current velocity of that axis. You can query the VELOCITYFEEDBACK value with the ? command in the ControlStudio terminal:

? A1.VelocityFeedback 

You can rename the axis. It is usually worthwhile to name the axes according to their function. It makes your program easier to understand and to debug. For example, you can enter:

A1.AxisName = ConveyorAxis

Later, you can query the velocity with:

? ConveyorAxis.VelocityFeedback 

The axis name can be changed only in the configuration program Config.Prg. You cannot print the axis name at any time.

Drive Address

Drive address is property of the axis. Simulated axes do not have drive addresses and do not require this property to be assigned. This defines the physical address (topological order of the motion bus or dip switch setting on the drive) to the axis defined in the softMC. If we wanted to assign the drive with address 5 to axis 1, we type the following command into the terminal window of the ControlStudio or in our program:

A1.Dadd = 5 ‘ Assign drive address 5 to axis 1
IN EtherCAT the EC_SETUP program manipulates DADD's of the axes according to the drives connected to the SoftMC

The short form, DADD, of axis property DRIVEADDRESS is used in the example. Axis.DriveAddress property should meet to the drive hardware address configuration . Most axis properties and constants have short forms that can speed typing and ease the programming effort.

Simulated Axes

A simulated axis is an axis that exists only within the MC. Simulated axes have most of the functions of physical axes including profile generators, units, position and velocity commands and feedback signals, and limits. However, simulated axes do not include a drive, motor or feedback device.

An axis can only be configured as a simulated axis while AnyBus configuration takes place in CONFIG.PRG or AUTOEXEC.PRG.

To set up a simulated axis, set the axis property SIMULATED to ON:

A1.Simulated = ON

Simulated axes require about the same amount of resources from the motion controller as physical axes. As a result, simulated axes are included in the total axis count of the controller. For example, a system with three physical axes and one simulated axis requires a four-axis MC. Simulated axes are used in the motion controller in the same way as physical axes. They are profiled with JOG and MOVE, can be geared and cammed, and can act as masters for geared and cammed axes. Variables from simulated axes such as position feedback can be used to generate events. During operation, the feedback position and velocity are set to their respective command values. Although most commands and variables for axes work for simulated axes, there are some exceptions. Simulated axes cannot receive AnyBus commands. Drive variables, such as position loop gains, cannot be set in simulated axes.

Starting Position

Before you get started, you must:

Install and tune drives. Follow the process for installing and tuning all drives. Run ServoStudio to select your motor type and tune the axis to your satisfaction.

Install and check your softMC.

Wire all I/O. Connect the fiber-optic ring, and follow the procedures to check the wiring.

Install ControlStudio. The terminal screen is used here extensively. Remember, any commands typed in the terminal window are lost when you power down. Enter these commands into softMC programs to be recalled at power up.

User Units

softMC supports user units with one floating-point conversion factor for each of six types of properties: position, velocity, acceleration, jerk, external position, and external velocity.

<axis>.DIRECTION' is applied as a multiplier to the units conversion factors. The movement factors (i.e., POSITIONFACTOR, VELOCITYFACTOR, ACCELERATIONFACTOR , JERKFACTOR) are only assigned positive values and DIRECTION determines their sign. DIRECTION can take one of two values: -1 for forward direction or +1 for reverse direction.

MC units allow you to work in units that are convenient. All unit types are independent, so position units are inches, velocity units are feet/min and acceleration is rpm/second. Units are changed only when the axis is disabled.

Position Units

Position units are controlled by POSITIONFACTOR or PFAC. The softMC internal units are encoder counts for encoder-based systems or 65536 counts per revolution for resolver-based systems. Encoder counts are four times encoder lines. To set up position units, determine how many counts are in one of your selected units. For example, suppose you had this system:

Desired units: inches

Rotary motor (as opposed to linear motor)

2000 line Encoder

3:1 gearbox

5 turn per inch ball screw

Determine POSITIONFACTOR (number of counts per inch):

1 inch = 5 turns on the screw = 15 turns into the gearbox = 15 * 2000 lines = 15 * 2000 * 4 counts = 120,000 counts

POSITIONFACTOR is set to the number of counts per inch: 120000.

A1.PositionFactor = 120000

For a second example, let’s change the first example from encoder to resolver, change the ball screw and use meters for the units:

Desired units: meters

Rotary motor

Resolver (65536 counts per revolution)

3:1 gearbox

2 turn/cm ball screw

Determine POSITIONFACTOR (number of counts per meter):

1 meter = 200 turns on the screw = 600 turns into the gearbox = 600 * 65536 counts = 39,321,600 counts

POSITIONFACTOR is set to the number of counts per meter: 39321600. If you use the ControlStudio auto setup program, provide the motor resolution and number of motor rotations per unit movement and ControlStudio calculates the math.

Velocity Units

Velocity units convert softMC internal velocity units (counts/mSec) to your units. They are controlled using VELOCITYFACTOR or VFAC. Normally, velocity units are either the position units per second or per minute, or they are rpm. If you want velocity units to be your position units per second, set VELOCITYFACTOR to POSITIONFACTOR divided by 1000 (to convert milliseconds to seconds):

A1.VelocityFactor = A1.PositionFactor/1000 ‘ for position units/sec

If you want position units per minute, divide by 60000:

A1.VelocityFactor = A1.PositionFactor/60000 ‘ for position units/min

If you want rpm, you must calculate the number of counts per revolution and then divide that by 60000 (to convert milliseconds to minutes):

Desired units: rpm

2000 line Encoder

You first need to determine the number of counts per inch for each revolution:

1 rev = 2000 lines

= 2000 * 4 counts

= 8000 counts

VelocityFactor is set to the number of counts per revolution divided by 60000:

A1.VelocityFactor = 8000/60000

Acceleration Units

Acceleration units convert softMC internal acceleration units (counts/msec2) to your units. They are controlled using ACCELERATIONFACTOR or <axis>.AFAC. Normally, acceleration units are either the velocity units per second or per minute. If you want acceleration units to be your velocity units per second, set ACCELERATIONFACTOR to VELOCITYFACTOR divided by 1000 (to convert milliseconds to seconds). Divide by 60000 to set acceleration units to velocity units per minute:

A1.AccelerationFactor = A1.VelocityFactor/1000 ‘Accel units = vel/sec


A1.AccelerationFactor = A1.VelocityFactor/60000 ‘Accel units = vel/min

Jerk Units

It is also necessary to define the jerk factor, even if you always use the smooth factor. The smooth factor automatically defines the jerk value from the velocity and acceleration values, but it is a value before factors, therefore totally invalid values of jerk (internally) can be computed. At least set Jfac=Afac/1000 and it should work. JERKFACTOR specifies the conversion factor between your jerk units and the internal units [counts per msec</nowiki>3]. <axis>.JERKFACTOR must contain the conversion factor for both the position dimension and the time dimension.

Acceleration Profile

The softMC provides smooth, controlled acceleration profiles to reduce vibration and wear on the machine, and to allow high acceleration rates. The softMC allows you to independently control acceleration and deceleration to further reduce vibration.

ACCELERATION and DECELERATION control the acceleration rates. The following lines of code entered at the terminal window (or in your program) change the acceleration rates for Axis A1:

A1.Acceleration = 1000
A1.Deceleration = 1000

Do not enter these commands yet. Acceleration units should be set before these values are entered. You can impose limits which constrain the time during which acceleration and deceleration occurs. The motion includes three major parts: acceleration phase, constant velocity cruise phase, and deceleration phase.

Jerk is the first derivative of acceleration. Fast moves usually generate large amounts of jerk. Having a large amount of jerk in a motion profile can excite machine resonance frequencies and thereby, cause unnecessary wear and noise. Some motion controllers simplify motion profiles by instantaneously changing the acceleration command which implies a very high level of jerk. The softMC allows you to limit the amount of jerk in all profiles by using the axis properties SMOOTHFACTOR or <axis/group>.JERK

Specify trapezoidal profiles by setting <axis/group>.SMOOTHFACTOR (SMOOTH) to zero. If you want a smoother acceleration, increase the SMOOTHFACTOR from 1 to a maximum of 100. If SMOOTHFACTOR is large (greater than 50), it can increase the acceleration time by one or more orders of magnitude.

Using <axis/group>.ACCELERATION and <axis/group>.JERK to limit velocity changes produces acceleration profiles that remove the high frequency components of torque that are present in straight-line acceleration. This minimizes the excitation of machine resonance frequencies which in turn reduces audible noise, vibration, and mechanical wear. For example, the figure below shows a typical softMC acceleration profile showing how controlled jerk produces smooth acceleration.


Additionally there are parameters that can define the duration of the acceleration/deceleration phases during the movement. These duration times will be used internally to calculate proper motion parameters to meet the time requirements as accurate as possible. <axis/group>.TIMEACCELERATION and <axis/group>.TIMEDECELERATION can be used for time-based definition.

Position and Velocity

Position and velocity are the key command and feedback signals for each axis. These properties are updated by the softMC every motion bus cycle and may be read at any time. Their properties are double-precision floating point numbers. Velocity Units are discussed above. The four properties which hold these values are:

You can read these properties anytime the motion bus is up.

Position error is defined as the difference between position commanded and position feedback. When an axis is at rest, (i.e., ISSETTLED), this simple definition of position error is valid. However, when the axis is in motion, the true position error does not equal the instantaneous commanded position minus the instantaneous feedback position because there is a time delay of several motion bus cycle times from when MOVE is issued until the feedback position is received.

When the softMC calculates position error, it automatically accounts for the communication delay. Depending on the type of motion bus and position manipulations of the drive (micro-interpolation) different values of communication delay can exist.

To manage position error problems, the softMC provides a number of axis and group properties relating to position error. <''axis''>.POSITIONERRORDELAY, allows you to specify the number of motion bus cycle times to apply when calculating position error.

The softMC allows you to set up any axis in your system as a rotary axis. Rotary axes are often used for mechanical mechanisms that repeat after a fixed amount of rotation.

For example, a motor driving a rotating table is often configured as a rotary axis. In this case, the table units are set up as degrees and the units of the axis are set to repeat after 360°. In that way, the position repeats after every rotation of the table, rather than continuing to increase indefinitely. The key to the rotary mode is setting rollover position (POSITIONROLLOVER or PROLLOVER) correctly and accurately.

Consider this example where the axis drives a rotary table through a 5:3 gearbox:

Desired units: Degrees
Desired repeat: 360
Gearbox: 5:3
Feedback 2000 line encoder
For this example, first set position units to degrees:
1 degree = 1/360 revolution of table
= (5/3) * (1/360) revolution of the motor
= 2000 * (5/3) * (1/360) lines
= 4 * 2000 * (5/3) * (1/360) counts
= 40000/1080

After setting these units, you must enable the rotary mode and set the rollover to 360 as follows:

A1.PositionFactor = 40000/1080
A1.PositionRollover = 360
A1.PositionRolloverEn = On  ‘Enable Rotary Motion

In this case, the feedback position is always between 0 and 360. You can still command long moves, say 10,000 degrees. However, when the motor comes to rest, the feedback is read as less than 360.

When using rotary mode in applications where the motor turns continuously in one direction, it is important to take advantage of all available accuracy in the softMC. This is because inaccuracy is accumulated over many revolutions of the motor. For example, we could have rounded A1.POSITIONFACTOR in the above example to 37.037, which is accurate to 1 part in 1,000,000. However, after 10,000 revolutions (2000 rpm for just 5 minutes), that 1 part in a 1,000,000 would have accumulated to a few degrees. This means that if the table position is 100 degrees, it might read as 97°. In other words, the table appears to drift.

In the example above, the math is exact until the softMC performs the division. Because the softMC calculates with double precision (about 14 places of accuracy), you should use softMC math when calculating ratios that cannot be represented precisely in decimal notation. In the example, using the full accuracy of the softMC (about one part in 1014) the motor would have to travel about 3x1011 revolutions to accumulate one degree of error. That is equivalent to 88 years of continuous rotation at 6000 rpm.

All drives provide interface hardware to accept an external or auxiliary encoder. This encoder is in addition to the primary position feedback device. You will need to set up the motion bus cyclic data (EtherCAT: PDO) to support this. External position is frequently used in master-slave operations (gearing and camming) where the system is slaved to an external signal such as a line-operated motor.

The softMC provides the external position through the axis property, POSITIONEXTERNAL or PEXT. This variable contains the accumulated encoder movement of the drive’s external encoder input. It is updated every motion bus cycle.

The softMC allows you to control the units of the POSITIONEXTERNAL (PEXT). This is controlled with POSITIONEXTERNALFACTOR. The process is identical to setting position units for an encoder. The external position and velocity factors are only effective for cases when the motion bus is configured to transmit the external encoder.

The softMC provides the external velocity through the VELOCITYEXTERNAL or <''axis''>.VEXT. This variable contains the accumulated encoder movement per millisecond and is also updated every motion bus cycle when the motion bus is configured to transmit the external encoder.

The softMC allows you to control the units of VELOCITYEXTERNAL with <''axis''>.VELOCITYEXTERNALFACTOR or <''axis''>.VEXTFAC. The process is identical to setting position units except that <''axis''>.VEXTFAC can only be input as an encoder signal.


This section outlines the many types of limits you can impose on the softMC system. These limits help protect the machine from excessive excursions of travel, speed, and torque. There are three types of limits in the system:

  • MC Generator Limits
  • MC Realtime Limits
  • Drive Limits

Limits can be imposed in several ways. First, some limits are imposed by the softMC and others by the drive. Limits can be checked in realtime or they can be checked only for subsequent actions.

MC Generator limits affect subsequent commands to the motion generator. For example, if you change an acceleration limit, this has no effect on the current motion command, but it applies to subsequent motion commands. If the axis is not in a jog or acting as a slave, then POSITIONMIN and POSITIONMAX (position limits) are checked only at the beginning of the move.

The softMC checks realtime limits each update cycle. Changes in these limits affect current operations. VELOCITYFEEDBACK is checked against VELOCITYOVERSPEED in every motion bus cycle.

Drive limits are imposed by the drive. Changes in these limits affect current operations. For example, ILIM limits the peak current that is output by the drive. These limits are imposed independently of the position and velocity commands issued by the controller.

Axis Position Limits

There are several limits in the softMC related to position:



POSITIONMIN (PMIN) and POSITIONMAX (PMAX) place minimum and maximum limits on the position feedback for an axis. Set the limits with:

A1.PositionMin = -10
A1.PositionMax = 200.5

or you can use the short form:

A1.PMin = -10
A1.PMax = 200.5

Position limits must be enabled before they can operate. Limits are enabled with POSITIONMINENABLE and POSITIONMAXENABLE. Position Units are discussed above.

Position limits are checked two ways. First, they are checked in the motion generator. If you command a position move beyond the position limits, an error is generated and the move does not start. Second, they are checked each motion bus update cycle (generally, 2 or 4 ms). If the axis is moving and crosses the position limit, this generates an error.

If the axis has already stopped because the position limits were crossed, the softMC does allow you to back out. In other words, you can enter commands that move the axis back within the limits. The axis will move without generating errors.

Position limits are continuously checked only when the drive is in master-slave mode. Some conditions may occasionally result in the motor moving outside PMIN or PMAX limits which are not detected by the softMC. Drive's position/velocity/torque loop instability may also cause position errors.

You can control whether the softMC watches either one or both of the limits in position limit. To do this, set POSITIONMINENABLE and POSITIONMAXENABLE to either ON or OFF.

A1.PositionMinEnable = ON
A1.PositionMaxEnable = ON

or, you can use the short forms:

A1.PMinEn = ON
A1.PMaxEn = ON

The default state of PMINEN and PMAXEN is off. You must enable them to use these limits.

You should limit the maximum position error your system tolerates. You do this by setting <''axis''>.POSITIONERRORMAX (<''axis''>.PEMAX).

Care should be taken to set PEMAX to a value that matches the needs of the application. When the actual position following error (PE) exceeds PEMAX, motion stops. If the motion is stopped when this condition is detected, the axis is disabled.

During normal operation, occasional occurrences of position error overflow usually indicates a malfunction of the machine, such as a worn or broken part, or a need for lubrication. You should set the maximum position error well outside the boundaries of normal machine operation or nuisance errors occur when the machine is running.

During installation, position error overflow frequently occurs because the system is unstable. In this case, the motor runs away even though zero velocity is commanded. Set POSITIONERRORMAX to a reasonably small value before powering the system up. For example, you might set it to a few revolutions of the motor (or a few inches or centimeters for linear systems). This way, if the tuning is unstable, the system is less likely to cause a problem. Setting PEMAX to a very large number prevents the Position Error Overflow error from detecting an unstable system, and consequently, the motor is able to run away.

The proportional position loop is the simplest position loop. The next figure shows a block diagram of a proportional position loop:


As you can see, the velocity command is proportional to the following error. Large velocity commands need large following error limits. At first, the units of inches/min/mil may seem confusing. The following error for an acceleration with a typical proportional loop is shown in the next figure.


The good news about 100% feed-forward is that it eliminates steady-state following error. The bad news is that the system overshoots when subjected to acceleration or deceleration. In some cases, this is not an issue because the system may always transition smoothly, or some overshoot is acceptable.

<''axis''>.POSITIONERRORSETTLE, defines what level of position error is considered close enough to zero to be settled. For example, you can use:

A1.PositionErrorSettle = 0.01

or you can use the short form:

A1.PESettle = 0.01

to specify that the position error must be below 0.01 units to be considered settled.

  • POSITIONERRORSETTLE is used when the motion controller must determine when an axis is close enough to the final end point of a move to be considered settled. This is commonly used between moves to ensure that the response to the first move is complete before moving to the second. The softMC does this automatically through STARTTYPE when executing MOVE commands as is discussed in the Single Axis Motion section of this manual. You must set TSETTLE>0 or POSITIONERRORSETTLE is ignored.
  • TIMESETTLE (or TSETTLE) defines the amount of time the position error must be lower than the value of PESETTLE before the move is considered settled. After the move profile is complete and the position error is less than POSTIONERRORSETTLE, the softMC waits TIMESETTLE milliseconds for settling. If the position error goes above POSITIONERRORSETTLE during that time, the timer resets.
  • ISSETTLED is a logical (TRUE or FALSE) property that indicates if the axis is settled. To be settled, the motion profile must be complete and the position error must be below POSITIONERRORSETTLE for a period of TIMESETTLE milliseconds.
  • ISMOVING is a property that indicates the state of the motion profiler. The valid range of values is from –1 to 3, with the following meaning:
-1 = element is a slave (gear or cam) unless an incremental move is issued, in which instance the following values are valid:
0 = element is not moving
1 = element is accelerating
2 = element is at constant velocity phase (cruise)
3 = element is decelerating


While a1.ismoving > 0 ‘wait for profiler to finish
End While

Axis Velocity Limits

There are several limits in the softMC related to velocity:

  • VelocityOverspeed defines an absolute motor velocity limit. When this limit is exceeded, an error is generated and the axis is brought to an immediate stop. VELOCITYOVERSPEED is in softMC velocity units and is set any time. It is checked every Motion-Bus update cycle. For example:
A1.VelocityOverspeed = 4000
  • VelocityMax(VMAX) sets the maximum speed that the motion generator can command. VELOCITYMAX is in softMC velocity units and is only set from the terminal window or in the configuration file, Config.Prg. It is checked at the beginning of each move. For example:
A1.VelocityMax = 5000

Two limits control acceleration and deceleration which themselves limit the velocity transients on acceleration profiles. These properties may be set from the terminal or in a user task (or any other context). These are ACCELERATIONMAX and DECELERATIONMAX.

  • ACCELERATIONMAX is the upper limit for acceleration in motion commands. It is in softMC acceleration units.
  • DECELERATIONMAX is the upper limit for deceleration in motion commands. It is in softMC acceleration units.

"Rate" (Scaling) Parameters

The following parameters are used to scale down/up maximum limitations of axes/groups:

  • <Axis/Group>.VelocityRate defines the axis velocity maximum scaling factor from 0.1 to 100 percents independently of acceleration, deceleration or jerk. <''axis''/''group''>.VelocityRate may be modal or nodal.
  • <Axis/Group>.AccelerationRate defines the axis acceleration maximum scaling factor from 0.1 to 100 percents independently of velocity, deceleration or jerk. <''axis''/''group''>.AccelerationRate may be modal or nodal.
  • <Axis/Group>.DecelerationRate defines the axis deceleration maximum scaling factor from 0.1 to 100 percents independently of velocity, acceleration or jerk. <''axis''/''group''>.DecelerationRate may be modal or nodal.
  • <Axis/Group>.JerkRate defines the axis Jerk maximum scaling factor from 0.1 to 100 percents independently of velocity, acceleration or deceleration. <axis>.JerkRate may be modal or nodal.

In these cases "rate" does not mean the change over time but a measure of the axis' maximal values.

For example:

A1.VRate = 50 ‘ VelocityRate 50%
A1.ARate = 70 ‘ AccelerationRate 70%
A1.DRate = 80 ‘ AccelerationRate 80%
A1.JRate = 60 ‘ JerkRate 60%

Verify Settings

Now, you can check the system using the softMC MOVE command. This command is discussed in detail later. For right now, use it to verify some of the settings above. First, enable your drive.


Enable the drive with the following commands:

System.Enable = ON

A1.Enable = ON

After the Motion-Bus is in operational mode. Means the drives are connected and there is cyclic information transfer between SoftMC and the drives (SERCOS: Phase = 4, EtherCAT: Operation)

You must turn on SYSTEM.ENABLE (SYS.EN) before turning on any of the drive-enable properties. This is because when SYSTEM.ENABLE is off, it forces all the axis-enable properties off.

Motion Flags

The next step in preparing a system for motion is turning on the motion flags. There are two motion flags that must be on: the system motion flag and the axis motion flag SYSTEM.MOTION:

System.Motion = ON

A1.Motion = ON


Now you can perform a move command. For example, enter:

Move A1 1000 VelocityCruise = 10

to move to position 1000 with a velocity of 10. You should see the motor move. Use a hand tachometer or other speed sensing device to verify that the speed settings are correct. Move to various positions using the incremental move (by setting Absolute to OFF) and verify your position units:

Move 1000 VelocityCruise = 10 Absolute = Off


Groups allow you to control multiple axes as a single mechanism. With groups, the position command and feedback signals are not single values, but instead they are vectors with two or more elements. These vectors are called points. Points are ordered sets of floating numbers enclosed by pair of curly brackets "{" and "}". For more details abort points-data type see: POINTS. Velocity and acceleration do not apply to a motor, but instead they apply to the combination of two or more motors moving in concert.

Set Up

Groups are combinations of axes. These axes must be orthogonal if their scalar properties (velocity) are to be correct. For example, a group can be used to drive an x-y table. Groups are supported for two- and three-axis machines. In fact, any number of axes can be added to a group.

To set up a group, first set up each of the axes that will be in the group. Then, use Common Shared to form the group:

Common Shared MyGroup as Group AxisName = xAxis AxisName = yAxis

There is no limitation to the number of axes in a group. All axes in the system (including simulated axes) may be part of one group.

As with axes, it is necessary to set VELOCITYFACTOR, ACCELERATIONFACTOR, and JERKFACTOR for the group, however there is not <group>.POSITIONFACTOR As a first approximation, set <group>.VFAC = 1/1000, set AFAC=VFAC/1000, and set JFAC=AFAC/1000.

Acceleration Profiles

As with single axes, the softMC provides controlled acceleration profiles for groups. This reduces vibration and wear on the machine, and allows the highest acceleration rates. You can independently control the acceleration and deceleration rates.

Acceleration and Deceleration

<group>.ACCELERATION and <group>.DECELERATION control the acceleration rates of the group mechanism. For example, the following lines change the acceleration rates for MyGroup:

MyGroup.Acceleration = 1000
MyGroup.Deceleration = 1000

<group>.ACCELERATION and <group>.DECELERATION apply to the combined motion of the individual axes. For example, if MyGroup is a three-axis group formed with Axis1, Axis2, and Axis3, then:

MyGroup.Acc = (Axis1.Accel2 + Axis2.Accel2 + Axis3.Accel2

Group acceleration is the orthogonal combination of the axes‘ acceleration. Group acceleration and deceleration are limited according to the axes‘ values. You can impose limits to constrain the time during which group acceleration and deceleration occurs. <group>.TIMEACCELERATION and <group>.TIMEDECELERATION define the duration of the acceleration phase.

Group Position

Group position differs from axis position in that a single property must represent the position of multiple axes. In some cases, the individual axis properties are maintained so that the property becomes a vector with two or more entries - point data type. This is the case for POSITIONFEEDBACK or POSITIONCOMMAND. In other cases, the position from multiple axes are combined using the square root of the sum of the squares, as for POSITIONERRORMAX.

Point data-types (Vectors)

With groups, three position properties are points: the position command, position feedback, and position final. In each case, the quantities in the points are equivalent to the individual axis properties. For example, you can set POSITIONFINAL as part of a MOVE:

Move MyGroup {5.5, 6.5}

This sets PFINAL of the first axis to 5.5 and the second to 6.5. Querying the position feedback from a two-axis group from the terminal also returns a vector. For example:

? MyGroup.PFb


(5.600443e+003, 6.422422e+003)

The positions in these points are ordered according to the way the group was created with Common…As Group. The first axis declared occupies the first position in the vector, the second occupies the second, etc.

Group's Scalars

Other group position properties are scalars. These properties are the orthogonal combination of the axis properties. These properties include:





If MyGroup is formed with Axis1 and Axis2, and AXIS1.POSITIONTOGO = 1 and AXIS2.POSITIONTOGO=1, MYGROUP.POSITIONTOGO = 1.414, the orthogonal combination of the two axes' POSITIONTOGO. Similarly, when you set POSITIONERRORMAX or POSITIONERRORSETTLE, the position error they are compared to is the orthogonal combination of the axes' POSITIONERROR.

Group Velocity

A group’s scalar velocity properties are always the orthogonal combination of the respective axes' velocity properties. Group velocity properties include:

VELOCITYCOMMAND point property
VELOCITYCRUISE scalar property
VELOCITYFINAL scalar property
VELOCITYMAX scalar property
VELOCITYOVERRIDE scalar property

Group Limits

Group limits are similar to limits placed on axes. Limits can be imposed in two ways: they can be checked realtime, or they can be checked only for subsequent actions.

  • Generator
Generator limits affect subsequent commands to the motion generator. For example, if you change an acceleration limit, this affects subsequent motion commands but has no effect on the current motion.
  • Realtime
The softMC checks realtime limits each motion bus sample. For example, exiting position error of every axis is monitored each SERCOS/EtherCAT/CanOPEN cycle.
  • Position
Position limits are imposed solely by the axes and are checked at the beginning of every movement. If one of the target’s points exceeds its limit, the whole movement is rejected. There are no group position limits. There are also several limits in the softMC related to position:
Set POSITIONERRORMAX (PEMAX) to the total position error the system can tolerate during operation (maximum square root of the sum of squares):
MyGroup.PEMax = 1.0
Set POSITIONERRORSETTLE to the total position error the system can tolerate to be considered in position.
MyGroup.PositionErrorSettle = 1.0
TIMESETTLE (TSETTLE) is the amount of time required before an axis is considered settled (POSITIONERROR<POSITIONERRORSETTLE). After a MOVE/CIRCLE profile is complete, the softMC waits for POSITIONERROR < POSITIONERRORSETTLE for TIMESETTLE milliseconds before setting ISSETTLED.
TIMESETTLEMAX (TSETTLEMAX) defines the amount of time allowed for settling after a move has been commanded. After the MOVE/CIRCLE profile is complete, the softMC waits TIMESETTLEMAX milliseconds for settling. If the position error remains above PESETTLE, an error is generated.
ISSETTLED is a binary (ON or OFF) property that indicates if the group is settled. To be settled, the motion profile must be complete and the orthogonal combination of axis position errors must be below POSITIONERRORSETTLE. The time condition must also be satisfied.
  • Velocity
There is one group limit in the softMC related to velocity: VELOCITYMAX (VMAX) sets the maximum speed the motion generator can command the group. This property is checked at the beginning of each move. For example:
Group.VelocityMax = 5000

The actual executing velocity is also limited according to the group’s axes velocity limitations. The maximum allowed axes velocity is initialize group velocity. In this case a note is returned and can be seen only if SYS.MOTIONASSISTANCE is on.

  • Acceleration
Three limits control acceleration, deceleration, and jerk, which limit the velocity transients on acceleration profiles.
ACCELERATIONMAX is the upper limit for acceleration in softMC acceleration units.
DECELERATIONMAX is the upper limit for deceleration in softMC acceleration units.
The actual executing acceleration and deceleration are limited also according to the group’s axes limitations. The maximum allowed axes of those parameters initialize the group’s values. In this case, a note is returned and can be seen only if SYS.MOTIONASSISTANCE is on.
The jerk properties, JERK, JERKMAX, and [MC-Basic:element.SMOOTHFACTOR|SMOOTHFACTOR]] are applicable in group motion to obtain smooth motion control.

Group Motion

A group is controlled by the motion generator. This software device receives commands from softMC tasks and produces position and velocity commands for each drive in the group every motion bus sample. The two group motion commands are MOVE and CIRCLE. The softMC also provides synchronization of the execution of motion commands as well as changing motion profiles on-the-fly and blending a followed movement. In addition, the softMC provides multiple modes for starting and stopping motion. Several conditions must be met before the softMC generates group motion:

  1. The controlling task must ATTACH to the controlled group.
  2. All axes in the group must be ENABLEd.
  3. The system and axis motion flags must be ENABLEd.

You can declare a group from every context. However, using Config.prg in most applications requires this to only be done once.

A1.Name = xAxis
A2.Name = yAxis
Common Shared xyTable as Group AxisName = xAxis AxisName = yAxis


Now, enable the drives by typing the following in the terminal window:

System.Enable = ON

MyGroup.Enable = ON
  • Motion Flags

The last step in preparing a system for motion is to turn the motion flags ON. There are two motion flags: the system motion flag and the motion flags of each axis within the group. For example:

System.Motion = ON
A1.Motion = ON
A2.Motion = ON
A3.Motion = ON

There is a motion flag for the group that can be used to enable motion for all axes in the group. In many applications, a hardware switch should be tied to the motion flag. The softMC does not have a hardware motion input, but you can use events to create this function. The following example demonstrates a task that uses external input SYSTEM.DIN.1 to control the system motion flag:

Program MotionSwitch
OnEvent MOTION_ON System.DIN.1 = ON System.Motion = ON End OnEvent
OnEvent MOTION_OFF System.DIN.1 = OFF System.Motion = OFF End OnEvent
End Program

  • Attach Task and Group/Axis

Before a task can send motion commands to a group, the group must be attached to the task. This prevents other tasks from attempting to control the group. To attach a group, issue an ATTACH from the controlling task:

Attach MyGroup

If no other task is attached to the group and no axis from the group is attached, the group is immediately attached. Otherwise, an error is generated.

As long as the task has the group attached, no other task can control the group or axes within the group. The axes belonging to the group cannot be controlled independently from other tasks. When a task is finished with a group, it should detach the group:

Detach MyGroup

If a task ends, all attached groups and axes are automatically detached. One exception for the requirement that a group be attached is if the motion command is issued from the terminal window. In this case, assuming the group is not attached by any other task, the group is automatically attached to the terminal window for the duration of the motion.


STOP stops group motion in the motion buffer. In the command, you must specify the group:

Stop GroupA

Normally, STOP is set to stop motion immediately at the rate of DECELERATIONMAX or DECELERATIONSTOP. However, you can modify the effects of STOP with STOPTYPE'. <group>.STOPTYPE can take four values:

STOPTYPE= IMMED Stop group immediately at DECELERATIONMAX on each axis. The current path of the movement is not preserved.

STOPTYPE= ENDMOTION Stop group at the end of the current motion.

STOPTYPE= ONPATH Stop group immediately. Keep the stopping trajectory on the current motion path.

STOPTYPE= ABORT Stop the current motion immediately without the ability to restore the stopped movements.

STOPTYPE defaults to IMMED. If STOPTYPE = ENDMOTION, the current move is completed before STOP is executed. If STOPTYPE = ONPATH, STOP is executed so the group stays on the path. Stopping is according to the current movement’s deceleration and not at maximum deceleration to remain on the path.


After a STOP, you must PROCEED to clear the motion buffer. You can use PROCEEDTYPE to specify which way the motion generator should continue:

PROCEEDTYPE = CONTINUE The motion generator continues the stopped command until complete.

PROCEEDTYPE = NEXTMOTION The motion generator aborts the current move and goes directly to the stopped move in the motion buffer.

PROCEEDTYPE = CLEARMOTION Clears the motion buffer. No motion executes. Default value.

PROCEEDTYPE = ABORT Current motion stops immediately but does not need a PROCEED to start the next motion. Only the current motion is stopped, the following commands are generated.


MOVE for groups is almost identical to a MOVE for axes. There are two differences. First, POSITIONCOMMAND, POSITIONFEEDBACK, and PFINAL are group size vectors. Second, the profile, including ACCELERATION and DECELERATION, applies to all axes in the group. For example:

MyGroup.VCruise = 2000
Move MyGroup {100, 100}

moves to position (100, 100) with a cruise velocity of 2000.

You can override the following axis properties as part of a MOVE:












PFINAL (end of a move), is always specified in MOVE. However, the meaning of PFINAL depends on <group>.ABSOLUTE. This allows point-to-point moves to be specified two ways:

ABSOLUTE = TRUE Final position is specified as actual group position at the end of the move. The final position equals PFINAL.INCREMENTAL.

ABSOLUTE = FALSE Final position is referenced to the start position. The final position is the sum of PFINAL and PCMD at the start of the move. So:

xyTableGroup.Absolute = TRUE
Move xyTableGroup {100, 200}

moves xyTableGroup to position (100, 200).

On the other hand:

xyTableGroup.Absolute = FALSE
Move xyTableGroup {100, 200}

moves xyTableGroup a distance of (100, 200) units from the start position.

ABSOLUTE defaults to INCREMENTAL. You can change ABSOLUTE any time, although the effect does not take place until you issue the next MOVE.


The softMC supports 2-axis circular interpolation with CIRCLE. In CIRCLE, you specify:

Group name

Angle to rotate (in degrees, positive = counter-clockwise) along with Center of the circle (CIRCLECENTER or CTR).

Target point (TARGETPOINT) along with another point on the arc (CIRCLEPOINT).

Circle xyTable Angle=90 CircleCenter = {0,0}


Circle xyTable CirclePoint = {10,20} TargetPoint = {100,200}

A 2-axis circle is generated in a specified plane with incremental movement in the third axis. That generate a 3 axis circle movement but not helical.

Circle xyTable CirclePoint = {10,20,10} TargetPoint = {100,200,20} circleplane= xy

In the above example, the circle is implemented in the XY plane along with the incremental change of the Z axis. Optionally, you can override the following group properties with CIRCLE:












For example, you can enter the following absolute and incremental circular moves:

Circle xyTable Angle=90 CTR = {0,0} Absolute = False

The value of ANGLE is not limited to 360. Greater values are specified to turn the motor more than once. The sign of the angle determines the direction of the motion. The value of ANGLE is not permanent. It exists only in the context of the command in which it is specified. Consequently, you can not query the value of ANGLE.

The value of CIRCLECENTER is not permanent. It exists only in the context of the command in which it is specified. Consequently, you cannot query the value of CIRCLECENTER.

TARGETPOINT is a group size array. It specifies the target point of the circle. This array is not queried. CIRCLE defined using TARGETPOINT is limited to 360 degrees.

CIRCLEPOINT is a position array that specifies a point on the arc. The arc is calculated using the TARGETPOINT and these points. This array is not queried.

In case of 3 dimensions circle the active CIRCLEPLANE defines which group axes participate in the circle movement. The third axis is moved linearly. There are 3 plans that can be chosen: XY, XZ and YZ.

Chain Commands

You can chain group MOVEs and CIRCLEs using <group>.STARTTYPE. The following program makes a series of moves.

A1.Name = xAxis
A2.Name = yAxis
Common Shared xyTable as Group AxisName = xAxis AxisName = yAxis

From another task named MoveCircProgram:

Attach xyTable
xyTable.Absolute = TRUE ‘Move to start position
xyTable.StartType = INPOS ‘Move to start and wait to settleMove xyTable {-3, -2}
While(xyTable.isSettled = False) ‘wait for settling
End While
‘Begin Pattern
xyTable.StartType = GCOM ‘Move smoothly from one move to the next
xyTable.Absolute = FALSE ‘Incremental moves 
Move xyTable {0, 4}
Circle xyTable Angle = -90 CircleCenter = {-2, 2}
Move xyTable {4, 0}
Circle xyTable Angle = -90 CircleCenter = { 2, 2}
Move xyTable {0,-4}
Circle xyTable Angle = -90 CircleCenter = { 2,-2}
Move xyTable {-4,0}
Circle xyTable Angle = -90 CircleCenter = {-2,-2}
While(xyTable.isSettled = False) ‘wait for settling
Detach xyTable
End Program

Move Control

This section reviews options the softMC provides for controlling group MOVEs and CIRCLEs.


Two movements blend tighter to smooth connection points. There are two ways to blend the movements: preserving the movement’s path (CP) or superposition. Set the blending method's ID with BLENDINGMETHOD.

Continuous path (CP)

caption The continuous path method (CP) blends where continuity and velocity smoothness are required (gluing, dispensing, …). It is less useful for high-speed pick and place applications where cycle time is the main quality measurement. Using this blending method, you ensure that maximum space velocities are never exceeded and the original path is always followed. The segment's middle point is always part of the blended path. Only two consecutive motions can be blended together.

caption When the second motion is completed before the first one, the system does not blend the first and the third motions together. The main parameter in this type of blending CP. It specifies the distance from the target point on which the blending (second motion) begins. CP is dimensional. It is expressed in group position units. The system automatically limits this value to half the segments length.

When the second movement is received too late (during the deceleration phase) or when the current motion causes excessive values of acceleration and velocity, blending between two movements is ignored.

For Move-to-Move blending, use:

Pos = start + l1 direction + l2 direction

For Move-and-Circle blending, use:

Pos = start + l1 direction + (cos(l2) rot_start + sin(l2) rot_normal

For Circle-and-Circle blending, use:

Pos = center + (cos(l1) rot_start1 + sin(l1) rot_normal1 + (cos(l2) rot_start1 + sin(l1) rot_normal1

where l1 and l2 are profiler positions of the first and the second motion.


Superposition blends motions at any point of time starting from the initial point of the movement up to the target. This blending mode is not limited by the combined actions of the two motions. It is your responsibility not to blend together motions that, in combination, produce velocities or accelerations outside of allowable system limits. However, each individual motion is limited by the usual kinematics constrains (VMAX, AMAX, DMAX, JMAX). This blending method is also able to swap movements when the second is finished before the first. In this case, there is continuous blending of the first and the third movements. Although this is a feature, it must be taken into consideration when designing blending paths.

Using BLENDINGFACTOR, you define the beginning blending (second motion) point anywhere on the first movement path. It is dimensionless property defining a percentage of the path where the blending starts. A zero value of BLENDINGFACTOR designates full blending, while 100 designates no blending.

For example.

Dim Shared blen_value As Long
Attach xyTable
BlendingMethod = 2
BlendingFactor = 0
StartType = GCom
For blen_value = 100 To 80 Step -5
Move xyTable {0,10} Abs=1 Vcruise=100 BlendingFactor=blen_value
Move xyTable {10,20} Abs=1 Vcruise=100 BlendingFactor=blen_value
Move xyTable {20,10} Abs=1 Vcruise=100 BlendingFactor=blen_value
Move xyTable {10,0} Abs=1 Vcruise=100 BlendingFactor=blen_value
Detach xyTable 
End Program

results in the following profile:


The following are blending limitations:

Blending type of the first movement defines the actual connection path, although the second movement has a different definition. The second movement can blend with the current movement, although its blending method was not defined. In this case, blending occurs according to the second movement.

Throughout the whole blending process, sine-acceleration or trapezoidal velocity profiles are used. However, mixing profile types is not allowed.

In the next example, no blending is ignored:

BlendingMethod = 0 CP = x BlendingFactor = x
BlendingMethod = 1 CP = 0 BlendingFactor = x
BlendingMethod = 2 CP = x BlendingFactor = 100

The Position Command Generator (PCG) has two working modes: single and double. When PCG is in single mode, only one profiler call per sample is allowed. This is identical to no blending. When PCG is in double mode, there are two profiler calls per sample that actually execute the motion superposition. If the profiler of the second motion is in Profiler Following mode, the profiler of the first movement leads both movements. Use DOUBLEMODE to detect double mode interpolation during blending.

Settling Time

The softMC actively watches to determine if the groups are settled into position. In most applications, the group position feedback is slightly delayed from the position command. After a move is complete, some time is required for the actual position to settle out to the commanded position. This time is called settling time.

Ideally, settling time allows the group to move so that position error is zero . However, in real systems you must allow for the condition where the position error never quite reaches zero. On the softMC, you specify how low you consider to be low enough with POSITIONERRORSETTLE or PESETTLE:

xyTableGroup.PESettle = 0.01

After the motion generator completes a move that ends with zero speed, it actively monitors the position error of the group (the orthogonal combination of the position error of each axis) to determine when it is between ±PESETTLE. If it is within this range, <group>.ISSETTLED is true (1). Otherwise, it is false.

In some applications, you must ensure that the position error remains below PESETTLE for a specified period of time before the group is considered settled. The softMC allows you to specify this time period with the <group>.TIMESETTLE or <group>.TSETTLE (given in milliseconds). If the position error exceeds PESETTLE during this time, the timer is reset. If position error is within PESETTLE’s range for the time specified by TSETTLE, <group>.ISSETTLED is true (1). Otherwise, it is false. For example:

PESettle = 0.01
TimeSettle = 0.01 xyTableGroup.StartType = INPOSMove 
xyTableGroup {100 , 200}
Move xyTableGroup {200 , 400}

This example requires that after the motion generator completes the first move and xyTableGroup has position error at or below 0.01 for at least 10 ms before the group is settled. Since STARTTYPE is INPOS, the motion generator waits for these conditions before starting the second move.

Start Moves

When the motion buffer is empty, group moves begin immediately. If you need to delay the next motion, you have two options. You can either use DELAY to insert a fixed delay time or STARTTYPE to delay, depending on a condition.

Use DELAY to force the motion generator to wait a fixed period of time between moves. The motion element xyTableGroup must be specified in DELAY. For example:

Move xyTableGroup {100, -100}
Delay xyTableGroup 1000
Move xyTableGroup {200, 500}

forces a 1 second delay between the two moves. DELAY has units of milliseconds and must be greater than zero.

DELAY differs from SLEEP in that SLEEP delays program execution and DELAY delays only the motion generator. DELAY is forced to the STARTTYPE mode.

If you want to delay the start of a new move until a condition has been met, use <axis>.STARTTYPE. There are four choices:

StartType = GeneratorCompleted or GCOM
When STARTTYPE=GCOM, the new move starts as soon as the motion generator completes the current move's motion.

StartType = InPosition or INPOS
When STARTTYPE=INPOS, the motion generator delays executing the new motion until the current move completes and the position error settles to near zero.

StartType = Immediate (IMMED) or SuperImmediate (SIMM)
When STARTTYPE=IMMED or SIMM, the new move overwrites the current move. This is used when making realtime changes to the profile, such as changing the end-point of the current move without bringing the system to rest. For example, registration applications frequently use this function.

StartType = Sync
When STARTTYPE = SYNC, the motion is synchronized with SYNCSTART.

Chain Moves

When chaining multiple moves which all end at zero speed, you normally want STARTTYPE=INPOS. This forces the motion generator to wait for the position error to become small before starting the next move. If the position profile starts on the second move too soon, the motor may never come to rest. Normally, the desired performance is for the velocity to go to zero before the second move starts. This is the case where STARTTYPE = INPOS.

The ending speed of a MOVE defaults to zero. However, you can specify a speed other than zero as the end speed. To do this, <axis>.VELOCITYFINAL. For example:

MyGroup.VelocityCruise = 2000
Move MyGroup {1.5, -2.33} VelocityFinal = 1000
Move MyGroup {2.0, 4.2} 

When the final velocity is not specified, the movement terminates with zero velocity. If you specify a non-zero final velocity, the smoothness of the motion is your responsibility.

If there are no movement commands to chain, the system stops motion with automatic braking and displays a message.

Multi-Step Moves

Combining non-zero end-point moves in the motion buffer produces multi-step moves. For example:

REM First Step
MyGroup.VelocityCruise = 2000 Move MyGroup {100, 400} VelocityFinal = 1000 ‘Second Step
MyGroup.StartType = GCOM
MyGroup.VelocityCruise = 1000 Move MyGroup {200, 400}

MyGroup.StartType is set to GCOM. The second move begins after the first move is complete. You must use STARTTYPE=GCOM when chaining a move after non-zero velocity end- move. You cannot use STARTTYPE=IMMED or SIMM because the new move overrides the old move. When the movement ends with non-zero final velocity, the next movement is started at the endpoint of the first movement or immediately, if STARTTYPE of the next movement is IMMED or SIMM.

You can combine non-zero velocity end moves to produce profiles with as many steps as needed. However, there are a few restrictions:

STARTTYPE for all non-zero velocity end moves (that is, VELOCITYFINAL<>0) must be GCOM.


PFINAL of the succeeding move must be far enough in front of PFINAL of the current move so the profile is possible with the acceleration limits. An error is generated if this rule is violated.

The end position or the end velocity of a move in progress can be changed by setting STARTTYPE=IMMED and issuing the second move. This move command cancels the current move. For example issuing a move without changing the velocity:

MyGroup.StartType = IMMED
Move MyGroup {150, -400}
Sleep 3000
Move MyGroup {150, -800}

As a second example, if you wanted to change the cruise velocity without changing the end-position, you write:

MyGroup.StartType = IMMED
Move MyGroup {150, -400} abs=1
Sleep 3000
Move MyGroup {150, -400} abs=1 VCruise = 1500

You can change the final position, cruise velocity, and final velocity of any executing move. Observe a few rules:


New and old VELOCITYCRUISE and VELOCITYFINAL must be positive.

If the succeeding move changes PFINAL or VFINAL, it must remain possible to create the profile with the axis acceleration limits.

Synchronize Multiple Axes

The softMC provides the ability to synchronize many single axis and group MOVEs so they all start simultaneously. This is useful when you have multiple axes with moves that are largely independent, but must start at the same time. It is also useful for coordinating a single axis with group.

Synchronization is controlled with <''axis''>.STARTTYPE, and SYNCSTART. The feature allows you to load the motion generator with a motion command, but delaying the generation of motion until SYNCSTART is issued.

For example:

Group1.StartType = SYNC
AuxAxis.StartType = SYNC
Move Group1 {500, 500} VCruise = 2000
Sleep 1000 ‘Program delayed between Move Commands
Move AuxAxis 100 VCruise = 1000
SyncStart Group1 AuxAxis

causes the two profiles to start at the same time.

<''axis''>.STARTTYPE is overridden inside move commands so the above example can be done more conveniently:

Move Group1 {500, 500} VCruise = 2000 StartType = SYNC
Move AuxAxis 100 VCruise = 1000 StartType = SYNC
SyncStart Group1 AuxAxis

You can synchronize as many groups and axes as you want, including simulated axes. Since each SYNCSTART specifies the groups and axes it synchronizes, you can independently synchronize multiple sets of groups and axes.

Clear A Pending Move

If you have loaded a synchronized move in the motion generator and need to delete it, use SYNCCLEAR. For example, if you entered the following command in the above sequence before issuing SYNCSTART:

SyncClear Group1

The Group1 move is deleted. Changing GROUP1.STARTTYPE only affects subsequent moves. You must use SYNCCLEAR to clear pending synchronized moves. SYNCCLEAR has no effect once the move is executing. In this case, you stop the move as you would a non-synchronized move.

Velocity Override

The softMC provides the ability to speed up or slow down all motion commands. This can be applied to an entire machine at once, an entire group, or to individual axes independently. This capability is used extensively in machine development. You can adjust the entire machine speed with a single command. Because the command can be issued from the terminal, you can observe machine operation at a variety of speeds without modifying your program.

All axes on the softMC are controlled with SYSTEM.VELOCITYOVERRIDE (SYS.VORD). For example:

Sys.VOSpd = 25

immediately (if the velocity is previously greater than 25) reduces the velocity of all currently executing MOVEs, CIRCLEs and JOGs, as well as any subsequently issued commands. Since, the velocities are controlled by VOSPD, the acceleration and jerk rates of all axes are proportionally adjusted. The final positions of MOVEs are not affected.

Use <group>.VELOCITYOVERRIDE (<group>.VORD) to override the velocity of a group rather than the entire machine. It is used similarly to SYS.VORD, except it applies only to the group. VORD can be applied to as many or as few groups as is desired and the amount of override specified for one axis is independent of the others.

If you use SYS.VORD and <group>.VORD simultaneously, the axis speed is reduced by the product of both override properties. For example:

Sys.VOrd = 66 ‘Reduce entire system to 2/3 speed

GroupB.VOrd = 50 ‘Reduce GroupB to 1/3 speed

You cannot override an axis in a group. Once an axis is part of a group, it cannot be controlled independently.

Motion Assignment

After assignment, a generic element can be used in all motion commands as a representative of another, usually “real”, motion element. All activities performed on the generic element identically affect the “real” element.

Common Shared Scara As Group AxNm = A1 AxNm = A2 AxNm = A3 AxNm = A4 Model = 4
Gen_Group = Scara
In Task1.Prg:
‘ Scara is attached to Task1.Prg through its generic representative Gen_Group
Attach Gen_Group
? “Scara is attached to “ Scara.AttachedTo
? “Initial position of Scara is “ Scara.PFb
‘ Scara is moved through its generic representative Gen_Group
Move Gen_Group {-300,-500,-40,0} absolute = 1
Sleep 200
? “Final position of Robot is “ Scara.PFb
Detach Gen_Group
--> Scara is attached to TASK1.PRG
--> Initial position of Scara is {0 , 0 , 0 , 0}
--> Final position of Scara is {-300 , -500 , -40 , 0}

Motion Properties

Through assignment, a generic element acquires all properties of the element being assigned to it. Properties of “real” elements can be queried through their generic representatives.

Gen_Axes_List[1] = A1
While Gen_Axes_List[1].IsMoving <> 0 
 Sleep 1
End While
Sys.Dout.1 = 1

Changes made in properties of generic elements identically affect the properties in the referenced “real” elements.

Print “Position Factor and Acceleration of A1 Before SetUp: “ A1.Pfac, A1.Acc
‘ Set A1’s properties through Gen_Axes_List[1]
Call AxisSetUp(Gen_Axes_List[1])
Print “Position Factor and Acceleration of A1 After SetUp: “ A1.Pfac, A1.Acc
--> Position Factor and Acceleration of A1 Before SetUp: 65536 1000
--> Position Factor and Acceleration of A1 After SetUp: 32768 1500