UNIVERSIDAD TECNOLOGICA DE HONDURAS
Trabajo:
Act2
Clase:
Programación Embebida
Docente:
Ing. Arvin Josel Rodas Aguilar
Alumna:
Emily Dariana Espinoza Gómez
# de cuenta:
202420110262
Choluteca/Honduras
Sistemas de Monitoreo Keep alive
A continuación, se explicará el desarrollo de la práctica para implementar un sistema de
señalización utilizando la función millis() en Arduino.
Se mostrará el procedimiento realizado, el circuito, el código y los resultados obtenidos,
con el objetivo de comprender la diferencia entre la programación síncrona (delay()) y la
programación asíncrona (millis()).
Materiales
Protoboard
Placa Arduino UNO
Cables jumper Resistencia LEDS
• 1 Placa Arduino UNO
• 1 Protoboard
• 1 LEDs
• 1 Resistencias de 220Ω.
• Cables jumper
Montaje
Para realizar la práctica, primero se implementó el circuito en el simulador Tinkercad con
el fin de verificar que las conexiones y el código funcionaran correctamente.
Se conectó el LED a la protoboard, se colocó una resistencia en serie con el terminal
positivo del LED y se realizaron las conexiones correspondientes entre la protoboard y la
placa Arduino mediante cables.
Una vez comprobado el funcionamiento en el simulador, se procedió a realizar el mismo
montaje físico, siguiendo el esquema elaborado en Tinkercad. Se conectó el LED, la
resistencia y los cables exactamente como en la simulación. Finalmente, se conectó el
cable USB desde la computadora al Arduino para alimentar la placa y cargar el programa,
verificando que el sistema funcionara correctamente en el entorno real.
Programación
Codigo Utilizado
//
----------------------------------------------------------------------------
FuncionMillis
---------------------------------------------------------------------------
// Definimos
const int pinLED = 13;
// Variables para el control de tiempo
unsigned long tiempoAnterior = 0;
const long intervalo = 7000; // Intervalo de 1 segundo (1000 ms)
void setup() {
pinMode(pinLED, OUTPUT);
}
void loop() {
unsigned long tiempoActual = millis();
// Al pasar un segundo e realiza el latido
if (tiempoActual - tiempoAnterior >= intervalo) {
tiempoAnterior = tiempoActual;
// El latido: encender
digitalWrite(pinLED, HIGH);
delay(50); // Un pulso corto
digitalWrite(pinLED, LOW);
}
}
//
Se programó la placa Arduino para controlar el LED conectado al pin digital 13 utilizando
la función millis(). Para ello, se definió el pin del LED como salida mediante pinMode()
y se creó una variable para almacenar el tiempo transcurrido desde el último encendido.
En la función loop(), se obtiene continuamente el tiempo actual con millis(). Cuando la
diferencia entre el tiempo actual y el tiempo anterior alcanza el intervalo establecido
(7000 ms o el tiempo que se programe) ,el LED se enciende durante 50 ms y luego se
apaga, simulando un "latido". Finalmente, se actualiza el tiempo anterior para repetir el
proceso de forma.
Aunque la práctica solicitaba un intervalo de 1000 ms (1 segundo), se configuró un
intervalo de 7000(7 segundos) ms debido a la explicación proporcionada por el ingeniero,
quien relacionó ese tiempo con un ritmo de latido más lento similar al comportamiento
de un corazón en una situación crítica. Por esta razón, se utilizó la siguiente
configuración:
const long intervalo = 7000;
Este valor permitió observar un parpadeo más espaciado del LED, simulando el ejemplo
explicado durante el laboratorio.
Preguntas de laboratorio
1. Análisis: ¿Qué ocurre con la sincronización de los LEDs?
Los LEDs se encienden y se apagan siguiendo el intervalo de tiempo programado en el
Arduino mediante la función `millis()`. Esto permite mantener un parpadeo constante y
ordenado, evitando retrasos o adelantos en la ejecución del ciclo.
El comportamiento generado simula una respiración o un latido de corazón, donde cada
encendido representa una pulsación controlada por el tiempo establecido en el programa.
2. ¿Cuál es la función del Keep Alive?
Es un mecanismo encargado de enviar señales periódicas para indicar que un dispositivo
o sistema continúa funcionando correctamente y mantiene activa la comunicación. Su
función principal es evitar que la conexión se cierre por falta de actividad y permitir
verificar que el dispositivo sigue ejecutando su programa de manera normal.
En este ejercicio permite comprobar que la placa Arduino permanece activa y que el
proceso de comunicación o monitoreo continúa funcionando correctamente.
3. Contexto Laboral: ¿Qué pasaría si el Keep Alive de un servidor deja de enviarse?
Si un servidor deja de enviar señales de Keep Alive, los demás equipos o servicios
conectados pueden interpretar que el servidor dejó de funcionar o perdió la comunicación.
Como resultado, las conexiones activas podrían cerrarse, las sesiones de los usuarios
podrían interrumpirse y algunos servicios dejarían de estar disponibles.
En sistemas críticos, esta situación puede activar mecanismos de respaldo, donde otro
servidor asume las funciones del servidor afectado para mantener la continuidad del
servicio y evitar interrupciones prolongadas.