В этой статье мы продолжаем изучать новинку этого года — микроконтроллер от Raspberry Pi Foundation на чипе собственной разработки RP2040 — Raspberry Pi Pico, выпущенный в начале 2021 года. Этот микроконтроллер можно применять в широком диапазоне проектов и инженерных приложений, а часто проекты связаны с выводом пользователю различной цифровой, символьной или графической информации, для чего и можно использовать модули дисплеев. К слову, Pico работает не только с выпущенными специально для него дисплеями (как это часто бывает с платами расширения для различных брендов) — он работает в том числе со стандартным интерфейсом I2C, что позволяет включать дисплеи в ряд с другими устройствами по последовательному протоколу, хотя давайте обо всём подробнее...
Целью данной статьи мы ставим изучение взаимодействия модуля жидкокристаллического дисплея 16×2 (16×2 LCD Display) с Raspberry Pi Pico.
LCD дисплей представляет собой электронный дисплейный модуль, в котором для создания видимого изображения используется жидкокристаллическая технология. Модуль 16×2 LCD Display — это один из простейших модулей такого типа, обычно используемый в электронных схемах для вывода цифровой и/или текстовой информации. Индекс 16×2 означает, что дисплей имеет 16 символов в строке в 2 таких строки по высоте экрана. Если рассматривать каждый символ LCD-дисплея, то он отображается в матрице 5×8 пикселей.
LCD-дисплей основан на драйвере HD44780. Существуют 2 версии этого LCD-дисплея: версия с I2C и версии без I2C. Мы возьмем обе версии этого дисплея в качестве примера, присоединим к Raspberry Pi Pico, а затем напишем код на MicroPython для взаимодействия LCD-дисплея 16×2 с Raspberry Pi Pico.
Для реализации поставленной задачи нам будут необходимы:
- Микроконтроллер Raspberry Pi Pico
- Модуль 16×2 LCD Display
- Компьютер или планшет для написания кода
- Кабель USB Type-A - MicroUSB для прошивки.
Обзор модуля дисплея 16×2 LCD Display.
Модуль 16×2 LCD Display назван так, потому что он имеет 16 столбцов и 2 строки. Таким образом, в нем будет всего (16 × 2 = 32) 32 символа, и каждый символ будет состоять из 5 × 8 пикселей. Одиночный символ со всеми его пикселями показан на рисунке ниже.
Каждый символ имеет (5 по горизонтали × 8 по вертикали = 40) 40 пикселей, а для 32 символов итого будет (32 × 40) 1280 пикселей. Кроме того, этот ЖК-дисплей также должен быть проинструктирован о положении пикселей. Справиться со всем этим с помощью только микроконтроллера будет сложной задачей, поэтому в ЖК-дисплее используется интерфейсный чип (интегральная схема), называемый драйвер или контроллер, модели HD44780. Подробнее об этом драйвере вы можете прочесть в оригинальном Руководстве от производителя HITACHI по ссылке: HD44780U (Dot MAtrix Liquid Crystal Display Controller/Driver). Этот драйвер установлена на задней стороне платы ЖК-модуля.
Функция драйвера — получать команды и данные от микроконтроллера (MCU) и обрабатывать их для отображения значимой информации на ЖК-экране. Рабочее напряжение ЖК-дисплея составляет от 4,7 В до 5,3 В, а потребление тока составляет 1 мА (без подсветки). Дисплей может работать как в 8-битном, так и в 4-битном режиме, а также может отображать любые созданные пользователем символы. Эти ЖК-дисплеи доступны с зеленой и синей подсветкой фона.
Версия модуля 16×2 LCD Display без I2C
На верхней части платы модуля ЖК-дисплея есть 16 контактов для передачи данных, управляющих команд и питания. Все вместе они участвуют в процессе правильного включения и отключения нужных пикселей экрана, а также включения LED-подсветки фона.
Версия модуля 16×2 LCD Display с I2C
Этот тип дисплея включает интерфейс I2C, для которого требуется только 2 контакта (SDA и SCL) для соединения с микроконтроллером. I2C (Inter-Integrated Circuit, IIC, I²C) — последовательная асимметричная шина, разработана фирмой Philips Semiconductors в начале 1980-х годов, для связи между интегральными схемами внутри электронных приборов. Она использует две двунаправленные линии связи: последовательную линию данных SDA (Serial DAta) и последовательную линию тактирования SCL (Serial CLock), и применяется для соединения низкоскоростных периферийных компонентов с процессорами и микроконтроллерами. Интерфейс I2C — это дополнительная плата (адаптер), прикрепленная к задней части ЖК-модуля и припаянная к 16 контактам на плате модуля дисплея. Адрес I2C для этих дисплеев — 0x3F или 0x27.
Адаптер имеет 8-битный чип расширения ввода / вывода PCF8574 производителя TI (Texas Instruments). С техническими данными этого чипа можно ознакомиться, перейдя по следующей ссылке: PCF8574 Remote 8-Bit I/O Expander for I 2C Bus.
Этот чип преобразует данные I2C от микроконтроллера в параллельные данные, необходимые для ЖК-дисплея. Есть небольшой подстроечный резистор для точной настройки контрастности дисплея (на картинке выше он синего цвета и имеет шлиц для вращения крестовой отвёрткой). Кроме того, на плате есть перемычка, подающая питание на подсветку (на противоположной от разъёма I2C стороне адаптера).
В чём же заключается преимущество использования адаптера с интерфейсом I2C для платы дисплея применительно к нашему микроконтроллеру Raspberry Pi Pico?
На этот вопрос ответить достаточно просто. Raspberry Pi Pico построен с использованием микроконтроллера RP2040. На его плате имеется 26 многофункциональных контактов GPIO из 36 контактов GPIO. 10 контактов GPIO не доступны для использования. Из 26 используемых контактов GPIO есть 2 пары контактов I2C.
Как было отмечено, синхронная несимметричная шина I2C (I2C Bus) последовательной связи с несколькими ведущими, несколькими ведомыми устройствами с коммутацией пакетов широко используется для присоединения низкоскоростных периферийных интегральных схем к процессорам и микроконтроллерам при передаче данных на короткие расстояния и внутри платы.
Как и связь UART, I2C использует только два провода для передачи данных между устройствами.
I2C Bus — cинхронная несимметричная шина I2C.
Device 1, Device 2, Device 3 — внешние устройства с интерыфейсом I2C.
SDA (Serial Data Line) — последовательная линия данных.
SCL (Serial Clock Line) — последовательная линия синхронизации.
Данные, подлежащие передаче, отправляются через провод SDA и синхронизируются с тактовым сигналом (clock signal) от SCL. Все устройства / интегральные схемы в сети I2C (I2C network) подключены к тем же линиям SCL и SDA, как показано выше.
Устройства, подключенные к шине I2C, являются либо ведущими (master), либо ведомыми (slave). В любой момент времени на шине I2C остается активным только один ведущий (мастер). Он управляет линией синхронизации SCL и решает, какая операция должна выполняться на линии данных SDA.
Все устройства, которые отвечают на инструкции от этого ведущего устройства, являются ведомыми. Для различения нескольких подчиненных устройств, подключенных к одной шине I2C, каждому подчиненному устройству физически назначается постоянный 7-битный адрес.
Когда ведущее устройство (master device) хочет передать данные на ведомое устройство (slave device) или от него, оно указывает этот конкретный адрес ведомого устройства в строке SDA, а затем приступает к передаче. Таким образом, между ведущим устройством и конкретным ведомым устройством происходит эффективная связь. Все остальные ведомые устройства не отвечают, если их адрес не указан ведущим устройством в строке SDA.
Микросхема микроконтроллера RP2040 имеет два контроллера I2C (см. схему выше), и к ним обоим можно получить доступ через контакты GPIO Raspberry Pi Pico. В следующей таблице показано подключение контактов GPIO к обоим контроллерам I2C.
| Контроллер I2C | Разъёмы GPIO |
| I2C0 – SDA | GP0 / GP4 / GP8 / GP12 / GP16 / GP20 |
| I2C0 – SCL | GP1 / GP5 / GP9 / GP13 / GP17 / GP21 |
| I2C1 – SDA | GP2 / GP6 / GP10 / GP14 / GP18 / GP26 |
| I2C1 – SCL | GP3 / GP7 / GP11 / GP15 / GP19 / GP27 |
Каждое соединение контроллера можно настроить через несколько контактов GPIO, как показано на схеме. Но перед использованием контроллера I2C вы должны настроить в программном обеспечении, какие выводы GPIO вы хотите использовать с конкретным контроллером I2C.
Особенности контактов Raspberry Pi Pico I2C:
Raspberry Pi Pico имеет чип RP2040, который поддерживает следующие функции:
- Устройство может работать в режиме ведущего (Master Mode) или ведомого (Slave Mode) с адресом по умолчанию = 0x055.
- Пины I2C имеют 3 режима скорости: стандартный (от 0 до 100 Кбит/с), быстрый (до 400 Кбит/с) и режим Fast Plus (до 1000 Кбит/с).
- Он может передавать и принимать буферы (Buffers).
- Его также можно использовать в режиме прерывания (interrupt) и DMA.
Для демонстрации примера подключения устройств по шине I2C приведём следующий пример:
В данной схеме подключено 3 разных устройства I2C к плате Pico: датчик MPU6050, 0,96-дюймовый OLED-дисплей и датчик BME680 (слева направо соответственно). Выводы SDA и SCL MPU6050, BME680 и OLED-дисплея подключены к общей линии I2C Raspberry Pi Pico. Имеется в наличии несколько контактов I2C, но все эти устройства можно подключить используя только одну пару контактов I2C Raspberry Pi Pico. Д данном случае это GPIO8 как SDA0 и GPIO9 как SCL0.
Напоминаем, что как было упомянуто выше, для работы микроконтроллера с шиной I2C, её нужно предваритетно включить, т.к. по умолчанию она выключена. Сделать это можно в графической среде или через терминал.
Включение в графической среде:
Нажимаем иконку малины в правом верхнем углу экрана и выбираем параметры -> Raspberry Pi Configuration:
Откроется окно настроек, выбираем вкладку Interfaces:
,
Во вкладке Interfaces выбираем enable (включено) для I2C:
Нажимаем ОК и теперь интерфейс включен.
Включение в терминале:
Настройка в терминале может понадобится, если мы, к примеру, подключаемся к Raspberry удалённо. Для настройки в терминале необходимо ввести с клавиатуры sudo raspi-config и нажать enter:
В открывшемся меню настроек, выбираем 5-й пункт Interfacing Options и нажимаем enter:
Откроется меню выбора интерфейсов, выбираем P5 I2C:
На вопрос отвечаем <Да>:
Готово. Интерфейс включен.
Теперь давайте вернёмся к вопросу подключения нашего модуля ЖК-дисплея к микроконтроллеру Pico.
Первый способ (для версии без I2C).
Подключите контакты 1, 5 и 16 ЖК-дисплея к GND Raspberry Pi Pico. Точно так же подключите контакты 2 и 15 ЖК-дисплея к контакту 5 В (Vbus) Raspberry Pi Pico. Подключите контакты 4, 6, 11, 12, 13, 14 ЖК-дисплея к контакту Raspberry Pi Pico GP16, GP17, GP18, GP19, GP20, GP21.
Для регулировки контрастности ЖК-дисплея подключите потенциометр 10кОм к контакту 3 ЖК-дисплея.
У нас получилось вот так:
Исходный код / программа.
Raspberry Pi Pico поддерживает программу на MicroPython для взаимодействия с ЖК-дисплеем 16 × 2. Вы можете использовать Thonny IDE или uPyCraft IDE для запуска кода MicroPython. Установка Thonny IDE была рассмотрена нами в предыдущей статье: Использование АЦП в Raspberry Pi Pico с примером на MicroPython.
Вот полный код для взаимодействия с ЖК-дисплеем 16х2 на драйвере HD44780 с Raspberry Pi Pico. Скопируйте код в IDE и сохраните его под именем main.py.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
|
import machine
import utime
rs = machine.Pin(16,machine.Pin.OUT)
e = machine.Pin(17,machine.Pin.OUT)
d4 = machine.Pin(18,machine.Pin.OUT)
d5 = machine.Pin(19,machine.Pin.OUT)
d6 = machine.Pin(20,machine.Pin.OUT)
d7 = machine.Pin(21,machine.Pin.OUT)
def pulseE():
e.value(1)
utime.sleep_us(40)
e.value(0)
utime.sleep_us(40)
def send2LCD4(BinNum):
d4.value((BinNum & 0b00000001) >>0)
d5.value((BinNum & 0b00000010) >>1)
d6.value((BinNum & 0b00000100) >>2)
d7.value((BinNum & 0b00001000) >>3)
pulseE()
def send2LCD8(BinNum):
d4.value((BinNum & 0b00010000) >>4)
d5.value((BinNum & 0b00100000) >>5)
d6.value((BinNum & 0b01000000) >>6)
d7.value((BinNum & 0b10000000) >>7)
pulseE()
d4.value((BinNum & 0b00000001) >>0)
d5.value((BinNum & 0b00000010) >>1)
d6.value((BinNum & 0b00000100) >>2)
d7.value((BinNum & 0b00001000) >>3)
pulseE()
def setUpLCD():
rs.value(0)
send2LCD4(0b0011)#8 bit
send2LCD4(0b0011)#8 bit
send2LCD4(0b0011)#8 bit
send2LCD4(0b0010)#4 bit
send2LCD8(0b00101000)#4 bit,2 lines?,5*8 bots
send2LCD8(0b00001100)#lcd on, blink off, cursor off.
send2LCD8(0b00000110)#increment cursor, no display shift
send2LCD8(0b00000001)#clear screen
utime.sleep_ms(2)#clear screen needs a long delay
setUpLCD()
rs.value(1)
for x in 'Hello World!':
send2LCD8(ord(x))
|
В результате запуска этого кода ЖК-дисплей начнет показывать сообщение Hello World! на своём экране.
Второй способ (подключение через шину I2C).
Приведенный выше код действителен для ЖК-дисплея 16×2 без модуля I2C. Модуль PCF8574 I2C или SMBus намного упрощает указанное в предыдущем способе подключение. Вместо того, чтобы использовать такое большое количество проводов, можно использовать этот модуль и с помощью его интегральной схемы преобразовать все линии вывода данных только в 2 физических провода. По умолчанию ЖК-дисплей становится устройством I2C с адресом I2C 0x27. Соединение между Raspberry Pi Pico и ЖК-дисплеем I2C очень простое (см. схему):
Подключите вывод ЖК-дисплея VCC и GND к выводу Raspberry Pi Pico 5V и GND соответственно. Подключите выводы SDA и SCL ЖК-дисплея к Raspberry Pi Pico GP8 и GP9 соответственно.
Трудно будет поспорить, что этот вариант подключения намного проще предыдущего. На фотографии адаптер I2C не распаян на обратной стороне модуля дисплея, а вынесен отдельно и соединён через макетную плату с платой дисплея гребёнчатым разъёмом в соответствующие контакты.
Исходный код / программа.
Программа для данного вида подключения выглядит значительно сложнее и разделена на 3 части. Нам нужно написать код драйвера, а также код протокола I2C, чтобы подключить их в основном классе main.py.
Вам же просто необходимо скопировать весь этот код, а затем сохранить все 3 кода на Raspberry Pi Pico Board оответственно в файлы: lcd_api.py, pico_i2c_lcd.py, main.py.
lcd_api.py
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
|
import time
class LcdApi:
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.
pass
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
def hal_sleep_us(self, usecs):
"""Sleep for some time (given in microseconds)."""
time.sleep_us(usecs)
|
pico_i2c_lcd.py
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
|
from lcd_api import LcdApi
from machine import I2C
from time import sleep_ms
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 character based 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 intiialization.
"""
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]))
|
Ну и основную программу:
main.py
|
1
2
3
4
5
6
7
8
9
10
11
12
|
from pico_i2c_lcd import I2cLcd
from machine import I2C
from machine import Pin
import utime as time
i2c = I2C(id=1,scl=Pin(9),sda=Pin(8),freq=100000)
lcd = I2cLcd(i2c, 0x27, 2, 16)
while True:
lcd.move_to(2,0)
lcd.putstr('Hello world')
|
Как только вы запустите все эти коды на Raspberry Pi Pico, на ЖК-дисплее появится сообщение Hello World!
Удачно выведенная классическая фраза Hello World! открывает практически неограниченные возможности для разработчиков по выводу информации на дисплей. Если вы прошли с нами весь путь подключения модуля, то небольшая модернизация исходного кода программы позволит выводить данные с ваших датчиков, получаемых и передаваемых цифровых и текстовых данных программ и приложений, впрочем, перечислять все возможные применения будет очень долго.
Стоит заметить, что подключение других модулей дисплея для микроконтроллера Raspberry Pi Pico очень похоже на приведенные выше варианты, поэтому знания, полученные в этой статье пригодятся вам для проектов любой сложности.
