Descubrearduino.com

Construye tu Cronómetro Avanzado con Arduino

por · Publicada · Actualizado

¡Saludos! Estoy aquí para guiarte en la construcción de un cronómetro robusto y funcional utilizando Arduino. Este tutorial ha sido diseñado para proporcionarte una comprensión profunda, desde la selección de componentes hasta la codificación y el ensamblaje, asegurando que puedas llevar a cabo este proyecto con éxito. Combino la información más relevante y precisa de múltiples fuentes para ofrecerte una guía definitiva. Un tutorial completo para diseñar, programar y ensamblar tu propio cronómetro digital preciso.

Puntos Clave del Proyecto

  • Precisión y No Bloqueo: Utiliza la función millis() de Arduino para una medición del tiempo precisa y eficiente, permitiendo que el microcontrolador realice otras tareas simultáneamente, a diferencia de delay().
  • Interfaz Intuitiva: Incorpora una pantalla LCD 16×2 para una visualización clara del tiempo transcurrido y botones dedicados para un control fácil de las funciones de inicio/pausa y reinicio.
  • Componentes Esenciales y Conexiones Claras: Detalla los materiales necesarios y proporciona esquemas de conexión precisos para facilitar el ensamblaje del hardware, incluyendo consideraciones para módulos I2C y resistencias pull-up/pull-down para la estabilidad de los botones.

Conceptos Fundamentales del Cronometraje con Arduino

Para construir un cronómetro confiable con Arduino, es esencial comprender los principios de cómo el microcontrolador gestiona y mide el tiempo. La clave reside en la función millis(), que es el corazón de nuestro cronómetro.

La Función millis(): Medición de Tiempo No Bloqueante

La función millis() de Arduino es fundamental para la creación de un cronómetro. Esta función devuelve el número de milisegundos transcurridos desde que la placa Arduino comenzó a ejecutar el programa actual. A diferencia de delay(), que detiene por completo la ejecución del código, millis() permite que tu programa continúe ejecutándose mientras mide el tiempo. Esto es crucial para un cronómetro, ya que necesitamos leer el estado de los botones y actualizar la pantalla LCD de forma continua sin interrupciones.

Es importante tener en cuenta que el valor de millis() se reinicia a cero después de aproximadamente 50 días. Para la mayoría de las aplicaciones de cronometraje, esto no es un problema, pero para proyectos de larga duración que requieran mantener la hora precisa incluso tras apagados (como un reloj), se recomienda el uso de un Módulo de Reloj de Tiempo Real (RTC) externo, como el DS3231, que ofrece mayor precisión y persistencia.

Librerías Esenciales

Para interactuar con la pantalla LCD, necesitarás una librería específica. Si utilizas una pantalla LCD 16×2 con un módulo I2C (altamente recomendado por su facilidad de conexión, ya que reduce el número de pines necesarios), la librería LiquidCrystal_I2C es la elección correcta. Esta librería simplifica enormemente la comunicación entre el Arduino y la pantalla.

Manejo de Pulsadores y Antirrebote (Debounce)

Los pulsadores son componentes mecánicos que, al ser presionados, no cierran el circuito de forma instantánea y limpia. En su lugar, pueden generar múltiples señales eléctricas rápidas debido a las vibraciones internas, un fenómeno conocido como «rebote». Para que el Arduino interprete una única presión como un único evento, es fundamental implementar una técnica de «antirrebote» (debounce) en el código. Esto se logra mediante un pequeño retardo (por ejemplo, 50 milisegundos) o mediante la verificación del estado del botón en intervalos de tiempo, asegurando que su estado se mantenga estable antes de registrar la pulsación. Además, el uso de resistencias pull-up o pull-down es crucial para asegurar una lectura estable del estado del botón y evitar lecturas «flotantes» que pueden generar errores.

Materiales Necesarios para tu Cronómetro

Para llevar a cabo este proyecto, necesitarás los siguientes componentes. La elección de una pantalla LCD con módulo I2C es altamente recomendada para simplificar el cableado.

Lista de Componentes

  • Placa Arduino UNO o compatible: Es el microcontrolador principal que controlará toda la lógica del cronómetro.
  • Pantalla LCD 16×2 con módulo I2C: Se utilizará para mostrar el tiempo transcurrido. El módulo I2C es altamente recomendable ya que simplifica las conexiones, requiriendo solo 4 pines (VCC, GND, SDA, SCL).
  • 2 Botones Pulsadores (Push Buttons): Uno para iniciar/pausar y otro para reiniciar el cronómetro.
  • Resistencias:
    • Dos resistencias de 10kΩ: Se utilizarán para las conexiones de los botones. Puedes usar configuraciones pull-up internas del Arduino o resistencias externas en configuración pull-down/pull-up.
    • (Opcional) Una resistencia de 220Ω: Si tu LCD no tiene módulo I2C y no tiene luz de fondo incorporada, para la retroiluminación.
  • Protoboard: Para montar el circuito de forma temporal y sin soldaduras, facilitando las conexiones y pruebas.
  • Cables Jumper Macho-Macho: Para realizar todas las conexiones entre los componentes.
  • Cable USB para Arduino: Necesario para conectar el Arduino a tu computadora y cargar el código.

Diagrama de Conexiones (Esquemático)

A continuación, se detalla cómo conectar cada componente a tu placa Arduino. Este esquema se centra en el uso de una pantalla LCD con módulo I2C por su simplicidad de cableado.

Esquema de conexión del cronómetro Arduino

Diagrama de conexiones para el cronómetro con Arduino, LCD I2C y botones.

Conexiones de la Pantalla LCD 16×2 con Módulo I2C

  • VCC: Conectar al pin 5V del Arduino.
  • GND: Conectar al pin GND del Arduino.
  • SDA: Conectar al pin A4 (SDA) del Arduino UNO.
  • SCL: Conectar al pin A5 (SCL) del Arduino UNO.

Nota: Para placas Arduino Mega, los pines SDA y SCL pueden ser el pin 20 y 21 respectivamente.

Conexiones de los Botones Pulsadores

Para los botones, utilizaremos la configuración INPUT_PULLUP en el código de Arduino, lo que elimina la necesidad de resistencias pull-up externas y simplifica el cableado. En esta configuración, el pin estará en estado HIGH (alto) cuando el botón no esté presionado, y pasará a LOW (bajo) cuando se presione (al conectar el pin a GND).

  • Botón de Inicio/Pausa:
    • Un terminal del botón al pin digital 2 del Arduino.
    • El otro terminal del botón a GND.
  • Botón de Reinicio:
    • Un terminal del botón al pin digital 3 del Arduino.
    • El otro terminal del botón a GND.

Asegúrate de que todas las conexiones sean firmes y correctas para evitar problemas durante la operación.

El Cerebro del Cronómetro: Código Arduino Detallado

El código es el corazón de nuestro cronómetro. A continuación, se presenta el código completo, diseñado para ser claro y eficiente. Asegúrate de tener instalado el IDE de Arduino y la librería LiquidCrystal_I2C.

Instalación de la Librería LiquidCrystal_I2C

Si aún no la tienes, sigue estos pasos para instalar la librería:

  1. Abre el Arduino IDE.
  2. Ve a Sketch > Incluir Librería > Administrar Librerías…
  3. En el buscador, escribe «LiquidCrystal I2C».
  4. Busca la librería de Marco Schwartz (o similar) e instálala.

Código Fuente del Cronómetro


#include <Wire.h>
#include <LiquidCrystal_I2C.h>

// Configura la dirección I2C de tu LCD. Es comúnmente 0x27 o 0x3F.
// Si no estás seguro, puedes ejecutar un "escáner I2C" para encontrarla.
LiquidCrystal_I2C lcd(0x27, 16, 2); // Dirección I2C, 16 columnas, 2 filas

// Pines de los pulsadores
const int startPauseButtonPin = 2;
const int resetButtonPin = 3;

// Variables para el cronómetro
unsigned long startTime = 0;      // Almacena el tiempo cuando el cronómetro se inicia o reanuda
unsigned long elapsedTime = 0;    // Almacena el tiempo total transcurrido
bool isRunning = false;           // Estado del cronómetro (true = corriendo, false = pausado)
unsigned long lastButtonPressTime = 0; // Para el anti-rebote (debounce) de los botones
const long debounceDelay = 50;    // Retraso para el anti-rebote en milisegundos

void setup() {
  Serial.begin(9600); // Inicia la comunicación serial para depuración

  // Inicializa la LCD
  lcd.init();
  lcd.backlight(); // Enciende la luz de fondo de la LCD
  lcd.print("Cronometro");
  lcd.setCursor(0, 1);
  lcd.print("00:00:00.000");

  // Configura los pines de los botones como entradas con pull-up interno
  // Esto elimina la necesidad de resistencias externas si usas esta configuración
  pinMode(startPauseButtonPin, INPUT_PULLUP);
  pinMode(resetButtonPin, INPUT_PULLUP);
}

void loop() {
  // Lee el estado de los botones
  int startPauseButtonState = digitalRead(startPauseButtonPin);
  int resetButtonState = digitalRead(resetButtonPin);

  // Anti-rebote para los botones
  // Solo procesa la pulsación si ha pasado suficiente tiempo desde la última
  if ((millis() - lastButtonPressTime) > debounceDelay) {
    // Lógica para el botón de Inicio/Pausa
    if (startPauseButtonState == LOW) { // LOW porque estamos usando INPUT_PULLUP
      if (isRunning) {
        // Pausar el cronómetro: acumula el tiempo transcurrido hasta ahora
        elapsedTime += millis() - startTime;
        isRunning = false;
        Serial.println("Cronometro Pausado");
      } else {
        // Iniciar o reanudar el cronómetro: guarda el tiempo actual como punto de inicio
        startTime = millis();
        isRunning = true;
        Serial.println("Cronometro Iniciado");
      }
      lastButtonPressTime = millis(); // Actualiza el tiempo de la última pulsación
    }

    // Lógica para el botón de Reset
    if (resetButtonState == LOW) { // LOW porque estamos usando INPUT_PULLUP
      elapsedTime = 0;             // Reinicia el tiempo transcurrido
      isRunning = false;           // Detiene el cronómetro
      Serial.println("Cronometro Reiniciado");
      lastButtonPressTime = millis(); // Actualiza el tiempo de la última pulsación
    }
  }

  // Actualizar el tiempo mostrado si el cronómetro está corriendo
  if (isRunning) {
    displayTime(elapsedTime + (millis() - startTime));
  } else {
    // Muestra el tiempo acumulado cuando está pausado/detenido
    displayTime(elapsedTime);
  }
}

// Función para mostrar el tiempo en la LCD
void displayTime(unsigned long ms) {
  // Convierte milisegundos a horas, minutos, segundos y milisegundos
  unsigned long totalSeconds = ms / 1000;
  unsigned int hours = totalSeconds / 3600;
  unsigned int minutes = (totalSeconds % 3600) / 60;
  unsigned int seconds = totalSeconds % 60;
  unsigned int milliseconds = ms % 1000;

  // Formatea la salida para que siempre tenga dos dígitos (o tres para milisegundos)
  char timeBuffer[16]; // Buffer para almacenar la cadena de tiempo
  // sprintf es útil para formatear cadenas de texto
  sprintf(timeBuffer, "%02d:%02d:%02d.%03d", hours, minutes, seconds, milliseconds);

  lcd.setCursor(0, 1); // Posiciona el cursor en la segunda fila, primera columna
  lcd.print(timeBuffer); // Imprime el tiempo
}

Análisis Detallado del Código

El código está estructurado en funciones clave que controlan el cronómetro:

  • Inclusiones de Librerías:
    • #include <Wire.h>: Necesaria para la comunicación I2C.
    • #include <LiquidCrystal_I2C.h>: Permite controlar la pantalla LCD con el módulo I2C.
  • Configuración de la LCD:
    • LiquidCrystal_I2C lcd(0x27, 16, 2);: Inicializa el objeto LCD con la dirección I2C (comúnmente 0x27 o 0x3F), el número de columnas (16) y filas (2).
  • Pines de los Botones:
    • const int startPauseButtonPin = 2; y const int resetButtonPin = 3;: Definen los pines digitales a los que están conectados los botones.
  • Variables del Cronómetro:
    • unsigned long startTime;: Almacena el valor de millis() cuando el cronómetro se inicia o reanuda.
    • unsigned long elapsedTime;: Almacena el tiempo total acumulado, útil para la función de pausa.
    • bool isRunning;: Bandera que indica si el cronómetro está actualmente activo (true) o pausado/detenido (false).
    • unsigned long lastButtonPressTime; y const long debounceDelay;: Variables para implementar el algoritmo de antirrebote de los botones, evitando múltiples lecturas por una sola pulsación.
  • Función setup():
    • Serial.begin(9600);: Inicializa la comunicación serial para depuración, permitiéndote ver mensajes en el Monitor Serial del IDE de Arduino.
    • lcd.init(); y lcd.backlight();: Inicializan la pantalla LCD y encienden su retroiluminación.
    • Configuración de los pines de los botones como INPUT_PULLUP: Esto activa las resistencias pull-up internas del microcontrolador, lo que significa que el pin estará en HIGH por defecto y LOW cuando el botón se presione (conectando el pin a GND).
  • Función loop():
    • Lectura de Botones y Antirrebote: Lee el estado de ambos botones. La condición if ((millis() - lastButtonPressTime) > debounceDelay) asegura que una pulsación solo se registre después de que haya pasado el tiempo de retardo del antirrebote, estabilizando la lectura.
    • Lógica de Inicio/Pausa: Cuando el botón de inicio/pausa se presiona (estado LOW):
      • Si el cronómetro está corriendo (isRunning es true), se pausa, y el tiempo transcurrido desde el último inicio se suma a elapsedTime.
      • Si el cronómetro está pausado (isRunning es false), se inicia o reanuda, y startTime se actualiza con el valor actual de millis().
    • Lógica de Reinicio: Cuando el botón de reinicio se presiona (estado LOW):
      • elapsedTime se pone a cero, y isRunning se establece en false, deteniendo el cronómetro.
    • Actualización del Tiempo: Dependiendo si el cronómetro está corriendo, se calcula el tiempo actual sumando elapsedTime y la diferencia entre millis() y startTime. Este tiempo se pasa a la función displayTime().
  • Función displayTime(unsigned long ms):
    • Toma el tiempo en milisegundos y lo convierte a un formato legible de horas, minutos, segundos y milisegundos.
    • Utiliza sprintf() para formatear la cadena de tiempo, asegurando que los números tengan el formato de dos o tres dígitos (ej., 01, 005) mediante especificadores como %02d y %03d.
    • Finalmente, posiciona el cursor en la LCD y muestra el tiempo formateado.

Pasos para la Implementación y Pruebas

Una vez que tienes los componentes y el código, sigue estos pasos para poner en marcha tu cronómetro.

Ensamblaje del Hardware

  1. Monta los Componentes: Utiliza tu protoboard para conectar la placa Arduino, la pantalla LCD y los botones siguiendo el diagrama de conexiones proporcionado. Presta especial atención a la polaridad (VCC y GND) y a las conexiones SDA/SCL de la LCD.
  2. Verifica Conexiones: Antes de conectar el Arduino a la energía, revisa todas las conexiones. Un error puede dañar los componentes. Si tienes un multímetro, puedes verificar la continuidad y la ausencia de cortocircuitos entre VCC y GND.

Preparación y Carga del Código

  1. Abre el IDE de Arduino: Si aún no lo has hecho, descarga e instala el Arduino IDE desde el sitio web oficial de Arduino.
  2. Selecciona tu Placa y Puerto: En el IDE, ve a Herramientas > Placa y selecciona «Arduino Uno». Luego, ve a Herramientas > Puerto y elige el puerto serial al que tu Arduino está conectado (generalmente tendrá un nombre como «COMx» en Windows o «/dev/tty.usbmodem» en macOS/Linux).
  3. Copia el Código: Pega el código completo proporcionado anteriormente en una nueva ventana del IDE de Arduino.
  4. Compila el Código: Haz clic en el botón «Verificar» (el icono de la marca de verificación) para compilar el código. Esto comprobará si hay errores de sintaxis. Si todo está correcto, verás un mensaje de «Compilación terminada» en la barra de estado inferior.
  5. Carga el Código: Haz clic en el botón «Subir» (el icono de la flecha hacia la derecha) para cargar el código a tu placa Arduino. Verás LEDs parpadeando en tu Arduino mientras se sube el programa. Una vez finalizado, aparecerá el mensaje «Subido» en el IDE.

Prueba y Depuración

  1. Inicialización: Una vez que el código se haya cargado, la pantalla LCD debería mostrar «Cronometro» en la primera línea y «00:00:00.000» en la segunda.
  2. Funcionamiento de Inicio/Pausa:
    • Presiona el botón de inicio/pausa. El tiempo debería comenzar a correr en la LCD.
    • Vuelve a presionarlo. El cronómetro debería pausarse y el tiempo detenerse. Si lo presionas de nuevo, debería reanudar el conteo desde donde lo dejaste.
  3. Funcionamiento de Reinicio:
    • Presiona el botón de reinicio. El cronómetro debería detenerse y el tiempo volver a «00:00:00.000».
  4. Depuración con Monitor Serial: Si algo no funciona como esperas, abre el Monitor Serial del Arduino IDE (Herramientas > Monitor Serial). Asegúrate de que la velocidad de baudios esté configurada en 9600. Verás los mensajes de depuración como «Cronometro Iniciado», «Cronometro Pausado», y «Cronometro Reiniciado», lo que te ayudará a identificar dónde podría estar el problema.

Consideraciones Adicionales y Mejoras

Una vez que tu cronómetro básico esté funcionando, puedes explorar varias mejoras para añadir funcionalidades o aumentar su precisión.

Precisión y Persistencia del Tiempo

Aunque millis() es excelente para cronometrajes no bloqueantes, no es un reloj de tiempo real. Para aplicaciones que requieren mantener la hora precisa incluso después de apagar el Arduino o para una precisión extrema a largo plazo (por ejemplo, más de 50 días), considera:

  • Módulo RTC (Real-Time Clock) como DS3231: Este módulo tiene su propio oscilador de cristal y una batería de respaldo, lo que le permite mantener la hora y fecha exactas incluso cuando el Arduino está apagado. Es ideal para cronómetros que también funcionan como relojes o para registro de tiempos a largo plazo.
  • Oscilador de Cuarzo Externo: Para una precisión aún mayor en el cronometraje de eventos muy cortos (microsegundos), se puede utilizar un oscilador de cuarzo externo de alta precisión o los temporizadores internos del microcontrolador en modos avanzados (como Input Capture).

Funcionalidades Extendidas

Tu cronómetro puede ser la base para proyectos más complejos:

  • Registro de Tiempos Parciales/Vueltas: Añade un tercer botón o modifica la lógica del botón de inicio/pausa para que, en lugar de pausar, registre un tiempo parcial en la pantalla o en el Monitor Serial.
  • Almacenamiento de Datos: Para guardar récords o una secuencia de tiempos, puedes integrar:
    • EEPROM: La memoria EEPROM interna del Arduino puede almacenar pequeñas cantidades de datos de forma no volátil.
    • Módulo de Tarjeta SD: Para almacenar grandes volúmenes de datos, un módulo de tarjeta SD es una excelente opción.
  • Activación por Sensores: En lugar de botones manuales, puedes usar sensores para iniciar o detener el cronómetro automáticamente:
    • Sensores de Barrera Infrarroja o Fotoeléctricos: Ideales para cronometrar eventos como carreras, detectando el paso de un objeto.
    • Sensores de Proximidad: Para activar o desactivar el cronómetro al acercar o alejar un objeto.
  • Notificaciones:
    • Buzzer/Zumbador: Para emitir una señal audible al iniciar, pausar, reiniciar o al llegar a un tiempo predefinido.
    • LEDs Indicadores: Un LED puede indicar si el cronómetro está corriendo o pausado.

Alternativas de Visualización

Aunque la LCD 16×2 es versátil, existen otras opciones para mostrar el tiempo:

  • Displays de 7 Segmentos: Ideales para números grandes y visibles a distancia. Requieren más pines o un controlador (como el MAX7219 o TM1637).
  • Pantallas OLED Gráficas: Ofrecen mayor flexibilidad para mostrar gráficos, iconos y texto personalizado, aunque suelen ser más pequeñas.
  • Pantallas TFT/LCD Gráficas: Para proyectos más avanzados que requieran interfaces de usuario ricas y visualmente atractivas.

Tabla de Comparación de Métodos de Cronometraje

Comprender las diferencias entre los métodos de cronometraje en Arduino es crucial para elegir la solución adecuada para tu proyecto.

Método Descripción Ventajas Desventajas Aplicaciones Típicas
millis() Función interna de Arduino que cuenta los milisegundos desde el inicio del programa. No bloquea la ejecución. Fácil de usar. No requiere hardware adicional. * Permite código no bloqueante. Precisión limitada del oscilador interno del Arduino. Se reinicia después de ~50 días. * No mantiene el tiempo si el Arduino se apaga. Cronómetros básicos, temporizadores de eventos cortos, control de tareas periódicas.
Módulo RTC (ej. DS3231) Dispositivo externo con su propio cristal y batería para mantener la hora y fecha exactas. Alta precisión. Mantiene el tiempo incluso sin energía del Arduino. * Proporciona fecha y hora completas. Requiere hardware adicional y cableado I2C. Necesita batería de respaldo. Relojes, sistemas de registro de datos con marca de tiempo, temporizadores de larga duración.
delay() Función que pausa la ejecución del programa por un número específico de milisegundos. * Extremadamente simple de usar para pausas fijas. Bloquea completamente el microcontrolador. No permite otras operaciones durante la pausa. Parpadeo de LEDs, pausas muy cortas donde no se necesita interactividad (uso limitado en cronómetros).
Timers/Temporizadores Internos Módulos de hardware dentro del microcontrolador que pueden generar interrupciones a intervalos precisos. Muy alta precisión (hasta microsegundos). Permite programación basada en interrupciones (no bloqueante). * Control a bajo nivel del hardware. Más complejo de programar (uso de registros). Puede requerir librerías específicas. Medición de alta frecuencia, generación de PWM precisa, control de motores paso a paso.

Video Explicativo: Cronómetro Arduino con Botones

Para complementar este tutorial, te recomiendo ver el siguiente video. Demuestra visualmente cómo funciona un cronómetro básico con Arduino, utilizando botones de inicio y parada, lo que te ayudará a comprender mejor la implementación práctica de lo que hemos cubierto.

Este video «Cronometro Arduino con botones de inicio y parada (Tutorial)» es altamente relevante porque presenta de manera práctica la construcción de un cronómetro similar al que hemos descrito. Muestra las conexiones físicas y el comportamiento esperado del cronómetro en acción, ofreciendo una perspectiva visual invaluable que refuerza los conceptos teóricos y el código proporcionado. Es un excelente recurso para consolidar tu aprendizaje y ver el proyecto en funcionamiento.

Preguntas Frecuentes

¿Puedo usar mi Arduino Nano o Mega en lugar de un UNO?

Sí, el código y los principios son los mismos. Solo asegúrate de verificar los pines SDA y SCL si usas una LCD I2C, ya que pueden variar en el Mega (pines 20 y 21, por ejemplo). Los pines digitales para los botones (2 y 3) son comunes en la mayoría de las placas Arduino.

¿Por qué mi cronómetro no se detiene o reinicia correctamente?

Esto suele ser un problema de «rebote» de los botones. Asegúrate de que la implementación del antirrebote en el código esté funcionando correctamente (la variable debounceDelay y la lógica de lastButtonPressTime). También verifica tus conexiones físicas; un cable suelto o una resistencia mal conectada pueden causar lecturas erróneas.

¿Cómo puedo mostrar milisegundos en la LCD?

El código proporcionado ya muestra milisegundos con tres dígitos (por ejemplo, «00:00:00.000»). La función displayTime() se encarga de formatear la cadena utilizando sprintf con el especificador %03d para los milisegundos.

¿Cómo puedo hacer que el cronómetro sea más preciso?

Para mayor precisión, especialmente en periodos largos o para aplicaciones críticas, considera añadir un módulo RTC (Real-Time Clock) como el DS3231. Los RTC tienen su propio cristal de cuarzo y batería, lo que les permite mantener una hora muy precisa independientemente del Arduino. Para mediciones a microsegundos en eventos muy cortos, podrías investigar el uso de los temporizadores internos del microcontrolador de Arduino.

¿Es posible agregar una función de «pausa» en lugar de solo «inicio/parada»?

Sí, el código ya implementa una función de inicio/pausa. El botón startPauseButtonPin alterna entre iniciar el cronómetro y pausarlo. Cuando se pausa, el tiempo transcurrido hasta ese momento se acumula en elapsedTime, lo que permite reanudar desde el punto donde se detuvo.

Conclusión

Has completado un proyecto fundamental en el mundo de Arduino: un cronómetro digital preciso y funcional. Este proyecto no solo te ha familiarizado con el uso de la función millis() para el cronometraje no bloqueante, sino que también te ha introducido al manejo de pantallas LCD, la interacción con botones y la importancia del antirrebote. La capacidad de controlar el tiempo de manera precisa es una habilidad invaluable en la electrónica y la programación embebida.

Este cronómetro es solo el punto de partida. Las habilidades y conocimientos adquiridos aquí te servirán como una base sólida para explorar proyectos más complejos y ambiciosos. ¡La experimentación es la clave para seguir aprendiendo y creando en el fascinante universo de Arduino!

Pin It on Pinterest

Shares