Обычная кнопочная клавиатура для ардуино. Arduino и матричная клавиатура. Гайд по использованию мембранной клавиатуры с Arduino
Эта статья посвящена матричной клавиатуре. Я расскажу об устройстве клавиатуры, её возможностях. И, конечно, статья содержит программный код с подробными пояснениями.
Собственно матричная клавиатурка.
Схема.
Все предельно просто. Если ни одна из кнопок не нажата, то между вертикальными линиями (1, 2, 3, 4) и горизонтальными линиями (5, 6, 7, 8) нет контакта. Нажатие кнопочки приводит к возникновению контакта между одной из вертикальных линий (1, 2, 3, 4) и одной из горизонтальных линий (5, 6, 7, 8). Например, нажатие кнопки S1 приводит к возникновению контакта между линиями 4 и 5.
Впрочем, никто не запрещает подключать эту клавиатурку к контроллеру через резисторы ом в 500. Это поспособствует защите контроллера от ошибок при подключении, а также программных ошибок.
Как работать с этой клавиатурой? Самая первая мысль, что приходит в голову, заключается в том, чтобы сконфигурировать выводы ардуино к которым подключены линии 1, 2, 3 и 4 как вход с включенным подтягивающим резистором. А выводы ардуино к которым подключены линии 5, 6, 7 и 8 сконфигурировать как выход и установить на них логический ноль. Пока ни одна из кнопок не нажата, на выводах ардуино связанных с линиями 1, 2, 3 и 4 будет логическая единица. Если кнопку нажать, то на одном из выводов ардуино связанном с линией 1, 2, 3 или 4 установится логический ноль. Но с любой из этих линий связано сразу четыре кнопки. Чтобы узнать какая конкретно кнопка нажата нужно изменить настройки. Выводы ардуино к которым подключены линии 1, 2, 3 и 4 следует сконфигурировать как выход и установить на них логический ноль. А выводы ардуино к которым подключены линии 5, 6, 7 и 8 необходимо сконфигурировать как вход с включенным подтягивающим резистором. Теперь логический ноль будет на одном из выводов ардуино связанном с линией 5, 6, 7 или 8. С каждой из этих линий также связано сразу четыре кнопки. Однако у каждой из линий 5, 6, 7 и 8 есть лишь одна общая кнопка с каждой из линий 1, 2, 3 и 4. Кнопка, которая нажата, находится на пересечении линий на которых читается логический ноль при первом и при втором варианте настроек.
Для наглядности опишу как это все будет работать при нажатии кнопки S2. Выводы ардуино к которым подключены линии 1, 2, 3 и 4 сконфигурированы как вход с включенным подтягивающим резистором. Выводы ардуино к которым подключены линии 5, 6, 7 и 8 сконфигурированы как выход и на них установлен логический ноль. На выводах ардуино связанных с линиями 1, 2 и 4 будет читаться логическая единица. На выводе ардуино связанном с линией 3 будет читаться логический ноль. Такое возможно при нажатии одной из кнопок S2, S6, S10 и S14. Теперь настройки меняются. Выводы ардуино к которым подключены линии 1, 2, 3 и 4 сконфигурированы как выход и на них установлен логический ноль. Выводы ардуино к которым подключены линии 5, 6, 7 и 8 сконфигурированы как вход с включенным подтягивающим резистором. На выводах ардуино связанных с линиями 6, 7 и 8 будет читаться логическая единица. На выводе ардуино связанном с линией 5 будет читаться логический ноль. Такое возможно при нажатии одной из кнопок S1, S2, S3 или S4. У линий 3 и 5 есть лишь одна общая кнопка. Это кнопка S2. Нажатая кнопка находится на пересечении линий 3 и 5.
Программа.
////////////////////////
//
// Arduino Uno
//
////////////////////////
//
// Sketch: Matrix Keyboard
//
// Keyboard --- Arduino Uno
//
// 1 --- D11
// 2 --- D10
// 3 --- D9
// 4 --- D8
// 5 --- A0 (D14)
// 6 --- A1 (D15)
// 7 --- A2 (D16)
// 8 --- A3 (D17)
#include
Результат работы программы можно наблюдать в мониторе порта Arduino IDE.
Основным недостатком описанного алгоритма является некорректная работа при одновременном нажатии нескольких кнопок. Здесь нужно сказать, что есть алгоритм для матричной клавиатуры позволяющий корректно обрабатывать одновременное нажатие двух кнопок. Но про него я расскажу как нибудь позже.
«. Сегодня подключаем матричную клавиатуру к плате Arduino, а также рассматриваем интересные схемы с ней. Сделать такую клавиатуру можно и самому из кнопок и печатной платы. В статье видео-инструкция, листинги программ, схемы подключения и необходимые компоненты.
Большая часть текста содержит объяснение программного кода, его можно скачать либо посмотреть видео под статьей.
Сделать такую клавиатуру можно и самому. Для этого понадобится печатная плата, 12 или 16 обычных кнопок и соединительные провода. Я же буду использовать готовую.
Для чего нужна матричная клавиатура?
Для примера возьмем обычную кнопку. Как вы знаете, это простейшее электромеханическое устройство. Чтобы подключить ее к плате, нужно использовать стягивающий резистор, а также задействовать по одному контакту питания и «земли». Нажатием такой кнопки можно выполнить определенное действие, например можно управлять светодиодом, различными приводами, механизмами и так далее. А что, если нам необходимо подключить несколько кнопок? Тогда придется задействовать больше контактов и большее число проводов, да и без макетной платы уже не обойтись, плюс еще резисторы придется использовать в большем количестве.
Для этого и придумали такую клавиатуру, чтобы упростить подключение большего числа кнопок. Такие устройства встречаются везде — в клавиатурах компьютеров, калькуляторах и так далее.
Подключать ее к плате следует 8 выводами, каждый из них считывает значения с определенных строк и столбцов. Подключать их следует к выводам на панели Digital. Я подключу, например, к выводам от 2 до 9 включительно. Нулевой и первый трогать не желательно, поскольку они предназначены для UART интерфейса (например, для подключения блютуз-модуля). Рациональнее оставить их свободными.
Так выглядит самая простая схема с использованием клавиатуры. Для более удобной работы с ней была написана библиотека Кейпад. Скачать ее, а также другие скетчи можно .
После того, как вы установили в библиотеку, можно зайти в Ардуино IDE (программа с сайта Arduino) и посмотреть примеры скетчей.
Возьмем самый простой скетч для ознакомления. Он позволяет считывать значение с клавиатуры при нажатии определенной клавиши и выводить их в порт. В данном случае это монитор порта на компьютере.
#include
{"2","5","8","0"},
{"3","6","9","#"},
{"A","B","C","D"}
};
void setup(){
Serial.begin(9600);
}
void loop(){
if (customKey){
Serial.println(customKey);
}
}
Скетч очень простой. Стоит отметить первые строчки кода. Сначала подключаем библиотеку, затем указываем сколько строк и столбцов у клавиатуры, а потом нужно правильно расположить названия клавиш, чтобы было удобнее работать.
Если это сделать неправильно, то, например, при нажатии цифры 4, в порт выйдет цифра 6 или любой другой символ. Это можно определить опытным путем и расположить символы, как они расположены на клавиатуре.
В функции void setup указываем скорость последовательного соединения с монитором порта 9600 бод . Функция нужна только для подачи питания на модули. В функции Void Loop прописываем условие. Переменная Char используется для хранения только одного символа, например, 1, А или 5, что подходит к ситуации. Если нажатие зафиксировано, то происходит вывод символа в монитор порта с помощью функции Serial Print. В скобках нужно указывать, какую переменную выводим в порт. Если все сделано верно, в мониторе порта получим символ, на который нажимали. Не забудьте в мониторе порта внизу справа указать скорость передачи данных такую же, как в скетче.
Схема с дисплеем и матричной клавиатурой
Давайте выведем данные на дисплей.
Я использую дисплей, сопряженный с модулем I2C, который упрощает подключение. Для работы с дисплеем с шиной I2C необходимо установить еще одну библиотеку. Скачать ее можно .
Далее нужно указать размерность дисплея. Используемый в примере дисплей вмещает по 16 символов в каждой из 2-ух строк, это я и указываю. В функции Void Setup нужно подать питание на дисплей и включить подсветку. Делается это с помощью двух функций: lcd.begin и lcd.backlight .
#include
#include
LiquidCrystal_I2C lcd(0x27, 16, 2);
const byte ROWS = 4; //число строк у нашей клавиатуры
const byte COLS = 4; //число столбцов у нашей клавиатуры
char hexaKeys = {
{"S","4","7","*"}, // здесь мы располагаем названия наших клавиш, как на клавиатуре,для удобства пользования
{"O","5","8","0"},
{"S","6","9","#"},
{"I","B","C","D"}
};
byte rowPins = {5, 4, 3, 2}; //к каким выводам подключаем управление строками
byte colPins = {9, 8, 7, 6}; //к каким выводам подключаем управление столбцами
//initialize an instance of class NewKeypad
Keypad customKeypad = Keypad(makeKeymap(hexaKeys), rowPins, colPins, ROWS, COLS);
void setup(){
Serial.begin(9600);
lcd.begin(); // Инициализируем экран
lcd.backlight();
}
void loop(){
char customKey = customKeypad.getKey();
if (customKey){
Serial.println(customKey);
lcd.setCursor(1,4); //устанавливаем курсор
lcd.print(customKey);
}
}
В функции Voil Loop нужно в самом условии прописать строчку lcd.print для вывода данных на дисплей. И еще нужно предварительно установить положение курсора. В скобках идут 2 цифры: первая — это номер символа, а вторая — номер строки. Нужно помнить, что у этого дисплея отсчет строк и столбцов начинается не с единицы, а с нуля. То есть здесь имеются строчки под номерами 0 и 1, а не 1 и 2, как может показаться сначала. Затем загрузим код в плату и посмотрим, что будет.
Так как дисплей работает по интерфейсу I2C, подключаем к аналоговым выводам. Выходы SDA и SCL соответственно подключаем к А4 и А5, а остальные два — это уже питание и «земля».
Как видим, нажимая на любой символ, видим его отображение на дисплее.
Чтобы стереть строчку, вспомним калькулятор. Когда нужно было удалить значение, мы нажимали на кнопку сброса. Нажмем на такую кнопку в плате и можем заново набирать символы.
Подключение клавиатуры к Arduino и управляющее действие
Последняя схема в уроке — выполнение заданного действия при нажатии определенной клавиши. Это основная цель подключения матричной клавиатуры к Arduino. По этой теме будут две отдельные статьи и видео, описывающие более сложные и интересные схемы. А сейчас знакомимся с этим модулем и запоминаем построение кода с его использованием.
Попробуем при нажатии определенной клавиши включать или выключать светодиод. Добавляем его в схему.
Подключение светодиода
Я буду использовать макетную плату и резистор (желательно использовать от 150 до 220 Ом). Двумя перемычками замкну схему, подключив их к пинам питания и земли на плате Ардуино.
Схема будет работать так: при нажатии на 1 включается светодиод, при нажатии на 2 — выключается.
Светодиод в примере подключен к пину 8 на плате Ардуино.
#include
const byte ROWS = 4; // Four rows
const byte COLS = 4; // Three columns
char keys = { // Define the Keymap
{"1","4","7","*"}, // здесь мы располагаем названия наших клавиш, как на клавиатуре,для удобства пользования
{"2","5","8","0"},
{"3","6","9","#"},
{"A","B","C","D"}
};
byte rowPins = { 5, 4, 3, 2 };// Connect keypad ROW0, ROW1, ROW2 and ROW3 to these Arduino pins.
byte colPins = { 9, 8, 7 ,6}; // Connect keypad COL0, COL1 and COL2 to these Arduino pins.
Keypad kpd = Keypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS);// Create the Keypad
#define ledpin 8
void setup()
{
pinMode(ledpin,OUTPUT);
Serial.begin(9600);
}
void loop()
{
char key = kpd.getKey();
if(key) // Check for a valid key.
{
switch (key)
{
case "1":
digitalWrite(ledpin, HIGH);
break;
case "2":
digitalWrite(ledpin, LOW);
break;
}
}
}
Давайте разберем скетч.
Возьмем первый скетч урока и просто его дополним. В начале с помощью полезной функции Define присвоим название подключенному к пину 8 светодиоду ledpin . В функции Void setup указываем сигнал со светодиода как выход.
Если бы не библиотека Кейпад для клавиатуры, пришлось бы прописывать то же самое для 8 пинов, с которыми связана клавиатура. В функции void loop условие. Нажатие определенной клавиши «приравнивается» к значению переменной key. Оператор Switch сравнивает значения переменной key и «дает» определенные команды в зависимости от этого значения. Состоит он из двух вспомогательных операторов Case и Break . Проще говоря, если будет найдено значение переменной, равное 1 , то будет выполняться действие. Оператор break служит командой выхода из оператора Case .
Соответственно при нажатии на 1 будет выполняться максимальная подача напряжения на светодиод и он будет гореть. При нажатии на 2 он гореть не будет. Это указывается в функции Digitat write , где в скобках задается название переменной и «указание» ей. Можно таким образом написать определенные команды для каждой кнопки и управлять большим количеством светодиодов или создать команду для включения всех светодиодов сразу.
Существует большое количество различных мастер-китов для тех или иных микроконтроллеров. Однако в Arduino придумали модель мастер-кита с практически нулевым порогом вхождения. Достаточно ввести три строки кода и ты уже мигаешь светодиодом или управляешь двигателем. Но по мере обростания макетной платы всякими датчиками, дисплеем и кнопочками начинаешь понимать, что не хватает более расширенного метода ввода - клавиатуры. Не дорогой и мобильный вариант описан под катом.
Часть первая - теоретическая
Есть много методов подключения клавиатуры к Arduino:- обычные матричные клавиатуры которые цепляются напрямую к портам (Keypad Tutorial). Недостаток - занимает много портов ввода/вывода, мало кнопок.
- матричные клавиатуры подключенные через I2C (I2C Port expander and Keypads). Достоинства - занимает всего два вывода, позволяет использовать несколько устройств на той же шине. Недостатки - нужно включать в проект библиотеку для работы с I2C, мало кнопок
- обычная PS/2 клавиатура (PS2 Keyboard). Достоинства - большая аппаратная база, куча кнопок на любой вкус, занимает мало выводов. Недостатки - нужна библиотека для преобразования скан-кодов, размер - PS/2 клавиатуры не отличаются мобильными размерами
Конкретно эта модель CHA-01 рассчитана питание 5 вольт и представляется телефону… модемом!
Есть еще модель CHA-10, которая используется с более новыми (если так можно сказать про аппараты пяти- семилетнего возраста) телефонами и работает от 3.3 вольт. Обе модели не сложно приобрести на EBay за ~$12 с доставкой.
Можно ограничится немодифицированной версией клавиатуры. Поискать разъем от старого телефона для подключения. Разработать библиотеку, которая будет парсить ввод от клавиатуры, и радоваться жизни.
Однако радоваться долго не получится - большой оверхед протокола (нажатие клавиши 0 вызывает, например, "AT*EKSE=0", а www - "AT*EAPP=0,5,«WWW: »,«WWW»") и включение ввода только после нажатия кнопки SMS не придают удобства использованию.
Выход - сделать на основе этой клавиатуры нечто свое, которое будет работать как необходимо нам и с возможностью изменять поведение если понадобится.
Часть вторая - практическая
Поиск на просторах интернета выдал следующую страницу , которую я использовал в качестве основы для своей переделки. Самым ценной информацией от туда было что микроконтроллер в клавиатуре и Atmel Mega162 совпадают по выводам и последним можно заменить встроенный.
Внутри клавиатура представляет собой стандартную матричную размером 7х7 и занимает 14 выводов микроконтроллера. Наружу информация выдается через UART.
Взяв за основу приведенную информацию строим план перевоплощения:
- заменить микроконтроллер на mega162 ($3 на рынке)
- заменить разъем на «распространенный»
- добавить возможность изменять ПО когда захочется (благо это реализуемо через бутлоадер)
- настроить нормальную IDE для работы с AVR/Arduino (чтобы избавится от ненужного здесь C++/библиотек)
- написать простое ПО для проверки работоспособности (проверка настройки IDE и ознакомление с Си для AVR)
Вооружившись паяльной станцией снимаем ненужные компоненты:
Распиновку оригинального разъема для CHA-01 можно найти :
1, 5 - Vcc +5 Вольт
2 - Chatboard serial out
3 - GND
4 - Chatboard serial in
Припаиваем наши запчасти:
В отличии от автора вышеприведенной статьи, я выбрал в качестве разъема стандартную линейку PBS-08 - она отлично помещается в корпус без напильника и даже ложится на нужные места на плате. И решил не переключаться на внешний резонатор.
В разъем были выведены RX, TX, GND, Vcc, MOSI, MISO, SCK и RST. Таким образом мы сможем в дальнейшем перепрограммировать устройство без извлечения из корпуса.
Кажется что все готово и можно подключать к программатору (я брал попользоваться USBASP, но можно использовать и ардуину для программирования других AVR - ArduinoISP)
Но avrdude напрочь отказывается видеть микроконтроллер. Так как до этого, опыта подобных переделок у меня не было - пришлось обратится к более опытным товарищам для диагностики. За дело взялась тяжелая артиллерия с осцилографом и генератором. После непродолжительных боев я был послан… RTFM.
Оказывается USBASP работает с быстрыми микроконтроллерами (более 4МГц), а mega162 по-умолчанию включает «делитель на 8» и работает от внутреннего генератора на частоте 1МГц. Так как частоты 1МГц для клавиатуры более чем достаточно (да и потребление меньше), я решил ее не менять а искать выходы из ситуации. Выход нашелся очень быстро - у USBASP есть джампер, который понижает «частоту общения» с микроконтроллером (или есть опция -B у avrdude, которая делает это программно, мне помогло -B 3).
Теперь, когда avrdude видит кристалл, казалось бы, следует перепрошить и забыть:) Но опыт первого RTFM меня немного остудил и я решил сначала прогнать ПО на эмуляторе (как оказалось не зря). Для этого, на Протеусе опытных товарищей, была собрана схема клавиатуры. И написана прошивка, которая опрашивала клавиатуру и выводила необходимый символ в UART. И так, все скомпилировано, загружено в эмулятор, параметры виртуального терминала выставлены в 9600,8n1. Но терминал почему-то показывает мусор при нажатии клавиши. Дебаг режим USART в эмуляторе показал что скорость обмена выставляется в 10200 а не в 9600… Опять RTFM - Baud rate зависит от частоты кристалла и при 1МГц стандартная настройка позволяет достичь скорости 4800 (при ошибке 0.2%), тогда как при скорости 9600 ошибка уже составляет 7%! В даташите также приведена таблица ошибок для различных Baudrate/MHz - откуда видно, что на частоте в 1МГц можно достичь ошибки в 0.2% только настройкой Double-rate USART. На Си это выглядит вот так:
#define F_CPU 1000000UL
#define BAUD_RATE 9600UL
// Init serial
UBRR0L = (uint8_t)(F_CPU/(BAUD_RATE*8L)-1);
UBRR0H = ((F_CPU/(BAUD_RATE*8L)-1) >> 8);
UCSR0A = _BV(U2X0); // Set double-speed, for low freq cpu
UCSR0B = _BV(TXEN0)|_BV(RXEN0); // Enable TX, Enable RX
UCSR0C = _BV(URSEL0)|_BV(UCSZ00)|_BV(UCSZ01); // 8n1 async
Ура, наш код отлично работает в эмуляторе - показывает все нажатия, отрабатывает нажатие Shift и тп.
Переходим к заливке ПО в клавиатуру. Бутлоадер взял с первой ссылки (stk500boot.zip). Так как он тоже работает через USART - изменил в исходниках инициализацию и скорость на 9600.
Заливается бутлоадер через USBASP следующей коммандой:
avrdude -c usbasp -p m162 -B 3 -U flash:w:stk500boot.hex:i -U hfuse:w:0x98:m
Изменение hfuse необходимо для изменения reset-vector - чтобы загрузка микроконтроллера начиналась с бутлоадера.
Дальнейшее общение с клавиатурой можно осуществлять через UART, и USBASP нам не понадобится.
Я выбрал USB-UART (Serial) конвертер на основе FTDI - так как на таком же чипе построена сама ардуина, соответственно драйвера в системе у меня уже стоят.
По случайному стечению обстоятельств разъем конвертера и моей клавиатуры идеально подошли друг другу, поэтому подключил напрямую:
Несмотря на заявление что данный бутлоадер STK500 совместимый - avrdude не захотел с ним работать через тип программатора stk500v1 - ругался что неверный ID устройства. По исходникам было видно что бутлоадер умеет читать и отдавать ID устройства, поэтому методом перебора я нашел что оно прекрасно работает если указать тип arduino.
Команда для заливки прошивки через UART:
avrdude -c arduino -p m162 -b 9600 -P /dev/tty.usbserial-00001004 -U flash:w:chatboard.hex:i
Проверка через терминал показала что нажимаются далеко не все кнопки, да и главная фича бутлоадера, переходить в режим апдейта ПО по нажатию кнопки Yes, тоже не работает. Перепрошить клавиатуру через UART стало невозможным. Более детальное исследование показало что не работает три колонки кнопок из матрицы 7х7. Все снова уперлось в RTFM… три вывода используемые нами для опроса клавиатуры имеют также альтернативную функцию (JTAG) включенную по-умолчанию. Выключив JTAG (переписать hfuse на 0xD8) получаем полностью работоспособную клавиатуру:
Время подключать к Arduino. В качестве интерфейсного разъема я выбрал нестандартный miniUSB, чтобы не воткнуть случайно что-то неподходящее. Донором для провода послужила старая мышка (откуда еще можно вынуть энкодер). Подключение к клавиатуре - стандартным штырьковым разъемом.
Переходник miniUSB - UART был собран для распиновки UART на SensorShield (на моей макетке пока нет стандартизированного вывода для UART).
Итоги
- Клавиатура достаточно маленькая чтобы таскать ее с собой в кармане.
- Опрос клавиатуры по UART позволяет работать с ней без каких-либо внешних библиотек (экономит место во флеше)
- Использование UART позволит в дальнейшем подключить клавиатуру без проводов через Bluetooth-serial или XBee-serial
PPS. Исходники и прошивку можно взять здесь:
Гайд по использованию мембранной клавиатуры с Arduino
Еще одним устройством, при помощи которого можно взаимодействовать с микроконтроллером Arduino , является клавиатура. Такую клавиатуру можно достать, к примеру, разобрав старый телефон или просто купив в магазине электротехники.
Клавиатуры бывают разных форм и размеров. Самые распространенные – это с расположением кнопок 3х4 или 4х4 . В продаже есть также клавиатуры с кнопками не только для цифр, но также для букв и даже слов.
Описание
Такие клавиатуры очень популярны среди тех, кто занимается проектами на базе Arduino . Они очень дешевые, и их можно использовать вместе с любым микроконтроллером.
Где купить?
Купить клавиатуру можно на eBay (к примеру, ), и она обойдется вам всего в пару долларов.
Как это работает?
Мембранная клавиатура – это матрица, состоящая из кнопок, расположенных рядами и столбцами. Таким образом, каждая кнопка находится в каком-нибудь столбце или ряду (см. картинку ниже). 12 -кнопочная клавиатура состоит из 4 рядов и 3 столбцов. Цифра «1» стоит на перекрестии 1 ряда и 1 столбца (Р1С1 ), «2» – это Р1С2 , «3» – Р1С3 , «звездочка» – Р4С1 , «9» – Р3С3 и т.д.
Необходимые компоненты
Для нашего проекта понадобятся следующие компоненты:
- Одна плата Arduino (см. на eBay)
- Одна мембранная клавиатура (см. на eBay)
- Провода-перемычки
Схема
Подсоедините эти компоненты друг к другу как показано на картинке ниже. Если ваша клавиатура выглядит по-другому, то подключите ее согласно информации из ее даташита (его можно найти в сети или спросить у продавца).
Установка библиотеки
Для нашего проекта понадобится библиотека «Keypad». Чтобы установить ее, выполните следующее:
- Загрузите отсюда ZIP -архив с библиотекой.
- Распакуйте ZIP -архив.
- Установите библиотеку в IDE Arduino, переместив распакованную папку в папку «libraries» IDE Arduino .
- Перезапустите IDE Arduino .
Если ваша клавиатура не работает с кодом ниже, то ее нужно подключить не так, как на картинке выше, а в соответствии с даташитом. Даташит можно найти в сети или спросить у продавца, у которого вы купили свою клавиатуру.
Примечание: Если у вашей клавиатуры другое количество клавиш, вам нужно будет поменять значения во 3-ей и 4-ой строчках кода. Кроме того, после этого нужно будет поменять значения в массиве, который расположен на строчках с 5-ой по 10-ую .
const byte ROWS = 4 ; // количество рядов
const byte COLS = 3 ; // количество столбцов
char keys[ ROWS] [ COLS] = {
{ "1" , "2" , "3" } ,
{ "4" , "5" , "6" } ,
{ "7" , "8" , "9" } ,
{ "#" , "0" , "*" }
byte rowPins[ ROWS] = { 8 , 7 , 6 , 5 } ; // контакты для рядов:
// R1 = D8, R2 = D7,
// R3 = D6, R4 = D5
byte colPins[ COLS] = { 4 , 3 , 2 } ; // контакты для столбцов:
#include "Keypad.h"
Клавиатуры позволяют пользователям вводить данные во время выполнения программы. Данная статья показывает вам, как подключить к Arduino 12-кнопочную клавиатуру, и как использовать библиотеку Keypad.h.
Клавиатура часто требуется для обеспечения ввода данных в систему на Arduino, и мембранные клавиатуры являются экономичным решением для многих приложений. Они довольно тонкие и могут быть легко установлены везде, где они необходимы.
В данной статье мы покажем, как использовать 12-кнопочную цифровую клавиатуру, похожую на ту, что вы можете увидеть на телефоне. 12-кнопочная клавиатура имеет три столбца и четыре строки. Нажатие кнопки замыкает вывод одной из строк с выводом одного из столбцов. Из этой информации Arduino может определить, какая кнопка была нажата. Например, когда нажата кнопка 1, замкнуты столбец 1 и строка 1. Arduino определит это и введет в программу 1.
На рисунке ниже показано, как внутри клавиатуры расположены строки и столбцы.
Эксперимент
В данном эксперименте мы продемонстрируем работу с библиотекой " keypad.h " для Arduino. Когда пользователь нажимает на кнопку на клавиатуре, программа отображает соответствующее значение в мониторе последовательного порта.
Необходимые комплектующие
- перемычки (необязательно);
- макетная плата (необязательно).
Схема соединений
Подключите клавиатуру к плате Arduino, как показано на рисунке ниже.
Код
/* Пример кода для руководства по работе с матричной клавиатурой 3x4 совместно с платой Arduino. Данный код выводит значение нажатой на клавиатуре кнопки в монитор последовательного порта. */ #include "Keypad.h" const byte Rows= 4; // количество строк на клавиатуре, 4 const byte Cols= 3; // количество столбцов на клавиатуре, 3 // определяем массив символов соответствующий распределению кнопок на клавиатуре: char keymap= { {"1", "2", "3"}, {"4", "5", "6"}, {"7", "8", "9"}, {"*", "0", "#"} }; // соединения клавиатуры с выводами Arduino задаются так: byte rPins= {A6,A5,A4,A3}; // строки с 0 по 3 byte cPins= {A2,A1,A0}; // столбцы с 0 по 2 // команда для библиотеки клавиатуры // инициализирует экземпляр класса Keypad Keypad kpd= Keypad(makeKeymap(keymap), rPins, cPins, Rows, Cols); void setup() { Serial.begin(9600); // инициализация монитора последовательного порта } // Если кнопка нажата, эта кнопка сохраняется в переменной keypressed. // Если keypressed не равна NO_KEY, то выводим значение в последовательный порт. void loop() { char keypressed = kpd.getKey(); if (keypressed != NO_KEY) { Serial.println(keypressed); } }Заключение
Это очень простой пример, но я думаю, вы смогли увидеть, как легко получить в программе на Arduino данные ввода с клавиатуры. Вы можете использовать этот тип ввода во многих различных проектах, в том числе.