Community
Fusion Manufacture
Talk shop with the Fusion (formerly Fusion 360) Manufacture Community. Share tool strategies, tips, get advice and solve problems together with the best minds in the industry.
cancel
Showing results for 
Show  only  | Search instead for 
Did you mean: 

Post processor writing A axis 'back to front'

5 REPLIES 5
SOLVED
Reply
Message 1 of 6
chris
1376 Views, 5 Replies

Post processor writing A axis 'back to front'

Hi.

First time setup problem.

 

I'm using the generic Osai 5 axis head head post processor.  I've got most things working but the 'A' axis is being generated as the inverse of what I need.  When I need G01 A90  I get G01 A0.   When I need G01 A85  I get G01 A5.

 

This picture illustrates how my machine is set up.

Axis1.jpg

 

My part is machining OK on simulation as per this screen shot

part-1.jpg

As seen in the picture, the tool orientation is in the vertical position working up down in the z plane which is correct.  The gcode generated has the x y and z movements correct, but its writing what you see here as A0.   I need this to be A90.

 

Post Proc below.

Ive tried  changing the line:

var aAxis = createAxis({coordinate:0, table:false, axis:[1, 0, 0], range:[90, 0], preference:1});

to ethier

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

or

var aAxis = createAxis({coordinate:0, table:false, axis:[1, 0, 0], range:[0, 90], preference:1});

but neither seem to have any effect.

 

Any help would be greatly appreciated. I'm loosing many hours here trying things on a trail and error basis.

 

Thanks in advance.

 

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

OSAI post processor configuration.

$Revision: 42049 24365c4692af9ba58117d1ab4b45705fca82c227 $
$Date: 2018-07-30 11:44:37 $

FORKID {61A162BF-C193-47a8-8ACD-CA0A7B954B94}
*/

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

longDescription = "Generic milling post for OSAI.";

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

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

minimumChordLength = spatial(0.0025, MM);
minimumCircularRadius = spatial(0.001, 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
preloadTool: false, // preloads next tool on tool change if any
showSequenceNumbers: true, // show sequence numbers
sequenceNumberStart: 10, // first sequence number
sequenceNumberIncrement: 1, // increment for sequence numbers
optionalStop: false, // optional stop
useRadius: false, // specifies that arcs should be output using the radius (R word) instead of the I and J words.
TCPType: 0 // specifies the TCP type to be used
};

// 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).", 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"},
useRadius: {title:"Radius arcs", description:"If yes is selected, arcs are outputted using radius values rather than IJK.", type:"boolean"},
TCPType: {title:"TCP type", description:"Sets the TCP type that is used on the machine.", type:"integer", values:[{id: 0, title:"Dynamic part TCP only."}, {id: 1, title:"No mobile table in the machine."}, {id: 2, title:"Mobile table on the first axis."}, {id: 3, title:"Mobile table on the second axis."}, {id: 4, title:"Mobile table on first and second axis."}, {id: 5, title:"Reserved."}]}
};

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

// samples:
// throughTool: {on: 88, off: 89}
// throughTool: {on: [8, 88], off: [9, 89]}
var coolants = {
flood: {on: 8,},
mist: {},
throughTool: {on: 88},
air: {},
airThroughTool: {},
suction: {},
floodMist: {},
floodThroughTool: {on: [8,10], off: [9,11]},
off: 9
};

var gFormat = createFormat({prefix:"G", width:2, zeropad:true, decimals:1});
var mFormat = createFormat({prefix:"M", width:2, zeropad:true, decimals:1});
var hFormat = createFormat({prefix:"h", width:2, zeropad:true, decimals:1});

var xyzFormat = createFormat({decimals:(unit == MM ? 3 : 4), forceDecimal:true});
var ijkFormat = createFormat({decimals:6, forceDecimal:true}); // unitless
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({onchange:function () {retracted = false;}, 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);

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

var gMotionModal = createModal({}, gFormat); // modal group 1 // G0-G3, ...
var gPlaneModal = createModal({onchange:function () {gMotionModal.reset();}}, gFormat); // modal group 2 // G17-19
var gAbsIncModal = createModal({}, gFormat); // modal group 3 // G90-91
var gFeedModeModal = createModal({}, gFormat); // modal group 5 // G93-94
var gUnitModal = createModal({}, gFormat); // modal group 6 // G70-71
var gCycleModal = createModal({}, gFormat); // modal group 9 // G81, ...
var gRetractModal = createModal({}, gFormat); // modal group 10 // G98-99

var WARNING_WORK_OFFSET_NOT_SUPPORTED = 0;

// collected state
var sequenceNumber;
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("N" + sequenceNumber, arguments);
sequenceNumber += properties.sequenceNumberIncrement;
} else {
writeWords(arguments);
}
}

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

function onOpen() {
if (properties.useRadius) {
maximumCircularSweep = toRad(90); // avoid potential center calculation errors for CNC
}

if (true) { // note: setup your machine here
var aAxis = createAxis({coordinate:0, table:false, axis:[1, 0, 0], range:[90, 0], preference:1});
var cAxis = createAxis({coordinate:2, table:false, axis:[0, 0, 1], range:[-90, 215], preference:1});
machineConfiguration = new MachineConfiguration(aAxis, cAxis);

setMachineConfiguration(machineConfiguration);
optimizeMachineAngles2(0); // TCP mode
}

if (!machineConfiguration.isMachineCoordinate(0)) {
aOutput.disable();
}
if (!machineConfiguration.isMachineCoordinate(1)) {
bOutput.disable();
}
if (!machineConfiguration.isMachineCoordinate(2)) {
cOutput.disable();
}

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

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

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

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

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

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

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

if (!retracted) {
writeRetract(Z);
}

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 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;
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 (insertToolCall || newWorkOffset || newWorkPlane) {

// stop spindle before retract during tool change
if (insertToolCall && !isFirstSection()) {
onCommand(COMMAND_STOP_SPINDLE);
}

// retract to safe plane
writeRetract(Z);
zOutput.reset();
}

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

// add tool.diameterOffset here
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."));
}
writeBlock(
sOutput.format(spindleSpeed), mFormat.format(tool.clockwise ? 3 : 4)
);
}

// wcs
var workOffset = currentSection.workOffset;
if (workOffset > 0) {
writeBlock("(UAO," + workOffset + ")");
}

forceXYZ();

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

forceAny();
gMotionModal.reset();

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

if (currentSection.isMultiAxis()) {
if (properties.TCPType == 0) {
writeBlock("(TCP)");
} else {
writeBlock("(TCP," + properties.TCPType + ")");
}
} else {
onCommand(COMMAND_LOCK_MULTI_AXIS);
}

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

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

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."));
}
writeBlock("DWT=" + secFormat.format(seconds));
writeBlock(gFormat.format(4));
}

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

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

function getCommonCycle(r1, r2, depth) {
return ["R" + xyzFormat.format(r1),
"R" + xyzFormat.format(r2),
"Z" + xyzFormat.format(depth)];
}

function onCyclePoint(x, y, z) {
if (isFirstCyclePoint()) {
repositionToCycleClearance(cycle, x, y, z);

// return to initial Z which is clearance plane and set absolute mode

var F = cycle.feedrate;
var P = (cycle.dwell == 0) ? 0 : clamp(0, cycle.dwell, 999999); // in seconds

switch (cycleType) {
case "drilling":
writeBlock(
gAbsIncModal.format(90), gCycleModal.format(81),
getCommonCycle(cycle.retract, cycle.clearance, cycle.bottom),
feedOutput.format(F)
);
break;
case "counter-boring":
if (P > 0) {
writeBlock("DWT=" + secFormat.format(P));
writeBlock(
gAbsIncModal.format(90), gCycleModal.format(82),
getCommonCycle(cycle.retract, cycle.clearance, cycle.bottom),
feedOutput.format(F)
);
} else {
writeBlock(
gAbsIncModal.format(90), gCycleModal.format(81),
getCommonCycle(cycle.retract, cycle.clearance, cycle.bottom),
feedOutput.format(F)
);
}
break;
case "chip-breaking":
case "deep-drilling":
// cycle.accumulatedDepth is ignored
var reductionFactor = cycle.incrementalDepthReduction / cycle.incrementalDepth;
if (P > 0) {
writeBlock("DWT=" + secFormat.format(P));
} else { // control does not retract the tool unless K is specified, it expects a dwell
reductionFactor = (reductionFactor == 0) ? 1 : reductionFactor;
}
writeBlock(
gAbsIncModal.format(90), gCycleModal.format(83),
getCommonCycle(cycle.retract, cycle.clearance, cycle.bottom),
"I" + xyzFormat.format(cycle.incrementalDepth),
conditional((reductionFactor != 0), "J" + xyzFormat.format(cycle.minimumIncrementalDepth)),
conditional((reductionFactor != 0), "K" + xyzFormat.format(reductionFactor)),
feedOutput.format(F)
);
break;
case "tapping":
if (!F) {
F = tool.getTappingFeedrate();
}
writeBlock(
gAbsIncModal.format(90), gCycleModal.format(84),
getCommonCycle(cycle.retract, cycle.clearance, cycle.bottom),
//"K" + xyzFormat.format(tool.threadPitch),
feedOutput.format(F)
);
break;
case "left-tapping":
if (!F) {
F = tool.getTappingFeedrate();
}
writeBlock(
gAbsIncModal.format(90), gCycleModal.format(84),
getCommonCycle(cycle.retract, cycle.clearance, cycle.bottom),
//"K" + xyzFormat.format(tool.threadPitch),
feedOutput.format(F)
);
break;
case "right-tapping":
if (!F) {
F = tool.getTappingFeedrate();
}
writeBlock(
gAbsIncModal.format(90), gCycleModal.format(84),
getCommonCycle(cycle.retract, cycle.clearance, cycle.bottom),
//"K" + xyzFormat.format(tool.threadPitch),
feedOutput.format(F)
);
break;
case "reaming":
if (P > 0) {
writeBlock("DWT=" + secFormat.format(P));
writeBlock(
gAbsIncModal.format(90), gCycleModal.format(89),
getCommonCycle(cycle.retract, cycle.clearance, cycle.bottom),
feedOutput.format(F)
);
} else {
writeBlock(
gAbsIncModal.format(90), gCycleModal.format(85),
getCommonCycle(cycle.retract, cycle.clearance, cycle.bottom),
feedOutput.format(F)
);
}
break;
case "stop-boring":
if (P > 0) {
expandCyclePoint(x, y, z);
} else {
writeBlock(
gAbsIncModal.format(90), gCycleModal.format(86),
getCommonCycle(cycle.retract, cycle.clearance, cycle.bottom),
feedOutput.format(F)
);
}
break;
case "manual-boring":
writeBlock(
gAbsIncModal.format(90), gCycleModal.format(88),
getCommonCycle(cycle.retract, cycle.clearance, cycle.bottom),
feedOutput.format(F)
);
break;
case "boring":
if (P > 0) {
writeBlock("DWT=" + secFormat.format(P));
writeBlock(
gAbsIncModal.format(90), gCycleModal.format(89),
getCommonCycle(cycle.retract, cycle.clearance, cycle.bottom),
feedOutput.format(F)
);
} else {
writeBlock(
gAbsIncModal.format(90), gCycleModal.format(85),
getCommonCycle(cycle.retract, cycle.clearance, cycle.bottom),
feedOutput.format(F)
);
}
break;
case "fine-boring":
case "back-boring":
default:
expandCyclePoint(x, y, z);
}
if (!cycleExpanded) {
var _x = xOutput.format(x);
var _y = yOutput.format(y);
if (!_x && !_y) {
xOutput.reset(); // at least one axis is required
_x = xOutput.format(x);
}
writeBlock(_x, _y);
}
} else {
if (cycleExpanded) {
expandCyclePoint(x, y, z);
} else {
writeBlock(xOutput.format(x), yOutput.format(y));
}
}
}

function onCycleEnd() {
if (!cycleExpanded) {
writeBlock(gCycleModal.format(80));
zOutput.reset();
}
}

var pendingRadiusCompensation = -1;

function onRadiusCompensation() {
pendingRadiusCompensation = radiusCompensation;
}

function onRapid(_x, _y, _z) {
var x = xOutput.format(_x);
var y = yOutput.format(_y);
var z = zOutput.format(_z);
if (x || y || z) {
if (pendingRadiusCompensation >= 0) {
error(localize("Radius compensation mode cannot be changed at rapid traversal."));
return;
}
writeBlock(gMotionModal.format(0), x, y, z);
feedOutput.reset();
}
}

function onLinear(_x, _y, _z, feed) {
var x = xOutput.format(_x);
var y = yOutput.format(_y);
var z = zOutput.format(_z);
var f = feedOutput.format(feed);
if (x || y || z) {
if (pendingRadiusCompensation >= 0) {
pendingRadiusCompensation = -1;
switch (radiusCompensation) {
case RADIUS_COMPENSATION_LEFT:
writeBlock(gPlaneModal.format(17));
writeBlock(gMotionModal.format(1), gFormat.format(41), x, y, z, f);
break;
case RADIUS_COMPENSATION_RIGHT:
writeBlock(gPlaneModal.format(17));
writeBlock(gMotionModal.format(1), gFormat.format(42), x, y, z, f);
break;
default:
writeBlock(gMotionModal.format(1), gFormat.format(40), x, y, z, f);
}
} else {
writeBlock(gMotionModal.format(1), x, y, z, f);
}
} else if (f) {
if (getNextRecord().isMotion()) { // try not to output feed without motion
feedOutput.reset(); // force feed on next line
} else {
writeBlock(gMotionModal.format(1), f);
}
}
}

function onRapid5D(_x, _y, _z, _a, _b, _c) {
if (pendingRadiusCompensation >= 0) {
error(localize("Radius compensation mode cannot be changed at rapid traversal."));
return;
}

if (currentSection.isOptimizedForMachine()) {
var x = xOutput.format(_x);
var y = yOutput.format(_y);
var z = zOutput.format(_z);
var a = 90-aOutput.format(_a);
var b = bOutput.format(_b);
var c = cOutput.format(_c);
writeBlock(gMotionModal.format(0), x, y, z, a, b, c);
} else {
var x = xOutput.format(_x);
var y = yOutput.format(_y);
var z = zOutput.format(_z);
var i = ijkFormat.format(_a);
var j = ijkFormat.format(_b);
var k = ijkFormat.format(_c);
writeBlock(gMotionModal.format(0), x, y, z, "I" + i, "J" + j, "K" + k);
}
feedOutput.reset();
}

function onLinear5D(_x, _y, _z, _a, _b, _c, feed) {
if (pendingRadiusCompensation >= 0) {
error(localize("Radius compensation cannot be activated/deactivated for 5-axis move."));
return;
}

if (currentSection.isOptimizedForMachine()) {
var x = xOutput.format(_x);
var y = yOutput.format(_y);
var z = zOutput.format(_z);
var a = 90-aOutput.format(_a);
var b = bOutput.format(_b);
var c = cOutput.format(_c);
var f = feedOutput.format(feed);
if (x || y || z || a || b || c) {
writeBlock(gMotionModal.format(1), x, y, z, a, b, c, f);
} else if (f) {
if (getNextRecord().isMotion()) { // try not to output feed without motion
feedOutput.reset(); // force feed on next line
} else {
writeBlock(gMotionModal.format(1), f);
}
}
} else {
forceXYZ();
var x = xOutput.format(_x);
var y = yOutput.format(_y);
var z = zOutput.format(_z);
var i = ijkFormat.format(_a);
var j = ijkFormat.format(_b);
var k = ijkFormat.format(_c);
var f = feedOutput.format(feed);
if (x || y || z || i || j || k) {
writeBlock(gMotionModal.format(1), x, y, z, "I" + i, "J" + j, "K" + k, f);
} else if (f) {
if (getNextRecord().isMotion()) { // try not to output feed without motion
feedOutput.reset(); // force feed on next line
} else {
writeBlock(gMotionModal.format(1), f);
}
}
}
}

function onCircular(clockwise, cx, cy, cz, x, y, z, feed) {
if (pendingRadiusCompensation >= 0) {
error(localize("Radius compensation cannot be activated/deactivated for a circular move."));
return;
}

if (isFullCircle()) {
if (properties.useRadius || isHelical()) { // radius mode does not support full arcs
linearize(tolerance);
return;
}
switch (getCircularPlane()) {
case PLANE_XY:
writeBlock(gPlaneModal.format(17));
writeBlock(gAbsIncModal.format(90), gMotionModal.format(clockwise ? 2 : 3), iOutput.format(cx), jOutput.format(cy), feedOutput.format(feed));
break;
case PLANE_ZX:
writeBlock(gPlaneModal.format(18));
writeBlock(gAbsIncModal.format(90), gMotionModal.format(clockwise ? 2 : 3), iOutput.format(cx), jOutput.format(cz), feedOutput.format(feed));
break;
case PLANE_YZ:
writeBlock(gPlaneModal.format(19));
writeBlock(gAbsIncModal.format(90), gMotionModal.format(clockwise ? 2 : 3), iOutput.format(cy), jOutput.format(cz), feedOutput.format(feed));
break;
default:
linearize(tolerance);
}
} else if (!properties.useRadius) {
switch (getCircularPlane()) {
case PLANE_XY:
writeBlock(gPlaneModal.format(17));
writeBlock(gAbsIncModal.format(90), gMotionModal.format(clockwise ? 2 : 3), xOutput.format(x), yOutput.format(y), zOutput.format(z), iOutput.format(cx), jOutput.format(cy), feedOutput.format(feed));
break;
case PLANE_ZX:
writeBlock(gPlaneModal.format(18));
writeBlock(gAbsIncModal.format(90), gMotionModal.format(clockwise ? 2 : 3), xOutput.format(x), yOutput.format(y), zOutput.format(z), iOutput.format(cx), jOutput.format(cz), feedOutput.format(feed));
break;
case PLANE_YZ:
writeBlock(gPlaneModal.format(19));
writeBlock(gAbsIncModal.format(90), gMotionModal.format(clockwise ? 2 : 3), xOutput.format(x), yOutput.format(y), zOutput.format(z), iOutput.format(cy), jOutput.format(cz), feedOutput.format(feed));
break;
default:
// see G16
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));
writeBlock(gAbsIncModal.format(90), 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));
writeBlock(gAbsIncModal.format(90), 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));
writeBlock(gAbsIncModal.format(90), gMotionModal.format(clockwise ? 2 : 3), xOutput.format(x), yOutput.format(y), zOutput.format(z), "R" + rFormat.format(r), feedOutput.format(feed));
break;
default:
// see G16
linearize(tolerance);
}
}
}

var currentCoolantMode = undefined;
var coolantOff = undefined;

function setCoolant(coolant) {
var coolantCodes = getCoolantCodes(coolant);
if (Array.isArray(coolantCodes)) {
for (var c in coolantCodes) {
writeBlock(coolantCodes[c]);
}
return undefined;
}
return coolantCodes;
}

function getCoolantCodes(coolant) {
if (!coolants) {
error(localize("Coolants have not been defined."));
}
if (!coolantOff) { // use the default coolant off command when an 'off' value is not specified for the previous coolant mode
coolantOff = coolants.off;
}

if (isProbeOperation()) { // avoid coolant output for probing
coolant = COOLANT_OFF;
}

if (coolant == currentCoolantMode) {
return undefined; // coolant is already active
}

var multipleCoolantBlocks = new Array(); // create a formatted array to be passed into the outputted line
if ((coolant != COOLANT_OFF) && (currentCoolantMode != COOLANT_OFF)) {
multipleCoolantBlocks.push(mFormat.format(coolantOff));
}

var m;
if (coolant == COOLANT_OFF) {
m = coolantOff;
coolantOff = coolants.off;
}

switch (coolant) {
case COOLANT_FLOOD:
if (!coolants.flood) {
break;
}
m = coolants.flood.on;
coolantOff = coolants.flood.off;
break;
case COOLANT_THROUGH_TOOL:
if (!coolants.throughTool) {
break;
}
m = coolants.throughTool.on;
coolantOff = coolants.throughTool.off;
break;
case COOLANT_AIR:
if (!coolants.air) {
break;
}
m = coolants.air.on;
coolantOff = coolants.air.off;
break;
case COOLANT_AIR_THROUGH_TOOL:
if (!coolants.airThroughTool) {
break;
}
m = coolants.airThroughTool.on;
coolantOff = coolants.airThroughTool.off;
break;
case COOLANT_FLOOD_MIST:
if (!coolants.floodMist) {
break;
}
m = coolants.floodMist.on;
coolantOff = coolants.floodMist.off;
break;
case COOLANT_MIST:
if (!coolants.mist) {
break;
}
m = coolants.mist.on;
coolantOff = coolants.mist.off;
break;
case COOLANT_SUCTION:
if (!coolants.suction) {
break;
}
m = coolants.suction.on;
coolantOff = coolants.suction.off;
break;
case COOLANT_FLOOD_THROUGH_TOOL:
if (!coolants.floodThroughTool) {
break;
}
m = coolants.floodThroughTool.on;
coolantOff = coolants.floodThroughTool.off;
break;
}

if (!m) {
onUnsupportedCoolant(coolant);
m = 9;
}

if (m) {
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_ORIENTATE_SPINDLE:19,
COMMAND_LOAD_TOOL:6
};

function onCommand(command) {
switch (command) {
case COMMAND_START_SPINDLE:
onCommand(tool.clockwise ? COMMAND_SPINDLE_CLOCKWISE : COMMAND_SPINDLE_COUNTERCLOCKWISE);
return;
case COMMAND_LOCK_MULTI_AXIS:
return;
case COMMAND_UNLOCK_MULTI_AXIS:
return;
case COMMAND_BREAK_CONTROL:
return;
case COMMAND_TOOL_MEASURE:
return;
}

var stringId = getCommandStringId(command);
var mcode = mapCommand[stringId];
if (mcode != undefined) {
writeBlock(mFormat.format(mcode));
} else {
onUnsupportedCommand(command);
}
}

function onSectionEnd() {
if (currentSection.isMultiAxis()) {
writeBlock("(TCP)");
} else {
onCommand(COMMAND_UNLOCK_MULTI_AXIS);
}
writeBlock(gPlaneModal.format(17));
writeBlock("(UAO," + 0 + ")"); // reset WCS

forceAny();
}

/** Output block to do safe retract and/or move to home position. */
function writeRetract() {
if (arguments.length == 0) {
error(localize("No axis specified for writeRetract()."));
return;
}
var words = []; // store all retracted axes in an array
for (var i = 0; i < arguments.length; ++i) {
let instances = 0; // checks for duplicate retract calls
for (var j = 0; j < arguments.length; ++j) {
if (arguments[i] == arguments[j]) {
++instances;
}
}
if (instances > 1) { // error if there are multiple retract calls for the same axis
error(localize("Cannot retract the same axis twice in one line"));
return;
}
switch (arguments[i]) {
case X:
words.push("X" + xyzFormat.format(machineConfiguration.hasHomePositionX() ? machineConfiguration.getHomePositionX() : 0));
break;
case Y:
words.push("Y" + xyzFormat.format(machineConfiguration.hasHomePositionY() ? machineConfiguration.getHomePositionY() : 0));
break;
case Z:
words.push("Z" + xyzFormat.format(machineConfiguration.getRetractPlane()));
retracted = true; // specifies that the tool has been retracted to the safe plane
break;
default:
error(localize("Bad axis specified for writeRetract()."));
return;
}
}
if (words.length > 0) {
gAbsIncModal.reset();
writeBlock(gMotionModal.format(0), gFormat.format(79), gAbsIncModal.format(91), words);
writeBlock(gAbsIncModal.format(90));
}
zOutput.reset();
}

function onClose() {
setCoolant(COOLANT_OFF);

writeRetract(Z);

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

writeRetract(X, Y);

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

5 REPLIES 5
Message 2 of 6
Boopathi_Sivakumar
in reply to: chris

@chris 

It can be done in generic post processor tool position vertical is considered as 0 deg. But in your case it is 90 deg so whatever the value comes should be (90-angle) will solve your case.

This is where code should be changed

onCommand(COMMAND_UNLOCK_MULTI_AXIS);

if (!retracted) {
writeRetract(Z);
}

writeBlock(
gMotionModal.format(0),
conditional(machineConfiguration.isMachineCoordinate(0), "A" + (90-abcFormat.format(abc.x))),
conditional(machineConfiguration.isMachineCoordinate(1), "B" + abcFormat.format(abc.y)),
conditional(machineConfiguration.isMachineCoordinate(2), "C" + abcFormat.format(abc.z))
);

This will do your job pretty neatly. I have attached your post processor also

 

Do a lot of testing before you putting the real job.

 

Poke us for any clarrifications

 

Thanks,

Boopathi

Boopathi Sivakumar
Sr Application Engineer
www.usamcadsoft.in
Facebook | Twitter | LinkedIn

Message 3 of 6
chris
in reply to: Boopathi_Sivakumar

Awesome thanks.  Will put it to the test and proceed with care.  Will keep you posted. Thanks again

Message 4 of 6
seth.madore
in reply to: chris

Just a polite request; Please don't copy/paste the entire contents of your post processor.

1) The automatic spam filter will likely flag this for removal (if it hasn't already)

2) It is not conducive to problem solving, as most people will just scroll and move on. Highlight the area you think is pertinent and attach the full .cps as an attachment.


Seth Madore
Customer Advocacy Manager - Manufacturing
Message 5 of 6
geral
in reply to: Boopathi_Sivakumar

Hi 

 

I am trying to flip the my C axis 180 DEG. The solution should be similar, but it seems not working to me...

 

Post copy from  osai.cps

 

What is odd is changing the configuration in the "5 axis setting" don´t have any effect in the code outpu.

 

ex:

 

    var aAxis = createAxis({coordinate:0table:falseaxis:[100], range:[-9292], preference:1});
    var cAxis = createAxis({coordinate:2table:falseaxis:[001], range:[-50280], preference:1});
    machineConfiguration = new MachineConfiguration(aAxiscAxis);
 
or
 
    var aAxis = createAxis({coordinate:0table:falseaxis:[100], range:[-9292], preference:1});
    var cAxis = createAxis({coordinate:2table:falseaxis:[00, -1], range:[-50280], preference:1});
    machineConfiguration = new MachineConfiguration(aAxiscAxis);
 
It ouput the same code... See attached files.
 
i managed to output the code needed changing these lines:
 
function onRapid5D(_x_y_z_a_b_c) {
  if (pendingRadiusCompensation >= 0) {
    error(localize("Radius compensation mode cannot be changed at rapid traversal."));
    return;
  }

  if (currentSection.isOptimizedForMachine()) {
    var x = xOutput.format(_x);
    var y = yOutput.format(_y);
    var z = zOutput.format(_z);
    var a = aOutput.format(_a);
    var b = bOutput.format(_b);
    //var c = cOutput.format(_c));
    var c = cOutput.format((3.14159265-_c));
    writeBlock(gMotionModal.format(0), xyzabc);
  } else {
    var x = xOutput.format(_x);
    var y = yOutput.format(_y);
    var z = zOutput.format(_z);
    var i = ijkFormat.format(_a);
    var j = ijkFormat.format(_b);
    var k = ijkFormat.format(_c);
    writeBlock(gMotionModal.format(0), xyz"I" + i"J" + j"K" + k);
  }
 
All the best
 
Marco 
 

 

Message 6 of 6

Good day, i've tried what you suggested on a Onsrud i3 post processor. But it has no effect, i guess the post processor was built in a different way.

 

function setWorkPlane(abc) {
  if (!forceMultiAxisIndexing && is3D() && !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);
  if (!retracted) {
    writeRetract(Z);
  }
 
  if (useMultiAxisFeatures) {
    if (cancelTiltFirst) {
      cancelWorkPlane();
    }
    if (machineConfiguration.isMultiAxisConfiguration() && useABCPrepositioning) {
      var angles = abc.isNonZero() ? getWorkPlaneMachineABC(currentSection.workPlane, false, false) : abc;
      positionABC(angles, true);
    }
    if (abc.isNonZero()) {
      gRotationModal.reset();
      writeBlock(gRotationModal.format(68.2), "X" + xyzFormat.format(0), "Y" + xyzFormat.format(0), "Z" + xyzFormat.format(0), "I" + abcFormat.format(abc.x), "J" + abcFormat.format(abc.y), "K" + abcFormat.format(abc.z)); // set frame
      writeBlock(gFormat.format(53.1)); // turn machine
    } else {
      if (!cancelTiltFirst) {
        cancelWorkPlane();
      }
    }
  } else {
    positionABC(abc, true);
  }

  onCommand(COMMAND_LOCK_MULTI_AXIS);

  currentWorkPlaneABC = abc;
}
 
Here is how it looks like.
 
It's the C axis i want to add 90 degrees.

Can't find what you're looking for? Ask the community or share your knowledge.

Post to forums