Guides · 12 min de lecture

Couveuse Arduino fait maison : DHT22, relais, servo et code

Couveuse Arduino fait maison : DHT22 pour température et humidité, chauffage par relais, retournement par servo, compteur de jours en EEPROM et suivi par ESP32.

Fabriquer une couveuse Arduino est l'un des projets les plus passionnants qui soient, car il transforme des mesures de température et d'humidité en un résultat bien vivant : maintiens 37,5 °C au dixième de degré près pendant 21 jours et un poussin sort de l'œuf. Les couveuses du commerce peuvent coûter cher ou ne pas proposer les réglages de l'espèce qui t'intéresse. Avec un Arduino Uno, un capteur DHT22, un relais, un chauffage et un servo, tu peux construire toi-même une couveuse réglable pour les œufs de poule, de caille et de cane, qui retourne les œufs toute seule et compte les jours.

Dans ce guide, nous voyons pas à pas le tableau de température, d'humidité et de durée par espèce, la liste du matériel, le choix du chauffage, le schéma de câblage, l'hystérésis qui empêche le chauffage de s'allumer et de s'éteindre sans arrêt, et un programme Arduino complet. Le code retrouve en EEPROM le jour où il en était après une coupure de courant, coupe le chauffage et déclenche une alarme si le capteur tombe en panne. Dans les dernières parties, tu trouveras le suivi à distance avec un ESP32, un thermostat MicroPython pour le Raspberry Pi Pico et le calendrier des 21 jours d'incubation.

Capteur de température et d'humidité DHT22
Capteur de température et d'humidité DHT22 (AM2302) : avec ±0,5 °C de précision et une plage d'humidité de 0 à 100 %, il convient bien mieux qu'un DHT11 à une couveuse.

Comment fonctionne une couveuse ?

Quand une poule couve ses œufs, elle leur apporte quatre choses à la fois, et la couveuse imite les quatre. La plupart des couveuses faites maison sont à "air pulsé" : un petit ventilateur brasse l'air en permanence, si bien que la température est la même partout dans la boîte. Dans les couveuses à air statique (sans ventilateur), l'air chaud monte : on mesure alors au niveau du haut des œufs et on vise environ 1 °C de plus.

  • Température : l'embryon a besoin d'une température stable d'environ 37,5 °C pour se développer. Même un écart de 1 °C fait baisser le taux d'éclosion, et au-delà de 39,5 °C l'embryon peut mourir rapidement.
  • Humidité : l'eau s'évapore par les pores de la coquille. Si l'humidité est trop basse, l'œuf perd trop d'eau ; si elle est trop haute, le poussin a du mal à percer sa coquille.
  • Retournement : retourner l'œuf plusieurs fois par jour empêche l'embryon de coller à la membrane de la coquille.
  • Aération : l'embryon consomme de l'oxygène et produit du dioxyde de carbone ; la boîte a besoin de quelques petits trous d'aération.

Température, humidité et durée d'incubation par espèce

EspèceDurée d'incubationTempérature (air pulsé)Humidité : incubationHumidité : éclosionArrêt du retournement
Poule21 jours37,5 °C50–55 %65–75 %Jour 18
Caille japonaise17–18 jours37,5 °C45–55 %65–75 %Jour 14
Cane (canard de Pékin)28 jours37,5 °C55–60 %65–75 %Jour 25
Dinde28 jours37,5 °C55–60 %65–75 %Jour 25
Oie28–32 jours (selon la race)37,2–37,5 °C55–60 %70–80 %3 jours avant l'éclosion
Canard de Barbarie35 jours37,5 °C55–60 %65–75 %Jour 32

Ce sont les plages les plus souvent recommandées dans les guides d'incubation ; la race, l'âge des œufs et l'altitude peuvent demander de petits ajustements. La "phase d'éclosion" est la dernière étape, environ trois jours avant la naissance : on ne retourne plus les œufs, on augmente l'humidité et on n'ouvre plus le couvercle. Si tu utilises une couveuse à air statique, maintiens 38,3 à 38,9 °C au niveau du haut des œufs. Mesure toujours la température à hauteur des œufs ; il peut y avoir 1 à 2 °C d'écart entre le haut et le bas de la boîte.

Liste du matériel

ComposantRôleRemarque
Arduino UnoCarte de commandeUn Nano convient aussi ; les broches sont les mêmes
DHT22 (AM2302)Mesure de la température et de l'humiditéL'erreur de ±2 °C du DHT11 est trop grande pour l'incubation
Module relais (2 canaux)Chauffage et humidificateurContacts 10 A ; avec un chauffage 12 V, un MOSFET convient aussi
ChauffageSource de chaleurOptions dans le tableau ci-dessous
Servo MG996RIncliner le plateau à œufsUn SG90 suffit pour quelques œufs de caille
Ventilateur 12 V (80 mm)Brasser l'airUn ventilateur de boîtier PC est idéal ; il tourne en permanence
Écran LCD I2C 16x2Affichage de la température, de l'humidité et du jourAdresse généralement 0x27
Buzzer et boutonAlarme et lancement d'une nouvelle couvéeLe bouton se branche entre D3 et GND
Boîte en polystyrène ou vieux réfrigérateurCaisson isoléUne bonne isolation donne une température plus stable et consomme moins
Bac à eau largeSource d'humiditéL'humidité dépend de la surface de l'eau, pas de sa quantité
Blocs d'alimentation 12 V et 5 VAlimentationPrévois un bloc 5 V 2 A séparé pour le servo

Choisir le chauffage et brancher le relais

Module relais pour Arduino
Module relais : il permet au petit signal 5 V de l'Arduino d'allumer et d'éteindre des charges à fort courant comme un chauffage ; sur la plupart des modules, le relais colle quand la broche IN passe à LOW.
ChauffageTension et puissanceCommandeAvantages et inconvénients
Ampoule à incandescence230 V, 25–60 WModule relaisBon marché et facile à trouver ; tension secteur, éclaire, durée de vie courte
Émetteur céramique (type terrarium)230 V, 25–100 WRelais ou SSRN'éclaire pas, longue durée de vie ; reste en tension secteur
Chauffage PTC (avec ventilateur)12 V, 50–100 WRelais ou MOSFETBasse tension, limite sa propre température
Résistance chauffante ou tapis chauffant12 V, 20–60 WMOSFETSilencieux, réglage proportionnel possible en PWM

Pour une boîte en polystyrène d'environ 40 litres, un chauffage de 20 à 40 W suffit en général ; un chauffage trop puissant dépasse la consigne et fait osciller la température. Calcule le courant d'un chauffage 12 V avec I = P / U : un PTC de 50 W consomme environ 4,2 A sous 12 V, il te faut donc du câble épais et un relais adapté à ce courant, ou un MOSFET à niveau logique. Pour le calcul, utilise l'outil Loi d'Ohm ; pour le câblage du MOSFET, lis Utiliser un MOSFET avec Arduino, et pour les détails du relais, Qu'est-ce qu'un module relais ?. Si tu veux commuter le chauffage très souvent, un relais statique (SSR), silencieux et sans usure, est un excellent choix.

Si tu utilises une ampoule ou un émetteur céramique sur le secteur 230 V, fais toutes les connexions secteur dans un boîtier fermé, avec des borniers isolés et un fusible ; pour les projets d'élèves, préfère les chauffages 12 V. Ajoute aussi une sécurité indépendante du logiciel : un thermostat bilame (type KSD301) en série avec le chauffage, qui ouvre le circuit à 40–45 °C, protège les œufs et la boîte même si le code ou le relais reste bloqué.

Schéma de câblage (Arduino Uno)

ComposantBroche du composantArduino UnoRemarque
DHT22VCC / DATA / GND5V / D2 / GNDSur un capteur nu, 10 kΩ entre DATA et VCC
Relais du chauffageIND7VCC du relais sur 5V, GND commune
Relais de l'humidificateurIND8Optionnel (brumisateur à ultrasons)
Servo (MG996R)Signal (orange)D9Rouge sur un 5 V externe, marron sur GND
Buzzer+D6L'autre patte sur GND
BoutonUne patteD3L'autre patte sur GND (pull-up interne)
Écran LCD I2C 16x2SDA / SCLA4 / A5VCC sur 5V, GND
Ventilateur 12 V+ / -Bloc 12 VNon relié à l'Arduino ; tourne en permanence

Hystérésis : pourquoi le chauffage ne doit pas cliqueter sans arrêt

Si le code disait seulement "en dessous de 37,5, chauffage allumé ; au-dessus, éteint", le relais claquerait toutes les deux secondes pendant que la mesure oscille entre 37,4 et 37,6. Les contacts d'un relais mécanique supportent environ 100 000 commutations, et une telle régulation épuiserait cette durée de vie en quelques jours. Avec une hystérésis, le chauffage s'allume sous 37,3 °C et s'éteint au-dessus de 37,7 °C ; entre les deux, il garde son état précédent. Dans une boîte bien isolée, cela représente environ 20 à 30 commutations par heure, soit 10 000 à 15 000 sur une incubation de 21 jours ; un relais tient donc largement plusieurs couvées. Tu trouveras une explication détaillée de l'hystérésis dans Fabriquer un thermostat Arduino.

Un chauffage reste chaud un moment après s'être éteint, la température peut donc dépasser un peu 37,7. Le ventilateur répartit vite cette chaleur. Si la température oscille encore de plus de ±0,5 °C, prends un chauffage plus petit ou pilote un chauffage 12 V par MOSFET et PWM avec une régulation PID ; la température se stabilise alors au dixième de degré.

Code Arduino de la couveuse

Installe depuis le gestionnaire de bibliothèques DHT sensor library (Adafruit) et LiquidCrystal I2C ; les bibliothèques Servo et EEPROM sont fournies avec l'Arduino IDE. Choisis l'espèce avec la valeur SPECIES en haut du code (0 poule, 1 caille, 2 cane). Pour commencer une nouvelle couvée, mets la carte sous tension en maintenant le bouton de D3 enfoncé : le compteur repart de zéro. Si tu l'allumes sans appuyer, la carte reprend au jour où elle en était.

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}

Comment fonctionne le code ?

  • Profils par espèce : pour chaque espèce, un tableau stocke le nombre total de jours, le jour de la phase d'éclosion, la température de consigne et l'humidité des deux phases. Pour ajouter une espèce, il suffit d'écrire une ligne de plus.
  • Compteur de minutes : millis() ajoute une minute toutes les 60 secondes ; le jour se calcule en divisant les minutes écoulées par 1440.
  • Régulation de la température et de l'humidité : la température est régulée avec une hystérésis de ±0,2 °C, l'humidité avec ±3 %. Le jour de la phase d'éclosion, l'humidité de consigne augmente d'elle-même.
  • Sécurité : si le DHT22 ne répond pas, le chauffage et l'humidificateur s'éteignent, le buzzer sonne et l'écran affiche "SENSOR HATASI" (erreur capteur). L'alarme sonne aussi si la température dépasse 38,5 °C ou, après la première heure, descend sous 36 °C.
  • Retournement des œufs : toutes les deux heures, le servo incline le plateau entre 45 et 135 degrés, lentement, degré par degré. À partir de la phase d'éclosion, le plateau reste à plat à 90 degrés.
  • Logique du relais : la constante RELAY_ACTIVE_LOW choisit le bon niveau pour les modules qui collent à LOW. Comme les relais sont mis à l'arrêt avant que les broches passent en sortie, le chauffage ne s'allume pas, même un instant, au démarrage.

Sauvegarde en EEPROM contre les coupures de courant

Quand le courant est coupé puis revient, l'Arduino redémarre de zéro et millis() repart à zéro ; sans sauvegarde, une couvée au jour 15 se croirait au jour 1 et raterait la phase d'éclosion. Le code écrit donc dans l'EEPROM les minutes écoulées, l'espèce et l'angle du plateau toutes les 10 minutes et à chaque retournement. Chaque cellule de l'EEPROM supporte environ 100 000 écritures ; comme ce code en fait environ 3 300 en 21 jours, la mémoire tiendra des dizaines de couvées. Deux limites sont à connaître : la durée de la coupure n'est pas comptée, et le résonateur céramique de l'Arduino Uno peut dériver de quelques heures sur 21 jours. Pour suivre le jour à la minute près, ajoute un module RTC sur pile et enregistre la date de départ. Pour éviter que le code reste bloqué, tu peux aussi utiliser le watchdog.

Retournement des œufs : servo ou moteur ?

Jusqu'à la phase d'éclosion, les œufs doivent être retournés au moins 3 à 5 fois par jour, idéalement toutes les 1 à 2 heures. Dans une couveuse faite maison, le plus pratique est un plateau où les œufs sont couchés, monté sur un axe central qu'un servo incline d'environ 45 degrés de chaque côté. Une douzaine d'œufs de poule avec le plateau pèse quelques centaines de grammes ; choisis un servo à engrenages métalliques comme le MG996R et équilibre le plateau sur son axe. Alimente le servo avec un bloc 5 V séparé et non par la broche 5V de l'Arduino ; sinon l'Arduino peut redémarrer à chaque mouvement du servo. Pour les bases, lis Qu'est-ce qu'un servomoteur ?. Les grandes couveuses utilisent parfois un motoréducteur à 5 tours par minute, mais un servo est plus simple à installer et connaît toujours son angle exact.

Surveiller la couveuse depuis ton téléphone avec un ESP32

Une couveuse se trouve souvent à la cave, au poulailler ou au garage, et aller regarder l'écran toutes les heures pendant 21 jours n'est pas simple. L'ESP32 fait tourner le même thermostat et, grâce à une petite page web, affiche sur ton téléphone la température, l'humidité, le jour et l'état du chauffage. Le code ci-dessous contient un choix de conception important : il tente de se connecter au Wi-Fi pendant 10 secondes au maximum et continue de chauffer s'il n'y arrive pas ; la fonction vitale de la machine ne doit jamais dépendre du réseau. Le compteur de jours est enregistré dans la flash de l'ESP32 avec Preferences. Choisis un module relais commandable en 3,3 V ; sur certains modules 5 V actifs à LOW, le niveau HIGH de 3,3 V de l'ESP32 ne suffit pas à relâcher complètement le relais. Si tu veux recevoir une alerte quand la température sort de la plage, combine ce code avec la méthode de Bot Telegram avec 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}

Thermostat MicroPython avec le Raspberry Pi Pico

La version MicroPython du Raspberry Pi Pico intègre déjà le pilote du DHT22 : aucun fichier supplémentaire à copier. Le code ci-dessous commande le relais sur GP16 avec la même logique d'hystérésis et coupe le chauffage dès que le capteur ne répond plus. Sur cette base, tu peux ajouter un servo, un écran LCD et un compteur de jours permanent pour porter toute la version Arduino sur le Pico ; si c'est ton premier Pico, commence par Qu'est-ce que le 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)

Calendrier d'incubation : que faire pendant les 21 jours ?

  1. 1 à 2 jours avant : fais tourner la couveuse à vide et vérifie que la température et l'humidité restent sur la consigne pendant au moins 24 heures. Compare le capteur avec un thermomètre fiable.
  2. Prépare les œufs : choisis des œufs propres, sans fêlure, de 7 à 10 jours maximum. Laisse-les 8 à 12 heures à température ambiante pour qu'ils ne se couvrent pas de condensation en entrant dans la couveuse ; ne les lave pas.
  3. Jour 1 : couche les œufs sur le plateau et mets la carte sous tension en maintenant le bouton enfoncé ; le compteur démarre à zéro.
  4. Jours 7 et 14 : dans une pièce sombre, mire les œufs avec une lampe puissante. Retire ceux où l'on ne voit pas de réseau de vaisseaux : ils ne sont pas fécondés et peuvent pourrir et contaminer les autres.
  5. Jour 18 : la phase d'éclosion commence : le code arrête le retournement, remet le plateau à plat et augmente l'humidité de consigne. À partir de maintenant, n'ouvre plus le couvercle.
  6. Jours 19 à 21 : les poussins percent d'abord la membrane interne puis la coquille ; cela peut prendre 12 à 24 heures. N'essaie pas de les aider en cassant la coquille.
  7. Après l'éclosion : laisse les poussins 12 à 24 heures dans la couveuse jusqu'à ce que leur duvet soit sec, puis place-les dans une poussinière chauffée.

Erreurs fréquentes et solutions

  • La température est bonne mais rien n'éclot : le capteur est peut-être loin des œufs, par exemple sous le couvercle. Place-le à hauteur des œufs et vérifie-le avec un thermomètre de référence.
  • La température grimpe à 39 °C : le chauffage est trop puissant pour la boîte. Prends-en un plus petit, place le ventilateur devant le chauffage ou passe à une régulation PID.
  • L'humidité ne monte pas : la surface du bac à eau est trop petite. Prends un bac plus large ou mets-y une éponge et, si besoin, réduis un peu les trous d'aération.
  • Après une coupure, le jour est revenu à zéro : le bouton est peut-être resté enfoncé au démarrage. N'oublie pas non plus que la durée de la coupure n'est pas comptée ; pour les longues coupures, ajoute un RTC.
  • Le servo tremble ou l'Arduino redémarre : le servo est alimenté par la broche 5V de l'Arduino. Utilise un bloc 5 V séparé et relie les masses (GND).
  • Le DHT22 renvoie parfois NaN : le câble est trop long ou la résistance de pull-up manque. Ajoute 10 kΩ sur un capteur nu et limite le câble à 1 ou 2 mètres ; en attendant, le code coupe le chauffage par sécurité.

Une couveuse réunit dans un seul projet la lecture de capteurs, la régulation avec hystérésis, la commande de moteurs, la mémoire permanente et le souci de la sécurité, et elle donne au bout du compte un résultat vraiment vivant. Teste d'abord la machine à vide pendant quelques jours, puis mets tes premiers œufs une fois les valeurs stables. Dans l'application BlueGrays, tu trouveras avec schéma et code pas à pas les projets température et humidité avec DHT11, DHT22 avec écran LCD sur ESP32, mesure de température avec NTC, écran LCD I2C, lampe 230 V commandée par relais et servomoteur, pour tester séparément chaque partie de cette couveuse.

Questions fréquentes

Quelle température pour une couveuse ?

Dans une couveuse à air pulsé, la consigne est de 37,5 °C pour les œufs de poule, de caille, de cane et de dinde ; pour l'oie, 37,2 à 37,5 °C suffisent. Dans une couveuse à air statique, la chaleur monte : on maintient alors 38,3 à 38,9 °C au niveau du haut des œufs. Mesure toujours à hauteur des œufs.

Quel taux d'humidité dans une couveuse ?

Pour les œufs de poule, on recommande 50 à 55 % pendant les 18 premiers jours et 65 à 75 % pendant les trois derniers. Les œufs de cane et de dinde demandent un peu plus pendant l'incubation, autour de 55 à 60 %. L'humidité dépend de la surface du bac à eau, pas de la quantité d'eau.

Peut-on utiliser un DHT11 dans une couveuse ?

C'est déconseillé. Le DHT11 a une erreur de ±2 °C, et en incubation même 1 °C d'écart fait baisser le taux d'éclosion. Un DHT22 (±0,5 °C), un SHT31 ou un DS18B20 pour la température donnent des résultats bien plus fiables.

Que faire en cas de coupure de courant pendant l'incubation ?

Lors de coupures de quelques heures, les œufs refroidissent lentement et les embryons survivent le plus souvent ; garde le couvercle fermé et couvre la boîte d'une couverture. Quand l'Arduino redémarre, le code de cet article reprend au bon jour grâce à l'EEPROM. Pour les longues coupures, pense à un onduleur et à un module RTC.

Combien de fois par jour retourner les œufs ?

Jusqu'à la phase d'éclosion, au moins 3 à 5 fois par jour ; les couveuses automatiques les retournent souvent toutes les 1 à 2 heures. Si tu le fais à la main, retourne-les un nombre impair de fois pour qu'ils ne passent pas toutes les nuits sur le même côté. Arrête complètement le retournement trois jours avant l'éclosion.

Quel chauffage pour une couveuse artisanale ?

Les choix les plus courants sont l'ampoule à incandescence, l'émetteur céramique et le chauffage PTC 12 V. Pour les projets d'élèves et de débutants, les chauffages 12 V sont plus sûrs car on ne travaille pas avec la tension du secteur. Quel que soit ton choix, ajoute un thermostat de sécurité qui fonctionne indépendamment du logiciel.

Voir tous les projets
Température et humidité avec DHT11
AR-55Intermédiaire

Température et humidité avec DHT11

Quelle température fait-il dans ta chambre, et l'air est-il humide ou sec ? Le capteur DHT11 mesure la température et l'humidité, et l'Arduino affiche les valeurs sur un écran LCD à deux lignes…

4.7(47)
83
ESP32 DHT22 Température et humidité (avec écran LCD)
ES-15Intermédiaire

ESP32 DHT22 Température et humidité (avec écran LCD)

Il s'agit d'un projet permettant de mesurer la température ambiante et le taux d'humidité à l'aide d'un capteur DHT22 et d'afficher ces données en temps réel sur un écran LCD I2C 16x2. Les données du capteur sont lues à l'aide du protocole one-wire grâce à la bibliothèque Adafruit DHT. Ce projet constitue la base des stations météo IoT, de la domotique ou des systèmes de surveillance de l'environnement dans les serres.

4.8(38)
57
Mesure de la température avec NTC et écran LCD 2x16
AR-44Débutant
Premium

Mesure de la température avec NTC et écran LCD 2x16

Mesure la température ambiante avec un capteur qui ressemble à une petite perle.

4.5(33)
44
Utilisation de l'écran LCD avec I2C
AR-32Débutant
Premium

Utilisation de l'écran LCD avec I2C

Offre un écran à ton Arduino et fais-lui écrire son premier message. L'écran LCD à deux lignes se branche avec seulement quelques fils ; un bonjour s'affiche sur la ligne du haut, puis un deuxième…

4.8(53)
70
Ampoule 220V avec bouton poussoir (Push)
AR-19Avancé
Premium

Ampoule 220V avec bouton poussoir (Push)

Tant que tu appuies sur le bouton, une vraie ampoule de 220 volts reste allumée, et elle s'éteint dès que tu relâches.

4.4(30)
38
Utilisation du servomoteur
AR-35Débutant
Premium

Utilisation du servomoteur

Le bras d'un petit servomoteur tourne tour à tour vers trois positions : tout au début, pile au milieu et tout au bout, en attendant deux secondes à chaque arrêt.

4.7(48)
67
Enregistreur de Température ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Avancé
Premium

Enregistreur de Température ESP32 (DHT22 + DS1307 RTC + microSD + OLED)

Construis avec l'ESP32 un enregistreur de température et d'humidité horodaté ! Un capteur DHT22 mesure la température et l'humidité une fois par minute, et chaque mesure est enregistrée sur une carte microSD au format CSV avec l'heure réelle du module RTC DS1307. L'écran OLED affiche en direct, en grands caractères, la dernière température, l'humidité, l'horodatage et le nombre d'enregistrements.

4.7(7)
12
Serveur Web asynchrone ESP32 (avec affichage de l'adresse IP sur l'écran LCD)
ES-27Avancé

Serveur Web asynchrone ESP32 (avec affichage de l'adresse IP sur l'écran LCD)

On transforme l'ESP32 en serveur web asynchrone que tu pilotes depuis ton téléphone ou ton ordinateur sur le même réseau Wi-Fi. Grâce à la bibliothèque ESPAsyncWebServer, le serveur traite plusieurs requêtes à la fois (il ne bloque pas sur une seule requête comme le WebServer.h classique). Ouvre l'adresse IP de l'ESP32 dans le navigateur et allume ou éteins la LED sur GPIO 5 avec les boutons ON/OFF (adresses /on et /off).

4.8(16)
26