MicroPython: I2C LCD-дисплей с ESP32/ESP8266
Узнайте, как подключить I2C LCD (жидкокристаллический дисплей) к платам ESP32 и ESP8266 NodeMCU, программируемым на MicroPython. Вы узнаете, как подключить дисплей к платам, какие библиотеки использовать, а также как написать код для отображения статического текста, бегущей строки и пользовательских символов.
Используете Arduino IDE? Тогда перейдите к этому руководству: Как использовать I2C LCD с ESP32 в Arduino IDE (совместимо с ESP8266).
Содержание:
В этом руководстве мы рассмотрим следующие темы:
Предварительные требования
Для работы с этим руководством вам необходимо установить прошивку MicroPython на плату ESP32 или ESP8266. Также вам потребуется IDE для написания и загрузки кода на плату. Мы рекомендуем использовать Thonny IDE или uPyCraft IDE:
Thonny IDE:
uPyCraft IDE:
Подробнее о MicroPython: MicroPython Programming with ESP32 and ESP8266
Необходимые компоненты
Для работы с этим руководством вам понадобятся следующие компоненты:
Макетная плата (опционально)
Соединительные провода (опционально)
Знакомство с LCD-дисплеем
Одним из самых простых и дешёвых экранов является жидкокристаллический дисплей (LCD). LCD-дисплеи встречаются в повседневных электронных устройствах, таких как торговые автоматы, калькуляторы, паркоматы и принтеры, и идеально подходят для отображения текста или небольших значков.
LCD-дисплеи различаются по количеству строк и столбцов символов, которые помещаются на экране. LCD 16x2 может отображать 2 строки по 16 символов в каждой. Существуют размеры от 8x1 до 40x4.
Один из самых простых способов управления LCD с помощью микроконтроллера — использование дисплея с интерфейсом I2C. Мы будем использовать LCD 16x2 с I2C-интерфейсом.
Для работы с этим руководством следует приобрести дисплей с I2C-интерфейсом. Что касается размера, вы можете выбрать любой — он должен быть совместим.
LCD с I2C-драйвером
Преимущество использования I2C LCD заключается в том, что подключение очень простое. Вам нужно подключить только выводы SDA и SCL.
Кроме того, на модуле есть встроенный потенциометр для регулировки контрастности между фоном и символами на LCD. На «обычном» LCD без I2C-интерфейса вам пришлось бы добавлять потенциометр в схему для регулировки контрастности.
Подключение I2C LCD к ESP32/ESP8266
Поскольку этот LCD-модуль поддерживает I2C-связь, подключение очень простое. Мы подключим выводы I2C к стандартным I2C-выводам ESP32 и ESP8266. Вывод VCC LCD необходимо подключить к 5V.
LCD-дисплей |
ESP32 |
ESP8266 |
|---|---|---|
SCL |
GPIO 22 |
GPIO 5 |
SDA |
GPIO 21 |
GPIO 4 |
VCC |
VIN (5V) |
VIN (5V) |
GND |
GND |
GND |
Подробнее о распиновке ESP32 и ESP8266:
Схема подключения
Вы также можете использовать следующие схемы в качестве справки.
ESP32
ESP8266 NodeMCU
Определение I2C-адреса LCD
Большинство I2C LCD имеют I2C-адрес 0x27. Однако ваш может отличаться. Поэтому важно проверить I2C-адрес перед продолжением работы. Обратитесь к даташиту датчика или запустите скетч I2C-сканера.
LCD-библиотеки — MicroPython
Существуют различные библиотеки, упрощающие взаимодействие с LCD. Мы будем использовать комбинацию двух модулей, разработанных пользователем dhylands на GitHub.
Выполните следующие шаги для установки двух необходимых модулей.
Загрузка и установка lcd_api.py
Скопируйте код в файл в Thonny IDE;
Перейдите в File > Save as… и выберите MicroPython Device;
Сохраните файл с именем lcd_api.py (не изменяйте имя).
# Provides an API for talking to HD44780 compatible character LCDs.
# https://github.com/dhylands/python_lcd/tree/master/lcd
import time
class LcdApi:
"""Implements the API for talking with HD44780 compatible character LCDs.
This class only knows what commands to send to the LCD, and not how to get
them to the LCD.
It is expected that a derived class will implement the hal_xxx functions.
"""
# The following constant names were lifted from the avrlib lcd.h
# header file, however, I changed the definitions from bit numbers
# to bit masks.
#
# HD44780 LCD controller command set
LCD_CLR = 0x01 # DB0: clear display
LCD_HOME = 0x02 # DB1: return to home position
LCD_ENTRY_MODE = 0x04 # DB2: set entry mode
LCD_ENTRY_INC = 0x02 # --DB1: increment
LCD_ENTRY_SHIFT = 0x01 # --DB0: shift
LCD_ON_CTRL = 0x08 # DB3: turn lcd/cursor on
LCD_ON_DISPLAY = 0x04 # --DB2: turn display on
LCD_ON_CURSOR = 0x02 # --DB1: turn cursor on
LCD_ON_BLINK = 0x01 # --DB0: blinking cursor
LCD_MOVE = 0x10 # DB4: move cursor/display
LCD_MOVE_DISP = 0x08 # --DB3: move display (0-> move cursor)
LCD_MOVE_RIGHT = 0x04 # --DB2: move right (0-> left)
LCD_FUNCTION = 0x20 # DB5: function set
LCD_FUNCTION_8BIT = 0x10 # --DB4: set 8BIT mode (0->4BIT mode)
LCD_FUNCTION_2LINES = 0x08 # --DB3: two lines (0->one line)
LCD_FUNCTION_10DOTS = 0x04 # --DB2: 5x10 font (0->5x7 font)
LCD_FUNCTION_RESET = 0x30 # See "Initializing by Instruction" section
LCD_CGRAM = 0x40 # DB6: set CG RAM address
LCD_DDRAM = 0x80 # DB7: set DD RAM address
LCD_RS_CMD = 0
LCD_RS_DATA = 1
LCD_RW_WRITE = 0
LCD_RW_READ = 1
def __init__(self, num_lines, num_columns):
self.num_lines = num_lines
if self.num_lines > 4:
self.num_lines = 4
self.num_columns = num_columns
if self.num_columns > 40:
self.num_columns = 40
self.cursor_x = 0
self.cursor_y = 0
self.implied_newline = False
self.backlight = True
self.display_off()
self.backlight_on()
self.clear()
self.hal_write_command(self.LCD_ENTRY_MODE | self.LCD_ENTRY_INC)
self.hide_cursor()
self.display_on()
def clear(self):
"""Clears the LCD display and moves the cursor to the top left
corner.
"""
self.hal_write_command(self.LCD_CLR)
self.hal_write_command(self.LCD_HOME)
self.cursor_x = 0
self.cursor_y = 0
def show_cursor(self):
"""Causes the cursor to be made visible."""
self.hal_write_command(self.LCD_ON_CTRL | self.LCD_ON_DISPLAY |
self.LCD_ON_CURSOR)
def hide_cursor(self):
"""Causes the cursor to be hidden."""
self.hal_write_command(self.LCD_ON_CTRL | self.LCD_ON_DISPLAY)
def blink_cursor_on(self):
"""Turns on the cursor, and makes it blink."""
self.hal_write_command(self.LCD_ON_CTRL | self.LCD_ON_DISPLAY |
self.LCD_ON_CURSOR | self.LCD_ON_BLINK)
def blink_cursor_off(self):
"""Turns on the cursor, and makes it no blink (i.e. be solid)."""
self.hal_write_command(self.LCD_ON_CTRL | self.LCD_ON_DISPLAY |
self.LCD_ON_CURSOR)
def display_on(self):
"""Turns on (i.e. unblanks) the LCD."""
self.hal_write_command(self.LCD_ON_CTRL | self.LCD_ON_DISPLAY)
def display_off(self):
"""Turns off (i.e. blanks) the LCD."""
self.hal_write_command(self.LCD_ON_CTRL)
def backlight_on(self):
"""Turns the backlight on.
This isn't really an LCD command, but some modules have backlight
controls, so this allows the hal to pass through the command.
"""
self.backlight = True
self.hal_backlight_on()
def backlight_off(self):
"""Turns the backlight off.
This isn't really an LCD command, but some modules have backlight
controls, so this allows the hal to pass through the command.
"""
self.backlight = False
self.hal_backlight_off()
def move_to(self, cursor_x, cursor_y):
"""Moves the cursor position to the indicated position. The cursor
position is zero based (i.e. cursor_x == 0 indicates first column).
"""
self.cursor_x = cursor_x
self.cursor_y = cursor_y
addr = cursor_x & 0x3f
if cursor_y & 1:
addr += 0x40 # Lines 1 & 3 add 0x40
if cursor_y & 2: # Lines 2 & 3 add number of columns
addr += self.num_columns
self.hal_write_command(self.LCD_DDRAM | addr)
def putchar(self, char):
"""Writes the indicated character to the LCD at the current cursor
position, and advances the cursor by one position.
"""
if char == '\n':
if self.implied_newline:
# self.implied_newline means we advanced due to a wraparound,
# so if we get a newline right after that we ignore it.
self.implied_newline = False
else:
self.cursor_x = self.num_columns
else:
self.hal_write_data(ord(char))
self.cursor_x += 1
if self.cursor_x >= self.num_columns:
self.cursor_x = 0
self.cursor_y += 1
self.implied_newline = (char != '\n')
if self.cursor_y >= self.num_lines:
self.cursor_y = 0
self.move_to(self.cursor_x, self.cursor_y)
def putstr(self, string):
"""Write the indicated string to the LCD at the current cursor
position and advances the cursor position appropriately.
"""
for char in string:
self.putchar(char)
def custom_char(self, location, charmap):
"""Write a character to one of the 8 CGRAM locations, available
as chr(0) through chr(7).
"""
location &= 0x7
self.hal_write_command(self.LCD_CGRAM | (location << 3))
self.hal_sleep_us(40)
for i in range(8):
self.hal_write_data(charmap[i])
self.hal_sleep_us(40)
self.move_to(self.cursor_x, self.cursor_y)
def hal_backlight_on(self):
"""Allows the hal layer to turn the backlight on.
If desired, a derived HAL class will implement this function.
"""
pass
def hal_backlight_off(self):
"""Allows the hal layer to turn the backlight off.
If desired, a derived HAL class will implement this function.
"""
pass
def hal_write_command(self, cmd):
"""Write a command to the LCD.
It is expected that a derived HAL class will implement this
function.
"""
raise NotImplementedError
def hal_write_data(self, data):
"""Write data to the LCD.
It is expected that a derived HAL class will implement this
function.
"""
raise NotImplementedError
# This is a default implementation of hal_sleep_us which is suitable
# for most micropython implementations. For platforms which don't
# support `time.sleep_us()` they should provide their own implementation
# of hal_sleep_us in their hal layer and it will be used instead.
def hal_sleep_us(self, usecs):
"""Sleep for some time (given in microseconds)."""
time.sleep_us(usecs) # NOTE this is not part of Standard Python library, specific hal layers will need to override this
Загрузка и установка machine_i2c_lcd.py
Скопируйте код в файл в Thonny IDE;
Перейдите в File > Save as… и выберите MicroPython Device;
Сохраните файл с именем machine_i2c_lcd.py (не изменяйте имя).
# Implements a HD44780 character LCD connected via PCF8574 on I2C.
# This was tested with: https://www.wemos.cc/product/d1-mini.html
# https://github.com/dhylands/python_lcd/blob/master/lcd/machine_i2c_lcd.py
from lcd_api import LcdApi
from time import sleep_ms
# The PCF8574 has a jumper selectable address: 0x20 - 0x27
DEFAULT_I2C_ADDR = 0x27
# Defines shifts or masks for the various LCD line attached to the PCF8574
MASK_RS = 0x01
MASK_RW = 0x02
MASK_E = 0x04
SHIFT_BACKLIGHT = 3
SHIFT_DATA = 4
class I2cLcd(LcdApi):
"""Implements a HD44780 character LCD connected via PCF8574 on I2C."""
def __init__(self, i2c, i2c_addr, num_lines, num_columns):
self.i2c = i2c
self.i2c_addr = i2c_addr
self.i2c.writeto(self.i2c_addr, bytearray([0]))
sleep_ms(20) # Allow LCD time to powerup
# Send reset 3 times
self.hal_write_init_nibble(self.LCD_FUNCTION_RESET)
sleep_ms(5) # need to delay at least 4.1 msec
self.hal_write_init_nibble(self.LCD_FUNCTION_RESET)
sleep_ms(1)
self.hal_write_init_nibble(self.LCD_FUNCTION_RESET)
sleep_ms(1)
# Put LCD into 4 bit mode
self.hal_write_init_nibble(self.LCD_FUNCTION)
sleep_ms(1)
LcdApi.__init__(self, num_lines, num_columns)
cmd = self.LCD_FUNCTION
if num_lines > 1:
cmd |= self.LCD_FUNCTION_2LINES
self.hal_write_command(cmd)
def hal_write_init_nibble(self, nibble):
"""Writes an initialization nibble to the LCD.
This particular function is only used during initialization.
"""
byte = ((nibble >> 4) & 0x0f) << SHIFT_DATA
self.i2c.writeto(self.i2c_addr, bytearray([byte | MASK_E]))
self.i2c.writeto(self.i2c_addr, bytearray([byte]))
def hal_backlight_on(self):
"""Allows the hal layer to turn the backlight on."""
self.i2c.writeto(self.i2c_addr, bytearray([1 << SHIFT_BACKLIGHT]))
def hal_backlight_off(self):
"""Allows the hal layer to turn the backlight off."""
self.i2c.writeto(self.i2c_addr, bytearray([0]))
def hal_write_command(self, cmd):
"""Writes a command to the LCD.
Data is latched on the falling edge of E.
"""
byte = ((self.backlight << SHIFT_BACKLIGHT) | (((cmd >> 4) & 0x0f) << SHIFT_DATA))
self.i2c.writeto(self.i2c_addr, bytearray([byte | MASK_E]))
self.i2c.writeto(self.i2c_addr, bytearray([byte]))
byte = ((self.backlight << SHIFT_BACKLIGHT) | ((cmd & 0x0f) << SHIFT_DATA))
self.i2c.writeto(self.i2c_addr, bytearray([byte | MASK_E]))
self.i2c.writeto(self.i2c_addr, bytearray([byte]))
if cmd <= 3:
# The home and clear commands require a worst case delay of 4.1 msec
sleep_ms(5)
def hal_write_data(self, data):
"""Write data to the LCD."""
byte = (MASK_RS | (self.backlight << SHIFT_BACKLIGHT) | (((data >> 4) & 0x0f) << SHIFT_DATA))
self.i2c.writeto(self.i2c_addr, bytearray([byte | MASK_E]))
self.i2c.writeto(self.i2c_addr, bytearray([byte]))
byte = (MASK_RS | (self.backlight << SHIFT_BACKLIGHT) | ((data & 0x0f) << SHIFT_DATA))
self.i2c.writeto(self.i2c_addr, bytearray([byte | MASK_E]))
self.i2c.writeto(self.i2c_addr, bytearray([byte]))
После загрузки модулей на плату вы можете использовать функциональные возможности библиотеки в своём коде для вывода текста на LCD.
Отображение статического текста — код
Отображение статического текста на LCD очень простое. Всё, что вам нужно сделать — это выбрать, где на экране должны отображаться символы, а затем отправить сообщение на дисплей. Если вы не укажете, где отображать текст, он будет записан в первое доступное место.
Этот пример отображает сообщение «Hello, World!» сначала в первой строке, а затем во второй строке. Он совместим с ESP32 и ESP8266 — просто убедитесь, что вы раскомментировали определение пинов для ESP8266.
# Rui Santos & Sara Santos - Random Nerd Tutorials
# Complete project details at https://RandomNerdTutorials.com/micropython-i2c-lcd-esp32-esp8266/
from machine import Pin, SoftI2C
from machine_i2c_lcd import I2cLcd
from time import sleep
# Define the LCD I2C address and dimensions
I2C_ADDR = 0x27
I2C_NUM_ROWS = 2
I2C_NUM_COLS = 16
# Initialize I2C and LCD objects
i2c = SoftI2C(sda=Pin(21), scl=Pin(22), freq=400000)
# for ESP8266, uncomment the following line
#i2c = SoftI2C(sda=Pin(4), scl=Pin(5), freq=400000)
lcd = I2cLcd(i2c, I2C_ADDR, I2C_NUM_ROWS, I2C_NUM_COLS)
lcd.putstr("It's working :)")
sleep(4)
try:
while True:
# Clear the LCD
lcd.clear()
# Display two different messages on different lines
# By default, it will start at (0,0) if the display is empty
lcd.putstr("Hello World!")
sleep(2)
lcd.clear()
# Starting at the second line (0, 1)
lcd.move_to(0, 1)
lcd.putstr("Hello World!")
sleep(2)
except KeyboardInterrupt:
# Turn off the display
print("Keyboard interrupt")
lcd.backlight_off()
lcd.display_off()
Как работает код
Давайте кратко рассмотрим, как работает код, чтобы понять, как взаимодействовать с LCD.
Импорт библиотек
Начнём с подключения всех необходимых модулей для связи с LCD. Мы будем использовать программный I2C.
from machine import Pin, SoftI2C
from machine_i2c_lcd import I2cLcd
from time import sleep
Свойства LCD
В следующих строках определяем свойства LCD. Наш LCD-дисплей — 2x16 (2 строки и 16 столбцов), а I2C-адрес — 0x27. Если ваш дисплей имеет другие размеры или другой адрес, измените следующие строки.
# Define the LCD I2C address and dimensions
I2C_ADDR = 0x27
I2C_NUM_ROWS = 2
I2C_NUM_COLS = 16
I2C-связь
Затем мы инициализируем I2C на GPIO 21 и 22 (для ESP32) — это пины, которые мы используем для подключения LCD.
i2c = SoftI2C(sda=Pin(21), scl=Pin(22), freq=400000)
Если вы используете ESP8266, обязательно закомментируйте предыдущую строку и раскомментируйте следующую, чтобы использовать стандартные I2C-пины ESP8266 (GPIO 4 и 5).
# for ESP8266, uncomment the following line
#i2c = SoftI2C(sda=Pin(4), scl=Pin(5), freq=400000)
После создания экземпляра I2C мы можем инициализировать I2C-связь с LCD с помощью следующей строки.
lcd = I2cLcd(i2c, I2C_ADDR, I2C_NUM_ROWS, I2C_NUM_COLS)
Мы создаём новый объект с именем lcd с помощью метода I2cLcd() и передаём в качестве аргументов экземпляр i2c, адрес, количество строк и столбцов. Теперь мы можем использовать lcd для обращения к LCD-экрану.
Вывод текста
Теперь, когда связь установлена, мы можем начать выводить текст. Вывод простого текста так же прост, как использование метода putstr() на объекте lcd и передача в качестве аргумента текста, который мы хотим отобразить. Например:
lcd.putstr("It's working :)")
Эта строка отобразит сообщение «It’s working :)». Поскольку мы не указали место, а LCD-экран ещё пуст, сообщение будет отображено в позиции (0, 0) — первая строка, первый столбец.
Затем у нас есть цикл while, который непрерывно отображает «Hello World!» на LCD, чередуя верхнюю и нижнюю строки, создавая простой повторяющийся шаблон отображения.
while True:
# Clear the LCD
lcd.clear()
# Display two different messages on different lines
# By default, it will start at (0,0) if the display is empty
lcd.putstr("Hello World!")
sleep(2)
lcd.clear()
# Starting at the second line (0, 1)
lcd.move_to(0, 1)
lcd.putstr("Hello World!")
sleep(2)
Очистка экрана
Перед записью новой информации мы очищаем содержимое экрана с помощью метода clear().
lcd.clear()
Затем мы отображаем строку «Hello World!» на LCD. По умолчанию вывод начинается с левого верхнего угла дисплея (позиция 0, 0).
lcd.putstr("Hello World!")
Это сообщение будет на экране в течение двух секунд.
sleep(2)
После этого мы снова очищаем экран.
lcd.clear()
Перемещение курсора
Далее мы используем метод move_to(), который принимает в качестве аргументов номер строки и столбца, что позволяет выбрать, где начать отображение текста. В данном случае мы устанавливаем позицию курсора в начало второй строки (строка 1, столбец 0) LCD. Это позволяет отобразить второе сообщение «Hello World!» на второй строке.
Выключение подсветки
Мы также добавляем фрагмент кода для выключения подсветки LCD в случае остановки программы прерыванием с клавиатуры. Вы можете использовать методы backlight_off() и display_off().
except KeyboardInterrupt:
# Turn off the display
print("Keyboard interrupt")
lcd.backlight_off()
lcd.display_off()
Этот простой пример демонстрирует наиболее полезные методы взаимодействия с LCD. Мы рекомендуем вам заглянуть в модули machine_i2c_lcd.py и lcd_api.py и проверить и протестировать другие методы, которые могут быть вам полезны.
Тестирование кода
Запустите предыдущий код на платах ESP32 или ESP8266. Сначала вы получите сообщение, показывающее, что дисплей работает.
После этого на первой строке на две секунды появится сообщение «Hello, World!», а затем на второй строке ещё на две секунды. Затем цикл повторяется, пока вы не остановите программу.
Примечание: если вы хотите, чтобы код запускался автоматически при загрузке ESP (например, без подключения к компьютеру), вам нужно сохранить файл на плату с именем main.py.
Когда вы называете файл main.py, ESP32 или ESP8266 автоматически запустит этот файл при загрузке. Если вы назовёте его по-другому, он всё равно будет сохранён в файловой системе платы, но не запустится автоматически при загрузке.
Устранение неполадок
Если LCD имеет очень слабый контраст и вы едва видите символы, поверните потенциометр на задней стороне дисплея, чтобы отрегулировать контрастность между символами и подсветкой.
Кроме того, убедитесь, что вы питаете LCD от 5V. Питание от 3V3 недостаточно для большинства таких модулей (если иное не указано в даташите).
Отображение бегущей строки
Бегущая строка на LCD полезна для отображения сообщений длиннее ширины дисплея (в нашем случае — длиннее 16 символов).
Используемая нами библиотека не имеет специальной функции для прокрутки текста, но вы можете создать свою собственную функцию, сдвигая текст влево на одну позицию за раз. Смотрите пример ниже.
# Rui Santos & Sara Santos - Random Nerd Tutorials
# Complete project details at https://RandomNerdTutorials.com/micropython-i2c-lcd-esp32-esp8266/
from machine import Pin, SoftI2C
from machine_i2c_lcd import I2cLcd
from time import sleep
# Define the LCD I2C address and dimensions
I2C_ADDR = 0x27
I2C_NUM_ROWS = 2
I2C_NUM_COLS = 16
# Initialize I2C and LCD objects
i2c = SoftI2C(sda=Pin(21), scl=Pin(22), freq=400000)
# for ESP8266, uncomment the following line
#i2c = SoftI2C(sda=Pin(4), scl=Pin(5), freq=400000)
lcd = I2cLcd(i2c, I2C_ADDR, I2C_NUM_ROWS, I2C_NUM_COLS)
def scroll_message(message, delay=0.3):
# Add spaces to the beginning of the message to make it appear from the right
message = " " * I2C_NUM_COLS + message + " "
# Scroll through the message
for i in range(len(message) - I2C_NUM_COLS + 1):
lcd.move_to(0, 0)
lcd.putstr(message[i:i + I2C_NUM_COLS])
sleep(delay)
try:
lcd.clear()
lcd.putstr("Testing scroll!")
sleep(2)
# Define the message to be scrolled
message_scroll = "This is a scrolling message with more than 16 characters"
while True:
# Scroll the message on the LCD
lcd.clear()
scroll_message(message_scroll)
except KeyboardInterrupt:
# Turn off the display when the code is interrupted by the user
print("Keyboard interrupt")
lcd.backlight_off()
lcd.display_off()
Как работает код
В этом примере мы создаём простую функцию scroll_message(), которая принимает в качестве аргументов сообщение для отображения и задержку между каждым сдвигом. По умолчанию задержка установлена на 0.3 секунды, но вы можете настроить её в зависимости от того, насколько быстро хотите прокручивать текст.
def scroll_message(message, delay=0.3):
# Add spaces to the beginning of the message to make it appear from the right
message = " " * I2C_NUM_COLS + message + " "
# Scroll through the message
for i in range(len(message) - I2C_NUM_COLS + 1):
lcd.move_to(0, 0)
lcd.putstr(message[i:i + I2C_NUM_COLS])
sleep(delay)
В этой функции мы начинаем с добавления к сообщению отступа, состоящего из пробелов в количестве, равном числу столбцов (I2C_NUM_COLS), и финального пробела в конце. Мы делаем это для создания пространства, откуда начинается прокрутка.
message = " " * I2C_NUM_COLS + message + " "
Затем у нас есть цикл for, который перебирает символы нашего сообщения. Мы устанавливаем позицию курсора в левый верхний угол LCD (столбец 0, строка 0), чтобы каждая итерация начиналась с начала LCD.
lcd.move_to(0, 0)
Затем мы отображаем часть сообщения на LCD, начиная с текущего индекса итерации i и охватывая ширину LCD (I2C_NUM_COLS символов).
lcd.putstr(message[i:i + I2C_NUM_COLS])
Выражение message[i:i + I2C_NUM_COLS] получает только часть сообщения, начиная с символа с индексом i и заканчивая символом i + I2C_NUM_COLS. По мере увеличения значения i мы выбираем новую часть сообщения, создавая эффект прокрутки.
Наконец, задержка в конце определяет скорость прокрутки.
sleep(delay)
Для прокрутки текста вызовите функцию scroll_message() и передайте в качестве аргументов сообщение, которое хотите прокрутить, и время задержки.
scroll_message(message_scroll, 0.4)
Тестирование кода
Запустите предыдущий код на плате ESP32 или ESP8266. Вы должны увидеть бегущую строку. Вы можете настроить скорость прокрутки в переменной задержки в функции scroll_message().
Отображение пользовательских символов
На LCD 16x2 имеется 32 блока, в которых можно отображать символы. Каждый блок состоит из матрицы 5x8 крошечных пикселей. Вы можете отображать пользовательские символы, определяя состояние каждого пикселя. Для этого создайте переменную массива байтов, которая будет хранить состояние каждого пикселя.
Создание пользовательских символов
Большинство LCD позволяют загрузить до 8 пользовательских символов в память дисплея, которые можно использовать позже. Затем вы можете обращаться к символам по их индексу (от 0 до 7).
Чтобы создать свой пользовательский символ, перейдите сюда и нарисуйте свой символ. Затем сгенерируйте переменную массива байтов для вашего символа. Например, сердце:
Массив байтов выделен жёлтым. Скопируйте массив байтов в одну строку. Например, для символа сердца:
0x00, 0x0A, 0x1F, 0x0E, 0x04, 0x00, 0x00
Сохраните свой массив байтов, потому что он понадобится вам позже в коде.
Отображение пользовательских символов — код
Следующий код отображает три пользовательских символа: термометр, зонтик и сердце. Вы можете отображать любой символ, используя его массив байтов.
# Rui Santos & Sara Santos - Random Nerd Tutorials
# Complete project details at https://RandomNerdTutorials.com/micropython-i2c-lcd-esp32-esp8266/
from machine import Pin, SoftI2C
from machine_i2c_lcd import I2cLcd
from time import sleep
# Define the LCD I2C address and dimensions
I2C_ADDR = 0x27
I2C_NUM_ROWS = 2
I2C_NUM_COLS = 16
# Initialize I2C and LCD objects
i2c = SoftI2C(sda=Pin(21), scl=Pin(22), freq=400000)
# for ESP8266, uncomment the following line
#i2c = SoftI2C(sda=Pin(4), scl=Pin(5), freq=400000)
lcd = I2cLcd(i2c, I2C_ADDR, I2C_NUM_ROWS, I2C_NUM_COLS)
# Create custom characters here: https://maxpromer.github.io/LCD-Character-Creator/
thermometer = bytearray([0x04, 0x0A, 0x0A, 0x0A, 0x0A, 0x1B, 0x1F, 0x0E])
lcd.custom_char(0, thermometer)
umbrella = bytearray([0x00, 0x04, 0x0E, 0x1F, 0x04, 0x04, 0x014, 0x0C])
lcd.custom_char(1, umbrella)
heart = bytearray([0x00, 0x0A, 0x1F, 0x1F, 0x0E, 0x04, 0x00, 0x00])
lcd.custom_char(2, heart)
try:
lcd.putstr("Characters")
lcd.move_to(0, 1)
# Display thermometer
lcd.putchar(chr(0))
# Display umbrella
lcd.move_to(2, 1)
lcd.putchar(chr(1))
# Display heart
lcd.move_to(4, 1)
lcd.putchar(chr(2))
except KeyboardInterrupt:
# Turn off the display when the code is interrupted by the user
print("Keyboard interrupt")
lcd.backlight_off()
lcd.display_off()
Как работает код
Сначала вам нужно сохранить массив байтов в переменной следующим образом:
thermometer = bytearray([0x04, 0x0A, 0x0A, 0x0A, 0x0A, 0x1B, 0x1F, 0x0E])
Измените массив байтов для любых других символов, которые вы хотите отобразить. В нашем случае мы также отображаем зонтик и сердце.
Затем, чтобы сохранить символ в памяти LCD, нужно использовать функцию custom_char() на объекте lcd и передать в качестве аргументов индекс, по которому вы хотите сохранить символ, и массив байтов для этого символа.
lcd.custom_char(0, thermometer)
Мы выполняем этот процесс для всех пользовательских символов, которые хотим отобразить, но каждый из них сохраняется по разному индексу custom_char().
thermometer = bytearray([0x04, 0x0A, 0x0A, 0x0A, 0x0A, 0x1B, 0x1F, 0x0E])
lcd.custom_char(0, thermometer)
umbrella = bytearray([0x00, 0x04, 0x0E, 0x1F, 0x04, 0x04, 0x014, 0x0C])
lcd.custom_char(1, umbrella)
heart = bytearray([0x00, 0x0A, 0x1F, 0x1F, 0x0E, 0x04, 0x00, 0x00])
lcd.custom_char(2, heart)
Наконец, для отображения пользовательского символа нужно просто использовать функцию putchar() следующим образом:
lcd.putchar(chr(0))
В нашем случае chr(0) соответствует термометру — символу, который мы сохранили по индексу 0. Аналогично поступаем со всеми остальными символами. В нашем случае мы отображаем статическое сообщение в первой строке, а затем отображаем пользовательские символы во второй строке.
try:
lcd.putstr("Characters")
lcd.move_to(0, 1)
# Display thermometer
lcd.putchar(chr(0))
# Display umbrella
lcd.move_to(2, 1)
lcd.putchar(chr(1))
# Display heart
lcd.move_to(4, 1)
lcd.putchar(chr(2))
Как видите, отображение пользовательских символов довольно просто.
Тестирование кода
Запустите или загрузите код на плату ESP32 или ESP8266. LCD отобразит ваши пользовательские символы. Не стесняйтесь изменять код и отображать свои собственные пользовательские символы. Вы также можете использовать несколько смежных блоков для создания более крупного значка на дисплее.
Заключение
В этом руководстве вы узнали, как использовать I2C LCD (жидкокристаллический дисплей) с ESP32 и ESP8266, программируемыми с прошивкой MicroPython. Мы рассмотрели отображение статического текста, бегущей строки и пользовательских символов.
Надеемся, это руководство было для вас полезным. У нас есть похожие руководства для OLED-дисплея:
Если вы хотите узнать больше о программировании ESP32 и ESP8266 с использованием MicroPython, ознакомьтесь с нашими ресурсами: