/** Copyright (C) 2012-2017 by Autodesk, Inc. All rights reserved. MicroKinetics TurnMaster Pro Lathe post processor configuration. $Revision$ $Date$ FORKID {88B77760-269E-4d46-8588-30814E7FE9A1} */ description = "MicroKenetics TurnMaster Pro"; vendor = "MicroKinetics"; vendorUrl = "http://www.microkinetics.com"; legal = "Copyright (C) 2012-2017 by Autodesk, Inc."; certificationLevel = 2; minimumRevision = 24000; extension = "cnc"; programNameIsInteger = true; setCodePage("ascii"); capabilities = CAPABILITY_TURNING; 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: false, // write machine writeTools: true, // writes the tools preloadTool: false, // preloads next tool on tool change if any showSequenceNumbers: true, // show sequence numbers sequenceNumberStart: 10, // first sequence number sequenceNumberIncrement: 1, // increment for sequence numbers optionalStop: true, // optional stop separateWordsWithSpace: true, // specifies that the words should be separated with a white space useRadius: false, // specifies that arcs should be output using the radius (R word) instead of the I, J, and K words. maximumSpindleSpeed: 100 * 60, // specifies the maximum spindle speed showNotes: false, // specifies that operation notes should be output. toolChangePosX: 0, toolChangePosZ: 0, materialInnerDiameter: 0, }; //var permittedCommentChars = " ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.,=_-"; var permittedCommentChars = " ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.,=_-{}:"; var gFormat = createFormat({prefix:"G", decimals:1, width:2, zeropad:true}); var mFormat = createFormat({prefix:"M", decimals:1, width:2, zeropad:true}); var spatialFormat = createFormat({decimals:(unit == MM ? 3 : 4), forceDecimal:true}); var xFormat = createFormat({decimals:(unit == MM ? 3 : 4), forceDecimal:true, scale:1}); // diameter mode var yFormat = createFormat({decimals:(unit == MM ? 3 : 4), forceDecimal:true}); var zFormat = createFormat({decimals:(unit == MM ? 3 : 4), forceDecimal:true}); var rFormat = createFormat({decimals:(unit == MM ? 3 : 4), forceDecimal:true}); // radius var feedFormat = createFormat({decimals:0, scale:(unit == MM ? 1 : 10)}); var pitchFormat = createFormat({decimals:(unit == MM ? 3 : 4), forceDecimal:true}); var toolFormat = createFormat({decimals:0, width:2, zeropad:true}); 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 xzFormat = createFormat({decimals:(unit == MM ? 3 : 4)}); var xOutput = createVariable({prefix:"X"}, xFormat); var yOutput = createVariable({prefix:"Y"}, yFormat); var zOutput = createVariable({prefix:"Z"}, zFormat); var feedOutput = createVariable({prefix:"F"}, feedFormat); var pitchOutput = createVariable({prefix:"K", force:true}, pitchFormat); var sOutput = createVariable({prefix:"S", force:true}, rpmFormat); // circular output var kOutput = createReferenceVariable({prefix:"K"}, xFormat); var iOutput = createReferenceVariable({prefix:"I"}, xFormat); // no scaling var g92ROutput = createVariable({prefix:"R"}, zFormat); // no scaling var gMotionModal = createModal({}, 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 // only for B and C mode var gFeedModeModal = createModal({}, gFormat); // modal group 5 // G98-99 / G94-95 var gSpindleModeModal = createModal({}, gFormat); // modal group 5 // G96-97 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 // fixed settings var firstFeedParameter = 500; var gotSecondarySpindle = true; var gotPartCatcher = false; var WARNING_WORK_OFFSET = 0; // collected state var sequenceNumber; var currentWorkOffset; var optionalSection = false; var forceSpindleSpeed = false; var activeMovements; // do not use by default var currentFeedId; /** Writes the specified block. */ function writeBlock() { if (properties.showSequenceNumbers) { if (optionalSection) { var text = formatWords(arguments); if (text) { writeWords("/", "N" + sequenceNumber, text); } } else { writeWords2("N" + sequenceNumber, arguments); } sequenceNumber += properties.sequenceNumberIncrement; } else { if (optionalSection) { writeWords2("/", arguments); } else { writeWords(arguments); } } } /** Writes the specified optional block. */ function writeOptionalBlock() { if (properties.showSequenceNumbers) { var words = formatWords(arguments); if (words) { writeWords("/", "N" + sequenceNumber, words); sequenceNumber += properties.sequenceNumberIncrement; } } else { writeWords2("/", arguments); } } function formatComment(text) { return "/ " + filterText(String(text).toUpperCase(), permittedCommentChars).replace(/[\(\)]/g, ""); } function formatStarComment(text) { return "/*" + filterText(String(text).toUpperCase(), permittedCommentChars).replace(/[\(\)]/g, ""); } /** Output a comment. */ function writeComment(text) { writeln(formatComment(text)); } /** Output a /* comment. */ function writeStarComment(text) { writeln(formatStarComment(text)); } function onOpen() { if (properties.useRadius) { maximumCircularSweep = toRad(90); // avoid potential center calculation errors for CNC } yOutput.disable(); if (!properties.separateWordsWithSpace) { setWordSeparator(""); } sequenceNumber = properties.sequenceNumberStart; if (programName) { writeComment(programName); } if (programComment) { writeComment(programComment); } // 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); } } writeStarComment(" {DEFVAR}: TCPX, " + properties.toolChangePosX + " "); writeStarComment(" {DEFVAR}: TCPZ, " + properties.toolChangePosZ + " "); var stock = getWorkpiece(); var materialDiameter = stock.upper.x - stock.lower.x; writeStarComment(" {O.D.}: " + spatialFormat.format(materialDiameter)); writeStarComment(" {I.D.}: " + spatialFormat.format(properties.materialInnerDiameter)); writeStarComment(" {PART LENGTH}: " + spatialFormat.format(stock.upper.z - stock.lower.z)); var xStart = (materialDiameter / 2) + 0.050; var zStart = 0.050; writeStarComment(" {X START}: " + spatialFormat.format(xStart)); writeStarComment(" {Z START}: " + spatialFormat.format(zStart)); // Dump tool information if (properties.writeTools) { var tools = getToolTable(); if (tools.getNumberOfTools() > 0) { for (var i = 0; i < tools.getNumberOfTools(); ++i) { var tool = tools.getTool(i); var comment = " {TOOL}: #" + toolFormat.format(tool.number) + ", " + getToolTypeName(tool.type) + ", RADIUS = " + xzFormat.format(tool.getCornerRadius()); writeStarComment(comment); } } } // absolute coordinates and feed per min writeBlock(gAbsIncModal.format(90)); if (properties.useRadius) { writeBlock(gFormat.format(75)); } else { writeBlock(gFormat.format(74)); } switch (unit) { case IN: writeBlock(gUnitModal.format(70)); break; case MM: writeBlock(gUnitModal.format(71)); break; } } function onComment(message) { writeComment(message); } /** Force output of X, Y, and Z. */ function forceXYZ() { xOutput.reset(); yOutput.reset(); zOutput.reset(); } function forceFeed() { currentFeedId = undefined; feedOutput.reset(); } /** Force output of X, Y, Z, and F on next output. */ function forceAny() { forceXYZ(); forceFeed(); } function getFeed(f) { return feedOutput.format(f); // use feed value } function getSpindle() { if (getNumberOfSections() == 0) { return SPINDLE_PRIMARY; } if (getCurrentSectionId() < 0) { return getSection(getNumberOfSections() - 1).spindle == 0; } if (currentSection.getType() == TYPE_TURNING) { return currentSection.spindle; } else { if (isSameDirection(currentSection.workPlane.forward, new Vector(0, 0, 1))) { return SPINDLE_PRIMARY; } else if (isSameDirection(currentSection.workPlane.forward, new Vector(0, 0, -1))) { if (!gotSecondarySpindle) { error(localize("Secondary spindle is not available.")); } return SPINDLE_SECONDARY; } else { return SPINDLE_PRIMARY; } } } function onSection() { if (currentSection.getType() != TYPE_TURNING) { if (!hasParameter("operation-strategy") || (getParameter("operation-strategy") != "drill")) { if (currentSection.getType() == TYPE_MILLING) { error(localize("Milling toolpath is not supported.")); } else { error(localize("Non-turning toolpath is not supported.")); } return; } } var forceToolAndRetract = optionalSection && !currentSection.isOptional(); optionalSection = currentSection.isOptional(); var turning = (currentSection.getType() == TYPE_TURNING); var insertToolCall = forceToolAndRetract || 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 newSpindle = isFirstSection() || (getPreviousSection().spindle != currentSection.spindle); var newWorkOffset = isFirstSection() || (getPreviousSection().workOffset != currentSection.workOffset); // work offset changes if (insertToolCall || newSpindle || newWorkOffset) { // retract to safe plane retracted = true; //writeBlock(gFormat.format(28), "U" + xFormat.format(0)); // retract forceXYZ(); } writeln(""); if (hasParameter("operation-comment")) { var comment = getParameter("operation-comment"); if (comment) { writeComment(comment); } } if (properties.showNotes && hasParameter("notes")) { var notes = getParameter("notes"); if (notes) { var lines = String(notes).split("\n"); var r1 = new RegExp("^[\\s]+", "g"); var r2 = new RegExp("[\\s]+$", "g"); for (line in lines) { var comment = lines[line].replace(r1, "").replace(r2, ""); if (comment) { writeComment(comment); } } } } if (insertToolCall) { retracted = true; // onCommand(COMMAND_COOLANT_OFF); if (!isFirstSection() && properties.optionalStop) { onCommand(COMMAND_OPTIONAL_STOP); } if (tool.number > 99) { warning(localize("Tool number exceeds maximum value.")); } var compensationOffset = tool.isTurningTool() ? tool.compensationOffset : tool.lengthOffset; if (compensationOffset > 99) { error(localize("Compensation offset is out of range.")); return; } gMotionModal.reset(); writeBlock(gMotionModal.format(0), "X(TCPX) Z(TCPZ)"); writeBlock(mFormat.format(6), "T" + toolFormat.format(tool.number)); if (tool.comment) { writeComment(tool.comment); } } // set coolant after we have positioned at Z //setCoolant(tool.coolant); forceAny(); gMotionModal.reset(); gFeedModeModal.reset(); var mSpindle = tool.clockwise ? 3 : 4; gSpindleModeModal.reset(); if (currentSection.getTool().getSpindleMode() == SPINDLE_CONSTANT_SURFACE_SPEED) { writeBlock(gSpindleModeModal.format(96), sOutput.format(tool.surfaceSpeed * ((unit == MM) ? 1/1000.0 : 1/12.0)), mFormat.format(mSpindle)); // var maximumSpindleSpeed = (tool.maximumSpindleSpeed > 0) ? Math.min(tool.maximumSpindleSpeed, properties.maximumSpindleSpeed) : properties.maximumSpindleSpeed; // writeBlock(gFormat.format(92), sOutput.format(maximumSpindleSpeed)); } else { writeBlock(gSpindleModeModal.format(97), sOutput.format(tool.spindleRPM), mFormat.format(mSpindle)); } setRotation(currentSection.workPlane); var initialPosition = getFramePosition(currentSection.getInitialPosition()); if (!retracted) { // TAG: need to retract along X or Z if (getCurrentPosition().z < initialPosition.z) { writeBlock(gMotionModal.format(0), zOutput.format(initialPosition.z)); } } if (insertToolCall) { gMotionModal.reset(); writeBlock( gAbsIncModal.format(0), xOutput.format(initialPosition.x), yOutput.format(initialPosition.y), zOutput.format(initialPosition.z) ); gMotionModal.reset(); } if (gotPartCatcher && (currentSection.partCatcher || (typeof currentSection.partCatcher == "undefined") && hasParameter("operation-strategy") && (getParameter("operation-strategy") == "turningPart"))) { // activate part catcher here } if (insertToolCall || retracted) { gPlaneModal.reset(); } } var resetFeed = false; 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" + secFormat.format(milliseconds)); } 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 is not supported by machine.")); return; } else { writeBlock(gMotionModal.format(0), x, y, z); } forceFeed(); } } function onLinear(_x, _y, _z, feed) { var x = xOutput.format(_x); var y = yOutput.format(_y); var z = zOutput.format(_z); var f = getFeed(feed); if (x || y || z) { if (pendingRadiusCompensation >= 0) { error(localize("Radius compensation mode is not supported by machine.")); return; } else { writeBlock(gMotionModal.format(1), x, y, z, f); } } else if (f) { if (getNextRecord().isMotion()) { // try not to output feed without motion forceFeed(); // force feed on next line } else { writeBlock(gMotionModal.format(1), f); } } } function onCircular(clockwise, cx, cy, cz, x, y, z, feed) { if (isSpeedFeedSynchronizationActive()) { error(localize("Speed-feed synchronization is not supported for circular moves.")); return; } if (pendingRadiusCompensation >= 0) { error(localize("Radius compensation mode is not supported by machine.")); return; } var start = getCurrentPosition(); if (isFullCircle()) { if (properties.useRadius || isHelical()) { // radius mode does not support full arcs linearize(tolerance); return; } switch (getCircularPlane()) { case PLANE_ZX: writeBlock(gMotionModal.format(clockwise ? 2 : 3), iOutput.format(Math.abs(cx - start.x), 0), kOutput.format(Math.abs(cz - start.z), 0), getFeed(feed)); break; default: linearize(tolerance); } } else if (!properties.useRadius) { switch (getCircularPlane()) { case PLANE_ZX: writeBlock(gMotionModal.format(clockwise ? 2 : 3), xOutput.format(x), yOutput.format(y), zOutput.format(z), iOutput.format(Math.abs(cx - start.x),0), kOutput.format(Math.abs(cz - start.z),0), getFeed(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_ZX: writeBlock(gMotionModal.format(clockwise ? 2 : 3), xOutput.format(x), yOutput.format(y), zOutput.format(z), "R" + rFormat.format(r ), getFeed(feed)); break; default: linearize(tolerance); } } } function onCycle() { } function getCommonCycle(x, y, z, r) { forceXYZ(); // force xyz on first drill hole of any cycle return [xOutput.format(x), yOutput.format(y), zOutput.format(z), "R" + spatialFormat.format(r)]; } function onCyclePoint(x, y, z) { if (isSameDirection(currentSection.workPlane.forward, new Vector(0, 0, 1)) || isSameDirection(currentSection.workPlane.forward, new Vector(0, 0, -1))) { writeBlock(gPlaneModal.format(17)); // XY plane } else { expandCyclePoint(x, y, z); return; } if (isFirstCyclePoint()) { switch (gPlaneModal.getCurrent()) { case 17: if (cycleType != "thread-turning") { writeBlock(gMotionModal.format(0), zOutput.format(cycle.clearance)); break; } case 18: writeBlock(gMotionModal.format(0), yOutput.format(cycle.clearance)); break; case 19: writeBlock(gMotionModal.format(0), xOutput.format(cycle.clearance)); break; default: error(localize("Unsupported drilling orientation.")); return; } if (cycleType != "thread-turning") { 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 "thread-turning": var threadsPerInch = 1.0/cycle.pitch; // per mm for metric var f = 1/threadsPerInch; var threadDepth = getParameter("operation:threadDepth"); var numberOfPasses = getParameter("operation:numberOfStepdowns"); writeBlock(xOutput.format(x)); // move to the start diameter writeBlock(gMotionModal.format(33), "X" + xFormat.format(threadDepth/numberOfPasses), "Z" + zFormat.format(z), pitchOutput.format(f), "Q" + numberOfPasses); return; case "drilling": writeBlock( CycleModal.format(83), getCommonCycle(x, y, z, cycle.retract), "Q1", feedOutput.format(F) ); break; case "chip-breaking": // cycle.accumulatedDepth is ignored if (P > 0) { expandCyclePoint(x, y, z); } else { writeBlock( gCycleModal.format(87), getCommonCycle(x, y, z, cycle.retract), "Q" + xFormat.format(cycle.incrementalDepth), feedOutput.format(F) ); } break; case "deep-drilling": if (P > 0) { expandCyclePoint(x, y, z); } else { writeBlock( gCycleModal.format(83), getCommonCycle(x, y, z, cycle.retract), "Q" + xFormat.format(cycle.incrementalDepth), // conditional(P > 0, "P" + milliFormat.format(P)), feedOutput.format(F) ); } break; default: expandCyclePoint(x, y, z); } } else { if (cycleType=="thread-turning") { return; // stop processing onCycle Point we only need one line of code for g33 } if (cycleExpanded) { expandCyclePoint(x, y, z); } else { var _x = xOutput.format(x); var _y = yOutput.format(y); var _z = zOutput.format(z); if (!_x && !_y && !_z) { switch (gPlaneModal.getCurrent()) { case 17: // XY xOutput.reset(); // at least one axis is required _x = xOutput.format(x); break; case 18: // ZX zOutput.reset(); // at least one axis is required _z = zOutput.format(z); break; case 19: // YZ yOutput.reset(); // at least one axis is required _y = yOutput.format(y); break; } } writeBlock(_x, _y, _z); } } } function onCycleEnd() { if (!cycleExpanded) { switch (cycleType) { case "thread-turning": forceFeed(); xOutput.reset(); zOutput.reset(); g92ROutput.reset(); break; default: writeBlock(gCycleModal.format(80)); } } } var currentCoolantMode = COOLANT_OFF; function setCoolant(coolant) { if (coolant == currentCoolantMode) { return; // coolant is already active } var m = undefined; if (coolant == COOLANT_OFF) { writeBlock(mFormat.format((currentCoolantMode == COOLANT_THROUGH_TOOL) ? 89 : 9)); currentCoolantMode = COOLANT_OFF; return; } switch (coolant) { case COOLANT_FLOOD: m = 8; break; case COOLANT_THROUGH_TOOL: m = 88; break; default: onUnsupportedCoolant(coolant); m = 9; } if (m) { writeBlock(mFormat.format(m)); currentCoolantMode = coolant; } } function onCommand(command) { switch (command) { case COMMAND_COOLANT_OFF: setCoolant(COOLANT_OFF); return; case COMMAND_COOLANT_ON: setCoolant(COOLANT_FLOOD); return; case COMMAND_LOCK_MULTI_AXIS: return; case COMMAND_UNLOCK_MULTI_AXIS: return; case COMMAND_START_CHIP_TRANSPORT: return; case COMMAND_STOP_CHIP_TRANSPORT: return; case COMMAND_BREAK_CONTROL: return; case COMMAND_TOOL_MEASURE: return; case COMMAND_ACTIVATE_SPEED_FEED_SYNCHRONIZATION: return; case COMMAND_DEACTIVATE_SPEED_FEED_SYNCHRONIZATION: return; case COMMAND_STOP: writeBlock(mFormat.format(0)); forceSpindleSpeed = true; return; case COMMAND_OPTIONAL_STOP: writeBlock(mFormat.format(1)); break; case COMMAND_END: writeBlock(mFormat.format(2)); break; case COMMAND_SPINDLE_CLOCKWISE: switch (currentSection.spindle) { case SPINDLE_PRIMARY: writeBlock(mFormat.format(3)); break; case SPINDLE_SECONDARY: writeBlock(mFormat.format(143)); break; } break; case COMMAND_SPINDLE_COUNTERCLOCKWISE: switch (currentSection.spindle) { case SPINDLE_PRIMARY: writeBlock(mFormat.format(4)); break; case SPINDLE_SECONDARY: writeBlock(mFormat.format(144)); break; } break; case COMMAND_START_SPINDLE: onCommand(tool.clockwise ? COMMAND_SPINDLE_CLOCKWISE : COMMAND_SPINDLE_COUNTERCLOCKWISE); return; case COMMAND_STOP_SPINDLE: switch (currentSection.spindle) { case SPINDLE_PRIMARY: writeBlock(mFormat.format(5)); break; case SPINDLE_SECONDARY: writeBlock(mFormat.format(145)); break; } break; case COMMAND_ORIENTATE_SPINDLE: if (getSpindle() == 0) { writeBlock(mFormat.format(19)); // use P or R to set angle (optional) } else { writeBlock(mFormat.format(119)); } break; //case COMMAND_CLAMP: // TAG: add support for clamping //case COMMAND_UNCLAMP: // TAG: add support for clamping default: onUnsupportedCommand(command); } } function onSectionEnd() { forceAny(); if (gotPartCatcher && (currentSection.partCatcher || (typeof currentSection.partCatcher == "undefined") && hasParameter("operation-strategy") && (getParameter("operation-strategy") == "turningPart"))) { // deactivate part catcher here } } function onClose() { optionalSection = false; // onCommand(COMMAND_COOLANT_OFF); onCommand(COMMAND_STOP_SPINDLE); // we might want to retract in Z before X // writeBlock(gFormat.format(28), "U" + xFormat.format(0)); // retract forceXYZ(); if (!machineConfiguration.hasHomePositionX() && !machineConfiguration.hasHomePositionY()) { writeBlock(mFormat.format(25)); // return to home } else { var homeX; if (machineConfiguration.hasHomePositionX()) { homeX = xOutput.format(machineConfiguration.getHomePositionX()); } var homeY; if (yOutput.isEnabled() && machineConfiguration.hasHomePositionY()) { homeY = yOutput.format(machineConfiguration.getHomePositionY()); } writeBlock(gFormat.format(53), gMotionModal.format(0), homeX, homeY, zOutput.format(machineConfiguration.getRetractPlane())); } writeBlock(mFormat.format(2)); // stop program }