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

Comentarios

Publicar un comentario

Entradas más populares de este blog

Fix Audio Windows on MAC

Imagen
  [GUIDE]  DSDT override  eGPU error 12 fix (Windows only)   here   ◄  Mac owners  please work through this thread to solve error 12 before doing a  DSDT override here   ◄  pre-compiled  DSDT overrides   - load or use as reference when making your own   Introduction   A Windows system's DSDT table root bridge definition (ACPI PNP0A08 or PNP0A03) is usually confined to a reserved 32-bit space (under 4GB) budgetted to be large enough to host the notebook's PCIe devices. A watermark TOLUD value is then set and locked in the system firmware. Windows OS honors the root bridge definition and will allocate PCIe devices within it. macOS ignores the root bridge constraints as too does Linux when booted with the 'pci=noCRS' parameter. Neither of those OS require a  DSDT override  and can allocate freely in the huge 64-bit PCIe address space.   When retrofitting a eGPU, an   error 12 (This device cannot find enough free resources that it can use)  can occur  against an eGPU in Win
Leer más

Tkinter tkFileDialog module

Imagen
Tkinter tkFileDialog module tkFileDialog  is a module with open and save dialog functions. Instead of implementing those in  Tkinter GUI  on your own. Related courses Tkinter GUI Application Development Projects Overview An overview of file dialogs: Function Parameters Purpose .askopenfilename Directory, Title, Extension To  open  file: Dialog that requests selection of an existing file. .asksaveasfilename Directory, Title, Extension) To  save  file: Dialog that requests creation or replacement of a file. .askdirectory None To  open directory Tkinter Open File The  askopenfilename  function to creates an file dialog object. The extensions are shown in the bottom of the form (Files of type). The code below will simply show the dialog and return the filename.  If a user presses cancel the filename is empty. On a Windows machine change the initialdir to “C:\”. Python 2.7 version: from Tkinter import * from Tkinter import * import Tkinter , Tkconstants ,
Leer más

Using real data types in VHDL

Imagen
Using real data types in VHDL    Apart from the standard types like integer and std_logic_vector's VHDL also offer  real  data types. But a real data type has a big disadvantage. It is not synthesis-able. It can be used only for simulation purposes. This disadvantage limits its use to a large extend, but there are plenty of projects where we look only for simulation results.   Before starting the coding part of a VHDL project,one has to decide whether the project to be implemented on a real FPGA or just a computer simulation is required. If it has to be ran on FPGA, then forget about the real package and use only synthesis-able data types like std_logic,integer etc... Otherwise you can reduce the time and complexity of your project by using real data types. The real data type is defined in the library called  MATH_REAL . So you have to include the following line before the entity declaration in the code: use ieee.math_real.all; The math_real package also offers some elemen
Leer más