Днес ще се опитаме да се спрем на изхода към текстов дисплей. Най-популярният е чипът HD44780 (или KS0066, съвместим с него). Изброяваме техните плюсове и минуси:

Професионалисти:

1. Ниска цена.
2. Лесен за програмиране, кодът ще бъде един и същ за всеки модел.
3. Разнообразие от модели - най-често срещаните: 8x1, 16x2, 20x4. Можете да намерите и доста екзотични модели 40x4, т.е. четири реда по 40 знака всеки.
4. Възможност за свързване на няколко дисплея към един Arduino.
5. Възможност за задаване на собствени символи.

минуси:

1. Не всички дисплеи поддържат руски знаци. За повече подробности вижте описанието на конкретен дисплей.
2. Връзката без използване на I2C шината изисква използването на 10-16 проводника, което е много лошо. с I2C - 4 проводника.

Въз основа на гореизложеното ще обмисля свързване на дисплея само чрез I2C.

Да опитаме.

Това, от което се нуждаем.

1. Arduino (взех модела Nano)
2. Дисплей на чип HD44780 с или без I2C модул (тогава имате нужда от отделна LC1602 IIC платка) - в нашия случай 16x2 без I2C модул
3. 10K резистор (Ако имате нужда от ръчно управление на подсветката).
4. Потенциометър (Ако имате нужда от ръчно управление на подсветката).
5. Breadboard 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).

Нека първо се справим с необходимия елемент на шаблона - типа. Той определя какъв тип променлива ще бъде изведен и може да приеме една от следните стойности:

Символ	Значение
° С	Един герой
с	Символен низ
d,i	Десетично цяло число със знак
о	Осмично цяло число
u	Цяло число без знак десетична
x, X	Шестнадесетично цяло число
стр	Указател (шестнадесетичен)
f	Дробно число във фиксиран формат
д, Е	Дробно число в научен формат
g, G	Дробно число в научен или фиксиран формат

Сивото маркира тези типове, които не са приложими при работа с Arduino. По този начин, за да изведете низ, трябва да посочите "%s", а за да изведете цяло число - "%d".

След това помислете за полето за ширина. Числото в него показва минималната ширина на полето, в което ще се показва шаблонът. Ако размерът на стойността в променливата е по-малък, полето ще бъде допълнено с интервали, ако е повече, записът ще излезе извън полето. Така моделът "%6d" за числото 385 ще отпечата 385 (обърнете внимание на трите интервала преди числото).

Спецификаторът за точност винаги започва с точка и числото след него показва различни действия в зависимост от типа на стойността. За типовете "d,o,u,x" ще покаже минимално количествосимволи, които трябва да се появят по време на обработката. За типа „f“ броят на десетичните знаци. За тип „s“, максималният брой низови знаци за отпечатване. Например „%6.1f“ за числото 34.2345 ще покаже „34.1“ (обърнете внимание, че точката също се счита за знак и ще има два интервала преди числото). Или шаблонът "%.3s" от низа "precision" ще покаже само първите три знака - "точка".

Флагът ви позволява да промените показването на показаната стойност:

Можете да прочетете повече за шаблоните на функцията printf в Интернет. Ето дадох кратък прегледнай-често използваните функции.

Така нашата изходна функция, пренаписана да използва форматиран изход, ще изглежда така:

Имайте предвид, че в редове 33 и 37 оформяме цял ред за извеждане, а в редове 34 и 38 ги извеждаме.

И накрая, нашите любими функции за настройка и цикъл.

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

Какво може да се промени или подобри?

Например, можете да направите автоматично управление на подсветката в зависимост от осветеността, като използвате фоторезистор или светлинен сензор от метеорологична станция, обсъдени в няколко статии по-рано. Например при силна светлина - увеличете яркостта на подсветката, а през нощта - намалете я. Или завийте сензор за движение и включете подсветката, когато се появи обект пред дисплея, или ... Като цяло, мисля, че вече сте разбрали, че ако желаете, като замените един или повече компоненти и напишете част от кода , можете сериозно да подобрите използваемостта на дисплея. Можем също така да използваме персонализирани символи за показване на дисплея.

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

И за днес имам всичко.

С тази проста статия искам да започна поредицата си от статии за автоматизацията на работното място.

В момента има на пазара голям брой LCD дисплеи или, както ги наричат ​​още, знаково синтезиращи дисплеи. 1602 дисплея (16 знака, 2 реда) на чип HD44780 и съвместим. Те могат да бъдат закупени евтино в Китай.

Тази статия описва подробно електрическата схема за този екран, но тя ще работи и за много други текстови дисплеи. Има библиотека за arduinoтечен кристал с който е много удобно да работите с дисплея.

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

1. LCD 1602 на чип HD44780
2. Всеки Arduino. В моя случай Arduino Nano
3. Тример резистор
4. оформление
5. Силов модул
6. Свързващи проводници

Връзка на дисплея

Дисплеят се захранва от 5V. Подсветката на дисплея е отделна верига, която не е свързана с останалата част от веригата. Можете да го включите, като приложите 5V към пин 15 и свържете минус към пин 16. Можете да го направите димируем с помощта на PWM сигнал. Също така е модерно да активирате и деактивирате отделно, ако е необходимо.

Захранването за останалата част от веригата на дисплея се подава към следните щифтове:

• 1-GND
• 2 - +5
• 3 - Контраст. Свързва се чрез делител на напрежение от 5V. Разделителят обикновено е конвенционален променлив или настройващ резистор.

За да свържете дисплея, достатъчно е да използвате 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 работи!!!"); ) void loop() ( )

Всичко е съвсем просто и трябва да стане ясно от коментарите.

Когато създавате свое собствено устройство, не е необичайно необходимостта от незабавно показване на разнообразна информация. Например, ако създадете контролер умен дом, тогава е разумно да оборудвате устройството с изходно устройство, което ви позволява бързо да разберете текущото състояние на системите. Най-доброто решение е течнокристален дисплей. Консумацията на енергия при изключена подсветка е минимална, а работата с дисплея е изключително опростена и не изисква много намеса в програмния код. Всъщност изходът на информация към LCD дисплея не се различава много от изхода към серийния порт. Статията обсъжда как да свържете дисплей, генериращ знаци, базиран на популярния чип HD44780, към контролер Arduino.

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

За да разберете някои от нюансите, е полезно да знаете как работи дисплеят за генериране на знаци. Характеристика на този тип дисплей е наличието на собствен контролер със собствена памет. DDRAM е памет на дисплея. За да покажете знак на екрана, трябва да заредите знака в клетка от паметта и след това да изпратите команда за показване на клетката от паметта. Когато се предават, знаците се кодират с ASCII кодове. Например, когато записвате код 0×31 в паметта, символът „ 1 ". Съответствието на кода на символа с неговото показване на екрана (т.е. "картината" на знака) се съхранява в паметта на CGROM. CGROM не е променлива памет. Поради това дисплеят може да показва само тези символи, които са "закрепени" в контролера. Ето защо не всеки дисплей може да показва, например, руски знаци. Дисплеите, продавани в нашия магазин, за съжаление не са русифицирани. Има и CGRAM памет. Тя е променлива. Можем да създадем свои собствени символи и да ги покажем на дисплея. Трябва да се има предвид, че можете да създадете не повече от осем знака.

Цялата тази "долна" работа е важна само за разбирането на някои от нюансите. За Arduino има проста и ясна библиотека, която върши цялата тежка работа вместо вас, позволявайки ви да контролирате изхода към дисплея лесно и просто.

Свързване на LCD дисплей към Arduino

За да свържете дисплея, разбира се, трябва да го инсталирате на макет. Моля, обърнете внимание: дисплеите, продавани в нашия магазин, се продават без запоен щифтов конектор. Ако искате веднага да получите дисплей, готов за инсталиране на макетна платка, поставете отметка в квадратчето „запояване на конектора“ на страницата на продукта и ние ще запоим конектора вместо вас. Прехвърлянето на данни към дисплея може да се организира по два начина: 4 или 8 бита наведнъж. Съответно са необходими 4 или 8 пина Arduino. На практика няма да има увеличение на скоростта при използване на осембитов интерфейс. Следователно са ни необходими само 4 цифрови изхода за пренос на данни. Ще са необходими още 3 изхода за настройка на режима на показване. Общо за свързване на дисплея са необходими само 7 цифрови изхода на контролера. Контактите на дисплея са подписани, което ще ви позволи да не се объркате при свързване:

Изводите са номерирани отляво надясно:

• 1-(VSS) Заземяване на дисплея. Свързва се към заземителната релса.
• 2-(VDD) Мощност на дисплея. Свързва се към захранващата шина.
• 3-(VO) Вход за потенциометър (включен). Контрастът на дисплея може да се регулира с потенциометъра. Средният изход на потенциометъра е свързан към изхода на дисплея.
• 4-(RS) Вход на сигнал "Команда". Свързва се към всеки цифров щифт на Arduino. В примера той е свързан към пин #12.
• 5-(RW) Задава режим "четене" или "запис". Ще записваме. Свързваме контакта към земята.
• 6-(д) Разрешете. Друг "команден" изход. Когато изходът е единица, дисплеят изпълнява предварително предадената команда. Свързва се към всеки цифров изход. В примера той е свързан към пин #11.
• 7-10 (D0-D3) остават несвързани. Това са щифтовете за данни, които се използват в 8-битовия интерфейс. Ние не се нуждаем.
• 11-14 (D4-D7) Контакти за предаване на данни в четирибитов режим. Свържете отново всички цифрови изходи. В примера те са свързани съответно към щифтове 5, 4, 3 и 2 (D4 към пин 5, D5 към пин 4 и т.н.).
• 15 (А) Подсветка LED анод. Резисторът за ограничаване на тока вече е инсталиран в дисплея, така че анодът просто се свързва към захранващата шина. Тъй като подсветката използва най-често срещания светодиод, можете да го свържете към всеки щифт, който поддържа и контролира програмно яркостта на подсветката.
• 16 (К) Осветителен катод. Свързва се към заземителната релса.

Визуална електрическа схема:

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

Заедно с Arduino IDEидва с отлична библиотека за дисплеи с течни кристали - LiquidCrystal. Библиотеката съдържа примери, които напълно разкриват възможностите на екрана. За да започнете, използвайте стандартния пример "HelloWorld" (Файл -> Примери -> LiquidCrystal -> HelloWorld) или качете следния код на дъската:

/* *RS щифт на дисплея към arduino пин 12 *Активиране на щифт на дисплея към arduino пин 11 *D4 щифт на дисплея към arduino пин 5 *D5 щифт на дисплея към arduino пин 4 *D6 щифт на дисплея към arduino пин 3 *D7 щифт на дисплея към arduino пин 2 *R/W щифт на дисплея към маса *Изход на потенциометър към VO щифт на дисплея */ // библиотека за включване: #include ; // Инициализиране на дисплея // Изброяване щифтове на ардуинокъм които // 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 щифт на дисплея към arduino щифт 12 *Активирайте изхода на дисплея към pin 11 на arduino *D4 щифт на дисплея към arduino щифт 5 *D5 щифт на дисплея към щифт 4 на arduino *D6 щифт на дисплея към щифт 3 на ардуино *D7 щифт на дисплея към щифт 2 на arduino *R/W дисплей кабел към маса * Изход на потенциометър към изход на VO дисплей // включва библиотеката: #включи ; // Инициализиране на дисплея // Избройте щифтовете на Arduino, към които са свързани // RS, E, D4, D5, D6, D7 щифтове на дисплея void setup()( // Посочете броя на колоните и редовете на дисплея: lcd . начало (16, 2); // Показване на съобщението. lcd . print("здравей, свят!"); void loop()( // номерирането на редове и колони започва от нула lcd . setCursor (0, 1); // показване на броя секунди, // изминало от зареждането на дъската: lcd . печат (милиси() / 1000);

След като качите този код в Ардуино платкаЕкранът ще покаже "Здравей, свят!" Английски "Здравей свят!") на първия ред и таймер, отброяващ секунди на втория ред.

Както обикновено, кодът е прост и ясен. Все пак ще го анализираме по-подробно:

• течнокристален LCD(12, 11, 5, 4, 3, 2) - този ред създава обект за показване, с който ще работим в бъдеще. В скоби номерата на щифтовете, към които са свързани контактите на дисплея, се предават като аргументи. Съответно: RS, E, D4, D5, D6, D7. Както беше отбелязано по-горе, пиновете при свързване могат да бъдат избрани напълно произволно.
• lcd.begin(16, 2) - тук задаваме размерите на дисплея. В този пример има 16 колони и 2 реда. За нашия дисплей 20X4 този ред ще изглежда така: lcd.begin(20, 4).
• lcd печат("здравей, свят!") - показва текст. След като зададете размера на дисплея (lcd.begin), курсорът се поставя в горния ляв ъгъл на дисплея. Следователно този текст ще се показва на първия (горния) ред отляво.
• lcd.setCursor(0, 1) - поставя курсора на зададената позиция. В този случай се посочва най-лявата позиция на втория ред. Номерът на колоната е даден в скоби, последван от номера на реда. И редовете, и колоните се номерират от позиция нула. Така: lcd.setCursor(0, 0) - поставя курсора в горния ляв ъгъл, lcd.setCursor(15, 0) - долния десен.
• lcd печат(millis()/1000) - вече е описано по-горе. Тук вместо текст като параметър се предава формула за изчисление. Резултатът се показва на екрана.

Сега, след като се справихме с най-простия пример, можем да преминем към по-сложни примери. И ако вече сте разбрали всичко и сте готови да закупите LCD дисплей, тогава съм събрал за вас връзки към китайски продавачи на дисплеи, които проверих:

Характерни LCD дисплеи

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

Преглед на други примери за библиотеката LiquidCrystal

В стандартните примери, доставени с библиотеката LiquidCrystal, можете да намерите следните скици:

• Автоматично превъртане- демонстрира възможност за превъртане на текст в автоматичен режим. Някаква бягаща линия. Когато се изведе знак, предишните знаци се изместват. Така новият символ се извежда на същото място.

• Мигайте- демонстрира възможност за активиране на показването на мигащ курсор под формата на правоъгълник.

• Курсор- демонстрира възможност за активиране на показването на курсора като мигаща хоризонтална лента.

• CustomCharacter- показва възможността за създаване на ваши собствени герои, които да ги показвате на дисплея. Между другото, има грешка в тази скица. Подробности по-долу.

• дисплей- показва начин за "изключване" на дисплея. Тоест показване или скриване на показания текст.

• Превъртете- демонстрира възможност за превъртане на текст в ръчен режим.

• сериен дисплей- Показва на екрана текста, отпечатан в прозореца на монитора на порта (т.е. текста, предаван през серийния порт).
• setCursor- изпълва дисплея с букви, демонстрирайки възможност за поставяне на курсора на всяка позиция на екрана.
• TextDirection- демонстрира способността да променя посоката на извеждане на текст (от дясно на ляво или от ляво на дясно).

Нека разгледаме по-подробно процедурите, чиито възможности са демонстрирани от тези примери:

lcd.autoscroll()

След като извикате тази процедура, текстът на екрана ще се превърта автоматично. За да спрете превъртането, обадете се lcd.noAutoscroll().

lcd.blink()

След извикване на процедурата, курсорът ще приеме формата на мигащ правоъгълник. За деактивиране се обадете lcd.noBlink()

lcd.cursor()

След извикване на процедурата, курсорът ще приеме формата на мигаща хоризонтална лента. За деактивиране се обадете lcd.noCursor(). Курсорът отново ще стане невидим.

lcd.createChar()

Процедурата зарежда в променливата екранна таблица със знаци (в CGRAM памет) символ, описан като байтов масив. Аргументът е номерът на знака и масив от байтове, описващи знака. Нека се спрем на това по-подробно. В паметта на дисплея могат да се съхраняват максимум осем знака. За да добавите своя символ, трябва:

1. Създайте масив от байтове, описващ знак.
2. Запишете символ в паметта на дисплея, като му присвоите номер в таблицата със символи. Знаците са номерирани от нула до седем.
3. Показване на знак на екрана с помощта на процедура lcd.write()(да не се бърка с lcd.print()), като аргумент, към който да прехвърлите номера на символа.

Грешка в средата за разработка и характеристиките на библиотеката доведе до невъзможност за показване на знак номер 0 (нула). Компилаторът ще срещне реда lcd.write(0) с грешка: “ извикването на претоварен ‘write(int)’ е двусмислено". Именно този ред се среща в примера CustomCharacterбиблиотеки. Когато се опитате да компилирате стандартния пример, ще получите грешка:

CustomCharacter.ino: Във функцията 'void setup()': CustomCharacter:115: грешка: извикването на претоварен 'write(int)' е двусмислено /home/nazarovd/arduino-1.0.5/libraries/LiquidCrystal/LiquidCrystal.h:82 : забележка: кандидатите са: virtual size_t LiquidCrystal::write(uint8_t) /home/nazarovd/arduino-1.0.5/hardware/arduino/cores/arduino/Print.h:49: забележка: size_t Print::write(const char *)

CustomCharacter. ino : Във функцията 'void setup()': CustomCharacter: 115: грешка: извикването на претоварен ‘write (int)’ е двусмислено /home/nazarovd/arduino-1.0.5/libraries/LiquidCrystal/LiquidCrystal. h : 82 : забележка : кандидатите са : virtual size_t LiquidCrystal :: write(uint8_t ) /home/nazarovd/arduino-1.0.5/hardware/arduino/cores/arduino/Печат. h : 49 : note : size_t Print :: write (const char * )

За да коригирате грешката, просто променете реда lcd.write( 0 ) към lcd.write( (байт) 0).
Сега малък пример за създаване на ваш собствен символ. Нека покажем символа на рублата.

// Включете библиотеката #include ; // Инициализиране на дисплея LiquidCrystal lcd(12, 11, 5, 4, 3, 2); // Описване на вашия символ. // Просто "начертайте" знака с единици // Единиците ще бъдат запълнени с точки, когато се показват, нулите ще бъдат непопълнени байт 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 секунди забавяне (10000); )

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

Тази инструкция показва как да се свържете с Arduino и да използвате LCD екрани на 16x2 и 20x4. Тези дисплеи имат вградена LED подсветка с ниска мощност, работят от +5 V. За да свържете тези LCD дисплеи, ви трябват 6 пина. Можете да използвате всякакви щифтове на вашия Arduino!

Инструкцията е написана на базата на LCD екрани Adafruit - синьо и бяло 16x2, RGB 16x2 LCD, и синьо и бяло 20x4, RGB 20x4. Ако използвате LCD екран от друг производител, няма 100% гаранция, че ще работи (въпреки че в 99% от случаите ще работи).

Символен срещу графичен LCD - Каква е разликата?

Има огромен брой различни LCD екрани. В тази статия ще разгледаме символните LCD дисплеи. Екрани като тези са чудесен вариант за показване на текст. Можете също така да персонализирате показването на икони, но размерът на тези икони не трябва да надвишава 7 пиксела (много малко!).

Снимката по-долу показва пример за 16-знаков LCD монитор с два реда:

Ако се вгледате внимателно, ще видите малки правоъгълници, където са показани символи. Всеки правоъгълник е отделна мрежа от пиксели. За сравнение, графичният LCD екран е показан по-долу:

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

В тази статия ще разгледаме само екрани с текст/символ!

Различни модели LCD екрани

След като ограничихме въпросния тип екрани, нека да разгледаме какви са те.

Въпреки че се използват само за показване на текст, има различни модели и форм-фактори: в горния ляв ъгъл е 20x4 LCD с бял текст на син фон, в горния десен ъгъл е 16x4 с черен текст на зелен фон, в долният ляв е и 16x1 с черен текст на сив фон.

Добрата новина е, че всички тези екрани са взаимозаменяеми. Ако сте персонализирали някой от тях, можете да го замените с друг модел. Скицата ще трябва да се промени малко, но връзката е същата!

В тази част използваме LCD екрани с една релса и 16 пина за свързване (вижте снимката по-горе). Има и LCD с 2 шини с 8 пина за свързване (на фигурата по-долу).

Свързването на втория модел към платка без спойка е по-трудно.

Свързване на символен LCD екран към Arduino

Монтиране на контактни шини

В допълнение към LCD екрана ще ви трябва допълнителна лента. Първо - при 10 kOhm. С помощта на потенциометъра ще регулираме контраста на дисплея. Всеки LCD екран има различни настройки за контраст, така че не можете без настройка. Освен това ще ви трябва 0,1" щифтова релса.

Ако релсата с контактите е твърде дълга, е модерно просто да отрежете допълнителните контакти!

Трябва да запоите щифтовете към LCD дисплея.

Когато запоявате, бъдете изключително внимателни, за да не повредите вашия! Първо можете да "хванете" първия и 16 контакта и след това да спойкате останалите.

Захранване и подсветка

Свържете захранването и осветлението

	Обяснения
	Започваме да навлизаме в някои интересни неща! Монтирайте вашия LCD върху макетната платка.
	Ние захранваме макетната платка от нашия Arduino. Свържете +5V към червената релса и Gnd към синята.
	След това ще свържем подсветката на нашия LCD екран. Свържете пин 16 към gnd и пин 15 към +5V. Повечето LCD екрани имат резистори за подсветка. Ако няма резистори на вашия модул, ще трябва да добавите един между 5V и пин 15. За да изчислите стойността на резисторите, проверете максимален токза захранване на подсветката и приблизителната стойност на спада на напрежението от листа с данни. Извадете спада на напрежението от 5V, след това разделете на максималния ток и закръглете до най-близката по-висока стандартна стойност на резистора. Например, ако спадът на напрежението е 3,5 V и токът е 16 mA, стойността на резистора ще бъде: (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, която значително опростява процеса на настройка на щифтове. Едно от предимствата на тази библиотека е, че можете да използвате всякакви щифтове на Arduino, за да свържете LCD щифтовете. Така че в края на това ръководство можете лесно да смените щифтовете, ако това е критично за вашия проект.

Крайна връзка на дисплея

	Обяснения
	Както споменахме по-горе, няма да използваме RW щифта, така че го изтегляме към земята. Това е щифт 5.
	След като свържем RS - това е щифт # 4. Използваме кафявия проводник, за да го свържем към цифров щифт #7 на Arduino.
	С бял проводник свържете щифта EN - щифт # 6 към цифровия щифт цифров # 8 на Arduino.
	Дойде ред и на контактите с данни. DB7 е щифт #14 на LCD дисплея. Той се свързва с оранжевия проводник към щифт #12 на Arduino.
	Остават три пина за данни, DB6 (щифт #13 жълт), DB5 (щифт #12 зелен) и DB4 (щифт #11 син). Те се свързват съответно към щифтове #11, 10 и 9 на Arduino.
	В резултат на Връзката ще получите нещо подобно на снимката вляво.

Използване на символен LCD

Време е да качите скицата в Arduino, за да управлявате LCD екрана. Библиотеката LiquidCrystal е инсталирана в Arduino IDE по подразбиране. Така че просто трябва да изтеглим един от примерите и да коригираме малко според щифтовете, които сме използвали за свързване.

Отворете скицата File→Examples→LiquidCrystal→HelloWorld.

Актуализиране на информация за пинове. Търси се следният ред:

Течнокристален LCD (12, 11, 5, 4, 3, 2);

И го променете на:

Сега можете да компилирате и качите скицата в Arduino.

Регулирайте контраста, ако е необходимо.

Разбира се, можете да използвате LCD дисплея във всякакъв размер. Например снимката по-долу показва LCD работа 20x4.

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

Едно от предимствата на екраните с черен текст на зелен фон е възможността за изключване на подсветката.

Използваме колко реда

Нека видим как LCD борави с дълги съобщения и използва няколко реда. Например, ако промените следния ред:

lcd.print("здравей, свят!");

За следващия:

lcd.print("здравей, свят! това е дълго дълго съобщение");

ЛСД дисплей 16x2 ще съкрати всичко след 16-ия знак:

Но LCD дисплей 20x4 ще пренася непоказани знаци от първия ред до третия (вторият ред ще продължи на четвъртия). Не е много удобно, но на този етап трябва да се примирите. Така че, когато показвате дълги низове, пребройте знаците, за да не надвишите позволената дължина.

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

Тези екрани работят точно като нормалните екрани, но имат три светодиода (червен, зелен, син) за подсветка, така че можете да използвате различни цветове на подсветката.

След като свържете LCD дисплея и го проверите съгласно инструкциите по-горе, свържете светодиодите към аналоговите PWM щифтове на вашия Arduino, за да настроите фино цвета. Ако използвате Ардуино Уно, трябва да имате останали три свободни PWM пина. свържете червения светодиод (щифт 16 на LCD) към цифров 3, зелен светодиод(пин 17) към цифров 5, а синият светодиод (пин 18 на LCD) към цифров 6. LCD модулът вече има резистори, така че не е необходимо да свързвате допълнителни.

Сега качете скицата по-долу в Arduino.

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

#включи

#включи

#define REDLITE 3

#define GREENLITE 5

#define BLUELITE 6

// декларираме броя на контактите, които използваме

// за пренос на данни

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

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

int яркост = 255;

// задайте броя на колоните и редовете на LCD:

lcd.begin(16, 2);

// показване на съобщение на LCD.

lcd.print("RGB 16x2 дисплей");

lcd.setCursor(0,1);

lcd.print("Многоцветен LCD");

pinMode(REDLITE, OUTPUT);

pinMode(GREENLITE, ИЗХОД);

pinMode(BLUELITE, OUTPUT);

яркост = 100;

за (int i = 0; i< 255; i++) {

setBacklight(i, 0, 255-i);

за (int i = 0; i< 255; i++) {

setBacklight(255-i, i, 0);

за (int i = 0; i< 255; i++) {

setBacklight(0, 255-i, i);

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

// настройте червения светодиод - той е по-ярък от останалите!

r = карта (r, 0, 255, 0, 100);

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

r = карта (r, 0, 255, 0, яркост);

g = карта (g, 0, 255, 0, яркост);

b = карта (b, 0, 255, 0, яркост);

// общ анод, така че обърнете!

r = карта (r, 0, 255, 255, 0);

g = карта (g, 0, 255, 255, 0);

b = карта (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. Освен това може да намерите страхотен уебсайт, който върши цялата мръсна работа по създаването на нови символи вместо вас!

Оставете вашите коментари, въпроси и споделете личен опитПо-долу. В дискусията често се раждат нови идеи и проекти!

Как да се сприятеляваме с дъска Arduino с дисплей на знаци? Доста просто! По-долу е всичко по ред и подробности.

Ако искате да получавате информация от Arduino, без да се свързвате с компютър и да извеждате към сериен порт, можете да използвате символен дисплей. Не е толкова трудно да се направи. Удобството от комуникацията е безценно.
За работа използвах J204A символен LCD дисплей, базиран на чипа 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	д	Часовник
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 бита на цикъл. защото Arduino има малко контакти, ние ще използваме 4 - това е повече от достатъчно, за да актуализира информацията на дисплея с невъзприемаема скорост.

Ето как свързвам всичко. Може да изглежда като хаос, но има система. Можете да изберете червени, зелени, жълти и оранжеви проводници. Червените винаги отиват към +5V, зелените отиват към GND, а жълтите и оранжевите са проводниците за свързване към Arduino, които пренасят данни.

Най-важната част е физическата връзка на дисплея. С щракване се отваря във висока резолюция, където всичко се вижда ясно.
R1 - резистор 200OM. Съпротивление, ограничаващо тока, преминаващ през подсветката на дисплея.
R2 - Потенциометър със съпротивление до 10kOM. Завъртаме писалката, избираме контраста на знаците.

И изключително проста скица за показване на няколко реда на екрана.

H> // Свързваме библиотеката за работа с дисплея. /* LiquidCrystal lcd(rs, активиране, d4, d5, d6, d7); създайте променлива от тип LiquidCrystal и определете през кои контакти Arduino работи с дисплея. повече за тази команда тук 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 летлив дълъг x = 5000; // променлива за съхраняване на LiquidCrystal time 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("Стартиране на screenon test!"); ) // Функцията, която ще се изпълни при щракване върху бутона. void screenon() ( x = millis()+5000; // Запомняне на времето за изключване на подсветката. Текущо време на работа +5 секунди. digitalWrite(screenLed,HIGH); // Захранващо напрежение към подсветката на дисплея. ) void цикъл () ( lcd.setCursor(0, 2); // отидете на третия ред lcd.print(x); // и отпечатайте часа, когато дисплеят се изключва lcd.setCursor(0, 3); // отидете на четвъртият ред lcd.print( millis()); // отпечатване на текущото време на работа if (x< millis()) // если время работы выключения наступило >( digitalWrite(screenLed,LOW); // след това изключете дисплея ) )

И резултатът: