practica Arduino

Bitwise Ar · Arduino desde cero · CTP

Capítulos 12 y 13 — LED RGB y sensor de sonido

Video oficial, montaje, teoría corta y los sketches completos del repo. Canal @BitwiseAr · GitHub

Capítulo 12 — LED RGB KY-016 / KY-009

Un LED RGB es tres LED en un encapsulado: rojo, verde y azul. Mezclando brillos (PWM 0–255) se arma cualquier color.

  • Cátodo común (KY-016): pata común a GND. HIGH prende. Programas 1, 2 y 3.
  • Ánodo común (KY-009): pata común a 5 V. LOW prende. Programa 4: se escribe 255 − valor.

0:00 intro · 3:48 módulos · 7:09 circuito · 8:31 P1 · 14:40 P2 · 18:54 P3 función · 24:46 P4 ánodo.

Materiales

Cant.Pieza
1Arduino UNO
1LED RGB 4 patas o módulo KY-016 (cátodo) / KY-009 (ánodo)
3330 Ω (si el LED es suelto; el módulo ya las trae)
4Jumpers

Montaje — cátodo común (P1 a P3)

LED / móduloUNO
R (rojo)D9 ~
G (verde)D10 ~
B (azul)D11 ~
Común −GND
Tiene que ser pin con ~. Si el LED es suelto: 330 Ω en serie en R, G y B. La pata más larga del RGB suelto suele ser el cátodo común.

Cap. 12 · P1 Rojo, verde, azul

int LEDROJO = 9;
int LEDVERDE = 10;
int LEDAZUL = 11;

void setup() {
  pinMode(LEDROJO, OUTPUT);
  pinMode(LEDVERDE, OUTPUT);
  pinMode(LEDAZUL, OUTPUT);
}

void loop() {
  analogWrite(LEDROJO, 255);
  analogWrite(LEDVERDE, 0);
  analogWrite(LEDAZUL, 0);
  delay(2000);

  analogWrite(LEDROJO, 0);
  analogWrite(LEDVERDE, 255);
  analogWrite(LEDAZUL, 0);
  delay(2000);

  analogWrite(LEDROJO, 0);
  analogWrite(LEDVERDE, 0);
  analogWrite(LEDAZUL, 255);
  delay(2000);
}
Cada 2 s cambia de color puro. Si el orden sale invertido, intercambie D9/D10/D11 según la seda del módulo.

Cap. 12 · P2 Mezcla: amarillo, celeste, rosado

int LEDROJO = 9;
int LEDVERDE = 10;
int LEDAZUL = 11;

void setup() {
  pinMode(LEDROJO, OUTPUT);
  pinMode(LEDVERDE, OUTPUT);
  pinMode(LEDAZUL, OUTPUT);
}

void loop() {
  analogWrite(LEDROJO, 255);   // amarillo = R+G
  analogWrite(LEDVERDE, 255);
  analogWrite(LEDAZUL, 0);
  delay(2000);

  analogWrite(LEDROJO, 0);     // celeste = G+B
  analogWrite(LEDVERDE, 255);
  analogWrite(LEDAZUL, 255);
  delay(2000);

  analogWrite(LEDROJO, 255);   // rosado
  analogWrite(LEDVERDE, 118);
  analogWrite(LEDAZUL, 192);
  delay(2000);
}
R+G = amarillo. G+B = cian. El rosado es una mezcla desigual: el ojo no ve los tres canales igual de fuertes.

Cap. 12 · P3 Función miColor()

Misma idea que P2, pero el trío de analogWrite queda en una función. Eso es lo que el video enseña de programación.

int LEDROJO = 9;
int LEDVERDE = 10;
int LEDAZUL = 11;

void setup() {
  pinMode(LEDROJO, OUTPUT);
  pinMode(LEDVERDE, OUTPUT);
  pinMode(LEDAZUL, OUTPUT);
}

void loop() {
  miColor(255, 255, 0);
  delay(2000);
  miColor(0, 255, 255);
  delay(2000);
  miColor(255, 118, 192);
  delay(2000);
}

void miColor(int rojo, int verde, int azul) {
  analogWrite(LEDROJO, rojo);
  analogWrite(LEDVERDE, verde);
  analogWrite(LEDAZUL, azul);
}

Cap. 12 · P4 Ánodo común (KY-009)

Común a 5 V. Para prender hay que bajar el pin. La función resta de 255.

int LEDROJO = 9;
int LEDVERDE = 10;
int LEDAZUL = 11;

void setup() {
  pinMode(LEDROJO, OUTPUT);
  pinMode(LEDVERDE, OUTPUT);
  pinMode(LEDAZUL, OUTPUT);
}

void loop() {
  miColor(255, 255, 0);
  delay(2000);
  miColor(0, 255, 255);
  delay(2000);
  miColor(255, 118, 192);
  delay(2000);
}

void miColor(int rojo, int verde, int azul) {
  analogWrite(LEDROJO, 255 - rojo);
  analogWrite(LEDVERDE, 255 - verde);
  analogWrite(LEDAZUL, 255 - azul);
}
Si con P3 se ve al revés (queda blanco y se “apaga” a color), el módulo es ánodo común: use P4.

Capítulo 13 — Sensor de sonido KY-037 / KY-038

El módulo compara el audio con un umbral que se fija con el preset de varias vueltas. Si el aplauso supera el umbral, D0 sale HIGH y el LED del módulo parpadea.

A0 no es el volumen en tiempo real en estos KY: replica el umbral del preset (0–1023). Sirve para leer cómo quedó ajustado, no para un VU-meter.

0:00 intro · 3:59 circuito · 4:46 P1 digital · 10:09 circuito A0 · 10:55 P2 analog.

Materiales

Cant.Pieza
1Arduino UNO
1KY-037 o KY-038 (4 pines: G + A0 D0)
1LED + 330 Ω
—Destornillador pequeño para el preset

Montaje

MóduloUNO
GGND
+5 V
D0D2
A0A0 (solo P2)
LED ánodo + 330 ΩD3 · cátodo a GND
Gire el preset hasta que el LED del módulo esté casi apagado en silencio y parpadee al chasquear. Si queda siempre ON, está demasiado sensible.

Cap. 13 · P1 Aplauso = cambia el LED

int MIC = 2;
int LED = 3;
int VALOR;
int ESTADO;

void setup() {
  pinMode(MIC, INPUT);
  pinMode(LED, OUTPUT);
}

void loop() {
  VALOR = digitalRead(MIC);
  if (VALOR == HIGH) {
    ESTADO = digitalRead(LED);
    digitalWrite(LED, !ESTADO);
    delay(500);
  }
}
Un sonido fuerte conmuta el LED. El delay(500) evita que un solo aplauso lo cambie diez veces.

Cap. 13 · P2 Leer el umbral por A0

Abra el Monitor Serie a 9600. Gire el preset y vea el número. No es el nivel de audio; es la referencia del comparador.

int SENSOR = 0;
int VALOR;

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

void loop() {
  VALOR = analogRead(SENSOR);
  Serial.println(VALOR);
  delay(100);
}
Si D0 no dispara: baje el umbral (número de A0 más bajo = más sensible, según el módulo). Pruebe primero con el LED del propio KY.

Códigos: github.com/bitwiseAr/Curso-Arduino-desde-cero — carpetas Capitulo12 y Capitulo13. Uso didáctico CTP. No pegar iframes en Elementor; use las miniaturas.

Electrónica Industrial · CTP · Primera práctica

Encender un LED en protoboard

Polaridad, resistencia serie, filas de la protoboard y dos códigos: fijo y parpadeo.

Qué está pasando

Un LED es un diodo: la corriente solo pasa de ánodo (+) a cátodo (−). Si lo pone al revés, no se quema de inmediato, pero no enciende.

  • Pata larga = ánodo = hacia el pin (5 V cuando el pin está HIGH).
  • Pata corta y el corte plano del encapsulado = cátodo = hacia GND.

En 5 V, un LED rojo pide unos 2 V. El resto hay que “quemarlo” en una resistencia. Sin ella el pin entrega de más y el LED o el pin se dañan.

R = (5 V − VF) / I   →   (5 − 2) / 0,015 A ≈ 200 Ω

En el taller use 220 Ω o 330 Ω. 1 kΩ también prende, más tenue. Nunca 0 Ω.

Ánodo y cátodo del LED

Larga = +. Corta y lado plano = −. La resistencia va en serie, da igual antes o después del LED.

La protoboard: cada fila de 5 huecos (a-b-c-d-e) está unida por dentro. El canal del centro parte el tablero. Los rieles + y − de los bordes corren a lo largo. No clave las dos patas del LED en la misma fila: haría corto y no prende.

Lista de materiales

Cant.PiezaDe la caja
1Arduino UNO + cable USB
1Protoboard
1LED 5 mm (rojo o verde)pata larga = ánodo
1Resistencia 220 Ω o 330 Ωrojo-rojo-marrón o naranja-naranja-marrón
2Jumpers macho-machouno al pin, uno a GND

Montaje en protoboard

  1. LED: pata larga en una fila (ejemplo fila 10, lado derecho). Pata corta en la fila 12. No en la misma.
  2. Resistencia: de la fila 10 a otra fila libre (ejemplo fila 8).
  3. Jumper amarillo o rojo: pin D8 del UNO → fila 8.
  4. Jumper negro: GND del UNO → fila 12 (cátodo).
QuéA
Ánodo LED (larga)220 Ω → pin D8
Cátodo LED (corta)GND
No use el pin 13 para esta práctica: ya tiene el LED de la placa y confunde. D8 está libre.
LED y 220 ohm en protoboard

Ánodo → 220 Ω → pin. Cátodo → GND. Las dos patas del LED en filas distintas.

Arduino UNO LED protoboard

Código 1 Encendido fijo

Pegue en el IDE. Placa: Arduino UNO. Puerto COM del cable. Subir.

const int PIN_LED = 8;

void setup() {
  pinMode(PIN_LED, OUTPUT);
  digitalWrite(PIN_LED, HIGH);   // 5 V en D8
}

void loop() {
  // vacío a propósito: el LED se queda encendido
}
El LED debe quedar prendido todo el tiempo. Si no: pata al revés o misma fila.

Código 2 Parpadeo (Blink)

const int PIN_LED = 8;

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

void loop() {
  digitalWrite(PIN_LED, HIGH);
  delay(500);
  digitalWrite(PIN_LED, LOW);
  delay(500);
}
1 Hz: medio segundo on, medio off. Cambie los 500 y vea qué pasa.

Reto (mismo cableado)

void loop() {
  digitalWrite(PIN_LED, HIGH);
  delay(80);
  digitalWrite(PIN_LED, LOW);
  delay(920);
}

Pulso corto cada segundo. Eso ya no es “queda prendido”: el UNO está ejecutando el loop una y otra vez.

Si no prende

Qué veCausa típica
NadaLED al revés. Déle vuelta.
NadaLas dos patas en la misma fila de 5 huecos.
NadaJumper en D7 y el código dice D8.
Muy tenueResistencia de 10 kΩ o más. Ponga 220–330 Ω.
Se apaga al tocarPata mal clavada. Empuje hasta el fondo.
IDE no subeHerramientas → Placa UNO y Puerto COM correcto.
Qué debe saber al salir. Ánodo / cátodo. Por qué la resistencia. Filas de la protoboard. pinMode OUTPUT. digitalWrite HIGH = 5 V, LOW = 0 V. loop se repite solo.

Práctica base CTP. Siguiente paso natural: pulsador + LED o LED RGB (página de los 4 videos).

Electrónica Industrial · CTP · 4 videos + práctica

Vea el video, arme con esta guía, copie el código

PIR HC-SR501, LED RGB, control de temperatura y encoder KY-040. Los pines de esta página mandan, no los del video si chocan.

Los 4 videos

#Qué aprendeVideoEn el taller
1Sensor pasivo IR + reléBitwise cap. 11PIR de cúpula + Songle / módulo relé
2Mezcla RGB y funciónBitwise cap. 12LED RGB de 4 patas + 3× 330 Ω
3Umbral y carga 12 VIoTicosDS18B20 o DHT11 + transistor / relé + ventilador
4Cuadratura e interrupciónHugo / KY-040KY-040 + 2 LED. Display opcional
Método. 1) Mire el video. 2) Pause. 3) Arme con la tabla de acá. 4) Pegue el código. 5) Compare con lo que vio.

1 PIR HC-SR501 + relé

Bitwise cap. 11 PIR Bitwise Ar · Cap. 11 · eFoa88s6yZY · vea 0:00 teoría, 3:22 cables, 4:16 código

Teoría (para que no solo copie)

PIR = Passive Infrared. No ilumina nada. El cristal de la cúpula “ve” el calor del cuerpo (infrarrojo lejano). Si esa imagen cambia (usted se mueve), el chip pone OUT en HIGH unos segundos.

Dos presets naranja:

  • Sensibilidad — hasta ~7 m.
  • Tiempo — cuánto dura el HIGH (el video también lo alarga con delay).

Jumper H = vuelve a disparar si sigue habiendo gente. L = un solo pulso.

Al encender se calibra 20–60 s. Si se mueve frente a él, “ve fantasmas”.

Pines HC-SR501

VCC · OUT · GND. Jumper H/L. Foto de referencia del módulo.

Lista de materiales

Cant.PiezaNota
1Arduino UNO
1HC-SR501 (cúpula blanca)el de la foto del taller
1Módulo relé 5 V o Songle + S8050 + 1 kΩ + 1N4007Bitwise usa módulo (activo en LOW)
1LED + 220 Ωcarga de aula; no 120 V
—Jumpers

Montaje (pines del video)

PIRUNOMódulo reléUNO
VCC5 VVCC5 V
GNDGNDGNDGND
OUTD2IND3
Módulo relé de 3 pines casi siempre es activo en LOW (LOW = clic). Songle desnudo: D3 → 1 kΩ → base S8050, emisor GND, colector a bobina −, bobina + a 5 V, diodo en paralelo. Entonces el código usa HIGH para activar. Abajo van las dos versiones.

Código — módulo relé (como el video)

int pir = 2;
int relay = 3;
int estado = 0;

void setup() {
  pinMode(pir, INPUT);
  pinMode(relay, OUTPUT);
  digitalWrite(relay, HIGH);   // relé apagado (activo LOW)
  delay(20000);                // calibración PIR
}

void loop() {
  estado = digitalRead(pir);
  if (estado == HIGH) {
    digitalWrite(relay, LOW);  // enciende
    delay(4000);
    digitalWrite(relay, HIGH); // apaga
  }
}
Espere 20 s en silencio. Cruce delante: el relé pega 4 s.

Código — Songle desnudo + transistor (caja del taller)

int pir = 2;
int relay = 3;

void setup() {
  pinMode(pir, INPUT);
  pinMode(relay, OUTPUT);
  delay(20000);
}

void loop() {
  if (digitalRead(pir) == HIGH) {
    digitalWrite(relay, HIGH); // satura el S8050
    delay(4000);
    digitalWrite(relay, LOW);
  }
}
Qué debe saber al salir. Diferencia entre sensor activo (emite IR, KY-032) y pasivo (PIR). Por qué el relé no se alimenta del pin. Por qué hay delay de arranque.

2 LED RGB — cátodo / ánodo y función

Bitwise cap. 12 RGB Bitwise Ar · Cap. 12 · xX8_QvwOJ6I · 0:17 ánodo/cátodo · 8:31 primer código · 18:54 función

Teoría

Un RGB son tres LED en un encapsulado. Mezcla aditiva:

  • R + G = amarillo
  • G + B = cian
  • R + B = magenta
  • R + G + B = blanco

Cátodo común: la pata larga (o la marcada) va a GND. El pin en HIGH enciende. El LED de 4 patas de la mesa casi siempre es este.

Ánodo común: común a 5 V. Hay que escribir 255 - valor. KY-016 a veces es ánodo.

PWM en pines con ~ (9, 10, 11): analogWrite(pin, 0..255).

El ojo es más sensible al verde: un “amarillo 255,255,0” se ve verdoso. Por eso el rosa del video baja el verde (255, 118, 192).

RGB en protoboard

Cátodo común: común a GND, cada color con 330 Ω a un pin PWM.

Ánodo común

Si el dibujo junta R, G y B al (+), es ánodo común.

Lista de materiales

Cant.Pieza
1LED RGB 4 patas (cátodo común) o módulo KY-016 / KY-009
3330 Ω (si el módulo no las trae; KY-009 no las trae)
1Arduino UNO + protoboard + jumpers

Cómo saber el común: la pata más larga suele ser el común. Si no prende nada, pruebe ese cable en 5 V en vez de GND (ánodo).

Montaje — cátodo común (el de la mesa)

PataVíaUNO
Rojo330 ΩD9 ~
Común (larga)—GND
Verde330 ΩD10 ~
Azul330 ΩD11 ~

Código — función miColor (cátodo común)

const int R = 9;
const int G = 10;
const int B = 11;

void miColor(int r, int g, int b) {
  analogWrite(R, r);
  analogWrite(G, g);
  analogWrite(B, b);
}

void setup() {
  pinMode(R, OUTPUT);
  pinMode(G, OUTPUT);
  pinMode(B, OUTPUT);
}

void loop() {
  miColor(255, 0, 0);     delay(800);  // rojo
  miColor(0, 255, 0);     delay(800);  // verde
  miColor(0, 0, 255);     delay(800);  // azul
  miColor(255, 255, 0);   delay(800);  // amarillo
  miColor(0, 255, 255);   delay(800);  // cian
  miColor(255, 118, 192); delay(800);  // rosa
  miColor(255, 255, 255); delay(800);  // blanco
  miColor(0, 0, 0);       delay(400);  // apagado
}
Si rojo y verde están al revés: intercambie D9 y D10 (pasa en KY-009).

Si es ánodo común

void miColor(int r, int g, int b) {
  analogWrite(R, 255 - r);
  analogWrite(G, 255 - g);
  analogWrite(B, 255 - b);
}

Y el común va a 5 V, no a GND. Siguen haciendo falta las 330 Ω.

Qué debe saber al salir. PWM. Por qué una función evita copiar seis veces analogWrite. Cátodo vs ánodo. Por qué 330 Ω.

3 Control de temperatura + ventilador

IoTicos control temperatura IoTicos · KoIdy8euSB0 · DS18B20 + ULN2003 + cooler 12 V · umbral 29 °C

Teoría

Es un lazo abierto con umbral: mide → compara → ON/OFF. No es PWM todavía.

El pin del UNO no puede alimentar un cooler. Hace falta un interruptor de potencia:

  • Video: ULN2003 (7 Darlington, ~500 mA, diodo interno).
  • Taller: S8050 + diodo o el relé Songle, o un canal del L293D.

GND común entre la fuente del motor y el UNO. Sin eso el transistor no cierra el circuito.

DS18B20 habla 1-Wire (un solo cable de datos + pull-up 4.7 kΩ). En el taller, si no hay Dallas, use el DHT11 azul.

DS18B20

DS18B20 TO-92: GND · DATA · VCC. Pull-up 4.7 kΩ de DATA a 5 V.

Lista de materiales — versión video

Cant.Pieza
1Arduino UNO
1DS18B20 + 4.7 kΩ
1ULN2003 (o ULN2004)
1Ventilador 12 V + fuente 12 V

ULN: pin 1 ← D5 del UNO. Pin 16 → negativo del cooler. Pin 8 = GND. Pin 9 = +12 V (diodo interno). Positivo del cooler a +12 V. GND de 12 V unido a GND del UNO.

Código — DS18B20 como el video

Librerías: OneWire y DallasTemperature.

#include <OneWire.h>
#include <DallasTemperature.h>

const int PIN_DATOS = 2;
const int PIN_FAN   = 5;
const float UMBRAL  = 29.0;

OneWire oneWire(PIN_DATOS);
DallasTemperature sensores(&oneWire);

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

void loop() {
  sensores.requestTemperatures();
  float t = sensores.getTempCByIndex(0);
  Serial.print("T= ");
  Serial.print(t);
  if (t > UMBRAL) {
    digitalWrite(PIN_FAN, HIGH);
    Serial.println("  FAN ON");
  } else {
    digitalWrite(PIN_FAN, LOW);
    Serial.println("  FAN OFF");
  }
  delay(800);
}

Versión taller: DHT11 + S8050 + motor 5 V de la hélice azul

QuéA
DHT11 VCC / GND / DATA5 V / GND / D8 (+ pull-up 4.7–10 k si no es módulo)
D5 → 1 kΩ → base S8050emisor GND, colector al − del motor
Motor +5 V de la MB102 (masa común)
Diodo 1N4007cátodo al +, ánodo al colector
#include <DHT.h>
DHT dht(8, DHT11);
const int PIN_FAN = 5;
const float UMBRAL = 29.0;

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

void loop() {
  float t = dht.readTemperature();
  Serial.println(t);
  digitalWrite(PIN_FAN, t > UMBRAL);
  delay(1500);
}
Aire caliente de un secador lejos del USB. No 120 V. Si T sale nan, DATA o pull-up.
Qué debe saber al salir. Umbral. Por qué un pin no mueve un motor. GND común. Diferencia DHT11 (humedad + T, lento) vs DS18B20 (solo T, 1-Wire).

4 Encoder KY-040 + LEDs

KY-040 encoder Hugo Gutiérrez · ByjsW3wuXWI · teoría de cuadratura + ISR. Complemento: Bitwise cap. 22 fnDHQ6YcxTs

Teoría

El KY-040 no es un potenciómetro. Dentro hay dos contactos A (CLK) y B (DT) desfasados 90° (cuadratura). Según cuál cambia primero, sabe si giró a la derecha o a la izquierda. Da vueltas infinitas.

SW es el clic del eje (pulsador a GND).

El video usa una interrupción en DT: el UNO deja lo que está haciendo y atiende el giro. En UNO solo D2 y D3 son INT0 e INT1.

El video pone el display TM1637 en pines 20 y 21: eso es Mega. En UNO esos pines no existen. Aquí el número va al Monitor Serie (y a la LCD si ya la armó). LEDs = sentido.

KY-040

CLK · DT · SW · + · GND. El de la bolsa Keyes del taller.

Conexión KY-040

Lista de materiales

Cant.Pieza
1KY-040
1LED rojo + 330 Ω
1LED verde + 330 Ω
1Arduino UNO
opc.LCD 16×2 o TM1637 de 4 pines (CLK/DIO)

Montaje UNO (no copie 20/21 del video)

KY-040UNOLEDUNO
GND / +GND / 5 VVerde + 330 ΩD5
DTD2 (INT0)Rojo + 330 ΩD6
CLKD4cátodosGND
SWD3 (opcional, resetea)

Código — UNO, interrupción, 0–100, Serie

const int PIN_DT  = 2;
const int PIN_CLK = 4;
const int LED_V   = 5;
const int LED_R   = 6;
const int PIN_SW  = 3;

volatile int valor = 0;
volatile unsigned long t0 = 0;

void giro() {
  if (millis() - t0 < 5) return;   // antirrebote
  t0 = millis();
  if (digitalRead(PIN_CLK) == LOW) {
    valor++;                       // horario
    digitalWrite(LED_R, HIGH);
    digitalWrite(LED_V, LOW);
  } else {
    valor--;                       // antihorario
    digitalWrite(LED_V, HIGH);
    digitalWrite(LED_R, LOW);
  }
  if (valor > 100) valor = 100;
  if (valor < 0)   valor = 0;
}

void setup() {
  pinMode(PIN_DT, INPUT);
  pinMode(PIN_CLK, INPUT);
  pinMode(PIN_SW, INPUT_PULLUP);
  pinMode(LED_V, OUTPUT);
  pinMode(LED_R, OUTPUT);
  attachInterrupt(digitalPinToInterrupt(PIN_DT), giro, FALLING);
  Serial.begin(9600);
}

void loop() {
  static int ultimo = -1;
  if (digitalRead(PIN_SW) == LOW) valor = 0;
  if (valor != ultimo) {
    ultimo = valor;
    Serial.println(valor);
  }
}
Monitor Serie 9600. Derecha: número sube, LED rojo. Izquier
Bitwise Ar · Curso Arduino desde cero

Índice de la saga (86 videos)

Canal: @BitwiseAr · Lista: playlist · Código: GitHub · Sketches 1–12: pegue también bitwise-saga-parte1-elementor.html

Un widget de Elementor no aguanta 86 capítulos con código. Este bloque es el índice. El código para copiar de los primeros 12 (los del taller CTP) va en el otro HTML. En GitHub cada carpeta CapituloN tiene los .txt oficiales.
#TemaVideoCódigo
1Introducción UNOeBVvD85Ml2c—
2IDE + Blink LED 13GUuWgk3dXd0Ejemplo Blink
3Pulsador + LED protoboardBWhup75svIkCap3
4PWM + potenciómetroArvU6pEiQdACap4
5HC-SR04 + Serialmlw3APOUt8UCap5
6Servomotor SG906bPVZg17vKcCap6
7DHT11 / DHT222tdsg_K-oQQCap7
8Módulo relé optoacopladoQ5UkNPgN9OwCap8
9Keypad 4×4 + clave9ligsi5Bgv8Cap9
10LCD 16×2 paraleloJEZiHQY-JPICap10
11PIR HC-SR501eFoa88s6yZYCap11
12LED RGB KY-016 / 009xX8_QvwOJ6ICap12
13Sonido KY-037 / 038wfiSH0CkInECap13
14LDR crepusculard3zcjfjqFxECap14
15Orientación (mercurio)8tZvNRE4rn8Cap15
16Vibración KY-002JF9Ksi7Zb20Cap16
17Joystick KY-023okvUaG2BRBoCap17
18Hall / campo magnéticoQ6f3VA2VsicCap18
19L298N un motor DC63aitq3KTaICap19
20L298N rover 2WDOfJ-nl7PwYACap20
21Interrupciones KY-010up-goNfJ_EYCap21
22Encoder KY-040fnDHQ6YcxTsCap22
23LM35 + LCD5l-o8pl0Y_4Cap23
24Bluetooth HC-05 AT5SmKOUHhmWkCap24
25HC-05 app + LED PWMkSl8SUb5L9ACap25
37MicroSD SPI + DHT loggernNDqRpfEy40Cap37
40RFID RC522LvRfxGTUEpECap40
53Sensor de aguapHmM7-4NKJQCap53
7074HC595 shift registerLFqIA3ZvZE8Cap70
72Arduino IoT CloudMMV-5k_33CICap72
73IoT Cloud + BME280XRjbsPYXn60Cap73

El resto de números (26–36, 38–39, 41–69, 74–86) está en la misma playlist y en la misma carpeta GitHub CapituloN. Abra la playlist y avance capítulo a capítulo.

Material de Bitwise Ar para uso didáctico en clase. Pines del video; si choca con otra práctica del taller, gane la tabla de esa práctica.

Bitwise Ar · Parte 1 · CTP

Capítulos 1 a 12 — video + código

Códigos alineados al repo oficial. Vea el video, arme, pegue. Lista completa: widget del índice.

Cap. 2 — IDE y Blink

Video GUuWgk3dXd0

Instale el IDE, placa UNO, puerto COM. El LED de la placa está en el pin 13.

void setup() {
  pinMode(13, OUTPUT);
}
void loop() {
  digitalWrite(13, HIGH);
  delay(1000);
  digitalWrite(13, LOW);
  delay(1000);
}
Parpadea el LED de la placa. Archivo → Ejemplos → 01.Basics → Blink es lo mismo.

Cap. 3 — Pulsador y LED (el de BWhup75svIk)

Video BWhup75svIk

Protoboard. LED 330 Ω en D3. Pulsador: un lado a 5 V, el otro a D2 y 10 kΩ a GND (pull-down).

PiezaUNO
Pulsador (con 10 k a GND)D2
LED ánodo + 330 ΩD3 · cátodo GND

Programa 1 — mientras pulsa, prende

void setup() {
  pinMode(2, INPUT);
  pinMode(3, OUTPUT);
}
void loop() {
  if (digitalRead(2) == HIGH) digitalWrite(3, HIGH);
  else digitalWrite(3, LOW);
}

Programa 2 — interruptor ON/OFF (oficial Bitwise)

int PULSADOR = 2;
int LED = 3;
int ESTADO = LOW;

void setup() {
  pinMode(PULSADOR, INPUT);
  pinMode(LED, OUTPUT);
  digitalWrite(LED, LOW);
}
void loop() {
  while (digitalRead(PULSADOR) == LOW) { }
  ESTADO = digitalRead(LED);
  digitalWrite(LED, !ESTADO);
  while (digitalRead(PULSADOR) == HIGH) { }
}

Programa 3 — 5 segundos y se apaga

int PULSADOR = 2;
int LED = 3;
void setup() {
  pinMode(PULSADOR, INPUT);
  pinMode(LED, OUTPUT);
  digitalWrite(LED, LOW);
}
void loop() {
  while (digitalRead(PULSADOR) == LOW) { }
  digitalWrite(LED, HIGH);
  delay(5000);
  digitalWrite(LED, LOW);
  while (digitalRead(PULSADOR) == HIGH) { }
}

Cap. 4 — PWM y potenciómetro

Video ArvU6pEiQdA

LED en D3 (~). Pot 10 k: extremos 5 V y GND, cursor A0.

int LED = 3;
int BRILLO;
void setup() {
  pinMode(LED, OUTPUT);
}
void loop() {
  for (BRILLO = 0; BRILLO < 256; BRILLO++) {
    analogWrite(LED, BRILLO);
    delay(15);
  }
  for (BRILLO = 255; BRILLO >= 0; BRILLO--) {
    analogWrite(LED, BRILLO);
    delay(15);
  }
}

Con potenciómetro:

void loop() {
  analogWrite(3, analogRead(A0) / 4);
}
analogRead 0–1023. analogWrite 0–255. Por eso se divide entre 4.

Cap. 5 — HC-SR04

Video mlw3APOUt8U

Trig D9, Echo D10, VCC 5 V, GND.

const int TRIG = 9, ECHO = 10;
void setup() {
  pinMode(TRIG, OUTPUT);
  pinMode(ECHO, INPUT);
  Serial.begin(9600);
}
void loop() {
  digitalWrite(TRIG, LOW); delayMicroseconds(2);
  digitalWrite(TRIG, HIGH); delayMicroseconds(10);
  digitalWrite(TRIG, LOW);
  long us = pulseIn(ECHO, HIGH);
  Serial.print(us / 58);
  Serial.println(" cm");
  delay(200);
}

Cap. 6 — Servo SG90

Video 6bPVZg17vKc

Señal naranja D9. Rojo 5 V (mejor fuente extra, masa común). Café GND.

#include <Servo.h>
Servo servo;
void setup() {
  servo.attach(9);
}
void loop() {
  servo.write(0); delay(1000);
  servo.write(90); delay(1000);
  servo.write(180); delay(1000);
}

Cap. 7 — DHT11 / DHT22

Video 2tdsg_K-oQQ

Librería DHT de Adafruit. DATA en D8 + pull-up 4.7–10 k si no es módulo.

#include <DHT.h>
DHT dht(8, DHT11);
void setup() {
  Serial.begin(9600);
  dht.begin();
}
void loop() {
  Serial.print(dht.readTemperature());
  Serial.print(" C  ");
  Serial.print(dht.readHumidity());
  Serial.println(" %");
  delay(2000);
}

Cap. 8 — Módulo relé

Video Q5UkNPgN9Ow

IN en D3. Muchos módulos activan en LOW. En aula: LED en COM/NO, no 120 V.

void setup() {
  pinMode(3, OUTPUT);
  digitalWrite(3, HIGH);
}
void loop() {
  digitalWrite(3, LOW); delay(1000);
  digitalWrite(3, HIGH); delay(1000);
}

Cap. 9 — Keypad 4×4

Video 9ligsi5Bgv8

Librería Keypad. Filas D2–D5, columnas D6–D9 (ajuste si el video usa otros).

#include <Keypad.h>
const byte FILAS = 4, COLS = 4;
char keys[FILAS][COLS] = {
  {'1','2','3','A'},
  {'4','5','6','B'},
  {'7','8','9','C'},
  {'*','0','#','D'}
};
byte pinesF[FILAS] = {2, 3, 4, 5};
byte pinesC[COLS]  = {6, 7, 8, 9};
Keypad teclado = Keypad(makeKeymap(keys), pinesF, pinesC, FILAS, COLS);
void setup() { Serial.begin(9600); }
void loop() {
  char k = teclado.getKey();
  if (k) Serial.println(k);
}

Cap. 10 — LCD 16×2 paralelo

Video JEZiHQY-JPI

RS D12, E D11, D4–D7 = D5 D4 D3 D2. RW a GND. V0 a pot 10 k. A/K backlight 220 Ω.

#include <LiquidCrystal.h>
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
void setup() {
  lcd.begin(16, 2);
  lcd.print("Hola CTP");
}
void loop() {
  lcd.setCursor(0, 1);
  lcd.print(millis() / 1000);
}

Cap. 11 — PIR HC-SR501

Video eFoa88s6yZY

OUT D2. Relé módulo IN D3 (activo LOW). Calibración 20 s.

void setup() {
  pinMode(2, INPUT);
  pinMode(3, OUTPUT);
  digitalWrite(3, HIGH);
  delay(20000);
}
void loop() {
  if (digitalRead(2) == HIGH) {
    digitalWrite(3, LOW);
    delay(4000);
    digitalWrite(3, HIGH);
  }
}

Cap. 12 — LED RGB

Video xX8_QvwOJ6I

Cátodo común: R D9, G D10, B D11, común GND, 330 Ω por color.

void color(int r, int g, int b) {
  analogWrite(9, r);
  analogWrite(10, g);
  analogWrite(11, b);
}
void setup() {}
void loop() {
  color(255, 0, 0); delay(600);
  color(0, 255, 0); delay(600);
  color(0, 0, 255); delay(600);
  color(255, 255, 0); delay(600);
}

Ánodo común: común a 5 V y analogWrite(pin, 255 - valor).

Caps. 13 en adelante: widget del índice + carpeta GitHub del capítulo. No meta 86 sketches en el mismo widget: Elementor lo corta.

Fuente: Bitwise Ar / github.com/bitwiseAr/Curso-Arduino-desde-cero. Uso didáctico CTP.

Bitwise Ar · Parte 2 · CTP

Capítulos 13 a 25 — video + código

Sonido, LDR, hall, L298N, encoder, LM35, Bluetooth. Repo oficial en cada título.

Cap. 13 — Micrófono KY-037 / KY-038

wfiSH0CkInE

D0 del módulo → D2. LED + 330 Ω en D3. Ajuste el preset hasta que el LED del módulo parpadee al chasquear.

int MIC = 2, LED = 3, VALOR, ESTADO;
void setup() {
  pinMode(MIC, INPUT);
  pinMode(LED, OUTPUT);
}
void loop() {
  VALOR = digitalRead(MIC);
  if (VALOR == HIGH) {
    ESTADO = digitalRead(LED);
    digitalWrite(LED, !ESTADO);
    delay(500);
  }
}
Un aplauso cambia el LED. Si no dispara, gire el preset.

Cap. 14 — LDR crepuscular

d3zcjfjqFxE

KY-018 o LDR a A0 (con divisor). LED en D3. Valor bajo = oscuro (cubra el LDR).

int SENSOR = 0, LED = 3, VALOR;
void setup() { pinMode(LED, OUTPUT); }
void loop() {
  VALOR = analogRead(SENSOR);
  if (VALOR < 200) {
    digitalWrite(LED, HIGH);
    delay(1000);
  }
  digitalWrite(LED, LOW);
}
Calibre el 200 con Monitor Serie: Serial.println(analogRead(A0));

Cap. 15 — Inclinación (mercurio / SW-520D)

8tZvNRE4rn8

Salida digital a D2. Incline el módulo 90°.

void setup() {
  pinMode(2, INPUT);
  pinMode(3, OUTPUT);
}
void loop() {
  digitalWrite(3, digitalRead(2));
}

Cap. 16 — Vibración KY-002

JF9Ksi7Zb20

S → D2. El KY-002 pone LOW al golpear. El código invierte para prender el LED.

int SENSOR = 2, LED = 3, ESTADO;
void setup() {
  pinMode(SENSOR, INPUT);
  pinMode(LED, OUTPUT);
}
void loop() {
  ESTADO = digitalRead(SENSOR);
  digitalWrite(LED, !ESTADO);
}

Cap. 17 — Joystick KY-023

okvUaG2BRBo
KY-023UNO
+ / GND5 V / GND
VRX / VRYA0 / A1
SWD10
4 LED PWMD3 izq · D5 der · D6 abajo · D9 arriba · D11 clic
int X, Y, SW;
void setup() {
  pinMode(3, OUTPUT); pinMode(5, OUTPUT);
  pinMode(6, OUTPUT); pinMode(9, OUTPUT);
  pinMode(11, OUTPUT); pinMode(10, INPUT);
}
void loop() {
  X = analogRead(A0); Y = analogRead(A1); SW = digitalRead(10);
  analogWrite(3, (X < 480) ? map(X, 0, 480, 255, 0) : 0);
  analogWrite(5, (X > 520) ? map(X, 520, 1023, 0, 255) : 0);
  analogWrite(6, (Y < 480) ? map(Y, 0, 480, 255, 0) : 0);
  analogWrite(9, (Y > 520) ? map(Y, 520, 1023, 0, 255) : 0);
  digitalWrite(11, !SW);
}

Cap. 18 — Hall (campo magnético)

Q6f3VA2Vsic

D0 → D2, LED D3. Acerque un imán a la cara marcada.

void setup() {
  pinMode(2, INPUT);
  pinMode(3, OUTPUT);
}
void loop() {
  digitalWrite(3, digitalRead(2));
}

Cap. 19 — L298N un motor DC

63aitq3KTaI
L298NUNO / fuente
IN1 / IN2 / ENAD2 / D3 / D5 (~)
+12 V motorfuente 12 V (no el 5 V del UNO)
GNDGND común con el UNO
Sin GND común el motor no gira. ENA en HIGH o PWM. No 120 V.
int IN1 = 2, IN2 = 3, ENA = 5;
void setup() {
  pinMode(IN1, OUTPUT); pinMode(IN2, OUTPUT); pinMode(ENA, OUTPUT);
}
void loop() {
  digitalWrite(ENA, HIGH);
  digitalWrite(IN1, LOW); digitalWrite(IN2, HIGH); delay(3000);
  digitalWrite(ENA, LOW); delay(2000);
  digitalWrite(ENA, HIGH);
  digitalWrite(IN1, HIGH); digitalWrite(IN2, LOW); delay(3000);
  digitalWrite(ENA, LOW); delay(2000);
}

Cap. 20 — L298N rover 2WD

OfJ-nl7PwYA

Motor B: IN3 D7, IN4 D8, ENB D6. Funciones adelante / atrás / giro.

void motor(int a1, int a2, int b1, int b2) {
  digitalWrite(2, a1); digitalWrite(3, a2);
  digitalWrite(7, b1); digitalWrite(8, b2);
}
void setup() {
  pinMode(2, OUTPUT); pinMode(3, OUTPUT); pinMode(5, OUTPUT);
  pinMode(7, OUTPUT); pinMode(8, OUTPUT); pinMode(6, OUTPUT);
  digitalWrite(5, HIGH); digitalWrite(6, HIGH);
}
void loop() {
  motor(LOW, HIGH, LOW, HIGH); delay(1500);  // adelante
  motor(LOW, LOW, LOW, LOW);   delay(400);
  motor(HIGH, LOW, HIGH, LOW); delay(1500);  // atras
  motor(LOW, LOW, LOW, LOW);   delay(1000);
}

Cap. 21 — Interrupción externa KY-010

up-goNfJ_EY

Señal del fotointerruptor en D2 (INT0). Pase un objeto por la ranura.

volatile int CONTADOR = 0;
int ANTERIOR = 0;
void setup() {
  Serial.begin(9600);
  attachInterrupt(digitalPinToInterrupt(2), sensor, RISING);
}
void loop() {
  if (ANTERIOR != CONTADOR) {
    Serial.println(CONTADOR);
    ANTERIOR = CONTADOR;
  }
}
void sensor() { CONTADOR++; }
Monitor 9600. Cada paso por la ranura suma 1.

Cap. 22 — Encoder KY-040

fnDHQ6YcxTs

DT → D2 (INT0), CLK → D4, + 5 V, GND. Límite 0–100.

int A = 2, B = 4, ANTERIOR = 50;
volatile int POSICION = 50;
void setup() {
  pinMode(A, INPUT); pinMode(B, INPUT);
  Serial.begin(9600);
  attachInterrupt(digitalPinToInterrupt(A), encoder, LOW);
  Serial.println("Listo");
}
void loop() {
  if (POSICION != ANTERIOR) {
    Serial.println(POSICION);
    ANTERIOR = POSICION;
  }
}
void encoder() {
  static unsigned long t0 = 0;
  unsigned long t = millis();
  if (t - t0 > 5) {
    if (digitalRead(B) == HIGH) POSICION++;
    else POSICION--;
    POSICION = min(100, max(0, POSICION));
    t0 = t;
  }
}

Cap. 23 — LM35 + Serial (y LCD en el video)

5l-o8pl0Y_4

LM35: VCC 5 V, GND, Vout → A0. 10 mV/°C.

int SENSOR;
float TEMPERATURA;
void setup() { Serial.begin(9600); }
void loop() {
  SENSOR = analogRead(A0);
  TEMPERATURA = ((SENSOR * 5000.0) / 1023) / 10;
  Serial.println(TEMPERATURA, 1);
  delay(1000);
}
LCD: mismos pines del cap. 10. lcd.print(TEMPERATURA);

Cap. 24 — Bluetooth HC-05 (comandos AT)

5SmKOUHhmWk

HC-05 TX → D10 (RX UNO), RX → D11 (TX UNO) con divisor 5 V→3.3 V en RX del módulo. VCC 5 V. Modo AT: botón EN al encender, 38400 baud.

#include <SoftwareSerial.h>
SoftwareSerial miBT(10, 11);
void setup() {
  Serial.begin(9600);
  Serial.println("Listo");
  miBT.begin(38400);
}
void loop() {
  if (miBT.available()) Serial.write(miBT.read());
  if (Serial.available()) miBT.write(Serial.read());
}
En el Monitor: AT y Enter. Responde OK si está en modo AT.

Cap. 25 — HC-05 + app (LED / PWM)

kSl8SUb5L9A

Mismo cableado. App Serial Bluetooth. Envíe 1 / 0 o un número 0–255.

#include <SoftwareSerial.h>
SoftwareSerial miBT(10, 11);
void setup() {
  pinMode(3, OUTPUT);
  miBT.begin(9600);
}
void loop() {
  if (miBT.available()) {
    char c = miBT.read();
    if (c == '1') digitalWrite(3, HIGH);
    if (c == '0') digitalWrite(3, LOW);
  }
}

Fuente: Bitwise Ar. Caps. 26+ en el índice y en github.com/bitwiseAr/Curso-Arduino-desde-cero/tree/master/CapituloN