Контроль положения контактов 3-х позиционного переключателя с помощью ардуино

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

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

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

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

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

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

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

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

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

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

В наших проектах мы будем работать с очень простыми тактовыми кнопками с 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;
  • тактовая кнопка;
  • резистор номиналом 10 кОм;
  • светодиод;
  • соединительные провода.

«Дребезг» контактов – это явление, свойственное механическим переключателям, кнопкам, тумблерам и реле.

Из-за того, что контакты обычно делают из металлов и сплавов, которые обладают упругостью, при физическом замыкании они не сразу устанавливают надёжное соединение. В течение короткого промежутка времени контакты несколько раз смыкаются и отталкиваются друг от друга.

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

Видно, что время от момента переключения до установившегося состояния составляет несколько миллисекунд. Это и называется «дребезгом».

Так выглядит эффект дребезга контактов на осциллограммах

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

Но в цепях, где идёт быстрое считывание и обработка информации (где частоты того же порядка, что и импульсы «дребезга», или выше), это является проблемой. В частности, Arduino UNO, который работает на частоте 16 МГц, отлично ловит «дребезг» контактов, принимая последовательность единиц и нулей вместо единичного переключения от 0 к 1.

2Подключение кнопки к Arduino для демонстрации подавления «дребезга»

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

Схема подключения кнопки к Arduino для демонстрации подавления эффекта «дребезга» контактов

3Алгоритм подавления«дребезга» контактов

Чтобы реализовать задачу подавления дребезга контактов, первое, что приходит в голову:

  • запоминать предыдущее состояние кнопки;
  • сравнивать с текущим состоянием;
  • если состояние изменилось, то меняем состояние светодиода.

Напишем такой скетч и загрузим в память Arduino.

int switchPin = 2; // вывод считывания кнопки int ledPin = 13; // вывод светодиода boolean lastButton = false; // предыдущее состояние кнопки boolean ledOn = false; // включён или выключен светодиод void setup() { pinMode(switchPin, INPUT); // состояние кнопки считываем (in) pinMode(ledPin, OUTPUT); // светодиод запитываем (out) } void loop() { int pressed = digitalRead(switchPin); /* состояние кнопки: HIGH, true — нажата, LOW, false — нет */ if (pressed == true && lastButton == false) { /* если кнопка сейчас нажата, а до этого была не нажата */ ledOn = !ledOn; // меняем состояние светодиода lastButton = true; // запоминаем новое состояние кнопки } else { lastButton = digitalRead(switchPin); // считываем состояние кнопки } digitalWrite(ledPin, ledOn); // зажигаем или гасим светодиод }<\p>

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

Читайте также:  Регулятор мощности паяльника

4Подавление дребезга контактовс помощью задержки

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

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

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

int switchPin = 2; // пин кнопки int ledPin = 13; // пин светодиода boolean lastButton = false; // предыдущее состояние кнопки boolean currentButton = false; // текущее состояние кнопки boolean ledOn = false; // состояние светодиода void setup() { pinMode (switchPin, INPUT); pinMode (ledPin, OUTPUT); } void loop() { currentButton = debounce (lastButton); // получаем состояние кнопки без дребезга if (lastButton == false && currentButton == true) { // если кнопка была нажата дольше 5 мсек, ledOn = !ledOn; // то меняем состояние светодиода } lastButton = currentButton; // обнуляем состояние нажатия кнопки digitalWrite (ledPin, ledOn); // зажигаем/гасим светодиод } // Процедура определения нажатия кнопки без дребезга: boolean debounce(boolean last) { boolean current = digitalRead(switchPin); // считываем текущее состояние кнопки if (last != current) { // если состояние изменилось delay(5); // делаем задержку на 5 мсек, пока уляжется дребезг current = digitalRead(switchPin); // и считываем снова } return current; // возвращаем текущее состояние кнопки }

В данном скетче мы объявим процедуру debounce() («bounce» по-английски – это как раз «дребезг», приставка «de» означает обратный процесс), на вход которой мы подаём предыдущее состояние кнопки. Если нажатие кнопки длится более 5 мсек, значит это действительно нажатие. Определив нажатие, мы меняем состояние светодиода.

Загрузим скетч в плату Arduino. Теперь всё гораздо лучше! Кнопка срабатывает без сбоев, при нажатии светодиод меняет состояние, как мы и хотели.

5Библиотеки для подавлениядребезга контактов

Аналогичная функциональность обеспечивается специальными библиотеками, например, библиотекой Bounce2. Для установки библиотеки помещаем её в директорию /libraries/ среды разработки Arduino и перезапускаем IDE.

Библиотека Bounce2 содержит следующие методы:

НазваниеНазначение
Bounce() инициализация объекта «Bounce»;
void interval (мсек) устанавливает время задержки в миллисекундах;
void attach (номерПина) задаёт вывод, к которому подключена кнопка;
int update() обновляет объект и возвращает true, если состояние пина изменилось, и false в противном случае;
int read() считывает новое состояние пина.

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

#include // подключаем библиотеку const int switchPin = 2; // пин кнопки const int ledPin = 13; // пин светодиода int cnt = 0; // счётчик нажатий Bounce b = Bounce(); // инстанциируем объект Bounce void setup() { pinMode(switchPin, INPUT); digitalWrite(switchPin, HIGH); // включаем подтягивающий резистор pinMode(ledPin, OUTPUT); b.attach(switchPin); // объект Bounce будет слушать кнопку на пине switchPin b.interval(5); // устанавливаем время задержки в [мс] } void loop() { if (b.update() && b.read() == 0) { // если зарегистрировано событие и кнопка нажата, cnt += 1; // инкрементируем счётчик нажатий if (cnt %2 == 0) digitalWrite(ledPin, LOW); // если нажатий чётное число, гасим светодиод else digitalWrite(ledPin, HIGH); // иначе — зажигаем светодиод } }

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

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

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

Источник: https://soltau.ru/index.php/themes/arduino/item/393-kak-izbavitsya-ot-drebezga-kontaktov-pri-podklyuchenii-knopki-k-arduino

Распайка звукоснимателей 103

Не хочешь смотреть рекламу? Зарегистрируйся!

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

До сих пор мы имели дело с одним датчиком, соединённым с регулятором громкости. И с регулятора громкости сигнал шел на разъем. Мы будем продолжать с теми же начальными условиями, только добавим еще один звукосниматель.

Контроль так же будем осуществлять одним регулятором громкости.

Как вы уже знаете, провода заземления от всех датчиков припаиваются в одной точке — точке заземления (например на крышке потенциометра). И идут туда напрямую — без всяких переключателей.

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

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

На рисунке видно, что до момента переключения короткий промежуток времени оба датчика могут быть подсоединены /*(: так и написано*/. Но в реальном случае этого не будет.

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

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

Есть 2 типа переключателей, обычно использующихся для этой цели.

Лопастной переключатель
(Со скользящим контактом или ползунковый)

Этот тип переключателей наиболее часто можно видеть на гитарах Fender. Обычно он выглядит так:

Стандартный для Telecaster переключатель – 3-х позиционный. Такая схема дает нам 3 комбинации, которые мы и хотели получить: нековый (у грифа) датчик, бридж + нек вместе, бриджевый датчик (у струнодержателя). Если смотреть на переключатель, то это позиции N – нек (у грифа), M – мидл(средняя позиция), B – бридж (у струнодержателя).

Стержень лопастного переключателя – механизм, обеспечивающий самый обычный контакт, где количество подключаемых контактов – три (в нашем случае). По одному на каждую позицию переключателя. В каждой позиции переключателя центральный контакт включает в цепь один из переключаемых контактов. Такой переключатель обычно называют «трёх-позиционный».

На рисунке представлена схема одного из типов таких переключателей. С положениями N, M (N+B), B, если смотреть слева на право. Также могу добавить, что нековый датчик будет работать в позициях N и M (для наглядности соединение изображено синим цветом, но на практике скорее всего будет белый провод).

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

А теперь подсоединим к переключателю наш бриджевый датчик (соединение показано красным проводом). Так он будет подключаться к выходу в позициях M и B.

Видите ли вы незадачу? У нас теперь есть провода, подсоединённые во всех трёх позициях переключателя друг к другу. В сущности 3-х позиционные контакты выполняют роль одного контакта, с обоими подключенными датчиками. Результатом является то, что не нужно думать в какой позиции переключателя оба датчика будут активны.

:)) Путь решения этой незадачи – добавление другого переключателя, аналогичного первому и подсоединённый по подобному принципу. В общем вы получите 2 переключающих платы на одном общем переключателе на и 3 пары переключаемых контактов совершенно не замыкающих друг друга. Но переключающихся одновременно, как один переключатель.

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

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

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

На рисунке она развёрнута вверх ногами.

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

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

Переключатель рычажного типа

Этот тип переключателей обычно можно увидеть на гитарах типа Les Paul. Также это 2 переключателя, контролируемых с помощью одного 3-х позиционного рычага, но отличающихся по механике. Схематически это выглядит так:

На картинке видно, что этот переключатель можно представить как два он-офф переключателя. В позиции 1 контакты 1 и А соединены, а контакты 2 и В – разомкнуты. В позиции 2 контакты 1 и А соединены, В и 2 – тоже соединены. А в позиции 3 соединены только 2 и В.
Реальный переключатель изображен слева.

Чтобы получить необходимые нам положения нек-оба-бридж, все что нам нужно сделать – это подпаять каждый датчик к контактам А и В, а контакты 1 и 2 – к регулятору громкости. Такой переключатель также обычно имеет контакт заземления.
Распайка с помощью этого переключателя выглядит так:

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

Вопросы еще остались? Или все понятно? Дайте нам знать в комментариях! _______________________________________

Источник: http://jablog.ru/blog/workshop/2895.html

Arduino урок 3 — Кнопка

В этом примере мы рассмотрим подключение кнопки к контроллеру Arduino. И рассмотрим несколько примеров обработки нажатия.

Для урока понадобятся:

  • Arduino
  • Макетная плата
  • Пара резисторов
  • Кнопка
  • Светодиод
  • Соединительные провода

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

Пример подключения

Простейший пример, при нажатии светодиод горит.

int LED = 13; // подключаем светодиод int knopka = 2; // подключаем кнопку void setup(){ pinMode(LED,OUTPUT); // пин 13 на выход pinMode(knopka, INPUT); // пин 2 на вход } void loop(){ if (digitalRead(knopka)==HIGH){ // если кнопка зажата digitalWrite(LED, HIGH);// включаем светодион } else{ digitalWrite(LED,LOW);// иначе, выключаем светодиод }}

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

void loop(){ if (digitalRead(knopka)==LOW){ digitalWrite(LED, HIGH); } else{ digitalWrite(LED,LOW); }}

Следующий код позволит отслеживать действия кнопки в мониторе порта

int knop=2; void setup(){ pinMode(knop, INPUT); Serial.begin(9600); // задаем скорость для связи } void loop(){ if (digitalRead(knop)==HIGH){ // если кнопка зажата… Serial.println(«ON»);} // отправляем на монитор «ON» if (digitalRead(knop)==LOW){ Serial.println(«OFF»);} }

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

int flag=0; void setup() { pinMode(13, OUTPUT); } void loop() { if(digitalRead(14)==HIGH&&flag==0)//если кнопка нажата // и перемення flag равна 0 , то … { digitalWrite(13,!digitalRead(13)); flag=1; //это нужно для того что бы с каждым нажатием кнопки //происходило только одно действие // плюс защита от «дребезга» 100% } if(digitalRead(14)==LOW&&flag==1)//если кнопка НЕ нажата //и переменная flag равна — 1 ,то … { flag=0;//обнуляем переменную flag } }

Еще немного изменим код и получим несколько действий, в данном случае 4.

int regim=1; int flag=0; void setup() { pinMode(10,OUTPUT); pinMode(9,OUTPUT); } void loop() { if(digitalRead(14)==HIGH&&flag==0)//если кнопка нажата // и перемення flag равна 0 , то … { regim++; flag=1; //это нужно для того что бы с каждым нажатием кнопки //происходило только одно действие // плюс защита от «дребезга» 100% if(regim>4)//ограничим количество режимов { regim=1;//так как мы используем только одну кнопку, // то переключать режимы будем циклично } } if(digitalRead(14)==LOW&&flag==1)//если кнопка НЕ нажата //и переменная flag равна — 1 ,то … { flag=0;//обнуляем переменную «knopka» } if(regim==1)//первый режим { digitalWrite(9,LOW);//выключаем все светодиоды digitalWrite(10,LOW); //здесь может быть любое ваше действие } if(regim==2)//второй режим { digitalWrite(10,HIGH);//включае красный светодиод digitalWrite(9,LOW); //здесь может быть любое ваше действие } if(regim==3)//третий режим { digitalWrite(9,HIGH);//включае зеленый светодиод digitalWrite(10,LOW); //здесь может быть любое ваше действие } if(regim==4)//четвертый режим { digitalWrite(9,HIGH);//включаем светодиоды одновременно digitalWrite(10,HIGH); //здесь может быть любое ваше действие } }

Источник: http://ampexpert.ru/arduino-urok-3-knopka/

Arduino Uno: Кнопка и чтение цифрового вывода

Продолжаю изучать базовые примеры и решил разобраться с примером DigitalReadSerial из File→Examples→1.Basics

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

Для опытов нам понадобятся:

  • плата Arduino Uno
  • кнопка (я использовал тактовую кнопку без фиксатора, которая шла в наборе)
  • резистор
  • макетная плата Breadboard
  • провода или перемычки
  • светодиод (опционально)

Приблизительно собранная схема может выглядеть следующим образом:

Вкратце опишу на словах данную схему. Вставляем в центре макетной платы кнопку таким образом, чтобы между парными ножками проходил желоб макетной платы. Далее соединяем перемычками питание 5V и землю GND на Arduino с рельсами на макетной плате.

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

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

Кнопка выполняет очень важную функцию — она замыкает цепь при нажатии.

Когда кнопка не нажата, то ток не проходит между ножками кнопки, и сигнал с цифрового вывода под номером 2 не может пройти через кнопку и резистор к выводу GND и определяется системой как LOW или 0.

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

Код

Разберем код по кусочкам

// Второй вывод связан с кнопкой
int pushButton = 2; void setup() { Serial.begin(9600); pinMode(pushButton, INPUT);
} void loop() { int buttonState = digitalRead(pushButton); Serial.println(buttonState, DEC); delay(1);
}

Первое, что мы делаем в процедуре setup(), то устанавливаем связь с портом для считывания данных на скорости 9600 бит в секунду с Arduino на ваш компьютер: Serial.begin(9600);.

Читайте также:  Подключение графического жк-дисплея 128х64 ks0108 к at89c52

Вторая строчка нам уже знакома, но здесь теперь используется параметр INPUT — мы устанавливаем второй цифровой вывод на режим чтения выходных данных, поступающих с кнопки, т.е. вводим в цифровой выход информацию от кнопки: pinMode(pushButton, INPUT);

Процедура инициализации закончена. Теперь необходимо цикле считывать поступающую информацию. Для начала нам понадобится новая переменная buttonState, которая будет содержать значения 0 или 1, поступающие от функции digitalRead(), используя в её параметре номер цифрового вывода: int buttonState = digitalRead(pushButton);.

Чтобы мы могли видеть поступающую информацию, нужно вывести получаемые результаты в специальное окно Serial Monitor при помощи команды println(). Второй параметр DEC выводит числа в привычной нам десятичной системе.

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

Если вы сейчас запустите программу и откроете также окно Serial Monitor (меню Tools | Serial Monitor), то на экране увидите бесконечные нули. Программа постоянно опрашивает состояние нашей конструкции и выводит результат — отсутствие тока. Если нажать на кнопку и удерживать её, то увидите, что цифры сменяются с 0 на 1. Значит в нашей цепи появился ток и информация изменилась.

При изучении пример мне показался слишком скучным. Поэтому для наглядности я добавил после резистора еще светодиод. Теперь при нажатии на кнопку у меня не только бегут единицы на Serial Monitor, но и загорается светодиод красивым цветом. Красота!

Кнопочный переключатель

В примере светодиод будет гореть, когда нажата кнопка. По сути мы замыкаем два куска провода, чтобы по ним прошёл ток. Отпустили кнопку — ток не течёт.

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

За основу взял пример с Амперки

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

На макетной плате.

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

Рассмотрим код

int buttonPin = 3; // пин для кнопки
int ledPin = 13; // пин для светодиода boolean isTurnOn = true; // включать ли свет?
boolean isLedEnabled = false; // включен ли свет? void setup()
{ pinMode(ledPin, OUTPUT); pinMode(buttonPin, INPUT_PULLUP);
} void loop()
{ // определить момент «клика» несколько сложнее, чем факт того, // что кнопка сейчас просто нажата. Для определения клика мы // сначала понимаем, отпущена ли кнопка прямо сейчас… boolean isButtonUp = digitalRead(buttonPin); // …если «следует включить и (&&) не отпущена сейчас»… if (isTurnOn && !isButtonUp) { // …может это «клик», а может и ложный сигнал (дребезг), // возникающий в момент замыкания/размыкания пластин кнопки, // поэтому даём кнопке полностью «успокоиться»… delay(10); // …и считываем сигнал снова isButtonUp = digitalRead(buttonPin); if (!isButtonUp) { // если она всё ещё нажата… // …это клик! Переворачиваем сигнал светодиода isLedEnabled = !isLedEnabled; digitalWrite(ledPin, isLedEnabled); } } // запоминаем последний режим для включения кнопки для новой итерации isTurnOn = isButtonUp;
}

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

Кнопка подключена к пину 2 и находится в режиме входа, так как нам нужно считывать состояние кнопки. При этом вместо режима INPUT теперь используется INPUT_PULLUP.

При нажатии на кнопку в данном режиме мы будем получать 0. Когда кнопка будет отпущена, то получим значение 1.

При использовании булевых переменных значение нажатой кнопки будет равно false, ненажатой — true.

Переменная isTurnOn отвечает за режим включения — включить или выключить. Переменная isButtonUp отвечает за кнопку, отпущенную сейчас.

Допустим, мы нажали кнопку — сделали щелчок. Сначала мы считываем показания с кнопки и узнаём, нажата ли она прямо сейчас.

boolean isButtonUp = digitalRead(buttonPin);

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

// …если «следует включить и (&&) не отпущена сейчас»…
if (isTurnOn && !isButtonUp) // оба значения true, значит вернёт тоже true

Логический оператор && («и») возвращает значение «истина» только в случае истинности обоих его операндов.

Взглянем на так называемую таблицу истинности для выражения isTurnOn && !isButtonUp («кнопка была отпущена и кнопка не отпущена»):

isTurnOn isButtonUp !isButtonUp isTurnOn && !isButtonUp
1
1
1 1 1
1 1

Но не торопитесь включать светодиод. У кнопок существует такой эффект, как «дребезг».

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

Через 10 миллисекунд мы проверяем еще раз, нажата ли кнопка: этот интервал больше, чем длительность «дребезга», но меньше, чем время, за которое человек успел бы дважды нажать на кнопку. Если кнопка всё еще нажата (по-прежнему возвращает значение false), значит, это был не дребезг и мы можем доверять показанию с контактов кнопки.

Снова инвертируем переменную (только одну) и передаём в digitalWrite() не конкретное значение HIGH или LOW, а просто булеву переменную isLedEnabled. В зависимости от того, какое значение было для нее вычислено, светодиод будет зажигаться или гаситься.

Последняя инструкция в isTurnOn = isButtonUp сохраняет текущее состояние кнопки в переменную предыдущего состояния, ведь на следующей итерации loop текущее состояние уже станет историей.

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

Реклама

Источник: http://developer.alexanderklimov.ru/arduino/button.php

Урок 15. Bluetooth модуль HC-06 подключение к Arduino. Управление устройствами с телефона

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

Один из самых популярных и распространенных методов обмена данными посредством Bluetooth.

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

Нам понадобится:

  • Arduino Uno R3
  • Набор проводов ПАПА-МАМА
  • HC-06 Bluetooth

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

Подключать Bluetooth модуль к микроконтроллеру Arduino удобнее всего с помощью проводков ПАПА-МАМА.

ArduinoBluetooth
Pin 1 (TX) RXD
Pin 0 (RX) TXD
GND GND
5V VCC

Будьте внимательны, подключать подключать нужно TX -> RXD ,RX -> TXD.

Теперь необходимо записать пробный код программы:

Во время загрузки скетча необходимо что бы Bluetooth модуль был отключен от микроконтроллера arduino. В противном случае скетч не запишется, потому что связь с Bluetooth модулем происходит по одному и томуже порту RX и TX, что и USB.

int val;
int LED = 13;
void setup()
{ Serial.begin(9600); pinMode(LED, OUTPUT); digitalWrite(LED, HIGH);
}
void loop()
{ if (Serial.available()) { val = Serial.read(); // При символе «1» включаем светодиод if (val == '1') { digitalWrite(LED, HIGH); } // При символе «0» выключаем светодиод if ( val == '0') { digitalWrite(LED, LOW); } }
}

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

После того как скетч записан и Bluetooth модуль подключен к Arduino, можно перейти к следующему шагу.

Подключение Bluetooth к телефону

Желательно в качестве источника питания для arduino использовать не USB, а внешний Блок питания на 9 В.

  1. Включаем Bluetooth на телефоне и ищем новые устройства
  2. Находим в списке расстройств «HC-06″ и подключаемся к нему.
  3. Телефон спросит пин-код. необходимо ввести «1234» или «0000«
  4. Ура. Устройство подключено.

Теперь нужно скачать bluetooth terminal на ваш телефон. Мы рассмотрим на примере платформы Android.

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

После того как мы установили терминал, запускаем его выбираем наш bluetooth модуль HC-06 и подключаемся к нему.

Пришло время попробовать проект в деле. Пишем в терминале цифру «0» и отправляем. Светодиод L который находится на плате arduino рядом с pin 13, должен погаснуть. Теперь отправим через терминал цифру «1» и светодиод L должен зажечься.

Демонстрация работы:

Домашняя работа:

  • Изменить скетч так, что бы светодиод зажигался и потухал с помощью одной и той же команды например «G».
  • Дописать скетч и научить его преобразовывать текстовые данные приходящие через блютус в цифровые и реализовать димер, зажигать светодиод с помощью ШИМ, на заданную яркость от 0 до 254 приходящую через bluetooth.

Источник: https://lesson.iarduino.ru/page/bluetooth-modul-hc-06-podklyuchenie-k-arduino-upravlenie-ustroystvami-s-telefona

Подключение к ардуино датчика вращения енкодер KY-040

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

У отдельного датчика имеются три вывода. Они обычно обозначаются как A, B и C. В случае KY-040, они ориентированы так, как показано на рисунке. Внутри энкодера есть два переключателя.

Первый переключатель соединяет вывод А с выводом С, а второй соединяет вывод B с выводом C. В каждом фиксированном положении датчика, оба переключателя или открыты или закрыты.

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

Как вы можете видеть, угловое положение контакта A и контакта B такое, что: вращающаяся пластинка по часовой стрелке соединит контакты А и С. Вращающаяся пластина против часовой стрелки соединит контакты В и С. Представим на графике переходные характеристики контактов при равномерном вращении пластины.

Определив то, какая пара контактов изменяет свое состояние первой, узнаем направление вращения вала. Если контакт А изменяет состояние первым, то вал вращается в направлении по часовой стрелке. Если же контакт B изменяет свое состояние первым, то вал энкодера вращается в направлении против часовой стрелки.

Выводы KY-040

На следующем рисунке показано назначение выводов данного ротационного энкодера.

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

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

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

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

Схема ротационного енкодера

Схема рассматриваемого модуля приведена ниже. R2 и R3 на схеме выполняют функцию подтягивающих резисторов.

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

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

Тут всё максимально просто. Все, что вам нужно сделать, это подключить четыре провода к модулю.

int pinA = 3;  // номер вывода, подключенный к CLK енкодера

 int pinB = 4;  // номер вывода контроллера, подключенный к DT енкодера

 int encoderPosCount = 0; 

 int pinALast;  

 int aVal;

 boolean bCW;

 void setup() { 

   pinMode (pinA,INPUT);

   pinMode (pinB,INPUT);

   /* Считываем значение на выводе A и запоминаем его как последнее значение на этом выводе */

   pinALast = digitalRead(pinA);   

   Serial.begin (9600);

 } 

 void loop() { 

   aVal = digitalRead(pinA);

   if (aVal != pinALast){ // проверка на изменение значения на выводе А по сравнению с предыдущим запомненным, что означает, что вал повернулся

     // а чтобы определить направление вращения, нам понадобится вывод В.

     if (digitalRead(pinB) != aVal) {  // Если вывод A изменился первым — вращение по часовой стрелке

       encoderPosCount ++;

       bCW = true;

     } else {// иначе B изменил свое состояние первым — вращение против часовой стрелки

       bCW = false;

       encoderPosCount—;

     }

     Serial.print («Вращение: «);

     if (bCW){

       Serial.println («по часовой стрелке»);

     }else{

       Serial.println(«против часовой стрелки»);

     }

     Serial.print(«Положение енкодера: «);

     Serial.println(encoderPosCount);

   } 

   pinALast = aVal;

 } 

Источник: http://electronica52.in.ua/proekty-arduino/podkluchenie-k-arduino-datchika-vracsheniya-enkoder-ky040

Программирование и настройка контроллера аэродинамической скорости на основе Arduino

Эта статья является окончанием серией публикаций начатой со статьи Стабилизация крыла HK Mini-Sonic. Здесь объясняется, как запрограммировать и настроить контроллер аэродинамической скорости, построенный на основе стабилизатора Guardian Eagle Tree,  пропеллерного датчика и платы Arduino Pro Micro.

Как залить прошивку в контроллер.

В прошлой статье Контроллер пропеллерного датчика аэродинамической скорости на основе Arduino я объяснял, как собрать контроллер и провести базовое тестирование. Теперь надо скомпилировать код и загрузить прошивку в контроллер:

— Загрузка программы производится через MicroUSB шнур с Windows компьютера. У меня установлена операционная система Windows 7, но и более новые версии операционной системы так же подходят.

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

Читайте также:  На приборный щиток

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

— Открыть страницу проекта в депозитарии github и скопировать в окно скетча. Сохранить скетч на диск.

— Проверить подключение платы Arduino — В среде разработки Arduino, в настройках меню «Инструменты» выбрать плату «Arduino Leonardo».

Если драйвер платы установлен правильно, после этого должна появиться новая строка типа «Порт: COM4 (Arduinon Leonardo)».

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

— Выполнить команду «Файл->Вгрузить». Во время загрузки плате Arduino должн мигать RX светодиод, подтверждающий передатчу данных — через несколько секунд контроллер будет запрограммирован.

При первом  запуске программы программы, контроллер записывает предустановленные параметры стабилизации в память EEPROM — после этого он должен издать звуковой сигнал длинной в 3 сек.

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

Все — прошивка залита в контроллер, можно отсоединить плату от компьютера.

Как работает программа контроллера?

Для работы с контроллером совсем не надо разбираться в программировании и понимать математические алгоритмы стабилизации, использованные в программе. Но лучше иметь хотя бы общее представление: — На плату Arduino приходит 3 импульсных ШИМ сигнала с приемника (THR_IN, GAIN_IN, MOD_IN) и один импульсный сигнал c фотодиода оптопары — PROP_IN.

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

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

Эти же эти подпрограммы, используя встроенный в Ардуино 32-битный таймер, формируют выходные импульсы THR_OUT, GAIN_OUT, а так же управляют включением-выключением зуммера и светодиода.

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

Самые важные параметры этих формул записаны в энергонезависимую память контроллера Ардуино — EEPRPOM.

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

Настройка контроллера:

Контроллер управляется следующими каналами передатчика. — Сигнал Thr — тяга двигателя. — Сигнал Gain формируется одним из потенциометров, расположенных на панели передатчика.

— Сигнал Mod  — поступает с 3-х-позицинного переключателя, формирующего три длительности импульса управления 1.1 мс, 1.5 мс, 1.9 мс которые соответствуют трем режимам стабилизации Guardian: 2D — 3D — X. Верхнее положение переключателя X — «стабилизация выключена» должно соответствовать максимальной длительности импульса.

Режимы работы контроллера

У контроллера есть 4 основных режима работы: — Режим пилотажа. — Сквозной режим. — Режим калибровки.

— Режим программирования параметров.

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

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

Вход в любой режим настройки осуществляется включением питания контроллера в момент, когда тяга не выключенна (рычажок тяги находится в центральном положении). Выбор режима настройки определяется положением 3-х позиционного переключателя: — Верхнее положение (X) — сквозной режим, подтверждение — один бип. — Среднее положение (3D) — режим калибровки, подтверждение — два бипа.

— Нижнее положение (2D) — режим программирования параметров, подтверждение — три бипа.

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

Режим пилотажа

При входе в режим пилотажа контроллер издает длинный прерывистый сигнал и включает-выключает светодиод. В пилотажном режиме положение 3-х позиционного переключателя определяет, какая мода управления — Х, 3D, 2D будет выбрана.

Переключение между модами управления можно осуществлять в любой момент времени. Потенциометр Gain отключен от управления (за исключением «Экспертного пилотажного режима», см. ниже).

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

Сквозной режим

В этом режиме сигналы Thr, Gain, Mod просто копируются контроллером скорости и передаются неизменными на контроллер тяги модели и стабилизатор Guardian.

Во многом, это похоже на поведение контроллера в пилотажной моде «без стабилизации», но в этом режиме сигнал с 3-х позиционного переключателя передается непосредственно на стабилизатор Guardian и не вызывает переключения пилотажных мод управления.

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

Режим калибровки

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

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

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

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

Режим программирования параметров

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

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

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

Список параметров:

1 — Коэффициент подавления стабилизации гироскопа аэродинамической скоростью (GAIN_SUP_PARAM). Влияет на стабилизацию полета в зоне высокой аэродинамической скорости — чем параметр больше, тем сильнее скорость подавляет усиление в цепи обратной связи гироскопа-стабилизатора. Предустановленное значение — 0.32.

2 — Максимальный коэффициент стабилизации гироскопа (GAIN_MAX_PARAM). Влияет на полет на низких скоростях. Предустановленное значение — 1.0.
3 — Напряжение включения звуковой сигнализации низкого напряжения аккумулятора (LOW_BATT_PARAM). Диапазон значений 0.0 — 1.0 соответствует напряжениям 5.0V — 7.5V.

предустановленное значение — 0.85 (6.8 V).
4 — Коэффициент чувствительности датчика аэродинамической скорости, определяет, как частота вращения пропеллерного датчика преобразуется в коэффициент управления стабилизацией (PROP_PARAM). Этот коэффициент подбирается для каждого датчика индивидуально.

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

5 — Коэффициент подавления тяги двигателя модели аэродинамической скоростью (THR_SUP_PARAM), параметр активен только в 2D режиме .

Тяга двигателя модели будет автоматически будет уменьшена, если аэродинамическая скорость очень высокая или увеличена, если скорость слишком низкая и величина этих «корректирующих» изменений тяги будет пропорционально этому коэффициенту. Предустановленное значение — 0.39.

6 — Величина минимальной стабилизированной тяги, активен только в 2D режиме (THR_MIN_PARAM). Это вспомогательный параметр. Данный параметр предотвращает остановку бесколлекторного двигателя модели, не давая контроллеру уменьшить число оборотов двигателя до нуля и тем самым дав ему возможность перестать вращаться. Диапазон значений 0.0 — 1.0 соответствует диапазону тяги двигателя 0 — 20%. Предустановленное значение — 0.34 (6.4% тяги).

Выбор и программирование параметра

— Как выбрать параметр для установки значения? — Номер параметра соответствует некоторому положению рычажка тяти — минимальное значение тяги это 0 (выход) максимальное — 6. Чтобы установить значение параметра нужно перемещать рукоятку тяги по всему диапазону и найти необходимое положение — контроллер сообщит о номере параметра короткими бипами.

— Как установить и сохранить значение параметра? — Установка значения производится потенциометром канала Gain. Все параметры могут быть установлены в диапазоне 0.0 — 1.0. Если вращать потенциометр — светодиод на контроллере загорается, когда значение, установленное потенциометром параметра, становится выше «старого» значения, записанного в EEPROM.

Так же, в момент совпадения нового и старого значения, зуммер производит короткий щелчок. Таким образом можно понять, какое значение параметра уже установлено и уменьшить или увеличить его. Запись нового значения в EEPROM производится кратковременным переключением 3-позицинного переключателя вверх-вниз-вверх (X)-(2D)-(X) .

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

«Экспертный» пилотажный режим.

Для более точного подбора значения любого параметра у контроллера есть возможность «присвоить» ему потенциометр сигнала Gain и управлять им непосредственно в полете и после серии экспериментов записать EEPROM наиболее подходящее значение.

— Как включить экспертный режим и «присвоить» потенциометр параметру? Присвоение можно сделать непосредственно в режиме программирования параметров, непосредственно после записи этого параметра в EEPROM — если сразу после записи параметра в EEPROM переключить 3-х позиционный переключатель вверх-вниз-вниз еще раз (это необходимо сделать в течении 1 сек.

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

— Как записать значение «присвоенного» параметра в EEPROM? — Это не делается автоматически — нужно перейти в режим программирования параметров, выбрать положение рычажка тяги, соответствующее номеру параметра и, не трогая потенциометра, произвести запись значения параметра 3-х позиционным переключателем.

— Как завершить экспертный режим и «отключить» потенциометр от параметра? — для этого достаточно просто снова войти в меню программирования.

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

Настройка и проверка контроллера.

Итак, программа залита в контроллер. Контроллер установлен в стенд, описанный в предыдущей статье Контроллер пропеллерного датчика аэродинамической скорости на основе Arduino , передатчик включен, тяга выставлена в ноль, 3-х позиционник поднят в режим пилотирования без стабилизации (Х).

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

Проверка подсоединения стабилизатора Guardian — Переводим переключатель в 2D или 3D моду, когда гироскоп включен, — при покачивании стабилизатора сервопривод на стенде должен шевелить 'рукой'.

Калибровка — Выключить питание контроллера, поставить переключатель в среднюю позицию (3D) и включить питание — контроллер войдет в режим калибровки. Откалибровать тягу, потом откалибровать потенциометр. Переместить рычаг тяги в нижнее положение и подождать 5 сек — контроллер должен издать длинный сигнал и перейти в режим пилотажа — калибровка закончена.

Проверка работы авто-подстройки усиления гироскопа — Перевести контроллер в режим 2D пилотажа, слегка наклонить Guardian, чтобы сервопривод изменил положение 'руки' и несильно подуть в пропеллерный датчик. При вращении пропеллера, коэффициент обратной связи, поступающия на  Guardian, должен уменьшиться и сервопривод так же должен уменьшить угол отклонения 'руки' от нейтрального положения.

Проверка работы стабилизатора скорости — Перевести контроллер в 2D режим. Включить тягу, примерно 20% от максимальной мощности. Подуть в пропеллерный датчик — тяга должна заметно уменьшиться.

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

Способы устранения проблем

Правильно собранный контроллер практически не нуждается в настройке. Что же делать, если он работает не так, как написано выше? — Ниже несколько диагностических советов.

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

Если при ри включенном передатчике, светодиод на контроллере мигает с 1 сек. периодом — значит значит сработала система детектирования потери сигналов управления — с приемника не приходит хотя бы один из сигналов THR_IN, GAIN_IN, MOD_IN. Необходимо проверить работу приемника и наличие всех управляющих сигналы на входах платы Ардуино.

Если все работает, но не вращается мотор — проверить подсоединение контроллера бесколлекторного двигателя к выходному сигналу платы Ардуино GAIN_OUT.

Если контроллер не реагирует на вращение пропеллера датчика аэродинамической скорости — скорее всего не работает или неправильно подключена оптопара — проверить напряжение на ножках HOA1874-012. С помощью осциллографа посмотреть, правильно ли подано питание на ножки светодиода и поступают ли импульсы с фотодиода при вращении пропеллера датчика.

Установка контроллера в модель

Я испробовал несколько конфигураций установки контроллера на крыло HK Mini Sonic, но наиболее удачное расположение потребовало изготовления специального компартмента для приемника, как показоно на фотографии. При установке, стабилизатор Guardian и приемник крепятся к корпусу модели толстой двусторонней клейкой лентой.

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

Заключение

Зачем я написал эти несколько статей? — Я хотел поделиться опытом — нет большого смысла делать такую сложную работу только для себя. Теперь после публикации всех пяти статей, я смогу не объяснять сто раз знакомым авиамоделистам, как это устройство работает :).

— Я давно задался идеей как-то использовать платы Arduino в авиа-моделировании.

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

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

Источник: http://rc-aviation.ru/mtech/avia/1782-kontroller-arduino

Ссылка на основную публикацию