Guia da Interface LCD 16×2 com STM32F103C8T6

Tempo de leitura: 8 minutes

Para qualquer projeto de microcontrolador, a interface de uma unidade de exibição com ele tornaria o projeto muito mais fácil e atraente para o usuário interagir. A unidade de exibição mais comumente usada para microcontroladores são os visores alfanuméricos de 16 × 2. Esses tipos de telas não são úteis apenas para exibir informações vitais para o usuário, mas também podem atuar como uma ferramenta de depuração durante o estágio inicial de desenvolvimento do projeto. Portanto, neste tutorial, aprenderemos como podemos fazer a interface de um display LCD 16 × 2 com a placa de desenvolvimento STM32F103C8T6 STM32 e programá-lo usando o IDE Arduino. Para quem está familiarizado com o Arduino, este tutorial será apenas um passeio do bolo, pois os dois são muito semelhantes. Além disso, para saber mais sobre o STM32 Blue Pill Board, siga nosso tutorial de primeiros passos.

 

Materiais requisitados

STM32 Blue Pill Development Board STM32F103C8T6
Display LCD 16×2
Programador FTDI
Fios de conexão
ProtoBoard

 

Breve introdução ao display LCD de matriz de pontos de 16×2

Como dito anteriormente, o IDE Energia fornece uma bela biblioteca que torna a interface um pedaço de bolo e, portanto, não é obrigatório saber nada sobre o módulo de exibição. Mas, não seria interessante mostrar o que estamos usando !!

O nome 16 × 2 implica que a exibição tem 16 colunas e 2 linhas, que juntas (16*2) formam 32 caixas. Uma única caixa seria algo assim na imagem abaixo

Uma única caixa possui 40 pixels (pontos) com uma ordem de matriz de 5 linhas e 8 colunas, esses 40 pixels juntos formam um caractere. Da mesma forma, 32 caracteres podem ser exibidos em todas as caixas. Agora vamos dar uma olhada nas pinagens.

O LCD tem um total de 16 pinos, conforme mostrado acima, eles podem ser categorizados em quatro grupos como a seguir

Pinos de fonte (1, 2 e 3): esses pinos fornecem a potência e o nível de contraste do display

Pinos de controle (4, 5 e 6): esses pinos definem/controlam os registros no IC de interface do LCD (mais informações podem ser encontradas no link abaixo)

Pinos de dados/comando (7 a 14): Esses pinos fornecem os dados de quais informações devem ser exibidas no LCD.

Pinos de LED (15 e 16): Esses pinos são usados para acender a luz de fundo do LCD, se necessário (opcional).

De todos esses 16 pinos, apenas 10 pinos são obrigatórios para o funcionamento correto do LCD se você quiser saber mais sobre esses monitores LCD, pule para este artigo LCD 16×2.

 

Diagrama de circuito e conexão

O diagrama de circuito para a interface 16*2 Dot matrix LCD com STM32F103C8T6 STM32 Blue Pill board é mostrado abaixo. É feito usando o software Fritzing.

Como você pode ver, a conexão completa é feita em uma placa de ensaio. Precisamos de uma placa FTDI para programar o microcontrolador STM32. De forma semelhante ao nosso tutorial anterior, conectamos a placa FTDI ao STM32, o Vcc e o pino de aterramento do programador FDTI são conectados ao pino 5V e ao pino de aterramento do STM32, respectivamente. Isso é usado para alimentar a placa STM32 e o LCD, já que ambos podem aceitar + 5V. Os pinos Rx e Tx da placa FTDI são conectados aos pinos A9 e A10 do STM32 para que possamos programar a placa diretamente sem o carregador de boot.

Em seguida, o LCD deve ser conectado à placa STM32. Vamos usar o LCD no modo de 4 bits, então temos que conectar os 4 pinos dos bits de dados (DB4 a DB7) e os dois pinos de controle (RS e EN) à placa STM32, conforme mostrado no circuito de interface do LCD STM32F103C8T6 diagrama acima. Além disso, a tabela abaixo o ajudará a fazer a conexão.

Pin nº do LCDNome do pino LCDNome do pino STM32
1Ground (Gnd)Ground (G)
2VCC5V
3VEEGround (G)
4Register Select (RS)PB11
5Read/Write (RW)Ground (G)
6Enable (EN)PB10
7Data Bit 0 (DB0)No Connection (NC)
8Data Bit 1 (DB1)No Connection (NC)
9Data Bit 2 (DB2)No Connection (NC)
10Data Bit 3 (DB3)No Connection (NC)
11Data Bit 4 (DB4)PB0
12Data Bit 5 (DB5)PB1
13Data Bit 6 (DB6)PC13
14Data Bit 7 (DB7)PC14
15LED Positive5V
16LED NegativeGround (G)

Assim que as conexões forem feitas, podemos abrir o IDE do Arduino e começar a programá-lo.

 

Programando STM32 para LCD usando Arduino

Conforme dito neste tutorial, estaremos usando o IDE Arduino para programar nosso microcontrolador STM32. Porém, o IDE do Arduino por padrão não terá a placa STM32 instalada, portanto, temos que baixar um pacote e preparar o IDE do Arduino para o mesmo. Isso é exatamente o que fizemos em nosso tutorial anterior, começando com STM32F103C8T6 usando Arduino IDE. Portanto, se você não instalou os pacotes necessários, volte para este tutorial e siga-o antes de continuar aqui.

Assim que a placa STM32 for instalada no IDE do Arduino, podemos iniciar a programação. O programa é muito semelhante ao de uma placa Arduino, a única coisa que mudará são os nomes dos pinos, já que as notações são diferentes para STM32 e Arduino. O programa completo é fornecido no final desta página, mas para explicar o programa eu o dividi em pequenos trechos significativos, conforme mostrado abaixo.

Uma vantagem notável de usar o Arduino para programar nossos microcontroladores é que o Arduino tem bibliotecas prontas para quase todos os sensores e atuadores famosos. Então aqui começamos nosso programa incluindo a biblioteca LCD que torna a programação muito mais fácil.

#include <LiquidCrystal.h> // include the LCD library

Na próxima linha, temos que especificar a quais pinos GPIO do STM32 conectamos o controle do display LCD e as linhas de dados. Para fazer isso, temos que verificar nosso hardware; para facilitar, você também pode consultar a tabela fornecida no topo que lista os nomes dos pinos do LCD em relação ao pino GPIO do STM32. Depois de mencionar os pinos, podemos inicializar o LCD usando a função LiquidCrystal. Também denominamos nosso LCD como “LCD”, conforme mostrado abaixo.

const int rs = PB11, en = PB10, d4 = PB0, d5 = PB1, d6 = PC13, d7 = PC14; //mention the pin names to with LCD is connected to
LiquidCrystal lcd(rs, en, d4, d5, d6, d7); //Initialize the LCD

Em seguida, entramos na função de configuração. Aqui, primeiro mencionamos que tipo de LCD estamos usando. Por ser um LCD 16*2, usamos a linha lcd.begin(16,2). O código dentro da função de configuração void é executado apenas uma vez. Então, nós o usamos para exibir um texto de introdução que aparece na tela por 2 segundos e depois é apagado. Para mencionar a posição onde o texto deve aparecer, usamos a função lcd.setcursor e para imprimir o texto usamos a função lcd.print. Por exemplo, lcd.setCursor(0,0) irá definir o cursor na primeira linha e primeira coluna, onde imprimimos “LCD de interface” e a função lcd.setCursor(0,1) move o cursor para a segunda linha, primeira coluna, onde imprimimos o linha “Cap Sistema”.

void setup() {
  lcd.begin(16, 2);//We are using a 16*2 LCD
  lcd.setCursor(0, 0); //At first row first column
  lcd.print("LCD Interface"); //Print this
  lcd.setCursor(0, 1); //At secound row first column
  lcd.print("-Cap Sistema"); //Print this
  delay(2000); //wait for two secounds
  lcd.clear(); //Clear the screen
}

Depois de exibir o texto de introdução, seguramos o programa por 2 segundos, criando um atraso para que o usuário possa ler a mensagem de introdução. Este atraso é criado pelo atraso de delay(2000), onde 2000 é o valor do atraso em segundos. Após o atraso, limpamos o LCD usando a função lcd.clear() que limpa o LCD removendo todo o texto do LCD.

Finalmente, dentro do loop vazio, exibimos “STM32 –Blue Pill” na primeira linha e o valor dos segundos na segunda linha. O valor de segundo pode ser obtido na função millis(). O milis() é um temporizador que aumenta desde o momento em que o MCU é ligado. O valor está na forma de milissegundos, então o dividimos por 1000 antes de exibi-lo em nosso LCD.

void loop() {
  lcd.setCursor(0, 0); //At first row first column
  lcd.print("STM32 -Blue Pill"); //Print this
  lcd.setCursor(0, 1); //At secound row first column
  lcd.print(millis() / 1000); //Print the value of secounds
}

Carregando o programa para a placa STM32F103C8T6

Faça as conexões conforme mostrado no diagrama de circuito e use o código fornecido a seguir no IDE do Arduino. Vá para ferramentas e certifique-se de que a placa certa foi selecionada conforme feito no tutorial de introdução. Além disso, antes de carregar o programa, certifique-se de que o jumper boot 0 esteja definido como 1, conforme mostrado na imagem abaixo, e pressione o botão reset. Quando o botão de upload é pressionado, o código deve ser carregado e a mensagem será exibida no LCD conforme mostrado na imagem abaixo.

 

Verificando a saída no modo operacional

Conforme discutido no parágrafo acima, você deve ser capaz de notar a saída assim que o código for carregado. Mas este programa não funcionará na próxima vez que você ligar a placa, uma vez que a placa ainda está no modo de programação. Assim, uma vez que o programa é carregado, o jumper na inicialização 0 deve ser alterado de volta para a posição 0, conforme mostrado abaixo. Além disso, agora que o programa já foi carregado para a placa STM32, não precisamos da placa FTDI e toda a configuração pode ser alimentada pela porta micro-USB da placa STM32, conforme mostrado abaixo.

Este é apenas um projeto de interface simples para ajudar a usar o display LCD com a placa STM32, mas você também pode usá-lo para construir projetos interessantes. Espero que você tenha entendido o tutorial e aprendido algo útil com ele. Se você teve algum problema para fazê-lo funcionar, use a seção de comentários para postar o problema ou use os fóruns para outras questões técnicas.

 

Código

/*
Programa para testar LCD Alafanumérico 16*2 com STM32 (Pílula Azul)

  O circuito:
* LCD RS pino para pino digital PB11
* LCD Enable pino para pino digital PB10
* LCD D4 pino para pino digital PB0
* LCD D5 pino para pino digital PB1
* LCD D6 Pino para pino digital PC13
* LCD D7 Pino para pino digital PC14
* LCD pino R/W para aterrar
* LCD Pino VSS para aterrar
* LCD Pino VCC para 5V
*/

#include <LiquidCrystal.h> // inclui a biblioteca LCD

const int rs = PB11, en = PB10, d4 = PB0, d5 = PB1, d6 = PC13, d7 = PC14; // mencione os nomes dos pinos com o LCD conectado a
LiquidCrystal lcd(rs, en, d4, d5, d6, d7); // Inicializa o LCD

void setup() {
  lcd.begin(16, 2);    // Estamos usando um LCD 16*2
  lcd.setCursor(0, 0); // Na primeira linha, primeira coluna
  lcd.print("LCD Interface"); // Imprima isto
  lcd.setCursor(0, 1); // Na segunda linha, primeira coluna
  lcd.print("-Cap Sistema"); // Imprima isto
  
  delay(2000); // aguarde dois segundos
  lcd.clear(); // Limpar a tela
}

void loop() {

  lcd.setCursor(0, 0); // Na primeira linha, primeira coluna
  lcd.print("STM32 -Blue Pill"); // Imprima isto

  lcd.setCursor(0, 1);        // Na segunda linha, primeira coluna
  lcd.print(millis() / 1000); // Imprime o valor de segundos
}

 

 

Conclusão

Neste artigo, mostrei como usar um LCD 16×2 com a Placa STM32F103C8T6 (Blue, Azul) com a IDE Arduino. Espero que você tenha achado útil e informativo. Se sim, compartilhe com um amigo que também gosta de eletrônica e de fazer coisas!

Eu adoraria saber quais projetos você planeja construir (ou já construiu) com esses LCD e Placas STM. Se você tiver alguma dúvida, sugestão ou se achar que falta algo neste tutorial, por favor, deixe um comentário abaixo.