Блок схема программы ардуино

Создать ЧПУ на Ардуино – сравнительно несложно. Но многие воспринимают это как вариант для пользователей-непрофессионалов, считая, что такой подход устроит лишь «чайников». В статье найдете пошаговую инструкцию и основные советы от мастеров.

• Что такое Arduino
• Разработка электроники с Arduino
• ЧПУ станок из дерева
• Зачем нужны шилды
• Для любителей выжигать на различных материалах
• А как насчет взаимодействия
• Вместо заключения

Создать ЧПУ на Ардуино – сравнительно несложно. Но многие воспринимают это как вариант для пользователей-непрофессионалов, считая, что такой подход устроит лишь «чайников».

Что такое Arduino

Прежде всего, стоит разобраться, что такое Arduino.

• название торговой марки аппаратуры, средств программирования, при помощи которых реально построить модели станков (в том числе, трехосевого), несложные системы автоматики и робототехники;
• линейка продукции, наличие открытой архитектуры у которой позволит скопировать или дополнить уже существующие конструкции;
• небольшая плата с собственным процессором и памятью;
• аппаратная вычислительная платформа или же контроллер;
• язык программирования, позволяющий разбирать различный софт (условно бесплатное ПО, свежие новости в области IT);
• так называемый электронный конструктор.

Создавая на Ардуино устройства электроники, способные принимать сигналы от разных цифровых и аналоговых датчиков, подключенных к нему, как к основе. Поэтому в контексте данной статьи, речь будет идти о платах.

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

Разработка электроники с Arduino

Такая плата может быть самостоятельно собрана пользователем или покупается в сборе. Она способна принимать программное обеспечение компьютера. Arduino, упрощая работу с микроконтроллерами, имеет преимущества перед другими устройствами:

• низкую стоимость;
• кросс-платформенность (способность работать в нескольких ОС);
• простую, понятную среду программирования (подходит для новичка, а также опытного пользователя);
• в качестве основы Arduino применяются микроконтроллеры ATMEGA8 и ATMEGA168.

Один из умельцев по схеме создал первый самодельный станок с ЧПУ из доступных материалов себестоимостью в пределах 170$. Его предназначение – резка пластика и фанеры, раскрой деталей для создания любой самоделки. Электронную часть собрано на arduino с прошивкой GRBL. Для этого понадобились главные узлы:

• платы Ардуина R3, cnc shield v3 Update или новая версия v4;
• ШД (тип NEMA 17);
• блок питания (24 В, 15 А).

Заготовил механику для самодельного ЧПУ своими руками, включая станину из фанеры толщиной 10 мм, шурупы и болты 8 мм. Чтобы сделать линейные направляющие, взял металлический уголок 25х25х3 мм и подшипники 8х7х22 мм. Движение оси Z на шпильке M8, а оси X и Y – зубчатые полиуретановые ремни T2.5. Использован самодельный шпиндель.

Рабочее пространство станка 45 см по X, 33 см по Y, 4 см по Z. Что касается фрезера, в Китае приобретено несколько фрез (3 и 4 канавки). Они идеальны для металла, а для фанеры (надо было вырезать шестерёнки) понадобились другие.

ЧПУ станок из дерева

Для него нужна Аrduino uno R3, G-сode Sender и GRBL. Необходимо заранее подготовить материалы и компоненты: фанеру, гайки с болтами, резьбовой вал и стержни из стали, шарикоподшипники, ШД Nema 23 и драйвера к ним, источник питания 24 В, 15 А, втулки из капролона, фторопласта и металла, провода.

Многое, входящее в электронику, прислали из Китая.

Основанием служат бруски из древесины с глухими, сквозными отверстиями. Стальной резьбовой вал, установленный по центру станка, служит приводом для оси Х. В момент его вращения – каретка (рабочий стол) выполняет перемещение вдоль этой оси Х.

ВНИМАНИЕ: чём толще фанера или деревянный брусок, тем меньшей будет вибрация, выше точность позиционирования.

Портал (ось Y) устанавливают на подвижном столе, фиксируя гайкой под столом. Ось Z служит для перемещения рабочего органа (он подает инструмент в вертикальном положении).

Для сборки понадобятся болты и гайки. Не стоит склеивать поломанные делали, лучше их заменить новыми. Подключая Arduino, ШД и драйверы к каждому из них, надо предусмотреть и блоки питания для них. Загрузив и настроив код GRBL, можно открыть G-сode Sender и подключить Arduino к ПК. Плата готова участвовать в процессе управления чпу станком.

Чтобы задать траекторию обработки, используются чертежи любой CAD программы. Затем используется CAM программа, формирующая G-код.

Зачем нужны шилды

Обладатели самодельных устройств наслышаны о платах расширения – Arduino cnc shield, применение которых расширяет функционал фрезерного оборудования.

Обычно шилду изготавливают под форм-фактор платы. Используют и несколько шилдов одновременно, устанавливая их на микроконтроллер (один на другой). Спектр их применения:

• при помощи официального устройства Arduino – Ethernet cnc shield можно добиться независимости проекта от ПК, да и для хостинга веб-сервера его используют;
• 4 Relay Shield – возможность для того, чтобы подключать 4-х периферийные устройства;

ВАЖНО: надо соблюдать осторожность с контактами этого устройства, чтобы не повредить Arduino.

• Рrotoshield – весьма полезный шилд в момент, когда собирается схема;
• LCD Shield позволяет информацию с Arduino выводить напрямую на периферийный экран;
• еnergy Shield – расширенные возможности для питания на Arduino. Реальна подзарядка мобильников и гаджетов;
• мotor shield обеспечивает управление большим числом моторов и их защиту;
• SD Card Shield служит для обработки и хранения больших массивов информации;

• Wi-fi Shield, подключенный к серийному порту, обеспечит дистанционное управление приводами роботизированных проектов;
• GPRS Shield оснащается антеннами для использования сети GSM/GPRS;
• E-Ink shield – путь для использования технологии электронных чернил, дисплею нужен для питания минимум энергии;
• мusic Shield способен воспроизводить музыку через Arduino в отличном качестве.

Реально создать лазерный 3D принтер, ЧПУ станок, употребляя бюджетные платы Arduino. С платой расширения CNC Shield можно работать на станках с числовым программным управлением, в гравировальной или фрезерной машине. А шилд для управления тремя ШД (трехосевой станок) имеет три разъема, чтобы не было проблем с каждым драйвером при подключении.

Для любителей выжигать на различных материалах

В сети можно увидеть многочисленные самодельные модели выжигателей, которые способны создавать рисунок на фанере, пластике, металле и даже на стекле. Причем достигается фотографическая схожесть и некоторая объемность изображения. Поверхность очищают, обезжиривают, грунтуют белым акрилом марки Kudo и, применяя лазерный ЧПУ выжигатель, его ещё называют пиропринтер, создают уникальные изображения. Иногда процесс длится 6 и больше часов.

Скорость работы выжигателя – стабильная 10 м/мин, и у программистов есть идеи, как ее поднять, не вмешиваясь в работу блока управления. Управлять выжигателем можно и с ноутбука (ОС Windows XP и 7), отказавшись от LPT кабеля. Это превратит выжигание в увлекательное занятие для детей и подростков с применением возможностей лазерных фрезеров.

А как насчет взаимодействия

Удивительно слушать заявления некоторых умельцев, что для ЧПУ Ардуино не подходит, тем более, невозможен симбиоз mach3 arduino, якобы они не желают взаимодействовать.

Другие же уверены в противном: ардуину можно реализовать для ЧПУ при помощи трёх вариантов:

1. Полностью автономный контроллер.
2. Плата-интерпретатор отвечает за движения, но они рассчитываются на компьютере.
3. Плата-транслятор (переходник) – выполняет роль виртуального ЛПТ-порта.

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

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

Вместо заключения

Какое бы устройство не собирали умельцы на базе Arduino: фрезерный станок или лазерный прибор для выжигания, им нужны чертежи и схемы, материалы и комплектующие, некоторые практические умения, чтобы справиться с этой задачей. А ещё – вера в свои силы, умело сочетающаяся с желанием чему-то научиться у других.

Источник: vseochpu.ru

Синтаксис скетча Arduino

Комментарии — это пояснительные инструкции, которые можно включить в код C++, чтобы объяснить, что делает этот код.
Компилятор игнорирует все, что появляется в комментарии, поэтому ни одно из этих сведений не отображается в результате.

Комментарий, начинающийся с двух косых черт ( // ), называется однострочным. Косые черты говорят компилятору игнорировать все, что следует, вплоть до конца строки.

#include using namespace std; int main() < cout

• Многострочный комментарий.

Комментарии, требующие нескольких строк, начинаются с /* и заканчиваются на */ .

Их можно разместить на одной линии или вставить между ними одну или несколько строк.

/* Это комментарий */ /* Комментарии на языке C++ могут занимать несколько строк */

Обязательные функции

Скетч начинается с void setup.
Функция setup() вызывается, когда стартует скетч. Используется для инициализации переменных, определения режимов работы выводов, запуска используемых библиотек и т.д. Функция setup запускает только один раз, после каждой подачи питания или сброса платы Arduino.

Пример

int buttonPin = 3; void setup() < Serial.begin(9600); pinMode(buttonPin, INPUT); >void loop() < // . >

Функция loop() крутится в бесконечном цикле, позволяя программе совершать вычисления и реагировать на них.

int buttonPin = 3; // setup инициализирует последовательный порт и кнопку void setup() < beginSerial(9600); pinMode(buttonPin, INPUT); >// в цикле проверяется состояние кнопки, // и на последовательный порт будет отправлено сообщение, если она нажата void loop()

Директивы

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

#define ledPin 3 // компилятор заменит любое упоминание ledPin //на значение 3 во время компиляции #define ledPin 3; // это ошибка, ; здесь не нужна #define ledPin = 3 // это тоже ошибка, знак = не нужен

***Стоит упомянуть о некотором нежелательном эффекте, который может иметь место при использовании директивы #define. Например, если имя константы, заданное с помощью директивы #define включить в имя другой константы или переменной, то оно будет заменено на свое значение.

Директива используется для включения сторонних библиотек в скетч

#include // подключает библиотеку. Ищет в папке с библиотеками #include «Servo.h» // ищет в папке со скетчем, а потом в папке с библиотеками

• #if, #else, #elif и #endif

Если после (#if) константное выражение принимает истинное значение, то код между #if и #endif компилируется, в противном случае код пропускается. Директива #endif используется для обо­значения конца блока #if.
Стандартный вид #if следующий:

//Например: /* простой пример с #if */ #include #define MAX 100 void loop() < #if MAX>99 Serial.println(«Скомпилировано для массива больше 99.n»); #endif return 0; >

Данная программа выводит сообщение на экран, поскольку, как определено в программе, МАХ имеет значение больше 99. Данный пример демонстрирует очень важный момент: выражение, следующее зa #if, вычисляется на этапе компиляции, следовательно, оно должно содержать ранее определенные идентификаторы и константы, а не переменные.

Работа (#else) во многом похожа на работу оператора else — она предоставляет альтернативный вариант, если #if содержит ложное состояние. Предыдущий пример можно расширить следую­щим образом:

/* простой пример с #if / #else */ #include #def ine MAX 10 void loop()< # if MAX>99 printf(«Скомпилировано для массива больше 99.n»); #else printf(«Скомпилировано для небольшого массива.n»); #endif return 0; >

В данном случае MAX определяется так, чтобы значение было меньше 99, в результате чего ком­пилируется не код, соответствующий #if, а код, соответствующий #else. Следовательно, выводится сообщение «Скомпилировано для небольшого массива».

Обратим внимание, что #else используется для обозначения конца блока #if и начала блока #else. Это делается потому, что может быть только один #endif, связанный c #if.

(#elif) означает «иначе если» и используется для построения лесенки if-else-if с целью определе­ния различных опций компиляции. За #elif следует константное выражение. Если выражение истинно, то блок кода компилируется и остальные выражения не проверяются. В противном слу­чае рассматривается следующий блок.

#define US 0 #define ENGLAND 1 #define FRANCE 2 #define ACTIVE_COUNTRY US #if ACTIVE_COUNTRY==US char currency[] = «dollar»; #elif ACTIVE_COUNTRY==ENGLAND char currency[] = «pound»; #else char currency[] = «franc»; #endif

Другой метод условной компиляции состоит в использовании директив (#ifdef) и (#ifndef), что соответственно означает «если определено» и «если не определено».

Стандартный вид #ifdef следующий:

#ifdef имя_макроса
последовательность операторов
#endif

Если имя макроса определено ранее в операторе #define, то последовательность операторов, стоящих между #ifdef и #endif, будет компилироваться.

Стандартный вид #ifndef следующий:

#ifndef имя_макроса
последовательность операторов
#endif

Если имя макроса не определено ранее в операторе #define, то последовательность операторов, стоящих между #ifdef и #endif, будет компилироваться.

Kaк #ifdef, так и #ifndef могут использовать оператор #else, но нe #elif. Например:

#include #define TED 10 void setup ()

выводит «Привет тед» и «РАЛЬФ не определен». Если TED не определен, то выведется «Привет всем», a за ним «РАЛЬФ не определен».

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

for (byte r = 0; r < 255; r++) < for (byte g = 255; g >-1; g—) < for (byte b = 0; b < 255; b++) < if (analogRead(0) >250) < // уйти из сравнений goto bailout; >// еще код > > > bailout: // перенеслись сюда

Оператор прерывания функции, он же оператор возврата значения из функции.

Источник: technogeeks.ru

Урок 7.3- Подпрограммы управления на кнопках

В прошлом уроке мы подключили LCD и научились извлекать звук из Ардуино. Т.е. фактически мы уже сделали полдела для полного функционала задуманных часов! Теперь пришло время разобраться с управлением к нашему контроллеру. Не будем тянуть кота за… бубенчики, переходим сразу к теме разговора.

Кнопочное управление.

Как и было сказано выше в нашем проекте будет 3 кнопки которые будут выполнять следующие функции: Слева- МИНУС, Середина- МЕНЮ, Справа- ПЛЮС. Про управление поговорим позже когда будем привязывать кнопки к требуемым функциям, сейчас нам надо указать контроллеру что мы нажимаем, например, кнопку МИНУС а не какую другую.

Опять же для решения данной задачи есть несколько путей. Начнем с самого легкого. Собираем любую схему как было написано в уроке 7.1. Теперь давайте проследим какие значения нам будут выдавать кнопки при нажатии. Давайте вместе напишем простейшую программу для отслеживания состояния порта А0 и выводом значений в Serial. Попробуйте сами написать без моей подсказки.

Если не можете- давайте писать вместе пошагово.

Serial . begin (9600);// подключаем Serial

Serial . println ( analogRead (A0));// выдаем в порт все что мы считали с порта

Данная программа содержит ВСЕГО 6 строк и начнет читать данные и с огромной скоростью передавать на монитор Serial значения считанные с порта А0 что не всегда удобно и вызывает рябь в глазах. Давайте допишем условие что пока на входе логический ноль данные не передаем.

Схема подключения кнопок к часам на АРДУИНО логический ноль нам обеспечит резистор который подключен напрямую к минусовому проводу в цепи управления кнопок. В данной схеме это резистор R5. При нажатии кнопок напряжение на А0 повысится в соответствии с подключенными резисторами в резистивном делителе, и вот на этом событии можно поставить условие на вывод.

Давайте посчитаем грубо. У нас 4 резистора по 1 кОм подключены к 5 В. На каждом резисторе напряжение составляет 5 Вольт/ 4 резистора= 1,25В. Это если не учитывать резистора R5 который дополнительно зашунтирует входную цепь входа А0.

Serial . begin (9600);// подключаем Serial

if ( analogRead (A0)>5)//если напряжение больше 5 бит

Serial . println ( analogRead (A0));// выдаем в порт все что мы считали с порта

Вам может показаться странным строка if ( analogRead (A0)>5)//если напряжение больше 5 бит и как напряжение может оказаться больше 5 бит. Оно же измеряется в Вольтах. И вы будете правы. НО!

Как было написано раньше, максимальное напряжение на входах Ардуино- 5В, вход А0- 10 битный, т.е. он раскладывает напряжение 5 Вольт на 1024 ступеньки по (5 Вольт/ 1024 бит)=0,00488 Вольт и прописав в условии analogRead (A0)>5 мы отбрасываем помехи до (0,00488 Вольт* 5 бит)= 0,0244 Вольта, которые могут вызвать ложное срабатывание операторов Serial . println ( analogRead (A0));// выдаем в порт все что мы считали с порта. Кроме того вы, возможно, обратили внимание что при нажатии кнопки всего ОДИН раз вылетает целый список разных значений. Добавьте после строки Serial . println ( analogRead (A0));// выдаем в порт все что мы считали с порта в новой строке delay (100); и вы будете получать по 1 значению каждые 100 миллисекунд. При нормальном нажатии получится всего лишь одно значение. Этот прием мы тоже будем использовать при написании обработчика нажатий кнопок.

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

Например: вы отладили часы на 5 В, затем подключили их к литиевому аккумулятору напряжением 4,2 В, соответственно все значения кнопок, которые вы прописали в контроллер могут уплыть и кнопки просто перестанут работать (на самом деле не должны так как в программе мы будем ставить условия на биты а не напряжение), или вы собрали готовое устройство а кнопки при сборке перепутали местами, или после сборки делителя запаяли не те резисторы. Это конечно не так страшно но можно немного заморочиться и сделать так что ничего паять и перепрограммировать не придется. Начнем осваивать более сложный, но и более гибкий путь, тем более что в проектах не всегда используются 3-4 кнопки. При использовании большого количества головная боль по прописыванию кнопок становится просто дикой.

Суть данного способа заключается в том что при старте контроллер проверяет свою память в секции setup на наличие ячеек со значением ноль (ничего не записано) и если там действительно находится ноль то переходит к функции присваивания значений кнопкам. Если же при проверке памяти значение ячейки отличается от ноля то просто считываем данные из ячеек и присваиваем кнопкам!

Все вроде просто до смешного, НО! Ячейки памяти могут вместить в себя 256 байт т.е. 8 бит информации, порт А0 как и все входы Ах 10 битный и «впихнуть» 1024 бита в 256 бита просто не получится. Выходов, как всегда, много, например выделять на одну кнопку четыре ячейки памяти (4 ячейки *256 бит)=1024 бит, просто складывать их и получать значение кнопок, можно просто посчитать до значения отклонения.

Как это объяснить. Ну например нажатие кнопки S2 подаст на вход А0 517 бит, что больше 256 в 2 раза и еще остается 5 бит, иначе говоря 517=256+256+5. Т.к. 1024 бита содержит в 4 раза больше информации чем 256 бит то делим полученное значение на 4, т.е. 517/4=129,25, контроллер округлит это до 129 и запишет 129 в нужную ячейку.

При прочтении ячейки контроллер должен уже умножить значение ячейки на 4, в итоге мы получим 129*4=516. Вроде уже меньше на 1 бит но в нашем случае это не критично (посмотрите выше на картинку- значения плавают в довольно большом пределе). Обработчик нажатия кнопок будет содержать условие на небольшое отклонение от изначально полученного.

Т.е. значение в пределах ±20 бит от полученного будут считаться нажатием на данную кнопку. Почему именно 20 и вообще зачем это нужно? Ну 20- это величина отклонения, вы можете указывать и большую и меньшую но при больших количествах кнопок следует ее уменьшить чтобы исключить возможность ложного срабатывания соседних по пределу кнопок, кроме того никто не защищен от дребезга контактов кнопок, а данное отклонение позволяет немного расширить предел срабатывания кнопок. Надеюсь на скриншоте выше видно, как значения при нажатии кнопки меняются от 239 до 255. Вероятность что вы попадете точно в указанное вами значение очень велика, но можно просто указать предел отклонения и ни о чем больше не думать нежели контроллер будет считать и улавливать передаваемые значения.

Кроме того данный способ можно еще модернизировать. Для это можно воспользоваться командами highByte и lowByte. Как работают данные операторы рассмотрим на примере ниже который я использовал в проекте паяльной станции:

iValue = analogRead (A2); // число > 255 разбиваем на байты (макс. 65536)
byte hi = highByte (iValue); // старший байт
byte low = lowByte (iValue); // младший байт

Видим что переменная iValue принимает значение пришедшее с порта А2, примем её как в примере выше равной 517. Дальше происходит присвоение переменной hi старшего байта. Что это означает. Это значит что программа делит данное число на 256 и выделяет целую часть. Иначе говоря в нашем случае мы 517 делим на 256, получается 2,01953125.

Переменная hi будет равна 2 т.к. целая часть из получившегося произведения равна 2. Дальше присваиваем переменной low значение младшего байта, иначе говоря остаток от деления. Повторю пример выше 517= А х 256 + В, где А-старший байт, В- младший байт или в нашем случае 517=2 х 256 + 5. Младший байт в нашем случае будет равен 5. Эти две переменные мы записываем в память и обратно собираем оператором word . В результате опять получаем посланное ранее значение. В отличии от описанного выше мы получаем точное значение.

int val = word (hi, low); // собираем значение по указанным ячейкам

Единственно что вы должны запомнить- значение не должно быть больше 65536, иначе вам придется делить старший байт снова и использовать для записи уже не 2 ячейки а 3.

Итак мы имеем- рабочую схему из 3 кнопок, значения этих самых кнопок. Осталось только запомнить эти самые значения. Опять же повторюсь, вы можете напрямую занести значения кнопок в скетч и ни о чем больше не думать но мы не ищем легких путей и поэтому сделаем универсальный скетч для ЛЮБОГО подключения кнопок!

Давайте подключим еще одну библиотеку, которая будет работать с памятью Ардуино. Ничего скачивать уже не надо, данная библиотека есть в наличии в интерфейсе Ардуино и поэтому делаем следущее: Ардуино- Скетч- Подключить библиотеку- EEPROM.

У вас появится в самом верху надпись # include , что означает что вы подключили библиотеку для работы с энергонезависимой памятью Ардуино. Что значит энергонезависимой? Т.е. при отключении питания данные в EEPROM остаются неизменными и не стираются как оперативные данные. Теперь мы можем указать что мы хотим сделать с памятью- записать в нее или напротив- считать. Теперь применив оператор EEPROM . write (2, hi); мы запишем в ячейку номер 2 значение старшего байта из примера выше и EEPROM . write (3, low); значение младшего байта в ячейку 3.

Считать эти значения мы можем операторами:

byte hi= EEPROM . read (2); // считываем значение из 2 ячейки
byte low= EEPROM . read (3); // считываем значение из 3 ячейки

и затем опять же пересобрать

int val = word (hi, low); // собираем значение по указанным ячейкам