Lesson Five Text

Parametric Programming Lesson Five: Generating Loops
1
Generating loops
To help you understand looping, first consider subprogramming commands. Most CNC controls
allow you to repeat subprograms a specified number of times. With Fanuc format, for example,
an L word specifies the number of times the subprogram must be executed. The command
N050 M98 P1000 L5
tells the control to execute program O1000 five times.
Keep in mind that repeating subprograms is rather limited. While you may be able to play some
tricks with incremental techniques, if anything changes from one execution of the subprogram to
the next, you cannot use subprogramming techniques to handle the application. With looping,
there are no such limitations.
Like subprograms, loops allow you to repeat a series of commands a specified number of times.
However, with looping, virtually anything can change each time through the loop. Before we
show helpful applications for looping, you must understand the basic steps to develop a loop.
There are many, many ways to develop loops. And it is hard to argue with any technique that
works. However, we recommend using a highly structured and consistent method of loop
creation. With our recommended method, all loops will have a counter. This counter is a
variable, and will be an integer (whole) number (1, 2, 3, etc.). Another variable (or constant
number) will represent the number of times the loop must be executed. This variable or constant
will also be an integer number. After each execution of the loop, the counter will be stepped.
The conditional branching statement will be used to test the counter and determine when the loop
has been executed the required number of times. Here is how you develop a loop in step-by-step
manner.

1) Initialize counter and anything that changes each time through the loop.
2) Test to see if the loop is completed.
3) Perform calculations (if necessary).
4) Generate motions (if necessary).
5) Step counter and everything that changes each time through the loop.
6) Go back to the test.
We recommend testing early on to determine if the loop is finished (though some programmers
elect to test at the end of the loop). Testing early might help you avoid machine motion
problems caused by bad looping criteria. If you test first, at least you have a chance that the test
will render a condition that will not allow machining to occur.
While it can be complicated enough to develop the logic for the loop itself, there are almost
always other functions that must be addressed in a loop. For now, lets concentrate on the loop
structure itself. Here is a example loop that simply counts to ten. We show this loop written in
the three parametric programming versions addressed by this text. In all cases, notice that the
counter variable is an integer number, as is the constant number of times the loop is to be
executed (10).

2
In custom macro B:

O1001 (Program number)
#100 =1 (Initialize loop counter)
(Initialize anything else that changes)
N1 IF[#100 GT 10.0]GOTO 99 (Test if finished)
(Calculate, if necessary)
(Perform motions for this time through the loop, if necessary)
.
.
.
#100 =#100 +1 (Step counter by one)
(Step anything else that changes)
GOTO 1 (Go back to test)
N99 M99 (End of custom macro)
In user task 2:

CTR1 =1 (Initialize loop counter)
N1 IF[CTR1 GT 10.0] GOTO N99 (Test if finished)
.
.
.
CTR1 =CTR1 +1 (Step counter by one)
GOTO N1 (Go back to test)
N99 RTS (End of user task program)
In Fadals macro:

#V1 =1 Initialize loop counter
#:LOOPBEGIN Statement label for loop beginning
#IF V1>10.0 THEN GOTO :LOOPEND Test if finished
.
.
.
#V1 =V1 +1 Step counter by one
#GOTO :LOOPBEGIN Go back to test
#:LOOPEND End of loop
3
M99 (End of macro)
In all cases, the counter is initialized to one. The first time the conditional branching command
is executed, the counter (1) is not greater than ten and the conditional expression is evaluated as
false. The loop is executed the first time. At the completion of this execution, the counter is
stepped by one. Its new value will be two. When the test is executed the second time, it will still
be false (two is not greater than ten). The loop is executed a second time. This continues until
the loop has been executed ten times. After the tenth execution, the counters value will be
eleven. When the test is made, its conditional expression will be true and the loop will be
exited.
Solving problems related to loops
If you have had experience with computer programming languages, you know that there is quite
a bit more to creating loops than just setting and stepping a counter and testing to see when the
loop is finished. Unfortunately, no two loops will be written in precisely the same manner,
meaning you must treat every loop application as special. But if you understand and follow the
guidelines we show, you should be able to develop even complex looping applications with
structured and consistent methods. We recommend that you have firm answers to these
questions before you begin writing a given loop.
When is a loop required?
There are two distinct times when loops are used. With one, looping is a convenience. It simply
minimizes redundant commands. With the other, looping is mandatory. there will be no other
feasible way to handle the application.
To minimize commands
First, loops can be used (though they may not be mandatory) to dramatically shorten the number
of redundant commands in a program. A few commands executed over and over again can
sometimes save hundreds or thousands of commands. Earlier in this chapter, for example, we
discussed how you can test arguments to see if they have been assigned.
In our discussion of Fadals macro argument testing (V1 through V8), we had to program many
commands just to test eight variables. Imagine having to test 50 variables! A loop can minimize
the number of commands you would need. To keep this example simple, say all variables to be
tested must be in the range of from minus ten to plus ten (-10.0 through +10.0). If any are not,
you wish to generate the alarm message and halt the program. Consider these commands in
Fadals macro format:

N1 #V60 =1 Counter
N2 #:LOOPBEGIN Begin loop for argument testing
N3 #IF V60>50 THEN GOTO :EXIT Test if finished with loop
N4 #:REPEAT Beginning of repeated alarm
N5 #IF (V(V60)>-10.0) AND (V(V60)<10.0) THEN GOTO :NEXT Test current argument
N6 #PRINT ARGUMENT V, V60, IS OUT OF RANGE Print alarm message
N7 #INPUT V99 Halt program
N8 #GOTO :REPEAT Be sure program does not continue
N9 #:NEXT
N10 #V60 =V60 +1
4
N11 #GOTO :LOOPBEGIN
N12 #:EXIT
N13 . . .
.
.
.
This series of commands actually tests fifty variables, from V1 through V50. If any are not in
the desired range, a specific alarm message is printed and the program will halt.
In line N1, notice that V series variable V60 is being used as the counter. In this application, it
just so happens that the counter value (1, 2, 3, through 50) happen to correspond to the variable
numbers being tested. So in line N5, V60 is referenced to specify the variable number being
tested. The first time N5 is executed V1 will be the variable tested. The next time, V2 will be
tested. This will be repeated until the loop is satisfied (after fifty loop executions). If any one of
the variables is found to be out of range, a specific alarm message (from line N60) will be
generated. Notice V60 is also being referenced in line N6 to specify which V series variable is
not correctly set.
While this application for looping may or may not be impressive to you, the main point of this
discussion is that looping can dramatically reduce the need for redundant commands. While the
commands needed to test fifty variables could be written in long-hand fashion without looping, a
great number of error prone commands would be required.
When the number of loop repetitions is a variable
The second general time when looping is required is when the number of loop executions varies
from one time the loop is required to the next. This is the more important reason for looping,
since there is no other (feasible) way to handle the varying number of repeated commands.
For example, say you are developing a user-created canned cycle for multi-pass grooving on a
turning center. As you look over your set of prints showing workpieces that will use your user-
created canned cycle, you notice that some grooves will require but one plunging pass, while
others will require two, three, or even four passes. It would be silly to develop a separate
parametric program for each number of plunging passes. Instead, you can develop a loop that
will allow the number of passes to change from one time the loop is executed to the next.
How many times must the loop be executed?
In some applications, this question is very easy to answer. If, for example, you are developing a
user-created canned cycle for machining bolt hole circles, and if the number of holes on the bolt
hole circle varies from one time your canned cycle is used to the next, you will need to create a
loop to machine the holes. In this case, the number of times the loop must be executed is equal
to the number of holes on the bolt hole pattern (one execution of the loop for each hole).
On the other hand, it can sometimes be quite difficult to determine the number of times a loop
must be executed up-front, based on all variations the loop must handle. Consider, for example a
deep hole peck drilling cycle. Figure 4.6 shows the application.
5

Figure 4.6
This is a perfect application for a loop. Based on the hole depth and peck depth specifications,
any number of loop executions will be required. If, for example, the hole depth is 3.0 in and the
peck depth is 1.0 in, how many loop executions (pecks) will be required? It should be easy to
see that if you divide the hole depth by the peck depth (3.0 / 1.0), you come up with the number
of pecks. In this case, three pecks. If the hole depth is 4.0 in and the peck depth is 0.5 in, eight
loop executions (pecks) will be required. If the hole depth is 5.0 in and the peck depth is 0.5 in,
ten loop executions (pecks) will be required.
At first glance, it may appear that determining the number of loop executions required for the
peck drilling loop is quite easy to calculate. Simply divide the hole depth by the peck depth.
However, it just so happens that in our example cases, the depth of the hole is evenly divisible by
the peck depth. This, of course, will not always be the case. What if the hole depth is 3.05 in
and the peck depth is 1.0 in?
One (rather poor) way to handle this problem is to force the user of this parametric program to
ensure that the hole depth is evenly divisible by the peck depth. This will force anyone using the
parametric program to perform calculations prior to using your program, but it makes your loop
easier to write. (By the way, your parametric programs should always be written in a way that
makes it easiest for the person using your parametric program, not the way that makes it easiest
for you to write.)
As you consider this application further, it may occur to you that if you round the result of the
hole depth divided by the peck depth, youll come up with an integer number equal to the
number of executions (pecks) required for the loop. However, you will also have to recalculate
the peck depth by dividing the hole depth by the newly calculated number of pecks. Here are the
6
calculations in all three versions of parametric programming addressed by this text. We also
include the counter variable as well as the test that determines when the loop is completed.
In custom macro B: We use Z (#26) to represent the hole depth and Q (#17) to represent the
peck depth.

O1001 (Deep hole peck drilling cycle)
#100 =ROUND[#26 / #17] (Number of pecks)
#17 =#26 / #100 (Recalculated peck depth)
#101 =1 (Initialize counter for loop)
.
.
N1 IF[#101 GT #100] GOTO 99 (If finished, exit loop)
.
.
.
In user task 2: We use HDEP to represent the hole depth and PDEP to represent the peck depth.

O1001 (Deep hole drilling cycle)
PECK =ROUND[HDEP / PDEP] (Number of pecks)
PDEP =HDEP / PECK (Recalculated peck depth)
PASS =1 (Initialize counter for loop)
.
.
N1 IF[PASS GT PECK] GOTO NEND
.
.
.
NEND RTS (End of user task program)
In Fadals macro: We use V1 to represent the hole depth and V2 to represent the peck depth.

#SET RND0
#V3 =RND(V1 / V2] Number of pecks
#V2 =V1 / V3 Recalculated peck depth
#V4 =1 Initialize counter for loop
.
.
#:LOOPBEGIN
#IF V4>V3 THEN GOTO :LOOPEND
.
.
.
#:LOOPEND
M99 (End of macro)
7
This is exactly the kind of challenge you will face as you begin developing your own loops.
Though each new loop will present its own special challenges, one of the first challenges to
overcome is determining how many times the loop will be executed. We urge you to conquer
this challenge before moving on with the loop.
Warning! You may be tempted to set up this peck drilling loop in such a way that it will test
against Z axis position instead of a nice round number of passes. This same temptation will
come any time your loop performs multiple machining operations. However, this solution to the
number-of-passes problem almost always renders a rather poorly formatted ending to your loop.
For example, say the hole depth is 3.05 and the peck depth is one inch. Your loop may plunge
the tool the first time and then test to see if the hole is finished. 1.0 is not greater than 3.05, so
the depth value is stepped and the loop is executed a second time. After the second pass, 2.0 is
still not greater than 3.05. Step the depth value is again stepped and the loop is executed again.
After the third pass, the hole will be 3.0 in deep. It is not quite to depth yet, but the loop cannot
make a full pass without going too deep.
This is what we mean by a poor loop ending. The loop must be exited, yet there is still
machining left to do, meaning more motion commands must be programmed even after the loop.
It is always better to completely solve the problem of the number of loop executions and by how
much counters must be stepped before you begin writing the loop. Letting the loop test against a
nice round number of executions will render a structured, consistent result.
What must be initialized and stepped?
Anything that changes each time through the loop must be initialized prior to the IF statement
and stepped at the end of the loop. Beginners tend to have problems visualizing things that
change from one loop execution to the next. You may find yourself in the middle of writing
your loop before it occurs to you that some loop function must change during each loop
execution. If you are having problems in this regard, it will help to write the first two or three
passes you want the loop to perform long-hand with hard and fixed CNC commands. This will
allow you to analyze what you need your loop to do and will make it easy to see what changes
during each pass.
With the deep hole peck drilling cycle, for example, two Z surfaces will change after each loop
execution. The current peck position will change, as will the rapid approach position prior to
each pass. (The rapid approach position outside the hole will not change. It will remain 0.1 in
above the surface to be machined.)
You must also determine by how much each of these variables will change after each execution
of the loop. We will call the change amount for each changing variable the increment value. In
both cases for the deep hole peck drilling cycle, the increment value will be equal to the peck
depth. That is, after each peck the new rapid approach position and peck depth position will be
the peck depth deeper into the hole.
Here is the continuation of the deep hole peck drilling cycle, including the variables that must be
initialized and stepped.

8
In custom macro B: We use Z (26) to represent the hole depth and Q (#17) to represent the peck
depth.

#102 =0.1 (Initialize current rapid approach position)
#103 =-[#17] (Initialize current hole bottom position)
.
.
.
.

CURR =0.1 (Initialize current rapid approach position)
CURZ =-[PDEP] (Initialize current hole bottom position)
.
.
.
.

#SET RND0
#V5 =0.1 Initialize current rapid approach position
#V6 =V2 Initialize current hole bottom position
.
#:LOOPBEGIN
.
.
.
#:LOOPEND
9
M99 (End of macro)
Are there any other constants required for the loop?
Though the deep hole peck drilling cycle requires no other constant values, you will commonly
need to perform yet more calculations outside the loop (prior to the IF statement) to come up
with values needed within the loop. In an evenly spaced bolt hole circle parametric program, for
example, the incremental angular distance between the holes will be the increment value for the
current angle being machined. That is, after each hole is machined, the current angle must be
stepped by the incremental angular distance between the holes. The incremental angular distance
between the holes will can be calculated as 360 divided by the number of holes on the bolt hole
pattern. Since this calculation renders a constant number and is only required once, it is best to
place it outside the loop (prior to the IF statement). You will commonly find it possible to
perform calculations outside the loop that will minimize the need to perform redundant
calculations within the loop.
Are any approach motions required prior to the loop?
Most machining loops require that the tool be positioned in a certain way prior to starting the
loop. This initial positioning movement is commonly done outside the loop, prior to the IF
statement. In our deep hole peck drilling cycle, for example, if this cycle is to be used on a
turning center, it will be necessary to bring the tool up close to the workpiece to be machined
(center of the spindle in X and 0.1 away from the workpiece in Z). Here is the additional
command in each version of the deep hole drilling cycle.
peck depth.
G00 X0 Z0.1 (Rapid up into position)
.
.
.
.
.
10
.
#SET RND0
#:LOOPBEGIN
.
.
.
#:LOOPEND
M99 (End of macro)
What must be done during each loop execution?
While this may sound like a simple question, as you approach your first few loops, it will likely
seem difficult to determine just what must be done each time the loop is executed. We break
actions in the loop into three types.
Calculations for movements are commonly required during loops that perform machining
operations. In almost all cases, something changes from one execution (machining pass) of the
loop to the next. If positioning movements change, calculations must be used to specify the
locations of the new positioning movements. In the case of our deep hole drilling cycle, since
the stepping of each variable handles all the differences from one loop execution to the next,
there is no need to perform special calculations prior to the motion commands.
Motion commands are also required for loops that perform motion commands. As you write
your first few loops, be careful not to do too much during your motion commands. Be sure you
isolate only those commands required to make one machining pass. Your tendency will be to
proceed right into the second or third pass. In the case of our deep hole drilling cycle, the loop
must perform three motions. First, it must rapid the tool to its (new) approach position in Z.
Second, it must feed the tool to its current bottom position. Third, it must retract the tool out of
the hole.
Counter and changing variable stepping must be done at the completion of each loop execution.
Be sure you step everything that changes each time through the loop. Along with the counter, in
our loop for deep hole drilling, we must step the current approach position and the current
bottom position. After stepping everything that changes, be sure to send the control back to the
IF statement to repeat the test that determines when the loop is finished (with a GOTO
statement).
Here is the completed loop for deep hole drilling in all three versions.
11
peck depth.
G00 Z#102 (Rapid to current approach position)
G01 Z#103 F0.007 (Plunge to current bottom position)
G00 Z0.1 (Rapid out of the hole)
#101 =#101 +1 (Step loop counter)
#102 =#102 - #17 (Step current rapid approach position)
#103 =#103 - #17 (Step current hole bottom position)
GOTO 1 (Go back to test)

G00 Z=CURR (Rapid to current approach position)
G01 Z=CURZ F0.007 (Plunge to current bottom position)
PASS =PASS +1 (Step loop counter)
CURR =CURR - PDEP (Step current rapid approach position)
CURZ =CURZ - PDEP (Step current hole bottom position)
GOTO N1 (Go back to test)
#SET RND0
12
#:LOOPBEGIN
#R1 =V5 Set R1 to the value of V5
G00 Z+R1 (Rapid to current approach position)
#R1 =V6 Set R1 to value of V6
G01 Z+V6 F0.007 (Plunge to current bottom position)
#V4 =V4 +1 Step loop counter
#V5 =V5 - V2 Step current rapid approach position
#V6 =V6 - V2 Step current hole bottom position
GOTO :LOOPBEGIN Go back to test
#:LOOPEND
M99 (End of macro)
Loop examples
We include two realistic examples of parametric programs that include loops, one for machining
centers and one for turning centers. These should reinforce your understanding of how loops
function. For each example, we even answer the questions posed earlier about loop criteria.
However, we must warn you again that not two looping applications will be the same, and each
will challenge you with different problems to overcome. If you follow our guidelines for
developing loops, and if you answer all important questions relative to the loop, you should be
able to tackle even the most complex loops.
Bolt hole circle example
Figure 4.7 shows the drawing for this application.

Figure 4.7
13
When is a loop required? This application requires a loop because we wish our bolt hole
machining parametric program to machine any number of holes. It would be infeasible to try to
write a separate parametric program for each number of holes.
How many times will the loop be executed? For this application, the answer to this question is
simple. The loop will be executed once per hole.
What must be initialized and stepped? Aside from the loop counter, the current angle (initialized
as the value of the starting angle), must be initialized and stepped. While the XY position will
change for each hole, it will be a function (sine & cosine) of the current angle.
Are there any constants for the loop? Yes, the incremental angular distance (calculated as 360
divided by the number of holes) must be calculated before the current angle can be stepped.
Also, the Z surfaces can be set as constants to avoid redundant calculations within the loop.
Are any approach movements required before the loop? In our application, we will assume that
the CNC programmer has not positioned the tool in XY prior to calling this parametric program.
However, we will assume the spindle is running, tool length compensation is instated, and the
tool is ready to begin machining.
What must be done during the loop itself? The loop must first calculate the XY position of the
current hole based on the current angle. In X, this will be done with the formula cosine of the
angle times the radius plus the dimension in X to the center of the bolt hole pattern. In Y the sine
function will be used. Next the hole will be machined using the canned cycle type specified in
the call statement. Finally, the counter will be stepped (by one) as will the current angle (by the
incremental angular distance between the holes.
Custom macro B example:
Figure 4.8 shows the letter address arguments to be used in this example.
14

Figure 4.8
Notice that the cycle type is specified with argument C. The number corresponding to C
represents the G code number for the desired canned cycle. C81., for example, requests a
standard drilling cycle. C84. requests a tapping cycle. And so on. Here is a portion of a main
program that uses the bolt hole circle custom macro.
O0008 (Main program)
N005 G54 G90 S800 M03 T02 (Select coordinate system, absolute mode, start spindle,
get next tool ready)
N010 G00 X3.0 Y2.5 (Rapid to center of bolt hole pattern)
N015 G43 H01 Z.1 (Instate tool length compensation, rapid up to workpiece)
N020 G65 P1008 X3.0 Y2.5 Z0 R1.75 D0.75 A45.0 H8.0 C81. F5.0 (Machine entire bolt
hole pattern with drilling cycle)
N025. . .
.
.
.

15
In the custom macro, X is represented by local variable #24, Y by #25, Z by #26, R by #18, D by
#7, A by #1, H by #11, C by #3, and F by #9.
O1008 (Custom macro to machine bolt hole circle)
#101 =1 (Initialize counter)
#102 =#1 (Initialize current angle to A)
#103 =360 / #11 (Constant for incremental angular distance between holes)
#104 =#26 +0.1 (Constant for rapid approach plane)
#105 =#26 - #7 (Constant for Z bottom position of hole)
N1 IF [#101 GT #11] GOTO 99 (Test if loop is finished)
#110 =#24 +COS[#102] * #18 (Calculate X position for current hole based on current
angle)
#111 =#25 +SIN[#102] * #18 (Calculate Y position for current hole based on current
angle)
G#3 X#110 Y#111 R#104 Z#105 F#9 (Machine current hole)
G80 (Cancel cycle)
#101 =#101 +1 (Step counter)
#102 =#102 +#103 (Step current angle)
GOTO 1 (Go back to test at loop beginning)

16
User task 2 example:
Figure 4.9 shows the local variable arguments to be used in this example.

Figure 4.9
Notice that the cycle type is specified with argument CYCL. The number corresponding to
CYCL represents the G code number for the desired canned cycle. CYCL=81., for example,
requests a standard drilling cycle. CYCL=84. requests a tapping cycle. And so on. Here is a
portion of a main program that uses the bolt hole circle user task program.
N005 G15 H1G90 S800 M03 T02 (Select coordinate system, absolute mode, start
spindle, get next tool ready)
N020 CALL O1008 XCTR=3.0 YCTR=2.5 ZSUR=0 RAD=1.75 HDEP=0.75 AGL=45.0
HLES=8.0 CYCL=81. FEED=5.0 (Machine entire bolt hole pattern with drilling cycle)
N025. . .
.
.
.
Here is the user task program:
17
O1008 (User task program to machine bolt hole circle)
HLE =1 (Initialize counter)
CURA =AGL (Initialize current angle to AGL)
IAGL =360 / HLES (Constant for incremental angular distance between holes)
RAPP =ZSUR +0.1 (Constant for rapid approach plane)
ZBTM =ZSUR - HDEP (Constant for Z bottom position of hole)
N1 IF [HLE GT HLES] GOTO N99 (Test if loop is finished)
CURX =XCTR +COS[CURA] * RAD (Calculate X position for current hole based on
current angle)
CURY =YCTR +SIN[CURA] * RAD (Calculate Y position for current hole based on
current angle)
G=CYCL X=CURX Y=CURY R=RAPP Z=ZBTM F=FEED (Machine current hole)
G80 (Cancel cycle)
HLE =HLE +1 (Step counter)
CURA =CURA +IAGL (Step current angle)
GOTO N1 (Go back to test at loop beginning)
N99 RTS (End of use task program)
Fadals macro example:
Figure 4.10 shows the V series variable arguments to be used in this example.

Figure 4.10
18
Notice that the cycle type is specified with argument V8. The number corresponding to V8
represents the G code number for the desired canned cycle. V8=81., for example, requests a
standard drilling cycle. V8=84. requests a tapping cycle. And so on. Here is a portion of a main
program that uses the bolt hole macro.
N020 #V1=3.0 Assign argument V1
N030 #V3=0 Assign argument V3
N055 #V8=81. Assign argument V8
N065 M98 P1008 (Machine entire bolt hole pattern with drilling cycle)
N070. . .
.
Here is the macro to machine the bolt hole circle.
O1008 (Macro to machine bolt hole circle)
#V21 =1 Initialize counter
#V22 =V5 Initialize current angle to V5
#V23 =360 / V6 Constant for incremental angular distance between holes
#R4 =V7 Set R4 to feedrate
#R5 =V8 Set R5 to cycle type
#R6 =V3 +0.1 Constant for rapid approach plane
#R7 =V3 - V9 Constant for Z bottom position of hole
#:LOOPBEGIN Beginning point of loop
#IF [V21 >V6] THEN GOTO :EXIT Test if loop is finished
#R8 =V1 +COS(V22) * V4 Calculate X position for current hole based on current angle
#R9 =V2 +SIN(V22) * V4 Calculate Y position for current hole based on current angle
G+R5 X+R8 Y+R9 R0+R6 Z+R7 F+R4 (Machine current hole)
G80 (Cancel cycle)
#V21 =V21 +1 Step counter
#V22 =V22 +V23 Step current angle
#GOTO :LOOPBEGIN Go back to test at loop beginning
#:EXIT End of loop
M99 (End of macro)

19
Multiple pass grooving example
Figure 4.11 shows the drawing for this application.

Figure 4.11
When is a loop required? This application may or may not require a loop. If the width of the
grooving tool is equal to the width of the groove, no loop is required, and only one plunging pass
will be made. However, if the groove width is wider than the tool width, multiple passes will be
required. The loop will handle any number of required passes.
How many times will the loop be executed? This is a rather difficult problem to solve. Say for
example, the groove width is 0.25 and the tool width is 0.125. Most programmers would agree
that three passes are required, since there must be some overlap between passes. Figure 4.12
shows one method of determining how many passes are required (with #of passes) when the
groove is wider than the grooving tool. The 0.02 value in this formula is the minimum overlap
between passes.

Figure 4.12
20
What must be initialized and stepped? Aside from the loop counter, the current Z position of the
grooving tool must be stepped. Figure 4.12 also shows the formula to determine by how much
the Z position must be stepped (with PASS).
Are there any constants for the loop? Yes, the X positions for each pass remain the same, as will
be the amount to move over between passes (PASS).
Are any approach movements required before the loop? In our application, we will assume that
the CNC programmer has positioned the tool up close to the work piece, but not precisely where
it must be to make the first pass, meaning an approach movement must be made before the loop.
What must be done during the loop itself? The loop must position the tool to the current Z point,
plunge the groove, pause, and get the tool out of the groove. Then the counter must be stepped
by one and the current Z position must be stepped by the proper move over amount (PASS)
shown in figure 4.12.
Custom macro B example:
Figure 4.13 shows the letter address arguments to be used in this application.

Figure 4.13
Here is a portion of a main program that calls the custom macro to machine a groove.
.
.
(Turning operations to get workpiece ready to groove)
.
.
N155 T0505 (Index to grooving tool)
N160 G96 S500 M03 (Start spindle at 500 SFM)
N165 G00 X4.0 Z0.1 (Rapid up close to workpiece)
21
N170 G65 P1009 B1.5 S1.0 Z1.0 W0.25 T0.125 C0.03 F0.005 (Machine groove)
N175 G00 X6.0 Z5.0 (Rapid to tool change position
N180 M01 (Optional stop)
N185 . . .
.
.
.
Here is the custom macro for this application: Letter address argument B will be represented in
the custom macro by local variable #2, S by #19, T by #20, F by #9, C by #3, W by #23, and Z
by #26.
O1009 (Custom macro to machine groove)
#101 =FUP[#23 / [#20 - 0.02]] (Calculate number of passes)
#102 =#23 - #20 (Calculate stock remaining after first pass)
#103 =#102 /[#101-1] (Calculate move over amount in Z)
#104 =1 (Initialize pass counter)
#105 =#26 (Initialize current Z position to plunge)
#106 =#2 +0.2 (Calculate clearance position in X)
G00 X#106 Z-[#105] (Rapid to first plunging position)
IF[#23 GT #20] GOTO 25 (Test if multiple passes are necessary)
(Only one pass is required)
G01 X#19 F#9 (Plunge groove)
G04 P500 (Pause to eliminate tool pressure)
G00 X#106 (Rapid out of groove)
GOTO 50 (Skip multiple passes)
N25 IF[#104 GT #101] GOTO 50 (Test if finished with multiple passes)
G00 Z-#105 (Rapid to current Z position for plunge)
G01 X#19 F#9 (Plunge groove in current position)
G04 P500 (Pause to eliminate tool pressure)
#105 =#105 - #103 (Step current plunging position in Z)
#104 =#104 +1 (Step counter)
GOTO 25 (Go back to test if finished making plunging passes)
(Machine chamfers)
N50 G00 Z-[#26 +#3] (Rapid to left side of left chamfer)
G01 X#2 (Feed flush with big diameter)
X[#2 - [2 * #3]] Z-#26 (Plunge left chamfer)
Z-[#26 - #23 - #3 +#20] (Rapid to right side of right chamfer)
G01 X#2 (Feed flush with big diameter)
X[#2 - [2 * #3]] Z-[#26 -#23 +#20] (Plunge right chamfer)
M99 (End of custom macro)

22
Nesting loops
As you have seen, loops add a great deal of power to your parametric programming capabilities.
In the bolt hole cycle, 10-12 commands can machine any number of holes. In the grooving
cycle, about 10 commands can make any number of grooving passes. In some looping
applications, just a few commands can cause thousands of machine movements!
While you may have had all the looping you can take for a while, we wish to show one more
powerful capability with looping called loop nesting. Loop nesting means to have one loop
inside another, and it is commonly helpful with machining center applications.
A grid pattern example
Figure 4.16 shows one time when loop nesting can be helpful.

Figure 4.16
As you can see, this workpiece requires the machining of several rows of evenly spaced holes.
Well say this is but one of many workpieces your company machines that require grid patterns
of holes to be machined. The number of holes along X and Y vary from one workpiece to the
next.
This application requires one loop inside another. The series of holes along the X axis, for
example, can be machined in one loop that is inside the loop that machines the Y rows of holes.
This, of course, could be reversed if you prefer. Figure 4.17 shows the custom macro B
arguments well use for this example. (Only one version of this example will be shown.)
23

Figure 4.17
To keep it simple, well keep certain things constant, like Z surface, hole depth, and feedrate,
even though you would likely need these values to be specified with arguments. Here is a
portion of a main program that machines the grid pattern.
.
.
N050 T05 M06 (Place 1/8 drill in spindle)
N060 G00 X0 Y0 (Rapid over to workpiece in XY)
N065 G43 H05 Z.1 (Instate tool length compensation, rapid up in Z)
N070 G65 P1010 X0.25 Y0.25 U0.25 V0.5 W10.0 H5.0 (Machine entire grid pattern)
.
.
.
Here is the custom macro that machines the entire grid pattern. Letter address X is represented
by local variable #24, Y by #25, U by #21, V by #22, W by #23, and H by #11.
O1010 (Custom macro to machine grid pattern)
G00 X#24 Y#25 (Move to lower left hole location)
(Begin outside loop for rows of holes along Y)
#101 =1 (Row counter for outside loop)
#102 =#25 (Current Y position for holes)
N1 IF[#101 GT #11] GOTO 99 (Test if Y row loop is finished)
(Begin inside loop for holes along X)
#111 =1 (Hole counter for inside loop)
#112 =#24 (current X position for hole)
N10 IF[#111 GT #23] GOTO 50 (Test if X row loop is finished)
24
G81 X#112 Y#102 R0.1 Z-0.5 F4.5 (Drill current hole)
G80 (Cancel cycle)
#111 =#111 +1 (Step hole counter for inside loop)
#112 =#112 +#21 (Step X position of hole)
GOTO 10 (Go back to test for inside loop)
N50 #101 =#101 +1 (Step Y row counter for outside loop)
#102 =#102 +#22 (Step Y position for hole)
GOTO 1 (Go back to test for outside loop)
#101 is the counter for the rows of holes along Y. #111 is the counter for the holes along X.
Notice how the test in N1 begins the outside loop. The first time this command is read, the
conditional expression will be false, which allows the entry to the inside loop. Holes along X
will be machined until the test in line N10 is true (the first row of holes along X is finished).
Then #101 is stepped and the second row of holes is machined. While this example may take
some study, notice how powerful this short program truly is. Literally thousands of holes can be
machined with one calling command to this very short program!
Again, we do not show this example in user task 2 or Fadals macro. However, you should now
be able to convert this program to any version of parametric programming with relative ease.

Lesson Five Text

Uploaded by

Copyright:

Available Formats

You might also like

Lesson Five Text

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Lesson Five Text

Uploaded by

Copyright:

Available Formats

Parametric Programming Lesson Five: Generating Loops

You might also like