Como configurar um LCD no Raspberry Pi e programá-lo com Python

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


Se você planeja usar um LCD com seu Raspberry Pi, há uma boa chance de precisar programá-lo em Python em algum momento. O Python é provavelmente a linguagem de programação mais popular para codificação no Raspberry Pi, e muitos dos projetos e exemplos que você encontrará são escritos em Python.

Anúncio PCBWay

Neste tutorial, mostrarei como conectar seu LCD e programá-lo em Python, usando a biblioteca RPLCD. Começarei mostrando como conectá-lo no modo de 8 ou 4 bits. Depois, explicarei como instalar a biblioteca e fornecerei exemplos para imprimir e posicionar o texto, limpar a tela e controlar o cursor. Também darei exemplos de rolagem de texto, criação de caracteres personalizados, impressão de dados de um sensor e exibição da data, hora e endereço IP do seu Pi.

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.

Estou usando um monitor LCD 16X2 aqui, mas os exemplos funcionarão com qualquer LCD que use o driver Hitachi HD44780.

Você também pode conectar o LCD via I2C, que usa apenas dois fios, mas isso requer algum hardware extra. Confira nosso artigo, Como configurar um LCD I2C no Raspberry Pi para ver como.

Também falo sobre como programar o LCD com C em outro artigo, mas por enquanto vamos nos concentrar no Python …

Aqui está a versão em vídeo deste tutorial, onde você pode assistir todos os programas de exemplo abaixo em tempo real:

Conectando o LCD

Existem duas maneiras de conectar o LCD ao seu Raspberry Pi – no modo de 4 bits ou no modo de 8 bits. O modo de 4 bits usa 6 pinos GPIO, enquanto o modo de 8 bits usa 10. Como usa menos pinos, o modo de 4 bits é o método mais comum, mas explicarei como configurar e programar o LCD nos dois sentidos.

Cada caractere e comando é enviado ao LCD como um byte (8 bits) de dados. No modo de 8 bits, o byte é enviado de uma só vez através de 8 cabos de dados, um bit por fio. No modo de 4 bits, o byte é dividido em dois conjuntos de 4 bits – os bits superiores e inferiores, que são enviados um após o outro através de 4 cabos de dados.

Teoricamente, o modo de 8 bits transfere dados duas vezes mais rápido que o modo de 4 bits, pois o byte inteiro é enviado de uma só vez. No entanto, o driver do LCD leva um tempo relativamente longo para processar os dados; portanto, independentemente do modo em uso, não notamos realmente uma diferença na velocidade de transferência de dados entre os modos de 8 e 4 bits.

Leia Também  Câmera Sony ZV-1 YouTuber - introdução, funções e exemplos de vídeo

Ligar o LCD no modo de 8 bits

Para conectar seu LCD no modo de 8 bits, configure-o assim:

Diagrama de conexão do modo de 8 bits do Raspberry Pi LCD

Os potenciômetros de luz de fundo e contraste são 10K Ohms, mas podem ser substituídos por resistores de 1K a 3K Ohm, se você desejar.

Ligar o LCD no modo de 4 bits

Para conectar o LCD ao seu Raspberry Pi no modo de 4 bits, configure-o assim:

Os potenciômetros aqui também podem ser substituídos por resistores de 1K ou 3K Ohm.

Programando o LCD com Python

Se esta é a primeira vez que você escreve e executa um programa Python, leia Como escrever e executar um programa Python no Raspberry Pi, que explicará tudo o que você precisa saber para executar os exemplos abaixo.

Usaremos uma biblioteca Python que fornece muitas funções úteis. É chamada de biblioteca RLPCD e foi escrita por Danilo Bargen.

Instalando a Biblioteca RPLCD

A biblioteca RPLCD pode ser instalada a partir do Python Package Index ou PIP. Ele já pode estar instalado no seu Pi, mas, se não, digite-o no prompt de comando para instalá-lo:

O sudo apt-get instala o python-pip

Depois de instalar o PIP, instale a biblioteca RPLCD digitando:

instalação do sudo pip RPLCD

Os programas de exemplo abaixo usam os números físicos dos pinos do Raspberry Pi, não os números BCM ou GPIO. Suponho que seu LCD esteja conectado da maneira que está nos diagramas acima, mas mostrarei como alterar as conexões de pinos, se necessário.

Gravar na tela no modo 8 bits

Vamos começar com um programa simples que exibirá “Olá, mundo!” no LCD. Se você tiver um LCD de tamanho diferente dos 16 × 2 que estou usando (como 20 × 4), altere o número de colunas e linhas na linha 2 do código. cols = define o número de colunas e linhas = define o número de linhas. Você também pode alterar os pinos usados ​​nos pinos RS, E e de dados do LCD. Os pinos de dados são definidos como pins_data =[D0, D1, D2, D3, D4, D5, D6, D7].

As cadeias de texto são gravadas no visor usando o lcd.write_string () função:

from RPLCD import CharLCD
lcd = CharLCD(cols=16, rows=2, pin_rs=37, pin_e=35, pins_data=[40, 38, 36, 32, 33, 31, 29, 23])
lcd.write_string(u'Hello world!')

Gravar na tela no modo de 4 bits

No modo de 4 bits, apenas os pinos LCD D4, D5, D6 e D7 são usados ​​para dados. Estes são definidos em pins_data =[D4, D5, D6, D7] na linha 2 abaixo:

from RPLCD import CharLCD
lcd = CharLCD(cols=16, rows=2, pin_rs=37, pin_e=35, pins_data=[33, 31, 29, 23])
lcd.write_string(u'Hello world!')

Posicione o texto

O texto pode ser posicionado em qualquer lugar da tela usando lcd.cursor_pos = (ROW, COLUMN). As linhas são numeradas começando do zero, então a linha superior é a linha 0 e a linha inferior é a linha 1. Da mesma forma, as colunas são numeradas começando em zero, portanto, para um LCD de 16 × 2, as colunas são numeradas de 0 a 15. Para Por exemplo, o código abaixo coloca “Olá, mundo!” começando na linha inferior, quarta coluna:

from RPLCD import CharLCD
lcd = CharLCD(cols=16, rows=2, pin_rs=37, pin_e=35, pins_data=[33, 31, 29, 23])

lcd.cursor_pos = (1, 3) 
lcd.write_string(u'Hello world!')

Limpar a tela

A função lcd.clear () limpará a tela. O código a seguir imprimirá “Hello world!” na tela por dois segundos antes de limpá-la:

import time
from RPLCD import CharLCD
lcd = CharLCD(cols=16, rows=2, pin_rs=37, pin_e=35, pins_data=[33, 31, 29, 23])

lcd.write_string(u'Hello world!')
time.sleep(2)
lcd.clear()

Texto piscando

Combinando lcd.clear () e hora de dormir() em um loop while produzirá um efeito de texto piscante:

import time
from RPLCD import CharLCD
lcd = CharLCD(cols=16, rows=2, pin_rs=37, pin_e=35, pins_data=[33, 31, 29, 23])

while True:
    lcd.write_string(u"Hello world!")
    time.sleep(1)
    lcd.clear()
    time.sleep(1)
    

Pressione Ctrl-C para sair do programa.

Leia Também  Blog do Tindie | Controle MIDI abrangente do seu rack!
cupom com desconto - o melhor site de cupom de desconto cupomcomdesconto.com.br

Ligar e desligar o cursor

A biblioteca RPLCD fornece várias funções para controlar o cursor. Você pode ter um cursor de bloco, um cursor de sublinhado ou um cursor piscando. Use as seguintes funções para definir o cursor:

  • Cursor do bloco piscando: lcd.cursor_mode = CursorMode.blink
  • Cursor de linha: lcd.cursor_mode = CursorMode.line
  • Cursor desativado: lcd.cursor_mode = CursorMode.hide

O código abaixo coloca um cursor piscando após o último caractere do texto:

from RPLCD import CharLCD
from RPLCD import CursorMode
lcd = CharLCD(cols=16, rows=2, pin_rs=37, pin_e=35, pins_data=[33, 31, 29, 23])

lcd.write_string(u'Hello world!')

lcd.cursor_mode = CursorMode.blink
#lcd.cursor_mode = CursorMode.line
#lcd.cursor_mode = CursorMode.hide

Quebras de linha

O texto entrará automaticamente na próxima linha se o comprimento do texto for maior que o comprimento da coluna do seu LCD. Você também pode controlar onde a sequência de texto será quebrada para a próxima linha inserindo n r onde você deseja que a interrupção ocorra. O código abaixo imprimirá “Olá” na linha superior e “mundo!” para a linha inferior.

from RPLCD import CharLCD
lcd = CharLCD(cols=16, rows=2, pin_rs=37, pin_e=35, pins_data=[33, 31, 29, 23])

lcd.write_string(u'Hellonrworld!')

Imprimir data e hora

Este programa exibirá a data e a hora no LCD:

from RPLCD import CharLCD
import time
lcd = CharLCD(cols=16, rows=2, pin_rs=37, pin_e=35, pins_data=[33, 31, 29, 23])


while True:
    lcd.write_string("Time: %s" %time.strftime("%H:%M:%S"))
    
    lcd.cursor_pos = (1, 0)
    lcd.write_string("Date: %s" %time.strftime("%m/%d/%Y"))
    

Imprima seu endereço IP

Este programa imprimirá o endereço IP da sua conexão Ethernet no LCD. Para imprimir o IP da sua conexão WiFi, basta alterar eth0 na linha 19 a wlan0:

from RPLCD import CharLCD
import socket
import fcntl
import struct

lcd = CharLCD(cols=16, rows=2, pin_rs=37, pin_e=35, pins_data=[33, 31, 29, 23])

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

lcd.write_string("IP Address:") 

lcd.cursor_pos = (1, 0)
lcd.write_string(get_ip_address('eth0'))

Caracteres personalizados

Cada caractere no LCD é uma matriz de 5 × 8 de pixels. Você pode criar qualquer padrão ou personagem em que possa pensar e exibi-lo na tela como um caractere personalizado. Confira este site para uma ferramenta interativa que cria a matriz de bits usada para definir caracteres personalizados.

Primeiro, definimos o caractere nas linhas 4 a 12 do código abaixo. Então usamos a função lcd.create_char (0-7, NAME) para armazenar o caractere na memória CGRAM do LCD. Até 8 (0-7) caracteres podem ser armazenados por vez. Para imprimir o caractere personalizado, usamos lcd.write_string (unichr (0)), onde o número em unichr () é o local da memória (0-7) definido em lcd.create_char ().

Imprimindo um único caractere personalizado

Dê uma olhada neste código, que imprime um único caractere de rosto sorridente na tela:

from RPLCD import CharLCD, cleared, cursor
lcd = CharLCD(cols=16, rows=2, pin_rs=37, pin_e=35, pins_data=[33, 31, 29, 23])

smiley = (
    0b00000,
    0b01010,
    0b01010,
    0b00000,
    0b10001,
    0b10001,
    0b01110,
    0b00000,
)
lcd.create_char(0, smiley)
lcd.write_string(unichr(0))

Imprimir vários caracteres personalizados

Este programa imprimirá as letras gregas ômega, pi e mu, juntamente com símbolos de temperatura (um termômetro) e umidade (uma gota d’água):

from RPLCD import CharLCD, cleared, cursor
lcd = CharLCD(cols=16, rows=2, pin_rs=37, pin_e=35, pins_data=[33, 31, 29, 23])

omega = (
    0b00000,
    0b01110,
    0b10001,
    0b10001,
    0b10001,
    0b01010,
    0b11011,
    0b00000,
)

pi = (
    0b00000,
    0b00000,
    0b11111,
    0b01010,
    0b01010,
    0b01010,
    0b10011,
    0b00000,
)

mu = (
    0b00000,
    0b10010,
    0b10010,
    0b10010,
    0b10010,
    0b11101,
    0b10000,
    0b10000,
)

drop = (
    0b00100,
    0b00100,
    0b01010,
    0b01010,
    0b10001,
    0b10001,
    0b10001,
    0b01110,
)

temp = (
    0b00100,
    0b01010,
    0b01010,
    0b01110,
    0b01110,
    0b11111,
    0b11111,
    0b01110,
)

lcd.create_char(0, omega)
lcd.create_char(1, pi)
lcd.create_char(2, mu)
lcd.create_char(3, drop)
lcd.create_char(4, temp)

lcd.write_string(unichr(0))
lcd.write_string(unichr(1))
lcd.write_string(unichr(2))
lcd.write_string(unichr(3))
lcd.write_string(unichr(4))

Rolagem de texto

Este programa rola o texto da direita para a esquerda em um loop infinito:

framebuffer = [
    '',
    '',
]

def write_to_lcd(lcd, framebuffer, num_cols):
    lcd.home()
    for row in framebuffer:
        lcd.write_string(row.ljust(num_cols)[:num_cols])
        lcd.write_string('rn')

from RPLCD import CharLCD
lcd = CharLCD(cols=16, rows=2, pin_rs=37, pin_e=35, pins_data=[33, 31, 29, 23])
write_to_lcd(lcd, framebuffer, 16)

import time
long_string = 'This string is too long to fit'

def loop_string(string, lcd, framebuffer, row, num_cols, delay=0.5): #DELAY= CONTROLS THE SPEED OF SCROLL
    padding = ' ' * num_cols
    s = padding + string + padding
    for i in range(len(s) - num_cols + 1):
        framebuffer[row] = s[i:i+num_cols]
        write_to_lcd(lcd, framebuffer, num_cols)
        time.sleep(delay)

while True:
    loop_string(long_string, lcd, framebuffer, 1, 16)
    

Você pode alterar a velocidade de rolagem atraso = 0,5 (linha 19).

Leia Também  Meus 10 principais tipos de artigo: o melhor conteúdo para mais visitantes, maior receita e novos backlinks

Imprimir dados de um sensor

Para demonstrar como imprimir dados de um sensor, aqui está um programa que exibe a temperatura de um sensor de temperatura digital DS18B20. Há algumas configurações a serem feitas antes que você possa fazer com que isso funcione no Raspberry Pi. Confira nosso tutorial no DS18B20 para ver como.

Em geral, você pega a variável de entrada do seu sensor e a converte em um número inteiro para realizar qualquer cálculo. Em seguida, converta o resultado em uma sequência e envie a sequência para a exibição usando lcd.write_string (sensor_data ()):

import os
import glob
import time
from RPLCD import CharLCD

lcd = CharLCD(cols=16, rows=2, pin_rs=37, pin_e=35, pins_data=[33, 31, 29, 23])

os.system('modprobe w1-gpio')
os.system('modprobe w1-therm')

base_dir = '/sys/bus/w1/devices/'
device_folder = glob.glob(base_dir + '28*')[0]
device_file = device_folder + '/w1_slave'

def read_temp_raw():
    f = open(device_file, 'r')
    lines = f.readlines()
    f.close()
    return lines

#CELSIUS CALCULATION
def read_temp_c():
    lines = read_temp_raw()
    while lines[0].strip()[-3:] != 'YES':
        time.sleep(0.2)
        lines = read_temp_raw()
    equals_pos = lines[1].find('t=')
    if equals_pos != -1:
        temp_string = lines[1][equals_pos+2:]
        temp_c = int(temp_string) / 1000.0 # TEMP_STRING IS THE SENSOR OUTPUT, MAKE SURE IT'S AN INTEGER TO DO THE MATH
        temp_c = str(round(temp_c, 1)) # ROUND THE RESULT TO 1 PLACE AFTER THE DECIMAL, THEN CONVERT IT TO A STRING
        return temp_c

#FAHRENHEIT CALCULATION
def read_temp_f():
    lines = read_temp_raw()
    while lines[0].strip()[-3:] != 'YES':
        time.sleep(0.2)
        lines = read_temp_raw()
    equals_pos = lines[1].find('t=')
    if equals_pos != -1:
        temp_string = lines[1][equals_pos+2:]
        temp_f = (int(temp_string) / 1000.0) * 9.0 / 5.0 + 32.0 # TEMP_STRING IS THE SENSOR OUTPUT, MAKE SURE IT'S AN INTEGER TO DO THE MATH
        temp_f = str(round(temp_f, 1)) # ROUND THE RESULT TO 1 PLACE AFTER THE DECIMAL, THEN CONVERT IT TO A STRING
        return temp_f

while True:

    lcd.cursor_pos = (0, 0)
    lcd.write_string("Temp: " + read_temp_c() + unichr(223) + "C")
    lcd.cursor_pos = (1, 0)
    lcd.write_string("Temp: " + read_temp_f() + unichr(223) + "F")

Bem, isso abrange a maior parte do que você precisa para começar a programar seu LCD com Python. Tente combinar os programas para obter alguns efeitos interessantes. Você pode exibir dados de vários sensores imprimindo e limpando a tela ou posicionando o texto. Você também pode fazer animações divertidas rolando caracteres personalizados.

Se você tiver algum problema ou dúvida, deixe um comentário abaixo. E não se esqueça de se inscrever para receber uma notificação por e-mail quando publicarmos novos artigos. Ok, falo com você na próxima vez!

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