Club robotique de Sophia-Antipolis

Accueil > POBOTpedia > Communications > Communications sans fil > Tester une communication série sans-fil

Tester une communication série sans-fil

lundi 20 mai 2013, par Julien H.

Remplacer les câbles par une liaison sans-fil, c’est devenu facile et peu onéreux avec des modules radio 433 MHz ou 2,4 GHz (802.15.4) mais hormis certains protocoles (Bluetooth, Wifi), il n’y a pas de correction d’erreurs. Il faut donc savoir mesurer les pertes auxquelles s’attendre.

Pour réaliser ce test, nous avons utilisé des modules XBee et des cartes Arduino parce que nous les avions sous la main, mais le code peut être utilisé avec toute autre liaison sans-fil (voire même filaire si vous pensez avoir des pertes de connexion).

D’autres solutions existent, notamment par la mesure de la puissance du signal. C’est aussi une donnée intéressante, surtout pour fixer des relais ou valider une solution antiparasites sur un robot mobile.

 Matériel

- une carte Arduino Romeo V2 (pour son support intégré) dispo chez Zartronic
- un module à écran LCD keypad shield de DFRobot dispo chez Zartronic
- deux modules XBee série 1 (802.15.4) dispos chez MATLOG
- un support USB/XBee ou simple adaptateur dispo chez MATLOG
- câbles USB ou batteries pour pouvoir bouger

Il s’agit bien sûr de matériel de test réutilisable. Une solution moins onéreuse peut se faire si vous dédiez ces composants à un usage unique.

JPEG - 76.3 ko
Interface de visualisation des statistiques
Affichage sur un écran des différentes valeurs en temps réel et en statistiques : nombre d’erreurs, durées moyenne et maximum

 Assemblage

Plutôt que d’utiliser deux micro-contrôleurs, un de chaque côté, nous avons soudé un câble (on appelle ça un "shunt") entre la patte DO et DI (data out / data in) d’un des deux modules - ou plutôt sur le support - ce qui revient au même que de relier RX et TX (si vous utilisez une liaison série filaire). Ainsi, toute donnée envoyée par le module est aussitôt renvoyée, sans traitement. Comme ce n’est pas un test de débit mais un test de perte de signal, ce n’est pas impactant sur le résultat, et cela limite les erreurs.

 Code source

L’archive est disponible en téléchargement :

Zip - 1.1 ko
Protocole de test d’une liaison série
#include <LiquidCrystal.h>
// déclaration de l'écran LCD connecté à l'Arduino
LiquidCrystal lcd(8,9,4,5,6,7);
// nombre de messages envoyés et reçus
long msg_envoi = 0;
long msg_recu = 0;
// nombre de ms à l'instant du dernier envoi et de la dernière réception (pour mesurer l'écart)
long last_sent = 0;
long last_seen = 0;
// caractère envoyé (s = sent) et reçu (r = receive)
int s = 0;
int r = 0;
// temps écoulé pour la dernière coupure
long last_err = 0;
// temps maximum écoulé pour une coupure
long max_err = 0;
// temps moyen d'une coupure
long moyenne = 0;
// nombre de coupures connues depuis le début
long count = 0;
boolean coupure = false;
void setup()
{
  // deux liaisons séries : celle de l'USB et celle du XBee
  Serial.begin(9600);
  Serial1.begin(9600);
  // initialisation de l'écran I2C
  lcd.begin(16, 2);            
  lcd.setCursor(0,0);
  lcd.print("Test XBee");
  delay(1000);
  lcd.clear();
}
void loop()
{  
  Serial1.write(s);
  delay(10);
  lcd.setCursor(15,0);
  lcd.write(s);
  s++;
  msg_envoi++;
  last_sent = millis();
  while (Serial1.available() > 0) {
    // nouvelle réception    
    r = Serial1.read();
    last_seen = millis();
    lcd.setCursor(15,1);
    lcd.write(r);
    msg_recu++;
  }
  if (millis() < 3000) {
      // on ne prend pas en compte les 3 premières secondes
  }
  else {
    // vérifier si on est en connexion ou en coupure
    if (last_sent-last_seen > 1)
    {  
      if (!coupure) {
        count++;
        coupure = true;
      }
      last_err = last_sent-last_seen;
      max_err = max(last_err,max_err);
    }
    else {
      if (coupure) {
        // fin de la coupure
        coupure = false;
        moyenne = (moyenne*(count-1)+last_err)/count;
      }
    }
  }
  // affichage des secondes
  lcd.setCursor(0,1);
  lcd.print(millis()/1000);
  lcd.print("s ");
  // affichage du nombre d'erreurs depuis le début
  lcd.print(count);
  lcd.print(" erreurs");
  // affichage des stats
  lcd.setCursor(0,0);
  lcd.print(100*msg_recu/msg_envoi);
  lcd.print("% ");
  // alterner les affichages
  switch ((millis()/1000)%3) {
  case 0:
    if (max_err > 5000) {
      lcd.print(max_err/1000);
      lcd.print("s max ");
    }
    else {
      lcd.print(max_err);
      lcd.print("ms max");      
    }
    break;
  case 1:
    if (moyenne > 5000) {
      lcd.print(moyenne/1000);
      lcd.print("s moy ");
    }
    else {
      lcd.print(moyenne);
      lcd.print("ms moy");
    }
    break;
  case 2:
    if (last_err > 5000) {
      lcd.print(last_err/1000);
      lcd.print("s der ");
    }
    else {
      lcd.print(last_err);
      lcd.print("ms der");
    }
    break;
  }
  if (coupure) {
    lcd.print("!");
  }
  else {
    lcd.print(" ");
  }
}

A noter l’usage de la liaison série "Serial1" spécifique aux cartes Leonardo qui ont un port série sur l’USB et un port série disponible (ici connecté au XBee par la carte toute intégrée Romeo V2).

 Résultats

Avec un émetteur et un récepteur séparés par 60 centimètres et un peu d’activité (ordinateurs, passage), voilà ce qu’on obtient sur un test de 180 secondes (3 minutes) :

- 95% d’octets bien reçus
- 31 erreurs
- une moyenne de 248 ms de durée d’interruption
- une interruption la plus longue de 6 secondes

Un autre test de même durée avec les modules sans-fil côte à côte n’a montré qu’une seule erreur de 22 ms, et toujours que 4 erreurs de même moyenne au bout de 812 secondes (le temps d’écrire cet article !)

Vos commentaires

  • Le 20 mai 2013 à 22:12, par Llorenç En réponse à : Tester une communication série sans-fil


    Hum, très intéressant ...
    _
    A une distance de 60 cm c’est surprenant de voir tant d’erreurs.
    Dans quel mode était les XBee ? De mémoire il y a deux modes principaux : la diffusion et le point à point. En mode diffusion il n’y a pas de vérification d’erreurs alors qu’en mode point à point il y en a une (retransmission 3 fois de la donnée). Un taux d’erreurs aussi important laisserait à penser que les XBee étaient en mode diffusion.
    Pour l’expérimentation suivante, ce pourrait être un plus de savoir si le canal utilisé versus la puissance du signal reçu à une influence sur les résultats (à priori oui...)
    il y a également un autre point qui peut entrer en compte, c’est la vitesse de transmission.
    Si on transmet plus vite que le tampon ne peut se vider, cela peut engendrer des pertes de données.
    Mais dans l’exemple ce n’est pas le cas puisqu’en considérant le temps CPU négligeable, on émet au mieux 8bits/10ms soit 800bps.

    • Le 20 mai 2013 à 22:54, par Julien H. En réponse à : Tester une communication série sans-fil

      Tu peux nous en dire plus sur ces deux modes ? Est-ce qu’en mode point à point on peut utiliser des répéteurs ?

    • Le 20 mai 2013 à 23:01, par Eric P. En réponse à : Tester une communication série sans-fil

      Je pense qu’il s’agit du broadcast versus l’adressage explicite du destinataire.
      En tout cas je n’en vois pas d’autres au niveau de la communication radio du XBee.

    • Le 24 mai 2013 à 21:55, par Julien H. En réponse à : Tester une communication série sans-fil

      Ok après vérification, le code était un peu trop exigeant puisqu’il mesurait aussi le temps de transfert... à 0 millisecondes !

      Une fois revenu à quelque chose de plus raisonnable (1 ms), c’est du 100% tout le temps.

    Répondre à ce message

  • Le 20 mai 2013 à 22:35, par Eric P. En réponse à : Tester une communication série sans-fil

    Je suis également surpris par un tel taux d’erreur sur une transmission aussi courte.
    Pour info, j’ai utilisé des XBee série 1 il y a plusieurs années pour des projets de recherche dans le domaine de l’instrumentation de lieux de vie par des réseaux de capteurs. Nous avons travaillé jusqu’aux limites de la portée des XBee, et n’avons pas enregistré de pertes de cet ordre. Les communications capteur->base étaient en broadcast pour éviter de devoir configurer un par un les transmetteurs embarqués sur les capteurs. La reconnaissance était faite par la base (ie le soft de la box de collecte) en se basant sur l’adresse MAC du XBee capteur.
    A mon avis, il faudrait faire la part des choses entre les erreurs imputables aux XBee et celles qui sont la conséquence des divers overheads liés au protocole de test utilisé ici, à savoir :
    - les autres traitements (ex : le LCD)
    - la sur-couche Arduino.
    Un test à faire serait donc de ré-écrire la manip en code AVR pur et dur (en reprenant par exemple certains exemples publiés sur ce site quelques années auparavant ;) et en supprimant les perturbations (ex : le LCD) pendant la mesure de la qualité de la communication. Ce qui veut dire qu’on peut par contre ré-organiser la logique en faisant tout d’abord une mesure de la qualité de communication, puis l’affichage de son résultat, et boucler globalement sur cette séquence.

    • Le 20 mai 2013 à 22:53, par Julien H. En réponse à : Tester une communication série sans-fil

      L’explication est beaucoup plus simple, c’est le peu de fiabilité du câble USB utilisé pour alimenter la carte adaptateur du XBee, et que je bougeais. Quand je ne touchais à rien, je n’obtenais aucune perte, comme je l’ai dit dans la fin de l’article.
      Mais effectivement c’est un résultat qui est curieux. Alors, qui est partant pour continuer ces tests mercredi ??

    • Le 20 mai 2013 à 23:03, par Eric P. En réponse à : Tester une communication série sans-fil

      C’est certain que si on lui chahute l’alimentation ou la liaison USB, "il va moins bien marcher maintenant" comme le disait Bourvil.

    Répondre à ce message

Un message, un commentaire ?

modération a priori

Attention, votre message n’apparaîtra qu’après avoir été relu et approuvé.

Qui êtes-vous ?

Pour afficher votre trombine avec votre message, enregistrez-la d’abord sur gravatar.com (gratuit et indolore) et n’oubliez pas d’indiquer votre adresse e-mail ici.

Ajoutez votre commentaire ici
  • Ce formulaire accepte les raccourcis SPIP [->url] {{gras}} {italique} <quote> <code> et le code HTML <q> <del> <ins>. Pour créer des paragraphes, laissez simplement des lignes vides.

Ajouter un document