- Schéma:
- Microcontrôleur PIC PIC16F877A LED Code de séquence de clignotement et explication de fonctionnement:
Dans notre tutoriel précédent, nous avons appris à faire clignoter une LED à l'aide du microcontrôleur PIC et avons construit le même circuit sur la carte Perf. Ensuite, nous avons utilisé PICkit 3, ICSP et MPLAB IPE pour transférer le programme sur notre carte Perf. Maintenant, dans ce didacticiel, nous allons progresser vers l'utilisation de plus de broches sur le microcontrôleur PIC. Nous utiliserons 7 sorties (LED) et une entrée. Pour ce tutoriel, nous utiliserons l'ancienne carte Perf (illustrée ci-dessous) et ajouterons des bâtons berg pour retirer les broches requises sur la deuxième carte LED. À la fin de ce tutoriel, nous allons générer une séquence de LED clignotantes à l'aide du microcontrôleur PIC PIC16F877A et apprendre à utiliser plusieurs entrées et sorties, quelques notions de base sur la boucle «for» et l'appel de fonction.
La carte LED n'est rien d'autre qu'une autre carte de performance, sur laquelle nous souderons les LED avec une résistance de limitation de courant (illustrée ci-dessous). Nous ajouterons également un bouton poussoir pour initier le clignotement de la LED de séquence.
Schéma:
Microcontrôleur PIC PIC16F877A LED Code de séquence de clignotement et explication de fonctionnement:
Le code complet a été donné ci-dessous (vérifiez à la fin), ici nous l'obtiendrons ligne par ligne. Ce code commencera à allumer les LED de manière séquentielle lorsque le bouton poussoir est enfoncé. Afin de comprendre les séquences, veuillez regarder la vidéo à la fin du tutoriel. Je vous recommande de comparer la sortie montrée en vidéo avec le code ci-dessous et d'essayer de comprendre le programme.
Regardons le code ligne par ligne. Les premières lignes sont pour la configuration des bits de configuration qui ont été expliqués dans le tutoriel précédent, donc je les saute pour le moment. La meilleure façon de comprendre un programme est de commencer par la fonction main ( void main () ), alors faisons-le
TRISB0 = 1; // Informe le MCU que la broche 0 du PORTB est utilisée comme entrée pour le bouton. TRISD = 0x00; // Informe le MCU que toutes les broches sont sorties PORTD = 0x00; // Initialise toutes les broches à 0
Le mot TRIS est utilisé pour définir si la broche est utilisée comme entrée / sortie et le mot PORT est utilisé pour créer une broche High / Low. La ligne TRISB0 = 1 fera la 0ème broche du PORT B comme entrée. Ce sera notre bouton poussoir. Les lignes TRISD = 0x00; PORTD = 0x00; fera toutes les broches du port D comme sortie et attribuera une valeur initiale de BAS à ces broches.
Puisque nous avons dit que B0 est utilisé comme entrée, nous allons connecter une extrémité du bouton poussoir à la broche B0 et l'autre extrémité à la terre. D'ici là, chaque fois que nous appuierons sur le bouton, la broche sera maintenue à la terre comme indiqué dans le schéma de connexion ci-dessus. Mais pour que cela se produise, nous devons utiliser une résistance de rappel afin que la broche soit maintenue haute lorsque le bouton n'est pas enfoncé. Une résistance pull up est quelque chose comme ça.
Mais notre PIC MCU a une faible résistance de rappel interne qui peut être activée par un logiciel de cette façon, ce qui évite beaucoup de tracas (lorsque plus de boutons doivent être connectés).
Qu'est-ce qu'une résistance pull up faible?
Il existe deux types de résistance pull up, l' un est Weak Pull Up et l'autre est Strong Pull Up. Les résistances de rappel faibles ont une valeur élevée et permettent ainsi à un faible courant de circuler et les résistances de rappel fortes sont de faible valeur, permettant ainsi à un courant fort de circuler. Tous les MCU utilisent principalement des résistances de rappel faibles. Afin de l'activer dans notre PIC MCU, nous devons consulter notre fiche technique pour le OPTION_REG (registre d'options) comme indiqué dans l'instantané ci-dessous.
Comme indiqué, le bit 7 traite de la faible résistance pull up. Il doit être mis à zéro pour l'activer. Ceci est fait par OPTION_REG <7> = 0 . Cela concerne spécifiquement le bit 7 laissant les autres bits à leurs valeurs par défaut. Avec cela, nous entrons dans notre boucle while, où il vérifie si le bouton est enfoncé en utilisant if (RB0 == 0). Si la condition est satisfaite, nous appelons notre fonction avec les paramètres 1, 3, 7 et 15.
sblink (1); // FUNCTION CALL 1 avec paramètre 1 sblink (3); // FUNCTION CALL 3 avec le paramètre 3 sblink (7); // FUNCTION CALL 7 avec le paramètre 7 sblink (15); // FUNCTION CALL 4 avec paramètre 15
Pourquoi utilisons-nous des fonctions?
Les fonctions sont utilisées pour réduire le nombre de lignes dans notre code. C'est ce que la plupart d'entre nous auraient su. Mais pourquoi avons-nous besoin de réduire le nombre de lignes, en particulier en ce qui concerne la programmation MCU. La raison est l'espace limité dans la mémoire de notre programme. Si nous n'optimisons pas correctement le code, nous pourrions manquer d'espace mémoire. Cela sera utile lorsque nous écrivons de longues pages de codes.
Toute fonction aura une fonction Definition ( sblink (int get) dans notre cas) et une fonction Call ( sblink (1) dans notre cas). Il est facultatif d'avoir une déclaration de fonction, pour l'éviter, j'ai placé ma définition de fonction avant d'appeler la fonction dans ma fonction principale.
Les paramètres de fonction sont la valeur qui sera passée de l'appel de fonction à la définition de fonction. Dans notre cas, les valeurs entières (1, 3, 7, 15) sont les paramètres qui sont passés de l'appel de fonction et la variable "get" récupère la valeur des paramètres dans la définition de la fonction pour les traiter. Une fonction peut avoir plus d'un paramètre.
Une fois la fonction appelée, les lignes ci-dessous dans la définition de la fonction seront exécutées.
pour (int i = 0; i <= 7 && RB0 == 0; i ++) {PORTD = get << i; // LED se déplace vers la gauche Séquence __delay_ms (50); } pour (int i = 7; i> = 0 && RB0 == 0; i--) {PORTD = get << i; // LED se déplace vers la gauche Séquence __delay_ms (50); }
Maintenant, cette ligne semble étrange: PORTD = get << i . Je vais expliquer ce qui se passe réellement ici.
"<<" est un opérateur de décalage vers la gauche qui décale tous les bits vers sa position gauche. Maintenant, lorsque nous appelons la fonction sblink (int get) avec le paramètre '1' comme sblink (1), la valeur de 'get' sera 1, ce qui en binaire est 0b00000001. Par conséquent, cette ligne sera comme PORTD = 0b00000001 << i .
La valeur de "i" variera de 0 à 7 puisque nous avons utilisé une 'boucle for ' pour (int i = 0; i <= 7 && RB0 == 0; i ++). La valeur de 'i' comprise entre 0 et 7 changera le résultat comme suit:
Comme vous pouvez le voir, nous avons allumé une LED à la fois (de gauche à droite) en gardant le reste éteint. La prochaine 'boucle for' pour (int i = 7; i> = 0 && RB0 == 0; i--) , fera également la même chose mais cette fois, la LED sera allumée de droite à gauche dans une séquence, comme nous sommes partis de 7 et descendions à 0. Nous avons utilisé un délai de 200 ms pour que nous puissions visualiser la LED allumée et éteinte.
Maintenant, lorsque nous passons la valeur 3 dans la fonction sblink (int get) , la fonction sblink (3) sera exécutée ce qui rend la valeur de 'get' comme 0b00000011, d'où le résultat sur PORTD sera:
Alors maintenant, cette fois, deux LED seront allumées à tout moment en utilisant sblink (3). De même pour sblink (7) et sblink (15), trois et quatre LED seront allumées dans une séquence. Une fois cela terminé, nous allumerons toutes les LED en utilisant la ligne PORTD = 0xFF . Regardez la vidéo ci-dessous pour une démonstration complète.
J'espère que vous avez compris le code et ainsi appris à utiliser les fonctions, les boucles «for» et «while» pour obtenir les sorties souhaitées. Vous pouvez maintenant modifier le code pour obtenir vos différentes séquences de clignotement des LED. Allez-y, compilez votre code et videz-le sur votre MCU et profitez de la sortie. Vous pouvez utiliser la section des commentaires si vous êtes coincé quelque part. J'ai également joint les fichiers de simulation et de programme ici.
C'est tout pour l'instant dans notre prochain tutoriel, nous allons apprendre à utiliser les minuteries PIC16F877A au lieu d'utiliser les fonctions de retard. Vous pouvez parcourir tous les didacticiels du microcontrôleur PIC ici.