Arduino basiert real

Das Oszilloskop ist eines der wichtigsten Werkzeuge, die Sie auf der Werkbank eines Elektronikingenieurs oder -herstellers finden. Es wird hauptsächlich zum Anzeigen der Wellenform und zum Bestimmen von Spannungspegeln, Frequenz, Rauschen und anderen Parametern von Signalen verwendet, die an seinem Eingang angelegt werden und sich im Laufe der Zeit ändern können. Es wird auch von Entwicklern eingebetteter Software zum Debuggen von Code und von Technikern zur Fehlerbehebung bei elektronischen Geräten während der Reparatur verwendet. Diese Gründe machen das Oszilloskop zu einem unverzichtbaren Werkzeug für jeden Ingenieur. Das einzige Problem ist, dass sie sehr teuer sein können. Oszilloskope, die die grundlegendsten Funktionen mit der geringsten Genauigkeit ausführen, können zwischen 45 und 100 US-Dollar kosten, während die fortschrittlicheren und effizienteren über 150 US-Dollar kosten. Heute werde ich zeigen, wie man das Arduino benutztund eine Software, die mit meiner bevorzugten Programmiersprache Python entwickelt wird, um ein kostengünstiges 4-Kanal-Arduino-Oszilloskop zu bauen, das die Aufgaben ausführen kann, für die einige der billigen Oszilloskope eingesetzt werden, wie die Anzeige von Wellenformen und die Bestimmung von Spannungspegeln für Signale.

Wie es funktioniert

Es gibt zwei Teile für dieses Projekt;

Der Datenkonverter
Der Plotter

Oszilloskope beinhalten im Allgemeinen die visuelle Darstellung eines analogen Signals, das an seinen Eingangskanal angelegt wird. Um dies zu erreichen, müssen wir zuerst das Signal von analog nach digital konvertieren und dann die Daten zeichnen. Für die Konvertierung nutzen wir den ADC (Analog-Digital-Wandler) des atmega328p-Mikrocontrollers, mit dem das Arduino die analogen Daten am Signaleingang in ein digitales Signal umwandelt. Nach der Konvertierung wird der Wert pro Zeit über UART vom Arduino an den PC gesendet, wo die mit Python entwickelte Plottersoftware den eingehenden Datenstrom in eine Wellenform konvertiert, indem alle Daten gegen die Zeit geplottet werden.

Erforderliche Komponenten

Die folgenden Komponenten sind erforderlich, um dieses Projekt zu erstellen.

Arduino Uno (Alle anderen Boards können verwendet werden)
Steckbrett
10k Widerstand (1)
LDR (1)
Überbrückungsdrähte

Erforderliche Software

Arduino IDE
Python
Python-Bibliotheken: Pyserial, Matplotlib, Drawnow

Schema

Das Schema für das Arduino-Oszilloskop ist einfach. Alles, was wir tun müssen, ist das zu untersuchende Signal an den angegebenen Analog-Pin des Arduino anzuschließen. Allerdings werden wir die LDR werden unter Verwendung in einer einfachen Spannungsteiler Einrichtung zur Erzeugung des Signals zu untersuchenden, so daß die erzeugte Wellenform des Spannungspegel beschreiben wird, auf der Grundlage der Intensität des Lichts, um die LDR.

Schließen Sie die Komponenten wie in den folgenden Schaltplänen gezeigt an.

Nach dem Anschließen sollte das Setup das folgende Bild mögen.

Wenn alle Verbindungen hergestellt sind, können wir mit dem Schreiben des Codes fortfahren.

Arduino-Oszilloskop-Code

Wir werden Codes für jeden der beiden Abschnitte schreiben. Wie bereits erwähnt, schreiben wir für den Plotter ein Python-Skript, das die Daten vom Arduino über UART und Plots akzeptiert, während wir für den Konverter eine Arduino-Skizze schreiben, die die Daten aus dem ADC aufnimmt und in diese konvertiert Spannungspegel, die an den Plotter gesendet werden.

Python (Plotter) -Skript

Da der Python-Code komplexer ist, werden wir damit beginnen.

Wir werden einige Bibliotheken verwenden, darunter: Drawow, Matplotlib und Pyserial mit dem Python-Skript, wie bereits erwähnt. Mit Pyserial können wir ein Python-Skript erstellen, das über die serielle Schnittstelle kommunizieren kann. Matplotlib bietet uns die Möglichkeit, Diagramme aus den über die serielle Schnittstelle empfangenen Daten zu generieren, und Drawow bietet uns die Möglichkeit, das Diagramm in Echtzeit zu aktualisieren.

Es gibt verschiedene Möglichkeiten, diese Pakete auf Ihrem PC zu installieren, am einfachsten über pip . Pip kann über die Befehlszeile auf einem Windows- oder Linux-Computer installiert werden. PIP ist mit Python3 gepackt, daher empfehle ich Ihnen, Python3 zu installieren und das Kontrollkästchen zum Hinzufügen von Python zum Pfad zu aktivieren. Wenn Sie Probleme mit der Installation von pip haben, finden Sie auf der offiziellen Python-Website Tipps.

Wenn pip installiert ist, können wir jetzt die anderen Bibliotheken installieren, die wir benötigen.

Öffnen Sie die Eingabeaufforderung für Windows-Benutzer, das Terminal für Linux-Benutzer und geben Sie Folgendes ein:

Pip installieren Pyserial

Installieren Sie anschließend matplotlib mit;

pip install matplotlib

Drawnow wird manchmal neben matplotlib installiert, aber um sicherzugehen, führen Sie es aus.

Pip installieren gezeichnet

Nach Abschluss der Installation können wir nun das Python-Skript schreiben.

Das Python-Skript für dieses Projekt ähnelt dem, das ich für das Raspberry Pi Based Oscilloscope geschrieben habe.

Wir importieren zunächst alle für den Code benötigten Bibliotheken.

Importzeit importieren matplotlib.pyplot als plt aus gezeichnetem Import * Import pyserial

Als Nächstes erstellen und initialisieren wir die Variablen, die während des Codes verwendet werden. Der Array- Wert wird zum Speichern der von der seriellen Schnittstelle empfangenen Daten verwendet, und cnt wird zum Zählen verwendet. Daten an Position 0 werden nach jeweils 50 Datenzählungen gelöscht. Dies geschieht, um die Daten auf dem Oszilloskop anzuzeigen.

val = cnt = 0

Als nächstes erstellen wir das serielle Port-Objekt, über das der Arduino mit unserem Python-Skript kommuniziert. Stellen Sie sicher, dass der unten angegebene COM-Port derselbe COM-Port ist, über den Ihre Arduino-Karte mit der IDE kommuniziert. Die oben verwendete Baudrate von 115200 wurde verwendet, um eine Hochgeschwindigkeitskommunikation mit dem Arduino sicherzustellen. Um Fehler zu vermeiden, muss auch die serielle Arduino-Schnittstelle für die Kommunikation mit dieser Baudrate aktiviert sein.

port = serial.Serial ('COM4', 115200, Zeitüberschreitung = 0,5)

Als nächstes machen wir die Handlung interaktiv mit;

plt.ion ()

Wir müssen eine Funktion erstellen, um das Diagramm aus den empfangenen Daten zu generieren. Dabei wird die erwartete Ober- und Mindestgrenze erstellt, die in diesem Fall 1023 beträgt, basierend auf der Auflösung des ADC des Arduino. Wir legen auch den Titel fest, beschriften jede Achse und fügen eine Legende hinzu, um die Identifizierung des Diagramms zu vereinfachen.

#Erstellen Sie die Figurenfunktion def makeFig (): plt.ylim (-1023,1023) plt.title ('Osciloscope') plt.grid (True) plt.ylabel ('ADC-Ausgänge') plt.plot (val, 'ro - ', label =' Channel 0 ') plt.legend (loc =' unten rechts ')

Damit getan, sind wir nun bereit, die Haupt schreiben Schleife , die die Daten von der seriellen Schnittstelle erfolgt, wenn verfügbar und zeichnet es. Zur Synchronisierung mit dem Arduino werden vom Python-Skript Handshake-Daten an das Arduino gesendet, um dessen Bereitschaft zum Lesen von Daten anzuzeigen. Wenn der Arduino die Handshake-Daten empfängt, antwortet er mit Daten vom ADC. Ohne diesen Handschlag können wir die Daten nicht in Echtzeit zeichnen.

while (True): port.write (b's ') # Handshake mit Arduino if (port.inWaiting ()): # wenn das Arduino auf value = port.readline () # antwortet, lesen Sie den Antwortdruck (Wert) #print, damit wir können Monitor it number = int (Wert) # Konvertiert empfangene Daten in Ganzzahldruck ('Kanal 0: {0}'. Format (Nummer)) # Schlaf eine halbe Sekunde. time.sleep (0.01) val.append (int (number)) drawow (makeFig) # Update-Diagramm zur Darstellung der neuen Dateneingabe plt.pause (.000001) cnt = cnt + 1 if (cnt> 50): val.pop (0) # Halten Sie den Plot frisch, indem Sie die Daten an Position 0 löschen

Der vollständige Python-Code für das Arduino-Oszilloskop ist am Ende dieses Artikels angegeben.

Arduino-Code

Der zweite Code ist die Arduino-Skizze, um die Daten zu erhalten, die das Signal vom ADC darstellen, und dann zu warten, bis das Handshake-Signal von der Plottersoftware empfangen wird. Sobald es das Handshake-Signal empfängt, sendet es die erfassten Daten über UART an die Plottersoftware.

Wir beginnen mit der Deklaration des Pins des Analogpins des Arduino, an den das Signal angelegt wird.

int sensorpin = A0;

Als nächstes initialisieren und starten wir die serielle Kommunikation mit einer Baudrate von 115200

void setup () { // initialisiere die serielle Kommunikation mit 115200 Bit pro Sekunde, um der des Python-Skripts zu entsprechen: Serial.begin (115200); }}

Zuletzt die Funktion voidloop () , die das Lesen der Daten übernimmt und die Daten seriell an den Plotter sendet.

void loop () { // lese den Eingang an analogem Pin 0: float sensorValue = analogRead (sensorpin); Byte-Daten = Serial.read (); if (data == 's') { Serial.println (sensorValue); Verzögerung (10); // Verzögerung zwischen den Lesevorgängen für Stabilität } }

Der vollständige Arduino-Oszilloskop-Code ist unten sowie am Ende dieses unten gezeigten Artikels angegeben.

int sensorpin = A0; void setup () { // initialisiere die serielle Kommunikation mit 115200 Bit pro Sekunde, um der des Python-Skripts zu entsprechen: Serial.begin (115200); } void loop () { // lese den Eingang am analogen Pin 0: #################################### ###################### schweben Sensorvalue = analogRead (sensorpin); Byte-Daten = Serial.read (); if (data == 's') { Serial.println (sensorValue); Verzögerung (10); // Verzögerung zwischen den Lesevorgängen für Stabilität } }

Arduino-Oszilloskop in Aktion

Laden Sie den Code in das Arduino-Setup hoch und führen Sie das Python-Skript aus. Sie sollten sehen, wie die Daten über die Python-Befehlszeile eingespeist werden und das Diagramm mit der Lichtintensität variiert (siehe Abbildung unten).

So kann Arduino als Oszilloskop verwendet werden. Es kann auch mit Raspberry Pi hergestellt werden. Lesen Sie hier das vollständige Tutorial zum Raspberry Pi-basierten Oszilloskop.