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.

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èce | Durée d'incubation | Température (air pulsé) | Humidité : incubation | Humidité : éclosion | Arrêt du retournement |
|---|---|---|---|---|---|
| Poule | 21 jours | 37,5 °C | 50–55 % | 65–75 % | Jour 18 |
| Caille japonaise | 17–18 jours | 37,5 °C | 45–55 % | 65–75 % | Jour 14 |
| Cane (canard de Pékin) | 28 jours | 37,5 °C | 55–60 % | 65–75 % | Jour 25 |
| Dinde | 28 jours | 37,5 °C | 55–60 % | 65–75 % | Jour 25 |
| Oie | 28–32 jours (selon la race) | 37,2–37,5 °C | 55–60 % | 70–80 % | 3 jours avant l'éclosion |
| Canard de Barbarie | 35 jours | 37,5 °C | 55–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
| Composant | Rôle | Remarque |
|---|---|---|
| Arduino Uno | Carte de commande | Un 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 humidificateur | Contacts 10 A ; avec un chauffage 12 V, un MOSFET convient aussi |
| Chauffage | Source de chaleur | Options dans le tableau ci-dessous |
| Servo MG996R | Incliner le plateau à œufs | Un SG90 suffit pour quelques œufs de caille |
| Ventilateur 12 V (80 mm) | Brasser l'air | Un ventilateur de boîtier PC est idéal ; il tourne en permanence |
| Écran LCD I2C 16x2 | Affichage de la température, de l'humidité et du jour | Adresse généralement 0x27 |
| Buzzer et bouton | Alarme et lancement d'une nouvelle couvée | Le bouton se branche entre D3 et GND |
| Boîte en polystyrène ou vieux réfrigérateur | Caisson isolé | Une bonne isolation donne une température plus stable et consomme moins |
| Bac à eau large | Source d'humidité | L'humidité dépend de la surface de l'eau, pas de sa quantité |
| Blocs d'alimentation 12 V et 5 V | Alimentation | Prévois un bloc 5 V 2 A séparé pour le servo |
Choisir le chauffage et brancher le relais

| Chauffage | Tension et puissance | Commande | Avantages et inconvénients |
|---|---|---|---|
| Ampoule à incandescence | 230 V, 25–60 W | Module relais | Bon marché et facile à trouver ; tension secteur, éclaire, durée de vie courte |
| Émetteur céramique (type terrarium) | 230 V, 25–100 W | Relais ou SSR | N'éclaire pas, longue durée de vie ; reste en tension secteur |
| Chauffage PTC (avec ventilateur) | 12 V, 50–100 W | Relais ou MOSFET | Basse tension, limite sa propre température |
| Résistance chauffante ou tapis chauffant | 12 V, 20–60 W | MOSFET | Silencieux, 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.
Schéma de câblage (Arduino Uno)
| Composant | Broche du composant | Arduino Uno | Remarque |
|---|---|---|---|
| DHT22 | VCC / DATA / GND | 5V / D2 / GND | Sur un capteur nu, 10 kΩ entre DATA et VCC |
| Relais du chauffage | IN | D7 | VCC du relais sur 5V, GND commune |
| Relais de l'humidificateur | IN | D8 | Optionnel (brumisateur à ultrasons) |
| Servo (MG996R) | Signal (orange) | D9 | Rouge sur un 5 V externe, marron sur GND |
| Buzzer | + | D6 | L'autre patte sur GND |
| Bouton | Une patte | D3 | L'autre patte sur GND (pull-up interne) |
| Écran LCD I2C 16x2 | SDA / SCL | A4 / A5 | VCC sur 5V, GND |
| Ventilateur 12 V | + / - | Bloc 12 V | Non 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.
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.
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.
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 ?.
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 à 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
Projets à réaliser après cet article
Voir tous les projets
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…

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.

Mesure de la température avec NTC et écran LCD 2x16
Mesure la température ambiante avec un capteur qui ressemble à une petite perle.

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…

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.

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.

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.

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).
Autres articles
Application BlueGrays
Réalise ce montage pas à pas sur ton téléphone
Schéma, code et liste des composants sur un seul écran. Plus de 500 projets Arduino, ESP32 et Pico à réaliser.
Scanne avec ton téléphone
Pointe l’appareil photo vers le code : la boutique d’applications de ton téléphone s’ouvre.
ou ouvre la boutique

