PRÁCTICA #7/MENSAJES POR DISPLAY LCD


UNIDAD EDUCATIVA PARTICULAR POLITÉCNICO COPOL
SEGUNDO DE BACHILLERATO "A" OXFORD/ÁREA DE INFORMÁTICA
ESTUDIANTE: ALEX TAPIA VALAREZO/PROFESOR: ENRIQUE GUEVARA
ACTIVIDAD INDIVIDUAL/ANÁLISIS DE CIRCUITOS ELECTRÓNICOS
PRÁCTICA #7
MATERIALES DE TRABAJO:

1 PROTOBOARD
1 DISPLAY LCD
1 ARDUINO
1 POTENCIÓMETRO
1 RESISTENCIA 220 (ROJO ROJO CAFÉ)
CABLES MACHO - MACHO O MACHO - HEMBRA
1 PASTA PARA SOLDAR
1 ROLLLO DE ESTAÑO PARA SOLDAR
1 CAUTÍN DE PLÁSTICO O MADERA PARA SOLDAR
1 PORTA-CAUTÍN
1 PINZA CORTA ESTAÑO

PROCEDIMIENTO/IMÁGENES DE EVIDENCIA

SOLDADURA DE ESPADINES A DISPLAY LCD CON CAUTÍN/PASTA PARA SOLDAR Y ESTAÑO



UTILIZACIÓN DE LUPA PARA MEJOR VISUALIZACIÓN DE SOLDADURA


CONEXIÓN DE ESPADINES DE DISPLAY LCD AL ARDUINO UNO

 CONEXIÓN DE DIVERSOS PUENTES CON AYUDA DEL DIAGRAMA GUÍA

 CONEXIÓN DE PATAS DEL POTENCIÓMETRO AL ARDUINO UNO

CONEXIÓN DE RESISTENCIA HACIA TERMINAL POSITIVA DEL PROTOBOARD

 CONEXIÓN EFECTIVA DE TERMINALES POSITIVA-NEGATIVA A PINES 5V-GND DEL ARDUINO UNO

 REVISIÓN DE CONEXIÓN DE ESPADINES DE DISPLAY LCD
CONEXIONES AL ARDUINO UNO EN GENERAL (PINES EMPLEADOS)

 REVISIÓN DE CONEXIÓN DE RESISTENCIA Y PUENTES DIVERSOS

REVISIÓN DE CONEXIÓN DE PATAS DEL POTENCIÓMETRO 



CONEXIÓN EFECTIVA DE COMPONENTES ELECTRÓNICOS

FUNCIONAMIENTO CORRECTO DE PRIMERA PROGRAMACIÓN











FUNCIONAMIENTO CORRECTO DE SEGUNDA PROGRAMACIÓN



















FUNCIONAMIENTO CORRECTO DE PROGRAMACIÓN CON SÍMBOLO PERSONALIZADO 




FUNCIONAMIENTO CORRECTO DE PROGRAMACIÓN CON NOMBRE DE ESTUDIANTE



PROCEDIMIENTO
Se procedió a soldar primero los espadines en el display LCD. En ese sentido, una vez soldados todos los espadines a utilizar, procedimos a posicionar el potenciómetro dentro del cuadrante izquierdo del protoboard para evitar hacer muchos más puentes; es así que pasamos a conectar el espadín VSS a la tercera pata del potenciómetro, así mismo los espadines VDD y VO del display LCD  a las patas primera y segunda del protoboard respectivamente. Continuamente se conectaron las terminales positiva-negativa del protoboard a los pines 5V-GND del arduino. Una vez realizado esto, pasamos a enlazar los espadines D4-D5-D6-D7 del display LCD a los pines 5-4-3-2 del Arduino UNO. Pero también utilizamos los espadines A-K para conectarlos; el primero con la resistencia hacia la terminal positiva del protoboard y el segundo hacia la terminal negativa directamente. Ademas, no podemos olvidar que también conectamos los espadines RS-E hacia los pines 12-11 del Arduino UNO y el espadín RW hacia la terminal negativa del protoboard. Finalmente se realizaron dos puentes para cerrar el circuito; el primero desde la primera pata del potenciómetro (pata izquierda) hacia la terminal positiva del protoboard y el segundo desde la tercera pata del potenciómetro (pata derecha) hacia la terminal negativa del protoboard. Luego simplemente hacía falta conectar el arduino UNO a la PC y empezar con las programaciones. 

  • Es necesario recalcar que las dos programaciones fueron ya realizadas por el Docente de la asignatura, a pesar de aquello, los estudiantes tuvieron luego que realizar otras dos programaciones distintas; la primera guiándose con la primera programación del Profesor, es decir, utilizando el código de ceros y unos (0-1) y la segunda guiándose así mismo con la segunda programación del Profesor, pero ésta vez redactando simplemente su nombre y apellido.

PROGRAMACIÓN/EVIDENCIA DE PROGRAMA "ARDUINO UNO"
Las programaciones guías empleadas fueron las siguientes:

 PRIMERA PROGRAMACIÓN GUÍA

 #include <LiquidCrystal.h>      // incluir la libreria

 LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

 // caracteres para formar SUPERMAN
byte S_UL[8] = 
{
  B00000,
  B00011,
  B00111,
  B01110,
  B11101,
  B11001,
  B11101,
  B01111
};
byte S_ULM[8] =
{
  B00000,
  B11111,
  B11111,
  B11000,
  B10000,
  B10000,
  B11111,
  B11111
};
byte S_URM[8] =
{
  B00000,
  B11111,
  B11111,
  B00110,
  B00011,
  B00000,
  B11111,
  B11111
};
byte S_UR[8] =
{
  B00000,
  B11000,
  B11110,
  B11110,
  B10111,
  B00011,
  B00111,
  B10110
};
byte S_DL[8] =
{
  B00111,
  B00011,
  B00001,
  B00000,
  B00000,
  B00000,
  B00000,
  B00000
};
byte S_DLM[8] =
{
  B00000,
  B10110,
  B11111,
  B11100,
  B01110,
  B00111,
  B00011,
  B00001
};
byte S_DRM[8] =
{
  B00001,
  B00011,
  B11111,
  B00111,
  B01110,
  B11100,
  B11000,
  B10000
};
byte S_DR[8] =
{
  B11100,
  B11000,
  B10000,
  B00000,
  B00000,
  B00000,
  B00000,
  B00000
};
// caracteres para formar BATMAN1
byte B1_UL[8] = 
{
  B00000,
  B00000,
  B00000,
  B11111,
  B11111,
  B01111,
  B00111,
  B00111
};
byte B1_ULM[8] =
{
  B00000,
  B00000,
  B00000,
  B10000,
  B10010,
  B11011,
  B11111,
  B11111
};
byte B1_URM[8] =
{
  B00000,
  B00000,
  B00000,
  B00001,
  B01001,
  B11011,
  B11111,
  B11111
};
byte B1_UR[8] =
{
  B00000,
  B00000,
  B00000,
  B11111,
  B11111,
  B11110,
  B11100,
  B11100
};
byte B1_DL[8] =
{
  B00000,
  B00000,
  B00000,
  B00011,
  B00001,
  B00000,
  B00000,
  B00000
};
byte B1_DLM[8] =
{
  B01111,
  B00011,
  B00001,
  B00000,
  B00000,
  B00000,
  B00000,
  B00000
};
byte B1_DRM[8] =
{
  B11110,
  B11000,
  B10000,
  B00000,
  B00000,
  B0000,
  B00000,
  B00000
};
byte B1_DR[8] =
{
  B00000,
  B00000,
  B00000,
  B11000,
  B10000,
  B00000,
  B00000,
  B00000
};
// caracteres para formar BATMAN
byte B_UL[8] = 
{
  B00000,
  B00000,
  B00000,
  B00001,
  B00110,
  B01110,
  B11111,
  B11111
};
byte B_ULM[8] =
{
  B00000,
  B00000,
  B00000,
  B00010,
  B00011,
  B00011,
  B10111,
  B11111
};
byte B_URM[8] =
{
  B00000,
  B00000,
  B00000,
  B01000,
  B11000,
  B11000,
  B11101,
  B11111
};
byte B_UR[8] =
{
  B00000,
  B00000,
  B00000,
  B10000,
  B01100,
  B01110,
  B11111,
  B11111
};
byte B_DL[8] =
{
  B11111,
  B11111,
  B01110,
  B00100,
  B00010,
  B00000,
  B00000,
  B00000
};
byte B_DLM[8] =
{
  B11111,
  B11111,
  B10011,
  B00001,
  B00000,
  B00000,
  B00000,
  B00000
};
byte B_DRM[8] =
{
  B11111,
  B11111,
  B11001,
  B10000,
  B00000,
  B00000,
  B00000,
  B00000
};
byte B_DR[8] =
{
  B11111,
  B11111,
  B01110,
  B00100,
  B01000,
  B00000,
  B00000,
  B00000
};
// caracteres para formar ESPADAS
byte E_UL[8] = 
{
  B00011,
  B00010,
  B00010,
  B00001,
  B00000,
  B00000,
  B00000,
  B01100
};
byte E_ULM[8] =
{
  B10000,
  B01000,
  B00100,
  B00010,
  B10001,
  B01000,
  B00100,
  B01010
};
byte E_URM[8] =
{
  B00011,
  B00100,
  B01000,
  B10001,
  B00010,
  B10100,
  B01000,
  B00100
};
byte E_UR[8] =
{
  B10000,
  B10000,
  B10000,
  B00000,
  B00000,
  B00000,
  B00000,
  B01100
};
byte E_DL[8] =
{
  B01110,
  B00111,
  B00111,
  B00011,
  B00111,
  B01110,
  B11100,
  B11000
};
byte E_DLM[8] =
{
  B10001,
  B00010,
  B00100,
  B11000,
  B11100,
  B11110,
  B00110,
  B00000
};
byte E_DRM[8] =
{
  B00010,
  B10001,
  B01001,
  B00111,
  B01111,
  B11110,
  B11000,
  B00000
};
byte E_DR[8] =
{
  B11100,
  B11000,
  B11000,
  B10000,
  B11000,
  B11100,
  B01110,
  B00110
};
// caracteres para formar LOGO DC
byte L_UL[8] = 
{
  B00000,
  B00000,
  B11111,
  B01111,
  B00110,
  B00111,
  B00111,
  B00111
};
byte L_ULM[8] =
{
  B00000,
  B00000,
  B11000,
  B11100,
  B01110,
  B00110,
  B00110,
  B00110
};
byte L_URM[8] =
{
  B00000,
  B00000,
  B00111,
  B01111,
  B11000,
  B11100,
  B11100,
  B11100
};
byte L_UR[8] =
{
  B00000,
  B00000,
  B01100,
  B11100,
  B11000,
  B11000,
  B00000,
  B00000
};
byte L_DL[8] =
{
  B00111,
  B00111,
  B00111,
  B00111,
  B01111,
  B00000,
  B00000,
  B00000
};
byte L_DLM[8] =
{
  B00110,
  B00110,
  B01110,
  B11100,
  B11000,
  B00000,
  B00000,
  B00000
};
byte L_DRM[8] =
{
  B11100,
  B11100,
  B11110,
  B01111,
  B00111,
  B00000,
  B00000,
  B00000
};
byte L_DR[8] =
{
  B00000,
  B00000,
  B11000,
  B11000,
  B11000,
  B00000,
  B00000,
  B00000
};

 void setup()
{ 
  lcd.begin(0, 2);     
}

 void BATMAN()        // usa los caracteres para crear BATMAN
{ 
  lcd.createChar(1,B_UL);
  lcd.createChar(2,B_ULM);
  lcd.createChar(3,B_URM);
  lcd.createChar(4,B_UR);
  lcd.createChar(5,B_DL);
  lcd.createChar(6,B_DLM);
  lcd.createChar(7,B_DRM);
  lcd.createChar(8,B_DR);
  
  lcd.setCursor(10, 0); 
  lcd.write(1);  
  lcd.write(2); 
  lcd.write(3);  
  lcd.write(4); 
  lcd.setCursor(10, 1);
  lcd.write(5);  
  lcd.write(6);
  lcd.write(7);  
  lcd.write(8);  
  
  lcd.setCursor(2, 1);
  lcd.print("BATMAN"); 
}
void BATMAN1()        // usa los caracteres para crear BATMAN1
{ 
  lcd.createChar(1,B1_UL);
  lcd.createChar(2,B1_ULM);
  lcd.createChar(3,B1_URM);
  lcd.createChar(4,B1_UR);
  lcd.createChar(5,B1_DL);
  lcd.createChar(6,B1_DLM);
  lcd.createChar(7,B1_DRM);
  lcd.createChar(8,B1_DR);
  
  lcd.setCursor(9, 0); 
  lcd.write(5);
  lcd.write(1);  
  lcd.write(2); 
  lcd.write(3);  
  lcd.write(4); 
  lcd.write(8);
  lcd.setCursor(11, 1);  
  lcd.write(6);
  lcd.write(7);   
  
  lcd.setCursor(2, 1);
  lcd.print("BATMAN"); 
}

 void SUPERMAN()        // usa los caracteres para crear SUPERMAN
{ 
  lcd.createChar(1,S_UL);
  lcd.createChar(2,S_ULM);
  lcd.createChar(3,S_URM);
  lcd.createChar(4,S_UR);
  lcd.createChar(5,S_DL);
  lcd.createChar(6,S_DLM);
  lcd.createChar(7,S_DRM);
  lcd.createChar(8,S_DR);
  
  lcd.setCursor(1, 0);  
  lcd.write(1);  
  lcd.write(2); 
  lcd.write(3);  
  lcd.write(4); 
  lcd.setCursor(1, 1);
  lcd.write(5);  
  lcd.write(6);
  lcd.write(7);  
  lcd.write(8);  
  
  lcd.setCursor(7, 1);
  lcd.print("SUPERMAN"); 
}

 void ESPADAS()        // usa los caracteres para crear ESPADAS
{ 
  lcd.createChar(1,E_UL);
  lcd.createChar(2,E_ULM);
  lcd.createChar(3,E_URM);
  lcd.createChar(4,E_UR);
  lcd.createChar(5,E_DL);
  lcd.createChar(6,E_DLM);
  lcd.createChar(7,E_DRM);
  lcd.createChar(8,E_DR);
  
  lcd.setCursor(6, 0);  
  lcd.write(1);  
  lcd.write(2); 
  lcd.write(3);  
  lcd.write(4); 
  lcd.setCursor(6, 1);
  lcd.write(5);  
  lcd.write(6);
  lcd.write(7);  
  lcd.write(8);  
}

 void DC_LOGO()        // usa los caracteres para crear DC_LOGO
{ 
  lcd.createChar(1,L_UL);
  lcd.createChar(2,L_ULM);
  lcd.createChar(3,L_URM);
  lcd.createChar(4,L_UR);
  lcd.createChar(5,L_DL);
  lcd.createChar(6,L_DLM);
  lcd.createChar(7,L_DRM);
  lcd.createChar(8,L_DR);
  
  lcd.setCursor(2, 0);  
  lcd.write(1);  
  lcd.write(2); 
  lcd.write(3);  
  lcd.write(4); 
  lcd.setCursor(2, 1);
  lcd.write(5);  
  lcd.write(6);
  lcd.write(7);  
  lcd.write(8);  
  
  lcd.setCursor(10,0);
  lcd.print("DC"); 
  lcd.setCursor(8, 1);
  lcd.print("COMICS"); 
}

 void loop()
{
  DC_LOGO();
  delay(5000);
  lcd.clear();
  
  SUPERMAN();
  delay(5000);
  lcd.clear();
  
  BATMAN();
  delay(5000);
  lcd.clear();
  
  ESPADAS();
  delay(3000);
  lcd.clear();
  
  SUPERMAN();
  delay(5000);
  lcd.clear();
  
  BATMAN1();
  delay(5000);
  lcd.clear();

}

 SEGUNDA PROGRAMACIÓN GUÍA





PRIMERA PROGRAMACIÓN CON SÍMBOLO PERSONALIZADO
#include <LiquidCrystal.h>      // incluir la libreria

 LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

 // caracteres para formar CARITA FELIZ
byte OJO_1[8] = 
{
  B00000,
  B01110,
  B01110,
  B01110,
  B01110,
  B00000,
  B00000,
  B00000
};
byte OJO_2[8] =
{
  B00000,
  B01110,
  B01110,
  B01110,
  B01110,
  B00000,
  B00000,
  B00000
};
byte SONRISA_1[8] =
{
  B00000,
  B00000,
  B00000,
  B00000,
  B00000,
  B00000,
  B11000,
  B11000
};
byte SONRISA_2[8] =
{
  B00000,
  B00000,
  B00000,
  B00000,
  B00000,
  B00000,
  B00011,
  B00011
};
byte SONRISA_3[8] =
{
  B11000,
  B11000,
  B11000,
  B11000,
  B11000,
  B11111,
  B11111,
  B00000
};
byte SONRISA_4[8] =
{
  B00000,
  B00000,
  B00000,
  B00000,
  B00000,
  B11111,
  B11111,
  B00000
};
byte SONRISA_5[8] =
{
  B00000,
  B00000,
  B00000,
  B00000,
  B00000,
  B11111,
  B11111,
  B00000
};
byte SONRISA_6[8] =
{
  B00011,
  B00011,
  B00011,
  B00011,
  B00011,
  B11111,
  B11111,
  B00000
};

 void setup()
{ 
  lcd.begin(16, 4);     
}

 void CARITA_FELIZ()        // usa los caracteres para crear BATMAN
{ 
  lcd.createChar(1,SONRISA_1);
  lcd.createChar(2,OJO_1);
  lcd.createChar(3,OJO_2);
  lcd.createChar(4,SONRISA_2);
  lcd.createChar(5,SONRISA_3);
  lcd.createChar(6,SONRISA_4);
  lcd.createChar(7,SONRISA_5);
  lcd.createChar(8,SONRISA_6);
  
  lcd.setCursor(0, 0); 
  lcd.write(1);  
  lcd.write(2); 
  lcd.write(3);  
  lcd.write(4); 
  lcd.setCursor(0, 1);
  lcd.write(5);  
  lcd.write(6);
  lcd.write(7);  
  lcd.write(8);  
  
  lcd.setCursor(8, 1);
  lcd.print("CARITA FELIZ"); 
}
void loop()
{
  
  CARITA_FELIZ();
  delay(5000);
  lcd.clear();
  
}

 SEGUNDA PROGRAMACIÓN CON NOMBRE DE ESTUDIANTE

¿QUÉ DIFICULTADES TUVO? ¿CÓMO LOGRO SUPERARLAS?
Las dificultades que se presentaron fueron que al inicio el display LCD no encendía incluyendo el hecho de que ya había modificado varias veces el circuito en el fin de que funcionara, sin importar eso, seguía sin funcionar al igual que el potenciómetro, pero éste último dato me permitió darme cuenta que los cables que se enlazaban con las tres patas del potenciómetro se encontraban mal conectados (estaban flojos) por lo que existía una gran intervención en el flujo y control de energía (funcionamiento básico del potenciómetro).
Por otro lado, cabe recalcar que el uso de palabras fundamentales, base para la programación en éste tipo de programas como "int", "void setup", "pinMode", "digitalWrite", "delay", "OUTPUT", "HIGH", "void loop", entre otros ya no fue problema, debido a que lo habíamos repasado mucho en clases anteriores. Aclarado eso, ya no existieron más complicaciones.

CONCLUSIÓN DE CÓMO FUNCIONA EL COMPONENTE TRABAJADO
Un display LCD (Liquid Crystal Display) es un display alfanumérico de matriz de puntos (dot-matrix) que sirve para mostrar mensajes a través de caracteres como letras, números o símbolos. La placa del display viene equipado con un microcontrolador (normalmente el modelo HD44780) que se encarga de generar los caracteres, polarizar la pantalla, desplazar el cursor. Además, también viene equipado con una memoria ROM donde están almacenados los caracteres a través de una matriz de puntos, y una memoria RAM donde se pueden almacenar caracteres creados por nosotros. Estos displays disponen de unos pines para conectar un microcontrolador (en nuestro caso Arduino) para poder dar instrucciones al display.
En el mercado existen displays de distintos tamaño de pantalla. En este tutorial se empleó un display 16×2, que quiere decir que contiene 16 columnas y 2 filas.
Normalmente los displays LCD tienen 16 pins (14 si la pantalla no es retroiluminada). Las funciones de los pins se describen a continuación:
Pins 1-2: Alimentación  +5V
– Pin 3: Voltaje para el contraste de la pantalla +5V. Si pones un potenciómetro puedes regular el contraste.
– Pin 4: RS (Register Select) controla la memoria del display.
– Pin 5: R/W (Read/Write) Selecciona modo escritura o modo lectura.
– Pin 6: Enable. Habilitar o deshabilitar la escritura del display.
– Pins 7-8-9-10-11-12-13-14: Bus de datos de 8 bits.
– Pins 15-16: Habilitar retroiluminación aplicando +5V.
  •  A través de la líbreria de Arduino LiquidCrystal podemos controlar un display LCD con Arduino.

A continuación se explica las funciones básicas:
– LiquidCrystal “nombre_variable” (rs, enable, d0, d1, d2, d3, d4, d5, d6, d7): A través de esta función se crea una variable de tipo LiquidCrystal. Entre paréntesis pondremos los pins del Arduino correspondientes a los pins del display (RS, Enable y los 8 pins de bus de datos). Con esta configuración se usa la totalidad del bus de datos.
– LiquidCrystal “nombre_variable” (rs, enable, d4, d5, d6, d7): Igual que la anterior función pero solo usando 4 bits del bus de datos.
– begin(columnas, filas): Inicializa la interfaz del LCD y establece las dimensiones de la pantalla.
– setCursor(columna, fila): Posicionar el cursor de la pantalla LCD.
– print(“mensaje”): Escribe texto a la pantalla LCD.
– clear(): Limpia la pantalla LCD y posiciona el cursor en la parte superior izquierda.

 DIAGRAMA GUÍA


Comentarios

Publicar un comentario