Partage
  • Partager sur Facebook
  • Partager sur Twitter

Reception en 433Mhz composant grillé ? (arduino)

Libraire rcSwitch

    9 septembre 2013 à 23:54:59

    Quelques infos sur l'avancement de mes tests :

    1 - La librairie disponible sur HomeEasyHackin ne fonctionne pas sur mon arduino uno (réalisée avec une ancienne librairie Arduino). Un fork a été réalisé depuis (voir issue n°7) mais j'ai renoncé car la méthode utilisée me paraît trop compliquée pour mes tests.

    2 - Je suis parti sur les infos décrites ici "http://playground.arduino.cc/Code/HomeEasy" (pour rappel mes equipements RF sont des Chacon compatibles avec le protocole "HomeEasy" et là "miracle" le programme n°2 (AM-HRR3 receiver test) m'a permis sans difficulté de récupérer les infos émises par la télécommande.

    3 - Je vais pouvoir maintenant travailler sur la réalisation d'une lib pour gérer toute la phase d'émisson. Le travail devrait pas être trop compliqué à faire à partir des programmes décrits sur le site.

    Il est clair qu'il ne faut pas compter sur une librairie "générique" car la communication des équipements RF433 est basée sur des protocoles plus ou moins "ouvert". Le tout est de choisir ceux qui sont le plus "ouvert" possible. Sinon pour les plus courageux, il reste le recours à l'oscilloscope ;-)

    -
    Edité par Chrysaor94 9 septembre 2013 à 23:57:06

    • Partager sur Facebook
    • Partager sur Twitter
      11 septembre 2013 à 7:08:44

      comment envoyer un raw code avec rc switch ou autre?

      jai trouvé ir protocol analyser sur google et fait un montage pour envoyer les rf sur carte son. ir analyser semble donner un raw code que jaimerai tester en l envoyant

      http://ostan.cz/IR_protocol_analyzer/

      http://davehouston.net/learn.htm

      • Partager sur Facebook
      • Partager sur Twitter
        12 septembre 2013 à 0:11:53

        +1, j'ai le meme problème, je vais essayé prochainement la solution de Chrysaor94

        merci pour les infos en tt cas et content de voir qu'on n'est pas seul.

        • Partager sur Facebook
        • Partager sur Twitter
          12 septembre 2013 à 11:40:36

          je 'bricole' depuis peu sur Raspberry pi et arduino.
          je galère avec le C/C++ étant de formation Basic, Fortran, Algol, Cobol...
          je trouve ce langage très peu intuitif. peut-être est-ce dû à ma formation initiale. faut dire que j'ai pratiqué ces langages pendant plus de 40 ans et, qui plus est, dans le domaine de la gestion.

          je profite donc de ma retraite pour me recycler ;-)

          donc, comme tous ceux qui sont intervenus sur ce fil, je rencontre un problème avec la réception 433 mhz.

          j'ai testé la réception sur 3 modules différents selon les 2 méthodes : interrupt0 pin #2 - RCSwitch et pin #11 avec VirtualWire.
          rien ne fonctionne !

          sur un des modules, j'ai tenté de modifier la valeur de la bobine selon ce qui est écrit par ailleurs : 2 tours = 433 mhz, 3 tours = 355 mhz (à vérifier).
          ça ne change rien.

          dans le doute, j'ai passé un email au vendeur chinois demandant s'il connaissait un problème avec ses modules. notamment si la fréquence était bien 433 mhz. j'attends la réponse.

          pour moi, le problème vient du module. j'en ai commandé deux autres à deux vendeurs différents. wait and see...

          à moins que tous mes émetteurs testés ne soient pas en 433 mhz, ce dont je doute.

          si quelqu'un a trouvé quelque chose, qu'il m'en parle (façon de parler ;-)

          bonne journée à tous!

          • Partager sur Facebook
          • Partager sur Twitter
            12 septembre 2013 à 16:33:53

            Bonjour latoufette,

            Je ne pense pas que ton problème vienne des récepteurs 433 mais plutôt du protocole utilisé au niveau du message émis par tes émetteurs. Quelles sont les marques de tes émetteurs ?

            Tu peux toujours essayer de tester le programme accessible ici "https://github.com/bharadwaaj/RF433/blob/master/RF.pde" (indiqué sur la file par cftrading1) sur l'arduino qui te permettra de voir si tu reçois quelque chose des émetteurs. Par contre, ne sois pas étonné mais tu devrais avoir beaucoup de bruit visible également en sortie.

            N'hésites pas à nous tenir au courant de tes tests...

            -
            Edité par Chrysaor94 12 septembre 2013 à 18:04:03

            • Partager sur Facebook
            • Partager sur Twitter
              12 septembre 2013 à 18:10:29

              Salut à tous,
              J'avais un peu zappé le truc, mais j'arrive à recevoir qu'une partie du code de ma télécommande personnellement avec le programme que j'ai créé. Il bug assez fort et n'accepte que les trames des télécommande chacon (homeasy).

              Par contre, j'ai fait un autre programme, (basée sur le travail d'idleman) qui envoie un code de 32bits et les module chacon y répondent.
              Il n'est pas très bien expliqué mais très compréhensible si vous avez un peu chercher les protocol HomeEasy. Si vous avez une question, hesitez pas !
              Je vous le mets ici :

              byte pin=8;
              boolean bit2[26];// nom de la telecommande
              boolean bit2Interruptor[4];//code interrupteur telecommande
              // a partir d'ici on = 1 off = 0
              void setup()
              {
                Serial.begin(9600);
                buildBool(68,bit2,sizeof(bit2));
                buildBool(1,bit2Interruptor,sizeof(bit2Interruptor));
               
              }
              void loop()
              {
                if(Serial.available()>0)
                {char val = Serial.read();
                  if(val=='1')
                  {
                    transmit(1,pin,bit2,bit2Interruptor);
                    delay(300);
                    transmit(1,pin,bit2,bit2Interruptor);
                    delay(300);
                    transmit(1,pin,bit2,bit2Interruptor);
                    delay(300);
                    transmit(1,pin,bit2,bit2Interruptor);
                    delay(300);
                    Serial.println("on");
                  }
                  if(val =='0')
                  {
                    transmit(0,pin,bit2,bit2Interruptor);
                    delay(300);
                    transmit(0,pin,bit2,bit2Interruptor);
                    delay(300);
                    transmit(0,pin,bit2,bit2Interruptor);
                    delay(300);
                    transmit(0,pin,bit2,bit2Interruptor);
                    delay(300);
                    Serial.println("off");
                  }
                }
              }
                    
              /*prend en arguement un integer, un tableau et ça longueur-1 ( cad que tab[26] à pour longueur 26 et non 27).C'est pour facilité l'emploi de sizeof
                * théoriquement, il faudrait donc marquer ( interger, array,sizeof(array) )
                * retourne un tableau de boolean avec le nombre integer en binaire
                */
              
              void buildBool(long integer,boolean array[],byte length){ 
                Serial.println("entering buildBool");
                for(int i = 0; integer!=0 ;i++){
                  if(integer<pow(2,i)){
                    array[length-i]=1;
                    integer = integer-(pow(2,(i-1)));
                    i = 0;
                  }
                }
              
              }
              //Envois d'une pulsation (passage de l'etat haut a l'etat bas)
              //1 = 310µs haut puis 1340µs bas
              //0 = 310µs haut puis 310µs bas
              void sendBit(boolean b,byte pin) {
               if (b) {
                 digitalWrite(pin, HIGH);
                 delayMicroseconds(310);   //275 orinally, but tweaked.
                 digitalWrite(pin, LOW);
                 delayMicroseconds(1340);  //1225 orinally, but tweaked.
               }
               else {
                 digitalWrite(pin, HIGH);
                 delayMicroseconds(310);   //275 orinally, but tweaked.
                 digitalWrite(pin, LOW);
                 delayMicroseconds(310);   //275 orinally, but tweaked.
               }
              }
              
              
              //Envoie d'une paire de pulsation radio qui definissent 1 bit réel : 0 =01 et 1 =10
              //c'est le codage de manchester qui necessite ce petit bouzin, ceci permet entre autres de dissocier les données des parasites
              void sendPair(boolean b,byte pin) {
               if(b)
               {
                 sendBit(true,pin);
                 sendBit(false,pin);
               }
               else
               {
                 sendBit(false,pin);
                 sendBit(true,pin);
               }
              }
              
              
              //Fonction d'envois du signal
              //recoit en parametre un booleen définissant l'arret ou la marche du matos (true = on, false = off)
              void transmit(boolean onOff,byte pin,boolean bit2[],boolean bit2Interruptor[])
              {
               int i;
              
               // Sequence de verrou anoncant le départ du signal au recepeteur
               digitalWrite(pin, HIGH);
               delayMicroseconds(275);     // un bit de bruit avant de commencer pour remettre les delais du recepteur a 0
               digitalWrite(pin, LOW);
               delayMicroseconds(9900);     // premier verrou de 9900µs
               digitalWrite(pin, HIGH);   // high again
               delayMicroseconds(275);      // attente de 275µs entre les deux verrous
               digitalWrite(pin, LOW);    // second verrou de 2675µs
               delayMicroseconds(2675);
               digitalWrite(pin, HIGH);  // On reviens en état haut pour bien couper les verrous des données
              
               // Envoie du code emetteur (272946 = 1000010101000110010  en binaire)
               for(i=0; i<26;i++)
               {
                 sendPair(bit2[i],pin);
               }
              
               // Envoie du bit définissant si c'est une commande de groupe ou non (26em bit)
               sendPair(false,pin);
              
               // Envoie du bit définissant si c'est allumé ou eteint 27em bit)
               sendPair(onOff,pin);
              
               // Envoie des 4 derniers bits, qui représentent le code interrupteur, ici 0 (encode sur 4 bit donc 0000)
               // nb: sur  les télécommandes officielle chacon, les interrupteurs sont logiquement nommés de 0 à x
               // interrupteur 1 = 0 (donc 0000) , interrupteur 2 = 1 (1000) , interrupteur 3 = 2 (0100) etc...
                for(i=0; i<4;i++)
               {
               if(bit2Interruptor[i]==0){
              	sendPair(false,pin);
               }else{
              	sendPair(true,pin);
               }
              }
               
               digitalWrite(pin, HIGH);   // coupure données, verrou
               delayMicroseconds(275);      // attendre 275µs
               digitalWrite(pin, LOW);    // verrou 2 de 2675µs pour signaler la fermeture du signal
              
              }

              Je vais essayé de corrigé les bug de télécommande.
              Enfait, le bug, c'est que mon programme retourne un nombre de 26 bits au lieu de 32 et je ne sais pas pourquoi ^^.
              A suivre

              • Partager sur Facebook
              • Partager sur Twitter
                13 septembre 2013 à 10:50:53

                bonjour Chrysaor9.

                effectivement, au temps pour moi : avec ce programme, je reçois bien, en cascade, des key= et address=
                lorsque j'active une de mes télécommandes, je reçois des codes qui semblent différents.

                pour répondre à ta question, dans mes télécommandes, j'ai du X10 KR22, du X10 détection d'ouverture, du Velleman pour la porte d'entrée, une autre sans marque pour ma porte de garage et même des télécommandes pour déclencher des flashes. tout ça en 433 mhz

                une question : est-ce que si j'arrivais à isoler le key et address d'une de mes télécommandes, ce serait suffisant pour l'émuler ?

                je crois qu'il faut que je me recycle sérieusement !

                en tout cas, un grand merci pour cette réponse qui me rassure ;-)

                cordialement

                • Partager sur Facebook
                • Partager sur Twitter
                  13 septembre 2013 à 22:11:12

                  Bonjour Latoufette,

                  Pour ce qui est du protocole X10, tu devrais trouver pas mal d'info sur le site "http://davehouston.net/". A priori, il existe plusieurs librairies Arduino. Regardes de ce coté "http://load-8-1.blogspot.fr/2010_06_01_archive.html". La lib "X10RF" a visiblement été testé avec une KR22 ;-)

                  Coté "Velleman" (modèle similaire VM130 ?), je pense qu'il y a peu d'espoir que tu arrives à simuler l'envoie d'une commande (le protocole est à priori  propriétaire). Je pense que tu auras la même limite pour la porte de garage. Ceci dit, c'est plutôt rassurant car je te raconte pas la sécurité du bousin si tu pouvais "sniffer" le signal de la télécommande avec un simple récepteur :-)

                  Enfin pour émuler ta télécommande, il faut que tu utilises une librairie X10 qui te permette de transmettre l'ensemble des informations attendues. La difficulté que j'ai eu de mon coté, a été dans un premier temps de pouvoir faire un reverse du message émis par l'émetteur pour récupérer l'identifiant de la télécommande. Pour cela, il faut que tu regardes si ces librairies te proposent un programme qui réalise cette opération en réception d'une trame "X10".

                  Bon courage ;-)

                  Cdt.

                  -
                  Edité par Chrysaor94 14 septembre 2013 à 8:16:24

                  • Partager sur Facebook
                  • Partager sur Twitter
                    14 septembre 2013 à 13:10:16

                    bonjour Chrysaor94.

                    merci pour toutes ces infos.
                    je vais aller faire un tour à l'occasion côté librairies pour le X10.

                    je me pose une question : aurai-je autant de difficultés pour faire dialoguer deux Arduino (ou un Arduino et un Raspberry pi) ?

                    à quel niveau est géré (ou généré) le protocole de communication entre mon émetteur et mon récepteur ?
                    j'attends du matériel (Arduino nano et breadboards) pour tester ça.

                    pour la porte de garage, je mettrai un arduino nano avec récepteur en // sur le récepteur actuel et le tour sera joué.

                    mon projet : regrouper l'accès à des caméras de vidéosurveillance de ma résidence secondaire, la gestion du chauffage (actuellement par téléphone avec une console X10), ajouter des sondes météo... le tout connecté a un Raspberry pi/serveur apache.

                    si tu as des liens intéressants qui peuvent me faciliter la tâche dans mon projet, je suis preneur ;-)

                    bon week-end

                    • Partager sur Facebook
                    • Partager sur Twitter
                      15 septembre 2013 à 15:49:41

                      @Chrysaor94 

                      Un tres bon point d'entrée:

                      http://blog.idleman.fr/

                      Tres bien fait, partage le code, indique ses sources, répond aux questions... bref, qlq'un de bien.

                      • Partager sur Facebook
                      • Partager sur Twitter
                        15 septembre 2013 à 22:32:17

                        ça communique!!

                        Deja pour ceux qui utilise des composants: http://yourduino.com/sunshop2/index.php?l=product_detail&p=341, aller sur google pour prendre la derniere version de virtualWire. du moins sur le site officielle. car la version n'ets pas a jour et ne fonctionne pas avec les dernieres version de l'arduino.

                        Sans ça, pour faire communiquer un RaspberryPi avec l'arduin, j'ai utilisé le code suivant pour l'arduino:

                        https://github.com/maditnerd/RpiArduinoCommand/blob/master/arduino/arduinocommand/arduinocommand.ino

                        et pour le raspberry:

                        https://github.com/denschu/rcswitch-pi

                        Je fais coté raspberry:  "sudo ./sendRev B 1 1"

                        coté Arduino je recois le message: "Pin 19 changed to Code Received: 7721996"

                        Bref, c'est 2 programme qui ne sont pas fait pour communiquer en semble mais ce qui est rassurant, c'est que je reçois des choses....

                        Pour ceux qui ont un doute sur le fait que leur matos fonctionne...

                        • Partager sur Facebook
                        • Partager sur Twitter
                          19 septembre 2013 à 22:32:50

                          Bonjour à tous,

                          Quelques news sur l'état d'avancement de mes tests concernant le contrôle des équipements Chacon. Je viens de finaliser une librairie qui implémente le contrôle en émission du protocole "HomeEasy" (inspirée très fortement de la lib "NexaCtrl" et des timer défini par Martyn Henderson). Pour ceux qui pourraient être intéressés, voici le lien en téléchargement "http://dl.free.fr/nrA7OUM1s".

                          Lien en téléchargement mis à jour le 07 octobre 2013.

                          -
                          Edité par Chrysaor94 7 octobre 2013 à 21:08:07

                          • Partager sur Facebook
                          • Partager sur Twitter
                            26 septembre 2013 à 22:10:53

                            Bonjour,

                            J'ai aussi le même problème que vous tous avec un ensemble émetteur - récepteur 433 Mhz (Ceux là => http://img607.imageshack.us/img607/1613/433bj.jpg). Pour le moment je ne les utilise pas encore avec des prises de type chacon mais j'utilise seulement le récepteur. J'aimerai faire une sorte de "sniffeur" RF de tous ce qui passe dans ma chambre mais j'ai déjà essayé toutes les libraires avec mon Arduino Uno et je ne reçois RIEN ! Je devrais quand même recevoir du bruit et des interférences non ?

                            Merci d'avance :)

                            -
                            Edité par Franboy01 27 septembre 2013 à 12:14:55

                            • Partager sur Facebook
                            • Partager sur Twitter
                              7 octobre 2013 à 0:29:04

                              chrysaor94, tu peux nous redonner un lien fonctionnel stp

                              merci

                              • Partager sur Facebook
                              • Partager sur Twitter
                                9 novembre 2013 à 14:48:20

                                Bonjour chrysaor94,

                                J'essaye ta librarie  "http://dl.free.fr/nrA7OUM1s" mais je ne sais pas trop quel paramètre utiliser pour >_EmetteurID_< dans l'appel de fonction  chaconRFCtrl.DeviceOn(_EmetteurID_,0).

                                pourrais-tu nous donner un petit eclairsissement ?

                                merci

                                Philippe

                                • Partager sur Facebook
                                • Partager sur Twitter
                                  12 novembre 2013 à 13:27:10

                                  Bonjour,

                                  si cela peut aider, j'ai constaté que les signaux récupérés depuis ce module sont très bruités quand l'arduino est alimenté en USB et/ou quand on branche une LED en parallèle sur une des sorties du module. Ceci peut à mon avis expliquer les pbs de réception, peu importe la lib utilisée.

                                  La solution dans mon cas : alimentation de l'arduino avec un transfo externe en parallèle de l'USB et une seule connexion de la pin RX vers un port en entrée coté arduino.

                                  -
                                  Edité par redmachine 12 novembre 2013 à 13:46:16

                                  • Partager sur Facebook
                                  • Partager sur Twitter
                                    22 novembre 2013 à 21:09:14

                                    Bonjour,

                                    PhiipeB, en fait, "_EmetteurID_" doit être remplacé par le numéro identifiant de l'émetteur (télécommande) qui te sert à commander tes récepteurs Chacon.

                                    Relis mon message du 9 sept.. En fait en utilisant  un programme (accessible sur "http://playground.arduino.cc/Code/HomeEasy"), tu pourras récupérer cet identifiant.

                                    Bon courage.

                                    • Partager sur Facebook
                                    • Partager sur Twitter
                                      2 décembre 2013 à 12:06:19

                                      Bonjour à tous

                                      je suis ce post car j''ai le même problème avec mon arduino mega 2560 pas de réception en tout cas rien ne s'affiche sur le moniteur série j'utilise la librarie RCswith avec l'exemple ReceiveDemoSimple pour essayer de récupérer les codes de ma télécommande (433,92Mhz)avez vous des réponses ???

                                      Merci

                                      ptit

                                      • Partager sur Facebook
                                      • Partager sur Twitter
                                        25 mars 2014 à 21:54:18

                                        Bonsoir,

                                        Quelqu'un a t-il réussi à adapter le code chacon pour recevoir le code des télécommande tel qu'on le fait sur un raspberry ?

                                        Je cherche à recevoir les codes sur un arduino plutôt que le raspberry.

                                        Merci d'avance pour vos réponses.

                                        • Partager sur Facebook
                                        • Partager sur Twitter
                                          4 avril 2014 à 11:42:36

                                          Hello à tous, même problème RC-Switch utilise les interruptions (beurk vu les parasites en milieu urbain avec les modules 433 low-cost) et surtout ne connait pas le protocole DIO chacon

                                          Donc j'ai repris du code easyHome arduino que j'ai simplifiée au max pour mon utilisation

                                          ça marche extrêmement bien pour moi! (à mettre dans la boucle loop tout simplement)

                                          j'essaierai de la faire évoluer pour virer les pulseIn() et faire de la détection de front descendant moi même, car je n'aime pas pulseIn (il faut éviter d'utiliser des interruptions après dans votre code avec les pulseIns, c'est pas très compatible)

                                          Je vous partage donc ma fonction en espérant qu'elle pourra vous servir aussi ;-)

                                          elle est brut et va recevoir 4 ou 5 fois le code de la télécommande pour une pression, a vous d'adapté un debounce ou la stopper quand vous recevez un code

                                          const unsigned int RECEPT_PIN = 2; //Pin de votre recepteur 433
                                          
                                          Void setup(){
                                          	pinMode(RECEPT_PIN, INPUT);
                                          	Serial.begin(9600);
                                          }
                                          
                                          
                                          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 < 64)
                                                  {
                                                  
                                                  t = pulseIn(RECEPT_PIN, LOW, 1000000);  //reception des bits
                                                  
                                                  if(t > 280 && t < 340) //si environ 310 + ou - 30 c'est un bit à 0
                                                  {	bit = 0;
                                                                      
                                                  }else if(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
                                          
                                          }




                                          Bonne réception 433 à vous ;-)

                                          -
                                          Edité par bapt1080 4 avril 2014 à 11:47:33

                                          • Partager sur Facebook
                                          • Partager sur Twitter
                                            26 avril 2014 à 1:25:26

                                            Bonsoir à tous,

                                            J'ai moi-même été confronté au problème du "je branche tout comme dans le tuto, je code tout avec les librairies des tutos et... j'ai rien.".

                                            Alors j'ai pris le taureau par les cornes et j'ai voulu regarder ce que mon récepteur recevait (en fait je me suis surtout demandé au début s'il recevait qqch).

                                            Pour ce faire, je suis parti du principe que du numérique, ça peut aussi se mesurer en analogique (tout est question de seuil).

                                            J'ai écrit ce petit bout de code :

                                            unsigned long origine;
                                            int previousValue;
                                            
                                            void setup()
                                            {
                                              Serial.begin(9600);
                                              previousValue = 0;
                                              origine = micros();
                                            }
                                            
                                            void loop()
                                            {
                                              unsigned long time = micros()-origine;
                                              int val = analogRead(3);
                                              
                                              if (val != previousValue){
                                                Serial.print((time-1)/1000.); // en ms
                                                Serial.print(" ");
                                                Serial.println(previousValue*5./1023.); // en V
                                                Serial.print(time/1000.); // en ms
                                                Serial.print(" ");
                                                Serial.println(val*5./1023.); // en V
                                                previousValue = val;
                                              }
                                            
                                            }

                                            J'ai branché la borne data sur l'entrée analogique 3 de ma uno, la borne vcc sur 5v, la borne ground... et là, j'ai pu conctater que j'avais bien du signal.

                                            Pour avoir une idée de la "tête" du signal, il suffit de copier coller la sortie série dans un fichier et de lancer xmgrace (installez le paquet grace de votre distribution linux préférée) sur ce fichier.

                                            Moi ça m'a donné un truc comme ceci :


                                            Primo, j'ai constaté que bien qu’alimenté en 5v, la sortie data du récepteur m'envoie du 3.6v.

                                            Deuzio, bien que j'ai l'impression d'avoir enlever toutes les piles de tous mes appareils susceptibles d'envoyer du 433MHz, et bien que j'habite à la campagne à côté d'un cimetière, y a qqch qui envoie la purée, mais je sais pas ce que c'est.

                                            Tertio, va falloir que j'essaie d'identifier les fréquences des signaux captés pour essayer de décrypter ce qu'ils transportent comme données.

                                            Bref, c'est pas encore la fête, mais au moins mon récepteur reçoit, et c'est le minimum que je lui demande.

                                            • Partager sur Facebook
                                            • Partager sur Twitter
                                              26 avril 2014 à 2:21:53

                                              Et si je fais une analyse fréquentielle :

                                              On dirait bien qu'il y a du signal. Reste à savoir le lire.

                                              • Partager sur Facebook
                                              • Partager sur Twitter
                                                27 avril 2014 à 11:13:39

                                                Quelques éléments supplémentaires :

                                                J'ai réussi à éliminer ce que je pensais être du signal, en reliant toutes les autres entrées analogiques au ground. J'en déduit qu'il y a parasitage entre les entrées analogiques.

                                                Et en effet, sans relier les autres au grnd, dès qu'un signal arrive, ça s'emballe et plus moyen de retourner sur un 0 constant.

                                                Ce que je suspecte : mon récepteur bon marché n'a pas de résistance de pulldown entre la borne data et la borne ground. Dès qu'un signal arrive, c'est la foire : mes autres bornes captent des signaux et là ça part en échange de faux signaux à l'infini entre les pâtes de l'atmega et mon récepteur bon marché.

                                                Ce que je vais faire : désactiver un max de pâtes de l'atmega, mettre une résistance de pulldown de 4.7kOhms sur l'entrée data,  et retester avec rcswitch pour voir s'il les protocoles apparaissent en clair maintenant.

                                                • Partager sur Facebook
                                                • Partager sur Twitter
                                                  7 juillet 2014 à 17:41:07

                                                  Bonjour,

                                                  vous avez avancé dans votre recherche de signaux ? En ce qui me concerne je suis aussi bloqué.

                                                  Bonne journée,

                                                  • Partager sur Facebook
                                                  • Partager sur Twitter
                                                    24 avril 2015 à 19:03:22

                                                    Bonjour,

                                                    Tout le monde a abandonné ce problème ? 

                                                    Ou bien tout le monde  a trouvé une solutiuon ?

                                                    Perso, je suis dans l'impasse en ayant testé toutes les solutions proposées. Avec deux recepteurs differents et toutes les librairies existantes.

                                                    Des nouvelles seraient les bien venues.

                                                    • Partager sur Facebook
                                                    • Partager sur Twitter
                                                      25 avril 2015 à 10:55:14

                                                      Salut,

                                                      Pour ma part j'en ai commandé des nouveaux et plus de problème. Peut être un problème dans une partie de la production.

                                                      • Partager sur Facebook
                                                      • Partager sur Twitter

                                                      Reception en 433Mhz composant grillé ? (arduino)

                                                      × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
                                                      × Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
                                                      • Editeur
                                                      • Markdown