Building Virtual Machine Tools

A project's machine tool is the kinematic chain between the machine table and the tool spindle: the anchors that stand for the machine's components, and the branches that carry the motion between them. A chain arrives in a project by loading a machine tool file — one of the shipped machines, or one saved from another project — and is reshaped there; saved as a file of its own, one chain serves every project that runs on that machine.

Where it is

The Equipment page, at /equipment, reached from the menu bar's Equipment switch. Select the Machine Tool item of the Control Tree (/equipment?tree=equipment/mechanism/machine-tool), the first item under the Mechanism group. The item is a leaf: its panel, in the editor column beside the tree, carries the identity of whichever chain is attached and ends with the Roles panel. The chain's structure — its anchors, branches, transformers and shapes — is edited in place in the Topology column to the right of the canvas. That column is shown by default on a window at least 1280 px wide; the fourth column button in the menu bar's column row — Toggle the Topology column — shows or hides it.

The item selected on a demo project, at /equipment?tree=equipment/mechanism/machine-tool. The panel is the Object Management (⋮) button, a type badge reading GeneralXyzabcMachineTool, the Name: and File: lines naming the chain in force and the file it came from, a caption, the Enable Error Terms switch with a caption of its own (see Switching error terms off), and the Roles panel: Table Mount and Tool Mount bound to the chain's two end anchors, then Axis X to Axis C, each bound to the branch that drives that axis or left empty on an axis the machine does not have, and last Spindle, bound to the branch that turns the tool. The canvas is drawing the stock on its fixture.

Note

The equipment canvas does not draw the machine until you ask it to. The Scene dropdown above the canvas carries a Solid group whose Machine checkbox starts cleared, so a chain that loaded perfectly still leaves that canvas showing only the fixture and the workpiece. Tick it to bring the machine into the same scene; to see it without the fixture and the stock, set Fixture Rendering Mode, Raw Shape Rendering Mode and Target Shape Rendering Mode to Hide in the same dropdown.

Attaching a chain to a project

A chain file is not a project's machine until it is loaded onto one. The Machine Tool item's Object Management (⋮) menu is where a chain arrives and leaves:

Entry	What it does
Load	Picks a `.MachineTool` or `.mt` file from the project or the administrator directory and installs it as the project's chain
New ClMillingDevice	Attaches a CL-driven blank device instead — the one chain type that needs no file, because it has nothing to configure
Save As	Writes the attached chain out as a `.MachineTool` or `.mt` file, its role bindings included
Copy / Paste	Carry the chain between projects as XML
XML Mode	Shows the attached chain as XML and installs the result of an edit (Apply); Cancel leaves it as it was

Every chain type other than the CL-driven device arrives by Load, Paste or XML. Installing one re-attaches the fixture and workpiece mounts and rebuilds the Control Tree, so the rest of the equipment follows the new machine without being touched.

Tip

Load opens on the shipped machines. This menu's picker has two roots, the project folder and the administrator directory, and on this item it opens in the administrator directory's Resource → MachineTool folder, where the shipped chains are: the folders CT-350.default and Table-B1.default, each a five-axis machine with its shapes — open the folder and pick the .mt inside — and Empty-wXYOZSt.default.mt, a bare three-axis chain with none. A chain file of your own inside the project is one root switch away.

A Load from a file also re-points what the project saves. A chain picked from inside the project folder is remembered as a path relative to that folder. One picked from the shipped resource library is first copied into the project, under the same relative path and with its shapes, and the project refers to that copy — so editing the chain and saving the project never writes over the shared machine. Loading the same shipped machine again writes it over that copy at once, and the edits made to the copy are lost: Save As an edited machine under a name of its own before starting over from its preset. New ClMillingDevice clears that reference instead, so the fresh chain is saved inside the project rather than over the file the previous one came from. Paste and an XML apply leave the reference exactly as it was.

Checking what is attached

The item's panel names the chain in force: the type badge, the Name: line and, for a chain that came from a file, the File: line. The whole chain is one entry further: the Object Management menu's XML Mode opens the attached chain as XML, and Cancel closes it without installing anything. To see the chain, tick Machine as in the note above.

The /machine-tool and /util/mech-builder addresses open this item too.

Roles

The Roles panel at the end of the item's panel says which element of the attached chain plays each part. Each row is a role with a dropdown over the chain's own anchors or branches and a Pick on the graph button: press it, and the next click on a matching element in the Topology column binds it.

Role	Kind	What binds to it
Table Mount, Tool Mount	anchor, required	The worktable-end anchor that fixtures and workpieces attach to, and the tool-end anchor that tools attach to
Axis X, Axis Y, Axis Z	branch, optional, needs DynamicTranslation	The branch that carries that linear axis
Axis A, Axis B, Axis C	branch, optional, needs DynamicRotation	The branch that carries that rotary axis
Spindle	branch, optional, needs DynamicRotation	The branch that turns the tool about its own axis — the one arriving where the tool mount hangs from, turning about the tool mount's −Z through its origin. A run turns it to the spindle angle while the spindle stands (after M05, at an oriented stop); it is not an axis of the NC program

A machine without a given axis leaves that row empty, and so does a machine whose spindle branch carries no rotation: its spindle simply does not turn on the canvas. Binding an axis or the spindle to a branch carrying the wrong transformer kind is refused, and so is binding one element to two roles, or binding an axis or the spindle to a branch marked as an error term — the rows' dropdowns leave marked branches out. Under the rows the server's checks are listed, or All checks pass.: a mount not bound, a role bound to an element outside the chain's own assembly, one element playing two roles, a mount no branch chain reaches from the root, an axis or spindle branch on the wrong transformer kind, an axis or spindle branch that is not on the chain between the table mount and the tool mount, or a spindle whose rotation does not run along the tool mount's Z axis through its origin — turning it would swing the tool, so move its Pivot onto the tool mount's origin. The error terms are checked too, each marked branch by the first check that fits: an axis or the spindle whose own branch is marked, a marked branch carrying a Dynamic Translation or Dynamic Rotation, a marked branch between the spindle branch and the tool mount, and any other marked branch that is no axis' or spindle's error term; the Fixture and Workpiece items' Roles panels report every marked branch of theirs, as neither part has error terms. Rebinding a role re-attaches the fixture and the workpiece and the canvas redraws.

The chain itself — its anchors, branches, transformers and shapes — is edited in the Topology column: the graph draws the whole equipment with one cluster per part and the machine's role anchors badged Machine Tool · Table Mount and Machine Tool · Tool Mount; click an anchor to rename it, extend a new anchor from it, add a branch or give it a geometry, and click a branch to rename it or change its transformer. Clicking the machine's cluster — titled with the chain's assembly name followed by a Machine Tool badge — selects this item in the Control Tree, so the roles and the graph sit side by side. A CL-driven ClMillingDevice has no editable topology or roles, and the panel says so.

Building the chain

A machine is built by loading the shipped machine closest to it and reshaping it in the project. New ClMillingDevice is the only blank chain on offer, so a chain with X, Y, Z and rotary axes always starts from an existing machine — a loaded file, or one pasted or applied as XML.

Load a starting point. Object Management → Load on the Machine Tool item opens on the shipped machines, as above. Empty-wXYOZSt.default.mt is a bare three-axis skeleton whose anchors are O, base, X, Y, Z, w, S and t; the two folders hold a finished five-axis machine each. The load copies the machine into the project, so nothing that follows changes the shared file.
Reshape it in the Topology column. Click an anchor to rename it — the new name is committed when you press Enter or leave the field — to Extend a new anchor from it, to Add Branch to another anchor, or to delete it with a double-click on its delete button. Click a branch to rename it and pick its transformer. The card itself is described in Anchors and Roles.
Give each axis branch a matching transformer. A linear axis is a branch carrying a Dynamic Translation, a rotary axis one carrying a Dynamic Rotation — the two kinds whose value a run varies. Every other branch — but the spindle's, which may carry a Dynamic Rotation too (step 4) — carries a static kind or No Transform; an error measured on the real machine is added afterwards, as an error term on the card of the axis or the spindle it belongs to, once that role is bound.
Bind the roles in the Roles panel at the end of the Machine Tool item's panel, in the editor column: Table Mount to the worktable-end anchor that fixtures and workpieces connect to, Tool Mount to the tool-end anchor that tools connect to, each Axis row the machine has to the branch that drives it, and Spindle to the branch that turns the tool, when it carries a Dynamic Rotation. A shipped machine arrives with its roles already bound, and renaming an element keeps its role; deleting one gives its role up, with a notice naming the role, and that row is left to bind again.
Give the anchors shapes. Optional: tick Geometry on an anchor's card and pick Box3d, Cylindroid, StlFile or GeomCombination; the Transform picker under the kind moves or turns the shape into place, or leaves it as drawn with No Transform. Display color, above the shape, sets the colour that anchor's shape is drawn in; until it is set, the badge beside it reads auto.
Keep it. Saving the project keeps the edited chain in the project's own copy. For a file another project on the same machine can load, use Object Management → Save As, which writes a .MachineTool or .mt file with the role bindings in it.

Names a machine file is read by

A chain in a project holds its roles by identity: an anchor or a branch keeps its role whatever it is renamed to, and Save As writes the bindings into the file, so a file saved that way loads with the same bindings whatever its elements are called. A machine tool file that records no roles — the shipped machines, and files written by earlier releases — takes them from the names of its anchors and branches as it loads, and a file saved with its Table Mount or Tool Mount unbound looks for that mount by name the same way. For such a file the names below are not labels but what makes the machine work at all:

The motion axes are named on the branches. A branch named X, Y or Z is taken as that linear axis, one named A, B or C as that rotary axis. Use each keyword at most once — a machine without a given axis simply has no branch carrying that keyword.
The transformer kind is read with the name. A branch named X, Y or Z must carry a Dynamic Translation, and one named A, B or C a Dynamic Rotation. A branch correctly named but left on a static transformer is bound to its axis row yet contributes no axis — the Roles panel flags it under the rows — and the machine ends up with one fewer axis than it looks like it has.
The end anchors are w and t. w, the worktable-end anchor, is taken as the Table Mount, and t, the tool-end anchor, as the Tool Mount. A machine file missing either still loads, with a message for each end anchor it lacks, but it cannot move: simulating it stops with a message naming the missing keyword, the worktable end first.
O and base name the ground anchor and the machine base. They bind no role, but the collision pairs below leave them out only when they are spelled exactly.
The spindle is found by place, not by name. The branch arriving at the anchor the tool mount hangs from — S on the shipped machines — is taken as the Spindle when it carries a Dynamic Rotation turning about the tool mount's −Z through its origin, whatever the branch is called. A spindle branch on No Transform, or on a static offset, is no spindle: the machine plays as it did, its spindle not turned on the canvas. A rotation that misses the tool axis is not taken either, and the load says so, as turning it would swing the tool around.

Important

Spell every keyword exactly as written. The motion axes are upper-case X, Y, Z, A, B, C; the ground anchor is upper-case O; and the base and the two end anchors are lower-case base, t and w. The exact spelling is always found first. When no anchor or branch carries it but exactly one differs from it only in letter case, the machine still takes that one, and the load reports it: The machine tool takes the anchor [W] as its end anchor ‘w’, a name it matches only ignoring letter case; rename it to ‘w’. When several do, none is taken, and the load names them. An end anchor nothing matches leaves the machine without it — The machine tool has no end anchor ‘w’: no anchor carries that name. — and its generated collision pairs are skipped. O and base get no such tolerance: they are only dropped from the collision walk below when spelled exactly.

Branch direction is free: the motion, the axis keywords and the default collision pairs all read a branch the same way round. Pointing every branch away from the ground anchor is a readability convention — it makes the structure read outwards, ground → base → motion axes → the t and w end anchors. On an axis branch, direction also decides which side of the axis its error term goes on.

The names also decide what can collide with what. A machine file asking for its collision pairs to be generated is answered by walking the chain twice, from the root anchor — O on the shipped machines — to the tool mount and to the table mount. That walk needs both end anchors, so a machine missing one loads without its generated pairs, with a message saying so; a file that lists its collision pairs explicitly keeps them. Either way every run on the machine stops at its start, naming the missing end anchor. Everything named on the way becomes a collidable component; the two end anchors the machine took, whatever their spelling, and O and base are dropped from both walks, the tool holder, cutter shank and cutter flute are added to the tool side and the fixture and workpiece to the table side, and every pair across the two sides is generated except workpiece against cutter flute — that one is the cut, not a collision.

Where the numbers come from

The most convenient approach is to assemble the machine in CAD, position the moving elements at the machine origin — the position at which every machine coordinate reads zero, generally the home position — and then:

Export the main components as individual STL files from that one coordinate system, and set each into its anchor.
Measure, in the same CAD coordinate system, the tool-end anchor, the worktable-end anchor and a point on each rotary axis' pivot, and enter those coordinates into the topology.
Expect the axis directions from the base to the worktable end to come out negative. That is relative motion rather than a mistake: moving the table one way moves the tool the other way through the chain.
Keep these as the design values. An error measured on the real machine — a squareness, a rotary axis' pivot offset — does not go into them: it is added as an error term on the card of the axis it belongs to.

Keep the meshes coarse. A machine carrying too much mesh is slower to open and slower to check for collisions, so export the components at the resolution a picture of the machine needs rather than at the resolution CAD produced them at.

With no CAD assembly to measure, the catalogue is enough — see A machine with no model below.

Error terms

An axis or the spindle of the machine tool can be given an error term: a branch of its own, just before the branch that plays it, marked as an error term. It carries an error of the real machine, found by measuring it, rather than part of its design. The simulated controller computes the machine coordinates as if the marked branches were not there, while the simulated machine moves, cuts and collides with them as long as the project's error terms are on, as they are by default. The error ends up in the part, as on a real machine whose controller does not know its errors. How the controller and the machine each read the chain is Kinematic Topology.

An error term holds one fixed value, so it fits the constant errors a measurement of the machine gives: the squareness between two linear axes, the tilt of an axis, a rotary axis' pivot offset, a tilt of the spindle housing, an offset of machine zero. Errors that vary along an axis' travel — pitch and scale errors, straightness, a volumetric error table — do not fit, and neither do reversal and backlash, servo mismatch or thermal growth; what the simulation leaves out is Machine Geometric Error.

Where an error term may go

An error term is added on the card of the branch that plays its axis or the spindle, through the card's Error term option, and the editor builds it in its place:

On an axis or the spindle of the machine tool only. The option is on the card of a branch of the machine tool bound to Axis X … Axis C or Spindle, and on no other card. A fixture or a workpiece has no error terms — place that part where it really sits instead — and neither the tool's branches nor the attachments between parts offer one.
One per axis. An axis or the spindle takes one error term, which holds one value; two errors of one axis, such as a tilt and a pivot offset, go into that one value — a General Transform holds a rotation and a translation together.
Just before the axis branch. The editor adds an anchor of its own, named after the axis branch — or after the anchor the branch leads to, when the branch has no name — with err after it: Xerr for the branch X, or Xerr001 when an anchor already carries that name. The error term, a branch of the same name, runs from the anchor the axis branch started at to the new anchor, and the axis branch runs on from the new anchor with its name, its transformer and its role. The axis branch's direction decides which side of the axis that is: on one pointing toward the ground anchor, the error term lands after the axis instead, between it and what it carries, where a squareness, a tilt or a pivot offset typed into it is another error. Keep the axis branches pointing away from the ground anchor, as the shipped machines do. The error term is never the axis branch itself: marked, the axis would drop out of the controller's model, and with error terms switched off out of the machine too.
On a static kind. The error term carries a Static Translation, Static Rotation, Static Freeform, General Transform or No Transform, since an error holds one value and no axis drives it. Its kind picker offers only these, and a Dynamic kind is refused on it.
Not between the spindle and the tool mount. The option is refused on the card of a branch that lies between the spindle branch and the tool mount, where its error term would lie too and make the spindle read as off the tool axis. A spindle housing's tilt is the Spindle's error term, just before the spindle branch: between Z and the spindle branch on a three-axis machine, between B and the spindle branch on a B head.

When the editor refuses, the option stays where it was and the reason shows as a notification.

Adding one, step by step

On the shipped Table-B1.default machine the C axis is the branch C, from the anchor X to the anchor C, carrying a Dynamic Rotation about (0, 0, -1) through the pivot (0, 0, 0). A pivot offset of that axis — its centre of rotation measured off where the design puts it — is the C axis' error term:

Open the axis branch's card. In the Topology column, click the branch C. Its card ends with the Error term option.
Switch on Error term. The editor inserts the anchor Cerr and the error term Cerr, from X to Cerr; C now runs from Cerr to C and keeps its name, its rotation and its Axis C role. The card stays on C and shows an Error term chip beside the option, the two anchors the error term joins, X → Cerr, and the error term's editor below them: a Static Rotation of 0° about (0, 0, 1), which leaves the machine as it was. The graph draws the branch Cerr thick, with an orange Error term badge.
Enter the error. In the error term's editor, pick Static Translation and type the offset — where the centre of rotation really is, less where the design puts it. A value is committed when you press Enter or leave its field, and each commit rebuilds the machine, which can keep the card busy for a few seconds.

The card of C right after step 2, on a demo project at /equipment?tree=equipment/mechanism/machine-tool, with the canvas column hidden and the graph laid out top-down:

At C = 0 the error term moves the table by the offset too. On the real machine a touch-off takes that into the work offset and leaves only the turn about a centre that is off; P0 does not, as Work offsets on a machine with error terms explains.

Clicking the branch Cerr in the graph opens the error term's own card: This branch is the error term of Axis C; it is added and removed on the card of Axis C. Its kind and value can be edited there too, among the static kinds. Switching Error term off on the card of C takes the branch and the anchor Cerr out again, and C runs from X as before. Take an error term out that way rather than by deleting the branch Cerr, which leaves the anchor C cut off from X, or the anchor Cerr, which takes the axis branch C with it and unbinds Axis C.

The other errors are added the same way, on the card of the axis or the spindle they belong to: a squareness between X and Y is a Static Rotation in the X axis' error term, between the anchor Y and the X axis branch, and a tilt of the spindle housing a Static Rotation in the spindle's error term, between the anchor B and the spindle branch S. The error term's anchor needs no shape, and without one it takes part in no collision check. Keep it so: a shape, a role or another branch into or out of that anchor is taken, but the branch then stops counting as the axis' error term (Limits). A segment split by hand into the same shape — a marked branch of a static kind, the only one into an anchor with no shape and no role, from which only the axis branch goes — reads as that axis' error term.

What a mark changes

Where the error sits, and how the program moves, decide what marking it changes in an NC program:

Without RTCP or a tilted working plane, the machine coordinates come from the program and its offsets alone, whatever the chain holds, so every error in the chain is cut into the part, marked or not.
With RTCP (G43.4, TRAORI, M128) or a tilted working plane (G68, G68.2, CYCLE800, PLANE), an unmarked pivot offset, squareness, tilt between rotary axes or offset on the tool side is part of the machine the controller knows, so the machine coordinates follow it. Marked, the machine coordinates stay those of the design machine, and the error is cut into the part.
A translation between the last rotary axis on the table side and the Table Mount only moves where the part's coordinates start, as placing the part elsewhere would. The controller cannot see it, marked or not, and on the shipped machines no axis follows it, so the editor offers no error term there.

A CL file played on the machine goes through the same controller, which leaves the marked branches out as well.

Switching error terms off

The Machine Tool item's panel carries an Enable Error Terms switch right above the Roles panel, with the caption Off: the machine moves without its error terms, and none is cut into the part. Either way, the controller computes the machine coordinates as if there were no error terms. It is on by default and belongs to the project, which saves it; the marks themselves belong to the machine, and Save As writes them into a machine file with the rest of the chain.

Switched off, the machine runs every marked branch as No Transform: it is the design machine and cuts like one. The marks stay, the Equipment canvas still draws the values as entered, and the card's chip and the graph's badge read Error term (not in effect), the badge outlined. That makes the switch the way to compare the part with and without the machine's errors. Each step's machine coordinates are the same either way; what differs is the tool tip — the step's CL, the tip in program coordinates — its feed rate, the cut, the forces and heat, and the collisions. The two runs can differ in their number of steps, so compare them by time or by machine coordinates, not by step number.

With no run session open, the machine follows the switch at once. With one open, the Equipment page shows Equipment edits are pending: a run session is still open, so the scene follows them at the next Reset. with a Reset now button, and the machine follows at that reset or at the start of the next play. No mission command sets the switch, and no message at the start of a run says whether error terms are in effect: this switch and the badges are where to look.

Work offsets on a machine with error terms

P0 on a Work Coordinates row (Set to the machine position at program zero), the alignment call that places the part on an offset, and the coordinate the canvas marks for a row all measure the machine as the controller knows it, with every marked branch left out. They answer the same whichever way the switch stands, so a part aligned to an offset gives that offset back under P0.

A touch-off on the real machine differs: it finds the part where it really is, so the work offset it gives already holds the shift the machine's errors cause with every axis at zero. P0 measures the machine as designed, so that shift stays in the simulated cut with the rest of the error. To reproduce a given shop's cut, type the work offset that shop measured — G54, or whichever row the program uses — into the row by hand rather than pressing P0; the two directions of alignment are Program Zero Alignment.

Limits

A later edit is not refused. The editor builds an error term in its place when it adds one and does not guard that place afterwards. Binding its axis to another branch, deleting the axis branch, giving the error term's anchor a shape or binding a mount to it, or adding a branch into or out of that anchor goes through, and leaves the mark on a branch that is no axis' error term: the Roles panel reports it, the branch's card shows the finding with a Clear mark button, and the axis branch's card shows no error term. The branch keeps its mark and its value, so putting the place back — the shape taken off, the role bound back — makes it the axis' error term again. Rebinding the spindle or the tool mount can likewise bring an error term between the spindle and the tool mount, which the Roles panel reports too. The rules on axes, the spindle and Dynamic kinds hold at every edit: binding an axis or the spindle to a marked branch, and giving a marked branch a Dynamic kind, are refused.
A file can bring a mark in anywhere. A machine or project file edited by hand can carry a mark on a branch of the machine tool, the fixture or the workpiece where the editor never puts one. The Roles panel reports it, and the branch's card shows the finding with a Clear mark button, which takes the mark off and leaves the branch's transformer as it is. On an axis or spindle branch, the mark has to be cleared before that card's Error term option can be switched on. A mark on an axis or the spindle also leaves the chain unsolvable, as the session reports, and stops every run at its start with a message naming the role and the branch; the project still loads. A mark the file spells as anything but true, false, 1 or 0 loads as no mark, with a warning naming the branch.
A CL-driven device is not edited here. A ClMillingDevice has no editable topology, so a mark its file carries cannot be taken off on this page, and a run on it stops at its start when the branch that drives it is marked.

A machine with no model

A machine that is neither in the resource library nor available as a CAD assembly can still be simulated, with a chain that carries no shapes. What a program cuts depends on the axes, their directions and the work offsets, not on what the machine looks like, so a shapeless chain gives up only the drawing of the machine and collisions against its body. The holder, the cutter shank and the flute are still checked against the fixture, and the holder and the shank against the stock (the flute against the stock is the cut, and is checked only before the program gives the spindle a speed), because those collision pairs come from the chain's names rather than from its shapes. Before 3.2.42 the pairs against the stock were generated but not evaluated — the running workpiece was never handed to the collision check, so a holder or shank that entered the stock raised no message, and the Showcase cases checked that clearance from the geometry instead; from 3.2.42 the engine evaluates them and reports Collided(Workpiece,ToolHolder) and Collided(Workpiece,CutterShank).

The catalogue supplies the rest: the travel of each axis, which axes the table carries and which the head carries, and the spindle-nose-to-table distance. The figures below are for a machine with 800 × 500 × 500 mm of travel whose spindle nose reaches from 600 mm down to 100 mm above the table.

Lay out the axes. A vertical machining centre whose table carries X and Y and whose head carries Z is [O][Y][X][w];[O][Z][S][t] in Machine Chain Code, with the table-side axes pointing negative — (-1, 0, 0) and (0, -1, 0) — and Z positive, (0, 0, 1). An axis that the column or the head carries goes on the t side instead, pointing positive. The resource library's MachineTool folder ships a shapeless three-axis chain with the same axes on the same sides and pointing the same ways, Empty-wXYOZSt.default.mt — [O][base][X][Y][w];[base][Z][S][t], X stacked under Y, which makes no difference for linear axes — with its tool end 1000 mm above its worktable end. Load it on the Machine Tool item as above: it is usable as it stands when the work offsets are typed in from the machine, and a structure to reshape in the Topology column for another layout or for the other direction in step 3, leaving every anchor without a shape.
Treat the tool-end anchor as the spindle gauge line. t is where the tool holder seats, and a tool's length offset (H) runs from there to the tip, so the chain carries no tool length of its own — the tool assembly adds it.
Place the two ends for the direction the work offsets come from. The two directions are Program Zero Alignment.
- Work offsets typed in from the machine. The part is placed so that program zero meets them, and that placement absorbs both end offsets, so on a machine with no shapes they change nothing about the cut. Any plausible placement does, such as the one below. To check the placement, press P0 on a work-offset row the program does not use and compare it with the typed row; M0 returns the spare row to machine zero afterwards.
- Work offsets written from the model with P0. Now the two ends decide where machine zero lies relative to the part, and so every offset P0 writes. A run starts at the home position — machine zero unless Home / G28 Reference says otherwise — and a tool change sends Z to its tool-change position, 0 unless Tool-Change Position says otherwise, so t has to stand above w by more than the fixture, the stock and the longest tool stacked together. With the two ends at one point the tool hangs through the part at home, and the first rapid after the tool change drags it through the stock: a rapid-cut warning is raised, but the material is gone for the rest of the run. For the machine above, a static translation of (-400, -250, -600) on the branch arriving at w, against none on the branch arriving at t, puts the table centre under the middle of the X and Y travel and the table top 600 mm below the tool end at home — the largest nose-to-table distance the catalogue gives. The shipped Empty-wXYOZSt.default.mt is not such a chain: its branch arriving at t already carries (0, 0, 1000), so the same placement there is (-400, -250, 400) on the branch arriving at w. Left at -600, the table sits 1600 mm below the tool end, and every Z that P0 writes lies about 1000 mm beyond the Z travel of step 4.
Enter the travel the way the controller reads it. On the common layout where every axis reads 0 at home and negative across its travel, this machine is X −800 to 0, Y −500 to 0 and Z −500 to 0, entered as − Limit and + Limit on the controller's Machine Limits (Stroke) leaf. Rapid Feedrates, Home / G28 Reference and Tool-Change Position sit beside it — see Controller. Read the machine's own machine-coordinate display rather than assume the layout; a machine whose axes read positive across their travel takes those numbers instead.
Check the end anchors after a load. A machine tool file of your own is loaded the same way: put it in the project folder — with the File Explorer's Upload, for one on your own computer — and pick it with the Machine Tool item's Load from the project root. The load's own notice says nothing about the anchors: an end anchor the machine lacks or carries in the wrong letter case is written to the service's log — open the Log Viewer from the Help menu. A missing one also shows at once in the Roles panel, as a Table Mount or Tool Mount row left empty with Not bound; the mechanism needs this role. under the list, and is reported again among the messages of the next project load once the project is saved.
Check the axes the chain actually carries. The controller's per-axis rows list X, Y and Z on every brand before any chain is attached, so a missing linear axis does not show there. Read the Roles panel instead: each axis the machine has is an Axis row bound to a branch, and an empty row is an axis the machine does not have. A branch that should drive an axis but was left on a static transformer drives nothing: taken by its name, it is flagged under the rows, and it cannot be bound to a row by hand until its transformer is changed — in the Topology column, click the branch and pick Dynamic Translation or Dynamic Rotation.

Example: a small five-axis vertical milling machine

A worked example, complete with its STLs: B1.zip. The same machine ships as the Table-B1.default preset, so Load on the Machine Tool item opens it in a project as it stands.

The machine it describes:

The B1 example machine, drawn with each of its anchors marked and named

And the topology those anchors and branches form, as the Topology column draws the machine's cluster once the preset is loaded — each branch labelled with its transformer kind, after its name where it has one:

Laying a machine on its side

A horizontal machine is built exactly like a vertical one and then laid down:

Create the topology from the machine's own axis coordinates.
On the branch between the ground anchor and the machine base, set a rotation of 180 degrees about a normalized axis direction of (0, 1, 1).

A machine tool file can also carry this same connectivity as a short bracket notation for hand-editing the XML — the grammar is Machine Chain Code.

Table of Contents