Arduino · Proyectos

ESP32 GPIO4 → Resistencia y LED hacia GNDEl pin fuente el LED. No pongas el LED directo a 3,3 V. USB del ordenador → Conector del DevKitAlimentas la placa por USB. No inyectes 5 V en un GPIO. ESP32 GND → Cátodo del LEDCierra el circuito del indicador. Teléfono → Punto de acceso TallerLocalÚnete solo a ese nombre. No actives datos móviles para esta prueba: la página vive en la placa. La dirección habitual es 192.168.4.1, escríbela tal cual, sin prefijo.

// AP-FEN-01 ESP32 punto de acceso local y un LED
// Pin: GPIO4 LED. Solo softAP, sin router y sin cuenta.
#include <WiFi.h>
#include <WebServer.h>
const int PIN_LED = 4;
const char* NOMBRE_AP = "TallerLocal";
const char* CLAVE_AP = "taller1234";
WebServer servicio(80);

void paginaRaiz() {
  String cuerpo = "<html><body><h1>Taller local</h1><p>LED ";
  cuerpo += digitalRead(PIN_LED) ? "encendido" : "apagado";
  cuerpo += "</p><p><a href=\"/encender\">Encender</a></p>";
  cuerpo += "<p><a href=\"/apagar\">Apagar</a></p></body></html>";
  servicio.send(200, "text/html", cuerpo);
}

void setup() {
  pinMode(PIN_LED, OUTPUT);
  digitalWrite(PIN_LED, LOW);
  Serial.begin(115200);
  WiFi.mode(WIFI_AP);
  WiFi.softAP(NOMBRE_AP, CLAVE_AP);
  servicio.on("/", paginaRaiz);
  servicio.on("/encender", []() {
    digitalWrite(PIN_LED, HIGH);
    paginaRaiz();
  });
  servicio.on("/apagar", []() {
    digitalWrite(PIN_LED, LOW);
    paginaRaiz();
  });
  servicio.begin();
  Serial.println(F("AP local levantado. Sin ruta hacia fuera."));
  Serial.println(WiFi.softAPIP());
}

void loop() {
  servicio.handleClient();
}

ESP32 GPIO16 → Datos del DHT11Una sola línea. No la pongas en un pin de solo entrada. ESP32 GPIO34 → Salida del TMP36GPIO34 es ADC y no sirve como salida. Perfecto para este sensor. ESP32 pin 3,3 V → VCC del DHT11 y del TMP36No uses 5 V: el ADC del ESP32 no lo admite. ESP32 GND → GND de los dos sensoresMasa común. Punto de acceso de la placa → Navegador del teléfonoSin nube. La página solo existe dentro de TallerLocal. Dirección habitual 192.168.4.1, sin prefijo.

// AP-FEN-02 ESP32 pagina local de sensores, sin nube
// Pines: GPIO16 DHT11, GPIO34 TMP36. Punto de acceso, sin router.
#include <WiFi.h>
#include <WebServer.h>
#include <DHT.h>
const int PIN_DHT = 16;
const int PIN_TMP = 34;
DHT dht(PIN_DHT, DHT11);
WebServer servicio(80);

float leerTmp36() {
  int crudo = analogRead(PIN_TMP);
  float voltios = crudo * (3.3f / 4095.0f);
  return (voltios - 0.5f) * 100.0f;
}

void pagina() {
  float td = dht.readTemperature();
  float ta = leerTmp36();
  String cuerpo = "<html><body><h1>Sensores locales</h1><p>DHT11: ";
  cuerpo += String(td, 1);
  cuerpo += " C</p><p>TMP36: ";
  cuerpo += String(ta, 1);
  cuerpo += " C</p><p>No sale de esta placa.</p></body></html>";
  servicio.send(200, "text/html", cuerpo);
}

void setup() {
  Serial.begin(115200);
  analogReadResolution(12);
  dht.begin();
  WiFi.mode(WIFI_AP);
  WiFi.softAP("TallerLocal", "taller1234");
  servicio.on("/", pagina);
  servicio.begin();
  Serial.println(WiFi.softAPIP());
  Serial.println(F("Sin nube y sin cuenta."));
}

void loop() {
  servicio.handleClient();
}

ESP32 GPIO4 → LED y resistencia a GNDIndicador del umbral. ESP32 GPIO17 → Pulsador hacia GNDCada pulsación suma uno al umbral y lo guarda. USB → DevKitAlimentación de la placa mientras pruebas. Luego puede ser un cargador local, no un servicio. ESP32 GND → LED y pulsadorMasa común. Router de casa → ESP32 unido por la clave de tu Wi-FiEsa clave es la de tu LAN, no una cuenta. No abras puertos. La página solo responde en la dirección local que imprime el monitor.

// AP-FEN-03 Ajustes guardados y servicio solo en la LAN
// Pines: GPIO4 LED, GPIO17 pulsador. Archivo local, sin salir de casa.
#include <WiFi.h>
#include <WebServer.h>
#include <LittleFS.h>
const int PIN_LED = 4;
const int PIN_BOTON = 17;
const char* NOMBRE_LAN = "MiCasa";
const char* CLAVE_LAN = "clave-de-casa";
int umbral = 20;
WebServer servicio(80);

void guardar() {
  File f = LittleFS.open("/umbral.txt", "w");
  if (!f) return;
  f.println(umbral);
  f.close();
}

void cargar() {
  File f = LittleFS.open("/umbral.txt", "r");
  if (!f) return;
  umbral = f.parseInt();
  f.close();
  if (umbral < 0 || umbral > 100) umbral = 20;
}

void pagina() {
  String cuerpo = "<html><body><h1>Solo LAN</h1><p>Umbral ";
  cuerpo += umbral;
  cuerpo += "</p><p>No hay conexion hacia fuera.</p></body></html>";
  servicio.send(200, "text/html", cuerpo);
}

void setup() {
  pinMode(PIN_LED, OUTPUT);
  pinMode(PIN_BOTON, INPUT_PULLUP);
  Serial.begin(115200);
  if (!LittleFS.begin(true)) {
    Serial.println(F("No se pudo montar el archivo."));
  }
  cargar();
  WiFi.mode(WIFI_STA);
  WiFi.begin(NOMBRE_LAN, CLAVE_LAN);
  while (WiFi.status() != WL_CONNECTED) delay(300);
  servicio.on("/", pagina);
  servicio.begin();
  Serial.println(WiFi.localIP());
  Serial.println(F("Escuchando solo en la LAN. No abras el router."));
}

void loop() {
  servicio.handleClient();
  if (digitalRead(PIN_BOTON) == LOW) {
    delay(30);
    if (digitalRead(PIN_BOTON) == LOW) {
      umbral += 1;
      if (umbral > 100) umbral = 0;
      guardar();
      while (digitalRead(PIN_BOTON) == LOW) delay(10);
    }
  }
  int prueba = 25;
  digitalWrite(PIN_LED, prueba >= umbral ? HIGH : LOW);
}

ESP32 GPIO4 → LED y resistencia a GNDSe enciende con el mensaje 1 y se apaga con el 0. USB → DevKitAlimentación local. ESP32 GND → Cátodo del LEDMasa del indicador. Raspberry de la LAN en el puerto 1883 → ESP32 como clienteBroker en tu red, por ejemplo 192.168.1.50. No pongas un nombre de un servicio público. Sin cuenta.

// AP-FEN-04 MQTT contra un broker de la red local
// Pin: GPIO4 LED. Libreria PubSubClient. Broker en la LAN, puerto 1883.
#include <WiFi.h>
#include <PubSubClient.h>
const int PIN_LED = 4;
const char* NOMBRE_LAN = "MiCasa";
const char* CLAVE_LAN = "clave-de-casa";
IPAddress broker(192, 168, 1, 50);
WiFiClient enlace;
PubSubClient cliente(enlace);

void alLlegar(char* tema, byte* carga, unsigned int largo) {
  if (largo < 1) return;
  if (carga[0] == '1') digitalWrite(PIN_LED, HIGH);
  if (carga[0] == '0') digitalWrite(PIN_LED, LOW);
  Serial.print(F("tema "));
  Serial.println(tema);
}

void setup() {
  pinMode(PIN_LED, OUTPUT);
  Serial.begin(115200);
  WiFi.mode(WIFI_STA);
  WiFi.begin(NOMBRE_LAN, CLAVE_LAN);
  while (WiFi.status() != WL_CONNECTED) delay(300);
  cliente.setServer(broker, 1883);
  cliente.setCallback(alLlegar);
  Serial.println(WiFi.localIP());
}

void reconectar() {
  while (!cliente.connected()) {
    if (cliente.connect("esp32-taller")) {
      cliente.subscribe("taller/led");
      cliente.publish("taller/estado", "vivo");
    } else {
      delay(1000);
    }
  }
}

void loop() {
  if (!cliente.connected()) reconectar();
  cliente.loop();
}

ESP32 GPIO4 → LED y resistencia a GNDTestigo de la versión que está corriendo. USB → DevKitHace falta la primera vez, para meter este sketch. Las siguientes pueden ir por la LAN. ESP32 GND → Cátodo del LEDMasa del LED. Ordenador en la misma LAN → Puerto de red que ofrece la placaArduinoOTA solo desde tu red. Si no ves el puerto, no estás en la misma LAN. No abras puertos en el router.

// AP-FEN-05 Actualizar el programa desde la LAN
// Pin: GPIO4 LED. ArduinoOTA, solo red local. Version de parpadeo 1.
#include <WiFi.h>
#include <ArduinoOTA.h>
const int PIN_LED = 4;
const char* NOMBRE_LAN = "MiCasa";
const char* CLAVE_LAN = "clave-de-casa";
const unsigned long RITMO_MS = 400;
unsigned long anterior = 0;
bool alto = false;

void setup() {
  pinMode(PIN_LED, OUTPUT);
  Serial.begin(115200);
  WiFi.mode(WIFI_STA);
  WiFi.begin(NOMBRE_LAN, CLAVE_LAN);
  while (WiFi.status() != WL_CONNECTED) delay(300);
  ArduinoOTA.setHostname("taller-local");
  ArduinoOTA.setPassword("clave-local");
  ArduinoOTA.onStart([]() { digitalWrite(PIN_LED, LOW); });
  ArduinoOTA.onError([](ota_error_t e) {
    Serial.print(F("Fallo OTA "));
    Serial.println((int)e);
  });
  ArduinoOTA.begin();
  Serial.println(WiFi.localIP());
  Serial.println(F("Listo para recibir el programa solo desde la LAN."));
}

void loop() {
  ArduinoOTA.handle();
  if (millis() - anterior >= RITMO_MS) {
    anterior = millis();
    alto = !alto;
    digitalWrite(PIN_LED, alto ? HIGH : LOW);
  }
}

Uno D8 → Patilla de carga PL del 74HC165Un pulso bajo copia los pulsadores al registro. Uno D9 → Reloj CP del 74HC165Cada flanco saca el siguiente bit. Uno D10 → Salida serie Q7 del 74HC165Aquí lees el bit, no escribas en esta patilla. Uno 5 V → VCC del 74HC165Misma lógica que el Uno. Uno GND → GND del chip y de los ocho pulsadoresMasa común. Sin ella los bits flotan.

// AP-FEN-06 Muchos pulsadores con 74HC165
// Pines: D8 carga, D9 reloj, D10 dato Q7
const int PIN_CARGA = 8;
const int PIN_RELOJ = 9;
const int PIN_DATO = 10;

uint8_t leerTeclas() {
  digitalWrite(PIN_CARGA, LOW);
  delayMicroseconds(5);
  digitalWrite(PIN_CARGA, HIGH);
  uint8_t bits = 0;
  for (int i = 0; i < 8; i++) {
    bits <<= 1;
    if (digitalRead(PIN_DATO)) bits |= 1;
    digitalWrite(PIN_RELOJ, HIGH);
    delayMicroseconds(2);
    digitalWrite(PIN_RELOJ, LOW);
  }
  return bits;
}

void setup() {
  pinMode(PIN_CARGA, OUTPUT);
  pinMode(PIN_RELOJ, OUTPUT);
  pinMode(PIN_DATO, INPUT);
  digitalWrite(PIN_CARGA, HIGH);
  digitalWrite(PIN_RELOJ, LOW);
  Serial.begin(9600);
  Serial.println(F("Ocho teclas en un byte."));
}

void loop() {
  uint8_t teclas = leerTeclas();
  Serial.println(teclas, BIN);
  delay(150);
}

Uno D11 → SER del primer 74HC595Dato serie. El segundo chip no recibe este cable: recibe QH prima del primero. Uno D12 → SRCLK de los dos 74HC595Reloj compartido. Uno D8 → RCLK de los dos 74HC595Cerrojo. Hasta que no sube, los LED no cambian. Uno 5 V → VCC de los dos chipsLógica a 5 V. Los LED salen de las patillas Q, con resistencia. Uno GND → GND de los chips y cátodos de los LEDMasa común.

// AP-FEN-07 Dieciseis LEDs con dos 74HC595
// Pines: D11 SER, D12 SRCLK, D8 RCLK
const int PIN_SER = 11;
const int PIN_CLK = 12;
const int PIN_LATCH = 8;

void escribir16(uint16_t valor) {
  digitalWrite(PIN_LATCH, LOW);
  shiftOut(PIN_SER, PIN_CLK, MSBFIRST, (valor >> 8) & 0xFF);
  shiftOut(PIN_SER, PIN_CLK, MSBFIRST, valor & 0xFF);
  digitalWrite(PIN_LATCH, HIGH);
}

void setup() {
  pinMode(PIN_SER, OUTPUT);
  pinMode(PIN_CLK, OUTPUT);
  pinMode(PIN_LATCH, OUTPUT);
  escribir16(0);
  Serial.begin(9600);
  Serial.println(F("Recorrido de un bit por 16 LED."));
}

void loop() {
  for (int i = 0; i < 16; i++) {
    escribir16((uint16_t)1 << i);
    Serial.println(i);
    delay(120);
  }
}

Uno D9 → LED y resistencia a GNDD9 es OC1A. No elijas otro pin si quieres que el timer lo mueva solo. Uno 5 V → Placa, por USBEl LED lo alimenta el pin, no este 5 V directo. Uno GND → Cátodo del LEDMasa del indicador. Timer 1 → Pin OC1ANo llames a analogWrite en D9 mientras este timer esté configurado: se pisan.

// AP-FEN-08 Senal periodica precisa con timer
// Pin: D9 es OC1A. Onda de 1 Hz por hardware.
// 16 MHz / 256 = 62500 cuentas por segundo.
// Conmutar la pata exige dos coincidencias por ciclo: 62500 / 2 - 1 = 31249.
const int PIN_OC1A = 9;

void setup() {
  pinMode(PIN_OC1A, OUTPUT);
  TCCR1A = 0;
  TCCR1B = 0;
  TCNT1 = 0;
  OCR1A = 31249;
  TCCR1A |= (1 << COM1A0);
  TCCR1B |= (1 << WGM12);
  TCCR1B |= (1 << CS12);
  Serial.begin(9600);
  Serial.println(F("1 Hz en D9. El loop no conmuta el pin."));
}

void loop() {
  Serial.println(TCNT1);
  delay(200);
}

Uno A4 → Lado de 5 V del shifter, canal SDAEl lado de 3,3 V de ese canal va al SDA de la Raspberry. Uno A5 → Lado de 5 V del shifter, canal SCLEl lado de 3,3 V va al SCL de la Raspberry. Uno D8 → LED y resistencia a GNDSe enciende si el byte recibido es 1. Uno 5 V → Alimentación alta del shifterReferencia de 5 V. La Raspberry pone la referencia de 3,3 V en el otro lado. Uno GND → GND del shifter y de la RaspberrySin masa común el bus no existe. Raspberry → Maestra del busLa Pi no es una placa del catálogo de este montaje. Tú la programas aparte para escribir en la dirección 0x12. No pongas 5 V en sus pines.

// AP-FEN-09 Arduino esclavo I2C de una Raspberry
// Pines: A4 SDA, A5 SCL, D8 LED. Direccion 0x12.
// La recepcion entra por Wire.onReceive. El Uno no llama al maestro.
#include <Wire.h>
const int PIN_SDA = A4;
const int PIN_SCL = A5;
const int PIN_LED = 8;
const byte DIRECCION = 0x12;
volatile byte ultimo = 0;
volatile bool nuevo = false;

void alRecibir(int cuantos) {
  while (Wire.available()) {
    ultimo = Wire.read();
    nuevo = true;
  }
  (void)cuantos;
}

void setup() {
  pinMode(PIN_LED, OUTPUT);
  digitalWrite(PIN_LED, LOW);
  Wire.begin(DIRECCION);
  Wire.onReceive(alRecibir);
  Serial.begin(9600);
  Serial.println(F("Esclavo 0x12 esperando."));
}

void loop() {
  if (!nuevo) return;
  noInterrupts();
  byte valor = ultimo;
  nuevo = false;
  interrupts();
  digitalWrite(PIN_LED, valor == '1' ? HIGH : LOW);
  Serial.print(F("byte "));
  Serial.println(valor, HEX);
}

Uno D0 → Recepción de la tramaRX. Por el USB lo usa el puente serie. No lo ocupes con otro cable mientras programas. Uno D1 → Envío de la respuestaTX hacia la Pi o hacia el monitor. Uno D8 → LED y resistencia a GNDIndicador de trama aceptada. USB → UnoAlimentación y, a la vez, camino serie con el ordenador o la Pi. Uno GND → GND del LED y, si vas por pines, de la PiSi el enlace es el propio USB, la masa ya viaja por el cable. Raspberry o monitor → Trama que empieza por 0xAANo envíes texto suelto si quieres ver el LED. Hace falta la cabecera, la longitud y la suma.

// AP-FEN-10 Protocolo propio por serie con una Pi
// Pines: D0 RX, D1 TX, D8 LED
// Trama: 0xAA, longitud, datos, XOR de los datos.
const int PIN_RX = 0;
const int PIN_TX = 1;
const int PIN_LED = 8;
const byte CABECERA = 0xAA;
enum Fase { ESPERA, LONGITUD, DATOS, SUMA };
Fase fase = ESPERA;
byte esperado = 0;
byte leidos = 0;
byte acumulado = 0;
byte datos[8];

void setup() {
  pinMode(PIN_LED, OUTPUT);
  Serial.begin(9600);
  Serial.println(F("Esperando trama AA."));
}

void loop() {
  if (!Serial.available()) return;
  byte b = Serial.read();
  if (fase == ESPERA) {
    if (b == CABECERA) fase = LONGITUD;
    return;
  }
  if (fase == LONGITUD) {
    if (b == 0 || b > 8) { fase = ESPERA; return; }
    esperado = b;
    leidos = 0;
    acumulado = 0;
    fase = DATOS;
    return;
  }
  if (fase == DATOS) {
    datos[leidos++] = b;
    acumulado ^= b;
    if (leidos >= esperado) fase = SUMA;
    return;
  }
  if (b == acumulado) {
    digitalWrite(PIN_LED, datos[0] == '1' ? HIGH : LOW);
    Serial.println(F("trama ok"));
  } else {
    Serial.println(F("suma mala"));
    digitalWrite(PIN_LED, LOW);
  }
  fase = ESPERA;
}

Salida del TMP36 → Uno A0No uses un pin digital para esta lectura. Uno 5 V → VCC del TMP36En el Uno la referencia del ADC es 5 V, así que el sensor también va a 5 V. Uno GND → GND del TMP36 y del pulsadorMasa común. Uno D2 → Pulsador hacia GNDAl pulsarlo, la próxima muestra se sustituye por un pico.

// AP-FEN-11 Media movil y mediana en un sensor ruidoso
// Pines: A0 TMP36, D2 pico de prueba
const int PIN_SENSOR = A0;
const int PIN_PICO = 2;
const int N = 9;
int ventana[N];
int indice = 0;
bool llena = false;

float aGrados(int crudo) {
  float v = crudo * (5.0f / 1023.0f);
  return (v - 0.5f) * 100.0f;
}

float media() {
  long s = 0;
  int n = llena ? N : indice;
  if (n == 0) return 0;
  for (int i = 0; i < n; i++) s += ventana[i];
  return s / (float)n;
}

float mediana() {
  int n = llena ? N : indice;
  int copia[N];
  for (int i = 0; i < n; i++) copia[i] = ventana[i];
  for (int i = 0; i < n; i++) {
    for (int j = i + 1; j < n; j++) {
      if (copia[j] < copia[i]) {
        int t = copia[i];
        copia[i] = copia[j];
        copia[j] = t;
      }
    }
  }
  return aGrados(copia[n / 2]);
}

void setup() {
  pinMode(PIN_PICO, INPUT_PULLUP);
  Serial.begin(9600);
  Serial.println(F("Media y mediana del TMP36."));
}

void loop() {
  int crudo = analogRead(PIN_SENSOR);
  if (digitalRead(PIN_PICO) == LOW) crudo = 900;
  ventana[indice] = crudo;
  indice++;
  if (indice >= N) { indice = 0; llena = true; }
  Serial.print(F("media "));
  Serial.print(aGrados((int)media()) >= 0 ? media() : 0);
  Serial.print(F(" cuentas_media "));
  Serial.print(media(), 1);
  Serial.print(F("  mediana_C "));
  Serial.println(mediana(), 1);
  delay(200);
}

Uno D2 → Pulsador de armar hacia GNDActivo a bajo, con antirrebote. Uno D3 → Reed hacia GNDCerrado a masa cuando el imán está junto al reed, es decir, puerta cerrada. Uno D8 → LED y resistencia a GNDSolo luce en el estado disparada. Uno 5 V → Placa por USBNo hay otra alimentación en esta maqueta. Uno GND → Pulsador, reed y LEDMasa común.

// AP-FEN-12 Alarma de casa por estados
// Pines: D2 armar, D3 reed, D8 LED
enum Estado { DESARMADA, SALIDA, ARMADA, ENTRADA, DISPARADA };
const int PIN_ARMAR = 2;
const int PIN_REED = 3;
const int PIN_LED = 8;
Estado estado = DESARMADA;
unsigned long marca = 0;
bool estable = HIGH;
unsigned long cambio = 0;

bool flancoArmar() {
  bool crudo = digitalRead(PIN_ARMAR);
  if (crudo != estable) {
    if (millis() - cambio > 30) {
      estable = crudo;
      cambio = millis();
      return crudo == LOW;
    }
  } else {
    cambio = millis();
  }
  return false;
}

bool puertaAbierta() { return digitalRead(PIN_REED) == HIGH; }

void setup() {
  pinMode(PIN_ARMAR, INPUT_PULLUP);
  pinMode(PIN_REED, INPUT_PULLUP);
  pinMode(PIN_LED, OUTPUT);
  Serial.begin(9600);
}

void loop() {
  bool armar = flancoArmar();
  if (estado == DESARMADA && armar) { estado = SALIDA; marca = millis(); }
  else if (estado == SALIDA && millis() - marca > 5000) estado = ARMADA;
  else if (estado == ARMADA && puertaAbierta()) { estado = ENTRADA; marca = millis(); }
  else if (estado == ENTRADA && !puertaAbierta()) estado = ARMADA;
  else if (estado == ENTRADA && millis() - marca > 4000) estado = DISPARADA;
  else if ((estado == ARMADA || estado == ENTRADA || estado == DISPARADA || estado == SALIDA) && armar && estado != SALIDA) {
    estado = DESARMADA;
  }
  if (armar && estado == SALIDA && millis() - marca > 300) estado = DESARMADA;
  digitalWrite(PIN_LED, estado == DISPARADA ? HIGH : LOW);
  Serial.println((int)estado);
  delay(20);
}

Uno D2 → Pulsador de anotar hacia GNDUn flanco, una escritura. Uno D8 → LED y resistencia a GNDConfirma la escritura. Salida del TMP36 → Uno A0Origen de la muestra. Uno 5 V → VCC del TMP36Referencia de 5 V, igual que el ADC. Uno GND → GND del sensor, del pulsador y del LEDMasa común.

// AP-FEN-13 Registro circular en EEPROM
// Pines: D2 anotar, D8 LED, A0 TMP36
#include <EEPROM.h>
const int PIN_BOTON = 2;
const int PIN_LED = 8;
const int PIN_SENSOR = A0;
const int POS_CABEZA = 0;
const int BASE = 1;
const int CAPACIDAD = 32;

int cabeza() {
  int h = EEPROM.read(POS_CABEZA);
  if (h < 0 || h >= CAPACIDAD) h = 0;
  return h;
}

void anotar(byte valor) {
  int h = cabeza();
  EEPROM.update(BASE + h, valor);
  h = (h + 1) % CAPACIDAD;
  EEPROM.update(POS_CABEZA, h);
}

void volcar() {
  int h = cabeza();
  Serial.println(F("anillo, de mas viejo a mas nuevo"));
  for (int i = 0; i < CAPACIDAD; i++) {
    int idx = (h + i) % CAPACIDAD;
    Serial.println(EEPROM.read(BASE + idx));
  }
}

void setup() {
  pinMode(PIN_BOTON, INPUT_PULLUP);
  pinMode(PIN_LED, OUTPUT);
  Serial.begin(9600);
  volcar();
}

void loop() {
  if (digitalRead(PIN_BOTON) != LOW) return;
  delay(30);
  if (digitalRead(PIN_BOTON) != LOW) return;
  float v = analogRead(PIN_SENSOR) * (5.0f / 1023.0f);
  int grados = (int)((v - 0.5f) * 100.0f);
  if (grados < 0) grados = 0;
  if (grados > 255) grados = 255;
  anotar((byte)grados);
  digitalWrite(PIN_LED, HIGH);
  Serial.print(F("guardado "));
  Serial.println(grados);
  delay(200);
  digitalWrite(PIN_LED, LOW);
  while (digitalRead(PIN_BOTON) == LOW) delay(10);
}

Pro Mini D2 → Pulsador hacia GNDLa interrupción es por nivel bajo. Mantenerlo pulsado lo deja despierto. Pro Mini D4 → LED y resistencia a GNDTestigo de vigilia. Pro Mini VCC → Alimentación de 5 V del adaptador o de una pila reguladaNo alimentes este modelo de 5 V con 3,3 V ni al revés. Pro Mini GND → GND del pulsador, del LED y del adaptadorMasa común. Sin ella ni programas ni despierta.

// AP-FEN-14 Sueno y despertar por interrupcion
// Pines: D2 despertar, D4 LED. Placa Pro Mini.
// Registro: SLEEP_MODE_PWR_DOWN. LowPower.powerDown hace este mismo corte.
#include <avr/sleep.h>
#include <avr/interrupt.h>
const int PIN_DESPERTAR = 2;
const int PIN_LED = 4;

void despertar() {}

void dormir() {
  set_sleep_mode(SLEEP_MODE_PWR_DOWN);
  sleep_enable();
  attachInterrupt(digitalPinToInterrupt(PIN_DESPERTAR), despertar, LOW);
  interrupts();
  sleep_cpu();
  sleep_disable();
  detachInterrupt(digitalPinToInterrupt(PIN_DESPERTAR));
}

void setup() {
  pinMode(PIN_DESPERTAR, INPUT_PULLUP);
  pinMode(PIN_LED, OUTPUT);
  Serial.begin(9600);
  Serial.println(F("Me dormire. Pulsa D2 para despertar."));
}

void loop() {
  digitalWrite(PIN_LED, HIGH);
  delay(300);
  digitalWrite(PIN_LED, LOW);
  Serial.println(F("a dormir"));
  Serial.flush();
  while (digitalRead(PIN_DESPERTAR) == LOW) delay(10);
  dormir();
  Serial.println(F("despierto"));
}

TMP36 salida → Uno A0Canal de temperatura. Divisor de la LDR → Uno A1LDR a 5 V, resistencia a masa, nudo central a A1. Hall analógico → Uno A2No uses la patilla digital del módulo para esta recta. Uno 5 V → Alimentación de los tres sensoresMisma referencia que el ADC, si no la recta no vale. Uno GND → Masa de los tres sensoresMasa común.

// AP-FEN-15 Calibracion en dos puntos de varias entradas
// Pines: A0 TMP36, A1 LDR, A2 Hall
// Cada canal: cuentas bajas, valor bajo, cuentas altas, valor alto.
const int PIN_TMP = A0;
const int PIN_LDR = A1;
const int PIN_HALL = A2;
const int TMP_C0 = 140;
const float TMP_V0 = 0.0f;
const int TMP_C1 = 200;
const float TMP_V1 = 25.0f;
const int LDR_C0 = 200;
const float LDR_V0 = 10.0f;
const int LDR_C1 = 800;
const float LDR_V1 = 80.0f;
const int HALL_C0 = 500;
const float HALL_V0 = 0.0f;
const int HALL_C1 = 700;
const float HALL_V1 = 1.0f;

float recta(int cuentas, int c0, float v0, int c1, float v1) {
  if (c1 == c0) return v0;
  return v0 + (v1 - v0) * (cuentas - c0) / (float)(c1 - c0);
}

void setup() {
  Serial.begin(9600);
  Serial.println(F("Dos puntos por canal, constantes en el sketch."));
}

void loop() {
  int t = analogRead(PIN_TMP);
  int l = analogRead(PIN_LDR);
  int h = analogRead(PIN_HALL);
  Serial.print(F("T "));
  Serial.print(recta(t, TMP_C0, TMP_V0, TMP_C1, TMP_V1), 1);
  Serial.print(F("  luz "));
  Serial.print(recta(l, LDR_C0, LDR_V0, LDR_C1, LDR_V1), 1);
  Serial.print(F("  campo "));
  Serial.println(recta(h, HALL_C0, HALL_V0, HALL_C1, HALL_V1), 2);
  delay(400);
}

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 lo alimentes a 12 V para ir más rápido. Uno GND → ULN2003 GNDMasa común.

// AP-FEN-16 Paso a paso con rampa de aceleracion
// Pines: D8 IN1, D9 IN2, D10 IN3, D11 IN4
// El periodo baja de 6 ms a 2 ms de uno en uno, y luego sube. No hay salto.
const int PINES[4] = {8, 9, 10, 11};
const int SECUENCIA[4][4] = {
  {1, 0, 0, 0},
  {0, 1, 0, 0},
  {0, 0, 1, 0},
  {0, 0, 0, 1}
};
const int PASOS = 800;
const int PERIODO_LENTO = 6000;
const int PERIODO_RAPIDO = 2000;

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

void setup() {
  for (int b = 0; b < 4; b++) pinMode(PINES[b], OUTPUT);
  Serial.begin(9600);
  int periodo = PERIODO_LENTO;
  int dirPeriodo = -20;
  for (int n = 0; n < PASOS; n++) {
    aplicar(n);
    delayMicroseconds(periodo);
    periodo += dirPeriodo;
    if (periodo <= PERIODO_RAPIDO) { periodo = PERIODO_RAPIDO; dirPeriodo = 20; }
    if (periodo >= PERIODO_LENTO) { periodo = PERIODO_LENTO; dirPeriodo = -20; }
  }
  for (int b = 0; b < 4; b++) digitalWrite(PINES[b], LOW);
  Serial.println(F("Rampa hecha. Bobinas sueltas."));
}

void loop() {}

Salida del TMP36 → Uno A0Temperatura de proceso. Uno D9 → Entrada del transistorPWM. La carga cuelga del transistor, no del pin. Uno D6 → LED y resistencia a GNDSe enciende si el mando pasa de un umbral, para ver el esfuerzo sin medir la carga. Uno 5 V → VCC del TMP36Referencia del sensor. Uno GND → Masa del sensor, del transistor y de la fuente de cargaMasa común obligatoria. Fuente de 5 a 12 V → Carga térmica a través del transistorNo conmutas la red. Una resistencia de potencia pequeña o una lámpara de baja tensión. Nada de enchufe de casa.

// AP-FEN-17 PID de temperatura con anti-windup
// Pines: A0 TMP36, D9 PWM, D6 LED
// La integral se recorta a I_MAX e I_MIN. No basta con recortar la salida.
const int PIN_SENSOR = A0;
const int PIN_PWM = 9;
const int PIN_LED = 6;
const float CONSIGNA = 30.0f;
const float KP = 8.0f;
const float KI = 0.5f;
const float KD = 1.0f;
const float I_MAX = 40.0f;
const float I_MIN = -40.0f;
float integral = 0;
float errorPrevio = 0;
unsigned long tPrevio = 0;

float leerGrados() {
  float v = analogRead(PIN_SENSOR) * (5.0f / 1023.0f);
  return (v - 0.5f) * 100.0f;
}

int pasoPid(float medida) {
  unsigned long ahora = millis();
  float dt = (ahora - tPrevio) / 1000.0f;
  tPrevio = ahora;
  if (dt <= 0 || dt > 2) return 0;
  float error = CONSIGNA - medida;
  integral += error * dt;
  if (integral > I_MAX) integral = I_MAX;
  if (integral < I_MIN) integral = I_MIN;
  float derivada = (error - errorPrevio) / dt;
  errorPrevio = error;
  float mando = KP * error + KI * integral + KD * derivada;
  if (mando > 255) mando = 255;
  if (mando < 0) mando = 0;
  return (int)mando;
}

void setup() {
  pinMode(PIN_PWM, OUTPUT);
  pinMode(PIN_LED, OUTPUT);
  analogWrite(PIN_PWM, 0);
  tPrevio = millis();
  Serial.begin(9600);
  Serial.println(F("PID con integral limitada. Carga de 5 a 12 V."));
}

void loop() {
  float t = leerGrados();
  int mando = pasoPid(t);
  analogWrite(PIN_PWM, mando);
  digitalWrite(PIN_LED, mando > 40 ? HIGH : LOW);
  Serial.print(F("C "));
  Serial.print(t, 1);
  Serial.print(F("  mando "));
  Serial.print(mando);
  Serial.print(F("  I "));
  Serial.println(integral, 2);
  delay(200);
}

Uno A4 → Lado alto del shifter, canal SDAEl lado bajo va al SDA del BMP280. Uno A5 → Lado alto del shifter, canal SCLEl lado bajo va al SCL del BMP280. Uno pin de 3,3 V → VCC del BMP280 y referencia baja del shifterNo alimentes el sensor a 5 V. Uno 5 V → Referencia alta del shifterSolo el shifter, no el sensor. Uno GND → GND del sensor y del shifterMasa común.

// AP-FEN-18 Ver los bytes que pasan por I2C
// Pines: A4 SDA, A5 SCL. BMP280 a 3,3 V.
#include <Wire.h>
const int PIN_SDA = A4;
const int PIN_SCL = A5;

void imprimirByte(byte b) {
  if (b < 16) Serial.print('0');
  Serial.print(b, HEX);
  Serial.print(' ');
}

void explorar() {
  Serial.println(F("direcciones que contestan"));
  for (byte dir = 1; dir < 127; dir++) {
    Wire.beginTransmission(dir);
    if (Wire.endTransmission() == 0) {
      Serial.print(F("ACK "));
      imprimirByte(dir);
      Serial.println();
    }
  }
}

void leerIdentidad() {
  Serial.println(F("escritura direccion 76, registro D0"));
  Wire.beginTransmission(0x76);
  Wire.write(0xD0);
  byte err = Wire.endTransmission();
  Serial.print(F("fin escritura "));
  Serial.println(err);
  Wire.requestFrom(0x76, 1);
  Serial.print(F("lectura "));
  while (Wire.available()) imprimirByte(Wire.read());
  Serial.println();
}

void setup() {
  Wire.begin();
  Serial.begin(9600);
  delay(200);
  explorar();
  leerIdentidad();
}

void loop() {
  delay(2000);
  leerIdentidad();
}

Uno D2 D3 D4 D5 D6 D7 D8 D9 D10 D11 D12 → Nada, durante el testDéjalos libres. Un cable a masa hará fallar ese pin a propósito. Uno A0 A1 A2 A3 A4 A5 → Nada, o el sensor que quieras observarEl test no juzga un valor único: imprime las cuentas. Uno D13 → LED de resumenAlto continuo si ningún digital leyó bajo. USB → UnoAlimentación mientras miras el monitor. Uno GND → Referencia del ensayoPuedes tocar un pin digital contra masa para ver cómo el test lo señala.

// AP-FEN-19 Autotest de pines al arrancar
// Pines: D2 D3 D4 D5 D6 D7 D8 D9 D10 D11 D12 A0 A1 A2 A3 A4 A5 D13
const int DIGITALES[] = {2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
const int N_DIG = 11;
const int ANALOGICAS[] = {A0, A1, A2, A3, A4, A5};
const int PIN_RESUMEN = 13;
int fallos = 0;

void setup() {
  Serial.begin(9600);
  pinMode(PIN_RESUMEN, OUTPUT);
  Serial.println(F("Autotest. Los digitales tienen que leer alto."));
  for (int i = 0; i < N_DIG; i++) {
    pinMode(DIGITALES[i], INPUT_PULLUP);
    delay(2);
    int v = digitalRead(DIGITALES[i]);
    Serial.print(F("D"));
    Serial.print(DIGITALES[i]);
    if (v == HIGH) Serial.println(F(" alto"));
    else {
      Serial.println(F(" pegado a masa"));
      fallos++;
    }
  }
  for (int i = 0; i < 6; i++) {
    int v = analogRead(ANALOGICAS[i]);
    Serial.print(F("A"));
    Serial.print(i);
    Serial.print(' ');
    Serial.println(v);
    if (v == 0 || v >= 1020) {
      Serial.println(F("analógica clavada, revisa el cable"));
    }
  }
  digitalWrite(PIN_RESUMEN, fallos == 0 ? HIGH : LOW);
  Serial.print(F("fallos "));
  Serial.println(fallos);
}

void loop() {}

Uno D5 → LED de la luz y resistencia a GNDLa luz no pasa por el relé. Uno D2 → Pulsador de la luz hacia GNDCada flanco cambia la luz. Uno D3 → Reed de la puerta hacia GNDBajo con la puerta cerrada. Salida del TMP36 → Uno A0Temperatura. Uno D7 → IN del reléSolo para la carga de baja tensión. Uno 5 V → TMP36 y VCC del módulo de reléLa bobina del módulo sale de aquí. La carga, no. Uno GND → Sensores, pulsador, LED y reléMasa común con la fuente de la carga. Contacto del relé → Lámpara o timbre de 5 a 12 VNo conmutas la red. Esta casa de maqueta no tiene enchufe de pared.

// AP-FEN-20 Mini hogar offline: luz, puerta, temperatura y rele
// Pines: D5 luz, D2 pulsador, D3 reed, A0 TMP36, D7 rele
// Sin radio. Rele de 5 a 12 V. No se conmuta la red.
const int PIN_LUZ = 5;
const int PIN_BOTON = 2;
const int PIN_REED = 3;
const int PIN_TEMP = A0;
const int PIN_RELE = 7;
const int RELE_ON = LOW;
const int RELE_OFF = HIGH;
const float UMBRAL_C = 29.0f;
bool luz = false;
bool botonAntes = HIGH;
enum Estado { REPOSO, PUERTA, CALOR, AMBOS };
Estado estado = REPOSO;

float leerGrados() {
  float v = analogRead(PIN_TEMP) * (5.0f / 1023.0f);
  return (v - 0.5f) * 100.0f;
}

void setup() {
  pinMode(PIN_LUZ, OUTPUT);
  pinMode(PIN_BOTON, INPUT_PULLUP);
  pinMode(PIN_REED, INPUT_PULLUP);
  pinMode(PIN_RELE, OUTPUT);
  digitalWrite(PIN_RELE, RELE_OFF);
  digitalWrite(PIN_LUZ, LOW);
  Serial.begin(9600);
  Serial.println(F("Hogar de mesa, sin enlace."));
}

void loop() {
  bool boton = digitalRead(PIN_BOTON);
  if (botonAntes == HIGH && boton == LOW) luz = !luz;
  botonAntes = boton;
  digitalWrite(PIN_LUZ, luz ? HIGH : LOW);
  bool abierta = digitalRead(PIN_REED) == HIGH;
  bool calor = leerGrados() >= UMBRAL_C;
  if (abierta && calor) estado = AMBOS;
  else if (abierta) estado = PUERTA;
  else if (calor) estado = CALOR;
  else estado = REPOSO;
  digitalWrite(PIN_RELE, (estado == PUERTA || estado == CALOR || estado == AMBOS) ? RELE_ON : RELE_OFF);
  Serial.print(F("estado "));
  Serial.print((int)estado);
  Serial.print(F("  C "));
  Serial.println(leerGrados(), 1);
  delay(200);
}