es gl es ca gl gl gl gl es gl en gl es en pt ceb gl gl gl gl gl gl pt pt gl gl gl gl it en gl gl gl gl gl gl gl gl gl pt gl es gl gl th en pt en gl gl en gl gl gl gl gl gl pt pt pt pt pt gl gl es gl gl pt gl gl pt gl gl gl gl gl gl gl gl uk gl gl gl gl gl gl gl gl gl gl gl gl uk gl gl gl gl gl gl en gl gl gl es gl es fr gl gl gl pt gl gl vi gl en gl gl gl es gl en gl gl gl gl gl gl en ja gl gl gl gl gl en gl gl gl gl en gl es es gl gl gl pt es gl gl gl pt pt en gl ar es gl en en en gl gl gl ca gl ca gl gl gl gl gl gl gl gl it gl gl gl gl gl gl gl gl gl gl en it es es gl es gl es es gl pt en gl gl ca fr fr gl gl gl pt es sv es gl sv pt en gl hu en gl gl en gl it it es uk pt gl gl gl gl gl en gl gl es gl gl vi gl gl gl gl es es gl gl gl gl gl it gl es en en en gl en en en en gl en en en en gl
LCD vén do inglés Liquid Crystal Display, é dicir, é unha pantalla de cristal liquido. As LCDs alfa-numéricas permiten mostrar mensaxes de texto sinxelos e hainas dispoñibles en diferentes formatos. A que usaremos aquí (modelo 1602A) ten un formato 16×2 (16 caracteres e dúas liñas).
Imos ver dúas opcións de conexión e programación:
Conexión a través de interface I2C
No primeiro caso, para poder realizar as conexións da pantalla debemos soldar unha tira de pins nos conectores e suxeitala cunha protoboard.
No segundo caso o controlador xa vén integrado e preparado para conectar. Úsanse unicamente dous pins de Arduíno, polo que pode ser interesante para proxectos complexos nos que xa teñamos moitos pins ocupados con outras cousas.
Elixe a opción correspondente á pantalla que vaias utilizar:
[tecnoloxia.org CC By-SA from Fritzing]
I²C ou I2C  é un bus de comunicacións en serie que utiliza dúas liñas para transmitir a información: unha para os datos e outra para o sinal de reloxo, polo que a conexión dunha pantalla LCD con interface I2C resulta moi sinxela, pois só temos catro pins.
No caso dunha placa Arduíno UNO as conexións serían:
GND e Vcc para a alimentación.
SDA ao pin analóxico A4. É o pin de datos.
SCL ao pin analóxico A5. É o que envía o sinal de reloxo.
A tarxeta Arduíno UNO Rev3 ten outros dous pins que podemos utilizar igualmente para a comunicación I2C, e que están na parte superior, xunto aos pins dixitais. Está indicado pola parte de atrás da tarxeta. Se tes este modelo de Arduíno e che resulta máis cómodo podes substituír as conexións A4 e A5 polos pins SDA e SCL da parte superior.
O módulo I2C soe vir acoplado á parte posterior da pantalla LCD, e incorpora un potenciómetro que permite o axuste do brillo.
Debes soldar unha tira de pins á pantalla LCD, conectala nunha protoboard, e realizar as seguintes conexións:
A pantalla LCD debería acenderse se conectamos a alimentación do Arduíno
Rs: ao pin 12 do Arduíno
É o díodo de retro-iluminación.
LED A: a unha resistencia de 220Ω conectada a 5V no outro extremo.
4º) Cables de datos:
Encárgase do axuste do brillo. Fai unha proba despois de conectalo. Deberían verse as matrices de puntos.
Vo: Pin central do potenciómetro.
Un pin dos extremos do potenciómetro a 5V e o outro a GND.
DB4: ao pin 5 do Arduíno
DB5: ao pin 4 do Arduíno
DB6: ao pin 3 do Arduíno
DB7: ao pin 2 do Arduíno
[Esquema exemplo de fritzing]
Nestas lapelas móstranse os programas de inicio da LCD normal e da LCD con I2C respectivamente. Na sección de prácticas mostraremos diversos exemplos de programas a incluír no loop(){ } e que se programan do mesmo xeito sexa cal sexa a opción escollida.
1. Configuración con I2C
O primeiro que debemos facer é incorporar a librería LiquidCrystal-I2C.  Pódese descargar  directamente neste zip. Unha vez gardada no noso ordenador engadímola ao directorio de librerías do IDE de Arduíno (” Sketch → Incluír biblioteca → engadir biblioteca zip”) e despois incluímola no noso proxecto (Sketch → Incluír biblioteca → LiquidCrystal-I2C).
Hai que incluír ademais outra librería estándar que xa temos no IDE de Arduíno e que se encarga da comunicación I2C: (Sketch → Incluír biblioteca → Wire)  (Wire reference)
Debemos coñecer o enderezo da pantalla LCD en hexadecimal.
Cada compoñente que conectamos a un bus I2C ten un enderezo único, o que permite que os datos sexan enviados a un dispositivo concreto no caso de ter conectado máis de un. O enderezo por defecto destas pantallas LCD soe ser 0x27, pero depende do modelo. Se tes outro dispositivo podes atopar o seu enderezo utilizando o programa I2C scanner no teu Arduíno. Sairá unha mensaxe como a da imaxe.
Despois debemos introducir os parámetros da clase LiquidCrystal_I2C. No noso caso serán o enderezo, o número de columnas e o número de filas:  LiquidCrystal_I2C lcd(0x27, 16, 2);
Proba este programa cunha mensaxe de inicio.
Para enviar un texto e que se mostre na pantalla utilizamos a función: lcd.print(“texto”);
Para borrar a pantalla utilizamos a función lcd.clear();
/* Pantalla LCD con I2C */ // Librerías #include   // Para a comunicación I2C #include   // Para o control da LCD con I2C // pins LiquidCrystal_I2C lcd(0x27, 16, 2); // Configuración: void setup(){ lcd.init(); // Inicializar a LCD //(pode que nalgunha librería teñeas que iniciar coa instrución lcd.begin(); e non a anterior. Consulta a documentación) lcd.backlight(); // acender lcd.print("LCD acesa!"); // Escribimos texto delay (2000); lcd.clear(); // Borrar pantalla } // Programa: void loop() { // Aquí escribiremos os programas }
Carga este programa e axusta o contraste co potenciómetro ata que se vexa ben o texto. Para que se mostre o texto permanentemente ata que finalices o axuste comenta a instrución de borrado:
// lcd.clear(); // Borrar pantalla
Elimina o comentario antes de introducir os programas seguintes no loop() para que se borre a pantalla de benvida antes de que se executen.
Antes de nada debemos incorporar a librería “LiquidCrystal.h” que xa está incluída no propio IDE de Arduíno: Sketch → Incluír biblioteca → LiquidCrystal
Despois debemos crear unha instancia chamada lcd, da clase LiquidCrystal, e escribimos os parámetros cos pins que utilizamos para conectar a pantalla a Arduíno. LiquidCrystal lcd( RS, EN, d4, d5, d6, d7);
No setup() debemos indicar o número de columnas e o número de filas da nosa LCD: lcd.begin(columnas, filas);
Imos escribir unha primeira mensaxe que aparece cando iniciamos o programa e que só se vai executar unha vez, pois está no setup().
Para enviar un texto e que se mostre na pantalla utilizamos a función: lcd.print(“texto”);
Para borrar a pantalla utilizamos a función lcd.clear();
#include   // Configuración: LiquidCrystal lcd(12, 11, 5, 4, 3, 2); // Escribimos os pins ao que está conectada a LCD void setup() { lcd.begin(16, 2); // nº columnas, nº de filas lcd.print("LCD acesa!"); // Escribimos delay(1000); lcd.clear(); // Borrar pantalla } // Programa: void loop(){ // Substitúe este bucle polos que aparecen nas seguintes prácticas para probalas }
Carga este programa e axusta o contraste co potenciómetro ata que se vexa ben o texto. Para que se mostre o texto permanentemente ata que finalices o axuste comenta a instrución de borrado:
// lcd.clear(); // Borrar pantalla
Elimina o comentario antes de introducir os programas seguintes no loop() para que se borre a pantalla de benvida antes de que se executen.
Aquí móstranse algúns exemplos de programas que podes incluír no loop(){ } que deixamos baleiro. Lémbrate de poñer primeiro o programa correspondente á configuración da túa pantalla LCD.
Imos escribir un texto na pantalla en diferentes posicións. Para indicar a posición do cursor debemos utilizar a función lcd.setCursor(columna, liña); A nosa pantalla ten 16 columnas (de 0 a 15) e 2 liñas (0 a de arriba e 1 a de abaixo)
// Posición do punteiro: void loop() { lcd.home(); // Pon o cursor no (0,0) lcd.print("Posicion:"); // Escribe un texto delay(500); lcd.setCursor(10, 0); // Cursor na columna 10 liña 0 lcd.print("10,0"); delay(500); lcd.setCursor(0, 1); // Cursor na columna 0 liña 1 lcd.print("0,1"); delay(500); lcd.setCursor(5, 1); // Cursor na columna 5 liña 1 lcd.print("5,1"); delay(500); lcd.setCursor(10, 1); lcd.print("10,1"); delay(3000); lcd.clear(); // Borrar pantalla }
Agora imos facer scroll cun texto derminado. Para mover un texto pola pantalla usaremos as funcións lcd.scrollDisplayLeft(); para movernos cara á esquerda e lcd.scrollDisplayRight(); cara á dereita.
Debemos indicar mediante un bucle for o número de posicións que queremos movernos. A velocidade do desprazamento pódese axustar cambiando o valor do delay do bucle for.
// Scroll void loop(){ lcd.print("tecnoloxia"); // Escribimos (texto de 10 caracteres) delay(1000); for (int pos=0; pos<10; pos++) { // Scroll 10 posicións á esquerda lcd.scrollDisplayLeft(); delay(150); } delay(1000); for (int pos=0; pos<26; pos++) { // Scroll 26 posicións á dereita. (10 da palabra + 16 da pantalla) lcd.scrollDisplayRight(); delay(150); } delay(1000); for (int pos=0; pos<13; pos++) { // Mover ao centro da pantalla (5 da palabra +8 da pantalla) lcd.scrollDisplayLeft(); delay(150); } delay(3000); lcd.clear(); // Borrar pantalla }
Tamén podemos configurar a pantalla para que faga scroll automático cando se introduce un texto. Para iso temos que utilizar a función lcd.autoscroll(); para activalo e lcd.noAutoscroll(); para desactivalo
// Scroll automático void loop(){ lcd.setCursor(0, 0); for (int thisChar=0; thisChar<10; thisChar++) { // Escribir de 0 a 9 sen scroll lcd.print(thisChar); delay(500); } lcd.autoscroll(); // Poñemos a pantalla en modo scroll automático: lcd.setCursor(16, 1); // Cursor na columna 16 liña 1 for (int thisChar=0; thisChar<10; thisChar++) { // Escribir de 0 a 9 (con scroll automático) lcd.print(thisChar); delay(500); } lcd.noAutoscroll(); // Paramos o scroll automático delay(3000); lcd.clear(); }
Agora imos mostrar na pantalla LCD un texto recollido desde a consola serie. Só falta que ti lle poñas scroll a gusto.
Para entender como funciona a consola serie podes mirar previamente esta páxina.
// Texto desde consola // ** Engadir isto no setup() do teu programa Serial.begin(9600); // Iniciamos a comunicación serial while(!Serial); // ** void loop() { lcd.print("Introduce texto"); lcd.setCursor(0, 1); lcd.print("na consola serie"); delay(1000); while(Serial.available()==0); // Agarda mentres non recibe datos if (Serial.available()) { // Cando están entrando caracteres polo porto serie ... delay(100); // Damos tempo para que chegue a mensaxe lcd.clear(); // Borramos a pantalla while (Serial.available() > 0) { // Mentres haxa datos no buffer lcd.write(Serial.read()); // Lemos os caracteres e escribímolos la LCD delay(100); } } delay(3000); lcd.clear(); // Borrar pantalla }
Se ves que se imprimen caracteres estraños despois do texto introducido na consola, pode ser que esteas engadindo o salto de liña.
Para solucionalo selecciona na parte inferior da consola “Falta final de liña”.
Podemos definir os nosos propios caracteres e amosalos na pantalla, e incluso crear animacións.
[tecnoloxia.org CC By-SA from lcdchar]
O primeiro que debemos facer é definir os nosos caracteres personalizados creando un array cos valores dos píxeles de cada carácter, formado por 40 puntos distribuídos en 8 filas e 5 columnas. Nesta web tes unha aplicación para debuxar e extraer o código dos teus debuxos.
Despois rexistramos o novo carácter coa instrución lcd.createChar(número asignado, nome do array);
Para mostralo na pantalla LCD temos dúas opcións:
// Debuxos void loop() { // definición dos novos caracteres byte corazon1[8] = {B00000,B01010,B11111,B11111,B11111,B01110,B00100,B00000}; byte corazon2[8] = {B00000,B01010,B10101,B10001,B10001,B01010,B00100,B00000}; byte bateria1[8] = {B01110,B11011,B10001,B10001,B10001,B10001,B10001,B11111}; byte bateria2[8] = {B01110,B11011,B10001,B10001,B10001,B10001,B11111,B11111}; byte bateria3[8] = {B01110,B11011,B10001,B10001,B10001,B11111,B11111,B11111}; byte bateria4[8] = {B01110,B11011,B10001,B10001,B11111,B11111,B11111,B11111}; byte bateria5[8] = {B01110,B11011,B10001,B11111,B11111,B11111,B11111,B11111}; byte bateria6[8] = {B01110,B11111,B11111,B11111,B11111,B11111,B11111,B11111}; lcd.createChar(0, corazon1); lcd.createChar(1, corazon2); lcd.createChar(2, bateria1); lcd.createChar(3, bateria2); lcd.createChar(4, bateria3); lcd.createChar(5, bateria4); lcd.createChar(6, bateria5); lcd.createChar(7, bateria6); // I love tecnoloxia lcd.home(); // Pon o cursor no (0,0) lcd.print("I "); lcd.print((char)0); // Pinta o corazón1 lcd.print(" tecnoloxia "); delay(3000); lcd.clear(); // Animación carga: lcd.home(); for (int i=2; i<=7; i++){ lcd.clear(); lcd.print((char)i); delay(1000); } lcd.print(" Carga completa"); delay(3000); lcd.clear(); // Animación corazón: for (int j=0; j<10; j++){ // Repetimos 10 veces for (int i=0; i<=1; i++){ // debuxa os corazóns 1 e 2 cun intervalo de tempo lcd.clear(); lcd.print((char)i); delay(300); } } delay(2000); lcd.clear(); }
Hai que ter en conta que só podemos usar 8 caracteres especiais simultaneamente (de 0 a 7). O número asignado indica a posición da memoria da pantalla onde gardamos o carácter personalizado. Esta pantalla ten 8 posicións de memoria, polo que se queremos gardar un noveno deseño teremos que substituír algún dos gardados anteriormente no momento de utilizalo.
Estas son algunhas ideas para traballar, pero o ideal é que traballes o necesario para incorporar unha pantalla LCD ao teu proxecto.
Datos dos sensores: Mostra na pantalla LCD os datos procedentes dun sensor. Por exemplo, dun sensor de temperatura mostra os graos centígrados e kelvin.
Datos de saída: Mostra na pantalla os datos de saída dalgún actuador do teu proxecto: Led aceso ou apagado, ángulo dun servo, estado dun motor (sentido de xiro e parado).
Ascensor: Nun proxecto dun ascensor de 3 pisos, mostra na pantalla o piso no que está ou se está subindo ou baixando.
En Thingiverse tedes o STL deste soporte para LCD deseñado polo alumnado de Tecnoloxía Industrial de 2ºBach (curso 16-17)
Se queres facer o teu propio soporte poden axudarche estas medidas:
Cando remates o teu traballo podes botar unha partida a Arduino LCD Game.
Facendo clic en “Code editor” podes copiar o código para cargalo no teu Arduíno. Se usas unha LCD con interface I2C lémbrate de adaptar a configuración do programa. Engade un pulsador ao pin 2. (Instrucións aquí)
[Captura de Arduino LCD Game from circuits.io]
Deixa un comentario Cancelar a resposta
Nome Correo electrónico Sitio web
Gardar o meu nome, correo electrónico e web neste navegador para a próxima vez que faga un comentario.
Descrición de Arduíno UNO
O IDE de Arduíno
Entradas e saídas dixitais
Condicional if … else
Sinais PWM e lectura serial
Array de LEDs e funcións
A posición dun servo
Servos de xiro continuo
Motor de corrente continua
Motores paso a paso
Sensor de Luz LDR
Sensor de temperatura LM35 e TMP36
Sensor de temperatura e humidade DHT11
Sensor de temperatura DS18B20
Sensor de movemento PIR
Sensor de cor TCS3200
Sensor de cor TCS34725 RGB
Sensor de auga no solo
Medindo o tempo 1
Medindo o tempo 2: RTC
Bluetooth mestre + escravo
O tanque de auga
Reloxo de area dixital
A máquina máis inútil
Clasificador M&M’s por cor
Alarma para a cortadora láser
© 2022 Arduino • Creado con GeneratePress
We use cookies on our website to give you the most relevant experience by remembering your preferences and repeat visits. By clicking “Accept All”, you consent to the use of ALL the cookies. However, you may visit "Cookie Settings" to provide a controlled consent.
This website uses cookies to improve your experience while you navigate through the website. Out of these, the cookies that are categorized as necessary are stored on your browser as they are essential for the working of basic functionalities of the website. We also use third-party cookies that help us analyze and understand how you use this website. These cookies will be stored in your browser only with your consent. You also have the option to opt-out of these cookies. But opting out of some of these cookies may affect your browsing experience.
Necessary cookies are absolutely essential for the website to function properly. This category only includes cookies that ensures basic functionalities and security features of the website. These cookies do not store any personal information.
Any cookies that may not be particularly necessary for the website to function and is used specifically to collect user personal data via analytics, ads, other embedded contents are termed as non-necessary cookies. It is mandatory to procure user consent prior to running these cookies on your website.