Guide · 11 min di lettura

Incubatrice Arduino fai da te: DHT22, relè, servo e codice

Incubatrice Arduino fai da te: DHT22 per temperatura e umidità, riscaldatore con relè, girauova a servo, contatore dei giorni in EEPROM e controllo con ESP32.

Costruire un'incubatrice Arduino è uno dei progetti più emozionanti che ci siano, perché trasforma le misure di temperatura e umidità in un risultato vivo: mantieni 37,5 °C al decimo di grado per 21 giorni e da un uovo nasce un pulcino. Le incubatrici in commercio possono costare parecchio o non offrire le impostazioni per la specie che ti interessa. Con un Arduino Uno, un sensore DHT22, un relè, un riscaldatore e un servo puoi costruire da solo una macchina regolabile per uova di gallina, quaglia e anatra, che gira le uova da sola e conta i giorni.

In questa guida vediamo passo passo la tabella di temperatura, umidità e durata per specie, l'elenco dei materiali, la scelta del riscaldatore, lo schema dei collegamenti, l'isteresi che impedisce al riscaldatore di accendersi e spegnersi di continuo e uno sketch Arduino completo. Il codice si ricorda dalla EEPROM a che giorno era dopo un blackout, spegne il riscaldatore e dà l'allarme se il sensore si guasta. Nelle ultime sezioni trovi il monitoraggio a distanza con un ESP32, un termostato in MicroPython per il Raspberry Pi Pico e il calendario dei 21 giorni di incubazione.

Sensore di temperatura e umidità DHT22
Sensore di temperatura e umidità DHT22 (AM2302): con ±0,5 °C di precisione e un campo di umidità da 0 a 100 % è molto più adatto del DHT11 a un'incubatrice.

Come funziona un'incubatrice?

Quando una chioccia cova le uova fornisce quattro cose insieme, e l'incubatrice le imita tutte e quattro. La maggior parte delle incubatrici fai da te è "ad aria forzata": una piccola ventola muove l'aria di continuo, così la temperatura è uguale in ogni angolo della scatola. Nelle incubatrici ad aria statica (senza ventola) l'aria calda si accumula in alto, quindi si misura all'altezza della parte superiore delle uova e si punta a circa 1 °C in più.

  • Temperatura: l'embrione ha bisogno di una temperatura stabile di circa 37,5 °C per svilupparsi. Anche scostamenti di 1 °C abbassano la percentuale di schiusa, e oltre i 39,5 °C l'embrione può morire in poco tempo.
  • Umidità: l'acqua evapora dai pori del guscio. Se l'umidità è troppo bassa l'uovo perde troppa acqua; se è troppo alta il pulcino fatica a rompere il guscio.
  • Rivoltamento: girare l'uovo più volte al giorno impedisce all'embrione di attaccarsi alla membrana del guscio.
  • Ventilazione: l'embrione consuma ossigeno e produce anidride carbonica; la scatola ha bisogno di qualche piccolo foro di aerazione.

Temperatura, umidità e durata dell'incubazione per specie

SpecieDurata dell'incubazioneTemperatura (aria forzata)Umidità: incubazioneUmidità: schiusaStop al rivoltamento
Gallina21 giorni37,5 °C50–55 %65–75 %Giorno 18
Quaglia giapponese17–18 giorni37,5 °C45–55 %65–75 %Giorno 14
Anatra (Pechino)28 giorni37,5 °C55–60 %65–75 %Giorno 25
Tacchino28 giorni37,5 °C55–60 %65–75 %Giorno 25
Oca28–32 giorni (secondo la razza)37,2–37,5 °C55–60 %70–80 %3 giorni prima della schiusa
Anatra muta35 giorni37,5 °C55–60 %65–75 %Giorno 32

Sono gli intervalli più consigliati nelle guide all'incubazione; la razza, l'età delle uova e l'altitudine possono richiedere piccoli aggiustamenti. La "fase di schiusa" è l'ultima, circa tre giorni prima della nascita: le uova non si girano più, l'umidità sale e il coperchio resta chiuso. Se usi un'incubatrice ad aria statica, mantieni 38,3–38,9 °C all'altezza della parte superiore delle uova. Misura sempre la temperatura all'altezza delle uova; tra il soffitto e il fondo della scatola possono esserci 1–2 °C di differenza.

Elenco dei materiali

ComponenteFunzioneNota
Arduino UnoScheda di controlloVa bene anche un Nano; i pin sono gli stessi
DHT22 (AM2302)Misura di temperatura e umiditàL'errore di ±2 °C del DHT11 è troppo per l'incubazione
Modulo relè (2 canali)Riscaldatore e umidificatoreContatti da 10 A; con un riscaldatore a 12 V va bene anche un MOSFET
RiscaldatoreFonte di caloreOpzioni nella tabella qui sotto
Servo MG996RInclinare il vassoio delle uovaPer poche uova di quaglia basta un SG90
Ventola 12 V (80 mm)Muovere l'ariaUna ventola da case per PC è l'ideale; gira sempre
LCD I2C 16x2Mostrare temperatura, umidità e giornoIndirizzo di solito 0x27
Buzzer e pulsanteAllarme e avvio di una nuova covaIl pulsante va tra D3 e GND
Box in polistirolo o vecchio frigoriferoInvolucro isolatoUn buon isolamento dà una temperatura più stabile e meno consumi
Vaschetta larga per l'acquaFonte di umiditàL'umidità dipende dalla superficie dell'acqua, non dalla quantità
Alimentatori da 12 V e 5 VAlimentazioneUsa un alimentatore da 5 V e 2 A separato per il servo

Scegliere il riscaldatore e collegare il relè

Modulo relè per Arduino
Modulo relè: permette al piccolo segnale a 5 V di Arduino di accendere e spegnere carichi ad alta corrente come un riscaldatore; nella maggior parte dei moduli il relè scatta quando il pin IN va a LOW.
RiscaldatoreTensione e potenzaComandoPro e contro
Lampadina a incandescenza230 V, 25–60 WModulo relèEconomica e facile da trovare; tensione di rete, fa luce, dura poco
Emettitore in ceramica (da terrario)230 V, 25–100 WRelè o SSRNon fa luce, dura a lungo; resta a tensione di rete
Riscaldatore PTC (con ventola)12 V, 50–100 WRelè o MOSFETBassa tensione, limita da solo la propria temperatura
Resistenza o tappetino riscaldante12 V, 20–60 WMOSFETSilenzioso, permette un controllo proporzionale in PWM

Per un box in polistirolo da circa 40 litri un riscaldatore da 20–40 W di solito basta; uno troppo potente supera l'obiettivo e fa oscillare la temperatura. Calcola la corrente di un riscaldatore a 12 V con I = P / V: un PTC da 50 W assorbe circa 4,2 A a 12 V, quindi servono cavi spessi e un relè adatto a quella corrente, oppure un MOSFET a livello logico. Per il calcolo usa lo strumento Legge di Ohm; per collegare il MOSFET leggi Usare un MOSFET con Arduino, e per i dettagli sul relè Cos'è un modulo relè?. Se vuoi accendere e spegnere il riscaldatore molto spesso, un relè a stato solido (SSR), silenzioso e senza usura, è un'ottima scelta.

Se usi una lampadina o un emettitore in ceramica a 230 V, fai tutti i collegamenti di rete dentro una scatola chiusa, con morsetti isolati e un fusibile; nei progetti scolastici preferisci i riscaldatori a 12 V. Aggiungi anche una protezione indipendente dal software: un termostato bimetallico (come il KSD301) in serie al riscaldatore, che apre il circuito a 40–45 °C, protegge uova e scatola anche se il codice o il relè restano bloccati.

Schema dei collegamenti (Arduino Uno)

ComponentePin del componenteArduino UnoNota
DHT22VCC / DATA / GND5V / D2 / GNDCon il sensore nudo, 10 kΩ tra DATA e VCC
Relè del riscaldatoreIND7VCC del relè a 5V, GND in comune
Relè dell'umidificatoreIND8Opzionale (nebulizzatore a ultrasuoni)
Servo (MG996R)Segnale (arancione)D9Rosso ai 5 V esterni, marrone a GND
Buzzer+D6L'altro terminale a GND
PulsanteUn terminaleD3L'altro terminale a GND (pull-up interno)
LCD I2C 16x2SDA / SCLA4 / A5VCC a 5V, GND
Ventola 12 V+ / -Alimentatore 12 VNon va ad Arduino; gira sempre

Isteresi: perché il riscaldatore non deve scattare di continuo

Se il codice dicesse solo "sotto 37,5 riscaldatore acceso, sopra spento", il relè scatterebbe ogni due secondi mentre la lettura oscilla tra 37,4 e 37,6. I contatti di un relè meccanico reggono circa 100.000 commutazioni e un controllo così ne consumerebbe la vita in pochi giorni. Con l'isteresi il riscaldatore si accende sotto i 37,3 °C e si spegne sopra i 37,7 °C; nella zona intermedia mantiene lo stato precedente. In una scatola ben isolata significa circa 20–30 commutazioni all'ora, cioè 10.000–15.000 in un'incubazione di 21 giorni: un relè regge tranquillamente diverse cove. Trovi una spiegazione dettagliata dell'isteresi nell'articolo Costruire un termostato con Arduino.

Un riscaldatore resta caldo per un po' anche dopo lo spegnimento, quindi la temperatura può salire un poco sopra 37,7. La ventola distribuisce in fretta quel calore. Se la temperatura oscilla comunque di più di ±0,5 °C, usa un riscaldatore più piccolo oppure comanda un riscaldatore a 12 V con MOSFET e PWM tramite un controllo PID; così la temperatura resta ferma al decimo di grado.

Codice Arduino dell'incubatrice

Installa dal Gestore librerie DHT sensor library (Adafruit) e LiquidCrystal I2C; le librerie Servo ed EEPROM sono già incluse nell'Arduino IDE. Scegli la specie con il valore SPECIES all'inizio del codice (0 gallina, 1 quaglia, 2 anatra). Per iniziare una nuova cova accendi la scheda tenendo premuto il pulsante su D3: il contatore riparte da zero. Se la accendi senza premere, la scheda riprende dal giorno in cui era.

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}

Come funziona il codice?

  • Profili per specie: per ogni specie un array contiene i giorni totali, il giorno della fase di schiusa, la temperatura obiettivo e l'umidità delle due fasi. Per aggiungere una specie basta scrivere una riga in più.
  • Contatore dei minuti: con millis() si aggiunge un minuto ogni 60 secondi; il giorno si ottiene dividendo i minuti trascorsi per 1440.
  • Controllo di temperatura e umidità: la temperatura è regolata con un'isteresi di ±0,2 °C, l'umidità con ±3 %. Arrivati alla fase di schiusa, l'umidità obiettivo sale da sola.
  • Sicurezza: se il DHT22 non risponde, riscaldatore e umidificatore si spengono, il buzzer suona e il display mostra "SENSOR HATASI" (errore sensore). L'allarme scatta anche se la temperatura supera i 38,5 °C o, dopo la prima ora, scende sotto i 36 °C.
  • Rivoltamento delle uova: ogni due ore il servo inclina il vassoio tra 45 e 135 gradi, piano, un grado alla volta. Dalla fase di schiusa il vassoio resta in piano a 90 gradi.
  • Logica del relè: la costante RELAY_ACTIVE_LOW sceglie il livello giusto per i moduli che scattano con LOW. Poiché i relè vengono messi a riposo prima che i pin diventino uscite, il riscaldatore non si accende nemmeno per un istante all'avvio.

Salvataggio in EEPROM contro i blackout

Quando la corrente salta e poi torna, Arduino riparte da capo e millis() si azzera; senza un salvataggio, una cova al giorno 15 crederebbe di essere al giorno 1 e salterebbe la fase di schiusa. Per questo il codice scrive nella EEPROM i minuti trascorsi, la specie e l'angolo del vassoio ogni 10 minuti e a ogni rivoltamento. Ogni cella della EEPROM regge circa 100.000 scritture; dato che questo codice ne fa circa 3.300 in 21 giorni, la memoria dura decine di cove. Ci sono due limiti da conoscere: la durata del blackout non viene contata e il risonatore ceramico di Arduino Uno può sgarrare di qualche ora in 21 giorni. Se vuoi tenere il giorno preciso al minuto, aggiungi un modulo RTC con batteria e salva la data di inizio. Contro un eventuale blocco del codice puoi usare anche il watchdog.

Girare le uova: servo o motore?

Fino alla fase di schiusa le uova vanno girate almeno 3–5 volte al giorno, meglio ogni 1–2 ore. Nelle incubatrici fai da te la soluzione più pratica è un vassoio con le uova coricate, montato su un perno centrale che un servo inclina di circa 45 gradi per lato. Una dozzina di uova di gallina con il vassoio pesa qualche centinaio di grammi; scegli un servo con ingranaggi in metallo come l'MG996R e bilancia bene il vassoio sul perno. Alimenta il servo con un alimentatore da 5 V separato e non dal pin 5V di Arduino, altrimenti Arduino può riavviarsi a ogni movimento del servo. Per le basi leggi Cos'è un servomotore?. Nelle incubatrici grandi si usa anche un motoriduttore da 5 giri al minuto, ma il servo si monta più facilmente e conosce sempre il suo angolo esatto.

Controllare l'incubatrice dal telefono con un ESP32

Spesso l'incubatrice sta in cantina, nel pollaio o in garage, e controllare il display ogni ora per 21 giorni è scomodo. L'ESP32 fa girare lo stesso termostato e, con una piccola pagina web, porta sul telefono temperatura, umidità, giorno e stato del riscaldatore. Il codice qui sotto contiene una scelta di progetto importante: prova a connettersi al Wi-Fi per al massimo 10 secondi e, se non ci riesce, continua a scaldare; la funzione vitale della macchina non deve mai dipendere dalla rete. Il contatore dei giorni viene salvato nella flash dell'ESP32 con Preferences. Scegli un modulo relè che si possa comandare a 3,3 V; in alcuni moduli a 5 V attivi a LOW, il livello HIGH a 3,3 V dell'ESP32 non riesce a rilasciare del tutto il relè. Se vuoi ricevere un avviso quando la temperatura esce dai limiti, unisci questo codice al metodo dell'articolo Bot 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 in MicroPython con il Raspberry Pi Pico

La versione MicroPython del Raspberry Pi Pico include già il driver del DHT22, quindi non devi copiare file aggiuntivi. Il codice qui sotto comanda il relè su GP16 con la stessa logica di isteresi e spegne il riscaldatore quando il sensore non risponde. Partendo da qui puoi aggiungere un servo, un LCD e un contatore dei giorni permanente e portare tutta la versione Arduino sul Pico; se è il tuo primo Pico, comincia da Cos'è il 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 di incubazione: cosa fare nei 21 giorni?

  1. 1–2 giorni prima di iniziare: fai funzionare l'incubatrice vuota e verifica che temperatura e umidità restino sull'obiettivo per almeno 24 ore. Confronta il sensore con un termometro di cui ti fidi.
  2. Prepara le uova: scegli uova pulite, senza crepe e con al massimo 7–10 giorni. Lasciale 8–12 ore a temperatura ambiente perché non si coprano di condensa entrando nell'incubatrice; non lavarle.
  3. Giorno 1: sistema le uova coricate nel vassoio e accendi la scheda tenendo premuto il pulsante; il contatore parte da zero.
  4. Giorni 7 e 14: in una stanza buia fai la speratura delle uova con una torcia potente. Togli quelle senza una rete di vasi sanguigni visibile: non sono fecondate e possono marcire rovinando le altre.
  5. Giorno 18: inizia la fase di schiusa: il codice smette di girare le uova, mette il vassoio in piano e alza l'umidità obiettivo. Da qui in poi non aprire il coperchio.
  6. Giorni 19–21: i pulcini rompono prima la membrana interna e poi il guscio; può richiedere 12–24 ore. Non cercare di aiutarli rompendo il guscio.
  7. Dopo la schiusa: lascia i pulcini nell'incubatrice per 12–24 ore finché il piumino è asciutto, poi spostali in una pulcinaia riscaldata.

Errori comuni e soluzioni

  • La temperatura è giusta ma non nasce niente: il sensore può essere lontano dalle uova, per esempio sotto il coperchio. Mettilo all'altezza delle uova e verificalo con un termometro di riferimento.
  • La temperatura schizza a 39 °C: il riscaldatore è troppo potente per la scatola. Usane uno più piccolo, metti la ventola davanti al riscaldatore o passa al controllo PID.
  • L'umidità non sale: la superficie della vaschetta è troppo piccola. Usane una più larga o una con una spugna dentro e, se serve, restringi un po' i fori di aerazione.
  • Dopo il blackout il giorno è tornato a zero: forse il pulsante era premuto all'accensione. Ricorda anche che la durata del blackout non viene contata; per blackout lunghi aggiungi un RTC.
  • Il servo trema o Arduino si riavvia: il servo è alimentato dal pin 5V di Arduino. Usa un alimentatore da 5 V separato e collega insieme le masse (GND).
  • Il DHT22 ogni tanto restituisce NaN: il cavo è troppo lungo o manca la resistenza di pull-up. Aggiungi 10 kΩ sul sensore nudo e tieni il cavo entro 1–2 metri; nel frattempo il codice spegne il riscaldatore per sicurezza.

L'incubatrice riunisce in un solo progetto lettura dei sensori, controllo con isteresi, comando dei motori, memoria permanente e attenzione alla sicurezza, e alla fine dà un risultato davvero vivo. Prova prima la macchina vuota per qualche giorno e, quando i valori sono stabili, metti le tue prime uova. Nell'app BlueGrays trovi con schema e codice passo passo i progetti di temperatura e umidità con DHT11, DHT22 con LCD su ESP32, misura della temperatura con NTC, LCD I2C, lampada a 230 V comandata da relè e servomotore, così puoi provare una per una tutte le parti di questa macchina.

Domande frequenti

A che temperatura deve stare un'incubatrice?

In un'incubatrice ad aria forzata l'obiettivo è 37,5 °C per uova di gallina, quaglia, anatra e tacchino; per l'oca bastano 37,2–37,5 °C. Nelle incubatrici ad aria statica il calore sale, quindi si mantengono 38,3–38,9 °C all'altezza della parte superiore delle uova. Misura sempre all'altezza delle uova.

Che umidità deve avere l'incubatrice?

Per le uova di gallina si consiglia il 50–55 % nei primi 18 giorni e il 65–75 % negli ultimi tre. Le uova di anatra e di tacchino vogliono un po' di più nella prima fase, intorno al 55–60 %. L'umidità dipende dalla superficie della vaschetta d'acqua, non dalla quantità d'acqua.

Si può usare un DHT11 in un'incubatrice?

Meglio di no. Il DHT11 ha un errore di ±2 °C e nell'incubazione anche 1 °C di scostamento abbassa la percentuale di schiusa. Un DHT22 (±0,5 °C), un SHT31 o, per la temperatura, un DS18B20 danno risultati molto più affidabili.

Cosa succede se manca la corrente durante l'incubazione?

Con blackout di poche ore le uova si raffreddano lentamente e di solito gli embrioni sopravvivono; tieni chiuso il coperchio e copri la scatola con una coperta. Quando Arduino si riaccende, il codice di questo articolo riprende dal giorno giusto grazie alla EEPROM. Per blackout lunghi valuta un gruppo di continuità e un modulo RTC.

Quante volte al giorno vanno girate le uova?

Fino alla fase di schiusa almeno 3–5 volte al giorno; le incubatrici automatiche di solito le girano ogni 1–2 ore. Se lo fai a mano, girale un numero dispari di volte, così non passano tutte le notti sullo stesso lato. Tre giorni prima della schiusa smetti del tutto di girarle.

Che riscaldatore usare per un'incubatrice fai da te?

Le scelte più comuni sono la lampadina a incandescenza, l'emettitore in ceramica e il riscaldatore PTC a 12 V. Nei progetti scolastici e per principianti i riscaldatori a 12 V sono più sicuri perché non si lavora con la tensione di rete. Qualunque cosa scegli, aggiungi un termostato di sicurezza che funzioni indipendentemente dal software.

Vedi tutti i progetti
Temperatura e umidità con DHT11
AR-55Intermedio

Temperatura e umidità con DHT11

Quanti gradi ci sono nella tua stanza, e l'aria è umida o secca? Il sensore DHT11 misura temperatura e umidità, e l'Arduino scrive i valori su uno schermo LCD a due righe, aggiornandoli ogni paio di…

4.7(47)
83
ESP32 DHT22 Temperatura e umidità (con display LCD)
ES-15Intermedio

ESP32 DHT22 Temperatura e umidità (con display LCD)

Si tratta di un progetto che misura la temperatura e l'umidità dell'ambiente tramite il sensore DHT22 e le visualizza in tempo reale su un display LCD I2C 16x2. I dati vengono letti dal sensore utilizzando il protocollo one-wire tramite la libreria Adafruit DHT. Questo progetto costituisce la base per stazioni meteorologiche IoT, sistemi di automazione domestica intelligente o sistemi di monitoraggio ambientale nelle serre. La comunicazione con il DHT22 avviene tramite il pin GPIO 4 dell'ESP32.

4.8(38)
57
Misura di temperatura con NTC e display Lcd 2x16
AR-44Principiante
Premium

Misura di temperatura con NTC e display Lcd 2x16

Misura la temperatura dell'ambiente con un sensore che sembra una piccola perlina.

4.5(33)
44
Utilizzo dello schermo LCD con I2C
AR-32Principiante
Premium

Utilizzo dello schermo LCD con I2C

Regala al tuo Arduino uno schermo tutto suo e fagli scrivere il primo messaggio.

4.8(53)
70
Lampadina 220V con pulsante (Push)
AR-19Avanzato
Premium

Lampadina 220V con pulsante (Push)

Finché tieni premuto il pulsante, una vera lampadina da 220 volt resta accesa, e si spegne appena lo lasci.

4.4(30)
38
Utilizzo del servomotore
AR-35Principiante
Premium

Utilizzo del servomotore

Il braccio di un piccolo servomotore ruota a turno in tre posizioni: tutto all'inizio, esattamente a metà e tutto alla fine, aspettando due secondi a ogni fermata.

4.7(48)
67
Data Logger di Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Avanzato
Premium

Data Logger di Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)

Costruisci con l'ESP32 un registratore di temperatura e umidità con orario! Un sensore DHT22 legge temperatura e umidità una volta al minuto e ogni lettura viene salvata su una scheda microSD in formato CSV con l'ora reale del modulo RTC DS1307. Il display OLED mostra in tempo reale, a caratteri grandi, l'ultima temperatura, l'umidità, l'orario e il numero totale di registrazioni.

4.7(7)
12
Server web asincrono ESP32 (con indicazione dell'IP sul display LCD)
ES-27Avanzato

Server web asincrono ESP32 (con indicazione dell'IP sul display LCD)

In questo progetto trasformiamo l'ESP32 in un server web asincrono che potrete controllare dal vostro telefono o computer collegato alla stessa rete Wi-Fi. Grazie alla libreria ESPAsyncWebServer, il server è in grado di elaborare più richieste contemporaneamente (a differenza del classico WebServer.h, che si blocca su una singola richiesta).

4.8(16)
26