Apple HomeKit mit ESP32 - Teil 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).

Homekit cadre

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 :

Quantité Composant  Note
1 ESP-32 Dev Kit C V4 Il est également possible d'utiliser d'autres versions de l'ESP32.
1 Capteur modulaire KY - 009 RGB LED SMD Comme nous ne voulons pas utiliser les LED comme des LED RVB, n'importe quelle LED simple avec une résistance en série appropriée fera l'affaire, bien sûr.
1 Câble Jumper 3 x 40 pcs. chacun 20 cm M2M/ F2M / F2F compatible avec Arduino et Raspberry Pi Breadboard 4 fils de liaison femelle/femelle sont nécessaires. S'il n'est pas disponible, le jeu spécifié est recommandé.

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

ESP32 Brochage

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

RGB SMD

- Sol
+ Vert
+ Rouge
+ Bleu

Câblage

Diagramme de circuit de fritzing

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

schéma de circuit Fritzing en variante

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é.

configuration

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

configuration

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 :

Exemple de l'application

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 !

Esp-32Projets pour les débutantsMaison intelligente

3 commentaires

Leon Ehring

Leon Ehring

Hallo Elias,
nein im Normalfall kannst du das ganz normal zu deinem Heimnetzwerk hinzufügen. Dann kannst du das als normales HomeKit Zubehör nutzen.
Die Verbindung mit dem Hotspot des IPhone ist eher ein minimal Beispiel, womit man externe Fehlerquellen ausschließen kann.

Mit freundlichen Grüßen

Carsten

Carsten

Hallo,
Danke erstmal für den Blog Eintrag, musste ich gleich mal ausprobieren :-)
Leider bekomme ich keine Verbindung zu meiner FritzBox (MAC Adressen Filter ist ausgeschaltet) und ich sehe auch keinen Verbindungsaufbauversuch im Log des Routers.
Im Seriellen Monitor habe ich die Credentials eingegeben und der ESP versucht “etwas”, allerdings kommt nur:
E (187432) wifi:AP has neither DSSS parameter nor HT Information, drop it
E (187495) wifi:AP has neither DSSS parameter nor HT Information, drop it
Trying to connect to XXXX. Waiting 2 second(s) for response…
….. wiederholt sich immer wieder
Hat dazu jemand vielleicht eine Idee?
Besten Dank und Grüße!

Elias

Elias

Hallo Leon,
Danke für den Beitrag! Das Thema kannte ich noch nicht und es ist super über diesen Blog darauf zu stoßen direkt mit einer kleinen Implementierung!

Funktioniert das HomeKit Netz nur in den persönlichen Hotspots der Geräte oder kann man die smarten Geräte auch im WLAN der Wohnung anmelden und dann mit einem Apple Geräte welches im gleichen WLAN ist Steuern?

Grüße
Weiter so!

Laisser un commentaire

Tous les commentaires sont modérés avant d'être publiés

Messages de blogs recommandés

  1. Installez maintenant ESP32 via l'administrateur de la carte
  2. Lüftersteuerung Raspberry Pi
  3. Arduino IDE - Programmieren für Einsteiger - Teil 1
  4. ESP32 - das Multitalent
  5. OTA-Over the Air-ESP Programmation par WiFi