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

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


Conectar um monitor LCD ao seu Raspberry Pi certamente aumentará seu projeto. Eles são ótimos para exibir leituras de sensores, músicas ou estações de rádio da Internet e coisas da Web, como tweets e cotações de ações. Qualquer que seja a sua opção de exibição, os LCDs são uma maneira simples e barata de fazer isso.

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

Neste tutorial, mostrarei duas maneiras diferentes de conectar um LCD ao Raspberry Pi com os pinos GPIO. A primeira maneira de mostrar a você é no modo de 8 bits, que usa 10 pinos GPIO. Depois, mostrarei como conectá-lo no modo de 4 bits e que usa apenas 6 pinos. Depois de ligar o LCD, mostrarei como programá-lo com C, usando a biblioteca WiringPi de Gordon Henderson.

Vou mostrar como imprimir texto na tela, limpar a tela, posicionar o texto e controlar o cursor. Você também verá como rolar o texto, criar caracteres personalizados, imprimir dados de um sensor e imprimir a 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.

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

Se o seu projeto usa Python, temos outro artigo que mostra como programar o LCD no Python.

Há outra maneira de conectar seu LCD que usa apenas dois fios, chamados I2C. Para ver como fazer isso, consulte o nosso tutorial Como configurar um LCD I2C no Raspberry Pi.

Aqui está um vídeo para assistir a uma demonstração rápida dos programas de configuração e de exemplo:

Conectando o LCD

A maioria das pessoas provavelmente deseja conectar seu LCD no modo de 4 bits, pois ele usa menos fios. No entanto, caso você esteja interessado, mostrarei como conectá-lo também no modo de 8 bits.

Ligar o LCD no modo de 8 bits

No modo de 8 bits, cada comando ou caractere é enviado ao LCD como um único byte (8 bits) de dados. O byte viaja em paralelo por 8 fios de dados, com cada bit percorrendo seu próprio fio. O modo de 8 bits possui o dobro da largura de banda que o modo de 4 bits, o que, em teoria, se traduz em maior velocidade de transferência de dados. A principal desvantagem do modo 8 bits é que ele usa muitos pinos GPIO.

A conexão do LCD no modo de 8 bits requer 10 pinos GPIO:

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

Os potenciômetros de brilho e contraste são de 10K Ohm, mas você também pode usar resistores de 1K a 3K Ohm aqui.

Ligar o LCD no modo de 4 bits

No modo de 4 bits, cada byte de dados é enviado ao LCD em dois conjuntos de 4 bits, um após o outro, no que são conhecidos como bits superiores e inferiores. Embora o modo de 8 bits transfira dados duas vezes mais rápido que o modo de 4 bits, o driver do LCD leva mais tempo para processar cada byte do que para transmitir o byte. Portanto, na realidade, não há realmente uma diferença notável na velocidade entre o modo de 4 bits e o modo de 8 bits.

O modo de 4 bits ocupa apenas 6 pinos GPIO para entrada / saída, o que a torna uma escolha popular para muitos projetos:

Modo Raspberry Pi LCD de 4 bits

Os potenciômetros de brilho e contraste são de 10K Ohm, mas os resistores de 1K a 3K Ohm também funcionarão.

Programar o LCD com C

Se você nunca trabalhou com programas C no Raspberry Pi, leia nosso artigo Como escrever e executar um programa C no Raspberry Pi primeiro. Ele explicará como escrever, compilar e executar programas em C.

Instale o WiringPi

O WiringPi é um módulo C que facilita a programação do LCD. Se você já possui o WiringPi instalado no seu Pi, pode pular esta seção. Caso contrário, siga as etapas abaixo para instalá-lo:

1. Podemos baixar o WiringPi usando o Git. Seu Pi pode ter o Git já instalado (se você pular esta etapa), mas se não, digite-o no prompt de comando:

sudo apt-get install git-core

  • Nota: Se você receber um erro ao instalar o Git, execute o sudo apt-get update e tente novamente.

2. Agora baixe o WiringPi digitando-o no prompt de comando:

Leia Também  Especialização - O segredo do sucesso para sites e blogs

git clone git: //git.drogon.net/wiringPi

3. Digite para alterar os diretórios:

fiação de cd

4. Execute o script de instalação com:

./Construir

5. Teste a instalação digitando:

gpio -v

Seguido por:

read do gpio

Agora estamos prontos para começar a programar o LCD!

Exemplos

Todos os exemplos abaixo são programas C independentes, que precisarão ser cumpridos digitando-o no prompt de comando:

gcc -o example example.c -lwiringPi -lwiringPiDev 

mudança exemplo e example.c para o nome do arquivo que você deseja usar.

Após a compilação do programa, ele pode ser executado digitando-o no prompt de comando:

O WiringPi possui seu próprio sistema de numeração de pinos, diferente dos sistemas de numeração de pinos Broadcom (BCM) e RPi físico (BOARD). Todos os programas abaixo usam os números dos pinos do WiringPi.

Escreva no LCD no modo 8 bits

Este programa mostra o código mínimo necessário para inicializar o LCD e imprimir “Olá, mundo!” Para ele:

#include 
#include 

//USE WIRINGPI PIN NUMBERS
#define LCD_RS  25               //Register select pin
#define LCD_E   24               //Enable Pin
#define LCD_D0  29               //Data pin D0
#define LCD_D1  28               //Data pin D1
#define LCD_D2  27               //Data pin D2
#define LCD_D3  26               //Data pin D3
#define LCD_D4  23               //Data pin D4
#define LCD_D5  22               //Data pin D5
#define LCD_D6  21               //Data pin D6
#define LCD_D7  14               //Data pin D7
 
int main()

    int lcd;
    wiringPiSetup();
    lcd = lcdInit (2, 16, 8, LCD_RS, LCD_E, LCD_D0, LCD_D1, LCD_D2, LCD_D3, LCD_D4, LCD_D5, LCD_D6, LCD_D7);

    lcdPuts(lcd, "Hello, world!");

Para usar pinos diferentes para conectar o LCD, altere os números dos pinos definidos nas linhas 5 a 14. Você precisará converter os números dos pinos do WiringPi nos números físicos dos pinos do Raspberry Pi. Veja aqui um diagrama que você pode usar para converter entre os diferentes sistemas de numeração.

A função na linha 20 é usada para inicializar o LCD:

lcd = lcdInit (ROWS, COLUMNS, BIT MODE, LCD_RS, LCD_E, LCD_D0, LCD_D1, LCD_D2, LCD_D3, LCD_D4, LCD_D5, LCD_D6, LCD_D7);

A função lcdPuts (lcd, “Olá, mundo!”) imprime “Olá, mundo!” na tela.

Escreva no LCD no modo de 4 bits

Para usar o LCD no modo de 4 bits, precisamos definir o número do modo de bit como 4 na função de inicialização (linha 20 abaixo). O código a seguir imprime “Olá, mundo!” Na tela no modo de 4 bits:

#include           
#include                
 
//USE WIRINGPI PIN NUMBERS
#define LCD_RS  25               //Register select pin
#define LCD_E   24               //Enable Pin
#define LCD_D4  23               //Data pin 4
#define LCD_D5  22               //Data pin 5
#define LCD_D6  21               //Data pin 6
#define LCD_D7  14               //Data pin 7
 
int main()

    int lcd;               
    wiringPiSetup();        
    lcd = lcdInit (2, 16, 4, LCD_RS, LCD_E, LCD_D4, LCD_D5, LCD_D6, LCD_D7, 0, 0, 0, 0);
               
    lcdPuts(lcd, "Hello, world!");   

Posicione o texto

Por padrão, o texto é impresso na tela na linha superior, segunda coluna. Para alterar a posição, use lcdPosition (lcd, COLUMN, ROW). Em um LCD de 16 × 2, as linhas são numeradas de 0 a 1 e as colunas são numeradas de 0 a 15.

O código a seguir imprime “Olá, mundo!” Na linha inferior, quarta coluna:

#include            
#include                 
 
//USE WIRINGPI PIN NUMBERS
#define LCD_RS  25               //Register select pin
#define LCD_E   24               //Enable Pin
#define LCD_D4  23               //Data pin 4
#define LCD_D5  22               //Data pin 5
#define LCD_D6  21               //Data pin 6
#define LCD_D7  14               //Data pin 7
 
int main()

    int lcd;               
    wiringPiSetup();        
    lcd = lcdInit (2, 16, 4, LCD_RS, LCD_E, LCD_D4, LCD_D5, LCD_D6, LCD_D7, 0, 0, 0, 0);
    
    lcdPosition(lcd, 3, 1); 
    lcdPuts(lcd, "Hello, world!");   

Limpar a tela

A função lcdClear (lcd) limpa a tela e define a posição do cursor na linha superior, primeira coluna. Este programa imprime “É assim que você” por dois segundos, limpa a tela e depois imprime “limpa a tela” por mais dois segundos:

#include           
#include                
 
//USE WIRINGPI PIN NUMBERS
#define LCD_RS  25               //Register select pin
#define LCD_E   24               //Enable Pin
#define LCD_D4  23               //Data pin 4
#define LCD_D5  22               //Data pin 5
#define LCD_D6  21               //Data pin 6
#define LCD_D7  14               //Data pin 7
 
int main()

    int lcd;               
    wiringPiSetup();        
    lcd = lcdInit (2, 16, 4, LCD_RS, LCD_E, LCD_D4, LCD_D5, LCD_D6, LCD_D7, 0, 0, 0, 0);
               
    lcdPuts(lcd, "This is how you"); 
    sleep(2);
    lcdClear(lcd);  

    lcdPuts(lcd, "clear the screen"); 
    sleep(2);
    lcdClear(lcd);

Observe como a primeira string é impressa na linha superior, segunda coluna (a posição padrão). Depois de limpar a tela, a segunda sequência é impressa na primeira linha, primeira coluna.

Texto piscando

Usando um loop while com lcdclear () e lcdputs () cria um efeito de texto piscante:

#include 
#include 

//USE WIRINGPI PIN NUMBERS
#define LCD_RS  25               //Register select pin
#define LCD_E   24               //Enable Pin
#define LCD_D4  23               //Data pin 4
#define LCD_D5  22               //Data pin 5
#define LCD_D6  21               //Data pin 6
#define LCD_D7  14               //Data pin 7

int main()

    int lcd;
    wiringPiSetup();
    lcd = lcdInit (2, 16, 4, LCD_RS, LCD_E, LCD_D4, LCD_D5, LCD_D6, LCD_D7, 0, 0, 0, 0);

    while(1)
        lcdPosition(lcd, 0, 0);
        lcdPuts(lcd, "Hello, world!");
        sleep(2);
        lcdClear(lcd);
        sleep(2);
        

Pressione Ctrl-C para sair do programa.

Ligar e desligar o cursor

O cursor está desativado por padrão, mas você pode obter diferentes estilos de cursores usando as seguintes funções:

  • Sublinhar o cursor que não pisca: lcdCursor (lcd, 1)
  • Sublinhar o cursor piscante: lcdCursor (lcd, 1), Seguido por lcdCursorBlink (lcd, 1)
  • Cursor de estilo de bloco piscando: lcdCursorBlink (lcd, 1)
  • Cursor desativado: lcdCursor (lcd, 0)
#include           
#include                

//USE WIRINGPI PIN NUMBERS
#define LCD_RS  25               //Register select pin
#define LCD_E   24               //Enable Pin
#define LCD_D4  23               //Data pin 4
#define LCD_D5  22               //Data pin 5
#define LCD_D6  21               //Data pin 6
#define LCD_D7  14               //Data pin 7

int main()

    int lcd;
    wiringPiSetup();
    lcd = lcdInit (2, 16, 4, LCD_RS, LCD_E, LCD_D4, LCD_D5, LCD_D6, LCD_D7, 0, 0, 0, 0);

    //lcdCursor(lcd, 0); //Cursor OFF
   
    lcdCursor(lcd, 1); //Cursor ON, underline, not blinking
    //lcdCursorBlink(lcd, 1); //Cursor ON, block, blinking    
    
    //Use both lines below to get a blinking underline/block cursor 
    //lcdCursor(lcd, 1);
    //lcdCursorBlink(lcd, 1);

    lcdPuts(lcd, "Hello, world!");

Imprimir data e hora

Este programa imprimirá a data e hora atuais no LCD:

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

//USE WIRINGPI PIN NUMBERS
#define LCD_RS  25               //Register select pin
#define LCD_E   24               //Enable Pin
#define LCD_D4  23               //Data pin 4
#define LCD_D5  22               //Data pin 5
#define LCD_D6  21               //Data pin 6
#define LCD_D7  14               //Data pin 7

int main()

    int lcd;
    wiringPiSetup();
    lcd = lcdInit (2, 16, 4, LCD_RS, LCD_E, LCD_D4, LCD_D5, LCD_D6, LCD_D7, 0, 0, 0, 0);

    while(1)
        time_t timer;
        char buffer_date[26];
        char buffer_time[26];
        struct tm* tm_info;

        time(&timer);
        tm_info = localtime(&timer);

        strftime(buffer_date, 26, "Date: %m:%d:%Y", tm_info);
        strftime(buffer_time, 26, "Time: %H:%M:%S", tm_info);

        lcdPosition(lcd, 0, 0);
        lcdPuts(lcd, buffer_date);

        lcdPosition(lcd, 0, 1);
        lcdPuts(lcd, buffer_time);

        

Imprima seu endereço IP

Este programa imprime o endereço IP da sua conexão Ethernet (eth0). Para obter o IP da sua conexão WiFi, altere eth0 para wlan0 na linha 30:

#include           
#include                 

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

//USE WIRINGPI PIN NUMBERS
#define LCD_RS  25               //Register select pin
#define LCD_E   24               //Enable Pin
#define LCD_D4  23               //Data pin 4
#define LCD_D5  22               //Data pin 5
#define LCD_D6  21               //Data pin 6
#define LCD_D7  14               //Data pin 7

int main()

    int lcd;
    wiringPiSetup();
    lcd = lcdInit (2, 16, 4, LCD_RS, LCD_E, LCD_D4, LCD_D5, LCD_D6, LCD_D7, 0, 0, 0, 0);

    int n;
    struct ifreq ifr;
    char iface[] = "eth0"; //Change this to the network of your choice (eth0, wlan0, etc.)

    n = socket(AF_INET, SOCK_DGRAM, 0);
    ifr.ifr_addr.sa_family = AF_INET;
    strncpy(ifr.ifr_name , iface , IFNAMSIZ - 1);
    ioctl(n, SIOCGIFADDR, &ifr);
    close(n);

    lcdPosition(lcd, 0, 0);
    lcdPrintf(lcd, "IP Address: ");

    lcdPosition(lcd, 0, 1);
    lcdPrintf(lcd, ("%s - %sn" , iface , inet_ntoa(( (struct sockaddr_in *)&ifr.ifr_addr )->sin_addr)));
    return 0;

Caracteres personalizados

Cada caractere do LCD é uma matriz 5 × 8 de pixels. Você pode criar qualquer padrão desejado e exibi-lo no LCD como um caractere personalizado. Até 8 caracteres personalizados podem ser armazenados na memória do LCD por vez. Este site tem uma ótima maneira visual de gerar a matriz de bits usada para definir caracteres personalizados.

Imprimindo um único caractere personalizado

Para imprimir um único caractere personalizado, primeiro defina o caractere. Para um exemplo disso, veja as linhas 12 a 19 abaixo. Então use a função lcdCharDef (lcd, 2, ômega) para armazenar o caractere na memória do LCD. O número 2 neste exemplo é um dos 8 locais na memória de caracteres do LCD. Os 8 locais são numerados de 0 a 7. Em seguida, imprima o caractere no visor com lcdPutchar (lcd, 2), em que o número 2 é o caractere armazenado no local da memória 2.

Este programa imprime a letra grega Omega no LCD:

#include            
#include                 

//USE WIRINGPI PIN NUMBERS
#define LCD_RS  25               //Register select pin
#define LCD_E   24               //Enable Pin
#define LCD_D4  23               //Data pin 4
#define LCD_D5  22               //Data pin 5
#define LCD_D6  21               //Data pin 6
#define LCD_D7  14               //Data pin 7

char omega[8] =  0b00000,
                  0b01110,
                  0b10001,
                  0b10001,
                  0b10001,
                  0b01010,
                  0b11011,
                  0b00000;

void customChar(void);
int lcd;

int main()

    int lcd;
    wiringPiSetup();
    lcd = lcdInit (2, 16, 4, LCD_RS, LCD_E, LCD_D4, LCD_D5, LCD_D6, LCD_D7, 0, 0, 0, 0);

    customChar();


void customChar(void)

        lcdCharDef(lcd, 2, omega);
        
        lcdClear(lcd);
        lcdPutchar(lcd, 2);
        sleep(3);

Imprimir vários caracteres personalizados

Veja um exemplo de uso de vários caracteres personalizados que imprimem as letras gregas ômega, pi e mu, além de símbolos de termômetro e gotas de água para temperatura e umidade:

#include          
#include                 

//USE WIRINGPI PIN NUMBERS
#define LCD_RS  25               //Register select pin
#define LCD_E   24               //Enable Pin
#define LCD_D4  23               //Data pin 4
#define LCD_D5  22               //Data pin 5
#define LCD_D6  21               //Data pin 6
#define LCD_D7  14               //Data pin 7

char omega[8] =  0b00000,
                  0b01110,
                  0b10001,
                  0b10001,
                  0b10001,
                  0b01010,
                  0b11011,
                  0b00000;

char pi[8] =  0b00000,
               0b00000,
               0b11111,
               0b01010,
               0b01010,
               0b01010,
               0b10011,
               0b00000;

char mu[8] =  0b00000,
               0b10010,
               0b10010,
               0b10010,
               0b10010,
               0b11101,
               0b10000,
               0b10000;
               
char drop[8] =  0b00100,
	             0b00100,
	             0b01010,
	             0b01010,
	             0b10001,
	             0b10001,
	             0b10001,
	             0b01110; 
	       
char temp[8] =  0b00100,
                 0b01010,
	             0b01010,
	             0b01110,
	             0b01110,
	             0b11111,
	             0b11111,
	             0b01110;

void customChar(void);
int lcd;

int main()

    int lcd;
    wiringPiSetup();
    lcd = lcdInit (2, 16, 4, LCD_RS, LCD_E, LCD_D4, LCD_D5, LCD_D6, LCD_D7, 0, 0, 0, 0);

    customChar();


void customChar(void)

        lcdCharDef(lcd, 10, omega); 
        lcdCharDef(lcd, 11, pi);
        lcdCharDef(lcd, 12, mu);
        lcdCharDef(lcd, 13, drop);
        lcdCharDef(lcd, 14, temp);

        lcdClear(lcd);

        lcdPutchar(lcd, 10);
        lcdPutchar(lcd, 11);
        lcdPutchar(lcd, 12);
        lcdPutchar(lcd, 13);
        lcdPutchar(lcd, 14);

        sleep(3);

Rolagem de texto

Rolar da direita para a esquerda

Este programa irá rolar o texto para a tela da direita para a esquerda, depois pausar, limpar a tela e voltar ao início:

#include 
#include 
#include 
#include 

//USE WIRINGPI PIN NUMBERS
#define LCD_RS  25               //Register select pin
#define LCD_E   24               //Enable Pin
#define LCD_D4  23               //Data pin 4
#define LCD_D5  22               //Data pin 5
#define LCD_D6  21               //Data pin 6
#define LCD_D7  14               //Data pin 7

void scrollText(void);
char message[] = "Hello, world!";
int count = 0;
int j = 0;
int lcd;

int main()

        wiringPiSetup();
        lcd = lcdInit (2, 16, 4, LCD_RS, LCD_E, LCD_D4, LCD_D5, LCD_D6, LCD_D7, 0, 0, 0, 0);
        while(1)
            scrollText();
            


void  scrollText(void)

        int i, n;
        int h;
        int tempSpace = 0;
        char scrollPadding[] = "                ";
        int messageLength = strlen(scrollPadding) + strlen(message);
        for (n = 0; n < messageLength; n++)h = 16; usleep(300000); printf("x1B[2J"); if (j > messageLength)
                        j = 0;

                for (i = 0; i < j ; i++)
                        scrollPadding[h - j] = message[i];
                h++;
                
                lcdPosition(lcd, 0, 0);
                lcdClear(lcd);
                lcdPrintf(lcd, "%s", scrollPadding);
                j++;
        

Rolar da esquerda para a direita

Este programa rola o texto da esquerda para a direita, faz uma pausa, limpa a tela e volta ao início:

#include 
#include 
#include 
#include 

//USE WIRINGPI PIN NUMBERS
#define LCD_RS  25               //Register select pin
#define LCD_E   24               //Enable Pin
#define LCD_D4  23               //Data pin 4
#define LCD_D5  22               //Data pin 5
#define LCD_D6  21               //Data pin 6
#define LCD_D7  14               //Data pin 7

void scrollText(void);
char message[] = "Hello, world!";
int count = 0;
int j = 0;
int lcd;

int main()

        wiringPiSetup();
        lcd = lcdInit (2, 16, 4, LCD_RS, LCD_E, LCD_D4, LCD_D5, LCD_D6, LCD_D7, 0, 0, 0, 0);
        while(1)
            scrollText();
            


void  scrollText(void)

        int i, n;
        int h;
        int tempSpace = 0;
        char scrollPadding[] = "                ";
        int messageLength = strlen(scrollPadding) + strlen(message);
        for (n = 0; n < messageLength; n++)h = 16; usleep(300000); printf("x1B[2J"); if (j > messageLength)
                        j = 0;

                for (i = strlen(message); i >= 0; i--)
                        scrollPadding[j - h] = message[i];
                h++;
                
                lcdPosition(lcd, 0, 0);
                lcdClear(lcd);
                lcdPrintf(lcd, "%s", scrollPadding);
                j++;
        

Imprimir dados de um sensor

Como um exemplo para mostrar como exibir leituras de um sensor, este programa imprime leituras de temperatura e umidade no LCD usando um sensor de temperatura e umidade DHT11. Para ver como configurar o DHT11 no Raspberry Pi, consulte o nosso artigo Como instalar o sensor de umidade DHT11 no Raspberry Pi.

O pino de sinal do DHT11 está conectado ao pino físico 7 do Raspberry Pi:

#include 
#include 
#include 
#include 
#include 

//USE WIRINGPI PIN NUMBERS
#define LCD_RS  25               //Register select pin
#define LCD_E   24               //Enable Pin
#define LCD_D4  23               //Data pin 4
#define LCD_D5  22               //Data pin 5
#define LCD_D6  21               //Data pin 6
#define LCD_D7  14               //Data pin 7
#define MAXTIMINGS 85
#define DHTPIN 7

int lcd;
int dht11_dat[5] = 0, 0, 0, 0, 0;

void read_dht11_dat()

        uint8_t laststate = HIGH;
        uint8_t counter = 0;
        uint8_t j = 0, i;
        float f; 

        dht11_dat[0] = dht11_dat[1] = dht11_dat[2] = dht11_dat[3] = dht11_dat[4] = 0;

        pinMode(DHTPIN, OUTPUT);
        digitalWrite(DHTPIN, LOW);
        delay(18);
        
        digitalWrite(DHTPIN, HIGH);
        delayMicroseconds(40);
        
        pinMode(DHTPIN, INPUT);

        for (i = 0; i < MAXTIMINGS; i++)
        
                counter = 0;
                while (digitalRead(DHTPIN) == laststate)
                
                        counter++;
                        delayMicroseconds(1);
                        if (counter == 255)
                        
                                break;
                        
                
                laststate = digitalRead(DHTPIN);

                if (counter == 255)
                        break;

                if ((i >= 4) && (i % 2 == 0))
                
                        dht11_dat[j / 8] <<= 1;
                        if (counter > 16)
                                dht11_dat[j / 8] 
         

        if ((j >= 40) && (dht11_dat[4] == ((dht11_dat[0] + dht11_dat[1] + dht11_dat[2] + dht11_dat[3]) & 0xFF)))
        
                f = dht11_dat[2] * 9. / 5. + 32;

                lcdPosition(lcd, 0, 0);
                lcdPrintf(lcd, "Humidity: %d.%d %%n", dht11_dat[0], dht11_dat[1]);

                lcdPosition(lcd, 0, 1);
                //lcdPrintf(lcd, "Temp: %d.0 C", dht11_dat[2]); //Uncomment for Celsius
                lcdPrintf(lcd, "Temp: %.1f F", f); //Comment out for Celsius
        


int main(void)

        int lcd;
        wiringPiSetup();
        lcd = lcdInit (2, 16, 4, LCD_RS, LCD_E, LCD_D4, LCD_D5, LCD_D6, LCD_D7, 0, 0, 0, 0);
        
        while (1)
        
                read_dht11_dat();
                delay(1000); 
        

        return(0);

Para a temperatura em Celsius, retire o comentário da linha 72 e, em seguida, comente a linha 73.

Espero que isso tenha ajudado você a colocar o LCD em funcionamento no seu Raspberry Pi. Os programas acima são apenas exemplos básicos, então tente combiná-los para criar efeitos e animações interessantes.

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

Artigos interessantes:
https://responsibleradio.com/como-fazer-um-excelente-plano-de-negocios/

https://draincleaningdenverco.com/ingressos-online-com-a-amazon-mechanical-turk/

https://weeventos.com.br/como-instalar-e-configurar-o-roundcube-2/

https://clipstudio.com.br/tomar-melhores-decisoes-com-base-zero-pensamento/

https://multieletropecas.com.br/como-fazer-um-teste-de-gravidez-corretamente/

https://holidayservice-tn.com/com-mais-facilidade-atraves-da-vida-desta-forma-mas-devagar-por-favor/

https://teleingressos.com.br/9-maneiras-que-voce-pode-obter-pago-para-perder-peso-e-finalmente-manter-essa-resolucao/

https://proverasfestas.com.br/como-fazer-postagem-de-convidado-trafego-e-autoridade-de-alto-valor/

https://coniferinc.com/encontre-os-precos-da-sunroom-on-line-no-mercado/

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