Программа управления чпу на ардуино для windows

Скачать программу для работы со станком с ЧПУ на базе Ардуино

Здесь можно скачать Ардуино ЧПУ программу бесплатно. Программа для управления станком с ЧПУ на базе платы Arduino написана на MS VB 6.0

Скачать

История версий

История версий, описание последних изменений, а также предыдущие версии программного обеспечения для станка с ЧПУ находятся здесь: Программа для управления станком с ЧПУ

Руководство пользователя программы управления станком с ЧПУ на Ардуино и его модификациями

Установка
Настройка
Перемещение в начальное положение
2D-фрезеровка / рисование
3D-фрезеровка (объёмные фигуры)
3D-сканирование
Художественная гравировка (фото, изображения и т.д.)
Гравировка орнаментов (силуэты, орнаменты и т.д.)
Резка по рисунку
Гравировка фотографии / картины CO2-лазером
Гравировка орнамента CO2-лазером на металле с помощью пасты
Делаем оправу для линзы (лупу) из фанеры с помощью CO2-лазера
Гравировка фотографии на стекле CO2-лазером
Гравировка герба на стеклянном стаканчике CO2-лазером

Примеры работы с программой управления станком с ЧПУ на Ардуино и его модификациями

Пример работы с ЧПУ

Рисуем простой цветок на станке с ЧПУ на Arduino. Драйверы ШД на ULN2003, шаговые двигатели: 28BYJ-48-5V.

Подробнее

Пример работы с ЧПУ

Простой способ выполнения качественной гравировки на пластине из нержавейки с использованием домашнего станка сч ЧПУ на Ардуино со «слабым» лазером мощностью 300 миллиВатт.

Подробнее

Источник

Если вы хотите собрать или находитесь в процессе создания собственного станка с ЧПУ, то, скорее всего, вы встретите термин GRBL. Итак, в этом руководстве мы узнаем, что такое GRBL, как установить и как использовать его для управления вашим станком с ЧПУ на базе Arduino.

Кроме того, мы узнаем, как использовать Universal G-code Sender, популярное программное обеспечение контроллера GRBL с открытым исходным кодом.

Что такое GRBL?

GRBL — это программное обеспечение или прошивка с открытым исходным кодом, которая позволяет управлять движением для станков с ЧПУ. Мы можем легко установить прошивку GRBL на Arduino и сразу же получить недорогой высокопроизводительный контроллер ЧПУ. GRBL использует G-код в качестве ввода и выводит управление движением через Arduino.

Для лучшего понимания мы можем взглянуть на следующую схему:

GRBL и Arduino принцип работы ЧПУ станка

Из схемы мы можем видеть место GRBL в принципе работы станка с ЧПУ. Это прошивка, которую нам нужно установить или загрузить в Arduino, чтобы она могла управлять шаговыми двигателями станка с ЧПУ. Другими словами, функция прошивки GRBL заключается в переводе G-кода в движение двигателя.

Требуемое оборудование

Arduino — Как мы уже говорили, нам понадобится Arduino для установки GRBL. В частности, нам нужна плата Arduino на базе Atmega 328, а это означает, что мы можем использовать либо Arduino UNO, либо Nano.
Шаговые двигатели. Очевидно, что шаговые двигатели обеспечивают движение машины.
Драйверы — для управления шаговыми двигателями нам нужны драйверы, и распространенный выбор, когда дело доходит до небольших станков с ЧПУ DIY (использующих шаговые двигатели NEMA 14 или 17), — это драйверы A4988 или DRV8825.
Arduino CNC Shield — для подключения шаговых драйверов к Arduino самый простой способ — использовать Arduino CNC Shield. Он использует все контакты Arduino и обеспечивает простой способ подключения всего, шаговых двигателей, шпинделя / лазера, концевых выключателей, охлаждающего вентилятора и т. д.

Обратите внимание, что это только основные электронные компоненты, которые нам нужны, чтобы понять, как работает станок с ЧПУ.

В качестве примера того, как все должно быть соединено, мы можем взглянуть на одну из машин для резки пенопласта с ЧПУ сделанную своими руками.

Схема сборки станка с ЧПУ GRBL

Здесь вы можете проверить и получить основные электронные компоненты, необходимые для сборки этого станка с ЧПУ:

Шаговый двигатель — NEMA 17
Шаговый драйвер A4988
Arduino CNC Shield
Arduino Uno

Главный инструмент этого станка с ЧПУ — это горячая проволока, которая может легко расплавить или прорезать пенополистирол и придать любую форму, которую мы хотим.

Как установить GRBL

Во-первых, чтобы иметь возможность установить или загрузить GRBL в Arduino, нам понадобится Arduino IDE.

Затем мы можем скачать прошивку GRBL с github.com.

Загрузите файл.ZIP и выполните следующие действия:

Откройте файл grbl-master.zip и извлеките файлы
Откройте IDE Arduino, перейдите в Sketch> Включить библиотеку> Добавить библиотеку.ZIP…

Добавление GRBL прошивки в IDE Arduino

Перейдите в извлеченную папку «grbl-master», в ней выберите папку «grbl» и щелкните открытый файл. Теперь нам нужно использовать GRBL как библиотеку Arduino.

использовать GRBL как библиотеку Arduino

Затем перейдите в Файл> Примеры> grbl> grblUpload. Откроется новый скетч, и нам нужно загрузить его на плату Arduino. Код может выглядеть странно, так как это всего лишь одна строка, но не беспокойтесь, все происходит в фоновом режиме в библиотеке. Итак, нам просто нужно выбрать плату Arduino, COM-порт и нажать эту кнопку загрузки, и все готово.

Конфигурация GRBL

На этом этапе мы должны настроить GRBL для нашей машины. Мы можем сделать это через Serial Monitor IDE Arduino. Как только мы откроем Serial Monitor, мы получим сообщение типа «Grbl 1.1h [‘$’ for help]». Если вы не видите это сообщение, убедитесь, что вы изменили скорость передачи данных на 115200.

Если мы введем «$$», мы получим список команд или текущих настроек, и они будут выглядеть примерно так:

$100 = 250 000 (x, шаг / мм)
$101 = 250 000 (y, шаг / мм)
$102 = 3200 000 (z, шаг / мм)
$110 = 500.000 (x макс. Скорость, мм / мин)
$111 = 500.000 (y макс. Скорость, мм / мин)
$ 112 = 500.000 (макс. скорость z, мм / мин)
$ 120 = 10.000 (ускорение x, мм / сек ^ 2)
$ 121 = 10.000 (ускорение y, мм / сек ^ 2)
$ 122 = 10.000 (ускорение z, мм / сек ^ 2)

Все эти команды могут или должны быть настроены в соответствии с нашим станком с ЧПУ. Например, с первой командой, $100 = 250,000 (x, шаг / мм), мы можем отрегулировать шаги на мм машины, или мы можем указать, сколько шагов должен сделать двигатель, чтобы наша ось X сместилась на 1 мм.

Однако я бы посоветовал оставить эти настройки как есть. Есть более простой способ настроить их в соответствии с нашей машиной с помощью программного обеспечения контроллера, который мы объясним в следующем разделе.

Контроллер GRBL

Итак, после того, как мы установили прошивку GRBL, теперь наш Arduino знает, как читать G-код и как управлять станком с ЧПУ в соответствии с ним. Однако, чтобы отправить G-код на Arduino, нам нужен какой-то интерфейс или программное обеспечение контроллера, которое сообщит Arduino, что делать. На самом деле для этого существует множество программ как с открытым кодом, так и коммерческих, подробно о них вы можете узнать из нашей статьи. Конечно, мы будем придерживаться открытого исходного кода, поэтому в качестве примера мы будем использовать Univarsal G-code Sender.

Интерфейс Univarsal G-code Sender

Как использовать универсальный отправитель G-кода

В этом примере я буду использовать версию платформы 2.0. После загрузки нам нужно извлечь zip-файл, перейти в папку «bin» и открыть любой из исполняемых файлов «ugsplatfrom». На самом деле это программа JAVA, поэтому для запуска этой программы сначала необходимо установить среду выполнения JAVA.

Как только мы откроем универсальный отправитель G-кода, сначала нам нужно настроить машину и настроить параметры GRBL, показанные ранее. Для этой цели мы воспользуемся мастером настройки UGS, который намного удобнее, чем вводить команды вручную через Serial Monitor IDE Arduino.

Выбор скорости передачи GRBL

Первый шаг здесь — выбрать скорость передачи, которая должна быть 115200, и порт, к которому подключен наш Arduino. Как только мы подключим Univarsal G-code Sender к Arduino, на следующем шаге мы сможем проверить направление движения двигателей.

Направление движения двигателей UGS

При необходимости мы можем изменить направление с помощью мастера или вручную переключить соединение двигателя на Arduino CNC Shield.

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

Значение по умолчанию — 250 шагов / мм. Это означает, что если мы нажмем кнопку перемещения «x +», двигатель сделает 250 шагов. Теперь, в зависимости от количества физических шагов двигателя, выбранного шагового разрешения и типа передачи, машина будет перемещаться на некоторое расстояние. Используя линейку, мы можем измерить фактическое перемещение машины и ввести это значение в поле «Фактическое перемещение». На основании этого мастер рассчитает и сообщит нам, на какое значение следует изменить параметр шаги / мм.

В моем случае станок сдвинулся на 3 мм. В соответствии с этим мастер предложил обновить параметр шаги / мм до значения 83.

GRBL калибровка шагов

После обновления этого значения станок теперь движется правильно, 1 мм в программном обеспечении означает 1 мм для станка с ЧПУ.

Консоль UGS

В консоли UGS, когда мы выполняем каждое действие, мы можем видеть выполняемые команды. Мы можем заметить, что, обновив параметр steps / mm, программа UGS фактически отправила в Arduino или прошивку GRBL команду, о которой мы упоминали ранее. Это было значение по умолчанию: $100 = 250 000 (x, шаг / мм), и теперь мы обновили значение до 83 шагов на мм: $100 = 83.

На следующем этапе мы можем включить концевые выключатели и проверить, правильно ли они работают.

Включение коцевиков

В зависимости от того, являются ли они нормально разомкнутым или нормально замкнутым соединением, мы также можем инвертировать их здесь.

Здесь стоит отметить, что иногда нам нужно отключить концевой выключатель оси Z. Так было сj станком для резки пенопласта с ЧПУ, где мне не нужен был концевой выключатель оси Z, и мне пришлось отключить его, чтобы иметь возможность правильно разместить станок. Итак, для этого нам нужно отредактировать файл config.h, который находится в папке библиотеки Arduino (или Documents Arduino libraries).

Файл config.h

Здесь нам нужно найти линии цикла возврата в исходное положение и прокомментировать установку по умолчанию для 3-х осевого станка с ЧПУ и раскомментировать настройку для 2-х осевых станков. Чтобы изменения вступили в силу, нам нужно сохранить файл и повторно загрузить эскиз grblUpload на нашу плату Arduino.

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

Возврат в исходное положение

Используя кнопку «Возврат в исходное положение», машина начнет движение к концевым выключателям. Если все пойдет наоборот, мы можем легко изменить направление.

Наконец, на последнем шаге мастера настройки мы можем включить мягкие ограничения для нашего станка с ЧПУ.

Ограничения станка с ЧПУ в UGS

Мягкие ограничения не позволяют машине выходить за пределы установленной рабочей зоны.

Заключение

Итак, благодаря прошивке GRBL и Arduino мы можем легко настроить и запустить наш DIY-станок с ЧПУ. Конечно, в этом руководстве мы рассмотрели только основы, но я думаю, что этого было достаточно, чтобы понять, как все работает и как запустить и запустить ваш первый станок с ЧПУ.

Arduino Uno и Arduino CNC Shield GRBL

Конечно, доступно множество других настроек и функций, так как GRBL действительно совместима с прошивкой контроллера ЧПУ. Все это подробно объясняется в документации GRBL, так что вы всегда можете проверить их на их вики-странице на github.com.

Кроме того, существует множество других программ контроллера GRBL с открытым исходным кодом, таких как Universal G-code Sender, и вот несколько: GRBLweb (веб-браузер), GrblPanel (графический интерфейс Windows), grblControl (графический интерфейс Windows / Linux), Easel (на основе браузера) и т. д. Вы должны изучить их и посмотреть, какой из них вам больше подходит.

Источник

Онлайн программа для симуляции готового G-Code для ЧПУ.

Я
уже рассказывал как можно сделать чертеж
в формате .svg: Inkscape где скачать русскую
версию. Настройка Inkscape. И потом из данного
файла сгенерировать G-code для ЧПУ станка:
Бесплатный онлайн генератор G-Code для
ЧПУ станка — MakerCAM.

Бесплатный онлайн генератор G-Code для ЧПУ станка — MakerCAM

Я
уже рассказывал как в
Inkscape можно начертить
2D деталь. Если не читали смотреть тут:
Inkscape где скачать русскую версию. Настройка
Inkscape

После создания чертежа в
формате .svg из него нужно сделать G-code.
Это можно сделать и с помощью Inkscape. Но
в данной программе делать, это достаточно
долго и много ненужных операций. Для
себя открыл
онлайн генератор кода
MakerCAM
. Данная программа доступна из
любого
современного браузера. Не нужно
ни чего скачивать на компьютер.

Обновлено: 1 февраля , 2021

PathCAM — Программа генерации g-code для фрезерного ЧПУ станка из 3D моделей .stl или .obj.

Наткнулся
недавно на программу которая может
сгенерировать траекторию движения для
фрезерных ЧПУ станков из 3D моделей в
формате .stl или .obj
.

Вот что пишет автор о своем программном
обеспечении:

«PathCAM
— Программное обеспечение для генерации
траекторий для роботов с ЧПУ! PathCAM —
это простой и удобный инструмент для
создания 2,5-мерных траекторий для
вырезания форм из заготовки с помощью
фрезерного станка с ЧПУ. PathCAM может
подключаться напрямую к некоторым
роботам с ЧПУ и может экспортировать
простой .gcode для других.

Обновлено: 18 июля , 2019

Universal G-Code Sender программа для управления ЧПУ станком.

Для управления ЧПУ станками используется G-Code.
G-Code — это язык программирования, используемый для отправки команд на станки с ЧПУ (числовое программное управление).

Universal G-Code Sender можно с качать отсюда.
Основным преимуществом является то, что Universal G-code Sender может работать на разных настольных платформах, таких как Windows, OS X, Linux и даже Raspberry Pi.
Для работы Universal G-code Sender необходимо устоновить Java:

Java 7 или выше — для Universal G-code Sender 1.0.8 и более ранних
Java 8 или выше — для Universal G-code Sender 1.0.9 и 2.0

Обновлено: 20 апреля , 2018

Inkscape где скачать русскую версию. Настройка Inkscape

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

И
начну я с программы Inkscape. Как не странно
но найти официальный сайт данной
программы найти в поисковике не
получается. Поэтому я снял видео как
скачать данную программу.

Обновлено: 13 февраля , 2018

Источник

Добрый день, уважаемые читатели!

Начало — Песочница: CNC Shield v3.0 — Железо
Как и обещал продолжаю писать о создании станка в домашних условиях на коленках.

Сегодня мы с Вами рассмотрим ‘софтовую’ часть, а именно прошивку и управляющую программу.

ARDUINO — GBRL

Скачиваем и устанавливаем среду разработки ARDUINO 1.6.7
Скачиваем прошивку — GBRL (версия v0.9 +)
Читаем WikiСкачиваем и распаковываем архив ‘gbrl-master.zip‘.

Вытаскиваем из архива папку ‘grbl‘ и копируем её в папку библиотек ARDUINO.

У меня это ‘C:Program FilesArduinolibraries‘.

Запускаем ARDUINO 1.6.7

Выбираем плату: Инструменты -> Плата -> Arduino UNO

Выбираем порт: Инструменты -> Порт -> Com 4 (у Вас может быть другой)

Подключаем библиотеку: Скетч -> Подключить библиотеку -> GBRL

Прошиваемся: Скетч -> Загрузка.

Если просит сохранить скетч, сохраняем в любую папку.

Ожидаем надписи — ‘Загрузка завершена‘.

Открываем монитор порта: Инструменты -> Монитор порта

Внизу справа выбираем скорость — 115200 бод.

Выбираем CR (возврат каретки)

Ожидаем ответ Ардуины:

Grbl 0.9j [‘$’ for help]

В консоли пишем $ и нажимаем ‘Отправить‘.

И видим, что нам отвечает наша Ардуина.

=====================================

Grbl 0.9j [‘$’ for help]

$$ (view Grbl settings)

$# (view # parameters)

$G (view parser state)

$I (view build info)

$N (view startup blocks)

$x=value (save Grbl setting)

$Nx=line (save startup block)

$C (check gcode mode)

$X (kill alarm lock)

$H (run homing cycle)

~ (cycle start)

! (feed hold)

? (current status)

ctrl-x (reset Grbl)

ok

======================================

Вводим $$ нажимаем Enter

======================================

$0=10 (step pulse, usec)

$1=25 (step idle delay, msec)

$2=0 (step port invert mask:00000000)

$3=0 (dir port invert mask:00000000)

$4=0 (step enable invert, bool)

$5=0 (limit pins invert, bool)

$6=0 (probe pin invert, bool)

$10=3 (status report mask:00000011)

$11=0.010 (junction deviation, mm)

$12=0.002 (arc tolerance, mm)

$13=0 (report inches, bool)

$20=0 (soft limits, bool)

$21=0 (hard limits, bool)

$22=0 (homing cycle, bool)

$23=0 (homing dir invert mask:00000000)

$24=25.000 (homing feed, mm/min)

$25=500.000 (homing seek, mm/min)

$26=250 (homing debounce, msec)

$27=1.000 (homing pull-off, mm)

$100=250.000 (x, step/mm)

$101=250.000 (y, step/mm)

$102=250.000 (z, step/mm)

$110=500.000 (x max rate, mm/min)

$111=500.000 (y max rate, mm/min)

$112=500.000 (z max rate, mm/min)

$120=10.000 (x accel, mm/sec^2)

$121=10.000 (y accel, mm/sec^2)

$122=10.000 (z accel, mm/sec^2)

$130=200.000 (x max travel, mm)

$131=200.000 (y max travel, mm)

$132=200.000 (z max travel, mm)

ok

======================================

Все настройки производятся через консоль в формате $0=1 или $0=0, 1 — включение, 0 — выключение.

Минимально-необходимые настройки:

Выставить шаги ($100-101-102);
Включить концевики ($20-21);
Активировать команду Home ($22).

Расшифровка параметров (ВНИМАНИЕ!!! У разных версий свои параметры, это примерная расшифровка):

(x, step/mm) — Установка числа шагов на миллиметр для оси X.

(y, step/mm) — Установка числа шагов на миллиметр для оси Y.

(z, step/mm) — Установка числа шагов на миллиметр для оси Z.

(step pulse, usec) — Длительность импульса шага микросекунд.

(default feed, mm/min) — Скорость рабочих (G1) перемещений инструмента.

(default seek, mm/min) — Скорость холостых (G0) перемещений инструмента.

(step port invert mask, int:00011100) — Маска выходных состояний сигналов, используется если необходимо проинвертировать сигналы на драйверы.

(step idle delay, msec) — Задержка выключения моторов, миллисекунд.

(acceleration, mm/sec^2) — Ускорение. Чем больше, тем быстрее разгон.

(junction deviation, mm) — Отклонение при прохождении крутых поворотов, увеличение значения увеличит скорость прохождения поворота, но уменьшит точность.

(arc, mm/segment) — Величина сегмента дуги или окружности. Не устанавливайте слишком малое значение, это требует повышенных вычислений.

(n-arc correction, int) — Точность вычисления дуг и кругов (не меньше 3!).

(n-decimals, int) — Минимальное число знаков после запятой в операциях с плавающей точкой.

(report inches, bool) — Единицы измерений Дюймы(1) или миллиметры (0).

(auto start, bool) — Включение автостарта после загрузки программы.

(invert step enable, bool) — Инверсия сигнала включения двигателей.

(hard limits, bool) — Включение механических лимитов(концевиков).

(homing cycle, bool) — Включение автопозиционирования по концевикам.

(homing dir invert mask, int:00000000) — Маска направление движения к точке Home.

(homing feed, mm/min) — Скорость движения у концевиков.

(homing seek, mm/min) — Скорость движения к точке Home.

(homing debounce, msec) — Задержка срабатывания концевиков

(homing pull-off, mm) — Расстояние «отскока».

Направление вращение двигателя меняется путем смены контактов двигателя или изменение маски в прошивки.

Меняются местами контакты B- и B+.

Настраиваем под себя, более подробно читаем тут.

Вводим в консоли команду — G1 X10 Y10 F300 — наши моторы крутятся.

Прошивка поддерживает все стандартные GCODE команды.

Universal-G-Code-Sender

Страница проекта находится тут.

Скачиваем версию 1.0.9, распаковываем, запускаем ‘start-windows.bat‘

Проверь у тебя установлена Java, нет? — качаем последнюю версию.

Фух — запустили:

Выбрали порт — у меня COM4
Скорость — 115200
Нажали кнопку ‘Open’

Увидели надпись **** Connected to COM4 @ 115200 baud **** — у нас все работает.

В закладке ‘Command‘ — в консоли пишем команду G1 X10 Y10 F300 — наши моторы крутятся.

Лень писать команды? — Идем в закладку ‘Machine Control‘, там управляем осями через кнопки.

Можно загрузить GCODE файл? — закладка ‘File Mode‘ — Browse — указываем GCODE файл.

Нужно ‘забиндить’ макросы? — закладка ‘Macros‘.

Ну вроде, теперь есть все необходимое для управления нашим станочком:

Электроника;
Прошивка;
Управляющая программа;
Механику и тип CNC вы выбираете сами.

Если, что то упустил или в чем то ошибся, за ранее прошу прощения.

Любая критика и поправки приветствуются.

Благодарю, Вас за внимание!

Источник

Приветствую, у меня вылазит иногда проблема:
Собрал выжигатель из шаговых двигателей старых принтеров и ардуины, но иногда grbl в ардуине начинает по своему глючить
1. загружаю файл cnc в jcnc,
2. Жму старт,
3. Шпиндель доходит до места начала прожига, включает шпиндель, ненадолго зависает и потом как-будто начинает выполнять только-что выполненную команду — т.е. двигается дальше, хотя иногда в cnc файле таких координат и близко нету, они тупо меньше.

Особенно часто бывает, когда выжигаешь крупную картинку и случайно по какой-либо причине процесса выжигания прервался. После «выпиливания» части cnc-кода, которая уже выжглась, и установки шпинделя в нулевое положение, делаешь ресет ардуины, запускаешь станок и он сам же перечеркивает свою работу
Лечится иногда ресетом компьютера, иногда в cnc-коде меняю G00 на G01 или обратно, переподключением USB-кабеля и ардуины и пр. В общем танцы с бубном и без бутылки не разобраться Косяк конечно не смертельный, но психуешь отчаянно

berkut229 писал(а):Всем привет. Столкнулся с проблемой при использовании GRBL. Суть в чем. Подготавливаю файл в CHPU конвертере небольшого размера примерно шириной 100 и высотой 200мм, закидываю в GRBL, все работает нормально. Если делаю файл уже шириной более 200мм, то GRBL не успевает отправлять команды за станком. И станок работает с паузами через каждые 3-5см пути. Эту проблему можно как то решить? Прошивка в ардуино 0.8 версии, видел 0.9 версию, может с ней лучше будет. Или может другой софт попробовать?

Лечил сменой прошивки со скоростью 9600 на 112000 и то данный косяк не изжил себя — задержка имеет место быть, но не так явно 300мм редко когда за 1 сек, но визуально концы линий пригорают (синий лазер 2Вт )

П.С.: Такая проблема была у меня при использовании прошивок grbl на скорости СОМ порта 9600, обычно это было так: если при выжигании длина линии к примеру 10мм — все ок, задержки не ощущались, но если длина линии за 100 мм уже появлялись довольно заметные задержки (по наблюдениям на 200 мм — задержка до 10-15 сек) , что конечно оставляла жирную черную точку портя товарный вид изделия

П.П.С.: В связи с описанными мной выше проблемам достаточно много перепробовал прошивок grbl, официальные у меня толково шли только до 0.8с (скорость 9600), выше 0.9 обычно или круги не рисовал или еще чего-то не шло. Поэтому вроде брал с параллельной ветки прошивку, сейчас не дома, но если надо могу посмотреть где скачал толковую на скорость 112000.

Источник

Click the Release tab to download pre-compiled .hex files or just click here

Grbl is a no-compromise, high performance, low cost alternative to parallel-port-based motion control for CNC milling. This version of Grbl runs on an Arduino with a 328p processor (Uno, Duemilanove, Nano, Micro, etc).

The controller is written in highly optimized C utilizing every clever feature of the AVR-chips to achieve precise timing and asynchronous operation. It is able to maintain up to 30kHz of stable, jitter free control pulses.

It accepts standards-compliant g-code and has been tested with the output of several CAM tools with no problems. Arcs, circles and helical motion are fully supported, as well as, all other primary g-code commands. Macro functions, variables, and most canned cycles are not supported, but we think GUIs can do a much better job at translating them into straight g-code anyhow.

Grbl includes full acceleration management with look ahead. That means the controller will look up to 16 motions into the future and plan its velocities ahead to deliver smooth acceleration and jerk-free cornering.

Licensing: Grbl is free software, released under the GPLv3 license.
For more information and help, check out our Wiki pages! If you find that the information is out-dated, please to help us keep it updated by editing it or notifying our community! Thanks!
Lead Developer: Sungeun «Sonny» Jeon, Ph.D. (USA) aka @chamnit
Built on the wonderful Grbl v0.6 (2011) firmware written by Simen Svale Skogsrud (Norway).

Official Supporters of the Grbl CNC Project

Update Summary for v1.1

IMPORTANT: Your EEPROM will be wiped and restored with new settings. This is due to the addition of two new spindle speed ‘$’ settings.
Real-time Overrides : Alters the machine running state immediately with feed, rapid, spindle speed, spindle stop, and coolant toggle controls. This awesome new feature is common only on industrial machines, often used to optimize speeds and feeds while a job is running. Most hobby CNC’s try to mimic this behavior, but usually have large amounts of lag. Grbl executes overrides in realtime and within tens of milliseconds.
Jogging Mode : The new jogging commands are independent of the g-code parser, so that the parser state doesn’t get altered and cause a potential crash if not restored properly. Documentation is included on how this works and how it can be used to control your machine via a joystick or rotary dial with a low-latency, satisfying response.
Laser Mode : The new «laser» mode will cause Grbl to move continuously through consecutive G1, G2, and G3 commands with spindle speed changes. When «laser» mode is disabled, Grbl will instead come to a stop to ensure a spindle comes up to speed properly. Spindle speed overrides also work with laser mode so you can tweak the laser power, if you need to during the job. Switch between «laser» mode and «normal» mode via a $ setting.
- Dynamic Laser Power Scaling with Speed : If your machine has low accelerations, Grbl will automagically scale the laser power based on how fast Grbl is traveling, so you won’t have burnt corners when your CNC has to make a turn! Enabled by the M4 spindle CCW command when laser mode is enabled!
Sleep Mode : Grbl may now be put to «sleep» via a $SLP command. This will disable everything, including the stepper drivers. Nice to have when you are leaving your machine unattended and want to power down everything automatically. Only a reset exits the sleep state.
Significant Interface Improvements: Tweaked to increase overall performance, include lots more real-time data, and to simplify maintaining and writing GUIs. Based on direct feedback from multiple GUI developers and bench performance testing. NOTE: GUIs need to specifically update their code to be compatible with v1.1 and later.
- New Status Reports: To account for the additional override data, status reports have been tweaked to cram more data into it, while still being smaller than before. Documentation is included, outlining how it has been changed.
- Improved Error/Alarm Feedback : All Grbl error and alarm messages have been changed to providing a code. Each code is associated with a specific problem, so users will know exactly what is wrong without having to guess. Documentation and an easy to parse CSV is included in the repo.
- Extended-ASCII realtime commands : All overrides and future real-time commands are defined in the extended-ASCII character space. Unfortunately not easily type-able on a keyboard, but helps prevent accidental commands from a g-code file having these characters and gives lots of space for future expansion.
- Message Prefixes : Every message type from Grbl has a unique prefix to help GUIs immediately determine what the message is and parse it accordingly without having to know context. The prior interface had several instances of GUIs having to figure out the meaning of a message, which made everything more complicated than it needed to be.
New OEM specific features, such as safety door parking, single configuration file build option, EEPROM restrictions and restoring controls, and storing product data information.
New safety door parking motion as a compile-option. Grbl will retract, disable the spindle/coolant, and park near Z max. When resumed, it will perform these task in reverse order and continue the program. Highly configurable, even to add more than one parking motion. See config.h for details.
New ‘$’ Grbl settings for max and min spindle rpm. Allows for tweaking the PWM output to more closely match true spindle rpm. When max rpm is set to zero or less than min rpm, the PWM pin D11 will act like a simple enable on/off output.
Updated G28 and G30 behavior from NIST to LinuxCNC g-code description. In short, if a intermediate motion is specified, only the axes specified will move to the stored coordinates, not all axes as before.
Lots of minor bug fixes and refactoring to make the code more efficient and flexible.
NOTE: Arduino Mega2560 support has been moved to an active, official Grbl-Mega project. All new developments here and there will be synced when it makes sense to.

List of Supported G-Codes in Grbl v1.1:
  - Non-Modal Commands: G4, G10L2, G10L20, G28, G30, G28.1, G30.1, G53, G92, G92.1
  - Motion Modes: G0, G1, G2, G3, G38.2, G38.3, G38.4, G38.5, G80
  - Feed Rate Modes: G93, G94
  - Unit Modes: G20, G21
  - Distance Modes: G90, G91
  - Arc IJK Distance Modes: G91.1
  - Plane Select Modes: G17, G18, G19
  - Tool Length Offset Modes: G43.1, G49
  - Cutter Compensation Modes: G40
  - Coordinate System Modes: G54, G55, G56, G57, G58, G59
  - Control Modes: G61
  - Program Flow: M0, M1, M2, M30*
  - Coolant Control: M7*, M8, M9
  - Spindle Control: M3, M4, M5
  - Valid Non-Command Words: F, I, J, K, L, N, P, R, S, T, X, Y, Z

Источник

Данная прошивка требует наличие на компьютере среды программирования Arduino, как ее установить и настроить мы рассматривали в статье «Установка и настройка Arduino».

Для своих проектов мы выбрали прошивку GRBL, как наиболее оптимизированную для станков с ЧПУ.

Скачать ее можно с официальной страницы разработчиков на GitHub.

Необходимо выбрать «Clone or download» — «Download ZIP«.

Распаковываем скачанный архив, и папку «grbl» из него необходимо заархивировать в отдельный ZIP-архив.

Теперь можно подключить к USB наш шильд, (NANO или UNO)

Из меню пуск запускаем ARDUINO.

Выбираем плату: Инструменты -> Плата -> Arduino (UNO или NANO)

Выбираем порт: Инструменты -> Порт -> Com 4 (возможны варианты)

Подключаем библиотеку: Скетч -> Подключить библиотеку -> Добавить ZIP библиотеку

и выбираем ZIP-архив в папке GRBL, который мы уже сделали.

После этого можно прошиваться: Файл -> Примеры -> GRBL -> grblUpload

После окончания процесса компиляции и прошивки мы увидим такое сообщение «Загрузка завершена«

Проверим, что у нас получилось.

Выберем пункты: Инструменты — Монитор порта

Должно выпасть следующее окно

Вводим CR (Возврат каретки) , 115200 бод в правом нижнем углу.

В консоли пишем $$, нажимаем Отправить

После всех манипуляции мы должны увидеть

А вот о том, что это такое и как настроить плату под конкретный станок мы поговорим в нашей следующей статьте

«Universal G-Code Sender — установка и настройка«

Источник

Создание станка с ЧПУ из доступных деталей с минимум слесарной работы

Время прочтения
11 мин

Просмотры 115K

Продолжаем обзор деятельности нашего Хакспейс-клуба.

Мы давно мечтали купить в наш клуб ЧПУ станок. Но решили его сделать сами. С нуля, начиная от железа и кончая программного обеспечение (прошивка контроллера и управляющая программа). И у нас это получилось.

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

Контроллер мы выбрали Arduino Mega 2560 и что бы много не думать, драйвер шаговых двигателей использовали RAMPS 1.4 (как у RepRap 3D принтера).

Программу контроллера писали по алгоритму метода конечных автоматов. Последний раз я о нем слышал лет 20 назад в институте, не помню по какому предмету изучали. Это была очень удачная идея. Код получился маленький и легко расширяемый без потери читабельности (если в дальнейшем понадобится не только оси XYZ, или использовать другой G-код). Программа контроллера принимает с USB порта G-код и, собственно, дает команду двигателям осей XYZ двигаться в заданном направлении. Кто не знает, G-код — это последовательность конструкций типа G1X10Y20Z10, которая говорит станку переместится по оси X на 10 мм, Y на 20 мм и Z на 10 мм. На самом деле, в G-коде много различных конструкций (например, G90 — используется абсолютная система координат, G91 — относительная) и много модификаций самого кода. В интернете много о нем описано.

Подробнее остановлюсь на описание скетча (прошивка контроллера).

Вначале в описании переменных прописываем, к какому выходу контроллера будет подключены двигатели и концевые выключатели.

В этом коде метода конечных автоматов переменная принимает значение ждать с USB порта первый байт, во второй конструкции case производится проверка наличия данных и переменная _s принимает значение get_cmd. Т.е считать данные с порта.

 switch(_s){
  case begin_cmd:         Serial.println("&"); //038
                          //to_begin_coord();
                          n_t=0;
                          _s=wait_first_byte;
                          len=0;
                          break;
                          
  case wait_first_byte:   if(Serial.available()){
                              Serial.print(">");
                             _s=get_cmd;
                              c_i=0;
                           }
                          break;

Далее считываем все, что есть в порту, переменная _s устанавливается в get_tag; т.е. переходим на прием буквенного значение G – кода.

case get_cmd:           c=Serial.read();
                          if(c!=-1){
                              if(c=='~'){
                                _s=get_tag;
                                c_i=0;
                                n_t=0;
                                break;
                              }
                           Serial.print(c);
                           if((c>=97)&&(c<=122))
                             c-=32;
                           if( (c==32)||(c==45)||(c==46)||((c>=48)&&(c<=57))||((c>=65)&&(c<=90)) ){
                             cmd[c_i++]=c;
                             len++;
                           }
                          }
                          break;

Ну и так далее.

полный код можно посмотреть здесь.

#include <Stepper.h>
#define STEPS 48
//#define SHAG 3.298701
#define STEP_MOTOR 1
double koefx = 1.333333;
double koefy = 1.694915;
Stepper stepper0(STEPS, 5, 4, 6, 3);
Stepper stepper1(STEPS, 8, 9, 10, 11);
Stepper stepper2(STEPS, 13, 12, 7, 2);
int x,y,x1,m;
int motor;
int inPinX = 15;                   // кнопка на входе 22
int inPinY = 14;                   // кнопка на входе 23
int inPinZ = 24;                   // кнопка на входе 24
int x_en = 62;
int x_dir = 48;
int x_step = 46;
int y_en = 56;
int y_dir = 61;
int y_step = 60;
const int begin_cmd=1;
const int wait_first_byte=2;
const int wait_cmd=3;
const int get_cmd=4;
const int test_cmd=5;
const int get_word=6;
const int get_tag=7;
const int get_val=8;
const int compilation_cmd=9;
const int run_cmd=10;
int abs_coord=1;
const int _X=1;
const int _Y=2;
//const int =10;
//const int =11;
//const int =12;


int _s=begin_cmd;
const int max_len_cmd=500;
char cmd[max_len_cmd];
char tag[100][20];
char val[100][20];
int n_t=0;
int c_i=0;
char c;
int i,j;
int amount_G=0;
int len=0;
char*trash;
int n_run_cmd=0;
int g_cmd_prev; //ya предыдущее значение G
class _g_cmd{
public:
_g_cmd(){
 reset();
}
int n; //ya
int g;
double x;
double y;
double z;
void reset(void){
 n=g=x=y=z=99999;
}
};
double _x,_y,_z;
double cur_abs_x,cur_abs_y,cur_abs_z; //ya stoyalo int
int f_abs_coord=1;

_g_cmd g_cmd[100];

void setup()
{

  stepper0.setSpeed(150);
  stepper1.setSpeed(150);
  stepper2.setSpeed(1000);
  Serial.begin(9600);
  pinMode(inPinX, INPUT);
  pinMode(inPinY, INPUT);
  pinMode(inPinZ, INPUT);
  pinMode(x_en, OUTPUT);
  pinMode(x_dir, OUTPUT);
  pinMode(x_step, OUTPUT);
  pinMode(y_en, OUTPUT);
  pinMode(y_dir, OUTPUT);
  pinMode(y_step, OUTPUT);
  digitalWrite(x_en, 1);
  digitalWrite(y_en, 1);
   to_begin_coord();
  //UNIimpstep(12,13,2,7,3,1000);
  //UNIimpstep(12,13,2,7,3,-1000);
}

void to_begin_coord(void)
{
 impstep(_X,-10000,1);
 impstep(_Y,-10000,1);
 cur_abs_x=cur_abs_y=cur_abs_z=0;
}

void loop()
{
  switch(_s){
  case begin_cmd:         Serial.println("&"); //038
                          //to_begin_coord();
                          n_t=0;
                          _s=wait_first_byte;
                          len=0;
                          break;
                          
  case wait_first_byte:   if(Serial.available()){
                              Serial.print(">");
                             _s=get_cmd;
                              c_i=0;
                           }
                          break;
                          
  case get_cmd:           c=Serial.read();
                          if(c!=-1){
                              if(c=='~'){
                                _s=get_tag;
                                c_i=0;
                                n_t=0;
                                break;
                              }
                           Serial.print(c);
                           if((c>=97)&&(c<=122))
                             c-=32;
                           if( (c==32)||(c==45)||(c==46)||((c>=48)&&(c<=57))||((c>=65)&&(c<=90)) ){
                             cmd[c_i++]=c;
                             len++;
                           }
                          }
                          break;

 
  case get_tag:           while((c_i<len)&&(cmd[c_i]<=32)) c_i++;
                          i=0;
                          while((c_i<len)&&(cmd[c_i]>=65)){
                             tag[n_t][i]=cmd[c_i];
                             i++;
                             c_i++;
                             while((c_i<len)&&(cmd[c_i]<=32)) c_i++;
                          }
                          if(i==0){
                            Serial.println("er2 cmd - 'no tag'");
                            _s=begin_cmd;
                            break;
                          }
                          tag[n_t][i]=0;
                          _s=get_val;
                          break;
                          
  case get_val:           while((c_i<len)&&(cmd[c_i]<=32)) c_i++;
                          i=0;
                          while((c_i<len)&& ( (cmd[c_i]=='.')||(cmd[c_i]=='-')||((cmd[c_i]>=48)&&(cmd[c_i]<=57)) ) ){
                             val[n_t][i]=cmd[c_i];
                             i++;
                             c_i++;
                             while((c_i<len)&&(cmd[c_i]<=32)) c_i++;
                          }
                          if(i==0){
                            Serial.println("er3 cmd - 'no val'");
                            _s=begin_cmd;
                            break;
                          }
                          val[n_t][i]=0;
                          n_t++;
                          _s=get_tag;
                          
                          if(c_i>=len)
                              _s=compilation_cmd;
                          break;
                        
  case compilation_cmd:   Serial.println("");
                          Serial.print("compilation cmd,input (");
                          Serial.print(n_t);
                          Serial.println("): ");

                          for(i=0;i<n_t;i++){
                            Serial.print(i);
                            Serial.print("=");
                            Serial.print(tag[i]);
                            Serial.print("(");
                            Serial.print(val[i]);
                            Serial.println(")");
                          }
                          for (int k=0; k<=j; k++)
                          {
                          g_cmd[k].reset();
                          }
                         j=0;
                         i=0;

                         while(i<n_t){
                          if(tag[i][0]=='N'){
                           g_cmd[j].n=(int)strtod(val[i],&trash);
                           i++;
                           while((i<n_t)&&(tag[i][0]!='N')){ //(g_cmd[j].g==1)&&
                                if(tag[i][0]=='G'){
                                   g_cmd[j].g=(int)strtod(val[i],&trash);
                                   g_cmd_prev = g_cmd[j].g;
                                }
                                else { g_cmd[j].g = g_cmd_prev;
                                }
                            if(tag[i][0]=='X')
                               g_cmd[j].x=(double)strtod(val[i],&trash);
                            if(tag[i][0]=='Y')
                               g_cmd[j].y=(double)strtod(val[i],&trash);
                            if(tag[i][0]=='Z')
                               g_cmd[j].z=(double)strtod(val[i],&trash);
                            i++;
                           }//while((i<n_t)&&(tag[i]!="G"))
                           j++;
                          }//if(tag[i]=="G")
                          else i++;
                         }//while(i<n_t)
                         amount_G=j;

                        Serial.print("compilation cmd,output (");
                        Serial.print(amount_G);
                        Serial.println("): ");
                  
                         for(j=0;j<amount_G;j++){
                            Serial.print(j);
                            Serial.print("=");
                            Serial.print("N");Serial.print(g_cmd[j].n);Serial.print(" ");
                            Serial.print("G");Serial.print(g_cmd[j].g);Serial.print(" ");
                            Serial.print("X");Serial.print(g_cmd[j].x);Serial.print(" ");
                            Serial.print("Y");Serial.print(g_cmd[j].y);Serial.print(" ");
                            Serial.print("Z");Serial.print(g_cmd[j].z);Serial.println(" ");
                         }
                         
                         n_run_cmd=0;
                         _s=run_cmd;
                         break;

  case run_cmd:          
                         Serial.print("run cmd [");
                         Serial.print("N");Serial.print(g_cmd[n_run_cmd].n);Serial.print(" ");
                         Serial.print("G");Serial.print(g_cmd[n_run_cmd].g);Serial.print(" ");
                         Serial.print("X");Serial.print(g_cmd[n_run_cmd].x);Serial.print(" ");
                         Serial.print("Y");Serial.print(g_cmd[n_run_cmd].y);Serial.print(" ");
                         Serial.print("Z");Serial.print(g_cmd[n_run_cmd].z);Serial.print(" ");
                         Serial.println("]");

                         int f_cmd_coord=0;
                         if(g_cmd[n_run_cmd].g==90){
                            f_abs_coord=1;
                            f_cmd_coord=1;
                            Serial.println("change to ABS coord");
                         }
                         if(g_cmd[n_run_cmd].g==91){
                            f_abs_coord=0;
                            f_cmd_coord=1;                            
                            Serial.println("change to REL coord");
                         }
                         Serial.print("cur_abs(");Serial.print(cur_abs_x);Serial.print(",");Serial.print(cur_abs_y);Serial.print(",");Serial.print(cur_abs_z);Serial.println(")");
                         if(f_cmd_coord){if(++n_run_cmd>=amount_G) _s=begin_cmd; break;}
                         
                         if(f_abs_coord){
                            Serial.println("zdes kosjak G90 ABS");
                            if (g_cmd[n_run_cmd].x==99999)
                            _x=0;
                            else
                           _x=g_cmd[n_run_cmd].x-cur_abs_x;
                            if (g_cmd[n_run_cmd].y==99999)
                            _y=0;
                            else
                           _y=g_cmd[n_run_cmd].y-cur_abs_y;
                           if (g_cmd[n_run_cmd].z==99999)
                            _z=0;
                            else
                           _z=g_cmd[n_run_cmd].z-cur_abs_z;
                           
                         }else{
                           Serial.println("normalno G91 REL");
                           _x=g_cmd[n_run_cmd].x;
                           _y=g_cmd[n_run_cmd].y;
                           _z=g_cmd[n_run_cmd].z;                         
                         }

                         if((_x==0)&&(_y==0)&&(_z==0)){
                           Serial.println("exit: _x=0,_y=0,_z=0");
                           if(++n_run_cmd>=amount_G) _s=begin_cmd; break;
                         }
                         
                        // _x=_x*koefx;
                        // _y=_y*koefy;
                         //_z=_z*koef;
                         double max_l=abs(_x); //ya
                         if(abs(_y)>max_l)
                             max_l=abs(_y);
                         if(abs(_z)>max_l)
                             max_l=abs(_z);
                         double unit_scale=90; // steps in 1.0
                         double unit_len=max_l*unit_scale,unit_step;
                         double px=0,py=0,pz=0,x=0,y=0,z=0,kx,ky,kz;
                         int all_x_steps=0,all_y_steps=0,all_z_steps=0;
                         kx=_x/unit_len;
                         ky=_y/unit_len;
                         kz=_z/unit_len;
                    //     Serial.print("unit_len - "); Serial.print(unit_len); Serial.print(" _x- "); Serial.print(_x); Serial.print(" max_l- "); Serial.println(max_l);
                    //     Serial.print("kx=");Serial.print(kx);Serial.print(" ky=");Serial.print(ky);Serial.print(" kz=");Serial.println(kz); 
                         if((kx==0)&&(ky==0)&&(kz==0)){if(++n_run_cmd>=amount_G) _s=begin_cmd; break;}
                         for(unit_step=0;unit_step<unit_len;unit_step++){

                          if((abs(x-px)*unit_scale)>=1){
                            impstep(_X,STEP_MOTOR*kx/abs(kx),1);  //stepper0.step(STEP_MOTOR*kx/abs(kx));
                            //Serial.print("x_step ");Serial.println(kx/abs(kx));
                            all_x_steps++;
                            px=x;
                          }
                          if((abs(y-py)*unit_scale)>=1){
                            impstep(_Y,STEP_MOTOR*ky/abs(ky),1); //stepper1.step(STEP_MOTOR*ky/abs(ky));
                            //Serial.print("y_step ");Serial.println(ky/abs(ky));
                            all_y_steps++;
                            py=y;
                          }
                          if((abs(z-pz)*unit_scale)>=1){
                            UNIimpstep(12,13,2,7,3,10*kz/abs(kz)); //stepper2.step(STEP_MOTOR*kz/abs(kz)); 
                            //Serial.print("z_step ");Serial.println(kz/abs(kz));
                            all_z_steps++;
                            pz=z;
                          }
                          x+=kx; y+=ky; z+=kz;
                       //   Serial.print(unit_step);Serial.print("  :  ");
                        //  Serial.print(x);Serial.print("  |  ");Serial.print(y);Serial.print("  |  ");Serial.println(z);                          
                         }
                          Serial.println("-----------------------------------------");
                          Serial.print("all_steps(");Serial.print(all_x_steps);Serial.print(",");Serial.print(all_y_steps);Serial.print(",");Serial.print(all_z_steps);Serial.print(")");
                          cur_abs_x+=_x; cur_abs_y+=_y; cur_abs_z+=_z;                         
                          Serial.print("cur_abs(");Serial.print(cur_abs_x);Serial.print(",");Serial.print(cur_abs_y);Serial.print(",");Serial.print(cur_abs_z);Serial.println(")");
                          Serial.println("-----------------------------------------");   
                         
                         if(++n_run_cmd>=amount_G) _s=begin_cmd;
                            
 }//switch(_s)
}

char end_button(int coord)
{
  int but=0;
  
  if(coord==_X)
      but=digitalRead(inPinX);
  if(coord==_Y)
      but=digitalRead(inPinY);
  
  if(but){
   if(coord==_X)
       Serial.println("[ X out of range ]"); 
   if(coord==_Y)
       Serial.println("[ Y out of range ]"); 
  }
  return but;
}
   
char impstep(int coord,int kol,int f_test_coord)
{
  int IN_en,IN_dir,IN_step,pause;
  pause=2; //35
  switch(coord){
   case _X:  IN_en=x_en; IN_dir=x_dir; IN_step=x_step;
     digitalWrite(IN_en, 0);
     break;
   case _Y:  IN_en=y_en; IN_dir=y_dir; IN_step=y_step;
     digitalWrite(IN_en, 0);
     break;
    }
  if(!f_test_coord)
     Serial.println("[ break step ]");
  //delay(100);
  if (kol<0)
    for (int i=0; i<=abs(kol); i++){
    if(f_test_coord&&end_button(coord)){
      impstep(coord,200,0);
      return 0;
    }
    digitalWrite(IN_dir, LOW);
    digitalWrite(IN_step, HIGH);
    delay(pause);
    digitalWrite(IN_step, LOW);
    delay(pause);
  }else
    for (int i=0; i <= kol; i++){
      if(f_test_coord&&end_button(coord)){
        impstep(coord,200,0);
        return 0;
      }
    digitalWrite(IN_dir, HIGH);
    digitalWrite(IN_step, HIGH);
    delay(pause);
    digitalWrite(IN_step, LOW);
    delay(pause);
    }
    digitalWrite(IN_en, 1);
    return 1;
  }

void UNIimpstep(int IN1,int IN2,int IN3,int IN4,int pause,int kol)
{
      //delay(100);
  if (kol<0)
    for (int i=0; i<=abs(kol); i++){
         digitalWrite(IN1, 0);
    digitalWrite(IN2, 1);
    digitalWrite(IN3, 0);
    digitalWrite(IN4, 0);
    delay(pause);
    digitalWrite(IN1, 1);
    digitalWrite(IN2, 0);
    digitalWrite(IN3, 0);
    digitalWrite(IN4, 0);
    delay(pause);
    digitalWrite(IN1, 0);
    digitalWrite(IN2, 0);
    digitalWrite(IN3, 0);
    digitalWrite(IN4, 1);
    delay(pause);
    digitalWrite(IN1, 0);
    digitalWrite(IN2, 0);
    digitalWrite(IN3, 1);
    digitalWrite(IN4, 0);
     delay(pause);
   }
   else
    for (int i=0; i <= kol; i++){
    digitalWrite(IN1, 1);
    digitalWrite(IN2, 0);
    digitalWrite(IN3, 0);
    digitalWrite(IN4, 0);
    delay(pause);
    digitalWrite(IN1, 0);
    digitalWrite(IN2, 1);
    digitalWrite(IN3, 0);
    digitalWrite(IN4, 0);
    delay(pause);
    digitalWrite(IN1, 0);
    digitalWrite(IN2, 0);
    digitalWrite(IN3, 1);
    digitalWrite(IN4, 0);
    delay(pause);
    digitalWrite(IN1, 0);
    digitalWrite(IN2, 0);
    digitalWrite(IN3, 0);
    digitalWrite(IN4, 1);
    delay(pause);
 }
}

Завершается конечный автомат конструкцией case run_cmd: где собственно и подается управляющий сигнал на двигатель. Управлением двигателем можно было бы использовать библиотеку #include <Stepper.h> но мы написали свою функцию(char impstep -для биполярного двигателя, void UNIimpstep — униполярного ), что бы можно было не ждать пока один двигатель отработает, что бы послать сигнал другому. Ну и на будущее, отдельная процедура позволит гибче использовать возможностями шагового двигателя. Например, если будем использовать другой драйвер двигателя программно задавать полушаг или шаг двигателя. В нынешнем исполнении с RAMPS получается 1/16 шага. Если кому интересно, про управление шаговыми двигателями можно отдельную статью часами писать.

Теперь немного о железе.

Двигатели использовали 17HS8401, самые мощные из NEMA17, которые смогли на ebay найти. Там же купили подшипники и оптические концевики.

Все остальное отечественное, родное. Оригинальная идея с направляющими, сделали их из длинных хромированных ручек для мебели, они как раз диаметром 12 мм под подшипники, длиной они продаются до метра, и прочности вполне хватает. В торцах ручек просверлили отверстия и метчиком нарезали резьбу. Это позволило просто болтом надежно соединить направляющие с несущим конструктивом. Для оси Z так вообще ручку прикрепили к пластине конструктива целиком, Вал продается в любом строительном магазине как шпилька с резьбой любого диаметра. Мы использовали на 8 мм. Соответственно и гайки 8 мм. Гайку с подшипником и несущим конструктивом оси Y соединили с помощью соединительной скобы. Скобы купили в специализированном магазине для витрин. Видели наверно такие хромированные конструкции в магазинах стоят на которых галстуки или рубашки висят, вот там используются такие скобы для соединения хромированных трубок. Двигатель соединили с валом муфтой, которую сделали из куска стального прута диаметром 14мм, просверлив по центру отверстие и пару отверстий сбоку, для зажимания винтами. Можно не заморачиваться и купить готовые на ebay по запросу cnc coupling их куча выпадает. Несущий конструктив нам вырубили на гильотине за 1000 р. Сборка всего этого заняло не много времени и получили на выходе вот такой станок, на фото еще не установлены концевики, контроллер и не установлен двигатель фрезы.

Точность получилась просто изумительная, во-первых шаговый двигатель шагает 1/16 шага, во-вторых вал с мелкой резьбой. Когда в станок вставили ручку вместо фрезы, он нарисовал сложную фигуру, потом еще несколько раз обвел эту фигуру, а на рисунке видно как будто он один раз рисовал, под лупой рассматривали пытались другую линию найти. Жесткость станка тоже хорошая. Шатается только в пошипниках в допустимых пределах их собственого допуска и посадки. Немного шатается еще по оси Y, ну здесь я думаю конструктив оси Z надо доработать.

Фото получилось не качественное, на заднем плане стекло отражает. Не знаю какой я конструктор станка, но фотограф я просто никакой. Вот чуть получше.

Теперь об управляющей программе. Не помню почему, но мы решили сделать свою программу, которая готовый G-код с компьютера передает в контроллер. Может просто не нашли подходящий.

Программа написана на Microsoft Visual C++, использовалась библиотеки:

port.Open(8, 9600, CSerialPort::NoParity, 8, CSerialPort::OneStopBit, CSerialPort::XonXoffFlowControl);
для открытия порта
port.Write(text, l); - запись в порт
port.Read(sRxBuf, LEN_BUF); - чтение порта.

Использовался еще стандартный компонент msflexgrid таблица, в которую в реальном времени заносится выполняемый в настоящий момент G-код. Т.е. эта программа просто открывает готовый G-код и маленькими порциями запихивает его в контроллер.

Исходный код управляющей программы можно посмотреть здесь github.com/konstantin1970/cnc.git
Для понимания добавлю еще, что стандартный windows hyperterminal или putty делает то-же самое, запихивает данные в контроллер.
Сам G-код можно сделать в любой CAD/CAM системе например, мне понравился ARTCAM.

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

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

Источник