Affichage à 7 segments en interface avec le microcontrôleur pic

Ceci est notre 8e tutoriel d' apprentissage des microcontrôleurs PIC utilisant MPLAB et XC8. Nous sommes passés de l'installation de MPLABX à l'utilisation d'un écran LCD avec PIC MCU. Si vous êtes nouveau ici, alors regardez les tutoriels précédents où vous pouvez apprendre les minuteries, les LED clignotantes, l'interface LCD etc. Vous pouvez trouver tous nos Tutoriels PIC ici. Dans notre dernier tutoriel, nous avons vu comment nous pouvons générer des caractères personnalisés avec notre écran LCD 16 * 2, équipons-nous maintenant d'un autre type de module d'affichage appelé écran à 7 segments et l'interfaçons avec le microcontrôleur PIC.

Bien que l'écran LCD 16x2 soit beaucoup plus confortable qu'un écran à 7 segments, il existe peu de scénarios dans lesquels un écran à 7 segments serait plus pratique qu'un écran LCD. L'écran LCD souffre de l'inconvénient d'avoir une faible taille de caractères et sera excessif pour votre projet si vous prévoyez simplement d'afficher des valeurs numériques. Les 7 segments ont également l'avantage contre les mauvaises conditions d'éclairage et peuvent être visualisés sous des angles plus clairs qu'un écran LCD normal. Alors, commençons à le savoir.

Module d'affichage 7 segments et 4 chiffres 7 segments:

L'affichage à 7 segments comporte sept segments et chaque segment a une LED à l'intérieur pour afficher les chiffres en éclairant les segments correspondants. Comme si vous voulez que les 7 segments affichent le nombre «5», vous devez alors briller les segments a, f, g, c et d en mettant leurs broches correspondantes hautes. Il existe deux types d'affichages à 7 segments: Common Cathode et Common Anode, ici nous utilisons un affichage Common Cathode à 7 segments. En savoir plus sur l'affichage à 7 segments ici.

Nous savons maintenant comment afficher le caractère numérique souhaité sur un seul affichage à 7 segments. Mais, il est assez évident que nous aurions besoin de plus d'un affichage à 7 segments pour transmettre toute information à plus d'un chiffre. Ainsi, dans ce didacticiel, nous utiliserons un module d'affichage à 7 segments à 4 chiffres, comme indiqué ci-dessous.

Comme nous pouvons le voir, quatre écrans à sept segments sont connectés ensemble. Nous savons que chaque module à 7 segments aura 10 broches et que pour 4 affichages à sept segments, il y aurait 40 broches au total et il serait mouvementé pour quiconque de les souder sur une carte à points, donc je recommande vivement à quiconque d'acheter un module. ou créez votre propre circuit imprimé pour utiliser un affichage à 7 segments à 4 chiffres. Le schéma de connexion pour le même est illustré ci-dessous:

Pour comprendre comment fonctionne le module à sept segments à 4 chiffres, nous devons examiner les schémas ci-dessus, comme indiqué, les broches A des quatre écrans sont connectées pour se rassembler en un A et de la même manière pour B, C…. jusqu'à DP. Donc, fondamentalement, si le déclencheur A est activé, alors les quatre A devraient aller haut, n'est-ce pas?

Mais cela n'arrive pas. Nous avons quatre broches supplémentaires de D0 à D3 (D0, D1, D2 et D3) qui peuvent être utilisées pour contrôler quel affichage parmi les quatre devrait aller haut. Par exemple: si j'ai besoin que ma sortie soit présente uniquement sur le deuxième écran, alors seulement D1 doit être rendu haut tout en gardant les autres broches (D0, D2 et D3) aussi bas. Nous pouvons simplement sélectionner quel affichage doit devenir actif en utilisant les broches de D0 à D3 et quel caractère à afficher en utilisant les broches de A à DP.

Connexion d'un module à sept segments à 4 chiffres avec un microcontrôleur PIC:

Ici, nous avons utilisé le microcontrôleur PIC PIC16F877A et le schéma du circuit est illustré ci-dessous.

Nous avons 12 broches de sortie du module parmi lesquelles 8 sont utilisées pour afficher les caractères et quatre sont utilisées pour sélectionner un affichage sur quatre. Par conséquent, les 8 broches de caractères sont attribuées à PORTD et les broches de sélection d'affichage sont attribuées aux quatre premières broches de PORTC.

Remarque: la broche de terre du module doit également être connectée à la terre du MCU qui n'est pas représentée ici.

Programmation avec PIC16F877A:

Maintenant que nous savons comment fonctionne réellement ce module, apprenons à programmer PIC16F877A pour lui faire afficher un nombre à 4 chiffres. Incrémentons une variable de 0 à 1000 et imprimons-la sur l'afficheur à 7 segments. Lancez le programme MPLABX et créez un nouveau projet, commençons par les bits de configuration.

#pragma config FOSC = HS // Bits de sélection de l'oscillateur (oscillateur HS) #pragma config WDTE = OFF // Bit d'activation de la minuterie de surveillance (WDT désactivé) #pragma config PWRTE = ON // Bit d'activation de la minuterie de mise sous tension (PWRT activé) # pragma config BOREN = ON // Bit d'activation de réinitialisation de Brown-out (BOR activé) #pragma config LVP = OFF // Bit d'activation de programmation série en circuit basse tension (alimentation simple) (RB3 est E / S numérique, HV activé MCLR doit être utilisé pour la programmation) #pragma config CPD = OFF // Data EEPROM Memory Code Protection Bit (Data EEPROM code protection off) #pragma config WRT = OFF // Flash Program Memory Write Enable bits (Write protection off; all program memory peut être écrit par la commande EECON) #pragma config CP = OFF // Bit de protection de code de mémoire de programme flash (protection de code désactivée)

Comme d'habitude, nous utilisons la fenêtre set configuration bits pour définir ces bits. Si vous n'êtes pas sûr de leur signification, consultez le didacticiel sur le clignotement des LED ici.

Définissons ensuite les broches de sortie pour basculer entre chaque chiffre de l'affichage.

// *** Définit les broches de signal des quatre écrans *** // #define s1 RC0 #define s2 RC1 #define s3 RC2 #define s4 RC3 // *** Fin de la définition ** ////

Ici, les broches RC0, RC1, RC2 et RC3 sont utilisées pour sélectionner entre les quatre chiffres de notre module d'affichage à 7 segments. Ces broches sont définies comme s1, s2, s3 et s4 respectivement.

Passons ensuite à void main (), à l' intérieur de laquelle nous avons la déclaration de variable suivante:

int i = 0; // la valeur à 4 chiffres à afficher int flag = 0; // pour créer un délai non signé int a, b, c, d, e, f, g, h; // juste des variables unsigned int seg = {0X3F, // valeur hexadécimale pour afficher le nombre 0 0X06, // valeur hexadécimale pour afficher le nombre 1 0X5B, // valeur hexadécimale pour afficher le nombre 2 0X4F, // valeur hexadécimale à afficher le nombre 3 0X66, // valeur hexadécimale pour afficher le nombre 4 0X6D, // valeur hexadécimale pour afficher le nombre 5 0X7C, // valeur hexadécimale pour afficher le nombre 6 0X07, // valeur hexadécimale pour afficher le nombre 7 0X7F, / / Valeur hexadécimale pour afficher le nombre 8 0X6F // Valeur hexadécimale pour afficher le nombre 9}; // Fin du tableau pour l'affichage des nombres de 0 à 9

Ici, les variables i et flag sont utilisées pour stocker les valeurs à afficher et créer un retard respectivement. Les variables entières non signées a à h sont utilisées pour diviser les nombres à quatre chiffres en chiffres uniques et les stocker (ce qui sera expliqué plus loin ici).

Une chose clé à noter ici est la déclaration du tableau "seg" . Dans ce programme, nous utilisons un nouveau type de données appelé Array. Array n'est rien d'autre qu'une collection de valeurs de type de données similaires. Ici, nous avons utilisé ce tableau pour stocker toutes les valeurs hexadécimales équivalentes pour afficher un nombre de 0 à 9.

L'adresse du tableau commence toujours à zéro. Donc, ce tableau aura la valeur hexadécimale d'un nombre numérique (0-9) stocké dans l'adresse qui est la même que celle du nombre comme indiqué ci-dessous

Variable:	seg	seg	seg	seg	seg	seg	seg	seg	seg	seg
Code hexadécimal:	0X3F	0X06	0X5B	0X4F	0X66	0X6D	0X7C	0X07	0X7F	0X6F
Eq. Numéro numérique:	0	1	2	3	4	5	6	sept	8	9

Donc simplement, si vous souhaitez afficher le numéro 0 sur votre 7 segments, vous pouvez appeler seg, de même si vous souhaitez afficher le numéro 6, il vous suffit d'utiliser seg.

Pour comprendre comment la valeur HEX a été réellement obtenue, examinons le tableau ci-dessous. La valeur HEX équivalente pour chaque nombre décimal est stockée dans le tableau afin de pouvoir être appelée pour afficher un nombre particulier.

Maintenant, passons à la partie suivante du code qui est la configuration d'E / S:

// ***** Configuration E / S **** // TRISC = 0X00; PORTC = 0X00; TRISD = 0x00; PORTD = 0X00; // *** Fin de la configuration des E / S ** ///

La configuration des E / S est simple car toutes les broches de notre 7 segments sont des broches de sortie et les connexions sont indiquées dans le schéma de circuit ci-dessus, alors déclarez-les simplement comme sorties et initialisez-les à zéro.

Sautons maintenant dans notre boucle infinie (while (1)). Ici, nous devons diviser la valeur de "i" en quatre chiffres et les afficher sur le segment 7. Commençons par diviser la valeur sur "i"

// *** Fractionnement de "i" en quatre chiffres *** // a = i% 10; // 4ème chiffre est enregistré ici b = i / 10; c = b% 10; // 3ème chiffre est enregistré ici d = b / 10; e = d% 10; // Le 2ème chiffre est enregistré ici f = d / 10; g = f% 10; // Le 1er chiffre est enregistré ici h = f / 10; // *** Fin du fractionnement *** //

En utilisant une opération simple de module et de division, le nombre à 4 chiffres (i) est séparé en nombres individuels. Dans notre cas, prenons un exemple où la valeur de "i" est 4578. Puis à la fin de ce processus la variable g = 4, e = 5, c = 7 et a = 8. Alors maintenant, il sera facile d'afficher chaque chiffre en utilisant simplement cette variable.

PORTD = seg; s1 = 1; // Allume l'affichage 1 et imprime le 4ème chiffre __delay_ms (5); s1 = 0; // Désactive l'affichage 1 après un délai de 5 ms PORTD = seg; s2 = 1; // Allume l'affichage 2 et imprime le 3ème chiffre __delay_ms (5); s2 = 0; // Désactive l'affichage 2 après un délai de 5 ms PORTD = seg; s3 = 1; // Allume l'écran 3 et imprime le 2ème chiffre __delay_ms (5); s3 = 0; // Éteint l'affichage 3 après un délai de 5 ms PORTD = seg; s4 = 1; // Allume l'affichage 4 et imprime le 1er chiffre __delay_ms (5); s4 = 0; // Éteint l'affichage 4 après un délai de 5 ms

C'est l'endroit réel où le MCU parle avec le segment 7. Comme nous le savons, nous ne pouvons afficher qu'un seul chiffre à la fois, mais nous avons quatre chiffres à afficher et seulement si les quatre chiffres sont activés, le numéro complet à quatre chiffres sera visible pour l'utilisateur.

Alors, comment allons-nous avec ça?

Heureusement pour nous, notre MCU est beaucoup plus rapide qu'un œil humain, alors ce que nous faisons réellement: nous affichons un chiffre à la fois mais nous le faisons très vite, comme indiqué ci-dessus.

Nous sélectionnons l'affichage à un chiffre, attendons 5 ms pour que le MCU et les 7 segments puissent le traiter, puis désactivons ce chiffre et passons au chiffre suivant et faisons de même jusqu'à ce que nous atteignions le dernier chiffre. Ce retard de 5 ms ne peut pas être observé par un œil humain et les quatre chiffres semblent allumés en même temps.

Voilà, enfin nous incrémentons simplement la valeur du chiffre affiché en utilisant un délai comme indiqué ci-dessous

if (flag> = 100) // attendre que le drapeau atteigne 100 {i ++; flag = 0; // seulement si l'indicateur est cent "i" sera incrémenté} flag ++; // indicateur d'incrémentation pour chaque flash

Le délai est utilisé pour que le temps nécessaire pour passer d'un numéro à un autre soit suffisamment long pour que nous puissions remarquer le changement.

Le code complet est donné ci-dessous et le processus est également expliqué dans la vidéo à la fin.

Configuration et test du matériel:

Comme toujours, simulons le programme à l'aide de Proteus avant d'utiliser notre matériel. Si la simulation réussit, vous devriez voir quelque chose comme ça

Ce projet n'a pas de configuration matérielle compliquée, nous utilisons à nouveau la même carte de microcontrôleur PIC que nous avons créée dans le didacticiel de clignotement des LED. Connectez simplement le module 7 segments avec votre carte microcontrôleur PIC selon le schéma de connexion. Une fois que vous avez terminé avec les connexions, videz simplement le code à l'aide de votre programmeur PicKit 3 et profitez de votre sortie.