Interface Segment Affichage avec Arduino Nano

Arduino Nano 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 un microcontrôleur Arduino Nano, 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 à sept segments
• 2: broche à sept segments
• 3: Types de sept segments
• 4: Comment vérifier un segment à sept segments est une anode courante ou une cathode commune
• 5: interfaçage à sept segments avec Arduino Nano
• 5.1: schéma
• 5.2: matériel
• 5.3: Installation de la bibliothèque requise
• 6: Contrôlez à sept segments à l'aide de bibliothèque avec Arduino Nano
• 6.1: code
• 6.2: sortie
• 7: Contrôlez à sept segments sans utiliser la bibliothèque Arduino Nano
• 7.1: code
• 7.2: sortie

1: Introduction à sept segments

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 Arduino pour contrôler un affichage à sept segments, l'Arduino 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: broche à 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.

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

4: Comment vérifier un segment à sept segments est une anode courante 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'un des segments brille, 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 segments avec Arduino Nano

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

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

Arduino nano interfaces 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'Arduino Nano sera utilisé pour envoyer des signaux à l'affichage à sept segments, lui indiquant quels segments allument ou désactivent.

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'Arduino Nano, l'affichage à sept segments devrait commencer à afficher les caractères numériques selon le programme.

5.1: schéma

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

Suivant la table Pinout pour la connexion Arduino Nano avec un seul affichage de sept segments:

Code PIN	Nom de broche	Arduino Nano Pin
1	b	D3
2	un	D2
3	Com	GND / VCC dépend de la configuration - Cathode / anode commune
4	F	D7
5	g	D8
6	DP	Broche
7	c	D4
8	Com	GND / VCC dépend de la configuration - Cathode / anode commune
9	d	D5
dix	e	D6

5.2: matériel

L'image ci-dessous montre le matériel d'Arduino Nano 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 Arduino Nano 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 bibliothèque avec Arduino Nano

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

6.1: code

Ouvrez l'IDE et téléchargez le code donné à Arduino Nano:

#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 [] = 2, 3, 4, 5, 6, 7, 8; / * Définissez les broches numériques Arduino 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); / * luminosité à sept segments * /

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 que nous utilisons avec Arduino Nano. Les broches de segment LED sont définies pour les tableaux d'arduino nano. Changez la broche en fonction du type d'Arduino Nano que vous utilisez.

Toutes les épingles numériques Arduino Nano peuvent être utilisées. Ensuite, comme nous utilisons le Anode commune Type, 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 Arduino Nano

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 Arduino Nano. Après cela, téléchargez le code de sept segments donné à Arduino Nano:

int segpins [] = 2, 3, 4, 5, 6, 7, 8; / * broche arduino 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 Arduino Nano 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 VOID LOOP () Fonction Une autre pour Loop est définie, ce 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 en utilisant leur équivalent binaire s'affichent en sept segments.

Conclusion

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