2026

marzo 20, 2026 , ,

Sistema de Aparcamiento Automático

Proyecto Arduino

Después de dominar los fundamentos de la electrónica, es hora de poner a prueba tus conocimientos con un proyecto emocionante y práctico: un Sistema Automático de Estacionamiento (Car Parking System) controlado por una placa Arduino.

Este video de Simple Circuits te muestra, paso a paso y en acción, cómo integrar varios componentes clave de la electrónica para crear un sistema funcional que detecta la llegada de un vehículo y gestiona el acceso a una barrera. Es un excelente ejemplo de cómo la programación y el hardware se unen para resolver problemas cotidianos.

En el video verás la integración de:

  • Sensores IR: Para detectar la presencia y la distancia del "coche".
  • Servomotores: Para actuar como la barrera de acceso.
  • Módulo LED o Pantalla: Para indicar el estado (acceso permitido, estacionamiento lleno, etc.).
  • La placa Arduino: El cerebro que procesa las señales de los sensores y controla los actuadores (servomotores).

¡Mira cómo se ensambla el hardware y se prueba el código que da vida a este sistema de parking inteligente!


Materiales necesarios:

  • Arduino UNO
  • Cables Jumper
  • Protoboard
  • Pantalla LCD con módulo I2C
  • Servomotor
  • Sensor Infrarrojo (IR)

Diagrama de circuito:



Diagrama de maqueta:



Código Arduino:

// Created by Simple Circuits
#include <Wire.h>
#include <LiquidCrystal_I2C.h>        //Incluir libreria by Frank de Brabander
LiquidCrystal_I2C lcd(0x27, 16, 2);
#include <Servo.h>
Servo myservo;

int IR1 = 2;
int IR2 = 3;
int Slot = 4;  //Total number of parking Slots
int flag1 = 0;
int flag2 = 0;

void setup() {
  Serial.begin(9600);
  lcd.init();       //initialize the lcd
  lcd.backlight();  //open the backlight

  pinMode(IR1, INPUT);
  pinMode(IR2, INPUT);

  myservo.attach(4);
  myservo.write(110);

  lcd.setCursor(0, 0);
  lcd.print("     ARDUINO    ");
  lcd.setCursor(0, 1);
  lcd.print(" PARKING SYSTEM ");
  delay(2000);
  lcd.clear();
}

void loop() {

  if (digitalRead(IR1) == LOW && flag1 == 0) {

    if (Slot > 0) {
      flag1 = 1;

      if (flag2 == 0) {
        myservo.write(0);
        Slot = Slot - 1;
      }
    } else {
      lcd.setCursor(0, 0);

      lcd.print("    SORRY :(    ");
      lcd.setCursor(0, 1);
      lcd.print("  Parking Full  ");
      delay(3000);
      lcd.clear();
    }
  }

  if (digitalRead(IR2) == LOW && flag2 == 0) {
    flag2 = 1;

    if (flag1 == 0) {
      myservo.write(0);
      Slot = Slot + 1;
    }
  }

  if (flag1 == 1 && flag2 == 1) {
    delay(1000);
    myservo.write(110);
    flag1 = 0, flag2 = 0;
  }

  lcd.setCursor(0, 0);
  lcd.print("    WELCOME!    ");
  lcd.setCursor(0, 1);
  lcd.print("Slot Left: ");
  lcd.print(Slot);
}


En este proyecto aprenderás a construir un tacho de basura automático usando Arduino Uno, un sensor ultrasónico HC-SR04 y un servomotor. La idea es que la tapa se abra sola cuando alguien se acerque al sensor y se cierre nuevamente después de unos segundos.

Este tipo de práctica es excelente para estudiantes porque combina sensores, movimiento y automatización en un proyecto útil y llamativo.

🎯 Objetivo

Detectar la cercanía de alguien o algo con un sensor ultrasónico y abrir automáticamente la tapa de un tacho mediante un servomotor.

📡 ¿Qué es un sensor ultrasónico HC-SR04?

El sensor ultrasónico HC-SR04 es un dispositivo que permite medir distancias sin contacto. Funciona enviando ondas de sonido que rebotan en un objeto y regresan al sensor, permitiendo calcular qué tan lejos se encuentra.

En Arduino, se usa comúnmente para detectar la cercanía de objetos, como en proyectos de automatización, robots o sistemas como el tacho de basura automático.

🧠 ¿Cómo funciona el proyecto?

El sistema mide la distancia con el sensor ultrasónico. Cuando detecta un objeto a una distancia corta, Arduino interpreta que alguien quiere usar el tacho y envía una señal al servomotor para abrir la tapa.

Después de unos segundos, si ya no detecta cercanía, el servomotor regresa a la posición inicial y la tapa se cierra.


🛠️ Materiales

    • 1 Arduino Uno
    • 1 sensor ultrasónico HC-SR04
    • 1 servomotor
    • Cables de conexión
    • Protoboard opcional
    • Tacho de basura con tapa abatible

🔌 Conexión

Sensor ultrasónico HC-SR04

    • VCC → 5V
    • GND → GND
    • TRIG → Pin 9
    • ECHO → Pin 10

Servomotor

    • Rojo → 5V
    • Marrón o negro → GND
    • Naranja o amarillo → Pin 6


💻 Código Arduino

#include <Servo.h>

Servo tapa;

const int trigPin = 9;
const int echoPin = 10;
const int servoPin = 6;

long duracion;
int distancia;

void setup() {
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
  tapa.attach(servoPin);
  tapa.write(0);
  Serial.begin(9600);
}

void loop() {
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);

  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  duracion = pulseIn(echoPin, HIGH);
  distancia = duracion * 0.034 / 2;

  Serial.print("Distancia: ");
  Serial.print(distancia);
  Serial.println(" cm");

  if (distancia > 0 && distancia <= 15) {
    tapa.write(90);
    delay(3000);
  } else {
    tapa.write(0);
  }

  delay(200);
}


📖 Explicación del código

    • Servo.h permite controlar el servomotor
    • el sensor ultrasónico mide la distancia del objeto cercano
    • si la distancia es menor o igual a 15 cm, la tapa se abre
    • el servomotor gira a 90 grados
    • después de un tiempo, si no hay nadie cerca, la tapa vuelve a cerrarse

De esta manera, el tacho funciona de forma automática y sin contacto.

🚀 Posibles mejoras

Puedes mejorar este proyecto de varias formas:

    • agregar un buzzer al abrir la tapa
    • colocar un LED indicador
    • mostrar la distancia en el Monitor Serial
    • usar una pantalla LCD para mostrar mensajes
    • añadir un segundo sensor para detectar nivel de llenado

⚠️ Errores comunes

❌ Conectar mal los pines TRIG y ECHO

❌ No unir GND de todos los componentes

❌ Esperar que el servo se mueva si no tiene alimentación correcta

❌ Usar un ángulo de apertura demasiado pequeño

❌ Colocar el sensor en una posición que no detecte bien a la persona

✅ Conclusión

Este proyecto de tacho de basura automático es una excelente aplicación de Arduino en automatización básica. Permite integrar detección de proximidad y control de movimiento en una maqueta útil y atractiva para el aula.

Además, ayuda a los estudiantes a comprender cómo un sistema electrónico puede detectar una acción del entorno y responder automáticamente.


[warning title="Simulación en Wokwi" icon="check-circle"] https://wokwi.com/projects/459066404064496641 [/warning]


En este proyecto aprenderás a usar una pantalla LCD 16x2 con módulo I2C para mostrar la temperatura en grados Celsius y generar una alerta cuando el valor supere un límite definido. Además de visualizar la información en pantalla, Arduino encenderá un LED y activará un buzzer cuando la temperatura sea alta.

Este tipo de práctica es muy útil porque integra varios elementos aprendidos anteriormente: lectura de sensores, uso de condiciones, control de salidas y visualización de datos en una pantalla.

🎯 Objetivo

Medir la temperatura con un sensor NTC, mostrarla en una pantalla LCD 16x2 I2C y activar una alerta con LED y buzzer cuando la temperatura sea mayor o igual a 30 °C.

🖥️ ¿Qué es una pantalla LCD 16x2 I2C?

La pantalla LCD 16x2 permite mostrar 2 filas de 16 caracteres. Gracias al módulo I2C, su conexión se simplifica mucho, ya que solo utiliza cuatro pines:

    • VCC
    • GND
    • SDA
    • SCL

Esto la convierte en una excelente opción para mostrar valores, mensajes de estado y alertas sin depender del Monitor Serial.

🌡️ ¿Qué hará este proyecto?

El sistema realizará las siguientes acciones:

    • leerá la temperatura desde un sensor NTC
    • convertirá la lectura a grados Celsius
    • mostrará la temperatura en la pantalla LCD
    • indicará si la temperatura es normal o alta
    • activará un LED y un buzzer si la temperatura llega a 30 °C o más

🛠️ Materiales

    • 1 Arduino Uno
    • 1 pantalla LCD 16x2 con módulo I2C
    • 1 sensor de temperatura analógico NTC
    • 1 LED
    • 1 buzzer
    • 1 resistencia de 220Ω
    • Protoboard y cables

Conexión

Pantalla LCD 16x2 I2C

    • VCC → 5V
    • GND → GND
    • SDA → A4
    • SCL → A5

Sensor NTC

    • VCC → 5V
    • GND → GND
    • S → A0

LED

    • Ánodo → Pin 8
    • Cátodo → Resistencia de 220Ω → GND

Buzzer

    • Pin positivo → Pin 9
    • Pin negativo → GND

En Wokwi, el sensor NTC puede funcionar mejor si se coloca fuera del protoboard y se conecta directamente con cables a 5V, GND y A0.


💻 Código Arduino

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

LiquidCrystal_I2C lcd(0x27, 16, 2);

const int sensorPin = A0;
const int ledPin = 8;
const int buzzerPin = 9;

const float BETA = 3950; // parámetro del NTC

void setup() {
  lcd.init();
  lcd.backlight();

  pinMode(ledPin, OUTPUT);
  pinMode(buzzerPin, OUTPUT);

  lcd.setCursor(0, 0);
  lcd.print("Iniciando...");
  delay(2000);
  lcd.clear();
}

void loop() {
  int valor = analogRead(sensorPin);
  
  //se convierte valor a grados Celcius
  float temperatura = 1 / (log(1 / (1023.0 / valor - 1)) / BETA + 1.0 / 298.15) - 273.15;

  lcd.setCursor(0, 0);
  lcd.print("Temp: ");
  lcd.print(temperatura);
  lcd.print((char)223);
  lcd.print("C   ");

  if (temperatura >= 30) {
    digitalWrite(ledPin, HIGH);
    digitalWrite(buzzerPin, HIGH);

    lcd.setCursor(0, 1);
    lcd.print("ALERTA TEMP ALTA");
  } else {
    digitalWrite(ledPin, LOW);
    digitalWrite(buzzerPin, LOW);

    lcd.setCursor(0, 1);
    lcd.print("Temp normal     ");
  }

  delay(1000);
}


📖 Explicación del código

    • #include <Wire.h> permite la comunicación I2C
    • #include <LiquidCrystal_I2C.h> carga la librería de la pantalla LCD
    • LiquidCrystal_I2C lcd(0x27, 16, 2); crea el objeto de la pantalla
    • analogRead(sensorPin) lee el valor analógico del sensor NTC
    • luego se aplica una fórmula para convertir esa lectura a grados Celsius
    • en la primera fila se muestra la temperatura actual
    • en la segunda fila se muestra el estado del sistema
    • si la temperatura es mayor o igual a 30 °C, se activa la alerta

Mientras la temperatura sea inferior a 30 °C, la pantalla mostrará el mensaje:

Temp normal

Pero si la temperatura alcanza o supera ese valor:

  • se encenderá el LED
  • sonará el buzzer
  • la pantalla mostrará:

ALERTA TEMP ALTA

De esta manera, el sistema no solo mide la temperatura, sino que también informa y responde automáticamente.

🚀 Posibles mejoras

Este proyecto puede ampliarse de varias formas:

    • cambiar el mensaje de alerta por uno más corto o más llamativo
    • hacer que el buzzer suene de forma intermitente
    • agregar un botón para apagar temporalmente la alarma
    • convertirlo en una estación ambiental básica

⚠️ Errores comunes

❌ No conectar correctamente SDA y SCL

❌ Usar una dirección I2C incorrecta en la pantalla

❌ Esperar que el sensor entregue grados Celsius sin conversión

❌ No dejar espacios al final de los mensajes de la LCD

❌ Colocar el sensor NTC en una posición incorrecta dentro del protoboard en Wokwi

✅ Conclusión

Este proyecto permite integrar varios conceptos importantes de Arduino en una sola práctica: sensores, pantalla, salidas y condiciones. Mostrar la temperatura en grados Celsius en una LCD hace que el sistema sea mucho más claro y útil para el usuario.

Además, al activar un LED y un buzzer cuando la temperatura supera los 30 °C, se crea una alerta básica que acerca al estudiante a aplicaciones reales de monitoreo y automatización.


[warning title="Simulación en Wokwi" icon="check-circle"] https://wokwi.com/projects/458960696514366465 [/warning]


En este artículo aprenderás a usar un sensor PIR con Arduino Uno para detectar movimiento y activar una alarma simple con LED y buzzer. Este tipo de proyecto es muy útil para introducir sistemas básicos de seguridad y automatización.

Cuando el sensor detecte movimiento, Arduino encenderá un LED y hará sonar un buzzer. Si no detecta movimiento, ambos permanecerán apagados.

🎯 Objetivo

Detectar movimiento con un sensor PIR y activar un LED y un buzzer como señal de alerta.

👀 ¿Qué es un sensor PIR?

Un sensor PIR es un dispositivo que detecta cambios en la radiación infrarroja emitida por los cuerpos, especialmente cuando una persona o un objeto en movimiento pasa frente a él.

Se usa con frecuencia en:

    • alarmas de seguridad
    • luces automáticas
    • sistemas de detección de presencia
    • proyectos de domótica

En Arduino, el sensor PIR trabaja como una entrada digital, ya que normalmente entrega solo dos estados:

    • HIGH → movimiento detectado
    • LOW → no hay movimiento

🛠️ Materiales

    • 1 Arduino Uno
    • 1 sensor PIR
    • 1 LED
    • 1 buzzer
    • 1 resistencia de 220Ω
    • Protoboard y cables

Conexión

Sensor PIR

    • VCC → 5V
    • GND → GND
    • OUT → Pin 2

LED

    • Ánodo → Pin 8
    • Cátodo → Resistencia de 220Ω → GND

Buzzer

    • Pin positivo → Pin 9
    • Pin negativo → GND


💻 Código Arduino

int sensorPIR = 2;
int ledPin = 8;
int buzzerPin = 9;

void setup() {
  pinMode(sensorPIR, INPUT);
  pinMode(ledPin, OUTPUT);
  pinMode(buzzerPin, OUTPUT);
  Serial.begin(9600);
}

void loop() {
  int estadoPIR = digitalRead(sensorPIR);

  if (estadoPIR == HIGH) {
    digitalWrite(ledPin, HIGH);
    digitalWrite(buzzerPin, HIGH);
    Serial.println("Movimiento detectado");
  } else {
    digitalWrite(ledPin, LOW);
    digitalWrite(buzzerPin, LOW);
    Serial.println("Sin movimiento");
  }

  delay(500);
}


📖 Explicación

    • digitalRead(sensorPIR) lee el estado del sensor PIR
    • Si el sensor detecta movimiento, devuelve HIGH
    • Entonces Arduino enciende el LED y activa el buzzer
    • Si no detecta movimiento, devuelve LOW
    • En ese caso, el LED y el buzzer permanecen apagados

Además, el programa muestra en el Monitor Serial si hay o no movimiento.

Es una práctica excelente para mostrar cómo Arduino puede reaccionar automáticamente ante eventos del entorno.

Este tipo de estructura es muy común en proyectos reales de automatización y seguridad.

🚀 Mejora del ejercicio

Puedes ampliar este proyecto de varias formas:

    • Hacer que el buzzer suene intermitente
    • dejar el LED encendido durante unos segundos después de detectar movimiento
    • mostrar mensajes más detallados en el Monitor Serial
    • activar un servomotor además de la alarma
    • convertirlo en un sistema de luz automática con sensor PIR

⚠️ Errores comunes

❌ Conectar mal el pin de salida del sensor PIR

❌ Confundir VCC con GND

❌ Colocar el LED sin resistencia

❌ Esperar que el sensor responda instantáneamente sin tiempo de estabilización

❌ Pensar que el PIR mide distancia, cuando en realidad detecta movimiento

📝 Nota importante

Algunos sensores PIR necesitan unos segundos de estabilización al iniciar la simulación o al encender el circuito. Durante ese tiempo, el comportamiento puede variar un poco hasta quedar listo para detectar movimiento correctamente.

Conclusión

El sensor PIR permite detectar movimiento de forma sencilla y convertir esa detección en una respuesta automática con Arduino. Al combinarlo con un LED y un buzzer, se puede crear una alarma básica que sirve como introducción a proyectos de seguridad y automatización.

Este tipo de práctica ayuda a los estudiantes a comprender cómo un sistema electrónico puede percibir un evento del entorno y actuar de inmediato.


[warning title="Simulación en Wokwi" icon="check-circle"] https://wokwi.com/projects/4589564863794913293 [/warning]


En este artículo aprenderás a usar un servomotor con Arduino Uno para controlar movimientos en un ángulo específico. A diferencia de un motor común, el servomotor no gira libremente de forma continua, sino que puede colocarse en una posición determinada, por ejemplo 0°, 90° o 180°.

Este componente es muy utilizado en proyectos de robótica, automatización y mecanismos interactivos, ya que permite mover piezas con precisión de una manera sencilla.

🎯 Objetivo

Controlar la posición de un servomotor con Arduino Uno para moverlo a diferentes ángulos programados.

⚙️ ¿Qué es un servomotor?

Un servomotor es un actuador que puede girar hasta una posición concreta dentro de un rango limitado, normalmente entre 0° y 180°.

Se diferencia de otros motores porque no solo se enciende o apaga, sino que puede ubicarse en una posición exacta. Por eso se usa en proyectos donde se necesita controlar movimiento con precisión.

🛠️ Materiales

    • 1 Arduino Uno
    • 1 servomotor
    • Cables

🔌 Conexión

Un servomotor suele tener 3 cables:

    • Rojo → 5V
    • Marrón o negro → GND
    • Naranja, amarillo o blanco → Pin digital 9


💻 Código Arduino

#include <servo.h>

Servo miServo;

void setup() {
  miServo.attach(9);
}

void loop() {
  miServo.write(0);
  delay(1000);

  miServo.write(90);
  delay(1000);

  miServo.write(180);
  delay(1000);
}


📖 Explicación

    • #include <Servo.h> carga la librería necesaria para controlar el servomotor
    • Servo miServo; crea un objeto para manejar el servo
    • miServo.attach(9); indica que el servomotor está conectado al pin 9
    • miServo.write(0); mueve el servo a 0 grados
    • miServo.write(90); lo mueve a 90 grados
    • miServo.write(180); lo mueve a 180 grados
    • Con delay(1000) se deja un segundo entre cada movimiento para poder observarlo con claridad.

En este ejercicio, el servomotor se moverá automáticamente entre tres posiciones:

    • 90°
    • 180°

Luego repetirá el ciclo una y otra vez.

Esta práctica es ideal para comprender cómo Arduino puede controlar movimiento de forma precisa.

⚙️ ¿Qué está pasando?

Aquí Arduino está enviando una señal de control al servomotor para indicarle en qué posición debe colocarse.

A diferencia de un LED o un buzzer, el servo no responde solo con encendido o apagado, sino con movimiento angular. Eso lo convierte en un componente muy útil para proyectos más avanzados.

🚀 Mejora del ejercicio

Puedes ampliar esta práctica de varias formas:

    • controlar el servomotor con un potenciómetro
    • moverlo con un botón
    • usarlo para abrir y cerrar una compuerta
    • combinarlo con un sensor para moverlo automáticamente

⚠️ Errores comunes

❌ Conectar mal los cables del servomotor

❌ Confundir el cable de señal con el de alimentación

❌ Esperar que el servo gire continuamente como un motor DC

❌ Usar un pin distinto sin cambiarlo en attach()

❌ No incluir la librería Servo.h

✅ Conclusión

El servomotor es un componente excelente para introducir movimiento en proyectos con Arduino. Gracias a él, es posible controlar posiciones específicas de forma sencilla, lo que abre la puerta a prácticas más dinámicas y cercanas a la robótica.

Con un ejercicio básico como este, los estudiantes pueden comprender cómo Arduino no solo controla luces o sonidos, sino también mecanismos en movimiento.


[warning title="Simulación en Wokwi" icon="check-circle"] https://wokwi.com/projects/458945670718154753 [/warning]


En este artículo aprenderás a usar un sensor de luz LDR con Arduino Uno para detectar cambios de iluminación en el ambiente y controlar un LED automáticamente. Este tipo de práctica introduce una forma básica de automatización, ya que el sistema responde por sí solo según la cantidad de luz recibida.

El ejercicio consiste en crear una luz nocturna automática: cuando el ambiente esté oscuro, el LED se encenderá; cuando haya suficiente luz, el LED se apagará.

🎯 Objetivo

Leer la cantidad de luz con un sensor LDR y encender un LED automáticamente cuando el nivel de iluminación sea bajo.

💡 ¿Qué es un sensor LDR?

Un LDR es una resistencia dependiente de la luz. Su valor cambia según la cantidad de iluminación que recibe:

    • con mucha luz, su comportamiento eléctrico cambia en un sentido
    • con poca luz, cambia en otro

Gracias a esto, Arduino puede leer un valor analógico y determinar si el ambiente está claro u oscuro.

🛠️ Materiales

    • 1 Arduino Uno
    • 1 sensor de luz LDR
    • 1 LED
    • 1 resistencia de 220Ω
    • Protoboard y cables

Conexión

Sensor LDR:

    • VCC → 5V
    • GND → GND
    • AO → A0

LED:

    • Ánodo → Pin 8
    • Cátodo → Resistencia de 220Ω → GND


💻 Código Arduino

int sensorLuz = A0;
int ledPin = 8;

void setup() {
  Serial.begin(9600);
  pinMode(ledPin, OUTPUT);
}

void loop() {
  int valorLuz = analogRead(sensorLuz);

  Serial.print("Valor de luz: ");
  Serial.println(valorLuz);

  if (valorLuz < 500) {
    digitalWrite(ledPin, HIGH);
  } else {
    digitalWrite(ledPin, LOW);
  }

  delay(500);
}

📖 Explicación

    • analogRead(sensorLuz) lee el valor del sensor LDR
    • Arduino recibe un valor entre 0 y 1023
    • Ese valor representa la cantidad de luz detectada
    • Con if, se compara la lectura con un límite definido
    • Si el valor indica poca luz, el LED se enciende
    • Si hay suficiente luz, el LED se apaga

La idea es simple:

    • cuando el ambiente está oscuro, el LED se enciende
    • cuando el ambiente está iluminado, el LED se apaga

Este tipo de lógica se usa en sistemas automáticos que no requieren intervención manual.

⚙️ ¿Qué está pasando?

Aquí Arduino está leyendo una condición del entorno: la intensidad de luz. A partir de esa lectura, toma una decisión automáticamente.

Eso convierte este proyecto en una práctica de automatización básica, porque el sistema responde por sí solo según lo que detecta el sensor.

🚀 Mejora del ejercicio

Puedes ampliar este proyecto de varias maneras:

    • cambiar el valor límite para ajustar la sensibilidad
    • mostrar mensajes como “Ambiente oscuro” o “Ambiente iluminado” en el Monitor Serial
    • usar varios LEDs según el nivel de luz
    • activar un buzzer además del LED

⚠️ Errores comunes

❌ Conectar mal el pin de señal del sensor

❌ Usar un valor límite sin observar primero el Monitor Serial

❌ Pensar que todos los LDR entregan los mismos valores

❌ Olvidar la resistencia del LED

❌ Conectar el LED al revés

✅ Conclusión

El sensor de luz LDR permite crear proyectos que responden automáticamente a la iluminación del entorno. Por eso es una excelente introducción a la automatización con Arduino.

Con una práctica sencilla como la luz nocturna automática, el estudiante comprende cómo un sensor puede activar una salida sin necesidad de pulsadores ni intervención directa del usuario.


[warning title="Simulación en Wokwi" icon="check-circle"] https://wokwi.com/projects/458940365048373249 [/warning]


En este artículo trabajaremos con un sensor de temperatura analógico (NTC) para medir cambios de temperatura y mostrar los valores en el Monitor Serial. Además, programaremos un LED para que se encienda cuando la temperatura supere un valor determinado.

Este ejercicio es importante porque representa uno de los primeros proyectos “reales” con Arduino: ya no solo controlamos luces o botones, sino que ahora Arduino lee una condición del entorno y toma una decisión a partir de ella.

🎯 Objetivo

Leer la temperatura desde un sensor NTC, mostrar el valor en el monitor serial y encender un LED cuando la temperatura supere un límite establecido.

🌡️ ¿Qué es un sensor NTC?

Un sensor NTC es un termistor, es decir, una resistencia que cambia según la temperatura. En este tipo de sensor, la resistencia disminuye cuando la temperatura aumenta.

Arduino no recibe directamente la temperatura en grados, sino un valor analógico que luego puede interpretarse para estimar la temperatura y tomar decisiones dentro del programa.

🛠️ Materiales

    • 1 Arduino Uno
    • 1 sensor de temperatura analógico (NTC)
    • 1 LED
    • 1 resistencia de 220Ω
    • Protoboard y cables

Conexión

Sensor NTC:

    • Pin izquierdo → GND
    • Pin central → 5V
    • Pin derecho → A0

LED:

    • Ánodo → Pin 8
    • Cátodo → Resistencia de 220Ω → GND


💻 Código Arduino

int sensorPin = A0;
int ledPin = 8;

void setup() {
  Serial.begin(9600);
  pinMode(ledPin, OUTPUT);
}

void loop() {
  int valorSensor = analogRead(sensorPin);

  Serial.print("Valor del sensor: ");
  Serial.println(valorSensor);

  if (valorSensor > 600) {
    digitalWrite(ledPin, HIGH);
  } else {
    digitalWrite(ledPin, LOW);
  }

  delay(1000);
}


📖 Explicación

    • analogRead(sensorPin) lee el valor del sensor NTC. Cada segundo, Arduino mostrará el valor detectado por el NTC. Así podrás comprobar cómo cambia la lectura al modificar la temperatura del sensor dentro de la simulación.
    • Ese valor puede variar entre 0 y 1023
    • Mientras mayor sea la temperatura, el valor leído cambia según el comportamiento del sensor en el circuito
    • Con la estructura if, Arduino compara el valor con un límite definido
    • Si el valor supera ese límite, el LED se enciende
    • Si no lo supera, el LED permanece apagado

Esto permite crear una alerta básica de temperatura, útil como introducción a sistemas de monitoreo.

⚙️ ¿Qué está pasando?

Aquí Arduino está usando una entrada analógica para recibir información del entorno. A diferencia de un botón, que solo tiene dos estados, el sensor NTC entrega valores variables.

Luego, Arduino analiza ese valor y toma una decisión con base en una condición. Esa lógica es la base de muchos proyectos reales, como alarmas térmicas, ventilación automática o sistemas de control ambiental.

🚀 Mejora del ejercicio

Puedes ampliar este proyecto de varias maneras:

    • cambiar el valor límite de activación del LED
    • mostrar un mensaje de alerta en el Monitor Serial
    • usar dos LEDs para indicar temperatura baja y alta
    • activar un buzzer cuando la temperatura supere el límite

⚠️ Errores comunes

❌ Conectar mal el sensor al pin analógico

❌ Esperar que el NTC muestre directamente grados Celsius sin conversión

❌ Usar un valor límite sin antes observar la lectura en el Monitor Serial

❌ Olvidar la resistencia del LED

❌ No verificar en qué sentido cambian los valores del sensor en la simulación

Conclusión

El sensor de temperatura analógico (NTC) permite a Arduino leer cambios del entorno y reaccionar ante ellos. Por eso este ejercicio es un paso importante dentro del aprendizaje, ya que introduce el uso de sensores en proyectos más cercanos a aplicaciones reales.

Mostrar la lectura en el Monitor Serial y encender un LED cuando se supera un valor determinado ayuda a comprender cómo Arduino puede monitorear variables físicas y actuar en consecuencia.

⚠️ Nota importante en Wokwi

En la simulación de Wokwi, el sensor de temperatura analógico puede funcionar mejor si se coloca fuera del protoboard y se conecta directamente con cables a 5V, GND y A0. Esto ayuda a evitar conexiones incorrectas entre filas de la protoboard.


[warning title="Simulación en Wokwi" icon="check-circle"] https://wokwi.com/projects/458888430479217665 [/warning]


Además de encender LEDs o leer botones, Arduino también puede controlar dispositivos que generan sonido. Uno de los más usados en prácticas iniciales es el buzzer, un actuador que permite emitir pitidos o alertas simples.

En este artículo aprenderás a utilizar un buzzer en dos ejercicios básicos: una alarma activada con botón y un sonido cuando se enciende un LED. Con esto introduces un nuevo tipo de actuador en tus proyectos y amplías las posibilidades de interacción.

🎯 Objetivo

Usar un buzzer como actuador de salida para emitir sonido en respuesta a una condición programada en Arduino.

🔊 ¿Qué es un buzzer?

Un buzzer es un componente electrónico que produce sonido cuando recibe una señal eléctrica. En Arduino se usa con frecuencia para crear:

    • alarmas
    • avisos sonoros
    • señales de confirmación
    • efectos simples de sonido

Es una excelente manera de añadir retroalimentación auditiva a un proyecto.

🧩 Tipos de ejercicio en este artículo

En este tema se trabajarán dos prácticas sencillas:

  • Alarma con botón
    • Al presionar el botón, el buzzer emite un sonido.
  • Sonido cuando el LED enciende
    • Cada vez que el LED se activa, el buzzer también suena.

Ambos ejercicios ayudan a comprender cómo Arduino puede controlar actuadores distintos al mismo tiempo.

🛠️ Materiales

    • 1 Arduino Uno
    • 1 buzzer
    • 1 botón
    • 1 LED
    • 1 resistencia de 220Ω
    • 1 resistencia de 10kΩ
    • Protoboard y cables


Ejercicio 1: Alarma con botón

🔌 Conexión

Botón:

    • Un terminal → 5V
    • Otro terminal → Pin 7
    • Resistencia de 10kΩ entre Pin 7 y GND

Buzzer:

    • Pin positivo → Pin 8
    • Pin negativo → GND


💻 Código Arduino

int boton = 7;
int buzzer = 8;

void setup() {
  pinMode(boton, INPUT);
  pinMode(buzzer, OUTPUT);
}

void loop() {
  int estadoBoton = digitalRead(boton);

  if (estadoBoton == HIGH) {
    digitalWrite(buzzer, HIGH);
  } else {
    digitalWrite(buzzer, LOW);
  }
}


📖 Explicación

    • digitalRead(boton) detecta si el pulsador está presionado
    • Si el botón está en HIGH, el buzzer se activa
    • Si el botón no está presionado, el buzzer permanece apagado

Este ejercicio funciona como una alarma básica controlada manualmente.

🔔 Hacer que el buzzer suene intermitente

Para generar un sonido con una frecuencia específica en un pin de Arduino se utiliza la función tone(), ya que permite producir tonos definidos, similares a notas musicales. A diferencia de digitalWrite(), que solo activa o desactiva el buzzer, tone() genera una señal que permite controlar el tipo de sonido, haciéndolo más preciso y útil para alarmas, efectos o melodías.

🔊 ¿Para qué sirve tone()?

Se utiliza para:

    • 🔔 emitir sonidos controlados
    • 🎵 reproducir notas musicales
    • 🚨 crear alarmas
    • 📢 generar avisos sonoros
    • 🎮 hacer efectos de sonido en proyectos

🧠 Sintaxis

tone(pin, frecuencia, duracion);

    • pin → donde está conectado el buzzer
    • frecuencia → en Hertz (Hz)
    • duración → en milisegundos (opcional)
💻 Código Arduino - Ejemplos de uso de la función tone()

🔊 Con delay (suena 3 segundos)
int boton = 7;
int buzzer = 8;
  
void setup() {
  pinMode(boton, INPUT);
  pinMode(buzzer, OUTPUT);
}

void loop() {
  int estadoBoton = digitalRead(boton);

  if (estadoBoton == HIGH) {
     tone(buzzer, 1000, 3000);	// suena 3 segundos
    delay(3000);	// evita que se repita muchas veces
  } else {
    noTone(buzzer);	// apaga el buzzer
  }
}
🎵 Sin delay (suena mientras presiona)
int boton = 7;
int buzzer = 8;
  
void setup() {
  pinMode(boton, INPUT);
  pinMode(buzzer, OUTPUT);
}
  
void loop() {
  int estadoBoton = digitalRead(boton);

  if (estadoBoton == HIGH) {
    tone(buzzer, 1000, 3000);
  } else {
    noTone(buzzer);	// apaga el buzzer
  }
}

[warning title="Simulación en Wokwi" icon="check-circle"] https://wokwi.com/projects/458870217131162625 [/warning]

💡 Ejercicio 2: Sonido cuando el LED enciende

🔌 Conexión

LED:

    • Ánodo → Pin 9
    • Cátodo → Resistencia de 220Ω → GND

Buzzer:

    • Pin positivo → Pin 8
    • Pin negativo → GND


💻 Código Arduino

int led = 9;
int buzzer = 8;

void setup() {
  pinMode(led, OUTPUT);
  pinMode(buzzer, OUTPUT);
}

void loop() {
  digitalWrite(led, HIGH);
  digitalWrite(buzzer, HIGH);
  delay(1000);

  digitalWrite(led, LOW);
  digitalWrite(buzzer, LOW);
  delay(1000);
}


📖 Explicación

    • Cuando el LED se enciende, el buzzer también se activa
    • Cuando el LED se apaga, el buzzer deja de sonar
    • Ambos componentes trabajan al mismo tiempo como salidas controladas por Arduino

Este ejercicio muestra cómo una misma acción puede activar más de un actuador.


[warning title="Simulación en Wokwi" icon="check-circle"] https://wokwi.com/projects/458870687877865473 [/warning]


⚙️ ¿Qué se aprende con estos ejercicios?

Con estas prácticas se refuerzan varios conceptos:

    • uso del buzzer como actuador
    • control de salidas digitales
    • activación de sonido por condición
    • coordinación entre diferentes componentes de salida
    • diseño de alertas simples con Arduino

Además, el estudiante empieza a comprender que Arduino no solo puede mostrar resultados con luz, sino también con sonido.

🚀 Posibles mejoras

Estos ejercicios se pueden ampliar fácilmente:

    • hacer que el buzzer emita pitidos intermitentes
    • combinar buzzer, LED y botón en un sistema de alarma
    • cambiar la duración del sonido con delay()
    • usar patrones diferentes de encendido y sonido

⚠️ Errores comunes

❌ Conectar invertido el buzzer

❌ Confundir buzzer activo con buzzer pasivo

❌ No compartir GND correctamente

❌ Esperar melodías complejas usando solo digitalWrite()

❌ Conectar el LED sin resistencia

Conclusión

El buzzer es un actuador sencillo pero muy útil para introducir sonido en proyectos con Arduino. Gracias a él, es posible crear alarmas, avisos y respuestas auditivas que hacen los circuitos más interactivos.

Con ejercicios como la alarma con botón o el sonido al encender un LED, el estudiante amplía su comprensión sobre el control de salidas y comienza a diseñar proyectos más completos, donde la respuesta del sistema no solo se ve, sino también se escucha.



Después de trabajar por separado con el botón y el potenciómetro, llega un ejercicio más interesante: combinar ambos en un mismo proyecto.

En este artículo aprenderás a usar un botón para encender o apagar un LED y un potenciómetro para controlar su brillo, introduciendo así la lógica combinada entre entrada digital, entrada analógica y salida PWM.

🎯 Objetivo

Encender un LED con un botón y, cuando esté encendido, controlar su brillo con un potenciómetro usando analogRead() y analogWrite().

🧩 ¿Qué se va a combinar?

En este ejercicio intervienen tres elementos importantes:

    • Botón → entrada digital
    • Potenciómetro → entrada analógica
    • LED → salida PWM

El botón decide si el LED debe estar encendido o apagado, mientras que el potenciómetro define qué tan fuerte brillará.

🛠️ Materiales

    • 1 Arduino Uno
    • 1 LED
    • 1 resistencia de 220Ω
    • 1 pulsador
    • 1 resistencia de 10kΩ
    • 1 potenciómetro de 10kΩ
    • Protoboard y cables

Conexión

Botón:

    • Un terminal → 5V
    • Otro terminal → Pin 7
    • Resistencia de 10kΩ entre Pin 7 y GND

Potenciómetro:

    • Pin izquierdo → 5V
    • Pin derecho → GND
    • Pin central → A0

LED:

    • Ánodo → Pin 9 (~PWM)
    • Cátodo → Resistencia de 220Ω → GND


💻 Código Arduino

int boton = 7;
int pot = A0;
int led = 9;

int estadoBoton = 0;
int valorPot = 0;
int brillo = 0;

void setup() {
  pinMode(boton, INPUT);
  pinMode(led, OUTPUT);
}

void loop() {
  estadoBoton = digitalRead(boton);
  valorPot = analogRead(pot);
  brillo = valorPot / 4;

  if (estadoBoton == HIGH) {
    analogWrite(led, brillo);
  } else {
    analogWrite(led, 0);
  }
}


📖 Explicación

    • digitalRead(boton) lee si el botón está presionado
    • analogRead(pot) obtiene un valor entre 0 y 1023
    • Ese valor se divide entre 4 para convertirlo a un rango de 0 a 255
    • analogWrite(led, brillo) ajusta el brillo del LED
    • Si el botón no está presionado, el LED permanece apagado

⚙️ ¿Qué está pasando?

Aquí Arduino está trabajando con dos tipos de entrada al mismo tiempo:

    • Entrada digital → botón
    • Entrada analógica → potenciómetro

Y con base en ambas controla una sola salida:

    • Salida PWM → LED

La lógica es esta:

    • Si el botón está presionado, el LED se enciende con el brillo indicado por el potenciómetro
    • Si el botón no está presionado, el LED permanece apagado

Este ejercicio ya no depende de una sola condición, sino de la combinación de dos entradas.

🚀 Mejora del ejercicio

Puedes ampliar este proyecto de varias formas:

    • Mostrar el valor del potenciómetro en el monitor serial
    • Hacer que el botón funcione como interruptor de encendido y apagado
    • Controlar varios LEDs con diferentes niveles de brillo
    • Reemplazar el LED por un buzzer o un motor pequeño

⚠️ Errores comunes

❌ Conectar mal el botón

❌ No colocar la resistencia pull-down de 10kΩ

❌ Olvidar la resistencia del LED

❌ Usar un pin que no tenga PWM para controlar el brillo

❌ Pensar que analogWrite() entrega voltaje analógico real

Conclusión

Este proyecto es importante porque introduce la lógica combinada en Arduino. Ya no se trata solo de leer una entrada o activar una salida, sino de hacer que varios componentes trabajen juntos dentro del mismo programa.

Con un botón que habilita el encendido y un potenciómetro que controla el brillo, empiezas a desarrollar una forma de programar más cercana a proyectos reales, donde varias condiciones determinan el comportamiento de un sistema.


[warning title="Simulación en Wokwi" icon="check-circle"] https://wokwi.com/projects/458844627181408257 [/warning]


En este punto del aprendizaje, ya has trabajado con LEDs, botones y sensores.

Ahora es momento de usar una herramienta clave en Arduino: El Monitor Serial

🎯 Objetivo

Aprender a usar el Monitor Serial para:

    • Mostrar mensajes en pantalla
    • Ver el estado de un botón
    • Visualizar valores de sensores

🧠 ¿Qué es el Monitor Serial?

El Monitor Serial es una herramienta del IDE de Arduino que permite:

    • 📤 Enviar datos desde Arduino a la computadora
    • 📥 Recibir datos desde la computadora

👉 Es fundamental para depurar (debug) programas.

⚙️ Configuración básica

Antes de usarlo, debes iniciar la comunicación en el código:

Serial.begin(9600);

👉 Esto establece la velocidad de comunicación (baud rate).

💻 Funciones principales

    • Serial.print() → muestra texto en la misma línea
    • Serial.println() → muestra texto y baja a la siguiente línea


🔘 Ejercicio 1: Mostrar estado de un botón

🔌 Conexión

(Usa el mismo circuito del botón que ya tienes)


💻 Código Arduino

int boton = 7; 

void setup() { 
	pinMode(boton, INPUT); 
	Serial.begin(9600); 
	
} void loop() { 
	int estado = digitalRead(boton); 
	Serial.print("Estado del botón: "); 
	Serial.println(estado); 
	delay(500); 
}


🔍 ¿Qué verás?

En el Monitor Serial aparecerá:

    • 0 → botón no presionado
    • 1 → botón presionado

👉 Esto te permite verificar si tu circuito funciona correctamente.


[warning title="Simulación en Wokwi" icon="check-circle"] https://wokwi.com/projects/458797368993424385 [/warning]


🎛️ Ejercicio 2: Mostrar valores de un sensor (potenciómetro)

🔌 Conexión

(Usa el mismo circuito del potenciómetro que ya tienes)


💻 Código Arduino

int pot = A0; 

void setup() { 
	Serial.begin(9600); 
} 

void loop() { 
	int valor = analogRead(pot); 
	Serial.print("Valor del potenciómetro: "); 
	Serial.println(valor); 
	delay(500); 
}


🔍 ¿Qué verás?

Valores que cambian entre:

👉 0 y 1023

Al girar el potenciómetro, verás cómo los números cambian en tiempo real.


[warning title="Simulación en Wokwi" icon="check-circle"] https://wokwi.com/projects/458795005088655361 [/warning]


🚀 Mejora del ejercicio

Puedes combinar todo lo aprendido:

    • 🔘 Mostrar estado del botón + encender LED
    • 🎚️ Mostrar valor del potenciómetro + controlar brillo
    • 📊 Crear gráficos usando el “Serial Plotter”

⚠️ Errores comunes

❌ No usar Serial.begin() en setup()

❌ No coincidir la velocidad (9600) con el Monitor Serial

❌ Olvidar seleccionar el puerto correcto

🧾 Conclusión

El Monitor Serial es una herramienta indispensable para cualquier proyecto en Arduino.

👉 Te permite ver lo que está pasando “dentro” del programa, facilitando la detección de errores y la comprensión del funcionamiento.

💡 Consejo: A partir de ahora, acostúmbrate a usar el Monitor Serial en todos tus proyectos. Es como tener una “ventana” al cerebro del Arduino.


Después de trabajar con salidas digitales y PWM, es momento de dar el siguiente paso: leer valores del mundo real.

En este artículo aprenderás a usar un potenciómetro como entrada analógica para controlar el brillo de un LED.

🎯 Objetivo

Leer el valor de un potenciómetro con analogRead() y usar ese valor para controlar el brillo de un LED con analogWrite().

🧠 ¿Qué es un potenciómetro?

Un potenciómetro es una resistencia variable que permite cambiar el voltaje girando una perilla.

👉 Arduino interpreta ese cambio como un valor numérico.

  • Valor mínimo → 0
  • Valor máximo → 1023

🔌 Materiales

    • 1 Arduino Uno
    • 1 LED
    • 1 resistencia (220Ω)
    • 1 potenciómetro (10kΩ recomendado)
    • Protoboard y cables

Conexión

🔘 Potenciómetro:

    • Pin izquierdo (VCC) → 5V
    • Pin derecho (GND) → GND
    • Pin central (SIG) → A0

💡 LED:

    • Ánodo → Pin 9 (~PWM)
    • Cátodo → Resistencia → GND


💻 Código Arduino

int pot = A0; 
int led = 9; 
int valor = 0; 

void setup() { 
	pinMode(led, OUTPUT); 
} 

void loop() { 
	valor = analogRead(pot); // Lee valor (0 - 1023) 
	valor = valor / 4; // Convierte a (0 - 255) 
	analogWrite(led, valor); // Controla brillo 
}

🔍 Explicación

    • analogRead(A0) devuelve valores entre 0 y 1023
    • analogWrite() trabaja de 0 a 255, por eso dividimos entre 4
    • Al girar el potenciómetro, el LED cambia su brillo en tiempo real

🎚️ ¿Qué está pasando?

Estás combinando:

    • 📥 Entrada analógica → potenciómetro
    • 📤 Salida PWM → LED

👉 Este es uno de los conceptos más importantes en Arduino: leer datos y reaccionar a ellos

🚀 Mejora del ejercicio

Puedes ampliar este proyecto:

    • 🔢 Mostrar el valor en el monitor serial
    • 🌈 Controlar varios LEDs
    • 🔊 Usar el valor para controlar un buzzer
    • 🎮 Crear un controlador tipo “volumen”

⚠️ Errores comunes

❌ No conectar bien el pin central del potenciómetro
❌ Olvidar la resistencia del LED
❌ No usar un pin PWM para el LED

🧾 Conclusión

El uso del potenciómetro introduce el concepto de entrada analógica, fundamental para trabajar con sensores en proyectos más avanzados.

💡 Consejo: Este mismo principio se usa con sensores reales como temperatura, luz o sonido.


[warning title="Simulación en Wokwi" icon="check-circle"] https://wokwi.com/projects/458786656051462145 [/warning]


Después de aprender a encender y apagar un LED, el siguiente paso es hacerlo más interesante: controlar su brillo.

Para lograrlo, Arduino utiliza una técnica llamada PWM (Modulación por Ancho de Pulso).

🎯 Objetivo

Controlar la intensidad (brillo) de un LED utilizando la función analogWrite().

🌈 Efecto Fade (subir y bajar brillo)

🧠 ¿Qué es PWM?

PWM significa Pulse Width Modulation (Modulación por Ancho de Pulso).

👉 Aunque Arduino no tiene salidas analógicas reales, simula una señal analógica encendiendo y apagando el LED muy rápidamente.

  • Más tiempo encendido → más brillo
  • Menos tiempo encendido → menos brillo

🔌 Pines PWM en Arduino Uno

Los pines que permiten PWM son:

👉 3, 5, 6, 9, 10 y 11 (marcados con ~)

🧰 Materiales

    • 1 Arduino Uno
    • 1 LED
    • 1 resistencia (220Ω)
    • Protoboard y cables

Conexión

    • LED (ánodo) → Pin 9 (~PWM)
    • LED (cátodo) → Resistencia → GND


💻 Código Arduino

int led = 9; 

void setup() { 
	pinMode(led, OUTPUT); 
} 

void loop() { 
	// Aumenta brillo 
	for (int i = 0; i <= 255; i++) { 
		analogWrite(led, i); 
		delay(5); 
	} 
	// Disminuye brillo 
	for (int i = 255; i >= 0; i--) { 
		analogWrite(led, i); 
		delay(5); 
	} 
}


🔍 Explicación

    • analogWrite(pin, valor) controla el brillo
    • El valor va de:
      • 0 → apagado
      • 255 → máximo brillo

🚀 Mejora del ejercicio

Puedes hacer este proyecto más interesante:

    • 🎚️ Controlar brillo con un potenciómetro
    • 🔘 Cambiar niveles de brillo con un botón
    • 💡 Usar varios LEDs con diferentes intensidades

⚠️ Errores comunes

❌ Usar un pin que no es PWM
❌ No usar resistencia en el LED
❌ Confundir analogWrite() con entrada analógica (analogRead())

🧾 Conclusión

El uso de PWM permite controlar dispositivos de manera más precisa, como la intensidad de luces o la velocidad de motores. Es una herramienta fundamental para proyectos más avanzados en Arduino.

💡 Consejo: Experimenta con diferentes valores entre 0 y 255 para ver cómo cambia el brillo del LED.


[warning title="Simulación en Wokwi" icon="check-circle"] https://wokwi.com/projects/458784387357356033 [/warning]


En los primeros proyectos con Arduino es común usar la función delay() para controlar el tiempo. Sin embargo, esta función tiene una gran limitación: detiene completamente el programa mientras espera.

En este artículo aprenderás a hacer parpadear un LED sin usar delay(), utilizando una técnica más avanzada y profesional con la función millis().

🎯 Objetivo

Lograr que un LED parpadee sin bloquear el programa, permitiendo ejecutar otras tareas al mismo tiempo.

⚠️ Problema con delay()

Ejemplo clásico:

    digitalWrite(led, HIGH);

    delay(1000);

    digitalWrite(led, LOW);

    delay(1000);

👉 ¿Qué pasa aquí?

    • Arduino se detiene completamente durante cada delay()
    • No puede leer botones ni sensores en ese tiempo
    • No permite hacer múltiples tareas

🧠 ¿Qué es millis()?

La función millis() devuelve el tiempo en milisegundos desde que el Arduino comenzó a ejecutar el programa.

👉 Es como un cronómetro interno que nunca se detiene.

🔌 Materiales

    • 1 Arduino Uno
    • 1 LED
    • 1 resistencia (220Ω)
    • Protoboard y cables

Conexión

    • LED (ánodo) → Pin 8
    • LED (cátodo) → Resistencia → GND


💻 Código Arduino

int led = 8; 
unsigned long tiempoAnterior = 0; 
int intervalo = 1000;    // 1 segundo 
int estadoLed = LOW; 

void setup() { 
	pinMode(led, OUTPUT); 
} 

void loop() { 
	unsigned long tiempoActual = millis(); 
	if (tiempoActual - tiempoAnterior >= intervalo) { 
		tiempoAnterior = tiempoActual;    // Cambia el estado del LED 
		if (estadoLed == LOW) { 
			estadoLed = HIGH; 
			} 
		else { estadoLed = LOW; 
		} 
		digitalWrite(led, estadoLed); 
	} 
}

🔍 Explicación del Código

    • millis() obtiene el tiempo actual
    • Se compara con el tiempo anterior
    • Si pasa el intervalo (1 segundo), se ejecuta la acción
    • El LED cambia de estado sin detener el programa

🔁 ¿Qué ventaja tiene?

✔ Permite hacer varias cosas al mismo tiempo

✔ Arduino no se “congela”

✔ Es la base de proyectos más avanzados

🚀 Mejora del ejercicio

Puedes combinar este código con otros elementos:

    • 🔘 Leer un botón mientras el LED parpadea
    • 🎚️ Cambiar la velocidad con un potenciómetro
    • 🔊 Activar un buzzer al mismo tiempo

🧾 Conclusión

El uso de millis() en lugar de delay() es un paso fundamental para pasar de proyectos básicos a proyectos más profesionales con Arduino. Permite crear sistemas más eficientes, dinámicos y capaces de realizar múltiples tareas al mismo tiempo.

💡 Consejo: Intenta modificar el intervalo para cambiar la velocidad del parpadeo. 


[warning title="Simulación en Wokwi" icon="check-circle"] https://wokwi.com/projects/458781252932657153 [/warning]


Uno de los proyectos más básicos y útiles al iniciar con Arduino es controlar un LED mediante un botón. Este ejercicio permite comprender cómo funcionan las entradas digitales y las salidas digitales, base de casi todos los proyectos electrónicos.

🎯 Objetivo

Encender un LED al presionar un botón y apagarlo al soltarlo.

🧰 Materiales

    • 1 Arduino Uno
    • 1 LED
    • 1 botón (push button)
    • 2 resistencias (220Ω y 10kΩ)
    • Protoboard
    • Cables jumper

🔌 Descripción del Circuito

En este proyecto:

    • El LED se conecta a un pin digital de salida (por ejemplo, el pin 8).
    • El botón se conecta a un pin digital de entrada (por ejemplo, el pin 7).
    • Se usa una resistencia para proteger el LED y otra como pull-down para el botón.

👉 Cuando presionas el botón, el Arduino detecta un HIGH (1) y enciende el LED.


💻 Código Arduino

//Mientras mantenga presionado el botón
//se mantiene encendido el Led

int led=8;                //definimos el valor del pin para el led
int boton=7;              //definimos el valor del pin para el boton

void setup() {
  pinMode(led, OUTPUT);   //declaramos el pin led como salida
  pinMode(boton, INPUT);  //declaramos el pin boton como entrada
}

void loop() {
  if (digitalRead(boton) == HIGH) {   //si el botón esta presionado
    digitalWrite(led, HIGH);          //encendemos el led
  }
  else {                              //caso contrario
    digitalWrite(led, LOW);           //apagamos el led
  }
}


[warning title="Simulación en Wokwi" icon="check-circle"] https://wokwi.com/projects/458711382664387585 [/warning]


🔁 Encender LED con Botón en Modo Interruptor (Toggle)

En el ejemplo anterior, el LED solo se encendía mientras mantenías presionado el botón. Ahora vamos a mejorar el proyecto para que funcione como un interruptor real (modo toggle).

🎯 ¿Qué es el modo Toggle?

El modo toggle permite que:

    • 🔘 Presionas una vez → el LED se enciende
    • 🔘 Presionas otra vez → el LED se apaga

Es decir, cada pulsación cambia el estado del LED, igual que un interruptor de luz en casa.


🔌 Circuito

✔ Se utiliza exactamente el mismo circuito anterior

(No necesitas hacer ningún cambio en las conexiones)

🧠 ¿Cómo funciona?

El Arduino debe detectar el momento exacto en que presionas el botón, no solo si está presionado.

Para eso:

    • Se guarda el estado anterior del botón
    • Se compara con el estado actual
    • Si detecta un cambio (de LOW a HIGH), cambia el estado del LED

💻 Código en Arduino

//Presiona botón enciende LED
//Vuelve a presionar botón y se apaga el LED

int led = 8;
int boton = 7;

int estadoBoton = 0;
int estadoAnterior = 0;
int estadoLed = 0;

void setup() {
  pinMode(led, OUTPUT);
  pinMode(boton, INPUT);
}

void loop() {
  estadoBoton = digitalRead(boton);

  // Detecta cuando se presiona el botón
  if (estadoBoton == HIGH && estadoAnterior == LOW) {
    estadoLed = !estadoLed; // Cambia el estado del LED
    delay(200); // Pequeño anti-rebote
  }

  digitalWrite(led, estadoLed);

  estadoAnterior = estadoBoton;
}


[warning title="Simulación en Wokwi" icon="check-circle"] https://wokwi.com/projects/458764769388938241 [/warning]


🔍 Explicación del Código

    • estadoAnterior guarda el estado previo del botón
    • Se detecta el cambio de LOW → HIGH (cuando presionas)
    • estadoLed = !estadoLed invierte el estado:
      • Si estaba apagado → se enciende
      • Si estaba encendido → se apaga

⚠️ Importante: Anti-rebote

Los botones físicos generan pequeñas vibraciones eléctricas al presionarse (rebote), lo que puede hacer que el Arduino detecte múltiples pulsaciones.

Por eso usamos:

delay(200);


🚀 Aplicaciones del modo Toggle

Este tipo de control es muy útil en proyectos reales:

    • 💡 Encendido/apagado de luces
    • 🔐 Sistemas de seguridad
    • 🤖 Robots
    • 🎮 Interfaces con botones


🧾 Conclusión

Este proyecto es fundamental para entender cómo Arduino interactúa con el mundo físico mediante entradas (botón) y salidas (LED). Dominar este ejercicio te permitirá avanzar hacia proyectos más complejos como sistemas automatizados, alarmas o interfaces interactivas.

El modo toggle convierte un simple botón en un verdadero interruptor digital. Dominar esta técnica te permitirá crear interfaces más avanzadas y mejorar la interacción en tus proyectos con Arduino.

 

MKRdezign

Formulario de contacto

Nombre

Correo electrónico *

Mensaje *

Con tecnología de Blogger.
Javascript DisablePlease Enable Javascript To See All Widget