ESP32 - écran LCD I2C
Ce tutoriel vous explique comment utiliser l'ESP32 avec un écran LCD 16x2 I2C, en utilisant MicroPython. Vous apprendrez :
- Comment connecter un écran LCD I2C à un ESP32
- Comment écrire du code MicroPython pour l'ESP32 afin d'afficher du texte sur l'écran LCD I2C
- Comment écrire du code MicroPython pour l'ESP32 afin d'afficher des nombres sur l'écran LCD I2C
- Comment écrire du code MicroPython pour l'ESP32 afin d'afficher des caractères personnalisés sur l'écran LCD I2C
Préparation du matériel
Ou vous pouvez acheter les kits suivants:
| 1 | × | Kit de Démarrage DIYables ESP32 (ESP32 inclus) | |
| 1 | × | Kit de Capteurs DIYables (30 capteurs/écrans) | |
| 1 | × | Kit de Capteurs DIYables (18 capteurs/écrans) |
Divulgation : Certains des liens fournis dans cette section sont des liens affiliés Amazon. Nous pouvons recevoir une commission pour tout achat effectué via ces liens, sans coût supplémentaire pour vous. Nous vous remercions de votre soutien.
À propos du LCD I2C 16x2
L'écran LCD I2C 16x2 est un écran comportant 16 colonnes et 2 rangées. Il dispose d'une interface I2C et est équipé d'un potentiomètre permettant de régler le contraste de l'écran.
Schéma des broches
L'écran LCD I2C utilise une interface I2C et comprend 4 broches.
- Broche GND : connectez-la à GND (0 volt).
- Broche VCC : connectez-la à VCC pour l'alimentation (5 volts).
- Broche SDA : transmet le signal de données I2C.
- Broche SCL : transmet le signal d'horloge I2C.
Coordonnée LCD
L'écran LCD I2C 16x2 comprend 16 colonnes et 2 lignes. La numérotation des colonnes et des lignes commence à partir de 0.
Diagramme de câblage
- Comment connecter l'ESP32 et l'écran LCD I2C en utilisant breadboard (alimenté via un câble USB)
Cette image a été créée avec Fritzing. Cliquez pour agrandir l'image.
- Comment connecter l'ESP32 et l'écran LCD I2C en utilisant plaque d'essai (alimenté par la broche Vin)
Cette image a été créée avec Fritzing. Cliquez pour agrandir l'image.
- Comment connecter l'ESP32 et l'écran LCD I2C en utilisant la carte d'extension à bornes à vis alimentée via un câble USB
- Comment connecter l'ESP32 et l'écran LCD I2C en utilisant une carte d'extension à bornes à vis (alimentée via la broche Vin)
| LCD I2C | ESP32 |
|---|---|
| VCC | Vin 5V |
| GND | GND |
| SDA | GPIO21 (SDA) |
| SCL | GPIO22 (SCL) |
Code MicroPython pour ESP32
/*
* Ce code ESP32 MicroPython a été développé par newbiely.fr
* Ce code ESP32 MicroPython est mis à disposition du public sans aucune restriction.
* Pour des instructions complètes et des schémas de câblage, veuillez visiter:
* https://newbiely.fr/tutorials/esp32-micropython/esp32-micropython-lcd-i2c
*/
from machine import I2C, Pin
from DIYables_MicroPython_LCD_I2C import LCD_I2C
import utime
# The I2C address of your LCD (Update if different)
I2C_ADDR = 0x27 # Use the address found using the I2C scanner
# Define the number of rows and columns on your LCD
LCD_ROWS = 2
LCD_COLS = 16
# Initialize I2C
i2c = I2C(1, scl=Pin(22), sda=Pin(21), freq=400000)
# Initialize LCD
lcd = LCD_I2C(i2c, I2C_ADDR, LCD_ROWS, LCD_COLS)
# Setup function
lcd.backlight_on()
lcd.clear()
# Main loop function
while True:
lcd.clear()
lcd.set_cursor(3, 0) # Move the cursor to column 3, row 0 (first row)
lcd.print("DIYables")
lcd.set_cursor(0, 1) # Move the cursor to column 0, row 1 (second row)
lcd.print("www.diyables.io")
utime.sleep(2)
lcd.clear()
lcd.set_cursor(0, 0) # Move to the beginning of the first row
lcd.print("Int: ")
lcd.print(str(1234)) # Print integer
lcd.set_cursor(0, 1) # Move to the beginning of the second row
lcd.print("Float: ")
lcd.print(str(56.78)) # Print float
utime.sleep(2)
Étapes rapides
Voici les instructions sur la façon de configurer et d’exécuter votre code MicroPython sur l’ESP32 en utilisant l’IDE Thonny :
- Assurez-vous que l'IDE Thonny est installé sur votre ordinateur.
- Confirmez que le micrologiciel MicroPython est chargé sur votre carte ESP32.
- Si c'est la première fois que vous utilisez un ESP32 avec MicroPython, consultez le guide ESP32 - Premiers pas. pour des instructions étape par étape.
- Connectez l'écran LCD I2C à l'ESP32 selon le schéma fourni.
- Connectez la carte ESP32 à votre ordinateur avec un câble USB.
- Ouvrez l'IDE Thonny sur votre ordinateur.
- Dans l'IDE Thonny, allez dans Outils Options.
- Sous l'onglet Interpréteur, choisissez MicroPython (ESP32) dans le menu déroulant.
- Assurez-vous que le bon port est sélectionné. L'IDE Thonny le détecte généralement automatiquement, mais vous devrez peut-être le sélectionner manuellement (comme COM12 sur Windows ou /dev/ttyACM0 sur Linux).
- Accédez à Outils Gérer les paquets dans l'IDE Thonny.
- Recherchez “DIYables-MicroPython-LCD-I2C”, puis trouvez la bibliothèque LCD I2C créée par DIYables.
- Cliquez sur DIYables-MicroPython-LCD-I2C, puis cliquez sur le bouton Install pour installer la bibliothèque LCD I2C.
- Copiez le code MicroPython fourni et collez-le dans l'éditeur de Thonny.
- Enregistrez le code sur votre ESP32 en :
- En cliquant sur le bouton Enregistrer ou en appuyant sur Ctrl+S.
- Dans la boîte de dialogue d'enregistrement, choisissez périphérique MicroPython.
- Nommez le fichier main.py.
- Cliquez sur le bouton vert Exécuter (ou appuyez sur F5) pour exécuter le script.
- Consultez le résultat sur l'écran LCD.
Faites plus avec l'écran LCD
Affichage d'un caractère personnalisé sur l'écran LCD
Pour afficher des caractères ou des symboles spéciaux (comme un cœur ou un oiseau en colère) sur un écran LCD, vous devrez utiliser un générateur de caractères. En effet, la fonction lcd.print() ne peut afficher que des caractères ASCII standard.
L'écran LCD 16x2 peut afficher 32 caractères, disposés en 16 positions par ligne sur 2 lignes. Chaque caractère est composé de 40 pixels, organisés en 8 lignes et 5 colonnes.
Le générateur de caractères crée un caractère (40 pixels). Il vous suffit de suivre ces étapes :
Click on each pixel to select/deselect
Copy below custom character code
Replace the heart in the below code
/*
* Ce code ESP32 MicroPython a été développé par newbiely.fr
* Ce code ESP32 MicroPython est mis à disposition du public sans aucune restriction.
* Pour des instructions complètes et des schémas de câblage, veuillez visiter:
* https://newbiely.fr/tutorials/esp32-micropython/esp32-micropython-lcd-i2c
*/
from machine import I2C, Pin
from DIYables_MicroPython_LCD_I2C import LCD_I2C
import utime
# The I2C address of your LCD (Update if different)
I2C_ADDR = 0x27
# Define the number of rows and columns on your LCD
LCD_ROWS = 2
LCD_COLS = 16
# Initialize I2C
i2c = I2C(1, scl=Pin(22), sda=Pin(21), freq=400000)
# Initialize LCD
lcd = LCD_I2C(i2c, I2C_ADDR, LCD_ROWS, LCD_COLS)
# Define custom character 0 (heart shape)
heart = [
0b00000,
0b01010,
0b11111,
0b11111,
0b01110,
0b00100,
0b00000,
0b00000
]
# Create the custom character at location 0
lcd.custom_char(0, heart)
# Display the custom character
lcd.print("Custom Char: ")
lcd.print_custom_char(0) # Display the custom character stored at location 0
Résultat affiché à l'écran :
Affichage de plusieurs caractères personnalisés sur un écran LCD
Nous pouvons créer jusqu'à 8 caractères spéciaux (de 0 à 7). Voici comment créer et afficher trois de ces caractères.
/*
* Ce code ESP32 MicroPython a été développé par newbiely.fr
* Ce code ESP32 MicroPython est mis à disposition du public sans aucune restriction.
* Pour des instructions complètes et des schémas de câblage, veuillez visiter:
* https://newbiely.fr/tutorials/esp32-micropython/esp32-micropython-lcd-i2c
*/
from machine import I2C, Pin
from DIYables_MicroPython_LCD_I2C import LCD_I2C
import utime
# The I2C address of your LCD (Update if different)
I2C_ADDR = 0x27
# Define the number of rows and columns on your LCD
LCD_ROWS = 2
LCD_COLS = 16
# Initialize I2C
i2c = I2C(1, scl=Pin(22), sda=Pin(21), freq=400000)
# Initialize LCD
lcd = LCD_I2C(i2c, I2C_ADDR, LCD_ROWS, LCD_COLS)
# Define custom character 0 (heart shape)
heart = [
0b00000,
0b01010,
0b11111,
0b11111,
0b01110,
0b00100,
0b00000,
0b00000
]
# Define custom character 1 (arrow pointing upwards)
arrow_up = [
0b00100,
0b01110,
0b11111,
0b00100,
0b00100,
0b00100,
0b00100,
0b00100
]
# Define custom character 2 (arrow pointing downwards)
arrow_down = [
0b00100,
0b00100,
0b00100,
0b00100,
0b00100,
0b11111,
0b01110,
0b00100
]
# Create the custom character at location 0
lcd.custom_char(0, heart)
lcd.custom_char(1, arrow_up)
lcd.custom_char(2, arrow_down)
# Display the custom character
lcd.set_cursor(0, 0) # Move the cursor to column 0, row 0 (first row)
lcd.print_custom_char(0) # Display the custom character stored at location 0
lcd.set_cursor(5, 0) # Move the cursor to column 5, row 0 (first row)
lcd.print_custom_char(1) # Display the custom character stored at location 0
lcd.set_cursor(10, 0) # Move the cursor to column 10, row 0 (first row)
lcd.print_custom_char(2) # Display the custom character stored at location 0
Résultat affiché sur l'écran LCD :
Résumé : Comment utiliser des caractères personnalisés sur un LCD
- Générer le code binaire : utilisez l'outil fourni pour générer le code binaire de votre caractère personnalisé.
- Notez le code : Copiez le code binaire depuis l'outil.
heart = [
0b00000,
0b01010,
0b11111,
0b11111,
0b01110,
0b00100,
0b00000,
0b00000
]
- Créez un caractère personnalisé et positionnez-le sur un nombre compris entre 0 et 7.
lcd.custom_char(0, heart)
- Afficher un symbole personnalisé sur l'écran LCD.
lcd.print_custom_char(0) # Afficher le caractère personnalisé stocké à l'emplacement 0
Dépannage de l'écran LCD I2C
Si vous avez des difficultés à afficher du texte sur votre écran LCD I2C, essayez ce qui suit :
- Ajuster la luminosité : Tournez le potentiomètre à l'arrière de l'écran LCD pour augmenter ou diminuer la luminosité.
- Vérifier l'adresse I2C : L'adresse I2C de l'écran LCD peut varier entre les fabricants. Les adresses courantes sont 0x27 et 0x3F. Expérimentez avec ces adresses pour voir si l'une d'elles fonctionne. Sinon, vous pouvez exécuter le code de scanner I2C ci-dessous sur une carte ESP32 pour rechercher la bonne adresse I2C.
/*
* Ce code ESP32 MicroPython a été développé par newbiely.fr
* Ce code ESP32 MicroPython est mis à disposition du public sans aucune restriction.
* Pour des instructions complètes et des schémas de câblage, veuillez visiter:
* https://newbiely.fr/tutorials/esp32-micropython/esp32-micropython-lcd-i2c
*/
from machine import I2C, Pin
import utime
i2c = I2C(1, scl=Pin(22), sda=Pin(21))
print('Scanning I2C bus...')
devices = i2c.scan()
if len(devices) == 0:
print("No I2C devices found")
else:
print('I2C devices found:',len(devices))
for device in devices:
print("Decimal address: ",device," | Hex address: ",hex(device))
utime.sleep(2)
Le résultat affiché dans le Shell en bas de Thonny :
Shell x
>>> %Run -c $EDITOR_CONTENT
MPY: soft reboot
Scanning I2C bus...
I2C devices found: 1
Decimal address: 39 | Hex address: 0x27
MicroPython (ESP32) • CP2102 USB To UART Bridge Controller @ COM12 ≡