DATRON next Control Guide

DATRON builds high-speed (HSC) milling machines — compact machines with very high-RPM spindles that take light, fast cuts with small tools, at their best in aluminum, graphite, plastics, and composites rather than heavy steel hogging. The machines you will hear named — Neo, M8Cube, MLCube — all run the same in-house control this guide is about: DATRON next. And DATRON next is genuinely unlike the control on your Haas or your Fanuc-equipped VMC. There is no G-code screen at the front of it. It is a touch-first control — a full touchscreen driven by tap, swipe, pinch, and even drawing on the screen with a finger — organized around a guided workflow: load a program, check tools, set up the work piece, simulate, mill. Underneath, every job is a program in DATRON's own SimPL language. This guide maps the whole picture from the control's own manual so a shop evaluating or receiving a Datron knows what it's actually getting.

What DATRON next Is

DATRON next is the control software on current DATRON milling machines — the manual describes it generically for “DATRON milling machines” rather than per model, and pitches the machines as offering “a high degree of precision, a comprehensive range of functions and simultaneously simple operating characteristics and low space requirements.” The user interface is a Windows-based touch application: a main menu of large tiles, a navigation bar whose next button returns you to that main menu from anywhere, a color-coded status bar (white = system ready, blue = program loaded, green = machining, flashing green = user action required, yellow = setup/service mode, purple = manual axis traverse, red = fault/abort), and a physical-feeling ON button that changes identity as the job progresses — it is the power-up button, then the Load program button, then the Start program button, then the pause control while the program runs. Gesture control is first-class: tap, tap-and-slide, pinch to zoom, drag the camera image to jog XY, and draw a contour on the screen with a finger.

You read the machine's state off the status bar the way you'd read a stack light — worth memorizing before your first day at the machine:

Status bar colour	Machine status (per the manual)
White	System ready, ON button not yet pressed
Blue	Machine ready; a program is loaded or can be loaded from program administration
Green	Machine is processing
Green flashing	Program interruption — user action required
Yellow	Setup mode / service mode (opened by keyswitch)
Purple	Manual operation — axes traversed with the hand-held control unit
Red	Fault, abort

For a precision job shop, the pitch is throughput on small parts: an operator can go from clamped blank to verified, simulated, running program through a sequence of guided screens, without writing or reading a line of code — while a programmer still has a full language (SimPL) and a full on-control editor with a debugger when the job needs logic. This guide is grounded in the DATRON next Software Manual 3.4; features are version-specific (3.4 added the daily program execution planner, for example), so check your machine's software version screen against the manual you're reading.

The next Workflow

The manual opens with a “Create workflow for component” diagram that is the whole philosophy in one page: draw the component in CAD, calculate milling tracks and create the milling program in CAM, then — at the machine — load the milling program, run the tool check, set up the work piece, and mill the component while observing progress, cutting feed, spindle load, and axis motions. The on-machine half of that is packaged as the CAM wizard, a step-by-step guided setup the manual says “guides you through the setup procedure of the machine step by step” and “clears potential sources of error.” The main menu shows the wizard's progress with icons that turn from grey to completed as you finish each step:

CAM wizard step	What happens on the control
1. Select and load program	Pick a program from the machine's memory locations — the local Machine folder, Samples, network Plugins, or a USB stick — and load it.
2. Tool check	The control compares the loaded program's tool list against reality: which required tools are in the tool magazine, which are in the manual-change warehouse, which are missing. Reload what's missing and measure all tools from this same screen.
3. Setting up work piece	Establish the origin — probe it with the XYZ sensor's measuring cycles or set it up over the camera image (see the setup section below).
4. Simulation	Graphic simulation of the loaded program in the 3D view: scrub a progress bar, switch perspective, show/hide the tool and its positioning moves, and jump between operation groups and individual data blocks.
5. Mill component	Press Start program; the status bar goes green and the ON button becomes the run/pause control. Pausing offers Release door / Continue / Abort.

Around that spine sit the other main-menu tiles: Program administration (folders, file operations, quick links pinning frequent programs to the toolbar), Tool management, Setting up work piece, 3D, Status, Editor, Manual operation, Settings, and User. On top of any loaded program sit the execution options — production behaviors set once and applied to how the program runs:

Execution option	What it does
Automatic pauses	Pause at every block start, after every tool change (to check the inserted tool), or wherever the program contains the SimPL `OptionalBreak` command — each pause opens a dialogue that must be confirmed to continue.
Restart after abort	Resume an interrupted job from a chosen point: the last positioning-feed move, the last change between components (multiple execution), the last tool change, or the call of a specific (even nested) sub-program.
After execution	Switch off the table vacuum and/or shut down the machine computer automatically when the program finishes — the end-of-shift lights-out combo.
Multiple execution (optional)	Mill many components from one start: in the matrix (a grid of parts cut from one blank — offsets and counts in X/Y, with the required blank size calculated for you) or with origins (one part per saved work-piece zero point across multiple clampings). Tool-change optimization mills every part with the inserted tool before changing.
Fits (optional)	Overrides for milling fits: corrective and control measurement intervals, manual-vs-automatic chip cleaning between measurements, or using the tool radius straight from the tool manager.

A program execution planner (new in 3.4) can additionally schedule a program of any type to run at a specific time every day, with a reminder dialogue two minutes before it fires — the machine just has to be ready at that time.

Ways to Program a Datron

The load-bearing fact: everything the control runs is SimPL. A program on a Datron is a .simpl file — a module in DATRON's own strongly-typed, English-based programming language — whether a human wrote it, a guided screen generated it, or a CAM post emitted it. Very long CAM output ships as SimPL sequences, a streaming form that can be gigabytes long and executes directly without pre-loading. Standard ISO G-code commands are also implemented in the control by default, and a customizable G-code wrapper (a SimPL program you edit yourself) lets you map non-ISO or house G-codes onto SimPL commands. Three practical routes into a running part:

Route	What it is	Best for
On-control guided workflows	What the next manual covers: the CAM wizard for CAM jobs, plus Manual operation — graphical process cycles run straight from the touchscreen: drilling, bore milling, thread milling, rectangle/circle contours, rectangular/circular pockets, face milling, text engraving, positioning moves, and technology settings (speed, feed, dynamics, contour smoothing, spray system).	Operators; setup; simple features and one-off cuts without writing any code
SimPL programs	Write modules in the on-control Editor — a real IDE with graphical input masks for every command, direct help, error status, and a debugger (breakpoints, single step, procedure step). Named, spelled-out parameters instead of cryptic words: DATRON SimPL Programming is the deep dive.	Parametric families, probing logic, fixtures, automation glue — anything with variables and flow control
CAM + post	Program in your CAM system; the post outputs SimPL (long jobs as sequences). At the machine it's a load-check-setup-simulate-run job through the CAM wizard.	3D surfacing, production parts, anything you'd CAM anyway

A taste of the language, using the manual's own program-parameter example — note named parameters and readable keywords where a Fanuc macro would have #101 and G65:

module Example
@ MeasuringSystem = "Metric" @
using Base                # the Base library: all milling commands

program kreis radius:number tiefe:number optional zustellung:number
# statements
endprogram

program Main
kreis radius=10.5 tiefe=33.3    # named call parameters, any order
endprogram
end

Setup, Probing & Tool Handling

Work piece setup. The Setting up work piece menu establishes the origin (the work-piece coordinate system) mechanically or optically. The mechanical route is the XYZ sensor — a fold-out probe; while it's folded out, the coordinate system references the probe tip rather than the tool center point — driving guided measuring cycles. Each cycle is a touch form on the setup screen, and each also exists as a SimPL command for use inside programs — the same probing engine both ways:

Measuring cycle	Establishes	SimPL command
Corner	Origin and alignment from a work-piece corner	`CornerMeasure`
Centre point rectangle	Center of a rectangular feature or blank	`RectangleMeasure`
Centre point circle	Center of a circular feature (boss or bore)	`CircleMeasure`
Z-height	Top-of-part Z reference	`SurfaceMeasure`
Edge	A single edge — also the prescribed cycle for rotary-axis origins (the manual warns against using the camera there)	`EdgeMeasure`
Symmetry	Centerline between two opposing faces	`SymmetryAxisMeasure`
U-shape	Three edges in a U — combines edge and symmetry in one cycle (added in 3.1)	— (drawn/guided cycle)
Plane (optional)	Orientation of a tilted surface	`PlaneOrientationMeasure`

The optical route is the (optional) camera: the Z-axis traverses up, you literally draw the measurement on the live camera image with a finger, the software recognizes the geometry and suggests measuring points, then the probe measures. Finished setups are saved by name — with a photo of the clamping — in the work piece administration, and transformation coordinates (displacement, rotation, reflection, scaling) can be layered on any origin. Two more setup-level tools matter for real work: the surface profile (optional) probes a Z-measuring grid so machining follows an uneven surface (think engraving depth on a not-quite-flat plate), and protected areas (optional) let you measure or define cubes, cylinders, and planes around clamps and fixtures that the machine then avoids. Workholding status is right on the same screens: vacuum table on/off with live pressure reading (with optional vacuum monitoring that pauses the program if it drops), suction head raise/lower, and compressed-air gauges.

Tool handling. Tool management tracks tools across five storage locations: the spindle (the active tool), the tool magazine (the automatic changer, shown as a graphical magazine — direct shank clamping or HSK seats depending on the machine), the warehouse (manual-change tools living outside the machine, including third-party tools), your user tool catalogue, and the DATRON tool catalogue — DATRON's full cutter library with technical data, importable into your own locations in a couple of taps. Tool length is measured automatically on the machine's tool length sensor (or flagged as externally measured with manually entered length); a detected breakage automatically locks the tool so it can never be changed into the spindle, and locked tools drop out of tool checks. The optional sister tool function assigns service lives, shows wear as green/orange/red (two rings on the graphical magazine: service life outside, tool life inside), and automatically swaps in the oldest matching sister when a tool wears out mid-run — the piece that makes lights-out multiple execution honest. Tool data exports/imports as an Excel worksheet to move a tool crib between machines.

Coming from Fanuc/Haas: What's Different

The same honest framing we use elsewhere in this wiki: none of this is better or worse in the abstract — it is a different set of defaults, optimized for high-speed machining of small parts with fast setup turnover. What actually changes day to day:

On your Fanuc/Haas	On DATRON next
G-code program screen front and center; you read and edit blocks	No G-code screen at the front. Programs are SimPL modules; ISO G-code is accepted (plus a user-editable G-code wrapper for house codes), but the working surface is the guided workflow and the SimPL editor
MDI line for quick moves and one-shot cuts	Manual operation menu: graphical process cycles (drill, pocket, contour, face, engrave, thread mill) and positioning commands filled in on touch forms — a form instead of a block
Macro B: `#`-variables, `G65`, `IF/GOTO`	SimPL: named variables, real data types (structures, lists, enumerations), `if/while/foreach`, subprograms with named parameters, an on-control debugger
Probing = optional macro package driven by `G31/G65` calls	Probing is native UI: XYZ-sensor measuring cycles and camera draw-to-measure are part of setup, and every cycle also exists as a SimPL command (`CornerMeasure`, `EdgeMeasure`, …) for use in programs
Offset registers: lengths and work offsets keyed in by number (`G54`, `H01`)	Tool management + work piece administration: tools carry their own measured data and catalogue identity; origins are saved objects with names and photos, not numbered registers
Prove-out habits built around heavy iron: single block, feed hold, low rapid	Simulation-first: the CAM wizard puts graphic simulation between setup and cycle start, and the editor simulates before it executes; a program with errors won't run at all
Big spindle taper, low-thousands RPM, heavy depth of cut	HSC spindle: very high RPM, small-diameter tools, shallow fast passes and high feeds — your feeds/speeds intuition needs recalibrating (see High-Speed Machining); spray-mist cooling and vacuum workholding replace flood and vise-everything

The mental shift that matters most: on a Fanuc you trust the operator to babysit the code; on DATRON next the control front-loads verification — tool check, guided setup, mandatory-feeling simulation — so the run itself is boring. Shops that lean into that (and into the SimPL layer when jobs repeat) get the machine's speed; shops that fight it and hunt for the MDI screen have a slower first month.

Automation Hooks

DATRON next is built to sit in a cell. The optional DATRON Live web interface serves machine status, tool data, the camera feed, and remote-link SimPL macros to any browser on the network — and behind it the control exposes a REST API in two tiers: API base (read authorization for current machine states, e.g. process-data recording) and API automation (additionally start and pause programs and change persistent values), documented in a separate DATRON manual. On the wiring side, dedicated automation inputs/outputs are addressable from SimPL (GetAutomationInput, SetAutomationOutput, WaitForAutomationInput, with named I/O), so a robot handshake is a few readable lines. Full coverage in DATRON Automation & REST API.

References

DATRON AG, DATRON next — Software Manual 3.4 (English), Mühltal, © 2024 — the control's own operating manual; describes the software from version 3.4.
DATRON AG, DATRON next SimPL — Programming Manual 2.18.1 (English), Mühltal, © 2022 — consulted for the language structure and command overview in the programming section.