Как подключить много кнопок к arduino
Перейти к содержимому

Как подключить много кнопок к arduino

  • автор:

Arduino.ru

Добрый день. Имеется 52 клавиши 4 ряда по 13 кнопок. Буквеная клавиатура, нужно подключить к ардуино нано.

Каким образом реализовать подключение клавиш к ардуине?

Аналогавая клавиатура не подходит. Можно использовать плату от ps2 клавиатуры, но мне этот вариант тоже не подходит. Щас пробую подключить наподобие как подключены 4х4 keypad матрицей 4х13 (нужно использовать 17 цифрвых и аналоговых пинов, а библиотека работает только с цифровыми). Думаю что можно через входные сдвиговые регистры(какие лучше подойдут?).

  • Войдите на сайт для отправки комментариев

Работа с кнопками

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

  • С фиксацией – кнопка остаётся нажатой после отпускания, без фиксации – отключается обратно.
  • Нормально разомкнутая (Normal Open, NO) – при нажатии замыкает контакты. Нормально замкнутая (Normal Closed, NC) – при нажатии размыкает контакты.
  • Тактовые кнопки – замыкают или размыкают контакт. У обычных тактовых кнопок ноги соединены вдоль через корпус (см. картинку ниже). Переключатели – обычно имеют три контакта, общий COM, нормально открытый NO и нормально закрытый NC. При отпущенной кнопке замкнута цепь COM-NC, при нажатой замыкается COM-NO.

blank

Подключение и подтяжка

Из урока про цифровые пины вы помните, что микроконтроллер может считывать напряжение со своей ноги. Соответственно кнопка может подать на пин тот уровень, к которому подключена её вторая нога. В том же уроке мы обсуждали, что не подключенный никуда цифровой пин принимает наводки из воздуха, и считанное с него значение будет практически случайным. То есть подключив к пину 5V (сигнал высокого уровня) через кнопку, мы ничего не добьёмся: при нажатой кнопке на пине будет считываться четкий сигнал высокого уровня, а при отпущенной – случайное значение. Для решения этой проблемы существует такое понятие, как подтяжка (pull) пина. Подтяжка выполняется к земле (pull down) или питанию (pull up) микроконтроллера при помощи резистора. Подтяжка выполняется противоположно принимаемому сигналу, т.е. если нужно ловить высокий сигнал, подтяжка выполняется к земле, если ловить нужно сигнал земли – подтяжка выполняется к питанию. Вот два варианта подключения кнопки, с подтяжкой к VCC и GND соответственно: blank Как выбирается сопротивление резистора? Тут всё очень просто: при нажатии на кнопку через резистор потечёт ток, так как в любом случае замыкается цепь питание-земля. Чем выше ток, больше потери энергии и нагрев резистора, а это никому не нужно, поэтому сопротивление резистора подтяжки обычно выбирается в диапазоне 5-50 кОм. Если ставить больше – подтяжка может не обеспечить стабильный уровень сигнала на пине, а если ставить меньше – будут больше потери энергии в нагрев резистора: при сопротивлении в 1 ком через него потечёт ток величиной 5 В/1000 Ом = 5 мА, для сравнения плата Ардуино с МК в активном режиме потребляет 20-22 мА. Чаще всего для подтяжки используется резистор на 10 кОм. Как вы помните из урока о цифровых пинах, у МК AVR есть встроенные резисторы для всех GPIO, эти резисторы подключены к питанию (к VCC), то есть буквально дублируют первую схему из этого урока и позволяют не использовать внешний резистор. У микроконтроллеров другой архитектуры бывает подтяжка к GND, или вообще может не быть внутренней подтяжки. При использовании подтяжки к питанию мы получим инвертированный сигнал – функция digitalRead() вернёт 1 при отпущенной кнопке, и 0 при нажатой (при использовании нормально-разомкнутой кнопки). Давайте подключим кнопку на пин D3 (и GND):

void setup() < Serial.begin(9600); pinMode(3, INPUT_PULLUP); >void loop() < // выведет 0, если кнопка нажата // и 1, если нет Serial.println(digitalRead(3)); delay(10); >

Алгоритмы

Отработка нажатия

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

void setup() < Serial.begin(9600); pinMode(3, INPUT_PULLUP); >bool flag = false; void loop() < // читаем инвертированное значение для удобства bool btnState = !digitalRead(3); if (btnState && !flag) < // обработчик нажатия flag = true; Serial.println("press"); >if (!btnState && flag) < // обработчик отпускания flag = false; //Serial.println("release"); >>

Дребезг контактов

Кнопка не идеальна, и контакт замыкается не сразу, какое-то время он “дребезжит”. Прогоняя данный алгоритм, система опрашивает кнопку и условия приблизительно за 6 мкс, то есть кнопка опрашивается 166’666 раз в секунду! Этого достаточно, чтобы получить несколько тысяч ложных срабатываний. Избавиться от дребезга контактов можно как аппаратно, так и программно: аппаратно задача решается при помощи RC цепи, то есть резистора (~1-10k) и конденсатора (~100nF). Выглядит это следующим образом:

blank blank

Программно можно ввести простейший таймер нажатия, основанный на millis() , время гашения дребезга примем 100 миллисекунд. Вот так будет выглядеть код:

void setup() < Serial.begin(9600); pinMode(3, INPUT_PULLUP); >bool flag = false; uint32_t btnTimer = 0; void loop() < // читаем инвертированное значение для удобства bool btnState = !digitalRead(3); if (btnState && !flag && millis() - btnTimer >100) < flag = true; btnTimer = millis(); Serial.println("press"); >if (!btnState && flag && millis() - btnTimer > 100) < flag = false; btnTimer = millis(); //Serial.println("release"); >>

Рекомендуется конечно же использовать аппаратный способ, так как он не нагружает ядро лишними расчетами. В 99.99% проектов будет достаточно программного антидребезга, так то смело используйте конструкцию с millis() .

“Импульсное” удержание

В устройствах с управлением кнопкой очень часто бывает нужна возможность изменения значения как однократно кликом по кнопке, так и “автоматически” с тем же шагом – при удержании. Такой вариант реализуется очень просто, добавлением ещё одного условия в наш предыдущий алгоритм, а именно: если кнопка была нажата, но ещё не отпущена, и прошло времени больше, чем задано – условие вернёт true . В примере ниже периодичность “нажатий” при удержании настроена на 500 миллисекунд (2 раза в секунду):

void setup() < Serial.begin(9600); pinMode(3, INPUT_PULLUP); >bool flag = false; uint32_t btnTimer = 0; void loop() < // читаем инвертированное значение для удобства bool btnState = !digitalRead(3); if (btnState && !flag && millis() - btnTimer >100) < flag = true; btnTimer = millis(); Serial.println("press"); >if (btnState && flag && millis() - btnTimer > 500) < btnTimer = millis(); Serial.println("press hold"); >if (!btnState && flag && millis() - btnTimer > 500) < flag = false; btnTimer = millis(); //Serial.println("release"); >>

Пользоваться таким кодом напрямую будет неудобно, поэтому можно “обернуть” его в класс (читай урок про классы и урок про написание библиотек).

Простейший класс кнопки

Вот так предыдущий пример можно сделать классом (мы делали это вот в этом уроке), положить его в отдельный файл (button.h) и пользоваться:

class button < public: button (byte pin) < _pin = pin; pinMode(_pin, INPUT_PULLUP); >bool click() < bool btnState = digitalRead(_pin); if (!btnState && !_flag && millis() - _tmr >= 100) < _flag = true; _tmr = millis(); return true; >if (!btnState && _flag && millis() - _tmr >= 500) < _tmr = millis (); return true; >if (btnState && _flag) < _flag = false; _tmr = millis(); >return false; > private: byte _pin; uint32_t _tmr; bool _flag; >;

И пример с этой “библиотекой”:

// файл лежит в одной папке со скетчем #include "button.h" button btn1(3); // указываем пин button btn2(4); void setup() < Serial.begin(9600); >void loop() < // метод click() "срабатывает" однократно при клике // и импульсно при удержании if (btn1.click()) Serial.println("press 1"); if (btn2.click()) Serial.println("press 2"); >

Другие возможности кнопки

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

  • Работа с нормально замкнутыми и нормально разомкнутыми кнопками
  • Работа с подключением PULL_UP и PULL_DOWN Опрос кнопки с программным антидребезгом контактов (настраиваемое время)
  • Отработка нажатия, удерживания, отпускания, клика по кнопке (+ настройка таймаутов)
  • Отработка одиночного, двойного и тройного нажатия (вынесено отдельно)
  • Отработка любого количества нажатий кнопки (функция возвращает количество нажатий)
  • Функция изменения значения переменной с заданным шагом и заданным интервалом по времени
  • Возможность работы с “виртуальными” кнопками (все возможности библиотеки используются для матричных и резистивных клавиатур)

Подробное описание библиотеки можно почитать в заголовочном файле на странице библиотеки, также там есть много примеров.

Аналоговые клавиатуры

Аналоговые клавиатуры – достаточно глубокая тема, достойная отдельного урока (у меня его пока что нет). Максимально подробный урок-исследование можно посмотреть на сайте Codius.

Видео

Полезные страницы

  • Набор GyverKIT – большой стартовый набор Arduino моей разработки, продаётся в России
  • Каталог ссылок на дешёвые Ардуины, датчики, модули и прочие железки с AliExpress у проверенных продавцов
  • Подборка библиотек для Arduino, самых интересных и полезных, официальных и не очень
  • Полная документация по языку Ардуино, все встроенные функции и макросы, все доступные типы данных
  • Сборник полезных алгоритмов для написания скетчей: структура кода, таймеры, фильтры, парсинг данных
  • Видео уроки по программированию Arduino с канала “Заметки Ардуинщика” – одни из самых подробных в рунете
  • Поддержать автора за работу над уроками
  • Обратная связь – сообщить об ошибке в уроке или предложить дополнение по тексту ([email protected])

Много кнопок на одном пине. Урок 20. Ардуино

Много кнопок на одном пине

Привет! Как контролировать много кнопок на одном пине Ардуино. И как много кнопок можно подключить. Как разделить нажатия разных кнопок. Попробуем собрать схему и написать программу для такого разделения.

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

Резисторы

Дребезг кнопки

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

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

Принципиальная схема исключения дребезга кнопки График нажатия кнопки через конденсатор

Подключим несколько кнопок

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

Принципиальная схема подключения многих кнопок и график нажатий

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

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

График нажатий на кнопки

Прерывание

Теперь займемся программой. Мы хотим использовать прерывание при нажатии на кнопку, чтобы в основном цикле программы у нас была возможность опрашивать датчики или управлять светодиодами. А кнопками мы будем выполнять дополнительные функции программы.

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

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

void setup() < Serial.begin(9600); pinMode(buttonPin, INPUT); attachInterrupt(0, swap, RISING); >void swap()< buttonState = analogRead(buttonPin); if (buttonState >= 1000) if (buttonState >= 513 && buttonState < 1000)if (buttonState >= 300 && buttonState < 500)if (buttonState >= 250 && buttonState < 300)if (buttonState >= 200 && buttonState < 250)if (buttonState >= 150 && buttonState < 200)Serial.println(str); >

Показания для каждой кнопки вы можете посмотреть в мониторе порта.

Полный текст программы

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

Принципиальная схема с прерыванием

А программа таким

const int buttonPin = 0; int buttonState = 0; String str; void setup() < Serial.begin(9600); pinMode(buttonPin, INPUT); attachInterrupt(0, swap, RISING); >void swap()< buttonState = analogRead(buttonPin); if (buttonState >= 1000) if (buttonState >= 513 && buttonState < 1000)if (buttonState >= 300 && buttonState < 500)if (buttonState >= 250 && buttonState < 300)if (buttonState >= 200 && buttonState < 250)if (buttonState >= 150 && buttonState < 200)Serial.println(str); > void loop() < //buttonState = analogRead(buttonPin); //Serial.println(buttonState); //delay(50); >

Заключение

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

Подключение кнопки к Arduino. Цифровой пин в режиме входа.

Доброго времени суток! В самом разгаре курс по программированию Arduino и, как и было запланировано в предыдущей части, сегодня будем разбираться с работой порта Ардуино в режиме входа. Для тестирования используем простенькую кнопку, в скетче же будем определять, нажата она или нет. Принцип работы, схема подключения, примеры программ – ко всему этому незамедлительно и переходим ��

  • Теоретическая часть
    • Порты ввода-вывода в режиме входа
    • Подтягивающий резистор
    • Токоограничивающий резистор
    • Схема подключения кнопки к Arduino Uno
    • Функция digitalRead()
    • Базовый пример
    • Расширенный пример

    Arduino. Порты ввода-вывода в режиме входа.

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

    Как мы уже выяснили ранее, цифровой пин потому и именуется цифровым, что может оперировать двумя возможными значениями — логическим нулем и единицей. А значит именно эти два варианта мы можем прочитать с входного порта. Остается прочертить взаимосвязь между этими цифровыми значениями и значениями напряжения на входе в Вольтах. А взаимосвязь здесь проста, я нарисовал табличку для наглядной и приятной глазу демонстрации:

    Состояние входа Напряжение
    Логический 0 от -0.5 В до 1.5 В (0.3 * Vcc)
    Логическая 1 от 3.0 В (0.6 * Vcc) до 5.5 В (Vcc + 0.5 В)

    То есть имеем две области:

    • Первая — этот интервал соответствует логическому 0
    • Вторая — при этих значениях напряжений со входа гарантированно прочитаем единицу

    Сразу бросается в глаза, что данные диапазоны не покрывают все возможные значения напряжений. Есть ряд промежуточных значений, в которых результат будет неоднозначен. Не буду углубляться, чтобы не перегружать эту статью, запомним тот факт, что есть некая «серая» зона, в которой вход может находиться и в одном, и в другом состоянии при одном и том же значении напряжения.

    При этом приведенные значения могут варьироваться с изменением температуры, графики можно найти в даташите на контроллер.

    В данном уроке я использую плату Arduino Uno, микроконтроллер которой работает с уровнями в 5 В. Именно поэтому данная величина повсеместно и фигурирует. Соответственно, в случае платы с уровнями в 3.3 В, ситуация будет уже другая, верхнее значение будет составлять именно 3.3 В, а не 5, также изменятся и диапазоны. Эти данные можно найти в документации, либо пишите в комментарии, либо на форум, я всегда по возможности стараюсь оперативно ответить.

    Вот так вот все просто, займемся принципиальной электрической схемой. Отправной точкой послужит непосредственно кнопка, которую и будем подключать. Рассмотрим несколько распространенных вариантов:

    Внешний вид стандартных кнопок

    В первом варианте исполнения все максимально просто — при нажатии происходит замыкание двух контактов, пока кнопка в покое — контакты разомкнуты. Второй вариант ничуть не сложнее, суть точно такая же, просто контакты соединены между собой внутри. То есть по умолчанию 1 и 4, а также 2 и 3 соединены между собой, при нажатии кнопки все ровно также, контакт 1 замыкается с контактом 2 (аналогично 3 и 4), по итогу при нажатой кнопке замкнуты будут все. Смотрим на наглядной схеме:

    Контакты кнопок.

    Все это по существу — одно и то же. Перейдем к конкретике, то есть к непосредственному подключению кнопки к Arduino Uno, вариантов может быть несколько:

    Варианты подключения

    В первом случае при нажатии кнопки происходит замыкание цифрового пина Ардуино на землю (GND). А это значит, что на входе микроконтроллера будет 0 В — низкий уровень. Напротив, во втором случае ситуация диаметрально противоположная: кнопка замыкает на 5 В, а значит на цифровом пине будет высокий уровень. Казалось бы, на этом разговор об электрической схеме можно заканчивать, но в реальности существует несколько дополнительных моментов, о которых зачастую бывает не сказано, что я категорически не одобряю.

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

    Решение здесь классическое и простое, а именно использовать подтяжку.

    Подтягивающий резистор.

    Конечно же, досконально разберем, что это означает. Итак подтяжка осуществляется при помощи дополнительного резистора (подтягивающий резистор), который подключается одним концом к линии, а другой либо к 5 В, либо к GND. Первый вариант — подтяжка вверх, второй — подтяжка вниз, смотрим на наглядном примере:

    Подключение кнопки к Ардуино

    Возьмем первую из приведенных схем. Пусть кнопка не нажата, тогда получим следующую картину: из-за высокого внутреннего сопротивления входа микроконтроллера ток ( I_R ) между точками 1-2 очень мал. Из чего следует, что и напряжение на резисторе U_R также мало, поскольку:

    U_R = I_R \cdot R_1

    А из этого, в свою очередь, вытекает то, что добавленный подтягивающий резистор ( R_1 ) гарантирует нам, что на входе будет высокий уровень (5 В). Это и называется подтяжкой вверх. Мысленно нажимаем кнопку и, конечно же, обстановка меняется, на входе получаем стабильные 0 В:

    Подтягивающий резистор

    В этом и заключается весь смысл идеи: при наличии подтягивающего резистора на цифровом входе возможны два четких варианта:

    • высокий уровень — кнопка не нажата
    • низкий уровень — кнопка нажата

    Аналогичные процессы протекают и при подтяжке вниз, только в данном случае резистор подключается к GND, а нажатая кнопка замыкает на 5V. И в данном случае:

    Подтягивающий резистор, подтяжка вниз

    • высокий уровень — кнопка нажата
    • низкий уровень — кнопка не нажата

    Таким образом, подтягивающий резистор в данной схеме просто необходим. Номинал (значение сопротивления) не обязательно должен иметь какую-то конкретную величину. Вдаваться в нюансы, когда ставить сопротивление больше, а когда меньше, мы в этой статье не будем, возьмем «традиционное» для такого случая значение в 10 КОм:

    R_1 = 10 \medspace КОм

    Кроме того, Arduino Uno, а точнее микроконтроллер AVR, на базе которого и построена плата, имеет встроенные подтягивающие резисторы, которые можно легко и непринужденно задействовать (об этом в практической части), что даст возможность сэкономить и место на плате, и затраты на покупку резисторов. Но я лично почти всегда предпочитаю использовать внешние.

    Токоограничивающий резистор.

    При подключении кнопки есть и еще один нюанс, хотя, казалось бы, операция максимально примитивна. Рассмотрим потенциальную ситуацию…

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

    Короткое замыкание

    Как видите, в точке 2 потенциал равен 5 В, а в точке 1: 0 В. При этом сопротивление проводов между этими точками мало, а это автоматически означает, что по цепи потечет ток, значение которого будет велико (из-за того, что R_ мало, а оно в знаменателе дроби, закон Ома):

    I = \frac>

    Результат максимально прост и непригляден — порт микроконтроллера будет неотвратимо уничтожен. Поэтому для исключения этого печального явления добавляется еще один резистор ( R_2 ):

    Arduino кнопка, схема подключения

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

    R_2 = \frac = 250 \medspace Ом

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

    И на этом беседу об электрических аспектах подключения кнопки к Ардуино можно считать успешно завершенной ) Двигаемся дальше.

    Схема подключения кнопки к Arduino Uno.

    Подводим итог, схема приобрела такой вид:

    Подключение кнопки к Ардуино

    А при использовании макетной платы коммутация может производиться так:

    Схема подключения кнопки к Ардуино на макетной плате.

    Функция digitalRead().

    Для настройки порта на работу в режиме входа используется все та же функция, что мы использовали ранее: pinMode() . Единственное отличие, что второй аргумент будет отличаться:

    pinMode(3, INPUT);

    Напомню, что для порта в режиме выхода было так:

    pinMode(3, OUTPUT);

    И здесь же можно активировать встроенный в микроконтроллер подтягивающий резистор, тогда конфигурация превратится в:

    pinMode(3, INPUT_PULLUP);

    Что примечательно, имеется возможность задействовать только подтяжку вверх, только так и никак иначе. Первый же аргумент везде по прежнему — номер пина платы Ардуино (в данном случае D3). С этим понятно, осталось понять, как получить значение на входе в скетче. И тут понадобится функция:

    digitalRead(pin)

    Один аргумент функции — номер пина, значение на входе которого нас интересует. Возвращаемое же значение может иметь два разных значения: LOW означает, что на входе низкий уровень, HIGH — высокий. Все очень логично и понятно �� Переходим к парочке примеров для закрепления разобранного.

    Базовый пример скетча.

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

    Подключение кнопки и светодиода к Arduino

    // Светодиод подключен к D2 int ledPin = 2; // Кнопка - к D3 int buttonPin = 3; void setup() < // D2 работает в качестве выхода pinMode(ledPin, OUTPUT); // D3 - в качестве входа pinMode(buttonPin, INPUT); >void loop() < // Текущее состояние кнопки int currentButtonState = digitalRead(buttonPin); if (currentButtonState == LOW) < // Кнопка нажата, зажигаем светодиод digitalWrite(ledPin, HIGH); >else < // Кнопка не нажата, гасим светодиод digitalWrite(ledPin, LOW); >>

    Здесь все максимально подробно и развернуто, на деле же можно значительно уменьшить размер скетча следующим образом:

    // Светодиод подключен к D2 int ledPin = 2; // Кнопка - к D3 int buttonPin = 3; void setup() < // D2 работает в качестве выхода pinMode(ledPin, OUTPUT); // D3 - в качестве входа pinMode(buttonPin, INPUT); >void loop() < // Текущее состояние кнопки int currentButtonState = digitalRead(buttonPin); digitalWrite(ledPin, !currentButtonState); >

    Если currentButtonState равно HIGH , то соответственно !currentButtonState = LOW , таким образом можно считанное из digitalRead() значение инвертировать и сразу без лишних манипуляций передать в digitalWrite() . Компилируем и запускаем — все работает по плану: кнопка не нажата — светодиод не горит, кнопка нажата — горит.

    Расширенный пример. Подключение кнопки и светодиода к Arduino.

    Давайте разберем еще один пример, чуть усложненный, но тоже простой. Пусть при нажатой кнопке светодиод мигает с периодом, равным 1 секунде, а при ненажатой — 250 мс. Для этого добавим переменную currentPeriod , которая будет соответствовать нужному значению полупериода:

    // Светодиод подключен к D2 int ledPin = 2; // Кнопка - к D3 int buttonPin = 3; // Полупериод, если кнопка нажата int halfPeriodPressed = 500; // Полупериод, если кнопка не нажата int halfPeriodNotPressed = 125; // Актуальный период int currentPeriod = halfPeriodNotPressed; void setup() < // D2 работает в качестве выхода pinMode(ledPin, OUTPUT); // D3 - в качестве входа pinMode(buttonPin, INPUT); >void loop() < // Текущее состояние кнопки int currentButtonState = digitalRead(buttonPin); if (currentButtonState == LOW) < // Кнопка нажата currentPeriod = halfPeriodPressed; >else < // Кнопка не нажата currentPeriod = halfPeriodNotPressed; >// Зажигаем светодиод digitalWrite(ledPin, HIGH); delay(currentPeriod); // Гасим светодиод digitalWrite(ledPin, LOW); delay(currentPeriod); >

    Пример, конечно, придуман исключительно в целях задействовать все пройденное в предыдущих уроках в одном скетче. На практике применимо не особо, все на примитивных задержках с delay() , тем не менее со своей демонстрационной задачей пример справляется отлично.

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

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *