Contrôleur domotique Arduino compatible Alexa : Automatisation intelligente simplifiée

Composants et fournitures

Composant	Quantité
Arduino Yun	1
ControlEverything.com Contrôleur relais 4 canaux pour I2C	1
Capteur température/humidité DHT11 (4 broches)	1
Résistance 10k ohm	2
Buzzer RedBot SparkFun	1
Transistor NPN usage général	1
Convertisseur DC-DC Buck LM2596	1
Amazon Alexa Echo Dot	1
Shield Proto Arduino	1
Webcam USB	1
Boîte de jonction blanche 200mmx155mmx80mm	1

Outils et machines nécessaires

Fer à souder (générique)

Applications et services en ligne

Arduino IDE
Amazon Alexa Skills Kit
Amazon Web Services AWS Lambda
API PubNub Publish/Subscribe

À propos de ce projet

Vue d'ensemble

Lorsqu'Amazon a lancé Alexa et des appareils comme l'Amazon Echo Dot sur le marché, une infinité d'options se sont ouvertes pour créer une excellente maison intelligente contrôlée par commandes vocales en langage naturel.

Ce projet réalise un contrôleur domotique Arduino qui peut connecter de nombreux capteurs et appareils à Internet et vous pouvez les contrôler en utilisant une compétence Amazon Alexa.

Vous pouvez installer et activer ma compétence "Arduino Home Controller" (l'étape facile), ou vous pouvez créer votre propre compétence guidée par ce tutoriel.

Pour l'instant, nous contrôlerons :

Quatre lumières dans la chambre, le garage, la cuisine et le salon.
Capteur de température et d'humidité.
Alarme buzzer.
Webcam pour prendre une photo de sécurité et l'envoyer par email.

Vous pouvez voir le contrôleur domotique Arduino en action dans cette courte vidéo de démonstration. Pour la démo et la vidéo, j'utilise quatre LEDs sur une plaque d'essai simulant des ampoules dans chaque pièce de la maison.

Si vous voulez utiliser des modules distants pour activer vos lumières, vous pouvez consulter mon projet Arduino Home Controller Remote Modules à cette URL.

Diagramme de blocs

Dans l'image du diagramme de blocs, nous pouvons voir les quatre composants principaux de ce projet :

Amazon Echo Dot pour recevoir les commandes vocales et les envoyer à AWS (Amazon Web Service).
AWS avec une compétence Amazon et une fonction Lambda pour interpréter toutes les commandes. Le nom de la compétence est "Arduino Home Controller", vous pourrez l'activer plus tard.
Un courtier MQTT utilisant le cloud PubNub©. Ce courtier recevra les messages de contrôle dans deux canaux, un pour définir les valeurs et un autre pour lire les valeurs des capteurs. Vous n'avez pas besoin de créer un compte PubNub, vous pouvez utiliser mon compte pour des fins de démonstration.
Contrôleur domestique utilisant Arduino Yun. Nous utiliserons Arduino Yun car il a un shield Ethernet intégré et une petite machine Linux où nous exécuterons Python pour gérer certaines actions. Il contrôle les relais pour les lumières, lit le capteur de température et d'humidité, active le buzzer pour l'alarme et manipule une webcam pour prendre une photo de sécurité. Pour les modules distants, voir mon projet complémentaire Arduino Home Controller Remote Modules à cette URL.

Contrôleur domotique Arduino compatible Alexa : Automatisation intelligente simplifiée

Installer tous les logiciels nécessaires

À ce stade, vous pouvez prendre deux options : une pour la démo, utilisez ma compétence Alexa, installez-la et utilisez-la ; ou l'option deux, vous pouvez créer votre propre compétence.

Parcourez l'application Alexa avec cet URL, dans celle-ci sélectionnez la section Skills dans le menu, recherchez Arduino et dans la liste vous verrez la compétence avec le nom "Arduino Home Controller", cliquez sur la carte de la compétence et cliquez sur le bouton "Activer" pour l'installer.

Ou vous devez aller sur l'App Store Amazon Skills en utilisant ce lien et appuyer sur le bouton "Activer".

Vous devez lier votre compte Amazon car nous utiliserons votre adresse email comme ID pour toutes les commandes envoyées à Arduino. Notez que nous n'utiliserons pas cette adresse pour envoyer des emails, seulement comme ID.

La compétence est installée et liée au compte Amazon et connectée à ma fonction Lambda dans le cloud AWS.

1. Créer une compétence

Vous devez vous inscrire et créer un compte développeur gratuit sur le site https://developer.amazon.com/home.html

Une fois connecté, allez dans le menu Alexa et sélectionnez dans Alexa Skills Kit le bouton "Get Started".
Ensuite, cliquez sur le bouton "Add a New Skill" pour créer une nouvelle compétence.
À la section Create a New Alexa Skill, vous devez :
- Sélectionner : Custom Interaction Model
- Langue : English US
- Nom : TestSkill est le nom de la compétence pour la recherche dans le store.
- Nom d'invocation : Test Skill est le nom pour commencer les commandes vocales comme Alexa Ask, Test Skill to turn alarm on
- Tous les champs globaux sur option No
- Cliquez sur "Save"

La nouvelle compétence a été créée et vous voyez un nouveau champ Application Id

amzn1.ask.skill.6e22e052-c32f-433c-8d39-dc94a77a4adb

Il est utilisé pour le lien entre la compétence et la fonction Lambda, nous l'utiliserons plus tard dans la section 2.5 du tutoriel.

1.4 Modèle d'interaction

Ici, on définit comment vous interagissez avec la compétence basée sur la définition des intentions, slots et énoncés.

Au menu Interaction Model, copiez et collez ce schéma JSON dans Intent Schema.

{
  "intents": [
    {
      "slots": [
        { "name": "light", "type": "States" },
        { "name": "which", "type": "HabRooms" }
      ],
      "intent": "LightIntent"
    },
    {
      "slots": [
        { "name": "alarm", "type": "States" }
      ],
      "intent": "AlarmIntent"
    },
    { "intent": "TakePhotoIntent" },
    { "intent": "GetTemperatureIntent" },
    { "intent": "GetHumidityIntent" },
    { "intent": "AboutIntent" },
    { "intent": "AMAZON.HelpIntent" },
    { "intent": "AMAZON.CancelIntent" },
    { "intent": "AMAZON.StopIntent" }
  ]
}

Définissez quelques slots nécessaires comme States et HabRooms dans Custom Slot Types.

Définissez tous les énoncés comme un modèle de conversation dans Sample Utterances, copiez et collez cette liste.


LightIntent Turn {which} light {light}
LightIntent Set {which} light {light}
AlarmIntent Turn alarm {alarm}
TakePhotoIntent Take a Photo
TakePhotoIntent Take Security Photo
GetTemperatureIntent Read Temperature
GetHumidityIntent Read Humidity
AboutIntent Tell me about
AboutIntent About

Avant de continuer avec la section suivante, Configuration, nous devons avoir créé notre fonction Lambda car nous devons lier la compétence et la fonction Lambda.

2. Créer une fonction Lambda

Vous devez vous inscrire et créer un compte sur la console AWS en utilisant l'URL https://aws.amazon.com/console/

Sélectionnez Services dans le menu du haut et Lambda dans la barre de menu de gauche.
Sélectionnez dans la barre de gauche Function et cliquez sur le bouton "Create function".
Définissez ces données :
- Cliquez sur Author from Scratch
- Name: TestSkillLambda
- Runtime: Node.js 6.10
- Role: Create Custom Role
Cela ouvrira une nouvelle fenêtre où vous devrez sélectionner les valeurs suivantes :
- IAM Role: Lambda_Basic_Execution
- PolicyName: "Create New Role Policy" puis éditez la politique et collez ce qui suit :
```
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "logs:CreateLogGroup",
        "logs:CreateLogStream",
        "logs:PutLogEvents"
      ],
      "Resource": "arn:aws:logs:*:*:*"
    },
    {
      "Effect": "Allow",
      "Action": [
        "iot:UpdateThingShadow"
      ],
      "Resource": "*"
    }
  ]
}
```
Pour sauvegarder, appuyez sur le bouton "Add" et revenez à la page Create Function et sélectionnez lambda_basic_execution dans le champ Existing role.
La fonction TestSkillLambda a été créée et vous voyez sa page de conception.
Sélectionnez dans la barre de menu de gauche Alexa Skills Kit et ajoutez-le à la zone délimitée add triggers.
Cliquez sur la boîte Alexa Skills Kit et faites défiler jusqu'à l'option Configure triggers, sélectionnez Enable et dans le champ Skill ID copiez et collez la valeur Application ID sauvegardée plus tard, voir la section 1.3 du tutoriel. À ce moment, nous lions la fonction Lambda avec la compétence en utilisant l'Application ou Skill ID.

Appuyez sur le bouton "Save" et Alexa Skills Kit sont sauvegardés et la fonction Lambda connaît la compétence et elles sont liées.

Faites défiler jusqu'à la section Function code et définissez les champs :
- Code entry type : Upload a .zip file
- Runtime: Node.js 6.10
- Appuyez sur le bouton "Upload" pour téléverser le code de la fonction en utilisant le fichier data.zip.

L'éditeur de code s'ouvrira et vous verrez les dossiers et fichiers téléversés. Sélectionnez le fichier index.js qui contient toute l'implémentation de la fonction Lambda.

Vous devez modifier la ligne 23, copiez et collez le même Application ID utilisé plus tard dans la section 1.3 du tutoriel. Appuyez sur le bouton "Save" et la fonction Lambda a été activée pour recevoir les commandes de la compétence.

var APP_ID = amzn1.ask.skill.6e22e052-c32f-433c-8d39-dc94a77a4adb

En haut de la page, au-dessus du bouton "Save", vous verrez l'ARN (Amazon Resource Name), c'est l'ID de la fonction Lambda que nous utiliserons à la section Configuration de la page Skill.

3. Retour à la définition de la compétence

Sélectionnez la section Configuration, à EndPoint sélectionnez AWS Lambda ARN, copiez et collez la chaîne ARN ci-dessus dans le champ Default. C'est la dernière action pour lier la compétence et la fonction Lambda, la compétence connaît la fonction Lambda et elles sont liées.

Faites défiler jusqu'à la section Account Linking et copiez les deux premiers Redirect URLs, vous en aurez besoin pour configurer le profil de sécurité.

Avant de continuer avec la configuration de la compétence, nous devons définir un profil de sécurité utilisé pour lier la compétence et le compte Amazon dans l'application Alexa.

4. Créer un profil de sécurité

Sur la même console développeur utilisée pour créer une compétence, sélectionnez Apps & Services et Login with Amazon et appuyez sur le bouton "Create a New Security Profile".

La page Security Profile Management vous permet de créer un profil avec toute la sécurité OAuth 2.0 pour lier la compétence avec votre compte Amazon.
Remplissez tous les champs avec ces données :
- Security Profile Name : TestSkillProfile
- Security Profile Description : Profile used by TestSkill
- Consent Privacy Notice URL : https://www.amazon.com/gp/help/customer/display.html?nodeId=201809740 (c'est un exemple, vous devez utiliser le vôtre)
- Cliquez sur le bouton "Save".

Lorsque vous sauvegardez toutes les données ou modifiez le profil de sécurité, deux nouveaux champs affichent des données importantes, Client ID et Client Secret. Vous en aurez besoin pour la configuration finale de la compétence.

Définissez les URLs de la liste blanche, sélectionnez l'onglet Web Settings.
- Allowed Origins : https://layla.amazon.com et https://pitangui.amazon.com
- Allowed Return URLs : ajoutez les deux premières URLs de la section 3.2

5. Finaliser la création de la compétence

Retournez à la définition de la compétence, sélectionnez la section Configuration et faites défiler jusqu'à Account Linking.
- Do you allow users to create an account : Sélectionnez Yes
- Authorization URL : https://www.amazon.com/ap/oa/?redirect_url=UUUUUU Là où il y a "UUUUUU", vous devrez remplacer ceci par l'une des Redirect URL's plus bas dans la page. Le lien finira par ressembler à quelque chose comme https://www.amazon.com/ap/oa/?redirect_url=https://layla.amazon.com/api/skill/link/UUUUUU
- Client Id : copiez et collez Client Id de la section 4.3.
- Scope : profile, voir l'explication à cette URL.

Continuez avec Account Linking :
- Authorization Grant Type : Auth Code Grant
- Access Token URI : https://api.amazon.com/auth/o2/token
- Client Secret : copiez et collez Client Secret de la section 4.3.
- Privacy Policy URL : https://www.amazon.com/gp/help/customer/display.html?nodeId=201809740 (c'est un exemple, vous devez utiliser le vôtre)
- Cliquez sur les boutons "Save" et "Next"

Global Fields est la section utilisée pour documenter la compétence.
- Sélectionnez la catégorie où trouver la compétence dans le store une fois certifiée, "Smart Home"
- Instructions de test
- La compétence sera disponible dans tous les pays.

Dernière section Privacy & Compliance

6. Installer TestSkill sur l'application Alexa

Lorsque vous sauvegardez la compétence, vous pouvez aller sur l'application Alexa à https://alexa.amazon.com/, sélectionnez dans la barre de menu de gauche l'option Skills, cliquez sur le bouton en haut à droite "Your Skills" et le filtre Dev Skills, vous pouvez voir la carte TestSkill. Notez le message "account linking required".

Si vous cliquez sur la carte, la page de description TestSkill affiche toutes les informations sur la compétence, cliquez sur le bouton "Enable".

En raison de la définition "account linking required", vous êtes redirigé vers la page de connexion Amazon pour lier la compétence à votre compte Amazon.

Si les infos de connexion sont validées, vous voyez cette page indiquant que la compétence est liée à votre compte Amazon.

La compétence est terminée, installée et liée à votre compte Amazon et connectée à la fonction Lambda.
Vous pouvez tester en disant Alexa, ask Test Skill et vous verrez le message de bienvenue d'Arduino Home Controller car tous les dialogues sont les mêmes.

Configurer Arduino Yun

Si c'est la première fois que vous utilisez Arduino Yun, vous devez le préparer avant le téléversement du sketch. Je suggère de consulter le guide ou tutoriel de Greg Baugues "Getting started with the Arduino Yun – the Arduino with WiFi". Merci à l'utilisateur Hackster @BenEagen pour avoir trouvé ce guide.

Afin de prendre une photo et de l'envoyer par email, nous devons installer un logiciel supplémentaire. Nous allons également tester la caméra USB pour voir si les pilotes fonctionnent correctement. Veuillez connecter la webcam USB au port USB de l'Arduino Yun.

Pour ce faire, connectez-vous à l'Arduino Yun avec un terminal :

ssh root@yourYunName.local

Le mot de passe par défaut est arduino.

Si la connexion est OK, vous verrez l'invite Linux OpenWRT :

Installer le logiciel de génération d'image

Commencez par une mise à jour du gestionnaire de paquets :

opkg update

Installez les pilotes UVC :

opkg install kmod-video-uvc

Installez le paquet python-openssl :

opkg install python-openssl

Nous avons également besoin de l'utilitaire fswebcam que nous utiliserons pour prendre des photos depuis le terminal :

opkg install fswebcam

Assurez-vous que la carte SD est montée dans l'Arduino Yun, vous pouvez le tester en exécutant cette commande :

mount

Si vous voyez dans la liste des périphériques un comme /dev/sda1 on /mnt/sda1 type vfat, la carte SD est OK.

Pour tester la caméra et prendre une photo, c'est vraiment facile. Tapez simplement :

cd /mnt/sda1
fswebcam test.png

Vous devriez voir des informations affichées, avec quelques erreurs, mais ne vous en faites pas. L'important est de voir ces lignes :

--- Opening /dev/video0... Trying source module v4l2... /dev/video0 opened.

Pour vérifier que la photo a été correctement prise, retirez la carte SD de l'Arduino Yun et lisez-la avec votre ordinateur. Vous devriez voir la photo apparaître à la racine de la carte SD "test.png". Ouvrez-la simplement pour vous assurer qu'elle a été correctement prise et qu'elle n'est pas corrompue.

Installer le logiciel d'envoi d'email

Avec la carte SD dans votre ordinateur, copiez le fichier python AHC_SendEmail.py et modifiez votre email et mot de passe d'un compte Gmail aux lignes 11, 12 et 13. Si vous avez un autre fournisseur d'email, modifiez les informations du serveur à la ligne 36.

Retirez la carte SD de l'ordinateur et insérez-la dans le slot SD de l'Arduino Yun. Au terminal connecté à l'Arduino Yun, exécutez les commandes :

cd /mnt/sda1
python /mnt/sda1/AHC_SendEmail.py /mnt/sda1/ test.png

Si tout est OK, vous devez recevoir un email avec votre photo.

Connecter tous les appareils à l'Arduino Yun

Basé sur le schéma électronique, connectez tous les appareils, en particulier le capteur DHT11 car nous en avons besoin pour lire la température et l'humidité, et le buzzer pour tester le son d'alarme.

Installer le fichier sketch ArduinoHomeMQTT.ino

J'ai créé un fichier libraries.zip avec toutes les bibliothèques nécessaires à ce fichier, vous pouvez le télécharger depuis mon site GitHub et le décompresser dans le répertoire libraries de l'Arduino IDE.

Bibliothèques incluses dans libraries.zip à l'intérieur du dossier ArduinoHomeMQTT :

ArduinoJson → utilisé pour manipuler le contenu JSON
DHT_sensor_library → utilisé pour gérer le capteur DHT
pubsubclient-master → utilisé pour se connecter, publier et s'abonner à PubNub©

Ouvrez Arduino IDE 1.6.x, dans outils sélectionnez "Board: Arduino Yun".

Chargez le fichier ArduinoHomeMQTT.ino et dans l'IDE modifiez la ligne 16 avec votre email Amazon utilisé lors de la liaison du compte dans l'application Alexa Skill activée.

Cette option identifie votre contrôleur lorsque AWS envoie un message MQTT au courtier.

Modifiez la ligne 50 avec votre UUID pour identifier votre contrôleur dans PubNub©, vous pouvez aller sur ce site et copier-coller l'UUID généré en ligne.

Maintenant, sauvegardez et téléversez le sketch et lorsque vous ouvrez la fenêtre du moniteur Arduino IDE, vous pouvez voir l'Arduino Yun connecté au courtier PubNub© et le capteur initialisé.

Tester tous les énoncés depuis Alexa Echo Dot

La compétence Alexa "Arduino Home Controller" gère cette liste d'énoncés, vous pouvez les voir dans l'application Alexa Skill à la section description. Vous pouvez tous les tester et voir dans le moniteur série de l'Arduino ID tous les messages reçus et envoyés au courtier PubNub©.

Contrôle des lumières :


==> "Alexa, ask arduino home to turn room light on"
==> "Alexa, ask arduino home to turn room light off"
==> "Alexa, ask arduino home to turn kitchen light on"
==> "Alexa, ask arduino home to turn kitchen light off"
==> "Alexa, ask arduino home to turn garage light on"
==> "Alexa, ask arduino home to turn garage light off"
==> "Alexa, ask arduino home to turn living room light on"
==> "Alexa, ask arduino home to turn living room light off"

Contrôle de l'alarme :


==> "Alexa, ask arduino home to turn alarm on"
==> "Alexa, ask arduino home to turn alarm off"

Lecture température et humidité :


==> "Alexa, ask arduino home to read temperature"
==> "Alexa, ask arduino home to read humidity"

Prendre une photo de sécurité :


==> "Alexa, ask arduino home to take a photo"

À propos et Aide :


==> "Alexa, ask arduino home about"
==> "Alexa, ask arduino home help"

Détails logiciels

Vous pouvez télécharger tous les fichiers pour ce projet depuis mon site Github.

Explication des dossiers

ArduinoHomeMQTT → fichier ino et bibliothèques pour Arduino Yun Home Controller
lambda → fonction Lambda en Node.js à déployer dans AWS Lambda, inclut tous les node_modules nécessaires, voir option 2 dans la section installer tous les logiciels.
python → fichier python pour envoyer un email avec photo jointe.

Workflow Arduino Home Controller vous montre comment les fichiers interagissent.

Amazon Echo Dot envoie la commande vocale et elle est reçue par la compétence Arduino Home Controller.
La compétence appelle le fichier de fonction Lambda index.js.
Le fichier de fonction Lambda est développé en Node.Js, utilise certains node modules et est hébergé sur Amazon Web Service (AWS).
La fonction Lambda interprète toutes les intentions et les convertit en message JSON MQTT et l'envoie au courtier PubNub©. Ce message a le format :


{
  "topic" : "Topic_xxxx",
  "command" : "on or off",
  "id" : "email address"
}

Le topic Topic_xxxx peut être :


Topic_room -> allumer/éteindre lumière chambre
Topic_livingroom -> allumer/éteindre lumière salon
Topic_kitchen -> allumer/éteindre lumière cuisine
Topic_garage -> allumer/éteindre lumière garage
Topic_alarm -> allumer/éteindre alarme
Topic_temperature -> lire température
Topic_humidity -> lire humidité
Topic_photo -> prendre et envoyer photo par email

La commande peut être on ou off.

Le message est envoyé en utilisant le canal AHC_IOT_01. Le canal AHC_IOT_02 est utilisé pour recevoir les valeurs de température ou d'humidité.
Le sketch Arduino Yun ArduinoHomeMQTT.ino se connecte au courtier et s'abonne ou publie sur les canaux et reçoit ou envoie des messages.
En utilisant un bridge, le sketch Arduino communique avec Linux OpenWRT pour la connexion WAN ou LAN et pour exécuter certaines commandes.
Si Arduino doit envoyer un email, il utilise le fichier python AHC_SendEmail.py, s'il doit prendre une photo, il appelle le programme fswebcam situé dans Linux OpenWRT.

Détails matériels

Le cœur du matériel est l'Arduino Yun.

Il utilise plusieurs broches numériques pour contrôler chaque appareil :


Broche 2 : connectée au capteur DHT11
Broche 8 : active l'alarme buzzer avec l'aide du transistor NPN
Broche 9 : contrôle lumière chambre
Broche 10 : contrôle lumière cuisine
Broche 11 : contrôle lumière garage
Broche 12 : contrôle lumière salon

La webcam est connectée au port USB.

Pour alimenter tous les appareils, le contrôleur utilise 12 volts DC et convertit en 5 volts en utilisant un convertisseur DC-DC.

J'ai fait un shield Arduino en utilisant le Arduino Proto Shield avec tous les connecteurs et l'électronique d'interface pour le capteur, l'alarme buzzer et l'alimentation. Il a de l'espace pour de nouveaux capteurs pour étendre le contrôleur.

Mettez l'Arduino Yun, le shield proto, les relais et le régulateur d'alimentation dans une boîte en plastique avec l'alarme, la webcam et le capteur à l'extérieur, et faites toutes les connexions comme mentionné dans le schéma électronique.

Pour la démo et la vidéo, j'utilise quatre LEDs sur une plaque d'essai simulant des ampoules dans chaque pièce de la maison.

Merci d'avoir lu ce guide, j'apprécie votre temps. Si vous avez des suggestions, n'hésitez pas à me contacter.

Je fais ce projet en mémoire de mon père, il est décédé l'an dernier, repose en paix Papa.

Code

ArduinoHomeMQTT.ino (Arduino)

Logiciel Arduino Yun pour contrôleur domotique


// ArduinoHomeMQTT
// v2.1
// Copyright (C)2018 Jose Cruz. All right reserved
// web: https://sites.google.com/view/raeiot/home
#include 
#include 
#include 
#include 
#include 

// Votre email Amazon lié à la compétence
#define MyID "YOUR AMAZON EMAIL LINKED IN ALEXA APP"
// Broche de données du capteur DHT11
#define DHTPIN 2
// Type de capteur DHT 11
#define DHTTYPE DHT11

// Initialiser le capteur DHT
DHT dht(DHTPIN, DHTTYPE);

// Broche de contrôle de l'alarme
#define alarm 8

// Broches de contrôle des lumières
#define room_light 9
#define kitchen_light 10
#define garage_light 11
#define livingroom_light 12

// Adresse et port du serveur MQTT PubNub
int mqtt_server_port = 1883;
const char* mqtt_server = "mqtt.pndsn.com";

// Topic d'abonnement
const char* topic = "AHC_IOT_01";
// Topic de publication
const char* topic2 = "AHC_IOT_02";

// ID éditeur PubNub
// pub-c-e93def7f-95aa-475a-aa60-cc3cd32ee8a7/
// ID abonné PubNub
// sub-c-ec04dbbc-0893-11e8-8e75-cea83f8405bb/
// UUID généré en ligne https://www.uuidgenerator.net/
// ID client PubNub
// clientId = pubID + subID + uuid;
const char* clientId = "pub-c-e93def7f-95aa-475a-aa60-cc3cd32ee8a7/sub-c-ec04dbbc-0893-11e8-8e75-cea83f8405bb/YOUR UUID GENERATED";

// Définir le client Ethernet Yun
YunClient ethClient;
// Définir le client PubNub pub et sub
PubSubClient client(ethClient);

// Processus pour la photo
Process picture;
// Nom de fichier
String filename;
// Chemin pour le fichier image
String path = "/mnt/sda1/";

// Créer un fichier image et l'envoyer par email
void TakePhoto() {
  // Générer le nom de fichier avec timestamp
  filename = "";
  picture.runShellCommand("date +%s");
  while (picture.running());
  while (picture.available() > 0) {
    char c = picture.read();
    filename += c;
  }
  filename.trim();
  filename += ".jpg";
  // Prendre la photo
  picture.runShellCommand("/usr/bin/fswebcam -i 0 --jpeg 95 --no-banner --fps 1 -S 1 -r 352x288 --save " + path + filename);
  while (picture.running());
  // L'envoyer par email
  picture.runShellCommand("python /mnt/sda1/AHC_SendEmail.py " + path + " " + filename);
  while (picture.running());
}

// Envoyer la température
void SendTemperature() {
  char cstr[16];
  // Lire la température en Celsius (par défaut)
  float t = dht.readTemperature();
  client.publish(topic2, itoa(t, cstr, 10));
}

// Envoyer l'humidité
void SendHumidity() {
  char cstr[16];
  float h = dht.readHumidity();
  client.publish(topic2, itoa(h, cstr, 10));
}

// Fonction de rappel pour la gestion des messages reçus
void callback(char* topic, byte* payload, unsigned int length) {
  Serial.print("Message arrived [");
  Serial.print(topic);
  Serial.print("] ");
  for (int i = 0; i < length; i++) {
    Serial.print((char)payload[i]);
  }
  Serial.println();
  StaticJsonBuffer<200> jsonBuffer;
  JsonObject& root = jsonBuffer.parseObject((char[])payload);
  String alexa_topic = root["topic"];
  String alexa_command = root["command"];
  String alexa_id = root["id"];
  if (alexa_id.equals(MyID)) {
    // Gérer tous les messages reçus topic depuis MQTT
    if (alexa_topic.endsWith("Topic_room")) {
      digitalWrite(room_light, (alexa_command.endsWith("on") ? LOW : HIGH));
    } else if (alexa_topic.endsWith("Topic_kitchen")) {
      digitalWrite(kitchen_light, (alexa_command.endsWith("on") ? LOW : HIGH));
    } else if (alexa_topic.endsWith("Topic_garage")) {
      digitalWrite(garage_light, (alexa_command.endsWith("on") ? LOW : HIGH));
    } else if (alexa_topic.endsWith("Topic_living room")) {
      digitalWrite(livingroom_light, (alexa_command.endsWith("on") ? LOW : HIGH));
    } else if (alexa_topic.endsWith("Topic_temperature")) {
      SendTemperature();
    } else if (alexa_topic.endsWith("Topic_humidity")) {
      SendHumidity();
    } else if (alexa_topic.endsWith("Topic_alarm")) {
      digitalWrite(alarm, (alexa_command.endsWith("on") ? HIGH : LOW));
    } else if (alexa_topic.endsWith("Topic_photo")) {
      TakePhoto();
    }
  }
}

// Se reconnecter au courtier MQTT si connexion perdue
void reconnect() {
  // Boucle jusqu'à reconnexion
  while (!client.connected()) {
    Serial.print("Attempting MQTT connection...");
    // Tentative de connexion
    if (client.connect(clientId)) {
      Serial.println("MQTT broker connected");
      client.subscribe(topic);
    } else {
      Serial.print("Failed, rc = ");
      Serial.print(client.state());
      Serial.println(" try again in 5 seconds");
      // Attendre 5 secondes avant de réessayer
      delay(5000);
    }
  }
}

void setup() {
  Bridge.begin();
  delay(2000);
  Serial.begin(115200);
  Serial.println("Init Arduino Home Controller v2.1...");
  pinMode(alarm, OUTPUT);
  pinMode(room_light, OUTPUT);
  pinMode(kitchen_light, OUTPUT);
  pinMode(garage_light, OUTPUT);
  pinMode(livingroom_light, OUTPUT);
  digitalWrite(room_light, HIGH);
  digitalWrite(kitchen_light, HIGH);
  digitalWrite(garage_light, HIGH);
  digitalWrite(livingroom_light, HIGH);
  // Définir le courtier MQTT PubNub
  client.setServer(mqtt_server, mqtt_server_port);
  client.setCallback(callback);
  client.connect(clientId);
  Serial.println("Connected to PubNub MQTT broker OK ...");
  client.subscribe(topic);
  Serial.println("Suscribe to topic at MQTT broker Ok ...");
  dht.begin();
  // Attendre l'initialisation du capteur
  delay(4000);
  Serial.println("DHT sensor Ok ...");
}

void loop() {
  if (!client.connected()) {
    reconnect();
  }
  client.loop();
}

AHC_SendEmail.py (Python)

Fichier à installer dans Linux OpenWRT de l'Arduino Yun pour aider à envoyer un email avec photo jointe


import smtplib
import sys
import time
from email.MIMEMultipart import MIMEMultipart
from email.MIMEText import MIMEText
from email.MIMEBase import MIMEBase
from email import encoders

fromaddr = "joseacruzp@gmail.com"
toaddr = "joseacruzp@gmail.com"
emailpassword = "YOUR PASSWORD"
subject = "Arduino Home Controller by Alexa Skill"
body = "Photo taken in " + time.strftime('%a, %d %b %Y %H:%M:%S %Z(%z)')
filedir = sys.argv[1]
filename = sys.argv[2]

msg = MIMEMultipart()
msg['From'] = fromaddr
msg['To'] = toaddr
msg['Subject'] = subject
msg.attach(MIMEText(body, 'plain'))

attachment = open(filedir + filename, "rb")
part = MIMEBase('application', 'octet-stream')
part.set_payload((attachment).read())
encoders.encode_base64(part)
part.add_header('Content-Disposition', "attachment; filename= %s" % filename)
msg.attach(part)

server = smtplib.SMTP('smtp.gmail.com', 587)
server.starttls()
server.login(fromaddr, emailpassword)
text = msg.as_string()
server.sendmail(fromaddr, toaddr, text)
server.quit()

index.js (JavaScript)

Fonction AWS Lambda si vous sélectionnez l'option 2, créez votre propre compétence


// Alexa SDK for Arduino Home Controller
// Copyright (c) 2014-2015 Amazon.com, Inc. or its affiliates. All Rights Reserved. Use is subject to license terms.
// Jose Cruz https://sites.google.com/view/jriot

// Définir la connexion à PubNub
var PubNub = require("pubnub");
var pubnub = new PubNub({
  ssl: true,
  publish_key: "pub-c-e93def7f-95aa-475a-aa60-cc3cd32ee8a7",
  subscribe_key: "sub-c-ec04dbbc-0893-11e8-8e75-cea83f8405bb",
  uuid: "YOUR UUID"
});

// Définir le canal PubNub
var channel = 'AHC_IOT_01';
// Utilisé pour recevoir certaines valeurs (température, humidité)
var channel2 = 'AHC_IOT_02';

// Définir les états des slots pour allumer/éteindre lumière et alarme
var slotStates = ['on', 'off'];

// App ID pour la compétence
var APP_ID = 'YOUR APP ID FOR THE SKILL';

// Le prototype AlexaSkill et fonctions d'aide
var AlexaSkill = require('./AlexaSkill');
var ArduinoHomeSkill = function() {
  AlexaSkill.call(this, APP_ID);
};

// Écouteur pour s'abonner et recevoir température et humidité
var mqttListener;
var access_token;
var url;
var https = require("https");

function SendMessage(topicname, commandvalue, speechOutput, iresponse) {
  https.get(url, res => {
    res.setEncoding("utf8");
    let body = "";
    res.on("data", data => {
      body += data;
    });
    res.on("end", () => {
      pubnub.publish({
        // Publie le message de commande à mon dispositif PubHub.
        channel: channel,
        message: {
          "topic": topicname,
          "command": commandvalue,
          "id": JSON.parse(body).email
        }
      }).then((response) => {
        console.log("message Published w/ timetoken", response.timetoken);
        if (speechOutput) iresponse.tell(speechOutput);
      }).catch((error) => {
        console.log("publishing failed w/ status: ", error);
        iresponse.ask("Sorry, I didn't catch what you said");
      });
    });
  });
}

/// Étendre AlexaSkill
ArduinoHomeSkill.prototype = Object.create(AlexaSkill.prototype);
ArduinoHomeSkill.prototype.constructor = ArduinoHomeSkill;

ArduinoHomeSkill.prototype.eventHandlers.onSessionStarted = function(sessionStartedRequest, session) {
  console.log("ArduinoHomeSkill onSessionStarted requestId: " + sessionStartedRequest.requestId + ", sessionId: " + session.sessionId);
  // Supprimer tous les écouteurs et abonnements définis
  pubnub.removeListener(mqttListener);
  pubnub.unsubscribeAll();
};

ArduinoHomeSkill.prototype.eventHandlers.onLaunch = function(launchRequest, session, response) {
  console.log("ArduinoHomeSkill onLaunch requestId: " + launchRequest.requestId + ", sessionId: " + session.sessionId);
  // Si pas de token Amazon, retourner une carte LinkAccount
  if (session.user.accessToken == undefined) {
    response.tellWithCardLink('To start using this skill, please use the companion app to authenticate on Amazon.');
    return;
  }
  var speechOutput = "Welcome to Arduino Home Controller. What would you like to do?";
  var repromptText = "I am ready";
  response.ask(speechOutput, repromptText);
};

ArduinoHomeSkill.prototype.eventHandlers.onSessionEnded = function(sessionEndedRequest, session) {
  console.log("ArduinoHomeSkill onSessionEnded requestId: " + sessionEndedRequest.requestId + ", sessionId: " + session.sessionId);
  console.log("End...");
};

// Définir tous les gestionnaires d'intentions
ArduinoHomeSkill.prototype.intentHandlers = {
  // Gestionnaire AboutIntent
  "AboutIntent": function(intent, session, response) {
    var myText;
    console.log("in about");
    myText = "Arduino Home Controller skill lets you control internet connected devices. It controls Lights at room, kitchen, garage or living room), reads a temperature sensor to scan home temperature, reads humidity sensor to scan home humidity, uses webcam to take a home security photo and send it by email and activates an alarm to alert some events. It uses PubNub site to manipulate all messages sent by Alexa with Lambda function. Please check information at skill page for more details. What would you like to do?";
    response.ask(myText);
    return;
  },
  // Gestionnaire LightIntent
  "LightIntent": function(intent, session, response) {
    var slotHabRooms = ['room', 'kitchen', 'garage', 'living room'];
    var lightSlot = intent.slots.light;
    var lightSlotValue = lightSlot ? lightSlot.value : "";
    var whichSlot = intent.slots.which;
    var whichSlotValue = whichSlot ? whichSlot.value : "";
    if (lightSlotValue && whichSlotValue && slotStates.indexOf(lightSlotValue.toLowerCase()) > -1 && slotHabRooms.indexOf(whichSlotValue.toLowerCase()) > -1) {
      SendMessage('Topic_' + whichSlotValue, lightSlotValue, "The light is now " + lightSlotValue, response);
    } else {
      response.ask("Sorry, I didn't catch what you said");
    }
  },
  // Gestionnaire AlarmIntent
  "AlarmIntent": function(intent, session, response) {
    var alarmSlot = intent.slots.alarm;
    var alarmSlotValue = alarmSlot ? alarmSlot.value : "";
    if (alarmSlotValue && slotStates.indexOf(alarmSlotValue.toLowerCase()) > -1) {
      SendMessage('Topic_alarm', alarmSlotValue, "The alarm is now " + alarmSlotValue, response);
    } else {
      response.ask("Sorry, I didn't catch what you said");
    }
  },
  // Gestionnaire TakePhotoIntent
  "TakePhotoIntent": function(intent, session, response) {
    SendMessage('Topic_photo', 'take', "Taken home photo ", response);
  },
  // Gestionnaire GetTemperatureIntent
  "GetTemperatureIntent": function(intent, session, response) {
    mqttListener = {
      status: function(statusEvent) {},
      message: function(message) {
        console.log("Receive=", message);
        var myText = "Inside Temperature is " + message.message + " degrees C";
        response.tell(myText);
      },
      presence: function(presenceEvent) {}
    };
    pubnub.addListener(mqttListener);
    pubnub.subscribe({ channels: [channel2] });
    SendMessage('Topic_temperature', 'Ok', null, response)
  },
  // Gestionnaire GetHumidityIntent
  "GetHumidityIntent": function(intent, session, response) {
    mqttListener = {
      status: function(statusEvent) {},
      message: function(message) {
        console.log("Receive=", message);
        var myText = "Inside Humidity is " + message.message + " %";
        response.tell(myText);
      },
      presence: function(presenceEvent) {}
    };
    pubnub.addListener(mqttListener);
    pubnub.subscribe({ channels: [channel2] });
    SendMessage('Topic_humidity', 'Ok', null, response)
  },
  // Gestionnaire HelpIntent
  "AMAZON.HelpIntent": function(intent, session, response) {
    response.ask("With Arduino Home Controller skill and Alexa you can control internet connected devices using an Arduino Yun or Arduino with Ethernet Shield. Please check information at skill page for more details. What would you like to do?");
  },
  // Gestionnaire StopIntent
  "AMAZON.StopIntent": function(intent, session, response) {
    response.tell("Thanks for using Arduino Home Controller. Bye see you later");
  },
  // Gestionnaire CancelIntent
  "AMAZON.CancelIntent": function(intent, session, response) {
    response.tell("Thanks for using Arduino Home Controller. Bye see you later");
  },
  default: function(intent, session, response) {
    response.ask("Try again");
  },
};

// Créer le gestionnaire qui répond à la requête Alexa
exports.handler = function(event, context) {
  try {
    access_token = event['context']['System']['user']['accessToken'];
    url = 'https://api.amazon.com/user/profile?access_token=' + access_token;
  } catch (error) {
    console.log(error);
  }
  // Créer une instance de Arduino Home Skill
  var ArduinoHomeControl = new ArduinoHomeSkill();
  ArduinoHomeControl.execute(event, context);
};

GitHub

https://github.com/jcruzp/ArduinoHomeController

Schémas

Carte principale avec relais, capteur température/humidité, alarme buzzer et webcam.

Intégrez votre chauffage central avec Arduino pour un contrôle intelligent Construire une Radio FM Compacte avec Arduino Nano et RDA5807M

Processus de fabrication

impression en 3D

Système de contrôle d'automatisation

Technologie industrielle