CAM-Fräsen mit X-Achse im Durchmesser??

Hallo zusammen,

ich hab hier jetzt schon allerlei Fragen gestellt...Jetzt habe ich eine wo jemand mit Sicherheit eine Antwort weiß!

Ich arbeite an einer Drehmaschine mit driventools und einer Y-Achse......
Die Fanuc Dialog-zyklen kann man vergessen zum Fräsen.....
Wir versuchen mit Inventor CSM 16 zu arbeiten...kick'd that shit to the max beim 3 achs fräsen...
Aber ich würde gerne auch Fräsprogramme für die Drehmaschine schreibem °_^

das Problem ist der Postprozessor......
wenn ich der Maschine "sage" g0 von x0 bis x50 ....fährt sie nur 25mm nach außen....
das Problem ist die Durchmesserprogrammierung.....
Per Maschinendatum kannn man das ganze umschalten, ein M Befehl wäre Praxisnaher..


kann mir da jemand helfen der inventor hsm, fanuc oder drehfräserfahrung hat?


Viele Grüße

driven Dante

Bist du aus irgendeinem Knast ausgebrochen?

Die Lösung ist ziemlich einfach. Schreib in deinen Postprozessor, dass jeder X-Wert vor der Ausgabe mit 2 multipliziert wird.

--> X=2*X

Grüße

Nico

Hallo,

die Lösung von nico ist schon ganz gut. Ich würde nur schauen ob vielleicht der Postprozessor die x Achse nicht im Allgemeinen mit Faktor zwei ausgeben kann, und nicht vergessen das i von g2/g3 auch ein Doppelter wert sein muss.

Lg

Ich sitze immer noch und bin in der Knastdreherei

Schon mal Danke für die schnellen Antworten...

könnt ihr mir auch sagen wie zur Hölle ich das ganze in dem Postprozessor einbauen soll? =)

Viele Grüße



/**
FANUC post processor configuration.

$Revision: 41030 1e537f7a89ea5d7051d183af3433708d6c82c0c0 $
$Date: 2016-04-22 22:15:13 $

FORKID {04622D27-72F0-45d4-85FB-DB346FD1AE22}
*/

description = "Generic FANUC";
vendor = "Fanuc";
vendorUrl = "http://www.fanuc.com";
legal = " 2012-2016.";
certificationLevel = 2;
minimumRevision = 24000;

longDescription = "Generic post for Fanuc.";

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

capabilities = CAPABILITY_MILLING;
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
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
o8: false, // specifies 8-digit program number
separateWordsWithSpace: true, // specifies that the words should be separated with a white space
allow3DArcs: false, // specifies that 3D circular arcs are allowed
useRadius: false, // specifies that arcs should be output using the radius (R word) instead of the I, J, and K words
forceIJK: false, // force output of IJK for G2/G3 when not using R word
useParametricFeed: false, // specifies that feed should be output using Q values
showNotes: false, // specifies that operation notes should be output
useSmoothing: false, // specifies if smoothing should be used or not
usePitchForTapping: false, // enable to use pitch instead of feed for the F-word for canned tapping cycles - note that your CNC control must be setup for pitch mode!
useG95: false // use IPR/MPR instead of IPM/MPM
};



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

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 dFormat = createFormat({prefix:"D", 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 pitchFormat = createFormat({decimals:(unit == MM ? 3 : 4), 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 pitchOutput = createVariable({prefix:"F", force:true}, pitchFormat);
var sOutput = createVariable({prefix:"S", force:true}, rpmFormat);
var dOutput = createVariable({}, dFormat);

// circular output
var iOutput = createReferenceVariable({prefix:"I"}, xyzFormat);
var jOutput = createReferenceVariable({prefix:"J"}, xyzFormat);
var kOutput = createReferenceVariable({prefix:"K"}, 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 // G94-95
var gUnitModal = createModal({}, gFormat); // modal group 6 // G20-21
var gCycleModal = createModal({}, gFormat); // modal group 9 // G81, ...
var gRetractModal = createModal({}, gFormat); // modal group 10 // G98-99

// fixed settings
var firstFeedParameter = 500;
var useMultiAxisFeatures = true;
var forceMultiAxisIndexing = false; // force multi-axis indexing for 3D programs

var WARNING_WORK_OFFSET = 0;

// collected state
var sequenceNumber;
var currentWorkOffset;
var optionalSection = false;
var forceSpindleSpeed = false;
var activeMovements; // do not use by default
var currentFeedId;



/**
Writes the specified block.
*/
function writeBlock() {
if (properties.showSequenceNumbers) {
if (optionalSection) {
var text = formatWords(arguments);
if (text) {
writeWords("/", "N" + sequenceNumber, text);
}
} else {
writeWords2("N" + sequenceNumber, arguments);
}
sequenceNumber += properties.sequenceNumberIncrement;
} else {
if (optionalSection) {
writeWords2("/", arguments);
} else {
writeWords(arguments);
}
}
}

/**
Writes the specified optional block.
*/
function writeOptionalBlock() {
if (properties.showSequenceNumbers) {
var words = formatWords(arguments);
if (words) {
writeWords("/", "N" + sequenceNumber, words);
sequenceNumber += properties.sequenceNumberIncrement;
}
} else {
writeWords2("/", arguments);
}
}

function formatComment(text) {
return "(" + filterText(String(text).toUpperCase(), permittedCommentChars).replace(/[\(\)]/g, "") + ")";
}

/**
Output a comment.
*/
function writeComment(text) {
writeln(formatComment(text));
}

function onOpen() {

if (false) { // note: setup your machine here
var aAxis = createAxis({coordinate:0, table:false, axis:[1, 0, 0], range:[-360,360], preference:1});
var cAxis = createAxis({coordinate:2, table:false, axis:[0, 0, 1], range:[-360,360], 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();
}

if (!properties.separateWordsWithSpace) {
setWordSeparator("");
}

if (properties.forceIJK) {
iOutput = createReferenceVariable({prefix:"I", force:true}, xyzFormat);
jOutput = createReferenceVariable({prefix:"J", force:true}, xyzFormat);
kOutput = createReferenceVariable({prefix:"K", force:true}, xyzFormat);
}

sequenceNumber = properties.sequenceNumberStart;
writeln("%");

if (programName) {
var programId;
try {
programId = getAsInt(programName);
} catch(e) {
error(localize("Program name must be a number."));
return;
}
if (properties.o8) {
if (!((programId >= 1) && (programId <= 99999999))) {
error(localize("Program number is out of range."));
return;
}
} else {
if (!((programId >= 1) && (programId <= 9999))) {
error(localize("Program number is out of range."));
return;
}
}
if ((programId >= 8000) && (programId <= 9999)) {
warning(localize("Program number is reserved by tool builder."));
}
var oFormat = createFormat({width:(properties.o8 ? 8 : 4), zeropad:true, decimals:0});
if (programComment) {
writeln("O" + oFormat.format(programId) + " (" + filterText(String(programComment).toUpperCase(), permittedCommentChars) + ")");
} else {
writeln("O" + oFormat.format(programId));
}
} else {
error(localize("Program name has not been specified."));
return;
}

// 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), gFeedModeModal.format(properties.useG95 ? 95 : 94), gPlaneModal.format(17), gFormat.format(49), gFormat.format(40), gFormat.format(80));

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

if (properties.useG95 && properties.useParametricFeed) {
error(localize("Parametric feed is not supported when using G95."));
return;
}

if (properties.useG95) {
feedFormat = createFormat({decimals:(unit == MM ? 4 : 5), forceDecimal:true});
feedOutput = createVariable({prefix:"F"}, feedFormat);
}
}

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

function forceFeed() {
currentFeedId = undefined;
feedOutput.reset();
}

/** Force output of X, Y, Z, A, B, C, and F on next output. */
function forceAny() {
forceXYZ();
forceABC();
forceFeed();
}

var lengthCompensationActive = false;
var retracted = false; // specifies that the tool has been retracted to the safe plane

/** Disables length compensation if currently active or if forced. */
function disableLengthCompensation(force) {
if (lengthCompensationActive || force) {
validate(retracted, "Cannot cancel length compensation if the machine is not fully retracted.");
writeBlock(gFormat.format(49));
lengthCompensationActive = false;
}
}

var currentSmoothing = false;

function setSmoothing(mode) {
if (mode == currentSmoothing) {
return false;
}

// 1) Make sure G49 is called before the execution of G05.1 Q1 Rx
// 2) G05.1 Q1 Rx must be engaged BEFORE G43-Tool Length Comp
// 3) AICC and AIAPC need to be turned on and off for each tool
// 4) AICC and AIAPC does not apply to canned drilling cycles
validate(!lengthCompensationActive, "Length compensation is active while trying to update smoothing.");

currentSmoothing = mode;
writeBlock(gFormat.format(5.1), mode ? "Q1" : "Q0");
return true;
}

function FeedContext(id, description, feed) {
this.id = id;
this.description = description;
this.feed = feed;
}

function getFeed(f) {
if (properties.useG95) {
return feedOutput.format(f/spindleSpeed); // use feed value
}
if (activeMovements) {
var feedContext = activeMovements[movement];
if (feedContext != undefined) {
if (!feedFormat.areDifferent(feedContext.feed, f)) {
if (feedContext.id == currentFeedId) {
return ""; // nothing has changed
}
forceFeed();
currentFeedId = feedContext.id;
return "F#" + (firstFeedParameter + feedContext.id);
}
}
currentFeedId = undefined; // force Q feed next time
}
return feedOutput.format(f); // use feed value
}

function initializeActiveFeeds() {
activeMovements = new Array();
var movements = currentSection.getMovements();

var id = 0;
var activeFeeds = new Array();
if (hasParameter("operation:tool_feedCutting")) {
if (movements & ((1 << MOVEMENT_CUTTING) | (1 << MOVEMENT_LINK_TRANSITION) | (1 << MOVEMENT_EXTENDED))) {
var feedContext = new FeedContext(id, localize("Cutting"), getParameter("operation:tool_feedCutting"));
activeFeeds.push(feedContext);
activeMovements[MOVEMENT_CUTTING] = feedContext;
activeMovements[MOVEMENT_LINK_TRANSITION] = feedContext;
activeMovements[MOVEMENT_EXTENDED] = feedContext;
}
++id;
if (movements & (1 << MOVEMENT_PREDRILL)) {
feedContext = new FeedContext(id, localize("Predrilling"), getParameter("operation:tool_feedCutting"));
activeMovements[MOVEMENT_PREDRILL] = feedContext;
activeFeeds.push(feedContext);
}
++id;
}

if (hasParameter("operation:finishFeedrate")) {
if (movements & (1 << MOVEMENT_FINISH_CUTTING)) {
var feedContext = new FeedContext(id, localize("Finish"), getParameter("operation:finishFeedrate"));
activeFeeds.push(feedContext);
activeMovements[MOVEMENT_FINISH_CUTTING] = feedContext;
}
++id;
} else if (hasParameter("operation:tool_feedCutting")) {
if (movements & (1 << MOVEMENT_FINISH_CUTTING)) {
var feedContext = new FeedContext(id, localize("Finish"), getParameter("operation:tool_feedCutting"));
activeFeeds.push(feedContext);
activeMovements[MOVEMENT_FINISH_CUTTING] = feedContext;
}
++id;
}

if (hasParameter("operation:tool_feedEntry")) {
if (movements & (1 << MOVEMENT_LEAD_IN)) {
var feedContext = new FeedContext(id, localize("Entry"), getParameter("operation:tool_feedEntry"));
activeFeeds.push(feedContext);
activeMovements[MOVEMENT_LEAD_IN] = feedContext;
}
++id;
}

if (hasParameter("operation:tool_feedExit")) {
if (movements & (1 << MOVEMENT_LEAD_OUT)) {
var feedContext = new FeedContext(id, localize("Exit"), getParameter("operation:tool_feedExit"));
activeFeeds.push(feedContext);
activeMovements[MOVEMENT_LEAD_OUT] = feedContext;
}
++id;
}

if (hasParameter("operation:noEngagementFeedrate")) {
if (movements & (1 << MOVEMENT_LINK_DIRECT)) {
var feedContext = new FeedContext(id, localize("Direct"), getParameter("operation:noEngagementFeedrate"));
activeFeeds.push(feedContext);
activeMovements[MOVEMENT_LINK_DIRECT] = feedContext;
}
++id;
} else if (hasParameter("operation:tool_feedCutting") &&
hasParameter("operation:tool_feedEntry") &&
hasParameter("operation:tool_feedExit")) {
if (movements & (1 << MOVEMENT_LINK_DIRECT)) {
var feedContext = new FeedContext(id, localize("Direct"), Math.max(getParameter("operation:tool_feedCutting"), getParameter("operation:tool_feedEntry"), getParameter("operation:tool_feedExit")));
activeFeeds.push(feedContext);
activeMovements[MOVEMENT_LINK_DIRECT] = feedContext;
}
++id;
}

if (hasParameter("operation:reducedFeedrate")) {
if (movements & (1 << MOVEMENT_REDUCED)) {
var feedContext = new FeedContext(id, localize("Reduced"), getParameter("operation:reducedFeedrate"));
activeFeeds.push(feedContext);
activeMovements[MOVEMENT_REDUCED] = feedContext;
}
++id;
}

if (hasParameter("operation:tool_feedRamp")) {
if (movements & ((1 << MOVEMENT_RAMP) | (1 << MOVEMENT_RAMP_HELIX) | (1 << MOVEMENT_RAMP_PROFILE) | (1 << MOVEMENT_RAMP_ZIG_ZAG))) {
var feedContext = new FeedContext(id, localize("Ramping"), getParameter("operation:tool_feedRamp"));
activeFeeds.push(feedContext);
activeMovements[MOVEMENT_RAMP] = feedContext;
activeMovements[MOVEMENT_RAMP_HELIX] = feedContext;
activeMovements[MOVEMENT_RAMP_PROFILE] = feedContext;
activeMovements[MOVEMENT_RAMP_ZIG_ZAG] = feedContext;
}
++id;
}
if (hasParameter("operation:tool_feedPlunge")) {
if (movements & (1 << MOVEMENT_PLUNGE)) {
var feedContext = new FeedContext(id, localize("Plunge"), getParameter("operation:tool_feedPlunge"));
activeFeeds.push(feedContext);
activeMovements[MOVEMENT_PLUNGE] = feedContext;
}
++id;
}
if (true) { // high feed
if (movements & (1 << MOVEMENT_HIGH_FEED)) {
var feedContext = new FeedContext(id, localize("High Feed"), this.highFeedrate);
activeFeeds.push(feedContext);
activeMovements[MOVEMENT_HIGH_FEED] = feedContext;
}
++id;
}

for (var i = 0; i < activeFeeds.length; ++i) {
var feedContext = activeFeeds[i];
writeBlock("#" + (firstFeedParameter + feedContext.id) + "=" + feedFormat.format(feedContext.feed), formatComment(feedContext.description));
}
}

var currentWorkPlaneABC = undefined;

function forceWorkPlane() {
currentWorkPlaneABC = undefined;
}

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 (useMultiAxisFeatures) {
if (abc.isNonZero()) {
writeBlock(gFormat.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 {
writeBlock(gFormat.format(69)); // cancel frame
}
} else {
gMotionModal.reset();
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 = false;
if (tcp) {
setRotation(W); // TCP mode
} else {
var O = machineConfiguration.getOrientation(abc);
var R = machineConfiguration.getRemainingOrientation(abc, W);
setRotation®;
}

return abc;
}

function onSection() {
var forceToolAndRetract = optionalSection && !currentSection.isOptional();
optionalSection = currentSection.isOptional();

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

var newWorkOffset = isFirstSection() ||
(getPreviousSection().workOffset != currentSection.workOffset); // work offset changes
var newWorkPlane = isFirstSection() ||
!isSameDirection(getPreviousSection().getGlobalFinalToolAxis(), currentSection.getGlobalInitialToolAxis());
if (insertToolCall || newWorkOffset || newWorkPlane) {

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

// retract to safe plane
retracted = true;
writeBlock(gFormat.format(28), gAbsIncModal.format(91), "Z" + xyzFormat.format(0)); // retract
writeBlock(gAbsIncModal.format(90));
forceXYZ();
if (insertToolCall && !isFirstSection()) {
disableLengthCompensation();
setSmoothing(false);
}
}

writeln("");

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

if (properties.showNotes && hasParameter("notes")) {
var notes = getParameter("notes");
if (notes) {
var lines = String(notes).split("\n");
var r1 = new RegExp("^[\\s]+", "g");
var r2 = new RegExp("[\\s]+$", "g");
for (line in lines) {
var comment = lines[line].replace(r1, "").replace(r2, "");
if (comment) {
writeComment(comment);
}
}
}
}

if (insertToolCall) {
forceWorkPlane();

retracted = true;
onCommand(COMMAND_COOLANT_OFF);

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

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

disableLengthCompensation();
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 ||
forceSpindleSpeed ||
isFirstSection() ||
(rpmFormat.areDifferent(tool.spindleRPM, sOutput.getCurrent())) ||
(tool.clockwise != getPreviousSection().getTool().clockwise)) {
forceSpindleSpeed = false;

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

onCommand(COMMAND_START_CHIP_TRANSPORT);
if (forceMultiAxisIndexing || !is3D() || machineConfiguration.isMultiAxisConfiguration()) {
// writeBlock(mFormat.format(xxx)); // shortest path traverse
}
}

// 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) {
var p = workOffset - 6; // 1->...
if (p > 300) {
error(localize("Work offset out of range."));
return;
} else {
if (workOffset != currentWorkOffset) {
writeBlock(gFormat.format(54.1), "P" + p); // G54.1P
currentWorkOffset = workOffset;
}
}
} else {
if (workOffset != currentWorkOffset) {
writeBlock(gFormat.format(53 + workOffset)); // G54->G59
currentWorkOffset = workOffset;
}
}
}

forceXYZ();

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

if (currentSection.isMultiAxis()) {
forceWorkPlane();
cancelTransformation();
} else {
var abc = new Vector(0, 0, 0);
if (useMultiAxisFeatures) {
var eulerXYZ = currentSection.workPlane.getTransposed().eulerZYX_R;
abc = new Vector(-eulerXYZ.x, -eulerXYZ.y, -eulerXYZ.z);
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);
}

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

if (properties.useSmoothing) {
if (hasParameter("operation-strategy") && (getParameter("operation-strategy") != "drill")) {
if (setSmoothing(true)) {
// we force G43 using lengthCompensationActive
}
} else {
if (setSmoothing(false)) {
// we force G43 using lengthCompensationActive
}
}
}

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 || !lengthCompensationActive || retracted || (!isFirstSection() && getPreviousSection().isMultiAxis())) {
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), gFormat.format(currentSection.isMultiAxis() ? 43.5 : 43), zOutput.format(initialPosition.z), hFormat.format(lengthOffset));
lengthCompensationActive = true;
} else {
writeBlock(
gAbsIncModal.format(90),
gMotionModal.format(0),
gFormat.format(currentSection.isMultiAxis() ? (machineConfiguration.isMultiAxisConfiguration() ? 43.4 : 43.5) : 43),
xOutput.format(initialPosition.x),
yOutput.format(initialPosition.y),
zOutput.format(initialPosition.z), hFormat.format(lengthOffset)
);
lengthCompensationActive = true;
}

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

validate(lengthCompensationActive, "Length compensation is not active.");

if (properties.useParametricFeed &&
hasParameter("operation-strategy") &&
(getParameter("operation-strategy") != "drill")) {
if (!insertToolCall &&
activeMovements &&
(getCurrentSectionId() > 0) &&
(getPreviousSection().getPatternId() == currentSection.getPatternId())) {
// use the current feeds
} else {
initializeActiveFeeds();
}
} else {
activeMovements = undefined;
}
retracted = false;
}

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

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

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;
if (properties.useG95) {
F = F/spindleSpeed;
}
var P = (cycle.dwell == 0) ? 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":
// 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" + milliFormat.format(P)),
feedOutput.format(F)
);
}
break;
case "tapping":
writeBlock(mFormat.format(29), sOutput.format(tool.spindleRPM));
if (properties.usePitchForTapping) {
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),
pitchOutput.format(tool.threadPitch)
);
forceFeed();
} else {
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":
writeBlock(mFormat.format(29), sOutput.format(tool.spindleRPM));
if (properties.usePitchForTapping) {
writeBlock(
gRetractModal.format(98), gAbsIncModal.format(90), gCycleModal.format(74),
getCommonCycle(x, y, z, cycle.retract),
"P" + milliFormat.format(P),
pitchOutput.format(tool.threadPitch)
);
forceFeed();
} else {
writeBlock(
gRetractModal.format(98), gAbsIncModal.format(90), gCycleModal.format(74),
getCommonCycle(x, y, z, cycle.retract),
"P" + milliFormat.format(P),
feedOutput.format(properties.useG95 ? tool.getTappingFeedrate()/spindleSpeed : tool.getTappingFeedrate())
);
}
break;
case "right-tapping":
writeBlock(mFormat.format(29), sOutput.format(tool.spindleRPM));
if (properties.usePitchForTapping) {
writeBlock(
gRetractModal.format(98), gAbsIncModal.format(90), gCycleModal.format(84),
getCommonCycle(x, y, z, cycle.retract),
"P" + milliFormat.format(P),
pitchOutput.format(tool.threadPitch)
);
forceFeed();
} else {
writeBlock(
gRetractModal.format(98), gAbsIncModal.format(90), gCycleModal.format(84),
getCommonCycle(x, y, z, cycle.retract),
"P" + milliFormat.format(P),
feedOutput.format(properties.useG95 ? tool.getTappingFeedrate()/spindleSpeed : tool.getTappingFeedrate())
);
}
break;
case "tapping-with-chip-breaking":
case "left-tapping-with-chip-breaking":
case "right-tapping-with-chip-breaking":
writeBlock(mFormat.format(29), sOutput.format(tool.spindleRPM));
if (properties.usePitchForTapping) {
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),
"Q" + xyzFormat.format(cycle.incrementalDepth),
pitchOutput.format(tool.threadPitch)
);
forceFeed();
} else {
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),
"Q" + xyzFormat.format(cycle.incrementalDepth),
feedOutput.format(properties.useG95 ? tool.getTappingFeedrate()/spindleSpeed : tool.getTappingFeedrate())
);
}
break;
case "fine-boring":
writeBlock(
gRetractModal.format(98), gAbsIncModal.format(90), gCycleModal.format(76),
getCommonCycle(x, y, z, cycle.retract),
"P" + milliFormat.format(P), // not optional
"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),
"Q" + xyzFormat.format(cycle.shift),
"P" + milliFormat.format(P), // not optional
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 "stop-boring":
if (P > 0) {
expandCyclePoint(x, y, z);
} else {
writeBlock(
gRetractModal.format(98), gAbsIncModal.format(90), gCycleModal.format(86),
getCommonCycle(x, y, z, cycle.retract),
feedOutput.format(F)
);
}
break;
case "manual-boring":
writeBlock(
gRetractModal.format(98), gAbsIncModal.format(90), gCycleModal.format(88),
getCommonCycle(x, y, z, cycle.retract),
"P" + milliFormat.format(P), // not optional
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() {
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);
forceFeed();
}
}

function onLinear(_x, _y, _z, feed) {
var x = xOutput.format(_x);
var y = yOutput.format(_y);
var z = zOutput.format(_z);
var f = getFeed(feed);
if (x || y || z) {
if (pendingRadiusCompensation >= 0) {
pendingRadiusCompensation = -1;
var d = tool.diameterOffset;
if (d > 99) {
warning(localize("The diameter offset exceeds the maximum value."));
}
writeBlock(gPlaneModal.format(17));
switch (radiusCompensation) {
case RADIUS_COMPENSATION_LEFT:
dOutput.reset();
writeBlock(gMotionModal.format(1), gFormat.format(41), x, y, z, dOutput.format(d), f);
break;
case RADIUS_COMPENSATION_RIGHT:
dOutput.reset();
writeBlock(gMotionModal.format(1), gFormat.format(42), x, y, z, dOutput.format(d), 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
forceFeed(); // 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 = aOutput.format(_a);
var b = bOutput.format(_b);
var c = cOutput.format(_c);
writeBlock(gMotionModal.format(0), x, y, z, a, b, c);
} 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);
writeBlock(gMotionModal.format(0), x, y, z, "I" + i, "J" + j, "K" + k);
}
forceFeed();
}

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 = aOutput.format(_a);
var b = bOutput.format(_b);
var c = cOutput.format(_c);
var f = getFeed(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
forceFeed(); // 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 = getFeed(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
forceFeed(); // 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;
}

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), getFeed(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), getFeed(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), getFeed(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), getFeed(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), getFeed(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), getFeed(feed));
break;
default:
if (properties.allow3DArcs) {
// make sure maximumCircularSweep is well below 360deg
// we could use G02.4 or G03.4 - direction is calculated
var ip = getPositionU(0.5);
writeBlock(gAbsIncModal.format(90), gMotionModal.format(clockwise ? 2.4 : 3.4), xOutput.format(ip.x), yOutput.format(ip.y), zOutput.format(ip.z));
writeBlock(xOutput.format(x), yOutput.format(y), zOutput.format(z), getFeed(feed));
} else {
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®, getFeed(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®, getFeed(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®, getFeed(feed));
break;
default:
if (properties.allow3DArcs) {
// make sure maximumCircularSweep is well below 360deg
// we could use G02.4 or G03.4 - direction is calculated
var ip = getPositionU(0.5);
writeBlock(gAbsIncModal.format(90), gMotionModal.format(clockwise ? 2.4 : 3.4), xOutput.format(ip.x), yOutput.format(ip.y), zOutput.format(ip.z));
writeBlock(xOutput.format(x), yOutput.format(y), zOutput.format(z), getFeed(feed));
} else {
linearize(tolerance);
}
}
}
}

var currentCoolantMode = COOLANT_OFF;

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

if (coolant == COOLANT_OFF) {
writeBlock(mFormat.format((currentCoolantMode == COOLANT_THROUGH_TOOL) ? 89 : 9));
currentCoolantMode = COOLANT_OFF;
return;
}

var m;
switch (coolant) {
case COOLANT_FLOOD:
m = 8;
break;
case COOLANT_THROUGH_TOOL:
m = 88;
break;
default:
onUnsupportedCoolant(coolant);
m = 9;
}

if (m) {
writeBlock(mFormat.format(m));
currentCoolantMode = coolant;
}
}

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

function onCommand(command) {
switch (command) {
case COMMAND_COOLANT_OFF:
setCoolant(COOLANT_OFF);
return;
case COMMAND_COOLANT_ON:
setCoolant(COOLANT_FLOOD);
return;
case COMMAND_STOP:
writeBlock(mFormat.format(0));
forceSpindleSpeed = true;
return;
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_START_CHIP_TRANSPORT:
return;
case COMMAND_STOP_CHIP_TRANSPORT:
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() {
writeBlock(gPlaneModal.format(17));

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

forceAny();
}

function onClose() {
writeln("");
optionalSection = false;

onCommand(COMMAND_COOLANT_OFF);

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

disableLengthCompensation(true);
setSmoothing(false);
zOutput.reset();

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

if (!machineConfiguration.hasHomePositionX() && !machineConfiguration.hasHomePositionY()) {
// 90/91 mode is don't care
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
writeln("%");
}

Hallo,

Ich kenne mich mit Infentor pp nicht aus, sichere den pp und versuche dann folgendes.

Nach
var xOutput = createVariable({prefix:"X"}, xyzFormat);

Das einfügen
xOutput = (xOutput*2)

Und nach

var iOutput = createReferenceVariable({prefix:"I"}, xyzFormat);

iOutput = (iOutput*2)

Aber ganz wichtig bevor du was änderst eine Sicherung von dem Aktuellen pp machen.

Lg

Un beim ersten Mal unbedingt langsam an der Maschine!

LG Nico

jetzt kommt dieses, anstatt nem NC Code :/




Fehler(C:\Users\Public\Documents\Autodesk\Inventor HSM\Posts\fanuc - Xx2.cps:353): TypeError: xOutput.reset is not a function
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Stack dump:
forceXYZ()@C:\Users\Public\Documents\Autodesk\Inventor HSM\Posts\fanuc - Xx2.cps:352
onSection()@C:\Users\Public\Documents\Autodesk\Inventor HSM\Posts\fanuc - Xx2.cps:671

Failed while processing onSection() for record 389.
Fehler: Failed to invoke function 'onSection'.
Fehler: Failed to invoke 'onSection' in the post configuration.
Fehler: Failed to execute configuration.
Stop time: Thursday, July 21, 2016 5:09:21 PM
Post processing failed.

Ich verwende Fusion 360 für meine Doosan Lynx 220 mit Y Achse und das sollten die selben Post Prozessoren wie bei Inventor HSM sein zumindest funktionieren die auch in Fusion. Am einfachsten du lädst dir von http://cam.autodesk.com/posts/ einen Post Prozessor für eine Haas ST 20 Y runter den verwende ich auch nur bisschen angepasst. In dem Haas Post musst du auch noch die X Achse auf Radius umstellen da diesen Satz suchen:
xFormat = createFormat({decimals:(unit == MM ? 3 : 4), forceDecimal:true, scale:1}); // radius mode

und das daraus machen

xFormat = createFormat({decimals:(unit == MM ? 3 : 4), forceDecimal:true, scale:2}); // diameter mode

dann stimmen zwar die ganzen M Codes noch nicht für die C Achse einschalten und Klemmen oder die Spindel an und aus aber das kann man einfach per Hand ändern oder im Post ist es auch recht einfach zu ändern.

DANKEEE....videos folgen ;)