Octopod : Solution domotique IoT intelligente pour maison et industrie

Composants et fournitures

Arduino UNO	×1
Arduino MKR WiFi 1010 (ou NodeMCU ESP8266 / ESP32)	×1
Maxim Integrated MAX32630FTHR (ou MAX32620FTHR, Arduino 1010, ou carte ESP8266 avec module WiFi externe)	×1
Raspberry Pi Zero Wireless (ou Pi 2/3 normal)	×1
Capteur température/humidité DHT11 (4 broches)	×1
Capteur de gaz Seeed Grove MQ2	×1
Capteur d'humidité du sol SparkFun (avec bornes à vis)	×1
Capteur de mouvement PIR (générique)	×1
Lecteur RFID (générique)	×1
Relais (générique, 2 canaux de préférence)	×1
LED RGB diffuse cathode commune	×1
Module caméra Raspberry Pi	×1
Servomoteurs (Tower Pro MG996R)	×1
Buzzer	×2
Module Bluetooth HC-05	×1
LED (générique)	×4
Adaptateur secteur / Power Bank	×2
Carte mémoire (>4 Go, classe 10 de préférence, requis pour Raspberry Pi OS)	×1

Outils et machines nécessaires

• Pistolet à colle chaude (générique)
• Imprimante 3D (générique) - Optionnel
• Outils manuels : pinces à bec long, ciseaux, cutter, etc.

Applications et services en ligne

• Blynk
• OpenCV

À propos du projet

Il existe de nombreux projets d'automatisation IoT, mais croyez-moi, il n'y a rien de tel qu'Octopod ! Octopod est construit avec NodeMCU (MAX32620FTHR ou Arduino MKR 1010), Arduino Uno, et Raspberry Pi 3. Octopod rend votre maison intelligente. Il vous envoie diverses données : température, humidité, et qualité de l'air (gaz) dans votre maison/bureau/industrie. Il vous envoie une notification dès qu'il détecte un mouvement et vous indique quand arroser vos plantes. Vous pouvez aussi contrôler vos appareils via l'application Blynk sur votre smartphone. Octopod permet même un véritable éclairage d'ambiance !

Octopod est équipé d'une minuscule caméra qui envoie un flux en direct. Cette caméra utilise aussi l'intelligence artificielle (OpenCV) pour détecter les humains dans son champ de vision et vous envoyer leurs photos par email. En plus, il dispose d'un système de verrouillage de porte par RFID ! Impressionnant, non ?

Comment tout fonctionne

Le NodeMCU est connecté à une série de capteurs, un module relais et des LEDs RGB. Il est connecté à l'application Blynk sur smartphone via WiFi, qui envoie toutes les données et permet de contrôler la maison.

Le Raspberry Pi est aussi connecté au WiFi, ce qui permet de voir le flux en direct via la Pi Camera. Nous avons installé les bibliothèques OpenCV sur le Pi, et configuré celui-ci pour détecter tout être humain dans son champ de vision et vous envoyer leurs images par email.

L'unité de porte intelligente utilise un module RFID. Quand un badge RFID autorisé est approché, la porte s'ouvre automatiquement.

ÉTAPE 1 : Programmation de l'Octopod principal

J'ai ajouté des commentaires sur presque chaque ligne, pour que vous compreniez et ne copiiez pas seulement. Voici en résumé ce qui se passe lors de l'exécution du code :

• Inclusion des bibliothèques :

Ce code utilise 2 bibliothèques principales : la bibliothèque Blynk pour la compatibilité avec l'app Blynk, et la bibliothèque DHT11 qui convertit les données brutes du capteur en température et humidité. Pour les télécharger, allez aux liens dans le code, téléchargez-les, puis dans l'IDE Arduino : Croquis → Inclure une bibliothèque → Ajouter bibliothèque .ZIP.

#include <ESP8266WiFi.h> // Bibliothèque WiFi ESP8266
#include <BlynkSimpleEsp8266.h> // Bibliothèque Blynk
#include <DHT.h> // Bibliothèque capteur DHT
#define BLYNK_PRINT Serial

Ce code Blynk connecte votre NodeMCU à Internet puis l'authentifie auprès de votre app :

// Obtenez le Token Auth dans l'app Blynk. Allez dans Paramètres du projet (icône écrou).
char auth[] = "Votre Clé Auth Blynk";
// Vos identifiants WiFi. Mettez "" pour réseaux ouverts.
char ssid[] = "Votre SSID WiFi";
char pass[] = "Votre Mot de passe WiFi";

• Définition des broches et entiers :

Ici nous définissons les broches de nos capteurs. Vous pouvez les changer selon vos besoins. Nous définissons aussi des entiers utilisés dans le code.

#define DHTPIN 2     // Broche capteur température/humidité
#define soilPin 4    // Broche capteur humidité sol
#define gasPin A0    // Broche analogique capteur gaz
#define pirPin 12    // Broche capteur PIR

int pirValue;        // Stockage valeur PIR lue
int soilValue;       // Stockage valeur humidité sol lue
int PIRpinValue;     // Valeur envoyée par Blynk App Pin V0
int SOILpinValue;    // Valeur envoyée par Blynk App Pin V1

• BLYNK_WRITE() :

Ce code dit à l'app Blynk qu'il peut utiliser les broches V0 et V1 pour indiquer si la détection de mouvement et le test d'humidité du sol sont ACTIVÉS.

BLYNK_WRITE(V0) // Broche V0 de l'app Blynk indique si Détection Mouvement est ON
{ PIRpinValue = param.asInt(); }

BLYNK_WRITE(V1) // Broche V1 de l'app Blynk indique si Humidité Sol est ON
{ SOILpinValue = param.asInt(); }

• void sendSensor() :

Ce code récupère les données du DHT11, les rend exploitables, et les envoie aux broches virtuelles V5 et V6.

void sendSensor() {
  int h = dht.readHumidity();
  int t = dht.readTemperature(); // ou dht.readTemperature(true) pour Fahrenheit
  if (isnan(h) || isnan(t)) {
    Serial.println("Echec lecture capteur DHT !");
    return;
  }
  // N'envoyez pas plus de 10 valeurs par seconde.
  Blynk.virtualWrite(V5, h); // humidité vers broche V5
  Blynk.virtualWrite(V6, t); // température vers broche V6
}

• void getPirValue() & void getSoilValue() :

Lit la valeur numérique des capteurs, puis exécute une condition if-else pour vérifier l'état du capteur. Si le capteur est dans l'état requis, il envoie une notification via l'app Blynk.

void getPirValue(void) {
  pirValue = digitalRead(pirPin);
  if (pirValue) // Broche numérique PIR = HIGH sur détection humaine
  {
    Serial.println("Mouvement détecté");
    Blynk.notify("Mouvement détecté");
  }
}

void getSoilValue(void) {
  soilValue = digitalRead(soilPin);
  if (soilValue == HIGH) // Broche numérique capteur sol = LOW quand humidité faible
  {
    Serial.println("Arroser les plantes");
    Blynk.notify("Arroser les plantes");
  }
}

• void setup() :

Dans setup(), nous faisons des choses à faire une seule fois : démarrer la communication série à 9600 bauds, autoriser ce code auprès de l'app Blynk, démarrer la lecture DHT, tweeter sur votre compte Twitter que votre projet domotique est en ligne, dire au Node que les broches PIR et capteur sol sont en entrée uniquement.

void setup() {
  Serial.begin(9600);
  Blynk.begin(auth, ssid, pass);
  // Vous pouvez aussi spécifier le serveur :
  // Blynk.begin(auth, ssid, pass, "blynk-cloud.com", 8442);
  // Blynk.begin(auth, ssid, pass, IPAddress(192,168,1,100), 8442);
  dht.begin();
  Blynk.tweet("OCTOPOD EST EN LIGNE ! ");
  pinMode(pirPin, INPUT);
  pinMode(soilPin, INPUT);
  timer.setInterval(1000L, sendSensor);
}

• void loop() :

Dans loop(), nous écrivons ce qui doit se répéter. Ici, on s'assure que le code avant setup s'exécute. Puis 2 instructions If-Else vérifient l'état des broches V0 et V1 et lisent les capteurs en conséquence.

void loop() {
  Blynk.run();
  timer.run();
  if (PIRpinValue == HIGH) // V0 de l'app Blynk dit si Détection Mouvement est ON
  { getPirValue(); }
  if (SOILpinValue == HIGH) // V1 de l'app Blynk dit si Humidité Sol est ON
  { getSoilValue(); }
}

ÉTAPE 2 : Programmation du verrou intelligent RFID

C'est un code simple qui ne demande pas beaucoup d'explications. Mais je vais quand même résumer. Il y a deux versions : une pour connecter l'unité porte au Bluetooth (avertissement via terminal série), l'autre envoie au série pour visualisation si Arduino connecté au PC. Je préfère la version simple sans Bluetooth.

• Allez dans Croquis → Inclure bibliothèque → Gérer les bibliothèques → Tapez MFRC522 dans la recherche et installez. Puis Fichier → Exemples → Bibliothèques personnalisées → MFRC522 → dumpInfo Sketch. Au début vous pouvez lire comment connecter les broches (ou voir l'image). Lancez le code, ouvrez le moniteur série et approchez une carte RFID du module MFRC522 pendant 5 secondes. Notez l'UID de la carte, et de même pour vos autres cartes et porte-clés.
• Téléchargez le code de votre choix. Ouvrez-le et allez à cette ligne. Remplacez les X par l'UID de la carte qui doit ouvrir la porte. Téléversez le code.

if (content.substring(1) == "XX XX XX XX") { }

Dans ce code, deux choses principales dans la partie If-Else : dans If, on dit à l'Arduino que si l'UID correspond, faire bouger le servo (porte ouverte), clignoter des LEDs et émettre un son via le buzzer. Sinon, clignoter d'autres LEDs et émettre un son différent.

ÉTAPE 3 : Configuration IA détection humaine sur Raspberry Pi

Dans cette étape guidée, nous apprenons à faire une caméra de sécurité intelligente. La caméra vous enverra un email à chaque détection d'objet, et si vous êtes sur le même WiFi, vous pouvez accéder au flux en direct en tapant l'IP du Raspberry Pi dans un navigateur. Je vais montrer comment créer cette caméra intelligente depuis zéro.

Prérequis :

1. OpenCV (Open Source Computer Vision Library)
2. Raspberry Pi 3B
3. Raspberry Pi Camera V2

Suppositions :

1. Raspberry Pi 3 avec Raspbian Stretch installé. Si vous ne l'avez pas, mettez à jour votre OS. Téléchargez-le ici et suivez les instructions de mise à niveau (ou la méthode NOOBS recommandée pour débutants). Note : La mise à jour de Jessie vers Stretch peut poser des problèmes. Une installation fraîche de Stretch est recommandée.
2. Accès physique au Pi pour ouvrir un terminal et exécuter des commandes, ou accès distant via SSH/VNC. Je ferai la majorité via SSH.

Étape 1 : CONNEXION DE LA CAMÉRA AU RASPBERRY PI 3

1. Ouvrez le module caméra. Attention : l'électricité statique peut l'endommager. Avant de le sortir de son sac antistatique gris, déchargez-vous en touchant un objet mis à la terre (radiateur, châssis PC).
2. Insérez le câble dans le connecteur entre les ports Ethernet et HDMI, contacts argentés face au port HDMI.
3. Démarrez votre Raspberry Pi.
4. Exécutez sudo raspi-config. Si l'option « camera » n'apparaît pas, mettez à jour : sudo apt-get update && sudo apt-get upgrade
5. Relancez sudo raspi-config — l'option « camera » devrait apparaître (dans Interfacing Options). Activez-la, sélectionnez « Finish » et redémarrez : sudo reboot

Étape 2 : INSTALLATION D'OPENCV

Si c'est votre première installation d'OpenCV ou vos débuts avec Raspbian Stretch, ce tutoriel est parfait.

Étape #1 : Étendre le système de fichiers

Nouvelle installation de Raspbian Stretch ? Étendez d'abord votre système de fichiers pour utiliser tout l'espace de la micro-SD :

$ sudo raspi-config

Sélectionnez « Advanced Options » puis « Expand Filesystem ». Choisissez « A1. Expand File System », Entrée, flèche vers le bas sur « OK », redémarrez. Si vous utilisez une carte 8 Go, vous utilisez peut-être ~50% de l'espace. Supprimez LibreOffice et Wolfram Engine pour libérer de l'espace :

$ sudo apt-get purge wolfram-engine
$ sudo apt-get purge libreoffice*
$ sudo apt-get clean
$ sudo apt-get autoremove

Après suppression, vous récupérez presque 1 Go !

Étape #2 : Installer les dépendances

$ sudo apt-get update && sudo apt-get upgrade
$ sudo apt-get install build-essential cmake pkg-config
$ sudo apt-get install libjpeg-dev libtiff5-dev libjasper-dev libpng12-dev
$ sudo apt-get install libavcodec-dev libavformat-dev libswscale-dev libv4l-dev
$ sudo apt-get install libxvidcore-dev libx264-dev
$ sudo apt-get install libgtk2.0-dev libgtk-3-dev
$ sudo apt-get install libatlas-base-dev gfortran
$ sudo apt-get install python2.7-dev python3-dev

Étape #3 : Télécharger le code source OpenCV

$ cd ~
$ wget -O opencv.zip https://github.com/Itseez/opencv/archive/3.3.0.zip
$ unzip opencv.zip
$ wget -O opencv_contrib.zip https://github.com/Itseez/opencv_contrib/archive/3.3.0.zip
$ unzip opencv_contrib.zip

Note : Assurez-vous que les versions opencv et opencv_contrib correspondent (ici 3.3.0).

Étape #4 : Python 2.7 ou Python 3 ? Installer pip

$ wget https://bootstrap.pypa.io/get-pip.py
$ sudo python get-pip.py
$ sudo python3 get-pip.py

Installez virtualenv et virtualenvwrapper (recommandé) :

$ sudo pip install virtualenv virtualenvwrapper
$ sudo rm -rf ~/.cache/pip

Mettez à jour ~/.profile :

$ nano ~/.profile
# Ajoutez à la fin :
# virtualenv and virtualenvwrapper
WORKON_HOME=$HOME/.virtualenvs
source /usr/local/bin/virtualenvwrapper.sh

Rechargez le profil : $ source ~/.profile

Créez l'environnement virtuel Python :

$ mkvirtualenv cv -p python2
# Ou pour Python 3 :
$ mkvirtualenv cv -p python3

Pour vérifier si vous êtes dans l'environnement « cv » : après redémarrage ou nouveau terminal, faites $ source ~/.profile && workon cv. Si vous voyez (cv) avant votre prompt, vous y êtes.

Étape #4 : Installer NumPy sur le Raspberry Pi

$ pip install numpy

Étape #5 : Compiler et installer OpenCV

$ workon cv
$ cd ~/opencv-3.3.0/
$ mkdir build
$ cd build
$ cmake -D CMAKE_BUILD_TYPE=RELEASE \
  -D CMAKE_INSTALL_PREFIX=/usr/local \
  -D INSTALL_PYTHON_EXAMPLES=ON \
  -D OPENCV_EXTRA_MODULES_PATH=~/opencv_contrib-3.3.0/modules \
  -D BUILD_EXAMPLES=ON ..

Vérifiez la sortie de CMake ! Descendez à la section Python 2 et Python 3. Assurez-vous que les chemins pointent vers l'interpréteur, les librairies, numpy et packages de l'environnement cv.

Configurer la taille du swap avant compilation

Augmentez la taille du swap pour compiler sur les 4 cœurs sans problèmes de mémoire :

$ nano /etc/dphys-swapfile
# Modifiez CONF_SWAPSIZE :
# CONF_SWAPSIZE=100
CONF_SWAPSIZE=1024

Redémarrez le service swap :

$ sudo /etc/init.d/dphys-swapfile stop
$ sudo /etc/init.d/dphys-swapfile start

Note : Remettez à 100Mo après compilation pour ne pas user la carte microSD (mémoire flash a écritures limitées).

Compilez OpenCV :

$ make -j4

Si erreur, recommencez avec un seul cœur : $ make clean && make

Une fois compilé, installez :

$ sudo make install
$ sudo ldconfig

Étape #6 : Finaliser l'installation OpenCV sur le Pi

Pour Python 2.7 : vérifiez /usr/local/lib/python2.7/site-packages/ pour cv2.so. Puis créez le lien symbolique :

$ cd ~/.virtualenvs/cv/lib/python2.7/site-packages/
$ ln -s /usr/local/lib/python2.7/site-packages/cv2.so cv2.so

Pour Python 3 : le fichier .so a un nom complexe. Renommez-le :

$ cd /usr/local/lib/python3.5/site-packages/
$ sudo mv cv2.cpython-35m-arm-linux-gnueabihf.so cv2.so
$ cd ~/.virtualenvs/cv/lib/python3.5/site-packages/
$ ln -s /usr/local/lib/python3.5/site-packages/cv2.so cv2.so

Étape #7 : Tester votre installation OpenCV 3

$ source ~/.profile
$ workon cv
$ python
>>> import cv2
>>> cv2.__version__
'3.3.0'

OpenCV 3 installé avec succès ! Supprimez les dossiers sources pour libérer de l'espace : $ rm -rf opencv-3.3.0 opencv_contrib-3.3.0 (attention : assurez-vous que l'installation est bonne avant).

Remettez le swap à 100Mo :

$ nano /etc/dphys-swapfile
CONF_SWAPSIZE=100
# CONF_SWAPSIZE=1024
$ sudo /etc/init.d/dphys-swapfile stop
$ sudo /etc/init.d/dphys-swapfile start

ÉTAPE 4 : Configuration du programme Python

Vérifiez que la caméra fonctionne : $ raspistill -o image.jpg (sauvegarde une image dans le répertoire courant).

Téléchargez tous les fichiers Python et modèles depuis : Lien Google Drive

Assurez-vous d'être dans l'environnement virtuel :

$ source ~/.profile
$ workon cv
$ cd Smart-Security-Camera
$ pip install -r requirements.txt

Modifiez mail.py pour vos identifiants email (Gmail SMTP) :

fromEmail = 'monemail@gmail.com'
fromEmailPassword = 'motdepasse1234'
toEmail = 'autreemail@gmail.com'

Modifiez main.py si besoin :

email_update_interval = 600 // email une fois par intervalle
video_camera = VideoCamera(flip=True)
object_classifier = cv2.CascadeClassifier("models/fullbody_recognition_model.xml")
// Autres modèles : facial_recognition_model.xml, upperbody_recognition_model.xml

Lancez : python main.py

Visualisez le flux en direct en visitant l'IP de votre Pi dans un navigateur sur le même réseau. Trouvez l'IP avec ifconfig (adresse inet). Visitez :5000 dans le navigateur.

Note : Pour voir le flux sur un autre réseau, utilisez ngrok : ./ngrok http 5000 et visitez un des liens générés. Le flux ne démarre pas automatiquement au boot. Pour le démarrage auto, ajoutez le programme dans /etc/rc.local.

Réception des emails : la première fois, Google peut bloquer. Cliquez sur « autoriser les applications moins sécurisées » et activez. La détection suivante enverra un email.

ÉTAPE 4 : Configuration de l'interface Blynk

C'est l'une des étapes les plus faciles et amusantes. C'est parti !

1. Téléchargez l'app Blynk (App Store / Google Play). Inscrivez-vous ou connectez-vous.
2. Cliquez sur Nouveau Projet. Nommez-le. Dans Device choisissez NodeMCU. Connection Type : WiFi. Créez.
3. Vous recevez une Auth Key par email. Copiez-la et ajoutez-la à votre code.
4. Cliquez sur + pour ajouter des widgets (nécessite de l'énergie).
5. Ajoutez 3 Jauges (Gauge). Première : Température. Couleur au choix. Pin : Virtual Pin V6. Plage 0-50°C, label °C/°F, lecture Push.
6. Répétez pour les 2 autres jauges avec les données des images.
7. Ajoutez un zeRGBa : R sur broche numérique GP15, G sur GP3, B sur GP1.
8. Ajoutez 4 Boutons, changez leurs couleurs. Configurez comme sur les images.
9. Ajoutez un SuperChart, 3 flux de données : Température, Humidité, Gaz. Couleurs, pins, plage, suffixe.
10. Ajoutez des onglets. Second onglet : Twitter, Notifications, Email, Eventor. Twitter : identifiants. Notifications : activez « Notify when hardware goes off ». Email : votre adresse. Eventor : configurez des déclencheurs (voir images).
11. C'est fini. Cliquez sur Play pour utiliser votre interface. Modifiez-la comme vous voulez. C'est simple et amusant !

ÉTAPE 5 : Fabrication de la structure Octopod

Attention - Ce sera l'un des processus les plus longs !

NOTE : Vous pouvez sauter cette étape et imprimer en 3D le boîtier que j'ai fourni !

Cette étape est optionnelle mais la plus importante ! Vous pouvez prendre une boîte à chaussures et éviter tout ce travail. Mais ce travail rend le projet unique. L'idée de ce design unique m'est venue pendant mes devoirs de maths. Cette forme s'inspire d'un octogone. C'est un octogone 3D ! C'est parti !

Fabrication de la structure :

• Prenez votre carton et dessinez un rectangle de 9 cm x 9,5 cm (dimensions modifiables). En les joignant bout à bout, dessinez 4 rectangles similaires (8 si votre carton est assez long).
• Faites des coupes partielles (comme des plis) entre ces rectangles et découpez toute cette longue pièce. Répétez jusqu'à avoir 4 pièces longues.
• Avec un rapporteur, tracez un angle de 135° et découpez-le comme sur les images. Faites 16 de ces angles identiques.
• Collez ces angles entre les petites pièces au pistolet à colle. Répétez pour toutes les jonctions.
• Collez 2 de ces structures ouvertes pour former une structure fermée (sorte d'octogone).
• Collez les 2 autres structures ouvertes perpendiculairement, formant une forme 3D.
• Découpez 4 pièces de 9 x 9,5 cm et collez-les dans tous les espaces vides.
• Il reste 8 triangles ouverts. Découpez 8 triangles en papier calque acrylique qui s'adaptent, mais ne les collez pas encore.

Peinture :

Allez dans un espace aéré ! Masque et gants obligatoires. Appliquez une couche sur la structure. Consultez YouTube pour les techniques de peinture parfaites. Laissez sécher 4-5 heures, puis 2ème couche. 3 couches semblent bonnes.

C'est fini ! Vous avez une pièce unique.

ÉTAPE 6 : Fabrication du boîtier de verrou de porte

Très simple. Prenez une boîte à chaussures et appliquez 2-3 couches régulières de peinture en bombe. Pour le design, faites un motif damier avec du ruban adhésif comme nous l'avons fait !

ÉTAPE 7 : Assemblage de l'Octopod

J'ai essayé de rendre cette étape simple avec le schéma. Référez-vous à l'image ou au fichier, et câblez en conséquence. Explications brèves :

• NodeMCU connecté à une grande plaque d'essai sans soudure. Alimentation plaque d'essai aussi connectée. NodeMCU, tous capteurs, LEDs et autres composants alimentés par l'alimentation.
• Connexions capteurs : DHT11 → D4/GP2, MQ2 → A0/ADC0, Humidité sol → D2/GP4, PIR → D6/GP1, RGB R → D8/GP15, G → Rx/GP3, B → Tx/GP1, Relais Ln1 → D0/GP16, Ln2 → D5/GP14.
• Alimentation : Power Bank ou adaptateur secteur connecté à l'alimentation de la plaque d'essai.
• Prenez le Raspberry Pi avec sa caméra. Faites un petit trou dans une paroi du carton et collez/scotchez la caméra.
• Insérez toute l'électronique par un triangle ouvert et fermez avec les découpes de papier calque. Mieux vaut laisser 1-2 triangles ouverts pour d'éventuelles réparations. Laissez les pointes du capteur d'humidité du sol à l'extérieur.

Tout est fait ! Allumez et placez l'Octopod sur la table de salle à manger ou table des invités et profitez ! Pour voir le flux direct du Raspberry Pi, ouvrez un navigateur et mettez l'IP du Pi. Amusez-vous !

ÉTAPE 8 : Assemblage du verrou de porte

Après avoir téléversé le code sur l'Arduino, faites les connexions comme sur l'image ou le fichier Fritzing. C'est simple. Prenez la boîte à chaussures, faites 2 trous pour les LEDs et laissez le servo dépasser. De nos jours, des serrures mécaniques à servo existent dans le commerce, mais le servo fonctionne bien. C'est une expérience, n'utilisez pas comme vraie serrure ! Collez le module RFID sur une paroi, ainsi que la petite plaque d'essai et l'Arduino. Alimentez avec adaptateur secteur ou Power Bank. Allumez l'Arduino et c'est bon ! Fini !

CONCLUSION

Ce fut un projet vraiment amusant !

Je suis très content du résultat. Je trouve les lumières superbes, et je pense que ça vaut le coup d'en faire ne serait-ce qu'une comme lampe d'appoint. Je ne remercierai jamais assez les créateurs des bibliothèques Blynk et OpenCV, ce sont d'excellents logiciels qui ont rendu ce projet possible ! Comme toujours, si vous avez des questions sur n'importe quelle partie, dites-le-moi et j'essaierai d'aider. Merci beaucoup ! Et votez pour nous !

-Saksham

Blog Arduino
Tutoriel complet Instructable

MISE À JOUR

Je travaille sur l'intégration avec Amazon Alexa, presque fini. Je publierai le code dans 2-3 jours !

Code

• octopod.ino
• octopod_door.ino
• octopod_door_bluetooth.ino

octopod.ino Arduino

Code principal pour Arduino MKR 1010 (NodeMCU dans mon cas).
Si vous utilisez MAX32620FTHR, téléchargez ses bibliothèques. Changez la carte dans les paramètres. Changez les broches comme indiqué :
ESP → MAX
A0 → GPIO2
A1 → GPIO1
Capteur sol (analogique) → GPIO3
Capteur gaz (MQ2) → GPIO4
Capteur PIR → GPIO0
Relais 1 → M0, Relais 2 → M1

/***************************************************************************
 OCTOPOD: PROJET DOMOTIQUE INTELLIGENT PAR SAKSHAM
 Bibliothèque Blynk latest : https://github.com/blynkkk/blynk-library/releases/latest
 Bibliothèque DHT latest : https://github.com/adafruit/DHT-sensor-library
***************************************************************************/
#include <ESP8266WiFi.h>
#include <BlynkSimpleEsp8266.h>
#include <DHT.h>
#define BLYNK_PRINT Serial

char auth[] = "Votre Clé Auth Blynk";
char ssid[] = "Votre SSID WiFi";
char pass[] = "Votre Mot de passe WiFi";

#define DHTPIN 2
#define soilPin 4
#define gasPin A0
#define pirPin 12

int pirValue;
int soilValue;
int PIRpinValue;
int SOILpinValue;

#define DHTTYPE DHT11
//#define DHTTYPE DHT22
//#define DHTTYPE DHT21
DHT dht(DHTPIN, DHTTYPE);
BlynkTimer timer;

BLYNK_WRITE(V0) { PIRpinValue = param.asInt(); }
BLYNK_WRITE(V1) { SOILpinValue = param.asInt(); }

void sendSensor() {
  int h = dht.readHumidity();
  int t = dht.readTemperature();
  if (isnan(h) || isnan(t)) {
    Serial.println("Echec lecture capteur DHT !");
    return;
  }
  Blynk.virtualWrite(V5, h);
  Blynk.virtualWrite(V6, t);
}

void getPirValue(void) {
  pirValue = digitalRead(pirPin);
  if (pirValue) {
    Serial.println("Mouvement détecté");
    Blynk.notify("Mouvement détecté");
  }
}

void getSoilValue(void) {
  soilValue = digitalRead(soilPin);
  if (soilValue == HIGH) {
    Serial.println("Arroser les plantes");
    Blynk.notify("Arroser les plantes");
  }
}

void setup() {
  Serial.begin(9600);
  Blynk.begin(auth, ssid, pass);
  dht.begin();
  Blynk.tweet("OCTOPOD EST EN LIGNE ! ");
  pinMode(pirPin, INPUT);
  pinMode(soilPin, INPUT);
  timer.setInterval(1000L, sendSensor);
}

void loop() {
  Blynk.run();
  timer.run();
  if (PIRpinValue == HIGH) { getPirValue(); }
  if (SOILpinValue == HIGH) { getSoilValue(); }
}

octopod_door.ino Arduino

Code pour contrôle verrou de porte automatique (SANS BLUETOOTH)

/***********************************************************************************************************
 OCTOPOD: PROJET DOMOTIQUE INTELLIGENT PAR SAKSHAM
 CODE VERROU RFID ARDUINO
 Bibliothèque requise - MFRC522
************************************************************************************************************/
#include <SPI.h>
#include <MFRC522.h>
#include <Servo.h>

#define SS_PIN 10
#define RST_PIN 9
#define LED_G 5
#define LED_R 4
#define BUZZER 2

MFRC522 mfrc522(SS_PIN, RST_PIN);
Servo myServo;

void setup() {
  Serial.begin(9600);
  SPI.begin();
  mfrc522.PCD_Init();
  myServo.attach(3);
  myServo.write(0);
  pinMode(LED_G, OUTPUT);
  pinMode(LED_R, OUTPUT);
  pinMode(BUZZER, OUTPUT);
  noTone(BUZZER);
  Serial.println("Approchez votre carte du lecteur...");
  Serial.println();
}

void loop() {
  if (!mfrc522.PICC_IsNewCardPresent()) return;
  if (!mfrc522.PICC_ReadCardSerial()) return;

  Serial.print("UID tag :");
  String content = "";
  for (byte i = 0; i < mfrc522.uid.size; i++) {
    Serial.print(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " ");
    Serial.print(mfrc522.uid.uidByte[i], HEX);
    content.concat(String(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " "));
    content.concat(String(mfrc522.uid.uidByte[i], HEX));
  }
  Serial.println();
  Serial.print("Message : ");
  content.toUpperCase();
  
  if (content.substring(1) == "XX XX XX XX") { // Remplacez par l'UID autorisé
    Serial.println("Accès autorisé");
    Serial.println();
    delay(500);
    digitalWrite(LED_G, HIGH);
    tone(BUZZER, 500);
    delay(300);
    noTone(BUZZER);
    myServo.write(180);
    delay(5000);
    myServo.write(0);
    digitalWrite(LED_G, LOW);
  } else {
    Serial.println(" Accès refusé");
    digitalWrite(LED_R, HIGH);
    tone(BUZZER, 300);
    delay(1000);
    digitalWrite(LED_R, LOW);
    noTone(BUZZER);
  }
}

octopod_door_bluetooth.ino Arduino

Code pour contrôle verrou de porte automatique (AVEC BLUETOOTH)

/***********************************************************************************************************
 OCTOPOD: PROJET DOMOTIQUE INTELLIGENT PAR SAKSHAM
 CODE VERROU RFID ARDUINO (VERSION BLUETOOTH)
 Bibliothèque requise - MFRC522
************************************************************************************************************/
#include <SoftwareSerial.h>
SoftwareSerial BTserial(0, 1); // RX | TX
#include <SPI.h>
#include <MFRC522.h>
#include <Servo.h>

#define SS_PIN 10
#define RST_PIN 9
#define LED_G 5
#define LED_R 4
#define BUZZER 2

MFRC522 mfrc522(SS_PIN, RST_PIN);
Servo myServo;

void setup() {
  BTserial.begin(9600);
  BTserial.println("En attente de connexions...");
  SPI.begin();
  mfrc522.PCD_Init();
  myServo.attach(3);
  myServo.write(0);
  pinMode(LED_G, OUTPUT);
  pinMode(LED_R, OUTPUT);
  pinMode(BUZZER, OUTPUT);
  noTone(BUZZER);
  BTserial.println("Approchez votre carte du lecteur...");
  BTserial.println();
}

void loop() {
  if (!mfrc522.PICC_IsNewCardPresent()) return;
  if (!mfrc522.PICC_ReadCardSerial()) return;

  BTserial.print("UID tag :");
  String content = "";
  for (byte i = 0; i < mfrc522.uid.size; i++) {
    BTserial.print(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " ");
    BTserial.print(mfrc522.uid.uidByte[i], HEX);
    content.concat(String(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " "));
    content.concat(String(mfrc522.uid.uidByte[i], HEX));
  }
  BTserial.println();
  BTserial.print("Message : ");
  content.toUpperCase();
  
  if (content.substring(1) == "33 3E A7 E5" || content.substring(1) == "E5 36 6B 49") {
    BTserial.println("Accès autorisé");
    BTserial.println();
    delay(500);
    digitalWrite(LED_G, HIGH);
    tone(BUZZER, 500);
    delay(300);
    noTone(BUZZER);
    myServo.write(180);
    delay(5000);
    myServo.write(0);
    digitalWrite(LED_G, LOW);
  } else {
    BTserial.println(" Accès refusé");
    digitalWrite(LED_R, HIGH);
    tone(BUZZER, 300);
    delay(1000);
    digitalWrite(LED_R, LOW);
    noTone(BUZZER);
  }
}

Pièces personnalisées et boîtiers

Design de base pour boîtier en carton/bois :
octopod_v2_ukTmIJ0uMl.f3d

Boîtier complet pour impression 3D :
octo_2_v3_sii4tuCF7d.f3d

Schémas

La configuration des broches peut différer avec Arduino MKR 1010

Sans Bluetooth
Pour Bluetooth : Rx (HC-05) → Tx (Arduino), Tx (HC-05) → Rx (Arduino), 5V vers 5V, GND vers GND

Correspondance broches ESP → MAX :
A0 → GPIO2, A1 → GPIO1
Capteur sol (analogique) → GPIO3
Capteur gaz (MQ2) → GPIO4
Capteur PIR → GPIO0
Relais 1 → M0, Relais 2 → M1