What Is Parametric Programming?

The best kept secret of CNC! There are few CNC people that even know what parametric programming is -- and fewer still that know how to use it! Given the enhancements that this kind of programming brings, it is surprising that more machine tool builders, control manufacturers, and technical schools don't say more about it. In this short discussion, we'll explain what parametric programming is and show its main applications. What it is Parametric programming can be compared to any computer programming language like BASIC, C Language, and PASCAL. However, this programming language resides right in the CNC control and can be accessed at G code level, meaning you can combine manual programming techniques with parametric programming techniques. Computer-related features like variables, arithmetic, logic statements, and looping are available. Like computer programming languages, parametric programming comes in several versions. The most popular is Custom Macro B (used by Fanuc and Fanuc-compatible controls). Others include User Task (from Okuma), Q Routine (from Sodick), and Advanced Programming Language [APL] (from G& L) In addition to having many computer-related features, most versions of parametric programming have extensive CNC-related features. Custom macro, for example, allows the CNC user to access many things about the CNC control (tool offsets, axis position, alarms, generate G codes, and program protection) right from within a CNC program. These things are impossible with only normal G code programming techniques. Applications: Many companies have excellent applications for custom macro and don't even know it. Of course, if you don't even know you have an application for something, it's impossible to even consider using it. While these applications are covered in much greater detail during our video course and CD-rom course, applications for custom macro fall into five basic categories. Do any of these sound familiar? Families of parts Almost all companies have at least some applications for custom macro that fit into this category. Possibly you have prints dimensioned with variables right on the print. The programmer must reference a chart on the drawing to come up with values needed in the program. Or perhaps you consistently find yourself editing one CNC program to make another one. If you do, you have a perfect application for custom macro! User-created canned cycles Even if you don't have a perfect family of parts application for custom macro, surely you have at least some work pieces that require similar machining operations. Or maybe you find yourself wishing your CNC control had more (or better) canned cycles. With custom macro, you can develop general purpose routines for operations like thread milling, bolt hole patterns, grooving, and pocket milling. In essence, you can develop your own canned cycles! Complex motions There may be times when your CNC control is incapable of easily generating a needed motion. To perform accurate taper thread milling (taper threads), for example, your control must have the ability to form a spiraling motion in XY while forming a linear motion in Z (helical motion will not suffice in this case). Unfortunately, most CNC

controls do not have spiral interpolation. But, believe it or not, with custom macro you can generate this desired motion. In essence, custom macro, allow you to create your own forms of interpolation. Driving accessory devices Probes, post process gauging systems, and many other sophisticated devices require a higher level of programming than can be found in standard G code level programming. Custom macro is the most popular parametric programming language used to drive these devices. In fact, if you have a probe on one or more of your machines, you probably have custom macro! Utilities There is a world of things you can do with custom macro that you would never consider doing without it. Custom macro can help reduce setup time, cycle time, program transfer time, and in general, facilitate the use of your equipment. A few example applications that fit into this category include part counters, tool life managers, jaw boring for turning centers, using standard edge finders as probing devices, and facilitating the assignment of program zero. Benefits of parametric programming Fast turnaround in production is the most significant benefit of family of parts macros. More time is often needed to develop macro than a standard program.

When to program parametrically Large number of parts that are same shape but different in dimensions Large number of parts that are similar in shape Parts that repeat fairly frequently Parts that contain repetitive tool path Various machining patterns Parametric program is never a replacement for other methods- it only enhances them. There could be a significant investment in time spent on parametric macro program development. The resulting benefits are must be tangible and measurable, in order to be economically efficient. Example: To stress what can be done with parametric programming, we show a simple example written in custom macro B for a machining center application. It will machine a mill a hole of any size at any location. Notice how similar this program is to a program written in BASIC. Program O0001 (Program number) #100=1.0 (Diameter of end mill) #101=3.0 (X position of hole) #102=1.5 (Y position of hole) #103=.5 (Depth of counter bored hole) #104=400 (Speed in RPM) #105=3.5 (Feed rate in IPM) #106=3.0 (Tool length offset number) #107=2.0 (Diameter of counter bored hole) G90 G54 S#104 M03 (Select abs mode, coordinate system, start spindle) G00 X#101 Y#102 (Rapid to hole center) G43 H#106 Z.1 (Instate tool length compensation, rapid to approach Z position) G01 Z-#103 F [#105 / 2] Y [#102 + #107 / 2 - #100 / 2] F#105 G02 J-[#107 / 2 - #100 / 2] G01 Y#102 G00 Z.1 M30 There are 3 types of variables - Local, Common and System variables. Local variables are "local" to the program that is currently executing. They can be set and read only in that program. As soon as control is passed to another program, such as when a subprogram is called, that program has its own set of local variables which can be set, read, etc. When control passes back to the original program, its set of local variables is restored. For instance, if you set variable #1 to 100 in the main program, then call a subprogram, var #1 is now empty. You can set and use var #1 in the sub without overwriting the value of #1 in the main. When you return to the main program, var #1 retains its original value of 100. This is useful because you can use local variables at will within subprograms without having to keep track of the local variables you are using in other programs for fear of overwriting them. If you watch the

macro variable screen as programs execute, you can see the local variable sets change as control is passed from one program to another. You can pass a value to a local variable when calling a subprogram with the G65 command. Common variables are "common" to all programs. Set the variable in one program and all of the other programs see the same value. They are retained even after program execution stops. They can be set within a program or by the operator on the macro variable screen. You can even create screen labels for some of them to make it easier for operators to set values. One of the things that we use them for is when we have a choice of profiles on a part. The operator can set variable 500, which may have a screen label of "PROFILE#", to the desired profile number and then the program uses this to select the correct tool, spindle, cutter comp and height offset. System variables are special variables that represent values in various registers of the control. For instance, when you call H14, you are referring to offset register 14. The value of offset register 14 can be read or set by accessing system variable #2014. Some system variables are read only and cannot be set. There are system variables for reading the absolute X, Y, or Z position of the machine (read only). We sometimes use this set of variables to read the machine position if we need to come back to that exact same point after a series of calculated moves which may have introduced rounding errors when executed. All of this should be in your operator manual. If you don't have one, get one! The book is not always clear in its descriptions, so write a lot of little test programs until it is clear just how things work. Always start out simple and work up to the complicated stuff. The present invention relates to the field of robotically-automated production lines. More specifically, the present invention relates to providing flexibility to a robotically-automated production line through parametric programming techniques. BACKGROUND OF THE INVENTION Over the past thirty years, machine automation has become an important aspect of every product's assembly or manufacturing line. Computer numerical control (CNC) machines are one type of common automated machinery. CNC machines can be directed by a computer program to perform any task that an operator could make a conventional machine perform, including welding, drilling, laser cutting, and bending. For example, a drill press operator who needs to drill three holes in a metal sheet no longer has to bring the press toward the sheet. Instead, the operator simply places the sheet on the drill press and a computer program commands the press to drill holes in the correct locations. Until recently, CNC machines required individual programs for each specific task. For example, two distinct programs were needed in order to command a drill press to drill four holes in the middle of one metal sheet and four holes along the perimeter of another metal sheet. Therefore, an operator was required to place the first metal sheet in the press, load the first program, remove the first metal sheet, place the second metal sheet in the press, and load the second program. Thus, while CNC automated a machine's individual functionality, it did not automate multiple independent tasks. As a result, programmers consistently had to edit one CNC program to make

another, no matter how closely related the tasks. The advent of robotic manufacturing and assembly lines automated this process to a greater extent by eliminating manual movement of the work piece. Specifically, using the above example, robots are now able to place the first metal sheet in the press, remove the first metal sheet when the CNC-controlled machinery has accomplished its task, place the second metal sheet in the press, and so on. However, the CNC-controlled machinery still requires discrete programs to perform different tasks. Therefore, although a manufacturing line may be automated robotically such that human intervention is not required to manipulate a work piece in a certain way, human intervention (in the form of additional programming) still is required to permit the robotically-controlled line to manipulate the work piece in a different way. Parametric programming has been developed to overcome the need for discrete programs for each independent task that a machine performs. Parametric programming is a technique that allows a CNC programmer to vary the parameters of the task within one program, instead of writing an entirely new program each time the parameters are varied. In other words, parametric programming allows programs to be written using variable-designated parameters instead of fixed numbers. These variables can be changed each time the program is called. For example, if a parametric program is stored in a machine's memory to drill a bolt hole, the program can be used with any corresponding data file to drill any size hole in any location. Parametric programming also includes structures for conditional and unconditional program branching, repetitive looping and mathematical equations. There are several parametric programming languages including CUSTOM MACRO B, USER TASK, Q ROUTINE and ADVANCED PROGRAMMING LANGUAGE. As a result, a programmer simply may develop one program for a certain machine, for example a drill press. The parametric program queues the operator to put in data sets for each individual task that the drill press must perform. The operator then tells the machine when to begin each task, instead of loading a new program each time. Therefore, programming efforts are reduced significantly. Although parametric programming of individual robotic devices and machines is possible, there is no current method for incorporating the flexibility of parametric programming into an entire robotically-controlled manufacturing or assembly line. Because there is no current method for incorporating parametric programming into an entire robotic line, the benefits of parametric programming have not been realized in this application. Thus, complicated and complete programming revisions are necessary in order to vary the tasks of robotic lines. As a result,

today's robotic manufacturing and assembly lines often are dedicated to manufacturing one type or size of a product. For example, in the context of electrical transformer tanks, a robotic manufacturing line can manufacture only one size enclosure with a particular set of characteristics (e.g., high voltage bushing locations). If another enclosure size with a different set of characteristics is desired, the line must be shut down and reprogrammed. Because of the consequent labor-intensive effort to make such a change, today's robotically-controlled manufacturing and assembly lines are dedicated to specific products or functions. Therefore, it would be advantageous to use the flexibility of parametric programming techniques in a robotic assembly or manufacturing line such that products of varying size and character can be manufactured without interruption in the line. By minimizing human intervention in the production process, the present invention facilitates a "lights out" factory for the production of distribution transformers. Specifically, an external user, like a customer or a field sales person, may orchestrate the entire production process to meet his or her requirements via the Internet, for example. The user is able to configure the product and produce an on line price quotation. Also, the user is able to submit orders, review scheduling, and receive confirmation of the manufacture of the products in a manner similar to ordering a custom made personal computer over the Internet. Additional detail for the "lights out" factory is found in International Application No.: PCT/US00/35268, International Filing Date: Dec. 27, 2000. SUMMARY OF THE INVENTION The present invention provides a system and method for creating products of varying characteristics on an automated production line. The system includes one or more production line devices, for example robots and machines. Each robot and machine is operated by a parametric computer program that may be stored locally with the production line devices. The system also comprises one or more data source(s) coupled to the production line devices. The data source provides characteristics of a desired product to the production line devices. The data source may be a local terminal or a remote terminal connected to the production line via the Internet, for example. In one embodiment, the system further comprises a computer coupled to the production line devices and to the data sources. The computer may route the inputted characteristics to each of the production line devices in a logical order. The computer also may convert

the characteristics into a formatted file readable by the parametric computer program, for example a machine data file (MDF). BRIEF DESCRIPTION OF THE DRAWINGS FIG. 1 is a block diagram of a robotically-automated electrical transformer tank manufacturing line, according to the present invention; FIG. 2 is a flowchart detailing the operation of the robotically-automated electrical transformer tank manufacturing line, according to the present invention; FIG. 3A is a table of a customer's individual desired features for an electrical transformer tank enclosure, according to the present invention; FIG. 3B is a drawing of a portion of an electrical transformer tank enclosure referred to in FIG. 3A, according to the present invention; FIG. 4A is a table indicating the machines and tools needed to perform a desired task, according to the present invention; FIG. 4B is an example of a MDF, according to the present invention; and FIGS. 5A and 5B are an exemplary MDF for use with the present invention for the manufacture of an electrical transformer tank. Reference will now be made in detail to a presently preferred embodiment of the invention, an example of which is illustrated in the accompanying drawings. DETAILED DESCRIPTION OF PREFERRED EMBODIMENTS By using parametric programming for an entire robotic production line, the present invention permits the robotic line to produce similar products of different characteristics without interruption in the line. For example, the present invention may allow a robotic manufacturing line to manufacture similar electrical transformer enclosures of varying sizes and various configurations. FIG. 1 is a block diagram of a robotically-automated electrical transformer tank manufacturing line 100, according to the present invention. As shown in FIG. 1, a data source 102 is coupled to a design database computer 104.

Data source 102 may be a data entry terminal, for example, local to manufacturing line 100. Alternatively, data source 102 may be a remote terminal coupled to design database computer 104 via the Internet. Although one data source is shown in FIG. 1, it should be appreciated that there may be more than one data source. Design database computer 104 is coupled to cell control computer 101. Design database computer 104 may be connected to cell control computer 101 and data source 102 using local access network (LAN) technology, for example an Ethernet system operating on TCP/IP protocol. Although FIG. 1 shows design database computer 104 separate from cell control computer 101, design database computer 104 may be a software component of cell control computer 101. Cell control computer 101 is coupled to terminal server 103, laser cutter 106, and master programmable logic controller (PLC) 105. Cell control computer 101 may be connected to master PLC 105 and terminal server 103 using LAN technology, for example an Ethernet system operating on TCP/IP protocol. Terminal server 103 is coupled to robot A 106, robot B 107, and robot C 111. Master PLC 105 is coupled to the devices in cell one 112, cell two 113, and cell three 114. Cell one 112 houses laser cutter 106 and robot A 107. Cell two houses embossing machine 108 and robot B 109. Cell three houses robot C 111 and stud welder 110. Although not shown, it should be appreciated that manufacture of the electrical transformer tank may include additional cells housing additional robots and machines. In this application the term "robot" refers a material moving device, and "machine" refers to a device that operates on and manipulates a workpiece. The terminology is consistent with that which is used in the art. FIG. 2 is a flowchart detailing a method of operating the robotically-automated electrical transformer tank manufacturing line 200, according to the present invention. In step 201, data source 102 provides the desired characteristics of a particular electrical transformer tank. The characteristics from data source 102 may be provided by a customer who is remote from the manufacturing line using an Internet connection, for example. Alternatively, the tank's characteristics may be entered by an operator who is queried at a data entry terminal local to the manufacturing line. The customer may specify the characteristics of the electrical transformer tank either by choosing a standard tank model number. Alternatively, the customer may specify a list of individual features by name or by part number with corresponding location designations. FIGS. 3A and 3B provide a table and corresponding drawing showing one

example of a customer's individual desired features. Each of the characteristics shown in FIG. 3B have a corresponding part number, name and location in the table in FIG. 3A. For example, a customer may require a switch hole, located at X1=19 and Y1=4.57 and a bend along the Y-axis at Y1=17.32 and Y2=51.51. The customer also may require two oil fill pads, located at X1=16.9 and Y1=6.82 and X2=6.82 and Y2=24.74. Each of these features has a corresponding part number. Referring back to FIG. 2, the characteristic data corresponding to the desired electrical transformer tank provided in step 201 then enters design database computer 104 in step 202. If the customer did not know the part number associated with each feature in step 201, step 202 will map the part number to a corresponding desired feature. Specifically, in step 202, design database computer 104 creates a MDF by mapping each desired characteristic (or the desired tank model number) to a database of part numbers and corresponding machine and tool numbers. The identified numbers represent the necessary machines and their tools needed to create the desired characteristics, as represented by part numbers. In other words, each part number has a corresponding list of machines and tools necessary to create the part. In addition, in step 202, if the data entry included individually desired features, design database computer 104 carries forward the specified locations of each of the desired characteristics as designated by data source 102. If the data entry simply specified a tank model number, these locations will be generated automatically. FIG. 4A provides a sample table indicating the machines and tools needed to perform a desired task. Each part number has a corresponding list of machines and tools necessary to create the desired part (i.e., feature). A tool is a subcomponent of a machine on the manufacturing line. As shown in FIG. 4A, machine M04 and tool T03 may be used to create part number 2A16023F01, which corresponds to the two oil fill holes specified by data source 102. Stated differently, part number 2A16124F01 may require the use of a plasma cutting head tool (e.g., T03) located in laser cutting machine 106 in order to create an oil fill hole. This process is repeated for each individual characteristic until a list of the necessary machines and tools is created as shown, for example, in FIG. 4A. Once the machines and their tools have been selected, a MDF may be created. FIG. 4B shows an example of a MDF, according to the present invention. As shown in FIG. 4B, the MDF lists the location (e.g., X-Y location) of the desired feature, and the machine and its tool necessary to create the feature. For example, in the first part of the table tool T03 of machine

M04 will create two holes. The first hole is located at x=16.90 and y=6.82. The second hole is located at x=16.90 and y=24.74. Then, tool T05 of machine M04 creates another hole at x=19 and y=4.57. Tool T243 of machine M05 then creates a bend along the y axis at x=0, y=17.32 and x=0, y=51.51. Notably, the order of each operation is logically arranged such that one machine may always operate on the electrical transformer tank enclosure before another machine. For example, it may be preferable for hole cutting machine M04 to operate on the electrical transformer tank enclosure before bending machine M05. An exemplary MDF for use with the present invention for the manufacture of an electrical transformer tank is included in FIGS. 5A and 5B. Referring back to FIG. 2, in step 203, cell control computer 101 parses the MDF into discrete file packets and transfers the packets to master PLC 105, terminal server 103 and laser cutter 106. Each file packet corresponds to a particular robot and machine. Unlike the other robots and machines, cell control computer 101 is coupled directly to laser cutter 106. This is due to the added complexity of laser cutter 106 and consequent volume of information that must be processed by laser cutter 106. In addition, because of the complexity of laser cutter 106, it may include a computer (not shown) that processes the MDF routed by cell control computer 106. The connection between laser cutter 104 and cell control computer 101 may be an RS-422 serial connection, for example. In step 204, cell control computer 101 sends the parsed MDF for robots A 107, B 109, and C 111 to terminal server 103. Terminal server 103 then sequences the parsed MDF for the operation of robot A 107, robot B 109, and robot C 111 in accordance with the manufacturing line's process. In step 205, cell control computer 101 sends the parsed MDF for machines 106, 108 and 110 to master PLC 105. Master PLC 105 then sequences the parsed MDF for each of machines 106, 108 and 110 in accordance with the manufacturing line's process. For example, as shown FIG. 4B, hole cutting machine M04 and tool T03 will be operated before bending machine M05 and tool T243. In step 206, robots A 107, B 109, and C 111 receive relevant MDF from terminal server 103 in a logical sequence. In step 207, machines 106, 108 and 110 receive the relevant MDF from master PLC 105 in a logical sequence. Each of the machines and the robots receive the MDF into their resident parametric programs. In step 208, a computer internal to robots 107, 109, and 111 converts the parametric program with the inputted MDF into a format readable by the individual robots, for example CNC programming instructions. In step 209,

a computer internal to machines 106, 108 and 110 convert the parametric program with the inputted MDF into a format readable by the individual machines, for example CNC programming instructions. The robots and the machines participate in the manufacturing, as commanded by the CNC programming instructions and to output the final product in step 210. Because the resident parametric program is a shell that integrates the entire functionality of the robots and machines, the parametric program is written for each production line device just once. The inputted MDF is the mechanism that instructs the production line devices to perform differently depending on the particular characteristics of the desired product. The present invention is directed to a system and method for automating a robotically-controlled production line, that includes, but is not limited to, the production of electrical transformer tank enclosures, regardless of any specific description in the drawing or examples set forth herein. It will be understood that the present invention is not limited to use of any of the particular parts or assemblies discussed herein. Indeed, this invention can be used in any assembly or manufacturing line that requires robotic automation. Further, the system disclosed in the present invention can be used with the method of the present invention or a variety of other applications. While the present invention has been particularly shown and described with reference to the presently preferred embodiments thereof, it will be understood by those skilled in the art that the invention is not limited to the embodiments specifically disclosed herein. Those skilled in the art will appreciate that various changes and adaptations of the present invention may be made in the form and details of these embodiments without departing from the true spirit and scope of the invention as defined by the following claims.

A custom macro for tool change format. (CNC Tech Talk). Source: Modern Machine Shop

Publication Date: 01-AUG-03 Much of CNC manual programming is redundant. Similar commands must be repeated on a fairly regular basis, especially when tool changes must be made. Because these commands are only similar (not identical), subprograms will not help when it comes to minimizing them. But if your control has custom macro B (or any version of parametric programming), you can simplify the commands required for tool changing. Even if you program with a computer aided manufacturing (CAM) system, you must consider how difficult it is for operators to run your programs. The techniques we show will simplify programming (especially for manual programmers), ensure consistency for tool changing commands, make your programs more fail-safe and make it easier for setup people and operators to rerun tools. First, consider a typical series of commands that are needed when you make a tool change on a vertical machining center. Of course, the specific commands for your particular machine(s) will vary. Similar commands will be required for turning centers (or any multi-tool CNC machine tool). N060 M09 (Turn off coolant) N065 G91 G28 Z0 M19 (return to tool change position, orient spindle) N070 T02 M06 (Place desired tool in spindle) N075 G90 G54 S500 M03 T03 (Select absolute mode, fixture offset, start spindle and select next tool) N080 G00 X1.5 Y2.0 (Rapid to first X and Y position) N085 G43 H02 Z0.1 (Instate tool length compensation, rapid to first Z position) N090 M08 (Start coolant) Note that the structure of these commands will remain the same for every tool change you make. Only the values of the numbers in bold italics will change from tool change to tool change. Again, these commands are redundant and tedious to write. It's easy for manual programmers to forget key words or commands. Consider this custom macro call statement that can be used to invoke a special tool change custom macro. N060 G65 P1000 T02 S500 X1.5 Y2.0 Z0.1 (Make tool change) When the custom macro (O1000) is executed, it will cause the machine to do everything done in the previous series of tool change commands. In our call statement, T represents the tool to be

placed in the spindle. Our macro will assume that the tool to be used after this one follows in sequence (tool three in this case). If it does not, a W word (for waiting station) can be included in this command to specify which tool is coming up next in the program. We've left W out, so we're letting the custom macro assume that the next tool will be station three. S specifies the spindle speed, and X, Y and Z specify the tool's first approach position. Here is the simple custom macro. O1000 (Tool change custom macro) IF [#23 NE #0] GOTO 1 (If W is included in call, skip default) #23 = #20 +1 (Set next waiting station tool to next number in sequence) N1 M09 (Turn off coolant) G91 G28 Z0 M19 (Return to tool change position, orient spindle) T#20 M06 (Place desired tool in spindle) G90 G54 S#19 M03 T#23 (Select absolute mode, fixture offset, start spindle and select next tool) G00 X#24 Y#25 (Rapid to first X and Y position) G43 H#20 Z#26 (Instate tool length compensation, rapid to first Z position) M08 (Start coolant) M99 (End of custom macro) We've taken the set of tool change commands and replaced those hard-and-fixed values that change from tool change to tool change with local variables (T is represented by #20, W by #23, S by #19, X by #24, Y by #25 and Z by #26). We have also set a default value for W (#23) if it's left out of the call statement. Look at the first two commands of the custom macro. If W is left out of the call statement (as it is in our example), the result of the IF statement will be false (W is vacant), and the next command (the default setting command) will be executed. #23 will be set to a value of whatever T (#20) is plus 1. If W is included in the call statement, #23 will have a value (#23 will not be vacant), the IF statement will be true and the default setting command will be skipped. Though our example custom macro doesn't show it, you could also include words and commands in the tool change format custom macro to make your programs more fail-safe. For example, you could include G80 and G40 in line N1 (when the coolant is turned off) to ensure that canned cycles and cutter radius compensation have been canceled. Most manual programmers will not do this, because they assume they've programmed correctly. Right after the tool change command (M06), you could include some safety commands to confirm that certain modes are still in their initialized states. Consider these commands.

G17 G20 G40 (Set XY plane, inch mode, cancel cutter radius compensation) G64 G69 G50.1 (Set normal cutting mode, cancel rotation, cancel mirror image) G80 G94 (Cancel canned cycle, select feed per minute mode) Again, these commands can be placed in the custom macro right after the tool change and will ensure that the machine is in appropriate states. This is most important for the first tool the first time the program is run. What about rerunning tools? One important task that CNC setup people and operators must perform on a regular basis is rerun tools. Our tool change format custom macro still allows rerunning tools. Actually, it will simplify the task. The restart block for rerunning tools is simply the call statement (G65 command) for each tool change. Everything required for restarting tools, including a movement to the appropriate tool change position, is included in the custom macro. Also, if your setup people and operators are currently restarting tools by scanning to the T word, they have to scan twice (assuming you have a machine with a double arm tool changer). The first time they scan, they find the command in which the tool is being placed in the waiting station. The second time, they find where it is actually being placed in the spindle. With the tool change custom macro, only one scan is required.

A more recent advancement in CNC interpreters is support of logical commands, known as parametric programming. Parametric programs incorporate both G-code and these logical constructs to create a programming language and syntax similar to BASIC. Various manufacturers refer to parametric programming in brand-specific ways. For instance, Haas Automation refers to parametric programs as macros. GE Fanuc refers to it as Custom Macro A & B, while Okuma refers to it as User Task 2. The programmer can make if/then/else statements, loops, subprogram calls, perform various arithmetic calculations, and manipulate variables to create a large degree of freedom within one program. An entire product line of different sizes can be programmed using logic and simple math to create and scale an entire range of parts, or create a stock part that can be scaled to any size a customer demands. Parametric programming also enables custom machining cycles, such as fixture creation and bolt circles. If a user wishes to create additional fixture locations on a work holding device, the machine can be manually guided to the new location and the fixture subroutine called. The machine will then drill and form the patterns required to mount additional vises or clamps at that location. Parametric programs are also used to shorten long programs with incremental or stepped passes. A loop can be created with variables for step values and other parameters, and in doing so remove a large amount of repetition in the program body. Because of these features, a parametric program is more efficient than using CAD/CAM software for large part runs. The brevity of the program allows the CNC programmer to rapidly make performance adjustments to looped commands, and tailor the program to the machine it is running on. Tool wear, breakage, and other system parameters can be accessed and changed

directly in the program, allowing extensions and modifications to the functionality of a machine beyond what a manufacturer envisioned. There are three types of variables used in CNC systems: local variable, common variable, and system variable. Local variable is used to hold data after machine off preset value. Common variable is used to hold data if machine switch off does not erase form data. The System variable this variable used system parameter this cannot use direct to convert the common variable for example tool radius, tool length, and tool height to be measured in millimeters or inches. Typical logic to a parameter program is as follows;
First define variables to start your program. -bolt circle radius -how many holes -center point of bolt circle Next build a subprogram that crunches the math. When you are ready to drill or tap your holes, run the drill cycle off of your math in subprogram. tool-change-point..... T101 (REVOLVER 1 CORRECTION 1 TOOL CALL) G97 S1000 M3 (SPINDLE SPEED, ROTATION DIRECTION) offset pickup,etc ..... G43 ..... in some cases (tool length pickup) #100=15 (RADIUS) #101=10 (HOW MANY HOLES) #102=50 (REJUMP-PARAMETER) #103=0 (CIRCLE-CENTER X) #104=-10 (CIRCLE-CENTER Y) G81 ..... (DRILL CYCLE) GOTO 100 (JUMP TO SUBPROGRAM) N50 (REUSE THE SUBprogramm) #100=7.5 (RADIUS ROUND 2) #101=7 #102=51 GOTO 100 (JUMP TO SUBPROGRAM) N51 G80 (DEACTIVATE MODAL G81) M30 (SUBprogram) N100 (THIS LINE HERE IS USES AS A MARKER) #105=0 (INIT) N101 X[COS[#105]*#100+#103] Y[SIN[#105]*#100+#104] (REMEMBER YOUR G81 CODE IS MODAL) #105=#105+[360/#101] IF [#105 LT 360] GOTO 101 (IF #105 < 360 -> NEXT ROUND) GOTO #102 This is just a model to show the logic of programming. As all languages have some differences, the logic is all similar

1. Cutting Gears with Loops

(Following is my generic-gear.ngc:) #1=25(number of teeth) #2=[360/#1](angle to turn chuck) #3=-.1(y clearance) #4=-.05(X start of cut) #5=2.2(X end of cut) #6=0(starting A position) #7=.7(feed rate infeed Y axis) #8=.394(depth of cut) #9=15(feed rate across X axis) G0 X#4 Y#3 G0 Z0 G0 A0 M3 S70 M8 o200 do G1 Y[#8-.04] F#7 G1 X#5 F#9 G1 Y#8 G1 X#4 F1.5 G0 Y#3 G0 X#4 #6=[#6+#2] G0 A#6 o200 while[#6 lt 359.9] M5 M9 M2

Notice that it does a rough cut across then climb mills back for a finish cut. Ed

2. Cutting Splines with Loops

(Following is my generic-spline.ngc:) M6 T0 G43 H0 #1=27(number of splines) #2=[360/#1](angle to turn chuck) #3=-.1(y clearance) #4=-.05(X start of spline) #5=5(X end of spline) #6=0(starting A position) #7=3(feed rate) #8=.088(depth of cut) G0 X#4 Y#3 G0 Z0 G0 A#6 M3 S200 M8 o200 do G1 Y#8 F#7 G1 X#5 G0 Y#3 G0 X#4 #6=[#6+#2] G0 A#6 o200 while[#6 lt 359.9] M5 M9 M2

similar to the gear but does all cutting in a single pass. Both are using a cutter on an arbor in a vertical spindle.

Ed

3. Thread Milling
(3/4-16 thread milling) G0 X0 Y0 (rapid to location) Z.1 G01 Z-1.020 F50.0 (your finish location will vary depending on conditions always start with a smaller cut until you establish exact finish location) G91 G01 X.1275 F3.0 (incremental move to finish location speeds and feeds will vary with materials being cut) G03 Z.0625 I-.1275 F4.0 (incremental 3 axis move creates right hand thread to establish Z movement divide 1 by thread pitch) ( 1 divided by 16 = .0625) G90 G01 X0 F20.0 (absolute move back to start location) G01 Z-1.020 (absolute move down to starting Z location) G91 G01 X.1275 F6.0 (incremental move to finish location) G03 Z.0625 I-.1275 F6.0 (incremental 3 axis move) G03 Z.0625 I-.1275 F10.0 (optional free pass to remove any burrs) G90 G01 X0 F20.0 (absolute move back to start location) G0 Z3.0 M2

4. Using a while loop to make circular indents in the side of a hand wheel
cat 110_mill_grips.ngc % (mill grips on other side, 3/8mill=9.5mm, 12 deep) (params) #1=-15 (drill depth) #2=10 (retraction interval) #100=-12 (depth) (fixed) (speed) F80 (reset) G0 Z5 G0 X0 Y0 G4 P5 (start round) #8=0 (angle in degrees) #9=30 (angle increment in degrees) O101 while [#8 lt 360] #5=32.30 (first step and start) #6=31.00 (second step) #7=35 (safe circle) (first step) G0 Z1 G0 X[#5 * cos] Y[#5 * sin] G1 Z[#100 + 0.06] G1 X[#7 * cos] Y[#7 * sin] (second step) G0 Z1 G0 X[#6 * cos] Y[#6 * sin]

G1 Z#100 G1 X[#7 * cos] Y[#7 * sin] (increment angle) #8=[#8 + #9] (wait) (M0) O101 endwhile (end) G0 Z5 G0 X1 Y-1 G1 X0 Y0 G0 Z20 %

5. Simple Turning example using IF

(simple turning) (#100 = max Z = start Z > #101) (#101 = min Z) (#200 = max X = start X > #201) (#201 = min X) (#300 = feed) (#400 = step size) (Z) #100 = 200 #101 = 0 (X) #200 = 17 #201 = 14 (FEED) #300 = 120 (STEP) #400 = 1 (END OF PARAMETERS) (set feed) F#300 (set current X) #250 = #200 O501 while [#250 gt #201] #250 = [#250 - #400] O502 if [#250 lt #201] #250 = O502 endif (goto start point, safety x 1mm) G0 X[#250 + #400 + 1] G0 Z#100 G0 X#250 G1 F#300 Z#101 O501 endwhile (retract to orig X) (END) G0 X[#200 + 1] M2

1. Introduction
The O word was devised by Ken Lerman as a way to implement several branching routines into the EMC interpreter. By using the O word a g code programmer can build subroutines, loops, and conditionals while taking advantage of the interpreter's use of variables and computation.

The canonical documentation for O-words is in the emc2 documentation: [1]. As clarifications and documentation improvements made on this page are incorporated in the official documentation, they should be removed from this page.

2. Notes
Each of these control blocks begins with an Onnnnn word. That makes easier for the parser to know what it is doing and isn't a problem for the user. I have to admit, though, that writing "call sub Onnnnn" seems more natural than writing "Onnnnn call sub". Note that each block must start and end with the same Onnnnn word. So if you start with o100 the block ends at the next o100 Subroutine declarations may NOT be nested. Subroutines may be called anywhere (but must be declared before they are called. They may be called from other subroutines, and may be called recursively if it makes sense. while and if may be nested. They may not overlap without nesting. When the interpreter scans a sub block, it remembers the location of the next line in the file and associates it with the "O" number. It continues scanning, skipping lines until it sees the matching Onnnnn endsub. When the interpreter scans a callsub, it pushes (saves) the current location in the input file (on a stack). It then goes to the location in the file associated with the Onnnnn and starts interpretation there. When the interpreter scans a return, it pops the stack and continues interpretation where it left off. When it interprets an endsub, it treats it like a return. When the interpreter scans a while, it remembers the location of the Onnnnn. If the expression is true (values close to zero are treated as zero), it continues execution. If the expression was not true, it skips execution of all of the blocks until it finds the matching Onnnnn. When the interpreter scans an endwhile, it restarts interpretation at the location of the remembered Onnnnn. (Assumng it wasn't skipping. If it was skipping, it ignores the endwhile). if is treated exactly as while. The matching endif is ignored if the interpreter was skipping. Interpretation is turned back on (skipping is ended).

3. Sample Programs
These sample programs are offered without any warranty as to their suitability for any task whatsoever! Use these or model your program after these at your own risk. 3.1. Sample 1 -- One side of a ball in cage

Here is a short program that uses a ball end mill to create part of a sphere. The comments in the code explain what each variable does. There is no error checking so you could create sphere that doesn't exist. Here is emc2+axis running this program. [emc2axis] I am sure the program could be simplified also not 100% sure the math is right. Here is 4 sides done - [cube]
#1=1.25 (size of box) #2=.0625 (cutter radius) #3=.125 (size of box bars) #4=5 (degrees of resolusion) #5=#4 (COUNTER) #6=[[#1/2]+#2] (ACTUAL RADIUS OF CIRCLE - CUTTER RADIUS + RADIUS) G01X0Y0F10 o140 do #8 = [[SIN[#5]*#6]*SIN[45]] ( X AND Y POSISION) #9 = [0-[[1-COS[#5]]*#6]] (Z HIGHT) G1X[#8]Y[#8]F3 Z[#9] G18 G02 X[0-#8]Z[#9]I[0-#8]K[0-[#9+[#6]]]F5 G19 G03 Y[0-#8]Z[#9]J[0-#8]K[0-[#9+[#6]]] G18 G03 X[#8]Z[#9]I[#8]K[0-[#9+[#6]]] G19 G02 Y[#8]Z[#9]J[#8]K[0-[#9+[#6]]] #5=[#5+#4] o140 while [#8 LT [#1/2-#2-#3]] G1Z1 X0Y0 M30

3.2. Sample 2 -- Subroutine Sample (ellipse)

Code originally by jepler, converted to gcode by KennethLerman (lerman), fixed by jepler. This code will machine an approximation to a ellipse.
(#1=xc #2=yc #3=xr #4=yr #5=subdiv #5=depth #7=rapid ht) o1000 sub (#10 = theta) (#11 = i) (#12 = x) (#13 = y) #14 = 360 #11 = 1 g0 x[#1+#3] y#2 g0 z#6 o1001 while [#11 LE #5] #10 = [#14 * #11 / #5] #12 = [#1 + [#3 * cos[#10]]] #13 = [#2 + [#4 * sin[#10]]] g1 x#12 y#13 #11 = [#11 + 1] o1001 endwhile g0 z#7

o1000 endsub (call it like this) f10 o1000 call [0] [0] [1] [2] [200] [-1] [2] m2

3.3. Sample 3 -- loops/math example (spirograph) I did this on a whim just to see if it could be done with the current math and loop abilities of emc2. Here is example output of the below program. [spiro]. I creates pretty big files - again not sure if everything is correct. Use at your own risk :).
#1=3.1 ( R in this formula {R+r}*cos{t} - {r+O}*cos{{{R+r}/r}*t} ) #2=2 ( r in above) #3=.6 ( O in above) #4=0 (starting t Deg) #5=.2 (deg of resolution) (check which of the R/r is bigger) o100 if [abs[#1] GT abs[#2]] #6=#1 (6 and 7 are temp locations for the R and r ) #7=#2 #8=1 o100 else #6=#2 #7=#1 #8=2 o100 endif (now we make them whole numbers if they are not.) (this is the start of figuring the number of degrees) (it has to go to do a complete cycle.) #9=#6 #10=#7 #11=2 o150 while [[fix[#6] NE #6] or [fix[#7] NE #7]] #6=[#9*#11] #7=[#10*#11] #11=[#11+1] o150 endwhile (now lets figure out if we can simplify the R/r fraction) (this is using Euclidean algorithm to get the gcd) #12=#6 #13=#7 o200 do #14=[#12 mod #13] #12=#13 #13=#14 o200 while [#13 NE 0] (#12 is now the gcd) (the Number of times around in degrees) (using the correct denominator.) o225 if[#8 eq 1]

#14=[[#7/#12]*360] o225 else #14=[[#6/#12]*360] o225 endif (here is the actual cutting - I don't have any z in it yet) o250 do #15=[[#1+#2]*COS[#4] - [#2+#3]*COS[[[#1+#2]/#2]*#4]] #16=[[#1+#2]*sin[#4] - [#2+#3]*sin[[[#1+#2]/#2]*#4]] g1 x[#15]y[#16]f200 #4=[#4+#5] o250 while [#4 LE #14] m30

3.4. Sample 4, a subroutine for helical hole milling using radius comp
o100 sub (helical hole milling, load tool and set feed first, then use like so:) (o100 call [x pos] [y pos] [safety height] [hole depth] [hole dia] [tool dia]) (tool dia doesn't have to be specified exactly.) #7=[#6/2] (#7 is depth per circle = half of tool diameter) #8=#7 (#8 is current depth step) g0 z#3 (start above and right so we make a convex corner for entry to the ccw arcs) g0 x[#1 + [#7 * 2]] y[#2 + [#5 / 2]] g41 g0 x#1 y[#2 + [#5 / 2]] o101 while [#8 LT #4] (down toward the specified depth a bit at a time) g3 x#1 y[#2 + [#5 / 2]] i0 j[0 - [#5 / 2]] z[0 - #8] #8=[#8 + #7] o101 endwhile (down to the actual depth) g3 x#1 y[#2 + [#5 / 2]] i0 j[0 - [#5 / 2]] z[0 - #4] (full circle at the actual depth) g3 x#1 y[#2 + [#5 / 2]] i0 j[0 - [#5 / 2]] (nice quarter-circle helical exit move) g3 x[#1 - [#5 / 2]] y#2 i0 j[0 - [#5 / 2]] z#3 g40 o100 endsub (here is the actual usage: T1 is a 1/16th end mill) g20 g64 g17 g90 t1 m6 s1000 m3 f5 o100 call [0] [0] [.01] [.125] [.125] [.0625] o100 call [.25] [0] [.01] [.125] [.5] [.0625] t0 m6 m2