Interface Physique Robuste pour Domotique : Maquette Maison Interactive (Arduino Yun + MQTT + OpenHAB)

Composants et Fournitures

Composant	Quantité
Servomoteur TowerPro SG90 (9g)	3
Petites Charnières	1 jeu
Boutons Poussoirs Momentanés	2
Arduino Yun (WiFi + Linux OpenWrt)	1
Transformateur de Courant 100A (YHDC SCT-013-000)	1
Résistances et Condensateurs (divers)	7

Concept : Interface Physique vs Virtuelle

La plupart des systèmes domotiques s'appuient sur une interface virtuelle (application smartphone). Pratique à distance, mais peu intuitive au quotidien : il faut sortir le téléphone, ouvrir l'appli, lire des icônes.

Ce projet propose une interface physique tangible : une maquette de maison posée sur la table basse ou le bureau, qui reflète en temps réel l'état de la vraie maison :

• Porte garage ouverte → porte maquette s'ouvre (servo).
• Porte entrée ouverte → porte maquette s'ouvre.
• Lumière allumée → LED rouge s'allume sur maquette.
• Consommation électrique → aiguille « buisson » bouge (servo).

Un coup d'œil suffit, sans écran, sans concentration. Et on peut aussi agir : deux boutons sur la maquette commandent la vraie maison (lumière Zigbee, porte garage).

Architecture Système

┌─────────────┐     MQTT      ┌──────────────┐     MQTT      ┌──────────────────┐
│  Capteurs   │ ─────────────▶ │  Broker MQTT │ ◀──────────── │  Maquette Maison │
│ (Énergie,   │   (Mosquitto   │  (Raspberry  │   (Arduino     │  (Arduino Yun +  │
│  Wink, DIY) │    sur Pi)     │     Pi)      │     Yun)       │   Servos/LED)    │
└─────────────┘                └──────────────┘                └────────┬─────────┘
                                                                        │
                                                                        │ Boutons
                                                                        ▼
                                                               ┌──────────────────┐
                                                               │   Actionneurs    │
                                                               │ (Lumière Zigbee, │
                                                               │  Porte Garage)   │
                                                               └──────────────────┘
                                    ▲
                                    │ REST API / MQTT
                                    ▼
                          ┌──────────────────┐
                          │    OpenHAB 2     │
                          │ (Interface Web/  │
                          │  App Mobile,     │
                          │  Règles, Graphes)│
                          └──────────────────┘

Centralisation : Raspberry Pi héberge Mosquitto (broker MQTT) + OpenHAB 2. OpenHAB fournit l'interface virtuelle (appli, graphiques énergie) et le moteur de règles. La maquette est un client MQTT comme les autres.

Construction de la Maquette (Partie 1)

Structure

Boîte en carton (récupération), toit formé par rabats collés/renforcés (Lego). Portes/fenêtres découpées, charnières collées (ruban double-face 3M type crochets). Servos fixés au ruban mousse 3M.

• Porte garage : servo #2 pousse vers le haut, gravité referme.
• Porte entrée : servo #1 tire via fil (charnière côté opposé). Pièce Lego comme entretoise.
• Compteur énergie : flèche sur palonnier servo #3, cadran « buisson » gradué kW. LED rouge au-dessus = lumière allumée.

Boutons de Commande

2 boutons momentanés traversants (écrou externe, contacts soudés) :

• Bouton 1 (broche 8) : toggle lumière Zigbee.
• Bouton 2 (broche 9) : ouverture/fermeture porte garage réelle.

Câblage et Code Maquette (Partie 2)

Raccordement Broches Arduino Yun

Fonction	Broche
LED État MQTT (connexion)	7
LED Lumière (indicateur)	4
Servo 1 - Porte Entrée	3
Servo 2 - Porte Garage	5
Servo 3 - Compteur Énergie	6
Bouton 1 - Lumière	8 (INPUT_PULLUP)
Bouton 2 - Porte Garage	9 (INPUT_PULLUP)

Options Contrôleur

• Arduino Uno + Shield Ethernet (~20€) : filaire, fiable. Code smarthome_ethernet.ino.
• Arduino Yun (~65€) : WiFi natif, pont Linux, plus libre. Code smarthome_yun.ino (inclut boutons).

Les deux codes sont très similaires (juste couche réseau). Vidéos démo : Yun | Uno+Ethernet.

Logique Code (Extrait Principaux Mécanismes)

• Abonnement MQTT topics : 2822 (LED lumière), 2832 (porte entrée), 2842 (porte garage), 2852 (énergie Watts).
• Callback MQTT : convertit payload float → position cible servo (0/1 pour portes, conversion linéaire 0-6000W → 180-0° pour énergie).
• Mouvement doux non-bloquant : millis() + pas de 1° toutes les 20ms (évite delay()).
• Boutons (anti-rebond 3s) : publient sur topics 2862 (lumière) et 2872 (garage) → OpenHAB traite → actionneurs réels.
• Watchdog MQTT : reconnexion auto toutes les 60s si déconnexion.

Fichiers code : smarthome_yun.ino, smarthome_ethernet.ino (pièces jointes).

Capteurs : Entrées (Partie 2)

1. Moniteur Énergie (OpenEnergyMonitor sur Arduino Yun)

Transformateur de courant 100A (SCT-013-000, ~7€) sur une phase entrante. Circuit conditionnement : résistance de charge 33Ω (ou 2×68Ω //), diviseur tension 2×10kΩ, condensateur 10µF (ou 2×22µF série). Bibliothèque EmonLib.h.

Calibration : lecture ampèremètre réel → correction offset (~+1A constant soustrait dans le code). Publication MQTT toutes les 10s : 2853 (Amps), 2852 (Watts = Amps × 115V).

Intégration OpenHAB (Énergie)

// Items
Number itm_smarthome_energy_amps "Energie (Amps) [%.1f]" {mqtt="<[mymosquitto:2853:state:default]"}
Number itm_smarthome_energy_watts "Energie (Watts) [%.1f]" {mqtt="<[mymosquitto:2852:state:default]"}

// Sitemap
Text label="Energie" icon="firstfloor" {
  Frame label="Consommation" {
    Text item=itm_smarthome_energy_amps
    Text item=itm_smarthome_energy_watts
    Chart item=itm_smarthome_energy_watts period=h refresh=5000
  }
}

// Persistence (rrd4j.persist)
Strategies { everyMinute : "0 * * * * ?" }
Items {
  itm_smarthome_energy_watts : strategy = everyUpdate
  // ... autres items
}

2. Nœuds Capteurs DIY Sans Fil (Optionnel)

Ancien projet : transceiver 433MHz/NRF24L01+ (~5€) + passerelle MQTT. Utilisé pour :

• Contact porte garage (reed switch) → état porte maquette.
• Photorésistance (détection lumière allumée) → LED maquette.
• Capteur reed switch batterie (peu esthétique pour intérieur).

Remplacé par capteurs Wink pour l'esthétique (étape suivante).

3. Capteurs Wink Hub + Tripper (Contact Porte/Fenêtre)

Wink Hub rooté (exploit PHP « aprontest ») → contrôle local LAN (sans cloud Wink). Script PHP sur Raspberry Pi (polling.php) interroge Hub Wink → état 2 capteurs Tripper → publie via API REST OpenHAB → OpenHAB republie MQTT → maquette met à jour portes.

Fichiers fournis : polling.php, items.txt, sitemap.txt, rules.txt, demo_1_general.sh.

Alternative sans root : API Wink Cloud → OpenHAB (dépend internet, latence).

Actionneurs : Sorties (Partie 3)

1. Contrôle Lumière Zigbee (via Wink Hub rooté)

OpenHAB + règles + script PHP → commande ampoule Cree Connected / GE Link. Bouton maquette + interface OpenHAB + application mobile → même résultat. Vidéo démo : Lumière bouton + capteur.

2. Ouverture Porte Garage Réelle

Module dédié : Arduino Clone + Shield Ethernet + Relais Reed + Télécommande garage de secours.

• Arduino abonné topic MQTT garage_command.
• Réception commande → impulsion relais reed (contacts secs) → ferme contact bouton télécommande → ouvre/ferme porte.
• Règle OpenHAB supplémentaire (garage_monitor_rules.txt) : synchronisation état + annonce audio optionnelle.

Code module garage : grage_opener.ino. Règle OpenHAB : garage_monitor_rules.txt.

Réflexions Finales et Pistes d'Évolution

• Flexibilité MQTT/OpenHAB : n'importe quel capteur (Z-Wave via clé USB, ESP8266 standalone, Arduino, Raspberry Pi) peut publier → maquette s'adapte.
• Wink sans root : possible via API Cloud + pont OpenHAB.
• Matériaux : carton/boîte de récupération, colle, Lego, ruban 3M → accessible, modifiable, réparables.
• Évolutions : ajouter température, humidité, qualité air, volets, chauffage... chaque nouvelle donnée = nouveau servo/LED sur maquette ou extension modulaire.
• Portabilité : maquette sur batterie + Yun WiFi = surveillance maison depuis bureau/travail via VPN.

Ce projet démontre qu'une interface physique tangible complète utilement le virtuel : information ambiante, compréhension immédiate, interaction ludique, et passerelle vers la domotique sérieuse (OpenHAB, MQTT, standards ouverts).

Schéma de Câblage

Fichiers Code Principaux

• smarthome_yun.ino : firmware maquette (Arduino Yun, WiFi, MQTT, servos, boutons).
• smarthome_ethernet.ino : version Arduino Uno + Shield Ethernet.
• energy_monitor_yun.ino : moniteur énergie (Yun + EmonLib + MQTT).
• grage_opener.ino : module commande porte garage (Arduino + Ethernet + relais reed).
• polling.php : script Raspberry Pi → Wink Hub (rooté) → OpenHAB REST.
• items.txt, sitemap.txt, rules.txt, garage_monitor_rules.txt : configuration OpenHAB.