Prácticas de Equipos Microprogramables.

Programación TIMER.

PRÁCTICA 01: Realización de un reloj visible en display LCD

ALUMNO: DOMINGO DEL RIO BERNAL

INTRODUCCIÓN
Descripción de qué se va a realizar, objetivos y materiales

Realización de un reloj en el que se visualice, los caracteres tipo, de un reloj digital,

sobre una pantalla LCD, del formato 16 x 2. En ella se plasmará solo las horas y
minutos. También se verá este formato de horas, en el monitor serie del interfaz IDE
del Arduino.
En mi caso lo realizare, tanto sobre una placa real, como también lo simulare sobre el
Proteus. Se realizará un código, en lenguaje C++, para compilar, y subirle al
microcontrolador ATmega 328P, que tiene las placas de Arduino uno.

Material empleado:
 Computadora, con el software, de la interfaz de Arduino, Proteus para la
simulación, más las correspondientes librerías y complementos para realizar la
simulación.
 Placa Arduino, cables varios, pila de 9v, con su cable para alimentación.
 Pantalla LCD del tipo 16 x 2, (2 líneas, 16 caracteres de largo) o compatibles a
estas. Están basadas en los chipsets Hitachi HD44780 (o similares); tienen dos
formas de conectarlas, en configuraciones de 4bits (2 mensajes) y 8bits (1
mensaje; utiliza más pines), es comunicación del tipo paralela.
Sus pines son:
 LCD 1 (0v) a masa.
 LCD 2 (5V) A +5V.
 LCD 3 (V0) contraste de la LCD, potenciómetro entre +5v y masa.
 LCD 4 (RS) Selección de Registro.
 LCD 5 (R/W) Lectura/Escritura.
 LCD 6 (E) Enable.
 LCD 7 (D0) Bit de datos menos significativo.
 LCD 8 (D1) Bit de datos.
 LCD 9 (D2) Bit de datos.
 LCD 10 (D3) Bit de datos.
 LCD 11 (D4) Bit de datos.
 LCD 12 (D5) Bit de datos.
 LCD 13 (D6) Bit de datos.
 LCD 14 (D7) Bit de datos más significativo.
 LCD 15 (Anodo Led).
 LCD 16 (Katodo Led), estos últimos dan a la LCD, Retroiluminación (luz
de fondo.
DESARROLLO / PROCESO
Descripción de qué y cómo se ha realizado (pasos). Añadir contenido teórico, esquemas, capturas de
pantalla, características o funcionamiento de la práctica o equipos

Desarrollo del código de programación; encabezamos con la librería LiquidCrystal.h.

Configuramos los pines del LCD para su conexionado sobre los de nuestra placa
Arduino: 7=RS, 6=Enable; son los bits de control. Pines de Arduino; 5=D4, 4=D5, 3=D6,
2=D7, (Bits de Datos) y tipo de 4bits.
Declaramos las variables, u_hora, d_hora, u_minuto, d_minuto y segundo.
Pasamos al setup(), donde se configura el hardware que se utiliza:
Serial.begin(9600), establece la velocidad de comunicación de datos, para la transmisión
de estos con la computadora serie, y con ello vemos los datos en el monitor serie.
lcd.begin(16, 2); comunica y configura las filas y columnas de la LCD. Lcd.clear(), limpia
de datos la LCD. Ahora pasamos loop(), al bucle o ciclo, el cual se ejecuta de forma
perpetua, con tasas de repetición cercanas a la velocidad de la placa, dependiendo de
las instrucciones que tenga que ejecutar.
Primero, iniciamos con un conteo de segundo “segundo++”, y teniendo en mente la
lógica de un reloj, minuto = 59 segundos, hora = 59 minutos, aplicamos if, junto con
los operadores de comparación, aritméticos y compuestos. Limitamos unidades a 10,
decenas a 60, y las horas a 24.
Seguidamente, con lcd.SetCursor(1, 0); definimos que nos escriba en la fíla 1(0 lógico),
las palabras entre comillas “RELOJ DOMINGO”; podía ser otras palabras, siempre entre
comillas. Otra vez con lcd.SetCursor(3, 1); escribimos en la columna 3 (0,1,2,3) y fíla 2
(1 lógico), las horas y minutos, en sus unidades y decenas. Utilizamos el lcd.print(), para
escribir los datos a visualizar.
Y seguidamente, con los comandos Serial.print(), y entre los paréntesis, escribimos
horas, minutos y porque no segundos. Y con una llave de cierre terminanos este
código.
Interfaz Hardware LCD driver HD44780 o compatible.
Pantallazo de la simulación con Proteus, y visualización del Monitor Serie,
Pines 1,2,3 se conectarán tal se explicó, más arriba.
Foto del código corriendo sobre una placa Arduino.
CONCLUSIÓN / OBSERVACIONES
Conclusiones finales, indicando qué se ha aprendido, problemas y dificultades encontradas durante
el desarrollo y sus soluciones, etc.

Desde luego, la forma de emplear los comandos, funciones, y demás del lenguaje de
programación. Ver cómo puede llegar a ser de extenso, solo la visualización de un
reloj,
sobre una LCD y una placa de Arduino. Me es cada vez más grato, trabajar la
simulación de PROTEUS y como se realizan simulaciones, como los RTC, relojes en
tiempo real, con los módulos visibles de estos y sus códigos. Solo citar la cantidad de
www visitadas y códigos vistos; y simulaciones realizadas. Y desde luego que
PROTEUS, me facilito todas las dificultades, tediosas de ver que los códigos corren
bienes, en su ejecución.

CÓDIGO:

#include <LiquidCrystal.h>
LiquidCrystal lcd(7, 6, 5, 4, 3, 2); //Configuramos los pines 7=RS 6=E
5,4,3,2=pines de control

int u_hora=0; // variable "u_hora"

int d_hora=0; // variable "d_hora"
int u_minuto=0; // variable "u_minuto"
int d_minuto=0; // variable "d_minuto"
int segundo=0; // variable "segundo"

void setup() {
Serial.begin(9600);
lcd.begin(16, 2); //Configuramos las filas y las columnas del LCD
lcd.clear();

void loop() {

segundo++;
delay(1000);
if (segundo > 59)
{
u_minuto ++;
segundo = 0;
}
//segundo
// minuto

if ( u_minuto == 10 )
{
u_minuto =0;
d_minuto++;
}

if ( ( d_minuto == 6 ) && ( u_minuto == 0 ) )

{
d_minuto =0;
u_hora++;
}

// hora

if ( u_hora == 10 ) {
u_hora =0;
d_hora++;
}

if ( (d_hora == 2) && (u_hora == 4) ) {

u_hora =0;
d_hora =0;
}
lcd.setCursor(1,0); //Situa el cursor en la segunda posición de la primera línea
lcd.print("Reloj DOMINGO"); //Escribe el texto entre comillas
lcd.setCursor(3, 1); //Situa el cursor en la cuarta posición de la segunda línea
lcd.print(d_hora); //Escribe la cantidad almacenada en la variable d_hora
lcd.print(u_hora); //Escribe la cantidad almacenada en la variable u_hora
lcd.print(":"); //Escribe el texto entre comillas
lcd.print(d_minuto); //Escribe la cantidad almacenada en la variable d_minuto
lcd.print(u_minuto); //Escribe la cantidad almacenada en la variable u_minuto

Serial.print(d_hora); //Escribe la cantidad de la variable d_hora

Serial.print(u_hora); //Escribe la cantidad de la variable u_hora
Serial.print(":"); //Escribe el texto entre comillas
Serial.print(d_minuto); //Escribe la cantidad de la variable d_minuto
Serial.println(u_minuto); //Escribe la cantidad de la variable u_minuto
Serial.print(":");
if(segundo<10) Serial.print("0");
Serial.println(segundo);