Guia da Interface LCD 16×2 com STM32F103C8T6
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.
Conteudo
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 LCD | Nome do pino LCD | Nome do pino STM32 |
1 | Ground (Gnd) | Ground (G) |
2 | VCC | 5V |
3 | VEE | Ground (G) |
4 | Register Select (RS) | PB11 |
5 | Read/Write (RW) | Ground (G) |
6 | Enable (EN) | PB10 |
7 | Data Bit 0 (DB0) | No Connection (NC) |
8 | Data Bit 1 (DB1) | No Connection (NC) |
9 | Data Bit 2 (DB2) | No Connection (NC) |
10 | Data Bit 3 (DB3) | No Connection (NC) |
11 | Data Bit 4 (DB4) | PB0 |
12 | Data Bit 5 (DB5) | PB1 |
13 | Data Bit 6 (DB6) | PC13 |
14 | Data Bit 7 (DB7) | PC14 |
15 | LED Positive | 5V |
16 | LED Negative | Ground (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.