Урок 2 – нажатие кнопки

STM32F4. Урок 2 – нажатие кнопки

На плате STM32F4Discovery установлена кнопка, которую может использовать пользователь. С помощью библиотеки, описанной в статье, можно опрашивать состояние кнопки. Расширяя таблицу в файле «stm32_ub_button.

c» (речь идет о BUTTON_t BUTTON[] – примечание переводчика) можно опрашивать состояние нескольких кнопок. В библиотеке версии 1.1 в файле «stm32_ub_button.h», может быть включена функция защиты от дребезга контактов, которая использует таймер.

В библиотеке используются функции “OnPressed”, “OnClick” и “OnReleased” которые возвращают “true”, когда происходит событие.

Пользовательская кнопка подключена к выводу PA0.

Требования:

Подключаемые модули CooCox-IDE : GPIO, (TIM, MISC).
Поддерживаемые библиотеки: отсутствуют.

Перечисления:

typedef enum { BTN_USER = 0 // BTN1 на STM32F4-Discovery
}BUTTON_NAME_t; typedef enum { BTN_RELEASED = 0, // Кнопка не нажата BTN_PRESSED // Кнопка нажата
}BUTTON_STATUS_t;

Функции:

void UB_Button_Init(void); // Инициализация кнопок
BUTTON_STATUS_t UB_Button_Read(BUTTON_NAME_t btn_name); // Считать состояние кнопки (без фильтрации дребезга)
bool UB_Button_OnPressed(BUTTON_NAME_t btn_name); // “True”, при нажатии кнопки (защита от дребезга)
bool UB_Button_OnClick(BUTTON_NAME_t btn_name); // “True”, при кратковременном нажатии (защита от дребезга)
bool UB_Button_OnRelease(BUTTON_NAME_t btn_name); // “True”, при отпускании кнопки (защита от дребезга)

Пример использования:

//————————————————————–
// File : main.c
// Date : 07.10.2013
// Version : 1.1
// Author : UB
// EMail : mc-4u(@)t-online.de
// Web : www.mikrocontroller-4u.de
// CPU : STM32F4
// IDE : CooCox CoIDE 1.7.0
// Module : CMSIS_BOOT, M4_CMSIS_CORE
// Function : Demo of Button Library
// Reference: These two files must be written to 8MHz
// “cmsis_boot/stm32f4xx.h”
// “cmsis_boot/system_stm32f4xx.c”
//————————————————————– #include “main.h”
#include “stm32_ub_button.h”
#include “stm32_ub_led.h” int main(void)
{ SystemInit(); // Инициализация настроек кварца UB_Button_Init(); // Инициализация кнопок UB_Led_Init(); // Инициализация светодиодов UB_Led_On(LED_GREEN); // Включение зеленого светодиода while(1) { // Проверка нажатия кнопок if(UB_Button_Read(BTN_USER)==BTN_PRESSED) { UB_Led_On(LED_RED); // Включение красного светодиода } else { UB_Led_Off(LED_RED); // Выключение красного светодиода } // Проверка отпускания кнопки if(UB_Button_OnClick(BTN_USER)==true) { UB_Led_Toggle(LED_BLUE); // Переключение синего светодиод } }
}

Режим работы:

Зеленый светодиод горит постоянно. Красный светодиод горит, пока не будет нажата кнопка.

Синий светодиод переключается при нажатии кнопки.

Библиотека, использованная в примере: stm32_ub_button, stm32_ub_led.

Увеличение числа кнопок:

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

В файле «stm32_ub_button.h» все кнопки должны быть перечислены в списке “BUTTON_NAME_t” и “BUTTON_ANZ” изменено в соответствии с количеством кнопок.
В файле «stm32_ub_button.h» в “BUTTON_t” для всех кнопок необходимо указать порты и номера выводов.

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

Оригинал статьи

Прикрепленные файлы:

ub_stm32f4_button_v101_rus.rar (6 Кб)
Demo_02_Button_rus.rar (202 Кб)

Rough

Источник: http://cxem.net/mc/mc294.php

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/

Урок 9. Обработчики событий на примере Button

Подробности 22 августа 2011

В этом уроке мы:

– научимся обрабатывать нажатие кнопки и узнаем, что такое обработчик

Создадим проект:

Project name: P0091_OnClickButtons
Build Target: Android 2.3.3
Application name: OnClickButtons
Package name: ru.startandroid.develop.onclickbuttons
Create Activity: MainActivity

В layout-файл main.xml напишем следующее и сохраним:

У нас есть TextView с текстом и две кнопки: OK и Cancel. Мы сделаем так, чтобы по нажатию кнопки менялось содержимое TextView. По нажатию кнопки OK – будем выводить текст: «Нажата кнопка ОК», по нажатию Cancel – «Нажата кнопка Cancel».

Открываем MainActivity.java. Описание объектов вынесем за пределы метода onCreate. Это сделано для того, чтобы мы могли из любого метода обращаться к ним. В onCreate мы эти объекты заполним с помощью уже пройденного нами метода findViewById. В итоге должен получиться такой код:

Обновляем секцию import (CTRL+SHIFT+O). Объекты tvOut, btnOk и btnCancel соответствуют View-элементам экрана и мы можем с ними работать. Нам надо научить кнопку реагировать на нажатие.

Для этого у кнопки есть метод setOnClickListener (View.OnClickListener l). На вход подается объект с интерфейсом View.OnClickListener. Именно этому объекту кнопка поручит обрабатывать нажатия. Давайте создадим такой объект.

Код продолжаем писать в onCreate:

OnClickListener oclBtnOk = new OnClickListener() { @Override public void onClick(View v) { // TODO Auto-generated method stub } };

Eclipse подчеркивает OnClickListener красной линией

т.к. пока не знает его. Необходимо обновить секцию import. Жмем CTRL+SHIFT+O, Eclipse показывает нам, что он знает два интерфейса с именем onClickListener и предлагает выбрать. Нам нужен View.OnClickListener, т.к. метод кнопки setOnClickListener принимает на вход именно его.

Итак, мы создали объект oclBtnOk, который реализует интерфейс View.OnClickListener. Объект содержит метод onClick – это как раз то, что нам нужно. Именно этот метод будет вызван при нажатии кнопки. Мы решили, что по нажатию будем выводить текст: «Нажата кнопка ОК» в TextView (tvOut). Реализуем это.

В методе onClick пишем:

tvOut.setText(“Нажата кнопка ОК”);

Обработчик нажатия готов. Осталось «скормить» его кнопке с помощью метода setOnClickListener.

btnOk.setOnClickListener(oclBtnOk);

В итоге должен получится такой код:

public class MainActivity extends Activity { TextView tvOut; Button btnOk; Button btnCancel; /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); // найдем View-элементы tvOut = (TextView) findViewById(R.id.tvOut); btnOk = (Button) findViewById(R.id.btnOk); btnCancel = (Button) findViewById(R.id.btnCancel); // создаем обработчик нажатия OnClickListener oclBtnOk = new OnClickListener() { @Override public void onClick(View v) { // Меняем текст в TextView (tvOut) tvOut.setText(“Нажата кнопка ОК”); } }; // присвоим обработчик кнопке OK (btnOk) btnOk.setOnClickListener(oclBtnOk); } }

Все сохраняем и запускаем. Жмем на кнопку ОК и видим. Что текст изменился

Нажатие на Cancel пока ни к чему не приводит, т.к. для нее мы обработчик не создали и не присвоили. Давайте сделаем это аналогично, как для кнопки OK. Сначала мы создаем обработчик:

OnClickListener oclBtnCancel = new OnClickListener() { @Override public void onClick(View v) { // Меняем текст в TextView (tvOut) tvOut.setText(“Нажата кнопка Cancel”); } };

Потом присваиваем его кнопке:

btnCancel.setOnClickListener(oclBtnCancel);

Сохраняем, запускаем, проверяем. Обе кнопки теперь умеют обрабатывать нажатия.

Давайте еще раз проговорим механизм обработки событий на примере нажатия кнопки. Сама кнопка обрабатывать нажатия не умеет, ей нужен обработчик (его также называют слушателем – listener), который присваивается с помощью метода setOnClickListener. Когда на кнопку нажимают, обработчик реагирует и выполняет код из метода onClick. Это можно изобразить так:

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

– создаем обработчик- заполняем метод onClick- присваиваем обработчик кнопке

и система обработки событий готова.

На следующем уроке:

– научимся использовать один обработчик для нескольких View-элементов
– научим Activity выступать в качестве обработчика

Присоединяйтесь к нам в Telegram:

– в канале StartAndroid публикуются ссылки на новые статьи с сайта startandroid.ru и интересные материалы с хабра, medium.com и т.п.

– в чатах решаем возникающие вопросы и проблемы по различным темам: Android, Kotlin, RxJava, Dagger, Тестирование

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

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

Источник: https://startandroid.ru/ru/uroki/vse-uroki-spiskom/16-urok-9-obrabotchiki-sobytij-na-primere-button.html

Arduino Урок 2 – Подключаем кнопку и светодиод Опубликовано HelioSun в 06.09.2017

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

Подключение кнопки

Сперва подключим кнопку к Arduino через любой доступный порт (pin). Можно использовать как аналоговый, так и цифровой порт. Для этого подадим на вход нашей кнопки 5 вольт, а выход соединим с портом Arduino, пусть это будет порт #2.

Так же, следует понимать, когда кнопка не нажата, связь между портами “5V” и “2” будет разомкнута. Из-за этого Arduino не сможет корректнто считывать информацию из порта “2”, так как этот pin будет висеть в воздухе. Решается эта проблема очень просто.

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

Таким образом, при нажатии на кнопку на порт “2” будет поступать 5 вольт напряжения, а когда не нажата порт будет соединён с землёй.

Добавляем светодиод

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

Катод светодиода (короткая ножка) подключаем на землю через разъём “GND”. Но не забываем про резистор, так как 5 вольт для одного светодиода слишком много и светодиод может перегореть.

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

Цветовая характеристика светодиода	Напряжение
Инфракрасный	до 1.9 В
Красный	от 1.6 до 2.03 В
Оранжевый	от 2.03 до 2.1 В
Желтый	от 2.1 до 2.2 В
Зелёный	от 2.2 до 3.5 В
Синий	от 2.5 до 3.7 В
Фиолетовый	от 2.8 до 4 В
Ультрафиолетовый	от 3.1 до 4.4 В
Белый	от 3 до 3.7 В

Рассчитать необходимое сопротивление резистора можно по следующей формуле:
R=(Uист-Uд)/Iд, где Uист – напряжение источника питания, Uд – напряжение диода, Iд – ток диода (обычный светодиод потребляет около 20 миллиампер).

Пишем программу

Наша схема готова, осталось написать программу. Запускаем Arduino IDE и вставляем следующий код:

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) { // подаем 5 вольт на порт наешго светодиода digitalWrite(ledPin, HIGH); } else { // выключаем светодиод digitalWrite(ledPin, LOW); } }

Подключаем нашу Arduino и перепрошиваем её через меню «Скетч → Загрузка» или нажав на комбинацию Control+U. Дожидаемся сообщения «Загрузка завершена».

Проверка работы устройства

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

Обсудить статью на форуме

Источник: https://heliosun.com.ua/arduino-urok-2-podklyuchaem-knopku-i-svetodiod/

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

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

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

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

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

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

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

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

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

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

В наших проектах мы будем работать с очень простыми тактовыми кнопками с 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);
}

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

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

Определяем, нажата ли кнопка.
Если кнопка не нажата, то просто выходим из метода loop, ничего не включая и не меняя.
Если кнопка нажата, то выполняем мигание, используя фрагмент стандартного скетча:
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/

Код программы к уроку 5. arduino и кнопки

/* * Набор для экспериментов ArduinoKit * Код программы для опыта №5: sketch 05 * * КНОПКИ * * Написано для сайта http://arduinokit.ru * * * Помощь сообщества Arduino. * Посетите сайт http://www.arduino.cc * * Комментарий к программе написан * 22 января 2014 * специально для http://arduinokit.ru

КНОПКИ.

Использование кнопок на цифровых входах.

Ранее мы использовали аналоговые порты (пины) для ввода данных, теперь же мы посмотрим в действии и цифровые порты. Поскольку цифровые порты знают только о двух уровнях сигналов — высоких «+5» и низких «0», они идеально подходят для взаимодействия с кнопками и переключателями, которые тоже имеют только два положения — «Вкл» и «Выкл».

Мы будем подключать один контакт кнопки проводом к заземлению, а другой контакт к цифровому порту. Когда Вы надавите на кнопку, произойдет замыкание цепи и земленой конец «-» присоединится к цифровому порту, а следовательно, полученный сигнал, Arduino будет считать как «низкий».

Но подождите — что происходит, когда кнопка не нажата? В этом состоянии, порт отключен от всего, т.е висит в воздухе, и это не понятное состояние мы называем «неопределенным», или плавующим.

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

В зависимости от различных условий окружающей среды это может быть воспринято ей и как HIGH («ВЫСОКИЙ» +5 Вольт), и как LOW («НИЗКИЙ» — логический ноль).

Чтобы не возникало никакий разночтений, и микроконтроллер точно знал что в данный момент у него на входе, мы дополнительно соединим порт Arduino через ограничивающий резистор (подойдет любой с номиналом от 1КОм — 10KОм) с шиной +5 Вольт. Эта «подтяжка» будет гарантировать наличие постоянного ВЫСОКОГО +5V сигнала, а при нажатии, на кнопку цепь замкнется на Землю — «0», а значит для ардуино, сигнал на входе изменится с HIGH, на LOW, т.е. с ВЫСОКОГО +5V, на НИЗКИЙ «0».

(Дополнительно: Когда вы привыкнете к резисторами, и будете знать когда они необходимы, вы сможете активировать внутренние резисторы подтяжки, находящиеся в самом процессоре ATmega. Для информации смотрите http://arduino.cc/en/Tutorial/DigitalPins).

Подсоединение оборудования:

Кнопки:

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

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

Самый простой способ подключить кнопку — подключить провода к клеммам — наискосок (по диагонали).

Подключите любой контакт кнопки 1 к земле (GND).
Подключите другой контакт кнопки к цифровому порту 2.

Подключите любой контакт кнопки 2 к земле (GND).
Подключите другой контакт кнопки к цифровому порту 3.

На ножки кнопок идущие к цифровым портам 2,3, подключите «подтягивающие» резисторы по 10Kом (коричневый/черный/красный), а вторые выводы этих резисторов подключите к общему «-» (GND).

Эти резисторы гарантируют, что на входе будет либо +5V (кнопка не нажата), либо «0», при нажатии, и не чего другого.

(И не забывайте, что в отличии от аналоговых входов у цифровых всего два состояния ВЫСОКОЕ и НИЗКИЙ.)

Светодиод:

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

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

Подсоедините положительный вывод светодиода к цифровому порту Arduino №13 Подсоедините отрицательный вывод светодиода к резистору 330 Ом.

Подсоедините другой вывод резистора к GND «-«.

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

// обращаться к порту по имени.

const int button1Pin = 2; // кнопка №1 — порт 2 const int button2Pin = 3; // кнопка №2 — порт 3

const int ledPin = 13; // порт 13, для светодиода

void setup() { // Установим порты кнопок как входящие: pinMode(button1Pin, INPUT);

pinMode(button2Pin, INPUT);

// Установим порт светодиода как исходящий: pinMode(ledPin, OUTPUT);

}

void loop() {

int button1State, button2State; // переменные для сохранения состояния кнопок

// Поскольку кнопки имеют только два состояния (нажаты и не нажаты) мы будем // работать с ними используя цифровые порты ввода. Для того чтобы считывать // информацию мы воспользуемся функцией digitalRead(). Эта функция позволяет // получить один параметр с цифрового порта и возвратить либо HIGH (+5V),

// либо LOW («0»).

// Здесь мы читаем текущее состояние кнопок и помещаем их значение
// в две переменные:

button1State = digitalRead(button1Pin);
button2State = digitalRead(button2Pin);

// Вспомните, если кнопка нажата, то порт будет соединен с массой («-«).
// Если кнопка не нажата, порт, через подтягивающий резистор будет подключен к +5 вольт.

// Таким образом, состояние порта будет LOW (низким), когда кнопка нажата,
// и HIGH (высоким), когда она не нажата.

// Теперь мы будем использовать состояние портов чтобы контролировать светодиод.

// Что мы хотим сделать, условие: // «Если какая-либо кнопка нажата, загорается светодиод», // «Но, если окажутся нажатыми обе кнопки, светодиод не загорится»

// Давайте переведем это в программный код.

// У Arduino есть специальные логические операторы, и операторы сравнения,
// которые часто используются при проверке условий, в частности:

// «==» (равенство) — Истинно, если обе стороны являются одинаковыми // Пример: // if (x == y) { // тело условия

//}

// «&&» (логическое И) — Истинно только при выполнении обоих условий // Пример: // Истинно, если оба выражения Истинно (true) // if (x > 0 && x < 5) { // тело условия

//}

// «!» (логическое НЕ) // Истинно если оператор ложен (false) // Пример: //if (!x) { // тело условия

//}

// «||» (логическое ИЛИ) — Истинно, если хотя бы одно из условий выполняется // Пример: //if (x > 0 || y > 0) { // тело условия

// }

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

// (Не забудьте, НИЗКИЙ (LOW), означает что кнопка нажата)

// «Если одна из кнопок нажата, светодиод светится» // получится:

// if ((button1State == LOW) || (button2State == LOW)) // зажечь светодиод

// «Если обе кнопки нажатые, светодиод не загорается» // получится:

// if ((button1State == LOW) && (button2State == LOW)) // не зажигать светодиод

// Теперь давайте используем вышеуказанные функции и объединим их в одной инструкции:

if (((button1State == LOW) || (button2State == LOW)) // сравниваем, нажата ли одна из кнопок && ! // и если нет ((button1State == LOW) && (button2State == LOW))) // сравниваем, нажаты ли обе кнопки // тогда… { digitalWrite(ledPin, HIGH); // включаем светодиод } else // в противном случае { digitalWrite(ledPin, LOW); // выключаем светодиод

}

// Как вы могли заметить, операторы могут быть объединены
// для решения комплексных задачь

// Не забудьте: Нельзя использовать оператор «=» при сравнении значений вместо // «==», потому что оператор «=» присваивает значение переменным!

}

В следующей статье мы опубликуем код к уроку №5 в виде архива.

Источник: http://arduinokit.ru/arduino/lessons-arduino/buttons-sketch.html

Урок 5. Клавиатура, назначение клавиш и описание

14:42 Людмила Главная страница » Компьютер для начинающих Просмотров: 14044

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

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

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

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

Функциональные клавиши (F1-F12) — используются для выполнения специальных задач. Если повторно нажать на ту же клавишу, то действие отменяется. Клавиша F1 — вызывает справку той программы, в которой вы находитесь в данный момент;
Алфавитно-цифровые – это клавиши с буквами, цифрами, знаками препинания и символами.
Управляющие клавиши — К ним относятся клавиши HOME, END, PAGE UP, PAGE DOWN, DELETE и INSERT.
Клавиши управления курсором – используются для перемещения курсора по документам, веб-страницам, редактирования текста и т.п. Клавиши управления (модификаторы) (Ctrl, Alt, Caps Lock, Win, Fn) – используются в различных комбинациях и по отдельности.
Цифровые клавиши – для быстрого ввода чисел.
Клавиши редактирования – Backspace, Delete.

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

Назначение клавиш клавиатуры

Каждая клавиша выполняет определенное действие:

Клавиша «пробел»— самая длинная клавиша на клавиатуре. Находится в самом низу по середине. Помимо своей основной функции, делатьпробел между словами, она ещё и удаляет «выделенный» объект.
Esc— отменяет последнее действие (закрывает ненужные окна).
Print Screen—делает «снимок» экрана. Этот снимок экрана можно вставить в Word или Paint. Такая фотография экрана называется «скриншот». А так же эта клавиша выводит на печать содержимое экрана.
Scroll Lock— служит, для прокрутки информации вверх-вниз, но не на всех компьютерах эта кнопка работает.
Pause/Break—приостанавливает действующий компьютерный процесс, но тоже – работает не на всех компьютерах.
Insert— служит для того, чтобы печатать текст поверх уже напечатанного. Если нажмете на эту клавишу, то новый текст будет печататься стирая старый. Чтобы отменить это действие, необходимо снова нажать на клавишу Insert.
Delete(на клавиатуре часто обозначена сокращенно Del)— удаление. Удаляет знаки, находящиеся с правой стороны мигающего курсора. Удаляет «выделенные» объекты (строки текста, папки, файлы).
Home— переход на начало заполненной строки.
End— переход на конец заполненной строки.
Page Up — перелистывает страницу вперёд.
Page Down— перелистывает страницу назад.
Backspase— удаляет знаки, находящиеся слева от мигающего курсора во время печатания текста. И возвращает на предыдущую страницу в браузерах и в окнах «Проводника», заменяя стрелочку «назад», в верхнем левом углу.
Tab— табуляция фиксирует курсор в определённом месте строки.
Caps Lock— переключатель заглавных и прописных букв.
Shift— кратковременное нажатие этой клавиши – даёт заглавную букву. Для того, чтобы напечатать заглавную, надо сначала нажать клавишу Shift и удерживая её нажать нужную букву. Клавишу Shift можно нажимать и справа, и слева, как вам удобнее.
Alt— чтобы перейти на противоположный язык (с английского на русский и наоборот) – надо нажать клавишу Alt и не отпуская её клавишу Shift. Нажатие и удержание клавиши AltGr (правый Alt) используется для перехода на второй уровень клавиатуры.
Ctrl— справа и слева. Открывает дополнительные возможности программ.
Nut Look– включает дополнительную цифровую клавиатуру.
Enter— клавиша ввода информации, подтверждает команду «да», или переход на следующую строку. • Клавиши управления курсором — (вверх), (вниз), (вправо),(влево). С помощью этих стрелок можно передвигаться не только по тексту, который вы печатаете, но и по открытым страницам сайтов и программ.

«Горячие» клавиши

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

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

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

Сочетания клавиш

Обычно такие комбинации обозначаются со знаком + (плюс). Например, Win + E. Это значит, что сначала вы должны нажать клавишу Win, а потом клавишу Е.

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

Самые необходимые действия на клавиатуре

Для того, чтобы переключиться на другой язык, необходимо нажать одновременно клавишу Shift + Alt или Shift + Ctrl.
Для того, чтобы напечатать большую (заглавную) букву, необходимо удерживать клавишу Shift и нажать на нужную букву.
Чтобы весь текст печатать только большими буквами, нажмите клавишу Caps Lock и отпустите. А чтобы опять перейти на маленькие буквы, нажмите эту клавишу еще раз.
Для того, чтобы напечатать запятую, необходимо нажать клавишу Shift и клавишу с запятой. Они обычно находятся рядом, справа.
Точка в английской раскладке находится рядом, слева от точки русской раскладки.
Чтобы быстро вызвать меню Пуск, можно нажать клавишу Win. На ней обычно нарисован значок окошка (логотип Windows).
Клавиша Fn предназначена для ноутбука. Если нажать ее и любую из клавиш F1-F10, то можно включить или отключить дополнительные функции. Обычно на клавишах F1-F10 нарисован маленький значок, который показывает, что именно эта клавиша делает.

Пока этих знаний о клавиатуре для вас достаточно. Найдите каждую клавишу на своей клавиатуре и попробуйте ее в действии.

Предыдущие уроки:

Главная

Источник: https://moydrygpk.ru/kompyuter-dlya-nachinayushih/urok-5-klaviatura-naznachenie-klavish-i-opisanie.html

Урок 5. Клавиатуры и кнопки · Telegram бот на Python 3 и aiogram

В сегодняшнем уроке мы разберём шаблоны сообщений и инлайн-клавиатуры и научимся применять встроенные в aiogram методы для составления сложных клавиатур.

Для начала стоит понять, в чем основное различие ReplyKeyboardMarkup и InlineKeyboardMarkup:

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

Такая клавиатура показывается вместо основной и не привязана ни к какому сообщению.

В кнопки такой клавиатуры нельзя заложить никакой информации, нельзя запрограммировать для неё подобный если пользователь нажимает кнопку с текстом «abc» отправить текст «qwerty» алгоритм, отправлено будет только то, что написано на кнопке (есть два исключения, о которых ниже).

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

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

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

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

Переходим к коду

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

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

from aiogram.types import ReplyKeyboardRemove, ReplyKeyboardMarkup, KeyboardButton, InlineKeyboardMarkup, InlineKeyboardButton button_hi = KeyboardButton('Привет!

Источник: https://surik00.gitbooks.io/aiogram-lessons/content/chapter5.html