/**
Copyright (C) 2012-2026 by Autodesk, Inc.
All rights reserved.
Siemens mill-turn post processor configuration.
$Revision: 44241 a0b87a8a75662897e83da0599ff438590544e50f $
$Date: 2026-09-01 16:24:01 $
FORKID {568F1FA1-24A4-4C05-A805-276F2DADC4C4}
*/
///////////////////////////////////////////////////////////////////////////////
// MANUAL NC COMMANDS
//
// The following ACTION commands are supported by this post.
//
// usePolarInterpolation - Force Polar interpolation mode for next operation (usePolarMode is deprecated but still supported)
// usePolarCoordinates - Force Polar coordinates for the next operation (useXZCMode is deprecated but still supported)
//
///////////////////////////////////////////////////////////////////////////////
description = "DMG CTX beta 800 TC";
vendor = "DMG MORI";
vendorUrl = "http://www.dmgmori.com";
legal = "Copyright (C) 2012-2026 by Autodesk, Inc.";
certificationLevel = 2;
minimumRevision = 45909;
longDescription = "Post processor for DMG CTX 800 machines. This post is still in beta and requires careful testing when used.";
extension = "mpf";
setCodePage("ascii");
capabilities = CAPABILITY_MILLING | CAPABILITY_TURNING;
tolerance = spatial(0.002, MM);
minimumChordLength = spatial(0.25, MM);
minimumCircularRadius = spatial(0.01, MM);
maximumCircularRadius = spatial(1000, MM);
minimumCircularSweep = toRad(0.01);
var useArcTurn = false;
maximumCircularSweep = toRad(useArcTurn ? 120 : 120); // max revolutions
allowHelicalMoves = !useArcTurn;
allowedCircularPlanes = undefined; // allow any circular motion
allowSpiralMoves = false;
allowFeedPerRevolutionDrilling = true;
highFeedrate = (unit == IN) ? 470 : 5000;
// user-defined properties
properties = {
xAxisMinimum: {
title : "X-axis minimum limit",
description: "Defines the lower limit of X-axis travel as a radius value.",
group : "configuration",
type : "spatial",
range : [-99999, 0],
value : 0,
scope : "post"
},
usePartCatcher: {
title : "Use part catcher",
description: "Specifies whether part catcher code should be output.",
group : "configuration",
type : "boolean",
value : false,
scope : "post"
},
gotChipConveyor: {
title : "Got chip conveyor",
description: "Specifies whether to use a chip conveyor.",
group : "configuration",
type : "boolean",
value : false,
scope : "post"
},
maximumSpindleSpeed: {
title : "Max spindle speed",
description: "Defines the maximum spindle speed allowed by your machines.",
group : "configuration",
type : "integer",
range : [0, 999999999],
value : 6000,
scope : "post"
},
showSequenceNumbers: {
title : "Use sequence numbers",
description: "'Yes' outputs sequence numbers on each block, 'Only on tool change' outputs sequence numbers on tool change blocks only, and 'No' disables the output of sequence numbers.",
group : "formats",
type : "enum",
values : [
{title:"Yes", id:"true"},
{title:"No", id:"false"},
{title:"Only on tool change", id:"toolChange"}
],
value: "true",
order: 1,
scope: "post"
},
sequenceNumberStart: {
title : "Start sequence number",
description: "The number at which to start the sequence numbers.",
group : "formats",
type : "integer",
value : 10,
order : 2,
scope : "post"
},
sequenceNumberIncrement: {
title : "Sequence number increment",
description: "The amount by which the sequence number is incremented by in each block.",
group : "formats",
type : "integer",
value : 10,
order : 3,
scope : "post"
},
useRadius: {
title : "Radius arcs",
description: "If yes is selected, arcs are outputted using radius values rather than IJK.",
group : "preferences",
type : "boolean",
value : false,
scope : "post"
},
useCycles: {
title : "Use cycles",
description: "Specifies if canned drilling cycles should be used.",
group : "preferences",
type : "boolean",
value : true,
scope : "post"
},
optionalStop: {
title : "Optional stop",
description: "Outputs optional stop code during when necessary in the code.",
group : "preferences",
type : "boolean",
value : true,
scope : "post"
},
useParametricFeed: {
title : "Parametric feed",
description: "Specifies the feed value that should be output using a Q value.",
group : "preferences",
type : "boolean",
value : false,
scope : "post"
},
useTailStock: {
title : "Use tailstock",
description: "Specifies whether to use the tailstock or not.",
group : "configuration",
type : "boolean",
value : false,
scope : "post"
},
homePositionX: {
title : "G53 home position X",
description: "G53 X-axis home position.",
group : "homePositions",
type : "number",
value : 469,
scope : "post"
},
homePositionY: {
title : "G53 home position Y",
description: "G53 Y-axis home position.",
group : "homePositions",
type : "number",
value : -99,
scope : "post"
},
homePositionZ: {
title : "G53 home position Z",
description: "G53 Z-axis home position.",
group : "homePositions",
type : "number",
value : 660,
scope : "post"
},
homePositionSubZ: {
title : "G53 home position Z (secondary spindle)",
description: "G53 Z-axis home position for the secondary spindle.",
group : "homePositions",
type : "number",
value : 1019,
scope : "post"
},
useYAxisForDrilling: {
title : "Position in Y for axial drilling",
description: "Positions in Y for axial drilling options when it can instead of using the C-axis.",
group : "preferences",
type : "boolean",
value : false,
scope : "post"
},
separateWordsWithSpace: {
title : "Separate words with space",
description: "Adds spaces between words if 'yes' is selected.",
group : "formats",
type : "boolean",
value : true,
scope : "post"
},
showNotes: {
title : "Show notes",
description: "Writes operation notes as comments in the outputted code.",
group : "formats",
type : "boolean",
value : false,
scope : "post"
},
writeMachine: {
title : "Write machine",
description: "Output the machine settings in the header of the code.",
group : "formats",
type : "boolean",
value : false,
scope : "post"
},
writeTools: {
title : "Write tool list",
description: "Output a tool list in the header of the code.",
group : "formats",
type : "boolean",
value : false,
scope : "post"
},
toolAsName: {
title : "Tool as name",
description: "If enabled, the tool will be called with the tool description rather than the tool number.",
group : "preferences",
type : "boolean",
value : true,
scope : "post"
},
useShortestDirection: {
title : "Use shortest direction",
description: "Specifies that the shortest angular direction should be used.",
group : "multiAxis",
type : "boolean",
value : true,
scope : "post"
}
};
// wcs definiton
wcsDefinitions = {
useZeroOffset: false,
wcs : [
{name:"Standard", format:"G", range:[54, 57]},
{name:"Extended", format:"G", range:[505, 599]}
]
};
var singleLineCoolant = false; // specifies to output multiple coolant codes in one line rather than in separate lines
// samples:
// {id: COOLANT_THROUGH_TOOL, on: 88, off: 89}
// {id: COOLANT_THROUGH_TOOL, on: [8, 88], off: [9, 89]}
// {id: COOLANT_THROUGH_TOOL, turret1:{on: [8, 88], off:[9, 89]}, turret2:{on:88, off:89}}
// {id: COOLANT_THROUGH_TOOL, spindle1:{on: [8, 88], off:[9, 89]}, spindle2:{on:88, off:89}}
// {id: COOLANT_THROUGH_TOOL, spindle1t1:{on: [8, 88], off:[9, 89]}, spindle1t2:{on:88, off:89}}
// {id: COOLANT_THROUGH_TOOL, on: "M88 P3 (myComment)", off: "M89"}
var coolants = [
{id:COOLANT_FLOOD, on:107},
{id:COOLANT_MIST},
{id:COOLANT_THROUGH_TOOL, on:154},
{id:COOLANT_AIR},
{id:COOLANT_AIR_THROUGH_TOOL, on:122},
{id:COOLANT_SUCTION},
{id:COOLANT_FLOOD_MIST},
{id:COOLANT_FLOOD_THROUGH_TOOL},
{id:COOLANT_OFF, off:109}
];
var mainSpindleAxisName = ["C4", 4]; // axis name, axis number (number is used for eg. SETMS(VALUE));
var subSpindleAxisName = ["C3", 3]; // axis name, axis number (number is used for eg. SETMS(VALUE));
var liveToolSpindleAxisName = ["C1", 1]; // axis name, axis number (number is used for eg. SETMS(VALUE));
var gFormat = createFormat({prefix:"G", decimals:0});
var mFormat = createFormat({prefix:"M", decimals:0});
var dFormat = createFormat({prefix:"D", decimals:0});
var spatialFormat = createFormat({decimals:(unit == MM ? 3 : 4)});
var xFormat = createFormat({decimals:(unit == MM ? 3 : 4), scale:2}); // diameter mode & IS SCALING POLAR COORDINATES
var yFormat = createFormat({decimals:(unit == MM ? 3 : 4)});
var zFormat = createFormat({decimals:(unit == MM ? 3 : 4)});
var abcFormat = createFormat({decimals:3, scale:DEG});
var abcDirectFormat = createFormat({decimals:3, scale:DEG, cyclicLimit:Math.PI * 2, cyclicSign:1, prefix:"=DC(", suffix:")"});
var cFormat = createFormat({decimals:3, scale:DEG, cyclicLimit:Math.PI * 2, cyclicSign:1, prefix:"="});
var fpmFormat = createFormat({decimals:(unit == MM ? 2 : 3)});
var fprFormat = createFormat({decimals:(unit == MM ? 3 : 4), minimum:(unit == MM ? 0.001 : 0.0001)});
var feedFormat = fpmFormat;
var toolFormat = createFormat({decimals:0});
var rpmFormat = createFormat({decimals:0});
var secFormat = createFormat({decimals:3}); // seconds - range 0.001-99999.999
var taperFormat = createFormat({decimals:1, scale:DEG});
var integerFormat = createFormat({decimals:0});
var xOutput = createOutputVariable({prefix:"X"}, xFormat);
var yOutput = createOutputVariable({prefix:"Y"}, yFormat);
var zOutput = createOutputVariable({prefix:"Z"}, zFormat);
var aOutput = createOutputVariable({prefix:"A"}, abcFormat);
var bOutput = createOutputVariable({prefix:"B1="}, abcFormat);
var cOutput = createOutputVariable({prefix:mainSpindleAxisName[0]}, cFormat);
var feedOutput = createOutputVariable({prefix:"F"}, feedFormat);
var sOutput = createOutputVariable({control:CONTROL_FORCE}, rpmFormat);
var dOutput = createOutputVariable({}, dFormat);
// circular output
var iOutput = createOutputVariable({prefix:"I", control:CONTROL_FORCE}, spatialFormat);
var jOutput = createOutputVariable({prefix:"J", control:CONTROL_FORCE}, spatialFormat);
var kOutput = createOutputVariable({prefix:"K", control:CONTROL_FORCE}, spatialFormat);
var gMotionModal = createOutputVariable({}, gFormat); // modal group 1 // G0-G3, ...
var gPlaneModal = createOutputVariable({onchange:function () {gMotionModal.reset();}}, gFormat); // modal group 2 // G17-19
var gFeedModeModal = createOutputVariable({}, gFormat); // modal group 5 // G98-99
var gSpindleModeModal = createOutputVariable({}, gFormat); // modal group 5 // G96-97
var gAbsIncModal = createOutputVariable({}, gFormat); // modal group 3 // G90-91
var gUnitModal = createOutputVariable({}, gFormat); // modal group 6 // G20-21..
var cAxisBrakeModal = createOutputVariable({}, mFormat);
var tailStockModal = createOutputVariable({}, mFormat);
// fixed settings
var firstFeedParameter = 100;
var turret1GotYAxis = true;
var gotYAxis = turret1GotYAxis;
var yAxisMinimum = toPreciseUnit(gotYAxis ? -100 : 0, MM); // specifies the minimum range for the Y-axis
var yAxisMaximum = toPreciseUnit(gotYAxis ? 100 : 0, MM); // specifies the maximum range for the Y-axis
var xAxisMinimum;
var gotBAxis = true; // B-axis always requires customization to match the machine specific functions for doing rotations
var bAxisIsManual = false;
var gotMultiTurret = false; // specifies if the machine has several turrets
var gotPolarInterpolation = true; // specifies if the machine has XY polar interpolation (TRANSMIT) capabilities
var gotSecondarySpindle = false;
var gotDoorControl = false;
var gotBarFeeder = false;
var reverseAxes = false;
var WARNING_TURRET_UNSPECIFIED = 0;
var SPINDLE_MAIN = 0;
var SPINDLE_SUB = 1;
var SPINDLE_LIVE = 2;
// getSpindle parameters
var TOOL = false;
var PART = true;
// collected state
var sequenceNumber;
var currentWorkOffset;
var optionalSection = false;
var forceSpindleSpeed = false;
var activeMovements; // do not use by default
var currentFeedId;
var previousSpindle = SPINDLE_MAIN;
var activeSpindle = SPINDLE_MAIN;
var forcePolarCoordinates = false; // forces Polar coordinate output, activated by Action:usePolarCoordinates
var forcePolarInterpolation = false; // force Polar interpolation output, activated by Action:usePolarInterpolation
var bestABC = undefined;
var turret1GotBAxis; // for storing the initial state of the gotBAxis variable, when switching turret.
var lastSpindleMode = undefined;
var lastSpindleSpeed = 0;
var lastSpindleDirection = undefined;
var previousMaximumSpeed = 0;
var toolLengthOffset = 0;
var machineState = {
liveToolIsActive : undefined,
cAxisIsEngaged : undefined,
machiningDirection : undefined,
mainSpindleIsActive : undefined,
subSpindleIsActive : undefined,
mainSpindleBrakeIsActive : undefined,
subSpindleBrakeIsActive : undefined,
tailstockIsActive : undefined,
usePolarInterpolation : undefined,
usePolarCoordinates : undefined,
axialCenterDrilling : undefined,
currentBAxisOrientationTurning: new Vector(0, 0, 0),
mainChuckIsClamped : undefined,
subChuckIsClamped : undefined,
spindlesAreAttached : false,
spindlesAreSynchronized : false,
stockTransferIsActive : false,
cAxesAreSynchronized : false,
feedPerRevolution : undefined
};
/** G/M codes setup */
function getCode(code, spindle) {
switch (code) {
/*
case "PART_CATCHER_ON":
return mFormat.format(36);
case "PART_CATCHER_OFF":
return mFormat.format(37);
case "TAILSTOCK_ON":
machineState.tailstockIsActive = true;
return tailStockModal.format(21);
case "TAILSTOCK_OFF":
machineState.tailstockIsActive = false;
return tailStockModal.format(22);
*/
case "ENABLE_C_AXIS":
machineState.cAxisIsEngaged = true;
return (spindle == SPINDLE_MAIN) ? "L707(0)" : "L705(0)";
case "DISENABLE_C_AXIS":
machineState.cAxisIsEngaged = false;
return (spindle == SPINDLE_MAIN) ? "L708" : "L706";
case "POLAR_INTERPOLATION_ON":
return "TRANSMIT_S" + ((spindle == SPINDLE_MAIN) ? mainSpindleAxisName[1] : subSpindleAxisName[1]);
case "POLAR_INTERPOLATION_OFF":
return "TRANS_OFF";
case "STOP_SPINDLE":
switch (spindle) {
case SPINDLE_MAIN:
machineState.mainSpindleIsActive = false;
return mFormat.format(mainSpindleAxisName[1]) + "=" + spatialFormat.format(5);
case SPINDLE_LIVE:
machineState.liveToolIsActive = false;
return mFormat.format(liveToolSpindleAxisName[1]) + "=" + spatialFormat.format(5);
case SPINDLE_SUB:
machineState.subSpindleIsActive = false;
return mFormat.format(subSpindleAxisName[1]) + "=" + spatialFormat.format(5);
}
break;
case "START_SPINDLE_CW":
switch (spindle) {
case SPINDLE_MAIN:
machineState.mainSpindleIsActive = true;
return mFormat.format(mainSpindleAxisName[1]) + "=" + spatialFormat.format(3);
case SPINDLE_LIVE:
machineState.liveToolIsActive = true;
return mFormat.format(liveToolSpindleAxisName[1]) + "=" + spatialFormat.format(3);
case SPINDLE_SUB:
machineState.subSpindleIsActive = true;
return mFormat.format(subSpindleAxisName[1]) + "=" + spatialFormat.format(3);
}
break;
case "START_SPINDLE_CCW":
switch (spindle) {
case SPINDLE_MAIN:
machineState.mainSpindleIsActive = true;
return mFormat.format(mainSpindleAxisName[1]) + "=" + spatialFormat.format(4);
case SPINDLE_LIVE:
machineState.liveToolIsActive = true;
return mFormat.format(liveToolSpindleAxisName[1]) + "=" + spatialFormat.format(4);
case SPINDLE_SUB:
machineState.subSpindleIsActive = true;
return mFormat.format(subSpindleAxisName[1]) + "=" + spatialFormat.format(4);
}
break;
case "FEED_MODE_UNIT_REV":
machineState.feedPerRevolution = true;
return gFeedModeModal.format(95);
case "FEED_MODE_UNIT_MIN":
machineState.feedPerRevolution = false;
return gFeedModeModal.format(94);
case "CONSTANT_SURFACE_SPEED_ON":
return gSpindleModeModal.format(96);
case "CONSTANT_SURFACE_SPEED_OFF":
return gSpindleModeModal.format(97);
case "LOCK_MULTI_AXIS":
switch (spindle) {
case SPINDLE_MAIN:
machineState.mainSpindleBrakeIsActive = true;
return cAxisBrakeModal.format(412);
case SPINDLE_SUB:
machineState.subSpindleBrakeIsActive = true;
return cAxisBrakeModal.format(312);
}
break;
case "UNLOCK_MULTI_AXIS":
switch (spindle) {
case SPINDLE_MAIN:
machineState.mainSpindleBrakeIsActive = false;
return cAxisBrakeModal.format(413);
case SPINDLE_SUB:
machineState.subSpindleBrakeIsActive = false;
return cAxisBrakeModal.format(313);
}
break;
case "CLAMP_CHUCK":
return mFormat.format(spindle == SPINDLE_MAIN ? 437 : 336);
case "UNCLAMP_CHUCK":
return mFormat.format(spindle == SPINDLE_MAIN ? 433 : 333);
case "SPINDLE_SYNCHRONIZATION_ON":
machineState.spindleSynchronizationIsActive = true;
return "L726";
case "SPINDLE_SYNCHRONIZATION_OFF":
machineState.spindleSynchronizationIsActive = false;
return "L727";
/*
case "START_CHIP_TRANSPORT":
return mFormat.format(31);
case "STOP_CHIP_TRANSPORT":
return mFormat.format(33);
case "OPEN_DOOR":
return mFormat.format(85);
case "CLOSE_DOOR":
return mFormat.format(86);
*/
/*
case AIR_BLAST_ON:
return mFormat.format(spindle == SPINDLE_MAIN ? 12 : 112);
case AIR_BLAST_OFF:
return mFormat.format(spindle == SPINDLE_MAIN ? 13 : 113);
*/
default:
error(localize("Command " + code + " is not defined."));
}
return 0;
}
/** Write WCS. */
function writeWCS(section) {
if (section.workOffset != currentWorkOffset) {
writeBlock(section.wcs);
currentWorkOffset = section.workOffset;
}
}
/** Returns the desired tolerance for the given section in MM.*/
function getTolerance() {
var t1 = toPreciseUnit(tolerance, MM);
var t2 = getParameter("operation:tolerance", t1);
t1 = t1 > 0 ? Math.min(t1, t2) : t2;
return unit == IN ? t1 * 25.4 : t1;
}
/**
Writes the specified block.
*/
function writeBlock() {
if (getProperty("showSequenceNumbers") == "true") {
if (sequenceNumber > 99999) {
sequenceNumber = getProperty("sequenceNumberStart");
}
if (optionalSection) {
var text = formatWords(arguments);
if (text) {
writeWords("/", "N" + sequenceNumber, text);
}
} else {
writeWords2("N" + sequenceNumber, arguments);
}
sequenceNumber += getProperty("sequenceNumberIncrement");
} else {
if (optionalSection) {
writeWords2("/", arguments);
} else {
writeWords(arguments);
}
}
}
function formatComment(text) {
return "; " + String(text);
}
/**
Writes the specified block - used for tool changes only.
*/
function writeToolBlock() {
var show = getProperty("showSequenceNumbers");
setProperty("showSequenceNumbers", (show == "true" || show == "toolChange") ? "true" : "false");
writeBlock(arguments);
setProperty("showSequenceNumbers", show);
}
/**
Output a comment.
*/
function writeComment(text) {
writeln(formatComment(text));
}
function getB(abc, section) {
if (section.spindle == SPINDLE_PRIMARY) {
return abc.y;
} else {
return Math.PI - abc.y;
}
}
function activateMachine(section) {
// TCP setting
operationSupportsTCP = section.isMultiAxis();
// handle multiple turrets
var turret = 1;
if (gotMultiTurret) {
turret = section.getTool().turret;
if (turret == 0) {
warningOnce(localize("Turret has not been specified. Using Turret 1 as default."), WARNING_TURRET_UNSPECIFIED);
turret = 1; // upper turret as default
}
turret = turret == undefined ? 1 : turret;
switch (turret) {
case 1:
gotYAxis = turret1GotYAxis;
gotBAxis = turret1GotBAxis;
break;
case 2:
gotYAxis = turret2GotYAxis;
gotBAxis = false;
break;
default:
error(subst(localize("Turret %1 is not supported"), turret));
return turret;
}
} else {
gotYAxis = turret1GotYAxis;
}
// disable unsupported rotary axes output
if (!gotYAxis) {
yOutput.disable();
}
aOutput.disable();
// define machine configuration
var bAxis;
var cAxis;
if (section.getSpindle() == SPINDLE_PRIMARY) {
bAxis = createAxis({coordinate:1, table:false, axis:[0, -1, 0], range:[-0.001, 90.001], preference:0, tcp:true});
cAxis = createAxis({coordinate:2, table:true, axis:[0, 0, 1], range:[0, 360], cyclic:true, preference:0, tcp:operationSupportsTCP});
} else {
bAxis = createAxis({coordinate:1, table:false, axis:[0, 1, 0], range:[-0.001, 180.001], preference:0, tcp:true});
cAxis = createAxis({coordinate:2, table:true, axis:[0, 0, -1], range:[0, 360], cyclic:true, preference:0, tcp:operationSupportsTCP});
}
if (gotBAxis) {
machineConfiguration = new MachineConfiguration(bAxis, cAxis);
bOutput.enable();
} else {
machineConfiguration = new MachineConfiguration(cAxis);
bOutput.disable();
}
// define spindle axis
if (!gotBAxis || bAxisIsManual || (turret == 2)) {
if ((getMachiningDirection(section) == MACHINING_DIRECTION_AXIAL) && !section.isMultiAxis()) {
machineConfiguration.setSpindleAxis(new Vector(0, 0, 1));
} else {
machineConfiguration.setSpindleAxis(new Vector(1, 0, 0));
}
} else {
machineConfiguration.setSpindleAxis(new Vector(0, 0, 1)); // set the spindle axis depending on B0 orientation
}
// define linear axes limits
var xAxisMaximum = 10000; // don't check X-axis maximum limit
yAxisMinimum = gotYAxis ? yAxisMinimum : 0;
yAxisMaximum = gotYAxis ? yAxisMaximum : 0;
var xAxis = createAxis({actuator:"linear", coordinate:0, table:true, axis:[1, 0, 0], range:[xAxisMinimum, xAxisMaximum]});
var yAxis = createAxis({actuator:"linear", coordinate:1, table:true, axis:[0, 1, 0], range:[yAxisMinimum, yAxisMaximum]});
var zAxis = createAxis({actuator:"linear", coordinate:2, table:true, axis:[0, 0, 1], range:[-100000, 100000]});
machineConfiguration.setAxisX(xAxis);
machineConfiguration.setAxisY(yAxis);
machineConfiguration.setAxisZ(zAxis);
// enable retract/reconfigure
safeRetractDistance = (unit == IN) ? 1 : 25; // additional distance to retract out of stock, can be overridden with a property
safeRetractFeed = (unit == IN) ? 20 : 500; // retract feed rate
safePlungeFeed = (unit == IN) ? 10 : 250; // plunge feed rate
var stockExpansion = new Vector(toPreciseUnit(0.1, IN), toPreciseUnit(0.1, IN), toPreciseUnit(0.1, IN)); // expand stock XYZ values
machineConfiguration.enableMachineRewinds();
machineConfiguration.setSafeRetractDistance(safeRetractDistance);
machineConfiguration.setSafeRetractFeedrate(safeRetractFeed);
machineConfiguration.setSafePlungeFeedrate(safePlungeFeed);
machineConfiguration.setRewindStockExpansion(stockExpansion);
// multi-axis feedrates
machineConfiguration.setMultiAxisFeedrate(
operationSupportsTCP ? FEED_FPM : FEED_DPM, // FEED_INVERSE_TIME,
99999, // maximum output value for dpm feed rates
DPM_COMBINATION, // INVERSE_MINUTES/INVERSE_SECONDS or DPM_COMBINATION/DPM_STANDARD
0.5, // tolerance to determine when the DPM feed has changed
unit == MM ? 1.0 : 1.0 // ratio of rotary accuracy to linear accuracy for DPM calculations
);
var axes = [machineConfiguration.getAxisU(), machineConfiguration.getAxisV(), machineConfiguration.getAxisW()];
if (axes.some(function(axis) {return axis.isEnabled() && axis.isTCPEnabled();})) {
bufferRotaryMoves = false; // disable bufferRotaryMoves if TCP is enabled on any rotary axis
}
machineConfiguration.setVendor("DMG MORI");
machineConfiguration.setModel("Ctx Beta 800");
setMachineConfiguration(machineConfiguration);
if (section.isMultiAxis()) {
section.optimizeMachineAnglesByMachine(machineConfiguration, OPTIMIZE_AXIS);
}
return turret;
}
function onOpen() {
if (getProperty("useRadius")) {
maximumCircularSweep = toRad(90); // avoid potential center calculation errors for CNC
}
xAxisMinimum = getProperty("xAxisMinimum");
// define machine
turret1GotBAxis = gotBAxis;
activeTurret = activateMachine(getSection(0));
if (highFeedrate <= 0) {
error(localize("You must set 'highFeedrate' because axes are not synchronized for rapid traversal."));
return;
}
if (!getProperty("separateWordsWithSpace")) {
setWordSeparator("");
}
sequenceNumber = getProperty("sequenceNumberStart");
if (programName) {
writeln("; %_N_" + translateText(String(programName).toUpperCase(), " ", "_") + "_MPF");
if (programComment) {
writeComment(programComment);
}
} else {
error(localize("Program name has not been specified."));
return;
}
var usesPrimarySpindle = false;
var usesSecondarySpindle = false;
for (var i = 0; i < getNumberOfSections(); ++i) {
var section = getSection(i);
switch (section.spindle) {
case SPINDLE_PRIMARY:
usesPrimarySpindle = true;
break;
case SPINDLE_SECONDARY:
usesSecondarySpindle = true;
break;
}
}
if (usesPrimarySpindle) {
writeComment("MAIN SPINDLE");
} else if (usesSecondarySpindle) {
writeComment("SUB SPINDLE");
}
if (usesPrimarySpindle && usesSecondarySpindle) {
error(localize("You cannot output programs for the main spindle and sub spindle in just one file."));
return;
}
// dump machine configuration
var vendor = machineConfiguration.getVendor();
var model = machineConfiguration.getModel();
var mDescription = machineConfiguration.getDescription();
if (getProperty("writeMachine") && (vendor || model || mDescription)) {
writeComment(localize("Machine"));
if (vendor) {
writeComment(" " + localize("vendor") + ": " + vendor);
}
if (model) {
writeComment(" " + localize("model") + ": " + model);
}
if (mDescription) {
writeComment(" " + localize("description") + ": " + mDescription);
}
}
// dump tool information
if (getProperty("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" + (getProperty("toolAsName") ? "=" + "\"" + (tool.description.toUpperCase()) + "\"" : toolFormat.format(tool.number)) + " " +
(tool.diameter != 0 ? "D=" + spatialFormat.format(tool.diameter) + " " : "") +
(tool.isTurningTool() ? localize("NR") + "=" + spatialFormat.format(tool.noseRadius) : localize("CR") + "=" + spatialFormat.format(tool.cornerRadius)) +
(tool.taperAngle > 0 && (tool.taperAngle < Math.PI) ? " " + localize("TAPER") + "=" + taperFormat.format(tool.taperAngle) + localize("deg") : "") +
(zRanges[tool.number] ? " - " + localize("ZMIN") + "=" + spatialFormat.format(zRanges[tool.number].getMinimum()) : "") +
" - " + localize(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 (spatialFormat.areDifferent(tooli.diameter, toolj.diameter) ||
spatialFormat.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;
}
}
}
}
}
if (true) { // stock - workpiece
var workpiece = getWorkpiece();
var delta = Vector.diff(workpiece.upper, workpiece.lower);
if (delta.isNonZero()) {
var spindle = getSection(0).getSpindle() == SPINDLE_PRIMARY ? 192 : 4288;
var XA = workpiece.upper.x; // diameter
var ZA = workpiece.upper.z; // stock offset Z
var ZI = workpiece.lower.z; // stock Z
var ZB = ZI + toPreciseUnit(1, MM); // stock in chuck
writeBlock(
"WORKPIECE" + "(" + ",,," + "\"" + "CYLINDER" + "\"" + "," + spindle + "," + zFormat.format(ZA) + "," + zFormat.format(ZI) +
"," + spatialFormat.format(ZB) + "," + xFormat.format(XA) + ")"
);
}
}
writeBlock("DIAMON");
writeBlock("TRANS_OFF");
writeBlock("TRANS");
writeBlock("ROT");
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(getCode("FEED_MODE_UNIT_MIN"), gPlaneModal.format(18));
writeBlock(gUnitModal.format((unit == IN) ? 70 : 71));
if (usesPrimarySpindle) {
writeBlock("SETMS(4)");
writeBlock("G26 S4=" + rpmFormat.format(getProperty("maximumSpindleSpeed")) + " ;MAXIMUM SPINDLE SPEED MAINSPINDLE");
writeBlock("STOPRE");
}
if (gotSecondarySpindle && usesSecondarySpindle) {
writeBlock("SETMS(3)");
writeBlock("G26 S3=" + rpmFormat.format(getProperty("maximumSpindleSpeed")) + " ;MAXIMUM SPINDLE SPEED SUBSPINDLE");
}
writeBlock("LIMS[" + (usesPrimarySpindle ? mainSpindleAxisName[1] : subSpindleAxisName[1]) + "]=" + rpmFormat.format(getProperty("maximumSpindleSpeed")));
if (gotSecondarySpindle) {
writeBlock(gFormat.format(153), gMotionModal.format(0), "Z3=" + spatialFormat.format(getProperty("homePositionSubZ")), dFormat.format(0)); // retract subspindle
}
sOutput.setCurrent(-1);
if (getProperty("gotChipConveyor")) {
onCommand(COMMAND_START_CHIP_TRANSPORT);
}
writeRetract(getSection(0), true);
if (gotSecondarySpindle) {
// retract Sub Spindle if applicable
}
}
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();
}
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();
}
function forceModals() {
if (arguments.length == 0) { // reset all modal variables listed below
if (typeof gMotionModal != "undefined") {
gMotionModal.reset();
}
if (typeof gPlaneModal != "undefined") {
gPlaneModal.reset();
}
if (typeof gAbsIncModal != "undefined") {
gAbsIncModal.reset();
}
if (typeof gFeedModeModal != "undefined") {
gFeedModeModal.reset();
}
} else {
for (var i in arguments) {
arguments[i].reset(); // only reset the modal variable passed to this function
}
}
}
function FeedContext(id, description, feed) {
this.id = id;
this.description = description;
this.feed = feed;
}
function formatFeedMode(mode) {
var fMode = (mode == FEED_PER_REVOLUTION || tapping) ? getCode("FEED_MODE_UNIT_REV") : getCode("FEED_MODE_UNIT_MIN");
if (fMode) {
feedFormat = mode == FEED_PER_REVOLUTION ? fprFormat : fpmFormat;
feedOutput.setFormat(feedFormat);
}
return fMode;
}
function getFeed(f) {
if (currentSection.feedMode != FEED_PER_REVOLUTION && machineState.feedPerRevolution) {
f /= spindleSpeed;
}
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=R" + (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 feedPerRev = currentSection.feedMode == FEED_PER_REVOLUTION;
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"), feedPerRev ? getParameter("operation:tool_feedCuttingRel") : getParameter("operation:tool_feedCutting"));
activeFeeds.push(feedContext);
activeMovements[MOVEMENT_CUTTING] = feedContext;
if (!hasParameter("operation:tool_feedTransition")) {
activeMovements[MOVEMENT_LINK_TRANSITION] = feedContext;
}
activeMovements[MOVEMENT_EXTENDED] = feedContext;
}
++id;
if (movements & (1 << MOVEMENT_PREDRILL)) {
feedContext = new FeedContext(id, localize("Predrilling"), feedPerRev ? getParameter("operation:tool_feedCuttingRel") : getParameter("operation:tool_feedCutting"));
activeMovements[MOVEMENT_PREDRILL] = feedContext;
activeFeeds.push(feedContext);
}
++id;
}
if (hasParameter("operation:finishFeedrate")) {
if (movements & (1 << MOVEMENT_FINISH_CUTTING)) {
var finishFeedrateRel;
if (hasParameter("operation:finishFeedrateRel")) {
finishFeedrateRel = getParameter("operation:finishFeedrateRel");
} else if (hasParameter("operation:finishFeedratePerRevolution")) {
finishFeedrateRel = getParameter("operation:finishFeedratePerRevolution");
}
var feedContext = new FeedContext(id, localize("Finish"), feedPerRev ? finishFeedrateRel : 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"), feedPerRev ? getParameter("operation:tool_feedCuttingRel") : 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"), feedPerRev ? getParameter("operation:tool_feedEntryRel") : 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"), feedPerRev ? getParameter("operation:tool_feedExitRel") : 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"), feedPerRev ? getParameter("operation:noEngagementFeedrateRel") : 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(
feedPerRev ? getParameter("operation:tool_feedCuttingRel") : getParameter("operation:tool_feedCutting"),
feedPerRev ? getParameter("operation:tool_feedEntryRel") : getParameter("operation:tool_feedEntry"),
feedPerRev ? getParameter("operation:tool_feedExitRel") : 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"), feedPerRev ? getParameter("operation:reducedFeedrateRel") : 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"), feedPerRev ? getParameter("operation:tool_feedRampRel") : 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"), feedPerRev ? getParameter("operation:tool_feedPlungeRel") : getParameter("operation:tool_feedPlunge"));
activeFeeds.push(feedContext);
activeMovements[MOVEMENT_PLUNGE] = feedContext;
}
++id;
}
if (true) { // high feed
if ((movements & (1 << MOVEMENT_HIGH_FEED)) || (highFeedMapping != HIGH_FEED_NO_MAPPING)) {
var feed;
if (hasParameter("operation:highFeedrateMode") && getParameter("operation:highFeedrateMode") != "disabled") {
feed = getParameter("operation:highFeedrate");
} else {
feed = this.highFeedrate;
}
var feedContext = new FeedContext(id, localize("High Feed"), feed);
activeFeeds.push(feedContext);
activeMovements[MOVEMENT_HIGH_FEED] = feedContext;
activeMovements[MOVEMENT_RAPID] = feedContext;
}
++id;
}
if (hasParameter("operation:tool_feedTransition")) {
if (movements & (1 << MOVEMENT_LINK_TRANSITION)) {
var feedContext = new FeedContext(id, localize("Transition"), getParameter("operation:tool_feedTransition"));
activeFeeds.push(feedContext);
activeMovements[MOVEMENT_LINK_TRANSITION] = feedContext;
}
++id;
}
for (var i = 0; i < activeFeeds.length; ++i) {
var feedContext = activeFeeds[i];
writeBlock("R" + (firstFeedParameter + feedContext.id) + "=" + feedFormat.format(feedContext.feed), formatComment(feedContext.description));
}
}
var currentWorkPlaneABC = undefined;
function forceWorkPlane() {
currentWorkPlaneABC = undefined;
}
function setWorkPlane(abc) {
// milling only
forceWorkPlane(); // we always want to output the workPlane
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);
gMotionModal.reset();
writeBlock(
gMotionModal.format(0),
conditional(machineConfiguration.isMachineCoordinate(0), aOutput.format(abc.x)),
conditional(machineConfiguration.isMachineCoordinate(1), bOutput.format(getB(abc, currentSection))),
conditional(machineConfiguration.isMachineCoordinate(2) && machineState.cAxisIsEngaged, cOutput.format(abc.z))
);
writeBlock("ROT");
writeBlock("AROT Y" + abcFormat.format(abc.y));
if (!currentSection.isMultiAxis() && !machineState.usePolarInterpolation && !machineState.usePolarCoordinates) {
if (machineState.cAxisIsEngaged) {
onCommand(COMMAND_LOCK_MULTI_AXIS);
}
}
currentWorkPlaneABC = new Vector(abc);
setCurrentDirection(abc);
}
function getBestABC(section) {
// try workplane orientation
var abc = section.getABCByPreference(machineConfiguration, section.workPlane, getCurrentDirection(), C, PREFER_CLOSEST, ENABLE_ALL);
if (section.doesToolpathFitWithinLimits(machineConfiguration, abc)) {
return abc;
}
var currentABC = new Vector(abc);
// quadrant boundaries are the preferred solution
var quadrants = [0, 90, 180, 270];
for (var i = 0; i < quadrants.length; ++i) {
abc.setZ(toRad(quadrants[i]));
if (section.doesToolpathFitWithinLimits(machineConfiguration, abc)) {
abc = machineConfiguration.remapToABC(abc, currentABC);
abc = machineConfiguration.remapABC(abc);
return abc;
}
}
// attempt to find soultion at fixed angle rotations
var maxTries = 60; // every 6 degrees
var delta = (Math.PI * 2) / maxTries;
var angle = delta;
for (var i = 0; i < (maxTries - 1); i++) {
abc.setZ(angle);
if (section.doesToolpathFitWithinLimits(machineConfiguration, abc)) {
abc = machineConfiguration.remapToABC(abc, currentABC);
abc = machineConfiguration.remapABC(abc);
return abc;
}
angle += delta;
}
return abc;
}
function getWorkPlaneMachineABC(section, workPlane) {
var W = workPlane; // map to global frame
var abc;
if (machineState.isTurningOperation && gotBAxis) {
var both = machineConfiguration.getABCByDirectionBoth(workPlane.forward);
abc = both[0];
if (both[0].z != 0) {
abc = both[1];
}
} else {
abc = bestABC ? bestABC :
section.getABCByPreference(machineConfiguration, W, getCurrentDirection(), C, PREFER_CLOSEST, ENABLE_RESET);
}
var direction = machineConfiguration.getDirection(abc);
if (!isSameDirection(direction, W.forward)) {
error(localize("Orientation not supported."));
}
if (machineState.isTurningOperation && gotBAxis && !bAxisIsManual) { // remapABC can change the B-axis orientation
if (abc.z != 0) {
error(localize("Could not calculate a B-axis turning angle within the range of the machine."));
}
}
var tcp = false;
if (tcp) {
setRotation(W); // TCP mode
} else {
var O = machineConfiguration.getOrientation(abc);
var R = machineConfiguration.getRemainingOrientation(abc, W);
setRotation(R);
}
if (machineState.usePolarCoordinates) { // set C-axis to initial polar coordinate position
var initialPosition = getFramePosition(section.getInitialPosition());
var polarPosition = getPolarCoordinates(initialPosition, abc);
abc.setZ(polarPosition.second.z);
}
return abc;
}
var bAxisOrientationTurning = new Vector(0, 0, 0);
function setSpindleOrientationTurning() {
var J; // cutter orientation
var R; // cutting quadrant
var leftHandTool = (hasParameter("operation:tool_hand") && (getParameter("operation:tool_hand") == "L" || getParameter("operation:tool_holderType") == 0));
if (hasParameter("operation:machineInside")) {
if (getParameter("operation:machineInside") == 0) {
R = currentSection.spindle == SPINDLE_PRIMARY ? 3 : 4;
} else {
R = currentSection.spindle == SPINDLE_PRIMARY ? 2 : 1;
}
} else {
if ((hasParameter("operation-strategy") && getParameter("operation-strategy") == "turningFace") ||
(hasParameter("operation-strategy") && getParameter("operation-strategy") == "turningPart")) {
R = currentSection.spindle == SPINDLE_PRIMARY ? 3 : 4;
} else {
error(subst(localize("Failed to identify spindle orientation for operation \"%1\"."), getOperationComment()));
return;
}
}
if (leftHandTool) {
J = currentSection.spindle == SPINDLE_PRIMARY ? 2 : 1;
} else {
J = currentSection.spindle == SPINDLE_PRIMARY ? 1 : 2;
}
writeComment("Post processor is not customized, add code for cutter orientation and cutting quadrant here if needed.");
}
function getBAxisOrientationTurning(section) {
var toolAngle = hasParameter("operation:tool_angle") ? getParameter("operation:tool_angle") : 0;
var toolOrientation = toRad(Math.round(toDeg(section.toolOrientation) * 1000) / 1000); //round to 0.001 degrees to avoid floating point noise
if (toolAngle && toolOrientation != 0) {
// error(localize("You cannot use tool angle and tool orientation together in operation " + "\"" + (getParameter("operation-comment")) + "\""));
}
var angle = toRad(toolAngle) + toolOrientation;
var axis = new Vector(0, 1, 0);
var mappedAngle = (currentSection.spindle == SPINDLE_PRIMARY ? (Math.PI / 2 - angle) : (Math.PI / 2 - angle));
var mappedWorkplane = new Matrix(axis, mappedAngle);
var abc = getWorkPlaneMachineABC(section, mappedWorkplane);
return abc;
}
function getSpindle(whichSpindle) {
// safety conditions
if (getNumberOfSections() == 0) {
return SPINDLE_MAIN;
}
if (getCurrentSectionId() < 0) {
if (machineState.liveToolIsActive && (whichSpindle == TOOL)) {
return SPINDLE_LIVE;
} else {
return getSection(getNumberOfSections() - 1).spindle;
}
}
function getSecondarySpindle() {
var spindle = getSpindle(PART);
return (spindle == SPINDLE_MAIN) ? SPINDLE_SUB : SPINDLE_MAIN;
}
// Turning is active or calling routine requested which spindle part is loaded into
if (machineState.isTurningOperation || machineState.axialCenterDrilling || (whichSpindle == PART)) {
return currentSection.spindle;
//Milling is active
} else {
return SPINDLE_LIVE;
}
}
/** Invert YZC axes for the sub-spindle. */
function invertAxes(activate, polarMode) {
var scaleValue = reverseAxes ? -1 : 1;
var yAxisPrefix = polarMode ? "Y" : "Y";
var yIsEnabled = yOutput.isEnabled();
yFormat.setScale(activate ? scaleValue : 1);
yOutput.setFormat(yFormat);
yOutput.setPrefix(yAxisPrefix);
cOutput.setFormat(getProperty("useShortestDirection") ? abcDirectFormat : cFormat);
cOutput.setPrefix(activate ? subSpindleAxisName[0] : mainSpindleAxisName[0]);
if (!yIsEnabled) {
yOutput.disable();
}
jOutput.setFormat(yFormat);
}
/** determines if the axes in the given plane are mirrored */
function isMirrored(plane) {
plane = plane == -1 ? getCompensationPlane(getCurrentDirection(), false, false) : plane;
switch (plane) {
case PLANE_XY:
if ((xFormat.getScale() * yFormat.getScale()) < 0) {
return true;
}
break;
case PLANE_YZ:
if ((yFormat.getScale() * zFormat.getScale()) < 0) {
return true;
}
break;
case PLANE_ZX:
if ((zFormat.getScale() * xFormat.getScale()) < 0) {
return true;
}
break;
}
return false;
}
function isPerpto(a, b) {
return Math.abs(Vector.dot(a, b)) < (1e-7);
}
function onSectionSpecialCycle() {
if (!isFirstSection()) {
activateMachine(currentSection);
}
}
function onSection() {
// Detect machine configuration
var currentTurret = isFirstSection() ? activeTurret : activateMachine(currentSection);
// Define Machining modes
tapping = isTappingCycle();
var forceSectionRestart = optionalSection && !currentSection.isOptional();
optionalSection = currentSection.isOptional();
bestABC = undefined;
setCurrentDirection(isFirstSection() ? new Vector(0, 0, 0) : getCurrentDirection());
machineState.isTurningOperation = (currentSection.getType() == TYPE_TURNING);
if (machineState.isTurningOperation && gotBAxis) {
bAxisOrientationTurning = getBAxisOrientationTurning(currentSection);
}
var insertToolCall = isToolChangeNeeded("number", "compensationOffset", "diameterOffset", "lengthOffset") || forceSectionRestart;
var newWorkOffset = isNewWorkOffset() || forceSectionRestart;
var newWorkPlane = isNewWorkPlane() || forceSectionRestart ||
(machineState.isTurningOperation &&
abcFormat.areDifferent(bAxisOrientationTurning.x, machineState.currentBAxisOrientationTurning.x) ||
abcFormat.areDifferent(bAxisOrientationTurning.y, machineState.currentBAxisOrientationTurning.y) ||
abcFormat.areDifferent(bAxisOrientationTurning.z, machineState.currentBAxisOrientationTurning.z));
var retracted = false; // specifies that the tool has been retracted to the safe plane
updateMachiningMode(currentSection); // sets the needed machining mode to machineState (usePolarInterpolation, usePolarCoordinates, axialCenterDrilling)
if (getProperty("toolAsName") && !tool.description) {
if (hasParameter("operation-comment")) {
error(localize("Tool description is empty in operation " + "\"" + (getParameter("operation-comment")) + "\""));
} else {
error(localize("Tool description is empty."));
}
return;
}
if (insertToolCall || newSpindle || newWorkOffset || newWorkPlane && !currentSection.isPatterned()) {
retracted = true;
if (!isFirstSection()) {
if (insertToolCall) {
onCommand(COMMAND_COOLANT_OFF);
}
// retract to safe plane
writeRetract(currentSection, true); // retract in X,Y,Z
}
}
// Get the active spindle
var newSpindle = true;
var tempSpindle = getSpindle(TOOL);
if (isFirstSection()) {
previousSpindle = tempSpindle;
}
newSpindle = tempSpindle != previousSpindle;
// End the previous section if a new tool is selected
if (!isFirstSection() && (newSpindle || (insertToolCall && previousSpindle == SPINDLE_LIVE))) {
writeBlock(getCode("STOP_SPINDLE", previousSpindle));
}
/*
if (machineState.isTurningOperation || machineState.axialCenterDrilling) {
if (previousSpindle == SPINDLE_LIVE) {
writeBlock(getCode("STOP_SPINDLE", SPINDLE_LIVE));
}
} else {
writeBlock(getCode("STOP_SPINDLE", previousSpindle));
}
*/
writeln("");
if (hasParameter("operation-comment")) {
var comment = getParameter("operation-comment");
if (comment) {
writeBlock("MSG (" + "\"" + formatComment(comment) + "\"" + ")");
}
}
// invert axes for secondary spindle
invertAxes(getSpindle(PART) == SPINDLE_SUB, false); // polar mode has not been enabled yet
var sledAssign;
switch (getSpindleCode(currentSection)) {
case 1:
sledAssign = (currentSection.spindle == SPINDLE_PRIMARY) ? mFormat.format(814) : mFormat.format(813);
break;
case 2:
sledAssign = mFormat.format(814);
break;
case 3:
sledAssign = mFormat.format(813);
break;
case 4:
sledAssign = mFormat.format(814);
break;
default:
return;
}
if (getProperty("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);
}
}
}
}
gPlaneModal.reset();
switch (machineState.machiningDirection) {
case MACHINING_DIRECTION_AXIAL:
writeBlock(gPlaneModal.format((currentSection.getType() == TYPE_TURNING) ? 18 : 17), sledAssign); // AXIAL
break;
case MACHINING_DIRECTION_RADIAL:
if (gotBAxis) {
writeBlock(gPlaneModal.format((currentSection.getType() == TYPE_TURNING) ? 18 : 17), sledAssign);
} else {
writeBlock(gPlaneModal.format(19)); // RADIAL
}
break;
case MACHINING_DIRECTION_INDEXING:
writeBlock(gPlaneModal.format(17), sledAssign); // INDEXING
break;
default:
error(subst(localize("Unsupported machining direction for operation " + "\"" + "%1" + "\"" + "."), getOperationComment()));
return;
}
if (machineState.isTurningOperation) {
writeBlock("DIAMON");
writeBlock("ROT");
xFormat.setScale(2); // diameter mode
} else {
writeBlock("DIAMOF");
xFormat.setScale(1); // radius mode
}
xOutput.setFormat(xFormat);
xOutput.reset();
if (insertToolCall) {
forceWorkPlane();
retracted = true;
if (!isFirstSection() && getProperty("optionalStop")) {
onCommand(COMMAND_OPTIONAL_STOP);
}
if (tool.number > 99) {
warning(localize("Tool number exceeds maximum value."));
}
var compensationOffset = tool.isTurningTool() ? tool.compensationOffset : tool.lengthOffset;
if (compensationOffset > 99) {
error(localize("Compensation offset is out of range."));
return;
}
toolLengthOffset = 1; // optional, use tool.lengthOffset instead
if (toolLengthOffset > 99) {
error(localize("Length offset out of range."));
return;
}
writeToolBlock("T" + (getProperty("toolAsName") ? "=" + "\"" + (tool.description) + "\"" : toolFormat.format(tool.number)));
if (tool.comment) {
writeComment(tool.comment);
}
var showToolZMin = false;
if (showToolZMin && (currentSection.getType() == TYPE_MILLING)) {
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());
}
}
}
var abc;
if (machineConfiguration.isMultiAxisConfiguration()) {
if (machineState.isTurningOperation) {
if (gotBAxis) {
cancelTransformation();
// handle B-axis support for turning operations here
abc = bAxisOrientationTurning;
//setSpindleOrientationTurning();
}
} else {
if (currentSection.isMultiAxis()) {
forceWorkPlane();
cancelTransformation();
onCommand(COMMAND_UNLOCK_MULTI_AXIS);
abc = currentSection.getInitialToolAxisABC();
} else {
abc = getWorkPlaneMachineABC(currentSection, currentSection.workPlane);
}
}
} else { // pure 3D
var remaining = currentSection.workPlane;
if (!isSameDirection(remaining.forward, new Vector(0, 0, 1))) {
error(localize("Tool orientation is not supported by the CNC machine."));
return;
}
setRotation(remaining);
}
var neutralHandTool = hasParameter("operation:tool_hand") && (getParameter("operation:tool_hand") == "N");
var compensationOffset = tool.isTurningTool() ? tool.compensationOffset : 1; // optional, use tool.lengthOffset instead
var primarySpindle = currentSection.spindle == SPINDLE_PRIMARY;
var P1 = compensationOffset;
var P2 = 0; // indexing shortest way
var P3 = 0;
var P4 = (tool.isTurningTool() || !tool.isLiveTool() || machineState.axialCenterDrilling) ? 2 : 1; // toolType, 1 = live tool, 2 = turning tool
var P5 = currentSection.spindle == SPINDLE_PRIMARY ? abcFormat.format(abc.y) : abcFormat.format(getB(abc, currentSection)); // B-axis angle
var P6;
if (tool.isTurningTool()) { // turning
switch (compensationOffset) {
case 1: // D1
if (primarySpindle) {
P6 = neutralHandTool ? (tool.clockwise ? 0 : 180) : (tool.clockwise ? 180 : 0); // neutral : left/right hand tools
} else {
P6 = neutralHandTool ? (tool.clockwise ? 180 : 0) : (tool.clockwise ? 0 : 180); // neutral : left/right hand tools
}
break;
case 2: // D2 120deg
if (primarySpindle) {
P6 = neutralHandTool ? (tool.clockwise ? 120 : 300) : (tool.clockwise ? 300 : 120); // neutral : left/right hand tools
} else {
P6 = neutralHandTool ? (tool.clockwise ? 300 : 120) : (tool.clockwise ? 120 : 300); // neutral : left/right hand tools
}
break;
case 3: // D3 240deg
if (primarySpindle) {
P6 = neutralHandTool ? (tool.clockwise ? 240 : 60) : (tool.clockwise ? 60 : 240); // neutral : left/right hand tools
} else {
P6 = neutralHandTool ? (tool.clockwise ? 60 : 240) : (tool.clockwise ? 240 : 60); // neutral : left/right hand tools
}
break;
default:
error(subst(localize("Unsupported compensation offset in operation \"%1\". Only 1-3 is allowed for turning."), getOperationComment()));
return;
}
} else {
P6 = 0; // milling
}
writeBlock("TC(" + P1 + "," + P2 + "," + P3 + "," + P4 + "," + P5 + "," + P6 + ")");
if (machineState.isTurningOperation || machineState.axialCenterDrilling) {
writeBlock((machineState.cAxisIsEngaged || machineState.cAxisIsEngaged == undefined) ? getCode("DISENABLE_C_AXIS", getSpindle(PART)) : "");
} else { // milling
writeBlock((!machineState.cAxisIsEngaged || machineState.cAxisIsEngaged == undefined) ? getCode("ENABLE_C_AXIS", getSpindle(PART)) : "");
}
// command stop for manual tool change, useful for quick change live tools
if (insertToolCall && tool.manualToolChange) {
onCommand(COMMAND_STOP);
writeComment("MANUAL TOOL CHANGE TO T" + (getProperty("toolAsName") ? "=" + "\"" + (tool.description.toUpperCase()) + "\"" : toolFormat.format(tool.number)) + ")");
}
if (newSpindle) {
// select spindle if required
}
// Write out maximum spindle speed
var useConstantSurfaceSpeed = currentSection.getTool().getSpindleMode() == SPINDLE_CONSTANT_SURFACE_SPEED;
var maximumSpindleSpeed = (tool.maximumSpindleSpeed > 0) ? Math.min(tool.maximumSpindleSpeed, getProperty("maximumSpindleSpeed")) : getProperty("maximumSpindleSpeed");
if ((maximumSpindleSpeed > 0) && (currentSection.getTool().getSpindleMode() == SPINDLE_CONSTANT_SURFACE_SPEED)) {
if ((insertToolCall || rpmFormat.areDifferent(maximumSpindleSpeed, previousMaximumSpeed)) && !machineState.stockTransferIsActive) {
writeBlock("LIMS[" + getSpindleCode(currentSection) + "]=" + rpmFormat.format(maximumSpindleSpeed));
sOutput.setCurrent(-1);
previousMaximumSpeed = maximumSpindleSpeed;
}
} else {
previousMaximumSpeed = 0; // reset for RPM spindle speeds
}
sOutput.setCurrent(-1); // force spindle speeds
var spindleChanged = tool.type != TOOL_PROBE && (!machineState.stockTransferIsActive || forceSpindle) &&
(insertToolCall || forceSpindleSpeed || isSpindleSpeedDifferent() || newSpindle);
if (spindleChanged) {
if (machineState.isTurningOperation || machineState.axialCenterDrilling) {
if (spindleSpeed > getProperty("maximumSpindleSpeed")) {
warning(subst(localize("Spindle speed exceeds maximum value for operation \"%1\"."), getOperationComment()));
}
} else {
if (spindleSpeed > 6000) {
warning(subst(localize("Spindle speed exceeds maximum value for operation \"%1\"."), getOperationComment()));
}
}
writeBlock("SETMS(" + getSpindleCode(currentSection) + ")");
// Engage tailstock
if (getProperty("useTailStock")) {
if (machineState.axialCenterDrilling || (currentSection.spindle == SPINDLE_SECONDARY) ||
(machineState.liveToolIsActive && (machineState.machiningDirection == MACHINING_DIRECTION_AXIAL))) {
if (currentSection.tailstock) {
warning(localize("Tail stock is not supported for secondary spindle or Z-axis milling."));
}
if (machineState.tailstockIsActive) {
writeBlock(getCode("TAILSTOCK_OFF"));
}
} else {
writeBlock(currentSection.tailstock ? getCode("TAILSTOCK_ON") : getCode("TAILSTOCK_OFF"));
}
}
startSpindle(false, false, getFramePosition(currentSection.getInitialPosition()));
}
// Get active feedrate mode
if (insertToolCall) {
forceModals();
} else {
gFeedModeModal.reset();
}
var feedMode = formatFeedMode(currentSection.feedMode);
writeBlock(feedMode);
if (getProperty("useParametricFeed") && !isDrillingCycle(true)) {
if (!insertToolCall &&
activeMovements &&
(getCurrentSectionId() > 0) &&
((getPreviousSection().getPatternId() == currentSection.getPatternId()) && (currentSection.getPatternId() != 0))) {
// use the current feeds
} else {
initializeActiveFeeds();
}
} else {
activeMovements = undefined;
}
// wcs
if (insertToolCall) { // force work offset when changing tool
currentWorkOffset = undefined;
}
writeWCS(currentSection);
if (currentSection.partCatcher) {
engagePartCatcher(true);
}
forceAny();
gMotionModal.reset();
if (currentSection.isMultiAxis()) {
forceWorkPlane();
cancelTransformation();
} else {
if (machineState.isTurningOperation) {
if (gotBAxis) {
writeBlock(gMotionModal.format(0), bOutput.format(getB(abc, currentSection)));
machineState.currentBAxisOrientationTurning = abc;
}
} else {
setWorkPlane(abc);
}
}
forceAny();
if (insertToolCall || newWorkPlane) {
writeBlock(gFormat.format(153), gMotionModal.format(0), "Z" + spatialFormat.format((currentSection.spindle == SPINDLE_SECONDARY) ? getProperty("homePositionSubZ") : getProperty("homePositionZ")), dFormat.format(0)); // retract with regard to spindle
zOutput.reset();
dOutput.reset();
}
if (true /*|| retracted && !insertToolCall*/) {
toolLengthOffset = tool.isTurningTool() ? tool.compensationOffset : 1; // optional, use tool.lengthOffset instead
if (toolLengthOffset > 99) {
error(localize("Length offset out of range."));
return;
}
writeBlock(dOutput.format(toolLengthOffset));
}
gMotionModal.reset();
if (machineState.cAxisIsEngaged) { // make sure C-axis in engaged
if (!machineState.usePolarInterpolation && !machineState.usePolarCoordinates && !currentSection.isMultiAxis()) {
onCommand(COMMAND_LOCK_MULTI_AXIS);
} else {
onCommand(COMMAND_UNLOCK_MULTI_AXIS);
}
}
// enable Polar coordinates mode
if (machineState.usePolarCoordinates && (tool.type != TOOL_PROBE)) {
if (polarCoordinatesDirection == undefined) {
error(localize("Polar coordinates axis direction to maintain must be defined as a vector - x,y,z."));
return;
}
setPolarCoordinates(true);
}
var initialPosition = getFramePosition(currentSection.getInitialPosition());
if (currentSection.isMultiAxis()) {
forceABC();
forceWorkPlane();
cancelTransformation();
// turn machine
writeBlock("TRANS_5A(" + (currentSection.spindle == SPINDLE_PRIMARY ? mainSpindleAxisName[1] : subSpindleAxisName[1]) + "," + "\"" + "BC" + "\"" + ")");
writeBlock(gAbsIncModal.format(90), gMotionModal.format(0), xOutput.format(initialPosition.x), yOutput.format(initialPosition.y), zOutput.format(initialPosition.z), aOutput.format(abc.x), bOutput.format(getB(abc, currentSection)), cOutput.format(abc.z));
} else {
if (insertToolCall || retracted) {
gMotionModal.reset();
if (machineState.usePolarCoordinates) {
var polarPosition = getPolarCoordinates(initialPosition, abc);
writeBlock(gPlaneModal.format(17));
writeBlock(gMotionModal.format(0), zOutput.format(polarPosition.first.z));
writeBlock(
gMotionModal.format(0),
xOutput.format(polarPosition.first.x),
gotYAxis ? yOutput.format(0) : "",
cOutput.format(polarPosition.second.z)
);
} else if (machineState.usePolarInterpolation) {
var polarPosition = getPolarCoordinates(initialPosition, abc);
writeBlock(gMotionModal.format(0), zOutput.format(initialPosition.z));
writeBlock(
gMotionModal.format(0),
xOutput.format(polarPosition.first.x),
gotYAxis ? yOutput.format(polarPosition.first.y) : ""
);
} else {
if (machineState.isTurningOperation) {
writeBlock(gMotionModal.format(0), yOutput.format(initialPosition.y));
writeBlock(gMotionModal.format(0), zOutput.format(initialPosition.z), xOutput.format(initialPosition.x));
} else {
writeBlock(gAbsIncModal.format(90), gMotionModal.format(0), zOutput.format(initialPosition.z));
writeBlock(gMotionModal.format(0), xOutput.format(initialPosition.x), yOutput.format(initialPosition.y));
}
}
}
if (machineState.usePolarInterpolation) {
setPolarInterpolation(true); // enable polar interpolation mode
}
}
// set coolant after we have positioned at Z
setCoolant(tool.coolant);
previousSpindle = tempSpindle;
activeSpindle = tempSpindle;
if (false) { // DEBUG
for (var key in machineState) {
writeComment(key + " : " + machineState[key]);
}
writeComment("Tapping = " + tapping);
writeComment((getMachineConfigurationAsText(machineConfiguration)));
}
}
var MACHINING_DIRECTION_AXIAL = 0;
var MACHINING_DIRECTION_RADIAL = 1;
var MACHINING_DIRECTION_INDEXING = 2;
function getMachiningDirection(section) {
var forward = section.workPlane.forward;
if (section.isMultiAxis()) {
forward = section.getGlobalInitialToolAxis();
forward = Math.abs(forward.z) < 1e-7 ? new Vector(1, 0, 0) : forward; // radial multi-axis operation
}
if (isSameDirection(forward, new Vector(0, 0, 1))) {
return MACHINING_DIRECTION_AXIAL;
} else if (Vector.dot(forward, new Vector(0, 0, 1)) < 1e-7) {
return MACHINING_DIRECTION_RADIAL;
} else {
return MACHINING_DIRECTION_INDEXING;
}
}
/** Helper function to determine the polar machining options set in the user interface */
var IN_CONTROL = 0;
var IN_COMPUTER = 1;
var IN_CONTROL_AUTOMATIC = 2;
var IN_COMPUTER_AUTOMATIC = 3;
var POLAR_OFF = 4;
function getOperationPolarMode(section) {
if (revision < 50413 || getGlobalParameter("product-id").toLowerCase().indexOf("fusion") == -1) {
return undefined; // legacy
}
var mode = undefined;
switch (section.getPolarMode()) {
case POLAR_MODE_COMPUTER:
mode = section.machiningType == MACHINING_TYPE_3AXIS ? IN_COMPUTER_AUTOMATIC : IN_COMPUTER;
break;
case POLAR_MODE_CONTROL:
mode = section.machiningType == MACHINING_TYPE_3AXIS ? IN_CONTROL_AUTOMATIC : IN_CONTROL;
break;
case POLAR_MODE_AUTO:
if (section.machiningType == MACHINING_TYPE_3AXIS) {
mode = gotPolarInterpolation ? IN_CONTROL_AUTOMATIC : IN_COMPUTER_AUTOMATIC;
} else {
mode = gotPolarInterpolation ? IN_CONTROL : IN_COMPUTER;
}
break;
default:
mode = POLAR_OFF;
}
return mode;
}
function updateMachiningMode(section) {
machineState.axialCenterDrilling = false; // reset
machineState.usePolarInterpolation = false; // reset
machineState.usePolarCoordinates = false; // reset
machineState.machiningDirection = getMachiningDirection(section);
var operationPolarMode = getOperationPolarMode(section); // determine the polar machining options set in the user interface
var isExplicitPolarMode = operationPolarMode == IN_COMPUTER || operationPolarMode == IN_CONTROL;
if (isExplicitPolarMode && (forcePolarCoordinates || forcePolarInterpolation)) {
error("The Manual NC \"Action\" command to enable polar machining and the operation option \"Machining Type Polar\" cannot be used together." + EOL +
"Please select only one option to enable polar machining.");
}
if ((section.getType() == TYPE_MILLING) && !section.isMultiAxis()) {
if (machineState.machiningDirection == MACHINING_DIRECTION_AXIAL) {
if (isDrillingCycle(section, false)) {
// drilling axial
machineState.axialCenterDrilling = isAxialCenterDrilling(section, true);
if (!machineState.axialCenterDrilling && !isAxialCenterDrilling(section, false)) { // several holes not on XY center
if (isExplicitPolarMode) {
if (operationPolarMode == IN_CONTROL) {
warning(subst(localize("Polar mode \"In Control\" is not supported for drilling operation \"%1\". The post processor will use mode \"In Computer\" instead."), getOperationComment()));
operationPolarMode = IN_COMPUTER;
}
if (operationPolarMode == IN_COMPUTER) {
machineState.usePolarCoordinates = true;
polarCoordinatesDirection = section.polarDirection;
if (getProperty("useYAxisForDrilling")) {
warning(subst(localize("Polar mode was requested for operation \"%1\". Therefore, the post property \"" + properties.useYAxisForDrilling.title + "\" will be ignored."), getOperationComment()));
}
}
} else {
if (operationPolarMode == undefined) { // legacy
bestABC = getBestABC(section);
bestABC = section.doesToolpathFitWithinLimits(machineConfiguration, bestABC) ? bestABC : undefined;
if (!getProperty("useYAxisForDrilling") || bestABC == undefined) {
machineState.usePolarCoordinates = true;
}
} else {
if (section.useRotationsToFitLimits > 0) {
bestABC = getBestABC(section);
bestABC = section.doesToolpathFitWithinLimits(machineConfiguration, bestABC) ? bestABC : undefined;
if (operationPolarMode != POLAR_OFF) {
if (!getProperty("useYAxisForDrilling") || bestABC == undefined) {
machineState.usePolarCoordinates = true;
}
}
}
}
}
}
} else { // milling
// Use new operation property for polar milling if available
if (isExplicitPolarMode) {
forcePolarCoordinates = operationPolarMode == IN_COMPUTER;
forcePolarInterpolation = operationPolarMode == IN_CONTROL;
polarCoordinatesDirection = section.polarDirection;
}
if (gotPolarInterpolation && forcePolarInterpolation) { // polar mode is requested by user
machineState.usePolarInterpolation = true;
bestABC = undefined;
} else if (forcePolarCoordinates) { // Polar coordinate mode is requested by user
machineState.usePolarCoordinates = true;
bestABC = undefined;
} else {
if (operationPolarMode == undefined) { // legacy
bestABC = getBestABC(section);
bestABC = section.doesToolpathFitWithinLimits(machineConfiguration, bestABC) ? bestABC : undefined;
if (bestABC == undefined) { // toolpath does not match XY ranges, enable interpolation mode
if (gotPolarInterpolation) {
machineState.usePolarInterpolation = true;
} else {
machineState.usePolarCoordinates = true;
}
}
} else {
if (section.useRotationsToFitLimits > 0) {
bestABC = getBestABC(section);
bestABC = section.doesToolpathFitWithinLimits(machineConfiguration, bestABC) ? bestABC : undefined;
if (bestABC == undefined && operationPolarMode != POLAR_OFF) {
if (gotPolarInterpolation && (operationPolarMode == IN_CONTROL_AUTOMATIC)) {
machineState.usePolarInterpolation = true;
} else {
machineState.usePolarCoordinates = operationPolarMode == IN_COMPUTER_AUTOMATIC;
}
}
}
}
}
}
} else if (machineState.machiningDirection == MACHINING_DIRECTION_RADIAL) { // G19 plane
var range = section.getOptimizedBoundingBox(machineConfiguration, machineConfiguration.getABC(section.workPlane));
var yAxisWithinLimits = machineConfiguration.getAxisY().getRange().isWithin(yFormat.getResultingValue(range.lower.y)) &&
machineConfiguration.getAxisY().getRange().isWithin(yFormat.getResultingValue(range.upper.y));
if (!gotYAxis) {
if (!section.isMultiAxis() && !yAxisWithinLimits) {
error(subst(localize("Y-axis motion is not possible without a Y-axis for operation \"%1\"."), getOperationComment()));
return;
}
} else {
if (!yAxisWithinLimits) {
error(subst(localize("Toolpath exceeds the maximum ranges for operation \"%1\"."), getOperationComment()));
return;
}
}
// C-coordinates come from setWorkPlane or is within a multi axis operation, we cannot use the C-axis for non wrapped toolpathes (only multiaxis works, all others have to be into XY range)
} else {
// usePolarCoordinates & usePolarInterpolation is only supported for axial machining, keep false
}
} else {
// turning or multi axis, keep false
}
if (machineState.axialCenterDrilling) {
cOutput.disable();
} else {
cOutput.enable();
}
// validations
if (forcePolarInterpolation && !gotPolarInterpolation) {
warning(localize("Polar mode \"In Control\" has been requested but is either disabled or not supported by the machine." + EOL +
"The post processor will use mode \"Automatic\" instead."));
}
if (machineState.usePolarCoordinates && section.getParameter("operation:compensationType", false) == "control") {
error(subst(localize("Polar interpolation type \"In Control\" is required for using cutter compensation type \"In Control\" in operation \"%1\", but is either disabled or unsupported by the machine."), getOperationComment()));
}
var checksum = 0;
checksum += machineState.usePolarInterpolation ? 1 : 0;
checksum += machineState.usePolarCoordinates ? 1 : 0;
checksum += machineState.axialCenterDrilling ? 1 : 0;
validate(checksum <= 1, localize("Internal post processor error."));
}
function getOperationComment() {
var operationComment = hasParameter("operation-comment") && getParameter("operation-comment");
return operationComment;
}
function setPolarInterpolation(activate) {
if (activate) {
writeBlock("DIAMOF");
writeBlock(gMotionModal.format(0), yOutput.format(0));
yOutput.reset();
writeBlock(getCode("POLAR_INTERPOLATION_ON", getSpindle(PART))); // command for polar interpolation
writeBlock(gPlaneModal.format(17));
xFormat.setScale(1); // radius mode
yOutput.enable();
} else {
writeBlock(getCode("POLAR_INTERPOLATION_OFF", getSpindle(PART)));
writeBlock("DIAMON");
xFormat.setScale(2); // diameter mode
if (!gotYAxis) {
yOutput.disable();
}
cOutput.reset();
}
xOutput.setFormat(xFormat);
xOutput.reset();
}
/** Write retract in XY/Z. */
function writeRetract(section, retractZ) {
writeBlock(gFormat.format(153), gMotionModal.format(0), "X" + (section.spindle == SPINDLE_PRIMARY ? xFormat.format(getProperty("homePositionX")) : Math.abs(xFormat.format(getProperty("homePositionX")))), dOutput.format(0)); // retract
xOutput.reset();
if (gotYAxis) {
writeBlock(gFormat.format(153), gMotionModal.format(0), "Y" + yFormat.format(getProperty("homePositionY")), dOutput.format(0)); // retract
yOutput.reset();
}
if (retractZ) {
writeBlock(gFormat.format(153), gMotionModal.format(0), "Z" + zFormat.format((section.spindle == SPINDLE_SECONDARY) ? getProperty("homePositionSubZ") : getProperty("homePositionZ")), dOutput.format(0)); // retract with regard to spindle
zOutput.reset();
}
writeBlock(dOutput.format(toolLengthOffset));
}
function onDwell(seconds) {
if (seconds > 99999.999) {
warning(localize("Dwelling time is out of range."));
}
writeBlock(gFormat.format(4), "F" + secFormat.format(seconds));
}
var pendingRadiusCompensation = -1;
function onRadiusCompensation() {
pendingRadiusCompensation = radiusCompensation;
}
function getCompensationPlane(abc, returnCode, outputPlane) {
var plane;
if (machineState.isTurningOperation) {
plane = PLANE_ZX;
} else if (machineState.usePolarInterpolation) {
plane = PLANE_XY;
} else {
var found = false;
if (!found) {
if (isSameDirection(currentSection.workPlane.forward, new Vector(0, 0, 1))) {
plane = PLANE_XY;
} else if (Vector.dot(currentSection.workPlane.forward, new Vector(0, 0, 1)) < 1e-7) {
plane = PLANE_YZ;
} else {
if (returnCode) {
if (machineState.machiningDirection == MACHINING_DIRECTION_AXIAL) {
plane = PLANE_XY;
} else {
plane = PLANE_ZX;
}
} else {
plane = -1;
if (outputPlane) {
error(localize("Tool orientation is not supported for radius compensation."));
return -1;
}
}
}
}
}
var code = plane == -1 ? -1 : (plane == PLANE_XY ? getG17Code() : (plane == PLANE_ZX ? 18 : 19));
if (outputPlane) {
writeBlock(gPlaneModal.format(code));
}
return returnCode ? code : plane;
}
var resetFeed = false;
function getHighfeedrate(radius) {
if (currentSection.feedMode == FEED_PER_REVOLUTION) {
if (toDeg(radius) <= 0) {
radius = toPreciseUnit(0.1, MM);
}
var rpm = spindleSpeed; // rev/min
if (currentSection.getTool().getSpindleMode() == SPINDLE_CONSTANT_SURFACE_SPEED) {
var O = 2 * Math.PI * radius; // in/rev
rpm = tool.surfaceSpeed / O; // in/min div in/rev => rev/min
}
return highFeedrate / rpm; // in/min div rev/min => in/rev
}
return highFeedrate;
}
function onRapid(_x, _y, _z) {
var x = xOutput.format(_x);
var y = yOutput.format(_y);
var z = zOutput.format(_z);
if (x || y || z) {
var useG1 = false; // ((x ? 1 : 0) + (y ? 1 : 0) + (z ? 1 : 0)) > 1;
var gCode = useG1 ? 1 : 0;
var f = useG1 ? (getFeed(getHighfeedrate(_x))) : "";
if (pendingRadiusCompensation >= 0) {
pendingRadiusCompensation = -1;
var plane = getCompensationPlane(getCurrentDirection(), false, true);
var ccLeft = isMirrored(plane) ? 42 : 41;
var ccRight = isMirrored(plane) ? 41 : 42;
switch (radiusCompensation) {
case RADIUS_COMPENSATION_LEFT:
writeBlock(gMotionModal.format(gCode), gFormat.format(ccLeft), x, y, z, f);
break;
case RADIUS_COMPENSATION_RIGHT:
writeBlock(gMotionModal.format(gCode), gFormat.format(ccRight), x, y, z, f);
break;
default:
writeBlock(gMotionModal.format(gCode), gFormat.format(40), x, y, z, f);
}
} else {
writeBlock(gMotionModal.format(gCode), x, y, z, f);
resetFeed = false;
}
}
}
function onLinear(_x, _y, _z, feed) {
if (isSpeedFeedSynchronizationActive()) {
resetFeed = true;
var threadPitch = getParameter("operation:threadPitch");
var threadsPerInch = 1.0 / threadPitch; // per mm for metric
var pitchLetter;
var xLength = Math.abs(xFormat.format(_x) - xFormat.format(xOutput.getCurrent()));
var zLength = Math.abs(zFormat.format(_z) - zFormat.format(zOutput.getCurrent()));
if (xLength > zLength) {
pitchLetter = "I";
} else {
pitchLetter = "K";
}
writeBlock(gFormat.format(33), xOutput.format(_x), zOutput.format(_z), pitchLetter + spatialFormat.format(1 / threadsPerInch));
return;
}
if (resetFeed) {
resetFeed = false;
forceFeed();
}
var x = xOutput.format(_x);
var y = yOutput.format(_y);
var z = zOutput.format(_z);
if (x || y || z) {
if (pendingRadiusCompensation >= 0) {
pendingRadiusCompensation = -1;
var plane = getCompensationPlane(getCurrentDirection(), false, true);
var ccLeft = isMirrored(plane) ? 42 : 41;
var ccRight = isMirrored(plane) ? 41 : 42;
switch (radiusCompensation) {
case RADIUS_COMPENSATION_LEFT:
writeBlock(
gMotionModal.format(isSpeedFeedSynchronizationActive() ? 32 : 1),
gFormat.format(ccLeft),
x, y, z, getFeed(feed));
break;
case RADIUS_COMPENSATION_RIGHT:
writeBlock(
gMotionModal.format(isSpeedFeedSynchronizationActive() ? 32 : 1),
gFormat.format(ccRight), x, y, z,
getFeed(feed));
break;
default:
writeBlock(gMotionModal.format(isSpeedFeedSynchronizationActive() ? 32 : 1), gFormat.format(40), x, y, z, getFeed(feed));
}
} else {
writeBlock(gMotionModal.format(isSpeedFeedSynchronizationActive() ? 32 : 1), x, y, z, getFeed(feed));
}
}
}
function onRapid5D(_x, _y, _z, _a, _b, _c) {
if (pendingRadiusCompensation >= 0) {
error(localize("Radius compensation mode cannot be changed at rapid traversal."));
return;
}
var x = xOutput.format(_x);
var y = yOutput.format(_y);
var z = zOutput.format(_z);
var a = aOutput.format(_a);
var b = bOutput.format(getB(new Vector(_a, _b, _c), currentSection));
var c = cOutput.format(_c);
if (x || y || z || a || b || c) {
if (true) {
// axes are not synchronized
writeBlock(gMotionModal.format(1), x, y, z, a, b, c, getFeed(highFeedrate));
} else {
writeBlock(gMotionModal.format(0), x, y, z, a, b, c);
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;
}
var x = xOutput.format(_x);
var y = yOutput.format(_y);
var z = zOutput.format(_z);
var a = aOutput.format(_a);
var b = bOutput.format(getB(new Vector(_a, _b, _c), currentSection));
var c = cOutput.format(_c);
if (x || y || z || a || b || c) {
writeBlock(gMotionModal.format(1), x, y, z, a, b, c, getFeed(feed));
}
}
// Start of Polar coordinates
var defaultPolarCoordinatesDirection = new Vector(1, 0, 0); // default direction for polar interpolation
var polarCoordinatesDirection = defaultPolarCoordinatesDirection; // vector to maintain tool at while in polar interpolation
var polarSpindleAxisSave;
function setPolarCoordinates(mode) {
if (!mode) { // turn off polar mode if required
if (isPolarModeActive()) {
deactivatePolarMode();
if (gotBAxis) {
machineConfiguration.setSpindleAxis(polarSpindleAxisSave);
bOutput.enable();
}
// setPolarFeedMode(false);
if (currentWorkPlaneABC != undefined) {
currentWorkPlaneABC.z = Number.POSITIVE_INFINITY;
}
}
polarCoordinatesDirection = defaultPolarCoordinatesDirection; // reset when deactivated
return;
}
var direction = polarCoordinatesDirection;
// determine the rotary axis to use for Polar coordinates
var axis = undefined;
if (machineConfiguration.getAxisV().isEnabled()) {
if (Vector.dot(machineConfiguration.getAxisV().getAxis(), currentSection.workPlane.getForward()) != 0) {
axis = machineConfiguration.getAxisV();
}
}
if (axis == undefined && machineConfiguration.getAxisU().isEnabled()) {
if (Vector.dot(machineConfiguration.getAxisU().getAxis(), currentSection.workPlane.getForward()) != 0) {
axis = machineConfiguration.getAxisU();
}
}
if (axis == undefined) {
error(localize("Polar coordinates require an active rotary axis be defined in direction of workplane normal."));
}
// calculate directional vector from initial position
if (direction == undefined) {
error(localize("Polar coordinates initiated without a directional vector."));
return;
}
// activate polar coordinates
// setPolarFeedMode(true); // enable multi-axis feeds for polar mode
if (gotBAxis) {
polarSpindleAxisSave = machineConfiguration.getSpindleAxis();
machineConfiguration.setSpindleAxis(new Vector(0, 0, 1));
bOutput.disable();
}
activatePolarMode(getTolerance() / 2, 0, direction);
var polarPosition = getPolarPosition(currentSection.getInitialPosition().x, currentSection.getInitialPosition().y, currentSection.getInitialPosition().z);
setCurrentPositionAndDirection(polarPosition);
}
function getPolarCoordinates(position, abc) {
var reset = false;
var current = getCurrentDirection();
if (!isPolarModeActive()) {
setCurrentDirection(abc);
var tempPolarCoordinatesDirection = (currentSection.machiningType && (currentSection.machiningType == MACHINING_TYPE_POLAR)) ? currentSection.polarDirection : polarCoordinatesDirection;
activatePolarMode(getTolerance() / 2, 0, tempPolarCoordinatesDirection);
reset = true;
}
var polarPosition = getPolarPosition(position.x, position.y, position.z);
if (reset) {
deactivatePolarMode();
setCurrentDirection(current);
}
return polarPosition;
}
// End of polar coordinates
function onCircular(clockwise, cx, cy, cz, x, y, z, feed) {
var directionCode;
if (isMirrored(getCircularPlane())) {
directionCode = clockwise ? 3 : 2;
} else {
directionCode = clockwise ? 2 : 3;
}
var toler = getTolerance();
if (isSpeedFeedSynchronizationActive()) {
error(localize("Speed-feed synchronization is not supported for circular moves."));
return;
}
var start = getCurrentPosition();
var revolutions = Math.abs(getCircularSweep()) / (2 * Math.PI);
var turns = useArcTurn ? (revolutions % 1) == 0 ? revolutions - 1 : Math.floor(revolutions) : 0; // full turns
if (isFullCircle()) {
if (isHelical()) {
linearize(toler);
return;
}
if (turns > 1) {
error(localize("Multiple turns are not supported."));
return;
}
// G90/G91 are dont care when we do not used XYZ
switch (getCircularPlane()) {
case PLANE_XY:
if (radiusCompensation != RADIUS_COMPENSATION_OFF) {
if ((gPlaneModal.getCurrent() !== null) && (gPlaneModal.getCurrent() != 17)) {
error(localize("Plane cannot be changed when radius compensation is active."));
return;
}
}
writeBlock(gMotionModal.format(directionCode), iOutput.format(cx - start.x), jOutput.format(cy - start.y), getFeed(feed));
break;
case PLANE_ZX:
if (radiusCompensation != RADIUS_COMPENSATION_OFF) {
if ((gPlaneModal.getCurrent() !== null) && (gPlaneModal.getCurrent() != 18)) {
error(localize("Plane cannot be changed when radius compensation is active."));
return;
}
}
writeBlock(gMotionModal.format(directionCode), iOutput.format(cx - start.x), kOutput.format(cz - start.z), getFeed(feed));
break;
case PLANE_YZ:
if (radiusCompensation != RADIUS_COMPENSATION_OFF) {
if ((gPlaneModal.getCurrent() !== null) && (gPlaneModal.getCurrent() != 19)) {
error(localize("Plane cannot be changed when radius compensation is active."));
return;
}
}
writeBlock(gMotionModal.format(directionCode), jOutput.format(cy - start.y), kOutput.format(cz - start.z), getFeed(feed));
break;
default:
linearize(toler);
}
} else if (useArcTurn) { // IJK mode
switch (getCircularPlane()) {
case PLANE_XY:
if (radiusCompensation != RADIUS_COMPENSATION_OFF) {
if ((gPlaneModal.getCurrent() !== null) && (gPlaneModal.getCurrent() != 17)) {
error(localize("Plane cannot be changed when radius compensation is active."));
return;
}
}
if (turns > 0) {
writeBlock(gAbsIncModal.format(90), gMotionModal.format(directionCode), xOutput.format(x), yOutput.format(y), zOutput.format(z), iOutput.format(cx - start.x), jOutput.format(cy - start.y), getFeed(feed), "TURN=" + turns);
} else {
writeBlock(gAbsIncModal.format(90), gMotionModal.format(directionCode), xOutput.format(x), yOutput.format(y), zOutput.format(z), iOutput.format(cx - start.x), jOutput.format(cy - start.y), getFeed(feed));
}
break;
case PLANE_ZX:
if (radiusCompensation != RADIUS_COMPENSATION_OFF) {
if ((gPlaneModal.getCurrent() !== null) && (gPlaneModal.getCurrent() != 18)) {
error(localize("Plane cannot be changed when radius compensation is active."));
return;
}
}
if (turns > 0) {
writeBlock(gAbsIncModal.format(90), gMotionModal.format(directionCode), xOutput.format(x), yOutput.format(y), zOutput.format(z), iOutput.format(cx - start.x), kOutput.format(cz - start.z), getFeed(feed), "TURN=" + turns);
} else {
writeBlock(gAbsIncModal.format(90), gMotionModal.format(directionCode), xOutput.format(x), yOutput.format(y), zOutput.format(z), iOutput.format(cx - start.x), kOutput.format(cz - start.z), getFeed(feed));
}
break;
case PLANE_YZ:
if (radiusCompensation != RADIUS_COMPENSATION_OFF) {
if ((gPlaneModal.getCurrent() !== null) && (gPlaneModal.getCurrent() != 19)) {
error(localize("Plane cannot be changed when radius compensation is active."));
return;
}
}
if (turns > 0) {
writeBlock(gAbsIncModal.format(90), gMotionModal.format(directionCode), xOutput.format(x), yOutput.format(y), zOutput.format(z), jOutput.format(cy - start.y), kOutput.format(cz - start.z), getFeed(feed), "TURN=" + turns);
} else {
writeBlock(gAbsIncModal.format(90), gMotionModal.format(directionCode), xOutput.format(x), yOutput.format(y), zOutput.format(z), jOutput.format(cy - start.y), kOutput.format(cz - start.z), getFeed(feed));
}
break;
default:
linearize(toler);
}
} 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:
forceXYZ();
writeBlock(gMotionModal.format(directionCode), xOutput.format(x), yOutput.format(y), zOutput.format(z), "CR=" + spatialFormat.format(r), getFeed(feed));
break;
case PLANE_ZX:
forceXYZ();
writeBlock(gMotionModal.format(directionCode), xOutput.format(x), yOutput.format(y), zOutput.format(z), "CR=" + spatialFormat.format(r), getFeed(feed));
break;
case PLANE_YZ:
forceXYZ();
writeBlock(gMotionModal.format(directionCode), xOutput.format(x), yOutput.format(y), zOutput.format(z), "CR=" + spatialFormat.format(r), getFeed(feed));
break;
default:
linearize(toler);
}
}
}
var chuckMachineFrame;
var chuckSubPosition;
var hadBarPull = false;
function getSecondaryPullMethod(type) {
var pullMethod = {};
// determine if pull operation, spindle return, or both
pullMethod.pull = false;
pullMethod.home = false;
switch (type) {
case "secondary-spindle-pull":
pullMethod.pullPosition = chuckSubPosition + cycle.pullingDistance;
pullMethod.machineFrame = chuckMachineFrame;
pullMethod.unclampMode = "keep-clamped";
pullMethod.pull = true;
hadBarPull = true;
break;
case "secondary-spindle-return":
pullMethod.pullPosition = cycle.feedPosition;
pullMethod.machineFrame = cycle.useMachineFrame;
pullMethod.unclampMode = cycle.unclampMode;
if (hadBarPull) {
pullMethod.pull = false;
pullMethod.home = true;
} else { // Legacy pull part only (when offset!=0), Return secondary spindle to home (when offset=0)
var feedDis = 0;
if (pullMethod.machineFrame) {
if (hasParameter("operation:feedPlaneHeight_direct")) { // Inventor
feedDis = getParameter("operation:feedPlaneHeight_direct");
} else if (hasParameter("operation:feedPlaneHeightDirect")) { // HSMWorks
feedDis = getParameter("operation:feedPlaneHeightDirect");
}
feedPosition = feedDis;
} else if (hasParameter("operation:feedPlaneHeight_offset")) { // Inventor
feedDis = getParameter("operation:feedPlaneHeight_offset");
} else if (hasParameter("operation:feedPlaneHeightOffset")) { // HSMWorks
feedDis = getParameter("operation:feedPlaneHeightOffset");
}
pullMethod.pull = feedDis != 0;
// pull part only (when offset!=0), Return secondary spindle to home (when offset=0)
pullMethod.home = pullMethod.unclampMode != "keep-clamped" ? true : !pullMethod.pull;
}
break;
}
return pullMethod;
}
function onCycle() {
if ((typeof isSubSpindleCycle == "function") && isSubSpindleCycle(cycleType)) {
error(localize("Stock transfer is not customized for your machine"));
return;
/*
writeln("");
if (hasParameter("operation-comment")) {
var comment = getParameter("operation-comment");
if (comment) {
writeComment(comment);
}
}
setCoolant(COOLANT_OFF);
writeRetract(currentSection, true); // retract in X, Y, Z
// wcs required here
currentWorkOffset = undefined;
writeWCS(currentSection);
writeBlock(gMotionModal.format(0), "B1=" + spatialFormat.format(180), "Y" + yFormat.format(-99));
bOutput.reset();
yOutput.reset();
switch (cycleType) {
case "secondary-spindle-grab":
if (cycle.usePartCatcher) {
engagePartCatcher(true);
}
writeBlock(mFormat.format(currentSection.spindle == SPINDLE_PRIMARY ? 326 : 426)); // check if the opposite spindle is empty
writeBlock(
getCode("UNCLAMP_CHUCK", getSpindle(PART)),
formatComment(currentSection.spindle == SPINDLE_PRIMARY ? "UNCLAMP SECONDARY CHUCK" : "UNCLAMP PRIMARY CHUCK")
);
writeBlock(getCode("FEED_MODE_UNIT_REV")); // mm/rev
if (cycle.stopSpindle) { // no spindle rotation
writeBlock(conditional(machineState.mainSpindleIsActive, getCode("STOP_SPINDLE", SPINDLE_MAIN)));
writeBlock(conditional(machineState.subSpindleIsActive, getCode("STOP_SPINDLE", SPINDLE_SUB)));
writeBlock("L705(0) ;ENGAGE C3-AXIS");
writeBlock("L707(0) ;ENGAGE C4-AXIS");
} else { // spindle rotation
writeBlock(getCode("UNLOCK_MULTI_AXIS", SPINDLE_MAIN));
writeBlock(getCode("UNLOCK_MULTI_AXIS", SPINDLE_SUB));
writeBlock("L706 ;DISENGAGE C3-AXIS");
writeBlock("L708 ;DISENGAGE C4-AXIS");
writeBlock("S" + mainSpindleAxisName[1] + "=" + rpmFormat.format(cycle.spindleSpeed), tool.clockwise ? getCode("START_SPINDLE_CW", SPINDLE_MAIN) : getCode("START_SPINDLE_CCW", SPINDLE_MAIN));
writeBlock("S" + subSpindleAxisName[1] + "=" +rpmFormat.format(cycle.spindleSpeed), tool.clockwise ? getCode("START_SUB_CCW", SPINDLE_SUB) : getCode("START_SPINDLE_CW", SPINDLE_SUB)); // inverted
writeBlock(getCode("SPINDLE_SYNCHRONIZATION_ON") + "(" + abcFormat.format(cycle.spindleOrientation) + ")", formatComment("SPINDLE SYNCHRONIZATION ON")); // Sync spindles
}
// writeBlock(getCode("AIR_BLAST_ON", SPINDLE_MAIN), formatComment("MAINSPINDLE AIR BLAST ON"));
// writeBlock(getCode("AIR_BLAST_ON", SPINDLE_SUB), formatComment("SUBSPINDLE AIR BLAST ON"));
writeBlock(mFormat.format(currentSection.spindle == SPINDLE_PRIMARY ? 307 : 407), formatComment("CLEANING COOLANT ON"));
onDwell(cycle.dwell);
gMotionModal.reset();
writeBlock(conditional(cycle.useMachineFrame, gFormat.format(53)), gMotionModal.format(0), "Z3=" + spatialFormat.format(cycle.feedPosition));
onDwell(cycle.dwell);
writeBlock(conditional(cycle.useMachineFrame, gFormat.format(53)), gMotionModal.format(1), "Z3=" + spatialFormat.format(cycle.chuckPosition), getFeed(cycle.feedrate));
writeBlock(
getCode("CLAMP_CHUCK", getSecondarySpindle()),
formatComment(currentSection.spindle == SPINDLE_PRIMARY ? "CLAMP SECONDARY CHUCK" : "CLAMP PRIMARY CHUCK")
);
writeBlock(mFormat.format(currentSection.spindle == SPINDLE_PRIMARY ? 309 : 409), formatComment("CLEANING COOLANT OFF"));
onDwell(cycle.dwell);
break;
case "secondary-spindle-return":
// TAG: SPINDEL START NICHT ERLAUBT WENN BEREITS AKTIV!!!
writeBlock(getCode("FEED_MODE_UNIT_REV")); // mm/rev
if (cycle.stopSpindle) { // no spindle rotation
writeBlock(conditional(machineState.mainSpindleIsActive, getCode("STOP_SPINDLE", SPINDLE_MAIN)));
writeBlock(conditional(machineState.subSpindleIsActive, getCode("STOP_SPINDLE", SPINDLE_SUB)));
} else { // spindle rotation
writeBlock("S" + mainSpindleAxisName[1] + "=" + rpmFormat.format(cycle.spindleSpeed), tool.clockwise ? getCode("START_SPINDLE_CW", SPINDLE_MAIN) : getCode("START_SPINDLE_CCW", SPINDLE_MAIN));
writeBlock("S" + subSpindleAxisName[1] + "=" +rpmFormat.format(cycle.spindleSpeed), tool.clockwise ? getCode("START_SPINDLE_CCW", SPINDLE_SUB) : getCode("START_SPINDLE_CW", SPINDLE_SUB)); // inverted
}
if (!machineState.spindleSynchronizationIsActive) {
writeBlock(getCode("SPINDLE_SYNCHRONIZATION_ON"), formatComment("SPINDLE SYNCHRONIZATION ON")); // Sync spindles
}
switch (cycle.unclampMode) {
case "unclamp-primary":
writeBlock(getCode("UNCLAMP_CHUCK", SPINDLE_MAIN), formatComment("UNCLAMP PRIMARY CHUCK"));
break;
case "unclamp-secondary":
writeBlock(getCode("UNCLAMP_CHUCK", SPINDLE_SUB), formatComment("UNCLAMP SECONDARY CHUCK"));
break;
case "keep-clamped":
break;
}
onDwell(cycle.dwell);
writeBlock(conditional(cycle.useMachineFrame, gFormat.format(53)), gMotionModal.format(1), "Z3=" + spatialFormat.format(cycle.feedPosition), getFeed(cycle.feedrate));
writeBlock(gMotionModal.format(0), "Z3=" + spatialFormat.format(1020));
if (machineState.spindleSynchronizationIsActive) { // spindles are synchronized
writeBlock(getCode("SPINDLE_SYNCHRONIZATION_OFF"), formatComment("SPINDLE SYNCHRONIZATION OFF")); // disable spindle sync
}
break;
case "secondary-spindle-pull":
if (cycle.stopSpindle) { // no spindle rotation
if (machineState.spindleSynchronizationIsActive) { // spindles are synchronized
writeBlock(getCode("SPINDLE_SYNCHRONIZATION_OFF")); // disable spindle sync
}
writeBlock(conditional(machineState.mainSpindleIsActive, getCode("STOP_SPINDLE", SPINDLE_MAIN)));
writeBlock(conditional(machineState.subSpindleIsActive, getCode("STOP_SPINDLE", SPINDLE_SUB)));
} else { // spindle rotation
writeBlock(sOutput.format(cycle.spindleSpeed), getCode("START_SPINDLE_CW", SPINDLE_MAIN));
// writeBlock(pOutput.format(cycle.spindleSpeed), mFormat.format(getCode("START_SPINDLE_CW", SPINDLE_SUB)));
}
writeBlock(getCode("FEED_MODE_UNIT_REV")); // mm/rev
writeBlock(getCode("UNCLAMP_CHUCK", getSpindle(PART));
onDwell(cycle.dwell);
writeBlock(gMotionModal.format(1), "Z3=" + spatialFormat.format(cycle.pullingDistance), getFeed(cycle.feedrate));
writeBlock(getCode("CLAMP_CHUCK", getSpindle(PART));
onDwell(cycle.dwell);
if (machineState.spindleSynchronizationIsActive) { // spindles are synchronized
writeBlock(getCode("SPINDLE_SYNCHRONIZATION_OFF")); // disable spindle sync
}
break;
}
*/
}
expandCurrentCycle = false;
if (true) {
if ((cycleType != "tapping") &&
(cycleType != "right-tapping") &&
(cycleType != "left-tapping") &&
(cycleType != "tapping-with-chip-breaking") &&
(cycleType != "turning-canned-rough")) {
writeBlock(getFeed(cycle.feedrate));
}
var RTP = cycle.clearance; // return plane (absolute)
var RFP = cycle.stock; // reference plane (absolute)
var SDIS = cycle.retract - cycle.stock; // safety distance
var DP = cycle.bottom; // depth (absolute)
// var DPR = RFP - cycle.bottom; // depth (relative to reference plane)
var DTB = cycle.dwell;
var SDIR = tool.clockwise ? 3 : 4; // direction of rotation: M3:3 and M4:4
switch (cycleType) {
case "drilling":
writeCycleClearance();
writeBlock(
"MCALL CYCLE81(" + spatialFormat.format(RTP) +
"," + spatialFormat.format(RFP) +
"," + spatialFormat.format(SDIS) +
"," + spatialFormat.format(DP) +
"," /*+ spatialFormat.format(DPR)*/ + ")"
);
break;
case "counter-boring":
writeCycleClearance();
writeBlock(
"MCALL CYCLE82(" + spatialFormat.format(RTP) +
"," + spatialFormat.format(RFP) +
"," + spatialFormat.format(SDIS) +
"," + spatialFormat.format(DP) +
"," /*+ spatialFormat.format(DPR)*/ +
"," + (DTB > 0 ? secFormat.format(DTB) : "") + ")"
);
break;
case "chip-breaking":
writeCycleClearance();
var FDEP = cycle.stock - cycle.incrementalDepth;
var FDPR = cycle.incrementalDepth; // relative to reference plane (unsigned)
var DAM = cycle.incrementalDepthReduction; // degression (unsigned)
var DTS = 0; // dwell time at start
var FRF = 1; // feedrate factor (unsigned)
var VARI = 0; // chip breaking
var _AXN = 3; // tool axis
var _MDEP = (cycle.incrementalDepthReduction > 0) ? cycle.minimumIncrementalDepth : cycle.incrementalDepth; // minimum drilling depth
var _VRT = 0; // retraction distance
var _DTD = (cycle.dwell != undefined) ? cycle.dwell : 0;
var _DIS1 = 0; // limit distance
if (cycle.accumulatedDepth < cycle.depth) {
expandCurrentCycle = true;
} else {
writeBlock(
"MCALL CYCLE83(" + spatialFormat.format(RTP) +
", " + spatialFormat.format(RFP) +
", " + spatialFormat.format(SDIS) +
", " + spatialFormat.format(DP) +
", " /*+ spatialFormat.format(DPR)*/ +
", " + spatialFormat.format(FDEP) +
", " /*+ spatialFormat.format(FDPR)*/ +
", " + spatialFormat.format(DAM) +
", " + /*conditional(DTB > 0, secFormat.format(DTB))*/ // only dwell at bottom
", " + (DTS > 0 ? secFormat.format(DTS) : "") +
", " + spatialFormat.format(FRF) +
", " + spatialFormat.format(VARI) +
", " + /*_AXN +*/
", " + spatialFormat.format(_MDEP) +
", " + spatialFormat.format(_VRT) +
", " + secFormat.format(_DTD) +
", 0" + /*spatialFormat.format(_DIS1) +*/
")"
);
}
break;
case "deep-drilling":
writeCycleClearance();
var FDEP = cycle.stock - cycle.incrementalDepth;
var FDPR = cycle.incrementalDepth; // relative to reference plane (unsigned)
var DAM = cycle.incrementalDepthReduction; // degression (unsigned)
var DTS = 0; // dwell time at start
var FRF = 1; // feedrate factor (unsigned)
var VARI = 1; // full retract
var _MDEP = (cycle.incrementalDepthReduction > 0) ? cycle.minimumIncrementalDepth : cycle.incrementalDepth; // minimum drilling depth
var _VRT = 0; // retraction distance
var _DTD = (cycle.dwell != undefined) ? cycle.dwell : 0;
var _DIS1 = 0; // limit distance
writeBlock(
"MCALL CYCLE83(" + spatialFormat.format(RTP) +
", " + spatialFormat.format(RFP) +
", " + spatialFormat.format(SDIS) +
", " + spatialFormat.format(DP) +
", " /*+ spatialFormat.format(DPR)*/ +
", " + spatialFormat.format(FDEP) +
", " /*+ spatialFormat.format(FDPR)*/ +
", " + spatialFormat.format(DAM) +
", " + /*conditional(DTB > 0, secFormat.format(DTB)) +*/ // only dwell at bottom
", " + (DTS > 0 ? secFormat.format(DTS) : "") +
", " + spatialFormat.format(FRF) +
", " + spatialFormat.format(VARI) +
", " + /*_AXN +*/
", " + spatialFormat.format(_MDEP) +
", " + spatialFormat.format(_VRT) +
", " + secFormat.format(_DTD) +
", 0" + /*spatialFormat.format(_DIS1) +*/
")"
);
break;
case "tapping":
case "left-tapping":
case "right-tapping":
writeCycleClearance();
var SDAC = SDIR; // direction of rotation after end of cycle
var MPIT = 0; // thread pitch as thread size
var PIT = ((tool.type == TOOL_TAP_LEFT_HAND) ? -1 : 1) * tool.threadPitch; // thread pitch
var POSS = 0; // spindle position for oriented spindle stop in cycle (in degrees)
var SST = spindleSpeed; // speed for tapping
var SST1 = spindleSpeed; // speed for return
writeBlock(
"MCALL CYCLE84(" + spatialFormat.format(RTP) +
", " + spatialFormat.format(RFP) +
", " + spatialFormat.format(SDIS) +
", " + spatialFormat.format(DP) +
", " /*+ spatialFormat.format(DPR)*/ +
", " + (DTB > 0 ? secFormat.format(DTB) : "") +
", " + spatialFormat.format(SDAC) +
", " + spatialFormat.format(MPIT) +
", " + spatialFormat.format(PIT) +
", " + spatialFormat.format(POSS) +
", " + spatialFormat.format(SST) +
", " + spatialFormat.format(SST1) + ")"
);
break;
case "tapping-with-chip-breaking":
writeCycleClearance();
var SDAC = SDIR; // direction of rotation after end of cycle
var MPIT = 0; // thread pitch as thread size
var PIT = ((tool.type == TOOL_TAP_LEFT_HAND) ? -1 : 1) * tool.threadPitch; // thread pitch
var POSS = 0; // spindle position for oriented spindle stop in cycle (in degrees)
var SST = spindleSpeed; // speed for tapping
var SST1 = spindleSpeed; // speed for return
var _AXN = 0; // tool axis
var _PTAB = 0; // must be 0
var _TECHNO = 0; // technology settings
var _VARI = 1; // machining type: 0 = tapping full depth, 1 = tapping partial retract, 2 = tapping full retract
var _DAM = cycle.incrementalDepth; // incremental depth
var _VRT = cycle.chipBreakDistance; // retract distance for chip breaking
writeBlock(
"MCALL CYCLE84(" + spatialFormat.format(RTP) +
", " + spatialFormat.format(RFP) +
", " + spatialFormat.format(SDIS) +
", " + spatialFormat.format(DP) +
", " /*+ spatialFormat.format(DPR)*/ +
", " + (DTB > 0 ? secFormat.format(DTB) : "") +
", " + spatialFormat.format(SDAC) +
", " + spatialFormat.format(MPIT) +
", " + spatialFormat.format(PIT) +
", " + spatialFormat.format(POSS) +
", " + spatialFormat.format(SST) +
", " + spatialFormat.format(SST1) +
", " + spatialFormat.format(_AXN) +
", " + spatialFormat.format(_PTAB) +
", " + spatialFormat.format(_TECHNO) +
", " + spatialFormat.format(_VARI) +
", " + spatialFormat.format(_DAM) +
", " + spatialFormat.format(_VRT) + ")"
);
break;
case "reaming":
writeCycleClearance();
var FFR = cycle.feedrate;
var RFF = cycle.retractFeedrate;
writeBlock(
"MCALL CYCLE85(" + spatialFormat.format(RTP) +
", " + spatialFormat.format(RFP) +
", " + spatialFormat.format(SDIS) +
", " + spatialFormat.format(DP) +
", " /*+ spatialFormat.format(DPR)*/ +
", " + (DTB > 0 ? secFormat.format(DTB) : "") +
", " + spatialFormat.format(FFR) +
", " + spatialFormat.format(RFF) + ")"
);
break;
case "stop-boring":
if (cycle.dwell > 0) {
expandCurrentCycle = true;
} else {
writeCycleClearance();
writeBlock(
"MCALL CYCLE87(" + spatialFormat.format(RTP) +
", " + spatialFormat.format(RFP) +
", " + spatialFormat.format(SDIS) +
", " + spatialFormat.format(DP) +
", " /*+ spatialFormat.format(DPR)*/ +
", " + SDIR + ")"
);
}
break;
case "fine-boring":
writeCycleClearance();
var RPA = 0; // return path in abscissa of the active plane (enter incrementally with)
var RPO = 0; // return path in the ordinate of the active plane (enter incrementally sign)
var RPAP = 0; // return plane in the applicate (enter incrementally with sign)
var POSS = 0; // spindle position for oriented spindle stop in cycle (in degrees)
writeBlock(
"MCALL CYCLE86(" + spatialFormat.format(RTP) +
", " + spatialFormat.format(RFP) +
", " + spatialFormat.format(SDIS) +
", " + spatialFormat.format(DP) +
", " /*+ spatialFormat.format(DPR)*/ +
", " + (DTB > 0 ? secFormat.format(DTB) : "") +
", " + SDIR +
", " + spatialFormat.format(RPA) +
", " + spatialFormat.format(RPO) +
", " + spatialFormat.format(RPAP) +
", " + spatialFormat.format(POSS) + ")"
);
break;
case "back-boring":
expandCurrentCycle = true;
break;
case "manual-boring":
writeCycleClearance();
writeBlock(
"MCALL CYCLE88(" + spatialFormat.format(RTP) +
", " + spatialFormat.format(RFP) +
", " + spatialFormat.format(SDIS) +
", " + spatialFormat.format(DP) +
", " /*+ spatialFormat.format(DPR)*/ +
", " + (DTB > 0 ? secFormat.format(DTB) : "") +
", " + SDIR + ")"
);
break;
case "boring":
writeCycleClearance();
// retract feed is ignored
writeBlock(
"MCALL CYCLE89(" + spatialFormat.format(RTP) +
", " + spatialFormat.format(RFP) +
", " + spatialFormat.format(SDIS) +
", " + spatialFormat.format(DP) +
", " /*+ spatialFormat.format(DPR)*/ +
", " + (DTB > 0 ? secFormat.format(DTB) : "") + ")"
);
break;
default:
expandCurrentCycle = true;
}
}
if (cycleType == "stock-transfer") {
error(localize("Stock transfer is not supported."));
return;
}
}
function writeCycleClearance() {
if (gotBAxis) {
return;
} else {
if (true) {
switch (gPlaneModal.getCurrent()) {
case 17:
writeBlock(gMotionModal.format(0), zOutput.format(cycle.clearance));
break;
case 18:
writeBlock(gMotionModal.format(0), yOutput.format(cycle.clearance));
break;
case 19:
writeBlock(gMotionModal.format(0), xOutput.format(cycle.clearance));
break;
default:
error(localize("Unsupported drilling orientation."));
return;
}
}
}
}
var expandCurrentCycle = false;
function onCyclePoint(x, y, z) {
// TAG: HANDLE B-AXIS (XYZ)
if (expandCurrentCycle) {
expandCyclePoint(x, y, z);
} else if (machineState.usePolarCoordinates) {
onCommand(COMMAND_UNLOCK_MULTI_AXIS);
var polarPosition = getPolarPosition(x, y, z);
setCurrentPositionAndDirection(polarPosition);
xOutput.reset();
cOutput.reset();
var _x = xOutput.format(polarPosition.first.x);
var _c = cOutput.format(polarPosition.second.z);
writeBlock(_x, _c, getCode("LOCK_MULTI_AXIS", getSpindle(PART)));
} else {
forceXYZ();
var _x = xOutput.format(x);
var _y = yOutput.format(y);
/*zOutput.format(z)*/
if (_x || _y) {
writeBlock(_x, _y);
}
}
}
function onCycleEnd() {
if (!expandCurrentCycle) {
writeBlock("MCALL"); // end modal cycle
}
zOutput.reset();
onCommand(COMMAND_UNLOCK_MULTI_AXIS);
}
var saveShowSequenceNumbers;
var pathBlockNumber = {start:0, end:0};
function onCyclePath() {
saveShowSequenceNumbers = getProperty("showSequenceNumbers");
// buffer all paths and stop feeds being output
feedOutput.disable();
setProperty("showSequenceNumbers", false);
redirectToBuffer();
//Adding indice in cases of multiple canned cycles calls
writeBlock("START" + integerFormat.format(currentSection.getId()) + ":");
gMotionModal.reset();
xOutput.reset();
zOutput.reset();
}
function onCyclePathEnd() {
writeBlock("END" + integerFormat.format(currentSection.getId()) + ":");
setProperty("showSequenceNumbers", saveShowSequenceNumbers); // reset property to initial state
feedOutput.enable();
var cyclePath = String(getRedirectionBuffer()).split(EOL); // get cycle path from buffer
closeRedirection();
for (line in cyclePath) { // remove empty elements
if (cyclePath[line] == "") {
cyclePath.splice(line);
}
}
var outsideProfiling = cycle.turningMode == 0;
var verticalPasses;
if (cycle.profileRoughingCycle == 0) {
verticalPasses = false;
} else if (cycle.profileRoughingCycle == 1) {
verticalPasses = true;
} else {
error(localize("Unsupported passes type."));
return;
}
// output cycle data
switch (cycleType) {
case "turning-canned-rough":
var NPP = "\"" + "START" + integerFormat.format(currentSection.getId()) + ":END" + integerFormat.format(currentSection.getId()) + "\""; // Name of contour subroutine
var MID = spatialFormat.format(cycle.depthOfCut); // Infeed depth (enter without sign)
//Siemens doesn't use sign for allowance
var FALZ = Math.abs(spatialFormat.format(cycle.zStockToLeave)); // Finishing allowance in the longitudinal axis (enter without sign)
var FALX = Math.abs(xFormat.format(cycle.xStockToLeave)); // Finishing allowance in the transverse axis (enter without sign)
var FAL = 0; // Finishing allowance suitable for contour (enter without sign)
var FF1 = feedFormat.format(cycle.cutfeedrate); // Feedrate for roughing without relief cut
var FF2 = feedFormat.format(cycle.cutfeedrate); //Feedrate for plunging into relief cut element
var FF3 = feedFormat.format(cycle.cutfeedrate); // Feedrate for finishing cut
var VARI = outsideProfiling ? (verticalPasses ? 2 : 1) : (verticalPasses ? 4 : 3); // Machining typeRange of values: 1 ... 12
var DT = 0; // Dwell time fore chip breaking when roughing
var DAM = 0; // Path length after which each roughing step is interrupted for chip breaking
var _VRT = spatialFormat.format(cycle.retractLength); // Lift-off distance from contour when roughing, incremental (to be entered without sign)
writeBlock(
"CYCLE95(" + NPP + ", " + MID + ", " + FALZ + ", " + FALX + ", " + FAL + ", " + FF1 + ", " + FF2 +
", " + FF3 + ", " + VARI + ", " + DT + ", " + DAM + ", " + _VRT + ")"
);
break;
default:
error(localize("Unsupported turning canned cycle."));
}
for (var i = 0; i < cyclePath.length; ++i) {
writeBlock(cyclePath[i]); // output cycle path
setProperty("showSequenceNumbers", saveShowSequenceNumbers); // reset property to initial state
}
}
function onPassThrough(text) {
var commands = String(text).split(",");
for (text in commands) {
writeBlock(commands[text]);
}
}
function onParameter(name, value) {
var invalid = false;
switch (name) {
case "action":
if (String(value).toUpperCase() == "USEPOLARMODE" ||
String(value).toUpperCase() == "USEPOLARINTERPOLATION") {
forcePolarInterpolation = true;
forcePolarCoordinates = false;
} else if (String(value).toUpperCase() == "USEXZCMODE" ||
String(value).toUpperCase() == "USEPOLARCOORDINATES") {
forcePolarCoordinates = true;
forcePolarInterpolation = false;
} else {
invalid = true;
}
}
if (invalid) {
error(localize("Invalid action parameter: ") + value);
return;
}
}
var currentCoolantMode = COOLANT_OFF;
var currentCoolantTurret = 1;
var coolantOff = undefined;
var isOptionalCoolant = false;
var forceCoolant = false;
function setCoolant(coolant, turret) {
var coolantCodes = getCoolantCodes(coolant, turret);
if (Array.isArray(coolantCodes)) {
if (singleLineCoolant) {
skipBlock = isOptionalCoolant;
writeBlock(coolantCodes.join(getWordSeparator()));
} else {
for (var c in coolantCodes) {
skipBlock = isOptionalCoolant;
writeBlock(coolantCodes[c]);
}
}
return undefined;
}
return coolantCodes;
}
function getCoolantCodes(coolant, turret) {
turret = gotMultiTurret ? (turret == undefined ? 1 : turret) : 1;
isOptionalCoolant = false;
var multipleCoolantBlocks = new Array(); // create a formatted array to be passed into the outputted line
if (!coolants) {
error(localize("Coolants have not been defined."));
}
if (tool.type == TOOL_PROBE) { // avoid coolant output for probing
coolant = COOLANT_OFF;
}
if (coolant == currentCoolantMode && turret == currentCoolantTurret) {
if ((typeof operationNeedsSafeStart != "undefined" && operationNeedsSafeStart) && coolant != COOLANT_OFF) {
isOptionalCoolant = true;
} else if (!forceCoolant || coolant == COOLANT_OFF) {
return undefined; // coolant is already active
}
}
if ((coolant != COOLANT_OFF) && (currentCoolantMode != COOLANT_OFF) && (coolantOff != undefined) && !forceCoolant && !isOptionalCoolant) {
if (Array.isArray(coolantOff)) {
for (var i in coolantOff) {
multipleCoolantBlocks.push(coolantOff[i]);
}
} else {
multipleCoolantBlocks.push(coolantOff);
}
}
forceCoolant = false;
var m;
var coolantCodes = {};
for (var c in coolants) { // find required coolant codes into the coolants array
if (coolants[c].id == coolant) {
var localCoolant = parseCoolant(coolants[c], turret);
localCoolant = typeof localCoolant == "undefined" ? coolants[c] : localCoolant;
coolantCodes.on = localCoolant.on;
if (localCoolant.off != undefined) {
coolantCodes.off = localCoolant.off;
break;
} else {
for (var i in coolants) {
if (coolants[i].id == COOLANT_OFF) {
coolantCodes.off = localCoolant.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(m[i]);
}
} else {
multipleCoolantBlocks.push(m);
}
currentCoolantMode = coolant;
currentCoolantTurret = turret;
for (var i in multipleCoolantBlocks) {
if (typeof multipleCoolantBlocks[i] == "number") {
multipleCoolantBlocks[i] = mFormat.format(multipleCoolantBlocks[i]);
}
}
return multipleCoolantBlocks; // return the single formatted coolant value
}
return undefined;
}
function parseCoolant(coolant, turret) {
var localCoolant;
if (getSpindle(TOOL) == SPINDLE_MAIN) {
localCoolant = turret == 1 ? coolant.spindle1t1 : coolant.spindle1t2;
localCoolant = typeof localCoolant == "undefined" ? coolant.spindle1 : localCoolant;
} else if (getSpindle(TOOL) == SPINDLE_LIVE) {
localCoolant = turret == 1 ? coolant.spindleLivet1 : coolant.spindleLivet2;
localCoolant = typeof localCoolant == "undefined" ? coolant.spindleLive : localCoolant;
} else {
localCoolant = turret == 1 ? coolant.spindle2t1 : coolant.spindle2t2;
localCoolant = typeof localCoolant == "undefined" ? coolant.spindle2 : localCoolant;
}
localCoolant = typeof localCoolant == "undefined" ? (turret == 1 ? coolant.turret1 : coolant.turret2) : localCoolant;
localCoolant = typeof localCoolant == "undefined" ? coolant : localCoolant;
return localCoolant;
}
function isSpindleSpeedDifferent() {
var areDifferent = false;
if (isFirstSection()) {
areDifferent = true;
}
if (lastSpindleDirection != tool.clockwise) {
areDifferent = true;
}
if (tool.getSpindleMode() == SPINDLE_CONSTANT_SURFACE_SPEED) {
var _spindleSpeed = tool.surfaceSpeed * ((unit == MM) ? 1 / 1000.0 : 1 / 12.0);
if ((lastSpindleMode != SPINDLE_CONSTANT_SURFACE_SPEED) ||
rpmFormat.areDifferent(lastSpindleSpeed, _spindleSpeed)) {
areDifferent = true;
}
} else {
if ((lastSpindleMode != SPINDLE_CONSTANT_SPINDLE_SPEED) ||
rpmFormat.areDifferent(lastSpindleSpeed, spindleSpeed)) {
areDifferent = true;
}
}
return areDifferent;
}
function onSpindleSpeed(spindleSpeed) {
var useConstantSurfaceSpeed = currentSection.getTool().getSpindleMode() == SPINDLE_CONSTANT_SURFACE_SPEED;
if (rpmFormat.areDifferent(spindleSpeed, sOutput.getCurrent())) {
if (machineState.isTurningOperation || machineState.axialCenterDrilling) { // turning
gSpindleModeModal.reset();
writeBlock(
useConstantSurfaceSpeed ? getCode("CONSTANT_SURFACE_SPEED_ON") : getCode("CONSTANT_SURFACE_SPEED_OFF"),
"S" + getSpindleCode(currentSection) + "=" + sOutput.format(useConstantSurfaceSpeed ? tool.surfaceSpeed * ((unit == MM) ? 1 / 1000.0 : 1 / 12.0) : Math.min(spindleSpeed, getProperty("maximumSpindleSpeed")))
);
} else { // milling
writeBlock(
getCode("CONSTANT_SURFACE_SPEED_OFF"),
"S" + getSpindleCode(currentSection) + "=" + sOutput.format(spindleSpeed)
);
}
}
}
function startSpindle(tappingMode, forceRPMMode, initialPosition) {
gSpindleModeModal.reset();
var useConstantSurfaceSpeed = currentSection.getTool().getSpindleMode() == SPINDLE_CONSTANT_SURFACE_SPEED;
writeBlock(
useConstantSurfaceSpeed ? getCode("CONSTANT_SURFACE_SPEED_ON") : getCode("CONSTANT_SURFACE_SPEED_OFF"),
"S" + getSpindleCode(currentSection) + "=" + sOutput.format(useConstantSurfaceSpeed ? tool.surfaceSpeed * ((unit == MM) ? 1 / 1000.0 : 1 / 12.0) : Math.min(spindleSpeed, getProperty("maximumSpindleSpeed"))),
(tool.clockwise ? getCode("START_SPINDLE_CW", getSpindle(TOOL)) : getCode("START_SPINDLE_CCW", getSpindle(TOOL)))
);
lastSpindleMode = tool.getSpindleMode();
lastSpindleSpeed = spindleSpeed;
lastSpindleDirection = tool.clockwise;
forceSpindleSpeed = false;
}
function onCommand(command) {
switch (command) {
case COMMAND_COOLANT_OFF:
setCoolant(COOLANT_OFF);
break;
case COMMAND_COOLANT_ON:
setCoolant(tool.coolant);
break;
case COMMAND_SPINDLE_CLOCKWISE:
writeBlock(getCode("START_SPINDLE_CW", getSpindle(TOOL)));
break;
case COMMAND_SPINDLE_COUNTERCLOCKWISE:
writeBlock(getCode("START_SPINDLE_CCW", getSpindle(TOOL)));
break;
case COMMAND_LOCK_MULTI_AXIS:
writeBlock(getCode("LOCK_MULTI_AXIS", getSpindle(PART)));
break;
case COMMAND_UNLOCK_MULTI_AXIS:
writeBlock(getCode("UNLOCK_MULTI_AXIS", getSpindle(PART)));
break;
case COMMAND_START_CHIP_TRANSPORT:
writeBlock(mFormat.format(31));
break;
case COMMAND_STOP_CHIP_TRANSPORT:
writeBlock(mFormat.format(33));
break;
case COMMAND_OPEN_DOOR:
break;
case COMMAND_CLOSE_DOOR:
break;
case COMMAND_BREAK_CONTROL:
break;
case COMMAND_TOOL_MEASURE:
break;
case COMMAND_ACTIVATE_SPEED_FEED_SYNCHRONIZATION:
break;
case COMMAND_DEACTIVATE_SPEED_FEED_SYNCHRONIZATION:
break;
case COMMAND_STOP:
writeBlock(mFormat.format(0));
forceSpindleSpeed = true;
forceCoolant = true;
break;
case COMMAND_OPTIONAL_STOP:
writeBlock(mFormat.format(1));
forceSpindleSpeed = true;
forceCoolant = true;
break;
case COMMAND_END:
writeBlock(mFormat.format(2));
break;
case COMMAND_STOP_SPINDLE:
lastSpindleSpeed = 0;
lastSpindleDirection = undefined;
break;
case COMMAND_ORIENTATE_SPINDLE:
/*
if (currentSection.getType() == TYPE_TURNING) {
if (currentSection.spindle == SPINDLE_PRIMARY) {
writeBlock(mFormat.format(19)); // use P or R to set angle (optional)
} else {
writeBlock(mFormat.format(119));
}
} else {
if (isSameDirection(currentSection.workPlane.forward, new Vector(0, 0, 1))) {
writeBlock(mFormat.format(19)); // use P or R to set angle (optional)
} else if (isSameDirection(currentSection.workPlane.forward, new Vector(0, 0, -1))) {
writeBlock(mFormat.format(119));
} else {
error(localize("Spindle orientation is not supported for live tooling."));
return;
}
}
*/
break;
default:
onUnsupportedCommand(command);
}
}
function getG17Code() {
return machineState.usePolarInterpolation ? 17 : 17;
}
function engagePartCatcher(engage) {
if (engage) {
// catch part here
writeBlock(getCode("PART_CATCHER_ON"), formatComment(localize("PART CATCHER ON")));
} else {
onCommand(COMMAND_COOLANT_OFF);
writeRetract(currentSection, true); // retract in X,Y,Z
writeBlock(getCode("PART_CATCHER_OFF"), formatComment(localize("PART CATCHER OFF")));
forceXYZ();
}
}
function onSectionEnd() {
if (machineState.usePolarInterpolation) {
setPolarInterpolation(false); // disable polar interpolation mode
}
if (isPolarModeActive()) {
setPolarCoordinates(false); // disable Polar coordinates mode
}
if (currentSection.partCatcher) {
engagePartCatcher(false);
}
if (((getCurrentSectionId() + 1) >= getNumberOfSections()) ||
(tool.number != getNextSection().getTool().number)) {
onCommand(COMMAND_BREAK_CONTROL);
}
if (hasNextSection()) {
if (getNextSection().getTool().coolant != currentSection.getTool().coolant) {
setCoolant(COOLANT_OFF);
}
}
forcePolarCoordinates = false;
forcePolarInterpolation = false;
forceAny();
}
function onClose() {
writeln("");
optionalSection = false;
onCommand(COMMAND_COOLANT_OFF);
if (getProperty("gotChipConveyor")) {
onCommand(COMMAND_STOP_CHIP_TRANSPORT);
}
forceWorkPlane();
if (getNumberOfSections() > 0) {
var section = getSection(getNumberOfSections() - 1);
if ((section.getType() != TYPE_TURNING) && isSameDirection(section.workPlane.forward, new Vector(0, 0, 1))) {
writeRetract(currentSection, true); // retract in X,Y,Z
zOutput.reset();
writeBlock(getCode("STOP_SPINDLE", SPINDLE_LIVE));
} else {
writeRetract(currentSection, true); // retract in X,Y,Z
writeBlock(getCode("STOP_SPINDLE", getSpindle(PART)));
}
}
if (machineState.tailstockIsActive) {
writeBlock(getCode("TAILSTOCK_OFF"));
}
forceWorkPlane();
writeBlock(getCode("DISENABLE_C_AXIS", getSpindle(PART)));
if (gotBarFeeder) {
writeln("");
writeComment(localize("Bar feed"));
// specify your code here for bar feeder
}
writeBlock("TRANS_OFF");
writeBlock("ROT");
writeln("");
onImpliedCommand(COMMAND_END);
onImpliedCommand(COMMAND_STOP_SPINDLE);
writeBlock(mFormat.format(30)); // stop program, spindle stop, coolant off
writeln("%");
}
function getSpindleCode(section) {
if (section.spindle == SPINDLE_PRIMARY) { // mainspindle
if (machineState.isTurningOperation || machineState.axialCenterDrilling) {
return mainSpindleAxisName[1];
} else {
return liveToolSpindleAxisName[1]; // milling live tool
}
} else { // subspindle
if (machineState.isTurningOperation || machineState.axialCenterDrilling) {
return subSpindleAxisName[1];
} else {
return liveToolSpindleAxisName[1]; // milling live tool
}
}
}
function getNextToolDescription(description) {
var currentSectionId = getCurrentSectionId();
if (currentSectionId < 0) {
return null;
}
for (var i = currentSectionId + 1; i < getNumberOfSections(); ++i) {
var section = getSection(i);
var sectionTool = section.getTool();
if (description != sectionTool.description) {
return sectionTool; // found next tool
}
}
return null; // not found
}