HSMWorks для Solid Works

22 марта 2018

http://cam.autodesk.com/posts/

КОЛЛЕГИ. САЙТ С ПОСТПРОЦЕССОРАМИ ДЛЯ HSMWORKS. Очень много достаточно функциональных для применения в нашей не совсем достаточной по мат.обеспечению действительности. Некоторые применял для товарных (т.е. для конечного выхода) деталей. Советую тем, кто пользуется HSMWORKS.

23 марта 2018

А здесь можно проследить историю версий и изменения в них. Да и постпроцессоры подходят к Fusion360, HSMWorks и Invertor HSM.

В 03.04.2016 в 00:51, sennik53 сказал:

Нужно после каждого перехода сохранять модель в формате stl. И для визуализации или отработки дальнейшего перехода вызывать сохраненную заготовку ( т.е.предудущую геометрию перехода - stl).

Согласен - не очень удобно. Но надеемся будут развития в этом неправлении у разработчиков.

Есть вариант гораздо проще.

Поставить галку в пункте Показать предварительный просмотр заготовки.

Изменено 23 марта 2018 пользователем psix1488

26 марта 2018

У нас предприятие обновляет продукцию autodesk и планируют купить набор( всё включено за 75р в год). Т.к. мне приходится работать в inventor то мне перепадет ещё и Inventor HSM.
Как вообще программка по функционалу? Брат близнец Solidcam?

Изменено 26 марта 2018 пользователем Artas28

26 марта 2018

Как по мне, так гораздо проще. Постпроцессоры готовые, править практически не требуется. Форум поддержки нормальный. на вопросы отвечают разработчики. Меня вполне устраивает. Что сказать по функционалу, не такой огромный как в SolidCam, но его хватает. Тут галерея их новой софтины. Много чего можно сделать в ней. Как говорится стратегий не много, но мне интересно с минимумом стратегий делать интересные детали. Ну и как писал выше готовые постпроцессоры для большинства машин.

Изменено 26 марта 2018 пользователем psix1488

27 марта 2018

Вчера скачал и попробовал.
1. что меня убило, это установка нуля. там были кнопки развернуть ось на 180 градусов или указать какой плоскости должна быть параллельна Х и У. А если у меня криволинейная деталь, у которой нет прямых ребер, то указать оси можно только с дополнительным построением.
2. Адаптивная обработка может как то учитывать заготовку? мне нужно что бы программа, учитывая форму заготовки, сделала её черновую обработку. не залезая внутрь детали. а она на оборот видит только то, что внутри. а вне детали ничего обрабатывать не хочет =(
До остального функционала пока не дошел, но пока программа на 3.

вот картинка, красным указана заготовка. Как сделать что бы программа обработала то, что снаружи (сделал из прямоугольника такую кривую форму, а внутрь фрезеровать карман не лезла)?

\o

Изменено 27 марта 2018 пользователем Artas28

27 марта 2018

В 23.03.2018 в 13:43, psix1488 сказал:

Есть вариант гораздо проще.

Это возможно в новых версиях. В предыдущих такого не было. Пока забросил HSMWORKS. ХОТЯ САМ-приложение достойно внимания. В 2012 году даже делал некоторые детали в "железе" (т.е. товарной номенклатуры).

Новые версии не пробовал, На вопросы, пожалуй, не смогу ответить. А так рекомендовал бы для параллельного использования с другими САМ системами в связке с применяемой CAD системой.

27 марта 2018

31 минуту назад, Artas28 сказал:

2. Адаптивная обработка может как то учитывать заготовку? мне нужно что бы программа, учитывая форму заготовки, сделала её черновую обработку. не залезая внутрь детали. а она на оборот видит только то, что внутри. а вне детали ничего обрабатывать не хочет =(

Как то я сталкивался с подобной проблемой в этой проге ! Чтоб обрабатывало снаружи при выборе контура его как-то надо вывернуть наружу (реверс) или выбрать сторону обработки точно не вспомню, копай где то в этом направлении !

Как по мне если сравнивать HSMWORKS и SolidCAm то первая по фрезеровке не дотягивает и не такая интуитивная настройка траекторий и прочих моментов хотя и дело привычки !

Не знаю как в новых версиях но в прошлых не обновлялся материал при визуализации если выбирается к примеру траектория 3 из списка в дереве и чтоб ее посмотреть надо прогонять и те что выше причем одновременно а это - !

Можно в сравнении перечислять еще много чего но как говорят кому что нравится и всем не угодишь ))))

Изменено 27 марта 2018 пользователем Frezer_PU

9 апреля 2018

В ‎27‎.‎03‎.‎2018 в 16:18, Frezer_PU сказал:

Не знаю как в новых версиях но в прошлых не обновлялся материал при визуализации если выбирается к примеру траектория 3

Я с этим разобрался, надо выбрать папку настройка, и нажать кнопку симуляция.(запустится симуляция сначала, а потом внизу где длинная полоска всей симуляции. выбрать кусок который тебе нужен).
Чем то она мне начинает нравится, хоть очень простенькая, зато очень быстро можно программировать, сама всё понимает что нужно делать.
С черновой обработкой наружных контуров тоже разобрался, не аймаш но соображает тоже неплохо)

15 апреля 2018

МОГУ ПРЕДЛОЖИТЬ ОКОЛО 1000 ПОСТПРОЦЕССОРОВ (МНОГИЕ ПОВТОРЯЮТСЯ - ВАРИАНТЫ СОЗДАНИЯ АВТОРАМИ ПОСТПРОЦЕССОРОВ(ПОХОЖЕ В СТАДИИ ОТЛАДКИ БЫЛИ ПОС-РЫ И ПОЭТОМУ НЕКОТОРЫЕ НЕ РАБОТАЮТ , А ДРУГИЕ НЕ СОВСЕМ ДОВЕДЕНЫ ДО КОНЦА)). НО МОЖНО ОТОБРАТЬ ВПОЛНЕ НОРМАЛЬНО ВЫДАЮЩИЕ КАДРЫ УП. ПРОБОВАЛ САМ. Если интересно - дайте знать.

15 апреля 2018

Есть адрес сайта по обучению стратегиям ( на русском языке сайт).

Есть адрес сайта по предоставлению наиболее распространенных постпроцессоров (Имется ввиду системы ЧПУ - ФАНУК, ХААС, СИНУМЕРИК, ХАЙДЕНХАЙН и др.). Официально предоставляется автодеском (постпроцессоры).

3 мая 2018

В 15.04.2018 в 14:44, sennik53 сказал:

МОГУ ПРЕДЛОЖИТЬ ОКОЛО 1000 ПОСТПРОЦЕССОРОВ (МНОГИЕ ПОВТОРЯЮТСЯ - ВАРИАНТЫ СОЗДАНИЯ АВТОРАМИ ПОСТПРОЦЕССОРОВ(ПОХОЖЕ В СТАДИИ ОТЛАДКИ БЫЛИ ПОС-РЫ И ПОЭТОМУ НЕКОТОРЫЕ НЕ РАБОТАЮТ , А ДРУГИЕ НЕ СОВСЕМ ДОВЕДЕНЫ ДО КОНЦА)). НО МОЖНО ОТОБРАТЬ ВПОЛНЕ НОРМАЛЬНО ВЫДАЮЩИЕ КАДРЫ УП. ПРОБОВАЛ САМ. Если интересно - дайте знать.

Мне интересно. Там CMS станков случаем нету?

4 мая 2018

16 часов назад, OOO сказал:

Мне интересно. Там CMS станков случаем нету?

ПОСТПРОЦЕССОРЫ ОСНОВАНЫ НА СИСТЕМАХ ЧПУ. Градация по моделям станков нет.

https://cloud.mail.ru/public/Lnoy/FKdTjwMk6

4 мая 2018

7 часов назад, sennik53 сказал:

ПОСТПРОЦЕССОРЫ ОСНОВАНЫ НА СИСТЕМАХ ЧПУ. Градация по моделям станков нет.

https://cloud.mail.ru/public/Lnoy/FKdTjwMk6

К сожалению там FANUC вдоль и поперек перекопанный производителем. + пять осей. Программа клевая и простая. А найти кто может подправить стандартный пост Fanuka не представляется возможным. Написали мне пост для PowerMill. Но теряется связка SolidWorks + HSM. А у меня на ней остальное оборудование, плюс минусы в конвертации моделей и т.д.

6 мая 2018

Скрытый текст

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

FANUC post processor configuration.

$Revision: 41960 008441bba96f8a0a2230dac71d544bca3ae8b70e $
$Date: 2018-05-01 11:19:56 $

FORKID {ECCF493A-8FAE-4803-A465-19049BA8E985}
*/

description = "Doosan 3/5-axis VMC (FANUC)";
vendor = "Doosan";
vendorUrl = "http://www.doosanmachinetools.com";
legal = "Copyright (C) 2012-2018 by Autodesk, Inc.";
certificationLevel = 2;
minimumRevision = 24000;

longDescription = "Post for Doosan 3/5-axis VMC post with Fanuc control.";

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

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

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

// user-defined properties
properties = {
writeMachine: true, // write machine
writeTools: true, // writes the tools
preloadTool: true, // preloads next tool on tool change if any
showSequenceNumbers: false, // show sequence numbers
sequenceNumberStart: 10, // first sequence number
sequenceNumberIncrement: 5, // increment for sequence numbers
optionalStop: true, // optional stop
o8: false, // specifies 8-digit program number
separateWordsWithSpace: true, // specifies that the words should be separated with a white space
allow3DArcs: false, // specifies that 3D circular arcs are allowed
useRadius: false, // specifies that arcs should be output using the radius (R word) instead of the I, J, and K words
forceIJK: false, // force output of IJK for G2/G3 when not using R word
useParametricFeed: false, // specifies that feed should be output using Q values
showNotes: false, // specifies that operation notes should be output
useSmoothing: false, // specifies if smoothing should be used or not
useNanoSmoothing: false, // specifies if nano smoothing should be used
usePitchForTapping: false, // enable to use pitch instead of feed for the F-word for canned tapping cycles - note that your CNC control must be setup for pitch mode!
useG30: true, // output G30 instead of G28
useG95: false, // use IPR/MPR instead of IPM/MPM
homePositionCenter: false, // moves the part in X in center of the door at end of program (ONLY WORKS IF THE TABLE IS MOVING)
has5Axis: false, // specifies if multi-axis toolpath should be output
useG54x4: false, // Fanuc 30i supports G54.4 for Workpiece Error Compensation
useSubroutines: false, // specifies that subroutines per each operation should be generated
useSubroutinePatterns: false, // generates subroutines for patterned operation
useSubroutineCycles: false // generates subroutines for cycle operations on same holes
};

// user-defined property definitions
propertyDefinitions = {
writeMachine: {title:"Write machine", description:"Output the machine settings in the header of the code.", group:0, type:"boolean"},
writeTools: {title:"Write tool list", description:"Output a tool list in the header of the code.", group:0, type:"boolean"},
preloadTool: {title:"Preload tool", description:"Preloads the next tool at a tool change (if any).", group:1, type:"boolean"},
showSequenceNumbers: {title:"Use sequence numbers", description:"Use sequence numbers for each block of outputted code.", group:1, type:"boolean"},
sequenceNumberStart: {title:"Start sequence number", description:"The number at which to start the sequence numbers.", group:1, type:"integer"},
sequenceNumberIncrement: {title:"Sequence number increment", description:"The amount by which the sequence number is incremented by in each block.", group:1, type:"integer"},
optionalStop: {title:"Optional stop", description:"Outputs optional stop code during when necessary in the code.", type:"boolean"},
o8: {title:"8 Digit program number", description:"Specifies that an 8 digit program number is needed.", type:"boolean"},
separateWordsWithSpace: {title:"Separate words with space", description:"Adds spaces between words if 'yes' is selected.", type:"boolean"},
allow3DArcs: {title:"Allow 3D arcs", description:"Specifies whether 3D circular arcs are allowed.", type:"boolean"},
useRadius: {title:"Radius arcs", description:"If yes is selected, arcs are outputted using radius values rather than IJK.", type:"boolean"},
forceIJK: {title:"Force IJK", description:"Force the output of IJK for G2/G3 when not using R mode.", type:"boolean"},
useParametricFeed: {title:"Parametric feed", description:"Specifies the feed value that should be output using a Q value.", type:"boolean"},
showNotes: {title:"Show notes", description:"Writes operation notes as comments in the outputted code.", type:"boolean"},
useSmoothing: {title:"Use smoothing", description:"Specifies if smoothing should be used or not.", type:"boolean"},
useNanoSmoothing: {title:"Use Nano smoothing", description:"Enables nano smoothing mode.", type:"boolean"},
usePitchForTapping: {title:"Force IJK", description:"Enables the use of pitch instead of feed for the F-word in canned tapping cycles. Your CNC control must be setup for pitch mode!", type:"boolean"},
useG30: {title:"Use G30", description:"Use G30 instead of G28.", type:"boolean"},
useG95: {title:"Use G95", description:"Use IPR/MPR instead of IPM/MPM.", type:"boolean"},
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.", type:"boolean"},
useG54x4: {title:"Use G54.4", description:"Fanuc 30i supports G54.4 for workpiece error compensation.", type:"boolean"},
has5Axis: {title:"Has 5-axis", description:"Specifies if multi-axis toolpaths are supported.", type:"boolean"},
useSubroutines: {title:"Use subroutines", description:"Specifies that subroutines per each operation should be generated.", type:"boolean"},
useSubroutinePatterns: {title:"Use subroutine patterns", description:"Generates subroutines for patterned operation.", type:"boolean"},
useSubroutineCycles: {title:"Use subroutine cycles", description:"Generates subroutines for cycle operations on same holes.", type:"boolean"}
};

// samples:
// throughTool: {on: 88, off: 89}
// throughTool: {on: [8, 88], off: [9, 89]}
var coolants = {
flood: {on: 8},
mist: {on: 12},
throughTool: {on: 7},
air: {on: 14, off: 15},
airThroughTool: {on:144, off: 145},
suction: {on: 132, off: 133},
floodMist: {},
floodThroughTool: {},
off: 9
};

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

// circular output
var iOutput = createReferenceVariable({prefix:"I"}, xyzFormat);
var jOutput = createReferenceVariable({prefix:"J"}, xyzFormat);
var kOutput = createReferenceVariable({prefix:"K"}, xyzFormat);

// fixed settings
var firstFeedParameter = 500;
var useMultiAxisFeatures = false;
var forceMultiAxisIndexing = false; // force multi-axis indexing for 3D programs
var useRotaryScale = false; // output C-axis on a rotary scale
var useRotarySign = true; // C-axis uses sign of angle to determine direction
var probeCode = {code:mFormat, value:165};
var maximumLineLength = 80; // the maximum number of charaters allowed in a line
var minimumCyclePoints = 5; // minimum number of points in cycle operation to consider for subprogram

var WARNING_WORK_OFFSET = 0;

var ANGLE_PROBE_NOT_SUPPORTED = 0;
var ANGLE_PROBE_USE_ROTATION = 1;
var ANGLE_PROBE_USE_CAXIS = 2;

var SUB_UNKNOWN = 0;
var SUB_PATTERN = 1;
var SUB_CYCLE = 2;

// collected state
var sequenceNumber;
var currentWorkOffset;
var optionalSection = false;
var forceSpindleSpeed = false;
var activeMovements; // do not use by default
var currentFeedId;
var g68RotationMode = 0;
var angularProbingMode;
var subprograms = [];
var currentPattern = -1;
var firstPattern = false;
var currentSubprogram;
var lastSubprogram;
var definedPatterns = new Array();
var incrementalMode = false;
var saveShowSequenceNumbers;
var cycleSubprogramIsActive = false;
var patternIsActive = false;
var lastOperationComment = "";
var previousABC = new Vector(0, 0, 0);
var retracted = false; // specifies that the tool has been retracted to the safe plane

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

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

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

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

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

gRotationModal.format(69); // Default to G69 Rotation Off

if (properties.useNanoSmoothing) {
properties.useSmoothing = true;
}

if (properties.has5Axis) { // note: setup your machine here
var aAxis = createAxis({coordinate:0, table:true, axis:[1, 0, 0], range:[-120, 30], preference:-1});
var cAxis;
if (useRotaryScale) { // output C-axis on rotary scale
cAxis = createAxis({coordinate:2, table:true, axis:[0, 0, 1], cyclic:true, range:[0, 360]});
} else { // output C-axis on linear scale
cAxis = createAxis({coordinate:2, table:true, axis:[0, 0, 1]});
}
machineConfiguration = new MachineConfiguration(aAxis, cAxis);

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

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

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

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

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

if (programName) {
var programId;
try {
programId = getAsInt(programName);
} catch(e) {
error(localize("Program name must be a number."));
return;
}
if (properties.o8) {
if (!((programId >= 1) && (programId <= 99999999))) {
error(localize("Program number is out of range."));
return;
}
} else {
if (!((programId >= 1) && (programId <= 9999))) {
error(localize("Program number is out of range."));
return;
}
}
if ((programId >= 8000) && (programId <= 9999)) {
warning(localize("Program number is reserved by tool builder."));
}

if (programComment) {
writeln("O" + oFormat.format(programId) + " (" + filterText(String(programComment).toUpperCase(), permittedCommentChars) + ")");
} else {
writeln("O" + oFormat.format(programId));
}
lastSubprogram = programId;
} else {
error(localize("Program name has not been specified."));
return;
}

// dump machine configuration
var vendor = machineConfiguration.getVendor();
var model = machineConfiguration.getModel();
var description = machineConfiguration.getDescription();

if (properties.writeMachine && (vendor || model || description)) {
writeComment(localize("Machine"));
if (vendor) {
writeComment(" " + localize("vendor") + ": " + vendor);
}
if (model) {
writeComment(" " + localize("model") + ": " + model);
}
if (description) {
writeComment(" " + localize("description") + ": " + description);
}
}

// dump tool information
if (properties.writeTools) {
var zRanges = {};
if (is3D()) {
var numberOfSections = getNumberOfSections();
for (var i = 0; i < numberOfSections; ++i) {
var section = getSection(i);
var zRange = section.getGlobalZRange();
var tool = section.getTool();
if (zRanges[tool.number]) {
zRanges[tool.number].expandToRange(zRange);
} else {
zRanges[tool.number] = zRange;
}
}
}

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

// absolute coordinates and feed per min
writeBlock(/*gAbsIncModal.format(90),*/ gFeedModeModal.format(properties.useG95 ? 95 : 94), gPlaneModal.format(17), gFormat.format(49), gFormat.format(40), gFormat.format(80));

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

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

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

writeRetract(Z);
writeRetract(Y);
writeBlock(gAbsIncModal.format(90));
}

function onComment(message) {
var comments = String(message).split(";");
for (comment in comments) {
writeComment(comments[comment]);
}
}

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

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

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

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

var lengthCompensationActive = false;

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

var currentSmoothing = false;

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

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

currentSmoothing = mode;
if (properties.useNanoSmoothing) {
writeBlock(gFormat.format(5.1), mode ? "Q3" : "Q0");
} else {
writeBlock(gFormat.format(5.1), mode ? "Q1" : "Q0");
}
return true;
}

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

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

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

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

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

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

var currentWorkPlaneABC = undefined;

function forceWorkPlane() {
currentWorkPlaneABC = undefined;
}

function defineWorkPlane(_section, _setWorkPlane) {
var abc = new Vector(0, 0, 0);
if (forceMultiAxisIndexing || !is3D() || machineConfiguration.isMultiAxisConfiguration()) { // use 5-axis indexing for multi-axis mode
// set working plane after datum shift

if (_section.isMultiAxis()) {
forceWorkPlane();
cancelTransformation();
if (_setWorkPlane) {
if (!properties.has5Axis) {
error(localize("This post configuration has not been customized for 5-axis simultaneous toolpath."));
}
onCommand(COMMAND_UNLOCK_MULTI_AXIS);
var abc = currentSection.getInitialToolAxisABC();
gMotionModal.reset();
writeBlock(
gMotionModal.format(0),
conditional(machineConfiguration.isMachineCoordinate(0), aOutput.format(abc.x)),
conditional(machineConfiguration.isMachineCoordinate(1), bOutput.format(abc.y)),
conditional(machineConfiguration.isMachineCoordinate(2),
cOutput.format(getDirectionalABC(previousABC.z, abc.z, cOutput)))
);
previousABC = abc;
}
} else {
if (useMultiAxisFeatures) {
var eulerXYZ = currentSection.workPlane.getTransposed().getEuler2(EULER_ZXZ_R);
abc = new Vector(eulerXYZ.x, eulerXYZ.y, eulerXYZ.z);
cancelTransformation();
} else {
abc = getWorkPlaneMachineABC(_section.workPlane, _setWorkPlane);
previousABC = abc;
}
if (_setWorkPlane) {
setWorkPlane(abc);
}
}
} else { // pure 3D
var remaining = _section.workPlane;
if (!isSameDirection(remaining.forward, new Vector(0, 0, 1))) {
error(localize("Tool orientation is not supported."));
return abc;
}
setRotation(remaining);
}
return abc;
}

function setWorkPlane(abc) {
if (!forceMultiAxisIndexing && is3D() && !machineConfiguration.isMultiAxisConfiguration()) {
return; // ignore
}

if (!((currentWorkPlaneABC == undefined) ||
abcFormat.areDifferent(abc.x, currentWorkPlaneABC.x) ||
abcFormat.areDifferent(abc.y, currentWorkPlaneABC.y) ||
abcFormat.areDifferent(abc.z, currentWorkPlaneABC.z))) {
return; // no change
}

onCommand(COMMAND_UNLOCK_MULTI_AXIS);

if (useMultiAxisFeatures) {
if (abc.isNonZero()) {
writeBlock(gFormat.format(68.2), "X" + xyzFormat.format(0), "Y" + xyzFormat.format(0), "Z" + xyzFormat.format(0), "I" + abcFormat.format(abc.x), "J" + abcFormat.format(abc.y), "K" + abcFormat.format(abc.z)); // set frame
writeBlock(gFormat.format(53.1)); // turn machine
} else {
writeBlock(gFormat.format(69)); // cancel frame
}
} else {
gMotionModal.reset();
writeBlock(
gMotionModal.format(0),
conditional(machineConfiguration.isMachineCoordinate(0), aOutput.format(abc.x)),
conditional(machineConfiguration.isMachineCoordinate(1), bOutput.format(abc.y)),
conditional(machineConfiguration.isMachineCoordinate(2),
cOutput.format(getDirectionalABC(previousABC.z, abc.z, cOutput)))
);
}

onCommand(COMMAND_LOCK_MULTI_AXIS);

currentWorkPlaneABC = abc;
}

var closestABC = false; // choose closest machine angles
var currentMachineABC;

function getWorkPlaneMachineABC(workPlane, _setWorkPlane) {
var W = workPlane; // map to global frame

var abc = machineConfiguration.getABC(W);
if (closestABC) {
if (currentMachineABC) {
abc = machineConfiguration.remapToABC(abc, currentMachineABC);
} else {
abc = machineConfiguration.getPreferredABC(abc);
}
} else {
abc = machineConfiguration.getPreferredABC(abc);
}

try {
abc = machineConfiguration.remapABC(abc);
if (_setWorkPlane) {
currentMachineABC = abc;
}
} catch (e) {
error(
localize("Machine angles not supported") + ":"
+ conditional(machineConfiguration.isMachineCoordinate(0), " A" + abcFormat.format(abc.x))
+ conditional(machineConfiguration.isMachineCoordinate(1), " B" + abcFormat.format(abc.y))
+ conditional(machineConfiguration.isMachineCoordinate(2), " C" + abcFormat.format(abc.z))
);
}

var direction = machineConfiguration.getDirection(abc);
if (!isSameDirection(direction, W.forward)) {
error(localize("Orientation not supported."));
}

if (!machineConfiguration.isABCSupported(abc)) {
error(
localize("Work plane is not supported") + ":"
+ conditional(machineConfiguration.isMachineCoordinate(0), " A" + abcFormat.format(abc.x))
+ conditional(machineConfiguration.isMachineCoordinate(1), " B" + abcFormat.format(abc.y))
+ conditional(machineConfiguration.isMachineCoordinate(2), " C" + abcFormat.format(abc.z))
);
}

var tcp = false;
if (tcp) {
setRotation(W); // TCP mode
} else {
var O = machineConfiguration.getOrientation(abc);
var R = machineConfiguration.getRemainingOrientation(abc, W);
setRotation(R);
}

return abc;
}

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

var probeOutputWorkOffset = 1;

function onParameter(name, value) {
if (name == "probe-output-work-offset") {
probeOutputWorkOffset = (value > 0) ? value : 1;
}
}

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

function subprogramDefine(_initialPosition, _abc, _retracted, _zIsOutput) {
// convert patterns into subprograms
var usePattern = false;
patternIsActive = false;
if (currentSection.isPatterned && currentSection.isPatterned() && properties.useSubroutinePatterns) {
currentPattern = currentSection.getPatternId();
firstPattern = true;
for (var i = 0; i < definedPatterns.length; ++i) {
if ((definedPatterns.patternType == SUB_PATTERN) && (currentPattern == definedPatterns.patternId)) {
currentSubprogram = definedPatterns.subProgram;
usePattern = definedPatterns.validPattern;
firstPattern = false;
break;
}
}

if (firstPattern) {
// determine if this is a valid pattern for creating a subprogram
usePattern = subprogramIsValid(currentSection, currentPattern, SUB_PATTERN);
if (usePattern) {
currentSubprogram = ++lastSubprogram;
}
definedPatterns.push({
patternType: SUB_PATTERN,
patternId: currentPattern,
subProgram: currentSubprogram,
validPattern: usePattern,
initialPosition: _initialPosition,
finalPosition: _initialPosition
});
}

if (usePattern) {
// make sure Z-position is output prior to subprogram call
if (!_retracted && !_zIsOutput) {
writeBlock(gMotionModal.format(0), zOutput.format(_initialPosition.z));
}

// call subprogram
writeBlock(mFormat.format(98), "P" + oFormat.format(currentSubprogram));
patternIsActive = true;

if (firstPattern) {
subprogramStart(_initialPosition, _abc, true);
} else {
skipRemainingSection();
setCurrentPosition(getFramePosition(currentSection.getFinalPosition()));
}
}
}

// Output cycle operation as subprogram
if (!usePattern && properties.useSubroutineCycles && currentSection.doesStrictCycle &&
(currentSection.getNumberOfCycles() == 1) && currentSection.getNumberOfCyclePoints() >= minimumCyclePoints) {
var finalPosition = getFramePosition(currentSection.getFinalPosition());
currentPattern = currentSection.getNumberOfCyclePoints();
firstPattern = true;
for (var i = 0; i < definedPatterns.length; ++i) {
if ((definedPatterns.patternType == SUB_CYCLE) && (currentPattern == definedPatterns.patternId) &&
!areSpatialVectorsDifferent(_initialPosition, definedPatterns.initialPosition) &&
!areSpatialVectorsDifferent(finalPosition, definedPatterns.finalPosition)) {
currentSubprogram = definedPatterns.subProgram;
usePattern = definedPatterns.validPattern;
firstPattern = false;
break;
}
}

if (firstPattern) {
// determine if this is a valid pattern for creating a subprogram
usePattern = subprogramIsValid(currentSection, currentPattern, SUB_CYCLE);
if (usePattern) {
currentSubprogram = ++lastSubprogram;
}
definedPatterns.push({
patternType: SUB_CYCLE,
patternId: currentPattern,
subProgram: currentSubprogram,
validPattern: usePattern,
initialPosition: _initialPosition,
finalPosition: finalPosition
});
}
cycleSubprogramIsActive = usePattern;
}

// Output each operation as a subprogram
if (!usePattern && properties.useSubroutines) {
currentSubprogram = ++lastSubprogram;
writeBlock(mFormat.format(98), "P" + oFormat.format(currentSubprogram));
firstPattern = true;
subprogramStart(_initialPosition, _abc, false);
}
}

function subprogramStart(_initialPosition, _abc, _incremental) {
redirectToBuffer();
var comment = "";
if (hasParameter("operation-comment")) {
comment = getParameter("operation-comment");
}
writeln(
"O" + oFormat.format(currentSubprogram) +
conditional(comment, formatComment(comment.substr(0, maximumLineLength - 2 - 6 - 1)))
);
saveShowSequenceNumbers = properties.showSequenceNumbers;
properties.showSequenceNumbers = false;
if (_incremental) {
setIncrementalMode(_initialPosition, _abc);
}
}

function subprogramEnd() {
if (firstPattern) {
writeBlock(mFormat.format(99));
writeln("");
subprograms += getRedirectionBuffer();
}
forceAny();
firstPattern = false;
properties.showSequenceNumbers = saveShowSequenceNumbers;
closeRedirection();
}

function subprogramIsValid(_section, _patternId, _patternType) {
var sectionId = _section.getId();
var numberOfSections = getNumberOfSections();
var validSubprogram = _patternType != 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();

for (var i = 0; i < numberOfSections; ++i) {
var section = getSection(i);
if (section.getId() != sectionId) {
defineWorkPlane(section, false);
// check for valid pattern
if (_patternType == SUB_PATTERN) {
if (section.getPatternId() == _patternId) {
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 (!areSpatialBoxesTranslated(masterPosition, patternPosition) || !areSpatialBoxesTranslated(masterBox, patternBox)) {
validSubprogram = false;
break;
}
}

// check for valid cycle operation
} else if (_patternType == SUB_CYCLE) {
if ((section.getNumberOfCyclePoints() == _patternId) && (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);
}

function setIncrementalMode(xyz, abc) {
xOutput = createIncrementalVariable({prefix:"X"}, xyzFormat);
xOutput.format(xyz.x);
xOutput.format(xyz.x);
yOutput = createIncrementalVariable({prefix:"Y"}, xyzFormat);
yOutput.format(xyz.y);
yOutput.format(xyz.y);
zOutput = createIncrementalVariable({prefix:"Z"}, xyzFormat);
zOutput.format(xyz.z);
zOutput.format(xyz.z);
aOutput = createIncrementalVariable({prefix:"A"}, abcFormat);
aOutput.format(abc.x);
aOutput.format(abc.x);
bOutput = createIncrementalVariable({prefix:"B"}, abcFormat);
bOutput.format(abc.y);
bOutput.format(abc.y);
cOutput = createIncrementalVariable({prefix:"C"}, abcFormat);
cOutput.format(abc.z);
cOutput.format(abc.z);
gAbsIncModal.reset();
writeBlock(gAbsIncModal.format(91));
incrementalMode = true;
}

function setAbsoluteMode(xyz, abc) {
if (incrementalMode) {
xOutput = createVariable({prefix:"X"}, xyzFormat);
xOutput.format(xyz.x);
yOutput = createVariable({prefix:"Y"}, xyzFormat);
yOutput.format(xyz.y);
zOutput = createVariable({prefix:"Z"}, xyzFormat);
zOutput.format(xyz.z);
aOutput = createVariable({prefix:"A"}, abcFormat);
aOutput.format(abc.x);
bOutput = createVariable({prefix:"B"}, abcFormat);
bOutput.format(abc.y);
cOutput = createVariable({prefix:"C"}, abcFormat);
cOutput.format(abc.z);
gAbsIncModal.reset();
writeBlock(gAbsIncModal.format(90));
incrementalMode = false;
}
}

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

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

var zIsOutput = false; // true if the Z-position has been output, used for patterns

var newWorkOffset = isFirstSection() ||
(getPreviousSection().workOffset != currentSection.workOffset); // work offset changes
var newWorkPlane = isFirstSection() ||
!isSameDirection(getPreviousSection().getGlobalFinalToolAxis(), currentSection.getGlobalInitialToolAxis()) ||
(currentSection.isOptimizedForMachine() && getPreviousSection().isOptimizedForMachine() &&
Vector.diff(getPreviousSection().getFinalToolAxisABC(), currentSection.getInitialToolAxisABC()).length > 1e-4) ||
(!machineConfiguration.isMultiAxisConfiguration() && currentSection.isMultiAxis()) ||
(!getPreviousSection().isMultiAxis() && currentSection.isMultiAxis() ||
getPreviousSection().isMultiAxis() && !currentSection.isMultiAxis()); // force newWorkPlane between indexing and simultaneous operations
var forceSmoothing = properties.useSmoothing &&
(hasParameter("operation-strategy") && (getParameter("operation-strategy") == "drill") ||
!isFirstSection() && getPreviousSection().hasParameter("operation-strategy") && (getPreviousSection().getParameter("operation-strategy") == "drill")); // force smoothing in case !insertToolCall (2d chamfer)
if (insertToolCall || newWorkOffset || newWorkPlane || forceSmoothing) {

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

// retract to safe plane
writeRetract(Z); // retract
writeBlock(gAbsIncModal.format(90));
forceXYZ();
if ((insertToolCall && !isFirstSection()) || forceSmoothing) {
disableLengthCompensation();
setSmoothing(false);
}
}

if (hasParameter("operation-comment")) {
var comment = getParameter("operation-comment");
if (comment && ((comment !== lastOperationComment) || !patternIsActive || insertToolCall)) {
writeln("");
writeComment(comment);
lastOperationComment = comment;
} else if (!patternIsActive || insertToolCall) {
writeln("");
}
} else {
writeln("");
}

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

if (insertToolCall) {
activeCoolants = []; // force coolant on tool change
forceWorkPlane();

retracted = true;
setCoolant(COOLANT_OFF);

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

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

disableLengthCompensation();

writeln("N" + sequenceNumber);
sequenceNumber += properties.sequenceNumberIncrement;

writeBlock("T" + toolFormat.format(tool.number), mFormat.format(6));
if (tool.comment) {
writeComment(tool.comment);
}
var showToolZMin = false;
if (showToolZMin) {
if (is3D()) {
var numberOfSections = getNumberOfSections();
var zRange = currentSection.getGlobalZRange();
var number = tool.number;
for (var i = currentSection.getId() + 1; i < numberOfSections; ++i) {
var section = getSection(i);
if (section.getTool().number != number) {
break;
}
zRange.expandToRange(section.getGlobalZRange());
}
writeComment(localize("ZMIN") + "=" + zRange.getMinimum());
}
}

if (properties.preloadTool) {
var nextTool = getNextTool(tool.number);
if (nextTool) {
writeBlock("T" + toolFormat.format(nextTool.number));
} else {
// preload first tool
var section = getSection(0);
var firstToolNumber = section.getTool().number;
if (tool.number != firstToolNumber) {
writeBlock("T" + toolFormat.format(firstToolNumber));
}
}
}
}

if (!isProbeOperation() &&
(insertToolCall ||
forceSpindleSpeed ||
isFirstSection() ||
(rpmFormat.areDifferent(tool.spindleRPM, sOutput.getCurrent())) ||
(tool.clockwise != getPreviousSection().getTool().clockwise))) {
forceSpindleSpeed = false;

if (tool.spindleRPM < 1) {
error(localize("Spindle speed out of range."));
return;
}
if (tool.spindleRPM > 99999) {
warning(localize("Spindle speed exceeds maximum value."));
}
writeBlock(
sOutput.format(tool.spindleRPM), mFormat.format(tool.clockwise ? 3 : 4)
);

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

// wcs
if (insertToolCall) { // force work offset when changing tool
currentWorkOffset = undefined;
}
var workOffset = currentSection.workOffset;
if (workOffset == 0) {
warningOnce(localize("Work offset has not been specified. Using G54 as WCS."), WARNING_WORK_OFFSET);
workOffset = 1;
}
if (workOffset > 0) {
if (workOffset > 6) {
var p = workOffset - 6; // 1->...
if (p > 300) {
error(localize("Work offset out of range."));
return;
} else {
if (workOffset != currentWorkOffset) {
writeBlock(gFormat.format(54.1), "P" + p); // G54.1P
currentWorkOffset = workOffset;
}
}
} else {
if (workOffset != currentWorkOffset) {
writeBlock(gFormat.format(53 + workOffset)); // G54->G59
currentWorkOffset = workOffset;
}
}
}

forceXYZ();

var abc = defineWorkPlane(currentSection, true);

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

forceXYZ();
gMotionModal.reset();

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

if (insertToolCall || !lengthCompensationActive || retracted || (!isFirstSection() && getPreviousSection().isMultiAxis())) {
var lengthOffset = tool.lengthOffset;
if (lengthOffset > 99) {
error(localize("Length offset out of range."));
return;
}

gMotionModal.reset();
writeBlock(gPlaneModal.format(17));

// cancel compensation prior to enabling it, required when switching G43/G43.4 modes
disableLengthCompensation(false);

// assumes a Head configuration uses TCP on a Fanuc controller
var offsetCode = 43;
if (currentSection.isMultiAxis()) {
if (machineConfiguration.isMultiAxisConfiguration() && (currentSection.getOptimizedTCPMode() == 0)) {
offsetCode = 43.4;
} else if (!machineConfiguration.isMultiAxisConfiguration()) {
offsetCode = 43.5;
}
}

if (!machineConfiguration.isHeadConfiguration()) {
writeBlock(
gAbsIncModal.format(90),
gMotionModal.format(0), xOutput.format(initialPosition.x), yOutput.format(initialPosition.y)
);
writeBlock(
gMotionModal.format(0),
gFormat.format(offsetCode),
zOutput.format(initialPosition.z),
hFormat.format(lengthOffset)
);
lengthCompensationActive = true;
} else {
writeBlock(
gAbsIncModal.format(90),
gMotionModal.format(0),
gFormat.format(offsetCode),
xOutput.format(initialPosition.x),
yOutput.format(initialPosition.y),
zOutput.format(initialPosition.z), hFormat.format(lengthOffset)
);
lengthCompensationActive = true;
}
zIsOutput = true;

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

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

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

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

if (isProbeOperation()) {
if (g68RotationMode != 0) {
error(localize("You cannot probe while G68 Rotation is in effect."));
return;
}
angularProbingMode = getAngularProbingMode();
writeBlock(probeCode.code.format(probeCode.value), "P" + 9832); // spin the probe on
}

// define subprogram
subprogramDefine(initialPosition, abc, retracted, zIsOutput);

retracted = false;
}

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

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

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

function getCommonCycle(x, y, z, r, c) {
forceXYZ(); // force xyz on first drill hole of any cycle
if (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)];
}
}

/** Convert approach to sign. */
function approach(value) {
validate((value == "positive") || (value == "negative"), "Invalid approach.");
return (value == "positive") ? 1 : -1;
}

/**
Determine if angular probing is supported.
*/
function getAngularProbingMode() {
if (machineConfiguration.isMultiAxisConfiguration()) {
if (machineConfiguration.isMachineCoordinate(2)) {
return ANGLE_PROBE_USE_CAXIS;
} else {
return ANGLE_PROBE_NOT_SUPPORTED;
}
} else {
return ANGLE_PROBE_USE_ROTATION;
}
}

/**
Output rotation offset based on angular probing cycle.
*/
function setProbingAngle() {
if ((g68RotationMode == 1) || (g68RotationMode == 2)) { // Rotate coordinate system for Angle Probing
if (!properties.useG54x4) {
gRotationModal.reset();
gAbsIncModal.reset();
writeBlock(
gRotationModal.format(68), gAbsIncModal.format(90),
(g68RotationMode == 1) ? "X0" : "X[#135]",
(g68RotationMode == 1) ? "Y0" : "Y[#136]",
"Z0", "I0.0", "J0.0", "K1.0", "R[#139]"
);
g68RotationMode = 3;
} else if (angularProbingMode != ANGLE_PROBE_NOT_SUPPORTED) {
writeBlock("#26010=#135");
writeBlock("#26011=#136");
writeBlock("#26012=#137");
writeBlock("#26015=#139");
writeBlock(gFormat.format(54.4), "P1");
g68RotationMode = 0;
} else {
error(localize("Angular probing is not supported for this machine configuration."));
return;
}
}
}

function onCyclePoint(x, y, z) {
var probeWorkOffsetCode;
if (isProbeOperation()) {
if (!useMultiAxisFeatures && !isSameDirection(currentSection.workPlane.forward, new Vector(0, 0, 1)) && (!cycle.probeMode || (cycle.probeMode == 0))) {
error(localize("Updating WCS / work offset using probing is only supported by the CNC in the WCS frame."));
return;
}

var workOffset = probeOutputWorkOffset ? probeOutputWorkOffset : currentWorkOffset;
if (workOffset > 99) {
error(localize("Work offset is out of range."));
return;
} else if (workOffset > 6) {
probeWorkOffsetCode = probe100Format.format(workOffset - 6 + 100);
} else {
probeWorkOffsetCode = workOffset + "."; // G54->G59
}
}

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

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

var F = cycle.feedrate;
if (properties.useG95) {
F /= spindleSpeed;
}
var P = (cycle.dwell == 0) ? 0 : clamp(1, cycle.dwell * 1000, 99999999); // in milliseconds

var forceCycle = false;
switch (cycleType) {
case "drilling":
writeBlock(
gRetractModal.format(98), gCycleModal.format(81),
getCommonCycle(x, y, z, cycle.retract, cycle.clearance),
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),
feedOutput.format(F)
);
} else {
writeBlock(
gRetractModal.format(98), gCycleModal.format(81),
getCommonCycle(x, y, z, cycle.retract, cycle.clearance),
feedOutput.format(F)
);
}
break;
case "chip-breaking":
// cycle.accumulatedDepth is ignored
if (P > 0) {
expandCyclePoint(x, y, z);
} else {
writeBlock(
gRetractModal.format(98), gCycleModal.format(73),
getCommonCycle(x, y, z, cycle.retract, cycle.clearance),
"Q" + xyzFormat.format(cycle.incrementalDepth),
feedOutput.format(F)
);
}
break;
case "deep-drilling":
if (P > 0) {
expandCyclePoint(x, y, z);
} else {
writeBlock(
gRetractModal.format(98), gCycleModal.format(83),
getCommonCycle(x, y, z, cycle.retract, cycle.clearance),
"Q" + xyzFormat.format(cycle.incrementalDepth),
// conditional(P > 0, "P" + milliFormat.format(P)),
feedOutput.format(F)
);
}
break;
case "tapping":
writeBlock(mFormat.format(29), sOutput.format(tool.spindleRPM));
if (properties.usePitchForTapping) {
writeBlock(
gRetractModal.format(98), gCycleModal.format((tool.type == TOOL_TAP_LEFT_HAND) ? 74 : 84),
getCommonCycle(x, y, z, cycle.retract, cycle.clearance),
"P" + milliFormat.format(P),
pitchOutput.format(tool.threadPitch)
);
forceFeed();
} else {
writeBlock(
gRetractModal.format(98), gCycleModal.format((tool.type == TOOL_TAP_LEFT_HAND) ? 74 : 84),
getCommonCycle(x, y, z, cycle.retract, cycle.clearance),
"P" + milliFormat.format(P),
feedOutput.format(F)
);
}
break;
case "left-tapping":
writeBlock(mFormat.format(29), sOutput.format(tool.spindleRPM));
if (properties.usePitchForTapping) {
writeBlock(
gRetractModal.format(98), gCycleModal.format(74),
getCommonCycle(x, y, z, cycle.retract, cycle.clearance),
"P" + milliFormat.format(P),
pitchOutput.format(tool.threadPitch)
);
forceFeed();
} else {
writeBlock(
gRetractModal.format(98), gCycleModal.format(74),
getCommonCycle(x, y, z, cycle.retract, cycle.clearance),
"P" + milliFormat.format(P),
feedOutput.format(properties.useG95 ? tool.getTappingFeedrate()/spindleSpeed : tool.getTappingFeedrate())
);
}
break;
case "right-tapping":
writeBlock(mFormat.format(29), sOutput.format(tool.spindleRPM));
if (properties.usePitchForTapping) {
writeBlock(
gRetractModal.format(98), gCycleModal.format(84),
getCommonCycle(x, y, z, cycle.retract, cycle.clearance),
"P" + milliFormat.format(P),
pitchOutput.format(tool.threadPitch)
);
forceFeed();
} else {
writeBlock(
gRetractModal.format(98), gCycleModal.format(84),
getCommonCycle(x, y, z, cycle.retract, cycle.clearance),
"P" + milliFormat.format(P),
feedOutput.format(properties.useG95 ? tool.getTappingFeedrate()/spindleSpeed : tool.getTappingFeedrate())
);
}
break;
case "tapping-with-chip-breaking":
case "left-tapping-with-chip-breaking":
case "right-tapping-with-chip-breaking":
writeBlock(mFormat.format(29), sOutput.format(tool.spindleRPM));
if (properties.usePitchForTapping) {
writeBlock(
gRetractModal.format(98), gCycleModal.format((tool.type == TOOL_TAP_LEFT_HAND ? 74 : 84)),
getCommonCycle(x, y, z, cycle.retract, cycle.clearance),
"P" + milliFormat.format(P),
"Q" + xyzFormat.format(cycle.incrementalDepth),
pitchOutput.format(tool.threadPitch)
);
forceFeed();
} else {
writeBlock(
gRetractModal.format(98), gCycleModal.format((tool.type == TOOL_TAP_LEFT_HAND ? 74 : 84)),
getCommonCycle(x, y, z, cycle.retract, cycle.clearance),
"P" + milliFormat.format(P),
"Q" + xyzFormat.format(cycle.incrementalDepth),
feedOutput.format(properties.useG95 ? tool.getTappingFeedrate()/spindleSpeed : tool.getTappingFeedrate())
);
}
break;
case "fine-boring":
writeBlock(
gRetractModal.format(98), gCycleModal.format(76),
getCommonCycle(x, y, z, cycle.retract, cycle.clearance),
"P" + milliFormat.format(P), // not optional
"Q" + xyzFormat.format(cycle.shift),
feedOutput.format(F)
);
break;
case "back-boring":
var dx = (gPlaneModal.getCurrent() == 19) ? cycle.backBoreDistance : 0;
var dy = (gPlaneModal.getCurrent() == 18) ? cycle.backBoreDistance : 0;
var dz = (gPlaneModal.getCurrent() == 17) ? cycle.backBoreDistance : 0;
writeBlock(
gRetractModal.format(98), gCycleModal.format(87),
getCommonCycle(x - dx, y - dy, z - dz, cycle.bottom, cycle.clearance),
"Q" + xyzFormat.format(cycle.shift),
"P" + milliFormat.format(P), // not optional
feedOutput.format(F)
);
break;
case "reaming":
if (P > 0) {
writeBlock(
gRetractModal.format(98), gCycleModal.format(89),
getCommonCycle(x, y, z, cycle.retract, cycle.clearance),
"P" + milliFormat.format(P),
feedOutput.format(F)
);
} else {
writeBlock(
gRetractModal.format(98), gCycleModal.format(85),
getCommonCycle(x, y, z, cycle.retract, cycle.clearance),
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),
feedOutput.format(F)
);
}
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
feedOutput.format(F)
);
break;
case "boring":
if (P > 0) {
writeBlock(
gRetractModal.format(98), gCycleModal.format(89),
getCommonCycle(x, y, z, cycle.retract, cycle.clearance),
"P" + milliFormat.format(P), // not optional
feedOutput.format(F)
);
} else {
writeBlock(
gRetractModal.format(98), gCycleModal.format(85),
getCommonCycle(x, y, z, cycle.retract, cycle.clearance),
feedOutput.format(F)
);
}
break;
case "probing-x":
forceXYZ();
// move slowly always from clearance not retract
writeBlock(probeCode.code.format(probeCode.value), "P" + 9810, zOutput.format(z - cycle.depth), getFeed(F)); // protected positioning move
writeBlock(
probeCode.code.format(probeCode.value), "P" + 9811,
"X" + xyzFormat.format(x + approach(cycle.approach1) * (cycle.probeClearance + tool.diameter/2)),
"Q" + xyzFormat.format(cycle.probeOvertravel),
"S" + probeWorkOffsetCode // "T" + toolFormat.format(probeToolDiameterOffset)
);
break;
case "probing-y":
forceXYZ();
writeBlock(probeCode.code.format(probeCode.value), "P" + 9810, zOutput.format(z - cycle.depth), getFeed(F)); // protected positioning move
writeBlock(
probeCode.code.format(probeCode.value), "P" + 9811,
"Y" + xyzFormat.format(y + approach(cycle.approach1) * (cycle.probeClearance + tool.diameter/2)),
"Q" + xyzFormat.format(cycle.probeOvertravel),
"S" + probeWorkOffsetCode // "T" + toolFormat.format(probeToolDiameterOffset)
);
break;
case "probing-z":
forceXYZ();
writeBlock(probeCode.code.format(probeCode.value), "P" + 9810, zOutput.format(Math.min(z - cycle.depth + cycle.probeClearance, cycle.retract)), getFeed(F)); // protected positioning move
writeBlock(
probeCode.code.format(probeCode.value), "P" + 9811,
"Z" + xyzFormat.format(z - cycle.depth),
"Q" + xyzFormat.format(cycle.probeOvertravel),
"S" + probeWorkOffsetCode // "T" + toolFormat.format(probeToolLengthOffset)
);
break;
case "probing-x-wall":
writeBlock(probeCode.code.format(probeCode.value), "P" + 9810, zOutput.format(z), getFeed(F)); // protected positioning move
writeBlock(
probeCode.code.format(probeCode.value), "P" + 9812,
"X" + xyzFormat.format(cycle.width1),
zOutput.format(z - cycle.depth),
"Q" + xyzFormat.format(cycle.probeOvertravel),
"R" + xyzFormat.format(cycle.probeClearance),
"S" + probeWorkOffsetCode // "T" + toolFormat.format(probeToolDiameterOffset)
);
break;
case "probing-y-wall":
writeBlock(probeCode.code.format(probeCode.value), "P" + 9810, zOutput.format(z), getFeed(F)); // protected positioning move
writeBlock(
probeCode.code.format(probeCode.value), "P" + 9812,
"Y" + xyzFormat.format(cycle.width1),
zOutput.format(z - cycle.depth),
"Q" + xyzFormat.format(cycle.probeOvertravel),
"R" + xyzFormat.format(cycle.probeClearance),
"S" + probeWorkOffsetCode // "T" + toolFormat.format(probeToolDiameterOffset)
);
break;
case "probing-x-channel":
writeBlock(probeCode.code.format(probeCode.value), "P" + 9810, zOutput.format(z - cycle.depth), getFeed(F)); // protected positioning move
writeBlock(
probeCode.code.format(probeCode.value), "P" + 9812,
"X" + xyzFormat.format(cycle.width1),
"Q" + xyzFormat.format(cycle.probeOvertravel),
// not required "R" + xyzFormat.format(cycle.probeClearance),
"S" + probeWorkOffsetCode // "T" + toolFormat.format(probeToolDiameterOffset)
);
break;
case "probing-x-channel-with-island":
writeBlock(probeCode.code.format(probeCode.value), "P" + 9810, zOutput.format(z), getFeed(F)); // protected positioning move
writeBlock(
probeCode.code.format(probeCode.value), "P" + 9812,
"X" + xyzFormat.format(cycle.width1),
zOutput.format(z - cycle.depth),
"Q" + xyzFormat.format(cycle.probeOvertravel),
"R" + xyzFormat.format(-cycle.probeClearance),
"S" + probeWorkOffsetCode
);
break;
case "probing-y-channel":
yOutput.reset();
writeBlock(probeCode.code.format(probeCode.value), "P" + 9810, zOutput.format(z - cycle.depth), getFeed(F)); // protected positioning move
writeBlock(
probeCode.code.format(probeCode.value), "P" + 9812,
"Y" + xyzFormat.format(cycle.width1),
"Q" + xyzFormat.format(cycle.probeOvertravel),
// not required "R" + xyzFormat.format(cycle.probeClearance),
"S" + probeWorkOffsetCode
);
break;
case "probing-y-channel-with-island":
yOutput.reset();
writeBlock(probeCode.code.format(probeCode.value), "P" + 9810, zOutput.format(z), getFeed(F)); // protected positioning move
writeBlock(
probeCode.code.format(probeCode.value), "P" + 9812,
"Y" + xyzFormat.format(cycle.width1),
zOutput.format(z - cycle.depth),
"Q" + xyzFormat.format(cycle.probeOvertravel),
"R" + xyzFormat.format(-cycle.probeClearance),
"S" + probeWorkOffsetCode
);
break;
case "probing-xy-circular-boss":
writeBlock(probeCode.code.format(probeCode.value), "P" + 9810, zOutput.format(z), getFeed(F)); // protected positioning move
writeBlock(
probeCode.code.format(probeCode.value), "P" + 9814,
"D" + xyzFormat.format(cycle.width1),
"Z" + xyzFormat.format(z - cycle.depth),
"Q" + xyzFormat.format(cycle.probeOvertravel),
"R" + xyzFormat.format(cycle.probeClearance),
"S" + probeWorkOffsetCode
);
break;
case "probing-xy-circular-hole":
writeBlock(probeCode.code.format(probeCode.value), "P" + 9810, zOutput.format(z - cycle.depth), getFeed(F)); // protected positioning move
writeBlock(
probeCode.code.format(probeCode.value), "P" + 9814,
"D" + xyzFormat.format(cycle.width1),
"Q" + xyzFormat.format(cycle.probeOvertravel),
// not required "R" + xyzFormat.format(cycle.probeClearance),
"S" + probeWorkOffsetCode
);
break;
case "probing-xy-circular-hole-with-island":
writeBlock(probeCode.code.format(probeCode.value), "P" + 9810, zOutput.format(z), getFeed(F)); // protected positioning move
writeBlock(
probeCode.code.format(probeCode.value), "P" + 9814,
"Z" + xyzFormat.format(z - cycle.depth),
"D" + xyzFormat.format(cycle.width1),
"Q" + xyzFormat.format(cycle.probeOvertravel),
"R" + xyzFormat.format(-cycle.probeClearance),
"S" + probeWorkOffsetCode
);
break;
case "probing-xy-rectangular-hole":
writeBlock(probeCode.code.format(probeCode.value), "P" + 9810, zOutput.format(z - cycle.depth), getFeed(F)); // protected positioning move
writeBlock(
probeCode.code.format(probeCode.value), "P" + 9812,
"X" + xyzFormat.format(cycle.width1),
"Q" + xyzFormat.format(cycle.probeOvertravel),
// not required "R" + xyzFormat.format(-cycle.probeClearance),
"S" + probeWorkOffsetCode
);
writeBlock(
probeCode.code.format(probeCode.value), "P" + 9812,
"Y" + xyzFormat.format(cycle.width2),
"Q" + xyzFormat.format(cycle.probeOvertravel),
// not required "R" + xyzFormat.format(-cycle.probeClearance),
"S" + probeWorkOffsetCode
);
break;
case "probing-xy-rectangular-boss":
writeBlock(probeCode.code.format(probeCode.value), "P" + 9810, zOutput.format(z), getFeed(F)); // protected positioning move
writeBlock(
probeCode.code.format(probeCode.value), "P" + 9812,
"Z" + xyzFormat.format(z - cycle.depth),
"X" + xyzFormat.format(cycle.width1),
"R" + xyzFormat.format(cycle.probeClearance),
"Q" + xyzFormat.format(cycle.probeOvertravel),
"S" + probeWorkOffsetCode
);
writeBlock(
probeCode.code.format(probeCode.value), "P" + 9812,
"Z" + xyzFormat.format(z - cycle.depth),
"Y" + xyzFormat.format(cycle.width2),
"R" + xyzFormat.format(cycle.probeClearance),
"Q" + xyzFormat.format(cycle.probeOvertravel),
"S" + probeWorkOffsetCode
);
break;
case "probing-xy-rectangular-hole-with-island":
writeBlock(probeCode.code.format(probeCode.value), "P" + 9810, zOutput.format(z), getFeed(F)); // protected positioning move
writeBlock(
probeCode.code.format(probeCode.value), "P" + 9812,
"Z" + xyzFormat.format(z - cycle.depth),
"X" + xyzFormat.format(cycle.width1),
"Q" + xyzFormat.format(cycle.probeOvertravel),
"R" + xyzFormat.format(-cycle.probeClearance),
"S" + probeWorkOffsetCode
);
writeBlock(
probeCode.code.format(probeCode.value), "P" + 9812,
"Z" + xyzFormat.format(z - cycle.depth),
"Y" + xyzFormat.format(cycle.width2),
"Q" + xyzFormat.format(cycle.probeOvertravel),
"R" + xyzFormat.format(-cycle.probeClearance),
"S" + probeWorkOffsetCode
);
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)) {
g68RotationMode = 2;
}
writeBlock(probeCode.code.format(probeCode.value), "P" + 9810, zOutput.format(z - cycle.depth), getFeed(F)); // protected positioning move
writeBlock(
probeCode.code.format(probeCode.value), "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),
conditional((g68RotationMode == 0) || (angularProbingMode == ANGLE_PROBE_USE_CAXIS), "S" + probeWorkOffsetCode)
);
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)) {
g68RotationMode = 2;
}
writeBlock(probeCode.code.format(probeCode.value), "P" + 9810, zOutput.format(z - cycle.depth), getFeed(F)); // protected positioning move
writeBlock(
probeCode.code.format(probeCode.value), "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),
conditional((g68RotationMode == 0) || (angularProbingMode == ANGLE_PROBE_USE_CAXIS), "S" + probeWorkOffsetCode)
);
break;
case "probing-x-plane-angle":
forceXYZ();
writeBlock(probeCode.code.format(probeCode.value), "P" + 9810, zOutput.format(z - cycle.depth), getFeed(F)); // protected positioning move
writeBlock(
probeCode.code.format(probeCode.value), "P" + 9843,
"X" + xyzFormat.format(x + approach(cycle.approach1) * (cycle.probeClearance + tool.diameter/2)),
"D" + xyzFormat.format(cycle.probeSpacing),
"Q" + xyzFormat.format(cycle.probeOvertravel)
);
g68RotationMode = 1;
break;
case "probing-y-plane-angle":
forceXYZ();
writeBlock(probeCode.code.format(probeCode.value), "P" + 9810, zOutput.format(z - cycle.depth), getFeed(F)); // protected positioning move
writeBlock(
probeCode.code.format(probeCode.value), "P" + 9843,
"Y" + xyzFormat.format(y + approach(cycle.approach1) * (cycle.probeClearance + tool.diameter/2)),
"D" + xyzFormat.format(cycle.probeSpacing),
"Q" + xyzFormat.format(cycle.probeOvertravel)
);
g68RotationMode = 1;
break;
default:
expandCyclePoint(x, y, z);
}

// place cycle operation in subprogram
if (cycleSubprogramIsActive) {
if (forceCycle || cycleExpanded || isProbeOperation()) {
cycleSubprogramIsActive = false;
} else {
// call subprogram
writeBlock(mFormat.format(98), "P" + oFormat.format(currentSubprogram));
subprogramStart(new Vector(x, y, z), new Vector(0, 0, 0), false);
}
}

// 2nd through nth cycle point
} else {
if (isProbeOperation()) {
// do nothing
}
if (cycleExpanded) {
expandCyclePoint(x, y, z);
} else {
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 (incrementalMode) {
switch (gPlaneModal.getCurrent()) {
case 17: // XY
zOutput.format(cycle.retract);
break;
case 18: // ZX
yOutput.format(cycle.retract);
break;
case 19: // YZ
xOutput.format(cycle.retract);
break;
}
}
writeBlock(xOutput.format(x), yOutput.format(y));
}
}
}

function onCycleEnd() {
if (isProbeOperation()) {
writeBlock(probeCode.code.format(probeCode.value), "P" + 9810, zOutput.format(cycle.clearance)); // protected retract move
writeBlock(probeCode.code.format(probeCode.value), "P" + 9833); // spin the probe off
setProbingAngle(); // define rotation of part
// we can move in rapid from retract optionally
} else {
if (cycleSubprogramIsActive) {
subprogramEnd();
cycleSubprogramIsActive = false;
}
if (!cycleExpanded) {
writeBlock(gCycleModal.format(80));
zOutput.reset();
}
}
}

var pendingRadiusCompensation = -1;

function onRadiusCompensation() {
pendingRadiusCompensation = radiusCompensation;
}

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

function onLinear(_x, _y, _z, feed) {
var x = xOutput.format(_x);
var y = yOutput.format(_y);
var z = zOutput.format(_z);
var f = getFeed(feed);
if (x || y || z) {
if (pendingRadiusCompensation >= 0) {
pendingRadiusCompensation = -1;
var d = tool.diameterOffset;
if (d > 99) {
warning(localize("The diameter offset exceeds the maximum value."));
}
writeBlock(gPlaneModal.format(17));
switch (radiusCompensation) {
case RADIUS_COMPENSATION_LEFT:
dOutput.reset();
writeBlock(gMotionModal.format(1), gFormat.format(41), x, y, z, dOutput.format(d), f);
break;
case RADIUS_COMPENSATION_RIGHT:
dOutput.reset();
writeBlock(gMotionModal.format(1), gFormat.format(42), x, y, z, dOutput.format(d), f);
break;
default:
writeBlock(gMotionModal.format(1), gFormat.format(40), x, y, z, f);
}
} else {
writeBlock(gMotionModal.format(1), x, y, z, f);
}
} else if (f) {
if (getNextRecord().isMotion()) { // try not to output feed without motion
forceFeed(); // force feed on next line
} else {
writeBlock(gMotionModal.format(1), f);
}
}
}

/*
function onRewindMachine() {
}
*/

/** Calculate angles on rotary scale with signed direction. */
function getDirectionalABC(_startAngle, _endAngle, _output) {
var signedAngle = _endAngle;

// linear scale or unsigned angles are output
if (!useRotaryScale || !useRotarySign) {
return signedAngle;
}

// angles are the same, set the previous output angle to the current angle so it is not output
if (!abcFormat.areDifferent(_startAngle, _endAngle)) {
_output.format(_startAngle);
}
// calculate the correct direction (sign) based on CLW/CCW direction
var delta = abcFormat.getResultingValue(_endAngle - _startAngle);
if (((delta < 0) && (delta > -180.0)) || (delta > 180.0)) {
if (_endAngle == 0) {
signedAngle = -Math.PI*2;
} else {
signedAngle = -_endAngle;
}
}
return signedAngle;
}

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 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(getDirectionalABC(previousABC.z, _c, cOutput));
if (x || y || z || a || b || c) {
writeBlock(gMotionModal.format(0), x, y, z, a, b, c);
forceFeed();
}
previousABC = new Vector(_a, _b, _c);
}

function onLinear5D(_x, _y, _z, _a, _b, _c, feed) {
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 cannot be activated/deactivated for 5-axis move."));
return;
}

var x = xOutput.format(_x);
var y = yOutput.format(_y);
var z = zOutput.format(_z);
var a = aOutput.format(_a);
var b = bOutput.format(_b);
var c = cOutput.format(getDirectionalABC(previousABC.z, _c, cOutput));
var f = getFeed(feed);
if (x || y || z || a || b || c) {
writeBlock(gMotionModal.format(1), x, y, z, a, b, c, f);
} else if (f) {
if (getNextRecord().isMotion()) { // try not to output feed without motion
forceFeed(); // force feed on next line
} else {
writeBlock(gMotionModal.format(1), f);
}
}
previousABC = new Vector(_a, _b, _c);
}

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

var start = getCurrentPosition();

if (isFullCircle()) {
if (properties.useRadius || isHelical()) { // radius mode does not support full arcs
linearize(tolerance);
return;
}
switch (getCircularPlane()) {
case PLANE_XY:
writeBlock(gPlaneModal.format(17), gMotionModal.format(clockwise ? 2 : 3), iOutput.format(cx - start.x, 0), jOutput.format(cy - start.y, 0), getFeed(feed));
break;
case PLANE_ZX:
writeBlock(gPlaneModal.format(18), gMotionModal.format(clockwise ? 2 : 3), iOutput.format(cx - start.x, 0), kOutput.format(cz - start.z, 0), getFeed(feed));
break;
case PLANE_YZ:
writeBlock(gPlaneModal.format(19), gMotionModal.format(clockwise ? 2 : 3), jOutput.format(cy - start.y, 0), kOutput.format(cz - start.z, 0), getFeed(feed));
break;
default:
linearize(tolerance);
}
} else if (!properties.useRadius) {
switch (getCircularPlane()) {
case PLANE_XY:
writeBlock(gPlaneModal.format(17), gMotionModal.format(clockwise ? 2 : 3), xOutput.format(x), yOutput.format(y), zOutput.format(z), iOutput.format(cx - start.x, 0), jOutput.format(cy - start.y, 0), getFeed(feed));
break;
case PLANE_ZX:
writeBlock(gPlaneModal.format(18), gMotionModal.format(clockwise ? 2 : 3), xOutput.format(x), yOutput.format(y), zOutput.format(z), iOutput.format(cx - start.x, 0), kOutput.format(cz - start.z, 0), getFeed(feed));
break;
case PLANE_YZ:
writeBlock(gPlaneModal.format(19), gMotionModal.format(clockwise ? 2 : 3), xOutput.format(x), yOutput.format(y), zOutput.format(z), jOutput.format(cy - start.y, 0), kOutput.format(cz - start.z, 0), getFeed(feed));
break;
default:
if (properties.allow3DArcs) {
// make sure maximumCircularSweep is well below 360deg
// we could use G02.4 or G03.4 - direction is calculated
var ip = getPositionU(0.5);
writeBlock(gMotionModal.format(clockwise ? 2.4 : 3.4), xOutput.format(ip.x), yOutput.format(ip.y), zOutput.format(ip.z), getFeed(feed));
writeBlock(xOutput.format(x), yOutput.format(y), zOutput.format(z));
} else {
linearize(tolerance);
}
}
} else { // use radius mode
var r = getCircularRadius();
if (toDeg(getCircularSweep()) > (180 + 1e-9)) {
r = -r; // allow up to <360 deg arcs
}
switch (getCircularPlane()) {
case PLANE_XY:
writeBlock(gPlaneModal.format(17), gMotionModal.format(clockwise ? 2 : 3), xOutput.format(x), yOutput.format(y), zOutput.format(z), "R" + rFormat.format(r), getFeed(feed));
break;
case PLANE_ZX:
writeBlock(gPlaneModal.format(18), gMotionModal.format(clockwise ? 2 : 3), xOutput.format(x), yOutput.format(y), zOutput.format(z), "R" + rFormat.format(r), getFeed(feed));
break;
case PLANE_YZ:
writeBlock(gPlaneModal.format(19), gMotionModal.format(clockwise ? 2 : 3), xOutput.format(x), yOutput.format(y), zOutput.format(z), "R" + rFormat.format(r), getFeed(feed));
break;
default:
if (properties.allow3DArcs) {
// make sure maximumCircularSweep is well below 360deg
// we could use G02.4 or G03.4 - direction is calculated
var ip = getPositionU(0.5);
writeBlock(gMotionModal.format(clockwise ? 2.4 : 3.4), xOutput.format(ip.x), yOutput.format(ip.y), zOutput.format(ip.z), getFeed(feed));
writeBlock(xOutput.format(x), yOutput.format(y), zOutput.format(z));
} else {
linearize(tolerance);
}
}
}
}

var currentCoolantMode = COOLANT_OFF;
var coolantOff = undefined;

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

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

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

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

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

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

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

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

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

var mapCommand = {
COMMAND_STOP:0,
COMMAND_OPTIONAL_STOP:1,
COMMAND_END:2,
COMMAND_SPINDLE_CLOCKWISE:3,
COMMAND_SPINDLE_COUNTERCLOCKWISE:4,
COMMAND_STOP_SPINDLE:5,
COMMAND_ORIENTATE_SPINDLE:19
};

function onCommand(command) {
switch (command) {
case COMMAND_STOP:
writeBlock(mFormat.format(0));
forceSpindleSpeed = true;
return;
case COMMAND_START_SPINDLE:
onCommand(tool.clockwise ? COMMAND_SPINDLE_CLOCKWISE : COMMAND_SPINDLE_COUNTERCLOCKWISE);
return;
case COMMAND_LOCK_MULTI_AXIS:
return;
case COMMAND_UNLOCK_MULTI_AXIS:
return;
case COMMAND_START_CHIP_TRANSPORT:
return;
case COMMAND_STOP_CHIP_TRANSPORT:
return;
case COMMAND_BREAK_CONTROL:
return;
case COMMAND_TOOL_MEASURE:
return;
}

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

function onSectionEnd() {
writeBlock(gPlaneModal.format(17));

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

if (true) {
if (isRedirecting()) {
if (firstPattern) {
var finalPosition = getFramePosition(currentSection.getFinalPosition());
var abc;
if (currentSection.isMultiAxis() && machineConfiguration.isMultiAxisConfiguration()) {
abc = currentSection.getFinalToolAxisABC();
} else {
abc = currentWorkPlaneABC;
}
if (abc == undefined) {
abc = new Vector(0, 0, 0);
}
setAbsoluteMode(finalPosition, abc);
subprogramEnd();
}
}
}

forceAny();
}

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

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

setCoolant(COOLANT_OFF);

writeRetract(Z);
retracted = true;

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

setWorkPlane(new Vector(0, 0, 0)); // reset working plane
writeBlock(gRotationModal.format(69));

writeRetract(X, Y);

onImpliedCommand(COMMAND_END);
onImpliedCommand(COMMAND_STOP_SPINDLE);
writeBlock(mFormat.format(30)); // stop program, spindle stop, coolant off
if (subprograms.length > 0) {
writeln("");
write(subprograms);
}
writeln("");
writeln("N" + Math.max(sequenceNumber, 9999));
writeln("");

writeln("%");
}

МОЖЕТ ВОТ ЭТОТ ПОДОЙДЕТ

В 05.05.2018 в 01:37, OOO сказал:

К сожалению там FANUC вдоль и поперек перекопанный производителем. + пять осей. Программа клевая и простая. А найти кто может подправить стандартный пост Fanuka не представляется возможным. Написали мне пост для PowerMill. Но теряется связка SolidWorks + HSM. А у меня на ней остальное оборудование, плюс минусы в конвертации моделей и т.д.

6 мая 2018

Это с библиотеки? Более подходящий что самое интересное оказалось обычный стандартный. Но после немного править приходится руками. Я больше механик, а написание УП просто сейчас необходимость. Этот более похож https://cam.autodesk.com/hsmposts?p=cr_onsrud_fanuc_31i но не работает в 3+2, и что самое интересное сравнивая УП не могу понять почему. Да и ладно... Думаю переходить на "солидкам" инфы больше, да и народ в нем лучше шарит судя по всему. ТОЛЬКО С ВРЕМЕНЕМ запара. Учится не успеваешь. :doh: , а работать нужно. В любом случае огромное СПАСИБО!

Изменено 6 мая 2018 пользователем OOO

7 мая 2018

Пример УП скинь.

7 мая 2018

Есть еще HAAS 5-ти координатный. Может он подойдет (haas umc-750).

Скрытый текст

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

HAAS post processor configuration.

$Revision: 41922 0119322ab50e0f9936c359de1f44723c085fe0c8 $
$Date: 2018-04-03 15:36:48 $

FORKID {CB31A24D-E8A4-4743-99C1-AE2F2C024C37}
*/

description = "HAAS UMC-750";
vendor = "Haas Automation";
vendorUrl = "https://www.haascnc.com";
legal = "Copyright (C) 2012-2018 by Autodesk, Inc.";
certificationLevel = 2;
minimumRevision = 24000;

longDescription = "Generic post for the HAAS UMC-750. 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. By default positioning moves will be output as high feed G1s instead of G0s. You can turn on the property 'useG0' to force G0s but be careful as the CNC will follow a dogleg path rather than a direct path.";

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

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

minimumChordLength = spatial(0.01, MM);
minimumCircularRadius = spatial(0.01, MM);
maximumCircularRadius = spatial(1000, MM);
minimumCircularSweep = toRad(0.01);
maximumCircularSweep = toRad(355);
allowHelicalMoves = true;
allowedCircularPlanes = undefined; // allow any circular motion
allowSpiralMoves = true;
highFeedrate = (unit == IN) ? 650 : 5000; // up to 650 should be supported

// user-defined properties
properties = {
writeMachine: true, // write machine
writeTools: true, // writes the tools
writeVersion: false, // include version info
preloadTool: true, // preloads next tool on tool change if any
chipTransport: false, // turn on chip transport at start of program
showSequenceNumbers: true, // show sequence numbers
sequenceNumberStart: 10, // first sequence number
sequenceNumberIncrement: 5, // increment for sequence numbers
sequenceNumberOnlyOnToolChange: false, // only output sequence numbers on tool change
optionalStop: true, // optional stop
separateWordsWithSpace: true, // specifies that the words should be separated with a white space
useRadius: false, // specifies that arcs should be output using the radius (R word) instead of the I, J, and K words.
useParametricFeed: false, // specifies that feed should be output using Q values
showNotes: false, // specifies that operation notes should be output
useG0: false, // allow G0 when moving along more than one axis
useG28: false, // specifies that G28 should be used instead of G53
useSubroutines: false, // specifies that subroutines per each operation should be generated
useSubroutinePatterns: false, // generates subroutines for patterned operation
useSubroutineCycles: false, // generates subroutines for cycle operations on same holes
useG187: false, // use G187 to set smoothing on the machine
useG73Retract: false, // use G73 Q K format for accumulated depth support
useMaximumMachineZRetract: false, // enable to use the maximum machine Z for retracts instead of G53 Z0
forceHomeOnIndexing: true, // force home position on indexing
optionallyCycleToolsAtStart: false, // cycle through each tool used at the beginning of the program when block delete is turned off - this allows the operator to easily measure all tools before they are used for the first run of the program
optionallyMeasureToolsAtStart: false, // measure each tool used at the beginning of the program when block delete is turned off - this allows the operator to easily measure all tools before they are used for the first run of the program
toolBreakageTolerance: 0.1, // value for which tool break detection will raise an alarm
safeRetractDistance: 0.0, // distance to add to retract distance when rewinding rotary axes
rewindCAxisEncoder: false // resets the C-axis encoder instead of rewinding axis, Setting 108 must be set to true and Parameter 498 bit 10 to 1
};

propertyDefinitions = {
writeMachine: {title:"Write machine", description:"Output the machine settings in the header of the code.", group:0, type:"boolean"},
writeTools: {title:"Write tool list", description:"Output a tool list in the header of the code.", group:0, type:"boolean"},
writeVersion: {title:"Write version", description:"Write the version number in the header of the code.", group:0, type:"boolean"},
preloadTool: {title:"Preload tool", description:"Preloads the next tool at a tool change (if any).", type:"boolean"},
chipTransport: {title:"Use chip transport", description:"Enable to turn on chip transport at start of program.", type:"boolean"},
showSequenceNumbers: {title:"Use sequence numbers", description:"Use sequence numbers for each block of outputted code.", group:1, type:"boolean"},
sequenceNumberStart: {title:"Start sequence number", description:"The number at which to start the sequence numbers.", group:1, type:"integer"},
sequenceNumberIncrement: {title:"Sequence number increment", description:"The amount by which the sequence number is incremented by in each block.", group:1, type:"integer"},
sequenceNumberOnlyOnToolChange: {title:"Block number only on tool change", description:"Specifies that block numbers should only be output at tool changes.", type:"boolean"},
optionalStop: {title:"Optional stop", description:"Specifies that optional stops M1 should be output at tool changes.", type:"boolean"},
separateWordsWithSpace: {title:"Separate words with space", description:"Adds spaces between words if 'yes' is selected.", type:"boolean"},
useRadius: {title:"Radius arcs", description:"If yes is selected, arcs are output using radius values rather than IJK.", type:"boolean"},
useParametricFeed: {title:"Parametric feed", description:"Parametric feed values based on movement type are output.", type:"boolean"},
showNotes: {title:"Show notes", description:"Enable to output notes for operations.", type:"boolean"},
useG0: {title:"Use G0", description:"Specifies that G0s should be used for rapid moves when moving along a single axis.", type:"boolean"},
useG28: {title:"Use G28 instead of G53", description:"Specifies that machine retracts should be done using G28 instead of G53.", type:"boolean"},
useSubroutines: {title:"Use subroutines", description:"Enables output of subroutines for each operation.", type:"boolean"},
useSubroutinePatterns: {title:"Subroutines for patterns", description:"Enable output of subroutines for patterns.", type:"boolean"},
useSubroutineCycles: {title:"Subroutines for cycles", description:"Enable output of subroutines for cycles.", type:"boolean"},
useG187: {title:"Use G187", description:"Specifies that smoothing using G187 should be used.", type:"boolean"},
useG73Retract: {title:"G73 cycles include accumulated depth", description:"Use G73 Q K format for accumulated depth support.", type:"boolean"},
useMaximumMachineZRetract: {title:"Retract to maximum Z", description:"Enable to use the maximum machine Z for retracts instead of G53 Z0.", type:"boolean"},
forceHomeOnIndexing: {title:"Force home position on indexing", description:"Force home position on multi-axis indexing.", type:"boolean"},
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.", type:"boolean"},
optionallyMeasureToolsAtStart: {title:"Optionally measure tools at start", description:"Measure each tool used at the beginning of the program when block delete is turned off.", type:"boolean"},
toolBreakageTolerance: {title:"Tool breakage tolerance", description:"Specifies the tolerance for which tool break detection will raise an alarm.", type:"spatial"},
safeRetractDistance: {title:"Safe retract distance", description:"Specifies the distance to add to retract distance when rewinding rotary axes.", type:"spatial"},
rewindCAxisEncoder: {title:"Rewind C-axis encoder", description:"Resets the C-axis encoder instead of rewinding axis, Setting 108 must be set to true and Parameter 498 bit 10 to 1.", type:"boolean"}
};

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

// old machines only support 4 digits
var oFormat = createFormat({width:5, zeropad:true, decimals:0});

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

// fixed settings
var firstFeedParameter = 100; // the first variable to use with parametric feed
var useDynamicWorkOffset = true; // Dynamic Work Offset (DWO), only supported on UMC-750 - like CYCL 19
var forceResetWorkPlane = false; // enable to force reset of machine ABC on new orientation
var minimumCyclePoints = 5; // minimum number of points in cycle operation to consider for subprogram

var WARNING_WORK_OFFSET = 0;

var ANGLE_PROBE_NOT_SUPPORTED = 0;
var ANGLE_PROBE_USE_ROTATION = 1;
var ANGLE_PROBE_USE_CAXIS = 2;

var SUB_UNKNOWN = 0;
var SUB_PATTERN = 1;
var SUB_CYCLE = 2;

// collected state
var sequenceNumber;
var currentWorkOffset;
var optionalSection = false;
var forceSpindleSpeed = false;
var activeMovements; // do not use by default
var currentFeedId;
var maximumCircularRadiiDifference = toPreciseUnit(0.005, MM);
var maximumLineLength = 80; // the maximum number of charaters allowed in a line
var g68RotationMode = 0;
var angularProbingMode;
var subprograms = [];
var currentPattern = -1;
var firstPattern = false;
var currentSubprogram;
var lastSubprogram;
var definedPatterns = new Array();
var incrementalMode = false;
var saveShowSequenceNumbers;
var cycleSubprogramIsActive = false;
var patternIsActive = false;
var lastOperationComment = "";
var retracted = false; // specifies that the tool has been retracted to the safe plane

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

/**
Writes the specified block - used for tool changes only.
*/
function writeToolBlock() {
if (properties.showSequenceNumbers) {
if (sequenceNumber > 99999) {
sequenceNumber = properties.sequenceNumberStart;
}
writeWords2("N" + sequenceNumber, arguments);
sequenceNumber += properties.sequenceNumberIncrement;
} else {
writeWords(arguments);
}
}

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

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

/**
Output a comment.
*/
function writeComment(text) {
writeln(formatComment(text.substr(0, maximumLineLength - 2)));
}

/**
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) {
writeOptionalBlock("T" + toolFormat.format(tool.number), mFormat.format(6)); // get tool
writeOptionalBlock(mFormat.format(0)); // wait for operator
}

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

gRotationModal.format(69); // Default to G69 Rotation Off

if (true) { // UMC-750
// using 0 instead of -35 to avoid rewind issues
var bAxis = createAxis({coordinate:1, table:true, axis:[0, 1, 0], range:[0-0.0001, 110+0.0001], preference:1});
// should be multiple of 360 if rewindCAxisEncoder is enabled
var cAxis = createAxis({coordinate:2, table:true, axis:[0, 0, 1], cyclic:false, range:[-13320, 13320], preference:0});
machineConfiguration = new MachineConfiguration(bAxis, cAxis);

machineConfiguration.setModel("HAAS UMC-750");
machineConfiguration.setVendor("Haas Automation");
machineConfiguration.setHomePositionX(toPreciseUnit(-29.0, IN));
machineConfiguration.setHomePositionY(toPreciseUnit(-8, IN));
if (properties.useMaximumMachineZRetract) {
machineConfiguration.setRetractPlane(toPreciseUnit(2.5, IN));
}

setMachineConfiguration(machineConfiguration);
optimizeMachineAngles2(0); // map tip mode
}

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

if (highFeedrate <= 0) {
error(localize("You must set 'highFeedrate' because axes are not synchronized for rapid traversal."));
return;
}

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

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

if (programName) {
var programId;
try {
programId = getAsInt(programName);
} catch(e) {
error(localize("Program name must be a number."));
return;
}
if (!((programId >= 1) && (programId <= 99999))) {
error(localize("Program number is out of range."));
return;
}
writeln(
"O" + oFormat.format(programId) +
conditional(programComment, " " + formatComment(programComment.substr(0, maximumLineLength - 2 - ("O" + oFormat.format(programId)).length - 1)))
);
lastSubprogram = programId;
} else {
error(localize("Program name has not been specified."));
return;
}

if (properties.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 (properties.writeVersion) {
if ((typeof getHeaderVersion == "function") && getHeaderVersion()) {
writeComment(localize("post version") + ": " + getHeaderVersion());
}
if ((typeof getHeaderDate == "function") && getHeaderDate()) {
writeComment(localize("post modified") + ": " + getHeaderDate());
}
}

// dump machine configuration
var vendor = machineConfiguration.getVendor();
var model = machineConfiguration.getModel();
var description = machineConfiguration.getDescription();

if (properties.writeMachine && (vendor || model || description)) {
writeComment(localize("Machine"));
if (vendor) {
writeComment(" " + localize("vendor") + ": " + vendor);
}
if (model) {
writeComment(" " + localize("model") + ": " + model);
}
if (description) {
writeComment(" " + localize("description") + ": " + description);
}
}

// dump tool information
if (properties.writeTools) {
var zRanges = {};
if (is3D()) {
var numberOfSections = getNumberOfSections();
for (var i = 0; i < numberOfSections; ++i) {
var section = getSection(i);
var zRange = section.getGlobalZRange();
var tool = section.getTool();
if (zRanges[tool.number]) {
zRanges[tool.number].expandToRange(zRange);
} else {
zRanges[tool.number] = zRange;
}
}
}

// optionally cycle through all tools
if (properties.optionallyCycleToolsAtStart || properties.optionallyMeasureToolsAtStart) {
var tools = getToolTable();
if (tools.getNumberOfTools() > 0) {
writeln("");
if (properties.optionallyMeasureToolsAtStart) {
writeComment(localize("Measure tools used"));
} else {
writeComment(localize("Cycle through tools used"));
}
for (var i = 0; i < tools.getNumberOfTools(); ++i) {
var tool = tools.getTool(i);
if (properties.optionallyMeasureToolsAtStart && (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 (properties.optionallyMeasureToolsAtStart) {
writeToolMeasureBlock(tool);
} else {
writeToolCycleBlock(tool);
}
}
}
writeln("");
}

if (false /*properties.useDynamicWorkOffset*/) {
var failed = false;
var dynamicWCSs = {};
for (var i = 0; i < getNumberOfSections(); ++i) {
var section = getSection(i);
var description = section.hasParameter("operation-comment") ? section.getParameter("operation-comment") : ("#" + (i + 1));
if (!section.hasDynamicWorkOffset()) {
error(subst(localize("Dynamic work offset has not been set for operation '%1'."), description));
failed = true;
}

var o = section.getDynamicWCSOrigin();
var p = section.getDynamicWCSPlane();
if (dynamicWCSs[section.getDynamicWorkOffset()]) {
if ((Vector.diff(o, dynamicWCSs[section.getDynamicWorkOffset()].origin).length > 1e-9) ||
(Matrix.diff(p, dynamicWCSs[section.getDynamicWorkOffset()].plane).n1 > 1e-9)) {
error(subst(localize("Dynamic WCS mismatch for operation '%1'."), description));
failed = true;
}
} else {
dynamicWCSs[section.getDynamicWorkOffset()] = {origin:o, plane:p};
}
}
if (failed) {
return;
}
}

if (false) {
// check for duplicate tool number
for (var i = 0; i < getNumberOfSections(); ++i) {
var sectioni = getSection(i);
var tooli = sectioni.getTool();
for (var j = i + 1; j < getNumberOfSections(); ++j) {
var sectionj = getSection(j);
var toolj = sectionj.getTool();
if (tooli.number == toolj.number) {
if (xyzFormat.areDifferent(tooli.diameter, toolj.diameter) ||
xyzFormat.areDifferent(tooli.cornerRadius, toolj.cornerRadius) ||
abcFormat.areDifferent(tooli.taperAngle, toolj.taperAngle) ||
(tooli.numberOfFlutes != toolj.numberOfFlutes)) {
error(
subst(
localize("Using the same tool number for different cutter geometry for operation '%1' and '%2'."),
sectioni.hasParameter("operation-comment") ? sectioni.getParameter("operation-comment") : ("#" + (i + 1)),
sectionj.hasParameter("operation-comment") ? sectionj.getParameter("operation-comment") : ("#" + (j + 1))
)
);
return;
}
}
}
}
}

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

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

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

if (properties.chipTransport) {
onCommand(COMMAND_START_CHIP_TRANSPORT);
}
}

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

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

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

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

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

var workMode;
if (((stockToLeave > stockToLeaveThreshold) && (verticalStockToLeave > stockToLeaveThreshold)) ||
(hasParameter("operation:strategy") && getParameter("operation:strategy") == "face")) {
workMode = 1; // roughing
} else {
if ((stockToLeave != 0) || (verticalStockToLeave != 0)) {
workMode = 2; // default
} else {
workMode = 3; // fine
}
}
writeBlock(gFormat.format(187), "P" + workMode); // set tolerance mode
// writeBlock(gFormat.format(187), "P" + workMode, "E" + xyzFormat.format(tolerance)); // set tolerance mode
} else {
writeBlock(gFormat.format(187)); // reset G187 setting to machine default
}
} else {
writeBlock(gFormat.format(187)); // reset G187 setting to machine default
}
}

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

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

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

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

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

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

var currentWorkPlaneABC = undefined;
var activeG254 = false;

function forceWorkPlane() {
currentWorkPlaneABC = undefined;
}

function defineWorkPlane(_section, _setWorkPlane) {
var abc = new Vector(0, 0, 0);
if (machineConfiguration.isMultiAxisConfiguration()) { // use 5-axis indexing for multi-axis mode
// set working plane after datum shift

if (_section.isMultiAxis()) {
cancelTransformation();
abc = _section.getInitialToolAxisABC();
if (_setWorkPlane) {
if (activeG254) {
writeBlock(gFormat.format(255)); // cancel DWO
activeG254 = false;
}
forceWorkPlane();
onCommand(COMMAND_UNLOCK_MULTI_AXIS);
gMotionModal.reset();
writeBlock(
gMotionModal.format(0),
conditional(machineConfiguration.isMachineCoordinate(0), "A" + abcFormat.format(abc.x)),
conditional(machineConfiguration.isMachineCoordinate(1), "B" + abcFormat.format(abc.y)),
conditional(machineConfiguration.isMachineCoordinate(2), "C" + abcFormat.format(abc.z))
);
}
} else {
abc = getWorkPlaneMachineABC(_section.workPlane, _setWorkPlane);
if (_setWorkPlane) {
setWorkPlane(abc);
}
}
} else { // pure 3D
var remaining = _section.workPlane;
if (!isSameDirection(remaining.forward, new Vector(0, 0, 1))) {
error(localize("Tool orientation is not supported."));
return abc;
}
setRotation(remaining);
}
return abc;
}

function setWorkPlane(abc) {
if (!machineConfiguration.isMultiAxisConfiguration()) {
return; // ignore
}

if (!((currentWorkPlaneABC == undefined) ||
abcFormat.areDifferent(abc.x, currentWorkPlaneABC.x) ||
abcFormat.areDifferent(abc.y, currentWorkPlaneABC.y) ||
abcFormat.areDifferent(abc.z, currentWorkPlaneABC.z))) {
return; // no change
}

// onCommand(COMMAND_UNLOCK_MULTI_AXIS);

if (activeG254) {
writeBlock(gFormat.format(255)); // cancel DWO
activeG254 = false;
}

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

// onCommand(COMMAND_LOCK_MULTI_AXIS);

if (useDynamicWorkOffset &&
(abcFormat.isSignificant(abc.x) || abcFormat.isSignificant(abc.y) || abcFormat.isSignificant(abc.z))) {
writeBlock(gFormat.format(254)); // enable DWO
activeG254 = true;
}