Documentation du Projet LCD avec Raspberry Pi

Introduction

Ce projet montre comment connecter et programmer un écran LCD (mode 8 bits) avec un Raspberry Pi. Le code initialise l'écran, affiche un message statique et maintient l'affichage en continu. Ce tutoriel est destiné aux étudiants qui souhaitent comprendre comment contrôler un écran LCD en Python avec le module machine.

Matériel Nécessaire

• Raspberry Pi (avec MicroPython installé)
• Écran LCD 16x2 (compatible HD44780)
• Fils de connexion
• Alimentation pour le Raspberry Pi et le LCD
• Breadboard (facultatif, pour organiser les connexions)

Schéma du Montage

Insérez ici le schéma de montage de votre circuit. Par exemple :

Assurez-vous que les connexions correspondent aux numéros de broches utilisés dans le code.

Le Code

Le code suivant initialise l'écran LCD, affiche un message sur deux lignes et laisse le message affiché en continu :

import machine
import utime

# Configuration des broches en mode 8 bits
rs_pin = machine.Pin(17, machine.Pin.OUT)  # Broche RS (Register Select)
e_pin  = machine.Pin(16, machine.Pin.OUT)   # Broche E (Enable)
data_pins = [
    machine.Pin(28, machine.Pin.OUT),  # D0
    machine.Pin(27, machine.Pin.OUT),  # D1
    machine.Pin(26, machine.Pin.OUT),  # D2
    machine.Pin(22, machine.Pin.OUT),  # D3
    machine.Pin(21, machine.Pin.OUT),  # D4
    machine.Pin(20, machine.Pin.OUT),  # D5
    machine.Pin(19, machine.Pin.OUT),  # D6
    machine.Pin(18, machine.Pin.OUT)   # D7
]

# Fonction pour envoyer une commande au LCD
def lcd_command(cmd):
    rs_pin.value(0)  # Mode commande
    for i in range(8):
        data_pins[i].value((cmd >> i) & 1)
    e_pin.value(1)
    utime.sleep_us(1)
    e_pin.value(0)
    utime.sleep_us(50)  # Délai pour le traitement de la commande

# Fonction pour effacer l'écran LCD
def lcd_clear():
    lcd_command(0x01)
    utime.sleep_ms(2)

# Fonction pour positionner le curseur sur le LCD
def lcd_set_cursor(row, col):
    address = (0x40 * row) + col
    lcd_command(0x80 | address)

# Fonction pour écrire une chaîne de caractères sur le LCD
def lcd_write_string(string):
    rs_pin.value(1)  # Mode données
    for char in string:
        for i in range(8):
            data_pins[i].value((ord(char) >> i) & 1)
        e_pin.value(1)
        utime.sleep_us(1)
        e_pin.value(0)
        utime.sleep_us(50)

# Fonction d'initialisation du LCD
def lcd_init():
    lcd_command(0x38)  # Mode 8 bits, 2 lignes, police 5x8
    lcd_command(0x0C)  # Affichage activé, curseur masqué
    lcd_command(0x06)  # Incrémentation du curseur
    lcd_clear()

# --- Programme principal ---
lcd_init()

lcd_set_cursor(0, 0)
lcd_write_string("Hello, world!")

lcd_set_cursor(1, 0)
lcd_write_string("LCD connecte!")

while True:
    utime.sleep(1)

Explications du Code

• Configuration des broches :
  Les broches du Raspberry Pi sont configurées en sortie pour contrôler l'écran LCD.

  • rs_pin gère le mode commande/donnée.
  • e_pin (Enable) déclenche l'envoi de données.
  • data_pins représente les 8 lignes de données (D0 à D7).

• Fonction lcd_command(cmd) :
  Envoie une commande au LCD en mode commande (RS = 0).

• Fonction lcd_clear() :
  Efface l'écran et attend 2 ms pour la réinitialisation.

• Fonction lcd_set_cursor(row, col) :
  Positionne le curseur en fonction de la ligne et de la colonne.

• Fonction lcd_write_string(string) :
  Affiche une chaîne de caractères en envoyant chaque caractère au LCD.

• Fonction lcd_init() :
  Initialise le LCD avec les bons paramètres et efface l'écran.

• Boucle principale :
  Le message reste affiché grâce à la boucle while True:.

Remarques

• Vérifiez que les numéros de broches utilisés correspondent à votre montage.
• Les délais (utime.sleep_us et utime.sleep_ms) sont importants pour la stabilité de l'affichage.
• Ce code fonctionne en mode 8 bits. Pour un mode 4 bits, il faudra adapter le code.

Conclusion

Ce tutoriel vous montre comment connecter un écran LCD à un Raspberry Pi et afficher un message de manière permanente. N'hésitez pas à expérimenter avec le code pour afficher d'autres messages ou l'intégrer dans des projets plus complexes.