Arduino справочник языка. Подключение и программирование ардуино для начинающих
Подробно Arduino язык программирования для начинающих представлен в таблице далее. Микроконтроллер Arduino программируется на специальном языке программирования, основанном на C/C ++. Язык программирования Arduino является разновидностью C++, другими словами, не существует отдельного языка программирования для Arduino. Скачать книгу PDF можно в конце страницы.
В Arduino IDE все написанные скетчи компилируются в программу на языке C/C++ с минимальными изменениями. Компилятор Arduino IDE значительно упрощает написание программ для этой платформы и создание устройств на Ардуино становится намного доступней людям, не имеющих больших познаний в языке C/C++. Дадим далее небольшую справку с описанием основных функций языка Arduino с примерами.
Подробный справочник языка Ардуино
Язык можно разделить на четыре раздела: операторы, данные, функции и библиотеки.
| Язык Arduino | Пример | Описание |
Операторы |
||
| setup() | void
setup
() { pinMode (3, INPUT ); } |
Функция используется для инициализации переменных, определения режимов работы выводов на плате и т.д. Функция запускается только один раз, после каждой подачи питания на микроконтроллер. |
| loop() | void
loop
() { digitalWrite (3, HIGH ); delay(1000); digitalWrite (3, LOW ); delay(1000); } |
Функция loop крутится в цикле, позволяя программе совершать вычисления и реагировать на них. Функции setup() и loop() должны присутствовать в каждом скетче, даже если эти операторы в программе не используются. |
Управляющие операторы |
||
| if | … if (x > if (x < 100) digitalWrite (3, LOW ); … |
Оператор if используется в сочетании с операторами сравнения (==, !=, <, >) и проверяет, достигнута ли истинность условия. Например, если значение переменной x больше 100, то включается светодиод на выходе 13, если меньше — светодиодвыключается. |
| if..else | … if (x > 100) digitalWrite (3, HIGH ); else digitalWrite (3, LOW ); … |
Оператор else позволяет cделать проверку отличную от указанной в if, чтобы осуществлять несколько взаимо исключающих проверок. Если ни одна из проверок не получила результат ИСТИНА, то выполняется блок операторов в else. |
| switch…case | … switch (x) { case 3: break ; } … |
Подобно if, оператор switch управляет программой, позволяя задавать действия, которые будут выполняться при разных условиях. Break является командой выхода из оператора, default выполняется, если не выбрана ни одна альтернатива. |
| for | void
setup
() { pinMode (3, OUTPUT ); } void loop () { for (int i=0; i <= 255; i++){ analogWrite (3, i); delay(10); } } |
Конструкция for используется для повторения операторов, заключенных в фигурные скобки. Например, плавное затемнение светодиода. Заголовок цикла for состоит из трех частей: for (initialization; condition; increment) — initialization выполняется один раз, далее проверяется условие condition, если условие верно, то выполняется приращение increment. Цикл повторяется пока не станет ложным условие condition. |
| while | void
loop
() { while (x < 10) { x = x + 1; Serial.println (x); delay (200); } } |
Оператор while используется, как цикл, который будет выполняться, пока условие в круглых скобках является истиной. В примере оператор цикла while будет повторять код в скобках бесконечно до тех пор, пока x будет меньше 10. |
| do…while | void
loop
() { do { x = x + 1; delay (100); Serial.println (x); } while (x < 10); delay (900); } |
Оператор цикла do…while работает так же, как и цикл while. Однако, при истинности выражения в круглых скобках происходит продолжение работы цикла, а не выход из цикла. В приведенном примере, при x больше 10 операция сложения будет продолжаться, но с паузой 1000 мс. |
| break
continue |
switch
(x) { case 1: digitalWrite (3, HIGH ); case 2: digitalWrite (3, LOW ); case 3: break ; case 4: continue ; default : digitalWrite (4, HIGH ); } |
Break используется для принудительного выхода из циклов switch, do, for и while, не дожидаясь завершения цикла. Оператор continue пропускает оставшиеся операторы в текущем шаге цикла. |
Синтаксис |
||
| ; (точка с запятой) |
… digitalWrite (3, HIGH ); … |
Точка с запятой используется для обозначения конца оператора. Забытая в конце строки точка с запятой приводит к ошибке при компиляции. |
| {} (фигурные скобки) |
void
setup
() { pinMode (3, INPUT ); } |
Открывающая скобка “{” должна сопровождаться закрывающей скобкой “}”. Непарные скобки могут приводить к скрытым и непонятным ошибкам при компиляции скетча. |
| // (комментарий) |
x = 5; // комментарий | |
Из чего состоит программа
Для начала стоит понять, что программу нельзя читать и писать как книгу: от корки до корки, сверху вниз, строку за строкой. Любая программа состоит из отдельных блоков. Начало блока кода в C/C++ обозначается левой фигурной скобкой { , его конец - правой фигурной скобкой } .
Блоки бывают разных видов и какой из них когда будет исполняться зависит от внешних условий. В примере минимальной программы вы можете видеть 2 блока. В этом примере блоки называются определением функции . Функция - это просто блок кода с заданным именем, которым кто-то затем может пользоваться из-вне.
В данном случае у нас 2 функции с именами setup и loop . Их присутствие обязательно в любой программе на C++ для Arduino. Они могут ничего и не делать, как в нашем случае, но должны быть написаны. Иначе на стадии компиляции вы получите ошибку.
Классика жанра: мигающий светодиод
Давайте теперь дополним нашу программу так, чтобы происходило хоть что-то. На Arduino, к 13-му пину подключён светодиод. Им можно управлять, чем мы и займёмся.
void setup() { pinMode(13 , OUTPUT) ; } void loop() { digitalWrite(13 , HIGH) ; delay(100 ) ; digitalWrite(13 , LOW) ; delay(900 ) ; }Скомпилируйте, загрузите программу. Вы увидите, что каждую секунду светодиод на плате помигивает. Разберёмся почему этот код приводит к ежесекундному миганию.
Каждое выражение - это приказ процессору сделать нечто. Выражения в рамках одного блока исполняются одно за другим, строго по порядку без всяких пауз и переключений. То есть, если мы говорим об одном конкретном блоке кода, его можно читать сверху вниз, чтобы понять что делается.
Теперь давайте поймём в каком порядке исполняются сами блоки, т.е. функции setup и loop . Не задумывайтесь пока что значат конкретные выражения, просто понаблюдайте за порядком.
Как только Arduino включается, перепрошивается или нажимается кнопка RESET , «нечто» вызывает функцию setup . То есть заставляет исполняться выражения в ней.
Как только работа setup завершается, сразу же «нечто» вызывает функцию loop .
Как только работа loop завершается, сразу же «нечто» вызывает функцию loop ещё раз и так до бесконечности.
Если пронумеровать выражения по порядку, как они исполняются, получится:
void setup() { pinMode(13 , OUTPUT) ; ❶ } void loop() { digitalWrite(13 , HIGH) ; ❷ ❻ ❿ delay(100 ) ; ❸ ❼ … digitalWrite(13 , LOW) ; ❹ ❽ delay(900 ) ; ❺ ❾ }Ещё раз напомним, что не стоит пытаться воспринимать всю программу, читая сверху вниз. Сверху вниз читается только содержимое блоков. Мы вообще можем поменять порядок объявлений setup и loop .
void loop() { digitalWrite(13 , HIGH) ; ❷ ❻ ❿ delay(100 ) ; ❸ ❼ … digitalWrite(13 , LOW) ; ❹ ❽ delay(900 ) ; ❺ ❾ } void setup() { pinMode(13 , OUTPUT) ; ❶ }Результат от этого не изменится ни на йоту: после компиляции вы получите абсолютно эквивалентный бинарный файл.
Что делают выражения
Теперь давайте попробуем понять почему написанная программа приводит в итоге к миганию светодиода.
Как известно, пины Arduino могут работать и как выходы и как входы. Когда мы хотим чем-то управлять, то есть выдавать сигнал, нам нужно перевести управляющий пин в состояние работы на выход. В нашем примере мы управляем светодиодом на 13-м пине, поэтому 13-й пин перед использованием нужно сделать выходом.
Это делается выражением в функции setup:
PinMode(13 , OUTPUT) ;
Выражения бывают разными: арифметическими, декларациями, определениями, условными и т.д. В данном случае мы в выражении осуществляем вызов функции . Помните? У нас есть свои функции setup и loop , которые вызываются чем-то, что мы назвали «нечто». Так вот теперь мы вызываем функции, которые уже написаны где-то.
Конкретно в нашем setup мы вызываем функцию с именем pinMode . Она устанавливает заданный по номеру пин в заданный режим: вход или выход. О каком пине и о каком режиме идёт речь указывается нами в круглых скобках, через запятую, сразу после имени функции. В нашем случае мы хотим, чтобы 13-й пин работал как выход. OUTPUT означает выход, INPUT - вход.
Уточняющие значения, такие как 13 и OUTPUT называются аргументами функции . Совершенно не обязательно, что у всех функций должно быть по 2 аргумента. Сколько у функции аргументов зависит от сути функции, от того как её написал автор. Могут быть функции с одним аргументом, тремя, двадцатью; функции могут быть без аргументов вовсе. Тогда для их вызова круглые скобка открывается и тут же закрывается:
NoInterrupts() ;
На самом деле, вы могли заметить, наши функции setup и loop также не принимают никакие аргументы. И загадочное «нечто» точно так же вызывает их с пустыми скобками в нужный момент.
Вернёмся к нашему коду. Итак, поскольку мы планируем вечно мигать светодиодом, управляющий пин должен один раз быть сделан выходом и затем мы не хотим вспоминать об этом. Для этого идеологически и предназначена функция setup: настроить плату как нужно, чтобы затем с ней работать.
Перейдём к функции loop:
void loop() { digitalWrite(13 , HIGH) ; delay(100 ) ; digitalWrite(13 , LOW) ; delay(900 ) ; }Она, как говорилось, вызывается сразу после setup . И вызывается снова и снова как только сама заканчивается. Функция loop называется основным циклом программы и идеологически предназначена для выполнения полезной работы. В нашем случае полезная работа - мигание светодиодом.
Пройдёмся по выражениям по порядку. Итак, первое выражение - это вызов встроенной функции digitalWrite . Она предназначена для подачи на заданный пин логического нуля (LOW , 0 вольт) или логической единицы (HIGH , 5 вольт) В функцию digitalWrite передаётся 2 аргумента: номер пина и логическое значение. В итоге, первым делом мы зажигаем светодиод на 13-м пине, подавая на него 5 вольт.
Как только это сделано процессор моментально приступает к следующему выражению. У нас это вызов функции delay . Функция delay - это, опять же, встроенная функция, которая заставляет процессор уснуть на определённое время. Она принимает всего один аргумент: время в миллисекундах, которое следует спать. В нашем случае это 100 мс.
Пока мы спим всё остаётся как есть, т.е. светодиод продолжает гореть. Как только 100 мс истекают, процессор просыпается и тут же переходит к следующему выражению. В нашем примере это снова вызов знакомой нам встроенной функции digitalWrite . Правда на этот раз вторым аргументом мы передаём значение LOW . То есть устанавливаем на 13-м пине логический ноль, то есть подаём 0 вольт, то есть гасим светодиод.
После того, как светодиод погашен мы приступаем к следующему выражению. И снова это вызов функции delay . На этот раз мы засыпаем на 900 мс.
Как только сон окончен, функция loop завершается. По факту завершения «нечто» тут же вызывает её ещё раз и всё происходит снова: светодиод поджигается, горит, гаснет, ждёт и т.д.
Если перевести написанное на русский, получится следующий алгоритм:
Поджигаем светодиод
Спим 100 миллисекунд
Гасим светодиод
Спим 900 миллисекунд
Переходим к пункту 1
Таким образом мы получили Arduino с маячком, мигающим каждые 100 + 900 мс = 1000 мс = 1 сек.
Что можно изменить
Давайте пользуясь только полученными знаниями сделаем несколько вариаций программы, чтобы лучше понять принцип.
Вы можете подключить внешний светодиод или другое устройство, которым нужно «мигать» на другой пин. Например, на 5-й. Как в этом случае должна измениться программа? Мы должны всюду, где обращались к 13-му пину заменить номер на 5-й:
Компилируйте, загружайте, проверяйте.
Что нужно сделать, чтобы светодиод мигал 2 раза в секунду? Уменьшить время сна так, чтобы в сумме получилось 500 мс:
void setup() { pinMode(5 , OUTPUT) ; } void loop() { digitalWrite(5 , HIGH) ; delay(50 ) ; digitalWrite(5 , LOW) ; delay(450 ) ; }Как сделать так, чтобы светодиод при каждом «подмигивании» мерцал дважды? Нужно поджигать его дважды с небольшой паузой между включениями:
void setup() { pinMode(5 , OUTPUT) ; } void loop() { digitalWrite(5 , HIGH) ; delay(50 ) ; digitalWrite(5 , LOW) ; delay(50 ) ; digitalWrite(5 , HIGH) ; delay(50 ) ; digitalWrite(5 , LOW) ; delay(350 ) ; }Как сделать так, чтобы в устройстве были 2 светодиода, которые мигали бы каждую секунду поочерёдно? Нужно общаться с двумя пинами и работать в loop то с одним, то с другим:
void setup() { pinMode(5 , OUTPUT) ; pinMode(6 , OUTPUT) ; } void loop() { digitalWrite(5 , HIGH) ; delay(100 ) ; digitalWrite(5 , LOW) ; delay(900 ) ; digitalWrite(6 , HIGH) ; delay(100 ) ; digitalWrite(6 , LOW) ; delay(900 ) ; }Как сделать так, чтобы в устройстве были 2 светодиода, которые переключались бы на манер железнодорожного светофора: горел бы то один то другой? Нужно просто не выключать горящий светодиод тут же, а дожидаться момента переключения:
void setup() { pinMode(5 , OUTPUT) ; pinMode(6 , OUTPUT) ; } void loop() { digitalWrite(5 , HIGH) ; digitalWrite(6 , LOW) ; delay(1000 ) ; digitalWrite(5 , LOW) ; digitalWrite(6 , HIGH) ; delay(1000 ) ; }Можете проверить другие идеи самостоятельно. Как видите, всё просто!
О пустом месте и красивом коде
В языке C++ пробелы, переносы строк, символы табуляции не имеют большого значения для компилятора. Там где стоит пробел, может быть перенос строки и наоборот. На самом деле 10 пробелов подряд, 2 переноса строки и ещё 5 пробелов - это всё эквивалент одного пробела.
Пустое пространство - это инструмент программиста, с помощью которого можно или сделать программу понятной и наглядной, или изуродовать до неузнаваемости. Например, вспомним программу для мигания светодиодом:
void setup() { pinMode(5 , OUTPUT) ; } void loop() { digitalWrite(5 , HIGH) ; delay(100 ) ; digitalWrite(5 , LOW) ; delay(900 ) ; }Мы можем изменить её так:
void setup( ) { pinMode(5 , OUTPUT) ; } void loop () { digitalWrite(5 ,HIGH) ; delay(100 ) ; digitalWrite(5 ,LOW) ; delay(900 ) ; }Всё, что мы сделали - немного «поработали» с пустым пространством. Теперь можно наглядно видеть разницу между стройным кодом и нечитаемым.
Чтобы следовать негласному закону оформления программ, который уважается на форумах, при чтении другими людьми, легко воспринимается вами же, следуйте нескольким простым правилам:
1. Всегда, при начале нового блока между { и } увеличивайте отступ. Обычно используют 2 или 4 пробела. Выберите одно из значений и придерживайтесь его всюду.
Плохо:
void loop() { digitalWrite(5 , HIGH) ; delay(100 ) ; digitalWrite(5 , LOW) ; delay(900 ) ; }Хорошо:
void loop() { digitalWrite(5 , HIGH) ; delay(100 ) ; digitalWrite(5 , LOW) ; delay(900 ) ; }2. Как и в естественном языке: ставьте пробел после запятых и не ставьте до.
Плохо:
DigitalWrite(5 ,HIGH) ; digitalWrite(5 , HIGH) ; digitalWrite(5 ,HIGH) ;
Хорошо:
DigitalWrite(5 , HIGH) ;
3. Размещайте символ начала блока { на новой строке на текущем уровне отступа или в конце предыдущей. А символ конца блока } на отдельной строке на текущем уровне отступа:
Плохо:
void setup() { pinMode(5 , OUTPUT) ; } void setup() { pinMode(5 , OUTPUT) ; } void setup() { pinMode(5 , OUTPUT) ; }Хорошо:
void setup() { pinMode(5 , OUTPUT) ; } void setup() { pinMode(5 , OUTPUT) ; }4. Используйте пустые строки для разделения смысловых блоков:
Хорошо:
Ещё лучше:
void loop() { digitalWrite(5 , HIGH) ; delay(100 ) ; digitalWrite(5 , LOW) ; delay(900 ) ; digitalWrite(6 , HIGH) ; delay(100 ) ; digitalWrite(6 , LOW) ; delay(900 ) ; }О точках с запятыми
Вы могли заинтересоваться: зачем в конце каждого выражения ставится точка с запятой? Таковы правила C++. Подобные правила называются синтаксисом языка . По символу; компилятор понимает где заканчивается выражение.
Как уже говорилось, переносы строк для него - пустой звук, поэтому ориентируется он на этот знак препинания. Это позволяет записывать сразу несколько выражений в одной строке:
void loop() { digitalWrite(5 , HIGH) ; delay(100 ) ; digitalWrite(5 , LOW) ; delay(900 ) ; }Программа корректна и эквивалентна тому, что мы уже видели. Однако писать так - это дурной тон. Код гораздо сложнее читается. Поэтому если у вас нет 100% веских причин писать в одной строке несколько выражений, не делайте этого.
О комментариях
Одно из правил качественного программирования: «пишите код так, чтобы он был настолько понятным, что не нуждался бы в пояснениях». Это возможно, но не всегда. Для того, чтобы пояснить какие-то не очевидные моменты в коде его читателям: вашим коллегам или вам самому через месяц, существуют так называемые комментарии.
Это конструкции в программном коде, которые полностью игнорируются компилятором и имеют значение только для читателя. Комментарии могут быть многострочными или однострочными:
/* Функция setup вызывается самой первой, при подаче питания на Arduino А это многострочный комментарий */ void setup() { // устанавливаем 13-й пин в режим вывода pinMode(13 , OUTPUT) ; } void loop() { digitalWrite(13 , HIGH) ; delay(100 ) ; // спим 100 мс digitalWrite(13 , LOW) ; delay(900 ) ; }Как видите, между символами /* и */ можно писать сколько угодно строк комментариев. А после последовательности / / комментарием считается всё, что следует до конца строки.
Итак, надеемся самые основные принципы составления написания программ стали понятны. Полученные знания позволяют программно управлять подачей питания на пины Arduino по определённым временны́м схемам. Это не так уж много, но всё же достаточно для первых экспериментов.
Здравствуйте! Я Аликин Александр Сергеевич, педагог дополнительного образования, веду кружки «Робототехника» и «Радиотехника» в ЦДЮТТ г. Лабинска. Хотел бы немного рассказать об упрощенном способе программирования Arduino с помощью программы «ArduBloсk».
Эту программу я ввел в образовательный процесс и восхищен результатом, у детей она пользуется особым спросом, особенно при написании простейших программ или для создания какого-то начального этапа сложных программ. ArduBloсk является графической средой программирования, т. е. все действия выполняются с нарисованными картинками с подписанными действиями на русском языке, что в разы упрощает изучение платформы Arduino. Дети уже со 2-го класса с легкостью осваивают работу с Arduino благодаря этой программе.
Да, кто-то может сказать, что еще существует Scratch и он тоже очень простая графическая среда для программирования Arduino. Но Scratch не прошивает Arduino, а всего лишь управляет им по средством USB кабеля. Arduino зависим от компьютера и не может работать автономно. При создании собственных проектов автономность для Arduino - это главное, особенно при создании роботизированных устройств.
Даже всеми известные роботы LEGO, такие как NXT или EV3 нашим ученикам уже не так интересны с появлением в программировании Arduino программы ArduBloсk. Еще Arduino намного дешевле любых конструкторов LEGO и многие компоненты можно просто взять от старой бытовой электронной техники. Программа ArduBloсk поможет в работе не только начинающим, но и активным пользователям платформы Arduino.
Итак, что же такое ArduBloсk? Как я уже говорил, это графическая среда программирования. Практически полностью переведена на русский язык. Но в ArduBloсk изюминка не только это, но и то, что написанную нами программу ArduBloсk конвертирует в код Arduino IDE. Эта программа встраивается в среду программирования Arduino IDE, т. е. это плагин.
Ниже приведен пример мигающего светодиода и конвертированной программы в Arduino IDE. Вся работа с программой очень проста и разобраться в ней сможет любой школьник.
В результате работы на программе можно не только программировать Arduino, но и изучать непонятные нам команды в текстовом формате Arduino IDE, ну а если же «лень» писать стандартные команды - стоит быстрыми манипуляциями мышкой набросать простенькую программку в ArduBlok, а в Arduino IDE её отладить.
Чтобы установить ArduBlok, необходимо для начала загрузить и установить Arduino IDE с официального сайта Arduino и разобраться с настройками при работе с платой Arduino UNO. Как это сделать описано на том же сайте или же на Амперке , либо посмотреть на просторах YouTube. Ну, а когда со всем этим разобрались, необходимо скачать ArduBlok с официального сайта, вот . Последние версии скачивать не рекомендую, для начинающих они очень сложны, а вот версия от 2013-07-12 - самое то, этот файл там самый популярный.
Затем, скачанный файл переименовываем в ardublock-all и в папке «документы». Создаем следующие папки: Arduino > tools > ArduBlockTool > tool и в последнею кидаем скачанный и переименованный файл. ArduBlok работает на всех операционных системах, даже на Linux, проверял сам лично на XP, Win7, Win8, все примеры для Win7. Установка программы для всех систем одинакова.
Ну, а если проще, я приготовил на Mail-диске 7z архив , распаковав который найдете 2 папки. В одной уже рабочая программа Arduino IDE, а в другой папке содержимое необходимо отправить в папку документы.
Для того, чтобы работать в ArduBlok, необходимо запустить Arduino IDE. После чего заходим во вкладку Инструменты и там находим пункт ArduBlok, нажимаем на него - и вот она, цель наша.
Теперь давайте разберемся с интерфейсом программы. Как вы уже поняли, настроек в ней нет, а вот значков для программирования предостаточно и каждый из них несет за собой команду в текстовом формате Arduino IDE. В новых версиях значков еще больше, поэтому разобраться с ArduBlok последней версии сложно и некоторые из значков не переведены на русский.
В разделе «Управление» мы найдем разнообразные циклы.
В разделе «Порты» мы можем с вами управлять значениями портов, а также подключенными к ним звукоизлучателя, сервомашинки или ультразвукового датчика приближения.
В разделе «Числа/Константы» мы можем с вами выбрать цифровые значения или создать переменную, а вот то что ниже вряд ли будите использовать.
В разделе «Операторы» мы с вами найдем все необходимые операторы сравнения и вычисления.
В разделе «Утилиты» в основном используются значки со временем.
«TinkerKit Bloks»- это раздел для приобретенных датчиков комплекта TinkerKit. Такого комплекта у нас, конечно же, нет, но это не значит, что для других наборов значки не подойдут, даже наоборот - ребятам очень удобно использовать такие значки, как включения светодиода или кнопка. Эти знаки используются практически во всех программах. Но у них есть особенность - при их выборе стоят неверные значки обозначающие порты, поэтому их необходимо удалить и подставить значок из раздела «числа/константы» самый верхний в списке.
«DF Robot» - этот раздел используется при наличии указанных в нем датчиков, они иногда встречаются. И наш сегодняшний пример - не исключение, мы имеем «Регулируемый ИК выключатель» и «Датчик линии». «Датчик линии» отличается от того, что на картинке, так как он от фирмы Амперка. Действия их идентичны, но датчик от Амперки намного лучше, так как в нем имеется регулятор чувствительности.
«Seeedstudio Grove» - датчики этого раздела мной ни разу не использовались, хотя тут только джойстики. В новых версиях этот раздел расширен.
И последний раздел это «Linker Kit». Датчики, представленные в нем, мне не попадались.
Хочется показать пример программы на роботе, двигающемся по полосе. Робот очень прост, как в сборке, так и в приобретении, но обо всем по порядку. Начнем с его приобретения и сборки.
Вот сам набор деталей все было приобретено на сайте Амперка .
- AMP-B001 Motor Shield (2 канала, 2 А) 1 890 руб
- AMP-B017 Troyka Shield 1 690 руб
- AMP-X053 Батарейный отсек 3×2 AA 1 60 руб
- AMP-B018 Датчик линии цифровой 2 580 руб
- ROB0049 Двухколёсная платформа miniQ 1 1890 руб
- SEN0019 Инфракрасный датчик препятствий 1 390 руб
- FIT0032 Крепление для инфракрасного датчика препятствий 1 90 руб
- A000066 Arduino Uno 1 1150 руб
Для начала соберем колесную платформу и припаяем к двигателям провода.
Затем установим стойки, для крепления платы Arduino UNO, которые были взяты от старой материнской платы ну или иные подобные крепления.
Затем крепим на эти стойки плату Arduino UNO, но один болтик прикрутить не получиться - разъемы мешают. Можно, конечно, их выпаять, но это уже на ваше усмотрение.
Следующим крепим инфракрасный датчик препятствий на его специальное крепление. Обратите внимание, что регулятор чувствительности находиться сверху, это для удобства регулировки.
Теперь устанавливаем цифровые датчики линии, тут придется поискать пару болтиков и 4 гайки к ним Две гайки устанавливаем между самой платформой и датчиком линии, а остальными фиксируем датчики.
Следующим устанавливаем Motor Shield или по другому можно назвать драйвер двигателей. В нашем случае обратите внимание на джампер. Мы не будем использовать отдельное питание для двигателей, поэтому он установлен в этом положение. Нижняя часть заклеивается изолентой, это чтобы не было случайных замыканий от USB разъема Arduino UNO, это на всякий случай.
Сверху Motor Shield устанавливаем Troyka Shield. Он необходим для удобства соединения датчиков. Все используемые нами сенсоры цифровые, поэтому датчики линии подключены к 8 и 9 порту, как их еще называют пины, а инфракрасный датчик препятствий подключен к 12 порту. Обязательно обратите внимание, что нельзя использовать порты 4, 5, 6, 7 так как оны используются Motor Shield для управлением двигателями. Я эти порты даже специально закрасил красным маркером, чтобы ученики разобрались.
Если вы уже обратили внимание, мной была добавлена черная втулка, это на всякий случай, чтобы установленный нами батарейный отсек не вылетел. И наконец, всю конструкцию мы фиксируем обычной резинкой.
Подключения батарейного отсека может быть 2-х видов. Первый подключение проводов к Troyka Shield. Также возможно подпаять штекер питания и подключать уже к самой плате Arduino UNO.
Вот наш робот готов. Перед тем как начать программировать, надо будет изучить, как все работает, а именно:
- Моторы:
Порт 4 и 5 используются для управления одним мотором, а 6 и 7 другим;
Скоростью вращения двигателей мы регулируя ШИМом на портах 5 и 6;
Вперед или назад, подавая сигналы на порты 4 и 7.
- Датчики:
У нас все цифровые, поэтому дают логические сигналы в виде 1 либо 0;
А что бы их отрегулировать, в них предусмотрены специальные регуляторы а при помощи подходящей отвертки их можно откалибровать.
Подробности можно узнать на Амперке . Почему тут? Потому что там очень много информации по работе с Arduino.
Ну что ж, мы, пожалуй, все просмотрели поверхностно, изучили и конечно же собрали робота. Теперь его необходимо запрограммировать, вот она - долгожданная программа!
И программа конвертированная в Arduino IDE:
Void setup() { pinMode(8 , INPUT); pinMode(12 , INPUT); pinMode(9 , INPUT); pinMode(4 , OUTPUT); pinMode(7 , OUTPUT); pinMode(5, OUTPUT); pinMode(6, OUTPUT); } void loop() { if (digitalRead(12)) { if (digitalRead(8)) { if (digitalRead(9)) { digitalWrite(4 , HIGH); analogWrite(5, 255); analogWrite(6, 255); digitalWrite(7 , HIGH); } else { digitalWrite(4 , HIGH); analogWrite(5, 255); analogWrite(6, 50); digitalWrite(7 , LOW); } } else { if (digitalRead(9)) { digitalWrite(4 , LOW); analogWrite(5, 50); analogWrite(6, 255); digitalWrite(7 , HIGH); } else { digitalWrite(4 , HIGH); analogWrite(5, 255); analogWrite(6, 255); digitalWrite(7 , HIGH); } } } else { digitalWrite(4 , HIGH); analogWrite(5, 0); analogWrite(6, 0); digitalWrite(7 , HIGH); } }
В заключении хочу сказать, эта программа просто находка для образования, даже для самообучения она поможет изучить команды Arduino IDE. Самая главная изюминка - это то, что более 50 значков установки, она начинает «глючить». Да, действительно, это изюминка, так как постоянное программирование только на ArduBlok не обучит вас программированию в Arduino IDE. Так называемый «глюк» дает возможность задумываться и стараться запоминать команды для точной отладки программ.
Желаю успехов.
В жизни ардуинщика рано или поздно наступает момент, когда в штатной среде разработки становится тесно. Если скетчам перестает хватать памяти, требуется жесткий реалтайм и работа с прерываниями или просто хочется быть ближе к железу - значит пришло время переходить на C. Бывалые электронщики при упоминании Arduino презрительно поморщатся и отправят новичка в радиомагазин за паяльником. Возможно, это не самый плохой совет, но мы пока не будем ему следовать. Если отбросить Arduino IDE и язык wiring/processing, у нас в руках останется прекрасная отладочная плата, уже оснащенная всем необходимым для работы микроконтроллера. И, что немаловажно, в память контроллера уже зашит бутлоадер, позволяющий загружать прошивку без использования программатора.
Для программирования на языке C нам понадобится AVR GCC Toolchain.
Также нам потребуется установленная Arduino IDE, т.к. она содержит утилиту avrdude, которая нужна для загрузки прошивки в контроллер. CrossPack тоже содержит avrdude, но версия, идущая с ним, не умеет работать с Arduino.
После того, как все установлено, создадим наш первый проект. Для начала напишем Makefile . Он позволит нам избежать ввода длинных команд вручную при каждой компиляции и загрузке прошивки.
#Контроллер, установленный на плате. Может быть другим, например atmega328 DEVICE = atmega168 #Тактовая частота 16 МГц CLOCK = 16000000 #Команда запуска avrdude. Ее нужно скопировать из Arduino IDE. AVRDUDE = /Applications/Arduino.app/Contents/Resources/Java/hardware/tools/avr/bin/avrdude -C/Applications/Arduino.app/Contents/Resources/Java/hardware/tools/avr/etc/avrdude.conf -carduino -P/dev/tty.usbserial-A600dAAQ -b19200 -D -p atmega168 OBJECTS = main.o COMPILE = avr-gcc -Wall -Os -DF_CPU=$(CLOCK) -mmcu=$(DEVICE) all: main.hex .c.o: $(COMPILE) -c $< -o $@ .S.o: $(COMPILE) -x assembler-with-cpp -c $< -o $@ .c.s: $(COMPILE) -S $< -o $@ flash: all $(AVRDUDE) -U flash:w:main.hex:i clean: rm -f main.hex main.elf $(OBJECTS) main.elf: $(OBJECTS) $(COMPILE) -o main.elf $(OBJECTS) main.hex: main.elf rm -f main.hex avr-objcopy -j .text -j .data -O ihex main.elf main.hex avr-size --format=avr --mcu=$(DEVICE) main.elf
В этом файле нам нужно вписать свою команду для запуска avrdude. На разных системах она будет выглядеть по разному. Чтобы узнать свой вариант, запускаем Arduino IDE и в настройках ставим галочку «Show verbose output during upload».
Теперь загружаем в Arduino любой скетч и смотрим сообщения, выводимые в нижней части окна. Находим там вызов avrdude, копируем все, кроме параметра -Uflash и вставляем в Makefile после «AVRDUDE = ».
Небольшое замечание: все отступы в Makefile делаются символами табуляции (клавишей Tab). Если ваш текстовый редактор заменяет эти символы пробелами, команда make откажется собирать проект.
Теперь создадим файл main.c - собственно текст нашей программы, в которой традиционно помигаем светодиодом.
#include
Наш проект готов. Откроем консоль в директории нашего проекта и введем команду «make»:
Как видим, размер получившейся прошивки составляет всего 180 байт. Аналогичный ардуиновский скетч занимает 1116 байт в памяти контроллера.
Теперь вернемся к консоли и введем «make flash» чтобы загрузить скомпилированный файл в контроллер:
Если загрузка прошла без ошибок, то светодиод, подключенный к 13 контакту платы, радостно замигает. Иногда avrdude не может найти плату или отваливается по таймауту - в этом случае может помочь передегивание USB кабеля. Также, во избежание конфликтов доступа к плате, не забудьте закрыть Arduino IDE перед командой «make flash».
Возможно многие вещи, описанные в этой статье, покажутся очевидными матерым разработчикам. Я постарался описать процесс максимально понятным для начинающего ардуинщика языком и собрать в одном месте информацию, которую мне удалось добыть в различных источниках, и проверенную опытным путем. Может быть кому-то эта статья сэкономит пару часов времени.
Удачи в освоении микроконтроллеров!
Этот симулятор лучше всего работает в браузере Chrome
Давайте рассмотрим Arduino по внимательней.
Arduino это не большой компьютер, к которому могут подключаться внешние цепи. В Arduino Uno используется Atmega 328P
Это самый большой чип на плате. Этот чип выполняет программы, которые хранятся в его памяти. Вы можете загрузить программу через usb с помощью Arduino IDE. Usb порт также обеспечивает питание arduino.
Есть отдельный разъём питания. На плате есть два вывода обозначенные 5v и 3.3v, которые нужны для того, чтобы запитывать различные устройства. Так же вы найдете контакты, помеченные как GND, это выводы земли (земля это 0В). Платформа Arduino, так же, имеет 14 цифровых выводов (пинов), помеченных цифрами от 0 до 13, которые подключаются к внешним узлам и имеют два состояния высокое или низкое (включено или выключено). Эти контакты могут работать как выходы или как входы, т.е. они могут либо передавать какие-то данные и управлять внешними устройствами, либо получать данные с устройств. Следующие выводы на плате обозначены А0-А5. Это аналоговые входы, которые могут принимать данные с различных датчиков. Это особенно удобно, когда вам надо измерить некий диапазон, например температуру. У аналоговых входов есть дополнительные функции, которые можно задействовать отдельно.
Как использовать макетную плату.
Макетная плата нужна для того чтобы временно соединить детали, проверить, как работает устройство, до того как вы спаяете все вместе.
Все нижеследующие примеры собраны на макетной плате, чтобы можно было быстро вносить изменения в схему и повторно использовать детали не заморачиваясь с пайкой.
В макетной плате есть ряды отверстий, в которые вы можете вставлять детали и провода. Некоторые из этих отверстий электрически соединены друг с другом.
Два верхних и нижних ряда соединены по - рядно вдоль всей платы. Эти ряды используются, чтобы подавать питание на схему. Это может быть 5в или 3.3в, но в любом случае, первое, что вам надо сделать - это подключить 5в и GND на макетную плату, как показано на рисунке. Иногда эти соединения рядов могут прерываться посередине платы, тогда, если вам понадобится, вы можете их соединить, как показано на рисунке.
Остальные отверстия, расположенные в середине платы, группируются по пять отверстий. Они используется для соединения деталей схемы.
Первое, что мы подключим к нашему микроконтроллеру, это светодиод. Схема электрических соединений показана на картинке.
Для чего нужен резистор в схеме? В данном случае он ограничивает ток, который проходит через светодиод. Каждый светодиод рассчитан на определённый ток, и если этот ток будет больше, то светодиод выйдет из строя. Узнать, какого номинала должен быть резистор можно с помощью закона ома. Для тех кто не знает или забыл, закон ома говорит, что существует линейная зависимость тока от напряжения. Т.е, чем больше мы приложим напряжение к резистору, тем больше потечет через него ток.
V=I*R
Где V
-напряжение на резистор
I
- ток через резистор
R
- сопротивление, которое надо найти.
Во-первых, мы должны узнать напряжение на резистор. Большинство светодиодов 3мм или 5мм, которые вы будете использовать, имеют рабочее напряжение 3в. Значит, на резисторе нам надо погасить 5-3=2в.
Затем мы вычислим ток, проходящий через резистор.
Большинство 3 и 5мм светодиодов светятся полной яркостью при токе 20мА. Ток больше этого может вывести их из строя, а ток меньшей силы снизит их яркость, не причинив никакого вреда.
Итак, мы хотим включить светодиод в цепь 5в,чтобы на нем был ток 20мА. Так как все детали включены в одну цепь на резистор тоже будет ток 20мА.
Мы получаем
2В = 20 мА * R
2В = 0.02A * R
R = 100 Ом
100 Ом это минимальное сопротивление, лучше использовать немного больше, потому, что светодиоды имеют некоторый разброс характеристик.
В данном примере используется резистор 220 Ом. Только потому, что у автора их очень много:wink: .
Вставьте светодиод в отверстия посередине платы таким образом, чтобы его длинный вывод был соединён с одним из выводов резистора. Второй конец резистора соедините с 5V, а второй вывод светодиода соедините с GND. Светодиод должен загореться.
Обратите внимание, что есть разница, как соединять светодиод. Ток течёт от более длинного вывода к более короткому. На схеме это можно представить, что ток течёт в ту сторону, куда направлен треугольник. Попробуйте перевернуть светодиод и вы увидите, что он не будет светиться.
А вот как вы будете соединять резистор, разницы совсем нет. Можете его перевернуть или попробовать подсоединить к другому выводу светодиода, это не повлияет на работу схемы. Он все так же будет ограничивать ток через светодиод.
Анатомия Arduino Sketch.
Программы для Arduino называют sketch. Они состоят из двух основных функций. Функция setup
и функция loop
внутри этой функции вы будете задавать все основные настройки. Какие выводы будут работать на вход или выход, какие библиотеки подключать, инициализировать переменные. Функция Setup()
запускается только один раз в течение скетча, когда стартует выполнение программы.
это основная функция, которая выполняется после setup()
. Фактически это сама программа. Это функция будет выполняться бесконечно, пока вы не выключите питание.
Arduino мигает светодиодом
В этом примере мы соединим схему со светодиодом к одному из цифровых выводов Arduino и будем включать и выключать его с помощью программы, а так же вы узнаете несколько полезных функций.
Эта функция используется в setup () части программы и служит для инициализации выводов, которые вы будете использовать, как вход (INPUT) или выход (OUTPUT) . Вы не сможете считать или записать данные с пина, пока не установите его соответственно в pinMode . Эта функция имеет два аргумента: pinNumber - это номер пина, который вы будете использовать.
Mode
-задает, как пин будет работать. На вход (INPUT)
или выход (OUTPUT)
. Чтобы зажечь светодиод мы должны подать сигнал ИЗ
Arduino. Для этого мы настраиваем пин на выход.
- эта функция служит для того, чтобы задать состояние (state)
пина (pinNumber)
. Есть два основных состояния (вообще их 3), одно это HIGH
, на пине будет 5в, другое это Low
и на пине будет 0в. Значит, чтобы зажечь светодиод нам надо на пине, соединенном со светодиодом выставить высокий уровень HIGH
.
Задержка. Служит для задержки работы программы на заданный в мсек период.
Ниже приведен код, который заставляет мигать светодиод.
//LED Blink
int ledPin = 7;//пин Arduino к которому подключен светодиод
void setup() {
pinMode(ledPin, OUTPUT);// установка пина как ВЫХОД
}
void loop() {
digitalWrite(ledPin, HIGH);//зажечь светодиод
delay(1000);// задержка 1000 мсек (1 сек)
digitalWrite(ledPin, LOW);//Выключить светодиод
delay(1000);//ждать 1 сек
}
Небольшие пояснения по коду.
Строки, которые начинаются с "//" это комментарии Arduino их игнорирует.
Все команды заканчиваются точкой с запятой, если вы их забудете, то получите сообщение об ошибке.
ledPin
- это переменная. Переменные используются в программах для хранения значений. В данном примере переменной ledPin
присваивается значение 7, это номер пина Arduino. Когда Arduino в программе встретит строку с переменной ledPin
, он будет использовать то значение, которое мы указали ранее.
Так запись pinMode(ledPin, OUTPUT)
аналогична записи pinMode(7, OUTPUT)
.
Но в первом случае вам достаточно поменять переменную и она поменяется в каждой строке, где используется, а во втором случае вам, чтобы поменять переменную, придётся ручками в каждой команде вносить изменения.
В первой строке указывает на тип переменной. При программировании Arduino важно всегда объявлять тип переменных. Пока вам достаточно знать, что INT
объявляет отрицательные и положительные числа.
Ниже представлено моделирование скетча. Нажмите старт, чтобы посмотреть работу схемы.
Как и ожидалось, светодиод гаснет и загорается через одну секунду. Попробуйте поменять задержку, чтобы посмотреть, как она работает.
Управление несколькими светодиодами.
В этом примере вы узнаете, как управлять несколькими светодиодами. Для этого установите ещё 3 светодиода на плату и соедините их с резисторами и выводами Arduino, как показано ниже.
Для того, чтобы включать и выключать светодиоды по очереди надо написать программу подобную этой:
//Multi LED Blink
int led1Pin = 4;
int led2Pin = 5;
int led3Pin = 6;
int led4Pin = 7;
void setup() {
//установка пинов как ВЫХОД
pinMode(led1Pin, OUTPUT);
pinMode(led2Pin, OUTPUT);
pinMode(led3Pin, OUTPUT);
pinMode(led4Pin, OUTPUT);
}
void loop() {
digitalWrite(led1Pin, HIGH);//зажечь светодиод
delay(1000);//задержка 1 сек
digitalWrite(led1Pin, LOW);//потушить светодиод
delay(1000);//задержка 1 сек
//do the same for the other 3 LEDs
digitalWrite(led2Pin, HIGH);//зажечь светодиод
delay(1000);// задержка 1 сек
digitalWrite(led2Pin, LOW);//потушить светодиод
delay(1000);//задержка 1 сек
digitalWrite(led3Pin, HIGH);//зажечь светодиод
delay(1000);// задержка 1 сек
digitalWrite(led3Pin, LOW);//потушить светодиод
delay(1000);//задержка 1 сек
digitalWrite(led4Pin, HIGH);//зажечь светодиод
delay(1000);// задержка 1 сек
digitalWrite(led4Pin, LOW);//потушить светодиод
delay(1000);//задержка 1 сек
}
Эта программа будет отлично работать, но это не самое рациональное решение. Код надо изменить. Для того, чтобы программа работала раз за разом мы применим конструкцию, которая называется .
Циклы удобны, когда надо повторить одно и тоже действие несколько раз. В коде, проведенном выше мы повторяем строки
DigitalWrite (led4Pin, HIGH);
delay (1000);
digitalWrite (led4Pin, LOW);
delay (1000);
полный код скетча во вложении
(скачиваний: 1187)
Регулировка яркости светодиодов
Иногда вам надо будет менять яркость светодиодов в программе. Это можно сделать с помощью команды analogWrite()
. Эта команда так быстро включает и выключает светодиод, что глаз не видит это мерцание. Если светодиод половину времени будет включён, а половину выключен, то визуально будет казаться, что он светится в половину своей яркости. Это называется широтно-импульсная модуляция (ШИМ или PWM по-английски). Шим применяется довольно часто, так как с ее помощью можно управлять "аналоговым" компонентом с помощью цифрового кода. Не все выводы Arduino подходят для этих целей. Только те выводы, около которых нарисовано такое обозначение "~
". Вы увидите его рядом с выводами 3,5,6,9,10,11.
Соедините один из ваших светодиодов с одним из выводов ШИМ(у автора это вывод 9). Теперь запуститьскетч мигания светодиода, но прежде измените команду digitalWrite()
на analogWrite()
. analogWrite()
имеет два аргумента: первый это номер вывода, а второй- значение ШИМ (0-255), применительно к светодиодам это будет их яркость свечения, а для электродвигателей скорость вращения. Ниже представлен код примера для разной яркости светодиода.
//Меняем яркость светодиода
int ledPin = 9;//к этому выводу подсоединен светодиод
void setup() {
pinMode(ledPin, OUTPUT);// инициализация пина на вывод
}
void loop() {
analogWrite(ledPin, 255);//полная яркость (255/255 = 1)
delay(1000);// пауза 1 сек
digitalWrite(ledPin, LOW);//выключить светодиод
delay(1000);//пауза 1 сек
analogWrite(ledPin, 191);//яркость на 3/4 (191/255 ~= 0.75)
delay(1000);//пауза 1 сек
digitalWrite(ledPin, LOW);//выключить светодиод
delay(1000);//пауза 1 сек
analogWrite(ledPin, 127);//половина яркости (127/255 ~= 0.5)
delay(1000);// пауза 1 сек
digitalWrite(ledPin, LOW);//выключить светодиод
delay(1000);//пауза 1 сек
analogWrite(ledPin, 63);//четверть яркости (63/255 ~= 0.25)
delay(1000);// пауза 1 сек
digitalWrite(ledPin, LOW);//выключить светодиод
delay(1000);//пауза 1 сек
}
Попробуйте поменять значение ШИМ в команде analogWrite ()
,чтобы увидеть, как это влияет на яркость.
Далее вы узнаете, как регулировать яркость плавно от полной до нулевой. Можно,конечно, скопировать кусок кода 255 раз
analogWrite(ledPin, brightness);
delay(5);//short delay
brightness = brightness + 1;
Но, сами понимаете - это будет не практично. Для этого лучше всего использовать цикл FOR, который использовали ранее.
В следующем примере используются два цикла, один для уменьшения яркости от 255 до 0
for (int brightness=0;brightness=0;brightness--){
analogWrite(ledPin,brightness);
delay(5);
}
delay(5)
используется, чтобы замедлить скорость нарастания и уменьшения яркости 5*256=1280 мсек= 1.28 сек.)
В первой строке используется "brightness-
" ,для того чтобы значение яркости уменьшалось на 1, каждый раз, когда цикл повторяется. Обратите внимание, что цикл будет работать до тех пор, пока brightness >=0
.Заменив знак >
на знак >=
мы включили 0 в диапазон яркости. Ниже смоделирован этот скетч. //плавно меняем яркость
int ledPin = 9;//к этому пину подключен светодиод
void setup() {
pinMode(ledPin, OUTPUT);// инициализация пина на выход
}
void loop() {
//плавно увеличиваем яркость (0 to 255)
for (int brightness=0;brightness=0;brightness--){
analogWrite(ledPin,brightness);
delay(5);
}
delay(1000);//ждем 1 сек
//плавно уменьшаем яркость (255 to 0)
for (int brightness=255;brightness>=0;brightness--){
analogWrite(ledPin,brightness);
delay(5);
}
delay(1000);//ждем 1 сек
}
}
Это видно не очень хорошо, но идея понятна.
RGB-светодиод и Arduino
RGB-светодиод на самом деле это три светодиода разного цвета в одном корпусе.
Включая разные светодиоды с различной яркостью можно комбинировать и получать разные цвета. Для Arduino, где количество градаций яркости равно 256 вы получите 256^3=16581375 возможных цветов. Реально их, конечно, будет меньше.
Светодиод, который мы будем использоваться общим катодом. Т.е. все три светодиода конструктивно соединены катодами к одному выводу. Этот вывод мы подсоединим к выводу GND. Остальные выводы, через ограничительные резисторы, надо подсоединить к выводам ШИМ. Автор использовал выводы 9-11.Таким образом можно будет управлять каждым светодиодом отдельно. В первом скетче показано, как включить каждый светодиод отдельно.
//RGB LED - test //pin connections int red = 9; int green = 10; int blue = 11; void setup(){ pinMode(red, OUTPUT); pinMode(blue, OUTPUT); pinMode(green, OUTPUT); } void loop(){ //включение/выключение красного светодиод digitalWrite(red, HIGH); delay(500); digitalWrite(red, LOW); delay(500); //включение/выключение зеленого светодиода digitalWrite(green, HIGH); delay(500); digitalWrite(green, LOW); delay(500); //включение/выключение синего светодиода digitalWrite(blue, HIGH); delay(500); digitalWrite(blue, LOW); delay(500); }
В следующем примере используются команды analogWrite()
и , чтобы получать различные случайные значения яркости для светодиодов. Вы увидите разные цвета, меняющиеся случайным образом.
//RGB LED - random colors
//pin connections
int red = 9;
int green = 10;
int blue = 11;
void setup(){
pinMode(red, OUTPUT);
pinMode(blue, OUTPUT);
pinMode(green, OUTPUT);
}
void loop(){
//pick a random color
analogWrite(red, random(256));
analogWrite(blue, random(256));
analogWrite(green, random(256));
delay(1000);//wait one second
}
Random(256)
-возвращает случайное число в диапазоне от 0 до 255.
В прикрепленном файле скетч, который продемонстрирует плавные переходы цветов от красного к зеленому, затем к синему, красному, зеленому и т.д.
(скачиваний: 326)
Пример скетча работает, но есть много повторяющегося кода. Можно упростить код, написав собственную вспомогательную функцию, которая будет плавно менять один цвет на другой.
Вот как она будет выглядеть:
(скачиваний: 365)
Давайте рассмотрим определение функции по частям. Функция называется fader
и имеет два аргумента. Каждый аргумент отделяется запятой и имеет тип объявленный в первой строке определения функции: void fader (int color1, int color2)
. Вы видите, что оба аргумента объявлены как int
, и им присвоены имена color1
и color2
в качестве условных переменных для определения функции. Void
означает, что функция не возвращает никаких значений, она просто выполняет команды. Если надо было бы написать функцию, которая возвращала результат умножения это выглядело бы так:
int multiplier(int number1, int number2){
int product = number1*number2;
return product;
}
Обратите внимание, как мы объявили Тип int
в качестве типа возвращаемого значения вместо
void
.
Внутри функции идут команды, которые вы уже использовали в предыдущем скетче, только номера выводов заменили на color1
и color2
. Вызывается функция fader
, ее аргументы вычисляются как color1 = red
и color2 = green
. В архиве полный скетч с использованием функций
(скачиваний: 272)
Кнопка
В следующем скетче будет использоваться кнопка с нормально разомкнутыми контактами, без фиксации.
Это значит, что пока кнопка не нажата, ток через неё не идёт, а после отпускания, кнопка возвращается в исходное положение.
В схеме, помимо кнопки используется резистор. В данном случае он не ограничивает ток, а "подтягивает" кнопку к 0в (GND). Т.е. пока кнопка не нажата на выводе Arduino, к которому она подключена, будет низкий уровень. Резистор, используемый в схеме 10 кОм.
//определяем нажатие кнопки int buttonPin = 7; void setup(){ pinMode(buttonPin, INPUT);//инициализируем пин на вход Serial.begin(9600);//инициализируем последовательный порт } void loop(){ if (digitalRead(buttonPin)==HIGH){//если кнопка нажата Serial.println("pressed"); // выводим надпись "pressed" } else { Serial.println("unpressed");// иначе "unpressed" } }
В этом скетче несколько новых команд.
-эта команда принимает значение High (высокий уровень) и low (низкий уровень), того вывода, который мы проверяем. Предварительно в setup() этот вывод надо настроить на вход.
; //где buttonPin это номер вывода, куда подсоединяется кнопка.
Последовательный порт позволяет отправлять Arduino сообщения на компьютер, в то время, как сам контроллер выполняет программу. Это полезно для отладки программы, отправки сообщений на другие устройства или приложения. Чтобы включить передачу данных через последовательный порт (другое название UART или USART), надо инициализировать его в setup()
Serial.begin() имеет всего один аргумент-это скорость передачи данных между Arduino и компьютером.
скетче используется команда для вывода сообщения на экран в Arduino IDE (Tools >> Serial Monitor).
- конструкция позволяют контролировать ход выполнения программы, объеденив несколько проверок в одном месте.
If(если) digitalRead возвращает значение HIGH, то на мониторе выводится слово "нажата". Else(иначе) на мониторе выводится слово " отжата" . Теперь можно попробовать включать и выключать светодиод по нажатию кнопки.
//button press detection with LED output int buttonPin = 7; int ledPin = 8; void setup(){ pinMode(buttonPin, INPUT);//this time we will set button pin as INPUT pinMode(ledPin, OUTPUT); Serial.begin(9600); } void loop(){ if (digitalRead(buttonPin)==HIGH){ digitalWrite(ledPin,HIGH); Serial.println("pressed"); } else { digitalWrite(ledPin,LOW); Serial.println("unpressed"); } }
Аналоговый вход.
analogRead
позволяет считать данные с одного из аналоговых выводов Arduino и выводит значение в диапазоне от 0 (0В) до 1023 (5В). Если напряжение на аналоговом входе будет равно 2.5В, то будет напечатано 2.5 / 5 * 1023 = 512
analogRead
имеет только один аргумент- Это номер аналогового входа (А0-А5). В следующем скетче приводится код считывания напряжения с потенциометра. Для этого подключите переменный резистор, крайними выводами на пины 5V и GND, а средний вывод на вход А0.
Запустите следующий код и посмотрите в serial monitor, как меняются значения в зависимости от поворота ручки резистора.
//analog input
int potPin = A0;//к этому пину подсоединяется центральный вывод потенциометра
void setup(){
//аналоговый пин по умолчанию включен на вход, поэтому инициализация не нужна
Serial.begin(9600);
}
void loop(){
int potVal = analogRead(potPin);//potVal is a number between 0 and 1023
Serial.println(potVal);
}
Следующий скетч объединяет скетч нажатия кнопки и скетч управления яркостью светодиода. Светодиод будет включаться от кнопки, и управлять яркостью свечения будет потенциометр.
//button press detection with LED output and variable intensity
int buttonPin = 7;
int ledPin = 9;
int potPin = A0;
void setup(){
pinMode(buttonPin, INPUT);
pinMode(ledPin, OUTPUT);
Serial.begin(9600);
}
void loop(){
if (digitalRead(buttonPin)==HIGH){//if button pressed
int analogVal = analogRead(potPin);
int scaledVal = map(analogVal, 0, 1023, 0, 255);
analogWrite(ledPin, scaledVal);//turn on led with intensity set by pot
Serial.println("pressed");
} else {
digitalWrite(ledPin, LOW);//turn off if button is not pressed
Serial.println("unpressed");
}
}
