Table of Contents

General NC Code Support

The vocabulary HiNC interprets is decided by the controller brand selected for the project. This page covers the ISO-family presets — Fanuc, Syntec and Mazak — and Siemens SINUMERIK. Heidenhain is a different language and has its own page: Heidenhain Support.

How to read this page

Coverage is stated in three states.

State What happens when the construct appears in your program
Supported interpreted, and its effect is simulated.
Recognized, not simulated consumed on purpose and reported under its own message id. The block keeps running and the construct's effect does not apply — but it can never be silently misread as something else.
Not supported the words are left over, and the block reports Parsing--Unconsumed naming them.
Tip

The message list a run produces is the coverage report for your program. Every word the interpreter could not use is named on the block that carried it, so you rarely have to infer coverage from the simulated result. An unknown code does not stop the run — it is reported and skipped.

A message says that a construct was not simulated, not that the path is wrong, and the two kinds are worth telling apart before anything is changed. Some constructs steer only what the control does around the path — a smoothing or look-ahead selection, a named program header, a cycle-time timer on #3001 — and leave the simulated motion unchanged; their paragraphs below say so. Others change the result when they are not read: a called program the lookup cannot find, a G code chosen by a variable, a macro argument whose variable is vacant, a G28 whose axis words follow another G word. Each of those paragraphs names the form that is read, so a simulation copy of the program can be rewritten where it matters while the delivered program stays untouched.

ISO core

Fanuc, Syntec and Mazak share the vocabulary below. Siemens spells most of it the same way and adds its own for the rest — see Siemens SINUMERIK.

Motion

Code Meaning
G00 Rapid positioning.
G01 Linear interpolation at the programmed feedrate.
G02 / G03 Circular interpolation, clockwise / counter-clockwise. The centre may be given as I / J / K offsets or as a radius R.
G04 Dwell. X / U are seconds, P is milliseconds, S is spindle revolutions. Both the G4 and G04 spellings are read. A decimal point in P follows the controller: Syntec reads the whole milliseconds (P2.5 dwells 2 ms); Fanuc (alarm PS0007) and Mazak refuse the word, so the block reports Dwell--DecimalPointRefused and does not dwell.
G28 Reference-point (home) return through an intermediate point. Under G91 a rotary word gives the intermediate as an increment on the previous modal angle. Which axis words belong to it is stated below.
G53 One-shot machine-coordinate move — work offsets are bypassed for that block only.

G28 takes only the axis words that follow it directly. Its words run up to the next G, M, F or S word in the block. In G91 G28 G0 Z0 the G0 closes the G28 before the Z0, so the block reads as a G28 with no axis — reported as Coord-RefReturn--003, with no return motion — followed by an incremental G0 Z0, which does not move. The block is written to mean a single reference return of Z, with G0 left as the modal motion for the blocks that follow — a Z lift before a traverse — and HiNC does not read it that way. Where the return matters — a G28 that lifts the tool before a traverse — put the axis words straight after G28 in a simulation copy: G91 G28 Z0, or G0 G91 G28 Z0. Where Z is already at its reference position when the block plays — at the start of a program, or of a called program whose caller has just returned Z — the reading changes nothing, and the block can stay as delivered with its Coord-RefReturn--003 listed as expected. Either way, treat every occurrence alike, called programs included: each one left as delivered raises its own message on every play.

A G28 with no axis words at all means different things on different controls, so HiNC reports it as Coord-RefReturn--003 and does not move. The message suggests reading such a block as every configured axis returning home; that is the wrong fix for the reordered form above, because it would send X and Y home as well.

Plane, units and positioning mode

Code Meaning
G17 / G18 / G19 Plane selection — XY / ZX / YZ. Arcs and canned cycles follow the active plane.
G21 Metric. This is the HiNC default.
G71 Metric — the RS-274-D / Fanuc G-code system C / Syntec spelling of G21, accepted the same way on the Fanuc and Syntec presets. Mazak EIA stays G20 / G21 only.
G20 Inch — not supported. The block reports Unit--InchNotSupported; post the program in metric.
G70 Inch — the RS-274-D / Fanuc G-code system C / Syntec spelling of G20, read on the Fanuc and Syntec presets. Not supported; the block reports Unit--InchNotSupported; post the program in metric.
G90 / G91 Absolute / incremental positioning. Under G91 a bare rotary word is an increment too; a per-word directive (C=AC(90), ACP / ACN, IC()) overrides the modal state.
G94 / G95 Feed per minute / feed per revolution.

Work coordinates

Code Meaning
G54–G59 Standard work coordinate systems.
G59.1–G59.9 Extended work coordinate systems, backed by the brand-neutral table the Fanuc, Mazak and Syntec presets carry behind their brand table. Like G54–G59, a row left at zero is read as an authoring convention and stays silent.
G54.1 P1–P48 Fanuc additional work coordinate systems, backed by the extended work offset table. Also read in the manual's second spelling G54 P1–P48, with or without the space; a G54 with no P word is the plain G54 above. A selected row nobody has entered reports Coord-WorkOffset--AdditionalZero.
G52 Local coordinate offset, applied on top of the active work coordinate system.
External work offset (EXT, #5201 onward) Not modelled. No table holds it, and a work-coordinate code composes only its own row. When the machine carries an external offset, add it into every G54–G59 and G54.1 P row the program selects. Leaving it out does not change what is cut once the part is aligned to its row, but it shifts the whole setup in machine coordinates, which stroke checks and collision detection see. A macro that reads the EXT variables finds no value.

Tool compensation

Code Meaning
G43 / G44 / G49 Tool length compensation, positive / negative / cancel. H selects the offset row and is modal, as on a Fanuc control: a G43 with no H — or with an H behind a vacant variable — re-selects the last H written, across a G49 and a tool change alike, and runs on H0 (a zero-length compensation, silently) until one is written; the tool number never fills it in, and the program-end reset clears it. The H / T agreement check is on by default: an H that is not the number of the tool in the spindle reports Comp-ToolHeight--HDiffersFromTool on the block that selects it and Comp-ToolHeight--HOutlivesToolChange on a tool change under a still-active compensation, each with both rows' lengths; H0 and G49 are exempt, and the compensation itself follows the H either way. Haas ships the same check as Setting 15 “H & T Code Agreement” (alarm 332, H0 exempt); Fanuc has none. A program written with another habit — tool 101 on row 1, one tool switching between G43.4 H02 and G43 H03 — sets HMustMatchTool to false on the controller's ToolOffsetAgreementCheck (controller XML or API; no panel yet). HardNc still resolves an omitted H from the tool number; the engines diverge there on purpose.
G41 / G42 / G40 Cutter radius compensation, left / right / cancel. D selects the offset row.

Radius compensation is resolved against the blocks that actually travel in the compensation plane. A block whose own words command no movement in that plane — a bare G41 / G42, a comment, an empty line, a plunge along the plane normal (Z under G17) — takes no offset of its own and no part in a corner:

  • Start-up waits for motion. A G41 or G42 block that does not move in the plane does not start the offset; the first block that travels in the plane is the start-up block and takes the perpendicular (type A) offset. The blocks between them carry the previous block's offset vector, so nothing moves on their account.
  • Corners are resolved between travelling blocks. Wordless blocks sitting between two moves are passed over, and the corner is the intersection of the two real segments. Running axes are the in-plane part of each displacement, so a ramping move keeps its full offset and a plunge along the plane normal stays on the offset line.
  • The plane cannot change inside a region. G17 / G18 / G19 selects the compensation plane, and it may only be selected while compensation is cancelled. A plane code that resolves to a different plane while G41 / G42 is active — including one sharing its block with the G40 that cancels the region — is reported as RadiusComp--PlaneChangeInRegion, because the corner spanning the change would be built from one running axis per plane. A control alarms there (Fanuc PS0037 CAN NOT CHANGE PLANE IN CRC). Re-selecting the plane already in force is not a change and is accepted.
  • A bare G40 closes the region. The last compensated block ends on its own perpendicular offset rather than turning toward the first uncompensated move after the cancel. A G40 that carries motion is the last corner's partner instead, and the compensated path meets the cancel line at their intersection (Fanuc type B); the legacy interpreter (EnableSoftNcRunner set false) ends that case perpendicular.
  • The D row must match the program's strategy. A zero-based program (the CAM path is the tool-centre path, G41 D.. kept for wear only) needs a D row whose geometry radius is 0; a cutter-radius program (the NC is the part contour) needs the tool radius there. An offset larger than an inner arc or groove of the contour makes the compensated path run against the programmed direction — a control stops with an interference alarm (Fanuc PS0041), HiNC reports RadiusComp--Interference and keeps playing the swapped-side path. The radius basis of the tool-house refresh is chosen on Tool Offsets.

Rotation, tilted planes and five-axis

Code Meaning
G68 Coordinate rotation in the active plane, around a centre point by angle R.
G68.2 Tilted work plane — Euler angles I / J / K with origin X / Y / Z.
G69 Cancels G68 and G68.2.
G53.1 Tool-axis direction — swings the rotary axes into line with the active G68.2 plane.
G43.4 RTCP / tool centre point management. The Siemens equivalent is TRAORI, the Heidenhain equivalent M128.

Under G43.4, G68, G68.2 and G53.1 the machine axes are solved on the nominal chain, in which every branch marked as an error term is taken as No Transform: like a real control that does not know its machine's errors, HiNC does not compensate the errors those branches carry, and while the project's error-term switch is on they stay in the cut.

Canned cycles

Code Cycle
G73 High-speed peck drilling — Q increments with a partial retract.
G74 Left-hand tapping.
G76 Fine boring — oriented spindle stop, Q shift, rapid out.
G81 Drilling.
G82 Drilling with a dwell at the bottom — P in milliseconds, as for G04. A decimal-point P is seconds on Syntec and refused on Fanuc (alarm PS0007) and Mazak: Dwell--DecimalPointRefused, the hole is drilled without its dwell.
G83 Peck drilling — Q increments with a full retract to the R point.
G84 Right-hand tapping.
G85 Boring, feed out.
G86 Boring, spindle stop then rapid out.
G87 Back boring.
G89 Boring with a dwell at the bottom — P in milliseconds, as for G04. A decimal-point P is seconds on Syntec and refused on Fanuc (alarm PS0007) and Mazak: Dwell--DecimalPointRefused, the hole is bored without its dwell.
G80 Cancel.
G98 / G99 Retract to the initial level / to the R level. The return level may be written before or after the cycle code in the same block: G99 G81 … and G81 G99 … read the same.

A cycle is expanded into the individual strokes it performs — approach, peck, dwell, retract — each with its own feedrate, so material removal and cycle time come out of the real motion rather than an approximation. Modal repetition and G91 incremental cycle data are resolved before the strokes are built.

A repeat block carrying an A / B / C word indexes the table and drills again, the standard way to drill a bolt circle: a rotary-only repeat fires the cycle (any axis word repeats it), a mixed block pre-positions XYZ and the table in one simultaneous move before the strokes, and under G68.2 without RTCP the feature frame stays pinned in machine space so the hole stays put while the workpiece turns. Under G91 only the words the block itself spoke are increments — an X-pitch repeat does not move Y again.

Polar interpolation

G12.1 turns polar coordinate interpolation on and G13.1 turns it off. Inside a polar section the X word is a diameter and the C word is a hypothetical Cartesian axis in millimetres, not rotary degrees. HiNC halves X, resolves G90 / G91, writes both the polar and the derived Cartesian positions along with the machine C angle, and simulates polar linear and polar arc motion — the arc as real spiral geometry that stays continuous across ±180°. G41 / G42 compensation is resolved on the hypothetical plane, and YA / ZB axis pairs work the same way. G codes that conflict with polar mode are checked before the mode is entered. A program end (M02 / M30) cancels polar interpolation as a RESET does: the next program starts in G13.1, and a G12.1 there enters it afresh.

Path smoothing

G05.1 Q1 enables high-precision contour control (AICC / Nano Smoothing) and Q0 disables it. The optional R precision level is preserved.

Bare G05 (or G5) is a different feature under a confusingly similar name, and the two are tracked separately so they cannot cancel one another. It selects a function through its P word, on the Fanuc and Mazak presets:

P Reading
P10000 HPCC — RISC-based high-precision contour control. Recognized, deliberately not simulated: it changes the machine's look-ahead, acceleration and servo behaviour, never the programmed coordinates. Reports Hpcc--NoOp.
P0 Cancels HPCC. Consumed silently — cancelling a no-op needs no message.
P10001–P10999 High-speed cycle machining. The real machine executes cycle data pre-registered in its variable area, which is actual axis motion HiNC cannot see, so the simulated result misses that machining. Reports Hpcc--HighSpeedCycleIgnored as a warning.
anything else Not supported offline and ignored, reported as Hpcc--UnsupportedFunction. Small P values select the high-speed remote buffer modes.
no P at all Not supported offline and ignored, reported as Hpcc--MissingFunctionWord.

An unevaluated macro variable or expression in P is tolerated — it reports Hpcc--UnevaluatedFunction rather than failing the block. The Syntec preset does not capture the P word of a bare G05: there the block reads as a G05 with no P (Hpcc--MissingFunctionWord) and the P word is reported as Parsing--Unconsumed.

AICC / Nano Smoothing is read in both spellings. G05.1 Q1 and G5.1 Q1, without the leading zero, record the same smoothing state; a controller saved in a project by version 3.2.32 or earlier reads only G05.1 until it is re-created from its brand preset. The G08 P… look-ahead selection is not read and reports Parsing--Unconsumed naming G08 and P. Neither code changes the programmed path: they steer how the control executes it, and the simulated time is computed from the programmed feed with no look-ahead or acceleration model (see Machining Time Estimation), so a program that keeps them simulates the same cut. G8.1 P… is reported the same way, for a different reason: it is not a standard Fanuc code, and what it does on a given machine — a builder's option, or a G-code macro call that may well move the axes — is for that machine's manual to say, so the simulation does not assume it is harmless.

M codes

Code Meaning
M00 / M01 Program stop / optional stop.
M02 / M30 Program end. On SoftNc the next block starts with tool-length compensation (including TCP), tilt, cutter-radius compensation, canned cycles and polar interpolation (G12.1) cancelled; a modal macro call (G66), the local coordinate offset (G52) and the volatile variables (#100–#499) are cleared on the M02 / M30 block itself, which otherwise still runs under the modal state it executed with. A Start after a Stop begins in the same state (A Start after a Stop). The HardNc fallback does not apply that reset.
M03 / M04 / M05 Spindle clockwise / counter-clockwise / stop.
M06 Tool change. The axis travel the change requires is synthesized rather than teleported.
M07 / M08 / M09 Mist coolant on / flood coolant on / coolant off.
M98 / M99 Subprogram call (M98 P{program} L{repeat}) and return, including M99 P{sequence} early return. The callee's file is looked up as stated in Finding a called program.
M198 Subprogram call from external storage — same shape as M98, different lookup folder.
Note

Composite and OEM M-codes are not built in — they are declared on the machine. An M13 that means “spindle CW plus flood coolant”, an M-code that triggers a tool change, or turret T-word semantics are stated once in the machine's own M-code table and expanded into the ISO effects the rest of the pipeline already understands. A code declared with no modelled effect is voiced once as DeclaredMCode--UnmodeledEffects instead of raising an unknown-code warning on every occurrence.

Note

If a program states a spindle speed greater than zero and makes a feed move before it ever issues a direction, HiNC assumes clockwise from that move on and reports SpindleDirection--AssumedCw on it. Without that assumption the cutting-force model would silently produce zero mechanics for the whole file. A speed stated ahead of its direction — S1200 a block before M03, or a Heidenhain TOOL CALL … S followed by M3 — reports nothing: the blocks before the direction carry the speed and no direction, and no cutting physics runs on them.

Finding a called program

M98 P… and M198 P… on the Fanuc, Syntec and Mazak presets, and G65 P… / G66 P… on Fanuc, find the callee by its program number in the controller's subprogram folder. M98, G65 and G66 read the internal folder; M198 reads the external folder and falls back to the internal one when no external folder is set. The internal folder defaults to NC, and a relative folder is anchored at the project folder — not at the folder of the program that makes the call. Six file names are tried, and the first that exists wins; for P25 they are:

Pattern For P25
O{P:D4}.NC O0025.NC
O{P}.NC O25.NC
O{P:D4} O0025
O{P} O25
{P:D4}.NC 0025.NC
{P}.NC 25.NC

{P:D4} pads the number to four digits; a number of four digits or more is used as written. Nothing else is tried: a callee delivered as O25.dat or O0025.txt is not found until a copy is placed under one of these names, and letter case is decided by the server's file system, so on a case-sensitive host O0025.nc is not O0025.NC. The main program has no such constraint — a program-file command plays it under any name.

A callee that is not found is an error — SubProgramCall--FileNotFound for M98 / M198, FanucMacroCall--FileNotFound for G65, FanucModalMacro--FileNotFound for G66 — and the call is skipped while the run carries on. A job whose cutting lives entirely in the callee therefore finishes with nothing machined. A call that landed shows its callee nested under the caller in The Program Branch. The folders are the controller's Subprogram Folders setting; how they are stored, what an emptied internal folder is saved as, and the file-name chains of the Siemens and Heidenhain presets are in Program Reading.

Fanuc

Everything in the ISO core, plus the following.

Custom Macro B

# variable assignment and arithmetic, with each range routed to the store it belongs to — #1–#33 local to the macro frame, #100–#499 volatile and cleared on M02 / M30, #500–#999 retained and saved with the project, #3000–#3999 system control. Boolean and logical operators, IF [..] GOTO n, IF [..] THEN <statement>, and WHILE [..] DO m / END m with a bounded-loop watchdog. Position and tool-offset system variables read back into expressions. Axis words and the F, S, T and H words take a variable or a bracket expression, so M6 T#120 changes to the tool #120 holds and G43 H#11 in a macro body compensates with the row the call bound to #11.

Local variables are written only inside a macro call. A block outside a G65 / G66 body that assigns #1–#33 reports LocalVariable--MainFrameWriteUnsupported, and the value is not kept. A real control allows the write; in the main program, carry the value in a common variable (#100 and up) instead.

A G code cannot be chosen by a variable. G[#120] and G#120 are not read: the text is reported as UnparsedText--Remaining, and the modal group the code was meant to set keeps its previous state. A program that selects its work offset this way — #120 = 55 followed by G90 G[#120] G0 X0 Y0 — runs that section on the work offset that was already active, so on a multi-station fixture every part is cut at the same station, with that warning as the only sign. The same holds inside a macro body that selects G[#1] from its argument. Write the literal code (G90 G55 G0 X0 Y0) in a simulation copy. When one body is called once per station and picks the station from its argument, the caller usually sets the same offset just before each call; with the literal code there, the work offset is modal when the body runs, so the body can stay as delivered — its G[#1] is still reported and changes nothing — and there is no need for one copy of it per station.

System-control variables are recorded, not emulated. A write to #3000–#3999 — resetting the #3001 millisecond clock, raising an alarm, pausing with a message — is consumed with no effect and reported as FanucSystemControl--Unsupported at message severity. A read returns the value the program last wrote. The simulation has no clock, so the #3001 millisecond timer and the #3002 hour timer stand still: they read the last value written, or 0 when the program never wrote them. The cycle-time stamp many programs place around an operation, #3001 = 0 … #610 = [#3001 / 1000], therefore assigns #610 = 0. A clock that stands still cannot end a timed wait, so the two timers are not evaluated in a WHILE or IF … GOTO condition: the condition reports FanucWhileDo--ConditionNotEvaluated or FanucGoto--ConditionNotEvaluated and the loop is left at once — the state the machine is in when the wait is over. Any other variable of the range is vacant until the program writes it. None of this changes the motion.

Vacant is not zero. A variable nobody has assigned is vacant, and an expression that reads one fails — the message carries Variable--Vacant — instead of taking the value 0 the way a Fanuc control does in arithmetic. The retained ledger that holds #500–#999 between runs is Persistent Variables.

Macro calls

G65 one-shot macro call and G66 / G67 modal macro, firing at every positioning block until cancelled; M98 / M198 / M99 subprogram calls. A callee's blocks are spliced into the program at the call site, so the rest of the run treats them exactly as if they had been written in the main file. The callee's file is looked up as stated in Finding a called program.

Arguments bind by argument specification I: A B C to #1–#3, I J K to #4–#6, D E F to #7–#9, H to #11, M to #13, Q R S T to #17–#20, and U … Z to #21–#26. G, L, N, O and P are not arguments — L is the repeat count and P the program number. Argument specification II, with its repeated I J K sets, is not modelled.

Call words may be variables or expressions. An argument, the program number P and the repeat count L — G65 P8010 A#120 H[#130], G65 P#500, M98 P#500, G66 P8020 X[#5+10] — are evaluated in the caller's context when the call is made. The P of an M99 return is evaluated too, where the M99 stands; it is not a program number but the sequence number of the caller's block to return to — M99 P#1. An argument that cannot be evaluated, because a variable in it is vacant, reports FanucMacroCall--ArgUnevaluated on the call line and leaves that local variable vacant inside the macro; for G66 it is reported once, on the G66 line, not on every block that triggers the macro. A P or L that cannot be evaluated reports VariableExpression--Unevaluated, one that is not a whole number reports ParsedInteger--NotWhole. A P that fails either way means the call is not made, and an M99 returns as a plain M99, to the block after the call; an L that fails is ignored, and the call is made once.

Note

A controller saved in a project by version 3.2.32 or earlier keeps the pipeline order it was saved with, in which call words are consumed before variables are evaluated: there every variable-driven argument reports FanucMacroCall--ArgUnevaluated. Re-create the controller from its brand preset to pick up the current order.

Program headers

A program header is read in its numeric forms, O1234 and <O1234>, on the first line or after a % line. A named header such as <PART_A_FINISH> is not recognized as a header: the line reports UnparsedText--Remaining and moves nothing.

Not supported

G10 programmable data setting, G50 spindle speed clamp, G31 skip, a G code chosen by a variable, G08 / G8.1 selections, and the external work offset (EXT).

Syntec

Syntec runs the ISO core plus the Fanuc-family subprogram calls (M98 / M198 / M99), # variables with the volatile, retained and system-control ranges, control flow (IF, GOTO, WHILE), and polar interpolation. A G code chosen by a variable, a system-control variable and a vacant read behave as stated under Custom Macro B. G65 / G66 macro calls are not supported on this preset: the call is reported as Parsing--Unconsumed and the macro body does not run.

Not supported. G65 / G66 macro calls, bare G05 P… HPCC selections (see Path smoothing), custom G macros defined on the controller, Pr parameter mapping, and twin-head / twin-turret program syntax.

Mazak

Mazak reads EIA/ISO with the Fanuc-family subprogram calls (M98 / M198 / M99), # variables with the volatile, retained and system-control ranges, control flow (IF, GOTO, WHILE), and polar interpolation. A G code chosen by a variable, a system-control variable and a vacant read behave as stated under Custom Macro B. G65 / G66 macro calls are not supported on this preset: the call is reported as Parsing--Unconsumed and the macro body does not run.

Not supported. G65 / G66 macro calls, MAZATROL conversational sections, and switching between MAZATROL and EIA/ISO inside one program. Export the EIA/ISO program from the controller.

Siemens SINUMERIK

Real .mpf / .spf programs replay end to end — this is not an ISO subset with a Siemens label on it.

Modal vocabulary. SUPA / G153 suppress all frames for one block and, like G53, position the spindle's gauge line in machine coordinates, so the tool length is left out of that block as well — a program that deselects the offset with D0 before such a Z move gets the same result either way; G70 / G71 units; the path-smoothing family (G60x / G64x, FNORM / SOFT / FFWON / COMP* / UPATH, CYCLE832); MSG() and STOPRE; CR= and TURN= arcs. Tail comments are quote-aware, so a ; inside MSG("A;B") does not truncate the block. G74 / G75 fixed-point return is claimed as a whole block, so the dummy axis values it carries never mint a rapid to those coordinates and its F never reaches the modal feedrate. G4 dwells for F seconds or S spindle revolutions — the ISO core's X / U seconds and P milliseconds are not SINUMERIK dwell words — and its F does not reach the modal feedrate either; a SINUMERIK controller saved by an earlier version takes these words when it is loaded.

Tools. T="NAME" string tool calls with D cutting-edge offsets, resolved through the $TC_DP tool table — lengths and radius plus additive wear. A name with no entry in the tool-name table changes no tool (ToolChange--NameUnresolved), so a run can finish without cutting; a D selected before the first tool call reads the row of tool 0 (SiemensToolOffset--TcdpRowMissing). T0 with M6 mounts nothing when the tool house has no tool 0, and leaves the last tool in the spindle. A tool an earlier tool change or a Manual Tooling entry took from the tool house keeps its number for the steps after it, and with it what HiNC takes from a tool-house tool — Feed per Tooth, Program Side Cusp, the cutting force, the cutter temperature and wear (Tooling--ZeroKeepsTool). The program's compensation is tool 0's from there on: a D reads the row of tool 0, as before the first tool call — normally no row, so no length compensation, and a tool the program's own tool change mounted now runs with its tip its whole length below the programmed path — silently on a block without a D word, with SiemensToolOffset--TcdpRowMissing on one that has it. For a tool a Manual Tooling entry mounted nothing changes at the T0: the program never called that tool, so its D read the row of tool 0 before the change as well, and the tool's length comes from a G43 H or the work offset's Z all along. The project's own tool, which HiNC counts as tool 0 until a tool change replaces it, is not a tool of the tool house: it stays tool 0 and its steps carry no tool values (Step-Tool--NotInHouse, A finished run with nothing to show).

Variables and expressions. R parameters R0–R999 are held as per-project data, DEF REAL / DEF INT declarations lower into assignments, and a full expression evaluator means Z=R63+150 and X=SIN(R10)*20 drive real motion. $P_UIFR[n,axis,TR] binds both ways to the frame table. Any other $ variable is recorded with an unsupported note rather than silently dropped.

Frames and five-axis. TRANS / ATRANS / ROT / AROT (with RPL=) and the solid-angle forms ROTS / AROTS compose into the tilt chain in Sinumerik RPY order (ROTS / AROTS behave as ROT / AROT: at most two angles, first-named axis first); TRAORI is a real RTCP mode, the sibling of ISO G43.4, with TRAFOOF handing the offset back; CYCLE800 is decoded from its MODE bits across all four swivel modes. From the build after 3.2.42, the orientation programming a TRAORI program can carry — the tool vector A3= / B3= / C3=, the angles A2= / B2= / C2= under ORIEULER / ORIRPY, the surface normals A4= / A5= and the ORI… interpolation words — is recognized but not simulated: the rotary axes keep their previously programmed positions, and each program reports Orientation-Vector--NotSimulated once. A controller saved in a project before then takes these words as named variables, with no message, until it is set again from the Siemens preset.

Calls and control flow. L-prefixed and named subprogram calls, inlined with their P repetition count; M17 / RET; REPEAT over a labelled slice; MCALL CYCLE81 / 82 / 83 / 85 mapped onto the shared canned-cycle machinery; PROC headers and labels. Only MCALL makes these cycles drill: a cycle called on a line of its own, such as CYCLE81(10,0,3,-6), is looked up as a subprogram and, with no .SPF of that name found, skipped with SiemensCall--Skipped. CYCLE800 and CYCLE832 are read directly. GOTOF / GOTOB, IF / ELSE / ENDIF, and WHILE / FOR / REPEAT-UNTIL / LOOP. Jumps and loop iterations are capped rather than hanging the session — over the cap the construct warns and falls through.

Per-word coordinate functions. AC() / IC() / DC() / ACP() / ACN(), including on I / J / K circle centres, so G90 C=IC(360/17) is one incremental index inside an absolute program. ACP() takes the forward window and ACN() the backward one, on a modulo axis (MD30310 = 1, see below); DC() takes the shortest swing on any rotary axis — a target exactly opposite turns positive, as the manual says.

Modulo rotary axes. A SINUMERIK rotary axis is a modulo axis only when its MD30310 row under Parameters (Native) is 1; the control's factory value is 0, and the play assumes it for an axis without the row. On a modulo axis a plain or AC() word moves the way the control's factory setting does (MD30455 bit 2 = 0): the target and the actual position are compared as the axis displays them, within 0–359.999°, and the axis turns positive when the target is the greater, negative otherwise, never through 0/360°. C350 from 0° turns +350°, and AC(0) from 240° turns −240°. Add the axis's MD30455 row under Parameters (Native) with bit 2 set (the integer 4) and plain words take the shortest way, as DC() does — an AC() written out keeps the comparison whatever the bit says; without the row, the first plain word on an axis whose compared direction is not the shortest-path one is reported once (Coord-McAbc--005). A word outside 0–359.999° — C-2.659, AC(-180), C400 — is converted into the range (B-5 = B355) and moved to from there; a control with bit 0 (the integer 1) clear would stop with an alarm instead, which the play reports once per axis (Coord-McAbc--006). On an axis that is not a modulo axis — a SINUMERIK axis whose MD30310 row is absent or 0, or a rotary axis of another control whose two limits on Machine Limits (Stroke) are set less than a turn apart — plain and AC() words are positions as written, like a linear axis's, while a DC() still takes the shortest swing, as the manual says, and ACP() / ACN() are reported (Coord-McAbc--007, naming the MD30310 row to enter; Coord-McAbc--003 on other controls) and stand as written. A plain word that turns a full turn or more as written — after DC() words ran the axis past a turn — is reported once per axis (Coord-McAbc--008), naming the MD30310 row and the turn a modulo axis would take; a value the block carries without a word, a CYCLE800 solve for one, goes to the turn nearest the current position that the limits admit.

Coded positions. CAC / CIC / CDC / CACP / CACN take a 1-based indexing position number instead of a coordinate, resolved against the machine's own indexing-position tables. On a SINUMERIK the positions wrap round — a CIC past the last position continues at position 1, and an equidistant definition divides 360° by MD30502 — only on a modulo axis (MD30310 = 1); without the row a CIC past the end is reported (CodedPosition--NumberInvalid, with CodedPosition--NotAModuloAxis naming the row) and the axis holds, an equidistant definition needs MD30501 as on a linear axis, and CACP / CACN, like ACP() / ACN(), are reported (Coord-McAbc--007).

OEM auxiliary M-codes. The preset declares M12 / M13 / M22 / M23 and M330 / M331 as note-only, so each occurrence voices DeclaredMCode--UnmodeledEffects rather than an unknown-code warning. A machine's own table overrides the declaration once the real effects are known.

Recognized, not simulated. SCALE / ASCALE, MIRROR / AMIRROR and CROTS — each reported as SiemensFrame--Unsupported.

Not supported. SETAL.

See Also

  • Heidenhain Support — klartext and Heidenhain DIN/ISO.
  • NC Parsing Engine — the pipeline behind these codes, the brand-by-brand support matrix in one table, and how a machine's own vocabulary is added without changing HiNC.
  • Program Reading — the Subprogram Folders setting behind Finding a called program: its storage, the folder anchor, and the file-name chains of every brand.
  • Persistent Variables — the retained #500–#999 ledger a program reads and writes, and the vacant value behind Variable--Vacant.