Уроки ардуино: создаем своими руками бесконтактный переключатель

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

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

Кнопка ардуино

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

Тактовые кнопки и кнопки-переключатели

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

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

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

Вариантов различных кнопок великое множество, это действительно один из самых распространенных видов электронных компонентов.

Кнопки ардуино для простых проектов

В наших проектах мы будем работать с очень простыми тактовыми кнопками с 4 ножками, которые идут практически в любом наборе ардуино.

Кнопка представляет собой переключатель с двумя парами контактов.

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

В зависимости от ситуации, вы можете создавать как схемы с нормально замкнутыми, так и с нормально разомкнутыми контактами – для этого нужно будет только соответствующим образом выполнить соединение в схеме.

Для удобства работы в комплекте с тактовой кнопкой обычно идет пластмассовый колпачок какого-то цвета, он достаточно очевидно надевается на кнопку и придает проекту менее хакерский вид.

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

Включение и выключение светодиода с помощью кнопки

Давайте начнем с самого простого способа подключения тактовой кнопки. Рассмотрим схему с Arduino в качестве источника питания,  светодиода, ограничительного резистора номиналом 220 Ом и кнопки, которая будет замыкать и размыкать цепь.

При подключении кнопки с двумя парами ножек важно правильно выбрать размыкающие контакты. Посмотрите на изображение внимательно: пары ножек расположены по бокам кнопки.

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

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

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

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

Подключение кнопки с подтягивающим резистором

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

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

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

Скетч для кнопки ардуино с подтягивающим резистором:

/* Пример использования тактовой кнопки в ардуино. Кнопка подключена к пину 2.
*/ const int PIN_BUTTON = 2; void setup() { Serial.begin(9600); pinMode(PIN_LED, OUTPUT);
} void loop() { // Получаем состояние кнопки и выводим в мониторе порта int buttonState = digitalRead(PIN_BUTTON); Serial.println(buttonState); delay(50);
}

Подключение кнопки в режиме INPUT_PULLUP

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

pinMode(PIN_BUTTON, INPUT_PULLUP);

Альтернативным вариантом будет выбрать режим пина как OUTPUT и установить на данный порт высокий уровень сигнала. Встроенный подтягивающий резистор подключиться автоматически.

pinMode(PIN_BUTTON, INPUT_PULLUP); digitalWrite(PIN_BUTTON, HIGH);

И все. Можно собрать вот такую сложную схему и работать с кнопкой в скетче.

Мигание светодиода после нажатия на кнопку

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

Поэтому давайте сделаем наш новый проект более «интеллектуальным»: при нажатии на кнопку заставим светодиод непрерывно мигать.

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

Полная схема проекта изображена на рисунке:

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

/* Скетч для схемы с использованием тактовой кнопки и светодиода Светодиод мигает, пока нажата кнопка. Кнопка подтянута к земле, нажатию соответствует HIGH на входе
*/ const int PIN_BUTTON = 2;
const int PIN_LED = 13; void setup() { Serial.begin(9600); pinMode(PIN_LED, OUTPUT);
} void loop() { // Получаем состояние кнопки int buttonState = digitalRead(PIN_BUTTON); Serial.println(buttonState); // Если кнопка не нажата, то ничего не делаем if (!buttonState) { delay(50); return; } // Этот блок кода будет выполняться, если кнопка нажата // Мигаем светодиодом digitalWrite(PIN_LED, HIGH); delay(1000); digitalWrite(PIN_LED, LOW); delay(1000);
}

Нажимаем и держим – светодиод мигает. Отпускаем – он гаснет. Именно то , что хотели. Хлопаем от радости в ладоши и приступаем к анализу того, что сделали.

Давайте посмотрим на скетч. В нем мы видим довольно простую логику.

1. Определяем, нажата ли кнопка.
2. Если кнопка не нажата, то просто выходим из метода loop, ничего не включая и не меняя.
3. Если кнопка нажата, то выполняем мигание, используя фрагмент стандартного скетча:
   1. Включаем светодиод, подавая напряжение на нужный порт
   2. Делаем нужную паузу при включенном светодиоде
   3. Выключаем светодиод
   4. Делаем нужную паузу при выключенном светодиоде

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

Дребезг кнопки ардуино

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

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

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

Для устранения дребезга используют программные и аппаратные решения. В двух словах лишь упомянем основные методы подавления дребезга:

• Добавляем в скетче паузу 10-50 миллисекунд между полкучением значений с пина ардуино.
• Если мы используем прерывания, то программный метд использоваться не может и мы формируем аппаратную защиту. Простейшая из них  — RC фильтр с конденсатором и сопротивлением.
• Для более точного подавления дребезга используется аппаратный фильтр с использованием триггера шмидта. Этот вариант позволит получить на входе в ардуино сигнал практически идеальной формы.

Более подробную информацию о способах борьбы с дребезгом вы можете найти в этой статье об устранении дребезга кнопок.

Переключение режимов с помощью кнопки

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

Факт нажатия мы определяем с помощью функции digitalRead(). В результате мы получим HIGH (1, TRUE) или LOW(0, FALSE), в зависимости от того, как подключили кнопку. Если мы подключаем кнопку с помощью внутреннего подтягивающего резистора, то нажатие кнопки приведет к появлению на входе уровня 0 (FALSE).

Для хранения информации о нажатии на кнопку можно использовать переменную типа boolean:

boolean keyPressed = digitalRead(PIN_BUTTON)==LOW;

Почему мы используем такую конструкцию, а не сделали так:

boolean keyPressed = digitalRead(PIN_BUTTON);

Все дело в том, что digitalRead() может вернуть HIGH, но оно не будет означать нажатие кнопки. В случае использования схемы с подтягивающим резистором HIGH будет означать, что кнопка, наоборот, не нажата.

В первом варианте (digitalRead(PIN_BUTTON)==LOW ) мы сразу сравнили вход с нужным нам значением и определили, что кнопка нажата, хотя и на входе сейчас низкий уровень сигнала. И сохранили в переменную статус кнопки.

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

Как переключать режимы работы после нажатия кнопки?

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

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

  Другими словами, нам нужно как-то зафиксировать в коде факт нажатия на кнопку и использовать информацию в дальнейшем, даже если кнопка уже не нажата.  Давайте посмотрим, как это можно сделать.

Логика работы программы очень проста:

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

Как определить нажатие нескольких кнопок?

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

Поэтому если количество кнопок у вас будет большим, то возможно возникновение дефицита свободных контактов.

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

Источник: https://ArduinoMaster.ru/datchiki-arduino/knopka-arduino/

Оптический выключатель со звуковым эффектом на Arduino

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

Основой выключателя является недавно купленный мной улучшенный клон контроллера Arduino, продающегося под названием Carduino Nano V.7

Работает выключатель так: Arduino с выхода D5 постоянно выдает ШИМ сигнал с частотой 976Гц и со скважностью 50%. К выходу D5 через токограничивающий резистор подключен светодиод, излучающий световой сигнал в инфракрасном диапазоне. Фототранзистор подключенный к входу Arduino D2 детектирует отраженный от руки ИК сигнал. Arduino получает ИК сигнал, проверяет его на достоверность и если сигнал из 20 идущих подряд импульсов соответствует частоте 976Гц, то тогда контроллер включает синий светодиод (L) на выходе D13 Arduino и начинает воспроизводить звуковой эффект через выход SPK контроллера. Все тоже самое происходит и при выключении светодиода (L).

Воспроизведение :

При воспроизведении звуковых эффектов используется звуковой фаил формата WAV без сжатия, с частотой 16000Гц и глубиной 8бит. Для улучшения качества воспроизведения звука, используется линейная интерполяция.

Для этого, выборка семплов происходит на частоте 96000Гц и между оригинальными семплами вставляются 4 промежуточных семпла рассчитанных методом линейной интерполяции.

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

Схема простая для ее сборки я использовал

1-Carduino Nano V.7 2-IR светодиод из старого пульта ДУ от телевизора, светодиод нужно запаять в термоусадку, во избежании бокового излучения 3-Фототранзистор LTR-3208E 4-Динамическая головка из детской игрушки 5-Резисторы 10к и 68омКак работает схема собранная мной на макетной плате, можно посмотреть на видео.

Код для Arduino Nano:

#include #include
#include
#include “fife.h”
#include “hi.h” ////////переменные проигрывателя////////////////////////////////////
#define speakerPin 11
volatile uint16_t sample=0;
volatile uint8_t lastSample, FirstSample;
volatile byte new_data,future_data,old_data;
volatile byte stat=0;
unsigned char *wave;
unsigned int length;
////////переменные выключателя////////////////////////////////////
uint8_t state = 0;
volatile uint16_t timerCount, lengthImpuls;
volatile uint16_t Counter=0;
////////////начальная предустановка///////////////////////////////
void setup() { pinMode(speakerPin, OUTPUT); //выход на динамик digitalWrite(speakerPin, LOW); //что бы не спалить динамик pinMode(2, INPUT); // Вход, к фототранзистору // digitalWrite(2, HIGH); //Подключить подтягивающий резистор pinMode(13, OUTPUT); //Лампочка pinMode(5, OUTPUT); //выход ШИМ на ИК светодиод TCCR0B = TCCR0B & 0b11111000 | 3; //частота ШИМ 976Гц analogWrite(5,128 ); //запустить ШИМ attachInterrupt(0, Ir_sens, RISING); //внешнее прерывание по фронту Timer1.initialize(10); //инициализация таймера Timer1.attachInterrupt(callback); //прерывание таймера
} ////////////обработка прерывания по таймеру///////////////////////////////
void callback() { timerCount++; }
////////////обработчик внешнего прерывания///////////////////////////////
void Ir_sens()
{ lengthImpuls = timerCount;
timerCount=0;
Counter++; }
///////////////////////Обработчик прерывания по совпадению с OCR2///////////////////
ISR(TIMER2_COMPA_vect) { switch (stat) { case 0:{ old_data = pgm_read_byte(&wave[sample]); OCR2A = old_data; stat=1; ++sample; if (sample == length) stat=4; future_data = pgm_read_byte(&wave[sample]); new_data = (old_data+future_data)/2; } break; case 1: {OCR2A=(old_data+new_data)/2; stat=2; } break; case 2: {OCR2A = new_data; stat=3; } break; case 3: {OCR2A=(new_data+future_data)/2; stat=0; } break; case 4: if(lastSample==0) stat=5; else {–lastSample; OCR2A=lastSample;} break; case 5: stopPlayback(); break; } }
////////////главный цикл программы///////////////////////////////
void loop() { if(lengthImpuls>105 || lengthImpuls99 && lengthImpuls20) { state=~state; digitalWrite(13, state); if(state>0) play_wave((unsigned char *)hi, hi_length); if(state==0) play_wave((unsigned char *)fife, fife_length); _delay_ms(200); while(Counter>10) { if(lengthImpuls>105 || lengthImpuls

Источник: https://habr.com/post/144180/

Бесконтактные концевые выключатели с принтеров и Arduino

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

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

Разные виды концевых выключателей показаны на фотографии ниже:

Некоторые из них установлены в пластиковые корпуса и, соответственно, отлично подойдут для проектов на Arduino.

Принцип действия бесконтактных концевых выключателей

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

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

Светодиод слева и фототранзистор справа:

Контакты концевых выключателей

Для того, чтобы использовать оптический концевой выключатель в вашем будущем проекте, надо определиться с его контактами. На плате выведено три контакта: Vcc (питание), Gnd (земля) и Sig (сигнал). Vcc подключается к аноду светодиода (+), Sig подключается к коллектору фототранзистора (+), а Gnd подключается к двум контактам: катоду светодиода и эмиттеру фототранзистора.

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

Светодиод расположен справа, а фототранзистор слева. Катод условно обозначен буквой К.

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

Для этого надо найти контакт, который идет одновременно и к светодиоду и к фототранзистору. Это будет контакт Gnd. Контакт на светодиоде, который не подключен к другому контакту (не Gnd) является сигналом. Обычно фотодиод затемнен или вообще черный.

Последний оставшийся контакт будет Vcc, который идет к аноду светодиода.

Бесконтактный концевой выключатель и Arduino

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

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

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

#define ENDSTOP_PIN 2 // какой пин мы используем?

void setup()

{

pinMode(ENDSTOP_PIN, INPUT);

Serial.begin(9600);

Serial.println(“Starting opto endstop exerciser.”);

}

void loop()

{

if (digitalRead(ENDSTOP_PIN))

{

if (0)

Serial.println(“open.”);

else

Serial.println(“blocked.”);

}

else

{

Serial.println(“open.”);

}

delay(500);

}

Оставляйте Ваши комментарии, вопросы и делитесь личным опытом ниже. В дискуссии часто рождаются новые идеи и проекты!

Источник: http://arduino-diy.com/arduino-beskontaktnyye-kontsevyye-vyklyuchateli

Урок 13. Подключение клавиатуры 4*4 и пьезоизлучателя к Arduino

Теперь научимся подключать устройство ввода к Ардуине. В этом примере разберемся, как подключить мембранную клавиатуру 4*4

Данный пример будет выполнять две задачи:

1. Первая задача: определяет, какая из клавиш была нажата на клавиатуре и передать информацию по сериал порту на компьютер, где в “мониторе последовательного порта “.
2. Вторая задача: при каждом нажатии клавиш издавать звуковой сигнал. У каждой клавиши звуковой сигнал будет разный.

В данном уроке нам понадобится:

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

• Библитетка keypad для клавиатуры 4×4

Сборка:

1) Клавиатуру удобнее всего подключить к Ардуине проводками Папа-Папа.

Контакты на клавиатуре отсчитываются слева на право.

Клавиатура 4*4Arduino (uno)

Контакт 1	pin 11
Контакт 2	pin 10
Контакт 3	pin 9
Контакт 4	pin 8
Контакт 5	pin 7
Контакт 6	pin 6
Контакт 7	pin 5
Контакт 8	pin 4

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

byte rowPins[ROWS] = {11,10, 9, 8}; byte colPins[COLS] = {7, 6, 5, 4};

2) Звуковой сигнал будет издаваться с помощью зуммера, его подключаем следующим образом:

ЗуммерArduino

GND	GND
IO	pin 3
VCC	5V или 3V

Контакт Pin3 так же может быть изменен на любой удобный вам цифровой выход. Настраивается здесь:

tone(3, (int)key*10, 300); // 3 – это и есть номер цифрового порта

Скетч:

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

#include // Подключаем библиотеку const byte ROWS = 4; // 4 строки
const byte COLS = 4; // 4 столбца
char keys[ROWS][COLS] = { {'1','2','3','A'}, {'4','5','6','B'}, {'7','8','9','C'}, {'*','0','#','D'}
}; byte rowPins[ROWS] = {11,10, 9, 8}; byte colPins[COLS] = {7, 6, 5, 4}; Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );
void setup(){ Serial.begin(9600);
}
void loop(){ char key = keypad.getKey(); if (key){ Serial.println(key); // Передаем название нажатой клавиши в сериал порт tone(3, (int)key*10, 300); // Издаем звуковой сигнал длиной 300 миллисекунд }
}

Скачать скетч можно по этой ссылке

Видео:

Источник: https://lesson.iarduino.ru/page/urok-13-podklyuchenie-klaviatury-4-4-i-pezoizluchatelya-k-arduino

Урок 5. Первая программа. Функции управления вводом/выводом. Кнопка, светодиод

В этом уроке напишем первую программу, научимся считывать значение цифровых входов и устанавливать состояние выходов. Реализуем управление такими простыми элементами, как кнопка и светодиод.

Предыдущий урок     Список уроков     Cледующий урок

Первая программа должна управлять светодиодом с помощью кнопки:

• при нажатой кнопке светодиод светится;
• при отжатой кнопке светодиод не светится.

Подключение кнопки и светодиода к плате Ардуино.

Для связи с внешними элементами в контроллере Arduino UNO существуют 14 цифровых выводов. Каждый вывод может быть определен программой как вход или выход.

У цифрового выхода есть только два состояния высокое и низкое. Высокое состояние соответствует напряжению на выходе порядка 5 В, низкое состояние – 0 В. Выход допускает подключение нагрузки с током до 40 мА.

Когда вывод определен как вход, считав его состояние, можно определить уровень напряжения на входе. При напряжении близком к 5 В (реально более 3 В) будет считано высокое состояние, соответствующее константе HIGH. При напряжении близком к 0 (менее 1,5 В) будет считано низкое состояние, или константа LOW.

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

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

Резистор рассчитывается по формуле I = Uвыхода – Uпадения на светодиоде / R.

Uвыхода = 5 В, Uпадения на светодиоде можно принять равным 1,5 В (более точно указывается в справочнике). Получается, то в нашей схеме ток через светодиод задан на уровне 10 мА.

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

Кнопку подключаем к любому другому выводу, например, 12. Аппаратная часть схемы подключения кнопки должна обеспечивать уровни напряжений 0 В при нажатой кнопке и 5 В при свободной. Это можно сделать простой схемой.

При отжатой кнопке резистор формирует на выводе 5 В, а при нажатой – вход замыкается на землю. Рекомендации по выбору резистора я напишу в заключительном уроке про кнопки. Сейчас предложу другой вариант.

Все выводы платы имеют внутри контроллера резисторы, подключенные к 5 В. Их можно программно включать или отключать от выводов. Сопротивление этих резисторов порядка 20-50 кОм.

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

В итоге схема подключения будет выглядеть так.

Кнопку можно припаять на проводах к разъему. Я установил ее на макетную плату без пайки. Купил специально для демонстрации уроков.

Функции управления вводом/выводом.

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

pinMode(pin, mode)

Устанавливает режим вывода (вход или выход).

Аргументы: pin и mode.

• pin – номер вывода;
• mode – режим вывода.

mode = INPUT	вывод определен как вход, подтягивающий резистор отключен
mode = INPUT_PULLUP	вывод определен как вход, подтягивающий резистор подключен
mode = OUTPUT	вывод определен как выход

Функция не возвращает ничего.

digitalWrite(pin, value)

Устанавливает состояние выхода (высокое или низкое).

Аргументы pin и value:

• pin – номер вывода;
• value – состояние выхода.

value = LOW	устанавливает выход в низкое состояние
value = HIGH	устанавливает выход в высокое состояние

Функция не возвращает ничего.

digitalRead(pin)

Считывает состояние входа.

Аргументы:  pin – номер вывода.

Возвращает состояние входа:

digitalRead(pin) = LOW	низкий уровень на входе
digitalRead(pin) = HIGH	высокий уровень на входе

Программа управления светодиодом.

С учетом предыдущего урока теперь у нас есть вся необходимая информация для написания программы. Программа в Ардуино состоит из двух функций setup() и loop.

В setup() мы устанавливаем режимы выводов, а в loop() считываем состояние кнопки в переменную buttonState и передаем его на светодиод. По пути инвертируем, т.к.

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

/* Программа scetch_5_1 урока 5
   Зажигает светодиод (вывод 13) при нажатии кнопки (вывод 12) */
 
boolean buttonState;   // создаем глобальную переменную buttonState
   
 void setup() {
  pinMode(13, OUTPUT);        // определяем вывод 13 (светодиод) как выход
  pinMode(12, INPUT_PULLUP);  // определяем вывод 12 (кнопка) как вход
}

//  бесконечный цикл
void loop() {
  buttonState = digitalRead(12);  // считываем состояние 12 входа (кнопки) и записываем в buttonState
  buttonState = ! buttonState;    // инверсия переменной buttonState
  digitalWrite(13, buttonState);  // записываем состояние из buttonState на выход 13 (светодиод)
}

Для хранения промежуточного значения состояния кнопки создаем переменную buttonState с типом boolean. Это логический тип данных. Переменная может принимать одно из двух значений: true (истинно) или false (ложно). В нашем случае – светодиод светится и не светится.

Скопируйте или перепишите код программы в окно Arduino IDE. Загрузите в контроллер и проверьте.

Для сохранения проектов Ардуино я создал папку d:Arduino ProjectsLessonsLesson5. В каждом уроке программы называю scetch_5_1, scetch_5_2, … Вы можете поступать также или ввести свою систему сохранения файлов.

Блок программы:

buttonState = digitalRead(12);  // считываем состояние 12 входа (кнопки) и записываем в buttonState
  buttonState = ! buttonState;    // инверсия переменной buttonState
  digitalWrite(13, buttonState);  // записываем состояние из buttonState на выход 13 (светодиод)

можно записать без использования промежуточной переменной buttonState.

digitalWrite(13, ! digitalRead(12) );

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

Т.е. функцию можно использовать как аргумент другой функции. Функции можно вызывать из функций.

Другой вариант этой же программы, использующий условный оператор if.

/* Программа scetch_5_2 урока 5
   Зажигает светодиод (вывод 13) при нажатии кнопки (вывод 12) */
  
void setup() {
  pinMode(13, OUTPUT);        // определяем вывод 13 (светодиод) как выход
  pinMode(12, INPUT_PULLUP);  // определяем вывод 12 (кнопка) как вход
}

//  бесконечный цикл
void loop() {
  if ( digitalRead(12) == LOW ) digitalWrite(13, HIGH);
  else digitalWrite(13, LOW);
}

В бесконечном цикле проверяется состояние вывода 12 (кнопка), и если оно низкое (LOW), то на выводе 13 (светодиод) формируется высокое состояние (HIGH). В противном случае состояние светодиода низкое (LOW).

Директива  #define.

Во всех примерах для функций ввода/вывода мы указывали аргумент pin, определяющий номер вывода, в виде конкретного числа – константы. Мы помнили, что константа 12 это номер вывода кнопки, а 13 – номер вывода светодиода. Гораздо удобнее работать с символьными именами. Для этого в языке C существует директива, связывающая идентификаторы с константами, выражениями.

Директива #define определяет идентификатор и последовательность символов, которая подставляется вместо идентификатора, каждый раз, когда он встречается в тексте программы.

В общем виде она выглядит так:

#define имя последовательность_символов

Если в наших программах мы напишем:

#define LED_PIN 13     // номер вывода светодиода равен 13

то каждый раз, когда в программе встретится имя LED_PIN, при трансляции вместо него будет подставлены символы 13. Функция включения светодиода выглядит так:

digitalWrite(LED_PIN, HIGH);

Окончательный вариант программы с использованием #define.

/* Программа урока 5
   Зажигает светодиод (вывод 13) при нажатии кнопки (вывод 12) */
  
#define LED_PIN 13     // номер вывода светодиода равен 13
#define BUTTON_PIN 12  // номер вывода кнопки равен 12

void setup() {
  pinMode(LED_PIN, OUTPUT);    // определяем вывод 13 (светодиод) как выход
  pinMode(BUTTON_PIN, INPUT_PULLUP);  // определяем вывод 12 (кнопка) как вход
}

//  бесконечный цикл
void loop() {
  digitalWrite(LED_PIN, ! digitalRead(BUTTON_PIN) );
}

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

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

Предыдущий урок      Список уроков      Cледующий урок

Источник: http://mypractic.ru/urok-5-pervaya-programma-funkcii-upravleniya-vvodomvyvodom-knopka-svetodiod.html

Как подключить кнопку к Arduino

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

• Arduino;
• тактовая кнопка;
• резистор 10 кОм;
• макетная плата;
• соединительные провода.

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

Виды кнопок, их внешний вид и обозначение на электрической схеме

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

Также кнопки делят на:

• нормально разомкнутые,
• нормально замкнутые.

Первые при нажатии замыкают цепь, вторые – размыкают.

Сейчас нашёл широкое применение тип кнопок, которые называют «тактовые кнопки». Тактовые – не от слова «такт», а от слова «тактильный», т.к. нажатие хорошо чувствуется пальцами.

Но этот ошибочный термин устоялся, и теперь эти кнопки у нас повсеместно так называют. Это кнопки, которые при нажатии замыкают электрическую цепь, а при отпускании – размыкают, т.е.

это нефиксирующиеся, нормально разомкнутые кнопки.

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

Кнопка – очень простое и полезное изобретение, служащее для лучшего взаимодействия человека и техники. Но, как и всё в природе, она не идеальна. Проявляется это в том, что при нажатии на кнопку и при её отпускании возникает т.н. «дребезг» (“bounce” по-английски).

Это многократное переключение состояния кнопки за короткий промежуток времени (порядка нескольких миллисекунд), прежде чем она примет установившееся состояние.

Это нежелательное явление возникает в момент переключения кнопки из-за упругости материалов кнопки или из-за возникающих при электрическом контакте микроискр.

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

В следующей статье мы подробно рассмотрим способы борьбы с «дребезгом» при замыкании и размыкании контактов. А пока что рассмотрим варианты подключения кнопки к Arduino.

3 Некорректное подключение кнопки

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

Неправильное подключение кнопки к Arduino

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

4Подключение кнопки по схеме с подтягивающим резистором

Сначала подключим к Arduino кнопку по схеме с подтягивающим резистором. Для этого один контакт кнопки соединим с землёй, второй – с цифровым выходом “2”. Цифровой выход “2” также подключим через резистор номиналом 10 кОм к питанию +5 В.

Схема подключения кнопки к Arduino по схеме с подтягивающим резистором

Напишем вот такой скетч для обработки нажатий на кнопку и загрузим в Arduino.

// Задаём номера выводов: const int buttonPin = 2; const int ledPin = 13; void setup() { pinMode(ledPin, OUTPUT); pinMode(buttonPin, INPUT); } void loop() { int buttonState = digitalRead(buttonPin); // считываем состояние кнопки if (buttonState == HIGH) { digitalWrite(ledPin, HIGH); // зажигаем светодиод при нажатии кнопки } else { digitalWrite(ledPin, LOW); // гасим светодиод при отпускании кнопки } }

Встроенный светодиод на выводе “13” постоянно горит, пока не нажата кнопка. Т.е. на порте “2” Arduino всегда присутствует высокий логический уровень HIGH. Когда нажимаем кнопку, напряжение на “2” порте принимает состояние LOW, и светодиод гаснет.

5 Подключение кнопки по схеме со стягивающим резистором

Теперь соберём схему со стягивающим резистором. Один контакт кнопки соединим с питанием +5 В, второй – с цифровым выходом “2”. Цифровой выход “2” подключим через резистор номиналом 10 кОм к земле. Скетч менять не будем.

Подключение кнопки к Arduino по схеме со стягивающим резистором

При включении схемы на цифровом порте “2” Arduino низкий уровень LOW, и светодиод не горит. При нажатии на кнопку на порт “2” поступает высокий уровень HIGH, и светодиод загорается.

Источник: https://soltau.ru/index.php/arduino/item/376-kak-podklyuchit-knopku-k-arduino

Гирлянда на Arduino. Функция debounce()

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

Для того чтобы осуществить “переключение” необходимо добавить новую переменную, которая будет хранить значение уровня сигнала предыдущего нажатия на кнопку. Помимо нее необходимо указать еще одну переменную. Она понадобится нам в теле функции void loop().

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

Алгоритм переделанной программы выглядит так: изначально lastButton = LOW, переменная buttonState хранит текущий уровень сигнала на выходе кнопки, а условие if проверяет, если кнопка зажата, и предыдущее значение lastButton было LOW, то переменная enable инвертируется (LOW станет HIGH).

После этого вне условия if функция digitalWrite() запишет уровень, который хранит переменная enable на контакт, к которому подключен светодиод. Финальный вид программы выглядит так:

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

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

Конфигурация контактов и функция void seup() остаются без изменений. Помимо изменений в основном коде необходимо добавить новую функцию. Назовем её debounce(). Поскольку эта функция будет возвращать нам значение boolean, то необходимо приписать соответствующий тип данных, который возвращает функции.

Эта функция принимает boolean значение, которое записывается в переменную под названием last. Далее снова считывается значение тактовой кнопки, идет сравнение с предыдущим значением и если значения различны, то после кратковременной задержки идет повторное считывание уровня поступающего на контакт “2”.

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

Теперь нам необходимо просто идентифицировать наши светодиоды в программе. Мы не будем писать номер контакта и режим работы для каждого светодиода. Мы создадим массив pins[], а режим работы зададим через цикл for(). Окончательный вариант программы выглядит так:

Цикл for() просто перебирает элементы массива pins[] и подставляет на место первого аргумента функции digitalWrite(). Зашиваем программу на Arduino и наслаждаемся результатом.

Скорость гирлянды можно регулировать, варьируя значением аргумента функции delay().

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

Надеюсь, что эта статья была для Вас полезной. В следующем уроке “Arduino и PWM” мы рассмотрим принцип работы ШИМ (широтно-импульсная модуляция) на данном примере.

Источник: http://arduinokit.blogspot.com/2013/05/girlyanda-na-arduino.html

Радиоуправление на Arduino

Соберем радиоуправление на основе Arduino Uno и радиомодуля MX-05v. Этот модуль работает на частоте 443 МГц, что позволяет использовать его под водой (волны в диапазоне 2.4 ГГц не проникают под воду). Потом поставим его на модель Радиоуправляемой Подводной Лодки.

Радиомодуль MX-05V + MX-FS-03V подкупает своей низкой ценой – около 60 рублей за пару. Заявленной дальности связи 20-200 метров хватает для небольших моделей машин или лодок.

Сделаем одноканальную аппаратуду. Для этого нам понадобятся:

• 2 платы Ардуино для приемника и передатчика
• комплект радиомодуля MX-05V + MX-FS-03V
• переменный резистор или джойстик для передатчика
• рулевая машинка (серва) для приемника

Суть работы программы заключается в следующем:

• считываем значение с переменного резистора (число от 0 до 1023)
• переводим это число в 2 байта (16 бит, т.к. 1023 занимает 10 бит и не поместится в один байт)
• передаем по радио-каналу
• приемник принимает 2 байта по радио каналу
• переводит их обратно в число от 0 до 1023
• передает команду серво-машинке

Принцип работы Arduino доступно описан на разных веб-ресурсах. Мне понравился бесплатный обучающий онлайн курс «Строим роботов и другие устройства на Arduino». Рекомендую.

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

Передатчик

// Библиотека передатчика
#include void setup() { // Запуск передатчика vw_set_ptt_inverted(true); vw_setup(1000); // Bits per sec } void loop() { // чтение показаний с переменного резистора int sensorValue = analogRead(A0); // отправляем значение send(sensorValue); } void send(int param) { // конвертируем int в массив из 2 байт uint8_t msg[2]; int len = 2; msg[0] = highByte(param); msg[1] = lowByte(param); // отправляем непосредственно в радиоканал vw_send(msg, len); // ждем пока сообщение не уйдет целиком vw_wait_tx(); }

Приемник

// Библиотека для приемника
#include // Библиотека для серво машинки. В отличии от обычной Servo.h не конфликтует с VirtualWire.h
// Скачать библиотеку можно тут. // http://en.osdn.jp/projects/sfnet_pgahtow/downloads/Arduino%20(v1.0)%20libaries/ServoTimer2.zip/
// Надо закомментировать 41 строчку в файле ServoTimer2.

h в случае ошибки компиляции
// 'typedef uint8_t boolean;'
#include // Создаем объект серво-машинки
ServoTimer2 myservo; void setup() { // для отладки // Serial.begin(9600); // Запуск приемника vw_set_ptt_inverted(true); vw_setup(1000); // бит в секунду vw_rx_start(); // запуск приемника // подключаем серво к 6 пину myservo.

attach(6);
} void loop() { uint8_t msg[2]; uint8_t len = 2; if (vw_get_message(msg, &len)) { // переводим байты в int int value = word(msg[0], msg[1]); // подгоняем под диапазон входных данных сервы int sValue = map(value, 0, 1023, 600, 2400); myservo.write(sValue); // Serial.

println(sValue); }
}

И в итоге – ничего не работает! Почему?

Питание

Радиомодуль MX-05V очень простой, из-за этого он очень восприимчив к внешним помехам. И даже такой маленький мотор как в серво-машинке способен нарушить его работу.

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

Итоговая схема подключения приемника выглядит так.

Результат

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

Источник: http://imelnikov.ru/radio/arduino-rc/

Как сделать Arduino c USB своими руками?

Официальную версию Arduino можно купить примерно за 27 евро. Есть отечественные аналоги (например Freeduino) и китайские копии которые стоят немного дешевле. Но зачем покупать? Ведь можно сделать Arduino своими руками.

Плата подключается к компьютеру и прошивается через USB благодаря микросхеме FT232RL на борту. С помощью джампера можно выбрать от какого источника будет питаться Arduino: USB порт компьютера (позиция «int») или от разъема блока питания (позиция «ext»).  Так же присутствует джампер разрешения автоматической перезагрузки (auto reset enable).

Достоинством данной платы является то что она односторонняя и легко изготавливается в домашних условиях.

Данный проект разработан в P-CAD. Вот скриншот электрической схемы:

А вот вид печатной платы самодельной Arduino:

Ну и расположение компонентов на схеме:

Советую электролитические конденсаторы уложить на бок (имеются ввиду C7 и C8).

После того как сделаете данную плату, не забудьте прошить контроллер Atmega8 (прошивка как и файлы печатной платы можно скачать по ссылке в конце статьи). ВНИМАНИЕ: обязательно выставьте корректные фьюзы!

Младший байт: BODLEVEL   1  BODEN      1  SUT1       0  SUT0       1  CKSEL3     1  CKSEL2     1  CKSEL1     1 

CKSEL0     1 

Старший байт: RSTDISBL   1  WDTON      1  SPIEN      0  CKOPT      0  EESAVE     1  BOOTSZ1    0  BOOTSZ0    1 

BOOTRST    0

После того как вы прошили свою самодельную плату Arduino нужно установить драйвер FTDI (скачать можно на официальном сайте)

Теперь запускаем Arduino IDE и начинаем творить. Только не забудьте предварительно выбрать используемую плату:  Сервис -> Платы -> Arduino NG or older w/ATmega8.

Вот и все. Итак, для того чтобы сделать Arduino своими руками вам нужно скачать этот архив. Там вы найдете файлы P-CAD  с печатной платой и схемой, прошивку для ATMega8, список деталей для покупки с примерной стоимостью, а также даташит на AVR контроллер ATMega8. Ну и напоследок хочу сказать что плата совместима абсолютно со всеми Arduino шилдами.

Печатная плата Arduino, разведенная в Sprint-Layout 5.0

Вы можете скачать печатную плату USB Arduino разработанную в Sprint-Layout 5. Данная программа более популярна среди радиолюбителей, нежели P-CAD. За разведенную плату огромное спасибо Дмитрию Ефремову. Печатная плата проверена, ошибок нет.

Фото готового устройства

Вид сверху

Вид снизу

Руководство пользователя

Так же Николай Вахрушев составил небольшое руководство пользователя — семи страничная шпаргалка по самодельной USB Arduino.

В руководстве вы увидите фотографии Ардуино с подписанными разъемами, джамперами, кнопками, индикаторами и выводами. Также дано детальное описание и назначение каждого элемента на плате.

Последние три страницы: перечень необходимых компонентов, печатная плата (можно сразу печатать  для ЛУТ) и электрическая схема.

Скачать руководство (PDF, 960 кБ)

Источник: http://easymcu.ucoz.ru/publ/12-1-0-120