Issuu on Google+

50408g

PostHASTE Postprocessor

Formatting Reference Manual Have you seen Appendix E? IF NOT, YOU SHOULD! Please see page 119 now. What is this manual and who is it for? This is the second of two manuals written for PostHASTE – it contains detailed information regarding the PostHASTE formatting templates. This manual was written for people who are already familiar with the basic concepts covered in the manual entitled Getting Started with PostHASTE. If you haven't already, please read (or review) that manual. What is PostHASTE? PostHASTE (sometimes referred to as “the post” for short) is a software system that translates your CAM system's tool motion output (CL files) into 'NC program' text (or 'ASCII') files to drive NC or CNC machines. PostHaste can create programs in any of these formats: •

EIA (sometimes referred to as 'ISO') standard: EIA programs are the most common type of machine control files; they typically use G, X, Y, Z, T and/or M codes (among others) for various machine movements and functions.

'Conversational': Conversational programs are usually somewhat similar to EIA programs, but typically have words or phrases (such as 'LINE' or 'ARC') in place of some or all of the standard letter codes.

Tab-sequential (or “columnar”): These types of programs are not very common anymore, but are sometimes needed for older (e.g. 'Bandit less expensive (such as Emco-Maier) machines. These programs have the various numerical values arranged in columns (instead of using a letter); the location (or spacing) of the numbers within each line determines the significance of the value. For example the first column may be an X position, the second column the Y position, and so on.

Limitations of PostHASTE Some machines do not use the above conventions and therefore PostHaste may not be suitable for use in generating NC programs for them; among them are some Brother and older Mazak ('Mazatrol' language) machines and several others. If you have any doubt as to whether or not PostHaste is suitable for your machine, then call us; we will be able to help you determine its suitability. If it is not, then you may either purchase a postprocessor that has been customized to the specific machine, or get as close to it as possible by configuring PostHaste, then editing the NC code (using a text editor) to suit your machine exactly.


Table Of Contents What is this manual and who is it for? ........................................................................................i What is PostHASTE? ..................................................................................................................i Limitations of PostHASTE..........................................................................................................i 1.

POSTHASTE BASICS ...................................................................................................... 1 1.1

How PostHaste works.............................................................................................................. 1

1.2

Template file extension naming conventions .......................................................................... 1

2.

FORMAT TEMPLATES - THE BASICS............................................................................ 2 2.1

Overall structure of the template file...................................................................................... 2 First - the NAME line ................................................................................................................ 2 The address (letter) formats ....................................................................................................... 2 Commands and 'Switches'.......................................................................................................... 3 Basic rules regarding commands ............................................................................................................... 3

The “Sequences” ....................................................................................................................... 3 2.1.1 3.

Comments in the format ...................................................................................................... 4

THE LETTER FORMATS.................................................................................................. 5 C__ (the COLUMN number - used only for columnar programs - see examples later)......................... 6 S_ (the “Spaces” number - used only for columnar programs - see examples later) ............................... 6 + (the plus sign) .......................................................................................................................................... 6 - (the minus sign) ........................................................................................................................................ 6 > (the “up to...” sign) .................................................................................................................................. 6 A numeral (in the above example the number: 3) ..................................................................................... 6 . (a decimal point) ....................................................................................................................................... 7 > (the “up to...” sign [again]) ..................................................................................................................... 7 A number (in the above example the number: 4) ...................................................................................... 7 x - the OUTPUT character. ........................................................................................................................ 7 The OUTPUT character for COLUMNAR style programs:..................................................................... 7

3.1

Advanced letter formatting ..................................................................................................... 8

3.1.1

Suppression of a letter (“numbers only” output) .................................................................. 8

3.1.2

Letter format modifiers ....................................................................................................... 8 Add __......................................................................................................................................................... 8 DivBy _ and

DivInto _ ......................................................................................................................... 9

Force............................................................................................................................................................ 9


Inc 10 IncFrom _.................................................................................................................................................. 10 Limit __ __................................................................................................................................................ 10 Clamp __ __.............................................................................................................................................. 10 Mod __ ...................................................................................................................................................... 11 Modal ........................................................................................................................................................ 11 Mult __...................................................................................................................................................... 11 No-Opt ...................................................................................................................................................... 12 Sub __ ....................................................................................................................................................... 12

3.1.3

How Letter Format Modifiers are used together................................................................. 12

Hierarchy of Modifiers: ........................................................................................................... 13 Notes re “LIMIT checking”: .................................................................................................... 14 Regarding IncFrom:................................................................................................................. 14 4.

COMMANDS AND 'SWITCHES' .................................................................................... 15 What's a Switch?...................................................................................................................... 15 4.1

List of Commands and Switches (the ones that are not used inside sequences) ................ 15 Note: See section 5.3 for commands that are used only inside of sequences. ............................ 15 We have listed all of the commands and switches in this section in alphabetical order, except for... .. 15

4.1.1

Ask ................................................................................................................................... 16 How to make the Ask repeat..................................................................................................................... 17

4.1.2

AskPeckClear? .................................................................................................................. 17

4.1.3

ByDiameter? (lathe only) .................................................................................................. 17

4.1.4

Comment .......................................................................................................................... 18

4.1.5

Convert ............................................................................................................................. 18

4.1.6

Coolant ............................................................................................................................. 19

Examples:................................................................................................................................ 19 4.1.6.1

Using [Cool] in an IF statement ............................................................................. 19

4.1.7

DComp ............................................................................................................................. 19

4.1.8

Drive................................................................................................................................. 20

4.1.9

Each .................................................................................................................................. 20

4.1.10

EOB ('End Of Block' characters).................................................................................... 20

4.1.11

EOF ('End Of File' characters)........................................................................................ 21

4.1.12

Feed and Rapid .............................................................................................................. 21

4.1.13

FeedType ....................................................................................................................... 21

4.1.14

First#?............................................................................................................................ 21

4.1.15

HCode, VCode, DCode and FeedCode........................................................................... 21


4.1.16

HCode2, VCode2, and DCode2 ..................................................................................... 22

4.1.17

Inc/Abs .......................................................................................................................... 22

4.1.18

Inch/MM........................................................................................................................ 22

4.1.19

Incremental? .................................................................................................................. 22

4.1.20

Ignore ............................................................................................................................ 23

4.1.21

Leading0s?..................................................................................................................... 23

4.1.22

LocalOutput? ................................................................................................................. 23

Important! Make sure your [Work] numbers match! ................................................................ 24 4.1.23

ModalGs ........................................................................................................................ 24

4.1.24

ModalLetters.................................................................................................................. 24

4.1.25

Notes: / EndOfNotes (or EndNotes) ............................................................................... 25

4.1.26

Rename.......................................................................................................................... 26

4.1.27

ReturnPlane or RetPlane ................................................................................................ 26

4.1.28

RevSigns........................................................................................................................ 27

4.1.29

RoundToQuad?.............................................................................................................. 27 Automatic 'round center to startpoint' feature.......................................................................................... 27

4.1.30

RevTurret2?................................................................................................................... 28

4.1.31

Sequence#s .................................................................................................................... 28

4.1.32

Spaces? .......................................................................................................................... 29

4.1.33

SpeedType (lathe only) .................................................................................................. 29

4.1.34

Spindle........................................................................................................................... 29

4.1.35

SpliceSubs?.................................................................................................................... 29

4.1.36

Thread ........................................................................................................................... 29

4.1.37

TLAxisEnabled? ............................................................................................................ 30

4.1.38

Tolerance ....................................................................................................................... 30

4.1.39

Tools.............................................................................................................................. 30

4.1.40

UpperCaseComments?................................................................................................... 31

4.1.41

Verbose?........................................................................................................................ 31

4.1.42

Work.............................................................................................................................. 31

4.1.43

WorkDefault .................................................................................................................. 32

4.1.44

ZRestart? ....................................................................................................................... 32

4.2

Arc processing commands and switches ............................................................................... 33

4.2.1

ArcPlane ........................................................................................................................... 33 Using the [ArcPlane] variable in an ArcCode sequence ......................................................................... 34

4.2.2

Cw and Ccw...................................................................................................................... 35

4.2.3

CtrCode............................................................................................................................. 35


4.2.4

CtrCode>180 and CtrCode360 .......................................................................................... 35

4.2.5

CtrIncremental?................................................................................................................. 36

4.2.6

ByQuadrants?.................................................................................................................... 36

4.2.7

Helical?............................................................................................................................. 36

4.2.7.1

Helical arcs - Handling special cases...................................................................... 36

So, what value is output with the K? ....................................................................................................... 37 What if you want some other K value?.................................................................................................... 37

4.2.8

MaxRad ............................................................................................................................ 38

4.2.9

MinRad ............................................................................................................................. 38

4.2.10 4.3

MinArc .......................................................................................................................... 38

Special commands for Columnar style formats.................................................................... 39

4.3.1

Spaces ............................................................................................................................... 39

4.3.2

Dummy ............................................................................................................................. 39

5.

THE “SEQUENCES”...................................................................................................... 40 5.1

Using Variables:..................................................................................................................... 40 For a complete list of variable names and descriptions, see Appendix A. ................................. 41

5.2

The Sequence Descriptions.................................................................................................... 42

5.2.1

The standard sequences ..................................................................................................... 42

5.2.1.1

StartCode............................................................................................................... 42

5.2.1.2

1stToolChange....................................................................................................... 43

5.2.1.3

ToolChange ........................................................................................................... 44

5.2.1.4

Infeed .................................................................................................................... 44

5.2.1.5

OutFeed................................................................................................................. 44

5.2.1.6

EndCode................................................................................................................ 45

5.2.2

Canned Cycles .................................................................................................................. 46

5.2.2.1

Two ways to output canned cycles: 'canned' and 'longhand'.................................... 46

You may “mix and match” your drilling cycle methods......................................................................... 46

5.2.2.2

Cancel ................................................................................................................... 47

“End cancel” vs. “End” ............................................................................................................................ 47 The 'Cancel' sequence............................................................................................................................... 47

5.2.2.3

Peck drilling (The Peck and ChipBreak cycles)...................................................... 47

…but what if my machine does not have a Peck or ChipBreak cycle?.................................................. 48

5.2.2.4

Advanced canned cycle control.............................................................................. 48

5.2.3

Controlling 'modality' - the “Force?” option ...................................................................... 49

5.2.4

Additional sequences for special purposes......................................................................... 50


5.2.4.1 Sequences for custom and multi-line movements LineCode, RapidCode and ArcCode (CwCode, CCWCode) ................................................................................................................ 50 Important notes regarding ArcCode (and CwCode and CcwCode):....................................................... 51 LineCode and RapidCode sequences....................................................................................................... 51

5.2.4.2

AutoThread (used for lathe only) ........................................................................... 51

[TParams] variable .................................................................................................................. 52 "Individual" thread parameter variables available................................................................................... 52

5.2.4.3

Index (used for machines with rotary axes) ............................................................ 53

... for machines with ONE rotary axis ...................................................................................... 53 Which letter should I use on my INDEX line? / Do I need the minus sign?...................................... 53 INDEX definition when rotary axis on CAD model does not match machine orientation.................... 54

... for machines with TWO (or more) rotary axes ..................................................................... 54 5.2.4.4

Stop ....................................................................................................................... 54

Handling ‘Optional Stop’ (OPSTOP) CL records................................................................................... 55

5.2.4.5

Upon, UponRec & Cycle sequences....................................................................... 55

Upon ....................................................................................................................................... 55 The Every, PreScan and Unique modifiers.............................................................................................. 56 The Relate option for 'Upon ... Unique' sequences: ................................................................................ 57

UponRec and Cycle ................................................................................................................. 58 Using variables with UponRec or Cycle to handle the incoming values.................................... 60 Cycle (using variables) ............................................................................................................ 60 More UponRec and Cycle examples......................................................................................... 61 5.2.5 5.3

CallMe and Call (User-defined sequences and 'reusing' sequences) .................................. 61

Commands that can be used inside of sequences.................................................................. 62

5.3.1

Call ................................................................................................................................... 62

5.3.2

Comments......................................................................................................................... 63

5.3.3

If, Else and EndIf .............................................................................................................. 63

5.3.4

File.................................................................................................................................... 64 What the File commands can do for you ................................................................................................. 64 How to use the File commands ................................................................................................................ 64 * Important notes re the Alias and Empty commands... .......................................................................... 66

5.3.4.1 5.3.5

NoEol and EOL................................................................................................................. 68

5.3.5.1 5.3.6

'File' usage example: Creating a 'tool list' at the top of the program. ....................... 67 EOL....................................................................................................................... 68

Set..................................................................................................................................... 69

5.3.6.1

Limitations of SET commands............................................................................... 70


6.

WORK FIXTURE OFFSETS (G54, ETC.): HOW THEY [WORK] ................................. 71 The 3 issues (in the format template) that control Work offsets................................................ 71 Work offsets "in a nutshell" ..................................................................................................... 71 But, what if you DON'T want work offsets in your NC programs?........................................... 72 Handling 'non-standard' work offsets (G54.1 P_ , G15 H_ ... etc.)............................................ 72 Details, details, details... .......................................................................................................... 72 The Work line ........................................................................................................................................... 73 The WorkDefault line ............................................................................................................................... 73 The [Work] variable (used in the sequences) .......................................................................................... 73 Changing [Work] offsets between drilling cycles................................................................................... 74 Getting rid of redundant G54 (et al) codes .............................................................................................. 75

7.

SPECIAL FEATURES .................................................................................................... 76 7.1

Using Equations (mathematical operations)......................................................................... 77

7.1.1

Mathematical symbols and functions................................................................................. 77

Hierarchy of operations & use of parentheses .......................................................................... 78 7.2

Suppressing line numbers and outputting blank lines ......................................................... 78 Suppressing line numbers ........................................................................................................ 78 Outputting blank lines.............................................................................................................. 79

7.3

'Text output' and text {variables} ......................................................................................... 79

7.3.1

Direct ('hard-coded') text output ........................................................................................ 79

7.3.2

Regarding use of 'quotes' (and outputting quotes in your code) .......................................... 80

7.3.3

Using {text variables} ....................................................................................................... 80

7.3.4

Important information regarding text and text variables:.................................................... 81

7.4

“Search and Replace�............................................................................................................ 81 Avoid 'double-replacements'!................................................................................................... 82 The NoComment option ........................................................................................................... 82 The ALL option........................................................................................................................ 83

7.5

If / Else Logic ......................................................................................................................... 84 Logical operators ('Equals', 'Greater than', etc.)........................................................................ 85 Testing 2 conditions: Using AND and OR with IF.................................................................... 85

7.6

Outputting subs (subprograms), and the automatic 'multiple part' program feature ....... 85

7.6.1

Basic Fanuc setup example................................................................................................ 86

7.6.2

Automatic multiple part programs ..................................................................................... 86

7.6.2.1

Sub numbering ...................................................................................................... 87


7.6.3

Sequences, variables and switches used for subs................................................................ 88

7.6.3.1

SubCall sequence................................................................................................... 88

7.6.3.2

SubStart, SubEnd, and Between sequences ............................................................ 88

7.6.3.3

[Sub], [SubLine] and [Times] (sub variables)......................................................... 89

7.6.3.4

Switches used to control subs ................................................................................ 89

SpliceSubs? switch ................................................................................................................................... 89

7.7

The PostHaste.log file (for “debugging”) .............................................................................. 90 Inhibiting the log file for faster processing............................................................................... 91

8.

“SPECIAL CASE” TACTICS & NOTES ......................................................................... 93 8.1

Concerning incremental / absolute output and the [IncMode] variable.............................. 93

8.2

How to format “P1=” type codes........................................................................................... 94

8.3

'Block deletes' on multi-part sub calls .................................................................................. 95

9.

APPENDIX A - LIST OF VARIABLES .......................................................................... 96 Categories of variables ............................................................................................................ 96 The variables... ........................................................................................................................ 97 9.1.1.1

Variables that apply to movements in general ........................................................ 98

9.1.1.2

Variables that can be used to format arc movements ............................................ 101

9.1.1.3

Variables related to “point-to-point” Drilling cycles ............................................ 102

9.1.1.4

Variables set from the Tool or Tool Change information ..................................... 104

9.1.1.5

Variables used for subroutines or subprograms .................................................... 107

9.1.1.6

Text Variables ..................................................................................................... 107

9.1.1.7

Prompted Variables ............................................................................................. 108

9.1.1.8

Variables used for Wire EDM posts..................................................................... 109

9.1.1.9

General Purpose (Misc.) variables ....................................................................... 110

10.

APPENDIX B - LIST OF “RETIRED” FUNCTIONS.................................................... 112

11.

APPENDIX C - APT-CL RECORDS RECOGNIZED.................................................... 113 CL records IGNORED by PostHaste: .................................................................................... 113 CL records recognized by PostHaste:..................................................................................... 114

12.

APPENDIX D - HANDLING ROTARY AXES............................................................. 116 Definitions: ............................................................................................................................................. 116

12.1

[RotAngle] vs. [AAxis], [BAxis] and [CAxis] ............................................................... 116


12.2

Where do the actual rotary angle values come from?.................................................. 116

12.2.1

MULTAX data............................................................................................................. 116

12.2.2

Coordinate system (CS or CSYS) data ......................................................................... 117

12.2.3

TLAXIS record data..................................................................................................... 117 TLAxisEnabled? switch.......................................................................................................................... 118

12.2.4

ROTATE, ROTHED or ROTABL records................................................................... 118

The VertCSame? switch......................................................................................................... 118 13.

APPENDIX E - WHAT'S NEW WITH POSTHASTE AND THIS MANUAL? ............ 119


1. PostHASTE Basics PostHASTE is basically a translator that reads CL (“Cutter Location�) tool path data and outputs it according to a formatting template that you can easily modify. PostHASTE operates quite simply - it usually only prompts you for two things... - the CL file to open and - (optionally) which machine format file you want to use. ...PostHASTE will then generate the NC program and save it according to the information you enter in response to the prompts. This manual discusses how to modify the format templates to suit your needs.

1.1 How PostHaste works PostHaste gets all of the configuration information for each machine from a format template file. (In the context of this manual, we will refer to it as either simply the format or the template.) All you have to do to change a machine program format is to modify the contents of the corresponding template file. This can be done easily with any word processor or text editor. The primary purpose of this manual is to explain how to modify the template(s) to achieve the desired output for 3 and 4 axis milling and 2 axis lathes. (Other instruction manuals are available for Mill-Turn machines [that is, lathes with live tooling] and 5 axis milling machines.)

1.2 Template file extension naming conventions We recommend using the file name extensions (the three characters that typically follow the period in a file name) in the chart below to differentiate between format files for various types of machines. The numbers in the extensions indicates the number of supported axes. Extension(s) .pM2 to .pM5 .pT2 to .pT4 .pU2 to .pU5 .pL2 to .pL5 .pF2... .pP2... .pE2 .pW2...

Machine type(s) Milling (2 axis to 5 axis machines) Turning (Lathes) - 2 to 4 axis mUltifunction (Mill-Turn) machines - 2 to 5 axis. Laser... Flame or plasma Punch presses wire EDM Water jet


2. Format templates - the basics This section will familiarize you with the overall structure of the format file. We highly recommend that while reading the following information, that you also load a format template file into the editor of your choice so you can follow along on your screen.

2.1 Overall structure of the template file Now, all of the formatting information that PostHASTE requires is placed in the format template file in these 4 basic areas: 1. The NAME line 2. The address (letter) formats 3. Commands and switches 4. The “Sequences� The following four sections briefly describe what these do Please take a look at a template file (on your screen) while you read the following; doing this will greatly help you get a good idea of how the template file works. First - the NAME line When you edit a template file, you will notice that the word NAME is the first thing in the format. The NAME line starts the description of each machine format. Without a NAME line, you don't have a format. Sorry - that's just the way it is. After the required NAME line, the remainder of the template can be broken into 3 sections (as described in brief below). These 3 sections look basically the same from one machine format to the next, so the easiest way to create a new NC code format is to copy an existing machine format template, then alter it to fit your needs. The address (letter) formats This lists the letters that can be used in your format - in the order that they will appear in the lines of machine program code - and the exact formatting of the numerical values that accompany each letter. Here's an excerpt from the letter format section of a Fanuc template: O N G X Y

>4 >4 >2 ->3.>4 ->3.>4

O can be up to 4 digits, no decimal. G can be up to 2 digits, no decimal. X can have minus sign, up to 3 before, up to 4 after decimal.

When you're ready to learn all about letter formatting, see section 3.


Commands and 'Switches' After the letter formats, there is typically a page or two full of commands such as... ModalGs 0 1 2 3 73 74 76 80 81 82 83 84 85 Sequence#s N 0 1 1 Char, Freq, Increment, Start HCode X VCode Y FeedCode F Spaces? Y

Spaces between words?

...Commands like the above tell the post basic information that is used commonly in many areas of the final machine program. (You may see section 4.1 to learn more about all of the available commands and switches.) Basic rules regarding commands

PostHaste expects to find the commands and switches written in a particular way; therefore any modifications that you make to the file must be done in STRICT ADHERENCE to the rules outlined here. As you have already seen (on the NAME line); this is the kind of structure that PostHASTE expects to find in the format: - a command word (such as “name”), then - a SINGLE SPACE (to separate the word from the following instructions), then - the parameters (letters, numbers or other specific words) pertaining to that particular command. If there is more than one parameter, then the parameters are always separated by a single space. Note: As you will see below, you must always be careful to not use more than one space between parameters. If you do, then you will turn the remainder of the line into a 'comment' that PostHaste will ignore. The “Sequences” The sequences describe where all of the words (letters and numbers) appear in the final program. They look similar to an NC program, as these sequences show: StartCode O[Program#] G90 End 1stToolChange N[Block] T[Tool] M6 G0 G40 G80 G[Work] X[H] Y[V] G43 Z[D] H[Lcomp] M[Direct] S[Speed] M[Cool] End Drill G81 X[H] Y[V] Z[D] R[RLevel] F[FRate] end cancel Cancel

F. in, R. out.


G80 end ... EndCode G28 G49 Z0 S100 G28 G91 X0 Y0 T[Tool1] M6 G90 M30 End

There are sequences to describe every portion of a finished machine program. You can get more information on sequences in section 5. Please note that again, all of the words in the sequences must be separated by a single space.

2.1.1

Comments in the format

NOTE: PostHaste will IGNORE ANYTHING ON THE LINE THAT HAS 2 OR MORE ADJACENT SPACES BEFORE IT - this allows you to put comments in the file in either of these 2 easy ways: 1. Simply move the cursor a few spaces past the end of a command line, then type your comment. 2. Type any comment on its own line - just make sure that the line has some leading spaces. We HIGHLY recommend that you make liberal use of comments! They take only a few seconds to write, but could save you many minutes (or hours!) of frustration later when you need to make changes to your format! CAUTION: BE CAREFUL NOT TO ACCIDENTALLY “COMMENT OUT� part of the actual formatting information by mistakenly entering 2 spaces in place of 1!


3. The Letter Formats This is a series of lines that each start with a specific character (usually a letter) followed by some numbers and signs. This is a list of all of the characters that your NC machine needs (and in the order that they will appear on any line of NC code). Add, change and/or delete letters and/or instructions so that they are arranged in the order that they appear in a line of NC code and are formatted according to the following information (if you look at the templates you will see something like these). Helpful hint: When reading the letter formats, the arrow (>) means “up to”. / 00 % N X F

00 >4 ->3.>4 >32

G 2 R +->24

“00” (“No digits before the decimal, no decimal, then no digits after”) is the format for any character that you wish to appear by itself (that is, with no numbers) - which makes it perfect for describing the percent sign (%) or “block delete” (/) characters, as it does in these examples. N address: (NO - sign allowed,) up to 4 characters (no decimal). X address: - sign allowed, up to 3 places before the decimal, a decimal, then up to 4 digits after. F address: (NO - sign allowed,) up to 3 places before the decimal, (NO decimal,) then 2 digits after. The post will add trailing zeros; thus a F value of -2.0 will be output as F200 G address: always 2 digits; a G value of 0 will be output as G00 R address: + sign is mandatory (unless the value is negative, in which case the '-' will appear), up to 2 places before the (invisible) decimal, then 4 after (adds trailing 0s such that an R value of 1.5 becomes R+15000).

You can see that the formatting options above gives you a lot of flexibility and are relatively selfexplanatory. (Note: The examples above do not show any of the “advanced character formatting” that can be done - as detailed in section 3.1.) NOTE: You can also format lower case letters. PostHaste will accept characters with ASCII values between 33 (!) and 122 (z). (The exclamation point [!] is a special case - read about it below in the section entitled “Suppressing line numbers and outputting blank lines” - section 7.1.)


The “maximum” possible letter format is something like this:

? C__ S_ +->_.>_ x ...where the “?” is the character (usually a letter) to be formatted, the “blanks" (_) can be any numeral, and the “x” is an optional character (or a set of empty quotes, like “”. Empty quotes here suppresses the output of the letter altogether. See section 3.1 [Advanced letter formatting] for more on this.) Here's what each of the characters in the formatting lines do: C__ (the COLUMN number - used only for columnar programs see examples later)

The number following the C notes the Column number at which this word starts. Note that there is a space after the number to separate this information from the next part of the line. (Note: There are special commands [Spaces and Dummy] that are needed for columnar style programs - read about them in section 4.3: Commands and Switches.) S_ (the “Spaces” number - used only for columnar programs - see examples later)

The numeral after the S determines how many spaces this word will take in the NC block. (Note: There are special commands [Spaces and Dummy] that are needed for columnar style programs - read about them in section 4.3: Commands and Switches.) + (the plus sign)

This causes PostHaste to output a + sign on the number if it is not negative. It must be the first formatting character in this line of your file if used at all. - (the minus sign)

As would be expected, this causes PostHaste to output a - (“minus”) sign on the number if it IS negative. It must be the next formatting character if a - sign is ever to be used for this character address. > (the “up to...” sign)

This (actually the “greater than” sign) is supposed to be an arrow that means that the number of digits before the decimal point can be “up to N places” (where the N is the next number on the format line [explained below]) and causes NO LEADING ZEROS TO BE OUTPUT in this address. IF THIS ARROW IS LEFT OUT, THEN THE POST WILL ADD LEADING 0s so that the number of digits before the decimal will always be the following number... A numeral (in the above example the number: 3)

If the above “up to” arrow is used then this is the MAXIMUM number of digits that may appear before the decimal point. If the above “up to” arrow is NOT used then this is the number of digits that will ALWAYS appear before the decimal point.


. (a decimal point)

The presence of the decimal point in the line here will indicate that this address requires a decimal point. Conversely; if this character is absent, then it will not be output in the NC code. You can also use COMMAS (,) instead of decimal points - this is common for use with European machine tools. > (the “up to...” sign [again])

Just like above; this arrow means that the number of digits AFTER the decimal point can be “up to N places” (where the N is the next number on the format line [explained below]) and causes NO TRAILING ZEROS TO BE OUTPUT in this address. IF THIS ARROW IS LEFT OUT, THEN THE POST WILL ADD TRAILING 0s so that the number of digits after the decimal will always be the following number... A number (in the above example the number: 4)

This is always a single digit that indicates the number of digits available AFTER the decimal point: If the above “up to” arrow is used then this is the MAXIMUM number of digits that may appear after the decimal point. If the above “up to” arrow is NOT used then this is the number of digits that will ALWAYS appear after the decimal point. x - the OUTPUT character.

If for any reason you wish to have a letter placed in the NC program INSTEAD of the one that is actually described by the formats, you may place this letter here. This comes in handy when for instance, the same letter must be formatted differently when it is used in different places. Case in point is the Bridgeport milling control: any negative Z value with a minus (like “Z-1.5”) is usually BELOW the Z0 point, but in the case of drilling cycles, no minus sign is required for the Z! Here are the lines that you can put in your format to accommodate this condition: Put these 2 lines in the “letter formats” section: Z ->3.>4 A >3.>4 Z

A canned cycle description should look like this: G81 X[H] Y[V] A[D] F[FRate] |

In this case a normally unused letter (A) is called in the drilling cycles, but the format line of the letter A ends with “ Z” so that a Z will actually come out in the NC code. It will also appear WITHOUT a minus sign (because of the absence of the “-“ in the “A” format line). In other words, the post formats for A, but outputs a Z. This is only one example of how this can be used; the possibilities are endless! The OUTPUT character for COLUMNAR style programs:

This output character designation works slightly differently when you are formatting a COLUMNAR style program (remember as mentioned above; the SPACES line designates a format as columnar); IF NO OUTPUT CHARACTER IS SPECIFIED, THEN A SPACE WILL BE OUTPUT IN PLACE OF THE LETTER INSTEAD OF THE LETTER ISTELF. (That's why in the examples above the T is repeated at the end of the T format line, and also why the note for the K address says that no letter will appear in the NC program; because there is no K repeated at the end of the format line.)


Note: There are special commands [Spaces and Dummy] that are needed for columnar style programs read about them in section 4.3: Commands and Switches.

3.1 Advanced letter formatting In addition to the “basic” formatting options described above, there are some other things you can add to the end of a letter format line to achieve many other operations. Here is a list of them:

3.1.1

Suppression of a letter (“numbers only” output)

You can suppress the output of a letter by putting a set of empty quotes after the letter format (where you would usually place the “output character”). For example, this line could be used to put “Line numbers” in the program without the “N” preceding them: N >4 ''

This would cause the resulting program to look like this: 1 O12 2 G0 G28 X0 Y0 Z0 3 T1 M6

3.1.2

instead of this: N1 O12 N2 G0 G28 X0 Y0 Z0 N3 T1 M6

Letter format modifiers

Letter formats can also have specific modifiers assigned to them for the purpose of Limit checking, conversion factors (MODulo, SUBtraction, MULTiplication and/or ADDition by any value[s]), Modal and Force attributes (read below) and 2 different types of “Incremental” designation: INC and IncFrom. These modifiers can simply be appended to the end of any “Letter format” line (as shown in the various examples in the discussion below). Note: - You can ADD or MULT by a LETTER, not just a number. We had originally planned to let you ADD or MULT a variable, but this way is much better because the letter you add or mult can be assigned to different variables at different times (and in turn, even IT can be made incremental, and have any other letter added, multed... etc), so it is infinitely more flexible. This is a quick list of how they work (the “_” in the headings below represents a number or letter that the modifier requires): Add __

Follow ADD with any number or variable that you want to add to the initial word value. The example below adds .1 to all Z values: Z ->3.>4 Add .1

As you might suspect, negative numbers can be used to effectively “subtract” a number from a particular word - in this case we're now subtracting .1 from the Z values: Z ->3.>4 Add -.1

You can use the Add option to add variables as well as numbers to your program values. This is handy for using on some milling machines that require that the RLevel value be added to the Z value for drilling. Just assign a substitute letter to be used to output the drilling Z and add the RLevel variable like this: C >3.>4 Z Add [RLevel]


Although you can easily add variables to your values, you can't subtract them in this way because the post won't recognize “-[RLevel]�. To handle this problem, we've given you the Sub modifier below... DivBy _

and

DivInto _

These are modifiers that allow you to use division in 2 different ways: - DivBy _ ...divides the letter's value by some other number or variable before outputting. If you want to divide the letter's value BY some number or variable, then use DivBy. The following example will divide all X values by 2: X ->3.>4 DivBy 2

...Resulting in the code "X12." being output as "X6.0" - DivInto _ ...divides the number or variable following DivInto into the letter's value before outputting it. As an example, to output the pitch on a tapping cycle you would format the letter to return the RECIPROCAL of the [Step] value by dividing the value INTO 1 (e.g. "1/pitch") like this... Q ->3.>4 DivInto 1

...then simply use Q[Step] in the TAP sequence. This would result in "Q20." being output for a 1/4-20 tap, for instance. ___ Like all letter math modifiers, DivInto and DivBy... - can be followed by numerical constants, other variables or other letters. - should NOT be used on N (line) numbers. (You can get around this to SOME extent by adding the line "each N[Block]" to your format...) If the use of either of these modifiers results in an attempted "division by zero", then... - the user will be warned - the letter value will be left 'unmodified' (the division will not take place), and - the post will continue.

Force

Always forces the appearance of the word (or just the letter if used in conjunction with MODAL.) Example: This is used commonly in Heidenhain conversational formats, where a particular letter (such as 'R') must appear (by itself) on every line, but a number only appears when the value has changed. R ->3.>4 Modal Force


Inc

The value of this word will be output as an increment from its last absolute value. (Last abs. value is subtracted.) Example: X ->3.>4 Inc IncFrom _

Specifies another letter: The LAST absolute value of THAT letter will be subtracted from the value of this word. Example: Some controls require that the Z value for drilling be measured incrementally from the R value. In those cases, use this format: z ->3.>4 Z IncFrom R

(NOTE: In this case, make sure that the R is processed BEFORE the z, otherwise the Z output will be incremental from the LAST value of R instead of the current value.) Limit __ __

Follow this with 2 numbers: the minimum and maximum limits. A warning message will appear if the tool motion file causes the letter to be outside the specified range. When the warning message appears, the user will have the option to continue or abort. (If the user chooses to continue, the 'bad' number WILL appear in the output.) Note: A single letter may not be formatted using Limit and Clamp. You may only use one of these on each letter format. Clamp __ __

Similar to Limit above, follow this with 2 numbers to indicate the minimum and maximum allowable values of the letter being formatted. Unlike the Limit action, the post will not output a warning, but it will 'clamp' the output value so that numbers larger than the 'upper clamp' value will be output AS the 'upper clamp' value. Likewise; values smaller than the lower clamp value will be output AS the lower value. Examples: The number would normally be output this way,

but the letter is formatted like this,

...so it actually appears in the code like this:

F9523.4

F >4.>3 Clamp 1 8000

F8000.0

S22

S >4 Clamp 50 9000

S50

Why? Because it is over the upper limit (8000), it is output as F8000. It is below the lower limit (50) so it is output as S50.

This is especially helpful when formatting the feed rate letter (especially if used for 'inverse time feed rate', where very short movements can produce very large F values). Note: A single letter may not be formatted using Limit and Clamp. You may only use one of these on each letter.


Mod __

This is the mathematical modulo function which returns the 'remainder' of a division operation. This is used commonly for machines that have a rotary axis with a 'numerical limit' of 360, but can be used for other things as well. Here are simple examples that show how the Mod function affects the output of various values: 0 mod 360 = 0 1 mod 360 = 1 320 mod 360 = 320 360 mod 360 = 0 361 mod 360 = 1 410.03 mod 360 = 50.03 720 mod 360 = 0 725 mod 360 = 5 -45 mod 360 = -45 -360 mod 360 = 0 -363.41 mod 360 = -3.41 ...etc. (Please note that the Mod function also works the same regardless of whether the incoming value is a positive and negative numbers.) Here is an example of how to use the Mod modifier in your template: To format the letter A properly for a 4 axis mill to get this output (when the rotary table keeps turning the same direction as it approaches, then continues past the '360 degree' boundary)... ... X.1 X.2 X.3 X.4 X.5 ...

A-356.0 A-358.0 A0.0 A-2.0 A-4.0

... use the 'modulo' function on the letter A like this: A ->3.>3 Mod 360

Modal

Causes a word to be suppressed (not output at all) unless its value has actually changed since the last time the letter was output. (Note: This has exactly the same effect as listing the letter in the ModalLetters command line. See section 4.1.24 for information on the ModalLetters command.) Mult __

Just like the Add modifier, follow MULT with any number or variable that you would like to multiply by the initial word value. This example “doubles� the X value by multiplying by 2: X ->3.>4 Mult 2

For example, the sign of a number can be reversed by multiplying it by -1 like the letter X shown here: X ->3.>4 Mult -1


Also, the mult modifier can be used to “divide” a number by using the reciprocal of that number. For instance, a number can be “divided by 2” by simply “multiplying by 1/2” like this: X ->3.>4 Mult .5 No-Opt

Code "zero optimization" can be overridden with the No-Opt modifier. By default, when the post outputs a "0" value along with "floating point" words (such as "X ->3.>4"), it suppresses the decimal point so that the output appears as "X0" instead of "X0." . This can save a significant amount of code in a long program. If, however, you want to prevent this optimization from taking place, you can add the "No-Opt" modifier onto any letter in the letter format section like this: X ->3.>4 No-Opt

This will cause a zero value to be output as "X0.". (Remember, upper or lower case doesn't matter on the modifiers.) Sub __

As you would expect, follow Sub with any number or variable that you want to SUBTRACT from the initial word value. The example below subtracts 1.5 from all X values: X ->3.>4 Sub 1.5

Even though you could do the same thing by Adding “-1.5”, you can't use the Add to subtract variables that's why we've given you the Sub option. Here's how we could subtract the RLevel variable from the Z value (if we wanted to): Z ->3.>4 Sub [RLevel]

(Remember to use [brackets] when specifying variables.) One of the nicest by-products of this modifier is the ability to make any letter's value "incremental" from any other variable. For example, if we wanted the letter W to be output incremental from the current X (horizontal position) value, we could format it in this way : W ->3.>4 Sub [H]

3.1.3

How Letter Format Modifiers are used together

Sometimes, you must use more than one modifier to get the results you want. As an example... Giving the MODAL modifier will prevent PostHaste from repeating the same values on later lines if the value of that letter has not changed. Some conversational machines require the letter to be output by itself (without the numerical value) if the value has not changed, such as the “R F M” required on all moves by the Heidenhain conversational format. In these cases, add the FORCE parameter AND the MODAL parameter (the order does not matter) like this: X R F M

>3,>4 >2 Modal Force >31 Modal Force >2 Modal Force


Notice that no “Modal” modifier need be given to X. This is because the post assumes that certain codes (including the HCode, VCode, DCode, and FeedCode - usually X, Y, Z, and F) are modal. If you want any of them NOT to be modal, then add a “ModalLetters” line (somewhere after the letter formats) to change the default “modality” of these (and any other) letters. Read more about the ModalLetters command below. Any letter(s) can be designated as incremental simply by using the INC modifier. For example, the following letter formats tell the post to output only the Z axis movements as incremental, while outputting absolute X and Y values: N G X Y Z I

>4 >2 ->3.>4 ->3.>4 ->3.>4 Inc ->3.>4

... The sample formatting lines below could be used for a Bridgeport milling post set up to output in Metric mode from American (SAE) dimensioned geometry. For metric, we simply multiply the X,Y, and Z values by 25.4 (the “inch-to-metric” conversion factor). Furthermore, the 2 lines below allow 2 different “Z” formats: one that allows negative numbers (for contour milling), and another used for drilling. Z values used in drilling (“canned”) cycles on a Bridgeport machine can have no minus sign, and are measured incrementally down from the RLevel point. So, we have a normal Z format line for contour milling, and we also format another letter (in this case “A”) to output a non-signed incremental Z value with 2.54 mm ADDed to compensate for a .1” RLevel level. (If a different vertical clearance value is used when designing the tool motion, then you must change this value to match. For example, if you used .05” for the “rapid down” clearance, then use 1.27mm as the “additive” in the post.) The “Limit” values used in these examples are arbitrary - your machine may be quite different. Z ->3.>4 Limit -150 125 Mult 25.4 A >3.>4 Z Limit 0 150 Mult 25.4 IncFrom Z | |

Notice: any “output letter” used MUST follow the numeric formatting BEFORE Mult, Add, Limit and/or Inc.

Use “IncFrom” to indicate letters measured incrementally from another letter.

After the “output letter”, the order of the rest of the modifiers (Mult, Add, Modal, Force, Limit, IncFrom and Inc) makes no difference. For example, formatting the “secondary Z” using the line below would result in exactly the same NC program, even though the modifiers are in a completely different order: A >3.>4 Z IncFrom Z Mult 25.4 Limit 0 150 |

Notice: again, the “output letter” (Z) is BEFORE the modifiers. Hierarchy of Modifiers: There is a hierarchy to the order in which the numerical functions (Mult, DivBy, DivInto, Add, Sub, Mod, Inc, IncFrom and IncSign) and Limit checks are performed (regardless of the order they are placed in the format): -

First, the original value is multiplied by the multiplier,

-

DivBy or DivInto are applied next,

-

then addition and subtraction are performed,


-

modulo is then applied (to the total so far)

-

the result is then checked against the limit values.*

-

Next, the result is converted to incremental (if Inc or IncFrom is present)

-

finally, the sign ( + or - ) of the resulting value is altered by IncSign.

* Note that the limit is checked before the value is made incremental. This has the effect of checking the original “absolute” value (not the resulting incremental value) against the limits. Notes re “LIMIT checking”: •

Limits are not checked on phrases that are the result of a “Replace” statement. In other words, if you inadvertently replace a phrase with another that is beyond a limit, then no warning will appear.

Limit values are Absolute! In other words, even if the letter is incremental, PostHaste will keep track of the absolute value of the letter, and warn if the absolute position values indicated by the “Limit” parameter have been exceeded.

Regarding IncFrom: Always remember (as mentioned in the discussion above) that the value of any word modified by INCFROM is affected by the CURRENT value of the “IncFrom” letter. This means that if a letter is incremental from another letter on the same line of code, THE “INCFROM” LETTER (Z in the examples here) SHOULD BE CALLED FIRST! This means that, of the 2 sample lines below, ONLY THE SECOND WOULD PRODUCE THE PROPER RESULT. This is because PostHaste processes the words in the order they appear * on the line. So in the first line below, it gets to the A value BEFORE the Z has been set to the RLevel value, so in this case the A value would be output as measured incrementally from whatever the Z value was BEFORE this line was processed. Wrong: Right:

G81 X[H] Y[V] A[D] Z[RLevel] F[FRate] G81 X[H] Y[V] Z[RLevel] A[D] F[FRate]

* Remember that the order that the words appear in the sequences does NOT control the order that they appear in the resulting code: that is determined by the order the letters are listed in the “letter format” section of the Template.


4. Commands and 'Switches' Commands and “switches” are used by PostHaste to describe certain aspects of the code for your machine. These commands and switches are usually placed in the template after the letter format section and before the sequences. These are all explained in detail in this section of the manual. Note: There are also other commands that are used only inside of sequences; those are not discussed here – see section 5.3 for those. What's a Switch? Any word that you see in the templates followed by a question mark (such as RevTurret2? or First#?) are called “switches” because they refer to various code conditions that can be turned on or off with a “YES or NO”. This is done simply by placing a Y or N after that switch. Watch for switches in the descriptions below.

4.1 List of Commands and Switches (the ones that are not used inside sequences) Note: See section 5.3 for commands that are used only inside of sequences. In the format template, any of the needed commands or switches should be listed AFTER the letter formatting section, and BEFORE the first sequence. The order in which they are listed in your format is usually not important. (Any exceptions to this will be noted in the corresponding sections below.) We have listed all of the commands and switches in this section in alphabetical order, except for...

...commands and switches relating to the following topics, which are discussed in the sections noted here: Topic:

Discussed in section:

Arcs Columnar style formats Subprograms (or Subroutines) Commands that are used inside of sequences

4.2 4.3 7.6 5.3


4.1.1

Ask

Use of this command allows you to have PostHaste ask you a question when it runs - the number you type in response to the question then sets the value of any variable you choose. Any variable can be used, but care must be taken to not overwrite a variable that has been set from the tool motion file (unless, of course, that is what you really want to do). Here's a simple example that changes the output at the end of your program from an M30 to an M99, based on the value that the post asks you: Ask [Val1] 'Enter 30 for a main program, 99 for a sub.' '30' EndCode M[Val1] End

(Outputs M30 for main program or M99 for a sub.)

The three parameters after the “Ask” are... - The variable to set (Remember, there are 20 “unused” variables named Val1 to Val20 that you can use that are not normally set from an incoming tool motion file). - the first quoted phrase specifies the exact wording of the prompt. - the second quoted phrase specifies the default answer. The variable can then be used later in any sequence portion of the format to output a numerical value with any letter. Here are some examples of how you may use ASK in the template. First, you place any needed ASK statement(s) in your template like this: Ask [Val2] 'What is X CLEARANCE diameter for cut off?' '4.5' Ask [Val3] 'Cut off Spindle Speed:' '200' Ask [Val1] 'What is Z value for cut off?' '-3'

Then, you access the “asked” variable(s) in a Sequence, as in this example of an automated “cutoff” cycle in the ENDCODE section of a lathe format: EndCode G0 Z.2 G28 U0 W0 M9 T[LastTool] /0 M0 G50 X0 Z0 T1200 M[Cool] G96 S[Val3] M[Direct] G0 Z[Val1] X[Val2] T1212 G1 X0 F.003 G0 X[Val2] G28 U0 W0 T1200 /0 M99 M30 End

{ Rapid to tool change position } { Cancel Offset for LAST tool. }

{ Val3 is Cut off Spin. Speed { Cut off Z,X: Val1,2 { Clear to diam.

When PostHaste runs, a prompt dialog (like the one pictured here) will appear for each “Ask” question. You can just press ENTER to use the optional default value (in this case 4.5), or enter any other number you wish.


Warning: Any time you add (what you think is) a 'new' variable to a post, make sure that that variable is NOT being used for some other purpose in the post already! Before adding a new variable, ALWAYS do a “Search” to make sure that you don't mistakenly re-use a variable that is being used for something else. Making this mistake can result in VERY strange output - and a big mess to “debug”! How to make the Ask repeat

You can have PostHaste ask any question just once per run, or make it ask the question(s) every time a certain sequence is output. For instance, if you want a question to be asked every time a tool is changed (for example), then simply place the Ask line(s) inside the ToolChange sequence. The same holds true for any sequence. This comes in handy, for instance when formatting for a wire EDM to ask the user for different “burn” settings every time an INFEED (Cuttercomp application) move is made. If you would like a particular question asked only once per run, then simply place the ASK line somewhere NOT within any sequence. (By the way, ASK lines are permissible within an IF structure.) Whatever value the user enters in response to each question will become the value of the specified variable until that variable is ASKed again, or until that variable is reset by something in the incoming tool motion file. (Remember: if you use Val1 to Val20, then they normally won't be reset by incoming tool motion [unless they are placed on a Cycle or UponRec definition line].)

4.1.2

AskPeckClear?

Setting this switch to Y tells PostHaste ask you for the peck clearance ([PeckClear] variable) value. If your machine supports this parameter in its peck drilling cycle, then after each peck the tool will rapid down into the hole to this distance from the current bottom before it starts feeding in on each subsequent peck. If you set this switch to N, then PostHaste uses .050 as this value. Note: if the Peck drilling sequence has “none” in it, the “longhand” peck drilling cycles will use this value in the discrete movements that are generated. Instead of having the post ask you for this value, you may 'hard-code' a particular value into your tempate(s) by using a Set cd like this: Set [PeckClear] to .03

4.1.3

ByDiameter? (lathe only)

This is a “switch” that you may use for LATHE work to indicate how the vertical movements are designated on your lathe. The X values on most lathes must be given as work DIAMETER, but some allow you to use RADIUS values. If yours uses DIAMETRIC X values, the put a Y (for YES) after ByDiameter like this: ByDiameter? Y

If your lathe operates on RADIUS values for X then put N (for NO): ByDiameter? N


4.1.4

Comment

The Comment command indicates the character(s) that mark the beginning and end of 'comments' that the machine will display on the screen, but otherwise ignore. On most modern controls, comments must be enclosed in parentheses, so the Comment command will look like this: Comment ( )

(Notice the spaces!) Some machines do NOT need a “end” comment character; in this case, just indicate the comment START character: Comment '

(Machines that use only a “comment start” character will ignore anything in the block that starts with the comment character.) Other machines may require more that a single character to start and end comments, like Heidenhain controls, which we can also format by using this Comments command: Comment (MSG, )

If your machine does not accept comments at all, then you need to disable the Comment command line (by either completely deleting it, or placing a few leading spaces in front of the line so that PostHaste ignores that line). Since the Comments command is what tells the post which characters to output before & after any comments, the post logic is set up such that if there ARE no comment characters, then the post will output no comments, so all comments (PPRINT records) found in the CL file will be ignored.

NOTE: Do NOT confuse the Comment command discussed above with the Comments command that is used inside of sequences (to tell the post exactly where to put the comments in the code). See section 5.3.2 for information on the Comments command.

4.1.5

Convert

This works very much like the Replace command – except that it works on incoming CL records – that is, before the CL data is processed by the post. There are many uses for this command – limited only by your imagination. Here are a few ways that we've used it: - Convert 'unrecognized' CL records into something that will be usable by the post. Example: Convert 'PIERCE / OFF' to 'RAPID'

- Delete unneeded words or phrases in the incoming CL records. Example: Convert 'TOOL NAME : ' to ''

- Use Convert in conjunction with an UponRec sequence to process incoming records in a 'non-standard' way. Example: Convert 'APPLY / LASER' to 'APPLY / 1' Convert 'APPLY / PUNCH' to 'APPLY / 0'

Set Val1 flag for laser, or.…. Reset it to 0 for Punch mode.

Uponrec Apply [Val1] Val1 = laser flag. if [Val1] = 1 G25 e5 Replace 'e05' with '(LASER OFFSET)' !0 M44 !0 M45 endif end

- 'Un-comment' an incoming comment in the CL file so that you can actually use data that was stored in the CL file as a comment. Example:


Convert '$$-> CSYS' to 'CSYS'

You can use the Convert command multiple times. NOTE: Like the Ignore command (below), Convert can be used either in the format template file, or in the PostHASTE.CFG file. (Put Convert commands in your .CFG file for CL records that you want all of your posts to use that same conversion, or put it in the template file[s] when you only want certain posts to perform the conversion.)

Note: In templates that use Convert and Ignore commands, the Convert operation will be performed before the Ignore command.

4.1.6

Coolant

Similarly to the Spindle command, the Coolant command is followed by the numerical values for the “M codes” for the various available coolant modes. Examples: For APT-CL versions of PostHaste: Coolant 8 9 7 50

M values: On, Off, Mist*, Hi pressure (Thru) On

* Note: If no “mist” coolant option is available on your machine, then put in the same M value that you are using for flood [ON] coolant so that at least you will get coolant into the NC program if you mistakenly choose MIST instead of FLOOD in your CAM system. 4.1.6.1

Using [Cool] in an IF statement

The [Cool] variable can be used in an IF statement, but you have to test its "Ordinal" value (0,1,2,3 etc.), not the "M" value (8, 9, 7, 88 etc.), as you might think at first glance. We did this so you can see if ANY coolant is 'on' by testing like this: IF [Cool] > 0

...

The value of the [Cool] variable - in the context of an IF statement – is shown below: • • • •

Flood = 1 ( If [Cool] = 1 ... ) * Off = 0 ( If [Cool] = 0 ... etc. ) * Mist = 2 THRU or HIGH = 3

4.1.7

DComp

The 3 values following the DCOMP command correspond to the machine's three diameter offset directions: Left, Right, and Cancel, respectively. DComp 41 42 40

Left, Right & Cancel G values

In a template that uses the above DComp line, the [Side] variable (usually used in an InFeed sequence like this: G[Side]) will return a 41 when the CL file has a CUTCOM / LEFT record active, and 42 when a CUTCOM / RIGHT record is active.


4.1.8

Drive

The Drive command specifies the folder and, optionally, the extension of the final NC code file. This allows you to route the NC code files for different machines into different directories with (optionally) different extensions. (If DRIVE is not used, the NC code file will end up in same folder as the incoming CL file, and it will have the default .NCC extension.) If, for example, you would like to re-route the output into a different directory (in this case the C:\Acro-1 directory), then use the DRIVE line as follows: Drive C:\Acro-1\

or

Drive C:\ACRO-1\

NOTES: -

Make sure that you include the proper drive letter (in this case the "C:"). If you omit the drive letter, the AutoOpen feature will not work correctly.

-

You can use 'network' drives if you like. (example: “S:� )

-

Note that if you are specifying only the folder (not the extension), then the last character MUST be a backslash (\), because the post simply appends this parameter verbatim onto the front of the finished NC code file name (since file names must be separated from the folder name by a backslash).

You can also use the DRIVE parameter to specify a different file name extension, as in this example: Drive C:\Acro-1\*.ABC

This will cause the file to be output with the .ABC extension instead of the default .NCC. Another possibility is to put the NC code files for all of your different machines into the same directory, but use different file name extensions for each machine. You can do this by using the same path (folder) name in the Drive commands for each machine format, but specifying a different extension for each.

4.1.9

Each

Use this command when you want a certain code to be output on each line of your NC program. It can be followed by a letter or a variable as in these examples: Each $0

or

Each S[Speed]

4.1.10 EOB ('End Of Block' characters) Use of the EOB (End of Block) command allows you to designate exactly what characters are output at the end of each line (block) of your NC program in place of the standard "Carriage Return" (CR) and Line Feed (LF) characters (ASCII values 13 and 10). This is done by listing the ASCII values of the desired characters after "EOB" (separated by spaces, as usual). For example, if you want a semicolon (;) instead of the LF, then your EOB command will look like this: EOB 13 59

...because 13 is the ASCII value of the CR and 59 is the semicolon character. You can have up to 20 numbers (ASCII characters) in your EOB "word".


4.1.11 EOF ('End Of File' characters) Use this command in the same way as the EOB command above to designate any special "End of File" characters you would like. This comes in handy if you need to output non-standard characters that can't be easily formatted in the EndCode section. Remember also that the last line of your program will include the standard CR,LF (unless you change it with EOB as mentioned earlier), so the actual characters at the end of your file will be the 'EOB' PLUS the EOF characters.

4.1.12 Feed and Rapid The Feed and Rapid lines indicate the exact letter and numerical value that cause the machine to start moving in 'feed' and 'rapid' modes, respectively. In the templates you will see a line that says: Feed G1

That's because on the machines we use here a G1 indicates that a move at the specified feed rate is going to be programmed in this block. Likewise, the line... Rapid G0

...describes the NC word that causes a rapid move to take place. Some machines do use G1 for ALL linear moves (regardless of 'feed' or 'rapid' mode) and simply use a high feed rate to move the machine in 'rapid' mode, so you could use something like this if you want: Rapid G1 F1000

(Note: as of this writing, the Rapid line will accept two words [as shown immediately above], but the Feed line accepts only one.)

4.1.13 FeedType This line lists the letter and the possible values of the NC word that indicates the type of value that will control the spindle speed: RPM and CSS (constant surface speed). The most common format for this is... FeedType G 95 94 93

( Val's for IPR, IPM, 'Inverse time' )

“Inverse time� is normally used only with 4-axis versions of the milling post-processor: it changes the feed rate (usually F) code to output the reciprocal of the number of seconds required to complete the current movement.

4.1.14 First#? This switch indicates whether or no you want a Sequence (block) number on the 1st line of your program. If you do, then follow FIRST#? with a Y (YES). If not, then use N (NO).

4.1.15 HCode, VCode, DCode and FeedCode These commands are followed by the CHARACTER that corresponds to their function (the H, V, and D in the 1st 3 commands stand for Horizontal, Vertical, and Depth, respectively). For standard milling, these characters are almost always X, Y, Z, and F. For standard turning work: HCode is Z, VCode is X, and the FeedCode is usually F (DCode [depth] is not used for turning).


4.1.16 HCode2, VCode2, and DCode2 Just like the HCode, VCode, and DCode designations, these allow you to designate the letters used (for 2turret lathes only) to indicate movements of the 2nd turret (in the case that they are different from the letters used for the 1st turret). For instance, the Fanuc/Miyano lathe (with the drilling axis) uses a B for all movements of the drilling axis, so we put the following line in our format template (and make sure in the CAM system that all drilling is done on turret # 2): HCode2 B

Then (when using turret number 2) PostHaste will automatically use output B instead of Z. (Make sure you add the letter you use to the list of letter formats.) NOTE: The RevTurret2? switch can be used to automatically reverse the sign of X axis value. Read about it in section 4.1.30

4.1.17 Inc/Abs This line indicates the letter and numerical values that set incremental or absolute programming mode on this NC machine. You should include the following line in your template: Inc/Abs G 91 90

... so the post will be able to detect that you have switched output modes. This is an absolute necessity if you want to include any absolute code (G90) in an incremental (G91) format program, and vice-versa. Including a G91 or G90 word in any sequence (in formats using the “Inc/Abs G 91 90� line) will cause the output of the HCode, VCode, DCode, and Rotary axis code (the one preceding any reference to [RotAngle]) to be output in an incremental or absolute fashion, respectively. You can also use the [IncMode] variable (read about this below) in place of the 90 or 91 to read and output the mode directly from the tool motion file like this: G[IncMode] .

4.1.18 Inch/MM The two numbers following this parameter indicate the value of the letter that switches the machine into INCH and MM programming, respectively. These values will can be accessed in the sequences through use of the [UnitMode] variable. The post automatically assigns 70 or 71 to [UnitMode] - so you only need to use the "Inch/MM" line if you want different values. (Typically, a word like "G[Unitmode]" would be used in the StartCode sequence to set the units of measurement for the entire program.) Inch/MM 70 71

4.1.19 Incremental? Setting this switch to "Y" tells the post that when the post starts outputting the code, that you want it to be in incremental mode. The default mode of the post is "N". Be aware, however, that if you have codes within the sequences that change to absolute or incremental (usually G90 and G91), that those codes will cause the post to switch modes regardless of the "Incremental?" setting. See the "Inc/Abs" parameter for the actual incremental or absolute codes that have been specified in your template.


4.1.20 Ignore This command can be used to tell the post to “ignore” certain records in the incoming CL file. Examples: Ignore INTOL Ignore PITCH

You can use this command multiple times. NOTE: Like the Convert command (above), Ignore can be used either in the format template file, or in the PostHASTE.CFG file. (Put Ignore commands in your .CFG file for CL records that you want all of your posts to ignore – put it in the template file[s] when you only want certain posts to ignore certain records.)

4.1.21 Leading0s? Many older controls require a “leading zero” on numbers whose absolute value is less than 1 (for instance X-0.5 as opposed to X-.5). For compatibility purposes, the default method of output for PostHaste is to add the leading zeroes. If you want to inhibit the leading zeros, then set this switch to N. Note: this command is also helpful if you just want to produce somewhat more 'compact' code.

4.1.22 LocalOutput? If the following 3 conditions exist, then you will need to use the LocalOutput? switch and set it to 'Y' to tell the post to output your NC program so that all XYZ output is relative to the 'local' (current) coordinate system (CS or CSYS): 1. When you are posting for machines with rotary axes AND... 2. your CL files include CSYS (coordinate system) data, AND... 3. you are using work offsets (the [Work] variable - G54, G55, etc) to set a different origin location on each face of the part. When CSYS data is being used to determine the rotary angles, then using this setting will cause the post to rotate and/or shift the incoming XYZ values as needed (which are stored in the CL file in 'world' coordinate space) per the CSYS data from the CL file, so that the coordinates output to the NC program will match the 'local' ([Work]) origin. By default (if you do not have this switch in your template), it is the equivalent of 'LocalOutput? N', and all locations (regardless of rotary angle) will be output from the same origin. They will be rotated (only) about the center line of rotation - but not 'shifted' to match the CSYS. NOTE: Since CSYS data is usually stored in CL files as a 'comment' like this... $$-> CSYS / ..., ... , ...

... you must also include a Convert line in the template (or PostHaste.CFG file), to get rid of the comment marker (the '$$-> ') and enable the post to read the CSYS data from 'comment' lines in the CL file. Example: Convert '$$-> CSYS' to 'CSYS' LocalOutput? Y


Important! Make sure your [Work] numbers match! If your post uses LocalOutput? Y, then you must make sure that each machining operation in your CAM system has the proper [Work] number assigned to it! If your system has a place to assign work offset numbers to each operation, then do so carefully - to make sure that you always assign the same work offset number to operations that are done on the same face. If your system does NOT have this capability, then you should set up the post to assign these numbers properly. For example, Some CAM users cannot directly enter a Work/Fixture Offset (WFO) number directly in their CAM system, but they may want to set the work offset number according to the Coordinate System (CS) number, so when you change CSs, the post automatically outputs a matching G54, G55 etc. You may do so by including a Convert line and a matching Upon sequence in your template (you may put the Convert line in your PostHaste.CFG file to simplify your templates): Convert '$$-> CS NUMBER' to 'WORK /' UponRec WORK [Work] Add 53 to [Work] end

NOTE: the above example only works for cam systems that include this ‘commented’ cs record in the CL file! This will assign G54 to CS number 1, G55 to CS number 2, etc. (Note: In lieu of using the Upon WORK sequence above, you can instead format a special letter for use with [Work] (and add 53 to it in the 'letter format' section): g >2 G Add 53 Format the letter... ... Work g ...(don't forget your Work command!)... ... Index X Z[Ilevel] X[H] Y[V] B[RotAngle] g[Work]+53 ...and make sure you use the proper letter. ... (Not only in Index, but wherever [Work] is used!)

4.1.23 ModalGs This is simply a list of all of the G values that are “modal”: this means that any G code in this list will remain in effect (and not be repeated) until another G code from this list is output. This prevents, for instance, a G1 from being output on every line when there are consecutive linear moves. G values that should appear on this line are G codes for any “movement” commands: linear, rapid, circular, and “canned” cycle G values. Example: ModalGs 0 1 2 3 73 74 80 81 82 83 84 85 86 87

4.1.24 ModalLetters For most machines, certain letters are modal - that is, they are not output unless their value has changed. The letters that most machines allow to be modal are: - the ones listed in the HCode, VCode, DCode, and FeedCode commands (Usually X, Y, Z, and F). - The one used in conjunction with the [RotAngle] variable (Usually A or B).


- The one used in conjunction with the [RLevel] variable (usually “R”) inside the canned cycle sequences (such as Drill, Peck, Tap, Ream, etc.) If a different letter is used with RLevel in different cycles, then the LAST one listed in the format is the only one that will be repeated on secondary holes. When any of the canned cycles mentioned above are defined in the normal way (as in the example below), PostHaste will output optimized code (the program with the least number of codes) for all points following the first one. For instance - if you define the Drill cycle this way... Drill G81 X[H] Y[V] Z[D] R[RLevel] F[Frate] end cancel

... then all points after the first (which will be on the G81 line) will only include the X, Y, Z and “RLevel” (usually “R”) words whose values have CHANGED - because all of these values are assumed to be modal (unless, of course, you override this with the method described above). However, the modality of these (and other) letters can be set by using the ModalLetters command. For instance, if you do NOT want the “RLevel” value to be modal (therefore causing it to be output on every line of a standard canned cycle), use the “ModalLetters” list, and leave the “R” out of it as shown here: ModalLetters X Y Z F

Or, if you want another letter to be output only when it has changed (Q, for example), it can be added to the ModalLetters line like this: ModalLetters X Y Z F R Q

4.1.25 Notes: / EndOfNotes (or EndNotes) These commands can be used to 'comment out' an entire section of your template. This is helpful when you want to... - write a large amount of comments in your template, or - temporarily disable a large amount of your template information. Example: Notes: The line above causes PostHaste to ignore all of these lines... until the 'EndNotes' or 'EndOfNotes' word is found at the beginning of a line (like the line below). EndOfNotes

You can use Notes: / EndOfNotes as many times as you would like in your templates, either inside or outside of sequences. Notes: •

Don't forget the colon (:) following Notes:

Either of the words EndOfNotes or EndNotes may be used – they are interchangeable.


4.1.26 Rename This command allows you to make up any name you want to use for any variable. (Some people call this capability "user-defined variables".) It is most commonly used to replace the names of the standard 'user' variables (Val1 to Val20) with names that are more descriptive. We commonly rename the 'Val...' variables because PostHaste never 'automatically' sets the [Val1] to [Val20] values from information coming in from the CL data - they are safe to use for any purpose you like without fear of interference by the CL data or PostHaste's internal workings. (However, you can also use Rename to 'override' the name of any other variable as well.) Here are some examples: Rename [Val9] to [ModeOfPreviousOp] Rename [Val20] to [DrillingHasAlreadyStarted] Rename [LComp] to [XMultiplier] ( << Note: This is NOT recommended! See NOTES below. )

NOTE! Care must be taken to NOT use a variable that is one of the 'automatically prompted' variables ( [Work], [EndH], [EndV], [MaxRPM], [Program#], [ToolH], [ToolV], [ToolD], [WorkH], [WorkV] and [WorkD]), because if you Rename one of those, the post will still prompt you as if you were using the original variable. (See section 9.1.1.7 for more information on the prompted variables.) 2nd NOTE! Another thing you have to watch out for when renaming variables other than [Val1] to [Val20] is that the value of almost all of the other variables can be affected by data coming in from the CL file. This means that if you use a variable besides Val1 to Val20 like this... Rename [LComp] to [XMultiplier]

...your [XMultiplier] variable will be set to the incoming tool length compensation number whenever a new tool is described in the CL file!

With the above said, it is certainly OK to simply change the name of a variable that you don't like if you expect to continue using that variable for its original purpose. For example, this would make sense: Rename [LComp] to [LengthCompensationNumber]

...however, most of the time, you will want to rename the user variables ([Val1] to [Val20]) instead - for the reasons stated above. See section 9.1.1.8 for more information on the user variables [Val1] to [Val20].

4.1.27 ReturnPlane or RetPlane Use either one of these commands (they are interchangeable) to give you control over what codes are output to indicate “Initial plane” or “Rapid plane” designation on canned cycles. PostHaste can output a G98 or G99 in any canned cycle depending on which “retract mode” you wish to use: Initial plane or Rapid plane, respectively. Just add the following line to your template: ReturnPlane 98 99

( 98 = Initial plane, 99 = Rapid plane. )


The actual code (G98 or G99) can be placed wherever you want it by simply accessing the [RetPlane] variable. For example, it may be added to any canned cycle sequence like this: Drill G81 G[RetPlane] X[H] Y[V] Z[D] R[RLevel] F[FRate] end cancel

4.1.28 RevSigns This is a list of characters that need to have their signs reversed. For instance; many lathes are set up so that positive X values indicate locations closer to the FRONT of the machine; in this case you would use a line like this: RevSigns X I

(Remember the I value for circle center designation corresponds to the X axis!) Some screw machines (the Citizen F10, for example) are set up so the Z+ direction is TOWARDS the spindle; so for that we use RevSigns Z K

As many values as you like may be placed on this line, so nothing is to prevent you from indicating any amount of letters to be reversed.

4.1.29 RoundToQuad? This switch allows you to turn off the post's automatic 'round center to startpoint' feature that can cause some machines to display 'arc endpoint out of tolerance' errors. Before we can explain why you would use this switch, we must first explain PostHaste's automatic 'round center to startpoint' feature... Automatic 'round center to startpoint' feature

This feature automatically 'moves' the center point of an arc so that it lines up with the arc startpoint if either (X or Y) dimension of the start point is within twice the Tolerance setting (typically .0002â&#x20AC;?) of the center X or Y. This rounding eliminates very short arcs that may appear in the code when the start point is very close to (but not quite on) the quadrant boundary. (Many machines have a problem processing very short arcs, so this feature 'rounds them out' so that these short arcs are eliminated from the code.) This rounding happens automatically when both of the following conditions are true: 1. when the ByQuadrants? switch is set to Y. 2. when either (X or Y) dimension of the start point of an arc is within twice the 'Tolerance' setting (typically .0002â&#x20AC;?) of the center X or Y. For example; if the Tolerance value is set to .0001, then... ...if an arc start point X is 1.2002, and the center point X is 1.2000, the center point X will be 'moved' to 1.2002, and the arc will then be processed and output accordingly. So why use the RoundToQuad? switch?


Some machines are exceptionally sensitive to mismatches between the arc start/center/endpoints. Sometimes, the rounding discussed above can cause these machines to stop in an 'endpoint out of tolerance' (or equivalent) error condition when programmed with an I/J center point. Other machines can even start cutting in an erratic manner - damaging your part, cutting tool, fixturing and/or machine. If your machine is like this, then you can inhibit the 'center point rounding' feature add the following line to your template: RoundToQuad? N

Inhibits 'round arc center to quad' feature.

A better solution... If your machine is that sensitive to I and J rounding errors, then we highly recommend that you program the arcs with an R value instead of I and J! (That is, if your machine accepts 'R' style arcs.) Using 'R' style arcs will cause the machine to calculate its own arc center points and eliminate many arc problems. To do this, your template would include these lines... ByQuadrants? Y CtrCode R

...and then you would not use the “RoundToQuad? N” switch.

4.1.30 RevTurret2? This switch is used for turning; it is set if you want the signs of the 'vertical' values (usually X and I) reversed for the 2nd turret. This is very common on twin turret lathes because the turrets work on opposing sides of the center line; in this case turn ON this function like this: RevTurret2? Y

If this function is not needed, then use an N or simply leave this line out of your template.

4.1.31 Sequence#s This line contains all information to tell PostHaste how to put “Block numbers” in the NC program. There are 4 pieces of information required and placed in order on this line: •

The “Character”: the first character after the command is the 1st CHARACTER of the “block number”. Usually this is an N.

The “Frequency”: A number here indicates HOW OFTEN a block number is placed on a line. If you want one on every line, then use 1. If you want one on every other line, then use 2. If you want one on every 5th line, then use 5...etc. (Using a frequency of 0 will cause the block numbers NOT to be automatically placed on a line; PostHaste will only put them where they are requested - on a tool change line, for instance (this will be explained in sections 4 and 5 below).

The “Increment”: This number by which the block number itself is incremented before the block number is output again. Using the value of 10 will create block number in the block address itself to be 10 greater than the last block number (like N10 N20 N30 ...etc).

The “Start value”: This is simply the value of the very first block number that appears in the code; numbers after the first are determined by the start value plus a multiple of the “Increment” (above).


4.1.32 Spaces? Note: Do not confuse the “Spaces?” switch with the “Spaces” command that is used for columnar formats as iscussed in section 4.3.1 ! Use the “Spaces?”switch if you want to suppress between-word spaces in the finished NC program: Spaces? N

The default state of PostHaste is to put a single space between each NC word for clarity, which is the equivalent of... Spaces? Y

Examples: Typical code (spaces between each word):

G1 X1.2 Y2.3 Z3.4 F54.5

Spaces removed (using Spaces? N ):

G1X1.2Y2.3Z3.4F54.5

Note: Even if you use Spaces? N , spaces will not be removed from comments (see Comment above).

4.1.33 SpeedType (lathe only) Similar to FeedType (above), this line lists the letter and the possible values of the word that indicates the type of value that will control the spindle speed: RPM and CSS (constant surface speed). The most common format for this is... SpeedType G 97 96

( RPM and CSS G codes )

4.1.34 Spindle The SPINDLE command is followed by 3 NUMBERS: the numbers that correspond to CLOCKWISE (usually M3), COUNTER-CLOCKWISE (usually M4) and spindle STOP (usually M5).

4.1.35 SpliceSubs? This switch would only be used (set to 'N') if these 2 conditions exist: •

your template supports the use of subroutines,

AND you want the subroutines to be output in a separate file from the 'main' portion of the program.

See section 7.6.3.4 for details.

4.1.36 Thread This command is used for lathe formats only. It indicates the word that is used (in place of a standard linear move word like G1) to perform a single threading pass. It is typically G32 or G33 as in this example: Thread G33

This will cause the post to simply output a G33 on every threading pass.


(Note: A threading pass is output by the post when a 'THREAD / TURN' record is found in the CL file before a GOTO record.)

4.1.37 TLAxisEnabled? Use the TLAxisEnabled? switch (set it to Y) to tell PostHaste that you want to the rotary angle(s) to be calculated from the vector (IJK) CL data found in TLAXIS records. There are several ways PostHaste can calculate rotary angles, TLAXIS data is one of them. See section 12.2 for a complete discussion of this topic. TLAXIS records are ignored by PostHaste - unless you use the TLAxisEnabled? switch and set it to Y. Examples of TLAXIS records: TLAXIS/ 0.000000, 0.000000, 1.000000

(Tool shank pointing towards Z+ axis [Typ. A0 or B0])

...or... TLAXIS/ -1.000000, 0.000000, 0.000000

(Tool shank towards X- axis [Typ. B-90])

4.1.38 Tolerance The default axes movement tolerance for milling and turning is .0001 (in accordance with the typical requirements of those machines while running in INCH unit mode) and .00001 for EDM machines. To override this default value, use the Tolerance command. Then PostHaste will instead round all axes values (X, Y, Z) to the tolerance value you indicate. If your machine resolves to a value other than the default value, then it is highly recommended to set this value according to the number of decimal places in your axes movements, otherwise errors can occur due to “buildup” of tolerances that can happen in calculations that PostHaste must use in determining arc angles, movement distances, etc. You can also use this to round the output if you have an oddball machine that has unusual tolerance limitations such as “resolution to .0002 or .0005”. For example; most machines that operate in millimeters should be set to '3 places' like this: Tolerance .001

4.1.39 Tools WARNING! This command is only used for machines with “incremental” tool changers!

WARNING: Make sure that there is no TOOLS line in any section of a format template that describes a machine that does NOT have an “incremental” T number for tool changes! IF YOU ACCIDENTALLY PUT (OR LEAVE) IT IN, THEN YOU WILL PROBABLY CRASH YOUR MACHINE! The number following the Tools command is the total number of tool positions that the machine has, like this: Tools 8

This command is used only with machines that require that the T number works “Incrementally”; in other words the value of the T # is the “number of INDEXES” (from the current tool) required to reach the next desired tool; NOT THE ACTUAL POSITION NUMBER OF THE TOOL ITSELF!


These are usually very old or inexpensive machines that for example, require a “T3” to change from tool number 2 to tool number 5. (Get it?) The reason this command is necessary is so that PostHaste knows what T# is needed at the end of the program to get the turret back to position number 1 (or, since these machines typically only index in one direction, the post needs to know the total number of tools in case it has to index “around the corner” if you should need to get from a higher tool number to a lower one.) So... be CAREFUL using the TOOLS command!!!

4.1.40 UpperCaseComments? If you want to make sure that no lower case letters get into your comments, then set the UpperCaseComments? switch to Y as in the example below. This will cause PostHASTE to convert all lower case letters in your comments to upper case. UpperCaseComments? Y

4.1.41 Verbose? Setting the Verbose? switch to Y makes the post output some additional comments that may be helpful in 'debugging' your templates - or at least helping you see why there appears to be more NC code in the output than you think there should be - because, as of this writing, the post will output comments at the start and end of arcs that are 'broken' into linear moves due to any of these reasons: 1. Polar interpolation (refer to the [PolarBreaks] variable), 2. When the arc's radius is greater than the machine's maximum allowable radius (See the MaxRad command), or 3. When an incoming helical arc is processed by a template that does not allow helical moves (see the Helical? switch). The 'arc break' comments that are placed in the code may look like the underlined ones shown below: ... (BREAKING ARC [ANGLE INCREMENT 5.32342 ]...) G1 X... Y... X... Y... X... Y... (...FINISHED BREAKING ARC [FACETS = 68].) ...

4.1.42 Work This line tells the post 2 things 1 - that you want a“work offset” (or “fixture offset”) value to be put in your programs (even if one is not passed through the tool motion file), and... 2 - what letter to put in front of the “work offset” (or “fixture offset”) number. Most machines use G54 for the primary offset, so the line usually looks like this... Work G

...but other machines may use a different letter. (For example, Fadal machines use E.)


If the work offset number is not passed through the tool motion file, then PostHaste will ask you for a work offset number. Use WorkDefault (below) to set the default work offset number. NOTE - Proper handling of work offsets is a critical issue for proper post operation - and avoidance of catastrophic machine crashes! Please see section 6 for a thorough discussion of this important subject!

4.1.43 WorkDefault If PostHaste has to ask you for the work offset number, then the value you put here will be the “default” value that shows up in the question. (That way, you will usually only have to hit the enter key.) Most users will set this to 54, but if you have a Fadal, you'll probably want to set it to 1. NOTE - Proper handling of work offsets is a critical issue for proper post operation - and avoidance of catastrophic machine crashes! Please see section 6 for a thorough discussion of this important subject!

4.1.44 ZRestart? This switch is typically used to prevent canned cycles from being restarted if the [D] (depth) or [RLevel] (R level) values change in the middle of the cycle. PostHaste assumes that a canned cycle must be restarted if the 'Z' or 'R' value changes in the middle of the cycle. If you want to PREVENT this restart from happening, then enter the following line in the template: ZRestart? N

( the N means 'no' )

By default (if this switch is left out of the template), when the Z or R values change during a cycle, the cycles will be canceled (G80) if necessary, then restarted again with the new Z and/or R value(s). In other words, leaving out the 'ZRestart? N' line (or using the line 'ZRestart? Y') will cause the following type of output (on a sample where the holes are all the same incremental depth, but start at different levels). Notice both the R and Z values change: G81 X-1.834 Y0.4503 Z0.4079 R1.0079 F4.0 G80 G81 X-1.1283 Y0.6773 Z0.1177 R0.7177 G80 G81 X0.4427 Y0.9409 Z-0.1445 R0.4555 G80

Placing 'ZRestart? N' in the format will suppress the cancel and restart codes and result in this output: G81 X-1.834 Y0.4503 Z0.4079 R1.0079 F4.0 X-1.1283 Y0.6773 Z0.1177 R0.7177 X0.4427 Y0.9409 Z-0.1445 R0.4555 G80

Note: Some machines can handle changing Z and R values when in incremental (G91) mode, but NOT in absolute (G90)! Beware!


4.2 Arc processing commands and switches The following sub-sections discuss the commands that tell PostHaste how to process your machine's “circular interpolation” codes. The commands and switches are: Cw, Ccw, CtrCode, CtrCode>180, CtrCode360, CtrIncremental?, ByQuadrants? MaxRad, MinArc, and MinRad.

4.2.1

ArcPlane

(Note - this command only applies to milling format templates.) Add the ArcPlane command to your milling template if you want to be able to support arcs in the ZX and YZ planes. (By default, the post supports arcs in the XY plane only.) The ArcPlane command tells the post what codes to add to arc motions for the 3 primary (XY, ZX and YZ) planes. The corresponding codes will automatically be added to the 'standard arc output' - that is, arcs that are output WITHOUT an ArcCode sequence. (Remember - if there is an ArcCode sequence in your template, then YOU are responsible for outputting the exact arc words needed.) Example: ArcPlane g 17 18 19 CtrCode I J K

Letter & plane numbers for XY, ZX and YZ. Codes for X, Y and Z centers of arcs.

This would cause the arc output to look like this for a 1 inch radius arc in the YZ plane (assuming the CtrIncremental? switch is set to Y): G19 G2 Y1.0 Z4.53 J.7071 K.7071 The ArcPlane command must come before the CtrCode command.

In order for the center letters to be recognize properly, ArcPlane must be listed in your template before the CtrCode command. (Otherwise the 3rd letter will be interpreted as the 'arc radius' letter instead of the 'Z center' letter.) If you are using ArcPlane and there are 4 letters in your CtrCode command, the fourth letter will be interpreted as the 'arc radius' letter. Other details re the ArcPlane command

Also please note that the ArcPlane example above uses lower case 'g', not 'G'. We use separate letters to prevent the post from 'overwriting' the tracking of the G value, which would cause a G2 AND a G17 (for example) on EVERY arc move - even if they are supposed to be modal. Because of this, we also make sure that we have a matching letter formatted for the ArcPlane: g >2 G Modal

For ArcPlane (G17, 18, 19)

(Of course, if you are already using the letter 'g' for something else in your template, then you may have to choose another letter to use.) In addition to the discussion above, the ArcPlane command tells the post ALL of the following information: •

If arcs are allowed in the ZX and YZ planes

What word is used to indicate the 3 primary arc planes (typically G17, G18 and G19 for XY, ZX and YZ, respectively)


(Indirectly) what 'center letters' to use for arcs in all 3 planes. The actual center letters are dictated by the CtrCode command, but as mentioned above, the ArcPlane command affects how the CtrCode command interprets the center letters.

This table shows the pertinent information (based on the ArcPlane command in the example above): Plane:

Plane number *

G code added to arc moves:

Center codes used in arc output

XY XZ (or ZX) YZ

1 2 3

G17 G18 G19

I and J I and K J and K

The 'plane number' is just for reference here. (There is no variable in the post for this number.) Most machines interpret XY as the 'primary' (first) plane, ZX as the 'secondary' plane and YZ as the 'tertiary' (third) plane. Using the [ArcPlane] variable in an ArcCode sequence

As mentioned earlier, your machine may require non-standard code to handle arc planes, so you may need to create your own ArcCode sequence to handle it. Below are some examples. Note that we have supplied an [ArcPlane] variable that you can use - not only for outputting the plane number, but for logic (IF) purposes as well. Example #1 - I, J AND K are needed to output the arcs: ArcCode G[ArcPlane] G[ArcDir] X[H] Y[V] Z[D] I[Ival] K[Kval] K[Kval] end

The “G[ArcPlane]” above will output G17, G18 or G19, depending on the plane. Example #2 - The ArcPlane can be detected (using IF commands) to output special code for each plane: ArcCode if [ArcPlane] = 17 (XY Plane) ...(Code to output XY plane arcs goes here)... endif if [ArcPlane] = 18 ... (Code for ZX plane arcs)... endif

(ZX plane)

if [ArcPlane] = 19 ... (YZ plane arc code)... endif

(YZ Plane)

end

The number you use to test the [ArcPlane] must correspond to the numbers in your ArcPlane command. In other words, if your ArcPlane command looked like this.... ArcPlane g 5 6 7

... then you would use the numbers 5, 6 and 7 in your IF lines instead of the 17, 18, and 19 in the example above.


4.2.2

Cw and Ccw

Just like the FEED and RAPID descriptions above, The Cw and CCW lines describe the “G code” (although it can be ANY letter) that causes circular motion like these: Cw G2 Ccw G3

Attention Lathe users: - Be careful; you may need to “swap” these code values like this... Ccw G2 Cw G3

- Lathe formats may also need to have the X and I values reversed with ...MULT -1. See section 3.1.2 for information on the MULT letter modifier.)

4.2.3

CtrCode

This command should be followed by 1, 2, or 3 letters, depending on which method of arc center point designation you would like to have in the NC code. This means that the significance of the letters following CtrCode changes depending on how many you use. Here are the 3 possibilities: CtrCode R

1 letter means that the Radius of the arc will be assigned to the letter. (NOTE: Machines that use this method generally cannot process arcs of greater than 180º, so make sure that you use the “ByQuadrants? Y” setting when using CtrCode with only a single letter!)

CtrCode I J

2 letters mean that the center point of the arc will be assigned to the letters. (NOTE: the CtrIncremental? switch [below] will cause them to be absolute or incremental).

CtrCode I J R

Using 3 letters will cause the first 2 to designate the center point, and the third to output the radius. (And, in case you're wondering... yes, there are machines that require all 3!)

4.2.4

CtrCode>180 and CtrCode360

These two commands let you further optimize your NC programs by allowing you to indicate different "center codes" for 2 special cases for arcs: ones that are greater than 180 degrees, and "full circle" (360 degree) arcs. Just like the original CtrCode command, you can follow these commands with one, two, or three letters, and they work the same way. (See CtrCode above.) These commands come in handy when you want to optimize the code by using "R" wherever possible. The problem with most machines is that "R" can only be used for arcs with 180 or less degrees of sweep angle. Some machines allow the use of negative R values to indicate arcs of greater than 180 degree sweep, so for these machines you can use the CtrCode>180 command with a letter that has been formatted to be multiplied by -1 (see example below). However, not even these machines are able to complete a 360 degree arc (a full circle) using the R designation, so for these arcs we have to "relapse" into using I and J again That's what our CtrCode360 is for... In the "Letter format" section of the PostForm, we add the following line: r ->3.>4 R Mult -1

Used only for arcs > 180 degrees.


Then, typically farther down, we use these lines: CtrCode R CtrCode>180 r CtrCode360 I J

Arc-center words for Arcs <= 180 degrees " " " " > 180 deg. "Full-circle" arc-center words

If only the CtrCode line is used (and the other two are not), then there is no distinction made between the 3 cases of arcs - they will all be output in the same way. This is fine if you want to use I and J as arc centers. As mentioned above in the discussion of CtrCode, if you like, you can simply use the "ByQuadrants? Y" option to simply break all arcs into 90 degrees or less sweep. This lets you avoid all these special cases, but may add to the length of the NC program by creating more lines of code to handle the additional arcs.

4.2.5

CtrIncremental?

The information after this command is only used if the “2 letter” codes (typically I and J [or for turning: I and K]) are used to indicate the center point of the arc. Put Y or N after the “CtrIncremental?” command to answer the question: “Does your machine measure the center of the arcs incrementally from the start point of the arc?”. IF YOU INDICATE “N”, THEN THE NUMERICAL VALUES OF THE 2 “CENTER” ADDRESSES WILL BE TAKEN AS ABSOLUTE FROM THE PROGRAM ORIGIN.

4.2.6

ByQuadrants?

Many NC machines do not give you the ability to program arcs of more than 90 degrees in a single block of code. This inability of the control requires that you program the circular moves “by quadrants” by breaking arcs at the quadrant boundaries. Thus to create a full circular move, you must program 1 block for each “quarter” of the arc (and even break it into 5 arcs if the starting point of the arc is not on a quadrant boundary!) If your machine has this limitation, then put a Y after the BYQUADRANTS? command. But if your machine allows full circle programming in 1 block, then indicate N.

4.2.7

Helical?

Unless otherwise indicated (with Helical? N ), the post assumes that your machine allows helical arc moves - which are typically nothing more than G2 or G3 blocks with a Z added such that the start and end points are at a different Z level. If the machine does NOT support helical interpolation, then add the following line to the template, and the post will break the helix into linear moves (using the chordal tolerance value indicated on the MaxRad line - so don't forget to add a MaxRad command too...): Helical? N

4.2.7.1

Helical arcs - Handling special cases

On helical arcs (as with all arcs), PostHaste's 'standard' arc processing only outputs 2 'center point' coordinates; the 2 letters that correspond to the arc's plane [ArcPlane] - typically I and J for arcs in the XY plane. (Note: even helical arcs have an implied plane - the plane perpendicular to the center line of the


helix.) If you need additional code on helical arcs (for example, the Siemens 2100 control requires a K value for helixes), this will require adding an ArcCode sequence to your template. The example below is an ArcCode sequence that will output a K value for the center (of ALL arcs) along with the standard I and J. ArcCode G[ArcDir] X[H] Y[V] Z[D] I[IVal] J[JVal] K[KVal] end

If you only want K values added when it's a HELICAL arc, then you can use an IF structure to only include the K if the startpoint Z doesn't match the endpoint Z: ArcCode if [LastD] <> [D] G[ArcDir] X[H] Y[V] Z[D] I[IVal] J[JVal] K[KVal] else G[ArcDir] X[H] Y[V] Z[D] I[IVal] J[JVal] endif end

(Adds K to helixes only.) (Non-helical arcs don't get K.)

....This could become more involved if you need to support other planes (G18, G19), and even more so if you need Helical arcs in the other planes... you may have to add some 'plane test' logic to your ArcCode like this: ArcCode if [ArcPlane] = 17 AND [D] <> [LastD] (XY Plane AND Helical.) ...(Code to output XY plane Helical arcs goes here)... EXIT << EXIT the seq. here to prevent further arc processing. endif if [ArcPlane] = 17 ... endif

(XY Plane, NOT Helical.)

if [ArcPlane] = 18 ... endif if [ArcPlane] = 19 ... endif end So, what value is output with the K?

For helical arcs requiring a K value, you must be sure that you are outputting the K value properly so that it matches the machine's requirements. If your template uses... CtrIncremental? N

...the [KVal] variable will output the absolute Z value at the startpoint of the arc. If you want the END Z to be output, then simply use K[D] instead. What if you want some other K value?

Example 1: If you want the 'lead' of the helix to be output (the difference between the startpoint and endpoint Z values then you can use this:


K[D]-[LastD]

Note - this is the same as outputting the incremental Z value of the endpoint - as measured from the startpoint.* Example 2: If you need the "average" Z level (the Z level 1/2 way between the start and endpoints of the helical arc), you could use an equation like this: ([LastD]+[D])/2 ...again, this outputs an ABSOLUTE value. If you would like to output the same point, but make it 'incremental from the startpoint, then you would simply subtract [LastD] from the total* like this: ([LastD]+[D])/2-[LastD] Here's how the whole sequence would look: ArcCode G[ArcDir] X[H] Y[V] K[D]-[LastD] Z[D] I[IVal] J[JVal] end

(K BEFORE Z! *)

* NOTE - Since the value in [LastD] gets updated IMMEDIATELY (to the current [D] value) upon [D] being output, you must check or use [LastD] in any output BEFORE [D] IS OUTPUT! This is why in the example above we have the K value on the line BEFORE the Z value. (If we put it after Z, then [LastD] would have already been updated, and would be equal to [D].)

IMPORTANT - As mentioned in the note above, the order in which you use the [LastH], [LastV] and [LastD] in your sequences is critical! Please make sure you see the section 9.1.1.1 (in Appendix A) for important information regarding these variables before you attempt to use them.

4.2.8

MaxRad

This line has 2 parameters: the first tells the post the maximum radius arc that your machine can handle, and the second is a "chordal deviation" value for breaking arcs that are over the maximum radius into a series of linear movements that approximate the arc. If your machine cannot handle arcs over 99 inches in radius, then the following command will cause those arcs to be broken into linear moves, holding a tolerance of +/-0.005 from the original arc. Example: MaxRad 99 .005

4.2.9

MinRad

Arcs that have a radius less than this value are output as a single linear movement. Example: MinRad .001

4.2.10 MinArc Arcs that are less than this distance (from start point to end point) are output as a single linear movement. Example: MinArc .001


NOTE: This does not apply to 360 degree arcs (full circles), of course.

4.3 Special commands for Columnar style formats NOTE: The following two commands (Spaces and Dummy) are used only in columnar style (or “tabsequential”) programs. You may skip reading about them if you have no such requirements.

4.3.1

Spaces

The number on the “SPACES” line is used ONLY IN COLUMNAR STYLE PROGRAMS (like the EMCO or TAB SEQUENTIAL format in the example template file) and determines the length of EVERY line of the program - since every line in these types of formats must have the same length. This line MUST appear in the template before the letter formats (below) for each format that uses this programming style, otherwise the words will not be placed correctly in the NC program. Note: Do not confuse the Spaces command with the Spaces? switch!

4.3.2

Dummy

If you would like a character to appear at the end of each line of a COLUMNAR style program (so the operator will be able to see exactly where the end of the line is), then put it after the DUMMY command. This command is optional for columnar output, anc you will definitely NOT use the DUMMY line if the format you are making is NOT columnar. Like the spaces command above, this command must be placed in the template before the letter format section. Note: Do NOT use this command if the communication software you are using cannot “strip” the dummy character when tranmitting the program to your machine. (If you are using UpLink to transfer your program to the machine, then make sure that the ASCII value of this character appears in UpLink's CONFIG.NC file [after DUMMY] to make sure that UpLink does NOT send this character out as part of the program.)


5. The “Sequences” After the Name line, the Letter format section and the Commands and Switches are out of the way, the rest of the lines in the template (described below) are ones that PostHaste uses to set up different NC program code “sequences”. These are sections of the template that mimic portions of the actual final NC program, and they describe the bulk of how the program actually appears. In the sequences, the basic sections of NC code that appear in specific places in the NC program are described easily and visually; simply edit the sequences so that they look the way you want your final code to appear. We have set up PostHaste so that you can specify the 7 basic code sequences: the StartCode, 1stToolChange, ToolChange (see example on the right), Infeed (“cutter-comp on”), OutFeed (“cuttercomp cancel”), EndCode, and the “Canned cycles” (drilling, reaming, tapping, etc.) sequences. There are some other sequences available that are used for special purposes, they are discussed in the sections below as well.

ToolChange (Secondary tool changes) M9 ...coolant off. G0 G28 G91 Z0 ...Retract in Z. N[Block] T[Tool] M6 G0 G90 G[Work] X[H] Y[V] G43 Z[D] H[Lcomp] M[Direct] S[Speed] M[Cool] T[NextTool] End

As you can see from the ToolChange sequence shown above, in addition to codes that look identical to finished NC code (such as M9 and G91), there are some other ones where the letter is followed by a variable instead of a number (like N[Block], T[Tool] and X[H]). This is a very important subject, and we'll discuss it now.

5.1 Using Variables: Overview: As you saw in the sample sequence above, the sequences make use of “variables” that indicate what kind of value is assigned to the various letter addresses. We have endeavored to make the names of the variables such that their significance is quite obvious. For example, we use the variables [H], [V] and [D] for the horizontal, vertical and depth position (respectively) on 3 axis milling machines, so you see these variables used almost exclusively in conjunction with the X, Y and Z letters. For a complete list of variable names and descriptions, see Appendix A. Details: In almost all of the sequences, variables must be used to indicate numerical values that you would like the post to put into your NC program. Don't let the word “variables” scare you; VARIABLE simply means: “A word that takes the place of a number”. Let me explain it this way:


There is a reason for (or description of) every value of an NC program that you create; we are simply showing the “reason” instead of the value itself. For instance: an X value on a mill generally indicates a HORIZONTAL POSITION; so we simply abbreviate it as the letter H... “H” is the VARIABLE that indicates “horizontal position”. Therefore, to indicate that you want the X to appear followed by the current horizontal position, then simply put X[H] where you want that to appear in your sequence. The different letters in your NC program generally have a specific “reason for existence”, so we simply match the “reason” to the letter. For instance, the letter T usually indicates a “tool number”, so we've created a variable called “TOOL” to specify the tool number. You will see it used in the ToolChange sequence like this: T[Tool] See... that wasn't so scary now, was it? For a complete list of variable names and descriptions, see Appendix A. Appendix A lists all of the variable names (and the values to which they refer) that we can use instead of numbers when describing the sequences. Because there are so many types of values that can be used in an NC program there are several pages of variables listed there. It's rather a long list (which you certainly do not need to memorize!), but you may want to “skim” it, just to get an idea of what's available. Appendix A is intended to be used for reference when you need it. In the following sections, we'll discuss the specific uses of the NC program sequences themselves. As you will see, variables play a big part in what goes on in the sequences.


5.2 The Sequence Descriptions The sequences are described in the template by simply giving… …the sequence name (on its own line)… then the line(s) of formatted NC “code” (and/or other commands, as discussed in section 5.3 )… then the word END on its own line (which of course marks the END of the sequence).

StartCode %0 O[Program#] End

The sequences in the list immediately below are “standard” sequences which are common to all machine program formats. After this list, there are other sequences that are used for special cases such as canned (point-to-point) cycles, subroutines and machines that require unusual coding for “standard” movements such as rapid moves, feed moves and arc moves.

5.2.1

The standard sequences

These are the “standard” sequences - common to all machine program formats... 5.2.1.1

StartCode

This is the sequence that lets you format the sequence of blocks at the very start of your NC program. Take a look at these excerpts to get an idea of how this works. For the Mitsubishi M0: StartCode L[Program#] /0 G91 /0 G28 X2 Y-2 Z-2 End

The 1st line contains the program “header”: the program identification letter followed by the program # (which is asked of the programmer automatically when you use of the Program# variable in your format). The next line is a G91 command (to put the machine into “incremental” mode for the next line... The 3rd line is a simple way to have these machines make sure that they are in “home” position - the G28 moves the tool (with the X, Y, and Z values included) 2 inches (incrementally) away from its current position (in each axis), then returns to machine home. The slashes (/) are for a “block skip” or “block delete” code. These lines appear in the program like this: L123 / G91 / G28 X2.0 Y-2.0 Z-2.0 Note that the slashes have no numbers accompanying them because their slash character is formatted for no numeric output:


(0 digits before the decimal, NO decimal, and 0 digits after)

/ 00

For the Fanuc 3000C: StartCode G17 G40 G80 G91 G45 X0 H62 G45 Y0 H63 End

The 1st line is an â&#x20AC;&#x153;initializationâ&#x20AC;? line that sets the work plane (G17), cancels diameter compensation and canned cycles (G40 and G80), and puts the machine into incremental programming mode (G91). The next 2 lines set the X and Y work offsets (using offset registers 62 and 63 for X and Y offset, respectively). 5.2.1.2

1stToolChange

Now pay attention: This is the sequence that covers ALL THE CODE AFTER THE START CODE THAT IS REQUIRED TO GET AND POSITION THE 1ST TOOL FOR THE START OF THE 1ST CYCLE. Notice that many variable references such as [Direct], [LComp], and [Work] can (and should) be used here. For the Mitsubishi M0... 1stToolChange N[Block] T[Tool] M6 G0 G90 G[Work] G40 G80 X[H] Y[V] G43 Z[D] H[Lcomp] M[Direct] S[Speed] M[Cool] End

The 1st line of the sequence actually does the tool change (...T1 M6). The 2nd line rapids into the X and Y position (still at tool change Z level) for the next cycle while making sure that the incremental programming mode, diameter compensation, and canned cycles have been canceled (G90,G40,G80) The 3rd line applies the length compensation and rapids to the current Z level (which is the clearance plane; the CAM system puts that into the D variable of the positioning move). The last line turns on the coolant. You should notice that the tool change procedure shown below for the Fanuc 3000C is significantly different, but PostHaste allows you to create that format just as easily! Here's an excerpt from the template showing the 1stToolChange sequence for the Fanuc 3000C: 1stToolChange S[Speed] G91 G45 Z0 H[LComp] M[Direct] G90 G92 X0 Y0 Z1 M[Cool] This line sets Z0 exactly 1' below the tool. G0 X[H] Y[V] Z[ILevel] End

Important note re the 1st ToolChange and ToolChange sequences:


These sequences are “triggered” by THE FIRST RAPID MOVE IN THE CL FILE FOLLOWING A CHANGE IN THE TOOL NUMBER - NOT by the CL record that changes the tool number itself. In other words, when reading the CL file, the 1stToolChange or ToolChange sequences will NOT be output immediately after the tool number changes (typically with a TOOL or LOADTL record); THE POST WILL WAIT UNTIL THE NEXT RAPID MOVE IS READ FROM THE CL FILE before outputting the 1stToolChange or ToolChange sequences. This means that ANY COMMENTS IN THE CL FILE PLACED BETWEEN THE LOADTL and the RAPID/GOTO records WILL APPEAR BEFORE THE 1stToolChange or ToolChange SEQUENCES (unless the Comments command is used - see section 5.3.2).

5.2.1.3

ToolChange

This should be much like the above sequence except that it should first include the block(s) required to retract the spindle (or tool) to tool change position. Here's a sample from the Mitsubishi format: ToolChange G91 M9 The 1st 2 lines turn off the coolant... G28 G44 Z0 S100 ...and home the Z axis. N[Block] T[Tool] M6 G0 G90 G40 G80 X[H] Y[V] G43 Z[D] H[Lcomp] M[Direct] S[Speed] M[Cool] End

Please see the “Important note re the 1st ToolChange and ToolChange sequences” just a few paragraphs above. 5.2.1.4

Infeed

The purpose of this sequence is to describe the code that your machine needs to apply tool radius compensation (a.k.a. 'cuttercomp'). This is usually only 2 blocks: 1 to plunge the tool down to cutting depth, then 1 to feed the tool towards the part surface - applying diameter compensation if the machine requires it. This sequence gets output on the first GOTO record following a CUTCOM/ON (or CUTCOM/LEFT or CUTCOM/RIGHT) record from the CL file. A sample from a Fanuc format: Infeed G1 Z[D] F[Plunge] G[Side] X[H] Y[V] H[DComp] F[FRate] end

5.2.1.5

(apply cuttercomp)

OutFeed

This is the code that typically feeds the tool away from the part surface (removing diameter compensation). This sequence gets output on the first GOTO record following a CUTCOM/OFF record. Outfeed G1 G40 X[H] Y[V] Z[D] end

(remove cuttercomp)


5.2.1.6

EndCode

These are the last line(s) of code that appear in an NC program. They should include block(s) to remove any length compensation and retract the spindle (or tool) into tool change (or program starting) position, a final tool change (if you so desire), and the program stop code (usually M2 or M30)... EndCode G91 G0 G28 G44 Z0 S100 G28 X0 Y0 M5 M30 End


5.2.2

Canned Cycles

The “canned cycle” sequences format the NC code for the canned cycle (or: “point-to-point”) operations such as drilling, tapping, or boring.* The sequence names that fall into this category are: -

Drill and Ream

“Feed in, rapid out” and “Feed in, Feed out” cycles.

-

Bore and Back

“Fine boring” (with spindle orient) and “Back boring” cycles

-

Tap and LTap

Tapping and Left-handed tapping cycles.

-

Peck and ChipBreak

“Full out” and “partial retract” peck drilling cycles.

There is also a Cancel sequence, which typically causes a G80 to appear on the line following the final hole of the cycle; we will discuss details on this below.

5.2.2.1

Two ways to output canned cycles: 'canned' and 'longhand'

Most canned cycles (all drilling cycles except Peck and ChipBreak) can be configured in 2 different ways: 1. Accessing the machine's “canned” (or “fixed”) cycle functions (as shown here)... Drill G81 X[H] Y[V] Z[D] R[RLevel] F[Frate] end cancel

2. ...or “roll your own” longhand drilling cycles by describing individual machine motions (using feed and rapid moves, spindle and feed controls...etc.). as shown here: Tap G0 X[H] Y[V] Z[RLevel] G1 Z[D] F[Frate] Z[RLevel] M4 G0 Z[ILevel] M3 end

Position over hole, move down to R level, feed down, reverse spindle, feed up to R level, forward spindle, rapid up to initial level.

All of the lines in the longhand format (described immediately above) must be repeated for each point location in the cycle. In this case there is no Cancel sequence needed, that's why there is no 'cancel' included on the End line of this example. (The section below discusses more details regarding this.) You may “mix and match” your drilling cycle methods...

Remember: you can format any canned cycle in either of the ways described above. Therefore if your machine has a built-in drilling cycle, but no reaming cycle, then you would use method #1 for the drilling, but construct the reaming cycle yourself as shown above in method #2.

*

The AutoThread cycle is not covered in this section because it is not a 'point to point' (holemaking) cycle. Read about AutoThread in section .


5.2.2.2

Cancel

“End cancel” vs. “End”

Please notice in the 'Drill' example (#1) above that the END line has the word CANCEL on it, and that the 'Tap' example (#2) does NOT use a CANCEL on the END line. This is because the first type ('canned' machine cycle) requires a “canned cycle cancel” code (typically G80), and the 'roll your own' drilling cycles do NOT require the cancel code. Here's why: Adding cancel to the end line of a canned cycle description actually tells the post TWO things: - ...to only output the cycle description ONCE - for the first hole only; subsequent holes will be drilled by outputting only the needed X, Y, Z and R value(s) for each hole. (See the ZRestart? switch [section 0] if your machine doesn't like Z and/or R values on subsequent holes in a canned cycle.) - ...to output the Cancel sequence after the final hole of the cycle. If there is NO cancel on the cycle's end line ... - ...then all of the line(s) described in the sequence will be output for every hole in the cycle, and - ...the Cancel sequence will not be output after the final hole.

The 'Cancel' sequence

The Cancel sequence lets you describe the code required to tell the machine to stop making holes and return to normal (non-canned cycle) machining. Most machines require just a single line with a G80 to do this - as shown here (but of course you may use as many words or lines as your machine requires): Cancel G80 end

NOTE: As mentioned above, the Cancel sequence will only be output at the end of a cycle if the original cycle description is ended with 'end cancel'. So... if you have “hand-built” a cycle with individual moves, make sure that you do NOT have a cancel on the cycle's end line. This way, your hand-built cycle will NOT output the cancel sequence after it's done with the last hole. 5.2.2.3

Peck drilling (The Peck and ChipBreak cycles).

The Peck drilling (“deep hole drilling” or “chip clearing”) and ChipBreak cycles are usually formatted much like other drilling reaming cycles, with the addition of the Step variable, to indicate the pecking increment. Here is an example typical of Fanuc controls: ChipBreak G73 X[H] Y[V] Z[D] R[RLevel] F[FRate] Q[Step] end


…but what if my machine does not have a Peck or ChipBreak cycle?

Some older machines do not have these cycles. Since peck drilling cannot efficiently be described using the 'roll your own' method described earlier, we have designed one into PostHaste that will synthesize the peck drilling (or chip breaking) cycle by automatically building the required “feed and rapid” moves - typically G0 and G1. (The actual codes depend on what you put into the FeedCode, Feed and Rapid commands.) To get this peck drilling cycle on a machine that does NOT have a built-in peck drilling cycle, just include these lines in the template in place of the peck drilling cycle description that may be there already: Peck None End

Likewise, a “Chip breaker” (or “partial retract”) drilling cycle can be simulated automatically by the post: ChipBreak None End

Using the above sequences, PostHaste will automatically generate feed and rapid moves as needed to perform the corresponding types of drilling operations. 5.2.2.4

Advanced canned cycle control.

As you learned in the section above, PostHaste will automatically output the secondary holes (after the first hole of the canned cycle) with the HCode, VCode and DCode and RLevel (usually, X, Y, Z and R) words only. If you want PostHaste to use letters other (or fewer) than those four, then you must define the subsequent lines of the cycle as well, as shown in the example below which will use U, V and W in place of the normal X, Y and Z: Drill 1 G81 X[H] Y[V] Z[D] R[RLevel] F[Frate] U[H] V[V] W[D] end cancel

The “1” after the “Drill” command means that only the 1st line will appear at the start of the cycle, and the remaining lines (the “U...” line) will be repeated at every subsequent hole. The number placed on the DRILL (or Tap... etc) line of any canned cycles specifies the number of non-repeating (“first hole”) lines. This means that you can create formats for “canned” drilling cycles that require MORE than 1 line of code to start the cycle, or require more than 1 line of code per hole. In the example format below, the machine requires 5 lines to set up the cycle and drill the first hole, and 2 lines (a position line AND an “M99” line) to drill each subsequent hole. By starting the DRILL cycle with the DRILL 5 line (instead of just DRILL)... DRILL 5 G81 ... P1... P2... X[H] Y[V] F600 M99 X[H] Y[V] M99 END

These 5 lines (ONLY) appear for the FIRST HOLE of the cycle... ...These 2 lines are repeated for every hole AFTER the first.


5.2.3

Controlling 'modality' - the “Force?” option

As you probably already know, the term modal refers to the property of certain codes that makes them “stay in effect until changed”. For instance, the code that indicates linear motion (G1 on most controls) stays in effect without being repeated on each line - so this means that the G1 code is modal. Feed rates (usually F) are modal in most machines as well - they make it this way so you don't have to keep repeating the F code on each movement line. You've already read above how to specify which letters are modal and which aren't (either by using the modal modifier in the “Letter formatting” section, or by using the ModalLetters command). These tactics control the overall modality of any or all letters you wish. However, at least one control manufacturer has seen fit to muddy the waters by setting up their controls so that the modality of certain letters changes depending on context. To handle this curve ball, we have given you the ability to control whether or not the modality of the modal letters is checked in each individual sequence. The "FORCE?" switch/modifier may be added to all sequences (including the "point to point" cycles [which are DRILL, REAM, BORE, BACK, TAP, LTAP, PECK, and the custom CYCLE sequence]). You can use this option to either tell PostHaste to... •

...honor the modality of the modal letters (suppress unchanged values) within the sequence by using... Force? N

...or to force all words to be output -regardless of their modality by using... Force? Y

For instance, if you want all letters to be output on every arc, use the "Force" modifier on the ArcCode line like this: ArcCode Force? Y ... end

F.Y.I - The Force? option can also be added to the Cancel, Index, Upon, Uponrec and Cycle sequences. If added to sequences that use other parameters, it must be placed AFTER all of the other parameters as in these examples: Index X Z Force? Y Upon [tool] Force? Y UponRec LiftZ [ILevel] [RLevel] [Val1] Force? Y Cycle Fred 2 [Val1] [Val2] [Val3] [Val8] Force? Y

--- “Altered States” --Because of “popular demand”, we have set up the default state of different sequences differently. For instance, we have set up movement commands (linear, circular and rapid motion) to honor modality (in other words, to not repeat values that haven't changed), but we've set up the default state of the ToolChange sequence (among others - see below) to repeat all values so that the machinist can start running his program from any tool change without worrying whether or not the machine will have all the information it needs to start correctly from that point. The 3 paragraphs following list all of the sequences by their default state: The default state of these sequences is "Forced" (the equivalent of "Force? Y"): StartCode, 1stToolChange, ToolChange, SubStart, SubEnd, SubCall, Index, Cancel, EndCode. All canned cycles (Drill, etc.) are the equivalent of "Force Y" for the 1st hole, but then are "modal" for the subsequent holes (the equivalent of "Force? N"). All other sequences are modal (the equivalent of "Force? N") - Rapid, LineCode, Infeed & Outfeed, ArcCode.


5.2.4

Additional sequences for special purposes

5.2.4.1 Sequences for custom and multi-line movements LineCode, RapidCode and ArcCode (CwCode, CCWCode) Note: The CwCode and CcwCode sequences have been 'retired' (by the addition of the ArcCode sequence) as of 10/2001; we have listed them in the header above since many older templates use them. We recommend that if you are using a template that has them, replace them with a single ArcCode sequence as described in this section. These sequences let you 'override' the post's standard method of outputting all of the various movements (arcs, feed moves and rapid moves). Some machines just don't get it. You give it a perfectly respectable piece of NC code like “G2 X1. Y1. J1.” and they choke. Formatting for 'non-standard' movement output with other post-processors has always been a nightmare. But not with PostHaste, which lets you configure the movement codes any way you want by using the RapidCode, LineCode and ArcCode sequences (along with other features of the post, like “search and replace”, and the advanced character formatting options mentioned earlier). Remember: Since these sequences completely take over ALL corresponding movements, you are responsible for formatting them to account for ALL codes and conditions needed (feed rates, “G0”, “G1”, spindle [Speed] changes, etc). For example, let's say you want each arc movement to output 3 lines of code like these examples: Clockwise arc:

Counterclockwise arc:

notes:

ARC CW X0 Y1.0 G2 X1.0 Y1.0

ARC CCW X0 Y1.0 G3 X1.0 Y1.0

<< Absolute center point << End point

To achieve the above output, simply place the following ArcCode sequence in your template: ArcCode q[ArcDir] X[IVal] Y[JVal] G[ArcDir] X[H] Y[V] end

( q word will be 'replaced' - see below. )

replace 'q02' with 'ARC CW' replace 'q03' with 'ARC CCW'

Of course, you must make sure that the letter “q” has been formatted (in the “letter format” section of the template) to output the leading 0 by using a line like this... q 2

...and also make sure your CtrIncremental? switch is set to N like this... CtrIncremental? N

That's it! Remember the quoted phrases used in the Replace line are case-sensitive, so in the first line of the sequence, make sure that you are using any word that is NOT used elsewhere in the format.


Important notes regarding ArcCode (and CwCode and CcwCode):

To output the center point in absolute mode as in the example above, make sure that you set your CtrIncremental? switch to N so that [IVal] and [JVal] get output as absolute values (not incremental, as they would with CtrIncremental? Y). Likewise, for the [ArcDir] variable to function properly, you must make sure that your CW and CCW commands are used correctly as well. The Fanuc standard would be... Cw G2 Ccw G3

...but you may, of course, use any letter and number your machine requires. LineCode and RapidCode sequences

Similarly to ArcCode, you may use the LineCode and RapidCode sequences to format linear (feed) and rapid movements. Examples: LineCode G1 X[H] Y[V] Z[D] F[Frate] end

(Standard linear move)

RapidCode G0 X[H] Y[V] Z[D] S[Speed] end

5.2.4.2

AutoThread (used for lathe only)

Many lathes support one or more types of 'canned' threading cycles. One of the ones most commonly used is a G76 cycle. Some machines require this to be a single line of code, and others require 2 lines. These one or two lines contain all information needed for the machine to create all of the threading passes. Below is a "2-line" example for a Fanuc 0T controlled lathe: ... Letter formats... A 60 P (Used for TParams) P >34 Q ->34 q >4 Q R ->3.>4 r ->3.>4 R Mult -1 ... AutoThread Automatic thread canned cycle G76 A[TParams] Q[VBite] R[VLeave] G76 X[V] Z[H] P[Depth] Q[Peck1] r[Taper] F[Frate] end

Note: Even though the NC machine requires a P number for TParams, in this example the TParams is assigned to the "A" letter address that is formatted to output the letter P. (This is done by including the line "A 60 P" in the letter formatting section of the template.) We did this in this case because the 2nd line of the format above also requires a P word (formatted for the [Depth] parameter), and it is NOT 6 digits there - so we have to have 2 different formats that output the 2 different P words.


Here's another example - this time, a single-line version used for some Fanuc controls and Haas lathes: AutoThread G76 X[V] Z[H] K[Depth] F[Frate] A60 End

Below is a 'quick reference' chart of the variables commonly used in AutoThread cycles. Variable

Significance to machine (Fanuc 10T):

[Chams] [Depth] [FRate] [Passes] [Peck1] [Pitch]

# of lead-out threads Total depth of thread (radius) thread lead # of finish (spring) passes. Depth of 1st pass The TPI value of the current thread. This is usually equivalent to “1/Lead”(Note – Pitch not usually used for metric threading.) Tool tip angle The # of ‘starts’ a thread has. Minimum pass depth: The passes get smaller and smaller until they reach this value, then they get no smaller. Differential of start diam. and end diam. (EndV-StartV) The ‘infeed angle’ of the thread – usually equivalent to the angle of the tip of the threading tool. 6 digit code containing 3 parameters; see explanation directly below. Finish stock: How much stock to leave before final pass(es)

[StartAng] [Starts] [Step] [Taper] [TipAng] [TParams] [VLeave]

[TParams] variable The [TParams] (Threading Parameters) variable is used in common "AutoThreading" (G76) cycles on Fanuc-style lathe controllers. It is usually output as a 6-digit "P" number that actually holds 3 different values that use 2 digits each. Some machines need it output with a different letter, but here's an example of how it's usually formatted for Fanuc 0T controls (among others): In an actual NC program, the A[TParams] word listed in the sequence above may end up looking like this: G76 P020360 ...

- The first 2 digits (02) indicates the number of finish passes ("spring passes") that are cut by the lathe after reaching the final thread depth. - The 2nd 2 digits (03) is the number of the "lead-out chamfer" threads. - The last 2 digits indicates the "Cutting infeed angle" in this case, "60". On some lathes, these last 2 digits can only be set to the following values: 80, 60, 55, 30, 29, or 00 (See a Fanuc Lathe manual for more details on the use of this word in your lathe threading NC programs.) "Individual" thread parameter variables available

The variables: [Passes], [Chams], and [TipAng] allow access to the individual values available in the [TParams] variable.


5.2.4.3

Index (used for machines with rotary axes)

For machines that have one or two rotary axes, this sequence dictates how the post outputs rapid moves that include rotary axis motion. This discussion addresses only machines with one rotary axis.* First of all, you may place an axis letter (usually X, but sometimes Y) following INDEX to indicate the "default" rotary table orientation (using an X means that the axis of rotation is parallel to the X axis.) IMPORTANT: Depending on which CAM system you're using, you may need to indicate the codes necessary to make sure the tool clears the workpiece, moves in X and Y while indexing the rotary axis, then moves the tool back down to the desired end point of the move. (Some CAM systems can output 'dangerous' rotary motions, so be very careful!) ... for machines with ONE rotary axis Machines that have a single rotary axis use the [RotAngle] variable. This example will generate code that cancels the length compensation (retracting the tool to “Z home” position) before rotating, then reapplies LComp afterwards: Index X G0 G49 G90 Z0 X[H] Y[V] A[RotAngle] G43 H[LComp] M[Cool] Z[D] End

...This one just lifts the tool to the “initial plane” level: Index X G0 Z[ILevel] X[H] Y[V] A[RotAngle] Z[D] End

...and this one creates a 'direct' 4-axis simultaneous rapid move. (Only use this if you are sure that the CL file contains ONLY “safe” indexing movements!!!): Index X G0 X[H] Y[V] Z[D] A[RotAngle] End Which letter should I use on my INDEX line? / Do I need the minus sign?

Note that in the examples above, the letter X is used on the INDEX line. You may use any one of these... Index Index Index Index

X XY Y-

...depending on which axis your rotary axis is parallel to, and which way it rotates. Most 'vertical' mills will use X or X-, most horizontal mills will use Y or Y-. (MillTurn machines will

*

For machines with 2 or more rotary axes, please see the manual entitled “Formatting 5 Axis Posts”


Adding the minus (-) will reverse the sign of the rotary angle. So, if you're getting “A-90.” when you want “A90.” (for example) then just add the minus sign. (...Or remove it if it's already there.)

INDEX definition when rotary axis on CAD model does not match machine orientation

The INDEX line will be different depending on whether the indexing axis of your CAD model actually matches the machine's rotary axis orientation. Here are the two different conditions that the post is set up to handle: •

Condition 1 - Model rotation axis matches machine rotation axis:

This is a standard condition (described above) where the CAD data is oriented to rotate about the X or Y axis, and your machine does also. In the standard cases, we use "Index Y" (or Y-) for typical Horizontal mills, or "Index X" (or X-) for Vertical mills, respectively. Remember that in the 'standard' cases, the "-" is added to the letter to reverse the sign of the rotary angles - which also effectively reverses the direction of most rotary tables. •

Condition 2 - Model rotation axis does NOT match the machine rotation axis:

This is sometimes done when the programmer wants to draw a complete tombstone in the CAD model sometimes they will lay it out so that the model is oriented to index (rotate) about the Z axis instead of the Y axis. In this case, we typically use an "Index Z Y-" sequence to tell the post that the incoming data is oriented to rotate around the Z axis while the machine actually rotates about the Y axis. Please note that the minus sign (-) on the Y does NOT work the same as it does in the standard setup (condition 1 above) - instead of reversing the sign of the rotary angle, in this case it indicates which direction the tool is coming from (in the CAD model) when the tombstone is in home (B0) position. In most cases, this will be from the "Y-" direction, so we use an Index definition like this: Index Z Y… end

NOTE - If you use Index Z Y (without the ‘-‘), the post will interpret B0 as being the side of the part towards the “Y+” direction, so the B angles will be different by 180 degrees. If you need B0 to be one of the other faces, then use the ADD modifier on the B letter format to add whatever additional angle you need (90, -90, etc.) to get the desired rotation, like this: B ->3.>3 Add 90 …

... for machines with TWO (or more) rotary axes The way that PostHaste formats multiple rotary axes is significantly different from machines with a single rotary axis. This topic is covered in a separate manual – the one entitled “Formatting 5 Axis Posts with the PostHASTE Postprocessor”. Please read about it there. 5.2.4.4

Stop

When a STOP record appears in the CL file, the Stop sequence is output. Here is a suggested layout for a Stop sequence: Stop Set [Val1] to [D] G0 G91 G28 Z0

<< Memorize current Z position << Retract Z


M0 Comments M[Cool] M[Direct] G0 G90 Z[Val1] end

<< Execute the stop code. << Turn the coolant and the << spindle back on, then << Return Z to current position.

Handling ‘Optional Stop’ (OPSTOP) CL records

While the post does have a Stop sequence (that is dedicated to the handling of STOP records in the CL data as mentioned above), we do not have a dedicated sequence to handle OPSTOP records. You may handle these (as well as any CL record that you may encounter) by using the generic UponRec sequence. Here's how you would trap and output code for an optional stop (OPSTOP) record in the CL file. UponRec OPSTOP M1 Comments (Note - the Comments line isn't required, but might be a good idea...) end

For more details on how the UponRec sequence works, please read the section immediately below re the Upon, UponRec & Cycle sequences. 5.2.4.5

Upon, UponRec & Cycle sequences

The discussion directly above (re OPSTOP records) brings up an important point; rather than us designing dedicated sequences for every possible CL record (which would be a never-ending chore), we have instead designed 3 simple ‘generic’ sequences to allow you to… •

handle any CL record that you may ever encounter, and/or

‘trap’ and output code whenever any variable is updated (typically by data coming in from the CL file).

Giving you the ability to handle these conditions yourself frees us at Ground Support to spend our time developing other features, rather than being bogged down by continual addition of an unending list of dedicated sequences and conditions. These 3 sequences are very handy – they allow you to handle many unusual situations. In a nutshell... Upon

is used to set any variables, output any desired code, or execute particular post commands whenever a particular [variable] is updated.

UponRec and Cycle

let you handle non-standard or custom records in the CL file. (Similar to Upon, you may use these sequences to set any variables, output any desired code, or execute any post commands.)

All three of these sequences can be used to override PostHaste's 'default' manner of handling any variables or incoming CL records. The sections below discuss the details pertaining to the Upon, UponRec and Cycle sequences. Upon You can use the Upon & UponRec sequences to output a sequence of blocks whenever a particular variable is updated by the CL (incoming tool motion) file. It can be used as in the following example: Upon [Work]


G[Work] X[H] Y[V] Z[D] end

The variable after the UPON (in this case [Work]) is called the “trigger” variable. In this example, when the [WORK] variable is CHANGED, it “triggers” this sequence to be executed. By default, if the value of [Work] has NOT changed, then no action will occur. Also, even if the value has been changed, the action will NOT occur if the next line or sequence to be output already has that variable in it - because PostHaste expects that sequence to handle it instead. Important note: Standard Upon sequences (those that do NOT use the Every or Unique modifiers) are not executed immediately – they are output (only if needed) just before the next sequence is output. In other words, the post waits until it is time to output the next sequence (whatever it is) before it executes the Upon sequence(s). We do this to prevent 'double output' of particular codes. A good example of this is what happens if you use Upon [Cool]... It is common that the coolant status would be different (on vs. off) when using different tools. It is less common that the coolant setting would change in between cutting operations using the same tool – but since you may want your post to handle that situation, you might include an Upon [Cool] sequence like this: Upon [Cool] M[Cool] end

If the post output that sequence immediately, then you would get an extra (unneeded) coolant command (M8 or M9) just before a tool change is output, so the post 'waits' until it has to output the next sequence and then checks that sequence to see if the 'trigger' variable (in this case, [Cool]) is in it: If the [Cool] variable is in the upcoming sequence (as it usually is in the ToolChange sequence), then the Upon [Cool] sequence is not output. If the [Cool] variable is not in the upcoming sequence (as it isn't in a typical RapidCode sequence), then the Upon [Cool] sequence is output. In this example, the Upon [Cool] sequence would be output before rapid moves (if the coolant status has changed), but not before a typical ToolChange sequence (because a typical ToolChange sequence contains a [Cool] variable). The Every, PreScan and Unique modifiers

As discussed above, the standard Upon sequence is only executed... 

when the value changes AND



the upcoming sequence does NOT include the trigger variable.

There are, however 3 modifiers that you can use with the Upon sequence to change that behavior: Every, PreScan and Unique. Using any of these 3 modifiers will result in the Upon sequence being executed immediately (that is, without checking the next upcoming sequence for the existence of the trigger variable). 

Use the Every modifier if you want to force the output of the sequence every time the variable is updated - even if the value has NOT been changed (in other words, every time the CL file [or your template] updates the variable – even if it is updated with the same value that is already stored in that variable). Do this by adding the word 'Every' before the variable as in this example:


Upon every [Work] ... ... End

(Remember - the capitalization of the letters in commands and variable names doesn't matter. However, the NC “words” ARE case-sensitive, so don't put “g0” in a sequence if you really want “G0”.) 

The PreScan modifier is used when you want to output code (or set variables or execute post commands) when the post is in its 'prescan' phase – which it does under certain conditions. (The post knows when it needs to do a 'prescan' of the CL file, so you don't have to worry about that yourself.) Upon Prescan [Tool] !0 O[Val1] T[Tool] M6 G0 X0 Z10 M0 G1 Z1 F.75 M0 Add 10 to [Val1] end

Note that the PreScan version of the Upon sequence has rather limited usefulness – the trigger variable can only be one that is actually read from the CL file in its (limited) prescan phase: [Tool], [Depth], [ILevel] or [RLevel] 

The Unique modifier will cause the Upon sequence to be output only when the value of the trigger variable is updated to a unique (or 'new' one) – that is, only when the variable is set to a value that it has never been set to before. Furthermore, the Unique modifier requires the use of a letter to 'format' the variable to (the B in the example below). This allows you much more control over what happens, because all of the letter formatting options can be used to determine what qualifies as 'unique'. For example, if the letter B (the one associated with the trigger variable) uses the MOD 360 (modulo) modifier, then a [RotAngle] of 390 degrees will result in the same output as 30 degrees, so even though the variable value is different, the Upon Unique sequence below will be output only on the first one. This can be used to... o create tool lists (because you don't want to add a 'repeated' tool to the list), or... o create 'rotary axis indexing subroutines' as in this example: Upon Unique B[RotAngle] Create the indexing subs in file # 1. File On 1 Only o[RotAngle] M11 G90 G00 B[RotAngle] M10 G10 G55 x999.999 y999.999 z999.999 M99 File On Main Only end (end Upon Unique B[RotAngle]) The Relate option for 'Upon ... Unique' sequences:

Sometimes, you need to have 2 different values (variables) in your post related to each other. A good example of this would be to relate the [Work] variable to the [RotAngle] variable so that corresponding


work offset (G54, G55, etc.) value is output according to the side of the part that you are currently machining. (Of course, some CAM systems output the [Work] data in the CL file whenever an indexing motion takes place, but some do not. The Relate option gives us a way to handle problems that arise when the CAM system does not already give us properly 'related' data in the CL file.) The example below relates the [Work] variable to the [RotAngle] variable, so that whenever a particular face of the part (B angle) is accessed, the post automatically updates the [Work] variable* so the same [Work] value (G54, G55, etc.) is always active* whenever that face is being machined. Whenever a "new" B angle is found, calculate a new [Work] offset value and RELATE it the RotAngle for each face: Upon Unique b[RotAngle] RELATE [Work] Add 1 to [Face#] << Increment the 'face counter' and Set [Work] to [Face#]+53 << calculate the related [Work] value. end

* Please note that the Relate function causes the [Work] variable to be automatically updated - not output! The actual outputting of the G54, G55, etc. would be controlled in some other area of the post. In the case of example above, it would probably be output in an Index or ToolChange sequence (because that's where B axis indexing moves are typically output). The Relate function (in this case) simply makes sure that whenever the [RotAngle] variable is changed, the post will automatically change the value in the [Work] variable to 'keep the work offset in synch' with the [RotAngle] changes. (Note: The [Face#] variable in the example above is a 'user defined' variable that has been created with the Rename function. See section 4.1.26 for details on using the Rename command.)

UponRec and Cycle These are similar to the Upon sequence, but these are triggered when the post reads a particular CL record. These let you... - handle 'user-defined', non-standard or special-purpose CL records and cycles. - override the way that the post handles any CL records. Before we get into explaining all of the details, let's just take a look at a quick example... If you want to output an 'optional stop' (typically M1) code whenever an OPSTOP record appears in the CL file, you would simply add this to your template: UponRec OPSTOP M1 Comments (Note - the Comments line isn't required, but might be a good idea...) end

In the simplest form of an UponRec sequence (as shown above), all you need to do is to make sure that the word following UponRec matches the actual name of the record that is coming in from the CL file. The above is the simplest form of an UponRec sequence, as there is no actual numerical data being passed in from the CL file. Here are some more examples that show how to handle records that pass numerical data... --- Excerpt from CL file: --... ETHEL/10.01, 20.02, 30.03 CYCLE/FRED, 1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8


GOTO / GOTO / GOTO / GOTO / CYCLE/OFF ...

1.000, 2.000, 3.000, 4.000,

2.031, 0.844, 2.031, 0.844,

0.000 0.000 0.000 0.000

--- Excerpt from template file: --... UponRec Ethel [Val8] [Val9] [Val10] G67 X[Val8] Y[Val9] Z[Val10] end CYCLE FRED 3 [Val1] [Val2] [Val3] [Val4] [Val5] [Val6] [Val7] [Val8] G88 X[Val1] Y[Val2] Z[Val3] G89 X[Val6] Y[Val7] Z[Val8] G67 X[H] Y[V] Z[D] G67 X[H] Y[V] Z[D] end cancel ...

... When you run PostHaste with the above CL data and template sections, this code will appear: ... G67 G88 G89 G67 G67 G67 G67 G80 ...

X10.01 Y20.02 Z30.03 X1.1 Y2.2 Z3.3 X6.6 Y7.7 Z8.8 X1. Y2.031 Z0 X2. Y0.844 X3. Y2.031 X4. Y0.844

< This line is from the ETHEL record/sequence, < These are from the FRED cycle. < < < < < <

Note: Even though the "ETHEL" and "CYCLE/FRED" records are adjacent to each other in our example, there is no additional relationship between them. (Much like it was in the original "I Love Lucy"... :-) You can use UponRec and Cycle sequences to "trap" CL records BEFORE they get to the post's "standard" processing. This lets you overrride PostHaste's processing of any standard records. Examples: •

…to prevent LOADTL records from being processed by the post's internal tool change routines, use an "UponRec Loadtl" sequence: your UponRec sequence will take precedence over the ToolChange sequence (and therefore prevent the ToolChange sequence from being output).

If the "CYCLE/DRILL..." data in your CL file is NUMERIC ONLY (in other words, it does NOT follow the normal text conventions for drilling cycles [FEDTO, RAPTO, etc.]), you can process them by using a "Cycle Drill" statement in your PostForm file. This will prevent the post's standard DRILL sequence from running and causing errors due to the non-standard portions of your CYCLE/DRILL records coming from the CL file.

As you may have noticed from the examples above, the template file is not case-sensitive when it comes to CL record names - the terms LOADTL and LoadTl are identical as far as the template is concerned. Note - Make sure that the name of the record you use in the UponRec line is spelled exactly the same as the actual name of the record in the CL file.


Using variables with UponRec or Cycle to handle the incoming values First of all, you probably noticed in the examples above that the UponRec and Cycle lines include some variables, such as [Val1], etc. These variables store the specific values that are read from the incoming CL record. Matching variables to values.

For best results, the number of variables in the template should match the number of values coming in from the incoming CL record. If, however, there is a mismatch, NO ERROR MESSAGE WILL BE GENERATED. â&#x20AC;˘

If the number of variables is LESS than the number of values provided in the CL record, then all of the variables you have specified will get set according to the values, and the "leftover" incoming values will be ignored.

â&#x20AC;˘

If the number of variables is MORE than the number of values in the CL record, then the extra variables will get set to zero.

By the way, "what's a VARIABLE and what's a VALUE?" The term "variable" refers to variables in the Postform file, such as [H] or [Tool] or [Val3]. (This is true throughout this manual, so we're telling you nothing new here.) The term "value" refers to a single numeric value (for example, the X position or a tool number) coming in from the CL file. Cycle (using variables) Use the CYCLE sequence to format a custom point-to-point (a.k.a. 'drilling') cycle. This means that you want to process a series of GOTO lines that follow a particular record in the CL file. Each GOTO will be interpreted as a point, just as in all other standard cycles (such as DRILL, PECK, TAP, etc.), until the CYCLE/OFF statement is reached. Except for the following special conditions, all of the rules that apply to standard drilling operations also apply to the CYCLE sequence - so you may want to review the "Canned Cycle" section of the manual (and especially the 'Advanced canned cycle control' information in section 5.2.2.4). The minimum requirement for a CYCLE sequence is just the word CYCLE followed by another word - that word being one that is not a standard APT cycle (such as DRILL, PECK, BORE, etc.) as in this example: CYCLE FRED ... ... end cancel

(NOTE: The "cancel" is optional.)

You may also use up to 10 variables (or none at all), as well as the "Force?" option - as shown in the example below. NOTE: If you use variables, then you MUST include the number of non-repeating 'first hole' lines immediately after the custom cycle name (the number 0 in the example below): CYCLE FRED 0 [Val1] [Step] [RLevel] [...] Force? Y


If you mistakenly omit the 'first hole' number, then you will probably get an error message when you run the post like "the number of setup lines in the CYCLE line exceeds the number of lines in the cycle". This is because PostHaste will interpret the internal value of the variable [Val1] (which happens to be 190) instead of a valid number. If you're not clear on what that number does, then again, please review the section entitled "Advanced canned cycle control" (section 5.2.2.4). More UponRec and Cycle examples Here is a use of UponRec (combined with a Convert command) to process incoming APPLY records in a 'non-standard' way: Convert 'APPLY / LASER' to 'APPLY / 1' Convert 'APPLY / PUNCH' to 'APPLY / 0'

Set Val1 flag for laser. Ignore: Apply / Punch

Uponrec APPLY [Val1] (Val1 = 'laser on' flag.) if [Val1] = 1 G25 e5 Replace 'e05' with '(LASER OFFSET)' M44 M45 endif end

Similarly, the Cycle sequence can be used to process any APT-CL CYCLE records that do not match the standard cycles that PostHaste recognizes - like the example below which processes a CYCLE / WELD record: Cycle WELD G89 G99 X[H] Y[V] Z[D] R[RLevel] F[FRate] d[Dwell] end cancel

5.2.5 CallMe and Call (User-defined sequences and 'reusing' sequences) The CallMe and Call commands allow you to create and/or 'remotely' execute any sequence from other places in the template, thereby eliminating the need to have identical lines of code in two (or more) different places in your template. (This is commonly used to eliminate the need to have identical lines inside the ToolChange and 1stToolChange sequences, for example.) â&#x20AC;˘

Call is used (inside any sequence) wherever you want to execute (output) any other sequence. You can call any standard sequence (such as 1stToolChange), or sequences that you have defined yourself with the CallMe command (see immediately below).

â&#x20AC;˘

CallMe can be used (outside of a sequence) to create new 'user-defined' sequence(s) to be called ('reused' or 'remotely executed') from elsewhere.

Examples Call can be used to execute (or 'reuse') any standard sequence Probably the most common (and sensible) use of the Call command would be in the ToolChange sequence, since the ToolChange sequence is usually just the same as the 1stToolChange sequence - with the addition of a few lines at the beginning.


This first example calls (executes) the 1stToolChange sequence from inside the ToolChange sequence (after the first few lines have turned off the coolant and retracted the tool): 1stToolChange T[Tool] M6 G[Work] G0 X[H] Y[V] S[Speed] M[Direct] G43 Z[D] H[Tool] M[Cool] End ToolChange M9 G0 G28 G91 Z0 Call 1stToolChange End

<< This single line takes the place of repeating the 4 lines found above in 1stToolChange.

CallMe can be used to create your own (a 'user-defined') sequence Note: Sequences that you create (with the CallMe command) do not get executed (output) until they are Called from somewhere else in the template via a Call command. CallMe DoSpeedIfChanged If [Val1] <> [Speed] S[Speed] NoEol Set [Val1] to [Speed] EndIf End RapidCode Call DoSpeedIfChanged. G0 X[H] Y[V] Z[D] End

<< Creates the “DoSpeedIfChanged” sequence.

(Note that CallMe sequences end with “End”, just like any other sequence.)

<< Calls (outputs) the DoSpeedIfChanged sequence.

5.3 Commands that can be used inside of sequences As mentioned earlier, there are some commands that are used only inside the sequences. They will be discussed here. (Commands that cannot be used in sequences are discussed in section 4.) The commands described in this section are listed in alphabetical order.

5.3.1

Call

Call is used (inside any sequence) wherever you want to execute (output) any other sequence (including sequences that you have defined yourself with the CallMe command). See section 5.2.5 for more details on Call (and how to create your own sequences with CallMe).


5.3.2

Comments

The Comments command dictates exactly where comments will appear in the output. It can be used in any sequence, but it makes the most sense to put it in the 1stToolChange, ToolChange and RapidCode sequences as in the examples below. (When working with 4 axis mill formats, then you should also include one in your Index sequence.) Note: The Comments command replaces the earlier [CommentDelay] variable. We highly recommend that you update any templates that you may have that use the [CommentDelay] variable so that they instead use the (much better) Comments command. When the template includes a Comments command, PostHaste will 'store' all comments coming in from the CL file (the PPRINT records) until a Comments command is found while processing the output. (Before this command was available in PostHaste, the 'operation and/or tool change comments' would typically appear in the code before the ToolChange sequence started â&#x20AC;&#x201C; which resulted in the comments appearing too early in the code. This means that on most machines, the comments would scroll off the top of the screen by the time the tool change [M6] was executed.) NOTE: Because the post now 'stores' the comments coming in from the CL file until a Comments command is executed, it is very important that you include a Comments command in all applicable sequences (1stToolChange, ToolChange, RapidCode [and Index, when applicable]). If you do not do this, then the comments for several operations may appear 'stacked up' in the same place in the code! So, if your format includes RapidCode and/or Index sequences, make sure that there are Comments commands in them!

Examples: RapidCode Comments G0 X[H] Y[V] Z[D] end

Rapid moves w/ NO rotary.

1stToolChange G0 G[Work] G40 G80 G90 B0 T[Tool] M6 Comments G90 G0 X[H] Y[V] G43 Z[D] S[Speed] M[Direct] H[LComp] End

First tool change

ToolChange M9 g28 g91 Z0 T[Tool] M6 Comments G90 G0 G[Work] X[H] Y[V] G43 Z[D] S[Speed] M[Direct] H[Lcomp] End

Secondary tool changes

5.3.3

If, Else and EndIf

Please see section 7.5 ( If / Else Logic ) on page 84 for a discussion of this topic.


5.3.4

File

In short, the 5 types of File commands give you control over both multiple output streams (or files) and multiple output styles that can either be routed into individual (or multiple) output files, or reorganized (in any order) into a single file. (If you didn't understand that, it's OK - it can be complicated. We'll explain below...) What the File commands can do for you

The File commands lets you route any or all selected lines of output data (generated by the sequence lines) into one or more separate output files simultaneously. Then, you can either leave the output distributed among the individual files. or, if you like, you can merge some or all of the files back together into a single (or even more than one) final output file. This not only gives you a high degree of control over how the final output file(s) are handled, but also over how the CL data gets processed; you can process the same section of CL data in several different ways, and then have the resulting output appear in multiple (different) locations within the same final program file (or in separate files). For example, it enables you to do these types of things (in addition to many more)... - Post the same CL data in several ways, then either - 'channel' the output of the different kinds of processing into different files, or - 'join' the separate files into a single finished NC program. Example: to create a 'tool list' at the top of your programs. - 'Break' the code into 2 or more files. (e.g. due to machine 'line number' limitations.) - 'Sort' the post's output into several separate files Example: every operation (or the motion for each tool) can be output to its own file. - Post programs for multiple machines simultaneously. - Create multiple output files for machines that require more than one file to perform a machining job. You can temporarily use up to 100 individual output files simultaneously in addition to the 'main' file. (You can actually create more than 100 files, but you can read or write only 100 of them simultaneously.) The main file is the 'usual' final program file that the post creates when you don't use any File commands (usually named the same as the incoming CL file, but with the .NCC extension). How to use the File commands

Per the usage examples in the table below, the word File is always followed by 2 parameters: - the 1st parameter is one of the six 'options' (Alias, Empty, Off, On, Insert or Edit), and then - a file number. The file number can be... - a number from 1 to 100 (inclusive) or - a [variable] or an equation that evaluates to an integer from 1 to 100 (inclusive), or - it can be the word 'Main'. (This lets you control the 'main' output file.) At this point, since you can only specify file by its number (not its 'name'), you may be wondering how to create a file with a specific name... that's what the File Alias option is for. Read about it (and all of the other options) in the table below.


Notes re the table below: 1. The File command options are listed in the order that they are most likely to be used. 2. Remember - in the examples here, the 1 can instead be a [variable] or equation or the word Main . Option Alias

*

Empty

*

Usage examples

Purpose

File Alias 1 'This file.txt' ...or... File Alias [Val19] 'This.txt' ...or... File Alias [Tool]+5 {CLName} '.cmd' ...or...?

Use this only if you want to indicate a specific file name that you want to use as an 'alias' of the file number indicated. That is all that this command does. (It does not 'empty' the file or turn it on or off.) From then on, simply use the file number (in this case, 1 ) for any Empty, On, Off, Edit or Insert operations; the post automatically keeps track of the actual file name. (This prevents you from having to have the file name text in multiple locations in your template [which could lead to lots of confusion in the case of file names that are based on variables!].) Note: If you just want to use a 'temporary' file (and you don't care what its name is), then do NOT use the File Alias command.

File Empty 1 ...or... File Empty [Tool] ...or... File Alias [Val3]+1 ...or...?

Because the Alias option does nothing but substitute a name for the file number, you will almost always follow every File Alias _ command with a matching... - File Empty _ command (to create a new, empty file) or a - File Insert _ command (to read the contents of a certain file into the other files that are 'on' [see 'File On' below]). --The first example on the left will cause any subsequent operations on file 1 to actually operate on the file called This file.txt instead of the ..\Temp\1 file. As you can see from the other examples on the left, the file name can be a 'hard-coded file name' or a {text variable} or any combination of 'hard-coded text', {text variables} and even [Numeric variables]. Numeric variables (such as [Tool] or [RotAngle]) will be formatted to output the 'simplest' text that represents the number – no leading or trailing zeroes, no trailing decimal points – regardless of any number formatting used elsewhere in the template. ( Examples: 0 or 1 or 180 or .5 ) Note: If you don't specify a folder, the file will be created in the same folder as your main output file. Note: Don't use the Alias option more than once per file number (because this will 'overwrite' the file) – unless you first use the Insert option to 'copy' its contents into another file(s). Empty creates a file that is initially empty; use Empty when you just need to use a 'temporary' file and you don't care what its name is. For example, when you just need to store some output that will be 'inserted' back into the main (or other) file later. Note: Since the Empty option only uses a number (it doesn't let you specify a file name), it will create a file called (in this case) 1 (with no extension - in the ..\Temp folder underneath the folder that PostHaste.exe is in). NOTE: You MUST use Empty when you want to start with a 'fresh' (empty) file. If you do NOT use Empty (i.e. if File ON 1 is executed before File Empty 1), then you will be appending information to the (existing) .. \Temp\1 file!


Option

Usage examples

Purpose

On

File On 1 ...or... File On Main ...or... File On [Tool]

Use the ON option when you want to start (or resume) outputting data to a specific file number. Any sequence lines executed after a File On _ command is executed will be output to the file number specified (as well as any other files that are also in the 'on' state) until the post executes a corresponding File Off _ command. (The file will also be turned off if a 'File On... ONLY' command is processed for any other file number [see “the ONLY option” below]. Note: The 'Main' file is ON by default when the post starts processing, so if you don't want it on to start with, then you must turn if off with a File Off Main command in your StartCode sequence. (Or, you can use a 'File On... ONLY' command to turn on 'only' some other file – thus turning off the main file.)

Note: Using the 'Only” option: File On 1 Only ...or... File On Main Only ...or... File On [Tool] Only

The “ONLY” option: You should make it a habit to use the ONLY option whenever applicable in your FILE ON commands. Adding 'ONLY' to the end of the line turns off all other files, leaving 'only' the specified file in the 'on' state. (This eliminates the need for most FILE OFF commands, which makes your template much cleaner looking and easier to understand.) In other words, use the ONLY option when you only want 1 file on at a time. (Obviously, if you need more that one file on at a time, you would NOT use ONLY.) This is the opposite of the ON option: use the OFF option when you want to stop including the upcoming code in a certain file (or files). This condition also persists until a File ON _ command is processed for the same file number.

Off

File Off 1 ...or... File Off Main ...or... File Off [Val12]+[Sub] ...

Insert

File Insert 1 ...or... File Insert [Val4]

Use this to copy the contents of any file into any other file(s) that are ON. See the EndCode sequence in the 'tool list' example below (section 5.3.4.1) for a good example of how this is done. NOTE: If you don't turn OFF a file before you 'insert' it into another, the post will automatically turn it off first – to prevent it from attempting to 'insert into itself'. (After the INSERT operation, the file will be left in the OFF condition.)

Edit

File Edit 1 ...or... File Edit [Tool]

This option causes the post to 'execute' the file – which in most cases should result in it being opened by an editor (such as WordPad, NotePad or Microsoft Word, etc.) Depending on how you have your system's Windows' File associations set up, this could cause a file to be opened in any application you choose ( - a communications package, for instance, to send a NC program to one of your machines). To set up Windows' File associations, use Windows Explorer and go to the Folder Options choice in the View menu. (in Windows 2000 and XP, the Folder Options choice is in the Tools menu.) --You may have multiple File Edit _ commands in your post, and you can even 'edit' the same file number more than once – but only if you use File Alias commands executed somewhere between the File Edit commands so that the file number is 'reassigned' to different file names - so that you are not trying to 'edit' the same physical file more than once. NOTES: 1. This command will NOT execute the file unless PostHaste's AutoOpen feature is enabled. (See the 'AutoOpen?' switch in the PostHaste.CFG file [Appendix A of the Getting Started manual].) 2. Since the AutoOpen feature automatically opens the 'main' file, you will never need to use the command File Edit Main

* Important notes re the Alias and Empty commands...

1. The Alias and Empty commands do NOT turn a file on. - Alias does nothing more than associate a file name with a file number, and - Empty simply empties a file and get it ready for use later in the process. (You must specifically give a File On _ command to start outputting to any file.) 2. The Empty and Alias commands cannot be used with 'Main' file. The post automatically creates an empty 'main' (final program) file (just as it always does when you are not using File commands).


5.3.4.1 'File' usage example: Creating a 'tool list' at the top of the program. This example template excerpt in the chart below uses 'temporary' files to process 2 parts of the output, then merges them (in EndCode) back into the main output file - to output a final file that starts with a 'tool list' (consisting of the 'operation comments' that are in the CL data) like this: % O123 (TOOL # 1 ) (T1 - 1/4 REM - RUFF 1 HOLE FOR PIN) (TOOL # 5 ) (T5 - 1/4 FEM - FIN 1 HOLE FOR PIN) (TOOL # 4 ) (T4 - 1/4 REM - RUFF 5 OD CUTOUTS) (TOOL # 5 ) (T5 - 1/4 FEM - FIN. 5 OD CUTOUTS) (TOOL # 9 ) (T9 - 5/8 45 DEG. 1-FL. CHAM. - CHAM 6 CUTOUTS [PGM AT .060 DIAM]) G17 G40 G80 G90 T1 M6 ...

Note: For brevity, the example below doesn't show the entire template - only the applicable sequences. ... Replace 't' with '(TOOL # ' << For 'Tool #' comment.

StartCode %0 << These 2 lines go into the 'main' file, by default. O123 File Empty 1 << File 1 will be the tool list. File Empty 2 << File 2 is the 'bulk' of the program. File on 2 Only << Turn on the 'bulk of the pgm. code' file G17 G40 G80 G90 End (StartCode)

1stToolChange T[Tool] M6 File on 1 << Turn on the 'tool list' file to get the t[Tool] )0 (TOOL # _ ) comment and the Comments op comments, then File off 1 turn off the 'tool list' file. M[Direct] S[Speed] G0 G54 X[H] Y[V] G43 Z[D] H[Lcomp]M[Cool] End

ToolChange M9 G49 Z0 M5 T[Tool] M6 File on 1 << Turn on the 'tool list' file to get the t[Tool] )0 (TOOL # _ ) comment and the Comments op comments, then File off 1 turn off the 'tool list' file. M[Direct] S[Speed] G0 X[H] Y[V] G43 Z[D] H[Lcomp] M[Cool] End

EndCode File On Main Only << Finally, turn on the main (_.NCC) file, (Note that this turns OFF the 'bulk' file [#2]). File Insert 1 then append the Tool list, and File Insert 2 the rest of the code into the main file. M9 continue outputting the 'end program' lines... G90 G0 G49 Z0 M5 X0 Y0 M30 %0 End

Note: The example above is an excerpt from the Tool List.pm3 file that is included in the standard post format library.


5.3.5

NoEol and EOL

Using NoEOL allows you to build a single line of output code (in a 'piece by piece' fashion) by 'stringing together' two or more sequence lines from your template. (In other words, when you want to create a single line of output code from MORE than a single sequence line.) The NoEOL (literally, â&#x20AC;&#x153;NO End Of Lineâ&#x20AC;?) command suppresses the 'end of line' characters that PostHaste automatically outputs at the end of each code sequence line. (Note - These are unique commands, as they are the only ones that can be used in a sequence on the same line as other output codes. All of the other commands [such as Comments, File, IF and Set] are always on lines by themselves and don't generate any output code.) Here's an example of how you might use NoEol. In this case - a combination punch press with a laser head - the user wanted a G61 to appear on the first cutting move, but only if the machine was in 'laser' mode (not punching). Here's how we did it: (Only the applicable sections of the template are shown, also demonstrating the Convert and UponRec commands.) Convert "APPLY / LASER" to "APPLY / 1" Convert "APPLY / PUNCH" to "APPLY / 0" Uponrec Apply [Val2] end

For Val2 laser flag. Ignore: Apply / Punch

Val2 = 'laser on' flag.

ToolChange G0 H[H] Y[V] if [Val2] = 1 (Laser) M64 '(LASER ON)' M66 G4 p100 M68 G61 NoEOL << NoEOL 'delays' the output of G61 to put it on the NEXT line! (1st cutting laser move). endif End (ToolChange)

5.3.5.1

EOL

Use this command (somewhere after NoEol command[s] are used) if you need to show where you want a line to be ended. You will NEVER need to use this command unless the last word that you want to be output on the line is accompanied by a NoEol command. (In other words, EOL cannot be used to output blank lines. Use the exclamation point for outputting blank lines - see section 0 for details on that.) Below is a good example of how the EOL command is used (along with some NoEol commands, of course). In this example, we want to prevent PostHaste from 'repeating' the first XY location in a drill cycle (where the machine requires that the XY location is on a separate line from the rest of the drilling code). Since PostHaste treats all codes for the first hole of a drilling cycle as non-modal, the first XY position in the cycle is redundant (because PostHaste also always generates a rapid move to the XY position above the first hole location before a drill cycle is started). We use the following lines inside the Drill sequence to suppress the (redundant) XY location of the first hole : Set [Val1] to 0

Val1 is a flag for 'X or Y has been output'.

if [H] <> [LastH] X[H] NoEol Set [Val1] to 1 endif

If X has changed, then Output it (with no EOL), and set the 'has been output' flag.


if [V] <> [LastV] Y[V] NoEol Set [Val1] to 1 endif

Same for Y...

if [Val1] = 1 Eol Endif

If X or Y has been output, then output the EOL to end the line.

Note: If we had left out the EOL section above, then the X and/or Y would be placed on the next line of code (because of the NoEOL commands on the X and Y lines), instead of being output on their own line.

5.3.6

Set

Set is a command that can be used inside a sequence (only) to set (or 'assign') the value of any variable. There are any number of reasons you may want to do this - it's limited only by your imagination. One of the most common uses is to use it in conjunction with “If/Then/Else” logic to control the output of certain codes. (See section 7.5 for information on the use of “If/Then/Else” logic.) Example: In this first example, we have a machine that uses a G code to dictate any one of 5 spindle speed ranges (from G65 to G69). We will SET [Range] to the proper spindle range. We show it here in the 1stToolChange sequence, but you'd also put it in the ToolChange and RapidCode sequences as well. (We've added blank lines to the examples for clarity - they don't affect operation of the post...) 1stToolChange G0 G90 G80 G40 G17 T[Tool] M6 SET [Range] to 65

This line sets the "under 1000 RPM" spindle range.

if [Speed] > 1000 SET [Range] to 66 endif

This IF structure sets the range if the speed exceeds the 1st gear range.

if [Speed] > 2000 SET [Range] to 67 endif

...and we do it again, one IF/SET structure for each range you want.

if [Speed] > 3000 SET [Range] to 68 endif if [Speed] > 4000 SET [Range] to 69 endif G[Range] M[Direct] S[Speed] G0 G[Work] X[H] Y[V] G43 Z[D] H[Lcomp] M[Cool] End (end of 1stToolChange)

This line actually outputs the code.


Another Example: If your machine requires the spindle to be stopped before gear changes, then we will need to set up the RapidCode sequence to stop the spindle if a gear change is needed. (Remember, RapidCode is used when you want to override the post's default way of handling rapid moves.) To detect if a gear change is needed, we'll use the SET feature to "memorize" the previous range, then use an IF statement to compare the previous range to the new range. If it's different, then we'll stop the spindle before outputting the new speed range code. First of all, add the Set line in the following example AS THE LAST LINE (just before the "end") in the 1stToolChange and ToolChange sequences... 1stToolChange (do the same in your ToolChange sequence.) . . . M[Cool] Set [Val2] to [Range] (This 'memorizes' the spindle range in [Val2]. ) End (end of 1stToolChange)

...this will cause Val2 to "memorize" the spindle range that was just output. (You'll also notice that this will become the last line of the RapidCode sequence shown below...) Now, Add IF structures to the RapidCode sequence to make it look like this: RapidCode ... ... ...

( We didn't bother showing all the same range codes that were already shown in the above example, but in a real format they should be here. )

if [Speed] > 4000 SET [Val1] to 69 endif

(These 3 lines are the same as in the above example - they set the high range...)

v--- THESE LINES ARE ADDED TO CHECK FOR SPINDLE STOP ---V if [Range] <> [Val2] M5 endif

If range has changed, then M5 to stop the spindle before...

G[Val1] M[Direct] S[Speed] G0 X[H] Y[V] Z[D] Set [Val2] to [Range] END

...the gear change. The rapid movement is output here. Finally, memorize the gear range again for the next time around.

(end of RapidCode)

5.3.6.1

Limitations of SET commands

You may have up to 200 Set commands per machine format. (That's a LOT â&#x20AC;&#x201C; if you think you need more, then there's probably a much better way to create the output that you need, so take a minute to re-think your strategy.) Here are the rules regarding Set commands (as you've already seen in the examples above): -

the first parameter must be any [variable]; the second can be a variable, a numeral, or an equation.

-

the two parameters are separated by the word "to" (upper, lower or 'mixed' case doesn't matter)

-

Set commands are only allowed inside of sequences.


6.

Work Fixture Offsets (G54, etc.): how they [Work]

Because they drastically affect overall positioning of your machine as well as individual movements, work offsets (including usage of the [Work] variable) are taken very seriously by the post. Having wrong or missing work offsets could easily cause you to crash your machine! For this reason, when it comes to outputting work offsets, PostHaste... •

NEVER ignores them,

NEVER "makes them up",

ALWAYS outputs ALL work offset changes, and

NEVER leaves room for ambiguity.

The only way PostHaste WON'T output them is if you set up your format template AND your tool path data to specifically NOT use them. (The details of how to do this are also discussed below.) The 3 issues (in the format template) that control Work offsets There are 3 things in the template that affect how and when the work offsets are output. (They are listed and described briefly here, and discussed in more detail below.) •

Factors 1 and 2 are usually found in the "miscellaneous parameters" area of the template: you can have lines that start with WORK or WORKDEFAULT as in the examples here: Work G

- This tells the post what letter to use for work offsets.

WorkDefault 54

- If the post asks you for an offset, this will be the default value shown..

The third factor is the use of the [Work] variable in the code sequences. Using the [Work] variable ANYWHERE may also affect the way work offsets changes are output EVERYWHERE ELSE in your program. Read about the [Work] variable below.

Work offsets "in a nutshell" If you want work offsets to appear in your programs, then all you really need is to either... •

Use the [Work] variable in your 1stToolChange and ToolChange sequences. This will allow you to control EXACTLY where the first "G54" appears. (Subsequent offset changes will automatically be output wherever needed - with whatever letter you placed before [Work] usually G.)

OR... •

Put a "Work G" (or equivalent) line in your format. (We recommend putting it in 'section 2' of your template - among the other commands & switches.) This will tell the post to just put them wherever they're really needed (...and to prompt you for offset numbers if they aren't in the CL data).

(Also, we recommend that if you want the "default" work offset to be something other than 54, then add a WorkDefault line to your format.)


That's it. But, what if you DON'T want work offsets in your NC programs? To completely eliminate work offsets from appearing in the code, you must do 2 things: 1. Eliminate all reference to work offsets in your template file - that is, make sure that you are NOT using the Work or WorkDefault command, and make sure that you are not using the [Work] variable in any of your sequences. 2. Do NOT allow any work offset numbers (other than ZERO) into your tool path data (CL file). NOTE: If you have done step number 1 (eliminated 'work' from your PostForm), but your tool path (CL) data still contains non-aero work offset numbers, THE POST WILL DISPLAY AN ERROR MESSAGE AND ABORT! (Because work offsets are just TOO important to leave to ambiguity!) Handling 'non-standard' work offsets (G54.1 P_ , G15 H_ ... etc.) Many machines now support 'extended work offsets' or require the use of work offsets that do not follow the traditional 'G54 to G59' scheme. Here are some examples... Fanuc 'extended offsets': up to P48 or beyond: G54.1 P1 G54.1 P2 G54.1 P3 ... etc. Siemens style work offsets: G15 H1 G15 H2 G15 H3 ... etc. Fortunately, most of these can be supported by the use of a single Replace command coupled with a unique letter. Here's a good way to do it: First, in the letter formats, add a unique letter (that will only be used for work offsets): p >3

The letter that will be 'replaced'

Next, add the Replace command that will replace the p with all of the code needed, up to the actual work offset number: Replace 'p' with 'G54.1 P'

Then add the related work offset commands in the 'commands and switches' section: Work p WorkDefault 1

Finally, in the sequences, always use the unique letter (in this case, p) for your work offsets: ... p[Work] ...

In the case of the Siemens post, we would do the same as the above with the exception of the Replace command, which would read: Replace 'p' with 'G15 H'

Details, details, details... Now, the logic behind how PostHaste actually DOES all of this dirty work (and exactly how it affects your finished programs) may still be a bit of a mystery to you. If you want to know "everything you ever wanted to know about how PostHaste handles work offsets but didn't really know what to ask", then read on - all of the gory details about each of these factors is discussed below - including, of course, their effect on the finished programs.


If you're not that ambitious, then just remember that the information is here if you should ever need it... The Work line

In the 'miscellaneous parameters' section of the template , the Work line does 3 things. 1. It tells the post that there must be work offset codes placed into the finished program. (Whether or not the [Work] variable is ever used in any sequences.) By default, the post puts the work offset into rapid moves. (This is a modal function - it will only output it - once - after every change in the [Work] value.) NOTE: IF YOU USE A RAPIDCODE SEQUENCE, YOU WILL BE OVERRIDING THE POST'S AUTOMATIC WORK OFFSET OUTPUT. So... make sure that you include a "G[Work]" (or equivalent) in any RapidCode sequence that you use. 2. It tells the post what letter to place before the work offset when it is necessary to output one. The post will automatically put in the code whenever the work offset is CHANGED somewhere in the job. The G54 (or equivalent) will appear on the line with the next X,Y and/or Z movement (rapid OR feed move). Please note that Use of the "Work G" line will NOT tell the post to output the work offset at the beginning of the program - to control the exact location, we recommend that you put a G[Work] (or equivalent) somewhere in your 1stToolChange and ToolChange sequences. 3. Finally, it tells the post that if, while reading from the CL data, a movement is found before the work offset value has been set, to ask you for the work offset number to use. (See "WorkDefault" below.)

The WorkDefault line

The number on the WorkDefault line is simply the default value that you see when the post asks you to enter a work offset number. If you do not have a WorkDefault line, the default will be 54 (as it is the first work offset number in most popular milling controllers). NOTE: Most Fadal users will want to use "Work E" and "WorkDefault 1" - which will correspond to an E1 code being placed in your programs (upon your approval). Note: Whatever the default number is, the post will NEVER put the "default" work offset into your code "automatically" - it will always ask you for the value first (that is, again, if there is NOT one in the incoming CL data).

The [Work] variable (used in the sequences)

The [Work] variable lets you determine exactly where the work offset codes should be placed in your finished program. As mentioned above, we recommend that you put them in your 1stToolChange and ToolChange sequences, like the example here: 1stToolChange T[Tool] M6 M[Direct] S[Speed] G0 G[Work] X[H] Y[V] G43 Z[D] H[Lcomp] M[Cool] End

<<< Here's the G[Work]


NOTE: The [Work] variable also performs exactly the same functions as the "work g" line discussed above - the letter before the first [Work] variable in your machine format becomes the letter that the post will output if the work offset is changed later in your program. Understanding that, you will realize that this means that if you use a [Work] variable in your format, that you don't need a "Work G" line (as mentioned above in the "in a nutshell" section).

Changing [Work] offsets between drilling cycles.

Even though the G[Work] is automatically output in the post's 'default' rapid moves, normally you won't see G54's (et al) between drilling cycles. This is because most machines don't require rapid moves between drilling cycles, so PostHaste does NOT output them by default. (Hence you normally won't see G54's being output between drilling cycles.) HOWEVER, adding [Work] changes between drilling cycles is very straightforward; just add G[Work] to your drilling cycles. EXAMPLES: Choose either one of these easy methods: 1. To get a "G54" on the G81 line, simply add G[Work] to your "G81" line like this: Drill G[Work] G81 X[H] Y[V] Z[D] R[RLevel] F[FRate] End

This will result in outputting your drilling like this: G54 G81 X2. Y2. Z-0.2 R0.05 F30.0 G80 G55 G81 X2. Y2. Z-0.2 R0.05 F30.0 G80 ...

2. To get the G54 BEFORE your "G81" line, Add G[Work] on its own line like this... Drill G[Work] G81 X[H] Y[V] Z[D] R[RLevel] F[FRate]

...which will result in drilling like this: G54 G81 X2. Y2. Z-0.2 R0.05 F30.0 G80 G55 G81 X2. Y2. Z-0.2 R0.05 F30.0 G80 ...


Getting rid of redundant G54 (et al) codes

Sometimes, when you have used the [Work] variable in several places in your template, you may get redundant G54s (as you might if you have [Work] in your ToolChange sequence and you used the above methods of outputting G54 between drilling cycles) like this: T2 M6 G0 G90 G54 X2. Y2. S6000 M3 <<< This G54 is output by the ToolChange sequence... G43 Z1. H2 M8 G54 <<< ...and this G54 is output by the Drill sequence. G81 X2. Y2. Z-0.2 R0.05 F30.0 G80 G55 G81 X2. Y2. Z-0.2 R0.05 F30.0 G80 ...

If you want to get rid of the redundant G54 (on 1st drill cycle after ToolChange), then simply use a different letter for WORK, and format that letter to output a modal G. These lines from a sample template show how we used a lower case "g" to do the job: g >2 G Modal

<<< Add this line to the 'letter format' section,

Work g

<<< Add this line to the 'commands and switches' section,

ToolChange T[Tool] M6 M[Direct] S[Speed] g[Work] G0 X[H] Y[V] G43 Z[D] H[Lcomp] M[Cool] End Drill g[Work] G81... end cancel ...

<<< Check ALL of your sequences; use g[Work] here...

<<< ...and here. (AND everywhere else [Work] is used!)

Note: If you use this tactic, make sure that you always use the proper letter (in this case 'g') with [Work] - throughout your format.


7. Special features This section lists special features of PostHaste that help in formatting for various conditions. These features include... •

using equations (including Mathematical symbols and functions) in your templates

outputting text directly (and the use of text variables)

suppressing line numbers on individual lines and outputting blank lines

the “Search and replace” function

“If / Else Logic” to control the output of certain lines of code

Outputting subs (subprograms or subroutines), and the automatic 'multiple part' program feature

the PostHaste.log file, which helps you 'debug' your template


7.1 Using Equations (mathematical operations) Instead of simple numbers or variables, you may use equations in any area within any sequence wherever you would like to output or reference values that are based on mathematical relationships between 2 or more variables and/or numbers. In the following places, you may use equations: - To 'output' a numeric value following any formatted letter inside any sequence - As the 'second parameter' in a Set command - in a File Alias command Here are some examples (the equations are in bold type): StartCode Set [Val2] to [Program#]+53 ... ToolChange File Alias 1 'SUB' 7999+[Tool] '.NCC' ... G0 X[H]/2 Y[V] (Note that the equation follows the letter X; the letter X is NOT part of the equation.) ... LineCode X[H]*cos([RotAngle]) Y[V] Z[D] end.

(the asterisk * does a 'multiply' function)

Needless to say, there are many things that you can do with equations - the possibilities are endless... ...But you must be careful not to attempt 'impossible' or 'undefined' mathematical operations. Examples: The following equations would yield an 'undefined' result (and cause an error): (when [H] is zero, this would cause a 'divide by zero' failure.) (when the value [V] is zero, the 'arc tangent' function fails as well.)

3.1416/[H] atan([V])

7.1.1

Mathematical symbols and functions

You may use any of the mathematical symbols and functions in the tables below. First, the mathematical symbols: Symbol

Meaning

Example

Notes:

* / + -

multiply divide add subtract

X2*[H] X[H]/2 D[Tool]+20 X[H]-8.03

^

'raise to the power of'

Y[H]^2

Outputs X with 'double' the normal [H] value. Cuts the X value in half by dividing by two. (Be careful NOT to divide by zero!) A handy way to offset your Diameter Offset number by 20 (or any number) Subtracting is a simple way of making a value 'incremental' from another! In this case the value output would be the [H] dimension 'measured incrementally from X8.03'. 'to the power of 2' means 'squared'.


... and the functions. Please note that functions always use parentheses - put any value (or other equation) inside the parentheses, and the function returns the corresponding numerical value. Function

Meaning

Example

Notes:

abs( )

Absolute value

Zabs([D])

sqrt( )

Square root

Rsqrt(sqr([H])+sqr([V]))

You might use this in a Bridgeport drilling operation where Z values do not need the minus sign. Outputs R with the 'polar' distance from the origin to the current XY (HV) position

sqr( ) sin( )

Square (raise to the power of 2) Sine

(See above) Ysin([Sweep])

cos( ) tan( ) asin( )

Cosine Tangent Arc Sine (Inverse sine)

Casin([H]/[Val2])

Outputs the letter C with the angle that is the 'arc sine' of [H] divided by [Val2].

acos( ) atan( )

Arc Cosine (Inverse cosine) Arc Tangent (Inverse Tangent)

Aatan([V]/[H])

Outputs the letter A with the 'polar angle' from the origin to the current XY (HV) position. Use an IF structure to keep this from being executed when [H] or [V] are zero!

ln( ) log( )

Natural Logarithm Logarithm

Outputs the letter Y with the sine of the current arc's 'sweep angle'

Hierarchy of operations & use of parentheses You can do quite advanced calculations, and all calculations are done in 'standard hierarchical order': functions first, multiplication and division next, addition & subtraction last. You may use parentheses to control the hierarchy of processing - as in this example: Y([V]+2)*tan([CAxis])

The parentheses result in adding 2 to [V] before multiplying by tan([Caxis]). Without the parentheses, the multiplication would be done first, then the addition.

7.2 Suppressing line numbers and outputting blank lines PostHaste regards the exclamation point â&#x20AC;&#x153;!â&#x20AC;? as a special character that can be used for 2 purposes... Suppressing line numbers First, it can cause the post to suppress line numbers as in the 'Program#' line of this example: StartCode !0 O[Program#] '!' Suppresses N number... G90 !0 '!' by itself causes blank line in output. G54 End


This causes the first four lines of the NC program to look like this: O1234 N1 G90 N2 G54

To achieve the desired effect, the exclamation point must be the first character on the line, so to use it for these purposes, you must have this line as the first line of the letter format section: ! 00

Outputting blank lines Also, if placed on a line by itself, the exclamation point will cause a blank line to be output (as in the blank line in between the G90 and G54 lines in the example above). If, for instance, you would like a blank line to appear at every tool change (to make it easier to see them in the program), you could do it this way: ToolChange M9 G28 G49 Z0 !0 << A blank line will appear here. N[Block] M6 G0 G40 G80 G[Work] X[H] Y[V] G43 Z[D] H[Lcomp] M[Direct] S[Speed] M[Cool] End

7.3 'Text output' and text {variables} There are several things that you can do to process or output text. In our context, 'text' means any information that does NOT fall into the strict adherence to the EIA standard of 'a letter followed by a number'. Examples of text are: 'ABC' or 'TOOL DEF' or 'CYCLE83' There are quite a few different functions of the post that have to do with text... •

You can output text directly by simply placing it within any sequence, enclosed in 'single quotes' or “double quotes”. This is called 'hard-coded' text, or 'direct text' output. (See examples below.)

You can use text and text variables (see below) to... - specify file names and - output comments based on file names and other text information from the CL file.

The following sections discuss some of the possibilities.

7.3.1

Direct ('hard-coded') text output

To include text in your programs, just enclose the desired text in 'single quotes' or “double quotes”. You can use either one, but the starting and ending quotes must match. In other words 'this is bad” because the start quote is a single quote and the end quote is a double quote. Having mismatched quotes in your template will cause problems. (We will discuss this in more detail below.) Examples

1. If you would like to put your company name at the top of each program, then you could do so like this:


Put this in your template...

...to get NC code output like this:

StartCode “%” O[Program#] '(PROGRAM BY FRED FARKLE FOR XYZ INC.)' end

% O123 (PROGRAM BY FRED FARKLE FOR XYZ INC.)

2. If your machine requires a series of characters or 'man-readable' words to start a drilling cycle (for example, “MCALL CYCLE83” instead of “G83”) then you can simply enter the text directly in your sequence like this: Put this in your template...

...to get NC code output like this:

Peck 'MCALL CYCLE83' X[H] Y[V] Z[D] R[RLevel] F[FRate] end cancel

MCALL CYCLE83 X1.11 Y2.22 Z-3.33 F20.

To output text that includes quotes (in other words, if you need to output “quote marks” into your program), see the Notes regarding use of 'quotes' discussion and examples under “Search and Replace” (section 7.4) below.

7.3.2 Regarding use of 'quotes' (and outputting quotes in your code) When working with older formats, you may see "double quotes" instead of 'single quotes'. This is OK, PostHaste accepts either type of quote marks. We do this so that you can include quote marks inside the actual text phrases. Just make sure of 2 things: 1. If you use either type of quote character inside the phrase, use the other type of quote at the start and end of the phrase, and 2. that you start and end the phrase with the same type of quote mark! Examples:

Notes:

"This 'phrase' is legal." 'So is this.' "This one won't be a problem, and" 'this one is "OK", too.' "But THIS one is bad,' 'this one is BAD also," 'and this one won't work either.'

Single quotes are allowed within a double-quoted phrase. Normal. Use double quotes when you need to have a single quote (like “won't”) in the text. Double quotes are OK inside a single-quoted phrase. Starts & ends with different quote types. Starts & ends with different quote types. The word won't includes a single quote (an apostrophe). To fix this problem, use "double quotes" to surround the phrase instead of 'single quotes'.

7.3.3

Using {text variables}

Text variables are the only variables that do not output numeric data - they output text. You can instantly tell the difference between a text variable and a numeric variable by the type of bracket that is used: Numeric variables have [square brackets] and text variables have {curly brackets}. Since these output text (not numeric values), they cannot be associated with a letter (as numeric variables always are, e.g.


“M[Cool]”). Text variables may be simply output as 'free-standing' text (that is, without a letter in front of it). In other words, you would NOT do this: G{PartNo}

<< This is NO GOOD!

Examples

1. If you want a comment in your NC program that shows the name of the template file, you may include one of these in your StartCode (or any other) sequence: Sample template lines: '(' {TemplateName} ')' '(' {TemplateName} {TemplateExt} ')'

Sample output: N20 (Fanuc 6T Generic) N20 (Fanuc 6T Generic.pT2)

2. Text variables and/or numeric variables can also be used (with or without quoted phrases) to construct file names in the File Alias command like this: File ALIAS 1 {CLPath} 'YASDA\O' [Sub]+[Val6]

Note that you can use numeric variables (in the above example [Sub] and [Val6]), and you can even use equations ([Sub]+[Val6]) when building the file alias.

7.3.4

Important information regarding text and text variables:

There is a wide range of things that you can do with text and text variables, as well as some capabilities and limitations you need to know about. See section 5.3.4 for more details on the File commands, including File Alias. See section 9.1.1.6 (in Appendix A) for a list of all text variables.

7.4 “Search and Replace” Lines like the following ones (which are used in some of the older Heidenhain 'conversational' formats) can be added to the template to “Replace” certain phrases with others. Replace 'G2 ' with 'DRreplace "G3 " With 'DR+ ' REPLACE 'T' WITH "TOOL DEF "

Notice that both the phrase to be replaced AND the new phrase are enclosed in quotes. This is necessary in order to be able to search and replace phrases with embedded spaces (such as “TOOL DEF”). Unlike most other areas of the template, PHRASES WITHIN QUOTES ARE ALWAYS CASE SENSITIVE! So, don't use “g3” when you really want to search for “G3”. (The words REPLACE and WITH, however can be upper, lower, or any mixture of cases as in the example above.) Also, if you were paying attention, you noticed that some of the phrases in the example above use 'single quotes' and some used “double quotes”. This is fine as long as each phrase starts and ends with the same kind of quote marks. See section 7.3.2 regarding use of quotes.


How Search & Replace works Each line of outgoing NC code will be scanned as many times as there are “Replace” lines in the machine format, and if a “replace” phrase is found, it will be replaced ONLY ONCE (unless you use the ALL option discussed below), then the post will go on to scan the same line again for the NEXT “Replacement”. Example: Using the Replace commands shown above, the line... G2 T1 G2 X0

...would end up being output as: DR- TOOL DEF 1 G2 X0

(Notice that the second G2 is NOT replaced because it was found [and replaced] earlier in the line.) Since the search and replace happens on a “per line” basis, it CANNOT be used to replace end-of-line characters, and cannot be used to “join” two lines into one. (To effectively 'join' two lines, see the NoEOL command in section 5.3.5.) Sometimes, “Search and replace” works TOO good... notice also, that spaces within the search phrase can be used to prevent unwanted replacements. In the first example, if we had used a “G2” and “DR-“ (without the trailing spaces), it would cause all “G28” words to end up as “DR-8” ! Avoid 'double-replacements'! Also, if more than 1 “replace” line is used in a format, THEY ARE PERFORMED IN THE ORDER THAT YOU SPECIFY THEM! This means that there is a possibility that you can inadvertently “double-replace”. Example of 'double-replacement' (don't do this!): If the following replace lines are used in this order... REPLACE 'T' WITH 'TOOL DEF' REPLACE 'D' WITH 'DIAM.'

...then the “D” in “TOOL DEF” will be replaced with “DIAM. “ and will cause “T1” to be changed to “TOOL DIAM. EF 1” instead of “TOOL DEF 1”. To prevent 'double-replacements' from happening, just reverse the order of the “Replace” lines so the D is replaced BEFORE the T. NOTES: Limits are not checked on phrases that are the result of a “Replace” statement. In other words, if you inadvertently replace a phrase with another that is beyond a particular limit, then no warning will appear. The size of the “Search phrases” (the 1st quoted phrase in a “Replace” line) is limited to 16 characters, and the “Replace” phrase (the 2nd quoted phrase per line) is limited to 70 characters. The NoComment option If you want to prevent a 'replacement' from occurring within program comments, then add the word NoComment to the end of the Replace line like this: Replace 'A' with 'A-' NoComments


Notes re NoComment: - You may use either NoComment or NoCommentS: the post will figure it out either way. - Reminder: As always, the Replace command (still) only acts ONCE per line. - The NoComment option will only prevent the FIRST comment on the line from having a 'replace' performed. In other words, if there is MORE THAN ONE COMMENT on the line, the second comment will not be 'protected' from the replace. (This shouldn't raise any problems; I can't remember the last time I saw a line of code with more than one comment on it...) - The NoComment option may be used in conjunction with the All option below. (The options may be listed in either order.) The ALL option Unless you use the All option, a Replace command is only performed once per line of output. This means that if you have more than one occurrence per line of something that needs to be replaced, just add the word ALL to the end of the Replace line like this: Replace '_' with ' ' All

As mentioned above, the All option may be used in conjunction with the NoComment option like this: Replace ',' with ', ' All NoComments

Or: Replace 'X' with 'X-' NoComments All

NOTE: Since the All option causes the replacement process to repeat until all occurrences are replaced, be careful not to create an 'infinite loop' with your Replace...All commands. This happens when your 'new' phrase contains the 'old' phrase like this... Replace '99' with '999' All

... 99 becomes 999, which gets 'replaced' again and becomes 9999, then 99999, then 999999, etc. ad infinitum. If left unchecked, this would continue until all memory and disk space have been consumed, followed by a crash of your PC's operating system. (Suffice it to say that infinite loops are a bad thing...) Fortunately, we limit the post's 'replace... all' to 100 repetitions â&#x20AC;&#x201C; more than enough to get your job done, but far less than would ever cause any problems on your computer. PostHaste gives you a warning (and then aborts) if a Replace is repeated more than 100 times on any line of code.


7.5 If / Else Logic IF, ELSE and ENDIF statements can be used to cause PostHaste to either allow or disallow any lines in any sequence based on the mathematical relationship between any 2 variables and/or constant values. Here's a sample of a ToolChange sequence that uses if/then logic in 2 different places - first, to control dual-range spindle speed (M41, M42), then again to suppress the “pre-indexing” in the last tool change. (blank lines have been added for clarity to separate the "logic" sections from the rest of the sequence): ToolChange M9 G28 G49 Z0 S100 N[Block] M6 This 'IF' structure sets the 'gear range' (M41 or 42): if [Speed] > 500 G0 G40 G80 G[Work] X[H] Y[V] M42 else G0 G40 G80 G[Work] X[H] Y[V] M41 endif G43 Z[D] H[Lcomp] M[Direct] S[Speed] M[Cool] This one suppresses pre-indexing of the last Tool: if [NextTool] <> [Tool1] T[NextTool] endif End

...as you can see from the example above… •

either one or both of the 2 values on the if line must be a [variable]. It can even be a variable that is set from an ASK statement - letting you give the operator a set of processing "options"... let your imagination run wild!

The lines 'inside' the IF structure may be indented. (Note: They may be indented one space only! If more than one leading space is used, that line will become a 'comment' - ignored by PostHaste!)

Here are the actual “rules” that apply to the if / then logic: The IF line must have a variable or a number followed by a 1 or 2-character “logical operator”, then another variable or number. As usual, all items must be separated by a single space. The optional Else line and the required Endif line do not use any "parameters". Here are some sample "If" lines: IF [Val1] = 2 If [Tool] > 24 if [speed] <= 500

(Note: Just as with all variable, sequence and command names, please notice that the capitalization of the words If, Else and EndIf doesn't matter.)


Logical operators ('Equals', 'Greater than', etc.) This is a list of the legal logical operators that can be used on the if line: Operator > < = <> <= >=

Meaning “Greater than” “Less Than” “Equals” “does not equal” “is less than or equal to” “is greater than or equal to”

Other limitations that apply to the use of logic: •

IF can only be used within a sequence or canned cycle.

An ENDIF line is required (even if there are no more lines after ENDIF within that sequence).

The ELSE line is optional.

The IF, ELSE and ENDIF lines must have at least 1 line of "code" between them.

IF statements cannot be nested.

You are limited to 100 IF structures per template.

Testing 2 conditions: Using AND and OR with IF You can use the words AND and OR to make an IF function test for 2 conditions at a time as in the following examples: if [Tool] > 5 OR [Val1] = 1 ...do these lines... ENDIF if [LastHole] <> 1 AND [SpeedType] < 97 ...do these lines... ENDIF

7.6 Outputting subs (subprograms), and the automatic 'multiple part' program feature PostHaste can output NC program subroutines or subprograms (we will refer to these as 'subs'...) for either of two reasons: 1. To automatically create subs to achieve 'multiple-part programs' (where each tool's motion is put into a separate sub, and then the 'main' program consists of tool changes and sub calls), or 2. If your incoming CL data includes subs, and you simply want the post to output them accordingly.


7.6.1

Basic Fanuc setup example

In either of the above cases, setting up your template to output subprograms or subroutines (commonly referred to as “subs”) is usually quite simple. (We also give you ways to handle quite a few variations from the 'basic' setup shown in this example.) However, before getting into all of the details, here is an example showing what you would add to a typical Fanuc post template to add sub support. Just add the SubCall, SubStart and SubEnd sequences (and make sure the letters you need are formatted in the 'letter format' section of your template): SubCall Describes the code used to call subs from the 'main' program. G0 G[Work] X[H] Y[V] Z[D] M98 P[Sub] end SubStart O[Sub] G0 X[H] Y[V] End

The code that appears at the top of each sub.

SubEnd M99 End

The code at the end of each sub.

Between O[Program#] End

Code 'between' the last sub and the start of the 'main program' portion of the file. (See note below)

... that's all you have to do! PostHaste will apply these sequences whenever they are needed in the code to output your subs properly. Note: By default, PostHaste will output the subs before the main portion of the program. If you want the subs to be output after the main portion, use the Subs1st? switch (discussed below).

7.6.2

Automatic multiple part programs

This is an exceptionally useful feature of PostHaste, as many CAM systems do not do a good job of producing compact NC programs for 'multiple part' setups... PostHaste will do it for you. If your template contains the above sequences, PostHaste will automatically generate a multiple part program if there are no subs found in the CL file. When PostHaste creates a multiple part program, it creates a sub for each tool's motion. Therefore if your job uses 9 tools, there will be 9 subs generated. (If any tool is repeated later in the job, another sub will be made for that section of the program as well.) PostHaste then produces a 'main' program that (after each tool change) calls the tool's corresponding sub at each work offset. The number of work offsets will match the number of parts. This is an important point, because you are limited to the number of parts by the number of work offsets that are available on the machine. When a multiple part program is being generated, the post will ask you the following questions: •

“How many parts are there?” Remember - you are limited by the number of available work offsets.


“What is the first work offset number?” Work offsets will 'increment up by one' for each part. If you indicate 54 as your first offset, the first part will be G54, the second part will be G55, and so on. (You may use G55 or G56 [etc.] as the 'first' offset if you like - but just remember that by doing so, you are reducing the total number of parts you can cut because of the 'upper limit' of you available work offsets.)

“Do you want to 'reverse' the order of the offsets for each tool?” On setups where several parts are spread out over the length of a machine table, there is less rapid motion required if you 'reverse' the order of the offsets. For example, the first tool would work in the order from G54 to G59 (e.g. 'left to right'), then the second tool would start with G59 and work back to G54 (working from right to left). This feature eliminates the 'long' rapid moves from one end of the table to the other after each tool change, and thus reduces the overall cycle time on the job. (The time savings are especially noticeable on jobs with 'low cutting time per tool' and a relatively large number of tools.) 7.6.2.1

Sub numbering

For multiple part programs, the [Sub] number (the 'O' number at the start of the subs) is automatically incremented (starting at 1) each time a new sub is output. It is usually a good idea to 'add' the sub numbers to the [Program#] variable so that the subs will follow directly after your main program in the machine's 'directory' page. In other words, if your 'main' program number ([Program#]) is 2000, you would want the first sub to be 2001, the second 2002, etc. To do this, simply add the [Program#] to the [Sub] in your SubStart and SubCall sequences as shown here: SubCall Describes the code used to call subs from the 'main' program. G0 G[Work] X[H] Y[V] M98 P[Sub]+[Program#] end SubStart O[Sub]+[Program#] G0 X[H] Y[V] End

The code that appears at the top of each sub.


7.6.3

Sequences, variables and switches used for subs

The output of all code related to subs is controlled in the template by using the items in the table below. This table describes them briefly, and details follow in the next sections. Items:

Type:

Notes / Description:

Mandatory (for subs to be output properly)?

SubStart SubEnd SubCall Between

Sequence Sequence Sequence Sequence

Code output at the start of each sub. Code output at the end of each sub. Code required to call a sub. Describes any code that needs to be output between the 'main' portion of the program and the subs.

Yes Yes Yes No. (Only used for machines that require some special code to separate the 'main' portion of the program file from the 'subs' portion.)

[Sub] [SubLine]

Variable Variable

Either [Sub] or [SubLine] must be used. Either [Sub] or [SubLine] must be used.

[Times]

Variable

Outputs the “O” number of the sub. Outputs the number of the N word (line number) of the sub. See section 7.6.3.3 for details. Usually the L number on the M98 (sub call) line in Fanuc programs. See section 7.6.3.3 for details

RenumSubs? SpliceSubs?

Switch Switch

No (N is the default condition) No (Y is the default condition)

Subs1st?

Switch

See explanation below in section 7.6.3.4 Set this switch to 'N' if you want the subs to be output in a separate file (or files) from the main program. See section 0 for details See explanation below in section 7.6.3.4

7.6.3.1

Not needed if you are only using subs for multi-part formats. This is needed if the CL data ever indicates that a sub is to be repeated.

No (N is the default condition)

SubCall sequence

The SubCall sequence shows how the subs will be called from the “Main” portion of the NC program. (See the 'basic' example in section 7.6.1 above.) SubCall Describes the code used to call subs from the 'main' program. G0 G[Work] X[H] Y[V] M98 P[Sub]+[Program#] end

7.6.3.2

SubStart, SubEnd, and Between sequences

The SubStart and SubEnd sequences are used to describe how the subs start and end, respectively - as shown in the example above. The Between sequence is used to describe any special code that should go between the subs and the main program code (Use the Subs1st? switch [see below] to direct PostHASTE to put the subs either before or after the “main” portion of the program). Example: These sequences and switches (in addition to the SubCall, SubStart and SubEnd sequences in the example above) are used for some Fadal formats... Subs1st? Y


Between M17 M30 End

...because some Fadal machines require that the subroutines come before the main program and that there is a M30 between the 'subs' and the 'main'. 7.6.3.3

[Sub], [SubLine] and [Times] (sub variables)

The following variables give you control of formatting of NC programs using Sub-routines & Subprograms: The variables:

What they do:

[Sub] [SubLine]

This is the value of the sub number, and can be used in the SubStart and SubCall sequences as in the above examples. This is used in the SubCall sequence in place of [Sub] to call a sub by its “line” (sequence) or “N” number (as opposed to using the sub number itself). This is used to designate the number of times a sub repeats. This should only be used in the SubCall sequence as shown above.

[Times]

Here's an example of how you would use the [SubLine] and [Times] variables in your SubCall sequence: SubCall M98 P[SubLine] L[Times] end

7.6.3.4

Switches used to control subs

Here are more details on the formatting switches have been added to help you control other actions that are significant when using subs: Formatting switches:

What they do:

RenumSubs? Y

Use this line to indicate that you want the sequence (N) numbers to be reset at the beginning of each sub and at the start of the “main” program section. You may also use an N to prevent this action. Notes: 1. If this line is not used, then the default condition is not to restart the numbers (as if you used the N option). 2. Do NOT attempt to use the Y option if you are using the [SubLine] variable (discussed above). Use this line to indicate that you want the subs to be placed after the main portion of the program - change the N to Y to output the subs before the main program. NOTE: If this line is not used, then the default condition is to place the subs before the main portion of the program (as if you had used the Y option). See below...

Subs1st? N

SpliceSubs? N

SpliceSubs? switch

This switch can be used to tell the post to NOT include any subroutines in the main NC program file. Typically, when subroutines are used, PostHaste includes them in the main output (.NCC) file. To do so, it first writes the NC code contained in each sub into a temporary file - one for each sub - then when all of the code (for subs and the 'main' program) has been generated, PostHaste automatically 'splices' all of those temporary files together to form the final output file. If you do NOT want the subs to be 'spliced' together with the main program, use this switch setting to prevent it: SpliceSubs? N


The most common reason you would use this is if you want each sub (or all subs) to be output to it's own separate file (instead of into the main file). In order to do this, you would need to use File commands to control the output of the various 'subs' and 'main' portions of your code into the files of your choice. Here is an example of one way you could do this: SpliceSubs? N

Do NOT splice the subs into the main file because each sub is put into in separate file (example: MyPart-SUB2.DAT ).

SubCall File on Main only M98 'P' {CLName} '-SUB' [Sub] end

<< ...each sub is called by the FILE NAME of the sub (less the '.DAT').

SubStart File alias 1 {CLName} '-SUB' [Sub] '.DAT' << Each sub file name based on the CL name and sub #. File empty 1 File on 1 only << (Each sub is written into the file named above on the File alias line.) end

SubEnd M99 File on Main only end

<< After each sub is completely written, make sure that you go back to writing to the main file.

NOTE: Be careful using this switch! If you tell the post... SpliceSubs? N

...without properly routing the subs into the files you want (by using the File commands as demonstrated in the above example), then your subroutines will simply not exist in the final NC program! For more information on subroutines (including automatic generation of multiple-part programs) see section 7.6. For more information on use of the File commands, see section 5.3.4.

7.7 The PostHaste.log file (for â&#x20AC;&#x153;debuggingâ&#x20AC;?) PostHaste generates the PostHaste.LOG file (in the same folder as your PostHaste.exe file). This file is a "debugging" aid that is essentially a "merging" of the incoming CL data and the outgoing NC code. By looking at this file (in any text editor), you can see exactly which CL records produced each line of NC program. (The incoming CL lines are numbered for your convenience.) NOTE: This file is overwritten each time you run the post, so if you want to save it, you will either have to rename it or move it to another folder. The example below is an excerpt from a PostHASTE.LOG file. For your convenience, the incoming CL lines are numbered and a blank line is placed at the end of each section of NC code that is output. This visually 'groups' the code with the CL data that produced it. (Note: Shading has been added to this document to highlight the first few sections of NC code - shading will not appear in an actual PostHASTE.LOG file.


### This is the .LOG file produced during processing of c:\temp\drill.ncc. ### This file lists the CL data and the NC program data produced by it. ### (This file gets overwritten each time you run the post.) O1 G20 G90 3 >PARTNO / 1050-2207_WP 5 >MACHIN / MILL, 01 6 >UNITS / INCHES 7 >LOADTL / 5 11 >SPINDL / RPM, 500.00, CLW 12 >FEDRAT / 100.00, IPM 13 >GOTO / 0.00, 0.471000, 0.500000 G70 G50 G19 H0 M9 T5 G0 G32 G40 G80 M5 M9 M6 S500 M3 G0 X0 Y0.471 M9 D5 G43 H5 Z0.5 14 >CYCLE / DRILL, DEPTH, 0.093000, IPM, 5.00, CLEAR, 0.10 15 >GOTO / 0.00, 0.471000, 0.400000 G81 F5. R0.5 Z-0.193 G98 G0 X0 Y0.471 16 >CYCLE / OFF G80 … … 64 >FEDRAT / 100.00, IPM 65 >GOTO / -1.00, 0.906000, 1.125000 G1 F100. Y0.906 66 >SPINDL / OFF 69 >LOADTL / 6 74 >SPINDL / RPM, 500.00, CLW

75 >FEDRAT / 300.00, IPM 76 >GOTO / -1.205000, 0.00, 0.800000 G70 G50 G19 H0 T6 G0 G32 G40 G80 M5 M9 M6S500 M3 G0 X-1.205 Y0 M9 D6 G43 H6 Z0.8 78 >CYCLE / BRKCHP, DEPTH, 0.137940, STEP, 0.030000, $ IPM, 1.00, CLEAR, 0.00, RETURN, 0.50, $ DWELL, 1.00, TIMES, 1 79 >GOTO / -1.205000, 0.00, 0.400000 G73 F1. Q0.03 D0.05 V-0.03 R0.4 Z-0.1379 G98 G0 X-1.205 Y0 80 >GOTO / -1.00, 0.471000, 0.400000 X-1. Y0.471 Z0.2621 81 >GOTO / 0.00, 0.471000, 0.400000 X0 … … 86 >GOTO / -1.00, -0.471000, 0.400000 X-1. 87 >CYCLE / OFF G80 88 >FEDRAT / 300.00, IPM 89 >GOTO / -1.00, -0.471000, 0.450000 G1 F300. Z0.45 90 >SPINDL / OFF 92 >FINI G31 M30

This file is overwritten each time you run the post, so if you want to save it, you will either have to rename it or move it to another folder. “F.Y.I.” - Looking at the beginning of this log file also tells you two important things about how PostHaste works: 1. The StartCode (in this case, the first 2 lines of NC code) is always generated before any CL data is read. 2. The 1stToolChange sequence is always “triggered” by the first GOTO in the CL data. Inhibiting the log file for faster processing. If you need to process long jobs, inhibiting the automatic generation of the .log file may help the post run slightly faster when processing. If you would like to inhibit this feature, add the following line to your PostHaste.CFG file: Logging? N

The “N” (no) tells the post to NOT create a PostHaste.LOG file. If this line is omitted (or if you use “Y”), then the post WILL create a PostHaste.LOG file (the equivalent of “Logging? Y”).


8. “Special Case” Tactics & Notes This section of the manual covers some tactics that you can use to achieve NC code output to match some special cases that we've come across over the years. This section is by no means an exhaustive reference of all the things you can achieve, because the only limits are your imagination. This section is meant to help stimulate your imagination by giving a few examples of how we've used some of the formatting “tools” in the GS post to overcome some specific formatting problems.

8.1 Concerning incremental / absolute output and the [IncMode] variable The [IncMode] variable gives you a great deal of control over how the absolute/incremental codes are placed in your NC programs. Instead of “hard coding” a G90 or G91 in any sequence, you can use G[IncMode] . The difference is that when the tool motion file that comes from the CAM program designates which parts of the tool motion are to be coded in incremental or absolute mode, PostHaste automatically places the corresponding G code in the location you've specified with G[IncMode]. For the [IncMode] variable to work, the following line MUST be present in the template: Inc/Abs G 91 90

( Inc first, then Abs. )

If you don't have it, PostHaste will warn you to add it before it will process the tool motion. You can use [IncMode] in any sequence. Here are 2 examples: ToolChange T[Tool] M6 G0 G[IncMode] X[H] Y[V] S[Speed] M[Direct] G[43] Z[D] H[LComp] End Sub O[Sub] G[IncMode] end

[----IncMode established at each tool change...

[----IncMode established at each sub.

Note: A G90 or G91 (according to the Inc/Abs line as formatted above) will automatically appear in the NC code whenever the mode is changed by information coming in from the tool motion file. This will NOT happen if the [IncMode] variable is used as the “trigger” variable for an UPON sequence - because the post expects you to have formatted your UPON sequence to handle it properly.


8.2 How to format “P1=” type codes. If you will recall, in the very first pages of the post-processor manual, it is clearly stated that PostHaste is designed to output NC code such that EVERY “word” of the code is “a letter followed by a number”. However, you can use the “replace” feature to overcome this limitation. Here's a good example of a case where this can be done. Some machines require drilling (and other) parameters to be output in a way that requires more than just “a letter followed by a number”. For example, look at this peck drilling cycle: G83 X1.0 Y2.0 P1=.5 P2=.25

( P1 is the hole bottom Z, P2 is peck increment. )

To output this, use the following lines to your template: Peck G83 X[H] Y[V] a[D] b[Step] end replace 'a' with 'P1=' replace 'b' with 'P2='

Of course, you must make sure that the letters “a” and “b” have been formatted in the “letter format” section of the file by using lines like these: a >3.>4 b >3.>4

As you can see, the “replace” feature is limited only by your imagination. To see it in intensive use, look at a “Heidenhain Conversational” format.


8.3 'Block deletes' on multi-part sub calls In multi-part programs, it is helpful to have 'block delete' (/) characters on all sub calls except the ones operating on the first fixture location. This way you can prove out a program on only 1 fixture (by turning on your machine's block delete switch), then activate the other fixtures later by turning it off. Here's what you may want such code may look (especially note the lines in bold)... % O1 T1 M6 ( T1 - SHELL MILL [NO COOLANT]) N1 G0 G40 G80 G90 G54 X7.25 Y5. G43 H3 Z0.25 S8000 M3 G54 G0 X7.25 Y5. M98 P2 / G55 G0 X7.25 Y5. (All offsets except G54 have block delete...) / M98 P2 / G56 G0 X7.25 Y5. / M98 P2 / G57 G0 X7.25 Y5. / M98 P2 M5 G91 G28 Z0 M9 T2 M6 ( T2 - SPOT DRILL) N1 G0 G90 G57 X8. Y13.5 G43 H1 Z0.25 M8 S8000 M3 / G57 G0 X8. Y13.5 / M98 P3 / G56 G0 X8. Y13.5 / M98 P3 / G55 G0 X8. Y13.5 / M98 P3 G54 G0 X8. Y13.5 M98 P3 M5 ...

If this is the kind of output that you want, then you may achieve it by simply using an IF condition: SubCall Describes the code used to call subs from the 'main' program. IF [Work] = 54 G0 G[Work] X[H] Y[V] M98 P[Sub]+[Program#] ELSE '/ ' G0 G[Work] X[H] Y[V] '/ ' M98 P[Sub]+[Program#] ENDIF end

Please note the trailing space character inside the quotes. Remember - when text is output, the post does NOT automatically pad it with spaces, as it does the actual output 'words' (such as G0 or X[H]) when the "Spaces? Y" switch is used.


9. Appendix A - List of Variables Following are lists that describe all of the variables that you can use in the sequences. Because there are so many types of values that can be used in a machine program there are several pages of variables listed here. You certainly do not need to memorize all of the variables - they are here for your reference. (You may, however want to just â&#x20AC;&#x153;skimâ&#x20AC;? it to get an idea of what's available.) NOTE: You may see other variables in your template that are not listed here. This could happen in one of 2 cases: 1.

'User-defined' variable names may have been created (using a Rename command - see section 4.1.26) by the person who created or modified the template.

OR... 2.

We may have missed documenting some of them in this manual! (Sorry!)

SO... If you see a variable in your template that you don't recognize from the lists below, then first check all of the Rename lines in the template. If there is NOT a matching Rename line, then that means we missed documenting it! If this is the case, please notify us and we will make sure that it is added to future revisions of this manual. Categories of variables In the lists of variables below, there is a Category column. This is what each category means: Category

Relevance

Axis position Motion attributes Arc motion Drilling Tool Change Prompted

These are the actual positions of the machines axes. Various information about the movement (distance moved, feed rate, etc.) Variables that are used only in processing arc motions. Variables that are used only in processing drilling ('point to point 'canned' cycles. Information related to the tool change process, or attributes of the tool itself The values of these variables will be asked of the user when the post runs - they are generally NOT set by the incoming CL data. Variables used for calling and/or defining machine subroutines and/or subprograms. Variables that don't fit into any of the above categories

Subs General


The variables... In addition to supplying 'categories', we have grouped the variables into separate lists according to the areas of usage in the format. Generally, all of the variables in a list will be used in the same sequence (or related sequences). NOTE: Within each list, the variables are listed in alphabetical order.

NOTE: Variables marked with asterisk (*) are probably not supported by your CAM system, so you should generally avoid using them. (Although you may employ them as â&#x20AC;&#x153;general useâ&#x20AC;? variables by setting their values by using the Set command within the format.)


9.1.1.1

Variables that apply to movements in general

You can use these variables in any sequence that produces motion. (ToolChange, Index, RapidCode, LineCode, CwCode, etc.) Variable(s)

Category

Details

Related / similar items

AAxis, BAxis, CAxis Adir, Bdir, Cdir

Rotary motion Rotary motion

RotAngle

ADist, BDist, CDist

Rotary motion

CPref

Rotary motion

D Dist4

Axis position Motion attributes Motion attributes Motion attributes Axis position Motion attributes

The (angular) position for the rotary axes ON 5 (or more) AXIS POSTS. (4 axis posts usually use RotAngle.) Typically only available on 5 (or more) axis Mill posts (or MillTurns with more than 1 rotary axis). The direction (0 = no rotary motion, 1 = Ccw, 2 = CW) that each rotary axis is moving on the current move (4 axis posts usually use RotAxDir.) These directions follow the ISO standard for tool rotation. (See the 5 axis Addendum manual for details on this.) Typically only available on 5 (or more) axis Mill posts (or MillTurns with more than 1 rotary axis). The distance (in degrees) each rotary axis is moving on the current move (4 axis posts usually use Dist4.) You may Set this variable to indicate the "preferred C value for the post to output whenever the machine has to do a (relatively long) rapid move (where the tool is moved into ‘'tool shank vertical’ [“I,J,K = 0,0,1”] position) moves". This is only needed on machines with a C axis that has physical limits; user should USUALLY set this to the 'mid-travel' value of his C axis; this should minimize the occurence of ‘unwinds’ by setting the C axis to its ‘middle of range’. (default 0) to allow user to set “Depth” (Z) linear axis endpoint position of the current movement Similar to Hdist, Vdist and DDist, but this is the angular measurement of the current rotary axis move (4 axis milling applications only). The “degrees per minute” feed rate (used in rotary axis milling only).

DPM FRate H HCDC, VCDC

H2, V2

Motion attributes

HDist, VDist, DDist

Motion attributes

HVector, VVector

Motion attributes

InvTime

Motion attributes

Feed rate value. This outputs in the proper units (IPM, IPR, MMPM, Inverse time, etc.) as needed. Horizontal (X) linear axis endpoint position of the current movement. "CDC" (cutter diameter compensation) vectors - used by some older Cincinnati machines. NOTE: For these to be active, the CDC command must first be specified in the “Commands & Switches” section of your post. Example: CDC P Q (4 axis Wire EDM posts only:) These hold the X and Y positions of the endpoint of the current movement (Rapid, feed or arc) for movements on the secondary (auxilliary) plane. These variables hold the linear distances that each axis is to travel on the current move. These are SIGNED (+ or -) values: if X is moving in the negative direction, [HDist] will be a negative value. These 2 values indicate the (vector) direction of the first completely compensated cutting move. They are used on machines that do not have “look ahead” ability to indicate which way the tool is going to go on the move AFTER the infeed. You will notice that they are used on the INFEED line of the Fanuc 3000C format. The reciprocal of MoveTime - “Inverse time” is a method that many milling machines equipped with rotary axes use to determine the actual feed rate. For those machines, this value is used instead of FRate.

AAxis, BAxis, CAxis, RotAxDir

HDist, VDist, DDist, Dist4

Unwind sequence

H, V, LastH, LastV, LastD HDist, VDist, DDist FRate, InvTime Plunge, FeedType, DPM, InvTime V, D, LastH, LastV, LastD IVect, JVect, KVect

H, V, Hctr2, VCtr2

Dist4, MoveLength

FRate variable, RotaryFeed command


Variable(s)

Category

Details

Related / similar items

IVect, JVect, KVect

Motion attributes

HCDC, VCDC, NormH, NormV, NormD

LastH, LastV, LastD, LastRotAng

Axis position

The 3 components of the unitized vector that describes â&#x20AC;&#x153;3D offsetâ&#x20AC;? - used only for machines that support this type of offset and where the incoming tool motion (CL) file provides this information. The post will not output these vectors automatically; the LineCode sequence is typically used to output these values if the machine needs them - as in this example: LineCode G1 X[H] Y[V] Z[D] I[IVect] J[JVect] K[KVect] F[Frate] end These hold the H, V and D and rotary (milling 4th axis) values that were previously output (typically the XYZ values of the endpoint of the previous movement). In other words, these values typically indicate where the tool is immediately before the current move is processed & output. BUT THAT IS NOT ALWAYS THE CASE. READ THE IMPORTANT INFORMATION BELOW REGARDING THE USE OF THESE VARIABLES.

H, V, D, RotAngle

Beware outputting (and calculations using) [LastH], [LastV] or [LastD]: Since the value in [LastD] (for example) gets updated IMMEDIATELY (to the current [D] value) upon [D] being output, you must check or use [LastD] in any output BEFORE [D] IS OUTPUT! This is why in the helical arc examples shown in section 4.2.7.1 we have the K value on the line BEFORE the Z value. (If we put it after Z, then [LastD] would have already been updated, and would be equal to [D].) The same is true with the variables [LastH] and [LastV]. If you need to use the value of [Last_] variables in several places in a sequence, then a way that you can get around this problem is to 'memorize' the [Last_] value into another variable, then use that variable instead. Here's a good example - in this RapidCode sequence, we have added 'Z safety logic' to help prevent crashes, so the first thing we do is memorize the [LastD] value: RapidCode Set [Val1] to [LastD] Set [Val2] to [D]

MoveLength

Motion attributes

Memorize "From" & "to" Z val's

if [Val2] < [Val1] G0 X[H] Y[V] Z[D] endif

Going down? XY first, then Z.

if [Val2] = [Val1] G0 X[H] Y[V] Z[D] endif

Same Z... Output XYZ together

if [Val2] > [Val1] G0 Z[D] X[H] Y[V] endif end

Going up: Z first, then XY.

This is the total distance from the start to the end of the current move, measured "as the bird flies" (not around arcs). It is essentially the hypotenuse of the "3D triangle" defined by the start and end points of the current movement. (This is always a positive value.)

Hdist, Vdist, DDist


Variable(s)

Category

Details

Related / similar items

MoveTime

Motion attributes

InvTime, MoveLength, TotalCutTime, TotalCutDist

NormH, NormV, NormD

Motion attributes

Pitch

Drilling, Threading

PolarAngle

Motion attributes

The length of time (in minutes) that the machine should take to complete the current movement. (Calculated by dividing MoveLength by the [IPM or MMPM] feed rate.) These variables define the 3D compensation vector used to indicate 3D offset direction when machining a 3D surfaces. They are ONLY set when they are read from the '3rd triplet' of GOTO records (after first being activated by a MODE or APPLY record like this): MODE/3DCOMP,ON or APPLY/3DCOMP,ON These variables can be used in the LineCode sequence like this: LineCode G1 X[H] Y[V] Z[D] I[NormH] J[NORMV] K[NORMD] F[Frate] end This is the reciprocal of the thread lead (1 / lead). Example: for a 1/4-20 thread, the lead is .05, so [Pitch] = 20 (which is 1/.05). It gets set during TAP cycles or when reading THREAD information from the CL file. (Typically used for MillTurn machines when milling on the face of the part…) This is the (typically C axis) angle of the current move’s endpoint (with 0 degrees being along the X+ axis direction). This is almost always used in conjunction with the PolarDist variable like this:

IVect, JVect, KVect

PolarDist, PolarBreak

if [Mode] = 3 and [IVect] < .99 Face (Polar) Milling: G1 X[PolarDist] Z[D] C[PolarAngle] F[Frate] endif

PolarBreak

Motion attributes

PolarDist

Motion attributes Axis position

RotAngle RotAxDir V RLevel TotalCutDist

Motion attributes Axis position Motion Attributes Motion Attributes

HOWEVER, you may use PolarDist and PolarAngle whenever you need to output the ‘polar’ location of the current move’s endpoint (or the current hole lcation, in the case of drilling cycles); PolarDist will indicate the distance of the current endpoint from the origin, and PolarAngle will be the angle (measured in ‘CAD standard’ method: 0 degrees is “3 o’clock”…) On MillTurn machines, when this variable is set to a non-zero number, the post will break lines and arcs that are milled on the 'face' of the workpiece (typically in the XY plane) into short linear polar (typically X,C) moves. This allows milling on the face of parts on MillTurn machines that do not have a Y axis. If this is what you want to do, then Set [PolarBreak] to the 'chordal deviation tolerance' that you want to hold on face contour milling operations. Almost always used in conjunction with PolarAngle – see discussion re PolarAngle above. The (angular) position for the milling rotary axis ON 4 AXIS MILLS ONLY. (5 axis posts MUST use AAxis, BAxis and/or CAxis instead!) Set to 1 when the milling rotary table is to move counterclockwise, and -1 when clockwise. Vertical (Y) linear axis endpoint dimension... Vertical clearance: the lowest of the two rapid levels. (Usually the R value in a canned cycle - mill only.) This is an ESTIMATE of the total distance the tool has traveled (so far) while in FEED mode. (Not rapid.) This is typically used in the EndCode sequence to display the overall estimated CUTTING (not including rapid) time as in this example: EndCode M30 %0 '(EST._FEED_TIME:_' t[TotalCutTime] '_MIN._[' t[TotalCutDist] '_IN.])'

End

MaxRad command, PolarDist and PolarAngle variables

PolarAngle, PolarBreak LastRotAng, AAxis, BAxis, CAxis RotAngle, Adir, Bdir, CDir H, D, LastH, LastV, LastD

TotalCutTime, MoveLength, FileSize


Variable(s)

Category

Details

Related / similar items

TotalCutTime

Motion Attributes

This is an ESTIMATE of the total TIME (in minutes) that the tool has spent (so far) while in FEED mode. (Does not include rapid moves.) See usage example immediately above.

TotalCutDist, MoveTime, FileSize

9.1.1.2

Variables that can be used to format arc movements

These variables are only used in the ArcCode sequence. (Note - in older posts, there may be CwCode and CcwCode sequences instead of a single ArcCode sequence. Variable(s)

Category

Details

Related / similar items

ArcDir

Arc motion

All other variables in this chart.

ArcPlane ArcRad

Arc motion Arc motion

The “Direction numnber” of the arc. The number is set with the CW and CCW commands. For instance, if you have the following CW and CCW commands in your template… Cw G2 Ccw G3 …then [ArcDir] will be 2 for clockwise arcs, and 3 for counter-clockwise. ArcDir is typically used with the letter G (in the ArcCode sequence) like this: Ccw G[ArcDir] X[H] Y[V] … See the discussion of the ArcPlane command in section 4.2.1 The radius of the arc.

ArcStartH, ArcStartV EndAng HCtr, VCtr, DCtr HCtr2, VCtr2

Arc motion Arc motion Arc motion

Ival, Jval

Arc motion

Normal1, Normal2, Normal3

Arc motion

StartAng, EndAng

Arc motion

Sweep

Arc motion

Arc motion

These variables hold the horizontal and vertical coordinates, respectively, of the start point of the current arc. See discussion of StartAng below. Absolute (X,Y,Z respectively) location of the arc center. Absolute location of the arc center – for arcs on the ‘auxilliary’ (or secondary) plane. The I and J values for the arc center. These will be either absolute or incremental (from the arc startpoint) depending on the CtrIncremental? switch setting. These variables hold the X, Y and Z components (respectively) for the “normal” vector of the most current arc. This vector describes the ‘axle’ of the arc and is usually set to 0,0,1 for Counter Clockwise arcs and 0,0,-1 for Clockwose. (Note - Unigraphics posts are exactly the opposite. See the Unigraphics? switch.) Ouputs the starting and ending angles of the current arc. (Angles will be in the range of 0 to 359.999, with “3 o'clock being 0 degrees, positive angles going ccw.) This is used to output the span of an arc (measured in degrees). This can be done by including it in the ArcCode (or CWCODE and CCWCODE) sequences (see below). The value output will be negative (-) for Clockwise arcs, and positive (+) for Counter-clockwise arcs. Therefore, if you need the output value to always be positive, then make sure that the letter you use it with is formatted with no minus sign (-). (Likewise, if you need to reverse the sign so that CW arcs are positive sweep and CCW are negative, then use the MULT modifier to multiply the letter's value by negative 1.)

ArcPlane command All other variables in this chart. H, V StartAng All other variables in this chart. HCtr, VCtr, H2, V2 HCtr, VCtr

IVect, JVect, KVect

All other variables in this chart. All other variables in this chart.


9.1.1.3

Variables related to “point-to-point” Drilling cycles

Some of the sequences that these variables are used in are Drill, Peck, Tap, etc. Variable(s)

Category

Details

Related / similar items

Cycle

Drilling

Tap

Dwell LastHole

General Drilling

See discussion of this in section 9.1.1.4 – as this variable is normally used in ToolChange and 1st ToolChange sequences. Dwell time (measured in seconds) at the bottom of a hole. This variable is automatically set to 1 when processing the last hole (and ONLY the last hole) in a point-to-point sequence. It is usually used in an IF statement to add or remove certain codes when processing the last hole of a drill cycle. The following example shows how to use LastHole in an IF structure (see "If/Then Logic") to get a special code (in this case "G98") on the last hole. Drill 5

[Rigid]

(first 5 lines are for the 1st hole in the cycle)

if [LastHole] = 1 G81 G98 X[H] Y[V] Z[D] R[RLevel] F[FRate] else G81 X[H] Y[V] Z[D] R[RLevel] F[FRate] endif if [LastHole] = 1 X[H] Y[V] G98 else X[H] Y[V] endif

Orient

Drilling

PeckClear

Drilling

Pitch

Drilling

PointH, PointV, PointD

Drilling

RetPlane

Drilling

end cancel [Orient] will be set to 1 when the CL file’s CYCLE record (describing the current drilling cycle) includes the minor word ‘ORIENT’ (otherwise [Orient] will be 0.) This is the “hole bottom clearance” distance that the post will use when generating peck drilling cycles. The default value is .050” unless the AskPeckClear? switch is set to Y (or if you use a Set command to set it to another value). Example - for metric posts we recommend:

[Rigid], [Orient]

AskPeckClear? switch (see section 4.1.2 )

Set [PeckClear] to 1

This is the reciprocal of the thread lead (1 / [Step]). Example: for a 1/4-20 thread, the lead is .05, so [Pitch] = 20 (which is 1/.05). Note; To use [Pitch], a FeedType command must be used earlier in the template. Most drilling Canned cycles require a Z value indicating the absolute Z position of the BOTTOM of the hole. That is why you usually see a Z[D] word in most Canned cycle descriptions. Some machines, however, require the designation of the Z level at TOP of the hole (the SURFACE of the part), rather than at the hole bottom. For those machines, use the PointD (“Point Depth”) variable instead. PointH and Point V are useful in 5 axis posts if you need to designate the XY location of the top of the hole. The value of the return plane mode (Initial plane = G98,“Rapid plane” = G99.) The actual number output depends on the “ReturnPlane” command (read about it in the Commands & Switches section earlier).

[Step]

[H], [V], [D]


Variable(s)

Category

Details

Related / similar items

Rigid

Tapping

[Rigid] is set to 1 when the cycle being processed is a rigid tap cycle. You may use an IF structure to output your TAP or Cancel sequences accordingly. Examples:

[LastHole]

Tap 6 If [Rigid] > 0 G93 G84 X[H] Y[V] Z[D] K[VBite] R[RLevel] F[FRate] else G84 X[H] Y[V] Z[D] R[RLevel] F[FRate] endif X[H] Y[V] W[RPlane] end cancel Cancel G80 if [Rigid] > 0 G94 endif end

Step

Drilling

Tap

Drilling

Note: Since [Rigid] is not reset until the start of the next cycle, it can be used in the CANCEL sequence as well as the TAP sequence. For PECK cycle: the “pecking” value (mill only; lathe uses SBite) For TAP cycle: the thread “lead” (the distance from one thread peak to the next). Note that [Step] is the reciprocal of [Pitch]; e.g. for a _-20 thread ([Pitch] = 20), the [Step] value is .05 (which is 1/20) See discussion of this in section 9.1.1.4 – as this is normally used in ToolChange and 1st ToolChange sequences.

[Pitch]

Tap


9.1.1.4

Variables set from the Tool or Tool Change information

These variables are typically used in the ToolChange and 1stToolChange sequences. Some of them are used other places as well. Remenber - variables marked with asterisk (*) are probably not supported by your CAM system, so you should generally avoid using them. (Although you may employ them as “general use” variables by setting their values by using the Set command within the template.) Variable(s)

Category

Details

Related / similar items (variables, unless noted)

Comp Cool

Tool change info Tool change info

LComp, DComp

Corner * Cycle

Tool change info Tool change info

Lathe Tool compensation offset #. (Not used for milling posts.) Coolant M code value (on, off, mist). Typically M8, M9 and M7, respectively The “corner radius” of the tool. The [Cycle] variable gets set - when there is a holemaking or threading cycle upcoming - according to the cycle type. Unless noted, the values listed below are for posts running in MILL mode. ADD 100 when post is in TURN (Lathe) mode: Note that [Cycle] is set to 0 when 'milling' (In other words, NOT doing any drilling cycles), and 100 when in 'turning' mode (e.g. turning or grooving). (Lathe) threading = 107 Drill = 13 (Remember: add 100 if in lathe mode...) LTap = 14 Peck = 15 Tap = 16 Ream = 17 Bore = 18 Back = 19 Custom1 = 21 Custom2 = 22 Custom3 = 23 ChipBreak = 28 CSink = 29 (Please note that there are 'gaps' in the numbering sequence above.) SO... If you want to differentiate between MILL and DRILL cycles in a mill post you would do something like this... ToolChange ... if [Cycle] = 0 Milling... milling does these lines else drilling does these... endif ... end ... and the same for a turning post, except that you would add 100 like this: ...

ToolRad, ToolDiam [Tap], [Rigid] and [Style] variables


Variable(s)

Category

Details

Related / similar items (variables, unless noted)

if [Cycle] = 100 ... DComp

CRC

Depth * Direct FeedType

Tool change info Tool change info Tool change info

Flutes *

Tool change info

IncMode

Tool change info

LastDep * LastTool

Tool change info Tool change info

LComp NextTool

Tool change info Tool change info

Plunge

Machining info

ILevel Range

Positioning Tool change info

SBite * SClear *

Tool change info Machining info

Side

CRC

SLeave *

Machining info

Speed SpeedType

Tool change info Tool change info

Spindle#

Tool change info

Diameter compensation offset #. (mill only) Usually used in the Infeed sequence, but some machines like this value put in the ToolChange sequences. Depth of the upcoming cycle (mill only) M code value of Spindle direction; Cw (3) or Ccw (4) G code value of IPM (usually 95), IPR (94) or “Inverse time” (93) designator that was set in the FEEDTYPE line (described above). (mill and lathe only) The number of flutes (cutting edges) this tool has (FYI: drills typically have 2). Will output the numerical value that corresponds to incremental or absolute program output according to the “INC/ABS” line (see above) - typically 90 or 91 (as in 'G90' and 'G91'). Depth of the previous cycle (mill only) The T# of the last tool used (commonly used in lathe programs to cancel compensation). Length compensation offset #. (mill only) The T# of the tool that is to be used AFTER the current tool. (Usually used to pre-select a tool for machines equipped with armtype tool changers.) In the program's final tool change, NextTool will be set to the first tool number used in the program (it will be equal to [Tool1]). (See the ToolChange sequence example at the top of section 7.5 for an example of how to suppress 'pre-selection' of a tool in the program's final tool change.) Plunge feed rate value (mill only). Usually used in the Infeed sequence. Z dimension used for lateral rapid moves (mill only). Spindle range number – read from the CL file's SPINDL record (the number following the RANGE minor word) “Side bite”: the XY step distance for multi-pass side milling Side (XY) clearance amount. (Typically the length of the 'Infeed' move [the move on which a G41 or G42 may appear to apply CRC.) Cutter compensation Left/Right side value (usually 41 or 42). Usually used in the Infeed sequence. 'Side Leave': Amount that the current toolpath will “leave” on the side of the contour being cut (amount to leave in X/Y) (Note: Sleave] and [Vleave] are not available with most CAM systems.) Spindle speed (usually an “S” value). G code value of RPM (97) or CSS (96) designator that was set in the SPEEDTYPE line (described above). (lathe only) The spindle number. (Only useful on lathes or MillTurns with more than 1 spindle.)

Lcomp, Tool, Side

D Speed, Range SpeedType

INC/ABS command

NextTool, Tool, Tool1 Dcomp, Tool LastTool, Tool, Tool1

FRate RLevel Speed, Direct Step Dcomp, Side

DComp Vleave

Direct, Range Speed, FeedType Turret


Variable(s)

Category

Details

Related / similar items (variables, unless noted)

Tap

Tool change info

Use the following IF structure in your ToolChange or 1stToolChange sequences to detect an upcoming TAP or LTAP cycle: If [Cycle] = [TAP] ... else ... endif

[Cycle] variable

The IF line in the example above is equivalent to... If [Cycle] = 13 OR [Cycle] = 14 ... See the [Cycle] variable for the list of cycle values.

Tool Tool1

Tool change info Tool change info

ToolDiam ToolRad Turret

Tool change info Tool change info Tool change info

UnitMode

Tool change info

VLeave *

Machining info

Work

Tool change / prompted (See “Details” column)

The [Tap] variable should actually be considered as a 'constant' (In other words, it is always set to the same value automatically by the post, and you should NEVER use a 'Set' command to change its value). “T” number The T number of the 1st tool in the program; this is usually referenced in the EndCode section to put the first tool back in the spindle (mill) or to return the turret back to tool position 1 (lathe) at the end of the program. The diameter of the tool. RADIUS value (1/2 the ToolDiam) of the current tool. This is the # of the turret now active. (Typically used in lathe or MillTurn posts only.) If your CAM system ever sets the [Turret] to 2, then the post will not run unless you add the HCode2, VCode2 and/or DCode2 commands to your template (to tell the post which letters you want assigned to the 2nd turret.). Read about these commands in section 4.1.16 Also available for turret 2 only is the RevTurret2? switch. Read about that in section 4.1.30 Will output the numerical value that corresponds to inch or MM programming mode according to the “INCH/MM” command. For example, if the following line is used... Inch/MM 70 71 ...then the following code (within a ToolChange sequence, for example) will output G70 when in INCH mode, and a G71 when in MM mode. G[UnitMode] 'Vertical Leave': Amount that the current toolpath will “leave” in the Z dimension for finishing with a later operation or tool. (Note: [Sleave] and [Vleave] are not applicable to most CAM systems.) Work offset # (usually in the range of 54 to 59). The user will be prompted for the first occurrence of this value if it is not found in the incoming CL data.

LastTool, NextTool, Tool1 LastTool, NextTool, Tool

ToolRad, Corner ToolDiam, Corner [Tool] & [Style] variables, RevTurret2? switch.

IncMode

SLeave

WorkDefault and Work commands. (See Appendix C for details on this topic!)


9.1.1.5

Variables used for subroutines or subprograms

You will find these variables in use in the SubStart, SubEnd and SubCall sequences. Variable(s)

Category

Details

Related / similar items

Sub

Subs

Times

SubLine

Subs

Times

Subs

This is the value of the sub number, and can be used in the SubStart and SubCall sequences. Typical usages: SubStart O[Sub] End SubCall M98 P[Sub] L[Times] End This is used in the SubCall sequence in place of [Sub] if the machine must call a sub by its starting block (N) number (as opposed to using the sub number itself). SubCall M98 P[SubLine] End This is used to designate the number of times a sub repeats; it is usually used only in the SubCall sequence.

9.1.1.6

See [Sub] details above for an example of how this is used in SubCall sequence.

Text Variables

These are the only variables that do not output numeric data - instead they output text. You can instantly tell the difference between a text variable and a numeric variable by the type of bracket that is used: Numeric variables have [square brackets] and text variables have {curly brackets }. See section 7.3 for details on... - how to output text, - outputting text variables and - using text and text variables in the File Alias command. Variable(s)

Category

{Partno}

Text

{CLPath} {CL Name} {CL Ext} {TemplatePath} {Template Name} {Template Ext} {OutputPath} {Output Name} {Output Ext}

Text Text Text Text Text Text Text Text Text

Details Use this variable to access or output the text in the PARTNO CL record. (Note: You can only use this variable with CAM systems that output APT-CL files that include a PARTNO record.) The 'drive and path' to the CL file. Example: C:\CLFiles\ The CL file name only (no path or extension) Example: Job123 The CL file extension (usually 3 letters) including the 'dot' Example: .INC The 'drive and path' to the format template file. Example: C:\PostHaste\Formats\ The format template file name only (no path or extension) Example: Fanuc 15iM, LeBlond The template file extension (usually 3 letters), includes the 'dot' Example: .pM3 The 'drive and path' to the final NC program file. Example: C:\NCPrograms\Mills\LeBlond\ The final NC program file name only (no path or extension) Example: Job123 Setup 1 The final NC program file name extension (usually 3 letters), includes the 'dot' Example: .NCC


9.1.1.7

Prompted Variables

The values of these variables may not be set in the CL data. If you use any of these variables in your format, then you will be prompted to enter their value(s) when the post starts processing your code. Variable(s)

Category

Details

Related / similar items

EndH, EndV

Prompted

ToolH, ToolV, ToolD

MaxRPM

Tool change / prompted (See â&#x20AC;&#x153;Detailsâ&#x20AC;? column) Prompted Axis position / Prompted

Position to which you would like the tool to come to rest at END of the program. Maximum spindle speed limit (used with Lathe only; usually in conjunction with a G50 or G92) The user will be prompted for the first occurrence of this value if it is not found in the incoming CL data. This number appears at the top of an NC program Tool change position. This is typically used in a ToolChange sequence to move the tool to a particular (prompted) X, Y, and/or Z location before executing the tool change (M6) proper. Work origin offset coordinates (usually used with a G92 or G10 command).

Program# ToolH, ToolV, ToolD WorkH, WorkV, WorkD

Prompted

EndH, EndV


9.1.1.8

Variables used for Wire EDM posts.

These are variables that don't really fit into any other category... Variable(s)

Category

Details

Related / similar items

InitPower

Wire EDM

Power, SparkGap, WireFeed

LowerDist, UpperDist Power

Wire EDM

‘Initial power’ setting value (Note – this variable will be set only if the CL file supports this function.) Uppoer & lower wire guide distances.

SparkGap

Wire EDM

Thickness WireFeed

Wire EDM Wire EDM

Wire EDM

‘Power’ setting value (Note – this variable will be set only if the CL file supports this function.) ‘Initial power’ value (Note – this variable will be set only if the CL file supports this function.) Thickness of the part. ‘Initial power’ value (Note – this variable will be set only if the CL file supports this function.)

Thickness InitPower, SparkGap, WireFeed InitPower, Power, WireFeed LowerDist, UpperDist InitPower, Power, SparkGap


9.1.1.9

General Purpose (Misc.) variables

These are variables that don't really fit into any other category... Variable(s)

Category

Details

Related / similar items

Block

General

The Block (or: sequence) number. This is automatically produced according to the Sequence#s line in the format (see above). If the 'frequency' of the Sequence#s is set to 0 (like this)...

The exclamation point (example: !0 ) can be used to suppress the output of block numbers.

Sequence#s N 0 1 1 1 Char, freq., incr, start

EndN FileSize LinTol

Mode

Lathe Roughing General Rotary axes

General

...then N[Block] can be used to 'force' out N numbers on certain lines. Example: N[Block] T[Tool] M6 See discussion of StartN below. The number of bytes in the final NC program file (so far). (NOTE – 5 axis and MillTurn posts only.) Set this variable to a non-zero number to activate PostHaste’s “Linearization” function (that will insert extra movements to break up movements with relatively large rotary angle changes into shorter moves to reduce tool tip gouging.). This variable is updated by the LINTOL record in APT CL files, or can be SET by the user like this: Set [LinTol] to .001 This variable is used mostly in MillTurn machine formats to determine if the operation is in milling or Turning mode. For MillTurn posts this is typically set by the MODE or APPLY record coming from the CL file … [Mode] = 1 when Turning,... per these CL records: MODE / TURN or APPLY / TURN [Mode] = 3 when Milling. This occurs when these records are found: MODE / MILL or APPLY / MILL For Wire EDM posts… [Mode] = 2 when in “2 axis” mode – typically when a contour is being cut that requires no independent movement of the UV (auxilliary or secondary) wire guide. [Mode] = 10 when in “4 axis” (typically ‘XYUV”) mode If you need to set the [Mode] yourself based on certain conditions, we recommend that you follow these conventions: Set [Mode] to 2 for “2D only” machining modes such as Laser, flame, 2 axis EDM, etc. Set [Mode] to 3 for simultaneous 3 axis milling mode. Set [Mode] to 4 for simultaneous 4 axis milling mode. Set [Mode] to 5 for simultaneous 5 axis milling mode. Set [Mode] to 6 for ‘generic’ MillTurn mode { XZC } Note: values of 7 to 9 are ‘reserved’ for possible future use – perhaps to differentiate different MillTurn modes (XYZC, XZBC, XYZBC,)

StartN TotalCutDist LINTOL (APT CL) record

MODE and TYPE commands


Variable(s)

Category

Details

Related / similar items

StartN, EndN

Lathe Roughing

These variables hold the “N numbers” (line numbers) of the starting and ending of the ‘finish path’ that is used for lathe roughing cycles. They are typically used in a Rough sequence like this: Rough G71 P[StartN] Q[EndN] U[VLeave] W[SLeave] … end

Stop

General

Taper

Lathe Threading

If a ‘full stop’ is commanded in the CL file, [Stop] will equal 0. If an ‘optional stop’ is commanded, this will equal 1. (Lathe only.) [Taper] holds the ‘diameter difference’ between the start diameter and the end diameter of the thread in AutoThread sequence. The taper of a thread is usually associated with the letter I or R. Example: G76 X[V] Z[H] P[Depth] Q[Peck1] I[Taper] F[Frate]

Val1 to Val20

General

These are general purpose 'user' variables that you can use for any purpose you want. These variables are not set by anything in the incoming CL data (unless you specifically use them in a Cycle or UponRec sequence definition line). When the post starts running, it always initializes these values to zero; the values of these variables can be set or changed only by using ADD, ASK, or SET statements or by putting them in the 'definition' (first) line of a Cycle or UponRec sequence.

Warning: Any time you add (what you think is) a 'new' variable to a post, make sure that that variable is NOT being used for some other purpose in the post already! Before adding a new variable, ALWAYS do a “Search” to make sure that you don't mistakenly re-use a variable that is being used for something else. Making this mistake can result in VERY strange output - and a big mess to “debug”!

See the Rename command (section 4.1.26) for more information on defining your own names for variables. See the Add, Ask, Set, Cycle, UponRec and IF (logic) sections for examples of how 'user' variables may be used.


10. Appendix B - List of “retired” functions. When working with OLD post formats, use this list to find things that aren't discussed earlier in the manual. (Functions are listed in alphabetical order.) As PostHASTE has advanced over many years, many of the original functions have been “retired” and replaced by better methods. For sake of clarity (and to reduce confusion), we discuss only the newer (better) solutions in the main sections of this manual. HOWEVER, for purposes of “backwards compatibility”, the “old” functions still work. You may come across some of these functions if you happen to be working on older PostHASTE templates. They are listed here for your convenience - in case you ever run across them and need to know what they do. Remember - there are better ways to achieve the same results: so we recommend that you do NOT use the retired functions - use instead the functions listed in the “Better to use” column of the table below. Item, Retirement M/Y

Better to use:

Notes:

<angle brackets> 9/94

[Square brackets]

2ndCircleCode, 4/93 CwCode, CcwCode 10/01 [CommentDelay] variable 12/01

ArcCode

Square brackets are now used for variables because (1) they are easier to type because they require no shift key, and (2) it makes IF commands less confusing if 'less than' (<) or 'greater than' (>) symbols are being used. Used for arc formats that require more than one line of code. (See p. 50)

ArcCode

Used for arc formats that require more than one line of code. (See p. 50)

Comments command

Varibles: [RPlane], [VClear] and [Vbite] 11/01 DCompAdd, LCompAdd 9/01 PostForm.* files 8/01

[Ilevel], [Rlevel] and [Step], respectively

See section 5.3.1for details on the Comments command. CommentDelay was used in older formats to 'postpone' comments for a few lines so that they would appear in a more useful location in your tool changes. The names RPlane and VClear were misleading because RPlane specified the “Initial Level” and has thus been changed to [ILevel]), and VClear specifies the “R level” (and has thus been changed to [RLevel]). Also, 'Step' sounds better than VBite. These commands were used with AuraCad/CAM product only. Since that product is no longer available, we have removed these commands. It's easier to just 'hard-code' this functionality as an equation (like D[DComp]+20) anyway. One machine format per file now, please. (Too many advantages to list here.) See Appendix B in the Getting Started manual for naming conventions. This is important! (The post does certain internal processes differently depending on the template file extension!) Removed last vestiges of .M and .L file extensions.

PConfig.M file 8/01 [CoolantOff] variable, 2/01

D[DComp]+20 H[LComp]+10 (etc.) “Single machine” format template files. (Examples: *.pM3 *.pM5 *.pT2 ...etc.) PostHASTE.cfg file Just use a simple... M9 ...instead of M[CoolantOff]

A long time ago, one of our larger customers requested that we add this variable. Since then, nobody has ever used it (as far as we know), and it makes thimgs more confusing, so it has been retired. If you really want to use it... (its value is set in the “Coolant” line) you may use it anywhere in the sequences that you want to turn the coolant off like this: M[CoolantOff] (See, M9 IS simpler, isn't it?)


11. Appendix C APT-CL Records recognized PostHaste automatically recognizes the APT-CL records in following list that start with the following words or symbols. ### NOTE -THIS SECTION IS "UNDER CONSTRUCTION" - WE WILL BE ADDING DESCRIPTIONS AND DETAILS OVER THE COMING MONTHS. THANK YOU FOR YOUR PATIENCE. - 3/22/04 ###

In addition to knowing which CL records PostHaste recognizes, It is probably just as important to know which CL records PostHaste IGNORES, so the first list below is a list of CL records that PostHaste IGNORES NOTE: If there is a record in your CL files that is NOT on either of these lists, PostHaste will issue a warning. HOWEVER - Remember you can always use an UPONREC sequence to... - cause PostHaste to 'recognize' one of the commands on the "not recognized" list, or - override PostHaste's 'default' way of handling a recognized record. CL records IGNORED by PostHaste: (listed in alphabetical order): AUTOPS

END

FINI

GOHOME

HEADER

INTOL

MACHIN

MCS

ORIGIN

OUTTOL

POSMAP

PSIS

ROW

SELECT

SEQNO

TLON

TOOLNO

UNITS

NOTE: Even though PostHaste ignores these records, you can override that attribute and enable them with an UponRec sequence in your template. Here's an example: UponRec INTOL [Val1] ... end


CL records recognized by PostHaste: CL Record Name ("Major word")

Description / notes / default actions, etc.

$$

Comment marker - the post will ignore all lines that start with '$$'. HOWEVER - you MAY 'Convert' them into actual valid records that you may process with PostHaste. (See details on the Convert command.) Processed the same as MODE. (See MODE below.) Some CAM systems use these records to describe arc movements instead of the standard 'CIRCLE & GOTO' pairs. Note - the ARCMOV record must immediately follow the ARCDAT record. (Along with ENDSUB and DEFSUB records,) describes subroutines or subprograms. Same as MOVARC Sets the [iLevel] value. Sets the [Cool] value. Some CAM systems output these records as a comment in the CL file. To utilize CSYS records, you must add the following line to your template or PostHaste.CFG file: Convert '$$-> CSYS' to 'CSYS' If this is done, then PostHaste’s ‘default’ handling of these records is to use them to automatically calculate the rotary angle(s). PostHaste also sets the variables [CSys1] to [CSys12] to the values that are in the CSYS records. Note - You can affect the way PostHaste interprets this record by use of the InvertCSYS? switch Indicates [Side] - typically used in the Infeed sequence. At this time, only the [ToolDiam] and [ToolRad] variables are set by PostHaste (from the number immediately following CUTTER . Specifies all types of holemaking cycles, and lathe threading. (Along with ENDSUB and CALSUB records,) describes subroutines or subprograms. Same as PPRINT (see notes re PPRINT below) (Along with DEFSUB and CALSUB records,) describes subroutines or subprograms. Spindle speed and mode

APPLY ARCDAT, ARCMOV CALSUB CIRCLE CLEARP COOLNT CSYS

CUTCOM or CUTDIR CUTTER CYCLE DEFSUB DISPLY ENDSUB FEDRAT FROM GOTO HOMEPT INDEX INDIRV INSERT LINTOL LOAD LOADTL MODE MOVARC MSYS

MULTAX PARTNO PPRINT

RAPID RETRCT ROTATE, ROTABL or ROTHED

General XYZ position of the endpoint of a linear or circular move, or the position at the 'top' of a hole. (Also see MULTAXI below.) Identical to the ROTATE command - see the note re ROTATE below. Used for arcs in CATIA... Text in the INSERT record will be placed directly and immediately into the final NC program. (No comment markers will be added.) Linearization tolerance - used in 5 axis milling applications. (This sets PostHaste’s [LinTol] variable.) PostHaste interprets LOADTL, LOAD and TURRET identically. PostHaste interprets LOADTL, LOAD and TURRET identically. Processed the same as APPLY Same as CIRCLE Similar to CSYS - but this is automatically interpreted as an 'inverted' CSYS. (Note - Unigraphics outputs MSYS records instead of CSYS, and Unigraphics does not put them in a ‘comment’, so no Convert command is needed for the post to read these records from Unigraphics CL files.) / ON or / OFF - indicates that upcoming GOTO records will include or exclude IJK (Tool shaft) vector data The text following PARTNO will be put into the {PartNo} text variable. (NO NUMERIC data will be parsed from the incoming PARTNO text.) Text following PPRINT will be output in the NC program as a comment. (PostHaste processes PPRINT records the same as DISPLY records.) You can use the comments command within your template to indicate where you want the comments to appear in the NC program. Turns the next GOTO into a rapid (typically G0) move. Used to set the rotary axis variables - typically [RotAngle] (if only 1 rotary axis on your machine) or 2 of the following: [AAxis], [BAxis], [CAxis]. (PostHaste processes the INDEX command in the same way.)


SET SPINDL STOP SYNCTR THREAD TLAXIS TURRET

Used to set the [Work] (Work fixture offset) variable. Spindle speed and mode Triggers PostHaste's STOP sequence. (typically M0 or M1, depending on template formatting) Used in synchronizing multiple turrets (on lathes & MillTurn machines) or multiple wire guides in 4 axis wire EDMs. Thread turning Similar to CSYS - can be used to calculate rotary angles. PostHaste interprets LOADTL, LOAD and TURRET records identically.


12. Appendix D Handling Rotary Axes This section of the manual lists information that you will need to understand in order to handle rotary axis issues with PostHaste.

NOTE - This section of the manual is 'under construction' - please excuse the temporary 'men at work' signs such as '###' or '<<<'. Thank you. Definitions:

Indexing vs.Rotary Milling: â&#x20AC;˘

Indexing refers to a rapid move with rotary motion. (Rotary 'positioning' only.)

â&#x20AC;˘

Rotary Milling refers to simultaneous rotation while actually cutting (that is, the rotary axis [or axes] are moving at the same time that the XYZ axes are moving at the cutting feed rate).

12.1 [RotAngle] vs. [AAxis], [BAxis] and [CAxis] Generally speaking, templates for machines that have only one rotary axis (for example, 4 axis mills) use the [RotAngle] variable. Machines with more than one rotary axis do not use the [RotAngle] variable; instead, they use a combination of 2 or more of the following variables: [AAxis], [BAxis] and/or [CAxis] The only exception to the above is that some machines with only a single rotary axis (most notably punch presses with a rotating tool holder) can use the [AAxis], [BAxis] and [CAxis] variables, but only when the CAM system outputs corresponding ROTATE or ROTABL records into the CL file that contain the AAXIS, BAXIS or CAXIS parameters (see the discussion below).

12.2 Where do the actual rotary angle values come from? The actual rotary angle(s) (that are output by the [RotAngle], [AAxis], [BAxis] and [CAxis] variables) are calculated from one of the following types of CL data ( - these are listed in the order of 'most desirable' to ' least desirable'):

12.2.1 MULTAX data ### This usually the most desirable data to use for calculating rotary angles. This data can be used for both indexing and rotary milling. The CL file will include a MULTAX / ON record, then the GOTO records will include 6 parameters (XYZ coordinates and an IJK vector); the IJK vector indicates the direction that the tool shaft is pointing (away from the tip).


Examples: Typical (3 axis) GOTO records (no MULTAX data): … GOTO / 4.6574936, -1.4959458, -0.4900000 GOTO / 4.6154199, -1.4861985, -0.4900000 RAPID GOTO / 4.6154199, -1.4861985, 0.1000000 …

MULTAX / ON record, followed by GOTO records with MULTAX (IJK vector) data: … MULTAX RAPID GOTO / FEDRAT GOTO / … MULTAX GOTO / GOTO / RAPID GOTO / …

/ ON

<< Initiates 5 axis positionining (XYZ and IJK)…

4.85985, -1.33816, 1.00000, -0.0879675, -0.0000970, 0.9961233 / PERMIN, 200.000000 4.85985, -1.33816, 1.18560, -0.0879675, -0.0000970, 0.9961233 / OFF << Back to 3 axis (XYZ only)… 4.6574936, -1.4959458, -0.4900000 4.6154199, -1.4861985, -0.4900000 4.6154199, -1.4861985, 0.1000000

12.2.2 Coordinate system (CS or CSYS) data Unless special arrangements are made in the template, CSYS data can only be used for indexing or multiple setups on a 3 axis mill – and usually cannot be used for rotary (simultaneous 4 axis) milling Since the ‘preferred method’ of rotary axis controls is through the use of MULTAX data (see above), CSYS data is NOT usually accessible to the post unless you specifically activate it by using a Convert command like this: Convert '$$-> CSYS' to 'CSYS' Ignore MULTAX This line must be added to prevent redundant rotary data!

Important!!! Please note that if you are using CSYS data (by including the Convert line above, you must disable the MULTAX data by including the Ignore MULTAX command in your template as well!

### ###>>> “Under construction…” – Need to discuss 'in plane rotation' and 'local coordinates' limitations/capabilities. <<<###

12.2.3 TLAXIS record data This is usually found in CATIA CL files, and is somewhat of a hybrid of both of the MULTAX and CSYS methods described above. It is similar to MULTAX data because it indicates a single IJK (tool shank) unit vector that indicates the XYZ direction from the tool tip back along the center line of the tool (towards the center of the spindle face). However, it is similar to the CSYS method because TLAXIS records appear


occasionally in the CL file for purposes of indexing (that is, rapid rotary positioning) rather than simultaneous rotary machining - which requires an IJK (MULTAX) vector in every GOTO record. Examples: TLAXIS/ 0.000000, 0.000000, 1.000000

(Tool shank pointing towards Z+ axis [Typ. A0 and/or B0])

...or... TLAXIS/ -1.000000, 0.000000, 0.000000

(Tool shank towards X- axis [Typ. B-90])

TLAxisEnabled? switch

TLAXIS records are ignored by PostHaste - unless you use the TLAxisEnabled? switch and set it to Y like this: TLAxisEnabled? Y

12.2.4 ROTATE, ROTHED or ROTABL records Using these records is the least desirable of the methods of obtaining rotary angle information. It is undesirable because the CAM system has actually calculated the rotary values, rather than letting the post calculate them from the 'vector' (IJK) information that is used in any of the above methods (MULTAX, CSYS or TLAXIS). The problem with that is that most CAM systems do not have the kinematic information regarding the rotary axes on your machine, so many times the CAM system outputs bad angles. With that said, sometimes this is the only information available, so alas, we must sometimes use it. Fortunately, IF your CAM system sets these values properly, then you should have no problem. Special attention must be paid to the way these records are handled. If any of these records include the parameters AAXIS, BAXIS or CAXIS, then the post will correspondingly set the [AAxis], [BAxis] or [BAxis] variables, respectively - EVEN IF THE ANGLES BEING SET DO NOT MATCH THE ACTUAL KINEMATICS OF YOUR PARTICULAR MACHINE. This can become very troublesome and complicated, so again, try to avoid using the ROTATE, ROTHED and ROTABL records if at all possible. ### <example> ###

The VertCSame? switch ###>>> Move this topic into the 5ax addendum. <<<###


13. Appendix E What's new with PostHASTE and this manual? RIGHT HERE is where you can find out about the latest features of PostHaste - without having to look through the entire manual! The chart below tells you where to find out about important and/or recent changes to PostHaste and this manual. (There are probably lots of very useful things you didn't know about PostHaste - take a minute to skim the leftmost column of the chart below. You'll learn a lot!)

Notes: •

For the most part, the chart is listed in order of 'newest to oldest', so whenever you get a new version of PostHaste (this manual), start reading from the top of the list to learn about the new items. (To make sure you see all of the new items, don't stop until you reach 'familiar territory'.)

We have listed the items that we feel are the most important for you to know about in boldface type. Don't miss these!

Note: in the Doc or Feat.? Column... •

D means that it's a documentation change (correction, addition, explanation, examples, etc), F means that it's a new feature of PostHaste.

(new) means that (even if it's not a new feature) it is a completely new subject in this manual, so you might not have heard about it before. Check it out!

New Item: How Rotary Axes are output (and controlled by CL data. ) Expanded discussion on defining the (4 axis) INDEX sequence Handling ‘Optional Stop’ (OPSTOP) CL records

Doc or Feat.? mo./yr. D – 2/05

D – 1/05

D – 1/05

Notes:

Read about it in section...

Important discussion for anyone processing 4 or 5 axis milling (or MillTurn) programs; the significance of the [Rotangle] and [AAxis], [BAxis] and [CAxis] variables and the following CL records: MULTAX, CSYS (Coordinate system or CS) TLAXIS, ROTATE, ROTHED, ROTABL. Sometimes (when programming a horizontal 4 axis machine) you may have a CAD model that is drawn so that the part must rotate about the Z axis, but your machine rotary table actually rotates the part about the Y axis. This discussion explains how you can define your INDEX sequence to handle that.

Appendix D Handling Rotary Axes

Discussion / example of using the UponRec sequence to output code required for an ‘optional stop’ (CL OPSTOP record).

5.2.4.4

Subsection of 5.2.4.3


New Item:

Doc or Feat.? mo./yr.

Updated Appendix A (Variable list) with many entries.

D – 1/05

AutoThread sequence, related variables [Cycle] [Style] and [Spindle#] variables

D - 4/04

[Turret] variable, RevTurret2? switch Verbose? switch

D - 4/04

[PolarBreak] variable

F - 7/'03

Appendix added: "APT-CL records recognized" Topic "Work Fixture Offsets" moved. TLAxisEnabled? switch

D - 3/'04

RELATE option on "Upon... Unique" sequences.

F - 2/04

SpliceSubs? switch Rename command WindowSize configuration setting ArcPlane command and [ArcPlane] variable [LastH], [LastV] and [LastD] variables. Helical arcs

F - 10/03 F - 10/03

both 04/04

F - 3/04

D - 3/'04

F - 2/04

F - 9/03

D - 6/03

D - 6/03

D - 6/03

Notes:

Read about it in section...

Added discussion of these variables (most of which have been available for a long time, but had not yet been documented): ADir (BDir, Cdir), ADist (BDist, CDist), ArcDir, ArcPlane, CPref, FileSize, H2 (V2), HCtr2 (VCtr2), InitPower, LowerDist (UpperDist), Normal1 (Normal2, Normal3), PointH (PointV, PointD), PolarAngle, PolarDist, Power, SparkGap, StartN (EndN), Stop, Taper, Thickness, WireFeed. Added/improved information on these variables: Mode, The AutoThread section (Section 5.2.4.2) also now includes the variables: Starts, TipAng Of special interest to lathe users; Automatic lathe threading cycle (typically G76) documented - along with use of the [TParams], [Passes], [Chams], and [TipAng] variables. Also of special interest to lathe users; additional values for [Cycle] and [Style] are now available, and we have added documentation of the [Spindle#] variable. (Note: The [Spindle#] variable has been available since 1//2000, but somehow it escaped being documented! Sorry! :-o ) ...and even more for lathe users; PostHaste has some special features for Multiturret lathes. See these sections for into on the [Turret] variable and RevTurret2? switch, respectively. Setting this to Y makes the post output some additional comments that may be helpful in 'debugging' your templates. 'Polar interpolation' control: For MillTurn posts, setting the [PolarBreak] value lets you control how & when lines and arcs milled on the face of a part are converted/broken into a series of short 'polar' (typically X,C) moves. Now there is a list of the APT-CL records that the APT version of PostHaste recognizes automatically.

Appendix A List of Variables

This was previously "Appendix C". We felt that it deserved a chapter in the manual, so we added section 6. (Note - The contents of that section have not changed - we just moved it.) Allows use of the TLAXIS record (for machines with rotary axes) to calculate rotary axis angles.

6

Allows you to relate any variable to a unique condition. For example: Relate a 'work offset' variable to each face of your workpiece so that the post will output the correct work offset number that has been calculated and related to each face (A or B angle) of the workpiece Lets you prevent subs from being including in the main output file. User-defined variable names! The Rename command lets you to make up any name you want - for any variable. If your post window is too small (if any of the buttons are missing or only partially visible) then you can configure the width and height (in pixels) of the main PostHaste window. The ArcPlane command (and optionally the [ArcPlane] variable) can be used in mill format templates to support arc output in the ZX (typically G18) and YZ (typically G19) planes. A very important discussion of these variables has been added - read about these in section 9.1.1.1 (That is inside Appendix A - look in the left column of that table to find the entry entitled “LastH, LastV, LastD, LastRotAng”.) Everything you ever wanted to know about handling helical arcs - including examples of some special cases.

5.2.4.2

9.1.1.4

9.1.1.4 4.1.30 4.1.41 9.1.1.1

Appendix C

Appendix D Handling Rotary Axes (Section 12.2) 0 (see the '...Relate...' subsection) 7.6.3.4 4.1.26 Appendix A of 'Getting Started' manual 4.2.1

9.1.1.1

4.2.7.1


New Item: LOOP structures Equations !

Doc or Feat.? mo./yr. ### D (new!) - 4/'03

Outputting text directly, {Text} variables, and other textrelated functions Call (command)

F(new!) 4/'03

CallMe

F(new!) 4/'03

F(new!) 4/'03

[PeckClear] AND and OR usage with IF Indenting lines in an IF structure Automatic Multiple-part output

D - 4/03 D (new) 2/03 D (new) 2/03 D (new) - 2/03

PostHaste.LOG

D (new) 2/03 D (new) 3/03

LocalOutput? switch [TotalCutTime], [TotalCutDist] [MoveTime] (doc. Error) MOD letter format modifier Coolant command, the [Cool] variable. Appendix C - Work offset details

F - 12/02 D - 12/02 D - 10/02 D - 10/02 D10/'02

The NoComment and All options (for Replace) Unique modifier to the UPON record

F – 8/'02

No-Opt letter format modifier

D - 8/'02

F - 8/'02

Notes: Create 'loops' for controlled repetitive processing of... anything! (You can even created 'nested loops'.) You can now follow letters with equations such as X[H]/2 or Ycos([RotAngle])*[Val12] (You can also use equations in other areas, too.) PostHaste now features 'text output' capability. In addition to any 'hardcoded' text that can be output from within any sequences, text variables (such as {CLName}) can be used for many purposes including commenting and creation of specific files in specific folders. Use Call to 'reuse' (output) any sequence from inside any other. e.g. You can usually use this to eliminate lines in your ToolChange sequence that are 'duplicates' of lines in your 1stToolChange sequence. Use CallMe to create your own sequences! (Then use Call to output them.) This can greatly reduce the complexity and the number of lines needed in your template! 'Rapid into peck' drill tip clearance AND and OR can now be used in IF structures to test for 2 conditions at a time. For more visual clarity within the template, you may indent lines within an IF structure with a single space. You can easily set up your posts to automatically generate multiple-part programs (using subroutines and work offsets [G54, G55, etc.]) - even if you've only programmed a single part in your CAM system. If you EVER need to do multiple-part setups , then READ THIS! Did you know that PostHaste creates a log file that is very helpful in 'debugging'? For machines with rotary axes, use this switch to output your XYZ data relative to the 'local' [Work] (G54, G55, etc.) origin for each face of your part. (Restrictions apply!) New variables that track your total feed time and distance so far.

Read about it in section... Coming soon! 7.1

'Text' topic: 7.3 List of text variables: 9.1.1.6 File Alias: 5.3.4 5.2.5

5.2.5

4.1.2 7.5 7.5 7.6

7.7 4.1.22

9.1.1.1

Before this date, the explanation of [MoveTime] mistakenly said that it was measured in seconds. It is actually measured in minutes. The MOD (modulo) letter format modifier makes rotary axis output possible on machines that have a 'numerical' limit of 360 (and/or -360) on the rotary axis. This section of the manual was updated to clarify the use of these commands and variables. This manual now includes an exhaustive discussion of how PostHaste handles Work/Fixture offsets (a.k.a. 'WFO's” and/or G54) - including details on the [Work] variable and the Work and WorkDefault commands. . NoComment prevents 'Replaces' from being performed on your comments, All 'Repeats' a replacement until all occurrences have been replaced.

9.1.1.1

Trigger output or processes only upon finding a unique ('not previously used') value of any variable... Can be used (for example) in a tool list to prevent duplication of tools that are used twice, or t o create unique G10 lines whenever a 'new' index (rotary position) is encountered. Inhibits PostHaste's 'zero optimization'; this lets you output zeroes as “0.” instead of “0”

0

3.1.2 4.1.6 Appendix C

7.4

3.1.2


New Item:

Doc or Feat.? mo./yr.

Index sequence

D - 8/'02

Format the output for Rapid moves that include rotary motion.

Set command Arc-related variables 'Spindle Range' codes (tactic) [UnitMode] Tolerance command Spaces? switch Each, EOB and EOF commands. File commands

D - 8/'02 D - 8/'02

Set the value of any variable to any number, variable or equation To get familiar with any of these variables... ArcRad, ArcStartH, ArcStartV, HCtr, VCtr, Ival, Jval, StartAng, EndAng, Sweep This is an example of a good 'general purpose' tactic that has many other uses – you should know how to do this! Value output corresponds to the values listed with the INCH/MM command. Set the post's rounding tolerance (to prevent rounding errors from accumulating while outputting incremental values). Puts spaces between words. If you didn't know about this, then read this section: These let you specify a 'word' to be output on each line of your program as well as the 'end of block' and 'end of file' character sequences, respectively. Many file handling functions are now available that allow you to ... - do 'multi-pass processing' - create/edit multiple output files - create tool lists at the top of your program files... and more! NoEOL lets you join several sequence lines into a single line of output (by suppressing the 'end of line' that PostHaste outputs after every sequence line). Gives you complete control over the exact location of your comments in the final NC code! The file extension tells PostHaste what type of machine is being formatted. What's the difference between a .pT2 and a .pU5 template file? Find out here.

NoEol (and EOL) commands Comments command Template file extension naming conventions Notes: / EndOfNotes (or EndNotes) DivBy and DivInto letter format modifiers

D - 8/'02 D - 8/'02 D - 8/'02 D - 8/'02 D - 8/'02 F – 7/02

F - 2/01 F– 12/01 F – 1/'02

F - 11/01

F – 7/'01

Notes:

Use Notes: and EndOfNotes (or EndNotes) lines to include large blocks of comments (without having to 'indent' them), or to 'comment out' a portion of your template. Letters can be formatted for 2 different types of Division operations.

Read about it in section... Error! Reference source not found. 5.3.5 4.2 5.3.6 (example of Set usage.) 9.1.1.4 4.1.37 4.1.32 4.1.9 to 4.1.11 5.3.4

5.3.5 5.3.1 1.2

4.1.25

3.1.2


PostHASTE for GibbsCAM 2005 - Format Reference Manual copy