Arduino · Proyectos

TMP36 Vs (patilla izquierda) → 5V de la UnoAlimenta el sensor a 5 V, la misma referencia que usa la fórmula. TMP36 GND (patilla derecha) → GND de la UnoMasa común con la placa. TMP36 Vout (patilla central) → A0Salida analógica, unos 750 mV a 25 °C. Sin resistencia en serie.

// AP-BIR-01 TMP36 en A0. Referencia 5 V. Monitor serie 9600.
const int pinTmp = A0;

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

void loop() {
  int lectura = analogRead(pinTmp);
  // (analogRead * 5.0 / 1023.0 - 0.5) * 100
  float tempC = (lectura * 5.0 / 1023.0 - 0.5) * 100.0;
  Serial.print("Temperatura C: ");
  Serial.println(tempC, 1);
  delay(500);
}

DHT11 VCC → 5V de la UnoEl DHT11 de esta práctica va a 5 V. DHT11 GND → GND de la UnoMasa común. DHT11 DATA → D2Único pin de datos. En el programa es el argumento del constructor DHT. Resistencia 10k → DATA (D2) y 5VPull-up a 5 V. Sin ella muchas lecturas salen no válidas. No es un segundo sensor.

// AP-BIR-02 DHT11 en D2 con pull-up de 10k a 5 V.
// Librería DHT: instálala en el gestor del IDE. No lleva URL.
#include <DHT.h>

const int pinDht = 2;
DHT dht(pinDht, DHT11);

void setup() {
  Serial.begin(9600);
  dht.begin();
  delay(2000);
}

void loop() {
  float t = dht.readTemperature();
  float h = dht.readHumidity();
  if (isnan(t) || isnan(h)) {
    Serial.println("Lectura no valida: revisa DATA, la pull-up y el tipo DHT11");
  } else {
    Serial.print("Temperatura C: ");
    Serial.print(t, 1);
    Serial.print("  Humedad %: ");
    Serial.println(h, 1);
  }
  delay(2000);
}

HC-SR04 VCC → 5V de la UnoEste módulo pide 5 V. HC-SR04 GND → GND de la UnoMasa común. HC-SR04 trig → D9Salida de la placa: pulso de unos 10 microsegundos. HC-SR04 echo → D8Entrada de la placa. No lo cruces con el trig.

// AP-BIR-03 HC-SR04 sin librería. Trig en D9, echo en D8.
const int pinTrig = 9;
const int pinEcho = 8;

void setup() {
  Serial.begin(9600);
  pinMode(pinTrig, OUTPUT);
  pinMode(pinEcho, INPUT);
  digitalWrite(pinTrig, LOW);
}

void loop() {
  digitalWrite(pinTrig, LOW);
  delayMicroseconds(2);
  digitalWrite(pinTrig, HIGH);
  delayMicroseconds(10);
  digitalWrite(pinTrig, LOW);

  long duracion = pulseIn(pinEcho, HIGH, 30000UL);
  float cm = duracion * 0.0343 / 2.0;
  if (duracion == 0) {
    Serial.println("Sin eco: fuera de alcance o trig y echo cruzados");
  } else {
    Serial.print("Distancia cm: ");
    Serial.println(cm, 1);
  }
  delay(200);
}

Servo cable de alimentación → 5V de la UnoSolo un servo pequeño. Si la placa se reinicia, pasa esta alimentación a una fuente de 5 V aparte. Servo cable de masa → GND de la UnoMasa común, también si más adelante alimentas el servo por fuera. Servo cable de señal → D9attach en el pin 9. Servo.h usa el temporizador de los pines 9 y 10. Fuente externa de 5 V, si hace falta → GND común con la Uno, positivo solo al servoNo unas el positivo externo al pin de 5 V de la placa si esa fuente es una pila o un cargador.

// AP-BIR-04 Barrido 0 a 180 con Servo.h del núcleo. Señal en D9.
#include <Servo.h>

Servo barrido;
const int pinServo = 9;

void setup() {
  barrido.attach(pinServo);
}

void loop() {
  for (int ang = 0; ang <= 180; ang += 1) {
    barrido.write(ang);
    delay(15);
  }
  for (int ang = 180; ang >= 0; ang -= 1) {
    barrido.write(ang);
    delay(15);
  }
}

Extremo del potenciómetro → 5V de la UnoUn extremo del elemento resistivo, no el cursor. Otro extremo del potenciómetro → GND de la UnoSi cambias los extremos, el giro se invierte y sigue siendo válido. Cursor del potenciómetro → A0Patilla central en un potenciómetro de panel. Servo alimentación → 5V de la UnoUn solo SG90. Servo masa → GND de la UnoMisma masa que el potenciómetro. Servo señal → D9attach en el pin 9. No uses este pin como PWM manual a la vez.

// AP-BIR-05 Servo en D9 gobernado por potenciómetro en A0.
#include <Servo.h>

Servo brazo;
const int pinServo = 9;
const int pinPot = A0;

void setup() {
  brazo.attach(pinServo);
}

void loop() {
  int lectura = analogRead(pinPot);
  int angulo = map(lectura, 0, 1023, 0, 180);
  brazo.write(angulo);
  delay(15);
}

Segmento a → D2 a través de resistenciaBit 0 de la máscara. Segmento b → D3 a través de resistenciaBit 1. Segmento c → D4 a través de resistenciaBit 2. Segmento d → D5 a través de resistenciaBit 3. Segmento e → D6 a través de resistenciaBit 4. Segmento f → D7 a través de resistenciaBit 5. Segmento g → D8 a través de resistenciaBit 6, la barra central. Cátodo común del display → GND de la UnoEn cátodo común la masa es común. No la lleves a 5 V. Punto decimal → sin conectarEsta práctica no usa el punto. Si lo pruebas, también lleva resistencia.

// AP-BIR-06 Un dígito, cátodo común.
// Segmentos a b c d e f g en D2 D3 D4 D5 D6 D7 D8.
const uint8_t pinSeg[7] = {2, 3, 4, 5, 6, 7, 8};
const uint8_t DIGITO = 5; // cámbialo por 0..9
const uint8_t mascaraDigito[10] = {
  0b00111111, // 0
  0b00000110, // 1
  0b01011011, // 2
  0b01001111, // 3
  0b01100110, // 4
  0b01101101, // 5
  0b01111101, // 6
  0b00000111, // 7
  0b01111111, // 8
  0b01101111  // 9
};

void mostrar(uint8_t mascara) {
  for (uint8_t i = 0; i < 7; i++) {
    if (mascara & (1 << i)) {
      digitalWrite(pinSeg[i], HIGH);
    } else {
      digitalWrite(pinSeg[i], LOW);
    }
  }
}

void setup() {
  for (uint8_t i = 0; i < 7; i++) {
    pinMode(pinSeg[i], OUTPUT);
  }
  mostrar(mascaraDigito[DIGITO]);
}

void loop() {
  // El dígito se queda fijo. Cambia DIGITO y vuelve a cargar.
}

Segmento a → D2 a través de resistenciaBit 0. Segmento b → D3 a través de resistenciaBit 1. Segmento c → D4 a través de resistenciaBit 2. Segmento d → D5 a través de resistenciaBit 3. Segmento e → D6 a través de resistenciaBit 4. Segmento f → D7 a través de resistenciaBit 5. Segmento g → D8 a través de resistenciaBit 6. Cátodo común → GND de la UnoComún a masa en este display.

// AP-BIR-07 Contador 0 a 9. Cátodo común. Segmentos en D2..D8.
// El ritmo lo lleva millis, no un delay que bloquee el bucle.
const uint8_t pinSeg[7] = {2, 3, 4, 5, 6, 7, 8};
const uint8_t mascaraDigito[10] = {
  0b00111111, 0b00000110, 0b01011011, 0b01001111, 0b01100110,
  0b01101101, 0b01111101, 0b00000111, 0b01111111, 0b01101111
};
const unsigned long intervalo = 700;
unsigned long marca = 0;
uint8_t n = 0;

void mostrar(uint8_t mascara) {
  for (uint8_t i = 0; i < 7; i++) {
    digitalWrite(pinSeg[i], (mascara & (1 << i)) ? HIGH : LOW);
  }
}

void setup() {
  for (uint8_t i = 0; i < 7; i++) {
    pinMode(pinSeg[i], OUTPUT);
  }
  mostrar(mascaraDigito[0]);
  marca = millis();
}

void loop() {
  unsigned long ahora = millis();
  if (ahora - marca >= intervalo) {
    marca = ahora;
    n++;
    if (n > 9) {
      n = 0;
    }
    mostrar(mascaraDigito[n]);
  }
}

74HC595 DS (patilla 14) → D11Datos serie. En el programa es el primer argumento de shiftOut. 74HC595 SHCP (patilla 11) → D12Reloj de desplazamiento. Segundo argumento de shiftOut. 74HC595 STCP (patilla 12) → D8Cerrojo. Pulso LOW-HIGH después de shiftOut. 74HC595 VCC (patilla 16) → 5V de la UnoAlimentación del chip. 74HC595 GND (patilla 8) → GND de la UnoMasa del chip y de los cátodos de los LED. 74HC595 OE (patilla 13) a GND y MR (patilla 10) a 5V → habilitar salidas y no resetearOE a masa enciende las salidas. MR a masa las borra siempre: tiene que ir a 5 V.

// AP-BIR-08 74HC595 sin librería.
// DS D11, SHCP D12, STCP D8. OE a GND, MR a 5 V.
const int pinDatos = 11;
const int pinReloj = 12;
const int pinLatch = 8;

void publicar(uint8_t valor) {
  digitalWrite(pinLatch, LOW);
  shiftOut(pinDatos, pinReloj, MSBFIRST, valor);
  digitalWrite(pinLatch, HIGH);
}

void setup() {
  pinMode(pinDatos, OUTPUT);
  pinMode(pinReloj, OUTPUT);
  pinMode(pinLatch, OUTPUT);
  publicar(0);
}

void loop() {
  for (uint8_t i = 0; i < 8; i++) {
    publicar((uint8_t)(1 << i));
    delay(180);
  }
}

Fila 1 del teclado → D2Salida. En reposo HIGH; se pone a LOW para explorar esa fila. Fila 2 del teclado → D3Salida. Fila 3 del teclado → D4Salida. Fila 4 del teclado → D5Salida. Columna 1 del teclado → D6Entrada INPUT_PULLUP. Tecla pulsada: LOW. Columna 2 del teclado → D7Entrada INPUT_PULLUP. Columna 3 del teclado → D8Entrada INPUT_PULLUP. Columna 4 del teclado → D9Entrada INPUT_PULLUP. Mazo de la membrana → orden de filas y luego columnasHay membranas con las columnas primero. Si las letras no coinciden, no cambies la tabla: gira el mazo.

// AP-BIR-09 Teclado 4x4 sin librería Keypad.
// Filas D2-D5 salidas. Columnas D6-D9 INPUT_PULLUP.
const uint8_t filas[4] = {2, 3, 4, 5};
const uint8_t columnas[4] = {6, 7, 8, 9};
const char teclas[4][4] = {
  {'1', '2', '3', 'A'},
  {'4', '5', '6', 'B'},
  {'7', '8', '9', 'C'},
  {'*', '0', '#', 'D'}
};

void setup() {
  Serial.begin(9600);
  for (uint8_t f = 0; f < 4; f++) {
    pinMode(filas[f], OUTPUT);
    digitalWrite(filas[f], HIGH);
  }
  for (uint8_t c = 0; c < 4; c++) {
    pinMode(columnas[c], INPUT_PULLUP);
  }
}

void loop() {
  for (uint8_t f = 0; f < 4; f++) {
    digitalWrite(filas[f], LOW);
    for (uint8_t c = 0; c < 4; c++) {
      if (digitalRead(columnas[c]) == LOW) {
        Serial.println(teclas[f][c]);
        delay(250);
      }
    }
    digitalWrite(filas[f], HIGH);
  }
}

Patilla de señal del zumbador pasivo → D8tone usa este pin. No hace falta PWM manual. Patilla de masa del zumbador → GND de la UnoEl retorno del sonido es masa, no un segundo pin. Zumbador de tres patillas, si el tuyo lo es → VCC a 5V, señal a D8, GND a masaNo pongas 5 V en D8. En un módulo de tres hilos la nota sigue saliendo por la patilla de señal.

// AP-BIR-10 Escala de do mayor en zumbador pasivo, pin D8.
const int pinZ = 8;
const int notas[] = {262, 294, 330, 349, 392, 440, 494, 523};
const int nNotas = 8;

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

void loop() {
  for (int i = 0; i < nNotas; i++) {
    tone(pinZ, notas[i], 280);
    delay(340);
    noTone(pinZ);
    delay(40);
  }
  delay(700);
}

Señal del zumbador pasivo → D8Mismo pin que tone en el programa. Masa del zumbador → GND de la UnoRetorno. Módulo de tres patillas → VCC a 5V si el módulo lo exigeLa melodía no sale por VCC. VCC solo alimenta el módulo; la nota va por D8.

// AP-BIR-11 Melodía en dos arrays. Zumbador pasivo en D8.
// Un 0 en notas[] es un silencio de la duración indicada.
const int pinZ = 8;
const int notas[] = {
  262, 262, 392, 392, 440, 440, 392,
  0,
  349, 349, 330, 330, 294, 294, 262
};
const int duracion[] = {
  280, 280, 280, 280, 280, 280, 520,
  200,
  280, 280, 280, 280, 280, 280, 560
};
const int nNotas = 15;

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

void loop() {
  for (int i = 0; i < nNotas; i++) {
    if (notas[i] > 0) {
      tone(pinZ, notas[i], duracion[i]);
    } else {
      noTone(pinZ);
    }
    delay(duracion[i]);
    noTone(pinZ);
    delay(30);
  }
  delay(900);
}

Patilla A del tilt → D2INPUT_PULLUP. No hace falta resistencia externa. Patilla B del tilt → GND de la UnoCuando el contacto cierra, D2 queda a masa y se lee LOW. Las dos patillas del tilt → no las unas a 5V y a GND a la vezEl tilt es un interruptor. Si lo pones entre 5 V y GND, al cerrar cortocircuitas la fuente.

// AP-BIR-12 Tilt en D2 con INPUT_PULLUP. LOW = inclinado.
const int pinTilt = 2;

void setup() {
  pinMode(pinTilt, INPUT_PULLUP);
  Serial.begin(9600);
}

void loop() {
  if (digitalRead(pinTilt) == LOW) {
    Serial.println("Inclinado");
  } else {
    Serial.println("En reposo");
  }
  delay(200);
}

Reed patilla A → D2INPUT_PULLUP. Imán cerca: LOW, puerta cerrada. Reed patilla B → GND de la UnoEl imán no se cablea: solo se acerca al vidrio del reed. D4 → resistencia y ánodo del LEDHIGH enciende el LED de puerta cerrada. Cátodo del LED → GND de la UnoRetorno del LED. Reed usado como si llevara alimentación → no lo pongas entre 5V y GNDEs un contacto seco. Entre 5 V y GND, al acercar el imán cortocircuitas la placa.

// AP-BIR-13 Reed en D2 (INPUT_PULLUP) y LED en D4.
// LOW = imán cerca = puerta cerrada.
const int pinReed = 2;
const int pinLed = 4;

void setup() {
  pinMode(pinReed, INPUT_PULLUP);
  pinMode(pinLed, OUTPUT);
  Serial.begin(9600);
}

void loop() {
  bool cerrada = (digitalRead(pinReed) == LOW);
  digitalWrite(pinLed, cerrada ? HIGH : LOW);
  if (cerrada) {
    Serial.println("Puerta cerrada");
  } else {
    Serial.println("Puerta abierta");
  }
  delay(200);
}

Módulo IR VCC → 5V de la UnoEstos módulos de obstáculo suelen ir a 5 V. Módulo IR GND → GND de la UnoMasa común. Módulo IR OUT → D2Digital. LOW suele significar obstáculo. No mide metros. Tornillo del módulo → ajuste de alcance, no es un pin de la UnoSi el LED del módulo se queda fijo, el potenciómetro está en un extremo y no es un fallo del pin D2.

// AP-BIR-14 Obstáculo IR digital en D2.
// En la mayoría de módulos, LOW significa que hay algo delante.
const int pinIr = 2;

void setup() {
  pinMode(pinIr, INPUT);
  Serial.begin(9600);
}

void loop() {
  if (digitalRead(pinIr) == LOW) {
    Serial.println("Obstaculo");
  } else {
    Serial.println("Libre");
  }
  delay(120);
}

Pulsador → D2INPUT_PULLUP. Pulsado es LOW. Otra patilla del pulsador → GND de la UnoNo lo alimentes a 5 V. D3 → resistencia de base y base del transistorLa Uno solo entrega la corriente de base, no la del motor. Emisor del NPN → GND de la UnoConmutación por masa. Negativo de la pila del motor → GND de la UnoMasa común obligatoria. El positivo de la pila no entra en la Uno. Positivo de la pila, diodo y motor → colector del transistorAlimentación del motor aparte. Diodo en antiparalelo: raya hacia el positivo de la pila y ánodo hacia el colector.

// AP-BIR-15 Motor con transistor. Pulsador en D2, base en D3.
// El motor NO se alimenta del pin: pila aparte, masa común, diodo en antiparalelo.
// Raya del diodo hacia el positivo de la pila. Resistencia entre D3 y la base.
const int pinBoton = 2;
const int pinBase = 3;

void setup() {
  pinMode(pinBoton, INPUT_PULLUP);
  pinMode(pinBase, OUTPUT);
  digitalWrite(pinBase, LOW);
}

void loop() {
  if (digitalRead(pinBoton) == LOW) {
    digitalWrite(pinBase, HIGH);
  } else {
    digitalWrite(pinBase, LOW);
  }
}

IN del módulo de relé → D8Muchos módulos arman la bobina con nivel bajo. El programa parte de HIGH. VCC del módulo → 5V de la UnoAlimenta la bobina del módulo, no una carga de red. GND del módulo → GND de la UnoMasa común con la placa. Contacto COM → 5V de la placa, solo para el LED de pruebaEste 5 V es la carga de baja tensión. No se toca la red de casa. No lleves la red a COM, NO ni NC. Contacto NO → resistencia y ánodo del LEDNO conduce cuando el relé está armado. Cátodo del LED → GND de la UnoCierra la carga de prueba de baja tensión.

// AP-BIR-16 Relé en D8. Solo conmuta 5 a 12 V.
// No se toca la red de casa. Carga de prueba: LED con resistencia en NO.
// Módulo típico activo a nivel bajo: HIGH = suelto, LOW = armado.
const int pinRele = 8;

void setup() {
  pinMode(pinRele, OUTPUT);
  digitalWrite(pinRele, HIGH);
}

void loop() {
  digitalWrite(pinRele, LOW);
  delay(1000);
  digitalWrite(pinRele, HIGH);
  delay(1000);
}

Ánodo rojo → D3 a través de resistenciaPWM. analogWrite en el pin 3. Ánodo verde → D5 a través de resistenciaPWM. analogWrite en el pin 5. Ánodo azul → D6 a través de resistenciaPWM. analogWrite en el pin 6. Cátodo común → GND de la UnoComún a masa. No es un cuarto color. Patilla común → no la lleves a 5V si es cátodoSi tu LED es de ánodo común, este cableado no sirve: el común iría a 5 V y los colores, invertidos, a los pines.

// AP-BIR-17 RGB cátodo común. PWM en D3 rojo, D5 verde, D6 azul.
const int pinR = 3;
const int pinG = 5;
const int pinB = 6;

void color(int r, int g, int b) {
  analogWrite(pinR, r);
  analogWrite(pinG, g);
  analogWrite(pinB, b);
}

void setup() {
  pinMode(pinR, OUTPUT);
  pinMode(pinG, OUTPUT);
  pinMode(pinB, OUTPUT);
  color(0, 0, 0);
}

void loop() {
  color(255, 0, 0);
  delay(600);
  color(0, 255, 0);
  delay(600);
  color(0, 0, 255);
  delay(600);
  color(255, 80, 0);
  delay(600);
  color(0, 0, 0);
  delay(400);
}

Joystick VRx → A0Eje analógico X. Joystick VRy → A1Eje analógico Y. Joystick SW → D2INPUT_PULLUP. Pulsado: LOW. Joystick VCC → 5V de la UnoReferencia de los potenciómetros internos. Joystick GND → GND de la UnoMasa de los ejes y del pulsador. SW sin pull-up → lecturas que parpadean al soltarNo dejes SW en INPUT pelado: al soltar, el contacto queda abierto y el pin flota.

// AP-BIR-18 Joystick: VRx A0, VRy A1, SW D2 con INPUT_PULLUP.
const int pinX = A0;
const int pinY = A1;
const int pinSw = 2;

void setup() {
  pinMode(pinSw, INPUT_PULLUP);
  Serial.begin(9600);
}

void loop() {
  int x = analogRead(pinX);
  int y = analogRead(pinY);
  int sw = digitalRead(pinSw);
  Serial.print("X=");
  Serial.print(x);
  Serial.print(" Y=");
  Serial.print(y);
  Serial.print(" SW=");
  Serial.println(sw == LOW ? "pulsado" : "suelto");
  delay(150);
}

LCD VCC → 5V de la UnoLa mochila y la retroiluminación salen de aquí. LCD GND → GND de la UnoMasa común. LCD SDA → A4Datos I2C de la Uno. No lo pases a un pin digital cualquiera. LCD SCL → A5Reloj I2C de la Uno. Potenciómetro de contraste de la mochila → no es un pin de la UnoSi solo ves cuadros o nada, gira el contraste antes de recablear SDA y SCL.

// AP-BIR-19 LCD 16x2 I2C. Dirección 0x27.
// Uno: SDA en A4, SCL en A5. Librería LiquidCrystal_I2C.
#include <Wire.h>
#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd(0x27, 16, 2);

void setup() {
  // No uses pinMode en A4 ni A5: Wire los toma como SDA y SCL.
  lcd.init();
  lcd.backlight();
  lcd.setCursor(0, 0);
  lcd.print("Hola, Birdie");
  lcd.setCursor(0, 1);
  lcd.print("Linea dos lista");
}

void loop() {
  // El texto queda fijo. Reescribirlo en cada vuelta no hace falta.
}

TMP36 Vs → 5V de la UnoReferencia de 5 V para la fórmula. TMP36 GND → GND de la UnoPatilla derecha con la cara plana hacia ti. TMP36 Vout → A0Temperatura en el segundo campo de la línea. Extremo del potenciómetro → 5V de la UnoNo es el cursor. Otro extremo del potenciómetro → GND de la UnoComparte masa con el TMP36. Cursor del potenciómetro → A1Tercer campo de la línea. No lo juntes en A0.

// AP-BIR-20 Una línea por muestra: millis, TMP36 en A0, potenciómetro en A1.
// Monitor serie a 9600. Separador ';' para copiar la columna.
const int pinTmp = A0;
const int pinPot = A1;
unsigned long ultima = 0;

void setup() {
  Serial.begin(9600);
  Serial.println("ms;tempC;pot");
}

void loop() {
  unsigned long ahora = millis();
  if (ahora - ultima >= 500) {
    ultima = ahora;
    int cruda = analogRead(pinTmp);
    float tempC = (cruda * 5.0 / 1023.0 - 0.5) * 100.0;
    int pot = analogRead(pinPot);
    Serial.print(ahora);
    Serial.print(';');
    Serial.print(tempC, 1);
    Serial.print(';');
    Serial.println(pot);
  }
}