Utilisation d’un afficheur 4 lignes

L’affichage de données provenant d’un raspberry (comme d’un arduino) peut se faire avec un écran plus ou moins grand, en revanche pour un affichage d’un nombre de donnée connu et peu élevées qui ne nécessite pas de couleur ou d’affichage particulier, l’affichage sur quelques lignes suffit.

Voici un petit script pour utiliser un afficheur 4 lignes avec 20 caractères par ligne sur le Rapsberry.

Cet afficheur est disponible sur Amazon.

Pour la réalisation et le fonctionnement, j’ai eu pas mal de souci, voici la documentation.

L’afficheur 4 lignes, 20 caractères (4*20)

Cet afficheur est un standard pour la visualisation d’informations quelques soit la complexité du projet, sa configuration en 4 * 20, permet un affichage clair.

Dimensions

En terme d’emplacement :

caracteristiques écran LCD
caracteristiques écran LCD

Disposition des pins

Le nom des pins est présent sur la carte mais voici un petit récapitulatif :
[table id=9 /]
Certains afficheurs disposent d’un rétro éclairage qui sera alimenter en 5 V entre les pins 15 et 16.

Utilisation de l’afficheur sur le Raspberry

Nous allons utiliser un script python, ma première intention était de fournir un montage et un script pour utiliser un MCP23017 (un registre) qui permet d’étendre le nombre de GPIO disponible (on peut utiliser soit 8 bits de données, soit 4 bits donc dans le meilleur des cas, utiliser 6 GPIO).

Mais après plusieurs tentatives, je n’ai toujours pas réussi à le faire fonctionner comme ça (mais je persévère), en attandant voici une solution (gourmande en GPIO), le tutoriel est issu www.raspberrypi-spy.co.uk.

Câblage de l’afficheur sur le raspberry

Voici le câblage :

câblage écran lcd
câblage écran lcd

Le réglage du contraste se fait sur la pin 3 via un potentiomêtre de 10kohms.

Code python pour utiliser le raspberry et l’afficheur

Voici le code avec des petits commentaires pour la compréhension :

#!/usr/bin/python
#-*- coding: utf8 -*-

# Le câblage de l'afficheur est comme suit:
# 1 : GND
# 2 : 5V
# 3 : Contrast (0-5V)*
# 4 : RS (Register Select)
# 5 : R/W (Read Write) - GND sur ce pin
# 6 : Enable or Strobe
# 7 : Data Bit 0 - Inutilisé
# 8 : Data Bit 1 - Inutilisé
# 9 : Data Bit 2 - Inutilisé
# 10: Data Bit 3 - Inutilisé
# 11: Data Bit 4
# 12: Data Bit 5
# 13: Data Bit 6
# 14: Data Bit 7
# 15: LCD Backlight +5V** - Optionnel
# 16: LCD Backlight GND - Optionnel

#import
import RPi.GPIO as GPIO
import time
# Définition des GPIO utiliser
LCD_RS = 7
LCD_E = 8
LCD_D4 = 25
LCD_D5 = 24
LCD_D6 = 23
LCD_D7 = 18
LED_ON = 15

# Définition de paramêtre de l'afficheur
LCD_WIDTH = 20 # Nombre de caratère maximum par ligne
LCD_CHR = True
LCD_CMD = False

LCD_LINE_1 = 0x80 # LCD RAM adresse pour la 1er ligne
LCD_LINE_2 = 0xC0 # LCD RAM adresse pour la 2eme ligne
LCD_LINE_3 = 0x94 # LCD RAM adresse pour la 3eme ligne
LCD_LINE_4 = 0xD4 # LCD RAM adresse pour la 4eme ligne

# Constante de temps
E_PULSE = 0.0005
E_DELAY = 0.0005

def main():
      # Séquence du programme principale

      GPIO.setmode(GPIO.BCM) # Utilisation des numéros BCM GPIO
     GPIO.setup(LCD_E, GPIO.OUT) # E
      GPIO.setup(LCD_RS, GPIO.OUT) # RS
      GPIO.setup(LCD_D4, GPIO.OUT) # DB4
      GPIO.setup(LCD_D5, GPIO.OUT) # DB5
      GPIO.setup(LCD_D6, GPIO.OUT) # DB6
      GPIO.setup(LCD_D7, GPIO.OUT) # DB7
      GPIO.setup(LED_ON, GPIO.OUT) # Activation du rétroéclairage, optionnel

# Initialisation de l'écran
lcd_init()
# Activation du rétro éclairage
lcd_backlight(True)
time.sleep(0.5)
lcd_backlight(False)
time.sleep(0.5)
lcd_backlight(True)
time.sleep(0.5)

while True:

      # Affichage de test pour l'exemple
      lcd_string("--------------------",LCD_LINE_1,2)
      lcd_string("Rasbperry Pi",LCD_LINE_2,2)
      lcd_string("Modele 2",LCD_LINE_3,2)
      lcd_string("--------------------",LCD_LINE_4,2)

      time.sleep(3) # 3 secondes d'attente

      lcd_string("La programmation",LCD_LINE_1,3)
      lcd_string("sur le web",LCD_LINE_2,3)
      lcd_string("France",LCD_LINE_3,2)
      lcd_string("20x4 LCD Module Test",LCD_LINE_4,2)

      time.sleep(3) # 3 secondes d'attente

      # Effacement de l'écran
      lcd_byte(0x01, LCD_CMD)

      time.sleep(3) # 3 secondes d'attente

def lcd_init():
      # Séquence d'initialisation de l'écran
      lcd_byte(0x33,LCD_CMD) # 110011 Initialisation
      lcd_byte(0x32,LCD_CMD) # 110010 Initialisation
      lcd_byte(0x06,LCD_CMD) # 000110 Direction du mouvement de cursor
      lcd_byte(0x0C,LCD_CMD) # 001100 Display On,Cursor Off, Blink Off
      lcd_byte(0x28,LCD_CMD) # 101000 Nombre de bit de donnée, Nombre de ligne, Taille de la police
      lcd_byte(0x01,LCD_CMD) # 000001 VIder l'écran
      time.sleep(E_DELAY)

def lcd_byte(bits, mode):
      # Envoi des bites sur les pins de données
      # bits = data
      # mode = True pour les caractère
      # False pour la commande

      GPIO.output(LCD_RS, mode) # RS

      # Bits de poids fort
      GPIO.output(LCD_D4, False)
      GPIO.output(LCD_D5, False)
      GPIO.output(LCD_D6, False)
      GPIO.output(LCD_D7, False)
      if bits&0x10==0x10:
           GPIO.output(LCD_D4, True)
      if bits&0x20==0x20:
           GPIO.output(LCD_D5, True)
      if bits&0x40==0x40:
           GPIO.output(LCD_D6, True)
      if bits&0x80==0x80:
           GPIO.output(LCD_D7, True)

      # Impulsion sur la pin 'enable'
      lcd_toggle_enable()

      # Bits de poids faible
      GPIO.output(LCD_D4, False)
      GPIO.output(LCD_D5, False)
      GPIO.output(LCD_D6, False)
      GPIO.output(LCD_D7, False)
      if bits&0x01==0x01:
           GPIO.output(LCD_D4, True)
      if bits&0x02==0x02:
           GPIO.output(LCD_D5, True)
      if bits&0x04==0x04:
           GPIO.output(LCD_D6, True)
      if bits&0x08==0x08:
           GPIO.output(LCD_D7, True)
# Impulsion sur la pin 'enable'
      lcd_toggle_enable()

def lcd_toggle_enable():
     # Impulsion pour l'activation
      time.sleep(E_DELAY)
      GPIO.output(LCD_E, True)
      time.sleep(E_PULSE)
      GPIO.output(LCD_E, False)
      time.sleep(E_DELAY)

def lcd_string(message,line,style):
      # Envoi de la ligne à afficher
      # style=1 Justifié à gauche
      # style=2 Centré
      # style=3 Justifié à droite

      if style==1:
           message = message.ljust(LCD_WIDTH," ")
      elif style==2:
           message = message.center(LCD_WIDTH," ")
      elif style==3:
           message = message.rjust(LCD_WIDTH," ")

      lcd_byte(line, LCD_CMD)

      for i in range(LCD_WIDTH):
           lcd_byte(ord(message[i]),LCD_CHR)

def lcd_backlight(flag):
      # Commande du rétroéclairage, optionnel
      GPIO.output(LED_ON, flag)

if __name__ == '__main__':

      try:
           main()
      except KeyboardInterrupt:
           pass
      finally:
           lcd_byte(0x01, LCD_CMD)
           lcd_string("En revoir!",LCD_LINE_1,2)
           GPIO.cleanup()

Démonstration vidéo

Laisser un commentaire