On peut acheter des prises électriques télécommandées, bien pratiques pour allumer et éteindre des lampes ou équipements dans sa maison. Comment piloter ces prises avec une carte Arduino, un émetteur/récepteur radiofréquence AM 433,92 MHz et un peu de rétro-ingénierie ? Et surtout, comment faire mieux que la télécommande de base fournie avec ces prises ? Réponses avec des exemples.
Ce qui suit suppose que vous maîtrisiez l’interface de programmation Arduino.
Matériel
Côté Arduino :
- Une carte Arduino (Uno révision 3, par exemple).
- Un ensemble émetteur/récepteur RF AM 433,92 MHz acheté 1,55 € (frais de port inclus !) sur ebay… (ce modèle exactement)
Pour les prises télécommandées testées :
- Chacon® : télécommande modèle RSL366T, référence 54655 (Tx) ; prise modèle RSL3660R-F, référence 54655 (Rx).
 |
 |
 |
- Diagral® : télécommande modèle SOLO101F ; prise modèle SOLO111F.
Le décodage
Pour savoir comment piloter les prises avec son Arduino, il faut d’abord connaître le code à transmettre sur la fréquence. Ce code peut dépendre du fabricant, il est structuré différemment selon les modèles…
Pour cela, on utilise le module récepteur RF correctement branché à la carte Arduino, et la librairie rc-switch permettant de communiquer avec l’émetteur/récepteur RF.
Une borne DATA est reliée au pin #2 (= interrupt 0) de l’Arduino Uno. L’antenne est un fil gainé de 17,3 cm (antenne quart d’onde équivalent à 433,92 MHz).
Ouvrir le fichier d’exemple « ReceiveDemo_Advanced » fourni avec la librairie. Son contenu est :
|
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 |
/* Example for receiving http://code.google.com/p/rc-switch/ If you want to visualize a telegram copy the raw data and paste it into http://test.sui.li/oszi/ Need help? http://forum.ardumote.com */ #include <RCSwitch.h> RCSwitch mySwitch = RCSwitch(); void setup() { Serial.begin(9600); mySwitch.enableReceive(0); // Receiver on interrupt 0 => that is pin #2 } void loop() { if (mySwitch.available()) { output(mySwitch.getReceivedValue(), mySwitch.getReceivedBitlength(), mySwitch.getReceivedDelay(), mySwitch.getReceivedRawdata(),mySwitch.getReceivedProtocol()); mySwitch.resetAvailable(); } } |
Compiler, lancer le programme sur la carte et ouvrir la fenêtre du Moniteur série. Testons les deux télécommandes…
Télécommande Chacon
Cette télécommande permet de piloter 4 récepteurs, soit ON, soit OFF. À l’arrière de la télécommande se trouve un bouton sélecteur à 4 positions notées « I II III IV » qui permet de choisir un groupe de prises particulier, ou de ne pas interférer avec les prises du voisin. Plaçons le sélecteur de groupe en position « I ». Appuyons sur le bouton n°1, ON. Le résultat affiché sur le Moniteur série est :
|
1 2 3 4 5 6 |
Decimal: 1381717 (24Bit) Binary: 000101010001010101010101 Tri-State: 0FFF0FFFFFFF PulseLength: 438 microseconds Protocol: 1 Raw data: 13580,392,1352,396,1352,396,1352,1268,480,396,1348,1272,476,396,1356,1264,480,396,1348,1272,476,396,1352,1268,476,396,1348,1272,480,392,1352,1272,476,396,1352,1268,480,396,1348,1268,480,392,1352,1272,476,1268,480,1268,480, |
Nous avons : le code binaire, son équivalent en codage tri-state, la conversion des 24 bits en décimal (1381717), la longueur d’impulsion, le protocole reconnu, et les données brutes du signal reçu.
Faisons de même avec le bouton n°1 OFF :
|
1 2 3 4 5 6 |
Decimal: 1381716 (24Bit) Binary: 000101010001010101010100 Tri-State: 0FFF0FFFFFF0 PulseLength: 437 microseconds Protocol: 1 Raw data: 13576,396,1352,400,1348,396,1348,1272,480,396,1352,1268,480,392,1352,1272,476,396,1352,396,1352,396,1348,1272,480,396,1348,1272,476,400,1348,1272,476,396,1352,1268,480,396,1352,1268,480,396,1348,1272,484,1264,480,1268,480, |
Répétons ces opérations avec les boutons n°2, 3 et 4, et avec les autres positions du sélecteur de groupe « II », « III » et « IV ».
En notant les différences, on comprend rapidement que le codage sur 24 bits est formé par 3 séquences de 8 bits, soit 3 octets :
- 1er octet : correspond au codage du sélecteur de groupe : (code binaire ; code tri-state)
I : 00010101 ; 0FFF
II : 01000101 ; F0FF
III : 01010001 ; FF0F
IV : 01010100 ; FFF0
- 2e octet : correspond au codage du numéro du bouton : (code binaire ; code tri-state)
1 : 00010101 ; 0FFF
2 : 01000101 ; F0FF
3 : 01010001 ; FF0F
4 : 01010100 ; FFF0
- 3e octet : correspond au codage de l’action, ON ou OFF : (code binaire ; code tri-state)
OFF : 01010100 ; FFF0
ON : 01010101 ; FFFF
On sait maintenant quel code utiliser. Par exemple pour une prise dont le bouton sélecteur est sur « III » et dont le numéro est « 2 », si l’on veut allumer (ON) la lampe branchée dessus, il faut envoyer la séquence binaire : 010100010100010101010101 (code tri-states : FF0FF0FFFFFF). La sortie sur le Moniteur série indique aussi la conversion des 24 bits en décimal ; pour cet exemple : 5326165.
Télécommande Diagral
Cette télécommande permet de piloter 16 récepteurs, avec un sélecteur de groupe à 16 choix. De plus, cette télécommande contient une programmation horaire avec 12 programmes possibles, ce qui est bien pratique pour allumer et éteindre des lampes ou appareillages à certaines heures.
Le codage sur 24 bits est formé par 3 séquences de 8 bits, soit 3 octets :
- 1er octet : correspond au codage du sélecteur de groupe : (code binaire ; code tri-state)
A : 00000000 ; 0000
B : 01000000 ; F000
C : 00010000 ; 0F00
D : 01010000 ; FF00
E : 00000100 ; 00F0
F : 01000100 ; F0F0
G : 00010100 ; 0FF0
H : 01010100 ; FFF0
I : 00000001 ; 000F
J : 01000001 ; F00F
K : 00010001 ; 0F0F
L : 01010001 ; FF0F
M : 00000101 ; 00FF
N : 01000101 ; F0FF
O : 00010101 ; 0FFF
P : 01010101 ; FFFF
- 2e octet : correspond au codage du numéro du bouton : (code binaire ; code tri-state)
1 : 00000000 ; 0000
2 : 01000000 ; F000
3 : 00010000 ; 0F00
4 : 01010000 ; FF00
5 : 00000100 ; 00F0
6 : 01000100 ; F0F0
7 : 00010100 ; 0FF0
8 : 01010100 ; FFF0
9 : 00000001 ; 000F
10 : 01000001 ; F00F
11 : 00010001 ; 0F0F
12 : 01010001 ; FF0F
13 : 00000101 ; 00FF
14 : 01000101 ; F0FF
15 : 00010101 ; 0FFF
16 : 01010101 ; FFFF
- 3e octet : correspond au codage de l’action, ON ou OFF : (code binaire ; code tri-state)
OFF : 00010100 ; 0FF0
ON : 00010101 ; 0FFF
Comparaison des deux télécommandes
On remarque que les codes ne sont pas identiques, ce qui explique pourquoi la télécommande Diagral ne peut pas piloter les prises Chacon, et inversement… Les fabricants s’assurent ainsi que seules leurs prises seront compatibles avec leur télécommande, et qu’il n’y aura pas d’interférences entre les équipements.
Mais nous avons pu décoder les séquences et nous pouvons utiliser l’Arduino pour commander toutes les prises, sans besoin de télécommande des fabricants.
Le pilotage
Connaissant les séquences, nous pouvons les envoyer avec l’Arduino, via l’émetteur RF, correctement branché :
La borne DATA est reliée au pin #10 de l’Arduino (ou un autre, du moment que le code ci-après est adapté).
Faisons un petit code pour allumer/éteindre la prise de son choix. Afin de nous faciliter la tâche, assignons une fois pour toutes les codes des prises à des noms de variable « humainement compréhensible ». Ces variables ne contiennent pas la séquence en binaire mais le nombre entier correspondant aux 24 bits de la séquence binaire.
L’instruction mySwitch.send envoie une séquence correspondant au nombre entier contenu dans la variable, qui sera codé sur 24 bits. L’instruction delay(1000) sert juste à attendre 1000 ms avant de passer à l’instruction suivante. Dans cet exemple simple, on fait clignoter une fois la « lampe du bureau », puis la « lampe du salon », suivi d’une pause de 5 s.
|
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 |
#include <RCSwitch.h> RCSwitch mySwitch = RCSwitch(); unsigned long Lampe_bureau_OFF = 1310740; unsigned long Lampe_bureau_ON = 1310741; unsigned long Lampe_salon_OFF = 1327124; unsigned long Lampe_salon_ON = 1327125; unsigned long Lampe_entree_OFF = 1314836; unsigned long Lampe_entree_ON = 1314837; void setup() { Serial.begin(9600); // Emetteur connecté au pin #10 de l'Arduino mySwitch.enableTransmit(10); Serial.println("init "); } void loop() { Serial.print("allume "); mySwitch.send(Lampe_bureau_ON, 24); delay(1000); Serial.println("eteint "); mySwitch.send(Lampe_bureau_OFF, 24); delay(1000); Serial.println("allume "); mySwitch.send(Lampe_salon_ON, 24); delay(1000); Serial.println("eteint "); mySwitch.send(Lampe_salon_OFF, 24); delay(5000); } |
Et voilà.
Les améliorations possibles
Alors que les télécommandes sont limitées au pilotage de 4 ou 16 prises, sur 4 ou 16 groupes possibles, et seulement pour leur marque, le système Arduino permet de piloter autant de prise que l’on souhaite, et de différentes marques, pour autant que l’on aie trouvé la logique de codage.
On peut donc piloter 4×4=16 prises Chacon, et 16×16=256 prises Diagral, soit bien plus que ce qu’offrent les télécommandes d’origine. En faisant l’analyse pour d’autres prises, il doit être possible de piloter plusieurs prises de marques différentes, l’Arduino servant alors de « télécommande universelle ».
Un Arduino autonome, dont le programme contient des séquences d’allumage et d’extinction de prises en fonction de l’heure, de la luminosité ambiante ou d’autres capteurs, peut servir à fabriquer un simulateur de présence complexe, ou à déclencher simultanément un ensemble de prises, volets roulants, etc., selon les moments de la journée, chose qui n’est pas possible avec la télécommande Chacon.
En combinant le module RF récepteur sur l’Arduino, il est possible de télécommander l’Arduino pour lui faire exécuter des actions complexes. Par exemple l’appuie du bouton n°2 ON déclenche un programme, le bouton n°2 OFF déclenche un autre programme, etc.
Plusieurs Arduino munis des modules RF peuvent interagir ensemble, dans la limite où les signaux ne sont pas émis en même temps…
Cependant, on voit que le codage de ces prises reste simple et leur accès n’est pas sécurisé : il est possible de programmer l’Arduino pour émettre toutes les séquences binaires possibles et mettre une grande pagaille chez un voisin qui utilise ce genre de prises ! 😉 Mais ce n’est bien sûr pas la philosophie d’un véritable hacker.
Les systèmes télécommandés plus sécurisés, comme ceux des portails de garage, possèdent des codages plus complexes qui peuvent changer à chaque utilisation.
Bravo pour cette rétro-ingénieurie. Un premier pas dans la domotique, il ne reste plus qu’a écrire des scénari, et ajouter un module RTC pour arduino 🙂
Salut Clovis,
je viens de tester. Tout OK avec de vieilles prises EXTEL.
Je me suis amusé à piloter ces prises via internet (requête et/ou page web) ça marche. Il faut bien sur ajouter le shield internet sur la carte arduino UNO. Je vais intégrer ces prises dans ma domotique mais sur des systèmes qui ne demandent pas une haute sécurité bien sur !!
A plus
Merci pour le retour et content que cela aie pu t’aider ! A bientôt pour des discussions domoarduinesques 😉
Bonjour Sotiro
Je ne trouve ton post qu’aujourd’hui seulement, et je suis dans le même cas : j’ai une dizaine (au moins) de vieilles prises Extel que j’aimerais bien pouvoir piloter via arduino et internet. Peux-tu partager stp 1) le codage Extel 2) ta réalisation finale ? D’avance merci
Salut à toi et excellentes fêtes de fin d’Année. Je suis pour l’instant en déplacement mais pendant la semaine de mon retour (le 4) je te donnerai mon code pour mes prises extel. patience ……
JM
Bonjour, de retour sur terre ; voici quelques informations et des pistes pour toi :
Une fois que tu as tes codes ON/OFF de toutes tes prises (description par Clovis) tu pourras faire un sketch comme ci-dessous (Inspiration à partir de nombreuses réalisations sur le net) et l’implementer dans ton UNO. Avec le shield bien sûr. Tu as dans le cas que je te presente ici une page « minimaliste » qui possède les commandes ON/OFF avec leurs attributions (salon, chambre, etc). Bien sur tu pourras faire une page plus sympa en modifiant le code. Moi cela ne m’intéresse pas vraiment d’avoir une page dédiée car je pilote ces prises à partir d’un Debian dédié à ma domotique. Auquel cas je pilote simplement en faisant un script 192.168.1.177/?on1 ou l’analogue ?off1 etc.
Voilou. Bonne réalisation.
bonjour ,
j’essaye de recevoir les commandes de prises mais je ne vois rien arriver.
mon probleme c’est quoi « Une borne DATA est reliée au pin #2 (= interrupt 0) de l’Arduino Uno » j’ai essayé la borne rx puis la 2 digital apres entrée sortie mais mon ecran reste vierge
peux tu m’aider?
Merci JM (j’ai corrigé les fôôtes 😉 )
Donc si j’en crois tes « codages EXTEL » qui sont dans ton code :
Prise n°1 :
ON : 4199748 correspond à 01000000 00010101 01000100
OFF : 4199745 correspond à 01000000 00010101 01000001
Prise n°2 :
ON : 4194641 correspond à 01000000 00000001 01010001
OFF : 4194644 correspond à 01000000 00000001 01010100
Le 1er octet de « groupe » est toujours 01000000.
Le 2e octet de « bouton » suit le même codage que j’ai donné.
Le 3e octet d' »action » (ON/OFF) semble varier dans ce cas en fonction du bouton… 🙁
Bonne chance auroy 🙂
Merci pour ce partage de retro-engineering.
J’avais également travailler sur le sujet pour le pilotage et la réception d »élément Chacon d’ancienne génération. Je galère à présent pour faire fonctionner les nouveaux module de la marque qui fonctionnent toujours en 433 mais sur le protocole DI.O (visiblement semblable au Home Easy). Mais pour le moment c’est un cuisant échec.
Si quelqu’un a déjà réussi, je suis preneur.
Merci infiniment pour ton aide concernant les prises Chacon, après lecture j’ai foncé en grande surface x) – il ne me restait qu’un émetteur (impossible de sniffer avant au moins une bonne semaine le temps que les modules arrivent par la poste donc), mais grâce à ton découpage logique par octets j’ai pu mapper les prises qui m’intéressaient sans avoir besoin de sniffer. Tu me fais passer du côté risqué de la domotique niveau assurances (des relais 5V qui contrôlent du CA) au confort des prises radiocommandées sans arduino embarqué et sans tous les protocoles over-élaborés en 2.4Ghz (qui ne me serviront à présent plus que pour les bandes de LEDs et le PWM) que j’avais mis en place pour les faire tourner :3. T’as peut-être sauvé mes miches avec ton article 😉
Hé bien tant mieux ! En espérant qu’ils ne changent pas leur codage 😉
Ils ont sortis une gamme DIO (code tournant) mais « l’ancienne » version est toujours commercialisée dans les supermarchés, et ton code marche parfaitement dessus ;). Je m’attendais à des complications mais nope :3.
Je suis totalement néophyte et très impressionné par ce tutoriel.
Je souhaite contrôler depuis mon Arduino un véhicule radiocommandé en 40Mhz. Comment faire pour hacker le protocole car je ne trouve pas de module émetteur récepteur dans cette fréquence?
Merci pour votre aide…
Je suis néophyte aussi 🙂 Je n’ai pas trouvé d’émetteur 40 MHz pour Arduino. Mais si la voiture radiocommandée était fournie avec sa télécommande, peut-être le plus simple est de la démonter, et de remplacer les manettes (potentiomètres) par des connexions à la carte Arduino. (Ou, disons, un montage électronique interfacé qui se comporte comme des potentiomètres.)
Bonjour,
Merci pour ce tuto.
J’ai une erreur à la compilation du fichier d’exemple “ReceiveDemo_Advanced”
‘output’ was not declared in this scope
Me manque-t-il une librairie ?
Merci par avance pour votre aide
Bonjour,
Probablement il vous manque la librairie « RCswitch », ou bien elle n’est pas placée au bon endroit. Voir : http://code.google.com/p/rc-switch/
Elle doit être installée dans le répertoire « libraries » de votre dossier Arduino. Elle doit contenir les fichiers RCswitch.h et RCswitch.cpp.
Dans le code indiqué dans le billet, l’instruction
#include <RCSwitch.h>est un appel au fichier de cette librairie.Bonjour,
Dans la version actuelle (2.52 de github) de la bibliothèque rc-switch, la méthode
outputn’est pas définie dans RCSwitch.h.On la trouve dans l’exemple ‘ReceiveDemo_Advanced’ où elle est définie dans le fichier output.ino (https://github.com/sui77/rc-switch/blob/master/examples/ReceiveDemo_Advanced/output.ino#L1-L29).
Cette fonction fait également appel à aux fonctions ‘bin2tristate’ (définie juste après output) et ‘dec2binWzerofill’ qui est définie dans le même projet dans le fichier helperfunctions.ino (https://github.com/sui77/rc-switch/blob/master/examples/ReceiveDemo_Advanced/helperfunctions.ino).
Donc pour utiliser cette fonction output dans ton sketch, tu peux soit copier ces 2 fichiers .ino dans le répertoire de ton sketch puis réouvrir ton sketch pour qu’ils apparaissent.
Ou alors copier les déclarations des 3 fonctions dans ton sketch.
Je remercie infiniment pour votre sujet très intéressant!
Par contre, j’ai un besoin un peut différent:
Serait-il possible de modifier le code d’une télécommande universelle (RF) avec votre émetteur?
En gros on génère un code avec l’arduino et on vient l’apprendre avec une télécommande universelle Type »http://www.amazon.fr/dp/B00CDJL82A/ref=pe_386181_40444391_TE_item_image »
En vous remerciant.
Merci ! 🙂
Pour que cela fonctionne, il faut :
1) que la télécommande travaille sur la même fréquence exactement (a priori c’est le cas du modèle que vous avez mis en lien)
2) que la télécommande fonctionne sur la même structuration de signal (là, rien n’est pas précisé sur le type de codage ; même si la télécommande est dite « universelle », elle ne l’est peut-être pas pour tous les types de codage).
Peut-être est-il possible d’enregistrer avec l’Arduino le signal d’origine dans la télécommande, et voir comment il est structuré, de façon à ensuite pouvoir émettre un signal de même nature par l’Arduino. Mais je ne peux pas vous garantir que cela fonctionnera. En effet, certaines télécommandes de garage (ou alarme, ou voitures) utilisent un code tournant. Cela signifie que l’émetteur et le récepteur contiennent le même algorithme de codage (comme un cryptage) : la télécommande envoie un code différent à chaque fois qu’on appuie le bouton, mais le récepteur peut reconnaître et valider ce code s’il correspond bien au même algorithme de codage. Dans ce cas, il doit être bien plus difficile d’analyser le codage (c’est-à-dire faire de la rétro-ingénierie) avec le simple montage Arduino présenté ici… Je n’ai jamais essayé… Tentez votre chance sur des forums de hackers confirmés 😉
Merci Clovis pour votre réponse rapide et détaillée!
La télécommande dont je vous ai donné le lien est une basique ( pas de code tournant) j’en ai commandé une pour faire des essais!
Mon but est de contrôler indépendamment différents produits (à base d’arduino) pouvant se trouver à proximité! d’ou l’intérêt d’avoir des télécommandes à code différents!
Encore merci à vous!
OK ! Alors ce sera intéressant de revenir nous donner le résultat 😉 A bientôt !
Malheureusement cela ne fonctionne pas pour moi malgré un grand nombre de manip . J’ai l’impression que le module Arduino nano ne reçoit rien sur l’entree 2 (int0) . Par contre j’utilise une télécommande Tel-010 et récepteur mmv-100 smart home (433.92) le problème est peut-être la . Dommage car vos explications sont réellement très claires.
Si tout est bien câblé, que le fil d’antenne fait la bonne longueur, que les instructions sont bien entrées, peut être que le module récepteur est défectueux ? Testez avec d’autres télécommandes chez des amis, ou bien avec un 2e Arduino qui envoie un signal (émetteur)… En tous cas merci pour votre commentaire. 🙂
Une idée : j’ai vu que la télécommande Tel-010 pouvait commander 16 appareils, or il n’y a que 4 boutons. Il doit y avoir un sélecteur (petit interrupteur) dans la télécommande permettant de changer de groupe d’appareils, numérotés 1 2 3 4, ce qui ferait bien 16 en potentialité. Cela ressemble fortement au système dont je parle dans l’article. On doit avoir un codage similaire : 4 bits pour déterminer l’appareil à commander : 2 bits pour le groupe (de 1 à 4) et 2 bits pour le bouton (de 1 à 4). À cela s’ajoute un bit pour l’action : on ou off (soit montée ou descente). Il ont peut être doublé, ou rajouté des bits pour se permettre d’évoluer plus tard… Mais ce ne sont pas 16 canaux (ce qui voudrait dire 16 fréquences radio différentes), mais 16 codages possibles sur la même fréquence.
Donc, ce que je vous conseille de tester, c’est, avec le module émetteur de l’Arduino, et un programme contenant une boucle, d’envoyer une série de 8 bits avec 2 secondes de pause entre chaque émission. Vous commencez avec 00000000, puis 00000001, puis 00000010, etc., jusqu’à 11111111. Si un recepteur (volet roulant) se met à monter ou descendre, vous saurez quel est le code associé.
Si le codage se fait sur 2 octets ou plus, la boucle devra être plus longue… Et il faudra être plus patient 😉 attention à ce que cela ne déclenche pas d’autres équipements radiocommandés…
Venez donner le résultat si ça fonctionne 🙂
Bonsoir et bonne année
Me revoilà avec mon Arduino nano et un nouvel équipement émetteur / récepteur . j’ai suivi le premier conseil en achetant l’ensemble (avec beaucoup de mal pour une cde fin novembre j’ai reçu le matériel cette semaine , perte par la poste ) . Bref à la réception du matériel j’ai refait donc le montage et testé le matériel . Malheureusement le résultat est identique . Du coup j’ai désinstallé l’appli Arduino et installé la nouvelle version 1.6.7.
Maintenant je suis confronté à un autre problème avec le défaut suivant:
« C:\Program Files (x86)\Arduino\examples\rc-switch master\examples\ReceiveDemo_Simple\ReceiveDemo_Simple.pde:7:22: fatal error: RCSwitch.h: No such file or directory
#include »
J’ai pourtant installé correctement ( enfin il me semble ) le dossier librairie rc-switch dans le répertoire exemple .
Finalement je sèche un peu car je me trouve à l’étape avant téléversement vers le module et déjà j’ai un problème
Je continu mon investigation, mais si vous avez une idée je suis preneur
Bonne soirée
Rebonsoir
Autan pour moi après une nouvelle et ultime installation le rcswitch est bien pris en compte. Bon ceci étant cela ne fonctionne toujours pas . J’ai deux questions donc :
Pour l’antenne y -a-t-il une qualité de fil électrique particulière à utiliser et la longueur ( Je parle des trois millimètres ) sont ils important à ce point ?
Lorsque j’envoi des trames par une télécommande radio les leds de communication sont elles ou doivent elles être en activités ?
Merci pour la réponse
J’essayerai aussi le conseil donné à Datawolf et yokenite, concernant l’alimentation même si je considérais cette alim de 5 volts correct après plusieurs mesures je ferai un test avec une alim de labo ce weekend pour évacuer cet éventuel source de problème.
Bonjour,
Il se peut que votre télécommande utilise un protocole non supporté par RCSwitch, en effet j’ai eu l’occasion de tester différente marques, le DIO ne fonctionne pas suivant mes tests. Ces prises par contre fonctionne:
http://www.leroymerlin.fr/v3/p/produits/lot-de-4-prises-telecommandables-interieure-idk-e1400980485
Cordialement
Bonsoir,
Je teste mon récepteur fraichement reçu, une des deux broches data connecté à la pin 2 de mon Uno (pour l’interrupt 0).
Mais après le mySwitch.enableReceive(0) j’ai toujours le mySwitch.available() à faux.
Composant grillé ?
Merci d’avance pour votre aide.
Bonjour,
Je suis dans le cas de Thibaut et Datawolf, je ne reçois rien, que j’essaie avec une télécommande Chacon ou bien un autre Arduino en émission (j’ai testé l’émetteur et le récepteur sans librairie à l’aide d’un tuto trouvé sur le net, ils fonctionnent).
Une idée ?
Merci en tout cas pour le tuto qui est trés clair.
Pour répondre à Datawolf et yokenite, je n’ai pas eu ces problèmes.
Par contre, je sais qu’en testant d’autres shields, j’avais des comportements curieux simplement parce que mon alimentation n’était pas assez puissante. Alimenter l’Arduino par le cordon USB qui est branché sur l’ordi n’est pas toujours suffisante, car les shields branchés dessus utilisent une partie du courant. Essayer d’alimenter l’Arduino avec une pile 9V ou avec un petit transfo, en plus de l’USB.
Ou alors… composant grillé. 🙁
Tester aussi le pin #3 (= interrupt 1) à la place du #2 ?
Vérifiez aussi si le fil d’antenne est bien soudé au module récepteur et si l’antenne est de bonne longueur. (Mais bon, si vous êtes sûrs que les modules fonctionnent par ailleurs…) :-S
Edit : apparemment, d’autres ont les mêmes problèmes. Voir ce sujet : https://openclassrooms.com/forum/sujet/reception-en-433mhz-composant-grille-arduino
Merci pour ta réponse.
J’ai déjà écumé les sujets, et déjà essayé l’interrupt 1, ainsi que VirtualWire, et aussi le branchement sur pin analogique; là je reçois des valeurs, mais pour les interpréter 🙁
J’ai commandé un ATtiny, j’y brancherai l’émetteur pour voir, avant de jeter l’ensemble.
Si tu captes un signal analogique, c’est que le récepteur fonctionne…
Au lieu d’écrire mySwitch.enableReceive(0), essaye : mySwitch.enableReceive(digitalPinToInterrupt(2)) (pour le pin #2)
Aurais-tu une photo de ton montage où l’on voit bien les cartes, connecteurs et fils ?
(Idem piur Thibault)
Merci Clovis pour t’être penché sur notre problème, j’ai aussi essayé les différentes pistes et ça ne marche toujours pas. J’ai reçu 2 autres récepteurs différents et c’est pareil.
A en croire les problèmes rencontrés par les utilisateurs sur le lien qur tu nous as passé, ça viendrait quand même bien de la qualité des composants.
Re-bonsoir,
Bon je progresse, je viens de trouver une nouvelle télécommande de portail et ça fonctionne nickel ! Par contre les 2 autres émetteurs 433Mhz (une commande de chauffage trés récente et une télécommande Chacon qui date de quelques années ) ça ne fonctionne pas du tout. Du coup je suis plutôt dans le cas de Thibault maintenant 🙂
En tout cas merci, et si quelqu’un trouve une solution pour les émetteurs non reconnus …
Bonjour,
Je progresse encore, j’ai trouvé 4 librairies sur ce site https://bitbucket.org/fuzzillogic/433mhzforarduino/wiki/Home pour différents protocoles de communication, notamment une pour les prises utilisant un protocole DIO, ce qui doit être le cas de ma télécommande Chacon.
En utilisant la librairie NewRemoteSwitch ça fonctionne trés bien. Par contre j’ai toujours un problème pour ma commande de chauffage, ce doit être encore un autre protocole.
Merci pour le partage ! 🙂
Bonjour,
Je suis étudiant et je recherche un moyen de communication sans fil à grande portée (>1km)
J’aimerais plus de détails à propos de :
– la portée des modules.
– la consommation d’énergie.
Bonjour,
Le système présenté ici ne porte que sur une dizaine de mètres (50 à 100 m grand maximum en champ libre)… Ce sont des télécommandes ou émetteurs/récepteurs prévus pour une utilisation domestique et locale.
Bonsoir
Merci à yokenite pour le lien . Mais malheureusement c’est la même chose pour moi pas de réponse avec mon système Smart Home. J’ai commencé une démarche en raccordant mon récepteur sur un raspberry PI pour l’instant pas très concluant mais je ne suis qu’au début pour cette méthode. Pour info j’ai fait aussi une démarche inverse en essayant de trouver un protocole acceptable pour mes mmv-100 là aussi sans résultat. C’est un décevant mais je ne lâcherai pas si facilement. Je vous tiendrai informé des mes investigations
J’ai aussi un contacteur de volet MMV – 100 et télécommande TEL-010 .. J’ai testé avec RFXmngr et j’obtiens :
================================================
Home Confort command
================================================
Packettype = Home Confort
subtype = TEL-010
Sequence nbr = 11
ID = 30101 decimal:196865
House Code = A
Unit Code = 1
Command = On
Signal level = 0 -120dBm
————————————————
————————————————
Packettype = Receiver/Transmitter Message
subtype = Transmitter Response
Sequence nbr = 11
response = ACK, data correct transmitted
================================================
Et ça fonctionne …. Je recherche le protocole à adapter pour JEEDOM et surtout l’équipement à mettre en place pour utiliser ce contacteur.
Ce que je comprends .. dans la notice (et apres tests)c’est que c’est la télécommande qui code le module .. et le module peux être activé par 6 télécommandes différentes.
Merci d’avance pour les prochaines infos
Bonjour,
Merci pour cet article qui m’a bien éclairé sur le codage, et que j’ai pu vérifier avec mes prises
Une petite question : je connais les sorties 3 états, mais je ne connais pas le codage tri-state. Une recherche par google ne m’a guère avancé, pourriez-vous nous donner quelques informations sur le passage binaire / tri-state ?
Merci d’avance.
Christian
bonjour j’aurais voulue savoir ou il faut brancher la pin data sur la pin 2 analogique ou digital
merci
Merci à yokenite pour le partage de l’info, j’ai essayé désespérément de trouver un code pour lire ma commande Di-o en vain mais avec le message de yokenite ça fonctionne.
En vrai c’était simplement une étape pour vérifier que mon montage était correcte le but étant de copier un télécommande 433.92mhz d’une animation de jet d’eau OASE pour les connaisseurs mais rien y fait.
Je sais que ce n’est pas le même que Di-o mais n’ayant jamais de réponse e mon montage Arduino+récepteur dans la console j’ai cherché à vérifier si mon récepteur était bien fonctionnel chose que je peux confirmer avec la libraire que yokenite a renseigné.
Dans certains forum j’ai pu lire qu’il était possible de récupérer la trame grâce a Audacity et une prise Jack.
Si c’est faisable est-il possible en suite de travailler et de reproduire les trames via l’Arduino et un émetteur RF433.92mhz pour simuler cette satanée télécommande.
?
C’est peut être beaucoup demandé ?
Encore merci à yokenite !
Fred.
Bonjour,
Merci pour ce tuto, ça fonctionne niquel 🙂
J’ai essayé avec la lib VirtualWire, mais pas moyen de la faire fonctionner :/
Pas moyen de trouver un code qui fait télécommande avec les DIO CHACON 54760 (Leroy Merlin).
Qui a une solution avec le module emetteur RF433,92 .
Merci
Bruno
Salut Bruno,
pour les 54760 j’utilise avec succès les codes suivants.
1/ pour envoyer les ordres via un shield ethernet:
/*
* UIPEthernet EchoServer example.
*
* UIPEthernet is a TCP/IP stack that can be used with a enc28j60 based
* Ethernet-shield.
*
* UIPEthernet uses the fine uIP stack by Adam Dunkels
*
* —————–
*
* This Hello World example sets up a server at 192.168.1.6 on port 1000.
* Telnet here to access the service. The uIP stack will also respond to
* pings to test if you have successfully established a TCP connection to
* the Arduino.
*
* This example was based upon uIP hello-world by Adam Dunkels
* Ported to the Arduino IDE by Adam Nielsen
* Adaption to Enc28J60 by Norbert Truchsess
*/
#include
bool bit2[26]={}; // 26 bit global to store the HE device address.
//rf 433
const int alimRFpin = 5; // pin alimentation RF433
const int txPin = 2; // 433mhz transmitter on pin2
const int ledPin = 13;
const int nbRetransmit = 4;
const int rang_bouton[][4]=
{
{false,false,false,false}, //bouton 1, index [0]
{false,false,false,true}, //bouton 2, index [1]
{false,false,true,false} //bouton 3, index [2]
};
// relai lecture
const int relPin = 3;
// relai +5v
const int relSendPin = 10;
EthernetServer server = EthernetServer(80);
void setup()
{
Serial.begin(57200);
// rf433
pinMode(txPin, OUTPUT); // transmitter pin.
pinMode(alimRFpin, OUTPUT); // pin alimentation RF433 (transistor)
digitalWrite(alimRFpin, LOW); // pas d’alimentation par défaut
// pin relai lecture
pinMode(relPin, INPUT); // in pin.
// pin relai output
pinMode(relSendPin, OUTPUT); // out pin.
digitalWrite(relSendPin, LOW);
// led
pinMode(ledPin, OUTPUT); // led
delay(500);
Serial.println(« Setup »);
itob(ici_le_numero_a_recuperer_avec_code_lecture,26); // code telecommande
uint8_t mac[6] = {0x00,0x06,0x02,0x09,0x07,0x0d};
Ethernet.begin(mac);
Serial.print(« localIP: « );
Serial.println(Ethernet.localIP());
Serial.print(« subnetMask: « );
Serial.println(Ethernet.subnetMask());
Serial.print(« gatewayIP: « );
Serial.println(Ethernet.gatewayIP());
Serial.print(« dnsServerIP: « );
Serial.println(Ethernet.dnsServerIP());
server.begin();
}
void loop()
{
size_t size = 0;
if (EthernetClient client = server.available())
{
while((size = client.available()) > 0)
{
Serial.println(« New client – taille= »+String(size));
if (size != 5)
{
Serial.println(« Commande Longueur invalide »);
client.println(« [EL] »);
client.stop();
delay(200);
return;
}
uint8_t msg[5] = {0,0,0,0,0};
size = client.read(msg,size);
Serial.write(msg,size);
if ( (msg[0] == ‘A’) && (msg[1] == ‘B’) && (msg[2] == ‘1’) )
{
SendBtn(1,true);
client.println(« [OK] »);
}
else if ( (msg[0] == ‘E’) && (msg[1] == ‘B’) && (msg[2] == ‘1’) )
{
SendBtn(1,false);
client.println(« [OK] »);
}
else if ( (msg[0] == ‘A’) && (msg[1] == ‘B’) && (msg[2] == ‘2’) )
{
SendBtn(2,true);
client.println(« [OK] »);
}
else if ( (msg[0] == ‘E’) && (msg[1] == ‘B’) && (msg[2] == ‘2’) )
{
SendBtn(2,false);
client.println(« [OK] »);
}
else if ( (msg[0] == ‘A’) && (msg[1] == ‘B’) && (msg[2] == ‘3’) )
{
SendBtn(3,true);
client.println(« [OK] »);
}
else if ( (msg[0] == ‘E’) && (msg[1] == ‘B’) && (msg[2] == ‘3’) )
{
SendBtn(3,false);
client.println(« [OK] »);
}
else if ( (msg[0] == ‘S’) && (msg[1] == ‘R’) && (msg[2] == ‘1’) )
{
Serial.println(« [SR1] »);
digitalWrite(relSendPin, HIGH); // on alimente le circuit pour tester l’etat du relais
delay(5);
int val = digitalRead(relPin); // read the input pin
digitalWrite(relSendPin, LOW);
client.print(« [R »);
client.print(String(val));
client.println(« ] »);
}
else
{
Serial.println(« Commande inconnue »);
client.println(« [UC] »);
client.stop();
delay(200);
return;
}
} // while
client.stop();
delay(200);
} // if
}
void SendBtn(const int btnId, const int value)
{
Serial.println(« Alimentation ON »);
digitalWrite(alimRFpin, HIGH); // on active l’alimentation RF433 via le base transistor relié au GND du RF433 et le 0V du circuit
delay(500);
Serial.print(« [« );
if (value == true)
{
Serial.print(« ON-« );
}
else Serial.print(« OFF-« );
Serial.print(String(btnId));
Serial.println(« ] »);
digitalWrite(ledPin, HIGH);
for (int i=0; i<nbRetransmit; i++)
{
transmit(value,btnId-1); // true=send ON,false=OFF
delay(10); // wait (socket ignores us it appears unless we do this)
}
digitalWrite(alimRFpin, LOW); // on coupe l'alimentation RF433
Serial.println("Alimentation OFF");
digitalWrite(ledPin, LOW); // coupe le voyant
}
void transmit(int blnOn, const int num_btn)
{
int i;
// Do the latch sequence..
digitalWrite(txPin, HIGH);
delayMicroseconds(275); // bit of radio shouting before we start.
digitalWrite(txPin, LOW);
delayMicroseconds(9900); // low for 9900 for latch 1
digitalWrite(txPin, HIGH); // high again
delayMicroseconds(275); // wait a moment 275
digitalWrite(txPin, LOW); // low again for 2675 – latch 2.
delayMicroseconds(2675);
// End on a high
digitalWrite(txPin, HIGH);
// Send HE Device Address..
// e.g. 1000010101000110010 272946 in binary.
for(i=0; i<26;i++)
{
sendPair(bit2[i]);
}
// Send 26th bit – group 1/0
sendPair(false);
// Send 27th bit – on/off 1/0
sendPair(blnOn);
// last 4 bits – recipient — button 1 on the HE300 set to
// slider position I in this example:
/*
sendPair(false);
sendPair(false);
sendPair(false);
sendPair(false);
*/
sendPair(rang_bouton[num_btn][0]);
sendPair(rang_bouton[num_btn][1]);
sendPair(rang_bouton[num_btn][2]);
sendPair(rang_bouton[num_btn][3]);
digitalWrite(txPin, HIGH); // high again (shut up)
delayMicroseconds(275); // wait a moment
digitalWrite(txPin, LOW); // low again for 2675 – latch 2.
}
void sendBit(boolean b)
{
if (b)
{
digitalWrite(txPin, HIGH);
delayMicroseconds(310); //275 originally, but tweaked.
digitalWrite(txPin, LOW);
delayMicroseconds(1340); //1225 originally, but tweaked.
}
else
{
digitalWrite(txPin, HIGH);
delayMicroseconds(310); //275 originally, but tweaked.
digitalWrite(txPin, LOW);
delayMicroseconds(310); //275 originally, but tweaked.
}
}
void sendPair(boolean b)
{
// Send the Manchester Encoded data 01 or 10, never 11 or 00
if(b)
{
sendBit(true);
sendBit(false);
}
else
{
sendBit(false);
sendBit(true);
}
}
void itob(unsigned long integer, int length)
{ //needs bit2[length]
// Convert long device code into binary (stores in global bit2 array.)
for (int i=0; i<length; i++)
{
if ((integer / power2(length-1-i))==1)
{
integer-=power2(length-1-i);
bit2[i]=1;
}
else bit2[i]=0;
}
}
unsigned long power2(int power)
{ //gives 2 to the (power)
unsigned long integer=1;
for (int i=0; i 2550 && t < 2800) //on lance le déchiffrage quand on reçoit un bit correspondant au dieuxieme cadenas du signal DIO
while(i 280 && t 1300 && t < 1400) //si environ 1350 + ou moins 50 c'est un bit à 1
{ bit = 1;
}else //sinon la série est érronnée, on sort de la fonction
break;
if(i % 2 == 1) // on ne traite que les deuxièmes bits (codage manchester)
{
if((prevBit ^ bit) == 0) //si faux = codage manchester KO, on sort
break;
//on stock chaque bit dans l'unsigned long
sender <<= 1;
sender |= prevBit;
}
//on enregistre le bit précédent
prevBit = bit;
++i;
}
// si on a 64 bit (i=64) on a un code DIO détecté
if(i == 64)
return sender;
return 0; //sinon pas de code DIO
}
la suite..
2/ lire le code de la telecommande
const unsigned int RECEPT_PIN = 2; //Pin de votre recepteur 433
void setup()
{
pinMode(RECEPT_PIN, INPUT);
Serial.begin(9600);
Serial.println(« Cool code receive »);
}
void loop()
{
unsigned long sender = 0;
if((sender = listenSignalDIO()) != 0){
Serial.println(sender);
//debounce avec delay() possible
}
}
//listenSignalDIO() by bapt1080
unsigned long listenSignalDIO(){
int i = 0; //compteur boucle
unsigned long t = 0; //recepteur du delai entre 2 front descendant
byte prevBit = 0; //avant dernière « bit » 433 reçue
byte bit = 0; //dernière « bit » 433 reçue
unsigned long sender = 0; //code DIO au format unsigned long – ne gère pas le bit on-off, donne 2 codes différents
t = pulseIn(RECEPT_PIN, LOW, 1000000);
if(t > 2550 && t < 2800) //on lance le déchiffrage quand on reçoit un bit correspondant au dieuxieme cadenas du signal DIO
while(i 280 && t 1300 && t < 1400) //si environ 1350 + ou moins 50 c'est un bit à 1
{ bit = 1;
}else //sinon la série est érronnée, on sort de la fonction
break;
if(i % 2 == 1) // on ne traite que les deuxièmes bits (codage manchester)
{
if((prevBit ^ bit) == 0) //si faux = codage manchester KO, on sort
break;
//on stock chaque bit dans l'unsigned long
sender <<= 1;
sender |= prevBit;
}
//on enregistre le bit précédent
prevBit = bit;
++i;
}
// si on a 64 bit (i=64) on a un code DIO détecté
if(i == 64)
return sender;
return 0; //sinon pas de code DIO
}
Bonjour, je n’arrive pas à recevoir les codes lorsque je j’appuis sur les boutons de me télécommande (électro dépôt) enfin je reçois le « decimal : … » qu’une fois tous les 100 essais, ce qui est plutôt aléatoire …
bonjour,
ce que j’ai pu constater pour mon cas :
la partie lecture de télécommande par l’arduino est plutot « aléatoire ». Je ne reçois pas toujours bien non plus. Je suppose que ça peut venir de la qualité du récepteur RF connecté à l’arduino ou encore au « bruit » extérieur (parasitage radio. Il y a vraiment du monde sur ces plages de fréquence).
Des fois ça marche bien, des fois beaucoup moins.
J’utilise donc uniquement l’arduino pour simuler la télécommande.
Bonjour,
1) Il faut bien vérifier que l’antenne est à la bonne longueur, sinon, elle ne captera pas la fréquence de façon optimale. Ici la longueur d’onde est : λ = c / f = 3.108 / 433,92.106 = 0,691 m = 69,1 cm. Pour la longueur de l’antenne, on peut prendre cette longueur (69,1 cm), ou la moitié (34,5 cm), ou le quart (17,3 cm) de la longueur pour des raisons de commodité. En prenant les sous-multiples de la longueur d’onde, on réduit l’efficacité de l’antenne, mais elle est moins encombrante…
2) J’ai constaté avec certains montages Arduino que l’alimentation électrique par une pile n’était pas suffisante, ni par le câble USB seul. J’avais des problèmes de réception. Maintenant j’alimente toujours ma carte Arduino avec un adaptateur secteur, et c’est bien mieux. Vérifier aussi les piles de la télécommande.
3) Les perturbations électromagnétiques peuvent brouiller le signal, surtout en zone urbaine dense. Mais tout de même à 1 m de l’antenne, ça devrait capter.
Hello,
Je voudrais savoir si l’émetteur RF de l’Arduino communique les commandes à la télécommande ou directement aux prises ?
Merci pour cet article magnifique ! 🙂 J’ai commandé le nécessaire, je vais pouvoir m’amuser !
Nadim
Bonjour,
L’émetteur RF communique directement aux prises (contenant un récepteur). Les télécommandes vendues avec les prises ne sont que des émetteur RF, elles ne possèdent pas de récepteur. L’Arduino, par contre, peut servir à la fois d’émetteur et de récepteur 🙂
Mille merci pour tes réponses, ça va beaucoup m’aider, j’ai acheté le nécessaire pour comment à bricoler et m’amuser ! 🙂
Une dernière question si ça ne t’importune pas, comment fabriquer fabriquer une antenne pour le transmetteur RF ? Quel file je dois acheter ? Car en cherchant du fil gainé, je tombe sur des trucs à 20€ etc … C’est du cuivre tout simple ? Tu le soudes ou tu le poses ?
Merci ! 😀
Pour l’antenne, un simple fil de cuivre isolé de plastique, une chute de fil quoi… directement soudé sur le circuit. Normalement, même le bout de piste du circuit imprimé en cuivre sur la plaque compte dans la longueur totale de l’antenne. Si cette piste fait 6 mm par exemple, il faut diminuer d’autant le fil d’antenne (pour être précis)…
J’ai installe la librairie RCSwitch sur mon Arduino et ça fonctionne bien avec 2 de mes télécommandes mais pas avec la troisieme… qui est aussi la plus importante pour mon petit projet. En lisant les différents postes je comprends qu’il se peut que cette télécommande utilise un protocole non supporté par RCSwitch pour le traitement du signal.
Y-a-t-il un moyen de faire que l’Arduino puisse lire le signal brut sans essayer de le decoder?
Merci
Particulièrement intéressant comme article.
Mais il me reste quelques questions sur la mémorisation de l’état des esclaves (lampes, prises, etc…)
Serait-il possible que chaque esclave communique uniquement avec l’ARDUINO et que, à son tour, l’ARDUINO communique avec tous les esclaves. De telle façon, le maitre connait et mémorise l’état de chaque esclave et agit en conséquence (à notre choix selon la programmation)
Bonjour,
Merci pour votre commentaire. Si les « esclaves » doivent pouvoir communiquer avec l’Arduino, ne serait-ce qu’envoyer un « accusé de réception » à l’Arduino pour confirmer l’état dans lequel ils se trouvent, ceux-ci devraient alors contenir une partie émetteur. C’est possible bien sûr, mais cela devient un autre problème que celui exposé ici. (Ici, le but était simplement de profiter de ces prises télécommandées bon marché pour une utilisation rudimentaire.) Vous devriez poser la question sur des forums spécialisés de domotique…
Bien à vous.
Merci pour l’article, j’ai réussi à piloter mes prises ! 🙂
J’aimerais savoir une chose, étant un noob en électricité …
C’est mauvais ou non déteindre/allumer une prise très rapidement ? Histoire de faire alterner des guirlandes super rapidement ! Et si c’est pas recommandé, quelle technique utiliser pour faire ça ?
Merci ! 🙂
Disons que les prises télécommandées ne sont pas prévues pour être allumées/éteintes au rythme d’une guirlande ! En général dans ces prises électriques, c’est un relais qui ouvre/ferme le circuit (si c’est le cas, on entend un « clic » à chaque changement d’état). Dans ce cas, il faut imaginer qu’à chaque « clic », il y a un petit arc électrique qui se forme dans le relais. Plusieurs fois par seconde pendant plusieurs minutes ça risque d’encrasser le relais et le faire chauffer… je ne suis pas sûr que ce soit bon !
Sinon pour des guirlandes, il existe des petits boitiers avec des programmes de clignotement variés : https://www.amazon.fr/dp/B009MOUIS4
Bonjour,
je suis (mal)heureux possesseur d’une télécommande Chacon modèle 54760.
Comme je veux connaitre l’adressage de ma télécommande, j’utilise un RPI avec RFSniffer mais je ne capte rien … Je ne sais pas s’il faut le lancer avec un pulselength spécifique ou …
J’ai zieuter le code (bien documenté) basé Arduino mais je sèche.
Toute aide appréciée.
M’ci
Bonsoir,
Bon article, mais j’ai une petite question concernant les prises.
Quand on reçoit la prise toute neuve, comment connaitre le code qui lui est affecté ?
Je crois qu’il n’y en a pas, et qu’il faut une télécommande pour la connecter à la prise, ensuite récupérer le code envoyé par la télécommande, et du coup, on peut piloter la prise par l’arduino.
Si j’ai bon, comment faire du coup pour contrôler 4×4 prises sachant qu’une télécommande ne peut en contrôler autant ?
PS: dans la doc de la prise, c’est indiqué :
Apprentissage du code :
1°)Brancher le module au courant
2°)Approcher l’émetteur du récepteur, appuyez une fois sur le bouton d’apprentissage du récepteur.
3°)La led du récepteur clignote lentement, appuyer sur le bouton ON de l’interrupteur.
4°)La lampe branchée sur le récepteur clignote deux fois, le code est confirmé et la led cesse de fonctionner.
Comme de base l’arduino n’envoie pas de code, je ne pense pas qu’on puisse se servir de l’arduino avec un petit module 433 pour paramétrer la prise non ?
Pour info, il s’agit de cette prise : https://www.amazon.fr/dp/B0033ZREXU/ref=pd_luc_rh_sbs_01_02_t_img_lh?_encoding=UTF8&psc=1
Merci d’avance pour vos lumières.
Bonsoir,
L’article que vous indiquez fonctionne sûrement avec un codage plus perfectionné que les simples prises évoquées dans cet article. Donc je ne suis pas du tout sûr que cela fonctionnera avec le code Arduino fourni. Le problème c’est que l’on ne connait a priori pas la longueur de la séquence codée qu’il faut envoyer, ni les informations qu’elle doit contenir pour que cela fonctionne… Très certainement, la séquence doit contenir : un code propre au fabricant, un code identifiant l’interrupteur émetteur, un code indiquant si le récepteur doit être ON ou OFF.
Vous pouvez essayer de reprendre une séquence des exemples proposés dans l’article et voir ce que cela donne en l’envoyant par l’Arduino et le module RF. Si cela ne fonctionne pas il faudrait au moins acheter une télécommande de cette marque, et de tenter une réception par l’Arduino pour voir comment sont construites les séquences.
Bonne chance !
Bonsoir,
Merci pour les infos, j’ai lancé la commande pour une télécommande compatible.
Croisage de doigts ^^
@Benoit,
j’ai le même module que vous, et ça fonctionne correctement (D-IO) avec Arduino.
C’est exactement comme une prise télécommandée (que j’utilise également de D-IO Chacon).
La prise ou le module n’ont pas à proprement parler d’adresse.
C’est l’appairage qui fait tout.
J’ai longtemps galéré. J’ai cru que c’était mes récepteurs et émetteurs connectés aux arduinos qui dysfonctionnaient.
Le problème c’est le code arduino.
La commutation du/des modules chacon par l’émetteur arduino se faisait relativement facilement.
Par contre la lecture du code télécommande/interrupteur pas du tout, ou très rarement.
Très compliqué de lire les codes D-IO dans ces conditions.
J’ai essayé plusieurs récepteurs mais cela ne changeait pas grand chose.
Quelqu’un a laissé un post plus haut en faisant référence à une librairie 433 (https://bitbucket.org/fuzzillogic/433mhzforarduino/wiki/Home).
Et là oh miracle,tout fonctionne avec chacon D-IO (prises et modules) et arduino (clones nano ou mega) :
– lecture des codes des télécommandes ou des interrupteurs
– envoi de commandes pour faire commuter les relais.
L’exemple
NewRemoteSwitch/examples/ShowReceivedCode fonctionne avec n’importe lequel de mes récepteurs 433 mhz (y compris ceux que je pensais défectueux à 2 euros).
Testé sur un clone RXB6 également, dont je ne parvenais rien à tirer.
En fait il fonctionne super bien avec bien plus de portée sans antenne que le XD-RF-5V (mais avec cette librairie ça fonctionne également sur le XD-RF-5V).
Pour simuler une télécommande ou un interrupteur nécessaire lors de l’appairage, l’exemple (toujours dans la même librairie) « Retransmitter/Retransmitter.ino » permet de le faire. Il suffit de choisir un code de télécommande arbitraire.
Hope this helps..
M.
Bonjour,
J’avais le même problème que kld j’ai donc mis la librairie RCSwitch dans mes documents/arduino librairie ET dans programmefile arduino librairie
j’ai maintenant un autre message d’erreur : stray /302 in program
pour l’émetteur ça marche super, j’ai programmé toutes mes prises chacon avec tes codes mais j’en ai d’autres que j’aimerais bien « décoder » avec le récepteur
peut on m’aider ??
merci à tous
Jean-Marie