LCD 2004 i2c Raspberry PI

1- Necesario

- una pantalla de 4 × 20 I²C ( de este tipo ) 
- un convertidor lógico 3.3v-5v a 70 centavos ( ejemplo )

2- Conexiones

Iremos cada vez que el convertidor, será lo más sencillo de explicar.

Lado 5V: 
conecte AVCC a + 5v desde Pi 
conecte AVCC a + 5v desde pantalla 
conecte AGND a GND desde PI 
conecte AGND a GND desde pantalla 
conecte ASCL a SCL desde pantalla 
conecte ASDA a SDA desde pantalla

Lado de 
3,3 V : conecte BVCC a Pi + 3,3 V 
conecte BGND a Pi GND 
conecte BSCL a PI's SCL 
conecte BSDA a Pi SDA

Gracias a este conjunto, es posible agregar tantos componentes / módulos I²C como desee (casi), ya sea en 3.3V o 5V: los módulos de 5V están conectados al lado A del convertidor, los módulos 3.3V (incluyendo la Pi) se conectan en el lado B.

2- Activación y configuración del módulo de software I²C.

Aquí, me repetiré especialmente ... Ya hemos preparado todo en el tutorial sobre el reloj RTC.

Añadimos los módulos al inicio:

sudo nano /etc/modules

Añade estas 2 líneas:

i2c-bcm2708 
i2c-dev

Reiniciamos:

sudo reboot

Instalamos las herramientas necesarias:

sudo apt-get install python-smbus i2c-tools

Eliminamos los módulos I²C de la lista negra (si es el caso):

sudo nano /etc/modprobe.d/raspi-blacklist.conf

la línea

blacklist i2c-bcm2708

se convierte en

#blacklist i2c-bcm2708

Reiniciamos, y el Raspi debería estar listo para usar dispositivos I²C.

3- Prueba de interfaz I²C

Usaremos el comando i2cdetect, que permite ver la lista de dispositivos I²C conectados a Pi. El comando es diferente si usa una Raspberry Pi Rev 1 o Rev 2 (la dirección del bus I²C es diferente), así que elija la correcta :

sudo i2cdetect -y 0 (pour la Rev 1)

sudo i2cdetect -y 1 (pour la Rev 2)

En esta captura, podemos ver que tengo 3 componentes I²C: 
- la pantalla en la dirección # 27 
- el chip AT24C32 del reloj RTC en la dirección # 50 
- el chip DS1307 del reloj RTC en dirección # 68 (está marcada como "UU" porque está en uso) 
Es posible que su pantalla tenga una dirección diferente, ya la he visto en 24 y 28. Anote esta dirección si es diferente A partir del 27, lo necesitaremos más adelante para configurar el driver.

4- Instalación del controlador

Usaremos un pequeño controlador de Python para comunicarnos con la pantalla. Comprenderás, si queremos comunicarnos con la pantalla, estará en python. 
En una carpeta, crearemos 2 archivos:

sudo nano i2c_lib.py

import smbus
from time import *

class i2c_device:
   def __init__(self, addr, port=1):
      self.addr = addr
      self.bus = smbus.SMBus(port)

# Write a single command
   def write_cmd(self, cmd):
      self.bus.write_byte(self.addr, cmd)
      sleep(0.0001)

# Write a command and argument
   def write_cmd_arg(self, cmd, data):
      self.bus.write_byte_data(self.addr, cmd, data)
      sleep(0.0001)

# Write a block of data
   def write_block_data(self, cmd, data):
      self.bus.write_block_data(self.addr, cmd, data)
      sleep(0.0001)

# Read a single byte
   def read(self):
      return self.bus.read_byte(self.addr)

# Read
   def read_data(self, cmd):
      return self.bus.read_byte_data(self.addr, cmd)

# Read a block of data
   def read_block_data(self, cmd):
      return self.bus.read_block_data(self.addr, cmd)

sudo nano lcddriver.py

import i2c_lib
from time import *

# LCD Address
ADDRESS = 0x27

# commands
LCD_CLEARDISPLAY = 0x01
LCD_RETURNHOME = 0x02
LCD_ENTRYMODESET = 0x04
LCD_DISPLAYCONTROL = 0x08
LCD_CURSORSHIFT = 0x10
LCD_FUNCTIONSET = 0x20
LCD_SETCGRAMADDR = 0x40
LCD_SETDDRAMADDR = 0x80

# flags for display entry mode
LCD_ENTRYRIGHT = 0x00
LCD_ENTRYLEFT = 0x02
LCD_ENTRYSHIFTINCREMENT = 0x01
LCD_ENTRYSHIFTDECREMENT = 0x00

# flags for display on/off control
LCD_DISPLAYON = 0x04
LCD_DISPLAYOFF = 0x00
LCD_CURSORON = 0x02
LCD_CURSOROFF = 0x00
LCD_BLINKON = 0x01
LCD_BLINKOFF = 0x00

# flags for display/cursor shift
LCD_DISPLAYMOVE = 0x08
LCD_CURSORMOVE = 0x00
LCD_MOVERIGHT = 0x04
LCD_MOVELEFT = 0x00

# flags for function set
LCD_8BITMODE = 0x10
LCD_4BITMODE = 0x00
LCD_2LINE = 0x08
LCD_1LINE = 0x00
LCD_5x10DOTS = 0x04
LCD_5x8DOTS = 0x00

# flags for backlight control
LCD_BACKLIGHT = 0x08
LCD_NOBACKLIGHT = 0x00

En = 0b00000100 # Enable bit
Rw = 0b00000010 # Read/Write bit
Rs = 0b00000001 # Register select bit

class lcd:
   #initializes objects and lcd
   def __init__(self):
      self.lcd_device = i2c_lib.i2c_device(ADDRESS)

      self.lcd_write(0x03)
      self.lcd_write(0x03)
      self.lcd_write(0x03)
      self.lcd_write(0x02)

      self.lcd_write(LCD_FUNCTIONSET | LCD_2LINE | LCD_5x8DOTS | LCD_4BITMODE)
      self.lcd_write(LCD_DISPLAYCONTROL | LCD_DISPLAYON)
      self.lcd_write(LCD_CLEARDISPLAY)
      self.lcd_write(LCD_ENTRYMODESET | LCD_ENTRYLEFT)
      sleep(0.2)

   # clocks EN to latch command
   def lcd_strobe(self, data):
      self.lcd_device.write_cmd(data | En | LCD_BACKLIGHT)
      sleep(.0005)
      self.lcd_device.write_cmd(((data & ~En) | LCD_BACKLIGHT))
      sleep(.0001)

   def lcd_write_four_bits(self, data):
      self.lcd_device.write_cmd(data | LCD_BACKLIGHT)
      self.lcd_strobe(data)

   # write a command to lcd
   def lcd_write(self, cmd, mode=0):
      self.lcd_write_four_bits(mode | (cmd & 0xF0))
      self.lcd_write_four_bits(mode | ((cmd << 4) & 0xF0))

   # put string function
   def lcd_display_string(self, string, line):
      if line == 1:
         self.lcd_write(0x80)
      if line == 2:
         self.lcd_write(0xC0)
      if line == 3:
         self.lcd_write(0x94)
      if line == 4:
         self.lcd_write(0xD4)

      for char in string:
         self.lcd_write(ord(char), Rs)

   # clear lcd and set to home
   def lcd_clear(self):
      self.lcd_write(LCD_CLEARDISPLAY)
      self.lcd_write(LCD_RETURNHOME)

En este último archivo, puede ajustar la dirección de su pantalla si no es 27:

# LCD Address
ADDRESS = 0x27

5- Usando la pantalla

Esto es lo más fácil ... 
Cuando desee utilizar la pantalla en un script, solo tiene que incluir los 2 archivos del controlador en la carpeta de su script. Aquí está el mínimo a utilizar para operar la pantalla:

# on importe le pilote
import lcddriver
from time import *

# on initialise le lcd
lcd = lcddriver.lcd()

# on reinitialise le lcd
lcd.lcd_clear()

# on affiche des caracteres sur chaque ligne
lcd.lcd_display_string("   Hello world !", 1)
lcd.lcd_display_string("      Je suis", 2)
lcd.lcd_display_string("        un", 3)
lcd.lcd_display_string("   Raspberry Pi !", 4)