Home Command

Home Command

Si contrôler son environnement grâce à la domotique présente de nombreux avantages, cela peut parfois sembler complexe ou onéreux.

Pourtant, aujourd’hui, de nombreuses solutions existent, comme les kits de développement, pour contrôler à moindre coût son portail, ses lumières, ses prises ou encore sa machine à café.

Découvrez le tutoriel réalisé par notre Ambassadeur Bricomaker Jérémy : Le Home Command !!

  1. Pourquoi ce projet ?



    Mon précédent tutoriel expliquait comment piloter une lampe en bluetooth.



    Le principal avantage du bluetooth par rapport aux ondes radio haute fréquence : la possibilité d’utiliser son portable comme télécommande.

    Sa principale limite : il est nécessaire de faire une manipulation pour se connecter au module bluetooth avant d’envoyer une commande (même si rien n’empêche d’ajouter un module bluetooth à la télécommande pour la piloter avec votre smartphone !)



    Ainsi, pour allumer votre lampe, vous devez prendre votre portable, activer le bluetooth, lancer l’application, vous connecter au module… pour enfin envoyer la commande d’allumage !
    Un peu fastidieux, n’est-ce pas ?



    Aujourd’hui, je vais vous expliquer comment fabriquer une Home Command permettant d’envoyer des signaux à différents récepteurs.



    Vous n’aurez ainsi qu’à allumer la Home Command et appuyer sur le bouton pour que cela fonctionne ! Les récepteurs (interrupteurs, prises commandes…) sont continuellement en fonction.
  2. Quel matériel ?



    Pour ce projet, il est nécessaire d’avoir ce matériel :



    La Home Command (l’émetteur)



    - Emetteur 433MHz
    - Arduino (Uno, Mini Pro ou autre)
    - Ecran tactile 4D Systems

    Les récepteurs :



    - Récepteur 433MHz
    - ATTiny45 (85, 84, 44) (programmable par Arduino)
    - Relais bistable
    - Régulateur 230VAC-5VDC

    Logiciels


    - Librairie « PinChangeInterrupt »
    - Workshop4 (IDE 4D Systems)
    - Librairie 4D pour Arduino
    - Librairie Manchester
  3. Tests des modules RF



    Un des éléments principaux de ce système, c’est bien entendu les modules qui permettent la transmission des signaux !



    Ce sont deux cartes, minimalistes au possible, dont l’une sert d’émetteur :
  4. Et l’autre de récepteur :


    Il semblerait que ce soit, l’une, si ce n’est LA méthode la plus simple et la moins chère pour faire de la transmission de données.
  5. Les modules sont très simples d’utilisation : une broche vers l’alimentation +5V, une autre vers la masse, et la dernière, la broche de donnée, reliée à une entrée de l’Arduino.



    (Vérifiez le brochage sur vos modules, il existe différentes versions.)



    Pour les tester, il suffit d’avoir 2 cartes Arduino, de brancher le récepteur sur l’une, et d’envoyer une commande (comme allumer une LED) avec l’autre.

    Il faut fixer une antenne sur les modules pour avoir une distance de communication raisonnable.



    Nous allons utiliser la librairie « Manchester » (elle fonctionne très bien sur les ATTiny, que nous allons détailler plus loin.)



    Très simple d’utilisation, il suffit de déclarer l’entrée de la carte que vous utilisez.



    Par exemple, moi j’utilise le pin 4 de mon Arduino Mega, donc j’écris dans mon code :

    #define RX_PIN 4 (ce qui va remplacer tous les « RX_PIN » du code par « 4 ». Comme ça, si vous changer de pin, vous avez seulement cette ligne à changer)
  6. Ensuite on déclare avec la librairie :

    man.setRxPin(RX_PIN) ;

    man.setupReceive(RX_PIN, MAN_1200) ;

    man.beginReceive() ;



    Et voilà, avec simplement ce bout de code, vous avez configuré votre module de réception, en ayant défini une vitesse de 1200, qui devra être la même de votre côté émetteur.

    (Pour en apprendre plus sur la librairie : http://mchr3k.github.io/arduino-libs-manchester/ )



    Voici donc le code global du côté récepteur :




    #include



    #define RX_PIN 4

    #define LED 13




    void setup()

    {

    pinMode(LED, OUTPUT);

    digitalWrite(LED, HIGH);

    delay(1000);

    digitalWrite(LED, LOW);

    man.setRxPin(RX_PIN);

    man.setupReceive(RX_PIN, MAN_1200);

    man.beginReceive();



    } // fin setup



    void loop() {

    if (man.receiveComplete()) { // Si le module reçoi un message complet

    uint16_t m = man.getMessage(); // Alors récupérer le message

    man.beginReceive(); // Débute l'écoute d'un nouveau message



    if (m==1234){digitalWrite(LED,HIGH);} // Si le message est 1234, allumer la LED

    if (m==4321){digitalWrite(LED,LOW);} // Si le message est 4321, éteindre la LED

    }

    } // fin loop


  7. Du coup, du côté émetteur nous avons :



    #include



    #define TX_PIN 4 // Broche de connextion de l'emeteur

    #define LED_PIN 13 // Broche de LED (pour visualisation)




    byte state = 0; // Lecture de l'état des broches du CR

    void setup() {



    pinMode(LED_PIN, OUTPUT);

    man.setTxPin(TX_PIN); // Définition de la broche l'emeteur

    man.setupTransmit(TX_PIN, MAN_1200); // Déclaration de la liaison RF

    }



    void loop() {

    man.transmit(1234); // Envois du message « 1234 »

    digitalWrite(LED_PIN, HIGH); // Visualisation avec une LED

    delay(5000); // Attente de 5 secondes

    man.transmit(4321); // Envois du message 4321

    digitalWrite(LED_PIN, LOW); // Visualisation LED

    delay(5000); // Attente de 5 secondes



    } // fin loop




    Ce programme envoie donc en boucle la commande pour allumer la LED, attend 5 secondes, envoie la commande pour éteindre puis attend de nouveau 5 secondes avant de recommencer.



    Ainsi, vos 2 cartes Arduino connectées et alimentées, vous devriez voir les LEDs de chacune d’elles s’allumer et s’éteindre en même temps.

    Alors que seulement une carte les contrôle.



    (PS : Les cartes Arduino UNO et d’autres, possèdent une LED attachée par défaut au pin 13, donc inutile d’en ajouter une.)
  8. Programmation des ATTINY



    Maintenant que l’on sait utiliser la librairie Manchester, voyons comment s’en servir sur les ATTiny !



    J’ai choisi d’utiliser ces microcontrôleurs car ils ont la particularité d’être petits (8 broches), de posséder les caractéristiques dont nous avons besoin, et d’être programmables comme une Arduino.
    Et ceci avec un branchement et une manipulation très simple.
  9. Voici comment vous devez brancher l’ATTiny à votre Arduino pour le programmer :
  10. Il faut également ajouter un condensateur de 10µF entre le reset (de l’Arduino) et la mass. Nous évitons ainsi la réinitialisation de l’Arduino lors du téléchargement du programme vers l’Attiny



    Pour éviter d’avoir une plaque d’essai et des fils qui se ballade partout, j’ai fait un shield pour mon Arduino qui permet de programmer en quelques clics.



    Une fois le branchement effectué, il faut passer du côté logiciel.



    Avant de lancer l’IDE Arduino, il va falloir installer les fichiers « core » des ATTiny que vous trouverez ici.



    Pour info, j’utilise la version 1.0.6 de l’IDE car la librairie Manchester ne veut pas compiler sous les dernières versions.
    Il faut l’installer manuellement.



    La manœuvre consiste à télécharger les fichiers à cette adresse puis de décompresser



    Le contenu, qui contient un dossier « attiny-ide.1.0.x » qui contient lui-même un fichier « attiny ».

    Copiez celui-ci dans un dossier « hardware » dans le dossier carnet de croquis de votre IDE.
  11. Lancement de l’IDE



    Vous pouvez maintenant lancer l’IDE et observer le visuel ci-dessous.



    Reprenons notre programme de tout à l’heure, et adaptons le pour une ATTiny, le module RX va être branché sur la broche n° 6, soit l’entrée « B1».

    On remplace alors «#define RX_PIN 4 » par « #define RX_PIN 1 ».



    Simple non ?



    Mais également, la LED, cette fois il n’y a ni LED ni broche 13. Prenons donc par exemple la broche n°2, correspondant au pin 3 de l’ATTiny.

    On a donc « #define LED 3 ».



    Tout le reste est inchangé.



    Maintenant voici, la procédure pour transférer ce programme sur le microcontrôleur :



    Ne branchez pas tout de suite l’ATTiny sur l’Arduino.



    Ouvrez l’IDE, puis faites : Fichier => Exemples / ArduinoISP

    Branchez votre carte Arduino

    Transférez le programme ArduinoISP sur la carte. C’est ce qui permet d’utiliser la carte Arduino comme programmeur.

    Ouvrez votre programme a transférer sur l’ATTiny

    Faites : Outils => Type de carte => ATTiny45 @ 8Mhz

    Puis 0utils => Graver la séquence d’initialisation (IMPORTANT ! Mais à faire seulement la première fois que vous programmer une ATTiny)

    Encore une fois Outils => Programmeur => Arduino as ISP

    Vous pouvez maintenant brancher votre ATtiny sur l’Arduino et procéder au transfert.
  12. Assemblage d’un récepteur



    Maintenant que notre microcontrôleur est pratiquement programmé, voyons le second point essentiel de notre bloc « récepteur» : le relai bistable.



    Alors, qu’est ce qu’un relais ?

    Un relais c’est comme un interrupteur, qui marche grâce au courant, qui en passant dans une bobine, crée un champ magnétique et ferme l’interrupteur.

    Le problème, c’est qu’il faut maintenir une tension sur la bobine lorsque l’on souhaite que l’interrupteur soit en position fermée.



    C’est là qu’intervient le relais bistable.

    Celui-ci permet d’avoir 2 positions stables, c’est-à-dire sans avoir besoin d’un courant continu.



    Il suffit d’une impulsion pour changer l’interrupteur de position.

    Il existe différentes manières de faire :

    – avec 1 bobine, il faut inverser la tension pour changer d’état,

    – avec 2 bobines, il faut alimenter l’une ou l’autre.


    Le modèle choisi ici, AZ850P2 sont 2 bobines supportant 250VAC/ 1A, idéale pour contrôler directement une lampe.



    Bien sûr, il est également possible de piloter des transistors, pour contrôler des relais plus gros (qui ne sont pas pilotables avec une tension nominale de 5V) etc.



    Les possibilités sont nombreuses, mais nous allons nous arrêter sur ces relais bistables dont voici le schéma :ci-dessous.

  13. On observe donc les 2 bobines, entre les broches : 1-5 et 10-6.



    Et 2 interrupteurs de chaque côtés, représentés ci-dessus en position « reset » avant la mise sous tension.



    Pour changer de position, il suffit alors d’envoyer un signal sur la broche 1 ou sur la broche 10. Ce sont 2 ces 2 broches qui vont être reliés à votre microcontrôleur.

    Il reste des entrées de libre sur le µC.

    On va donc ajouter un bouton poussoir pour changer l’état du relais directement, sans avoir besoin de la Home Command.



    Profitons-en pour ajouter un bouton sur la broche reset.



    Notre programme ressemble maintenant à ça :



    #include

    #include



    #define RX_PIN 1 //= pin 6

    #define Relay1 3 //= pin 2 => broche 1

    #define Relay2 4 //= pin 3 => broche 10



    volatile int state = 0; // valeur variable



    void setup()

    {

    pinMode(Relay1, OUTPUT);

    pinMode(Relay2, OUTPUT);

    digitalWrite(Relay1,LOW);

    digitalWrite(Relay2,LOW);

    man.setRxPin(RX_PIN);

    man.setupReceive(RX_PIN, MAN_1200);

    man.beginReceive();

    attachPcInterrupt( 2, pressb, FALLING);

    } // fin setup



    void pressb(){

    state=!state;

    // if(state==0){state=1;}

    // if(state==1){state=0;}



    }



    void loop() {

    if (man.receiveComplete()) {

    uint16_t m = man.getMessage();

    man.beginReceive();

    if (m==1234){ // Si le message reçu est 1234 mettre l’état 1

    state = 1;

    }

    if (m==4321){ // Si le message reçu est 4321 mettre l’état 0

    state = 0;

    }

    } // fin receive

    if (state==0){

    digitalWrite(Relay1,LOW);

    digitalWrite(Relay2,HIGH);

    delay(200);

    digitalWrite(Relay2,LOW);

    }

    if (state==1){

    digitalWrite(Relay2,LOW);

    digitalWrite(Relay1,HIGH);

    delay(200);

    digitalWrite(Relay1,LOW);

    }

    } // fin loop

  14. Voici donc un schéma viable (avec des borniers pour l’alimentation et les sorties du relais)
  15. Cette carte est alimentée directement en 5V, mais les sorties J1 et J2 peuvent supporter 230VAC/1A.

    Il faut donc trouver un moyen d’alimenter ce système à partir d’une simple prise (230VAC).

    C’est là que nous utilisons un chargeur de portable ! Car il transforme le courant alternatif en courant continu, de 5V. Idéal !



    Il suffit de brancher directement ce « module » sur le système, et de repiquer le 230VAC pour le balancer dans le relais bistable.
  16. J’ai effectué un routage de ce schéma pour en faire un typon.



    Après tirage, gravure, perçage et soudage des composants, nous obtenons une jolie carte.
  17. On ajoute le transformateur du chargeur de portable.

    Je place le tout dans un boitier de transformateur, en perçant des trous, pour la prise et pour un bouton poussoir, extension du bouton se trouvant sur la carte.
  18. Test de l’écran 4D Systems



    Ah cet écran !

    Cela fait déjà un certain temps que je connais 4D Systems (de nom) et pour avoir vu un camarade de classe travailler sur un tel écran, cela m’a donné envie !

    Rien que leur slogan « Turning Technology into Art » me plait beaucoup !



    Et ce n’est pas un simple écran ! C’est un ensemble de processeurs complets avec un nombre d’entrées/sorties et possédant son propre langage de programmation (le 4DGL).

    Mais ici nous allons surtout s’intéresser aux possibilités graphiques et interface avec Arduino.



    Le logiciel fourni permet d’élaborer des interfaces graphiques à base de glisser/déposer. Il est très simple, pour des résultats très satisfaisants.



    Avant d’aller plus loin, il faut savoir qu’il existe 3 modèles de processeurs différents chez 4D Systems : PICASSO, DIABLO16 et GOLDELOX.



    J’utilise l’écran tactile uLCD-24PTU, qui est un PICASSO.

    Pour l’utiliser, rien de plus simple : il suffit de le brancher sur la liaison série de votre Arduino.



    Ensuite pour le “programmer” (ici, il sera seulement question d’élaborer une interface graphique simple) vous devez installer l’environnement Workshop 4 disponible sur leur site.

    Une fois installé, lancez-le, créez un nouveau projet, sélectionnez votre modèle d’écran, puis choisissez l’environnement “ViSi-Genie”.



    Home Command
  19. J'élabore l’interface en seulement 6 minutes.

    Il s’agit de simple glisser/déposer et de quelques paramètres.



    Voici le résultat que j’obtiens (voir l'image ci-dessous).



    (J’ai repris les éléments graphiques utilisés dans mon précédent tutoriel pour l’application smartphone).



    Il ne reste plus qu’à uploader ceci sur votre écran en branchant l’écran sur l’adaptateur USB et en connectant la carte SD à votre PC.

    Appuyez sur « Build Copy/Load ».



    Une fois terminé, insérez la carte µSD dans l’écran et votre interface est prête !



    Tout le reste consiste à établir le dialogue entre votre écran et votre Arduino.

    4D Systems fournit une librairie spécialement pour ça : https://github.com/4dsystems/ViSi-Genie-Arduino-Library



    N’hésitez pas à aller lire la documentation très fournie de 4D Systems.
  20. Une fois la librairie installée, on peut commencer notre code.



    Ouvrez un exemple fourni avec la librairie si vous voulez tester.



    Voici le code que j’ai utilisé :




    /*
    Programme de transmission de commande sur Arduino

    Avec un écran tactile 4D Systems

    Utilisation de la librairie Manchester pour

    la communication à l'aide de module 433MHz

    0 (RX) => TX écran 4D

    1 (TX) => RX écran 4D

    5 => RESET écran 4D

    4 => Broche data module TX

    */

    #include // Librairie 4D Systems pour écran 4D PICASSO

    #include // Librairie communication



    Genie genie;



    #define RESETLINE 5 // Broche de reset de l'écran 4D

    #define TX_PIN 4 // Broche de connextion de l'emeteur

    #define LED_PIN 13 // Broche de LED (pour visualisation)



    int wxc1 = 0; // variables state

    int wxc2 = 0;

    int wxc3 = 0;

    int wxc4 = 0;

    int wxc5 = 0;

    void setup() {



    pinMode(LED_PIN, OUTPUT);

    pinMode(RESETLINE, OUTPUT);



    man.setTxPin(TX_PIN);

    man.setupTransmit(TX_PIN, MAN_1200); // Déclaration du module RF



    Serial.begin(115200); // Déclaration communication avec l'écran (en liaison série)

    genie.Begin(Serial); // Utilisation de la liaison série Serial



    genie.AttachEventHandler(myGenieEventHandler);

    digitalWrite(RESETLINE, 0);

    delay(100);

    digitalWrite(RESETLINE, 1); // Démarage de l'écran

    delay (3500);

    genie.WriteContrast(1);

    genie.WriteStr(0, GENIE_VERSION);

    }



    void loop() {



    genie.DoEvents();



    } // fin loop

    void myGenieEventHandler(void)

    {

    genieFrame Event;

    genie.DequeueEvent(&Event);



    // INTERRUPTEUR 1

    if (genie.EventIs(&Event, GENIE_REPORT_EVENT, GENIE_OBJ_USERBUTTON, 0))

    { if (wxc1 == 0){ digitalWrite(LED_PIN, LOW); man.transmit(1234); wxc1 = 1;}

    else { digitalWrite(LED_PIN, HIGH); man.transmit(4321); wxc1 = 0;}

    } // fin if



    // INTERRUPTEUR 2

    if (genie.EventIs(&Event, GENIE_REPORT_EVENT, GENIE_OBJ_USERBUTTON, 1))

    { if (wxc2 == 0){ wxc2 = 1;}

    else { wxc2 = 0;}

    } // fin if

    // INTERRUPTEUR 3

    if (genie.EventIs(&Event, GENIE_REPORT_EVENT, GENIE_OBJ_USERBUTTON, 2))

    { if (wxc3 == 0){ wxc3 = 1;}

    else { wxc3 = 0;}

    } // fin if

    // INTERRUPTEUR 4

    if (genie.EventIs(&Event, GENIE_REPORT_EVENT, GENIE_OBJ_USERBUTTON, 3))

    { if (wxc4 == 0){ wxc4 = 1;}

    else { wxc4 = 0;}

    } // fin if

    // INTERRUPTEUR 5

    if (genie.EventIs(&Event, GENIE_REPORT_EVENT, GENIE_OBJ_USERBUTTON, 4))

    { if (wxc5 == 0){ wxc5 = 1;}

    else { wxc5 = 0;}

    } // fin if

    } // fin geni handler





    Dans ce code, seul l’interrupteur 1 envoie un message, par la commande « man.transmit(1234) ; » dans un cas et « man.transmit(4321) ; » dans l’autre.



    À vous de configurer les autres boutons pour envoyer les bonnes commandes.
    N’oubliez pas de changer les messages du côté récepteur !
  21. Ajout d’un pont diviseur



    Les batteries Li-ion ont une tension de 3.7V à 4.2V à vide en réalité.



    Et l’entrée de l’Arduino supporte 5V. C’est pour cela que nous utilisons un pont diviseur ici.

    Batteries chargées, la tension mesurée au voltmètre à l’entrée de l’Arduino est de 3.5V Ceci représente donc notre 100%.



    Ces valeurs vont servir d’étalonnage. Échantillonnant sur 1024 valeurs (de 0 à 1023).



    Donc si on à 5V on obtient 1023, et 0V = 0.



    Un simple produit en croix nous indique donc que pour 3.5V on obtient 716, et 574 pour 2.8V.

    Il suffit alors d’indiquer tout ceci à notre programme.



    En prenant par exemple qu’au-delà de 716 notre batterie est à 100% et en dessous de 574 nous somme sous les 15%.

    Donc 716 = 100 et 574 = 15.

    Une fonction d’Arduino permet de faire l’étalonnage en toute simplicité :

    « map (variable, 716, 574, 100, 15) ; »



    À ajouter dans le « void loop »






    int batlvl = analogueRead(A5) ; // (pour l’entrée analogue 5)

    batlvl = map(batlvl, 716, 574, 100, 15) ; // Etalonnage

    genie.WriteObject(GENIE_OBJ_GAUGE, 0, batlvl) ; // Envois la commande à l’écran, au l’objet « Gauge » id « 0 » la valeur « batlvl »


  22. Assemblage de la Home Command



    Nous avons tous les éléments, il ne reste plus qu’à les assembler dans un petit boitier !



    Cependant, pour ce tutoriel, je fus en panne d’Arduino mini.

    J’utilise donc un Arduino Uno (plus encombrant), je n’ai pu mettre à terme mon design initial, et vous présente donc un design provisoire.



    Il s’agit d’une boite de bons chocolats. J’ai coupé un rectangle pour glisser l’écran, auquel j’ai bricolé un cadre en bois. Puis percé un trou pour un interrupteur On/Off.

    J’ai récupéré deux batterie Li-ion d’une vieille batterie PC. (3.7V x 2 = 7.4V pour alimenter l’Arduino, c’est parfait).
  23. On referme le tout, avec une petite touche design tout de même.
  24. Évolutions envisagées



    La première chose qui se verra changée, c’est la Home Command.

    Ceci est un design totalement provisoire. Il est basé sur une carte Arduino UNO, à la place d’une mini initialement prévue.



    Il se pourrait même que j’utilise un simple microcontrôleur ATmega328P sur un circuit imprimé sur-mesure qui intègre un régulateur 5V ainsi que le pont diviseur de tension pour la mesure du niveau de batterie.

    Cette solution permettra de réduire considérablement la taille de la Home Command.



    Une chose qui pourrait être mise en place sur le long terme en plus, c’est un tableau de commande global.

    C’est-à-dire une télécommande fixe, accrochée à un mur par exemple, qui donnerait le contrôle de la pièce/maison.



    Un petit plus, si le nombre de périphériques augmente considérablement, il faudrait élaborer une interface interactive, avec des onglets ou de manière déroulante, avec par exemple, un commutateur rotatif pour effectuer une sélection.



    Pour finir, dans ce tutoriel je montre un récepteur qui fait office de prise, pour y brancher une lampe ou un appareil électrique « simple » (et ne consommant pas plus de 1A).

    C’est évidemment un exemple de mise en place du système, car à partir du moment où vous pouvez envoyer des commandes à distance à un récepteur, vous pouvez imaginer bon nombre d’applications !



    Il est tout à fait possible d’intégrer ce module à un interrupteur de lampe de plafond, en le cachant dans le mur, de relier plusieurs relais sur la carte pour actionner différents boutons d’un appareil (par exemple relier le bouton ON de votre amplificateur audio et celui de votre ordinateur, et ainsi pouvoir démarrer les 2 à distance avant même de sortir de votre lit !)
  25. Conclusion



    Allumer des objets à distance avec un gadget entre les doigts, c’est un jeu d’ enfant !

    Mais en plus, être celui qui met crée l’objet permettant d’avoir le contrôle sur le monde qui nous entoure, c’est extra … !



    Je m’y amuse beaucoup, et je pense que je n’ai pas fini d’ajouter des périphériques sur ma Home Command, même les plus inutiles, juste pour dire que je peux le faire !



    Et s’il y a une chose, un petit détail qui rend un peu tristounet, c’est le fait que les transmissions ne se font qu’en sens unique.
    Ce qui fait qu’en regardant l’écran, nous avons aucune idée de l’état de l’interrupteur (ou autre).



    À cette échelle d’application, nous pouvons aisément nous en passer.

    Pour une installation de plus grande envergure, nous pouvons envisager des modules un peu plus chers, permettant un dialogue dans les deux sens !
Réalisé par
Posté le
Univers
IoT
Temps de fabrication
3 jours
Niveau de difficulté
Expert
Matériel(s)
1
Emetteur 433MHz
1
Arduino (Uno, Mini Pro ou autre)
1
Ecran tactile 4D Systems
1
Récepteur 433MHz
1
ATTiny45 (85, 84, 44)
1
Relais bistable
1
Régulateur 230VAC-5VDC

Aucun commentaire. Soyez le premier à en écrire un !

Vous devez être connecté pour laisser un commentaire.