Turb(l)o(g)

Crédit photo : Marlon J. Manrique

Un robot qui se promène tout seul, c’est fun, mais on s’en lasse vite, surtout quand on a peu de metres carrés exploitables. Comme je le disais dans l’article précédent, l’étape suivante, c’est de pouvoir piloter le robot.

Il y a la méthode cheap à l’ancienne, avec de l’infrarouge, mais ça marche franchement pas bien et la porté est très limitée. Ceci dit, c’est le plus facile à mettre en oeuvre et on peut faire parler n’importe quelle télécommande avec l’arduino, y compris le vieux bidule de l’ancienne freebox qui traîne dans un coin.

Mais pour faire une vrai télécommande, de nos jours, on utilise de la radio, et si possible, du 2.4Ghz, fréquence de résonance de l’eau apte à tous nous coller des cancer du cerveau (que j’ai toujours pas compris pourquoi, d’ailleurs … J’veux dire, pourquoi on a déployé tant de bidules qui utilisent cette fréquence ? pourquoi pas 3.4Ghz ?)

En matière de radio, j’avais depuis longtemps deux petites xBee au fond de mes tiroirs et je n’en avais jamais rien fait à part les faire parler ensemble. Ce sont deux petits modules à la norme ZigBee qui font environ 2cm² pour 5 millimètres d’épaisseur et qui savent discuter un peu comme le font des points d’accès et des clients wifi, soit en mode infrastructure avec une xBee centrale soit en mode adhoc avec une très bonne gestion de la communication qui permettent à un réseau de xBee de s’autoconfigurer pour faire transiter l’information d’un bout à l’autre même si ces deux extrémités ne peuvent pas communiquer directement.

Nous n’en sommes pas encore à ce genre de haute voltige, je voudrais juste, dans un premier temps, que le robot avance quand je lui dis d’avancer, tourne à gauche, à droite, et éventuellement fasse marche arrière, le tout avec seulement deux xBee.

Comment on cause à ces choses la ? Vous n’allez pas le croire, comme à un bon vieux modem RTC. On s’échappe du mode de transmission avec une séquence +++ et on lui envoi des commandes AT, par exemple ATCH permet de changer le canal de transmission utilisé, ATWR de sauvegarder la configuration, etc …

Et ensuite, c’est très simple, sauf configuration particulière, tout ce qui rentre sur la broche RX de la première xBee ressort sur la broche TX de l’autre et inversement, le tout selon le standard TTL (donc pas branchable en l’état sur le port série d’un PC) et à la vitesse précisée dans la configuration (de 1200 a 115200 bauds). En pratique, plus le débit est faible, plus la distance entre les deux xBee peut être grande. Pour ma part, j’ai choisi un classique 9600 même si 4800 aurait probablement largement suffit.

Si vous avez pratiqué un peu les arduino, vous savez qu’il faut utiliser Serial.read et Serial.print pour communiquer entre l’arduino et le PC. Il en va de même pour communiquer entre l’arduino et le xBee. Vous voyez venir la blague : quand l’arduino est branché au PC, elle n’est pas branchée au xBee, et inversement. C’est assez emmerdant pour débugger un programme mais on s’y fait.

J’ai donc installé le xBee sur un bout de breadboard à peu près dégagé sur le coté du robot. Câblage très simple : la masse, le RX, le TX et le +5v. Les 4 câbles gris&noirs qui sont juste à droite me servent à déconnecter le RX et le TX entre le xBee et l’arduino quand je branche l’USB pour injecter une nouvelle version du code (à défaut d’interrupteur, on fait avec les moyens du bord)

Du coté de la télécommande, qui est elle aussi une arduino, j’ai trouvé un adaptateur qui permet de brancher directement le xBee sur l’arduino. Je l’aurais bien fait coté robot aussi, mais ca m’empêchait de brancher le contrôleur des moteurs du robot … ennuyeux, vous en conviendrez.

Est apparu, ensuite, l’épineux problème des boutons. J’ai eu beau cherché et retourner toute la maison, pas moyen de mettre la main sur un quelconque bouton poussoir dans mon bordel. J’ai laisser sécher mes idées 3 ou 4 heures et j’ai trouvé : l’arduino dispose de 6 broches dites « analogiques » qui sont donc capables de déterminer le voltage, entre 0 et 5v, d’à peu près n’importe quoi. J’ai donc réalisé le petit montage suivant, au dos de l’arduino servant de télécommande, les deux habilement maintenues ensemble avec un colier plastique :

Eh oui, ou plutôt non, pas d’interrupteurs ou de boutons … Il n’y a que des fils de cuivre à nu. On ne s’inquiète pas, 5 volts, ça n’a jamais tué personne, et j’en ai vu d’autres, des châtaignes (ouiiii c’est pour ça que je suis un peu con)

Regardez d’un peu plus près cette très belle télécommande. Il y a trois groupes de 2 fils à nu, les fils impaires sont reliés ensemble à la masse (seconde ligne en partant du haut) et les seconds sont reliés, d’un coté, au +5v via une résistance assez importante (j’ai oublié combien j’ai mis, vous retrouverez avec le code couleur), et de l’autre, aux pattes analogiques de l’arduino.

Au repos, que se passe-t-il ? L’arduino détecte 5 volts  sur chacune des trois broches. Mais si vous mouillez votre pouce et que vous faites contact avec le fil relié à la masse, le courant va préférer aller se déverser dans la masse via votre doigt (qui doit avoir une résistance de l’ordre de 200kohm alors que la résistance dans l’arduino doit être cent ou mille fois plus élevée. L’arduino va donc détecter une baisse de tension et c’est ça que nous allons utiliser pour piloter notre robot.

On y trouve aussi une led blanche et sa petite résistance de protection, c’est juste un signal que j’ai ajouté en cours de développement pour savoir si ma télécommande causait bien avec le robot.

Place au code, à présent. Deux parties : la transmission et l’interprétation. Comme je voulais faire la télécommande la plus idiote possible, j’interprète ce qui se passe dans le robot, la télécommande ne fait que transmettre. Je vais donc tout simplement envoyer les valeurs relevées par l’arduino sur chacune de ses 6 broches analogiques, attendre confirmation de bonne réception, puis recommencer :

void setup()
{
  Serial.begin(9600);
  pinMode(13, OUTPUT);
  delay(10000); // on patiente, que la xbee soit prête
  Serial.flush();
}

void loop()
{
  Serial.print(0, BYTE); // on ballance un 0 pour marquer la limite entre deux paquets de données
  Serial.print(analogRead(0)/4, BYTE); // on encode la valeur de chaque broche
  Serial.print(analogRead(1)/4, BYTE); // analogique de l'arduino sur un octet
  Serial.print(analogRead(2)/4, BYTE);
  Serial.print(analogRead(3)/4, BYTE);
  Serial.print(analogRead(4)/4, BYTE);
  Serial.print(analogRead(5)/4, BYTE);

  int i=0;
  do { // On attends de recevoir la confirmation du robot pendant une seconde maximum
    if (Serial.peek() == 33) {
      Serial.read();
      digitalWrite(13, HIGH); // Si on l'a, on fait clignoter la led
      delay(10);
      digitalWrite(13, LOW);
      break;
    } else {
      Serial.read();
      delay(100);
    }
    i++;
  } while (i < 10);
  delay(50); // Pas la peine de trop se presser non plus
}

Et de l’autre coté ? ben c’est pas beaucoup plus compliqué. Dans ma boucle, j’installe simplement :

  if (Serial.available() > 6) {
    int r0, r1, r2, r3, r4, r5;
    do {
      if (Serial.peek() == 0) {
        Serial.read();
        r0 = Serial.read();
        r1 = Serial.read();
        r2 = Serial.read();
        r3 = Serial.read();
        r4 = Serial.read();
        r5 = Serial.read();
        Serial.print("!"); // On renvoi l'acknowledge à la télécommande

        if (r0 < 100) roll = true;
        else roll = false;

        if (r5 < 100) {
          tleft = true;
          roll = true;
        }
        else tleft = false;

        if (r4 < 100) {
          tright = true;
          roll = true;
        }
        else tright = false;
        break;
      } else {
        Serial.read();
      }
    } while (roll == false);
  }

En gros, j’ai constaté que mon doigt mouillé donnait systématiquement une valeur inférieure à 100 aux broches analogiques de ma télécommande, donc, si j’ai un doigt sur 0, je fais avancer la chose, si je l’ai sur 4 ou 5, je la fais tourner à gauche ou à droite, et … C’est tout !

Le robot gère le fait qu’il peut éventuellement recevoir de la merde entre deux trames et sait donc vider son buffer jusqu’à recevoir un 0 qui marque le début d’une nouvelle salve de la télécommande. Accessoirement, il ne s’intéresse à cette routine que s’il y a 6 caractère en attente dans le buffer série, c’est à dire que si on a déjà reçu entièrement une trame.

Le tout a un délai de réaction absolument magnifique de l’ordre du quart de seconde ce qui donne un robot presque maniable !

Je vais faire une petite pause avant de vous parler de la suite … j’attends une commande de matériel :)