Proyectos de programación Arduino: semáforo, pulsador, LDR, servo y seguidor de luz

Este documento presenta una colección de ejemplos de código para Arduino, cubriendo desde el control básico de LEDs y semáforos hasta proyectos más complejos como juegos de reflejos, seguidores de luz y simulaciones de limpiaparabrisas. Cada sección incluye el código fuente y comentarios explicativos para facilitar su comprensión e implementación.

Control de Semáforo con Arduino

Este código simula el funcionamiento de un semáforo utilizando tres LEDs (verde, ámbar y rojo) conectados a pines digitales de Arduino. La secuencia de luces se controla mediante retardos de tiempo.

// Código para semáforo
#define PIN_VERDE  3
#define PIN_AMBAR  7
#define PIN_ROJO  10

void setup() {
  pinMode(PIN_VERDE, OUTPUT);
  pinMode(PIN_AMBAR, OUTPUT);
  pinMode(PIN_ROJO, OUTPUT);
}

void loop() {
  digitalWrite(PIN_VERDE, HIGH);
  delay(7000); // Verde encendido por 7 segundos
  digitalWrite(PIN_VERDE, LOW);
  digitalWrite(PIN_AMBAR, HIGH);
  delay(2000); // Ámbar encendido por 2 segundos
  digitalWrite(PIN_AMBAR, LOW);
  digitalWrite(PIN_ROJO, HIGH);
  delay(8000); // Rojo encendido por 8 segundos
  digitalWrite(PIN_ROJO, LOW);
}

Control de LED con Pulsador

Este ejemplo muestra cómo encender y apagar un LED utilizando un pulsador. Se configura el pin del pulsador con INPUT_PULLUP para simplificar el circuito, lo que significa que el botón estará en estado HIGH cuando no esté presionado y LOW cuando se presione.

// LED con pulsador
int pinLed = 3;
int pinPulsador = 4;

void setup() {
  // Configuramos el pin del botón como entrada con pull-up interno
  pinMode(pinPulsador, INPUT_PULLUP);
  // Configuramos el pin del LED como salida
  pinMode(pinLed, OUTPUT);
}

void loop() {
  // Leemos el estado del pulsador
  // En configuración pull-up, guardará LOW si está pulsado, HIGH si no
  int estadoPulsador = digitalRead(pinPulsador);

  // Utilizamos un condicional para controlar el LED
  if (estadoPulsador == LOW) {
    // Encendemos el LED si el botón está pulsado
    digitalWrite(pinLed, HIGH);
  } else {
    // Apagamos el LED cuando se suelte el botón
    digitalWrite(pinLed, LOW);
  }
}

Juego de Reflejos con Arduino

Este proyecto implementa un sencillo juego de reflejos para dos jugadores. Un LED central (salida) se enciende aleatoriamente, y el primer jugador en presionar su botón correspondiente enciende su propio LED, indicando que ha ganado la ronda.

// Juego de reflejos
#define PIN_LED_1   11  // Pin LED del jugador 1
#define PIN_BOTON_1 12  // Pin botón del jugador 1
#define PIN_LED_2   2   // Pin LED del jugador 2
#define PIN_BOTON_2 3   // Pin botón del jugador 2
#define PIN_SALIDA  7   // Pin LED verde de salida

byte game_over; // Variable que indica si el juego ha terminado

void setup() {
  pinMode(PIN_LED_1, OUTPUT);
  pinMode(PIN_BOTON_1, INPUT);
  pinMode(PIN_LED_2, OUTPUT);
  pinMode(PIN_BOTON_2, INPUT);
  pinMode(PIN_SALIDA, OUTPUT);

  game_over = 0; // Al comienzo del juego, no ha terminado

  digitalWrite(PIN_LED_1, LOW); // Apagamos LEDs de jugadores
  digitalWrite(PIN_LED_2, LOW);

  digitalWrite(PIN_SALIDA, HIGH); // Encendemos el LED de salida (preparación)

  // Tiempo aleatorio entre 1 y 10 segundos antes del "pistoletazo"
  delay(random(1000, 10001)); 
  digitalWrite(PIN_SALIDA, LOW); // Pistoletazo de salida: apaga el LED central
}

void loop() {
  byte boton_1 = digitalRead(PIN_BOTON_1);
  byte boton_2 = digitalRead(PIN_BOTON_2);

  if ((boton_1 == HIGH) && (game_over == 0)) { // Jugador 1 gana
    digitalWrite(PIN_LED_1, HIGH);
    game_over = 1;
  }

  if ((boton_2 == HIGH) && (game_over == 0)) { // Jugador 2 gana
    digitalWrite(PIN_LED_2, HIGH);
    game_over = 1;
  }

  delay(10); // Pequeña pausa para evitar lecturas erráticas
}

Lectura de Sensor LDR (Fotorresistencia)

Este código demuestra cómo leer valores de un sensor LDR (Light Dependent Resistor o fotorresistencia) y mostrarlos en el monitor serie de Arduino. También calcula y muestra el voltaje correspondiente a la lectura.

// LDR
void setup() {
  // Configuramos la conexión serie: definimos la velocidad de transferencia de datos
  Serial.begin(9600);

  // Configuramos el pin analógico A0 como entrada (opcional para analogRead)
  pinMode(A0, INPUT);
}

void loop() {
  // Leemos la entrada analógica del LDR
  int luz = analogRead(A0);

  // Mostramos la lectura del LDR en el monitor serie
  Serial.print("Lectura: ");
  Serial.print(luz);

  // Mostramos los voltios que le llegan (para un Arduino de 5V)
  Serial.print(" Voltios: ");
  Serial.println(luz * (5.0 / 1023.0));

  delay(500); // Esperamos 0.5 segundos antes de la siguiente lectura
}

Alarma de Luz con LDR y Zumbador

Este proyecto utiliza un LDR para detectar cambios en la intensidad de la luz y activar un zumbador (buzzer) cuando la luz detectada cae por debajo de un umbral específico, funcionando como una alarma de oscuridad.

// LDR BUFFER (Alarma de luz)
#define PIN_LDR A0
#define PIN_BUZZER 2

void setup() {
  pinMode(PIN_LDR, INPUT); // Configura el pin del LDR como entrada
  pinMode(PIN_BUZZER, OUTPUT); // Configura el pin del zumbador como salida

  delay(5000); // Retardo inicial (opcional, para estabilización)
}

void loop() {
  // Leemos el valor del LDR
  int ldr = analogRead(PIN_LDR);

  // Si el valor de luz es bajo (oscuro), activa el zumbador
  if (ldr < 500) {
    digitalWrite(PIN_BUZZER, HIGH);
  } else {
    // Si hay suficiente luz, apaga el zumbador
    digitalWrite(PIN_BUZZER, LOW);
  }
}

Generador de Tono Variable con LDR

Este código transforma la lectura de un LDR (o un potenciómetro conectado a un pin analógico) en una frecuencia de tono variable, que se reproduce a través de un zumbador. La frecuencia del tono cambia en función de la cantidad de luz detectada.

// Generador de tono con LDR
#define PIN_TONO A0
#define PIN_BUZZER 2

void setup() {
  pinMode(PIN_TONO, INPUT); // Pin para la lectura analógica (LDR/potenciómetro)
  pinMode(PIN_BUZZER, OUTPUT); // Pin para el zumbador
}

void loop() {
  // Leemos el valor del sensor (LDR o potenciómetro)
  int ldr = analogRead(PIN_TONO);

  // Mapeamos el rango de lectura (0-1023) a un rango de frecuencia (50-5000 Hz)
  int frecuencia = map(ldr, 0, 1023, 50, 5000);

  // Reproducimos la nota en el zumbador con la frecuencia calculada
  tone(PIN_BUZZER, frecuencia);

  // Opcional: añadir un pequeño delay o noTone() si se desea un control más preciso
  // delay(10); // Pequeña pausa
}

Simulación de Limpiaparabrisas con Servo Motor

Este ejemplo utiliza un servomotor para simular el movimiento de un limpiaparabrisas. El servo se mueve repetidamente de 0 a 180 grados y viceversa, creando un movimiento oscilante.

// Limpiaparabrisas
#include <Servo.h> // Librería para servos

#define PIN_SERVO 9 // Pin al que conectamos la señal del servo

Servo myServo; // Instancia para el servo
int pos = 0;   // Variable para guardar la posición del servo

void setup() {
  myServo.attach(PIN_SERVO); // Declaramos la salida del servo
}

void loop() {
  // Movimiento del servo en un sentido (de 0 a 180 grados)
  for (pos = 0; pos <= 180; pos += 1) {
    myServo.write(pos);
    delay(20);
  }

  // Movimiento del servo en el otro sentido (de 180 a 0 grados)
  for (pos = 180; pos >= 0; pos -= 1) {
    myServo.write(pos);
    delay(20);
  }
}

Seguidor de Luz (Girasol Robótico) con Servomotor y LDRs

Este proyecto crea un seguidor de luz, similar a un girasol robótico, utilizando un servomotor y dos sensores LDR. El servomotor ajusta su posición para orientarse hacia la fuente de luz más intensa, comparando las lecturas de los dos LDRs.

// Girasol (Seguidor de luz)
#include <Servo.h> // Librería para servos

Servo myServo; // Creamos una instancia del objeto Servo

#define PIN_LDR_DCHA A4 // Pin analógico para el LDR derecho
#define PIN_LDR_IZDA A5 // Pin analógico para el LDR izquierdo
#define PIN_SERVO 3     // Pin para el servomotor

#define ZONA_ZERO 20    // Margen de "zona muerta" para evitar movimientos constantes

int pos = 90; // Ángulo de posición inicial del servo (centro)

// Declaración de funciones (prototipos)
void girar_dcha();
void girar_izda();

void setup() {
  // Los pines analógicos no necesitan pinMode explícito para analogRead, pero se puede incluir
  pinMode(PIN_LDR_DCHA, INPUT);
  pinMode(PIN_LDR_IZDA, INPUT);
  myServo.attach(PIN_SERVO);

  // Inicialmente en posición central (90°)
  myServo.write(pos);
}

void loop() {
  // Lectura de las LDRs
  int luz_dcha = analogRead(PIN_LDR_DCHA);
  int luz_izda = analogRead(PIN_LDR_IZDA);

  // Gira hacia el lado que ve más luz, considerando la zona cero
  if (luz_dcha > luz_izda + ZONA_ZERO) {
    girar_dcha();
  }
  if (luz_izda > luz_dcha + ZONA_ZERO) {
    girar_izda();
  }
  // Pequeña pausa para estabilización y evitar movimientos bruscos
  delay(50);
}

void girar_dcha() { // Función para girar a la derecha
  if (pos < 180) {
    pos++;
    myServo.write(pos);
    delay(20);
  }
}

void girar_izda() { // Función para girar a la izquierda
  if (pos > 0) {
    pos--;
    myServo.write(pos);
    delay(20);
  }
}