topic Re: Prototrak smx post processor issue please fix in HSM Post Processor Forum

Prototrak smx post processor issue please fix

gearheadcrawler — Mon, 17 Feb 2020 22:19:59 GMT

The first move the machine makes is always a rapid to Z0. The prototrak conversational post processor always generates the code wrong. The rapid in x and y are on one line and the z on another causing this problem. It should post all x,y and z rapid moves on the same line for this controller please fix the problem.

Re: Prototrak smx post processor issue please fix

andrea.amilo — Fri, 21 Feb 2020 08:13:53 GMT

Hi @gearheadcrawler ,

I think you could work in this way to modify first move of your Prototrak postprocessor.

This is in onSection function at line 550 :

    if (!machineConfiguration.isHeadConfiguration()) {
      writeBlock(
        gAbsIncModal.format(90),
        gMotionModal.format(0), xOutput.format(initialPosition.x), yOutput.format(initialPosition.y), zOutput.format(initialPosition.z));
    } else {
      writeBlock(
        gAbsIncModal.format(90),
        gMotionModal.format(0),
        xOutput.format(initialPosition.x),
        yOutput.format(initialPosition.y),
        zOutput.format(initialPosition.z)
      );

Now you will have first rapid move XYZ on the same line.

Please test it carefully.

Re: Prototrak smx post processor issue please fix

gearheadcrawler — Mon, 24 Feb 2020 14:32:51 GMT

are you saying delete line 550 and replace with this?? im sorry ive never had to make post processor adjustments so this is new to me??

Re: Prototrak smx post processor issue please fix

andrea.amilo — Mon, 24 Feb 2020 14:58:08 GMT

Hi @gearheadcrawler ,

you have to replace lines 550, 551 and 552 with the one in red.

Please test it carefully and let me know.

Re: Prototrak smx post processor issue please fix

gearheadcrawler — Mon, 24 Feb 2020 16:04:51 GMT

this may be a dumb question but i have to be sure are you saying the post in red needs to go on all three lines or just delete 550 551 552 and then only paste the red code one time???

Re: Prototrak smx post processor issue please fix

andrea.amilo — Mon, 24 Feb 2020 16:44:37 GMT

Hi @gearheadcrawler ,

I confirm you the line in red has to replace three original lines 500, 551, 552.

Please take a look at this picture showing you a comparison between original and edited postprocessor :

Re: Prototrak smx post processor issue please fix

gearheadcrawler — Tue, 10 Mar 2020 18:08:35 GMT

Ok so that seemed to fix most problems all milling cycles work great although on a drilling cycle it still wants rapid across part at feed hieght??

Re: Prototrak smx post processor issue please fix

andrea.amilo — Tue, 10 Mar 2020 20:23:05 GMT

Hi @gearheadcrawler ,

I think that suggested modification works in every condition, both milling and drilling cycles.

Have you tested ? Have you got an example of "a drilling cycle it still wants rapid across part" ?

Re: Prototrak smx post processor issue please fix

gearheadcrawler — Wed, 11 Mar 2020 17:25:58 GMT

this is what I am currently using milling cycles go to retract but the drilling cycles move at feed height.

/**
Copyright (C) 2012-2018 by Autodesk, Inc.
All rights reserved.

ProtoTRAK GCD post processor configuration.

$Revision: 42473 905303e8374380273c82d214b32b7e80091ba92e $
$Date: 2019-09-04 07:46:02 $

FORKID {065403A3-A589-43ef-B345-90B5274EE274}
*/

description = "ProtoTRAK GCD";
vendor = "Southwestern Industries";
vendorUrl = "http://www.southwesternindustries.com";
legal = "Copyright (C) 2012-2018 by Autodesk, Inc.";
certificationLevel = 2;
minimumRevision = 40783;

longDescription = "Generic milling post for ProtoTRAK GCD format.";

extension = "gcd"; // use "cam" for some controls
programNameIsInteger = true;
setCodePage("ascii");

capabilities = CAPABILITY_MILLING;
tolerance = spatial(0.002, MM);

minimumChordLength = spatial(0.25, MM);
minimumCircularRadius = spatial(0.01, MM);
maximumCircularRadius = spatial(1000, MM);
minimumCircularSweep = toRad(0.01);
maximumCircularSweep = toRad(90);
allowHelicalMoves = true;
allowedCircularPlanes = undefined; // allow any circular motion

// user-defined properties
properties = {
writeMachine: true, // write machine
writeTools: true, // writes the tools
preloadTool: true, // preloads next tool on tool change if any
showSequenceNumbers: true, // show sequence numbers
sequenceNumberStart: 10, // first sequence number
sequenceNumberIncrement: 5, // increment for sequence numbers
optionalStop: true, // optional stop
separateWordsWithSpace: true, // specifies that the words should be separated with a white space
useRigidTapping: "yes", // output rigid tapping block
circularOutsideXY: false // circular in YZ and ZX planes
};

// user-defined property definitions
propertyDefinitions = {
writeMachine: {title:"Write machine", description:"Output the machine settings in the header of the code.", group:0, type:"boolean"},
writeTools: {title:"Write tool list", description:"Output a tool list in the header of the code.", group:0, type:"boolean"},
preloadTool: {title:"Preload tool", description:"Preloads the next tool at a tool change (if any).", group:1, type:"boolean"},
showSequenceNumbers: {title:"Use sequence numbers", description:"Use sequence numbers for each block of outputted code.", group:1, type:"boolean"},
sequenceNumberStart: {title:"Start sequence number", description:"The number at which to start the sequence numbers.", group:1, type:"integer"},
sequenceNumberIncrement: {title:"Sequence number increment", description:"The amount by which the sequence number is incremented by in each block.", group:1, type:"integer"},
optionalStop: {title:"Optional stop", description:"Outputs optional stop code during when necessary in the code.", type:"boolean"},
separateWordsWithSpace: {title:"Separate words with space", description:"Adds spaces between words if 'yes' is selected.", type:"boolean"},
useRigidTapping: {
title: "Use rigid tapping",
description: "Select 'Yes' to enable, 'No' to disable, or 'Without spindle direction' to enable rigid tapping without outputting the spindle direction block.",
type: "enum",
values:[
{title:"Yes", id:"yes"},
{title:"No", id:"no"},
{title:"Without spindle direction", id:"without"}
]
},
circularOutsideXY: {title:"Allow circular outside of XY-plane", description:"Allow circular interpolation to be output in the YZ and ZX planes.", group:0, type:"boolean"}
};

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

var singleLineCoolant = false; // specifies to output multiple coolant codes in one line rather than in separate lines
// samples:
// {id:aaCOOLANT_THROUGH_TOOL, on: 88, off: 89}
// {id: COOLANT_THROUGH_TOOL, on: [8, 88], off: [9, 89]}
var coolants = [
{id: COOLANT_FLOOD, on: 8},
{id: COOLANT_MIST, on: 7},
{id: COOLANT_THROUGH_TOOL},
{id: COOLANT_AIR},
{id: COOLANT_AIR_THROUGH_TOOL},
{id: COOLANT_SUCTION},
{id: COOLANT_FLOOD_MIST},
{id: COOLANT_FLOOD_THROUGH_TOOL},
{id: COOLANT_OFF, off: 9}
];

// 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;
var retracted = false; // specifies that the tool has been retracted to the safe plane

/**
Writes the specified block.
*/
function writeBlock() {
if (!formatWords(arguments)) {
return;
}
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 (!properties.circularOutsideXY) {
allowedCircularPlanes = (1 << PLANE_XY); // allow XY-plane circular motion
}

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;

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

if ((getNumberOfSections() > 0) && (getSection(0).workOffset == 0)) {
for (var i = 0; i < getNumberOfSections(); ++i) {
if (getSection(i).workOffset > 0) {
error(localize("Using multiple work offsets is not possible if the initial work offset is 0."));
return;
}
}
}

// absolute coordinates and feed per min
writeBlock(gAbsIncModal.format(90), gFeedModeModal.format(94), gPlaneModal.format(17));

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

function onComment(message) {
writeComment(message);
}

/** Force output of X, Y, and Z. */
function forceXYZ() {
xOutput.reset();
yOutput.reset();
zOutput.reset();
}

/** Force output of A, B, and C. */
function forceABC() {
aOutput.reset();
bOutput.reset();
cOutput.reset();
}

/** Force output of X, Y, Z, A, B, C, and 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 = false;
if (tcp) {
setRotation(W); // TCP mode
} else {
var O = machineConfiguration.getOrientation(abc);
var R = machineConfiguration.getRemainingOrientation(abc, W);
setRotation(R);
}

return abc;
}

function isProbeOperation() {
return (hasParameter("operation-strategy") &&
getParameter("operation-strategy") == "probe");
}

function onSection() {
var insertToolCall = isFirstSection() ||
currentSection.getForceToolChange && currentSection.getForceToolChange() ||
(tool.number != getPreviousSection().getTool().number);

retracted = false; // specifies that the tool has been retracted to the safe plane
var newWorkOffset = isFirstSection() ||
(getPreviousSection().workOffset != currentSection.workOffset); // work offset changes
var newWorkPlane = isFirstSection() ||
!isSameDirection(getPreviousSection().getGlobalFinalToolAxis(), currentSection.getGlobalInitialToolAxis()) ||
(currentSection.isOptimizedForMachine() && getPreviousSection().isOptimizedForMachine() &&
Vector.diff(getPreviousSection().getFinalToolAxisABC(), currentSection.getInitialToolAxisABC()).length > 1e-4) ||
(!machineConfiguration.isMultiAxisConfiguration() && currentSection.isMultiAxis()) ||
(!getPreviousSection().isMultiAxis() && currentSection.isMultiAxis() ||
getPreviousSection().isMultiAxis() && !currentSection.isMultiAxis()); // force newWorkPlane between indexing and simultaneous operations

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

if (insertToolCall) {
forceWorkPlane();

setCoolant(COOLANT_OFF);

if (!isFirstSection() && properties.optionalStop) {
onCommand(COMMAND_OPTIONAL_STOP);
}

if (tool.number > 99) {
warning(localize("Tool number exceeds maximum value."));
}

writeBlock("T" + toolFormat.format(tool.number), mFormat.format(6));
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) {
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(spindleSpeed, sOutput.getCurrent())) ||
(tool.clockwise != getPreviousSection().getTool().clockwise)) {
if (spindleSpeed < 1) {
error(localize("Spindle speed out of range."));
return;
}
if (spindleSpeed > 99999) {
warning(localize("Spindle speed exceeds maximum value."));
}
var tapping = hasParameter("operation:cycleType") &&
((getParameter("operation:cycleType") == "tapping") ||
(getParameter("operation:cycleType") == "right-tapping") ||
(getParameter("operation:cycleType") == "left-tapping") ||
(getParameter("operation:cycleType") == "tapping-with-chip-breaking"));
if (!tapping || (tapping && !(properties.useRigidTapping == "without"))) {
writeBlock(
sOutput.format(spindleSpeed), mFormat.format(tool.clockwise ? 3 : 4)
);
}
}

// wcs
if (insertToolCall) { // force work offset when changing tool
currentWorkOffset = undefined;
}
var workOffset = currentSection.workOffset;
if (workOffset == 0) {
warningOnce(localize("Work offset has not been specified. Using G54 as WCS."), WARNING_WORK_OFFSET);
workOffset = 1;
}
if (workOffset > 0) {
if (workOffset > 6) {
error(localize("Work offset out of range."));
return;
} 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

// set coolant after we have positioned at Z
setCoolant(tool.coolant);

forceAny();
gMotionModal.reset();

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

if (insertToolCall || retracted) {
var lengthOffset = tool.lengthOffset;
if (lengthOffset > 99) {
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), zOutput.format(initialPosition.z)
);
writeBlock(gMotionModal.format(0), zOutput.format(initialPosition.z));
} else {
writeBlock(
gAbsIncModal.format(90),
gMotionModal.format(0),
xOutput.format(initialPosition.x),
yOutput.format(initialPosition.y),
zOutput.format(initialPosition.z)
);
}

gMotionModal.reset();
} else {
writeBlock(
gAbsIncModal.format(90),
gMotionModal.format(0),
xOutput.format(initialPosition.x),
yOutput.format(initialPosition.y)
);
}
}

function onDwell(seconds) {
if (seconds > 99999.999) {
warning(localize("Dwelling time is out of range."));
}
milliseconds = clamp(1, seconds * 1000, 99999999);
writeBlock(gFeedModeModal.format(94), gFormat.format(4), "P" + milliFormat.format(milliseconds));
}

function onSpindleSpeed(spindleSpeed) {
writeBlock(sOutput.format(spindleSpeed));
}

function onCycle() {
writeBlock(gPlaneModal.format(17));
}

function getCommonCycle(x, y, z, r) {
forceXYZ(); // force xyz on first drill hole of any cycle
return [xOutput.format(x), yOutput.format(y),
zOutput.format(z),
"R" + xyzFormat.format(r)];
}

function onCyclePoint(x, y, z) {
if (!isSameDirection(getRotation().forward, new Vector(0, 0, 1))) {
expandCyclePoint(x, y, z);
return;
}
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 : clamp(1, cycle.dwell * 1000, 99999999); // in milliseconds

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" + milliFormat.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":
expandCyclePoint(x, y, z);
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" + milliFormat.format(P)),
feedOutput.format(F)
);
}
break;
case "tapping":
F = tool.getThreadPitch() * rpmFormat.getResultingValue(spindleSpeed);
if (properties.useRigidTapping != "no") {
writeBlock(mFormat.format(29), sOutput.format(spindleSpeed));
}
writeBlock(
gRetractModal.format(98), gAbsIncModal.format(90), gCycleModal.format((tool.type == TOOL_TAP_LEFT_HAND) ? 74 : 84),
getCommonCycle(x, y, z, cycle.retract),
"P" + milliFormat.format(P),
feedOutput.format(F)
);
break;
case "left-tapping":
F = tool.getThreadPitch() * rpmFormat.getResultingValue(spindleSpeed);
if (properties.useRigidTapping != "no") {
writeBlock(mFormat.format(29), sOutput.format(spindleSpeed));
}
writeBlock(
gRetractModal.format(98), gAbsIncModal.format(90), gCycleModal.format(74),
getCommonCycle(x, y, z, cycle.retract),
"P" + milliFormat.format(P),
feedOutput.format(F)
);
break;
case "right-tapping":
F = tool.getThreadPitch() * rpmFormat.getResultingValue(spindleSpeed);
if (properties.useRigidTapping != "no") {
writeBlock(mFormat.format(29), sOutput.format(spindleSpeed));
}
writeBlock(
gRetractModal.format(98), gAbsIncModal.format(90), gCycleModal.format(84),
getCommonCycle(x, y, z, cycle.retract),
"P" + milliFormat.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" + milliFormat.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 "boring":
if (P > 0) {
writeBlock(
gRetractModal.format(98), gAbsIncModal.format(90), gCycleModal.format(89),
getCommonCycle(x, y, z, cycle.retract),
"P" + milliFormat.format(P), // not optional
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() {
if (hasParameter("operation:compensationType") && (getParameter("operation:compensationType") == "control") &&
(radiusCompensation != RADIUS_COMPENSATION_OFF)) {
error(localize("Radius compensation 'In control' is not supported. Use 'Wear' instead."));
}
pendingRadiusCompensation = radiusCompensation;
}

/** Adjust final point to lie exactly on circle. */
function CircularData(_plane, _center, _end) {
// use Output variables, since last point could have been adjusted if previous move was circular
var start = new Vector(xOutput.getCurrent(), yOutput.getCurrent(), zOutput.getCurrent());
var saveStart = new Vector(start.x, start.y, start.z);
var center = new Vector(
xyzFormat.getResultingValue(_center.x),
xyzFormat.getResultingValue(_center.y),
xyzFormat.getResultingValue(_center.z)
);
var end = new Vector(_end.x, _end.y, _end.z);
switch (_plane) {
case PLANE_XY:
start.setZ(center.z);
end.setZ(center.z);
break;
case PLANE_ZX:
start.setY(center.y);
end.setY(center.y);
break;
case PLANE_YZ:
start.setX(center.x);
end.setX(center.x);
break;
default:
this.center = new Vector(_center.x, _center.y, _center.z);
this.start = new Vector(start.x, start.y, start.z);
this.end = new Vector(_end.x, _end.y, _end.z);
this.offset = Vector.diff(center, start);
this.radius = this.offset.length;
break;
}
this.start = new Vector(
xyzFormat.getResultingValue(start.x),
xyzFormat.getResultingValue(start.y),
xyzFormat.getResultingValue(start.z)
);
var temp = Vector.diff(center, start);
this.offset = new Vector(
xyzFormat.getResultingValue(temp.x),
xyzFormat.getResultingValue(temp.y),
xyzFormat.getResultingValue(temp.z)
);
this.center = Vector.sum(this.start, this.offset);
this.radius = this.offset.length;

temp = Vector.diff(end, center).normalized;
this.end = new Vector(
xyzFormat.getResultingValue(this.center.x + temp.x * this.radius),
xyzFormat.getResultingValue(this.center.y + temp.y * this.radius),
xyzFormat.getResultingValue(this.center.z + temp.z * this.radius)
);

switch (_plane) {
case PLANE_XY:
this.start.setZ(saveStart.z);
this.end.setZ(_end.z);
this.offset.setZ(0);
break;
case PLANE_ZX:
this.start.setY(saveStart.y);
this.end.setY(_end.y);
this.offset.setY(0);
break;
case PLANE_YZ:
this.start.setX(saveStart.x);
this.end.setX(_end.x);
this.offset.setX(0);
break;
}
}

if (pendingRadiusCompensation >= 0) {
error(localize("Radius compensation cannot be activated/deactivated for a circular move."));
return;
}

var circle = new CircularData(getCircularPlane(), new Vector(cx, cy, cz), new Vector(x, y, z));

if (isFullCircle()) {
if (isHelical()) { // radius mode does not support full arcs
var t = tolerance;
if (hasParameter("operation:tolerance")) {
t = getParameter("operation:tolerance");
}
linearize(t);
return;
}
switch (getCircularPlane()) {
case PLANE_XY:
writeBlock(
gAbsIncModal.format(90), gPlaneModal.format(17), gMotionModal.format(clockwise ? 2 : 3),
iOutput.format(circle.offset.x, 0), jOutput.format(circle.offset.y, 0), feedOutput.format(feed)
);
break;
case PLANE_ZX:
writeBlock(
gAbsIncModal.format(90), gPlaneModal.format(18), gMotionModal.format(clockwise ? 2 : 3),
iOutput.format(circle.offset.x, 0), kOutput.format(circle.offset.z, 0), feedOutput.format(feed)
);
break;
case PLANE_YZ:
writeBlock(
gAbsIncModal.format(90), gPlaneModal.format(19), gMotionModal.format(clockwise ? 2 : 3),
jOutput.format(circle.offset.y, 0), kOutput.format(circle.offset.z, 0), feedOutput.format(feed)
);
break;
default:
var t = tolerance;
if (hasParameter("operation:tolerance")) {
t = getParameter("operation:tolerance");
}
linearize(t);
}
} else {
switch (getCircularPlane()) {
case PLANE_XY:
writeBlock(
gAbsIncModal.format(90), gPlaneModal.format(17), gMotionModal.format(clockwise ? 2 : 3),
xOutput.format(circle.end.x), yOutput.format(circle.end.y), zOutput.format(circle.end.z),
iOutput.format(circle.offset.x, 0), jOutput.format(circle.offset.y, 0), feedOutput.format(feed)
);
break;
case PLANE_ZX:
writeBlock(
gAbsIncModal.format(90), gPlaneModal.format(18), gMotionModal.format(clockwise ? 2 : 3),
xOutput.format(circle.end.x), yOutput.format(circle.end.y), zOutput.format(circle.end.z),
iOutput.format(circle.offset.x, 0), kOutput.format(circle.offset.z, 0), feedOutput.format(feed)
);
break;
case PLANE_YZ:
writeBlock(
gAbsIncModal.format(90), gPlaneModal.format(19), gMotionModal.format(clockwise ? 2 : 3),
xOutput.format(circle.end.x), yOutput.format(circle.end.y), zOutput.format(circle.end.z),
jOutput.format(circle.offset.y, 0), kOutput.format(circle.offset.z, 0), feedOutput.format(feed)
);
break;
default:
var t = tolerance;
if (hasParameter("operation:tolerance")) {
t = getParameter("operation:tolerance");
}
linearize(t);
}
}
}

var currentCoolantMode = COOLANT_OFF;
var coolantOff = undefined;

var m;
var coolantCodes = {};
for (var c in coolants) { // find required coolant codes into the coolants array
if (coolants[c].id == coolant) {
coolantCodes.on = coolants[c].on;
if (coolants[c].off != undefined) {
coolantCodes.off = coolants[c].off;
break;
} else {
for (var i in coolants) {
if (coolants[i].id == COOLANT_OFF) {
coolantCodes.off = coolants[i].off;
break;
}
}
}
}
}
if (coolant == COOLANT_OFF) {
m = !coolantOff ? coolantCodes.off : coolantOff; // use the default coolant off command when an 'off' value is not specified
} else {
coolantOff = coolantCodes.off;
m = coolantCodes.on;
}

if (!m) {
onUnsupportedCoolant(coolant);
m = 9;
} else {
if (Array.isArray(m)) {
for (var i in m) {
multipleCoolantBlocks.push(mFormat.format(m[i]));
}
} else {
multipleCoolantBlocks.push(mFormat.format(m));
}
currentCoolantMode = coolant;
return multipleCoolantBlocks; // return the single formatted coolant value
}
return undefined;
}

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_LOAD_TOOL:6
};

function onSectionEnd() {
writeBlock(gPlaneModal.format(17));
if (!isLastSection() && (getNextSection().getTool().coolant != tool.coolant)) {
setCoolant(COOLANT_OFF);
}
if (((getCurrentSectionId() + 1) >= getNumberOfSections()) ||
(tool.number != getNextSection().getTool().number)) {
onCommand(COMMAND_BREAK_CONTROL);
}

forceAny();
}

function onClose() {
setCoolant(COOLANT_OFF);

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

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

Re: Prototrak smx post processor issue please fix

andrea.amilo — Fri, 13 Mar 2020 10:13:16 GMT

Hi @gearheadcrawler ,

I am sorry but I am not able to find anything wrong in your postprocessor.

Maybe the drilling cycles move at feed height due to programming inside Fusion.

If so, please take a look at this picture related to drilling cycles clearance height :

Please let me know.