LABORATORIO 2 SISTEMAS DIGITALES II

Diego Cabrera Pineda(67602)1 Carlos Pereira Sanchez(62695)2 Deiby Reyes Sandoval(62033)3

Abstract— This document presents the implementation of Codigo:

the first lab exercise in Digital Systems II. It meets the
criteria set by the instructor and aims to revisit fundamental #include "mbed.h"
concepts of digital electronics. The STM32 development board
is employed, along with programming languages suited for // Definición de pines para comunicación
embedded systems, to accomplish this task. con el display y control de señales
BusOut DATOS(PC_0, PC_3, PF_3, PF_5, PF_10,
I. INTRODUCCION PF_2, PF_1, PF_0);
En este informe se detalla la ejecución de un reloj digital DigitalOut ENABLES (PG_3);
exhibido en una pantalla LCD 16x2, con la ejecución central DigitalOut RS (PG_2);
fundamentada en la programación basada en interrupciones
ticker. La implementación del reloj se realiza a través de la
B. INICIALIZACION LCD
plataforma Mbed, haciendo uso crucial de los tickers para
generar interrupciones temporales a intervalos precisos. Esta Se incluyen las funciones para el funcionamiento de la
estrategia posibilita una actualización periódica y precisa de LCD como es la funcion INICIALIZAR, y para la escritura
la hora minutos segundo y milisegundos que se mostraran en la LCD saber posicion y contenido que es RI y RD.
en la pantalla LCD.
Codigo:

II. METODOLOGIA void INICIALIZAR(void)

{
Para poder realizar la practica se necesito la NUCLEO
ThisThread::sleep_for(50ms);
F767ZI, una LCD 16X2, resistencias 220, jumpers,
R_I(0b00110000);
pulsadores de 3 o 4 patas, eñ entorno de trabajo MBED
para hacer el codigo en lenguaje C.
ThisThread::sleep_for(25ms);
R_I(0b00110000);

ThisThread::sleep_for(1ms);
R_I(0b00110000);

R_I(0b00111000);
R_I(0b00001111);
R_I(0b00000001);
}

void R_D(uint8_t CARACTER)

Fig. 1. Montaje {
RS = 1;
ENABLES = 0;
A. CONFIGURACION LCD Y STM DATOS = CARACTER;
Se requiren establecer las diferentes conexiones entre la
LCD y la STM, se configuraran los pines de salida de datos ENABLES = 1;
”BusOut” a los cuales se le asignaran cada uno de los pines ThisThread::sleep_for(1ms);
de entrada de la LCD segun sea necesario, es importante ENABLES = 0;
destacar que la pantalla LCD 16x2 está equipada con ocho ThisThread::sleep_for(2ms);
pines de entrada de datos, además de dos pines RD y RI, }
junto con un pin de habilitación (”enable”), estos pines de
entrada de la LCD seran conectados a los pines de salida void R_I(uint8_t COMANDO)
”BusOut” de la STM para resivir los datos. {
RS = 0;
 ENABLES = 0; SEGMEN = 1;
DATOS = COMANDO; }

ENABLES = 1;
ThisThread::sleep_for(1ms); D. FUNCION INTER
ENABLES = 0; Se realiza esta funcion se encarga de gestionar los ajustes
ThisThread::sleep_for(2ms); de tiempo basados en las pulsaciones de los botones. Utiliza
} una serie de condicionales para determinar qué botón
ha sido presionado (HORAMA, MINUMA, SEGMAS,
C. CONFIGURACION PULSADORES
HORAME, MINUME, SEGMEN) y realiza las acciones
Se crean las variables de las interrupciones para aumentar correspondientes. El mecanismo de antirrebote se utiliza
y disminuir tanto de horas, minutos y segundos. Primero para evitar ajustes rápidos y múltiples. Por ejemplo, si el
debemos colocar las interrupciones cuando iniciamos el botón de aumento de horas (HORAMA) ha sido presionado,
codigo esto quiere decir que cada interrupciones tiene una verifica si se puede incrementar la hora actual sin exceder
funcion a la cual entrar al momento de que se active la 24. Si es posible, deshabilita las interrupciones del botón,
interrupcion. Se configura un pulsador en modo pull-up, pausa durante un corto perı́odo para evitar cambios rápidos
donde el pin se mantiene en estado alto (1),cuando el y luego actualiza la hora. Luego, vuelve a habilitar las
pulsador se presiona, el pin cambia a estado bajo (0), interrupciones y establece un temporizador de antirrebote
generando una interrupción. para ignorar pulsaciones adicionales durante un tiempo
especı́fico.
Codigo:
Codigo:
[Link](PullUp);
[Link](callback(&SUBIRHORA)); {
[Link](PullUp); if (HORAMA == 1)
[Link](callback(&SUBIRMINUTO)); {
[Link](PullUp); if (H < 24)
[Link](callback(&SUBIRSEGUNDO)); {
[Link](PullUp); HORASMAS.disable_irq();
[Link](callback(&BAJARHORA));
[Link](PullUp); ThisThread::sleep_for(150ms);
[Link](callback(&BAJARMINUTO)); H++;
[Link](PullUp); HORAMA = 0;
[Link](callback(&BAJARSEGUNDO));
---------------------------- // Habilitar la interrupción nuevament
void SUBIRHORA() HORASMAS.enable_irq();
{ }
HORAMA = 1; if (H >= 24)
} {
void SUBIRMINUTO() H = 0;
{ }
MINUMA = 1; }
} if (MINUMA == 1)
void SUBIRSEGUNDO() {
{ if (M < 60)
SEGMAS = 1; {
} MINUTOSMAS.disable_irq();
void BAJARHORA() ThisThread::sleep_for(150ms);
{ M++;
HORAME = 1; MINUMA = 0;
} MINUTOSMAS.enable_irq();
void BAJARMINUTO() }
{ if (M >= 60)
MINUME = 1; {
} H++;
void BAJARSEGUNDO() M = 0;
{ }
 } dı́gitos ASCII correspondientes para mostrarlos en la
if (SEGMAS == 1) pantalla. Cada componente temporal se presenta en su
{ propia sección en la pantalla LCD, formateado como
if (S < 60) MM:SS:HH, donde MM representa los minutos, SS los
{ segundos y HH las horas. La función utiliza comandos de
SEGUNDOSMAS.disable_irq(); la pantalla LCD para posicionar y mostrar los dı́gitos en
ThisThread::sleep_for(150ms); sus respectivas secciones. En resumen, la función LCDS
S++; traduce las variables de tiempo en dı́gitos ASCII legibles
SEGMAS = 0; para la pantalla LCD, actualizando la pantalla con la hora
SEGUNDOSMAS.enable_irq(); actualizada.
}
if (S >= 60) Codigo:
{
M++; void LCDS(void)
S = 0; {
} int UDS, US, UM, DM, DH, UH;
}
if (HORAME == 1)
{ // DECIMAS DE SEGUNDO
if (H > 0) UDS = (DS % 10) + 48;
{ R_I(203);// posicion
HORASMENOS.disable_irq(); R_D(UDS);// Dato
ThisThread::sleep_for(150ms);
H--; // SEGUNDOS
HORAME = 0; US = (S / 10) + 48; // unidades de segundos
HORASMENOS.enable_irq(); DS = (S % 10) + 48; // decimas de segundos
} R_I(200);
} R_D(US);
if (MINUME == 1) R_D(DS);
{ R_I(196);
if (M > 0) R_D(’:’);
{
MINUTOSMENOS.disable_irq(); // MINUTOS
ThisThread::sleep_for(150ms); UM = (M / 10) + 48;
M--; DM = (M % 10) + 48;
MINUME = 0; R_I(197);
MINUTOSMENOS.enable_irq(); R_D(UM);
} R_D(DM);
} R_I(199);
if (SEGMEN == 1) R_D(’:’);
{
if (S > 0) // HORAS
{ UH = (H / 10) + 48;
SEGUNDOSMENOS.disable_irq(); DH = (H % 10) + 48;
ThisThread::sleep_for(150ms); R_I(194);
S--; R_D(UH);
SEGMEN = 0; R_D(DH);
SEGUNDOSMENOS.enable_irq(); R_I(202);
} R_D(’:’);
} }
}
F. FUNCIONAMIENTO RELOJ
La funcion RELOJDIGITAL que ocupara todo el sistema
E. FUNCION LCDS de aumento e iterrupciones se ubicara dentro de un while
Esta función se encarga de actualizar la pantalla LCD para que esta se este ejecutando en bucle
con la hora actualizada. Divide la hora en décimas de Se inicia con el incremento de la variable DS, que repre-
segundo, segundos, minutos y horas, y los convierte en senta las décimas de segundo, mediante la instrucción DS++.
Este incremento ocurre durante un intervalo de 100 ms. A {
continuación, se emplea una estructura condicional ”if” para H++;
verificar si se han acumulado 10 décimas de segundo. En M = 0;
caso afirmativo, se incrementa la variable de segundos (S++)
y la variable DS vuelve a 0. if (H >= 24)
Adicionalmente, se incorpora otra condición ”if” para {
comprobar si los segundos han llegado a 59. En tal caso, H = 0;
se incrementa la variable de minutos (M) y la variable de }
segundos se reinicia a 0. Se continúa con una evaluación }
similar para los minutos, donde si estos alcanzan los 59 }
minutos, se incrementa la variable de horas (H) y la variable }
de minutos se resetea a 0. }
Al final del proceso, se aborda la variable de horas. Si
III. CONCLUSIONES
esta variable llega a 24 horas, se establece que regrese a 0,
permitiendo ası́ el ciclo continuo del reloj. Esta secuencia A través de la programación y el análisis de este código,
de instrucciones define el núcleo del funcionamiento del se aprenden conceptos esenciales como el uso de pines
reloj, implementando un mecanismo lógico que maneja la digitales, configuración de interrupciones, operaciones
actualización de las décimas de segundo, segundos, minutos con variables volátiles, manipulación de valores ASCII
y horas de manera coherente, asegurando una medición y para mostrar información y la implementación de tem-
visualización precisa del tiempo. porizadores para controlar eventos como el antirrebote.
Estas habilidades son fundamentales para la progra-
mación embebida y la electrónica digital. este labo-
ratorio ofrece una experiencia práctica en la progra-
mación de microcontroladores para gestionar el tiempo
y la interacción con componentes externos, destacando
conceptos clave como interrupciones, antirrebote y vi-
sualización de datos en una pantalla LCD

Fig. 2. Montaje2

Codigo:
void RELOJDIGI(void)
{
DS++;
ThisThread::sleep_for(500ms);

LCDS();

if (DS >= 9)
{
S++;
DS = 0;
INTER();

if (S >= 60)
{
M++;
S = 0;

if (M >= 60)