Функция arduino pinmode

Тактовые кнопки[править | править код]

Тактовая кнопка — простой механизм, замыкающий цепь пока есть давление на толкатель.

У классической 4-ех контактной тактовой кнопки замыкание происходит по диагонали.

Всего существуют 3 способа подключения тактовой кнопки к Arduino

Самая элементарная схема править | править код

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

в данной сборке необходимо объявить цифровой пин в специальный режим INPUT_PULLUP.

pinMode(цифровой пин, INPUT_PULLUP);

снимать состояние кнопки мы будем с помощью функции digitalRead().

boolean buttonstate = digitalRead(№пина);
  • Есть нажатие: buttonstate = 0;
  • Нет нажатия: buttonstate = 1;

Схема с подтягивающим резисторомправить | править код

Программирование аналогично схеме сверху ,в данном случае цифровой пин Vout должен иметь тип INPUT

pinMode(Vout, INPUT);
  • Есть нажатие: buttonstate = 0;
  • Нет нажатия: buttonstate = 1;

Схема с стягивающим резисторомправить | править код

Аналогично с схемой с подтягивающим резистором ,только происходит инверсия

  • Есть нажатие: buttonstate = 1;
  • Нет нажатия: buttonstate = 0;

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

Ошибки дребезга кнопки

Как отразится дребезг на нашем проекте? Да самым прямым образом – мы будем получать на входе совершенно случайный набор значений. Ведь если мы считываем значение с кнопки непрерывно, в каждом новом рабочем цикле функции loop, то будем замечать все “всплески” и “падения” сигнала. Потому что пауза между двумя вызовами loop составляет микросекунды и мы измерим все мелкие изменения.

Если мы хотим отследить ситуацию, когда кнопка была отпущена после нажатия, то получим множество ложных сигналов – она будет “нажата-отпущена” десятки раз, хотя мы выполнили лишь однократное нажатие.

Вот пример скетча, в котором непременно обнаружится ошибка дребезга

Мы сможем увидеть в мониторе порта в первые мгновения после нажатия целый набор нулей и единиц в случайной последовательности (не важно, что означает 1 – нажатие или отпускание кнопки, важен сам факт появления хаоса)


void loop() {

  if (digitalRead(PIN_BUTTON)) {

    Serial.println("1");

  } else {

    Serial.println("0");

  }
}

Естественно, такое поведение ни к чему хорошему не приведет и нам нужно придумать способ борьбы с дребезгом. В нашем арсенале есть два способа: программный и аппаратный. Первый довольно простой, но не всегда его можно использовать в реальных проектах. Второй – более надежный, но требует существенных изменений в схеме. Давайте рассмотрим оба способа подробнее.

Структуры

// ====== СТРУКТУРЫ ======
// полный урок тут: https://alexgyver.ru/lessons/variables-types/

struct myStruct { // создаём ярлык myStruct
  boolean a;
  byte b;
  int c;
  long d;
  byte e;
} kek;            // и сразу создаём структуру kek

// создаём массив структур cheburek типа myStruct
myStruct cheburek;

void setup() {
  // присвоим членам структуры значения вручную
  kek.a = true;
  kek.b = 10;
  kek.c = 1200;
  kek.d = 789456;
  kek.e = 10;    // e у нас массив!
  kek.e = 20;
  kek.e = 30;
  
  // присвоим структуру kek структуре cheburek номер 0
  cheburek = kek;
  
  // присвоим элемент массива из структуры kek
  // структуре cheburek номер 1
  cheburek.e = kek.e;
  
  // забьём данными структуру cheburek номер 2
  cheburek = (myStruct) {
    false, 30, 3200, 321654, {1, 2, 3, 4, 5}
  };
}

Общие рекомендации по написанию обработчиков прерываний

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

  • Во-первых, делайте обработчики предельно короткими. Ведь они прерывают выполнение основной программы, а также блокируют обработку других прерываний. По возможности обработчик должен фиксировать только факт возникновения события, изменяя значение переменной. А сама реакция на событие должна выполняться в основной программе при анализе этой переменной.
  • Как уже было сказано, при входе в обработчик устанавливается глобальный запрет на обработку других прерываний. А это в свою очередь влияет на работу функций, использующих прерывания. Будьте с ними осторожнее. Если не уверены в безопасности их вызова, то лучше откажитесь от их использования в обработчике.
  • Возьмите за правило объявлять разделяемые между основной программой и обработчиком переменные как volatile. И не забывайте, что этого квалификатора недостаточно в случае многобайтных переменных — используйте при работе с ними атомарно исполняемые блоки или interrupts/noInterrupts

следующей части

Defining Digital Pins modes: INPUT, INPUT_PULLUP, and OUTPUT

Digital pins can be used as , , or . Changing a pin with changes the electrical behavior of the pin.

Pins Configured as INPUT

Arduino (ATmega) pins configured as with are said to be in a high-impedance state. Pins configured as make extremely small demands on the circuit that they are sampling, equivalent to a series resistor of 100 Megohms in front of the pin. This makes them useful for reading a sensor.

If you have your pin configured as an , and are reading a switch, when the switch is in the open state the input pin will be «floating», resulting in unpredictable results. In order to assure a proper reading when the switch is open, a pull-up or pull-down resistor must be used. The purpose of this resistor is to pull the pin to a known state when the switch is open. A 10 K ohm resistor is usually chosen, as it is a low enough value to reliably prevent a floating input, and at the same time a high enough value to not draw too much current when the switch is closed. See the Digital Read Serial tutorial for more information.

If a pull-down resistor is used, the input pin will be when the switch is open and when the switch is closed.

If a pull-up resistor is used, the input pin will be when the switch is open and when the switch is closed.

Pins Configured as INPUT_PULLUP

The ATmega microcontroller on the Arduino has internal pull-up resistors (resistors that connect to power internally) that you can access. If you prefer to use these instead of external pull-up resistors, you can use the argument in .

See the Input Pullup Serial tutorial for an example of this in use.

Pins configured as inputs with either or can be damaged or destroyed if they are connected to voltages below ground (negative voltages) or above the positive power rail (5V or 3V).

Pins Configured as OUTPUT

Pins configured as with are said to be in a low-impedance state. This means that they can provide a substantial amount of current to other circuits. ATmega pins can source (provide current) or sink (absorb current) up to 40 mA (milliamps) of current to other devices/circuits. This makes them useful for powering LEDs because LEDs typically use less than 40 mA. Loads greater than 40 mA (e.g. motors) will require a transistor or other interface circuitry.

Pins configured as outputs can be damaged or destroyed if they are connected to either the ground or positive power rails.

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

Из урока про цифровые пины вы помните, что микроконтроллер может считывать напряжение со своей ноги. Соответственно кнопка может подать на пин тот уровень, к которому подключена её вторая нога. В том же уроке мы обсуждали, что не подключенный никуда цифровой пин принимает наводки из воздуха, и считанное с него значение будет практически случайным. То есть подключив к пину 5V (сигнал высокого уровня) через кнопку, мы ничего не добьёмся: при нажатой кнопке на пине будет считываться четкий сигнал высокого уровня, а при отпущенной – случайное значение. Для решения этой проблемы существует такое понятие, как подтяжка (pull) пина. Подтяжка выполняется к земле (pull down) или питанию (pull up) микроконтроллера при помощи резистора. Подтяжка выполняется противоположно принимаемому сигналу, т.е. если нужно ловить высокий сигнал, подтяжка выполняется к земле, если ловить нужно сигнал земли – подтяжка выполняется к питанию. Вот два варианта подключения кнопки, с подтяжкой к VCC и GND соответственно:

Как выбирается сопротивление резистора? Тут всё очень просто: при нажатии на кнопку через резистор потечёт ток, так как в любом случае замыкается цепь питание-земля. Чем выше ток, больше потери энергии и нагрев резистора, а это никому не нужно, поэтому сопротивление резистора подтяжки обычно выбирается в диапазоне 5-50 кОм. Если ставить больше – подтяжка может не обеспечить стабильный уровень сигнала на пине, а если ставить меньше – будут больше потери энергии в нагрев резистора: при сопротивлении в 1 ком через него потечёт ток величиной 5 В/1000 Ом = 5 мА, для сравнения плата Ардуино с МК в активном режиме потребляет 20-22 мА. Чаще всего для подтяжки используется резистор на 10 кОм.

Как вы помните из урока о цифровых пинах, у МК AVR есть встроенные резисторы для всех GPIO, эти резисторы подключены к питанию (к VCC), то есть буквально дублируют первую схему из этого урока и позволяют не использовать внешний резистор. У микроконтроллеров другой архитектуры бывает подтяжка к GND, или вообще может не быть внутренней подтяжки. При использовании подтяжки к питанию мы получим инвертированный сигнал – функция вернёт 1 при отпущенной кнопке, и 0 при нажатой (при использовании нормально-разомкнутой кнопки). Давайте подключим кнопку на пин D3 (и GND):

void setup() {
  Serial.begin(9600);
  pinMode(3, INPUT_PULLUP);
}

void loop() {
  // выведет 0, если кнопка нажата
  // и 1, если нет
  Serial.println(digitalRead(3));
  delay(10);
}

GPIO

Начнем с пинов, которых больше всего, это GPIO, с англ. General Purpose Input-Output, входы-выходы общего назначения, на плате они подписаны как D0–D13 и A0–A5. По картинке распиновки они называются PD*, PB* и PC*, (вместо звёздочки – цифра) отмечены тёмно-бежевым цветом. Почему “официально” они называются PD/PB/PC? Потому что пины объединены в пОрты по несколько штук (не более 8), на примере Нано есть три порта: D, B и C, соответственно пины так и подписаны: PD3 – Port D 3 – третий выход порта D. Это цифровые пины, способные выдавать логический сигнал (0 или VCC) и считывать такой же логический сигнал. VCC это напряжение питания микроконтроллера, при обычном использовании обычной платы Ардуино это 5 Вольт, соответственно это 5 вольтовая логика: 0V – сигнал низкого уровня (LOW), 5V – высокого уровня (HIGH). Напряжение питания микроконтроллера играет очень большую роль, об этом мы ещё поговорим. GPIO имеют несколько режимов работы: вход (INPUT), выход (OUTPUT) и вход с подтяжкой к питанию встроенным в МК резистором на 20 кОм (INPUT_PULLUP). Подробнее о режимах поговорим в отдельном уроке.

Все GPIO пины в режиме входа могут принять сигнал с напряжением от 0 до 5 вольт (на самом деле до 5.5 вольт, согласно даташиту на микроконтроллер). Отрицательное напряжение или напряжение, превышающее 5.5 Вольт приведёт к выходу пина или даже самого МК из строя. Напряжение 0-2.5 вольта считается низким уровнем (LOW), 2.5-5.5 – высоким уровнем (HIGH). Если GPIO никуда не подключен, т.е. “висит в воздухе”, он принимает случайное напряжение, возникающее из за наводок от сети (провода 220в в стенах) и электромагнитных волн на разных частотах, которыми пронизан современный мир.

GPIO в режиме выхода (OUTPUT) являются транзисторными выходами микроконтроллера и могут выдать напряжение 0 или VCC (напряжение питания МК). Стоит отметить, что микроконтроллер – логическое, а не силовое устройство, его выходы рассчитаны на подачу сигналов другим железкам, а не на прямое их питание. Максимальный ток, который можно снять с GPIO выхода ардуино – 40 мА. Если попытаться снять больше – пин выйдет из строя (выгорит выходной транзистор и всё). Что такое 40 мА? Обычный 5мм одноцветный светодиод потребляет 20 мА, и это практически единственное, что можно питать напрямую от Ардуино. Также не стоит забывать о максимальном токе со всех пинов, он ограничен 200 мА, то есть не более 10 светодиодов можно запитать от платы на полную яркость…

Установка

Автоматическая

  • Открой the Arduino IDE
  • Зайди в Файл > Настройки
  • Вставь этот адрес в Дополнительные ссылки для менеджера плат:

  • Открой Инструменты > Плата > Менеджер плат…
  • Подожди загрузку списка
  • Листай в самый низ, пока не увидишь GyverCore
  • Жми Установка
  • Закрой окно
  • Выбери плату в Инструменты > Плата > GyverCore > ATmega328 based
  • Готово!
  • Примечание: новая версия компилятора по умолчанию идёт для Windows 64, если нужно для win32 или Linux — нужно установить вручную.
    Идём в C:\Users\Username\AppData\Local\Arduino15\packages\GyverCore\hardware\avr\2.0\tools\avr-gcc, удаляем оттуда всё и кладём туда файлы из архива нужной версии (папка avr-gcc в корне данного репозитория)

Ручная

  • Файлы из папки GyverCore в этом репозитории положить по пути C:\Users\Username\AppData\Local\Arduino15\packages\GyverCore\hardware\avr\2.0\
  • Версия компилятора по умолчанию для Windows 64, если нужна другая — читай выше как установить

Приём данных

На принимающей стороне опрашиваем функцию , она однократно вернёт при получении корректного пакета данных (внутри автоматически проводится проверка ошибок передачи, переполнения, совпадения адреса и контроль целостности данных, если он включен).

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

struct myStruct {
  byte val_b;
  int val_i;
  float val_f;
};
myStruct rx_data;

void setup() {
}

void loop() {
  rx.tick();
  if (rx.gotData()) {
    rx.readData(rx_data);
  }
}

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

Строки

// ====== СТРОКИ STRING ======
// полный урок тут: https://alexgyver.ru/lessons/strings/

String string0 = "Hello String";              // заполняем словами в кавычках
String string1 = String("lol ") + String("kek");  // сумма двух строк
String string2 = String('a');                 // строка из символа в одинарных кавычках
String string3 = String("This is string");    // конвертируем строку в String
String string4 = String(string3 + " more");   // складываем строку string3 с текстом в кавычках
String string5 = String(13);                  // конвертируем из числа в String
String string6 = String(20, DEC);             // конвертируем из числа с указанием базиса (десятичный)
String string7 = String(45, HEX);             // конвертируем из числа с указанием базиса (16-ричный)
String string8 = String(255, BIN);            // конвертируем из числа с указанием базиса (двоичный)
String string9 = String(5.698, 3);            // из float с указанием количества знаков после запятой (тут 3)

// длина строки
String textString = "Hello";
sizeof(textString);   // вернёт 6
textString.length();  // вернёт 5
// полный набор инструментов String тут https://alexgyver.ru/lessons/strings/

// ====== МАССИВЫ СИМВОЛОВ ======
// объявить массив текста длиной 6 символов
// и задать текст
char helloArray[] = "Hello!";

// объявить массив текста длиной 100 символов
// и задать в его начало текст
char textArray = "World";

// длина строки
char textArray = "World";
sizeof(textArray);  // вернёт 100
strlen(textArray);  // вернёт 5

Важные страницы

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

ООП и процедурный подход

Порог вхождения

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

Объем кода

Оборачивание всего подряд в классы приводит к генерации огромного объема кода как текста: его просто приходится писать гораздо больше, соответственно читать тоже. Делать это в родной IDE к слову очень неприятно по сравнению со взрослыми средами разработки, в которых есть автоподстановка слов и членов классов, а также “дерево” проекта и его файлов.

Вес и скорость выполнения кода

Компиляторы все время обновляются и улучшаются, даже встроенный в Arduino IDE avr-gcc: новые версии всё лучше оптимизируют код, делая его легче и быстрее. Тем не менее, большое количество вложенных друг в друга классов и длинные цепочки передачи данных будут неизбежно работать чуть медленнее и занимать больше места, чем при более компактном процедурном подходе.

Область определения и названия

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

Крупные проекты

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

Мелкие проекты и прототипы

Написание небольшой программы в процедурном стиле гораздо легче и быстрее классического оопшного программирования на C++, именно поэтому Ардуино IDE это просто блокнот, который сохраняет скетч в своём расширении .ino, вместо взрослых .h и .cpp: нам не нужно думать о файловой структуре проекта, мы просто пишем код и всё. Для быстрого прототипирования и отладки небольших алгоритмов это работает отлично, но с крупным проектом могут начаться проблемы и неудобства.

Библиотеки и совместимость

Если вы откроете любую библиотеку для Ардуино, то с 99.9% вероятностью увидите там класс. Сила ООП в том, что мы берём библиотеку (или просто какой то класс), добавляем в свой код и не получаем никаких конфликтов имён и вообще пересечения кода (в 99% случаев): класс работает сам по себе, это отдельная программа. Если вы возьмёте например какой то кусок “голого” кода и вставите в свой такой же голый код – будет довольно большой шанс пересечений и конфликтов, а самое страшное – когда компилятор не видит ошибок, а программа работает неадекватно.

Конструктивные особенности

Из чего состоят лампы ДРЛ 250? Характеристики их предусматривают наличие таковых составных основных частей:

  • Цоколя, покрытого никелем.
  • Резистора, обеспечивающего ограничения напряжения.
  • Фольги из молибдена.
  • Рамки.
  • Стеклянной колбы (на нее, собственно, и наносят люминоморфное покрытие).
  • Свинцовой проволоки.
  • Основного электрода, покрытого вольфрамом.
  • Азота, который выступает в качестве заполнителя внешней колбы.
  • Сжатого спая кварцевого источника освещения. Кварцевая горелка является основным рабочим элементом лампы.

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

Параметры UART

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

Скорость передачи

Скорость в бодах — это количество битов в секунду (бит/с), которое может передавать/принимать устройство UART. Для правильной передачи данных необходимо настроить оба прибора UART с одинаковой скоростью передачи данных в бодах. Распространенными значениями скорости передачи данных являются 9600, 1200, 2400, 4800, 19200, 38400, 57600 и 115200 бит в секунду.

Бит четности

Бит четности — это бит, добавляемый к передаваемым данным и сообщающий приемнику, является ли число единиц в передаваемых данных нечетным или четным. Возможная настройка для бита четности — «нечетный» (ODD) или «четный» (EVEN).

  • ODD — бит четности равен ‘1’, если в данных присутствует нечетное число 1. В противном случае бит четности устанавливается равным нулю.
  • EVEN — бит четности равен ‘1’, если в данных присутствует четное число единиц. В противном случае бит четности устанавливается равным нулю.

Количество стоп-битов

Приборы UART могут использовать ни одного, один или два стоповых бита для маркировки конца переданного набора битов (так называемых пакетов).

Управление потоком

Flow Control (управление потоком) — это метод, позволяющий избежать риска потери данных при передаче данных через UART. В устройстве UART в качестве управления потоком для запуска/остановки передачи данных используются специальные символы.

Условия и выбор

// ========= УСЛОВИЯ =========
// полный урок тут: https://alexgyver.ru/lessons/conditions/

// === Сравнение и логика ===
== , != , >= , <= ;   // равно, не равно, больше или равно, меньше или равно
! , && , || ;         // НЕ, И, ИЛИ  

// === if-else ===
// при выполнении одного действия {} необязательны
if (a > b) c = 10;  // если a больше b, то c = 10
else c = 20;        // если нет, то с = 20

// вместо сравнения можно использовать лог. переменную
boolean myFlag, myFlag2;
if (myFlag) c = 10;

// сложные условия
// если оба флага true - c = 10
if (myflag && myFlag2) c = 10;  

// при выполнении двух и более {} обязательны
if (myFlag) {
  с = 10;
  b = c;
} else {
  с = 20;
  b = a;
}

// else if
byte state;
if (state == 1) a = 10;       // если state 1
else if (state == 2) a = 20;  // если нет, но если state 2
else a = 30;                  // если и это не верно, то вот

// === Оператор ? ===
// "Короткий" вариант if-else
int с = (a > b) ? 10 : -20;  // если a > b, то с = 10. Если нет, то с = -20
Serial.println( (flag) ? ("флаг поднят") : ("флаг опущен") );

// === Оператор выбора ===
switch (val) {
case 1:
  // выполнить, если val == 1
  break;
case 2:
  // выполнить, если val == 2
  break;
default:
  // выполнить, если val ни 1 ни 2
  // default опционален
  break;
}

// Оператор break очень важен, позволяет выйти из switch
// Можно использовать так:
switch (val) {
case 1:
case 2:
case 3:
case 4:
  // выполнить, если val == 1, 2, 3 или 4
  break;
case 5:
  // выполнить, если val == 5
  break;
}

Варианты питания Ардуино Уно

Рабочее напряжение платы Ардуино Уно – 5 В. На плате установлен стабилизатор напряжения, поэтому на вход можно подавать питание с разных источников. Кроме этого, плату можно запитывать с USB – устройств. Источник питания выбирается автоматически.

  • Питание от внешнего адаптера, рекомендуемое напряжение от 7 до 12 В. Максимальное напряжение 20 В, но значение выше 12 В с высокой долей вероятности быстро выведет плату из строя. Напряжение менее 7 В может привести к нестабильной работе, т.к. на входном каскаде может запросто теряться 1-2 В. Для подключения питания может использоваться встроенный разъем DC 2.1 мм или напрямую вход VIN для подключения источника с помощью проводов.
  • Питание от USB-порта компьютера.
  • Подача 5 В напрямую на пин 5V. В этом случае обходится стороной входной стабилизатор  и даже малейшее превышение напряжения может привести к поломке устройства.

Пины питания

  • 5V – на этот пин ардуино подает 5 В, его можно использовать для питания внешних устройств.
  • 3.3V – на этот пин от внутреннего стабилизатора подается напряжение 3.3 В
  • GND – вывод земли.
  • VIN – пин для подачи внешнего напряжения.
  • IREF – пин для информирования внешних устройств о рабочем напряжении платы.

Заголовочный файл pitches.h

Теперь мы знаем как генерировать звуки с помощью функции tone(). Но как узнать какой вид тона будет генерироваться на каждой частоте? Для этой цели в Arduino есть специальная таблица нот, которая приравнивает каждую частоту к определенному типу музыкальной ноты. Эта таблица нот первоначально была написана Бреттом Хангманом (Brett Hagman), на чьих трудах и была основана работа функции tone(). Мы будем использовать эту таблицу нот чтобы проигрывать наши мелодии.

Приведенный участок кода записан в заголовочном файле pitches.h в форме zip файла. Вы должны скачать его и включить его в свой код программы как сделано в конце данной статьи. Либо этот код вы можете взять непосредственно из скачанного zip файла.

pinMode Arduino IDE описание

Arduino pinMode OUTPUT (пины настроены как выход)

OUTPUT (порт работает как выход) — пин становится управляемым источником питания с максимальным током 40 мА. В зависимости от команды digitalWrite() пин принимает значение единицы или нуля. Пример:

Функция digitalWrite() и analogWrite()

Цифровой пин Ардуино может генерировать цифровой сигнал с помощью команды digitalWrite(), т.е. выдавать напряжение 5 Вольт. Цифровой сигнал может иметь два значения — 0 или 1 (0 Вольт или 5 Вольт). Если в программе используется команда analogWrite() для ШИМ портов платы, то микроконтроллер может генерировать сигнал PWM Arduino на портах — создавать имитацию аналогового сигнала.

void setup() {
   pinMode(10, OUTPUT);
}

void loop() {
   digitalWrite(10, HIGH);
   delay(250);
   digitalWrite(10, LOW);
   delay(250);
}

К пинам ардуино нельзя подключать устройства, потребляющие ток более 40 мА, так как основное назначение микроконтроллера — это управления другими устройствами при помощи логических сигналов. Если к пину подключить устройство, потребляющее ток больше указанного значения, то пин может выгореть. Поэтому к выводам микроконтроллера Ардуино не следует подключать ничего мощнее светодиода.

Arduino pinMode INPUT (пины настроены как вход)

INPUT (порт работает как вход) — пин в этом режиме считывает данные с аналоговых и цифровых датчиков, состояния кнопок. Порт находится в высокоимпедансном состоянии, т.е. у пина высокое сопротивление. Пример:

Функция digitalRead() и analogRead()

Arduino может определить наличие напряжения на пине через функцию digitalRead(), которая возвращает 0 (LOW) или 1 (HIGH). Существует разница между цифровым датчиком (который обнаруживает включение/выключение) и аналоговым датчиком, значение которого постоянно изменяется. Используя функцию analogRead(), можно прочитать напряжение с аналогового датчика, функция возвращает число от 0 до 1023.

void setup() {
   pinMode(10, INPUT);
   Serial.begin(9600);
}

void loop() {
   int data = digitalRead(10);
   Serial.println(data);
   delay(250);
}

Нельзя подавать на вход микроконтроллера напряжение выше напряжения питания платы. Кроме того, для аналоговых выводов Ардуино можно использовать команды digitalRead() и digitalWrite(). В этом случае аналоговые порты будут считывать (digitalRead) или выдавать (digitalWrite) цифровой, а не аналоговый сигнал.

INPUT_PULLUP (порт работает как вход) но к пину подключается резистор в 20 кОм. В этом режиме при подключении кнопки к Ардуино можно не использовать внешние подтягивающие резисторы. Пример:

Причины дребезга кнопок

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

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

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

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

Оцените статью
Рейтинг автора
5
Материал подготовил
Илья Коршунов
Наш эксперт
Написано статей
134
Добавить комментарий