- Erforderliches Material:
- ADC0804 Einkanaliges 8-Bit-ADC-Modul:
- Schaltplan und Erklärung:
- Programmieren des Raspberry Pi:
- Anzeigen des Flex-Sensor-Werts auf dem LCD mit Raspberry 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 Internet der Dinge verwendet werden. Es gibt viele coole Dinge, die mit einem PI gemacht werden können, aber eine traurige Eigenschaft ist, dass es kein eingebautes ADC-Modul hat.
Nur wenn der Raspberry Pi mit Sensoren verbunden werden kann, kann er die realen Parameter kennenlernen und mit ihnen interagieren. Die meisten Sensoren sind analoge Sensoren. Daher sollten wir lernen, einen externen ADC-Modul-IC mit Raspberry Pi zu verwenden, um diese Sensoren miteinander zu verbinden. In diesem Projekt lernen wir, wie wir den Flex-Sensor mit dem Raspberry Pi verbinden und seine Werte auf dem LCD-Bildschirm anzeigen können.
Erforderliches Material:
- Himbeer-Pi (jedes Modell)
- ADC0804 IC
- 16 * 2 LCD-Anzeige
- Flex Sensor
- Widerstände und Kondensatoren
- Steckbrett oder Perf Board.
ADC0804 Einkanaliges 8-Bit-ADC-Modul:
Bevor wir fortfahren, lernen wir diesen ADC0804 IC kennen und wie man ihn mit Himbeer-Pi verwendet. ADC0804 ist ein 8-Bit-IC mit einem Kanal, dh er kann einen einzelnen ADC-Wert lesen und auf digitale 8-Bit-Daten abbilden. Diese 8-Bit-Digitaldaten können vom Raspberry Pi gelesen werden, daher beträgt der Wert 0-255, da 2 ^ 8 256 ist. Wie in den Pinbelegungen des IC unten gezeigt, werden die Pins DB0 bis DB7 zum Lesen dieser Digitaldaten verwendet Werte.
Eine weitere wichtige Sache ist, dass der ADC0804 mit 5 V arbeitet und daher einen Ausgang in einem 5-V-Logiksignal liefert. Bei einem 8-Pin-Ausgang (der 8 Bit darstellt) liefert jeder Pin einen + 5 V-Ausgang, um die logische '1' darzustellen. Das Problem ist also, dass die PI-Logik +3,3 V hat, sodass Sie dem + 3,3-V-GPIO-Pin von PI keine +5-V-Logik geben können. Wenn Sie einen GPIO-Pin von PI mit +5 V versorgen, wird die Karte beschädigt.
Um den Logikpegel von +5 V zu verringern, verwenden wir eine Spannungsteilerschaltung. Wir haben die Spannungsteilerschaltung bereits besprochen und sie zur weiteren Klärung untersucht. Wir werden zwei Widerstände verwenden, um die + 5V-Logik in 2 * 2,5V-Logik zu unterteilen. Nach der Teilung geben wir Raspberry Pi + 2,5 V Logik. Wenn also die logische '1' von ADC0804 dargestellt wird, sehen wir + 2,5 V am PI GPIO-Pin anstelle von + 5 V. Weitere Informationen zu ADC finden Sie hier: Einführung in ADC0804.
Unten sehen Sie das Bild des ADC-Moduls mit ADC0804 , das wir auf Perf Board aufgebaut haben:
Schaltplan und Erklärung:
Das vollständige Schaltbild für die Verbindung des Flex-Sensors mit dem Raspberry Pi ist unten dargestellt. Die Erklärung dafür ist wie folgt.
Diese Himbeer-Pi-Flex-Sensorschaltung scheint mit vielen Drähten etwas komplex zu sein, aber wenn Sie genauer hinschauen, werden die meisten Drähte direkt vom LCD- und 8-Bit-Daten-Pin mit dem Himbeer-Pi verbunden. Die folgende Tabelle hilft Ihnen beim Herstellen und Überprüfen der Verbindungen.
|
Pin Name |
Himbeer-Pin-Nummer |
Raspberry Pi GPIO Name |
|
LCD Vss |
Pin 4 |
Boden |
|
LCD Vdd |
Pin 6 |
Vcc (+ 5 V) |
|
LCD Vee |
Pin 4 |
Boden |
|
LCD Rs |
Pin 38 |
GPIO 20 |
|
LCD RW |
Pin 39 |
Boden |
|
LCD E. |
Pin 40 |
GPIO 21 |
|
LCD D4 |
Pin 3 |
GPIO 2 |
|
LCD D5 |
Pin 5 |
GPIO 3 |
|
LCD D6 |
Pin 7 |
GPIO 4 |
|
LCD D7 |
Pin 11 |
GPIO 17 |
|
ADC0804 Vcc |
Pin 2 |
Vcc (+ 5 V) |
|
ADC0804 B0 |
Pin 19 (bis 5,1 K) |
GPIO 10 |
|
ADC0804 B1 |
Pin 21 (bis 5,1 K) |
GPIO 9 |
|
ADC0804 B2 |
Pin 23 (bis 5,1 K) |
GPIO 11 |
|
ADC0804 B3 |
Pin 29 (bis 5,1 K) |
GPIO 5 |
|
ADC0804 B4 |
Pin 31 (bis 5,1 K) |
GPIO 6 |
|
ADC0804 B5 |
Pin 33 (bis 5,1 K) |
GPIO 13 |
|
ADC0804 B6 |
Pin 35 (bis 5,1 K) |
GPIO 19 |
|
ADC0804 B7 |
Pin 37 (bis 5,1 K) |
GPIO 26 |
|
ADC0804 WR / INTR |
Pin 15 |
GPIO 22 |
Sie können das folgende Bild verwenden, um die Pin-Nummern auf Raspberry seitdem zu bestimmen.
Wie alle ADC-Module benötigt auch der ADC0804-IC ein Taktsignal, um zu funktionieren. Glücklicherweise verfügt dieser IC über eine interne Taktquelle, sodass wir nur die RC-Schaltung zu den CLK-In- und CLK-R-Pins hinzufügen müssen, wie in der Schaltung gezeigt. Wir haben einen Wert von 10K und 105pf verwendet, aber wir können jeden Wert verwenden, der nahe 1uf, 0.1uf, 0.01uf auch funktionieren sollte.
Dann das Flex zu verbinden Sensor wir eine Potentialteilerschaltung mit einem 100K - Widerstand verwendet haben. Wenn der Flex-Sensor gebogen wird, ändert sich der Widerstand und der Potentialabfall über dem Widerstand. Dieser Abfall wird vom ADC0804-IC gemessen und entsprechend 8-Bit-Daten generiert.
Überprüfen Sie andere Projekte im Zusammenhang mit Flex Sensor:
- Flex-Sensor-Schnittstelle mit AVR-Mikrocontroller
- Angry Bird Game Controller auf Arduino-Basis mit Flex Sensor
- Servomotorsteuerung durch Flex-Sensor
- Töne durch Tippen auf die Finger mit Arduino erzeugen
Programmieren des Raspberry Pi:
Sobald wir mit den Verbindungen fertig sind, sollten wir den Status dieser 8-Bit mit Raspberry Pi lesen und sie in Dezimal konvertieren, damit wir sie verwenden können. Das Programm, mit dem Sie dasselbe tun und die resultierenden Werte auf dem LCD-Bildschirm anzeigen können, finden Sie am Ende dieser Seite. Weiter wird der Code unten in kleinen Junks erklärt.
Wir benötigen eine LCD- Bibliothek, um LCD mit Pi zu verbinden. Hierfür verwenden wir die von shubham entwickelte Bibliothek, mit deren Hilfe wir ein 16 * 2-LCD-Display mit einem Pi im Vierdrahtmodus verbinden können. Außerdem benötigen wir Bibliotheken, um Zeit- und Pi-GPIO-Pins zu nutzen.
Hinweis : Die Datei lcd.py sollte von hier heruntergeladen und in demselben Verzeichnis abgelegt werden, in dem dieses Programm gespeichert ist. Erst dann wird der Code kompiliert.
lcd importieren #Importieren Sie die LCD-Bibliothek per [email protected] Importzeit #Importzeit importieren RPi.GPIO als GPIO #GPIO wird nur als GPIO bezeichnet
Die LCD-Pin-Definitionen werden den Variablen wie unten gezeigt zugewiesen. Beachten Sie, dass diese Nummern die GPIO-Pin-Nummern und nicht die tatsächlichen Pin-Nummern sind. In der obigen Tabelle können Sie GPIO-Nummern mit Pin-Nummern vergleichen. Die Array-Binärdatei enthält alle Daten-Pin-Nummern und die Array-Bits speichern den resultierenden Wert aller GPIO-Pins.
#LCD Pin-Definitionen D4 = 2 D5 = 3 D6 = 4 D7 = 17 RS = 20 EN = 21 Binärdateien = (10,9,11,5,6,13,19,26) #Array von Pin-Nummern verbinden sich mit DB0- DB7-Bits = #Ergebniswerte von 8-Bit-Daten
Jetzt müssen wir die Eingangs- und Ausgangspins definieren. Die sieben Datenpins sind der Eingangspin und der Triggerpin (RST und INTR) ist der Ausgangspin. Wir können die 8-Bit-Datenwerte nur dann vom Eingangspin lesen, wenn wir den Ausgangspin gemäß Datenblatt für eine bestimmte Zeit hoch auslösen. Da wir die Binärpins im Binärarray deklariert haben, können wir eine for- Schleife für die Deklaration verwenden, wie unten gezeigt.
für binär in binären: GPIO.setup (binär, GPIO.IN) #Alle binären Pins sind Eingangspins #Trigger-Pin GPIO.setup (22, GPIO.OUT) #WR- und INTR-Pins werden ausgegeben
Mit den Befehlen der LCD-Bibliothek können wir nun das LCD-Modul initialisieren und eine kleine Intro-Meldung anzeigen, wie unten gezeigt.
mylcd = lcd.lcd () mylcd.begin (D4, D5, D6, D7, RS, DE) #Intro-Nachricht mylcd.Print ("Flex Sensor with") mylcd.setCursor (2,1) mylcd.Print ("Raspberry Pi ") time.sleep (2) mylcd.clear ()
Innerhalb der unendlichen während Schleife, beginnen wir die binären Werte wandeln sie in dezimal zu lesen und das Ergebnis auf dem LCD aktualisieren. Wie bereits erwähnt, sollten wir vor dem Lesen der ADC-Werte den Trigger-Pin für eine bestimmte Zeit hoch einstellen, um die ADC-Konvertierung zu aktivieren. Dies erfolgt in den folgenden Zeilen.
GPIO.output (22, 1) #Turn ON Trigger time.sleep (0.1) GPIO.output (22, 0) #Turn OFF Trigger
Jetzt sollten wir die 8-Daten-Pins lesen und das Ergebnis im Bit-Array aktualisieren. Dazu verwenden wir eine for- Schleife, um jeden Eingangspin mit True und False zu vergleichen. Wenn true, wird das jeweilige Bit-Array als 1 erstellt, andernfalls wird es als 0 erstellt. Dies waren alle 8-Bit-Daten, die jeweils zu 0 und 1 der gelesenen Werte gemacht wurden.
#Lesen Sie die Eingangsstifte und aktualisieren Sie das Ergebnis im Bit-Array für i im Bereich (8): if (GPIO.input (binarys) == True): bits = 1 if (GPIO.input (binarys) == False): bits = 0
Sobald wir das Bit-Array aktualisiert haben, sollten wir dieses Array in einen Dezimalwert konvertieren. Dies ist nichts anderes als eine Umwandlung von Binär zu Dezimal. Für 8-Bit-Binärdaten ist 2 ^ 8 256. Wir erhalten also Dezimaldaten von 0 bis 255. In Python wird der Operator "**" verwendet, um die Potenz eines beliebigen Werts zu ermitteln. Da Bits mit MSB beginnen, multiplizieren wir es mit 2 ^ (7-Position). Auf diese Weise können wir alle Binärwerte in Dezimaldaten konvertieren und diese dann auf dem LCD anzeigen
#Berechnen Sie den Dezimalwert mit dem Bit-Array für i im Bereich (8): Dezimal = Dezimal + (Bits * (2 ** (7-i)))
Sobald wir den Dezimalwert kennen, ist es einfach, den Spannungswert zu berechnen. Wir müssen es nur mit 19,63 multiplizieren. Denn für eine 8-Bit-5-VADC ist jedes Bit eine Analogie von 19,3 Millivolt. Der resultierende Spannungswert ist der Wert der Spannung, die an den Pins Vin + und Vin- des ADC0804-IC aufgetreten ist.
# Spannungswert berechnen Spannung = dezimal * 19,63 * 0,001 # Eine Einheit ist 19,3 mV
Anhand des Spannungswerts können wir bestimmen, wie und in welche Richtung der Flex-Sensor gebogen wurde. In den folgenden Zeilen habe ich gerade die gelesenen Spannungswerte mit vorgegebenen Spannungswerten verglichen, um die Position des Flex-Sensors auf dem LCD-Bildschirm anzuzeigen.
#Verspannung und Anzeigestatus des Sensors vergleichen mylcd.setCursor (1,1) if (Spannung> 3,8): mylcd.Print ("Bent Forward") elif (Voltage <3,5): mylcd.Print ("Bent Backward") else: mylcd.Print ("Stabil")
Ebenso können Sie den Spannungswert verwenden, um jede Aufgabe auszuführen, die der Raspberry Pi ausführen soll.
Anzeigen des Flex-Sensor-Werts auf dem LCD mit Raspberry Pi:
Die Arbeit des Projekts ist sehr einfach. Aber stellen Sie sicher, haben Sie die lcd.py heruntergeladen Header - Datei und haben sie im gleichen Verzeichnis platziert, wo Ihr aktuelles Programm vorhanden ist. Stellen Sie dann sicher, dass die Verbindungen im Schaltplan mit einem Steckbrett oder einem Perf-Board angezeigt werden, und führen Sie das folgende Programm auf Ihrem Pi aus, damit Sie arbeiten können. Ihr Setup sollte ungefähr so aussehen.
Wie gezeigt, zeigt das LCD den Dezimalwert, den Spannungswert und die Sensorposition an. Biegen Sie den Sensor einfach vorwärts oder rückwärts und Sie sollten sehen können, wie sich die Spannung und der Dezimalwert ändern. Außerdem wird ein Statustext angezeigt. Sie können jeden Sensor anschließen und feststellen, dass die Spannung über ihm variiert.
Die vollständige Funktionsweise des Tutorials finden Sie im folgenden Video. Ich hoffe, Sie haben das Projekt verstanden und es genossen, etwas Ähnliches zu bauen. Wenn Sie irgendwelche Zweifel haben, lassen Sie sie im Kommentarbereich oder in den Foren und ich werde mein Bestes geben, um sie zu beantworten.