Курс arduino — отображение данных на lcd

Взаимодействие Arduino с символьным LCD дисплеем

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

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

В данной статье мы рассмотрим, как использовать LCD дисплей 16×2 совместно с Arduino. У LCD дисплея 16×2, который используется в эксперименте, всего 16 выводов.

Как показано в таблице ниже, восемь выводов являются линиями данных (выводы 7-14), два – для питания и земли (выводы 1 и 16), три вывода используются для управления работой LCD (выводы 4-6), и один используется для регулировки контрастности LCD дисплея (вывод 3). Оставшиеся два вывода (15 и 16) питают подсветку. Описание выводов LCD дисплея приведено ниже:

Назначение выводов LCD дисплея на HD44780

Номер выводаНазначение вывода
1 земля
2 +5В
3 Средний вывод потенциометра (для регулировки контрастности)
4 Выбор регистра (RS)
5 Чтение/Запись (RW)
6 Включение (EN)
7 DB0
8 DB1
9 DB2
10 DB3
11 DB4
12 DB5
13 DB6
14 DB7
15 +4.2–5 В
16 земля

Выводы LCD дисплея на HD44780

Эксперимент 1

В этом эксперименте мы подключим 16×2 LCD дисплей к Arduino Mega 2560 и отобразим на LCD какой-нибудь текст.

Необходимые комплектующие

Схема соединений

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

Подключение символьного LCD дисплея к плате Arduino

Выводы LCD дисплеяВыводы платы Arduino
DB4 4
DB5 5
DB6 6
DB7 7
RS 8
EN 9

Схема подключения LCD дисплея к Arduino Mega 2560

Код

#include «LiquidCrystal.h» // инициализировать библиотеку, указав ей выводы подключения LiquidCrystal lcd(8,9,4,5,6,7); void setup() { lcd.begin(16,2); // установить курсор в начало первой строки LCD дисплея lcd.setCursor(0,0); // напечатать текст lcd.print(» 16×2 LCD»); // установить курсор в начало следующей строки lcd.setCursor(0,1); lcd.print(» DISPLAY»); } void loop() {}

Эксперимент 2

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

Необходимые комплектующие

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

Схема соединений

Код

#include «LiquidCrystal.h» // инициализировать библиотеку, указав ей номера выводов LiquidCrystal lcd(8,9,4,5,6,7); void setup() { lcd.begin(16,2); // установить курсор в начало первой строки LCD дисплея lcd.setCursor(0,0); // напечатать текст lcd.print(» COUNTER»); delay(100); int a=0; lcd.setCursor(0,1); lcd.print(» «); lcd.print(a); while(a

Источник: https://radioprog.ru/post/157

Код программы к уроку 10. arduino и жидко кристаллический дисплей (жки)

/* * Набор для экспериментов ArduinoKit * Код программы для опыта №10: sketch 10 * * ЖИДКО КРИСТАЛЛИЧЕСКИЙ ДИСПЛЕЙ (ЖКИ) * * Написано для сайта http://arduinokit.ru * * * Помощь сообщества Arduino. * Посетите сайт http://www.arduino.cc * * Комментарий к программе написан * 22 января 2014 * специально для http://arduinokit.ru

*/

ЖИДКО КРИСТАЛЛИЧЕСКИЙ ДИСПЛЕЙ (ЖКИ)

Жидкокристаллический дисплей (ЖКИ, или по английски «Liquid Crystal Display» — LCD) представляет собой сложный электронный модуль, который может быть использован для отображения текста или числовых данных. Дисплей размещен в рамке, на печатной плате, имеет две строки по 16 символов, а также подсветку, для использования в темное время суток.

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

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

Подключение оборудования:

ЖК-модуль имеет 16-штырьковый разъем, (прилагается) припаянный к верхнему краю. Первый контакт находится ближе к углу дисплея. 16-ый контакт — ближе к центру ЖКИ. Подключите ЖК к макетной плате. Как обычно, общую шину «+» и «-» макетной платы соедините с вашей Arduino.

Подключите потенциометр 10K на свободное место на вашей макетной плате. Подключите крайнюю ножку потенциометра к +5В, а другую крайнюю к GND, не имеет значения, какой, куда. Во время опыта, вы будете использовать потенциометр для регулировки контрастности ЖК-дисплея.

Теперь соедините контакты ЖК с Arduino. Помните, что контакт 1 на ЖК-дисплее находится ближе к углу. От туда и начинайте.

1 к Земле (GND) 2 к +5V 3 к центральному пину потенциометра 4 к цифровому порту 12 Arduino 5 к Земле (GND) 6 tк цифровому порту 11 Arduino 7 (не подключен) 8 (не подключен) 9 (не подключен) 10 (не подключен) 11 к цифровому порту 5 Arduino 12 к цифровому порту 4 Arduino 13 к цифровому порту 3 Arduino 14 к цифровому порту 2 Arduino 15 к +5V

16 к Земле (GND)

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

Библиотека

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

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

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

панель очень легко поцарапать.

ЖК-дисплей имеет подсветку, которая загорается при подачи напряжения питания. Если подсветка не включается, проверьте

правильность соединений.

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

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

// Подгузка библиотеки LiquidCrystal.h, которая даст нам
// возможность взаимодействия с ЖКИ без лишних сложностей:

#include<\p>

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

// http://arduino.cc/en/Reference/LiquidCrystal

LiquidCrystal lcd(12,11,5,4,3,2);

void setup() { // Библиотека LiquidCrystal.h может использоваться с различными // типами ЖК устройств. Мы используем двухстрочный, шестнадцати // символьный ЖК индикатор. Поэтому здесь, ниже, мы информируем

// об этом Arduino, укажем ей с какой частью библиотеки работаем:

lcd.begin(16, 2); // устанавливаем кол-во столбцов и строк

// Данные отправленные на дисплей будут там оставаться, пока не // будут перезаписаны новой информацией, или до отключении питания. // Это может стать проблемой, — вы загружаете новый скетч в Arduino, // а на ЖК дисплее все еще видны данные от старой программы. Поэтому, // давайте очистим ЖК с помощью команды clear(),

// из библиотеки LiquidCrystal:

lcd.clear();

// Теперь мы будем отображать сообщения на ЖК-дисплее!

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

// этого нужно использовать дополнительные команды библиотеки.

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

lcd.print(«hello, world!»); // печать на ЖКИ сообщения

// Регулировка контрастности (ВАЖНО!)

// При запуске скетча (программы) впервые, есть шанс // что вы ничего не увидите на ЖК-дисплее. Это может произойти // потому, что контрастность еще не отрегулирована. // Не волнуйтесь, это легко исправить, и как только вы установите

// нужные параметры, больше уже менять ничего не понадобится.

// Запустите скетч, затем покрутите потенциометр, в разные стороны // пока на ЖК дисплее не появится текст «Hello, World!». // Если вы все еще не видете текст, проверить все соединения и

// убедитесь, что скетч был успешно загружен в Arduino.

}

void loop()
{

// Можно поместить невидимый курсор в любое место на ЖК дисплее // перед передачей данных. Местоположение определяется от нулевого // символа верхней строки. Верхняя строка — 0, нижняя строка — 1.

// Столбцы считаются с нулевого символа с лева, до 15-го справа.

// В дополнение к «Hello, World!»(привет, мир!) напечатанных ранее, // выведем на экран время в секундах, от последнего сброса Arduino. // Не забудьте, что данные, которые Вы отправляете на дисплей, // остаются там, пока Вы их не сотрете, командой «lcd.clear()»,

// или не отключите питание.

// Здесь мы устанавливаем невидимый курсор в первый столбец (столбец 0),
// второй строки (строка 1):

lcd.setCursor(0,1);

// Теперь выведем на экран число секунд (millis() / 1000),
// которое проработала Arduino от последнего перезапуска:

lcd.print(millis()/1000);

// ПОДСКАЗКА: Так как увеличение чисел всегда растет в длину, // (1..10..20…100….1000) то новые посланные, всегда, // будут перекрывать предыдущие. Но, если Вы решите вывести на // экран уменьшение чисел (пример — обратный отсчет), то Вы // увидите на дисплее артефакты, как бы зависшие символы, это

// происходит если новое значение короче старого.

// Чтобы этого не происходило, Вы должны сначало стереть старое, // прежде чем записать новое. Это можно сделать перезаписав последнее // число пробелами. // Если Вы сотрете старое число и сразу запишете новое, никто, даже Вы

// этого не заметит. Вот типичная последовательность кода:

// lcd.setCursor(0,1);   // устанавливаем курсор в 0-ом столбце, 1 строка // lcd.print(»       «); // стираем самое длинное число // lcd.setCursor(0,1);   // устанавливаем курсор в 0-ом столбце, 1 строка

// lcd.print(millis()/1000); // печатаем число секунд после сброса

// ДАЛЬНЕЙШИЕ ШАГИ:

// Вы узнали основы, о том как присоединить жидкокристаллический дисплей
// к Arduino, и как отправить текст или числовые данные на дисплей!

// У LCD библиотеки есть множество команд которые позволяют управлять ЖКИ: // показать, спрятать курсор, прокрутить его, прокрутить экран вверх или вниз и т. д. // для получения дополнительной информации:

// http://arduino.cc/en/Reference/LiquidCrystal

// Arduino IDE идет с множеством дополнительных библиотек, после установки // их можно найти в c:Program FilesArduinolibraries // Примеры библиотеки LiquidCrystal, с которыми вы можете «поиграть» находятся:

// c:Program FilesArduinolibrariesLiquidCrystalexamples

// Весело и с интересом проведите время, и сообщите нам о том, что у Вас получается!
// Ваши друзья — ArduinoKit.Ru.

}

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

Вывод информации на маленький LCD экран. Arduino PC2LCD

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

Читайте также:  Программы для проектирования печатных плат (pcb)

Я использовал Arduino Leonardo + LCD Keypad Shield. Но можно использовать варианты дешевле и компактнее, например, Arduino Nano + LCD 1602. Пока поддерживается только двухстрочный экранчик по 16 символов в строке.

Операционная система Linux, но в будущем, возможно, будет поддержка и Windows.

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

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

ls /dev/tty*

Затем в командной строке нужно выполнить такую команду для настройки последовательного интерфейса:

stty -F /dev/ttyACM0 cs8 115200 ignbrk -brkint -icrnl -imaxbel -opost -onlcr -isig -icanon -iexten -echo -echoe -echok -echoctl -echoke noflsh -ixon -crtscts

Здесь /dev/ttyACM0 — это адрес подключенного Arduino. У вас он может быть другим, например /dev/ttyUSB0.

Теперь можно попробовать с командной строки вывести текст на LCD экране:

echo «Hello Arduino» > /dev/ttyACM0

Пример кода для Arduino можно взять здесь: https://github.com/andchir/arduino_pc2lcd/blob/master/ino/SerialDisplay.ino.
Нужно закачать этот код в микроконтроллер через Arduino IDE.

Далее скачиваем проект https://github.com/andchir/arduino_pc2lcd в папку на своем сервере.

В командной строке переходим в папку проекта и запускаем:

cd /var/www/html/arduino_pc2lcd php -f index.php

На экранчике должна появиться информация о состоянии сервера (вашего локального компьютера). Эта информацию будет обновляться и сменяться через заданное время. Все действия, которые выводят информацию, находятся в папке «action». Там же находится конфигурационный JSON-файл — data.json. Вот его содержание:

{ «switch_delay»: 10, «actions»: [ { «name»: «ram», «active»: true, «refresh_time»: 3 }, { «name»: «hdd», «active»: true, «refresh_time»: 3 }, { «name»: «uptime», «active»: true, «refresh_time»: 3 } ] }

switch_delay — Время в секундах, через которое сменяется информация на экране.
actions — Массив со всеми действиями, которые выводят информацию.
name — Название действия и его папки.
active — Активность действия (true/false).
refresh_time — Частота обновления данных текущего действия в секундах.

В данный момент доступны 3 готовых экшена:
ram — Сколько всего оперативной памяти и сколько свободно.
hdd — Сколько всего места на диске и сколько свободно.
uptime — Сколько времени прошло после включения или перезагрузки сервера, сколько сейчас пользователей в системе и нагрузка за последние 1, 5 и 15 минут.

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

Источник: http://wdevblog.net.ru/dnevnik/programmirovanie/vyivod-informaczii-na-malenkij-lcd-ekran.-arduino-pc2lcd.html

Урок 8. Вывод на экран LCD своих символов и знаков

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

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

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

Для начала берем основу кода, для работы с LCD дисплеем:

//подключение библиотеки для работы с LCD
#include //инициализируем LCD с указанием контактов
LiquidCrystal lcd(12, 11, 10, 5, 4, 3, 2); void setup()
{
//начало работы, с указанием размерности экрана lcd.begin(16, 2); } void loop()
{ }

Описывать данный скетч мы не будем, так как подробно каждая строка рассматривается в предыдущем уроке. 

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

Добавление символов происходит с помощью создания массива, размерностью 5 на 7 (что соответствует размеру одного прямоугольника, входящего в дисплей), состоящего из бинарных чисел (0 и 1):

byte line_1[8] = { B00000, B00000, B00000, B00000, B00000, B00000, B00000,
}

Как видите, сейчас массив заполнен одними нулями. То есть ни один из пикселей прямоугольника сейчас не задействован. Чтобы сформировать символ, нужно в массив добавить единицы. Получается, что там где в массиве 0 — пиксель не включен, а где 1 — пиксель включен. 

Например вот так выглядит символ «П»:

byte line_1[8] = { B11111, B10001, B10001, B10001, B10001, B10001, B10001, };

Теперь нужно данный символ инициализировать, для этого в функции setup() пишем следующее:

lcd.createChar(1,line_1);

, где 1 — это порядковый номер, а line_1 — это имя массива байтов. 

Вот так выглядит полный код программы:

//подключение библиотеки для работы с LCD
#include //инициализируем LCD с указанием контактов
LiquidCrystal lcd(12, 11, 10, 5, 4, 3, 2); //создаем свои символы
byte line_1[8] = { B11111, B10001, B10001, B10001, B10001, B10001, B10001,
}; void setup()
{
//начало работы, с указанием размерности экрана lcd.begin(16, 2);
//инициализируем массив lcd.createChar(1,line_1);
//сдвигаем курсор на первый столбец и первую строку lcd.setCursor(0,0);
//выводим символ на экран lcd.write(1);
} void loop()
{ }

Если залить скетч в Arduino, то мы увидим букву «П», стоящую в первом столбце, первой строки. 

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

//подключение библиотеки для работы с LCD
#include //инициализируем LCD с указанием контактов
LiquidCrystal lcd(12, 11, 10, 5, 4, 3, 2); //создаем свои символы
byte line_1[8] = { B10000, B10000, B10000, B10000, B10000, B10000, B10000,
}; byte line_2[8] = { B11000, B11000, B11000, B11000, B11000, B11000, B11000,
}; byte line_3[8] = { B11100, B11100, B11100, B11100, B11100, B11100, B11100, }; byte line_4[8] = { B11110, B11110, B11110, B11110, B11110, B11110, B11110, }; byte line_5[8] = { B11111, B11111, B11111, B11111, B11111, B11111, B11111,
}; void setup()
{
//начало работы, с указанием размерности экрана lcd.begin(16, 2);
//инициализируем массивы lcd.createChar(0,line_1); lcd.createChar(1,line_2); lcd.createChar(2,line_3); lcd.createChar(3,line_4); lcd.createChar(4,line_5); //сдвигаем курсор на одну второй столбце, первой строки lcd.setCursor(1,0); //выводим сообщение lcd.print(«GM-project.com»); }

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

void loop()
{
//сдвигаем курсор на первый столбец и вторую строку lcd.setCursor(0,1);
//очищаем эту строку lcd.print(» «); //16 пробелов
//выводим на экран загрузку
for (int i = 0; i

Источник: http://gm-project.ucoz.com/publ/arduino_s_nulja/rabota_s_arduino/urok_8_vyvod_na_ehkran_lcd_svoikh_simvolov_i_znakov/5-1-0-35

Подключение жидкокристаллического дисплея к Arduino

ЖК дисплей

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

Энергопотребление при отключённой подсветке минимально а работа с дисплеем предельно проста и не требует сильного вмешательства в код программы. Фактически, вывод информации на ЖК дисплей не многим отличается от вывода в серийный порт.

В статье рассмотрено подключение знакогенерирующего дисплея на базе популярного чипа HD44780 к контроллеру Arduino.

Как работает жидкокристаллический текстовый дисплей

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

Для вывода символа на экран необходимо загрузить символ в ячейку памяти, а затем передать команду на отображение ячейки памяти. При передаче символы кодируются ASCII кодами.  Например, при записи в память кода  0×31 на дисплей будет выведен символ «1». Соответствие кода символа его отображению на экране (т.е.

«картинке» символа) хранится в памяти CGROM. CGROM не изменяемая память. Поэтому, дисплей может отображать только те символы, которые «зашиты» в контроллер. Именно поэтому не каждый дисплей способен отображать, например, русские символы. Дисплеи, продающиеся в нашем магазине, к сожалению, не русифицированы. Есть ещё CGRAM память.

Она изменяемая. Мы можем создавать собственные символы и отображать их на дисплее. Стоит учитывать, что можно создать не более восьми символов.

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

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

Если вы хотите получить дисплей сразу готовый к установке на макетку, отметьте галочку «припаять разъём» на странице товара и мы припаяем разъём для вас. Передача данных на дисплей может быть организована двумя способами: по 4 или по 8 бит за раз.

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

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

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

Выводы нумеруем слева направо:

  • 1-(VSS) Земля дисплея. Подключается к рельсе земли.
  • 2-(VDD) Питание дисплея. Подключается к рельсе питания.
  • 3-(VO) Вход потенциометра (входит в комплект). С помощью потенциометра регулируется контрастность дисплея. К выводу дисплея подключается средний выход потенциометра.
  • 4-(RS) Вход «командного» сигнала. Подключается к любому цифровому выводу Arduino. В примере подключён к выводу №12.
  • 5-(RW) Устанавливает режим «чтения» или «записи». Мы собираемся записывать. Подключаем контакт к земле.
  • 6-(E) Enable. Ещё один «командный» вывод. Когда на вывод подаётся единица, дисплей выполняет переданную ранее команду. Подключается к любому цифровому выводу. В примере подключен к выводу №11.
  • 7-10 (D0-D3) оставляем не подключёнными. Это контакты передачи данных, который используются в восьмибитном интерфейсе. Нам не нужны.
  • 11-14 (D4-D7) Контакты для передачи данных в четырёхбитном режиме. Подключаются опять таки к любым цифровым выводам. В примере подключены соответственно к 5,4,3 и 2 выводам (D4 к 5 выводу, D5 к 4 и т.д.).
  • 15 (A) Анод светодиода подсветки. Токоограничительный резистор уже установлен в дисплее, поэтому анод подключается просто к рельсе питания. Поскольку в подсветке используется самый обычный светодиод, вы можете подключить его к любому выводу, поддерживающему ШИМ и управлять яркостью подсветки программно.
  • 16 (K) Катод подсветки. Подключается к рельсе земли.

Визуальная схема подключения:

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

Программирование

Вместе с Arduino IDE поставляется прекрасная библиотека для жидкокристаллических дисплеев — LiquidCrystal. Библиотека содержит примеры, полностью раскрывающие возможности экрана. Для начала воспользуйтесь стандартным примером «HelloWorld» (Файл -> Примеры -> LiquidCrystal -> HelloWorld) или загрузите в плату следующий код:

*RS вывод дисплея к 12 выводу arduino*Enable вывод дисплея к 11 выводу arduino*D4 вывод дисплея к 5 выводу arduino*D5 вывод дисплея к 4 выводу arduino*D6 вывод дисплея к 3 выводу arduino*D7 вывод дисплея к 2 выводу arduino*R/W вывод дисплея к земле*Выход потенциометра к VO выводу дисплея// подключаем библиотеку:#include ;// Инициализируем дисплей// Перечисляем выводы arduino к которым подключены//                RS, E,  D4, D5, D6, D7 контакты дисплеяLiquidCrystal lcd(12, 11, 5,  4,  3,  2);// Указываем количество столбцов и строк дисплея:// Выводим сообщение на дисплей.lcd.print(«hello, world!»);// устанавливаем курсор в 0 (нулевой) столбец первой строки// фактически курсор установится во вторую (нижнюю) строку// нумерация строк и столбцов начинается с нуля// выводим на дисплей количество секунд,// прошедших с момента загрузки платы:lcd.print(millis()/1000);
Читайте также:  Кодовый замок на тиристорах

После загрузки этого кода в плату Arduino на экране отобразится надпись «hello, world!»(англ. «привет, Мир!») на первой строке и таймер, отсчитывающий секунды на второй строке.

https://www.youtube.com/watch?v=cCiYBnVlHfM

Как обычно и бывает, код простой и понятный. Однако, мы всё же разберём его более подробно:

  • LiquidCrystal lcd(12, 11, 5, 4, 3, 2) — эта строка создаёт объект дисплея, с которым мы будем работать в будущем. В скобках в качестве аргументов передаются номера пинов, к которым подключены контакты дисплея. Соответственно: RS, E, D4, D5, D6, D7. Как уже отмечалось выше, номера выводов при подключении можно выбирать совершенно произвольно.
  • lcd.begin(16, 2) — здесь мы настроили размеры дисплея. В данном примере 16 столбцов и 2 строки. Для нашего дисплея 20Х4 эта строчка выглядела бы так: lcd.begin(20, 4).
  • lcd.print(«hello, world!») — выводит текст на дисплей. После указания размера дисплея (lcd.begin) курсор устанавливается в левый верхний угол дисплея. Поэтому, этот текст будет выведен на первой (верхней) строке слева.
  • lcd.setCursor(0, 1) — устанавливает курсор на указанную позицию. В данном случае указана крайняя левая позиция второй строки. В скобках задаётся номер столбца, затем номер строки. И строки и столбцы нумеруются с нулевой позиции. Таким образом: lcd.setCursor(0, 0) — установит курсор в левый верхний угол, lcd.setCursor(15, 0) — правый нижний.
  • lcd.print(millis()/1000) — уже описано выше. Здесь вместо текста в качестве параметра передаётся формула для вычисления. Результат выводится на экран.

Теперь, когда мы разобрались с простейшим примером, можно перейти к примерам посложнее. А если вы уже всё поняли и готовы купить ЖК дисплей, то я собрал для вас ссылки на проверенных мной китайских продавцов дисплеев:

Символьные ЖК дисплеи

Размер дисплея (столбцы*строки)Цвет подстветкиСтатус
20*4 Синий проверено
20*4 Жёлтый проверено
16*2 Синий проверено
16*2 Жёлтый проверено
16*2 Зелёный проверено

Обзор других примеров библиотеки LiquidCrystal

В стандартных примерах, поставляющихся вместе с библиотекой LiquidCrystal можно найти следующие скетчи:

    • Autoscroll — демонстрирует возможность прокрутки текста в автоматическом режиме. Некое подобие бегущей строки. При выводе символа предыдущие символы сдвигаются. Таким образом, новый символ выводится на одном и том же месте.
    • Blink — демонстрирует возможность включить отображение мигающего курсора в виде прямоугольника.
    • Cursor — демонстрирует возможность включить отображение курсора в виде мигающей горизонтальной черты.
    • CustomCharacter — показана возможность создания собственных символов для отображения их на дисплее. Кстати, в этом скетче ошибка. Подробности ниже.
    • Display — показывает способ «выключать» дисплей. То есть показывать или скрывать выведенный текст.
    • Scroll — демонстрирует возможность прокрутки текста в ручном режиме.
    • SerialDisplay — отображает на экране текст, напечатанный в окне монитора порта (т.е. текст, передающийся через серийный порт).
    • setCursor — заполняет дисплей буквами, демонстрируя возможность установки курсора в любую позицию экрана.
    • TextDirection — демонстрирует возможность изменять направление вывода текста (с права налево или слева направо).

Рассмотрим более подробно процедуры, возможности которых демонстрируют эти примеры:

lcd.autoscroll()

После вызова этой процедуры, текст на экране будет автоматически прокручиваться. Для остановки прокрутки, следует вызвать lcd.noAutoscroll().

lcd.blink()

После вызова процедуры курсор примет вид мигающего прямоугольника. Для отключения следует вызвать lcd.noBlink(). Курсор снова станет невидимым.

lcd.cursor()

После вызова процедуры курсор примет вид мигающей горизонтальной черты. Для отключения следует вызвать lcd.noСursor(). Курсор снова станет невидимым.

lcd.createChar()

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

  1. Создать байтовый массив, описывающий символ.
  2. Записать символ в память дисплея, присвоив ему номер в таблице символов. Символы нумеруются в диапазоне от нуля до семи.
  3. Вывести символ на экран с помощью процедуры lcd.write() (не путать с lcd.print() ), в качесте аргумента которой передать номер символа.

Баг среды разработки и особенности библиотеки вылились в невозможность вывести на экран символ под номером 0 (ноль). Компилятор повстречав строку lcd.write(0) выдаст ошибку: «call of overloaded ‘write(int)’ is ambiguous«. Именно такая строка встречается в примере CustomCharacter библиотеки. При попытке скомпилировать стандартный пример, вы получите ошибку:

CustomCharacter.ino: In function ‘void setup()’:CustomCharacter:115: error: call of overloaded ‘write(int)’ is ambiguous/home/nazarovd/arduino-1.0.5/libraries/LiquidCrystal/LiquidCrystal.h:82: note: candidates are: virtual size_t LiquidCrystal::write(uint8_t)/home/nazarovd/arduino-1.0.5/hardware/arduino/cores/arduino/Print.h:49: note:                 size_t Print::write(const char*)

Для устранения ошибки достаточно изменить строку lcd.write() на lcd.write((byte)0).
Теперь небольшой пример по созданию своего символа. Давайте выведем на дисплей символ рубля.

#include ;// Инициализируем дисплейLiquidCrystal lcd(12, 11, 5, 4, 3, 2);// Описываем свой символ.// Просто «рисуем» символ единицами// Единицы при выводе на экран окажутся закрашенными точками, нули — не закрашенными  // записываем свой символ в память экрана  // аргументами передаём номер символа  // и байтовый массив, описывающий наш символ  // устанавливаем курсор в левый верхний угод экрана  // выводим символ с номером ноль на экран  // ничего не делаем 10 секунд

Символ рубля отображается на экране

lcd.noDisplay()

«Выключает» дисплей. На самом деле, просто скрывает выведенные на экран символы. Вызов процедуры lcd.display() «включает» дисплей. Все символы снова отображаются. Обратите внимание: не происходит очистки дисплея. Символы именно перестают отображаться.

lcd.scrollDisplayLeft(); lcd.scrollDisplayRight();

Позволяют прокручивать длинные строки текста в ручном (управляемом) режиме. lcd.scrollDisplayLeft() прокручивает строку на один символ влево, lcd.scrollDisplayRight() прокручивает строку на один символ вправо.

lcd.rightToLeft(); lcd.leftToRight();

Устанавливает направление отображения текста. lcd.rightToLeft() устанавливает режим отображения справа на лево, lcd.leftToRight() заставляет текст отображаться слева направо.

lcd.clear()

Очищает экран.

Напоминаю, заказать дисплей у проверенных мной продавцов можно по ссылкам в этой таблице:

Символьные ЖК дисплеи

Размер дисплея (столбцы*строки)Цвет подстветкиСтатус
20*4 Синий проверено
20*4 Жёлтый проверено
16*2 Синий проверено
16*2 Жёлтый проверено
16*2 Зелёный проверено

А ещё я собираю большой список проверенных продавцов. Ознакомиться можно здесь.

Источник: https://uscr.ru/podklyuchenie-zhidkokristallicheskogo-displeya-k-arduino/

Курс Arduino — Отображение данных на LCD

Куда вывести данные?

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

Сегодня нам понадобятся

  • LCD дисплей
  • Светодиодная шкала , 7-сегментный индикатор и Светодиод.
  • Потенциометр
  • Резисторы на 220 Ом
  • Соединительные провода  «Папа-Папа»

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

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

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

А теперь заставим наше устройство работать.

#define POT A0
#define FIRST 2 //Первый пин на шкале.
#define NUM 10 //Это количество пинов на шкале. void setup() { //Чтобы не описывать каждый пин по отдельности, создадим цикл со счетчиком //Здесь пропишем общее количество пинов шкалы. for (int i = 0; i < NUM; ++i) //Каждый из пинов шкалы обозначим как выход. pinMode(i + FIRST, OUTPUT); } void loop() { //Определим уровень сигнала для включения светодиода int val = analogRead(POT) / 93; //Создадим цикл для выведения значения на шкалу. for( int i = 0; i < NUM; ++i) { //Определим, какой светодиод зажигать. boolean Segment = (val > 0 + i); digitalWrite(i + FIRST, Segment); }
}

Пояснения

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

Boolean Segment  С помощью этой логической переменной мы определили условие, при котором включается следующий сегмент.

 LCD

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

Код

#include //Подключим библиотеку для дисплея.
//Покажем, к каким выводам мы подключили дисплей
LiquidCrystal lcd(13, 12, 11, 10, 9 ,8); #define POT A5
#define LED 7
void setup() { lcd.begin(16, 2); //Сообщаем кол-во строк и столбцов. lcd.print («Command's name:»); //В первую строку выводим сообщение. pinMode(LED, OUTPUT); } void loop() { int val = analogRead(POT); val = map(val, 0, 1023, 0, 4); //Ставим курсор на 1 строку, колонку 0. //Это соответствует левому квадрату 2-й строки. lcd.setCursor(0, 1); //Выводим сообщения параллельно с выполнением задач. if( val == 1) { //Если не поставить пробелы, последняя буква f при переключении потенциометра // не будет стираться. lcd.print («Led on «); digitalWrite(LED, HIGH); } else if(val == 2) { lcd.print («Led off»); digitalWrite(LED, LOW); } else if(val ==3) { lcd.print («Blink «); for( int i = 0; i < 3; i++) { digitalWrite(LED, HIGH); delay(600); digitalWrite(LED, LOW); delay(600); } } }

Пояснения

LiquidCrystal     О том, почему подключать LCD экран именно так, читай здесь.

Lcd.begin(x; y)   Эта функция сообщает LiquidCrystal, сколько строк(x) и столбцов(y) у нашего экрана.

Lcd.print   Эта функция печатает сообщение на экран.

Lcd.setCursor(x, y)  Эта функция ставит курсор на 1 строку в колонку 0.Это левый квадрат 2-й строки, т.к. нумерация начинается с нуля.

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

7-сегментный индикатор

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

Внимание на схему.

Код

#define FIRST 2
#define COUNT 7
#define POT A5 //Создадим массив в который пропишем кодировки выводимых чисел.
byte Segments[10] = { 0b00111111, 0b00001010, 0b01011101, 0b01011110, 0b01101010, 0b01110110, 0b01110111, 0b00011010, 0b01111111, 0b01111110,
}; void setup()
{ for (int i = 0; i < COUNT; ++i) pinMode(i + FIRST, OUTPUT); } void loop() { // определяем число, которое собираемся отображать. int number = analogRead(POT) / 103; // получаем код, в котором зашифрована арабская цифра int value = Segments[number]; // для каждого из 7 сегментов индикатора определяем: должен ли он быть включён. for (int i = 0; i < COUNT; ++i) { // Для этого считываем бит (англ. read bit), соответствующий текущему // сегменту «i». Истина — он установлен (1), ложь — нет (0) boolean Segment = bitRead(value, i); // включаем/выключаем сегмент на основе полученного значения digitalWrite(i + FIRST, Segment); } }

Читайте также:  Команда исследователей создала тонкие, эффективные и гибкие фотоэлементы

Пояснения

Byte – Тип данных byte позволяет сохранить до 1 байта данных. С помощью этого типа данных мы описывали цифры, выводимые на 7-сегментном индикаторе. Часть 0b говорит, что используется двоичная система счисления.

Массивы – Массив – это набор однотипных данных. Есть два типа массивов. Массив переменных и массив символов. В нашем коде мы создали массив, в котором прописали кодировки чисел. Потом мы просто брали нужную кодировку и выводили на экран.

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

Вывод

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

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

Скачать список элементов (PDF)

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

  • LCD.ino (1 Кб)
  • Segment.ino (1 Кб)
  • led.ino (1 Кб)

Источник: http://cxem.gq/arduino/arduino187.php

Arduino для начинающих. Урок 10. Подключение матричной клавиатуры и интересные схемы

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

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

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

Матричная клавиатура для Arduino

Для чего нужна матричная клавиатура?

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

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

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

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

Схема подключения матричной клавиатуры к Arduino

Подключать ее к плате следует 8 выводами, каждый из них считывает значения с определенных строк и столбцов. Подключать их следует к выводам на панели Digital. Я подключу, например, к выводам от 2 до 9 включительно. Нулевой и первый трогать не желательно, поскольку они предназначены для UART интерфейса (например, для подключения блютуз-модуля). Рациональнее оставить их свободными.

Схема подключения матричной клавиатуры к Arduino

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

После того, как вы установили в библиотеку, можно зайти в Ардуино IDE (программа с сайта Arduino) и посмотреть примеры скетчей.

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

#include // подключаем нашу библиотеку const byte ROWS = 4; //число строк у нашей клавиатуры const byte COLS = 4; //число столбцов у нашей клавиатуры char hexaKeys[ROWS][COLS] = { {'1','4','7','*'}, // здесь мы располагаем названия наших клавиш, как на клавиатуре,для удобства пользования {'2','5','8','0'}, {'3','6','9','#'}, {'A','B','C','D'} }; byte rowPins[ROWS] = {5, 4, 3, 2}; //к каким выводам подключаем управление строками byte colPins[COLS] = {9, 8, 7, 6}; //к каким выводам подключаем управление столбцами //initialize an instance of class NewKeypad Keypad customKeypad = Keypad( makeKeymap(hexaKeys), rowPins, colPins, ROWS, COLS); void setup(){ Serial.begin(9600); } void loop(){ char customKey = customKeypad.getKey(); if (customKey){ Serial.println(customKey); } }
Скетч очень простой. Стоит отметить первые строчки кода. Сначала подключаем библиотеку, затем указываем сколько строк и столбцов у клавиатуры, а потом нужно правильно расположить названия клавиш, чтобы было удобнее работать.

Если это сделать неправильно, то, например, при нажатии цифры 4, в порт выйдет цифра 6 или любой другой символ. Это можно определить опытным путем и расположить символы, как они расположены на клавиатуре.

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

В функции void setup указываем скорость последовательного соединения с монитором порта 9600 бод. Функция нужна только для подачи питания на модули. В функции Void Loop прописываем условие. Переменная Char используется для хранения только одного символа, например, 1, А или 5, что подходит к ситуации.

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

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

Схема с дисплеем и матричной клавиатурой

Давайте выведем данные на дисплей.

Схема подключения сопряженного с модулем I2C дисплея к Arduino

Я использую дисплей, сопряженный с модулем 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[ROWS][COLS] = { {'S','4','7','*'}, // здесь мы располагаем названия наших клавиш, как на клавиатуре,для удобства пользования {'O','5','8','0'}, {'S','6','9','#'}, {'I','B','C','D'} }; byte rowPins[ROWS] = {5, 4, 3, 2}; //к каким выводам подключаем управление строками byte colPins[COLS] = {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 и управляющее действие

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

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

Подключение светодиода

Я буду использовать макетную плату и резистор (желательно использовать от 150 до 220 Ом). Двумя перемычками замкну схему, подключив их к пинам питания и земли на плате Ардуино.

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

Светодиод в примере подключен к пину 8 на плате Ардуино.

#include  const byte ROWS = 4; // Four rows const byte COLS = 4; // Three columns char keys[ROWS][COLS] = { // Define the Keymap {'1','4','7','*'}, // здесь мы располагаем названия наших клавиш, как на клавиатуре,для удобства пользования {'2','5','8','0'}, {'3','6','9','#'}, {'A','B','C','D'} }; byte rowPins[ROWS] = { 5, 4, 3, 2 };// Connect keypad ROW0, ROW1, ROW2 and ROW3 to these Arduino pins. byte colPins[COLS] = { 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 указываем сигнал со светодиода как выход.

Подключение клавиатуры к Arduino и управление светодиодом

Если бы не библиотека Кейпад для клавиатуры, пришлось бы прописывать то же самое для 8 пинов, с которыми связана клавиатура. В функции void loop условие. Нажатие определенной клавиши «приравнивается» к значению переменной key.

 Оператор Switch сравнивает значения переменной key и «дает» определенные команды в зависимости от этого значения. Состоит он из двух вспомогательных операторов Case и Break. Проще говоря, если будет найдено значение переменной, равное 1 , то будет выполняться действие.

Оператор break служит командой выхода из оператора Case.

Соответственно при нажатии на 1 будет выполняться максимальная подача напряжения на светодиод и он будет гореть. При нажатии на 2 он гореть не будет.

Это указывается в функции Digitat write, где в скобках задается название переменной и «указание» ей.

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

Источник: http://edurobots.ru/2017/03/arduino-keypad/

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