1 - Le microcontrôleur (AVR)

Le microcontrôleur est le composant principal de la carte. Pour être schématique c'est le cerveau de la carte, pour être plus précis c'est lui qui fait les opérations arithmétiques et logiques. (Voir Wikipedia pour plus de détails).

Nous avons choisi un ATmega88 de la famille des AVR. Par la suite, nous parlerons indistinctement du "microcontôleur", de "l'AVR" ou de "l'ATmega88". Par abus de langage, il se pourrait aussi que nous l'appelions "micrprocesseur" même si un mivrocontrôleur est bien plus qu'un microprocesseur.

Dans la suite, vous aurez régulièrement besoin de consulter la datasheet de l'ATmega88 , elle se trouve ici.

Placement de l'AVR

Tout d'abord, dans la barre de menu, cliquez sur Place -> Device ou sur le petit icône Device.

Dans la nouvelle fenêtre :

Choisissez la partition IC.

Puis dans choisir ATMEGA88 dans la colonne Part Name

Enfin, cliquez sur "place" pour placer le composant, placez le, puis appuyez sur Echap.

2 - Alimentation

Nous allons maintenant nous occuper de l'alimentation qui est une partie importante d'un PCB . En effet, il faut que l'alimentation soit la plus stable possible afin de ne pas perturber le fonctionnement du microcontrôleur et des autres composants électroniques (comme les capteurs). 

Comme il y a beaucoup d'éléments pour faire une alimentation correcte, nous allons la mettre dans une nouvelle page du schématique. Cette séparation est purement virtuelle puisque sur la future carte tous les composants seront ensemble. Pour ajouter une nouvelle page, cliquez sur (+) en bas de la page.

Ajoutez-y les composants suivants :

• Dans la partition IC : L4931CD50(le régulateur).
• Dans la partition Capacitor : prenez le CAPCERAM1210 de capacité 10µF (un condensateur), et placez-en 2.
• Dans la partition Capacitor : prenez le CAPCERAM0805 de capacité 100nF et placez-en aussi 2.
• Dans la partition Resistors : prenez la RES_0603_E24 de 220ohms et placez-en une.
• Dans la partition Diodes : prenez une LED_RED_0805 et une schotky MBRS130LT3
• Dans les connecteurs prenez 2 PAD

En plus des "vrais" composants, on ajoute des symboles qui ne représentent rien de physique mais montre visuellement à quoi sont reliés les fils (masse ou alimentation) :

place > symbol > supply ground > un P_VCC, cinq GND_SMALL, et un VCC

Renommez le P_VCC en VCC_in.

Une fois les composants ajoutés, agencez-les de la manière suivante :

(Ne vous occupez pas du numéro à coté de la lettre dans les noms des composants ça se fera tout seul plus tard)

Dans la barre de menu, allez dans Place, puis Wire pour pouvoir dessiner des fils. Pour obtenir le schemas final.

Reliez les composants comme ceci :

Nous avons ainsi une alimentation stabilisée sur le fil qui s'appelle VCC. VCC_IN représente quant à lui l'entrée de l'alimentation. En pratique on y a mis un PAD pour pouvoir souder le fil qui viendra de la pile.

Maintenant sachez que nous avons une alimentation différente pour les composants logiques que celle pour les moteurs. En effet, quand les moteurs vont se mettre en rouote subitement, il y aura une chute de tension sur le fil qui alimente les moteurs or on ne peut pas se permettre que le microcontrôleur subisse cette chute de tension car il pourrait rebooter inopinément (l'ATmega88 comme beaucoup de microcontroleur possède un système de vérification de l'alimentation : si celle-ci chute un peu trop, le microcontroleur se coupe. Il se rallume quand l'alimentation redépasse un certain seuil).

Le VCC que nous avons eu en sortie du cricuit que vous venez faire va nous servir à alimenter l'AVR et d'autres composant logiques. Nous venons donc de réaliser l'alimentation "logique". Nous allons maintenant faire la partie pour alimenter le moteur et autres composants qui nécessite de la puissance mais sont moins exigeants sur la stabilité. C'est ce qu'on appelle l'alimentation "de puissance".

Procédez comme précédemment pour obtenir ceci sur la même page :

Attention !! ce n'est pas le même régulateur !!! Notez aussi que c'est la même masse par contre ce n'est pas les mêmes fils pour l'alimentation (P_VCC et P_VCC_in)

Le régulateur et les condos de découplage servent à avoir une alimentation la plus stable possible.

Maintenant repassez à la page 1 du schématique pour relier l'AVR à l'alimentation de la manière suivante (vous aurez besoin d'un symbole VCC, et d'un GND) :

Pour que l'alimentation soit encore plus stable pour l'AVR, on ajoute aussi des condensateurs de découplage autour de celui-ci : 3 capas de 100nF (CAPCERAM0805) pour obtenir le schema suivant :

3 - l'Horloge

3. L'horloge :

Place device quartz : placer un "quartz" à 20MHz.

Et prenez aussi deux capacités à 15pF. Les capacités, branchées près du quartz servent à fabriquer un circuit oscillant, pour fournir l'horloge à l'AVR. Pour connaitre, la valeur de ces capacités, il faut se reporter à la datasheet de l'AVR à la section horloge.

Il vous faudra aussi 2 symboles GND
Reliez-les de cette manière à la patte XTAL1 et XTAL2 de l'AVR :

4 - Le port série :

Pour communiquer avec un ordinateur (programmation, debug, ou autre) la solution la plus simple en robotique reste le port série. On en trouve sur quasiment tous les ordinateurs fixes et il existe des adaptateurs de série/USB pour les ordinateurs portables. Du côté de la carte, il faut prévoir un connecteur sur lequel nous brancherons le cable qui arrive de l'ordinateur. Au club, nous avons un connecteur standard qui s'appelle Micromatch (connecteur rouge carré) mais vous pouvez mettre un autre connecteur ou même des pads pour souder directement vos fils (moins bonne solution).

Nous verrons au moment de programmer le microcontrôleur comment se servir de la liaison série.

Placez le connecteur : dans la Partition "Connectors", choisissez un MICROMATCH de référence 70-0014.

Placez aussi une résistance de 10Kohms (RES_0603_E96), un symbole VCC et un GND.

Et reliez l'ensemble aux pattes RX et TX de l'AVR de la façon suivante :

La résistance sur le fil RX sert à maintenir le fil à la tension VCC quand il n'y a rien qui passe sur le fil. On évite ainsi de repérer des 0 aléatoirement. Si par contre, le fil passe à l'état bas, il y aura un courant qui passe dans la résistance, c'est pourquoi la résistance est grande : l'intensité qui traverse sera faible.

5 - le bouton Reset

Pour programmer le microcontroleur, il faudra le reseter. Dans les phases de développement, on a donc besoin de le reseter très souvent. On prévoit donc dès maintenant un bouton pour reseter l'ATmega88 sur la carte ce qui évitera de devoir débrancher l'alimentation puis de la rebrancher.

Le bouton de reset est un simple bouton poussoir qui mettra la patte de reset du micrcontrôleur à la masse et ainsi le resetera. On met bien une résistance de "pull-up" qui fait que la patte reste bien à la tension VCC quand le bouton n'est pas appuyé. Si on ne l'avait pas mis, on aurait pu avoir des reset intempestifs suivant la tension flottante autour de cette patte.

Placez 1 résistances de 10Kohms (RES_0603_E96), un SWITCH B3S (dans la partition "Misc"), un symbole VCC et un GND, et placez-les sur la patte "RESET"  de l'AVR comme ceci :

6 - le capteur de distance

Comme nous l'avions prévu dans les spécifications, nous aurons un capteur de distance sur la carte. Ce capteur sera analogique, c'est-à-dire qu'il donnera l'information de distance sous la forme d'une tension analogique entre 0 et VCC . Pour comprendre cette information analogique, il faut brancher le fil sur une patte qui possède un convertisseur analogique/numérique (en anglais ADC pour Analog Digital Converter). C'est pourquoi on utilisera la patte ADC7 du microcontrôleur.

Sur le schématique, tirez un fil sur la patte ADC7.

Place -> Symbol -> Renvois -> INTERPAGE, lier l'interpage (pour avoir la suite du fil ailleurs sur la page), puis faire un clic droit sur le fil, et dans Properties, lui donner un nom :

Placez un micromatch (car le capteur sera reliéà un fil au bout duquel on aura mis un micromatch) et reliez le à l'alimentation comme précédemment, et sur le port 3 du micromatch, faites de même que pour la patte ADC7 de l'AVR, en lui donnant le même nom, ce qui donne ceci :

7 - le port SPI

On ajoute maintenant un connecteur sur les fils qui sert au port SPI. Ainsi, si on a 2 cartes qui possèdent ce genre de connecteurs, il suffira de faire un cable entre les 2 et les 2 cartes pourront dialoguer en SPI. Pour l'instant, on s'occupe simplement de mettre le connecteur.

Ajoutez un micromatch et reliez-le aux pattes SCK, MISO, MOSI, ce qui donne :

8 - Autres Entrées/Sorties

De la même manière qu'on avait fait pour le sharp, nous allons ajouter des interfaces vers les capteurs couleurs, les leds, le bus I2C ...

Ajouter à l'AVR de la même manière que le sharp des liens internes à la page :

Pour les capteurs de couleurs :

Pour le bus I2C (uniquement 2 fils sca et sdl avec des pull-up) et les LED qui seront bien pratiques pour le debugguage :

Ajoutez enfin les 2 dernières E/S qui sont simplement des fils reliés à un micromatch qui pourront servir pour diverses utilisations (LEDs supplémentaires, boutons poussoirs, bumpers, etc. ):

(ne vous préoccupez pas encore des noms M1*** ou M2***, ils viennent juste après)

9 - Ponts en H

Comme nous l'avons vu à la page Alimentation, on alimente les moteurs séparément des autres composants. Toutefois les moteurs sont quand même commandés par le micrcontrôleur. Pour relier le microcontrôleur aux moteurs on utilise donc des ponts en H. Vous trouverez toutes les explications sur le fonctionnement des ponts en H sur la page dédiée ou sur Wikipedia.

Rajoutez une page au schéma électrique, puis rajouter des transistors (DUAL_NPMOS) et tout ce qu'il faut pour obtenir ceci (les connecteurs << sont des connecteurs de page à page, ils permettent d'avoir le début du fil sur une page et la fin sur une autre page) :

Les PAD J8 et J10 sont les endroits où nous allons brancher les fils qui vont au moteur et les fils M1_IN1 et M1_IN2 sont les fils qui seront reliés au microcontrôleur pour la commande du moteur. P_VCC représente quant à lui le fil qui vient de l'alimentation de puissance.

Refaire la même chose pour en avoir 2 car nous aurons 2 moteurs sur notre robot :)

Vous aurez remarqué les liens externes vers la première page, il faut donc mettre les fils de même nom relié au microcontrôleur dans la première page :

Vous avez maintenant réalisé toute la partie de design des schémas électriques. A ce stade, vous savez exactement quels sont les composants électroniques utilisés sur la carte et comment ils sont branchés entre eux. 

Attention au moment de commander les composants, il faut aussi penser aux composants qui sont reliés par un connecteur qui n'apparaissent pas sur les schémas, par exemple le capteur de distance, les capteurs de couleurs, les boutons poussoirs ou bumpers...

1 - Démarrage Expedition PCB

Maintenant que le schéma électrique est fait, nous allons passer au placement et au routage.

Pour passer sur le logiciel de placement et routage, il faut compiler le schéma que vous avez fait. Pour ceci, tools -> other utilities puis choisissez le packager, puis apply. Choisissez full compile puis apply encore. Là vous ne devez pas avoir d'erreurs.

Si vous avez malgré tout une erreur, je ne peux que vous motiver à trouver par vous même avec les messages d'erreur imprimés. Si vous êtes membres du club, n'hésitez à poster sur la mailing list et sinon, vous pouvez googler ou envoyer une demande d'aide à Mentor Graphics. Si c'est une erreur de ce tutorial qui est à l'origine de l'erreur de compilation, nous serons ravis de la corriger, il suffit d'envoyer un mail à contact@telecom-robotics.fr .

Une fois que la compilation est terminée, faites clic droit sur la feuille et faites set instance pour mettre des noms aux composants. Ensuite sur la barre de gauche choisissez en bas "integration view", clic droit sur tutorial.pcb -> open : et là normalement, expedition PCB s'ouvre. Vous pouvez également ouvrir Expedition PCB puis faire Fichier/ouvrir et choisir tutorial.pcb qui se trouve dans le dossier Tutorial.

2 - Placement AVR

Nous allons aborder dans cette page le placement des composants sur la carte.

Avant de commencer, faites Setup -> project integration, vous devez obtenir ceci :

Cliquez sur "Forward Annotate", ceci pour importer notre schéma sur le PCB.

Place -> place parts and cells et appuyer sur la double flèche vers le bas (include all). On a alors la liste de tous les composants qui sont dans le schématique comme ceci :

On place en premier l'AVR, pour ceci choisir l'AVR dans la liste (vous pourrez le reconnaitre car c'est un cicuit intégré donc symbole U et c'est le seul composant avec 32 pattes).
Ensuite, il faut essayer de placer les différents composants par groupe. On met d'abord les 4 ponts en H. Si vous ne savez pas quels composants sont les ponts en H, n'hésitez pas à refaire un tour dans le schématic.

Pour une meilleure lisibilité du PCB (Printed Circuit Board pour ceux que ça intéresse :), vous pouvez choisir de n'afficher qu'une partie des informations pour chaque composant. Pour cela vous pouvez ouvrir le display control (View / Display Control) et choisir vous-même ce que vous voulez voir afficher. Je vous conseille d'utiliser les modèles prédéfinis et de choisir "Loc : Placement" en bas du display control. Vous avez normalement la même option dans les boutons rapides en haut. Là où il est marqué "Display Schemes" vous pouvez directement choisir "Loc: Placement".

On met ensuite les micromatch. Tout au long du placement, vous pouvez utilisez les touches "F1", "F2", etc... il est indiqué en bas de l'écran leur fonction. Appuyez par exemple sur "F3" pour faire pivoter un composant quand il est sélectionné mais pas encore placé.

Au bout de 5 mn vous devez obtenir ceci :

3 - placement alimentation

On continue de placer les composants par groupe. On s'intéresse maintenant à la partie alimentation. On va essayer de regrouper l'alimentation logique d'un côté et l'alimentation de puissance de l'autre. N'hésitez pas à bien serrer les composants lorsque vous savez qu'ils sont liés et qu'ils seront simples à router (CAD que tracer les fils qui vont les relier sera facile).

Pour cela, repérez sur le schéma électrique quels sont les composants qui font partie de l'alimentation logique d'abord et placez-les dans un coin. Vous devriez obtenir quelque chose comme ceci:

 Ensuite, renouvelez l'opération pour l'alimentation de puissance. et vous obtenez quelque chose d'approchant à ceci: (si vous n'avez pas autant serrer les composants, ce n'est pas très grave, il sera toujours temps de les serrer tout à l'heure)

4 - placement quartz, bouton poussoir et pads

Avant de placer les derniers "gros" composants, c'est-à-dire le quartz, le switch et les pads, on peut se rendre compte que si on tourne l'AVR, il sera plus adapté. On le tourne en resant cliqué dessus et en appuyant sur F3. Vous devriez avoir quelque chose comme ça:

Le quartz sert à fournir l'horloge à l'AVR. Il faut que le signal de l'horloge soit le plus précis possible et donc pour éviter les interférences, on essaye de placer le quartz tout près de l'AVR. Le bouton poussoir peut être placer n'importe où sur la carte, il sert simplement à rebooter plus facilement l'AVR. On va quand même le mettre du côté où est la pin du reset sur l'AVR.

Quant aux pads, ce sont juste des bouts de métal sur lesquels on viendra souder directement un fil électrique. On en a déjà mis pour l'alimentation (pour souder les fils qui viennent des piles) et il en faut encore pour brancher les moteurs.

On va donc mettre le quartz près de l'AVR ainsi que les 2 capacités qui servent à le faire osciller. Pour connaitre la valeur des capacités qu'il faut mettre avec le quartz, on peut le lire dans la datasheet de l'AVR. Vous devriez obtenir un truc à peu près dans ce genre:

Mettez maintenant le bouton poussoir et les pads pour obtenir quelque chose comme ça:

5 - placement petits composants

Il reste donc à faire le placement des derniers petits composants. Parmi ces composants, il en reste seulement 2 d'importants, ce sont les capacités de découplage. En gros, ces capacités permettent à l'AVR d'avoir une alimentation stable. Il est très important de les mettre juste à côté de l'AVR, quitte à repousser un peu le reste.

Ensuite les diodes sont à mettre où vous voulez sur la carte sachant qu'elles seront amenées à bouger lors du routage. Il faut mettre les résistances qui vont avec tout près pour une question pratique et puis c'est plus joli sur la carte :) Ne faites donc pas trop attention à vous les mettez, essayez quand même de ne pas trop croiser les fils.

Enfin, les résistances qui restent sont toutes des pull-ups ou des pulls-down, ce sont des résistances qui servent à maintenir la ligne à 1 ou à 0 si personne n'y touche. Il faut essayer de les mettre près du composant auquel elles sont censées "appartenir". Ceci n'est pas indispensable, mais vous verrez que ce sera plus pratique lors du routage.

Pour les capacités de découplage vous devriez avoir quelque chose comme ceci:

Et au final:

6 - premier routage

On peut maintenant passer au routage de la carte, c'est-à-dire relier les composants qu'on a placé sur la carte par des fils de cuivre. C'est une des parties les plus délicates en électronique. En effet, il y a énormément de paramètres à prendre en compte comma par exemple l'influence d'une piste de cuivre sur ses voisines, le temps de parcours du signal dans les pistes et encore bien d'autres. Cependant, dans notre cas, nous nous pouvons oublier quasiment toutes ces contraintes puisqu'elles sont à prendre en compte suelement lorsque la fréquence d'horloge est élevée. Nous n'avons que 20 MHz ce qui est largement en dessous de la zone d'"inquiétude" :)

Par contre, notre grosse difficulté c'est que nous n'avons normalement qu'une couche, il faudrait donc que tous les fils de cuivre tiennent sur une seule face sans se croiser. Si vraiment, on se rend compte qu'on ne peut pas y arriver (2 fils sont obligés de se croiser à un endroit) on pourra éventuellement utiliser une deuxième couche. Il y aura alors un des fils qui passera sous la carte.

Commençons tout d'abord par un premier routage simple, on va ne relier que les composants qui sont côte à côte et dont le routage est simple. Pour passer en mode routage dans Expedition PCB, il faut cliquer sur l'icone "Route mode" qui est juste à côté de l'icone "Place mode", c'est un icone rouge avec 2 traits en diagonal et 2 points.

Quand vous cliquez maintenant sur une patte d'un composant, le fil auquel elle est relié et toutes les autres pattes connectés sont en surbrillance. L'objectif est de tracer un fil de cuivre entre toutes ces pattes. Si vous cliquez sur une patte reliée à VCC ou GND (la masse) vous verrez qu'il y a du boulot, ce sont les 2 fils les plus difficiles à router, il ne faut donc pas commencer par ceus-là.

Pour routez, cliquez une fois sur une patte, puis faites un drag&drop pour tracer le fil. Vous pouvez le lacher au milieu pour faire un premier trait puis recommencer. Si vous n'êtes pas content du fil tracé, vous pouvez soit le supprimez avec la touche suppr. Pour supprimer complètement le fil, faites un double clic (ce qui selectionne tout le fil) puis suppr. Vous pouvez aussi faire Route/Modify Corners (il y a aussi un icone en haut) dans ce mode, vous pouvez bougez les coins comme vous le souhaitez. Ce mode est assez pratique pour faire de jolis fils...

Commencez par router les 2 parties d'alimenttation, les pull-ups et les pull-downs, les pads, les capacités de découplage. Enfin tous les "petits" fils.

Après l'alimentation vous avez normalement quelque chose qui ressemble à ça:

Encore une fois, ne vous inquiétez pas si tous les fils ne sont pas exactement à la même place. Cependant, il faut quand même que vos fils ne fassent pas de chemins compliqués pour l'instant. Préférez donc retourner un petit composant en repassant dans le "place mode" plutot que de faire un fil qui fait tout le tour. Ensuite vous avez un truc comme ça:

Maintenant va commencer la partie un peu plus difficile.

7 - routage du microprocesseur

Il faut maintenant router l'AVR. Les instructions sont simples: vous devez reliez toutes les pattes de l'AVR sauf l'alimentation et la masse, même si vous pouvez y réfléchir dès maintenant.

Quand ça ne va vraiment pas avec un composant, que vous vous êtes vraiment creusé la tête (c'est-à-dire que vous avez vraiment essayé 10 minutes sans résultat même en tournant le composant ou en bougeant ses voisins), il peut rester la solution de changer les pins du composant. Attention, il faut un prérequis: c'est que les pins en question sont interchangeables. Sur la plupart des composant vous devez mettre l'alimentation à certains endroits ou relier spécifiquement une pin du composant à une pin de l'AVR.

Nous n'avons sur la carte que quelques contraintes:

• le sharp doit être relié à une pin qui peut faire de la conversion analogique/numérique
• les bumpers doivent rester sur les pins qui sont capables de générer une interruption en soft si vous voulez mieux gérer ces capteurs
• le bouton poussoir doit asolument rester sur la pin du reset
• l'horloge doit rester sur les pins d'horloge

Comme vous le voyez, nos contraintes ne sont pas très grandes, et notamment le routage des micromatch (les composants qui sont simplement des connecteurs pour diverses capteurs ou bus) est assez flexible. Il faudra simplement faire attention ensuite à comment y brancher les capteurs ou bus.

Donc, si vous voulez changer le schéma électrique, il faut retourner dans DesignView. Vous faites vos changements sur le schéma électrique ensuite vous relancer le packager dans Tools/Other Utilities puis "Packager" ou directement sur l'icone en haut et vous relancer la forward annotation (l'opération qui permet à Expédition PCB de savoir à quelles pins est reliée telle pin) dans Setup/Project Integration. Ce sont les mêmes étapes que la première fois qu'on a lancé le packager. Ne vous inquiétez pas, tout ce qui n'est pas changé dans le schéma électriquene sera pas changer sur le PCB, vous ne perdez donc que le routage des pins qui ont été modifiées.

Pour ma part, j'obtiens ceci en ne changeant pratiquement rien: j'ai changé les pins color2 et color3 sur mon micromatch. Et j'ai changé plusieurs connections de micromatch (souvent la masse je l'ai mise en 4...).

8 - routage alimentation

Normalement il ne vous reste que la masse et VCC à router. Faites votre possible pour router VCC sur le plan du dessus (fils en bleu) et garder la masse pour après.

Vous pouvez rencontrer des problèmes facilement résolubles. Par exemple dans une situation comme celle-ci:

Et rien qu'en déplaçant un fil entre les pads du micromatch, vous pouvez router! 

Normalement, VCC est routable sur la face du dessus mais vous pouvez avoir des problèmes pour GND. Essayez quand même d'abord de router sur le plan du dessus en bougeant les composants ou en changeant les pins. Ensuite, quand vous êtes désespérés, vous pouvez utiliser la 2ème couche. Comme on l'a dit on peut router sur la face du dessous comme ça on peut croiser les fils, il faudra juste percer un trou dans la carte et mettre un fil pour que le courant passe du dessus au dessous.

Quand vous avez un fil et que vous voulez le faire passer en dessous, appuyez sur F10 ("add via", les commandes des touches F sont rappelées en bas et elles changent suivant le mode dans lequel vous vous trouvez). Un "via" sera créé automatiquement, un "via" c'est justement le trou dans la carte qui fera passer le courant. Quand le via est placé votre fil apparait maintenant en rouge, vous êtes sur l'autre face de la carte et vous pouvez croiser les fils bleus, réappuyer sur F10 pour refaire un via et revenir sur la face du dessus. Par exemple pour les ponts en H, j'obtiens ceci:

Et à la fin, vous vous rendez compte qu'il reste beaucoup de place entre les composants. Essayez donc de ressere un peu le tout, vous pouvez déplacer un groupe de composants en mode "plae" et les bouger tous ensemble. Après resserage, j'obtiens un routage à peu près comme cela.

1 - Le soft: vue globale

Avant d'écrire un soft, il convient de voir ce qu'on veut en faire. Nous avons dégagé 2 modes de fonctionnement principaux mais il est tout à fait possible d'en envisager d'autres. Les 2 modes sont détaillés ci-dessous.

• Mode 1 : filaire commandé via port série

Ce mode permettra de tester les différentes "fonctions" du robot. Dans la version de base il possèdera un simple module de gestion des roues pour déplacer le robot, c'est-à-dire qu'en envoyant un caractère sur le port série, le robot devra répondre en executant une action. Par exemple, on appuie sur 'z' et le robot met les 2 moteurs en marche avant pour qu'il avance. Si on appuie sur 'd' le robot allumera uniquement le moteur gauche en marche avant pour qu'il tourne à droite, etc.

C'est donc principalement un mode de test pour voir si tout fonctionne bien. Ce mode se distingue du suivant car toutes les actions sont executées après l'envoi d'une touche. Le robot ne fait rien "par lui-même".

• Mode 2 : mode autonome

Ce mode est le mode autonome du robot. Le robot sera lancé de manière aléatoire et se déplacera de façon autonome. Plusieurs cas sont alors à distinguer par ordre de complexité :

    - le robot se déplace de manière aléatoire et change de direction lorsqu'il détecte un obstacle par l'intermédiaire des bumpers. Ce mode est un mode a posteriori : le robot réagit après collision (bumper)

    - le robot se déplace de manière aléatoire et change de direction lorsqu'il détecte un obstacle par l'intermédiaire du capteur de distance. Ce mode est un mode a priori : le robot anticipe la collision (capteur de distance)

    - le robot est lancé à proximité d'une ligne et lorsqu'il la rencontre par l'intermédiaire des 4 capteurs de couleur, la suit.

On voit qu'à l'intérieur du mode 2, il y a plusieurs sous mode, en pratique, ce sera des programmes différents.

Nous allons donc voir comment écrire un premier programme très simple (celui qui gère uniquement les bumpers) et surtout comment le mettre sur le microcontrôleur.

2 - Ecrire un premier programme

A savoir avant de commencer

Avant de commencer à programmer le microcontrôleur, il ya quelques notions de base à bien avoir en tête. Ces notions sont abordées dans la page de cours sur la programmation qui sera prochainement en ligne.

Ecrire un premier programme

 
Récupérer l'archive bumper.c.txt (Download en bas de la page), renommez-le en bumper.c. Ce fichier écrit en langage C est incomplet. Il faut le compléter de manière à tester le fonctionnement d'un bumper relié à la carte. Lisez bien ce qui suit avant de commencer.
 
L'entête du programme contient les fichiers annexes au fonctionnement du programme bumper(ces fichiers annexes sont inclus dans le programme grâce à #include). Ces fichiers contiennent des constantes ou des fonctions nécessaires au fonctionnement du programme.
 
L'entête contient également des définitions de constantes :
    - exemple : #define LED_RED PD7 permet d'utiliser LED_RED dans tout le code à la place de PD7 pour plus de clarté. Il s'agit uniquement d'une substitution syntaxique.
 
La fonction principale du programme qui se lance à l'execution est la fonction main(). On appellera dans cette fonction les autres fonctions définies dans le fichier pour effectuer ce que doit réaliser le programme.
 
Il y a deux fonctions à compléter en dehors de la fonction main() pour réaliser ce programme :
    - la fonction init_led() configure LED_RED et LED_BLUE en sortie. Elle doit permettre de commander la sortie par un niveau logique 0 ou 1 sur la PIN.
    - la fonction init_interruptor() configure les pins INTERRUPTOR0 et INTERRUPTOR1 en entrée. Cette fois-ci on va relever l'état des pins et non imposer leur état.
 
La fonction main() doit donc utiliser ces deux fonctions pour configurer les entrées et sorties puis être capable de déceler lorsqu'un bumper est actionné. On écrit donc une boucle dite "d'attente active" qui permet de vérifier l'état des bumpers (appuyés ou relachés) en permanence et de réaliser l'action désirée en réaction, par exemple allumer une LED.
 

Aide :

 
Pour configurer une PIN d'un port donné (A,B,C ou D) en entrée ou en sortie, il faut aller dans le registre adéquat, par exemple le port DDRX pour le port X (cf p81 de la data sheet). Dans tous les cas quand vous avez un doute, vous pouvez toujours regarder la datasheet. Pour la configuration d'une pin en entrée ou en sortie il faut aller voir dans la datasheet s'il faut mettre un 1 ou un 0 dans la datasheet.
 
Opérateur OU logique : le symbole |= permet de faire un OU logique avec soi-même. C'est un opérateur très utile pour mettre un bit à 1 sans changer les autres bits du nombre!
 
Pour lire l'état d'une PIN il faut aller lire le registre PINXY pour la PIN Y du port X. Mais c'est aussi marqué dans la datasheet :)

3 - Compiler un premier programme

Une fois que votre programme vous semble juste, il faut le compiler. Cependant, il va falloir le compiler pour l'AVR, en effet le code ne sera pas executé par l'ordinateur mais bien par le processeur de la carte (ici un AVR). Vous compilez donc sur l'ordinateur mais pour un autre processeur. Il faut pour cela utiliser un autre gcc: avr-gcc.

Vérifiez tout d'abord que vous avez avr-gcc d'installé en tapant avr-gcc dans un terminal, s'il vous dit "command not found" vérifiez qu'il est correctement installer et que le binaire est bien dans votre PATH.

Si vous êtes sur Debian, il suffit d'installer les paquets :

• avrdude
• avrdude-doc
• gcc-avr
• avr-libc
• binutils-avr

Ce compilateur nécessite des options de compilation:

• Le type d'AVR utilisé pour savoir quels sont les fichiers qu'il doit inclure. En effet, certaines fonctions sont implémentées différemment selon le type d'AVR. Notre AVR est un ATMega88, on met donc -mmcu=atmega88 sur la ligne de compilation.
• La fréquence de fonctionnement du processeur : -DF_CPU=20000000 En gros, l'option -D définit une variable. C'est donc la variable F_CPU que l'on fixe à 20MHz puisqu'on a mis un quartz de 20MHz
• Les librairies nécessaires pour compiler sont surement placées dans un répertoire comme /usr/local/avr/avr/lib ou /usr/lib/avr/lib sauf si vous avez installé les librairies vous-même. Retrouvez ce répertoire sur votre ordinateur et mettre l'option -L /usr/avr/avr/lib. A l'école c'est ce répertoire qui est utilisé.
• on peut demander à ce que toutes les warnings soient considérer comme des erreurs pour nous obliger à faire un code propre -Werror
• on optimise la taille du code généré avec -Os
• on limite la taille que peuvent prendre les fonctions inline avec -finline-limit=800

Vous pouvez donc compiler votre programme avec la ligne suivante:

avr-gcc -Os -finline-limit=800 -mmcu=atmega88 -DF_CPU=20000000 -Werror -L /usr/local/avr/avr/lib nom_du_programme.c -o nom_du_programme

Vous avez donc un programme executable pour un ATMega88 mais malheureusement, vous ne pouvez pas le tester sur votre ordinateur. Il faudra encore patienter jusqu'à ce qu'on ait mis le programme sur l'ATMega.

Pour mettre un programme sur l'ATMega il faut d'abord le transformer en .hex pour qu'il puisse être transférer par le port série. On utilise la commande avr-objcopy qui permet de convertir des fichiers objets en d'autres formats, l'option -O ihex dit que le fichier de sortie doit être en hexadecimal et l'option -R .eeprom dit qu'on enleve la section qui concerne l'eeprom. Cette option est utile car très souvent on stocke des données utiles à l'utilisateur dans l'eeprom (par exemple des infos de calibrage pour les webcams) et on ne veut pas que le programme qu'on va transférer les écrase. Ce qui nous donne la ligne de commande suivante:

avr-objcopy -O ihex -R .eeprom nom_du_programme nom_du_programme.hex

Gardez bien le fichier .hex car c'est lui qu'on va envoyer sur notre robot à la prochaine page. Mais avant cela voyons d'abord comment faire un Makefile au cas où nos projets deviennent plus gros.

Il existe de nombreux tutoriaux sur les Makefile c'est pourquoi je serai bref, nous verrons juste les points importants, pour comprendre la base, lisez cette page assez bien faite et succinte: http://mrbook.org/tutorials/make/ et pour plus d'infos la documentation officielle http://www.gnu.org/software/make/manual/make.html

Voici un exemple de Makefile ci dessous, regardez les commentaires en dessous.

# Notre AVR : ATMEGA88 à 20MHz
MCU = atmega88
F_CPU = 20000000
 
# Programme a construire
TARGET = test
 
# Ne plus toucher ci-dessous 
CC           = avr-gcc 
OBJCOPY      = avr-objcopy 
SIZE         = avr-size 
OBJECTS = $( patsubst %.c,%.o,$(shell echo *.c) ) 
HEADERS = $( shell echo *.h ) 
CFLAGS = -g -Os -finline-limit=800 -mmcu=$(MCU) -DF_CPU=$(F_CPU) -Werror 
LDFLAGS = -L /usr/local/avr/avr/lib -mmcu=$(MCU)  
 
all: $(TARGET).hex
	@echo "==============================="
	@echo "compiled for: $(MCU)"
	@echo -n "program size is: "
	@$(SIZE) -A $< | grep "\.sec1" | tr -s " " | cut -d" " -f2
	@echo "==============================="  
 
$(TARGET): $(OBJECTS) $(TARGET).o  
 
%.o: $(HEADERS)  
 
%.hex: %
	$(OBJCOPY) -O ihex -R .eeprom $< $@  
 
clean:
	rm -f $(TARGET).hex
	rm -f *~
	rm -f *.o
	rm -f $(TARGET)

ATTENTION, il se peut que votre navigateur remplace les tabulations du Makefile par un simple espace. Dans ce cas, remplacez tous les espaces en début de ligne par des tabulations.

Voilà, ce Makefile considère que tous les fichiers .c sont des fichiers sources du programme et va donc compiler tous les .c du dossier puis va faire le linkage. Ensuite il créera le fichier .hex avec la commande avr-objcopy. Ce qui est très pratique si on a un programme avec de nombreux fichiers sources. En plus, on pourra utiliser le même Makefile pour différents projets très simplement, puisqu'il suffit de changer le nom du TARGET et non pas le nom de tous les fichiers sources.

Vous pouvez le tester en le copiant dans un fichier appelé "Makefile" dans votre dossier de travail. Tapez ensuite la commande make. Vous devriez voir tous les fichiers se compiler puis le programme être linker et enfin la commande pour faire le .hex. Si ça ne marche pas, essayez d'abord de trouver par vous-même ce qui ne fonctionne pas et ensuite n'hésitez pas à poster sur la liste de diffusion pour les membres du clubs.

Quand tout fonctionne, on peut passer sereinement au transfert de ce premier programme sur le robot.

4 - Branchement / Flashage de la carte

Branchement de la carte

Port série

On branche la carte au port série de l'ordinateur. Il faut donc voir quel est le micromatch (connecteur rouge) qui correspond au port série, c'est celui qui est relié aux port RX et TX du processeur. Branchez sur ce micromatch un cable spécial qui a d'un côté un branchement pour micromatch et de l'autre un connecteur de port série, normalement si vous avez respecté le tutorial pour relier RX et TX les cables sont bons. Branchez le port série sur l'unité centrale.

Alimentation

A l'école on a des alimentations (les gros blocs jaunes) qui permettent d'alimenter pleins de trucs différents. Cette alimentation permet un contrôle en tension et en intensité. Lorsque le voyant lumineux rouge de l'intensité est allumé, c'est l'intensité qui limite l'alimentation. Lorsque le voyant vert de la tension est allumé, c'est la tension qui limite l'alimentation.

Le régulateur de la carte se fixe sur 5V. Il faut donc délivrer une tension minimale de 5V. On prendra une tension entre 5V et 7V. Pour ceux qui n'ont pas d'alimentation de ce genre, sachez qu'une pile 9V fait tout à fait l'affaire. Prévoyez-en plusieurs si vous comptez développer un assez gros programme.

Le bouton "Attente" de l'alimentation permet d'arrêter et de relancer l'alimentation de la carte. Lors du lancement de l'alimentation le bootloader se lance. Il a été programmé pour allumer les LED rouge et bleu à son lancement. La LED reliée à l'alimentation est en revanche allumée dés que l'alimentation est en route, indépendamment du bootloader. Elle reste donc allumée lorsque l'on appuie sur le bouton "Reset" qui relance le bootloader.

Vous pouvez donc soit brancher la carte sur cette alimention soit utiliser la pile de 9V.

Flashage de la carte

Une fois la carte alimentée et reliée au port série de l'unité centrale, le programme "minicom" permet de communiquer avec la carte par l'intermédiaire du port série. Pour le lancer il suffit de taper "minicom" sur la ligne de commande.

A son lancement, minicom affiche le numéro de port sur lequel il communique. Il affichera par exemple : Port /dev/ttyS1

Si rien ne s'affiche, c'est que la carte est branchée sur un autre port. On sort alors de minicom et on le relance avec l'option "-s" qui permet de le configurer. On peut alors modifier le numéro de port pour mettre par exemple/dev/ttyS0, il suffit de rentrer dans le menu "Serial port config" et changer le nom du device en tapant A. De manière générale, on tape Ctrl-A suivi de X pour quitter minicom et Ctrl-A suivi de Z pour entrer dans le menu de minicom.

Une fois le bon port spécifié, minicom affiche à l'écran une suite de b et de a. Le b signifie que le bootloader se lance et le a signifie que l'application se lance. Comme pour l'instant aucun programme n'a été chargé dans la mémoire, le programme retourne au début et affiche un b et ainsi de suite.

On peut regarder les options de minicom mais elles ne permettent pas d'envoyer de caractères assez rapidement pour pouvoir envoyer des commandes (et un programme) au bootloader. On télécharge donc le programme foodloader sur le site officiel. On extrait les archives avec la commande tar -xvf "nom_du_fichier" dans un répertoire qu'on aura créé au préalable avec la commande mkdir nom_du_repertoire.

Pour compiler foodloader on utilise la commande make une fois placé dans le répertoire contenant toutes les archives.

Pour lancer le programme on se place dans le répertoire launch-bootloader et on entre la commande ./launch-bootloader. Le programme va alors dire qu'on doit le lancer en spécifiant le nom du port série et la vitesse de transfert d'informations. La bonne commande de lancement est donc ./launch-bootloader /dev/ttyS0 115200 si /dev/ttyS0 est le nom du port et 115200 est la vitesse de transfert en bits/sec(c'est la vitesse maximale de communication du port série et cette valeur a été spécifiée dans le bootloader)

Une fois le programme lancé, il demande de brancher la carte sur le port série si cela n'a pas été fait et affiche "running" si elle est connectée.

On peut alors tester que le bootloader répond bien en discutant avec lui par l'intermédiaire du programme.

Pour pouvoir charger un programme dans le bootloader il faut utiliser avrdude. Après avoir téléchargé l'archive on la décompresse avec la même commande que pour foodloader. Ensuite, il faut entrer la commande make all pour compiler le programme.

Note : il faut aussi récupérer le fichier .avrduderc sur le site de foodloader. Il faut le copier coller dans un fichier texte et l'enregistrer dans le répertoire choisi sous le nom .avrduderc. Il faut alors décommenter les lignes suivantes :

programmer
  id    = "avr109";
  desc  = "Atmel AppNote AVR109 Boot Loader";
  type  = butterfly;
  baudrate = 115200;

On doit alors spécifier le programme que l'on passera en argument au programme avrdude. Ce sera le fichier test.hex fourni dans l'archive sur le site. Une fois ce programme écrit et compilé avec makefile, on peut lancer avrdude avec la commande suivante :

./avrdude -p m88 -b 115200 -c avr109 -F -C ~/.avrduderc -P /dev/ttyS0 -U f:w:chemin_de_test.hex

Le programme test.hex permet d'allumer et d'éteindre la LED bleue en tapant sur n'importe quelle touche. On peut alors le tester en tapant sur n'importe quelle touche par l'intermédiaire de minicom.

Mais toute cette étape a été simplifiée en mettant tout dans le makefile. Il suffit donc de faire make program.