AVR – Chapitre 1 – Faire clignoter une diode

Hello world !

Pour ceux qui on l’habitude d’apprendre de nouveaux langages, il y a une première étape incontournable : le Hello world. La preuve que ça marche. En électronique, il s’agit de faire clignoter une diode.

On a pu voir ici le code pour Arduino ou pour le MSP430. En AVR, le code ressemble beaucoup au MSP430 :

 

Pas de panique !

Pour beaucoup, cette notation peut parraître obscure, voire barbare. Mais c’est ainsi que l’on doit parler à un micro-controleur. Cela dit, une fois habitué, vous n’aurez aucun mal à comprendre la simplicité de ce code.

On verra plus en détail au prochain chapître le contenu réel du code ; pour le moment nous allons nous concentrer sur sa structure.

On doit distinguer :

  • le chargement de bibliothèques
  • les définitions de pré-compilation
  • la déclaration des fonctions (il n’y en a aucune ici)
  • la fonction principale «main», qui se découpe ainsi :
    • un bloc d’initialisation
    • une boucle infinie

Voyons celà de plus près !

Le chargement de bibliothèques

 

Ceux déjà habitués savent déjà de quoi il s’agit ; les bibliothèques contiennent des ensembles de constantes, de fonctions et de structures utilsables dans vos projets. Il suffit de les importer en utilisant la directive #include , qui sera interprétée juste avant la compilation.

Ici nous utilisons la bibliothèque avr/io.h , qui contient la définition de constantes permettant un accès aisé aux entrées et sorties, ainsi que quelques fonctions rendant le code plus lisible. Ici, je n’ai pas utilisé ces fonctions pour avoir un code plus brut, mais rien ne vous empêche à l’avenir de les utiliser si vous préférez.

La bibliothèque  util/delay.h  ajoute des fonctions permettant de mettre une exécution en pause, comme _delay_ms , qui prend en argument un nombre de millisecondes. La présence de cette bibliothèque demande que l’on précise la fréquence du micro-contrôleur, par la constante F_CPU . Sans celà, les temps d’attente seraient approximatifs.

Les définitions de pré-compilation

 

Ces constantes ont une utilté particulière parce qu’elle ne sont pas définies en tant que constantes au sein de l’execution, mais simplement pendant la compilation. Ainsi, juste avant que le compilateur ne fasse sont travail, toutes les occurences de chaque constante sont remplacées par la valeur que l’on définit dans ce bloc. Par exemple, lorsque l’on écrit _delay_ms(DELAY) , le compilateur va lire  _delay_ms(500)  et le convertir en code machine. Il ne lira pas une réference à une constante.
Ces constantes sont utiles mais doivent être utilisées de façons intelligentes ; car à chaque occurence, la pré-compilation va recopier l’ensemble des données en mémoire, et celà peut être très gourmand. Il est par ailleurs totalement exclu de faire des chaînes de caractères avec ces constantes, il faudra utiliser les constantes C classique.

Comme expliqué dans la section précédente, la constante F_CPU doit être définie pour que les temps d’attente soient corrects. Elle est définie ici pour l’exemple, mais il est plus propre de la renseigner dans un Makefile, pour la propager au travers de l’option  -DF_CPU=  pour avr-gcc .

DELAY  est ici un exemple simple de l’utilisation des constantes ; on y définit le temps d’attente en millisecondes entre deux changements d’état de la diode.

La fonction «main»

Comme expliqué plus haut, nous la séparons en deux parties.

Le bloc d’initialisation

Ici, nous allons initialiser tout ce qui doit l’être avant de démarrer réellement l’execution. Il peut s’agir de :

  • configurer des ports et initialiser la valeur des broches (cf. chapître suivant)
  • faire appel à des fonctions qui vont prendre en charge un protocole en particulier
  • intialiser des horloges

Il n’y a pas vraiment de limite à l’utilisation de ce bloc (hormis la taille de la mémoire), mais il est important de garder en tête que celui ci n’est (théoriquement) pas rappeler jusqu’au prochain redemarrage du micro-controlleur (RESET).

La boucle infinie

Elle contient un bloc de code qui sera executer en repetition jusqu’à ce qu’on eteigne le micro-controleur (ou qu’il plante lamentablement). C’est ici que devrait se faire le plus gros de votre travail. Dans mon exemple, on se contente de basculer la valeur d’une broche et d’attendre une demie-seconde.

Vous verrez plusieurs façons de définir cette boucle : for(;;) , while(1), while(1==1) , for(;1==1;) ,… Je ne suis pas sûr qu’il y en ait une qui soit plus performante que les autres, personellement, j’aime bien utilisé for(;;) .

 

2 réflexions au sujet de « AVR – Chapitre 1 – Faire clignoter une diode »

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

*