robocop

Dans ce tutoriel, nous allons voir comment créer une temporisation en électronique.

Elle sera réalisée grâce à un petit circuit que l'on appelle circuit RC.
Sommaire :

1. Introduction
2. Réalisation
3. Conclusion


Introduction


Le but d'une temporisation est de retarder l'activation d'une action. C'est pourquoi on parle de temporisation au travail.

Je vais vous donner un petit exemple.
Soit le circuit suivant :

Par défaut la lampe est éteinte, et lorsque l'on ferme le bouton poussoir, elle s'allume immédiatement.

Maintenant, imaginons que pour X raison, on veuille que la lampe ne s'allume que 5 secondes après la fermeture du bouton poussoir.
Pour cela, on va réaliser une temporisation.

On a alors le circuit suivant :


Mais que mettre dans la case "Tempo" ? ...


Réalisation


Dans notre case "Tempo", nous allons nous servir d'un circuit RC et d'une porte logique ET.
Comme son nom l'indique, un circuit RC est composé d'une résistance ® et d'un condensateur ©.
Voici donc à quoi va ressembler notre case "Tempo" :


La plupart du temps, pour la porte ET, nous nous servons d'un circuit intégré CMOS 4081.


Explications :


Lorsque l'entrée E passe à l'état logique "1" (c'est à dire lorsque un signal arrive), l'entrée 1 de la porte logique ET passe à l'état "1" également. Mais le condensateur C n'étant pas chargé, il absorbe la quasi-totalité du courant, et l'entrée 2 de la porte logique reste à l'état "0".
Plus cela va et plus le condensateur se charge, il absorbe donc de moins en moins de courant et ainsi, une tension de plus en plus forte arrive à l'entrée 2 de la porte logique.
Lorsque la valeur de cette tension atteint Vcc/2 (Vcc étant la tension d'alimentation de la porte logique), l'entrée 2 passe à l'état "1" et donc la sortie S également : notre temporisation est terminée.


Comment agir sur la durée de temporisation ?


Vous l'aurez compris, avant que la deuxième entrée de la porte ET passe à "1", il faut que le condensateur se charge, ce qui prend un certain temps. Et selon la capacité du condensateur (exprimée en Farads), la durée de charge sera plus ou moins longue.
Le premier facteur à agir sur la durée de temporisation est donc la capacité du condensateur.
La durée de charge d'un condensateur dépend également de la quantité de courant qui lui arrive. Et cette quantité de courant varie en fonction de la valeur de la résistance R. Ainsi plus la valeur de la résistance est grande, plus la durée de temporisation est élevée.
La valeur de la résistance et donc le deuxième facteur à agir sur la durée de temporisation.

Une formule permet de calculer la durée de temporisation en prenant en compte ces deux facteurs :
avec :

T = durée de temporisation en secondes
Ln = logarithme népérien
R = valeur de la résistance en Ohms
C = capacité du condensateur en Farads


Ln(2) est environ égal à 0.7, donc on retient généralement la formule ainsi :


Conclusion


Pour conclure, nous allons donner une solution à notre problème !

Nous avons le circuit général ainsi que ce qui va dans la case tempo, il ne nous reste plus qu'a fusionner les deux :

Il nous reste une dernière chose à faire, et c'est probablement la plus importante : le calcul des valeurs de la résistance et du condensateur.

Nous voulons 5 secondes de temporisation.
Donc on reprend notre formule et on a :
Ensuite on se fixe l'une des deux valeurs. Par exemple on s'impose un condensateur de 1000 microFarads (1*10^-3 Farads)
On a donc :
Il ne nous reste plus qu'a résoudre l'équation : Ohms.

Nous utiliserons donc un condensateur de 1000µF et d'une résistance de 7,1KΩ.

Ce circuit nous fournira une temporisation d'ENVIRON 5 secondes. En effet, les valeurs des résistances et des condensateurs vendus dans le commerce possèdent une certaine marge d'erreur. Ainsi une résistance vendue avec une valeur de 100Ω ne fournira peut-être que 98Ω. Idem pour les condensateurs. Donc si vous désirez avoir une temporisation d'une durée très précise, il faudra envisager une autre solution technique, l'utilisation d'un micro-contrôleur par exemple.

Voilà, ce tutoriel est terminé, et j'espère qu'il vous aura plut.

Maintenant, vous êtes en mesure de réaliser une temporisation d'une certaine durée grâce à un circuit RC.
Et si vous avez des questions, n'hésitez pas à les poser sur le forum ...

Les servomoteurs sont des ensembles mécanique composés d'un moteur courant continu, d'un servomoteur, d'un potentiomètre et d'un système électronique d'asservissement. Le moteur peut tourner selon un certain angle, qui dépend du servomoteur : il y a une butée mécanique qui l'empêche d'aller plus loin, et le potentiometre permet de connaitre la position de l'axe du servomoteur, c'est à dire l'angle que forme l'axe du servomoteur avec la butée.

La commande du moteur se fait selon un signal assez similaire des signaux du type PWM : il s'agit d'un signal carré dont la durée des impulsions détermine l'angle que doit atteindre l'axe du servomoteur :



Ainsi, les servomoteurs sont très pratique en robotique par exemple pour créer un robot bipède : on peut s'en servir pour réaliser les jambes du robot.

Cependant ici nous allons voir une application dérivée du servomoteur. En effet, un servomoteur contient un reducteur, un moteur, un système d'asservissement et un boitier solide et compacte. On peut trouver des servomoteurs pour moins de 10 euros. Ainsi, si on pouvait enlever la butée du servomoteur, et l'utiliser comme moteur à courant continu, on aurait à disposition un moteur avec un bon couple, dans un beau boitier, on disposerait de la marche arrière, et tout cela pour moins de 10 euros !

C'est l'objet de ce tutoriel.
Sommaire :

1. Principe
2. Enlever la butée
3. Remplacer le potentiomètre par une résistance variable
4. A la recherche du neutre
5. Commande du moteur
  Principe


Lorsque l'on envoi une commande au moteur, l'asservissement alimente le moteur jusqu'a que la commande correspond à la tension du potentiomètre, c'est à dire a la bonne position.

Maintenant, si on remplace le potentiomètre par une résistance fixe, qui correspond à un angle de 0 degrés, lorsque l'on lui enverra un signal pour aller dans un sens ou dans l'autre, il va tourner tourner dans ce sens, mais il se croira toujours à 0 degrés, et va continuer à tourner indéfiniment !

Ainsi, nous avons un moteur à courant continu.
  Enlever la butée



Le servomoteur possède une protection, une butée mécanique qu'il faut enlever.

Commencez par démontez le servomoteur et enlevez avec un cutter ou une pince la butée :





La butée enlevée

  Remplacer le potentiomètre par une résistance variable



Enlevez le circuit électronique et dessoudez le potentiomètre.
Remplacez le par deux résistances montées pont diviseur de tension.

Pour la valeur des résistances, il faudra chercher, cela dépend de votre servomoteur. L'idéal est d'avoir deux résistances de la valeur du potentiomètre quand le servomoteur se trouve à un angle de 0 degrés.

Ceci-dis, si on est pas super précis, cela n'a pas une réelle importance, il faudra juste trouver la valeur du "neutre".

Personellement, j'ai utilisé pour mon servomoteur deux résistances de 2.2 Kohm.

Voici une photo du servomoteur après modification :



Il est également possible pour cette étape de garder le potentiomètre, en coupant son axe qui dépasse et qui modifie sa valeur avec le mécanisme de réduction du moteur, et en le fixant au neutre avec de la pâte à modeler.

C'est la méthode qui est présentée dans cet article.
  A la recherche du neutre


Prenez votre arduino (ou votre microcontrolleur habituel) et réalisez le circuit suivant :


On alimentera la carte par l'USB.

On va écrire une programme qui fait tourner le servomoteur entre un angle de 0 à 180 degrés, et on va regarder à quelle impulsion le moteur s'arrête : il s'agira du neutre.

Voici le programme :
Code : C

#include

Servo servo;

void setup()
{
servo.attach(10); // On attache le servomoteur à la patte 10 de l'arduino
Serial.begin(9600); // On va envoyer des informations à l'ordinateur grâce à ce port
}

void loop()
{
int i = 0;
while(i <= 180)
{
servo.write(i); //On fait avancer le servomoteur de 5 en 5, de 0 jusqu'à 180
Serial.println(i); //On affiche la valeur en cours de l'angle
delay(1000); // On attend une seconde pour avoir le temps de lire la valeur qui nous interesse

i = i+5;
}
while(i >= 180)
{
servo.write(i); //on fait reculer ensuite le servomoteur
Serial.println(i);
delay(1000);
i = i-5;
}

}

On fait simplement varier l'angle, et à chaque fois on affiche la valeur de cet angle.
Je trouve personnellement que mon moteur s'arrête, puis change de sens à 85°.
Il est ensuite possible d'être plus précis en allant de 1 en 1. Je trouve alors un angle de 84°.

Commande du moteur


Et voilà, le modification du moteur est maintenant terminée.
Si vous envoyez un angle plus grand que le neutre votre moteur ira dans un sens, et si vous envoyez un angle plus petit, il ira dans l'autre sens.
Il est même possible d'avoir des vitesses : on peut faire ralentir le moteur en envoyant une valeur proche du neutre.

Voici une fonction que j'ai écris pour controler facilement mon moteur, il suffit de lui donner une vitesse comprise entre -5 et 5, et il avancera ou reculera suivant cette vitesse :
Code : C

#define SERVO 0

int getNeutral = 84; // La valeur du neutre de mon servomoteur
void handleS(int s, int speed)
{
//Vitesse :
// 0 -> 0; 1 -> 1; 2 -> 3; 3 -> 8; 4 -> 10; v => 5 -> 30
int tab[6] = {0,1,3,8,10,30};
int pos = getNeutral;

int acc;
if (speed < 0)
acc = - tab[abs(speed)];
else
acc = tab[speed];

servog.write(pos += acc);
}

Et voilà, vous savez maintenant comment modifier vos servomoteurs en moteur à courant continu .
Bon bricolage.

Introduction

Vous avez décidé de vous lancer dans un robot, qui vous servira par exemple de base pour tester divers composants et micro-contrôleurs?

Ne négligez pas la partie mécanique !
Elle devra supporter toutes vos applications et être fiable.

Ici, je vous propose de construire une base.

Je ne vous apprends pas à construire un robot complet, je vous montre juste comment construire une bonne base mécanique, pour pouvoir par la suite développer vos propres applications.

Ce robot se déplacera grâce à deux roues entrainées par deux servomoteurs modifiés en moteurs à courant continu.
  Partir sur de bonnes bases

Ici, nous allons réaliser le châssis qui servira de support à votre électronique.


En quelle matière ?


Nous aurions pu utiliser de nombreuses matières comme le fer, le PVC, le plastique, etc.
Mais j'ai préféré utiliser du bois, pour sa simplicité de mise en forme (il est plus facile de scier du bois que de l'acier ).

Voilà ce qu'il nous faut :

une plaque de contreplaqué de 5 ou de 6 min d'épaisseur.
une scie à bois
une lime à bois
une perceuse


Je vous laisse le soin de vous procurer tout cela.


La fabrication :


Ca y est, vous avez tout ?

Tracez tout d'abord le châssis avec un crayon à papier sur la plaque en bois comme sur le schéma suivant :



Le robot sera - comme vous pouvez le voir - de forme ronde et de diamètre assez large, pour avoir la place de mettre tous les composants.

Découpez-le ensuite à l'aide d'une scie et d'une lime à bois - ou encore d'une scie sauteuse - et percez-le au centre à l'aide d'une perceuse et d'un forêt au diamètre assez important comme 10 min.

Voilà : maintenant que j'ai tout dit, à vous de jouer .

Maintenant, nous allons passer aux roues pour qu'il puisse rouler, notre beau petit robot .

Pour que notre robot puisse avancer, j'ai choisi comme moyen de locomotion les roues . Les roues


Matériel :

Les roues seront en bois, il faudra une plaque de bois d'environ 1 cm d'épaisseur. Il va nous falloir également une perceuse et une scie cloche de 60 mm de diamètre :
Pour ne pas que les roues dérapent, il va falloir les équiper de petits pneus en caoutchouc.
Les pneus des petites roues lego feront l'affaire .

Nous fixerons ensuite les roues sur deux servomoteurs modifiés en moteur à courant continu.


Fabrication :


Découpez à l'aide de la scie cloche deux roues de 60 mm de diamètre dans la plaque de bois, puis recouvrez-les des petits pneus lego.


Voilà ce que cela donne chez moi :

Fixez-les ensuite sur les servomoteurs comme sur ce schéma :

Et voilà le travail :

Nous avons désormais deux belles roues qu'il va falloir fixer sur le châssis.


Ah la la... La fixation des servomoteurs... Ce n'est pas le plus facile.
Je vais ici vous présenter la méthode que j'ai utilisé.
La fixation des servomoteurs


Ma méthode :

Pour fixer les servomoteurs, je découpe une pièce en fer que je perce pour que les trous correspondent à ceux du servomoteur.

Je crois que vous comprendrez mieux avec une photo :

Vous comprenez le principe ?


L'usinage des pièces en fer :


Tracez la pièce sur une plaque de fer, et découpez-la avec une scie à métaux.
Tracez ensuite les trous et percez-les avec une perceuse (sans blague o_O ) et un forêt de la bonne taille.

Et voilà, vous avez une belle pièce :
Maintenant, répétez l'opération 3 fois : nous aurons besoin de 4 pièces pour fixer les deux servos.


Fixation :

Il va vous falloir 4 petites vis à bois et 8 vis/écrous.



Fixez les servomoteurs, de façon que leurs axes soient au centre du robot :



Voilà quelques photos du robot à ce stade :


Vous l'avez sûrement remarqué, le robot penche d'un côté, et pour arranger tout cela, nous allons installer une 3ème roue pour que le robot soit parfaitement plat.

Pour ne pas que le robot penche d'un côté, il va falloir rajouter une troisième roue.
La troisieme roue

Préparation :


Percez le châssis à l'aide d'un forêt de 5 mm de diamètre comme sur le schéma suivant :



Matériel :


Il va nous falloir :

une tige filetée de 5 mm de diamètre ainsi que des écrous
une perle en bois (que vous emprunterez - gentiment bien sûr - à votre petite soeur :| . )
un petit niveau pour contrôler la planéité du châssis du



Construction :



Pliez la tige filetée à 90° et emprisonnez-la entre des écrous comme sur la photo ci-dessous :
Attention, la perle doit pouvoir tourner sans frottements.


Fixez ensuite la tige sur le châssis (dans le trou percé au début de ce tuto) de façon que le châssis soit bien parallèle au sol.
Aidez-vous du petit niveau.

Et voilà notre petit robot :


Vous pouvez ensuite couper le petit bout de tige filetée qui dépasse .

Bonjour,

Je vous propose ici la construction d'un nouveau robot, Roby, qui pédagogiquement pourra se placer après avec les deux Cocotix, Cocotix V1, et Cocotix V2.
Roby sera programmable avec la plateforme arduino et intègrera différents capteurs : capteurs d'obstacles et de lumière comme dans cocotix V1 et V2, mais également d'autres comme capteurs de distance infrarouge ou ultrason si vous le désirez : le robot se veut extensible.

-------------------------------------
Liste des composants (par microrupteurman2) :

- 2 servomoteurs type s3003 modifiés en rotation continue
- 1 arduino
- 2 micro-rupteurs
- Les piles indiquées sur le schéma avec leur boîtier
- Une plaque d'essai (breadboard)
- Des roues pour servo, facilement réalisables
- Une roulette pour le 3e point d'appui
- fil électrique,
- vis
- matériel de soudure
- 1 interrupteur
- 2 résistances de 10k0
- 1 capteur Sharp Gp2d112
-------------------------------------

Le robot aura comme base mécanique la structure présentée ici.
Bien évidemment, vous pouvez utiliser la structure de votre choix, mais dans le code du robot, j'utiliserai bien deux servomoteurs pour la propulsion.



But du robot

Comme vu sur la vidéo, Roby aura pour but de naviguer dans une pièce, en évitant les obstacles, soit grâce a un capteur infrarouge de distance, soit avec des "antennes", des capteurs de contact.



Roby, robot basé sur une carte arduino

Par la suite, si vous le souhaitez, encore une fois, vous pourrez très simplement rajouter des capteurs, de l'enregistrement de données sur carte SD, une petite caméra, une liaison sans fil, etc.

Tout cela se fait très simplement avec certains modules pour Arduino.

Structure mécanique

Le structure mécanique est axée sur deux servomoteurs modifiés en courant continu.
Si vous n'avez pas d'idées, vous pouvez vous inspirer de ce tutoriel.



L'Arduino



Toute l'électronique du robot sera basée sur la carte Arduino Duemilanove. Arduino Duemilanove est une carte électronique qui comporte un microcontrolleur atmel ATmga328 et des composants supplémentaires pour faciliter la programmation du composant.

Ainsi la carte intègre directement un port usb pour programmer la carte en USB, un quartz 16MHz, un régulateur linéaire de tension 5, différentes LED, un bouton de reset, bref, pleins de bonnes choses pour commencer très rapidement sans soucis.
Cerise sur le gâteau, la carte est très accessible, moins de 30 euros.

Installation de la carte

Pour pouvoir programmer la carte, il faut déjà installer les drivers et les outils de programmation sur votre ordinateur.
La carte fonctionne aussi bien sur une architecture windows que linux.

Pour l'installation, je vous renvoi sur le chapitre dédié à l'installation d'Arduino sur l'ouvrage débuter avec Arduino

Test de la carte

On va voir si l'installation s'est bien passée en faisant clignoter une DEL.
La carte arduino équivalente à une carte clone Arduino Uno intègre d'office une petite DEL sur la patte 13.

On va donc mettre successivement la patte de 0 à 1, et de 1 à 0, toutes les 1.5 secondes.

On ouvre donc leur IDE, et on tape le programme suivant :
Code : C

int ledPin = 13;

void setup() {
// On initialise la patte 13 en pin de sortie
pinMode(ledPin, OUTPUT);
}

void loop()
{
digitalWrite(ledPin, HIGH); // on met la patte à 1
delay(1000); // on attend une seconde
digitalWrite(ledPin, LOW); // on met la patte à 0
delay(1000); // on attend une seconde
}

On remarque que chaque code possède au minimum deux fonctions, setup() et loop().
setup() est appelée au lancement de la carte, et loop() et executée en boucle, tant que la carte reçoit du courant.

Compilez votre code, puis envoyer le sur la carte.
Au bout de quelques secondes, la DEL de la carte devrait clignoter.
 
Ressources


Pour à peu près tout, il existe une librairie pour votre carte arduino : vous pouvez controler un servomoteur avec la librairie de servomoteurs, controler un écran LCD, communiquer avec l'ordinateur à travers le port USB, etc.

Voici un lien qui présente pleins d'exemples amusant à réaliser, et un autre, qui présente rapidement le langage avec lequel vous travaillez.

Amusez-vous bien !

Alimentation

Il y a dans ce robot deux alimentations : une pile 9 V pour alimenter l'arduino et 4 piles 1.5 V en série pour alimenter les servomoteurs et autres capteurs.

L'avantage de ce système, c'est que l'on peut alimenter l'arduino par la prise USB lorsque l'on écrira le programme, tout en gardant alimenté les servomoteurs : le débogage est donc plus aisé.

Attention cependant : il faut faire attention a bien relier les deux masses entre elle, cela peut être source de bogues assez vicieux.
Vous pouvez fixer vos piles commme sur cette photo :

Commencez par fixez les deux alimentation comme sur la photo :



Faites un trou au milieu du robot pour laisser passer les fils de l'alimentation et un trou sur le coté pour fixer l'interrupteur.
L'idéal c'est d'avoir un interrupteur capable d'avoir de couper/alimenter deux circuits à la fois. De cette façon, vous pourrez éteindre ou allumer votre robot en une fois.
Maintenant, si vous n'avez que deux interrupteurs normaux, ça fonctionnera aussi.

Fixez sur le robot l'arduino et la plaque d'essai.

Cablez alors les alimentations, l'arduino et les servomoteurs de cette façon :



Vous avez donc avec ce schéma 6V pour les deux servomoteurs et 9 V pour l'arduino.
Les deux masses sont bien reliées entres elles.
Sur la plaque d'essai, la première ligne correspond donc aux +6V et la deuxième à la masse.
Voici une photo de mon robot à cette étape :



Test des moteurs

On va écrire dans un premier temps un programme qui fait avancer le robot tout droit.

Tout d'abord, nous allons écrire une fonction toute simple, getNeutral(moteur) qui retournera la valeur du neutre de vos servomoteurs :
Code : C++

#include <Servo.h>

#define SERVOG 1
#define SERVOD 0

Servo servog;
Servo servod;

int getNeutral(int s)
{
if(s == SERVOG)
return 86;
else
return 84;
}

Chaque servomoteur est représenté par un entier naturel : le servomoteur gauche 1 et le servomoteur droit 0.
Remplacez les valeurs 86 et 84 respectivement par les valeurs du neutre que vous trouvez pour le servomoteur gauche et pour le servomoteur droit de votre robot.

Essayez de faire bouger vos servomoteurs en utilisant cette fonction.
Tout va bien ? Ok, nous allons écrire une fonction handleS(servomoteur, vitesse) qui envoit une commande au servomoteur. Cette commande est caractérisé par une vitesse qui va de -5 à 5. Si la vitesse est négative, on dira au moteur d'aller dans un sens et si le vitesse est positive on dira au robot d'aller dans l'autre sens.

Les différentes vitesses sont obtenues en se rapprochant du neutre. Je vous conseil de faire vos propres tests.
Attention cependant : nos servomoteurs ne sont pas dans le même sens. Pour avancer tout droit, un des servomoteurs doit aller dans un sens, et l'autre servomoteur doit aller dans l'autre sens.
On ne va donc pas oublier d'inverser le sens de rotation pour un des moteurs.
Code : C++

void handleS(int s, int speed)
{
//Vitesse :
// 0 -> 0; 1 -> 1; 2 -> 3; 3 -> 8; 4 -> 10; v => 5 -> 30
int tab[6] = {0,1,3,8,10,30};
int pos = getNeutral(s);

int acc;
// A chaque vitesse on fait correspondre un nombre qui est la différence de ce que l'on va envoyer au servomoteur par rapport au neutre.
// Les valeurs que je donne sont mes valeurs, je vous conseille de chercher vos propres valeurs, cela dépend de votre servomoteur.
if (speed < 0)
acc = - tab[abs(speed)];
else
acc = tab[speed];

if(s == SERVOG)
servog.write(pos += acc);
// On inverse le sens de rotation pour le moteur droit car les deux servomoteurs ne sont pas montés dans le même sens.
else
servod.write(pos -= acc);
}

A partir de là, on peut écrire une fonction move(direction) qui fait déplacer le robot dans une direction donnée :
Code : C++

#define AVANT 1
#define ARRIERE 0
#define GAUCHE 2
#define DROITE 3

#define VMAX 5

void move(int direction)
{
int m1 = 0, m2 = 0;
switch(direction)
{
case DROITE: m1 = 1; m2 = -1; break;
case GAUCHE: m1 = -1; m2 = 1; break;
case AVANT: m1 = 1; m2 = 1; break;
case ARRIERE: m1 = -1; m2 = -1; break;
}
handleS(SERVOG, m1*VMAX);
handleS(SERVOD, m2*VMAX);
}

Rien de bien compliqué : en fonction du déplacement, on indique dans quel sens doit se déplacer chaque moteur.

Code complet


On va, en utilisant toutes ces fonctions, demander au robot d'avancer tout droit :
Code : C++

#include <Servo.h>

#define AVANT 1
#define ARRIERE 0
#define GAUCHE 2
#define DROITE 3

#define SERVOG 1
#define SERVOD 0

#define VMAX 5

Servo servog;
Servo servod;

int getNeutral(int s)
{
if(s == SERVOG)
return 86;
else
return 84;
}


void handleS(int s, int speed)
{
//Vitesse :
// 0 -> 0; 1 -> 1; 2 -> 3; 3 -> 8; 4 -> 10; v => 5 -> 30
int tab[6] = {0,1,3,8,10,30};
int pos = getNeutral(s);

int acc;
if (speed < 0)
acc = - tab[abs(speed)];
else
acc = tab[speed];

if(s == SERVOG)
servog.write(pos += acc);
else
servod.write(pos -= acc);
}


void move(int direction)
{
int m1 = 0, m2 = 0;
switch(direction)
{
case DROITE: m1 = 1; m2 = -1; break;
case GAUCHE: m1 = -1; m2 = 1; break;
case AVANT: m1 = 1; m2 = 1; break;
case ARRIERE: m1 = -1; m2 = -1; break;
}
handleS(SERVOG, m1*VMAX);
handleS(SERVOD, m2*VMAX);
}



void setup()
{
servog.attach(10);
servod.attach(9);
move(AVANT);
}

void loop()
{
delay(15);
}

Cela est très simple avec la fonction move : move(AVANT);
Maintenant, on va faire faire avancer le robot pendant 8 secondes, lui faire faire un demi-tour, le faire avancer pendant 8 secondes, et ainsi de suite.
Pour faire tourner le robot, on va le faire tourner vers la gauche pendant un certain temps.
Personnellement, je trouve qu'il faut le laisser tourner 2 secondes pour qu'il fasse un demi-tour complet.
Ainsi, tout naturellement, le code est le suivant :
Code : C++

void loop()
{
move(AVANT);
delay(8000);
move(GAUCHE);
delay(2000);
}

Capteurs de contact : détecter les obstacles


Nous allons rajouter des capteurs de contact de type UPDD comme dans Cocotix. Il faut donc les connecter a deux pattes de l'arduino, et nous allons simplement regarder les états des deux pattes de l'arduino : si l'une est à 1, il faut enclencher un virage .

Voici donc le schéma de ce montage :



Les deux résistances sont des résistances de "pull-down", reliées à la masse pour éviter d'avoir des pattes flottantes et pour forcer l'état normal des deux pattes à 0.

Le code pour faire éviter les obstacles fait reculer, puis de tourner le robot à la détection de chaque obstacle :
Code : C++

#define UPDDG 3 // on utilise la patte 2 pour le capteur de gauche et 4 pour le capteur de droite.
#define UPDDD 4

void handleUPDD(int updd)
{
if(digitalRead(updd) == HIGH) //Si le capteur est enclenché
{
move(ARRIERE); // on recule d'abord pendant 0.4 sec
delay(400);

if (updd == UPDDG) // Puis on tourne dans le sens inverse du capteur détecté...
{
move(DROITE);
}
else
{
move(GAUCHE);
}
delay(600); // ...pendant 0.6 sec
}
}

Voici le schéma complet du robot à ce stade :



Et le code complet :
Code : C++
 

#include <Servo.h>

#define AVANT 1
#define ARRIERE 0
#define GAUCHE 2
#define DROITE 3

#define SERVOG 1
#define SERVOD 0

#define UPDDG 3
#define UPDDD 4

#define VMAX 5

Servo servog;
Servo servod;

int getNeutral(int s)
{
if(s == SERVOG)
return 86;
else
return 84;
}


void handleS(int s, int speed)
{
//Vitesse :
// 0 -> 0; 1 -> 1; 2 -> 3; 3 -> 8; 4 -> 10; v => 5 -> 30
int tab[6] = {0,1,3,8,10,30};
int pos = getNeutral(s);

int acc;
if (speed < 0)
acc = - tab[abs(speed)];
else
acc = tab[speed];

if(s == SERVOG)
servog.write(pos += acc);
else
servod.write(pos -= acc);
}


void move(int direction)
{
int m1 = 0, m2 = 0;
switch(direction)
{
case DROITE: m1 = 1; m2 = -1; break;
case GAUCHE: m1 = -1; m2 = 1; break;
case AVANT: m1 = 1; m2 = 1; break;
case ARRIERE: m1 = -1; m2 = -1; break;
}
handleS(SERVOG, m1*VMAX);
handleS(SERVOD, m2*VMAX);
}

void handleUPDD(int updd)
{
if(digitalRead(updd) == HIGH)
{
move(ARRIERE);
delay(500);

if (updd == UPDDG)
{
move(DROITE);
}
else
{
move(GAUCHE);
}
delay(800);
}
}



void setup()
{
pinMode(UPDDG, INPUT);
pinMode(UPDDD, INPUT);

servog.attach(10);
servod.attach(9);
move(AVANT);
}

void loop()
{
handleUPDD(UPDDG);
handleUPDD(UPDDD);
move(AVANT);
delay(15);
}

Capteur de distance infrarouge

Pour finir je vous propose de rajouter un capteur de distance pour détecter les obstacles sans les percuter.
Nous allons utiliser un capteur Sharp gp2d120 qui permet de voir de 4 cm à 80 cm.
Le capteur est simplement composé de 3 fils, deux pour l'alimentation (+5v et masse) et un pour la sortie analogique : le capteur renvoie une tension comprise entre 0 et 5v proportionnel à la distance des objets.



Branchez donc le capteur sur l'arduino : le fil rouge sur le +5V, le fil noir à la masse, et le jaune sur la patte 4 de l'arduino, qui est une patte analogique : on peut directement lire la tension envoyée à cette patte.

Vous pouvez le fixer sur le robot comme sur cette image :




Pour lire une patte la valeur de la tension envoyée à la patte 4, il suffit de faire :
Code : C++

int v = analogRead(4);

Après quelques tests de mon capteur, j'ai constaté que si v était supérieur à 180 (obstacle à 10 cm), alors il fallait reculer pour éviter l'obstacle, alors que si v est supérieur à 100 (obstacle à 30 cm) il suffisait de ralentir d'un coté pour éviter l'obstacle.

Voici donc le code que je vous propose :
Code : C++

void sharp()
{
int v = analogRead(4);
if (v >= 180) // si on est à moins de 10 cm d'un obstacle
{
move(ARRIERE); //on recule
delay(300);
move(DROITE); //puis on part sur la droite
delay(900);
}
else if (v >= 100) //sinon si on est à moins de 30 cm d'un obstacle
{
handleS(SERVOG, VMAX);
handleS(SERVOD, 0); // on ralentit simplement la roue droite pour engager un virage en douceur
delay(1500);
}
}

Au final, voici le code complet :
Code : C++

#include <Servo.h>

#define AVANT 1
#define ARRIERE 0
#define GAUCHE 2
#define DROITE 3

#define SERVOG 1
#define SERVOD 0

#define UPDDG 3
#define UPDDD 4

#define SHARP 4

#define VMAX 5

Servo servog;
Servo servod;

int vLdr = 5;

int getNeutral(int s)
{
if(s == SERVOG)
return 86;
else
return 84;
}


void handleS(int s, int speed)
{
//Vitesse :
// 0 -> 0; 1 -> 1; 2 -> 3; 3 -> 8; 4 -> 10; v => 5 -> 30
int tab[6] = {0,1,3,8,10,30};
int pos = getNeutral(s);

int acc;
if (speed < 0)
acc = - tab[abs(speed)];
else
acc = tab[speed];

if(s == SERVOG)
servog.write(pos += acc);
else
servod.write(pos -= acc);
}


void move(int direction)
{
int m1 = 0, m2 = 0;
switch(direction)
{
case DROITE: m1 = 1; m2 = -1; break;
case GAUCHE: m1 = -1; m2 = 1; break;
case AVANT: m1 = 1; m2 = 1; break;
case ARRIERE: m1 = -1; m2 = -1; break;
}
handleS(SERVOG, m1*VMAX);
handleS(SERVOD, m2*VMAX);
}

void handleUPDD(int updd)
{
if(digitalRead(updd) == HIGH)
{
move(ARRIERE);
delay(500);

if (updd == UPDDG)
{
move(DROITE);
}
else
{
move(GAUCHE);
}
delay(800);
}
}

void sharp()
{
int v = analogRead(SHARP);
if (v >= 180)
{
move(ARRIERE);
delay(300);
move(DROITE);
delay(900);
}
else if (v >= 100)
{
handleS(SERVOG, VMAX);
handleS(SERVOD, 0);
delay(1500);
}
}
void setup()
{
pinMode(UPDDG, INPUT);
pinMode(UPDDD, INPUT);

Serial.begin(9600);
servog.attach(10);
servod.attach(9);
move(AVANT);
}

void loop()
{
handleUPDD(UPDDG);
handleUPDD(UPDDD);
sharp();
move(AVANT);
delay(100);
}

Comme vous pouvez le voir, rajouter un capteur n'a pas été difficile .

Roby, robot basé sur une carte arduino.

Et voilà, c'est fini pour ce tutoriel.
Évidemment, la réalisation proposée ici n'est qu'une base à améliorer.
N'hésitez pas à nous faire par de vos améliorations, quelles soient électronique ou algorithmique soit en postant sur le forum, soit en créant votre tutoriel .

Remerciement : cgizmo, avec qui j'ai écrit le code du robot.

Ca y est, vous avez construit Cocotix, le petit robot coccinelle qui évite les obstacles.
Celui-ci vous a permis de débuter dans la robotique, de vous rendre compte des problèmes mécaniques et de découvrir l'électronique.

Mais voilà, maintenant, il faut progresser, et je vous propose maintenant une nouvelle version de Cocotix.
Ce robot sera un peu plus compliqué de réalisation que le précédent, car il intègrera un circuit imprimé.

Présentation du robot

Eh oui, ce nouveau robot sera capable de suivre la lumière, tout en évitant les obstacles.

Mais moi, je n'ai pas le matériel pour réaliser un circuit électronique !

Rassurez-vous, le schéma est très simple, et vous pourrez le réaliser sur une simple plaque d'essai en bakélite.


Alors, vous êtes tenté? C'est parti !

Une vidéo

Tout d'abord, je vous propose une petite vidéo du robot, de façon que vous puissiez voir quelles sont ses possibilités et ses fonctions :




Quelques informations techniques...

Pour ce robot, pas besoin de pic, d'atmel ou autres micro-contrôleurs. Toute la partie commande est analogique, à partir de simples transistors. Nous utiliserons des photo-résistances en guise de capteurs de lumière.

Liste des composants

Pour réaliser ce robot, vous aurez besoin de :

petits moteurs
1 interrupteur on/off
4 résistances de 100 ohms
2 résistances de 220 ohms
1 DEL rouge et 1 DEL verte
2 résistances variables de 10 k
2 microrupteurs (type switch)
2 transistors BC547C
2 photorésistances LDR
2 transistors BC557C
1 plaque de bakélite
2 supports à 2 piles AAA

Le schéma électronique

Le schéma électronique est assez simple à comprendre (cliquez sur l'image pour aggrandir le schéma):



Note : GND correspond au 0V ("-" de la pile) et VCC au +V ("+" de la pile).

Commençons par le système pour éviter les obstacles. Il est beaucoup plus simple que celui de Cocotix.


Le courant circule de "C" à "NC" quand l'interrupteur ne détecte pas d'obstacle : le moteur tourne normalement et le robot avance tout droit.

Maintenant, imaginons que l'interrupteur détecte un obstacle.

Le courant circule donc de "C" à "NO" ou plutôt, il ne circule plus, puisque "NO n'est branché à aucun fil".

Conclusion : le moteur s'arrête.
Les fils des interrupteurs seront comme dans la V1 du robot, croisés.

Ainsi, quand l'interrupteur de gauche rencontre un obstacle, le moteur droit s'arrête et le robot tourne à droite : l'obstacle est évité.

Voyons maintenant le système pour suivre la lumière.

Pour chaque commande de moteur, on utilise un transistor BC547C (de type NPN) et un transistor BC557C (de type PNP).



Voici donc l'effet que cela produit :

• Quand le courant d'entrée (1) est élevé, le courant de sortie (2) est faible.
• Quand le courant d'entrée (1) est faible, le courant de sortie (2) est élevé.

Ainsi, quand il y a peu de lumière dans une photo-résistance, il y a une forte résistance, et donc un faible courant d'entrée (1).

Résultat : le courant de sortie (2) est élevé et le moteur tourne rapidement.

Au contraire, quand il y a beaucoup de lumière dans une photo-résistance, le courant d'entrée (1) est élevé et le courant de sortie (2) est faible.

Le moteur tourne doucement voir s'arrête : le robot se dirige vers la lumière !

Partie électronique

Nous allons réaliser la carte électronique sur une plaque de bakélite.
Vous pouvez vous aidez de ce schéma, si vous avez du mal à comprendre le schéma vu précédemment :

Un immense merci à Alex93 pour la réalisation de cette image !


Il faut mettre les composants sur la face sans pastille et les souder du côté pastille.

Ensuite, on réalise les pistes en étalant de l'étain sur les pastilles.

Voilà, maintenant que vous avez compris, à vous de jouer.

Serrez au maximum : la taille de votre robot dépendra de la taille de votre circuit !

Voilà le mien :



J'ai tellement voulu serrer les composants que l'on ne voit pas grand-chose o_O .

Assemblage des pièces

Cette fois-ci, le support n'est plus un calendrier en carton, mais une plaque de P.V.C.
Ainsi, le robot gagne en solidité .

Voici les dimensions du châssis (en mm), mais n'hésitez pas à les adapter à la taille de votre plaque électronique :





Comme dans Cocotix V1, il n'y a pas de roue, et c'est l'axe du moteur qui touche directement par terre. L'interrupteur sert de troisième appui.

Collez les moteurs, les micro-rupteurs, les photo-résistances, le circuit électronique et les deux supports à piles AAA avec de la colle chaude et réalisez les connexions :


Prévoyez également deux trous pour les DEL :


Les 4 piles sont branchées en série.

Derniers réglages


Votre robot est presque opérationnel, encore un petit réglage.

Avec un petit tournevis, régler les résistances variables. Plus la résistance sera petite, plus le robot réagira à la lumière, et moins il ira vite. Le truc, c'est de trouver le réglage parfait pour que le robot ait suffisamment de vitesse pour avancer et qu'il réagisse bien à la lumière.

Enfin, vous pouvez lui rajouter une petite coque en carton, comme sur cocotix V1.

Votre robot est alors terminé !

Voilà, ce tutoriel touche à sa fin. J'espère que vous avez pris plaisir à le lire et à construire ce petit robot.
N'hésitez pas à poser vos questions sur le forum, notamment si vous avez un problème. Montrez-nous vos réalisations .

La robotique, cela coûte une fortune en composants électroniques, demande du matériel sophistiqué pour réaliser des circuits imprimés, bref, ce n'est pas pour moi.
Je ne sais même pas souder... Bye !



Attendez, revenez, car ici, je vous propose un robot pour environs 10 euros, et sans circuit imprimé ! Rien que cela.
Idéal pour les débutants en électronique, ce robot est un passage obligé en robotique. Consultez l'introduction, vous y verrez plus d'information et surtout une petite vidéo qui vous montrera la bébète en action /> .
Cocotix est un robot très facile à réaliser. Il n'a qu'un seul but : éviter les obstacles.



Une vidéo

Pour voir les possibilités de ce robot, rien de tel qu'une petite vidéo, n'est-ce pas ?

Combien coûte-t-il ?

Vraiment pas cher. L'avantage de ce robot, c'est d'être accessible à tous. Comptez 5 euros environ pour les petits moteurs et 5 à 6 euros environs pour le reste des composants.

Retrouvez sur le shop le kit complet cocotix pour réaliser votre premier robot.
 
Vous voulez le construire ?
Pas de problème je vous explique tout. Commencez par vous procurer les composants, en lisant le prochain chapitre /> .
Voila la liste de tous les composants et outils qu'il vous faudra pour réaliser cocotix.

Composants

Désignation : Moteur électrique tout simple
Quantité : 2
Prix (en euros) : 2,50
Total : 5

Désignation : Support de deux piles AA
Quantité : 1
Prix (en euros) : 1, 20
Total : 1, 20

Désignation : Interrupteur miniature à levier
Quantité : 1
Prix (en euros) : 1,00
Total : 1,00

Désignation : Microrupteur
Quantité : 2
Prix (en euros) : 1, 90
Total : 3, 80

Outils

Désignation : Ensemble de soudage fer
Quantité : 1
Prix (en euros) : 6, 95
Total : 6, 95

Récupération

Il y a des objets que l'on n'a pas besoin d'acheter car on peut les récupérer facilement :

• Un calendrier en carton
• 2 petites pailles

Et voilà, c'est tout /> .
Pour installer tous les composants de notre robot, il va nous falloir une bonne base, le châssis.
Le choix du châssis

Pour ce châssis, vous pouvez prendre plusieurs types de matériaux comme le P.V.C ou le plexiglas.
Mais la solution de facilité reste le carton des calendriers.

Découpe du châssis
(Les unités sont en mm)Procurez vous donc le calendrier de l'année dernière et découpez-le (à l'aide de ciseaux) comme sur le schéma de gauche.
Voilà mon châssis :
Prochain chapitre : la préparation des composants !
Ici, nous allons préparer les composants avant de les installer sur le châssis.



Couper, dénuder, souder

Réunissez tous les composants puis prenez du fil souple (évitez le rigide qui casse plus facilement) et coupez des bouts de fil de 4 cm de long.
Dénudez-les sur 5 mm de chaque coté et soudez-les sur chaque patte des composants comme sur la photo suivante :



Il faut en tout 11 morceaux de fil.

Et, mais attends, j'ai tout soudé, mais il me reste un fil. Qu'est-ce que j'en fais?
Du calme, j'y viens /> .

Une troisième connexion



Il va falloir souder un fil sur le support à piles AA pour créer une troisième connexion.
Voila à quoi va nous servir le dernier fil /> .
Soudez-le comme sur la photo de gauche.

Et voilà, tous nos composants sont prêts à être montés sur le calendrier.
Aujourd'hui, c'est un grand jour, nous allons fixer les composants sur le châssis ^^.
Les moteurs

Pour ce robot, il n'y aura pas de roues, car c'est souvent la source d'erreur dans les robots.

Mais alors, comment avance-t-il ?



Vous comprenez le système?

Faites un trou à l'arrière du robot et placez-y l'interrupteur on/off (voir schéma).
C'est celui-ci qui servira de troisième appui au robot.
Maintenant, avec de la colle très forte (moi, j'ai utilisé de la colle chaude et un pistolet à colle), collez les moteurs comme sur le schéma ci dessous.



Veillez à ce que le robot soit bien plat.

Les autres composants

Collez les deux microrupteurs et le support à pile comme sur la photo suivante :



Votre robot commence à prendre forme /> .
Prochaine et dernière étape : le montage.

C'est l'ultime étape de la fabrication de votre robot.
Cela veut dire qu'à la fin du chapitre, votre robot sera fonctionnel.

Relier les fils

Soudez les fils entre eux comme sur le schéma de gauche. Je vous conseille de l'imprimer pour ne pas vous tromper.

Les moteurs

En fonction du sens du courant qui le traverse, le moteur tourne dans un sens ou dans l'autre.
Les deux moteurs doivent tourner dans le même sens lorsqu'un même courant les traverse.
(on se comprend ^^ ).

Les microrupteurs


Normalement, si vous regardez bien vos microrupteurs, vous pourrez apercevoir les indications C, NO, et NC.
Respectez le schéma et ne vous trompez pas lors du montage.

Tester le robot

Mettez deux piles AA (LR6) dans le socle à piles, et allumez le robot avec l'interrupteur on/off.

Votre robot est fonctionnel /> .

L'esthétique
Votre robot est fonctionnel, certes, mais un petit relooking ne lui ferait pas de mal.

Vous pouvez soit vous fier à votre imagination, soit faire le même que le mien.
Voilà la coque que j'ai réalisée avec photoshop, puis imprimée.
Et voilà le travail :



Et voilà la construction s'arrête ici !

J'espère que cette initiation à la robotique vous a plût et je vous invite à lire la seconde partie, qui concerne l'explication du schéma électronique : comment ça marche !
Je listerais dans cette page tout vos cocotix que vous avez réalisé.
Celui de Zefortiche :

Celui de Alex93 :

Celui de Adrien93 :

Celui de Morgiahn :

Celui de Nano-Shtr00mf :

Ceux réalisés par l'ICAM de Nantes en raison du téléthon

Celui de Goff :

Celui de Nano-Shtr00mf :

Celui de Kinoa :


Celui de Jules :

Et de son cousin Adrien, "tankix" :

Celui de Kirigol
(Lien daylimotion)

Merci à eux, et bravo pour leur réalistion.
Si vous aussi, vous avez construit cocotix, envoyez moi une photo de
votre robot par message privé.
Merci d'avance.

Les microrupteurs

Nous allons voir ici le fonctionnement des capteurs du robot.
Les microrupteurs de ce robot sont en fait des interrupteurs updd (ou switch), pour Unie Pole Double Direction.
Sur cet interrupteur, on peut distinguer 3 indications : C, NO, et NC.

C signifie commun, c'est le point de branchement qui ne change pas.

NC se traduit par Normally Close. Lorsque l'interrupteur n'est pas actionné, le courant passe par NC.

NO, est l'acronyme de Normally Open. Lorsque l'interrupteur n'est pas actionné, la partie du montage branchée à NO est ignorée. Mais quand l'interrupteur est actionné, le courant passe par ce point de branchement.

Voila un interrupteur UPDD à l'intérieur :



Voilà, maintenant que vous avez compris cela, je vais pouvoir vous expliquer l'ensemble du circuit.
Maintenant que vous avez compris comment fonctionnent les interrupteurs UPDD, je vais vous expliquer le circuit électronique avec l'ensemble des composants.

Le schéma du robot

Voici le schéma du robot :

Si les interrupteurs ne sont pas enclenchés, voila comment circule le courant :

Les deux moteurs tournent dans le même sens.

Mais maintenant, imaginons qu'un des interrupteurs soit enclenché, celui de gauche par exemple :

Lorsqu'un des interrupteurs est sur position NC, c'est la deuxième pile qui prend le relais. Celle-ci est branchée à "l'envers" de la première.
Le moteur tourne donc dans l'autre sens.
Résultat : le robot tourne et évite l'obstacle.

Vous comprenez le principe?

L'interrupteur

J'ai rajouté un interrupteur ON/OFF pour arrêter le robot, sinon, il faudrait enlever les piles pour le stopper: ce n'est pas très pratique.

Voilà, maintenant vous savez tout sur ce robot.