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 |
|---|---|
| 1 | Arduino UNO |
| 1 | LED RGB 4 patas o módulo KY-016 (cátodo) / KY-009 (ánodo) |
| 3 | 330 Ω (si el LED es suelto; el módulo ya las trae) |
| 4 | Jumpers |
Montaje — cátodo común (P1 a P3)
| LED / módulo | UNO |
|---|---|
| R (rojo) | D9 ~ |
| G (verde) | D10 ~ |
| B (azul) | D11 ~ |
| Común − | GND |
~. 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);
}
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);
}
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);
}
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 |
|---|---|
| 1 | Arduino UNO |
| 1 | KY-037 o KY-038 (4 pines: G + A0 D0) |
| 1 | LED + 330 Ω |
| — | Destornillador pequeño para el preset |
Montaje
| Módulo | UNO |
|---|---|
| G | GND |
| + | 5 V |
| D0 | D2 |
| A0 | A0 (solo P2) |
| LED ánodo + 330 Ω | D3 · cátodo a GND |
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);
}
}
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);
}
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.
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 Ω.
Larga = +. Corta y lado plano = −. La resistencia va en serie, da igual antes o después del LED.
Lista de materiales
| Cant. | Pieza | De la caja |
|---|---|---|
| 1 | Arduino UNO + cable USB | |
| 1 | Protoboard | |
| 1 | LED 5 mm (rojo o verde) | pata larga = ánodo |
| 1 | Resistencia 220 Ω o 330 Ω | rojo-rojo-marrón o naranja-naranja-marrón |
| 2 | Jumpers macho-macho | uno al pin, uno a GND |
Montaje en protoboard
- LED: pata larga en una fila (ejemplo fila 10, lado derecho). Pata corta en la fila 12. No en la misma.
- Resistencia: de la fila 10 a otra fila libre (ejemplo fila 8).
- Jumper amarillo o rojo: pin D8 del UNO → fila 8.
- Jumper negro: GND del UNO → fila 12 (cátodo).
| Qué | A |
|---|---|
| Ánodo LED (larga) | 220 Ω → pin D8 |
| Cátodo LED (corta) | GND |
Ánodo → 220 Ω → pin. Cátodo → GND. Las dos patas del LED en filas distintas.
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
}
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);
}
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é ve | Causa típica |
|---|---|
| Nada | LED al revés. Déle vuelta. |
| Nada | Las dos patas en la misma fila de 5 huecos. |
| Nada | Jumper en D7 y el código dice D8. |
| Muy tenue | Resistencia de 10 kΩ o más. Ponga 220–330 Ω. |
| Se apaga al tocar | Pata mal clavada. Empuje hasta el fondo. |
| IDE no sube | Herramientas → Placa UNO y Puerto COM correcto. |
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).
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é aprende | Video | En el taller |
|---|---|---|---|
| 1 | Sensor pasivo IR + relé | Bitwise cap. 11 | PIR de cúpula + Songle / módulo relé |
| 2 | Mezcla RGB y función | Bitwise cap. 12 | LED RGB de 4 patas + 3× 330 Ω |
| 3 | Umbral y carga 12 V | IoTicos | DS18B20 o DHT11 + transistor / relé + ventilador |
| 4 | Cuadratura e interrupción | Hugo / KY-040 | KY-040 + 2 LED. Display opcional |
1 PIR HC-SR501 + relé
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”.
VCC · OUT · GND. Jumper H/L. Foto de referencia del módulo.
Lista de materiales
| Cant. | Pieza | Nota |
|---|---|---|
| 1 | Arduino UNO | |
| 1 | HC-SR501 (cúpula blanca) | el de la foto del taller |
| 1 | Módulo relé 5 V o Songle + S8050 + 1 kΩ + 1N4007 | Bitwise usa módulo (activo en LOW) |
| 1 | LED + 220 Ω | carga de aula; no 120 V |
| — | Jumpers |
Montaje (pines del video)
| PIR | UNO | Módulo relé | UNO |
|---|---|---|---|
| VCC | 5 V | VCC | 5 V |
| GND | GND | GND | GND |
| OUT | D2 | IN | D3 |
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
}
}
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);
}
}
2 LED RGB — cátodo / ánodo y función
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).
Cátodo común: común a GND, cada color con 330 Ω a un pin PWM.
Si el dibujo junta R, G y B al (+), es ánodo común.
Lista de materiales
| Cant. | Pieza |
|---|---|
| 1 | LED RGB 4 patas (cátodo común) o módulo KY-016 / KY-009 |
| 3 | 330 Ω (si el módulo no las trae; KY-009 no las trae) |
| 1 | Arduino 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)
| Pata | Vía | UNO |
|---|---|---|
| Rojo | 330 Ω | D9 ~ |
| Común (larga) | — | GND |
| Verde | 330 Ω | D10 ~ |
| Azul | 330 Ω | 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 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 Ω.
analogWrite. Cátodo vs ánodo. Por qué 330 Ω.3 Control de temperatura + ventilador
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 TO-92: GND · DATA · VCC. Pull-up 4.7 kΩ de DATA a 5 V.
Lista de materiales — versión video
| Cant. | Pieza |
|---|---|
| 1 | Arduino UNO |
| 1 | DS18B20 + 4.7 kΩ |
| 1 | ULN2003 (o ULN2004) |
| 1 | Ventilador 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 / DATA | 5 V / GND / D8 (+ pull-up 4.7–10 k si no es módulo) |
| D5 → 1 kΩ → base S8050 | emisor GND, colector al − del motor |
| Motor + | 5 V de la MB102 (masa común) |
| Diodo 1N4007 | cá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);
}
4 Encoder KY-040 + LEDs
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.
CLK · DT · SW · + · GND. El de la bolsa Keyes del taller.
Lista de materiales
| Cant. | Pieza |
|---|---|
| 1 | KY-040 |
| 1 | LED rojo + 330 Ω |
| 1 | LED verde + 330 Ω |
| 1 | Arduino UNO |
| opc. | LCD 16×2 o TM1637 de 4 pines (CLK/DIO) |
Montaje UNO (no copie 20/21 del video)
| KY-040 | UNO | LED | UNO |
|---|---|---|---|
| GND / + | GND / 5 V | Verde + 330 Ω | D5 |
| DT | D2 (INT0) | Rojo + 330 Ω | D6 |
| CLK | D4 | cátodos | GND |
| SW | D3 (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);
}
}
Índice de la saga (86 videos)
Canal: @BitwiseAr · Lista: playlist · Código: GitHub · Sketches 1–12: pegue también bitwise-saga-parte1-elementor.html
CapituloN tiene los .txt oficiales.| # | Tema | Video | Código |
|---|---|---|---|
| 1 | Introducción UNO | eBVvD85Ml2c | — |
| 2 | IDE + Blink LED 13 | GUuWgk3dXd0 | Ejemplo Blink |
| 3 | Pulsador + LED protoboard | BWhup75svIk | Cap3 |
| 4 | PWM + potenciómetro | ArvU6pEiQdA | Cap4 |
| 5 | HC-SR04 + Serial | mlw3APOUt8U | Cap5 |
| 6 | Servomotor SG90 | 6bPVZg17vKc | Cap6 |
| 7 | DHT11 / DHT22 | 2tdsg_K-oQQ | Cap7 |
| 8 | Módulo relé optoacoplado | Q5UkNPgN9Ow | Cap8 |
| 9 | Keypad 4×4 + clave | 9ligsi5Bgv8 | Cap9 |
| 10 | LCD 16×2 paralelo | JEZiHQY-JPI | Cap10 |
| 11 | PIR HC-SR501 | eFoa88s6yZY | Cap11 |
| 12 | LED RGB KY-016 / 009 | xX8_QvwOJ6I | Cap12 |
| 13 | Sonido KY-037 / 038 | wfiSH0CkInE | Cap13 |
| 14 | LDR crepuscular | d3zcjfjqFxE | Cap14 |
| 15 | Orientación (mercurio) | 8tZvNRE4rn8 | Cap15 |
| 16 | Vibración KY-002 | JF9Ksi7Zb20 | Cap16 |
| 17 | Joystick KY-023 | okvUaG2BRBo | Cap17 |
| 18 | Hall / campo magnético | Q6f3VA2Vsic | Cap18 |
| 19 | L298N un motor DC | 63aitq3KTaI | Cap19 |
| 20 | L298N rover 2WD | OfJ-nl7PwYA | Cap20 |
| 21 | Interrupciones KY-010 | up-goNfJ_EY | Cap21 |
| 22 | Encoder KY-040 | fnDHQ6YcxTs | Cap22 |
| 23 | LM35 + LCD | 5l-o8pl0Y_4 | Cap23 |
| 24 | Bluetooth HC-05 AT | 5SmKOUHhmWk | Cap24 |
| 25 | HC-05 app + LED PWM | kSl8SUb5L9A | Cap25 |
| 37 | MicroSD SPI + DHT logger | nNDqRpfEy40 | Cap37 |
| 40 | RFID RC522 | LvRfxGTUEpE | Cap40 |
| 53 | Sensor de agua | pHmM7-4NKJQ | Cap53 |
| 70 | 74HC595 shift register | LFqIA3ZvZE8 | Cap70 |
| 72 | Arduino IoT Cloud | MMV-5k_33CI | Cap72 |
| 73 | IoT Cloud + BME280 | XRjbsPYXn60 | Cap73 |
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.
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 GUuWgk3dXd0Instale 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);
}
Cap. 3 — Pulsador y LED (el de BWhup75svIk)
Video BWhup75svIkProtoboard. LED 330 Ω en D3. Pulsador: un lado a 5 V, el otro a D2 y 10 kΩ a GND (pull-down).
| Pieza | UNO |
|---|---|
| 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 ArvU6pEiQdALED 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);
}
Cap. 5 — HC-SR04
Video mlw3APOUt8UTrig 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 6bPVZg17vKcSeñ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-oQQLibrerí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 Q5UkNPgN9OwIN 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 9ligsi5Bgv8Librerí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-JPIRS 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 eFoa88s6yZYOUT 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_QvwOJ6ICá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).
Fuente: Bitwise Ar / github.com/bitwiseAr/Curso-Arduino-desde-cero. Uso didáctico 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
wfiSH0CkInED0 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);
}
}
Cap. 14 — LDR crepuscular
d3zcjfjqFxEKY-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);
}
Cap. 15 — Inclinación (mercurio / SW-520D)
8tZvNRE4rn8Salida 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
JF9Ksi7Zb20S → 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-023 | UNO |
|---|---|
| + / GND | 5 V / GND |
| VRX / VRY | A0 / A1 |
| SW | D10 |
| 4 LED PWM | D3 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)
Q6f3VA2VsicD0 → 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| L298N | UNO / fuente |
|---|---|
| IN1 / IN2 / ENA | D2 / D3 / D5 (~) |
| +12 V motor | fuente 12 V (no el 5 V del UNO) |
| GND | GND común con el UNO |
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-nl7PwYAMotor 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_EYSeñ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++; }
Cap. 22 — Encoder KY-040
fnDHQ6YcxTsDT → 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_4LM35: 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);
}
Cap. 24 — Bluetooth HC-05 (comandos AT)
5SmKOUHhmWkHC-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());
}
Cap. 25 — HC-05 + app (LED / PWM)
kSl8SUb5L9AMismo 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