Comment construire votre propre maison intelligente en un après-midi
Published: 2024-02-20 15:50:23

L'internet des objets (IdO) s'est considérablement transformé au fil des ans, et les maisons intelligentes sont de plus en plus répandues. Grâce aux dernières avancées, les propriétaires ont désormais accès à une variété de technologies domestiques intelligentes, allant de systèmes de sécurité sophistiqués à des assistants domestiques intelligents.

De nouveaux produits et technologies ont vu le jour, tels que _SmartThings_ et les appareils _compatibles avec Apple HomeKit_, aux côtés des enceintes intelligentes _compatibles avec Spotify_, comme _HomePod_, et des appareils alimentés par _Z-Wave_ et _Zigbee_. Même les routeurs sont désormais dotés d'une prise en charge de la maison intelligente. Malgré ces changements, cet article offre toujours des indications précieuses pour toute personne intéressée par le développement de projets de maison intelligente.

Pour en savoir plus sur la manière dont PubNub supporte des [milliers de clients dans le monde entier](https://www.pubnub.com/customers/), consultez nos ressources [PubNub pour les développeurs](https://www.pubnub.com/developers/). Vous trouverez également plusieurs témoignages de clients qui illustrent l'efficacité de nos offres dans le monde réel. N'hésitez pas à nous contacter à l'adresse [devrel@pubnub.com](mailto:devrel@pubnub.com) si vous avez des suggestions ou des questions concernant le contenu de cet article.

De nos jours, les technologies IoT ont rendu les [maisons intelligentes et la domotique](https://www.pubnub.com/industry/iot-and-connected-devices/) plus courantes. Les propriétaires utilisent désormais des produits avancés tels que la suite d'appareils Ring pour la sécurité domestique. Cette gamme comprend des capteurs de mouvement, des sonnettes vidéo, des serrures intelligentes et des caméras de sécurité de pointe intégrées à des produits domestiques intelligents alimentés par SmartThings et Apple HomeKit.

Les systèmes domestiques intelligents peuvent également aider les propriétaires dans leurs routines quotidiennes. Des produits comme le thermostat Nest peuvent réguler automatiquement les températures, tandis que des écrans intelligents comme le Smart Display de Lenovo peuvent afficher du contenu personnalisé. Philips Hue permet aux propriétaires de contrôler les interrupteurs d'éclairage par le biais d'ampoules intelligentes, tandis que les produits Apple HomePod et Bose compatibles avec Spotify offrent des fonctionnalités de haut-parleur intelligent. La gestion du contrôle vocal est également possible grâce à des assistants personnels tels que Google Home, Amazon Alexa, Amazon Echo ou Siri, qui facilitent le contrôle de divers appareils IoT ainsi que le réglage de minuteries. Malgré la liste exhaustive des appareils domestiques intelligents existants, ce tutoriel vous guide dans le développement de votre propre système domestique intelligent à l'aide de PubNub.

Chez PubNub, nous sommes spécialisés dans la mise à disposition du grand public du domaine de l'IoT. Avec notre [API de données en temps réel](https://www.pubnub.com/learn/glossary/what-is-real-time-data/) et notre [plateforme d'espaces virtuels](https://www.pubnub.com/learn/glossary/virtual-spaces/), vous pouvez compter sur PubNub pour alimenter votre hub de maison intelligente. Voyons comment vous pouvez créer un système de maison intelligente intuitif et efficace avec trois technologies de maison intelligente.

Construisons un système de maison intelligente
----------------------------------------------

Qu'est-ce qui différencie une maison intelligente d'une maison ordinaire ? Deux facteurs essentiels : l'**automatisation** et la **centralité**. Une maison intelligente automatise les tâches de base et peut transmettre des informations dans les deux sens à partir d'un point central, généralement une application domestique. Dans ce tutoriel, nous utiliserons PubNub pour mettre en œuvre ces deux piliers de l'IoT et construire les technologies suivantes :

-   Smart Light - automatisation des lumières
    
-   Détecteur de lumière - centralisation des données
    
-   Détecteur de porte - centralisation des données
    

Exigences
---------

Pour créer ces trois technologies IoT qui constituent un système de maison intelligente, nous avons besoin des matériaux et du matériel suivants :

### Raspberry Pi

Pour programmer nos technologies IdO et leur permettre de communiquer entre vous et votre maison, vous avez besoin d'un [microcontrôleur](https://www.techopedia.com/definition/3641/microcontroller). L'un des microcontrôleurs les plus faciles à utiliser est la dernière version du [Raspberry Pi](https://www.raspberrypi.com/products/), qui, en janvier 2022, est le Raspberry Pi 4. Si vous n'en avez jamais installé, vous trouverez les [instructions](https://www.raspberrypi.org/documentation/setup/) sur le site web du produit.

### Relais

Pour protéger notre Raspberry Pi des hautes tensions qui pourraient l'endommager, nous avons besoin d'un [relais](https://en.wikipedia.org/wiki/Relay). Un relais est essentiellement un interrupteur qui peut gérer des courants et des tensions élevés pour que le Raspberry Pi n'ait pas à le faire.

![](https://www.pubnub.com/cdn/3prze68gbwl1/asset-17suaysk1qa1jfx/798b2af320f8250dbc8ce0de8bd57659/image4-1024x400.png)

### Une lampe

Pour créer une lampe intelligente, vous aurez besoin d'une lampe simple et peu coûteuse.

### Phototransistor

Pour créer un capteur de lumière intelligent, vous aurez besoin d'un [phototransistor](https://www.electronics-notes.com/articles/electronic_components/transistor/what-is-a-phototransistor-tutorial.php). Ce composant fonctionne comme un interrupteur, permettant au courant de circuler uniquement en présence de lumière, ce qui en fait un capteur idéal pour déterminer si les lumières de la maison sont allumées.

![](https://www.pubnub.com/cdn/3prze68gbwl1/asset-17suaysk1qa1jfy/e1a23b21d6c4ebae2e8564dba4fa99ea/image1-1024x768.png)

### Feuille d'étain et fil de fer

Pour créer un capteur de porte, vous devrez utiliser des pastilles de contact en papier d'étain qui laissent passer l'électricité si les pastilles entrent en contact. De cette façon, vous pouvez fixer une pastille à une porte et à son cadre de sorte qu'à chaque fois que la porte est fermée, les pastilles entrent en contact et indiquent au Raspberry Pi que notre porte est fermée. Vous devez créer deux tampons en papier d'aluminium, avec des fils connectés à chacun des tampons. Fixez l'une des pastilles à la porte et l'autre au cadre à l'aide de ruban adhésif.

![](https://www.pubnub.com/cdn/3prze68gbwl1/2E3nPnFTq0dJS77tTCxdGt/a40b63f3c1130fcef370ff8945ee8953/iot-tin-foil-prep.png)

Passons maintenant à l'installation du matériel.

Installation du matériel
------------------------

### Lampe intelligente

Pour fabriquer une lampe intelligente à partir d'une lampe ordinaire, vous devez séparer le câble d'alimentation en deux parties (lorsqu'il est débranché, bien sûr) et dénuder une partie du boîtier pour exposer les fils. Chaque lampe est équipée d'un câble d'alimentation (généralement rouge) et d'un câble de mise à la terre (généralement noir).

![](https://www.pubnub.com/cdn/3prze68gbwl1/3X0oSvQDbmvFgd8N9hFwO8/863deb74f4c162236b1c213266929df9/IoT_Splice_Power_Cable.png)

Prenez maintenant votre relais et reconnectez les fils de terre, connectez une extrémité du câble d'alimentation dans le port NO (Normalement Ouvert) du relais, et l'autre extrémité dans le port NC (Normalement Fermé) du relais.

![](https://www.pubnub.com/cdn/3prze68gbwl1/7k8iovdFS1eXjN4W6JWvNr/259aa20723db1ac47dbe1d3371ed42c3/IoT_Relay_Connections.png)

Maintenant, pour connecter le module lampe-relais au RPi, connectez-les aux broches GPIO du RPi.

![](https://www.pubnub.com/cdn/3prze68gbwl1/asset-17suaysk1qa1jg3/f16339a7dabec603ee165f67f535ece1/image8-1024x601.png)

### Capteurs de lumière

Le circuit du capteur de lumière est beaucoup plus simple à réaliser. Connectez votre phototransistor à l'une des broches GPIO du RPI.

![](https://www.pubnub.com/cdn/3prze68gbwl1/asset-17suaysk1qa1jg4/f0789c8071f37ec279a90dafc868118c/image10-1024x904.png)

### Capteur de porte

Pour le capteur de porte, connectez un pad à une broche GPIO du RPi et l'autre pad à la masse (pour les besoins du diagramme, les pads sont représentés par des LED).

![](https://www.pubnub.com/cdn/3prze68gbwl1/asset-17suaysk1qa1jg5/9a1f1a3135aaf16f027810de40443f68/image2-1024x894.png)

Conception du système
---------------------

Avant de commencer à implémenter le code, assurez-vous d'avoir un [compte PubNub](https://admin.pubnub.com/#/register) gratuit, car vous aurez besoin de vos clés de publication et d'abonnement pour envoyer des informations à travers le réseau PubNub.

### Activer SSH

Le protocole Secure Shell (SSH) permet aux utilisateurs d'accéder à distance à leurs terminaux RPi depuis leurs ordinateurs via le WiFi. S'il est complété par GitHub, les utilisateurs peuvent pousser du code depuis leur ordinateur vers un dépôt distant, SSH dans le terminal Pi, et extraire le code sans fil. Cela permet un processus de développement plus rapide et plus fluide.

Pour activer SSH sur votre RPi, [suivez les instructions simples et rapides.](https://www.raspberrypi.org/documentation/remote-access/ssh/)

### Télécharger les bibliothèques et les dépendances de l'appareil

Pour nos appareils, vous devez faire fonctionner une tension de sortie de 1 ou 0 à partir du RPI pour les mettre en marche. Inversement, les capteurs fournissent au RPi une tension d'entrée de 1 ou 0, selon qu'ils sont humides ou secs. Ces deux fonctions nécessitent l'utilisation des broches GPIO du RPi.

Comme vous allez coder en Python, il sera utile d'installer la [bibliothèque GPIO Zero](https://gpiozero.readthedocs.io/en/stable/), qui vous permettra de faire des appels de fonction simples pour activer ou lire les broches.

_NOTE : Rappelez-vous que ces bibliothèques doivent être installées sur le RPi en vous connectant en SSH à votre appareil et en exécutant les commandes ci-dessous._

```js
sudo apt install python-gpiozero
```

### Créez votre application avec PubNub

Le [code complet de ce projet est situé dans ce dépôt pour référence.](https://github.com/PubNubDevelopers/beginner-smarthome) Créez un script python pour interfacer nos capteurs à l'internet. Ouvrez un nouveau document dans votre éditeur de texte préféré et importez les bibliothèques et autres dépendances pour permettre aux appareils de communiquer sur le réseau PubNub.

```js
#---------------Library Setup----------------#
import pubnub
from pubnub.pnconfiguration import PNConfiguration
from pubnub.pubnub import PubNub
from pubnub.callbacks import SubscribeCallback
from pubnub.enums import PNOperationType, PNStatusCategory
 
from gpiozero import Button, LED
from time import sleep
 
#--------------------------------------------#
 
 
 
 
#----------------PubNub Setup----------------#
pnconfig = PNConfiguration()
pnconfig.subscribe_key = "YOUR SUBSCRIBE KEY"
pnconfig.publish_key = "YOUR PUBLISH KEY"
pnconfig.ssl = False
pubnub = PubNub(pnconfig)
#--------------------------------------------#
```

Vous devez indiquer au Raspberry Pi quels appareils sont connectés à quelles broches :

```js
#------------Sensor Declarations-------------#
#lamp is connected to GPIO4 as an LED
lamp = LED(4)
 
#door sensor is connected to GPIO3 as a Button
door_sensor = Button(3)
#light sensor is connected to GPIO14 as a Button
light = Button(14)
#--------------------------------------------#
```

_NOTE : La lampe est déclarée comme une LED car vous voulez la contrôler comme s'il s'agissait d'une simple LED. Les capteurs sont initialisés comme des boutons car ils émettent un signal actif constant de la même manière qu'un bouton lorsqu'il est maintenu enfoncé ou pressé. C'est la magie de la bibliothèque GPIO Zero qui permet d'interfacer facilement les capteurs et les périphériques._

Vous devez également créer une variable compteur pour savoir combien de fois notre porte a été ouverte :

```js
#door counter
doorCount = 0
```

Pour que notre lampe IoT puisse interagir avec un client, nous devons utiliser la capacité de PubNub de pub/sub bidirectionnel. Cela nécessite l'ajout d'un listener pour gérer les messages entrants et la configuration d'un abonnement pour écouter un canal spécifique.

```js
class MySubscribeCallback(SubscribeCallback):
    def status(self, pubnub, status):
        # The status object returned is always related to subscribe but could contain information about subscribe, heartbeat, or errors
        # use the operationType to switch on different options
        if status.operation == PNOperationType.PNSubscribeOperation or status.operation == PNOperationType.PNUnsubscribeOperation:
            if status.category == PNStatusCategory.PNConnectedCategory:
                # This is expected for a subscribe, this signifies no error or issue exists
            elif status.category == PNStatusCategory.PNReconnectedCategory:
                # This usually occurs if subscribe temporarily fails but reconnects. This indicates there was a temporary error but it has already been resolved
            elif status.category == PNStatusCategory.PNDisconnectedCategory:
                # This is the expected category for an unsubscribe. This means there was no error in unsubscribing from everything
            elif status.category == PNStatusCategory.PNUnexpectedDisconnectCategory:
                # This is usually an issue with the internet connection, this is an error, handle appropriately. A retry will be initiated automatically.
            elif status.category == PNStatusCategory.PNAccessDeniedCategory:
                # This indicates that PAM does not permit this client to subscribe to this channel and channel group configuration. This constitutes a specific error
            else:
                # This is usually an issue with the internet connection, this is an error, handle appropriately. A retry will be initiated automatically.
        elif status.operation == PNOperationType.PNSubscribeOperation:
            # Heartbeat operations can indeed encounter errors, so it is essential to verify if there's an error first. For more detailed information on how to configure heartbeat notifications through the status PNObjectEventListener callback, please refer to [PNConfiguration heartbeat config](https://www.pubnub.com/docs/sdks/javascript/api-reference/pn-configuration)
            if status.is_error():
                # There was an error with the heartbeat operation, handle here
            else:
                # Heartbeat operation was successful
        else:
            # Encountered unknown status type
```

Dans le callback ci-dessus, la `présence` gère les données de présence entrantes, tandis que le `message` gère les commandes de la lampe. Nous allumons la lampe si le client envoie le message "ON". Inversement, si le message est "OFF", nous éteignons la lampe.

```js
def presence(self, pubnub, presence):
    pass  # handle incoming presence data
 
def message(self, pubnub, message):
    #message handler for Lamp commands
    #Turn the lamp on if client receives the message “ON”
    if message.message == 'ON':
        lamp.on()
        #let your subscriber client know that the lamp has been turned on
        pubnub.publish().channel('ch1').message("lamp has been turned on").sync()
        sleep(3)
    #Turn the lamp on if client receives the message “OFF”
    elif message.message == 'OFF':
        lamp.off()
        #let your subscriber client know that the lamp has been turned off
        pubnub.publish().channel('ch1').message("lamp has been turned off").sync()
```

Nous nous assurons ensuite que notre programme ajoute la `fonction MySubscribeCallback()` et qu'il est abonné au canal choisi, en l'occurrence "ch1".

```js
pubnub.add_listener(MySubscribeCallback())
#make sure to subscribe to the channel of your choice. In this case, we chose to create a channel called “ch1” to publish to
pubnub.subscribe().channels('ch1').execute()
```

Prenez note du gestionnaire d'événements pour les messages. Chaque fois que votre programme reçoit un message du client de l'application, vous analysez le message à l'aide de `message.message`. Vous créez ensuite des gestionnaires d'événements à l'aide d'instructions if pour allumer ou éteindre la lampe à l'aide de la commande GPIO `.on()` ou `.off()`.

Enfin, sachez que lorsqu'un message est publié vers le client, l'utilisateur est informé que sa demande a été exécutée avec succès. Dans ce cas, vous indiquez au client si la lampe est allumée ou éteinte.

Cette section est facultative (puisque vous ne l'utilisez pas pour ce programme), mais un rappel de l'éditeur peut être créé pour exécuter une fonction chaque fois qu'un message est publié.

```js
def publish_callback(result, status):
    pass
    # Handle PNPublishResult and PNStatus
```

Le dernier segment du programme vérifie en permanence les entrées des capteurs afin de déterminer si ces derniers détectent quelque chose. Une sorte de "routeur", la boucle principale while vérifie les entrées de manière répétée : \`while True:\`. À l'intérieur de cette boucle while principale, des boucles sub-while peuvent être construites pour interroger les capteurs de manière spécifique. Puisque les capteurs ont été initialisés comme des boutons de la bibliothèque GPIO Zero, la fonction \`.is\_held\` est nécessaire.

Même si nous n'utilisons pas de bouton, les capteurs agissent comme s'ils étaient des boutons puisqu'ils simulent le même "signal de maintien d'un bouton" lorsqu'ils sont actifs (c'est-à-dire qu'ils détectent quelque chose). Plusieurs bouts de code interrogent le capteur de porte et les lumières pour vérifier leur état. Si le capteur est actif, un message est envoyé au client pour lui indiquer si le capteur est activé ou désactivé. Des principes similaires peuvent être appliqués à d'autres produits de la maison intelligente, tels que SmartThings, les appareils Apple HomeKit ou même votre HomePod, ce qui permet d'étendre considérablement les capacités de votre maison intelligente.

### Téléchargement de votre code

Pour télécharger votre code sur votre Raspberry Pi, engagez toujours votre code dans votre dépôt, puis transférez-le sur votre Raspberry Pi. Ouvrez votre terminal, entrez dans votre répertoire de travail et livrez votre code au nuage à l'aide de ces commandes.

```js
git add .
git commit -m "updates"
git push
```

Connectez-vous en SSH à votre Raspberry Pi et naviguez jusqu'au répertoire approprié.

```js
ssh pi@<YOUR IP ADDRESS>
cd <your directory>
```

Ensuite, extrayez le code du nuage et exécutez-le. Pendant que vous attendez, prenez le temps d'écouter votre liste de lecture Spotify préférée ou de programmer vos tâches. L'efficacité multitâche est l'une des beautés d'un monde connecté !

```js
git pull
python <Your program>.py
```

### Construire un client avec PubNub

Ensuite, nous devons construire un script client qui vous permettra d'utiliser un téléphone portable ou un ordinateur pour envoyer et recevoir des données vers et depuis nos capteurs. Pour ce faire, il faut créer un fichier HTML qui utilise des boutons pour publier des commandes vers le Raspberry Pi et des zones de texte pour récupérer des données du Raspberry Pi. Cela peut être réalisé avec un simple script HTML et l'ajout de quelques boutons, de balises ID et du SDK JavaScript PubNub. Ce système est suffisamment souple pour s'intégrer à divers protocoles, y compris Z-Wave et ZigBee, ce qui ouvre de nouvelles perspectives de développement.

```js
<!DOCTYPE html>
<html>
  <body>
    <button type="button" onclick="publish('ON')">Lamp ON</button>
    <button type="button" onclick="publish('OFF')">Lamp OFF</button>
    <p id="lights">Lights are on?</p>
    <script src="https://cdn.pubnub.com/sdk/javascript/pubnub.4.20.2.js"></script>
    <script>
    var pubnub = new PubNub({
      publishKey : 'pub-c-2d8f55f6-daa7-467b-923b-6a1e6570c9fc',
      subscribeKey : 'sub-c-1575c412-2116-11e8-a7d0-2e884fd949d2',
      });
      function publish(a){
        var publishConfig = 
        {
          channel : "ch1",   //Your publishing channel name
          message : a
        };
        pubnub.publish(publishConfig, function(status, response){
          console.log(status, response);
        });
      }
```

Enfin, écoutez le canal sur lequel le Raspberry Pi publie les données de notre capteur de lumière. Nous pouvons instancier un écouteur avec le bloc de code suivant :

```js
    pubnub.addListener({
            message: function(m) {
                // handle message
                var channelName = m.channel; // The channel for which the message belongs
                var channelGroup = m.subscription; // The channel group or wildcard subscription match (if exists)
                var pubTT = m.timetoken; // Publish timetoken
                var msg = m.message; // The Payload
                var publisher = m.publisher; //The Publisher
                document.getElementById("lights").innerHTML = msg;
                console.log(msg);
            },
            presence: function(p) {
                // handle presence
                var action = p.action; // Can be join, leave, state-change or timeout
                var channelName = p.channel; // The channel for which the message belongs
                var occupancy = p.occupancy; // No. of users connected with the channel
                var state = p.state; // User State
                var channelGroup = p.subscription; //  The channel group or wildcard subscription match (if exists)
                var publishTime = p.timestamp; // Publish timetoken
                var timetoken = p.timetoken;  // Current timetoken
                var uuid = p.uuid; // UUIDs of users who are connected with the channel
            },
            status: function(s) {
                var affectedChannelGroups = s.affectedChannelGroups;
                var affectedChannels = s.affectedChannels;
                var category = s.category;
                var operation = s.operation;
            }
        });
        pubnub.subscribe({
            channels: ['ch2'],
            
        });
    </script>
  </body>
</html>
```

Notez que vous vous êtes abonné à ch2. C'est parce que vous voulez un canal dédié pour les données du capteur de lumière afin de ne pas avoir à différencier les données des autres capteurs. Si vous avez oublié de publier sur un canal dédié dans le processus d'application précédent, assurez-vous de revenir en arrière et de le faire.

Une fois que vous avez enregistré votre script, ouvrez le fichier dans un navigateur web et vous devriez obtenir quelque chose comme ceci :

![](https://www.pubnub.com/cdn/3prze68gbwl1/asset-17suaysk1qa1jg6/06a91807b15406afcdf3499f565d6c1d/image7-1024x431.png)

Vous avez maintenant terminé la mise en œuvre de trois appareils domestiques intelligents simples sur un Raspberry Pi ! Testez votre code en vous connectant à votre Raspberry Pi pour exécuter votre code python et interagir avec votre programme client. Vous devriez être en mesure de contrôler votre lampe intelligente à l'aide des deux boutons et de voir des messages textuels si votre porte est ouverte ou si vos lumières sont allumées. Vous avez réussi à créer un système de maison intelligente en utilisant des appareils connectés qui communiquent avec PubNub.

Si vous souhaitez en savoir plus sur la manière d'alimenter vos applications IoT et vos systèmes domestiques intelligents, consultez nos ressources IoT.

-   [Interagir avec une démonstration de tableau de bord IoT en temps réel](https://www.pubnub.com/demos/iot-dashboard/)
    
-   [Comment développer une solution IoT](https://www.pubnub.com/how-to/develop-an-iot-solution/)
    
-   [Construire une solution IoT avec PubNub](https://www.pubnub.com/tutorials/iot-dashboard/)
    
-   [Cinq exigences pour sécuriser les communications IoT](https://www.pubnub.com/resources/whitepaper/5-key-requirements-to-securing-iot-communications/)
    
-   [MQTT](https://www.pubnub.com/guides/mqtt/)
    

Si vous avez d'autres questions ou préoccupations, n'hésitez pas à [contacter](mailto:devrel@pubnub.com) devrel@pubnub.com.