Include an external gcode file. Note that the contents are processed, not included raw, so unsupported commands or phrasings may be lost.

gcode("plugin.gcode");          // Include "plugin.gcode"

Includes a gcode string. Note that the contents are processed, not included raw, so unsupported commands or phrasings may be lost.

gexec("G0 X100 Y200");          // Add gcode command "G0 X100 Y200"

Issue a linear motion at the rapid feed rate from the current position to the new position defined by the provided axes arguments.

rapid(0, 0, 0);          // Rapid to x=0, y=0, z=0
rapid(10, 10);           // Rapid to x=10, y=10, z remains 0
rapid({z: 10, y: 10});   // Rapid to y=10, z=10, x remains 10

The same as rapid() but incremental defaults to true.

The same as rapid() except moves are at the current feed rate set by a call to feed().

The same as cut() but incremental defaults to true.

x, y and z specify the offset from the current position to the far center of the helical move in the selected plane. If the z value is zero then the move is a simple arc in the selected plane, otherwise it is a true helical move with an axis of length equal to the absolute value of the z value either above or below the selected plane through the current control point depending on the sign.

angle is the rotation of the arc in radians. A positive value indicates a clockwise rotation, negative a counter-clockwise rotation.

plane specifies to which plane the helical axis is perpendicular. Valid values are XY (the default), XZ or YZ.

Make a linear move in the direction indicated until the probe state changes to the target state. If active is true the probe motion will stop on contact. Otherwise it will stop on loss of contact.

probe() will return the coordinates of the position at the time the probe changed state. If the programmed point was reached before the state changed then the programmed point will be returned instead.

probe(z = -10);  // Probe towards z=-10
probe(z = 10, active = false);  // Probe away from current z

It is an error if:

• The current point is the same as the programmed point.
• The current feed rate is zero.
• The probe is already in the target state.

seconds indicate the time in seconds that all axes will remain unmoving. Fractions of a second may be used.

dwell(0.5);  // Dwell for half a second.

rate indicates the units per minute in the XYZ Cartesian system of all subsequent non-rapid moves until the feed rate is changed.

mode may be one of the following:

• FEED_UNITS_PER_MIN - The feed rate is in units per minute. The unit may be inches, millimeters or degrees depending on the current unit of length and which axes are moving.
• FEED_INVERSE_TIME - Indicates that moves should be completed in one divided by rate minutes. For example, if rate is 2.0, moves should be completed in half a minute.
• FEED_UNITS_PER_REV - Means that the controlled point should move a certain number of units per revolution.

If no arguments are given, returns the current feed rate and mode.

feed(4);           // Move at 4 units per minute
rate = feed()[0];  // Get the current feed rate

rate indicates the revolutions per minute of the spindle.

If rate is positive the spindle will turn in the clockwise direction. If negative in the counterclockwise direction.

A rate of zero turns the spindle off.

If surface is specified it selects a constant surface speed of surface feet per minute if IMPERIAL units are selected or meters per minute if METRIC units are selected. If max is also specified it indicates the maximum spindle RPM.

If no arguments are given, returns the current spindle speed, surface speed and maximum RPM.

speed(1000);    // Spin clockwise at 1K RPM.
speed(-20000);  // Spin counterclockwise at 20K RPM.

Make tool number the current tool.

tool(1);  // Select tool 1

If no arguments are given, information about the currently selected tool is returned. E.g.:

{
   number: 1,
   shape: CONICAL,        // A tool type constant
   angle: Math.PI * 0.5,  // In radians, 90°
   length: 10,            // In current units
   diameter: 3.175,       // In current units
   snub_diameter: 1       // If shape == SNUBNOSE
}

For example, to get the current tool radius:

var tool_radius = tool().diameter / 2;

The tool type constants are as follows:

• CYLINDRICAL
• CONICAL
• BALLNOSE
• SPHEROID
• SNUBNOSE

type may be either METRIC which selects millimeters as the unit of measure or IMPERIAL which selects inches.

If no arguments are given the current type is returned.

units(METRIC);  // Select millimeters

Pause the program until the user resumes. If optional is true then only pause if the stop switch is activated.

pause(true);

Get current simulation's workpiece offset and dimensions.

workpiece() = {
  dims: {x: 100, y: 100, z: 10},
  offset: {x: -50, y: -50, z: -10}
}

Return an array of the current xyz position, i.e. [x, y, z].

Return the current x position.

Return the current y position.

Return the current z position.

Convert all arguments to strings and print them to the output stream.

Note that print() writes to the same output stream as the gcode functions so if you don't want to interfere with the gcode output you should wrap text in parentheses () so that it is treated as a gcode comment.

print() does not automatically add an end of line and does not interpret formatting strings.

print("Hello World!\n");

print("(A gcode comment)\n");

Return a dict of the current positions, i.e. {x y z a b c u v w}.

print(position().x, position().y, position().z);

Convert all arguments to strings and output a GCode comment.

comment("A gcode comment");

Convert all arguments to strings and output a GCode message.

In some contexts GCode messages are displayed to the user.

message("Hello World");

Print to log info stream.

Print to log debug stream.

Print to log warning stream.

Print to log error stream.

Load the specified module. Modules are searched for in the directories specified in the TPL_PATH environment variable. A TPL module may be either a file ending in .tpl, .js or .json or a directory containing a package.json file.

.tpl or .js files are loaded as code whereas .json files are loaded as data. Code modules must assign values to the module.exports (alternatively exports) dictionary in order for them to be accessible. For example:

// A TPL module
module.exports = {
  data: [1, 2, 3],
 
  hello: function () {print("Hello World!\n");}
}

If the above code were in a file called hello.tpl, you might use the following to access it:

var m = require('hello.tpl');
 
m.hello();
 
for (var i = 0; i < m.data.length; i++)
  print(m.data[i], '\n');

package.json files are treated specially. The contents are interpreted as a dictionary of JSON data and the attribute main is read to get the relative path of the entry point for the module. The specified file is then loaded as a code or data module as above.

When a module is being loaded the following variables are defined:

If any modules have cyclic require() calls, module values may not be accessible at module load time. For example:

var b = require('b.tpl');
print(b.data, '\n');
module.exports = {data: 'A'}

var a = require('a.tpl');
print(a.data, '\n');
module.exports = {data: 'B'}

var a = require('a.tpl');
var b = require('b.tpl');
print(a.data, '\n');
print(b.data, '\n');

Running main.tpl will produce the following output:

undefined
B
A
B

The first reference to a.data is undefined because module A is not yet fully loaded when accessed in module B. However, all data has been loaded by the time main.tpl accesses it.

Use the Clipper library to compute polygon offsets.

The polys argument is an array of one or more polygons and is formatted either as an array of arrays of dictionaries:

[
  [{x: 0, y: 0}, {x: 1, y: 0}, . . ., {x: 0, y: 0}],
  . . .
]

or an array of arrays of 2D arrays:

[
  [[0, 0], [1, 0], . . ., [0, 0]],
  . . .
]

Note, the results of dxf.open() are not directly usable by offset() but other functions in the dxf module can convert raw DXF data to polygons.

Read a DXF file and return JSON data as a dictionary of layers. Each layer is a list of any of the following entities:

Points

{
  type: dxf.POINT,
  x: 0,
  y: 0,
  z: 0
}

Lines

{
  type: dxf.LINE,
  start: {x: 0, y: 0, z: 0},
  end: {x: 1, y: 1, z: 1}
}

Arcs

{
  type: dxf.ARC,
  center: {x: 0, y: 0, z: 0},
  radius: 1,
  startAngle: 0,
  endAngle: 2 * Math.PI,
  clockwise: true
}

Polylines

{
  type: dxf.POLYLINE,
  vertices: [
    {type: dxf.POINT, x: 0, y: 0, z: 0},
    . . .
  ]
}

Splines

{
  type: dxf.SPLINE,
  degree: 3,
  ctrlPts: [
    {type: dxf.POINT, x: 0, y: 0, z: 0},
    . . .
  ],
  knots: [0, . . .]
}

Example

var dxf = require('dxf');
var layers = dxf.open('test.dxf');