Micropython.fr | Carte Pi Pico

I2C : Lcd

Ce que l'on va faire ici

Voici comment utiliser un afficheur I2C avec Micropython. Ici avec la carte Pi Pico

Le matériel

  • Un module afficheur LCD 1602 I2C (l'afficheur utilise un HD44780 et la com' I2C est faite via un PCF8574) - conso = 1.1mA + Led - Vcc=5V (Si 3.3V fonctionne mais affichage pas terrible..)
  • La carte micropython

Le montage

Sur la Pi Pico, on connecte :

  • les broches SDA/SCL du module connectées en GP16(SDA) /GP17 (SCL) qui corresponde à I2C n°0

  • Vbus (=5V alim USB) ou VSys idéalement ~5V et GND de la carte vers Vcc / GND du module.

Pré-requis

Les fichiers suivant sont à copier sur la flash :

Le plus simple c'est à l'aide de notre utilitaire copy.sh à partir du répertoire où se trouvent les libs.

Dispo ici : https://github.com/dhylands/python_lcd/tree/master/lcd

Le code

from machine import I2C, Pin # import class I2C
from pico_i2c_lcd import I2cLcd # import lib

# The PCF8574 has a jumper selectable address: 0x20 - 0x27
DEFAULT_I2C_ADDR = 0x27

"""Test function for verifying basic functionality."""
print("Running test_main")
i2c = I2C(0,scl=Pin(17), sda=Pin(16), freq=400000) # création de l'objet i2C
lcd = I2cLcd(i2c, DEFAULT_I2C_ADDR, 2, 16) # création de l'objet LCD i2c

lcd.putstr("It Works!\nSecond Line")
#delay(3000)
#lcd.clear()

Notes

Si on ne voit rien ou pas bien, il faut modifier le contraste en tournant le potentiomètre à l'arrière jusqu'à avoir une visibilité correcte. .

La librairie en question fournit :

La classe principale I2cLcd (qui elle-même ré-implémente la classe interne LcdApi ) fournit :

Constructeur

lcd=I2cLcd(i2c, DEFAULT_I2C_ADDR, lignes, colonnes)

où :

  • i2c : l'objet I2C à utiliser
  • DEFAULT_I2C_ADDR : l'adresse par défaut à utiliser
  • lignes : nombre de lignes
  • colonnes : nombre de colonnes

Voici par exemple la définition possible pour un LCD I2C 2x16 : 

DEFAULT_I2C_ADDR = 0x27
lcd = I2cLcd(i2c, DEFAULT_I2C_ADDR, 2, 16)

Fonctions

  • clear() : efface l'écran et ramène origine à 0,0 - sans effet sur l'état du curseur
  • hal_write_init_nibble() : fonction interne
  • display_off() : éteint l'écran
  • backlight_on() : allume le rétro-éclairage
  • hide_cursor() : masque le curseur
  • display_on() : allume écran
  • show_cursor() : montre le curseur
  • blink_cursor_on() : active clignotement curseur
  • blink_cursor_off() : désactive clignotement curseur
  • backlight_off() : éteint le rétro-éclairage
  • move_to(colonne,ligne) : se déplace en position voulue - La numérotation commence à 0,0 (1ère ligne, 1ère colonne)
  • putchar() : ajoute un caractère
  • putstr() : ajoute une chaîne (supporte saut de ligne !)
  • custom_char() : définition d'un caractère personnalisé
  • hal_sleep_us() : fonction interne

Propriétés

  • LCD_FUNCTION_RESET
  • LCD_FUNCTION
  • LCD_FUNCTION_2LINES
  • hal_write_command
  • hal_backlight_on
  • hal_backlight_off
  • hal_write_data
  • LCD_CLR
  • LCD_HOME
  • LCD_ENTRY_MODE
  • LCD_ENTRY_INC
  • LCD_ENTRY_SHIFT
  • LCD_ON_CTRL
  • LCD_ON_DISPLAY
  • LCD_ON_CURSOR
  • LCD_ON_BLINK
  • LCD_MOVE
  • LCD_MOVE_DISP
  • LCD_MOVE_RIGHT
  • LCD_FUNCTION_8BIT
  • LCD_FUNCTION_10DOTS
  • LCD_CGRAM
  • LCD_DDRAM
  • LCD_RS_CMD
  • LCD_RS_DATA
  • LCD_RW_WRITE
  • LCD_RW_READ

Tests dans l'interpréteur

On a ici une illustration de l'intérêt majeur du mode interpréteur pour explorer une librairie avec de nombreuses fonctions : il est facile de tester une à une les fonctions, voir l'effet, essayer une autre, etc... Bref, c'est à la fois ludique et efficace pour apprendre.

Note

Le gain de temps pour la découverte d'une librairie est énorme en utilisant l'interpréteur car on peut réagir immédiatement aux effets constatés, etc. Pas besoin de recompiler, etc. Et le code testé est copiable/collable facilement.

Par exemple : 

>>> from machine import I2C, Pin
>>> from pico_i2c_lcd import I2cLcd
>>> DEFAULT_I2C_ADDR = 0x27
>>> i2c = I2C(0,scl=Pin(17), sda=Pin(16), freq=400000)
>>> lcd = I2cLcd(i2c, DEFAULT_I2C_ADDR, 2, 16)
>>> lcd.move_to(8,0)
>>> lcd.put # double appui sur TAB pour auto-complétion
putchar         putstr
>>> lcd.putstr("Test")
>>> lcd.blink_cursor_o
blink_cursor_on                 blink_cursor_off
>>> lcd.blink_cursor_on()
>>> lcd.hide_cursor()
>>> lcd.clear()
>>> lcd.putchar('A')
>>> lcd.putstr("Micropython\nc'est cool !")
>>> lcd.clear()
>>> lcd.putstr("Micropython\nc'est cool !")
>>> lcd.clear() # efface et ramne origine  0,0
>>> lcd.move_to(1,1) # 2e ligne 2e colonne
>>> lcd.putchar('A')
>>> lcd.clear()
>>> lcd.show_cursor()
>>> lcd.clear()
>>> lcd.hide_cursor()
>>> import utime
>>> for i in range(10):
...     lcd.move_to(0,0)
...     lcd.putstr(str(i))
...     utime.sleep_ms(400)

# etc... trop cool !