Projet AirDuino

[EricDuino]

Lorsque 3 amis mettent en commun des compétences, du temps et des envies pour s'amuser et partager dans un esprit amical, "Libre" et "Collaboratif", il peut être normal, d'être tenté, de créer un projet Libre de type Open Hardware.

C'est ce que nous essayons de faire par l'intermédiaire de ce Forum.

Notre objectif collaboratif est de rendre accessible au plus nombreux notre projet et bien sur de profiter de critiques constructives afin de l'améliorer. Nous profitons de la communauté mondiale du Libre et nous souhaitons y contribuer en langue Française.

Notre projet est né autour de vieilles passions centrées sur l'informatique et l'électronique.


Nous sommes nouveaux dans l'Aventure Arduino :

Nous nous sommes lancé dans l'Aventure Arduino le 6/10/2011 par un premier achat chez Snootlab.
Jean a publié le PacMan sur le Deuligne le 14/11/2011
Le 24/11/2011 rencontre de Massimo Banzi.
Le 25/11 nous nous sommes inscrits au Tournoi National de Robotique de Nîmes qui aura lieu dans quelques jours le 12/5/2012.

Nous avons voulu participer à ce tournoi en utilisant Arduino.
Juste retour des choses, nous ne nous en cachons pas et au contraire nous souhaitons tout vous dévoiler.

Nous comptons vous presenter dans ce Forum :

Les cartes AirDuino Motor V1 et V2
Le capteur 8xCNY70/I2C
Nos robots et nos résultats

Mais aussi le détail de nos fonctions :

pilotage moteurs
lecture capteur
suivi de ligne de type PD (un PID sans I)
évènement ligne
résolution de labyrinthe

Pour commencer, voici une photo des 6 Robots AirDuino qui seront présentés ce samedi 12/5/2012 à Nîmes aux épreuves de Suivi de Ligne et de Labyrinthe de Ligne.

Nous espérons pouvoir les presenter le samedi 26/5/2012 au THSF sur la zone "Makers" animée par Snootlab.

AirDuino

les_6_AirDuino.jpg (114.28 Kio) Vu 2604 fois

[subreptice]

Bonsoir !

Tout ceci est extrêmement intéressant !
Vivement la suite

(
j'ai éventuellement 75 questions ; par exemple : vous avez alignés les 8 CN70 :
- c'est parce-que se sont des robots très rapides ?
- c'est à cause du facteur de forme "plaque à essai" ?
- il n'y a pas "d'annonce de tournant" sur la piste du suivi de ligne à Nîmes ?
- spontanément, j'en aurai mis au moins un (CNY70) déporté à l'avant au centre du robot, afin de détecter une "rupture de ligne droite", et d'amorcer un ralentissement de la vitesse du robot, donner dans le code la priorité à la recherche latérale, bref, anticiper la suite ( =vas falloir tourner !! ) mais c'est peu être idiot et puis le 12, c'est bientôt ! Bonne chance !
...
)

[EricDuino]

Juste quelques éléments de réponse (et de questionnement) avant de travailler sur la suite :
la disposition alignée des capteurs a été, à l'origine, dictée par la nécessité de lire des informations qui sont présentées perpendiculairement à la ligne suivie (voir plus en détail les règlements des 2 épreuves sur le site du tournoi). Malheureusement lorsqu'on suit une ligne, on n'y est jamais parfaitement aligné donc lire les infos perpendiculaires... Alors, nous avons dû trouver un moyen de vaincre, dans une certaine limite, ce phénomène. Cette solution doit permettre de positionner les capteurs en arc de cercle, en V et de continuer à lire des informations perpendiculaires (non testé). C'est assez complexe à expliquer (et peut-être à comprendre) mais ceci est très intéressant car cela nous a permis de résoudre d'autres problèmes que nous avons rencontrés lors de nos parcours de ligne à une vitesse située entre 25 et 100 cm/s.
Nous verrons ceci bien plus tard dans ce forum.

[EricDuino]

La carte AirDuino Motor.

C'est une carte compatible Arduino UNO disposant d'une commande moteur de type SN754410, 3 leds, un bouton poussoir, un récepteur IR (non monté car interdit pour le tournoi), connecteur avec alim pour les ports D11 à D13 et A0 à A5, connecteur de programmation, connecteur alim avec interrupteur et led témoin.

Sur la V1, la tension de la batterie alimente les moteurs.
Sur la V2, un deuxième régulateur assure aux moteurs une tension fixe indépendante des fluctuations de la batterie.

Le design du circuit permet une réalisation sur plaque d'essai, il faut compter 2 heures de travail pour un habitué à la réalisation de circuits sur ce type de support.

Le design est simple, il a été réalisé sans schéma et est le résultat d'une dizaine de prototypes.

Le typon a ensuite été réalisé à l'aide du logiciel gratuit et non libre "ExpressPCB" (encore sans schéma), le tirage a été confié à ERCIM sur Toulouse ( - de 4€).

MotorV11.jpg (62.4 Kio) Vu 2564 fois

MotorV12.jpg (98.58 Kio) Vu 2564 fois

[EricDuino]

Le capteur 8xCNY70/I2C.

C'est une carte qui se connecte à un Arduino au +5v, à la masse et au bus I2C (ports A4 et A5 sur une UNO). Elle utilise le PCF 8574P de manière à interfacer sur le bus I2C les 8 capteurs CNY70 en tant qu'entrées.

Le CNY70 est un capteur optique à réflexion qui est composé d'une diode infrarouge et d'un phototransistor. Il est utilisable pour de la détection de contraste à faible distance. Il est ici utilisé pour distinguer le noir du blanc à une distance de 2 à 5 mm. Le potentiomètre permet de graduer l'éclairement des diodes.

Le design et le typon ont étés réalisés de la même façon que la carte AirDuino Motor. Le cout chez ERCIM est équivalent, il faut compter 1 heure et demie pour une réalisation sur plaque d'essai. Nous avons réalisé des versions légèrement différentes en matière d'espacement de capteurs : versions XL, L, M, S et XS de 8 à 16 cm de largeur de lecture en fonction des robots, des besoins et des stratégies.

capt.jpg (62.16 Kio) Vu 2564 fois

capt2.jpg (53.22 Kio) Vu 2564 fois

[EricDuino]

La transition.

L'interconnexion du réel et du virtuel, de l'électronique et de l'informatique, du matériel et de l'immatériel, de l'Open Source et de l'Open Hardware !

Voici donc, avant de poursuivre vers des descriptions abstraites, l'assemblage des 2 composants majeurs constitutifs de notre projet au programmateur (une carte UNO sans l'ATMEGA).

prog.jpg (130.44 Kio) Vu 2564 fois

Vous pouvez en faire autant et même plus, bien plus simplement avec une carte UNO et un Rotoshield, malheureusement (et tant mieux !) pour le tournoi national l'ensemble des cartes doit être réalisé par les participants.

Le reste du physique c'est au minimum 2 moteurs, 2 roues et un châssis.
J'ai commencé avec de la récup de moteurs et de roues sur des jouets et une petite cagette comme châssis. Du "Hacking" !
Sinon il existe des châssis motorisés avec de très belles roues de 30 à 1000€ ou même des robots comme le "4WD mini-Q" ou le "3pi" de 70 à 100€. Du "Commerce" !

Moi j'aime "Faire" (et défaire et refaire...), apprendre, m'amuser et partager !

La suite après le tournoi.

[EricDuino]

coupe.jpg (85.21 Kio) Vu 2532 fois

Et voila, 3° à l'épreuve de suivi de ligne

[Lionel]

Bravo !

[fred]

Bravo !
Les résultats ici.

[EricDuino]

J'observe l'évolution des visites et je suis satisfait du nombre qui vient de passer à 220 ce soir, je commence tranquillement la publication du code par une fonction moteur et une petite chorégraphie avance - tourne, avant de suivre une ligne il faut marcher et tourner !

Cette fonction est issue d'une évolution de code trouvé chez DFRobot que j'ai utilisé pour un 4WD Mini-Q, auparavant je n'utilisais pas de fonction et mon code est vite devenu illisible et difficile à faire évoluer.

Mais parler de code sans parler de matériel ne permet pas de passer à du concret et de s'amuser en mêlant Soft et Hard, je trouve l'un sans l'autre pas toujours très amusant ou alors pas longtemps !

J'incite les débutants désireux de concevoir des "robots mobiles" à commencer par des "robots différentiels", ils se dirigent et se déplacent comme un tank par la rotation indépendante de leurs 2 chenilles. Rien à voir avec le déplacement d'une voiture radio commandée, tourner sur place devient possible, pas de problème de tringlerie. Il faut ici gérer des différences de vitesse et de sens de rotation pour tourner mais aussi gérer des vitesses et des sens de rotation égaux pour aller droit. J'ai rencontre par ces expérimentations des phénomènes physiques et mécaniques très inattendus... Les 6 robots AirDuino sont de ce type.

J'ai commencé par câbler des commandes moteurs (Ponts en H en circuit intégré) SN754410NE ou L293DNE sur des shields maison auxquels j'ai ajouté des récepteurs de télécommandes issus de vieux magnétoscopes de façon à pouvoir piloter ces robots par des télécommandes infrarouges quelconques, c'est aussi un exercice très intéressant qui ne sera peut-être pas traité ici, mais très ludique et qui peut servir à de la mise au point. Vous pouvez ainsi créer une base pour que des enfants puissent mettre en mouvement leurs constructions de LEGO et les piloter avec la télécommande de votre TV...

Voici avant le "code du début" une photo de 2 shields maison de commande moteur avec récepteur IR ainsi qu'un petit capteur de ligne :

shields.jpg (217.63 Kio) Vu 2390 fois

et voici le code :

Code: Tout sélectionner

//EricDuino le 22-5-2012


// définition les pins du SN754410NE

#define EN12 9 // Left Motor Enable Pin EN1,2
#define IN1A 8 // LeftRight Motor Direction Pin 1A
#define IN2A 7 // Left Motor Direction Pin 2A
#define EN34 10 // Right Motor Enable Pin EN3,4
#define IN3A 5 // Right Motor Direction  3A
#define IN4A 4 // Right Motor Direction  4A

// la fonction moteur

#define FORW 1 // Forward
#define BACK 0 // Backward
// M1 = Moteur Gauche M2 = Moteur Droit
void Motor_Control (int M1_DIR, int M1_EN, int M2_DIR, int M2_EN) // Motor control function
{
  ////////// M1 ////////////////////////
  if (M1_DIR == FORW) // Set M1 Motor Direction
  {
    digitalWrite (IN1A, LOW); // HIGH, Rotate clockwise
    digitalWrite (IN2A, HIGH); // LOW, Rotate clockwise
  }
  else
  {
    digitalWrite (IN1A, HIGH); // LOW, Anti Rotate clockwise
    digitalWrite (IN2A, LOW); // HIGH, Anti Rotate clockwise
  }
    analogWrite (EN12, M1_EN);

  /////////// M2 //////////////////////
  if (M2_DIR == FORW) // Set M2 Motor Direction
  {
    digitalWrite (IN3A, HIGH); // HIGH, Rotate clockwise
    digitalWrite (IN4A, LOW); // LOW, Rotate clockwise
  }
  else
  {
    digitalWrite (IN3A, LOW); // LOW, Anti Rotate clockwise
    digitalWrite (IN4A, HIGH); // HIGH, Anti Rotate clockwise
  }
    analogWrite (EN34, M2_EN);
}


// le setup
void setup()
{
  // setup et init des pins SN754410NE
  pinMode(EN12, OUTPUT);
  pinMode(IN1A, OUTPUT);
  pinMode(IN2A, OUTPUT);
  pinMode(EN34, OUTPUT);
  pinMode(IN3A, OUTPUT);
  pinMode(IN4A, OUTPUT);

  digitalWrite(EN12, LOW);
  digitalWrite(IN1A, LOW);
  digitalWrite(IN2A, LOW);
  digitalWrite(EN34, LOW);
  digitalWrite(IN3A, LOW);
  digitalWrite(IN4A, LOW);

  delay(3000);
}

//la boucle principale

void loop() {
  Motor_Control (FORW, 0, FORW, 0);
  delay(1000);
  Motor_Control (FORW, 255, FORW, 255);
  delay(1000);
  Motor_Control (FORW, 0, FORW, 0);
  delay(1000);
  Motor_Control (BACK, 255, FORW, 255);
  delay(1000);

}







Amusez-vous et faites moi (nous) part de vos réalisations pour m'inciter à poursuivre à décrire les briques de ce projet, les prochaines étapes devraient s'orienter vers la lecture de la ligne puis vers l'asservissement (PD - PID), sachez que si vous ne passez pas par les étapes décrites jusqu'ici la suite n'aura pas beaucoup d'intérêt.

Allez, lancez-vous, expérimentez et si besoin, testez de temps en temps l'attitude "Fuck the World and do something with your hands".

[EricDuino]

THSF 3.0 samedi 26 10h-18h, l'équipe AirDuino presente son projet :

THSF.jpg (192.25 Kio) Vu 2335 fois

Et voila une journée bien remplie avec nos objectifs de communication, découverte et de partage atteints.
Merci aux nombreux visiteurs, aux petits et grands enfants.

[Cassiope34]

Un anonimous était de la partie

[JujudOrion]

Salut,

C'etait sympa de vous rencontrer au THSF, sympas ces robots, bonne continuation pour la suite.

A bientôt.

Julien

[Marmothon]

Bonjour,

On s'est rencontré au Tournoi de Robotique de Nîmes, je voulais passer au THSF mais j'ai complétement zappé l’événement ...

J'avais un petit robot basé sur le projet Arduino, plus précisément sur Metaboard, qui est une version économique nécessitant moins de composants.

IMG_20120607_133141.jpg (83.35 Kio) Vu 2226 fois

Mon électronique est restée à l’état de prototype, mais je travail sur une version "définitive" pour l'année prochaine. Je pourrais partager mon programme si ça vous intéresse. Nos robots tournant plus ou moins à la même vitesse, ça peut être intéressant de comparer.

Denis

[EricDuino]

Bonjour Denis,

Merci de nous avoir recontacté et vraiment dommage pour le THSF !
Je ne connaissais pas Métaboard, cela me semble intéressant mais je reste persuadé de la moins bonne accessibilité que du "pur" Arduino et la limitation à 14k de code et le manque de port série que j'utilise beaucoup pour le débug me dérange. Le chouette truc c'est la prog en direct USB. Si le choix Métaboard est purement économique, c'est pour moi uniquement le système de programmateur qui fait la différence, moi je programme avec une UNO sans ATmega, le reste est strictement équivalent et je profite du "full Arduino UNO compatible".
Disposes-tu d'une UNO ?

Côté code, j'ai fait le choix de ne pas tout diffuser d'un coup de façon à le reprendre point par point pour le rendre accessible. Pour ce qui est du tien, bien sûr il m'intéresse, n'hésite pas à le diffuser ici.

Lors de la présentation au THSF, le public semblait plus intéressé par le pilotage par télécommande IR, la chorégraphie ou la détection d'obstacles que par le suivi de ligne, je risque donc de proposer le code de pilotage par télécommande avant de reprendre le cours prévu. Mais je suis un peu "multi projets" et ceci me ralenti dans le travail de cette publication...

[Marmothon]

Le choix du metaboard, c’était aussi pour pouvoir réaliser le circuit du robot complet sur une carte en composant traversant simple face, sans avoir à utiliser de convertisseur usb-serie, etc... (Ce qui n'a pas été fait). La limitation de la taille du code dépend de l'atmega qu'il y à dessus, moi j'ai un atmega8 de recup' dessus donc limité à 7k de code ! Pour le debug j'ai branché un convertisseur USB-série dessus. Je n'ai pas d'UNO.

Pour l'année prochaine je dois faire un carte bien propre, réalisée en CMS (je peux normalement avoir accès à un four) notamment à cause de la plus grande offre en composant et pour la taille. Pour l'instant rien n'est définitif mais je veux arriver à caser un atmega328 à 20mhz, un convertisseur DC-DC afin d'avoir une tension fixe pour les moteurs et un connecteur au format Xbee, toujours en utilisant la prog en usb.
Avec le connecteur Xbee je veux pouvoir mettre un module bluetooth, pour pouvoir débugger en situation ou contrôler des paramètres sur l'ordi ou mon téléphone Android. On peut aussi imaginer plein de petites fantaisies ...

Pour ce qui est du code, le voici, j'ai rajouté 2-3 commentaires mais c'est globalement un peu brouillon, pas très accessible

Code: Tout sélectionner

/*
______  ___                              ___________               
___   |/  /_____ ______________ ___________  /___  /______________
__  /|_/ /_  __ `/_  ___/_  __ `__ \  __ \  __/_  __ \  __ \_  __ \
_  /  / / / /_/ /_  /   _  / / / / / /_/ / /_ _  / / / /_/ /  / / /
/_/  /_/  \__,_/ /_/    /_/ /_/ /_/\____/\__/ /_/ /_/\____//_/ /_/

*/

#define motPin 10   
#define motSens 8
#define motPin2 9
#define motSens2 12

int M1,M2;

int maxS = 1023;
int minS = 0;

int lastError = 0;

float KP; //0.6 - 1
float KD; //5 - 14
//float KI = 0.01;

int a,b,c,error;
//float integral = 0;

unsigned long lastMark = 0;

void setup()  {
 
  pinMode(0, INPUT);
  pinMode(1, INPUT);
  pinMode(3, INPUT);
 
  pinMode(4, OUTPUT);
  pinMode(6, OUTPUT);
  pinMode(8, OUTPUT);
  pinMode(9, OUTPUT);
  pinMode(10, OUTPUT);
  pinMode(12, OUTPUT);
  pinMode(13, OUTPUT);
 
  digitalWrite(motSens, LOW);
  digitalWrite(motSens2, LOW);
 
  digitalWrite(4, HIGH); // allumer led
 
  if ( digitalRead(7) ){ // choix vitesse, rajouté pendant le tournoi pour essayer d'aller plus vite en gardant le retour en arrière possible.
    M1 = 150;
    M2 = 150;
    KP = 1; //0.6 - 1
    KD = 14;
  } else {
    M1 = 100;
    M2 = 100;
    KP = 0.6; //0.6 - 1
    KD = 5;
  }
 
  //Serial.begin(9600);
  int start = HIGH;
  while ( start ) {
    start = digitalRead(7);
    //Serial.println("wait");
   
  }
  digitalWrite(13, HIGH);
  delay(500);
  calibrate(); 
  digitalWrite(13, LOW);
}


void loop()  {
 
  // lecture de tout les capteurs de ligne dans un tableau
  int Sensors[8];
  Sensors[0] = digitalRead(0)*10;
  Sensors[7] = digitalRead(1)*10;
  int somme = Sensors[0];
 
  for (int i = 0; i<6; i++){
    Sensors[i+1] = map(analogRead(i), minS, maxS, 0, 10);
    somme += Sensors[i+1];
  }
  somme += Sensors[7];
 
  if (somme < 5) { // s'arreter si on tombe sur du blanc
    analogWrite(motPin, 0);
    analogWrite(motPin2, 0);
    delay(500);
    digitalWrite(13, HIGH);
    while (1);
  } else { 
    error = ( 100*Sensors[1]+200*Sensors[2]+300*Sensors[3]+400*Sensors[4]+500*Sensors[5]+600*Sensors[6]+700*Sensors[7] ) / somme;
    error -= 350;
  }
 
  // -350 < error < 350
  // 0  -> ligne milieu
  //Serial.print("Error = ");
  //Serial.println(error);
 
  //integral += KI * error;
  int motorSpeed = KP * error + KD * (error - lastError);
  lastError = error;
 
  //Serial.println(motorSpeed);
  int m1Speed = M1 + motorSpeed;
  int m2Speed = M2 - motorSpeed;
 
  // pouvoir mettre un moteur à l’envers si vitesse négative
  if (m1Speed < 0){
    digitalWrite(motSens, HIGH);
    digitalWrite(motSens2, LOW);
    m1Speed *= -1;
  } else if (m2Speed < 0){
    digitalWrite(motSens2, HIGH);
    digitalWrite(motSens, LOW);
    m2Speed *= -1;
  } else {
    digitalWrite(motSens, LOW);
    digitalWrite(motSens2, LOW);
  }
  //m1Speed = constrain(m1Speed, 0, 255);
  //m2Speed = constrain(m2Speed, 0, 255);
 
  /*Serial.print("m1Speed = ");
  Serial.println(m1Speed);
  Serial.print("m2Speed = ");
  Serial.println(m2Speed);*/
 
  analogWrite(motPin, m1Speed);
  analogWrite(motPin2, m2Speed);
 
  // arrêter le programme avec le bouton poussoir
  if (!digitalRead(7)){
    analogWrite(motPin, 0);
    analogWrite(motPin2, 0);
    delay(500);
    digitalWrite(13, HIGH);
    while (1);
  }
}

void calibrate(){ // calibration des capteurs
  //Serial.println("calibrate");
  maxS = 0;
  minS = 1023;
  int start = HIGH;
  while ( start ) {
    for(int i = 0; i < 6; i++ ){
      int a = analogRead(i);
      if(a > maxS) maxS = a;
      if(a < minS) minS = a;
    }
    start = digitalRead(7);
    //Serial.println("cali");
  }
  delay(100);
  /*Serial.print("maxS = ");
  Serial.println(maxS);
  Serial.print("minS = ");
  Serial.println(minS);*/
}


Tout les serial.print en commentaire sont là pour débugger.

Contrairement à toi j'utilise les capteurs en analogique, ça me permet d’augmenter un peu la résolution en lorsque je passe au dessus d'une séparation noir/blanc.
Une question m'est venu à l’esprit : il faudrait que je vérifie mais je crois que le temps de lecture des convertisseur analogique/numérique est bien plus long qu'une entrée digitale, du coup et il plus performant d'avoir une résolution un poil mieux ou de faire tourner le prog plus vite ? Comme toi tu utilise l'i2c c'est encore une autre histoire...

[Cassiope34]

Salut marmothon,
je sais que je le site partout dès qu'il est question de suiveur de ligne, mais ton dernier projet me fait fortement penser au génial petit PochetBot2 d'André Stanek qui dispose de tout ce que tu voudrais faire et plus encore, le tout tenant dans une petite boite d'allumette, et apparemment trés trés performant

Malheureusement il devait le commercialiser, mais ce ne sera vraissemblablement pas le cas

@+

[EricDuino]

Nouvelle appariton "Publique" de la Team AirDuino prévue le 20-21 Octobre au 12° Salon du Modélisme de la Salvetat Saint-Gilles (31) : http://clubsam.oldiblog.com

[EricDuino]

Une autre présentation Publique est en train de se préparer : ImagiLAN 2012 à Bordeaux le Samedi 13 Octobre...

Mais grande nouvelle du jour (Merci Subreptice ) un nouveau concours de suivi de ligne International est organisé :

http://letsmakerobots.com/node/34187

Nous sommes très motivés
Participerons-nous
Et vous

Le concours commence demain...

[EricDuino]

De façon à transporter et présenter correctement nos robots, j'ai dessiné avec LibreCAD un gabarit de découpe d'une boite (pas inutile cette fois), j'ai confié la fourniture du MDF6mm et la découpe laser à http://damengo.com. Superbe !

Boite laser Damengo.jpg (125.03 Kio) Vu 1691 fois

Coût indicatif pour ma réalisation : 9€30 de fourniture et découpe.


Dans sa vidéo de présentation de Léonardo, j'ai vu que Massimo avait des boites du genre :



Donc j'en voulais

Il est probable que nos prochains châssis de robots seront confiés à ce même prestataire, finie perceuse et chantourneuse : vive la découpe laser de Damengo !