Oscilloscope

http://sites.schaltungen.at/arduino-uno-r3/oscilloscope

http://www.linksammlung.info/

http://www.schaltungen.at/

Wels, am 2014-12-06

BITTE nützen Sie doch rechts OBEN das Suchfeld [ ] [ Diese Site durchsuchen]

DIN A3 oder DIN A4 quer ausdrucken
**********************************************************************************
DIN A4 ausdrucken

*********************************************************

Arme-Leute-Oszilloskop um € 20,-

ARDUINO UNO - Multi-Channel Oscilloscope

A-D-Wandler Grundlagen für Anfänger
200_a_DATEL-x_D-A#174 HANDBUCH der Datenwandlung (000 .. )_1a.pdf (000 bis 174 Seiten)

Ich mußte leider feststellen das die im Internet kostenlos downloadbaren Oszilloskop-Sketche fast alle kleine Fehler haben.
Auch die kleinsten Fehler in einem Sketch verhindern aber deren Gebrauch.
Meist hat man auch keine Ahnung wo es eigentlich hackt.
Nur durch akribische Fehlersuche bringt man dann diese Sketche zum laufen.
Oft sind es auch die die geänderten Befehle in der neuen Version.
In welcher Version geschrieben wurde ist aber nicht zu finden.

*.pde sollten Processing Files sein aber früher waren dies auch Arduino-Sketche.

Alle korrigierten Sketche sind von www.schaltungen.at downloadbar.
Alle Sketche mit deutschen Erklärungen / Bemerkungen versehen, war doch sehr zeitaufwendig ! ! !
fritz prenninger

P.S
Bei den tausenden simplen Blinkschaltungen die keiner wirklich braucht da gibt es keine Probleme.

*********************************************************

Arduino - Multi-Channel Oscilloscope

(Poor Man's Oscilloscope)

Arduino UNO Rev3 Oscilloscop Front End

Kanal-1 bis Kanal-6 werden alle 50ms dargestellt.

SENDER:    Arduino-IDE 1.0.6
EMPFÄNGER: Processing-PDE 2.2.1

SENDER:    ARDUINO-UNO_Oscilloscope_1-Channel_ArduinoIDE_2a.ino (H, 1023,)
EMPFÄNGER: ARDUINO_UNO_Oscilloscope_1_Channel_Processing_2a.pde 428Hz ( + bis 12,5kHz) (bei 115200 Baud)

SENDER:    ARDUINO-UNO_Oscilloscope_2-Channel_ArduinoIDE_2a.ino (H, 1023, 256,)
EMPFÄNGER: ARDUINO_UNO_Oscilloscope_2_Channel_Processing_2a.pde

SENDER:    ARDUINO-UNO_Oscilloscope_3-Channel_ArduinoIDE_2a.ino (H, 1023, 528, 256,)
EMPFÄNGER: ARDUINO_UNO_Oscilloscope_3_Channel_Processing_2a.pde

SENDER:    ARDUINO-UNO_Oscilloscope_6-Channel_ArduinoIDE_2a.ino (H, 1023, 0, 1023, 0, 1023, 0,)
EMPFÄNGER: ARDUINO_UNO_Oscilloscope_6_Channel_Processing_2a.pde (deutsch) 20Hz ( + bis 172Hz) (bei 9600 Baud)

Alle Sketche von www.schaltungen.at downloadbar.

4-Kanal Wechselpannungs-Vorsatz + 2V / - 1V

R1 = 113k R2 = 10M C1 = Drehkondensator 2..5pF

http://duino4projects.com/wp-content/uploads/2013/05/Arduino-Quasi-real-time-oscilloscope-schematic.jpg
http://duino4projects.com/quasi-real-time-oscilloscope-using-arduino/
http://www.instructables.com/id/Arduino-Multi-Channel-Oscilloscope-Poor-Mans-O/
https://github.com/konsumer/arduinoscope

* Processing 3-Cannel-Code:
* Processing-Sketch: ARDUINO UNO-Oszilloskop 3-Kanal Processing_1a.pde
* Bietet eine visuelle Darstellung von 3 analogen Eingängen pin-A0 bis pin-A2 in Echtzeit.
*
* Diese Software erweitert die Kanal-Anzahl einer früheren Version.
* Die vorherige Version war ein Projekt, das part of Accrochages.
* Siehe http://accrochages.drone.ws
*
* Der Autor dieses angepassten Software hat keine Beziehung / Verbindung zu Accrochages.
* Er bedankt sich für die große Vorlage und die Inspiration, um diese Software zu schreiben.
*
* Die nachfolgende Erklärung war Teil der Originalsoftware.
* Dies ist zu Ihrer Information.
*
* (C) 2008 Sofian Audry mailto:[email protected]
*
* Dieses Programm ist eine freie Software: Sie können sie weitergeben und / oder modifizieren.
* Unter den Bedingungen der GNU General Public License, wie veröffentlicht.
* Die Free Software Foundation, entweder gemäß Version 3 der Lizenz oder (Nach Ihrer Option) jeder späteren Version.
*
* Dieses Programm wurde geschrieben in der Hoffnung, dass es Ihnen von Nutzen sein wird.
*
* Kopie der GNU General Public License downloadbar von http://www.gnu.org/licenses/

*********************************************************

Arduino - Oscilloscope (poor man's Oscilloscope)

von RuiSantos

SENDER : ARDUINO-UNO Oscilloscope 3-Channel ArduinoIDE_1a.ino

EMPFÄNGER: ARDUINO-UNO Oscilloscope 3-Channel Processing_1a.pde

http://www.instructables.com/id/Arduino-Oscilloscope-poor-mans-Oscilloscope/?lang=de

Poormans Oszilloskop (mit Arduino + Processing) UND Arduinoscope.
Davide Gomba - 25. Februar 2010

Wenn Sie für die visuelle Darstellung eines analogen Signals mit Arduino und Verarbeitung suchen, dann sollten Sie diese Skecth herunterladen.
http://accrochages.drone.ws/en/node/90
Oscilloscope.pde 1,88 KB
oscilloscope.h 2,92 KB

über [Accrochanges] http://accrochages.drone.ws/en/node/90

über [Arduinoscope die Github] https://code.google.com/p/arduinoscope/

http://blog.arduino.cc/2010/02/25/poormans-oscilloscope-with-arduino-processing-and-arduinoscope/

http://mitchtech.net/arduino-oscilloscope/

Arduino Poor man's oscilloscope processing code
https://gist.github.com/chrismeyersfsu/3270419

http://randomnerdtutorials.com/arduino-poor-mans-oscilloscope/

ARDUINO_UNO_Oscilloscope_3_Channel_Processing_2a.pde

Software-Upgrades für das Arduino-Oszilloskop (Arme-Leute-Oszilloskop), die auf 1- bis 6-Datenkanäle gleichzeitig sich visualisieren lassen.

Dieses "Gerät" ist nicht ein tatsächliches Oszilloskops.
Die meisten der Funktionen die Sie von einem Oszilloskop erwarten, sind nicht verfügbar.

Funktionen des Oszilloskop-Sketches:
Baudrate Default 9.600, Sie sollten diese aber auf 115.200 Baud ändern.

Bei 115.200 Baud

+ = nur 1 Kanal WERTe alle 80us = 12,5kHz
- = nur 1 Kanal WERTe alle 2333us = 428,0Hz

1-Kanal (am schnellsten)
2-Kanal (etwas langsamer)
3-Kanal (noch langsamer)
6-Kanal (pro 50ms alle 6-Kanäle)

Datenerfassung und Anzeige:
0..5Vdc Signalbereich durch Hardware bestimmt (ARDUINO UNO R3)
Zeit-Skala-Zoom in / out, indem Sie die Tasten [ - ] oder [ + ] drücken.

Bei 9.600 Baud

+ = alle 6 Kanäle WERTe alle 5,8ms = 172Hz
- = alle 6 Kanäle WERTe alle 50,0ms = 20Hz

Wenn die serielle Schnittstelle Geschwindigkeit auf 9600 bps konfiguriert sollte es in der Lage, 320 Samples pro Sekunde zu erhalten, so ist es sinnvoll bis zu ~ 30 Hz ist.
http://blog.arduino.cc/2010/02/25/poormans-oscilloscope-with-arduino-processing-and-arduinoscope/
http://www.instructables.com/id/Arduino-Oscilloscope-poor-mans-Oscilloscope/
http://www.instructables.com/id/Arduino-Multi-Channel-Oscilloscope-Poor-Mans-O/
http://www.instructables.com/id/Arduino-Improved-Poor-Mans-Oscilloscope/
http://www.instructables.com/id/How-to-make-an-Arduino-oscilloscope-probe/
ETP_Oscilloscop
http://www.youtube.com/watch?v=5ky_N5-Fu6M

Raster:
Graue Linien = 0,5V Schritte
Dunkle gelbe Linien = 1V Schritten

Screenshot-Funktionalität:
Bei einem Maus-Klick in das Processing-Ausgabefenster wird ein Screen-Shot (Bildschirmausdruck) des Oszi-Fenster abgespeichert.
Im jeweiligen aktuellen Processing File ORDNER unter > YourPathHere > OsciDatei1.png wird das *.png-Bild gespeichert.
Auf diese Weise können Sie im Wesentlichen auf "stopp" die Daten und schauen Sie es. Praktisch für die Datenanalyse.
Damit dies funktioniert, müssen Sie in das Programm hinausgehen "zu zeichnen ()" Abschnitt, und stellen Sie den Dateipfad, eine, die mit Ihrem Computer funktioniert.

Alles was Sie brauchen ist ein Arduino und ein USB-Kabel.

Arduino - Oscilloscope (poor man's Oscilloscope)

by RuiSantos

Code aus Github

Zuerst laden Sie die Processing-PDE https://processing.org/
Sie brauchen diese nicht installieren, läuft als *.EXE File

Auf den ARDUINO-UNO laden diesen Sketch
https://gist.github.com/chrismeyersfsu/3270419#file-gistfile1-c
Nach Ausführen dieses Code in Verarbeitung IDE oscilloscope.c

1x ARDUINO UNO R3
1x Bread-Board
1x LED rot 5mm low-current
1x 10k Widerstand
1x 4.7k Widerstand
1x 1k Widerstand
1x 100nF Elektrolyt-Kondensator

1x NE555

1) Laden Sie Processing ist eine Programmierumgebung, die aussieht und ähnlich mit der Arduino-Programmierumgebung ist.

Alles ist kostenlos. Klicken Sie hier zum Download.

2) Je nach Anzahl der Kanäle, die Sie gerne haben, laden Sie einen "Arduino Sketche".
Zwei Sketche einen für das Senden und einen für das Empfangen der Daten sind notwendig.

3) Nehmen Sie die entsprechenden ARDUINO-UNO_Oscilloscope_6-Channel_... Sketche von oben und kopieren Sie sie in Bearbeitung.

4) Ändern Sie den "Pfad" in der letzten Zeile des Codes in einen Pfad Ihrer Wahl.

5) Führen Sie es in Bearbeitung.

6) Stellen Sie sicher, Ihre Signale dürfen 5Vdc nicht überschreiten.
Kanal 1 = Analog pin-A0
Kanal 2 = Analog pin-A1
Kanal 3 = Analog pin-A2

Hinweise:
Die Verarbeitungs Sketche verwenden die serielle Schnittstelle 1 (COM6)
Unter Umständen müssen Sie eien anderen Wert einstellen, wenn bei Ihnen eine andere serielle Schnittstelle aufscheint.
Ich dokumentierte jeden Schritt des Sketches mit vielen Kommentaren. Der Code sollte so "selbsterklärend" sein.

Echtzeit besteht nicht - die Daten werden mit Verzögerung angezeigt wenn
Die Verzögerung, die in der Arduino Programm eingestellt ist nicht groß genug.
Wenn zu viele Daten gesendet werden.
Die Bearbeitungszeit ansammelt.

Wenn Sie die Ablenkgeschwindigkeit mit "+" erhöhen werden weniger Daten angezeigt.
Dies hat einen direkten Einfluß auf das Potential für die Verzögerungen, da weniger Verarbeitungszeit erforderlich ist.
Das Fenster ist zu breit = zu viele x-Werte müssen verschoben werden = zu viel Zeit für die Berechnungen erforderlich = entscheiden Sie sich für die kleineren Fenstergröße 600x400 Pixel (1014x690 Pixel nur bis ca. 20Hz)

********************************************************

ARDUINO UNO R3: Analog Messungen

Ein Arduino hat 6 Analogeingängen (pin-A0 bis pin-A5), die es uns ermöglicht, Spannungen im analogen Bereich zu messen.
Dies könnte eine Spannung, Strom, Widerstand, Temperatur, Licht und so weiter sein.
Dieser Artikel untersucht die Verwendung und Leistung des Analog-Digital-Wandler (ADC) auf dem Arduino.
Die Tests werden auf einem Arduino Nano v3.0, die sehr ähnlich zu der Arduino Uno mit der bemerkenswerteste Unterschied der Größe durchgeführt wird.
Auch der Mikrocontroller ATmega328p an Bord ist die gleiche und läuft mit einer Taktfrequenz von 16MHz.

AnalogRead
Die Wandlungszeit des Standard analogRead () wird mit dem Code unten untersucht.
Um den Beginn und das Ende der Umwandlung ein Marker Ausgabe auf pin-12.
Der Pegel an diesem Pin erstellt wird, bevor die analogRead() umgeschaltet ausgeführt zu erkennen.
Die Ausführung des bitSet() und bitClear (), um die Ausgabe umzuschalten dauert 125ns.

int marker = 12; // marker output pin

		int analogPin = 3; // analog input pin

		int aval = 0; // analog value

		

		void setup() {

		pinMode(marker, OUTPUT); // pin = output

		}

		

		void loop() {

		bitSet(PORTB, 4); // marker high

		aval = analogRead(analogPin); // sample signal

		bitClear(PORTB, 4); // marker low

		aval = analogRead(analogPin); // sample signal

		}

Code 1: Zeit die Ausführungszeit des analogRead Funktion.

Fig. 2: Ausführungszeit des analogRead() Funktion. (Zeitbasis: 50 ms / div)

Während der Analog-Digital-Umwandlung der Pegel auf dem marker pin bleibt hoch für 111us.
Die Ausführungszeit (125 ns) zum Ändern des Markierungssignals ist daher vernachlässigbar.
Die maximale Geschwindigkeit, mit der Probe analogRead () ist daher 9,1 kHz.
Ein Nachteil bei der Verwendung analogRead () ist, dass der Arduino kann anderer Code nicht ausgeführt werden während der Wartezeit für die Umwandlung Ergebnis.

Mit ADC Interrupts
Wie oben beschrieben, kann der Arduino anderen Code nicht ausgeführt werden, während die analogRead () Funktion auszuführen.
Da die ATMEGA328 verwendet nicht die CPU-Core für die Übernahme der analogen Signale, es ist eine Verschwendung von Verarbeitungsmöglichkeiten.
Vor allem, wenn ein Signal muss ständig abgetastet werden. Dies kann durch die Verwendung von Interrupts kompliziertere erfolgen.
Da es keine Standard-Funktionen, um das Setup eines Analog-Wandlung mit Unterbrechungen, müssen die Register mit dem ADC verbunden manuell bearbeitet werden.

Single shot sampling
Eine Einzelschuss Probenahme ist in der Tat, was die Arduino hat beim Aufruf des analogRead () Funktion.
Es gibt nicht viel, um die Vorteile zu erlangen, wenn dies mit anderen Mitteln durchgeführt.
Denn bevor der ADC kann gestartet werden, zuerst die ADC-Bereit-Flag überprüft werden.
Und das bedeutet, Polling, die Flagge in einer Schleife, und ist nicht anders als die Arduino tut.

Free running sampling
Wenn ein Signal muss ständig abgetastet werden, ist es eine gute Idee, dies mit Unterbrechungen einzurichten.
Die ATmega328 in eine Freilauf-Modus konfiguriert werden. In diesem Modus startet der ADC Konvertierung automatisch, nachdem die vorherige.
Jedesmal, wenn eine Umwandlung eines Interrupt abgeschlossen wird erzeugt, das den Unterbrechungsroutine ISR (ADC_vect) fordert, wobei die ADC-Folge gelesen und verarbeitet werden.

So richten Sie die Freilauf-Modus drei Register muss konfiguriert werden: ADMUX, ADCSRA und ADCSRB.
Eine detaillierte Beschreibung dieser Register sind ATmega328 Datenblatt.
In diesem Fall ist die interne 1,1-Volt-Referenzspannung und der Analogeingangskanal ADC3 mit ADMUX ausgewählt.
Die Taktfrequenz in ADCSRA ausgewählt und bei ÷ 16 in diesem Beispiel gesetzt.
Eine einzelne Analog-Wandlung dauert 13 Taktzyklen.
Die Abtastrate kann von dieser Einstellung und der CPU-Taktfrequenz berechnet werden:
16 MHz / (16 * 13) ≈ 77kHz.
Dadurch, dass das bit-6 in ADCSRA hoch, beginnt die Freilauf-Konvertierung.

int marker = 12; // marker output pin

		int aval = 0; // analog value

		

		void setup() {

		pinMode(marker, OUTPUT); // pin = output

		DIDR0 = 0x3F; // digital inputs disabled

		ADMUX = 0x43; // measuring on ADC3, use the internal 1.1 reference

		ADCSRA = 0xAC; // AD-converter on, interrupt enabled, prescaler = 16

		ADCSRB = 0x40; // AD channels MUX on, free running mode

		bitWrite(ADCSRA, 6, 1); // Start the conversion by setting bit 6 (=ADSC) in ADCSRA

		sei(); // set interrupt flag

		}

		

		void loop() {

		}

		

		/*** Interrupt routine ADC ready ***/

		ISR(ADC_vect) {

		bitClear(PORTB, 4); // marker low

		aval = ADCL; // store lower byte ADC

		aval += ADCH << 8; // store higher bytes ADC

		bitSet(PORTB, 4); // marker high

		}

Code 2: Messen Sie die Ausführungszeit der das Lesen der ADC-Wert.

Das Ergebnis der AD-Umwandlung wird in der Unterbrechungsroutine (ISR ADC_vect) gelesen.

ADCL und ADCH:

Weil das Ergebnis der Analog-Digital-Umwandlung ist 10-bit lang, es ist mehr als zwei Byte breite Register unterteilt.

Für eine korrekte Anzeige ist es wichtig, dass zuerst der ADCL gelesen wird und erst dann die ADCH Register.

Im Beispielcode der ADC-Ergebnis wird in der int-Variable "aval" kopiert.

Fig. 3: Freilaufende Analog-Wandlung mit dem Teilungsfaktor auf 16 eingestellt (Zeitbasis: 5 ms / div)

Um die Ausführungszeit der Marker vor dem Lesen des ADC niedrig und wird wieder hoch, nachdem es gemacht zu messen.

Man beachte, dass die Gesamtausführungszeit der Unterbrechungsroutine ist länger.

Beachten Sie, dass die "Schleife" Jetzt ist völlig kostenlos und kann verwendet werden, um anderen Code auszuführen.

Welche Referenz?

Um ein analoges Signal zu messen muss es einen Spannungspegel, es mit zu vergleichen. Diese Spannung wird als die Referenz. Im ATMEGA328 des Arduino diese Referenzspannung ist auch die maximale Spannung, die gemessen werden kann. Die Spannungen werden immer relativ zum Boden gemessen. Das Arduino hat drei Referenzspannung Optionen: AVcc, die dem digitalen 5-V-Stromleitung verbunden ist, die interne 1,1 V und die Möglichkeit, eine externe Spannungsreferenz zu verwenden. Da die Messungen der Eingangsspannungen relativ zu der Bezugsspannung hat, Schwankungen der Referenzspannung das Ergebnis beeinflussen.

Die Referenzspannung kann mit der Funktion analogReference () gesetzt werden oder mit den REFS [1:0] bits im ADMUX Register.

Feige. 4: Mit der 5-V-Referenz bei der Messung eines Widerstandes in einer Halbbrücke. Messung mit dem internen 1,1 V Referenz

Feige. 5: Verwenden Sie den internen 1,1 V oder externe Referenz bei der Messung von externen Spannungen.

AVcc Referenz

Die AVcc beträgt die vorgegebene Referenzspannung und ist nur bei der Messung von Spannungen, die direkt abhängig von der Versorgungsspannung sind.

Dies ist der Fall, wenn die Spannung einer halben Widerstandsbrücke, wie in Bild 4 dargestellt Wenn aus irgendeinem Grund die Versorgungsspannung fällt, wird die Spannung an dem Verbindungspunkt der beiden Widerstände proportional sinken gemessen werden.

Weil nun der Referenz- und Eingangsspannungsänderung proportional, wird das ADC-Resultat immer noch die gleichen.

Interne 1,1-V-Referenz

Verwenden Sie die interne 1,1 V Referenz für genaue Messungen der externen Spannungen.

Das 1,1-V-Referenz ist stabiler und ist abhängig von der Versorgungsspannung oder Temperatur kaum.

Daher kann absolute Messungen durchgeführt werden.

Das Beispiel in Abbildung 5 verwendet die 1,1 V Referenz und eine 10: 1 Widerstandsteiler an externe Spannungen zwischen 0 und 11 V zu messen

Genauigkeit

Nach Angaben der ATMEGA328 Datenblatt die Referenzspannung 1,1 ± 0,1 V.

Dies ist eine recht große Toleranz. Der gemessene Referenzspannung der getesteten Arduino Nano war 1.089 V bei einer Umgebungstemperatur von 21 ° C und die Packung Temperatur betrug 29 ° C.

Wenn das Paket der ATMEGA328 herunter mit Frostspray auf -18 ° C abgekühlt wird die Referenzspannung misst 1,084 V. Der Temperaturdrift ist daher 100 ppm / ° C.

int analogPin = 3; // analog input pin

		

		void setup() {

		analogReference(INTERNAL); // select internal 1.1 volt reference

		Serial.begin(9600);

		}

		

		void loop() {

		int aval = analogRead(analogPin); // sample analog input

		Serial.println(aval);

		delay(300);

		}

Code 3: Auslesen der Messwerte dreimal pro Sekunde.

Ein Test mit dem Code neben bestätigt eine leichte Ergebnis Drift aufgrund der Temperaturänderung. Das analoge Stift 3 ist mit einem 0,545-V-Quelle verbunden. Bei einer Gehäusetemperatur von 29 ° C das Ergebnis muss sein: (0,545 / 1,089) * 1024 = 512 (511 Lese-) und bei einer Temperatur von -18 ° C wird es: (0,545 / 1,084) * 1024 = 515 ( 515 Lese)

Allerdings ist die Temperaturdrift gering ist, für eine exakte Messung ein Arduino-Anwendung muss aufgrund der großen Gesamtunsicherheit von 10% kalibriert werden.

Noise

Futtermittel eine Gleichspannung an die Arduino

Fig. 6: Diese Schaltung liefert eine einstellbare Gleichspannung an den Arduino Analogeingang.

Ein Weg, um den Geräuschpegel zu messen, ist an der Ausbreitung in Werte aus dem ADC aussehen. Um dies zu einer stabilen DC-Pegel an einem der analogen Eingänge angeboten und die umgewandelten Werte werden klassierte, um ein Histogramm zu erstellen tun.

Testschaltung

Die Schaltung in Bild 6 liefert die Testspannung an den Arduino.

Die Quelle ist eine sehr stabile rauscharme einstellbare Stromversorgung bei einer Spannung von 0,55 V, halbieren 1,1 V Referenzspannung.

Das Signal wird zusätzlich durch R1, C1,2 filtriert und über einen 100 Ω Widerstand R2 an den analogen Eingang A3 des Arduino verbunden.

Der Boden ist mit GND Pin zur gleichen Reihe verbunden.

Binning

Die ATmega328 ADC hat eine Auflösung von 2 ¹⁰ = 1024 bit.

Die Idee, Binning ist zu zählen, wie oft ein bestimmter Wert auftritt.

Daher wird ein Array mit 1024 Plätzen genannte Bins, die jede der möglichen ADC-Werte repräsentiert erstellt.

Da der verfügbare Speicher knapp, nur Byte-Größe Behälter erstellt werden.

Die Anzahl von Zählungen wird daher auf 255 beschränkt.

Zwei Programme

Das Rauschen wird mit dem analogRead Funktion sowie mit der Interrupt-Verfahren getestet.

Die beiden Programme zu tun im Grunde das Gleiche: Ein Array mit 1024 Behälter definiert.

Im Setup alle Behälter werden auf 0 gesetzt und der interne 1,1 V Referenzspannung gewählt ist.

Beide Programme verwenden eine Vorfeld von 10.000 Dummy Messwerte.

Danach beginnt der Binning und auf jeder ADC führen die entsprechende bin um eins erhöht.

Wenn einer der Behälter 1024 das Maximum von 255 erreicht zählt die Übernahme beendet und alle 1024 bins Werte werden an den Computer senden.

int analogPin = 3; // analog input pin

		int sendStatus = 0; // send status

		int startDelay = 0;

		byte valueBin[1024]; // value bins

		

		void setup() {

		analogReference(INTERNAL); // select internal 1.1 volt reference

		for (int i=0; i<=1023; i++) { // clear bins

		valueBin[i] = 0;

		}

		Serial.begin(9600);

		Serial.println("Start");

		}

		

		void loop() {

		int aval = analogRead(analogPin); // sample analog input

		if (sendStatus == 0) { // do nothing the first x samples

		if (startDelay < 10000) {

		startDelay++;

		}

		else {

		valueBin[aval] += 1; // increase value bin

		if (valueBin[aval] == 255) { // stop if a bin is full

		sendStatus = 1;

		}

		}

		}

		if (sendStatus == 1) {

		for (int i=0; i<=1023; i++) { // output bin values

		Serial.print(i);

		Serial.print("\t");

		Serial.println(valueBin[i]);

		}

		Serial.println("Done");

		sendStatus = 2;

		}

		}

Code 4: Binning die Messwerte mit der analogRead Verfahren.

int sendStatus = 0; // send status

		int startDelay = 0;

		byte valueBin[1024]; // value bins

		

		void setup() {

		TIMSK0 = 0x00; // disable timer (causes anoying interrupts)

		DIDR0 = 0x3F; // digital inputs disabled

		ADMUX = 0xC3; // measuring on ADC3, left adjust, internal 1.1V ref

		ADCSRA = 0xAC; // AD-converter on, interrupt enabled, prescaler = 128

		ADCSRB = 0x40; // AD channels MUX on, free running mode

		bitWrite(ADCSRA, 6, 1); // Start the conversion by setting bit 6 (=ADSC) in ADCSRA

		sei(); // Set global interrupt flag

		for (int i=0; i<=1023; i++) { // clear bins

		valueBin[i] = 0;

		}

		Serial.begin(9600);

		Serial.println("Start");

		}

		

		void loop() {

		if (sendStatus == 1) {

		for (int i=0; i<=1023; i++) { // output bin values

		Serial.print(i);

		Serial.print("\t");

		Serial.println(valueBin[i]);

		}

		Serial.println("Done");

		sendStatus = 2;

		}

		}

		

		/*** Interrupt routine ADC ready ***/

		ISR(ADC_vect) {

		int aval = ADCL; // store lower byte ADC

		aval += ADCH << 8; // store higher bytes ADC

		if (sendStatus == 0) {

		if (startDelay < 10000) { // do nothing the first x samples

		startDelay++;

		}

		else {

		valueBin[aval] += 1; // increase value bin

		if (valueBin[aval] == 255) { // stop if a bin is full

		sendStatus = 1;

		}

		}

		}

		}

Code 5: Binning die Messwerte mit der Interrupt-Verfahren.

Testfrequenzen

Der Test wird mit dem analogRead Funktion durchgeführt und mit der weiterhin Stichprobenbasis.

Da die Abtastfrequenz im letzten Fall ist einstellbar, werden vier verschiedenen Frequenzen indem Sie den Wert in der Zeile ADCSRA = 0xAC getestet;.

Diese sind: 9,6 kHz (CLK ÷ 128), 19,2 kHz (CLK ÷ 64), 38,4 kHz (CLK ÷ 32) und 76,9 kHz (CLK ÷ 16).

Die Sample-Frequenz mit analogRead ist ca. 9,1 kHz.

Ergebnisse

Die Ergebnisse beider Methoden und allen Probenfrequenzen ähneln.

Die Proben werden über zwei benachbarte Bins und eine extrem einige Proben in einem dritten Fach finden.

Dies bedeutet, daß die Rauschpegel in allen Fällen annehmbar niedrig sind.

Feige. 7: Bei jedem ADC Sample-Frequenz gibt die gemessene Gleichspannung wie erwartet eine enge Spitze in dem Histogramm.

Das Umschalten zwischen Eingängen und Referenzspannungen

Das Arduino Nano hat 8 analoge Eingänge.

Da der ADC kann nur ein Signal zu digitalisieren gleichzeitig muß das analoge Eingangs konvertiert werden vor Beginn des ADC ausgewählt werden.

Auch muß die erforderliche Referenzspannung ausgewählt werden.

Auswahl Analogeingänge

Die Auswahl des Analogeingangs erfolgt durch analogPin = n, wobei n die analogen Pin-Nummer,

oder durch Änderung der analogen Kanalauswahl MUX Bits [3:0] in der ADMUX Register.

Besondere Aufmerksamkeit sollte bezahlt, wenn der Freilauf-Modus verwendet werden:

Der Analogkanal muss, bevor eine neue Analog-Wandlung beginnt gewählt werden. In der Interrupt-Routine ein Analogeingang gewählt, dessen Ergebnis wird unter der folgenden Interrupt lesen.

Um die Geräuschentwicklung und Genauigkeit zu testen, wenn die Eingänge geschaltet werden, werden die zusätzlichen folgenden Codes in den Codes 4 und 5.

Eine zweite Spannung wird an den Analogeingang 5 nun auch die gemessenen Werte genau wie im Geräuschtest binned aufgebracht enthalten.

void loop() {

		if (analogPin == 3) {

		analogPin = 5;}

		else {

		analogPin = 3;}

		int aval = analogRead(analogPin);

		...

Code 6: Änderung der analogRead Funktion, um zwischen den analogen Eingängen.

ISR(ADC_vect) {

		if (ADMUX == 0xC3) {

		ADMUX = 0xC5;}

		else {

		ADMUX = 0xC3;}

		int aval = ADCL;

		...

Code 7: Änderung für die weiterhin Abtastmodus zwischen analogen Eingängen wechseln.

Ergebnisse

Beide gemessenen Spannungen als zwei Spitzen in den Histogrammen sichtbar. Abbildung 8 zeigt die Histogramme der fünf Tests: AnalogRead() Funktion, Freilauf bei ÷ 128 ÷ 64 ÷ 32 und ÷ 16.

Die gemessenen Werte der ersten Spannung (ADC-Wert 511) nicht von der vorherigen Rauschprüfung abweichen.

So ist die Messung sind immer noch genau.

Die umgebenden Behälter sind sehr klein, was bedeutet, dass der Geräuschpegel nicht zu erhöhen.

Fig. 8: Jeder der fünf Histogramme zeigt zwei Spitzen, die die beiden gemessenen Spannungen.

Ändern Referenzspannung

Ändern der Referenzspannung kann nicht so schnell wie das Umschalten zwischen den analogen Eingängen durchgeführt werden.

Dies ist aufgrund der 100nF Kondensator nach pin-Aref des ATmega328 am Arduino Platte verbunden.

Dieser Kondensator braucht Zeit zum Laden und Entladen. Abbildung 9 zeigt ein Oszilloskop Grundstück von diesen absetzen Verzögerungen.

Die Zeit, um die Referenzspannung von 1,1V bis 5V zu ändern, ist relativ schnell: 15us , aber die Änderung in der entgegengesetzten Richtung von 5V bis 1,1V beträgt mindestens 5ms.

void loop() {

		if (swr == true) {

		analogReference(DEFAULT);

		swr = false;

		}

		else {

		analogReference(INTERNAL);

		swr = true;

		}

		delay(8);

		int aval = analogRead(analogPin);

		...

Code 8: Änderung der analogRead Funktion, um zwischen den Referenzspannungen.

Fig. 9: Settle Zeit der Referenzspannung (Zeitbasis: 2 ms / div, Vertikal: 2 V / div)

Der Wechsel zwischen Referenzspannungen ist bei der Verwendung der fortProbenahmeVerfahren vermieden werden.

Wenn es gemischt Eingänge:

Messung der externen Spannungen und Widerstandsbrücken wie die in Figur 4, ist es bevorzugt, die Widerstandsbrücke aus dem 1.1 Referenzspannung zu liefern. Beachten Sie, dass die Referenzspannung kann nur kleine Ströme zu liefern.

Eine Last von einem 4,7 kOhm Widerstand ließ den Referenzspannungsabfall von 1,0880 bis 1,0857.

In diesem Fall ist es das beste, die Aref Spannung mit einem Operationsverstärker Puffer und verbinden die Widerstandslasten an den Operationsverstärker-Ausgang.

Samplefrequenz vs. Auflösung

Schließen Sie den Funktionsgenerator mit dem Arduino Kreis

Fig. 10: Ein Funktionsgenerator mit dem Arduino analogen Eingang verbunden.

Die gleichen zwei Binning Code 4 und 5 werden verwendet, um die Auflösung im Vergleich zu der Abtastfrequenz analysieren.

Für diesen Test wird ein Funktionsgenerator ist mit der Arduino analogen Eingang, wie in Abbildung 10 dargestellt

Der Funktionsgenerator liefert eine Dreieckswellenform mit einem Top-Top-Spannung von 25 mV und eine Offset-Spannung (= Mittelwert) von 0,55 V.

Bei jedem Messung der Wellenformfrequenz wird so gewählt, daß die Abtastfrequenz ist 163 mal höher.

Ein Dreieck-Wellenform wird gewählt, weil jeder Wert (wenn quantisiert) ist ebenfalls häufig.

Wenn ein solches Signal wird jedes Fach Wert innerhalb des Minimal- und Maximalspannung binned sollte die gleiche Anzahl haben.

Ergebnisse

Wie die Ergebnisse in Abbildung 11 zeigt die niederfrequenten Abtastung analogRead() und setzt Abtastung mit clk ÷ 128 eine angemessene flache Oberseite:

z.B. alle Werte im Bereich treten mit der gleichen Nummer.

Aber bei höheren Sampling-Frequenzen (clk ÷ 64, clk ÷ 32 und clk ÷ 16) Lücken werden in der Binning-Block, der noch schlimmer mit der Frequenz zu erhalten.

Das Datenblatt des ATmega328 warnt über dieses Phänomen:

Bei einer ADC-Takt über 200 kHz ist die Auflösung niedriger wird.

Bei einer Taktfrequenz von 16 MHz und einem Teilungsfaktor von 64 ADC-Takt wird 250 kHz, oberhalb der Schwelle, die Auflösung kleiner als die von den Messungen bestätigt.

Fig. 11: Ein Dreieck Spannung sollte einen flachen oberen Histogramm zu geben. Je höher die Abtastfrequenz, desto mehr Lücken erscheint.

Sie haben erwähnt, dass ein einzelner Analog-Wandlung dauert 13 Taktzyklen, je nachdem, was?

Die 13 Taktzyklen, für eine einzige Umwandlung ist fest und kann nicht geändert werden.
Siehe ATMEGA328 Datenblatt Kapitel 24, Bild 24-5, 24-6 und 24-7.
Und siehe auch die zugehörige Beschreibung der Mikrocontroller AD-Wandler.

Wie kam es zu dem Schluss, dass mit analogRead () würde Arduino von der Ausführung anderer Code halten während der Wartezeit für die Umwandlung Ergebnis gekommen? Und ist, dass nur die ATmega328-Controller eingesetzt?

Es ist eine logische Folgerung. Jeder AD-Wandler verwendet einen Prozess (es sei denn, es ist eine sehr teure Flash-Wandler), die Zeit (Taktzyklen), nimmt, um das Ergebnis zu erhalten. Und da die Funktion analogRead () gibt das Ergebnis, das bei der nachfolgenden Code verwendet werden kann, gibt es keinen anderen Weg, als zu warten, bis das Ergebnis vorliegt. Dies gilt für jede Steuerung, und der Codetyp außer das Ergebnis wird von einem separaten Interrupt-Routine, die von dem ADC genannt, wenn es bereit ist, verarbeitet.

http://meettechniek.info/embedded/arduino-analog.html

*********************************************************
oscilloscope arduino processing

Arduino Oscilloscope with Processing

033_d_fritz-x_Digital Sampling Oscilloscope § ATmega328p (28 Seiten)_1a.pdf

arduinoscop_1a.ino

pin-A0 bis pinA5 pin-2 bis pin-13

Serielle Daten in der Form einlesen

1023 1023 1023 1023 1023 1023 0 1 0 1 0 1 0 1 0 1 0 1

https://code.google.com/p/arduinoscope/

http://lawrencematthew.wordpress.com/2011/08/30/build-a-6-channel-oscilloscope-with-just-arduino/

Diesr Sketch erfordert controlP5
http://www.sojamo.de/libraries/controlP5/

11,5 Sekuden / Bildschirmbreite 1000ms = 1Hz (Puls=500ms & Pause=500ms)

SENDER: ArduinoScope_1a.ino
pin-A0 bis pinA5
Serielle Daten in der Form einlesen (ohne Header - Space ist Trennzeichen)

1023 1023 1023 1023 1023 1023
1023 0 0 0 0 1023
(Raum seperates pin = Daten, LF-getrennt-Rahmendaten)

EMPFÄNGER: SimpleSerialArduinoScope_2c.pde

arduinoscope

application-osx.zip	Standalone simple arduinoscope for Mac OSX Featured	Aug 2009	494 KB	3991
application-win32.zip	Standalone simple arduinoscope for windows 32bit Featured	Aug 2009	418 KB	18911
application-linux64.tar.gz	Standalone simple arduinoscope for linux 64bit Featured	Aug 2009	448 KB	2170
application.-linux32.tar.gz	Standalone simple arduinoscope for linux 32bit Featured	Aug 2009	442 KB	3054
arduino-arduinoscope.pde	Arduino code for SimpleSerialArduinoscope Featured	Aug 2009	586 bytes	37471
processing-arduinoscope.zip	Processing library Featured	Aug 2009	65.2 KB	22809
Screenshot-Oscilliscope.png	Sceenshot of 6 analog channels being used	Mar 2009	29.4 KB	149344


arduinoscope.nw	working on unifying test & release	2 years ago
	processing	controlP5	a year ago
	util	more async-ee	2 years ago
	.gitignore	fixed typo	2 years ago
	.sparkleshare	+ ‘.sparkleshare’	2 years ago
	README.md	updated gh-pages links	9 months ago

https://github.com/konsumer/arduinoscope
https://code.google.com/p/arduinoscope/downloads/list
https://code.google.com/p/arduinoscope/wiki/Usage

Using Arduino as Oscilloscope - ArduinoScope!

arduinoscope
https://code.google.com/p/arduinoscope/source/browse/trunk/arduino_oscilliscope.pde?r=7

arduinoscope ist another Zweig Sofian Audry's Processing-basierte Oszilloskop.
https://code.google.com/p/arduinoscope/

ORDNER > processing-arduinoscop > examples > FirmataArduinoscope.pde
http://www.homebrew-tech.com/arduino/brewing-arduino-announcement/usingarduinoasoscilloscope-arduinoscope

processing-arduinoscope.zip

                             Arduino-Oszilloskop

Unten ist ein Arduino Oszilloskop das ich mit dem Oszilloskop-Projekt aus der Praxis Arduino Buch aufgebaut habe.
Die Auflösung ist 10-bit, aber für etwa 50 US-Dollar (ohne Computer) können Sie ein einfaches Oszilloskop bekommen.
Im Wesentlichen die Arduino spuckt gerade die Werte, die sie erhält an den analogen und digitalen Eingängen, so schnell sie können Ihren Computer.
Die analogen Eingänge sind langsamer als die digitalen Einsen, so dass diese Oszilloskop ist wahrscheinlich eine bessere Logikanalysator.

Unter der verwendeung der Control P5 Bibliothek

Ezer Longinus
http://www.ezerlonginus.com/?/other/Oscilloscope/

*************************
Arduino als Oszilloskop - ArduinoScope!
geschrieben 27. November 2010, 01.31 Uhr von Haris Hashim [Update 27. November 2010, 04.19 Uhr]

Inhalt
     1 Einführung
     2 Tutorial
         2.1 Schritt 1
         2.2 Schritt 2
         2.3 Schritt 3
         2.4 Schritt 4
         2.5 Schritt 5
         2.6 Schritt 6
     3 Schräge Sachen

Einführung

Arduino Umfang nutzen sowohl Arduino und Processing.
Wir werden eine Sketch zum Arduino Board hochzuladen.
Diese bewirken, dass die Bord-Spannungswert von analogen I / O Stift gelesen und gesenden über die serielle Kommunikation an PC.

Auf der PC-Seite. Wir eröffnen Verarbeitung und führen Sie einen Processing-Sketch (beachten Sie, dass es auch Verarbeitung Sketch, gleich wie Arduino.
Oder besser gesagt Arduino wird unter Verwendung der Terminologie von über Verarbeitung durchgeführt nennen).
Der Processing-Sketch läuft auf dem PC, hören Sie den ersten seriellen Anschluss an Spannungswert zu akzeptieren und sie grafisch dar.

Das ist es auf den Punkt. Lassen Sie uns also sehen, wie es eingerichtet werden.

Lernprogramm

Schritt 1
Ich gehe davon aus, dass   Arduino schon installiert ist.
Entpacken Sie die heruntergeladene ZIP-Datei irgendwo bequem. In meinem Fall ist es "D: \ app \ Verarbeitung".
Führen Sie das Programm. Zum Beispiel "D: \ App \ Verarbeitungs-1.2.1 \ processing.exe".
Beim ersten Durchgang wird es einen Ordner im Benutzerdokument Ordner mit der Bezeichnung "Bearbeitung" erstellen.
Benutzerdokumentordner ist "Eigene Dateien".
Brauchen Sie, um dieses "Processing" Ordner für den nächsten Schritt zu kennen.

Schritt 2
Genau wie Arduino (oder umgekehrt, ist Arduino wie Processing). Verarbeitung nutzen Bibliotheken dazu, unser Leben leichter. Arduinoscope selbst ist eine Bibliothek.

Es nutzen Sie eine andere Bibliothek namens ControlP5. Was bieten grafische UI-Element für die Benutzeroberfläche.

Müssen Sie es herunterladen, damit Kopf an ControlP5 Web-Seite und laden Sie es
Entpacken Sie die heruntergeladene ZIP-Datei in "Bibliotheken" im Ordner "[Eigene Dateien] \ Processing". Lage [Eigene Dateien] \ Verarbeitung Ordner wie in vorherigen Schritt erwähnt. Stellen Sie sicher, dass Sie "[Eigene Dateien] \ Verarbeitung \ Bibliotheken \ controlP5" Ordner nach dem Ausführen dieser Schritt.

Schritt 3
Wie oben erwähnt, Arduinoscope selbst ist eine Bibliothek.
Wir müssen es zu downloaden! Dies ist das übersteigt jede Vorstellungskraft Teil.
Aber zuerst nur den Kopf, um Verbrauchsseite Arduinoscope.
Die Seite gibt 2 Links zur Verarbeitung lib und der Arduino-Patch.
Die erste Verbindung laden Sie die Bibliothek selbst ein. Wir werden am anderen Glied in nächster Schritt aussehen.
Wie auch immer, laden Sie bitte die Bibliothek von Arduinoscope Seite, um die neueste Version herunterzuladen.
Nachdem der Download abgeschlossen ist Extrakt Inhalte "[Eigene Dateien] \ Verarbeitung \ Bibliotheken \ arduinoscope".
Ordnername muss "arduinoscope" sein. Dies ist wichtig, sonst geht es nicht!

Fallstrick hier (und ich tat dies!) Ist es, den Ordner zu benennen folgende Zip-Datei-Namen.
Welche ist "Verarbeitung-arduinoscope". Funktioniert nicht !.

Ein weiterer Fallstrick (und ich habe dies auch!) Ist es, die Bibliothek zu kopieren, um Bibliotheksordner Arduino.
Denken Sie daran, dass es sich um Verarbeitungsbibliothek und nicht Arduino Bibliothek.
Es wird natürlich nicht funktionieren. Plus beim Start Arduino IDE.
Es dauert etwa Bibliothek mit Namen mit nicht erlaubt Zeichen beschweren, bis der säumige Bibliothek gelöscht oder sonst bewegt.

Schritt 4
Jetzt müssen wir den Arduino Sketch oder genannt Arduino Patch im vorherigen Schritt herunterladen.
Beachten Sie, dass Arduinoscope verwenden sowohl Verarbeitungs Arduino.
In diesem Schritt laden Sie die Arduino-Patch. Grundsätzlich ist es eine PDE-Datei mit genauen Dateinamen von "Arduino-arduinoscope.pde".
Zum Zeitpunkt des Schreibens, ist die zweite Verbindung für das Arduino-Patch nicht funktioniert (Tipp: Rechtschreibfehler mit Bindestrich und Unterstrich).
Hier ist der Link, der "Arduino-arduinoscope.pde" funktioniert. In Zukunft könnte agood Idee, aus Arduinoscope Seite herunterladen.
Falls es aktualisiert oder der obige Fehler korrigiert wird.
Hier ist ein weiteres umwerfend Teil. Was zum Teufel sollen wir mit dieser Datei?
Zuerst möchte ich raten, um die Datei umzubenennen, um "arduinoscope.pde" ohne vernünftigen Grund. Nur zum Spaß; D
Erstellen Sie einen Ordner mit dem Namen "arduinoscope" in Arduino Sketch Ordner und kopieren Sie die Skizze gibt.
Arduino Sketch Ordner in "[Eigene Dateien] \ Arduino \ Skizze" entfernt.
Nun ist es Zeit, um unseren geliebten Arduino-IDE ausführen.
Dann öffnen Sie den Sketch aus dem Menü Datei> Sketchseite> Sketch> arduinoscope.
Laden Sie diese Skizze zu kompatibles Board Arduino.
Welche bringen uns in eine andere Fallgrube!
Die Falle der nicht mit demselben Namen für die Ordner und Zeichendatei.
Wenn der Dateiname ist "arduinoscope.pde".
Der Ordnername muss "arduinoscope" sein.
Sonst werden nicht sehen, die Skizze in Datei> Sketchbook> Skizzen-Menü.
Kann offenbar noch zu durchsuchen und öffnen Sie über Datei> Öffnen-Menü.

Am Ende dieser sehr langen Schritt. Stellen Sie sicher, dass Sie ein Arduino Board (Duemilanove oder Uno oder ein kompatibles Board) hochgeladen mit dem Arduino Patch haben.
Dieses Board ausgeführt und kontinuierlich zu senden analogen Spannungswert mit dem PC über USB.
Diese Lesart wird sich im nächsten Schritt gelesen werden.

Schritt 5
Zurück zur Verarbeitung IDE. In der IDE werden wir eröffnen die Skizze, die zum Lesen der Serienwert von letzten COM-Port gefunden zuständig ist.
Dieser Wert stammt aus Arduino Board wie im letzten Schritt beschrieben.
Die Skizze wird ein Diagramm als das, was wir von einem Oszilloskop erwarten, zu zeigen.

Also, wo können wir feststellen, dass Skizze?
Ein Konzept von den letzten Schritt gelernt habe, ist, dass. Sketch-Datei im Ordner Skizze und ist von Datei> Sketchbook> Skizze bequem zugänglich.
Im Falle der Verarbeitung, wird diese "[Eigene Dateien] \ Verarbeitung \ Skizze" zu sein.

Ein anderes Konzept, das nicht sofort klar ist, dass Bibliotheken können beispielsweise Skizze bieten!
Überprüfen Sie es heraus, indem Sie zu "arduinoscope" Bibliotheksordner. In diesem Ordner befindet sich ein "Beispiele" Ordner mit Skizzen im Inneren.
Dieses Beispiel Skizze ist zugänglich über das Menü Datei> Sketchbook> Bibliotheken> arduinoscope> Beispiele.

Also zögern Sie nicht und eröffnen eine Probe Sketch, indem Sie Datei> Sketchbook> Bibliotheken> arduinoscope> Beispiele> SimpleSerialArduinoscope.
Bevor Sie den Sketch. Beachten Sie, dass in der Verarbeitung gibt es nur Lauf-Taste, aber kein Upload-Button.
Die Verarbeitung läuft der Sketch am PC.
Was Arduino, dem Sketch auf einem Remote-Arduino-Board laufen entgegengesetzt.
Daher ist die Upload-Button für Arduino und keine solche Taste in der Verarbeitung.
Führen Sie die Sketch aus! Das öffnet ein weiteres Fenster mit grafischer Oszilloskop-Schnittstelle.

Schritt 6
Wir haben einen Sketch auf der PC-Oszilloskop zeigt.
Auf der anderen Seite müssen wir Arduino Board läuft. Wie können wir also testen?
Was passiert ist, dass das Arduino-Board ist Sampling Spannungswert am Analog- I / O-Pin pin-A0 bis pin-A5 in einer Schleife.
Da im Moment, wird nichts an die Pins angeschlossen. Die Werte sind eine Art Null mit ein wenig Hintergrundgeräusche.
Um zu testen, schließen 5V Pin Analog -I / O Pin 1 im PC sofort unsere Arduinoscope laufen wird Werte im Bereich von 5V zu zeigen.
Trennen 5V Pin und an 3,3V Pin. Dies führt dazu, das Lesen, um bis zu 3,3V Niveau fallen.

Schräge Sachen
Anzeige auf dem PC-Show 6 Lesungen möglicherweise für die 6-Kanal-Analog I / O-Pin.
Lassen Sie sagen, 5V ist mit der Analog-I / O-Pin 1.
Alle 6 Messwerte zeigen einen abnehmenden Wert von 5V. Vielleicht gibt es einen Fehler irgendwo.
Werden versuchen, 5V verbinden den analogen E / A-Pin 1, 3,3V I / O-Pin 2 Analog-und sehen, was los ist.

http://www.homebrew-tech.com/arduino/brewing-arduino-announcement/usingarduinoasoscilloscope-arduinoscope

*********************************************************

Cheap oscilloscope built from Arduino and Processing

Poorman’s oscilloscope (with Arduino + Processing)

SENDER: ARDUINO-UNO Oscilloscopio (1-Kanal)_1a.ino

EMPFÄNGER: Oscilloscope node90_1a.pde (1-Kanal)
EMPFÄNGER: Oscilloscope_Zoom node90_1a.pde (1-Kanal - mit + und - Taste Ablenkgeschwindigkeit verändern )

arduinoscope / processing /
Dies ist die Verarbeitungsbibliothek.
Es hat eine Firmata Abhängigkeit, so dass Sie brauchen, um die processing lib (https://github.com/pardo-bsso/processing-arduino) installieren und auch installieren Sie die Firmata Firmware auf Ihrem arduino
in Arduino-IDE MENU > Datei > Beispiele > Firmata > StandardFirmata)

Sobald Sie diese zwei Dinge getan haben, legen Sie die
processing/libraries/arduinoscope Ordner in Ihrem Ordner Verarbeitungsbibliotheken
Sie müssen auch zu controlP5 (http://www.sojamo.de/libraries/controlP5/#installation) installiert zu werden Beispiele zur Arbeit.
Nun starten Sie die Verarbeitung, und Sie sollten eine arduinoscope Beispiel haben (unter File/Examples.)
Dies ist die Quelle für die Stand-alone-Anwendungen.

Poormans Oszilloskop (mit Arduino + Processing)

Fr, 06/20/2008 - 5.32 - Sofian

Diese Software ermöglicht es Ihnen, eine visuelle Darstellung eines analogen Signals mit Arduino und Verarbeitung zu erhalten. Die Auflösung beträgt 10 Bit, was gut ist, aber die Frequenz ist viel niedriger als die von einem realen Oszilloskop, aber es ist immer noch ziemlich nützlich.

Es funktioniert, indem Sie Werte aus dem Arduino Board (Pin 0) zu lesen, um Verarbeitung durch serielle Kommunikation.

Alternative Arduino Oszilloskop Projekte

Arduinoscope (wurde von unserem Oszilloskop inspiriert)

https://code.google.com/p/arduinoscope/
http://accrochages.drone.ws/en/node/90
http://makezine.com/2008/07/02/cheap-oscilloscope-built/

*********************************************************
studioarduino
Arduino e Processing

http://studioarduino.wordpress.com/2013/04/18/arduino-e-processing/

SENDER:           ARDUINO-UNO Oscilloscopio (1-Kanal)_1a.ino
EMPFÄNGER:   Processing ARDUINO-UNO Oscilloscopio (1-Kanal)_1a.pde

*********************************************************
Arduino Poor Man’s Oscilloscope

SENDER:           ARDUINOscope 1-Kanal_1a.ino
EMPFÄNGER:   Processing ARDUINOscope 1-Kanal_1a.pde

http://mitchtech.net/arduino-oscilloscope/

*********************************************************
Arduino - Improved Poor Man's Oscilloscope
http://www.instructables.com/id/Arduino-Multi-Channel-Oscilloscope-Poor-Mans-O/?lang=de
http://www.instructables.com/id/Arduino-Improved-Poor-Mans-Oscilloscope/?lang=de
http://www.instructables.com/id/Arduino-Oscilloscope-poor-mans-Oscilloscope/

Poorman's oscilloscope (with Arduino + Processing)
Mein Processing Code ist eine Erweiterung Verarbeitung von
Sofian Audry der Oszilloskop, mit Änderungen für Abtastrate, Genauigkeit, Anzahl der Kanäle usw.
http://accrochages.drone.ws/en/node/90

Arduino Poor Man's Oscilloscope

http://blog.arduino.cc/2010/02/25/poormans-oscilloscope-with-arduino-processing-and-arduinoscope/

Arduino – Poor Man’s Oscilloscope

http://randomnerdtutorials.wordpress.com/2013/02/01/arduino-poor-mans-oscilloscope/
http://randomnerdtutorials.com/arduino-poor-mans-oscilloscope/

Arduino Poor man's oscilloscope processing code
https://gist.github.com/chrismeyersfsu/3270419

*********************************************************
Arduino High speed Oscilloscope with PC interface
http://www.instructables.com/id/Arduino-High-speed-Oscilloscope-with-PC-interface/

Arduino Frequency Detection
http://www.instructables.com/id/Arduino-Frequency-Detection/

*********************************************************

Arduino + Oscilloscope = Arduinoscope

einfache Projekt namens arduinoscope zu Ihrem arduino in ein einfaches Oszilloskop konvertieren. Es bedarf der Verarbeitung (Java basiert), Arduino IDE und zwei Verarbeitungsbibliotheken
Verarbeitungs-arduinoscope und controlP5 - eine grafische Benutzeroberfläche für die Verarbeitung.

http://pablotrigo.com/blog/?p=166
https://github.com/konsumer/arduinoscope

*********************************************************

BUILD A 6 CHANNEL OSCILLOSCOPE WITH JUST ARDUINO

arduino-arduinoscope.pde

http://lawrencematthew.wordpress.com/2011/08/30/build-a-6-channel-oscilloscope-with-just-arduino/
http://www.homebrew-tech.com/arduino/brewing-arduino-announcement/usingarduinoasoscilloscope-arduinoscope

*********************************************************

XOscillo
Arduino oscilloscope (and Parallax)

A software oscilloscope that acquires data using an arduino or a parallax (more platforms to come).

xoscillo ist ein C # (Windows) Werkzeug.

https://code.google.com/p/xoscillo/

Arduino based oscilloscipe

Eigenschaften

Keine Notwendigkeit für zusätzliche Hardware, um die grundlegenden Funktionen zu erhalten
Max Frequenz 7 KHz, genug für Bastler
bis zu 4 Kanäle (mit einer niedrigeren Abtastrate 7/4 KHz)
8bit vertikale Auflösung
Variable Trigger-Spannung auf Kanal 0
Kann Daten so lange, wie Sie benötigen, probieren

Schnellstart

Flash Ihre Arduino mit der Firmware, die in der Zip-Datei kommt.
Verwenden Sie die analogen Eingänge von # 0 bis # 3
- beachten Sie, der Trigger überwacht nur den analogen Kanal pin-A0.
Starten Sie die App
Im Menü finden Sie auf "Datei" und dann auf "Arduino"

Aufzeichnungen

Das Arduino-ADC liest Werte von 0 bis 5 Volt, kann es negative Spannungen aus der Box nicht lesen

pin-A0 pin-13
oscope_arduino_1a

to solve the "Waiting for trigger" issue just connect something to analog in 0 and set trigger to in example 1, this will activate XOscillo when the signal reaches 1 volt. You can use other voltages as well.

zur Lösung der "Warten auf Trigger" Thema schließen Sie einfach etwas in 0 analog und stellen Sie Trigger in Beispiel 1, wird dieser XOscillo
aktivieren, wenn das Signal 1 Volt erreicht. Sie können andere Spannungen zu nutzen.

XOscillo.exe (geht nicht da ARDUINO ohne neue Firmware)

http://codinglab.blogspot.co.at/2010/09/arduino-oscilloscope-and-parallax.html

https://code.google.com/p/xoscillo/
https://code.google.com/p/xoscillo/wiki/arduino

PARALLAX PropScope USB Oscilloscope € 179,-

http://www.parallax.com/product/32220?SortField=ProductName,ProductName

*********************************************************
Signal Processing (Signalverarbeitung)

Small Electronic Thingies for All Kinds of Fun Stuff

Einführung
Diese Seite beschreibt eine einfache arduino-processing-sketch, die als sehr elementare Oszilloskop-Funktionen.
Der Arduino packt Daten aus seinem analogen Anschluss, während gleichzeitig die Ausgabe eines vorgegebenen Wellenform auf einem PWM-Pin. Im Falle dieses Beispiels führt die vorgegebene Signalverlauf im Sinus von 100Hz.

Oscilloscope

Version 1

In einem Interrupt-Schleife von 1kHz die Abtastwerte gespeichert.
500 samples/Bild werden aufgenommen, so dass eine Aktualisierungsrate von etwa 2 Bilder / Sekunde kann bei der Verarbeitung Sketches zu erwarten.

Beim Processing-Sketch kann
Offset (vertikalen Versatz) unter Verwendung von [w] und [z] skaliert werden.
Amplitude kann unter Verwendung von [e], [x] skaliert werden.
Zeitscala kann unter Verwendung von [a] und [s] skaliert werden.

}
void keyPressed(){
if (key=='w') offset-=10;     // + 0,0V 0,2V 0,4V usw. (10pixel = 0,2V)
if (key=='z') offset+=10;    // - 0,0V 0,2V 0,4V usw.
if (key=='e') amplitude+=0.1; // 0,0V..2,5V..5,0V = 250pixel
if (key=='x') amplitude-=0.1;
if (key=='a') timescaling-=0.1; //100ms/Div.   (500pixel = 500ms)
if (key=='s') timescaling+=0.1;
}

        ____
>----|___|----+-----> out
       1k     |
          1uF =
              |
             GND
         Bild RC-Filter

Vorgeschalteter Tiefpass-Filter (Treble cut) 1k 1uF = 159,15Hz = Zeitkonstante 0,001sec.

Abtastfrequenz auf 1 kHz (1000 WERTe / Sek. ) Div. 100ms = 10Hz

Analog-Eingang pin-A0 UND LED an Digital-Ausgang pin-9

SENDER: Arduino-Sketch: Signal Arduino 1Kanal-Oszi 1kHz_1a.ino
EMPFÄNGER: Processing-Sketch: Signal Processing 1Kanal-Oszi 1kHz_1a.pde

http://wiki.edwindertien.nl/doku.php?id=software:signalprocessing

*****************
Version 2
Sketch Version 2 hat auch zusätzlich eine Cursor-Funktionalität mit Hilfe der linken und rechten Maus.
Dazu kommt, dass die Abtastfrequenz auf 5 kHz erhöht wurde.

Mit dem folgenden 5 kHz Arduino Sketch - die in der Lage mehrere Wellenformen (Sägezahn, Sinus, Rechteck, Dreieck, ) ist.
Der folgende Code erzeugt die grundlegenden Wellenformen bei 100 Hz
- treffen Sie Ihre Auswahl der gewünschten Signalform

outputValue[n]=(n*5)%250; // Sägezahn// ODERoutputValue[n]=(char)127*sin((float)2*Pi*n/50)+127; // Sinus// ODERif(sin((float)2*Pi*n/50)>0) outputValue[n]=255; else outputValue[n]=0; // Rechteck// ODERif(((n*10)%500)>250) outputValue[n] = 250-(n*10)%500; else outputValue[n] = (n*10)%500; // Dreieck

Stellen Sie sicher, dass die Wellenform passt: Amplitude muss zwischen 0 und 255 muss die gesamte Wellenform "loopable 'in 500 Werte sein.

// working with an arduino dumping 500 bytes of data every second or so
// adjust amplitude with [e] and [x]
// adjust vertical offset with [w] and [z]
// adjust timescale with [a] and [s]
// Left and Right mouse can put a measurement cursor in the plane

Vorgeschalteter Tiefpass-Filter (Treble cut) 1k 1uF = 159,15Hz = Zeitkonstante 0,001sec.

Abtastfrequenz auf 1 kHz (1000 WERTe / Sek. ) Div. 100ms = 10Hz (Puls=50ms & Pause=50ms)

SENDER: Arduino-Sketch: Signal Arduino 1Kanal-Oszi 5kHz_1a.ino

Mit dem folgenden 5 kHz Arduino Sketch - die in der Lage mehrere Wellenformen (Sägezahn, Sinus, Rechteck, Dreieck, ) ist.
Der folgende Code erzeugt die grundlegenden Wellenformen bei 100 Hz
- treffen Sie Ihre Auswahl der gewünschten Signalform

for(int n=0;n<500;n++) {
//outputValue[n]=(n*5)%250; // Sägezahn
outputValue[n]=(char)127*sin((float)2*Pi*n/50)+127; // Sinus
//if(sin((float)2*Pi*n/50)>0) outputValue[n]=255; else outputValue[n]=0; // Rechteck //if(((n*10)%500)>250) outputValue[n] = 250-(n*10)%500; else outputValue[n] = (n*10)%500; // Dreieck
}

EMPFÄNGER: Processing-Sketch: Signal Processing 1Kanal-Oszi 5kHz_1a.pde

http://wiki.edwindertien.nl/doku.php?id=software:signalprocessing

*****************
Graphwriter für XBee Beschleunigungsmesser

Ein weiterer Sketch zur Visualisierung von Sensor-Daten, unter verwendung einer Processing-Grafik.
Sketch für 6 Analog-Sensor-Werte (50 Hz)
Als Sensoren hat einen analogen Joystick auf 3 Analog-Eingänge hinzugefügt pin-A0, pin-A1 und pin-A2.
Ein XBee Beschleunigungsmesser ist mit den 3 Analog-Eingängen pin-A3, pin-A4 und pin-A5.

// 6-Analoge Signalwerte bei 20Hz schreiben auf Serial-Port auf 9600bps
// Jeden Wert mit vorangestellten Header A, B, C, X, Y, Z
// connect DIN of module to pin-3 (TxD) and Dout of module to pin-2(RxD)

SENDER:         Arduino-Sketch:       Signal Arduino 6Kanal-Oszi 50Hz_1a.ino

// Analoge-Signal Grafik-Schreiber
// 6 Analoge Signale, bei 9600bps aufnehmen
// Jeden der 6-Werte mit Header A, B, C, X, Y, Z
//
// pausiert des Bildschirms mit der Leertaste
// durch drücken der Leertaste Anzeige läuft wieder weiter
// Taste <C> löscht den Bildschirm
// Taste <R> beginnt mit der Aufzeichnung der Werte in einer Datei
// Taste <S> stoppt die Aufnahme.
// Jedes Mal wenn die Taste <R> gedrückt wird, wird eine neue Datei
// "values1.txt" mit Fortlaufender-Nummer angelegt.

EMPFÄNGER: Processing-Sketch: Signal Processing 6Kanal-Oszi 50Hz_1a.pde

http://wiki.edwindertien.nl/doku.php?id=software:signalprocessing

*********************************************************
Arduin-O-Scope (a tiny oscilloscope project)
appears to be similar to the Poorman's oscilloscope in terms of capabilites.
Arduin-O-Scope ist ein winziges Oszilloskop-Projekt.
http://forum.arduino.cc/index.php/topic,8077.0.html

Aniss SerialScope
Serial oscilloscope
http://forum.arduino.cc/index.php?topic=8807.0

ArduinoCommander
http://arduinocommander.blogspot.co.at/2013/02/oscilloscope.html
http://www.arduinocommander.info/2013/03/upload-sketch.html

basiert auf der Poormans Oszilloskop oben machen einige Verbesserungen einschließlich Mehrkanal-Unterstützung,
Logik-Analysator-Modus und Anzeigen numerischer Werte neben der grafischen Darstellung der Messwerte basieren.
https://code.google.com/p/arduinoscope/
https://github.com/konsumer/arduinoscope

Fa. Agilent   Why Oscilloscope Bandwidth Matters
http://www.adafruit.com/blog/2012/01/27/why-oscilloscope-bandwidth-matters/

*********************************************************
       NUR WECHSELSPANNUNG wartet auf Nulldurchgang

Dr. Monk's DIY Electronics Blog      Monk Makes Simon Monk (Autor)

Project 18 Oscilloscop

Projekt 18 im Simon Monk Buch 30 Arduino Projekts for the EVIL GENIUS

Prg. liest die 10-bit Daten von Analog-Eingang pin-A0, teilt die WERTe durch 4 um Byte WERTe (8-bit) zu erhalten.
Diese Bytes werden dann über den Serial-Port COM6 (USB) an das Processing-Empfangsprogramm gesendet.

Externe Schaltung - sie schafft eine 2,5V Referenz für eine AC-Kopplung.

ACHTUNG: Eingang nur für Wechsel-Spannung +/- 2,5Vss
Beachten Sie, dass es keinen Überspannungsschutz, so zu verstehen, was Sie versuchen, und messen Sie mit ihr, oder Sie beschädigen oder zerstören Sie Ihre Arduino könnte.

Arduino UNO or Diecimila or Duemilanove Board

C1 220 nF nonpolarized
C2, C3 100 μF electrolytic
R1, R2 1 MΩ 0.5W metal film resistor
R3, R4 1 KΩ 0.5W metal film resistor

Abbildung 7-2

SENDER: Arduino-Sketch: Project18-Oscilloscope_2a.ino
EMPFÄNGER: Processing-Sketch: Processing-Project18-Oscilloscope_2a.pde

Y = + / - 250 Werte = + / - 2,5Vs X = 800 Werte

Neue Werte überschreiben die vorhandenen | alten Werte

http://www.doctormonk.com/2011/12/arduino-oscilloscope-update.html
http://www.doctormonk.com/2011_12_01_archive.html

Projekt 18 Oszilloskop
Ein Oszilloskop ist ein Gerät, mit dem Sie sehen können ein elektronisches Signal, so dass es als ein erscheint
Wellenform.
Ein traditionelles Oszilloskop funktioniert durch Verstärken eines Signals, die Position eines Punktes zu steuern,
auf der Y-Achse (vertikale Achse) der Kathodenstrahlröhre während ein Zeitbasis-Mechanismus Sweeps links nach rechts
die X-Achse und dann klappt zurück, wenn es erreicht die Ende.

Dieses Projekt liest Werte aus dem analogen Eingangs pin-A0 und sendet sie über USB an den Computer an.
Anstatt durch die Serial Monitor empfangen werden, werden sie werden durch ein kleines Programm, das ihnen zeigt eingegangen
in einem Oszilloskop artig.
Da das Signal ändert, ändert sich die Form der Wellenform.
Beachten Sie, dass, wie Oszilloskope gehen, ist dies eine nicht werde keine Preise für Richtigkeit und Geschwindigkeit gewinnen, aber

Dies ist das erste Mal, dass wir Kondensatoren verwendet.
C1 kann entweder umgekehrt angeschlossen werden; jedoch
C2 und C3 sind polarisiert und müssen angeschlossen werden richtig gepolt, oder sie werden beschädigt.
Wie bei den LEDs auf polarisierten Kondensatoren, die Plusleitung (als weißes Rechteck auf markierten
Das schematische Symbol) länger ist als die negativen führen. Die Minusleitung auch oft eine - (minus) oder Raute neben dem Minusleitung.

Hardware
Abbildung 7-2 zeigt die schematische Darstellung für Projekt 18
Es gibt zwei Teile der Schaltung. R1 und R2 hochohmige Widerstände, dass "Nullpunkt" der Tonsignal der Analogeingang auf 2,5V.
Sie sind wie ein Spannungsteiler.
Der Kondensator C1 kann der Signal ohne jede Gleichstrom (DC) Komponente übergeben auf das Signal (Wechselstrom oder AC-Modus in ein
traditionelle Oszilloskop).
R3, R4, C2, C3 und liefern nur eine stabile Referenzspannung von 2,5V.
Der Grund dafür ist, so dass unsere Oszilloskop kann sowohl positive Anzeige und negative Signale.
So eine Klemme unserer Messleitung ist bei 2,5V festgelegt;
Ein Signal an die andere Leitung wird relativ zu dem.
Eine positive Spannung wird bedeuten ein Wert am Analogeingang von mehr als 2,5V, und ein negativer Wert einen Wert am Analog bedeuten
Eingang von weniger als 2,5V.

Software
Die Sketch ist kurz und einfach (Listing Projekt 18).
Sein einziger Zweck ist es, den Analogeingang zu lesen und die WERTe auf den USB-Anschluss so schnell wie möglich zu senden.
Das erste, was zu beachten ist, die Baudrate auf 115.200, die höchste zur Verfügung stehende.
Daten durch die Verbindung als möglichst ohne komplexe Kompressions-Techniken, werden wir unsere Roh- Zehn-Bit-Verschiebung
Wert rechts zwei Bits (value = (value >> 2); dies hat die Wirkung der Division durch vier und es werden aus 10bit-WERTe 8-bit-WERTe

Der einfachste Weg, um das Oszilloskop zu prüfen ist, verwenden die einen leicht verfügbaren Signal, das durchdringt
meiste Zeit unseres Lebens und das ist Netzbrummen. Netz Strom oszilliert bei 50Hz oder 60 Hz , und jedes elektrische
Gerät strahlt elektromagnetische Strahlung bei dieser Frequenz.
Um ihn abzuholen, ist alles, was Sie tun müssenm berühren Sie die Messleitung an die analogen Eingang
und Sie sollten ein Signal ähnlich dem zu sehennAbbildung 7-1.

Sowie welches die Wellenform, die Fenstermenthält einen kleinen Kasten mit einer Anzahl darin.
Dies ist die Anzahl der Abtastwerte pro Sekunde.
Jede Probe stellt ein Pixel in dem Fenster, und das Fenster ist 600 Pixel breit.
Eine Abtastrate von 4700 Abtastungen pro Sekunde bedeutet, dass jede Probe eine Dauer 1/4700 Sekunden, und so die volle Breite der
600 Proben stellt 600/4700 oder 128 Millisekunden.
Die Wellenlänge in Abbildung 7-1 ist ca. 1/6 der das, oder 21 Millisekunden, was entspricht einer Frequenz von 1 / 0,021 oder 47.6Hz.
Das ist, nahe genug, um zu bestätigen, dass das, was wir sehen, gibt es eine Netzfrequenz von 50 Hz Brummen.

Die Amplitude des Signals, wie in den angezeigten Abbildung 7-1, mit einer Auflösung von einem Pixel pro Beispielschritt, wobei es 256 Stufen.
Also, wenn Sie Verbinden Sie die beiden Messleitungen zusammen, die Sie sehen sollten eine horizontale Linie auf halbem Weg über das Fenster. diese entspricht 0 V und 128 Pixel vom oberen Rand auf dem Bildschirm, wie das Fenster ist 256 Pixel hoch.
Dies bedeutet, dass da das Signal um zwei Drittel des Fensters, die Amplitude des Signals ungefähr 3 V Spitze-Spitze.
Sie werden feststellen, dass die Abtastfrequenz wechseln ziemlich viel, etwas verstärkt, dass dies die gröbsten von Oszilloskopen und nicht geltend gemacht werden auf für alles entscheidend.
Um die Zeitbasis ändern, ändern Sie den Wert in die delay Microseconds Funktion.

*********************************************************
Electronics-Lab.com Blog

http://www.electronics-lab.com/blog/?p=29451
http://www.open-electronics.org/guest_projects/a-pc-and-an-arduino-heres-your-diy-oscilloscope/

Wir haben ein Oszilloskop mit PC und Arduino Board entwickelt. Das Signal wird zunächst zugeführt Arduino Ausschusses, wenn das analoge Signal in ein digitales Signal durch den ADC die dann seriell an den PC ausgegeben wird, und wird durch die Software MATLAB über die COM-Ports gelesen umgewandelt. Hier wird das Signal in Form von digitalen Daten zu lesen, sondern wird dann umgewandelt, um ein unter Verwendung der Auflösung des ADC vom Arduino verwendet Analog. Die Software MATLAB wurde dann verwendet, um die Signale zu plotten.

033_d_DESIGNING-x_A-PC-OSCILLOSCOPE-USING-ARDUINO_1a.pdf

A PC and an Arduino: here’s your DIY Oscilloscope
http://www.open-electronics.org/guest_projects/a-pc-and-an-arduino-heres-your-diy-oscilloscope/

*********************************************************
Digital Sampling Oscilloscope LabVIEW

Mary Anne Peters & Joseph Tylka
Department of Mechanical and Aerospace Engineering
Princeton University, Princeton, NJ 08544, USA

Stückliste
1 Arduino Nano                     ATmega328
3 Op-Amp (package of 2)            UA747CN
1 Bilateral Switch (package of 4) TC4066BP
1 NAND Gate (package of 4) SN7400N
1 NOT Gate (package of 6)          SN7404N
1 AND Gate (package of 4)          SN74LS08N
1 Digital Buffer (package of 8)    SN74LS244N
2 D-Type Flip-Flop (package of 4) SN74S175N
1 Analog to Digital Converter      ADC0800PCD
2 Digital to Analog Converter      DAC0800LCN
1 4-Bit Counter                    SN74LS163AN
1 12-Bit Counter                   CD4040BE
1 Static RAM                       HM6116P
1 Bit Rate Generator              MC14411

1 Resistor          470R
1 Resistor          5,1k
7 Resistor           10k
1 Resistor           15M
1 Variable Resistor 10k
1 Potentiometer     100k
2 Capacitor         10nF
1 Capacitor         68nF
4 Capacitor        100nF
1 Crystal      1,8432MHz
1 Push Button Switch –
2 SPDT Switch –

Fig. 12. Oszilloskop-Daten im Vergleich zu Daten nach der Analog-Wandlung, gemessene mit LabView über das ARDUINO Abtastrate: 1200 Hz.

Auszug: Nur schlechte Maschinen-Übersetzung aus dem Englischen.

F. Arduino Nano Mikrocontroller
Wie im vorherigen Abschnitt, der Arduino deutlich spielt eine wichtige Rolle beim Betrieb unseres Oszilloskops.
Es ist für die Initialisierung des Verfahrens auf das Füllen verantwortlich SRAM mit Daten entsprechend einem Schwung des Eingangs Signal.
Zusätzlich liest der Arduino die Daten, die ist an den Daten-Eingabe / Ausgabe-Pins des SRAM vorhanden ist und
sendet diese 8 Bits als ein Byte über eine serielle Schnittstelle an das Computer.
Die Daten können dann in LabView betrachtet werden, wie in Abschnitt diskutiert werden. II-H.
Der Schreib-Sweep Druckknopf ist mit der Arduino, die den Anwender verbunden drückt, um den Schreibvorgang zu starten.
Der Schaltplan für Arduino ist in Fig. 19.
Bevor wir unsere spezifischen Arduino-Code, werden wir diskutieren die Arduino-Programmierumgebung und Code
Struktur im Allgemeinen. Das Arduino-Programmierumgebung ist sehr ähnlich zu C und C ++, aber mit vielen einzigartigen integrierten Funktionen.
Der primäre Zweck des Arduino ist, um den Code in dem Haupt wiederholt auszuführen Schleife, mit Leere Schleife () aufgerufen wird, während die Arduino ist
eingeschaltet ist.
Natürlich kann, wie bei jeder anderen Programmiersprache Umgebung müssen einige Initialisierungsschritte genommen werden.
die ersten Codezeilen sind die Variablendeklaration und Initialisierungsbefehle.
Unmittelbar nach den Variablendeklarationen wird die Setup-Routine, mit Leere Setup () aufgerufen. viele wichtige Aktionen innerhalb dieser Funktion durchgeführt.
Zum Beispiel kann das Programmiergerät anzugeben, welche von die digitalen Stifte auf der Arduino wird als digitale eingesetzt werden
Eingänge (Lesen digitale Signale) und welche digital sein wird Ausgänge (Herstellung von digitalen Signalen).
Ähnlich werden die analogen Stifte als Analogeingänge angegeben werden (Lesen Analog Signalen durch und ADC) oder analoge Ausgänge (Herstellung
pulsweitenmodulierte Analogsignale).
Auch die Kommunikations Einstellungen auf der Arduino in der erklärt Setup-Funktion, wie beispielsweise die Initialisierung einer seriellen Verbindung
und Festlegung der Übertragungsrate.
Eine nützliche Eigenschaft des Arduino sind seine "unterbrechen" Pins.
Diese Stifte können als normale digitale Stifte funktionieren, oder Unterbrechungen, die besondere Priorität in die gegeben sind Arduino Verarbeitung.
Um als Interrupt-Funktion, die Interrupt-Pin muss so konfiguriert werden, um ein bestimmtes Signal zu detektieren verwendet,
beispielsweise einem niedrigen zu hohen Übergangs (unter Verwendung ansteigend), absteigend Übergang (mit FALLEN) oder entweder
Übergang (mit CHANGE).
Die Interrupts kann auch sein, konfiguriert ist, um zu erfassen, wenn das Signal einen hohen oder niedrigen Verwendung hoch oder niedrig sind.
Wenn die festgelegte Funktion auftreten, sofort verlässt das Arduino gleich welcher Verarbeitungs es lief, und führt die Interrupt vorgesehene Funktion.
Nachdem die Interrupt-Task abgeschlossen ist, kehrt der Arduino zur Hauptschleife.
Hinweis daß die Interrupts Nummern (typischerweise 0 und 1) gegebenen welche von den digitalen Stiften, auf denen sie sich unterscheiden kann
aktiviert (typischerweise 2 bzw. 3). Digitaler Stift D13 ist einzigartig, da er verbunden ist eine LED auf der Arduino Platine neben funktioniert wie eine normale Digitalstift.
Dies macht Pin D13 besonders nützlich für die Fehlersuche, da eine visuelle Rückmeldung kann dem Benutzer sofort gegeben werden.
Sobald die Arduino-Code kompiliert wurde, muss sie in das Gerät geladen werden via USB.
Der Darenverkehr zwischen der Arduino und der PC (wie Daten, die an die serielle geschickt Port) erfolgt ebenfalls über den USB.
Wir diskutieren jetzt den Steuercode haben wir umgesetzt in der Arduino.
Der Pseudocode-Version der Code wird in Alg gegeben. 1 und wird der aktuelle Code reproduziert
in Fig. 9 im Anhang. Zeilennummern in diese gegeben Abschnitt mit dem Pseudocode in Alg beziehen. 1. Auch Fig. 3
zeigt die Struktur des Arduino Code als Block-Diagramm.

Algorithm 1 Arduino Control Code
1: loop
2: Read inputs D5 through D12
3: Compile data into byte
4: Send byte across the serial line
5: end loop
6: interrupt (D3: low ! high)
7: Set D13 = high
8: end interrupt
9: interrupt (D2: low ! high)
10: if D13 == high then
11: Set D13 = low
12: end if
13: end interrupt

Für die Datenerfassung mit dem Arduino, haben wir 8 Digital Stifte, D5 bis D12, als digitale Eingänge konfiguriert. die
Primärkreislauf des Arduino beginnt durch Lesen der Signale bei diesen Digitaleingänge (Linie 2).
Das Arduino dann kompiliert diese 8 Datenbits in einem Byte (line 3), die über eine serielle Schnittstelle mit dem PC (Linie 4) gesendet wird.
Diese Daten können dann mit LabView betrachtet werden, wie wir wollen diskutieren in Sec. II-H.
Wir haben zwei digitale Stifte, D2 und D3, die sind als digitale Eingänge konfiguriert und werden als Unterbrechungen verwendet.
Beide Interrupts werden ihre jeweiligen Eingänge zu überwachen bei steigender Flanke, dh einen aufsteigend Übergang (Linien 6 und 9).
Wir haben auch die D13 Digitalstift configure als digitaler Ausgang.
Der Schreib Sweep Druckknopf bis D3 verbunden ist, so dass, wenn der Benutzer den Knopf drückt, die Arduino führt die angegebene Funktion sofort
als Reaktion auf Interrupts.
In unserem Fall ist die Funktion, führen wir Sätze der D13 Pin auf High (Linie 7), die, wie in Abschnitt diskutiert. II-E, kann die SRAM-Steuerlogik
so daß Daten in den Speicher geschrieben werden.
Auch von Sec. II-E, der Q9-Ausgang des Zählers ist mit D2 gesendet, so dass, wenn die letzte Adresse ist, die durch den Zähler erreicht und Q9
hoch ist, die zweite Interrupt-Funktion ausgeführt. in unserem Fall beginnt die Funktion, indem Sie den Zustand der D13 (Linie 10) und, wenn D13 ist derzeit hoch, die Funktionssätze es low 8 werden (Zeile 11).
Wenn D13 liefert niedrig ist, kann Daten nicht mehr in den Speicher geschrieben werden.
Wir bemerken, dass, unabhängig von der Interrupt-Funktionen, die Arduino immer Streaming der Daten von den Ausgängen
des SRAM in den PC.
Das heißt, selbst wenn Daten wird nicht mehr in den Speicher geschrieben, werden die Arduino weiterhin die gleiche Wellenform an die PC zu strömen, da
wird der Zähler um durch Adressen weiter und das SRAM wird im Lesemodus, bis der Benutzer gesperrt werden drückt die Schreib Sweep Taster.
Zusammenfassend hat die Arduino zwei Interrupt-Pins, D2 und D3, der Q9-Ausgang des 12-Bit-Überwachung Zähler und der Schreib Sweep Taster bzw.
für steigende Flanken. Der Ausgang D13 sendet ein Steuersignal um Steuerlogik des SRAMs um anzuzeigen, dass Daten können
an den SRAM geschrieben. Auch werden die Datenstifte auf dem SRAM werden zu 8 digitale Eingänge auf der Arduino, D5 verbunden
D12, so daß der Arduino kann, dass Daten zu senden der PC.
Der Schreib-Sweep-Taster im wesentlichen beginnt eine Kettenreaktion von Ereignissen, um das Schreiben einer zu erleichtern
Single-Sweep des Eingangssignals in den Speicher. Erstens, die 12-Bit-Zähler gelöscht, so daß die SRAM beginnt
schriftlich bei der ersten Adresse. Gleichzeitig wird der D13 Ausgabe des Arduino hoch eingestellt ist, so dass die SRAMs
Steuerlogik kann eine Datenerfassung durch die gesendet werden Puffer und in den Speicher geschrieben. Wenn die Benutzermitteilungen
der Druckknopf beginnt der Zähler zu zählen, und die ADC beginnt der Speicher voll. Genau 256 Probenahme
Frequenztaktperioden nach dem Loslassen der Taste, Q9 geht hoch und der D13 Ausgang niedrig eingestellt, so dass die Daten kann nicht mehr in den Speicher geschrieben werden.

B. Messungen mit LabView
Vor diesem Zeitpunkt sind die in diesem Abschnitt dargestellten Daten erfasst mit Hilfe der professionellen Oszilloskop und neu gezeichnet
mit MATLAB. Daten erfasst Hier diskutieren wir LabVIEW über die Arduino, die das Endprodukt ist unsere Oszilloskop.
Erfassen von Daten mit LabView ist ein Dreiin Abschnitt beschriebenen Schritten. II-E, II-F und II-H.
Abbildung 12 im Anhang zeigt die LabView-Capture mit eine Abtastfrequenz von 1200 Hz.
Die untere Grundstück ist von LabView genommen, während die obere Grundstück wurde mit erfasst die Tisch Oszilloskop zum Vergleich.
LabView wiederholt Stücke dieselben im Speicher gespeichert, bis die Daten der Benutzer neue Daten schreibt in den Speicher. ca.
zwei Durchläufe durch die Speicher sind in Fig. 12.
Eine Diskontinuität ist sichtbar, wenn das Signal wiederholt (diese kommt zweimal in der Figur), was anzeigt, dass das Eingangssignal
wurde an verschiedenen Punkten in seiner Periode zu Beginn die Pfeilung und am Ende.
Die obere Grafik zeigt die T Signalzählen (blaue Linie) und das Y-Signal (grün Linie) durch die DACs erzeugt.
Beachten Sie, dass die Zeit auf die X-Achse in LabView ist in Millisekunden. die Dauer von einem Zug der Daten ist ca. 213 ms
(256 Perioden = 1200 Hz) für diesen Fall.
Die Amplitude das abgetastete Signal können maximal 5 V sein? was würde zu einem Minimum von 0 zählt (􀀀5 V) entsprechen,
oder ein Maximum von 255 Zählungen (+5 V) auf der Y-Achse (mit der Bezeichnung Amplitude) der LabView Grundstück.
In unserem Fall, das abgetastete Signal eine max / min von etwa der? 2 V dies entspricht einer Amplitude zwischen 80 und 180
zählt in LabView, das ist das, was wir beobachten.
So, um verwenden Sie die LabView-Display als Oszilloskop, einem einfach liest die X-Achse die Zeit in Millisekunden und die Y-Achse
kann auf eine Spannung, die durch Subtrahieren von 128 von umgerechnet werden die Amplitude und Multiplizieren des resultierenden Werts durch das

Verhältnis 5 V = 128 zählt.
Fig. 13, ebenfalls in der Anlage, eine zweite Wellenform in LabView mit einer Abtastrate erfasst, jetzt 9600 Hz.
In beiden dieser LabView Messungen der Frequenz des Eingangssignals ist? 65 Hz.
Beachten Sie, dass die höhere Abtastrate macht die Diskretisierung von die Abtast- und Halteschaltung weniger bemerkbar. jedoch
die Folge der höheren zeitlichen Auflösung ist, dass weniger Schwingungen in den Speicher bei einer gegebenen erfassten
Eingangssignalfrequenz, die Größe des Speichers fixiert.
In diesem Fall ist nur etwas mehr als eine Periode des Eingangssignals erfasst und im Speicher gespeichert.
Bei einer Samplefrequenz von 9600 Hz, ca. 27 ms (256 Perioden = 9600 Hz) des Signals erfasst wird.

033_d_fritz-x_Digital Sampling Oscilloscope § ATmega328p (28 Seiten) LabView_1a.pdf
http://www.princeton.edu/ssp/exp.-methods/mae511.pdf

*********************************************************
Arduino-Watchdog-Circuit

https://github.com/mattbornski/Arduino-Watchdog-Circuit

*********************************************************

Arduino based Digital Oscilloscope

Arduino basiert Digital-Oszilloskop
Verfasst am 4. August 2011 von M. Nguyen

Ich wollte schon immer ein Oszilloskop zu Hause haben. Ich versuche, ein Digital-Oszilloskop mit dem Arduino zu machen.
Ich habe die Digital-Oszilloskop in einem Arduino Schild.
Gerade jetzt, es ist nicht sehr gut. Es funktioniert, aber es Verzerrungen im empfangenen Signal.

Ich habe eine TLV571 Chip, ein Hochgeschwindigkeits -Analog-Digital-Wandler ist. Der ADC hat eine Bandbreite von 1,25 Millionen Abtastungen pro Sekunde.
Ich habe auch die INA128 Chip, ein Instrumental-Verstärker ist.
Ein Instrumentenverstärker ermöglicht es Ihnen, eine Spannung, ohne das Signal zu stören zu messen.
Ich verwendete Operationsverstärker auf 0 bis 5 Volt zu verkleinern -12 bis 12 Volt-Signale. Ich habe auch einen MAX633 die eine Spannung Schritt nach oben, die eine duale Spannungsversorgung von -12 und 15 Volt erzeugt werden können.
Ich habe auch einen BNC-Stecker so ein BNC-Testkabel kann wie ein echtes Oszilloskop verwendet werden.

Der ADC wird durch die Arduino kontrolliert. Der ADC nimmt 600 Datenproben und die Arduino sendet die Proben auf den Computer.
Früher habe ich eine Software namens Verarbeitung, um die Daten aus dem Arduino zu erhalten und die Daten grafisch darzustellen.
Die Abtastzeit erhöht und durch Verwendung der "A" und "z" verringert werden.
Die Verzögerungszeit ist die Zeit zwischen jeder neuen Gruppe von Abtastwerten genommen wird, kann mit Hilfe des "s" und die Taste "x" verändert werden.
Ich habe nicht den genauen Zeitpunkt der Verzögerungen und Probenahmezeit, da ein Bedarf ein echtes Oszilloskop zu messen, dass.

Der Digital-Oszilloskop ist nicht vollständig getestet.
Das erste Bild zeigt ein 1000 Hz Signal, das von einem anderen Arduino generiert wurde.
Die Bandbreite ist im Moment nicht sehr gut, da die Arduino ist ein bisschen langsam. Ich hoffe, dass die Geschwindigkeit mit einem anderen Mikrocontroller verbessern.
Es ist eine Verzerrung, die in dem dritten Bild zu erkennen ist.
Diese Verzerrung ist sehr bemerken konnte.
Keine Verzerrung, wenn das digitale Oszilloskop und das Signal, das Läufe von derselben Stromquelle gemessen.
Der Digital-Oszilloskop muss sich mit einem Netzteil mit ausreichender Leistung zu bekommen gesteckt werden.

Im Augenblick ist die Digital-Oszilloskop ist nicht sehr gut, aber ich hoffe, die Probleme in der Zukunft zu beheben.

Hier ist der Schaltplan

http://therobotfix.wordpress.com/2011/08/04/arduino-based-digital-oscilloscope/

*********************************************************
Practical Arduino

Arduino Oscilloscope / Logic Analyzer

Keine Elektronik nur Chinch-Stecker-Adapter

Einer der frustrierenden Dinge über die Entwicklung und das Debugging elektronischen Schaltungen ist, dass man nicht in der Schaltung, um zu sehen, was geschieht.
Selbst mit einer Schaltung, bevor Sie sich auf eine Werkbank gelegt und eingeschaltet mag es scheinen, als wärst du in der Dunkelheit, nicht in der Lage, herauszufinden, warum eine Eingangsänderung oder Veränderung in einem Teil der Schaltung wird der Effekt, den Sie erwarten, nicht mit.
Manchmal kann es sich wie Sie mit einer Augenbinde auf Arbeits.
In diesem Projekt verwenden wir ein Arduino, mehrere Eingangswerte zu erfassen und diese über den USB-Anschluss an einen Host-Computer, auf dem ein Programm, das die Werte entschlüsselt und zeigt sie auf dem Bildschirm.
Da die Arduino selbst nicht bietet keine besondere Intelligenz und geht einfach auf beliebige Werte liest, ist dieses Projekt sehr flexibel und das Verhalten des Systems kann einfach durch Änderung der Software, die auf Ihrem Computer ausgeführt wird, geändert werden.
Dies eröffnet eine Vielzahl von Möglichkeiten für die Verwendung der gleichen grundlegenden Hardware zu verarbeiten und visualisieren analogen Daten, parallele digitale Daten und serielle digitale Daten.
Das Visualisierungsprogramm in diesem Projekt gezeigt, wird in Verarbeitung geschrieben werden, wird ein Schwesterprojekt zu Arduino entwickelt, um die schnelle Entwicklung der bildenden Programme auf die gleiche Weise, die Arduino ermöglicht die schnelle Entwicklung von Körperprogramme zu ermöglichen.
Die Verarbeitung läuft unter Windows, Linux und MacOS.
Allerdings hat diese einfache Vorgehensweise einige wichtige Einschränkungen sowohl in Bezug auf Abtastrate und Auflösung also nicht erwarten, ein Arduino-basiertes System, um eine professionelle Oszilloskop oder Logik-Analysator Rivalen.
Die Analogeingänge auf einem Arduino arbeiten standardmäßig mit 10-Bit-Auflösung, die eine Skala von 0 bis 1023 liefert, während fortgeschrittene ADCs bieten Auflösung von 12 Bit oder höher.
Die Arduino Analogeingänge auch nehmen rund 100 Mikrosekunden, um eine Messung vorzunehmen, die Begrenzung der Anzahl von Proben kann es pro Sekunde und eine Beschränkung auf viel niedrigeren Frequenzen als eine erweiterte ADC.
Das Ergebnis ist ein System, das sehr gut mit 10-Bit-Auflösung mit bis zu irgendwo in der Region von 5 kHz betrieben werden, je nachdem, wie viele Kanäle Sie überwachen.
Nicht so toll, specs, aber sicherlich besser als gar nichts, wenn Sie nicht eine professionelle Oszilloskop oder Logik-Analysator leisten.

Arduinoscope:
code.google.com/p/arduinoscope/
http://accrochages.drone.ws/en/node/90

arduino-arduinoscope.pde
https://github.com/konsumer/arduinoscope

Poorman's oscilloscope:

accrochages.drone.ws/en/node/90

http://accrochages.drone.ws/en/node/90

Original Processing code	1.88 KB
Arduino code as an include file	2.92 KB
Processing code with zoom option	2.64 KB

Arduin-O-Scope v01:

www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1233536778

http://forum.arduino.cc/index.php/topic,8077.0.html

http://www.practicalarduino.com/projects/scope-logic-analyzer

*********************************************************

Soundkarten-Oszilloskop

nur für Wechselspannung 20Hz bis 20kHz

Wem ein wirklich einfaches Oszilloskop für kleine Frequenzen (bis etwa 20 kHz) ausreicht, bspw. um die Kommunikation am I2C-Bus zu analysieren, kann dazu die Soundkarte des PC benutzen.

Allerdings eignet sich eine Soundkarte nicht dazu, Gleichspannungen zu messen, zu niederfrequente Signale können daher nicht damit erfasst werden:

Im Screenshot nebenan erkennt man das z. B. an der fallenden Gerade am Schluss (obwohl der tatsächliche Signalpegel konstant oben bleibt).

Auch ist hier besondere Vorsicht geboten, da Soundkarten nur für geringe Spannungen ausgelegt sind und bei einer zu hohen Eingangsspannung möglicherweise der ganze PC beschädigt wird.

Daher ist eine Vorschaltung mit Spannungsbegrenzung (ca 0,7V) nötig.

Der Vorteil der Soundkartennutzung ist, dass es sich dank des PCs um eine Art Speicheroszilloskop handelt und die Daten zum Beispiel in Excel analysiert werden können.

Hardy u. Karola Scheidig verschiedene Programme zum Messen mit der Soundkarte.
Visual Analyser von Alfredo Accattatis und der University of Rome Tor Vergata, "Donateware"
Soundcard Oscilloscope für Windows von Christian Zeitnitz, kostenlos für Privatanwendung
Spectrum Lab von DL4YHF
Spectrogram von R.S. Horne, ältere Version kostenlos
Audiotester 30-Tage-Version kostenlos
DasyLab Eingeschränkte Version (Soundkarte und serielle Schnittstelle) als Beilage zum Buch "Signale-Prozesse-Systeme" ISBN 9783642018633
Zelscope von Constantin Zeldovich 14-Tage Evaluationsversion
Linksammlung

http://www.mikrocontroller.net/articles/Oszilloskop

*********************************************************
Open source multi-channel EEG/ECG/EMG
Chris Rorden's Neuropsychology Lab

Die ads1299 dass ein fantastisches Gerät kann mit der Arduino mit dem SPI-Anschluss, providing eine sehr einfache, kostengünstige und qualitativ hochwertigen 8-Kanal-EEG / EMG / EKG-System communiquer ist.

Arduino Software
Die Arduino Sketch "adsArd" Programme ein Arduino-kompatibles Gerät, um die ADS129n.zip SPI Daten auf dem USB-und Bluetooth-Anschlüsse zu übersetzen. Dieses Skript ist nur auf der Teensy 3. getestet Wir vermuten, es wird auf der Arduino Due zur binären Kommunikation arbeiten, sobald der Entwickler Abstimmung der nativen seriellen Port. Sofern Sie eine Teensy3 verwenden, müssen Sie ein paar Zeilen in adsCMD bearbeiten, um die für die SPI-Kommunikation verwendet Stifte angeben (zum Beispiel verwendet der Teensy 2 Pins 1,2,3 für SPI-Kommunikation).
Sobald Ihr Arduino wurde neu programmiert, so wird es als eine SPI-serielle Interposer handeln, wenn es neu gestartet wird.
Für die Teensy 3, wird das Licht auf dem Gerät ab, wenn die ADS129n ruht, schwach beleuchtet, wenn die ADS129n wird Streaming-Daten, und blinkt langsam, wenn der Teensy nicht in der Lage, eine ADS129x erkennen (überprüfen Sie die Verbindungen zwischen dem Teensy und die ADS129x).

Matlab-Software
Die Matlab-Software kann der Benutzer festlegen, die Abtastrate, Anzahl der Kanäle, und ob Sie die Daten speichern möchten.
Falls gewünscht, werden die Daten in Brainvision Analyzer-Format, das Sie mit dem kostenlosen Elecro oder EEGlab Software anzeigen können gespeichert werden.
Processing-Software
Indem Sie die ersten Zeilen der Processing-Skript können Sie die Abtastrate festlegen, Anzahl der Kanäle, und ob Sie die Daten speichern möchten. Auf Wunsch werden die Daten als durch Tabulatoren getrennten Text gespeichert werden. Sie können diese Dateien mit Ihrem Lieblings-Tabelle anzuzeigen.

http://www.mccauslandcenter.sc.edu/CRNL/tools/ads1298

Teensy USB Development Board

http://www.pjrc.com/store/teensy3.html
http://openeeg.sourceforge.net/doc/

*********************************************************
EEG with an ARDUINO UNO R3

Homebrew Do-it-yourself-EEG, EKG und EMG
Für Anfänger sind die Schaltung recht detaillierte, jemand mit Elektronik Erfahrung soll dies überspringen.
Ein Schlüsselbegriff: die wichtigste Komponente der neurophysiologischen Aufzeichnung, vor allem für kleine Signale wie EEG,
ist nicht die Hardware oder die Software, aber die Qualität der elektrischen Anschlüsse an den Körper und Kopf.
Der Abschnitt über die Elektroden und Elektrolyte ist daher entscheidend.

EMG (Elektromyogramm) und EKG (Elektrokardiographie) sind ziemlich einfach zu erfassen, da sie relativ große Signale
(ein Millivolt oder mehr), und treten weitgehend Audiofrequenzen, die mit Musik und Sprache überlappen.
EEG ist schwieriger, da das Signal etwa 20 mal kleiner und Aktivität erstreckt sich bis herab zu 1 Hz oder darunter.
Ein Arduino eignet sich am besten für EEG Messungen, dieser benötigt aber eine Verstärkerschaltung.

AD620 Verstärker mit Arduino UNO

Chip Epsteins EEG-System

EEG Mit einem Arduino
Immer den ganzen Weg bis zum 1 Hz Frequenzbereich des EEG erfordert Kommunikation über eine digitale Schnittstelle; in der heutigen Zeit wäre dies ein USB-Anschluss sein.
Eine billige und bequeme Einrichtung zur Erfassung und Übertragung von Daten über USB-Kabel ist der Arduino, die ungefähr $ 30 (weniger, wenn Sie Ihre eigenen zusammen) kostet.
Das Arduino führt recht schnell Analog - Digital-Wandlung und dient auch als Plattform für zusätzliche circuity.
Es ist, als eine serielle Schnittstelle programmiert, sondern übersetzt automatisch auf USB.
Die Software, einschließlich der Verarbeitung der Sprache, ist Open Source, und große Mengen von Informationen sind im Internet für verschiedene Plattformen und Anwendungen zur Verfügung.
Die Kehrseite des Arduino ist, dass es Spannungen so klein wie die von einer Audio- oder mike Eingang bearbeitet nicht lösen kann, so erforderlich, eine kompliziertere Verstärker mit größeren Gewinn ist.
Der Vorteil ist, dass, wenn die Aufnahme nicht EEG Sie ein flexibles Gerät mit umfassenden Möglichkeiten, andere Interaktionen zwischen Ihrem Computer und der Außenwelt.

Das Bordnetz von der Arduino ist 5 V.
Dies lässt wenig Raum für DC-Offsets von den Elektroden, so dass die Verstärkung der AD620 bis etwa 20.
Eine zweite Stufe mit dem alten 3130 Operationsverstärker bietet zusätzliche Verstärkung begrenzt und Signalfilterung und DC Vorspannung für die Arduino Analogeingang.
Denn das Eingabe ist relativ laut, erfordert es einige Tiefpassfilterung, die kann auch zur Verringerung der 50Hz Rauschen zu tun doppelte Aufgabe.
Eine weitere Stufe der Filterung in der Rückkopplungsschleife benötigt nur einen einzigen Kondensator, so dass wir, dass in sowie zu werfen.
Die aufgeführten Komponentenwerten wird daher ein zweiter Ordnung Tiefpaßfilter.
Der Kombifilter ist nicht gut charakterisiert, aber gut genug für unsere Zwecke.
Es hilft zu verbessern sowohl die 50Hz Störproblem und Muskelkontraktion Artefakte, ohne übermäßig zu verringern normalen EEG-Aktivität.
(Weil die Verarbeitungsroutine wir entlehnt mit einer recht niedrigen Abtastrate könnte Muskelgeräusche neigen Aliasing, welches ähnliche Aktivität sieht in den EEG-Frequenzen und kann sehr schwierig zu entziffern herzustellen.)

Sie können diese Schaltung zur EKG als auch verwenden, aber ich kann es nicht empfehlen.
Der Gewinn ist eigentlich zu hoch und mehrere Schaltungsanpassungen erforderlich wäre, um nur zwischen EEG und EKG hin und her zu schalten.
Der einzige Vorteil wäre ein genaues Spiegelbild der ST-Strecke und T-Welle sein.
Dies dürfte von Bedeutung nur an Ärzte, die sollten wirklich werden mit echten EKG-Geräte sein.

Stückliste:
Arduino UNO, Decimilla oder Duemilanova,
USB-Kabel,
Lochrasterplatinen
BreadBOARD (Steckbrett)
Schaltdraht Dm 0,65mm
DVM = Multimeter
1x AD620 Instrumentenverstärker
2x 3130 (DIP) CMOS-Operationsverstärker
3x 15k Widerstände
2x 1M Widerstände
1x 10K Widerstand
1x 2,2K Widerstand
1x 1M Trimmpoti
1x 10uF Elektrolytkondensator, vorzugsweise nichtpolarisiert
1x 6,8nF Kondensator
1x 0,68 uF Kondensator
2x 1 nF Kondensator

Eine schematische Darstellung der Gesamtschaltung und eine Großaufnahme der Anschlüsse sind auf der nächsten Seite angezeigt.
Wenn möglich mit einem Steckbrett, die in einem protoboard passt, nicht draußen sitzen mit langen Draht läuft, die sich lösen oder Störgeräusche aufnehmen können.

EEG Schaltbild Vorverstärker

Die Verstärker benötigen eine neutrale Referenz oder schwimmenden Boden, auf halbem Weg zwischen der Arduino 5 V Plus und Masse liefert.
Die zweite 3130 (ganz rechts im Bild, mit den beiden 15k Widerstände) bietet dieses.
Draht es, schließen Sie das Arduino (ich nehme an, Sie werden von dem USB-Kabel sein, schalten Sie es), und überprüfen Sie mit dem Spannungsmesser, um sicherzustellen, dass die 3130 setzt heraus 2,5 Volt an Pin 6.
Dieser Ausgang wird "neutral" für sein die beiden anderen Chips.
Nächste Draht bis die andere 3130, die den Hochleistungsverstärker ist.
Aber dürfen Sie das 1M Ohm Schneider in ganz.
Sie werden zum Vorspannen muss die Ausgabe in der Mitte des Eingangsbereichs für das Arduino Analogeingang, auf welche verwiesen wird auf "intern" und hat eine Reichweite von 0 bis 1,1 V.
Wir werden auf halbem Weg zwischen 0 und 1,1 Volt anzustreben.
Um dies zu tun, verwenden Sie das Ohm-Meter den 1,0M Ohm Trimmer auf rund 500k Ohm eingestellt.
Dann legen Sie sie in der Schaltung, Anschluss von bis das Gerät aus und verwenden Sie den Spannungsmesser, um den Stift 6 Ausgang des 3130 mit dem Arduino Boden zu vergleichen.
Stellen Sie den Trimmer auf 0,55 Volt.
Schließlich Installieren und verdrahten Sie die AD620. Die 2.2k Ohm Widerstand stellt die Verstärkung dieses Chips zu etwa 23, so dass die Gesamtverstärkung der Schaltung ist um 1500.
Als ersten Scheck, vorübergehend kurz die beiden AD620 Eingangs-Pins (2 und 3) in die neutrale Leitung (Pin 5).
Der Ausgang Pin 6 sollte dann etwa 2,5 Volt.
Schalten Sie das Gerät und entfernen Sie die Kurzschlussleitungen .
Die beiden Tiefpassfilter-Segmente sind hilfreich für EEG, aber wenn Sie sie nicht benötigen, lassen Sie die mit * gekennzeichneten Kondensator.

Installieren der Software für Arduino
Sobald Sie die Arduino Vorverstärkerschaltung abgeschlossen haben, laden Sie die Arduino und Verarbeitungssoftware passend für Ihr Notebook.
Stellen Sie sie auf und prüfen sie nach den Anleitungen für Ihr Modell und Plattform.
Dann schließen Sie die Arduino per USB-Kabel, und mit dem Arduino-Software kopieren, einfügen, und laden Sie das Programm:

SENDER: Arduino-Sketch: Arduino-Code-EEG_1a.ino

Ziehen Sie dann das Arduino und in processing-- nicht in der Arduino software-- kopieren und das Programm unten.
Hinweis:
dass diese beiden Programme werden von einer von Sofian Audry angepasst

http://accrochages.drone.ws/sites/accrochages.drone.ws/files/Oscilloscope.pde
und wie sie sind daher in der Öffentlichkeit, unter GNU General Public License Einschränkungen.
Beachten Sie auch, dass diese einen erwartet die Arduino Signal an Port 0, wo es scheint, in der Regel für den Mac zu sitzen.
Bei einem PC, müssen Sie die Nummer der richtigen COM-Port zu finden mit println (Serial.list ()); siehe http://itp.nyu.edu/physcomp/Labs/SerialOut

EMPFÄNGER: Processing-Sketch: Processing-Code-EEG-180Hz_1a.pde

Wenn alle die Software bereit, ziehen Sie den Arduino, schließen Sie das EEG führt wie in "Aufzeichnen des EEG" beschrieben,
schließen Sie das Arduino, und führen Sie das Verarbeitungsprogramm.
Wenn das Signalrauschen / Amplitude schlecht ist, oder Sie eine langsame CPU haben,
kann das Display laufen langsam, da die Bearbeitung nicht in genau definierten Zeitintervallen so konzipiert, sammeln und anzeigen Proben.
Wenn alles funktioniert, sollten Sie sehen, wie die Aktivität in den Begleit Seiten dargestellt.

Y = Vertikal Mitten-Bildschirm - Spannung bei 200-Pixels = 0,55 Volt

X mit Sekunden-Raster (hellgrau genau hinsehen)

X = Horozontal-AblenkungDefault eingestellt 180 Samples/Sekunde = 180Hz

Bildschirmbreite 900-Pixels / 180S/s = alle 5 Sekunden werden die Daten überschrieben

TEST mit Pulse 450ms / 50ms

https://sites.google.com/site/chipstein/home-page/eeg-with-an-arduino
https://sites.google.com/site/chipstein/home-page/eeg-with-an-arduino/assembling-the-arduino-eeg-circult
https://sites.google.com/site/chipstein/home-page/eeg-with-an-arduino/recording-eeg-or-ekg-with-an-arduino
http://openeeg.sourceforge.net/doc/


Serial.print(value, BYTE); SOLL Serial.write(value);
Serial.print( 0xff, BYTE); SOLL Serial.write(0xff);

*********************************************************
        Girino funktioniert bei mir noch nicht werde den FEHLER suchen ! ! !

ORDNER > Girino-ARDUINO-Osci

SENDER:          Arduino-Sketch: Girino_Osci_1a.ino

Girinoscope 1.1.2

Girinoscope-v1.1.2-beta-201428080519.zip
Eine einfache grafische Benutzeroberfläche für Girino

https://github.com/Chatanga/Girinoscope/releases/tag/v1.0.1-beta
https://github.com/Chatanga/Girinoscope
https://translate.google.at/translate?sl=en&tl=de&js=y&prev=_t&hl=de&ie=UTF-8&u=https%3A%2F%2Fgithub.com%2FChatanga%2FGirinoscope&edit-text=

EMPFÄNGER: ORDNER > Girino-ARDUINO-Osci > girinoscope.bat

Wenn ein Signal die Triggerschwelle überschreitet.
Die aktuelle Version Aufzeichnungen mit 8-bit Präzision.

Vor einiger Zeit war ich auf einem Arduino-Projekt arbeiten, und ich brauchte, um zu sehen, ob das Ausgangssignal wurde in Übereinstimmung mit den Einzelheiten.
So verbrachte ich einige Zeit im Internet auf der Suche nach Arduino Oszilloskope bereits implementiert, aber ich wusste nicht, was ich gefunden habe.
Die Projekte, die ich fand, waren meist von einer grafischen Benutzeroberfläche für die Computerverarbeitung in schriftlichen und einer sehr einfachen Arduino Sketch zusammen.
Der Sketch waren so etwas wie:

void setup() {
    Serial.begin(9600);
}
void loop() {
    int val = analogRead(ANALOG_IN);
    Serial.println(val);
}

Dieser Ansatz ist nicht falsch, und ich will niemanden beleidigen, aber das ist zu langsam für mich.
Die serielle Schnittstelle ist langsam und Senden jedes Ergebnis einer analogRead () durch es zu einem Engpass.

Ich studiere Waveform Digitizer für einige Zeit und ich weiß recht gut wie funktionieren sie, so dass ich von ihnen inspirieren.
Das waren die Ausgangspunkte des Oszilloskops, die ich wollte zu erstellen:
     das eingehende Signal sollte von der Arduino, es zu bewahren entkoppelt werden;
     mit einem Offset des Signals ist es möglich, negative Signale zu sehen;
     die Daten gepuffert werden soll;
     einen Hardware-Trigger ist erforderlich, um die Signale zu fangen;
     ein Ringpuffer kann die Signalform vor dem Trigger geben (mehr zu diesem Punkt zu folgen);
     mit Unterhebel-Funktionen, die den Standard macht das Programm schneller laufen.
Der Sketch für die Arduino ist dieser Schritt angebracht, zusammen mit dem Schema der Schaltung, die ich gemacht habe.

Der Name, den ich kam mit, Girino, ist eine leichtfertige Wortspiel auf Italienisch.
Giro bedeutet Rotation und dem Suffix -ino Sie eine kleine Drehung, aber Girino bedeutet auch, Kaulquappe.
Auf diese Weise habe ich einen Namen und ein Maskottchen.

http://www.instructables.com/id/Girino-Fast-Arduino-Oscilloscope/

*********************************************************

MENU Tools USB Type: Serial Serial
EMPFÄNGER: Processing-Sketch: osciProcessing_1a.pde

osciProcessing für die Verarbeitung

TaylorHanayik/StimSync/osciProcessing/osciProcessing.pde

Software Details:

osciProcessing ist ein Oszilloskop zur Verarbeitung Erweiterung einer Anwendung von Sofian Audry. Diese Software ausführen, gehen Sie folgendermaßen vor:

Achten Sie darauf, die Erfassungssoftware (zB stimsyncArd), um Ihre Arduino / Teensy hochgeladen haben.
Das erste Mal, wenn Sie diese Software ausführen:
1. Wenn Sie mit einem Macintosh OSX-Computer verwenden, müssen Sie die Befehle sudo mkdir -p / var / lock auszuführen; sudo chmod 777 / var / lock aus einer Terminal-Anwendung vor dem Ausführen des Verarbeitungscode zum ersten Mal.
2. Wenn Sie diese Software auf einem Linux-Computer sind, haben Sie wahrscheinlich etwas ähnliches wie das, was für OSX erforderlich machen. Wenn Sie versuchen, das Programm zum ersten Mal ausgeführt wird, sehen Sie sich die in der Verarbeitung Konsolenfenster angezeigt Warnungen. Diese sollten Sie, was zu tun zu unterweisen.
3. Wenn Sie eine Teensy auf einem Windows-Computer, müssen Sie die Installation von Windows-Treibern ersten . Nach meiner Erfahrung ist die Windows-Software nicht so flüssig wie auf OSX (die Teensy erscheint, um die Daten in großen Clustern von Paketen, gefolgt von langen Pausen zu liefern).
Sicherstellen, dass der Arduino / Teensy ist an den Computer angeschlossen.
Starten Verarbeitung und Nutzung Datei / Öffnen, um die Datei zu öffnen osciProcessing.pde, dann wählen Sie Skizze / Run
Erscheint ein Dialogfeld mit einem Dropdown-Menü, zeigen Sie die Liste der verfügbaren Geräte. Wählen Sie den Namen Ihres Arduino / Teensy (diese Regel als "usbmodems" - siehe Bild rechts). Wenn Ihr Gerät nicht angezeigt wird, stellen Sie sicher, das Arduino / Teensy angeschlossen, dass sie die Erfassungssoftware ausgeführt wird und dass Sie alle erforderlichen Treiber installiert haben. Nachdem Sie das Gerät ausgewählt haben, drücken Sie "OK", um die Auswahl zu übernehmen.
Sie sollten nun ein Oszilloskop.
Man beachte, dass die ersten paar Zeilen des Skripts können Sie die Abtastrate und die Anzahl der Kanäle für die Aufnahme festzulegen.
Fehlerbehebung: Wenn das nicht funktioniert, wenden Sie sich bitte werfen Sie einen Blick auf die Fehler in der Verarbeitung Konsolenfenster ausgewiesen.

5.) MatLab: ScopeMath_Arduino Dies ist ein einfaches Oszilloskop für Matlab.
Sie können die Sample-Rate, Anzahl der Kanäle ändern und speichern Daten in Gehirn Vision Analyzer-Format (für die Analyse mit EEGlab, Elecro, etc).

6.) Verarbeitung: osciProcessing Dies ist ein einfaches Oszilloskop für die Verarbeitung.
Sie können die Sample-Rate und Anzahl der Kanäle zu ändern.

7.) XCODE: osciXcode Dies ist ein einfaches Oszilloskop für die Xcode Sprache (mit einer kompilierten OSX-Programm).
Sie können die Sample-Rate und Anzahl der Kanäle zu ändern.

https://github.com/TaylorHanayik/StimSync/blob/master/osciProcessing/osciProcessing.pde
http://www.mccauslandcenter.sc.edu/CRNL/tools/oscilloscope

*********************************************************
Oscilloscope using Teensy or Arduino

Ich empfehle meinen Code mit dem Teensy 2.0 und Arduino Leonardo (die Verwendung der Atmel Atmega32u4 CPU) oder der Teensy 3.0 oder Arduino Due (die ARM-CPUs verwenden). Während mein Code wird in der Theorie auf älteren Geräten Arduino diese Geräte hatte sehr schlechte Kommunikationsleistung.
Zum Beispiel ist ein Arduino Uno auf etwa nur einen einzigen Kanal bei 100 Samples pro Sekunde, wo ein Teensy 3 leicht zu senden ein Dutzend Kanäle bei 2000 Abtastungen pro Sekunde. Um eine der älteren Geräten zu verwenden, müssen Sie die Kommunikationsgeschwindigkeit (siehe die Kommentare in meinem Matlab-Skript für weitere Details) verlangsamen.

http://www.mccauslandcenter.sc.edu/CRNL/tools/oscilloscope

*********************************************************

Serial Oscilloscope in ARBEIT

AUDIO_IN = pin-A1
AUDIO_OUT = pin-3

SENDER: Arduino-Sketch: Serial_Oscilloscope_Analog_2a.ino
EMPFÄNGER: Processing-Sketch: Processing Serial_Oscilloscope_Analog_2a.ino

Grafische Darstellung des ARDUINO UNO AnalogSensor.

Puls 15ms Pause 5ms = Impuls 20ms = 50Hz

9600 Baud X = 800 Pixels = 840ms 800/840x1000 = 952 Samples / Sekunde für Wechselspannung < 160Hz

Y = 5,0V (10-bit) 1024/4=256 (8-bit)

Puls 15ms Pause 5ms = Impuls 20ms = 50Hz

115200 Baud X = 800 Pixels = 128ms 800/128x1000 = 6250 Samples / Sekunde für Wechselspannung < 1.000Hz

Y = 5,0V (10-bit) 1024/4=256 (8-bit)

Maschinenübersetzung aus dem Englischen ! ! !
Ich habe eine E-Gitarre wie der Sensor, anstatt die typischen Sensoren haben wir in der Klasse verwendet haben weil Wechselstrom
(statt einfacher Sensoren, die sich nur auf bestehende Gleichstrom) die Gitarre erzeugt, musste ich einen DC-Offset zu verwenden,
um den Sensorausgang richtig Graph da die Gitarrensignal wechselt bei einer hohen Frequenz,
erhöhte ich die serielle Kommunikationsrate, um die Wiedergabetreue des Graphen zu verbessern

Die Sensoren nutzen wir bisher haben ziemlich passiv gewesen.
Zum Beispiel kann ein Fotowiderstand nicht Spannung zu erzeugen, sondern erschwert nur die Strömung in unterschiedlichem Ausmaß.
Aber eine E-Gitarre tatsächlich erzeugt Strom durch den Prozess der Induktion:
wenn ein Metall Saite schwingt in der Nähe eines Gitarren-Pickup ist ein Wechselstrom von der Abholung emittiert.
Der Strom, der aus der Gitarre kommt können Maßnahme von einem Analog-Eingang des Arduino werden,
fast genauso wie sie den Strom, der durch einen Fotowiderstand leitet messen.
Es besteht ein wesentlicher Unterschied:
Die Gitarre muss nicht zu jeder positiven Spannung verbunden werden, da der Gitarre erzeugt ihre eigene Spannung.
So sind die einzigen Verbindungen notwendig sind Boden und auf dem Arduino das analoge Eingangs-Pin.

Wir haben jedoch bisher mit DC, die von 0V bis zu einer positiven Spannung nur, typischerweise + 5V im Schaltungen so weit variiert arbeiten.
Die analogRead Funktion der Spannung er sieht in eine Zahl (WERT) zwischen 0 (bei 0V) und 1023 (bei + 5V) zu übersetzen.
Aber die Gitarre Ausgänge AC, das von der negativen Spannung (typisch -1V) und eine positive Spannung (typischerweise + 1V) variiert.
Wenn die analogRead Funktion trifft eine negative Spannung, stellt es als 0.
Dies bedeutet, dass die Hälfte der Messwerte immer ignoriert.
Also beschloss ich, etwa + 2,5V (Offset) an den Analogeingang hinzuzufügen.
Dies bewirkt, dass die Spannung an dem analogen Eingang gesehen,
von einem Ausgangswert von +2,5V anstelle von 0 abweichen,
und das erlaubt es dem analogen Eingang, der die negative Komponente des Originalsignals von der Gitarre zu lesen.
Denken Sie daran, dass ich sagte, die Gitarre erzeugt AC zwischen -1V und +1V; wo die Gitarre Ausgänge -1V, wird der Analogeingang sehen + 1,5V.
Wo die Gitarre Ausgänge + 1V, wird der Analogeingang sehen + 3,5V.
ACHTUNG: 2,5V Gleichstrom-Offset oder der Gleichstrom-Vorspannung notwendig.

Die letzte Abweichung war die Verwendung einer höheren Rate von seriellen Übertragung, um eine höhere Genauigkeit Messungen der Gitarrensignal erhalten.
Effektiv erhöhte ich die Abtastrate des Audio-Aufnahme.

Die Abtastrate sollte 10x höher als die Meßfrequenz sein..

Das Signal von einer E-Gitarre variiert zwischen -1V und +1V hunderte oder tausende Male pro Sekunde.
Für eine präzise Wiedergabe von NF-Audio Signalen werden 44.100 Samples pro Sekunde benötigt
(dies ist die typische Abtastrate für ein CD oder MP3).

Für einen seriellen Übertragungsrate von 9600 Baud was bedeutet, dass die maximale Anzahl von WERTen (jeder WERT in diesem Fall ein 1 Byte-Messung) die Arduino könnte an den Computer senden würde 9600 Samples pro Sekunde erhöht man die serielle Übertragungsrate auf 115200 SpS
(115200 Baud ist die schnellste Übertragungsrate die ein Computern unterstützt.)
Dies erhöht die Abtastrate auf 115.200 Samples pro Sekunde
(Auf Grund anderer Einschränkungen sind die 115.200 Baud nur ein theoretisches Maximum).

115200 Baud ist die höchste Baudrate was ein Standard PC-UART Baustein mitmacht.

Sie können die Baudrate in den Code ändern, um zu sehen, was passiert mit der Grafik.

Bei 16 MHz sind dies 4800, 9600, 14400, 19200, 28800, 38400, 57600, max. 115200 Baud

Baudraten Tabelle für AVRs

http://www.kreatives-chaos.com/artikel/baudraten-tabelle-fuer-avrs

Arduino-Sketch:      Serial_Oscilloscope.ino
Processing-Sketch:   Serial_Oscilloscope.pde
Fritzing project:    Serial Oscilloscope.fzz

http://www.karlward.com/blog/2012/10/serial-oscilloscope/

*********************************************************

Le programme Arduino

SENDER: Arduino-Sketch: AnalogReadSerial_2a.ino

pin-A0 bis pin-A5

Le programme Processing Serveur réseau

   Erläuterungen:
Dieses Programm dient als "Brücke", die vom Server Arduino Board erhalten über die serielle Schnittstelle, die mit dem Arduino-Client WLAN-Netzwerk, das auf einem anderen PC angeschlossen wird String zu senden.
     Dieses Programm erzeugt zunächst einen Netzwerkserver (IP-Adresse des PC-Server) und sendet die über die serielle Schnittstelle auf dem 5905-Anschluss WiFi-Netzwerk erhalten String.
     Achtung:
Sie müssen die gewünschte Schriftart installieren (in Bearbeitung: Extras> Schriftart erstellen ..) oder Kommentarzeilen mit Hilfe der Textschrift.

http://www.mon-club-elec.fr/pmwiki_mon_club_elec/pmwiki.php?n=MAIN.ArduinoExpertCanTelemetrieWifi6voies

*********************************************************

XARDOSCOPE
ist ein Zweikanal-Oszilloskop-Anwendung für Linux, mit einem ATmega328 Gerät zur Datenerfassung und eine serielle oder eine USB-Schnittstelle für die Kommunikation mit dem PC. Das Look and Feel ist in der Nähe eines traditionellen Oszilloskops. Abtastrate für Version 0.95 ist über 2350 Samples pro Sekunde für jeden Kanal. Ursprünglich für Arduino Uno entwickelt, aber funktioniert am besten mit einem Atmega328 und einem TTL / USB-Konverter. *** NEU: ein Vorverstärker vorgestellt, das einen Eingangsbereich von -4 V bis +6 V für DC mit 10 mV Auflösung und +/- 0,5 V AC mit 1 mV Auflösung mit Standard 1MegOhm Eingangsimpedanz bietet.

lxardoscope ist in C geschrieben und elegante Benutzeroberfläche ist Jahr. Es erfasst Daten mit 8-Bit-Präzision.
Es gibt eine schöne Beschreibung zur Kopplung dies zu einer DDS-Modul, um Wellenformen zu erzeugen und Probe em.

http://www.elecfreaks.com/2110.html
http://www.elecfreaks.com/store/dds-module-ad9850-p-260.html

http://lxardoscope.sourceforge.net/

*********************************************************

DIN A4 ausdrucken
*********************************************************
Impressum: Fritz Prenninger, Haidestr. 11A, A-4600 Wels, Ober-Österreich, mailto:[email protected]
ENDE