Interface Segment Affichage avec Esptop 10 en utilisant Arduino IDE

ESP32 est une plate-forme électronique ouverte populaire qui peut être utilisée pour contrôler et interagir avec une grande variété d'appareils électroniques, y compris des écrans à sept segments. En utilisant le microcontrôleur ESP32, il est possible de contrôler facilement l'état de chaque segment dans un écran à sept segments, permettant la création d'écrans numériques personnalisés et d'autres projets interactifs.

Cet article couvre le contenu suivant:

• 1: Introduction à Seven Segment
• 2: Pinout à sept segments
• 3: Types de sept segments
• 4: Comment vérifier un segment à sept est une anode commune ou une cathode commune
• 5: Interfaçage sept segment avec ESP32
• 5.1: schéma
• 5.2: matériel
• 5.3: Installation de la bibliothèque requise
• 6: Contrôlez sept segments à l'aide de la bibliothèque avec ESP32
• 6.1: code
• 6.2: sortie
• 7: Contrôlez sept segments sans utiliser la bibliothèque ESP32
• 7.1: code
• 7.2: sortie

1: Introduction à Seven Segment

Un segment à sept peut afficher des informations numériques à l'aide d'un programme de microcontrôleur. Il se compose de sept segments individuels, chacun pouvant être illuminé ou éteint indépendamment pour créer divers caractères numériques.

Un affichage de sept segments fonctionne en illuminant différentes combinaisons de ses sept segments pour afficher des caractères numériques. Chaque segment est contrôlé par une broche individuelle, qui peut être activée ou désactivée pour créer le caractère numérique souhaité. Lorsque les segments sont éclairés dans la bonne combinaison, le caractère numérique est visible pour le spectateur.

Lorsque vous utilisez un microcontrôleur ESP32 pour contrôler un écran à sept segments, l'ESP32 envoie des signaux aux broches spécifiques de l'affichage à sept segments, lui indiquant quels segments s'activer ou désactiver afin d'afficher un caractère numérique spécifique.

Cela se fait en écrivant un programme dans l'ide Arduino (Environnement de développement intégré) en utilisant le langage de programmation C ++. Le programme utilise la bibliothèque Arduino pour contrôler l'état de chaque segment avec des commandes simples. Le programme peut également être configuré pour afficher différents caractères numériques en fonction de la saisie des capteurs ou de l'interaction utilisateur.

2: Pinout à sept segments

L'affichage à sept segments a généralement dix broches, avec une broche pour chaque segment, une pour la décimale et deux broches communes. Voici un tableau de l'épinglage typique:

Code PIN	Nom de broche	Description
1	b	Pin LED supérieur à droite
2	un	Pin LED la plus haut
3	VCC / GND	GND / VCC dépend de la configuration - Cathode / anode commune
4	F	Pin LED en haut à gauche
5	g	Broche à LED du milieu
6	DP	Broche
7	c	Pin LED en bas à droite
8	VCC / GND	GND / VCC dépend de la configuration - Cathode / anode commune
9	d	Broche LED inférieure
dix	e	Pin LED en bas à gauche

Chaque segment est étiqueté comme a, b, c, d, e, f et g. La broche commune est généralement utilisée pour contrôler tous les segments à la fois. La broche commune est soit active faible ou active élevée en fonction de l'écran.

3: Types de sept segments

Il existe deux principaux types de sept segments:

• Cathode commune
• Anode commune.

1: dans un cathode commune Affichage, toutes les terminaux négatifs des segments LED sont connectés ensemble.

2: dans un anode commune Affichage, tous les terminaux positifs des segments LED sont connectés.

4: Comment vérifier un segment à sept est une anode commune ou une cathode commune

Pour vérifier le type de sept segments, nous avons juste besoin d'un outil simple - Multimètre. Suivez les étapes pour vérifier le type d'affichage à sept segments:

1. Tenez fermement l'affichage à sept segments et identifiez broche 1 Utilisation du brochage expliqué ci-dessus.
2. Prendre un multimètre. Assumer le plomb rouge pour positif (+) et le plomb noir du multimètre pour négatif (-).
3. Définissez le multimètre sur le test de continuité.
4. Après cette vérification, le travail du compteur peut être vérifié en touchant à la fois des prospects positifs et négatifs. Un son bip sera produit si le compteur fonctionne correctement. Sinon, remplacez les batteries de votre multimètre par une nouvelle.
5. Mettez le plomb noir sur la broche 3 ou 8 du multimètre. Ces deux broches sont communes et connectées en interne. Sélectionnez n'importe quelle broche.
6. Maintenant, mettez le plomb rouge ou positif du multimètre sur d'autres broches de sept segments comme 1 ou 5.
7. Après avoir touché la sonde rouge si un segment brille, l'affichage est un cathode commune.
8. Échangez les fils multimètres si aucun segment ne brille.
9. Connectez maintenant le fil rouge à la broche 3 ou 8.
10. Après cela, a mis un plomb noir ou négatif sur les épingles restantes de l'affichage. Maintenant, si l'une des éclairs du segment, votre affichage est un anode commune, Comme dans l'anode commune, la broche positive est courante, et les autres sont connectés à une alimentation négative.
11. Répétez les étapes pour vérifier tous les autres segments d'affichage un par un.
12. Si l'un des segments ne brille pas, alors ce sera défectueux.

Voici une image de référence pour un test de sept segments en utilisant un multimètre. Nous pouvons voir que le plomb rouge est au COM Pin 8 et le noir est à la broche de segment, donc nous utilisons Anode commune Sept segment:

5: Interfaçage sept segment avec ESP32

Pour interfacer un écran à sept segments avec un ESP32, vous aurez besoin des matériaux suivants:

• Un microcontrôleur ESP32
• Un écran à sept segments
• Une planche à pain
• Fils de cavalier

Interfaces ESP32 avec des écrans à sept segments en plusieurs étapes simples.

1: Tout d'abord, connectez l'écran à sept segments à la planche à pain.

2: Ensuite, connectez l'Arduino Nano à un écran à sept segments à l'aide de fils. L'ESP32 sera utilisé pour envoyer des signaux à l'affichage à sept segments, lui indiquant quels segments s'allumer ou désactiver.

3: Maintenant, écrivez un code Arduino dans ide. Le programme devra envoyer des signaux aux broches spécifiques de l'affichage à sept segments, lui indiquant quels segments s'activer ou désactiver afin d'afficher un caractère numérique spécifique.

4: L'IDE Arduino fournit une bibliothèque à l'aide de laquelle nous pouvons facilement contrôler l'état de chaque segment avec des commandes simples.

5: Une fois le programme écrit et téléchargé sur l'ESP32, l'affichage à sept segments devrait commencer à afficher les caractères numériques selon le programme.

5.1: schéma

Pour programmer sept segments d'abord, nous devons concevoir le circuit et le connecter avec ESP32. L'utilisation du schéma de référence ci-dessous relie votre carte ESP32 avec un affichage à sept segments.

Suivant la table Pinout pour la connexion ESP32 avec un seul écran à sept segments:

Code PIN	Nom de broche	Broche ESP32
1	b	D2
2	un	D15
3	Com	GND / VCC dépend de la configuration - Cathode / anode commune
4	F	D19
5	g	D21
6	DP	Broche
7	c	D4
8	Com	GND / VCC dépend de la configuration - Cathode / anode commune
9	d	D5
dix	e	D18

5.2: matériel

L'image ci-dessous montre le matériel d'ESP32 et de sept segments:

5.3: Installation de la bibliothèque requise

Après avoir connecté sept segments, nous devons installer une bibliothèque dans le IDE Arduino. En utilisant cette bibliothèque, nous pouvons facilement programmer ESP32 avec sept segments.

Aller à la recherche de gestionnaire de bibliothèque pour Sevseg Bibliothèque et l'installez-la dans Arduino IDE.

6: Contrôlez sept segments à l'aide de la bibliothèque avec ESP32

Après avoir installé la bibliothèque, nous écrivons un code Arduino en utilisant la même bibliothèque.

6.1: code

Open IDE et téléchargez le code donné à ESP32:

#include "Sevseg.h "/ * inclus la bibliothèque à sept segments * /
Sevseg Sevseg; / * Créer une bibliothèque de sept segments * /
void setup()

octet Sevensegments = 1; / * Nombre de sept segments connectés * /
octet CommonPins [] = ; / * Définir la broche commune de sept segments * /
BYTE LEDSEGLINGPINS [] = 15, 2, 4, 5, 18, 19, 21; / * Définir ESP32 Digital Pins pour sept segments * /
bool résistantsonsegments = true; / * attribuer un type booléen aux registres du segment sept = * /
sevseg.Begin (Common_anode, Sevensegments, CommonPins, ledSegmentPins, résistances); / * Configuration de sept segments * /
sevseg.SetBrightness (80); / * Sept segments luminosité * /

VOID LOOP ()

pour (int i = 0; i < 10; i++) /*Display number from 0 to 9 using for loop*/

sevseg.setNumber (i);
sevseg.RefreshDisplay (); / * Actualiser l'affichage à sept segments après chaque itération * /
retard (1000); / * Retard de délai pour l'itération de la boucle * /

Code commencé par appeler le Sevseg bibliothèque. Après cela, nous avons défini le nombre de segments, nous utilisons avec ESP32. Les broches de segment LED sont définies pour les cartes ESP32. Modifiez la broche en fonction du type d'ESP32 que vous utilisez.

Toutes les épingles numériques ESP32 peuvent être utilisées.

Ensuite, comme nous utilisons le type d'anode commun, nous l'avons donc défini à l'intérieur du code.

En cas de cathode commune, remplacez-le par le code ci-dessous:

Enfin un pour Une boucle est utilisée qui affichera des chiffres de 0 à 9 et actualisera l'affichage chaque fois qu'un nombre est affiché:

6.2: sortie

Nous pouvons voir sept segments affichant des numéros à partir de 0 à 9:

7: Contrôlez sept segments sans utiliser de bibliothèque avec ESP32

Pour contrôler les sept segments sans aucune bibliothèque, nous devons définir manuellement les nombres à l'intérieur du code Arduino dans leur représentation binaire.

7.1: code

Ouvrir IDE et connecter ESP32. Après cela, téléchargez le code de sept segments donné sur ESP32:

int segpins [] = 15, 2, 4, 5, 18, 19, 21; / * ESP32 PIN pour sept segments * /
BYTE SEGCODE [10] [7] = / * Array du numéro 0-9 dans l'ordre de A de G * /
// a b c d e f g
0, 0, 0, 0, 0, 0, 1, / * afficher 0 * /
1, 0, 0, 1, 1, 1, 1, / * Afficher 1 * /
0, 0, 1, 0, 0, 1, 0, / * afficher 2 * /
0, 0, 0, 0, 1, 1, 0, / * Afficher 3 * /
1, 0, 0, 1, 1, 0, 0, / * Afficher 4 * /
0, 1, 0, 0, 1, 0, 0,, / * afficher 5 * /
0, 1, 0, 0, 0, 0, 0, / * afficher 6 * /
0, 0, 0, 1, 1, 1, 1, / * Afficher 7 * /
0, 0, 0, 0, 0, 0, 0, / * afficher 8 * /
0, 0, 0, 0, 1, 0, 0, / * Afficher 9 * /
;
void DisplayDigit (int digit) / * Fonction pour initialiser chaque segment * /

pour (int a = 0; a < 7; a++)

DigitalWrite (segpins [a], segcode [chiffre] [a]); / * instruisant les segments respectifs pour les nombres de 0 à 9 * /


void setup()

pour (int a = 0; a < 7; a++) // for loop for setting the pins as output*/

pinmode (segpins [a], sortie);


VOID LOOP ()

pour (int b = 0; b < 10; b++)/* generating numbers from 0 to 9 */

DisplayDigit (b); / * affiche les nombres générés * /
retard (1000);

Dans le code ci-dessus d'abord, nous avons défini les broches numériques pour ESP32 où sept segments seront connectés. Un tableau est initialisé pour définir le nombre de 0 à 9.

Suivant à l'intérieur du tableau Les 10 chiffres à partir de 0 à 9 sont définis dans leur représentation binaire.

Suivant dans void setup() La partie A pour la boucle est définie. Ceci pour boucle avec l'aide de pinceau La fonction définit les broches à sept segments sous forme de sortie.

Enfin dans le vide boucle() fonction une autre pour la boucle est définie qui générera un nombre de 0 à 9 chaque fois que le programme s'exécute.

7.2: sortie

Ici, nous pouvons voir tous les nombres définis à l'intérieur du code à l'aide de leur équivalent binaire s'affichent sur sept segments:

Conclusion

En conclusion, l'interfaçage d'un écran à sept segments avec un microcontrôleur ESP32 est un processus simple qui peut être fait avec quelques matériaux de base et un peu de connaissances en programmation. Avec un code ESP32 et Arduino, vous pouvez facilement contrôler l'état de chaque segment dans un écran à sept segments, permettant la création d'écrans numériques personnalisés et d'autres projets interactifs.