Arduino · Proyectos

Uno D7 → L298N IN1Sentido, primera entrada. Uno D8 → L298N IN2Sentido, segunda entrada. No la pongas igual que IN1 si quieres girar. Uno D9 → L298N ENAEnable del canal A. En esta práctica solo se pone en alto, sin modular todavía. Uno 5 V → L298N pin de lógica 5 VSi la fuente del motor es de unos 7 a 12 V puedes usar el regulador de la placa del puente; si alimentas el motor a 5 V, quita el puente de selección y usa este 5 V de la placa. Uno GND → L298N GNDMasa común entre placa, puente y fuente del motor. Fuente externa de 5 a 12 V → Bornes de potencia del L298NNo conmutas la red. No conectes 230 V ni un motor de persiana de alterna. Solo corriente continua de baja tensión.

// AP-EAG-01 Motor adelante y atras con puente H
// Pines: D7 IN1, D8 IN2, D9 ENA
const int PIN_IN1 = 7;
const int PIN_IN2 = 8;
const int PIN_ENA = 9;
const unsigned long TRAMO_MS = 2000;

void parar() {
  digitalWrite(PIN_IN1, LOW);
  digitalWrite(PIN_IN2, LOW);
  digitalWrite(PIN_ENA, LOW);
}

void sentido(bool adelante) {
  digitalWrite(PIN_ENA, HIGH);
  digitalWrite(PIN_IN1, adelante ? HIGH : LOW);
  digitalWrite(PIN_IN2, adelante ? LOW : HIGH);
}

void setup() {
  pinMode(PIN_IN1, OUTPUT);
  pinMode(PIN_IN2, OUTPUT);
  pinMode(PIN_ENA, OUTPUT);
  parar();
  Serial.begin(9600);
  Serial.println(F("Puente H listo. Motor de 5 a 12 V, sin red."));
}

void loop() {
  unsigned long fase = (millis() / TRAMO_MS) % 4;
  if (fase == 0) {
    sentido(true);
    Serial.println(F("adelante"));
  } else if (fase == 2) {
    sentido(false);
    Serial.println(F("atras"));
  } else {
    parar();
    Serial.println(F("parado"));
  }
  delay(50);
}

Uno D7 → L298N IN1Sentido fijo en esta práctica. Uno D8 → L298N IN2Complementario de IN1. Uno D9 → L298N ENASalida PWM. No uses un pin sin PWM si quieres velocidad de verdad. Uno 5 V → L298N lógicaLógica a 5 V, separada de la potencia. Uno GND → L298N GND y fuenteMasa común obligatoria. Fuente de 5 a 12 V → Bornes de potencia del L298NNo conmutas la red. El PWM no convierte este circuito en un regulador de alterna.

// AP-EAG-02 Velocidad de un motor con PWM
// Pines: D7 IN1, D8 IN2, D9 ENA (PWM)
const int PIN_IN1 = 7;
const int PIN_IN2 = 8;
const int PIN_ENA = 9;
int orden = 0;
unsigned long anterior = 0;

void setup() {
  pinMode(PIN_IN1, OUTPUT);
  pinMode(PIN_IN2, OUTPUT);
  pinMode(PIN_ENA, OUTPUT);
  digitalWrite(PIN_IN1, HIGH);
  digitalWrite(PIN_IN2, LOW);
  analogWrite(PIN_ENA, 0);
  Serial.begin(9600);
  Serial.println(F("Rampa PWM en D9. Potencia 5 a 12 V, sin red."));
}

void loop() {
  if (millis() - anterior < 30) return;
  anterior = millis();
  orden += 2;
  if (orden > 400) orden = 0;
  int ciclo = orden <= 200 ? orden : 400 - orden;
  analogWrite(PIN_ENA, ciclo);
  Serial.print(F("PWM "));
  Serial.println(ciclo);
}

Uno D8 → ULN2003 IN1Primera bobina. Uno D9 → ULN2003 IN2Segunda bobina. Uno D10 → ULN2003 IN3Tercera bobina. Uno D11 → ULN2003 IN4Cuarta bobina. El orden importa: si saltas una, vibra y no avanza. Uno 5 V → ULN2003 +5 VEste motor es de 5 V. No lo alimentes a 12 V. Uno GND → ULN2003 GNDMasa común. Alimentación del motor → ULN20035 V, no la red y no una fuente de 12 V. Si el USB se cae, usa una fuente de 5 V externa con la masa unida.

// AP-EAG-03 28BYJ-48: una vuelta
// Pines: D8 IN1, D9 IN2, D10 IN3, D11 IN4
const int PINES[4] = {8, 9, 10, 11};
const int PASOS_VUELTA = 2048;
const int SECUENCIA[4][4] = {
  {1, 0, 0, 0},
  {0, 1, 0, 0},
  {0, 0, 1, 0},
  {0, 0, 0, 1}
};

void aplicar(int indice) {
  for (int b = 0; b < 4; b++) {
    digitalWrite(PINES[b], SECUENCIA[indice][b]);
  }
}

void soltar() {
  for (int b = 0; b < 4; b++) digitalWrite(PINES[b], LOW);
}

void setup() {
  for (int b = 0; b < 4; b++) pinMode(PINES[b], OUTPUT);
  soltar();
  Serial.begin(9600);
  Serial.println(F("Una vuelta: 2048 pasos a 5 V."));
  for (int n = 0; n < PASOS_VUELTA; n++) {
    aplicar(n % 4);
    delay(3);
  }
  soltar();
  Serial.println(F("Vuelta hecha. Bobinas sueltas."));
}

void loop() {
}

Uno D8 → ULN2003 IN1Fase 1. Uno D9 → ULN2003 IN2Fase 2. Uno D10 → ULN2003 IN3Fase 3. Uno D11 → ULN2003 IN4Fase 4. Uno 5 V → ULN2003 positivo5 V, no 12 V. Uno GND → ULN2003 GNDMasa común. Entrada del monitor → Grados enteros con signoEscribes un número, por ejemplo 90 o -45, y pulsas intro. No hay nada fuera de tu ordenador y tu placa.

// AP-EAG-04 Paso a paso por grados
// Pines: D8 IN1, D9 IN2, D10 IN3, D11 IN4
const int PINES[4] = {8, 9, 10, 11};
const long PASOS_VUELTA = 2048;
const int SECUENCIA[4][4] = {
  {1, 0, 0, 0},
  {0, 1, 0, 0},
  {0, 0, 1, 0},
  {0, 0, 0, 1}
};
int indice = 0;

void aplicar(int i) {
  int k = (i % 4 + 4) % 4;
  for (int b = 0; b < 4; b++) digitalWrite(PINES[b], SECUENCIA[k][b]);
}

void moverGrados(long grados) {
  long pasos = grados * PASOS_VUELTA / 360;
  int dir = pasos >= 0 ? 1 : -1;
  long n = pasos >= 0 ? pasos : -pasos;
  Serial.print(F("pasos "));
  Serial.println(pasos);
  for (long k = 0; k < n; k++) {
    indice += dir;
    aplicar(indice);
    delay(3);
  }
  for (int b = 0; b < 4; b++) digitalWrite(PINES[b], LOW);
}

void setup() {
  for (int b = 0; b < 4; b++) pinMode(PINES[b], OUTPUT);
  Serial.begin(9600);
  Serial.println(F("Escribe grados, por ejemplo 90 o -180."));
}

void loop() {
  if (!Serial.available()) return;
  long grados = Serial.parseInt();
  while (Serial.available()) Serial.read();
  if (grados < -360 || grados > 360) {
    Serial.println(F("Limita a una vuelta, de -360 a 360."));
    return;
  }
  moverGrados(grados);
  Serial.println(F("hecho"));
}

HC-05 TX → Uno D2D2 es el RX del SoftwareSerial. La señal del módulo ya sale a 3,3 V y el Uno la lee bien. Uno D3 → Level shifter HV y de ahí al RX del HC-05No unas D3 directo al RX del módulo: esa patilla no admite 5 V. Uno 5 V → HC-05 VCC y HV del shifterEl breakout típico regula a 3,3 V por dentro. No alimentes el radio desde el pin de 3,3 V del Uno, que da poca corriente. Uno 3,3 V → LV del level shifterSolo la referencia de baja del shifter, no el módulo completo. Uno GND → HC-05 GND y GND del shifterMasa común. Uno D8 → Resistencia y LED hacia GNDEl LED indica la orden local. Teléfono emparejado → HC-05Mando local, sin nube. Baudios de datos: 9600. Si algún día entras en AT con KEY a alto antes de alimentar, esa consola va a 38400, no a 9600.

// AP-EAG-05 HC-05 mando local de un LED
// Pines: D2 RX del enlace, D3 TX del enlace, D8 LED
// Datos a 9600 baudios. El modo AT del HC-05, si lo usaras, iria a 38400.
#include <SoftwareSerial.h>
const int PIN_BT_RX = 2;
const int PIN_BT_TX = 3;
const int PIN_LED = 8;
SoftwareSerial bt(PIN_BT_RX, PIN_BT_TX);

void setup() {
  pinMode(PIN_LED, OUTPUT);
  digitalWrite(PIN_LED, LOW);
  Serial.begin(9600);
  bt.begin(9600);
  Serial.println(F("HC-05 en datos a 9600. Enlace local, sin cuenta."));
  Serial.println(F("Envia 1 para encender y 0 para apagar."));
}

void loop() {
  if (bt.available()) {
    char c = bt.read();
    Serial.print(F("recibido "));
    Serial.println(c);
    if (c == '1') digitalWrite(PIN_LED, HIGH);
    else if (c == '0') digitalWrite(PIN_LED, LOW);
  }
}

Salida del sensor-ir → Uno D2Activo a nivel bajo cuando ve la ráfaga de 38 kHz. Uno 5 V → VCC del receptor IREl TSOP de mando suele ir a 5 V. Mira la serigrafía de tu módulo. Uno GND → GND del receptor IRSin esta masa la salida se queda flotando. Uno D8 → Resistencia y LED a GNDSe enciende solo si el código coincide con el guardado. Mando IR → Cúpula del receptorApunta de cerca, a menos de un metro, sin sol directo que sature el sensor.

// AP-EAG-06 Receptor IR de un mando
// Pines: D2 receptor, D8 LED
// Sustituye TECLA por el valor que veas en el monitor.
const int PIN_IR = 2;
const int PIN_LED = 8;
const uint32_t TECLA = 0x00FFA25DUL;

bool medir(int nivel, unsigned long tMin, unsigned long tMax) {
  unsigned long t0 = micros();
  while (digitalRead(PIN_IR) == nivel) {
    if (micros() - t0 > tMax + 1500UL) return false;
  }
  unsigned long dt = micros() - t0;
  return dt >= tMin && dt <= tMax;
}

bool leerNec(uint32_t &codigo) {
  if (digitalRead(PIN_IR) != LOW) return false;
  if (!medir(LOW, 8000, 10000)) return false;
  if (!medir(HIGH, 4000, 5200)) return false;
  uint32_t v = 0;
  for (int i = 0; i < 32; i++) {
    if (!medir(LOW, 250, 900)) return false;
    unsigned long t0 = micros();
    while (digitalRead(PIN_IR) == HIGH) {
      if (micros() - t0 > 2500UL) return false;
    }
    unsigned long espacio = micros() - t0;
    v >>= 1;
    if (espacio > 1000UL) v |= 0x80000000UL;
  }
  codigo = v;
  return true;
}

void setup() {
  pinMode(PIN_IR, INPUT);
  pinMode(PIN_LED, OUTPUT);
  Serial.begin(9600);
  Serial.println(F("Pulsa una tecla. Copia el codigo a TECLA."));
}

void loop() {
  uint32_t codigo = 0;
  if (!leerNec(codigo)) return;
  Serial.println(codigo, HEX);
  digitalWrite(PIN_LED, codigo == TECLA ? HIGH : LOW);
  delay(150);
}

Uno emisor D3 → Resistencia y LED infrarrojo hacia GNDD3 admite tone a 38000 Hz. El cátodo del LED va a masa. Uno emisor 5 V → Nada del LED de datosEl LED se alimenta del pin, no lo pongas directo a 5 V. Uno emisor GND → Cátodo del LED infrarrojoCierra el circuito del emisor. Salida del sensor-ir → Uno receptor D2La receptora escucha por D2. Uno receptor 5 V → VCC del TSOPAlimenta el receptor en su propia placa. Uno receptor GND → GND del TSOPLa masa no viaja entre placas: cada una tiene la suya. Uno receptor D8 → LED visible y resistencia a GNDParpadea cuando el byte recibido es el esperado. LED infrarrojo → Cúpula del TSOPEnfréntalos a pocos centímetros. Un LED visible solo te sirve para ver que el pin conmuta; el TSOP quiere infrarrojo.

// AP-EAG-07 Enlace IR entre dos placas
// Hay dos sketches. Graba cada uno en su placa.

// ===== Placa emisora. Pines: D3 LED infrarrojo =====
const int PIN_IR = 3;
const byte MENSAJE = 0xA5;

void marca(int us) {
  tone(PIN_IR, 38000);
  delayMicroseconds(us);
  noTone(PIN_IR);
}
void espacio(int us) { delayMicroseconds(us); }

void enviarByte(byte dato) {
  marca(2400);
  espacio(1200);
  for (int b = 0; b < 8; b++) {
    marca(600);
    espacio((dato & 1) ? 1600 : 600);
    dato >>= 1;
  }
  marca(600);
}

void setup() { pinMode(PIN_IR, OUTPUT); Serial.begin(9600); }
void loop() {
  enviarByte(MENSAJE);
  Serial.println(F("enviado A5"));
  delay(400);
}

// ===== Placa receptora. Pines: D2 TSOP, D8 LED =====
/*
const int PIN_IR = 2;
const int PIN_LED = 8;

bool pulsoAlto(unsigned long &ancho) {
  unsigned long t0 = micros();
  while (digitalRead(PIN_IR) == HIGH) {
    if (micros() - t0 > 6000UL) return false;
  }
  ancho = micros() - t0;
  return true;
}

bool leerByte(byte &dato) {
  if (digitalRead(PIN_IR) != LOW) return false;
  unsigned long t0 = micros();
  while (digitalRead(PIN_IR) == LOW) {
    if (micros() - t0 > 5000UL) return false;
  }
  if (micros() - t0 < 1800UL) return false;
  unsigned long espacioCab = 0;
  if (!pulsoAlto(espacioCab)) return false;
  if (espacioCab < 800UL) return false;
  byte v = 0;
  for (int b = 0; b < 8; b++) {
    t0 = micros();
    while (digitalRead(PIN_IR) == LOW) {
      if (micros() - t0 > 2000UL) return false;
    }
    unsigned long espacio = 0;
    if (!pulsoAlto(espacio)) return false;
    if (espacio > 1000UL) v |= (1 << b);
  }
  dato = v;
  return true;
}

void setup() {
  pinMode(PIN_IR, INPUT);
  pinMode(PIN_LED, OUTPUT);
  Serial.begin(9600);
  Serial.println(F("Esperando byte IR"));
}
void loop() {
  byte dato = 0;
  if (!leerByte(dato)) return;
  Serial.println(dato, HEX);
  digitalWrite(PIN_LED, dato == 0xA5 ? HIGH : LOW);
  delay(50);
  digitalWrite(PIN_LED, LOW);
}
*/

Uno D9 → CE del nRF24 a través del shifterChip enable. Uno D10 → CSN del nRF24 a través del shifterSelección SPI. En el Uno debe quedar como salida. Uno D11 → MOSI del nRF24 a través del shifterSPI, dato hacia el módulo. nRF24 MISO → Uno D12Sale a 3,3 V desde el módulo y el Uno lo lee bien sin subirla. Uno D13 → SCK del nRF24 a través del shifterReloj SPI. Uno pin de 3,3 V → VCC del nRF24 y LV del shifterNunca pongas 5 V en el VCC del radio. El pin de 3,3 V del Uno llega justo; si se reinicia al emitir, usa un regulador de 3,3 V aparte. Uno 5 V → HV del level shifterSolo la referencia alta del shifter. Uno GND → GND del nRF24 y del shifterMasa común en cada placa. Entre las dos placas no hace falta un cable. Condensador de 10 microfaradios → Patillas VCC y GND del nRF24Respeta la polaridad del electrolítico. Sin este condensador el enlace falla de forma intermitente justo al transmitir.

// AP-EAG-08 NRF24L01 un mensaje entre dos Unos
// Pines en las dos placas: D9 CE, D10 CSN, D11 MOSI, D12 MISO, D13 SCK
// Alimentacion del radio: 3,3 V y condensador de 10 microfaradios.
// Libreria RF24. Dos sketches, uno por placa.

// ===== Placa emisora =====
#include <SPI.h>
#include <RF24.h>
const int PIN_CE = 9;
const int PIN_CSN = 10;
const int PIN_MOSI = 11;
const int PIN_MISO = 12;
const int PIN_SCK = 13;
RF24 radio(PIN_CE, PIN_CSN);
const byte DIRECCION[6] = "EAG08";

void setup() {
  Serial.begin(9600);
  Serial.print(F("SPI D11 D12 D13, CE D9, CSN D10, VCC 3,3 V. MOSI "));
  Serial.println(PIN_MOSI);
  if (!radio.begin()) {
    Serial.println(F("Radio no responde. Revisa 3,3 V y el condensador."));
    while (true) {}
  }
  radio.setChannel(76);
  radio.setDataRate(RF24_250KBPS);
  radio.setPALevel(RF24_PA_LOW);
  radio.openWritingPipe(DIRECCION);
  radio.stopListening();
}
void loop() {
  char texto[8] = "hola";
  bool ok = radio.write(texto, sizeof(texto));
  Serial.println(ok ? F("enviado") : F("sin ack"));
  delay(500);
}

// ===== Placa receptora: mismo cableado, otro sketch =====
/*
#include <SPI.h>
#include <RF24.h>
const int PIN_CE = 9;
const int PIN_CSN = 10;
const int PIN_MOSI = 11;
const int PIN_MISO = 12;
const int PIN_SCK = 13;
RF24 radio(PIN_CE, PIN_CSN);
const byte DIRECCION[6] = "EAG08";

void setup() {
  Serial.begin(9600);
  if (!radio.begin()) {
    Serial.println(F("Radio no responde"));
    while (true) {}
  }
  radio.setChannel(76);
  radio.setDataRate(RF24_250KBPS);
  radio.setPALevel(RF24_PA_LOW);
  radio.openReadingPipe(1, DIRECCION);
  radio.startListening();
  Serial.println(F("Escuchando en canal 76"));
}
void loop() {
  if (!radio.available()) return;
  char texto[8] = {0};
  radio.read(texto, sizeof(texto));
  Serial.print(F("recibido "));
  Serial.println(texto);
}
*/

Uno A4 → SDA del OLEDDatos I2C. En el Uno R3, A4 es SDA. Uno A5 → SCL del OLEDReloj I2C. Uno 5 V → VCC del OLEDEl breakout habitual acepta 5 V porque lleva su regulador. Si el tuyo dice solo 3,3 V, aliméntalo a 3,3 V. Uno GND → GND del OLED y del HallMasa común. Salida analógica del sensor-hall → Uno A0No uses la salida digital del módulo para este gráfico. Uno 5 V → VCC del sensor HallAlimenta el sensor a la tensión que indica su placa, normalmente 5 V.

// AP-EAG-09 OLED SSD1306 grafico de un sensor
// Pines: A4 SDA, A5 SCL, A0 sensor Hall
// Librerias Adafruit_SSD1306 y Adafruit_GFX. Direccion 0x3C.
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
const int PIN_SDA = A4;
const int PIN_SCL = A5;
const int PIN_HALL = A0;
Adafruit_SSD1306 oled(128, 64, &Wire, -1);
int x = 0;
int yAnterior = 32;

void setup() {
  pinMode(PIN_SDA, INPUT);
  pinMode(PIN_SCL, INPUT);
  Serial.begin(9600);
  if (!oled.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
    Serial.println(F("OLED no responde en 0x3C"));
    while (true) {}
  }
  oled.clearDisplay();
  oled.setTextColor(SSD1306_WHITE);
  oled.display();
}

void loop() {
  int lectura = analogRead(PIN_HALL);
  int y = map(lectura, 0, 1023, 63, 0);
  oled.drawLine(x, yAnterior, x + 1, y, SSD1306_WHITE);
  yAnterior = y;
  x++;
  if (x >= 127) {
    x = 0;
    oled.clearDisplay();
  }
  oled.fillRect(0, 0, 40, 10, SSD1306_BLACK);
  oled.setCursor(0, 0);
  oled.print(lectura);
  oled.display();
  delay(40);
}

Uno D6 → Resistencia de 330 ohmios y de ahí a DIN de la tiraLa resistencia va en el datos, no en la alimentación. DIN es la entrada, no DOUT. Fuente de 5 V → 5 V de la tiraCon pocos LED puedes probar desde el 5 V del Uno. Con una tira larga usa fuente de 5 V aparte. Uno GND → GND de la tira y de la fuenteSin masa común la tira pinta colores al azar. Condensador de unos 1000 microfaradios → 5 V y GND de la tira, junto al primer LEDRespeta la polaridad. Este condensador frena el pico al encender. Un solo color, el que fija el sketch, para no mezclar el ensayo con efectos.

// AP-EAG-10 Tira de LEDs direccionables, un color
// Pin: D6 datos, con resistencia de 330 ohmios en serie.
// Libreria Adafruit_NeoPixel. Un solo color en toda la tira.
#include <Adafruit_NeoPixel.h>
const int PIN_DATOS = 6;
const int NUM_LEDS = 8;
Adafruit_NeoPixel tira(NUM_LEDS, PIN_DATOS, NEO_GRB + NEO_KHZ800);
const unsigned long PASO_MS = 40;
unsigned long anterior = 0;
int brillo = 10;
int dir = 1;

void setup() {
  tira.begin();
  tira.setBrightness(40);
  tira.clear();
  tira.show();
  Serial.begin(9600);
  Serial.println(F("Un solo color rojo en D6."));
}

void loop() {
  if (millis() - anterior < PASO_MS) return;
  anterior = millis();
  brillo += dir;
  if (brillo >= 80 || brillo <= 5) dir = -dir;
  uint32_t color = tira.Color(brillo, 0, 0);
  for (int i = 0; i < NUM_LEDS; i++) tira.setPixelColor(i, color);
  tira.show();
}

Uno A4 → SDA del OLEDI2C datos. Uno A5 → SCL del OLEDI2C reloj. Uno D2 → Pulsador subir, el otro extremo a GNDActivo a bajo. Uno D3 → Pulsador bajar, el otro extremo a GNDActivo a bajo. Uno D4 → Pulsador aceptar, el otro extremo a GNDEntra o sale del ajuste. Uno 5 V → VCC del OLEDBreakout típico con regulador. Uno GND → GND del OLED y de los tres pulsadoresMasa común.

// AP-EAG-11 Menu en OLED con pulsadores
// Pines: A4 SDA, A5 SCL, D2 subir, D3 bajar, D4 aceptar
// Adafruit_SSD1306 y Adafruit_GFX, direccion 0x3C.
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
const int PIN_SDA = A4;
const int PIN_SCL = A5;
const int PIN_SUBIR = 2;
const int PIN_BAJAR = 3;
const int PIN_OK = 4;
Adafruit_SSD1306 oled(128, 64, &Wire, -1);
const char* LINEAS[3] = {"Intervalo", "Umbral", "Salir"};
int valores[3] = {10, 50, 0};
int cursor = 0;
int estado = 0;
unsigned long estableDesde[3] = {0, 0, 0};
bool nivelEstable[3] = {HIGH, HIGH, HIGH};
bool pulsado[3];

bool leerEstable(int i, int pin) {
  bool ahora = digitalRead(pin);
  if (ahora != nivelEstable[i]) {
    if (millis() - estableDesde[i] > 25) {
      nivelEstable[i] = ahora;
      estableDesde[i] = millis();
      return ahora == LOW;
    }
  } else {
    estableDesde[i] = millis();
  }
  return false;
}

void pintar() {
  oled.clearDisplay();
  oled.setTextColor(SSD1306_WHITE);
  oled.setTextSize(1);
  for (int i = 0; i < 3; i++) {
    oled.setCursor(0, i * 12);
    oled.print(i == cursor ? ">" : " ");
    oled.print(LINEAS[i]);
    if (i < 2) {
      oled.print(estado == 1 && i == cursor ? " [" : " ");
      oled.print(valores[i]);
      if (estado == 1 && i == cursor) oled.print("]");
    }
  }
  oled.display();
}

void setup() {
  pinMode(PIN_SUBIR, INPUT_PULLUP);
  pinMode(PIN_BAJAR, INPUT_PULLUP);
  pinMode(PIN_OK, INPUT_PULLUP);
  Serial.begin(9600);
  if (!oled.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
    Serial.println(F("OLED ausente en 0x3C"));
    while (true) {}
  }
  pintar();
}

void loop() {
  pulsado[0] = leerEstable(0, PIN_SUBIR);
  pulsado[1] = leerEstable(1, PIN_BAJAR);
  pulsado[2] = leerEstable(2, PIN_OK);
  if (pulsado[2]) estado = estado == 0 ? 1 : 0;
  if (estado == 0) {
    if (pulsado[0]) cursor = (cursor + 2) % 3;
    if (pulsado[1]) cursor = (cursor + 1) % 3;
  } else if (cursor < 2) {
    if (pulsado[0]) valores[cursor] += 1;
    if (pulsado[1] && valores[cursor] > 0) valores[cursor] -= 1;
  }
  if (pulsado[0] || pulsado[1] || pulsado[2]) pintar();
}

HX711 DT → Uno D3Dato. La placa espera a que baje para leer. HX711 SCK → Uno D2Reloj que generas tú. No lo dejes flotando. Uno 5 V → VCC del HX711El módulo admite 5 V. No alimentes la celda por otro lado. Uno GND → GND del HX711Masa común. Uno D4 → Pulsador de tara hacia GNDAl pulsarlo se guarda la tara en una variable, no fuera de la placa. Peso conocido → Plato de la celdaUsa una masa que puedas leer en el propio objeto, por ejemplo un paquete etiquetado. La escala resultante se copia al sketch.

// AP-EAG-12 Bascula HX711, calibracion local
// Pines: D3 DT, D2 SCK, D4 tara
// ESCALA sale de (lectura_con_peso - tara) / PESO_CONOCIDO_G
// y se queda escrita aqui. No se envia a ningun sitio.
const int PIN_DT = 3;
const int PIN_SCK = 2;
const int PIN_TARA = 4;
const float PESO_CONOCIDO_G = 200.0;
const float ESCALA = 430.0;
long tara = 0;

long leerCuentas() {
  while (digitalRead(PIN_DT) == HIGH) {}
  long v = 0;
  for (int i = 0; i < 24; i++) {
    digitalWrite(PIN_SCK, HIGH);
    delayMicroseconds(1);
    v = (v << 1) | digitalRead(PIN_DT);
    digitalWrite(PIN_SCK, LOW);
    delayMicroseconds(1);
  }
  digitalWrite(PIN_SCK, HIGH);
  delayMicroseconds(1);
  digitalWrite(PIN_SCK, LOW);
  if (v & 0x800000L) v |= ~0xFFFFFFL;
  return v;
}

void setup() {
  pinMode(PIN_DT, INPUT);
  pinMode(PIN_SCK, OUTPUT);
  pinMode(PIN_TARA, INPUT_PULLUP);
  digitalWrite(PIN_SCK, LOW);
  Serial.begin(9600);
  delay(300);
  tara = leerCuentas();
  Serial.println(F("Tara hecha. Peso conocido previsto: 200 g."));
  Serial.println(F("Si cambias ESCALA, vuelve a grabar el sketch."));
}

void loop() {
  if (digitalRead(PIN_TARA) == LOW) {
    delay(30);
    tara = leerCuentas();
    Serial.println(F("tara nueva en la placa"));
    delay(300);
  }
  long neto = leerCuentas() - tara;
  float gramos = neto / ESCALA;
  Serial.print(F("cuentas "));
  Serial.print(neto);
  Serial.print(F("  g "));
  Serial.println(gramos, 1);
  delay(400);
}

Salida del ACS712 → Uno A0Tensión centrada cerca de 2,5 V cuando no pasa corriente. Uno 5 V → VCC del ACS712El cero depende de esta alimentación. Mide la misma referencia que usa el Uno. Uno GND → GND del ACS712Masa común con la fuente de la carga. Borne IP+ del ACS712 → Positivo de la fuente de la cargaLa corriente de la carga entra por un borne y sale por el otro. No pongas la red. Fuente de continua de baja tensión, por ejemplo 5 o 12 V. Borne IP- del ACS712 → Positivo de la carga, y la carga vuelve a masaEl sensor va en serie. No lo pongas en paralelo con la fuente o harás un cortocircuito.

// AP-EAG-13 Corriente con ACS712
// Pin: A0 salida del sensor
// Version de 5 A: 0,185 V por amperio. Carga de baja tension, sin red.
const int PIN_SENSOR = A0;
const float VREF = 5.0;
const float V_POR_A = 0.185;
float ceroV = 2.5;

void setup() {
  Serial.begin(9600);
  Serial.println(F("Sin carga, calculo el cero durante un segundo."));
  long acum = 0;
  for (int i = 0; i < 50; i++) {
    acum += analogRead(PIN_SENSOR);
    delay(20);
  }
  ceroV = (acum / 50.0) * (VREF / 1023.0);
  Serial.print(F("cero V "));
  Serial.println(ceroV, 3);
}

void loop() {
  long acum = 0;
  for (int i = 0; i < 10; i++) acum += analogRead(PIN_SENSOR);
  float v = (acum / 10.0) * (VREF / 1023.0);
  float amperios = (v - ceroV) / V_POR_A;
  Serial.print(F("V "));
  Serial.print(v, 3);
  Serial.print(F("  A "));
  Serial.println(amperios, 3);
  delay(300);
}

Uno D7 → IN del módulo de reléActivo a nivel bajo en la mayoría de módulos de un canal. Uno 5 V → VCC del relé y del ACS712La bobina del módulo se alimenta de aquí. La carga, no. Uno GND → GND del relé y del ACS712Masa común con la fuente de la carga. Salida del ACS712 → Uno A0Misma lectura que en la práctica de corriente. Contacto COM del relé → Fuente de 5 a 12 V de la cargaNo conmutas la red. El común no ve un enchufe de casa. Contacto NO del relé → ACS712 en serie y luego la carga hacia masaAl cerrar el relé circula continua de baja tensión. Si no estás seguro del cable, no lo enchufes.

// AP-EAG-14 Consumo de un rele en el tiempo
// Pines: D7 IN del rele, A0 ACS712
// Carga de 5 a 12 V. No se conmuta la red.
const int PIN_RELE = 7;
const int PIN_SENSOR = A0;
const int RELE_ON = LOW;
const int RELE_OFF = HIGH;
const float V_POR_A = 0.185;
float ceroV = 2.5;
unsigned long anterior = 0;
unsigned long fase = 0;
float amperiosSegundo = 0;

float leerAmperios() {
  long acum = 0;
  for (int i = 0; i < 8; i++) acum += analogRead(PIN_SENSOR);
  float v = (acum / 8.0) * (5.0 / 1023.0);
  return (v - ceroV) / V_POR_A;
}

void setup() {
  pinMode(PIN_RELE, OUTPUT);
  digitalWrite(PIN_RELE, RELE_OFF);
  Serial.begin(9600);
  delay(200);
  ceroV = (analogRead(PIN_SENSOR) * (5.0 / 1023.0));
  anterior = millis();
  fase = millis();
  Serial.println(F("Rele de baja tension. Acumulo A*s."));
}

void loop() {
  if (millis() - fase >= 5000) {
    fase = millis();
    bool encendido = digitalRead(PIN_RELE) == RELE_OFF;
    digitalWrite(PIN_RELE, encendido ? RELE_ON : RELE_OFF);
  }
  unsigned long ahora = millis();
  float dt = (ahora - anterior) / 1000.0;
  anterior = ahora;
  if (dt <= 0 || dt > 1) return;
  float a = leerAmperios();
  if (a < 0) a = 0;
  amperiosSegundo += a * dt;
  Serial.print(F("A "));
  Serial.print(a, 3);
  Serial.print(F("  A*s "));
  Serial.println(amperiosSegundo, 3);
  delay(200);
}

Uno A4 → SDA del DS3231I2C. Dirección 0x68. Uno A5 → SCL del DS3231Reloj I2C. Uno D7 → IN del reléSe activa solo dentro de la ventana de alarma. Uno 5 V → VCC del DS3231 y del reléLa pila del reloj es aparte y no sustituye este 5 V mientras programas. Uno GND → GND del DS3231 y del reléMasa común. Contacto del relé → Carga de 5 a 12 VNo conmutas la red. Usa el LED de práctica o un timbre de baja tensión.

// AP-EAG-15 Alarma de reloj que activa un rele
// Pines: A4 SDA, A5 SCL, D7 rele
// Carga de 5 a 12 V. No se conmuta la red.
#include <Wire.h>
const int PIN_SDA = A4;
const int PIN_SCL = A5;
const int PIN_RELE = 7;
const int RELE_ON = LOW;
const int RELE_OFF = HIGH;
const int HORA_ALARMA = 7;
const int MINUTO_ALARMA = 30;
const unsigned long DURACION_MS = 20000;
unsigned long activadaEn = 0;
bool sonando = false;

byte bcdAentero(byte b) { return (b >> 4) * 10 + (b & 0x0F); }
byte enteroAbcd(byte n) { return ((n / 10) << 4) | (n % 10); }

void leerHora(int &h, int &m, int &s) {
  Wire.beginTransmission(0x68);
  Wire.write(0x00);
  Wire.endTransmission();
  Wire.requestFrom(0x68, 3);
  s = bcdAentero(Wire.read() & 0x7F);
  m = bcdAentero(Wire.read());
  h = bcdAentero(Wire.read() & 0x3F);
}

void fijarHora(int h, int m, int s) {
  Wire.beginTransmission(0x68);
  Wire.write(0x00);
  Wire.write(enteroAbcd(s));
  Wire.write(enteroAbcd(m));
  Wire.write(enteroAbcd(h));
  Wire.endTransmission();
}

void setup() {
  pinMode(PIN_RELE, OUTPUT);
  digitalWrite(PIN_RELE, RELE_OFF);
  Wire.begin();
  Serial.begin(9600);
  Serial.println(F("Alarma local. Ajusta HORA_ALARMA en el sketch."));
}

void loop() {
  int h, m, s;
  leerHora(h, m, s);
  Serial.print(h); Serial.print(':');
  Serial.print(m); Serial.print(':');
  Serial.println(s);
  if (!sonando && h == HORA_ALARMA && m == MINUTO_ALARMA && s < 5) {
    sonando = true;
    activadaEn = millis();
    digitalWrite(PIN_RELE, RELE_ON);
  }
  if (sonando && millis() - activadaEn > DURACION_MS) {
    sonando = false;
    digitalWrite(PIN_RELE, RELE_OFF);
  }
  delay(500);
}

Uno A4 → HV del shifter y SDA del OLEDEl lado LV del mismo canal va al SDA del BMP280. Uno A5 → HV del shifter y SCL del OLEDEl lado LV va al SCL del BMP280. Uno pin de 3,3 V → VCC del BMP280 y LV del shifterNo alimentes el BMP280 a 5 V. Uno 5 V → VCC del OLED y HV del shifterLa pantalla, en su breakout habitual, lleva regulador. Uno GND → GND del BMP280, del OLED y del shifterUna sola masa para los tres. Bus I2C → Solo la placa y estos dos módulosMedida local. No añadas un módulo de red a este montaje: la práctica no publica los datos.

// AP-EAG-16 Meteo local: BMP280 en OLED
// Pines: A4 SDA, A5 SCL. OLED en 0x3C. BMP280 en 0x76.
// Adafruit_SSD1306, Adafruit_GFX y Adafruit_BMP280.
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <Adafruit_BMP280.h>
const int PIN_SDA = A4;
const int PIN_SCL = A5;
Adafruit_SSD1306 oled(128, 64, &Wire, -1);
Adafruit_BMP280 bmp;

void setup() {
  Serial.begin(9600);
  Wire.begin();
  if (!oled.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
    Serial.println(F("OLED no esta en 0x3C"));
    while (true) {}
  }
  if (!bmp.begin(0x76)) {
    Serial.println(F("BMP280 no esta en 0x76"));
    while (true) {}
  }
  bmp.setSampling(Adafruit_BMP280::MODE_NORMAL,
                  Adafruit_BMP280::SAMPLING_X2,
                  Adafruit_BMP280::SAMPLING_X16,
                  Adafruit_BMP280::FILTER_X16,
                  Adafruit_BMP280::STANDBY_MS_500);
  oled.setTextColor(SSD1306_WHITE);
  oled.setTextSize(1);
}

void loop() {
  float t = bmp.readTemperature();
  float p = bmp.readPressure() / 100.0;
  oled.clearDisplay();
  oled.setCursor(0, 0);
  oled.print(F("Local, sin enviar"));
  oled.setCursor(0, 16);
  oled.print(F("T "));
  oled.print(t, 1);
  oled.print(F(" C"));
  oled.setCursor(0, 32);
  oled.print(F("P "));
  oled.print(p, 1);
  oled.print(F(" hPa"));
  oled.display();
  Serial.print(t, 1);
  Serial.print(F(" C  "));
  Serial.print(p, 1);
  Serial.println(F(" hPa"));
  delay(1000);
}

Uno D2 → Final de carrera de arriba, el otro contacto a GNDSi ya está pulsado, prohibido seguir subiendo. Uno D3 → Final de carrera de abajo, el otro contacto a GNDSi ya está pulsado, prohibido seguir bajando. Uno D4 → Pulsador subir hacia GNDPetición, no orden ciega. Uno D5 → Pulsador bajar hacia GNDNo debe poder coincidir en marcha con subir. Uno D7 → L298N IN1Sentido subir. Uno D8 → L298N IN2Sentido bajar. Uno D9 → L298N ENAEnable. Se queda en bajo cuando ya se llegó. Uno 5 V → Lógica del L298NLógica aparte de la potencia. Uno GND → GND del puente, finales y pulsadoresMasa común con la fuente del motor. Fuente de 5 a 12 V → Potencia del L298NNo conmutas la red. Este ensayo no se conecta al motor de la ventana de casa.

// AP-EAG-17 Persiana con dos finales de carrera
// Pines: D2 fin arriba, D3 fin abajo, D4 subir, D5 bajar, D7 IN1, D8 IN2, D9 ENA
// Motor de 5 a 12 V. No se conmuta la red.
const int PIN_FIN_ARRIBA = 2;
const int PIN_FIN_ABAJO = 3;
const int PIN_SUBIR = 4;
const int PIN_BAJAR = 5;
const int PIN_IN1 = 7;
const int PIN_IN2 = 8;
const int PIN_ENA = 9;

void parar() {
  digitalWrite(PIN_IN1, LOW);
  digitalWrite(PIN_IN2, LOW);
  digitalWrite(PIN_ENA, LOW);
}

void setup() {
  pinMode(PIN_FIN_ARRIBA, INPUT_PULLUP);
  pinMode(PIN_FIN_ABAJO, INPUT_PULLUP);
  pinMode(PIN_SUBIR, INPUT_PULLUP);
  pinMode(PIN_BAJAR, INPUT_PULLUP);
  pinMode(PIN_IN1, OUTPUT);
  pinMode(PIN_IN2, OUTPUT);
  pinMode(PIN_ENA, OUTPUT);
  parar();
  Serial.begin(9600);
  Serial.println(F("Persiana de practica. Si ya llego, el motor no sigue."));
}

void loop() {
  bool arriba = digitalRead(PIN_FIN_ARRIBA) == LOW;
  bool abajo = digitalRead(PIN_FIN_ABAJO) == LOW;
  bool quiereSubir = digitalRead(PIN_SUBIR) == LOW;
  bool quiereBajar = digitalRead(PIN_BAJAR) == LOW;
  if (arriba && abajo) {
    parar();
    return;
  }
  if (quiereSubir && quiereBajar) {
    parar();
    return;
  }
  if (quiereSubir && !arriba) {
    digitalWrite(PIN_ENA, HIGH);
    digitalWrite(PIN_IN1, HIGH);
    digitalWrite(PIN_IN2, LOW);
    return;
  }
  if (quiereBajar && !abajo) {
    digitalWrite(PIN_ENA, HIGH);
    digitalWrite(PIN_IN1, LOW);
    digitalWrite(PIN_IN2, HIGH);
    return;
  }
  parar();
}

Uno D9 → Trig del HC-SR04Pulso corto de disparo. Uno D8 → Echo del HC-SR04En el Uno a 5 V el eco entra directo. Uno D6 → Cable de señal del servoEl servo no va a un pin de alimentación. Uno D2 → LED rojo y resistencia a GNDBarrera cerrada. Uno D3 → LED ámbar y resistencia a GNDBarrera en movimiento. Uno D4 → LED verde y resistencia a GNDBarrera abierta. Uno 5 V → VCC del HC-SR04 y del servo5 V. No alimentes el servo a 12 V. Uno GND → GND del sensor, del servo y de los LEDMasa común, también si el servo come de otra fuente de 5 V.

// AP-EAG-18 Garaje: ultrasonidos, servo y semaforo
// Pines: D9 trig, D8 echo, D6 servo, D2 rojo, D3 ambar, D4 verde
#include <Servo.h>
const int PIN_TRIG = 9;
const int PIN_ECHO = 8;
const int PIN_SERVO = 6;
const int PIN_ROJO = 2;
const int PIN_AMBAR = 3;
const int PIN_VERDE = 4;
Servo barrera;
int angulo = 0;
int destino = 0;
unsigned long anterior = 0;

long distanciaCm() {
  digitalWrite(PIN_TRIG, LOW);
  delayMicroseconds(2);
  digitalWrite(PIN_TRIG, HIGH);
  delayMicroseconds(10);
  digitalWrite(PIN_TRIG, LOW);
  unsigned long eco = pulseIn(PIN_ECHO, HIGH, 30000UL);
  if (eco == 0) return 999;
  return (long)(eco * 0.0343 / 2.0);
}

void luces() {
  bool moviendo = angulo != destino;
  digitalWrite(PIN_ROJO, (!moviendo && angulo == 0) ? HIGH : LOW);
  digitalWrite(PIN_AMBAR, moviendo ? HIGH : LOW);
  digitalWrite(PIN_VERDE, (!moviendo && angulo >= 90) ? HIGH : LOW);
}

void setup() {
  pinMode(PIN_TRIG, OUTPUT);
  pinMode(PIN_ECHO, INPUT);
  pinMode(PIN_ROJO, OUTPUT);
  pinMode(PIN_AMBAR, OUTPUT);
  pinMode(PIN_VERDE, OUTPUT);
  barrera.attach(PIN_SERVO);
  barrera.write(0);
  Serial.begin(9600);
}

void loop() {
  long cm = distanciaCm();
  destino = (cm > 4 && cm < 18) ? 90 : 0;
  if (millis() - anterior > 20) {
    anterior = millis();
    if (angulo < destino) angulo++;
    if (angulo > destino) angulo--;
    barrera.write(angulo);
  }
  luces();
  Serial.print(cm);
  Serial.print(F(" cm  ang "));
  Serial.println(angulo);
  delay(30);
}

Salida digital del sensor-hall → Uno D2Interrupción. Un flanco por vuelta. Uno D6 → LED y resistencia a GNDTestigo de pulso. Uno D7 → L298N IN1Sentido fijo. Uno D8 → L298N IN2Complementario de IN1. Uno D9 → L298N ENAPWM bajo para no perder pulsos a ojo. Uno 5 V → VCC del Hall y lógica del puenteEl motor no sale de este 5 V si tu fuente de potencia es otra. Uno GND → GND del Hall y del puenteMasa común con la fuente del motor. Fuente de 5 a 12 V → Potencia del L298NNo conmutas la red. Sujeta el imán antes de dar corriente.

// AP-EAG-19 Vueltas con sensor Hall
// Pines: D2 Hall, D6 LED, D7 IN1, D8 IN2, D9 ENA
// Motor de 5 a 12 V. No se conmuta la red. Un iman, una vuelta.
const int PIN_HALL = 2;
const int PIN_LED = 6;
const int PIN_IN1 = 7;
const int PIN_IN2 = 8;
const int PIN_ENA = 9;
volatile unsigned int pulsos = 0;
unsigned long anterior = 0;

void contar() { pulsos++; }

void setup() {
  pinMode(PIN_HALL, INPUT_PULLUP);
  pinMode(PIN_LED, OUTPUT);
  pinMode(PIN_IN1, OUTPUT);
  pinMode(PIN_IN2, OUTPUT);
  pinMode(PIN_ENA, OUTPUT);
  digitalWrite(PIN_IN1, HIGH);
  digitalWrite(PIN_IN2, LOW);
  analogWrite(PIN_ENA, 90);
  attachInterrupt(digitalPinToInterrupt(PIN_HALL), contar, FALLING);
  Serial.begin(9600);
  anterior = millis();
  Serial.println(F("Una bajada en D2 es una vuelta."));
}

void loop() {
  if (millis() - anterior < 1000) return;
  anterior = millis();
  noInterrupts();
  unsigned int n = pulsos;
  pulsos = 0;
  interrupts();
  unsigned int rpm = n * 60;
  digitalWrite(PIN_LED, n ? HIGH : LOW);
  Serial.print(F("vueltas/s "));
  Serial.print(n);
  Serial.print(F("  rpm "));
  Serial.println(rpm);
  delay(40);
  digitalWrite(PIN_LED, LOW);
}

Uno D8 → IN del reléSe fuerza a reposo antes de cualquier otra lógica. Uno D7 → LED y resistencia a GNDLatido. Si se queda fijo, el perro está a punto de actuar o ya actuó. Uno D2 → Pulsador de cuelgue hacia GNDMientras lo mantienes, el bucle no alimenta al watchdog. Uno D4 → Pulsador de confirmación hacia GNDSolo tras un reinicio por el perro permite armar el relé. Uno 5 V → VCC del módulo de reléBobina del módulo, no la carga de potencia. Uno GND → GND del relé y de los pulsadoresMasa común. Contacto del relé → Carga de 5 a 12 VNo conmutas la red. Tras un cuelgue la carga no debe volver sola.

// AP-EAG-20 Rearranque seguro con watchdog
// Pines: D8 rele, D7 LED, D2 cuelgue, D4 confirmar
// Libreria de nucleo avr/wdt.h. Carga del rele de 5 a 12 V, sin red.
#include <avr/wdt.h>
const int PIN_RELE = 8;
const int PIN_LED = 7;
const int PIN_CUELGUE = 2;
const int PIN_OK = 4;
const int RELE_ON = LOW;
const int RELE_OFF = HIGH;
uint8_t causaReset __attribute__((section(".noinit")));

void capturaCausa() __attribute__((naked, used, section(".init3")));
void capturaCausa() {
  causaReset = MCUSR;
  MCUSR = 0;
  wdt_disable();
}

bool vinoDelPerro = false;
bool confirmado = false;
unsigned long ultimoLatido = 0;
bool ledAlto = false;

void setup() {
  pinMode(PIN_RELE, OUTPUT);
  digitalWrite(PIN_RELE, RELE_OFF);
  pinMode(PIN_LED, OUTPUT);
  pinMode(PIN_CUELGUE, INPUT_PULLUP);
  pinMode(PIN_OK, INPUT_PULLUP);
  vinoDelPerro = causaReset & _BV(WDRF);
  Serial.begin(9600);
  if (vinoDelPerro) {
    Serial.println(F("Reinicio por watchdog. Rele apagado hasta confirmar."));
  } else {
    Serial.println(F("Arranque normal. Watchdog a 2 s."));
    confirmado = true;
  }
  wdt_enable(WDTO_2S);
}

void loop() {
  if (digitalRead(PIN_CUELGUE) == LOW) {
    Serial.println(F("Cuelgue voluntario. Suelta el boton."));
    while (digitalRead(PIN_CUELGUE) == LOW) {}
  }
  wdt_reset();
  if (vinoDelPerro && !confirmado && digitalRead(PIN_OK) == LOW) {
    confirmado = true;
    Serial.println(F("Confirmado. Ya puedes armar el rele."));
  }
  if (confirmado && !vinoDelPerro) {
    digitalWrite(PIN_RELE, RELE_OFF);
  }
  if (millis() - ultimoLatido > 200) {
    ultimoLatido = millis();
    ledAlto = !ledAlto;
    digitalWrite(PIN_LED, ledAlto ? HIGH : LOW);
  }
}