MicroPython : écran LCD I2C avec ESP32/ESP8266

Apprenez à interfacer l’écran LCD (Liquid Crystal Display) I2C avec les cartes NodeMCU ESP32 et ESP8266 programmées avec MicroPython. Vous apprendrez comment connecter l’écran aux tableaux, quelles bibliothèques utiliser et écrire du code pour afficher du texte statique et défilant et des icônes personnalisées.

Vous utilisez l’IDE Arduino ? Suivez plutôt ce tutoriel : Comment utiliser l’écran LCD I2C avec ESP32 sur l’IDE Arduino (compatible ESP8266).

Table des matières:

Ce didacticiel couvre les sujets suivants :

Conditions préalables

Pour suivre ce tutoriel, vous devez installer le firmware MicroPython sur vos cartes ESP32 ou ESP8266. Vous avez également besoin d’un IDE pour écrire et télécharger le code sur votre tableau. Nous vous suggérons d’utiliser Thonny IDE ou uPyCraft IDE :

• ThonnyIDE :
• L’EDI uPyCraft :

En savoir plus sur MicroPython : Programmation MicroPython avec ESP32 et ESP8266

Pièces requises

Pour suivre ce tutoriel vous avez besoin des pièces suivantes :

Vous pouvez utiliser les liens précédents ou vous rendre directement sur MakerAdvisor.com/tools pour trouver toutes les pièces pour vos projets au meilleur prix !

Présentation de l’écran LCD

L’un des écrans d’affichage les plus simples et les moins chers est l’affichage à cristaux liquides (LCD). Les écrans LCD se trouvent dans les appareils électroniques courants tels que les distributeurs automatiques, les calculatrices, les parcomètres et les imprimantes, et sont idéaux pour afficher du texte ou de petites icônes.

Les écrans LCD sont mesurés en fonction du nombre de lignes et de colonnes de caractères qui tiennent sur l’écran. Un écran LCD 16×2 peut afficher 2 lignes de 16 caractères chacune. Vous trouverez des tailles allant du 8×1 au 40×4.

L’un des moyens les plus simples de contrôler un écran LCD avec un microcontrôleur consiste à en utiliser un doté d’une interface I2C. Nous utiliserons un écran LCD 16×2 qui utilise la communication I2C.

Pour suivre ce tutoriel, vous devez en obtenir un qui utilise également I2C. Quant à la taille, vous pouvez choisir la taille que vous souhaitez et elle doit être compatible.

LCD avec pilote I2C

L’avantage d’utiliser un écran LCD I2C est que le câblage est vraiment simple. Il vous suffit de câbler les broches SDA et SCL.

De plus, il est livré avec un potentiomètre intégré pour régler le contraste entre l’arrière-plan et les caractères de l’écran LCD. Sur un écran LCD « classique » sans support I2C, vous devez ajouter un potentiomètre au circuit pour régler le contraste.

Câblage de l’écran LCD I2C à l’ESP32/ESP8266

Étant donné que ce module LCD prend en charge la communication I2C, le câblage est très simple. Nous connecterons les broches I2C aux broches I2C par défaut de l’ESP32 et de l’ESP8266. La broche VCC de l’écran LCD doit être connectée au 5V.

En savoir plus sur le brochage des ESP32 et ESP8266 :

Schéma de circuit

Vous pouvez également utiliser les diagrammes suivants comme référence.

ESP32

Nœud MCU ESP8266

Trouver l’adresse LCD I2C

La plupart des écrans LCD I2C auront l’adresse I2C 0x27. Cependant, le vôtre pourrait être différent. Il est donc important de vérifier l’adresse I2C avant de continuer. Alors, consultez la fiche technique du capteur ou exécutez un croquis du scanner I2C.

Bibliothèques LCD – MicroPython

Il existe différentes bibliothèques qui facilitent la communication avec l’écran LCD. Nous utiliserons une combinaison de deux modules différents développés par l’utilisateur de dhylands GitHub.

Suivez les étapes suivantes pour installer les deux modules requis.

Téléchargez et téléchargez le lcd_api.py

1. Cliquez ici pour télécharger le code lcd_api.py ;
2. Copiez le code dans un fichier sur Thonny IDE ;
3. Allez dans Fichier > Enregistrer sous… et sélectionnez Périphérique MicroPython ;
4. Enregistrez le fichier sous le nom lcd_api.py (ne changez pas le nom).

# 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

Afficher le code brut

Téléchargez et téléchargez le machine_i2c_lcd.py

1. Cliquez ici pour télécharger le code machine_i2c_lcd.py ;
2. Copiez le code dans un fichier sur Thonny IDE ;
3. Allez dans Fichier > Enregistrer sous… et sélectionnez Périphérique MicroPython ;
4. Enregistrez le fichier sous le nom machine_i2c_lcd.py (ne changez pas le nom).

# 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]))

Afficher le code brut

Une fois les modules chargés sur les cartes, vous pouvez désormais utiliser les fonctionnalités de la bibliothèque dans votre code pour écrire du texte sur l’écran LCD.

Affichage du texte statique – Code

L’affichage de texte statique sur l’écran LCD est très simple. Tout ce que vous avez à faire est de sélectionner l’endroit où vous souhaitez que les caractères soient affichés sur l’écran, puis d’envoyer le message à l’écran. Si vous ne précisez pas où vous souhaitez afficher le texte, il sera écrit dans le premier espace disponible.

Cet exemple affiche le message « Hello, World ! » message dans la première ligne, puis sur la deuxième ligne. Il est compatible avec l’ESP32 et l’ESP8266, assurez-vous simplement de décommenter la définition des broches de l’ESP8266.

# Rui Santos & Sara Santos - Raspberryme.com
# Complete project details at https://Raspberryme.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()

Afficher le code brut

Comment fonctionne le code

Jetons un coup d’œil rapide au fonctionnement du code pour voir comment interagir avec l’écran LCD.

Importation de bibliothèques

Nous commençons par inclure tous les modules requis pour communiquer avec l’écran LCD. Nous utiliserons le logiciel I2C.

from machine import Pin, SoftI2C
from machine_i2c_lcd import I2cLcd
from time import sleep

Propriétés de l’écran LCD

Sur les lignes suivantes, définissez vos propriétés LCD. Notre écran LCD est un écran LCD 2 × 16 (2 lignes et 16 colonnes) et l’adresse I2C est 0x27. Si votre présentoir a des dimensions différentes ou s’il a une adresse différente, modifiez les lignes suivantes.

# Define the LCD I2C address and dimensions
I2C_ADDR = 0x27
I2C_NUM_ROWS = 2
I2C_NUM_COLS = 16

Communication I2C

Ensuite, nous initialisons I2C sur les GPIO 21 et 22 (pour l’ESP32), les broches que nous utilisons pour connecter l’écran LCD.

i2c = SoftI2C(sda=Pin(21), scl=Pin(22), freq=400000)

Si vous utilisez un ESP8266, assurez-vous de commenter la ligne précédente et de décommenter ce qui suit pour utiliser les broches I2C par défaut de l’ESP8266 (GPIO 4 et 5).

# for ESP8266, uncomment the following line
#i2c = SoftI2C(sda=Pin(4), scl=Pin(5), freq=400000)

Après avoir créé une instance I2C, nous pouvons initialiser une communication I2C avec l’écran LCD en utilisant la ligne suivante.

lcd = I2cLcd(i2c, I2C_ADDR, I2C_NUM_ROWS, I2C_NUM_COLS)

Nous créons un nouvel objet appelé lcd en utilisant la méthode I2cLcd() et passons en arguments l’instance i2c, l’adresse et le nombre de lignes et de colonnes. Nous pouvons maintenant utiliser lcd pour désigner l’écran LCD.

Écrire du texte

Maintenant que nous avons établi une communication, nous pouvons commencer à rédiger du texte. Écrire un texte simple est aussi simple que d’utiliser la méthode putstr() sur l’objet lcd et de passer en argument le texte que nous voulons afficher. Par exemple:

lcd.putstr("It's working :)")

Cela affichera le message «Ça marche 🙂». Parce que nous n’avons pas spécifié d’endroit et que l’écran LCD est toujours vide, il affichera le message à (0, 0) première ligne, première colonne.

Ensuite, nous avons une boucle while qui affiche en permanence « Hello World ! » sur l’écran LCD, en alternant entre les rangées du haut et du bas, créant un motif d’affichage simple et répétitif.

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)

Effacer l’écran

Avant d’écrire de nouvelles informations, nous effaçons le contenu de l’écran à l’aide de la méthode clear().

lcd.clear()

Ensuite, nous affichons la chaîne « Hello World ! » sur l’écran LCD. Par défaut, il commence dans le coin supérieur gauche de l’écran (position 0, 0).

lcd.putstr("Hello World!")

Ce message restera à l’écran pendant deux secondes.

sleep(2)

Après cela, nous effacerons à nouveau l’écran.

lcd.clear()

Déplacer le curseur

Après cela, nous utiliserons la méthode move_to() qui accepte comme arguments le numéro de ligne et de colonne, nous permettant de choisir où commencer à afficher le texte. Dans ce cas, nous plaçons la position du curseur au début de la deuxième ligne (ligne 1, colonne 0) de l’écran LCD. Cela nous permet d’afficher le deuxième « Hello World ! » message sur la deuxième ligne.

Éteindre le rétroéclairage

Nous ajoutons également un extrait pour éteindre la lumière LCD au cas où le programme serait arrêté par une interruption du clavier. Vous pouvez utiliser les méthodes backlight_off() et display_off().

except KeyboardInterrupt:
    # Turn off the display
    print("Keyboard interrupt")
    lcd.backlight_off()
    lcd.display_off()

Cet exemple simple montre les méthodes les plus utiles pour interagir avec l’écran LCD. Nous vous encourageons à jeter un œil aux modules machine_i2c_lcd.py et lcd_api.py et à vérifier et tester d’autres méthodes qui, selon vous, pourraient être utiles.

Tester le code

Exécutez le code précédent sur vos cartes ESP32 ou ESP8266. Vous recevrez d’abord un message indiquant que cela fonctionne.

Après, il affichera le message Hello, World! message dans la première ligne pendant deux secondes, puis dans la deuxième ligne pendant encore deux secondes. Ensuite, la boucle se répète jusqu’à ce que vous arrêtiez le programme.

Remarque : si vous souhaitez qu’un code s’exécute automatiquement au démarrage de l’ESP (par exemple, sans être connecté à votre ordinateur), vous devez enregistrer le fichier sur la carte sous le nom main.py.

Lorsque vous nommez un fichier main.py, l’ESP32 ou l’ESP8266 exécutera automatiquement ce fichier au démarrage. Si vous lui donnez un nom différent, il sera toujours enregistré sur le système de fichiers de la carte, mais il ne s’exécutera pas automatiquement au démarrage.

Dépannage

Si l’écran LCD a très peu de contraste et que vous voyez à peine les caractères, tournez le potentiomètre situé à l’arrière pour régler le contraste entre les caractères et le rétroéclairage.

De plus, assurez-vous d’alimenter l’écran LCD en 5 V. L’alimentation en 3V3 n’est pas suffisante pour la plupart de ces modules (sauf indication contraire dans la fiche technique).

Affichage du texte défilant

Le défilement du texte sur l’écran LCD est utile pour afficher des messages plus longs que la largeur de votre écran LCD (dans notre cas, plus de 16 caractères).

La bibliothèque que nous utilisons ne comprend pas de fonction spécifique pour faire défiler le texte, mais vous pouvez créer votre propre fonction en déplaçant le texte vers la gauche, une position à la fois. Voir l’exemple ci-dessous.

# Rui Santos & Sara Santos - Raspberryme.com
# Complete project details at https://Raspberryme.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()

Afficher le code brut

Comment fonctionne le code

Dans cet exemple, nous créons une fonction simple appelée scroll_message() qui accepte comme arguments le message à afficher et le délai entre chaque décalage. Par défaut, nous définissons le délai sur 0,3 seconde, mais vous pouvez l’ajuster en fonction de la vitesse à laquelle vous souhaitez que le texte défile.

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)

Sur cette fonction, nous commençons par ajouter un remplissage à notre message composé d’autant d’espaces vides que de nombre de colonnes (I2C_NUM_COLS) et d’un espace final à la fin. Nous faisons cela pour créer un espace à partir duquel commencer le défilement.

message = " " * I2C_NUM_COLS + message + " "

Ensuite, nous avons une boucle for qui parcourra les caractères de notre message. Nous plaçons la position du curseur dans le coin supérieur gauche de l’écran LCD (colonne 0, ligne 0) pour garantir que chaque itération commence au début de l’écran LCD.

lcd.move_to(0, 0)

Ensuite, nous affichons une partie du message sur l’écran LCD, en commençant par l’index d’itération actuel i et couvrant la largeur de l’écran LCD (caractères I2C_NUM_COLS).

lcd.putstr(message[i:i + I2C_NUM_COLS])

Le message d’expression suivant[i:i + I2C_NUM_COLS] obtient juste une partie du message commençant au caractère d’index i et se terminant au caractère i + IC2_NUM_COLS. Au fur et à mesure que nous augmentons la valeur de i, nous sélectionnons une nouvelle partie du message, créant ainsi l’effet de défilement.

Enfin, le délai à la fin déterminera la vitesse de défilement.

sleep(delay)

Pour faire défiler le texte, appelez la fonction scroll_message() et passez en arguments le message que vous souhaitez faire défiler et le délai.

scroll_message(message_scroll, 0.4)

Tester le code

Exécutez le code précédent sur votre carte ESP32 ou ESP8266. Vous devriez recevoir un message défilant. Vous pouvez ajuster la vitesse de défilement dans la variable delay de la fonction scroll_message().

Affichage des caractères personnalisés

Dans un écran LCD 16×2, il y a 32 blocs dans lesquels vous pouvez afficher des caractères. Chaque bloc est composé de 5×8 minuscules pixels. Vous pouvez afficher des caractères personnalisés en définissant l’état de chaque petit pixel. Pour cela, vous pouvez créer une variable de tableau d’octets pour contenir l’état de chaque pixel.

Création de personnages personnalisés

La plupart des écrans LCD vous permettent de télécharger environ 8 caractères personnalisés dans la mémoire de l’écran LCD que vous pourrez utiliser ultérieurement. Ensuite, vous pouvez accéder aux caractères par leur index (0 à 7).

Pour créer votre personnage personnalisé, vous pouvez aller ici et concevoir votre personnage personnalisé. Ensuite, générez la variable de tableau d’octets pour votre personnage. Par exemple, un cœur :

Le tableau d’octets est surligné en jaune. Copiez le tableau d’octets sur une seule ligne. Par exemple, dans le cas du personnage de cœur :

0x00, 0x0A, 0x1F, 0x0E, 0x04, 0x00, 0x00

Enregistrez votre tableau d’octets car vous l’utiliserez plus tard dans le code.

Affichage des caractères personnalisés – Code

Le code suivant affiche trois caractères personnalisés, un thermomètre, un parapluie et un cœur. Vous pouvez afficher n’importe quel caractère de votre choix en utilisant son tableau d’octets.

# Rui Santos & Sara Santos - Raspberryme.com
# Complete project details at https://Raspberryme.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()

Afficher le code brut

Comment fonctionne le code

Tout d’abord, vous devez enregistrer votre tableau d’octets dans une variable comme suit :

thermometer = bytearray([0x04, 0x0A, 0x0A, 0x0A, 0x0A, 0x1B, 0x1F, 0x0E])

Modifiez le tableau d’octets pour tous les autres caractères que vous souhaitez afficher. Dans notre cas, nous arborons également un parapluie et un cœur.

Ensuite, pour enregistrer votre personnage sur la mémoire de votre écran LCD, vous devez utiliser la fonction custom_char() sur l’objet lcd et passer en argument l’index où vous souhaitez enregistrer le caractère et le tableau d’octets de ce caractère.

lcd.custom_char (0, thermometer)

Nous effectuons ce processus précédent pour tous les caractères personnalisés que nous souhaitons afficher, mais chacun est enregistré sur un index custom_char() différent.

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)

Enfin, pour afficher votre personnage personnalisé il vous suffit d’utiliser la fonction putchar() de la manière suivante :

lcd.putchar(chr(0))

Dans notre cas, chr(0) correspond au thermomètre, le caractère que nous avons enregistré sur l’index 0. Nous procédons de la même manière pour tous les autres caractères. Dans notre cas, nous affichons un message statique sur la première ligne, puis nous affichons nos caractères personnalisés sur la deuxième ligne.

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))

Comme vous pouvez le constater, l’affichage des caractères personnalisés est assez simple.

Tester le code

Exécutez ou téléchargez le code sur votre carte ESP32 ou ESP8266. L’écran LCD affichera vos caractères personnalisés. N’hésitez pas à modifier le code et à afficher vos propres caractères personnalisés. Vous pouvez également utiliser plusieurs blocs adjacents pour créer une icône plus grande sur l’écran.

Conclusion

Dans ce didacticiel, vous avez appris à utiliser l’écran LCD (Liquid Crystal Display) I2C avec les ESP32 et ESP8266 programmés avec le micrologiciel MicroPython. Nous avons expliqué comment afficher du texte statique, du texte défilant et des caractères personnalisés.

Nous espérons que ce guide vous sera utile. Nous avons des tutoriels similaires pour l’écran OLED :

Si vous souhaitez en savoir plus sur la programmation de l’ESP32 et de l’ESP8266 à l’aide du micrologiciel MicroPython, consultez nos ressources :

Plongez dans l’histoire de Raspberry Pi avec cette vidéo :