텍스트 비교

두 텍스트 파일의 차이점을 찾아보세요

실시간 편집

변경 없는 행 숨기기

줄바꿈 비활성화

레이아웃

비교 단위

구문 강조

Diffchecker Desktop 가장 안전하게 Diffchecker를 사용하는 방법. 데스크톱 앱을 사용하면 비교 데이터가 외부로 전송되지 않습니다!데스크톱 앱 받기

Untitled diff

생성일 11년 전비교 결과 만료 없음

52 삭제

행
총
삭제

글자
총
삭제

이 기능을 계속 사용하려면 업그레이드해 주세요 Diffchecker Pro 요금제 보기

793 행

48 추가

행
총
추가

글자
총
추가

이 기능을 계속 사용하려면 업그레이드해 주세요 Diffchecker Pro 요금제 보기

776 행

/**

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

저장된 비교 결과

원본

파일 열기

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
}

수정본

파일 열기

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