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

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

Bonjour tout le monde !

J’espère que les fêtes se sont bien passées pour vous aussi et que le réveil du lendemain n’a pas était trop dur ;)

Aujourd’hui je vous est préparé un tutoriel sur la librairie VirtualWire, qui permet (comme son nom l’identique) de créer un câble "virtuel" entre deux arduino.

Alors quand je dis "câble virtuel" je sous entends sans fil, et pas n’importe quel module sans fil.
La librairie VirtualWire a été créée pour fonctionner des modules émetteurs / récepteurs 433MHz, modules que je vais vous présenter dans ce billet.

Avant tout chose il vous faudra l’ide arduino et la librairie VirtualWire disponible ici : http://www.open.com.au/mikem/arduino/
(pour les curieux il y a d’autre librairies sympa sur ce site ;))

Mon tutoriel est en grande partie une version francisé du pdf d’utilisation de VirtualWire mais je vais quand même rajouter quelque petits choses qui ne sont pas expliquées dedans ;)

L’avantage de la librairie VirtualWire c’est quelle permet de mettre en communication plusieurs arduino en utilisant des modules sans-fil low-cost (~5€ pour les miens) tout en assurant une transmission parfaite de l’information (via un systéme de checksum).

La librairie VirtualWire permet d’envoyer des messages binaires (du texte ou des données brutes (structures, variables, …)) à la manière d’un paquet UDP sur un réseau ethernet, c’est à dire sans adressage (pas d’envoi vers l’arduino n spécifiquement, c’est du "broadcasting"), sans retransmission en cas d’erreur (si le message est corrompu, il est ignoré) et sans ACK (Acknowledge) (il serait donc intéressant de prévoir un mini système de question/réponse entre les deux arduino dans le cadre d’une application sérieuse).
Pour fonctionner la librairie VirtualWire implémente en software un algorithme de ASK (Amplitude Shift Keying).
(Si vous êtes curieux : http://en.wikipedia.org/wiki/Amplitude-shift_keying)

L’avantage d’une transmission ASK c’est que le signal d’horloge est synchronisé sur le signal reçu, ce n’est pas le cas avec Serial, au départ j’avais prévu de voir faire ce tutoriel en deux parties, une partie VirtualWire et une partie Serial, mais les problèmes de synchronisation avec Serial sont assez problématiques, par conséquent je vais juste faire la partie VirtualWire.

Trêve de bavardage techniques. Vous avez installé la librairie VirtualWire ? Votre ide arduino est ouvert ? Ok Let’s GO !

Tout d’abord la partie hardware, il va nous falloir :
– deux cartes arduino, une pour émettre et une pour recevoir,
– un émetteur 433MHz et un récepteur 433MHz (~5€ piéce exemple : émetteur & récepteur)
– des câbles, dont deux d’au moins ~20cm (ils vont nous servir d’antennes).

Le câblage :

Le Récepteur :

récepteur -> Arduino
GND -> GND
DATA -> D11
VCC -> 5V
(+ Antenne)

L’émetteur :

Arduino -> émetteur
GND -> GND
D12 -> DATA
5V -> VCC
(+ Antenne)

Avant de vous donner les deux sketch arduino émetteur / récepteur voici le descriptif des fonctions de la librairie virtualWire :

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

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

vw_set_ptt_pin
extern void vw_set_ptt_pin(uint8_t pin);
Définie la broche utilisée comme broche ENABLE (aka broche PTT ou "Press to talk", les émetteurs low-cost ont rarement cette fonctionnalité), par défaut D10.

vw_set_ptt_inverted
extern void vw_set_ptt_inverted(uint8_t inverted);
Définie l’état "actif" de la broche PTT, si inverted = false -> HIGH, si inverted = true -> LOW

vw_setup
extern void vw_setup(uint16_t speed);
Initialise la librairie et assigne la vitesse de transmission (dans mon cas mon couple Rx/Tx peut allez jusqu’à 2400 bauds).
Note: plus la vitesse de transmission est lente plus la porté est accentué, au contraire une vitesse de transmission élevée diminuera la porté du signal.
Note 2 : Après l’appel d’une fonction vw_set_****** vous devrez toujours rappeler la fonction vw_rx_start() sinon vous ne recevrez jamais de messages.

vw_rx_start
extern void vw_rx_start();
Déclenche l’interruption gérant le signal en réception, c’est cette fonction qui "démarre" la partie réception de la librairie VirtualWire.

vw_rx_stop
extern void vw_rx_stop();
Arrête l’interruption gérant le signal en réception, c’est cette fonction qui "arrête" la partie réception de la librairie VirtualWire.

vx_tx_active
extern uint8_t vx_tx_active();
Retourne true si la partie transmission de la librairie VirtualWire est active.

vw_wait_tx
extern void vw_wait_tx();
Fonction bloquante qui attend la fin de la transmission en cours avant de rendre la main à la suite du programme.

vw_wait_rx
extern void vw_wait_rx();
Fonction bloquante qui attend l’arrivée d’un nouveau message avant de rendre la main à la suite du programme.

vw_wait_rx_max
extern uint8_t vw_wait_rx_max(unsigned long milliseconds);
Fonction bloquante AVEC TIMEOUT (en millisecondes) qui attend l’arrivée d’un nouveau message ou le dépassement du timeout avant de rendre la main à la suite du programme.

vw_send
extern uint8_t vw_send(uint8_t* buf, uint8_t len);
Transmet un message de taille len à partir des données contenues dans le tableau buf (de type uint8_t, soit unsigned char).
Rend la main à la suite du programme immédiatement la plus part du temps (suivant la taille len).
Retourne true s’il n’y a pas d’incohérence entre len et VW_MAX_PAYLOAD (taille maximum par envoi).

vw_have_message
extern uint8_t vw_have_message();
Retourne true si un message à était reçu, que celui ci ait une bonne ou une mauvaise checksum !!

vw_get_message
extern uint8_t vw_get_message(uint8_t* buf, uint8_t* len);
Copie le message reçu dans buf avec comme limite à ne pas dépasser len, si le message dépasse len celui ci sera tronqué.
Le message est copié dans buf que celui ait une bonne ou une mauvaise checksum, cependant la fonction ne retournera true que si la checksum est valide (sinon false).

Voila j’en est fini avec les fonctions de la librairie, à présent vous devriez pouvoir comprendre sans trop de problèmes les deux sketch suivant :

Partie émetteur :

#include <VirtualWire.h> // inclusion de la librairie VirtualWire

const char *msg = "Arduino"; // Tableau qui contient notre message

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 ... "); // On signale le début de l'envoi
    vw_send((uint8_t *)msg, strlen(msg)); // On envoie le message 
    vw_wait_tx(); // On attend la fin de l'envoi
    Serial.println("Done !"); // On signal la fin de l'envoi
	delay(1000); // Et on attend 1s pour pas flooder
}

Partie récepteur :

#include <VirtualWire.h> // 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

    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("");
		}
    }
}

Petit précision par rapport aux émetteurs 433MHz, il sont très souvent employés pour les télécommandes sans fil (porte de garage, lampe domotique, etc …) si dans votre programme vous recevez des messages indésirable c’est surement que vous avez capté le signal d’une de ces télécommandes.
Par le passé par exemple j’ai (sans le vouloir) bloqué mon ouverture de portail en envoyant trop de choses à la fois et en continu.
(Pour les petits malins, il faut un NE555 générant un signal carré de 1KHz pour bloquer complétement toute télécommande sur 433MHz dans les 50 métres aux alentours. ;)).

Le principe de mon code est simple, le 1er arduino va envoyer "arduino" au second arduino qui va l’afficher sur le serial monitor, voici ce que ce la donne :

(Ps: il n’est pas possible de faire un test de réception + émission en simultané avec une seul carte arduino, il vous faut absolument deux cartes)

VirtualWire, simple, rapide, et efficace, que demander de plus ;)

Détails technique pour les Hackers :)
Les message peuvent faire au maximum 27 octets.
Chaque message est transmit de cette maniére :
• 36 bits de préambule (couple de 0 & 1),
• 12 bits formant le "symbole" de start (0xb38 en hexa),
• 1 octets définissant la longueur du message (de 4 à 30), checksum compris,
• n octets du message,
• 2 octets de checksum.

Par rapport à ma note sur l’importance du couple vitesse / porté (tiré du pdf de VirtualWire) :
At 7000bps, Range about 90m
At 5000bps, Range about 100m
At 2000bps, Range over 150m
At 1000bps, Range over 150m

Les distances sont relativement identiques avec mon émetteur, seulement je n’ai mesuré que sur la plage 1000 – 2400 bauds (plage de mon émetteurs) et non 1000 – 7000 bauds.

About these ads

Discussion

141 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
  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
  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
  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 :D

    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
  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
  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
  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
  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
  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

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

Laisser un commentaire

Entrez vos coordonnées ci-dessous ou cliquez sur une icône pour vous connecter:

Logo WordPress.com

Vous commentez à l'aide de votre compte WordPress.com. Déconnexion / Changer )

Image Twitter

Vous commentez à l'aide de votre compte Twitter. Déconnexion / Changer )

Photo Facebook

Vous commentez à l'aide de votre compte Facebook. Déconnexion / Changer )

Photo Google+

Vous commentez à l'aide de votre compte Google+. Déconnexion / Changer )

Connexion à %s

Archives

Wow. Dogecoin. Amaze.

Laissez un tip en Dogecoin

DMMNFk6WBVTpx2Wu1Z35GL61QXSd6r6WQx

Suivre

Recevez les nouvelles publications par mail.

Rejoignez 725 autres abonnés