Como configurar um LCD I2C no Raspberry Pi

cupom com desconto - o melhor site de cupom de desconto cupomcomdesconto.com.br


A conexão de um LCD ao seu Raspberry Pi apimentará quase qualquer projeto, mas e se seus pinos estiverem ligados a conexões com outros módulos? Não tem problema, basta conectar o seu LCD ao I2C, ele usa apenas dois pinos (bem, quatro se você contar a terra e a energia).

Como configurar um LCD I2C no Raspberry Pi 1

Neste tutorial, mostrarei tudo o que você precisa para configurar um LCD usando o I2C, mas se você quiser saber mais sobre o I2C e os detalhes de como ele funciona, confira nosso artigo Noções básicas do I2C Communication Protocol.

BÔNUS: Fiz um guia de início rápido para este tutorial, que você pode baixar e voltar mais tarde, se não puder configurá-lo agora. Ele abrange todas as etapas, diagramas e códigos que você precisa para começar.

Existem algumas maneiras de usar o I2C para conectar um LCD ao Raspberry Pi. O mais simples é obter um LCD com uma mochila I2C. A maneira hardcore de bricolage é usar um LCD HD44780 padrão e conectá-lo ao Pi através de um chip chamado PCF8574.

O PCF8574 converte o sinal I2C enviado do Pi em um sinal paralelo que pode ser usado pelo LCD. A maioria dos LCDs I2C usa o PCF8574 de qualquer maneira. Vou explicar como conectar os dois lados em um minuto.

Também mostrarei como programar o LCD usando Python e fornecerei exemplos de como imprimir e posicionar o texto, limpar a tela, rolar texto, imprimir dados de um sensor, imprimir a data e a hora e imprimir o endereço IP do seu Pi.

Se você não possui um LCD habilitado para I2C ou um PCF8574, estes tutoriais mostrarão como conectar um LCD aos pinos GPIO:

Aqui está a versão em vídeo deste tutorial, na qual passo a instalação e mostro todos os exemplos de programação abaixo:

Ligue o LCD

O I2C (circuito inter-integrado) também é conhecido como interface de dois fios, pois usa apenas dois fios para enviar e receber dados. Na verdade, são necessários quatro se você contar os fios Vcc e terra, mas a energia sempre pode vir de outra fonte.

Conectando um LCD ativado para I2C

Raspberry Pi I2C LCD - I2C Backpack LCD

Conectar um LCD com uma mochila I2C é bastante auto-explicativo. Conecte o pino SDA no Pi ao pino SDA no LCD e o pino SCL no Pi ao pino SCL no LCD. Os pinos terra e Vcc também precisarão ser conectados. A maioria dos LCDs pode operar com 3,3V, mas eles devem funcionar com 5V, portanto, conecte-o ao pino de 5V do Pi, se possível.

Conectando um LCD com um PCF8574

Raspberry Pi I2C LCD - PCF8574

Se você possui um LCD sem I2C e possui um chip PCF8574, pode usá-lo para conectar seu LCD com um pouco de fiação extra. O PCF8574 é um expansor de E / S de 8 bits que converte um sinal paralelo em I2C e vice-versa. O Raspberry Pi envia dados para o PCF8574 via I2C. O PCF8574 converte o sinal I2C em um sinal paralelo de 4 bits, que é retransmitido para o LCD.

Use o diagrama a seguir para conectar o LCD ao Raspberry Pi via PCF8574:

Leia Também  5 riscos que você pode evitar e que facilitarão sua vida

Raspberry Pi LCD - Diagrama de conexão I2C

  • R1: resistor de 10K Ohm
  • Potenciômetros: 10K Ohms, mas podem ser substituídos por resistores de 1K a 3K Ohm

No diagrama acima, o fio azul se conecta ao pino SDA do Raspberry Pi. O fio amarelo se conecta ao pino SCL do Pi.

Ativar I2C no Pi

Antes de começarmos a programação, precisamos garantir que o módulo I2C esteja ativado no Pi e instalar algumas ferramentas que tornarão mais fácil o uso do I2C.

Habilitar I2C no raspi-config

Primeiro, faça login no seu Pi e digite sudo raspi-config para acessar o menu de configuração. Em seguida, seta para baixo e selecione “Configurações avançadas”:

Raspberry Pi LCD - Conexões I2C - sudo raspi-config

Agora, seta para baixo e selecione “I2C Ativar / Desativar carregamento automático”:

Raspberry Pi LCD - Conexões I2C - sudo raspi-config enable i2c

Escolha “Sim” no próximo prompt, saia do menu de configuração e reinicie o Pi para ativar as configurações.

Instale ferramentas I2C e SMBUS

Agora precisamos instalar um programa chamado I2C-tools, que nos dirá o endereço I2C do LCD quando ele estiver conectado ao Pi. Portanto, no prompt de comando, digite sudo apt-get install i2c-tools.

Em seguida, precisamos instalar o SMBUS, que fornece à biblioteca Python o acesso ao barramento I2C no Pi. No prompt de comando, insira sudo apt-get install python-smbus.

Agora reinicie o Pi e efetue login novamente. Com o seu LCD conectado, digite i2cdetect -y 1 no prompt de comando. Isso mostrará uma tabela de endereços para cada dispositivo I2C conectado ao seu Pi:

Raspberry Pi LCD - Conexões I2C - Detecção I2C

O endereço I2C do meu LCD é 21. Anote esse número, precisaremos mais tarde.

Programando o LCD

Usaremos o Python para programar o LCD; portanto, se for a primeira vez que você escreve / executa um programa em Python, consulte Como escrever e executar um programa em Python no Raspberry Pi antes de prosseguir.

Instalando a biblioteca

Encontrei uma biblioteca Python I2C que possui um bom conjunto de funções e funciona muito bem. Esta biblioteca foi originalmente publicada aqui, depois expandida e aprimorada pelo usuário do GitHub DenisFromHR.

Copie esse código para a biblioteca e salve-o em um arquivo chamado I2C_LCD_driver.py:

# -*- coding: utf-8 -*-
# Original code found at:
# https://gist.github.com/DenisFromHR/cc863375a6e19dce359d

"""
Compiled, mashed and generally mutilated 2014-2015 by Denis Pleic
Made available under GNU GENERAL PUBLIC LICENSE

# Modified Python I2C library for Raspberry Pi
# as found on http://www.recantha.co.uk/blog/?p=4849
# Joined existing 'i2c_lib.py' and 'lcddriver.py' into a single library
# added bits and pieces from various sources
# By DenisFromHR (Denis Pleic)
# 2015-02-10, ver 0.1

"""

# i2c bus (0 -- original Pi, 1 -- Rev 2 Pi)
I2CBUS = 0

# LCD Address
ADDRESS = 0x27

import smbus
from time import sleep

class i2c_device:
   def __init__(self, addr, port=I2CBUS):
      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)


# 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_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))

   # write a character to lcd (or character rom) 0x09: backlight | RS=DR<
   # works!
   def lcd_write_char(self, charvalue, mode=1):
      self.lcd_write_four_bits(mode | (charvalue & 0xF0))
      self.lcd_write_four_bits(mode | ((charvalue << 4) & 0xF0))
  
   # put string function with optional char positioning
   def lcd_display_string(self, string, line=1, pos=0):
    if line == 1:
      pos_new = pos
    elif line == 2:
      pos_new = 0x40 + pos
    elif line == 3:
      pos_new = 0x14 + pos
    elif line == 4:
      pos_new = 0x54 + pos

    self.lcd_write(0x80 + pos_new)

    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)

   # define backlight on/off (lcd.backlight(1); off= lcd.backlight(0)
   def backlight(self, state): # for state, 1 = on, 0 = off
      if state == 1:
         self.lcd_device.write_cmd(LCD_BACKLIGHT)
      elif state == 0:
         self.lcd_device.write_cmd(LCD_NOBACKLIGHT)

   # add custom characters (0 - 7)
   def lcd_load_custom_chars(self, fontdata):
      self.lcd_write(0x40);
      for char in fontdata:
         for line in char:
            self.lcd_write_char(line)         
         

Pode ser necessário alterar algumas coisas no código acima, dependendo da configuração. Na linha 19, há uma função que define a porta para o barramento I2C (I2CBUS = 0). A porta 0 usada pelo Raspberry Pi mais antigo, mas os modelos mais novos usam a porta 1. Portanto, dependendo do modelo de RPi que você possui, talvez seja necessário alterar isso de 0 para 1.

Leia Também  Reinvenção Knowmada - entrevista Dani Bezares de desaprendo.com
cupom com desconto - o melhor site de cupom de desconto cupomcomdesconto.com.br

Em seguida, coloque o endereço I2C do seu LCD na linha 22 do código da biblioteca. Por exemplo, meu endereço I2C é 21, então alterarei a linha 22 para ENDEREÇO ​​= 0x21.

Escrever para exibição

A seguir, é apresentado um programa mínimo "Hello World!" Para demonstrar como inicializar o LCD:

import I2C_LCD_driver
from time import *

mylcd = I2C_LCD_driver.lcd()

mylcd.lcd_display_string("Hello World!", 1)

Posicione o texto

A função mylcd.lcd_display_string () imprime o texto na tela e também permite escolher onde posicioná-lo. A função é usada como mylcd.lcd_display_string ("TEXTO PARA IMPRIMIR", LINHA, COLUNA). O código a seguir imprime "Hello World!" Na linha 2, coluna 3:

import I2C_LCD_driver
from time import *

mylcd = I2C_LCD_driver.lcd()

mylcd.lcd_display_string("Hello World!", 2, 3)

Em um LCD de 16 × 2, as linhas são numeradas de 1 a 2, enquanto as colunas são numeradas de 0 a 15. Portanto, para imprimir “Hello World!” Na primeira coluna da linha superior, use: mylcd.lcd_display_string ("Olá, mundo!", 1, 0).

Limpar a tela

A função mylcd.lcd_clear () limpa a tela:

import I2C_LCD_driver
from time import *

mylcd = I2C_LCD_driver.lcd()

mylcd.lcd_display_string("This is how you", 1)
sleep(1)

mylcd.lcd_clear()

mylcd.lcd_display_string("clear the screen", 1)
sleep(1)

mylcd.lcd_clear()

Texto piscando

Podemos usar um loop while simples com o mylcd.lcd_display_string () e mylcd.lcd_clear () para criar um efeito de texto intermitente contínuo:

import time
import I2C_LCD_driver
mylcd = I2C_LCD_driver.lcd()

while True:
    mylcd.lcd_display_string(u"Hello world!")
    time.sleep(1)
    mylcd.lcd_clear()
    time.sleep(1)
    

Você pode usar o hora de dormir() na linha 7 para alterar o tempo (em segundos) em que o texto permanece ativado. O tempo em que o texto fica desativado pode ser alterado no hora de dormir() na linha 9. Para finalizar o programa, pressione Ctrl-C.

Imprimir data e hora

O programa a seguir imprime a data e hora atuais no LCD:

import I2C_LCD_driver
import time
mylcd = I2C_LCD_driver.lcd()


while True:
    mylcd.lcd_display_string("Time: %s" %time.strftime("%H:%M:%S"), 1)
    
    mylcd.lcd_display_string("Date: %s" %time.strftime("%m/%d/%Y"), 2)
    

Imprima seu endereço IP

Este código imprime o endereço IP da sua conexão Ethernet (eth0) Para imprimir o IP da sua conexão WiFi, altere eth0 para wlan0 na linha 18:

import I2C_LCD_driver
import socket
import fcntl
import struct

mylcd = I2C_LCD_driver.lcd()

def get_ip_address(ifname):
    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    return socket.inet_ntoa(fcntl.ioctl(
        s.fileno(),
        0x8915, 
        struct.pack('256s', ifname[:15])
    )[20:24])

mylcd.lcd_display_string("IP Address:", 1) 

mylcd.lcd_display_string(get_ip_address('eth0'), 2)

Rolar texto da direita para a esquerda continuamente

Este programa irá rolar uma sequência de texto do lado direito do LCD para o lado esquerdo e repetir continuamente:

import I2C_LCD_driver
from time import *

mylcd = I2C_LCD_driver.lcd()

str_pad = " " * 16
my_long_string = "This is a string that needs to scroll"
my_long_string = str_pad + my_long_string

while True:
    for i in range (0, len(my_long_string)):
        lcd_text = my_long_string[i:(i+16)]
        mylcd.lcd_display_string(lcd_text,1)
        sleep(0.4)
        mylcd.lcd_display_string(str_pad,1)
        

Rolar texto da direita para a esquerda uma vez

O código a seguir desliza o texto na tela de direita para esquerda uma vez, para e sai da tela limpa.

import I2C_LCD_driver
from time import *

mylcd = I2C_LCD_driver.lcd()

str_pad = " " * 16
my_long_string = "This is a string that needs to scroll"
my_long_string = str_pad + my_long_string

for i in range (0, len(my_long_string)):
 lcd_text = my_long_string[i:(i+16)]
 mylcd.lcd_display_string(lcd_text,1)
 sleep(0.4)
 mylcd.lcd_display_string(str_pad,1)
 

Rolar o texto da esquerda para a direita uma vez

Este programa desliza o texto para a tela a partir de esquerda para a direita uma vez, para e deixa os 16 primeiros caracteres da sequência de texto na tela.

import I2C_LCD_driver
from time import *

mylcd = I2C_LCD_driver.lcd()

padding = " " * 16
my_long_string = "This is a string that needs to scroll"
padded_string = my_long_string + padding

for i in range (0, len(my_long_string)):
 lcd_text = padded_string[((len(my_long_string)-1)-i):-i]
 mylcd.lcd_display_string(lcd_text,1)
 sleep(0.4)
 mylcd.lcd_display_string(padding[(15+i):i], 1)
 

Caracteres personalizados

Você pode criar qualquer padrão que desejar e imprimi-lo na tela como um caractere personalizado. Cada caractere é uma matriz de 5 x 8 pixels. Até 8 caracteres personalizados podem ser definidos e armazenados na memória do LCD. Esse gerador de caracteres personalizado ajudará você a criar a matriz de bits necessária para definir os caracteres na memória do LCD.

Leia Também  Tindie Blog | Sensor capacitivo de umidade do solo evita problemas de corrosão enfrentados por sensores resistivos

Imprimindo um único caractere personalizado

O código a seguir gera um caractere "<":

import I2C_LCD_driver
from time import *

mylcd = I2C_LCD_driver.lcd()

fontdata1 = [      
        [ 0b00010, 
          0b00100, 
          0b01000, 
          0b10000, 
          0b01000, 
          0b00100, 
          0b00010, 
          0b00000 ],
]

mylcd.lcd_load_custom_chars(fontdata1)
mylcd.lcd_write(0x80)
mylcd.lcd_write_char(0)

Imprimir vários caracteres personalizados

Este programa imprime uma grande seta apontando para a direita (→) na tela:

import I2C_LCD_driver
from time import *

mylcd = I2C_LCD_driver.lcd()

fontdata1 = [
        # char(0) - Upper-left character
        [ 0b00000, 
          0b00000, 
          0b00000, 
          0b00000, 
          0b00000, 
          0b00000, 
          0b11111, 
          0b11111 ],

        # char(1) - Upper-middle character
        [ 0b00000, 
          0b00000, 
          0b00100, 
          0b00110, 
          0b00111, 
          0b00111, 
          0b11111, 
          0b11111 ],
        
        # char(2) - Upper-right character
        [ 0b00000, 
          0b00000, 
          0b00000, 
          0b00000, 
          0b00000, 
          0b00000, 
          0b10000, 
          0b11000 ],
        
        # char(3) - Lower-left character
        [ 0b11111, 
          0b11111, 
          0b00000, 
          0b00000, 
          0b00000, 
          0b00000, 
          0b00000, 
          0b00000 ],
       
        # char(4) - Lower-middle character
        [ 0b11111, 
          0b11111, 
          0b00111, 
          0b00111, 
          0b00110, 
          0b00100, 
          0b00000, 
          0b00000 ],
        
        # char(5) - Lower-right character
        [ 0b11000, 
          0b10000, 
          0b00000, 
          0b00000, 
          0b00000, 
          0b00000, 
          0b00000, 
          0b00000 ],
]

mylcd.lcd_load_custom_chars(fontdata1)

mylcd.lcd_write(0x80)
mylcd.lcd_write_char(0)
mylcd.lcd_write_char(1)
mylcd.lcd_write_char(2)

mylcd.lcd_write(0xC0)
mylcd.lcd_write_char(3)
mylcd.lcd_write_char(4)
mylcd.lcd_write_char(5)

Imprimir dados de um sensor

O código abaixo exibirá dados de um sensor de temperatura e umidade DHT11. Siga este tutorial para obter instruções sobre como configurar o DHT11 no Raspberry Pi. O pino de sinal DHT11 está conectado ao pino BCM 4 (pino físico 7 do RPi).

A temperatura é exibida na linha 1 e a umidade na linha 2:

import RPi.GPIO as GPIO
import dht11
import I2C_LCD_driver

from time import *

mylcd = I2C_LCD_driver.lcd()

GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)
GPIO.cleanup()

while True:
  
  instance = dht11.DHT11(pin = 4)
  result = instance.read()

# Uncomment for Fahrenheit:
# result.temperature = (result.temperature * 1.8) + 32 

  if result.is_valid():
    mylcd.lcd_display_string("Temp: %d%s C" % (result.temperature, chr(223)), 1)
    mylcd.lcd_display_string("Humidity: %d %%" % result.humidity, 2)
    

Para Fahrenheit, retire o comentário das linhas 18 e 19 e altere C para F na linha 22. Você também pode alterar o pino de sinal da entrada DHT11 na linha 15.

Ao inserir a variável do seu sensor no mylcd.lcd_display_string () função (linha 22 no código acima), você pode imprimir os dados do sensor como qualquer outra sequência de texto.

Esses programas são apenas exemplos básicos de maneiras de controlar o texto no seu LCD. Tente mudar as coisas e combinar o código para obter alguns efeitos interessantes. Por exemplo, você pode fazer algumas animações interessantes rolando com caracteres personalizados. Não há espaço na tela suficiente para gerar todos os dados do sensor? Apenas imprima e limpe cada leitura por alguns segundos seguidos.

Deixe-nos saber nos comentários se você tiver alguma dúvida ou dificuldade para configurar isso. Deixe também um comentário se tiver outras idéias sobre como obter alguns efeitos interessantes ou apenas para compartilhar seu projeto!

Posts que devem ser lidos também:
https://responsibleradio.com/25-melhores-ideias-de-novos-negocios-na-india-com-investimento-baixo-e-medio/

https://draincleaningdenverco.com/ganhos-online-compartilhando-arquivos/

https://weeventos.com.br/ativar-preenchimento-automatico-do-aka-intellisense-no-bloco-de-notas/

https://clipstudio.com.br/9-dicas-para-evitar-um-facebook-conta-de-proibicao/

https://multieletropecas.com.br/conheca-lancetalent-plataforma-de-trabalho-entre-freelancers-e-startups/

https://holidayservice-tn.com/operar-a-negociacao-com-cfds-um-trabalho-em-casa-muito-rentavel/

https://teleingressos.com.br/nos-nao-podemos-viver-como-vizinhos-ricos-entao-meu-marido-quer-me-mentir/

https://proverasfestas.com.br/como-escrever-um-e-mail-de-desculpas-apos-um-desastre-de-newsletter/

https://coniferinc.com/designer-kurti-online-shopping-e-o-caminho-a-seguir-para-a-frente/

cupom com desconto - o melhor site de cupom de desconto cupomcomdesconto.com.br