Сегодня попробуем остановиться на выводе на текстовый дисплей. Наиболее популярным является чип HD44780 (или совместимый с ним KS0066). Перечислим их плюсы и минусы:

Плюсы:

1. Невысокая цена.
2. Простота программирования, код будет одинаков для любой модели.
3. Многообразие моделей – наиболее распространённые: 8×1, 16×2, 20×4. Также можно встретить довольно экзотические модели 40×4, т.е. четыре строки по 40 символов в каждой.
4. Возможность подключить несколько дисплеев к одной Arduino.
5. Возможность задавать собственные символы.

Минусы:

1. Далеко не все дисплеи поддерживают русские символы. Подробнее надо смотреть в описании к конкретному дисплею.
2. Подключение без использования I2C-шины требует использования 10-16 проводов, что очень плохо. с I2C – 4 провода.

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

Давайте попробуем.

Что нам понадобится.

1. Arduino (Я взял модель Nano)
2. Дисплей на чипе HD44780 с модулем I2C или без него (тогда понадобится отдельно плата LC1602 IIC) – в нашем случае 16×2 без I2C модуля
3. Резистор на 10Ком (Если нужно ручное управление подсветкой).
4. Потенциометр (Если нужно ручное управление подсветкой).
5. Макетная плата Breadboard.
6. Библиотека LiquidCrystal_I2C.

Небольшое отступление №1: Как отличить дисплей с I2C-модулем?

На самом деле все довольно просто. Если, перевернув дисплей мы видим длинную колодку разъемов (как правило 16 штук) то модуля I2C на дисплее нет:

А вот так выглядит дисплей с уже установленным I2C-модулем:

Контакты SCL, SDA, VCC, GND используются для подключения Arduino. Два контакта слева – на картинке они замкнуты перемычкой – нужны для работы подсветки.

Если модуль не подключен – придется сделать это самостоятельно. Главное, на что стоит обратить внимание – соединить контакты в правильном порядке. Как правило первый и 16 пины помечены. Иногда бывает, что 15-16 контакты, через которые осуществляется управление подсветкой, могут располагаться перед первым (в этом случае они будут пронумерованы). На самом же модуле первый пин также может быть обозначен не цифрой, а квадратом вокруг самого пина.

Схемы:

Соберем следующую схему:

Обращу внимание на следующие моменты:

1. Если вам попался дисплей с уже припаянным I2C-модулем, то провода, помеченные серым, не понадобятся. В остальном – ничего не меняется.
2. Если мы не хотим менять яркость дисплея – то схема упростится:

как заметили, два пина на I2C-модуле с маркировкой LED отвечают за подсветку дисплея. Если не хотим использовать управление яркостью – их просто можно замкнуть.

Теперь давайте разберем код.

Тут почти все нам должно быть знакомо. В строке 5 указываем адрес устройства. В строках 16 и 17 – количество символов в строке и количество строк. В строках 20-22 – Создаем объект для работы с дисплеем и описываем параметр работы с ним.

Небольшое отступление №2: Как узнать адрес I2C-устройства?

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

Тут мы видим функцию, которая, собственно, и будет заниматься выводом на дисплей. Принцип вывода примерно такой:

– Задаём позицию начала вывода функцией setCursor()

– Печатаем строку функцией print()

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

Таким образом у нас на экране в первой строке появится надпись “Test LCD1602”, а во второй будет указано разрешение дисплея и счетчик, показывающий, сколько циклов отработал наш скетч.

Но, если нам надо будет выводить много значений переменных на экран, этот метод не совсем удобен. Дело в том, что процедура вывода на дисплей – очень энергоёмкая и медленная, а вывод мы делаем в этой функции аж 7 раз. Гораздо проще будет заранее сформировать строку заранее, а затем вывести её целиком. В этом нам поможет функция форматированного ввода sprintf().

Небольшое отступление №3: Функция форматированного ввода sprintf().

В Языке C существует несколько очень удобных функций для вывода строк – они называются функциями форматированного вывода – printf (от слов print и format). В нашем конкретном случае нас интересует функция sprintf, которая не выводит ничего на экран, а формирует строку для последующего вывода. Выглядит она примерно так:

sprintf (str , “Строка %d для вывода “, i );

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

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

Что же такое шаблоны? Любой шаблон начинается символом “%” и заканчивается одним из десяти (в случае Arduino – семи) символов типа. Между ними может быть указано довольно много информации о том, как выводить значение, а может быть не указано и ничего.

Давайте разберем что же может быть в шаблоне. В общем случае шаблон имеет такой вид:

%[флаг ][ширина ][.точность ]типа

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

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

Символ	Значение
c	Один символ
s	Строка символов
d,i	Целое десятичное со знаком
o	Целое восьмеричное
u	Целое десятичное без знака
x, X	Целое шестнадцатеричное
p	Указатель (в шестнадцатеричном виде)
f	Дробное число в фиксированном формате
e, E	Дробное число в научном формате
g, G	Дробное число в научном или фиксированном формате

Серым помечены те типы, которые не применимы при работе с Arduino. Таким образом, для вывода строки надо указать “%s”, а для вывода целого числа – “%d”.

Далее рассмотрим поле ширины. Число в нем указывает минимальную ширину поля, в котором будет выведен шаблон. Если размер значения в переменной меньше – поле будет добито пробелами, если больше – запись выйдет за пределы поля. Таким образом шаблон “%6d” для числа 385 выведет 385 (обратим внимание на три пробела перед числом).

Спецификатор точности всегда начинается с точки и следующее за ним число указывает различные действия в зависимости от типа значения. Для типов “d,o,u,x” он укажет минимальное количество символов, которое должно появится при обработке. Для типа “f” – число знаков после запятой. Для типа “s” – максимальное число символов стоки, который будут выведены. Например, “%6.1f” для числа 34.2345 выведет “34.1” (обращу внимание, что точка также считается знаком и перед числом будет присутствовать два пробела). Или шаблон “%.3s” от строки “точность” выведет только первые три символа – “точ”.

Флаг позволяет изменить отображение выводимого значения:

Более подробно о шаблонах функции printf можно прочитать интернете. Здесь же я дал краткий обзор наиболее часто используемых возможностей.

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

Заметим, что в строках 33 и 37 мы формируем целую строку для вывода, а в строках 34 и 38 – выводим их.

Наконец, наши любимые функции setup и loop.

В строке 47 мы задаем разрешение дисплея, в строке 48 – включим подсветку (яркость которой можно отрегулировать потенциометром). В строке 49 установим счетчик циклов в ноль. Увеличивать его будем на единицу в 37-й строке при выводе (помните конструкцию count++?). Наконец, в строке 56 вызываем рассмотренную раннее функцию вывода на дисплей. Все.

Что можно поменять или улучшить?

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

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

А на сегодня у меня все.

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

На данный момент на рынке существует большое количество LCD дисплеев, или, как их еще называют - знакосинтезирующих. Особо большое распростанение получили дисплеи 1602 (16 символов, 2 строки) на чипе HD44780 и совместимых с ним. Их можно недорого приобрести в Китае.

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

Необходимые компоненты

1. LCD 1602 на чипе HD44780
2. Любая Arduino. В моем случае Arduino Nano
3. Подстроечный резистор
4. Макетка
5. Модуль питания
6. Соеденительные провода

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

Дисплей питается от напряжения 5В. Подсветка дисплея - это отдельный контур, не связанный со всей остальной схемой. Включить ее можно подав 5В на 15 контакт и подключив минус на 16. Сделать ее диммируемой можно с помощью ШИМ сигнала. Также модно включать и отключать отдельно, при необходимости.

Питание все остальной схемы дисплея подается на следующие выводы:

• 1 - GND
• 2 - +5
• 3 - Контрастность. Подключается через делитель напряжения от 5В. Делителем обычно служит обычный переменный или подстроечный резистор.

Для подключения дисплея достаточно истпользовать 6 линий, 6 контактов на Arduino. Нам незачем считывать показания дисплея, поэтому сразу соеденяем 5 контакт (RW), который отвечает за чтение-запись с землей.

Затем, соединяем Arduino и экран нашими 6-ю линиями коммуникации. Какие именно контакты будут выбраны на Arduino не имеет значения: мы зададим их в программе, но для примера была выбрана такая конфигурация:

• 4-й контакт дисплея — 4-й контакт Arduino. Это линия адресного сигнала. Известная как A0 или RS. В зависимости от того, 0 она или 1, дисплей понимает имеем ли мы на линии данных команду вроде «передвинуть курсор» или код символа для отображения.
• 6-й контакт дисплея — 5-й контакт Arduino. Это линия разрешения доступа к данным. Известная, как E или Enable. Когда эта линия становится единицей, дисплей исполняет команду или выводит символ с линии данных.
• 11-й, 12-й, 13-й, 14-й контакт дисплея — 10-й, 11-й, 12-й, 13-й контакт Arduino соответственно. Это линии данных. Известные как DB4, DB5, DB6, DB7.

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

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

// Подключаем стандартную библиотеку LiquidCrystal #include // Инициализируем объект-экран, передаём использованные // для подключения контакты на Arduino в порядке: // RS, E, DB4, DB5, DB6, DB7 LiquidCrystal lcd(4, 5, 10, 11, 12, 13); void setup() { // устанавливаем размер (количество столбцов и строк) экрана lcd.begin(16, 2); // печатаем первую строку lcd.print("Hello World"); // устанавливаем курсор в колонку 0, строку 1. То есть на // самом деле это вторая строка, т.к. нумерация начинается с нуля lcd.setCursor(0, 1); // печатаем вторую строку lcd.print("LCD is Working!!!"); } void loop() { }

Всё довольно просто и должно быть понятно из комментариев.

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

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

Для понимания некоторых нюансов полезно знать как работает знакогенерирующий дисплей. Особенностью работы дисплеев такого типа является наличие своего контроллера с собственной памятью. DDRAM — память дисплея. Для вывода символа на экран необходимо загрузить символ в ячейку памяти, а затем передать команду на отображение ячейки памяти. При передаче символы кодируются ASCII кодами. Например, при записи в память кода 0×31 на дисплей будет выведен символ «1 ». Соответствие кода символа его отображению на экране (т.е. «картинке» символа) хранится в памяти CGROM. CGROM не изменяемая память. Поэтому, дисплей может отображать только те символы, которые «зашиты» в контроллер. Именно поэтому не каждый дисплей способен отображать, например, русские символы. Дисплеи, продающиеся в нашем магазине, к сожалению, не русифицированы. Есть ещё CGRAM память. Она изменяемая. Мы можем создавать собственные символы и отображать их на дисплее. Стоит учитывать, что можно создать не более восьми символов.

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

Подключение жидкокристаллического дисплея к 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 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); void setup() { // Указываем количество столбцов и строк дисплея: lcd.begin(16, 2); // Выводим сообщение на дисплей. lcd.print("hello, world!"); } void loop() { // устанавливаем курсор в 0 (нулевой) столбец первой строки // фактически курсор установится во вторую (нижнюю) строку // нумерация строк и столбцов начинается с нуля lcd.setCursor(0, 1); // выводим на дисплей количество секунд, // прошедших с момента загрузки платы: lcd.print(millis()/1000); }

*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 контакты дисплея void setup () { // Указываем количество столбцов и строк дисплея: lcd . begin (16 , 2 ) ; // Выводим сообщение на дисплей. lcd . print ("hello, world!" ) ; void loop () { // нумерация строк и столбцов начинается с нуля lcd . setCursor (0 , 1 ) ; // выводим на дисплей количество секунд, // прошедших с момента загрузки платы: lcd . print (millis () / 1000 ) ;

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

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

• 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*)

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(0 ) на lcd.write((byte)0 ).
Теперь небольшой пример по созданию своего символа. Давайте выведем на дисплей символ рубля .

// Подключаем библиотеку #include ; // Инициализируем дисплей LiquidCrystal lcd(12, 11, 5, 4, 3, 2); // Описываем свой символ. // Просто "рисуем" символ единицами // Единицы при выводе на экран окажутся закрашенными точками, нули - не закрашенными byte rubl = { 0b00000, 0b01110, 0b01001, 0b01001, 0b01110, 0b01000, 0b11110, 0b01000, }; void setup() { // записываем свой символ в память экрана // аргументами передаём номер символа // и байтовый массив, описывающий наш символ lcd.createChar(0, rubl); // настраиваем дисплей lcd.begin(16, 2); } void loop() { // устанавливаем курсор в левый верхний угод экрана lcd.setCursor(0,0); // выводим символ с номером ноль на экран lcd.write((byte)0); // ничего не делаем 10 секунд delay(10000); }

// Подключаем библиотеку #include ; // Инициализируем дисплей LiquidCrystal lcd (12 , 11 , 5 , 4 , 3 , 2 ) ;

В этой инструкции показано, как подключать к Arduino и использовать LCD экраны на 16х2 и 20х4. Эти экраны имеют встроенную подсветку на базе маломощного светодиода, работают от +5 В. Для подключения этих жидкокристаллических экранов понадобится 6 контактов. Можно использовать любые пины на вашем Arduino!

Инструкция написана на основании LCD экранов от компании Adafruit - blue&white 16x2, RGB 16x2 LCD, и blue&white 20x4, RGB 20x4. Если вы используете ЖК экран от другого производителя, нет 100% гарантии, что он сработает (хотя в 99% случаев все работает).

Символьные и графические LCD - в чем разница?

Существует огромное количество разных ЖК экранов. В этой статье мы рассмотрим символьные (character) LCD. Подобные экраны - отличный вариант для отображения текста. Можно настроить и отображение иконок, но размер этих иконок не должен превышать 7 пикселей (очень маленькие!).

На фото ниже показан пример работы LCD монитора на 16 символов с двумя строками:

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

На графическом жидкокристаллическом дисплее одна большая сетка пикселей (в данном примере - 128х64). На нем можно отобразить текст, но лучше выводить изображения. Графические LCD обычно больше по размерам, на них больше контактов для подключения, использовать их несколько сложнее, чем текстовые.

В этой статье мы рассмотрим только текстовые/символьные экраны!

Разные модели LCD экранов

После того, как мы ограничили тип рассматриваемых экранов, рассмотрим, какие они бывают.

Несмотря на то, что они используются только для отображения текста, существуют разные модели и форм-факторы: в левом верхнем углу ЖК экран 20x4 с белым текстом на синем фоне, в правом верхнем - 16x4 с черным текстом на зеленом фоне, слева внизу - и 16x1 с черным текстом на сером фоне.

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

В этой части мы используем LCD экраны с одной рельсой и 16 контактами для подключения (смотрите фото выше). Есть и LCD с 2 рельсами по 8 контактов для подключения (на рисунке ниже).

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

Подключение символьного LCD экрана к Arduino

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

Помимо LCD экрана вам понадобится дополнительная обвязка. Во-первых - на 10 КОм. С помощью потенциометра мы будем настраивать контрастность дисплея. На каждом ЖК экране различные настройки контрастности, так что без регулировки не обойтись. Кроме того, вам понадобится рельса контактов 0.1".

Если рельса с контактами слишком длинная, лишние контакты модно просто отрезать!

Вам надо припаять контакты к ЖК дисплею.

При пайке будьте предельно осторожны, не повредите ваш ! Можете сначала "прихватить" первый и 16 контакты, а потом уже припаять остальные.

Питание и подсветка

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

	Пояснения
	Мы начинаем подбираться к интересным вещам! Установите ваш LCD на breadboard.
	Макетную плату запитываем от нашего Arduino. Подключите +5V к красной рельсе, а Gnd - к синей.
	После этого подключим подсветку нашего LCD экрана. Подключите контакт 16 к gnd, а пин 15 - к +5V. На большинстве ЖК экранов предусмотрены резисторы для подсветки. Если же на вашем модуле резисторов не оказалось, придется добавить один между 5V и пином 15. Для расчета номинала резисторов, уточните максимальный ток для питания подсветки и примерное значение падения напряжения из даташита. Отнимите значение падения напряжения от 5 В, после этого разделите на максимальную силу тока и округлите к ближайшему большему стандартному значению номинала резистора. Например, если падение напряжения составляет 3.5 В, а сила тока 16 мА, номинал резистора будет равен: (5 - 3.5)/0.016 = 93.75 Ом, или 100 Ом после округления к стандартному значению. Если вы не можете найти даташит, используйте резистор на 220 Ом. Правда, в этом случае подсветка может быть достаточно бледной.
	Подключите ваш Arduino к питанию. Подсветка должна загореться.

Кстати, на некоторых дешевых LCD экранах подсветка не предусмотрена!

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

Цепь для настройки контраста

	Пояснения
	Устанавливаем потенциометр. На фото он находится справа от пина 1.
	Подключите одну сторону потенциометра к +5V, а вторую - к Gnd. Средний контакт потенциометра подключите к 3 пину на LCD.
	Теперь подключаем логику нашего экрана - это отдельная от подсветки цепь! Пин 1 идет к Gnd, а пин 2 - к +5V.
	Включите ваш Arduino. Если на LCD Мониторе предусмотрена подсветка, она должна загореться. Покрутите ручку потенциометра, чтобы увидеть первую прямоугольники пикселей на первой строке.

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

Окончательное подключение

От D0 до D7, RS, EN, и RW. D0-D7 - это контакты, на которых хранится значения, передаваемые на дисплей. Контакт RS сообщает контроллеру, будем ли мы отображать данные (например, ASCII символ) или это управляющий байт (например, смена положения курсора). Контакт EN - это сокращение от "enable" (доступно), с помощью этого контакта мы сообщаем LCD, когда данные готовы для считывания. Контакт RW используется для установки направления - мы хотим отобразить (обычно) или считать (используется реже) данные с дисплея.

Не все эти контакты надо подключать к Arduino. Например, использовать RW не надо, если мы только отображаем данные на экране, так что его достаточно "подтянуть" к контакту Gnd. Кроме того, можно обмениваться данными с LCD экраном, используя 4 контакта вместо 8. Вероятно, возникает закономерный вопрос, в каких случаях используют 8 контактов? Скорее всего, это влияет на скорость передачи данных. То есть, используя 8 контактов вместо 4, вы можете увеличить скорость обмена информацией в 2 раза. В данном случае, скорость не важна, так что мы используем 4 контакта для подключения LCD к Arduino.

Итак, нам понадобятся 6 контактов: RS, EN, D7, D6, D5, и D4.

Для работы с LCD экраном, будем использовать библиотеку LiquidCrystal library, которая значительно облегчает процесс настройки пинов. Одно из достоинств этой библиотеки: вы можете использовать любые пины на Arduino для подключения контактов ЖК дисплея. Так что по окончанию этого гайда вы сможете легко заменить контакты, если это критично для вашего проекта.

Окончательное подключение дисплея

	Пояснения
	Как упоминалось выше, мы не будем использовать пин RW, так что "подтягиваем" его к земле. Это пин 5.
	После подключаем RS - это пин #4. Мы используем коричневый провод для его подключения к цифровому контакту #7 на Arduino.
	Белым проводом подключаем контакт EN - пин #6 к цифровому пину digital #8 на Arduino.
	Подошла очередь к контактам data. DB7 - это пин #14 на LCD. Он подключается оранжевым проводом к пину #12 на Arduino.
	Осталось три контакта data, DB6 (пин #13 желтый), DB5 (пин #12 зеленый) и DB4 (пин #11 синий). Они подключаются к пинам #11, 10 и 9 на Arduino соответственно.
	В результате Подключения у вас получится что-то похожее на фото слева.

Используем символьный LCD

Пришло время загрузить скетч на Arduino для управления LCD экраном. Библиотека LiquidCrystal library установлена в Arduino IDE по умолчанию. Так что нам достаточно загрузить один из примеров и немного подкорректировать в соответствии с теми пинами, которые мы использовали для подключения.

Откройте скетч File→Examples→LiquidCrystal→HelloWorld.

Обновляем информацию о пинах. Ищем следующую строку:

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

И меняем ее на:

Теперь можете компилировать и загружать скетч на Arduino.

Если надо, настройте контраст

Естественно, вы можете использовать ЖК дисплей с любыми размерами. Например, на фото ниже показана работа LCD 20x4.

Или черный текст на зеленом фоне:

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

Задействуем насколько строк

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

lcd.print("hello, world!");

На следующую:

lcd.print("hello, world! this is a long long message");

LCD дисплей 16x2 обрежет все после 16-го символа:

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

LCD с RGB подсветкой

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

После подключения LCD и его проверки в соответствии с инструкциями выше, подключите светодиоды к ШИМ аналоговым пинам вашего Arduino для точной настройки цвета. Если вы используете Arduino Uno, у вас должно было остаться три свободных ШИМ контакта. подключите красный светодиод (16 контакт на LCD) к Digital 3, зеленый светодиод (контакт 17) - к Digital 5, а синий светодиод (18 контакт на LCD) - к digital 6. На LCD модуле уже предусмотрены резисторы, так что подключать дополнительные не надо.

Теперь загрузите приведенный ниже скетч на Arduino.

// включаем в скетч библиотеки:

#include

#include

#define REDLITE 3

#define GREENLITE 5

#define BLUELITE 6

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

// для передачи данных

LiquidCrystal lcd(7, 8, 9, 10, 11, 12);

// яркость можно изменять в диапазоне 0 -> 255

int brightness = 255;

// настраиваем количество столбцов и строк на LCD:

lcd.begin(16, 2);

// отображаем сообщение на LCD.

lcd.print("RGB 16x2 Display ");

lcd.setCursor(0,1);

lcd.print(" Multicolor LCD ");

pinMode(REDLITE, OUTPUT);

pinMode(GREENLITE, OUTPUT);

pinMode(BLUELITE, OUTPUT);

brightness = 100;

for (int i = 0; i < 255; i++) {

setBacklight(i, 0, 255-i);

for (int i = 0; i < 255; i++) {

setBacklight(255-i, i, 0);

for (int i = 0; i < 255; i++) {

setBacklight(0, 255-i, i);

void setBacklight(uint8_t r, uint8_t g, uint8_t b) {

// настраиваем красный светодиод - он ярче остальных!

r = map(r, 0, 255, 0, 100);

g = map(g, 0, 255, 0, 150);

r = map(r, 0, 255, 0, brightness);

g = map(g, 0, 255, 0, brightness);

b = map(b, 0, 255, 0, brightness);

// общий анод, так что инвертируем!

r = map(r, 0, 255, 255, 0);

g = map(g, 0, 255, 255, 0);

b = map(b, 0, 255, 255, 0);

Serial.print("R = "); Serial.print(r, DEC);

Serial.print(" G = "); Serial.print(g, DEC);

Serial.print(" B = "); Serial.println(b, DEC);

analogWrite(REDLITE, r);

analogWrite(GREENLITE, g);

analogWrite(BLUELITE, b);

Результат работы данного скетча приведен на видео ниже

Команда createChar

Вероятно, вы захотите использовать специальные символы. Например, если вы разрабатываете проект с использованием датчика температуры (), вам пригодится символ (°).

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

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

Как подружить плату Ардуино с символьным дисплеем? Довольно просто! Все ниже по порядку и с подробностями.

Если есть желание получать информацию от Ардуино без подключения к компьютеру и вывода на серийный порт, можно использовать символьный дисплей. Сделать это не так сложно. Полученное удобство от общения неоценимо.
Для работы я использовал символьный LCD-дисплей J204A на базе чипа HD44780, на eBay часто встречается как LCD2004. 4 строки по 20 символов, инвертированный. Куплен с кучей других на eBay, за сущие копейки, от 60 до 100 рублей за штуку. Русский язык не поддерживается по-умолчанию, но это решаемая проблема, об этом как нибудь в следующий раз. И еще коннекторы на схеме не распаяны, придется поработать паяльником.
Для работы с дисплеями используется библиотека LiquidCrystal.h входящая в дефолтную постаку Arduino IDE.

А вот даташита по дисплею LCD2004 я не нашел, но зато в интернетах полным полно таблиц по дисплею . Но они практически не отличаются друг от друга. По управлению и подключению полностью идентичны. Отличие только в количестве строк/символов на дисплее. Но это абсолютно не повлияет если у вас 1602.

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

#	Контакты	Для чего используется	Примечание
1	VSS (VSS)	GND. Земля. Питание микроконтроллера дисплея.	0V
2	VDD (VCC)	Питающее напряжение для микроконтроллера дисплея.	+5V
3	V0 (VEE)	Контраст символов на дисплее. Подключать лучше через потенциометр.	от 0v до +5V
4	RS (RS)	Выбор регистра.
5	RW (R/W)	Переключение режима чтения/записи. Утянем на землю, нам нужно только передавать информацию на дисплей.	0-запись +5V-чтение
6	E	Тактирование
7	D0 (DB0)		Данные
8	D1 (DB1)	Передача данных. (Не будем использовать)	Данные
9	D2 (DB2)	Передача данных. (Не будем использовать)	Данные
10	D3 (DB3)	Передача данных. (Не будем использовать)	Данные
11	D4 (DB4)		Данные
12	D5 (DB5)	Передача данных. (Задействуется)	Данные
13	D6 (DB6)	Передача данных. (Задействуется)	Данные
14	D7 (DB7)	Передача данных. (Задействуется)	Данные
15	A (LED+)	+5V Напряжение, подсветка дисплея, через потенциометр можно регулировать яркость дисплея.	+5V
16	K (LED-)	GND Земля, подсветка дисплея	0V

v

Передача данных к дисплею возможна в двух вариантах: по 8 и по 4 бит за такт. Т.к. Ардуино имеет мало контактов, мы будем использовать 4 — этого с лихвой хватает, чтоб обновлять информацию на дисплее с запредельной для восприятия скоростью.

Вот так все это дело у меня подключено. Возможно кажется что это хаос, но тут есть система. Можно выделить красные, зеленые, желтые и оранжевые провода. Красные всегда идут на +5V, зеленые — GND, а желтые и оранжевые — это провода для подключения к Ардуино, по которым идут данные.

Самая важная часть — физическое подключение дисплея. По клику открывается в большом разрешении, где все хорошо видно.
R1 — Резистор 200OM. Сопротивление ограничивающее ток, проходящий через подсветку дисплея.
R2 — Потенциометр с сопротивлением до 10kOM. Кутим ручку, подбираем контраст символов.

И крайне простой скетч, для вывода на экран пары строк.

H> // Подключаем библиотеку для работы с дисплеем. /* Командой LiquidCrystal lcd(rs, enable, d4, d5, d6, d7); создаем переменную типа LiquidCrystal И определяем через какие контакты Ардуино рабоает с дисплеем. подробнее про эту команду тут http://arduino.cc/en/Reference/LiquidCrystalConstructor */ LiquidCrystal lcd(6, 7, 8, 9, 10, 11); void setup() { lcd.begin(20, 4); // определяем характеристики дисплея (20 Символов в строке, 4 строки) // Для дисплея 1602 надо указывать lcd.begin(16, 2); lcd.setCursor(1, 1); // Указываем с какой позиции начать выводить текст. строки и символы начинаются с 0!!! // 1 уже отодвинет каретку на одно деление от начала экрана и сдвинет текст на одну строку ниже lcd.print("compblog.vlukyanov"); // выводим текст начиная с указанной позиции. lcd.setCursor(7, 2); // выводим с 8го символа на экране в третьей строке. lcd.print(".com"); // текст для вывода. } void loop() { // в цикле ни чего больше не делаем все уже сделано во время инициализации платы. }

Результат. Если знать, как все это подключается и как написать код, то время на все работы 5 минут.

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

Например:

• Скролить текст;
• Мигать позицией курсора;
• Включаться/выключаться.

А теперь бонус!
Подсветка дисплея тратит энергию, которую, при питании от батареи, например, хотелось бы экономить. Я сделал для себя такой вариант — при нажатии на кнопку, включается подсветка дисплея на 5 секунд.

H> // Подключаем библиотеку для работы с дисплеем. int buttonInt = 0; // Номер прерывания, которое будет вызыватся. int screenLed = 4; // Номер пина к которому подключен экран. +5V volatile long x = 5000; // переменная для хранения времени LiquidCrystal lcd(6, 7, 8, 9, 10, 11); void setup() { attachInterrupt(buttonInt, screenon, FALLING); // параметры прерывания lcd.begin(20, 4); pinMode(screenLed, OUTPUT); digitalWrite(screenLed,HIGH); // включаем дисплей lcd.setCursor(0, 0); lcd.print("Start screenon test!"); } // Функция которая будет выполнятся при нажатии на кнопку. void screenon() { x = millis()+5000; // Запоминаем время, когда надо выключить подсветку. Текущее время работы +5 секунд. digitalWrite(screenLed,HIGH); // Подаем напряжение на подсветку дисплея. } void loop() { lcd.setCursor(0, 2); // переходим к третей строке lcd.print(x); // и выводим время когда дисплей выключится lcd.setCursor(0, 3); // переходим к четвертой строке lcd.print(millis()); // печатаем текущее время работы if (x < millis()) // если время работы выключения наступило > { digitalWrite(screenLed,LOW); // то гасим дисплей } }

И результат: