Programme Blink en C pour Atmega16a (programmateur USBASP, sans interface de développement)

Vous vous intéressez à l’Atmega16a et sa programmation ? Vous voulez faire vos premiers pas avec, mais ne savez pas par où commencer ? Alors ce tutoriel est fait pour vous ! Car vous verrez qu’avec peu de moyens, on peut facilement programmer un atmega, et ce, très rapidement ! Ici d’ailleurs, vous découvrirez comment créer votre tout premier programme fonctionnel en langage C, en le voyant s’exécuter sur une platine d’essai pour microcontrôleur ATmega !

Pour être plus précis encore, je vais vous montrer comment réaliser un programme blink, permettant de faire clignoter une LED branchée sur une des sorties de l’Atmega16A. Ainsi, vous pourrez faire vos premiers pas avec ce microcontrôleur, et voir les différentes techniques et étapes à suivre, pour arriver au résultat final (compilation, programmation, exécution, …).

Bien évidemment, suivant votre niveau de connaissances sur les microcontrôleurs AVR de chez ATMEL, votre maîtrise du langage C, et votre débrouillardise, ce tuto pourrait vous sembler enfantin, tout comme il pourrait vous paraître super dur à appréhender. Or, ne sachant pas votre niveau, je vais partir du principe que vous débutez en électronique, avec tout de même quelques connaissances de base en C, et sur les microcontrôleurs de manière générale. Cela étant dit, je vais toutefois essayer d’expliquer un maximum de choses ici, afin d’accompagner du mieux possible tous les débutants en programmation ATmega16.

Dans tous les cas, si jamais vous avez des questions, n’hésitez pas à les poser en zone commentaire, en bas de cet article. J’y répondrai dès que je pourrais, et bien sûr, dans la mesure du possible, afin de vous aider du mieux que je pourrais. De même, si vous constatez des erreurs ou imprécisions dans ce présent tuto, n’hésitez pas à m’en faire part en commentaire, afin que je puisse corriger ces éventuelles coquilles, et par la même, améliorer la qualité de cet article, et les suivants !

À noter toutefois que je ne suis pas un expert en microcontrôleur Atmega16A, ni même ingénieur ou enseignant en électronique. En fait, je ne suis qu’un simple passionné d’électronique, qui a à cœur de vous partager ses connaissances sur ce site web dédié à la pratique de l’électronique. Du coup, n’hésitez pas à me faire part de vos suggestions et remarques en commentaire, ou via la page contact, afin de contribuer à l’amélioration du présent tuto, et des prochains 😉

Nota : ce tuto sera le plus pertinent pour tous ceux qui fonctionnent sous Windows 10. Je vous prie de bien vouloir m’excuser auprès des gens qui tournent sous Mac ou Linux, car dans ce cas, vous devrez inévitablement adapter ce tuto à votre environnement. Par ailleurs, soyez extrêmement prudents quand vous réalisez vos différentes manips et programmations, car vous êtes seul responsable des conséquences !

✪ Préambule : comment programmer le microcontrôleur Atmega16A ?

Comme tout microcontrôleur qu’on souhaite programmer, l’atmega16 nécessite un minimum de choses pour ce faire :

• Sur le plan matériel (hardware) : un programmateur Atmega16 (coûtant quelques euros seulement, généralement)
• Sur le plan logiciel (software) : un compilateur, et un utilitaire de transfert, pour envoyer le programme de votre PC au µC (tout cela étant gratuit, je vous rassure !)

Donc, rien de bien compliqué, ni d’excessivement cher 😉

Le seul point délicat, selon moi, réside seulement dans la partie logicielle. Car le choix que j’ai fait ici, a été de ne pas programmer ce microcontrôleur au travers d’une IDE spécifique, mais plutôt d’utiliser le strict minimum pour y arriver. Car cela permet de mieux comprendre chaque étape du processus de programmation, ce qui est particulièrement enrichissant lorsqu’on débute avec les MCU ATmega16, et qu’on souhaite vraiment comprendre ce qui se passe en arrière-plan.

Pour ce projet, les fichiers sources dont nous aurons besoin (et que je vous fournirai en bas de cet article) seront au nombre de deux :

• Un fichier source en langage C (le programme Blink, en lui-même)
• Et un script de compilation + upload, pour faire le lien entre votre PC et le programmateur Atmega16a (format Batch)

Du coup, un simple traitement de texte suffira pour éditer ces fichiers, au besoin (ce qui sera d’ailleurs nécessaire au niveau du script, afin de l’adapter à votre environnement de travail personnel). Ainsi, au final, on aura une solution légère, efficace, et qui ne requiert qu’un minimum de fichiers. En bref, vous en aurez la maîtrise totale !

Bien entendu, rien de vous empêche d’écrire votre programme C sous un IDE « prêt à l’emploi », tel que MPLAB X IDE, ou l’Atmel Studio IDE. C’est d’ailleurs ce que je vous recommande de faire si vous êtes débutant, et que vous ne vous intéressez pas à la mécanique d’arrière-plan, concernant la programmation de l’Atmega. Pour autant, savoir comment fonctionne ces choses « cachées » est aussi une excellente forme d’apprentissage, c’est pourquoi je vous présenterai ici une façon assez atypique de faire les choses. Mais dans tous les cas, cette solution sera ultra légère, et facile à maîtriser, contrairement aux développements sous IDE.

Du reste, trêve de blabla, et passons sans plus attendre à la partie matérielle, en vue de préparer la programmation de notre microprocesseur Atmega16a !

➤ Etape 1 : matériel à prévoir (programmateur, platine d’essais, accessoires)

Côté matériel, nous aurons besoin de 4 choses grand maximum :

• Une platine de test Atmega16 avec LED embarquée, qui permettra de recevoir le microcontrôleur ATMEGA16A à programmer/tester. Au passage, ce type de carte intègre un connecteur ISP, pour pouvoir y brancher le câble de programmation (nappe), ainsi qu’une LED intégrée, idéale pour tester notre programme Blink !
• Un programmateur USBASP, qui nous permettra de faire l’interface entre notre ordinateur et la platine de test ci-dessus (normalement fourni avec la platine de test)
• Une rallonge mâle-femelle USB type A-A afin d’avoir un câble de raccordement suffisamment long entre la prise USB de notre ordi, et le programmateur USASP
• Et le microcontrôleur AVR MCU en lui-même : le ATmega16A, vierge de tout programme !

Comme indiqué ci-dessus, la platine de test est nativement équipée d’une LED. Celle-ci est donc déjà câblée au microcontrôleur Atmega16a, et est d’ailleurs raccordée à sa broche PA0, pour être plus précis. À noter que cette LED est branchée en inverse, c’est-à-dire qu’elle s’allumera lorsque qu’on lui enverra du 0 volts, et s’éteindra lorsqu’on lui enverra +Vcc.

Remarques :
– Ici, tout fonctionne en 5 volts. Il n’y a donc pas besoin de passer par du 3,3, et se « compliquer » la tâche !
– Par ailleurs, pas besoin de quartz non plus pour faire ses essais, car l’Atmega16A fonctionne de base sur son oscillateur interne à 1 MHz (je vous montrerai d’ailleurs comment modifier les fusibles de ce µC dans un autre article, afin de monter plus haut en fréquence, via un oscillateur externe).
– Enfin, pas besoin d’alimentation externe, car l’énergie est fournie par le programmateur USB lui-même, lors des essais.

➤ Etape 2 : récupérer les logiciels gratuits nécessaires

N’ayant qu’un PC avec Windows 10 sous la main, je vous ai fait ce tuto avec ce système d’exploitation là. Bien entendu, si vous travaillez sur un système d’exploitation différent, il faudra adapter ce tutoriel (désolé !). Toutefois, je pense qu’on peut assez facilement trouver un émulateur Windows pour ces autres systèmes d’exploitations (je pense notamment à Mac et Linux), pour pouvoir suivre ce tuto à la lettre !

Mais tout d’abord, un point qui va vous rassurer ! Ici, tous les logiciels nécessaires à la programmation d’un Atmega16 sont gratuits ! Et d’ailleurs, pour être plus précis, nous n’en utiliserons que deux, à savoir :

• L’IDE Arduino préalablement installée (https://www.arduino.cc/en/software), même si on ne s’en servira pas directement (vous verrez !)
• Un driver générique pour appareil USB, pour que le PC reconnaisse le programmateur USBASP. Perso, je me suis servi d’un utilitaire reconnu, qui s’appelle Zadig (https://zadig.akeo.ie/), et qui fonctionne à merveille ici

Remarque : aussi surprenant que cela puisse paraître, nous n’allons pas nous servir ici de l’IDE Arduino, à proprement parler. Car comme évoqué en introduction, le but de cet article est aussi d’essayer de vous montrer ce qui se passe en arrière-plan, et donc de faire la programmation en dehors de tout IDE (ceci, pour que vous compreniez bien chaque étape de la programmation d’un Atmega16A). Mais du coup, me direz-vous : quel est l’intérêt d’installer l’IDE d’arduino, si c’est pour ne pas s’en servir ? En fait, la raison est simple : c’est essentiellement pour y récupérer 2 fichiers exécutables, qui sont :
– Avr-gcc, le compilateur C
– Avrdude, un utilitaire de transfert et programmation, pour envoyer le programme du PC au programmateur Atmega16
Par ailleurs, nous allons profiter des bibliothèques de base (librairies) livrées avec l’IDE Arduino, et de quelques fichiers de configurations indispensables, caractérisant chaque MCU (micro contrôleur), pour faciliter le codage et la programmation. Du coup, installer cet IDE est juste un moyen détourné pour profiter de tous ces « sous-programmes » et fichiers de configuration, déjà tout prêts, pour tester ce projet 😉

Du reste, hormis l’environnement Arduino, nous aurons besoin d’un petit driver générique USB, pour que Windows 10 puisque reconnaître le programmateur USBASP. Car en effet, ce dernier n’est généralement jamais fourni avec son driver, et Windows 10 ne reconnait pas nativement ce programmateur. C’est pourquoi vous aurez besoin d’un petit programme spécifique, tel que Zadig, pour que votre PC puisse reconnaitre correctement le programmateur. Mais rassurez-vous, car il n’y a rien de difficile à faire ici. Et une fois que c’est fait, ce n’est plus à refaire ! D’ailleurs, il n’y a que ces quelques étapes à suivre, pour que tout soit opérationnel :

• Lancer le programme ZADIG
• Brancher le programmateur sur une des prises USB de votre ordi
• Attendre quelques secondes, afin de voir apparaître « USBASP » dans la liste déroulante de ZADIG
• Sélectionner « WinUSB » dans la liste des Driver (là où vous avez le choix entre WinUSB, libusb, USBserial, …)
• Cliquer sur « Install Driver », pour lancer l’installation du driver
• Et attendre 1 à 2 minutes, pour que tout se paramètre en arrière-plan (ne vous inquiétez pas si ça prend du temps, car cette configuration automatique est plutôt lente, même si on possède un PC super rapide !)

Si tout s’est bien passé, vous devriez voir votre « USBASP » s’afficher dans votre gestionnaire de périphériques, comme ci-dessous.

➤ Etape 3 : réaliser le montage

Pour programmer le microcontrôleur Atmega16a, vous devrez réaliser le montage suivant :

En fait, comme vous le voyez, le raccordement de tous ces éléments est super simple à faire. Car il s’agit simplement de :

• Loger le microcontrôleur Atmega16a sur la platine de test (pour cela, il suffit d’actionner le petit levier à gauche, de bas en haut, ou de haut en bas, pour déverrouiller ou reverrouiller le support de µC)
• Brancher la platine de test au programmateur, via la nappe fournie avec le programmateur USBASP
• Et raccorder le programmateur à votre PC, via une rallonge USB, ou directement dessus

Voici d’ailleurs ce que ça donne visuellement, sans le branchement PC :

Remarque très importante : attention aux décharges électrostatiques, lorsque vous manipulez tous ces composants. Car si vous ne prenez aucune précaution, vous pourriez fort bien griller certains composants essentiels ici. C’est pourquoi je vous recommande vraiment l’usage de gants antistatiques pour l’électronique ou d’un bracelet antistatique avec dragonne, pour vous relier à la terre, par exemple.

Comme annoté sur la photo précédente, la platine de test dispose d’un interrupteur « marche / arrêt ». En fait, il s’agit plutôt d’un switch, pour passer d’une alimentation à une autre. Car dans un sens, l’alimentation se fait via le programmateur relié à l’ordi, et dans l’autre, l’alimentation devient externe, en s’alimentant via la prise jack DC Ø5,5, située à gauche de la platine. Ceci étant dit, quelque soit la position de l’interrupteur inverseur, la programmation arrivera à se faire. Par contre, pour voir le programme blink fonctionner, il faudra appuyer sur ce bouton jusqu’à voir la lumière rouge « sous tension » s’allumer (que ce soit via votre PC, au travers du programmateur USBASP, ou via une alimentation 5 volts externe, branchée sur le connecteur DC 5,5).

Le saviez-vous ? Typiquement, le microcontrôleur Atmega16a peut être alimenté avec une tension comprise entre 2,7V à 5,5V. Mais si vous prévoyez de monter plus en haut en fréquence, que les 1 MHz configurés de base, il faudra impérativement passer sous 5 volts, selon les recommandations du fabricant !

➤ Etape 4 : compilation du programme et programmation de l’Atmega16a

Ça y est, nous arrivons à la partie la plus intéressante, c’est-à-dire le codage en lui-même !

En fait, il s’agira ici d’écrire un petit programme en langage C, permettant de faire clignoter la LED de la platine d’essai ATmega, branchée sur la pin A0 du MCU ATmega16A. Ensuite, nous verrons ensemble comment compiler ce programme (avec le compilateur « avr-gcc », disponible dans les fichiers de l’IDE Arduino), et comment l’envoyer à l’Atmega16, via le programmateur USBASP (nous ferons ça avec le logiciel « avrdude », lui aussi fourni quelque part au milieu des fichiers de l’IDE Arduino). Alors c’est parti !

✎ Le programme Blink customisé, pour faire clignoter une LED deux fois de suite, depuis l’Atmega16, et en langage C

Histoire de ne pas faire comme tout le monde, je vous propose ici un code permettant de faire clignoter la LED deux fois d’affilé, puis de s’éteindre quelques instants, et que cela se répète à l’infini.

Pour ce faire, nous aurons tout d’abord besoin d’indiquer au programme C la fréquence d’horloge du microcontrôleur, car la librairie « delay.h », gérant les « pauses » en aura besoin. À noter que par défaut, d’usine, le MCU Atmega16A fonctionne à une fréquence de 1MHz, sur oscillateur interne (sans besoin de quartz extérieur ni autre, donc). Dans tous les cas, quelque soit la fréquence d’utilisation de votre µC, il faudra la spécifier en dur dans le code, afin qu’une seconde dure bien 1 seconde ! Cela peut sembler « inutile », mais la librairie delay.h a besoin de cette info, sans quoi elle ne pourrait deviner la fréquence d’horloge du microcontrôleur (et donc, n’aurait aucune référence pour calibrer cette durée de « 1 seconde »). Du coup, pour que tout fonctionne correctement, les premières lignes du programme devront ressembler à ça, si vous fonctionnez à une vitesse de 1 MHz au niveau du CPU :

#define F_CPU 1000000UL  // 1 MHz CPU clock (UL = unsigned long)
#include <avr/io.h>      // Bibliothèque principale, pour piloter les entrées/sorties du µC
#include <util/delay.h>  // Bibliothèque de fonctions, permettant de faire attendre le microcontrôleur quelques instants, avant de passer à la suite

Puis on définit un ensemble de variables, qui vont nous servir plus loin, comme : la durée d’allumage ou d’extinction de la LED, et, le numéro de la broche sur laquelle cette LED sera rattachée (PA0, dans notre cas).

#define BLINK_DELAY_MS_COURT 200  // Indique la durée d'une pause qui sera "courte" (200 ms ici)
#define BLINK_DELAY_MS_LONG 1500  // Indique la durée d'une pause qui sera "longue" (1500ms ici)
#define pinA0 0b00000001          // Masque de sélection de la pin AO de l'Atmega16a (on aurait pu mettre 0b0100000 pour sélectionner la pin A6 par exemple, car chaque bit correspond à une sortie du port en question)

Une fois ces déclarations faites, on passe au programme principal. Et avant tout, on va définir la pin A0 du MCU comme sortie. Pour cela, il faudra fixer son registre correspondant à « 1 ». Dans notre cas, ce registre s’appelle DDRA, puisque la pin « A0 » est sur le PORTA. Ce registre est d’ailleurs codé sur 8 bits, à savoir 1 bit par entrée/sortie, et la valeur de chaque bit indique son sens (0=entrée, et 1=sortie). On va donc se servir du masque « pinA0 » créé précédemment, pour qualifier la pin de ce registre en sortie.

DDRA|=pinA0;			// La fonction OU permet de définir la pinA0 en « sortie »

Et comme il s’agit d’un clignotement, on va créer une boucle infinie, dans laquelle on va mettre toute la séquence à répéter.

// Boucle infinie
while(1) {
… lignes de code pour allumer, puis éteindre la LED (se répètera à l’infini) …
}

Du reste, la séquence de clignotement est super simple à réaliser. Car pour commencer, on va allumer la LED une première fois. Cela se fait en mettant la pin PA0 du microcontrôleur à l’état bas, soit 0 volt (puisque la LED est branchée à l’envers, dessus). Pour ce faire, on se sert de la fonction « ET » et du masque pinA0 présenté ci-dessus. Car le but ici, est de forcer la valeur de sortie cette pin à 0, en ne touchant pas aux autres. Au niveau du code, cela s’écrit de la manière suivante :

PORTA &= ~pinA0;                    // Activation de la pin A0, pour la 1ère fois (la fonction ET permet de mettre la pinA0 à l’état bas, soit 0 volts, pour que la LED s'allume)
_delay_ms(BLINK_DELAY_MS_COURT);    // puis on fait une pause de 200 ms

Après cet allumage, suivi de sa pause de 200ms, on va éteindre la LED, en passant la pin A0 à l’état haut, soit +5 volts (car encore une fois, la LED étant branchée à l’envers, il faut raisonner en inverse ici). Cela se réalise en se servant de la fonction « OU » et du masque pinA0 préalablement créé.

PORTA |= pinA0;                     // Désactivation de la pin A0 (la fonction OU permet de mettre la pinA0 à l’état haut, soit +5 volts, pour que la LED s'éteigne)
_delay_ms(BLINK_DELAY_MS_COURT);    // puis on refait une pause de 200 ms

Après l’extinction de la LED, et une nouvelle pause de 200 ms échue, on refait un 2^ème clignotement, et ce, exactement de la même manière que la première fois. Soit :

PORTA &= ~pinA0;                    // Activation de la pin A0, pour la 2nde fois
_delay_ms(BLINK_DELAY_MS_COURT);    // pause de 200 ms

Puis, après 200 autres millisecondes, on éteint la LED, et cette fois-ci, on va attendre un peu plus longtemps, pour boucler la boucle ! (1,5 secondes).

PORTA |= pinA0;                     // Désactivation de la pin A0
_delay_ms(BLINK_DELAY_MS_LONG);     // pause de 1500 ms

Au final, on obtient le programme suivant :

#define F_CPU 1000000UL  // 1 MHz CPU clock (UL = unsigned long)
#include <avr/io.h>      // Bibliothèque principale, pour piloter les entrées/sorties du µC
#include <util/delay.h>  // Bibliothèque de fonctions, permettant de faire attendre le microcontrôleur quelques instants, avant de passer à la suite

#define BLINK_DELAY_MS_COURT 200  // Indique la durée d'une pause qui sera "courte" (200 ms ici)
#define BLINK_DELAY_MS_LONG 1500  // Indique la durée d'une pause qui sera "longue" (1500ms ici)
#define pinA0 0b00000001          // Masque de sélection de la pin AO de l'Atmega16a (on aurait pu mettre 0b0100000 pour sélectionner la pin A6 par exemple, car chaque bit correspond à une sortie du port en question)

int main(void)
{
  // Registre DDRx : chaque bit définit l'état de chaque pin. Si un bit est à 0, cela signifie que la pin correspondante sera définie comme étant une entrée. Ä l'inverse, si ce bit est à 1, alors on indique au MCU que cette broche sera une sortie
  DDRA|=pinA0;			// La fonction OU permet de définir la pinA0 en « sortie »

  // Boucle infinie
  while(1) {
    PORTA &= ~pinA0;                    // Activation de la pin A0, pour la 1ère fois (la fonction ET permet de mettre la pinA0 à l’état bas, soit 0 volts, pour que la LED s'allume)
    _delay_ms(BLINK_DELAY_MS_COURT);    // puis on fait une pause de 200 ms

    PORTA |= pinA0;                     // Désactivation de la pin A0 (la fonction OU permet de mettre la pinA0 à l’état haut, soit +5 volts, pour que la LED s'éteigne)
    _delay_ms(BLINK_DELAY_MS_COURT);    // puis on refait une pause de 200 ms

    PORTA &= ~pinA0;                    // Activation de la pin A0, pour la 2nde fois
    _delay_ms(BLINK_DELAY_MS_COURT);    // pause de 200 ms

    PORTA |= pinA0;                     // Désactivation de la pin A0
    _delay_ms(BLINK_DELAY_MS_LONG);     // pause de 1500 ms
  }
}

✎ La compilation et l’envoi du programme en AUTOMATIQUE, grâce à un script quasi tout prêt !

Maintenant que vous avez compris le programme C dans le détail, il s’agit à présent de le compiler, afin que celui-ci puisse être enregistré dans la mémoire du microcontrôleur. Et pour gagner du temps, et éviter bien des erreurs, j’ai conçu un petit script pour faire cela en automatique.

Par contre, il faudra absolument modifier les paramètres de base, afin que ceux-ci correspondent exactement à ceux de votre PC. Pour cela, il vous faudra éditer le script que je vais vous fournir, avec un éditeur de texte type Notepad++, et modifier le nom des répertoires, selon les spécificités de votre environnement.

Au niveau du script, vous aurez donc besoin de mettre à jour ses 3 premières lignes. Pour ma part, voici les paramètres utilisés (« JEROME » étant mon nom de profil Windows 10 ») :

set rep_avr_gcc=C:\Users\JEROME\Documents\ArduinoData\packages\arduino\tools\avr-gcc\7.3.0-atmel3.6.1-arduino5\bin
set rep_avrdude=C:\Users\JEROME\Documents\ArduinoData\packages\arduino\tools\avrdude\6.3.0-arduino17\bin
set rep_avrdudeconf=C:\Users\JEROME\Documents\ArduinoData\packages\arduino\tools\avrdude\6.3.0-arduino17\etc

En fait, il s’agit simplement d’indiquer au script :

• où trouver le compilateur « avr-gcc » (en remplaçant « JEROME » par votre nom de profil sous Windows 10)
• où trouver l’utilitaire de programmation « avrdude » (en remplaçant « JEROME » par votre nom de profil sous Windows 10)
• et où trouver les fichiers de configuration pour le programmateur (en remplaçant « JEROME » par votre nom de profil sous Windows 10)

Une fois ces modifications faites, et que vous aurez bien installé les drivers du programmateur USBASP, comme vu précédemment, vous serez prêt à faire feu !

Nota : j’ai écrit ce script de telle manière qu’il s’arrêtera s’il y a le moindre problème (ou presque !), avec un message en vert si tout s’est bien passé, ou en rouge, s’il y a eu un problème. Vous verrez que c’est particulièrement utile pour repérer rapidement des erreurs de compilation, dans le code C, ou au niveau de la programmation via l’USBASP. Voici d’ailleurs quelques exemples d’aperçu écran, selon si tout s’est bien passé, ou s’il y a eu des erreurs.

Cas 1 : exemple d’erreur dans le codage, signalé par le script

Cas 2 : exemple d’erreur au niveau du programmateur, signalé par le script

Cas 3 : exemple avec aucune erreur, avec une programmation parfaitement réussie !

Ainsi, si tout s’est bien déroulé, vous devriez voir la LED de votre platine de test clignoter !

⚝ Pour aller plus loin

✎ Les fusibles de l’Atmega16a

Par défaut, le MCU livré par le fabricant fonctionne à 1 MHz, sur oscillateur interne. Ainsi, pas de besoin de quartz ou quoi que ce soit d’autre pour servir d’horloge, ce qui est très pratique pour faire ses premiers pas avec ce microcontrôleur. Par contre, dès lors que vous souhaiterez passer à la vitesse supérieure, et donc travailler à une fréquence plus élevée, il faudra le spécifier clairement au microcontrôleur (au travers de ses « fusibles »), et intégrer, par exemple, un oscillateur à quartz externe (l’Atmega16A pouvant tourner jusqu’à 16 MHz).

Remarque : si vous jetez un coup d’œil attentif, vous verrez sur mes photos que ma platine de test est équipée d’un quartz à 8 MHz. Mais en fait, le programme est bien cadencé à 1 MHz, et non 8 MHz, car je n’ai rien touché à la configuration d’origine de l’Atmega16 (ses « fusibles »). Ainsi, le MCU ne prend pas en compte ce qui est branché sur lui (ici un quartz de 8 MHz), et fonctionne donc comme si rien n’était branché sur lui, c’est-à-dire à 1 MHz, sur son oscillateur intégré.

En fait, si vous voulez changer de mode et aller plus vite, comme pour passer de l’oscillateur interne à 1 MHz à un oscillateur externe à quartz ou autre chose, il faudra reprogrammer les « fusibles » du microcontrôleur. À propos, ces fusibles ne sont pas des « fusibles » à proprement parler, comme on pourrait en trouver en automobile, mais plutôt des registres internes au µC. Ces registres, reprogrammables, détiennent en fait toutes les valeurs indiquant au microprocesseur quel type et quelle spécificité d’horloge il devra utiliser, une fois le démarrage de l’Atmega effectué.

Cette étape de reprogrammation des fusibles est d’ailleurs super simple à faire, avec le logiciel « Avrdude » cité plus haut, qui nous a servi à programmer l’ATmega16A. Il s’en charge d’ailleurs à merveille, et en toute simplicité. Par contre, une mauvaise programmation de fusibles peut être lourde de conséquence, en cas d’erreur. Car cela peut mener à ne plus pouvoir vous servir du µC, si l’on fait mal les choses ! Et je n’exagère pas du tout ici, car il est impossible de revenir en arrière, dans certains cas (hormis peut-être avec certains équipements spécifiques, mais qui coûtent parfois excessivement cher).

C’est pourquoi je vous recommande la plus grande prudence si jamais vous envisagez de changer vos fusibles de microcontrôleur, car encore une fois, vous êtes seul responsable des conséquences de vos actes ! Du reste, j’essayerai de vous faire prochainement un article spécifiquement consacré à la programmation des fusibles sur Atmega, afin de vous expliquer tout cela en détail, si j’ai le temps !

✎ Les interfaces de développement plus poussées (Microchip)

Ici, je vous ai présenté une méthode simple, légère, et ultra économique, pour programmer un Atmega16. Maintenant, il faut savoir qu’il existe des IDE « tout prêts », pouvant se charger de tout cela. Par contre, attendez-vous à des programmes particulièrement « lourds » à installer, c’est-à-dire comprenant de très nombreux fichiers à loger sur votre disque dur. Mais comme le but de cet article était avant tout de vous montrer une solution légère, rapide, et détaillée, j’ai préféré vous montrer les « coulisses » en fonctionnant « à l’ancienne », c’est à dire en vous montrant tout ce qui se passe à l’arrière-plan, pour une meilleure compréhension (compilation, upload, programmation, …).

Du reste, au niveau des interfaces de développement, le fabricant Microchip (qui a racheté Atmel) a mis à disposition deux outils pour le grand public, et les professionnels. Il s’agit de :

• L’IDE MPLAB X
• L’IDE Atmel Studio

Vous avez donc le choix, selon vos préférences, de développer dans l’un ou l’autre de ces environnements, ou bien, de faire sans ! Car comme vous le constaterez ici, il y a bien des façons de coder et programmer un microcontrôleur, et cela est l’affaire de chacun, suivant ses goûts et préférences 😉

✎ Les autres microcontrôleurs Atmel AVR

Le tuto que je vous ai présenté ici est transposable pour bon nombre de microcontrôleur AVR de chez Atmel. Ainsi, maîtriser cette façon de faire vous permettra d’être à l’aise sur tous ces types de MCU, tant au niveau programmation, que de leur utilisation. Par contre, il faudra bien évidemment adapter certaines parties du présent tuto, car chaque µC a ses particularités propres (cadence d’horloge, ports d’entrées sorties, registres, …).

Bien entendu, il faudra par ailleurs adapter les différents scripts éventuels fournis ici (compilation, programmation, …), selon vos spécificités, et celles de votre environnement.

✎ Fichiers sources de ce tutoriel

Voici les fichiers sources utilisés dans ce projet :

• le programme Blink en langage C pour microcontrôleur ATmega16A (que vous pouvez éditer tout simplement, avec Notepad++, par exemple)
• le script de compilation (avr-gcc) et de programmation (avrdude) pour Windows 10 (à paramétrer, selon votre environnement)

Voilà, nous voici au terme de cet article concernant la programmation de l’atmega16A. En espérant que tout cela pourra vous être utile, et vous servir dans vos prochains projets !

À très bientôt 😉

JEROME

Passionné par tout ce qui touche à l'électronique, sans toutefois en être expert, j'ai à coeur de vous partager ici, peu à peu, tout ce que j'ai appris, découvert, réalisé, et testé jusqu'à présent ! En espérant que tout cela puisse vous servir, ainsi qu'au plus grand nombre !

(*) Mis à jour le 15/05/2021