Как изменить адрес i2c экрана

Библиотека:

Для работы с символьными графическими дисплеями предлагаем воспользоваться библиотекой LiquidCrystal которая входит в стандартный набор Arduino IDE и предназначена для работы по 8-битному (4-битному) параллельному интерфейсу. Если Ваш дисплей подключается к Arduino по аппаратной шине I2, то Вам нужно установить библиотеку LiquidCrystal_I2C (большинство функций которой повторяют функции первой библиотеки).

Поддерживаемые дисплеи:

Дисплей	Подключение и инициализация
LCD1602 — символьный дисплей (16×02 символов), с параллельным интерфейсом (синий)	#include <LiquidCrystal.h> LiquidCrystal lcd( 2 , 3 , 4 , 5 , 6 , 7 [ , 8 , 9 , 10 , 11 ] ); void setup(){ lcd.begin( 16 , 2 ); } // Пояснение: LiquidCrystal ОБЪЕКТ ( RS , E , D4 , D5 , D6 , D7 ); void setup(){ ОБЪЕКТ.begin( КОЛ_СТОЛБЦОВ , КОЛ_СТРОК ); } // Если используется 8 проводов шины данных, то указываем их все LiquidCrystal ОБЪЕКТ ( RS , E , D0 , D1 , D2 , D3 , D4 , D5 , D6 , D7 );
LCD1602 I2C — символьный дисплей (16×02 символов), с интерфейсом I2C (синий)	#include <Wire.h> #include <LiquidCrystal_I2C.h> LiquidCrystal_I2C lcd( 0x27 или 0x3F , 16 , 2 ); void setup(){ lcd.init(); } // Пояснение: LiquidCrystal_I2C ОБЪЕКТ ( АДРЕС_I2C , КОЛ_СТОЛБЦОВ , КОЛ_СТРОК ); // АДРЕС_I2C может быть либо 0x27, либо 0x3F
LCD1602 I2C — символьный дисплей (16×02 символов), с интерфейсом I2C (зелёный)	#include <Wire.h> #include <LiquidCrystal_I2C.h> LiquidCrystal_I2C lcd( 0x27 или 0x3F , 16 , 2 ); void setup(){ lcd.init(); } // Пояснение: LiquidCrystal_I2C ОБЪЕКТ ( АДРЕС_I2C , КОЛ_СТОЛБЦОВ , КОЛ_СТРОК ); // АДРЕС_I2C может быть либо 0x27, либо 0x3F
LCD2004 — символьный дисплей (20×04 символов), с параллельным интерфейсом (синий)	#include <LiquidCrystal.h> LiquidCrystal lcd( 2 , 3 , 4 , 5 , 6 , 7 [ , 8 , 9 , 10 , 11 ] ); void setup(){ lcd.begin( 20 , 4 ); } // Пояснение: LiquidCrystal ОБЪЕКТ ( RS , E , D4 , D5 , D6 , D7 ); void setup(){ ОБЪЕКТ.begin( КОЛ_СТОЛБЦОВ , КОЛ_СТРОК ); } // Если используется 8 проводов шины данных, то указываем их все LiquidCrystal ОБЪЕКТ ( RS , E , D0 , D1 , D2 , D3 , D4 , D5 , D6 , D7 );
LCD2004 I2C — символьный дисплей (20×04 символов), с интерфейсом I2C (синий)	#include <Wire.h> #include <LiquidCrystal_I2C.h> LiquidCrystal_I2C lcd( 0x27 или 0x3F , 20 , 4 ); void setup(){ lcd.init(); } // Пояснение: LiquidCrystal_I2C ОБЪЕКТ ( АДРЕС_I2C , КОЛ_СТОЛБЦОВ , КОЛ_СТРОК ); // АДРЕС_I2C может быть либо 0x27, либо 0x3F

#1 Пример

Выводим надпись на дисплей LCD1602 подключённый по шине I2C. Для работы с дисплеем LCD2004 нужно изменить 3 строку на LiquidCrystal_I2C lcd(0x27,20,4);

#include <Wire.h>                     //  Подключаем библиотеку для работы с шиной I2C
#include <LiquidCrystal_I2C.h>        //  Подключаем библиотеку для работы с LCD дисплеем по шине I2C
LiquidCrystal_I2C lcd(0x27,16,2);     //  Объявляем  объект библиотеки, указывая параметры дисплея (адрес I2C = 0x27, количество столбцов = 16, количество строк = 2)
                                      //  Если надпись не появилась, замените адрес 0x27 на 0x3F
void setup(){                         //
    lcd.init();                       //  Инициируем работу с LCD дисплеем
    lcd.backlight();                  //  Включаем подсветку LCD дисплея
    lcd.setCursor(0, 0);              //  Устанавливаем курсор в позицию (0 столбец, 0 строка)
    lcd.print("LCD");                 //  Выводим текст "LCD", начиная с установленной позиции курсора
    lcd.setCursor(0, 1);              //  Устанавливаем курсор в позицию (0 столбец, 1 строка)
    lcd.print("www.iarduino.ru");     //  Выводим текст "www.iarduino.ru", начиная с установленной позиции курсора
}                                     //
                                      //
void loop(){}                         //  Код внутри функции loop выполняется постоянно. Но так как мы выводим статичный текст, нам достаточно его вывести 1 раз при старте, без использования кода loop

#2 Пример

Выводим надпись на дисплей LCD1602 подключённый по 4-битной параллельной шине. Для работы с дисплеем LCD2004 нужно изменить 5 строку на lcd.begin(20, 4);

#include <LiquidCrystal.h>            //  Подключаем библиотеку LiquidCrystal для работы с LCD дисплеем
LiquidCrystal lcd(2,3,4,5,6,7);       //  Объявляем объект библиотеки, указывая выводы дисплея (RS,E,D4,D5,D6,D7)
                                      //  Если используется 8 проводов шины данных, то указываем (RS,E,D0,D1,D2,D3,D4,D5,D6,D7)
void setup(){                         //
    lcd.begin(16, 2);                 //  Инициируем работу с LCD дисплеем, указывая количество (столбцов, строк)
    lcd.setCursor(0, 0);              //  Устанавливаем курсор в позицию (0 столбец, 0 строка)
    lcd.print("LCD2004");             //  Выводим текст "LDC1602", начиная с установленной позиции курсора
    lcd.setCursor(0, 1);              //  Устанавливаем курсор в позицию (0 столбец, 1 строка)
    lcd.print("www.iarduino.ru");     //  Выводим текст "www.iarduino.ru", начиная с установленной позиции курсора
}                                     //
                                      //
void loop(){}                         //  Код внутри функции loop выполняется постоянно. Но так как мы выводим статичный текст, нам достаточно его вывести 1 раз при старте, без использования кода loop

#3 Пример

Выводим надпись «Русский язык» на дисплей LCD1602 подключённый по шине I2C:

#include <Wire.h>                     //  Подключаем библиотеку для работы с шиной I2C
#include <LiquidCrystal_I2C.h>        //  Подключаем библиотеку для работы с LCD дисплеем по шине I2C
LiquidCrystal_I2C lcd(0x27,16,2);     //  Объявляем  объект библиотеки, указывая параметры дисплея (адрес I2C = 0x27, количество столбцов = 16, количество строк = 2)
                                      //
uint8_t symbol[6][8] = {              //  Объявляем массив из 6 собственных символов (к и й я з ы), каждый символ состоит из 8 байт
        { 0, 0,18,20,24,20,18, 0 },   //  к
        { 0, 0,17,19,21,25,17, 0 },   //  и
        {10, 4,17,19,21,25,17, 0 },   //  й
        { 0, 0,15,17,15, 5, 9, 0 },   //  я
        { 0, 0,14,17, 6,17,14, 0 },   //  з
        { 0, 0,17,17,29,19,29, 0 }};  //  ы
                                      //
void setup(){                         //
    lcd.init();                       //  Инициируем работу с LCD дисплеем
    lcd.backlight();                  //  Включаем подсветку LCD дисплея
    lcd.createChar(1, symbol[0]);     //  Загружаем 1 символ "к" в ОЗУ дисплея
    lcd.createChar(2, symbol[1]);     //  Загружаем 2 символ "и" в ОЗУ дисплея
    lcd.createChar(3, symbol[2]);     //  Загружаем 3 символ "й" в ОЗУ дисплея
    lcd.createChar(4, symbol[3]);     //  Загружаем 4 символ "я" в ОЗУ дисплея
    lcd.createChar(5, symbol[4]);     //  Загружаем 5 символ "з" в ОЗУ дисплея
    lcd.createChar(6, symbol[5]);     //  Загружаем 6 символ "ы" в ОЗУ дисплея
    lcd.setCursor(0, 0);              //  Устанавливаем курсор в позицию (0 столбец, 0 строка)
    lcd.print("Pycc123 4561"); //  Выводим текст "Pycckий языk", где "Pycc" написано латиницей, а "kий языk" - символами из ОЗУ дисплея
}                                     //  Если нужно вывести символ из ОЗУ дисплея, то пишем  и номер символа
                                      //
void loop(){}                         //  Код внутри функции loop выполняется постоянно. Но так как мы выводим статичный текст, нам достаточно его вывести 1 раз при старте, без использования кода loop

#4 Пример

Выводим время прошедшее после старта на дисплей LCD1602 подключённый по шине I2C:

#include <Wire.h>                          //  Подключаем библиотеку для работы с шиной I2C
#include <LiquidCrystal_I2C.h>             //  Подключаем библиотеку для работы с LCD дисплеем по шине I2C
LiquidCrystal_I2C lcd(0x27,16,2);          //  Объявляем  объект библиотеки, указывая параметры дисплея (адрес I2C = 0x27, количество столбцов = 16, количество строк = 2)
                                           //
uint8_t  tim_D, tim_H, tim_M, tim_S;       //  Объявляем  переменные для хранения дней, часов, минут и секунд.
uint32_t tim;                              //  Объявляем  переменную для хранения общего количества времени прошедшего после старта.
                                           //  Если надпись не появилась, замените адрес 0x27 на 0x3F
void setup(){                              //
    lcd.init();                            //  Инициируем работу с LCD дисплеем
    lcd.backlight();                       //  Включаем подсветку LCD дисплея
}                                          //
                                           //
void loop(){                               //
//  Получаем время прошедшее после старта: //
    tim   =  millis()   / 1000;            //  Получаем общее количество секунд (максимум 4'294'967 сек ≈ 49,7 дней).
    tim_S =  tim        % 60;              //  Получаем секунды: остаток от деления всех секунд на минуту (60 сек).
    tim   = (tim-tim_S) / 60;              //  Получаем общее количество минут.
    tim_M =  tim        % 60;              //  Получаем минуты: остаток от деления всех минут на час (60 мин).
    tim   = (tim-tim_M) / 60;              //  Получаем общее количество часов.
    tim_H =  tim        % 24;              //  Получаем часы: остаток от деления всех часов на день (24 час).
    tim_D = (tim-tim_H) / 24;              //  Получаем общее количество дней.
//  Выводим время прошедшее после старта:  //
    if (millis()%1000<100){                //  Условие выполняется в течении 100 первых миллисекунд каждой новой секунды.
        delay(100);  lcd.setCursor(0, 0);  //  Устанавливаем курсор в позицию (0 столбец, 0 строка).
                     lcd.print("Days: ");  //  Выводим текст.
        if(tim_D<10){lcd.print( 0      );} //  Выводим 0 перед количеством дней.
                     lcd.print(tim_D   );  //  Выводим количество дней.
                     lcd.setCursor(0, 1);  //  Устанавливаем курсор в позицию (0 столбец, 1 строка)
                     lcd.print("Time: ");  //  Выводим текст.
        if(tim_H<10){lcd.print( 0      );} //  Выводим 0 перед количеством часов.
                     lcd.print(tim_H   );  //  Выводим количество часов.
                     lcd.print(':'     );  //  Выводим символ.
        if(tim_M<10){lcd.print( 0      );} //  Выводим 0 перед количеством минут.
                     lcd.print(tim_M   );  //  Выводим количество минут.
                     lcd.print(':'     );  //  Выводим символ.
        if(tim_S<10){lcd.print( 0      );} //  Выводим 0 перед количеством секунд.
                     lcd.print(tim_S   );  //  Выводим количество секунд.
    }                                      //
}                                          //

Функции, общие для библиотек LiquidCrystal и LiquidCrystal_I2C:

• begin(cols,rows,[char_size]); – Инициализация дисплея с указанием количества столбцов, строк и размера символа.
• clear(); – Очистка дисплея с установкой курсора в положение 0,0 (Занимает много времени!).
• home(); – Установка курсора в положение 0,0 (Занимает много времени!).
• display(); – Быстрое включение дисплея (без изменения данных в ОЗУ).
• noDisplay(); – Быстрое выключение дисплея (без изменения данных в ОЗУ).
• blink(); – Включение мигающего курсора (с частотой около 1 Гц).
• noBlink(); – Выключение мигающего курсора.
• cursor(); – Включение подчеркивания курсора.
• noCursor(); – Выключение подчеркивания курсора.
• scrollDisplayLeft(); – Прокрутка дисплея влево. Сдвиг координат дисплея на один столбец влево (без изменения ОЗУ).
• scrollDisplayRight(); – Прокрутка дисплея вправо. Сдвиг координат дисплея на один столбец вправо (без изменения ОЗУ).
• leftToRight(); – Указывает в дальнейшем сдвигать положение курсора, после вывода очередного символа, на один столбец вправо.
• rightToLeft(); – Указывает в дальнейшем сдвигать положение курсора, после вывода очередного символа, на один столбец влево.
• noAutoscroll(); – Указывает в дальнейшем выравнивать текст по левому краю от позиции курсора (как обычно).
• autoscroll(); – Указывает в дальнейшем выравнивать текст по правому краю от позиции курсора.
• createChar(num,array); – Запись пользовательского символа в CGRAM дисплея под указанным номером.
• setCursor(col,row); – Установка курсора в позицию указанную номером колонки и строки.
• print(data); – Вывод текста, символов или цифр на экран дисплея. Синтаксис схож с одноимённой функцией класса Serial.

Функции, реализованные только в библиотеке LiquidCrystal_I2C:

• init(); – Инициализация дисплея. Должна быть первой командой библиотеки LiquidCrystal_I2C после создания объекта. На самом деле данная функция есть и в библиотеке LiquidCrystal, но в той библиотеке она вызывается автоматически (по умолчанию) при создании объекта.
• backlight(); – Включение подсветки дисплея.
• noBacklight(); – Выключение подсветки дисплея.
• setBacklight(flag); – Управление подсветкой (true — включить / false — выключить), используется вместо функций noBacklight и backlight.

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

/* Для шины I2C:                      */
#include <Wire.h>                     //  Подключаем библиотеку для работы с шиной I2C
#include <LiquidCrystal_I2C.h>        //  Подключаем библиотеку для работы с LCD дисплеем по шине I2C
LiquidCrystal_I2C lcd(0x3F,20,4);     //  Объявляем  объект библиотеки, указывая параметры дисплея (адрес I2C = 0x3F, количество столбцов = 20, количество строк = 4)
                                      //
void setup(){                         //
    lcd.init();                       //  Инициируем работу с LCD дисплеем
    lcd.backlight();                  //  Включаем подсветку LCD дисплея
    ...                               //  Выводим информацию, которая должна отображаться при старте
}                                     //
                                      //
void loop(){}                         //
    ...                               //  Выводим информацию которая должна меняться по алгоритму Вашего кода
}                                     //

/* Для 4 проводной параллельной шины: */
#include <LiquidCrystal.h>            //  Подключаем библиотеку LiquidCrystal для работы с LCD дисплеем
LiquidCrystal lcd(2,3,4,5,6,7);       //  Объявляем объект библиотеки, указывая выводы дисплея (RS,E,D4,D5,D6,D7)
                                      //  Если используется 8 проводов шины данных, то указываем (RS,E,D0,D1,D2,D3,D4,D5,D6,D7)
void setup(){                         //
    lcd.begin(16, 2);                 //  Инициируем работу с LCD дисплеем, указывая количество (столбцов, строк)
    ...                               //  Выводим информацию, которая должна отображаться при старте
}                                     //
                                      //
void loop(){}                         //
    ...                               //  Выводим информацию которая должна меняться по алгоритму Вашего кода
}                                     //

Функции управления дисплеем:

/*  Выводим надпись для наблюдения за функциями управления дисплеем: */
    lcd.cursor(0,0);                  //  Устанавливаем курсор в крайний верхний угол дисплея (0 столбец, 0 строка)
    lcd.print("iarduino.ru");         //  Выводим текст "iarduino.ru" (первая буква "i" будет находиться в позиции "0,0", а последняя "u" в позиции "10,0", невидимый курсор в позиции "11,0")
                                      //
    lcd.noDisplay();                  //  Выключаем дисплей (надпись исчезнет с дисплея)
    lcd.display();                    //  Включаем дисплей (надпись появится на дисплее в том же месте)
    lcd.scrollDisplayLeft();          //  Сдвигаем координаты столбцов влево  (на дисплее будет отображаться "arduino.ru" без первой буквы "i", которая выйдет за пределы дисплея, но останется в его ОЗУ)
    lcd.scrollDisplayRight();         //  Сдвигаем координаты столбцов вправо (на дисплее будет отображаться "iarduino.ru" на том же месте, где и была выведена изначально)
    lcd.clear();                      //  Чистим дисплей (надпись безвозвратно исчезнет с дисплея)
    lcd.noBacklight();                //  Отключаем подсветку дисплея
    lcd.backlight();                  //  Включаем  подсветку дисплея
    lcd.setBacklight(0);              //  Отключаем подсветку дисплея
    lcd.setBacklight(1);              //  Включаем  подсветку дисплея

Функции управления курсором:

    lcd.setCursor( 0, 1);             //  Устанавливаем курсор на первый символ второй строки (нумерация строк и столбцов начинается с 0)
    lcd.home();                       //  Устанавливаем курсор на первый символ первой строки (как при вызове lcd.setCursor(0,0);)
    lcd.blink();                      //  Делаем курсор видимым (на месте курсора будет мигать прямоугольник)
    lcd.noBlink();                    //  Делаем курсор невидимым (убираем мигающий прямоугольник)
    lcd.cursor();                     //  Делаем курсор видимым (на месте курсора появится знак подчёркивания)
    lcd.noCursor();                   //  Делаем курсор невидимым (убираем знак подчёркивания)
                                      //  Если курсор попадает на место где есть символ, то этот символ не исчезает

Функции указывающие направление и выравнивание:

    lcd.leftToRight();                //  Указываем курсору сдвигаться вправо                           (Как обычно в европейской письменности)
    lcd.clear(); lcd.setCursor(5,0);      lcd.print("ABC");   //  На дисплее увидим: "     ABC        " (После "A" курсор сдвинулся вправо и вывелась "B", далее курсор сдвинулся вправо и вывелась "C")
    lcd.rightToLeft();                //  Указываем курсору сдвигаться влево                            (Как в письменности справа налево)
    lcd.clear(); lcd.setCursor(5,0);      lcd.print("ABC");   //  На дисплее увидим: "   CBA          " (После "A" курсор сдвинулся влево и вывелась "B", далее курсор сдвинулся влево и вывелась "C")
    lcd.noAutoscroll();               //  Устанавливаем выравнивание по левому краю                     (Как обычно)
    lcd.clear(); lcd.setCursor(5,0);      lcd.print("ABC");   //  На дисплее увидим: "     ABC        " (Как обычно)
    lcd.autoscroll();                 //  Устанавливаем выравнивание по правому краю                    (Координаты дисплея будут сдвинуты влево на количество выведенных символов)
    lcd.clear(); lcd.setCursor(5,0);      lcd.print("ABC");   //  На дисплее увидим: "  ABC           " (Координаты дисплея будут сдвинуты на 3 символа влево, так как после каждого символа совершается вызов функции scrollDisplayLeft)

Функции ввода текста и символов:

#include <Wire.h>                 //  Подключаем библиотеку для работы с шиной I2C
#include <LiquidCrystal_I2C.h>    //  Подключаем библиотеку для работы с LCD дисплеем по шине I2C
LiquidCrystal_I2C lcd(0x27,16,2); //  Объявляем  объект библиотеки, указывая параметры дисплея (адрес I2C = 0x27, количество столбцов = 16, количество строк = 2)
                                  //
uint8_t symbol_d[8] = {0b00000,   //  1 строка символа "д"
                       0b00000,   //  2 строка символа "д"
                       0b00110,   //  3 строка символа "д"
                       0b01010,   //  4 строка символа "д"
                       0b01010,   //  5 строка символа "д"
                       0b01010,   //  6 строка символа "д"
                       0b11111,   //  7 строка символа "д"
                       0b10001};  //  8 строка символа "д"   Весь массив можно записать одной строкой: uint8_t symbol_d[8]={0,0,6,10,10,10,31,17};
                                  //
uint8_t symbol_i[8] = {0b00000,   //  1 строка символа "и"
                       0b00000,   //  2 строка символа "и"
                       0b10001,   //  3 строка символа "и"
                       0b10011,   //  4 строка символа "и"
                       0b10101,   //  5 строка символа "и"
                       0b11001,   //  6 строка символа "и"
                       0b10001,   //  7 строка символа "и"
                       0b00000};  //  8 строка символа "и"   Весь массив можно записать одной строкой: uint8_t symbol_i[8]={0,0,17,19,21,25,17,0};
void setup(){                     //
    lcd.init();                   //  Инициируем работу с LCD дисплеем
    lcd.backlight();              //  Включаем подсветку LCD дисплея
    lcd.createChar(1,symbol_d);   //  Загружаем в память дисплея первый символ
    lcd.createChar(2,symbol_i);   //  Загружаем в память дисплея второй символ
    lcd.clear();                  //  Чистим экран
    lcd.setCursor(0,0);           //  Устанавливаем курсор в крайний верхний угол
    lcd.print("Pa12o");         //  Выводим текст "Paдиo" при этом символы 'P', 'a' , 'o' пишем латиницей,
}                                 //  а символы 'д', 'и' выводим из памяти дисплея, указывая их номера
                                  //
void loop(){                      //
    lcd.setCursor(0,1);  lcd.print("                ");                          // стираем всю нижнюю строку
    lcd.setCursor(0,1);  lcd.print("i"); lcd.print("arduino"); lcd.print(".ru"); // выводим текст "i" "arduino" ".ru" в нижней строке
    delay(2000);                                                                 // ждём 2 секунды
    lcd.setCursor(0,1);  lcd.print("                ");                          // стираем всю нижнюю строку
    lcd.setCursor(0,1);  lcd.print(12.345);                                      // выводим число 12.34 (выводится 2 знака после запятой)
    delay(2000);                                                                 // ждём 2 секунды
    lcd.setCursor(0,1);  lcd.print("                ");                          // стираем всю нижнюю строку
    lcd.setCursor(0,1);  lcd.print(12, HEX);                                     // выводим число 12 в виде шестнадцатиричного числа
    delay(2000);                                                                 // ждём 2 секунды
    lcd.setCursor(0,1);  lcd.print("                ");                          // стираем всю нижнюю строку
    lcd.setCursor(0,1);  lcd.print(1);                                           // выводим число 1
    delay(2000);                                                                 // ждём 2 секунды
}

Описание

Классический LCD дисплей, раньше такие стояли в кассовых аппаратах и офисной технике.

• Бывают разного размера, самый популярный – 1602 (16 столбцов 2 строки), есть ещё 2004, 0802 и другие. В наборе идёт 1602.
• Снабжён отключаемой светодиодной подсветкой. Существует несколько вариантов, например синий фон белые буквы, зелёный фон чёрные буквы, чёрный фон белые буквы и проч. В наборе идёт с зелёным фоном и чёрными буквами.
• Сам по себе требует для подключения 6 цифровых пинов, но китайцы выпускают переходник на шину I2C на базе PCF8574, что сильно упрощает подключение и экономит пины. В наборе идёт дисплей с припаянным переходником.
• На переходнике также распаян потенциометр настройки контрастности (синий параллелепипед с крутилкой под крестовую отвёртку). В зависимости от напряжения питания нужно вручную подстроить контрастность. Например при питании платы от USB на пин 5V приходит ~4.7V, а при внешнем питании от адаптера – 5.0V. Контрастность символов на дисплее будет разной!
• Переходник может иметь разный адрес для указания в программе: 0х26, 0x27 или 0x3F, об этом ниже.

Подключение

Дисплей подключается по шине I2C, выведенной на пины:

• Arduino: SDA – A4, SCL – A5
• Wemos: SDA – D2, SCL – D1
• Питание: 5V в обоих случаях

Библиотеки

Для этого дисплея существует несколько библиотек, я рекомендую LiquidCrystal_I2C от Frank de Brabander. Библиотека идёт в архиве к набору, а также её можно скачать через менеджер библиотек по названию LiquidCrystal_I2C и имени автора. Репозиторий на GitHub.

print(data);          // вывести (любой тип данных)
setCursor(x, y);      // курсор на (столбец, строка)
clear();              // очистить дисплей
home();               // аналогично setCursor(0, 0)
noDisplay();          // отключить отображение
display();            // включить отображение
blink();              // мигать курсором на его текущей позиции
noBlink();            // не мигать
cursor();             // отобразить курсор
noCursor();           // скрыть курсор
scrollDisplayLeft();  // подвинуть экран влево на 1 столбец
scrollDisplayRight(); // подвинуть экран вправо на 1 столбец
backlight();          // включить подсветку
noBacklight();        // выключить подсветку
createChar(uint8_t, uint8_t[]);                     // создать символ
createChar(uint8_t location, const char *charmap);  // создать символ

Пример вывода

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

• Прошить пример “Демо”
• Если дисплей показывает чёрные прямоугольники или пустой экран – крутим контраст
• Если кроме чёрных прямоугольников и пустого экрана ничего не видно – меняем адрес в программе: 0х26, 0x27 и 0x3F
• Снова крутим контраст, должно заработать
• Если не работает – проверяем подключение и повторяем сначала
• Примечание: в наборе должны идти дисплеи с адресом 0x27, но может зависеть от партии!

// базовый пример инициализации и вывода текста
#include <LiquidCrystal_I2C.h>  // подключаем библу

// адрес дисплея 0x3f или 0x27
// размер дисплея 16x2 (поддерживаются и другие, например 20x4)
LiquidCrystal_I2C lcd(0x27, 16, 2);  // адрес, столбцов, строк

void setup() {
  lcd.init();           // инициализация
  lcd.backlight();      // включить подсветку  
  lcd.setCursor(1, 0);  // столбец 1 строка 0
  lcd.print("Hello, world!");
  lcd.setCursor(4, 1);  // столбец 4 строка 1
  lcd.print("GyverKIT");
}

void loop() {
}

#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 16, 2);

void setup() {
  lcd.init();           // инициализация
  lcd.backlight();      // включить подсветку  

  // строки для вывода
  char s1[] = "Hello, world!";
  char s2[] = "GyverKIT";

  lcd.setCursor(1, 0);
  for (int i = 0; i < strlen(s1); i++) {
    lcd.print(s1[i]);
    delay(100);
  }

  lcd.setCursor(4, 1);
  for (int i = 0; i < strlen(s2); i++) {
    lcd.print(s2[i]);
    delay(100);
  }
}

void loop() {
}

Символы дисплея

В памяти дисплея содержится 255 символов, это английские буквы, стандартные символы и китайские буквы. Стандартные символы, такие как [email protected]#$%&()* и так далее выводятся через print(), остальные можно вывести по их коду при помощи write():

Из интересных:

• Стрелка вправо – 126
• Стрелка влево – 127
• Символ градуса – 223
• Прямоугольник – 255

#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 16, 2);

void setup() {
  lcd.init();           // инициализация
  lcd.backlight();      // включить подсветку

  // выводим стрелочку, надпись temp, число и градус
  lcd.write(126);
  lcd.print("Temp: ");
  lcd.print(25.6);
  lcd.write(223); 
}

void loop() {
}

Свои символы

Библиотека поддерживает создание “своих” дополнительных символов размером 5х7 точек, можно воспользоваться онлайн-генератором кодов символов – ссылка. Для компактности рекомендую переключить его в HEX. Вот так будет выглядеть “символ” крестик: byte myX[] = {0x00, 0x00, 0x11, 0x0A, 0x04, 0x0A, 0x11, 0x00};

Дисплей имеет 8 ячеек под сторонние символы, добавляются они при помощи createChar(номер, массив), где номер – от 0 до 7, а массив – имя массива с данными, которое мы создали для символа. Выводятся символы при помощи write(номер).

Важный момент: после вызова createChar сбрасывается позиция вывода текста, нужно обязательно вызвать setCursor!

// выводим кастомные символы

#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 16, 2);

byte bell[]  = {0x4, 0xe, 0xe, 0xe, 0x1f, 0x0, 0x4};
byte note[]  = {0x2, 0x3, 0x2, 0xe, 0x1e, 0xc, 0x0};
byte clock[] = {0x0, 0xe, 0x15, 0x17, 0x11, 0xe, 0x0};
byte heart[] = {0x0, 0xa, 0x1f, 0x1f, 0xe, 0x4, 0x0};
byte duck[]  = {0x0, 0xc, 0x1d, 0xf, 0xf, 0x6, 0x0};
byte check[] = {0x0, 0x1, 0x3, 0x16, 0x1c, 0x8, 0x0};
byte cross[] = {0x0, 0x1b, 0xe, 0x4, 0xe, 0x1b, 0x0};
byte retarrow[] = {0x1, 0x1, 0x5, 0x9, 0x1f, 0x8, 0x4};

void setup() {
  lcd.init();           // инициализация
  lcd.backlight();      // включить подсветку

  // загружаем все сразу
  lcd.createChar(0, bell);
  lcd.createChar(1, note);
  lcd.createChar(2, clock);
  lcd.createChar(3, heart);
  lcd.createChar(4, duck);
  lcd.createChar(5, check);
  lcd.createChar(6, cross);
  lcd.createChar(7, retarrow);

  // выводим для примера все
  lcd.home();
  lcd.write(0);
  lcd.write(1);
  lcd.write(2);
  lcd.write(3);
  lcd.write(4);
  lcd.write(5);
  lcd.write(6);
  lcd.write(7);
}

void loop() {
}

Важная информация по дисплеям

Данная информация относится ко всем дисплеям.

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

Уроки по таймерам:

• Функции времени
• Как написать скетч
• Видеоурок

Рассмотрим два примера.

// оптимально выводим значение с потенциометра по таймеру
// текстовый лейбл не выводим, дисплей не очищаем
// потенциометр подключен на A0
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 16, 2);

void setup() {
  lcd.init();           // инициализация
  lcd.backlight();      // включить подсветку
  lcd.home();
  lcd.print("Pot. val: ");
}

void loop() {
  static uint32_t tmr;
  // таймер на 10 раз в секунду
  if (millis() - tmr >= 100) {
    tmr = millis();
    lcd.setCursor(10, 0);
    lcd.print(analogRead(0));
    lcd.print("   ");
  }
}

// выводим счётчик нажатий по событию
#include <EncButton.h>
EncButton<EB_TICK, 3> btn(INPUT_PULLUP);  // кнопка на D3

#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 16, 2);

void setup() {
  lcd.init();           // инициализация
  lcd.backlight();      // включить подсветку
}

void loop() {
  btn.tick();
  if (btn.isClick()) {
    static int count = 0;
    count++;

    // очищаем и выводим текст и значение
    lcd.home();
    lcd.clear();
    lcd.print("Counter: ");
    lcd.print(count);
  }
}

Вывод на русском языке

Данный дисплей работает следующим образом: шрифт (буквы, цифры, символы) зашит в память контроллера дисплея, поэтому язык определяется моделью контроллера. Самые распространённые – с английским и китайским, как в табличке выше. Есть дисплеи с кириллицей (вместо китайского), но они сильно дороже. Также у нас есть 8 ячеек для хранения своих символов, и с их помощью можно вполне организовать вывод на другом языке. Что касается русского – большая часть букв совпадает по написанию, и это сильно упрощает задачу. Есть готовые библиотеки, где это уже реализовано, например LCD_1602_RUS_ALL от ssilver2007. Библиотека поддерживает также украинский язык для LCD1602. Пример:

#define _LCD_TYPE 1  // для работы с I2C дисплеями
#include <LCD_1602_RUS_ALL.h>
LCD_1602_RUS lcd(0x27, 16, 2);

void setup() {
  lcd.init();
  lcd.backlight();
  lcd.setCursor(0, 0);
  lcd.print("Привет!");
}

void loop() {
}

Домашнее задание

• Освоить библиотеку LiquidCrystal_I2C, попробовать все функции из документации
• Создать несколько символов и вывести их
• Оптимизировать последний пример: не очищать дисплей и не выводить лейбл при клике, менять только значение

Подключение I2C дисплея к ардуино. Русификация текста. 

Сегодня вы узнаете про подключение I2C дисплея к Ардуино, а точнее как сделать из простого LCD1602 i2c дисплей используя модуль I2C. А ещё как изменять адрес на шине I2C, как выводить русский(кириллицу) шрифт и многое другое.

Это история о том, как был у меня дисплей LCD 2004 и подключался он напрямую, то есть аж 8 проводами и надоело мне это сильно. И решил я упростить себе и надеюсь и вам тоже работу и купил в Китае модуль-адаптер I2C .
I2C адаптер  — это преобразователь интерфейсов обеспечивающий обмен между параллельной шиной LCD и шиной I2C. И вместо 8 контактов на Ардуино вам понадобится всего 2, а к самой шине I2C можно подключить огромное число различных устройств.
Разницу можно видеть невооружённым взглядом.

Так что же такое I2C.

I2C  — это последовательный протокол обмена данными. Для передачи данных используются 2 линии связи. 
SDA (Serial Data)  — шина последовательных данных и
SCL (Serial Clock). — шина тактирования. 

Шины Управляются низким сигналом, поэтому они должны быть подтянуты к  шине питания через резисторы которые обычно уже припаяны к модулям I2C. Но при использовании нескольких модулей могут быть проблемы если у каждого модуля есть подтягивающие резисторы то их надо выпаять и оставить всего по одному резистору.
Должно быть хотя бы одно ведущее устройство и до 127 ведомых. Обычно в качестве ведущего используют Ардуино.
У каждого ведомого должен быть свой уникальный адрес по которому к нему будет обращаться ведущий.

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

Теперь что мы имеем. У нас есть простой дисплей на 20 символов и 4 строчки с подпаянными 16 контактами. И есть модуль адаптер I2C так же с подпаянными 16 контактами.
Нам нужно соединить все контакты на модуле с контактами на дисплее. Они расположены так, что вам ничего не надо выдумывать, а просто выпаять штырьки на дисплее и вставить в освободившееся место контакты с адаптера.
Если вы не любите или не хотите паять, то можно воспользоваться макетной платой и вставить дисплей и адаптер соединив первый и последующие выводы.

Вот и всё устройство готово и может уже работать., Но я всё же пойду припаяю, так как это более надёжно и мне так больше нравится. Так что подождите, это не долго. Ну вот и всё.
Как видите, ничего сложного в замене штырьков на адаптер нет. Я просто выпаял их и вместо них запаял I2C адаптер. И теперь вместо сборки целой схемы и кучи проводов мне надо будет подключить всего 2 провода, а куда и как я покажу чуть позже.

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

Рассмотрим работу скетча Сканер I2C.

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

У меня сейчас подключено только дисплей, поэтому сканер нашёл только его. Как можно видеть, дисплей определился по адресу 027 
Теперь давайте изменим адрес на другой. Для этого на модуле есть три пары контактных площадок которые нужно замкнуть и тогда у вас изменится адрес. Всего возможно сменить до 4 адресов.
Сначала замыкаем первую пару контактов и видим, что адрес изменился на 026. Если убрать перемычку, то адрес снова станет 027.
Я специально в скетче сделал задержку в 5 секунд, чтобы было проще видеть изменения.
Теперь замкнём вторую пару. Адрес изменился на 025. Отпускаем и он снова стал 027.
Ну и у нас осталась третья пара. Вы наверное думаете что по логике адрес должен быть 024. А вот и нет. Адрес стал 023. Почему так я не знаю. Кто знает напишите. А может просто так захотел производитель дисплея.
Теперь, что мы имеем.
Мы можем обратиться к нашему дисплею по адресам, 027, 026, 025, 023. Так что если у вас какое-то устройство будет на одном из этих адресов, вы сможете изменить его и у вас не будет конфликтов.
Продолжаем дальше.

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

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

Здесь указываем адрес устройства которое определил сканер. И какой у вас дисплей. 16 или 20 знаков.
Здесь мы инициализируем дисплей.
Включаем на нём подсветку. 
Устанавливаем курсор на то  знакоместо экрана с которого хотим начать печатать текст. Устанавливаем нужную строку. Отсчёт ведётся с 0.
Выводим текст. Перемещаем курсор на 2 строку.
Выводим другую надпись. И так далее.
Прошиваем контроллер и смотрим результат. Мы видим, что обе надписи вывелись на экран и именно там где мы и хотели. 

Теперь усложним задачу. Выведем текст кириллицей. И не важно поддерживает ваш дисплей кириллицу или нет, вам поможет вот эта библиотека LCD 16 02 RUS ALL
По моему мнению – это самая лучшая библиотека для вывода кириллицы на экран. Она работает с разными дисплеями с 16 и 20 символами и с подключением по I2C и прямым подключением.

Выводить будем алфавит. Мне писали, что не все символы в библиотеке показываются правильно. Вот сейчас и проверим. Я буду выводить по 10 букв в строку, сначала заглавными буквами, а потом прописными. Для лучшего восприятия, я сделал паузы в 5 секунд между выводом строк. 
Как я уже неоднократно говорил, вы не можете одновременно вывести больше 8 своих символов, а каждая буква, отличающаяся по начертанию от латинской — это свой символ. Избежать этого можно очисткой экрана. Главное, чтобы одновременно на экране не было больше 8 не стандартных букв.

Ну вот вроде всё что хотел рассказал. Если вам понравилось это видео и вы хотите и дальше смотреть интересные видео, то пишите комментарии, ставьте лайки, размещайте и делитесь моими видео. Это очень мне поможет.
 

В этом уроке

• Что такое I2C и в чем её удобство
• Адресация модулей
  
• Как изменить адрес модуля и почему это важно

Видео версия урока

Назначение и принцип работы шины I2C

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

Все модули, которые управляются по шине I2C, на самом деле соединены одним шлейфом. Это позволяет, используя всего два вывода контроллера, подключить к нему более сотни устройств! (Поясним: мотор подключен шиной из 4-х проводов: два из них — питание: + и -, и еще два — именно провода шины I2C, поэтому, можно сказать, что для управления модулем требуется всего два провода).

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

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

Изменение I2C-адресов модулей

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

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

Для этого потребуется открутить 4 винта и снять модуль питания, после чего достать контроллер.

*Шлейфы на картинке не показаны, их можно не отключать

После этого подключаем к контроллеру модуль правый мотор, как показано на рисунке (модуль с платы снимать не нужно):

После того, как Вы подключили правый мотор к контроллеру, загрузите следующий скетч. После загрузки адрес модуля будет изменён на тот, который Вы указали в начале скетча (3 строка).

// ПРИМЕР СМЕНЫ АДРЕСА МОДУЛЯ I2C-FLASH:          // * Строки со звёздочкой являются необязательными
                                                  //
uint8_t newAddress = 0x0A;                        //   Назначаемый модулю адрес (0x07 < адрес < 0x7F)
                                                  //
#include <Wire.h>                                 // * Подключаем библиотеку для работы с аппаратной шиной I2C
#include <iarduino_I2C_Address.h>                 //   Подключаем библиотеку для работы с адресами модулей линейки I2C-flash
iarduino_I2C_Address j;                           //   Объявляем объект j для работы с модулем I2C-flash. Адрес модуля будет определен автоматически
                                                  //   Если адрес модуля известен, то его можно указать при создании объекта, например, iarduino_I2C_Address j(0xA0);
void setup(){                                     //
     delay(500);                                  // * Ждём завершения переходных процессов, связанных с подачей питания
     Serial.begin(9600);                          //
     while(!Serial){;}                            // * Ждём завершения инициализации шины UART
     j.begin();                                   //   Инициируем работу с модулем
     while(!j){;}                                 // * Запрещаем дальнейшую работу, если модуль не инициализирован
     Serial.print("Найден модуль 0x");            //
     Serial.println( j, HEX );                    //   Выводим текущий адрес модуля
     j=newAddress;                                //   Меняем адрес модуля на newAddress
     if(j==newAddress){                           // * Проверяем новый адрес модуля
         Serial.println("Адрес модуля изменён");  // * Успех записи нового адреса можно проверить по результату присвоения: if( j=newAddress ){/*успешно*/;}else{/*провал*/;}
     }                                            // * 
     Serial.print("Текущий адрес модуля 0x");     //
     Serial.println( j, HEX );                    //   Выводим текущий адрес модуля
}                                                 //
                                                  //
void loop(){                                      //
}                                                 //

Адреса для модулей:

Больше устройств I2C на машинке не предвидится. Остальные модули работают не по шине I2C (они просто подключаются к выводам контроллера).

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

Измените таким же образом адреса всех модулей на указанные в таблице.

Теперь можно снова собрать машинку и двигаться дальше. Наши модули готовы к работе.

Проверка моторов

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

#include <Wire.h>                       // Подключаем библиотеку для работы с шиной I2C
#include <iarduino_I2C_Motor.h>         // Подключаем библиотеку для работы с мотором
iarduino_I2C_Motor  mot_R (0x0A);       // Объявляем объект mot_R для правого мотора с указанием адреса 0х0А
iarduino_I2C_Motor  mot_L (0x0B);       // Объявляем объект mot_L для левого мотора с указанием адреса 0х0В
void setup(){                         
  Serial.begin(9600);                                                           //  Инициируем работу монитора порта на скорости 9600 бод
  if (mot_R.begin()) Serial.println("Отлично, найден мотор с адресом 0x0A");    //  Инициируем работу с правым мотором. Если инициализация прошла успешно, выводим сообщение об успехе
  else Serial.println("Что-то не так... Мотор с адресом 0x0A не найден");       //  Иначе - сообщение об ошибке
  if (mot_L.begin()) Serial.println("Отлично, найден мотор с адресом 0x0B");    //  Инициируем работу с левым мотором. Если инициализация прошла успешно, выводим сообщение об успехе
  else Serial.println("Что-то не так... Мотор с адресом 0x0B не найден");       //  Иначе - сообщение об ошибке
}                                                
void loop(){                                    
}

LCD дисплей Arduino позволяет визуально отображать данные с датчиков. Расскажем, как правильно подключить модуль QAPASS LCD к Arduino по I2C и рассмотрим основные команды инициализации и управления LCD 1602. Также рассмотрим различные функции в языке программирования C++, для вывода текстовой информации на дисплее, который часто требуется использовать в проектах Ардуино.

Как подключить к Arduino LCD без I2C

Текстовый экран 16×2 используется для вывода информации с датчиков, отображения меню или подсказок. На экране выводятся черные символы размером 5×8 пикселей. Встроенная подсветка включается подачей питания на пины модуля. Текстовый дисплей 16×2 без модуля IIC подключается к микроконтроллеру через 16 контактов. Распиновка экрана с примером подключения размещена ниже.

Жидкокристаллический дисплей имеет 2 ряда по 16 символов, отсюда и его название LCD 1602. В память устройства встроено 192 знака, еще 8 знаков может определить сам пользователь. При подключении дисплея без IIC модуля потребуется использовать 6 портов общего назначения у микроконтроллера Arduino, не считая питания. Соберите схему, как на картинке выше и загрузите следующую программу в плату.

Скетч. Ардуино и LCD 1602 без I2C модуля

// подключаем библиотеку для работы с экраном
#include <LiquidCrystal.h>

// объявляем объект, для управления дисплеем указываем пины
LiquidCrystal LCD(13, 12, 11, 10, 9, 8);
 
void setup() {
   LCD.begin(16, 2);      // указываем количество строк и столбцов

   LCD.setCursor(1, 0);     // ставим курсор на 1 символ первой строки
   LCD.print("I LOVE");     // печатаем сообщение на первой строке
  
   LCD.setCursor(8, 1);        // ставим курсор на 1 символ второй строки
   LCD.print("ARDUINO");  // печатаем сообщение на второй строке
}
 
void loop() {

}

Пояснения к коду:

1. для данного примера используется стандартная библиотека LiquidCrystal.h для QAPASS, которая не поддерживает кириллицу;
2. чтобы упростить схему и не использовать большое количество пинов микроконтроллера, следует использовать дисплей с модулем I2C.

Принцип работы I2C интерфейса Arduino

I2C — последовательная двухпроводная шина для связи интегральных схем внутри электронных приборов, известна, как I²C или IIC (англ. Inter-Integrated Circuit). I²C была разработана фирмой Philips в начале 1980-х годов, как простая 8-битная шина для внутренней связи между схемами в управляющей электронике (например, в компьютерах на материнских платах, в мобильных телефонах и т.д.).

В простой системе I²C может быть несколько ведомых устройств и одно ведущее устройство, которое инициирует передачу данных и синхронизирует сигнал. К линиям SDA (линия данных) и SCL (линия синхронизации) можно подключить несколько ведомых устройств. Часто ведущим устройством является контроллер Ардуино, а ведомыми устройствами: часы реального времени или LCD Display.

Как подключить LCD 1602 I2C к Arduino

Жидкокристаллический дисплей 1602 с I2C модулем подключается к плате Ардуино всего 4 проводами — 2 провода данных и 2 провода питания. Подключение QAPASS 1602a к Arduino проводится стандартно для шины I2C: вывод SDA подключается к порту A4, вывод SCL – к порту A5. Питание LCD дисплея осуществляется от порта +5V. Смотрите подробнее схему подключения жк монитора 1602 на фото ниже.

После подключения LCD монитора к Ардуино через I2C вам потребуется установить библиотеку LiquidCrystal_I2C.h для работы с LCD дисплеем по интерфейсу I2C и библиотека Wire.h (имеется в стандартной программе Arduino IDE). Скачать рабочую библиотеку LiquidCrystal_I2C.h для LCD 1602 с модулем I2C можно на странице Библиотеки для Ардуино на нашем сайте по прямой ссылке с Google Drive.

Скетч для жк дисплея QAPASS 1602 I2C

#include <Wire.h> // библиотека для управления устройствами по I2C 
#include <LiquidCrystal_I2C.h> // подключаем библиотеку для QAPASS 1602

LiquidCrystal_I2C LCD(0x27,16,2); // присваиваем имя LCD для дисплея

void setup() {
   LCD.init(); // инициализация LCD дисплея
   LCD.backlight(); // включение подсветки дисплея
   
   LCD.setCursor(1, 0);     // ставим курсор на 1 символ первой строки
   LCD.print("I LOVE");     // печатаем сообщение на первой строке
  
   LCD.setCursor(8, 1);        // ставим курсор на 1 символ второй строки
   LCD.print("ARDUINO");  // печатаем сообщение на второй строке
}

void loop() {
   LCD.noDisplay(); // выключаем и включаем надпись на дисплее
   delay(1000);
   LCD.display();
   delay(1000);
}

Пояснения к коду:

1. перед выводом информации на дисплей, необходимо задать положение курсора командой setCursor(0,1), где 0 — номер символа в строке, 1 — номер строки;
2. в отличии от clear() — команда noDisplay() не удаляет надпись, а отключает ее вывод на дисплее и ее можно снова показать.

Подключение двух дисплеев по I2C

По умолчанию у всех дисплеев 1602 с модулем I2C адрес — «0x27», но можно изменить адрес текстового экрана и узнать его через сканер iic шины. Таким образом, если у вас есть необходимость подключить к одному микроконтроллеру несколько дисплеев 1602, то следует изменить адреса устройств, что бы не было совпадений. Давайте рассмотрим, каким образом изменить IIC адрес жидкокристаллического дисплея.

Если перевернуть дисплей и посмотреть на IIC модуль (смотри фото выше), то там можно заметить контакты, обозначенные, как «A0»,  «A1» и «A2». Если по умолчанию LCD имеет адрес «0x27» на шине IIC, то замкнув перемычку «A0», адрес дисплея сменится на «0x26». Таким образом, к одной шине можно подключить несколько дисплеев, не забыв указать их адреса в скетче — смотри следующий пример кода.

Скетч. Подключение нескольких LCD 1602 к шине i2c

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

#include <Wire.h> // библиотека для шины I2C 
#include <LiquidCrystal_I2C.h> // библиотека для 16x2 I2C

LiquidCrystal_I2C LCD1(0x27, 16, 2); // присваиваем имя первому дисплею
LiquidCrystal_I2C LCD2(0x26, 16, 2); // присваиваем имя второму дисплею

void setup() {
   LCD1.init(); // инициализация первого дисплея
   LCD2.init(); // инициализация второго дисплея
   LCD1.backlight(); // включение подсветки
   LCD2.backlight(); // включение подсветки
}

void loop() {
   // прокручиваем надпись на первом дисплее
   LCD1.setCursor(1, 0);
   LCD1.print("I LOVE ARDUINO");
   LCD1.scrollDisplayLeft();
   // прокручиваем надпись на втором дисплее
   LCD2.setCursor(1, 0);
   LCD2.print("HELLO WORLD");
   LCD2.scrollDisplayRight();
  
   delay(300);
}

Пояснения к коду:

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

Библиотека LiquidCrystal_I2C.h для LCD дисплея

В следующем примере разберем сразу несколько возможностей, которая дает библиотека LiquidCrystal_I2C Arduino (на самом деле мы взяли команды из стандартной библиотеки). Продемонстрируем вывод мигающего курсора, как убрать надпись с экрана на некоторое время без удаления и, как управлять подсветкой дисплея из кода программы. Для этого загрузите в Ардуино следующий код программы.

Скетч. Описание библиотеки LiquidCrystal_I2C.h

#include <Wire.h> // библиотека для управления устройствами по I2C 
#include <LiquidCrystal_I2C.h> // подключаем библиотеку для QAPASS 16x2

LiquidCrystal_I2C LCD(0x27,16,2); // присваиваем имя LCD для дисплея

void setup() {
   LCD.init();    // инициализация LCD дисплея
   LCD.backlight(); // включение подсветки дисплея

   LCD.blink(); // включение мигающего курсора
   delay(2000);
   LCD.noBlink();
   
   LCD.setCursor(1, 0);    // ставим курсор на 1 символ первой строки
   LCD.print("I LOVE");   // печатаем сообщение на первой строке
   LCD.setCursor(8, 1);        // ставим курсор на 1 символ второй строки
   LCD.print("ARDUINO");  // печатаем сообщение на второй строке
   delay(2000);

   LCD.cursor(); // включение текущей позиции курсора
   delay(2000);
   LCD.noCursor();
}

void loop() {
   LCD.noBacklight(); // выключаем и включаем подсветку экрана
   delay(1000);
   LCD.backlight();
   delay(1000);
}

Пояснения к коду:

1. библиотека LiquidCrystal_I2C.h содержит встроенные команды для управления LCD дисплея по шине I²C и позволяет значительно упростить скетч.
2. читайте также про возможность авто прокрутки строки на дисплее Ардуино.

Заключение: Используя программы Ардуино для lcd 1602a из этой записи и схему  подключения lcd 1602 к Ардуино по i2c вы сможете применять данный дисплей в проектах Ардуино с LCD и в различных примерах. Если у вас остались вопросы по использованию монитора 1602 i2c Arduino — оставляйте их в комментариях на этой странице. Возможно, то что вы ищете уже решено и есть в ответах.

Время прочтения
2 мин

Просмотры 12K

Приветствую всех жителей Хабра!

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

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

Совсем недавно меня, как и многих пользователей, озадачило отсутствие возможности изменить адрес у данного датчика. Гугл, конечно же, выдал кучу статей о всяких мультиплексорах для шины I2C от «купить в известном всем китайском интернет-магазине» до «сделать схему своими руками». Нигде не было вариантов без паяльника и дополнительных расходов. Это не могло не расстроить так как нужно было решить проблему здесь и сейчас (заказчики такие заказчики). Хочу рассказать о более легком и непринужденном, очень простом выходе из данной ситуации. Заинтриговала? Тогда рассказываю.

Исходные данные: Arduino mega и 4 датчика HTU21.

Задача: необходимо подключить все датчики htu по шине I2C и считывать значения. Причем данные сенсоры — не единственные ведомые устройства на данной шине (в планах еще ЖК экран и другие датчики).

Что мы знаем? У датчика HTU21 фиксированный адрес на шине — 0x40 1. Как, имея микроконтроллер и 4 датчика с одинаковыми адресами на шине, обращаться к конкретному устройству без лишних микросхем?

Все оказывается довольно просто:

1. подключаем землю, scl и sda как обычно (не забываем про подтягивающие резисторы для линии данных и синхронизации);
2. подключаем провод питания каждого датчика к цифровому входу на Arduino (вы уже наверняка поняли куда я веду)
3. поочередно подаем HIGH на каждый цифровой вход, питающий отдельный датчик и, после задержки, считываем значение с запитанного сенсора.
4. подаем сигнал LOW для этого датчика и повторяем цикл для других сенсоров.

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

Не зря говорится, что все гениальное — просто!

Листинг прилагается:

/* функция, считывающая значение температуры
и влажности с датчиков HTU21 и датчика BME280 */

void greenhouseHT()
{  
    delay(30);
    rooms[3].TempA = bme.readTemperature();
    delay(30);
    rooms[3].HumA = bme.readHumidity(); 
    delay(30);  

  for (int i=0; i<3; i++)
  {
    digitalWrite(HTU21_pins[i], HIGH);
    delay(30);
    rooms[i].HumA   = myGreenhouseHumidity.readHumidity(); 
    rooms[i].TempA  = myGreenhouseHumidity.readTemperature(); 
    delay(30);
    digitalWrite(HTU21_pins[i], LOW);
    delay(30);
  }
  digitalWrite(pin_HTU21_1, HIGH);
}