PPE machine poseuse de dominos

Bonjour à tous !

Comme le laisse le deviner le titre, je suis en terminale S SI (Science de l'ingénieur).
Et dans le cadre du PPE, mon équipe et moi même avons décidé d'étudier une "simple" machine poseuse de dominos, comme le montre cette image :
http://shop.vlan.be/images_zoekers/3099056_0.jpg

On a eu l'idée de mettre la direction sur l'axe des roues arrières, pour lui permettre de pouvoir suivre une certaine courbe (pour poser des dominos autrement qu'en ligne droite) en suivant une ligne (sans angle droit bien sur pour des dominos) en insérant des liaisons pivot à coté des 2 roues sur l'axe vertical (les roues arrières pivotent donc). La rotation sera effectuée par 2 servo moteurs dans l'axe des liaisons pivots.
Servos (x2) : http://www.conrad.fr/micro_servo_top_line_es_07_p_50802_52047_856617_491302_FAS

Pour commander ces 2 servos, j'ai décidé de prendre une carte de programmation Arduino nano (bon choix vous croyez ?), car elle me parait assez petite et légère (le soucis de légereté est assez important).

Le soucis est pour les capteurs :
Je sais qu'il me faut des capteurs infrarouges, mais je ne sais pas dutout si ilme faut un type spécial et/ou un branchement spécial par la suite sur la carte.

Pouvez vous me conseiller s'il vous plait ? :slight_smile:

ps : Je n'ai malheureusement aucune base solide en électronique (oui, je ne suis qu'en terminale, on est pas censé en faire), par contre l'électricité ça ira (en SI, normal). Sur internet je n'arrive pas à trouver des indications, à chaque fois je tombe sur des personnes assez calées en électronique (<-- langage incompréhensible), et surtout, leurs problèmes ne sont pas vraiment les capteurs, donc pas de résultats exploitables...

Salut,

Si je peux t'aider, je pense que ce serais mieux d'avoir un Arduino Mini PRO. Il est plus petit, plus léger et vous pourrez souder directement au board vos connexions.
Pour la direction du petit véhicule, j'ai déjà eu celui que tu montre en photo(!!). Il arrive à tourner avec un petit mécanisme qui est actionné par la rotation d'une forme (comme un cercle) insérée par l'utilisateur. Ce mécanisme pourrait peut-être être controlé par un seul servo.

Pour les senseurs, regarde ceci: http://www.seeedstudio.com/depot/electronic-brick-–-line-finder-p-680.html?cPath=144_149

Si ça peut t'aider, voici le lien vers les tutoriels de mon blog. J'ai récemment commencé à les écrire par contre, du contenu va se rajouter. Je peux aussi écrire sur un sujet en particulier si tu me le demande.
www.binette228.wordpress.com/tutoriels

Bonne chance dans ton projet et garde nous informé!

Salut !
Alors d'abord un grand merci pour ta réponse.

Je sais pas pourquoi je n'ai pas vu que tu as répondu, excuse moi. Après c'était les vacances donc bon... voilà voilà.

Alors au début j'étais tenté par l'arduino mini, mais on doit mettre quelque chose en plus pour pouvoir le brancher en USB (d'où mon choix de la nano qui me paraissait plus simple).

Pour ce qui est de cet élément suiveur de ligne, il est donc compatible avec les arduino ? Comment se branche-t-il ? (fils à souder, usb... ?)

petit up =) (s'il vous plait)

Tout à fait compatible et en plus tu as un exemple de code :
http://www.seeedstudio.com/depot/datasheet/line%20finder%20demo_code.zip

Ca à l'air d'être simple : tu lis 0 en entrée, c'est blanc, 1023 c'est noir, les valeurs intermédiaires t'indiquent la distance.

Startx

Ok j'ai bien avancé sur mon projet, et là je m'intéresse au code proprement dit (maintenant que tout les montages sont faits).

Dans l'exemple de code que tu m'as fournis, de petites choses m'interpellent :
void setup() {
pinMode(signalPin, INPUT); // initialize the digital pin as an output

Là c'est juste une faute de frappe nan ? Il aurait du mettre :
void setup() {
pinMode(signalPin, INPUT); // initialize the digital pin as an input

ensuite :
Serial.begin(9600); // initialize serial communications at 9600 bps:

Je ne comprends pas trop le principe de cette instruction.
Elle indique le débit de communication ? Ce taux est-il adapté pour un arduino nano 2.x ? (avec ATmega168)

Et enfin, on voit ici deux méthodes pour acquérir les données. La digitale (avec high et low), et l'analogique.

La digitale n'admet que des couleurs "parfaites", c'est à dire blanc pur (valeur : 0), et noir pur (valeur : 1023), ou alors il y a un intervalle de tolérance ?

Au pire je peux toujours me débrouiller en analogique, mais je ne comprends pas du tout le code montré pour l'analogique, je voudrais pas l'utiliser bêtement :confused:

ps : ce type de capteur peut être branché directement sur un arduino nano, ou faut il une résistance ? (je pense que non, vu qu'il doit être alimenté en 5V, et qu'il y a un port 5v sur l'arduino)

Merci de votre réponse.

Oui c'est bien input.

En digital, il n'y a que 2 valeurs possible : 0 ou 1, noir ou blanc ! C'est comme çà, il n'ya pas d'interval.

Par contre en analog, comme l'arduino à une capacité d'échantillonage sur 10 bits on peut avoir des valeurs entre 0 et 1024 (car 2^10 = 1024).

Donc si tu veux pouvoir 'jouer' avec des intervalles il faut passer le module en analog et connecter la sortie du sensor sur une antrée analog de l'arduino.

Pour lire la valeur 'lue' par l'arduino on porcède de la sorte:

int valeur;

valeur = analogRead(A0); // Lit la valeur sur l'entrée A0

En ce qui concerne le

Serial.begin(9600);

C'est l'initialisation du port série de l'arduino pour une vitesse de 9600 bauds (il en existe plusieurs : 4800, 9600, 19200, 38400, 115200).

Dans le cas présent cela ne sert qu'à afficher les réultats dans la fenêtre de degoggage de l'arduino.

(Serial.println("WHITE"); par exemple).

La vitesse ne pose aucun problème.

Sinon pour le branchement, aucun soucis : masse et 5volts.

Sinon mini programe pour jouer en analog.

loop()
{
int valeurSensor;

valeurSensor = analogRead(A0);

Serial.print("Valeur Sensor : ");
Serial.println(valeurSensor);

delay(200);
}

et zou pour afficher les valeurs de gris !
}

hmmm d'accord je comprends mieux.

Cependant, petite question encore pour le digital : est-ce que y'a une marge d'erreur ? je veux dire, si la couleur est très proche du noir, mais que ce n'est pas du noir, on recevra "HIGH" comme valeur ou une valeur inexploitable (ou inconnue) ?

le circuit intégré utilisé est un comparateur.

Donc dans la zone gris foncé/gris clair il risque d'envoyer des valeurs qui vont osciller entre blanc et noir.

Comme il n'envoie que 2 valeurs 0 ou 1, la zone entre 2 valeur de gris proche du 0 ou du 1 sera incertaine...

Tu comprends ?

L'avantage avec l'analog, c'est que si tu veux, tu peux avoir 10, 20 ou plus de valeurs de gris. Tout dépend de ce que tu veux comme précision.

par exemple en analog pour avoir 10 valeurs différentes, de 0 à 100% par pas de 10% on pourrait faire :

value = analogRead(A0); // retourne une valeur entre 0 et 1023

int pourcent;

pourcent = value / 100; // on va avoir quelquechose entre 0 et 10

Serial.print("Valeur lue de blanc : ");
Serial.print(pourcent);
Serial.println(" pourcent);

A partir de là, pourcent vaut entre 0 (noir je suppose) et 10 (blanc), avec 10 pas intermédiaires.

En digital tu n'aura pas çà.

Ah oui donc en fait en digital il dira toujours noir ou blanc, selon le niveau de gris mesuré.

Exemple : on a un gris super foncé, le capteur va dire --> "noir", et inversement

Bien ça ?

Mais bon si j'ai bien compris, le mieux est l'analog et dire que si les valeurs mesurés sont dans un certain intervalle, dire que c'est du noir, et dans l'autre, dire que c'est du blanc.

ps : qu'est-ce que les fonctions serial.print et serial.println ?
ps 2 : ah tiens au fait, la fonction myservo.write (pos), quand on fait tourner de +1 ou de -1, cela veut dire : positif (+1) --> sens trigo; négatif (-1) --> sens horaire ? parce que c'est bien beau de le faire tourner d'un angle, mais il me faut le sens ^^"

Voici le code que j'ai fait :

#include <Servo.h> // on inclue le header pour incorporer les librairies qu'il faut pour controler les servomoteurs
 
Servo myservo;
Servo myservo2;

// on créé deux objets servomoteur

int pos = 90; // on met la variable de position initiale des deux servomoteurs à 90° et non 0° pour pouvoir tourner des deux côtés (l'amplitude utilisée sera bien inférieure à 90 ° dans tout les cas)
char signalPin =  3; // numéro de pin du premier capteur
char signalPin2 =  4; // numéro de pin du deuxième capteur


void setup()
{
  pinMode(signalPin, INPUT); // on indique que le pin 3 est en mode input
  pinMode(signalPin2, INPUT); // on indique que le pin 4 est en mode input
  Serial.begin(9600); // ?
  myservo.attach(1); // on indique que le premier servo est sur le pin 1
  myservo2.attach(2); // on indique que le deuxième servo est sur le pin 2
  myservo.write(pos); // on met le premier servo en position 90°
  myservo2.write(pos); // on met le deuxième servo en position 90°
}
 
 
void loop()
{
  
      if(HIGH == digitalRead(signalPin)) // on teste le capteur 1 (à droite dans le sens du déplacement de l'appareil) pour vérifier la présence de la ligne noire
  {
    pos -= 2; // on fait tourner les deux servomoteurs de 2° car sinon ça pourrait être trop lent de tourner, et le capteur risque de dépasser la ligne noire, et la machine perdrait ainsi sa trajectoire
    myservo.write(pos);
    myservo2.write(pos); // les roues pivotantes sont celles à l'arrière, donc on doit les faire pivoter dans le sens inverse où la machine veut tourner
    delay(15); // pour laisser le temps au servomoteur d'atteindre sa position
  }
    
    else if (HIGH == digitalRead(signalPin2)) // on teste le capteur 2 seulement si le capteur 1 n'a pas indiqué "HIGH"
  {
    pos += 2;
    myservo.write(pos);   
    myservo2.write(pos); // le même principe est appliqué
    delay(15); // pour laisser le temps au servomoteur d'atteindre sa position
  }
  
}

nb : - le code est sur-commenté exprès, on sait jamais si c'est tellement un mauvais code que même le principe n'est pas évident à comprendre ^^'

  • le code est supposé ainsi si on considère que ajouter +1 à pos fait tourner le servomoteur dans le sens horaire, et -1 dans le sens trigonométrique, avec servomoteur 1 et capteur 1 à droite, et servomoteur 2 et capteur 2 à gauche (vue de derrière la machine).

Voilà donc le but de ce code est le suivant (je dis bien le but car je ne sais pas encore si il l'atteint) :
L'objectif est de faire suivre une courbe (par le moyen d'une ligne noire sur un fond blanc) à une machine qui, à la base, ne peut poser des dominos qu'en ligne droite.
On a donc "greffé" sur cette machine traction un système de liaison pivot sur l'axe arrière, un système à coté de la roue gauche, et de la roue droite (il y a donc deux servomoteurs). Faire tourner l'axe arrière dans son ensemble était impossible, ou très difficile à réaliser vu la machine, on a donc du faire tourner les deux roues arrières indépendamment entre elles, mais elles doivent quand même être parallèles en permanence.
Ces deux servomoteurs sont contrôlés par une carte arduino nano 2.x, cette carte de programmation agit en fonction de deux capteurs situés sur chacun des côtés de l'appareil.

Les capteurs utilisés sont ceux-ci :
http://www.seeedstudio.com/depot/electronic-brick-–-line-finder-p-680.html?cPath=144_149

Les servomoteurs utilisés sont ceux-ci :
http://www.conrad.fr/micro_servo_top_line_es_07_p_50802_52047_856617_491302_FAS

La courbe n'étant pas aléatoire (nous la ferons sans piège, et peu courbée, juste des rotations faibles, pourquoi pas une à droite puis une à gauche), le code devrait être plus facile à établir.

J'ai donc imaginé le code ci dessus.

Deux précisions sur ce code :
Je ne sais pas si " Serial.begin(9600); " est utile en pratique

Dans cet exemple http://www.seeedstudio.com/depot/datasheet/line%20finder%20demo_code.zip , le pin des capteurs (pin 3 et 4) est stocké dans une variable de type int. Personnellement, je crois qu'une variable char est suffisante, non ?

Donc en résumé :

l'axe arrière ressemble à ça (vue de face, à l'arrière de la machine) :
s s
O--I-[-------]-I--O

Les O sont les roues arrière
Les I sont les liaisons pivot
Les [] sont les bord de la machine ( donc [-------] représente l'épaisseur de la machine )
Les s sont les servomoteurs directement fixés sur l'axe vertical de rotation de l'embout du servomoteur

L'axe est immobile au milieu, il ne tourne même pas, par contre, après les liaisions pivots (donc à gauche et à droite des " I "), les axes tournent (on a donc fait deux roues libres, grâce à des petits roulements intégrés aux embouts qui relient les deux axes de la liaison pivot).

Que pensez vous de ce code par rapport au système ?

ps : en fait j'ai utilisé le capteur en mode digital ^^" , seul le noir et le blanc m'intéresse comme couleur, il n'y aura pas d'intermédiaire en plus (normalement).

Essayes !

Sinon je pense sincerement que pour suivre une ligne noire, il va falloir coder un peu plus.

Pose toi la question :

Si la ligne noire tourne à droite. Comment le capteur sait qu'elle tourne vers la droite ?
Idem si la ligne tourne à gauche.

Donc quand ton robot va arriver devant une ligne qui tourne, comment va tu opérer pour savroir dans quel sens tourner les roues...

Tu vas voir, il va falloir coder un peu pour donner un semblant d'intelligence au robot !

Que se passe-t-il s'il perd la trace noire ?

Faites des dessins (positions capteur et ligne, pour imaginer ce qu'il faut coder).

A+

Ben le truc c'est qu'il y a deux capteurs, un à droite de l'appareil, un à gauche, donc si le capteur gauche trouve la ligne noire, l'appareil devra tourner à gauche, et inversement, c'est plus compliqué que ça avec 2 capteurs qui encadrent la ligne ?

Tu verra...

Le but du jeu c'est de trouver les bonnes valeurs pour faire tourner ton truc afin qu'il ne zigzag pas en permanence.

Essaye et tiens nous au courant. Fais nous une video !

Hmm encore une petite question, comment alimenter l'arduino nano ? ^^'

Selon ce lien on peut mettre soit du 5 volts régulé (pin 27), ou entre 6 et 20 volts non régulé (pin 30).
Mais le voltage recommandé est entre 7 et 12 volts, mais à quel pin ? le 30 je suppose.

Je pense pas pouvoir trouver quelque chose de relativement léger et portable qui fasse 5 volts pile, je devrais donc mettre en série plusieurs piles et mettre ça sur le pin 30 c'est ça ?

ps : le + se met donc sur le pin 30, mais le - , où se branche-t-il ? Sur la masse ?

si tu utilise des piles ou autres, pin 30 ! alime stabilisée... l'autre pin.

Le + sur pin 30, le - à la masse comme d'hab.

Essaye des piles de 9v ou trouve une petite alimentation pour alimenter le bouzin. Sinon tu va en bouffer vite des piles !

D'accord, merci de la confirmation =) .

Là par contre je sèche totalement, le PC ne reconnait pas l'arduino par usb...

malgré les consignes ici :
http://arduino.cc/fr/Main/DebuterInstallationWindows

Déjà quand je le connêcte à un port USB, rien ne s'allume (peut être normal sur la nano)
Par contre ce qui l'est moins, c'est que dans le gestionnaire des périphériques, je n'ai pas le "USB serial port", sur aucun ordi que j'ai testé (ni portable ni fixe).

J'ai testé tout les ports usb à l'arrière des tours de tous les ordis que j'ai essayé, rien n'y fait.

Il me faut un adaptateur usb - série donc ?
Comme ceci : http://www.amazon.fr/TRENDnet-TU-S9-TrendNet-Convertisseur-serie/dp/B0007T27H8/ref=sr_1_1?ie=UTF8&qid=1304413636&sr=8-1

Si tu as un nano, il faut télécharger les drivers FTTDI

http://www.ftdichip.com/Drivers/VCP.htm

installes les et tiens nous au jus

D'accord j'essayerais ça chez moi (je suis au lycée là). Donc pas besoin de port série avec les drivers, l'USB suffit ?

L'usb (il me semble avec ton module) va communiquer par le port usb, mais le drivers ci-dessus va interpréter ton non comme étant un péripherique série.

Donc pas besoin de ton adaptateur usb-serie. De toute facon tu le connecterai où sur le nano ?