Cela fait maintenant quelques semaines que j’ai repris la fabrication du robot, et après une grosse partie de mécanique enfin achevée, l’électronique avait besoin de progresser pour pouvoir faire rouler le robot et poursuivre son développement.

Bon, la commande de la vitesse et du sens de rotation des moteurs du robot est plus complexe qu’elle peut y paraitre au premier abord et il ne s’agit pas seulement de brancher les moteurs sur un gros potentiomètre avec un joli système d’inversion de polarité pour changer la direction!

Imaginé et conçu en détail depuis belle lurette,il ne manquait plus que la phase de réalisation et d’assemblage pour chacun des éléments suivants (du moteur vers la commande):
1 – Carte de puissance (Pont en H – L298)
2 – Carte de contrôle (Microcontroleur – PIC 18F2431)
3 – Contrôle informatique de la carte de contrôle (haha …)

1 – Carte de puissance
Le courant de puissance des moteurs passe par un pont en H, circuit classique pour commander de manière simple et efficace un moteur à courant continu. Cette carte reçoit en entrée les signaux logiques (5V) de gestion du sens de rotation, et le signal PWM pour varier la puissance.

Carte de puissance en cours de test, connectée à la carte de contrôle des moteurs (en haut, fils blancs et jaunes) et à la partie puissance (vers le bas, alimentation a droite, moteur de test à gauche).

2 – Carte de contrôle

J’avais déjà pas mal travaillé sur la carte de contrôle moteur, celle ci ayant même eu le privilège d’être assemblée sur une plaque de pvc avec le programmateur de PIC, la carte d’interface USB/I²C Diolan, et un petit régulateur 5 volts. Cette implantation étant très pratique pour travailler et tester le code envoyé au PIC, tout est resté comme ça pour les phases de test.

La carte dans sa version actuelle sert simplement de « passerelle » pour les ordres venant du PC en direction de la carte de puissance, et ceux qui pensaient y trouver un contrôleur PID seront – pour l’instant – déçus. Le PIC est programmé en C (MCC18) dans l’IDE MaLab de Microchip.
Pour la partie du code qui s’occupe de la gestion des moteurs, la carte réagis à 6 commandes en provenance du bus I2C. Ces identifiants de commandes sont déclarés dans un ficher d’entête sous forme de constantes, communes au projet MCC18 pour le PIC et à l’interface développée en C++ côté informatique.

Voici les déclarations de commandes avec le code en hexadécimal qui leur est attribué:

#define I2C_SET_PWM1 0x10 //Valeur de la sortie PWM pour le moteur 1 (0-1023)
#define I2C_SET_SENS1 0x11 //Direction de rotation pour le moteur 1 (0-1)
#define I2C_SET_PWM2 0x18 //Valeur de la sortie PWM pour le moteur 2 (0-1023)
#define I2C_SET_SENS2 0x12 //Direction de rotation pour le moteur 2 (0-1)
#define I2C_SET_PWMS 0x20 //Valeur de la sortie PWM pour les deux moteurs (0-1023 / 0-1023)
#define I2C_SET_SENSS 0x21 //Direction de rotation pour pour les deux moteurs (0-1 / 0-1)

3 – Contrôle informatique

Le programme qui commande la carte moteur est développée en C++ sous CodeBlocks à l’aide des librairies graphiques wxWidget, associés au driver de la carte U2C de Diolan compilé sous forme de librairie partagée. Cette interface permet de communiquer avec les différentes cartes à base de PIC via le bus I²C (contrôle moteur, alimentation principale et carte d’interface générale), d’y envoyer des commandes et de lire des valeurs. Les fonctions développées dans cette interface seront par la suite regroupées au sein du driver Player (cf ce post décrivant le système : Contrôle informatique : Player, Stage et compagnie)

Interface de contrôle sous Linux

Une vidéo est en cours de préparation ou je présenterais une démo d’un moteur, piloté grâce à toutes cette chaine de commande.

A très bientôt pour la suite !

Il y a quelques semaines (mois…?), j’ai passé un peu de temps sur la fabrication de la carte d’alimentation du robot.

Cette carte ayant été conçue et décrite il y a déjà un bon moment, je met les 2 liens vers les articles correspondants mais je ne vais pas me ré-étendre sur les fonctionnalités de la carte :
Ici : Carte d’alimentation
et là : Carte d’alimentation – Suite

Le PBC avait été gravé en même temps que toutes les autres cartes, il y a plus d’un an, et attendait sagement de recevoir ses composants depuis tout ce temps.

Voici en photos, les étapes de la réalisation !!

Mise en place des straps

La première étape est la mise en place des – trop nombreux – straps de la carte.

Composants fins

On soude ensuite les composants sur la carte, généralement du plus petit au plus gros, ou du plus fin au plus épais comme vous préférez

Suite de la mise en place des composants…

La carte terminée

Voici la carte terminée. Le connecteur marqué « INT » est celui de l’interrupteur général du robot.

Autre vue de la carte

Sur cette dernière vue, vous pouvez voir de gauche à droite :

- le connecteurs I2C (communication avec la carte mère)
- le connecteur pour la programmation in-situ du microcontrôleur (ICSP)
- la masse générale ( – )
- l’alimentation externe pour l’alimentation en station (EXT)
- l’entrée du chargeur de batterie (BATT)
- les 2 bornes de la batterie (BATT + et -)

J’ai effectué quelques tests sur cette carte et écrit une ébauche de programme pour le PIC 16F819. Ma première impressions concernant la programmation est que je me suis planté en choisissant un pic de cette famille car du coup, je suis obligé de jongle entre 2 compilateurs (le reste de mes micro-contrôleurs sont des 18F).
Pour ce qui est des fonctionnalités principales, la conversion analogique/numérique des 3 tensions à l’air de se passer pas trop mal malgré quelques valeurs bizares et la communication 1²C fonctionne aussi à peu près.

Je ne détaillerais pas le code aujourd’hui mais comme tout le reste, vous pouvez le trouver sur le repository SVN de mon projet Sourceforge

Dans les jours qui viennent, j’espère trouver le temps pour terminer le couplage entre les moteurs et les roues de la base roulante du robot. Une fois que cette première partie mécanique sera terminée, je m’attaquerais à la carte de puissance des moteurs.

A bientôt !

La carte de contrôle des moteurs qui me posait tant de problèmes est enfin domptée, il ne me reste que quelques résistances cms de pull up à souder pour qu’elle soit totalement fonctionnelle.

Comme elle n’a pas encore été décrites dans ces colonnes, voici un topo sur son cas:

Cette carte très simple est architecturée autour d’un PIC 18F2431 de Microchip. Vous trouverez la datasheet de ce composant sur sa page produit mais voici quelques unes des caractéristiques qui m’ont fait le choisir:
- Un module SSP (port de communication I²C)
- Jusqu’à 6 sorties PWM (Pulse Width Modulation), pratiques pour le contrôle des moteurs du robot (4 utilisées)
- Un module « MotionFeedback » qui peut se charger du décodage d’un encodeur en quadrature
- Pas mal d’autres IO qui compléteront les fonctionnalités de la carte en assurant par exemple le comptage du 2ème décodeur, etc….

Grâce à ce petit microcontroleur de 28 broches, la carte remplira donc les fonctions suivantes:
- Contrôle de la distance effectuée, de la vitesse et du sens de rotation des 2 moteurs de propulsion grâce aux 2 encodeurs incrémentiels
- Stockage et mise à disposition de ces informations via le bus I²C
- Asservissement en vitesse (position ..?) des moteurs en fonction des commandes de position reçue.
- Communication avec le PC maître, via la carte U2C-12 de Diolan

Voici le schéma électronique de la carte:Dans un prochain post, je montrerais la réalisation de la carte et les premiers pas de son utilisation.

A bientôt !

Hier après midi j’ai décidé que de passer ne serai-ce que 5 minutes à sortir 4 cartes différentes, tout brancher etc… pour pouvoir expérimenter et développer sur ma carte de contrôle moteurs ne pouvais plus durer !

J’ai très rapidement fabriqué une platine en PVC pour fixer tout ce bazar et n’avoir ainsi qu’à brancher mes deux prises USB et la batterie pour pouvoir faire joujou.

Voici quelques photos du bidule:

Préparation de la plaque (mesures ultra-précises des emplacements de fixation par la technique dite du crayon-dans-les-trous-des-cartes)

Voici la plate-forme terminée avec toutes les cartes fixées dessus et les différents branchements faits.

Détail de la carte en cours d’expérimentation.

Je viens de me rendre compte que je n’avais pas encore décrit cette carte ni publié les schémas et typons ailleurs que sur sourceforge… cet oubli sera réparé dans les prochains jours si je trouve un peu de temps.

A bientôt!

Il existe plusieurs familles de microcontroleurs et je ne vais pas tenter de les citer ni de les comparer. Si vous voulez participer au débat (enflammé), rendez-vous dans la section « Robotics » du forum de planète science. Les adeptes des différentes familles s’y entretuent à coup d’arguments plus ou moins crédibles, certains s’accusent d’avoir des parts dans les différents fondeurs, bref que du bonheur : Planète Science

J’en profite pour remercier tout les participants de ce forum très vivant pour leurs conseils et tout et tout. C’est une vraie mine d’informations sur laquelle je passe tout les jours et ou j’ai trouvé beaucoup de solutions aux problèmes qui m’empêchaient de dormir. (En plus le président de l’assoc est un ami des parents de ma femme… le monde est petit )

Bon je me lance, j’ai choisi de travailler avec des microcontroleurs de Microchip, les fameux PIC.
Vous vous en doutiez ? rhooo tout de suite… j’ai hésité quelques jours à utiliser des AVR mais la gratuité des logiciels, la simplicité de l’architecture et la communauté des Pic ont finis de me convaincre.
Un plus très appréciable pour les radins comme moi, c’est que Microchip a une politique très interessante pour les étudiant/bidouilleurs/profiteurs: les Samples !!
Grace à une simple inscription sur leur site, ils envoient gratos des échantillons de leurs microcontroleurs, frais de ports offerts, et ceci jusqu’à une commande de 12 unités tout les 2 mois. Pas de quoi ouvrir une usine de production en chine mais pour tester et faire joujou avec un robot, c’est plus que suffisant.

Voici la liste des modèles que j’ai choisis pour les différentes applications que j’envisage:

• PIC16F88 (1ère commande, surement pas utilisés)
  
• PIC16F627A (idem)
• PIC16F819 (carte d’alimentation)
• PIC18F2431
• PIC18F4520
• PIC18F2550

Avec ça, j’ai de quoi faire tout ce dont j’ai besoin et en particulier une carte de commande pour mes moteurs (PWM hardware) et une carte de décodage pour les encodeurs rotatifs.
Tout ces Pics supportent le protocole I2C et seront donc connectés à la carte mère via la petite carte Diolan que je vous ai présentée dans un autre post.

C’est tout fébrile qu’après 10 ans d’abstinence je me suis recollé devant une plaquette à essai, que j’ai branché quelques résistances un condos et 2 leds, et que j’ai vu mes 2 leds clignoter, une larme à l’oeil tellement c’était beau !! (Lise perplexe: « Si c’était pour faire ça, t’aurai pu acheter un interrupteur aussi… » no comment).

En une soirée, j’ai bidouillé mon 16F819 dans tout les sens et j’ai réussi à intégrer 2 commandes ON et OFF en I2C qui allument et éteignent la led ! ouaiiiiii !!!

Je mettrai à disposition les codes sources de mes différentes applis quand elles seront fonctionnelles, ce blog n’ayant pas vocation à devenir un cours de PIC. (Bigonoff s’en charge très bien)

A bientôt !