Arduino · Proyectos

Básico · AP-BAS-01

Parpadeo de un LED

Objetivo

El LED externo de D2 queda parpadeando solo, medio segundo encendido y medio segundo apagado, con una resistencia de 220 Ω en serie. Este es el único montaje del bloque que usa delay a propósito: cada espera detiene el programa por completo y no puede atender otra cosa mientras tanto. Cuando lo cargas, el parpadeo sigue sin que pulses nada.

Materiales

La franja sale del catálogo de Hardware. No es un precio de tienda.

Cableado

Código

// Cableado: D2 LED, GND, 5V.
// Parpadeo con delay. El programa se queda parado
// 500 ms encendido y 500 ms apagado. No usa millis.
// Resistencia de 220 ohmios en serie con el anodo.
const int pinLed = 2;

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

void loop() {
  digitalWrite(pinLed, HIGH);
  delay(500);
  digitalWrite(pinLed, LOW);
  delay(500);
}

Pasos

1. Clava la Uno en la protoboard o deja la placa al lado y lleva los hilos hasta ella.
2. Pon el LED rojo con el ánodo hacia la resistencia y el cátodo, la pata corta, hacia el carril azul de GND.
3. Coloca la resistencia de 220 Ω entre el pin D2 y el ánodo del LED.
4. Une el cátodo al carril GND y ese carril al pin GND de la placa.
5. El carril rojo puede ir a 5 V, pero no lo conectes al LED: la corriente tiene que entrar por D2.
6. Carga el sketch, espera el reinicio y comprueba que el LED cambia de estado cada medio segundo sin pulsar nada.

Variantes

• Cambia los dos delay a 200 y a 800 para un destello corto y una pausa larga.
• Sustituye el LED rojo por uno verde y deja la misma resistencia de 220 Ω.
• Mueve el LED a D4 y cambia el número del pin en el sketch para que coincida.

Depuración

• Si el LED no enciende, el cátodo no está en el carril GND o ese carril no llega al pin GND.
• Sin la resistencia de 220 Ω el LED se fuerza y el pin D2 puede dañarse: no la quites.
• Si el LED está al revés, con el cátodo hacia D2, no luce aunque el sketch sea correcto.
• Si escribiste el pin 13 en el sketch y el cable está en D2, parpadea el testigo de la placa y no tu LED.

Software: digitalwrite

Básico · AP-BAS-02

LED con pulsador

Objetivo

El LED de D2 se enciende solo mientras mantienes pulsado el botón de D7 y se apaga en cuanto lo sueltas. El pulsador va a GND y la entrada usa la resistencia interna, así que un nivel bajo significa pulsado. La lectura se repite con millis cada 20 ms, sin detener el programa en una espera fija.

Materiales

La franja sale del catálogo de Hardware. No es un precio de tienda.

Cableado

Código

// Cableado: D2 LED, D7 pulsador, GND, 5V.
// LED encendido solo mientras D7 esta a GND.
// La muestra se toma cada 20 ms con millis.
const int pinLed = 2;
const int pinBtn = 7;
unsigned long marca = 0;

void setup() {
  pinMode(pinLed, OUTPUT);
  pinMode(pinBtn, INPUT_PULLUP);
  digitalWrite(pinLed, LOW);
}

void loop() {
  unsigned long ahora = millis();
  if (ahora - marca >= 20) {
    marca = ahora;
    if (digitalRead(pinBtn) == LOW) {
      digitalWrite(pinLed, HIGH);
    } else {
      digitalWrite(pinLed, LOW);
    }
  }
}

Pasos

1. Monta el LED rojo en D2 con la resistencia de 220 Ω en serie y el cátodo al carril GND.
2. Conecta un terminal del pulsador a D7 y el otro terminal al mismo carril GND.
3. No pongas resistencia en el pulsador: el sketch activa INPUT_PULLUP en D7.
4. Deja el carril de 5 V unido a la placa, pero no lo uses en el botón.
5. Carga el sketch y mantén el pulsador: el LED debe quedarse encendido solo durante la pulsación.
6. Suelta el botón y comprueba que el LED se apaga al momento, sin quedarse enganchado.

Variantes

• Invierte la lógica para que el LED esté encendido en reposo y se apague al pulsar.
• Pasa el pulsador a D8 y el LED a D4, y cambia esos dos números en el sketch.
• Añade un segundo LED en D3 que haga siempre lo contrario que el de D2.

Depuración

• Si el LED no responde, el cátodo o el pulsador se han quedado sin el hilo de GND.
• Si falta la resistencia de 220 Ω, el LED luce demasiado y el pin sufre.
• Con pinMode INPUT, sin INPUT_PULLUP, D7 flota y el LED parpadea aunque no pulses.
• Si el pulsador va a 5 V en vez de a GND, INPUT_PULLUP lo deja siempre en alto y el LED no se enciende.

Software: digitalwrite digitalread millis

Básico · AP-BAS-03

Semáforo de tres luces

Objetivo

El semáforo de coches queda ciclando solo: verde en D4, ámbar en D3, rojo en D2 y un tramo con rojo y ámbar a la vez antes de volver al verde. Cada fase dura un tiempo medido con millis, así el programa no se bloquea entre un color y el siguiente. No hay pulsador: al cargar el sketch la secuencia empieza en verde y se repite.

Materiales

La franja sale del catálogo de Hardware. No es un precio de tienda.

Cableado

Código

// Cableado: D2 LED, D3 LED, D4 LED, GND, 5V.
// Rojo D2, ambar D3, verde D4.
// Fase 0 verde 5 s, fase 1 ambar 1,5 s,
// fase 2 rojo 5 s, fase 3 rojo y ambar 2 s.
const unsigned long tiempos[4] = {5000, 1500, 5000, 2000};
int fase = 0;
unsigned long marca = 0;

void luces(int f) {
  digitalWrite(2, (f == 2 || f == 3) ? HIGH : LOW);
  digitalWrite(3, (f == 1 || f == 3) ? HIGH : LOW);
  digitalWrite(4, (f == 0) ? HIGH : LOW);
}

void setup() {
  pinMode(2, OUTPUT);
  pinMode(3, OUTPUT);
  pinMode(4, OUTPUT);
  luces(0);
  marca = millis();
}

void loop() {
  unsigned long ahora = millis();
  if (ahora - marca >= tiempos[fase]) {
    marca = ahora;
    fase = (fase + 1) % 4;
    luces(fase);
  }
}

Pasos

1. Coloca el LED rojo en D2, el ámbar en D3 y el verde en D4.
2. Pon una resistencia de 220 Ω en serie con cada ánodo, antes del LED.
3. Lleva los tres cátodos al carril GND y ese carril al pin GND.
4. No juntes los ánodos entre sí: cada color tiene su pin.
5. Carga el sketch y mira el verde: debe aguantar unos cinco segundos.
6. Después verás ámbar solo, luego rojo solo, y luego rojo con ámbar antes de repetir el verde.
7. Si un color no aparece, cambia solo ese LED de pata: el cátodo es el que va a GND.

Variantes

• Alarga el verde a ocho segundos cambiando el primer valor del array de tiempos.
• Quita la fase de rojo con ámbar y deja solo verde, ámbar y rojo.
• Haz que el ámbar parpadee tres veces antes del rojo, contando esos destellos con millis.

Depuración

• Si los tres LED quedan apagados, el carril de cátodos no llega a GND.
• Si falta una resistencia de 220 Ω, ese color luce de más o el pin se calienta.
• Si rojo y verde están cruzados, la secuencia parece invertida: rojo es D2 y verde es D4.
• Si cambias un tiempo con una espera bloqueante, el ciclo se vuelve torpe y no puedes añadir luego un pulsador.

Software: digitalwrite millis

Enseñanza: L32 Semáforo

Básico · AP-BAS-04

Antirrebote de un pulsador

Objetivo

Cada pulsación limpia en D7 cambia el LED de D2: una vez lo enciende y la siguiente lo apaga. El antirrebote espera 30 ms con millis antes de aceptar el cambio, así un solo clic no cuenta como varios. El pulsador va a GND con INPUT_PULLUP y solo se mira el flanco de bajada, no el tiempo que lo dejes hundido.

Materiales

La franja sale del catálogo de Hardware. No es un precio de tienda.

Cableado

Código

// Cableado: D2 LED, D7 pulsador, GND, 5V.
// Antirrebote de 30 ms. Cada flanco a LOW conmuta el LED.
const int pinLed = 2;
const int pinBtn = 7;
bool estable = true;
bool ultimo = true;
bool ledOn = false;
unsigned long marcaBtn = 0;

void setup() {
  pinMode(pinLed, OUTPUT);
  pinMode(pinBtn, INPUT_PULLUP);
  digitalWrite(pinLed, LOW);
}

void loop() {
  unsigned long ahora = millis();
  bool lectura = digitalRead(pinBtn);
  if (lectura != ultimo) {
    ultimo = lectura;
    marcaBtn = ahora;
  }
  if (ahora - marcaBtn >= 30 && lectura != estable) {
    estable = lectura;
    if (estable == LOW) {
      ledOn = !ledOn;
      digitalWrite(pinLed, ledOn ? HIGH : LOW);
    }
  }
}

Pasos

1. Monta el LED verde en D2 con 220 Ω y el cátodo a GND.
2. Une un terminal del pulsador a D7 y el otro a GND.
3. Confirma en el sketch que D7 está en INPUT_PULLUP, no en INPUT.
4. Carga el programa y da un clic corto: el LED debe cambiar una sola vez.
5. Mantén el botón hundido un segundo y comprueba que no sigue conmutando.
6. Suelta y vuelve a pulsar: el segundo clic devuelve el LED al estado anterior.
7. Si al pulsar una vez el LED titila varias veces, sube la espera de 30 ms a 50 ms.

Variantes

• Haz que solo cuente el flanco de subida, al soltar, en lugar del flanco al pulsar.
• Añade otro LED en D3 que quede siempre al revés que el de D2.
• Tras cinco conmutaciones, deja el LED fijo encendido hasta un reinicio.

Depuración

• Sin el hilo de GND del pulsador, D7 nunca baja y el LED no cambia.
• Si omites la resistencia de 220 Ω del LED, el brillo es excesivo y el pin queda desprotegido.
• Si usas INPUT en vez de INPUT_PULLUP, el pin flota y una sola pulsación parece un tren de clics.
• Si el botón va a 5 V, el pull-up interno no ve la bajada y el antirrebote no tiene flanco que contar.

Software: digitalwrite digitalread millis debounce

Básico · AP-BAS-05

Dos pulsadores, un LED

Objetivo

Dos pulsadores mandan sobre un solo LED en D2: D7 lo enciende y D8 lo apaga. Cada botón tiene su antirrebote de 30 ms con millis y solo actúa en el flanco, así que dejarlo pulsado no repite la orden. Si los dos flancos coinciden en la misma vuelta, manda apagar. El LED conserva el último estado hasta el siguiente clic válido.

Materiales

La franja sale del catálogo de Hardware. No es un precio de tienda.

Cableado

Código

// Cableado: D2 LED, D7 pulsador, D8 pulsador, GND, 5V.
// D7 enciende, D8 apaga. Antirrebote de 30 ms en cada uno.
const int pinLed = 2;
const int pinOn = 7;
const int pinOff = 8;
bool estOn = true;
bool ultOn = true;
bool estOff = true;
bool ultOff = true;
unsigned long marcaOn = 0;
unsigned long marcaOff = 0;
bool ledOn = false;

void setup() {
  pinMode(pinLed, OUTPUT);
  pinMode(pinOn, INPUT_PULLUP);
  pinMode(pinOff, INPUT_PULLUP);
  digitalWrite(pinLed, LOW);
}

void loop() {
  unsigned long ahora = millis();
  bool lecOn = digitalRead(pinOn);
  bool lecOff = digitalRead(pinOff);
  bool flancoOn = false;
  bool flancoOff = false;

  if (lecOn != ultOn) {
    ultOn = lecOn;
    marcaOn = ahora;
  }
  if (ahora - marcaOn >= 30 && lecOn != estOn) {
    estOn = lecOn;
    if (estOn == LOW) flancoOn = true;
  }

  if (lecOff != ultOff) {
    ultOff = lecOff;
    marcaOff = ahora;
  }
  if (ahora - marcaOff >= 30 && lecOff != estOff) {
    estOff = lecOff;
    if (estOff == LOW) flancoOff = true;
  }

  if (flancoOff) ledOn = false;
  else if (flancoOn) ledOn = true;
  digitalWrite(pinLed, ledOn ? HIGH : LOW);
}

Pasos

1. Monta el LED en D2 con su resistencia de 220 Ω y el cátodo a GND.
2. Conecta el primer pulsador entre D7 y GND: será el de encender.
3. Conecta el segundo pulsador entre D8 y GND: será el de apagar.
4. Carga el sketch y pulsa D7: el LED se enciende y se queda así al soltar.
5. Pulsa D8: el LED se apaga y no vuelve hasta un nuevo clic en D7.
6. Mantén D7 hundido y comprueba que no parpadea: solo cuenta el flanco.
7. Pulsa los dos a la vez: debe imponerse el de apagar.

Variantes

• Cambia el papel de los pines para que D8 encienda y D7 apague.
• Haz que D8, en vez de apagar, conmute el LED como un tercer modo.
• Añade un LED en D3 que indique cuál fue el último pulsador usado.

Depuración

• Si ningún botón responde, el carril GND no está unido al pin GND de la placa.
• Sin la resistencia de 220 Ω el LED queda sin límite de corriente.
• Si uno de los pines está en INPUT y no en INPUT_PULLUP, ese botón parece pulsarse solo.
• Si cruzas los hilos y D7 va al botón de apagar, la leyenda física no coincide con lo que hace el LED.

Software: digitalwrite digitalread millis debounce

Básico · AP-BAS-06

Secuencia de cuatro LEDs

Objetivo

Cuatro LED en D2, D3, D4 y D5 se encienden de uno en uno, van de izquierda a derecha y vuelven, como una luz que rebota. El avance ocurre cada 200 ms medidos con millis, y en cada momento solo hay un LED encendido. Al cargar el sketch la secuencia empieza sola por D2 y no necesita pulsador.

Materiales

La franja sale del catálogo de Hardware. No es un precio de tienda.

Cableado

Código

// Cableado: D2 LED, D3 LED, D4 LED, D5 LED, GND, 5V.
// Un solo LED encendido. Rebote en los extremos cada 200 ms.
const int leds[4] = {2, 3, 4, 5};
int indice = 0;
int paso = 1;
unsigned long marca = 0;

void setup() {
  for (int i = 0; i < 4; i++) {
    pinMode(leds[i], OUTPUT);
    digitalWrite(leds[i], LOW);
  }
  digitalWrite(leds[0], HIGH);
  marca = millis();
}

void loop() {
  unsigned long ahora = millis();
  if (ahora - marca >= 200) {
    marca = ahora;
    digitalWrite(leds[indice], LOW);
    indice += paso;
    if (indice == 0 || indice == 3) {
      paso = -paso;
    }
    digitalWrite(leds[indice], HIGH);
  }
}

Pasos

1. Alinea cuatro LED y asigna D2, D3, D4 y D5 de izquierda a derecha.
2. Pon 220 Ω entre cada pin y el ánodo de su LED.
3. Une los cuatro cátodos al carril GND y el carril al pin GND.
4. Carga el sketch: debe encenderse primero el LED de D2.
5. Observa que la luz avanza hacia D5 y, al llegar, regresa hacia D2.
6. Comprueba que nunca quedan dos LED encendidos a la vez.
7. Si el orden físico está cruzado, mueve hilos hasta que el recorrido sea continuo.

Variantes

• Baja el intervalo a 80 ms para una carrera más rápida.
• Deja una estela encendiendo el LED actual y el anterior durante el mismo paso.
• Haz un solo sentido: al llegar a D5, apaga todo y vuelve a empezar en D2.

Depuración

• Si no se mueve ninguno, falta el GND común de los cátodos.
• Si un LED de la fila no participa, revisa su resistencia de 220 Ω o el ánodo suelto.
• Si el recorrido salta un hueco, ese pin está cableado en otro LED.
• Si usas D7 para un LED de esta fila, pierdes un pin pensado para pulsadores y el orden del sketch deja de coincidir.

Software: digitalwrite millis

Básico · AP-BAS-07

Dado con seis LEDs

Objetivo

Al pulsar D7 el dado gira durante un segundo y luego deja encendidos tantos LED como el valor obtenido, de 1 a 6. Los LED están en D2, D3, D4, D5, D6 y D11, porque D7 es el pulsador y no puede ser a la vez una cara. El giro y la pausa final se miden con millis, y el monitor serie a 9600 baudios escribe el número que ha salido.

Materiales

La franja sale del catálogo de Hardware. No es un precio de tienda.

Cableado

Código

// Cableado: D2 LED, D3 LED, D4 LED, D5 LED, D6 LED, D11 LED, D7 pulsador, GND, 5V.
// El numero de LED encendidos es la tirada. Monitor a 9600.
const int leds[6] = {2, 3, 4, 5, 6, 11};
const int pinBtn = 7;
int estado = 0;
unsigned long inicio = 0;
unsigned long marcoPaso = 0;
unsigned long marcaBtn = 0;
bool estable = true;
bool ultimo = true;

void mostrar(int n) {
  for (int i = 0; i < 6; i++) {
    digitalWrite(leds[i], i < n ? HIGH : LOW);
  }
}

bool flanco(unsigned long ahora) {
  bool lectura = digitalRead(pinBtn);
  if (lectura != ultimo) {
    ultimo = lectura;
    marcaBtn = ahora;
  }
  if (ahora - marcaBtn >= 30 && lectura != estable) {
    estable = lectura;
    if (estable == LOW) return true;
  }
  return false;
}

void setup() {
  for (int i = 0; i < 6; i++) pinMode(leds[i], OUTPUT);
  pinMode(pinBtn, INPUT_PULLUP);
  Serial.begin(9600);
  randomSeed(millis());
  mostrar(0);
  Serial.println("Pulsa para tirar. Se encienden tantas luces como el valor.");
}

void loop() {
  unsigned long ahora = millis();
  bool pulsado = flanco(ahora);
  if (estado == 0 && pulsado) {
    estado = 1;
    inicio = ahora;
    marcoPaso = ahora;
    Serial.println("Girando...");
  } else if (estado == 1) {
    if (ahora - marcoPaso >= 80) {
      marcoPaso = ahora;
      mostrar(random(1, 7));
    }
    if (ahora - inicio >= 1000) {
      int valor = random(1, 7);
      mostrar(valor);
      Serial.print("Ha salido ");
      Serial.println(valor);
      estado = 0;
    }
  }
}

Pasos

1. Coloca seis LED con 220 Ω en D2, D3, D4, D5, D6 y D11, en ese orden.
2. Lleva todos los cátodos y un terminal del pulsador al carril GND.
3. Une el otro terminal del pulsador a D7 y deja D7 en INPUT_PULLUP.
4. Abre el monitor serie a 9600 baudios antes de tirar.
5. Pulsa una vez: durante un segundo las luces cambian deprisa.
6. Al parar, cuenta los LED encendidos y compáralo con la línea Ha salido del monitor.
7. Tira otra vez y comprueba que una pulsación larga no lanza varias tiradas seguidas.

Variantes

• Acorta el giro a 400 ms si quieres partidas más rápidas.
• Representa la cara del dado con un grupo de puntos en vez de una fila de luces.
• Impide una tirada nueva hasta que pase un segundo con el resultado a la vista.

Depuración

• Si no arranca la tirada, el pulsador no llega a GND o D7 no está en INPUT_PULLUP.
• Si el sexto LED nunca se enciende en un seis, falta su resistencia o el hilo de D11.
• Si el monitor muestra signos raros, está en otros baudios: tiene que ir a 9600.
• Si usas D7 como sexto LED, te quedas sin pulsador y el sketch deja de coincidir con el cableado.

Software: digitalwrite digitalread millis debounce serial

Básico · AP-BAS-08

Zumbador y pulsador

Objetivo

El zumbador pasivo de D10 suena un tono continuo mientras mantienes el pulsador de D7, y calla en cuanto lo sueltas. El programa revisa el botón cada 20 ms con millis y aplica un antirrebote corto para que el pitido no chisporrotee. No hay LED: el aviso es solo sonoro, y la otra pata del zumbador va directa a GND.

Materiales

La franja sale del catálogo de Hardware. No es un precio de tienda.

Cableado

Código

// Cableado: D10 zumbador, D7 pulsador, GND, 5V.
// Tono de 880 Hz mientras D7 esta a GND. Antirrebote de 25 ms.
const int pinZumb = 10;
const int pinBtn = 7;
bool estable = true;
bool ultimo = true;
unsigned long marcaBtn = 0;
unsigned long marca = 0;
bool sonando = false;

void setup() {
  pinMode(pinZumb, OUTPUT);
  pinMode(pinBtn, INPUT_PULLUP);
}

void loop() {
  unsigned long ahora = millis();
  bool lectura = digitalRead(pinBtn);
  if (lectura != ultimo) {
    ultimo = lectura;
    marcaBtn = ahora;
  }
  if (ahora - marcaBtn >= 25 && lectura != estable) {
    estable = lectura;
  }
  if (ahora - marca >= 20) {
    marca = ahora;
    if (estable == LOW && !sonando) {
      tone(pinZumb, 880);
      sonando = true;
    } else if (estable == HIGH && sonando) {
      noTone(pinZumb);
      sonando = false;
    }
  }
}

Pasos

1. Identifica el zumbador pasivo: dos patillas, sin oscilador propio.
2. Une la patilla de señal a D10 y la otra patilla al carril GND.
3. Conecta el pulsador entre D7 y GND.
4. Carga el sketch y pulsa: debes oír un tono fijo de 880 Hz.
5. Suelta y comprueba que el silencio es inmediato, sin un pitido colgado.
6. Pulsa varias veces seguidas: no debe quedar un crepitar entre tono y silencio.

Variantes

• Sube el tono a 1500 Hz o bájalo a 440 Hz cambiando el número de tone.
• Haz dos notas alternas mientras el botón sigue pulsado, contando el cambio con millis.
• Añade un LED en D2 que se encienda durante el mismo tiempo que dura el tono.

Depuración

• Si no hay sonido y el pulsador está bien, la segunda pata del zumbador no está en GND.
• Un zumbador activo de tres patillas no sigue bien a tone: este montaje pide el pasivo.
• Sin INPUT_PULLUP, D7 flota y el zumbador suena a rachas aunque no pulses.
• Si el botón va a 5 V, la entrada nunca lee LOW y tone no llega a arrancar.

Software: digitalread millis debounce tone

Básico · AP-BAS-09

Brillo con potenciómetro

Objetivo

El giro del potenciómetro en A0 cambia el brillo del LED de D3 de apagado a pleno, sin escalones grandes. D3 es un pin PWM de la Uno, así que analogWrite puede recortar el ciclo de encendido. La lectura se refresca cada 30 ms con millis para no saturar el pin y para que el giro se note continuo.

Materiales

La franja sale del catálogo de Hardware. No es un precio de tienda.

Cableado

Código

// Cableado: D3 LED, A0 potenciometro, 5V, GND.
// D3 es PWM. El cursor del potenciometro entra por A0.
// Se lee cada 30 ms con millis.
const int pinLed = 3;
const int pinPot = A0;
unsigned long marca = 0;

void setup() {
  pinMode(pinLed, OUTPUT);
  analogWrite(pinLed, 0);
}

void loop() {
  unsigned long ahora = millis();
  if (ahora - marca >= 30) {
    marca = ahora;
    int lectura = analogRead(pinPot);
    int brillo = map(lectura, 0, 1023, 0, 255);
    analogWrite(pinLed, brillo);
  }
}

Pasos

1. Conecta un extremo del potenciómetro a 5 V y el extremo opuesto a GND.
2. Lleva la patilla central a A0. Si no es la central, el giro no será progresivo.
3. Monta el LED en D3, no en D2: D3 admite PWM en la Uno.
4. Pon la resistencia de 220 Ω entre D3 y el ánodo, y el cátodo a GND.
5. Carga el sketch y gira despacio de un tope al otro.
6. En un tope el LED queda apagado y en el otro, a pleno brillo.
7. Si el brillo salta del mínimo al máximo a mitad de giro, cruza los extremos de alimentación.

Variantes

• Limita el máximo a 80 para un brillo suave aunque gires a tope.
• Invierte el mapa para que a la derecha el LED se apague.
• Lee el potenciómetro y enciende además un segundo LED fijo cuando pases de la mitad.

Depuración

• Si el LED no regula, está en un pin sin PWM: D2 no vale, tiene que ser D3.
• Sin la resistencia de 220 Ω el LED brilla de golpe y el pin PWM queda forzado.
• Si el cátodo no va a GND, no hay camino de retorno y el LED parece muerto en todo el giro.
• Si A0 está suelto, la lectura flota y el brillo tiembla aunque no toques el cursor.

Software: analogread analogwrite pwm millis

Básico · AP-BAS-10

Fotorresistencia enciende un LED

Objetivo

La fotorresistencia decide si el LED de D2 está encendido: con poca luz se enciende y con luz de la habitación se apaga. La LDR va de 5 V a A0 y una resistencia de 10 kΩ va de A0 a GND, así que más luz da una lectura más alta. Cada 200 ms el sketch mide A0 con millis y escribe el número en el monitor serie a 9600 baudios para que puedas ajustar el umbral de 450.

Materiales

La franja sale del catálogo de Hardware. No es un precio de tienda.

Cableado

Código

// Cableado: D2 LED, A0 LDR, 5V, GND.
// LDR entre 5V y A0. Resistencia de 10 kiloohmios entre A0 y GND.
// Lectura alta = mucha luz. LED encendido si la lectura baja de 450.
// Monitor serie a 9600. Muestra cada 200 ms con millis.
const int pinLed = 2;
const int pinLuz = A0;
const int umbral = 450;
unsigned long marca = 0;

void setup() {
  pinMode(pinLed, OUTPUT);
  Serial.begin(9600);
  Serial.println("Tapa la LDR: el LED debe encenderse por debajo de 450.");
}

void loop() {
  unsigned long ahora = millis();
  if (ahora - marca >= 200) {
    marca = ahora;
    int lectura = analogRead(pinLuz);
    if (lectura < umbral) {
      digitalWrite(pinLed, HIGH);
    } else {
      digitalWrite(pinLed, LOW);
    }
    Serial.println(lectura);
  }
}

Pasos

1. Conecta una pata de la LDR a 5 V y la otra pata al pin A0.
2. Pon la resistencia de 10 kΩ entre ese mismo nudo de A0 y el carril GND.
3. Monta el LED en D2 con 220 Ω y el cátodo a GND. No mezcles esta resistencia con la de 10 kΩ.
4. Abre el monitor serie a 9600 baudios.
5. Con luz de la mesa la cifra debe quedar por encima de 450 y el LED apagado.
6. Tapa la LDR con el dedo: la cifra baja y el LED se enciende.
7. Si en tu mesa los números viven en otra zona, cambia el 450 para que el cambio coincida con tapar y destapar.

Variantes

• Sube el umbral si quieres que el LED se encienda con menos oscuridad.
• Invierte la comparación para encender el LED cuando hay mucha luz.
• Sustituye el encendido seco por un brillo PWM en D3 según lo oscuro que esté.

Depuración

• Si la lectura no se mueve, A0 no está en el nudo o falta el hilo de GND de la 10 kΩ.
• Si pones 220 Ω en el divisor y te dejas la 10 kΩ, el margen de lecturas se aplasta.
• Si cruzas LDR y resistencia, la lógica de noche y día queda del revés.
• Un monitor a 115200 baudios enseña caracteres rotos: el sketch abre a 9600.

Software: digitalwrite analogread millis serial

Básico · AP-BAS-11

Termistor como aviso de calor

Objetivo

Este aviso de calor no usa un termistor NTC suelto, porque esa pieza no tiene ficha en el catálogo. El sensor es un TMP36 en A0: entrega una tensión que sube con la temperatura, el LED de D2 se enciende desde 30 grados y el zumbador pasivo de D10 pita a intervalos. La cuenta y el pitido van con millis, y el monitor serie a 9600 baudios muestra los grados para que veas el umbral.

Materiales

La franja sale del catálogo de Hardware. No es un precio de tienda.

Cableado

Código

// Cableado: A0 TMP36, 5V, GND, D2 LED, D10 zumbador.
// Aviso de calor con TMP36, no con un NTC suelto.
// 10 mV por grado y 0,5 V a 0 grados. Umbral 30 grados.
// Monitor serie a 9600. Tiempos con millis.
const int pinSensor = A0;
const int pinLed = 2;
const int pinZumb = 10;
unsigned long marcaLectura = 0;
unsigned long marcaBeep = 0;
bool beepOn = false;
bool calor = false;

void setup() {
  pinMode(pinLed, OUTPUT);
  pinMode(pinZumb, OUTPUT);
  Serial.begin(9600);
  Serial.println("TMP36 en A0. Alarma desde 30 grados.");
}

void loop() {
  unsigned long ahora = millis();
  if (ahora - marcaLectura >= 500) {
    marcaLectura = ahora;
    int lectura = analogRead(pinSensor);
    float voltios = lectura * (5.0 / 1023.0);
    float grados = (voltios - 0.5) * 100.0;
    calor = grados >= 30.0;
    digitalWrite(pinLed, calor ? HIGH : LOW);
    Serial.print("Grados: ");
    Serial.println(grados, 1);
  }
  if (calor) {
    if (ahora - marcaBeep >= 400) {
      marcaBeep = ahora;
      beepOn = !beepOn;
      if (beepOn) tone(pinZumb, 1200);
      else noTone(pinZumb);
    }
  } else if (beepOn) {
    beepOn = false;
    noTone(pinZumb);
  }
}

Pasos

1. Mira la cara plana del TMP36: izquierda a 5 V, centro a A0 y derecha a GND.
2. No pongas una resistencia en serie con la patilla central: A0 lee la tensión directa.
3. Monta el LED rojo en D2 con 220 Ω y el cátodo a GND.
4. Une el zumbador pasivo entre D10 y GND.
5. Abre el monitor serie a 9600 baudios y anota la temperatura de la mesa, cerca de 20 a 25 grados.
6. Aprieta el sensor entre los dedos sin cortocircuitar patillas: al pasar de 30 grados se enciende el LED y el zumbador pita a golpes.
7. Suelta el sensor y espera: al bajar de 30 grados el LED se apaga y el pitido cesa.

Variantes

• Baja el umbral a 28 grados si quieres que salte antes.
• Deja solo el LED y quita el tono si el pitido te estorba en la mesa.
• Escribe en el monitor un texto distinto por debajo de 20 grados y por encima de 30.

Depuración

• Si el TMP36 se calienta al momento, tienes cruzados 5 V y GND: la cara plana manda la posición.
• No es un NTC de dos patillas: si lo tratas como tal, A0 no verá grados sino una resistencia mal puesta.
• Sin el GND del LED, la alarma se oye pero la luz no acompaña.
• Si el monitor está a otros baudios distintos de 9600, los grados salen como signos ilegibles.

Software: digitalwrite analogread millis serial tone

Básico · AP-BAS-12

LED fijo y LED regulable

Objetivo

Conviven dos LED: el de D2 se queda fijo encendido como testigo de que la placa está en marcha, y el de D3 cambia de brillo con el potenciómetro de A0. D3 es PWM, así que el giro del cursor recorre analogWrite de 0 a 255. La lectura del potenciómetro se actualiza cada 40 ms con millis, mientras el LED fijo no se apaga en ningún momento.

Materiales

La franja sale del catálogo de Hardware. No es un precio de tienda.

Cableado

Código

// Cableado: D2 LED, D3 LED, A0 potenciometro, 5V, GND.
// D2 queda fijo en HIGH. D3 es PWM y sigue al cursor de A0.
// La lectura se renueva cada 40 ms con millis.
const int pinFijo = 2;
const int pinReg = 3;
const int pinPot = A0;
unsigned long marca = 0;

void setup() {
  pinMode(pinFijo, OUTPUT);
  pinMode(pinReg, OUTPUT);
  digitalWrite(pinFijo, HIGH);
  analogWrite(pinReg, 0);
}

void loop() {
  unsigned long ahora = millis();
  if (ahora - marca >= 40) {
    marca = ahora;
    int lectura = analogRead(pinPot);
    int brillo = map(lectura, 0, 1023, 0, 255);
    analogWrite(pinReg, brillo);
  }
}

Pasos

1. Monta el LED fijo en D2 con 220 Ω y el cátodo a GND.
2. Monta el LED regulable en D3 con otra resistencia de 220 Ω. No uses D2 para el brillo.
3. Alimenta los extremos del potenciómetro con 5 V y GND, y lleva el centro a A0.
4. Carga el sketch: el LED de D2 debe encenderse y quedarse quieto.
5. Gira el potenciómetro y mira solo el LED de D3: tiene que recorrer de apagado a brillante.
6. Vuelve el cursor a un tope y al otro para confirmar que D2 no se entera del giro.

Variantes

• Haz que el LED fijo parpadee muy lento, cada dos segundos, sin dejar de leer el potenciómetro.
• Limita el LED regulable a un máximo de 120 para no deslumbrar.
• Usa el mismo potenciómetro para decidir también si el LED fijo está permitido, con un umbral.

Depuración

• Si intentas regular el de D2 con analogWrite, no verás brillo intermedio: D2 no es PWM.
• Si falta una de las dos resistencias de 220 Ω, ese LED queda sin protección.
• Si los cátodos no comparten el GND de la placa, uno de los dos parece fundido.
• Si el cursor no es la patilla central, D3 salta de brillo en vez de subir de forma continua.

Software: digitalwrite analogread analogwrite pwm millis

Básico · AP-BAS-13

Contador de pulsaciones en el monitor serie

Objetivo

Cada clic válido en D7 suma una pulsación y el monitor serie, a 9600 baudios, escribe el total acumulado. El LED de D2 da un destello corto de 80 ms para confirmar el clic, medido con millis, sin parar el contador. El antirrebote de 30 ms ignora los rebotes del pulsador, que va a GND con INPUT_PULLUP, así que mantenerlo hundido no sigue sumando.

Materiales

La franja sale del catálogo de Hardware. No es un precio de tienda.

Cableado

Código

// Cableado: D2 LED, D7 pulsador, GND, 5V.
// Cuenta flancos con antirrebote de 30 ms.
// Destello de 80 ms en el LED. Monitor a 9600.
const int pinLed = 2;
const int pinBtn = 7;
bool estable = true;
bool ultimo = true;
unsigned long marcaBtn = 0;
unsigned long marcaLed = 0;
bool destello = false;
unsigned int cuenta = 0;

void setup() {
  pinMode(pinLed, OUTPUT);
  pinMode(pinBtn, INPUT_PULLUP);
  Serial.begin(9600);
  Serial.println("Contador listo. Cada clic suma uno.");
}

void loop() {
  unsigned long ahora = millis();
  bool lectura = digitalRead(pinBtn);
  if (lectura != ultimo) {
    ultimo = lectura;
    marcaBtn = ahora;
  }
  if (ahora - marcaBtn >= 30 && lectura != estable) {
    estable = lectura;
    if (estable == LOW) {
      cuenta++;
      Serial.print("Pulsaciones: ");
      Serial.println(cuenta);
      digitalWrite(pinLed, HIGH);
      destello = true;
      marcaLed = ahora;
    }
  }
  if (destello && ahora - marcaLed >= 80) {
    digitalWrite(pinLed, LOW);
    destello = false;
  }
}

Pasos

1. Monta el LED en D2 con 220 Ω y el cátodo a GND.
2. Conecta el pulsador entre D7 y GND.
3. Abre el monitor serie a 9600 baudios y espera la frase de inicio.
4. Da un clic corto: debe salir Pulsaciones: 1 y el LED debe lucir un instante.
5. Da cuatro clics más, separados, y comprueba que el número llega a 5.
6. Mantén el botón un segundo: el contador no debe correr solo.
7. Si un clic suma dos o tres, alarga el antirrebote de 30 ms a 50 ms.

Variantes

• Añade un segundo pulsador en D8 que ponga la cuenta a cero.
• Haz que el LED quede encendido de forma permanente al llegar a diez.
• Imprime también el tiempo en milisegundos entre un clic y el anterior.

Depuración

• Si el contador no se mueve, falta el GND del pulsador o D7 no está en INPUT_PULLUP.
• Sin la resistencia de 220 Ω el destello existe pero el LED trabaja forzado.
• Con el monitor a 115200 baudios verás basura en vez del número: usa 9600.
• Si el pulsador va a 5 V, no hay flanco a LOW y la cuenta se queda en cero.

Software: digitalwrite digitalread millis debounce serial

Básico · AP-BAS-14

Semáforo peatonal

Objetivo

El semáforo de coches espera en verde, en D4, hasta que pides paso con el pulsador de D7. Entonces pasa a ámbar en D3, luego a rojo en D2 durante cinco segundos para cruzar, y vuelve al verde. Los tiempos los lleva millis y el botón tiene antirrebote, así que una sola petición basta aunque lo pulses durante el rojo. Rojo, ámbar y verde están en D2, D3 y D4.

Materiales

La franja sale del catálogo de Hardware. No es un precio de tienda.

Cableado

Código

// Cableado: D2 LED, D3 LED, D4 LED, D7 pulsador, GND, 5V.
// Rojo D2, ambar D3, verde D4, peaton en D7 a GND.
// Verde en reposo. Tras la peticion: ambar 2 s y rojo 5 s.
const int pinRojo = 2;
const int pinAmbar = 3;
const int pinVerde = 4;
const int pinPeaton = 7;
int fase = 0;
bool peticion = false;
bool estable = true;
bool ultimo = true;
unsigned long marca = 0;
unsigned long marcaBtn = 0;

void poner(int f) {
  digitalWrite(pinRojo, f == 2 ? HIGH : LOW);
  digitalWrite(pinAmbar, f == 1 ? HIGH : LOW);
  digitalWrite(pinVerde, f == 0 ? HIGH : LOW);
}

void setup() {
  pinMode(pinRojo, OUTPUT);
  pinMode(pinAmbar, OUTPUT);
  pinMode(pinVerde, OUTPUT);
  pinMode(pinPeaton, INPUT_PULLUP);
  poner(0);
  marca = millis();
}

void loop() {
  unsigned long ahora = millis();
  bool lectura = digitalRead(pinPeaton);
  if (lectura != ultimo) {
    ultimo = lectura;
    marcaBtn = ahora;
  }
  if (ahora - marcaBtn >= 30 && lectura != estable) {
    estable = lectura;
    if (estable == LOW) peticion = true;
  }

  if (fase == 0 && peticion && ahora - marca >= 3000) {
    fase = 1;
    marca = ahora;
    poner(fase);
  } else if (fase == 1 && ahora - marca >= 2000) {
    fase = 2;
    marca = ahora;
    peticion = false;
    poner(fase);
  } else if (fase == 2 && ahora - marca >= 5000) {
    fase = 0;
    marca = ahora;
    poner(fase);
  }
}

Pasos

1. Monta rojo en D2, ámbar en D3 y verde en D4, cada uno con 220 Ω al ánodo.
2. Une los cátodos y un terminal del pulsador de peatón al carril GND.
3. Lleva el otro terminal del pulsador a D7.
4. Carga el sketch: debe quedarse en verde, sin cambiar solo.
5. Pulsa una vez. Si el verde lleva menos de tres segundos, espera ese mínimo y verás el ámbar.
6. El ámbar dura dos segundos y después se queda el rojo unos cinco segundos: ese es el cruce.
7. Al volver el verde, pulsa durante el rojo de una segunda prueba y comprueba que la petición se guarda.

Variantes

• Acorta el rojo de cruce a tres segundos en una calle poco ancha.
• Haz parpadear el ámbar durante su fase en vez de dejarlo fijo.
• Añade un LED blanco en D5 que se encienda solo durante el rojo de los coches.

Depuración

• Si nunca sale del verde, el pulsador no baja a GND o D7 no usa INPUT_PULLUP.
• Si falta la resistencia de un color, esa luz queda desprotegida o no se distingue.
• Si rojo y verde están cruzados, el cruce ocurre con el verde encendido: D2 es el rojo.
• Si el cátodo común no llega a GND, las tres luces parecen apagadas aunque la petición se acepte.

Software: digitalwrite digitalread millis debounce

Básico · AP-BAS-15

Juego de reflejos

Objetivo

El juego enciende el LED de D2 tras una espera al azar y mide cuántos milisegundos tardas en pulsar D7. Si pulsas antes de que el LED se encienda, la ronda se anula por anticipación. Todo el cronómetro va con millis, el botón lleva antirrebote y el monitor serie a 9600 baudios escribe el tiempo de reflejo o el aviso de que te has adelantado.

Materiales

La franja sale del catálogo de Hardware. No es un precio de tienda.

Cableado

Código

// Cableado: D2 LED, D7 pulsador, GND, 5V.
// Espera aleatoria, luego cronometro hasta el clic.
// Anticiparse anula la ronda. Monitor a 9600.
const int pinLed = 2;
const int pinBtn = 7;
unsigned long marca = 0;
unsigned long inicio = 0;
unsigned long espera = 2000;
int estado = 0;
bool estable = true;
bool ultimo = true;
unsigned long marcaBtn = 0;

bool flanco(unsigned long ahora) {
  bool lectura = digitalRead(pinBtn);
  if (lectura != ultimo) {
    ultimo = lectura;
    marcaBtn = ahora;
  }
  if (ahora - marcaBtn >= 30 && lectura != estable) {
    estable = lectura;
    if (estable == LOW) return true;
  }
  return false;
}

void setup() {
  pinMode(pinLed, OUTPUT);
  pinMode(pinBtn, INPUT_PULLUP);
  Serial.begin(9600);
  randomSeed(millis());
  Serial.println("Pulsa solo cuando el LED se encienda.");
  marca = millis();
}

void loop() {
  unsigned long ahora = millis();
  bool pulsado = flanco(ahora);

  if (estado == 0) {
    digitalWrite(pinLed, LOW);
    if (ahora - marca >= 1200) {
      espera = (unsigned long)random(1500, 4000);
      marca = ahora;
      estado = 1;
      Serial.println("Espera el LED...");
    }
  } else if (estado == 1) {
    if (pulsado) {
      Serial.println("Demasiado pronto. Nueva ronda.");
      marca = ahora;
      estado = 0;
    } else if (ahora - marca >= espera) {
      digitalWrite(pinLed, HIGH);
      inicio = ahora;
      estado = 2;
    }
  } else if (estado == 2) {
    if (pulsado) {
      unsigned long reaccion = ahora - inicio;
      digitalWrite(pinLed, LOW);
      Serial.print("Reflejo: ");
      Serial.print(reaccion);
      Serial.println(" ms");
      marca = ahora;
      estado = 3;
    } else if (ahora - inicio >= 3000) {
      digitalWrite(pinLed, LOW);
      Serial.println("Tiempo agotado.");
      marca = ahora;
      estado = 3;
    }
  } else if (estado == 3 && ahora - marca >= 1800) {
    marca = ahora;
    estado = 0;
  }
}

Pasos

1. Monta el LED en D2 con 220 Ω y el cátodo a GND.
2. Conecta el pulsador entre D7 y GND.
3. Abre el monitor serie a 9600 baudios y lee la frase de inicio.
4. No pulses durante el mensaje Espera el LED: si lo haces, la ronda se anula.
5. Cuando el LED se encienda, pulsa lo antes que puedas.
6. Lee la línea Reflejo y los milisegundos. Luego espera la siguiente ronda, que llega sola.
7. Prueba a dejar pasar el LED: a los tres segundos debe decir que el tiempo se agotó.

Variantes

• Estrecha la espera aleatoria entre 800 ms y 1500 ms para un juego más nervioso.
• Guarda el mejor tiempo y escríbelo solo cuando lo superes.
• Añade un segundo LED en D3 que se encienda si te anticipas.

Depuración

• Si siempre dice que te anticipas, D7 flota porque falta INPUT_PULLUP o el hilo de GND.
• Sin la resistencia de 220 Ω el estímulo luminoso fuerza el pin D2.
• Con el monitor fuera de 9600 baudios no lees el tiempo, solo caracteres rotos.
• Si el cátodo del LED no va a GND, el cronómetro corre pero no ves cuándo empezar.

Software: digitalwrite digitalread millis debounce serial

Básico · AP-BAS-16

Simón de tres colores

Objetivo

El juego enseña una secuencia de colores y tú la repites: rojo en D2 con el pulsador D7, ámbar en D3 con D8 y verde en D4 con D9. Cada acierto alarga la serie un paso, hasta seis, y un fallo la reinicia. La reproducción, la escucha y el pitido del zumbador pasivo de D10 avanzan con millis y con antirrebote, y el monitor serie a 9600 baudios te dice cuándo te toca.

Materiales

La franja sale del catálogo de Hardware. No es un precio de tienda.

Cableado

Código

// Cableado: D2 LED, D3 LED, D4 LED, D7 pulsador, D8 pulsador, D9 pulsador, D10 zumbador, GND, 5V.
// Simon de tres colores. Monitor a 9600. Antirrebote 30 ms.
const int leds[3] = {2, 3, 4};
const int btns[3] = {7, 8, 9};
const int zumb = 10;
const int TOPE = 6;
int secuencia[6];
int ronda = 1;
int iPlay = 0;
int iJug = 0;
int estado = 0;
unsigned long marca = 0;
bool estable[3] = {true, true, true};
bool ultimo[3] = {true, true, true};
unsigned long marcaBtn[3] = {0, 0, 0};

void apagar() {
  digitalWrite(2, LOW);
  digitalWrite(3, LOW);
  digitalWrite(4, LOW);
}

void colorOn(int c) {
  apagar();
  digitalWrite(leds[c], HIGH);
}

int flanco(unsigned long ahora) {
  int cual = -1;
  for (int i = 0; i < 3; i++) {
    bool lectura = digitalRead(btns[i]);
    if (lectura != ultimo[i]) {
      ultimo[i] = lectura;
      marcaBtn[i] = ahora;
    }
    if (ahora - marcaBtn[i] >= 30 && lectura != estable[i]) {
      estable[i] = lectura;
      if (estable[i] == LOW && cual < 0) cual = i;
    }
  }
  return cual;
}

void nuevaPartida() {
  ronda = 1;
  secuencia[0] = random(0, 3);
  iPlay = 0;
  iJug = 0;
  estado = 0;
  apagar();
  noTone(zumb);
  marca = millis();
}

void setup() {
  for (int i = 0; i < 3; i++) {
    pinMode(leds[i], OUTPUT);
    pinMode(btns[i], INPUT_PULLUP);
  }
  pinMode(zumb, OUTPUT);
  Serial.begin(9600);
  randomSeed(millis());
  Serial.println("Repite la secuencia. D7 rojo, D8 ambar, D9 verde.");
  nuevaPartida();
}

void loop() {
  unsigned long ahora = millis();
  int pulsado = flanco(ahora);

  if (estado == 0) {
    if (ahora - marca >= 280) {
      colorOn(secuencia[iPlay]);
      tone(zumb, 420 + secuencia[iPlay] * 180, 160);
      marca = ahora;
      estado = 1;
    }
  } else if (estado == 1) {
    if (ahora - marca >= 420) {
      apagar();
      noTone(zumb);
      iPlay++;
      marca = ahora;
      if (iPlay >= ronda) {
        iPlay = 0;
        iJug = 0;
        estado = 2;
        Serial.println("Te toca.");
      } else {
        estado = 0;
      }
    }
  } else if (estado == 2) {
    if (pulsado >= 0) {
      colorOn(pulsado);
      marca = ahora;
      if (pulsado == secuencia[iJug]) {
        tone(zumb, 520 + pulsado * 160, 120);
        iJug++;
        estado = 4;
      } else {
        tone(zumb, 180, 400);
        Serial.println("Fallo. Empezamos de nuevo.");
        estado = 3;
      }
    } else if (ahora - marca >= 8000) {
      Serial.println("Tiempo agotado.");
      marca = ahora;
      estado = 3;
    }
  } else if (estado == 4) {
    if (ahora - marca >= 220) {
      apagar();
      noTone(zumb);
      if (iJug >= ronda) {
        Serial.println("Ronda correcta.");
        if (ronda < TOPE) {
          secuencia[ronda] = random(0, 3);
          ronda++;
        } else {
          Serial.println("Has llegado a seis. Nueva partida.");
          ronda = 1;
          secuencia[0] = random(0, 3);
        }
        iPlay = 0;
        estado = 5;
      } else {
        estado = 2;
      }
      marca = ahora;
    }
  } else if (estado == 5) {
    if (ahora - marca >= 600) {
      estado = 0;
      marca = ahora;
    }
  } else if (estado == 3) {
    if (((ahora / 150) % 2) == 0) {
      digitalWrite(2, HIGH);
      digitalWrite(3, HIGH);
      digitalWrite(4, HIGH);
    } else {
      apagar();
    }
    if (ahora - marca >= 1200) {
      nuevaPartida();
    }
  }
}

Pasos

1. Monta el LED rojo en D2, el ámbar en D3 y el verde en D4, cada uno con 220 Ω.
2. Pon el pulsador de D7 junto al rojo, el de D8 junto al ámbar y el de D9 junto al verde, todos a GND.
3. Conecta el zumbador pasivo entre D10 y GND.
4. Abre el monitor serie a 9600 baudios y espera a que suene y se encienda el primer color.
5. Cuando leas Te toca, pulsa el botón de ese mismo color.
6. Si aciertas, la siguiente vuelta añade un color más al final de la serie.
7. Si fallas, los tres LED parpadean juntos y la partida vuelve a un solo paso.

Variantes

• Quita el zumbador y deja solo las luces si quieres jugar en silencio.
• Acorta la pausa entre colores para una reproducción más rápida.
• Añade un cuarto color más adelante en D5 y D6 cuando domines los tres.

Depuración

• Si un color no suena ni se pulsa, ese pulsador no está a GND o no usa INPUT_PULLUP.
• Si falta la resistencia de 220 Ω de un LED, ese color queda más brillante y desprotegido.
• Un zumbador activo no sigue la nota de tone: tiene que ser el pasivo, con una pata a GND.
• Con el monitor fuera de 9600 baudios no ves el aviso Te toca y juegas a ciegas.

Software: digitalwrite digitalread millis debounce serial tone

Básico · AP-BAS-17

Luz nocturna automática

Objetivo

La luz nocturna sube sola el brillo del LED de D3 cuando la fotorresistencia ve poca luz, y lo apaga si la mesa está clara. La LDR va de 5 V a A0 con 10 kΩ hacia GND, y D3 entrega PWM mediante analogWrite. La medida se renueva cada 80 ms con millis, y el monitor serie a 9600 baudios enseña la lectura cruda para que calibres el punto de encendido.

Materiales

La franja sale del catálogo de Hardware. No es un precio de tienda.

Cableado

Código

// Cableado: D3 LED, A0 LDR, 5V, GND.
// LDR a 5V, 10 kiloohmios a GND. Mucha luz = lectura alta = LED apagado.
// Brillo PWM en D3. Monitor a 9600. Muestra cada 80 ms.
const int pinLed = 3;
const int pinLuz = A0;
unsigned long marca = 0;

void setup() {
  pinMode(pinLed, OUTPUT);
  Serial.begin(9600);
  analogWrite(pinLed, 0);
  Serial.println("Luz nocturna. Tapa la LDR para subir el brillo.");
}

void loop() {
  unsigned long ahora = millis();
  if (ahora - marca >= 80) {
    marca = ahora;
    int lectura = analogRead(pinLuz);
    int brillo = 0;
    if (lectura < 800) {
      brillo = map(lectura, 800, 150, 0, 255);
      brillo = constrain(brillo, 0, 255);
    }
    analogWrite(pinLed, brillo);
    Serial.println(lectura);
  }
}

Pasos

1. Conecta la LDR entre 5 V y A0.
2. Pon 10 kΩ entre A0 y GND. Esa no es la resistencia del LED.
3. Monta el LED en D3 con 220 Ω y el cátodo a GND. D3 es PWM; D2 no serviría para el brillo.
4. Abre el monitor serie a 9600 baudios y anota la lectura con la luz de la mesa.
5. Tapa la LDR poco a poco: la cifra baja y el LED debe ganar brillo.
6. Destapa del todo: con una lectura alta el LED vuelve a apagarse.
7. Si en tu mesa no llega a apagarse, cambia el 800 del mapa por un valor cercano a tu lectura de día.

Variantes

• Fija un brillo mínimo de 15 para una luz de cortesía que nunca se apague del todo.
• Invierte el mapa y conviértelo en una luz que se apague de noche.
• Enciende un segundo LED fijo en D2 solo cuando el brillo PWM pase de 200.

Depuración

• Si el brillo no cambia de forma continua, el LED está en un pin sin PWM, como D2 o D4.
• Si falta la 10 kΩ a GND, A0 no tiene divisor y la lectura se queda pegada arriba o abajo.
• Si cruzas la LDR y la resistencia, la noche apaga el LED en vez de encenderlo.
• Un monitor que no esté a 9600 baudios no te deja calibrar el 800 con números legibles.

Software: analogread analogwrite pwm millis serial

Enseñanza: L34 Luz o aviso que decide solo

Básico · AP-BAS-18

Intermitente de emergencia

Objetivo

Un clic en D7 activa el intermitente de emergencia: los LED de D2 y D3 se alternan cada 350 ms, y otro clic los deja apagados. El pulsador va a GND, lleva antirrebote de 30 ms y solo cambia el modo en el flanco, medido con millis. Mientras está en marcha nunca quedan los dos encendidos a la vez, y en reposo los dos están apagados.

Materiales

La franja sale del catálogo de Hardware. No es un precio de tienda.

Cableado

Código

// Cableado: D2 LED, D3 LED, D7 pulsador, GND, 5V.
// Un clic arranca el alternado cada 350 ms. Otro clic lo para.
// Antirrebote de 30 ms con millis.
const int pinA = 2;
const int pinB = 3;
const int pinBtn = 7;
bool activo = false;
bool lado = false;
bool estable = true;
bool ultimo = true;
unsigned long marcaBtn = 0;
unsigned long marca = 0;

void setup() {
  pinMode(pinA, OUTPUT);
  pinMode(pinB, OUTPUT);
  pinMode(pinBtn, INPUT_PULLUP);
  digitalWrite(pinA, LOW);
  digitalWrite(pinB, LOW);
}

void loop() {
  unsigned long ahora = millis();
  bool lectura = digitalRead(pinBtn);
  if (lectura != ultimo) {
    ultimo = lectura;
    marcaBtn = ahora;
  }
  if (ahora - marcaBtn >= 30 && lectura != estable) {
    estable = lectura;
    if (estable == LOW) {
      activo = !activo;
      if (!activo) {
        digitalWrite(pinA, LOW);
        digitalWrite(pinB, LOW);
      }
      marca = ahora;
      lado = false;
    }
  }
  if (activo && ahora - marca >= 350) {
    marca = ahora;
    lado = !lado;
    digitalWrite(pinA, lado ? HIGH : LOW);
    digitalWrite(pinB, lado ? LOW : HIGH);
  }
}

Pasos

1. Monta dos LED ámbar en D2 y D3, cada uno con su resistencia de 220 Ω.
2. Lleva los dos cátodos y un terminal del pulsador a GND.
3. Une el otro terminal del pulsador a D7.
4. Carga el sketch y comprueba que al empezar los dos LED están apagados.
5. Pulsa una vez: deben alternarse, uno encendido y el otro apagado.
6. Pulsa otra vez y confirma que los dos se quedan apagados.
7. Mantén el botón: no debe entrar y salir del modo muchas veces por un solo apoyo.

Variantes

• Baja el intervalo a 150 ms para un parpadeo más urgente.
• Haz que en emergencia los dos LED se enciendan y se apaguen juntos, en fase.
• Añade un tercer LED en D4 que quede fijo mientras el modo está activo.

Depuración

• Si no arranca, el pulsador no tiene GND o D7 no está en INPUT_PULLUP.
• Si un lado no luce, falta su resistencia de 220 Ω o el cátodo de ese LED está suelto.
• Si los dos lucen a la vez siempre, hay un puente entre D2 y D3 en la protoboard.
• Si el botón va a 5 V, el pull-up no ve el flanco y el modo no cambia.

Software: digitalwrite digitalread millis debounce

Básico · AP-BAS-19

Tres brillos con tres pulsadores

Objetivo

Tres pulsadores eligen el brillo de un solo LED PWM en D3: D7 lo deja bajo, D8 lo deja medio y D9 lo deja alto. Cada botón va a GND, se lee con antirrebote de 30 ms y solo actúa al pulsarlo, así que el brillo se mantiene al soltar. El nivel se aplica con analogWrite y el tiempo de espera del rebote lo cuenta millis. Al arrancar, el LED permanece apagado hasta el primer clic.

Materiales

La franja sale del catálogo de Hardware. No es un precio de tienda.

Cableado

Código

// Cableado: D3 LED, D7 pulsador, D8 pulsador, D9 pulsador, GND, 5V.
// D7 brillo 40, D8 brillo 140, D9 brillo 255. D3 es PWM.
// Antirrebote de 30 ms con millis. Arranque apagado.
const int pinLed = 3;
const int pines[3] = {7, 8, 9};
const int brillos[3] = {40, 140, 255};
bool estable[3] = {true, true, true};
bool ultimo[3] = {true, true, true};
unsigned long marcaBtn[3] = {0, 0, 0};

void setup() {
  pinMode(pinLed, OUTPUT);
  for (int i = 0; i < 3; i++) pinMode(pines[i], INPUT_PULLUP);
  analogWrite(pinLed, 0);
}

void loop() {
  unsigned long ahora = millis();
  for (int i = 0; i < 3; i++) {
    bool lectura = digitalRead(pines[i]);
    if (lectura != ultimo[i]) {
      ultimo[i] = lectura;
      marcaBtn[i] = ahora;
    }
    if (ahora - marcaBtn[i] >= 30 && lectura != estable[i]) {
      estable[i] = lectura;
      if (estable[i] == LOW) {
        analogWrite(pinLed, brillos[i]);
      }
    }
  }
}

Pasos

1. Monta el LED en D3 con la resistencia de 220 Ω y el cátodo a GND.
2. No lo pongas en D2: ese pin no hace PWM y los tres brillos se verían iguales.
3. Conecta tres pulsadores a GND desde D7, D8 y D9.
4. Carga el sketch y comprueba que el LED arranca apagado.
5. Pulsa D7: debe quedar un brillo bajo y mantenerse al soltar.
6. Pulsa D8 y luego D9: el brillo sube a medio y después a pleno.
7. Vuelve a D7 para confirmar que puedes bajar de nivel sin reiniciar la placa.

Variantes

• Cambia los tres niveles a 20, 90 y 180 si el alto deslumbra.
• Haz que una segunda pulsación en el mismo botón apague el LED.
• Añade un LED fijo en D2 que indique que ya has elegido algún nivel.

Depuración

• Si los tres botones encienden el LED al mismo brillo, estás en un pin sin PWM y no en D3.
• Sin la resistencia de 220 Ω el nivel alto fuerza el LED.
• Si un pulsador no responde, su hilo de GND falta o ese pin no está en INPUT_PULLUP.
• Si un botón va a 5 V en vez de a GND, ese nivel no llega a cargarse nunca.

Software: digitalread analogwrite pwm millis debounce

Básico · AP-BAS-20

Testigo de la placa y eco por serie

Objetivo

El testigo soldado en la placa, el de D13, parpadea solo cada medio segundo para indicar que el programa sigue vivo. A la vez, lo que escribes en el monitor serie a 9600 baudios vuelve a salir con el prefijo Eco cuando pulsas retorno. El parpadeo usa millis, así que la placa puede devolver el texto sin detenerse en una espera. No hace falta un LED externo ni un pulsador.

Materiales

La franja sale del catálogo de Hardware. No es un precio de tienda.

Cableado

Código

// Cableado: D13 testigo, GND, 5V.
// El testigo de la placa parpadea cada 500 ms con millis.
// El monitor a 9600 devuelve la linea con el prefijo Eco.
const int pinTestigo = 13;
char linea[40];
int n = 0;
unsigned long marca = 0;
bool encendido = false;

void setup() {
  pinMode(pinTestigo, OUTPUT);
  Serial.begin(9600);
  Serial.println("Escribe y pulsa retorno. La placa devuelve el eco.");
}

void loop() {
  unsigned long ahora = millis();
  if (ahora - marca >= 500) {
    marca = ahora;
    encendido = !encendido;
    digitalWrite(pinTestigo, encendido ? HIGH : LOW);
  }
  while (Serial.available()) {
    char c = (char)Serial.read();
    if (c == '\n' || c == '\r') {
      if (n > 0) {
        linea[n] = '\0';
        Serial.print("Eco: ");
        Serial.println(linea);
        n = 0;
      }
    } else if (n < 39) {
      linea[n] = c;
      n++;
    }
  }
}

Pasos

1. No conectes un LED externo a D13: vas a usar el testigo que ya trae la placa.
2. No unas D13 con GND ni con 5 V mediante un cable.
3. Conecta solo el cable USB y carga el sketch.
4. Mira el testigo de la placa: debe cambiar de estado cada medio segundo.
5. Abre el monitor serie a 9600 baudios y lee la frase de inicio.
6. Escribe una palabra, pulsa retorno y comprueba que vuelve precedida de Eco.
7. Mientras llega la respuesta, el testigo no debe congelarse.

Variantes

• Cambia el parpadeo a 150 ms para ver más claro que el eco no lo detiene.
• Devuelve el texto entre corchetes en vez de usar el prefijo Eco.
• Cuenta las líneas recibidas y escribe ese número al final de cada eco.

Depuración

• Si el testigo no late, el sketch está escribiendo en otro pin y no en D13.
• Si puenteas D13 a GND con un cable, apagas el testigo y puedes forzar el pin.
• Con el monitor a 115200 baudios el eco sale ilegible: el sketch usa 9600.
• Si el retorno no dispara la respuesta, el monitor no está enviando el salto de línea al pulsar intro.

Software: digitalwrite millis serial