Schnittstelle sieben Segment -Anzeige mit eSptop 10 mit Arduino IDE

ESP32 ist eine beliebte Open-Source-Elektronikplattform, mit der eine Vielzahl von elektronischen Geräten gesteuert und interagiert werden kann, einschließlich sieben Segment-Displays. Durch die Verwendung von ESP32-Mikrocontroller können Sie den Status jedes Segments in einer Anzeige mit sieben Segment problemlos steuern, sodass die Erstellung benutzerdefinierter numerischer Anzeigen und anderer interaktiver Projekte erstellt werden kann.

Dieser Artikel deckt den folgenden Inhalt ab:

• 1: Einführung in Seven Segment
• 2: sieben Segment -Pinout
• 3: Arten von sieben Segment
• 4: So überprüfen Sie ein sieben Segment, der eine gemeinsame Anode oder eine gemeinsame Kathode ist
• 5: sieben Segment mit ESP32 anpassen
• 5.1: Schema
• 5.2: Hardware
• 5.3: Installation der erforderlichen Bibliothek
• 6: Kontrolle von sieben Segment mit der Bibliothek mit ESP32
• 6.1: Code
• 6.2: Ausgabe
• 7: Steuerung sieben Segment ohne Verwendung der Bibliothek ESP32
• 7.1: Code
• 7.2: Ausgabe

1: Einführung in Seven Segment

Ein sieben Segment kann numerische Informationen mit einem Mikrocontroller-Programm anzeigen. Es besteht aus sieben einzelnen Segmenten, von denen jede unabhängig voneinander beleuchtet oder ausgeschaltet werden kann.

Ein sieben Segment-Display funktioniert, indem verschiedene Kombinationen seiner sieben Segmente zur Anzeige numerischer Zeichen beleuchtet werden. Jedes Segment wird durch einen einzelnen Stift gesteuert, der ein- oder ausgeschaltet werden kann, um das gewünschte numerische Zeichen zu erzeugen. Wenn die Segmente in der richtigen Kombination beleuchtet werden, ist der numerische Charakter für den Betrachter sichtbar.

Bei Verwendung eines ESP32-Mikrocontroller zur Steuerung eines Sieben-Segment-Displays sendet der ESP32 Signale an die spezifischen Stifte auf der Anzeige mit sieben Segment.

Dies erfolgt durch das Schreiben eines Programms in der Arduino IDE (integrierte Entwicklungsumgebung) unter Verwendung der C ++ - Programmiersprache. Das Programm nutzt die Arduino -Bibliothek, um den Status jedes Segments mit einfachen Befehlen zu steuern. Das Programm kann auch eingerichtet werden, um verschiedene numerische Zeichen basierend auf Eingaben von Sensoren oder Benutzerinteraktion anzuzeigen.

2: sieben Segment -Pinout

Das sieben Segment-Display hat normalerweise 10 Stifte mit einem Stift für jedes Segment, einen für die Dezimalzahl und zwei gemeinsame Stifte. Hier ist eine Tabelle der typischen Pinout:

PIN Nummer	Pin -Name	Beschreibung
1	B	Obere rechte LED -Stift
2	A	Oberste LED -Stift
3	VCC/GND	GND/VCC hängt von der Konfiguration ab - gemeinsame Kathode/Anode
4	F	Oben linke LED -Stift
5	G	Middle LED -Stift
6	dp	DOT -LED -PIN
7	C	Unten rechte LED -Stift
8	VCC/GND	GND/VCC hängt von der Konfiguration ab - gemeinsame Kathode/Anode
9	D	Untere LED -Stift
10	e	Unten linke LED -Stift

Jedes Segment ist als A, B, C, D, E, F und G gekennzeichnet. Der gemeinsame Stift wird normalerweise verwendet, um alle Segmente gleichzeitig zu kontrollieren. Der gemeinsame Stift ist je nach Anzeige entweder aktiv oder aktiv oder aktiv hoch.

3: Arten von sieben Segment

Es gibt zwei Haupttypen von sieben Segmenten anzeigen:

• Gemeinsame Kathode
• Gemeinsame Anode.

1: in a Gemeinsame Kathode Anzeigen, alle negativen Terminals der LED -Segmente sind miteinander verbunden.

2: in a Gemeinsame Anode Anzeige, alle positiven Terminals der LED -Segmente sind verbunden.

4: So überprüfen Sie ein sieben Segment, der eine gemeinsame Anode oder eine gemeinsame Kathode ist

Um die Art der sieben Segmente zu überprüfen, benötigen wir nur ein einfaches Werkzeug - Multimeter. Befolgen Sie die Schritte, um die Art der sieben Segment-Anzeige zu überprüfen:

1. Halten Sie die sieben Segment-Anzeige fest in der Hand und identifizieren Sie es Pin 1 Verwenden der oben erläuterten Pinout.
2. Nehmen Sie einen Multimeter. Nehmen Sie für positiv rote Blei an (+) und schwarzes Blei von Multimeter für negativ (-).
3. Stellen Sie Multimeter auf den Kontinuitätstest fest.
4. Nach dieser Überprüfung kann die Funktionsweise des Messgeräts überprüft werden, indem sowohl positive als auch negative Leads berührt werden. Ein Piepton -Sound wird erzeugt, wenn das Messgerät ordnungsgemäß funktioniert. Ansonsten ersetzen Sie die Batterien in Ihrem Multimeter durch einen neuen.
5. Legen Sie schwarzer Blei auf Pin 3 oder 8 des Multimeters. Beide Stifte sind häufig und intern verbunden. Wählen Sie einen Stift aus.
6. Stellen Sie nun den roten oder positiven Vorsprung des Multimeters auf andere Stifte von sieben Segmenten wie 1 oder 5 ein.
7. Nach dem Berühren der roten Sonde, wenn ein Segment leuchtet, ist das Display a Gemeinsame Kathode.
8. Wenden Sie die Multimeter -Leads, wenn kein Segment leuchtet.
9. Schließen Sie nun die rote Kleidung an Pin 3 oder 8 an.
10. Danach schwarz oder negatives Blei auf die verbleibenden Stifte des Displays. Wenn nun ein Leuchten des Segments ist, ist Ihr Display a Gemeinsame Anode, Wie in gemeinsamer Anode ist der positive Stift häufig und der Rest ist mit einer negativen Versorgung verbunden.
11. Wiederholen Sie die Schritte, um alle anderen Anzeigensegmente einzeln zu überprüfen.
12. Wenn eines der Segmente nicht leuchtet, ist es fehlerhaft.

Hier ist ein Referenzbild für einen sieben Segment-Test mit a Multimeter. Wir können sehen Gemeinsame Anode sieben Segment:

5: sieben Segment mit ESP32 anpassen

Um ein sieben Segment-Display mit einem ESP32 zu verknüpfen, benötigen Sie die folgenden Materialien:

• Ein ESP32 -Mikrocontroller
• Ein Sieben-Segment-Display
• Ein Brotbrett
• Jumperdrähte

ESP32-Schnittstellen mit sieben Segment-Anzeigen in mehreren einfachen Schritten.

1: Schließen Sie zunächst das Sieben-Segment-Display an das Breadboard an.

2: Schließen Sie den Arduino-Nano als nächstes mit einem sieben Segment-Display mit Drähten an. Der ESP32 wird verwendet, um Signale an das sieben Segment-Display zu senden, wobei er mitteilt, welche Segmente ein- oder ausschalten sollen.

3: Schreiben Sie nun einen Arduino -Code in IDE. Das Programm muss Signal.

4: Die Arduino -IDE bietet eine Bibliothek, mit der wir den Status jedes Segments einfach mit einfachen Befehlen steuern können.

5: Sobald das Programm geschrieben und auf das ESP32 hochgeladen wurde, sollte die Anzeige mit sieben Segment die numerischen Zeichen gemäß dem Programm angezeigt.

5.1: Schema

Um zuerst sieben Segmente zu programmieren, müssen wir die Schaltung entwerfen und mit ESP32 anschließen. Verwenden Sie das folgende Referenzschema, das Ihre ESP32-Karte mit einem sieben Segment-Display verbindet.

Befolgen Sie die Pinout-Tabelle für die ESP32-Verbindung mit einer einzelnen Sieben-Segment-Anzeige:

PIN Nummer	Pin -Name	ESP32 PIN
1	B	D2
2	A	D15
3	Com	GND/VCC hängt von der Konfiguration ab - gemeinsame Kathode/Anode
4	F	D19
5	G	D21
6	dp	DOT -LED -PIN
7	C	D4
8	Com	GND/VCC hängt von der Konfiguration ab - gemeinsame Kathode/Anode
9	D	D5
10	e	D18

5.2: Hardware

Das unten stehende Bild zeigt die Hardware von ESP32 und sieben Segment:

5.3: Installation der erforderlichen Bibliothek

Nachdem wir sieben Segmente angeschlossen haben, müssen wir eine Bibliothek in der Arduino-IDE installieren. Mit dieser Bibliothek können wir ESP32 problemlos mit sieben Segmenten programmieren.

Gehen Sie zur Suche nach Bibliotheksmanager nach Sevseg Bibliothek und installieren Sie es in Arduino IDE.

6: Kontrolle von sieben Segment mit der Bibliothek mit ESP32

Nach der Installation der Bibliothek schreiben wir einen Arduino -Code mit derselben Bibliothek.

6.1: Code

Öffnen Sie die IDE und laden Sie den gegebenen Code auf ESP32 hoch:

#include "Sevseg.H " /*enthalten sieben Segmentbibliothek* /
Sevseg Sevseg; /*Erstellen Sie eine Siebensegmentbibliothek*/
void setup ()

Byte Sevensegmente = 1; /*Anzahl der angeschlossenen sieben Segment*/
Byte CommonPins [] = ; /*Definieren Sie den gemeinsamen Stift von sieben Segment*/
Byte LedSegmentPins [] = 15, 2, 4, 5, 18, 19, 21; /*ESP32 Digitale Pins für sieben Segment definieren*/
bool resistorsonsegmente = true; /*Zuweisen des Booleschen Typs den Registern des sieben = Segments*/
Sevseg.begin (Common_anode, Sevensegmente, CommonPins, LedSegmentpins, Widerständesegmente);/ *Konfiguration von sieben Segment *///
Sevseg.SetBrightness (80); /*Sieben Segmenthelligkeit*///

Hohlraumschleife ()

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

Sevseg.setNumber (i);
Sevseg.RefreshDisplay (); /*Die Anzeige der sieben Segment nach jeder Iteration aktualisieren*/
Verzögerung (1000); /*Zeitverzögerung für die Schleifen -Iteration*/

Code begann mit dem Anruf die Sevseg Bibliothek. Danach haben wir die Anzahl der Segmente definiert, wir verwenden mit ESP32. LED -Segmentstifte sind für ESP32 -Boards definiert. Ändern Sie den PIN gemäß der Art von ESP32, die Sie verwenden.

Jede der ESP32 Digital Pins kann verwendet werden.

Als nächstes verwenden wir den gemeinsamen Anodentyp, sodass wir ihn im Code definiert haben.

Im Falle einer gemeinsamen Kathode ersetzen Sie es durch den folgenden Code:

Endlich a für Die Schleife wird verwendet, wodurch Ziffern von 0 bis 9 angezeigt werden und die Anzeige jedes Mal aktualisiert werden, wenn eine Zahl angezeigt wird:

6.2: Ausgabe

Wir können sieben Segmente sehen, die Zahlen von 0 bis 9 anzeigen:

7: Kontrolle von sieben Segment ohne Bibliothek mit ESP32

Um sieben segmente ohne Bibliothek zu kontrollieren, müssen wir die Zahlen im Arduino-Code in ihrer binären Darstellung manuell definieren.

7.1: Code

Öffnen Sie IDE und verbinden Sie ESP32. Laden Sie den angegebenen Code mit sieben Segment auf ESP32 hoch:

Int Segpins [] = 15, 2, 4, 5, 18, 19, 21;/*ESP32 PIN für sieben Segment*////
Byte Segcode [10] [7] = /*Array von Nummer 0-9 in der Reihenfolge von a von g* /
// a b c d e f g
0, 0, 0, 0, 0, 0, 1, /*Anzeige 0* /
1, 0, 0, 1, 1, 1, 1, /*Anzeige 1* /
0, 0, 1, 0, 0, 1, 0, /*Anzeige 2* /
0, 0, 0, 0, 1, 1, 0, /*Anzeige 3* /
1, 0, 0, 1, 1, 0, 0, /*Anzeige 4* /
0, 1, 0, 0, 1, 0, 0,, /*Anzeige 5* /
0, 1, 0, 0, 0, 0, 0, /*Anzeige 6* /
0, 0, 0, 1, 1, 1, 1, /*Anzeige 7* /
0, 0, 0, 0, 0, 0, 0, /*Anzeige 8* /
0, 0, 0, 0, 1, 0, 0, /*Anzeige 9* /
;
void displayDigit (intstellit) /*Funktion zum Initialisieren jedes Segments* /

für (int a = 0; a < 7; a++)

DigitalWrite (Segpins [a], Segcode [Ziffer] [a]);/ * unterrichten die jeweiligen Segmente für die Zahlen von 0 bis 9 *///


void setup ()

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

PinMode (Segpins [a], Ausgabe);


Hohlraumschleife ()

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

displayDigit (b);/*Zeigen Sie die generierten Zahlen an*/an
Verzögerung (1000);

Im obigen Code haben wir zuerst die digitalen Pins für ESP32 definiert, bei denen sieben Segmente verbunden werden. Ein Array wird initialisiert, um die Zahl von 0 bis 9 zu definieren.

Als nächstes im Array sind alle 10 Ziffern von 0 bis 9 in ihrer binären Darstellung definiert.

Als nächstes in void setup () Teil A für Schleife ist definiert. Dies für Schleife mit Hilfe von PinMode Funktion legt die sieben Segmentstifte als Ausgang fest.

Endlich in Leere Schleife() Funktion Ein weiterer für die Schleife ist definiert, wodurch jedes Mal eine Zahl von 0 bis 9 erstellt wird, wenn das Programm ausgeführt wird.

7.2: Ausgabe

Hier können wir sehen, dass alle im Code definierten Zahlen mit ihrem binären Äquivalent auf sieben Segmenten angezeigt werden:

Abschluss

Zusammenfassend ist ein einfacher Prozess, der mit ein paar grundlegenden Materialien und ein wenig Programmierkenntnissen durchgeführt werden kann. Mit einem ESP32- und Arduino-Code können Sie den Status jedes Segments in einer Anzeige mit sieben Segment problemlos steuern und die Erstellung benutzerdefinierter numerischer Anzeigen und andere interaktive Projekte ermöglichen.