🪴 LE GARDIEN ZEN & FUN – Meuble d'entrée connecté

🎯 Objectifs du projet

• Apprendre à travailler le bois de palette
• Initiation à l'électronique et à la programmation (Arduino/ESP)
• Créer un objet unique, esthétique et fonctionnel
• Partager un tutoriel open-source pour la communauté

📐 Stratégie de réalisation

🔩 Matériel & fournitures

Bois & quincaillerie

Électronique & high-tech

Total estimé (neuf) : ~80-100€ (hors récup')

💻 Codes sources

1. ESP8266 – Station météo + LEDs ambiance

// Station météo intérieure avec affichage OLED et LEDs pilotées par météo extérieure
// Ce code lit les données locales (DHT22), récupère la météo externe via API, affiche sur OLED, et ajuste les LEDs.
// Assurez-vous d'avoir les librairies installées : ESP8266WiFi, Wire, Adafruit_GFX, Adafruit_SSD1306, DHT, ArduinoJson.
// Testez sur breadboard avant intégration pour debugguer les connexions.
#include <ESP8266WiFi.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <DHT.h>
#include <ArduinoJson.h>
// WiFi
const char* ssid = "TON_SSID";
const char* password = "TON_MDP";
// API météo (OpenWeatherMap)
const char* host = "api.openweathermap.org";
const char* apiKey = "TA_CLE_API";
const char* city = "Paris"; // Ta ville
// Broches
#define DHTPIN D4
#define DHTTYPE DHT22
#define LED_PIN D2 // Ruban LED (via transistor ou mosfet)
DHT dht(DHTPIN, DHTTYPE);
// OLED
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);
// Variables météo extérieure
float extTemp = 0;
int extWeather = 0; // code météo
void setup() {
  Serial.begin(115200);
  dht.begin();
 
  // Initialisation OLED
  if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
    Serial.println("OLED non trouvé");
  }
  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);
 
  pinMode(LED_PIN, OUTPUT);
  digitalWrite(LED_PIN, LOW);
 
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("WiFi connecté");
}
void loop() {
  // Lecture capteur intérieur
  float h = dht.readHumidity();
  float t = dht.readTemperature();
 
  if (isnan(h) || isnan(t)) {
    Serial.println("Erreur lecture DHT");
    return;
  }
 
  // Récupération météo extérieure
  getWeatherData();
 
  // Affichage sur OLED
  display.clearDisplay();
  display.setCursor(0,0);
  display.print("Interieur:");
  display.setCursor(0,10);
  display.print(t); display.print("C ");
  display.print(h); display.print("%");
  display.setCursor(0,25);
  display.print("Exterieur:");
  display.setCursor(0,35);
  display.print(extTemp); display.print("C ");
  display.print(weatherToChar(extWeather));
  display.display();
 
  // Contrôle LED selon météo
  setLedColor(extWeather);
 
  delay(60000); // Attente 1 minute
}
void getWeatherData() {
  WiFiClient client;
  if (!client.connect(host, 80)) {
    Serial.println("Connexion échouée");
    return;
  }
 
  String url = "/data/2.5/weather?q=" + String(city) + "&appid=" + String(apiKey) + "&units=metric";
  client.print(String("GET ") + url + " HTTP/1.1\r\n" +
               "Host: " + host + "\r\n" +
               "Connection: close\r\n\r\n");
 
  delay(500);
 
  String response;
  while(client.available()) {
    response = client.readStringUntil('\r');
  }
 
  // Parse JSON
  int jsonStart = response.indexOf('{');
  if (jsonStart > 0) {
    String json = response.substring(jsonStart);
    DynamicJsonDocument doc(1024);
    deserializeJson(doc, json);
    extTemp = doc["main"]["temp"];
    extWeather = doc["weather"][0]["id"];
  }
}
char weatherToChar(int code) {
  if (code >= 200 && code < 300) return '⛈️'; // Orage
  if (code >= 300 && code < 400) return '🌧️'; // Bruine
  if (code >= 500 && code < 600) return '☔'; // Pluie
  if (code >= 600 && code < 700) return '❄️'; // Neige
  if (code >= 700 && code < 800) return '🌫️'; // Brume
  if (code == 800) return '☀️'; // Clair
  if (code > 800) return '☁️'; // Nuageux
  return '?';
}
void setLedColor(int code) {
  // Exemple : bleu pour pluie, jaune pour soleil, blanc pour nuage
  // Note : Adaptez pour ruban RGB en utilisant des librairies comme FastLED si besoin de couleurs précises.
  if (code >= 500 && code < 600) { // Pluie -> bleu
    analogWrite(LED_PIN, 50); // Intensité faible (PWM si supporté)
  } else if (code == 800) { // Soleil -> jaune (oranger)
    analogWrite(LED_PIN, 200);
  } else { // Autre -> blanc (intensité moyenne)
    analogWrite(LED_PIN, 100);
  }
}

2. Arduino Nano – Tiroir motorisé (version simple)

// Contrôle tiroir motorisé avec capteur IR et interrupteur magnétique
// Ce code gère l'ouverture/fermeture auto, avec détection de main et délai. Utilisez un pont en H pour inverser le sens du moteur.
// Testez la durée d'ouverture/fermeture (delay 2000) selon la longueur du tiroir et la vitesse du moteur.
#define MOTOR_IN1 9
#define MOTOR_IN2 10
#define ENABLE_PIN 11 // PWM pour vitesse (optionnel)
#define IR_SENSOR A0 // Capteur infrarouge (ou digital selon modèle)
#define MAGNET_SENSOR 2 // Interrupteur ILS (entrée pull-up)
#define LED_TIROIR 13
bool tiroirOuvert = false;
unsigned long ouvertureTime = 0;
const long dureeOuverture = 10000; // 10 secondes avant fermeture auto
void setup() {
  pinMode(MOTOR_IN1, OUTPUT);
  pinMode(MOTOR_IN2, OUTPUT);
  pinMode(ENABLE_PIN, OUTPUT);
  pinMode(IR_SENSOR, INPUT);
  pinMode(MAGNET_SENSOR, INPUT_PULLUP);
  pinMode(LED_TIROIR, OUTPUT);
 
  digitalWrite(ENABLE_PIN, HIGH); // Moteur actif
  stopMotor();
}
void loop() {
  // Détection main (IR)
  int irValue = analogRead(IR_SENSOR);
  if (irValue > 500 && !tiroirOuvert) { // Seuil à ajuster selon calibration (testez avec Serial.print)
    ouvrirTiroir();
  }
 
  // Détection fermeture via ILS
  if (digitalRead(MAGNET_SENSOR) == HIGH && tiroirOuvert) {
    // Tiroir fermé manuellement ? On arrête le moteur
    stopMotor();
    tiroirOuvert = false;
    digitalWrite(LED_TIROIR, LOW);
  }
 
  // Fermeture automatique après délai
  if (tiroirOuvert && (millis() - ouvertureTime > dureeOuverture)) {
    fermerTiroir();
  }
}
void ouvrirTiroir() {
  digitalWrite(MOTOR_IN1, HIGH);
  digitalWrite(MOTOR_IN2, LOW);
  delay(2000); // Durée d'ouverture (à ajuster selon course, mesurez avec un chronomètre)
  stopMotor();
  tiroirOuvert = true;
  ouvertureTime = millis();
  digitalWrite(LED_TIROIR, HIGH);
}
void fermerTiroir() {
  digitalWrite(MOTOR_IN1, LOW);
  digitalWrite(MOTOR_IN2, HIGH);
  delay(2000);
  stopMotor();
  tiroirOuvert = false;
  digitalWrite(LED_TIROIR, LOW);
}
void stopMotor() {
  digitalWrite(MOTOR_IN1, LOW);
  digitalWrite(MOTOR_IN2, LOW);
}

3. Script Python (optionnel) pour exfiltration météo vers PC

#!/usr/bin/env python3
# Récupère les données du capteur via série et les envoie vers un serveur MQTT (optionnel)
# Installez paho-mqtt via pip. Exécutez sur un PC connecté à l'ESP via USB. Adaptez le port série (/dev/ttyUSB0 pour Linux, COMX pour Windows).
# Pour MQTT, configurez un broker local comme Mosquitto.
import serial
import paho.mqtt.client as mqtt
import time
ser = serial.Serial('/dev/ttyUSB0', 115200) # Adapte le port
client = mqtt.Client()
client.connect("localhost", 1883, 60)
while True:
    line = ser.readline().decode().strip()
    if line.startswith("Temp:"):
        # Exemple de parsing
        temp = line.split()[1]
        client.publish("maison/entree/temperature", temp)
    time.sleep(1)

📏 Plans de coupe (palettes)

Vue d'ensemble – dimensions

• Hauteur totale : 100 cm (90 cm pieds + 2-3 cm plateau). Cela permet une ergonomie idéale pour une entrée, avec le plateau à hauteur de hanche.
• Largeur : 80-100 cm (selon palettes). Adaptez pour qu'il s'intègre dans votre espace ; mesurez votre entrée avant coupe.
• Profondeur : 30-40 cm. Suffisant pour rangement sans empiéter sur le passage.
• Dosseret : 30 cm de haut. Pour supporter le mur végétal sans alourdir visuellement.
• Tiroir intérieur : 70 cm (L) x 25 cm (P) x 25 cm (H). Volume pour clés, courrier, petits objets ; assurez-vous que les rails supportent 5-10kg.

Détail des pièces

Remarque : Adaptez les dimensions en fonction des planches récupérées. Le principe est de garder des proportions harmonieuses. Utilisez un logiciel gratuit comme SketchUp pour visualiser avant coupe si besoin.

🔨 Étapes de réalisation détaillées

Étape 1 : Préparation des palettes

• Démontez les palettes avec un pied-de-biche, retirez tous les clous. Inspectez chaque planche pour fissures ou moisissures ; jetez les défectueuses.
• Sélectionnez les planches les plus saines (pas de fentes, pas de pourriture). Classez-les par taille pour optimiser les coupes.
• Poncez abondamment : grain 80, puis 120, puis 220 pour un toucher lisse. Poncez dans le sens du bois pour éviter les rayures ; aspirez la poussière entre passes.

Étape 2 : Assemblage de la structure

• Assemblez le cadre de base avec les pieds et les traverses (vis + colle). Mesurez les diagonales pour vérifier l'équerrage ; ajustez si différence >1cm.
• Fixez le plateau sur le dessus (vis par dessous). Percez des avant-trous pour éviter de fendre le bois.
• Fixez le dosseret à l'arrière. Renforcez avec des équerres métalliques si le meuble est lourd.
• Assemblez le tiroir (vérifiez l'équerrage) et montez les rails. Testez l'ouverture/fermeture plusieurs fois pour fluidité ; ajustez les vis si coincé.

Étape 3 : Intégration des composants électroniques

• Recharge sans fil : Creusez un logement dans le plateau pour la bobine Qi (utilisez une défonceuse ou perceuse avec fraise), collez-la avec époxy. Fixez la powerbank et les ports USB sous le plateau (velcro ou vis). Passez les câbles via un trou discret de 1cm diamètre.
• Tiroir motorisé : Installez le moteur à l'arrière du meuble, reliez-le au tiroir par une tige filetée ou courroie. Placez le capteur IR sur la façade avant (trou de 5mm), l'ILS sur le côté (aligné avec aimant). Câblez le pont en H et l'ESP sur une breadboard fixée à l'intérieur ; utilisez des fils AWG 22 pour fiabilité.
• Station météo : Fixez le DHT22 et l'OLED sur le côté du dosseret (trous percés avec foret 3mm). Connectez à l'ESP8266 via I2C pour OLED et digital pour DHT ; isolez les soudures avec gaine thermo.
• LEDs : Collez le ruban LED sous le plateau (éclairage sol) ou derrière le dosseret (halo). Utilisez un contrôleur PWM si RGB pour transitions fluides ; testez l'intensité pour éviter surchauffe.

Étape 4 : Programmation

• Téléversez le code de la station météo sur l'ESP8266 (après avoir modifié SSID et clé API). Utilisez l'IDE Arduino ; surveillez les erreurs de compilation pour librairies manquantes.
• Téléversez le code du tiroir sur l'Arduino (ou autre micro). Ajoutez des Serial.print pour debug (ex: "IR detecte: " + irValue).
• Testez chaque fonction indépendamment. Simulez des scénarios : passez la main, attendez le délai, forcez la fermeture manuelle.

Étape 5 : Finitions et plantations

• Appliquez une ou deux couches d'huile de lin sur tout le bois (laissez sécher 24h). Utilisez un pinceau pour les recoins ; essuyez l'excès pour éviter les gouttes.
• Installez les plantes grasses dans le mur végétal (poches en feutre ou petits pots fixés). Ajoutez un drainage (graviers au fond) et arrosez modérément au départ.
• Rangez les câbles avec des colliers, vérifiez l'isolation. Utilisez des gaines pour grouper les fils et éviter les enchevêtrements.
• Testez l'ensemble : posez un téléphone sur la zone Qi, passez la main devant le capteur, admirez les LEDs et l'écran OLED. Debuggez tout bug (ex: faux positifs IR) en ajustant seuils.

🎓 Conclusion & perspectives

Ce projet allie créativité, récupération et technologie pour un résultat unique. Il peut être adapté à l'infini :

• Ajoutez une enceinte Bluetooth
• Intégrez un réveil avec simulateur d'aube
• Utilisez des capteurs de CO2 pour la qualité de l'air
• Créez une version extérieure pour le balcon

"Le vrai luxe, c'est de fabriquer soi-même des objets qui ont une âme."