#статьи
-
0
Платы, лампы, провода — это всё любовь моя!
Иллюстрация: Оля Ежак для Skillbox Media
Автор статей о программировании, технологиях и гаджетах. Пишет код на JavaScript и Python. Любит веб-технологии, модные приложения и магию Apple.
Если вы всегда мечтали создавать собственные гаджеты, но не умеете паять платы, обратите внимание на Arduino. Это универсальная платформа для разработки электронных устройств любой сложности. На её основе можно собрать робота, клавиатуру, умный чайник или радиоуправляемую машинку.
В этой статье рассказываем про Arduino: что это такое, для чего нужно и как его программировать. А ещё объясняем, какую плату выбрать новичку, и даём ссылки на полезные материалы.
Содержание
- Что такое Arduino
- История Arduino: скандалы, интриги, торговые войны
- Анатомия платы
- Какую плату Arduino выбрать
- Какое ещё железо нужно ардуинщику
- IDE для Arduino
- Как программировать Arduino
- Как загрузить прошивку на плату
- Мигаем светодиодом: первый проект на Arduino
- Усложняем проект: добавляем управление
- Что делать дальше
- Дополнительные материалы
Arduino — это платформа для разработки электронных устройств. Она идеально подходит для изучения программирования, электроники, сборки прототипов реальных гаджетов и хобби-проектов. Платформа включает в себя:
- аппаратную часть — плату с микроконтроллером, например Arduino Uno;
- программную часть — бесплатную среду разработки Arduino IDE и встроенные библиотеки, которые упрощают работу с оборудованием.
Изображение: Arduino
Главная фишка Arduino — доступность и простота. Для начала работы достаточно самой платы, USB-кабеля и компьютера. Благодаря множеству готовых библиотек и простому языку программирования даже новичок может за вечер собрать рабочее устройство — например, колёсного робота.
Вот примеры других устройств, собранных на Arduino:
В начале 2000-х компании Telecom Italia и Olivetti открыли в итальянском городе Ивреа курсы по дизайну взаимодействия. Студентов учили проектировать устройства с удобными интерфейсами, опираясь на поведение пользователей.
На курсах студенты работали с платформой BASIC Stamp. Код приходилось писать на PBASIC — диалекте языка программирования BASIC, что было довольно сложно для людей, которые по складу ума больше дизайнеры, чем программисты.
Фото: Marcin1988 / Wikimedia Commons
Выпускник курса Эрнандо Барраган решил изменить ситуацию: в 2004 году он разработал альтернативную платформу Wiring — плату с прошивкой и поддержку программирования на упрощённом C++. Разработка гаджетов стала проще и быстрее.
Важно, что Wiring и последовавшая за ним Arduino распространялись с открытым исходным кодом. Это позволило сообществу адаптировать и развивать проект, а также стало основой для десятков совместимых платформ.
Фото: Hernando Barragán
Платы Wiring за короткий период стали очень популярны на курсе, но оставались дорогими — около 60 долларов за плату. Тогда научный руководитель Баррагана Массимо Банци сделал форк проекта: использовал более дешёвый микроконтроллер ATmega8, но оставил программную часть Wiring. Так появился прототип Arduino, сначала называвшийся Wiring Lite.
Фото: Hernando Barragán
Название Arduino команда выбрала в честь местного бара, где собирались студенты и преподаватели. Сам бар был назван в честь короля Италии Ардуина Иврейского.
В 2008 году Банци зарегистрировал в США компанию Arduino LLC, которой принадлежали права на бренд. Платы производились сторонними фабриками по лицензии.
Важно, что Wiring и последовавшая за ним Arduino распространялись с открытым исходным кодом. Это позволило сообществу адаптировать и развивать проект, а также стало основой для десятков совместимых платформ.
Когда популярность Arduino начала расти, команде понадобилось открывать юрлица в других странах. Но при попытке зарегистрировать компанию в Италии выяснилось, что бренд Arduino там уже оформлен — на Джанлуку Мартино, одного из сооснователей проекта и владельца завода, производившего платы. Оказалось, что он тайно регистрировал компании с названием Arduino SRL в разных странах.
Суть конфликта была в том, что руководство Arduino LLC выбрало бесфабричную модель производства: при таком подходе инженеры проектируют платы и инструменты, а изготовление может взять на себя любая фабрика. Мартино же боялся, что его завод не сможет конкурировать с китайскими производителями, и хотел сохранить производство на собственном заводе.
Это привело к тому, что Arduino LLC могла продавать свои платы только в США, а Arduino SRL — в остальных странах. Торговая война продолжалась до 1 октября 2016 года. Тогда на конференции World Maker Faire Массимо Банци и Федерико Мусто, гендиректор Arduino SRL, объявили о слиянии компаний в одно юрлицо — Arduino AG.
Фото: Arduino Team
Сейчас Arduino выпускает платы и готовые наборы для энтузиастов, университетов и школ программирования. Также у компании есть линейка промышленных контроллеров, которые используют для автоматизации складов и заводов. Один из главных принципов Arduino — разрабатывать недорогие платы, чтобы создание умных устройств было доступным увлечением.
Рассмотрим, какие пины, интерфейсы и кнопки есть на плате Arduino. Мы покажем всё на примере третьего поколения Uno. Более детально устройство платы можно изучить в официальной документации.
Фото: Skillbox Media
На фотографии выше:
- Кнопка перезагрузки (1) — кнопка для перезапуска загруженного кода, если, например, плата перестала корректно реагировать на команды.
- Цифровые пины (2) — универсальные пины, которые могут генерировать и считывать сигналы. К ним можно подключать датчики, моторы, кнопки и другие элементы управления.
- Коннектор USB-B (3) — порт, с помощью которого плату можно подключить к компьютеру и прошить.
- Контроллер ATmega328P (4) — «мозг» Arduino Uno, который выполняет все вычисления и операции. Можно сказать, что он здесь вместо процессора и памяти, — как центральный блок у обычного компьютера, только компактнее и проще.
- Коннектор питания (5) — порт для подключения платы к аккумулятору или розетки.
- Пины питания (6) — пины, с помощью которых можно запитать датчики, моторы и другие элементы, подключённые к Uno.
- Аналоговые пины (7) — пины, которые могут только считывать сигналы. Подходят для подключения датчиков.
Каждый цифровой и аналоговый пин имеет свои ограничения по току и напряжению, поэтому перед подключением внешних устройств стоит свериться с технической документацией.
Платы Arduino могут различаться по количеству пинов, форм-фактору и мощности. Ниже расскажем, какие модели бывают и как выбрать подходящую.
В интернет-магазине компании доступно несколько десятков плат для разработки роботов, умных устройств, компактных гаджетов и промышленного оборудования. В таком разнообразии легко запутаться, поэтому давайте разберём особенности самых популярных решений Arduino, чтобы вы знали, что точно стоит купить в личную мастерскую.
Микроконтроллер: ATmega328P
Память: 32 КБ флеш-памяти и 2 КБ SRAM
Для каких проектов подходит: для роботов и любых умных устройств
Цена: 27–55 долларов
Документация
Изображение: Arduino Docs
Arduino Uno — одна из самых популярных и универсальных плат. На ней достаточно портов для подключения большого количества датчиков, моторов, сервоприводов и контроллеров. Если хотите начать изучать программирование для Arduino, смело покупайте Uno. Этой платы хватит как для учебных экспериментов, так и для полноценных проектов.
Микроконтроллер: ATmega328
Память: 32 КБ флеш-памяти и 2 КБ SRAM
Для каких проектов подходит: для компактных устройств
Цена: 15–40 долларов
Документация
Изображение: Arduino Docs
Arduino Nano — компактная версия Uno. У неё меньше портов и меньше памяти, зато она без проблем поместится в корпусе практически любого устройства. Ещё один плюс платы в том, что её можно разместить на макетной плате.
Микроконтроллер: ATmega2560
Память: 256 КБ флеш-памяти и 8 КБ SRAM
Для каких проектов подходит: для устройств с большим количеством датчиков
Цена: 50–70 долларов
Документация
Изображение: Arduino Docs
Arduino Mega — плата с большим количеством пинов, более мощным микроконтроллером и увеличенным объёмом памяти. Она отлично подходит для сложных проектов, в которых нужно много датчиков и ресурсоёмких вычислений, например для шагающих роботов с парой десятков сервоприводов. Плата дорогая, поэтому нет смысла брать её для обучения. На первых порах хватит возможностей Uno.
Микроконтроллер: ATmega32U4
Память: 32 КБ флеш-памяти и 2,5 КБ SRAM
Для каких проектов подходит: для клавиатур, мышек и контроллеров
Цена: 22 доллара
Документация
Изображение: Arduino Docs
Arduino Micro — компактная плата с поддержкой режима работы HID (human interface device — устройство человеческого интерфейса). Это значит, что на базе Micro можно собрать собственную клавиатуру, мышку, руль для симулятора гонок или контроллер для игровой консоли.
Arduino разрабатывает платы не только для обучения и хобби-проектов. У компании есть профессиональная линейка Arduino Pro для промышленных устройств. Их используют для автоматизации процессов на заводах и складах. Устройства с приставкой Pro обычно выпускают в чёрном цвете, а обычные — в синем.
В линейку Arduino Pro входят следующие семейства:
- Portenta — набор высокопроизводительных плат и модулей для промышленных проектов. Они могут одновременно выполнять низкоуровневый код и скрипты на MicroPython или JavaScript.
- Nicla — компактные платы для ИИ-проектов с низким энергопотреблением. Например, на базе платы Nicla Vision можно собрать систему для автоматической сортировки заказов на складе.
- Opta — серия программируемых логических контроллеров в форм-факторе microPLC. У них есть Ethernet, Wi-Fi, Bluetooth и крепление для DIN-рейки, позволяющее устанавливать устройство в электротехнические шкафы.
На маркетплейсах можно встретить множество плат, которые очень похожи на Arduino, но называются по-другому. Нет, это не подделки, а вполне легальные и рабочие устройства.
Практически все платы компании и прошивки выпускаются под открытой лицензией Creative Commons Attribution ShareAlike. Это значит, что любой желающий может создавать собственные платы Arduino — в помощь разработчикам компания публикует на официальном сайте схемы, чертежи и документацию. А ещё в компании не против того, чтобы крупные производители запускали серийное производство аналогов. Главное условие: не использовать название Arduino, его производные и логотип. Все эти атрибуты защищены авторским правом.
Изображение: Arduino Docs
Например, российская компания «Амперка» выпускает платы Iskra — это аналоги Arduino с небольшими доработками, которые изготовлены по официальным чертежам. Arduino не против таких решений на рынке.
Кадр: AmperkaRu / YouTube
При этом важно учитывать, что не все производители добросовестно соблюдают лицензии и соглашения. На маркетплейсах можно найти множество плат Arduino, цены на которые значительно ниже, чем на официальном сайте. Скорее всего, это подделки китайских компаний, которые решили использовать логотип Arduino, несмотря на запрет. Они часто изготовлены из некачественных материалов или с нарушением технологии производства, поэтому быстро приходят в негодность.
Если вы увидели «оригинальную» плату с большой скидкой, то сперва проверьте, не пытаются ли вам продать подделку. Для этого можно использовать официальное руководство от команды Arduino.
Изображение: Arduino
В проектах лучше использовать оригинальные платы или аналоги компаний, которые дорожат своей репутацией. Платы китайских «ноунеймов» практически всегда оказываются некачественными, но стоят в 5–10 раз меньше. С другой стороны, если ваша цель — просто попробовать себя в разработке на Arduino, то можно сэкономить.
Одной платы не хватит для того, чтобы создавать интересные проекты. Плата — это мозг, которому нужны другие органы. Давайте рассмотрим список инструментов и устройств, без которых нельзя обойтись.
К платам Arduino можно подключать сторонние модули, датчики и сенсоры. Например, если вы хотите собрать метеостанцию, то надо будет докупить термометр, барометр и анемометр. А для робота нужна будет камера, дальномер и моторы.
Фото: Skillbox Media
Сенсоры и модули подбирают под конкретное устройство на этапе проектирования. Не стоит сразу покупать всё, что только можно подключить к плате, — формируя набор дополнительных устройств, отталкивайтесь от задачи. Со временем у вас и так накопится большая коллекция электронных полезностей.
Модули и датчики можно подключать сразу к плате, но это не всегда удобно. Например, сенсор может перекрывать собой соседние пины. Для решения этой проблемы используют макетные платы — универсальные пластины для быстрого монтажа компонентов и создания прототипов.
Для экспериментов удобнее использовать макетные платы без пайки — их ещё называют бредбордами (от англ. breadboard). На этой плате контакты разведены так, чтобы к ней можно было подключить несколько модулей.
Фото: Skillbox Media
Если захотите собрать собственный модуль, можно использовать макетную плату с пайкой. Она представляет собой обычную печатную плату со свободными пинами, на которой можно смонтировать любые электронные компоненты.
Модули и сенсоры надо чем-то соединять между собой на макетной плате и подключать к Arduino. Для этого используют кабели типа Dupont трёх видов: «папа — папа», «мама — мама» и «мама — папа».
Фото: Skillbox Media
Интересный факт: Dupont — это не официальное название коннектора. В начале XXI века китайские производители начали осваивать массовое производство соединительных кабелей и для изоляции использовали материалы американской химической компании DuPont. В итоге название прижилось на бытовом уровне, и сейчас любые коннекторы с шагом 2,54 мм называют кабелями Dupont.
Шилд (от англ. shield — щит) — плата расширения, которая подключается к Arduino и даёт новые возможности. Например, с помощью шилда можно добавить поддержку Wi-Fi или GPS, если изначально их не было.
Фото: Skillbox Media
Как правило, связка из нескольких модулей может заменить собой шилд, но такая конструкция будет не очень аккуратной и компактной. Платы расширения чаще используют в образовательных целях — например, на курсах по разработке для Arduino. Простой способ крепления шилдов позволяет ученикам сосредоточиться на коде.
Для монтажа электронных компонентов и сборки финального устройства могут понадобиться дополнительные инструменты:
- Паяльник. После экспериментов на бредборде электрическую схему проекта можно перенести на печатную макетную плату. Для этого понадобится паяльник, припой, канифоль и флюс.
- «Третья рука». Во время пайки не всегда удобно одновременно держать раскалённый паяльник, припой, плату и элемент, который вы собираетесь припаять. На помощь в таких случаях приходит «третья рука» — штатив, который позволяет закрепить все необходимые элементы и работать с ними.
Фото: Dro Kulix / Wikimedia Commons
- Набор пинцетов. Электронные компоненты могут быть очень мелкими, и брать их руками не всегда удобно. Лучше использовать пинцеты, чтобы случайно ничего не сломать.
Программировать Arduino можно в любом редакторе кода, но удобнее делать это в специальных средах. В них есть инструменты, благодаря которым разработка становится быстрее и проще. Давайте рассмотрим популярные IDE и редакторы кода для Arduino.
Скриншот: Arduino IDE / Skillbox Media
Arduino IDE — официальная среда разработки от команды Arduino. В ней есть все необходимые инструменты для удобной работы с одноимёнными платами. Можно писать код, отлаживать его, оптимизировать, загружать на платы и запускать.
Важно отметить, что есть две версии официальной среды разработки: обновлённая Arduino IDE 2 и устаревшая Arduino IDE Legacy. Обе работают, но во второй доступны не все современные функции — например, нет поддержки автоматического завершения кода и синхронизации файлов с облачным хранилищем.
Скриншот: Arduino Cloud / Skillbox Media
Arduino Cloud — облачная платформа для удалённого управления подключёнными платами. В основном её используют для развёртывания самодельных IoT‑устройств, но на платформе есть и встроенный редактор кода. С его помощью можно также писать скетчи, отлаживать их и загружать на платы прямо в браузере. Одно из преимуществ Arduino Cloud в том, что редактор можно открыть даже на смартфоне.
Скриншот: Arduino Cloud / Skillbox Media
Скриншот: Visual Studio Code / Skillbox Media
Platform IO — плагин, который превращает редактор кода, например VS Code, в IDE для работы с Arduino. Благодаря Platform IO в редакторе появляется дебагер, анализатор кода, функции для тестирования и возможность прошивать плату.
Плагин бесплатный и доступен для всех популярных IDE и редакторов кода. Есть даже версия для Vim, которая запускается в терминале.
Скриншот: Platform IO
Код для Arduino пишут на языке программирования Arduino C — это сочетание C++ и фреймворка Wiring. Файлы с кодом разработчики называют скетчами (от англ. sketch — набросок).
В этой статье мы рассмотрим только основы программирования Arduino. Если вы хотите стать гуру разработки, то предлагаем добавить в закладки наш ультимативный гайд по C++ в пяти частях:
Программы для Arduino пишут по шаблону, который выглядит так:
#include <Example.h> void setup() { } void loop() { }
В нём:
- #include <Example.h> — директива для подключения сторонних библиотек или связывания нескольких файлов одного проекта.
- void setup() — функция, в которой инициализируют пины платы и указывают режимы их работы.
- void loop() — цикл с основным кодом программы. В нём разработчики описывают логику прошивки и используют пины, которые инициализировали в функции setup().
Функции setup и loop — обязательная часть каждого скетча. Без них компилятор не сможет собрать проект.
В Arduino C, как и в любом другом языке программирования, есть переменные. В них можно хранить данные с датчиков, промежуточные вычисления или параметры пинов. Чаще всего разработчики используют следующие типы переменных:
- int — целые числа в диапазоне от −32768 до 32767.
- long — целые числа в диапазоне от −2147483648 до 2147483647.
- float — числа с плавающей точкой, в которых можно хранить значения с точностью до семи знаков после запятой.
- byte — отдельные символы из ASCII-таблицы.
- String() — строки из нескольких символов.
- bool — логические значения true или false.
Примеры:
int number = 2025; long bignumber = 2147483647; float pi = 3.141592; char byte = 'A'; String mystr = String("Hello World"); bool mybool = true;
В языке Arduino C есть все привычные математические операторы. С их помощью можно вычислять значения и присваивать результаты переменным:
| Оператор | Описание | Пример |
|---|---|---|
| = | Присваивание значения переменной | a = 256 |
| + | Сложение | 100 + 83 |
| — | Вычитание | 45 — 2 |
| * | Умножение | 5 * 12 |
| / | Целочисленное деление | 100 / 10 |
| % | Остаток от деления | 43% 4 |
Для сравнения значений используют операторы сравнения. Они возвращают true (истина) или false (ложь):
| Оператор | Описание | Пример |
|---|---|---|
| == | Равно | a == b |
| != | Не равно | a != b |
| < | Меньше | a < b |
| > | Больше | a > b |
| <= | Меньше или равно | a <= b |
| >= | Больше или равно | a >= b |
Для управления потоками программы в Arduino C предусмотрены условные операторы и циклы:
- if-else — оператор «если», с помощью которого можно реализовать несколько сценариев и запускать их в зависимости от условий. Если условие оператора if соблюдается, то система выполняет его. В остальных случаях выполнится условие else if.
if (sensor > 800) { // выполняется, если значение > 800 digitalWrite(LED_BUILTIN, HIGH); } else if (sensor > 400) { // если 400 < значение ≤ 800 analogWrite(LED_BUILTIN, 128); } else { // в других случаях digitalWrite(LED_BUILTIN, LOW); }
- for — цикл для повторного выполнения одного и того же действия. Например, с его помощью можно пройтись по массиву светодиодов и поморгать каждым.
for (int i = 0; i < 10; i++) { // выполнится 10 раз, i от 0 до 9 digitalWrite(LED_BUILTIN, (i % 2 == 0) ? HIGH : LOW); delay(200); }
- while — цикл, который выполняется до тех пор, пока его условие истинно.
int count = 0; while (count < 5) { // выполняется, пока count < 5 Serial.println(count); count++; delay(300); }
- do-while — цикл, который сначала выполняет действие, а потом проверяет условие завершения.
int val; do { val = analogRead(A1); Serial.println(val); delay(500); } while (val < 500); // цикл обязательно выполнится хотя бы один раз
Для удобства программы можно разделять на функции — блоки кода, которые выполняют определённое действие, возвращают результат и доступны в любом месте программы. Представьте, что вы собираете лазерный прибор для измерения расстояния. Датчик передаёт значения в метрах, но на экран надо ещё выводить километры и футы. Операции перевода значений можно вынести в отдельную функцию и вызывать в любом месте кода.
В общем виде функции в Arduino выглядят следующим образом:
тип_возвращаемого_значения имя_функции (аргументы) { // тело_функции return возвращаемое_значение; }
В ней:
- тип_возвращаемого_значения — тип данных, который функций возвращает в результате работы;
- имя_функции — название, с помощью которого функцию можно будет вызывать;
- аргументы — переменные, которые функция получает на вход;
- тело_функции — основной код функции.
- return возвращаемое_значение — значение, которое функция вернёт после работы.
Для примера напишем функцию, которая принимает два числа, вычисляет их сумму и выводит в терминал сообщение о том, чётная ли сумма или нет:
void printSumParity(int a, int b) { int sum = a + b; if (sum % 2 == 0) { Serial.println("Чётная сумма"); } else { Serial.println("Нечётная сумма"); } }
Перед тем как начать писать код, давайте разберёмся, как этот код загрузить на плату:
- Шаг 1. Подключите плату к компьютеру с помощью USB-кабеля.
- Шаг 2. В Arduino IDE откройте выпадающий список Select board и выберите в нём вашу плату.
- Шаг 3. Нажмите на кнопку со стрелкой, которая расположена слева от выпадающего списка.
- Шаг 4. Если всё прошло успешно, то в терминале появится сообщение «Done uploading» и сведения о том, сколько памяти занял скетч.
Многие разработчики в качестве своей первой программы пишут код, который выводит на экран фразу «Hello, world!». У микроконтроллеров нет экранов, поэтому выводить приветствие некуда. При этом в сообществе разработчиков есть аналог «Hello, world!» — программа Blink, которая мигает одним из светодиодов на плате.
С помощью такой простой программы можно проверить сразу три вещи. Если светодиод мигает:
- плата точно работает, а электронные компоненты не повреждены;
- компилятор правильно настроен и собирает код под нужную платформу;
- компьютер без ошибок загружает прошивку на плату.
Давайте напишем код программы Blink и загрузим его на Arduino, чтобы убедиться, что всё работает:
Для сборки нам понадобится:
- любая плата Arduino (у нас Uno R3);
- светодиод;
- резистор номиналом 220 Ом;
- провода типа «папа — папа»;
- макетная плата.
Все компоненты соединяем следующим образом:
Инфографика: Skillbox Media
Должна получиться похожая конструкция:
Код для мигания светодиодом выглядит так:
void setup() { // Инициализируем пины pinMode(13, OUTPUT); } // Функция loop бесконечно выполняется по кругу void loop() { digitalWrite(13, HIGH); // Включаем светодиод delay(1000); // Ждём одну секунду digitalWrite(13, LOW); // Выключаем светодиод delay(1000); // Ждём одну секунду }
В коде выше мы используем три функции, не считая setup() и loop(), без которых компилятор не сможет собрать скетч:
- pinMode(pin, mode) — функция для настройки режима работы цифрового пина. На вход она принимает два аргумента: pin и mode. В первом надо указать номер пина, во втором — режим работы. Мы выбрали пин под номером 13 и сделали его выходным (OUTPUT).
- digitalWrite(pin, value) — функция для подачи напряжения на пин, указанный в аргументе pin. Во втором аргументе надо выбрать значение, которое подаётся на пин: HIGH или LOW.
- delay() — с помощью этой функции можно на время приостановить выполнение кода. Для этого в скобках надо указать длительность паузы в миллисекундах. Забавный факт: максимальное значение — 4 294 967 295 мс, что составляет 49 дней, но на практике никто не ставит паузу больше нескольких секунд
Если всё сделали правильно, то при подключении питания к плате должен мигать наш светодиод:
Теперь усложним проект: сделаем так, чтобы светодиод горел постоянно, а с помощью кнопки его можно было бы выключать.
Схема устройства выглядит следующим образом:
Должно получиться такое устройство:
Код проекта выглядит так:
void setup() { // Инициализируем пины pinMode(13, OUTPUT); pinMode(9,INPUT); } // Функция loop бесконечно выполняется по кругу void loop() { // включаем светодиод при нажатой кнопке if(digitalRead(9) == HIGH) { digitalWrite(13, HIGH); } else { digitalWrite(13, LOW); } }
Если всё сделали правильно, то с помощью кнопки можно будет управлять светодиодом:
Если вы собрали проекты из этой статьи и теперь хотите попробовать что-нибудь посложнее, то обратите внимание на наше руководство по созданию робота. В нём мы показываем, как сконструировать и запрограммировать управляемую мини-платформу.
Также на базе Arduino есть множество проектов с открытым кодом, которые вы можете повторить:
- ArduSat — миниатюрный космический спутник;
- Arduboy — портативная игровая консоль.
- ArduPilot — система автопилота для дронов, самолётов, лодок и марсоходов.
- OpenEVSE — зарядная станция для электромобилей.
Практический курс: «Программист микроконтроллеров»
Узнать о курсе
Arduino — программирование, которое можно потрогать. Плата позволяет не только поработать с кодом, но и реализовать его в физическом мире. Например, запрограммировать плату помигать светодиодами или сделать из нее музыкальный инструмент. Разбираемся, как начать программировать на Arduino с нуля, какие IDE подходят для работы с платой и приводим примеры кода.
Что такое Arduino
Arduino — аппаратная платформа на базе микроконтроллера, предназначенная для разработки умных устройств и автоматизированных систем. С помощью Arduino можно запрограммировать собственный дверной замок с магнитным ключом, построить робота с распознаванием голосовых команд или собрать автоматическую кормушку для питомца. К основной плате можно подключать дополнительные модули от сторонних производителей. Так систему можно оснастить дисплеем, датчиками, аккумуляторами и беспроводной связью.
Arduino придумали в Италии в начале 2000-х годов. Разрабатывали систему для быстрого и легкого обучения программированию и схемотехнике, поэтому платформу изначально делали гибкой, чтобы ее можно было использовать в любых школах и кружках.
Все разработки Arduino открыты для использования, поэтому, кроме оригинальных плат, можно найти китайские копии. Компания всегда публикует чертежи своих разработок, схемотехнику и программную часть. В результате копии практически ничем не уступают платам из Италии.
На чем программируют Arduino
Код для всех плат семейства Arduino пишется на языке Arduino, созданном на базе C++ и фреймворка Wring. Создатели платформы выбрали C++ из-за скорости работы и высокой эффективности при разработке для устройств с ограниченным количеством памяти. Фреймворк Wring отвечает за управление аппаратной частью Arduino. Код компилируется с помощью avr-gcc.
Некоторые платы поддерживают программирование на языке MicroPython. Для этого нужно самостоятельно установить все необходимое окружение и подготовить аппаратную часть контроллера к обработке такого кода.
Программировать удобнее всего в интегрированных средах разработки. У плат семейства Arduino есть Arduino IDE. Приложение доступно для Windows, Linux и macOS. В нем собрали все инструменты, которые могут пригодиться во время разработки собственных проектов. В Arduino IDE можно писать код, оптимизировать работу платы, получать данные об эффективности кода, устанавливать сторонние библиотеки и разрабатывать свои. Arduino IDE можно скачать с официального сайта компании, код проекта открыт и опубликован на GitHub.
Если нет возможности установить Arduino IDE, то программировать плату можно в браузере, в облачной среде разработки. В ней поддерживается работа с кодом, отправка написанного кода на плату, взаимодействие с библиотеками и мониторинг. Возможности облачной IDE ограничены, и для полного доступа необходимо приобрести подписку Arduino Cloud.
Разрабатывать код для Arduino можно и в редакторе кода Visual Studio Code от Microsoft. Это возможно благодаря стороннему плагину PlatformIO, который упрощает взаимодействие с железом. Плагин бесплатный и предоставляет функции для разработки, отладки и прошивки плат.
Визуальное программирование Arduino
Новичкам может быть сложно сразу начать писать код на Arduino C из-за того, что в основе языка лежит достаточно сложный C++. Далеко не все платы поддерживают MicroPython, поэтому решением может стать визуальное программирование, построенное на перетягивании нужных фрагментов кода друг за другом. Такой способ будет полезен не только начинающим, но и детям на кружках по программированию.
Проект Массачусетского технологического института S4A представляет собой модификацию языка визуального программирования для Arduino. С его помощью можно собирать блоки кода в готовую прошивку для фирменных плат. Проект давно не обновлялся, но все равно стабильно работает. Есть русский язык и подробная документация по установке.
Проект ArduBlock от российских разработчиков активно поддерживается и предлагает актуальные функции для большинства плат Arduino и ESP. Программирование с помощью блоков, а также уроки и инструкции на русском языке доступны в браузере. Вместе с ArduBlock авторы проекта выпускают стартовые наборы для начинающих.
Основы программирования Arduino
Файл с кодом проекта для Arduino в сообществе принято называть скетчем. Скетчи пишут по специальным правилам, обеспечивающим корректную работу с железом и выполнение команд. Базовая структура выглядит следующим образом:
#include "name"
void setup() {
}
void loop() {
}
В самом начале скетча в главный файл подключают сторонние библиотеки с помощью директивы #include и названия библиотеки. Название можно указать с помощью кавычек («») или галочек (<>). В первом случае поиск к файлу библиотеки производится сначала в папке со скетчем, а потом в папке с установленными библиотеками. Если использовать галочки, то система будет искать указанный файл только в папке с установленными библиотеками.
Далее следует функция setup(), которая выполняется при каждом запуске скетча на Arduino. В этот момент система задает вводам и выводам на плате режим работы, получает значения переменных и подготавливает плату для работы с остальной частью кода.
Функция loop() выполняется по кругу и управляет Arduino. В этой части разработчики пишут основной код скетча, который реализует логику всего проекта. Выполнение loop() запускается сразу за setup(). Эти две функции обязательно должны быть в скетче каждого проекта, даже в тех случаях, когда в функциях нет никаких инструкций. Без них невозможно выполнение кода на Arduino.
Комментарии и разделители
Arduino программируют на языке, спроектированном на базе C++, поэтому он наследует многие его особенности. Так, однострочные комментарии задаются с помощью двойного слэша (//). Весь текст внутри комментария компилятор будет игнорировать, обычно текст в слэшах используют для пояснения работы кода. Комментарии в первую очередь нужны людям, которые пишут код и работают с ним, а не компьютеру.
Для комментирования сразу нескольких строк используется конструкция из слэша и звездочки (/* комментарий */). Такую конструкцию обязательно надо закрывать, иначе компилятор не сможет найти конец комментария.
// Однострочный комментарий // Второй однострочный комментарий /* А это уже Многострочный комментарий */
Все инструкции нужно отделять точкой с запятой (;). Эта особенность тоже пришла в синтаксис Arduino из C++. Если этого не делать, код не соберется и скетч нельзя будет загрузить на плату.
Переменные Arduino
Переменные в Arduino нужны, как и во всех языках программирования, для хранения данных. В программировании Arduino мы должны указывать тип переменной перед ее именем. Существуют следующие типы данных:
Операторы Arduino
Загрузка прошивки на плату
Представим, что мы написали и отладили код, теперь его нужно протестировать на железе. Для этого надо как-то отправить код на плату Arduino. В фирменной среде разработки для этого предусмотрена удобная возможность прошивать платы.
Сначала подключаем плату по USB к компьютеру. В каждом поколении и типе Arduino используется свой стандарт подключения. Это важно учитывать. В запущенной IDE раскрываем список и ищем в нем плату.
Выбираем и нажимаем на кнопку с иконкой стрелочки. Плата начнет моргать светодиодами. Если прошивка прошла успешно, в терминале появится сообщение.
Поморгаем светодиодом
В мире программирования в качестве первой программы принято выводить на дисплей фразу «Hello, World!». В мире Arduino сложилась традиция моргать светодиодом, который выведен на плату. Новички с помощью этого скетча начинают изучать программирование микроконтроллеров, а профессионалы — проверяют платы на наличие дефектов.
Для начала работы над проектом необходимо запустить Arduino IDE. Нужный скетч входит в библиотеку примеров среды разработки. Его можно найти в разделе File → Examples → 01. Basics → Blink. После выбора в окне редактора появится код, первые строчки которого заменяет обширный комментарий с описанием проекта. Его можно сразу удалить, чтобы не мешался. Детально рассмотрим код:
// the setup function runs once when you press reset or power the board
void setup() {
// initialize digital pin LED_BUILTIN as an output.
pinMode(LED_BUILTIN, OUTPUT);
}
// the loop function runs over and over again forever
void loop() {
digitalWrite(LED_BUILTIN, HIGH); // turn the LED on (HIGH is the voltage level)
delay(1000); // wait for a second
digitalWrite(LED_BUILTIN, LOW); // turn the LED off by making the voltage LOW
delay(1000); // wait for a second
}
В функции setup() пин LED_BUILTIN настраивается в режим вывода. Это значит, что через него мы не будем ничего принимать и используем только для передачи параметров. Пины LED_BUILTIN и 13 соединены вместе. Если в коде заменить LED_BUILTIN на 13, то ничего не поменяется.
Функция loop() используется для управления пином, который мы инициализировали выше. Сначала мы подаем на него напряжение в 5 вольт с помощью HIGH, выдерживаем паузу 1000 миллисекунд с помощью delay() и убираем напряжение. Функция loop() повторяется по кругу, поэтому все инструкции в коде будут выполняться до тех пор, пока на плате будет питание.
Собираем пианино
Мы уже знаем практически всю теорию для программирования Arduino и даже попробовали написать свой «Hello, World!», поэтому сейчас можно переходить к более сложным проектам. Попробуем собрать простой музыкальный инструмент, похожий на пианино.
Схема
Схема проекта очень простая, а для сборки понадобятся три кнопки, три резистора на 10 кОм, пищалка и охапка соединительных проводов. Схему будем собирать на макетной плате. Так быстрее работать с прототипами и не надо при каждой новой версии схемы все перепаивать.
Все элементы следует подключать в следующей последовательности, соблюдая порядок пинов:
Код
Весь код проекта выглядит следующим образом:
#define BUZZER 13 // пищалка на 13 пине
#define KEY_FIRST 7 // первый пин клавиш
#define KEY_COUNT 3 // всего клавиш
void setup() {
pinMode(BUZZER, OUTPUT);
}
void loop() {
for (int i = 0; i < KEY_COUNT; ++i) {
int keyPin = i + KEY_FIRST;
boolean keyUp = digitalRead(keyPin);
if (!keyUp) {
int frequency = 3500 + i * 500;
tone(BUZZER, frequency, 20);
}
}
}
Его можно сразу перепечатать в среду разработки и попробовать загрузить на плату. Если все прошло успешно, то при нажатии кнопок будет проигрываться звук. Теперь разберем код более детально.
В самом начале мы задаем имена для пинов, которые будем использовать. Делается это с помощью директивы #define. После указываем имя большими буквами и номер пина на плате Arduino. Все, после этого в коде мы сможем обращаться к пину по его имени, а не номеру. Это особенно удобно в больших проектах, когда сложно запомнить, какой пин за что отвечает.
#define BUZZER 13 // пищалка на 13 пине #define KEY_FIRST 7 // первый пин клавиш #define KEY_COUNT 3 // всего клавиш
После следует привычная функция setup(). В ней производим подготовительные настройки платы. В этом проекте мы устанавливаем пин пищалки в режим выхода, потому что мы не будем через него ничего получать. Нам надо отдавать звук.
void setup() {
pinMode(BUZZER, OUTPUT);
}
Важно отметить, что по умолчанию все пины работают в режиме входа. Поэтому мы не прописываем для каждого пина то, что он используется в проекте в качестве входного.
Теперь идет самая важная часть кода — функция loop(), в которой выполняется вся логика. В случае с пианино мы в цикле for проходимся по всем кнопкам, которые у нас есть. Зная номер кнопки, вычисляем ее пин. Потом считываем с нее значение, чтобы узнать, нажата кнопка или нет. Если нажата, то воспроизводим звук. Для считывания значения кнопки используем функцию digitalRead(), а воспроизводим звук с помощью tone().
void loop() {
for (int i = 0; i < KEY_COUNT; ++i) {
int keyPin = i + KEY_FIRST;
boolean keyUp = digitalRead(keyPin);
if (!keyUp) {
int frequency = 3500 + i * 500;
tone(BUZZER, frequency, 20);
}
}
}
Итог
- Программировать Arduino не так сложно, как может показаться. Разработчики платформы постарались сделать все, чтобы можно было просто писать код, а не разбираться с устройством платы.
- Arduino существует уже достаточно много лет и активно поддерживается сообществом, поэтому можно найти библиотеки для решения практически любых задач.
- Платформу поддерживают и сторонние производители, поэтому в магазинах можно найти множество датчиков, сенсоров и модулей, расширяющих возможности Arduino.
- Разработчики развивают не только саму платформу, но и инструменты для работы с ней.
В этой статье я решал собрать полное пошаговое руководство для начинающих Arduino. Мы разберем что такое ардуино, что нужно для начала изучения, где скачать и как установить и настроить среду программирования, как устроен и как пользоваться языком программирования и многое другое, что необходимо для создания полноценных сложных устройств на базе семейства этих микроконтроллеров.
Тут я постараюсь дать сжатый минимум для того, что бы вы понимали принципы работы с Arduino. Для более полного погружения в мир программируемых микроконтроллеров обратите внимание на другие разделы и статьи этого сайта. Я буду оставлять ссылки на другие материалы этого сайта для более подробного изучения некоторых аспектов.
Что такое Arduino и для чего оно нужно?
Arduino — это электронный конструктор, который позволяет любому человеку создавать разнообразные электро-механические устройства. Ардуино состоит из программной и аппаратной части. Программная часть включает в себя среду разработки (программа для написания и отладки прошивок), множество готовых и удобных библиотек, упрощенный язык программирования. Аппаратная часть включает в себя большую линейку микроконтроллеров и готовых модулей для них. Благодаря этому, работать с Arduino очень просто!
С помощью ардуино можно обучаться программированию, электротехнике и механике. Но это не просто обучающий конструктор. На его основе вы сможете сделать действительно полезные устройства.
Начиная с простых мигалок, метеостанций, систем автоматизации и заканчивая системой умного дома, ЧПУ станками и беспилотными летательными аппаратами. Возможности не ограничиваются даже вашей фантазией, потому что есть огромное количество инструкций и идей для реализации.
Стартовый набор Arduino
Для того что бы начать изучать Arduino необходимо обзавестись самой платой микроконтроллера и дополнительными деталями. Лучше всего приобрести стартовый набор Ардуино, но можно и самостоятельно подобрать все необходимое. Я советую выбрать набор, потому что это проще и зачастую дешевле. Вот ссылки на лучшие наборы и на отдельные детали, которые обязательно пригодятся вам для изучения:
| Базовый набор ардуино для начинающих: | Купить |
| Большой набор для обучения и первых проектов: | Купить |
| Набор дополнительных датчиков и модулей: | Купить |
| Ардуино Уно самая базовая и удобная модель из линейки: | Купить |
| Беспаечная макетная плата для удобного обучения и прототипирования: | Купить |
| Набор проводов с удобными коннекторами: | Купить |
| Комплект светодиодов: | Купить |
| Комплект резисторов: | Купить |
| Кнопки: | Купить |
| Потенциометры: | Купить |
Среда разработки Arduino IDE
Для написания, отладки и загрузки прошивок необходимо скачать и установить Arduino IDE. Это очень простая и удобная программа. На моем сайте я уже описывал процесс загрузки, установки и настройки среды разработки. Поэтому здесь я просто оставлю ссылки на последнюю версию программы и на статью с подробной инструкцией.
Язык программирования Ардуино
Когда у вас есть на руках плата микроконтроллера и на компьютере установлена среда разработки, вы можете приступать к написанию своих первых скетчей (прошивок). Для этого необходимо ознакомиться с языком программирования.
Для программирования Arduino используется упрощенная версия языка C++ с предопределенными функциями. Как и в других Cи-подобных языках программирования есть ряд правил написания кода. Вот самые базовые из них:
- После каждой инструкции необходимо ставить знак точки с запятой (;)
- Перед объявлением функции необходимо указать тип данных, возвращаемый функцией или void если функция не возвращает значение.
- Так же необходимо указывать тип данных перед объявлением переменной.
- Комментарии обозначаются: // Строчный и /* блочный */
Подробнее о типах данных, функциях, переменных, операторах и языковых конструкциях вы можете узнать на странице по программированию Arduino. Вам не нужно заучивать и запоминать всю эту информацию. Вы всегда можете зайти в справочник и посмотреть синтаксис той или иной функции.
Все прошивки для Arduino должны содержать минимум 2 функции. Это setup() и loop().
Функция setup
Функция setup() выполняется в самом начале и только 1 раз сразу после включения или перезагрузки вашего устройства. Обычно в этой функции декларируют режимы пинов, открывают необходимые протоколы связи, устанавливают соединения с дополнительными модулями и настраивают подключенные библиотеки. Если для вашей прошивки ничего подобного делать не нужно, то функция все равно должна быть объявлена. Вот стандартный пример функции setup():
void setup() {
Serial.begin(9600); // Открываем serial соединение
pinMode(9, INPUT); // Назначаем 9 пин входом
pinMode(13, OUTPUT); // Назначаем 13 пин выходом
}В этом примере просто открывается последовательный порт для связи с компьютером и пины 9 и 13 назначаются входом и выходом. Ничего сложного. Но если вам что-либо не понятно, вы всегда можете задать вопрос в комментариях ниже.
Функция loop
Функция loop() выполняется после функции setup(). Loop в переводе с английского значит «петля». Это говорит о том что функция зациклена, то есть будет выполняться снова и снова. Например микроконтроллер ATmega328, который установлен в большинстве плат Arduino, будет выполнять функцию loop около 10 000 раз в секунду (если не используются задержки и сложные вычисления). Благодаря этому у нас есть большие возможности.
Макетная плата Breadbord
Вы можете создавать простые и сложные устройства. Для удобства я советую приобрести макетную плату (Breadbord) и соединительные провода. С их помощью вам не придется паять и перепаивать провода, модули, кнопки и датчики для разных проектов и отладки. С беспаечной макетной платой разработка становится более простой, удобной и быстрой. Как работать с макетной платой я рассказывал в этом уроке. Вот список беспаечных макетных плат:
| Макетная плата на 800 точек с 2 шинами питания, платой подачи питания и проводами: | Купить |
| Большая макетная плата на 1600 точек с 4 шинами питания: | Купить |
| Макетная плата на 800 точек с 2 шинами питания: | Купить |
| Макетная плата на 400 точек с 2 шинами питания: | Купить |
| Макетная плата на 170 точек: | Купить |
| Соединительные провода 120 штук: | Купить |
Первый проект на Arduino
Давайте соберем первое устройство на базе Ардуино. Мы просто подключим тактовую кнопку и светодиод к ардуинке. Схема проекта выглядит так:
Обратите внимание на дополнительные резисторы в схеме. Один из них ограничивает ток для светодиода, а второй притягивает контакт кнопки к земле. Как это работает и зачем это нужно я объяснял в этом уроке.
Для того что бы все работало, нам надо написать скетч. Давайте сделаем так, что бы светодиод загорался после нажатия на кнопку, а после следующего нажатия гас. Вот наш первый скетч:
// переменные с пинами подключенных устройств
int switchPin = 8;
int ledPin = 11;
// переменные для хранения состояния кнопки и светодиода
boolean lastButton = LOW;
boolean currentButton = LOW;
boolean ledOn = false;
void setup() {
pinMode(switchPin, INPUT);
pinMode(ledPin, OUTPUT);
}
// функция для подавления дребезга
boolean debounse(boolean last) {
boolean current = digitalRead(switchPin);
if(last != current) {
delay(5);
current = digitalRead(switchPin);
}
return current;
}
void loop() {
currentButton = debounse(lastButton);
if(lastButton == LOW && currentButton == HIGH) {
ledOn = !ledOn;
}
lastButton = currentButton;
digitalWrite(ledPin, ledOn);
}В этом скетче я создал дополнительную функцию debounse для подавления дребезга контактов. О дребезге контактов есть целый урок на моем сайте. Обязательно ознакомьтесь с этим материалом.
ШИМ Arduino
Широтно-импульсная модуляция (ШИМ) — это процесс управления напряжением за счет скважности сигнала. То есть используя ШИМ мы можем плавно управлять нагрузкой. Например можно плавно изменять яркость светодиода, но это изменение яркости получается не за счет уменьшения напряжения, а за счет увеличения интервалов низкого сигнала. Принцип действия ШИМ показан на этой схеме:
Когда мы подаем ШИМ на светодиод, то он начинает быстро зажигаться и гаснуть. Человеческий глаз не способен увидеть это, так как частота слишком высока. Но при съемке на видео вы скорее всего увидите моменты когда светодиод не горит. Это случится при условии что частота кадров камеры не будет кратна частоте ШИМ.
В Arduino есть встроенный широтно-импульсный модулятор. Использовать ШИМ можно только на тех пинах, которые поддерживаются микроконтроллером. Например Arduino Uno и Nano имеют по 6 ШИМ выводов: это пины D3, D5, D6, D9, D10 и D11. В других платах пины могут отличаться. Вы можете найти описание интересующей вас платы в этом разделе.
Для использования ШИМ в Arduino есть функция analogWrite(). Она принимает в качестве аргументов номер пина и значение ШИМ от 0 до 255. 0 — это 0% заполнения высоким сигналом, а 255 это 100%. Давайте для примера напишем простой скетч. Сделаем так, что бы светодиод плавно загорался, ждал одну секунду и так же плавно угасал и так до бесконечности. Вот пример использования этой функции:
// Светодиод подключен к 11 пину
int ledPin = 11;
void setup() {
pinMode(ledPin, OUTPUT);
}
void loop() {
for (int i = 0; i < 255; i++) {
analogWrite(ledPin, i);
delay(5);
}
delay(1000);
for (int i = 255; i > 0; i--) {
analogWrite(ledPin, i);
delay(5);
}
}Аналоговые входы Arduino
Как мы уже знаем, цифровые пины могут быть как входом так и выходом и принимать/отдавать только 2 значения: HIGH и LOW. Аналоговые пины могут только принимать сигнал. И в отличии от цифровых входов аналоговые измеряют напряжение поступающего сигнала. В большинстве плат ардуино стоит 10 битный аналогово-цифровой преобразователь. Это значит что 0 считывается как 0 а 5 В считываются как значение 1023. То есть аналоговые входы измеряют, подаваемое на них напряжение, с точностью до 0,005 вольт. Благодаря этому мы можем подключать разнообразные датчики и резисторы (терморезисторы, фоторезисторы) и считывать аналоговый сигнал с них.
Для этих целей в Ардуино есть функция analogRead(). Для примера подключим фоторезистор к ардуино и напишем простейший скетч, в котором мы будем считывать показания и отправлять их в монитор порта. Вот так выглядит наше устройство:
В схеме присутствует стягивающий резистор на 10 КОм. Он нужен для того что бы избежать наводок и помех. Теперь посмотрим на скетч:
int sensePin = 0; // Пин к которому подключен фоторезистор
void setup() {
analogReferense(DEFAULT); // Задаем опорное значение напряжения. Эта строка не обязательна.
Serial.begin(9600); // Открываем порт на скорости 9600 бод.
}
void loop() {
Serial.println(analogRead(sensePin)); // Считываем значение и выводим в порт
delay(500); // задержка для того что бы значений было не слишком много
}Вот так из двух простейших элементов и четырех строк кода мы сделали датчик освещенности. На базе этого устройства мы можем сделать умный светильник или ночник. Очень простое и полезное устройство.
Вот мы и рассмотрели основы работы с Arduino. Теперь вы можете сделать простейшие проекты. Что бы продолжить обучение и освоить все тонкости, я советую прочитать книги по ардуино и пройти бесплатный обучающий курс. После этого вы сможете делать самые сложные проекты, которые только сможете придумать.
Пройдите тест, узнайте какой профессии подходите
Работать самостоятельно и не зависеть от других
Работать в команде и рассчитывать на помощь коллег
Организовывать и контролировать процесс работы
Введение в Arduino и его возможности
Arduino — это популярная платформа для создания электронных проектов, которая подходит как для новичков, так и для опытных разработчиков. Она состоит из микроконтроллеров и программного обеспечения для их программирования. С помощью Arduino можно создавать различные устройства: от простых светодиодных мигалок до сложных систем управления. Платформа Arduino была разработана с целью сделать электронику и программирование доступными для всех, независимо от уровня подготовки.
Arduino позволяет легко взаимодействовать с внешними устройствами, такими как датчики, моторы и дисплеи. Это делает его идеальным инструментом для обучения основам электроники и программирования. Платформа поддерживает множество библиотек, которые упрощают работу с различными компонентами. Например, с помощью библиотеки Wire можно легко работать с устройствами, использующими протокол I2C, а библиотека Servo позволяет управлять сервоприводами.
Arduino также поддерживает множество дополнительных плат расширения (шилдов), которые добавляют новые возможности. Например, шилды для управления двигателями, беспроводной связи или дисплеями. Это позволяет создавать более сложные и функциональные проекты. Кроме того, сообщество Arduino активно делится своими наработками и проектами, что позволяет быстро находить решения для различных задач и получать вдохновение для новых проектов.
Установка и настройка Arduino IDE
Для начала работы с Arduino необходимо установить Arduino IDE (Integrated Development Environment). Это бесплатное программное обеспечение, которое позволяет писать, компилировать и загружать код на плату Arduino. Arduino IDE поддерживает множество операционных систем, включая Windows, macOS и Linux, что делает его доступным для большинства пользователей.
Шаги по установке Arduino IDE:
- Перейдите на официальный сайт Arduino: arduino.cc.
- Зайдите в раздел «Software» и выберите «Downloads».
- Скачайте версию Arduino IDE для вашей операционной системы (Windows, macOS, Linux).
- Установите Arduino IDE, следуя инструкциям на экране. Процесс установки может немного отличаться в зависимости от операционной системы, но в целом он достаточно прост и интуитивно понятен.
После установки откройте Arduino IDE. Вам нужно будет выбрать модель вашей платы Arduino и порт, к которому она подключена. Для этого:
- Подключите плату Arduino к компьютеру с помощью USB-кабеля.
- В Arduino IDE перейдите в меню «Tools» и выберите «Board». Найдите вашу модель платы в списке и выберите её. Например, если у вас плата Arduino Uno, выберите «Arduino Uno».
- В меню «Tools» выберите «Port» и выберите соответствующий COM-порт. Обычно это единственный порт, который появляется после подключения платы.
Теперь ваша Arduino IDE готова к работе! 🎉 Вы можете начать писать свои первые скетчи и загружать их на плату. Для проверки правильности установки и настройки можно воспользоваться примером из встроенной библиотеки Arduino — Blink. Этот пример заставит встроенный светодиод на плате мигать, что подтвердит успешное подключение и работу платы.
Основы языка программирования Arduino (C/C++)
Arduino использует упрощённую версию языка программирования C/C++, что делает его доступным для новичков. Основные элементы языка включают функции, переменные, циклы и условия. Знание этих элементов позволит вам создавать разнообразные программы для управления различными устройствами и компонентами.
Основные функции:
setup(): Эта функция выполняется один раз при запуске платы. Здесь обычно инициализируются настройки. Например, настройка пинов ввода/вывода, установка начальных значений переменных и т.д.loop(): Эта функция выполняется непрерывно, пока плата включена. Здесь размещается основной код программы. В этой функции можно реализовать логику работы вашего устройства, обработку данных от датчиков, управление исполнительными устройствами и многое другое.
Пример простейшей программы (скетча) для Arduino:
Этот скетч заставляет встроенный светодиод мигать с интервалом в 1 секунду. Это классический пример, который помогает понять основные принципы работы с Arduino и его программированием.
Переменные и типы данных:
int: Целые числа. Используются для хранения целочисленных значений, таких как счётчики, индексы и т.д.float: Числа с плавающей запятой. Используются для хранения дробных значений, таких как результаты измерений датчиков.char: Символы. Используются для хранения отдельных символов, таких как буквы и цифры.boolean: Логические значения (true/false). Используются для хранения логических значений, таких как состояния переключателей или результатов условий.
Условия и циклы:
if,else: Условные операторы. Используются для выполнения кода в зависимости от выполнения определённых условий.for,while: Циклы. Используются для многократного выполнения кода.
Пример использования условий и циклов:
Этот пример показывает, как можно использовать циклы для многократного выполнения кода и условия для выполнения различных действий в зависимости от состояния входного сигнала.
Примеры простых проектов и их разбор
Проект 1: Мигающий светодиод
Этот проект заставит светодиод мигать с заданным интервалом. Он является отличным началом для изучения основ программирования и работы с Arduino.
Этот проект помогает понять, как использовать функции digitalWrite и delay для управления светодиодом. Вы можете изменить интервал мигания, изменив значение в функции delay.
Проект 2: Управление светодиодом с помощью кнопки
Этот проект позволяет включать и выключать светодиод с помощью кнопки. Он демонстрирует, как можно использовать входные сигналы для управления выходными устройствами.
Этот проект показывает, как можно использовать функцию digitalRead для чтения состояния кнопки и условные операторы для управления светодиодом в зависимости от состояния кнопки.
Проект 3: Регулировка яркости светодиода с помощью потенциометра
Этот проект позволяет регулировать яркость светодиода с помощью потенциометра. Он демонстрирует, как можно использовать аналоговые входы и выходы для управления устройствами.
Этот проект показывает, как можно использовать функцию analogRead для чтения аналоговых значений и функцию analogWrite для управления яркостью светодиода с помощью ШИМ (широтно-импульсной модуляции).
Советы и ресурсы для дальнейшего изучения
- Официальная документация Arduino: arduino.cc/reference — здесь вы найдёте подробное описание всех функций и библиотек. Это основной источник информации, который поможет вам разобраться в различных аспектах работы с Arduino.
- Форумы и сообщества: Присоединяйтесь к форумам и группам в социальных сетях, чтобы получать помощь и делиться своими проектами. Сообщество Arduino очень активно и всегда готово помочь новичкам.
- Онлайн-курсы и видеоуроки: На YouTube и платформах, таких как Coursera и Udemy, можно найти множество курсов по Arduino. Эти курсы помогут вам углубить свои знания и научиться создавать более сложные проекты.
- Книги и учебные пособия: Существуют книги, специально написанные для начинающих, такие как «Arduino для начинающих» и «Программирование для Arduino». Эти книги помогут вам систематизировать свои знания и получить более глубокое понимание работы с платформой.
Изучение Arduino — это увлекательный процесс, который открывает множество возможностей для творчества и инженерных решений. Начните с простых проектов и постепенно переходите к более сложным. Удачи в ваших начинаниях! 🚀
Читайте также
Друзья, на связи снова специалист Giant 4 Алексей! Мы продолжаем наш небольшой курс статей, по использованию платы Arduino Nano и так называемой адресной лентой, на основе светодиодов ws2812b. На сегодня это уже четвертая статья. В прошлый раз мы написали первую программу для управления лентой. Но все-таки нужно иметь хотя бы небольшое представление о языке программирования, которым мы пользовались. Иначе говорить о чем-то дальше будет просто бессмысленно. И так, перед Вами C/C++ подобный язык. Конечно же, мы не будем изучать его полностью, но я постараюсь затронуть основные моменты.
Конечно же, это функции setup() и loop() и они нам уже знакомы.
Функция setup() вызывается автоматически, при старте программы. Она выполняется один раз и ничего не возвращает, поэтому мы обозначаем данную функцию типом void. В дальнейшем мы разберем, что это значит.
Функция loop() начинает выполняться после завершения функции setup(), данная функция тоже ничего не возвращает и выполняется по кругу бесконечное количество раз.
И loop(), и setup() являются необходимым минимумом программы. Эти функции должны всегда присутствовать, иначе компилятор выдаст ошибку. Как правило, в setup() происходит инициализация объектов. А в loop() выполняется основная программа и вызываются другие функции.
Конечно же, когда речь идет о программировании, то приходится использовать данные разного типа. Типов достаточно много, но мы разберем лишь некоторые из них.
— Boolean – это логический тип данных, переменные такого типа могут принимать лишь два значения true или false. Где true – это истина, а false – это ложь. Без этого типа было бы невозможно организовать логику программы. Для того, чтобы объявить переменную такого типа, необходимо записать «boolean a;». И тогда нам будет доступна переменная с именем «а» типа boolean. А для того, чтобы присвоить данной переменной значение, нужно сделать такую запись – «a = true;». Хотя можно присвоить значение сразу, при объявлении переменной «boolean a = true;». А чтобы в дальнейшем изменить значение переменной, достаточно просто присвоить ей новое значение. Кстати, да, знак равенства – это операция присваивания. Записи с такой операцией принято читать справа налево. «a = true;» — Значение true присваивается переменно «a».
Таким же образом, как мы объявляли переменные типа boolean, можно объявить переменную любого типа.
— int – пожалуй, самый используемый и востребованный тип. В переменных такого типа хранятся целые числа от -32768 до 32767. Данные ограничения связанны с тем, что на переменную выделяется два байта памяти и больше записать просто не получится. Хотя, если понадобится, то можно воспользоваться другими типами, на которые выделено больше памяти, например, тип long (от -2 147 483 648 до 2 147 483 647).
— String – строковый тип. В переменную такого типа можно записать строку или массив символов.
Переменная – это имя, закреплённое за выделенной областью памяти. Переменная позволяет опустить потребность контроля, за расположением принадлежащей ей ячейки памяти. Достаточно записать значение в переменную, и значение попадет в выделенную для этого область памяти. При этом, пока существует переменная, присвоенное ей значение будет оставаться в целостности и не будет случайно стерто.
Как мы уже могли понять, переменные могут быть разных типов и содержать в себе разные данные. Мало того, очень важно то, в каком месте объявлена переменная, так как объявление работает лишь в рамках тела, обособленного фигурными скобками. Как только тело заканчивается, переменная перестает существовать. В следующем примере при каждом повторе функции loop(), в начале работы, переменная инициализируется и ей присваивается значение, а в момент завершения, переменная перестает существовать.
С этим нужно быть аккуратным, так как на инициализацию переменной тратится немного вычислительного ресурса микроконтроллера.
Теперь хочу еще раз обратить ваше внимание на то, что если мы объявим переменную в теле одной функции, и при этом попытаемся использовать в теле другой функции, то программа не сможет ее увидеть. Хорошо, что ошибка вылезет еще на этапе компиляции.
void setup()
{
int a;
}
void loop()
{
a = 1;
}
Но при этом, если в теле функции, где объявлена переменная, есть еще какое-то тело, например, условие, то все будет отлично работать.
void setup()
{
}
void loop()
{
int a;
if()
{
a = 1;
}
}
Также можно объявить глобальную переменную, которая будет видна из любой части программы. Но тогда она никогда не будет очищена. И любое место, где она использована, может повлиять на ее значение. Будьте аккуратны.
boolean myBool;
void setup()
{
myBool = true;
}
void loop()
{
myBool = false;
}
Арифметические операторы
С одним из арифметических операторов Arduino вы уже знакомы – это оператор присваивания «=». Но есть и другие, их немного и смысл, думаю, будет понятен и без объяснений.
— «+» — сложение;
— «-» — вычитание;
— «*» — умножение;
— «/» — деление;
— «%» = остаток от деления.
Но, не смотря на всю простоту, я приведу пример.
int myInt = 0;
void setup()
{
myInt = 1 + 2;
}
void loop()
{
myInt = myInt * 3;
}
В первой строчке мы объявляем переменную типа int с именем myInt. В пятой строке мы присваиваем нашей переменной значение из суммы чисел «1» и «2», то есть myInt равен трем. В десятой строке мы присваиваем переменной значение, равное значению переменной, умноженной на «3». Следовательно, 3 * 3 = 9. Но так как функция loop() выполняется по кругу, то при втором проходе, когда переменная уже равна 9, ей будет уже присвоено произведение двух чисел «9» и «3». Следовательно, переменная будет хранить в себе число 27. А при третьем проходе значение превратится в 81. И так будет продолжаться до бесконечности.
Функции
И снова мы возвращаемся к этому, только теперь мы уже вооружены некоторыми знаниями и готовы писать свои функции для Ардуино. Да, помимо стандартных setup() и loop() мы можем создавать свои, совершенно любого назначения. Помните, я говорил, что перед названием функции мы пишем «void» именно потому что она ничего не возвращает? Так вот, функция – это отдельно стоящий блок программы, который мы можем вызвать в любой момент. Мы имеем возможность передать функции какие-то значения, чтобы использовать их в теле функции. Также мы можем распорядиться таким образом, чтобы функция вернула значение нам, к примеру, результат расчета. И «void» — это еще один тип данных, использующийся только в купе с функциями. Если перед названием функции стоит «void» — это значит, что функция ничего не возвращает, она делает свои операции и просто заканчивает работу. Функции при программировании Arduino используют, как правило, в тех случаях, когда одно и то же действие необходимо повторять из разных частей программы и с разными значениями. Не понятно? Не страшно, сейчас разберем все подробно.
Создать функцию в Arduino очень просто, ее даже не нужно объявлять, достаточно только записать. Давайте создадим функцию с названием «myFun». Эта функция ничего не принимает, ничего не возвращает и даже ничего не выполняет. Пока что она просто есть.
int myInt = 0;
void setup()
{
myInt = 1 + 2;
}
void loop()
{
myInt = myInt * 3;
}
void myFun()
{
}
Теперь давайте заставим данную функцию выполнять операцию сложения.
void setup()
{
}
void loop()
{
}
void myFun()
{
int sum = 5 + 4;
}
В данном случае, хоть в теле функции и происходит математическая операция, она никогда не будет выполнена, так как функция ниоткуда не вызывается. Давайте исправим это. Теперь при каждом прохождении тела loop() данная функция будет вызываться и производить сложение, присваивая результат переменной sum.
void setup()
{
}
void loop()
{
myFun();
}
void myFun()
{
int sum = 5 + 4;
}
Но на данной момент это совершенно бессмысленная операция, так как переменная sum существует только в пределах функции. Давайте изменим тип нашей функции с «void» на «int». И теперь «myFun()» должна возвращать значение типа int. Для этого используется команда return.
void setup()
{
}
void loop()
{
myFun();
}
int myFun()
{
int sum = 5 + 4;
return sum;
}
Но сейчас по-прежнему функционал программы не совсем корректен, потому что значение, полученное в функции, и которое она возвращает, возвращается в место вызова функции. И чтобы его использовать в дальнейшем, необходимо его к чему-то присвоить. Давайте исправляться дальше.
void setup()
{
}
void loop()
{
int mySum = myFun();
}
int myFun()
{
int sum = 5 + 4;
return sum;
}
В теле функции loop() мы объявили переменную типа int и присвоили ей возвращаемое функцией myFun() значение. Но программа до сих пор выглядит глупо. Мы и так знаем результат сложения «5» и «4». Поэтому давайте передавать в myFun() значение, которые хотим сложить. Для этого в круглых скобках необходимо объявить через запятую тип и имя параметров, которые мы хотим получить. А при вызове функции передать ей эти параметры. Выглядит это следующим образом.
void setup()
{
}
void loop()
{
int mySum = myFun(4, 5);
}
int myFun(int a, int b)
{
int sum = a + b;
return sum;
}
Теперь, вызывая нашу функцию из разных мест программы, мы можем передавать ей разные значения и получать сумму этих значений. Да, как правило, задачи у функций немного посложнее, но мы пока только учимся, и поэтому я стараюсь использовать максимально простые примеры для первых экспериментов в программировании Ардуино. Сейчас мы разберемся, что из себя представляет оператор if и вернемся к написанию функций.
Оператор If
Оператор if представляет из себя некоторое условие, которое используется в сочетании с операторами сравнения. Их несколько, но пока что мы разберем только один, а уже потом затронем остальные. Первый оператор сравнения, о котором мы с вами узнаем – это оператор равенства. Обозначается он как два, стоящие друг за другом, знака равно «==». И давайте сразу перейдем к записи условия. Тут в теле loop() я объявил две переменных, «a» и «b» типа int. Затем идет условие, которое правильно читать следующим образом – «если a равно b, тогда выполняются следующие действия». В нашем случае «следующие действия» — это вызов функции, который не произойдет, потому что оператор сравнения «равно» вернет значение «false» и в тело условия программа не зайдет.
void setup()
{
}
void loop()
{
int a = 3;
int b = 4;
if(a == b)
{
myFun();
}
}
Да, вы поняли правильно, в качестве значения if принимает либо true, либо false. Следовательно, такая запись тоже возможна. Правда, смысла она не имеет, так как если условие предопределено, то нужды писать его нет.
void setup()
{
}
void loop()
{
int a = 3;
int b = 4;
if(false)
{
myFun();
}
}
Кстати, в программе и такая запись возможна 
void setup()
{
}
void loop()
{
boolean myBool = false;
int a = 3;
int b = 4;
if(myBool)
{
myFun();
}
}
Также может возникнуть такая ситуация, что при выполнении условия нужно выполнить одни команды, а при невыполнении условия, нужно выполнить другие команды. Для этого существует конструкция if – else. С низу будет пример, а читается это так – «если «a» равно «b», то вызывается функция myFun_01, иначе вызывается функция myFun_02». Прелесть этой записи в том, что никогда и ни при каких обстоятельствах не будут вызваны обе функции. Тут либо одна, либо другая.
void setup()
{
}
void loop()
{
int a = 3;
int b = 4;
if(a == b)
{
myFun_01();
}
else
{
myFun_02();
}
}
Теперь, когда все стало понятным, давайте вернемся к операторам сравнения в ардуино. Их не очень много, и они интуитивно понятны. Я просто перечислю их, потому что объяснения тут излишни.
x == y (x равно y)
x != y (x не равно y)
x < y (x меньше чем y)
x > y (x больше чем y)
x <= y (x меньше чем или равно y)
x >= y (x больше чем или равно y)
И снова функции
Тут я не хочу усложнять материал, а просто привести пример в купе с операторами условия. Давайте напишем функцию, где будем сравнивать два числа, а возвращаемым значением данной функции будет строка, говорящая о результате сравнения. Итак, простая программа для Arduino.
void setup()
{
}
void loop()
{
int a = 3;
int b = 4;
String myStr = myFun(a, b);
}
String myFun(int x, int y)
{
String str;
if(x > y)
{
str = x + » больше » + y;
}
else
{
if(x < y)
{
str = x + » меньше » + y;
}
else
{
str = x + » равно » + y;
}
}
return str;
}
Пожалуй, все, что есть в данной программе, мы проходили, кроме сложения строк. Но на этом я не буду заострять свое внимание, просто посмотрите и примите, что так можно делать. Причем значение типа int автоматически преобразуется в строку.
В 10-ой строке у нас идет вызов функции, причем результат ее работы присвоен к переменной типа String.
С 13-ой строки начинается функция, она принимает два значения типа int и возвращает значение типа String. Мы все это уже проговаривали.
В 16-ой строке идет условие if—else, при попадании в которое у нас формируется строка. Но самая интересная часть для нас — это тело else, начинающееся с 20 строки. Тут в else мы вложили еще один оператор if—else. Так тоже можно делать. И вложение может быть очень глубоким, а не на одну ступень.
Я специально решил показать подобный пример, чтобы в дальнейшем облегчить понимание происходящего.
Комментарии
Комментарии – это строки в программе, служащие для информирования программиста о том, как работает его программа. При компиляции комментарии пропускаются, поэтому можно писать их в любом количестве. Зачастую не принято комментировать каждую строку, обычно подписывают функционал и принадлежность функций или блоков, чтобы по прошествии времени быстро вспомнить их назначение. Комментарии бывают однострочные и многострочные. Однострочные начинаются с символов «//» и после вся строка будет комментарием. Многострочные комментарии имеют обособление, в начале ставится «/*», а в конце «*/».
void setup()
{
/* В данном примере
функция setup()
не используется*/
}
void loop()
{
int a = 3; //объявляю переменную типа int
int b = 4;
}
Цикл
И напоследок этого короткого и не полного курса по языку программирования Arduino, я хочу поговорить про циклы. Их существует несколько видов, и, как мы уже поняли, сама функция loop() – это тоже цикл. Но я все-таки не буду охватывать все и остановлюсь на циклах типа for.
Конструкция for используется для набора команд, заключенных в фигурные скобки. Заголовок состоит из трех частей «for(int i = 0; i < 10; i++)». Самой первой (и единожды) выполняется инициализация переменной, отвечающая за счетчик цикла «int i = 0». При каждом прохождении цикла проверяется условие «i < 10», если оно верно, то цикл продолжает выполняться. Также если условие верно, то происходит приращение из третий части «i++», тут каждый проход цикла к i прибавляется единица. Также переменную, объявленную в цикле, можно использовать в теле цикла.
void setup()
{
}
void loop()
{
String str;
for(int i = 0; i < 10; i++)
{
str = «номер » + i;
}
}
В данном примере у нас присутствует цикл на 10 итераций, от 0 до 9. Также при каждом заполнении у нас перезаписывается переменная, строкового типа. В данную переменную мы пишем слово «номер», а затем через строковое сложение прибавляем реальный номер итерации. Думаю, на этом с циклами можно закончить.
Заключение
Вот и подошла к концу очередная статья. Конечно же мы затронули далеко не все темы, а то что затронули, раскрыли не полностью. Но тем не менее, у нас не книга по программированию, а пока лишь ознакомительная статья. И знаний, полученных сегодня, вполне хватит, чтобы мы с вами продолжили совместную продуктивную работу с Ардуино в следующей статье.