Created
January 22, 2019 03:44
-
-
Save liamkinne/cdb6199c561212b09affc67c708fc0d7 to your computer and use it in GitHub Desktop.
Post processor config for the Tekcel M Series Router. Has some changes to work with the old controller.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
/** | |
Copyright (C) 2012-2016 by Autodesk, Inc. | |
All rights reserved. | |
TekMOV Router post processor configuration. | |
$Revision$ | |
$Date$ | |
FORKID {21E9AB8B-76BE-4e51-9D5B-CA4A2631FC5F} | |
*/ | |
description = "TEKCEL CNC Router"; | |
vendor = "TEKCEL"; | |
vendorUrl = "http://www.tekcel.com.au"; | |
legal = "Copyright (C) 2012-2016 by Autodesk, Inc."; | |
certificationLevel = 2; | |
minimumRevision = 24000; | |
extension = "cnc"; | |
programNameIsInteger = false; | |
setCodePage("ascii"); | |
tolerance = spatial(0.002, MM); | |
minimumChordLength = spatial(0.01, MM); | |
minimumCircularRadius = spatial(0.01, MM); | |
maximumCircularRadius = spatial(1000, MM); | |
minimumCircularSweep = toRad(0.01); | |
maximumCircularSweep = toRad(180); | |
allowHelicalMoves = true; | |
allowedCircularPlanes = undefined; // allow any circular motion | |
// user-defined properties | |
properties = { | |
writeMachine: true, // write machine | |
writeTools: true, // writes the tools | |
showSequenceNumbers: false, // show sequence numbers | |
sequenceNumberStart: 10, // first sequence number | |
sequenceNumberIncrement: 10, // increment for sequence numbers | |
separateWordsWithSpace: true, // specifies that the words should be separated with a white space | |
optionalStop: false, // output optional stop prior to tool change | |
useRadius: false, // specifies that arcs should be output using the radius (R word) instead of the I, J, and K words. | |
zHome: 20.0, // Z-axis home position | |
outputCircular: true, // machine supports circular interpolation | |
linearizeTolerance: 1000.0 // tolerance for linearizing XY-moves | |
}; | |
var permittedCommentChars = " ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.,=_-"; | |
var mapCoolantTable = new Table( | |
[9, 8, null, 88], | |
{initial:COOLANT_OFF, force:true}, | |
"Invalid coolant mode" | |
); | |
var gFormat = createFormat({prefix:"G", decimals:0}); | |
var mFormat = createFormat({prefix:"M", width:2, zeropad:true, decimals:0}); | |
var hFormat = createFormat({prefix:"H", decimals:0}); | |
var dFormat = createFormat({prefix:"D", decimals:0}); | |
var xyzFormat = createFormat({decimals:(unit == MM ? 3 : 4), forceDecimal:true}); | |
var rFormat = xyzFormat; // radius | |
var abcFormat = createFormat({decimals:3, forceDecimal:true, scale:DEG}); | |
var feedFormat = createFormat({decimals:(unit == MM ? 0 : 0), forceDecimal:false}); | |
var toolFormat = createFormat({decimals:0}); | |
var rpmFormat = createFormat({decimals:0}); | |
var secFormat = createFormat({decimals:3, forceDecimal:true}); // seconds - range 0.001-99999.999 | |
var milliFormat = createFormat({decimals:0}); // milliseconds // range 1-9999 | |
var taperFormat = createFormat({decimals:1, scale:DEG}); | |
var xOutput = createVariable({prefix:"X", force:true}, xyzFormat); | |
var yOutput = createVariable({prefix:"Y", force:true}, xyzFormat); | |
var zOutput = createVariable({prefix:"Z", force:true}, xyzFormat); | |
var aOutput = createVariable({prefix:"A"}, abcFormat); | |
var bOutput = createVariable({prefix:"B"}, abcFormat); | |
var cOutput = createVariable({prefix:"C"}, abcFormat); | |
var feedOutput = createVariable({prefix:"F"}, feedFormat); | |
var sOutput = createVariable({prefix:"S", force:true}, rpmFormat); | |
var dOutput = createVariable({}, dFormat); | |
// circular output | |
var iOutput = createReferenceVariable({prefix:"I"}, xyzFormat); | |
var jOutput = createReferenceVariable({prefix:"J"}, xyzFormat); | |
var kOutput = createReferenceVariable({prefix:"K"}, xyzFormat); | |
var gMotionModal = createModal({force:true}, gFormat); // modal group 1 // G0-G3, ... | |
var gPlaneModal = createModal({onchange:function () {gMotionModal.reset();}}, gFormat); // modal group 2 // G17-19 | |
var gAbsIncModal = createModal({}, gFormat); // modal group 3 // G90-91 | |
var gFeedModeModal = createModal({}, gFormat); // modal group 5 // G93-94 | |
var gUnitModal = createModal({}, gFormat); // modal group 6 // G20-21 | |
var gCycleModal = createModal({}, gFormat); // modal group 9 // G81, ... | |
var gRetractModal = createModal({}, gFormat); // modal group 10 // G98-99 | |
var WARNING_WORK_OFFSET = 0; | |
// collected state | |
var sequenceNumber; | |
var currentWorkOffset; | |
/** | |
Writes the specified block. | |
*/ | |
function writeBlock() { | |
if (properties.showSequenceNumbers) { | |
writeWords2("N" + sequenceNumber, arguments); | |
sequenceNumber += properties.sequenceNumberIncrement; | |
} else { | |
writeWords(arguments); | |
} | |
} | |
/** | |
Output a comment. | |
*/ | |
function writeComment(text) { | |
writeln("(" + filterText(String(text).toUpperCase(), permittedCommentChars) + ")"); | |
} | |
function onOpen() { | |
if (!machineConfiguration.isMachineCoordinate(0)) { | |
aOutput.disable(); | |
} | |
if (!machineConfiguration.isMachineCoordinate(1)) { | |
bOutput.disable(); | |
} | |
if (!machineConfiguration.isMachineCoordinate(2)) { | |
cOutput.disable(); | |
} | |
if (!properties.separateWordsWithSpace) { | |
setWordSeparator(""); | |
} | |
sequenceNumber = properties.sequenceNumberStart; | |
// writeln("%"); | |
/* | |
if (programName) { | |
var programId; | |
try { | |
programId = getAsInt(programName); | |
} catch(e) { | |
error(localize("Program name must be a number.")); | |
} | |
if (properties.o8) { | |
if (!((programId >= 1) && (programId <= 99999999))) { | |
error(localize("Program number is out of range.")); | |
} | |
} else { | |
if (!((programId >= 1) && (programId <= 9999))) { | |
error(localize("Program number is out of range.")); | |
} | |
} | |
if ((programId >= 8000) && (programId <= 9999)) { | |
warning(localize("Program number is reserved by tool builder.")); | |
} | |
var oFormat = createFormat({width:(properties.o8 ? 8 : 4), zeropad:true, decimals:0}); | |
if (programComment) { | |
writeln("O" + oFormat.format(programId) + " (" + filterText(String(programComment).toUpperCase(), permittedCommentChars) + ")"); | |
} else { | |
writeln("O" + oFormat.format(programId)); | |
} | |
} else { | |
error(localize("Program name has not been specified.")); | |
} | |
*/ | |
// dump machine configuration | |
var vendor = machineConfiguration.getVendor(); | |
var model = machineConfiguration.getModel(); | |
var description = machineConfiguration.getDescription(); | |
if (properties.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 (properties.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(gUnitModal.format(20)); | |
break; | |
case MM: | |
writeBlock(gUnitModal.format(21)); | |
break; | |
} | |
// Output startup blocks | |
writeBlock(gAbsIncModal.format(90), zOutput.format(properties.zHome)); | |
writeBlock(gPlaneModal.format(17)); | |
writeBlock(gFormat.format(40)); | |
writeBlock(gCycleModal.format(80)); | |
} | |
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 F on next output. */ | |
function forceAny() { | |
forceXYZ(); | |
forceABC(); | |
feedOutput.reset(); | |
} | |
function onParameter(name, value) { | |
} | |
var currentWorkPlaneABC = undefined; | |
function forceWorkPlane() { | |
currentWorkPlaneABC = undefined; | |
} | |
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( | |
gMotionModal.format(0), | |
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 = true; | |
if (tcp) { | |
setRotation(W); // TCP mode | |
} else { | |
var O = machineConfiguration.getOrientation(abc); | |
var R = machineConfiguration.getRemainingOrientation(abc, W); | |
setRotation(R); | |
} | |
return abc; | |
} | |
function onSection() { | |
var insertToolCall = isFirstSection() || | |
currentSection.getForceToolChange && currentSection.getForceToolChange() || | |
(tool.number != getPreviousSection().getTool().number); | |
var 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 (insertToolCall || newWorkOffset || newWorkPlane) { | |
// retract to safe plane | |
/* | |
retracted = true; | |
writeBlock(gFormat.format(28), gAbsIncModal.format(91), "Z" + xyzFormat.format(0)); // retract | |
writeBlock(gAbsIncModal.format(90)); | |
zOutput.reset(); | |
*/ | |
} | |
if (hasParameter("operation-comment")) { | |
var comment = getParameter("operation-comment"); | |
if (comment) { | |
writeComment(comment); | |
} | |
} | |
if (insertToolCall) { | |
// forceWorkPlane(); | |
// onCommand(COMMAND_COOLANT_OFF); | |
if (!isFirstSection() && properties.optionalStop) { | |
onCommand(COMMAND_OPTIONAL_STOP); | |
} | |
if (tool.number > 99) { | |
warning(localize("Tool number exceeds maximum value.")); | |
} | |
if (tool.comment) { | |
writeComment(tool.comment); | |
} | |
writeBlock(mFormat.format(6), "T" + toolFormat.format(tool.number)); | |
var showToolZMin = false; | |
if (showToolZMin) { | |
if (is3D()) { | |
var numberOfSections = getNumberOfSections(); | |
var zRange = currentSection.getGlobalZRange(); | |
var number = tool.number; | |
for (var i = currentSection.getId() + 1; i < numberOfSections; ++i) { | |
var section = getSection(i); | |
if (section.getTool().number != number) { | |
break; | |
} | |
zRange.expandToRange(section.getGlobalZRange()); | |
} | |
writeComment(localize("ZMIN") + "=" + zRange.getMinimum()); | |
} | |
} | |
} | |
if (insertToolCall || | |
isFirstSection() || | |
(rpmFormat.areDifferent(tool.spindleRPM, sOutput.getCurrent())) || | |
(tool.clockwise != getPreviousSection().getTool().clockwise)) { | |
if (tool.spindleRPM < 1) { | |
error(localize("Spindle speed out of range.")); | |
} | |
if (tool.spindleRPM > 99999) { | |
warning(localize("Spindle speed exceeds maximum value.")); | |
} | |
writeBlock( | |
mFormat.format(tool.clockwise ? 3 : 4), sOutput.format(tool.spindleRPM) | |
); | |
} | |
/* | |
// wcs | |
if (insertToolCall) { // force work offset when changing tool | |
currentWorkOffset = undefined; | |
} | |
var workOffset = currentSection.workOffset; | |
if (workOffset == 0) { | |
warningOnce(localize("Work offset has not been specified. Using G54 as WCS."), WARNING_WORK_OFFSET); | |
workOffset = 1; | |
} | |
if (workOffset > 0) { | |
if (workOffset > 6) { | |
error(localize("Work offset out of range.")); | |
} else { | |
if (workOffset != currentWorkOffset) { | |
writeBlock(gFormat.format(53 + workOffset)); // G54->G59 | |
currentWorkOffset = workOffset; | |
} | |
} | |
} | |
*/ | |
forceXYZ(); | |
if (machineConfiguration.isMultiAxisConfiguration()) { // use 5-axis indexing for multi-axis mode | |
// set working plane after datum shift | |
var abc = new Vector(0, 0, 0); | |
if (currentSection.isMultiAxis()) { | |
forceWorkPlane(); | |
cancelTransformation(); | |
} else { | |
abc = getWorkPlaneMachineABC(currentSection.workPlane); | |
} | |
setWorkPlane(abc); | |
} else { // 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); | |
} | |
// set coolant after we have positioned at Z | |
/* | |
{ | |
var c = mapCoolantTable.lookup(tool.coolant); | |
if (c) { | |
writeBlock(mFormat.format(c)); | |
} else { | |
warning(localize("Coolant not supported.")); | |
} | |
} | |
*/ | |
forceAny(); | |
gMotionModal.reset(); | |
/* | |
var initialPosition = getFramePosition(currentSection.getInitialPosition()); | |
writeBlock(gMotionModal.format(0), xOutput.format(initialPosition.x), | |
yOutput.format(initialPosition.y), zOutput.format(initialPosition.z)); | |
*/ | |
} | |
function onDwell(seconds) { | |
if (seconds > 99999.999) { | |
warning(localize("Dwelling time is out of range.")); | |
} | |
milliseconds = clamp(1, seconds * 1000, 99999999); | |
writeBlock(gFeedModeModal.format(94), gFormat.format(4), "P" + milliFormat.format(milliseconds)); | |
} | |
function onSpindleSpeed(spindleSpeed) { | |
writeBlock(sOutput.format(spindleSpeed)); | |
} | |
function onCycle() { | |
writeBlock(gPlaneModal.format(17)); | |
} | |
function getCommonCycle(x, y, z, r) { | |
forceXYZ(); | |
return [xOutput.format(x), yOutput.format(y), | |
zOutput.format(z), | |
"R" + xyzFormat.format(r)]; | |
} | |
function onCyclePoint(x, y, z) { | |
if (isFirstCyclePoint()) { | |
repositionToCycleClearance(cycle, x, y, z); | |
// return to initial Z which is clearance plane and set absolute mode | |
var F = cycle.feedrate; | |
var P = (cycle.dwell == 0) ? 0 : clamp(1, cycle.dwell * 1000, 99999999); // in milliseconds | |
switch (cycleType) { | |
case "drilling": | |
writeBlock( | |
gCycleModal.format(81), | |
getCommonCycle(x, y, z, cycle.retract), | |
feedOutput.format(F) | |
); | |
break; | |
case "deep-drilling": | |
// cycle.accumulatedDepth is ignored | |
if (P > 0) { | |
expandCyclePoint(x, y, z); | |
} else { | |
writeBlock( | |
gCycleModal.format(83), | |
getCommonCycle(x, y, z, cycle.retract), | |
"Q" + xyzFormat.format(cycle.incrementalDepth), | |
feedOutput.format(F) | |
); | |
} | |
break; | |
default: | |
expandCyclePoint(x, y, z); | |
} | |
} else { | |
if (cycleExpanded) { | |
expandCyclePoint(x, y, z); | |
} else { | |
writeBlock(xOutput.format(x), yOutput.format(y)); | |
} | |
} | |
} | |
function onCycleEnd() { | |
if (!cycleExpanded) { | |
writeBlock(gCycleModal.format(80)); | |
zOutput.reset(); | |
} | |
} | |
var pendingRadiusCompensation = -1; | |
function onRadiusCompensation() { | |
pendingRadiusCompensation = radiusCompensation; | |
} | |
function onRapid(_x, _y, _z) { | |
var x = xOutput.format(_x); | |
var y = yOutput.format(_y); | |
var z = zOutput.format(_z); | |
if (x || y || z) { | |
if (pendingRadiusCompensation >= 0) { | |
error(localize("Radius compensation mode cannot be changed at rapid traversal.")); | |
} | |
writeBlock(gMotionModal.format(0), x, y, z); | |
feedOutput.reset(); | |
} | |
} | |
function onLinear(_x, _y, _z, feed) { | |
var x = xOutput.format(_x); | |
var y = yOutput.format(_y); | |
var z = zOutput.format(_z); | |
//writeln("OnLinear = " + x + ", " + y + ", " + z); | |
var f = feedOutput.format(feed); | |
if (x || y || z) { | |
var compRegister = ""; | |
var dRegister = ""; | |
if (pendingRadiusCompensation >= 0) { | |
pendingRadiusCompensation = -1; | |
var d = tool.diameterOffset; | |
if (d > 99) { | |
warning(localize("The diameter offset exceeds the maximum value.")); | |
} | |
writeBlock(gPlaneModal.format(17)); | |
switch (radiusCompensation) { | |
case RADIUS_COMPENSATION_LEFT: | |
dOutput.reset(); | |
compRegister = gFormat.format(41); | |
dRegister = dOutput.format(d); | |
break; | |
case RADIUS_COMPENSATION_RIGHT: | |
dOutput.reset(); | |
compRegister = gFormat.format(42); | |
dRegister = dOutput.format(d); | |
break; | |
default: | |
compRegister = gFormat.format(40); | |
} | |
} | |
// | |
//...Linearize move | |
// | |
var start = getCurrentPosition(); | |
//writeln("Previous = " + start.x + ", " + start.y + ", " + start.z); | |
var end = new Vector(_x, _y, _z); | |
var fwdvec = Vector.diff(end,start); | |
var unitvec = fwdvec.getNormalized(); | |
var numberOfSegments = getNumberOfSegments(start,end); | |
//writeln("numberOfSegments = " + numberOfSegments); | |
// numberOfSegments = 1; | |
// var factor = 1.0/numberOfSegments; | |
var factor = fwdvec.length / numberOfSegments; | |
//writeln("Length = " + fwdvec.length); | |
for (var i = 1; i <= numberOfSegments; ++i) { | |
var p = Vector.sum(start, Vector.product(unitvec, (i * factor))); | |
// var p = getPositionU(i * factor); | |
var x = xOutput.format(p.x); | |
var y = yOutput.format(p.y); | |
var z = zOutput.format(p.z); | |
writeBlock(gMotionModal.format(1), compRegister, x, y, z, dRegister, f); | |
compRegister = ""; | |
dRegister = ""; | |
} | |
// | |
//...No motion output with this move | |
// | |
} else if (f) { | |
if (getNextRecord().isMotion()) { // try not to output feed without motion | |
feedOutput.reset(); // force feed on next line | |
} else { | |
writeBlock(gMotionModal.format(1), f); | |
} | |
} | |
} | |
function getNumberOfSegments(_start,_end) { | |
// | |
//...Calculate angle to use for linearization | |
//...The angle is the smallest difference between the angle of the move | |
//...and 0, 45, 90 degrees | |
// | |
var fwdvec = Vector.diff(_start, _end); | |
var angle = Math.abs(fwdvec.getNormalized().getXYAngle()); | |
//writeln("angle = " + toDeg(angle)); | |
angle = (angle > Math.PI/2.0) ? Math.PI - angle : angle; | |
angle = (angle > Math.PI/4.0) ? Math.PI/2.0 - angle : angle; | |
angle = Math.min(angle,(Math.PI/4.0-angle)); | |
//writeln("last angle = " + toDeg(angle)); | |
if (angle == 0.0) { | |
return 1; | |
} | |
// | |
//...Calculate the maximum percentage of the move | |
// | |
var maxLength = properties.linearizeTolerance / Math.sin(angle) * 2.0; | |
//writeln("maxLength = " + maxLength); | |
var moveLength = fwdvec.length; | |
//writeln("moveLength = " + moveLength); | |
var numberOfSegments = (moveLength > maxLength) ? Math.ceil(moveLength / maxLength) : 1; | |
return(numberOfSegments); | |
} | |
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; | |
} | |
if (pendingRadiusCompensation >= 0) { | |
error(localize("Radius compensation mode cannot be changed at rapid traversal.")); | |
return; | |
} | |
var x = xOutput.format(_x); | |
var y = yOutput.format(_y); | |
var z = zOutput.format(_z); | |
var a = aOutput.format(_a); | |
var b = bOutput.format(_b); | |
var c = cOutput.format(_c); | |
writeBlock(gMotionModal.format(0), 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; | |
} | |
if (pendingRadiusCompensation >= 0) { | |
error(localize("Radius compensation cannot be activated/deactivated for 5-axis move.")); | |
return; | |
} | |
var x = xOutput.format(_x); | |
var y = yOutput.format(_y); | |
var z = zOutput.format(_z); | |
var a = aOutput.format(_a); | |
var b = bOutput.format(_b); | |
var c = cOutput.format(_c); | |
var f = feedOutput.format(feed); | |
if (x || y || z || a || b || c) { | |
writeBlock(gMotionModal.format(1), x, y, z, a, b, c, f); | |
} else if (f) { | |
if (getNextRecord().isMotion()) { // try not to output feed without motion | |
feedOutput.reset(); // force feed on next line | |
} else { | |
writeBlock(gMotionModal.format(1), f); | |
} | |
} | |
} | |
function onCircular(clockwise, cx, cy, cz, x, y, z, feed) { | |
if (!properties.outputCircular) { | |
linearize(tolerance); | |
return; | |
} | |
if (pendingRadiusCompensation >= 0) { | |
error(localize("Radius compensation cannot be activated/deactivated for a circular move.")); | |
return; | |
} | |
var start = getCurrentPosition(); | |
if (isFullCircle()) { | |
if (properties.useRadius || isHelical()) { // radius mode does not support full arcs | |
linearize(tolerance); | |
return; | |
} | |
switch (getCircularPlane()) { | |
case PLANE_XY: | |
writeBlock(gAbsIncModal.format(90), gPlaneModal.format(17), gMotionModal.format(clockwise ? 2 : 3), iOutput.format(cx - start.x, 0), jOutput.format(cy - start.y, 0), feedOutput.format(feed)); | |
break; | |
case PLANE_ZX: | |
writeBlock(gAbsIncModal.format(90), gPlaneModal.format(18), gMotionModal.format(clockwise ? 2 : 3), iOutput.format(cx - start.x, 0), kOutput.format(cz - start.z, 0), feedOutput.format(feed)); | |
break; | |
case PLANE_YZ: | |
writeBlock(gAbsIncModal.format(90), gPlaneModal.format(19), gMotionModal.format(clockwise ? 2 : 3), jOutput.format(cy - start.y, 0), kOutput.format(cz - start.z, 0), feedOutput.format(feed)); | |
break; | |
default: | |
linearize(tolerance); | |
} | |
} else if (!properties.useRadius) { | |
switch (getCircularPlane()) { | |
case PLANE_XY: | |
writeBlock(gAbsIncModal.format(90), gPlaneModal.format(17), gMotionModal.format(clockwise ? 2 : 3), xOutput.format(x), yOutput.format(y), zOutput.format(z), iOutput.format(cx - start.x, 0), jOutput.format(cy - start.y, 0), feedOutput.format(feed)); | |
break; | |
case PLANE_ZX: | |
writeBlock(gAbsIncModal.format(90), gPlaneModal.format(18), gMotionModal.format(clockwise ? 2 : 3), xOutput.format(x), yOutput.format(y), zOutput.format(z), iOutput.format(cx - start.x, 0), kOutput.format(cz - start.z, 0), feedOutput.format(feed)); | |
break; | |
case PLANE_YZ: | |
writeBlock(gAbsIncModal.format(90), gPlaneModal.format(19), gMotionModal.format(clockwise ? 2 : 3), xOutput.format(x), yOutput.format(y), zOutput.format(z), jOutput.format(cy - start.y, 0), kOutput.format(cz - start.z, 0), feedOutput.format(feed)); | |
break; | |
default: | |
linearize(tolerance); | |
} | |
} else { // use radius mode | |
var r = getCircularRadius(); | |
if (toDeg(getCircularSweep()) > (180 + 1e-9)) { | |
r = -r; // allow up to <360 deg arcs | |
} | |
switch (getCircularPlane()) { | |
case PLANE_XY: | |
writeBlock(gPlaneModal.format(17), gMotionModal.format(clockwise ? 2 : 3), xOutput.format(x), yOutput.format(y), zOutput.format(z), "R" + rFormat.format(r), feedOutput.format(feed)); | |
break; | |
case PLANE_ZX: | |
writeBlock(gPlaneModal.format(18), gMotionModal.format(clockwise ? 2 : 3), xOutput.format(x), yOutput.format(y), zOutput.format(z), "R" + rFormat.format(r), feedOutput.format(feed)); | |
break; | |
case PLANE_YZ: | |
writeBlock(gPlaneModal.format(19), gMotionModal.format(clockwise ? 2 : 3), xOutput.format(x), yOutput.format(y), zOutput.format(z), "R" + rFormat.format(r), feedOutput.format(feed)); | |
break; | |
default: | |
linearize(tolerance); | |
} | |
} | |
} | |
var mapCommand = { | |
COMMAND_STOP:0, | |
COMMAND_OPTIONAL_STOP:1, | |
COMMAND_END:2, | |
COMMAND_SPINDLE_CLOCKWISE:3, | |
COMMAND_SPINDLE_COUNTERCLOCKWISE:4, | |
COMMAND_STOP_SPINDLE:5, | |
COMMAND_ORIENTATE_SPINDLE:19, | |
COMMAND_LOAD_TOOL:6, | |
COMMAND_COOLANT_ON:8, | |
COMMAND_COOLANT_OFF:9 | |
}; | |
function onCommand(command) { | |
switch (command) { | |
case COMMAND_START_SPINDLE: | |
onCommand(tool.clockwise ? COMMAND_SPINDLE_CLOCKWISE : COMMAND_SPINDLE_COUNTERCLOCKWISE); | |
return; | |
case COMMAND_LOCK_MULTI_AXIS: | |
return; | |
case COMMAND_UNLOCK_MULTI_AXIS: | |
return; | |
case COMMAND_BREAK_CONTROL: | |
return; | |
case COMMAND_TOOL_MEASURE: | |
return; | |
} | |
var stringId = getCommandStringId(command); | |
var mcode = mapCommand[stringId]; | |
if (mcode != undefined) { | |
writeBlock(mFormat.format(mcode)); | |
} else { | |
onUnsupportedCommand(command); | |
} | |
} | |
function onSectionEnd() { | |
// writeBlock(gPlaneModal.format(17)); | |
forceAny(); | |
} | |
function onClose() { | |
// onCommand(COMMAND_COOLANT_OFF); | |
/* | |
writeBlock(gFormat.format(28), gAbsIncModal.format(91), "Z" + xyzFormat.format(0)); // retract | |
zOutput.reset(); | |
*/ | |
setWorkPlane(new Vector(0, 0, 0)); // reset working plane | |
writeBlock(gMotionModal.format(0),zOutput.format(properties.zHome)); | |
writeBlock(mFormat.format(6), "T" + toolFormat.format(0)); | |
onImpliedCommand(COMMAND_END); | |
onImpliedCommand(COMMAND_STOP_SPINDLE); | |
// writeBlock(mFormat.format(30)); // stop program, spindle stop, coolant off | |
// writeln("%"); | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment