Texte vergleichen

Finde den Unterschied zwischen zwei Textdateien

Live-Editor

Gleiches ausblenden

Zeilenumbruch aus

Ansicht

Vergleichsgenauigkeit

Syntaxhervorhebung

Diffchecker Desktop Der sicherste Weg, Diffchecker zu nutzen. Hol dir die Desktop-App: Deine Diffs verlassen nie deinen Computer!Desktop holen

Untitled diff

Erstellt vor 11 JahrenDiff läuft nie ab

52 Entfernungen

Zeilen
Gesamt
Entfernt

Zeichen
Gesamt
Entfernt

Um diese Funktion weiterhin zu nutzen, aktualisiere auf Diffchecker Pro Preise anzeigen

793 Zeilen

48 Hinzufügungen

Zeilen
Gesamt
Hinzugefügt

Zeichen
Gesamt
Hinzugefügt

Um diese Funktion weiterhin zu nutzen, aktualisiere auf Diffchecker Pro Preise anzeigen

776 Zeilen

/**

Tormach Mach3Mill post processor configuration.

Tormach Path Pilot post processor configuration.

$Revision: 39140 $

$Revision: 37254 $

$Date: 2015-06-10 14:13:32 +0200 (on, 10 jun 2015) $

$Date: 2014-05-26 11:17:00 +0200 (ma, 26 maj 2014) $

FORKID {AE2102AB-B86A-4aa7-8E9B-F0B6935D4E9F}

//setWriteStack(true);

description = "Generic Tormach Mach3Mill";

description = "Generic Tormach Path Pilot";

vendor = "Autodesk, Inc.";

vendorUrl = "http://www.autodesk.com";

certificationLevel = 2;

minimumRevision = 24000;

extension = "TAP";

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

useG28: true, // disable to avoid G28 output

useM6: true, // disable to avoid M6 output - preload is also disabled when M6 is disabled

preloadTool: false, // preloads next tool on tool change if any

showSequenceNumbers: true, // show sequence numbers

sequenceNumberStart: 10, // first sequence number

sequenceNumberIncrement: 10, // increment for sequence numbers

optionalStop: true, // optional stop

separateWordsWithSpace: true, // specifies that the words should be separated with a white space

useRadius: true, // specifies that arcs should be output using the radius (R word) instead of the I, J, and K words.

dwellInSeconds: true // specifies the unit for dwelling: true:seconds and false:milliseconds.

};

var permittedCommentChars = " ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.,=_-";

var mapCoolantTable = new Table(

[9, 8, 7],

{initial:COOLANT_OFF, force:true},

"Invalid coolant mode"

);

var nFormat = createFormat({prefix:"N", decimals:0});

var gFormat = createFormat({prefix:"G", decimals:1});

var mFormat = createFormat({prefix:"M", 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 : 1), forceDecimal:true});

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"}, xyzFormat);

var yOutput = createVariable({prefix:"Y"}, xyzFormat);

var zOutput = createVariable({prefix:"Z"}, 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", force:true}, xyzFormat);

var jOutput = createReferenceVariable({prefix:"J", force:true}, xyzFormat);

var kOutput = createReferenceVariable({prefix:"K", force:true}, 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 gCycleModal = createModal({force:false}, gFormat); // modal group 9 // G81, ...

var gRetractModal = createModal({}, gFormat); // modal group 10 // G98-99

var gRetractModal = createModal({force:true}, gFormat); // modal group 10 // G98-99

var WARNING_WORK_OFFSET = 0;

// collected state

var sequenceNumber;

var currentWorkOffset;

var previousCoolantMode;

/**

Writes the specified block.

function writeBlock() {

if (properties.showSequenceNumbers) {

writeWords2(nFormat.format(sequenceNumber % 100000), arguments);

sequenceNumber += properties.sequenceNumberIncrement;

} else {

writeWords(arguments);

}

/**

Output a comment.

function writeComment(text) {

writeln("(" + filterText(String(text).toUpperCase(), permittedCommentChars) + ")");

}

function onOpen() {

if (false) {

var aAxis = createAxis({coordinate:0, table:true, axis:[-1, 0, 0], cyclic:true, preference:1});

machineConfiguration = new MachineConfiguration(aAxis);

setMachineConfiguration(machineConfiguration);

optimizeMachineAngles2(1); // map tip mode

}

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("%");

writeln("(*********************************************************)");

writeln("(* Tormach Path Pilot Post Processsor Version 0.4 Debug *)");

writeln("(*********************************************************)");

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);

}

// 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);

}

if (false) {

// check for duplicate tool number

for (var i = 0; i < getNumberOfSections(); ++i) {

var sectioni = getSection(i);

var tooli = sectioni.getTool();

for (var j = i + 1; j < getNumberOfSections(); ++j) {

var sectionj = getSection(j);

var toolj = sectionj.getTool();

if (tooli.number == toolj.number) {

if (xyzFormat.areDifferent(tooli.diameter, toolj.diameter) ||

xyzFormat.areDifferent(tooli.cornerRadius, toolj.cornerRadius) ||

abcFormat.areDifferent(tooli.taperAngle, toolj.taperAngle) ||

(tooli.numberOfFlutes != toolj.numberOfFlutes)) {

error(

subst(

localize("Using the same tool number for different cutter geometry for operation '%1' and '%2'."),

sectioni.hasParameter("operation-comment") ? sectioni.getParameter("operation-comment") : ("#" + (i + 1)),

sectionj.hasParameter("operation-comment") ? sectionj.getParameter("operation-comment") : ("#" + (j + 1))

)

);

return;

}

// absolute coordinates and feed per min

writeBlock(gAbsIncModal.format(90), gFormat.format(54), gFormat.format(64), gFormat.format(50), gPlaneModal.format(17), gFormat.format(40), gFormat.format(80), gFeedModeModal.format(94), gFormat.format(91.1), gFormat.format(49));

switch (unit) {

case IN:

writeBlock(gUnitModal.format(20));

writeBlock(gUnitModal.format(20), "(Inch)" );

break;

case MM:

writeBlock(gUnitModal.format(21));

writeBlock(gUnitModal.format(21), "(Metric)");

break;

}

function onComment(message) {

var comments = String(message).split(";");

for (comment in comments) {

writeComment(comments[comment]);

}

/** 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();

}

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) {

if (properties.useG28) {

// retract to safe plane

retracted = true;

writeBlock(gFormat.format(28), gAbsIncModal.format(91), "Z" + xyzFormat.format(0)); // retract

//writeBlock(gFormat.format(28), gAbsIncModal.format(91), "Z" + xyzFormat.format(0)); // retract

writeBlock(gFormat.format(30)); // use G30 instead of G28 above

writeBlock(gAbsIncModal.format(90));

zOutput.reset();

}

writeln("");

if (hasParameter("operation-comment")) {

var comment = getParameter("operation-comment");

if (comment) {

writeComment(comment);

}

if (insertToolCall) {

forceWorkPlane();

// onCommand(COMMAND_STOP_SPINDLE);

// onCommand(COMMAND_COOLANT_OFF);

if (!isFirstSection() && properties.optionalStop) {

onCommand(COMMAND_OPTIONAL_STOP);

}

if (tool.number > 256) {

warning(localize("Tool number exceeds maximum value."));

}

var lengthOffset = tool.lengthOffset;

if (lengthOffset > 256) {

error(localize("Length offset out of range."));

return;

}

writeBlock(mFormat.format(998));

// writeBlock(mFormat.format(998));

writeBlock(gFormat.format(30));

if (properties.useM6) {

writeBlock("T" + toolFormat.format(tool.number),

gFormat.format(43),

hFormat.format(lengthOffset),

mFormat.format(6));

} else {

writeBlock("T" + toolFormat.format(tool.number), gFormat.format(43), hFormat.format(lengthOffset));

}

if (tool.comment) {

writeComment(tool.comment);

}

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 (properties.preloadTool && properties.useM6) {

var nextTool = getNextTool(tool.number);

if (nextTool) {

writeBlock("T" + toolFormat.format(nextTool.number));

} else {

// preload first tool

var section = getSection(0);

var firstToolNumber = section.getTool().number;

if (tool.number != firstToolNumber) {

writeBlock("T" + toolFormat.format(firstToolNumber));

}

if (insertToolCall ||

// set coolant after we have positioned at Z

var c = mapCoolantTable.lookup(tool.coolant);

/* {

var c = mapCoolantTable.lookup(tool.coolant);

if (c) {

writeBlock(mFormat.format(c));

} else {

warning(localize("Coolant not supported."));

}

} */

/* if (insertToolCall ||

isFirstSection() ||

(rpmFormat.areDifferent(tool.spindleRPM, sOutput.getCurrent())) ||

(tool.clockwise != getPreviousSection().getTool().clockwise)) {

(tool.clockwise != getPreviousSection().getTool().clockwise) || previousCoolantMode != c) { */

if (tool.spindleRPM < 1) {

error(localize("Spindle speed out of range."));

return;

}

if (tool.spindleRPM > 99999) {

warning(localize("Spindle speed exceeds maximum value."));

}

writeBlock(

sOutput.format(tool.spindleRPM), mFormat.format(tool.clockwise ? 3 : 4)

sOutput.format(tool.spindleRPM), mFormat.format(tool.clockwise ? 3 : 4),

conditional(c, mFormat.format(c))

);

}

previousCoolantMode = c;

// }

// wcs

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) {

var p = workOffset; // 1->... // G59 P1 is the same as G54 and so on

if (p > 254) {

error(localize("Work offset out of range."));

} else {

if (workOffset != currentWorkOffset) {

writeBlock(gFormat.format(59), "P" + p); // G59 P

currentWorkOffset = workOffset;

}

} 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);

}

forceAny();

gMotionModal.reset();

var initialPosition = getFramePosition(currentSection.getInitialPosition());

if (!retracted) {

if (getCurrentPosition().z < initialPosition.z) {

writeBlock(gMotionModal.format(0), zOutput.format(initialPosition.z));

}

if (!insertToolCall && retracted) { // G43 already called above on tool change

var lengthOffset = tool.lengthOffset;

if (lengthOffset > 256) {

error(localize("Length offset out of range."));

return;

}

gMotionModal.reset();

writeBlock(gPlaneModal.format(17));

if (!machineConfiguration.isHeadConfiguration()) {

writeBlock(

gAbsIncModal.format(90),

gMotionModal.format(0), xOutput.format(initialPosition.x), yOutput.format(initialPosition.y)

);

writeBlock(gMotionModal.format(0), gFormat.format(43), zOutput.format(initialPosition.z), hFormat.format(lengthOffset));

} else {

writeBlock(

gAbsIncModal.format(90),

gMotionModal.format(0),

gFormat.format(43), xOutput.format(initialPosition.x),

yOutput.format(initialPosition.y),

zOutput.format(initialPosition.z), hFormat.format(lengthOffset)

);

}

} else {

writeBlock(

gAbsIncModal.format(90),

gMotionModal.format(0),

xOutput.format(initialPosition.x),

yOutput.format(initialPosition.y)

);

}

// 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."));

}

} */

}

function onDwell(seconds) {

if (seconds > 99999.999) {

warning(localize("Dwelling time is out of range."));

}

if (properties.dwellInSeconds) {

writeBlock(gFormat.format(4), "P" + secFormat.format(seconds));

} else {

milliseconds = clamp(1, seconds * 1000, 99999999);

writeBlock(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 : cycle.dwell; // in seconds

switch (cycleType) {

case "drilling":

writeBlock(

gRetractModal.format(98), gAbsIncModal.format(90), gCycleModal.format(81),

getCommonCycle(x, y, z, cycle.retract),

feedOutput.format(F)

);

break;

case "counter-boring":

if (P > 0) {

writeBlock(

gRetractModal.format(98), gAbsIncModal.format(90), gCycleModal.format(82),

getCommonCycle(x, y, z, cycle.retract),

"P" + secFormat.format(P),

feedOutput.format(F)

);

} else {

writeBlock(

gRetractModal.format(98), gAbsIncModal.format(90), gCycleModal.format(81),

getCommonCycle(x, y, z, cycle.retract),

feedOutput.format(F)

);

}

break;

case "chip-breaking":

// cycle.accumulatedDepth is ignored

if (P > 0) {

expandCyclePoint(x, y, z);

} else {

writeBlock(

gRetractModal.format(98), gAbsIncModal.format(90), gCycleModal.format(73),

getCommonCycle(x, y, z, cycle.retract),

"Q" + xyzFormat.format(cycle.incrementalDepth),

feedOutput.format(F)

);

}

break;

case "deep-drilling":

if (P > 0) {

expandCyclePoint(x, y, z);

} else {

writeBlock(

gRetractModal.format(98), gAbsIncModal.format(90), gCycleModal.format(83),

getCommonCycle(x, y, z, cycle.retract),

"Q" + xyzFormat.format(cycle.incrementalDepth),

// conditional(P > 0, "P" + secFormat.format(P)),

feedOutput.format(F)

);

}

break;

case "tapping":

if (tool.type == TOOL_TAP_LEFT_HAND) {

expandCyclePoint(x, y, z);

} else {

if (!F) {

F = tool.getTappingFeedrate();

}

writeBlock(mFormat.format(29), sOutput.format(tool.spindleRPM));

writeBlock(sOutput.format(tool.spindleRPM));

writeBlock(

gRetractModal.format(98), gAbsIncModal.format(90), gCycleModal.format(84),

getCommonCycle(x, y, z, cycle.retract),

"P" + secFormat.format(P),

feedOutput.format(F)

);

}

break;

case "left-tapping":

expandCyclePoint(x, y, z);

break;

case "right-tapping":

if (!F) {

F = tool.getTappingFeedrate();

}

writeBlock(mFormat.format(29), sOutput.format(tool.spindleRPM));

writeBlock(

gRetractModal.format(98), gAbsIncModal.format(90), gCycleModal.format(84),

getCommonCycle(x, y, z, cycle.retract),

"P" + secFormat.format(P),

feedOutput.format(F)

);

break;

case "fine-boring":

writeBlock(

gRetractModal.format(98), gAbsIncModal.format(90), gCycleModal.format(76),

getCommonCycle(x, y, z, cycle.retract),

"P" + secFormat.format(P),

"Q" + xyzFormat.format(cycle.shift),

feedOutput.format(F)

);

break;

case "back-boring":

var dx = (gPlaneModal.getCurrent() == 19) ? cycle.backBoreDistance : 0;

var dy = (gPlaneModal.getCurrent() == 18) ? cycle.backBoreDistance : 0;

var dz = (gPlaneModal.getCurrent() == 17) ? cycle.backBoreDistance : 0;

writeBlock(

gRetractModal.format(98), gAbsIncModal.format(90), gCycleModal.format(87),

getCommonCycle(x - dx, y - dy, z - dz, cycle.bottom),

"I" + xyzFormat.format(cycle.shift),

"J" + xyzFormat.format(0),

"P" + secFormat.format(P),

feedOutput.format(F)

);

break;

case "reaming":

if (P > 0) {

writeBlock(

gRetractModal.format(98), gAbsIncModal.format(90), gCycleModal.format(89),

getCommonCycle(x, y, z, cycle.retract),

"P" + secFormat.format(P),

feedOutput.format(F)

);

} else {

writeBlock(

gRetractModal.format(98), gAbsIncModal.format(90), gCycleModal.format(85),

getCommonCycle(x, y, z, cycle.retract),

feedOutput.format(F)

);

}

break;

case "stop-boring":

writeBlock(

gRetractModal.format(98), gAbsIncModal.format(90), gCycleModal.format(86),

getCommonCycle(x, y, z, cycle.retract),

"P" + secFormat.format(P),

feedOutput.format(F)

);

break;

case "manual-boring":

writeBlock(

gRetractModal.format(98), gAbsIncModal.format(90), gCycleModal.format(88),

getCommonCycle(x, y, z, cycle.retract),

"P" + secFormat.format(P),

feedOutput.format(F)

);

break;

case "boring":

if (P > 0) {

writeBlock(

gRetractModal.format(98), gAbsIncModal.format(90), gCycleModal.format(89),

getCommonCycle(x, y, z, cycle.retract),

getCo

"P" + secFormat.format(P),

feedOutput.format(F)

);

} else {

writeBlock(

gRetractModal.format(98), gAbsIncModal.format(90), gCycleModal.format(85),

getCommonCycle(x, y, z, cycle.retract),

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

Gespeicherte Diffs

Originaltext

Datei öffnen

Tormach Mach3Mill post processor configuration.

$Revision: 39140 $
  $Date: 2015-06-10 14:13:32 +0200 (on, 10 jun 2015) $
  
  FORKID {AE2102AB-B86A-4aa7-8E9B-F0B6935D4E9F}
*/

description = "Generic Tormach Mach3Mill";
vendor = "Autodesk, Inc.";
vendorUrl = "http://www.autodesk.com";
legal = "Copyright (C) 2012-2014 by Autodesk, Inc.";
certificationLevel = 2;
minimumRevision = 24000;

extension = "TAP";
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
  useG28: true, // disable to avoid G28 output
  useM6: true, // disable to avoid M6 output - preload is also disabled when M6 is disabled
  preloadTool: false, // preloads next tool on tool change if any
  showSequenceNumbers: true, // show sequence numbers
  sequenceNumberStart: 10, // first sequence number
  sequenceNumberIncrement: 10, // increment for sequence numbers
  optionalStop: true, // optional stop
  separateWordsWithSpace: true, // specifies that the words should be separated with a white space
  useRadius: true, // specifies that arcs should be output using the radius (R word) instead of the I, J, and K words.
  dwellInSeconds: true // specifies the unit for dwelling: true:seconds and false:milliseconds.
};

var permittedCommentChars = " ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.,=_-";

var mapCoolantTable = new Table(
  [9, 8, 7],
  {initial:COOLANT_OFF, force:true},
  "Invalid coolant mode"
);

// circular output
var iOutput = createReferenceVariable({prefix:"I", force:true}, xyzFormat);
var jOutput = createReferenceVariable({prefix:"J", force:true}, xyzFormat);
var kOutput = createReferenceVariable({prefix:"K", force:true}, xyzFormat);

var WARNING_WORK_OFFSET = 0;

// collected state
var sequenceNumber;
var currentWorkOffset;

/**
  Writes the specified block.
*/
function writeBlock() {
  if (properties.showSequenceNumbers) {
    writeWords2(nFormat.format(sequenceNumber % 100000), arguments);
    sequenceNumber += properties.sequenceNumberIncrement;
  } else {
    writeWords(arguments);
  }
}

/**
  Output a comment.
*/
function writeComment(text) {
  writeln("(" + filterText(String(text).toUpperCase(), permittedCommentChars) + ")");
}

function onOpen() {

if (false) {
    var aAxis = createAxis({coordinate:0, table:true, axis:[-1, 0, 0], cyclic:true, preference:1});
    machineConfiguration = new MachineConfiguration(aAxis);

setMachineConfiguration(machineConfiguration);
    optimizeMachineAngles2(1); // map tip mode
  }

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) {
    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);
    }
  }

// 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;
        }
      }
    }

// absolute coordinates and feed per min
  writeBlock(gAbsIncModal.format(90), gFormat.format(54), gFormat.format(64), gFormat.format(50), gPlaneModal.format(17), gFormat.format(40), gFormat.format(80), gFeedModeModal.format(94), gFormat.format(91.1), gFormat.format(49));

switch (unit) {
  case IN:
    writeBlock(gUnitModal.format(20));
    break;
  case MM:
    writeBlock(gUnitModal.format(21));
    break;
  }
}

function onComment(message) {
  var comments = String(message).split(";");
  for (comment in comments) {
    writeComment(comments[comment]);
  }
}

/** 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();
}

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 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) {
    
    if (properties.useG28) {
      // retract to safe plane
      retracted = true;
      writeBlock(gFormat.format(28), gAbsIncModal.format(91), "Z" + xyzFormat.format(0)); // retract
      writeBlock(gAbsIncModal.format(90));
      zOutput.reset();
    }
  }

writeln("");

if (hasParameter("operation-comment")) {
    var comment = getParameter("operation-comment");
    if (comment) {
      writeComment(comment);
    }
  }

if (insertToolCall) {
    forceWorkPlane();
    
    // onCommand(COMMAND_STOP_SPINDLE);
    // onCommand(COMMAND_COOLANT_OFF);
  
    if (!isFirstSection() && properties.optionalStop) {
      onCommand(COMMAND_OPTIONAL_STOP);
    }

if (tool.number > 256) {
      warning(localize("Tool number exceeds maximum value."));
    }
    
    var lengthOffset = tool.lengthOffset;
    if (lengthOffset > 256) {
      error(localize("Length offset out of range."));
      return;
    }

writeBlock(mFormat.format(998));
    if (properties.useM6) {
      writeBlock("T" + toolFormat.format(tool.number),
      gFormat.format(43),
      hFormat.format(lengthOffset),
      mFormat.format(6));
    } else {
      writeBlock("T" + toolFormat.format(tool.number), gFormat.format(43), hFormat.format(lengthOffset));
    }
    if (tool.comment) {
      writeComment(tool.comment);
    }
    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 (properties.preloadTool && properties.useM6) {
      var nextTool = getNextTool(tool.number);
      if (nextTool) {
        writeBlock("T" + toolFormat.format(nextTool.number));
      } else {
        // preload first tool
        var section = getSection(0);
        var firstToolNumber = section.getTool().number;
        if (tool.number != firstToolNumber) {
          writeBlock("T" + toolFormat.format(firstToolNumber));
        }
      }
    }
  }
  
  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."));
      return;
    }
    if (tool.spindleRPM > 99999) {
      warning(localize("Spindle speed exceeds maximum value."));
    }
    writeBlock(
      sOutput.format(tool.spindleRPM), mFormat.format(tool.clockwise ? 3 : 4)
    );
  }

// wcs
  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) {
      var p = workOffset; // 1->... // G59 P1 is the same as G54 and so on
      if (p > 254) {
        error(localize("Work offset out of range."));
      } else {
        if (workOffset != currentWorkOffset) {
          writeBlock(gFormat.format(59), "P" + p); // G59 P
          currentWorkOffset = workOffset;
        }
      }
    } 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

forceAny();
  gMotionModal.reset();

var initialPosition = getFramePosition(currentSection.getInitialPosition());
  if (!retracted) {
    if (getCurrentPosition().z < initialPosition.z) {
      writeBlock(gMotionModal.format(0), zOutput.format(initialPosition.z));
    }
  }

if (!insertToolCall && retracted) { // G43 already called above on tool change
    var lengthOffset = tool.lengthOffset;
    if (lengthOffset > 256) {
      error(localize("Length offset out of range."));
      return;
    }

gMotionModal.reset();
    writeBlock(gPlaneModal.format(17));
    
    if (!machineConfiguration.isHeadConfiguration()) {
      writeBlock(
        gAbsIncModal.format(90),
        gMotionModal.format(0), xOutput.format(initialPosition.x), yOutput.format(initialPosition.y)
      );
      writeBlock(gMotionModal.format(0), gFormat.format(43), zOutput.format(initialPosition.z), hFormat.format(lengthOffset));
    } else {
      writeBlock(
        gAbsIncModal.format(90),
        gMotionModal.format(0),
        gFormat.format(43), xOutput.format(initialPosition.x),
        yOutput.format(initialPosition.y),
        zOutput.format(initialPosition.z), hFormat.format(lengthOffset)
      );
    }
  } else {
    writeBlock(
      gAbsIncModal.format(90),
      gMotionModal.format(0),
      xOutput.format(initialPosition.x),
      yOutput.format(initialPosition.y)
    );
  }

// 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."));
    }
  }
}

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 : cycle.dwell; // in seconds

switch (cycleType) {
    case "drilling":
      writeBlock(
        gRetractModal.format(98), gAbsIncModal.format(90), gCycleModal.format(81),
        getCommonCycle(x, y, z, cycle.retract),
        feedOutput.format(F)
      );
      break;
    case "counter-boring":
      if (P > 0) {
        writeBlock(
          gRetractModal.format(98), gAbsIncModal.format(90), gCycleModal.format(82),
          getCommonCycle(x, y, z, cycle.retract),
          "P" + secFormat.format(P),
          feedOutput.format(F)
        );
      } else {
        writeBlock(
          gRetractModal.format(98), gAbsIncModal.format(90), gCycleModal.format(81),
          getCommonCycle(x, y, z, cycle.retract),
          feedOutput.format(F)
        );
      }
      break;
    case "chip-breaking":
      // cycle.accumulatedDepth is ignored
      if (P > 0) {
        expandCyclePoint(x, y, z);
      } else {
        writeBlock(
          gRetractModal.format(98), gAbsIncModal.format(90), gCycleModal.format(73),
          getCommonCycle(x, y, z, cycle.retract),
          "Q" + xyzFormat.format(cycle.incrementalDepth),
          feedOutput.format(F)
        );
      }
      break;
    case "deep-drilling":
      if (P > 0) {
        expandCyclePoint(x, y, z);
      } else {
        writeBlock(
          gRetractModal.format(98), gAbsIncModal.format(90), gCycleModal.format(83),
          getCommonCycle(x, y, z, cycle.retract),
          "Q" + xyzFormat.format(cycle.incrementalDepth),
          // conditional(P > 0, "P" + secFormat.format(P)),
          feedOutput.format(F)
        );
      }
      break;
    case "tapping":
      if (tool.type == TOOL_TAP_LEFT_HAND) {
        expandCyclePoint(x, y, z);
      } else {
        if (!F) {
          F = tool.getTappingFeedrate();
        }
        writeBlock(mFormat.format(29), sOutput.format(tool.spindleRPM));
        writeBlock(
          gRetractModal.format(98), gAbsIncModal.format(90), gCycleModal.format(84),
          getCommonCycle(x, y, z, cycle.retract),
          feedOutput.format(F)
        );
      }
      break;
    case "left-tapping":
      expandCyclePoint(x, y, z);
      break;
    case "right-tapping":
      if (!F) {
        F = tool.getTappingFeedrate();
      }
      writeBlock(mFormat.format(29), sOutput.format(tool.spindleRPM));
      writeBlock(
        gRetractModal.format(98), gAbsIncModal.format(90), gCycleModal.format(84),
        getCommonCycle(x, y, z, cycle.retract),
        feedOutput.format(F)
      );
      break;
    case "fine-boring":
      writeBlock(
        gRetractModal.format(98), gAbsIncModal.format(90), gCycleModal.format(76),
        getCommonCycle(x, y, z, cycle.retract),
        "P" + secFormat.format(P),
        "Q" + xyzFormat.format(cycle.shift),
        feedOutput.format(F)
      );
      break;
    case "back-boring":
      var dx = (gPlaneModal.getCurrent() == 19) ? cycle.backBoreDistance : 0;
      var dy = (gPlaneModal.getCurrent() == 18) ? cycle.backBoreDistance : 0;
      var dz = (gPlaneModal.getCurrent() == 17) ? cycle.backBoreDistance : 0;
      writeBlock(
        gRetractModal.format(98), gAbsIncModal.format(90), gCycleModal.format(87),
        getCommonCycle(x - dx, y - dy, z - dz, cycle.bottom),
        "I" + xyzFormat.format(cycle.shift),
        "J" + xyzFormat.format(0),
        "P" + secFormat.format(P),
        feedOutput.format(F)
      );
      break;
    case "reaming":
      if (P > 0) {
        writeBlock(
          gRetractModal.format(98), gAbsIncModal.format(90), gCycleModal.format(89),
          getCommonCycle(x, y, z, cycle.retract),
          "P" + secFormat.format(P),
          feedOutput.format(F)
        );
      } else {
        writeBlock(
          gRetractModal.format(98), gAbsIncModal.format(90), gCycleModal.format(85),
          getCommonCycle(x, y, z, cycle.retract),
          feedOutput.format(F)
        );
      }
      break;
    case "stop-boring":
      writeBlock(
        gRetractModal.format(98), gAbsIncModal.format(90), gCycleModal.format(86),
        getCommonCycle(x, y, z, cycle.retract),
        "P" + secFormat.format(P),
        feedOutput.format(F)
      );
      break;
    case "manual-boring":
      writeBlock(
        gRetractModal.format(98), gAbsIncModal.format(90), gCycleModal.format(88),
        getCommonCycle(x, y, z, cycle.retract),
        "P" + secFormat.format(P),
        feedOutput.format(F)
      );
      break;
    case "boring":
      if (P > 0) {
        writeBlock(
          gRetractModal.format(98), gAbsIncModal.format(90), gCycleModal.format(89),
          getCommonCycle(x, y, z, cycle.retract),
          "P" + secFormat.format(P),
          feedOutput.format(F)
        );
      } else {
        writeBlock(
          gRetractModal.format(98), gAbsIncModal.format(90), gCycleModal.format(85),
          getCommonCycle(x, y, z, cycle.retract),
          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 onCircular(clockwise, cx, cy, cz, x, y, z, feed) {
  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, // flood
  COMMAND_COOLANT_OFF:9
};

function onSectionEnd() {
  writeBlock(gPlaneModal.format(17));

if (((getCurrentSectionId() + 1) >= getNumberOfSections()) ||
      (tool.number != getNextSection().getTool().number)) {
    onCommand(COMMAND_BREAK_CONTROL);
  }

forceAny();
}

function onClose() {
  writeln("");

onCommand(COMMAND_COOLANT_OFF);

if (properties.useG28) {
    writeBlock(gFormat.format(28), gAbsIncModal.format(91), "Z" + xyzFormat.format(0)); // retract
    zOutput.reset();
  }

setWorkPlane(new Vector(0, 0, 0)); // reset working plane

if (!machineConfiguration.hasHomePositionX() && !machineConfiguration.hasHomePositionY()) {
    if (properties.useG28) {
      writeBlock(gFormat.format(28), gAbsIncModal.format(91), "X" + xyzFormat.format(0), "Y" + xyzFormat.format(0)); // return to home
    }
  } else {
    var homeX;
    if (machineConfiguration.hasHomePositionX()) {
      homeX = "X" + xyzFormat.format(machineConfiguration.getHomePositionX());
    }
    var homeY;
    if (machineConfiguration.hasHomePositionY()) {
      homeY = "Y" + xyzFormat.format(machineConfiguration.getHomePositionY());
    }
    writeBlock(gAbsIncModal.format(90), gFormat.format(53), gMotionModal.format(0), homeX, homeY);
  }

onImpliedCommand(COMMAND_END);
  onImpliedCommand(COMMAND_STOP_SPINDLE);
  writeBlock(mFormat.format(30)); // stop program, spindle stop, coolant off
}

Bearbeitung

Datei öffnen

Tormach Path Pilot post processor configuration.

$Revision: 37254 $
  $Date: 2014-05-26 11:17:00 +0200 (ma, 26 maj 2014) $
  
  FORKID {AE2102AB-B86A-4aa7-8E9B-F0B6935D4E9F}
*/
//setWriteStack(true);
description = "Generic Tormach Path Pilot";
vendor = "Autodesk, Inc.";
vendorUrl = "http://www.autodesk.com";
legal = "Copyright (C) 2012-2014 by Autodesk, Inc.";
certificationLevel = 2;
minimumRevision = 24000;

extension = "TAP";
setCodePage("ascii");

tolerance = spatial(0.002, MM);

var permittedCommentChars = " ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.,=_-";

var mapCoolantTable = new Table(
  [9, 8, 7],
  {initial:COOLANT_OFF, force:true},
  "Invalid coolant mode"
);

var WARNING_WORK_OFFSET = 0;

// collected state
var sequenceNumber;
var currentWorkOffset;
var previousCoolantMode;

/**
  Output a comment.
*/
function writeComment(text) {
  writeln("(" + filterText(String(text).toUpperCase(), permittedCommentChars) + ")");
}

function onOpen() {

if (false) {
    var aAxis = createAxis({coordinate:0, table:true, axis:[-1, 0, 0], cyclic:true, preference:1});
    machineConfiguration = new MachineConfiguration(aAxis);

setMachineConfiguration(machineConfiguration);
    optimizeMachineAngles2(1); // map tip mode
  }

sequenceNumber = properties.sequenceNumberStart;

writeln("%");
  writeln("(*********************************************************)");
  writeln("(* Tormach Path Pilot Post Processsor Version 0.4 Debug  *)");
  writeln("(*********************************************************)");
  if (programName) {
    writeComment(programName);
  }
  if (programComment) {
    writeComment(programComment);
  }

// dump machine configuration
  var vendor = machineConfiguration.getVendor();
  var model = machineConfiguration.getModel();
  var description = machineConfiguration.getDescription();

switch (unit) {
  case IN:
    writeBlock(gUnitModal.format(20), "(Inch)" );
    break;
  case MM:
    writeBlock(gUnitModal.format(21), "(Metric)");
    break;
  }
}

function onComment(message) {
  var comments = String(message).split(";");
  for (comment in comments) {
    writeComment(comments[comment]);
  }
}

/** 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();
}

var currentWorkPlaneABC = undefined;

function forceWorkPlane() {
  currentWorkPlaneABC = undefined;
}

function setWorkPlane(abc) {
  if (!machineConfiguration.isMultiAxisConfiguration()) {
    return; // ignore
  }

onCommand(COMMAND_UNLOCK_MULTI_AXIS);

// NOTE: add retract here

currentWorkPlaneABC = abc;
}

var closestABC = false; // choose closest machine angles
var currentMachineABC;

function getWorkPlaneMachineABC(workPlane) {
  var W = workPlane; // map to global frame

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) {
    
    if (properties.useG28) {
      // retract to safe plane
      retracted = true;
      //writeBlock(gFormat.format(28), gAbsIncModal.format(91), "Z" + xyzFormat.format(0)); // retract
	  writeBlock(gFormat.format(30)); // use G30 instead of G28 above
      writeBlock(gAbsIncModal.format(90));
      zOutput.reset();
    }
  }

writeln("");

if (hasParameter("operation-comment")) {
    var comment = getParameter("operation-comment");
    if (comment) {
      writeComment(comment);
    }
  }

if (tool.number > 256) {
      warning(localize("Tool number exceeds maximum value."));
    }
	
    var lengthOffset = tool.lengthOffset;
    if (lengthOffset > 256) {
      error(localize("Length offset out of range."));
      return;
    }

//   writeBlock(mFormat.format(998));
    writeBlock(gFormat.format(30));
    if (properties.useM6) {
      writeBlock("T" + toolFormat.format(tool.number),
	  gFormat.format(43),
	  hFormat.format(lengthOffset),
	  mFormat.format(6));
    } else {
      writeBlock("T" + toolFormat.format(tool.number), gFormat.format(43), hFormat.format(lengthOffset));
    }
    if (tool.comment) {
      writeComment(tool.comment);
    }
    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 (properties.preloadTool && properties.useM6) {
      var nextTool = getNextTool(tool.number);
      if (nextTool) {
        writeBlock("T" + toolFormat.format(nextTool.number));
      } else {
        // preload first tool
        var section = getSection(0);
        var firstToolNumber = section.getTool().number;
        if (tool.number != firstToolNumber) {
          writeBlock("T" + toolFormat.format(firstToolNumber));
        }
      }
    }
  }
  
    // set coolant after we have positioned at Z
	    var c = mapCoolantTable.lookup(tool.coolant);
  /* {
    var c = mapCoolantTable.lookup(tool.coolant);
   if (c) {
      writeBlock(mFormat.format(c));
    } else {
      warning(localize("Coolant not supported."));
    }
  } */
  
 /* if (insertToolCall ||
      isFirstSection() ||
      (rpmFormat.areDifferent(tool.spindleRPM, sOutput.getCurrent())) ||
      (tool.clockwise != getPreviousSection().getTool().clockwise) ||  previousCoolantMode != c) { */
    if (tool.spindleRPM < 1) {
      error(localize("Spindle speed out of range."));
      return;
    }
    if (tool.spindleRPM > 99999) {
      warning(localize("Spindle speed exceeds maximum value."));
    }
    writeBlock(
      sOutput.format(tool.spindleRPM), mFormat.format(tool.clockwise ? 3 : 4),
	  conditional(c, mFormat.format(c)) 
    );
	 previousCoolantMode = c;
 // }

forceXYZ();

if (machineConfiguration.isMultiAxisConfiguration()) { // use 5-axis indexing for multi-axis mode
    // set working plane after datum shift

forceAny();
  gMotionModal.reset();

// 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."));
    }
  } */
}

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 : cycle.dwell; // in seconds

switch (cycleType) {
    case "drilling":
      writeBlock(
        gRetractModal.format(98), gAbsIncModal.format(90), gCycleModal.format(81),
        getCommonCycle(x, y, z, cycle.retract),
        feedOutput.format(F)
      );
      break;
    case "counter-boring":
      if (P > 0) {
        writeBlock(
          gRetractModal.format(98), gAbsIncModal.format(90), gCycleModal.format(82),
          getCommonCycle(x, y, z, cycle.retract),
          "P" + secFormat.format(P),
          feedOutput.format(F)
        );
      } else {
        writeBlock(
          gRetractModal.format(98), gAbsIncModal.format(90), gCycleModal.format(81),
          getCommonCycle(x, y, z, cycle.retract),
          feedOutput.format(F)
        );
      }
      break;
    case "chip-breaking":
      // cycle.accumulatedDepth is ignored
      if (P > 0) {
        expandCyclePoint(x, y, z);
      } else {
        writeBlock(
          gRetractModal.format(98), gAbsIncModal.format(90), gCycleModal.format(73),
          getCommonCycle(x, y, z, cycle.retract),
          "Q" + xyzFormat.format(cycle.incrementalDepth),
          feedOutput.format(F)
        );
      }
      break;
    case "deep-drilling":
      if (P > 0) {
        expandCyclePoint(x, y, z);
      } else {
        writeBlock(
          gRetractModal.format(98), gAbsIncModal.format(90), gCycleModal.format(83),
          getCommonCycle(x, y, z, cycle.retract),
          "Q" + xyzFormat.format(cycle.incrementalDepth),
          // conditional(P > 0, "P" + secFormat.format(P)),
          feedOutput.format(F)
        );
      }
      break;
    case "tapping":
      if (tool.type == TOOL_TAP_LEFT_HAND) {
        expandCyclePoint(x, y, z);
      } else {
        if (!F) {
          F = tool.getTappingFeedrate();
        }
        writeBlock(sOutput.format(tool.spindleRPM));
        writeBlock(
          gRetractModal.format(98), gAbsIncModal.format(90), gCycleModal.format(84),
          getCommonCycle(x, y, z, cycle.retract),
		   "P" + secFormat.format(P),
          feedOutput.format(F)
        );
      }
      break;
    case "left-tapping":
      expandCyclePoint(x, y, z);
      break;
    case "right-tapping":
      if (!F) {
        F = tool.getTappingFeedrate();
      }
      writeBlock(mFormat.format(29), sOutput.format(tool.spindleRPM));
      writeBlock(
        gRetractModal.format(98), gAbsIncModal.format(90), gCycleModal.format(84),
        getCommonCycle(x, y, z, cycle.retract),
		 "P" + secFormat.format(P),
        feedOutput.format(F)
      );
      break;
    case "fine-boring":
      writeBlock(
        gRetractModal.format(98), gAbsIncModal.format(90), gCycleModal.format(76),
        getCommonCycle(x, y, z, cycle.retract),
        "P" + secFormat.format(P),
        "Q" + xyzFormat.format(cycle.shift),
        feedOutput.format(F)
      );
      break;
    case "back-boring":
      var dx = (gPlaneModal.getCurrent() == 19) ? cycle.backBoreDistance : 0;
      var dy = (gPlaneModal.getCurrent() == 18) ? cycle.backBoreDistance : 0;
      var dz = (gPlaneModal.getCurrent() == 17) ? cycle.backBoreDistance : 0;
      writeBlock(
        gRetractModal.format(98), gAbsIncModal.format(90), gCycleModal.format(87),
        getCommonCycle(x - dx, y - dy, z - dz, cycle.bottom),
        "I" + xyzFormat.format(cycle.shift),
        "J" + xyzFormat.format(0),
        "P" + secFormat.format(P),
        feedOutput.format(F)
      );
      break;
    case "reaming":
      if (P > 0) {
        writeBlock(
          gRetractModal.format(98), gAbsIncModal.format(90), gCycleModal.format(89),
          getCommonCycle(x, y, z, cycle.retract),
          "P" + secFormat.format(P),
          feedOutput.format(F)
        );
      } else {
        writeBlock(
          gRetractModal.format(98), gAbsIncModal.format(90), gCycleModal.format(85),
          getCommonCycle(x, y, z, cycle.retract),
          feedOutput.format(F)
        );
      }
      break;
    case "stop-boring":
      writeBlock(
        gRetractModal.format(98), gAbsIncModal.format(90), gCycleModal.format(86),
        getCommonCycle(x, y, z, cycle.retract),
        "P" + secFormat.format(P),
        feedOutput.format(F)
      );
      break;
    case "manual-boring":
      writeBlock(
        gRetractModal.format(98), gAbsIncModal.format(90), gCycleModal.format(88),
        getCommonCycle(x, y, z, cycle.retract),
        "P" + secFormat.format(P),
        feedOutput.format(F)
      );
      break;
    case "boring":
      if (P > 0) {
        writeBlock(
          gRetractModal.format(98), gAbsIncModal.format(90), gCycleModal.format(89),
          getCommonCycle(x, y, z, cycle.retract),
          "P" + secFormat.format(P),
          feedOutput.format(F)
        );
      } else {
        writeBlock(
          gRetractModal.format(98), gAbsIncModal.format(90), gCycleModal.format(85),
          getCommonCycle(x, y, z, cycle.retract),
          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 onRapid5D(_x, _y, _z, _a, _b, _c) {
  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();
}

var start = getCurrentPosition();

function onSectionEnd() {
  writeBlock(gPlaneModal.format(17));

if (((getCurrentSectionId() + 1) >= getNumberOfSections()) ||
      (tool.number != getNextSection().getTool().number)) {
    onCommand(COMMAND_BREAK_CONTROL);
  }

forceAny();
  
   var initialPosition = getFramePosition(currentSection.getInitialPosition());
    writeBlock( 
	 // zOutput.format(initialPosition.z), 
	  mFormat.format(5), 
	  mFormat.format(9)
	);
}

function onClose() {
  writeln("");

//onCommand(COMMAND_COOLANT_OFF);

/*  if (properties.useG28) {
    writeBlock(gFormat.format(28), gAbsIncModal.format(91), "Z" + xyzFormat.format(0)); // retract
    zOutput.reset();
  }
  */
  zOutput.reset();
  setWorkPlane(new Vector(0, 0, 0)); // reset working plane

/* if (properties.useG28 && !machineConfiguration.hasHomePositionX() && !machineConfiguration.hasHomePositionY()) {
    writeBlock(gFormat.format(28), gAbsIncModal.format(91), "X" + xyzFormat.format(0), "Y" + xyzFormat.format(0)); // return to home
  } else {
    var homeX;
    if (machineConfiguration.hasHomePositionX()) {
      homeX = "X" + xyzFormat.format(machineConfiguration.getHomePositionX());
    }
    var homeY;
    if (machineConfiguration.hasHomePositionY()) {
      homeY = "Y" + xyzFormat.format(machineConfiguration.getHomePositionY());
    }
    writeBlock(gAbsIncModal.format(90), gFormat.format(53), gMotionModal.format(0), homeX, homeY);
  }
*/
  onImpliedCommand(COMMAND_END);
  onImpliedCommand(COMMAND_STOP_SPINDLE);
  writeBlock(gFormat.format(30));
  writeBlock(mFormat.format(30)); // stop program, spindle stop, coolant off
  writeln("%");
}