21 jours à 37,5 °C : c’est ce qu’il faut pour qu’un œuf de poule devienne un poussin. Dans la nature, c’est la poule qui s’en occupe. Mais une poule ne couve qu’une douzaine d’œufs à la fois, et seulement quand elle le décide. C’est pour cela que les éleveurs utilisent des couveuses électriques : des boîtes qui gardent les œufs à la bonne température et à la bonne humidité, jour et nuit. On en trouve dans le commerce. Mais avec un peu de système D, vous pouvez aussi fabriquer la vôtre. C’est le premier projet du Lab Maker : une couveuse de 12 œufs pilotée par un Arduino, une petite carte électronique que l’on programme pour mesurer et commander des choses. Dans cet article, vous trouverez tout : le matériel avec les prix, le câblage, le code complet, la simulation pour tester sans rien acheter, et la construction de la boîte.

1. Le principe : mesurer, décider, agir

Le fonctionnement tient en une phrase : un capteur mesure, l’Arduino décide, les relais obéissent.

  • Le capteur DHT22 mesure la température et l’humidité de l’air dans la boîte.
  • L’Arduino compare ces mesures aux valeurs voulues (on dit « les consignes »). Trop froid ? Il allume le chauffage. Trop sec ? Il lance le brumisateur.
  • Les relais sont des interrupteurs commandés par l’Arduino. Ils allument ou coupent la résistance chauffante et le brumisateur.
  • L’horloge RTC DS3231 compte les jours, même après une coupure de courant.
  • L’écran LCD affiche le jour, la température et l’humidité.

Les consignes changent toutes seules selon le jour :

PériodeTempératureHumidité
Jours 1 à 18 (incubation)37,5 °C45 %
Jours 19 à 21 (éclosion)37,5 °C67,5 %

Pour éviter que le relais claque sans arrêt, le programme utilise une petite marge. Le chauffage s’allume dès que la température passe sous 37,5 °C, et il ne s’éteint qu’au-dessus de 38,0 °C. Même idée pour l’humidité, avec une marge de 2 %.

2. Pourquoi la fabriquer soi-même ?

Soyons honnêtes dès le départ : cette couveuse n’est pas moins chère par œuf qu’une couveuse du commerce. Le 24 octobre 2026, sur glotelho.cm, un modèle de 56 œufs coûtait 95 000 FCFA (environ 1 700 F par œuf) et un modèle automatique de 100 œufs 224 400 FCFA. Notre couveuse revient à environ 40 000 FCFA pour 12 œufs, sans compter la boîte. Son intérêt est ailleurs :

  • Comprendre : vous apprenez à utiliser un capteur, une horloge, des relais et une régulation. C’est une compétence qui resservira pour une serre, un séchoir ou une armoire de fermentation.
  • Réparer vous-même : toutes les pièces sont standard et se trouvent au Cameroun. Si le capteur lâche, vous changez une pièce d’environ 4 500 F, au lieu de chercher une carte électronique introuvable.
  • Adapter : les températures, l’humidité et le nombre de jours se changent dans le code. Vous pouvez l’ajuster pour d’autres oiseaux, après avoir vérifié leurs besoins.
  • Commencer petit : vous testez avec 12 œufs avant d’investir dans une grande couveuse.
  • Ne pas attendre : le jour de nos relevés, les deux modèles du commerce étaient en rupture de stock.
  • Réutiliser : l’Arduino, l’écran et les relais pourront servir dans d’autres projets.

Il y a aussi des limites, et il vaut mieux les connaître :

  • Cette couveuse ne retourne pas les œufs toute seule : c’est à vous de le faire, à la main.
  • Elle n’a pas d’alarme en cas de problème.
  • Le montage demande du temps.
  • Pour produire beaucoup de poussins, une couveuse du commerce reste plus adaptée.

3. Le matériel et le budget

Les prix ci-dessous ont été relevés le 24 octobre 2026, en grande partie sur komtech.app. Ils peuvent changer : vérifiez-les avant d’acheter.

PièceRôlePrix (FCFA)
Arduino Uno R3 (avec câble USB)Le cerveau du système7 000
Capteur DHT22Mesure la température et l’humidité4 500
Module RTC DS3231, avec sa pileCompte les jours, même sans courant2 500
Écran LCD 1602 avec adaptateur I2CAffiche le jour, T et H4 000
Module relais 5 V × 2Allume ou coupe le chauffage et le brumisateur2 000
Bouton poussoirDémarre l’incubation50 à 100
Module brumisateur USB 5 VAjoute de l’humidité3 000
Résistance chauffante PTC 12 V, 30 WChauffe la boîteenviron 2 500
Alimentation 12 V, 4 A ou 5 AAlimente la résistance chauffante13 000 à 15 000
Vieux chargeur de téléphone (USB 5 V)Alimente le brumisateurdéjà à la maison
Fils Dupont (40 brins)Les connexions1 000

Total : environ 39 600 à 41 600 FCFA, sans la boîte.

Amélioration conseillée : un petit ventilateur 12 V de 5 × 5 cm (3 500 FCFA). Il n’est pas dans la vidéo, mais il mélange l’air pour avoir la même température partout dans la boîte. Avec lui, le total passe à environ 43 100 à 45 100 FCFA.

Quelques précisions sur nos choix :

  • Pourquoi une résistance PTC ? Elle limite sa température toute seule (vers 120 °C pour ce modèle). C’est plus sûr dans une boîte fermée. 30 W suffisent pour une petite boîte d’environ 40 × 30 × 30 cm.
  • Pourquoi une alimentation de 4 ou 5 ampères ? La résistance consomme environ 2,5 A, avec un pic au démarrage, plus le ventilateur. Une alimentation 12 V de 2 A est trop juste.
  • Attention aux faux amis : un « chargeur de batterie 12 V » n’est pas une alimentation. Il est fait pour recharger des batteries, pas pour alimenter un montage.
  • La pile du module RTC est importante : c’est elle qui garde l’heure pendant une coupure de courant.

4. Le câblage

ÉlémentBroche de l’Arduino
DHT22 (fil de données)D2
Bouton (l’autre patte va au GND)D3
Relais 1, chauffage (IN)D7
Relais 2, brumisateur (IN)D8
Écran LCD I2C et RTC (SDA)A4
Écran LCD I2C et RTC (SCL)A5
Tous les modules (VCC et GND)5V et GND

L’écran et l’horloge partagent les deux mêmes fils, A4 et A5. Sur l’Arduino Uno, ces deux broches sont fixes pour l’I2C : vous ne pouvez pas les changer. Les autres broches sont libres : ce sont celles de notre exemple, et ce sont celles du code plus bas.

Le côté puissance :

  • Chauffage : le + de l’alimentation 12 V va sur la borne COM du relais 1. La borne NO du relais va sur un fil de la résistance. L’autre fil de la résistance revient au − de l’alimentation. Reliez aussi le − de l’alimentation au GND de l’Arduino (la masse commune).
  • Brumisateur : coupez le fil rouge (le + 5 V) d’une rallonge USB et faites-le passer par les bornes COM et NO du relais 2. Le brumisateur se branche au bout de la rallonge, la rallonge sur le chargeur.
  • Ventilateur (si vous l’ajoutez) : branché directement sur l’alimentation 12 V, il tourne en permanence.

Nos relais s’activent à l’état haut : quand l’Arduino met la broche à HIGH, le relais ferme le circuit et ça chauffe. À LOW, tout s’arrête. Certains modules marchent à l’envers : la solution est expliquée dans la partie dépannage.

Attention : ne branchez jamais la résistance chauffante ou le brumisateur directement sur l’Arduino. Ils passent toujours par un relais, avec leur propre alimentation. Ce projet reste en 12 V et en 5 V : c’est voulu. Si vous voulez utiliser un élément chauffant en 220 V, il faut un boîtier isolé, un fusible et des relais prévus pour ce courant. Si vous n’êtes pas sûr de vous, restez en 12 V.

Simulation Wokwi de l'incubateur Arduino avec ses deux relais

Le montage dans le simulateur Wokwi : l'écran affiche « Poule J1/21 », T:24.0C H:40 %, et les deux relais sont allumés car il fait trop froid et trop sec. © / Kennedyen.net

5. Le code

Avant de téléverser le code, installez ces bibliothèques depuis le gestionnaire de bibliothèques de l’IDE Arduino :

  • RTClib (d’Adafruit), pour l’horloge ;
  • DHT sensor library (d’Adafruit), pour le capteur. L’IDE vous proposera aussi « Adafruit Unified Sensor » : acceptez ;
  • LiquidCrystal I2C, pour l’écran.

Les bibliothèques Wire et EEPROM sont déjà fournies avec l’IDE.

Ce qu’il faut retenir du code :

  • Les consignes sont en haut du programme. Pour les changer, modifiez simplement les chiffres TEMP_INCUB, HUMID_INCUB, TEMP_ECLOS et HUMID_ECLOS.
  • Rien ne chauffe avant le démarrage. Tant que vous n’avez pas appuyé sur le bouton, les relais restent éteints et l’écran affiche « Poule Attente ».
  • La date de départ est gardée en mémoire. Au moment de l’appui, l’Arduino enregistre la date dans sa mémoire permanente (l’EEPROM). Après une coupure, il relit cette date, regarde l’heure sur le RTC et calcule tout seul le jour où il en est.
  • L’heure du RTC se règle une seule fois. Dans le setup(), enlevez les deux barres // devant la ligne rtc.adjust(...), téléversez, puis remettez les // et téléversez à nouveau. Sinon, l’horloge reviendrait à l’heure de compilation à chaque redémarrage.

Voici le code complet. Il a été compilé sans erreur dans l’IDE Arduino.

/*
 * ============================================================
 * INCUBATEUR D'OEUFS DE POULE - Le Lab Maker, Projet 01
 * Kennedyen.net
 * ============================================================
 *
 * Consignes automatiques :
 *   - Jours 1 à 18  : T = 37.5 °C, H = 45 %
 *   - Jours 19 à 21 : T = 37.5 °C, H = 67.5 % (éclosion)
 *
 * Fonctionnement :
 *   1. Au démarrage, rien ne chauffe : les relais restent éteints
 *      tant que l'incubation n'a pas été démarrée ("Poule Attente").
 *   2. Un appui sur le bouton enregistre la date de départ dans
 *      l'EEPROM (mémoire permanente) et met le jour à 1.
 *   3. L'Arduino calcule le jour actuel grâce au RTC DS3231,
 *      qui garde l'heure même sans courant.
 *      Après une coupure, l'incubation reprend toute seule.
 *   4. Il lit la température et l'humidité avec le DHT22.
 *   5. Si T < consigne -> chauffage ON.
 *      Si T > consigne + marge -> chauffage OFF.
 *      (Pareil pour l'humidité avec le brumisateur.)
 *   6. Tout est affiché sur l'écran LCD.
 *
 * Simulation Wokwi : le DS3231 n'existe pas dans le simulateur.
 * Utilisez un DS1307 et remplacez RTC_DS3231 par RTC_DS1307
 * (une seule ligne, dans la partie "Objets").
 * ============================================================
 */

#include <Wire.h>
#include <RTClib.h>
#include <DHT.h>
#include <LiquidCrystal_I2C.h>
#include <EEPROM.h>

// -------- Broches --------
#define PIN_DHT            2      // DHT22 sur D2
#define PIN_RELAIS_CHAUFF  7      // Relais du chauffage
#define PIN_RELAIS_HUMID   8      // Relais du brumisateur
#define PIN_BOUTON         3      // Bouton de démarrage

// -------- Niveau d'activation des relais --------
// Ce montage utilise des relais qui s'activent à l'état haut (HIGH).
// Si vos relais marchent à l'envers (allumés en permanence, ou
// allumés quand ils devraient être éteints), échangez HIGH et LOW :
//   #define RELAIS_ON   LOW
//   #define RELAIS_OFF  HIGH
#define RELAIS_ON   HIGH
#define RELAIS_OFF  LOW

// -------- Type de DHT --------
#define TYPE_DHT DHT22

// -------- Adresse du LCD I2C --------
// Si l'écran reste noir, essayez 0x3F au lieu de 0x27
#define LCD_ADRESSE 0x27

// -------- Consignes (modifiables) --------
const float TEMP_INCUB  = 37.5;   // Température jours 1-18
const float HUMID_INCUB = 45.0;   // Humidité jours 1-18
const float TEMP_ECLOS  = 37.5;   // Température jours 19-21
const float HUMID_ECLOS = 67.5;   // Humidité jours 19-21

// -------- Marges pour éviter les oscillations --------
const float MARGE_TEMP  = 0.5;    // On coupe à 38.0 °C
const float MARGE_HUMID = 2.0;    // On coupe à +2 %

// -------- Adresse EEPROM pour la date de début --------
const int EEPROM_ADR = 0;

// -------- Objets --------
DHT capteur(PIN_DHT, TYPE_DHT);
RTC_DS3231 rtc;                     // Sur Wokwi : RTC_DS1307 rtc;
LiquidCrystal_I2C lcd(LCD_ADRESSE, 16, 2);

// -------- Variables globales --------
unsigned long timestampDebut = 0;   // Date/heure de départ
int jour = 0;                       // 0 = pas encore démarré
float consigneTemp  = TEMP_INCUB;
float consigneHumid = HUMID_INCUB;

bool chauffageON = false;
bool humiditeON  = false;
bool incubationDemarree = false;    // Vrai dès que le bouton a été pressé

unsigned long dernierAffichage = 0;
const unsigned long INTERVALLE = 2000; // 2 secondes

// ============================================================
// Calcule les consignes selon le jour actuel
// ============================================================
void calculerConsignes() {
  if (jour >= 1 && jour <= 18) {
    consigneTemp  = TEMP_INCUB;
    consigneHumid = HUMID_INCUB;
  } else if (jour >= 19) {
    consigneTemp  = TEMP_ECLOS;
    consigneHumid = HUMID_ECLOS;
  } else {
    // Pas démarré : valeurs par défaut (sécurité)
    consigneTemp  = TEMP_INCUB;
    consigneHumid = HUMID_INCUB;
  }
}

// ============================================================
// Démarre l'incubation : enregistre la date du jour
// ============================================================
void demarrerIncubation() {
  timestampDebut = rtc.now().unixtime();   // Date actuelle en secondes
  EEPROM.put(EEPROM_ADR, timestampDebut);  // Sauvegarde permanente
  jour = 1;
  incubationDemarree = true;
  calculerConsignes();
  Serial.println("Incubation demarree !");
}

// ============================================================
// Lit la date de début dans l'EEPROM et calcule le jour
// ============================================================
void calculerJour() {
  EEPROM.get(EEPROM_ADR, timestampDebut);

  // EEPROM vierge -> pas d'incubation en cours
  if (timestampDebut == 0 || timestampDebut == 0xFFFFFFFF) {
    jour = 0;
    incubationDemarree = false;
    return;
  }

  // Une date valide est présente -> incubation en cours
  incubationDemarree = true;

  // Différence entre maintenant et le début, en secondes
  unsigned long secondesEcoulees = rtc.now().unixtime() - timestampDebut;

  // 1 jour = 24 * 3600 = 86400 secondes
  jour = secondesEcoulees / 86400UL + 1;
  if (jour > 21) jour = 21; // On bloque au jour 21
}

// ============================================================
// Affiche tout sur le LCD
// ============================================================
void afficherLCD(float temp, float humid) {
  lcd.clear();

  // Ligne 1 : "Poule J5/21" ou "Poule Attente"
  lcd.setCursor(0, 0);
  lcd.print("Poule ");
  if (!incubationDemarree) {
    lcd.print("Attente");
  } else {
    lcd.print("J");
    lcd.print(jour);
    lcd.print("/21");
  }

  // Ligne 2 : "T:37.5C H:45%"
  lcd.setCursor(0, 1);
  lcd.print("T:");
  lcd.print(temp, 1);
  lcd.print("C H:");
  lcd.print(humid, 0);
  lcd.print("%");
}

// ============================================================
// SETUP
// ============================================================
void setup() {
  Serial.begin(9600);
  Serial.println("Incubateur - Demarrage");

  // Initialisation du capteur
  capteur.begin();

  // Initialisation du RTC
  if (!rtc.begin()) {
    Serial.println("RTC introuvable !");
    while (1); // Bloque le programme
  }

  // ATTENTION : décommentez la ligne suivante UNE SEULE FOIS pour régler
  // l'heure du RTC sur l'heure de compilation, téléversez, puis
  // recommentez-la et téléversez à nouveau :
  // rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));

  // Initialisation du LCD
  lcd.init();
  lcd.backlight();
  lcd.print("Incubateur");
  lcd.setCursor(0, 1);
  lcd.print("Poule...");
  delay(2000);

  // Configuration des broches
  pinMode(PIN_RELAIS_CHAUFF, OUTPUT);
  pinMode(PIN_RELAIS_HUMID,  OUTPUT);
  pinMode(PIN_BOUTON,        INPUT_PULLUP);

  digitalWrite(PIN_RELAIS_CHAUFF, RELAIS_OFF);
  digitalWrite(PIN_RELAIS_HUMID,  RELAIS_OFF);

  // Calcul du jour au démarrage (reprise après coupure)
  calculerJour();
  calculerConsignes();
}

// ============================================================
// BOUCLE PRINCIPALE
// ============================================================
void loop() {
  // ---- 1. Lecture du capteur ----
  float temperature = capteur.readTemperature();
  float humidite    = capteur.readHumidity();

  // Si erreur de lecture, on ignore et on recommence
  if (isnan(temperature) || isnan(humidite)) {
    Serial.println("Erreur DHT !");
    delay(1000);
    return;
  }

  // ---- 2. Bouton : détection de l'appui (passage HIGH -> LOW) ----
  static bool boutonPrecedent = HIGH;
  bool boutonActuel = digitalRead(PIN_BOUTON);

  if (boutonPrecedent == HIGH && boutonActuel == LOW) {
    delay(50);                              // Anti-rebond
    if (digitalRead(PIN_BOUTON) == LOW) {
      demarrerIncubation();
    }
  }
  boutonPrecedent = boutonActuel;

  // ---- 3. Recalcule le jour ----
  calculerJour();
  calculerConsignes();

  // ---- 4. Commande des relais, seulement si l'incubation est démarrée ----
  if (incubationDemarree) {
    // Chauffage (avec marge)
    if (temperature < consigneTemp) {
      digitalWrite(PIN_RELAIS_CHAUFF, RELAIS_ON);
      chauffageON = true;
    } else if (temperature > consigneTemp + MARGE_TEMP) {
      digitalWrite(PIN_RELAIS_CHAUFF, RELAIS_OFF);
      chauffageON = false;
    }

    // Brumisateur (avec marge)
    if (humidite < consigneHumid) {
      digitalWrite(PIN_RELAIS_HUMID, RELAIS_ON);
      humiditeON = true;
    } else if (humidite > consigneHumid + MARGE_HUMID) {
      digitalWrite(PIN_RELAIS_HUMID, RELAIS_OFF);
      humiditeON = false;
    }
  } else {
    // Pas d'incubation en cours -> tout éteint
    digitalWrite(PIN_RELAIS_CHAUFF, RELAIS_OFF);
    digitalWrite(PIN_RELAIS_HUMID,  RELAIS_OFF);
    chauffageON = false;
    humiditeON  = false;
  }

  // ---- 5. Affichage LCD toutes les 2 secondes ----
  if (millis() - dernierAffichage >= INTERVALLE) {
    afficherLCD(temperature, humidite);
    dernierAffichage = millis();
  }

  // ---- 6. Affichage série pour le dépannage ----
  Serial.print("Bouton: ");
  Serial.print(boutonActuel == LOW ? "APPUYE " : "relache");
  Serial.print(" | T="); Serial.print(temperature);
  Serial.print("C H="); Serial.print(humidite);
  Serial.print("% | J="); Serial.print(jour);
  Serial.print(" | Etat="); Serial.print(incubationDemarree ? "ACTIVE " : "ATTENTE");
  Serial.print(" | Chauf="); Serial.print(chauffageON ? "ON " : "OFF");
  Serial.print(" Hum="); Serial.println(humiditeON ? "ON" : "OFF");

  delay(50); // Boucle rapide : un appui court sur le bouton n'est pas manqué
}

6. Tester sans matériel : la simulation Wokwi

Avant d’acheter quoi que ce soit, vous pouvez essayer le montage gratuitement, ici même, dans la fenêtre ci-dessous. Cliquez sur le bouton vert de lecture (▶) en haut de la simulation pour la lancer, appuyez sur le bouton vert du montage pour démarrer l’incubation, puis cliquez sur le capteur et bougez ses curseurs de température et d’humidité : vous verrez les relais s’allumer et s’éteindre.

La simulation de l'incubateur, à tester directement dans la page. Simulation réalisée avec Wokwi / Kennedyen.net

Sur téléphone, la fenêtre est un peu petite : ouvrez plutôt la simulation en plein écran sur Wokwi. Le chargement peut aussi prendre quelques secondes si votre connexion est lente.

Une seule différence avec le vrai montage : le module DS3231 n’existe pas dans Wokwi. La simulation utilise donc un DS1307, et une seule ligne du code change :

RTC_DS1307 rtc;   // au lieu de : RTC_DS3231 rtc;

Pour 21 jours, les deux horloges conviennent. Mais le DS3231 est bien plus précis : il dérive d’environ une minute par an, contre environ une minute par mois pour le DS1307. C’est lui que nous conseillons pour la vraie couveuse.

Ouvrez aussi le moniteur série (9600 bauds). Une ligne s’affiche à chaque tour de boucle, par exemple : Bouton: relache | T=24.00C H=40.00% | J=1 | Etat=ACTIVE | Chauf=ON Hum=ON. C’est très pratique pour comprendre ce que fait le programme.

Les limites de la simulation :

  • Le capteur se règle à la main avec un curseur. Un vrai capteur réagit plus lentement.
  • La mémoire est effacée chaque fois que vous arrêtez la simulation. Pour imiter une coupure de courant, utilisez plutôt le bouton Reset de la carte : le programme redémarre et retrouve sa date de départ. Sur un vrai Arduino, la mémoire est conservée dans tous les cas.
  • Rien ne chauffe pour de vrai. Quand le chauffage s’allume, la température affichée ne monte pas. La simulation vérifie la logique du programme, pas le comportement réel de la couveuse.

Ce qu’il reste donc à vérifier en vrai : le temps de montée en température (plusieurs minutes), les pertes de chaleur de la boîte, la différence de température entre le haut et le bas, la sécurité électrique et le bon fonctionnement pendant 21 jours.

7. Construire la boîte

La boîte est aussi importante que l’électronique : une boîte mal isolée laisse partir la chaleur, et la résistance n’arrive plus à suivre. Voici ce que nous conseillons :

  • Taille : environ 40 × 30 × 30 cm.
  • Matière isolante : polystyrène épais, ou contreplaqué doublé à l’intérieur.
  • Couvercle : avec une fenêtre transparente, pour surveiller les œufs sans ouvrir.
  • Aération : quelques petits trous, car les embryons ont besoin d’air.
  • Support des œufs : un grillage métallique fin (mailles d’environ 1 cm) tendu sur un petit cadre en bois, à environ 5 cm du fond, pour que l’air chaud passe dessous. Les 12 œufs sont couchés en 3 rangées de 4, avec de petites baguettes entre les rangées pour qu’ils ne roulent pas. Évitez le plateau en carton : il boit l’humidité et finit par moisir.
  • Capteur : à la hauteur des œufs, loin de la résistance, sinon il mesure la chaleur de la résistance et non celle des œufs.
  • Résistance PTC : sur un côté, avec une grille de protection. Ne la collez pas directement contre le polystyrène : fixez-la sur une petite plaque de métal ou laissez un espace.
  • Brumisateur : dans un coin, posé dans un petit récipient d’eau.
  • Ventilateur (conseillé) : il brasse l’air, mais ne doit pas souffler directement sur les œufs.
  • Électronique : l’Arduino, les relais et l’alimentation dans un petit boîtier séparé, à l’extérieur, loin de l’humidité. L’écran se place dans une petite fenêtre découpée dans la paroi.

Représentation d&#x27;une couveuse Arduino de 12 œufs

Représentation de la couveuse créée par IA, ce n'est pas une photo réelle : 12 œufs sur un grillage surélevé, résistance protégée sur le côté, brumisateur dans un coin et électronique à l'extérieur. © / Kennedyen.net

8. Les 21 jours, étape par étape

  1. Faites un essai à vide. Laissez tourner la couveuse sans œufs pendant au moins une journée. Vérifiez avec un thermomètre séparé que la température est stable et la même partout.
  2. Placez les œufs, puis appuyez sur le bouton. L’écran passe de « Poule Attente » à « Poule J1/21 ». À partir de là, tout se règle tout seul.
  3. Retournez les œufs à la main, 3 fois par jour, jusqu’au jour 18. Sans retournement, l’embryon risque de coller à la coquille. Un nombre impair de retournements évite que l’œuf passe deux nuits de suite sur le même côté. Faites une croix au crayon (pas au feutre) sur un côté de chaque œuf : vous saurez tout de suite lesquels vous avez tournés. Lavez-vous les mains avant de les toucher.
  4. Au jour 19, la couveuse passe seule en mode éclosion : l’humidité monte à 67,5 %. À partir de ce jour, on ne touche plus aux œufs et on évite d’ouvrir le couvercle, pour garder l’humidité.
  5. Jour 21 : l’éclosion. L’écran reste bloqué sur « J21/21 ». Laissez les poussins sécher dans la couveuse avant de les sortir.

Et en cas de coupure de courant ? Au retour du courant, l’Arduino retrouve sa date de départ et reprend le compte des jours sans que vous ayez à appuyer sur le bouton. Mais pendant la coupure, il ne peut pas chauffer : la boîte refroidit. D’où l’intérêt d’une bonne isolation, et d’éviter d’ouvrir le couvercle pendant ce temps.

9. En cas de problème

  • L’écran reste noir ou n’affiche rien : dans le code, remplacez l’adresse 0x27 par 0x3F. Vérifiez aussi le petit réglage de contraste (une petite vis bleue) à l’arrière de l’écran.
  • Les relais marchent à l’envers (allumés en permanence, ou allumés au mauvais moment) : en haut du code, échangez HIGH et LOW dans les lignes RELAIS_ON et RELAIS_OFF.
  • Le moniteur série affiche « RTC introuvable ! » : vérifiez les fils de l’horloge sur A4 et A5.
  • Le moniteur série affiche « Erreur DHT ! » : vérifiez le fil de données du capteur sur D2, et son alimentation.
  • Le jour affiché est faux : l’heure du RTC n’a pas été réglée. Refaites la manipulation avec la ligne rtc.adjust(...) décrite plus haut.
  • Le bouton ne démarre rien : vérifiez qu’une patte est sur D3 et l’autre sur GND. Le moniteur série doit afficher « APPUYE » quand vous appuyez.

10. Pour aller plus loin

Ce projet est une base. Voici quelques idées pour l’améliorer :

  • un buzzer qui sonne si la température devient trop haute ou trop basse ;
  • un servomoteur qui incline le support des œufs, pour ne plus les retourner à la main ;
  • un bouton d’annulation pour remettre l’incubation à zéro ;
  • un module ESP8266 ou ESP32 pour suivre la température depuis votre téléphone ;
  • une batterie pour tenir pendant les coupures de courant.

Un capteur qui mesure, un Arduino qui décide

Avec une quarantaine de milliers de francs et quelques après-midi de travail, vous avez une couveuse que vous comprenez de A à Z. Si une pièce lâche, vous savez laquelle changer. Si vous voulez couver d’autres œufs, vous savez où modifier le code. C’est tout l’esprit du Lab Maker : comprendre, tester, réussir.

Le projet est aussi présenté en vidéo sur notre compte TikTok. Si vous vous lancez, racontez-nous comment s’est passée votre première éclosion. Le prochain projet du Lab Maker arrive très bientôt sur le site !