Apple HomeKit avec ESP32 - Partie 1

Bonjour et bienvenue à mon premier blog post à AZ-Delivery !

Le blog d'aujourd'hui, première partie d'une nouvelle série de blogs, porte sur la domotique avec Apple HomeKit. HomeKit est un framework smarthome pour les appareils iOS qui permet aux utilisateurs d'accéder à tous les appareils smarthome de leur maison dans une seule application. HomeKit couvre l'ensemble du processus de développement. Un principe important est que les appareils smarthome correspondants, tels que les ampoules, les thermostats ou les caméras, peuvent communiquer directement par Bluetooth ou WLAN avec l'appareil Apple à contrôler.

HomeKit comprend deux cadres de travail à cette fin. Le HomeKit Framework pour le développement de propres applications HomeKit sur iOS et le HomeKit Accessory Protocol pour le développement d'accessoires smarthome correspondants (voir la figure suivante).

Le protocole d'accessoires HomeKit, HAP en abrégé, a été publié sous la forme d'un projet open source. Le protocole d'accessoires HomeKit est mis en œuvre sur un ESP32, un microcontrôleur petit et peu coûteux d'Espressif. La bibliothèque utilisée pour implémenter la norme HAP est la bibliothèque HomeSpan spécialement développée pour l'ESP32 et l'IDE Arduino. Il est ainsi possible de mettre en œuvre divers accessoires HomeKit avec seulement quelques composants peu coûteux et un effort raisonnable.

Dans ce qui suit, je vais d'abord vous présenter quelques bases du protocole d'accessoires HomeKit, puis je vous présenterai la mise en œuvre d'une LED à gradation compatible HomeKit.

Protocole pour les accessoires HomeKit

Comme déjà annoncé, je vais me concentrer sur le protocole d'accessoires HomeKit dans ce blog, car le cadre HomeKit est utilisé pour le développement d'applications pour faire fonctionner ses propres appareils smarthome. Dans ce qui suit, je vais expliquer quelques bases théoriques sur le HAP, des informations plus concrètes sur un accessoire HomeKit et l'aspect de la sécurité dans HomeKit suivront dans la deuxième partie de cette série de blogs.

Le protocole des accessoires HomeKit définit les exigences relatives au dispositif à développer et à la connexion au cadre HomeKit. Le kit de développement d'accessoires HomeKit est pris en compte ici, qui prend en charge des tâches telles que le chiffrement pour le développeur afin qu'il puisse se concentrer sur la logique de l'application.

Le HAP commence par la définition du niveau de transport réseau requis, qui comprend le Bluetooth Low Energy et les protocoles basés sur IP, notamment le WLAN. Pour les accessoires basés sur l'IP, ce qui concerne également la LED à gradation développée dans le cadre de ce blog, plusieurs exigences s'appliquent. Les plus importantes sont la prise en charge simultanée des connexions IPv4 et IPv6, la mise en œuvre de Bonjour, notamment en ce qui concerne les services DNS Multicast, et l'autorisation de huit connexions TCP simultanées à un serveur d'accessoires HAP. En outre, les serveurs HAP doivent être en mesure de générer et de sérialiser la notation d'objet JavaScript, JSON en abrégé, dans le cadre de la RFC 7159 et d'encoder et de décoder JSON au format UTF-8. En outre, le PAH définit diverses exigences de sécurité, que j'aborderai plus en détail dans le prochain blog. En outre, le PAH traite des différents rôles. Le client HAP, qui est généralement un iPhone ou un iPad, est toujours le contrôleur, qui envoie des demandes au serveur d'accessoires HAP, c'est-à-dire à l'appareil de la maison intelligente, et reçoit le retour d'information correspondant. En outre, le client doit enregistrer et traiter les messages du serveur HAP, par exemple enregistrer et traiter la mise à jour d'une valeur de couleur. De plus, le serveur HAP doit être compatible avec le protocole HTTP, conformément aux RFC 7230 et RFC 7231, et être capable de répondre aux demandes HTTP par des réponses HTTP appropriées et des codes d'état HTTP correspondants.

Le point majeur suivant dans la norme HAP est le modèle de données. Cela définit la manière dont les accessoires eux-mêmes, qui sont également appelés profils et décrivent généralement le dispositif, doivent être structurés. À cette fin, les accessoires sont constitués d'objets et de caractéristiques de service, dont je parlerai également plus en détail dans la prochaine partie de cette série de blogs. Cela a également une incidence sur les exigences relatives au processus de configuration, qui seront abordées plus en détail dans le prochain article du blog.

Les autres exigences importantes pour les dispositifs du protocole d'accessoires HomeKit sont, dans le cas d'un dispositif WLAN, la nécessité d'être sur le même réseau que le client HomeKit, dans le cas d'une communication possible à la fois via WLAN et BluetoothLE, de fournir les mêmes informations sur les deux voies de communication et de ne pas permettre la mise à niveau du micrologiciel.

Structure du matériel

Composants et brochage

Pour la mise en œuvre, vous avez besoin :

Voici la disposition des broches de l'ESP32 donnée ci-dessus :

Vous trouverez ci-dessous la disposition des broches du module SMD ci-dessus :

- Sol
+ Vert
+ Rouge
+ Bleu

Câblage

Les broches suivantes doivent être connectées les unes aux autres pour la construction du circuit :

1. La broche GND du module LED RVB doit être connectée à n'importe quelle broche GND du microcontrôleur.

2. La broche R du module LED RVB doit être connectée à une broche GPIO du microcontrôleur.

3. La broche G du module LED RVB doit être connectée à une broche GPIO du microcontrôleur.

4. La broche B du module LED RVB doit être connectée à une broche GPIO du microcontrôleur.

Alternative de câblage

Pour une LED qui n'est pas déjà soudée à un PCB avec une résistance en série, il faut veiller à ce que le câblage soit correct. Pour cela, l'anode, qui doit être le fil le plus long, doit être connectée à la broche GPIO souhaitée et la cathode à la masse. Notez la nécessité d'une résistance en série appropriée. Elle doit généralement être calculée en fonction de la LED utilisée. En guise d'alternative, des résistances en série de l'ordre de 150 Ohm à 220 Ohm sont généralement adaptées aux LED. Il faut toutefois garder à l'esprit qu'une résistance en série trop faible peut conduire à un courant trop élevé et donc à la destruction de la LED.

Structure du logiciel

La bibliothèque utilisée dans ce projet est la bibliothèque déjà nommée "HomeSpan" pour l'intégration du protocole des accessoires HomeKit. En outre, une intégration PWM est nécessaire pour faire varier la luminosité des LED. Vous pouvez l'implémenter vous-même de manière arbitraire ou utiliser la fonctionnalité utilisée dans HomeSpan pour contrôler les LED via PWM. Dans cet exemple, je présenterai ce dernier afin de rendre l'implémentation aussi claire et simple que possible. La bibliothèque HomeSpan peut être installée via le gestionnaire de bibliothèque dans l'IDE Arduino.

La bibliothèque HomeSpan reprend l'implémentation du protocole d'accessoires HomeKit dans la variante open source R2. Le modèle de données HomeKit présente ici un intérêt particulier, c'est-à-dire tous les accessoires fournis par Apple, y compris leurs services et caractéristiques. Seuls les dispositifs de son et de vidéo ne peuvent être créés en raison de leurs exigences matérielles accrues. HomeSpan permet une programmation complète des accessoires HomeKit dans l'IDE Arduino et offre également une interface en ligne de commande avec un niveau élevé d'informations de débogage et de messages d'erreur.

Pour une bonne structuration, le programme est divisé en trois parties. La première partie "dimmable_LED" correspond à la fonction principale et s'occupe de la définition des accessoires HomeKit et crée des objets qui représentent le serveur HAP des appareils définis. La deuxième partie du programme "DEV_Identify.h" est une fonction permettant une création plus claire et plus rapide des accessoires HomeKit. On transmet à cette fonction les données du "Service d'information sur les accessoires" sous forme de chaîne de caractères, de sorte que la fonction crée ensuite un accessoire HomeKit à partir de ces données en appelant les fonctions HAP correspondantes. En outre, le processus d'initialisation visible requis dans le HAP est mis en œuvre par une LED clignotante, qui n'est pas représentée du côté matériel dans ce projet. Cependant, vous pouvez facilement implémenter cette fonction en connectant une LED à la broche de sortie pour les clignotements définis dans la zone "DEV_Identify.h". Dans mon exemple, je l'ai réglé sur GPIO 4. Si le module LED mentionné ci-dessus est utilisé, l'une des trois LED contrôlables individuellement pourrait être utilisée pour la conversion matérielle. Dans la troisième partie du programme, "DEV_Sensors.h", tous les autres services requis ou facultatifs de l'accessoire sont définis et la routine de lecture des données du capteur, ou dans le cas des actionneurs, la routine d'exécution de l'actionneur, est créée.

Dans ce cas précis, une LED à gradation a été intégrée. La LED utilisée est atténuée à l'aide de la fonctionnalité PWM de l'ESP32. La LED est la première à recevoir le service d'information sur les accessoires, qui est nécessaire pour chaque accessoire HomeKit. Ce service contient la version du micrologiciel, une routine d'identification, un fabricant, la désignation du modèle, un nom et le numéro de série comme caractéristiques. Les LEDs et leurs services correspondants ont ensuite été implémentés dans la zone "DEV_LED.h".

Dans le cas d'une LED à gradation, il existe un service de puissance pour décrire si la LED est allumée ou éteinte et un service de niveau qui décrit la luminosité réglée de la LED. Une valeur de départ est définie pour le service de niveau, qui est prise en charge lorsque la LED est allumée sans que la luminosité soit fermement définie. En outre, une plage de travail est définie pour la LED dans laquelle la luminosité peut être réglée par l'utilisateur dans l'app HomeKit correspondante.

Le code source est commenté et disponible sous forme de dépôt GitHub pour le téléchargement et les tests.

Dans ce qui suit, il est à nouveau présenté sous forme de code source :

Dimmable_LED.ino:

 /*********************************************************************************
  * Avec licence
  *  
  * Copyright (C) 2020 Gregg E. Berman
  *  
  * https://github.com/homespan/homespan
  *  
  * La permission est attribuée gratuitement à toute personne obtenant une copie
  * de ce logiciel et des fichiers de documentation associés (le "logiciel"), de traiter
  * Dans le logiciel sans restriction, y compris sans limitation des droits
  * utiliser, copier, modifier, fusionner, publier, distribuer, sublicense et / ou vendre
  * Copies du logiciel et permettre aux personnes à qui le logiciel est
  * Meublé de le faire, sous réserve des conditions suivantes:
  *  
  * L'avis de copyright ci-dessus et cet avis de permission doivent être inclus dans tous les
  * Copies ou portions substantielles du logiciel.
  *  
  * Le logiciel est fourni "tel quel", sans garantie d'aucune sorte, expresse ou
  * Implicite, y compris mais non limitée aux garanties de la marchandise,
  * Fitness pour un but particulier et un non -fringement. En aucun cas le
  * Les auteurs ou les titulaires de droits d'auteur sont responsables de toute réclamation, dommages-intérêts ou autres
  * Responsabilité, que ce soit dans une action de contrat, délit ou autrement, résultant de,
  * Out ou en relation avec le logiciel ou l'utilisation ou d'autres relations dans le
  *  LOGICIEL.
  *  
  ********************************************************************************/
  
 #include "foomespan.h" 
 #include "dev_led.h" 
 #include "dev_identicy.h" 
 ​
 annuler mettre en place() {
   
   En série.commencer(115200);
 ​
   ficherôme.commencer(Catégorie :: Éclairage,"Homespan a conduit");  
                                                         
   // Créer une LED DIMMABLE attachée à la broche 16
   Nouveau Spanacessory();                                                          
     Nouveau Dev_Identify("DIMMABLE LED","AZ-Livraison","123-ABC","LED","0.9",0);
     Nouveau Service :: Happrotocolinformation();
       Nouveau Caractéristique :: Version("1.1.0");
     Nouveau Dev_dimmableled(16);                                                       
      
 } // fin de la configuration ()
 ​
 //////////////////////////////////////
 ​
 annuler boucle(){
   
   ficherôme.sondage();
   
 } // fin de boucle ()

DEV_Identify.h:

 ​
 //////////////////////////////////
 // Services spécifiques à l'appareil //
 //////////////////////////////////
 ​
 structurer Dev_Identify : Service :: accessoryInformation {
 ​
   int nblinks;                    // Nombre de fois pour clignoter LED intégré dans Identifier la routine
   Spancaractéristique *identifier;   // référence à la caractéristique d'identification
   
   Dev_Identify(const carboniser *Nom, const carboniser *manuel, const carboniser *sn, const carboniser *maquette, const carboniser *version, int nblinks) : Service :: accessoryInformation(){
     
     Nouveau Caractéristique :: Nom(Nom);                   // Créez toutes les caractéristiques requises avec les valeurs définies en fonction des arguments ci-dessus
     Nouveau Caractéristique :: Fabricant(manuel);
     Nouveau Caractéristique :: SerialNumber(sn);    
     Nouveau Caractéristique :: Modèle(maquette);
     Nouveau Caractéristique :: FirmwareRevision(version);
     identifier=Nouveau Caractéristique :: Identifier();          // stocke une référence à la caractéristique d'identification d'utilisation ci-dessous
 ​
     cette->nblinks=nblinks;                            // stocke le nombre de fois pour clignoter le voyant
 ​
     punaise(ficherôme.getStatuspin(),SORTIR);          // Assurez-vous que le voyant est défini pour la sortie
   }
 ​
   booléen mettre à jour(){
        
     pour(int je=0;je<nblinks;je++){
       denadewrite(ficherôme.getStatuspin(),MEUGLER);
       retard(250);
       denadewrite(ficherôme.getStatuspin(),HAUTE);
       retard(250);
     }
 ​
     revenir(vrai);                               // retourne vrai
     
   } // mettre à jour
   
 };

DEV_LED.h:

 ​
 ////////////////////////////////////
 // Services à LED spécifiques à l'appareil //
 ////////////////////////////////////
 ​
 // Bibliothèque de diverses fonctions PWM
 #include "extras / pwmpin.h"
 ​
 ////////////////////////////////////
 ​
 // LED DIMMABLE
 structurer Dev_dimmableled : Service :: Lightbulb {       
 ​
   // référence à la broche LED
   LEDPIN *LEDPIN;                                   
   // référence à la caractéristique sur la caractéristique
   Spancaractéristique *Puissance;                        
   // référence à la caractéristique de luminosité
   Spancaractéristique *niveau;                        
 ​
   // Méthode constructeur ()
   Dev_dimmableled(int épingler) : Service :: Lightbulb(){       
 ​
     Puissance=Nouveau Caractéristique :: sur();     
 ​
     // caractéristique de luminosité avec une valeur initiale de 50%
     niveau=Nouveau Caractéristique :: Luminosité(50);       
     // définit la plage de la luminosité à partir d'un min de 5%, à un maximum de 100%, par étapes de 1%
     niveau->se séparer(5,100,1);                       
 ​
     // Configure une LED PWM pour la sortie à la broche spécifiée
     cette->LEDPIN=Nouveau LEDPIN(épingler);                   
 ​
     // Message d'initialisation
     En série.imprimer("Configuration de la LED dimmable: PIN ="); 
     En série.imprimer(LEDPIN->getpin());
     En série.imprimer("\ n");
     
   } // constructeur final
   
   // METHODE DE MISE À JOUR ()
   booléen mettre à jour(){
                                   
     // affiche des informations sur ce qui est mis à jour
     Log1("Mise à jour de la LED DIMMABLE sur PIN =");       
     log1(LEDPIN->getpin());
     Log1(": Courant actuel =");
     Log1(Puissance->Getval()?"Vrai":"Faux");
     Log1(« Courant Luminosité = »);
     Log1(niveau->Getval());
  
     SI(Puissance->mis à jour()){
       Log1("Nouvelle puissance =");
       Log1(Puissance->GetNewval()?"Vrai":"Faux");
     }
 ​
     SI(niveau->mis à jour()){
       Log1("Nouvelle luminosité =");
       Log1(niveau->GetNewval());
     } 
 ​
     Log1("\ n");
 ​
     // Mises à jour Le Réel PWM PIN
     LEDPIN->ensemble(Puissance->GETNEWVAL()*niveau->GetNewval());    
    
     revenir(vrai);
   
   } // mettre à jour
 };
 ​
 ////////////////////////////////////

Configuration

Il s'agit du mode de configuration de notre LED HomeKit, auquel on peut accéder via la console série de l'IDE Arduino. Veuillez noter que le débit en bauds correct doit être réglé.

Le WLAN peut être configuré en tapant un "W" :

Ici, le WLAN est maintenant configuré et le capteur HomeKit s'est connecté au réseau local, dans ce cas le hotspot de mon iPhone. Vous pouvez désormais l'ajouter à votre domicile sur votre appareil iOS avec le code de configuration standard "466-37-726".

Cela ressemble à ceci dans l'application Home, par exemple :

Dans le prochain post de cette série de blogs, j'approfondirai un peu plus les bases théoriques du protocole d'accessoires HomeKit et vous présenterai les sujets susmentionnés sur les accessoires et la sécurité. Je vous présenterai également le concept de pont dans HomeKit. Un capteur de température et d'humidité sera ensuite mis en place.

J'espère que vous aurez beaucoup de plaisir à le réaliser !