7 Segmentanzeige mit Himbeer-Pi

Raspberry Pi ist ein Prozessor-basiertes Board mit ARM-Architektur, das für Elektronikingenieure und Bastler entwickelt wurde. Der PI ist derzeit eine der vertrauenswürdigsten Projektentwicklungsplattformen. Mit höherer Prozessorgeschwindigkeit und 1 GB RAM kann der PI für viele hochkarätige Projekte wie Bildverarbeitung und IoT verwendet werden.

Um hochkarätige Projekte durchführen zu können, muss man die Grundfunktionen von PI verstehen. In diesen Tutorials werden wir alle grundlegenden Funktionen von Raspberry Pi behandeln. In jedem Tutorial werden wir eine der Funktionen von PI diskutieren. Am Ende dieser Raspberry Pi Tutorials-Reihe können Sie Raspberry Pi lernen und selbst gute Projekte erstellen. Gehen Sie die folgenden Tutorials durch:

• Erste Schritte mit Raspberry Pi
• Himbeer-Pi-Konfiguration
• LED Blinkend
• Tastenschnittstelle
• Raspberry Pi PWM-Generation
• LCD-Schnittstelle mit Raspberry Pi
• Gleichstrommotor steuern
• Schrittmotorsteuerung
• Schnittstellenschieberegister
• Raspberry Pi ADC Tutorial
• Servomotorsteuerung
• Kapazitives Touchpad

In diesem Tutorial werden wir die Raspberry Pi 7-Segmentanzeige-Schnittstelle ausführen. Sieben-Segment-Anzeigen sind die billigsten für eine Anzeigeeinheit. Einige dieser zusammen gestapelten Segmente können zur Anzeige von Temperatur, Zählerwert usw. verwendet werden. Wir werden die 7-Segment-Anzeigeeinheit an GPIO von PI anschließen und sie steuern, um die Ziffern entsprechend anzuzeigen. Danach schreiben wir in PYTHON ein Programm für die Anzeige von sieben Segmenten, das von 0 bis 9 zählt und sich auf Null zurücksetzt.

Sieben-Segment-Anzeige:

Es gibt verschiedene Arten und Größen von 7-Segment-Anzeigen. Wir haben Seven Segment ausführlich behandelt. Grundsätzlich gibt es zwei Arten von 7-Segmenten: Common Anode-Typ (Common Positive oder Common VCC) und Common Cathode-Typ (Common Negative oder Common Ground).

Gemeinsame Anode (CA): Hier sind alle negativen Anschlüsse (Kathode) aller 8 LEDs miteinander verbunden (siehe Abbildung unten), die als COM bezeichnet werden. Und alle positiven Anschlüsse bleiben in Ruhe.

Gemeinsame Kathode (CC): Hier sind alle positiven Anschlüsse (Anoden) aller 8 LEDs miteinander verbunden, die als COM bezeichnet werden. Und alle negativen Thermiken bleiben in Ruhe.

Diese Sieben-Segment-Anzeigen von CC und CA sind sehr praktisch, wenn mehrere Zellen zusammen gemultiplext werden. In unserem Tutorial verwenden wir CC oder Common Cathode Seven Segment Display.

Wir haben bereits 7 Segmente mit 8051, mit Arduino und mit AVR interfaced. In vielen unserer Projekte haben wir auch die 7-Segment-Anzeige verwendet.

Wir werden ein wenig über Raspberry Pi GPIO diskutieren, bevor wir fortfahren.

In Raspberry Pi 2 befinden sich 40 GPIO-Ausgangspins. Von 40 können jedoch nur 26 GPIO-Pins (GPIO2 bis GPIO27) programmiert werden (siehe Abbildung unten). Einige dieser Pins erfüllen einige spezielle Funktionen. Mit speziellem GPIO haben wir noch 17 GPIO übrig.

Das + 5,3-V-Signal des GPIO (Pin 1 oder 17) reicht aus, um die 7-Segment-Anzeige anzusteuern. Um eine Strombegrenzung bereitzustellen, verwenden wir für jedes Segment einen Widerstand von 1 kΩ, wie im Schaltplan gezeigt.

Um mehr über GPIO-Pins und ihre aktuellen Ausgänge zu erfahren, gehen Sie wie folgt vor: LED blinkt mit Raspberry Pi

Erforderliche Komponenten:

Hier verwenden wir Raspberry Pi 2 Model B mit Raspbian Jessie OS. Alle grundlegenden Hardware- und Softwareanforderungen wurden bereits erläutert. Sie können sie in der Raspberry Pi-Einführung nachschlagen.

• Verbindungsstifte
• Common Cathode 7-Segmentanzeige (LT543)
• 1KΩWiderstand (8 Stück)
• Steckbrett

Schaltung und Funktionserklärung:

Die Verbindungen, die für die Anzeige des Interfacing 7-Segments mit Raspberry Pi hergestellt werden, sind unten angegeben. Wir haben hier das Common Cathode 7 Segment verwendet:

PIN1 oder e ------------------ GPIO21

PIN2 oder d ------------------ GPIO20

PIN4 oder c ------------------ GPIO16

PIN5 oder h oder DP ---------- GPIO 12 // nicht obligatorisch, da wir keinen Dezimalpunkt verwenden

PIN6 oder b ------------------ GPIO6

PIN7 oder ein ------------------ GPIO13

PIN9 oder f ------------------ GPIO19

PIN10 oder g ---------------- GPIO26

PIN3 oder PIN8 ------------- mit Masse verbunden

Wir werden also 8 GPIO-Pins von PI als 8-Bit-PORT verwenden. Hier ist GPIO13 LSB (Least Significant Bit) und GPIO 12 MSB (Most Significant Bit).

Nun, wenn wir „1“ angezeigt Nummer wollen, müssen wir an die Macht Segmente B und C. Um die Segmente B und C mit Strom zu versorgen, müssen GPIO6 und GPIO16 mit Strom versorgt werden. Das Byte für die Funktion 'PORT' ist also 0b00000110 und der Hex-Wert von 'PORT' ist 0x06. Wenn beide Pins hoch sind, wird „1“ angezeigt.

Wir haben die Werte für jede anzuzeigende Ziffer geschrieben und diese Werte in einer Zeichenfolge mit dem Namen 'DISPLAY' gespeichert (siehe Abschnitt Code unten). Dann haben wir diese Werte einzeln aufgerufen, um die entsprechende Ziffer auf dem Display mit der Funktion 'PORT' anzuzeigen.

Programmiererklärung:

Sobald alles gemäß Schaltplan angeschlossen ist, können wir den PI einschalten, um das Programm in PYHTON zu schreiben.

Wir werden über einige Befehle sprechen, die wir im PYHTON-Programm verwenden werden.

Wir werden die GPIO-Datei aus der Bibliothek importieren. Mit der folgenden Funktion können wir die GPIO-Pins von PI programmieren. Wir benennen auch "GPIO" in "IO" um. Wenn wir also im Programm auf GPIO-Pins verweisen möchten, verwenden wir das Wort "IO".

importiere RPi.GPIO als IO

Manchmal, wenn die GPIO-Pins, die wir verwenden möchten, andere Funktionen ausführen. In diesem Fall erhalten wir während der Ausführung des Programms Warnungen. Der folgende Befehl weist den PI an, die Warnungen zu ignorieren und mit dem Programm fortzufahren.

IO.setwarnings (False)

Wir können die GPIO-Pins von PI entweder anhand der Pin-Nummer an Bord oder anhand ihrer Funktionsnummer referenzieren. Wie 'PIN 29' auf der Karte ist 'GPIO5'. Also sagen wir hier entweder, dass wir den Pin hier durch '29' oder '5' darstellen werden.

IO.setmode (IO.BCM)

Wir setzen 8 GPIO-Pins als Ausgangspins für Daten- und Steuerpins des LCD.

IO.setup (13, IO.OUT) IO.setup (6, IO.OUT) IO.setup (16, IO.OUT) IO.setup (20, IO.OUT) IO.setup (21, IO.OUT) IO.setup (19, IO.OUT) IO.setup (26, IO.OUT) IO.setup (12, IO.OUT)

Wenn die Bedingung in geschweiften Klammern erfüllt ist, werden die Anweisungen in der Schleife einmal ausgeführt. Wenn also das Bit 0 des 8-Bit-Pins wahr ist, ist PIN13 HIGH, andernfalls ist PIN13 LOW. Wir haben acht 'if else'-Bedingungen für Bit0 bis Bit7, so dass die entsprechende LED innerhalb der 7-Segment-Anzeige auf High oder Low gesetzt werden kann, um die entsprechende Nummer anzuzeigen.

if (Pin & 0x01 == 0x01): IO.output (13,1) else: IO.output (13,0)

Dieser Befehl führt die Schleife 10 Mal aus, wobei x von 0 auf 9 erhöht wird.

für x im Bereich (10):

Der folgende Befehl wird als Forever-Schleife verwendet. Mit diesem Befehl werden die Anweisungen in dieser Schleife kontinuierlich ausgeführt.

Während 1:

Alle anderen Funktionen und Befehle wurden im folgenden Abschnitt 'Code' mit Hilfe von 'Kommentare' erläutert.

Nach dem Schreiben und Ausführen des Programms löst der Raspberry Pi die entsprechenden GPIOs aus, um die Ziffer auf der 7-Segment-Anzeige anzuzeigen. Das Programm ist so geschrieben, dass die Anzeige kontinuierlich von 0 bis 9 zählt.