Guías · 12 min de lectura

Incubadora casera con Arduino: DHT22, relé, servo y código

Incubadora casera con Arduino paso a paso: DHT22 para temperatura y humedad, relé para el calefactor, volteo con servo, conteo de días y monitoreo con ESP32.

Hacer una incubadora casera con Arduino es uno de los proyectos más emocionantes que existen, porque convierte la medición de temperatura y humedad en un resultado vivo: si mantienes 37,5 °C con una décima de grado de precisión durante 21 días, de un huevo sale un pollito. Las incubadoras comerciales pueden ser caras o no traer los ajustes de la especie que te interesa. Con un Arduino Uno, un sensor DHT22, un módulo relé, un calefactor y un servo puedes armar tú mismo una máquina ajustable para huevos de gallina, codorniz y pato, que voltea los huevos sola y lleva la cuenta de los días.

En esta guía te explicamos paso a paso la tabla de temperatura, humedad y duración por especie, la lista de materiales, cómo elegir el calefactor, el diagrama de conexiones, la histéresis que evita que el calefactor se prenda y apague sin parar, y un código completo para Arduino. El código recuerda el día en que iba gracias a la EEPROM cuando se va la luz, apaga el calefactor y da la alarma si falla el sensor. En las últimas secciones verás cómo vigilar la incubadora desde el celular con un ESP32, un termostato en MicroPython con la Raspberry Pi Pico y el calendario de los 21 días.

Sensor de temperatura y humedad DHT22
Sensor de temperatura y humedad DHT22 (AM2302): con ±0,5 °C de precisión y un rango de humedad de 0 a 100 % es mucho más adecuado para una incubadora que el DHT11.

¿Cómo funciona una incubadora?

Cuando una gallina se echa sobre sus huevos les da cuatro cosas al mismo tiempo, y la incubadora imita esas cuatro. La mayoría de las incubadoras caseras son de "aire forzado": un pequeño ventilador mueve el aire todo el tiempo, así que la temperatura es igual en todos los rincones de la caja. En las de aire quieto (sin ventilador), el aire caliente se junta arriba, por lo que se mide a la altura de la parte superior de los huevos y la meta se pone cerca de 1 °C más alta.

  • Temperatura: El embrión necesita una temperatura estable de unos 37,5 °C para desarrollarse. Incluso desviaciones de 1 °C bajan el porcentaje de nacimientos, y más de 39,5 °C puede matar al embrión en poco tiempo.
  • Humedad: El agua se evapora por los poros del cascarón. Si la humedad es muy baja, el huevo pierde demasiada agua; si es muy alta, al pollito le cuesta romper el cascarón.
  • Volteo: Voltear el huevo varias veces al día evita que el embrión se pegue a la membrana del cascarón.
  • Ventilación: El embrión consume oxígeno y produce dióxido de carbono; la caja necesita unos cuantos agujeros pequeños para que circule el aire.

Tabla de temperatura, humedad y días de incubación por especie

EspecieDías de incubaciónTemperatura (aire forzado)Humedad: primera etapaHumedad: etapa finalEtapa final (sin volteo)
Gallina21 días37,5 °C50–55 %65–75 %Día 18
Codorniz japonesa17–18 días37,5 °C45–55 %65–75 %Día 14
Pato Pekín28 días37,5 °C55–60 %65–75 %Día 25
Pavo (guajolote)28 días37,5 °C55–60 %65–75 %Día 25
Ganso28–32 días (según la raza)37,2–37,5 °C55–60 %70–80 %3 días antes de la eclosión
Pato criollo (Muscovy)35 días37,5 °C55–60 %65–75 %Día 32

Estos son los rangos más recomendados en las guías de incubación; la raza, la edad del huevo y la altitud de tu ciudad pueden pedir pequeños ajustes, algo a tener en cuenta en lugares altos como Bogotá, Quito o Ciudad de México. La "etapa final" o "lockdown" es la última fase, unos tres días antes de la eclosión: los huevos ya no se voltean, se sube la humedad y no se abre la tapa. Si usas una incubadora de aire quieto, mantén 38,3–38,9 °C a la altura de la parte superior de los huevos. Mide siempre la temperatura a la altura de los huevos; entre el techo y el piso de la caja puede haber 1–2 °C de diferencia.

Lista de materiales

PiezaFunciónNota
Arduino UnoPlaca de controlTambién sirve un Nano; los pines son los mismos
DHT22 (AM2302)Medir temperatura y humedadEl error de ±2 °C del DHT11 es demasiado para una incubadora
Módulo relé (2 canales)Calefactor y humidificadorContactos de 10 A; con calefactor de 12 V también sirve un MOSFET
CalefactorFuente de calorOpciones en la tabla de abajo
Servo MG996RInclinar la charola de huevosPara unos pocos huevos de codorniz basta un SG90
Ventilador de 12 V (80 mm)Mover el aireUno de gabinete de computadora es ideal; funciona todo el tiempo
LCD I2C 16x2Mostrar temperatura, humedad y díaLa dirección suele ser 0x27
Buzzer y botónAlarma e inicio de una nueva incubaciónEl botón va entre D3 y GND
Hielera de unicel o refrigerador viejoCaja aisladaUn buen aislamiento da temperatura más estable y menos consumo
Recipiente ancho con aguaFuente de humedadLa humedad depende de la superficie del agua, no de la cantidad
Eliminadores de 12 V y 5 VAlimentaciónUsa un eliminador de 5 V y 2 A aparte para el servo

Cómo elegir el calefactor y conectar el relé

Módulo relé para Arduino
Módulo relé: con la pequeña señal de 5 V del Arduino prende y apaga cargas de alta corriente como un calefactor; en la mayoría de los módulos el relé se activa cuando el pin IN está en LOW.
CalefactorVoltaje y potenciaControlVentajas y desventajas
Foco incandescente110–220 V, 25–60 WMódulo reléBarato y fácil de conseguir; voltaje de red, da luz y dura poco
Calefactor cerámico (tipo terrario)110–220 V, 25–100 WRelé o SSRNo da luz y dura mucho; sigue siendo voltaje de red
Calefactor PTC (con ventilador)12 V, 50–100 WRelé o MOSFETBajo voltaje y limita su propia temperatura
Resistencia o tapete calefactor12 V, 20–60 WMOSFETSilencioso; permite control proporcional con PWM

Para una hielera de unicel (telgopor, icopor o poliestireno expandido) de unos 40 litros, un calefactor de 20–40 W suele ser suficiente; uno demasiado potente se pasa de la meta y hace oscilar la temperatura. Calcula la corriente de los calefactores de 12 V con I = P / V: un PTC de 50 W consume unos 4,2 A a 12 V, así que necesitas cable grueso y un relé que aguante esa corriente o un MOSFET de nivel lógico. Para el cálculo usa la herramienta Ley de Ohm; para conectar el MOSFET, revisa Cómo usar un MOSFET con Arduino, y para los detalles del relé, ¿Qué es un módulo relé?. Si quieres prender y apagar el calefactor muy seguido, un relé de estado sólido (SSR), silencioso y sin desgaste, es una gran opción.

Si usas un foco o un calefactor cerámico conectado a la red eléctrica (110–220 V), haz todas las conexiones de red dentro de una caja cerrada, con clemas aisladas y un fusible; en proyectos escolares prefiere los calefactores de 12 V. Agrega además una protección que no dependa del software: un termostato bimetálico (como el KSD301) en serie con el calefactor, que abre el circuito a 40–45 °C, protege los huevos y la caja aunque el código o el relé se queden trabados.

Diagrama de conexiones (Arduino Uno)

PiezaPin de la piezaArduino UnoNota
DHT22VCC / DATA / GND5V / D2 / GNDCon el sensor sin módulo, 10 kΩ entre DATA y VCC
Relé del calefactorIND7VCC del relé a 5V, GND común
Relé del humidificadorIND8Opcional (nebulizador ultrasónico)
Servo (MG996R)Señal (naranja)D9Rojo a 5 V externo, café a GND
Buzzer+D6La otra pata a GND
BotónUna pataD3La otra pata a GND (pull-up interno)
LCD I2C 16x2SDA / SCLA4 / A5VCC a 5V, GND
Ventilador de 12 V+ / -Eliminador de 12 VNo va al Arduino; funciona todo el tiempo

Histéresis: ¿por qué el calefactor no debe prenderse y apagarse sin parar?

Si el código solo dijera "si está por debajo de 37,5 prende el calefactor y si está por arriba apágalo", el relé haría clic cada dos segundos mientras la lectura va y viene entre 37,4 y 37,6. Los contactos de un relé mecánico aguantan unas 100.000 conmutaciones, y un control así acaba con esa vida en pocos días. Con histéresis, el calefactor se prende por debajo de 37,3 °C y se apaga al pasar de 37,7 °C; en la zona intermedia conserva su estado anterior. En una caja bien aislada eso significa unas 20–30 conmutaciones por hora, entre 10.000 y 15.000 en una incubación de 21 días, así que un relé aguanta varias incubaciones sin problema. Encontrarás la explicación detallada de la histéresis en Termostato con Arduino.

El calefactor sigue caliente aun después de apagarse, por eso la temperatura puede subir un poco por encima de 37,7. El ventilador reparte ese calor rápido. Si aun así oscila más de ±0,5 °C, usa un calefactor más pequeño o maneja uno de 12 V con un MOSFET y PWM mediante control PID; la temperatura se queda fija en la décima de grado.

Código de la incubadora con Arduino

Instala desde el Gestor de Librerías DHT sensor library (Adafruit) y LiquidCrystal I2C; las librerías Servo y EEPROM ya vienen con el Arduino IDE. Elige la especie con el valor SPECIES al inicio del código (0 gallina, 1 codorniz, 2 pato). Para empezar una incubación nueva, enciende la placa con el botón de D3 presionado y el contador vuelve a cero. Si la enciendes sin presionarlo, la placa sigue desde el día en que iba.

C++ (Arduino IDE)
1// Arduino kuluçka makinesi / Arduino egg incubator
2#include <Wire.h>
3#include <LiquidCrystal_I2C.h>
4#include <DHT.h>
5#include <Servo.h>
6#include <EEPROM.h>
7
8const int DHT_PIN = 2;
9const int BUTTON_PIN = 3;        // açılışta basılı tut: yeni kuluçka / hold at power-on: new hatch
10const int BUZZER_PIN = 6;
11const int HEATER_PIN = 7;        // ısıtıcı rölesi / heater relay
12const int HUMIDIFIER_PIN = 8;    // nemlendirici rölesi (isteğe bağlı) / humidifier relay (optional)
13const int SERVO_PIN = 9;
14const bool RELAY_ACTIVE_LOW = true;   // çoğu röle modülü LOW ile çeker / most relay modules switch on LOW
15
16struct Profile {
17  const char* name;
18  byte days;          // toplam kuluçka süresi / total incubation days
19  byte lockdownDay;   // çevirmenin durduğu gün / day turning stops
20  float temp;         // hedef sıcaklık °C / target temperature °C
21  byte hum;           // ilk dönem nem % / humidity before lockdown
22  byte humLock;       // son günler nem % / humidity during lockdown
23};
24const Profile PROFILES[] = {
25  {"Tavuk/Chicken", 21, 18, 37.5, 50, 70},
26  {"Bildircin/Quail", 17, 14, 37.5, 50, 70},
27  {"Ordek/Duck", 28, 25, 37.5, 55, 75},
28};
29const byte SPECIES = 0;          // 0 tavuk, 1 bıldırcın, 2 ördek / 0 chicken, 1 quail, 2 duck
30
31const float HYST = 0.2;          // histerezis: 37,3'te aç, 37,7'de kapat / hysteresis: on at 37.3, off at 37.7
32const float ALARM_LOW = 36.0;
33const float ALARM_HIGH = 38.5;
34const uint32_t TURN_EVERY_MIN = 120;  // 2 saatte bir çevir / turn every 2 hours
35
36struct SaveData {
37  uint16_t magic;
38  uint32_t minutes;              // geçen dakika / elapsed minutes
39  byte species;
40  byte angle;                    // tepsinin son açısı / last tray angle
41};
42const uint16_t MAGIC = 0xB10E;   // EEPROM'da geçerli kayıt işareti / valid-record marker
43SaveData save;
44
45LiquidCrystal_I2C lcd(0x27, 16, 2);
46DHT dht(DHT_PIN, DHT22);
47Servo tray;
48
49bool heaterOn = false;
50bool humidifierOn = false;
51int trayAngle = 45;
52uint32_t lastTurnMinute = 0;
53unsigned long lastMinuteMs = 0;
54unsigned long lastReadMs = 0;
55
56void setRelay(int pin, bool on) {
57  digitalWrite(pin, (on != RELAY_ACTIVE_LOW) ? HIGH : LOW);
58}
59
60void moveTraySlowly(int target) {   // yumurtaları sarsmadan çevir / turn the eggs without jolting
61  int step = (target > trayAngle) ? 1 : -1;
62  while (trayAngle != target) {
63    trayAngle += step;
64    tray.write(trayAngle);
65    delay(20);
66  }
67}
68
69void setup() {
70  setRelay(HEATER_PIN, false);       // önce kapalı, sonra çıkış / off first, then output
71  setRelay(HUMIDIFIER_PIN, false);
72  pinMode(HEATER_PIN, OUTPUT);
73  pinMode(HUMIDIFIER_PIN, OUTPUT);
74  pinMode(BUZZER_PIN, OUTPUT);
75  pinMode(BUTTON_PIN, INPUT_PULLUP);
76
77  lcd.init();
78  lcd.backlight();
79  dht.begin();
80  EEPROM.get(0, save);
81  bool invalid = save.magic != MAGIC || save.species >= sizeof(PROFILES) / sizeof(PROFILES[0]);
82  if (invalid || digitalRead(BUTTON_PIN) == LOW) {   // ilk açılış ya da buton / first start or button
83    save.magic = MAGIC;
84    save.minutes = 0;
85    save.species = SPECIES;
86    save.angle = 45;
87    EEPROM.put(0, save);
88  }
89  trayAngle = save.angle;            // tepsi kaldığı yerden devam eder / tray resumes where it was
90  tray.attach(SERVO_PIN);
91  tray.write(trayAngle);
92  lastTurnMinute = save.minutes;
93}
94
95void loop() {
96  const Profile& p = PROFILES[save.species];
97  byte day = save.minutes / 1440 + 1;
98
99  if (millis() - lastMinuteMs >= 60000UL) {    // her dakika / every minute
100    lastMinuteMs += 60000UL;
101    save.minutes++;
102    if (save.minutes % 10 == 0) EEPROM.put(0, save);   // 10 dakikada bir kaydet / save every 10 minutes
103  }
104
105  if (day < p.lockdownDay && save.minutes - lastTurnMinute >= TURN_EVERY_MIN) {
106    moveTraySlowly(trayAngle == 45 ? 135 : 45);   // ±45 derece eğ / tilt ±45 degrees
107    lastTurnMinute = save.minutes;
108    save.angle = trayAngle;
109    EEPROM.put(0, save);
110  } else if (day >= p.lockdownDay && trayAngle != 90) {
111    moveTraySlowly(90);                           // son günlerde düz bırak / keep level during lockdown
112    save.angle = trayAngle;
113    EEPROM.put(0, save);
114  }
115
116  if (millis() - lastReadMs < 2000) return;       // DHT22 en fazla 2 sn'de bir okunur / read every 2 s
117  lastReadMs = millis();
118
119  float t = dht.readTemperature();
120  float h = dht.readHumidity();
121  bool sensorOk = !isnan(t) && !isnan(h);
122
123  if (!sensorOk) {
124    heaterOn = false;                             // sensör yoksa ısıtma / no sensor, no heat
125    humidifierOn = false;
126  } else {
127    if (t < p.temp - HYST) heaterOn = true;
128    if (t > p.temp + HYST) heaterOn = false;
129    byte targetHum = (day >= p.lockdownDay) ? p.humLock : p.hum;
130    if (h < targetHum - 3) humidifierOn = true;
131    if (h > targetHum + 3) humidifierOn = false;
132  }
133  setRelay(HEATER_PIN, heaterOn);
134  setRelay(HUMIDIFIER_PIN, humidifierOn);
135
136  bool alarm = !sensorOk || t > ALARM_HIGH || (t < ALARM_LOW && save.minutes > 60);
137  if (alarm) tone(BUZZER_PIN, 2000, 300); else noTone(BUZZER_PIN);
138
139  lcd.setCursor(0, 0);
140  if (sensorOk) {
141    lcd.print(t, 1);
142    lcd.print("C ");
143    lcd.print(h, 0);
144    lcd.print("% ");
145    lcd.print(heaterOn ? "ISI " : "    ");     // ısıtıcı açık / heater on
146  } else {
147    lcd.print("SENSOR HATASI   ");           // sensör hatası / sensor error
148  }
149  lcd.setCursor(0, 1);
150  lcd.print("Gun ");
151  lcd.print(day);
152  lcd.print("/");
153  lcd.print(p.days);
154  lcd.print(day >= p.lockdownDay ? " KILIT  " : " CEVIR  ");   // kilit = çevirme yok / lockdown = no turning
155}

¿Cómo funciona el código?

  • Perfiles por especie: Para cada especie se guardan en un arreglo los días totales, el día de la etapa final, la temperatura meta y la humedad de las dos etapas. Para agregar otra especie basta con escribir una línea más.
  • Contador de minutos: Con millis() se suma un minuto cada 60 segundos; el día se calcula dividiendo los minutos transcurridos entre 1440.
  • Control de temperatura y humedad: La temperatura se controla con una histéresis de ±0,2 °C y la humedad con ±3 %. Al llegar el día de la etapa final, la humedad meta sube sola.
  • Seguridad: Si el DHT22 no responde, se apagan el calefactor y el humidificador, suena el buzzer y la pantalla muestra "SENSOR HATASI" (error de sensor). La alarma también suena si la temperatura pasa de 38,5 °C o, después de la primera hora, baja de 36 °C.
  • Volteo de huevos: Cada dos horas el servo inclina la charola entre 45 y 135 grados, grado por grado y despacio. Desde el día de la etapa final la charola se queda nivelada en 90 grados.
  • Lógica del relé: La constante RELAY_ACTIVE_LOW elige el nivel correcto para módulos que se activan con LOW. Como los relés se dejan apagados antes de configurar los pines como salida, el calefactor no se prende ni un instante al arrancar.

Registro en EEPROM contra los apagones

Cuando se va la luz y regresa, el Arduino arranca de cero y millis() vuelve a empezar; sin un registro, una incubación en el día 15 creería estar en el día 1 y se saltaría la etapa final. Por eso el código guarda en la EEPROM los minutos transcurridos, la especie y el ángulo de la charola cada 10 minutos y en cada volteo. Cada celda de la EEPROM aguanta unas 100.000 escrituras; como este código hace unas 3.300 escrituras en 21 días, la memoria dura decenas de incubaciones. Debes conocer dos límites: el tiempo que dura el apagón no se cuenta, y el resonador cerámico del Arduino Uno puede desviarse unas horas en 21 días. Si quieres llevar el día al minuto, agrega un módulo de reloj RTC con pila y guarda la fecha de inicio. Para que el código no se quede trabado, también puedes usar el watchdog.

Volteo de huevos: ¿servo o motor?

Hasta la etapa final, los huevos deben voltearse al menos 3–5 veces al día, idealmente cada 1–2 horas. En las incubadoras caseras lo más práctico es una charola donde los huevos van acostados, montada sobre un eje al centro, que un servo inclina unos 45 grados hacia cada lado. Una docena de huevos de gallina con su charola pesa algunos cientos de gramos; para moverla elige un servo de engranes metálicos como el MG996R y coloca la charola balanceada sobre el eje. Alimenta el servo con un eliminador de 5 V aparte y no con el pin 5V del Arduino; si no, el Arduino puede reiniciarse cada vez que el servo se mueve. Para lo básico sobre servos, revisa ¿Qué es un servomotor?. En incubadoras grandes también se usa un motorreductor de 5 vueltas por minuto, pero el servo se instala más fácil y siempre sabe en qué ángulo está.

Vigilar la incubadora desde el celular con un ESP32

La incubadora suele estar en el patio, el gallinero o una bodega, y durante 21 días es difícil ir a revisar la pantalla cada hora. El ESP32 corre el mismo termostato y, con una pequeña página web, te lleva al celular la temperatura, la humedad, el día y el estado del calefactor. El código de abajo tiene una decisión de diseño importante: intenta conectarse al Wi-Fi durante 10 segundos como máximo y, si no lo logra, sigue calentando; la función vital de la máquina nunca debe depender de la red. El contador de días se guarda en la flash del ESP32 con Preferences. Elige un módulo relé que se pueda activar con 3,3 V; en algunos módulos de 5 V que se activan con LOW, el HIGH de 3,3 V del ESP32 no alcanza a soltar el relé por completo. Si quieres recibir un aviso cuando la temperatura salga del rango, combina el código con el método de Bot de Telegram con ESP32.

C++ (Arduino IDE)
1#include <WiFi.h>
2#include <WebServer.h>
3#include <Preferences.h>
4#include <DHT.h>
5
6const char* ssid = "AgAdi";          // Wi-Fi adın / your Wi-Fi name
7const char* password = "Sifre123";   // Wi-Fi şifren / your Wi-Fi password
8const int DHT_PIN = 4;
9const int HEATER_PIN = 26;           // röle IN (LOW ile çeker) / relay IN (active LOW)
10const float TARGET = 37.5;
11const float HYST = 0.2;
12const int INCUBATION_DAYS = 21;
13
14DHT dht(DHT_PIN, DHT22);
15WebServer server(80);
16Preferences prefs;                   // flaşta kalıcı kayıt / persistent storage in flash
17
18float t = NAN, h = NAN;
19bool heaterOn = false;
20uint32_t minutes = 0;
21unsigned long lastReadMs = 0, lastMinuteMs = 0;
22
23void setHeater(bool on) {
24  heaterOn = on;
25  digitalWrite(HEATER_PIN, on ? LOW : HIGH);
26}
27
28void handleRoot() {
29  String s = "<meta name='viewport' content='width=device-width'>"
30             "<meta http-equiv='refresh' content='10'>"
31             "<h2>Kulucka / Incubator</h2>";
32  s += "<p>Sicaklik / Temp: " + String(t, 1) + " C</p>";
33  s += "<p>Nem / Humidity: " + String(h, 0) + " %</p>";
34  s += "<p>Gun / Day: " + String(minutes / 1440 + 1) + " / " + String(INCUBATION_DAYS) + "</p>";
35  s += "<p>Isitici / Heater: " + String(heaterOn ? "ON" : "OFF") + "</p>";
36  server.send(200, "text/html", s);
37}
38
39void setup() {
40  digitalWrite(HEATER_PIN, HIGH);    // önce kapalı / off first
41  pinMode(HEATER_PIN, OUTPUT);
42  Serial.begin(115200);
43  dht.begin();
44  prefs.begin("kulucka", false);
45  minutes = prefs.getUInt("min", 0); // kesintiden sonra kaldığı yerden / resume after a power cut
46
47  WiFi.begin(ssid, password);
48  unsigned long start = millis();
49  while (WiFi.status() != WL_CONNECTED && millis() - start < 10000) delay(250);   // en fazla 10 sn bekle / wait 10 s max
50  Serial.println(WiFi.localIP());
51  server.on("/", handleRoot);
52  server.begin();
53}
54
55void loop() {
56  server.handleClient();             // Wi-Fi yoksa da ısıtma sürer / heating continues without Wi-Fi
57
58  if (millis() - lastMinuteMs >= 60000UL) {
59    lastMinuteMs += 60000UL;
60    minutes++;
61    if (minutes % 10 == 0) prefs.putUInt("min", minutes);
62  }
63
64  if (millis() - lastReadMs < 2000) return;
65  lastReadMs = millis();
66  t = dht.readTemperature();
67  h = dht.readHumidity();
68  if (isnan(t)) setHeater(false);    // sensör okunamadı: ısıtıcı kapalı / sensor failed: heater off
69  else if (t < TARGET - HYST) setHeater(true);
70  else if (t > TARGET + HYST) setHeater(false);
71}

Termostato en MicroPython con Raspberry Pi Pico

La versión de MicroPython para la Raspberry Pi Pico ya trae el controlador del DHT22, así que no necesitas cargar archivos extra. El código de abajo maneja el relé del GP16 con la misma lógica de histéresis y apaga el calefactor si no puede leer el sensor. Sobre esta base puedes agregar un servo, una LCD y un contador de días permanente para pasar toda la versión de Arduino a la Pico; si es la primera vez que la usas, empieza con ¿Qué es la Raspberry Pi Pico?.

MicroPython
1from machine import Pin
2import dht, time
3
4sensor = dht.DHT22(Pin(15))           # DHT22 veri GP15 / DHT22 data on GP15
5heater = Pin(16, Pin.OUT, value=1)    # LOW ile çeken röle, başta kapalı / active-LOW relay, off at start
6TARGET, HYST = 37.5, 0.2
7
8while True:
9    try:
10        sensor.measure()
11        t, h = sensor.temperature(), sensor.humidity()
12        if t < TARGET - HYST:
13            heater.value(0)           # ısıtıcı açık / heater on
14        elif t > TARGET + HYST:
15            heater.value(1)           # ısıtıcı kapalı / heater off
16        state = "ON" if heater.value() == 0 else "OFF"
17        print("{:.1f} C  {:.0f} %  isitici/heater: {}".format(t, h, state))
18    except OSError:
19        heater.value(1)               # sensör okunamadı: güvenli tarafta kal / sensor failed: stay safe
20        print("DHT22 okunamadi / read failed")
21    time.sleep(2)

Calendario de incubación: ¿qué hacer durante los 21 días?

  1. 1–2 días antes de empezar: Prende la incubadora vacía y comprueba que la temperatura y la humedad se mantienen en la meta al menos 24 horas. Compara el sensor con un termómetro de confianza.
  2. Prepara los huevos: Elige huevos limpios, sin grietas y de no más de 7–10 días. Déjalos 8–12 horas a temperatura ambiente para que no "suden" al entrar a la incubadora; no los laves.
  3. Día 1: Acomoda los huevos acostados en la charola y enciende la placa con el botón presionado; el contador empieza en cero.
  4. Días 7 y 14: En un cuarto oscuro, alumbra los huevos con una linterna potente (ovoscopía). Retira los que no muestren red de venas, porque no están fecundados y pueden pudrirse y dañar a los demás.
  5. Día 18: Empieza la etapa final: el código deja de voltear, nivela la charola y sube la humedad meta. A partir de aquí no abras la tapa.
  6. Días 19–21: Los pollitos rompen primero la membrana interna y luego el cascarón; puede tardar 12–24 horas. No intentes ayudarlos rompiendo el cascarón.
  7. Después de la eclosión: Deja a los pollitos en la incubadora 12–24 horas hasta que se sequen las plumas y luego pásalos a una criadora con calor.

Errores comunes y cómo solucionarlos

  • La temperatura está en la meta pero no nace ningún pollito: El sensor puede estar lejos de los huevos, por ejemplo en el techo. Colócalo a la altura de los huevos y compruébalo con un termómetro de referencia.
  • La temperatura se dispara a 39 °C: El calefactor es demasiado potente para la caja. Usa uno más chico, pon el ventilador frente al calefactor o pasa a control PID.
  • La humedad no sube: La superficie del recipiente de agua es pequeña. Usa uno más ancho o uno con una esponja adentro y, si hace falta, cierra un poco los agujeros de ventilación.
  • Al regresar la luz el día volvió a cero: Quizá el botón se quedó presionado al arrancar. Recuerda también que el tiempo del apagón no se cuenta; para apagones largos agrega un RTC.
  • El servo tiembla o el Arduino se reinicia: El servo se está alimentando del pin 5V del Arduino. Usa un eliminador de 5 V aparte y une las tierras (GND).
  • El DHT22 da NaN de vez en cuando: El cable es muy largo o falta la resistencia pull-up. Con el sensor sin módulo agrega 10 kΩ y deja el cable en 1–2 metros; mientras tanto, el código apaga el calefactor por seguridad.

La incubadora junta en un solo proyecto la lectura de sensores, el control con histéresis, el manejo de motores, la memoria permanente y el pensamiento en seguridad, y al final da un resultado que de verdad está vivo. Primero prueba la máquina vacía durante unos días y, cuando los valores estén estables, coloca tus primeros huevos. En la app BlueGrays encontrarás, con diagramas y código paso a paso, los proyectos de temperatura y humedad con DHT11, DHT22 con LCD en ESP32, medición de temperatura con NTC, LCD I2C, control de un foco de 220 V con relé y servomotor, para que pruebes por separado cada parte de esta máquina.

Preguntas frecuentes

¿A qué temperatura debe estar una incubadora de huevos?

En una incubadora de aire forzado la meta es 37,5 °C para huevos de gallina, codorniz, pato y pavo; para ganso bastan 37,2–37,5 °C. En las de aire quieto el calor se acumula arriba, así que se mantienen 38,3–38,9 °C a la altura de la parte superior de los huevos. Mide siempre a la altura de los huevos.

¿Qué humedad necesita una incubadora casera?

Para huevos de gallina se recomienda 50–55 % durante los primeros 18 días y 65–75 % en los últimos tres. Los huevos de pato y de pavo piden un poco más en la primera etapa, alrededor de 55–60 %. La humedad depende de la superficie del recipiente de agua, no de la cantidad de agua.

¿Sirve el DHT11 para una incubadora?

No es recomendable. El DHT11 tiene un error de ±2 °C y en la incubación hasta 1 °C de diferencia baja el porcentaje de nacimientos. El DHT22 (±0,5 °C), el SHT31 o el DS18B20 para la temperatura dan resultados mucho más confiables.

¿Qué pasa si se va la luz durante la incubación?

En apagones de pocas horas los huevos se enfrían despacio y casi siempre los embriones sobreviven; mientras tanto no abras la tapa y puedes cubrir la caja con una cobija. Cuando el Arduino vuelve a encender, el código de este artículo sigue desde el día en que iba gracias a la EEPROM. Para apagones largos piensa en un no-break y un módulo RTC.

¿Cuántas veces al día hay que voltear los huevos?

Hasta la etapa final, al menos 3–5 veces al día; en las incubadoras automáticas es común voltearlos cada 1–2 horas. Si lo haces a mano, voltéalos un número impar de veces para que no pasen todas las noches sobre el mismo lado. Tres días antes de la eclosión deja de voltearlos por completo.

¿Qué foco o calefactor usar en una incubadora casera?

Las opciones más comunes son el foco incandescente, el calefactor cerámico y el calefactor PTC de 12 V. En proyectos escolares o de principiantes, los de 12 V son más seguros porque no trabajas con el voltaje de la red. Elijas el que elijas, agrega un termostato bimetálico que funcione sin depender del software.

Ver todos los proyectos
Temperatura y humedad con DHT11
AR-55Intermedio

Temperatura y humedad con DHT11

¿Qué temperatura hace en tu habitación, y el aire está húmedo o seco? El sensor DHT11 mide la temperatura y la humedad, y el Arduino escribe los valores en una pantalla LCD de dos líneas…

4.7(47)
83
ESP32 DHT22 Temperatura y humedad (con pantalla LCD)
ES-15Intermedio

ESP32 DHT22 Temperatura y humedad (con pantalla LCD)

Se trata de un proyecto que mide la temperatura y la humedad ambientales mediante el sensor DHT22 y las muestra en tiempo real en una pantalla LCD I2C 16x2. Los datos del sensor se leen mediante el protocolo de un solo cable (one-wire) utilizando la biblioteca DHT de Adafruit. Este proyecto constituye la base para estaciones meteorológicas IoT, sistemas de automatización doméstica inteligente o sistemas de monitorización ambiental en invernaderos.

4.8(38)
57
Medición de temperatura con NTC y pantalla LCD 2x16
AR-44Principiante
Premium

Medición de temperatura con NTC y pantalla LCD 2x16

Mide la temperatura del ambiente con un sensor que parece una pequeña cuenta. Esta pieza, llamada NTC, deja pasar la electricidad con más facilidad cuanto más se calienta; el Arduino lee ese cambio…

4.5(33)
44
Uso de la pantalla LCD con I2C
AR-32Principiante
Premium

Uso de la pantalla LCD con I2C

Dale a tu Arduino su propia pantalla y haz que escriba su primer mensaje. La pantalla LCD de dos líneas se conecta con solo unos pocos cables; primero aparece un saludo en la línea de arriba, luego…

4.8(53)
70
Bombilla 220V con Pulsador (Push)
AR-19Avanzado
Premium

Bombilla 220V con Pulsador (Push)

Mientras mantienes pulsado el botón, una bombilla real de 220 voltios se queda encendida, y se apaga en cuanto lo sueltas.

4.4(30)
38
Uso del servomotor
AR-35Principiante
Premium

Uso del servomotor

El brazo de un pequeño servomotor gira por turnos a tres posiciones: al principio del todo, justo al centro y al final del todo, esperando dos segundos en cada parada.

4.7(48)
67
Registrador de Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Avanzado
Premium

Registrador de Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)

¡Monta con el ESP32 un registrador de temperatura y humedad con hora! Un sensor DHT22 lee la temperatura y la humedad una vez por minuto, y cada lectura se guarda en una tarjeta microSD en formato CSV con la hora real del módulo RTC DS1307. La pantalla OLED muestra en vivo y con letra grande la última temperatura, la humedad, la marca de tiempo y el total de registros.

4.7(7)
12
Servidor web asíncrono ESP32 (con indicación de IP en la pantalla LCD)
ES-27Avanzado

Servidor web asíncrono ESP32 (con indicación de IP en la pantalla LCD)

En este proyecto, convertimos el ESP32 en un servidor web asíncrono que puedes controlar desde tu teléfono o tu ordenador, siempre que estén conectados a la misma red Wi-Fi. Gracias a la biblioteca ESPAsyncWebServer, el servidor puede procesar varias solicitudes al mismo tiempo (a diferencia del clásico WebServer.h, que se bloquea con una sola solicitud).

4.8(16)
26