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.

¿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
| Especie | Días de incubación | Temperatura (aire forzado) | Humedad: primera etapa | Humedad: etapa final | Etapa final (sin volteo) |
|---|---|---|---|---|---|
| Gallina | 21 días | 37,5 °C | 50–55 % | 65–75 % | Día 18 |
| Codorniz japonesa | 17–18 días | 37,5 °C | 45–55 % | 65–75 % | Día 14 |
| Pato Pekín | 28 días | 37,5 °C | 55–60 % | 65–75 % | Día 25 |
| Pavo (guajolote) | 28 días | 37,5 °C | 55–60 % | 65–75 % | Día 25 |
| Ganso | 28–32 días (según la raza) | 37,2–37,5 °C | 55–60 % | 70–80 % | 3 días antes de la eclosión |
| Pato criollo (Muscovy) | 35 días | 37,5 °C | 55–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
| Pieza | Función | Nota |
|---|---|---|
| Arduino Uno | Placa de control | También sirve un Nano; los pines son los mismos |
| DHT22 (AM2302) | Medir temperatura y humedad | El error de ±2 °C del DHT11 es demasiado para una incubadora |
| Módulo relé (2 canales) | Calefactor y humidificador | Contactos de 10 A; con calefactor de 12 V también sirve un MOSFET |
| Calefactor | Fuente de calor | Opciones en la tabla de abajo |
| Servo MG996R | Inclinar la charola de huevos | Para unos pocos huevos de codorniz basta un SG90 |
| Ventilador de 12 V (80 mm) | Mover el aire | Uno de gabinete de computadora es ideal; funciona todo el tiempo |
| LCD I2C 16x2 | Mostrar temperatura, humedad y día | La dirección suele ser 0x27 |
| Buzzer y botón | Alarma e inicio de una nueva incubación | El botón va entre D3 y GND |
| Hielera de unicel o refrigerador viejo | Caja aislada | Un buen aislamiento da temperatura más estable y menos consumo |
| Recipiente ancho con agua | Fuente de humedad | La humedad depende de la superficie del agua, no de la cantidad |
| Eliminadores de 12 V y 5 V | Alimentación | Usa un eliminador de 5 V y 2 A aparte para el servo |
Cómo elegir el calefactor y conectar el relé

| Calefactor | Voltaje y potencia | Control | Ventajas y desventajas |
|---|---|---|---|
| Foco incandescente | 110–220 V, 25–60 W | Mó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 W | Relé o SSR | No da luz y dura mucho; sigue siendo voltaje de red |
| Calefactor PTC (con ventilador) | 12 V, 50–100 W | Relé o MOSFET | Bajo voltaje y limita su propia temperatura |
| Resistencia o tapete calefactor | 12 V, 20–60 W | MOSFET | Silencioso; 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.
Diagrama de conexiones (Arduino Uno)
| Pieza | Pin de la pieza | Arduino Uno | Nota |
|---|---|---|---|
| DHT22 | VCC / DATA / GND | 5V / D2 / GND | Con el sensor sin módulo, 10 kΩ entre DATA y VCC |
| Relé del calefactor | IN | D7 | VCC del relé a 5V, GND común |
| Relé del humidificador | IN | D8 | Opcional (nebulizador ultrasónico) |
| Servo (MG996R) | Señal (naranja) | D9 | Rojo a 5 V externo, café a GND |
| Buzzer | + | D6 | La otra pata a GND |
| Botón | Una pata | D3 | La otra pata a GND (pull-up interno) |
| LCD I2C 16x2 | SDA / SCL | A4 / A5 | VCC a 5V, GND |
| Ventilador de 12 V | + / - | Eliminador de 12 V | No 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.
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.
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.
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?.
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–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.
- 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.
- Día 1: Acomoda los huevos acostados en la charola y enciende la placa con el botón presionado; el contador empieza en cero.
- 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.
- 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.
- 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.
- 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.
Proyectos para hacer después de leer esto
Ver todos los proyectos
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…

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.

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…

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…

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.

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.

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.

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).
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

