Configuration des bits de fusible du microcontrôleur AVR. Création et téléchargement dans la mémoire flash du microcontrôleur du programme de clignotement des voyants : 5 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:08

Dans ce cas, nous allons créer un programme simple en code C et le graver dans la mémoire du microcontrôleur. Nous allons écrire notre propre programme et compiler le fichier hexadécimal, en utilisant Atmel Studio comme plate-forme de développement intégrée. Nous allons configurer les bits de fusible et télécharger le fichier hexadécimal dans la mémoire du microcontrôleur AVR ATMega328P, en utilisant notre propre programmeur et logiciel AVRDUDE.

AVRDUDE - est un programme pour télécharger et télécharger les mémoires sur puce des microcontrôleurs AVR d'Atmel. Il peut programmer le Flash et l'EEPROM, et lorsqu'il est pris en charge par le protocole de programmation série, il peut programmer les bits de fusible et de verrouillage.

Étape 1: Écriture du programme et compilation du fichier hexadécimal à l'aide d'Atmel Studio

Si vous n'avez pas Atmel Studio, vous devez le télécharger et l'installer:

Ce projet utilisera C, alors sélectionnez l'option Projet exécutable GCC C dans la liste des modèles pour générer un projet exécutable simple.

Ensuite, il est nécessaire de spécifier pour quel appareil le projet sera développé. Ce projet sera développé pour le microcontrôleur AVR ATMega328P.

Tapez le code du programme dans la zone Main Source Editor d'Atmel Studio. L'éditeur de source principal – Cette fenêtre est l'éditeur principal des fichiers source du projet en cours. L'éditeur dispose de fonctions de vérification orthographique et de saisie semi-automatique.

1. Nous devons indiquer au compilateur à quelle vitesse notre puce fonctionne pour qu'elle puisse calculer correctement les retards.

#ifndef F_CPU

#define F_CPU 16000000UL // indiquant la fréquence du cristal du contrôleur (16 MHz AVR ATMega328P) #endif

2. Nous incluons le préambule, où nous mettons nos informations d'inclusion à partir d'autres fichiers, qui définissent les variables globales et les fonctions.

#include //header pour activer le contrôle du flux de données sur les broches. Définit les broches, les ports, etc.

#include // en-tête pour activer la fonction de retard dans le programme

3. Après le préambule vient la fonction main().

int main(void) {

La fonction main() est unique et distincte de toutes les autres fonctions. Chaque programme C doit avoir exactement une fonction main(). Main() est l'endroit où l'AVR commence à exécuter votre code lors de la première mise sous tension, c'est donc le point d'entrée du programme.

4. Définir la broche 0 du PORTB comme sortie.

DDRB=0b00000001; //Définir PORTB1 comme sortie

Pour ce faire, nous écrivons un nombre binaire dans le registre de direction de données B. Le registre de direction de données B nous permet de faire entrer ou sortir les bits du registre B. L'écriture d'un 1 les fait sortir, tandis qu'un 0 les ferait entrer. Étant donné que nous attachons une LED pour agir comme sortie, nous écrivons un nombre binaire, faisant de la broche 0 du PORT B la sortie.

5. Boucle.

tandis que (1) {

Cette instruction est une boucle, souvent appelée boucle principale ou boucle d'événement. Ce code est toujours vrai; par conséquent, il s'exécute encore et encore dans une boucle infinie. Cela ne s'arrête jamais. Par conséquent, la LED clignotera à l'infini, à moins que l'alimentation du microcontrôleur ne soit coupée ou que le code ne soit effacé de la mémoire du programme.

6. Allumez la LED connectée au port PB0

PORTB= 0b00000001; // allume la LED connectée au port PB0

Cette ligne, donne un 1 au PB0 de PortB. PORTB est un registre matériel sur la puce AVR qui contient 8 broches, PB7-PB0, allant de gauche à droite. Mettre un 1 à la fin donne un 1 à PB0; cela met PB0 au niveau haut, ce qui l'allume. Par conséquent, la LED connectée à la broche PB0 s'allumera et s'allumera.

7. Retard

_delay_ms(1000); //crée un délai de 1 seconde

Cette instruction crée un délai d'une seconde, de sorte que la LED s'allume et reste allumée pendant exactement 1 seconde.

8. Désactivez toutes les broches B, y compris PB0

PORTB= 0b00000000; //Désactive toutes les broches B, y compris PB0

Cette ligne désactive les 8 broches du port B, de sorte que même PB0 est désactivé, donc la LED s'éteint.

9. Un autre retard

_delay_ms(1000); //crée un autre délai d'une seconde

Il s'éteint exactement pendant 1 seconde, avant de recommencer la boucle et de rencontrer la ligne, qui le rallume, répétant le processus partout. Cela se produit à l'infini de sorte que la LED clignote constamment.

10. Déclaration de retour

}

retour (0); //cette ligne n'est jamais réellement atteinte }

La dernière ligne de notre code est une instruction return(0). Même si ce code n'est jamais exécuté, car il existe une boucle infinie qui ne se termine jamais, pour nos programmes qui s'exécutent sur des ordinateurs de bureau, il est important que le système d'exploitation sache s'ils ont fonctionné correctement ou non. Pour cette raison, GCC, notre compilateur, veut que chaque main() se termine par un code de retour. Les codes de retour sont inutiles pour le code AVR, qui s'exécute indépendamment de tout système d'exploitation pris en charge; néanmoins, le compilateur lèvera un avertissement si vous ne terminez pas main avec return().

La dernière étape est la construction du projet. Cela signifie compiler et enfin lier tous les fichiers objets pour générer le fichier exécutable (.hex). Ce fichier hexadécimal est généré dans le dossier Debug qui se trouve dans le dossier Project. Ce fichier hexadécimal est prêt à être chargé dans la puce du microcontrôleur.

Étape 2: Modification de la configuration par défaut des bits de fusible du microcontrôleur

Il est important de se rappeler que certains des fusibles peuvent être utilisés pour verrouiller certains aspects de la puce et peuvent potentiellement la briquer (la rendre inutilisable)

Il y a un total de 19 bits de fusible qui sont utilisés dans l'ATmega328P, et ils sont séparés en trois octets de fusible différents. Trois des bits de fusible sont contenus dans l'« octet de fusible étendu », huit sont contenus dans l'« octet de fusible haut » et huit autres sont contenus dans l'« octet de fusible bas ». Il y a aussi un quatrième octet qui est utilisé pour programmer les bits de verrouillage.

Chaque octet est de 8 bits et chaque bit est un paramètre ou un indicateur distinct. Lorsque nous parlons de réglage, pas de réglage, de fusibles programmés, non programmés, nous utilisons en fait du binaire. 1 signifie non défini, non programmé et un zéro signifie défini, programmé. Lors de la programmation des fusibles, vous pouvez utiliser la notation binaire ou plus communément la notation hexadécimale.

Les puces ATmega 328P ont un oscillateur RC intégré qui a une fréquence de 8 MHz. De nouvelles puces sont livrées avec cet ensemble comme source d'horloge et le fusible CKDIV8 actif, ce qui donne une horloge système de 1 MHz. L'heure de démarrage est réglée au maximum et la période de temporisation est activée.

Les nouvelles puces ATMega 328P ont généralement les paramètres de fusible suivants:

Fusible bas = 0x62 (0b01100010)

Fusible haut = 0xD9 (0b11011001)

Fusible étendu = 0xFF (0b11111111)

Nous utiliserons la puce ATmega 328 avec un cristal externe de 16 MHz. Par conséquent, nous devons programmer les bits de "Fuse Low Byte" en conséquence.

1. Les bits 3-0 contrôlent le choix de l'oscillateur, et le réglage par défaut de 0010 consiste à utiliser l'oscillateur RC interne calibré, ce que nous ne voulons pas. Nous voulons que l'oscillateur à cristal de faible puissance fonctionne de 8,0 à 16,0 MHz, donc les bits 3-1 (CKSEL[3:1]) doivent être définis sur 111.

2. Les bits 5 et 4 contrôlent le temps de démarrage, et le paramètre par défaut de 10 correspond à un délai de démarrage de six cycles d'horloge à partir de la mise hors tension et de l'économie d'énergie, plus un délai de démarrage supplémentaire de 14 cycles d'horloge plus 65 millisecondes à partir de la réinitialisation.

Pour être du bon côté pour un oscillateur à cristal de faible puissance, nous voulons le délai maximum possible de 16 000 cycles d'horloge à partir de la mise hors tension et de l'économie d'énergie, donc SUT[1] doit être défini sur 1, plus un délai de démarrage supplémentaire de 14 cycles d'horloge plus 65 millisecondes à partir de la réinitialisation, donc SUT[0] doit être défini sur 1. De plus, CKSEL[0] doit être défini sur 1.

3. Le bit 6 contrôle la sortie d'horloge vers PORTB0, ce dont nous ne nous soucions pas. Ainsi, le bit 6 peut être laissé à 1.

4. Le bit 7 contrôle l'opération de division par 8 et le paramètre par défaut de 0 a la fonctionnalité activée, ce que nous ne voulons pas. Ainsi, le bit 7 doit être modifié de 0 à 1.

Par conséquent, le nouveau Fuse Low Byte doit être 11111111 qui, en notation hexadécimale, est 0xFF

Pour programmer des bits du "Fuse Low Byte", nous pouvons utiliser notre programmeur (https://www.instructables.com/id/ISP-Programmer-fo…) et le logiciel AVRDUDE. AVRDUDE est un utilitaire de ligne de commande qui est utilisé pour télécharger depuis et télécharger vers des microcontrôleurs Atmel.

Télécharger AVRDUDE:

Tout d'abord, nous devons ajouter décrire notre programmeur au fichier de configuration d'AVRDUDE. Sous Windows, le fichier de configuration se trouve généralement au même emplacement que le fichier exécutable d'AVRDUDE.

Collez le texte dans le fichier de configuration avrdude.conf:

# ISPProv1

ID du programmeur = " ISPProgv1"; desc = "coup de port série, reset=dtr sck=rts mosi=txd miso=cts"; type = "serbe"; connection_type = série; réinitialiser = 4; sck = 7; mosi = 3; miso = 8;;

Avant de démarrer l'AVRDUDE, il faut connecter le microcontrôleur au programmateur, selon le schéma

Ouvrez la fenêtre d'invite DOS.

1. Pour afficher la liste des programmeurs pris en charge par avrdude, tapez la commande avrdude -c c. Si tout va bien, la liste devrait avoir l'ID de programmeur "ISPProgv1"

2. Pour afficher la liste des périphériques Atmel pris en charge par avrdude, tapez la commande avrdude -c ISPProgv1. La liste doit contenir le périphérique m328p pour Atmel ATMega 328P.

Ensuite, tapez avrdude -c ISPProgv1 –p m328p, la commande indique à avrdude quel programmeur est utilisé et quel microcontrôleur Atmel est connecté. Il présente la signature ATmega328P en notation hexadécimale: 0x1e950f. Il présente la programmation des bits de fusible actuellement dans l'ATmega328P également en notation hexadécimale; dans ce cas, les octets de fusible sont programmés par défaut d'usine.

Ensuite, tapez avrdude -c ISPProgv1 –p m328p –U lfuse:w:0xFF:m, c'est une commande pour dire à avrdude quel programmeur est utilisé et quel microcontrôleur Atmel est connecté et pour changer l'octet bas du fusible en 0xFF.

Maintenant, le signal d'horloge doit provenir de l'oscillateur à cristal de faible puissance.

Étape 3: gravure du programme dans la mémoire du microcontrôleur ATMega328P

Tout d'abord, copiez le fichier hexadécimal du programme que nous avons créé au début de l'instruction dans le répertoire AVRDUDE.

Ensuite, tapez dans la fenêtre d'invite DOS la commande avrdude –c ISPProgv1 –p m328p –u –U flash:w:[nom de votre fichier hexadécimal]

La commande écrit un fichier hexadécimal dans la mémoire du microcontrôleur. Maintenant, le microcontrôleur fonctionne conformément aux instructions de notre programme. Regardons ça!

Étape 4: Vérifiez que le microcontrôleur fonctionne conformément aux instructions de notre programme

Connectez les composants conformément au schéma du circuit DEL clignotant de l'AVR

Tout d'abord, nous avons besoin de puissance, comme tous les circuits AVR. Une alimentation d'environ 5 volts est suffisante pour le fonctionnement de la puce AVR. Vous pouvez l'obtenir à partir de piles ou d'une alimentation CC. Nous connectons +5V d'alimentation à la broche 7 et connectons la broche 8 à la terre sur la planche à pain. Entre les deux broches, nous plaçons un condensateur céramique de 0,1 F pour lisser la puissance de l'alimentation afin que la puce AVR reçoive une ligne d'alimentation lisse.

La résistance de 10KΩ est utilisée pour fournir une réinitialisation de mise sous tension (POR) à l'appareil. Lorsque l'alimentation est mise sous tension, la tension aux bornes du condensateur sera nulle, de sorte que l'appareil se réinitialise (puisque la réinitialisation est active au niveau bas), puis le condensateur se charge à VCC et la réinitialisation sera désactivée.

Nous connectons l'anode de notre LED à la broche AVR PB0. Il s'agit de la broche 14 de l'ATMega328P. Puisqu'il s'agit d'une LED, nous voulons limiter le courant circulant vers la LED afin qu'elle ne grille pas. C'est pourquoi nous plaçons une résistance de 330Ω en série avec la LED. La cathode de la LED est connectée à la terre.

Un cristal de 16 MHz est utilisé pour fournir une horloge au microcontrôleur Atmega328 et des condensateurs de 22pF sont utilisés pour stabiliser le fonctionnement du cristal.

Ce sont toutes les connexions nécessaires pour allumer la LED. Source de courant.

D'accord. La LED clignote avec un délai d'une seconde. Le travail du microcontrôleur correspond à nos tâches

Étape 5: Conclusion

Certes, c'était un long processus pour simplement faire clignoter une LED, mais la vérité est que vous avez réussi à franchir des obstacles majeurs: créer une plate-forme matérielle pour programmer un microcontrôleur AVR, utiliser Atmel Studio comme plate-forme de développement intégrée, utiliser AVRDUDE comme logiciel pour configurer et programmer un microcontrôleur AVR

Si vous souhaitez vous tenir au courant de mes projets de microcontrôleurs de base, abonnez-vous à mon YouTube ! Regarder et partager mes vidéos est un moyen de soutenir ce que je fais

Abonnez-vous à la chaîne YouTube FOG