El Blog de Joseca

Artículos variados de Educación, Informática y otras cosas más.

Últimos artículos

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]


MKRdezign

Formulario de contacto

Nombre

Correo electrónico *

Mensaje *

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