Domotique DIY – Partie 3 – Hack des prises télécommandées

Nous allons se pencher cette fois ci sur la possibilité d’intégration de prises télécommandées que nous pouvons trouver un peu par tout. Elles sont vendues avec leurs télécommande et utilisent le protocole 433 Mhz que nous voulons exploiter. Quelques exemples sur les photos:

Prises télécommandées

Prises télécommandées

Prises télécommandées

Prises télécommandées

Attention a bien choisir les prises a protocole 433 MHz

Interception des codes envoi/réception de chaque prise.

La librairie 433Utils installé dans la Partie 2 nous permettra de déterminer les codes de chaque prise. Pour cela il sufit de vous conecter a votre Box DIY (notre RPi configuré dans la Partie 1) en SSH avec Putty par exemple.

Putty_SSH

Putty_SSH

saisissez le code suivant:

1
2
cd ~/433Utils/RPi_utils
sudo ./RFSniffer
cd ~/433Utils/RPi_utils
sudo ./RFSniffer

il vous reste maintenant a diriger votre télécommande vers votre Raspberry et appuyez sur les boutons.
Et la par magie votre code apparaît.

RF433 Réception code

RF433 Réception code

Copier le précieusement en précisant le numéro de chaque bouton.
Il ne reste plus qu’a utiliser ces codes avec notre RPi pour pouvoir commander nos prises. Pour cela nous allons coder un peu en C++ et PHP.
Pour envoyer le code vers une prise nous allons également utiliser la bibliothèque RCSwitch

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
/*
 * Usage: ./send <numéro prise><command>
 * Command is 0 for OFF and 1 for ON
 * 
1 on - 327662
01001111111111101110
1 off - 327679
01001111111111111111
2 on - 
01001111111101101100
2 off - 
01001111111101111101
3 on - 
01001111111110101111
3 off - 
01001111111110111110
 *
 *    
 */
 
#include "RCSwitch.h"
#include <stdlib.h>
#include <stdio.h>
 
int main(int argc, char *argv[]) {
 
  /*
   * output PIN is hardcoded for testing purposes
   * see https://projects.drogon.net/raspberry-pi/wiringpi/pins/
   * for pin mapping of the raspberry pi GPIO connector
   */
  int i = 0;
  int PIN = 0;
  int command  = atoi(argv[1]);
 
  if (wiringPiSetup () == -1) return 1;
  RCSwitch mySwitch = RCSwitch();
  mySwitch.setProtocol(3);
  mySwitch.enableTransmit(PIN);
 
    
  switch(command) {
        case 11:  // 1 a ON
            for (i=1; i<10; i++) {
            mySwitch.send("01001111111111101110");
            delayMicroseconds(810);
            }
            break;
        case 10:  // 1 a Off
            for (i=1; i<10; i++) {
            mySwitch.send("01001111111111111111");
            delayMicroseconds(810);
            }
            break;
        case 21:  // 2 a On
            for (i=1; i<10; i++) {
            mySwitch.send("01001111111101101100");
            delayMicroseconds(810);
            }
            break;
        case 20:  // 2 a Off
            for (i=1; i<10; i++) {
            mySwitch.send("01001111111101111101");
            delayMicroseconds(810);
            }
            break;
        case 31:  // 3 a ON
            for (i=1; i<10; i++) {
            mySwitch.send("01001111111110101111");
            delayMicroseconds(810);
            }
            break;
        case 30:  // 3 a Off
            for (i=1; i<10; i++) {
            mySwitch.send("01001111111110111110");
            delayMicroseconds(810);
            }
            break;
        default:
            printf("./send Numéro Prise+1=On ou 0=Off");
            return -1;
    }
      
      
  return 0;
}
/*
 * Usage: ./send <numéro prise><command>
 * Command is 0 for OFF and 1 for ON
 * 
1 on - 327662
01001111111111101110
1 off - 327679
01001111111111111111
2 on - 
01001111111101101100
2 off - 
01001111111101111101
3 on - 
01001111111110101111
3 off - 
01001111111110111110
 *
 *    
 */

#include "RCSwitch.h"
#include <stdlib.h>
#include <stdio.h>

int main(int argc, char *argv[]) {

  /*
   * output PIN is hardcoded for testing purposes
   * see https://projects.drogon.net/raspberry-pi/wiringpi/pins/
   * for pin mapping of the raspberry pi GPIO connector
   */
  int i = 0;
  int PIN = 0;
  int command  = atoi(argv[1]);

  if (wiringPiSetup () == -1) return 1;
  RCSwitch mySwitch = RCSwitch();
  mySwitch.setProtocol(3);
  mySwitch.enableTransmit(PIN);

    
  switch(command) {
        case 11:  // 1 a ON
            for (i=1; i<10; i++) {
            mySwitch.send("01001111111111101110");
            delayMicroseconds(810);
            }
            break;
        case 10:  // 1 a Off
            for (i=1; i<10; i++) {
            mySwitch.send("01001111111111111111");
            delayMicroseconds(810);
            }
            break;
        case 21:  // 2 a On
            for (i=1; i<10; i++) {
            mySwitch.send("01001111111101101100");
            delayMicroseconds(810);
            }
            break;
        case 20:  // 2 a Off
            for (i=1; i<10; i++) {
            mySwitch.send("01001111111101111101");
            delayMicroseconds(810);
            }
            break;
        case 31:  // 3 a ON
            for (i=1; i<10; i++) {
            mySwitch.send("01001111111110101111");
            delayMicroseconds(810);
            }
            break;
        case 30:  // 3 a Off
            for (i=1; i<10; i++) {
            mySwitch.send("01001111111110111110");
            delayMicroseconds(810);
            }
            break;
        default:
            printf("./send Numéro Prise+1=On ou 0=Off");
            return -1;
    }
      
      
  return 0;
}

 

Il suffit de compiler le code puis le tester. (Attention le code change selon les prises).

L’usage est simple:
./send <numéro prise><commande>

Commande:  0 pour OFF et 1 pour ON
Exemple de commandes:

Allumer la prise 1
./send 11

Éteindre la prise 1
./send 10

Allumer la prise 2
./send 21

Éteindre la prise 3
./send 30

Nous pouvons facilement commander l’allumage et extinction des nos prises en ligne de commandes mais nous voudrions aussi de les inclurent dans Domoticz. Pour cela nous allons utiliser le périphérique virtuel « Dummy », mais avant il faut pouvoir lancer notre code via une page web. Alors au boulot, nous allons écrire quelques lignes en PHP pour pouvoir exécuter notre send.cpp via une page web.

1
2
3
4
5
6
7
8
9
10
11
12
<?php
// API actioner les prises
// ./send <numero Prise><on/off>
// on = 1
// off = 0
// exemple ./send 10
$prise = $_GET['prise'];
$etat = $_GET['etat'];
system('sudo ./send '.$prise.$etat, $retval);
print_r ($retval) ;
 
?>
<?php
// API actioner les prises
// ./send <numero Prise><on/off>
// on = 1
// off = 0
// exemple ./send 10
$prise = $_GET['prise'];
$etat = $_GET['etat'];
system('sudo ./send '.$prise.$etat, $retval);
print_r ($retval) ;

?>

le principe et le même que notre code send.cpp pour l’utiliser il suffit d’appeler la page send.php avec une variable prise et une etat sous la forme:

send.php?prise=1&etat=1 

L’intégration dans Domoticz.

– Configuration

Configuration

Configuration

– Matériel

Matériel

Matériel

– Sélectionner Dummy et donner un nom par exemple Prise_1

Dummy

Dummy

– Cliquer sur « Capteur virtuel »

Capteur virtuel

Capteur virtuel

– Sélectionner Interrupteur

Interupteur

Interrupteur

– OK

Création

Création

– Dans Interrupteur / ajout manuel

Ajout Interrupteur

Ajout Interrupteur

– Sélectionner la Prise_1 de Type X10

 

X10

X10

– Cliquer sur éditer

Edition

Edition

– remplir Action On et Off comme suit

On/Off

On/Off

– Votre prise et prêt a emploi

Prise Finie

Prise Finie

– recommencer pareil avec les autres prises

Le Tuto en vidéo

32 réflexions au sujet de « Domotique DIY – Partie 3 – Hack des prises télécommandées »

  1. Bonjour,
    superbe article en 3 parties.
    C’est a un detail pres, exactement ce dont j’avais besoin.

    Le detail ? Et bien j’utilise un rfxcom sur un PC avec Domoticz. Savez-vous si les outils 433utils existent dans une version compatible rfxcom ?

    Ou si il y a une astuce pour remplacer le code vers le wiringpi par un code pour interroger le rfxcom ?

    Merci d’avance pour vos reponses, et encore bravo pour l’article
    Benoit

  2. Bonjour Benoit et bien venu sur le site,
    Je ne comprend pas très bien ta question:
    « Savez-vous si les outils 433utils existent dans une version compatible rfxcom  »
    RFXCom est directement compatible avec Domoticz.
    Vous voulez faire quoi exactement ?

  3. Bonjour,
    excusez-moi je me suis peut-etre mal exprimé.
    En effet, Domoticz et RFXCom fonctionnent tres bien ensemble.

    Par contre, j’ai achete il y a qq temps un pack telecommande et 3 prises (ressemblant fortement a la photo de droite), qui, bien qu’etant sur la fréquence 433Mhz, n’est pas detecté par le RFXCom.
    D’après mes recherches, la télécommande utilise le protocol DASH7, non reconnu par le firmware du RFXCom (à ce jour)

    A la lecture de votre article, je pensais avoir trouvé la solution, par l’intermediaire des programmes de 433utils, pour piloter ces prises par l’intermediaire de Domoticz. (j’aurais recupere le signal, mis dans un script qui aurait ete execute lors d’une action dans Domoticz).

    Comme à priori, les programmes 433utils se basent sur WiringPi, je ne peux l’exploiter. (mon Domoticz tourne sur un PC Debian avec RFXCom)
    D’ou le sens de ma question, si vous connaissiez un equivalent qui me permettait de recevoir les messages et surtout d’envoyer par script ces commandes.

    Cordialement,
    Benoit.

    • Bonjour Benoit,
      Oui je comprend mieux maintenant.
      Par contre si tu es sur que tes prises ne sont pas compatibles avec RFXCom alors il te faut trouver un autre émetteur compatible,
      ce n’est pas en changeant les bibliothèques ou le soft que cela deviendra compatible.

  4. Bonjour,
    super tutoriel, j’ai commencé à faire ma propre box domotic il y a deux jours, mes plans utilise un PI2 et des module Aurel !
    Le code du send.cpp diffère de mon coté j’ai un unitcode et un sytemcode a rentrer puis la commande 0 ou 1 pour le on / off.
    A mon sens il faudrait ajouter les test de fonctionnement, le sniffer est simpa pour savoir si tout est ok, pour vérifier l’émission j’ai ouvert 2 putty (je suis en SSH sur mon PI2) l’un avec le sniffer, l’autre avec des sudo ./codesend 12345.
    Je pense utiliser un php appelant la commande codesend plutot que le send, cela m’évitera de devoir recompiler le send.cpp a chaque fois que j’ajouterais un périphérique sur domoticz.
    Je suis à l’affut de tes prochains tuto ! 🙂

  5. Bonjour à tous,

    nouveau venu sur le site et sur la domotique sur framboise en général, je m’essaye progressivement à différents montage.
    Je cherche notamment, comme beaucoup à piloter les fameuses prises 433 Mhz (les miennes ressemblent comme 2 gouttes d’eau à celles de la photo de droite en haut de la page).
    j’ai fait les montages proposés.
    a priori ils sont bons par si je fais un RFsniffer, j’obtiens bien un code à 7 digits de la part de chaque bouton de la télécommande.
    Si j’ouvres 2 fenêtres putty, une avec Rfsniffer; une avec codesend, le code que j’envoi est bien « sniffé ».
    par contre pas moyen de faire commuter la moindre prise avec le raspberry.
    j’arrive à faire fonctionner codesend mais uniquement en boucle entre l’émetetteur et le récepteur; pas moyen de faire commuter la prise (pas de messages d’erreur reçu)
    par contre dès que j’essaie ./send, quelques soient les combinaisons, j’obtiens systématiquement une « erreur de segmentation »; j’ai essayé plusieurs combinaisons, (0 ,1 , on off…) et toujours le même résultats.
    quelqu’un a-t-il une idée pour me faire progresser ?

    merci; Denis

  6. Bonjour,

    désolé pour ce retour tardif.
    j’ai le consend.cpp suivant :

    ‘codesend’ hacked from ‘send’ by @justy

    – The provided rc_switch ‘send’ command uses the form systemCode, unitCode, command
    which is not suitable for our purposes. Instead, we call
    send(code, length); // where length is always 24 and code is simply the code
    we find using the RF_sniffer.ino Arduino sketch.

    Usage: ./codesend decimalcode
    (Use RF_Sniffer.ino to check that RF signals are being produced by the RPi’s transmitter)
    */

    #include « RCSwitch.h »
    #include
    #include

    int main(int argc, char *argv[]) {

    // This pin is not the first pin on the RPi GPIO header!
    // Consult https://projects.drogon.net/raspberry-pi/wiringpi/pins/
    // for more information.
    int PIN = 0;

    // Parse the firt parameter to this command as an integer
    int code = atoi(argv[1]);

    if (wiringPiSetup () == -1) return 1;
    printf(« sending code[%i]\n », code);
    RCSwitch mySwitch = RCSwitch();
    mySwitch.enableTransmit(PIN);

    mySwitch.send(code, 24);

    return 0;

    }

    et le send.cpp suivant :
    /*
    Usage: ./send
    Command is 0 for OFF and 1 for ON
    */

    #include « RCSwitch.h »
    #include
    #include

    int main(int argc, char *argv[]) {

    /*
    output PIN is hardcoded for testing purposes
    see https://projects.drogon.net/raspberry-pi/wiringpi/pins/
    for pin mapping of the raspberry pi GPIO connector
    */
    int PIN = 0;
    char* systemCode = argv[1];
    int unitCode = atoi(argv[2]);
    int command = atoi(argv[3]);

    if (wiringPiSetup () == -1) return 1;
    printf(« sending systemCode[%s] unitCode[%i] command[%i]\n », systemCode, unitCode, command);
    RCSwitch mySwitch = RCSwitch();
    mySwitch.enableTransmit(PIN);

    switch(command) {
    case 1:
    mySwitch.switchOn(systemCode, unitCode);
    break;
    case 0:
    mySwitch.switchOff(systemCode, unitCode);
    break;
    default:
    printf(« command[%i] is unsupported\n », command);
    return -1;
    }
    return 0;
    }

    toujours aucun résultats probants.

    Pour ce qui est du code présenté plus haut, j’ai systématiquement des erreurs lors de la compilation ;
    :45:49: warning: deprecated conversion from string constant to ‘char*’ en ligne 45, 57, 63…
    et : référence indéfinie vers « RCSwitch::RCSwitch() » …

    j’ai essayé d’autres codes, mais rien de plus pour le moment.
    je n’ai pas testé d’envoi direct de code binaire, je ne sais pas comment il faut le coder.

    merci d’avance
    Denis

    • Bonjour Denis,

      Pour commencer tu as 2 include(s) qui ne sert a rien.
      a mon avis il faut les remplacer par:
      #include
      #include

      Apres c’est une histoire de base, peut tu publier la commende que tu exécutes et qui provoque l’erreur.
      Le code que tu récupères et en base 10.
      Merci

  7. Salut,

    Le week-end a été riche en tests en tout genre, et enfin j’ai réussi à piloter une série de prises!! j’ai même avec un simple bout de fil de 17cm en guise d’antenne une super distance d’emission (maison 150 m2 sur 2 étages, et ça passe partout, y compris à travers la dalle de béton !!!).
    Je vais pouvoir continuer le développement, et notamment l’intégration dans Domoticz, mais je ne suis pas inquiet sur cette partie.

    Par contre sur 4 types de prises, un seul fonctionne. As-tu une idée qui permettrait d’avancer sur ce terrain pour décoder le protocole des autres, qui doit quand même être proche les unes des autres.
    Pour info, elles viennent toutes de la grande distribution.

    celles qui fonctionnent sont marquées :
    pas de marque; Ref 6899; importées par COMI; elles sont à dip-switches (5 pour la télécommande; 5 pour la prise); achetées il y a près de 10 ans à Intermarché.

    les autres : (les dernières achetées) : FHT7901 433.0(-434.79 Mhz Zhejiang Fuhaota Electric and tools PI 15137 avec également 10 Dip-switches ; pas comptaticle avec les précédentes, et dont je n’arrive même pas à sniffer le code emis par la télécommande.
    mais aussi Silvercrest IAN7423 type 10164 D (Lidl) sans switches (je n’ai plus la télécommande)
    et TechX ref 941, modèle BHC9938F (sans switches); j’en ai plusieurs qui fonctionnent avec la télécommande, mais je n’arrive pas à les commander avec la framboise.

    NB: j’arrive uniquement à commander les prises avec ./send que je t’ai envoyé dans le post précédent en utilisant la syntaxe : ./send code_binaire_a_5_bits_de_la_telecommande code_à_1_digit_de_la_prise_à_commuter (1 à 5 selon position des dipswitches) et 0 ou 1 pour éteindre / allumer
    Pas réussi à utiliser ./codesend.

    Merci par avance de ton aide.

    • Bonjour Denis,
      Content pour ta réussite,
      Pour les prise restante essai d’analyser le signale avec un oscilloscope, souvent certain producteur crypte le signale, le binaire inversé, précédé d’un 1 ou un 0 etc…..

      • salut et merci pour ce retour,
        je ne suis pas équipé en oscilloscope.
        par contre, aurais-tu sous le coude un tout petit script, simplifié à l’extrême, qui lirait de manière ultra simplifiée le port GPIO en entrée, relié au récepteur 433 Mhz, par exemple de manière synchrone (à une fréquence cohérente avec la porteuse je suppose) pour soit l’afficher soit le poser dans un fichier log.txt. peut-être ainsi en observant la différence de comportement entre le bruit de fond et une trame émise par une télécommande je pourrais peut-être avancer : bref un « RFSniffer » ultra simplifié, directement en binaire.

  8. Salut,
    j’essaye tant bien que mal de faire fonctionner mes prises phenix yc-4000s.
    j’ai sniffé le code de la telecommande pour chaques prises avec rfsniffer, puis je l’ai converti en binaire et mis dans le send.cpp.
    je precise que je ne connais absolument pas la programmation (je compte bientôt y remedier ^^)

    Je dispose d’un RPi 1ére generation. avec un autre tuto ca fonctionne parfaitement: https://arno0x0x.wordpress.com/2015/04/02/rf433-outlet/
    mais je prefere le tiens car je veux les integrer dans domoticz.

    lorsque je fait sudo ./send 11 rien ne se passe :/ et le sniffer ne detecte rien, de plus lors de la compilation j’ai ça:
    send.cpp: In function ‘int main(int, char**)’:
    send.cpp:49:50: warning: deprecated conversion from string constant to ‘char*’ [-Wwrite-strings]
    mySwitch.send(« 100000100010101010001 »);
    ^
    send.cpp:55:50: warning: deprecated conversion from string constant to ‘char*’ [-Wwrite-strings]
    mySwitch.send(« 100000100010101010100 »);
    ^
    send.cpp:61:50: warning: deprecated conversion from string constant to ‘char*’ [-Wwrite-strings]
    mySwitch.send(« 100000101000101010001 »);
    ^
    send.cpp:67:50: warning: deprecated conversion from string constant to ‘char*’ [-Wwrite-strings]
    mySwitch.send(« 100000101000101010100 »);
    ^
    send.cpp:73:50: warning: deprecated conversion from string constant to ‘char*’ [-Wwrite-strings]
    mySwitch.send(« 100000101010001010001 »);
    ^
    send.cpp:79:50: warning: deprecated conversion from string constant to ‘char*’ [-Wwrite-strings]
    mySwitch.send(« 100000101010001010100 »);
    ^
    send.cpp:85:50: warning: deprecated conversion from string constant to ‘char*’ [-Wwrite-strings]
    mySwitch.send(« 100000101010100010001 »);
    ^
    send.cpp:91:50: warning: deprecated conversion from string constant to ‘char*’ [-Wwrite-strings]
    mySwitch.send(« 100000101010100010100 »);
    ^
    g++ RCSwitch.o send.o -o send -lwiringPi
    g++ -c -o codesend.o codesend.cpp
    g++ RCSwitch.o codesend.o -o codesend -lwiringPi
    g++ -c -o RFSniffer.o RFSniffer.cpp
    g++ RCSwitch.o RFSniffer.o -o RFSniffer -lwiringPi

  9. Super tuto merci !!

    Moi j’en suis à essayer de récupérer le code de mes prises achetées chez Electro Dépôt (http://www.electrodepot.fr/prise-rf–prises-telecommandees-x-3-interieure.html) .

    En effet, le codesend est bien « snifé » et je recois bien le code tapé.

    Cependant lorsque j’utilise la télécommande rien ne se passe. L’emetteur de la télécommande est estampillé 433.92 Mhz et j’ai acheté émetteur/récepteur 433 Mhz (https://www.amazon.fr/gp/product/B00V4ISS38/ref=oh_aui_detailpage_o08_s00?ie=UTF8&psc=1).

    L’émetteur/récepteur en ma possession fonctionne t’il sur toute la bande 433 Mhz (y compris 433.92) ? Pensez vous que les télécommandes soient cryptées ? Avec quoi d’autre puis je faire un autre test ?

    Merci de votre retour.

  10. Bonjour et merci pour vôtre tuto,

    voilà je cherche à récupérer l’ID de communication de mes volet.

    j’ai pour celà un raspberry et un module rfxcom , pourriez vous me dire si celà est compatible avec les partie 2 et 3 de votre tuto ?

    merci par avance.

  11. Bonjour,

    Merci pour votre tuto ! J’ai réussi la quasi totalité des étapes mais je bloque au moment de créer le fichier PHP. Suffit il de créer un fichier avec la commande nano, de le nommer send.php et de copier le code que vous donner ? Je l’ai mis dans le répertoire /domoticz/scripts/php, est ce correct ?

    Une fois dans domoticz, l’adresse ip est elle celle du raspberry où est installé domoticz ?
    Si l’IP de mon rasp est 192.168.1.42, est ce que la synthaxe : http://192.168.1.42/domoticz/scripts/php/code.php?prise=1&etat=1 est bonne ?

    Merci et à bientôt !

Laisser un commentaire