/** Copyright (C) 2012-2024 by Autodesk, Inc. All rights reserved. HAAS post processor configuration. $Revision: 44116 675ded3d2b678de7ff4f524dcf3065cebb51fe70 $ $Date: 2024-03-22 10:19:38 $ FORKID {DBD402DA-DE90-4634-A6A3-0AE5CC97DEC7} */ //////////////////////////////////////////////////////////////////////////////////////////////// // MANUAL NC COMMANDS // // The following ACTION commands are supported by this post. // // CYCLE_REVERSAL - Reverses the spindle in a drilling cycle // USEPOLARMODE - Enables polar interpolation for the following operation. // VFD_HIGH - Uses high pressure flood coolant if machine has VFD // VFD_LOW - Uses low pressure flood coolant if machine has VFD // VFD_NORMAL - Uses normal pressure flood coolant if machine has VFD // //////////////////////////////////////////////////////////////////////////////////////////////// description = "HAAS - Next Generation Control"; vendor = "Haas Automation"; vendorUrl = "https://www.haascnc.com"; legal = "Copyright (C) 2012-2024 by Autodesk, Inc."; certificationLevel = 2; minimumRevision = 45917; longDescription = "Generic post for the HAAS Next Generation control. The post includes support for multi-axis indexing and simultaneous machining. The post utilizes the dynamic work offset feature so you can place your work piece as desired without having to repost your NC programs." + EOL + "You can specify following pre-configured machines by using the property 'Machine model':" + EOL + "UMC-500" + EOL + "UMC-750" + EOL + "UMC-1000" + EOL + "UMC-1600-H"; extension = "nc"; programNameIsInteger = true; setCodePage("ascii"); keywords = "MODEL_IMAGE PREVIEW_IMAGE"; capabilities = CAPABILITY_MILLING | CAPABILITY_MACHINE_SIMULATION; tolerance = spatial(0.002, MM); minimumChordLength = spatial(0.25, MM); minimumCircularRadius = spatial(0.01, MM); maximumCircularRadius = spatial(1000, MM); minimumCircularSweep = toRad(0.01); maximumCircularSweep = toRad(355); allowHelicalMoves = true; allowedCircularPlanes = undefined; // allow any circular motion allowSpiralMoves = true; allowFeedPerRevolutionDrilling = true; highFeedrate = (unit == IN) ? 650 : 5000; probeMultipleFeatures = true; // user-defined properties properties = { machineModel: { title : "Machine model", description: "Specifies the pre-configured machine model.", group : "configuration", type : "enum", values : [ {title:"None", id:"none"}, {title:"UMC-500", id:"umc-500"}, {title:"UMC-750", id:"umc-750"}, {title:"UMC-1000", id:"umc-1000"}, {title:"UMC-1600-H", id:"umc-1600"} ], value: "none", scope: "post" }, hasAAxis: { title : "Has A-axis rotary", description: "Enable if the machine has an A-axis table/trunnion. Check the table direction on the machine and use the (Reversed) selection if the table is moving in the opposite direction.", group : "configuration", type : "enum", values : [ {title:"No", id:"false"}, {title:"Yes", id:"true"}, {title:"Reversed", id:"reversed"} ], value: "false", scope: "post" }, hasBAxis: { title : "Has B-axis rotary", description: "Enable if the machine has a B-axis table/trunnion. Check the table direction on the machine and use the (Reversed) selection if the table is moving in the opposite direction.", group : "configuration", type : "enum", values : [ {title:"No", id:"false"}, {title:"Yes", id:"true"}, {title:"Reversed", id:"reversed"} ], value: "false", scope: "post" }, hasCAxis: { title : "Has C-axis rotary", description: "Enable if the machine has a C-axis table. Specifies a trunnion setup if an A-axis or B-axis is defined. Check the table direction on the machine and use the (Reversed) selection if the table is moving in the opposite direction.", group : "configuration", type : "enum", values : [ {title:"No", id:"false"}, {title:"Yes", id:"true"}, {title:"Reversed", id:"reversed"} ], value: "false", scope: "post" }, useDPMFeeds: { title : "Rotary moves use DPM feeds", description: "Enable to output DPM feeds, disable for Inverse Time feeds with rotary axes moves.", group : "multiAxis", type : "boolean", value : false, scope : "post" }, useTCP: { title : "Use TCPC programming", description: "The control supports Tool Center Point Control programming.", group : "multiAxis", type : "boolean", value : true, scope : "post" }, useTiltedWorkplane: { title : "Use DWO", description: "Specifies that the Dynamic Work Offset feature (G254/G255) should be used.", group : "multiAxis", type : "boolean", value : true, scope : "post" }, preloadTool: { title : "Preload tool", description: "Preloads the next tool at a tool change (if any).", group : "preferences", type : "boolean", value : true, scope : "post" }, gotChipConveyor: { title : "Use chip transport", description: "Enable to turn on chip transport at start of program.", group : "configuration", type : "boolean", value : false, scope : "post" }, optionalStop: { title : "Optional stop", description: "Specifies that optional stops M1 should be output at tool changes.", group : "preferences", type : "boolean", value : true, 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" }, useRadius: { title : "Radius arcs", description: "If yes is selected, arcs are output using radius values rather than IJK.", group : "preferences", type : "boolean", value : false, scope : "post" }, useG0: { title : "Use G0", description: "Specifies that G0s should be used for rapid moves when moving along a single axis.", group : "preferences", type : "boolean", value : false, scope : "post" }, safePositionMethod: { title : "Safe Retracts", description: "Select your desired retract option. 'Clearance Height' retracts to the operation clearance height.", group : "homePositions", type : "enum", values : [ {title:"G28", id:"G28"}, {title:"G53", id:"G53"}, {title:"Clearance Height", id:"clearanceHeight"} ], value: "G53", scope: "post" }, useSmoothing: { title : "Use G187", description: "G187 smoothing mode.", group : "preferences", type : "enum", values : [ {title:"Off", id:"-1"}, {title:"Automatic", id:"9999"}, {title:"Rough", id:"1"}, {title:"Medium", id:"2"}, {title:"Finish", id:"3"} ], value: "-1", scope: "post" }, homePositionCenter: { title : "Home position center", description: "Enable to center the part along X at the end of program for easy access. Requires a CNC with a moving table.", group : "homePositions", type : "boolean", value : false, scope : "post" }, optionallyCycleToolsAtStart: { title : "Optionally cycle tools at start", description: "Cycle through each tool used at the beginning of the program when block delete is turned off.", group : "preferences", type : "boolean", value : false, scope : "post" }, measureTools: { title : "Optionally measure tools at start", description: "Measure each tool used at the beginning of the program when block delete is turned off.", group : "preferences", type : "boolean", value : false, scope : "post" }, forceHomeOnIndexing: { title : "Force XY home position on indexing", description: "Move XY to their home positions on multi-axis indexing.", group : "homePositions", type : "boolean", value : true, scope : "post" }, toolBreakageTolerance: { title : "Tool breakage tolerance", description: "Specifies the tolerance for which tool break detection will raise an alarm.", group : "preferences", type : "spatial", value : 0.1, scope : "post" }, toolArmDrive: { title : "Machine has a tool setting probe arm", description: "Outputs M104/M105 to extend/retract the tool setting probe arm", group : "configuration", type : "boolean", value : false, scope : "post" }, useSSV: { title : "Use SSV", description: "Outputs M138/M139 to enable Spindle Speed Variation (SSV).", group : "preferences", type : "boolean", value : false, scope : "post" }, safeStartAllOperations: { title : "Safe start all operations", description: "Write optional blocks at the beginning of all operations that include all commands to start program.", group : "preferences", type : "boolean", value : false, scope : "post" }, fastToolChange: { title : "Fast tool change", description: "Skip spindle off, coolant off, and Z retract to make tool change quicker.", group : "preferences", type : "boolean", value : false, scope : "post" }, useG95forTapping: { title : "Use G95 for tapping", description: "use IPR/MPR instead of IPM/MPM for tapping", group : "preferences", type : "boolean", value : false, scope : "post" }, safeRetractDistance: { title : "Safe retract distance", description: "Specifies the distance to add to retract distance when rewinding rotary axes.", group : "multiAxis", type : "spatial", value : 0, scope : "post" }, writeVersion: { title : "Write version", description: "Write the version number in the header of the code.", group : "formats", type : "boolean", value : false, 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", scope: "post" }, sequenceNumberStart: { title : "Start sequence number", description: "The number at which to start the sequence numbers.", group : "formats", type : "integer", value : 10, 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 : 5, scope : "post" }, showNotes: { title : "Show notes", description: "Enable to output notes for operations.", group : "formats", type : "boolean", value : false, scope : "post" }, useM130PartImages: { title : "Include M130 part images", description: "Enable to include M130 part images with the NC file.", group : "formats", type : "boolean", value : false, scope : "post" }, useM130ToolImages: { title : "Include M130 tool images", description: "Enable to include M130 tool images with the NC file.", group : "formats", type : "boolean", value : false, scope : "post" }, coolantPressure: { title : "Coolant pressure", description: "Select the coolant pressure if equipped with a Variable Frequency Drive. Select 'Default' if this option is not installed.", group : "preferences", type : "enum", values : [ {title:"Default", id:""}, {title:"Low", id:"P0"}, {title:"Normal", id:"P1"}, {title:"High", id:"P2"} ], value: "", scope: "post" }, singleResultsFile: { title : "Create single results file", description: "Set to false if you want to store the measurement results for each probe / inspection toolpath in a separate file", group : "probing", type : "boolean", value : true, scope : "post" }, useClampCodes: { title : "Use clamp codes", description: "Specifies whether clamp codes for rotary axes should be output. For simultaneous toolpaths rotary axes will always get unclamped.", group : "multiAxis", type : "boolean", value : true, scope : "post" } }; // wcs definiton wcsDefinitions = { useZeroOffset: false, wcs : [ {name:"Standard", format:"G", range:[54, 59]}, {name:"Extended", format:"G154 P", range:[1, 99]} ] }; // old machines only support 4 digits var oFormat = createFormat({width:5, zeropad:true, decimals:0}); var nFormat = createFormat({decimals:0}); var gFormat = createFormat({prefix:"G", decimals:0}); var mFormat = createFormat({prefix:"M", decimals:0}); var hFormat = createFormat({prefix:"H", decimals:0}); var diameterOffsetFormat = createFormat({prefix:"D", decimals:1}); var probeWCSFormat = createFormat({prefix:"S", decimals:0, forceDecimal:true}); var probeExtWCSFormat = createFormat({prefix:"S154.", width:2, zeropad:true, decimals:0}); var xyzFormat = createFormat({decimals:(unit == MM ? 3 : 4), forceDecimal:true}); var rFormat = xyzFormat; // radius var abcFormat = createFormat({decimals:3, forceDecimal:true, scale:DEG}); var feedFormat = createFormat({decimals:(unit == MM ? 2 : 3), forceDecimal:true}); var feedPerRevFormat = createFormat({decimals:(unit == MM ? 3 : 4), forceDecimal:true}); var inverseTimeFormat = createFormat({decimals:3, forceDecimal:true}); var pitchFormat = createFormat({decimals:(unit == MM ? 3 : 4), forceDecimal:true}); var toolFormat = createFormat({decimals:0}); var rpmFormat = createFormat({decimals:0}); var secFormat = createFormat({decimals:3, forceDecimal:true}); // seconds - range 0.001-1000 var milliFormat = createFormat({decimals:0}); // milliseconds // range 1-9999 var taperFormat = createFormat({decimals:1, scale:DEG}); var xOutput = createOutputVariable({onchange:function() {state.retractedX = false;}, prefix:"X"}, xyzFormat); var yOutput = createOutputVariable({onchange:function() {state.retractedY = false;}, prefix:"Y"}, xyzFormat); var zOutput = createOutputVariable({onchange:function() {state.retractedZ = false;}, prefix:"Z"}, xyzFormat); var aOutput = createOutputVariable({prefix:"A"}, abcFormat); var bOutput = createOutputVariable({prefix:"B"}, abcFormat); var cOutput = createOutputVariable({prefix:"C"}, abcFormat); var feedOutput = createOutputVariable({prefix:"F"}, feedFormat); var inverseTimeOutput = createOutputVariable({prefix:"F", control:CONTROL_FORCE}, inverseTimeFormat); var pitchOutput = createOutputVariable({prefix:"F", control:CONTROL_FORCE}, pitchFormat); var sOutput = createOutputVariable({prefix:"S", control:CONTROL_FORCE}, rpmFormat); // circular output var iOutput = createOutputVariable({prefix:"I", control:CONTROL_FORCE}, xyzFormat); var jOutput = createOutputVariable({prefix:"J", control:CONTROL_FORCE}, xyzFormat); var kOutput = createOutputVariable({prefix:"K", control:CONTROL_FORCE}, xyzFormat); var gMotionModal = createOutputVariable({onchange:function() {if (skipBlocks) {forceModals(gMotionModal);}}}, gFormat); // modal group 1 // G0-G3, ... var gPlaneModal = createOutputVariable({onchange:function() {if (skipBlocks) {forceModals(gPlaneModal);} forceModals(gMotionModal);}}, gFormat); // modal group 2 // G17-19 var gAbsIncModal = createOutputVariable({onchange:function() {if (skipBlocks) {forceModals(gAbsIncModal);}}}, gFormat); // modal group 3 // G90-91 var gFeedModeModal = createOutputVariable({}, gFormat); // modal group 5 // G93-94 var gUnitModal = createOutputVariable({}, gFormat); // modal group 6 // G20-21 var gCycleModal = createOutputVariable({}, gFormat); // modal group 9 // G81, ... var gRetractModal = createOutputVariable({control:CONTROL_FORCE}, gFormat); // modal group 10 // G98-99 var gWorkplaneModal = createOutputVariable({}, gFormat); // G254-G255 var gRotationModal = createOutputVariable({ onchange: function () { if (probeVariables.probeAngleMethod == "G68") { probeVariables.outputRotationCodes = true; } } }, gFormat); // modal group 16 // G68-G69 var ssvModal = createOutputVariable({}, mFormat); // M138, M139 var mClampModal = createModalGroup( {strict:false}, [ [10, 11], // 4th axis clamp / unclamp [12, 13] // 5th axis clamp / unclamp ], mFormat ); var mProbeArmModal = createOutputVariable({}, mFormat); // M104, M105 extend / retract the tool setting probe arm var skipBlocks = false; var settings = { coolant: { // samples: // {id: COOLANT_THROUGH_TOOL, on: 88, off: 89} // {id: COOLANT_THROUGH_TOOL, on: [8, 88], off: [9, 89]} // {id: COOLANT_THROUGH_TOOL, on: "M88 P3 (myComment)", off: "M89"} coolants: [ {id:COOLANT_FLOOD, on:8}, {id:COOLANT_MIST}, {id:COOLANT_THROUGH_TOOL, on:88, off:89}, {id:COOLANT_AIR, on:83, off:84}, {id:COOLANT_AIR_THROUGH_TOOL, on:73, off:74}, {id:COOLANT_SUCTION}, {id:COOLANT_FLOOD_MIST}, {id:COOLANT_FLOOD_THROUGH_TOOL, on:[88, 8], off:[89, 9]}, {id:COOLANT_OFF, off:9} ], singleLineCoolant: false, // specifies to output multiple coolant codes in one line rather than in separate lines }, smoothing: { roughing : 1, // roughing level for smoothing in automatic mode semi : 2, // semi-roughing level for smoothing in automatic mode semifinishing : 2, // semi-finishing level for smoothing in automatic mode finishing : 3, // finishing level for smoothing in automatic mode thresholdRoughing : toPreciseUnit(0.5, MM), // operations with stock/tolerance above that threshold will use roughing level in automatic mode thresholdFinishing : toPreciseUnit(0.05, MM), // operations with stock/tolerance below that threshold will use finishing level in automatic mode thresholdSemiFinishing: toPreciseUnit(0.1, MM), // operations with stock/tolerance above finishing and below threshold roughing that threshold will use semi finishing level in automatic mode differenceCriteria: "level", // options: "level", "tolerance", "both". Specifies criteria when output smoothing codes autoLevelCriteria : "stock", // use "stock" or "tolerance" to determine levels in automatic mode cancelCompensation: false // tool length compensation must be canceled prior to changing the smoothing level }, retract: { cancelRotationOnRetracting: true, // specifies that rotations (G68) need to be canceled prior to retracting methodXY : "G53", // special condition, overwrite retract behavior per axis methodZ : undefined, // special condition, overwrite retract behavior per axis useZeroValues : ["G28", "G30"], // enter property value id(s) for using "0" value instead of machineConfiguration axes home position values (ie G30 Z0) homeXY : {onIndexing:false, onToolChange:false, onProgramEnd:{axes:[X, Y]}} // Specifies when the machine should be homed in X/Y. Sample: onIndexing:{axes:[X, Y], singleLine:false} }, parametricFeeds: { firstFeedParameter : 100, // specifies the initial parameter number to be used for parametric feedrate output feedAssignmentVariable: "#", // specifies the syntax to define a parameter feedOutputVariable : "F#" // specifies the syntax to output the feedrate as parameter }, unwind: { method : 1, // 1 (move to closest 0 (G28)) or 2 (table does not move (G92)) codes : [gFormat.format(28), gAbsIncModal.format(91)], // formatted code(s) that will (virtually) unwind axis (G90 G28), (G92), etc. workOffsetCode: "", // prefix for workoffset number if it is required to be output useAngle : "true", // 'true' outputs angle with standard output variable, 'prefix' uses 'anglePrefix', 'false' does not output angle anglePrefix : [], // optional prefixes for output angles specified as ["", "", "C"], use blank string if axis does not unwind resetG90 : true // set to 'true' if G90 needs to be output after the unwind block }, machineAngles: { // refer to https://cam.autodesk.com/posts/reference/classMachineConfiguration.html#a14bcc7550639c482492b4ad05b1580c8 controllingAxis: ABC, type : PREFER_PREFERENCE, options : ENABLE_ALL }, workPlaneMethod: { useTiltedWorkplane : true, // specifies that tilted workplanes should be used (ie. G68.2, G254, PLANE SPATIAL, CYCLE800), can be overwritten by property eulerConvention : undefined, // specifies the euler convention (ie EULER_XYZ_R), set to undefined to use machine angles for TWP commands ('undefined' requires machine configuration) eulerCalculationMethod: "standard", // ('standard' / 'machine') 'machine' adjusts euler angles to match the machines ABC orientation, machine configuration required cancelTiltFirst : true, // cancel tilted workplane prior to WCS (G54-G59) blocks useABCPrepositioning : true, // position ABC axes prior to tilted workplane blocks forceMultiAxisIndexing: false, // force multi-axis indexing for 3D programs optimizeType : undefined // can be set to OPTIMIZE_NONE, OPTIMIZE_BOTH, OPTIMIZE_TABLES, OPTIMIZE_HEADS, OPTIMIZE_AXIS. 'undefined' uses legacy rotations }, subprograms: { initialSubprogramNumber: 90000, // specifies the initial number to be used for subprograms. 'undefined' uses the main program number minimumCyclePoints : 5, // minimum number of points in cycle operation to consider for subprogram format : oFormat, // the format to use for the subprogam number format // objects below also accept strings with "%currentSubprogram" as placeholder. Sample: {files:["%"], embedded:"N" + "%currentSubprogram"} files : {extension:extension, prefix:undefined}, // specifies the subprogram file extension and the prefix to use for the generated file startBlock : {files:["%" + EOL + "O"], embedded:["N"]}, // specifies the start syntax of a subprogram followed by the subprogram number endBlock : {files:[mFormat.format(99) + EOL + "%"], embedded:[mFormat.format(99)]}, // specifies the command to for the end of a subprogram callBlock : {files:[mFormat.format(98) + " P"], embedded:[mFormat.format(97) + " P"]} // specifies the command for calling a subprogram followed by the subprogram number }, comments: { permittedCommentChars: " abcdefghijklmnopqrstuvwxyz0123456789.,=_-+:", // letters are not case sensitive, use option 'outputFormat' below. Set to 'undefined' to allow any character prefix : "(", // specifies the prefix for the comment suffix : ")", // specifies the suffix for the comment outputFormat : "ignoreCase", // can be set to "upperCase", "lowerCase" and "ignoreCase". Set to "ignoreCase" to write comments without upper/lower case formatting maximumLineLength : 80 // the maximum number of characters allowed in a line, set to 0 to disable comment output }, probing: { macroCall : gFormat.format(65), // specifies the command to call a macro probeAngleMethod : undefined, // supported options are: OFF, AXIS_ROT, G68, G54.4. 'undefined' uses automatic selection probeAngleVariables : {x:"#185", y:"#186", r:"#194", baseParamG54x4:26000, baseParamAxisRot:5200, method:1}, // specifies variables for the angle compensation macros, method 0 = Fanuc, 1 = Haas allowIndexingWCSProbing: false // specifies that probe WCS with tool orientation is supported }, maximumSequenceNumber: 99999, // the maximum sequence number (Nxxx), use 'undefined' for unlimited programNumber : {min:1, max:99999, reserved:[Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY]} // specifies the program number range and reserved numbers }; // fixed settings var forceResetWorkPlane = false; // enable to force reset of machine ABC on new orientation // collected state var coolantPressure = ""; var currentCoolantPressure = ""; var maximumCircularRadiiDifference = toPreciseUnit(0.005, MM); var hasA = false; var hasB = false; var hasC = false; var measureTool = false; var cycleReverse = false; var homePositionCenter = false; var toolChecked = false; // specifies that the tool has been checked with the probe /** Returns the matching HAAS tool type for the tool. */ function getHaasToolType(toolType) { switch (toolType) { case TOOL_DRILL: case TOOL_REAMER: return 1; // drill case TOOL_TAP_RIGHT_HAND: case TOOL_TAP_LEFT_HAND: return 2; // tap case TOOL_MILLING_FACE: case TOOL_MILLING_SLOT: case TOOL_BORING_BAR: return 3; // shell mill case TOOL_MILLING_END_FLAT: case TOOL_MILLING_END_BULLNOSE: case TOOL_MILLING_TAPERED: case TOOL_MILLING_DOVETAIL: return 4; // end mill case TOOL_DRILL_SPOT: case TOOL_MILLING_CHAMFER: case TOOL_DRILL_CENTER: case TOOL_COUNTER_SINK: case TOOL_COUNTER_BORE: case TOOL_MILLING_THREAD: case TOOL_MILLING_FORM: return 5; // center drill case TOOL_MILLING_END_BALL: case TOOL_MILLING_LOLLIPOP: return 6; // ball nose case TOOL_PROBE: return 7; // probe default: error(localize("Invalid HAAS tool type.")); return -1; } } function getHaasProbingType(toolType, use9023) { switch (getHaasToolType(toolType)) { case 3: case 4: return (use9023 ? 23 : 1); // rotate case 1: case 2: case 5: case 6: case 7: return (use9023 ? 12 : 2); // non rotate case 0: return (use9023 ? 13 : 3); // rotate length and dia default: error(localize("Invalid HAAS tool type.")); return -1; } } function writeToolCycleBlock(tool) { writeBlock("T" + toolFormat.format(tool.number), mFormat.format(6)); // get tool writeBlock(mFormat.format(0)); // wait for operator } function prepareForToolCheck() { onCommand(COMMAND_STOP_SPINDLE); onCommand(COMMAND_COOLANT_OFF); // cancel TCP so that tool doesn't follow tables disableLengthCompensation(false, "TCPC OFF"); if (getCurrentDirection().length != 0) { setWorkPlane(new Vector(0, 0, 0)); forceWorkPlane(); } if (getProperty("toolArmDrive")) { writeBlock(mProbeArmModal.format(104), formatComment("Extend tool setting probe arm")); } } function writeToolMeasureBlock(tool, preMeasure) { var comment = measureTool ? formatComment("MEASURE TOOL") : ""; if (!preMeasure) { prepareForToolCheck(); } if (true) { // use Macro P9023 to measure tools var probingType = getHaasProbingType(tool.type, true); writeBlock( gFormat.format(65), "P9023", "A" + probingType + ".", "T" + toolFormat.format(tool.number), conditional((probingType != 12), "H" + xyzFormat.format(getBodyLength(tool))), conditional((probingType != 12), "D" + xyzFormat.format(tool.diameter)), comment ); } else { // use Macro P9995 to measure tools writeBlock("T" + toolFormat.format(tool.number), mFormat.format(6)); // get tool writeBlock( gFormat.format(65), "P9995", "A0.", "B" + getHaasToolType(tool.type) + ".", "C" + getHaasProbingType(tool.type, false) + ".", "T" + toolFormat.format(tool.number), "E" + xyzFormat.format(getBodyLength(tool)), "D" + xyzFormat.format(tool.diameter), "K" + xyzFormat.format(0.1), "I0.", comment ); // probe tool } if (getProperty("toolArmDrive") && !preMeasure) { writeBlock(mProbeArmModal.format(105), formatComment("Retract tool setting probe arm")); } measureTool = false; } function defineMachineModel() { var useTCP = getProperty("useTCP"); switch (getProperty("machineModel")) { case "umc-500": var axis1 = createAxis({coordinate:1, table:true, axis:[0, 1, 0], range:[-35, 120], preference:1, tcp:useTCP}); var axis2 = createAxis({coordinate:2, table:true, axis:[0, 0, 1], cyclic:true, preference:0, reset:1, tcp:useTCP}); machineConfiguration = new MachineConfiguration(axis1, axis2); machineConfiguration.setHomePositionX(toPreciseUnit(-23.96, IN)); machineConfiguration.setHomePositionY(toPreciseUnit(-3.37, IN)); machineConfiguration.setRetractPlane(toPreciseUnit(0, IN)); settings.maximumSpindleRPM = 8100; break; case "umc-750": var axis1 = createAxis({coordinate:1, table:true, axis:[0, 1, 0], range:[-35, 120], preference:1, tcp:useTCP}); var axis2 = createAxis({coordinate:2, table:true, axis:[0, 0, 1], cyclic:true, preference:0, reset:1, tcp:useTCP}); machineConfiguration = new MachineConfiguration(axis1, axis2); machineConfiguration.setHomePositionX(toPreciseUnit(-29.0, IN)); machineConfiguration.setHomePositionY(toPreciseUnit(-8, IN)); machineConfiguration.setRetractPlane(toPreciseUnit(2.5, IN)); settings.maximumSpindleRPM = 8100; break; case "umc-1000": var axis1 = createAxis({coordinate:1, table:true, axis:[0, 1, 0], range:[-35, 120], preference:1, tcp:useTCP}); var axis2 = createAxis({coordinate:2, table:true, axis:[0, 0, 1], cyclic:true, preference:0, reset:1, tcp:useTCP}); machineConfiguration = new MachineConfiguration(axis1, axis2); machineConfiguration.setHomePositionX(toPreciseUnit(-40.07, IN)); machineConfiguration.setHomePositionY(toPreciseUnit(-10.76, IN)); machineConfiguration.setRetractPlane(toPreciseUnit(0, IN)); settings.maximumSpindleRPM = 8100; break; case "umc-1600": var axis1 = createAxis({coordinate:1, table:true, axis:[0, 1, 0], range:[-120, 120], preference:1, tcp:useTCP}); var axis2 = createAxis({coordinate:2, table:true, axis:[0, 0, 1], cyclic:true, preference:0, reset:1, tcp:useTCP}); machineConfiguration = new MachineConfiguration(axis1, axis2); machineConfiguration.setHomePositionX(toPreciseUnit(0, IN)); machineConfiguration.setHomePositionY(toPreciseUnit(0, IN)); machineConfiguration.setRetractPlane(toPreciseUnit(0, IN)); settings.maximumSpindleRPM = 7500; break; } machineConfiguration.setModel(getProperty("machineModel").toUpperCase()); machineConfiguration.setVendor("Haas Automation"); setMachineConfiguration(machineConfiguration); if (receivedMachineConfiguration) { warning(localize("The provided CAM machine configuration is overwritten by the postprocessor.")); receivedMachineConfiguration = false; // CAM provided machine configuration is overwritten } } var compensateToolLength = false; // add the tool length to the pivot distance for nonTCP rotary heads function defineMachine() { hasA = getProperty("hasAAxis") != "false"; hasB = getProperty("hasBAxis") != "false"; hasC = getProperty("hasCAxis") != "false"; var useTCP = getProperty("useTCP"); if (hasA && hasB && hasC) { error(localize("Only two rotary axes can be active at the same time.")); return; } else if ((hasA || hasB || hasC) && getProperty("machineModel") != "none") { error(localize("You can only select either a machine model or use the ABC axis properties.")); return; } else if (((hasA || hasB || hasC) || getProperty("machineModel") != "none") && (receivedMachineConfiguration && machineConfiguration.isMultiAxisConfiguration())) { error(localize("You can only select either a machine in the CAM setup or use the properties to define your kinematics.")); return; } if (getProperty("machineModel") == "none") { if (hasA || hasB || hasC) { // configure machine var aAxis; var bAxis; var cAxis; if (hasA) { // A Axis - For horizontal machines and trunnions var dir = getProperty("hasAAxis") == "reversed" ? -1 : 1; if (hasC || hasB) { var aMin = (dir == 1) ? -120 - 0.0001 : -30 - 0.0001; var aMax = (dir == 1) ? 30 + 0.0001 : 120 + 0.0001; aAxis = createAxis({coordinate:0, table:true, axis:[dir, 0, 0], range:[aMin, aMax], preference:dir, reset:(hasB ? 0 : 1), tcp:useTCP}); } else { aAxis = createAxis({coordinate:0, table:true, axis:[dir, 0, 0], cyclic:true, tcp:useTCP}); } } if (hasB) { // B Axis - For horizontal machines and trunnions var dir = getProperty("hasBAxis") == "reversed" ? -1 : 1; if (hasC) { var bMin = (dir == 1) ? -120 - 0.0001 : -30 - 0.0001; var bMax = (dir == 1) ? 30 + 0.0001 : 120 + 0.0001; bAxis = createAxis({coordinate:1, table:true, axis:[0, dir, 0], range:[bMin, bMax], preference:-dir, reset:1, tcp:useTCP}); } else if (hasA) { bAxis = createAxis({coordinate:1, table:true, axis:[0, 0, dir], cyclic:true, tcp:useTCP}); } else { bAxis = createAxis({coordinate:1, table:true, axis:[0, dir, 0], cyclic:true, tcp:useTCP}); } } if (hasC) { // C Axis - For trunnions only var dir = getProperty("hasCAxis") == "reversed" ? -1 : 1; cAxis = createAxis({coordinate:2, table:true, axis:[0, 0, dir], cyclic:true, reset:1, tcp:useTCP}); } if (hasA && hasC) { // AC trunnion machineConfiguration = new MachineConfiguration(aAxis, cAxis); } else if (hasB && hasC) { // BC trunnion machineConfiguration = new MachineConfiguration(bAxis, cAxis); } else if (hasA && hasB) { // AB trunnion machineConfiguration = new MachineConfiguration(aAxis, bAxis); } else if (hasA) { // A rotary machineConfiguration = new MachineConfiguration(aAxis); } else if (hasB) { // B rotary - horizontal machine only machineConfiguration = new MachineConfiguration(bAxis); } else if (hasC) { // C rotary machineConfiguration = new MachineConfiguration(cAxis); } setMachineConfiguration(machineConfiguration); if (receivedMachineConfiguration) { warning(localize("The provided CAM machine configuration is overwritten by the postprocessor.")); receivedMachineConfiguration = false; // CAM provided machine configuration is overwritten } } } else { defineMachineModel(); } if (!receivedMachineConfiguration) { // multiaxis settings if (machineConfiguration.isHeadConfiguration()) { machineConfiguration.setVirtualTooltip(false); // translate the pivot point to the virtual tool tip for nonTCP rotary heads } // retract / reconfigure var performRewinds = false; // set to true to enable the rewind/reconfigure logic if (performRewinds) { machineConfiguration.enableMachineRewinds(); // enables the retract/reconfigure logic 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 machineConfiguration.setSafeRetractDistance(safeRetractDistance); machineConfiguration.setSafeRetractFeedrate(safeRetractFeed); machineConfiguration.setSafePlungeFeedrate(safePlungeFeed); var stockExpansion = new Vector(toPreciseUnit(0.1, IN), toPreciseUnit(0.1, IN), toPreciseUnit(0.1, IN)); // expand stock XYZ values machineConfiguration.setRewindStockExpansion(stockExpansion); } // multi-axis feedrates if (machineConfiguration.isMultiAxisConfiguration()) { machineConfiguration.setMultiAxisFeedrate( useTCP ? FEED_FPM : getProperty("useDPMFeeds") ? FEED_DPM : FEED_INVERSE_TIME, 9999.99, // maximum output value for inverse time feed rates getProperty("useDPMFeeds") ? DPM_COMBINATION : INVERSE_MINUTES, // INVERSE_MINUTES/INVERSE_SECONDS or DPM_COMBINATION/DPM_STANDARD 0.5, // tolerance to determine when the DPM feed has changed 1.0 // ratio of rotary accuracy to linear accuracy for DPM calculations ); setMachineConfiguration(machineConfiguration); } /* home positions */ // machineConfiguration.setHomePositionX(toPreciseUnit(0, IN)); // machineConfiguration.setHomePositionY(toPreciseUnit(0, IN)); // machineConfiguration.setRetractPlane(toPreciseUnit(0, IN)); } } function createToolImages() { var tools = getToolTable(); if (tools.getNumberOfTools() > 0) { for (var i = 0; i < tools.getNumberOfTools(); ++i) { var tool = tools.getTool(i); var toolRenderer = createToolRenderer(); if (toolRenderer) { toolRenderer.setBackgroundColor(new Color(1, 1, 1)); toolRenderer.setFluteColor(new Color(40.0 / 255, 40.0 / 255, 40.0 / 255)); toolRenderer.setShoulderColor(new Color(80.0 / 255, 80.0 / 255, 80.0 / 255)); toolRenderer.setShaftColor(new Color(80.0 / 255, 80.0 / 255, 80.0 / 255)); toolRenderer.setHolderColor(new Color(40.0 / 255, 40.0 / 255, 40.0 / 255)); if (i % 2 == 0) { toolRenderer.setBackgroundColor(new Color(1, 1, 1)); } else { toolRenderer.setBackgroundColor(new Color(240 / 255.0, 240 / 255.0, 240 / 255.0)); } var path = "tool" + tool.number + ".png"; var width = 400; var height = 532; toolRenderer.exportAs(path, "image/png", tool, width, height); } } } } var seenPatternIds = {}; function previewImage() { var permittedExtensions = ["JPG", "MP4", "MOV", "PNG", "JPEG"]; var patternId = currentSection.getPatternId(); var show = false; if (!seenPatternIds[patternId]) { show = true; seenPatternIds[patternId] = true; } var images = []; if (show) { if (FileSystem.isFile(FileSystem.getCombinedPath(FileSystem.getFolderPath(getOutputPath()), modelImagePath))) { images.push(modelImagePath); } if (hasParameter("autodeskcam:preview-name") && FileSystem.isFile(FileSystem.getCombinedPath(FileSystem.getFolderPath(getOutputPath()), getParameter("autodeskcam:preview-name")))) { images.push(getParameter("autodeskcam:preview-name")); } for (var i = 0; i < images.length; ++i) { var fileExtension = images[i].slice(images[i].lastIndexOf(".") + 1, images[i].length).toUpperCase(); var permittedExtension = false; for (var j = 0; j < permittedExtensions.length; ++j) { if (fileExtension == permittedExtensions[j]) { permittedExtension = true; break; // found } } if (!permittedExtension) { warning(localize("The image file format " + "\"" + fileExtension + "\"" + " is not supported on HAAS controls.")); } if (!getProperty("useM130PartImages") || !permittedExtension) { FileSystem.remove(FileSystem.getCombinedPath(FileSystem.getFolderPath(getOutputPath()), images[i])); // remove images.splice([i], 1); // remove from array } } if (images.length > 0) { writeBlock(mFormat.format(130), "(" + images[images.length - 1] + ")"); } } } function onOpen() { receivedMachineConfiguration = machineConfiguration.isReceived(); if (typeof defineMachine == "function") { defineMachine(); // hardcoded machine configuration } activateMachine(); // enable the machine optimizations and settings if (getProperty("useDPMFeeds")) { gFeedModeModal.format(94); } if (getProperty("useRadius")) { maximumCircularSweep = toRad(90); // avoid potential center calculation errors for CNC } if (getProperty("forceHomeOnIndexing")) { settings.retract.homeXY.onIndexing = {axes:[X, Y], singleLine:true}; } if (settings.workPlaneMethod.useTiltedWorkplane) { validate(settings.workPlaneMethod.useABCPrepositioning, localize("Setting 'useABCPrepositioning' must be enabled when 'useTiltedWorkplane' is enabled.")); validate(settings.workPlaneMethod.eulerConvention == undefined, localize("This post processor does not support EULER angles.")); } if (getProperty("useLiveConnection")) { if (getProperty("showSequenceNumbers")) { warning(localize("'Use sequence numbers' is switched off due to live connection.")); } setProperty("showSequenceNumbers", "false"); } gWorkplaneModal.format(255); // Default to G255 DWO off gRotationModal.format(69); // Default to G69 Rotation Off ssvModal.format(139); // Default to M139 SSV turned off mClampModal.format(10); // Default 4th axis modal code to be clamped mClampModal.format(12); // Default 5th axis modal code to be clamped mProbeArmModal.format(105); // Default to M105 retract the tool setting probe arm if (highFeedrate <= 0) { error(localize("You must set 'highFeedrate' because axes are not synchronized for rapid traversal.")); return; } if (!getProperty("separateWordsWithSpace")) { setWordSeparator(""); } writeln("%"); writeln("O" + oFormat.format(getProgramNumber()) + conditional(programComment, " " + formatComment(programComment))); if (getProperty("useG0")) { writeComment(localize("Using G0 which travels along dogleg path.")); } else { writeComment(subst(localize("Using high feed G1 F%1 instead of G0."), feedFormat.format(highFeedrate))); } if (getProperty("writeVersion")) { if ((typeof getHeaderVersion == "function") && getHeaderVersion()) { writeComment(localize("post version") + ": " + getHeaderVersion()); } if ((typeof getHeaderDate == "function") && getHeaderDate()) { writeComment(localize("post modified") + ": " + getHeaderDate()); } } writeProgramHeader(); if (getProperty("useM130ToolImages")) { createToolImages(); } if (getProperty("optionallyCycleToolsAtStart") || getProperty("measureTools")) { cycleToolsAtStart(); // optionally cycle through all tools } // absolute coordinates and feed per min writeBlock(gAbsIncModal.format(90), gFeedModeModal.format(94), gPlaneModal.format(17)); writeBlock(gUnitModal.format(unit == MM ? 21 : 20)); if (getProperty("gotChipConveyor")) { onCommand(COMMAND_START_CHIP_TRANSPORT); } // Probing Surface Inspection if (typeof inspectionWriteVariables == "function") { inspectionWriteVariables(); } if (getProperty("useLiveConnection") && (typeof liveConnectionHeader == "function")) { liveConnectionHeader(); } validateCommonParameters(); } function cycleToolsAtStart() { var tools = getToolTable(); optionalSection = true; if (tools.getNumberOfTools() > 0) { writeln(""); writeBlock(mFormat.format(0), formatComment(localize("Read note"))); // wait for operator writeComment(localize("With BLOCK DELETE turned off each tool will cycle through")); writeComment(localize("the spindle to verify that the correct tool is in the tool magazine")); if (getProperty("measureTools")) { writeComment(localize("and to automatically measure it")); } writeComment(localize("Once the tools are verified turn BLOCK DELETE on to skip verification")); if (getProperty("toolArmDrive") && getProperty("measureTools")) { writeBlock(mProbeArmModal.format(104), formatComment("Extend tool setting probe arm")); } for (var i = 0; i < tools.getNumberOfTools(); ++i) { var tool = tools.getTool(i); if (getProperty("measureTools") && (tool.type == TOOL_PROBE)) { continue; } var comment = "T" + toolFormat.format(tool.number) + " " + "D=" + xyzFormat.format(tool.diameter) + " " + localize("CR") + "=" + xyzFormat.format(tool.cornerRadius); if ((tool.taperAngle > 0) && (tool.taperAngle < Math.PI)) { comment += " " + localize("TAPER") + "=" + taperFormat.format(tool.taperAngle) + localize("deg"); } comment += " - " + getToolTypeName(tool.type); writeComment(comment); if (getProperty("measureTools")) { writeToolMeasureBlock(tool, true); } else { writeToolCycleBlock(tool); } } } if (getProperty("toolArmDrive") && getProperty("measureTools")) { writeBlock(mProbeArmModal.format(105), formatComment("Retract tool setting probe arm")); } optionalSection = false; writeln(""); } /** Disables length compensation if currently active or if forced. */ function disableLengthCompensation(force, message) { if (currentSection.isMultiAxis() && tcp.isSupportedByOperation || force) { if (state.lengthCompensationActive || force) { writeBlock(gFormat.format(49), conditional(message, formatComment(message))); state.lengthCompensationActive = false; } } } function setSmoothing(mode) { smoothingSettings = settings.smoothing; if (mode == smoothing.isActive && (!mode || !smoothing.isDifferent) && !smoothing.force) { return; // return if smoothing is already active or is not different } if (validateLengthCompensation && smoothingSettings.cancelCompensation) { validate(!state.lengthCompensationActive, "Length compensation is active while trying to update smoothing."); } if (mode) { // enable smoothing writeBlock( gFormat.format(187), "P" + smoothing.level, conditional((smoothingSettings.differenceCriteria != "level"), "E" + xyzFormat.format(smoothing.tolerance)) ); } else { // disable smoothing writeBlock(gFormat.format(187)); } smoothing.isActive = mode; smoothing.force = false; smoothing.isDifferent = false; } function onManualNC(command, value) { switch (command) { case COMMAND_ACTION: if (String(value).toUpperCase() == "CYCLE_REVERSAL") { cycleReverse = true; } else if (String(value).toUpperCase() == "VFD_LOW") { coolantPressure = "P0"; } else if (String(value).toUpperCase() == "VFD_NORMAL") { coolantPressure = "P1"; } else if (String(value).toUpperCase() == "VFD_HIGH") { coolantPressure = "P2"; } else if (String(value).toUpperCase() == "USEPOLARMODE") { usePolarMode = true; } break; default: expandManualNC(command, value); } } function onSection() { var forceSectionRestart = optionalSection && !currentSection.isOptional(); optionalSection = currentSection.isOptional(); var insertToolCall = isToolChangeNeeded() || forceSectionRestart; var newWorkOffset = isNewWorkOffset() || forceSectionRestart; var newWorkPlane = isNewWorkPlane() || forceSectionRestart; operationNeedsSafeStart = getProperty("safeStartAllOperations") && !isFirstSection(); initializeSmoothing(); // initialize smoothing mode if (insertToolCall || operationNeedsSafeStart) { if (getProperty("fastToolChange") && !isProbeOperation()) { currentCoolantMode = COOLANT_OFF; } else if (insertToolCall) { // no coolant off command if safe start operation onCommand(COMMAND_COOLANT_OFF); } } // toolpath starting information for live connection if (getProperty("useLiveConnection") && (typeof liveConnectionWriteData == "function")) { liveConnectionWriteData("toolpathStart"); } if ((insertToolCall && !getProperty("fastToolChange")) || newWorkOffset || newWorkPlane || toolChecked) { // stop spindle before retract during tool change if (insertToolCall && !isFirstSection() && !toolChecked && !getProperty("fastToolChange")) { onCommand(COMMAND_STOP_SPINDLE); } writeRetract(Z); // retract to safe plane if (forceResetWorkPlane && newWorkPlane) { forceWorkPlane(); setWorkPlane(new Vector(0, 0, 0)); // reset working plane } } writeln(""); writeComment(getParameter("operation-comment", "")); if (getProperty("showNotes")) { writeSectionNotes(); } // Use new operation property for polar milling if (currentSection.machiningType && (currentSection.machiningType == MACHINING_TYPE_POLAR)) { usePolarMode = true; // Update polar coordinates direction according to operation property polarDirection = currentSection.polarDirection; } // enable polar interpolation if (usePolarMode && (tool.type != TOOL_PROBE)) { if (polarDirection == undefined) { error(localize("Polar direction property must be a vector - x,y,z.")); return; } setPolarMode(currentSection, true); } if (insertToolCall || operationNeedsSafeStart) { forceModals(); if (getProperty("useM130ToolImages")) { writeBlock(mFormat.format(130), "(tool" + tool.number + ".png)"); } } // tool change writeToolCall(tool, insertToolCall); // activate those two coolant modes before the spindle is turned on if ((tool.coolant == COOLANT_THROUGH_TOOL) || (tool.coolant == COOLANT_AIR_THROUGH_TOOL) || (tool.coolant == COOLANT_FLOOD_THROUGH_TOOL)) { if (!isFirstSection() && !insertToolCall && (currentCoolantMode != tool.coolant)) { onCommand(COMMAND_STOP_SPINDLE); forceSpindleSpeed = true; } setCoolant(tool.coolant); } else if ((currentCoolantMode == COOLANT_THROUGH_TOOL) || (currentCoolantMode == COOLANT_AIR_THROUGH_TOOL) || (currentCoolantMode == COOLANT_FLOOD_THROUGH_TOOL)) { onCommand(COMMAND_STOP_SPINDLE); setCoolant(COOLANT_OFF); forceSpindleSpeed = true; } if (toolChecked) { forceSpindleSpeed = true; // spindle must be restarted if tool is checked without a tool change toolChecked = false; // state of tool is not known at the beginning of a section since it could be broken for the previous section } startSpindle(tool, insertToolCall); previewImage(); // write parametric feedrate table if (typeof initializeParametricFeeds == "function") { initializeParametricFeeds(insertToolCall); } // Output modal commands here writeBlock(gPlaneModal.format(17), gAbsIncModal.format(90), gFeedModeModal.format(94)); // set wcs var wcsIsRequired = true; if (insertToolCall || operationNeedsSafeStart) { currentWorkOffset = undefined; // force work offset when changing tool wcsIsRequired = newWorkOffset || insertToolCall || !operationNeedsSafeStart; } writeWCS(currentSection, wcsIsRequired); var abc = defineWorkPlane(currentSection, true); setProbeAngle(); // output probe angle rotations if required coolantPressure = coolantPressure == "" ? getProperty("coolantPressure", "") : coolantPressure; // manual NC Action command takes precedence over property if (!forceCoolant) { forceCoolant = coolantPressure != currentCoolantPressure; } setCoolant(tool.coolant); // writes the required coolant codes if (getProperty("useSSV")) { if (!(currentSection.getTool().type == TOOL_PROBE || currentSection.checkGroup(STRATEGY_DRILLING))) { writeBlock(ssvModal.format(138)); } else { writeBlock(ssvModal.format(139)); } } smoothing.force = operationNeedsSafeStart && (getProperty("useSmoothing") != "-1"); setSmoothing(smoothing.isAllowed); // prepositioning var initialPosition = isPolarModeActive() ? getCurrentPosition() : getFramePosition(currentSection.getInitialPosition()); var isRequired = insertToolCall || state.retractedZ || !state.lengthCompensationActive || (!isFirstSection() && getPreviousSection().isMultiAxis()); writeInitialPositioning(initialPosition, isRequired); writeStartBlocks(insertToolCall, function () { var preloadTool = getNextTool(tool.number != getFirstTool().number); if (getProperty("preloadTool") && preloadTool) { writeBlock("T" + toolFormat.format(preloadTool.number)); // preload next/first tool } }); if (isProbeOperation()) { validate(probeVariables.probeAngleMethod != "G68", "You cannot probe while G68 Rotation is in effect."); validate(probeVariables.probeAngleMethod != "G54.4", "You cannot probe while workpiece setting error compensation G54.4 is enabled."); writeBlock(gFormat.format(65), "P" + 9832); // spin the probe on inspectionCreateResultsFileHeader(); } else { // surface Inspection if (isInspectionOperation() && (typeof inspectionProcessSectionStart == "function")) { inspectionProcessSectionStart(); } } if (subprogramsAreSupported()) { subprogramDefine(initialPosition, abc); // define subprogram } } function getOffsetCode() { return tcp.isSupportedByOperation ? 234 : 43; } function onDwell(seconds) { if (seconds > 99999.999) { warning(localize("Dwelling time is out of range.")); } seconds = clamp(0.001, seconds, 99999.999); writeBlock(gFeedModeModal.format(94), gFormat.format(4), "P" + milliFormat.format(seconds * 1000)); } function onSpindleSpeed(spindleSpeed) { writeBlock(sOutput.format(spindleSpeed)); } function onCycle() { writeBlock(gPlaneModal.format(17)); } function onCyclePoint(x, y, z) { if (isInspectionOperation()) { if (typeof inspectionCycleInspect == "function") { inspectionCycleInspect(cycle, x, y, z); return; } else { cycleNotSupported(); } } else if (isProbeOperation()) { writeProbeCycle(cycle, x, y, z); } else { writeDrillCycle(cycle, x, y, z); } } function onCycleEnd() { if (isProbeOperation()) { zOutput.reset(); gMotionModal.reset(); writeBlock(gFormat.format(65), "P" + 9810, zOutput.format(cycle.retract)); // protected retract move } else { if (subprogramsAreSupported() && subprogramState.cycleSubprogramIsActive) { subprogramEnd(); } if (!cycleExpanded) { writeBlock(gCycleModal.format(80)); gMotionModal.reset(); } writeBlock(gFeedModeModal.format(94)); if (currentSection.feedMode == FEED_PER_REVOLUTION) { feedOutput.setFormat(feedFormat); // re-apply feedFormat to feedOutput } } if (getProperty("useLiveConnection") && isProbeOperation() && typeof liveConnectionWriteData == "function") { liveConnectionWriteData("macroEnd"); } } // Start of onRewindMachine logic /** Allow user to override the onRewind logic. */ function onRewindMachineEntry(_a, _b, _c) { return false; } /** Retract to safe position before indexing rotaries. */ function onMoveToSafeRetractPosition() { // cancel TCP so that tool doesn't follow rotaries disableLengthCompensation(false, "TCPC OFF"); writeRetract(Z); if (getSetting("retract.homeXY.onIndexing", false)) { writeRetract(settings.retract.homeXY.onIndexing); } } /** Rotate axes to new position above reentry position */ function onRotateAxes(_x, _y, _z, _a, _b, _c) { // position rotary axes xOutput.disable(); yOutput.disable(); zOutput.disable(); unwindABC(new Vector(_a, _b, _c)); invokeOnRapid5D(_x, _y, _z, _a, _b, _c); setCurrentABC(new Vector(_a, _b, _c)); xOutput.enable(); yOutput.enable(); zOutput.enable(); } /** Return from safe position after indexing rotaries. */ function onReturnFromSafeRetractPosition(_x, _y, _z) { // reinstate TCP if (tcp.isSupportedByOperation) { if (getSetting("workPlaneMethod.prepositionWithTWP", true)) { writeInitialPositioning(new Vector(_x, _y, _z), true); } else { writeBlock(gMotionModal.format(0), gFormat.format(getOffsetCode()), hFormat.format(tool.lengthOffset), formatComment("TCPC ON")); forceFeed(); state.lengthCompensationActive = true; } } else { // position in XY forceXYZ(); xOutput.reset(); yOutput.reset(); zOutput.disable(); invokeOnRapid(_x, _y, _z); // position in Z zOutput.enable(); invokeOnRapid(_x, _y, _z); } } // End of onRewindMachine logic // Start of polar interpolation var usePolarMode = false; // controlled by manual NC operation, enables polar interpolation for a single operation var defaultPolarDirection = new Vector(1, 0, 0); // default direction for polar interpolation var polarDirection = defaultPolarDirection; // vector to maintain tool at while in polar interpolation function setPolarMode(section, mode) { if (!mode) { // turn off polar mode if required if (isPolarModeActive()) { deactivatePolarMode(); setPolarFeedMode(false); usePolarMode = false; } polarDirection = defaultPolarDirection; // reset when deactivated return; } var direction = polarDirection; // determine the rotary axis to use for polar interpolation var axis = undefined; if (machineConfiguration.getAxisV().isEnabled()) { if (Vector.dot(machineConfiguration.getAxisV().getAxis(), section.workPlane.getForward()) != 0) { axis = machineConfiguration.getAxisV(); } } if (axis == undefined && machineConfiguration.getAxisU().isEnabled()) { if (Vector.dot(machineConfiguration.getAxisU().getAxis(), section.workPlane.getForward()) != 0) { axis = machineConfiguration.getAxisU(); } } if (axis == undefined) { error(localize("Polar interpolation requires an active rotary axis be defined in direction of workplane normal.")); } // calculate directional vector from initial position if (direction == undefined) { error(localize("Polar interpolation initiated without a directional vector.")); return; } else if (direction.isZero()) { var initialPosition = getFramePosition(section.getInitialPosition()); direction = Vector.diff(initialPosition, axis.getOffset()).getNormalized(); } // put vector in plane of rotary axis var temp = Vector.cross(direction, axis.getAxis()).getNormalized(); direction = Vector.cross(axis.getAxis(), temp).getNormalized(); // activate polar interpolation setPolarFeedMode(true); // enable multi-axis feeds for polar mode activatePolarMode(tolerance / 2, 0, direction); var polarPosition = getPolarPosition(section.getInitialPosition().x, section.getInitialPosition().y, section.getInitialPosition().z); setCurrentPositionAndDirection(polarPosition); forceWorkPlane(); } function setPolarFeedMode(mode) { if (machineConfiguration.isMultiAxisConfiguration()) { machineConfiguration.setMultiAxisFeedrate( !mode ? multiAxisFeedrate.mode : getProperty("useDPMFeeds") ? FEED_DPM : FEED_INVERSE_TIME, multiAxisFeedrate.maximum, !mode ? multiAxisFeedrate.type : getProperty("useDPMFeeds") ? DPM_COMBINATION : INVERSE_MINUTES, multiAxisFeedrate.tolerance, multiAxisFeedrate.bpwRatio ); if (!receivedMachineConfiguration) { setMachineConfiguration(machineConfiguration); } } } // End of polar interpolation var currentCoolantMode = COOLANT_OFF; var coolantOff = undefined; var forceCoolant = false; var isOptionalCoolant = false; function setCoolant(coolant) { var coolantCodes = getCoolantCodes(coolant); forceSingleLine = false; currentCoolantPressure = coolant == COOLANT_FLOOD ? currentCoolantPressure : ""; if ((coolantCodes != undefined) && (coolant == COOLANT_FLOOD)) { if (coolantPressure != "") { forceSingleLine = true; coolantCodes.push(coolantPressure); } currentCoolantPressure = coolantPressure; } if (Array.isArray(coolantCodes)) { writeStartBlocks(!isOptionalCoolant, function () { if (settings.coolant.singleLineCoolant || forceSingleLine) { writeBlock(coolantCodes.join(getWordSeparator())); } else { for (var c in coolantCodes) { writeBlock(coolantCodes[c]); } } }); return undefined; } return coolantCodes; } var isSpecialCoolantActive = false; function getCoolantCodes(coolant) { var coolants = settings.coolant.coolants; 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) { if (operationNeedsSafeStart && coolant != COOLANT_OFF && !isSpecialCoolantActive) { isOptionalCoolant = true; } else if (!forceCoolant || coolant == COOLANT_OFF) { return undefined; // coolant is already active } } if ((coolant != COOLANT_OFF) && (currentCoolantMode != COOLANT_OFF) && (coolantOff != undefined) && !isOptionalCoolant && !forceCoolant) { if (Array.isArray(coolantOff)) { for (var i in coolantOff) { multipleCoolantBlocks.push(coolantOff[i]); } } else { multipleCoolantBlocks.push(coolantOff); } } forceCoolant = false; if (isSpecialCoolantActive) { forceSpindleSpeed = true; } var m; var coolantCodes = {}; for (var c in coolants) { // find required coolant codes into the coolants array if (coolants[c].id == coolant) { isSpecialCoolantActive = (coolants[c].id == COOLANT_THROUGH_TOOL) || (coolants[c].id == COOLANT_FLOOD_THROUGH_TOOL) || (coolants[c].id == COOLANT_AIR_THROUGH_TOOL); coolantCodes.on = coolants[c].on; if (coolants[c].off != undefined) { coolantCodes.off = coolants[c].off; break; } else { for (var i in coolants) { if (coolants[i].id == COOLANT_OFF) { coolantCodes.off = coolants[i].off; break; } } } } } if (coolant == COOLANT_OFF) { m = !coolantOff ? coolantCodes.off : coolantOff; // use the default coolant off command when an 'off' value is not specified } else { coolantOff = coolantCodes.off; m = coolantCodes.on; } if (!m) { onUnsupportedCoolant(coolant); m = 9; } else { if (Array.isArray(m)) { for (var i in m) { multipleCoolantBlocks.push(m[i]); } } else { multipleCoolantBlocks.push(m); } currentCoolantMode = coolant; 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; } var mapCommand = { COMMAND_END : 2, COMMAND_SPINDLE_CLOCKWISE : 3, COMMAND_SPINDLE_COUNTERCLOCKWISE: 4, COMMAND_STOP_SPINDLE : 5, COMMAND_ORIENTATE_SPINDLE : 19, COMMAND_LOAD_TOOL : 6 }; function onCommand(command) { switch (command) { case COMMAND_STOP: writeBlock(mFormat.format(0)); forceSpindleSpeed = true; forceCoolant = true; return; case COMMAND_OPTIONAL_STOP: writeBlock(mFormat.format(1)); forceSpindleSpeed = true; forceCoolant = true; return; case COMMAND_COOLANT_ON: setCoolant(tool.coolant); return; case COMMAND_COOLANT_OFF: setCoolant(COOLANT_OFF); return; case COMMAND_START_SPINDLE: forceSpindleSpeed = false; writeBlock(sOutput.format(spindleSpeed), mFormat.format(tool.clockwise ? 3 : 4)); return; case COMMAND_LOAD_TOOL: writeToolBlock("T" + toolFormat.format(tool.number), mFormat.format(6)); writeComment(tool.comment); if (measureTool) { writeToolMeasureBlock(tool, false); } // preload tool is handled within onSection return; case COMMAND_LOCK_MULTI_AXIS: if (machineConfiguration.isMultiAxisConfiguration() && (machineConfiguration.getNumberOfAxes() >= 4)) { writeBlock(mClampModal.format(10)); // lock 4th-axis motion if (machineConfiguration.getNumberOfAxes() == 5) { writeBlock(mClampModal.format(12)); // lock 5th-axis motion } } return; case COMMAND_UNLOCK_MULTI_AXIS: var outputClampCodes = getProperty("useClampCodes") || currentSection.isMultiAxis() || isPolarModeActive(); if (outputClampCodes && machineConfiguration.isMultiAxisConfiguration() && (machineConfiguration.getNumberOfAxes() >= 4)) { writeBlock(mClampModal.format(11)); // unlock 4th-axis motion if (machineConfiguration.getNumberOfAxes() == 5) { writeBlock(mClampModal.format(13)); // unlock 5th-axis motion } } return; case COMMAND_BREAK_CONTROL: if (!toolChecked) { // avoid duplicate COMMAND_BREAK_CONTROL prepareForToolCheck(); writeBlock( gFormat.format(65), "P" + 9853, "T" + toolFormat.format(tool.number), "B" + xyzFormat.format(0), "H" + xyzFormat.format(getProperty("toolBreakageTolerance")) ); if (getProperty("toolArmDrive")) { writeBlock(mProbeArmModal.format(105), formatComment("Retract tool setting probe arm")); } toolChecked = true; state.lengthCompensationActive = false; // macro 9853 cancels tool length compensation } return; case COMMAND_TOOL_MEASURE: measureTool = true; return; case COMMAND_START_CHIP_TRANSPORT: writeBlock(mFormat.format(31)); return; case COMMAND_STOP_CHIP_TRANSPORT: writeBlock(mFormat.format(33)); return; case COMMAND_PROBE_ON: return; case COMMAND_PROBE_OFF: return; } var stringId = getCommandStringId(command); var mcode = mapCommand[stringId]; if (mcode != undefined) { writeBlock(mFormat.format(mcode)); } else { onUnsupportedCommand(command); } } function onSectionEnd() { if (isInspectionOperation() && !isLastSection()) { writeBlock(gFormat.format(103), "P0", formatComment("LOOKAHEAD ON")); } if (!isLastSection() && (getNextSection().getTool().coolant != tool.coolant)) { setCoolant(COOLANT_OFF); } if ((((getCurrentSectionId() + 1) >= getNumberOfSections()) || (tool.number != getNextSection().getTool().number)) && tool.breakControl) { onCommand(COMMAND_BREAK_CONTROL); } else { toolChecked = false; } if (subprogramsAreSupported()) { subprogramEnd(); } forceAny(); writeBlock(gFeedModeModal.format(94)); // feed per minute disableLengthCompensation(false, "TCPC OFF"); if (isProbeOperation()) { writeBlock(gFormat.format(65), "P" + 9833); // spin the probe off if (probeVariables.probeAngleMethod != "G68") { setProbeAngle(); // output probe angle rotations if required } } if (getProperty("useLiveConnection") && (typeof liveConnectionWriteData == "function")) { if (isInspectionOperation()) { liveConnectionWriteData("inspectSurfaceAlarm"); } liveConnectionWriteData("toolpathEnd"); } // reset for next section operationNeedsSafeStart = false; coolantPressure = ""; cycleReverse = false; setPolarMode(currentSection, false); } function onClose() { if (!(getProperty("useLiveConnection") && controlType != "NGC")) { if (isDPRNTopen) { writeln("DPRNT[END]"); writeBlock("PCLOS"); isDPRNTopen = false; } } if (!getProperty("useLiveConnection") && typeof inspectionProcessSectionEnd == "function") { inspectionProcessSectionEnd(); } cancelWCSRotation(); writeln(""); optionalSection = false; if (getProperty("useSSV")) { writeBlock(ssvModal.format(139)); } onCommand(COMMAND_STOP_SPINDLE); onCommand(COMMAND_COOLANT_OFF); // retract writeRetract(Z); if (!getProperty("homePositionCenter") && getSetting("retract.homeXY.onProgramEnd", false)) { writeRetract(settings.retract.homeXY.onProgramEnd); } cancelWorkPlane(); // Unwind Rotary table at end if (machineConfiguration.isMultiAxisConfiguration()) { unwindABC(new Vector(0, 0, 0)); positionABC(new Vector(0, 0, 0), true); } if (getProperty("homePositionCenter")) { if (hasParameter("part-upper-x") && hasParameter("part-lower-x")) { var xHome = (getParameter("part-upper-x") + getParameter("part-lower-x")) / 2; } else { var xHome = machineConfiguration.hasHomePositionX() ? machineConfiguration.getHomePositionX() : toPreciseUnit(0, MM); } writeBlock(gMotionModal.format(0), "X" + xyzFormat.format(xHome)); // only desired when X is in the table writeRetract(Y); } if (getProperty("useLiveConnection")) { writeComment("Live Connection Footer"); // Live connection write footer writeBlock(inspectionVariables.liveConnectionStatus, "= 2"); // If using live connection set results active to a 2 to signify program end } onImpliedCommand(COMMAND_END); onImpliedCommand(COMMAND_STOP_SPINDLE); if (getProperty("useM130PartImages") || getProperty("useM130ToolImages")) { writeBlock(mFormat.format(131)); } writeBlock(mFormat.format(30)); // stop program, spindle stop, coolant off if (subprogramsAreSupported()) { writeSubprograms(); } writeln(""); writeln("%"); } /* keywords += (keywords ? " MODEL_IMAGE" : "MODEL_IMAGE"); function onTerminate() { var outputPath = getOutputPath(); var programFilename = FileSystem.getFilename(outputPath); var programSize = FileSystem.getFileSize(outputPath); var postPath = findFile("setup-sheet-excel-2007.cps"); var intermediatePath = getIntermediatePath(); var a = "--property unit " + ((unit == IN) ? "0" : "1"); // use 0 for inch and 1 for mm if (programName) { a += " --property programName \"'" + programName + "'\""; } if (programComment) { a += " --property programComment \"'" + programComment + "'\""; } a += " --property programFilename \"'" + programFilename + "'\""; a += " --property programSize \"" + programSize + "\""; a += " --noeditor --log temp.log \"" + postPath + "\" \"" + intermediatePath + "\" \"" + FileSystem.replaceExtension(outputPath, "xlsx") + "\""; execute(getPostProcessorPath(), a, false, ""); executeNoWait("excel", "\"" + FileSystem.replaceExtension(outputPath, "xlsx") + "\"", false, ""); } */ // >>>>> INCLUDED FROM include_files/commonFunctions.cpi // internal variables, do not change var receivedMachineConfiguration; var tcp = {isSupportedByControl:getSetting("supportsTCP", true), isSupportedByMachine:false, isSupportedByOperation:false}; var state = { retractedX : false, // specifies that the machine has been retracted in X retractedY : false, // specifies that the machine has been retracted in Y retractedZ : false, // specifies that the machine has been retracted in Z lengthCompensationActive: false, // specifies that tool length compensation is active mainState : true // specifies the current context of the state (true = main, false = optional) }; var validateLengthCompensation = getSetting("outputToolLengthCompensation", true); // disable validation when outputToolLengthCompensation is disabled var multiAxisFeedrate; var sequenceNumber; var optionalSection = false; var currentWorkOffset; var forceSpindleSpeed = false; var operationNeedsSafeStart = false; // used to convert blocks to optional for safeStartAllOperations function activateMachine() { // disable unsupported rotary axes output if (!machineConfiguration.isMachineCoordinate(0) && (typeof aOutput != "undefined")) { aOutput.disable(); } if (!machineConfiguration.isMachineCoordinate(1) && (typeof bOutput != "undefined")) { bOutput.disable(); } if (!machineConfiguration.isMachineCoordinate(2) && (typeof cOutput != "undefined")) { cOutput.disable(); } // setup usage of useTiltedWorkplane settings.workPlaneMethod.useTiltedWorkplane = getProperty("useTiltedWorkplane") != undefined ? getProperty("useTiltedWorkplane") : getSetting("workPlaneMethod.useTiltedWorkplane", false); settings.workPlaneMethod.useABCPrepositioning = getProperty("useABCPrepositioning") != undefined ? getProperty("useABCPrepositioning") : getSetting("workPlaneMethod.useABCPrepositioning", false); if (!machineConfiguration.isMultiAxisConfiguration()) { return; // don't need to modify any settings for 3-axis machines } // identify if any of the rotary axes has TCP enabled var axes = [machineConfiguration.getAxisU(), machineConfiguration.getAxisV(), machineConfiguration.getAxisW()]; tcp.isSupportedByMachine = axes.some(function(axis) {return axis.isEnabled() && axis.isTCPEnabled();}); // true if TCP is enabled on any rotary axis // save multi-axis feedrate settings from machine configuration var mode = machineConfiguration.getMultiAxisFeedrateMode(); var type = mode == FEED_INVERSE_TIME ? machineConfiguration.getMultiAxisFeedrateInverseTimeUnits() : (mode == FEED_DPM ? machineConfiguration.getMultiAxisFeedrateDPMType() : DPM_STANDARD); multiAxisFeedrate = { mode : mode, maximum : machineConfiguration.getMultiAxisFeedrateMaximum(), type : type, tolerance: mode == FEED_DPM ? machineConfiguration.getMultiAxisFeedrateOutputTolerance() : 0, bpwRatio : mode == FEED_DPM ? machineConfiguration.getMultiAxisFeedrateBpwRatio() : 1 }; // setup of retract/reconfigure TAG: Only needed until post kernel supports these machine config settings if (receivedMachineConfiguration && machineConfiguration.performRewinds()) { safeRetractDistance = machineConfiguration.getSafeRetractDistance(); safePlungeFeed = machineConfiguration.getSafePlungeFeedrate(); safeRetractFeed = machineConfiguration.getSafeRetractFeedrate(); } if (typeof safeRetractDistance == "number" && getProperty("safeRetractDistance") != undefined && getProperty("safeRetractDistance") != 0) { safeRetractDistance = getProperty("safeRetractDistance"); } if (machineConfiguration.isHeadConfiguration()) { compensateToolLength = typeof compensateToolLength == "undefined" ? false : compensateToolLength; } if (machineConfiguration.isHeadConfiguration() && compensateToolLength) { for (var i = 0; i < getNumberOfSections(); ++i) { var section = getSection(i); if (section.isMultiAxis()) { machineConfiguration.setToolLength(getBodyLength(section.getTool())); // define the tool length for head adjustments section.optimizeMachineAnglesByMachine(machineConfiguration, OPTIMIZE_AXIS); } } } else { optimizeMachineAngles2(OPTIMIZE_AXIS); } } function getBodyLength(tool) { for (var i = 0; i < getNumberOfSections(); ++i) { var section = getSection(i); if (tool.number == section.getTool().number) { return section.getParameter("operation:tool_overallLength", tool.bodyLength + tool.holderLength); } } return tool.bodyLength + tool.holderLength; } function getFeed(f) { if (getProperty("useG95")) { return feedOutput.format(f / spindleSpeed); // use feed value } if (typeof activeMovements != "undefined" && 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 settings.parametricFeeds.feedOutputVariable + (settings.parametricFeeds.firstFeedParameter + feedContext.id); } } currentFeedId = undefined; // force parametric feed next time } return feedOutput.format(f); // use feed value } function validateCommonParameters() { validateToolData(); for (var i = 0; i < getNumberOfSections(); ++i) { var section = getSection(i); if (getSection(0).workOffset == 0 && section.workOffset > 0) { error(localize("Using multiple work offsets is not possible if the initial work offset is 0.")); } if (section.isMultiAxis()) { if (!section.isOptimizedForMachine() && (!getSetting("workPlaneMethod.useTiltedWorkplane", false) || !getSetting("supportsToolVectorOutput", false))) { error(localize("This postprocessor requires a machine configuration for 5-axis simultaneous toolpath.")); } if (machineConfiguration.getMultiAxisFeedrateMode() == FEED_INVERSE_TIME && !getSetting("supportsInverseTimeFeed", true)) { error(localize("This postprocessor does not support inverse time feedrates.")); } if (getSetting("supportsToolVectorOutput", false) && !tcp.isSupportedByControl) { error(localize("Incompatible postprocessor settings detected." + EOL + "Setting 'supportsToolVectorOutput' requires setting 'supportsTCP' to be enabled as well.")); } } } if (!tcp.isSupportedByControl && tcp.isSupportedByMachine) { error(localize("The machine configuration has TCP enabled which is not supported by this postprocessor.")); } if (getProperty("safePositionMethod") == "clearanceHeight") { var msg = "-Attention- Property 'Safe Retracts' is set to 'Clearance Height'." + EOL + "Ensure the clearance height will clear the part and or fixtures." + EOL + "Raise the Z-axis to a safe height before starting the program."; warning(msg); writeComment(msg); } } function validateToolData() { var _default = 99999; var _maximumSpindleRPM = machineConfiguration.getMaximumSpindleSpeed() > 0 ? machineConfiguration.getMaximumSpindleSpeed() : settings.maximumSpindleRPM == undefined ? _default : settings.maximumSpindleRPM; var _maximumToolNumber = machineConfiguration.isReceived() && machineConfiguration.getNumberOfTools() > 0 ? machineConfiguration.getNumberOfTools() : settings.maximumToolNumber == undefined ? _default : settings.maximumToolNumber; var _maximumToolLengthOffset = settings.maximumToolLengthOffset == undefined ? _default : settings.maximumToolLengthOffset; var _maximumToolDiameterOffset = settings.maximumToolDiameterOffset == undefined ? _default : settings.maximumToolDiameterOffset; var header = ["Detected maximum values are out of range.", "Maximum values:"]; var warnings = { toolNumber : {msg:"Tool number value exceeds the maximum value for tool: " + EOL, max:" Tool number: " + _maximumToolNumber, values:[]}, lengthOffset : {msg:"Tool length offset value exceeds the maximum value for tool: " + EOL, max:" Tool length offset: " + _maximumToolLengthOffset, values:[]}, diameterOffset: {msg:"Tool diameter offset value exceeds the maximum value for tool: " + EOL, max:" Tool diameter offset: " + _maximumToolDiameterOffset, values:[]}, spindleSpeed : {msg:"Spindle speed exceeds the maximum value for operation: " + EOL, max:" Spindle speed: " + _maximumSpindleRPM, values:[]} }; var toolIds = []; for (var i = 0; i < getNumberOfSections(); ++i) { var section = getSection(i); if (toolIds.indexOf(section.getTool().getToolId()) === -1) { // loops only through sections which have a different tool ID var toolNumber = section.getTool().number; var lengthOffset = section.getTool().lengthOffset; var diameterOffset = section.getTool().diameterOffset; var comment = section.getParameter("operation-comment", ""); if (toolNumber > _maximumToolNumber && !getProperty("toolAsName")) { warnings.toolNumber.values.push(SP + toolNumber + EOL); } if (lengthOffset > _maximumToolLengthOffset) { warnings.lengthOffset.values.push(SP + "Tool " + toolNumber + " (" + comment + "," + " Length offset: " + lengthOffset + ")" + EOL); } if (diameterOffset > _maximumToolDiameterOffset) { warnings.diameterOffset.values.push(SP + "Tool " + toolNumber + " (" + comment + "," + " Diameter offset: " + diameterOffset + ")" + EOL); } toolIds.push(section.getTool().getToolId()); } // loop through all sections regardless of tool id for idenitfying spindle speeds // identify if movement ramp is used in current toolpath, use ramp spindle speed for comparisons var ramp = section.getMovements() & ((1 << MOVEMENT_RAMP) | (1 << MOVEMENT_RAMP_ZIG_ZAG) | (1 << MOVEMENT_RAMP_PROFILE) | (1 << MOVEMENT_RAMP_HELIX)); var _sectionSpindleSpeed = Math.max(section.getTool().spindleRPM, ramp ? section.getTool().rampingSpindleRPM : 0, 0); if (_sectionSpindleSpeed > _maximumSpindleRPM) { warnings.spindleSpeed.values.push(SP + section.getParameter("operation-comment", "") + " (" + _sectionSpindleSpeed + " RPM" + ")" + EOL); } } // sort lists by tool number warnings.toolNumber.values.sort(function(a, b) {return a - b;}); warnings.lengthOffset.values.sort(function(a, b) {return a.localeCompare(b);}); warnings.diameterOffset.values.sort(function(a, b) {return a.localeCompare(b);}); var warningMessages = []; for (var key in warnings) { if (warnings[key].values != "") { header.push(warnings[key].max); // add affected max values to the header warningMessages.push(warnings[key].msg + warnings[key].values.join("")); } } if (warningMessages.length != 0) { warningMessages.unshift(header.join(EOL) + EOL); warning(warningMessages.join(EOL)); } } function forceFeed() { currentFeedId = undefined; feedOutput.reset(); } /** Force output of X, Y, and Z. */ function forceXYZ() { xOutput.reset(); yOutput.reset(); zOutput.reset(); } /** Force output of A, B, and C. */ function forceABC() { aOutput.reset(); bOutput.reset(); cOutput.reset(); } /** Force output of X, Y, Z, A, B, C, and F on next output. */ function forceAny() { forceXYZ(); forceABC(); forceFeed(); } /** Writes the specified block. */ function writeBlock() { var text = formatWords(arguments); if (!text) { return; } var prefix = getSetting("sequenceNumberPrefix", "N"); var suffix = getSetting("writeBlockSuffix", ""); if ((optionalSection || skipBlocks) && !getSetting("supportsOptionalBlocks", true)) { error(localize("Optional blocks are not supported by this post.")); } if (getProperty("showSequenceNumbers") == "true") { if (sequenceNumber == undefined || sequenceNumber >= settings.maximumSequenceNumber) { sequenceNumber = getProperty("sequenceNumberStart"); } if (optionalSection || skipBlocks) { writeWords2("/", prefix + sequenceNumber, text + suffix); } else { writeWords2(prefix + sequenceNumber, text + suffix); } sequenceNumber += getProperty("sequenceNumberIncrement"); } else { if (optionalSection || skipBlocks) { writeWords2("/", text + suffix); } else { writeWords(text + suffix); } } } validate(settings.comments, "Setting 'comments' is required but not defined."); function formatComment(text) { var prefix = settings.comments.prefix; var suffix = settings.comments.suffix; var _permittedCommentChars = settings.comments.permittedCommentChars == undefined ? "" : settings.comments.permittedCommentChars; switch (settings.comments.outputFormat) { case "upperCase": text = text.toUpperCase(); _permittedCommentChars = _permittedCommentChars.toUpperCase(); break; case "lowerCase": text = text.toLowerCase(); _permittedCommentChars = _permittedCommentChars.toLowerCase(); break; case "ignoreCase": _permittedCommentChars = _permittedCommentChars.toUpperCase() + _permittedCommentChars.toLowerCase(); break; default: error(localize("Unsupported option specified for setting 'comments.outputFormat'.")); } if (_permittedCommentChars != "") { text = filterText(String(text), _permittedCommentChars); } text = String(text).substring(0, settings.comments.maximumLineLength - prefix.length - suffix.length); return text != "" ? prefix + text + suffix : ""; } /** Output a comment. */ function writeComment(text) { if (!text) { return; } var comments = String(text).split(EOL); for (comment in comments) { var _comment = formatComment(comments[comment]); if (_comment) { if (getSetting("comments.showSequenceNumbers", false)) { writeBlock(_comment); } else { writeln(_comment); } } } } function onComment(text) { writeComment(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); } var skipBlocks = false; var initialState = JSON.parse(JSON.stringify(state)); // save initial state var optionalState = JSON.parse(JSON.stringify(state)); var saveCurrentSectionId = undefined; function writeStartBlocks(isRequired, code) { var saveSkipBlocks = skipBlocks; var saveMainState = state; // save main state if (!isRequired) { if (!getProperty("safeStartAllOperations", false)) { return; // when safeStartAllOperations is disabled, dont output code and return } if (saveCurrentSectionId != getCurrentSectionId()) { saveCurrentSectionId = getCurrentSectionId(); forceModals(); // force all modal variables when entering a new section optionalState = Object.create(initialState); // reset optionalState to initialState when entering a new section } skipBlocks = true; // if values are not required, but safeStartAllOperations is enabled - write following blocks as optional state = optionalState; // set state to optionalState if skipBlocks is true state.mainState = false; } code(); // writes out the code which is passed to this function as an argument state = saveMainState; // restore main state skipBlocks = saveSkipBlocks; // restore skipBlocks value } var pendingRadiusCompensation = -1; function onRadiusCompensation() { pendingRadiusCompensation = radiusCompensation; if (pendingRadiusCompensation >= 0 && !getSetting("supportsRadiusCompensation", true)) { error(localize("Radius compensation mode is not supported.")); return; } } function onPassThrough(text) { var commands = String(text).split(","); for (text in commands) { writeBlock(commands[text]); } } 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 } } } /** Helper function to be able to use a default value for settings which do not exist. */ function getSetting(setting, defaultValue) { var result = defaultValue; var keys = setting.split("."); var obj = settings; for (var i in keys) { if (obj[keys[i]] != undefined) { // setting does exist result = obj[keys[i]]; if (typeof [keys[i]] === "object") { obj = obj[keys[i]]; continue; } } else { // setting does not exist, use default value if (defaultValue != undefined) { result = defaultValue; } else { error("Setting '" + keys[i] + "' has no default value and/or does not exist."); return undefined; } } } return result; } function getForwardDirection(_section) { var forward = undefined; var _optimizeType = settings.workPlaneMethod && settings.workPlaneMethod.optimizeType; if (_section.isMultiAxis()) { forward = _section.workPlane.forward; } else if (!getSetting("workPlaneMethod.useTiltedWorkplane", false) && machineConfiguration.isMultiAxisConfiguration()) { if (_optimizeType == undefined) { var saveRotation = getRotation(); getWorkPlaneMachineABC(_section, true); forward = getRotation().forward; setRotation(saveRotation); // reset rotation } else { var abc = getWorkPlaneMachineABC(_section, false); var forceAdjustment = settings.workPlaneMethod.optimizeType == OPTIMIZE_TABLES || settings.workPlaneMethod.optimizeType == OPTIMIZE_BOTH; forward = machineConfiguration.getOptimizedDirection(_section.workPlane.forward, abc, false, forceAdjustment); } } else { forward = getRotation().forward; } return forward; } function getRetractParameters() { var _arguments = typeof arguments[0] === "object" ? arguments[0].axes : arguments; var singleLine = arguments[0].singleLine == undefined ? true : arguments[0].singleLine; var words = []; // store all retracted axes in an array var retractAxes = new Array(false, false, false); var method = getProperty("safePositionMethod", "undefined"); if (method == "clearanceHeight") { if (!is3D()) { error(localize("Safe retract option 'Clearance Height' is only supported when all operations are along the setup Z-axis.")); } return undefined; } validate(settings.retract, "Setting 'retract' is required but not defined."); validate(_arguments.length != 0, "No axis specified for getRetractParameters()."); for (i in _arguments) { retractAxes[_arguments[i]] = true; } if ((retractAxes[0] || retractAxes[1]) && !state.retractedZ) { // retract Z first before moving to X/Y home error(localize("Retracting in X/Y is not possible without being retracted in Z.")); return undefined; } // special conditions if (retractAxes[0] || retractAxes[1]) { method = getSetting("retract.methodXY", method); } if (retractAxes[2]) { method = getSetting("retract.methodZ", method); } // define home positions var useZeroValues = (settings.retract.useZeroValues && settings.retract.useZeroValues.indexOf(method) != -1); var _xHome = machineConfiguration.hasHomePositionX() && !useZeroValues ? machineConfiguration.getHomePositionX() : toPreciseUnit(0, MM); var _yHome = machineConfiguration.hasHomePositionY() && !useZeroValues ? machineConfiguration.getHomePositionY() : toPreciseUnit(0, MM); var _zHome = machineConfiguration.getRetractPlane() != 0 && !useZeroValues ? machineConfiguration.getRetractPlane() : toPreciseUnit(0, MM); for (var i = 0; i < _arguments.length; ++i) { switch (_arguments[i]) { case X: if (!state.retractedX) { words.push("X" + xyzFormat.format(_xHome)); xOutput.reset(); state.retractedX = true; } break; case Y: if (!state.retractedY) { words.push("Y" + xyzFormat.format(_yHome)); yOutput.reset(); state.retractedY = true; } break; case Z: if (!state.retractedZ) { words.push("Z" + xyzFormat.format(_zHome)); zOutput.reset(); state.retractedZ = true; } break; default: error(localize("Unsupported axis specified for getRetractParameters().")); return undefined; } } return {method:method, retractAxes:retractAxes, words:words, singleLine:singleLine}; } /** Returns true when subprogram logic does exist into the post. */ function subprogramsAreSupported() { return typeof subprogramState != "undefined"; } // <<<<< INCLUDED FROM include_files/commonFunctions.cpi // >>>>> INCLUDED FROM include_files/defineWorkPlane.cpi validate(settings.workPlaneMethod, "Setting 'workPlaneMethod' is required but not defined."); function defineWorkPlane(_section, _setWorkPlane) { var abc = new Vector(0, 0, 0); if (settings.workPlaneMethod.forceMultiAxisIndexing || !is3D() || machineConfiguration.isMultiAxisConfiguration()) { if (isPolarModeActive()) { abc = getCurrentDirection(); } else if (_section.isMultiAxis()) { forceWorkPlane(); cancelTransformation(); abc = _section.isOptimizedForMachine() ? _section.getInitialToolAxisABC() : _section.getGlobalInitialToolAxis(); } else if (settings.workPlaneMethod.useTiltedWorkplane && settings.workPlaneMethod.eulerConvention != undefined) { if (settings.workPlaneMethod.eulerCalculationMethod == "machine" && machineConfiguration.isMultiAxisConfiguration()) { abc = machineConfiguration.getOrientation(getWorkPlaneMachineABC(_section, true)).getEuler2(settings.workPlaneMethod.eulerConvention); } else { abc = _section.workPlane.getEuler2(settings.workPlaneMethod.eulerConvention); } } else { abc = getWorkPlaneMachineABC(_section, true); } if (_setWorkPlane) { if (_section.isMultiAxis() || isPolarModeActive()) { // 4-5x simultaneous operations cancelWorkPlane(); if (_section.isOptimizedForMachine()) { positionABC(abc, true); } else { setCurrentDirection(abc); } } else { // 3x and/or 3+2x operations setWorkPlane(abc); } } } else { var remaining = _section.workPlane; if (!isSameDirection(remaining.forward, new Vector(0, 0, 1))) { error(localize("Tool orientation is not supported.")); return abc; } setRotation(remaining); } tcp.isSupportedByOperation = isTCPSupportedByOperation(_section); return abc; } function isTCPSupportedByOperation(_section) { var _tcp = _section.getOptimizedTCPMode() == OPTIMIZE_NONE; if (!_section.isMultiAxis() && (settings.workPlaneMethod.useTiltedWorkplane || isSameDirection(machineConfiguration.getSpindleAxis(), getForwardDirection(_section)) || settings.workPlaneMethod.optimizeType == OPTIMIZE_HEADS || settings.workPlaneMethod.optimizeType == OPTIMIZE_TABLES || settings.workPlaneMethod.optimizeType == OPTIMIZE_BOTH)) { _tcp = false; } return _tcp; } // <<<<< INCLUDED FROM include_files/defineWorkPlane.cpi // >>>>> INCLUDED FROM include_files/getWorkPlaneMachineABC.cpi validate(settings.machineAngles, "Setting 'machineAngles' is required but not defined."); function getWorkPlaneMachineABC(_section, rotate) { var currentABC = isFirstSection() ? new Vector(0, 0, 0) : getCurrentABC(); var abc = machineConfiguration.getABCByPreference(_section.workPlane, currentABC, settings.machineAngles.controllingAxis, settings.machineAngles.type, settings.machineAngles.options); if (!isSameDirection(machineConfiguration.getDirection(abc), _section.workPlane.forward)) { error(localize("Orientation not supported.")); } if (rotate) { if (settings.workPlaneMethod.optimizeType == undefined || settings.workPlaneMethod.useTiltedWorkplane) { // legacy var useTCP = false; var R = machineConfiguration.getRemainingOrientation(abc, _section.workPlane); setRotation(useTCP ? _section.workPlane : R); } else { if (!_section.isOptimizedForMachine()) { machineConfiguration.setToolLength(compensateToolLength ? _section.getTool().overallLength : 0); // define the tool length for head adjustments _section.optimize3DPositionsByMachine(machineConfiguration, abc, settings.workPlaneMethod.optimizeType); } } } return abc; } // <<<<< INCLUDED FROM include_files/getWorkPlaneMachineABC.cpi // >>>>> INCLUDED FROM include_files/positionABC.cpi function positionABC(abc, force) { if (!machineConfiguration.isMultiAxisConfiguration()) { error("Function 'positionABC' can only be used with multi-axis machine configurations."); } if (typeof unwindABC == "function") { unwindABC(abc); } if (force) { forceABC(); } var a = aOutput.format(abc.x); var b = bOutput.format(abc.y); var c = cOutput.format(abc.z); if (a || b || c) { writeRetract(Z); if (getSetting("retract.homeXY.onIndexing", false)) { writeRetract(settings.retract.homeXY.onIndexing); } onCommand(COMMAND_UNLOCK_MULTI_AXIS); gMotionModal.reset(); writeBlock(gMotionModal.format(0), a, b, c); if (getCurrentSectionId() != -1) { setCurrentABC(abc); // required for machine simulation } } } // <<<<< INCLUDED FROM include_files/positionABC.cpi // >>>>> INCLUDED FROM include_files/unwindABC.cpi function unwindABC(abc) { if (settings.unwind == undefined) { return; } if (settings.unwind.method != 1 && settings.unwind.method != 2) { error(localize("Unsupported unwindABC method.")); return; } var axes = new Array(machineConfiguration.getAxisU(), machineConfiguration.getAxisV(), machineConfiguration.getAxisW()); var currentDirection = getCurrentDirection(); for (var i in axes) { if (axes[i].isEnabled() && (settings.unwind.useAngle != "prefix" || settings.unwind.anglePrefix[axes[i].getCoordinate] != "")) { var j = axes[i].getCoordinate(); // only use the active axis in calculations var tempABC = new Vector(0, 0, 0); tempABC.setCoordinate(j, abc.getCoordinate(j)); var tempCurrent = new Vector(0, 0, 0); // only use the active axis in calculations tempCurrent.setCoordinate(j, currentDirection.getCoordinate(j)); var orientation = machineConfiguration.getOrientation(tempCurrent); // get closest angle without respecting 'reset' flag // and distance from previous angle to closest abc var nearestABC = machineConfiguration.getABCByPreference(orientation, tempABC, ABC, PREFER_PREFERENCE, ENABLE_WCS); var distanceABC = abcFormat.getResultingValue(Math.abs(Vector.diff(getCurrentDirection(), abc).getCoordinate(j))); // calculate distance from calculated abc to closest abc // include move to origin for G28 moves var distanceOrigin = 0; if (settings.unwind.method == 2) { distanceOrigin = abcFormat.getResultingValue(Math.abs(Vector.diff(nearestABC, abc).getCoordinate(j))); } else { // closest angle distanceOrigin = abcFormat.getResultingValue(Math.abs(getCurrentDirection().getCoordinate(j))) % 360; // calculate distance for unwinding axis distanceOrigin = (distanceOrigin > 180) ? 360 - distanceOrigin : distanceOrigin; // take shortest route to 0 distanceOrigin += abcFormat.getResultingValue(Math.abs(abc.getCoordinate(j))); // add distance from 0 to new position } // determine if the axis needs to be rewound and rewind it if required var revolutions = distanceABC / 360; var angle = settings.unwind.method == 2 ? nearestABC.getCoordinate(j) : 0; if (distanceABC > distanceOrigin && (settings.unwind.method == 2 || (revolutions > 1))) { // G28 method will move rotary, so make sure move is greater than 360 degrees writeRetract(Z); if (getSetting("retract.homeXY.onIndexing", false)) { writeRetract(settings.retract.homeXY.onIndexing); } onCommand(COMMAND_UNLOCK_MULTI_AXIS); var outputs = [aOutput, bOutput, cOutput]; outputs[j].reset(); writeBlock( settings.unwind.codes, settings.unwind.workOffsetCode ? settings.unwind.workOffsetCode + currentWorkOffset : "", settings.unwind.useAngle == "true" ? outputs[j].format(angle) : (settings.unwind.useAngle == "prefix" ? settings.unwind.anglePrefix[j] + abcFormat.format(angle) : "") ); if (settings.unwind.resetG90) { gAbsIncModal.reset(); writeBlock(gAbsIncModal.format(90)); } outputs[j].reset(); // set the current rotary axis angle from the unwind block currentDirection.setCoordinate(j, angle); setCurrentDirection(currentDirection); } } } } // <<<<< INCLUDED FROM include_files/unwindABC.cpi // >>>>> INCLUDED FROM include_files/writeWCS.cpi function writeWCS(section, wcsIsRequired) { if (section.workOffset != currentWorkOffset) { if (getSetting("workPlaneMethod.cancelTiltFirst", false) && wcsIsRequired) { cancelWorkPlane(); } if (typeof forceWorkPlane == "function" && wcsIsRequired) { forceWorkPlane(); } writeStartBlocks(wcsIsRequired, function () { writeBlock(section.wcs); }); currentWorkOffset = section.workOffset; } } // <<<<< INCLUDED FROM include_files/writeWCS.cpi // >>>>> INCLUDED FROM include_files/writeToolCall.cpi function writeToolCall(tool, insertToolCall) { if (!isFirstSection()) { writeStartBlocks(!getProperty("safeStartAllOperations") && insertToolCall, function () { writeRetract(Z); // write optional Z retract before tool change if safeStartAllOperations is enabled }); } writeStartBlocks(insertToolCall, function () { writeRetract(Z); if (getSetting("retract.homeXY.onToolChange", false)) { writeRetract(settings.retract.homeXY.onToolChange); } if (!isFirstSection() && insertToolCall) { if (typeof forceWorkPlane == "function") { forceWorkPlane(); } onCommand(COMMAND_COOLANT_OFF); // turn off coolant on tool change if (typeof disableLengthCompensation == "function") { disableLengthCompensation(false); } } if (tool.manualToolChange) { onCommand(COMMAND_STOP); writeComment("MANUAL TOOL CHANGE TO T" + toolFormat.format(tool.number)); } else { if (!isFirstSection() && getProperty("optionalStop") && insertToolCall) { onCommand(COMMAND_OPTIONAL_STOP); } onCommand(COMMAND_LOAD_TOOL); } }); if (typeof forceModals == "function" && (insertToolCall || getProperty("safeStartAllOperations"))) { forceModals(); } } // <<<<< INCLUDED FROM include_files/writeToolCall.cpi // >>>>> INCLUDED FROM include_files/startSpindle.cpi function startSpindle(tool, insertToolCall) { if (tool.type != TOOL_PROBE) { var spindleSpeedIsRequired = insertToolCall || forceSpindleSpeed || isFirstSection() || rpmFormat.areDifferent(spindleSpeed, sOutput.getCurrent()) || (tool.clockwise != getPreviousSection().getTool().clockwise); writeStartBlocks(spindleSpeedIsRequired, function () { if (spindleSpeedIsRequired || operationNeedsSafeStart) { onCommand(COMMAND_START_SPINDLE); } }); } } // <<<<< INCLUDED FROM include_files/startSpindle.cpi // >>>>> INCLUDED FROM include_files/parametricFeeds.cpi properties.useParametricFeed = { title : "Parametric feed", description: "Specifies that the feedrates should be output using parameters.", group : "preferences", type : "boolean", value : false, scope : "post" }; var activeMovements; var currentFeedId; validate(settings.parametricFeeds, "Setting 'parametricFeeds' is required but not defined."); function initializeParametricFeeds(insertToolCall) { if (getProperty("useParametricFeed") && getParameter("operation-strategy") != "drill" && !currentSection.hasAnyCycle()) { if (!insertToolCall && activeMovements && (getCurrentSectionId() > 0) && ((getPreviousSection().getPatternId() == currentSection.getPatternId()) && (currentSection.getPatternId() != 0))) { return; // use the current feeds } } else { activeMovements = undefined; return; } activeMovements = new Array(); var movements = currentSection.getMovements(); var id = 0; var activeFeeds = new Array(); if (hasParameter("operation:tool_feedCutting")) { if (movements & ((1 << MOVEMENT_CUTTING) | (1 << MOVEMENT_LINK_TRANSITION) | (1 << MOVEMENT_EXTENDED))) { var feedContext = new FeedContext(id, localize("Cutting"), getParameter("operation:tool_feedCutting")); activeFeeds.push(feedContext); activeMovements[MOVEMENT_CUTTING] = feedContext; 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"), getParameter("operation:tool_feedCutting")); activeMovements[MOVEMENT_PREDRILL] = feedContext; activeFeeds.push(feedContext); } ++id; } if (hasParameter("operation:finishFeedrate")) { if (movements & (1 << MOVEMENT_FINISH_CUTTING)) { var feedContext = new FeedContext(id, localize("Finish"), getParameter("operation:finishFeedrate")); activeFeeds.push(feedContext); activeMovements[MOVEMENT_FINISH_CUTTING] = feedContext; } ++id; } else if (hasParameter("operation:tool_feedCutting")) { if (movements & (1 << MOVEMENT_FINISH_CUTTING)) { var feedContext = new FeedContext(id, localize("Finish"), getParameter("operation:tool_feedCutting")); activeFeeds.push(feedContext); activeMovements[MOVEMENT_FINISH_CUTTING] = feedContext; } ++id; } if (hasParameter("operation:tool_feedEntry")) { if (movements & (1 << MOVEMENT_LEAD_IN)) { var feedContext = new FeedContext(id, localize("Entry"), getParameter("operation:tool_feedEntry")); activeFeeds.push(feedContext); activeMovements[MOVEMENT_LEAD_IN] = feedContext; } ++id; } if (hasParameter("operation:tool_feedExit")) { if (movements & (1 << MOVEMENT_LEAD_OUT)) { var feedContext = new FeedContext(id, localize("Exit"), getParameter("operation:tool_feedExit")); activeFeeds.push(feedContext); activeMovements[MOVEMENT_LEAD_OUT] = feedContext; } ++id; } if (hasParameter("operation:noEngagementFeedrate")) { if (movements & (1 << MOVEMENT_LINK_DIRECT)) { var feedContext = new FeedContext(id, localize("Direct"), getParameter("operation:noEngagementFeedrate")); activeFeeds.push(feedContext); activeMovements[MOVEMENT_LINK_DIRECT] = feedContext; } ++id; } else if (hasParameter("operation:tool_feedCutting") && hasParameter("operation:tool_feedEntry") && hasParameter("operation:tool_feedExit")) { if (movements & (1 << MOVEMENT_LINK_DIRECT)) { var feedContext = new FeedContext(id, localize("Direct"), Math.max(getParameter("operation:tool_feedCutting"), getParameter("operation:tool_feedEntry"), getParameter("operation:tool_feedExit"))); activeFeeds.push(feedContext); activeMovements[MOVEMENT_LINK_DIRECT] = feedContext; } ++id; } if (hasParameter("operation:reducedFeedrate")) { if (movements & (1 << MOVEMENT_REDUCED)) { var feedContext = new FeedContext(id, localize("Reduced"), getParameter("operation:reducedFeedrate")); activeFeeds.push(feedContext); activeMovements[MOVEMENT_REDUCED] = feedContext; } ++id; } if (hasParameter("operation:tool_feedRamp")) { if (movements & ((1 << MOVEMENT_RAMP) | (1 << MOVEMENT_RAMP_HELIX) | (1 << MOVEMENT_RAMP_PROFILE) | (1 << MOVEMENT_RAMP_ZIG_ZAG))) { var feedContext = new FeedContext(id, localize("Ramping"), getParameter("operation:tool_feedRamp")); activeFeeds.push(feedContext); activeMovements[MOVEMENT_RAMP] = feedContext; activeMovements[MOVEMENT_RAMP_HELIX] = feedContext; activeMovements[MOVEMENT_RAMP_PROFILE] = feedContext; activeMovements[MOVEMENT_RAMP_ZIG_ZAG] = feedContext; } ++id; } if (hasParameter("operation:tool_feedPlunge")) { if (movements & (1 << MOVEMENT_PLUNGE)) { var feedContext = new FeedContext(id, localize("Plunge"), getParameter("operation:tool_feedPlunge")); activeFeeds.push(feedContext); activeMovements[MOVEMENT_PLUNGE] = feedContext; } ++id; } if (true) { // high feed if ((movements & (1 << MOVEMENT_HIGH_FEED)) || (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]; var feedDescription = typeof formatComment == "function" ? formatComment(feedContext.description) : feedContext.description; writeBlock(settings.parametricFeeds.feedAssignmentVariable + (settings.parametricFeeds.firstFeedParameter + feedContext.id) + "=" + feedFormat.format(feedContext.feed) + SP + feedDescription); } } function FeedContext(id, description, feed) { this.id = id; this.description = description; this.feed = feed; } // <<<<< INCLUDED FROM include_files/parametricFeeds.cpi // >>>>> INCLUDED FROM include_files/smoothing.cpi // collected state below, do not edit validate(settings.smoothing, "Setting 'smoothing' is required but not defined."); var smoothing = { cancel : false, // cancel tool length prior to update smoothing for this operation isActive : false, // the current state of smoothing isAllowed : false, // smoothing is allowed for this operation isDifferent: false, // tells if smoothing levels/tolerances/both are different between operations level : -1, // the active level of smoothing tolerance : -1, // the current operation tolerance force : false // smoothing needs to be forced out in this operation }; function initializeSmoothing() { var smoothingSettings = settings.smoothing; var previousLevel = smoothing.level; var previousTolerance = xyzFormat.getResultingValue(smoothing.tolerance); // format threshold parameters var thresholdRoughing = xyzFormat.getResultingValue(smoothingSettings.thresholdRoughing); var thresholdSemiFinishing = xyzFormat.getResultingValue(smoothingSettings.thresholdSemiFinishing); var thresholdFinishing = xyzFormat.getResultingValue(smoothingSettings.thresholdFinishing); // determine new smoothing levels and tolerances smoothing.level = parseInt(getProperty("useSmoothing"), 10); smoothing.level = isNaN(smoothing.level) ? -1 : smoothing.level; smoothing.tolerance = xyzFormat.getResultingValue(Math.max(getParameter("operation:tolerance", thresholdFinishing), 0)); if (smoothing.level == 9999) { if (smoothingSettings.autoLevelCriteria == "stock") { // determine auto smoothing level based on stockToLeave var stockToLeave = xyzFormat.getResultingValue(getParameter("operation:stockToLeave", 0)); var verticalStockToLeave = xyzFormat.getResultingValue(getParameter("operation:verticalStockToLeave", 0)); if (((stockToLeave >= thresholdRoughing) && (verticalStockToLeave >= thresholdRoughing)) || getParameter("operation:strategy", "") == "face") { smoothing.level = smoothingSettings.roughing; // set roughing level } else { if (((stockToLeave >= thresholdSemiFinishing) && (stockToLeave < thresholdRoughing)) && ((verticalStockToLeave >= thresholdSemiFinishing) && (verticalStockToLeave < thresholdRoughing))) { smoothing.level = smoothingSettings.semi; // set semi level } else if (((stockToLeave >= thresholdFinishing) && (stockToLeave < thresholdSemiFinishing)) && ((verticalStockToLeave >= thresholdFinishing) && (verticalStockToLeave < thresholdSemiFinishing))) { smoothing.level = smoothingSettings.semifinishing; // set semi-finishing level } else { smoothing.level = smoothingSettings.finishing; // set finishing level } } } else { // detemine auto smoothing level based on operation tolerance instead of stockToLeave if (smoothing.tolerance >= thresholdRoughing || getParameter("operation:strategy", "") == "face") { smoothing.level = smoothingSettings.roughing; // set roughing level } else { if (((smoothing.tolerance >= thresholdSemiFinishing) && (smoothing.tolerance < thresholdRoughing))) { smoothing.level = smoothingSettings.semi; // set semi level } else if (((smoothing.tolerance >= thresholdFinishing) && (smoothing.tolerance < thresholdSemiFinishing))) { smoothing.level = smoothingSettings.semifinishing; // set semi-finishing level } else { smoothing.level = smoothingSettings.finishing; // set finishing level } } } } if (smoothing.level == -1) { // useSmoothing is disabled smoothing.isAllowed = false; } else { // do not output smoothing for the following operations smoothing.isAllowed = !(currentSection.getTool().type == TOOL_PROBE || isDrillingCycle()); } if (!smoothing.isAllowed) { smoothing.level = -1; smoothing.tolerance = -1; } switch (smoothingSettings.differenceCriteria) { case "level": smoothing.isDifferent = smoothing.level != previousLevel; break; case "tolerance": smoothing.isDifferent = smoothing.tolerance != previousTolerance; break; case "both": smoothing.isDifferent = smoothing.level != previousLevel || smoothing.tolerance != previousTolerance; break; default: error(localize("Unsupported smoothing criteria.")); return; } // tool length compensation needs to be canceled when smoothing state/level changes if (smoothingSettings.cancelCompensation) { smoothing.cancel = !isFirstSection() && smoothing.isDifferent; } } // <<<<< INCLUDED FROM include_files/smoothing.cpi // >>>>> INCLUDED FROM include_files/writeProgramHeader.cpi properties.writeMachine = { title : "Write machine", description: "Output the machine settings in the header of the program.", group : "formats", type : "boolean", value : true, scope : "post" }; properties.writeTools = { title : "Write tool list", description: "Output a tool list in the header of the program.", group : "formats", type : "boolean", value : true, scope : "post" }; function writeProgramHeader() { // 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")) { if (false) { // set to true to use the post kernel version of the tool list writeToolTable(TOOL_NUMBER_COL); } else { 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 = (getProperty("toolAsName") ? "\"" + tool.description.toUpperCase() + "\"" : "T" + toolFormat.format(tool.number)) + " " + "D=" + xyzFormat.format(tool.diameter) + " " + localize("CR") + "=" + xyzFormat.format(tool.cornerRadius); if ((tool.taperAngle > 0) && (tool.taperAngle < Math.PI)) { comment += " " + localize("TAPER") + "=" + taperFormat.format(tool.taperAngle) + localize("deg"); } if (zRanges[tool.number]) { comment += " - " + localize("ZMIN") + "=" + xyzFormat.format(zRanges[tool.number].getMinimum()); } comment += " - " + getToolTypeName(tool.type); writeComment(comment); } } } } } // <<<<< INCLUDED FROM include_files/writeProgramHeader.cpi // >>>>> INCLUDED FROM include_files/subprograms.cpi properties.useSubroutines = { title : "Use subroutines", description: "Select your desired subroutine option. 'All Operations' creates subroutines per each operation, 'Cycles' creates subroutines for cycle operations on same holes, and 'Patterns' creates subroutines for patterned operations.", group : "preferences", type : "enum", values : [ {title:"No", id:"none"}, {title:"All Operations", id:"allOperations"}, {title:"All Operations & Patterns", id:"allPatterns"}, {title:"Cycles", id:"cycles"}, {title:"Operations, Patterns, Cycles", id:"all"}, {title:"Patterns", id:"patterns"} ], value: "none", scope: "post" }; properties.useFilesForSubprograms = { title : "Use files for subroutines", description: "If enabled, subroutines will be saved as individual files.", group : "preferences", type : "boolean", value : false, scope : "post" }; var NONE = 0x0000; var PATTERNS = 0x0001; var CYCLES = 0x0010; var ALLOPERATIONS = 0x0100; var subroutineBitmasks = { none : NONE, patterns : PATTERNS, cycles : CYCLES, allOperations: ALLOPERATIONS, allPatterns : PATTERNS + ALLOPERATIONS, all : PATTERNS + CYCLES + ALLOPERATIONS }; var SUB_UNKNOWN = 0; var SUB_PATTERN = 1; var SUB_CYCLE = 2; // collected state below, do not edit validate(settings.subprograms, "Setting 'subprograms' is required but not defined."); var subprogramState = { subprograms : [], // Redirection buffer newSubprogram : false, // Indicate if the current subprogram is new to definedSubprograms currentSubprogram : 0, // The current subprogram number lastSubprogram : undefined, // The last subprogram number definedSubprograms : new Array(), // A collection of pattern and cycle subprograms saveShowSequenceNumbers: "", // Used to store pre-condition of "showSequenceNumbers" cycleSubprogramIsActive: false, // Indicate if it's handling a cycle subprogram patternIsActive : false, // Indicate if it's handling a pattern subprogram incrementalSubprogram : false, // Indicate if the current subprogram needs to go incremental mode incrementalMode : false, // Indicate if incremental mode is on mainProgramNumber : undefined // The main program number }; function subprogramResolveSetting(_setting, _val, _comment) { if (typeof _setting == "string") { return formatWords(_setting.toString().replace("%currentSubprogram", subprogramState.currentSubprogram), (_comment ? formatComment(_comment) : "")); } else { return formatWords(_setting + (_val ? settings.subprograms.format.format(_val) : ""), (_comment ? formatComment(_comment) : "")); } } /** * Start to redirect buffer to subprogram. * @param {Vector} initialPosition Initial position * @param {Vector} abc Machine axis angles * @param {boolean} incremental If the subprogram needs to go incremental mode */ function subprogramStart(initialPosition, abc, incremental) { var comment = getParameter("operation-comment", ""); var startBlock; if (getProperty("useFilesForSubprograms")) { var _fileName = subprogramState.currentSubprogram; var subprogramExtension = extension; if (settings.subprograms.files) { if (settings.subprograms.files.prefix != undefined) { _fileName = subprogramResolveSetting(settings.subprograms.files.prefix, subprogramState.currentSubprogram); } if (settings.subprograms.files.extension) { subprogramExtension = settings.subprograms.files.extension; } } var path = FileSystem.getCombinedPath(FileSystem.getFolderPath(getOutputPath()), _fileName + "." + subprogramExtension); redirectToFile(path); startBlock = subprogramResolveSetting(settings.subprograms.startBlock.files, subprogramState.currentSubprogram, comment); } else { redirectToBuffer(); startBlock = subprogramResolveSetting(settings.subprograms.startBlock.embedded, subprogramState.currentSubprogram, comment); } writeln(startBlock); subprogramState.saveShowSequenceNumbers = getProperty("showSequenceNumbers", undefined); if (subprogramState.saveShowSequenceNumbers != undefined) { setProperty("showSequenceNumbers", "false"); } if (incremental) { setAbsIncMode(true, initialPosition, abc); } if (typeof gPlaneModal != "undefined" && typeof gMotionModal != "undefined") { forceModals(gPlaneModal, gMotionModal); } } /** Output the command for calling a subprogram by its subprogram number. */ function subprogramCall() { var callBlock; if (getProperty("useFilesForSubprograms")) { callBlock = subprogramResolveSetting(settings.subprograms.callBlock.files, subprogramState.currentSubprogram); } else { callBlock = subprogramResolveSetting(settings.subprograms.callBlock.embedded, subprogramState.currentSubprogram); } writeBlock(callBlock); // call subprogram } /** End of subprogram and close redirection. */ function subprogramEnd() { if (isRedirecting()) { if (subprogramState.newSubprogram) { var finalPosition = getFramePosition(currentSection.getFinalPosition()); var abc; if (currentSection.isMultiAxis() && machineConfiguration.isMultiAxisConfiguration()) { abc = currentSection.getFinalToolAxisABC(); } else { abc = getCurrentDirection(); } setAbsIncMode(false, finalPosition, abc); if (getProperty("useFilesForSubprograms")) { var endBlockFiles = subprogramResolveSetting(settings.subprograms.endBlock.files); writeln(endBlockFiles); } else { var endBlockEmbedded = subprogramResolveSetting(settings.subprograms.endBlock.embedded); writeln(endBlockEmbedded); writeln(""); subprogramState.subprograms += getRedirectionBuffer(); } } forceAny(); subprogramState.newSubprogram = false; subprogramState.cycleSubprogramIsActive = false; if (subprogramState.saveShowSequenceNumbers != undefined) { setProperty("showSequenceNumbers", subprogramState.saveShowSequenceNumbers); } closeRedirection(); } } /** Returns true if the spatial vectors are significantly different. */ function areSpatialVectorsDifferent(_vector1, _vector2) { return (xyzFormat.getResultingValue(_vector1.x) != xyzFormat.getResultingValue(_vector2.x)) || (xyzFormat.getResultingValue(_vector1.y) != xyzFormat.getResultingValue(_vector2.y)) || (xyzFormat.getResultingValue(_vector1.z) != xyzFormat.getResultingValue(_vector2.z)); } /** Returns true if the spatial boxes are a pure translation. */ function areSpatialBoxesTranslated(_box1, _box2) { return !areSpatialVectorsDifferent(Vector.diff(_box1[1], _box1[0]), Vector.diff(_box2[1], _box2[0])) && !areSpatialVectorsDifferent(Vector.diff(_box2[0], _box1[0]), Vector.diff(_box2[1], _box1[1])); } /** Returns true if the spatial boxes are same. */ function areSpatialBoxesSame(_box1, _box2) { return !areSpatialVectorsDifferent(_box1[0], _box2[0]) && !areSpatialVectorsDifferent(_box1[1], _box2[1]); } /** * Search defined pattern subprogram by the given id. * @param {number} subprogramId Subprogram Id * @returns {Object} Returns defined subprogram if found, otherwise returns undefined */ function getDefinedPatternSubprogram(subprogramId) { for (var i = 0; i < subprogramState.definedSubprograms.length; ++i) { if ((SUB_PATTERN == subprogramState.definedSubprograms[i].type) && (subprogramId == subprogramState.definedSubprograms[i].id)) { return subprogramState.definedSubprograms[i]; } } return undefined; } /** * Search defined cycle subprogram pattern by the given id, initialPosition, finalPosition. * @param {number} subprogramId Subprogram Id * @param {Vector} initialPosition Initial position of the cycle * @param {Vector} finalPosition Final position of the cycle * @returns {Object} Returns defined subprogram if found, otherwise returns undefined */ function getDefinedCycleSubprogram(subprogramId, initialPosition, finalPosition) { for (var i = 0; i < subprogramState.definedSubprograms.length; ++i) { if ((SUB_CYCLE == subprogramState.definedSubprograms[i].type) && (subprogramId == subprogramState.definedSubprograms[i].id) && !areSpatialVectorsDifferent(initialPosition, subprogramState.definedSubprograms[i].initialPosition) && !areSpatialVectorsDifferent(finalPosition, subprogramState.definedSubprograms[i].finalPosition)) { return subprogramState.definedSubprograms[i]; } } return undefined; } /** * Creates and returns new defined subprogram * @param {Section} section The section to create subprogram * @param {number} subprogramId Subprogram Id * @param {number} subprogramType Subprogram type, can be SUB_UNKNOWN, SUB_PATTERN or SUB_CYCLE * @param {Vector} initialPosition Initial position * @param {Vector} finalPosition Final position * @returns {Object} Returns new defined subprogram */ function defineNewSubprogram(section, subprogramId, subprogramType, initialPosition, finalPosition) { // determine if this is valid for creating a subprogram isValid = subprogramIsValid(section, subprogramId, subprogramType); var subprogram = isValid ? subprogram = ++subprogramState.lastSubprogram : undefined; subprogramState.definedSubprograms.push({ type : subprogramType, id : subprogramId, subProgram : subprogram, isValid : isValid, initialPosition: initialPosition, finalPosition : finalPosition }); return subprogramState.definedSubprograms[subprogramState.definedSubprograms.length - 1]; } /** Returns true if the given section is a pattern **/ function isPatternOperation(section) { return section.isPatterned && section.isPatterned(); } /** Returns true if the given section is a cycle operation **/ function isCycleOperation(section, minimumCyclePoints) { return section.doesStrictCycle && (section.getNumberOfCycles() == 1) && (section.getNumberOfCyclePoints() >= minimumCyclePoints); } /** Returns true if the subroutine bit flag is enabled **/ function isSubProgramEnabledFor(subroutine) { return subroutineBitmasks[getProperty("useSubroutines")] & subroutine; } /** * Define subprogram based on the property "useSubroutines" * @param {Vector} _initialPosition Initial position * @param {Vector} _abc Machine axis angles */ function subprogramDefine(_initialPosition, _abc) { if (isSubProgramEnabledFor(NONE)) { // Return early return; } if (subprogramState.lastSubprogram == undefined) { // initialize first subprogram number if (settings.subprograms.initialSubprogramNumber == undefined) { try { subprogramState.lastSubprogram = getAsInt(programName); subprogramState.mainProgramNumber = subprogramState.lastSubprogram; // mainProgramNumber must be a number } catch (e) { error(localize("Program name must be a number when using subprograms.")); return; } } else { subprogramState.lastSubprogram = settings.subprograms.initialSubprogramNumber - 1; // if programName is a string set mainProgramNumber to undefined, if programName is a number set mainProgramNumber to programName subprogramState.mainProgramNumber = (!isNaN(programName) && !isNaN(parseInt(programName, 10))) ? getAsInt(programName) : undefined; } } // convert patterns into subprograms subprogramState.patternIsActive = false; if (isSubProgramEnabledFor(PATTERNS) && isPatternOperation(currentSection)) { var subprogramId = currentSection.getPatternId(); var subprogramType = SUB_PATTERN; var subprogramDefinition = getDefinedPatternSubprogram(subprogramId); subprogramState.newSubprogram = !subprogramDefinition; if (subprogramState.newSubprogram) { subprogramDefinition = defineNewSubprogram(currentSection, subprogramId, subprogramType, _initialPosition, _initialPosition); } subprogramState.currentSubprogram = subprogramDefinition.subProgram; if (subprogramDefinition.isValid) { // make sure Z-position is output prior to subprogram call var z = zOutput.format(_initialPosition.z); if (!state.retractedZ && z) { validate(!validateLengthCompensation || state.lengthCompensationActive, "Tool length compensation is not active."); // make sure that length compensation is enabled var block = ""; if (typeof gAbsIncModal != "undefined") { block += gAbsIncModal.format(90); } if (typeof gPlaneModal != "undefined") { block += gPlaneModal.format(17); } writeBlock(block); zOutput.reset(); invokeOnRapid(xOutput.getCurrent(), yOutput.getCurrent(), _initialPosition.z); } // call subprogram subprogramCall(); subprogramState.patternIsActive = true; if (subprogramState.newSubprogram) { subprogramStart(_initialPosition, _abc, subprogramState.incrementalSubprogram); } else { skipRemainingSection(); setCurrentPosition(getFramePosition(currentSection.getFinalPosition())); } } } // Patterns are not used, check other cases if (!subprogramState.patternIsActive) { // Output cycle operation as subprogram if (isSubProgramEnabledFor(CYCLES) && isCycleOperation(currentSection, settings.subprograms.minimumCyclePoints)) { var finalPosition = getFramePosition(currentSection.getFinalPosition()); var subprogramId = currentSection.getNumberOfCyclePoints(); var subprogramType = SUB_CYCLE; var subprogramDefinition = getDefinedCycleSubprogram(subprogramId, _initialPosition, finalPosition); subprogramState.newSubprogram = !subprogramDefinition; if (subprogramState.newSubprogram) { subprogramDefinition = defineNewSubprogram(currentSection, subprogramId, subprogramType, _initialPosition, finalPosition); } subprogramState.currentSubprogram = subprogramDefinition.subProgram; subprogramState.cycleSubprogramIsActive = subprogramDefinition.isValid; } // Neither patterns and cycles are used, check other operations if (!subprogramState.cycleSubprogramIsActive && isSubProgramEnabledFor(ALLOPERATIONS)) { // Output all operations as subprograms subprogramState.currentSubprogram = ++subprogramState.lastSubprogram; if (subprogramState.mainProgramNumber != undefined && (subprogramState.currentSubprogram == subprogramState.mainProgramNumber)) { subprogramState.currentSubprogram = ++subprogramState.lastSubprogram; // avoid using main program number for current subprogram } subprogramCall(); subprogramState.newSubprogram = true; subprogramStart(_initialPosition, _abc, false); } } } /** * Determine if this is valid for creating a subprogram * @param {Section} section The section to create subprogram * @param {number} subprogramId Subprogram Id * @param {number} subprogramType Subprogram type, can be SUB_UNKNOWN, SUB_PATTERN or SUB_CYCLE * @returns {boolean} If this is valid for creating a subprogram */ function subprogramIsValid(_section, subprogramId, subprogramType) { var sectionId = _section.getId(); var numberOfSections = getNumberOfSections(); var validSubprogram = subprogramType != SUB_CYCLE; var masterPosition = new Array(); masterPosition[0] = getFramePosition(_section.getInitialPosition()); masterPosition[1] = getFramePosition(_section.getFinalPosition()); var tempBox = _section.getBoundingBox(); var masterBox = new Array(); masterBox[0] = getFramePosition(tempBox[0]); masterBox[1] = getFramePosition(tempBox[1]); var rotation = getRotation(); var translation = getTranslation(); subprogramState.incrementalSubprogram = undefined; for (var i = 0; i < numberOfSections; ++i) { var section = getSection(i); if (section.getId() != sectionId) { defineWorkPlane(section, false); // check for valid pattern if (subprogramType == SUB_PATTERN) { if (section.getPatternId() == subprogramId) { var patternPosition = new Array(); patternPosition[0] = getFramePosition(section.getInitialPosition()); patternPosition[1] = getFramePosition(section.getFinalPosition()); tempBox = section.getBoundingBox(); var patternBox = new Array(); patternBox[0] = getFramePosition(tempBox[0]); patternBox[1] = getFramePosition(tempBox[1]); if (areSpatialBoxesSame(masterPosition, patternPosition) && areSpatialBoxesSame(masterBox, patternBox) && !section.isMultiAxis()) { subprogramState.incrementalSubprogram = subprogramState.incrementalSubprogram ? subprogramState.incrementalSubprogram : false; } else if (!areSpatialBoxesTranslated(masterPosition, patternPosition) || !areSpatialBoxesTranslated(masterBox, patternBox)) { validSubprogram = false; break; } else { subprogramState.incrementalSubprogram = true; } } // check for valid cycle operation } else if (subprogramType == SUB_CYCLE) { if ((section.getNumberOfCyclePoints() == subprogramId) && (section.getNumberOfCycles() == 1)) { var patternInitial = getFramePosition(section.getInitialPosition()); var patternFinal = getFramePosition(section.getFinalPosition()); if (!areSpatialVectorsDifferent(patternInitial, masterPosition[0]) && !areSpatialVectorsDifferent(patternFinal, masterPosition[1])) { validSubprogram = true; break; } } } } } setRotation(rotation); setTranslation(translation); return (validSubprogram); } /** * Sets xyz and abc output formats to incremental or absolute type * @param {boolean} incremental true: Sets incremental mode, false: Sets absolute mode * @param {Vector} xyz Linear axis values for formating * @param {Vector} abc Rotary axis values for formating */ function setAbsIncMode(incremental, xyz, abc) { var outputFormats = [xOutput, yOutput, zOutput, aOutput, bOutput, cOutput]; for (var i = 0; i < outputFormats.length; ++i) { outputFormats[i].setType(incremental ? TYPE_INCREMENTAL : TYPE_ABSOLUTE); if (typeof incPrefix != "undefined" && typeof absPrefix != "undefined") { outputFormats[i].setPrefix(incremental ? incPrefix[i] : absPrefix[i]); } if (i <= 2) { // xyz outputFormats[i].setCurrent(xyz.getCoordinate(i)); } else { // abc outputFormats[i].setCurrent(abc.getCoordinate(i - 3)); } } subprogramState.incrementalMode = incremental; if (typeof gAbsIncModal != "undefined") { if (incremental) { forceModals(gAbsIncModal); } writeBlock(gAbsIncModal.format(incremental ? 91 : 90)); } } function setCyclePosition(_position) { var _spindleAxis; if (typeof gPlaneModal != "undefined") { _spindleAxis = gPlaneModal.getCurrent() == 17 ? Z : (gPlaneModal.getCurrent() == 18 ? Y : X); } else { var _spindleDirection = machineConfiguration.getSpindleAxis().getAbsolute(); _spindleAxis = isSameDirection(_spindleDirection, new Vector(0, 0, 1)) ? Z : isSameDirection(_spindleDirection, new Vector(0, 1, 0)) ? Y : X; } switch (_spindleAxis) { case Z: zOutput.format(_position); break; case Y: yOutput.format(_position); break; case X: xOutput.format(_position); break; } } /** * Place cycle operation in subprogram * @param {Vector} initialPosition Initial position * @param {Vector} abc Machine axis angles * @param {boolean} incremental If the subprogram needs to go incremental mode */ function handleCycleSubprogram(initialPosition, abc, incremental) { subprogramState.cycleSubprogramIsActive &= !(cycleExpanded || isProbeOperation()); if (subprogramState.cycleSubprogramIsActive) { // call subprogram subprogramCall(); subprogramStart(initialPosition, abc, incremental); } } function writeSubprograms() { if (subprogramState.subprograms.length > 0) { writeln(""); write(subprogramState.subprograms); } } // <<<<< INCLUDED FROM include_files/subprograms.cpi // >>>>> INCLUDED FROM include_files/onRapid_haas.cpi function onRapid(_x, _y, _z) { var x = xOutput.format(_x); var y = yOutput.format(_y); var z = zOutput.format(_z); if (x || y || z) { if (pendingRadiusCompensation >= 0) { error(localize("Radius compensation mode cannot be changed at rapid traversal.")); return; } if (!getProperty("useG0") && (((x ? 1 : 0) + (y ? 1 : 0) + (z ? 1 : 0)) > 1)) { // axes are not synchronized writeBlock(gFeedModeModal.format(94), gMotionModal.format(1), x, y, z, getFeed(highFeedrate)); } else { writeBlock(gMotionModal.format(0), x, y, z); forceFeed(); } } } // <<<<< INCLUDED FROM include_files/onRapid_haas.cpi // >>>>> INCLUDED FROM include_files/onLinear_fanuc.cpi function onLinear(_x, _y, _z, feed) { if (pendingRadiusCompensation >= 0) { xOutput.reset(); yOutput.reset(); } var x = xOutput.format(_x); var y = yOutput.format(_y); var z = zOutput.format(_z); var f = getFeed(feed); if (x || y || z) { if (pendingRadiusCompensation >= 0) { pendingRadiusCompensation = -1; var d = getSetting("outputToolDiameterOffset", true) ? diameterOffsetFormat.format(tool.diameterOffset) : ""; writeBlock(gPlaneModal.format(17)); switch (radiusCompensation) { case RADIUS_COMPENSATION_LEFT: writeBlock(gMotionModal.format(1), gFormat.format(41), x, y, z, d, f); break; case RADIUS_COMPENSATION_RIGHT: writeBlock(gMotionModal.format(1), gFormat.format(42), x, y, z, d, f); break; default: writeBlock(gMotionModal.format(1), gFormat.format(40), x, y, z, f); } } else { writeBlock(gMotionModal.format(1), x, y, z, f); } } else if (f) { if (getNextRecord().isMotion()) { // try not to output feed without motion forceFeed(); // force feed on next line } else { writeBlock(gMotionModal.format(1), f); } } } // <<<<< INCLUDED FROM include_files/onLinear_fanuc.cpi // >>>>> INCLUDED FROM include_files/onRapid5D_haas.cpi function onRapid5D(_x, _y, _z, _a, _b, _c) { if (!currentSection.isOptimizedForMachine()) { error(localize("This post configuration has not been customized for 5-axis simultaneous toolpath.")); return; } if (pendingRadiusCompensation >= 0) { error(localize("Radius compensation mode cannot be changed at rapid traversal.")); return; } var num = (xyzFormat.areDifferent(_x, xOutput.getCurrent()) ? 1 : 0) + (xyzFormat.areDifferent(_y, yOutput.getCurrent()) ? 1 : 0) + (xyzFormat.areDifferent(_z, zOutput.getCurrent()) ? 1 : 0) + ((aOutput.isEnabled() && abcFormat.areDifferent(_a, aOutput.getCurrent())) ? 1 : 0) + ((bOutput.isEnabled() && abcFormat.areDifferent(_b, bOutput.getCurrent())) ? 1 : 0) + ((cOutput.isEnabled() && abcFormat.areDifferent(_c, cOutput.getCurrent())) ? 1 : 0); var x = xOutput.format(_x); var y = yOutput.format(_y); var z = zOutput.format(_z); var a = aOutput.format(_a); var b = bOutput.format(_b); var c = cOutput.format(_c); if (x || y || z || a || b || c) { if (!getProperty("useG0") && (tcp.isSupportedByOperation || (num > 1))) { // axes are not synchronized writeBlock(gFeedModeModal.format(94), gMotionModal.format(1), x, y, z, a, b, c, getFeed(highFeedrate)); } else { writeBlock(gMotionModal.format(0), x, y, z, a, b, c); forceFeed(); } } } // <<<<< INCLUDED FROM include_files/onRapid5D_haas.cpi // >>>>> INCLUDED FROM include_files/onLinear5D_fanuc.cpi function onLinear5D(_x, _y, _z, _a, _b, _c, feed, feedMode) { if (pendingRadiusCompensation >= 0) { error(localize("Radius compensation cannot be activated/deactivated for 5-axis move.")); return; } if (!currentSection.isOptimizedForMachine()) { forceXYZ(); } var x = xOutput.format(_x); var y = yOutput.format(_y); var z = zOutput.format(_z); var a = currentSection.isOptimizedForMachine() ? aOutput.format(_a) : toolVectorOutputI.format(_a); var b = currentSection.isOptimizedForMachine() ? bOutput.format(_b) : toolVectorOutputJ.format(_b); var c = currentSection.isOptimizedForMachine() ? cOutput.format(_c) : toolVectorOutputK.format(_c); if (feedMode == FEED_INVERSE_TIME) { forceFeed(); } var f = feedMode == FEED_INVERSE_TIME ? inverseTimeOutput.format(feed) : getFeed(feed); var fMode = feedMode == FEED_INVERSE_TIME ? 93 : getProperty("useG95") ? 95 : 94; if (x || y || z || a || b || c) { writeBlock(gFeedModeModal.format(fMode), gMotionModal.format(1), x, y, z, a, b, c, f); } else if (f) { if (getNextRecord().isMotion()) { // try not to output feed without motion forceFeed(); // force feed on next line } else { writeBlock(gFeedModeModal.format(fMode), gMotionModal.format(1), f); } } } // <<<<< INCLUDED FROM include_files/onLinear5D_fanuc.cpi // >>>>> INCLUDED FROM include_files/onCircular_haas.cpi function onCircular(clockwise, cx, cy, cz, x, y, z, feed) { if (isSpiral()) { var startRadius = getCircularStartRadius(); var endRadius = getCircularRadius(); var dr = Math.abs(endRadius - startRadius); if (dr > maximumCircularRadiiDifference) { // maximum limit linearize(tolerance); // or alternatively use other G-codes for spiral motion return; } } if (pendingRadiusCompensation >= 0) { error(localize("Radius compensation cannot be activated/deactivated for a circular move.")); return; } var start = getCurrentPosition(); if (isFullCircle()) { if (getProperty("useRadius") || isHelical()) { // radius mode does not support full arcs linearize(tolerance); return; } switch (getCircularPlane()) { case PLANE_XY: writeBlock(gPlaneModal.format(17), gFeedModeModal.format(94), gMotionModal.format(clockwise ? 2 : 3), iOutput.format(cx - start.x), jOutput.format(cy - start.y), getFeed(feed)); break; case PLANE_ZX: writeBlock(gPlaneModal.format(18), gFeedModeModal.format(94), gMotionModal.format(clockwise ? 2 : 3), iOutput.format(cx - start.x), kOutput.format(cz - start.z), getFeed(feed)); break; case PLANE_YZ: writeBlock(gPlaneModal.format(19), gFeedModeModal.format(94), gMotionModal.format(clockwise ? 2 : 3), jOutput.format(cy - start.y), kOutput.format(cz - start.z), getFeed(feed)); break; default: linearize(tolerance); } } else if (!getProperty("useRadius")) { switch (getCircularPlane()) { case PLANE_XY: writeBlock(gPlaneModal.format(17), gFeedModeModal.format(94), gMotionModal.format(clockwise ? 2 : 3), 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: writeBlock(gPlaneModal.format(18), gFeedModeModal.format(94), gMotionModal.format(clockwise ? 2 : 3), 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: writeBlock(gPlaneModal.format(19), gFeedModeModal.format(94), gMotionModal.format(clockwise ? 2 : 3), xOutput.format(x), yOutput.format(y), zOutput.format(z), jOutput.format(cy - start.y), kOutput.format(cz - start.z), getFeed(feed)); break; default: linearize(tolerance); } } else { // use radius mode var r = getCircularRadius(); if (toDeg(getCircularSweep()) > (180 + 1e-9)) { r = -r; // allow up to <360 deg arcs } switch (getCircularPlane()) { case PLANE_XY: writeBlock(gPlaneModal.format(17), gFeedModeModal.format(94), gMotionModal.format(clockwise ? 2 : 3), xOutput.format(x), yOutput.format(y), zOutput.format(z), "R" + rFormat.format(r), getFeed(feed)); break; case PLANE_ZX: writeBlock(gPlaneModal.format(18), gFeedModeModal.format(94), gMotionModal.format(clockwise ? 2 : 3), xOutput.format(x), yOutput.format(y), zOutput.format(z), "R" + rFormat.format(r), getFeed(feed)); break; case PLANE_YZ: writeBlock(gPlaneModal.format(19), gFeedModeModal.format(94), gMotionModal.format(clockwise ? 2 : 3), xOutput.format(x), yOutput.format(y), zOutput.format(z), "R" + rFormat.format(r), getFeed(feed)); break; default: linearize(tolerance); } } } // <<<<< INCLUDED FROM include_files/onCircular_haas.cpi // >>>>> INCLUDED FROM include_files/workPlaneFunctions_haas.cpi var currentWorkPlaneABC = undefined; function forceWorkPlane() { currentWorkPlaneABC = undefined; } function cancelWCSRotation() { if (typeof gRotationModal != "undefined" && gRotationModal.getCurrent() == 68) { writeBlock(gRotationModal.format(69)); } } function cancelWorkPlane(force) { if (typeof gWorkplaneModal != "undefined") { if (force) { gWorkplaneModal.reset(); } var command = gWorkplaneModal.format(255); if (command) { writeBlock(command); // cancel frame forceWorkPlane(); } } } function setWorkPlane(abc) { if (!settings.workPlaneMethod.forceMultiAxisIndexing && is3D() && !machineConfiguration.isMultiAxisConfiguration()) { return; // ignore } var workplaneIsRequired = (currentWorkPlaneABC == undefined) || abcFormat.areDifferent(abc.x, currentWorkPlaneABC.x) || abcFormat.areDifferent(abc.y, currentWorkPlaneABC.y) || abcFormat.areDifferent(abc.z, currentWorkPlaneABC.z); writeStartBlocks(workplaneIsRequired, function () { writeRetract(Z); if (getSetting("retract.homeXY.onIndexing", false)) { writeRetract(settings.retract.homeXY.onIndexing); } if (settings.workPlaneMethod.useTiltedWorkplane) { onCommand(COMMAND_UNLOCK_MULTI_AXIS); cancelWorkPlane(); if (machineConfiguration.isMultiAxisConfiguration()) { var machineABC = abc.isNonZero() ? (currentSection.isMultiAxis() ? getCurrentDirection() : getWorkPlaneMachineABC(currentSection, false)) : abc; if (settings.workPlaneMethod.useABCPrepositioning || machineABC.isZero()) { positionABC(machineABC, false); } else { setCurrentABC(machineABC); } if (abcFormat.isSignificant(abc.x % (Math.PI * 2)) || abcFormat.isSignificant(abc.y % (Math.PI * 2)) || abcFormat.isSignificant(abc.z % (Math.PI * 2))) { writeBlock(gWorkplaneModal.format(254)); // enable DWO } } } else { positionABC(abc, true); } if (!currentSection.isMultiAxis() && !isPolarModeActive()) { onCommand(COMMAND_LOCK_MULTI_AXIS); } currentWorkPlaneABC = abc; }); } // <<<<< INCLUDED FROM include_files/workPlaneFunctions_haas.cpi // >>>>> INCLUDED FROM include_files/writeRetract_fanuc.cpi function writeRetract() { var retract = getRetractParameters.apply(this, arguments); if (retract && retract.words.length > 0) { if (typeof cancelWCSRotation == "function" && getSetting("retract.cancelRotationOnRetracting", false)) { // cancel rotation before retracting cancelWCSRotation(); } for (var i in retract.words) { var words = retract.singleLine ? retract.words : retract.words[i]; switch (retract.method) { case "G28": forceModals(gMotionModal, gAbsIncModal); writeBlock(gFormat.format(28), gAbsIncModal.format(91), words); writeBlock(gAbsIncModal.format(90)); break; case "G30": forceModals(gMotionModal, gAbsIncModal); writeBlock(gFormat.format(30), gAbsIncModal.format(91), words); writeBlock(gAbsIncModal.format(90)); break; case "G53": forceModals(gMotionModal); writeBlock(gAbsIncModal.format(90), gFormat.format(53), gMotionModal.format(0), words); break; default: if (typeof writeRetractCustom == "function") { writeRetractCustom(retract); } else { error(subst(localize("Unsupported safe position method '%1'"), retract.method)); return; } } if (retract.singleLine) { break; } } } } // <<<<< INCLUDED FROM include_files/writeRetract_fanuc.cpi // >>>>> INCLUDED FROM include_files/initialPositioning_haas.cpi /** * Writes the initial positioning procedure for a section to get to the start position of the toolpath. * @param {Vector} position The initial position to move to * @param {boolean} isRequired true: Output full positioning, false: Output full positioning in optional state or output simple positioning only * @param {String} codes1 Allows to add additional code to the first positioning line * @param {String} codes2 Allows to add additional code to the second positioning line (if applicable) * @example var myVar1 = formatWords("T" + tool.number, currentSection.wcs); var myVar2 = getCoolantCodes(tool.coolant); writeInitialPositioning(initialPosition, isRequired, myVar1, myVar2); */ function writeInitialPositioning(position, isRequired, codes1, codes2) { var motionCode = {single:0, multi:0}; if (false) { switch (highFeedMapping) { case HIGH_FEED_MAP_ANY: motionCode = {single:1, multi:1}; // map all rapid traversals to high feed break; case HIGH_FEED_MAP_MULTI: motionCode = {single:0, multi:1}; // map rapid traversal along more than one axis to high feed break; } } else { motionCode = (highFeedMapping != HIGH_FEED_NO_MAPPING || !getProperty("useG0") ? {single:0, multi:1} : {single:0, multi:0}); } var feed = (highFeedMapping != HIGH_FEED_NO_MAPPING || !getProperty("useG0")) ? getFeed(highFeedrate) : ""; var gOffset = getSetting("outputToolLengthCompensation", true) ? gFormat.format(getOffsetCode()) : ""; var hOffset = getSetting("outputToolLengthOffset", true) ? hFormat.format(tool.lengthOffset) : ""; var additionalCodes = [formatWords(codes1), formatWords(codes2)]; writeBlock(gPlaneModal.format(17)); forceModals(gMotionModal); writeStartBlocks(isRequired, function() { var modalCodes = formatWords(gAbsIncModal.format(90)); // multi axis prepositioning with TWP if (currentSection.isMultiAxis() && getSetting("workPlaneMethod.prepositionWithTWP", true) && getSetting("workPlaneMethod.useTiltedWorkplane", false) && tcp.isSupportedByOperation && getCurrentDirection().isNonZero()) { var W = machineConfiguration.getOrientation(getCurrentDirection()); var prePosition = W.getTransposed().multiply(position); var angles = settings.workPlaneMethod.eulerConvention != undefined ? W.getEuler2(settings.workPlaneMethod.eulerConvention) : getCurrentDirection(); setWorkPlane(angles); writeBlock(modalCodes, gMotionModal.format(motionCode.multi), xOutput.format(prePosition.x), yOutput.format(prePosition.y), feed, additionalCodes[0]); cancelWorkPlane(); writeBlock(gMotionModal.format(0), gOffset, hOffset, additionalCodes[1]); // G0 motion mode is required for the G234 command forceXYZ(); writeBlock(gMotionModal.format(motionCode.single), xOutput.format(position.x), yOutput.format(position.y), zOutput.format(position.z)); // motionCode.single is desired, we only expect Z movement state.lengthCompensationActive = true; } else { if (machineConfiguration.isHeadConfiguration()) { writeBlock(modalCodes, gMotionModal.format(motionCode.multi), gOffset, xOutput.format(position.x), yOutput.format(position.y), zOutput.format(position.z), hOffset, feed, additionalCodes ); } else { writeBlock(modalCodes, gMotionModal.format(motionCode.multi), xOutput.format(position.x), yOutput.format(position.y), feed, additionalCodes[0]); writeBlock(gMotionModal.format(motionCode.single), gOffset, zOutput.format(position.z), hOffset, additionalCodes[1]); } state.lengthCompensationActive = true; } forceModals(gMotionModal); if (isRequired) { additionalCodes = []; // clear additionalCodes buffer } }); validate(!validateLengthCompensation || state.lengthCompensationActive, "Tool length compensation is not active."); // make sure that lenght compensation is enabled if (!isRequired) { // simple positioning var modalCodes = formatWords(gAbsIncModal.format(90), gPlaneModal.format(17)); if (!state.retractedZ && xyzFormat.getResultingValue(getCurrentPosition().z) < xyzFormat.getResultingValue(position.z)) { writeBlock(modalCodes, gMotionModal.format(motionCode.single), zOutput.format(position.z), feed); } forceXYZ(); writeBlock(modalCodes, gMotionModal.format(motionCode.multi), xOutput.format(position.x), yOutput.format(position.y), feed, additionalCodes); } forceFeed(); } // <<<<< INCLUDED FROM include_files/initialPositioning_haas.cpi // >>>>> INCLUDED FROM include_files/getProgramNumber_fanuc.cpi function getProgramNumber() { if (typeof oFormat != "undefined" && getProperty("o8")) { oFormat.setWidth(8); } var minimumProgramNumber = getSetting("programNumber.min", 1); var maximumProgramNumber = getSetting("programNumber.max", getProperty("o8") ? 99999999 : 9999); var reservedProgramNumbers = getSetting("programNumber.reserved", [8000, 9999]); if (programName) { var _programNumber; try { _programNumber = getAsInt(programName); } catch (e) { error(localize("Program name must be a number.")); } if (!((_programNumber >= minimumProgramNumber) && (_programNumber <= maximumProgramNumber))) { error(subst(localize("Program number '%1' is out of range. Please enter a program number between '%2' and '%3'."), _programNumber, minimumProgramNumber, maximumProgramNumber)); } if ((_programNumber >= reservedProgramNumbers[0]) && (_programNumber <= reservedProgramNumbers[1])) { warning(subst(localize("Program number '%1' is potentially reserved by the machine tool builder. Reserved range is '%2' to '%3'."), _programNumber, reservedProgramNumbers[0], reservedProgramNumbers[1])); } } else { error(localize("Program name has not been specified.")); } return _programNumber; } // <<<<< INCLUDED FROM include_files/getProgramNumber_fanuc.cpi // >>>>> INCLUDED FROM include_files/drillCycles_haas.cpi function writeDrillCycle(cycle, x, y, z) { if (isInspectionOperation() && (typeof inspectionCycleInspect == "function")) { inspectionCycleInspect(cycle, x, y, z); return; } if (!isSameDirection(machineConfiguration.getSpindleAxis(), getForwardDirection(currentSection))) { expandCyclePoint(x, y, z); return; } var forceCycle = false; switch (cycleType) { case "tapping-with-chip-breaking": case "left-tapping-with-chip-breaking": case "right-tapping-with-chip-breaking": forceCycle = true; if (!isFirstCyclePoint()) { writeBlock(gCycleModal.format(80)); gMotionModal.reset(); } } if (forceCycle || isFirstCyclePoint()) { // return to initial Z which is clearance plane and set absolute mode repositionToCycleClearance(cycle, x, y, z); if (currentSection.feedMode == FEED_PER_REVOLUTION) { feedOutput.setFormat(feedPerRevFormat); // apply feedPerRevFormat to feedOutput writeBlock(gFeedModeModal.format(95)); } var F = cycle.feedrate; var P = !cycle.dwell ? 0 : clamp(1, cycle.dwell * 1000, 99999999); // in milliseconds var E = typeof cycleReverse != "undefined" && cycleReverse ? "E" + rpmFormat.format(2000) : ""; switch (cycleType) { case "drilling": writeBlock( gRetractModal.format(98), gCycleModal.format(81), getCommonCycle(x, y, z, cycle.retract, cycle.clearance), E, feedOutput.format(F) ); break; case "counter-boring": if (P > 0) { writeBlock( gRetractModal.format(98), gCycleModal.format(82), getCommonCycle(x, y, z, cycle.retract, cycle.clearance), "P" + milliFormat.format(P), // not optional E, feedOutput.format(F) ); } else { writeBlock( gRetractModal.format(98), gCycleModal.format(81), getCommonCycle(x, y, z, cycle.retract, cycle.clearance), E, feedOutput.format(F) ); } break; case "chip-breaking": var useG73Retract = getProperty("useG73Retract", false); if ((!useG73Retract && (cycle.accumulatedDepth < cycle.depth)) || (useG73Retract && (cycle.accumulatedDepth < cycle.depth) && (cycle.incrementalDepthReduction > 0))) { expandCyclePoint(x, y, z); } else if (cycle.accumulatedDepth < cycle.depth) { writeBlock( gRetractModal.format(98), gCycleModal.format(73), getCommonCycle(x, y, z, cycle.retract, cycle.clearance), ("Q" + xyzFormat.format(cycle.incrementalDepth)), ("K" + xyzFormat.format(cycle.accumulatedDepth)), conditional(P > 0, "P" + milliFormat.format(P)), // optional E, feedOutput.format(F) ); } else { writeBlock( gRetractModal.format(98), gCycleModal.format(73), getCommonCycle(x, y, z, cycle.retract, cycle.clearance), (((cycle.incrementalDepthReduction > 0) ? "I" : "Q") + xyzFormat.format(cycle.incrementalDepth)), conditional(cycle.incrementalDepthReduction > 0, "J" + xyzFormat.format(cycle.incrementalDepthReduction)), conditional(cycle.incrementalDepthReduction > 0, "K" + xyzFormat.format(cycle.minimumIncrementalDepth)), conditional(P > 0, "P" + milliFormat.format(P)), // optional E, feedOutput.format(F) ); } break; case "deep-drilling": writeBlock( gRetractModal.format(98), gCycleModal.format(83), getCommonCycle(x, y, z, cycle.retract, cycle.clearance), (((cycle.incrementalDepthReduction > 0) ? "I" : "Q") + xyzFormat.format(cycle.incrementalDepth)), conditional(cycle.incrementalDepthReduction > 0, "J" + xyzFormat.format(cycle.incrementalDepthReduction)), conditional(cycle.incrementalDepthReduction > 0, "K" + xyzFormat.format(cycle.minimumIncrementalDepth)), conditional(P > 0, "P" + milliFormat.format(P)), // optional E, feedOutput.format(F) ); break; case "tapping": var tappingFPM = tool.getThreadPitch() * rpmFormat.getResultingValue(spindleSpeed); F = (getProperty("useG95forTapping") ? tool.getThreadPitch() : tappingFPM); if (getProperty("useG95forTapping")) { writeBlock(gFeedModeModal.format(95)); } writeBlock( gRetractModal.format(98), gCycleModal.format((tool.type == TOOL_TAP_LEFT_HAND) ? 74 : 84), getCommonCycle(x, y, z, cycle.retract, cycle.clearance), E, pitchOutput.format(F) ); forceFeed(); break; case "left-tapping": var tappingFPM = tool.getThreadPitch() * rpmFormat.getResultingValue(spindleSpeed); F = (getProperty("useG95forTapping") ? tool.getThreadPitch() : tappingFPM); if (getProperty("useG95forTapping")) { writeBlock(gFeedModeModal.format(95)); } writeBlock( gRetractModal.format(98), gCycleModal.format(74), getCommonCycle(x, y, z, cycle.retract, cycle.clearance), E, pitchOutput.format(F) ); forceFeed(); break; case "right-tapping": var tappingFPM = tool.getThreadPitch() * rpmFormat.getResultingValue(spindleSpeed); F = (getProperty("useG95forTapping") ? tool.getThreadPitch() : tappingFPM); if (getProperty("useG95forTapping")) { writeBlock(gFeedModeModal.format(95)); } writeBlock( gRetractModal.format(98), gCycleModal.format(84), getCommonCycle(x, y, z, cycle.retract, cycle.clearance), E, pitchOutput.format(F) ); forceFeed(); break; case "tapping-with-chip-breaking": case "left-tapping-with-chip-breaking": case "right-tapping-with-chip-breaking": var tappingFPM = tool.getThreadPitch() * rpmFormat.getResultingValue(spindleSpeed); F = (getProperty("useG95forTapping") ? tool.getThreadPitch() : tappingFPM); if (getProperty("useG95forTapping")) { writeBlock(gFeedModeModal.format(95)); } // Parameter 57 bit 6, REPT RIG TAP, is set to 1 (On) // On Mill software versions12.09 and above, REPT RIG TAP has been moved from the Parameters to Setting 133 var u = cycle.stock; var step = cycle.incrementalDepth; var first = true; while (u > cycle.bottom) { if (step < cycle.minimumIncrementalDepth) { step = cycle.minimumIncrementalDepth; } u -= step; step -= cycle.incrementalDepthReduction; gCycleModal.reset(); // required if ((u - 0.001) <= cycle.bottom) { u = cycle.bottom; } if (first) { first = false; writeBlock( gRetractModal.format(99), gCycleModal.format((tool.type == TOOL_TAP_LEFT_HAND ? 74 : 84)), getCommonCycle((gPlaneModal.getCurrent() == 19) ? u : x, (gPlaneModal.getCurrent() == 18) ? u : y, (gPlaneModal.getCurrent() == 17) ? u : z, cycle.retract, cycle.clearance), E, pitchOutput.format(F) ); } else { var position; var depth; switch (gPlaneModal.getCurrent()) { case 17: xOutput.reset(); position = xOutput.format(x); depth = zOutput.format(u); break; case 18: zOutput.reset(); position = zOutput.format(z); depth = yOutput.format(u); break; case 19: yOutput.reset(); position = yOutput.format(y); depth = xOutput.format(u); break; } writeBlock(conditional(u <= cycle.bottom, gRetractModal.format(98)), position, depth); } if (subprogramState.incrementalMode) { setCyclePosition(cycle.retract); } } forceFeed(); break; case "fine-boring": writeBlock( gRetractModal.format(98), gCycleModal.format(76), getCommonCycle(x, y, z, cycle.retract, cycle.clearance), "P" + milliFormat.format(P), // not optional "Q" + xyzFormat.format(cycle.shift), E, feedOutput.format(F) ); forceSpindleSpeed = true; break; case "back-boring": if (P > 0) { expandCyclePoint(x, y, z); } else { var dx = (gPlaneModal.getCurrent() == 19) ? cycle.backBoreDistance : 0; var dy = (gPlaneModal.getCurrent() == 18) ? cycle.backBoreDistance : 0; var dz = (gPlaneModal.getCurrent() == 17) ? cycle.backBoreDistance : 0; writeBlock( gRetractModal.format(98), gCycleModal.format(77), getCommonCycle(x - dx, y - dy, z - dz, cycle.bottom, cycle.clearance), "Q" + xyzFormat.format(cycle.shift), E, feedOutput.format(F) ); forceSpindleSpeed = true; } break; case "reaming": if (feedFormat.getResultingValue(cycle.feedrate) != feedFormat.getResultingValue(cycle.retractFeedrate)) { expandCyclePoint(x, y, z); break; } writeBlock( gRetractModal.format(98), gCycleModal.format(85), getCommonCycle(x, y, z, cycle.retract, cycle.clearance), E, feedOutput.format(F) ); break; case "stop-boring": if (P > 0) { expandCyclePoint(x, y, z); } else { writeBlock( gRetractModal.format(98), gCycleModal.format(86), getCommonCycle(x, y, z, cycle.retract, cycle.clearance), E, feedOutput.format(F) ); forceSpindleSpeed = true; } break; case "manual-boring": writeBlock( gRetractModal.format(98), gCycleModal.format(88), getCommonCycle(x, y, z, cycle.retract, cycle.clearance), "P" + milliFormat.format(P), // not optional E, feedOutput.format(F) ); break; case "boring": if (feedFormat.getResultingValue(cycle.feedrate) != feedFormat.getResultingValue(cycle.retractFeedrate)) { expandCyclePoint(x, y, z); break; } writeBlock( gRetractModal.format(98), gCycleModal.format(89), getCommonCycle(x, y, z, cycle.retract, cycle.clearance), "P" + milliFormat.format(P), // not optional E, feedOutput.format(F) ); break; default: expandCyclePoint(x, y, z); } if (subprogramsAreSupported()) { // place cycle operation in subprogram handleCycleSubprogram(new Vector(x, y, z), new Vector(0, 0, 0), false); if (subprogramState.incrementalMode) { // set current position to clearance height setCyclePosition(cycle.clearance); } } } else { if (cycleExpanded) { expandCyclePoint(x, y, z); } else { if (isPolarModeActive()) { var polarPosition = getPolarPosition(x, y, z); writeBlock(xOutput.format(polarPosition.first.x), yOutput.format(polarPosition.first.y), zOutput.format(polarPosition.first.z), aOutput.format(polarPosition.second.x), bOutput.format(polarPosition.second.y), cOutput.format(polarPosition.second.z)); return; } if (!xyzFormat.areDifferent(x, xOutput.getCurrent()) && !xyzFormat.areDifferent(y, yOutput.getCurrent()) && !xyzFormat.areDifferent(z, zOutput.getCurrent())) { switch (gPlaneModal.getCurrent()) { case 17: // XY xOutput.reset(); // at least one axis is required break; case 18: // ZX zOutput.reset(); // at least one axis is required break; case 19: // YZ yOutput.reset(); // at least one axis is required break; } } if (subprogramsAreSupported() && subprogramState.incrementalMode) { // set current position to retract height setCyclePosition(cycle.retract); } writeBlock(xOutput.format(x), yOutput.format(y), zOutput.format(z)); if (subprogramsAreSupported() && subprogramState.incrementalMode) { // set current position to clearance height setCyclePosition(cycle.clearance); } } } } function getCommonCycle(x, y, z, r, c) { forceXYZ(); if (isPolarModeActive()) { var polarPosition = getPolarPosition(x, y, z); return [xOutput.format(polarPosition.first.x), yOutput.format(polarPosition.first.y), zOutput.format(polarPosition.first.z), aOutput.format(polarPosition.second.x), bOutput.format(polarPosition.second.y), cOutput.format(polarPosition.second.z), "R" + xyzFormat.format(r)]; } else { if (subprogramsAreSupported() && subprogramState.incrementalMode) { zOutput.format(c); return [xOutput.format(x), yOutput.format(y), "Z" + xyzFormat.format(z - r), "R" + xyzFormat.format(r - c)]; } else { return [xOutput.format(x), yOutput.format(y), zOutput.format(z), "R" + xyzFormat.format(r)]; } } } // <<<<< INCLUDED FROM include_files/drillCycles_haas.cpi // >>>>> INCLUDED FROM include_files/commonInspectionFunctions_haas.cpi var isDPRNTopen = false; function inspectionCreateResultsFileHeader() { if (getProperty("useLiveConnection") && controlType != "NGC") { return; // do not DPRNT if Live connection is active on a classic control } if (isDPRNTopen) { if (!getProperty("singleResultsFile")) { writeln("DPRNT[END]"); writeBlock("PCLOS"); isDPRNTopen = false; } } if (isProbeOperation() && !printProbeResults()) { return; // if print results is not desired by probe/probeWCS } if (!isDPRNTopen) { writeBlock("PCLOS"); writeBlock("POPEN"); // check for existence of none alphanumeric characters but not spaces var resFile; if (getProperty("singleResultsFile")) { resFile = getParameter("job-description") + "-RESULTS"; } else { resFile = getParameter("operation-comment") + "-RESULTS"; } resFile = resFile.replace(/:/g, "-"); resFile = resFile.replace(/[^a-zA-Z0-9 -]/g, ""); resFile = resFile.replace(/\s/g, "-"); writeln("DPRNT[START]"); writeln("DPRNT[RESULTSFILE*" + resFile + "]"); if (hasGlobalParameter("document-id")) { writeln("DPRNT[DOCUMENTID*" + getGlobalParameter("document-id") + "]"); } if (hasGlobalParameter("model-version")) { writeln("DPRNT[MODELVERSION*" + getGlobalParameter("model-version") + "]"); } } if (isProbeOperation() && printProbeResults()) { isDPRNTopen = true; } } function getPointNumber() { if (typeof inspectionWriteVariables == "function") { return (inspectionVariables.pointNumber); } else { return ("#172[60]"); } } function inspectionWriteCADTransform() { if (getProperty("useLiveConnection") && controlType != "NGC") { return; // do not DPRNT if Live connection is active on a classic control } var cadOrigin = currentSection.getModelOrigin(); var cadWorkPlane = currentSection.getModelPlane().getTransposed(); var cadEuler = cadWorkPlane.getEuler2(EULER_XYZ_S); writeln( "DPRNT[G331" + "*N" + getPointNumber() + "*A" + abcFormat.format(cadEuler.x) + "*B" + abcFormat.format(cadEuler.y) + "*C" + abcFormat.format(cadEuler.z) + "*X" + xyzFormat.format(-cadOrigin.x) + "*Y" + xyzFormat.format(-cadOrigin.y) + "*Z" + xyzFormat.format(-cadOrigin.z) + "]" ); } function inspectionWriteWorkplaneTransform() { var orientation = (machineConfiguration.isMultiAxisConfiguration()) ? machineConfiguration.getOrientation(getCurrentDirection()) : currentSection.workPlane; var abc = orientation.getEuler2(EULER_XYZ_S); if ((getProperty("useLiveConnection"))) { liveConnectorInterface("WORKPLANE"); writeBlock(inspectionVariables.liveConnectionWPA + " = " + abcFormat.format(abc.x)); writeBlock(inspectionVariables.liveConnectionWPB + " = " + abcFormat.format(abc.y)); writeBlock(inspectionVariables.liveConnectionWPC + " = " + abcFormat.format(abc.z)); writeBlock("IF [" + inspectionVariables.workplaneStartAddress, "EQ -1] THEN", inspectionVariables.workplaneStartAddress, "=", currentSection.getParameter("autodeskcam:operation-id") ); } if (getProperty("useLiveConnection") && controlType != "NGC") { return; // do not DPRNT if Live connection is active on a classic control } writeln("DPRNT[G330" + "*N" + getPointNumber() + "*A" + abcFormat.format(abc.x) + "*B" + abcFormat.format(abc.y) + "*C" + abcFormat.format(abc.z) + "*X0*Y0*Z0*I0*R0]" ); } function writeProbingToolpathInformation(cycleDepth) { if (getProperty("useLiveConnection") && controlType != "NGC") { return; // do not DPRNT if Live connection is active on a classic control } writeln("DPRNT[TOOLPATHID*" + getParameter("autodeskcam:operation-id") + "]"); if (isInspectionOperation()) { writeln("DPRNT[TOOLPATH*" + getParameter("operation-comment") + "]"); } else { writeln("DPRNT[CYCLEDEPTH*" + xyzFormat.format(cycleDepth) + "]"); } } // <<<<< INCLUDED FROM include_files/commonInspectionFunctions_haas.cpi // >>>>> INCLUDED FROM include_files/probeCycles_renishaw.cpi validate(settings.probing, "Setting 'probing' is required but not defined."); var probeVariables = { outputRotationCodes: false, // determines if it is required to output rotation codes compensationXY : undefined, probeAngleMethod : undefined, rotaryTableAxis : -1 }; function writeProbeCycle(cycle, x, y, z, P, F) { if (isProbeOperation()) { if (!settings.workPlaneMethod.useTiltedWorkplane && !isSameDirection(currentSection.workPlane.forward, new Vector(0, 0, 1))) { if (!settings.probing.allowIndexingWCSProbing && currentSection.strategy == "probe") { error(localize("Updating WCS / work offset using probing is only supported by the CNC in the WCS frame.")); return; } } if (printProbeResults()) { writeProbingToolpathInformation(z - cycle.depth + tool.diameter / 2); inspectionWriteCADTransform(); inspectionWriteWorkplaneTransform(); if (typeof inspectionWriteVariables == "function") { inspectionVariables.pointNumber += 1; } } protectedProbeMove(cycle, x, y, z); } var macroCall = settings.probing.macroCall; switch (cycleType) { case "probing-x": protectedProbeMove(cycle, x, y, z - cycle.depth); writeBlock( macroCall, "P" + 9811, "X" + xyzFormat.format(x + approach(cycle.approach1) * (cycle.probeClearance + tool.diameter / 2)), "Q" + xyzFormat.format(cycle.probeOvertravel), getProbingArguments(cycle, true) ); break; case "probing-y": protectedProbeMove(cycle, x, y, z - cycle.depth); writeBlock( macroCall, "P" + 9811, "Y" + xyzFormat.format(y + approach(cycle.approach1) * (cycle.probeClearance + tool.diameter / 2)), "Q" + xyzFormat.format(cycle.probeOvertravel), getProbingArguments(cycle, true) ); break; case "probing-z": protectedProbeMove(cycle, x, y, Math.min(z - cycle.depth + cycle.probeClearance, cycle.retract)); writeBlock( macroCall, "P" + 9811, "Z" + xyzFormat.format(z - cycle.depth), "Q" + xyzFormat.format(cycle.probeOvertravel), getProbingArguments(cycle, true) ); break; case "probing-x-wall": protectedProbeMove(cycle, x, y, z); writeBlock( macroCall, "P" + 9812, "X" + xyzFormat.format(cycle.width1), zOutput.format(z - cycle.depth), "Q" + xyzFormat.format(cycle.probeOvertravel), "R" + xyzFormat.format(cycle.probeClearance), getProbingArguments(cycle, true) ); break; case "probing-y-wall": protectedProbeMove(cycle, x, y, z); writeBlock( macroCall, "P" + 9812, "Y" + xyzFormat.format(cycle.width1), zOutput.format(z - cycle.depth), "Q" + xyzFormat.format(cycle.probeOvertravel), "R" + xyzFormat.format(cycle.probeClearance), getProbingArguments(cycle, true) ); break; case "probing-x-channel": protectedProbeMove(cycle, x, y, z - cycle.depth); writeBlock( macroCall, "P" + 9812, "X" + xyzFormat.format(cycle.width1), "Q" + xyzFormat.format(cycle.probeOvertravel), // not required "R" + xyzFormat.format(cycle.probeClearance), getProbingArguments(cycle, true) ); break; case "probing-x-channel-with-island": protectedProbeMove(cycle, x, y, z); writeBlock( macroCall, "P" + 9812, "X" + xyzFormat.format(cycle.width1), zOutput.format(z - cycle.depth), "Q" + xyzFormat.format(cycle.probeOvertravel), "R" + xyzFormat.format(-cycle.probeClearance), getProbingArguments(cycle, true) ); break; case "probing-y-channel": protectedProbeMove(cycle, x, y, z - cycle.depth); writeBlock( macroCall, "P" + 9812, "Y" + xyzFormat.format(cycle.width1), "Q" + xyzFormat.format(cycle.probeOvertravel), // not required "R" + xyzFormat.format(cycle.probeClearance), getProbingArguments(cycle, true) ); break; case "probing-y-channel-with-island": protectedProbeMove(cycle, x, y, z); writeBlock( macroCall, "P" + 9812, "Y" + xyzFormat.format(cycle.width1), zOutput.format(z - cycle.depth), "Q" + xyzFormat.format(cycle.probeOvertravel), "R" + xyzFormat.format(-cycle.probeClearance), getProbingArguments(cycle, true) ); break; case "probing-xy-circular-boss": protectedProbeMove(cycle, x, y, z); writeBlock( macroCall, "P" + 9814, "D" + xyzFormat.format(cycle.width1), "Z" + xyzFormat.format(z - cycle.depth), "Q" + xyzFormat.format(cycle.probeOvertravel), "R" + xyzFormat.format(cycle.probeClearance), getProbingArguments(cycle, true) ); break; case "probing-xy-circular-partial-boss": protectedProbeMove(cycle, x, y, z); writeBlock( macroCall, "P" + 9823, "A" + xyzFormat.format(cycle.partialCircleAngleA), "B" + xyzFormat.format(cycle.partialCircleAngleB), "C" + xyzFormat.format(cycle.partialCircleAngleC), "D" + xyzFormat.format(cycle.width1), "Z" + xyzFormat.format(z - cycle.depth), "Q" + xyzFormat.format(cycle.probeOvertravel), "R" + xyzFormat.format(cycle.probeClearance), getProbingArguments(cycle, true) ); break; case "probing-xy-circular-hole": protectedProbeMove(cycle, x, y, z - cycle.depth); writeBlock( macroCall, "P" + 9814, "D" + xyzFormat.format(cycle.width1), "Q" + xyzFormat.format(cycle.probeOvertravel), // not required "R" + xyzFormat.format(cycle.probeClearance), getProbingArguments(cycle, true) ); break; case "probing-xy-circular-partial-hole": protectedProbeMove(cycle, x, y, z - cycle.depth); writeBlock( macroCall, "P" + 9823, "A" + xyzFormat.format(cycle.partialCircleAngleA), "B" + xyzFormat.format(cycle.partialCircleAngleB), "C" + xyzFormat.format(cycle.partialCircleAngleC), "D" + xyzFormat.format(cycle.width1), "Q" + xyzFormat.format(cycle.probeOvertravel), getProbingArguments(cycle, true) ); break; case "probing-xy-circular-hole-with-island": protectedProbeMove(cycle, x, y, z); writeBlock( macroCall, "P" + 9814, "Z" + xyzFormat.format(z - cycle.depth), "D" + xyzFormat.format(cycle.width1), "Q" + xyzFormat.format(cycle.probeOvertravel), "R" + xyzFormat.format(-cycle.probeClearance), getProbingArguments(cycle, true) ); break; case "probing-xy-circular-partial-hole-with-island": protectedProbeMove(cycle, x, y, z); writeBlock( macroCall, "P" + 9823, "Z" + xyzFormat.format(z - cycle.depth), "A" + xyzFormat.format(cycle.partialCircleAngleA), "B" + xyzFormat.format(cycle.partialCircleAngleB), "C" + xyzFormat.format(cycle.partialCircleAngleC), "D" + xyzFormat.format(cycle.width1), "Q" + xyzFormat.format(cycle.probeOvertravel), "R" + xyzFormat.format(-cycle.probeClearance), getProbingArguments(cycle, true) ); break; case "probing-xy-rectangular-hole": protectedProbeMove(cycle, x, y, z - cycle.depth); writeBlock( macroCall, "P" + 9812, "X" + xyzFormat.format(cycle.width1), "Q" + xyzFormat.format(cycle.probeOvertravel), // not required "R" + xyzFormat.format(-cycle.probeClearance), getProbingArguments(cycle, true) ); if (getProperty("useLiveConnection") && (typeof liveConnectionStoreResults == "function")) { liveConnectionStoreResults(); } writeBlock( macroCall, "P" + 9812, "Y" + xyzFormat.format(cycle.width2), "Q" + xyzFormat.format(cycle.probeOvertravel), // not required "R" + xyzFormat.format(-cycle.probeClearance), getProbingArguments(cycle, true) ); break; case "probing-xy-rectangular-boss": protectedProbeMove(cycle, x, y, z); writeBlock( macroCall, "P" + 9812, "Z" + xyzFormat.format(z - cycle.depth), "X" + xyzFormat.format(cycle.width1), "R" + xyzFormat.format(cycle.probeClearance), "Q" + xyzFormat.format(cycle.probeOvertravel), getProbingArguments(cycle, true) ); if (getProperty("useLiveConnection") && (typeof liveConnectionStoreResults == "function")) { liveConnectionStoreResults(); } writeBlock( macroCall, "P" + 9812, "Z" + xyzFormat.format(z - cycle.depth), "Y" + xyzFormat.format(cycle.width2), "R" + xyzFormat.format(cycle.probeClearance), "Q" + xyzFormat.format(cycle.probeOvertravel), getProbingArguments(cycle, true) ); break; case "probing-xy-rectangular-hole-with-island": protectedProbeMove(cycle, x, y, z); writeBlock( macroCall, "P" + 9812, "Z" + xyzFormat.format(z - cycle.depth), "X" + xyzFormat.format(cycle.width1), "Q" + xyzFormat.format(cycle.probeOvertravel), "R" + xyzFormat.format(-cycle.probeClearance), getProbingArguments(cycle, true) ); if (getProperty("useLiveConnection") && (typeof liveConnectionStoreResults == "function")) { liveConnectionStoreResults(); } writeBlock( macroCall, "P" + 9812, "Z" + xyzFormat.format(z - cycle.depth), "Y" + xyzFormat.format(cycle.width2), "Q" + xyzFormat.format(cycle.probeOvertravel), "R" + xyzFormat.format(-cycle.probeClearance), getProbingArguments(cycle, true) ); break; case "probing-xy-inner-corner": var cornerX = x + approach(cycle.approach1) * (cycle.probeClearance + tool.diameter / 2); var cornerY = y + approach(cycle.approach2) * (cycle.probeClearance + tool.diameter / 2); var cornerI = 0; var cornerJ = 0; if (cycle.probeSpacing !== undefined) { cornerI = cycle.probeSpacing; cornerJ = cycle.probeSpacing; } if ((cornerI != 0) && (cornerJ != 0)) { if (currentSection.strategy == "probe") { setProbeAngleMethod(); } } protectedProbeMove(cycle, x, y, z - cycle.depth); writeBlock( macroCall, "P" + 9815, xOutput.format(cornerX), yOutput.format(cornerY), conditional(cornerI != 0, "I" + xyzFormat.format(cornerI)), conditional(cornerJ != 0, "J" + xyzFormat.format(cornerJ)), "Q" + xyzFormat.format(cycle.probeOvertravel), getProbingArguments(cycle, true) ); break; case "probing-xy-outer-corner": var cornerX = x + approach(cycle.approach1) * (cycle.probeClearance + tool.diameter / 2); var cornerY = y + approach(cycle.approach2) * (cycle.probeClearance + tool.diameter / 2); var cornerI = 0; var cornerJ = 0; if (cycle.probeSpacing !== undefined) { cornerI = cycle.probeSpacing; cornerJ = cycle.probeSpacing; } if ((cornerI != 0) && (cornerJ != 0)) { if (currentSection.strategy == "probe") { setProbeAngleMethod(); } } protectedProbeMove(cycle, x, y, z - cycle.depth); writeBlock( macroCall, "P" + 9816, xOutput.format(cornerX), yOutput.format(cornerY), conditional(cornerI != 0, "I" + xyzFormat.format(cornerI)), conditional(cornerJ != 0, "J" + xyzFormat.format(cornerJ)), "Q" + xyzFormat.format(cycle.probeOvertravel), getProbingArguments(cycle, true) ); break; case "probing-x-plane-angle": protectedProbeMove(cycle, x, y, z - cycle.depth); writeBlock( macroCall, "P" + 9843, "X" + xyzFormat.format(x + approach(cycle.approach1) * (cycle.probeClearance + tool.diameter / 2)), "D" + xyzFormat.format(cycle.probeSpacing), "Q" + xyzFormat.format(cycle.probeOvertravel), "A" + xyzFormat.format(cycle.nominalAngle != undefined ? cycle.nominalAngle : 90), getProbingArguments(cycle, false) ); if (currentSection.strategy == "probe") { setProbeAngleMethod(); probeVariables.compensationXY = "X" + xyzFormat.format(0) + " Y" + xyzFormat.format(0); } break; case "probing-y-plane-angle": protectedProbeMove(cycle, x, y, z - cycle.depth); writeBlock( macroCall, "P" + 9843, "Y" + xyzFormat.format(y + approach(cycle.approach1) * (cycle.probeClearance + tool.diameter / 2)), "D" + xyzFormat.format(cycle.probeSpacing), "Q" + xyzFormat.format(cycle.probeOvertravel), "A" + xyzFormat.format(cycle.nominalAngle != undefined ? cycle.nominalAngle : 0), getProbingArguments(cycle, false) ); if (currentSection.strategy == "probe") { setProbeAngleMethod(); probeVariables.compensationXY = "X" + xyzFormat.format(0) + " Y" + xyzFormat.format(0); } break; case "probing-xy-pcd-hole": protectedProbeMove(cycle, x, y, z); writeBlock( macroCall, "P" + 9819, "A" + xyzFormat.format(cycle.pcdStartingAngle), "B" + xyzFormat.format(cycle.numberOfSubfeatures), "C" + xyzFormat.format(cycle.widthPCD), "D" + xyzFormat.format(cycle.widthFeature), "K" + xyzFormat.format(z - cycle.depth), "Q" + xyzFormat.format(cycle.probeOvertravel), getProbingArguments(cycle, false) ); if (cycle.updateToolWear) { error(localize("Action -Update Tool Wear- is not supported with this cycle.")); return; } break; case "probing-xy-pcd-boss": protectedProbeMove(cycle, x, y, z); writeBlock( macroCall, "P" + 9819, "A" + xyzFormat.format(cycle.pcdStartingAngle), "B" + xyzFormat.format(cycle.numberOfSubfeatures), "C" + xyzFormat.format(cycle.widthPCD), "D" + xyzFormat.format(cycle.widthFeature), "Z" + xyzFormat.format(z - cycle.depth), "Q" + xyzFormat.format(cycle.probeOvertravel), "R" + xyzFormat.format(cycle.probeClearance), getProbingArguments(cycle, false) ); if (cycle.updateToolWear) { error(localize("Action -Update Tool Wear- is not supported with this cycle.")); return; } break; } } function printProbeResults() { return currentSection.getParameter("printResults", 0) == 1; } /** Convert approach to sign. */ function approach(value) { validate((value == "positive") || (value == "negative"), "Invalid approach."); return (value == "positive") ? 1 : -1; } // <<<<< INCLUDED FROM include_files/probeCycles_renishaw.cpi // >>>>> INCLUDED FROM include_files/getProbingArguments_renishaw.cpi function getProbingArguments(cycle, updateWCS) { var outputWCSCode = updateWCS && currentSection.strategy == "probe"; if (outputWCSCode) { var maximumWcsNumber = 0; for (var i in wcsDefinitions.wcs) { maximumWcsNumber = Math.max(maximumWcsNumber, wcsDefinitions.wcs[i].range[1]); } maximumWcsNumber = probeExtWCSFormat.getResultingValue(maximumWcsNumber); var resultingWcsNumber = probeExtWCSFormat.getResultingValue(currentSection.probeWorkOffset - 6); validate(resultingWcsNumber <= maximumWcsNumber, subst("Probe work offset %1 is out of range, maximum value is %2.", resultingWcsNumber, maximumWcsNumber)); var probeOutputWorkOffset = currentSection.probeWorkOffset > 6 ? probeExtWCSFormat.format(currentSection.probeWorkOffset - 6) : probeWCSFormat.format(currentSection.probeWorkOffset); var nextWorkOffset = hasNextSection() ? getNextSection().workOffset == 0 ? 1 : getNextSection().workOffset : -1; if (currentSection.probeWorkOffset == nextWorkOffset) { currentWorkOffset = undefined; } } return [ (cycle.angleAskewAction == "stop-message" ? "B" + xyzFormat.format(cycle.toleranceAngle ? cycle.toleranceAngle : 0) : undefined), ((cycle.updateToolWear && cycle.toolWearErrorCorrection < 100) ? "F" + xyzFormat.format(cycle.toolWearErrorCorrection ? cycle.toolWearErrorCorrection / 100 : 100) : undefined), (cycle.wrongSizeAction == "stop-message" ? "H" + xyzFormat.format(cycle.toleranceSize ? cycle.toleranceSize : 0) : undefined), (cycle.outOfPositionAction == "stop-message" ? "M" + xyzFormat.format(cycle.tolerancePosition ? cycle.tolerancePosition : 0) : undefined), ((cycle.updateToolWear && cycleType == "probing-z") ? "T" + xyzFormat.format(cycle.toolLengthOffset) : undefined), ((cycle.updateToolWear && cycleType !== "probing-z") ? "T" + xyzFormat.format(cycle.toolDiameterOffset) : undefined), (cycle.updateToolWear ? "V" + xyzFormat.format(cycle.toolWearUpdateThreshold ? cycle.toolWearUpdateThreshold : 0) : undefined), (cycle.printResults ? "W" + xyzFormat.format(1 + cycle.incrementComponent) : undefined), // 1 for advance feature, 2 for reset feature count and advance component number. first reported result in a program should use W2. conditional(outputWCSCode, probeOutputWorkOffset) ]; } // <<<<< INCLUDED FROM include_files/getProbingArguments_renishaw.cpi // >>>>> INCLUDED FROM include_files/protectedProbeMove_renishaw.cpi function protectedProbeMove(_cycle, x, y, z) { var _x = xOutput.format(x); var _y = yOutput.format(y); var _z = zOutput.format(z); var macroCall = settings.probing.macroCall; if (_z && z >= getCurrentPosition().z) { writeBlock(macroCall, "P" + 9810, _z, getFeed(cycle.feedrate)); // protected positioning move } if (_x || _y) { writeBlock(macroCall, "P" + 9810, _x, _y, getFeed(highFeedrate)); // protected positioning move } if (_z && z < getCurrentPosition().z) { writeBlock(macroCall, "P" + 9810, _z, getFeed(cycle.feedrate)); // protected positioning move } } // <<<<< INCLUDED FROM include_files/protectedProbeMove_renishaw.cpi // >>>>> INCLUDED FROM include_files/setProbeAngle_fanuc.cpi function setProbeAngle() { if (probeVariables.outputRotationCodes) { validate(settings.probing.probeAngleVariables, localize("Setting 'probing.probeAngleVariables' is required for angular probing.")); var probeAngleVariables = settings.probing.probeAngleVariables; var px = probeAngleVariables.x; var py = probeAngleVariables.y; var pz = probeAngleVariables.z; var pi = probeAngleVariables.i; var pj = probeAngleVariables.j; var pk = probeAngleVariables.k; var pr = probeAngleVariables.r; var baseParamG54x4 = probeAngleVariables.baseParamG54x4; var baseParamAxisRot = probeAngleVariables.baseParamAxisRot; var probeOutputWorkOffset = currentSection.probeWorkOffset; validate(probeOutputWorkOffset <= 6, "Angular Probing only supports work offsets 1-6."); if (probeVariables.probeAngleMethod == "G68" && (Vector.diff(currentSection.getGlobalInitialToolAxis(), new Vector(0, 0, 1)).length > 1e-4)) { error(localize("You cannot use multi axis toolpaths while G68 Rotation is in effect.")); } var validateWorkOffset = false; switch (probeVariables.probeAngleMethod) { case "G54.4": var param = baseParamG54x4 + (probeOutputWorkOffset * 10); writeBlock("#" + param + "=" + px); writeBlock("#" + (param + 1) + "=" + py); writeBlock("#" + (param + 5) + "=" + pr); writeBlock(gFormat.format(54.4), "P" + probeOutputWorkOffset); break; case "G68": gRotationModal.reset(); gAbsIncModal.reset(); var xy = probeVariables.compensationXY || formatWords(formatCompensationParameter("X", px), formatCompensationParameter("Y", py)); writeBlock( gRotationModal.format(68), gAbsIncModal.format(90), xy, formatCompensationParameter("Z", pz), formatCompensationParameter("I", pi), formatCompensationParameter("J", pj), formatCompensationParameter("K", pk), formatCompensationParameter("R", pr) ); validateWorkOffset = true; break; case "AXIS_ROT": var param = baseParamAxisRot + probeOutputWorkOffset * 20 + probeVariables.rotaryTableAxis + 4; writeBlock("#" + param + " = " + "[#" + param + " + " + pr + "]"); forceWorkPlane(); // force workplane to rotate ABC in order to apply rotation offsets currentWorkOffset = undefined; // force WCS output to make use of updated parameters validateWorkOffset = true; break; default: error(localize("Angular Probing is not supported for this machine configuration.")); return; } if (validateWorkOffset) { for (var i = currentSection.getId(); i < getNumberOfSections(); ++i) { if (getSection(i).workOffset != currentSection.workOffset) { error(localize("WCS offset cannot change while using angle rotation compensation.")); return; } } } probeVariables.outputRotationCodes = false; } } function formatCompensationParameter(label, value) { return typeof value == "string" ? label + "[" + value + "]" : typeof value == "number" ? label + xyzFormat.format(value) : ""; } // <<<<< INCLUDED FROM include_files/setProbeAngle_fanuc.cpi // >>>>> INCLUDED FROM include_files/setProbeAngleMethod.cpi function setProbeAngleMethod() { var axisRotIsSupported = false; var axes = [machineConfiguration.getAxisU(), machineConfiguration.getAxisV(), machineConfiguration.getAxisW()]; for (var i = 0; i < axes.length; ++i) { if (axes[i].isEnabled() && isSameDirection((axes[i].getAxis()).getAbsolute(), new Vector(0, 0, 1)) && axes[i].isTable()) { axisRotIsSupported = true; if (settings.probing.probeAngleVariables.method == 0) { // Fanuc validate(i < 2, localize("Rotary table axis is invalid.")); probeVariables.rotaryTableAxis = i; } else { // Haas probeVariables.rotaryTableAxis = axes[i].getCoordinate(); } break; } } if (settings.probing.probeAngleMethod == undefined) { probeVariables.probeAngleMethod = axisRotIsSupported ? "AXIS_ROT" : getProperty("useG54x4") ? "G54.4" : "G68"; // automatic selection } else { probeVariables.probeAngleMethod = settings.probing.probeAngleMethod; // use probeAngleMethod from settings if (probeVariables.probeAngleMethod == "AXIS_ROT" && !axisRotIsSupported) { error(localize("Setting probeAngleMethod 'AXIS_ROT' is not supported on this machine.")); } } probeVariables.outputRotationCodes = true; } // <<<<< INCLUDED FROM include_files/setProbeAngleMethod.cpi