Atelier pour commander une voiture jouet avec KiCar

http://www.didel.com/
[email protected]
www.didel.com/kidules/KiCarDeb.pdf
Atelier pour commander une voiture jouet avec KiCar
Documentation pour encadrants www.didel.com/kidules/KiCar.pdf
Les voitures télécommandées dont la mécanique est
encore bonne et ont une alimentation de 3 à 6V
peuvent être modifiées (on enlève le circuit radio) pour
être pilotées par le Kidule KiCar (ou la cartes qui ont
les circuits de commande pour deux moteurs). Le jeu
est de commander les moteurs pour en faire un robot
autonome, ajouter des phares, des capteurs
d’obstacles, des capteurs de lumière, etc.
Avec une voiture jouet, un moteur fait avancer et un actuateur (un moteur ou électro-aimant) fait
tourner. Un robot avec deux roues motorisées comme un tank est tout aussi facile à programmer.
Cette notice est prévue pour accompagner un atelier avec des moniteurs qui peuvent expliquer
l’environnement de programmation et les programmes (voir www.didel.com/kidules/KiPiDe.pdf )
La carte processeur
La carte KiCar va remplacer la carte radio, qui commande les moteurs et a deux fils qui viennent
de la pile, via l’interrupteur. Ne pas couper le fil d’antenne.
Le kit fournit les
connecteurs à mettre
sur la carte et à souder
sur les éléments
raccordés sur la carte.
Quelques connecteurs
ne doivent pas être
soudés, mais ils sont
fournis dans le kit, en
vue du futur.
Le but est de câbler les moteurs, tester le fonctionnement sous contrôle du processeur, ajouter
des phares, un klakson, des capteurs de distance. Ceci sera expliqué et testé au fur et à mesure.
Le soudage doit être fait
soigneusement, avec les
connecteurs bien droits et bien
enfoncés. Comme toujours, on
soude une patte, vérifie que c’est
le bon connecteur, bien soudé.
S’il est en biais ou pas assez
enfonçé on pousse le connecteur
avec le doigt en chauffant de
l’autre côté. Ensuite, on soude
toutes les pins.
Maintenant on peut voir ou placer KiCar dans la
voiture et quelle longueur de fils prévoir.
Première partie : modification de la voiture
La première étape est de bien regarder comment c’est construit. Quels sont les fils qui viennent
du bloc de pile, via l’interrupteur, quels sont les fils moteur et direction. On va couper ces fils et
mettre des connecteurs. La radio pourra être réinstallée, et avec les connecteurs compatibles, le
processeur pourra tout contrôler. En plus, on pourra ajouter des phares et des capteurs.
On veut pouvoir rebrancher la radio, et le fils qui vont vers la radio sont trop court pour le KiCar.
Le plus simple est de couper les câbles loin de la radio, et de remettre des câbles neufs qui
partent des moteurs et de l’alimentation.
Pour l’alimentation, utiliser la Prise-B (http://www.bricobot.ch/docs/PriseB.pdf)
Pour les moteurs, actuateurs, ampoules et LEDs, mettre des prises mâles à 2 broches côté
moteur.
Insérer les pins dans un connecteur
femelle pour éviter que le chauffage
déforme le plastique.
Un fil soudé sans protection casse
rapidement à la soudure. Il faut soit
mettre de la gaine thermorétractable,
soit, ce qui est mieux si c’est bien fait,
mettre une goutte de colle chaude
aplatie entre 2 plaques protégées par
du papier cuisson.
Pendant que le fer est chaud, on peut déjà préparer les adaptateurs des pages suivantes.
Le processeur
Avant de câbler et tester en utilisant des programmes du microcontrôleur, il faut comprendre un
minimum.
Le boitier noir contient la mémoire et la logique qui
exécute les instructions.
Sur les pins on a des groupes de 8 bits, les PORTS
A B C. Les lignes de ce port peuvent être
programmées en entrées ou sorties. En entrée, on
lira l’état d’un interrupteur : 5V si l’interrupteur est
ouvert, 0V s’il est fermé. En sortie, on peut allumer
une diode lumineuse ou faire coller la membrane
d’un haut-parleur. On préfère si le courant est
‘’pompé’’ par le processeur plutôt qu’envoyé. C’est
un 0V qui allume la LED. Les moteurs ont besoin
d’un amplificateur.
Programmer avec Pinguino
La programmation ne s’apprend pas en 5 minutes, il y a beaucoup de règles à comprendre et à
respecter exactement avant de pouvoir créer son propre programme.
Mais c’est assez facile de voir ce que fait un programme en comprenant les quelques mots
d’anglais des instructions et en lisant ses commentaires.
L’environnement Pinguino est utilisé pour éditer les programmes, les compiler (traduire en code
processeur) et télécharger le code dans le KiCar. Mettre en place cet environnement est ingrat,
l’aide d’un gourou est souvent nécessaire. Suivre la procédure dans www.didel.com/kidules/KiPiDe.pdf
Pour apprendre à programmer, cette documentation explique les instructions et propose des
exercices. Un Kidule Dé peut être connecté au KiCar, mais le poussoir du KiCar ne peut pas être
lu, il faut adapter le programme pour lire le poussoir du KiCar.
Pour comprendre le KiCar dans le détail, programmer correctement ses entrées-sorties et aller
vers des applications robotiques complètes, voir www.didel.com/kidules/KiCar.pdf. Le but ici est de
tester des programmes et apprendre à les modifier.
Les phares
Les phares sont prévus sur le connecteur U6top proche du connecteur USB. Les cathodes sont
reliées via leur résistance aux pins 3 et 4, le point commun est la pin2 = +5V.
Le programme pour clignoter les phares est simple. Charger et exécuter KiCarCliPhares.pde
après avoir mis dans un dossier Kicar les fichiers extraits de www.didel.com/kidules/KiCar.zip
La procédure pour mettre en route Pinguino est décrite sous www.didel.com/kidules/KiPiDe.pdf
On doit appeler les définitions de base du KiCar, ajouter celles de l’application, et lancer le
programme qui allume, attend, éteint, attend.
Le connecteur prévu pour les phares est le U4top (connecteur à 4 pins en haut, initialisé en
sorties). Le câblage et les définitions doivent correspondre. La Led droite est câblée entre la pin 4
et la pin 1 (+) Elle s’allume quand le processeur mets un 0 sur sa sortie RC7 (ligne 7 du portC).
En C, on écrit PhareDroite = Allume ;
Il faut avoir déclaré au début #define PhareDroite PORTCbits.RC7 (dépends de notre
application) et #define Allume 0 (dans le fichier KiCarDef.h, s’est valable pour toutes les Leds
que l’on câblera).
// KiCarCliPhares.pde
#include "KiCarDef.h"
#define PhareGauche
PORTCbits.RC6
#define PhareGauche
PORTCbits.RC7
void loop()
{
PhareGauche = Allume;
PhareDroite = Allume;
delay(500); // 500 ms = 0.5s
PhareGauche = Eteint;
PhareDroite = Eteint;
delay(500);
}
Modifiez pour que cela alterne
Une partie non visible du programme (dans le #include) définit des noms qui correspondent aux
pins du processeur et prépare le processeur avec les pins dans la bonne direction (c’est le setup).
On peut tester plusieurs programmes avec les phares, et se familiariser avec quelques
instructions.
KiCarOnOffPhares.pde on allume et éteint si on presse sur le poussoir du processeur.
KiCarVariePhares.pde Variation d’intensité (PWM)
KiCarVariePharesf.pde Idem avec la variation en fonction
KiCarVariePharesLib.pde Idem avec la variation en librairie
KiCarOnOffLentPhares.pde on allume et éteint progressivement si on presse
Le poussoir
Le poussoir nous sera utile pour appeler différents programmes, mais commençons avec des
exemples simples. Il est un peu spécial, car quand on presse, la Led bleue s’allume. Et si la led
bleue est allumée, le processeur voit un poussoir pressé.
On peut tester le poussoir et faire tourner le moteur ou allumer une LED quand on presse.
Le programme KiCarCopieMot.pde utilise la commande if, avec un double = parce que l’on
compare (est-ce que le poussoir est pressé ?)
//KiCarCopieMot.pde
active Mot1Pos
#include "KiCarDef.h"
void loop()
{
if (PousProc == PousOn)
Mot1Pos = On;
else
Mot1Pos = Off;
}
Ce que l’on ne voit pas avec ce programme, c’est que le poussoir a des rebonds de contact, il
alterne on-off irrégulièrement pendant quelque millisecondes, Un délai de 5 ms est nécessaire si
on veut attendre que cela soit pressé, puis relâché pour par exemple démarrer le moteur et
l’arrêter. On a vu les instructions dans le programme KiCarOnOffPhares.pde.
Les programmes suivant agissent sur la Led Bleue qui s’allume 2 secondes quand on a pressé.
On voit que c’est plus clair en utilisant la fonction WaitPous en librairie
KiCarWaitPous.pde
Allume la Led bleue pour 2 secondes à chaque pression
Supprimer ?
Un fonction très utile, un peu plus compliquée à programmer permet de compter le nombre de fois
où on a pressé. Le programme KiCarCntPous.pde apelle GetPous (); qui donne le nombre
d’actions (copiées dans Cnt). On fait ensuite clignoter la Led bleu ce nombre de fois avec une
boucle for.
A noter, que quand on presse, la Led bleue s’allume parce que l’on presse. Quand on n’a plus
pressé pendant 1 seconde, c’est le programme qui fait clignoter la Led.
Plusieurs démos dans le programme
La fonction GetPous peut être appelée à l’enclenchement pour appeler des programmes
différents selon le nombre d’actions sur le poussoir. On verra des exemples plus loin.
Poussoirs supplémentaires et Moustaches.
Là ou il y a une ligne de libre, on peut brancher un
interrupteur, un poussoir, une moustache qui ferme un
contact quand la voiture touche un obstacle.
Pour une paire de moustache, les ligne 0 1 2 3 du
connecteur U6 top conviennent bien et sont déjà prévues
en entrée. Sur ce connecteur, on propose plus loin de
brancher un haut-parleur puissant.
Pour un programme d’évitement d’obstacle naif, il faut dire
‘’ avance, si contact à droite ou à gauche recule pendant 2
secondes .. ‘’ KiCarMoustache.pde a faire et tester
Pour le moteur, on voit que l’ont peut soit penser aux pins
activées ou non, soit à la fonction : avancer, reculer,
stopper. Il suffit de définir ce que l’on veut.
Capteurs de lumières
Une LDR est une résistance
variable. Si on fait un pont
avec une résistance fixe. la
tension va varier. Avec le
câblage ci-contre (LDR contre
le Gnd), la tension diminue
avec la lumière. Le
processeur lit un zéro quand
la tension est en dessous de
1.2V environ, il lit un 1 si la
tension est supérieure à 1.3V.
Entre les deux, le processeur n’aime pas et va hésiter. On vérifie dans un instant.
Le programme KiCarTestIrDist.pde, identique au précédant mais avec l’entrée définie sur la
ligne RA0, c’est à dire la pin 3 du connecteur U6bot teste la LDR en allumant la LedBleue si c’est
obscur.
/*KiCarTestLdr.pde Allume la LedBleue si éclairé
Brancher une LDR avec un pot de 20k sur Dist 0 1..
\image:KiCarLdr.bmp
*/
#include "KiCarDef.h"
void loop()
{
RA4LED; // Led bleue active
LedBleue = Dist0 ; //allume si Dist0 < 1.2V
}
On aurait pu écrire
void loop()
{
RA4LED; // Led bleue active
if (Dist0==0) LedBleue = Allume ;
else LedBleue = Eteint ;
}
On doit mettre l’instruction RA4LED parce que par défaut (si on ne modifie pas les définitions
dans KiCarDef.h) le poussoir PousProc est actif.
On voit que lorsque la lumière varie et que l’on passe entre éteint et allumé, la Led bleue apparaît
en demi-intensité, parce qu’elle est tantôt allumée, tantôt éteinte. Si on rajoute un délai(20); à
la fin du programme, on voit bien que la led clignote dans cette zone de transition.
Jouer avec la lumière n’est pas facile, car l’intensité de l’éclairage varie considérablement et notre
œil, qui a une réponse logarithmique (on est sensible à 10 fois plus, 100 fois plus), ne s’en rend
pas bien compte. L’électronique est linéaire (2 fois plus, 4 fois plus) et il faut adapter les
résistances, avec comme seule règle que la résistance de la résistance doit être 3 fois celle de la
LDR dans la zone de passage du tout ou rien.
En remplaçant la résistance par un potentiomètre, on peut régler le seuil dans une certaine
gamme d’éclairage. On peut aussi mettre un cache sur la LDR. Donc la règles est :
- si c’est obscur, augmenter la résistance
- si c’est très lumineux, cacher une partie de la LDR ou mettre une résistance plus faible.
Avec une LDR, un potentiomètre de 22 à100k est bien adapté.
Attention avec un potentiomètre, il faut toujours se demander ce qu’il se passe lorsqu’il est en
extrémité et que la résistance est faible, puis nulle. Si le courant n’est pas limité, c’est dangereux.
Dans notre cas, le courant est limité par le capteur de lumière. Il faudrait éclairer très fort pour que
cela chauffe.
On peut mettre deux LDR pour éviter les obstacles ? Difficilement car la
variation de lumière est trop faible lorsque l’on se rapproche de l’obstacle. Par
contre, avec un cache entre deux LDR qui regardent dans la même direction,
on peut écrire un programme qui fait que le robot se dirige vers une bougie.
Eviter des obstacles
Les capteurs de distance infrarouge (IR) ont une diode qui éclaire et un phototransistor qui
mesure la lumière. Le phototransistor est comme une LDR, un peu moins sensible. Pourquoi de
l’infrarouge ? Pour être moins sensible à la lumière ambiante. Le soleil donne peu d’infrarouge,
une ampoule beaucoup, un néon moins, une Led visible pas du tout. Donc ne comptez pas sur
une lampe de poche à Leds pour faire réagir votre robot.
Comme on le voit dans la figure, il
faut une résistance pour limiter le
courant dans la Led IR et un
potentiomètre pour régler la
distance de commutation. On
veut deux capteurs, et on peut
mettre les diodes IR en série.
Pour économiser du courant, on
passe par un transistor qui allume
pendant la mesure ; une mesure
toutes les 20ms (le robot se
déplace de quelques mm) et bien
suffisante.
Le transistor est prévu sur le
connecteur U6bot et pour faciliter
le câblage, un circuit imprimé est
utilisé pour le capteur.
Il nous faut d’abord un
programme de test. La
Led Bleue est de
nouveau très utile. Le
programme précédent a
été modifié en faisant un
cycle avec les Leds IR
allumées, puis éteint. On
sait mieus ainsi que
l’éclairage fonctionne.
/*KiCarTestIrDist.pde Allume la LedBleue si obscur
Brancher une LDR avec un pot de 20k sur Dist 0 1 2 3
\image:KiCarDist2Ir.bmp
*/
#include "KiCarDef.h"
void loop()
{
RA4LED;// active la Led bleue en sortie
IR01 = On ; IR23 = On ;
LedBleue = Dist0 ;
delay (100) ;
IR01 = Off ; IR23 = Off ;
LedBleue = Dist0 ;
delay (100) ;
}
Si on décide que RA0 est à gauche et que l’on câble correctement, on va tout de suite définir des
noms clairs : #define IRGauche PORTAbits.RA0
#define IRDroite PORTAbits.RA1
Une lecture analogique permettrait de mesurer des petites différences de lumière, mais seulement
dans la zone entre 1V et 4V. Le potentiomètre reste nécessaire, car entre une chambre et une
terrasse, la lumière change dans un facteur 1000, sans que notre œil s’en rende vraiment compte.
Pour un premier test, mettre une résistance de 2 à 10 kOhm et charger le programme
KiCarIn0.pde, qui copie l’état de la pin IRGauche (ou Droite si on appuie sur le poussoir) sur la
LedBleue.
Photos pcb, vero, selon sol choisie par Jonatan
La sol que je préfère. Capteurs pré-câblés
PCB avec ou sans pot.
Les moteurs
Les moteurs d’un robot jouet sont souvent bruyant et consomment beaucoup de courant. Une
résistance de 5 à 10 Ohm en série, ou mieux une paire de diodes tête-bêche (le courant doit
passer dans les 2 sens) limite la puissance. Avec la pile directement connectée sur un moteur (les
connecteurs sont pratiques, c’est facile de tester. Ce qu’il faut savoir, et que l’on peut vérifier en
mettant une ampoule de lampe de poche en série avec le moteur (pas une diode lumineuse),
c’est que le courant de démarrage est 2 à 5 fois plus important que quand le moteur tourne.
Si le câble USB du Kidule fournit ce courant, il y a chute de tension dans le câble et avec le câble
fin des dérouleurs, le processeur peut voir sa tension baisser tellement qu’il redémarre. Il y a
aussi des parasites dus aux balais qui n’améliorent pas. Bref, utilisez un câble USB court ou
laissez la batterie de la voiture sous tension (il y a une diode de protection).
Souder deux LEDs bicolores sur un
connecteur. Cela permettra de remplacer les
moteurs par des LEDs et d’avoir toute
l’information voulue sur le sens de rotation et la
vitesse, sans avoir l’inconvénient du bruit et de
l’usure plus rapide des piles.
La carte KiCar a deux amplis qui font circuler le courant dans un sens ou dans l’autre. Selon les
combinaisons des 2 bits, on a 4 comportements pour un moteur ou une diode bicolore
Mot0Pos=0;Mot0Neg=0; 0 0
roue libre
diode bicolore éteinte
Mot0Pos=0;Mot0Neg=1; 0 1
tourne dans un sens
vert (ou rouge)
Mot0Pos=1;Mot0Neg=0; 1 0
tourne dans l’autre sens
rouge (ou vert)
Mot0Pos=1;Mot0Neg=1; 1 1
bloqué
diode éteinte
idem pour le moteur1
Le courant maximum est 0.5A. Roue libre signifie que l’ampli est ‘’inexistant’’ pour le moteur. Dans
l’état bloqué, les transistors sont conducteurs, et la force contre-électromotrice freine le moteur,
comme quand on court-circuite ses sorties.
Le programme KiTestMoteurs.pde fait des aller-retours avec arrêt de 0.8 secondes. Si on presse
sur le poussoir, le moteur est bloqué à l’arrêt. On voit bien la différence.
Moteur ralenti
Pour ralentir un moteur, on lui envoie des impulsions. Le PWM continuer
On a vu comment clignoter des Leds. En augmentant la fréquence, on peut commander un
moteur en ralenti. Mais on ne fait rien d’autre. Ralentir le moteur par des impulsions oblige de
travailler par interruption. On lance une routine d’interruption assez compliquée, puisqu’elle va
aussi surveiller le capteur de distance et le poussoir.
Trajectoires
avance (vitesse, angle) recule () tourneDroite ?? vitesse –7.. 0..7 tourne -7..0..7
ex de programme avance si obstacle recule etc
Le klakson
Un buzzer ou haut-parleur est commandé par une sortie du
microcontrôleur. Il faut savoir si un 1 ou un 0 fait coller la
membrane. Sur une sorties directe, on peut choisir, mais c’est
un 0 actif qui est préféré. Si le haut parleur est câblé sur une
sortie transistor, c’est un 1 car le transistor inverse. Le transistor
augmente considérablement le courant, donc le bruit.
Le programme KiCarSon.pde est simplement un clignotement
rapide. Dépéchez-vous de charger KiCarSonPous.pde qui ne
fait du son que si l’on presse sur le poussoir.
Le programme KiCarSirene.pde a été repris de la notice www.didel.com/kidules/KiPiDe.pdf ,
qui explique différents approches.
Capteur de télécommande infrarouge
Un IRM (InfraRed Module) a trois pattes et se branche
sur une prise servo redéfinie en entrée.
La routine KiCarZap.pde a faire surveille ce qui vient
en infrarouge et prend une décision tout-ou-rien, comme
si c’était un poussoir qui a des long rebonds pendant
que l’on pèse.
Le programnme KiCarTestIRM.pde a faire n’est pas
bloquant.il dure quelques millisecondes pendant
lesquelles il étudie comment le signal change, et il
active une variable s’il y a eu pression d’une touche
quelconque de la télécommande pendant une demiseconde.
Pour décoder les touches, il faut savoir quelle est le type
de la télécommande et c’est nettement plus compliqué.
photo
jdn 110423/110529
Programmes sur le .zip
KiCarDef.h
KiCarCliPhares.pde
KiCarCopieMot.pde
KiCarTestLdr.pde
KiCarWaitPous.pde
KiCarTestIrDist.pde
KiCarIn0.pde
KiCarSon.pde
KiCarSonPous.pde
KiCarSirene.pde
KiCarSireneLente.pde