Per-Axis Tables

Four leaves of the Controller branch's machine plane are one table each, keyed on the machine's axes: Machine Limits (Stroke), Rapid Feedrates, Home / G28 Reference and Tool-Change Position. They live on the Equipment page at /equipment under the Control-Tree ids equipment/controller/machine/limits, equipment/controller/machine/rapid, equipment/controller/machine/home and equipment/controller/machine/tool-change; none of them is gated by a snapshot flag, so every brand grows all four. Two components serve them — one panel behind the first three, discriminating on the id's last segment, and a second behind Tool-Change Position — and the differences between those two components are what this page is mostly about. Machine Limits (Stroke) also carries one project-level switch, Stroke limit check, which has its own section.

Important

Anatomy makes no claim that any id named here is stable across versions. The migration hop that keeps an older ?tree= value resolving is described in Tree Ids and Routes.

Where the Rows Come From

Every row on all four leaves is one axis of the runner's machine-axis configuration, read as AxisNames through the proxy-resolved dependency list. On all five brand presets that configuration is the brand parameter table itself: ControllerParameterTableBase declares IMachineAxisConfig alongside IStrokeLimitConfig, IRapidFeedrateConfig and IHomeMcConfig, so one object supplies both the row set and three of the four value sets. Which brand carries which table is Brand Matrix.

The table's axis set is a single parameter row: the per-axis integer bucket under the table's axis-type number, whose keys are the axis names and whose values are the AxisType — linear, rotary or spindle. Adding an axis therefore means adding a key to that one row, and exactly one surface on this branch reaches it.

Neither panel here has an add-row or delete-row control. Both render a fixed header over one <tr> per axis and nothing else.
The four per-axis routes behind them write one axis' value and nothing more, and only for an axis their own read lists: the axis set the rows come from, which on a brand preset is the seeded X, Y and Z plus the machine chain's axes. The caller names an axis; the route matches the name against that list, ignoring letter case — the exact spelling first, otherwise the one row that differs from it only in case — and writes into the stroke-limit, rapid-rate, home or tool-change store under the listed spelling, so x lands on X. Any other name is refused inside the branch's success envelope: HTTP 200 with success: false, axes holding the listed names in their order, and a message naming the refused axis and the list — No axis 'Q' on this machine; its axes are X, Y, Z, B, C., or No axis 'Q' on this machine; it has no axes yet. while the list is empty; nothing is written. A name that matches two rows differing only in case, and neither of them exactly, is refused the same way, the message saying why: No axis 'ax' on this machine: several axes (AX, Ax) match it only ignoring letter case, so none is taken; its axes are …. A runner without the store refuses first, with the missing-dependency message, before the name is looked at. Tool-Change Position's list is its own rows, fallback included (see below), so every row the four leaves show can be written and no other name can. The panels send each row's own name, so the refusal is met only over REST. None of the four touches the axis-type row, so none of them changes which rows the next read returns.
Parameters (Native) edits the axis-type row itself, and is the one place on the branch that widens the axis set: the Add / Set footer of its Axis Parameters (Integer) leaf takes a free-text axis name, so the table's axis-type number, a name and a value of 0 linear, 1 rotary or 2 spindle adds an axis, which then appears on all four leaves. Its grid cannot — the per-axis columns are the union of the axis names already present, so a cell can be written only for an axis that exists — and its delete button removes a whole parameter row, every axis cell of one number at once, rather than one axis.

Axes arrive from the machining chain. Whenever the project opens, the setup equipment is edited outside a session, a session begins, or the active runner suit or the chain changes, the project service re-binds the suit and calls ConfigureByMachiningChain(API), which walks the chain's axis codes and their transformers: a rotating transformer writes the axis as rotary and any other transformer writes it as linear; every chain axis whose reference position is still unset is seeded to 0, and on a brand parameter table a rotary chain axis with no rapid-rate row of its own is seeded to 36000 deg/min. That is the mechanism behind the description above the Home / G28 Reference table, "Axes without a value are seeded to 0 when a machine tool attaches."

The stamp adds rows and never removes one. The generic axis configuration carried by the CSV and CL runner suits is cleared before the walk; a brand parameter table is not, and keeps every axis it already held. An axis dropped from the chain therefore keeps its rows on all four leaves, and no surface removes it individually. The three-axis default table every brand preset seeds is why a project with no machine tool attached still shows X, Y and Z.

The stamp overwrites the axis type and nothing else. A chain axis takes its chain type back at every re-bind, but a value the table already holds stays, on a rotary chain axis as on a linear one: the walk fills a reference position or a rotary rapid rate only where the axis has none. So a Home Position or a Rapid Rate edited here, a cell written in Parameters (Native), and the rotary rapid rate a project saved in the legacy format brings from its MaxRotarySpeedABC_rpm, at rpm × 360 deg/min — 21600 deg/min at the legacy model's default of 60 rpm (see Legacy Controller Model) — all reach the play. A linear axis gains no rapid-rate row from the walk; one without a row of its own reads the 20000 mm/min default described under The Value Columns.

The caption below the first three tables records the row half of that: "Axis rows follow the Machine Tool chain; they cannot be added here." Where the chain itself is edited is Machine Tool.

The Value Columns

Each leaf renders the axis column, its own value column or columns, and a unit column.

Leaf	Value columns	Empty cell means
Machine Limits (Stroke)	+ Limit, − Limit	no limit set for that axis and side
Rapid Feedrates	Rapid Rate	never empty — see below
Home / G28 Reference	Home Position	no reference position stored
Tool-Change Position	Stays put, Position	see Stays Put

The stroke-limit and home readers return an optional value and hand null straight through, so an unset cell is blank. The rapid reader does not: it returns the stored rate, or — when the axis has no rate of its own — the base class's fixed default, 20000 mm/min for a linear axis and 36000 deg/min for a rotary one. So a Rapid Rate cell is always a number, and a number in it is not proof that the axis has a row.

A table cloned fresh from a brand's preset seed decides what the three leaves then open on, and all four brand defaults agree in shape: a linear X, Y and Z, a reference position of 0 on each, and a rapid rate per axis — and no stroke limit at all. Machine Limits therefore opens entirely blank on every brand, while Rapid Feedrates and Home / G28 Reference open populated. Whether a brand switch clones a fresh table or keeps the project's own is Machine and Controller Plane.

The Unit Column

The unit column's header is the translated label Unit; its cell text is not translated and does not come from the server. Each panel computes it in the browser from the row's rotary flag, using literal strings:

Leaf	Linear axis	Rotary axis
Machine Limits (Stroke)	`mm`	`deg`
Rapid Feedrates	`mm/min`	`deg/min`
Home / G28 Reference	`mm`	`deg`
Tool-Change Position	`mm`	`deg`

The flag itself is server-side, and it is the axis type rather than a separate setting: an axis stored as rotary or as spindle reports rotary, so a spindle-mode axis is labelled in degrees.

The unit is a label, not a conversion. The base class writes a linear and a rotary rapid rate into the same per-axis cell and reads them back through the same lookup, differing only in the default returned when the cell is absent; the stroke-limit and home accessors are equally unit-blind. Nothing on these three leaves converts, so their numbers are the raw stored numbers, and the same values appear in Parameters (Native) under the brand table's storage key, where the caption under each key names the same unit — Positive stroke limit (mm or deg), or G28 first reference position (mm or deg) on the Fanuc table:

Role	Fanuc	Mazak	Syntec	Siemens	Heidenhain
Axis type — the row set	1006	1006 †	1006 †	30300	400 †
Reference position (home)	1240	1240 †	1240 †	34010 †	410 †
Positive stroke limit	1300 †	1300 †	1300 †	36100 †	420 †
Negative stroke limit	1320 †	1320 †	1320 †	36110 †	430 †
Rapid rate	1420	1420 †	1420 †	32000	1010

† Known not to be the control's own parameter number for the value; Parameters (Native) flags the row with a warning line under its caption.

The Mazak column repeats the Fanuc one because the Mazak preset carries the Fanuc parameter-table proxy: the same table, numbered after FANUC's parameters. A MAZATROL control names its parameters by letter group instead — F91, M1 and so on (MAZATROL MATRIX Programming EIA/ISO H740PB0030E) — so under a Mazak brand marker the native form flags every one of these keys. That flag is the web service's, read from the brand marker; the engine's table is the same under both markers. The Syntec table keeps the Fanuc table's numbers under its own Pr prefix, and Siemens spends its rapid-rate role on the max-axis-velocity machine datum.

These numbers are the table's keys, not a list of the controls' numbers. Each number above is the key the brand table keeps that role under, modeled on a controller's parameter numbers, and the project file stores the value under it. The table marks the keys known to differ; an unmarked key is not thereby the control's number. The stroke pair is marked on every brand, as keys that are not the controls' numbers for those limits — although a FANUC 0i-C's No. 1320 and a SINUMERIK's MD36100 and MD36110 are stroke parameters, for the other end:

A FANUC 0i-C keeps stored stroke check 1 at No. 1320 for the positive end and No. 1321 for the negative end, and its No. 1300 is a bit parameter (FANUC Series 0i-C / 0i Mate-C Parameter Manual B-64120EN/01, pp. 53, 50), so the 1320 here holds the negative end where the FANUC 0i-C's No. 1320 holds the positive one.
On a SINUMERIK, MD36100 is the minus and MD36110 the plus software limit switch (SINUMERIK 840D sl Extended Functions Function Manual 09/2011, 6FC5397-1BP40-2BA0) — the reverse of the two keys here.
A TNC 426 or TNC 430 keeps its software limit switches at MP910.x for the positive end and MP920.x for the negative end; there MP420 turns the Hirth coupling on or off and MP430 is the Hirth increment (HEIDENHAIN Technical Manual TNC 426 / TNC 430, 11/2003, §4.3.1; the same in the Technical Manual TNC 407/415/425, 01/1998). A TNC 640 or TNC7 numbers its machine parameters in six digits and has no MP420 at all.
A Syntec control keeps its software stroke limit 1 at Pr2401~Pr2440; its Pr1300 is the 20th axis' backlash critical speed and its Pr1320 the 20th axis' pitch error compensation type (SYNTEC CNC Parameters, 2019-05-30, §1.142, §1.87, §1.88).

Beyond the stroke pair, the reference position is marked on the Syntec, Siemens and Heidenhain tables: a SINUMERIK keeps the reference point value at MD34100, $MA_REFP_SET_POS (6FC5397-1BP40-2BA0); a TNC 426 or TNC 430 spends MP410 on assigning the axis keys IV and V; and on a Syntec control Pr1221~Pr1240 enable each axis' backlash compensation. Syntec's rapid-rate and axis-type keys are marked as well: its Pr1401~Pr1420 are each axis' mechanical compensation time constant, and Pr1006 falls inside the Pr1001~Pr1020 block that sets each axis' fast return home (SYNTEC CNC Parameters, 2019-05-30). So is Heidenhain's axis-type key: neither a TNC 426 or TNC 430 nor a TNC 407, 415 or 425 has an MP400 — their machine-parameter lists go from MP340 straight to MP410 — and there an axis is rotary through its letter in the axis designation, MP100 / MP410.

Four keys are known to be the controls' own numbers for these values, and the tables leave them unmarked: No. 1240, the first reference position, and No. 1420, the rapid traverse rate, on a FANUC 0i-C; MD32000, MAX_AX_VELO, on a SINUMERIK; and MP1010, the rapid traverse, on a TNC 426 or TNC 430. Under a Mazak brand marker the two FANUC numbers are flagged with the rest of their column. No. 1006 is the FANUC 0i-C's number as well, but a FANUC 0i-C holds bit flags there where the table stores the axis-type ordinal, so its value does not copy across as it is.

A value read off a real control therefore goes into a cell here by its meaning — + Limit or − Limit, Home Position, Rapid Rate — and in the unit its row names, the Unit column here or the caption in Parameters (Native), never by matching its number. The unit matters as much as the meaning, because a control may show the same travel in another unit: a FANUC 0i-C keeps No. 1240 and No. 1320 / No. 1321 as integers in its least increment (IS-B: 0.001 mm / 0.001 deg; B-64120EN/01 pp. 48, 53), and a Syntec control keeps its stroke limits in BLU (SYNTEC CNC Parameters §1.142). Copied as shown into these millimetre and degree rows, a 500000 µm limit becomes 500000 mm, and the check never fires. The keys themselves stay as they are, because every saved project holds its values under them. The marked keys among the system parameters, and how the native form flags a marked row, are on Native Parameters.

Tool-Change Position stands outside the keys and the native form: its values live on ToolingMcConfig, a plain runner-owned dependency rather than a parameter table, so they have no key, appear in no native form at all, and a brand apply returns them to the preset defaults — see Machine and Controller Plane.

Stays Put, and the Sentinel Behind It

IToolingMcConfig stores one number per axis, and the contract gives one number a second meaning: NaN means the axis stays where it is during a tool change. The read splits that back into two fields — a stored NaN becomes the Stays put flag with no position, anything else becomes the position — and the panel renders the flag as a checkbox and the position as a numeric field disabled while the box is ticked.

Writing goes the same way round. Ticking the box sends the stay flag and the reader writes NaN. Unticking it sends a position, and because the panel clears its own cell when the box is ticked, the position it sends on the way back is 0 — so unticking parks the axis at machine zero rather than restoring what was there before.

A third state exists and is not the sentinel: an axis with no entry in the map at all. Its box is unticked and its Position cell blank, because the reader reports no position and no stay. At run time the two are indistinguishable — the tool-change motion overlays only those axes that carry a number and are not NaN onto the current pose, and leaves every other axis alone. So the machine stays put either way; the tick mark distinguishes only how that was recorded.

The overlay has a vocabulary of its own, narrower than the table. X, Y and Z always take part; every other axis takes part only while the machine declares it rotary. A linear axis outside those three is stored, shown and editable on this leaf, and never moved.

The preset default is exactly this mixture: X and Y carry the sentinel, Z carries 0, and no rotary axis carries an entry, which is why a rotary axis usually opens unticked and blank.

Above the table sits Tool-change mechanism time, a single field in seconds bound to ToolingTime. It becomes the duration of the tool change step the runner emits, and it is the changer mechanism alone — the axis travel to and from the position is timed separately from the positions in the table. It is 0 on every brand preset, and it is written into the runner file only when non-zero.

One Reader, Two Readings of Its Presence Flag

All four reads answer the same shape: a present flag plus one row per axis. present reports whether the backing configuration resolved — stroke limit, rapid feedrate, home or tool change — and it is computed independently of the rows. Each reader builds the row list from the axis set whether or not that configuration resolved, and fills the value cells from an optional reference, so a missing configuration yields blank limit and home cells, a 0 rapid rate, and rows all the same.

The two components read the answer differently, and this is the sharpest divergence between them.

The axis-table panel discards present entirely. Its typed reader parses the flag; the panel assigns only the rows. Its second empty layer keys on the row count instead: with no axes it shows "No machine axes yet — these rows are driven by the Machine Tool chain. Attach a machine tool to edit per-axis values.", and with axes it renders the table whatever the flag said.
The tool-change panel reads present and, when it is false, shows "No tool-change config on the active runner."

What that costs: a runner that has axes but no stroke-limit, rapid-feedrate or home configuration renders a full, editable table of blank or zero cells, and every commit fails with a toast naming the missing dependency instead of the panel saying the table is absent. On the five shipped brand presets the state cannot arise, because the one object that supplies the axis set supplies all three configurations too. The reachable case is the mirror one, and it reaches the two panels differently: deleting the axis-type parameter row from Parameters (Native) empties the axis set, and the three axis-table leaves fall to the no-axes line while Tool-Change Position keeps its rows, because its reader falls back to the tool-change configuration's own axis keys when the axis set is empty, and its writer accepts the same rows. Rows recovered that way are reported as linear whatever they are.

The tool-change flag itself is never false on a shipped preset: all five carry the tool-change configuration as a plain entry, so the server reports it false only on a hand-built or file-loaded runner. The empty line is nevertheless on screen while the read is in flight and stays there after a failed one, because the panel's presence flag starts false and the failure path only raises a toast. For the same reason a failed read on the three axis-table leaves leaves their rows empty, so those leaves show the no-axes line rather than the table.

Above both layers sits the shared no-runner guard every leaf of the branch carries; it, and the commit, rollback and toast rules the four leaves share with the rest of the branch, are Editing Contract.

Editing a Cell

Numeric cells are the shared numeric field, so a value commits on blur or on Enter and never per keystroke — its full contract is Numeric Input. The Stays put checkbox commits on the click. Three details govern how these four leaves commit:

The writes are per cell, not per row. Editing + Limit sends that side alone, and the endpoint leaves a side it was not sent unchanged. The branch's row-shaped editors do not agree on this: a tool-offset or work-coordinate edit resends the whole row, while Parameters (Native) writes one axis cell at a time as these four do.
Clearing a cell writes nothing. An emptied field parses to null and the handler returns before the request, so the box is left blank on screen while the stored number stands, and the number returns when the panel is remounted by selecting another node and coming back. There is consequently no way to unset a stroke limit or a reference position from these panels; the only surface that removes one is the whole-row delete on the Axis Parameters leaf of Parameters (Native).
No cell is bounded. None of the four tables passes a minimum or a maximum to its fields, so a negative limit or a negative rapid rate is accepted and stored. The mechanism time is the one bounded field on the four leaves, at zero or above.

The Stroke-Limit Check Switch

Machine Limits (Stroke) carries one control that is not a cell: the Stroke limit check toggle, with a caption beneath it — "On: every played step is checked against the limits below, and a session warns as it begins about linear axes without both limits. Off stops both; the NC program's blocks are still compared with these limits at their end positions, but a motion that leaves the travel mid-block, such as a drilling cycle's plunge or an arc, is then not caught." It is drawn on that leaf alone; Rapid Feedrates and Home / G28 Reference, served by the same component, carry none. It sits first in the panel, above the description and the table, and stays there above the no-axes block when the axis set is empty, because it belongs to the project rather than to any axis. The description above the table points back at it: "Machine travel limits per axis (empty = no limit set). Which checks compare against them is set by the switch above." The label and the caption are translated; the toggle's hover title carries the raw identifier EnableStrokeLimitCheck, the name the session-begin warning below gives the switch, and the toggle is marked data-setting="EnableStrokeLimitCheck", a locator that reads the same under every language.

The switch is EnableStrokeLimitCheck, a project-level flag, on by default and saved with the project. It is neither a row of the parameter table nor a value of the runner, so installing a runner file or switching the brand leaves it as it was. It governs two things:

The per-step check. While the switch is on, every played step's machine pose is compared with the limits — this table's, or the legacy stroke boxes' on a runner that carries no stroke configuration — as the next section describes. While it is off, no step is compared, so none is reported and none pauses the player.
The session-begin warning. While the switch is on, each session reports StrokeLimit--Unconfigured once on the Shell tab as it begins, naming every linear axis of the machine chain that lacks a positive or a negative end in this table and in the legacy box behind it alike; the text points at this leaf and names the switch as EnableStrokeLimitCheck. While it is off, the session says nothing about the limits.

It does not govern the comparison made as the program is read. A block that ends past a limit set here is reported as StrokeLimit--Positive or StrokeLimit--Negative with the switch on or off, and the rotary limits steer the tilt solves either way. That comparison sees each block only at its end position, so it does not stand in for the per-step check: with the switch off, a block that passes a limit only on its way — a drilling cycle's plunge, an arc's bulge — and ends inside the travel goes unreported. Turning the switch off unsets no limit; only a limit's absence silences the block reports, and the one surface that removes a limit is named under Editing a Cell.

The play reads the flag from the project's own configuration at every step, so a change reaches the per-step check from the next step played, in a play already under way too. The warning is raised once as a session begins, so a change reaches it from the next session.

The toggle reads its value when the leaf mounts, and again whenever the Equipment page is shown after another page. The page is kept alive while another page is open, so coming back to it remounts nothing; that second read is what puts a value changed meanwhile — by a mission script through SessionShell.EnableStrokeLimitCheck, or over REST — on screen when the user comes back. Until a read has answered, the toggle is disabled. A failed read raises a toast with the context Load stroke limit check, and a toggle no read has answered yet stays disabled until one does. A click commits at once in the branch's optimistic shape — the toggle flips, the write goes out, and a failed write flips it back with a toast under Save stroke limit check — see Editing Contract. While its write is on its way the toggle is disabled too, so a second click cannot overtake the first.

Over REST the switch is GET /api/Controller/stroke-limit-check, which answers a bare JSON true or false, and PUT on the same route with a bare JSON boolean as its body, which answers 200 with no body. Both answer 404 with the coded NoProjectLoaded payload when no project is loaded, and that is their only guard: unlike the legacy routes beside them on /api/Controller, they do not need the legacy controller model — see Legacy Controller Model. A mission script reaches the same project flag as EnableStrokeLimitCheck(API); the two routes above are its only REST face.

What the Values Do When a Program Plays

The stroke limits are compared at two moments, and only the second listens to the switch.

As the program is read, one of the semantics that end the runner's pipeline, in every brand preset, compares each block's end position with the table: the machine position once the block has executed, every axis name its machine-coordinate record carries, each against the limit stored under that name. A value past a limit is reported as StrokeLimit--Positive or StrokeLimit--Negative, an error on the NC Diagnostics tab anchored to the block. Only the values that changed from the previous block are compared, so the block that moves into a violation reports it once instead of every later block repeating it. A position the block reaches only on its way is never compared here — a canned cycle's plunge, whose motion goes down to the hole bottom while the block ends back at the R point or the initial level, an arc's bulge, a G28 intermediate point, the swing of a tilt or of an RTCP move. This comparison runs wherever the table holds an end, whatever the switch says, and it never pauses the player.
As each step plays, while the Stroke limit check switch is on, the chain's current machine pose is compared with the limits; a position past one is reported as Stroke-Limit--Over, a validation error on the Step Diagnostics tab anchored to that step, and pauses the player when pause-on-failure is set. This check walks a fixed axis vocabulary — X, Y and Z from the machine point, A, B and C from its orientation — so a limit stored against any other axis name is kept and shown here but never tested at a step. It is the only check that sees the positions a block passes through, so while the switch is off a block that passes a limit on its way and ends inside the travel goes unreported.

Both comparisons carry the same small tolerance (Tolerance), so an axis parked exactly on its limit is not reported. The rotary limits also steer the tilt solves, whatever the switch says: when a G53.1, G68.2, CYCLE800, PLANE SPATIAL or LN posture has its nearest rotary solution outside the travel, the solve takes the admissible branch nearest the entry instead of commanding a posture the machine cannot take. A project that declared its travel only in the legacy machine-limits boxes gets those ends copied into this table on load, for the axes carrying no end here. Rapid-traverse timing walks the per-step check's six names too: a G00 move is timed axis-by-axis at each axis' rate and takes the slowest, falling back to the same 20000 mm/min and 36000 deg/min defaults when no configuration answers.

The reference positions reach further, but only at the start. The initializer that sets the machine pose at the first block writes every declared axis, reading each axis' stored reference and falling back to 0 for one that has none. The G28 reference return reads the same store through a narrower window: X, Y and Z for its linear stage, and A, B or C for its rotary stage — and a rotary letter only while the machine declares that axis rotary and a reference position is stored for it, an unconfigured one being reported as a validation error instead. So an axis outside the six canonical names still carries its stored reference into the pose at the first block, while its rapid rate and its G28 return are inert and its stroke limit is never tested at a step.

Layout

Equipment Control Tree — the tree column of /equipment
- Controller Node Row
  - Machine / Controller Group Row
    - Machine Limits (Stroke) Node Row — equipment/controller/machine/limits
    - Rapid Feedrates Node Row — equipment/controller/machine/rapid
    - Home / G28 Reference Node Row — equipment/controller/machine/home
    - Tool-Change Position Node Row — equipment/controller/machine/tool-change
Editor Column — beside the tree column, at the page's full height: the panel of whichever node is selected
- Machine Limits (Stroke) / Rapid Feedrates / Home / G28 Reference Panel — one component, its role taken from the selected id's last segment
  - Stroke limit check Toggle — on Machine Limits (Stroke) only, first in the panel whether or not the axis set is empty; dense, disabled until a read answers and while its write is on its way, re-read each time the Equipment page is shown again, its hover title EnableStrokeLimitCheck, marked data-setting="EnableStrokeLimitCheck"
  - Scope Caption — on Machine Limits (Stroke) only, under the toggle: "On: every played step is checked against the limits below, and a session warns as it begins about linear axes without both limits. Off stops both; the NC program's blocks are still compared with these limits at their end positions, but a motion that leaves the travel mid-block, such as a drilling cycle's plunge or an arc, is then not caught."
  - Description Caption — "Machine travel limits per axis (empty = no limit set). Which checks compare against them is set by the switch above.", "G00 rapid traverse rate per axis." or "G28 first reference (home) machine coordinate per axis. Axes without a value are seeded to 0 when a machine tool attaches."
  - Axis Table — dense, flat, bordered
    - Header Row — Axis, then + Limit and − Limit, or Rapid Rate, or Home Position, then Unit
    - Axis Row, one per axis
      - Axis Name Label — bold, not editable
      - Value Numeric Field, one per value column
      - Unit Label — mm / deg, or mm/min / deg/min on Rapid Feedrates
  - Footer Caption — "Axis rows follow the Machine Tool chain; they cannot be added here."
  - No-Axes Block — replaces the description, the table and the footer caption when the axis set is empty, below the toggle and its caption on Machine Limits (Stroke): a precision-manufacturing icon beside "No machine axes yet — these rows are driven by the Machine Tool chain. Attach a machine tool to edit per-axis values."
- Tool-Change Position Panel
  - Tool-change mechanism time Numeric Field — suffixed s, minimum 0
  - Axis Table — dense, flat, bordered
    - Header Row — Axis, Stays put, Position, Unit
    - Axis Row, one per axis
      - Axis Name Label — bold, not editable
      - Stays put CheckBox
      - Position Numeric Field — disabled while Stays put is ticked
      - Unit Label — mm / deg
  - Footer Caption — “Stays put” leaves the axis where it is during a tool change.
  - No-Config Block — replaces the field, the table and the caption: "No tool-change config on the active runner."
- Shared Empty State — replaces either panel's whole body while the snapshot reports no runner: "No NC runner — load a project first."

Source Code Path

See HiNC App Anatomy for git repository links.

Web Application

HiNC-2025-webservice (Quasar CLI SPA):

wwwroot-src/src/components/controlTree/SoftNcAxisTablePanel.vue — the panel behind the first three leaves: the role taken from the node id's last segment, the Stroke limit check toggle and its caption drawn on the limits role alone above both the no-axes block and the table, with its disabled state while unread or writing, its optimistic write and its second read each time the Equipment page is shown again, the value columns and description per role, the unit strings computed from the row's rotary flag, the row-count empty layer that discards the read's presence flag, and the per-cell commit that returns on a cleared field.
wwwroot-src/src/components/controlTree/SoftNcToolChangePanel.vue — the tool-change panel: the mechanism-time field, the Stays put checkbox that clears the position and sends 0 on the way back, the disabled position cell, and the presence-flag empty layer.
wwwroot-src/src/components/controlTree/SoftNcEmptyState.vue — the shared no-runner line both panels open with.
wwwroot-src/src/components/widgets/NumericInput.vue — the numeric cell: commit on blur or Enter, and the empty-text-to-null parse the panels reject.
wwwroot-src/src/components/controlTree/softNcItemTypes.ts — the four node ids, their labels and label keys, and the two item types that bind them to the two panels.
wwwroot-src/src/api/softNcRunner.ts — the four readers and their setters: the row shapes, the presence flag both panels receive, the per-side stroke-limit payload, and the stay-or-position tool-change payload.
wwwroot-src/src/api/controller.ts — the switch's client: getStrokeLimitCheck and updateStrokeLimitCheck over the two stroke-limit-check routes, which throw on a 404 or a 500 rather than answer a default.
wwwroot-src/src/composables/useSoftNcRunner.ts — the shared runner snapshot the first empty layer reads.
wwwroot-src/src/i18n/en/softNc.ts — the four node labels, the three descriptions, the column headers, the two footer captions, the two empty-state lines, and the switch's label, caption and two error contexts quoted above.
wwwroot-src/src/i18n/en/common.ts — the shared Axis and Unit column headers.
wwwroot-src/src/components/controlTree/SoftNcNativeParamsPanel.vue — the panel behind the neighbouring Parameters (Native) leaves, which edit the same parameter rows by number: the per-cell axis writes, the grid columns unioned from the existing axis names, the delete that drops a whole row, and the Add / Set footer whose free-text axis field is what widens the axis-type row.
Mech/SoftNcRunnerController.cs — the REST surface: the chain-driven axis helper every reader builds its rows from, the four readers with their independently computed presence flags, the four per-axis writers, which resolve the named axis against the rows their own read lists, ignoring case, refuse any other name with that list, and never declare an axis, the native per-axis-integer route that does, the tool-change row list its reader and its writer share, with its fallback to the tool-change configuration's own axis keys, the NaN sentinel write, the rotary lookup the rapid write re-derives server-side from the resolved name, and the native read whose storage-key flag covers every captioned row but a work-offset address under a Mazak brand marker.
Controller/ControllerController.cs — the switch's two routes, a GET and a PUT on stroke-limit-check, guarded on a loaded project alone; beside them the legacy stroke-limit-xyz and stroke-limit-abc writers, which also write this table's X, Y, Z and A, B, C limits and refuse with 400 an array that is not six numbers long.

HiAPI Engine

HiMech/NcParsers/Dependencys/ControllerParameterTableBase.cs — the one object behind three of the four leaves: the axis set as the keys of the axis-type row, the reference-position, rapid-rate and stroke-limit accessors over the per-axis buckets, the fixed rapid defaults, the per-axis captions that name each row's unit, the storage-key marker the base sets on the two stroke-limit ids and each brand table extends, the query that tells an axis' own rapid-rate row from the default the reader answers, which the chain walk asks before it seeds a rotary rate, and the rotary configuration helper, which writes the axis type, the reference position and the rapid rate together over whatever the table holds and which the chain walk does not call.
HiMech/NcParsers/Dependencys/IMachineAxisConfig.cs — the axis contract and the axis-type enum whose rotary and spindle members both make a row rotary.
HiMech/NcParsers/Dependencys/IStrokeLimitConfig.cs — the limit accessors, and the per-step check itself with its fixed X/Y/Z and A/B/C vocabulary and its Stroke-Limit--Over validation report.
HiMech/NcParsers/Semantics/StrokeLimitCheckSemantic.cs — the per-block check: each block's end position, the machine-coordinate state the block leaves, against the table and nothing the block passes on its way, only the values that changed from the previous block, the StrokeLimit--Positive and StrokeLimit--Negative reports, and no switch consulted.
HiMech/NcParsers/Dependencys/StrokeLimitUtil.cs — the tolerance both checks share, and the chain-axis and missing-end helpers the session-begin warning is built from.
HiMech/MachiningProcs/MachiningActRunnerConfig.cs — the switch's flag: on by default, and read from and written to the project file with the rest of the project's act-runner settings.
HiMech/NcParsers/Dependencys/IRapidFeedrateConfig.cs — the linear and rotary rate accessors.
HiMech/NcParsers/Dependencys/IHomeMcConfig.cs — the reference-position accessors.
HiMech/NcParsers/Dependencys/IToolingMcConfig.cs — the tool-change contract: the NaN sentinel and the mechanism time.
HiMech/NcParsers/Dependencys/Generic/ToolingMcConfig.cs — the sole implementation: the per-axis map, the preset default of X and Y staying and Z at 0, and the serialization that omits a zero mechanism time.
HiMech/NcParsers/Dependencys/Fanuc/FanucParameterTable.cs, HiMech/NcParsers/Dependencys/Syntec/SyntecParameterTable.cs, HiMech/NcParsers/Dependencys/Siemens/SiemensMachineDataTable.cs, HiMech/NcParsers/Dependencys/Heidenhain/HeidenhainParameterTable.cs — the storage keys in the table above, the keys each table marks as not the control's number, each documented beside what the control keeps under that number or where it keeps the value, the brand wording of the reference-position caption, and the three-axis default each brand opens on.
HiMech/NcParsers/Dependencys/Fanuc/FanucParameterTableProxy.cs, HiMech/NcParsers/Dependencys/Syntec/SyntecParameterTableProxy.cs, HiMech/NcParsers/Dependencys/Siemens/SiemensMachineDataTableProxy.cs, HiMech/NcParsers/Dependencys/Heidenhain/HeidenhainParameterTableProxy.cs — the placeholders the brand presets actually carry: each clones its three-axis seed into the project's own dependency list when that list holds none, and resolves to the project's table when it does.
HiMech/NcParsers/SoftNcRunner.cs — the chain walk that stamps axis codes, fills a missing reference position and, on a brand table, a rotary axis' missing rapid rate; the legacy import that writes a legacy project's per-axis rotary speed into the rotary rapid rates; and the five brand presets that decide which parameter table and which tool-change configuration a brand carries.
HiNc/MachiningProcs/LocalProjectService.cs — where the chain walk is triggered from, why the generic axis configuration is cleared first and a brand table is not, the per-step stroke-limit check that returns at once while the switch is off and otherwise reads the limits through the proxy-resolved list, and the session-begin audit behind StrokeLimit--Unconfigured, silent while the switch is off.
HiNc/MachiningProcs/SessionShell.cs — the switch's mission-script face, a property over the same project flag the two REST routes read and write.
HiMech/MachiningProcs/MachiningSession.cs — the play loop that runs that check once per step and pauses on failure.
HiMech/NcParsers/Semantics/LinearMotionUtil.cs — rapid-traverse timing: per-axis rates, the slowest axis, and the same six axis names the stroke check uses.
HiMech/NcParsers/Initializers/HomeMcInitializer.cs — the reference positions written for every declared axis at the first block.
HiMech/NcParsers/LogicSyntaxs/ReferenceReturnSyntax.cs — the G28 return: the three linear names it resolves a final position for, the three rotary letters it tests against the declared axes, and the validation error a rotary letter the machine has not declared raises.
HiMech/NcParsers/LogicSyntaxs/ToolChangeMotionSyntax.cs — the overlay: X, Y and Z plus the declared rotary axes, of which only the ones carrying a non-NaN position move.
HiMech/NcParsers/Semantics/ToolChangeSemantic.cs — the tool-change step that carries the mechanism time as its duration.

Table of Contents