NOTE: This control feature is optional; call your HFO for information on how to purchase it.

Macros add capabilities and flexibility to the control that are not possible with standard G-code. Some possible uses are: families of parts, custom canned cycles, complex motions, and driving optional devices. The possibilities are almost endless.

A Macro is any routine/subprogram that you can run multiple times. A macro statement can assign a value to a variable, read a value from a variable, evaluate an expression, conditionally or unconditionally branch to another point within a program, or conditionally repeat some section of a program.

M00, M01, M30 - Stop Program
G04 - Dwell
G65 Pxx - Macro subprogram call. Allows passing of variables.
M29 - Set output relay with M-FIN.
M129 - Set output relay with M-FIN.
M59 - Set output relay.
M69 - Clear output relay.
M96 Pxx Qxx - Conditional Local Branch when Discrete Input Signal is 0
M97 Pxx - Local Sub Routine Call
M98 Pxx - Sub Program Call
M99 - Sub Program Return or Loop
G103 - Block Lookahead Limit. No cutter comp allowed.
M109 - Interactive User Input

The control stores decimal numbers as binary values. As a result, numbers stored in variables can be off by 1 least significant digit. For example, the number 7 stored in macro variable #10000, may later be read as 7.000001, 7.000000, or 6.999999. If your statement was

IF [#10000 EQ 7]… ;

it may give a false reading. A safer way of programming this would be

IF [ROUND [#10000] EQ 7]… ;

This issue is usually a problem only when you store integers in macro variables where you do not expect to see a fractional part later.

Look-ahead is a very important concept in macro programming. The control attempts to process as many lines as possible ahead of time in order to speed up processing. This includes the interpretation of macro variables. For example,

#12012 = 1 ;
G04 P1. ;
#12012 = 0 ;

This is intended to turn an output on, wait 1 second, and then turn it off. However, lookahead causes the output to turn on then immediately back off while the control processes the dwell. G103 P1 is used to limit lookahead to 1 block. To make this example work properly, modify it as follows:

G103 P1 (See the G-code section of the manual for a further explanation of G103) ;
;
#12012=1 ;
G04 P1. ;
;
;
;
#12012=0 ;

The Haas control uses block look-ahead to read and prepare for blocks of code that come after the current block of code. This lets the control transition smoothly from one motion to the next. G103 limits how far ahead the control looks at blocks of code. The Pnnaddress code in G103 specifies how far ahead the control is allowed to look. For additional information, refer to G103 Limit Block Look-Ahead (Group 00)

Block Delete mode lets you selectively skip blocks of code. Use a / character at the beginning of the program blocks that you want to skip. Press BLOCK DELETE to enter the Block Delete mode. While Block Delete mode is active, the control does not execute the blocks marked with a / character. For example:

Using a

/M99 (Sub-Program Return) ;

before a block with

M30 (Program End and Rewind) ;

makes the sub-program a main program when BLOCK DELETE is on. The program is used as a sub-program when Block Delete is off.

When a block delete token "/" is used, even if Block Delete mode is not active, the line will block look ahead. This is useful for debugging macro processing within NC programs.

You save or load macro variables through the Net Share or USB port, much like settings, and offsets.

The local and global macro variables #1 - #33 and #10000 - #10999 are displayed and modified through the Current Commands display.

NOTE: Internal to the machine, 10000 is added to 3-digit macro variables. For example: Macro 100 is displayed as 10100.

To search for a variable, enter the macro variable number and press the up or down arrow.

The variables displayed represent values of the variables when the program runs. At times, this may be up to 15 blocks ahead of actual machine actions. Debugging programs is easier when a G103 P1 is inserted at the beginning of a program to limit block buffering. A G103 without the P value can be added after the macro variable blocks in the program. For a macro program to operate correctly it is recommended that the G103 P1 be left in the program during loading of variables. For more details about G103 see the G-code section of the manual.

In the Timers And Counters window, you can display the values of any two macro variables and assign them a display name.

To set which two macro variables display in the Timers And Counters window:

The arguments in a G65 statement are a means to send values to a macro subprogram and set the local variables of a macro subprogram.

The next (2) tables indicate the mapping of the alphabetic address variables to the numeric variables used in a macro subprogram.

TABLE 1: Alphabetic Address Table

TABLE 2: Alternate Alphabetic Addressing

Arguments accept any floating-point value to four decimal places. If the control is in metric, it will assume thousandths (.000). In example below, local variable #1 will receive .0001. If a decimal is not included in an argument value, such as:

G65 P9910 A1 B2 C3 ;

The values are passed to macro subprograms according to this table:

All 33 local macro variables can be assigned values with arguments by using the alternate addressing method. The following example shows how to send two sets of coordinate locations to a macro subprogram. Local variables #4 through #9 would be set to .0001 through .0006 respectively.

Example:

G65 P2000 I1 J2 K3 I4 J5 K6; 

The following letters cannot be used to pass parameters to a macro subprogram: G, L, N, O or P.

There are (3) categories of macro variables: local, global, and system.

Macro constants are floating-point values placed in a macro expression. They can be combined with addresses A-Z, or they can stand alone when used within an expression. Examples of constants are 0.0001, 5.3 or -10.

Local variables range between #1 and #33. A set of local variables is available at all times. When a call to a subprogram with a G65 command is executed, local variables are saved and a new set is available for use. This is called nesting of local variables. During a G65 call, all new local variables are cleared to undefined values and any local variables that have corresponding address variables in the G65 line are set to G65 line values. Below is a table of the local variables along with the address variable arguments that change them:

Variables 10, 12, 14- 16 and 27- 33 do not have corresponding address arguments. They can be set if a sufficient number of I, J and K arguments are used as indicated above in the section about arguments. Once in the macro subprogram, local variables can be read and modified by referencing variable numbers 1- 33.

When the L argument is used to do multiple repetitions of a macro subprogram, the arguments are set only on the first repetition. This means that if local variables 1- 33 are modified in the first repetition, then the next repetition will have access only to the modified values. Local values are retained from repetition to repetition when the L address is greater than 1.

Calling a subprogram via an M97 or M98 does not nest the local variables. Any local variables referenced in a subprogram called by an M98 are the same variables and values that existed prior to the M97 or M98 call.

Global variables are accessible at all times and remain in memory when power is turned off. There is only one copy of each global variable. Global variables are numbered #10000-#10999. Three legacy ranges: (#100-#199, #500-#699, and #800-#999) are included. The legacy 3 digit macro variables begin at the #10000 range; ie., macro variable #100 is displayed as #10100. 

NOTE: Using variable #100 or #10100 in a program the control will access the same data. Using either variable number is acceptable.

Sometimes, factory-installed options use global variables, for example, probing and pallet changers, etc. Refer to the Macro Variables Table for global variables and their use.

CAUTION: When you use a global variable, make sure that no other programs on the machine use the same global variable.

System variables let you interact with a variety of control conditions. System variable values can change the function of the control. When a program reads a system variable, it can modify its behavior based on the value in the variable. Some system variables have a Read Only status; this means that you cannot modify them. Refer to the Macro Variables Table for a list of system variables and their use.

The macro variables table of local, global, and system variables and their usage follows. The new generation control variables list includes legacy variables.

System variables are associated with specific functions. A detailed description of these functions follows.

#550-#699 #10550- #10699 General and Probe Calibration Data

These general purpose variables are saved on power off. Some of these higher #5xx variables store probe calibration data. Example: #592 sets which side of the table the tool probe is positioned. If these variables are overwritten, you will need to calibrate the probe again.

note: If the machine does not have a probe installed, you can use these variables as general-purpose variables saved on power off.

#1080-#1097 #11000-#11255 #13000-#13063 1-Bit Discrete Inputs

You can connect designated inputs from external devices with these macros:

Specific input values can be read from within a program. The format is #11nnn where nnn is the Input Number. Press DIAGNOSTIC and select the I/O tab to see the Input and Output numbers for different devices.

Example:

#10000=#11018

This example records the state of #11018, which refers to Input 18 (M-Fin_Input), to variable #10000.

For available User Inputs on the I/O PCB, refer to the Robot Integration Aid reference document in the Haas service website.

#12000-#12255 1-Bit Discrete Outputs

The Haas control is capable of controlling up to 256 discrete outputs. However, a number of these outputs are reserved for the Haas control to use.

Specific output values can be read, or written to, from within a program. The format is #12nnn where nnn is the Output Number.

Example:

#10000=#12018 ;

This example records the state of #12018, which refers to Input 18 (Coolant Pump Motor), to variable #10000.

Maximum Axis Loads

These variables contain the maximum load an axis has achieved since the machine was last powered on, or since that Macro Variable was cleared. The Maximum Axis Load is the greatest load (100.0 = 100%) an axis has seen, not the Axis Load at the time that the control reads the variable.

Tool Offsets

Each tool offset has a length (H) and diameter (D) along with associated wear values.

#3000 Programmable Alarm Messages

#3000 Alarms can be programmed. A programmable alarm will act like the built-in alarms. An alarm is generated by setting macro variable #3000 to a number between 1 and 999.

#3000= 15 (MESSAGE PLACED INTO ALARM LIST) ;

When this is done, Alarm flashes at the bottom of the display and the text in the next comment is placed into the alarm list.
The alarm number (in this example, 15) is added to 1000 and used as an alarm number. If an alarm is generated in this manner all motion stops and the program must be reset to continue. Programmable alarms are always numbered between 1000 and 1999.

#3001-#3002 Timers

Two timers can be set to a value by assigning a number to the respective variable. A program can then read the variable and determine the time passed since the timer was set. Timers can be used to imitate dwell cycles, determine part-to-part time or wherever time-dependent behavior is desired.

• #3001 Millisecond Timer - The millisecond timer represents the system time after power on in number of milliseconds. The whole number returned after accessing #3001 represents the number of milliseconds.
• #3002 Hour Timer - The hour timer is similar to the millisecond timer except that the number returned after accessing#3002 is in hours. The hour and millisecond timers are independent of each other and can be set separately.

System Overrides

Variable #3003 overrides the Single Block function in G-code.

When #3003 has a value of 1, the control executes each G-code command continuously even though the Single Block function is ON.

When #3003 has a value of zero, Single Block operates as normal. You must press CYCLE START to execute each line of code in single block mode.

...
#3003=1 ;
G54 G00 G90 X0 Y0 ;
S2000 M03 ;
G43 H01 Z.1 ;
G81 R.1 Z-0.1 F20. ;
#3003=0 ;
T02 M06 ;
G43 H02 Z.1 ;
S1800 M03 ;
G83 R.1 Z-1. Q.25 F10. ;
X0. Y0. ;
%

Variable #3004

Variable #3004 overrides specific control features during operation.

The first bit disables FEED HOLD. If variable #3004 is set to 1, FEED HOLD is disabled for the program blocks that follow. Set #3004 to 0 to enable FEED HOLD again. For example:

..
(Approach code - FEED HOLD allowed) ;
#3004=1 (Disables FEED HOLD) ;
(Non-stoppable code - FEED HOLD not allowed) ;
#3004=0 (Enables FEED HOLD) ;
(Depart code - FEED HOLD allowed) ;
...

Variable #3004 resets to 0 at M30.
This is a map of variable #3004 bits and the associated overrides.

E = Enabled D = Disabled

#3006 Programmable Stop

You can add stops to the program that act like an M00 - The control stops and waits until you press CYCLE START, then the program continues with the block after the #3006. In this example, the control displays the comment on the lower-center of the screen.

#3006=1 (comment here) ;

#3030 Single Block

In Next Generation Control when the system variable #3030 is set to a 1; the control will go into single block mode. There is no need to limit the lookahead using a G103 P1, the Next Generation Control will correctly process this code. 

NOTE: For the Classic Haas Control to process system variable #3030=1 correctly, it is necessary to limit the lookahead to 1 block using a G103 P1 before the #3030=1 code.

#4001-#4021 Last Block (Modal) Group Codes

G-code groups let the machine control process the codes more efficiently. G-codes with similar functions are usually in the same group. For example, G90 and G91 are under group 3. Macro variables #4001 through #4021 store the last or default G code for any of 21 groups.

G-Codes Group number is listed next to it's description in the G-Code section.

Example:

G81 Drill Canned Cycle (Group 09)

When a macro program reads the group code, the program can change the behavior of the G-code. If #4003 contains 91, then a macro program could determine that all moves should be incremental rather than absolute. There is no associated variable for group zero; group zero G codes are Non-modal.

#4101-#4126 Last Block (Modal) Address Data

Address codes A-Z (excluding G) are maintained as modal values. The information represented by the last line of code interpreted by the lookahead process is contained in variables #4101 through #4126.

The numeric mapping of variable numbers to alphabetic addresses corresponds to the mapping under alphabetic addresses. For example, the value of the previously interpreted D address is found in #4107 and the last interpreted I value is #4104. When aliasing a macro to an M-code, you may not pass variables to the macro using variables #1 - #33. Instead, use the values from #4101 - #4126 in the macro.

#5001-#5006 Last Target Position

The final programmed point for the last motion block can be accessed through variables #5001 - #5006, X, Z, Y, A, B, and C respectively. Values are given in the current work coordinate system and can be used while the machine is in motion.

#5021-#5026 Current Machine Coordinate Position

To get the current machine axis positions, call macro variables #5021-#5026 corresponding to axis X, Y, Z, A, B, and C, respectively.

NOTE: Values CANNOT be read while the machine is in motion.

#5041-#5046 Current Work Coordinate Position

To get the current work coordinate positions, call macro variables #5041-#5046 corresponding to axis X, Y, Z, A, B, and C, respectively.

NOTE: The values CANNOT be read while the machine is in motion.  The value of #504X has tool length compensation applied to it.

#5061-#5069 Current Skip Signal Position

Macro variables #5061-#5069 corresponding to X, Y, Z, A, B, C, U, V and W respectively, give the axis positions where the last skip signal occurred. Values are given in the current work coordinate system and can be used while the machine is in motion.

The value of #5063 (Z) has tool length compensation applied to it.

#5081-#5086 Tool Length Compensation

Macro variables #5081 - #5086 give the current total tool length compensation in axis X, Y, Z, A, B, or C, respectively. This includes tool length offset referenced by the current value set in H (#4008) plus the wear value.

#5201-#5326, #7001-#7386, #14001-#14386 Work Offsets

Macro expressions can read and set all work offsets. This lets you preset coordinates to exact locations, or set coordinates to values based upon the results of skip signal (probed) locations and calculations.

When any of the offsets are read, the interpretation look-ahead queue is stopped until that block is executed.

#6001-#6250 Settings Access with Macro Variables

Access settings through variables #20000 - #20999 or #6001 - #6250, starting from setting 1 respectively. Refer to Chapter 18 for the detailed descriptions of the settings that are available in the control.

NOTE: The #20000 - 20999 range numbers correspond directly to Setting numbers. You should use #6001 - #6250 for settings access only if you need your program to be compatible with older Haas machines

#6198 Next-Generation Control Identifier

The macro variable #6198 has a read-only value of 1000000.

You can test #6198 in a program to detect the control version, and then conditionally run program code for that control version. For example:

%
IF[#6198 EQ 1000000] GOTO5 ;
(Non-NGC code) ;
GOTO6 ;
N5 (NGC code) ;
N6 M30 ;
%

In this program, if the value stored in #6198 is equal to 1000000, go to Next Generation Control compatible code then end the program. If if the value stored in #6198 is not equal to 1000000, run the non-NGC program and then end the program.

#6996-#6999 Parameter Access With Macro Variables

These macro variables can access all parameters and any of the parameter bits, as follows:

• #6996: Parameter Number
• #6997: Bit Number (optional)
• #6998: Contains the value of the parameter number specified in variable #6996
• #6999: Contains the bit value (0 or 1) of the parameter bit specified in variable #6997.

NOTE: Variables #6998 and #6999 are read-only.

You can also use macro variables #30000 - #39999, starting from parameter 1, respectively. Contact your HFO for more details regarding parameter numbers.

USAGE: 

To access the value of a parameter, copy the number of that parameter into variable #6996. The value of that parameter is available in macro variable #6998, as shown:

%
#6996=601 (Specify parameter 601) ;
#10000=#6998 (Copy the value of parameter 601 to variable #10000) ;
%

To access a specific parameter bit, copy the parameter number into variable 6996 and the bit number to macro variable 6997. The value of that parameter bit is available in macro variable 6999, as shown:

%
#6996=57 (Specify parameter 57) ;
#6997=0 (Specify bit zero) ;
#10000=#6999 (Copy parameter 57 bit 0 to variable #10000) ;
%

Pallet Changer Variables

The status of the pallets from the Automatic Pallet Changer is checked with these variables:

#8500-#8515 Advanced Tool Management

These variables give information on Advanced Tool Management (ATM). Set variable #8500 to the tool group number, then access information for the selected tool group with the read-only macros #8501-#8515.

#8550-#8567 Advanced Tool Management Tooling

These variables give information on tooling. Set variable #8550 to the tool offset number, then access information for the selected tool with the read-only macros #8551-#8567

NOTE: Macro variables #1601-#2800 give access to the same data for individual tools as #8550-#8567 give for Tool Group tools.

#50001 - #50200 Tool Type

Use macro variables #50001 - #50200, to read or write the tool type set in the tool offset page.

Available Tool Types for Mill

G65 is the command that calls a subprogram with the ability to pass arguments to it. The format follows:

G65 Pnnnnn [Lnnnn] [arguments] ;

Arguments italicized in square brackets are optional. See the Programming section for more details on macro arguments.

The G65 command requires a P address corresponding to a program number currently located in the control’s drive or path to a program. When the L address is used the macro call is repeated the specified number of times.

When a subprogram is called, the control looks for the subprogram on the active drive or the path to the program. If the subprogram cannot be located on the active drive, the control looks in the drive designated by Setting 251. Refer to the Setting Up Search Locations section for more information on subprogram searching. An alarm occurs if the control does not find the subprogram.

In Example 1, subprogram 1000 is called once without conditions passed to the subprogram. G65 calls are similar to, but not the same as, M98 calls. G65 calls can be nested up to 9 times, which means, program 1 can call program 2, program 2 can call program 3 and program 3 can call program 4.

Example 1:

G65 P1000 (Call subprogram O01000 as a macro) ;
M30 (Program stop) ;
O01000 (Macro Subprogram) ;

...

M99 (Return from Macro Subprogram) ;

In Example 2, the program LightHousing.nc is called using the path that it is in.

Example 2:

G65 P15 A1. B1.;
G65 (/Memory/LightHousing.nc) A1. B1.;

NOTE: Paths are case sensitive.

In Example 3, subprogram 9010 is designed to drill a sequence of holes along a line whose slope is determined by the X and Y arguments that are passed to it in the G65 command line. The Z drill depth is passed as Z, the feed rate is passed as F, and the number of holes to be drilled is passed as T. The line of holes is drilled starting from the current tool position when the macro subprogram is called.

Example 3:

NOTE: The subprogram program O09010 should reside on the active drive or on a drive designated by Setting 252.

G00 G90 X1.0 Y1.0 Z.05 S1000 M03 (Position tool) ;
G65 P9010 X.5 Y.25 Z.05 F10. T10 (Call O09010) ;
M30 ;

O09010 (Diagonal hole pattern) ;
F#9 (F=Feedrate) ;
WHILE [#20 GT 0] DO1 (Repeat T times) ;
G91 G81 Z#26 (Drill To Z depth) ;
#20=#20-1 (Decrement counter) ;
IF [#20 EQ 0] GOTO5 (All holes drilled) ;

G00 X#24 Y#25 (Move along slope) ;
N5 END1 ;
M99 (Return to caller) ;

Aliased codes are user defined G and M-codes that reference a macro program. There are 10 G alias codes and 10 M alias codes available to users. Program numbers 9010 through 9019 are reserved for G-code aliasing and 9000 through 9009 are reserved for M-code aliasing.

Aliasing is a means of assigning a G-code or M-code to a G65 P##### sequence. For instance, in the previous Example 2, it would be easier to write:

G06 X.5 Y.25 Z.05 F10. T10 ;

When aliasing, variables can be passed with a G-code; variables cannot be passed with an M-code.

Here, an unused G-code has been substituted, G06 for G65 P9010. In order for the previous block to work, the value associated with subprogram 9010 must be set to 06. Refer to the Setting Aliases section for how to setup aliases.

NOTE: G00, G65, G66, and G67 cannot be aliased. All other codes between 1 and 255 can be used for aliasing.

If a macro call subprogram is set to a G-code and the subprogram is not in memory, then an alarm is given. Refer to the G65 Macro Subprogram Call section on page 5 on how to locate the subprogram. An alarm occurs if the sub-program is not found.

If a macro call subprogram is set to a G-code and the subprogram is not in memory, then an alarm is given. Refer to the Macro Subprogram Call section on how to locate the subprogram. An alarm occurs if the sub-program is not found.