Skyduino:~#
Articles
arduino, Corrigé, programmation, tutoriel

[Tutoriel] Arduino et émetteur/récepteur 433MHz (VirtualWire)

Le contenu de cet article a été entièrement réécrit et mis à jour sur le site Carnet du Maker.

Liens vers les nouveaux articles :

N.B. Les commentaires de l’article ont été pris en compte lors de la rédaction des nouveaux articles😉

Discussion

193 réflexions sur “[Tutoriel] Arduino et émetteur/récepteur 433MHz (VirtualWire)

  1. Super article ! exactement ce que je cherchais.

    Publié par coliss | 1 janvier 2012, 19 h 14 min
  2. Très intéressant. Merci.

    J’ai une question : si on souhaite mettre en place un système de questions/réponses entre les 2 Arduinos, il faut donc qu’elles puissent émettre et recevoir toutes les 2.
    Dans ce cas, existe-t-il des cartes qui font à la fois émetteur / récepteur et qui fonctionneraient avec la librairie VirtualWire ?

    merci.

    Publié par mcmf | 3 janvier 2012, 1 h 01 min
  3. Le DR3100 peut émettre / recevoir (mais pas en même temps bien sur) et fonctionne avec VirtuaWire, sinon n’importe quel transmetteur 433MHz devrait marcher.

    Publié par skywodd | 3 janvier 2012, 9 h 12 min
  4. Ok, merci Skywodd.

    Publié par mcmf | 4 janvier 2012, 0 h 20 min
  5. Salut Skywodd

    J’essayais de mettre en pratique ce montage

    J’ai un souci de compilation avec vw_setup(2000); qui n’est pas déclaré

    J’utilise arduino 1.0, y a t’il eu des changement dans la bibliothèque ???

    Publié par Cyril | 7 janvier 2012, 13 h 20 min
    • Il y eu énormément de changement dans l’api arduino lors du passage en 1.0.
      La librairie VirtualWire comme beaucoup d’autre librairies ne compile plus à cause de ces changements, essaye de compiler en arduino 0023 pour moi ça marche.

      PS: je continu à faire mes tutoriels sous arduino 0023 tant que les librairies compatible arduino 1.0 ne seront pas plus nombreuse, je te conseil donc de rester sous arduino 0023 sauf si tu veut absolument tester les différentes nouveauté introduite dans la 1.0😉

      Publié par skywodd | 7 janvier 2012, 16 h 43 min
      • J’ai utilisé la dernière librairie dispo pour VirtualWire, la compil ce passe bien avec la V1, mais le résultat ne correspond pas, j’obtient une chaine de num au lieu de caractères

        Avec la V023 pas de problème

        Publié par Cyril | 7 janvier 2012, 18 h 42 min
  6. @CYRIL surement une incompatibilité causé par les changements dans l’api arduino 1.0, si tu peut reste sous 0023 pour le moment ya vraiment trop de problémes d’incompatibilités avec la version 1.0.

    Publié par skywodd | 7 janvier 2012, 19 h 29 min
  7. Merci beaucoup pour ce tuto!!
    Tu me donne de nouvelles possibilités d’utilisation des cartes arduino.
    T’es au top continu:-)

    Publié par cutprodcutprod | 20 janvier 2012, 16 h 24 min
  8. Merci pour ce tuto clair et détaillé !
    La réalisation s’est passée sans problème et fonctionnement OK du 1er coup.
    Pour aller plus loin en utilisant cette base, j’ai commencé à mettre en œuvre un système de détection du passage du facteur.
    Etape 1 : Ir Led + PhotoTransistor, coté émetteur / Led coté récepteur => ça marche :-))
    Etape 2 : Ir Led + PhotoTransistor coté émetteur / Led + Ethernet Shield coté récepteur pour connexion serveur et envoi d’un email « Le facteur est passé » => ça marche en utilisant les ports rx et tx standard mais pas avec la librairie VirtualWire.
    Les ports Rx (11) et Tx (12) de la lib VirtualWire peuvent ils être modifiés (du fait que la carte Ethernet utilise déjà ses ports) ?
    Merci pour vos conseils

    Publié par Vince | 23 janvier 2012, 17 h 59 min
    • Tient tient, quelqu’un qui n’as pas lu les descriptions des fonctions😉

      extern void vw_set_tx_pin(uint8_t pin);
      Définie la broche utilisé pour transmettre les données, par défaut D12.

      extern void vw_set_rx_pin(uint8_t pin);
      Définie la broche utilisé pour recevoir les données, par défaut D11.

      Publié par skywodd | 23 janvier 2012, 21 h 47 min
      • En fait je me suis mal exprimé…Sorry.
        Je me demandais si il y avait une incompatibilité de la lib VirtualWire avec la carte Ethernet car j’ai bien modifié les ports ptt, rx et tx dans VirtualWire.cpp (les 3 ports étant utilisés par la carte Ethernet).
        Voici mes valeurs:
        static uint8_t vw_ptt_pin = 5;
        static uint8_t vw_rx_pin = 6;
        static uint8_t vw_tx_pin = 7;

        Peut être une erreur qui se cache ailleurs…je vais regarder ça de plus près.

        Merci Skywood et encore bravo pour tes posts divers et variés.

        Publié par Vince | 24 janvier 2012, 2 h 14 min
  9. @VINCE : Si tu as modifié les 3 broches il n’y a pas de raison que ça ne marche pas.
    Tu as bien le vw_setup() (avec une vitesse acceptable par ton kit 433MHz) et vw_rx_start() ?

    Ethernet + VirtualWire c’est faisable, la preuve : http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1289769139 donc ya surement un probléme autre pars😉

    Publié par skywodd | 24 janvier 2012, 9 h 18 min
    • Reprise des tests ce matin….et oui le problème venait bien d’ailleurs….petit fil de masse coté émetteur qui s’était discrètement fait la malle !
      Y a plus qu’à ranger tout ça dans une petite boite et attendre que le facteur soit passé avant de mettre le nez dehors:-)
      Merci Skywood

      Publié par Vince | 24 janvier 2012, 10 h 09 min
  10. Salut !! Est-ce que ces petits modules sans fils seraient assez rapide pour effectuer la liaison entre une Super Famicom (Super Nintendo) et un controleur Super Famicom. J’ai 12bits (12 boutons ) de donnée a transferer 60 fois par seconde. Est-ce possible avec un couple émeteur recepteur 433 ?? Est ce quil va y avoir une grosse latence?
    Merci

    Publié par Patrice | 3 mars 2012, 23 h 34 min
    • Si tu place l’état des boutons dans un uint16_t tu pourrait (au maximum) envoyé ~15 messages par seconde.
      Pour avoir 60Hz de rafraichissement des modules de type nrf24L01 seraient beaucoup plus adapté.

      Publié par skywodd | 3 mars 2012, 23 h 53 min
  11. bonjour,
    merci pour ce tuto j’arrive biens a envoyer et recevoir et afficher le message mais ce que j’aimerais c’est pouvoir piloter une sortie en fonction du message recut
    pouvez vous m’aider je n’arrive pas a trouver la solution( je debute sur arduino)

    en resume si je recoit le message pin111 mettre la pin 11 au niveau haut
    si je recoit pin131 mettre la pin 13 au niveau haut

    merci

    Publié par yanick | 21 juin 2012, 17 h 44 min
    • Il suffit d’utiliser la fonction strcmp (en supposant que le message envoyé est au format texte) :

      if(strcmp("pin111", buf) == 0)
        digitalWrite(11, HIGH);
      else if(strcmp("pin131", buf) == 0)
        digitalWrite(13, HIGH);
      

      http://www.cplusplus.com/reference/clibrary/cstring/strcmp/

      Publié par skywodd | 21 juin 2012, 17 h 47 min
      • Si a la place de « pin111 » on veut mettre une variable INT il sufit de mettre la variable comme ce si :

        int val(buf)
        {
          for(int i=0; i <= 255; i++)
          {
            if(strcmp(i, buf) == 0)
                 return i;
          }
        }
        

        Si je comprend bien le lien que tu as mis sa ne peut que comparer des textes:/

        Publié par Adrien | 2 octobre 2012, 20 h 06 min
      • Regarde du coté des fonctions « sscanf » et « sprintf » qui permettent de lire / écrire des variables dans une chaine de caractères suivant un format donné.

        Publié par skywodd | 2 octobre 2012, 20 h 14 min
      • Un grand merci pour ton aide, je vais essayer de me débrouiller avec sa:)

        Publié par Adrien | 2 octobre 2012, 20 h 23 min
  12. merci
    je test cela au plus vite

    Publié par yanick | 22 juin 2012, 13 h 36 min
  13. @skywood merci pour l’infos.
    mais quand je test le code que tu m’a mis j’ai ce message d’erreur il doit me manquer quelque chose non ?

    sketch_jun23b.cpp: In function ‘void loop()’:
    sketch_jun23b:28: error: invalid conversion from ‘uint8_t*’ to ‘const char*’
    sketch_jun23b:28: error: initializing argument 2 of ‘int strcmp(const char*, const char*)’

    merci

    Publié par yanick | 23 juin 2012, 22 h 58 min
    • Ha oui, j’avais pas vu qu’il fallait un cast …

      if(strcmp("pin111", (char*)buf) == 0)
        digitalWrite(11, HIGH);
      else if(strcmp("pin131", (char*)buf) == 0)
        digitalWrite(13, HIGH);
      

      Ça devrait le faire.

      Publié par skywodd | 23 juin 2012, 23 h 04 min
  14. merci
    la compilation marche reste a tester sur le montage merci encore.

    Publié par yanick | 24 juin 2012, 9 h 37 min
  15. bon c’est presque bon je viens bien piloter pa sorti mais j’ai seulement une reve impulsion ne n’arrive pas a la maintenir pendant le temps voulu.

    un idee?

    // commande pin 4 voie 4

    if(strcmp(« v41 »,(char*) buf) == 0)

    {
    digitalWrite(ledPin4, HIGH);
    delay(1000);
    digitalWrite(ledPin4, LOW);

    }if(strcmp(« v51 »,(char*) buf) == 0)
    // commande pin 5 voie 5

    {
    digitalWrite(ledPin5, HIGH);
    delay(1000);
    digitalWrite(ledPin5, LOW);

    }}

    Publié par yanick | 25 juin 2012, 15 h 19 min
    • probleme resolu cela venait de mon alimentation qui etait defetueuse .
      chgt de l’alim et tout est redevenu ok.
      merci

      Publié par yanick | 29 juin 2012, 17 h 40 min
  16. Bonjour,
    Merci pour ce tuto excellent! Je l’ai suivi à la lettre et il à parfaitement fonctionné!
    J’aimerais maintenant pouvoir récupérer les infos d’une sonde Oregon THGN132N qui émet sur du 433Mhz.
    Mon récepteur avec votre programme est en écoute mais aucun signal/message ne lui parvient , savez vous d’où cela peut il venir?

    Merci d’avance pour votre aide

    Cordialement,

    Benjamin

    Publié par Benny | 4 août 2012, 15 h 04 min
    • Après recherche, il semblerait que ma sonde utilise le protocole Oregon version 2.x basé sur un encodage appelé Manchester (http://en.wikipedia.org/wiki/Manchester_code) . J’ai trouvé un programme arduino permettant de décoder le protocole V3 : http://www.lostbyte.com/Arduino-OSV3/ . Pas mal de choses ne sont pas de mon niveau mais peut-être que cela te parle😉 Merci encore pour ton aide.

      Publié par Benny | 4 août 2012, 15 h 27 min
      • Apparemment c’est très spécial comme protocole (l’encodage Manchester est trés répandu par contre).
        Tu devrais utiliser cette librairie si tu veut utiliser ton capteur, sinon faire un décodeur Manchester + Oregon à la main demanderai beaucoup de temps.

        Publié par skywodd | 4 août 2012, 19 h 52 min
  17. Après encore quelques recherche je suis tombé sur ce site : http://jeelabs.net/projects/11/wiki/Decoding_the_Oregon_Scientific_V2_protocol#bfheader-ec6397c0822900144d198679449d287b qui parle du décodage du protocole V2 d’Oregon, il donne même un sketch : http://jeelabs.net/attachments/download/1018 . J’ai uploadé ce programme mais je n’ai pas de sortie dans le serial monitor après plusieurs minutes si ce n’est le println « [ookDecoder] » . Pourtant l’encoding Manchester semble bien être utilisé dans sa class : OregonDecoderV2 .
    Merci encore pour ton aide.

    Publié par Benny | 5 août 2012, 11 h 32 min
  18. Je viens de trouver les specs pour les différentes version de protocole : http://wmrx00.sourceforge.net/Arduino/OregonScientific-RF-Protocols.pdf, ca reste très complexe pour moi xD Si jamais tu as de bon tuto ou pages d’aide pour triturer du binaire je suis preneur!

    Publié par Benny | 5 août 2012, 12 h 06 min
  19. bonjour, 2 jours que je luttes pour faire fonctionner ce module ; à la place de ‘arduino’, j’obtiens 65114100117105110111
    Est ce uniquement un pb de virtualwire ?
    Merci d’avance
    Ma

    Publié par Max Patissier | 11 août 2012, 14 h 58 min
    • -> Un petit lien pastebin vers le code émetteur / récepteur (si modifié) et le câblage utilisé ?
      Si j’ai pas de quoi analyser la situation je peut pas deviner le probléme.

      A mon avis c’est un probléme de code ou de câblage😉

      Publié par skywodd | 11 août 2012, 15 h 56 min
    • j’ai un autre soucis de la meme veine….

      J’essaye de passer un float venant d’une sonde de T°.

      Tout fonctionne hormis que la T° réceptionnée montre 10° de plus que celle émise….

      voici mon code d’émition :

      #include // inclusion de la librairie VirtualWire

      int sensorPinE = A1; //the analog pin the TMP36’s Vout (sense) pin is connected to

      void setup()
      {
      Serial.begin(2400); //Start the serial connection with the computer
      vw_setup(2000); //to view the result open the serial monitor
      }

      void loop() // run over and over again
      {
      //getting the voltage reading from the temperature sensor
      int readingE = analogRead(sensorPinE);

      // converting that reading to voltage, for 3.3v arduino use 3.3
      float voltageE = readingE * 5.0;
      voltageE /= 1024.0;

      // now print out the temperature
      float temperatureCE = (voltageE – 0.5) * 100 ; //converting from 10 mv per degree wit 500 mV offset
      //to degrees ((volatge – 500mV) times 100)

      Serial.println(temperatureCE,1);

      char msg[19];
      dtostrf(temperatureCE,10,2,msg);
      Serial.println(msg);
      vw_send((uint8_t *)msg, strlen(msg));
      vw_wait_tx(); // On attend la fin de l’envoi

      delay(3000); //waiting a second
      }

      et le code de réception est celui du tuto.
      Sur le monitor de l’émetteur, les données sont les bonnes (msg)
      Merci d’avance pour toute bonne idée et piste !
      Max

      Publié par Max Patissier | 12 août 2012, 3 h 23 min
      • Affiche le buffer émis et le buffer reçu sous forme de valeurs hexa séparé par un espace.
        Si ça ce trouve c’est un probléme de buffer.

        Essaye aussi de déclarer char msg[19]; en tant que variable globale (hors de la fonction).

        Publié par skywodd | 12 août 2012, 16 h 08 min
      • une bonne nuit après :
        si je mets :

        char msg[19];
        float tp = temperatureCE;
        dtostrf(tp,10,5,msg); // au lieu de dtostrf(temperatureCE,10,2,msg)
        vw_send((uint8_t *)msg, strlen(msg));
        vw_wait_tx(); // On attend la fin de l’envoi

        je réceptionne la bonne température…. ca fonctionne mais j’ai du mal à comprendre comment la var temperatureCE peut changer dans la fonction dtostrf ; j’ai dejà eu le cas sous delphi ou il fallait passer un ‘temp:=temp’ pour réceptionner la bonne valeur (sans doute un bug du compilateur) mais je n’aime pas me coucher sur ce genre d’incompréhension. Si quelqu’un a une idée ou une explication ! merci d’avance. Et bravo pour les tuto, bien faits et bien écrits !

        Publié par Max Patissier | 12 août 2012, 16 h 12 min
      • Le cast float -> double lors de l’appel à dtostrf() peut être qui n’est pas bien passé ?

        Publié par skywodd | 12 août 2012, 16 h 14 min
  20. Bonjours, y aurait-il moyen d’avoir d’autre example de code, car j’essaye de coder un arduino pour qu’il puisse recevoir des commande prédéfinie mais je bloc sur les variable char …., sa ne dois surement pas être la bonne méthode pour envoyer des commande a distance …

    Merci d’avance

    Publié par Adrien | 2 octobre 2012, 18 h 44 min
    • Il y a un début d’exemple de système de commande à distance dans les commentaires😉
      La fonction à utiliser c’est « strcmp » avec des if.

      Publié par skywodd | 2 octobre 2012, 18 h 52 min
      • D’accord un grand merci, je vais lire et regarder tous sa:)

        Publié par Adrien | 2 octobre 2012, 18 h 56 min
      • Effectivement se serais un truc du genre mais … j’envois une commande que j’enregistre dans une variable puis j’envois une valleur de 0 à 255, le but serais de contrôler la vitesse et le sens du moteur a distance mais j’ais beau chercher je ne vois pas grand chose comme solution.
        ….
        Quoi que maintenant que j’y panses avec la « strcmp » et des boolean sa pourrais aller

        Merci pour ton aide

        Publié par Adrien | 2 octobre 2012, 19 h 04 min
  21. Merci pour ce tuto très intéressant, justement je veux le suivre afin de commander un moteur a distance mais comme je suis au début je ne sais pas comment faire commander un moteur en utilisant ces modules
    merci pour votre aide

    Publié par Djad | 5 octobre 2012, 23 h 47 min
  22. Très bon tuto.
    En suivant ce que tu décris, j’arrive à obtenir le même résultat et allumer ou éteindre une diode.
    Par contre, dès que je débranche les modules pour les rendre autonomes (un branché sur ma box et l’autre sur mon pc), ça ne marche plus
    Une idée d’où peut provenir le souci?

    Publié par Michel | 22 mars 2013, 2 h 37 min
  23. ah ben c’est bon problème résolu, merci

    Publié par Michel | 22 mars 2013, 2 h 59 min
  24. Salut Skywodd,
    Merci pour ce tuto qui m’a vraiment aider malheureusement j’ai le même problème que cyril:
    « J’ai utilisé la dernière librairie dispo pour VirtualWire, la compil ce passe bien avec la V1, mais le résultat ne correspond pas, j’obtient une chaine de num au lieu de caractères »

    Le problème c’est que moi je ne peux pas prendre la version V023 étant en projet scolaire.
    J’obtiens au lieu du message arduino le nombre: 7797105114105101
    Pourrais-tu m’aider?

    PS: je ne sais pas si cela à un rapport mais la commande strlen n’est pas en couleur dans mon programme.

    Publié par Adri | 2 avril 2013, 12 h 01 min
  25. Bonjour j’ai un petit problème :
    En fait j’envoie une chaîne de caractère contenant le pourcentage d’une batterie

    char msg[64];
    sprintf(msg, « %d », Pourcentagebattery);

    Et le problème est que je reçoit donc une chaîne mais je ne sais pas comment retrouver la valeur du pourcentage de ma batterie ?

    Publié par Marquis | 10 avril 2013, 18 h 41 min
  26. Salut Skywodd,
    Merci pour ce tuto qui m’a vraiment aider mais malheureusement
    j’ai une question est ce que la bibliothéque virtualWire est compatible avec des modules de transmissions et réceptions de 863MHz ( dans mon cas j’ai un emetteur AUREL tx8lavsa05 863 MHz et un récepteur AUREL AM8SF 863MHz)
    Merci d’avance

    Publié par IsaAd | 5 mai 2013, 18 h 40 min
  27. OK skywood merci:)

    Publié par IsaAd | 6 mai 2013, 15 h 27 min
  28. bonjour, tout d’abord je debute totalement sur arduino, en electronic, et donc aussi en liaison rf433.
    bien que ce tuto soit fort interressant, j’ai suivi scrupuleusement toutes les instructions (copié/collé du prog) mais ça ne fonctionne pas !😥
    j’ai essayé avec la derniere version de l’ide aindi que la version recommandée ici (0023) sans succés.

    j’ai donc plusieurs questions:

    – ces codes sont-ils pret a l’emplois ou manque-t-il des lignes
    – avez-vous un exemple de code complet et fonctionnel afin de faire des test

    d’avance merci.

    je precise qu’étant débutant je demande des prog complet pour essayé de comprendre leurs fonctionnement et non pour copier/coller betement..

    Publié par nexen | 19 mai 2013, 16 h 18 min
    • >> – ces codes sont-ils pret a l’emplois ou manque-t-il des lignes

      Il sont prés à l’emploi.

      >> – avez-vous un exemple de code complet et fonctionnel afin de faire des test

      La librairie est fourni avec un exemple « Ping » de test😉

      Ps: la librairie est elle correctement installé ? Quelles sont les erreurs ?

      Publié par skywodd | 20 mai 2013, 16 h 39 min
  29. bonjour,
    J’aurais voulu savoir si la lib. virtualWire et la lib. LiquidCrystal peuvent fonctionner en même temps :
    un LCD graphique :http://www.miniinthebox.com/fr/12864-128-x-64-points-graphique-retro-eclairage-bleu-couleur-lcd-module-d-affichage_p391035.html?litb_from=sysmail
    et un module radio en récepteur

    Quel sont les délai de réception/transition ?

    sinon Merci beaucoup cet article m’aide vraiment !!!!

    Publié par martinfactory | 20 mai 2013, 0 h 43 min
    • LiquidCrystal ne gère pas les afficheurs graphiques !
      Sinon avec la librairie u8glib tu n’auras pas de problème (mais il faudra vérifier que tu as assez de broches libres).

      Pour les timings voir le pdf page 5😉

      Publié par skywodd | 20 mai 2013, 16 h 45 min
  30. merci:)
    Et si je contrôle le LCD en SPI ça me fais 3 broches + une pour le récepteur ça devrais le faire nan ?

    Publié par martinfactory | 20 mai 2013, 22 h 36 min
  31. Merci beaucoup😀

    Publié par martinfactory | 22 mai 2013, 15 h 23 min
  32. Bonjour,
    j’essaie de faire marcher un RR3-433 sur un arduino 2560, pendant que j’ai mis un RT5 sur un Uno
    sur le 2560 j’ai le code suivant (complétement pompé sur ton site) :
    #include // inclusion de la librairie VirtualWire
    uint8_t buf[VW_MAX_MESSAGE_LEN];
    uint8_t buflen = VW_MAX_MESSAGE_LEN; // Taille maximum de notre tableau
    void setup() // Fonction setup()
    {
    Serial.begin(9600); // Initialisation du port série pour avoir un retour sur le serial monitor
    Serial.println(« Tuto VirtualWire »); // Petit message de bienvenue
    vw_setup(2000); // initialisation de la librairie VirtualWire à 2000 bauds (note: je n’utilise pas la broche PTT)
    vw_rx_start(); // Activation de la partie réception de la librairie VirtualWire
    }
    void loop() // Fonction loop()
    {
    Serial.println(« debut RX « );
    if (vw_wait_rx_max(2000)) // Si un message est reçu dans les 200ms qui viennent
    {
    if (vw_get_message(buf, &buflen)) // On copie le message, qu’il soit corrompu ou non
    {
    Serial.print(« RX : « );
    for (byte i = 0; i < buflen; i++) // Si il n'est pas corrompu on l'affiche via Serial
    Serial.print(buf[i]);
    Serial.println("");
    }
    }
    Serial.println("fin RX ");
    }

    qui se complie bien, j'ai branché l'antenne en 3, l'alim en 15 ou en 12), le signal en 14,, la masse en 11 comme prévu sur la doc trouvé en :
    http://www.telecontrolli.com/en/resources/telecontrolli-download/products-datasheet-telecontrolli/radiofrequency-products/rf-receivers-datasheet.html?download=153:rr3

    J'ai branché le port 14 du RTC sur le port 11 du Méga (2560) le TX buitbuit … mais je ne reçoit rien ….

    Faut-il mettre sur un port de type RX comme le port 15 (noté RX3) du Arduino 2560 ?
    et alors comment le déclarér ?
    j'ai essayé :
    #include // inclusion de la librairie VirtualWire
    uint8_t buf[VW_MAX_MESSAGE_LEN];
    uint8_t buflen = VW_MAX_MESSAGE_LEN; // Taille maximum de notre tableau
    uint8_t pin = 15;
    extern void vw_set_rx_pin(uint8_t pin);
    void setup() // Fonction setup() ….
    ça se compile mais je n’ai pas plus de résultat.
    Comment et quoi vérifier quand ça fonctionne pas ?

    Merci de votre aide toujours efficace.

    Publié par Barrois | 24 mai 2013, 17 h 20 min
  33. pourquoi avoir branché l’antenne sur le arduino ?

    Publié par martinfactory | 24 mai 2013, 17 h 52 min
    • « j’ai branché l’antenne en 3 » sur le shield de réception RR3-433 (désolé pour se raccouci.
      Je pense avoir trouvé en http://forum.freetronics.com/viewtopic.php?f=12&t=4750
      la raison de mes problème: « On the MEGA2560 the ICP is on a different pin. »
      /**
      * http://www.practicalarduino.com/project … n-receiver
      */

      The Mega328 only has one ICP which is on D8, the Mega2560 has a few ICPs as follows:
      ICP1 – PD4 (Not connected in the Arduino)
      ICP3 – PE7 (Not connected in the Arduino)
      ICP4 – PL0 (D49 in the Arduino)
      ICP5 – PL1 (D48 in the Arduino)

      reste à traduire et à essayer.

      Publié par Barrois | 27 mai 2013, 8 h 21 min
  34. j’ai trouvé ça aussi : http://forum.snootlab.com/viewtopic.php?t=805&p=3841
    qui semble provenir de chez toi … :
    vw_setup(2000); // initialisation de la librairie VirtualWire à 2000 bauds (note: je n’utilise pas la broche PTT)
    vw_set_rx_pin(43);
    donc le port receiver du 2560 serait le 43 ?

    Publié par Barrois | 27 mai 2013, 10 h 46 min
  35. Est-il possible d’envoyer une variable plutôt qu’une char ?

    Merci d’avance

    Publié par Nathan | 27 mai 2013, 19 h 59 min
    • Oui il suffit de faire un cast de pointeur :

      int val = 42;
      
      vw_send((uint8_t *) &val, sizeof(int));
      

      Publié par skywodd | 27 mai 2013, 20 h 07 min
      • Un énorme merci !!!:)

        Publié par Nathan | 27 mai 2013, 20 h 20 min
      • Avec cela tu aura l’adresse de val non ?
        parce que &val c’est l’adresse de val et en le castant tu le transforme en pointeur mais la tu affiche le pointeur pas la valeur pointée !

        Publié par Adrien | 28 août 2015, 9 h 54 min
      • Avec le code ci dessus tu obtiendras la valeur de val en réception, sous la forme d’un integer brut (dépendant du compilateur utilisé).
        La fonction vw_send prend en paramétre un pointeur sur données (ici &val) et la taille des données (ici sizeof int).

        Publié par Skywodd | 13 septembre 2015, 14 h 00 min
  36. bonjour skywood, ton tuto est très intéressant, je l ai testé dans le cadre scolaire, pour un projet, en rajoutant un buzzer pour faire sonner dès qu il reçoit le message, tout marche très bien mais je voudrais juste savoir ou et comment se branche les antennes.
    merci de ta réponse

    Publié par pitralph | 2 juin 2013, 17 h 12 min
    • Ou : sur la broche « antenne » (« ANT »)
      Comment : avec un fer à souder et de la soudure …
      Je vois pas quoi répondre d’autre …

      Publié par skywodd | 3 juin 2013, 9 h 55 min
    • longueur de l’antenne : 1/4 d’onde
      Pour du 433,92 Mhz ça fait : 17,2825 cm soit 17,3 cm

      Publié par nb | 19 juillet 2013, 14 h 27 min
  37. Bonjour Skywodd,
    Merci pour ce tuto très instructif!
    Je démarre un projet sous Arduino, je souhaite commander mes portails automatiques. Pour cela je dois imiter la télécommande du constructeur (elle émet sur une fréquence de 433.920 Mhz).

    Dans un premier temps j’aimerai récupérer les signaux envoyés par cette télécommande.
    D’après toi je peux utiliser ton code « récepteur » pour essayer ?

    Le problème c’est que je n’ai aucune idée du protocole/encodage utilisés par cette télécommande, ni de la vitesse d’émission… Je risque de rencontrer les mêmes problèmes que Benny avec sa sonde Oregon (qui fonctionne sur un protocole différent).

    Sinon, est-il possible de surveiller toutes les données émise en 433MHz grâce à VirtualWire (je veux dire les données « brutes », peu importe le protocole de l’émetteur) ?

    Merci.
    Geoffrey

    Publié par ggeo | 14 juillet 2013, 11 h 06 min
    • VirtualWire ne te sera d’aucune utilité, il te faut un analyseur logique câblé sur un récepteur 433MHz.
      Regarde mes articles sur blyss, c’est le même principe.

      Publié par skywodd | 14 juillet 2013, 21 h 38 min
      • Merci pour ta réponse. Effectivement, ton reverse engineering de « blyss » est le même principe (au passage bravo pour ce travail).
        J’ai bien peur que le protocole utilisé par mes télécommandes soit un peu plus difficile à comprendre…
        Me reste donc à utiliser un sniffer pour analyser les trames:)

        Publié par ggeo | 20 juillet 2013, 13 h 29 min
  38. Bonjour,

    J’apporte ma pierre…
    Il me semble préférable de placer les deux lignes:
    uint8_t buf[VW_MAX_MESSAGE_LEN]; // Tableau qui va contenir le message reçu (de taille maximum VW_MAX_MESSAGE_LEN)
    uint8_t buflen = VW_MAX_MESSAGE_LEN; // Taille maximum de notre tableau

    dans la loop.
    Ca permet de gérer les messages envoyés par l’émetteur et qui sont de longueur variable. Actuellement la taille maxi est celle du premier message reçu.

    Très bon tuto

    Merci

    Publié par nb | 19 juillet 2013, 19 h 57 min
  39. bonjour,
    un tres bon tuto ,
    svp je veux savoir quel est la distance maximal qui doit etre entre l’emetteur et le recepteur merci

    Publié par arduino lover | 12 août 2013, 13 h 30 min
  40. ah bon alors on dit que la distance que je veux est de 50m est-ce possible ?

    Publié par arduino lover | 13 août 2013, 14 h 27 min
  41. les modules entrée de gamme sont entre 60 et 90m théoriquement dans les conditions types

    Publié par iDjad | 13 août 2013, 17 h 26 min
  42. Salut , merci pour le tuto c’est tres utile,
    est-ce qu’on peut utiliser ce module pour la transmission audio sans fil ?

    Publié par Tech | 17 août 2013, 21 h 29 min
  43. Salut,
    Merci pour ce tuto qui est très claire et très utile.
    As-tu déja essayé une communication entre un Arduino et un Raspberry .

    Publié par Mike | 21 août 2013, 20 h 15 min
    • Salut,

      Je me permets de répondre.
      Plusieurs formes de communications sont possibles, ta question n’est pas assez précise sur ce point.
      Si tu veux parler de communication RF433 entre les deux en utilisant Virtualwire, ce n’est pas possible, la lib n’a pas été portée (et ne le sera probablement jamais) sur Raspberry.
      Avec un autre protocole, RPI emetteur et ARDUINO récepteur, c’est possible. L’inverse non, à cause de la fréquence très élevée avec le RPI qui n’est pas temps réel, et qui fait beaucoup d’autres choses en même temps.

      Publié par nb | 21 août 2013, 21 h 52 min
      • Bonjour NB et merci pour ta réponse,

        En fait je suis novice et je me suis mis dans l’idée de développer un peu de domotique à la maison. Le premier projet est un détecteur de profondeur pour ma citerne d’eau de plus pour calculer le volume disponible.

        Pour le moment, un capteur HR-SR4 couplé avec un arduino et un emetteur RF 433mhz a été réalisé et fonctionne pas mal sur un bureau:). La partie software se fait effectivement en RF433 en utilisant Virtualwire.

        Le but maintenant est de collecter ces données sur un raspberry pour les rendre disponible (xively, web ou autre).

        Si je suis bien ton raisonnement, ça ne sera pas possible. Il faudra donc que je récolte les informations sur un arduino qui serait linker avec un raspberry pour lui transférer les informations par cable ?

        Bonne soirée
        Mike

        Publié par Mike | 21 août 2013, 23 h 18 min
      • Bonjour,

        Oui, c’est exactement ça. Le RPI n’aurait pas d’activité temps réel, mais une activité ordinaire d’ordi.
        Tu aurais donc un arduino émetteur (celui qui mesure l’eau), un arduino récepteur qui sera là juste pour décoder le flux RF433, et un RPI pour analyser/utiliser/publier les infos.
        La liaison entre le récepteur et le RPI pourra se faire par câble (serial ou i2c), ou encore en wifi (plus cher et plus volumineux). Je n’ai pour ma part expérimenté que l’i2c.
        Note également qu’avec le virtualwire, tu pourras avoir plusieurs récepteurs arduino. ex un pour communiquer avec le RPI, et un pour afficher le volume sur un écran lcd à l’entrée de ta maison.
        Bon courage pour ta réalisation, ça fonctionnera snas problème.

        Publié par nb | 22 août 2013, 9 h 01 min
      • Merci pour tes éclaircissements. J’ai vu qu’il existait des shield pour le Rpi, je pense que je vais me tourner vers cela. (genre http://shop.openenergymonitor.com/rfm12pi-v2-pre-assembled-raspberry-pi-expansion-board-433-mhz/)

        Publié par Mike | 22 août 2013, 12 h 05 min
      • C’est pas mal du tout, je ne connaissais pas ce concept.
        Ce n’est pas donné mais esthétique, compact et fonctionnel.
        De plus le RPi suffit pour tout préparer, pas besoin d’un PC supplémentaire.
        Je vais le faire connaitre sur le blog d’Idleman dédié au RPi, mais qui fait de fréquentes embardées dans le monde Arduino…

        Merci pour l’info et bon courage pour la suite.
        Ce serait bien une fois terminé de faire de publier une synthèse.

        ps : Skyduino + Idleman, ça fait plaisir de voir des gens comme ça. C’est HS, mais c’est un cri du coeur.

        Publié par nb | 22 août 2013, 13 h 54 min
  44. A la lecture des derniers commentaires je me posais la question, ne serait-il pas mieux d’utiliser la carte PCduino (linux+arduino http://www.pcduino.com) à la place de la Rpi pour communiquer avec une autre arduino.

    On resterait ainsi dans le milieu arduino (plus simple à mon avis pour la compatibilité des prog).

    Publié par Franck | 22 août 2013, 15 h 29 min
  45. Bonjour a tous,

    Qu’est ce que vous utilisez comme emetteur/recepteur 433mhz ?
    Personnellement j’en ai acheté chez des vendeurs ebay chinois (http://www.befr.ebay.be/itm/370685120131?ssPageName=STRK:MEWNX:IT&_trksid=p3984.m1439.l2648) et j’ai vraiment de très mauvais résultat …

    Mike

    Publié par Mike | 22 août 2013, 15 h 49 min
  46. La taille maxi des messages est passée à 80 caractères depuis la v1.17:

    1.17 Increase default MAX_MESSAGE_LENGTH to 80. Added vw_get_rx_good() and vw_get_rx_bad() functions.

    La dernière version de la lib est disponible ici:
    http://www.airspayce.com/mikem/arduino/VirtualWire

    Publié par nb | 27 août 2013, 19 h 30 min
  47. Bonjour Skyduino, en testant ton tuto et avec des modules chinois, j’arrive péniblement à 4 mètres d éloignement. j’ai des d’antennes supérieure à 17cm,

    Publié par laul | 6 octobre 2013, 13 h 03 min
    • 4m ça me semble un peu léger, mes modules atteignent les 25m sans trop de probléme.

      Publié par skywodd | 9 octobre 2013, 16 h 07 min
      • Hey ! Je me suis mis dans le crâne de faire un truc tout con, j’appuie sur un bouton, ça envoie un message au récepteur qui lance l’allumage d’une Led. Le tout sur un seul arduino. Je galère même pour ça, c’est possible ou pas ?😉 je ne saisis pas très bien comment il fait pour rester en écoute et des que il y a plus d’informations il arrête la Led. J’ai beau tout faire la les reste allumée.

        Publié par Nicolas | 23 octobre 2013, 1 h 44 min
      • Deux solutions :
        – soit tu fait deux commandes : une pour allumer, une pour éteindre
        – soit tu fait une unique commande pour allumer et tu ajoutes un timer pour éteindre la led âpres un temps défini.
        Dans la deuxième solution le fait d’envoyer la commande « allumer » plus rapidement que le délai gardera la led allumée.
        Pour le timer regarde l’exemple « blink without delay »😉

        Publié par skywodd | 23 octobre 2013, 19 h 24 min
  48. Bonjour et merci pour ce tutoriel qui m’a bien aidé pour établir une com dans mon projet actuel.
    Le projet en question consiste à allumer ou éteindre une led « 1 » si on appuie sur le bouton « 1 », et ainsi de suite pour en tout (pour l’instant) 4 boutons et 4 leds.
    Ma carte réceptrice reçoit bien les caractères ascii correspondants à ce que j’envoie, mon soucis à présent est de « décoder » ce que je reçois pour pouvoir allumer le bon voyant. J’ai tenté d’utiliser strcmp(), comme suggéré plus haut dans un autre exemple, mais ça ne fonctionne pas chez moi.

    Voici le code de mon récepteur :

    void loop()

    {
    uint8_t buf[VW_MAX_MESSAGE_LEN];
    uint8_t buflen = VW_MAX_MESSAGE_LEN;

    if (vw_get_message(buf, &buflen)) // On test afin de savoir si un message est reçu.
    {
    Serial.print(« RX : « );
    digitalWrite(led_rx, LOW); // Un message est reçu.
    int i;
    for (i = 0; i < buflen; i++) // On affiche tous ce que l'on a
    Serial.print(buf[i]);
    Serial.println("");

    if(strcmp("1",(char*) buf) == 0)
    {
    etat_led_1 = !etat_led_1;
    digitalWrite(led_1, etat_led_1);
    }

    if(strcmp("2",(char*) buf) == 0)
    {
    etat_led_2 = !etat_led_2;
    digitalWrite(led_2, etat_led_2);
    }

    if(strcmp("3",(char*) buf) == 0)
    {
    etat_led_3 = !etat_led_3;
    digitalWrite(led_3, etat_led_3);
    }

    if(strcmp("4",(char*) buf) == 0)
    {
    etat_led_4 = !etat_led_4;
    digitalWrite(led_4, etat_led_4);
    }

    delay(100);
    digitalWrite(led_rx, HIGH);

    }
    }

    Publié par Chris | 21 novembre 2013, 17 h 29 min
    • A mon avis dans le code émetteur tu envois strlen(msg) et non strlen(msg) + 1 octets😉

      Publié par skywodd | 23 novembre 2013, 11 h 40 min
      • Bonjour et merci pour ta réponse.
        Apparemment ça ne lui plaisait pas le fait que je compare directement le contenu du buffer à mon caractère.

        En insérant une étape intermédiaire de recopiage du buffer dans une chaine de caractère, et en comparant ensuite les 2 chaînes de caractères ça passe mieux.

        Voici un extrait de ce que ça donne :

        int i;
        for (i = 0; i < buflen; i++) // On affiche tous ce que l'on a
        {
        Serial.print(buf[i]);
        string1[i] = buf[i];
        }
        Serial.println("");

        if(strcmp(msg_1, string1) == 0)
        {
        etat_led_1 = !etat_led_1;
        digitalWrite(led_1, etat_led_1);
        }
        Etc etc…

        Merci encore pour ton tuto !😉

        Publié par Chris | 25 novembre 2013, 16 h 16 min
  49. Bonjour,

    J’ai un petit souci à la réception des trames qui deviennent incomplètes au bout d’un certain temps.
    J’ai décris mon problème sur le forum Arduino auquel vous participez régulièrement :
    http://forum.arduino.cc/index.php?topic=204444.0

    Si vous avez une piste pour la résolution de ce problème, n’hésitez pas
    Merci pour votre implication.
    Olivier

    Publié par Olivier BERNARD | 14 décembre 2013, 9 h 51 min
  50. Salut skywodd, tu dis qu’un 555 sur 1kHz peut bloqué les transmissions en 433MHz. Comment c’est possible ?

    Publié par eliobou | 2 février 2014, 14 h 10 min
    • Le NE555 génère un signal carré, de 1KHz ou autre (en réalité la fréquence importe peu).
      Ce signal est modulé puis transmit sur la porteuse de 433MHz par le module RF.

      En envoyant un signal comme ça en permanence tu brouilles complètement les autres signaux sur la même porteuse. Du coup en face le récepteur ne reçoit que du « bruit » incompréhensible.

      Publié par skywodd | 2 février 2014, 17 h 05 min
  51. Bonjour
    Je débute avec Arduino et mon projet consiste à lire des valeurs numériques exprimées en millisecondes, sur une carte SD, puis fabriquer une trame constitué uniquement de ces valeurs
    Pour exemple j’ai sur la SD les valeur 200 ;100 ;50 ;100 ;30 ; etc. Tout ça en millisecondes et je voudrais que la valeur 200 mette la sortie PWE de l’Arduino à l’état haut pendant 200 milli , puis la valeur 100 à l’état bas pendant 100 milli , la valeur 50 à l’état haut pendant 50 milli etc.

    Pour l’instant j’arrive à afficher les valeurs de la SD sur le moniteur série, mais je bloque pour le reste.
    Si vous aviez une idée pour résoudre mon problème ce serait cool.
    Merci d’avance.

    Publié par Tricotin | 5 février 2014, 13 h 26 min
    • Je complete un peu mon projet
      Je souhaite récupérer à la sortie d’une console lumiere les data (protocol DMX)
      Apres avoir programmé celle ci mes projecteur à l’autre bout vont réagir d’une certaine façon.
      Certain vont s’allumer d’autres vont diminuer leur intensité etc.
      L’idée c’est de remplacer la console par un arduino qui renverra vers mes projecteurs exactement la même trame en boucle que celle envoyée par la console.
      Ce-ci me permettrai de me passer de la consolle vue que le protocole DMX n’attends pas de message retour vers la console donc vers l’arduino.
      J’espere avoir été assez claire mais je suis vraiment novice en programmation arduino et c’est pourquoi je me passionne en ce moment en lisant l’excellent ouvrage de Christian Tavernier sur la programmation arduino.

      Publié par Tricotin | 5 février 2014, 15 h 44 min
  52. Bonjour
    En fait je me suis mal expliqué
    J’ai déjà stocké à la main ,sur une carte SD, l’équivalent de 3 trames qui représente trois fonctions de la console lumière
    J’ai récupéré ces 3 trames à l’aide d’un analyseur logique puis j’ai mesuré les créneaux positif et négatif en Microseconds et les est recopier sur la carte SD sous forme de fichier TXT
    Ca représente 150 lignes c’étais fastidieux mais c’est fait .
    Je n’ai besoin que de la partie restitution de trame
    Le programme que je désire mettre dans l’Arduino consisterais à copier les données de la carte SD dans un tableau
    Puis allé lire la ligne n° 1 de ce tableau et fabriquer un créneau positif de la valeur stocké en Microseconds sur la ligne N° 1
    Puis allé lire la ligne n° 2 de ce même tableau et fabriquer un créneau négatif de la valeur stocké en Microseconds sur la ligne N° 2 et ainsi de suite jusqu’a la ligne 50
    J’aurai donc recréé la trame n°1 que je ferai tourner en boucle pendant 10 secondes .
    Puis j’irais lire la trame n°2 en procédant de la même façon en commencent par la ligne 51 jusqu’a la ligne 100 pendant 10 secondes également
    Puis la trame n° 3 de 101 à 150 pendant 10 secondes et je repartirais sur la trame n° 1 en boucle indéfiniment
    Il ne me reste plus qu’à connecter la sortie programmé de l’Arduino sur la ligne data de mes projecteurs et ils vont jouer les 3 fonctions les une après les autres en boucle
    Voila j’espère avoir été un peu plus claire
    Merci d’avance

    Publié par Tricotin | 11 février 2014, 3 h 33 min
  53. Très bon tuto, très clair. J’ai un souci d’un ordre un peu plus « électronique », que les problèmes évoqués au dessus : il semblerait que mon environnement soit blindé de parasites (même en supprimant / éloignant au maximum les différentes sources possibles). Résultat, je ne récupère pas à chaque coup le signal, et ça empire visiblement avec la longueur du message… Ca semble venir principalement de l’émetteur, j’ai donc essayé de rajouter une résistance de 100k entre la masse et l’alimentation, mais ça n’améliore pas les choses… Une idée?

    J’ai commandé le même jeu d’émetteur récepteur que toi, je verrai si ça donne plus de satisfaction…

    Publié par kayagni | 24 février 2014, 21 h 47 min
    • Bonjour j’ai modifier tout le sketch et j’arrive à relire sur le moniteur série les valeurs qui sont stockées sur la carte
      La question que je me pose es que je relis bien un tableau, à priori oui, puisque si je met une valeur inférieure à 176 sur la ligne // int valeurs[176]; // j’ai des chiffres et des symboles aberrants sur le moniteur série
      Par conte si je met une valeur égale ou supérieure à 176 j’affiche bien les valeurs contenues sur la carte sd
      Pouvez vous me confirmer que je relie bien un tableau et non pas la carte sd directement
      Là j’ai un petit doute

      Voici le nouveau sketch
      Merci

      #include

      File myFile;
      int valeurs[176];

      void setup()
      {
      Serial.begin(9600);
      pinMode(10, OUTPUT);
      SD.begin(4);

      // Transfert valeurs de SD vers Tableau
      myFile = SD.open(« toto.txt »,FILE_READ);
      if (myFile!=false) {
      while (myFile.available()) {
      for (int lect =0; lect <myFile.size(); lect++) {
      valeurs[lect]= myFile.read();

      }

      // lecture des valeurs du tableau vers moniteur
      for (int i =0; i <myFile.size(); i++) {
      Serial.write( valeurs[i]);
      }}
      }
      }
      void loop()
      {

      }

      Le contenue de la carte sd

      12565

      355

      355

      715

      715

      355

      355

      715

      715

      355

      355

      715

      715

      355

      355

      715

      715

      355

      355

      715

      715

      355

      355

      715

      715

      355

      12565

      Publié par Tricotin | 26 février 2014, 0 h 55 min
      • myFile.size() te retourne le nombre d’octets contenu dans le fichier, pas le nombre de valeurs.
        myFile.read() te retourne un octet, pas un int, utilise myFile.parseInt() a la place😉

        Publié par skywodd | 1 mars 2014, 18 h 09 min
      • Ok merci cool

        Publié par Tricotions | 3 mars 2014, 14 h 37 min
  54. Lorsque je fais un cast de la valeur de mon pointeur, si j’envoie la valeur 420, le récepteur me retourne… 164… Je n’arrive pas à comprendre où est la boulette… Une idée?

    Publié par kayagni | 1 mars 2014, 2 h 38 min
  55. Salut merci de ton tuto, je voulais savoir si il était obligatoire d’utiliser 2 arduino ou si on pouvait remplacer l’une des deux par un pont en H ?

    Publié par Antoine | 5 mars 2014, 1 h 05 min
    • Tu as obligatoirement deux Arduino, un pour émettre, un pour recevoir (et si tu le souhaite contrôler un pont en H).

      Publié par skywodd | 6 mars 2014, 22 h 03 min
  56. J’avais pensé par exemple a une petite telecommande ?

    Publié par Antoine | 5 mars 2014, 2 h 24 min
  57. ça fait longtemps, j’essaie de réaliser une simple transmission à base RT4 + RR3, PIC12f, MANCHESTERE, mikroe.
    sur simulation fonctionne, mais sur la réalité n’aime pas fonctionner, quelqu’un pour m’aider??

    cordialement

    Publié par AKLI NA | 30 mars 2014, 13 h 22 min
  58. salut pouvez vous m’aider à resoudre mon prob:) je cherche un code qui permet d’envoyer une tonalité à l’aide d un emetteur tx-saw 433mgh +arduino uno(comme si une station radio fm ) à une téléphone portable sous une fréq b1 déterminée et merci d’avance

    Publié par mhamdi nour elhak | 7 avril 2014, 3 h 25 min
  59. Salut, merci pour ton tuto, je dois réaliser pour mon projet de terminal (au bac) une station météo. Je m’occupe de l’émetteur récepteur 433mhz qui doit capter la donnée d’un pluviomètre connecté à l’émetteur et le récepteur doit l’envoyé sur un afficheur lcd et qu’il puisse afficher correctement le degrés de pluviométrie. Je ne sais toujours pas comment je vais faire déjà que le temps me manque mais pour l’instant j’ai un autre problème.

    Le message s’envoie bien puisque je reçois un message sur l’arduino du récepteur, par contre le message est: « 65114100117105110111 » et non « Rx : Arduino ». Comment cela fait il ?

    Merci d’avance:)

    Publié par Arthur | 7 avril 2014, 16 h 37 min
    • Remplace :

      Serial.print(buf[i]);
      

      Par :

      Serial.write(buf[i]);
      

      Publié par skywodd | 9 avril 2014, 12 h 05 min
      • merci de ta réponse, j’avais oublié de répondre mais à la fin j’ai mit  » Serial.print(char(buf[i]));  » et ça a marché.:)

        Publié par Arthur | 11 mai 2014, 1 h 39 min
  60. pour les émetteurs/ récepteurs–> conseil après fait des tests sur quelques ref différentes, utiliser les modules Aurel Wireless pour une meilleure porté et meilleure sensibilité du récepteur

    Publié par kaim | 2 mai 2014, 10 h 39 min
  61. A reblogué ceci sur Alex CNC.

    Publié par alnoa | 9 mai 2014, 19 h 03 min
  62. Salut Skywodd et salut tout le monde.

    Tutoriel très intéressant et compréhensible.

    Pardonnez-moi d’avance (s’iou plait, ne me battez pas hein) mais je n’es pas lu la globalité des questions/réponses suivant le tuto.

    Donc ma question, et mon projet est:

    je souhaiterai non pas transmettre un simple message « arduino » mais transmettre une température venant de mon capteur ds18b20, hors l’ide me dis que ce n’est pas une bonne valeurs.

    Pourriez vous m’indiquer le sentier a suivre a fin d’y comprendre le blocage,

    par avance merci.

    Cordialement,
    -Visvic-

    Publié par VISVIC | 22 juin 2014, 20 h 15 min
    • il faut surement convertir tes valeurs du capteur car dans l’exemple c’est un char utiliser.

      Publié par laul | 23 juin 2014, 13 h 37 min
      • @LAUL, c’est ce que j’ai pensé aussi, mais c’est la ou s’arrète mes connaissance (donc connaissance nul lol) pour savoir comment le convertir et le reconvertir apres le signal recu …

        Publié par VISVIC | 23 juin 2014, 19 h 51 min
  63. Prendre en compte que si vous devez utiliser le pin 10 sans se servir de la fonction ptt, il vous faut changer le pin ptt via vw_set_ptt_pin(); ou vw_set_ptt_inverted.

    Publié par alnoa | 6 août 2014, 18 h 39 min
  64. super merci

    Publié par alnoa | 20 octobre 2014, 13 h 44 min
  65. Bonjour, super tuto merci.
    J’ai repris les deux sketch arduino émetteur / récepteur, j’ai essayé d’afficher les résultat du récepteur sur écran LCD mais il n’y a que le test qui fonction en début de programme.
    Je n’arrive pas à voir d’ou vient mon erreur. Avez-vous une idée?
    merci. Marc.

    //********EMETTEUR**********

    #include // inclusion de la librairie VirtualWire

    const char *msg1 = « Arduino »; // Tableau qui contient notre message 7 caracteres + 1 nul
    const char *msg2 = « ERREUR « ;// Tableau qui contient notre message 7 caracteres + 1 nul
    void setup() // Fonction setup()
    {
    Serial.begin(9600); // Initialisation du port série pour avoir un retour sur le serial monitor
    Serial.println(« Tuto VirtualWire »); // Petit message de bienvenue

    vw_setup(2000); // initialisation de la librairie VirtualWire à 2000 bauds (note: je n’utilise pas la broche PTT)
    }

    void loop() // Fonction loop()
    {
    Serial.print(« TX Debut envoi1 « ); // On signale le début de l’envoi
    vw_send((uint8_t *)msg1, strlen(msg1)); // On envoie le message
    vw_wait_tx(); // On attend la fin de l’envoi
    Serial.println(« Done Fin Envoi1 »); // On signal la fin de l’envoi
    delay(3000); // Et on attend 1s pour pas flooder

    Serial.print(« TX Debut envoi2 « ); // On signale le début de l’envoi
    vw_send((uint8_t *)msg2, strlen(msg2)); // On envoie le message
    vw_wait_tx(); // On attend la fin de l’envoi
    Serial.println(« Done Fin Envoi2 »); // On signal la fin de l’envoi
    delay(3000); // Et on attend 1s pour pas flooder
    }

    **************************************************************************************************
    //****************RECEPTEUR***************

    #include // inclusion de la librairie VirtualWire
    #include // Inclusion de la librairie pour afficheur LCD

    int retro = 9; // retroéclairage sur broche 9
    int led =13;

    const int RS=2; //declaration constante de broche Afficheur LCD
    const int E=3; //declaration constante de broche

    const int D4=4; //declaration constante de broche Afficheur LCD
    const int D5=5; //declaration constante de broche Afficheur LCD
    const int D6=6; //declaration constante de broche Afficheur LCD
    const int D7=7; //declaration constante de broche Afficheur LCD

    LiquidCrystal lcd(RS, E, D4, D5, D6, D7);// initialisation LCD en mode 4 bits

    void setup() // Fonction setup()
    {
    pinMode(led, OUTPUT); // Pin 13 etat en sortie
    pinMode(retro, OUTPUT);
    lcd.begin(16, 2); // Afficheur LCD 2 lignes 16 caractères
    delay(10); // pause rapide pour laisser temps initialisation
    analogWrite(retro, 125); // Ecriture analogique PWM ou LMI réglage luminosité rétroéclairage de 0 à255
    delay(10); // pause rapide pour laisser temps initialisation

    // Test du LCD
    lcd.clear();// Efface ecran
    lcd.setCursor(0, 0) ; // positionne le curseur à l’endroit voulu (colonne, ligne) (1ère=0 !)
    lcd.print(« Tuto VirtualWire ») ; // affiche la chaîne texte – message de test
    delay(1000); // pause

    vw_setup(2000); // initialisation de la librairie VirtualWire à 2000 bauds (note: je n’utilise pas la broche PTT)
    vw_rx_start(); // Activation de la partie réception de la librairie VirtualWire
    }
    void loop() // Fonction loop()
    {
    uint8_t buf[VW_MAX_MESSAGE_LEN]; // Tableau qui va contenir le message reçu (de taille maximum VW_MAX_MESSAGE_LEN)
    uint8_t buflen = VW_MAX_MESSAGE_LEN; // Taille maximum de notre tableau

    if (vw_wait_rx_max(200)) // Si un message est reçu dans les 200ms qui viennent
    {
    if (vw_get_message(buf, &buflen)) // On copie le message, qu’il soit corrompu ou non
    {
    lcd.clear();// Efface ecran
    lcd.setCursor(0, 1) ; // positionne le curseur (colonne, ligne)
    lcd.print(« RX Debut »);
    delay (500);
    for (byte i = 0; i < buflen; i++) // Si il n'est pas corrompu on l'affiche via Serial
    {
    lcd.setCursor(0, 0) ; // positionne le curseur (colonne, ligne)
    lcd.print(buf[i]);
    }
    delay (500);
    lcd.setCursor(0, 1);
    lcd.print(" ");// efface la 2eme ligne par 16 caracteres espace
    lcd.setCursor(0, 1) ; // positionne le curseur (colonne, ligne)
    lcd.print("RX Fin");
    delay (500);

    if(strcmp("Arduino", (char*)buf) == 0)
    {
    lcd.setCursor(0, 1);
    lcd.print(" ");// efface la 2eme ligne par 16 caracteres espace
    lcd.setCursor(0, 1) ; // positionne le curseur (colonne, ligne)
    lcd.print("pin 13 HIGH");
    delay (500);
    digitalWrite(13, HIGH);
    }
    else if(strcmp("ERREUR ", (char*)buf) == 0)
    {
    lcd.setCursor(0, 1);
    lcd.print(" ");// efface la 2eme ligne par 16 caracteres espace
    lcd.setCursor(0, 1) ; // positionne le curseur (colonne, ligne)
    lcd.print("pin 13 LOW");
    delay (500);
    digitalWrite(13, LOW);
    }
    }
    }
    }

    Publié par Marc | 25 octobre 2014, 15 h 32 min
    • Bonjour, je pense avoir un problème avec le rétroéclairage.
      J’ai remplacé
      analogWrite(retro, 125); // Ecriture analogique PWM ou LMI réglage luminosité rétroéclairage de 0 à255
      par
      digitalWrite(9, HIGH);
      mais je ne peu pas régler la luminosité du rétroéclairege.
      Quelqu’un as-t-il une idée.
      Cordialement.
      Marc.

      Publié par Marc | 26 octobre 2014, 11 h 29 min
      • Bonjour, dans la librairie « VirtualWire » il est spécifier (Caution: VirtualWire takes over Arduino Timer1, and this will affect the PWM capabilities of the digital pins 9 and 10.
        J’ ai donc changer de broche.
        Tout est OK
        Cordialement.
        Marc.

        Publié par Marc | 30 octobre 2014, 8 h 27 min
  66. Salut, super tutot.

    J’essaye de faire en sorte que lorsque je reçois le message correctement, cela active un relais via la sortie 13, mais je galère au niveau du code, quelqu’un pour m’éclairer ?

    #include // inclusion de la librairie VirtualWire

    void setup() // Fonction setup()
    {
    Serial.begin(9600); // Initialisation du port série pour avoir un retour sur le serial monitor
    Serial.println(« Tuto VirtualWire »); // Petit message de bienvenue
    pinMode (13, OUTPUT);
    vw_setup(2000); // initialisation de la librairie VirtualWire à 2000 bauds (note: je n’utilise pas la broche PTT)
    vw_rx_start(); // Activation de la partie réception de la librairie VirtualWire
    }

    void loop() // Fonction loop()
    {
    uint8_t buf[VW_MAX_MESSAGE_LEN]; // Tableau qui va contenir le message reçu (de taille maximum VW_MAX_MESSAGE_LEN)
    uint8_t buflen = VW_MAX_MESSAGE_LEN; // Taille maximum de notre tableau

    // REMARQUE ULTRA IMPORTANTE :
    // Par le passé ces deux lignes se trouvaient en « haut de programme », c’était donc des variables globales.
    // Elles ne doivent PAS être globales, c’est très important !
    //
    // Pourquoi ?
    // C’est très simple. Posez vous la question suivante : que vaut « buflen » si la réception d’un message échoue,
    // où qu’on reçoit un message de moins de VW_MAX_MESSAGE_LEN octets ?
    // Au début « buflen » vaut VW_MAX_MESSAGE_LEN, mais après « buflen » vaudra une valeur < VW_MAX_MESSAGE_LEN.
    // Et paf, la taille de votre buffer vient de diminuer pour la réception suivante, et ainsi de suite.

    if (vw_wait_rx_max(200)) // Si un message est reçu dans les 200ms qui viennent
    {
    if (vw_get_message(buf, &buflen)) // On copie le message, qu'il soit corrompu ou non
    {
    Serial.print("RX : ");
    for (byte i = 0; i < buflen; i++) // Si il n'est pas corrompu on l'affiche via Serial
    Serial.print(buf[i]);
    Serial.println("");
    }
    }
    if ( buf == "Test reussi")
    { digitalWrite(13, HIGH);
    }

    }

    Publié par naleur | 25 novembre 2014, 16 h 04 min
  67. bonjour,

    pour commencer, très bon tuto, ça permet aux noob dont je fait parti de comprendre les bases.
    maintenant, et même aprés avoir lu tous les post je n’arrive pas a mes fins, a savoir:

    envoyer une commande genre « onlumiere3 » et que de l’autre coté la reception de cette commande active une sortie de mon choix.
    contrainte supplementaire, cette valeure « onlumiere3 » se couple avec && « si l’inter local est sur 1 »

    un bon samaritain pour me montrer la voie a prendre ?

    d’avance merci.

    Publié par nexen | 2 février 2015, 0 h 35 min
  68. bonjour tout le monde
    comment puis-je faire pour envoyer les informations de mes capteurs de température et de comptage ??

    Publié par baptiste | 12 mars 2015, 9 h 12 min
  69. Bonjour, Comment je fais pour synchroniser l’émetteur et le récepteur?

    Publié par afaf | 19 mars 2015, 11 h 21 min
  70. Bonjour, je suis en T’STI2D et après plusieurs essais a tenter de modifier le programme d’ici pour l’adapter a ce que je veut (Hélas tous des échecs) j’en vient a vous demander votre aide. Je souhaite en effet modifier le délai d’une seconde entre chaque envoie pour un Déclenchement par un simple boutton(le principe d’une télécommande HF) Après plusieurs programmes trouvés sur le net, je vous remercie d’avance si vous pouvez m’aider a finaliser mon projet.

    Publié par CielArt | 9 avril 2015, 11 h 19 min
    • Si tu veux un fonctionnement type télécommande de TV :

      void loop() // Fonction loop()
      {
          if (digitalRead(2) == LOW) { // En partant du principe que l'interrupteur est câblé sur la broche D2 avec un résistance tirage à VCC
              vw_send((uint8_t *)msg, strlen(msg));
              vw_wait_tx();
              delay(1000);
          }
      }
      

      Publié par Skywodd | 9 avril 2015, 14 h 01 min
  71. Salut, pour un petit drone comment puis-je dire au premier arduino ( un explorez )de dire lui même ( si le joystick bouge ) au deuxième arduino ( un uno ) d’alimenter les moteurs ??

    Publié par Foxlight_ | 21 juin 2015, 15 h 12 min
  72. S’il vous plait, comment je pourrais envoyer la valeur donné par un potentiomètre ? Je suis débutant et je ne vois pas comment faire.

    Publié par Onytis | 31 octobre 2015, 15 h 07 min
  73. Bonjour
    Quel est le débit de ce genre d’émétteur recepteur ?
    merci

    Publié par MoisSI | 17 novembre 2015, 20 h 00 min
    • A 2Kbps (standard), le débit maximum théorique avec VirtualWire est de 132 octets par seconde.
      Mais dans la vraie vie, avec les interférences, c’est plus 27 octets (= un message VirtualWire) par seconde vu qu’il faut répéter au moins 4 fois un message pour le recevoir correctement à l’autre bout.

      Publié par Skywodd | 23 novembre 2015, 14 h 14 min
  74. Bonjour, je tente un petit projet à partir d’une mega2560 et d’une arduino nano
    But : récupérer des info venants de capteur d’alarme, la temperature, …et des variable venant de la carte nano.
    et pouvoir controller des prises fonctionnant sur DIO (ref54760)
    pour cela j’utilise les librairies suivantes :
    RCSwitch pour les capteurs alarme
    NewRemoteTransmiter pour émettre vers les prises DIO
    tout va très bien.
    Lorsque je veux inclure la récup de données depuis la Nano j’ai rajouté le librairie virtualwire (transmission de variables)
    Là je peux encore recevoir les codes de mes détecteurs et les traiter mais par contre je ne sais plus émettre pour mes prises DIO.

    voici un code que j’utilise (simplifié)
    Donc emetteur sur pin 11 et recepteur sur pin 2
    #include
    #include
    #include

    NewRemoteTransmitter transmitterDIO1(8613114, 11, 260, 3);

    void setup() {
    vw_setup(2000); // initialisation de la librairie VirtualWire à 2000 bauds (note: je n’utilise pas la broche PTT)
    vw_set_rx_pin(2);
    vw_rx_start(); // Activation de la partie réception de la librairie VirtualWire
    }

    void loop() {
    lecturevirtualwire(); //décodage des variables Arduino Nano
    allumertout();
    delay(20000);
    }
    void allumertout()
    {
    transmitterDIO1.sendUnit(0, true);
    transmitterDIO1.sendUnit(1, true);
    transmitterDIO1.sendUnit(2, true);

    }
    void lecturevirtualwire() {
    // code de ton example …
    }
    Dès que rx_start est activé je ne peux plus emettre.

    Actuellement je contourne le probleme en mettant rx_stop avant emission
    void allumertout()
    {
    vw_rx_stopt();
    transmitterDIO1.sendUnit(0, true);
    transmitterDIO1.sendUnit(1, true);
    transmitterDIO1.sendUnit(2, true);
    vw_rx_start();
    }
    Comment se fait il que la lecture d’un code RF entrant puisse bloquer l’émission ?
    Toute explication serait la bienvenue
    Merci

    Publié par pat65 | 26 novembre 2015, 13 h 17 min
  75. Ça fonctionne très bien mais ma porté n’est que de quelques mètres… même avec de petites antennes grrrr … Une idée quelqu’un ?

    Publié par iannick | 2 janvier 2016, 22 h 43 min
    • La porteuse 433MHz est tellement saturée que ça m’étonne pas qu’après quelques mètres on ne capte que du bruit.
      En général, avec des modules chinois pas cher, j’arrive à une portée grand max de 10-15m.

      C’est pour quel type d’application ?

      Publié par Skywodd | 6 janvier 2016, 10 h 56 min
      • Salut,

        Est-ce qu’il y a une autre fréquence qui peut être utilisée ?
        Si oui, est-ce qu’il y a des matériels pas trop chers, je pense essentiellement à des prises, et des récepteurs qui fonctionnent avec.

        Merci d’avance

        Publié par Noury | 6 janvier 2016, 16 h 34 min
      • La porteuse 868MHz est utilisable mais il existe pas beaucoup de matos dessus à l’exception des alarmes sans fil et autres modules Z-Waze.

        Publié par Skywodd | 25 janvier 2016, 11 h 49 min
  76. Bonjour,j ai un problème avec mon code arduino.
    Mon but est de envoyer 1 voir 3 (maximum) position précises a un servomoteur et un moteur pas a pas.
    Le seul problème, c est que la partie interrupteur(sans fil) ,je comprend pas les informations donner.
    Mon problème n’est pas que le servo ou le moteur ne marche pas(fonctionne sans wifi) .
    Mais quand la télécommande envoie les données rien ne se passe.
    je ne comprend pas d’où viens le problème?
    quelqu’un aurait une idée?

    Publié par progetsin | 5 janvier 2016, 16 h 21 min
  77. // Emetteur 433 MHz
    // Programme d’émission de données
    // Source : https://skyduino.wordpress.com/2011/12/29/tutoriel-arduino-et-emetteurrecepteur-433mhz-virtualwire/
    //=====================================================
    #include

    const char *msg = « 28790658 »;
    //Chiffres de 0-9 (les caractères ABC… sont transmis en code A=65,…)

    void setup()
    {
    Serial.begin(9600);
    Serial.println(« Tuto VirtualWire »);

    vw_setup(2000);
    }

    void loop()
    {
    Serial.print(« TX … « );
    vw_send((uint8_t *)msg, strlen(msg));
    vw_wait_tx();
    Serial.println(« Done ! »);
    delay(2000); // Et on attend 1s pour pas flooder
    }

    // ==== Recepteur 433 MHz ===============================
    // Source : https://skyduino.wordpress.com/2011/12/29/tutoriel-arduino-et-emetteurrecepteur-433mhz-virtualwire/
    //=======================================================

    #include

    uint8_t buf[VW_MAX_MESSAGE_LEN];
    uint8_t buflen = VW_MAX_MESSAGE_LEN;

    void setup()
    {
    Serial.begin(9600);
    Serial.println(« Tuto VirtualWire »);
    vw_setup(2000);
    vw_rx_start();
    }
    void loop()
    {
    if (vw_wait_rx_max(200))
    {
    if (vw_get_message(buf, &buflen))
    {
    Serial.print(« RX : « );
    for (byte i = 0; i < buflen; i++)
    //Serial.print(buf[i]);
    {Serial.print(buf[i]- '0');
    }
    Serial.println("");
    }

    mais je viens de voir que j ai une arduino nano est pas uno est ce que sa change??

    Publié par progetsin | 8 janvier 2016, 8 h 19 min
  78. Hello World

    Publié par JefferyRilk | 8 janvier 2016, 18 h 14 min
  79. Bonjour.
    quand j’envoie un int superieur a 40000 je recois des choses bizarres. je me sert de itoa pour la conversion.
    C’est à cause de la limite d’envoi?

    Publié par jb | 11 janvier 2016, 22 h 33 min
  80. bonjour,
    je cherche à mesurer une tension, celle d’une photorésistance, donc la tension va varier et il me faut donc un échantillonnage assez précis, grâce à un arduino, je vais avoir un module autonome alimenté par une pile qui enverra la valeur de cette tension à un autre par le biais d’émetteur récepteur.
    J’aimerais savoir comment il est possible de récupérer cette tension ?
    merci d’avance

    Publié par faudot | 18 janvier 2016, 16 h 14 min
  81. Merci pour votre travail.
    Je tente d’envoyer plusieurs valeurs mais je n’y parviens pas car trop peu de connaissance dans ce langage.
    D’apres les post précédents il faut envoyer les valeurs en binaire, mais j’en suis incapable.

    J’ai ma fonction avec 2 variables (var1 & var2) de types différents (int & byte)

    void txData(){

    int var1 = 683;

    byte var2 = 16;

    comment dois je faire pour placer ces 2 valeurs dans la variable msg et la transmettre

    ??
    ??
    ??

    vw_send((uint8_t *)msg, strlen(msg));

    }

    void rxData(){

    Ici je souhaite récupérer mes valeurs var1 & var2

    uint8_t buf[VW_MAX_MESSAGE_LEN];
    uint8_t buflen = VW_MAX_MESSAGE_LEN;

    if (vw_get_message(buf, &buflen))
    {

    for (byte i = 0; i < buflen; i++){ // Si il n'est pas corrompu on l'affiche via Serial

    ??
    ??
    ??

    }

    Serial.println(var1);
    Serial.println(var2);

    }

    Merci par avance de votre aide

    Publié par Leon | 27 janvier 2016, 11 h 02 min
  82. Bonjour, comment se fait’il que je suis obliger d’ouvrir le moniteur série pour que l’émetteur commence a envoyer des données ?

    Publié par fab | 23 février 2016, 18 h 46 min
  83. Merci pour le tuto! C’est tout à fait ce qu’il me fallait:)

    Publié par Enikka | 28 février 2016, 17 h 31 min
  84. Bonjour, Merci pour ce tuto, il est très complet (quoique un peti schéma sur fritzing serait super sympa) et le code est vraiment intéressant.

    Mais voilà j’ai une question….
    Je voudrais faire un drone basé sur une carte arduino qui serait elle même piloté par une autre carte arduino…
    Pour la communication sans fil j’ai cherché un système peu chère et je suis tombé sur les émetteurs récepteurs RF 434MHz.
    Je veux que le drone soit en liaison constante et à une faible distance de la télécommande arduino mais cela me pose certains problèmes:
    Premièrement, je ne suis pas sûr que la vitesse d’envoi des données soit suffisante (je veux juste 16 signaux différents) et que le signal soit assez long pour contenir assez d’information.
    Deuxièmement, est ce que la corruption des signal est fréquente ? Je veux garder une liaison constante (une erreur pourrait entraîner un crash) et je compte l’utiliser dans un milieu limité en fréquence hertzienne (au milieu des champs)

    Donc, selon vous est ce que le choix d’un module de 434MHz pour une liaison avec un drone en temps réel est une bonne idée ?
    Je sais qu’il existe mieux mais je veux une liaison à faible coût et très légère au niveau du poids…

    Merci de votre attention
    Cordialement,
    Arthur P

    Publié par Arthur P | 7 mars 2016, 21 h 29 min
  85. Bonjour Sky !

    je voudrais rajouter deux scripts : un pour l’émission de la température relevé à l’aide d’une sonde DS18B20, l’autre la réception de la température.
    On y voit que la longueur d’un message transmis doit être de 27 caractères maximum, et la reconstitution des chiffres et du nombre grave à la fonction : toFloat

    Voici la partie émission de 4 nombres positifs et négatifs :

    // transmitter.pde
    //
    // Simple example of how to use VirtualWire to transmit messages
    // Implements a simplex (one-way) transmitter with an TX-C1 module
    //
    // See VirtualWire.h for detailed API docs
    // Author: Mike McCauley (mikem@airspayce.com)
    // Copyright (C) 2008 Mike McCauley
    // $Id: transmitter.pde,v 1.3 2009/03/30 00:07:24 mikem Exp $

    #include
    #include // Inclusion de la librairie OneWire
    const int led_pin = 11; // pin de reception
    const int transmit_pin = 12; // pin de transmission
    const int receive_pin = 2;
    const int transmit_en_pin = 3;
    #define DS18B20 0x28 // Adresse 1-Wire du DS18B20
    #define BROCHE_ONEWIRE 7 // Broche utilisée pour le bus 1-Wire
    OneWire ds(BROCHE_ONEWIRE); // Création de l’objet OneWire ds
    float tempa, tempb; // temperature mesuree et son inverse pour avoir un chiffre negatif

    static char dtostrfbuffer[15],dtostrfbufferm[15],somme[15];
    static char sprintfbuffer[15];

    // Fonction recuperant la temperature depuis le DS18B20
    // Retourne true si tout va bien, ou false en cas d’erreur
    boolean getTemperature(float *temp){
    byte data[9], addr[8];
    // data : Donnees lues depuis le scratchpad
    // addr : adresse du module 1-Wire detecte

    if (!ds.search(addr)) { // Recherche un module 1-Wire
    ds.reset_search(); // Reinitialise la recherche de module
    return false; // Retourne une erreur
    }
    if (OneWire::crc8(addr, 7) != addr[7]) // Verifie que l’adresse a ete correctement reesolue
    return false; // Si le message est corrompu on retourne une erreur
    if (addr[0] != DS18B20) // Verifie qu’il s’agit bien d’un DS18B20
    return false; // Si ce n’est pas le cas on retourne une erreur
    ds.reset(); // On reset le bus 1-Wire
    ds.select(addr); // On selectionne le DS18B20
    ds.write(0x44, 1); // On lance une prise de mesure de temperature
    delay(800); // Et on attend la fin de la mesure
    ds.reset(); // On reset le bus 1-Wire
    ds.select(addr); // On selectionne le DS18B20
    ds.write(0xBE); // On envoie une demande de lecture du scratchpad

    for (byte i = 0; i < 9; i++) // On lit le scratchpad
    data[i] = ds.read(); // Et on stock les octets resolus

    // Calcul de la temperature en degre Celsius
    // *temp = ((data[1] << 8) | data[0]) * 0.0625;
    tempa = ((data[1] << 8) | data[0]) * 0.0625;
    // Pas d'erreur
    return true;
    }
    void setup()
    {
    Serial.begin(9600); // Debugging only
    Serial.println("Transmetteur ds18b20");
    // Initialise the IO and ISR
    vw_set_tx_pin(transmit_pin);
    vw_set_rx_pin(receive_pin);
    vw_set_ptt_pin(transmit_en_pin);
    vw_set_ptt_inverted(true); // Required for DR3100
    vw_setup(2000); // Bits per sec
    pinMode(led_pin, OUTPUT);
    }
    byte count = 1;
    void loop()
    {
    // Lit la temperature ambiante a ~1Hz
    if(getTemperature(&tempa)) {
    tempb = – tempa;
    // Affiche la temperature
    Serial.print("Temperature : ");
    Serial.print(tempa);
    Serial.write(176); // caractere °
    Serial.write('C');
    Serial.println();
    dtostrf(tempa,6, 2, dtostrfbuffer); // signe, deux chiffres et deux chiffres apres la virgule
    dtostrf(tempb,6, 2, dtostrfbufferm); // signe, deux chiffres et deux chiffres apres la virgule
    Serial.print("dtostrf positif ");
    Serial.print(dtostrfbuffer);
    Serial.print(" dtostrf negatif ");
    Serial.println(dtostrfbufferm);
    char msg1[256];
    // constitution du message :
    // un nombre positif / un nombre negatif / un nombre positif / un nombre negatif
    sprintf (msg1,"%s/%s/%s/%s",dtostrfbuffer,dtostrfbufferm,dtostrfbuffer,dtostrfbufferm);

    // calcul de la logueur du message
    float somma = float(strlen(msg1)); // calcul de la longueur du message dans somma
    dtostrf(somma,2,0, somme); // mise de la longueur dans somme en format 6.2
    Serial.print("longueur du message = ");
    Serial.print(somme);
    Serial.println(" =< la longueur maxi du message : 27 caracteres");

    digitalWrite(led_pin, HIGH); // Flash a light to show transmitting

    Serial.println(msg1);

    vw_send((uint8_t *)msg1, strlen(msg1)); // envoi du message des 4 nombres

    vw_wait_tx(); // Wait until the whole message is gone
    digitalWrite(led_pin, LOW);
    delay(1000);
    count = count + 1;
    }
    }

    puis la partie réception (le message n'est accepté que si le ChekSum est correct)

    #include <VirtualWire.h>
    
    // receiver (digital 11)
    //
    // Simple example of how to use VirtualWire to receive messages
    // Implements a simplex (one-way) receiver with an Rx-B1 module
    //
    // See VirtualWire.h for detailed API docs
    // Author: Mike McCauley
    // Copyright (C) 2008 Mike McCauley
    // $Id: receiver.pde,v 1.3 2009/03/30 00:07:24 mikem Exp $
    
    
    float a;
    #undef int
    #undef abs
    #undef double
    #undef float
    #undef round++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    void setup()
    {
        Serial.begin(9600);	// Debugging only
        Serial.print("Receiver longueur maximum du message :");
        Serial.print(VW_MAX_MESSAGE_LEN);
        Serial.println(" en fait 27 caracteres utiles");
        // Initialise the IO and ISR
        vw_set_ptt_inverted(true); // Required for DR3100
        vw_setup(2000);	 // Bits per sec
    
        vw_rx_start();       // Start the receiver PLL running
    }
    
    void loop()
    {
        uint8_t buf[VW_MAX_MESSAGE_LEN];
        uint8_t buflen = VW_MAX_MESSAGE_LEN;
         char msg[27];
    
        if (vw_get_message(buf, &buflen)) // Non-blocking
        {
    	int i;
            digitalWrite(13, true); // Flash a light to show received good message
    	// Message with a good checksum received, dump it.
    	Serial.print("Recu: ");
    	for (i = 0; i < buflen; i++)
    	{
    	    Serial.print((char)buf[i]);
    	}
    	Serial.println("");
            digitalWrite(13, false);
            
            // ecriture du message 
            
            for (i = 0; i < buflen; i++){ msg[i]= buf[i];
                    Serial.print((char)msg[i]);
            }
                    Serial.println("");
                    
                // décorticage du message  char => chiffre => nombre  
                
                Serial.print(" 1 "); // premier nombre
           String inString = "";    // string pour retenir les chiffres   
           float  a;                // float pour retenir le nombre
            for (i = 0; i < 6; i++){ msg[i]= buf[i];
                    Serial.print((char)msg[i]);
            inString += (char)msg[i]; // assemblage des chiffres
            }
                    Serial.println("");
                    Serial.print(" inString  : ");
                    Serial.println(inString);
            a = inString.toFloat(); // fabrication du nombre
                    Serial.print(" a  : ");
                    Serial.println(a);
     
                    Serial.print(" 2 "); // deuxieme nombre                
                    inString = "";
            for (i = 7; i < 13; i++){ msg[i]= buf[i];
                    Serial.print((char)msg[i]);
            inString += (char)msg[i]; // assemblage des chiffres
            }
                    Serial.println("");
                    Serial.print(" inString  : ");
                    Serial.println(inString);
            a = inString.toFloat(); // fabrication du nombre
                    Serial.print(" a  : ");
                    Serial.println(a);
    
                    Serial.print(" 3 "); // troisieme nombre                   
                    inString = "";
            for (i = 14; i < 20; i++){ msg[i]= buf[i];
                    Serial.print((char)msg[i]);
            inString += (char)msg[i]; // assemblage des chiffres
            }
                    Serial.println("");
                    Serial.print(" inString  : ");
                    Serial.println(inString);
            a = inString.toFloat(); // fabrication du nombre
                    Serial.print(" a  : ");
                    Serial.println(a);
    
                    Serial.print(" 4 "); // quatrieme nombre
                    inString = "";
            for (i = 21; i < 27; i++){ msg[i]= buf[i];
                    Serial.print((char)msg[i]);
            inString += (char)msg[i]; // assemblage des chiffres
            }
                    Serial.println("");
                    Serial.print(" inString  : ");
                    Serial.println(inString);
            a = inString.toFloat(); // fabrication du nombre
                    Serial.print(" a  : ");
                    Serial.println(a);
    
        }
    }
    
    

    Publié par Bernard Barrois | 15 mars 2016, 22 h 20 min
  86. Désolé le premier script est mal passé je retente :

    #include <VirtualWire.h>
    
    // receiver (digital 11)
    //
    // Simple example of how to use VirtualWire to receive messages
    // Implements a simplex (one-way) receiver with an Rx-B1 module
    //
    // See VirtualWire.h for detailed API docs
    // Author: Mike McCauley
    // Copyright (C) 2008 Mike McCauley
    // $Id: receiver.pde,v 1.3 2009/03/30 00:07:24 mikem Exp $
    
    
    float a;
    #undef int
    #undef abs
    #undef double
    #undef float
    #undef round++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    void setup()
    {
        Serial.begin(9600);	// Debugging only
        Serial.print("Receiver longueur maximum du message :");
        Serial.print(VW_MAX_MESSAGE_LEN);
        Serial.println(" en fait 27 caracteres utiles");
        // Initialise the IO and ISR
        vw_set_ptt_inverted(true); // Required for DR3100
        vw_setup(2000);	 // Bits per sec
    
        vw_rx_start();       // Start the receiver PLL running
    }
    
    void loop()
    {
        uint8_t buf[VW_MAX_MESSAGE_LEN];
        uint8_t buflen = VW_MAX_MESSAGE_LEN;
         char msg[27];
    
        if (vw_get_message(buf, &buflen)) // Non-blocking
        {
    	int i;
            digitalWrite(13, true); // Flash a light to show received good message
    	// Message with a good checksum received, dump it.
    	Serial.print("Recu: ");
    	for (i = 0; i < buflen; i++)
    	{
    	    Serial.print((char)buf[i]);
    	}
    	Serial.println("");
            digitalWrite(13, false);
            
            // ecriture du message 
            
            for (i = 0; i < buflen; i++){ msg[i]= buf[i];
                    Serial.print((char)msg[i]);
            }
                    Serial.println("");
                    
                // décorticage du message  char => chiffre => nombre  
                
                Serial.print(" 1 "); // premier nombre
           String inString = "";    // string pour retenir les chiffres   
           float  a;                // float pour retenir le nombre
            for (i = 0; i < 6; i++){ msg[i]= buf[i];
                    Serial.print((char)msg[i]);
            inString += (char)msg[i]; // assemblage des chiffres
            }
                    Serial.println("");
                    Serial.print(" inString  : ");
                    Serial.println(inString);
            a = inString.toFloat(); // fabrication du nombre
                    Serial.print(" a  : ");
                    Serial.println(a);
     
                    Serial.print(" 2 "); // deuxieme nombre                
                    inString = "";
            for (i = 7; i < 13; i++){ msg[i]= buf[i];
                    Serial.print((char)msg[i]);
            inString += (char)msg[i]; // assemblage des chiffres
            }
                    Serial.println("");
                    Serial.print(" inString  : ");
                    Serial.println(inString);
            a = inString.toFloat(); // fabrication du nombre
                    Serial.print(" a  : ");
                    Serial.println(a);
    
                    Serial.print(" 3 "); // troisieme nombre                   
                    inString = "";
            for (i = 14; i < 20; i++){ msg[i]= buf[i];
                    Serial.print((char)msg[i]);
            inString += (char)msg[i]; // assemblage des chiffres
            }
                    Serial.println("");
                    Serial.print(" inString  : ");
                    Serial.println(inString);
            a = inString.toFloat(); // fabrication du nombre
                    Serial.print(" a  : ");
                    Serial.println(a);
    
                    Serial.print(" 4 "); // quatrieme nombre
                    inString = "";
            for (i = 21; i < 27; i++){ msg[i]= buf[i];
                    Serial.print((char)msg[i]);
            inString += (char)msg[i]; // assemblage des chiffres
            }
                    Serial.println("");
                    Serial.print(" inString  : ");
                    Serial.println(inString);
            a = inString.toFloat(); // fabrication du nombre
                    Serial.print(" a  : ");
                    Serial.println(a);
    
        }
    }
    
    

    Publié par Bernard Barrois | 15 mars 2016, 22 h 23 min
  87. salut tout le monde j’utilise un touchscreen et donc j’ai que la broche 0 ou 1 de libre comment je fais pour modifier les valeurs par défaut du recepteur ?

    Publié par QUENTIN WAVELET | 16 mars 2016, 22 h 08 min
  88. Bonjour,
    J’ai réalisé le montage avec des émetteurs et récepteur du même type (Emetteur 433.92 MHz « RT6-433 » et Récepteur 433,92 MHz « RR3-433 »). Les données s’envoient quand je met le moniteur série de l’émetteur mais elles ne sont pas réceptionnées sur le moniteur série du récepteur. J’ai branché le tout sur une plaque Arduino accompagnée de 2 cartes Arduino.

    Publié par Benjamin | 29 mars 2016, 14 h 00 min
  89. donc la portée de ton système n’excède pas les 10 15 m ?

    Publié par juju | 7 avril 2016, 16 h 18 min
    • dsl en fait c’est avec des composant chinois 10-15m et avec ton système ça dépend de la vitesse de transmission des données comme indiqué a la fin de ton article. Es ce bien cela ??

      Publié par juju | 7 avril 2016, 16 h 24 min
  90. Bonjour , j’utilise pour émetteur un AUREL TX-8L25IA ( 868.3 MHz) et pour récepteur un AUREL RX-AM8SF ( 868.3 MHz) , j’ai testé le programme , mais la partie réception ne marche pas , y a t’il des modification a faire dans les programmes par rapport a mes émetteur récepteur de même fréquence ? Merci de votre réponse

    Publié par Nicolas | 18 avril 2016, 10 h 13 min

Rétroliens/Pings

  1. Pingback: Modules AM 433/868 MHz | LibreRuche - 10 juillet 2012

  2. Pingback: Arduino + module 433Mhz simple | blog de laurent - 7 octobre 2013

  3. Pingback: [Tutoriel] Arduino et émetteur/ré... - 22 janvier 2014

  4. Pingback: » came code finder - 26 février 2014

  5. Pingback: RFXtrx433 | Pearltrees - 19 mars 2014

  6. Pingback: RF433MHz | Pearltrees - 5 juin 2015

  7. Pingback: r2d2 | Pearltrees - 13 juillet 2015

  8. Pingback: ARDUINO - christophelucas | Pearltrees - 29 juillet 2015

  9. Pingback: RF 433Mhz | Pearltrees - 25 août 2015

  10. Pingback: Connexion rf entre arduino - La programmation pour tous - 20 mai 2016

Skyduino devient Carnet du Maker

Le site Carnet du Maker remplace désormais le blog Skyduino pour tout ce qui touche à l'Arduino, l'informatique et au DIY.

Suivre

Recevez les nouvelles publications par mail.

Rejoignez 1 005 autres abonnés