1003 lines
30 KiB
Plaintext
1003 lines
30 KiB
Plaintext
/**
|
|
Copyright (C) 2012-2025 by Autodesk, Inc.
|
|
All rights reserved.
|
|
|
|
ISEL post processor configuration.
|
|
|
|
$Revision: 45583 10f6400eaf1c75a27c852ee82b57479e7a9134c0 $
|
|
$Date: 2025-08-21 13:23:15 $
|
|
|
|
FORKID {FF26919F-F5E0-4fcc-9408-035EEE34FAB4}
|
|
*/
|
|
|
|
description = "ISEL Intermediate";
|
|
vendor = "ISEL";
|
|
vendorUrl = "https://www.isel.com";
|
|
legal = "Copyright (C) 2012-2025 by Autodesk, Inc.";
|
|
certificationLevel = 2;
|
|
minimumRevision = 45702;
|
|
|
|
longDescription = "Generic milling post for ISEL intermediate format.";
|
|
|
|
extension = "ncp";
|
|
setCodePage("ascii");
|
|
|
|
capabilities = CAPABILITY_MILLING;
|
|
tolerance = spatial(0.002, MM);
|
|
|
|
minimumChordLength = spatial(0.25, MM);
|
|
minimumCircularRadius = spatial(0.01, MM);
|
|
maximumCircularRadius = spatial(1000, MM);
|
|
minimumCircularSweep = toRad(0.01);
|
|
maximumCircularSweep = toRad(360);
|
|
allowHelicalMoves = true;
|
|
allowedCircularPlanes = undefined; // allow any circular motion
|
|
highFeedrate = (unit == IN) ? 300 : 3000;
|
|
|
|
// user-defined properties
|
|
properties = {
|
|
writeMachine: {
|
|
title : "Write machine",
|
|
description: "Output the machine settings in the header of the code.",
|
|
group : "formats",
|
|
type : "boolean",
|
|
value : true,
|
|
scope : "post"
|
|
},
|
|
writeTools: {
|
|
title : "Write tool list",
|
|
description: "Output a tool list in the header of the code.",
|
|
group : "formats",
|
|
type : "boolean",
|
|
value : true,
|
|
scope : "post"
|
|
},
|
|
showSequenceNumbers: {
|
|
title : "Use sequence numbers",
|
|
description: "'Yes' outputs sequence numbers on each block, 'Only on tool change' outputs sequence numbers on tool change blocks only, and 'No' disables the output of sequence numbers.",
|
|
group : "formats",
|
|
type : "enum",
|
|
values : [
|
|
{title:"Yes", id:"true"},
|
|
{title:"No", id:"false"},
|
|
{title:"Only on tool change", id:"toolChange"}
|
|
],
|
|
value: "true",
|
|
scope: "post"
|
|
},
|
|
sequenceNumberStart: {
|
|
title : "Start sequence number",
|
|
description: "The number at which to start the sequence numbers.",
|
|
group : "formats",
|
|
type : "integer",
|
|
value : 10,
|
|
scope : "post"
|
|
},
|
|
sequenceNumberIncrement: {
|
|
title : "Sequence number increment",
|
|
description: "The amount by which the sequence number is incremented by in each block.",
|
|
group : "formats",
|
|
type : "integer",
|
|
value : 5,
|
|
scope : "post"
|
|
},
|
|
expandCycles: {
|
|
title : "Expand drilling cycles",
|
|
description: "If enabled, all drilling cycles are expanded.",
|
|
group : "preferences",
|
|
type : "boolean",
|
|
value : true,
|
|
scope : "post"
|
|
},
|
|
fastvel: {
|
|
title : "Rapid feedrate",
|
|
description: "User defined rapid feedrate.",
|
|
group : "preferences",
|
|
type : "number",
|
|
value : 0,
|
|
scope : "post"
|
|
},
|
|
useHelicalArcs: {
|
|
title : "Use helical arcs",
|
|
description: "Specifies if helical arcs are supported.",
|
|
group : "preferences",
|
|
type : "boolean",
|
|
value : false,
|
|
scope : "post"
|
|
},
|
|
extendedCoolants: {
|
|
title : "Use extended coolant codes",
|
|
description: "If enabled, Air (COOLANT), Flood (COOLANT2), and Mist (COOLANT2) coolants are supported.",
|
|
group : "preferences",
|
|
type : "boolean",
|
|
value : false,
|
|
scope : "post"
|
|
},
|
|
safePositionMethod: {
|
|
title : "Safe Retracts",
|
|
description: "Select your desired retract option. 'Clearance Height' retracts to the operation clearance height.",
|
|
group : "homePositions",
|
|
type : "enum",
|
|
values : [
|
|
{title:"Clearance Height", id:"clearanceHeight"},
|
|
{title:"WPCLEAR", id:"wpclear"}
|
|
],
|
|
value: "wpclear",
|
|
scope: "post"
|
|
}
|
|
};
|
|
|
|
// wcs definiton
|
|
wcsDefinitions = {
|
|
useZeroOffset: false,
|
|
wcs : [
|
|
{name:"Standard", format:"WPREG#ACT", range:[1, 8]}
|
|
]
|
|
};
|
|
|
|
/** Returns the feed in micrometers/s. */
|
|
function toVel(feed) {
|
|
return feed / 60 * 1000;
|
|
}
|
|
|
|
/** Returns the spatial coordinate in micrometers. */
|
|
function toUM(spatial) {
|
|
return spatial * 1000;
|
|
}
|
|
|
|
/** Returns the angular coordinate in angular seconds. */
|
|
function toAS(angular) {
|
|
return angular * 60 * 60;
|
|
}
|
|
|
|
var xyzFormat = createFormat({decimals:0, forceDecimal:false});
|
|
var abcFormat = createFormat({decimals:0, forceSign:false, forceDecimal:false, scale:DEG});
|
|
var sweepFormat = createFormat({decimals:0, scale:DEG});
|
|
var feedFormat = createFormat({decimals:0, forceDecimal:false});
|
|
var toolFormat = createFormat({decimals:0});
|
|
var rpmFormat = createFormat({decimals:0});
|
|
var milliFormat = createFormat({decimals:0}); // milliseconds // range 1-9999
|
|
var taperFormat = createFormat({decimals:1, scale:DEG});
|
|
|
|
var xOutput = createVariable({prefix:"X"}, xyzFormat);
|
|
var yOutput = createVariable({prefix:"Y"}, xyzFormat);
|
|
var zOutput = createVariable({onchange:function () {retracted = false;}, prefix:"Z"}, xyzFormat);
|
|
var aOutput = createVariable({prefix:"A"}, abcFormat);
|
|
var bOutput = createVariable({prefix:"B"}, abcFormat);
|
|
var cOutput = createVariable({prefix:"C"}, abcFormat);
|
|
var feedOutput = createVariable({}, feedFormat);
|
|
|
|
// circular output
|
|
var iOutput = createVariable({prefix:"I", force:true}, xyzFormat);
|
|
var jOutput = createVariable({prefix:"J", force:true}, xyzFormat);
|
|
var kOutput = createVariable({prefix:"K", force:true}, xyzFormat);
|
|
|
|
// collected state
|
|
var sequenceNumber;
|
|
var forceSpindleSpeed = false;
|
|
var currentPlane;
|
|
var lastSpindleSpeed = 0;
|
|
var retracted = false; // specifies that the tool has been retracted to the safe plane
|
|
|
|
/**
|
|
Writes the specified plane.
|
|
*/
|
|
function writePlane(plane) {
|
|
if (plane != currentPlane) {
|
|
currentPlane = plane;
|
|
writeBlock("PLANE " + plane);
|
|
}
|
|
}
|
|
|
|
/**
|
|
Writes the specified block.
|
|
*/
|
|
function writeBlock() {
|
|
if (getProperty("showSequenceNumbers") == "true") {
|
|
// up to 6 digits
|
|
writeWords2("N" + sequenceNumber, arguments);
|
|
sequenceNumber += getProperty("sequenceNumberIncrement");
|
|
} else {
|
|
writeWords(arguments);
|
|
}
|
|
}
|
|
|
|
/**
|
|
Writes the specified block - used for tool changes only.
|
|
*/
|
|
function writeToolBlock() {
|
|
var show = getProperty("showSequenceNumbers");
|
|
setProperty("showSequenceNumbers", (show == "true" || show == "toolChange") ? "true" : "false");
|
|
writeBlock(arguments);
|
|
setProperty("showSequenceNumbers", show);
|
|
}
|
|
|
|
/**
|
|
Output a comment.
|
|
*/
|
|
function writeComment(text) {
|
|
writeBlock("; " + text);
|
|
}
|
|
|
|
function formatCycleTime(cycleTime) {
|
|
cycleTime += 0.5; // round up
|
|
var seconds = cycleTime % 60 | 0;
|
|
var minutes = ((cycleTime - seconds) / 60 | 0) % 60;
|
|
var hours = (cycleTime - minutes * 60 - seconds) / (60 * 60) | 0;
|
|
if (hours > 0) {
|
|
return subst(localize("%1h:%2m:%3s"), hours, minutes, seconds);
|
|
} else if (minutes > 0) {
|
|
return subst(localize("%1m:%2s"), minutes, seconds);
|
|
} else {
|
|
return subst(localize("%1s"), seconds);
|
|
}
|
|
}
|
|
|
|
function onOpen() {
|
|
machineConfiguration.setRetractPlane(0);
|
|
machineConfiguration.setHomePositionX(0);
|
|
machineConfiguration.setHomePositionY(0);
|
|
|
|
if (!machineConfiguration.isMachineCoordinate(0)) {
|
|
aOutput.disable();
|
|
}
|
|
if (!machineConfiguration.isMachineCoordinate(1)) {
|
|
bOutput.disable();
|
|
}
|
|
if (!machineConfiguration.isMachineCoordinate(2)) {
|
|
cOutput.disable();
|
|
}
|
|
|
|
sequenceNumber = getProperty("sequenceNumberStart");
|
|
writeBlock("IMF_PBL", programName);
|
|
|
|
if (!programName) {
|
|
error(localize("Program name has not been specified."));
|
|
}
|
|
if (programComment) {
|
|
writeComment(programComment);
|
|
}
|
|
|
|
var cycleTime = 0;
|
|
var currentTool;
|
|
var toolChangeTime = 15; // specifies the time needed for a tool change
|
|
for (var i = 0; i < getNumberOfSections(); ++i) {
|
|
var section = getSection(i);
|
|
cycleTime += section.getCycleTime();
|
|
var tool = section.getTool();
|
|
if (currentTool != tool.number) {
|
|
currentTool = tool.number;
|
|
// cycleTime += toolChangeTime;
|
|
}
|
|
if (getProperty("fastvel") > 0) {
|
|
// cycleTime += section.getRapidDistance()/getProperty("fastvel") * 60;
|
|
}
|
|
}
|
|
writeComment(localize("Estimated Cycle Time") + ": " + formatCycleTime(cycleTime));
|
|
|
|
if (getProperty("fastvel")) {
|
|
writeBlock("FASTVEL " + feedFormat.format(toVel(getProperty("fastvel"))));
|
|
}
|
|
// dump machine configuration
|
|
var vendor = machineConfiguration.getVendor();
|
|
var model = machineConfiguration.getModel();
|
|
var description = machineConfiguration.getDescription();
|
|
|
|
if (getProperty("writeMachine") && (vendor || model || description)) {
|
|
writeComment(localize("Machine"));
|
|
if (vendor) {
|
|
writeComment(" " + localize("vendor") + ": " + vendor);
|
|
}
|
|
if (model) {
|
|
writeComment(" " + localize("model") + ": " + model);
|
|
}
|
|
if (description) {
|
|
writeComment(" " + localize("description") + ": " + description);
|
|
}
|
|
}
|
|
|
|
// dump tool information
|
|
if (getProperty("writeTools")) {
|
|
var zRanges = {};
|
|
if (is3D()) {
|
|
var numberOfSections = getNumberOfSections();
|
|
for (var i = 0; i < numberOfSections; ++i) {
|
|
var section = getSection(i);
|
|
var zRange = section.getGlobalZRange();
|
|
var tool = section.getTool();
|
|
if (zRanges[tool.number]) {
|
|
zRanges[tool.number].expandToRange(zRange);
|
|
} else {
|
|
zRanges[tool.number] = zRange;
|
|
}
|
|
}
|
|
}
|
|
|
|
var tools = getToolTable();
|
|
if (tools.getNumberOfTools() > 0) {
|
|
for (var i = 0; i < tools.getNumberOfTools(); ++i) {
|
|
var tool = tools.getTool(i);
|
|
var comment = "T" + toolFormat.format(tool.number) + " " +
|
|
"D=" + xyzFormat.format(tool.diameter) + " " +
|
|
localize("CR") + "=" + xyzFormat.format(tool.cornerRadius);
|
|
if ((tool.taperAngle > 0) && (tool.taperAngle < Math.PI)) {
|
|
comment += " " + localize("TAPER") + "=" + taperFormat.format(tool.taperAngle) + localize("deg");
|
|
}
|
|
if (zRanges[tool.number]) {
|
|
comment += " - " + localize("ZMIN") + "=" + xyzFormat.format(zRanges[tool.number].getMinimum());
|
|
}
|
|
comment += " - " + getToolTypeName(tool.type);
|
|
writeComment(comment);
|
|
}
|
|
}
|
|
}
|
|
|
|
switch (unit) {
|
|
case IN:
|
|
writeBlock("INCH");
|
|
break;
|
|
case MM:
|
|
writeBlock("METRIC");
|
|
break;
|
|
}
|
|
}
|
|
|
|
function onComment(message) {
|
|
writeComment(message);
|
|
}
|
|
|
|
/** Force output of X, Y, and Z. */
|
|
function forceXYZ() {
|
|
xOutput.reset();
|
|
yOutput.reset();
|
|
zOutput.reset();
|
|
}
|
|
|
|
/** Force output of A, B, and C. */
|
|
function forceABC() {
|
|
aOutput.reset();
|
|
bOutput.reset();
|
|
cOutput.reset();
|
|
}
|
|
|
|
/** Force output of X, Y, Z, A, B, C, and VEL on next output. */
|
|
function forceAny() {
|
|
forceXYZ();
|
|
forceABC();
|
|
feedOutput.reset();
|
|
}
|
|
|
|
function onParameter(name, value) {
|
|
}
|
|
|
|
var currentWorkPlaneABC = undefined;
|
|
|
|
function forceWorkPlane() {
|
|
currentWorkPlaneABC = undefined;
|
|
}
|
|
|
|
var currentCoolantMode = COOLANT_OFF;
|
|
var forceCoolant = false;
|
|
|
|
function setCoolant(coolant) {
|
|
if (coolant == currentCoolantMode && (!forceCoolant || coolant == COOLANT_OFF)) {
|
|
return; // coolant is already active
|
|
}
|
|
forceCoolant = false;
|
|
|
|
var m;
|
|
switch (coolant) {
|
|
case COOLANT_OFF:
|
|
if (getProperty("extendedCoolants") && (currentCoolantMode == COOLANT_FLOOD || currentCoolantMode == COOLANT_MIST)) {
|
|
m = "COOLANT2 OFF";
|
|
} else {
|
|
m = "COOLANT OFF";
|
|
}
|
|
break;
|
|
case COOLANT_FLOOD:
|
|
if (getProperty("extendedCoolants")) {
|
|
setCoolant(COOLANT_OFF);
|
|
m = "COOLANT2 ON";
|
|
} else {
|
|
m = "COOLANT ON";
|
|
}
|
|
break;
|
|
case COOLANT_MIST:
|
|
if (getProperty("extendedCoolants")) {
|
|
setCoolant(COOLANT_OFF);
|
|
m = "COOLANT2 ON";
|
|
} else {
|
|
onUnsupportedCoolant(coolant);
|
|
m = "COOLANT_OFF";
|
|
break;
|
|
}
|
|
break;
|
|
case COOLANT_AIR:
|
|
if (getProperty("extendedCoolants")) {
|
|
setCoolant(COOLANT_OFF);
|
|
m = "COOLANT ON";
|
|
} else {
|
|
onUnsupportedCoolant(coolant);
|
|
m = "COOLANT_OFF";
|
|
break;
|
|
}
|
|
break;
|
|
default:
|
|
onUnsupportedCoolant(coolant);
|
|
m = "COOLANT OFF";
|
|
}
|
|
|
|
if (m) {
|
|
writeBlock(m);
|
|
currentCoolantMode = coolant;
|
|
}
|
|
}
|
|
|
|
function setWorkPlane(abc) {
|
|
if (!machineConfiguration.isMultiAxisConfiguration()) {
|
|
return; // ignore
|
|
}
|
|
|
|
if (!((currentWorkPlaneABC == undefined) ||
|
|
abcFormat.areDifferent(abc.x, currentWorkPlaneABC.x) ||
|
|
abcFormat.areDifferent(abc.y, currentWorkPlaneABC.y) ||
|
|
abcFormat.areDifferent(abc.z, currentWorkPlaneABC.z))) {
|
|
return; // no change
|
|
}
|
|
|
|
onCommand(COMMAND_UNLOCK_MULTI_AXIS);
|
|
|
|
// NOTE: add retract here
|
|
|
|
writeBlock(
|
|
"FASTABS",
|
|
conditional(machineConfiguration.isMachineCoordinate(0), "A" + abcFormat.format(abc.x)),
|
|
conditional(machineConfiguration.isMachineCoordinate(1), "B" + abcFormat.format(abc.y)),
|
|
conditional(machineConfiguration.isMachineCoordinate(2), "C" + abcFormat.format(abc.z))
|
|
);
|
|
|
|
onCommand(COMMAND_LOCK_MULTI_AXIS);
|
|
|
|
currentWorkPlaneABC = abc;
|
|
}
|
|
|
|
var closestABC = false; // choose closest machine angles
|
|
var currentMachineABC;
|
|
|
|
function getWorkPlaneMachineABC(workPlane) {
|
|
var W = workPlane; // map to global frame
|
|
|
|
var abc = machineConfiguration.getABC(W);
|
|
if (closestABC) {
|
|
if (currentMachineABC) {
|
|
abc = machineConfiguration.remapToABC(abc, currentMachineABC);
|
|
} else {
|
|
abc = machineConfiguration.getPreferredABC(abc);
|
|
}
|
|
} else {
|
|
abc = machineConfiguration.getPreferredABC(abc);
|
|
}
|
|
|
|
try {
|
|
abc = machineConfiguration.remapABC(abc);
|
|
currentMachineABC = abc;
|
|
} catch (e) {
|
|
error(
|
|
localize("Machine angles not supported") + ":"
|
|
+ conditional(machineConfiguration.isMachineCoordinate(0), " A" + abcFormat.format(abc.x))
|
|
+ conditional(machineConfiguration.isMachineCoordinate(1), " B" + abcFormat.format(abc.y))
|
|
+ conditional(machineConfiguration.isMachineCoordinate(2), " C" + abcFormat.format(abc.z))
|
|
);
|
|
}
|
|
|
|
var direction = machineConfiguration.getDirection(abc);
|
|
if (!isSameDirection(direction, W.forward)) {
|
|
error(localize("Orientation not supported."));
|
|
}
|
|
|
|
if (!machineConfiguration.isABCSupported(abc)) {
|
|
error(
|
|
localize("Work plane is not supported") + ":"
|
|
+ conditional(machineConfiguration.isMachineCoordinate(0), " A" + abcFormat.format(abc.x))
|
|
+ conditional(machineConfiguration.isMachineCoordinate(1), " B" + abcFormat.format(abc.y))
|
|
+ conditional(machineConfiguration.isMachineCoordinate(2), " C" + abcFormat.format(abc.z))
|
|
);
|
|
}
|
|
|
|
var tcp = false;
|
|
if (tcp) {
|
|
setRotation(W); // TCP mode
|
|
} else {
|
|
var O = machineConfiguration.getOrientation(abc);
|
|
var R = machineConfiguration.getRemainingOrientation(abc, W);
|
|
setRotation(R);
|
|
}
|
|
|
|
return abc;
|
|
}
|
|
|
|
function writeWCS() {
|
|
// wcs
|
|
if (currentSection.workOffset > 0) {
|
|
writeBlock(currentSection.wcs);
|
|
} else {
|
|
writeBlock("WPZERO STANDARD");
|
|
}
|
|
}
|
|
|
|
function onSection() {
|
|
var insertToolCall = isFirstSection() ||
|
|
currentSection.getForceToolChange && currentSection.getForceToolChange() ||
|
|
(tool.number != getPreviousSection().getTool().number);
|
|
|
|
retracted = false; // specifies that the tool has been retracted to the safe plane
|
|
var newWorkOffset = isFirstSection() ||
|
|
(getPreviousSection().workOffset != currentSection.workOffset); // work offset changes
|
|
var newWorkPlane = isFirstSection() ||
|
|
!isSameDirection(getPreviousSection().getGlobalFinalToolAxis(), currentSection.getGlobalInitialToolAxis());
|
|
if (newWorkOffset || newWorkPlane) {
|
|
// retract to safe plane
|
|
writeRetract(Z);
|
|
if (getProperty("safePositionMethod") == "clearanceHeight") {
|
|
writeWCS();
|
|
}
|
|
}
|
|
|
|
if (hasParameter("operation-comment")) {
|
|
var comment = getParameter("operation-comment");
|
|
if (comment) {
|
|
writeComment(comment);
|
|
}
|
|
}
|
|
|
|
if (insertToolCall) {
|
|
forceWorkPlane();
|
|
onCommand(COMMAND_COOLANT_OFF);
|
|
if (!isFirstSection()) {
|
|
writeBlock("SPINDLE", "OFF");
|
|
}
|
|
/*
|
|
if (!isFirstSection() && getProperty("optionalStop")) {
|
|
onCommand(COMMAND_OPTIONAL_STOP);
|
|
}
|
|
*/
|
|
|
|
if (tool.number > 99) {
|
|
warning(localize("Tool number exceeds maximum value."));
|
|
}
|
|
|
|
writeToolBlock("GETTOOL", toolFormat.format(tool.number));
|
|
if (tool.comment) {
|
|
writeComment(tool.comment);
|
|
}
|
|
}
|
|
|
|
var spindleChanged = tool.type != TOOL_PROBE &&
|
|
(insertToolCall || forceSpindleSpeed || isFirstSection() ||
|
|
(rpmFormat.areDifferent(spindleSpeed, lastSpindleSpeed)) ||
|
|
(tool.clockwise != getPreviousSection().getTool().clockwise));
|
|
if (spindleChanged) {
|
|
forceSpindleSpeed = false;
|
|
if (spindleSpeed < 1) {
|
|
error(localize("Spindle speed out of range."));
|
|
}
|
|
if (spindleSpeed > 99999) {
|
|
warning(localize("Spindle speed exceeds maximum value."));
|
|
}
|
|
// SCLW / SCCLW
|
|
writeBlock("SPINDLE", (tool.clockwise ? "CW" : "CCW"), "RPM" + rpmFormat.format(spindleSpeed));
|
|
lastSpindleSpeed = spindleSpeed;
|
|
}
|
|
|
|
forceXYZ();
|
|
|
|
{ // pure 3D
|
|
var remaining = currentSection.workPlane;
|
|
if (!isSameDirection(remaining.forward, new Vector(0, 0, 1))) {
|
|
error(localize("Tool orientation is not supported."));
|
|
return;
|
|
}
|
|
setRotation(remaining);
|
|
}
|
|
|
|
forceAny();
|
|
|
|
var initialPosition = getFramePosition(currentSection.getInitialPosition());
|
|
if (!retracted && !insertToolCall) {
|
|
if (getCurrentPosition().z < initialPosition.z) {
|
|
writeBlock("FASTABS", zOutput.format(toUM(initialPosition.z)));
|
|
}
|
|
}
|
|
|
|
var x = xOutput.format(toUM(initialPosition.x));
|
|
var y = yOutput.format(toUM(initialPosition.y));
|
|
var z = zOutput.format(toUM(initialPosition.z));
|
|
if (!machineConfiguration.isHeadConfiguration()) {
|
|
if (x || y) {
|
|
writeBlock("FASTABS", x, y);
|
|
}
|
|
// handle length offset
|
|
if (z) {
|
|
writeBlock("FASTABS", z);
|
|
}
|
|
} else {
|
|
if (x || y || z) {
|
|
writeBlock("FASTABS", x, y, z);
|
|
}
|
|
}
|
|
setCoolant(tool.coolant);
|
|
}
|
|
|
|
function onSpindleSpeed(spindleSpeed) {
|
|
writeBlock("SPINDLE", (tool.clockwise ? "CW" : "CCW"), "RPM" + rpmFormat.format(spindleSpeed));
|
|
lastSpindleSpeed = spindleSpeed;
|
|
}
|
|
|
|
function onDwell(seconds) {
|
|
if (seconds > 99999.999) {
|
|
warning(localize("Dwelling time is out of range."));
|
|
}
|
|
milliseconds = clamp(1, seconds * 1000, 99999999);
|
|
writeBlock("WAIT", milliFormat.format(milliseconds));
|
|
}
|
|
|
|
function onCycle() {
|
|
// go to the initial retract level
|
|
if (!getProperty("expandCycles")) {
|
|
writeBlock("FASTABS", zOutput.format(toUM(cycle.clearance)));
|
|
}
|
|
}
|
|
|
|
function onCyclePoint(x, y, z) {
|
|
if (!isSameDirection(getRotation().forward, new Vector(0, 0, 1))) {
|
|
expandCyclePoint(x, y, z);
|
|
return;
|
|
}
|
|
if (getProperty("expandCycles")) {
|
|
expandCyclePoint(x, y, z);
|
|
return;
|
|
}
|
|
|
|
if (isFirstCyclePoint()) {
|
|
|
|
var F = cycle.feedrate;
|
|
var P = !cycle.dwell ? 0 : clamp(1, cycle.dwell * 1000, 99999999); // in milliseconds
|
|
|
|
switch (cycleType) {
|
|
case "drilling":
|
|
case "counter-boring":
|
|
writeBlock(
|
|
"DRILLDEF", "C1",
|
|
"P" + xyzFormat.format(toUM(cycle.stock)), // um
|
|
"D" + xyzFormat.format(cycle.depth), // mm - positive is down
|
|
"T" + milliFormat.format(cycle.dwell * 1000), // ms
|
|
"V" + feedFormat.format(toVel(F)), // mm/s
|
|
"L" + xyzFormat.format(cycle.clearance) // mm
|
|
);
|
|
break;
|
|
case "chip-breaking":
|
|
if (cycle.accumulatedDepth < cycle.depth) {
|
|
expandCyclePoint(x, y, z);
|
|
} else {
|
|
writeBlock(
|
|
"DRILLDEF", "C2",
|
|
"P" + xyzFormat.format(toUM(cycle.stock)), // um
|
|
"D" + xyzFormat.format(cycle.depth), // mm - positive is down
|
|
"T" + milliFormat.format(cycle.dwell * 1000), // ms
|
|
"V" + feedFormat.format(toVel(F)), // mm/s
|
|
"L" + xyzFormat.format(cycle.clearance), // mm
|
|
"F" + xyzFormat.format(cycle.incrementalDepth), // mm
|
|
"O" + xyzFormat.format(cycle.incrementalDepth), // mm
|
|
"I" + xyzFormat.format(0) // mm
|
|
);
|
|
}
|
|
break;
|
|
case "deep-drilling":
|
|
writeBlock(
|
|
"DRILLDEF", "C2",
|
|
"P" + xyzFormat.format(toUM(cycle.stock)), // um
|
|
"D" + xyzFormat.format(cycle.depth), // mm - positive is down
|
|
"T" + milliFormat.format(cycle.dwell * 1000), // ms
|
|
"V" + feedFormat.format(toVel(F)), // mm/s
|
|
"L" + xyzFormat.format(cycle.clearance), // mm
|
|
"F" + xyzFormat.format(cycle.incrementalDepth), // mm
|
|
"O" + xyzFormat.format(cycle.incrementalDepth), // mm
|
|
"I" + xyzFormat.format(0) // mm
|
|
);
|
|
break;
|
|
case "tapping":
|
|
case "left-tapping":
|
|
case "right-tapping":
|
|
case "fine-boring":
|
|
case "back-boring":
|
|
case "reaming":
|
|
case "stop-boring":
|
|
case "manual-boring":
|
|
case "boring":
|
|
default:
|
|
expandCyclePoint(x, y, z);
|
|
}
|
|
} else {
|
|
if (cycleExpanded) {
|
|
expandCyclePoint(x, y, z);
|
|
} else {
|
|
var _x = xOutput.format(toUM(x));
|
|
var _y = yOutput.format(toUM(y));
|
|
if (_x || _y) {
|
|
writeBlock("DRILL", _x, _y);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function onCycleEnd() {
|
|
zOutput.reset();
|
|
}
|
|
|
|
function onRadiusCompensation() {
|
|
if (radiusCompensation != RADIUS_COMPENSATION_OFF) {
|
|
error(localize("Radius compensation in the controller is not supported."));
|
|
}
|
|
}
|
|
|
|
function onRapid(_x, _y, _z) {
|
|
var x = xOutput.format(toUM(_x));
|
|
var y = yOutput.format(toUM(_y));
|
|
var z = zOutput.format(toUM(_z));
|
|
if (x || y || z) {
|
|
writeBlock("FASTABS", x, y, z);
|
|
feedOutput.reset();
|
|
}
|
|
}
|
|
|
|
function onLinear(_x, _y, _z, feed) {
|
|
var x = xOutput.format(toUM(_x));
|
|
var y = yOutput.format(toUM(_y));
|
|
var z = zOutput.format(toUM(_z));
|
|
var vel = feedOutput.format(toVel(feed));
|
|
if (vel) {
|
|
writeBlock("VEL", vel);
|
|
}
|
|
if (x || y || z) {
|
|
writeBlock("MOVEABS", x, y, z);
|
|
}
|
|
}
|
|
|
|
function onRapid5D(_x, _y, _z, _a, _b, _c) {
|
|
if (!currentSection.isOptimizedForMachine()) {
|
|
error(localize("This post configuration has not been customized for 5-axis simultaneous toolpath."));
|
|
return;
|
|
}
|
|
var x = xOutput.format(toUM(_x));
|
|
var y = yOutput.format(toUM(_y));
|
|
var z = zOutput.format(toUM(_z));
|
|
var a = aOutput.format(toAS(_a));
|
|
var b = bOutput.format(toAS(_b));
|
|
var c = cOutput.format(toAS(_c));
|
|
var vel = feedOutput.format(toVel(feed));
|
|
if (x || y || z || a || b || c) {
|
|
writeBlock("MOVEABS", x, y, z, a, b, c);
|
|
feedOutput.reset();
|
|
}
|
|
}
|
|
|
|
function onLinear5D(_x, _y, _z, _a, _b, _c, feed) {
|
|
if (!currentSection.isOptimizedForMachine()) {
|
|
error(localize("This post configuration has not been customized for 5-axis simultaneous toolpath."));
|
|
return;
|
|
}
|
|
var x = xOutput.format(toUM(_x));
|
|
var y = yOutput.format(toUM(_y));
|
|
var z = zOutput.format(toUM(_z));
|
|
var a = aOutput.format(toAS(_a));
|
|
var b = bOutput.format(toAS(_b));
|
|
var c = cOutput.format(toAS(_c));
|
|
var vel = feedOutput.format(toVel(feed));
|
|
if (vel) {
|
|
writeBlock("VEL", vel);
|
|
}
|
|
if (x || y || z || a || b || c) {
|
|
|
|
writeBlock("MOVEABS", x, y, z, a, b, c);
|
|
}
|
|
}
|
|
|
|
function onCircular(clockwise, cx, cy, cz, x, y, z, feed) {
|
|
var vel = feedOutput.format(toVel(feed));
|
|
if (vel) {
|
|
writeBlock("VEL", vel);
|
|
}
|
|
|
|
if (isHelical()) {
|
|
if (getProperty("useHelicalArcs")) {
|
|
switch (getCircularPlane()) {
|
|
case PLANE_XY:
|
|
writePlane("XY");
|
|
writeBlock(clockwise ? "CWHLXABS" : "CCWHLXABS", iOutput.format(toUM(cx)), jOutput.format(toUM(cy)), "W" + sweepFormat.format(getCircularSweep()), xOutput.format(toUM(x)), yOutput.format(toUM(y)), zOutput.format(toUM(z)));
|
|
break;
|
|
case PLANE_ZX: // note: left hand coordinate system
|
|
writePlane("XZ");
|
|
writeBlock(clockwise ? "CCWHLXABS" : "CWHLXABS", iOutput.format(toUM(cx)), kOutput.format(toUM(cz)), "W" + sweepFormat.format(getCircularSweep()), xOutput.format(toUM(x)), yOutput.format(toUM(y)), zOutput.format(toUM(z)));
|
|
break;
|
|
case PLANE_YZ:
|
|
writePlane("YZ");
|
|
writeBlock(clockwise ? "CWHLXABS" : "CCWHLXABS", jOutput.format(toUM(cy)), kOutput.format(toUM(cz)), "W" + sweepFormat.format(getCircularSweep()), xOutput.format(toUM(x)), yOutput.format(toUM(y)), zOutput.format(toUM(z)));
|
|
break;
|
|
default:
|
|
linearize(tolerance);
|
|
}
|
|
} else {
|
|
linearize(tolerance);
|
|
return;
|
|
}
|
|
} else {
|
|
switch (getCircularPlane()) {
|
|
case PLANE_XY:
|
|
writePlane("XY");
|
|
writeBlock(clockwise ? "CWABS" : "CCWABS", iOutput.format(toUM(cx)), jOutput.format(toUM(cy)), xOutput.format(toUM(x)), yOutput.format(toUM(y)), zOutput.format(toUM(z)));
|
|
break;
|
|
case PLANE_ZX: // note: left hand coordinate system
|
|
writePlane("XZ");
|
|
writeBlock(clockwise ? "CCWABS" : "CWABS", iOutput.format(toUM(cx)), kOutput.format(toUM(cz)), xOutput.format(toUM(x)), yOutput.format(toUM(y)), zOutput.format(toUM(z)));
|
|
break;
|
|
case PLANE_YZ:
|
|
writePlane("YZ");
|
|
writeBlock(clockwise ? "CWABS" : "CCWABS", jOutput.format(toUM(cy)), kOutput.format(toUM(cz)), xOutput.format(toUM(x)), yOutput.format(toUM(y)), zOutput.format(toUM(z)));
|
|
break;
|
|
default:
|
|
linearize(tolerance);
|
|
}
|
|
}
|
|
}
|
|
|
|
var mapCommand = {
|
|
COMMAND_SPINDLE_CLOCKWISE : "SPINDLE CW",
|
|
COMMAND_SPINDLE_COUNTERCLOCKWISE: "SPINDLE CCW",
|
|
COMMAND_START_SPINDLE : "SPINDLE ON",
|
|
COMMAND_STOP_SPINDLE : "SPINDLE OFF"
|
|
};
|
|
|
|
function onCommand(command) {
|
|
switch (command) {
|
|
case COMMAND_STOP:
|
|
writeBlock("HALT");
|
|
forceSpindleSpeed = true;
|
|
forceCoolant = true;
|
|
return;
|
|
case COMMAND_LOCK_MULTI_AXIS:
|
|
return;
|
|
case COMMAND_UNLOCK_MULTI_AXIS:
|
|
return;
|
|
case COMMAND_BREAK_CONTROL:
|
|
return;
|
|
case COMMAND_TOOL_MEASURE:
|
|
return;
|
|
case COMMAND_COOLANT_OFF:
|
|
setCoolant(COOLANT_OFF);
|
|
return;
|
|
case COMMAND_COOLANT_ON:
|
|
setCoolant(COOLANT_FLOOD);
|
|
return;
|
|
}
|
|
|
|
/*
|
|
if (command == COMMAND_START_SPINDLE) {
|
|
writeBlock("SPINDLE", (tool.clockwise ? "CW" : "CCW"));
|
|
return;
|
|
}
|
|
*/
|
|
if (command == COMMAND_STOP_SPINDLE) {
|
|
lastSpindleSpeed = 0;
|
|
}
|
|
var stringId = getCommandStringId(command);
|
|
var mcode = mapCommand[stringId];
|
|
if (mcode != undefined) {
|
|
writeBlock(mcode);
|
|
} else {
|
|
onUnsupportedCommand(command);
|
|
}
|
|
}
|
|
|
|
function onSectionEnd() {
|
|
forceAny();
|
|
}
|
|
|
|
/** Output block to do safe retract and/or move to home position. */
|
|
function writeRetract() {
|
|
var words = []; // store all retracted axes in an array
|
|
var retractAxes = new Array(false, false, false);
|
|
var method = getProperty("safePositionMethod");
|
|
if (method == "clearanceHeight") {
|
|
if (!is3D()) {
|
|
error(localize("Safe retract option 'Clearance Height' is only supported when all operations are along the setup Z-axis."));
|
|
}
|
|
return;
|
|
}
|
|
validate(arguments.length != 0, "No axis specified for writeRetract().");
|
|
|
|
for (i in arguments) {
|
|
retractAxes[arguments[i]] = true;
|
|
}
|
|
if ((retractAxes[0] || retractAxes[1]) && !retracted) { // retract Z first before moving to X/Y home
|
|
error(localize("Retracting in X/Y is not possible without being retracted in Z."));
|
|
return;
|
|
}
|
|
// special conditions
|
|
/*
|
|
if (retractAxes[2]) { // Z doesn't use G53
|
|
method = "G28";
|
|
}
|
|
*/
|
|
|
|
// define home positions
|
|
var _xHome;
|
|
var _yHome;
|
|
var _zHome;
|
|
if (method == "G28") {
|
|
_xHome = toPreciseUnit(0, MM);
|
|
_yHome = toPreciseUnit(0, MM);
|
|
_zHome = toPreciseUnit(0, MM);
|
|
} else {
|
|
_xHome = machineConfiguration.hasHomePositionX() ? machineConfiguration.getHomePositionX() : toPreciseUnit(0, MM);
|
|
_yHome = machineConfiguration.hasHomePositionY() ? machineConfiguration.getHomePositionY() : toPreciseUnit(0, MM);
|
|
_zHome = machineConfiguration.getRetractPlane() != 0 ? machineConfiguration.getRetractPlane() : toPreciseUnit(0, MM);
|
|
}
|
|
for (var i = 0; i < arguments.length; ++i) {
|
|
switch (arguments[i]) {
|
|
case X:
|
|
words.push("X" + xyzFormat.format(toUM(_xHome)));
|
|
xOutput.reset();
|
|
break;
|
|
case Y:
|
|
words.push("Y" + xyzFormat.format(toUM(_yHome)));
|
|
yOutput.reset();
|
|
break;
|
|
case Z:
|
|
words.push("Z" + xyzFormat.format(toUM(_zHome)));
|
|
zOutput.reset();
|
|
retracted = true;
|
|
break;
|
|
default:
|
|
error(localize("Unsupported axis specified for writeRetract()."));
|
|
return;
|
|
}
|
|
}
|
|
if (words.length > 0) {
|
|
switch (method) {
|
|
case "G28":
|
|
gMotionModal.reset();
|
|
gAbsIncModal.reset();
|
|
writeBlock(gFormat.format(28), gAbsIncModal.format(91), words);
|
|
writeBlock(gAbsIncModal.format(90));
|
|
break;
|
|
case "G53":
|
|
gMotionModal.reset();
|
|
writeBlock(gAbsIncModal.format(90), gFormat.format(53), gMotionModal.format(0), words);
|
|
break;
|
|
case "wpclear":
|
|
writeBlock("WPCLEAR");
|
|
writeBlock("FASTABS", words);
|
|
writeWCS();
|
|
break;
|
|
default:
|
|
error(localize("Unsupported safe position method."));
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
function onClose() {
|
|
onCommand(COMMAND_COOLANT_OFF);
|
|
writeBlock("SPINDLE", "OFF");
|
|
|
|
setWorkPlane(new Vector(0, 0, 0)); // reset working plane
|
|
|
|
onImpliedCommand(COMMAND_STOP_SPINDLE);
|
|
onImpliedCommand(COMMAND_END);
|
|
writeBlock("PROGEND");
|
|
}
|
|
|
|
function setProperty(property, value) {
|
|
properties[property].current = value;
|
|
}
|