Programming With Variables

Contents

Introduction
Types of Variables
Units of Variables
Changing Variable Values
Writing blocks using variables
Sample Variable Programs
Example 1 - Drilling a pattern from a variable location
Example 2 - Incremented drilling
Example 3 - An outside milled four cornered object
Example 4 - Milling an inside circle
Example 5 - Iterated Run
Credits

RS274NGC makes provision for the inclusion of variables in the numeric part of program words. Variables can be named with any number up to 5399. You can access the value of a variable in a gcode program by placing a pound (#) sign before the number/name of the variable that you want to reference. Often in the EMC literature the terms variables and parameters are used to refer to the same thing.

For those who learned part programming on older machine tool controls, the inclusion of variables makes for some strange looking program blocks. But variables can be very useful programming tools. This unit develops the concepts of variables as a gcode programming tool and applies them to five common milling tasks.

Before we begin, you need to understand that the NGC development defined a lot of variables and how they should be used in machine control. But the EMC and its interpreter only takes advantage of a few of these variables and those only for its built in coordinate system. You can see which ones, all in the 5000 + range if you view the emc.var or generic.var files shipped with EMC. A typical variable file is listed in table 1. We will add and use several variables that do not have predefined functions in the EMC.
 
 

There are two ways to define variables for use in part programs. The most obvious is an explicit reference to the variable in the currently used variable file. Each time the EMC starts up it loads a variable file. The default variable file is emc.var but this can be changed in the .ini file. For convenience, this paper uses emc.var as if it were the currently loaded file.

When the following line is placed in emc.var, it explicitly defines a variable.

1000 55

Implicit reference to a variable is done when a name is used within a program but no reference is made to that variable in the variable file. The following line of code in a part program will initialize a variable named 1000 and assign it a value of 55.

#1000 = 55

Explicit variables act just like implicit variables while the EMC is running but reloading the variable file will reset explicit variables to the value that they are assigned in the variable file. When EMC is shut down normally, the current values of all explicit variables are written into emc.var. Since explicit variables can change value from one run of EMC to the next, they may not contain the values that you expect when you restart your machine.

The EMC doesn't care very much what we name variables or what we use them for. For explicitly defined variables, the EMC cares only that they are two numbers in a row on a line by themselves in the emc.var file. For implicitly defined variables, the EMC cares not a whit. The only complaints that you might get from the EMC is if a reference to a variable makes a reference to an unknown word, or is out of range for a distance, or concerns tool compensation. While you are writing or using variables you will want to refer to and probably stay away from those variables listed in emc.ini that are used to set up the coordinate systems.

No units are implied by the value assigned to a variable. Variables simply contain numbers. As an example, if variable #1000 as we have defined it above were referenced in a part program after a (g) as we have done in the following line, it would refer to a coordinate system. In this case g55.

G#1000

X#1000

T#1000 M6

The variable assignment operator allows you to change the value of a variable while a gcode program is running. Any reference to a variable name followed by an equals sign and a number or an expression in brackets [] will assign that number to the named variable.

#1002 = [#1000 + #1001]

One interesting case of assignment comes from the fact that you can assign a variable it's own value so incrementing is permitted by the interpreter.

#1000 = [#1000 + 1]

Right about now, the conventional program code writer will realize that it is a bit easier to just write the real numbered code than it is to write the variable code. It is also easier to read and make sense of real numbered code as the following two lines illustrate.

Hard code T55 M6 G43 H55 G55 X55 A55
Variable code T#1000 M6 G43 H#1000 G#1000 X#1000 A#1000

Variables can also be of value where a location is repeated many times during a program. Rather than typing (x21.1345) in a dozen locations in a program you can assign that value to a variable at the top of your program and reference it wherever you need to within. Then if a program wide change needs to be made to that value it can be done once and all references will shift to the new value.

Under any of these conditions variable programming becomes much more efficient than repeating or editing all those lines of code with the correct values.

In this section we develop five examples of the use of variables in program code. These examples are not intended to be complete in themselves. Nor are they intended to be particularly useful or efficient. They are intended only to illustrate certain uses of variables in gcode.

You should also remember that these code samples were all written for my machine. It does not lay out the axis the way that they are on graph paper. X moves plus toward the left and y moves minus toward you when you face the mill. For all of the illustrations below the operator would be standing below the figure and looking into it.
 
 

Example 1 - Drilling a pattern from a variable location

One of the simplest uses of variables is to set up positions from which a set of milling operations can be performed. In this capacity these variables work somewhat like the coordinate systems that are common to many g code implementations.

This program assumes that the drill bit is already loaded and that the machine is home. The pattern is five holes. One in the center and four on a 1 inch radius around that center hole. Opposite holes in the pattern are aligned with the axes in what could be called a diamond. (see figure 1)

We will begin by assigning values to two variables. We can then use these variables as the center of the hole pattern and increment the drilling operation with respect to that center location.

This set of code blocks could have been written using the real values for the locations, however the use of just two variables allows the entire pattern to be shifted rather easily during production to keep the hole locations within the tolerances specified on the print. Writing this kind of code using variables also allows for wide variation in the setup of the machine for milling.

In this example the pattern is a fixed shape and size - perhaps a pipe flange or a bearing mount for a sliding rod. The two variables allow the operator to quickly shift the pattern to the exact coordinates where it should be placed. In the example the editing would have to be done to the program code on lines N10 and N12 because the variables are implicit. Explicit variables would allow the operator to change the values in the emc.var file and reload it.

Code like that developed in this example can easily be copied and pasted several times into the same program to reproduce the same pattern at several locations. The only additional code that must be added is a line that changes the variables for each location. This could be as simple as #1000 = (number) before each pasted chunk, or it could be an increment from the first location. Example two shows how to increment.

The lines of code in table 3 illustrate the technique of incrementing variables along with using those variables during the running of a program. Again lines N10 and N12 assign initial values to the variables that will be used. Line N14 moves the machine to the location of the hole to be drilled while N16 and N18 perform the operation. Line N20 increments both variables. In the illustrated code #1000 is increased by 2 and #1001 is increased by 1. Taken together, lines N14 through 18 are a loop (although this version of RS274NGC does not implement looping) and the code is just copied and pasted into the program for the number of times the operation is to be repeated.

Since the EMC interpreter doesn't care what the lines are numbered, the above code will run as is. It would look somewhat better if it were renumbered. Again only the variable values need to be changed to move the location of the set of holes. In this case, the code will produce a diagonal set of four holes. Each hole is two inches in x and one inch in y away from the previous hole.

A cautionary note must be included here. Once the machine tool is into the program, there is no good way to know where it is except to observe the machine itself. Stopping and then restarting from anywhere but the top line is an invitation to disaster because the values of the variables have been changed by the program itself.

This example is more complicated than what you have seen so far. Our task is to mill a four cornered object that has all outside corners using tool diameter compensation. This object could be a square, a rectangle, a parallelogram, a trapezoid, or an object where none of the angles and sides are the same.

We need to tell the machine all of the following information.

• Tool number and length
• Coordinate system and plane
• Approach point
• Depth
• Tool diameter offset and direction of travel, and coolant on
• First corner coordinates, feed rate milling and feed rate
• Second corner coordinates
• Third corner coordinates
• Fourth corner coordinates
• Turn off tool diameter offset, tool length, and coolant, retract depth, and return home.

The size and shape of the part can be changed and depend upon the actual numbers entered in lines numbered 190 to 220. Suppose we wanted to cut a trapezoid with the small side one inch less that the long side. This could easily be made trapezoidal by changing those lines as table 5 lists. A set of these sample shapes is shown in table 8.

Now the narrow side is one inch smaller than its longer parallel side and the other two are angled in by a half inch. Notice that very few changes needed to be made in the code in order to create the second part. We added both coordinates to the corner definitions and changed the actual numbers. These distance kinds of g-code numbers can be stored as variables. By changing the actual values of these variables we can create many different sizes and shapes using the same set of part program code.

First we need to define a set of variables and what we will use them for.

One small problem that comes up with variable programming is that often you must include the tool diameter both in the tool file and as a variable when it will be used to compute an approach point.

Now all that we have to do is plug in these variable names in place of the hard numbers in the above code. For this more general case, we will include x and y coordinates for each corner. By doing this we can rotate the shape and make non parallel sides. We will also need to set up a computation for the approach in line 40 and the exit in line 110.

The variables and what they do are included in code as comment blocks. This way if the part program and the variable file become separated I can recreate the variable file easily. Including the variables as comments also helps when reading the program and debugging a setup.

There are some limits on how far you can rotate this part using the four corners. A useful rule is that the line between the first corner and the second should not be more than 45 degrees off of the x axis of the machine or the cutter comp may not work correctly. If the line between the last corner and the first is steeper than a 45 you will get a tool gouge that will not be reported by the EMC.

TABLE 8
Corner values and sample shape

Square  corner x  y  1  0  0  2  2  0  3  2  -2  4  0  -2
Rectangle  corner x  y  1  0  0  2  4  0  3  4  -2  4  0  -2
Trapezoid  corner x  y  1  0  0  2  4  0  3  3.5  -2  4  0.5  -2
Parallelogram 1  corner x  y  1  0  0  2  4  0  3  4.5  -2  4  0.5  -2
Parallelogram 2  corner x  y  1  0  0  2  4  1  3  5  -1  4  1  -2
Diamond  corner x  y  1  0 0  2 1 1  3  2 0  4 1 -1
Shape  corner x  y  1  0  0  2  1  1  3  4 2  4 3 -1

As mentioned earlier, this code and the shapes that can be cut with it is not very easy to read. But you should read through it and substitute the variable description wherever you find a pound sign. When you have done this a few times any program file that uses variables will become easier to understand.

Inside milling with cutter compensation requires a little more complexity on the approach and setup of the cutter compensation but the use of variables works much the same way that it did in the four sided example above.

For this example we want to drill an initial hole inside the circle and then change to the end mill and return to the hole and start the approach there. The first step is to list the steps that we need to take to complete this task.

• Machine home
• Load a drill for starting hole
• Set drill length and coordinates
• Compute approach hole location and move to it
• Drill the hole
• Retract drill
• Move home
• Change tool to end mill
• Pick up tool length and move to approach hole
• Plunge end mill
• Set feed rate, tool diameter compensation and arc approach first point
• First half circle
• Second half circle
• Move away from circle
• Retract mill
• Move home

For the initial test of this program, the relevant portion of the variable file looked like those lines in table 9.

By using variables we are able to easily adjust the size of the hole that will be cut and the size of the cutter. By making the tool slots also variables, the code can be used over and over in the same program with different combinations. Editing sizes is relatively easy for the operator during final setup and run because the variables are explicit. One caution here is that both #1104 and the size of the tool defined in the emc.tbl need to be about the same size.

Example 4 uses one half of the radius of the finished circle as the radius of the tool approach for tool diameter compensation. (see figure 11) The edge of the tool is placed on this arc before the compensation move is begun. For large circles this approach may waste some time getting from the initial location to the start of the circle cut. A change in the approach point arithmetic expression could move the approach point closer to the edge of the circle.

One limitation of the code in table 10 is that tool diameter can't be larger than the radius (d/2) of the finished hole or the EMC will generate a cutting compensation error message.

As we have already seen in example 2, the EMC's interpreter allows for the setting of variables during program code execution. That example reset the loop variable at the start of each program run. But the value of a variable persists throughout the life of an EMC run so that it's incremented value can be accessed by pressing the <run> button to start the next loop.

Variable #1000 is a explicit variable. It is also the loop variable. By making #1000 explicit the machine operator can reset the loop to zero by reloading the parameter file from the TclTk parameter edit window when all of the loops through the program have been completed. This code shows a simple drilling operation that uses successive coordinate systems for each run.

This line is placed in the variable file.

1000 1001

This kind of program might be used with a setup that had a number of vices on the milling table with the same part in each. The same thing could be achieved using a single program with incrementing between each and an option stop (m0). Such a program would be much longer and would require <restart> rather than <run>.

As the EMC interpreter exists now, there is no good way to know which coordinate system will be used next without looking at the machine or remembering the offsets as loaded into each coordinate system. This code will also cause an error message if you attempt to run it after the nineth time. Since the loop variable is explicit, it can be reset at any time before the EMC is shut down by reloading the variable file.

Credits

This page is a part of the EMC Handbook and is covered by its GPLD copyright.   It is maintained by Ray Henry. Comments, criticism, flames, additions, subtractions, and editing are welcomed.