Exploration des bases du microcontrôleur

Une chose est formidable à propos des circuits intégrés de microcontrôleur, ils sont disponibles presque partout dans le monde et chez les détaillants électroniques.

introduction

Fondamentalement, les dispositifs à microcontrôleur sont couramment utilisés dans des applications impliquant des évaluations de l'environnement environnant et dans des composants électroniques similaires.

Vous pouvez trouver ces dispositifs utilisés pour afficher un certain paramètre, dans les applications de contrôle de moteur, l'éclairage LED, les capteurs de divers types tels que capteur d'inclinaison, accéléromètre, vélocimètre, enregistreurs de données, contrôleurs de température, claviers, etc.

La compréhension principale concernant les microcontrôleurs pourrait être obtenue en se référant au microcontrôleur AVR Amega32 qui est si avancé qu'il est parfois appelé un ordinateur dans une puce.

Cet appareil est affecté à l'exécution d'une série de commandes pour former un programme.

Le langage du programme que vous verriez ici est C ++. Vous apprendrez cette langue plus en profondeur dans le cours ici.

En ce qui concerne les microcontrôleurs, vous avez la possibilité de contrôler et de configurer tous ses brochages.

Si vous êtes un peu fatigué avec cela, détendez-vous car ce n'est rien du tout complexe, vous serez soulagé de tous les aspects de manière constante mais ferme au fur et à mesure que nous avancerons.

Dans une puce MCU, toutes les broches, à l'exception des Vdd et Vss, qui sont les broches d'alimentation de la puce, peuvent être attribuées avec des désignations exclusives.

Détails du brochage

Si vous regardez la puce du haut, vous trouverez une petite encoche triangulaire qui indique le point de départ du point de départ des brochages, c'est-à-dire que la broche n ° 1 de la puce commence juste sous cette encoche.

À partir de cette broche, vous trouverez 20 broches vers le bas de ce côté (gauche), et 20 autres broches de l'autre côté (droite), en continuant de bas en haut sur le côté droit.

Les 8 premières broches partant de l'encoche sont les PBO-7 qui forment les broches d'index du CI puisque tout programme ici commence par l'index zéro.

La série de brochage ci-dessus est appelée PORT B, alors qu'il existe d'autres ensembles identiques de ports affectés de A à D.

Ces ports pourraient être affectés pour accepter et reconnaître une donnée alimentée appelée INPUT, et aussi pour transmettre des données sous une forme spécifiée appelée OUTPUT.

Deux des broches qui entrent dans la catégorie générale sont les broches (+) / (-) qui sont également appelées Vdd et GND.

Une broche du PORT D (PDO-6) peut être vue située sur le côté gauche de la puce dans la zone inférieure.

PD7 qui est la broche n ° 7 du PORT D pourrait être tracé seul et en commençant la série de brochage du côté droit.

En passant maintenant du côté droit de la puce où se termine le PORT D, le PORT C commence son décompte vers le haut dans l'ordre.

Ceux-ci contribuent aux nombreuses broches intéressantes du MCU, de l'analogique au numérique.

Ces broches sont conçues pour devenir les entrées de détection pour détecter les nombreux paramètres via des étages de circuits analogiques configurés en externe.

Les broches ci-dessus constituent le PORT A.

La conversion analogique-numérique à travers les broches ci-dessus pourrait être comprise à l'aide d'un exemple dans lequel un niveau de température analogique détecté à l'aide d'un capteur ordinaire tel qu'un thermister est appliqué à l'une des broches PORT A qui est facilement acceptée et convertie par le MCU. pour produire une lecture numérique de zéro à 255 degrés F (un chiffre de 8 bits qui pourrait être mis à niveau pour obtenir une sortie de 10 bits).

Une autre caractéristique qui pourrait être observée dans les MCU en plus est l'espace de programmation disponible ou la mémoire qui détermine l'espace pour les variables et le programme spécifiés pour le microcontrôleur.

De plus, les MCU ont une horloge intégrée affectée au comptage des paramètres pertinents.

Les caractéristiques d'horloge permettent au MCU de s'appliquer à de nombreux processus de comptage différents qui pourraient être rapides de l'ordre de quelques microsecondes en fonction de la spécification du dispositif particulier, et pourraient également être plus lents à tous les degrés souhaités.

À présent, vous avez peut-être compris dans une certaine mesure le concept du microcontrôleur et concernant ses ports et ses broches.

Comment créer un connecteur SPI du programmeur au microcontrôleur

Il est maintenant temps d’approfondir un peu le sujet et d’enquêter sur le monde de la programmation.

Cela dit, avant de nous livrer à une procédure de chargement de programme dans la puce, nous devons trouver un moyen approprié d'intégrer le connecteur SPI (Serial Peripheral Interface) avec le MCU.

Cependant, même après cela, nous ne pouvons pas simplement pousser le SPI dans les broches du MCU, n'est-ce pas? Nous ne pouvons pas non plus permettre aux fils prolongés du SPI d'être directement insérés dans la planche à pain. Cela peut également entraîner un réglage incorrect des fils connectés avec des broches incorrectes faisant de mauvaises connexions.

Par conséquent, afin de rendre les choses absolument impeccables, nous effectuons les procédures sur un minuscule veroboard dans lequel nous obtenons les broches métalliques de connexion nécessaires également appelées «en-tête» soudées. Ces broches d'en-tête peuvent maintenant être utilisées pour la connexion avec le connecteur SPI. Les connexions de cet en-tête peuvent être terminées vers d'autres broches d'en-tête parallèles qui peuvent être utilisées pour les connexions de la carte d'essai.

Ainsi, l'assemblage ci-dessus forme maintenant une plate-forme de connexion intermédiaire confortable et fiable pour le SPI au MCU.

Jusqu'à présent, tout a l'air bien et parfait, alors passons à la question du programmeur requis entre votre PC et le MCU.

Il pourrait y avoir une multitude d'entreprises qui fabriquent et vendent ces unités de programmation, donc leur acquisition ne devrait pas vous poser de problème, comme Adafruit Industries, USBtinyISP ou Sparkfun, etc.

Certains d'entre eux peuvent sembler complètement différents des types conventionnels, mais ont fondamentalement tout identique et suivent les règles de programmation standard et peuvent être utilisés comme une interface entre votre PC et le microcontrôleur AVR.

Cependant, assurez-vous de penser que si vous utilisez un autre MCU et non un AVR Atmega32, vous devrez peut-être rechercher un programmeur compatible pour cette puce MCU particulière.

On peut remarquer que bon nombre de ces programmeurs utilisent des pilotes identiques, il faut s’occuper de quelque chose et nous en apprendrons plus dans nos chapitres suivants.

La connexion de votre PC avec la puce du microcontrôleur est vraiment basique, et vous seriez ravi de savoir à quel point la procédure est simple pour cela. Alors appuyons tout de suite sur le boutonJ

Faire la carte d'interface SPI expliquée ci-dessus n'est pas difficile, il s'agit de faire fonctionner votre fer à souder à travers toutes les connexions à travers les deux rangées d'en-tête de broches sur une petite carte à usage général.

La figure ci-dessus montre les détails de connexion que vous devrez suivre lors de l'interconnexion des fils entre les en-têtes.

Pour rendre les choses encore plus simples, passons en revue les détails de connexion suivants pour le même en se référant à l'image ci-dessus:

La broche SPI partant du coin supérieur gauche va vers «Master IN, Slave OUT» (MISO)

La broche SPI du centre gauche se connecte à la broche d'horloge (SCK)

La broche SPI en bas à gauche se joint à la réinitialisation. (Nous en apprendrons plus sur cette épingle dans les didacticiels suivants)

SPI correspondant à la partie inférieure droite se connecte à la broche GND du MCU, GND se réfère à la broche qui forme la ligne d'alimentation zéro ou le rail négatif (relatif) de l'alimentation.

Le SPI se terminant à partir de l'en-tête central droit se connecte à la broche «Master Out, Slave IN» (MOSI) du MCU.

Le SPI sortant de l'en-tête supérieur droit est câblé avec le (+) du MCU qui est bien évidemment le Vdd ou la broche d'alimentation positive du MCU.

C'est tout.

Connectez les deux connecteurs comme expliqué et votre carte d'interface SPI est prête pour les actions requises.

Pour une aide supplémentaire, vous pouvez consulter la figure ci-dessus, votre carte d'interface finale devrait ressembler à ceci une fois que toutes les connexions de câbles sont correctement effectuées à l'aide de la discussion ci-dessus.

J'espère que vous avez peut-être déjà construit l'interface SPI comme expliqué dans le tutoriel précédent, et il est maintenant temps de s'assurer que notre ordinateur accepte le programmeur que nous devons intégrer entre le PC et le MCU.

Création d'un code de programmation simple pour une MCU

Nous prenons une unité USBTinyISP disponible chez Sparkfun, pour relier l'ordinateur au microcontrôleur.

Nous savons que tout système d'exploitation informatique tel que Windows nécessitera des pilotes sans lesquels il serait inutile de charger quoi que ce soit dans l'ordinateur, ainsi notre programmeur aura besoin de pilotes pour se charger dans votre ordinateur.

Jetons un coup d'œil aux procédures requises pour installer les pilotes dans le système d'exploitation de votre ordinateur, nous prenons ici l'exemple du système d'exploitation Windows 7 avec des spécifications 32 bits ou 64 bits.

Ouvrez sparkfun.com et cliquez sur 'Pocket AVR Programmer page'. Le lien peut être facilement visualisé dans la page.

Ensuite, trouvez «Pilote Windows» sous les documents et cliquez simplement dessus.

Cela vous fournira le fichier pocketprog-driver.zip dans votre ordinateur.

Accédez à votre ordinateur, recherchez l'emplacement de téléchargement et décompressez simplement le fichier téléchargé dans un dossier.

Si votre ordinateur est un système d'exploitation 64 bits, vous devez suivre quelques étapes supplémentaires comme indiqué ci-dessous, avec un système d'exploitation 32 bits, vous pouvez directement commencer l'installation à partir du fichier décompressé.

Pour un 64 bits, suivez ces derniers, pour un 32 bits, ignorez simplement:

Google «libusb sourceforge» et cliquez sur cette dernière version de liens.

Vous rencontreriez quelques fichiers supplémentaires, mais vous seriez intéressé de trouver le fichier bib, c'est-à-dire: libusb-win32-bin - #. #. #. #. Zip

Maintenant, allez chercher cet emplacement de téléchargement sur votre ordinateur, décompressez-le et enregistrez-le dans l'un des dossiers.

Dans ce dossier, naviguez sur le dossier bin, en poursuivant vers le dossier amd64.

Vous verriez ici quelques dossiers comme: ghcalled libusb0.dll et libusb0.sys.

Vous voudrez les renommer comme suit: libusb0_x64.dll et libusb0_x64.sys.

Vous devrez maintenant copier les fichiers ci-dessus dans le dossier pocketprog-driver, écraser simplement les fichiers sur la version existante.

Pour installer les pilotes ci-dessus, la méthode suivante qui est plutôt non conventionnelle dans son type vous intéresserait:

C'est un mode «ajouter du matériel hérité».

Cliquez sur «Menu Démarrer»

Puis procédez par un clic droit sur «ordinateur»

Cliquez sur 'Gérer', et enfin sur 'Gestionnaire de périphériques'

Ensuite, dans le menu, choisissez 'Ajouter du matériel hérité'

Continuez et appuyez sur 'suivant', jusqu'à ce que l'assistant soit inséré

En suivant les instructions, cliquez sur «Installer le matériel que vous auriez besoin de sélectionner dans une liste avancée», cela affichera l'icône du bouton radio dans cette sélection particulière. Il s’agit en fait d’un bouton de contrôle Windows qui apparaîtrait maintenant comme un petit cercle avec un limage bleu arrondi à l’intérieur.

Maintenant, cliquez simplement sur 'Suivant'

Cela vous montrera le menu «Afficher tous les appareils» sur lequel vous devrez cliquer.

Après cela, cliquez sur l'icône «Have Disk».

À l'aide de l'icône «Parcourir», accédez à l'emplacement du dossier pocketprog-driver. Si la sélection a été correctement effectuée par vous, vous visualiseriez le fichier pocketprog.inf placé dans ce dossier particulier.

Double-cliquez sur ce fichier et vous assisterez certainement à l'installation du pilote sur votre PC.

Encore et encore !! Continuons avec notre prochain didacticiel sur la page suivante.

À présent, vous avez peut-être installé le logiciel requis et construit l'interface SPI.

Comment transférer un programme dans une puce de microcontrôleur

La prochaine étape nécessitera quelques composants tels qu'une maquette, une LED et une résistance calculée pour l'application prévue.

Dans cette section, nous allons apprendre la méthode de test du programmeur et confirmer l'installation des pilotes appropriés et du logiciel.

Afin de vérifier si les pilotes et le logiciel ont été installés correctement, nous allons mettre en œuvre un programme simple appelé avrdude.

L'AVRdude est un programme associé à la dernière installation de WinAVR sans lequel le transfert réel du fichier dans le MCU ne peut pas être possible.

Ce programme est un format de fichier .hex qui devient essentiellement compréhensible par le MCU pour les exécutions requises.

En cas d'échec de la vérification, le programmeur sera incapable d'effectuer le transfert du fichier.

Voyons rapidement comment nous pouvons mettre en œuvre la procédure de test à l'aide des instructions suivantes:

Ouvrez l'invite DOS (système d'exploitation du disque) en cliquant sur «menu démarrer» et en tapant cmd.exe dans la zone de recherche donnée.

Maintenant, l'exécution de l'AVRdude peut être effectuée en tapant simplement avrdude –c usbtiny –p m32 sur l'invite DOS. Dès que cela est implémenté, le DOS reconnaît instantanément si la connexion a réussi.

Dans la commande ci-dessus, le «-c» est un indicateur de notification qui inclut la spécification du paramètre du programmeur «usbtiny», tandis que le tag «-p» identifie le microcontrôleur («m32 indiquant Atmega32).

Si vous avez utilisé une autre MCU, vous devrez inclure les préfixes pertinents pour l'implémentation.

Une fois la procédure ci-dessus terminée, vous pouvez taper «exit» sur l'invite DOS, ce qui vous fera sortir de la fenêtre.

Si vous vous posez des questions sérieuses concernant les détails de programmation réels, eh bien pour cela, nous devons d'abord souder et construire le circuit LED analogique externe sur lequel le programme pourrait être implémenté, car à moins qu'il n'y ait un système pour accuser réception de la réponse du MCU, la programmation et le fonctionnement du microcontrôleur n'aurait aucun sens.

La fabrication de la carte LED est très simple, il s'agit de souder les deux fils de la LED sur un morceau de veroboard et de connecter la résistance avec l'un des fils de la LED. Le rôle de cette LED est uniquement de limiter le courant de la LED afin qu'elle ne brûle pas en raison de la tension excessive et du courant de la sortie MCU.

La valeur de la résistance peut être calculée en utilisant la formule simple suivante:

R = (Ub - LEDfwd) / I

Où Ub est la tension d'alimentation, LEDfwd est la tension de fonctionnement optimale de la LED utilisée et I est son ampérage optimal.

Supposons que nous utilisons une LED ROUGE qui a une tension directe de LED = 2,5 V et un courant I = 20 mA, l'équation ci-dessus peut être résolue comme suit:

Étant donné que la tension du MCU serait de 5 V, elle peut être exprimée comme suit:

R = (5 - 2.5) /. 02 = 125 ohms, ¼ watt, la valeur la plus proche étant 120 ohms fera l'affaire.

Maintenant, nous avons la LED, une résistance de 120 ohms et un veroboard, interconnectez simplement les composants ci-dessus comme indiqué dans le schéma avec le microcontrôleur.

Une fois que cela est fait, le MCU peut être programmé pour la réponse prévue sur la configuration de LED ci-dessus.

Ensuite, la programmation du MCU.

Afin de permettre au microcontrôleur d'effectuer des implémentations significatives, il est impératif d'écrire des instructions appropriées dans le MCU.

Comment installer un environnement de programmation et étudier WinAVR

Pour cela, nous pourrions probablement utiliser notre propre «éditeur de texte» sur notre PC, bien que nous pourrions apprécier l'utilisation d'un «environnement de programmation» plus professionnel au lieu d'un éditeur de texte ordinaire, simple car cette approche vous permettrait d'en profiter fonctionnalités intéressantes intégrées dans ce package «environnement de programmation».

Il prendrait en charge la création et l'édition de programmes dans différents langages et les compilerait également dans un mode livrable facilement compréhensible et accepté par une puce de microcontrôleur.

En fin de compte, cela serait pris en charge par WinAVR et transféré dans la puce MCU concernée.

WinAVR pourrait également être équipé pour exécuter de nombreuses autres opérations telles que le dépannage des programmes et nous avertir de la syntaxe possible et des erreurs et erreurs de compilation. Nous en discuterons dans nos prochains tutoriels.

Vous voudriez que le cours d'installation de WinAVR soit extrêmement rapide et rapide. Plongeons dans les détails avec les points suivants:

Vous devrez télécharger les dernières versions à partir du dossier WinAVR source forge files. Vous rencontreriez des informations utiles liées à ce téléchargement sur son site officiel.

Vous serez invité à travers une requête de sécurité, de sorte que vous puissiez répondre si vous souhaitez que le téléchargement ait lieu, ceci est demandé que le fichier à télécharger est un fichier exécutable.

Téléchargez le fichier et lancez le processus d'exécution en cliquant dessus. Laissez l'installation commencer.

Le processus vous guidera avec quelques questions auxquelles vous pouvez répondre afin que vous puissiez rationaliser l'installation selon votre confort. Vous voudriez ignorer bon nombre d'entre eux dans leurs formes par défaut, il vous appartient de sélectionner ceux qui vous semblent les mieux adaptés pour les actions.

Jusqu'à présent, vous trouviez tout assez normal et facile à vivre et vous trouviez quelques options dans le menu de démarrage. Pas de soucis, seuls certains d'entre eux utiliseraient en fait un seul des éléments nommés «bloc-notes des programmeurs».

Une fois cliqué sur cette icône, lancera l'interface utilisateur afin que vous puissiez appliquer l'écriture des programmes (comme la création et l'édition). Vous assisterez également au programme composé de commandes de menu pour vous aider à compiler les codes et à les intégrer dans le microcontrôleur.

Le travail fondamental du bloc-notes de programmeur ci-dessus est de transformer un code lisible par l'homme que vous écririez en une série d'instructions compréhensibles uniquement par le MCU.

Le prochain tutoriel couvrira les tests du programmeur ci-dessus afin que nous puissions être sûrs de sa compatibilité avec Windows et s'il 'serre parfaitement la main' avec votre microcontrôleur IC.

Comment programmer un MCU pour allumer une LED

Une fois cela confirmé, nous continuerions à créer un petit code «ne rien faire», juste pour nous assurer que la procédure de transfert de code ne rencontre pas d'erreurs.

Bien sûr, nous sommes maintenant prêts à implémenter notre premier programme à l'intérieur du MCU, mais avant cela, il serait intéressant de résumer rapidement ce que nous avons fait au cours de nos précédents tutoriels:

Nous avons acheté le microcontrôleur AVR Atmel selon nos spécifications requises ici, nous avons utilisé l'ATMega32 pour les illustrations.Nous avons ensuite appris les bases du microcontrôleur et l'unité de programmation qui est responsable du transfert d'un programme dans la puce MCU.

Plus loin, nous avons construit le connecteur d'interface SP qui est indispensable pour que votre ordinateur puisse être relié au microcontrôleur pour les actions de programmation.

Après cela, nous avons confirmé si les pilotes étaient correctement installés sur l'ordinateur pour un système d'exploitation 32 bits et 64 mais.

Ensuite, nous avons installé l'environnement de programmation appelé Win AVR pour faciliter l'écriture facile et le transfert des codes dans le microcontrôleur, suivi de l'implémentation de l'avrdude pour vérifier le programmeur avec votre PC et le microcontrôleur interconnectés.

Enfin, dans le chapitre précédent, nous avons terminé la construction du circuit LED / résistance et l'avons connecté aux sorties MCU appropriées.

C’est en effet beaucoup de travail, mais il est temps de se lancer tout de suite dans de vrais trucs de programmation!

Pour commencer, nous voudrions diviser le microcontrôleur en trois catégories, cela simplifierait beaucoup notre compréhension:

Contrôle, détection et communication

Il serait intéressant de savoir que les fonctions ci-dessus peuvent être programmées de nombreuses manières différentes.

Dans notre premier programme, nous essaierions d'ordonner au microcontrôleur de 'contrôler' un paramètre externe, oui vous avez raison ce serait la LED que nous avons construite récemment.

Pour être précis, nous allons dire au MCU d'allumer la LED connectée, oui, je sais que cela semble assez primitif, mais la phase de démarrage doit toujours être facile.

Aller de l'avant avec le travail actuel, faire du MCU contrôler la LED est en fait assez simple:

Pour cela, nous demandons à la broche n ° 0 du PORT B ​​de produire le 5V requis pour la LED.

Rappelez-vous du tutoriel précédent, nous avons connecté l'anode de la LED à la broche mentionnée ci-dessus du MCU.

Il y a deux choses essentielles à adresser à cette broche du MCU: 1) sortie et 2) 5 volts

Nous allons apprendre un moyen par lequel nous pouvons demander à la broche particulière de devenir la sortie du MCU.

Une fois qu'il est défini pour être la sortie de la puce, nous pouvons lui demander d'être «haut» (5V) ou «bas» (0V) comme souhaité pour une application.

Étant donné que tout circuit logique tel qu'un MCU, les broches pourraient être avec une sortie ou une entrée et pourraient être configurées pour produire un haut logique ou un bas logique, les broches doivent seulement être affectées soit pour être un haut logique soit un bas logique , il n'y a pas d'états intermédiaires ou non définis autres que ces deux états pour les microcontrôleurs ou pour tout circuit intégré numérique d'ailleurs. Il en va de même pour chaque broche du MCU.

En ce qui concerne les affectations des broches d'entrée et de sortie, les entrées seraient positionnées pour accepter les signaux d'étages analogiques externes, tandis que les sorties seraient responsables de les interpréter dans les états logiques spécifiés, ou une fréquence.

Bien que les affectations ci-dessus puissent être effectuées dans de nombreuses méthodes différentes, nous discuterions de l'une d'entre elles par souci de simplicité. Cependant, il faut noter que bien que celui qui serait présenté en ce moment semble facile et intéressant, il n'est pas si viable et n'est pas un type recommandé pour toutes les applications MCU, pour la même raison, vous découvrirez des méthodes de programmation plus populaires plus tard dans le cours. . Ces programmes permettront d'attribuer uniquement les broches souhaitées conformément aux spécifications sans affecter les autres broches adjacentes qui pourraient éventuellement être déjà affectées à d'autres fonctions.

Cependant, pour le moment, nous ne nous soucierons pas autant des autres épingles et n'utiliserons que les épingles pertinentes, évitant ainsi des complications à certains égards.

Pour attribuer une broche en tant que sortie, nous devons utiliser le registre de direction des données (DDR). Si vous vous demandez ce que signifie le registre ici, il s’agit simplement d’un espace dans le MCU qui permet au microcontrôleur de répondre d’une manière spécifiée.

En utilisant le DDR, nous pouvons définir la broche soit pour envoyer des données qui ressemblent à une «sortie», soit pour accepter des données sous la forme d'une «entrée».

Cependant, vous pouvez être confus concernant le mot, qu'est-ce que cela implique? Une donnée ajoute une troisième dimension aux broches qui peuvent être assignées pour être continuellement à zéro logique (0 V) ou logique haut (5 V), mais qu'en est-il des signaux qui pourraient varier rapidement comme une fréquence d'impulsions. Une fréquence serait accompagnée de logiques hautes et basses (5V et 0V) oscillant avec des intervalles ou des périodes spécifiés, elle devient donc orientée dans le temps et peut être ajustée par rapport au temps, c'est pourquoi nous identifions comme «données» signifiant un paramètre qui indique une fonction relative à une autre fonction (états logiques et temps).

Une méthode d'attribution de pin0 en tant que sortie consiste à écrire le code suivant:

DDRB = 0b00000001

Dans le programme ci-dessus, DDRB signifie Data Direction Register for PORT B ​​0b indique au compilateur l'expression binaire suivante d'un nombre tandis que le «1» à la fin de l'expression indique la position du pin0, c'est-à-dire son emplacement sous la forme de la première broche du PORT B.

Si vous vous souvenez, nous avons appris que le PORT B ​​lui associe 8 broches (de 0 à la broche 7), et si vous remarquez que le code ci-dessus contient également 8 chiffres, ce qui signifie que chaque chiffre signifie ces 8 broches du PORT B.

Maintenant, la procédure suivante consiste à attribuer 5V à cette broche (pin0). Là encore, le principe de fonctionnement est identique au DDR comme ci-dessus exprimé à travers le code binaire suivant:

PORTB = 0b00000001

Comme on peut le voir, la seule différence entre le code ci-dessus et le précédent est que dans ce code, nous avons utilisé le registre PORT. Ce registre gère spécifiquement les affectations de broches de ce port particulier pour lequel il a été positionné à l'intérieur du MCU. Ainsi, il nous permet d'affecter les logiques de données réelles (0 ou 1) pour ces brochages.

Maintenant, nous pourrions être intéressés à en discuter concernant les détails approximatifs de notre programme. Comme nous savons que tous les programmes nécessitent un espace particulier pour lancer l'exécution, cela peut être comparé à un chef qui connaît tous les ingrédients d'une recette particulière mais qui ne sait pas par où commencer.

La fonction «principale» est ici l'emplacement où chacun des programmes C / C ++ lance l'exécution. Par conséquent, le main peut être créé comme:

int main (void)
{
}

Cependant, pour permettre au programme d'interpréter les détails des registres DDR et PORT et leur fonctionnement à l'intérieur de la puce MCU, une déclaration supplémentaire doit être incluse qui peut consister en toutes les données concernant l'AVR MCU. Nous voudrions peut-être ajouter cette inclusion à tous nos programmes.

#comprendre
int main (void)
{
}

Dès que la compilation démarre, la section pré-processeur du compilateur se concentre sur le répertoire AVR pour identifier le fichier «io.h». L'extension '.h' indique ici qu'il s'agit d'un fichier d'en-tête, et que ce code à l'intérieur du fichier serait introduit au début (tête) du fichier source en cours de création, d'où le nom 'header'.

Ici, nous pouvons introduire les instructions DDR et PORT dans notre code, car l'ajout du fichier d'en-tête io.h aurait orienté le compilateur à leur sujet.

#comprendre

int main (void)

{

DDRB = 0b00000001 // Réglage du registre de direction des données pin0 sur la sortie et les broches restantes comme entrée

PORTB = 0b00000001 // Régler pin0 sur 5 volts

}

Ce qui précède fixe l'orientation de la pin0 en tant que sortie, ayant une magnitude de 5V. Cependant, il y a toujours un problème qui n'est pas déterminé pour cette broche, à savoir que cette broche n'a pas encore reçu l'instruction de s'allumer indéfiniment tant que le MCU est alimenté. Cette boucle de rétroaction infinie garantirait que cette broche du MCU ne s'éteint pas, mais continue indéfiniment avec la sortie 5V.

Bien qu'il existe de nombreuses méthodes différentes pour appliquer une instruction de boucle à une broche, nous essaierons d'utiliser la boucle «while» ici. Comme son nom l'indique, la boucle «while» indique au microcontrôleur que «tant que» l'alimentation est disponible, vous devez rester activé avec le 5V assigné pour le brochage assigné.

#comprendre

int main (void)

{

DDRB = 0b00000001 // Réglage du registre de direction des données pin0 sur la sortie et les broches restantes comme entrée

PORTB = 0b00000001 // Régler pin0 sur 5 volts

tandis que (1)

{

// Le code serait ici s'il avait besoin de s'exécuter encore et encore et encore ... sans fin

}

}

Vous voudrez peut-être noter que, ici, nous avons utilisé «1» sous la forme d'un argument pour la boucle «while», puisque tout sauf «0» peut être considéré comme un «vrai» logique.

Cela implique que la prise en compte de la boucle «while» ne serait jamais responsable de quoi que ce soit sauf d'un «vrai» logique, ce qui signifie que la broche particulière se verrouillerait indéfiniment avec l'état spécifié.

Il est possible de constater que la LED est allumée en permanence sur la broche attribuée tant que le MCU a reçu une alimentation sur ses Vdd et Vss.

Voilà, maintenant nous avons le résultat que nous voulions obtenir et pouvons enfin le voir se produire après tant de travail acharné, mais néanmoins voir le doux résultat de notre travail acharné est si satisfaisant.

Dans les prochains didacticiels, nous allons apprendre à ajouter une dimension «temps» à la LED ci-dessus, c'est-à-dire comment la faire clignoter à une certaine vitesse spécifiée.

En fait, dans l'implémentation ci-dessus, la LED clignote en fait, mais la vitesse de boucle est si rapide que c'est presque comme un interrupteur permanent sur l'éclairage LED.

Nous allons voir comment cette boucle peut être ajoutée avec un retard comme vous le souhaitez afin de faire clignoter la LED à ce rythme retardé.

Comment faire clignoter une LED à l'aide du microcontrôleur AVR

Dans la dernière discussion, nous avons appris comment allumer une LED via un microcontrôleur, c'était exceptionnel, n'est-ce pas? Peut-être pas tellement!

Ici, nous allons apprendre comment pimenter l'éclairage LED ci-dessus en attribuant une fonctionnalité bidirectionnelle, c'est-à-dire que nous allons essayer de le faire clignoter ou clignoter à une fréquence ou à une vitesse spécifiée. Nous verrons également comment ce taux pourrait être augmenté ou diminué selon les souhaits de l'utilisateur.

Jetons un œil à ceci:

#comprendre

#comprendre

int main (void)

{

DDRB | = 1<< PINB0

tandis que (1)

{

PORTB ^ = 1<< PINB0

_delay_ms (100)

}

}

Si vous vous sentez déconcerté par ces symboles étranges (&, ^, | etc.) utilisés dans l'expression ci-dessus (& n'est pas là mais pourrait être utilisé dans d'autres codes similaires), voici les informations connexes que vous seriez intéressé à connaître à propos de ces :

Il comprend de nombreux algorithmes logiques standard tels que AND, OR, NOT et XOR qui sont généralement utilisés avec le code ci-dessus.

Ces fonctionnalités logiques comparent spécifiquement les deux bits «1» et «0» selon leurs tables de vérité attribuées.

Nous aurons une idée en analysant la disposition des bits suivante:

01001011 et
10001101
équivaut à
00001001

Dans le code ci-dessus & se réfère à AND tel qu'il est utilisé dans la programmation C.

En lisant les lignes verticalement, cela suggère que 0 et 1 sont égaux à 0, 1 et 0 égale également 0, 0 et 0 égale 0, 1 et 1 égale 1. La lecture est aussi simple que cela. Celles-ci sont conformes à la table de vérité d'un opérateur AND.

Si nous évaluons le tableau suivant, il indique le symbole «|» désignant l'utilisation de la fonctionnalité 'OU', le '|' se trouve juste à gauche de «retour arrière» sur le clavier de votre ordinateur:

01001011 |
10001101
équivaut à
11001111

De la même manière, cette table de vérité d'une fonctionnalité logique OU indique que les bits 0 ou 1 sont égaux à 1, 1 ou 0 égale également 1, 0 ou 0 égale 0, tandis que 1 ou 1 est égal à 1.

La combinaison de bits suivante est pour l'opérateur logique XOR noté ^ et peut être étudiée comme nous l'avons fait avec les tables de vérité AND, OR:

01001011 ^
10001101
équivaut à
11000110

Continuons maintenant avec le premier programme et apprenons ce que signifie la ligne suivante:

#comprendre

Grâce à nos didacticiels précédents, nous savons comment l'expression fonctionne, nous ne la réitérerons donc pas, mais elle semble être un nouveau «include» exprimé par #include qui doit être étudié.

Dans ce «include», le delay.h nous permet quelques méthodes simples de mise en œuvre.

Comme son nom l'indique, le delay.h nous permet d'induire un retard dans le programme particulier.

L'expression suivante int main (void) pourrait être omise de la discussion en cours puisque nous l'avons déjà couvert dans nos articles précédents.

Vient ensuite la DDRB modifiée.

Ce qui suit montre la forme antérieure qui n'est pas une meilleure façon d'attribuer les broches puisque toutes les broches de 0 à 7 ont été commutées pour former les entrées. Mais imaginez simplement quelle serait la situation si nous voulions créer un programme plus long nécessitant ces broches pour une autre fonctionnalité? Par exemple, la broche 2 peut être nécessaire pour appliquer une commutation à distance d'un appareil. Dans ce cas, nous n’apprécierions pas d’attribuer la même valeur qu’une entrée uniquement par essais et erreurs. Cela pourrait signifier une réponse incorrecte de la télécommande au récepteur de l'appareil.

DDRB = 0b00000001

Nous voulons plutôt influencer un seul bit, hat pin0 bit, en jetant un coup d'œil à la fonctionnalité «OU», cela pourrait être exécuté via un masquage binaire.

DDRB = DDRB | 0b00000001

Ici, il est voilé avec un masque «OU»: 0b00000001, bien qu'il semble tout à fait être un nombre binaire authentique, au cas où la DDRB précédente par exemple: 0b01001010, alors appliquer un OU à cela via le masquage pourrait donner: 0b01001010 | 0b00000001 = 0b01001011.

La différence résultante, comme on pourrait en témoigner, ne concerne que le pin0, dont les bits ont changé!

La compression de l'instruction ci-dessus encore plus via C ++ donne:

DDRB | = 0b00000001

Cependant, nous constatons qu’il y a encore plus dans le programme donné. Bien que cela puisse sembler tout à fait légitime et évident, nous devrions tirer parti de certaines des déclarations du fichier d'en-tête io.h, en particulier lorsqu'il est fondamentalement créé pour notre commodité?

Donc si «DDRB | = 1<< PINBO, why it’s like that?

1<< PINBO is implemented for applying the masking effect. The “1” indicates what may be introduced inside the mask, while the < < is simply the left shift functionality. It executes exactly as it’s named, and PINBO is the number of locations that the “1” would sequence across the left hand side. To be precise PINBO may be equivalent of a 0.

Nous commençons donc par un 0b00000000, et mettons un «1» pour produire 0b0000001, puis nous le transférons aux positions 0 à gauche, ce qui donne un 0b00000001 exactement identique à celui ci-dessus.

Maintenant, si l'on suppose que c'était PINB4, la déclaration pourrait être exprimée comme 1<< PINB4. I this case the “1” would be pushed to the left 4 locations producing: 0b00010000.

Attention, nous utilisons un index nul, ce qui signifie qu'il y a quatre zéros après le «1».

Passons maintenant à la boucle «while» que nous avions notée à travers la «boucle infinie» plus tôt. Mais peut-être que maintenant nous voulons que le microcontrôleur implémente certaines des exécutions souhaitées. Cela peut être possible uniquement à l'intérieur de la boucle donnée. C’est la boucle où la séquence particulière est répétée encore et encore.

Dans le cas où l'exécution aurait été placée avant la boucle, elle n'aurait été implémentée qu'une seule fois.

Cependant, pour faire clignoter indéfiniment la LED, il faudrait activer / désactiver alternativement le PINB0 dans la boucle. On retrouve ici aussi les retards introduits, sans lesquels le clignotement de la LED serait impossible. Mais cela obligerait la LED à clignoter à une vitesse très rapide difficile à reconnaître à l'œil nu, il faudrait qu'elle ralentisse un peu pour devenir identifiable à nos yeux.

Nous sommes conscients de la procédure de configuration d'un bit particulier dans le nombre binaire, mais nous ne sommes pas sûrs de la méthode d'application d'un bit spécifique «0» au cas où il s'agirait encore d'un «1».

Le programme suivant peut être vu en train de faire cela, mais nous verrons également qu'il peut ne pas être visible dans le programme.

Les deux premières instructions font passer le bit à «1» (5V, la LED s'allume), puis une pause est introduite pendant 100 ms.

Les deux lignes suivantes transforment le bit PINB0 en «0» (tension nulle, voyant éteint), mais désolé, la comparaison AND ne pourra pas exécuter un «0» à partir du bit, mais si nous n'utilisons PAS «~» pour le masque binaire, il pourrait changer tous les 0 en 1 et vice versa.

Cela nous permettra d'influencer uniquement le bit PINB0 et de le basculer sur «0». La parenthèse a été incluse afin de contenir l'exécution du masquage de sorte que l'opération NOT puisse être appliquée à l'ensemble des masques et pas simplement au-dessus du «1» avant le décalage à gauche.<<”.

PORTB | = 1<< PINB0
_delay_ms (100)
PORTB & = ~ (1<< PINB0)
_delay_ms (100)

Afin de créer les délais ON OFF ou les périodes de durée égale, nous pouvons couper les quatre lignes précédentes à deux et appliquer la fonctionnalité XOR à notre avantage. Il faut noter lors d'une exécution XOR une broche assignée à un 1 au cas où elle serait 0 et vice versa. Cette exécution n'influencerait que le PINB0. Comme la commande est parfois appliquée, elle transformerait simplement le bit en l'opposé de la logique existante.

PORTB ^ = 1<< PINB0
_delay_ms (100)

FINI! Votre LED clignoterait maintenant selon le taux défini…. Simple, n'est-ce pas?