7 Segmentanzeige mit Pic-Mikrocontroller

Dies ist unser 8. Tutorial zum Erlernen von PIC-Mikrocontrollern mit MPLAB und XC8. Wir haben uns von der Installation von MPLABX bis zur Verwendung eines LCD mit PIC-MCU weiterentwickelt. Wenn Sie neu hier sind, schauen Sie sich die vorherigen Tutorials an, in denen Sie Timer, blinkende LED, LCD-Schnittstellen usw. lernen können. Alle unsere PIC-Tutorials finden Sie hier. In unserem letzten Tutorial haben wir gesehen, wie wir mit unserem 16 * 2-LCD-Display benutzerdefinierte Zeichen generieren können. Jetzt können wir uns mit einem anderen Anzeigemodul ausstatten, dem 7-Segment-Display, und es mit dem PIC-Mikrocontroller verbinden.

16x2 LCD ist zwar viel komfortabler als 7-Segment-Displays, aber es gibt nur wenige Szenarien, in denen ein 7-Segment-Display handlicher wäre als ein LCD-Display. LCD hat den Nachteil einer geringen Zeichengröße und ist für Ihr Projekt zu viel des Guten, wenn Sie nur einige numerische Werte anzeigen möchten. 7-Segmente haben auch den Vorteil gegenüber schlechten Lichtverhältnissen und können aus größeren Winkeln betrachtet werden als ein normaler LCD-Bildschirm. Also, lasst es uns wissen.

7-Segment- und 4-stelliges 7-Segment-Anzeigemodul:

Die 7-Segment-Anzeige enthält sieben Segmente und jedes Segment enthält eine LED, um die Zahlen durch Aufleuchten der entsprechenden Segmente anzuzeigen. Wenn Sie möchten, dass das 7-Segment die Zahl "5" anzeigt, müssen Sie die Segmente a, f, g, c und d leuchten lassen, indem Sie die entsprechenden Stifte hoch setzen. Es gibt zwei Arten von 7-Segment-Anzeigen: Common Cathode und Common Anode. Hier verwenden wir die 7-Segment-Anzeige von Common Cathode. Erfahren Sie hier mehr über die 7-Segment-Anzeige.

Jetzt wissen wir, wie wir unser gewünschtes numerisches Zeichen auf einer einzelnen 7-Segment-Anzeige anzeigen können. Es ist jedoch ziemlich offensichtlich, dass wir mehr als eine 7-Segment-Anzeige benötigen würden, um Informationen zu übermitteln, die mehr als eine Ziffer haben. In diesem Tutorial verwenden wir also ein 4-stelliges 7-Segment-Anzeigemodul, wie unten gezeigt.

Wie wir sehen können, sind vier Sieben-Segment-Anzeigen miteinander verbunden. Wir wissen, dass jedes 7-Segment-Modul 10 Pins hat und für 4 7-Segment-Displays insgesamt 40 Pins und es für jeden hektisch wäre, sie auf eine Punktplatte zu löten. Ich würde daher jedem empfehlen, ein Modul zu kaufen oder stellen Sie Ihre eigene Platine für die Verwendung eines 4-stelligen 7-Segment-Displays her. Das Verbindungsschema dafür ist unten gezeigt:

Um zu verstehen, wie das 4-stellige Sieben-Segment-Modul funktioniert, müssen wir uns die obigen Schaltpläne ansehen. Wie gezeigt, sind die A-Pins aller vier Anzeigen so verbunden, dass sie für B, C… bis zu DP als ein A und dasselbe zusammengefasst sind. Wenn also Trigger A eingeschaltet ist, sollten alle vier A hoch gehen, oder?

Das passiert aber nicht. Wir haben zusätzliche vier Pins von D0 bis D3 (D0, D1, D2 und D3), mit denen gesteuert werden kann, welche Anzeige von den vier hoch gehen soll. Beispiel: Wenn mein Ausgang nur auf dem zweiten Display vorhanden sein soll, sollte nur D1 hoch eingestellt werden, während andere Pins (D0, D2 und D3) so niedrig gehalten werden. Mit den Pins von D0 bis D3 können wir einfach auswählen, welche Anzeige aktiv werden soll und welches Zeichen mit den Pins von A bis DP angezeigt werden soll.

4-stelliges Sieben-Segment-Modul mit PIC-Mikrocontroller verbinden:

Hier haben wir den PIC-Mikrocontroller PIC16F877A verwendet und das Schema für die Schaltung ist unten gezeigt.

Wir haben 12 Ausgangspins vom Modul, von denen 8 zur Anzeige der Zeichen und vier zur Auswahl einer von vier Anzeigen verwendet werden. Daher sind alle 8 Zeichen-Pins PORTD und die Anzeigeauswahl-Pins den ersten vier PORTC-Pins zugeordnet.

Hinweis: Der Erdungsstift des Moduls sollte auch mit der Erdung der MCU verbunden sein, die hier nicht gezeigt wird.

Programmierung mit PIC16F877A:

Nachdem wir nun wissen, wie dieses Modul tatsächlich funktioniert, lernen wir, wie PIC16F877A so programmiert wird, dass es eine 4-stellige Nummer anzeigt. Erhöhen wir eine Variable von 0 auf 1000 und drucken Sie sie auf der 7-Segment-Anzeige aus. Starten Sie das MPLABX-Programm und erstellen Sie ein neues Projekt. Beginnen wir mit den Konfigurationsbits.

#pragma config FOSC = HS // Oszillatorauswahlbits (HS-Oszillator) #pragma config WDTE = OFF // Watchdog-Timer-Aktivierungsbit (WDT deaktiviert) #pragma config PWRTE = ON // Einschalttimer-Aktivierungsbit (PWRT aktiviert) # Pragma-Konfiguration BOREN = EIN // Brown-Out-Reset-Aktivierungsbit (BOR aktiviert) # Pragma-Konfiguration LVP = AUS // Niederspannungs-Einzelprogrammierung (Einzelversorgung) Serielle Programmierung Aktivierungsbit (RB3 ist digitale E / A, HV ein) Für die Programmierung muss MCLR verwendet werden.) #Pragma config CPD = OFF // Daten-EEPROM-Speichercode-Schutzbit (Daten-EEPROM-Codeschutz aus) #pragma config WRT = OFF // Flash-Programmspeicher Schreibaktivierungsbits (Schreibschutz aus; gesamter Programmspeicher kann von der EECON-Steuerung beschrieben werden) #pragma config CP = OFF // Flash-Programmspeichercode-Schutzbit (Codeschutz aus)

Wie üblich verwenden wir das Fenster zum Setzen von Konfigurationsbits, um diese Bits zu setzen. Wenn Sie sich nicht sicher sind, was sie bedeuten, besuchen Sie das Tutorial zum Blinken der LED hier.

Als nächstes definieren wir die Ausgangspins zum Umschalten zwischen den einzelnen Ziffern der Anzeige.

// *** Definiere die Signalpins aller vier Anzeigen *** // #define s1 RC0 #define s2 RC1 #define s3 RC2 #define s4 RC3 // *** Ende der Definition ** ////

Hier werden die Pins RC0, RC1, RC2 und RC3 zur Auswahl zwischen den vier Ziffern unseres 7-Segment-Anzeigemoduls verwendet. Diese Pins sind als s1, s2, s3 bzw. s4 definiert.

Als nächstes springen wir in void main (), in dem wir die folgende Variablendeklaration haben:

int i = 0; // der 4-stellige Wert, der angezeigt werden soll int flag = 0; // zum Erstellen einer vorzeichenlosen Verzögerung int a, b, c, d, e, f, g, h; // nur Variablen ohne Vorzeichen int seg = {0X3F, // Hex-Wert zur Anzeige der Zahl 0 0X06, // Hex-Wert zur Anzeige der Zahl 1 0X5B, // Hex-Wert zur Anzeige der Zahl 2 0X4F, // Hex-Wert zur Anzeige die Zahl 3 0X66, // Hex-Wert zur Anzeige der Zahl 4 0X6D, // Hex-Wert zur Anzeige der Zahl 5 0X7C, // Hex-Wert zur Anzeige der Zahl 6 0X07, // Hex-Wert zur Anzeige der Zahl 7 0X7F, / / Hex-Wert zur Anzeige der Zahl 8 0X6F // Hex-Wert zur Anzeige der Zahl 9}; // Ende des Arrays zur Anzeige von Zahlen von 0 bis 9

Hier werden die Variablen i und flag zum Speichern der anzuzeigenden Werte und zum Erzeugen einer Verzögerung verwendet. Die vorzeichenlosen Ganzzahlvariablen a bis h werden verwendet, um die vierstelligen Zahlen in einzelne Ziffern zu zerlegen und zu speichern (was später hier erläutert wird).

Eine wichtige Sache, die hier zu beachten ist, ist die Array-Deklaration "seg" . In diesem Programm verwenden wir einen neuen Datentyp namens Array. Array ist nichts anderes als eine Sammlung ähnlicher Datentypwerte. Hier haben wir dieses Array verwendet, um alle äquivalenten Hex-Werte für die Anzeige einer Zahl von 0 bis 9 zu speichern.

Die Adresse des Arrays beginnt immer bei Null. In diesem Array wird also der Hex-Wert einer numerischen Zahl (0-9) in der Adresse gespeichert, die mit der der unten gezeigten Zahl übereinstimmt

Variable:	seg	seg	seg	seg	seg	seg	seg	seg	seg	seg
Hex-Code:	0X3F	0X06	0X5B	0X4F	0X66	0X6D	0X7C	0X07	0X7F	0X6F
Gl. Numerische Nummer:	0	1	2	3	4	5	6	7	8	9

Wenn Sie also die Nummer 0 in Ihrem 7-Segment anzeigen möchten, können Sie seg aufrufen. Wenn Sie die Nummer 6 anzeigen möchten, müssen Sie einfach seg verwenden.

Um zu verstehen, wie der HEX-Wert tatsächlich erhalten wurde, schauen wir uns die folgende Tabelle an. Der äquivalente HEX-Wert für jede Dezimalzahl wird im Array gespeichert, sodass er aufgerufen werden kann, um eine bestimmte Zahl anzuzeigen.

Fahren wir nun mit dem nächsten Teil des Codes fort, der die E / A-Konfiguration darstellt:

// ***** E / A-Konfiguration **** // TRISC = 0X00; PORTC = 0X00; TRISD = 0x00; PORTD = 0X00; // *** Ende der E / A-Konfiguration ** ///

Die E / A-Konfiguration ist einfach, da alle Pins in unserem 7-Segment Ausgangspins sind und die Verbindungen im obigen Schaltplan dargestellt sind. Deklarieren Sie sie einfach als Ausgänge und initialisieren Sie sie auf Null.

Lassen Sie uns nun in unsere Endlosschleife springen (während (1)). Hier müssen wir den Wert von "i" in vier Ziffern aufteilen und im 7-Segment anzeigen. Lassen Sie uns zunächst den Wert auf "i" aufteilen.

// *** Aufteilen von "i" in vier Ziffern *** // a = i% 10; // Hier wird die 4. Ziffer gespeichert b = i / 10; c = b% 10; // Hier wird die 3. Ziffer gespeichert d = b / 10; e = d% 10; // Hier wird die 2. Ziffer gespeichert f = d / 10; g = f% 10; // 1. Ziffer wird hier gespeichert h = f / 10; // *** Ende der Aufteilung *** //

Durch Verwendung einer einfachen Modul- und Divisionsoperation wird die 4-stellige Zahl (i) in einzelne Zahlen getrennt. In unserem Fall nehmen wir ein Beispiel, in dem der Wert von "i" 4578 beträgt. Am Ende dieses Prozesses ist dann die Variable g = 4, e = 5, c = 7 und a = 8. Jetzt ist es einfach, jede Ziffer mit dieser Variablen anzuzeigen.

PORTD = seg; s1 = 1; // Anzeige 1 einschalten und 4. Stelle drucken __delay_ms (5); s1 = 0; // Anzeige 1 nach 5 ms Verzögerung ausschalten PORTD = seg; s2 = 1; // Schalte Anzeige 2 ein und drucke die 3. Ziffer __delay_ms (5); s2 = 0; // Anzeige 2 nach 5 ms Verzögerung ausschalten PORTD = seg; s3 = 1; // Schalte Anzeige 3 ein und drucke die 2. Ziffer __delay_ms (5); s3 = 0; // Anzeige 3 nach 5 ms Verzögerung ausschalten PORTD = seg; s4 = 1; // Schalte Anzeige 4 ein und drucke die erste Ziffer __delay_ms (5); s4 = 0; // Display 4 nach 5ms Verzögerung ausschalten

Dies ist der eigentliche Ort, an dem die MCU mit dem 7-Segment spricht. Wie wir wissen , können wir jeweils nur eine Ziffer anzeigen, es müssen jedoch vier Ziffern angezeigt werden, und nur wenn alle vier Ziffern aktiviert sind, ist die vollständige vierstellige Nummer für den Benutzer sichtbar.

Wie gehen wir damit um?

Glücklicherweise ist unsere MCU sehr viel schneller als ein menschliches Auge. Was wir also tatsächlich tun: Wir zeigen jeweils eine Ziffer an, aber wir tun es sehr schnell, wie oben gezeigt.

Wir wählen eine Ziffernanzeige aus und warten 5 ms, damit die MCU und das 7-Segment sie verarbeiten können. Dann schalten wir diese Ziffer aus und fahren mit der nächsten Ziffer fort und machen dasselbe, bis wir die letzte Ziffer erreichen. Diese Verzögerung von 5 ms kann von einem menschlichen Auge nicht beobachtet werden und alle vier Ziffern schienen gleichzeitig eingeschaltet zu sein.

Das ist es, schließlich erhöhen wir einfach den Wert der angezeigten Ziffer mit einer Verzögerung, wie unten gezeigt

if (flag> = 100) // warte bis das Flag 100 erreicht {i ++; flag = 0; // nur wenn flag hundert ist "i" wird inkrementiert} flag ++; // Inkrement-Flag für jeden Blitz

Die Verzögerung wird verwendet, damit die Zeit für den Wechsel von einer Nummer zur anderen lang genug ist, um die Änderung zu bemerken.

Der vollständige Code ist unten angegeben und der Vorgang wird auch im Video am Ende erläutert.

Hardware-Setup und -Test:

Wie immer lassen Sie uns das Programm mit Proteus simulieren, bevor wir tatsächlich mit unserer Hardware arbeiten. Wenn die Simulation erfolgreich ist, sollten Sie so etwas sehen

Dieses Projekt hat keine komplizierten Hardware-Setups. Wir verwenden wieder dieselbe PIC-Mikrocontroller-Karte, die wir im LED-Blink-Tutorial erstellt haben. Verbinden Sie einfach das 7-Segment-Modul gemäß Anschlussplan mit Ihrer PIC-Mikrocontroller- Karte. Wenn Sie mit den Verbindungen fertig sind, geben Sie den Code einfach mit Ihrem PicKit 3-Programmierer aus und genießen Sie Ihre Ausgabe.