Parametric Programming Lesson Six: System Variables

CNC features of parametric programming

You have now been exposed to the most common computer-related features of parametric
programming. Please be sure to reference your control manufacturer’s programming manual to
see if you have other computer related features that have not been addressed by this text. And
armed with your current knowledge, you should be able to easily understand the information
presented in manuals supplied by your control manufacturer.
As you have seen, computer related features by themselves give the parametric programmer a
formidable programming tool, especially for user-created canned cycle and family-of-parts
applications. These computer related features are extremely important, and will be used
throughout this chapter to build on what you now know and introduce the CNC related features
of parametric programming.
CNC related features allow functions that you would never consider possible with standard CNC
programming. They offer access to many control functions that are not available with standard
G code level commands. Of course, the first step to incorporating any new function or technique
is knowing it is possible to do so. At the very least, this chapter should open your eyes to a
world of new possibilities.
For each CNC feature, we will first introduce the feature and show the syntax of how it is
handled in each version of parametric programming. We will then show some applications for
the feature. While you may not have immediate need for some of the applications we show, our
intention is as much to get you thinking about what can be done as to show you specific
applications. With a little ingenuity, almost anything is possible.
We must point out right away that compared to computer related features, CNC related features
vary much more dramatically from one version of parametric programming to another. For
example, certain CNC related features that are available in one version of parametric
programming may not available in another. Even the most common CNC related features are
handled quite differently among different versions of parametric programming. For this reason,
this chapter begins with the most common CNC related features and works toward the more
obscure. And since there are some CNC features that are very obscure indeed, we will offer
explanations of times when these unusual CNC features can be helpful.
Aside from parametric programming, CNC controls vary with regard to their general capabilities
and user-friendliness. A task that may require parametric programming capabilities on one
control may be part of the standard functions of another. This means some of the applications in
this chapter may not even be applicable in some versions of parametric programming, especially
if the control manufacturer offers other (easier) ways to handle the problem being solved without
parametric programming techniques. For this reason, some examples in this chapter are only
given in the version/s of parametric programming for controls that most requires their use.
Almost all example programs to this point have fallen into the category of either user-created
canned cycles or family-of-parts. These two categories make it very easy to stress applications
for the computer related features. CNC related features, on the other hand, are more commonly
related to the utilities and driving accessory devices categories, and many of the applications
shown in this chapter reflect this point.

1
 Parametric Programming Lesson Six: System Variables

System variables
Most CNC related features of parametric programming are handled with system variables. Like
any other variable in parametric programming, most system variables contain numeric values.
However, each system variable has a fixed function, and can only be used to reference its related
function.
Generally speaking, system variables allow the parametric programmer to access many machine
functions right from within the parametric program. Offsets, machine position, alarm generation,
and current machine states are among the accessible functions. With custom macro B, system
variables range in the #1000 through #6000 series. With user task and Fadal’s macro, system
variables are addressed with special system variable names.
Unfortunately, there are two reasons why this text cannot completely address the specific
techniques needed to utilize every system variable for every version of parametric programming.
First, the actual names of system variables vary from one version to the next, as does the actual
usage for given system variables. This makes it difficult to give firm examples for every version.
Second, and more importantly, names and usage for certain system variables vary even among
control models within a given control manufacturer’s product line. With Fanuc’s custom macro
B for example, the control model and even how the control is equipped with certain control
options determine the actual names of system variables. This makes it next to impossible to
show an example for every possibility.
For this reason, you must be prepared to reference you own control manufacturer’s programming
manual to determine which system variables are available with your particular CNC control/s.
Even with this limitation, this presentation should still nicely demonstrate applications for the
various system variables we show. It will be left up to you to relate these application examples
to your particular control/s. This should require little more than a cross-check of your control
manufacturer’s manual to determine a pertinent system variable’s name.

Access to tool offsets

Almost all versions of parametric programming give you access to the tool offsets within your
control. Though different versions of parametric programming utilize different system variable
names to access specific tool offsets, rest assured that most give you access to every kind of tool
offset within the control. In essence, this gives you the ability to read and write values to and
from tool offsets.
You probably already know that most controls give you the ability to write to the tool offsets
with standard G code level programming techniques. Fanuc, for example, uses a G10 command
for this purpose. However, there is no standard CNC function on most controls (without
parametric programming) that allows you to read the value stored within a tool offset and use it
within your CNC programs. This new ability has some pretty sophisticated implications. But
before we show applications, we will first show the related system variables in each version of
parametric program addressed by this text.
In Fanuc’s custom macro B
As stated earlier, it will be impossible for this text to address all specific offset-related system
variables since their names vary from one control model within the Fanuc product line to
another. Additionally, there is an entirely different set of system variable names from machining

2
 Parametric Programming Lesson Six: System Variables

center controls to turning center controls. To complicate the problem, almost all models in the
Fanuc product line can be equipped with a variety of offset-related alternatives, further changing
the system variable naming structure related to tool offsets.
For this reason, all of our system variable related presentations will be directed at one specific
machining center control (the 15M) and one specific turning center control (the 15T) in Fanuc’s
product line. Additionally, our presentation will be limited to showing each control’s most basic
offset configuration. Rest assured that all techniques we show can be accomplished with any
Fanuc (or Fanuc-compatible) control equipped with custom macro B. If you understand our
presentations, it will be a relatively simple matter to cross reference the related system variable
names based on your own particular control model/s and offset configuration.
Tool length and cutter radius compensation offsets
With the most basic tool offset configuration of the 15M machining center control, there is one
offset value per tool offset. The CNC program determines how the offset value is used (as a tool
length and cutter radius compensation offset). For this offset configuration, you will be using a
series system variables in the #2000 series. #2001 is the value of offset number one. #2002 is
the value of offset number 2. This continues up until the total number of offsets in the control (if
the control has 199 offsets, #2199 is the value of offset number 199).
As stated, you can read and write to and from your tool offsets. The command
#100 = #2001
for example, places the current value of offset number one in common variable #100. On the
other hand, you can also write to your offsets. The command
#2001 = #100
enters the current value of common variable #100 into offset number one. You must, of course,
be careful not to overwrite a needed offset.
Fixture offsets
Another series of system variables is related to fixture offsets (also called work shift offsets).
For the 15M control, these system variables range from #5201 through #5335. This series of
system variables assumes your control has but six fixture offsets. If you have purchased the
option for more, a completely different set of system variables is involved.
As you know, each fixture offset has at least three values (one for X, one for Y, and one for Z).
If your machine has additional axes, there will be more values in each fixture offset. Here is a
chart that shows the fixture offset system variables for a three axis machining center controlled
by a 15M control equipped with six fixture offsets.
Fixture offset #0 (common) Fixture offset #4 (G57)
X - #5201 X - #5281
Y - #5202 Y - #5282
Z - #5203 Z - #5283
Fixture offset #1 (G54) Fixture offset #4 (G58)
X - #5221 X - #5301

3
 Parametric Programming Lesson Six: System Variables

Y - #5222 Y - #5302
Z - #5223 Z - #5303
Fixture offset #2 (G55) Fixture offset #4 (G57) Fixture offset #6 (G59)
X - #5241 X - #5281 X - #5321
Y - #5242 Y - #5282 Y - #5322
Z - #5243 Z - #5283 Z - #5323
Fixture offset #3 (G56) Fixure offset #5 (G58)
X - #5261 X - #5301
Y - #5262 Y - #5302
Z - #5263 Z - #5303
As with tool offsets, you can read or write to or from any fixture offset. The commands
#5221 = -12.1263
#5222 = -12.2245
#5223 = -13.2247
enter the value of fixture offset number one’s X as -12.1263, fixture offset number one’s Y as -
12.2245, and fixture offset number one’s Z as -13.2247. On the other hand, the commands
#100 = #5221
#101 = #5222
#102 = #5223
store the current X, Y and Z values of fixture offset number one into common variables #100,
#101, and #102 respectively.
Turning center wear offsets
Each turning center wear offset contains four values (X, Z, R, and T). A different series of
system variables gives you access to each type. Here is a chart that shows the wear offset related
system variables for a 15T control.
Offset X Z R T
1 #2001 #2101 #2201 #2301
2 #2002 #2102 #2202 #2302
3 #2003 #2103 #2203 #2303
. . . . .
. . . . .
99 #2099 #2199 #2299 #2399
As with any other offset, you can read and write to and from any turning center wear offset. The
command

4
 Parametric Programming Lesson Six: System Variables

#100 = #2101
stores the current Z value of wear offset number one in common variable #100. On the other
hand, the command
#2101 = #100
enters the current value of #100 into the Z value of wear offset number one.

Turning center geometry offsets

Turning center geometry offsets also contain four values (X, Z, R, and T). A different series of
system variables gives you access to each type. Here is a chart that shows the wear offset related
system variables for a 15T control.
Offset X Z R T
1 #2401 #2501 #2601 #2701
2 #2402 #2502 #2602 #2702
3 #2403 #2503 #2603 #2703
. . . . .
. . . . .
. . . . .
99 #2499 #2599 #2699 #2799
As with any other offset, you can read and write to and from any turning center geometry offset.
The command
#100 = #2501
stores the current Z value of geometry offset number one in common variable #100. On the
other hand, the command
#2501 = #100
enters the current value of #100 into the Z value of geometry offset number one.
A trick with system variable numbers
It is often necessary to reference a given offset value by its offset number. But as you can see
from the set of system variables related to offsets, a rather inconvenient system variable number
must be used instead of the offset number itself. For this reason, it can be helpful to reference a
variable (local or common) as part of the system variable’s designation for a given tool offset.
This variable will contain the offset number to be referenced. Consider these commands for a
15M machining center control.
N1 #100 = 1
N2 #[2000 + #100] = 6.5573
In line N1, the value of common variable #100 is being set to one. In line two, this value (one) is
being used as part of the system variable number for a specific tool offset. With this technique,

5
 Parametric Programming Lesson Six: System Variables

#100 is actually the tool length compensation offset number being given a value. In line N2, the
control will first add 2000 to #100, resulting in a value of 2001. The pound sign outside the
brackets specifies that system variable #2001 (the value of offset number one) is being
referenced.
In chapter two, an application is shown that can take advantage of this technique. Here is the call
statement to the right side milling macro shown in chapter two.
N025 G65 P1000 X0. Y0. Z0. W5.0 H3.0 T0.5 D1.0 F5.0 (Mill right side)
In this call statement, letter address argument D is being used to specify the actual diameter of
the milling cutter. However, if you use cutter radius compensation on a regular basis, it may be
more convenient to let D represent the tool offset number in which the milling cutter’s radius is
stored. This will more consistently reflect the method by which your operators normally use
cutter radius compensation offsets. Here is the new call statement, with the modified D word.
N025 G65 P1000 X0. Y0. Z0. W5.0 H3.0 T0.5 D31.0 F5.0 (Mill right side)
Note that the value of D is now 31. The operator must, of course, store the radius of the milling
cutter in offset number thirty-one (0.500 if a 1” diameter cutter is used) before this program can
be run. Here is the modified custom macro program which takes advantage of this new
capability.

O1000 (Custom macro to mill right side)

N1 #100 = #[2000 + #7] (Copy cutter radius from offset to common variable #100)
N2 G00 X[#24 + #23 + #100] Y[#25 - 0.1 + #100] (Rapid to starting position)
N3 G01 Z[#26 - #20 - 0.1] F50. (Fast feed to work surface)
N4 Y[#25 + #11 + #100] F#9 (Mill right side)
N5 G00 Z[#26 + 0.1] Rapid to above workpiece)
N6 M99 (End of custom macro)
In line N1, the value stored in the offset (number 31 in our case) is placed in common variable
#100. This common variable is referenced in every motion command that requires the cutter
radius.
This technique is also helpful when an entire series of offsets must be manipulated in some
manner. Using a simple loop, any number of offsets can be manipulated with a very short series
of commands. Here is an example loop that clears (sets to zero) ninety-nine tool length and
cutter radius compensation offsets. It requires only five commands!
.
.
.
#100 = 1 (Initialize counter for loop to first offset number to one)
N1 IF[#100 GT 99] GOTO 5 (Test if finished with loop)
#[2000 + #100] = 0 (Set current offset value to zero)
#100 = #100 + 1 (Step counter)
GOTO 1 (Go back to test to see if loop is finished)
N5 . . .
.
.

6
 Parametric Programming Lesson Six: System Variables

.
Note that similar techniques can be used with system variables for other offset types (fixture
offsets and all kinds of turning center offsets).
In Okuma’s user task 2
Names for system variables related to offsets remain much the same among the entire Okuma
control product line. About the only major difference you will notice is between machining
center and turning center system variable names. Though this is the case, we still recommend
that you reference your programming manual from Okuma to confirm the names of offset-related
system variables.
Tool length and cutter radius compensation
The system variable name for tool length compensation offsets is VTOFH. A number in
brackets to the right of the system variable name specifies the tool length compensation offset
number. As with any offset, you can read and write to and from the offsets with this variable.
For example, the command
VTOFH[1] = V1
enters the current value of common variable V1 into tool length compensation offset number
one. On the other hand, the command
V1 = VTOFH[1]
stores the current value of tool length compensation offset number one in common variable V1.
In similar fashion, another system variable (VTOFD) handles the cutter radius compensation
offsets. The command
VTOFD[1] = V1
enters the current value of common variable V1 into cutter radius compensation offset number
one. The command
V1 = VTOFD[1]
stores the current value of cutter radius compensation offset number one in common variable V1.
You must, of course, be careful not to overwrite a needed offset.
Fixture offsets
Three more system variables (VZOFX, VZOFY, and VZOFZ) give you access to your fixture
offsets. (Note: If your machine has more than three axes, more than three system variables are
involved.) The commands
VZOFX[1] = V1
VZOFY[1] = V2
VZOFZ[1] = V3
enter the current values of common variables V1, V2, and V3 respectively into the X, Y and Z
positions of fixture offset number one. On the other hand, the commands
V1 = VZOFX[1]
V2 = VZOFY[1]

7
 Parametric Programming Lesson Six: System Variables

V3 = VZOFZ[1]
store the current X, Y, and Z values of fixture offset number one into V1, V2, and V3
respectively.
Turning center offsets
With turning centers, the X and Z value of each offset is available with system variables VTOFX
and VTOFZ. The command
VTOFX[1] = V1
enters the current value of common variable V1 into the X position of offset one. The command
V1 = VTOFX[1]
stores the current X value of offset number one in common variable V1.
In similar fashion, the tool nose radius compensation values of each offset are available through
system variables VNSRX and VNSRZ.
A trick with system variable numbers
You will often need to manipulate the value in brackets (the offset number) when working with
offset related system variables. Note that this number can be referenced with a variable.
Consider these commands:
N1 TLGT = 1
N2 VTOFH[TLGT] = 6.5573
In line N1, the value of local variable TLGT is being set to one. In line two, this value (one) is
being used as part of the system variable for a specific tool offset. With this technique, TLGT is
actually the tool length compensation offset number being set. In line N2, TLGT is used to
determine which offset is being referenced.
In chapter two, an application is shown that can take advantage of this technique. Here is the call
statement to the right side milling macro shown in chapter two.
N025 CALL O1000 XZER = 0 YZER = 0 ZZER = 0 WIDT = 5.0 HGHT = 3.0 THK =
0.5 TDIA = 1.0 FEED = 5.0 (Mill right side)
In this call statement, local variable TDIA is being used to specify the diameter of the milling
cutter. However, if you use cutter radius compensation on a regular basis, it may be more
convenient to let a local variable, say TLFF, represent the tool offset number in which the
milling cutter’s radius is stored. This will more consistently reflect the method by which your
operators normally use tool offsets. Here is the new call statement, modified to use local
variable TLFF as the offset number in which the cutter’s radius is entered.
N025 CALL O1000 XZER = 0 YZER = 0 ZZER = 0 WIDT = 5.0 HGHT = 3.0 THK =
0.5 TLFF = 5.0 FEED = 5.0 (Mill right side)
Note that the value of TLFF is 5. This indicates that the radius position of offset number five is
being used in which to store the cutter’s radius. The operator must, of course, store the radius of
the milling cutter in offset number five (0.500 if a 1” diameter cutter is used) before this program
is run. Here is the modified user task program which takes advantage of this new capability.

8
 Parametric Programming Lesson Six: System Variables

O1000 (User task program to mill right side)

N1 TRAD = VTOFD[TLFF]
N2 G00 X=XZER+WIDT+TRAD Y=YZER-0.1+TRAD (Rapid to starting position)
N3 G01 Z=ZZER-THK-0.1 F50. (Fast feed to work surface)
N4 Y=YZER+HGHT+TRAD F=FEED (Mill right side)
N5 G00 Z=ZZER+0.1 Rapid to above workpiece)
N6 RTS (End of user task program)
In line N1, the value stored in the offset (number 5 in our case) is placed in local variable TRAD.
This local variable is then referenced in every motion command that requires the cutter radius.
This technique is also helpful when an entire series of offsets must be manipulated in some
manner. Using a simple loop, any number of offsets can be manipulated with a very short series
of commands. Here is an example loop that clears (sets to zero) ninety-nine tool length and
cutter radius compensation offsets. It requires only six commands!

.
.
.
TLFF = 1 (Initialize counter for loop to first offset number to one)
N1 IF[TLFF GT 99] GOTO N5 (Test if finished with loop)
VTOFH[TLFF] = 0 (Set current tool length offset value to zero)
VTOFD[TLFF] = 0 (Set current cutter radius offset to zero)
TLFF = TLFF + 1 (Step counter)
GOTO N1 (Go back to test to see if loop is finished)
N5 . . .
.
.
.

Note that similar techniques can be used with system variables for other offset types (fixture
offsets and all kinds of turning center offsets).
In Fadal’s macro
Fadal also uses a series of system variables to allow access to offset data.
Tool length and cutter radius compensation
For tool length compensation offsets, you use a series of H codes that correspond to the offset
number. For example, the command
#H01 = V1
enters the current value of V series variable V1 into tool length compensation offset number one.
On the other hand, the command
#V1 = H01
enters the value of tool length compensation offset number one into V series variable V1.
In similar fashion a series of D codes allow access to cutter radius compensation offsets. The
command

9
 Parametric Programming Lesson Six: System Variables

#D01 = V1
enters the current value of V series variable V1 into cutter radius compensation offset number
one. On the other hand, the command
#V1 = D01
enters the value of cutter radius compensation offset number one into V series variable V1. You
must, of course, be careful not to overwrite a needed offset.
Fixture offsets
Another series of system variables is related to fixture offsets (also called work shift offsets). As
you know, each fixture offset has at least three values (one for X, one for Y, and one for Z). If
your machine has additional axes, there will be more values in each fixture offset.
FX1 through FX48 allow access to the X value of each fixture offset. FY1 through FY48 allow
access to the Y value for each fixture offset. FZ1 through FZ48 allow access to the Z value for
each fixture offset. If your machine has a rotary axis, FA1 through FA48 or FB1 through FB48
allow axis to the rotary axis value of each fixture offset. For example, the commands
#FX1 = V1
#FY1 = V2
#FZ1 = V3
enter the values of V series variables V1, V2, and V3 into fixture offset number one’s X, Y, and
Z positions respectively. On the other hand, the commands
#V1 = FX1
#V2 = FY1
#V3 = FZ1
enter the values fixture offset number one’s X, Y, and Z positions into V series variables V1, V2,
and V3 respectively.
A trick with system variable numbers
You will often need to manipulate the system variable number when working with offset related
system variables. Note that the number of the system variable can be referenced with a variable.
Consider these commands:
N1 #V1 = 1
N2 #H(V1) = 6.5573
In line N1, the value of V series variable V1 is being set to one. In line two, this value (one) is
being used as part of the system variable name for a specific tool offset. With this technique, V1
is actually the tool length compensation offset number being set. Note that this variable (or
arithmetic expression) must be placed in parentheses. In line N2, V1 is used to determine which
offset is being referenced.
In chapter two, an application is shown that can take advantage of this technique. Here are the
calling commands to the right side milling macro.
.

10
 Parametric Programming Lesson Six: System Variables

.
.
N025 #V1=0 ‘Assign argument V1
N030 #V2=0 ‘Assign argument V2
N035 #V3=0 ‘Assign argument V3
N040 #V4=5.0 ‘Assign argument V4
N045 #V5=3.0 ‘Assign argument V5
N050 #V6=0.5 ‘Assign argument V6
N055 #V7=1.0 ‘Assign argument V7
N060 #V8=5.0 ‘Assign argument V8
N065 M98 P1000 (Mill right side)
.
.
.
In line N055, V series variable V7 is being used to specify the diameter of the milling cutter.
However, if you use cutter radius compensation on a regular basis, it may be more convenient to
let V7 represent the tool offset number in which the milling cutter’s radius is stored. This will
more consistently reflect the method by which your operators normally use tool offsets. Here are
the new calling commands, modified to use V7 as the offset number in which the cutter’s radius
is stored.
.
.
.
N025 #V1=0 ‘Assign argument V1
N030 #V2=0 ‘Assign argument V2
N035 #V3=0 ‘Assign argument V3
N040 #V4=5.0 ‘Assign argument V4
N045 #V5=3.0 ‘Assign argument V5
N050 #V6=0.5 ‘Assign argument V6
N055 #V7=5.0 ‘Assign argument V7
N060 #V8=5.0 ‘Assign argument V8
N065 M98 P1000 (Mill right side)
.
.
.
Note that the value of V7 is now 5. This indicates that the radius position of offset number five
is being used in which to store the cutter’s radius. The operator must, of course, store the radius
of the milling cutter in offset number five (0.500 if a 1” diameter cutter is used) before this
program is run. Here is the modified macro program which takes advantage of this new
capability.

O1000 (Macro program to mill right side)

N1 #V21 = D(V7) ‘Place cutter radius in V21
N2 #R0=V1+V4+V21 `Calculate X position for cutter
N3 #R1=V2-0.1-V21 `Calculate Y starting position

11
 Parametric Programming Lesson Six: System Variables

N4 #R2=V3-V6-0.1 `Calculate work surface position in Z

N5 #R3=V2+V5+0.1+V21 `Calculate Y ending position
N6 #R4 = V8 `Transfer feedrate into R4
N7 #R5 = V3 + 0.1 `Calculate clearance position in Z
N8 G00 X+R0 Y+R1 (Rapid to starting position)
N9 G01 Z+R2 F50. (Fast feed to work surface)
N10 Y+R3 F+R4 (Mill right side)
N11 G00 Z+R5 (Rapid to above workpiece)
N12 M99 (End of parametric program)
In line N1, the value stored in the offset (number 5 in our case) is placed in V series variable
V21. This V series variable is then referenced every time the cutter radius is required.
This technique is also helpful when an entire series of offsets must be manipulated in some
manner. Using a simple loop, any number of offsets can be manipulated with a very short series
of commands. Here is an example loop that clears (sets to zero) ninety-nine tool length and
cutter radius compensation offsets. It requires only eight commands!
.
.
.
#V1 = 1 ‘Initialize counter for loop to one
#:LOOPBEGIN ‘Beginning of loop
#IF V199 THEN GOTO :EXITLOOP ‘Test if finished with loop
#H(V1) = 0 ‘Set current tool length offset value to zero)
#D(V1) = 0 ‘Set current cutter radius offset to zero
#V1 = V1 + 1 ‘Step counter
#GOTO :LOOPBEGIN ‘Go back to test to see if loop is finished
#:EXITLOOP ‘End of loop
.
.
.
Note that similar techniques can be used with system variables for other offset types (fixture
offsets and all kinds of turning center offsets).
Do you have more offsets than we have discussed?
Again, we have only introduced the most common offset types in their most basic configurations.
If your particular control/s have more and/or different offset specifications (like zero shift
offsets), it is very likely that you have access to them through the use of (other) system variables.
You must reference you programming manual to determine which system variables are involved.

Applications for offset access

While the actual method of offset access varies from one version of parametric programming to
another, the reasons why offset access is helpful remains quite consistent. Though this new
capability may not at first glance seem at all earth-shattering, having the ability to read and write
values to and from your offset tables has important implications.

12
 Parametric Programming Lesson Six: System Variables

As extra variables
The first application we present has little to do with actually needing offsets for a special
purpose. We just want to mention that if you run out of variables for your parametic
programming applications, your offset table makes an excellent place to find more. As long as
you do not over-write a needed offset, you can use your offsets as a kind of permanent common
variable (since offset values are not lost when you turn the power off). Depending upon the
control model and type, you may have many unused offsets.
Improving upon compensation types
As you know, offsets are normally used with some form of tool compensation. Machining
centers require offsets for tool length compensation, cutter radius compensation, and fixture
offsets. Turning centers require them for wear offsets, (possibly) geometry offsets, and tool nose
radius compensation. While all of these compensation types are very important and most are
relatively easy to use, all compensation types are quite inflexible in the way they must be used.
In certain applications, you may not agree with the method by which they must be used. Or it
simply may not be convenient to use the compensation type in its intended manner. With
parametric programming, you actually have the ability to improve upon your current
compensation types with utility programs.
Here is a specific example. Say your turning center operators are constantly making decimal
point entry mistakes when entering turning center wear offsets. If, for example, they determine a
wear offset entry should be 0.002 in, they sometimes make a mistake and enter the value as
0.200 instead. To begin to improve upon your current tool wear offset compensation type, you
may determine that offset values should never be over a given amount, say 0.150 in (in your own
opinion). If any wear offset is larger than 0.150 in, it is very likely that an entry error has been
made.
By having wear offset values available to your parametric program for testing, you can actually
develop a series of tests to determine if any of the current offset values are greater than 0.150 in.
If they are, an alarm can be sounded!
In custom macro B
We’ll say that this turning center has twelve turret stations and that wear offsets one through
twelve must be tested in this manner (both X and Z). Here is the series of commands that do the
testing. Note that a loop is used to minimize the number of required commands.
.
.
.
#100 = 1 (Counter for loop)
N1 IF[#100 GT 12] GOTO 5 (Test if loop is finished)
IF[#[2000 + #100] LT 0.15] GOTO 2 (Test if X offset is under 0.15 in)
#3000 = 100 (X OFFSET TOO BIG)
N2 IF[#[2100 + #100] LT 0.15] GOTO 3 (Test if Z offset is under 0.15)
#3000 = 101 (Z OFFSET TOO BIG)
N3 #100 = #100 + 1 (Step counter)
GOTO 1 (Go back to see if loop is finished)
N5 . . .
.
.

13
 Parametric Programming Lesson Six: System Variables

.
In the second and third IF statements, notice again how the system variable related to each wear
offset is referenced using a common variable (#100). The expression #[2000 + #100] first adds
the value of #100 to 2000 (result: 2001, 2002, 2003, and so on). The pound sign outside the
brackets allows the system variable number itself to be a changing value, based on the value of
common variable #100.
In user task 2
We’ll say that this turning center has twelve turret stations and that wear offsets one through
twelve must be tested in this manner (both X and Z). Here is the series of commands that do the
testing. Note that a loop is used to minimize the number of required commands.
.
.
.
TLFF = 1 (Counter for loop)
N1 IF[TLFF GT 12] GOTO N5 (Test if loop is finished)
IF[VTOFX[TLFF] LT 0.15] GOTO N2 (Test if X offset is under 0.15 in)
VUACM[1] = `X OFFSET TOO BIG’
VDOUT[991] = 100
N2 IF[VTOFZ[TLFF] LT 0.15] GOTO N3 (Test if Z offset is under 0.15)
VUACM[1] = `Z OFFSET TOO BIG’
VDOUT[991] = 101
N3 TLFF = TLFF + 1 (Step counter)
GOTO N1 (Go back to see if loop is finished)
N5 . . .
.
.
.
In the second and third IF statements, notice how the system variable related to each wear offset
is referenced the local variable TLFF. The coding VTOFX[TLFF] renders the value of the offset
number equal to the current value of TLFF (offset 1, 2, 3, and so on).
Any other ideas?
Remember that almost any compensation type can be improved, based upon specific problems
you (or your operators) are having. Many machining center controls, for example, force the
operator to work with very large, cumbersome tool length compensation values. If workpiece
sizing must be done on a regular basis (possibly to bring a critical pocket to its correct depth), it
can be difficult for the operator to calculate the direction (plus or minus) and amount of offset
change. And once they do, the must then add or subtract this value from a very large tool length
value in order to come up with the correct value of the offset. This task takes time and is error
prone, even for experienced operators. For those tools that require this kind of critical and
cumbersome sizing, you could easily add a special sizing offset. The operator will simply enter
the small deviation between the desired and actual pocket depth in this offset, making it much
easier to size the pocket. In the positioning command that brings the tool to the bottom of this
critical pocket, you can easily reference the value of this secondary offset, making the tool go
precisely to its correct depth. The same techniques can be used for cutter radius compensation
when critical tolerances must be held when performing peripheral milling.

14
 Parametric Programming Lesson Six: System Variables

User defined compensation types

There are certain tooling, setup, and programming problems that no standard compensation
functions are designed to handle. Yet with the ability to access offset values from within
parametric programs, you can actually develop your own special compensation utilities and solve
previously impossible problems! Truly, only your own ingenuity limits what can be done in this
regard.
Figure 5.1 shows a workpiece that stresses the need for a user-defined compensation type.

Figure 5.1
The turning operations for this workpiece are done by a screw machine. When setup, the screw
machine will run about 500-600 workpieces before tool maintenance is required. Note the rather
open tolerance on the overall length of the workpiece (plus or minus 0.002 in). During tool
maintenance on the screw machine, the overall length of the workpiece will change slightly.
Though the change in workpiece length is very small, and though the overall length is still well
within the tolerance band, this change in workpiece length can wreak havoc with the subsequent
CNC machining center operation due to the nature of the setup being used. Figure 5.2 shows the
setup.

15
 Parametric Programming Lesson Six: System Variables

Figure 5.2
Note that eight workpieces are sandwiched and clamped against one another in the fixture.
When machining the hole in the outside diameter of each workpiece, any change in workpiece
length will cause an accumulation of error in the hole locations being machined on the
machining center.
Remember, about 500-600 blank workpieces are machined by the screw machine with no
deviation in workpiece length. It is only when a new batch of blanks come through (about once
per shift) that the CNC machining center operator must deal with this problem.
Admittedly, this may be more a fundamental problem with fixture design than it is a
programming problem, and your tool designer may be able to design a fixture that eliminates the
problem altogether. However, this is a real world example of the kind of problem a CNC person
faces on a regular basis - one that no standard compensation type is designed to solve.
With your new ability to access offset values from within a CNC program, however, you can
easily overcome this problem. A special tool offset (we’ll use offset number ninety-nine) will be
used in which to store the deviation between the nominal workpiece size (0.500 in) and the
actual workpiece size. If, for example, a batch of workpiece blanks comes through as 0.5007 in
long, the operator will simply store a value of plus 0.0007 in offset number ninety-nine. If the
blanks coming through are 0.4994 long, the operator stores a value of minus 0.0006 in offset
ninety-nine.
Here is a portion of the program shown in custom macro B format that counterbores the eight
holes (you should now be able to easily convert this program to any version of parametric
programming). Program zero is the left most end of the stack in X and the center of the

16
 Parametric Programming Lesson Six: System Variables

workpieces in Y and Z. Notice how every hole location in X references the value stored in offset
ninety-nine.
.
.
.
N225 T03 M06 (Place counterbore in spindle)
N230 G54 G90 S700 M03 T04 (Select coordinate system, absolute mode, turn spindle
on, get next tool ready)
N235 G00 X[0.25 + #2099/2] Y-1.0 (Move into position for first hole)
N240 G43 H03 Z1.25 (Instate tool length compensation, rapid up close in Z)
N245 G82 R1.25 Z0.25 F4.5 (Counterbore first hole)
N250 X[0.75 + #2099 + #2099/2] (Second hole)
N255 X[1.25 + #2099*2 + #2099/2] (Third hole)
N260 X[1.75 + #2099*3 + #2099/2] (Fourth hole)
N265 X[2.25 + #2099*4 + #2099/2] (Fifth hole)
N270 X[2.75 + #2099*5 + #2099/2] (Sixth hole)
N275 X[3.25 + #2099*6 + #2099/2] (Seventh hole)
N280 X[3.75 + #2099*7 + #2099/2] (Eighth hole)
N285 G80 (Cancel cycle)
.
.
.
You can easily determine whether enhancing current compensation types or developing new
ones can help by watching and talking to your CNC operators. What kinds of problems are they
having? Are they making the same mistakes over-and-over again when adjusting offsets for
sizing purposes? Are they taking additional time performing (error prone) calculations before
they can even enter the offset adjustment? Are they having problems understanding the rational
behind how certain offset values must be entered? Do they have to measure one attribute in
order to determine the offset setting of another (measuring over the pins after a threading
operation, for instance). If the answer to any of these questions is yes, you can likely simplify
the value and method of offset entry. As stated, only your own ingenuity will limit what can be
done!
Referencing offsets in program zero assigning commands
If you are using offsets to assign program zero (fixture offsets on machining centers or geometry
offsets on turning centers), you can skip this section. On the other hand, if you are assigning
program zero in the program (with G92 on machining centers or G50/G92 on turning centers),
you will find this section very interesting indeed.
One of the advantages of using offsets to assign program zero is that the program zero
specification is kept separate from the program. Program zero assigning values are entered into
offsets by the operator during setup. This is especially helpful on turning centers when the same
cutting tools are commonly used from one setup to the next. For tools that remain in the turret
from job to job, program zero assigning values need not be changed.
While there are exceptions to this statement based on your methods of assigning program zero, if
you are assigning program zero in the program, it is likely that the setup person must re-enter the
program zero setting numbers for every tool in every setup (even for tools used from one

17
 Parametric Programming Lesson Six: System Variables

production run to the next). This will take time and is quite error prone since four values per tool
must be changed. Here is a portion of a turning center program (in Fanuc format) that uses G50
to assign program zero from within the program. Note that this is a very common technique with
Fanuc-controlled turning centers that do not have geometry offsets.

O0013 (Program number)

N005 G50 X10.2356 Z6.8277 (Assign program zero for tool one)
N010 T0101 (Index to station one)
N015 G96 S500 M03 (Start spindle)
N020 G00 X4.2 Z0.005 (Rapid to approach position)
N025 G01 X-0.06 F0.012 (Rough face workpiece)
N030 G00 Z0.1 (Rapid away from workpiece)
N040 G00 X10.2356 Z6.8277 T0100 (Rapid to tool change position, cancel offset)
N045 M01 (Optional stop)
.
.
.
Note that line N005 assigns program zero and in line N040, the tool is sent back to precisely this
starting position. With this programming format, again, four values per tool must be changed
within the CNC program for every program run.
With your new ability to reference offset values from within your CNC program, you can easily
modify the G50 command that assigns program zero and the G00 command that returns the
machine to its tool change position for each tool to include a reference to an offset. In essence,
you can gain one of the main benefits of geometry offsets, the ability to keep program zero
assigning values separate from the program.
Say your turning center has twelve tool stations and thirty-two offsets (a common scenario).
You will still use offsets one through twelve as your wear offsets. However, now you can use
offsets twenty-one through thirty-two in which to store the program zero assigning values for
tools one through twelve. Consider the same program, modified to utilize offsets as program
zero assigning values.

O0013 (Program number)

N005 G50 X[#2021] Z[#2121] (Assign program zero for tool one)
N010 T0101 (Index to station one)
N015 G96 S500 M03 (Start spindle)
N020 G00 X4.2 Z0.005 (Rapid to approach position)
N025 G01 X-0.06 F0.012 (Rough face workpiece)
N030 G00 Z0.1 (Rapid away from workpiece)
N040 G00 X[#2021] Z[#2121] T0100 (Rapid to tool change position, cancel offset)
N045 M01 (Optional stop)
.
.
.
Now, instead of entering the values X10.2356 and Z6.8277 in the program (in two places each),
the setup person will enter the value 10.2356 in the X register of offset number twenty-one and

18
 Parametric Programming Lesson Six: System Variables

6.8277 in the Z register of offset number twenty-one. With this technique, only two entries (one
for X and one for Z) are required per tool. And when going from one production run to the next,
these values need not be re-entered for tools that stay in the turret.
Note that this technique can also be used on machining centers if you are using G92 to assign
program zero in the program (it is especially helpful if you are repeating the G92 command at
the beginning of each tool). The command (given in Fanuc format)
N005 G92 X[#2097] Y[#2098] Z[#2099]
retrieves the value in offset number ninety-seven and uses it for the X value of the G92
command. The value in offset number ninety-eight is used for Y, and offset ninety-nine is used
for Z.
Remember that this techniques overcomes but one of the limitations of assigning program zero in
the program. The most severe limitation, however, still exists. If the machine is not in its proper
starting position when the program is activated (the machine is out of position), the control will
utilize an incorrect program zero assigning command - and the results can be disastrous. Later,
as we discuss access to the machine’s position, we will show how to refine this technique, and
minimize the potential for disaster.

Access to current position

This function of parametric programming gives you the ability to determine the machine’s
position in any axis at any time during the execution of a program. Some versions of parametric
programming allow the ability to determine machine position in several ways, but almost all
allow, at the very least, the ability to access the machine’s current position in the absolute mode
relative to program zero in the current coordinate system.
Again, we will show how this is done in each version of parametric programming before we
discuss the implications of when this can be helpful.
In custom macro B
Custom macro B allows you to access the machine position in several ways. The three most
important ways are 1) relative to the machine’s zero return (reference) position, 2) relative to the
program zero point of the current coordinate system (absolute position), and 3) relative to the
program zero point of the current coordinate system at the instant of probe stylus contact. Here
are the system variables involved.
Three axis machining center:
#5001 - Current X position relative to program zero in the current coordinate system
#5002 - Current Y position relative to program zero in the current coordinate system
#5003 - Current Z position relative to program zero in the current coordinate system

#5021 - Current X position relative to the machine’s zero return position

#5022 - Current Y position relative to the machine’s zero return position
#5023 - Current Z position relative to the machine’s zero return position

19
 Parametric Programming Lesson Six: System Variables

#5061 - Current X position relative to the program zero point in the current coordinate system at
the instant of probe stylus contact
#5062 - Current Y position relative to the program zero point in the current coordinate system at
the instant of probe stylus contact
#5063 - Current Z position relative to the program zero point in the current coordinate system at
the instant of probe stylus contact
Two axis turning center:
#5001 - Current X position relative to program zero in the current coordinate system
#5002 - Current Z position relative to program zero in the current coordinate system

#5021 - Current X position relative to the machine’s zero return position

#5022 - Current Z position relative to the machine’s zero return position

#5061 - Current X position relative to the program zero point in the current coordinate system at
the instant of probe stylus contact
#5062 - Current Z position relative to the program zero point in the current coordinate system at
the instant of probe stylus contact
In user task 2
User task 2 allows you to access the current absolute position relative to the program zero point
in the current coordinate system (the current absolute position) in each axis. For a three axis
machine tool, three system variables are involved.
VSIOX - Current X position relative to the program zero point in the current coordinate system
VSIOY - Current Y position relative to the program zero point in the current coordinate system
VSIOZ - Current Z position relative to the program zero point in the current coordinate system
In Fadal’s macro
Macro allows you to access the current absolute position relative to the program zero point in the
current coordinate system (the current absolute position) in each axis. For a three axis machine
tool, three system variables are involved.
AX - Current X position relative to the program zero point in the current coordinate system
AY - Current Y position relative to the program zero point in the current coordinate system
AZ - Current Z position relative to the program zero point in the current coordinate system
Applications for axis position access
There are several times when it can be helpful to find the machine’s current position from within
a parametric program. Here we offer a few.

20
 Parametric Programming Lesson Six: System Variables

With user-created canned cycles

In chapters two, three, and four, we offered several user-created canned cycle examples. With
most machining operations, it is necessary to specify (with arguments) the location of the
machining operation to be performed. In the case of the user-created canned cycle for thread
milling, for example, it is necessary to specify the location of the hole to be thread milled in X
and Y. With the grooving example, it is necessary to specify the location of the groove to be
machined in X and Z.
With certain applications, you may elect to allow your user-created canned cycle parametric
program to assume that the tool is in certain relationship with the machining operation being
performed when the parametric program is activated. This will minimize the number of
arguments that must be specified in the call statement. With the user-created canned cycle for
thread milling, for example, you can let the parametric program assume that the milling cutter is
positioned right in the center of the hole to be thread milled in X & Y. This will eliminate the
need to specify the X and Y position to the parametric program, which in turn, shortens the call
statement.
The best way to achieve this goal is to access the machine’s current absolute position in X, Y,
and Z at the very beginning of the parametric program (before any motion is generated). This
will allow you to work in the absolute mode during the positioning movements of the user-
created canned cycle parametric program. Here is an example for thread milling shown in user
task 2 format. It is identical to the example shown at the end of chapter three, with one
exception. Notice that the specification of the hole center in X and Y (XCTR and YCTR) are
omitted from the call statement. In line N160 of the main program, the tool is sent to the hole
center in X and Y (2.0 in X and 2.0 in Y). The user task program will access this position and
use it as a reference point for motion commands.

O0006 (Program number)

.
.
(Machine hole to get ready for thread milling)
.
.
N150 T04 M06 (Place thread milling cutter in spindle)
N155 G90 G54 S400 M03 T05 (Select absolute mode, coordinate system, start spindle,
get next tool ready)
N160 G00 X2.0 Y2.0 (Rapid over to center of hole)
N165 G43 H04 Z.1 (Rapid up to workpiece in Z)
N170 CALL O1006 THK=0.75 PICH=0.125 TDIA=1.0 MDIA=3.0 ARAD=1.0 FEED=5.0
(Call user task program and mill thread)
.
.
.
User task program to mill thread:
O1006 (Program number)
XCTR = VSIOX (Store X position in local variable XCTR)
YCTR = VSIOY (Store Y position in local variable YCTR)

21
 Parametric Programming Lesson Six: System Variables

TRAD = TDIA/2 (Set TRAD to the radius of the cutter)

CURZ = -[THK + 0.1] (Initial Z position)
G00 X=XCTR Y=YCTR+MAJR/2-ARAD (Rapid to center of approach radius, point 1)
Z=CURZ (Rapid to beginning Z position)
CURZ = CURZ - PICH/4 (Calculate Z position at end of approach radius)
G01 X=XCTR-ARAD+TRAD F=FEED*5 (Fast feed to beginning of approach radius,
point 2)
G02 X=XCTR Y=YCTR+MAJR/2-TRAD Z=CURZ R=ARAD-TRAD F=FEED (Circular
approach to beginning of thread, point 3)
CURZ = CURZ - PICH/2 (Calculate Z position half way around thread)
G02 Y=YCTR-MAJR/2+TRAD Z=CURZ R=MAJR/2-TRAD (Mill half way around
thread, point 4)
CURZ=CURZ-PICH/2 (Calculate Z position at end of thread)
G02 Y=YCTR+MAJR/2-TRAD Z=CURZ R=MAJR/2-TRAD (Mill balance of thread,
point 5)
CURZ = CURZ - PICH/4 (Calculate Z position at end of retract radius)
G02 X=XCTR+ARAD-TRAD Y=YCTR+MAJR/2-ARAD Z=CURZ R=ARAD-TRAD
(Retract to point 6)
G00 X=XCTR (Return to center of approach radius)
Z0.1 (Rapid to clearance position above workpiece)
RTS (end of user task program)
While we only show one version of this program, you can easily apply the same techniques to
the custom macro B and macro versions of this program.
A tool length measuring program
While many companies have moved the setup-related task of measuring tool lengths for
machining center setups off line (measure tool lengths for the next job during the current
production run), there are many companies that still measure tool lengths on line during setup.
Maybe there is no one available to measure tool lengths during the production run. Or maybe the
lot size is so small that there is no time to set up and measure tool lengths off line.
Regardless of the reason, if tool lengths must be measured on line, you must make it as easy as
possible for your setup people to perform the tool length measuring function. Tool length
measuring probes make this task about as easy as it can be. However, many companies do not
have tool length measuring probes and must rely solely on the setup person to perform rather
tedious and error prone measurements for each tool while the machine is down between
production runs.
If your setup people must make manual measurements on the machine to measure each tool’s
length (and, of course, enter each tool length value into the corresponding offset), you can
dramatically facilitate the task with a utility parametric program designed to help measure tool
lengths. This program will take advantage of the ability to access the machine’s current position
from within a program together with the ability to enter values into tool length offsets.
To keep our example simple to follow, we will make five assumptions. First, we will assume
that you are using the length of each tool as the tool length compensation offset value. Second,
we will also assume that the offset number for each tool corresponds to the tool station number
(offset one for station number one, offset two for station number two, and so on). Third, we will

22
 Parametric Programming Lesson Six: System Variables

assume that all tools to be measured, assembled and loaded into the machine’s tool magazine
prior to running this utility program. Fourth, we assume that the setup person uses a three inch
block to touch each tool. This block is placed directly on the table top prior to tool measurement.
And finally, we will assume that your setup people will always have a series of tools in
consecutive tool stations to measure.
In custom macro B format:
Prior to using this program for the first time, the distance from the table top to the machine
spindle nose must be measured. This value will be placed in permanent common variable #500.
Note that this measurement is taken with the machine resting at its zero return position.

O0014 (Program number)

#100 = 1 (First tool to measure)
#101 = 15 (Last tool to measure)
#102 = #100 (Initialize counter for loop)
N1 IF[#102 GT #101] GOTO 99 (Test if finished)
G91 G28 Z0 M19 (Return to tool change position, orient spindle)
T#102 M06 (Place current tool in spindle)
#3006 = 101 (TOUCH TOOL TIP TO BLOCK) (Stop with message command)
#[2000 + #102] = #500 - 3 - ABS[#5023] (Set offset)
G91 G01 Z.5 F30. (Move away from block)
#102 = #102 + 1 (Step counter)
GOTO 1 (Go back to test)
N99 M30 (End of loop and program)
While you should be able to follow most of this program, it does introduce some new functions.
First of all, we are using #500 as a system constant (system constants are introduced in chapter
two). This value (the distance from the table top to the spindle nose at the machine’s reference
position) will be measured and entered but once. The control will retain the value of #500 from
day to day (it is a permanent common variable) and it will be available whenever this tool length
measuring utility program is used.
The set up person will first edit the first two commands of this program to specify the current
first tool number and last tool number for tools to be measured. They will then place the three
inch block on the table under the spindle nose and activate the program. After the loop is
initialized and the first execution of the IF statement is found to be false, the G28 command will
send the machine to its tool change position. The first tool to be measured will be placed in the
spindle and the program will halt due to the stop with message command.
Though it has not been introduced (yet) system variable #3006 is very similar to the #3000 alarm
generation system variable. However, instead of placing the machine in an true alarm state, it
simply places the machine in a program stop state, just like M00. But unlike M00, the display
screen will automatically change and the message TOUCH TOOL TIP TO BLOCK will be
placed on the screen. An M00 command would work just as well as #3006, but the setup person
must be monitoring the program page of the display screen in order to see any message.
At this point, the setup person places the machine in a manual mode (jog, manual, handwheel,
etc.) and manually brings the tool tip for the first tool down to touch the three inch block. When

23
 Parametric Programming Lesson Six: System Variables

the tool tip touches the block, they place the machine back in the automatic mode and reactivate
the cycle. The command
#[2000 + #102] = #500 - 3 - ABS[#5023]
correctly calculates the tool length value and places it into the tool offset corresponding to the
current tool station number. Remember that system variable #5023 is the distance in Z from the
machine’s zero return position to its current position. Since this value will be a negative number
(in our case), the absolute function is being used to reverse its sign. When this value plus an
additional three inches (for the block height) is subtracted from permanent common variable
#500, the result will render the tool’s length. This value is then placed into the current offset
specified as #[2000 + #102].
The program will then back the tool off slightly, step the counter to get to the next tool, and go
back to the test. This process will then be repeated for each tool to be measured.
With the exception of the stop with message command, the techniques used in this program can
be easily adapted to any version of parametric programming (use an M00 to replace the stop with
message command). However, both Okuma and Fadal have very helpful built-in functions that
adequately help the operator measure and enter tool lengths. For this reason, we do not show
this example in user task 2 of macro.
To help with the measurement of program zero on machining centers
Just as we can access machine position for purpose of measuring tool lengths, so can we do so
for the purpose of measuring the location of the program zero point. For machining center
applications, nothing beats a spindle probe for this function. However, if you do not have a
spindle probe equipped on your machine, believe it or not, these functions of parametric
programming even allow you to use a standard conductivity-type edge finder to handle just about
any application a true spindle probe is designed to handle. (By conductivity-type, we mean an
edge finder that incorporates a light that will illuminate the instant it comes into contact with any
metallic surface.) The only major limitation is that the actual task of touching the edge finder to
each surface must be performed manually. This ability opens the door for you to develop a
series of very helpful utility parametric program to facilitate the measurement of program zero
based upon your own specific program zero point specifications. Again, anything that can be
done with a true spindle probe can be done with an edge finder!
A corner pickup utility (custom macro B version)
This example will locate the lower left corner of a rectangular workpiece in X and Y. It will also
locate the top surface of the workpiece in Z. It will assume the use of an easy-to-use
conductivity-type edge finder. Since this program is to be used on a regular basis, we will utilize
two system constants. The radius of the edge finder (0.100) is stored in permanent common
variable #500 and the length of this edge finder is stored in #501. Once each surface location is
found, the distance from the machine’s reference point to the program zero surface will be stored
in fixture offset number one. Prior to running this program, the setup person will manually
position the edge finder about 0.5 in in each direction from the corner to be picked up (0.5 to the
left of the corner in X, 0.5 below the corner in Y, and 0.5 above the corner in Z).

O0015 (Program to pick up lower left corner)

G91 G01 Y0.75 Z-0.75 F30.0 (Move to first touch position)
#3006 = 101 (TOUCH LEFT SIDE IN X)

24
 Parametric Programming Lesson Six: System Variables

#5221 = #5021 + #500 (Set X of fixture offset number one)

G91 G01 X-0.2 (Move away in X)
Y-0.75 (Move down in Y)
X0.55 (Move to second touch position)
#3006 = 102 (TOUCH BOTTOM SURFACE IN Y)
#5222 = #5022 + #500 (Set Y of fixture offset number one)
G91 Y-0.2 (Move away in Y)
Z0.75 (Move above top surface in Z)
Y0.55 (Move to third touch position)
#3006 = 103 (TOUCH TOP SURFACE IN Z)
#5223 = #5023 - #501 (Set Z of fixture offset number one)
G91 G01 Z0.5 (Move away in Z)
G54 X0 Y0 (Instate coordinate system, move over corner)
M30 (End of program)
Using these techniques, you can develop any pickup routine that a true probing system is
designed to do (any other corner, center of hole, boss or pin, center of slot, etc.).
When assigning program zero in the program
If you are assigning program zero with offsets (fixture offsets on machining centers or geometry
offsets on turning centers), you can skip this section. However, if you are assigning program
zero in the program (with G92 on machining centers or G50/G92 on machining centers) as is
required on older Fanuc controls, you must read this section! Applying this technique can make
your machine much safer to utilize.
Earlier in this chapter we describe how to reference offset values in conjunction with program
zero assignment. However, this technique did not eliminate the single largest cause of machine
crashes with machines requiring program zero to be assigned in the program. As you well know,
if the machine is not in its planned starting position when the program is activated, the control
will “believe” the program zero setting command in the program, and program zero will not be
assigned correctly. It is very likely that this will result in a crash.
By having the ability to access the machine’s current position relative to the zero return position
from within your program, you can actually use the machine’s current position as of your
program zero assigning command. The control will take the distance from the zero return
position into consideration when program zero is assigned. In effect, the machine will never be
out of position again! Consider this portion of a turning center program.

O0013 (Program number)

N005 G50 X[#2021 + #5021] Z[#2121 + #5022] (Assign program zero for tool one)
N010 T0101 (Index to station one)
N015 G96 S500 M03 (Start spindle)
N020 G00 X4.2 Z0.005 (Rapid to approach position)
N025 G01 X-0.06 F0.012 (Rough face workpiece)
N030 G00 Z0.1 (Rapid away from workpiece)
N040 G00 X5.0 Z6.0 T0100 (Rapid to tool change position, cancel offset)
N045 M01 (Optional stop)
.

25
 Parametric Programming Lesson Six: System Variables

.
.
In line five, notice that offset number twenty one is being used in which to store the program
zero assigning values (referenced by system variables #2021 and #2121). Remember these offset
values are equal to the distance from program zero to the tip of each tool while the machine is
resting at its zero return position. To these values we add whatever distance the machine may be
from the zero return position. If the machine happens to be at the zero return position, the values
of #5021 and #5022 will be zero. If the machine is to the negative side of the zero return
position, the values of these system will be negative. If the machine is to the positive side of the
zero return position, the values of these system variables will be positive. So regardless of the
machine’s position, the program zero assigning command will be correct. Note that this
technique even allows one more benefit of geometry offsets. In line N040, notice that you no
longer have to send the machine back to a special tool change position. Instead, you can
minimize cycle time by moving the tool to any location at which the turret can safely index.

Access to alarm generation

Almost every version of parametric programming allows the programmer to perform tasks
related to error trapping. Error trapping is the process of finding conditions that require the
stoppage of a program’s execution. During our discussion of conditional branching in chapter
four, we introduced the alarm generation functions of each version of parametric programming
addressed by this text. Here we show another example in each version and review the syntax of
alarm generation.
A part counting parametric program
While most CNC controls have some form of part counter, few control-based part counters have
the ability to halt the program after a specified number of workpieces has been run.
In custom macro B format
This part counter will use a global flag (we will use permanent common variable #500) as the
actual counter. This will allow the part counting utility program to keep track of the current part
count even after the power has been turned off. Prior to using this part counter for the very first
time, the setup person will confirm that the value of permanent common variable #500 is zero
(this value can be displayed and entered through the display screen and control panel.
At the end of any program that uses the part counter utility, a simple call statement will specify
the number of workpieces to be run before the alarm is sounded (with letter address argument C,
which is represented by local variable #3). An optional letter address argument (M for multiple)
can be included in the call statement to specify how many workpieces are being machined per
cycle. If M (represented by local variable #13) is left out of the call statement, the custom macro
will assume that one workpiece is run per cycle. Here is a portion of a main program that uses
the part counter utility.
.
.
.
N350 G65 P9101 C1500. (Call part counter utility, specify that fifteen hundred
workpieces are to be run, one per cycle)
M30 (End of main program)

26
 Parametric Programming Lesson Six: System Variables

Part counting custom macro utility program:

O9101 (Program number)

IF [#13 NE #0] GOTO 1 (If M is specified skip to N1)
#13 = 1 (M not specified, set default value to one)
N1 #500 = #500 + #13 (Step part count by the number of parts per cycle)
IF[#500 LT #3] GOTO 99 (If not done yet, exit program)
#500 = 0 (Reset counter to 0 for next production run)
#3000 = 100 (PART COUNT ACHIEVED)
N99 M99 (End of custom macro)
Of course, any time the operator wants to check the current part count, they can simply display
permanent common variable #500. But with this utility program, the operator need not be
present to stop the cycle when the part count is reached. This is especially handy with machines
that can run several cycles without operator intervention (like bar feeding turning centers).
To review the alarm generation system variable, #3000, if it is executed, will cause the machine
to go into alarm state. The alarm will be very similar to any other program storage (PS) alarm.
The program’s execution will be halted and the operator must clear the alarm by pressing the
reset button before anything else can be done.
The alarm message page will be automatically displayed and the message in parentheses (which
must be in capitol letters and can be up to 26 characters) will be displayed. The alarm number,
which is chosen by the programmer and placed next to the equal sign must be in the range of
100-255 on most controls. This is simply a number the programmer can use to further document
the alarm, though the message in parentheses is usually sufficient for this purpose. For the alarm
generated in the part counter program, the message generated will appear like this. The MC in
the message stands for MaCro alarm (as opposed to servo alarm, program storage alarm,
overtravel alarm, etc.).
MC-100 PART COUNT ACHIEVED
In user task 2 format
This part counter will use a global flag (we will use common variable V32) as the actual counter.
Since global variables are non-volatile, this will allow the part counting utility program to keep
track of the current part count even after the power has been turned off. Prior to using this part
counter for the very first time, the setup person will confirm that the value of common variable
V32 is zero (this value can be displayed and entered through the display screen and control
panel.
At the end of any program that uses the part counter utility, a simple call statement will specify
the number of workpieces to be run before the alarm is sounded (with local variable argument
TTLC for ToTaL Count). An optional local variable argument (MULT for MULTiple) can be
included in the call statement to specify how many workpieces are being machined per cycle. If
MULT is left out of the call statement, the custom macro will assume that one workpiece is run
per cycle. Here is a portion of a main program that uses the part counter utility.
.
.
.

27
 Parametric Programming Lesson Six: System Variables

N350 CALL O9101 TTLC=1500. (Call part counter utility, specify that fifteen hundred
workpieces are to be run, one per cycle)
M02 (End of main program)
Part counting custom macro utility program:

O9101 (Program number)

IF MULT GOTO N1 (If argument MULT is specified skip to N1)
MULT = 1 (MULT is not specified, set default value to one)
N1 V32 = V32 + MULT (Step part count by the number of parts per cycle)
IF[V32 LT TTLC] GOTO N99 (If not done yet, exit program)
V32 = 0 (Reset counter to 0 for next production run)
VUACM[1] = `RUN COMPLETED’
VDOUT[991] = 100
N99 RTS (End of user task program)
Of course, any time the operator wants to check the current part count, they can simply display
common variable V32. But with this utility program, the operator need not be present to stop the
cycle when the part count is reached. This is especially handy with machines that can run
several cycles without operator intervention (like bar feeding turning centers).
To review the alarm generation system variables, VUACM, which stands for User Alarm
CoMment, places the message in single quotation marks (`’) on the display screen. The number
in brackets (normally one) specifies the character number with which to begin the message. The
message can be up to sixteen characters long. System variable VDOUT with a value in brackets
of 991 causes the machine to go into alarm state. The alarm will be very similar to any other
program storage alarm. The program’s execution will be halted and the operator must clear the
alarm by pressing the reset button before anything else can be done.
The alarm message page will be automatically displayed and the message in single quotes (which
must be in capitol letters) will be displayed. The alarm number is chosen by the programmer and
placed to the right to the equal sign of the VDOUT command. This is simply a number the
programmer can use to further document the alarm, though the message in single quotes is
usually sufficient for this purpose. For the alarm generated in the part counter program, the
message generated will appear like this.
3202 Alarm C User reserve code 100 RUN COMPLETED
In Fadal’s macro format
This part counter will use a global flag (we will use common variable V99) as the actual counter.
Since V series variables are non-volatile, this will allow the part counting utility program to keep
track of the current part count even after the power has been turned off. Prior to using this part
counter for the very first time, the setup person will confirm that the value of V series variable
V99 is zero (this value can be displayed and entered through the display screen and control
panel.
At the end of any program that uses the part counter utility, simple calling commands will
specify the number of workpieces to be run before the alarm is sounded (with V series variable
argument V1). Another V series variable (V2) will specify how many workpieces are being
machined per cycle.

28
 Parametric Programming Lesson Six: System Variables

.
.
.
N350 #V1=1500. ‘Set number of parts to run to 1500
N355 #V2=1.0 ‘Set number parts per cycle
N360 M98 P9101 (Call part counter utility)
N365 M02 (End of main program)
Part counting macro utility program:

O9101 (Program number)

#V99 = V99 + V2 ‘Step part count by the number of parts per cycle
#IF V99 > V1 THEN GOTO :EXIT ‘If not done yet, exit program
#V99 = 0 ‘Reset counter to 0 for next production run
#:REPEAT ‘Statement label for message repeat
#PRINT “PART COUNT ACHIEVED” ‘Print alarm message
#INPUT V20 ‘Halt program activation
#GOTO :REPEAT ‘Repeat alarm is the cycle is reactivated
#:EXIT ‘Statement label for end of program
M99 (End of custom macro)
Of course, any time the operator wants to check the current part count, they can simply display
common variable V99. But with this utility program, the operator need not be present to stop the
cycle when the part count is reached. This is especially handy with machines that can run
several cycles without operator intervention (like bar feeding turning centers).
To review alarm generation, the PRINT command is used to print a message (of any kind) on the
display screen. The message must be enclosed in quotation marks (“”). The PRINT command
by itself does not actually stop the program. For this reason, we use an INPUT command that is
normally used to request information from the operator. The V series variable in the INPUT
command can be any unused V series variable.
Since the operator can still reactivate the program by simply pressing cycle start, logic is
included after the INPUT command that keeps the program from going any further. The GOTO
statement sends the control back to the print command, placing the machine in an endless loop.
The operator could press cycle start any number of times, but the program will not continue.

Minimizing the time required for error trapping

During our discussion of conditional branching in chapter four, we offered an example of error
trapping that used several IF statements to set default values, test for missing mandatory
arguments, and test for conflicting arguments in the call statement. Here we show the program
again (in custom macro B format) as part of our discussion of the impact of error trapping on
cycle time.

O1006 (Program number)

(PRESET Z AND T)
IF[#26 NE #0] GOTO 5 (Test if Z is vacant)
#26 = 0.75 (Preset Z to 0.75)
N5 IF[#20 NE #0] GOTO 6 (Test if T is vacant)

29
 Parametric Programming Lesson Six: System Variables

#20 = 1.0 (Preset T to 1.0)

(TEST MANDATORY VARIABLES & GENERATE ALARM IF MISSING)
N6 IF[#24 EQ #0] GOTO 98 (If X is missing, generate alarm)
IF[#25 EQ #0] GOTO 98 (If Y is missing, generate alarm)
IF[#17 EQ #0] GOTO 98 (If Q is missing, generate alarm)
IF[#13 EQ #0] GOTO 98 (If M is missing, generate alarm)
IF[#1 EQ #0] GOTO 98 (If A is missing, generate alarm)
IF[#9 EQ #0] GOTO 98 (If F is missing, generate alarm)
IF[#2 EQ #0] GOTO 98 (If B is missing, generate alarm)
#20 = #20 / 2 (Set #20 to radius of tool instead of diameter)
#13 = #13 / 2 (Set #13 to radius of major diameter)
IF[#2 EQ 1.0] GOTO 20 (Test if blind hole)
(CALCULATIONS FOR TOP TO BOTTOM)
#101 = #24 - #1 + #20 (X position of tool center at approach position)
#102 = #24 + #1 - #20 (X position of tool center at retract position)
#103 = #25 + #13 - #20 (Y position of tool center at points 3 & 5)
#104 = #25 + #13 - #1 (Y position of tool center at points 2 & 6)
#105 = -[#26 + #17/4] (Z position of point 3)
#106 = #105 - #17/2 (Z position of point 4)
#107 = #106 - #17/2 (Z position of point 5)
#108 = #107 - #17/4 (Z position of point 6)
#109 = #1 - #20 (Radius of approach tool path)
#110 = #13 - #20 (Radius of tool path for milling thread)
#111 = #25 - #13 + #20 (Y position of tool center at point 4)
#112 = 2 (Set G code number for circular motion [G02])
GOTO 60
(CALCULATIONS FOR BOTTOM TO TOP
N20 #101 = #24 + #1 - #20 (X position of tool center at approach position)
#102 = #24 - #1 + #20 (X position of tool center at retract position)
#103 = #25 + #13 - #20 (Y position of tool center at points 3 & 5)
#104 = #25 + #13 - #1 (Y position of tool center at points 2 & 6)
#105 = -[#26 - #17/4] (Z position of point 3)
#106 = #105 + #17/2 (Z position of point 4)
#107 = #106 + #17/2 (Z position of point 5)
#108 = #107 + #17/4 (Z position of point 2)
#109 = #1 - #20 (Radius of approach tool path)
#110 = #13 - #20 (Radius of tool path for milling thread)
#111 = #25 - #13 + #20 (Y position of tool center at point 4)
#112 = 3 (Set G code number for circular motion [G03])
(MOTIONS)
N60 G00 X#101 Y#104 (Move in XY to approach point)
Z-#26 (Rapid to start of thread milling in Z)
G#112 X#24 Y#103 Z#105 R#109 F#9 (Approach to point 3)
Y#111 Z#106 R#110 (Mill half way around circle to point 4)
Y#103 Z#107 R#110 (Mill the rest of the way to point 5)
X#102 Y#104 Z#108 R#109 (Retract from thread)

30
 Parametric Programming Lesson Six: System Variables

G00 X#24 Y#25 (Move to hole center)

Z0.1 (Rapid out of hole)
GOTO 99
(ALARM IF DATA IS MISSING)
N98 #3000 = 100 (DATA MISSING IN CALL)
N99 M99 (end of custom macro)
The bulk of this program does nothing but test and calculate. There are actually only eight
motion commands in the entire program. While the computers within CNC controls are getting
faster and faster, even today’s thirty-two bit controls will require some execution time to perform
the calculations and tests. You will likely notice a short pause after activating the this program
before the machine actually starts moving.
If the lot size is relatively small, the extra processing time required to perform these non-motion
commands will have but a small impact on the length of time it takes to complete the production
run. However, as quantities grow, you will want to do something about this wasted cycle time.
While our example is related to a user-created canned cycle application, and the techniques we
show will work just fine, the impact of error trapping on cycle time is usually more critical in
family-of-parts applications. Just remember that all techniques shown in this example can be
applied to part family applications with equal ease and success.
Using optional block skip
One (rather crude) way to solve the added cycle time problem is to use the optional block skip
function (slash code) in all calculation and testing commands. Assuming this is the only
parametric program being used and the common variables needed by this program are not
overwritten in some other program, optional block skip will allow the control to skip redundant
commands after the first workpiece is run. Consider this program.

O1006 (Program number)

IF[#101 NE #0] GOTO 1 (Test to ensure #101 has been set)
#3000 = 110 (TURN BLOCK SKIP OFF)
N1 (PRESET Z AND T)
/IF[#26 NE #0] GOTO 5 (Test if Z is vacant)
/#26 = 0.75 (Preset Z to 0.75)
/N5 IF[#20 NE #0] GOTO 6 (Test if T is vacant)
/#20 = 1.0 (Preset T to 1.0)
(TEST MANDATORY VARIABLES & GENERATE ALARM IF MISSING)
/N6 IF[#24 EQ #0] GOTO 98 (If X is missing, generate alarm)
/IF[#25 EQ #0] GOTO 98 (If Y is missing, generate alarm)
/IF[#17 EQ #0] GOTO 98 (If Q is missing, generate alarm)
/IF[#13 EQ #0] GOTO 98 (If M is missing, generate alarm)
/IF[#1 EQ #0] GOTO 98 (If A is missing, generate alarm)
/IF[#9 EQ #0] GOTO 98 (If F is missing, generate alarm)
/IF[#2 EQ #0] GOTO 98 (If B is missing, generate alarm)
/#20 = #20 / 2 (Set #20 to radius of tool instead of diameter)
/#13 = #13 / 2 (Set #13 to radius of major diameter)
/IF[#2 EQ 1.0] GOTO 20 (Test if blind hole)
(CALCULATIONS FOR TOP TO BOTTOM)

31
 Parametric Programming Lesson Six: System Variables

/#101 = #24 - #1 + #20 (X position of tool center at approach position)

/#102 = #24 + #1 - #20 (X position of tool center at retract position)
/#103 = #25 + #13 - #20 (Y position of tool center at points 3 & 5)
/#104 = #25 + #13 - #1 (Y position of tool center at points 2 & 6)
/#105 = -[#26 + #17/4] (Z position of point 3)
/#106 = #105 - #17/2 (Z position of point 4)
/#107 = #106 - #17/2 (Z position of point 5)
/#108 = #107 - #17/4 (Z position of point 6)
/#109 = #1 - #20 (Radius of approach tool path)
/#110 = #13 - #20 (Radius of tool path for milling thread)
/#111 = #25 - #13 + #20 (Y position of tool center at point 4)
/#112 = 2 (Set G code number for circular motion [G02])
/GOTO 60
(CALCULATIONS FOR BOTTOM TO TOP
/N20 #101 = #24 + #1 - #20 (X position of tool center at approach position)
/#102 = #24 - #1 + #20 (X position of tool center at retract position)
/#103 = #25 + #13 - #20 (Y position of tool center at points 3 & 5)
/#104 = #25 + #13 - #1 (Y position of tool center at points 2 & 6)
/#105 = -[#26 - #17/4] (Z position of point 3)
/#106 = #105 + #17/2 (Z position of point 4)
/#107 = #106 + #17/2 (Z position of point 5)
/#108 = #107 + #17/4 (Z position of point 2)
/#109 = #1 - #20 (Radius of approach tool path)
/#110 = #13 - #20 (Radius of tool path for milling thread)
/#111 = #25 - #13 + #20 (Y position of tool center at point 4)
/#112 = 3 (Set G code number for circular motion [G03])
(MOTIONS)
N60 G00 X#101 Y#104 (Move in XY to approach point)
Z-#26 (Rapid to start of thread milling in Z)
G#112 X#24 Y#103 Z#105 R#109 F#9 (Approach to point 3)
Y#111 Z#106 R#110 (Mill half way around circle to point 4)
Y#103 Z#107 R#110 (Mill the rest of the way to point 5)
X#102 Y#104 Z#108 R#109 (Retract from thread)
G00 X#24 Y#25 (Move to hole center)
Z0.1 (Rapid out of hole)
/GOTO 99
(ALARM IF DATA IS MISSING)
/N98 #3000 = 100 (DATA MISSING IN CALL)
N99 M99 (end of custom macro)
At the very beginning of this program, notice the test to ensure that #101 has been set. If the
operator forgets to turn the optional block skip switch off for the first workpiece after turning on
the power, the machine will go into alarm state. Once the first workpice is run, the optional
block skip switch can be turned on. From this point, the control will ignore the calculations and
tests, minimizing cycle time.

32
 Parametric Programming Lesson Six: System Variables

A check sum test

Though using optional block skip for this purpose is effective, using it eliminates the possibility
of using optional block skip for any other purpose since most machines have only one optional
block skip function. Another way to minimize wasted calculation and testing time is to use a
check sum test. Here’s how it works.
Two global flags will be used. Since our example is in custom macro B, we’ll use permanent
common variables #500 and #501. In permanent common variable #500, we’ll store the total of
all values that might be changed that will affect the accuracy of the testing and calculations
previously done. Note that in our case, only the letter address arguments are involved with
testing and calculations. So only their corresponding local variables will be involved with the
check sum test. However, it is possible that other control functions, like tool offsets, are
involved with your testing and calculations. For the check sum test to be effective, everything
that will effect the correctness of the previous tests and calculations must be included in the
check sum test. Here is the program for the same thread milling application, modified to use the
check sum test technique.

O1006 (Program number)

(PRESET Z AND T)
IF[#26 NE #0] GOTO 5 (Test if Z is vacant)
#26 = 0.75 (Preset Z to 0.75)
N5 IF[#20 NE #0] GOTO 6 (Test if T is vacant)
#20 = 1.0 (Preset T to 1.0)
(CHECK SUM TEST)
#500 = #26 + #20 + #24 + #25 + #17 + #13 + #1 + #9 + #2
IF[#500 EQ #501] GOTO 60 (If check sum test passes, go to motion commands)
#501 = #500 (Set #501 equal to #500 so if nothing changes, check sum test will pass
next time)
(TEST MANDATORY VARIABLES & GENERATE ALARM IF MISSING)
N6 IF[#24 EQ #0] GOTO 98 (If X is missing, generate alarm)
IF[#25 EQ #0] GOTO 98 (If Y is missing, generate alarm)
IF[#17 EQ #0] GOTO 98 (If Q is missing, generate alarm)
IF[#13 EQ #0] GOTO 98 (If M is missing, generate alarm)
IF[#1 EQ #0] GOTO 98 (If A is missing, generate alarm)
IF[#9 EQ #0] GOTO 98 (If F is missing, generate alarm)
IF[#2 EQ #0] GOTO 98 (If B is missing, generate alarm)
#20 = #20 / 2 (Set #20 to radius of tool instead of diameter)
#13 = #13 / 2 (Set #13 to radius of major diameter)
IF[#2 EQ 1.0] GOTO 20 (Test if blind hole)
(CALCULATIONS FOR TOP TO BOTTOM)
#101 = #24 - #1 + #20 (X position of tool center at approach position)
#102 = #24 + #1 - #20 (X position of tool center at retract position)
#103 = #25 + #13 - #20 (Y position of tool center at points 3 & 5)
#104 = #25 + #13 - #1 (Y position of tool center at points 2 & 6)
#105 = -[#26 + #17/4] (Z position of point 3)
#106 = #105 - #17/2 (Z position of point 4)
#107 = #106 - #17/2 (Z position of point 5)

33
 Parametric Programming Lesson Six: System Variables

#108 = #107 - #17/4 (Z position of point 6)

#109 = #1 - #20 (Radius of approach tool path)
#110 = #13 - #20 (Radius of tool path for milling thread)
#111 = #25 - #13 + #20 (Y position of tool center at point 4)
#112 = 2 (Set G code number for circular motion [G02])
GOTO 60
(CALCULATIONS FOR BOTTOM TO TOP
N20 #101 = #24 + #1 - #20 (X position of tool center at approach position)
#102 = #24 - #1 + #20 (X position of tool center at retract position)
#103 = #25 + #13 - #20 (Y position of tool center at points 3 & 5)
#104 = #25 + #13 - #1 (Y position of tool center at points 2 & 6)
#105 = -[#26 - #17/4] (Z position of point 3)
#106 = #105 + #17/2 (Z position of point 4)
#107 = #106 + #17/2 (Z position of point 5)
#108 = #107 + #17/4 (Z position of point 2)
#109 = #1 - #20 (Radius of approach tool path)
#110 = #13 - #20 (Radius of tool path for milling thread)
#111 = #25 - #13 + #20 (Y position of tool center at point 4)
#112 = 3 (Set G code number for circular motion [G03])
(MOTIONS)
N60 G00 X#101 Y#104 (Move in XY to approach point)
Z-#26 (Rapid to start of thread milling in Z)
G#112 X#24 Y#103 Z#105 R#109 F#9 (Approach to point 3)
Y#111 Z#106 R#110 (Mill half way around circle to point 4)
Y#103 Z#107 R#110 (Mill the rest of the way to point 5)
X#102 Y#104 Z#108 R#109 (Retract from thread)
G00 X#24 Y#25 (Move to hole center)
Z0.1 (Rapid out of hole)
GOTO 99
(ALARM IF DATA IS MISSING)
N98 #3000 = 100 (DATA MISSING IN CALL)
N99 M99 (end of custom macro)
Close to the beginning of this program (just after the default settings), notice the command that
sets permanent common variable #500 to the total of all local variables representing letter
address arguments in the call statement. Then comes the check sum test. For the very first
workpiece in the production run, this test will be evaluated as false, since there is no way the
total of all local variables involved with this application will equal the most recent setting of
#501. Because this test will render a false result, all of the testing and calculation commands
will be performed. Right after the check sum test, notice that #501 is being set equal to #500.
As long as none of the letter address arguments are changed, the next time the check sum test is
executed, it will render a true result. In this case, the control will skip all tests and calculations,
and proceed directly to the motion commands, saving program execution time. Only if any of
the letter address arguments is changed by the operator will the tests and calculations be
performed again.

34
 Parametric Programming Lesson Six: System Variables

Again, this example involves only the letter address arguments. But keep in mind that any value
that, if changed, would affect the correctness of calculations and tests can be included in the
check sum test.

Other system variables of interest

As stated at the beginning of this chapter, versions of parametric programming vary with regard
to how many CNC related features are available. From this point on, we isolate those system
variables that are available in but one of the versions addressed by this text (custom macro B).
Be sure to check in your own control manufacturer’s programming manual to determine if you
have other system variable functions not addressed by this text.
#1000 series - Access to terminal locations
Custom macro B allows you to access certain terminal locations on a printed circuit board right
from within a program. For the purposes of outputting signals to some outside device, you can
set any one of thirty-two terminal locations high (on) or low (off). When setting it high, you are
sending a twenty-four volt signal to the terminal location, which is usually done to activate some
outside device. When setting it low, you are removing the twenty-four volt signal.
Another set of (32) terminals is used as input signals. These are commonly used to attain
confirmation that the outside device has completed its function. If an input terminal is high, the
outside device has sent the signal back telling the control it has completed its function. If the
input terminal is low, there is no twenty-four volt signal currently at the location, meaning the
device is still in the process of completing its function.
System variables #1000 through #1031 are used to monitor the input terminals. System variables
#1100 through #1131 are used to send the twenty-four volt signal to the output terminals. Input
terminal locations are marked on the schematic diagram as UI000 through UI031. Output
terminal locations are marked as UO000 through UO031.
Consider this example program that could be used to activate any M code-type device, like an
indexer, hydraulic clamping, or automatic door.

O9001 (Program number)

#1100 = 1 (Activate outside device)
N1 IF[#1000 EQ 1] GOTO 99 (Test if device is finished)
GOTO 1 (Go back and test again)
N99 M99 (End of custom macro)
The first command send the twenty-four volt signal to output terminal location UO000. This
activates the indexer, hydraulic clamping, automatic door, or any other device. The IF statement
tests to see if a confirmation signal has yet been received from the outside device. That is, has
input terminal location UI000 received a twenty-four volt signal yet? If it has not, which is
likely for the first few times the IF statement is executed, the control proceeds to the GOTO
statement and the test is repeated. In essence, the control is stuck in a loop until the confirmation
signal is read. When it is, the control exits the custom macro.
Note that custom macro even allows the programmer to activate this program by specifying a
user defined M code, making it appear as if a true M code is being used to activate the outside
device. More on user defined M codes later in this chapter.

35
 Parametric Programming Lesson Six: System Variables

Access to timers
System variables #3001 and #3002 allow you to access the control’s internal clock/timer. #3001
is a timer that is incremented in milliseconds while #3002 is incremented in hours. For newer
Fanuc controls, you will also have access to the current time and date, giving you even more
control of what you can do with timer related functions.
These timers within the control are always running. However, you can reset the milliseconds
timer and hour timer by setting them to a value of zero. For example, the command #3001 = 0
resets the milliseconds timer. #3002 = 0 resets the hour timer.
1,000 milliseconds, of course, is equal to one second. Here is a simple example showing how to
use the milliseconds timer to make the control to pause for two seconds (just as the G04 dwell
command would).

#3001 = 0 (Reset milliseconds timer)

N1 IF [#3000 GT 2000] GOTO 99 (If finished exit loop)
GOTO 1 (Go back to test)
N99 . . .
.
.
.
These timers will be helpful whenever you need your custom macro to keep track of time. One
time this is necessary is when trying to monitor cycle time for a given tool, as would be needed
with any kind of tool life monitoring. With this technique, you can come up with a limited tool
life management system. But keep in mind that most controls offer excellent tool life
management systems that can outperform much of what you can do with parametric
programming techniques aimed a tool life management. If you need tool life management on a
regular basis, please look into the specific optional feature for tool life management.
Timing events
You can actually time the period that a given cutting tool is machining. Once its total time is
exhausted, you can have the control change to a fresh tool and/or generate an alarm telling the
operator to perform tool maintenance.
Older Fanuc controls with custom macro B, for example, have two timers, one for milliseconds
and one for hours. Newer Fanuc controls have a clock that offers time in a similar format to the
time/date function of personal computers.
#3001 is the milliseconds timer and #3002 is the hours timer. Both are constantly running, but
can be reset to zero at any time. Consider these commands that accumulate the time tool number
one is cutting in permanent common variable #500.

O0001 (Program number)

N005 T0101 (Index to tool number 1)
N010 G96 S500 M03 (Start spindle)
N015 G00 X3.0 Z0.1 (Rapid into position)
N020 #3001 = 0 (Reset milliseconds timer)
N025 G71 P030 Q050 U0.040 W0.005 D0.125 F0.012 (Rough turn)

36
 Parametric Programming Lesson Six: System Variables

N030 G00 X1.0 (Beginning of finish pass definition)

N035 G01 Z-1.0 (Turn first diameter)
N040 X2.0 (Feed up first face)
N045 Z-2.0 (Turn second diameter)
N050 X3.0 (Feed up second face)
N055 #500 = #500 + #3001 (Accumulate time in #500)
N060 G00 X4.5 Z4.0 (Rapid to tool change position)
.
.
.
N305 IF [#500 LT 40000] GOTO 320 (If time is less than 40 minutes, go to end of
program)
N310 #500 = 0 (Reset accumulated time)
N315 #3000 = 100 (TOOL ONE DULL)
N320 M30
Notice that line N020, the milliseconds timer is reset to zero. From the instant this command is
executed, #3001 will accumulate time. After the tool is finished, #500 is stepped by the amount
of time that has passed in line N055. At the end of the program, the test in line N305 determines
if the tool has been used for more than forty minutes (40000 milliseconds is forty minutes).
When it has, #500 is set back to zero (for the next insert) and the alarm in line N315 is given,
telling the operator to change inserts.
Suppressing single block and M code await
System variable #3003 allows you to take control of two important control functions, single
block and whether M codes are awaited. If #3003 is set to 0 (the initialized state), single block is
not suppressed and the control will wait for auxiliary functions (M codes) to be completed before
going on to the next command. If #3003 is set to 1, single block will be suppressed and the
control will wait for the completion of M codes to continue with the program. If #3003 is set to
2, single block is not suppressed, and the control will not wait for the completion of auxiliary
functions. If set to 4, single block is suppressed and M codes will be awaited.
An application for suppressing single block. There may be times when if single block is on,
detrimental things could happen. For example, when tapping a hole, the machine must flow
through the entire tapping operation. For machining centers and many turning centers, this is
simply part of the G84 tapping canned cycle function. Even if single block is on, the control will
treat the entire tapping operation as one block.
However, many Fanuc controlled turning center controls do not have a tapping cycle. They
force the programmer to write the tapping commands long-hand. When tapping longhand, there
is no way of inhibiting single block with normal G code level programming. But with custom
macro, it is possible to suppress single block. Here is an example that shows how. Letter
address Z is represented in the custom macro by local variable #26, R by #18, and F by #9.
Main program:

O0003 (Program number)

N005 G00 T0101 M41 (Select tool, offset, and spindle range)
N010 G97 S500 M03 (Start spindle CW at 500 RPM)

37
 Parametric Programming Lesson Six: System Variables

N015 G65 P1003 Z-1.0 R.25 F.0625 (Tap hole)

N020 G00 X5. Z4. T0100 (Move to tool change position, cancel offset)
N025 M30 (End of program)
Custom macro:

O1003 (Program number)

G00 X0 Z#18 (Rapid to approach position)
#3003 = 1 (Suppress single block)
G32 Z#26 F#9 (Feed into hole)
M04 (Reverse spindle)
G32 Z#18 (Feed back out of hole)
#3003 = 0 (Reactivate single block)
M99 (End of Custom Macro)
Prior to entering the hole, the command #3003 = 1 makes the control ignore the single block
function (even if it is on). After coming out of the hole the command #3003 = 0 reactivates the
single block function.
An application for not waiting for M codes. The machine tool builder determines, for many M
codes, whether the confirmation signal will be waited before the control can go on to the next
command. In most cases, you will agree with the machine tool builder’s decision as to whether a
given M code should be awaited or not. However, there may be times when, especially for time
savings reasons, you may not agree and wish to take control of whether the control waits for a
given M code to be completed.
For example, some machining centers require that a door to the automatic tool changer be
completely closed at the completion of each tool change. This is quite common for machines
with totally enclosed guarding. In some cases, an M code is used to close the door. In this
example, the control should not have to wait for the door to completely close before going on to
the next command. The control should be allowed to simply continue with the program, since
the door can be closing without fear of any dangerous situation arising.
Whether the control waits for the completion of the door closing M code can be controlled by
system variable #3003. If your particular machine does wait (wasting time), simply set #3003 =
2 prior to activating the M code in question. Of course, you must set #3003 = 0 when finished
with the M code in order to get the control back to its normal state for other M codes that do
require the control to wait.

Controlling feed hold, feedrate override, and exact stop check

In similar manner, system variable #3004 gives you control of three more important CNC
functions. Here is a chart that shows the meaning of each value of #3004.
Value Feed Hold Feedrate Override Exact Stop Check
0 Effective Effective Effective
1 Suppressed Effective Effective
2 Effective Suppressed Effective

38
 Parametric Programming Lesson Six: System Variables

3 Suppressed Suppressed Effective

4 Effective Effective Suppressed
5 Suppressed Effective Suppressed
6 Effective Suppressed Suppressed
7 Suppressed Suppressed Suppressed

For all intents and purposes, exact stop check can be controlled by other means (G09 and G61)
so you typically do not have to use system variable #3004 for this purpose. But as with
suppressing single block, #3004 can be very helpful when you need to control feed hold and
feedrate override. If you have applications that require that feed hold and feedrate override be
suppressed (like tapping with G01), you can give the command #3004 = 3 just prior to the
commands in question.
After giving the motion commands, don’t forget to set #3004 = 0 to reinstated control of feed
hold and feedrate override.
Stop with message
Earlier in this chapter we discussed the #3000 alarm generating system variable. As you know,
this system variable, if read, will put the control into alarm state and display a message on the
screen. In order to continue with the program, the operator must reset the alarm.
There are times when you wish to stop the machine and give the operator a message, but you
want the operator to be able to continue with the program by simply pressing cycle start. Most
programmers use the simple M00 program stop for this purpose. If, for example, you wish to
stop the machine so the operator can clear chips and add tapping compound, you could give this
command.
N050 M00 (BLOW CHIPS AWAY AND ADD TAPPING COMPOUND)
However, if the operator is not monitoring the program mode while running the program, the
message in parentheses will not be seen. The operator will have to switch display screen modes
in order to see the message. The programmer can force the message to appear with system
variable #3006. However, with system variable #3006, the operator will be able to continue with
the cycle by simply pressing the cycle start button. Here is an example of the syntax for the stop
with message system variable. Note how similar it is to the alarm generation system variable
(#3000).
Access to modal information
The #4000 series system variables give you access to currently instated modal information. Here
are the various system variables in this series as well as their meanings.
#4001 through #4021 specify the currently active G code within each G code group. The various
G code groups are listed in the beginning of your programming manual. For example, for
machining centers, G00, G01, G02, and G03 are in G code group number one. To attain the
currently instated G code in this group, you could give this command.
#101 = #4001

39
 Parametric Programming Lesson Six: System Variables

Group number two is plane selection (G17, G18, and G19). Group number three is Absolute and
Incremental modes (G90 and G91). Again, to see the complete list of G code groups, look in
your programming manual.
Here are other system variables in the #4000 series that allow access to modal information:
#4102 - Currently instated B word
#4107 - Currently instated D word
#4108 - Currently instated E word
#4109 - Currently instated F word
#4111 - Currently instated H word
#4113 - Currently instated M word
#4114 - Currently instated N word
#4115 - Currently instated O word
#4119 - Currently instated S word
#4120 - Currently instated T word
An application
For the most part, these system variables are not commonly required by the typical parametric
programmer. However, there is one time when their use may be helpful. Say you wish to use
the incremental mode for motions within a custom macro, yet you are unsure of the machine’s
current state relative to incremental and absolute mode when the custom macro is activated. At
the end of your custom macro, you wish to leave the machine in the state you found it. Consider
these commands.

O1054 (Program number)

#101 = #4003 (Determine the current setting of G90 or G91)
G91 (Set incremental mode)
(Motions under the influence of incremental mode)
.
.
.
#4003 = #101 (Reset mode to original state)
M99 (End of Custom Macro)
Notice that in the command #101 = #4003, we are storing the current value of G code group
number three (which happens to be the group related to G90 or G91) in common variable #101.
Then the G91 mode is selected to perform the machining operation. Near the end of the custom
macro, we have the command #4003 = #101. This command is reselecting the mode (stored
earlier) by reassigning system variable #4003.

40