Communication rf entre deux arduinos

Communication rf entre arduino
Share Button

Un des moyens efficaces et peu coûteux pour faire communiquer (transmettre) deux arduinos passe par l’utilisation d’un couple émetteur/récepteur. Sa mise en place se fait grâce la librairie virtualwire, qui permet une mise en place simple et rapide. 

Dans un des futurs petits projets que je veux réaliser, j’ai besoin d’envoyer les données mesurées d’un capteur provenant d’un arduino et de les envoyer vers un second arduino. J’ai opté pour une communication rf (radio-fréquence) moins gourmande qu’une connexion wifi et plus esthéqtique qu’une connexion filaire. Pour la réalisation, j’utilise cet arduino nano.

Le couple émetteur/récepteur rf

J’ai opté pour ce couple émetteur/récepteur dont la consommation est aux alentours de 5mA.

Sa portée varie, annoncée pour une zone ouverte de 500 m. Je tâcherai de tester cette distance qui me paraît un peu énorme. Différents sites parle plutôt d’une distance de plusieurs dizaines de mètres.

Emetteur récepteur rf pour arduino

Emetteur récepteur rf pour arduino

Disposition des broches

Voici une petite image pour l’emplacement et rôle des pins.

Pin et disposition des broches

Pin et disposition des broches

Il n’y a pas de difficulté particulières.

Pour le récepteur rf

Le récepteur est à droite sur la photo précédente, il se branche sur la broche D11 de votre arduino qui sera le récepteur de votre montage.

Le choix de la broche est celui par défaut que j’utiliserai pour ce tuto.

Pour l’émetteur rf

Le récepteur est le composant à gauche de la photo, sa broche data ira sur la broche D12 de votre arduino qui sera l’émetteur.

De la même manière, c’est la broche qui est par défaut pour ce tuto.

Le script du montage

Installation de la librairie VirtualWire

Afin d’utiliser facilement votre module rf, il faut télécharger la librairie de virtualwire, disponible sur ce site.

Une fois télécharger, ne dé-zipper pas le fichier, se rendre sur le logiciel arduino (tutoriel pour l’installation d’arduino).

Aller chercher ajouter la bibliothèque ZIP comme sur l’image qui suit :

installation librairie arduino

installation librairie arduino

Puis aller chercher le fichier ZIP et valider.

Script pour l’émetteur

Pour le script, j’ai pioché sur internet et notamment sur ce site : skyduino.wordpress.com, je n’y ai quasiment pas touché sauf pour un point que j’expliquerai plus bas.

Script pour le récepteur

Résultat après versement des script dans les deux arduinos

affichage test rf sur arduino

affichage test rf sur arduino

Problèmes rencontrés lors du test rf

Affichage des caractères

Mis à part le soucis d’un récepteur défaillant qui m’a fait tourné en rond longtemps, j’ai eu un soucis d’affichage. Le script précédent fait que l’émetteur envoi le mot Arduino au récepteur, dans mes premiers tests, le récepteur m’affiché une série de chiffre, après quelques recherches, il s’agissait du code ASCII du caractère (format envoyé par la librairie VirtualWire).

Le code présent sur le site de skyduino ne permet d’afficher que ce code ASCII, l’affichage se faisait par :

Pour pouvoir afficher le caractère correspondant, il faut mettre :

Ceci permet d’afficher le caractère correspond au code ASCII.

Ce petit détail m’a pris un peu de temps alors que c’était très simple, c’est pourquoi, je préfère le mettre noir sur blanc.

Changer les pins de branchements

Par défaut, VirtualWire utilise la broche D12 pour l’émetteur et la broche D11 pour le récepteur. Pour la modifier

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

Les fonctions disponibles dans la bibliothèque VirtualWire

Je place cette partie volontairement en fin d’article, car l’exemple permet largement de bien appréhender la librairie.

  • 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).

Voilà, maintenant c’est à vous de vous amuser.

Share Button

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *