vendredi 22 juillet 2011

Des yeux pour Arduino Car

Introduction
Jusqu'a maintenant, je me suis focalisé sur la propulsion d'Arduino Car.
Si cela en fait un véhicule capable de se déplacer seul, il est aussi terriblement stupide dans ce sens ou il ira se jeter sur le premier obstacle sans même s'en rendre compte.

Voila pourquoi je vais équiper Arduino Car de senseur.
Mon dévolu se porte sur les capteurs infrarouge gp2y0a21 de Sharp.


Capteur infrarouge Sharp gp2y0a21
J'ai justement eu l'occasion d'en acheter 4 chez Antratek.
J'ai d'ailleurs écris l'article "Detecteur de proximité infrarouge - Sharp gp2y0a21" sur Arduino Notepad, un occasion unique pour se faire la main dessus.
L'article précité indique d'ailleurs ou se fournir ce type de capteur.


Montage des capteurs
Je vais commencer par monter deux capteurs sur l'avant de la voiture histoire de détecter les obstacles frontaux.
Une bonne partie de l'article sera consacré à ce montage et aux tests des capteurs.

D'autres capteurs seront nécessaires

Par contre, je sais déjà qu'il me faudra envisager deux autres capteurs, ce que viendra confirmer les premiers tests.
Ces capteurs serviront:
  • Détecter les obstacles en hauteur (pour éviter à la voiture de se jeter sous les meubles bas ou les voitures).
  • Un détecteur de profondeur (orienté vers le sol) pour détecter les trous ou simplement les bordures de trottoir en oblique (45°).
  • Si le détecteur de profondeur est placé au centre de pare-chocs, cela permettra aussi de détecter des objets tels que des pieds de chaises ayant échappé aux deux premiers détecteurs.
Truc et astuces
Pour faciliter le montage, je vous suggère de préparer:
  1. L'utilisation de tout petits colsons (exemple ici) pour faciliter le montage. 
  2. Un fer à souder pour marquer les emplacements des trous à forer pour placer les senseurs infrarouges.
  3. Une mèche pour faire les trous en vue de laisser passer les colsons.
  4. Du fil et des pins headers pour le raccordement sur les entrées A0 et A1 d'Arduino.
Le montage en images
Eléments du montage

Percage des trous de fixation

Fixation à l'aide de Colsons

Autre vue de la fixation

Raccordement électrique

Détail du raccordement

Placement sur la voiture

Raccordement Arduino
  • Entrée Analogique A0 : Senseur Gauche (fil brun)
  • Entrée Analogique A1 : Senseur Droit (fil orange)
  • Sortie 3.3V raccordée sur entrée AREF.
    Comme les capteurs infrarouges ne retournent pas une tension supérieure à 3.3V, cet important raccordement permet d'augmenter la précision des lectures analogiques.
Schéma de raccordement des détecteurs
Test de la détection
Pour faire les tests de détections, j'ai créé un petit logiciel spécifique lit les valeurs analogiques sur A0 et A1 et envoi l'information sur le port série (qu'il est possible de visualiser avec le moniteur d'Arduino IDE).
L'information est lue toutes les secondes et envoyées sur le port série comme suit:
----------------------------
GAUCHE 478, volt=1.54, prox=24
DROITE 71, volt=0.23, prox=255
-----------------------------
GAUCHE 470, volt=1.51, prox=24
DROITE 232, volt=0.75, prox=255

A savoir:
  • Détecteur de Gauche
    • Valeur lue sur le port analogique (0 à 1024)
    • Conversion en volts (sur base de la tension de référence de 3.3v)
    • Un indice de proximité (voir documentation plus loin).
  • Détecteur Droit
    Idem
Indice de proximité
Sur base du graphique suivant disponible dans la datasheet (accessible depuis cet article) et sachant que la dite "distance de jugement" est de ~24cm, j'ai écris un bout de code évaluant grossièrement la proximité d'un objet (l'indice de proximité).
Source: datasheet
Ce bout de code retourne les valeurs suivantes:
  • 255: hors du champs de proximité. Pas d'évaluation plus précise.
  • 24: distance de jugement atteinte. Soit 24 cm ou moins.
  • 15: distance proche atteinte. Soit 15cm ou moins (il est grand temps d'agir!).
Code source
Source: Infrared_Sensor_Test.pde
/*
    ArduinoCar - http://arduinocar103.blogspot.com
    Test des detecteurs Infra-rouge Avant  d'ArduinoCar
    
    Date: 21 juillet 2011
      
    Description:
      Ce programme affiche les valeurs detectées par les deux 
      détecteurs IR placé à l'avant de la voiture (branchés 
      sur A0 et A1).
      
      Les valeurs sont écrites sur le port série
    
    Montage:
      ARef = 3.3 volts
      Infrared left=pin A0
      Infrared right=Pin A1
 */
 
 int pinIrGauche = 0; // détecteur Infrarouge a Gauche
 int pinIrDroite = 1; // détecteur Infrarouge a Droite
 
 void setup(){
     analogReference( EXTERNAL );
     Serial.begin( 9600 );
 }
 
 void loop(){
   // Capture de la valeur
   int valeurIrGauche = analogRead( pinIrGauche );
   int valeurIrDroite = analogRead( pinIrDroite );
   
   // Transformation en volts (référence=3.3v)
   float voltIrGauche = ((float)valeurIrGauche)*3.3/1024;
   float voltIrDroite = ((float)valeurIrDroite)*3.3/1024;
   
   // Evaluation de la proximité (par ordre de grandeur en CM)
   // Les valeurs possibles sont:
   //  * 255 = valeur maximale, hors du champs de la perception
   //  * 24  = objet à la distance de jugement (24 cm ou moins)
   //  * 15  = objet très proche (15 cm ou moins)
   // 
   byte proximiteGauche = 255; // distance > 24 cm
   if( voltIrGauche > 1.6 ) 
     proximiteGauche = 15; // distance < 15 cm
   else
     if( voltIrGauche > 1.1 ) // distance de jugement +/- 24 cm
       proximiteGauche = 24;

   byte proximiteDroite = 255; // distance > 24 cm
   if( voltIrDroite > 1.6 ) 
     proximiteDroite = 15; // distance < 15 cm
   else
     if( voltIrDroite > 1.1 ) // distance de jugement +/- 24 cm
       proximiteDroite = 24;
   
   // Affichage des valeurs
   Serial.print( "GAUCHE " );
   Serial.print( valeurIrGauche ); Serial.print( ", volt=" ); 
   Serial.print( voltIrGauche ); Serial.print( ", prox=" ); Serial.println( (int)proximiteGauche );

   Serial.print( "DROITE " );
   Serial.print( valeurIrDroite ); Serial.print( ", volt=" ); 
   Serial.print( voltIrDroite ); Serial.print( ", prox=" ); Serial.println( (int)proximiteDroite );
   
   // Affichage d'un séparateur
   Serial.println( "-----------------------------" );
   
   delay( 1000 ); // attendre 1 seconde avant lecture suivante.
 }

Conclusions
Premièrement: la fonction de proximité
Le code de détection de proximité va grandement facilité la détection d'objet.
Il faudra donc en faire une fonction.

Deuxièmement: les défauts de détections
Il existe des situations dans lesquelles la détection de proximité est peu inefficace, voire pas du tout.
Certaines imperfections peuvent être palliées par une action logicielle... d'autres nécessiterons des capteurs complémentaires.

La bordure de trottoir en biais:
Dans ce cas, la détection des 24 cm n'intervient que très tard... très vite suivie par la détection des 15 cm (pour une avancée du véhicule d'un cm seulement).
ArduinoCar détecte pas rapidement les bordures en biais.

Dans ce cas, la détection est tellement tardive que le véhicule ira se jeter dans la bordure rien qu'avec son inertie.
Il faudra donc prévoir un système de freinage pour que le véhicule (une impulsion en marche arrière par exemple :-) ).

Les objets au dessus des détecteurs:
C'est le cas des dessous d'armoire, ou de voiture.
Si les senseurs passent, ce n'est pas forcement la cas du restant du véhicule exemple.
Arduino Car ne détecte pas les objets en hauteur
Il est possible de résoudre cet inconvénient en plaçant un senseur en hauteur.
 
Les objects sous les détecteur:
Voici un cas pratique
Arduino Car ne détecte pas les objets au ras du sol
Ce cas de figure (tout comme la bordure de trottoir en biais) peu être contourné en plaçant un détecteur infrarouge pointant vers le bas.

Le pied de chaise:
Encore un autre cas pratique...
La pied de chaise n'est pas détecté!
Ce problème, tout comme celui des objets au dessus des détecteurs peuvent être résolu à l'aide d'un senseur infrarouge en hauteur (et orientable).


... il ne reste plus qu'a passer à la suite

mercredi 20 juillet 2011

Premières constatations d'ordre technique

J'ai eu l'occasion de faire quelques essais avec Arduino Car maintenant que la motorisation est terminée.

Et trois choses sautent immédiatement aux yeux.

Premièrement: détection des obstacles
C'est prévu depuis le début mais il faudra vraiment que j'ajoute des détecteurs infrarouge sur Arduino Car.
Lorsque l'accu est bien chargé, une marche avant de 4 secondes est suffisant pour que la voiture quitte le parking (pour aller s'encastrer sous un autre véhicule).

Deuxièmement: autonomie, une histoire d'accu
Le véhicule ne dispose pas d'une très longue autonomie.
En moins de 10 minutes, l'accumulateur est suffisamment a plat pour que la voiture n'avance presque plus à régime de 78% alors que c'est honorable à pleine charge.
Ensuite, comme le véhicule manque de nerf, la direction ne se redresse pas vraiment bien... probablement que le fait d'avancer aide la direction à se redresser.

L'accumulateur à une autonomie de 650mAh.
Les précédentes mesures ont démontrés que la propulsion consomme environ 800mA en charge et que chaque train de direction consomme ~330mA en butée.
Comme il y a deux trains de directions, cela fait 660 mA
Dans la pire des situations, la consommation globale est de  ~ 800 + (330 * 2) = 1460mA.
Si je veux faire fonctionne mon montage pendant une heure, j'ai besoin d'un accu de 1500 mAh.
Hors, je n'ai qu'un accu de 650mAh (usagé). Je ne peux compter au mieux que sur 30 minutes d'activité.
Quoi que 15 à 20 min semble plus vraisemblable!


Troisièmement: la distance parcourue
C'est bien beau de faire une marche arrière pour changer de direction (face a un mur par exemple).
Mais la distance parcourue lors de la marche arrière dépends de la charge de batterie.
Lorsque la batterie est presque morte, le véhicule ne parcours par 1/4 de tour en 2.5 secondes... alors qu'a pleine charge, elle fait plus d'un tour sur le même laps de temps.
Il faudra donc un moyen pour mesurer/estimer la distance parcourue... probablement d'un capteur à effet Hall et de quelques aimants permanent sur la roue.

En conclusion, je dirais qu'il y a encore du boulot :-D

Commande de la motorisation

Introduction
Après le montage place à la programmation de l'Arduino Car.
Pour le moment, il ne sera malheureusement possible que de se concentrer sur la mise en marche et la commande des trains de direction.

La voiture étant encore dépourvue de détecteurs, il ne peut malheureusement pas interagir avec le monde extérieur.
J'entends par interaction le fait de ne pas aller se jeter bêtement dans dans un mur ou un arbre... mais chaque chose en son temps -);

Quoi qu'il en soit, cela n'empêche pas de préparer un code relativement correcte et faisant preuve d'une certaine lisibilité.


Résultats
Voici la vidéo du résultat obtenu histoire de se mettre un peu l'eau à la bouche ;-)


Informations techniques
Le code à été rédigé de manière à rendre son utilisation la plus "simple" et "évidente" possible.
Ainsi, lorsque les choses se compliquerons un peu, il n'y aura pas lieu de se demander comment on fait avancer la voiture... de simple appels de fonction tel que marche( AVANT, 100 ) (pour une avance à 100% de régime) me simplifiera grandement la vie.

Constantes
J'ai ajouté quelques définitions de constantes pour améliorer la lisibilité du code.
Concernant la direction:
  • DROITE: pour tourner à droite.
  • GAUCHE: pour tourner à gauche. 
  • AUCUN: Pour aller tout droit (abandonner tout changement de direction).
Il est également possible de commander chaque train de direction indépendamment... dans ce cas, j'utilise les constantes AVANT & ARRIERE décrites plus loin pour indiquer le train de direction à commander.

Concernant le déplacement:
  • AVANT: Marche avant OU Commande Direction Avant.
  • ARRIERE:  Marche Arrière OU Commande Direction Arrière
  • ARRET: Passer à l'arrêt
L'instruction marche
Mise en marche du moteur de propulsion dans un sens et a un régime déterminé.

void marche( byte Sens, byte Regime)

Paramètres:
  • Sens: Direction de déplacement (AVANT/ARRIERE/ARRET)
  • Regime: Regime moteur en % (de 0 à 100)
Note:
Pour un arrêt de la marche, il suffit d'indiquer un régime moteur de 0% (peu importe le sens).

L'instruction arret
Signifie l'arrêt du moteur de propulsion!

void arret()

Note:
Effectue l'appel  marche( ARRET, 0 );

L'instruction tourner - première forme
Commande du train de direction avant ou arrière dans le but de faire tourner le véhicule dans une direction désirée (vers la droite ou la gauche).

void tourner( byte Train, byte Direction )

Paramètres:
  • Train: Train de direction à commander (AVANT ou ARRIERE).
  • Direction: Direction que doit prendre le véhicule (DROITE, GAUCHE, ou AUCUN pour "tout droit").
Exemple:
tourner( AVANT, DROITE)

L'instruction tourner - deuxième forme
Coordonne les deux trains de directions (avant et arrière) dans le but de faire tourner le véhicule dans la direction voulue.

void tourner( byte Direction )

Paramètres:
  • Direction: Direction souhaitée pour le véhicule. DROITE, GAUCHE, AUCUN (pour "tout droit")
Exemple:
tourner( GAUCHE )

Code source
Source: ArduinoCar_Test_Moteur.pde
 
Code d'exemple
Dans un premier temps, le code initialise toutes les sorties dans la fonction setup().
Et bien que cela n'est pas conforme à l'utilisation générale d'Arduino, la fonction setup() appelle la fonction de test testMoteur().
En faisant de la sorte, la routine de test ne fonctionne qu'une seule et unique fois (ce qui est bien pratique) et est réactivable en pressant le bouton reset :-)

void setup(){
  // Direction
  pinMode( pinFrontDir1, OUTPUT );
  pinMode( pinFrontDir2, OUTPUT );
  pinMode( pinBackDir1, OUTPUT );
  pinMode( pinBackDir2, OUTPUT );
  // Motor 
  pinMode( pinMotor1, OUTPUT );
  pinMode( pinMotor2, OUTPUT );
  // La commande PWM est assurée à l'aide d'AnalogWrite
  
  testMoteur();
}

void testMoteur() {
  // Avance mis regime apparent
  marche( AVANT, 78 );
  delay( 5000 );
  
  // Demi-tour
  tourner( DROITE );
  marche( AVANT, 78 );
  delay(3200);
  arret();
  tourner( GAUCHE );
  marche( ARRIERE, 78 );
  delay(3200);
  arret();
  tourner( AUCUN );
 
  // Avance rapide
  marche( AVANT, 100 );
  delay( 3000 );
  arret();
  
  // Deplacement de travers
  tourner( AVANT, DROITE );
  tourner( ARRIERE, GAUCHE );
  marche( ARRIERE, 100 );
  delay( 4000 );
  tourner( AVANT, GAUCHE );
  tourner( ARRIERE, DROITE );
  marche( ARRIERE, 1000 );
  delay( 3000 );
  
  // Arret definitif
  arret();
  tourner( AUCUN );
}

Assemblage des composants de motorisation

Introduction
Voici donc le moment de placer un Arduino sur Arduino Car et d'effectuer les différents raccordements des prototypes boards destiné à la propulsion de l'engin.

Nous verrons plus tard comment monter des dispositifs de détections pour éviter les murs et autres objets placés sur le parcours d'Arduino Car?

Pour facilité le montage et les raccordements, je vais commencer par une section truc et astuce qui sera bien utile pour vous facilité la tâche.

Trucs et Astuces
Fixation d'Arduino
Pour la fixation d'Arduino, j'utilise des petites vis type vis à bois que l'on retrouve sur tous les types d'appareils électroménager. Ce type de vis rentre assez facilement dans le plastique.
Pour faire les trous, le plus simple est encore d'utiliser la pane pointue & bien chaude de votre fer à souder.
En y allant pas trop fort, il est possible de faire un avant trou de taille raisonnable où l'on peut y présenter la future vis. Après refroidissement du plastique, il sera plus facile de l'y visser.
De même, il est possible de placer Arduino à sa position finale et d'utiliser la pane du fer à souder pour marquer l'emplacement des trous.
et comme déjà précisé, il suffit d'un bon coup de chiffon à chaud et immédiatement après la fonte du plastique pour nettoyer la pane du fer à souder.

Alimentation d'Arduino
Juste une petite note pour précisé le raccordement de l'alimentation 9 Volts sur Arduino.
Il est toujours possible d'utiliser une prise jack comme décris sur l'article "Alimentation externe pour Arduino" mais il est tout aussi simple (dans notre cas) de:
  • raccorder le "-" de la pile 9v sur une broche GND d'Arduino
  • raccorder le "+" de la pile de 9v sur la broche Vin d'Arduino
En fait la broche Vin est branchée sur le centre le la prise Jack (juste avant le régulateur de tension d'Arduino.

Raccordement des prototypes boards
Les différents prototypes board d'Arduino Car sont équipés de Pin Header (mâles) tandis qu'Arduino est équipé de bornes de raccordement femelle.

Raccorder le tout peut paraître fastidieux. Pourtant, il est possible de se simplifier la tâche assez facilement.

Il est possible de se fournir des "fiches femelles" correspondant au Pin Header sur des PC hors d'usage (surtout sur les raccordement utilisés pour les boutons et les leds en façades).


Avec un peu d'imagination, un fer à souder et du thermo-rétractable, il est possible de monter:
  • Des câbles "femelle-femelle" pour raccorder les prototypes board entre eux.
  • Des câbles "mâle-femelle" (en utilisant quelques pin header) pour raccorder les prototypes board sur Arduino.
Si vous éprouvez du mal à vous fournir des fiches/contacts mâles, vous pouvez toujours en acheter en fourniture électronique:
  • Chez Cotubex (pour la belgique) dans la gamme CO36
  • Autres suggestions encore à venir
Assemblage
Après les recommandations, voici les différents raccordements entre les prototypes boards de l'Arduino Car
Raccordements des prototypes board de l'Arduino Car
 Informations sur le montage
  • Les masses des alimentations +9v et +7.2v sont raccordées ensemble sous le prototype board.
  • Arduino est alimenté en +9v via la pin Vin
  • La logique du L293E et du L298HN sont alimentés par le régulateur d'Arduino (broche +5v d'Arduino).
  • Je n'utilise pas de commande PWM pour la direction. C'est pour cette raison que les deux broches "Chip Enabled" du L293E sont directement raccordées au +5v.
  • Le moteur de propulsion sera commandé en PWM. C'est pour cette raison que la broche "Chip Enabled" du L298HN est raccordée sur sur sortir PWM d'Arduino.
Arduino - branchement des broches de commande
  • Arduino Pin 2 & 3 : Commande de direction du train avant.
    • Pin 2=High + Pin 3=Low => une direction
    • Pin 2=Low + Pin 3=High => autre direction
    • Pin 2=Low + Pin 3=Low => mouvement libre, c'est la mécanique de rappel qui recentre les roues dans l'axe du véhicule.
    • Si le véhicule tourne dans la mauvaise direction, il faut soit inverser le raccordement des pin 2 & 3, soit inverser la logique de commande du programme Arduino.
  • Arduino Pin 12 & 13 : Commande de direction du train arrière
    Mêmes indications que pour les pins 2 & 3
  • Arduino Pin 4 & 5 : Commande du sens de marche
    • Pin 2=High + Pin 3=Low => Avant
    • Pin 2=Low + Pin 3=High => Arrière
    • Pin 2=Low + Pin 3=Low => Pas de déplacement.
    • Attention: l'ordre de mise en mouvement est commandé par la pin PWM 11.
    • Tout comme pour la direction, si le sens de déplacement physique est incorrect, il suffit d'inverser le raccordement de la pin 4 & 5 ou de modifier la logique du code.
  • Arduino Pin 11: Commande du moteur de propulsion en modulation de largeur d'impulsion.
    La commande du "Chip Enabled" du L298HN en PWM permet de moduler la puissance moteur d'Arduino.
    A PWM = 200 (soit 78%) donne une propulsion apparente à mis régime.
    A PWM = 255 (soit 100%) donne une propulsion a plein régime.
Résultat final
Voici l'encombrement final.
Seul l'alimentation est raccordée sur Arduino... le restant des branchements n'est pas encore fait.
Encombrement de l'Arduino Car
(manque encore les raccordements sur Arduino)

lundi 18 juillet 2011

Etage de puissance - Montage

Introduction
Après le montage du bornier moteur, il est temps de penser à l'étage de puissance.
Après avoir fait les différents essais (voir "Test des étages de puissance"), j'ai décidé de monter l'étage de puissance sur un prototype board avec les spécifications suivantes:
  • Utiliser un L293E (moteurs de directions) et un L298HN (moteur de propulsion)
  • Pas d'utilisation des circuit senseurs du L293E et L298HN (raccordement des broches senseurs à la masse).
  • Faire un montage sur un autre prototype board 2.54 mm.
    Ainsi, il sera facilement de le démonter de l'Arduino Car pour l'utiliser temporairement avec un autre montage.
  • Utiliser des "pin header" pour les différents raccordements.
    A la fois avantageux pour sa légèreté et sa facilité d'assemblage.
  • Séparation complète des circuits L293 et L298.
    Cela permettrait éventuellement d'utiliser le L293 avec une alimentation de puissance différentes (en puissance et tension) de l'étage de puissance du L298.
    Cela peut s'avérer très pratique si je réutilise l'étage de puissance sur un autre montage.
  • Utilisation de diode de protection de type "Fast".
    BYV27-100-TAP: Diode Ultrafast, 2A, 100V. Farnell #1469371
Composition de l'étage
Les différentes instructions de montages sont accessibles depuis l'article "Test des étages de puissance".
Ainsi donc, je vais me contenter de décrire les différentes connexion de l'étage assemblé sur le prototype board.
La logique de commande est alimentée à l'aide de la sortie +5V d'Arduino.
Toutes les masses ont étés raccordées entre-elles.
Concernant les cavalier, je regrette de ne pas avoir pensé à faire la même chose pour VSS (l'alimentation de la logique de commande).
Cela aurait été bien pratique :-/

Détail du brochage
Voici le détail du pinning de raccordement du L298HN et L293E sur le prototype board

Fixation sur l'Arduino Car
Dans le cas ci-présent, j'avais anticipé la fixation du prototype board sur l'Arduino Car.
C'est la raison pour laquelle il y a deux sections au feutre rouge, endroit où je ne pouvais rien souder car il reposaient directement sur la voiture.
La fixation est assurée par de simple vis de type mécano.

Au final cela ressemble à cela.

Il reste encore de la place au milieu pour placer un Arduino et à l'avant pour un périphérique de détection de proximité :-)

Truc et astuces
Protection et isolation
Les différentes soudures du L298 et du L293 et raccordements sont assez proches.
Il n'est pas toujours facile de travailler avec du fil téléphonique tout en étant certain de ne pas faire fondre la partie isolante du fil...
De même, au montage (ou lors d'incident avec l'Arduino Car), une pression pourrait causé de faux contacts dans la partie de puissance.
Pour éviter facilement ce problème, il suffit d'utiliser un pistolet à colle chaude pour enduire les différents points/soudures sensibles. Cela assure autant la stabilité du montage que son isolation (d'un contact/fil par rapport à l'autre).

Circuit de dissipation du L293
N'oubliez pas de souder les pins GND du L293 et de lui assurer une surface de dissipation minimal.
Voir section "Le refroidissement" dans l'article "Contrôle Moteur DC via L293E"

Ou trouver des cavaliers
Les cavaliers permettant de raccorder ensembles les étages VS du L293E et L298HN peuvent, comme souvent, être dégotés au parc à container.
Les disques durs et lecteurs CD des ordinateurs disposent souvent quelques cavaliers de 2.54 mm d'espacement :-)



dimanche 17 juillet 2011

Bornier moteur

Description
Monter un "bornier" de raccordement moteur sur l'ancienne voiture télécommandée permet de faciliter le raccordement des différents moteurs sur l'étage de puissance (encore à venir).

C'est aussi l'occasion d'ajouter une pile de 9 volts qui fournira une alimentation séparée pour la logique de commande (à savoir Arduino).
Séparer les alimentations de l'étage de puissance et de la logique de commande est une recommandation assez courante, cela permet de maîtriser les interférences dues aux parasites (voir recommandation de séparer les alimentations de l'article "Montage Moteur DC - Recommandations").

Montage du bornier
Le bornier est constitué d'un morceau de prototype board et de "Pin Header" (plus léger qu'un vrai bornier à vis).

Les deux premières étapes furent:
  1. De rallonger les câbles moteurs.
    • Avec du fil récupéré dans un PC au parc à container (cela fera très bien l'affaire).
    • Préserver les selfs (ou en ajouter soi même) sur le moteur de propulsion est tout à fait approprié.
    • Un peu de gaine thermo-rétractable assurera l'isolation.
  2. De percer un trou (à la foreuse) sur le dessus du boîtier pour faire passer les câbles.
    Plusieurs trous en cercle peuvent être nécessaire... il est possible d'éliminer les rugosités en faisant fondre le plastique avec un fer à souder.
Rallonger les fils moteurs
Préserver les selfs (à enfermer dans
de la gaine thermo-rétractable)
Utiliser de la gaine thermo pour isoler (en blanc ici)
Détail important
Il est très important de raccorder ensemble toutes les masses.
C'est à dire celles des moteurs et celles de l'accumulateur 7.2 volts



Fermeture du bloc principal

Mise en place du bornier
Détail du bornier
Détail toujours aussi important
Il faut également raccorder ensemble les masses des alimentations de puissance et de logique de commande.
Le "-" de la pile de 9 volts doit donc être raccordée au "-" de l'accumulateur de 7.2 volts (tout comme cette dernière masse doit être connectée aux masses des moteurs)

Truc et astuces
Placer le bornier à l'arrière
Le bornier est placé à l'arrière car il faut encore assembler et placer:
  1. Un étage de puissance constitué d'un L293E et d'un L298HN.
  2. Un Arduino
  3. Divers détecteurs de proximités (on en parlera bien plus tard).
Fixation du bornier
Quelques pièces de mécano sont toujours les bien venues surtout les petits tubes en plastiques qui permettent d'insérer une séparation physique entre le prototype board et le support en plastique de la voiture.
C'est plus propre et cela laisse de la place pour le passage des câbles sous le prototype board.
Pour la fixation, vous pouvez opter pour de petites vis type "bois", de celle utilisée dans les différents appareils ménagés (récup. au parc a container).
Ce type fixation est assez discrète et rentre assez facilement dans le plastique.

Un petit truc:
Vous pouvez faire un petit avant trou avec votre fer à souder.
Vous remarquerez avec le temps que fer a souder et plastique font bons ménages.
Il suffit de passer un chiffon sur le fer (juste après opérations) pour retirer les déchets de plastiques collés sur la pane.

Connecteur 9 Volts
Le connecteur 9 volts peut aussi être récupéré sur n'importe quel rechargeur de piles ou certaines télécommandes.
Encore une fois, c'est un article (le rechargeur de pile) que l'on trouve assez souvent dans un parc a container.
Pensez aussi a placer un petit interrupteur pour couper facilement l'alimentation 9 volts. J'en ai rajouter un depuis l'écriture de l'article ;-)

samedi 16 juillet 2011

Test des étages de puissance

Dans l'article précédent, je mentionnais le choix d'un L293 pour la commande des trains de direction et celui d'un L298HN pour la commande de la propulsion.

Après avoir acheter les composants chez Farneel Belgique (via be.farnell.com), j'ai effectué les différents montages de test.
Montage avec lesquels j'ai, entre autre, mesuré les différentes tensions et différents courant de fonctionnement.

Ces montages sont décrits sur Arduino103.blogspot.com (blog.domeu.net) un blog plus général consacré à Arduino.

Je vous propose donc la lecture des articles suivants:
  1. Contrôle Moteur DC via L293D (H Bridge Driver, Circuit Intégré Pont H)
  2. Contrôle Moteur DC via L293E
    Le L293E est la version du circuit utilisé pour le contrôle des trains de direction.
  3. Contrôle Moteur DC via L298
    Le L298HN utilisé pour la propulsion du véhicule.
    Si le L298N est disponible chez Farnell il faut rallonger 25 eur pour le faire venir des Etats-Unis.
    Par contre, le modèle L298HN (H=Horizontal) est disponible sur le sol Belge sans surcoût :-) .
    Finalement, je vous suggère de lire l'article référencé car l'adaptation d'un L298 sur un board 2.54mm réclame quelques manipulations.
  4. Pour les plus mordu, l'article "Pont H à transistor pour contrôler un Moteur DC dans les deux sens" qui aborde le fonctionnement technique des Pont-H.
  5. Un passage par l'article "Montage Moteur DC - Recommandations" peut également vous apprendre quelques informations utiles.
Au final, voici le résultat "visuel" de mes différents essais de montage du L293E (en premier) et L298HN (en deuxième).
 


Restera plus qu'a prévoir un montage définitif sur un board de prototypage... mais ce sera pour plus tard.

Première mesure et premières erreurs

Pourquoi faire des mesures
Il faudra utiliser pour commander le moteur principal et les trains de directions.
Bien entendu, il serait possible d'utiliser des pont-H fait main ... mais le plus facile serait encore d'utiliser des circuits intégrés à Pont-H histoire de se simplifier la vie.
La plupart des pont-H supportent facilement plus de 40 Volts, des mesures de tension de fonctionnement ne sont pas nécessaires.

Par contre, le choix du circuit intégré dépendra principalement de le puissance requise... et donc du courant de charge du moteur.
C'est pour cela qu'une série de mesure s'impose pour connaître les courant de fonctionnement.

Premières mesures, premières erreurs
Ma première erreur est grosse comme une porte de maison !
Armé de mon multimètre, je me suis mis en tête de mesurer les courants de fonctionnement des différents moteurs (propulsion, direction avant et direction arrière).
Ayant déjà constaté que la direction n'est pas prise en charge par un servo-moteur, je sais déjà que le moteur DC ira jusqu'à butée et qu'a butée, j'aurais un courant proche d'un courant de court circuit (limité par une résistance de 2.2 Ohms).
 
Mon accumulateur faisant 7.2 volts, j'ai utilisé une alimentation stabilisée de 7.5 volts que j'ai branché directement sur mes différents moteurs tout en faisant les mesures de courant.

Pour le moteur de propulsion, j'ai mesuré le courant a vide, en charge (en freinant volontairement les roues) et le courant maximum (en bloquant les roues).
C'est ainsi que je découvre les valeurs suivantes:
Pour la direction:
  • Imax = 300 mA en butée
Pour la propulsion:
  • I_a_vide = 250 mA
  • I_en_charge = 1A à 1.5A en fonction de la charge
  • Imax (bloqué) = 2A
Le courant maximum apparait lorsque le moteur est bloqué (par exemple lors de la rencontre d'un mur)... et il atteint 2 Ampères.
Ce n'est pas rien!

Sur base de ces informations, j'ai sélectionné les circuits intégré suivants dans la liste "Quelques H Bridge Drivers" de l'article "Contrôle Moteur DC via L293D (H Bridge Driver, Circuit Intégré Pont H)":
  • un L293 pour la commande des directions (avec une commande indépendante pour chaque direction)
  • L298 supportant des courants plus important pour la commande de la propulsion.
Où est donc l'erreur?
Si elle ne vous paraît pas évidente, il faut se souvenir que dans une voiture téléguidée, les différents moteurs sont également contrôlés à l'aide de Pont-H.
Ceux-ci sont plus souvent constitués de Pont-H à transistors (car plus économiques).
La principale caractéristique d'un Pont-H, c'est qu'il induit une chute de tension égale à 2 fois Vce_sat (Voir informations relatives aux chutes de tensions dans l'article "Pont H à transistor pour contrôler un Moteur DC dans les deux sens").

En considérant une chute de tension VCE_sat de ~1 volt, la tension aux bornes des moteurs seraient alors de 7.2v - 2 * ~1v = ~ 5.2 volts.
C'est la raison pour laquelle la batterie fait 7.2 volts car cela permet d'anticiper la chute de tension du pont-H et de fournir une tension de fonctionnement suffisante pour les moteurs!
 
En somme, la tension de fonctionnement est plus faible que dans mes tests... et en conséquences les différents courants également plus faibles.

Pour éviter l'erreur
Une mesure de la tension aux bornes des moteurs (à vide) m'aurait permis de me rendre compte de mon erreur initiale.
En effet, je n'aurais pas du faire un test sous 7.5 volts mais plutôt à l'aide d'une alimentation en 5 volts ou en 6 volts.
Mais ne disposant pas de la télécommande, une telle mesure aurait été difficile à faire.
Par contre, les prochaines fois, je penserais à la règle d'or "anticiper la chute de tension du Pont-H"

De nouvelles mesures des courants
Ce que je n'ai pas dit, c'est que je me suis aperçu de mon erreur en faisant des mesures de courant sur mes montages du L293 et du L298.
Les courants ne correspondaient absolument pas! C'est en mesurant les tensions aux bornes de mes moteurs que j'ai compris l'énormité de l'erreur lors de mes premiers tests.

Le montage du L293E et L298HN seront abordés dans un futur article.

Commande de direction:
Mesure effectuée avec un L293, direction en butée.
  • Tension: 5.5 v 
  • Imax: 330mA
  • I à PWM=180/255: 150 mA
  • I à PWM=210/255: 180 mA
Une commande PWM pour la direction n'est cependant pas vraiment appropriée.
Car la direction prise par les roues de direction dépendra directement de la charge de l'accumulateur. Plus l'accu sera à plat et plus la commande de direction en PWM manquera d'efficacité!
A PWM = 180, les roues tournent légèrement, à PWM=210 les roues trounent à fond et à PWM=255 (100%), les roues tournent à fond (et brutalement).

Commande de propulsion:
La datasheet du L298HN mentionne un VCEsat typique de 1.8v.
En fonctionnement normal, le moteur est alimenté en 7.2-1.8=5.4 Volts.
VceSat augmente avec l'augmentation du courant. Pour I=1A, VceSat=3.2v et pour I=2A, VceSat=4.9v.
Ce qui peut sembler un désavantage, aura un effet bénéfique.
Cette augmentation de la chute de tension VceSat aura pour effet immédiat de diminuer le courant de charge du moteur (par exemple quand il est bloqué) et de trouver un nouveau point d'équilibre pour le couple VceSat & I où le courant sera moins important.
Au final, cet effet indésirable protègera le circuit de puissance.

Mesure effectuée avec un L298HN sous différentes conditions.
  • Fonctionnement à vide
    • Vmoteur (tension aux bornes du moteur) = 5.4~5.5v
    • I (courant de charge du moteur) =300mA
  • Fonctionnement en charge
    • Vmoteur=3v
    • I=800mA -> 1A
  • Moteur bloqué
    • Vmoteur = 1.5 v
    • I=1.1A (le courant est limité!)
Booster l'Arduino Car
A contrario, ce que mon erreur m'aura appris, c'est que les différents moteurs supportent assez bien une tension de fonctionnement de 7.5v.
Ainsi donc, si j'ai un jour besoin de booster un peu le véhicule, je pourrai toujours considérer faire des essais (et mesures) avec un accumulateur de 9 Volts.

Via le L298HN, la tension de fonctionnement du moteur serait alors de 9-1.8 = 7.2 volts.

vendredi 15 juillet 2011

Découverte du véhicule

Voici donc la voiture télécommandée avec laquelle je vais travailler.
Pour 3 Eur en prix d'achat, je trouve que ce n'est pas mal du tout.

Je vous présente donc un modèle Nikko

En quelques étapes, on découvre l'intérieur, avec un accu de 7.2v avec une capacité de 650 mA.
Si ce n'est pas énorme, c'est déjà bien assez pour faire quelques test :-)


Le chargeur est manquant mais avec un peu de recherche (et +/- 10 eur) j'ai trouvé toute l'information nécessaire pour le recharger.
Voir l'article "Accumulateurs NiCd - comment les choisir et les recharger" sur Arduino Notepad.

Continuons à explorer les entrailles de la bête...
On y découvre un train de direction à l'avant et à l'arrière :-)
Train de direction avant
Train de direction arrière + détail
J'ai enlevé la logique de commande.
Les différents raccordements vers les différents moteur sont bien visible.
Les selfs sont bien visibles sur le circuit de propulsion (ainsi qu'une partie des raccordements servant à rallonger les cables d'origines).

 
Le moteur de propulsion à des selfs
Mise en évidence des selfs

La présence de selfs n'est pas anodine.
En effet, une self à la propriété de devenir bloquante lorsqu'elle est traversée par un courant alternatif à haute fréquence.
Cela peut paraître totalement farfelu de prime abords car les moteurs sont alimentés en courant continu.
Il ne faut pas oublier qu'un moteur est constitué de bobines tournant dans un champ magnétique... il y a donc un rotor équipé d'un collecteur et de balais (voir article Collecteur Tournant sur Wikipedia).
Lorsque le moteur tourne, le circuit électrique est interrompu brusquement pour en reconstitué un autre (au fur et a mesure que le rotor tourne). Cela permet d'assurer la continuité de la rotation.
Mais ces brusque interruptions de circuit génère des parasites et des effets de selfs.

Un parasite peu être comparer a une impulsion très courte à très haute fréquence. Très énergétique, ces parasites produisent des surtensions qui peuvent endommager les circuits de puissances.
S'il y a une self sur le circuit, elle deviendra bloquante (effet bouchon) pour ces hautes fréquences et atténuera donc le parasite.

Le but recherché est de protéger le circuit de puissance généralement constitué d'un pont-H. Les pont-H sont constitués de transistors qui n'apprécie généralement pas les surtensions.


Les moteurs ont 3 fils
Selon toute logique seul deux fils sont nécessaires pour commander un moteur à courant continu.
C'est d'ailleurs ce que confirme la documentation de wikipedia (voir ci-dessous)
Source: wikipedia
Pourtant, si l'on regarde le raccordements des moteurs de la voiture télécommandée, il y a clairement 3 fils par moteur... mais pourquoi donc?

Mise en évidence des 3 fils
de commande d'un moteur
En démontant le bloc moteur, je découvre le schéma de raccordement suivant:


Il s'agit d'un circuit de déparasitage (encore une fois) constitué de 3 capacités en céramique.

Déparasitage moteur
Une capacité est directement utilisée entre les deux pôles du moteur.
Cela permet d'absorber les parasites émis par le moteur (entre fil jaune et fil vert)... ce qui permet de protéger le pont H en absorbant les surtensions et effets transitoires du moteur.

Déparasitage par rapport à la masse
Comme toute l'électronique est raccordée à VCC et GND (la masse).
Si l'on ne dispose que d'une seule alimentation pour la motorisation et l'électronique de commande, alors, ce VCC est aussi utilisé pour alimenter le moteur (soit via le fil jaune, soit via le fil vert en fonction du sens de rotation souhaité).
Dans ce cas, il convient d'être prévoyant et d'également déparasité les bornes du moteur par rapport à la masse afin d'éviter (autant que possible) le retour de parasites sur l'alimentation VCC.

La résistance de 2.2 Ohms
Il s'agit ici du moteur commandant la direction avant du véhicule.
Cette résistance sert a limiter la courant de court-circuit, celui qui apparait lorsque le moteur est bloqué dans son mouvement.
C'est le cas lorsque la direction arrive à butée lorsque l'on tourne soit à gauche, soit à droite. Dans ce cas, Rmoteur = ~0 Ohms.

Ainsi donc, dans la pire des situations, le courant maximum sera de 5volts /  2.2 Ohms, soit 2.7 ampères.

Dans les faits, je n'ai pas relevé un courant aussi énorme... mais cela est dût à l'utilisation de pont-H pour commander la direction.
Si le courant augmente dans le pont-H, la chute de tension causée par le pont (Vce) augmente également, ce qui a pour effet de limiter le courant de court-circuit.
En effet, si la tension chute aux bornes du moteur, le courant de court-circuit sera moins important.

Au moins, cette résistance assure que le pont-H ne soit pas en court-circuit franc lorsque le moteur est bloqué (parce que cela, le pont-H n'apprécierait pas du tout!).

lundi 11 juillet 2011

Arduino Car est né

Voila, après pas mal de découverte concernant Arduino sur mon blog Arduino Notepad, j'ai décidé de pousser l'aventure un peu plus loin avec un projet spécifique.

Pour ce projet spécifique, j'ai décidé de lancer un nouveau blog pour ne pas trop mélanger les articles dédiés à ce projet d'autres articles d'intérêt général plutôt centré sur la plateforme Arduino.

Qu'est ce donc que le projet Arduino Car:
Et bien, avant de me lancer dans l'achat de moteurs robotiques assez couteux, je me suis dit qu'il serait intéressant de concevoir un petit véhicule autonome basé sur une voiture téléguidée.
Ces véhicules disposent déjà de beaucoup d'éléments intéressants pour un tel projet d'automatisation.

En effet, sur une voiture téléguidée, l'on retrouve les éléments suivants:
  • Une gabarit prévus pour un véhicule motorisé sur lequel viennent se placer les différents éléments mécaniques et électronique
  • Un bloc moteur pour commander l'avance et le recul.
  • Un bloc moteur et une mécanique de commande de direction.
  • Un accumulateur (généralement d'assez piètre facture mais c'est déjà pas si mal).
  • Une électronique de commande (que l'on va dégommer vite fait).
  • Une télécommande (qui ne servira pas dans notre cas).
Ou trouver le matériel de base
Pour commencer, il faut un Arduino (voire un kit de développement de base pour se faire les dents dessus) et un véhicule téléguidé.

Pour trouver le véhicule téléguider:
  • Il est possible de s'en acheter un neuf... mais c'est un peu cher pour le désosser!
  • Il est toujours possible d'aller faire une attaque punitive dans les jouet de son bambin (s'il en a une) mais ce n'est pas très sympa.
  • En dernier ressort, il reste les brocantes et garage sales... j'y ai trouvé mon bonheur en deux semaines pour la modique somme de 3 Euro :-) .
Pour trouver un Arduino:
Pour le reste du matériel:
En Belgique, il y a toujours Antratek (détecteurs), Farnell et Cotubex (pour la petite électronique) et surtout, les PC balancés au parc à container (une mine d'or en cable, connecteurs et visserie!).
Pour les détails sur le matériel nécessaire, nous en parlerons en cours de route