Макрос WHILE на Fanuc для фрезеровки массива отверстий

[kirilljsx]

Задолбался я вручную пересчитывать координаты для массивов отверстий, когда можно один раз написать макрос и забыть про головную боль. WHILE на Фануке — это мощный инструмент, который берёт на себя всю рутину: меняет координаты, считает итерации, управляет подачей в зависимости от нагрузки на шпиндель. Расскажу, как это работает и почему это стоит освоить каждому программисту.

Эта статья для тех, кто уже знает базовый G-код, но хочет перейти на следующий уровень автоматизации. Не будет абстрактных примеров — только рабочие куски кода, которые можно взять и адаптировать под свой станок.

Основы WHILE в макросах Fanuc

WHILE — это цикл, который крутится, пока выполняется условие. Звучит просто, но именно на этом строятся все параметрические программы для повторяющихся операций. В отличие от встроенных циклов сверления (G81, G82, G83), WHILE даёт полный контроль: ты сам задаёшь логику, сам управляешь переменными, сам решаешь, когда остановиться.

Структура WHILE на Fanuc выглядит так: сначала инициализируешь переменную-счётчик, потом пишешь условие в квадратных скобках, потом код, который будет повторяться, и в конце закрываешь цикл оператором END. Вот схема:

#1 = 0
WHILE [#1 LT 5] DO1
  G0 X[#1*10] Y0
  #1 = #1 + 1
END1

Это простой пример: переменная #1 стартует с нуля, условие LT (less than) говорит, что цикл крутится, пока #1 меньше 5. На каждой итерации инструмент движется по X с шагом 10 мм, потом счётчик увеличивается на 1. После пятой итерации цикл завершится. Казалось бы, ерунда, но когда нужно просверлить 50 отверстий в массиве — вот тут это спасает жизнь.

Логические операторы, которые тебе понадобятся:

• EQ (equal) - равно
• NE (not equal) - не равно
• GT (greater than) - больше
• LT (less than) - меньше
• GE (greater or equal) - больше или равно
• LE (less or equal) - меньше или равно

Параметрическая фрезеровка массива отверстий

Ну, вот мясо. Нужно просверлить не одно отверстие, а целый массив — скажем, 4х3 в линейку с шагом 20 мм. Вручную писать 12 координат? Ни в жизнь. Юзаем две вложенные переменные: одна крутит по X, другая по Y.

Применение WHILE здесь становится суперполезным, потому что ты можешь комбинировать его с логикой станка. Например, если ты знаешь, что подача зависит от диаметра сверла или материала, можешь внутри цикла менять F (подачу) на лету. Или, если нужно отводить инструмент после каждого отверстия, контролировать это через счётчик.

Вот рабочий пример для массива 4х3 отверстия с шагом 20 мм:

#1 = 0            ; Счётчик по X
#2 = 0            ; Счётчик по Y
#10 = 20          ; Шаг по X
#11 = 20          ; Шаг по Y
#20 = 4           ; Количество отверстий по X
#21 = 3           ; Количество отверстий по Y
G0 Z5             ; Быстрый подход к безопасной высоте

WHILE [#2 LT #21] DO1
  #1 = 0
  WHILE [#1 LT #20] DO2
    G0 X[#1*#10] Y[#2*#11]
    G81 X[#1*#10] Y[#2*#11] Z-5 R2 F100
    #1 = #1 + 1
  END2
  #2 = #2 + 1
END1

G0 Z100           ; Отвод инструмента
M30

Видишь, тут два цикла WHILE друг в друге (вложенные циклы). Внешний крутит по Y, внутренний по X. На каждой итерации вычисляются координаты через арифметические выражения в квадратных скобках. G81 — это встроенный цикл сверления, он срабатывает в каждой точке массива.

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

• #1 и #2 — счётчики, которые увеличиваются на 1 на каждой итерации
• #10 и #11 — шаги сетки (в мм)
• #20 и #21 — количество отверстий по каждой оси
• X[#1*#10] Y[#2*#11] — вычисления координат: первое отверстие в (0,0), второе в (20,0), третье в (40,0) и так далее
• DO2 и END2 — отдельный номер для вложенного цикла (обязательно разные номера)

Динамическая подстройка подач по нагрузке

Это крутой момент, потому что современные станки могут выдавать данные о нагрузке на шпиндель через системные переменные. На Fanuc это переменная #1133 для Oi и аналогичные в других версиях (зависит от версии ПО). Если ты знаешь, как эту информацию получить, можешь подстраивать подачу на лету.

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

Вот примерная реализация:

#30 = 100         ; Базовая подача
#31 = 80          ; Минимальная подача
#32 = 120         ; Максимальная подача
#33 = 70          ; Пороговое значение нагрузки (в %)

#1 = 0
WHILE [#1 LT 10] DO1
  G0 X[#1*20] Y0
  
  ; Проверяем нагрузку на шпиндель
  IF [#1133 GT #33] THEN #30 = #31
  IF [#1133 LE #33] THEN #30 = #32
  
  ; Сверлим с подстроенной подачей
  G81 X[#1*20] Y0 Z-5 R2 F#30
  
  #1 = #1 + 1
END1

Здесь #1133 — системная переменная, которая показывает текущую нагрузку на шпиндель. Если она больше 70%, подача снижается до 80 (мм/мин), если меньше — подаём на 120. Это примитивная логика, но в реальности можно заточить под конкретный материал и диаметр сверла.

Системные переменные для мониторинга:

• #1133 - Нагрузка на шпиндель (для Oi)
• #1134 - Скорость шпинделя
• #5061 - Текущее положение по X
• #5062 - Текущее положение по Y
• #5063 - Текущее положение по Z

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

Правильная структура и отладка макроса

Ладно, код написал, но как убедиться, что он работает, а не создаст завал или аварию? Первое правило — никогда не запускай WHILE с поднятым инструментом и не проверяй на холостом ходу. Второе правило — всегда задавай ограничение по итерациям, иначе рискуешь бесконечным циклом и аварийной остановкой станка.

Отладка — это половина успеха. Прежде чем запустить полный макрос, проверь его на простом примере: скажем, одна строка из трёх отверстий вместо полного массива. Используй комментарии обильно — они не занимают место в памяти и серьёзно помогают потом разобраться, что ты писал.

Вот структурированный пример с комментариями:

; ПАРАМЕТРИЧЕСКОЕ СВЕРЛЕНИЕ МАССИВА
; Входные параметры
#10 = 20          ; ШАГ ПО X (мм)
#11 = 15          ; ШАГ ПО Y (мм)
#20 = 4           ; КОЛИЧЕСТВО ОТВЕРСТИЙ ПО X
#21 = 3           ; КОЛИЧЕСТВО ОТВЕРСТИЙ ПО Y
#30 = 100         ; ПОДАЧА (мм/мин)
#50 = -5          ; ГЛУБИНА СВЕРЛЕНИЯ (мм)

; Инициализация счётчиков
#1 = 0            ; Счётчик по X
#2 = 0            ; Счётчик по Y

; Безопасный подход
G0 G90 Z5 M3 S1500
G0 X0 Y0

; ОСНОВНОЙ ЦИКЛ СВЕРЛЕНИЯ
WHILE [#2 LT #21] DO1
  #1 = 0          ; Сброс счётчика X
  
  WHILE [#1 LT #20] DO2
    ; Быстрый подход к точке
    G0 X[#1*#10] Y[#2*#11]
    
    ; Цикл сверления
    G81 X[#1*#10] Y[#2*#11] Z#50 R2 F#30
    
    ; Увеличиваем счётчик X
    #1 = #1 + 1
  END2
  
  ; Увеличиваем счётчик Y
  #2 = #2 + 1
END1

; ЗАВЕРШЕНИЕ
G0 Z100
M9
M5
M30

Типичные ошибки, которых нужно избежать:

• Забыл END для цикла — программа не скомпилируется
• Разные номера DO/END (DO1 с END2) — путаница в логике
• Не инициализировал счётчик перед WHILE — срабатывает со случайным значением
• Условие написал неправильно (GT вместо LT) — цикл не сработает или будет работать неправильно
• Забыл увеличить счётчик внутри цикла — бесконечный цикл и авария
• Нагрузку проверяю, но неверно интерпретирую значение — подача не меняется как нужно

Автоматизация сложных траекторий

Вот когда WHILE становится по-настоящему мощным — когда нужно делать что-то нестандартное. Например, спираль из отверстий, или линия отверстий с переменным шагом, или забивка кармана с адаптивной глубиной.

Спираль реализуется так: на каждой итерации увеличиваешь не только координату X, но и Y, и радиус от центра растёт по мере того, как крутишься. Вот примерный код:

#100 = 5          ; Начальный радиус
#101 = 0.5        ; Шаг увеличения радиуса
#102 = 20         ; Количество витков
#103 = 0          ; Счётчик

WHILE [#103 LT #102] DO1
  #110 = [#100 + #103*#101]  ; Текущий радиус
  #111 = [#103*360/#102]      ; Угол в градусах
  
  ; Преобразуем полярные координаты в декартовы
  #1 = [#110*COS[#111]]      ; X
  #2 = [#110*SIN[#111]]      ; Y
  
  G0 X[#1+50] Y[#2+50]       ; Смещение на (50,50)
  G81 X[#1+50] Y[#2+50] Z-5 R2 F100
  
  #103 = #103 + 1
END1

Это уже не школьная математика, но Fanuc нормально понимает COS и SIN, поэтому спирали, окружности, овалы — всё делается через геометрию внутри G-кода.

Применение WHILE для адаптивных операций:

• Карман с переменной глубиной (на каждый проход увеличиваешь Z)
• Фрезеровка паза с уменьшающимся шагом (для чистоты)
• Сверление с проверкой усилия (если нагрузка выросла — снижаешь подачу или глубину)
• Обработка по спирали или волнистой траектории (используешь тригонометрию)

Интеграция с системой мониторинга станка

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

Например, если температура инструмента превышает критическое значение, цикл может прерваться и выдать предупреждение. Или если давление СОЖ упало, программа автоматически снизит подачу и скорость, чтобы сберечь инструмент.

Логика такая:

#1000 = 85        ; Максимальная температура инструмента
#1001 = 50        ; Критическое давление СОЖ

WHILE [#1 LT 20] DO1
  ; Проверяем системные переменные
  IF [#1136 GT #1000] THEN #3000 = 100  ; Аварийный останов с кодом ошибки
  IF [#1137 LT #1001] THEN #3000 = 101  ; Аварийный останов для низкого давления
  
  G0 X[#1*20] Y0
  G81 X[#1*20] Y0 Z-5 R2 F100
  #1 = #1 + 1
END1

Переменная #3000 — это аварийный останов с сообщением. Если задать ей значение больше нуля, программа остановится и выведет ошибку. Это полезно для безопасности и для предотвращения брака.

Производительность и оптимизация

Так, код работает, но может ли он работать быстрее? Конечно может. Первое, что нужно понять: каждый проход цикла — это вычисления и логика, это занимает время. Если ты можешь снизить количество проверок внутри цикла, это заметно ускорит обработку.

Второе: не усложняй условия без необходимости. Если тебе нужно просто пробежать по массиву, не нужны дополнительные IF’ы и проверки на каждой итерации. Если же нужна адаптация (проверка нагрузки, температуры), то да, придётся пожертвовать скоростью ради надёжности.

Третье: используй встроенные циклы (G81, G82, G83) вместо собственной логики сверления. Они оптимизированы на уровне ПО и работают быстрее, чем если ты вручную пишешь G0 и G1.

Советы по оптимизации:

• Инициализируй переменные один раз, перед циклом, а не на каждой итерации
• Используй G0 для ускоренных движений между отверстиями, G1 только для рабочих перемещений
• Минимизируй количество IF’ов внутри цикла — лучше один IF снаружи, чем десять внутри
• Встроенные циклы (G81, G82, G83) быстрее, чем самописная логика сверления
• Не переводи станок в работающем цикле на холостой ход без необходимости

На что обратить внимание при запуске

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

Частая ошибка новичков — запустить полный массив из 50 отверстий сразу, без проверки. Если там баг в логике, рискуешь сломать инструмент или испортить деталь. Лучше потратить 10 минут на отладку, чем потом искать причину брака.

Чек-лист перед запуском:

• Все END закрыты, номера DO/END совпадают
• Счётчики инициализированы (не забыл #1 = 0)
• Условия в WHILE написаны правильно (LT, GT, EQ)
• Внутри цикла счётчик увеличивается (#1 = #1 + 1)
• Безопасная высота Z задана перед циклом
• Подача и скорость шпинделя адекватны материалу
• Тестировал на холостом ходу
• Начал с малого (одна итерация или две)

Если всё это сделал, можно запускать в боевых условиях с уверенностью.

Что дальше

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