Замкнутый WHILE-цикл на Fanuc: фрезеровка пазов без раздува кода

[kirilljsx]

Кто-нибудь писал параметрические программы для фрезеровки пазов на Fanuc и упирался в одну беду - код растёт как на дрожжах? Один паз, второй, третий - и вот уже сотка строк, половина из которых одно и то же. Есть способ изящнее: замкнутый WHILE-цикл, который зациклит обработку нужное количество раз, контролируя координаты через переменные. Результат - компактная программа, которая легко масштабируется под любые размеры, и не нужно каждый раз переписывать всё с нуля.

Зачем вообще нужны переменные в Fanuc

Фанук поддерживает параметрическое программирование - это значит, что ты можешь забить все ключевые размеры в переменные и дальше оперировать ими как угодно. Вместо того чтобы прописывать каждую координату вручную, ты задаёшь параметры один раз: длину паза, ширину, глубину, подачу - и циклишь обработку. Переменные в Fanuc обозначаются как #1, #2, #3 и так далее. Локальные переменные (#1-#33) хранят значения внутри одной программы, глобальные (#100-#199) живут дольше и доступны между подпрограммами.

Преимущество очевидно: если завтра техдолг скажет, что паз надо сделать на 10 миллиметров глубже - ты меняешь одну строку, а не переписываешь полпрограммы. Плюс ошибок меньше, потому что логика просчитана один раз в коде, а не вбита вручную в каждый блок.

WHILE-цикл: суть и отличие от L-параметра

В старых управляющих программах часто использовали L-параметр в циклах сверления (G81, G83 и прочих) - он задавал количество повторений. Но это работает только внутри стандартного цикла и только для простых операций. Если тебе нужно зациклить произвольную последовательность команд с контролем переменных - L-параметра недостаточно.

Отсюда появилась конструкция WHILE-END - полноценный цикл, который проверяет условие перед каждой итерацией. Синтаксис прост: ты пишешь WHILE[условие] DO (номер цикла), потом блок команд, потом END (номер). Пока условие истинно, цикл крутится. Условия могут быть разными: LT (меньше), GT (больше), EQ (равно), GE (больше либо равно) и так далее. Фанук проверяет условие перед каждым повтором, и если оно ложно - прыгает на команду после END.

Это даёт полную свободу: ты можешь внутри цикла менять как координаты, так и подачу, глубину, даже инструмент. Логика программы становится гораздо гибче, чем с обычными циклами.

Структура параметрического цикла фрезеровки паза

Давайте разберём на конкретике. Допустим, нужно нафрезеровать прямоугольный паз размером 50x30 миллиметров, глубиной 5 миллиметров. Паз будет обработан слоями: сначала снимешь слой в 2 миллиметра, потом ещё 2, потом финишная подача на остаток. Вместо того чтобы писать три одинаковых блока команд, зацикливаешь через WHILE.

Вот логика, которая сработает:

1. Задаёшь начальные параметры: координаты начала, размеры паза, глубину, шаг по Z.
2. Инициализируешь счётчик слоёв - это обычная переменная, например #10.
3. Пишешь условие: пока текущая глубина (#10) меньше чем целевая глубина (#3) - выполняй цикл.
4. Внутри цикла: две подводки по X (слева и справа), две подводки по Y (спереди и сзади), каждая на текущую глубину из #10.
5. После каждого прохода увеличиваешь #10 на шаг подачи по глубине.
6. Цикл автоматически выйдет, когда #10 достигнет или превысит целевую глубину.

Результат: паз обработан слоями без дублирования кода, логика видна сразу, легко менять стратегию.

Рабочий пример кода

Вот что это выглядит в реальном Fanuc коде:

O1234
G21
G90
G54

#1 = 50    ; Длина паза
#2 = 30    ; Ширина паза
#3 = -5    ; Целевая глубина (минус, потому что вниз)
#4 = 2     ; Шаг по глубине за один проход
#5 = 5     ; Боковой припуск (от краёв)
#10 = 0    ; Счётчик текущей глубины

G0 Z100
T01 M06
G0 X0 Y0
S1200 M03
G43 H01 Z5

; Основной цикл фрезеровки
WHILE[#10 GT #3] DO1
  #10 = [#10 - #4]  ; Идём глубже на один шаг
  
  ; Проход вдоль длины паза
  G1 Z#10 F50
  G1 X[#1 - #5] F100
  G1 X#5
  
  ; Проход вдоль ширины паза
  G1 Y[#2 - #5] F100
  G1 Y#5
  
  G0 Z5  ; Рапид на безопасную высоту
END1

; Финиш
G0 Z100
M05
M30

Что здесь происходит:

• #10 = 0 - стартуем с поверхности.
• WHILE[#10 GT #3] - пока текущая глубина больше целевой (помнишь, целевая отрицательная -5), крутимся.
• #10 = [#10 - #4] - на каждой итерации идём глубже на #4 (2 миллиметра).
• Внутри цикла - четыре движения по периметру паза на текущей глубине.
• G0 Z5 - после каждого проохода рапидом поднимаемся на безопасную высоту.
• Когда #10 станет -5 или меньше (например -6), условие ложно - выходим из цикла.

Итог: паз обработан в три слоя (0 → -2 → -4 → -6, но финальный проход вылезет за границу на 1 миллиметр - это нормально, финиш возьмёт). Код - 30 строк вместо 100.

Контроль координат: как не потеряться в переменных

Когда переменных становится много, легко запутаться. Поэтому стоит сразу придумать систему обозначений. Например:

• #1-#5: основные размеры (длина, ширина, глубина, подачи, припуски).
• #10-#19: счётчики и флаги (текущая глубина, номер прохода, условие выхода).
• #20+: координаты, которые меняются внутри цикла.

Внутри цикла ты часто пересчитываешь координаты на лету. Например, если нужно обработать паз со скруглениями на углах, координаты будут зависеть от радиуса скругления - #6 допустим. Тогда подводки выглядят вот так:

G1 X[#1 - #5 - #6]
G1 Y[#2 - #5 - #6]
G1 X[#6]
G1 Y[#6]

Франук сам просчитает значения в квадратных скобках перед каждым движением. Это удобно, потому что если завтра поменяется припуск или радиус - меняешь переменную, и координаты пересчитаются автоматически.

Важный момент: используй скобки всегда, когда складываешь или вычитаешь переменные. Без них Fanuc может неправильно понять выражение. G1 X[#1 + #2] - правильно, G1 X#1 + #2 - неправильно (интерпретируется как отдельные команды).

Практические советы по оптимизации

Есть несколько трюков, которые делают циклы работоспособнее и быстрее:

• Коррекция радиуса инструмента (G41/G42): если ширина паза больше диаметра фрезы, вместо того чтобы пересчитывать координаты вручную, включи коррекцию. Фанук сам сместит траекторию на радиус инструмента.
• Микроподъём между проходами: добавь G0 Z[#10 + 1] вместо G0 Z100 - поднимись не на полный рапид, а на 1 миллиметр выше текущей глубины. Экономит время на вертикальные движения.
• Пакетные подачи: если обработка идёт слоями, используй разные подачи для слоёв и для финиша. Слои - быстрее (F150), финиш - медленнее (F50).
• Проверка лимитов: добавь логику, которая не даст программе выйти за границы заготовки. Например, если координата получилась отрицательной, заними её в ноль или выброси ошибку.

Таблица типовых условий WHILE:

Условие	Обозначение	Пример
Меньше	LT	WHILE[#10 LT 0] DO1
Больше	GT	WHILE[#10 GT -5] DO1
Равно	EQ	WHILE[#10 EQ 0] DO1
Не равно	NE	WHILE[#10 NE 5] DO1
Больше или равно	GE	WHILE[#10 GE -5] DO1
Меньше или равно	LE	WHILE[#10 LE 0] DO1

Типичные ошибки и как их не допустить

Первая ошибка - бесконечный цикл. Если забыл изменять счётчик внутри цикла, программа зависнет. Всегда проверяй: есть ли строка вроде #10 = [#10 - #4] внутри WHILE? Нет - жди зависания. Вторая - неправильное условие выхода. Напиши WHILE[#10 GT -5] вместо WHILE[#10 GE -5], и на последний проход не попадёшь. Проверь логику дважды перед первым запуском.

Третья беда - неиспользованные переменные. Если ты задал #15 на начало программы, а потом забыл его в условии - он будет мешать, занимая память. Хорошая практика: в комментариях описать, какая переменная за что отвечает, вот так:

; #1 = длина паза
; #2 = ширина паза
; #3 = целевая глубина
; #10 = счётчик слоёв

Четвёртая - путаница с координатами. Когда паз не в нуле, а, скажем, в (100, 75), легко затупить и прописать абсолютные координаты вместо относительных. Используй G90 для абсолютного режима - это безопаснее. Если нужны относительные движения - явно переводи в G91, обработай, и обратно в G90.

Когда WHILE-цикл - правильное решение, а когда нет

Не всегда параметрический цикл - это панацея. Если нужно нафрезеровать один паз один раз, напиши обычный G-код - будет быстрее и понятнее. WHILE имеет смысл, когда:

• Паз обрабатывается слоями (многопроходная фрезеровка).
• Нужно обработать массив пазов с одинаковой стратегией, но разными координатами.
• Размеры варьируются, и ты хочешь одну программу под разные детали.
• Логика обработки сложная: не просто вниз, но и под углом, спиралью, с проверкой условий.

Если паз маленький, на один проход, в одной точке - обычный G81 (цикл сверления) справится быстрее. WHILE - для тяжелых случаев.

Переход на станок и отладка

Первый запуск - всегда боевой. Введи программу, но не запускай на полной скорости. Сделай так:

1. Загрузи программу в станок.
2. Проверь траекторию в симуляторе (если есть - на современных фануках симуляция встроена).
3. Первый проход - вхолостую, без заготовки, на низкой подаче (F20-30).
4. Смотри, как движется инструмент: правильно ли идёт по X, потом по Y, правильно ли слезает по Z.
5. Если траектория верная, включай заготовку и переходи на рабочую подачу.

Если что-то идёт не так - останови программу (кнопка FEED HOLD), вернись в начало, поправь переменные и перезапусти. На Fanuc это делается просто: изменяешь значение переменной через консоль (обычно кнопка #DATA), пересчитываешь, и вперёд.

Масштабирование: от одного паза к массиву

Когда циклом овладеешь, захочется обработать несколько пазов за раз. Добавь внешний WHILE для перемещения между точками обработки:

#20 = 0  ; Счётчик пазов
#21 = 3  ; Количество пазов

WHILE[#20 LT #21] DO2
  ; Вычислишь координату X следующего паза
  #11 = [#20 * 100]  ; Если пазы через каждые 100 миллиметров
  G0 X#11 Y0
  
  ; Вложенный цикл фрезеровки
  WHILE[#10 GT #3] DO1
    ; ... код обработки одного паза ...
  END1
  
  #10 = 0    ; Ресет счётчика слоёв для следующего паза
  #20 = [#20 + 1]
END2

Так одна программа обработает три паза подряд. Если завтра нужно четыре паза - меняешь #21 на 4 и всё.

На что ещё обратить внимание

Параметрическое программирование на Fanuc - это не сложный язык вроде Python, но и не просто кнопочки нажимать. Есть нюансы, которые не всегда очевидны:

• Порядок операций в выражениях: скобки, умножение, деление считаются раньше, чем сложение и вычитание. Если написал #1 = 5 + 10 * 2, получится 25, а не 30. Используй лишние скобки, не стесняйся.
• Целые числа: Fanuc работает с целыми числами в параметрах. Если нужна точность до дробей миллиметра, используй множители: вместо #1 = 5.5 пиши #1 = 55 (и потом в координатах G1 X[#1/10]).
• Защита от дурака: добавь проверку входных данных. Если оператор ввёл отрицательную глубину паза - программа должна выбросить ошибку, а не залезть в чернину. Используй условные операторы IF-ELSE для проверок.

Дальнейшее развитие идеи

Основную логику WHILE-цикла ты теперь знаешь. Но это только начало. Можно комбинировать циклы, использовать подпрограммы (вызов O1000, O2000), добавлять ветвления через IF-THEN для разных стратегий обработки. Есть программисты, которые пишут параметрические циклы для спиральной фрезеровки, для обработки под углом, даже для адаптивной подачи в зависимости от нагрузки. Но это уже высший пилотаж. Начни с простого - замкнутый слойный паз, отладь, убедись, что работает - и потом развивай.

Основной вывод: WHILE-цикл - это инструмент для думающих программистов. Он требует дополнительной внимательности при отладке, чуть больше времени на написание, но окупается многократно, когда нужно переделать стратегию или поменять размеры. Компактный, логичный код, который легко читается через полгода - вот что получится, если вникнуть в логику параметрического программирования на Fanuc.