La domotique chez soi

Je rentre d’une journée de boulot, et fatigué, je m’affale comme une masse dans le canapé. Me vient alors l’envie de regarder un épisode de ‘ The Big Bang Theory ‘, je sors donc mon portable, démarre l’application DomoGJ et appuie sur quelques boutons. Le volet se ferme, les lumières s’éteignent, le vidéo projecteur s’allume, la toile descend lentement et majestueusement, et l’épisode commence enfin. Bienvenue chez moi :-D

Et pour pas trop cher ! Je détaillerai dans cet article le prix, la liste des composants, où acheter, et enfin je donnerai mes sources. Comme d’habitude, ce projet s’articule autour de modules arduino et un peu d’Android. Le but étant de contrôler les lumières, les volets, tout ce qui vous passe par la tête en fait, à l’aide de votre portable Android – en réalité n’importe quel matériel qui a accès à internet – , où que vous soyez (Chez vous, ou pas :p).

Attention cependant avant de vous mettre à l’ouvrage, on touche à l’électricité, et on ne rigole pas avec ça, je ne suis pas responsable de l’utilisation que vous faites de ce tutorial. Veillez à toujours travailler avec le courant coupé.

Comment ça marche ? Un petit schéma :

Votre portable est donc connecté en wifi à votre box, ou bien à l’internet. Il appelle une URL qui passe par votre box et ai redirigé vers le module arduino connecté en ethernet. L’URL contient des variables, que l’arduino va extraire et analyser pour envoyer un signal RF dans tout l’appartement. Celui-ci va être capté par tous les modules arduino, et bien entendu seulement un seul d’entre eux est concerné, il va donc appliquer les ordres, généralement activer – ou pas – un relais. Un relais nous sert d’interrupteurs. En faisant passer un petit courant d’un côté (5v, celui de l’arduino), il laisse passer de l’autre les 220v du gros courant servant à allumer nos ampoules.

Module Principal

J’appelle module principal la partie connectée à votre box. Elle se compose des éléments suivant :

  • Arduino (Version Uno, pro, nano, vous avez l’embarras du choix, il y en a pour une vingtaine d’euros. Personnellement, je n’utilise pas les boards officiels, j’assemble tout à la main, c’est beaucoup moins cher (8 euros en tout), lire le tutorial)
  • Shield Ethernet pour Arduino (Vous pouvez acheter l’officiel, à 31 euros, ou bien celui que j’ai utilisé, à 15 euros, mais attention, peu de documentation et le code est un peu… Obscur ! Si j’avais à le refaire je prendrai l’officiel. On peut également ajouter qu’il est possible d’avoir un module arduino avec l’ethernet intégré, mais jamais testé)
  • RF Link Transmitter 434MHz (Pour envoyer sans fil les informations aux autres modules, chez Sparkfun à moins de $4 !!!)

Ce qui nous fait un total de 35 euros avec les composants que j’ai utilisé, on peut descendre à 25 en utilisant les solutions les moins coûteuse.

(Promettez-moi de ranger tout ça dans une belle boite, j’ai tout caché dans une boite noire qui s’accorde bien avec ma freebox Revolution :) )

Pour le cablage, il y a quatre pins sur l’émtteur RF : 5v, GND, Data et l’antenne. Dans le programme qui suivra, le pin Data est connecté au pin 3 de l’arduino.

Maintenant, il va falloir choisir comment on va envoyer les ordres aux différents récepteur. Comme décrit un peu plus tôt dans l’article, on utilise des URL dans lesquelles on fait passer des variables. Un ordre typique de mon installation :

http://(IP de l’arduino)/?cmd=A-1-3-0

La commande est «  A-1-3-0 « . Nous verrons un peu plus tard ce que celle-ci signifie, pour le moment notre module principal a juste à récupérer cette commande et à l’envoyer grâce à son module RF. Le code arduino :

#include <VirtualWire.h>
#include <etherShield.h>
#undef int
#undef abs
#undef double
#undef float
#undef round
 
static uint8_t mymac[6] = {0x54,0x55,0x58,0x10,0x00,0x24};
static uint8_t myip[4] = {192,168,1,15};
static char baseurl[]="http://192.168.1.15/";
static uint16_t mywwwport =80;
 
#define BUFFER_SIZE 500
#define STR_BUFFER_SIZE 40
static uint8_t buf[BUFFER_SIZE+1];
static char strbuf[STR_BUFFER_SIZE+1];
int cool = 0;
int tprecedent = 0;
 
EtherShield es=EtherShield();
uint16_t print_webpage(uint8_t *buf);
 
void setup(){
  Serial.begin(9600);
  vw_set_ptt_inverted(true);
  vw_setup(2000);
  vw_set_tx_pin(3);
  pinMode(4, OUTPUT);
  pinMode(5, OUTPUT);
  pinMode(6, OUTPUT);
  es.ES_enc28j60Init(mymac);
  es.ES_enc28j60clkout(2);
  delay(10);
  es.ES_enc28j60PhyWrite(PHLCON,0x880);
  delay(500);
  es.ES_enc28j60PhyWrite(PHLCON,0x990);
  delay(500);
  es.ES_enc28j60PhyWrite(PHLCON,0x880);
  delay(500);
  es.ES_enc28j60PhyWrite(PHLCON,0x990);
  delay(500);
  es.ES_enc28j60PhyWrite(PHLCON,0x476);
  delay(100);
  es.ES_init_ip_arp_udp_tcp(mymac,myip,80);
}
 
void loop(){
  uint16_t plen, dat_p;
  plen = es.ES_enc28j60PacketReceive(BUFFER_SIZE, buf);
  if(plen!=0){
    if(es.ES_eth_type_is_arp_and_my_ip(buf,plen)){
      es.ES_make_arp_answer_from_request(buf);
      return;
    }
 
    if(es.ES_eth_type_is_ip_and_my_ip(buf,plen)==0){
      return;
    }
 
    if(buf[IP_PROTO_P]==IP_PROTO_ICMP_V && buf[ICMP_TYPE_P]==ICMP_TYPE_ECHOREQUEST_V){
      es.ES_make_echo_reply_from_request(buf,plen);
      return;
    }
    if (buf[IP_PROTO_P]==IP_PROTO_TCP_V&&buf[TCP_DST_PORT_H_P]==0&&buf[TCP_DST_PORT_L_P]==mywwwport){
      if (buf[TCP_FLAGS_P] & TCP_FLAGS_SYN_V){
        es.ES_make_tcp_synack_from_syn(buf);
        return;
      }
      if(buf[TCP_FLAGS_P] & TCP_FLAGS_ACK_V){
        es.ES_init_len_info(buf);
        dat_p=es.ES_get_tcp_data_pointer();
        if (dat_p==0){
          if (buf[TCP_FLAGS_P] & TCP_FLAGS_FIN_V){
            es.ES_make_tcp_ack_from_any(buf);
          }
          return;
        }
        if (strncmp("GET ",(char *)&(buf[dat_p]),4)!=0){
          plen=es.ES_fill_tcp_data_p(buf,0,PSTR("HTTP/1.0 200 OK\r\nContent-Type: text/html\r\n\r\n<h1>200 OK</h1>"));
          goto SENDTCP;
        }
        if (strncmp("/ ",(char *)&(buf[dat_p+4]),2)==0){
          plen=print_webpage(buf);
          goto SENDTCP;
        }
 
         find_key_val((char *)&(buf[dat_p+5]),"cmd");
 
         if(cool == 1){
           plen=print_webpage(buf);
         }
         lum(strbuf);
 
         if(strbuf[0] == 'B'){ //Autre module qui contrôle directement des octocoupleurs faisant le lien entre l'arduino et une télécommande
           if(strbuf[2] == '0'){
             digitalWrite(4, HIGH);
             delay(100);
             digitalWrite(4, LOW);
           }else if(strbuf[2] == '1'){
             digitalWrite(5, HIGH);
             delay(100);
             digitalWrite(5, LOW);
           }else if(strbuf[2] == '2'){
             digitalWrite(6, HIGH);
             delay(100);
             digitalWrite(6, LOW);
           }
         }
 
SENDTCP:  es.ES_make_tcp_ack_from_any(buf); // send ack for http get
          es.ES_make_tcp_ack_with_data(buf,plen); // send data
      }
    }
  }
}
 
void lum(const char* test){
  if((millis()-tprecedent) > 200){ //Pour eviter deux ordres à la suite
    const char *msg = test;
    Serial.print(msg);
    Serial.println();
    vw_send((uint8_t *)msg, strlen(msg));
    vw_wait_tx();
    tprecedent = millis();
  }
}
 
uint8_t find_key_val(char *str,char *key){
  uint8_t found=0;
  uint8_t i=0;
  char *kp;
  kp=key;
  while(*str &&  *str!=' ' && found==0){
    if (*str == *kp){
      kp++;
      if (*kp == '\0'){
        str++;
        kp=key;
        if (*str == '='){
          found=1;
        }
      }
    }else{
      kp=key;
    }
    str++;
  }
  if (found==1){
    while(*str &&  *str!=' ' && *str!='&' && i<STR_BUFFER_SIZE){
      strbuf[i]=*str;
      i++;
      str++;
    }
    strbuf[i]='\0';
  }
  cool = 1;
  return(found);
}
 
uint16_t print_webpage(uint8_t *buf){
  uint16_t plen;
  plen=es.ES_fill_tcp_data_p(buf,0,PSTR("HTTP/1.0 200 OK\r\nContent-Type: text/html\r\n\r\n"));
  plen=es.ES_fill_tcp_data_p(buf,plen,PSTR("<form METHOD=get action=\""));
  plen=es.ES_fill_tcp_data(buf,plen,baseurl);
  plen=es.ES_fill_tcp_data_p(buf,plen,PSTR("\">"));
  plen=es.ES_fill_tcp_data_p(buf,plen,PSTR("<input type=submit name=\"cmd\" value=\"A-6-2-0-3-0-4-0-5-0-6-0-7-0\"><br><br>"));
  plen=es.ES_fill_tcp_data_p(buf,plen,PSTR("</form>"));
 
  return(plen);
 }

 

Module Exécutant

J’appelle module exécutant les modules qui vont recevoir les ordres du module principal et les appliquer. Les modules exécutant peuvent être très différent suivant ce que vous voulez contrôler, mais en général ils sont composés de :

  • Arduino (Toujours le même, vous pouvez peut-être envisager la version nano, ou pro mini, car ils auront souvent à se loger dans un petit endroit, à côté de l’interrupteur)
  • RF Link Receiver 434MHz (Il s’agit cette fois-ci du récepteur RF, toujours chez Sparkfun à moins de $5 !)
  • Relais (Ils vont jouer le rôle de commutateur entre le faible courant de l’arduino et le 220v de votre électricité, j’utilise ces modèles là, il y’en a deux par shield et ils coûtent environ 4 euros)
  • Convertisseur 220v -> 5v (Pour alimenter l’arduino ! Je ne l’ai pas compté dans le module principale, car je sous entends qu’il est à côté de votre box disposant de port usb 5v, on en trouve pour 2 euros sur ebay)
  • De l’électronique diverses ! Je ne vais pas détailler mais n’oubliez pas que si vous ajoutez une commande à distance, il est préférable de laisser un interrupteur physique ! Imaginez qu’il vous arrive quelque chose dans votre appartement et que les gens voulant vous sauver perdent du temps à trouver la lumière… A méditer je crois ;)

Le prix total, et bien par exemple avec un module qui permet de gérer six lumières, le prix est de 30 euros (8 + (4*3) + 4 + Divers). Un module pour gérer un volet électrique vous coûtera 18 euros environ.

Un de mes modules de lumières (J’ai également refait le panneau des interrupteurs, un peu dans le genre cokpit d’avion) :

J'utilisais des leds pour symboliser les lumières, pendant les tests :)

 

Mes anciens interrupteurs... Pas très sexy (Le mur non plus d'ailleurs, la peinture m'attends depuis un bon bout de temps)

Pour rentrer tout ça là-dedans, je ne vous raconte pas la galère

Passons à la programmation ! Souvenez-vous en, on parlait tou à l’heure d’une commande envoyé par le module principal, qui ressemblait à :

A-1-3-0

Le A signifie que je souhaite exécuter l’ordre A (Ooooh… :p), et celui-ci dans mon cas commande 6 ampoules. Le 1 qui vient juste après nous donne le nombre d’instructions (Ici, 1 :p). Je lui dit donc de mettre à l’état 0 l’ampoule n°3. On pourrait traduire par : (Identifiant de l’ordre)-(Nombre d’instructions)-(Identifiant de l’amoule)-(Etat). Et on peut ajouter d’autres ordres ! Comme par exemple :

A-3-3-1-5-0-6-1 = Il y a trois ordres, allume l’ampoule 3, éteint l’amoule 5, allume l’ampoule 6.

Le code arduino (A adapter suivant vos modules, bien entendu) :

#include <VirtualWire.h>
#undef int
#undef abs
#undef double
#undef float
#undef round
 
int etat[] = {0, 0, 0, 0, 0, 0};
int diff[] = {0, 0, 0, 0, 0, 0};
 
int timer = 0;
int ancien = 0;
 
void setup(){
  Serial.begin(9600);
  vw_set_ptt_inverted(true);
  vw_setup(2000);
  vw_set_rx_pin(8);
  vw_rx_start();
 
  pinMode(2, OUTPUT);
  pinMode(3, OUTPUT);
  pinMode(4, OUTPUT);
  pinMode(5, OUTPUT);
  pinMode(6, OUTPUT);
  pinMode(7, OUTPUT);
 
  pinMode(12, INPUT); //Switch ON/OFF
  pinMode(9, OUTPUT); //LED
  pinMode(10, OUTPUT); //LED
 
  pinMode(14, INPUT); //Lumiere
  pinMode(15, INPUT); //Lumiere
  pinMode(16, INPUT); //Lumiere
  pinMode(17, INPUT); //Lumiere
  pinMode(18, INPUT); //Lumiere
  pinMode(19, INPUT); //Lumiere
 
  digitalWrite(12, HIGH); //Switch ON/OFF
 
  digitalWrite(14, HIGH); //Lumiere
  digitalWrite(15, HIGH); //Lumiere
  digitalWrite(16, HIGH); //Lumiere
  digitalWrite(17, HIGH); //Lumiere
  digitalWrite(18, HIGH); //Lumiere
  digitalWrite(19, HIGH); //Lumiere
}
 
void loop(){
  digitalWrite(9,HIGH);
  if(digitalRead(12) == LOW){
    timer = 0;
    digitalWrite(10,LOW);
    uint8_t buf[VW_MAX_MESSAGE_LEN];
    uint8_t buflen = VW_MAX_MESSAGE_LEN;
    char msg[30] = "";
    //vw_wait_rx();
    if(vw_get_message(buf, &buflen)){
      digitalWrite(10,HIGH);
      for (int i=0;i<buflen;i++) msg[i]=0; {
        int i;
        char vBuff[30] = "";
        for (int i = 0; i < buflen; i++){
          msg[i] = buf[i];
        }
        strcat(vBuff, msg);
 
        Serial.print(vBuff);
 
        const char separator[] = "-";
        char* accum;
        char* lecture = strtok_r(vBuff,separator,&accum);
 
        Serial.println();
        if(lecture[0] == 'A'){
          lecture = strtok_r(NULL,separator,&accum);
          int nbr = atoi(lecture);
          if(nbr == 10){
            int tps = atoi(strtok_r(NULL,separator,&accum));
            dodo(tps);
          }else{
            for(int j = 0; j < nbr; j++){
              int pin = atoi(strtok_r(NULL,separator,&accum));
              if(atoi(strtok_r(NULL,separator,&accum))){
                digitalWrite(pin, HIGH);
              }else{
                digitalWrite(pin, LOW);
              }
            }
          }
        }
      }
    }else{
      digitalWrite(10,LOW);
    }
    for(int k=14; k<20; k++){
 
      if(digitalRead(k) == HIGH && etat[k-14] == 0){
        diff[k-14] = 1;
      }else if(digitalRead(k) == LOW && etat[k-14] == 1){
        diff[k-14] = 1;
      }
 
      if(diff[k-14] == 1){
        digitalWrite(10,HIGH);
        delay(5);
        if(digitalRead(k) == HIGH){
          digitalWrite((k-12),LOW);
        }else{
          digitalWrite((k-12),HIGH);
        }
        digitalWrite(10,LOW);
        diff[k-14] = 0;
      }
 
      if(digitalRead(k) == HIGH){
        etat[k-14] = 1;
      }else{
        etat[k-14] = 0;
      }
    }
  }else{
    digitalWrite(10,LOW);
    if(timer == 10){
      for(int k=2; k<8; k++){
        digitalWrite(k,LOW);
      }
    }else{
      timer++;
      digitalWrite(10, HIGH);
      delay(20);
      digitalWrite(10, LOW);
      delay(980);
    }
  }
  delay(50);
}
 
void dodo(int time){
  ancien = millis();
  for(int i = 0; i<time; i++){
    digitalWrite(10, HIGH);
    delay(20);
    digitalWrite(10, LOW);
    delay(980);
  }
  for(int k=2; k<8; k++){
    digitalWrite(k,LOW);
  }
}

(Il y a dans ce code des choses  » en plus « , c’est à dire un switch qui mis sur off me laisse 10 secondes de lumières avant de tout éteindre (Très pratique quand on s’absente), ainsi qu’une fonction  » dodo « , l’ordre ressemble à  » A-10-30 « , où 10 signifie que l’on veut la fonction dodo, et 30 le nombre de secondes au bout duquel les lumières s’éteignent, ça laisse le temps de poser le portable et de se glisser dans son lit)

Module Android

Cette partie là est plutôt cadeau, il n’y a rien de vraiment très compliqué, il faut juste sous Android créer une application avec des boutons qui appellent des url. Libre à vous de vous compliquer un peu la tâche avec une interface graphique (Ce que je n’ai toujours pas eu le temps de faire :p).

L'appli magique, au look révolutionnaire.

 

Test lointain d'une interface graphique, que je finirai bien un jour, notez le système de navigation par onglet :)

 

Cet article touche à sa fin, j’ajouterai que bien entendu, les ajouts et variantes existent par millier, on peut imaginer le volet qui s’ouvre et se ferme en fonction de l’heure, de même même pour les lumières, et vous pouvez ajouter plein d’autre module, la toile du vidéo projecteur qui descend du plafond dans mon cas, gérer les télécommandes infrarouges pour allumer certain périphérique, la gestion d’une lumière multicolore, toujours bien pour les ambiances, la machine à café du matin, les arrosages automatique, etc. Tout cela pour une somme relativement modique, j’en ai eu pour 50 euros avec mon petit appartement (Bon, et quand même pas mal de temps de bricolage). Si il y a des câbles partout chez vous, le prix est dégressif :)

On pourrait aussi imaginer un système qui en plus de donner des ordres puisse nous donner l’état des lumières (Allumés, éteintes), pour par exemple pouvoir tout éteindre ou nous prévenir si vous êtes à plus de 50m de votre appartement. Tout est possible, et je vous souhaite vraiment d’avoir le temps de développer tout ça :)

Pour ceux qui se poserait la question, mon système est en place depuis plusieurs mois dans mon appartement, et depuis qu’il est en route il n’y a eu aucun soucis ! N’hésitez pas à commenter si vous avez des questions ;)

68 réflexions au sujet de « La domotique chez soi »

  1. Félicitation pour votre projet. J’ai l’intention de faire à peu près la même chose que vous, cependant un détail me gène quand a l’envoi d’ordre par internet.
    Le fait de passer des commandes dans une URL reste très dangereux. il suffit qu’on connaisse votre IP et toute votre maison va alors se mettre à s’allumer, s’éteindre. Avez vous trouvé un moyen de sécuriser cela.

    • Alors ce n’est pas forcément  » par internet « , ce que je décris ici (Même si cela se passe par url) reste local (Il faut être connecté en wifi à la box). Actuellement, mon système fonctionne également par internet, mais je passe par un serveur dédié avec un système de session ;)

  2. Génial le montage. Je cherche depuis un moment un montage de ce type . Merci pour les codes Arduino, en revanche je bloque un peu sur l’application sous Android. Est il possible de mettre en ligne l’application Android ?

    Merci et bravo pour le travail réalisé

    • Malheureusement non, le code est complètement  » sale  » et contient d’autres choses par ci par là, mais il y a de très bons tutoriaux sur le site du zéro qui sont beaucoup plus instructif que mes sources ;)

  3. Bonjour GJ vraiment grand merci pour ce tuto très très utile je suis très content des tutos du genre sont rarissimes de nos jours.
    Par contre j’ai une question en terme de coût et autre est-il possible de mettre au point le même système en utilisant une carte arduino uno et un module wifi.De ce fait on pourra interagir directement avec la carte arduino à l’aide d’un portable sous android par exemple qui enverra directement les données via l’adresse de la carte arduino.Ainsi on aurra plus besoin du module principale

    • Ha mais totalement ! Ce système de module a été mis en place pour des raisons économique, mais si les moyens sont là pour mettre du wifi à toutes les bases arduino, il ne faut pas hésiter à se faire plaisir !

  4. Bonsoir GJ Ton tuto est très utile ! Merci.

    Mais est il possible d’avoir le code arduino exécutant compatible avec le Shield Ethernet officiel ?

    Merci de ton aide

  5. salut bravo pour ce tuto franchement super!!!!
    je voulais savoir si il est possible de brancher une carte avec module relay IO directement sur les fusible du disjoncteur pour ne pas avoir besoin de faire de branchement sur chaque interrupteur de la maison.
    Si oui en laissant le relay allumer toute le journée n y a t il pas un risque de surchauffe du relay?

    merci de ton aide

    • Salut, content qu’il t’ai plu !

      Pour le disjoncteur, renseignes-toi auprès de quelqu’un de vraiment qualifié en électricité, mais je ne vois pas de soucis (Sous réserve que tu laisses le fusible remplir son rôle, il doit toujours faire office de protection en cas de surcharge). Tout dépend aussi comment tes circuits sont réalisés, j’ai par exemple toutes les ampoules du salon reliées au même fusible dans le disjoncteur.

      Quand au relais, disons que c’est son rôle, il n’y a pas de raison qu’il surchauffe si on lui envoie la bonne tension !

      Encore une fois, renseignes-toi auprès de quelqu’un qui s’y connait !

      • dernière question ;à
        penses tu qu il serait possible de brancher un ipx-800 dans l armoire électrique en wifi

        , merci de ta rapidité

        • En théorie oui, mais ça me parait complètement disproportionné niveau prix. La IPX-800 est seulement équipé d’un port Ethernet, il faut imaginer tout un dispositif pour ajouter une connectivité wifi… Mais je comprends qu’avoir les applications toute prête comme cette carte en dispose soit plus avantageux. A toi de voir si tu as l’argent pour ! Mais réfléchis bien à comment l’arranger en wifi !

  6. Salut super tuto mais j’ai une question,

    Comment alimenter, le module exécutant de l’arduino ?
    Car je pense que le principal est alimenter via la box mais les autres ?

    • Ha pour ça il faut avoir la possibilité de faire arriver un + et un – pour raccorder un transformateur 220v -> 5v. J’ai eu la chance d’avoir des prises proche à chaque fois pour y faire partir deux fils pour alimenter les modules !

  7. Salut,

    C est interessant moi je vais passer en rj45 donc pas besoin de la carte principale mais ma question est
    Comment brancher les interrupteur ?
    Je coudrais les brancher classiquement en va et vien avec le relay, ceci permet d eteindre et d allumer meme si l arduino est hs
    Mais par contre comment savoir l etat des lampes pour faire par exemple « tput eteindre » ?

    • ouai j’ai le même problème :

      >Soit tu met un capteur de lumière et du coup tu prends des transmetteurs bidirectionnels (pour le retour du capteur). Mais ça te donne juste l’état, si ton interrupteur est appuyé alors extinction manuelle !

      >Sinon tu met des télé-rupteurs + capteurs (voir mon commentaire plus bas !)

  8. Bonjour

    Génial votre projet.
    Je voudrais faire de même mais juste pour piloter mes volets roulants.

    Toutefois je ne comprends pas comment fonctionne la partie Relays vers les volets ?

    Tu envois juste un signal électrique au volet qui en fonction de son état initial monte ou descend ?

    Merci de ton aide.

    • Salut, je ne pourrai pas précisément te répondre car j’imagine qu’il existe pas mal de configuration de volets roulant. Chez moi, j’ai réussir à m’en sortir avec deux relais (A ma grande surprise, les commandes du volet étaient en 220v !!), et il y’en a un qui a laissé sa peau pendant les premiers tests. Le plus simple (Et le moins dangeureux) serait d’avoir un volet avec télécommande pour ne bricoler que celle-ci (Avec un optocoupleur par bouton).

  9. Bonjour et bravo pour votre travail.
    Serait il possible de piloter les relais en mode impulsionnel ?
    C est à dire faire coller le relais tant qu on appuie sur son bouton de commande ?
    Merci d avance

  10. Énorme projet ! Moi qui finissait par désespérer avec un serveur xpl, mais pas besoin !

    Et sinon pour avoir le retour sur des capteurs (temp., niveau haut/bas stores, lumière, …) il faut utiliser des transmetteurs bi-directionnels de manière à renvoyer vers l’arduino maître ! (NRF24L01 ~2€ les 2 sur ebay)
    Mais là je sais pas vraiment comment afficher le résultat sur l’app android …?(j’ignore comment les requêtes sont gérées par le shield)

    Sinon pour les arduino je me fournis aussi sur ebay ~6€ l’arduino pro mini ! du coup on en commande 4/5 ! Idem pour les relais (~1.5€ l’unité et 2€ les 2) !

    Pour les personnes faisant construire : il faut passer des câbles ethernet blindés un peu partout dans la maison ! comme ça on utilise un shield par module avec un POE (power over ethernet) qui alimente l’arduino grâce au câble ethernet !

    Le shield ethernet sur ebay ~5€

    Pour l’alim des arduino, soit on se trouve à coté d’une prise (*) ou d’une source, soit on utilise une pile (WTF !??!): Oui mais alors il faut utiliser le mode veille des transmetteurs et de l’arduino (lib.: Enerlib).

    (*) toujours ebay pour les convertisseurs 230V vers usb/5V ~2€ ou encore des vieux adaptateurs qui traînent
    à modifier (sortir du plastique, un radiateur pour diffuser, …)

    Reste une question : Les interrupteurs ?

    > Soit comme chez moi avec des télérupteurs au tableau électrique (relais mécaniques qui passent du niveau haut>bas et inversement par une même impulsion) qui sont relié aux interrupteurs en // (permet d’avoir plus de 2 interrupteurs par lumière contrairement au va-et-vient). Dans ce cas là pas de problème ! on monte un seul arduino sur le compteur et c’est parti !
    >Soit on a des va-et-vient classiques, dans quel cas on fait comment ? car si la lumière est allumée avec un interrupteur, on ne pourra pas l’éteindre avec l’arduino et inversement ! On utilise des télérupteurs (relais bistables)?

    Sinon ceux qui sont pas à l’aise avec le dev. d’app. android, il y a évidement l’AppInventor, mais si j’ai le temps, je vous ferais une app complètement paramétrable (Si j’ai le temps …)

  11. Bonjour,

    tout d’abord merci pour ce tuto très instructifs.
    Par contre, il y a un point qui reste flou.

    Je ne comprend pas comment les arduino « esclaves » comprennent qu’ils ont du boulot à faire ou non vu que le mettre envoie un signal dans tout l’appartement.

    • L’arduino maitre envoie un code dans tout l’appartement !
      Chaque arduino esclave répond a un ou plusieurs codes différents selon les esclaves !
      Ainsi si on envoie le code A-D1-0
      La sortie D1 de l’arduino A se met à 0 car l’arduino A recherche uniquement ce code !

  12. Salut, excellent tuto !!

    Je cherche à faire un peu la même chose a ceci près que j’utilise un raspberry PI (distribution raspian) et que mes récepteurs/relais sont des recepteurs chacon.

    Cependant je me heurte a deux problèmes épineux et je me disais que tu pourrais peut être m’aiguiller :

    1) Je n’ai trouvé aucune doc relative a la construction(modulation/démodulation) d’un signal, y a t’il des normes? Qu’utilise tu comme séquence ? Séparés par cb de µs ? Sait tu comment je pourrais trouver la séquence de mes chacons?

    2) Raspian ne fonctionne pas en temps réel, j’ai peur que ça pose problème concernant la génération d’un signal (les délais en µs étant relativement précis et le temps d’exécution d’un script relativement aléatoire).

    Troisième petite question pour le fun (optionnelle) : as tu déjà pensé aux commandes par reconnaissance vocale ? Si oui quelle librairie as tu utilisé ( sans parler de bêtes webservices type apple/google & co). Pour le moment j’utilise la librairie speech de microsoft mais j’aimerais me désolidariser de l’intervention de microsoft dans mon projet.

    Amicalement,

    Idle

  13. Bonjour
    Excellent tuto ça m’aide beaucoup actuellement à la réalisation d’un système pareil.
    Cependant j’ai une question. Si je monte mon interrupteur et mon arduino en système de va et vien pour permettre d’allumer la lampe aussi bien bien avec l’interrupteur que ma carte arduino comment ferais-je pour connaitre l’état de ma lampe au niveau de mon arduino si je l’ai allumé avec mon interrupteur?
    J’espère que je me suis bien exprimé :D

    • deux variable te seront necessaire du style :
      boolean ancienEtat = false/true; (l’interupteur est dans l’etait bas ou haut suivant l’etat de depart)
      boolean etatActuel = digitalRead(interrupteur);
      int bascule = 0; (tu comprendra après)

      if (ancienEtat != etatActuel) //si l’interrupteur à changé de position
      {
      bascule = 1 – bascule;
      }
      //ainsi si la bascule est à 1, elle passe a 0 et inversement ^^

      if (bascule == 1)
      digitalWrite(lumiere, HIGH);
      else
      digitalWrite(lumiere, LOW);

      tout ceci n’est qu’un exemple comme ça sans essais mais je pense que si tu arrive a comprendre le principe tu pourras faire ce que tu souhaite

  14. c’est vraiment Énorme ce que vous avez partagé avec nous !! je vous félicite
    Je vais essayer tout comme vous et j’espère que cela marcherai .. Est ce que vous êtes disponible pour toute interrogation ?? Merci d’avance

  15. Bonsoir.

    Article très intéressant, et solutions peu coûteuses !
    Je compte tenter l’expérience dans mon nouvel appartement, mais soucis : Je suis locataire ! (pas question de faire des trous, donc)
    Je peux contourner le problème en utilisant des multiprises (enfin je pense), mais j’ai vu qu’il existait des prises « radio » (contrôlables à distance), donc dans mon cas (je n’avais aucune notion en électronique il y a 3 jours) c’est peut être plus sûr, et ce n’est pas plus cher (pour remplacer le module exécutant).

    Pour le module principal, j’aimerais en fait économiser le shield ethernet : L’USB permet de faire passer à la fois le courant et de la data. Or, dans mon cas, ma « box » est un routeur de type WRT/Tomate (en gros, j’ai un accès « root » dessus, et je peux compiler et exécuter des programmes), donc je pensais utiliser ce port USB pour envoyer les commandes reçue à l’Arduino (ou du moins tout le côté qui ne nécessite pas le temps-réel).

    Cela me permettrait d’économiser encore + (15/30 euros) sur l’installation domotique.

    Qu’en penses-tu ? C’est faisable ?

  16. Yop,
    très bon tuto
    Juste un détail : le site SparkFun que tu conseilles est situé aux US!
    Du coup, en plus des frais de port j’ai du payer
    32 euros de frais de douanes!
    Un peu cher pour une installation économique.

  17. Au temps pour moi, j’ai confondu les commandes!
    Le site SparkFun ne réclame pas de droit de douanes, par contre ils sont assez longs.
    Je vous déconseille fortement MiniInTheBox.com, c’est un site Chinois avec des prix attractifs mais qui vous assomment par la suite avec des frais prohibitifs!

  18. Bonjour ,
    Félicitation et merci pour ce tuto !!

    Est il possible de partager le code Android AppInventor même si il est d’après vous un peu « sale » …j’aimerai voir le principe pour appeler les url ?

    merci

    chris

  19. Tout d’abords, félicitation pour ce projet que je trouve passionnant et le tutoriel très bien expliquer. Cela me donne envie de m’y mettre moi aussi.
    Je voudrais garder les interrupteurs physiques mais je ne vois pas comment réaliser cela car si je relis interrupteur physique et la commande de l’arduino en parallèle , cela fonctionnera toujours si l’un ou l’autre est activé.
    Or je voudrais par exemple: je rentre dans mon appartement, j’allume la lumière avec le bouton physique, je puisse l’éteindre avec l’arduino sans ré-appuyer sur le bouton physique.
    J’ai peut être une idée avec les bascules mais j’aimerai avoir votre avis.
    Merci de vos réponse,
    Cordialement

  20. @Jeremy
    Il te suffit de faire un montage en va et vient
    Si c’est pas pour une nouvelle installation, il vaut mieux remplacer les interrupteurs physiques par des télérupteurs + commande par l’arduino .

  21. Bonjour ,

    Tres sympas que ce que vous avez fait , je reve de le réaliser chez moi .

    pouvez vous m’aider de le realiser chez moi dans ma villa de vacance dans un endroit magique en proffitons de passer des bonne vacance pas luin de la mer .

    Cordialement
    A.Rouached

  22. Bon le montage fonctionne très bien entre deux pc reliés via les modules 433mhz
    Par contre j’ai quelques soucis pour mettre des alimentations rendant le module recepteur independant
    J’ai acheté des alimentation 5v 1A, la carte est bien alimentée mais elle ne fonctionne pas correctement
    Quel type d’alimentation avec vous utilisée, et sur quel site peut on se fournir?
    merci.

    • Perso,
      j’ai utilisé des transfo 230V > Usb
      (environ 1.5$ l’unité sur ebay) et ça marche !
      Après on peut le démonter pour le cacher dans les blocs interrupteur !

  23. Bonjour mon projet est similirairement identique ( bac) on souhaite controler une maison par le vocal de l’iphone j’aurais voulu savoir si il etait possible d’avoir plus d’information sur le controle des lumiere de par le bouton mural et par l’arduino, des schéma de branchements avec les relais par exemple et aussi concernant vos volet roulants comment les branchez vous et comment les utilisez vous ( mural + smartphone ou juste smartphone )
    Merci

  24. Bonjour,

    Voila j’ai déjà chez moi des volets roulant électrique à commande distant. Comment je peux faire afin de synchroniser mon Arduino avec émetteur 434 et mes volets roulant communique entre eux. Il y à surement un « code » qui doit être échangé afin que le volet roulant puisse interpréter la demande.
    Merci pour ton aide.
    Stéphane.

    • Salut,

      Il y a certainement un code effectivement, à voir en fonction de la marque de ton volet. Sinon tu peux prendre la télécommande et y mettre des optocoupleurs sur les boutons pour contrôler depuis un module arduino la télécommande qui émettra le signal (Un peu tordu mais parfois plus rapide à bricoler).

  25. Bonjour,

    Est-il possible d’alimenter l’arduino avec le secteur en déviant les fils de l’ampoule ? De sorte à ne pas avoir à brancher un transformateur sur une prise.

    Comment as tu fais toi ?

    Merci !

    • Salut,

      Il est possible d’utiliser les fils pour alimenter l’arduino oui, à condition d’utiliser un transformateur adéquat. J’utilise un transformateur similaire aux chargeur portable (Souvent avec un embout USB, tant qu’ils sortent du 5v). La difficulté étant de le placer dans l’emplacement des interrupteurs qui est – trop – souvent petit.

  26. Bonjour,
    Bravo pour ce tuto ! J’ai l’ambition de faire un peu la même chose à la maison. J’ai réussi à contrôler des périphériques (220V) à l’aide de mon arduino et des relais. Concernant le fonctionnement générale, est-ce que c’est obligé d’avoir un arduino sur chaque prise ? Si tel est le cas, ne connais-tu pas une alternative qui serait moins couteuse et surtout moins fastidieuse à mettre en place ?
    Je te remercie d’avance pour ta réponse et encore bravo !!!

    • Pas vraiment d’autre solution !

      Si ce n’est câblé tout, mais bon dans une maison existante …

      Sinon pour que ce soit moins cher il suffit de commander les composants en chine (~3.5€ l’arduino nano)

      après tu peux peut être regrouper certaines prises (même cloison), sinon il y a toujours la possibilité de câbler au tableau électrique pour les lampes (moi j’ai des télérupteur sur chaque lampe donc c’est parfait)

  27.  » appuie sur quelques boutons. Le volet se ferme, les lumières s’éteignent, le vidéo projecteur s’allume, la toile descend lentement »
    Cool j’ai des interrupteurs qui font pareil!

    • J’imagine que l’intérêt est de pouvoir centraliser sur la même plateforme, l’exécution de plusieurs « scènes » comme on dit en éclairage… (: mode « film », mode « lumière tamisée », mode « grand soleil » etc… Cela dit il faut tout de même que ça reste simple à déclencher, sinon on perd tout l’intérêt.

      • Tout à fait. Cela peut-être un simple widget sur portable ou application à portée de main. Voir même en commande vocale si la maison est équipée ;)

  28. Bonjour!
    Merci d’avoir publié ce magnifique article! Seulement deux petites questions: peut tu remettre le liens de tes relais? Il n’est plus valable! Et quelles parties du code sont à adapter pour un usage perso? Merci d’avance!

  29. I read a lot of interesting posts here. Probably you spend a lot of time writing,
    i know how to save you a lot of work, there is an online tool that creates
    high quality, google friendly posts in seconds, just search in google – laranitas free content

  30. Bonjour,

    je souhaiterais réaliser à peu près un système domotique similaire au votre et j’aurais grand besoin de vos conseils, pourriez-vous me contacter à l’adresse indiqué s’il vous plait.

    Merci par avance.

    Dum

  31. bonjour,

    super boulot,
    je debute dans un projet assez similaire mais je suis vraiment noob, pourriez-vous plus commenter (en fait beaucoup plus) vos codes arduino s’il vous plais car au point ou j’en suis je ne comprend pas un dixieme de ce qui est ecrit.

    par avance merci.

  32. Envoyer moi le code de la partie android s’il vous plait car j’ai une problème pour l’envoie de l’ordre depuis android vers la carte arduino

  33. Very informative post, i am regular reader of your blog.
    I noticed that your blog is outranked by many
    other websites in google’s search results. You deserve
    to be in top-10. I know what can help you,
    search in google for:
    Omond’s tips outsource the work

  34. Salut GJ,

    et bravo pour cette installation.

    J’aurai, à mon tour, une (au moins) question. Je présente mon projet.
    J’ai une box domotique qui peut générer des ordres http. Je souhaiterais commander des électrovannes par cette box. J’ai pensé aux cartes arduino.

    Puis-je me servir d’une simple carte d’extention « Ethernet shield » + une carte de relais ?
    Ou
    Dois-je forcément me procurer une carte arduino Uno + extension Ethernet shield + carte de relais ?

    En bref, vu que je me sers d’une box domotique, il me faut simplement des relais pilotables à distance. Que me conseilles-tu, GJ ?

    VinceDuSud

  35. Bonjour,
    Super installation. les boutons mode cockpit c’est pas mal.
    J’ai fait qqch de simulaire récemment avec des interrupteurs va et vient. j’embarque le système de commande derrière chaque interrupteur piloté en radio vers mon Rpi qui est au niveau de mon tableau électrique. pour gain de place derrière l’inter, j’ai optimisé en utilisant un attiny85… cela fonctionne bien. Cependant, avec un montage en va et vient + relais board, je n’ai pas de retour d’état. si je ne suis pas dans la pièce je n’ai pas possibilité de savoir si lumière est allumée ou éteinte.
    j’ai donc décidé de ne pas brancher l’intérrupteur sur la phase de l’alimentation électrique mais sur une broche interruption de mon µC avec une résistance de tirage et au +5V, si appui sur le bouton, je peux connaître l’état et je peux switcher le relais. idem pour le récepteur radio connecter en entrée. inconvénient: si le sytème tombe en panne, le relais va rester dans la position actuelle à savoir lumière tjrs éteinte ou allumée en permanence.

    Qu’en pensez-vous? avez-vous cabler de cette façon vos inter en entrée de votre arduino ou sur une broche d’interruption? afin d’avoir un retour d’état?

  36. Merci pour ton article. Même si le coté « technique » peut faire un peu peur de prime abord à la plupart d’entre nous, cela donnera envie à certains d’installer ou de faire installer de la domotique chez eux …
    As tu mis une serrure connectée, depuis ?

Répondre à fraborak Annuler la réponse.

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

*

Vous pouvez utiliser ces balises et attributs HTML : <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>