Oscilloscope

http://sites.prenninger.com/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:info@sofianaudry.com
*
* 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

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




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.
Ausführungszeit analogRead
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.

Freilaufende Analog-Wandlung
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.

Messung mit der 5-V-Referenz 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 10 = 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.

Histogrammgleichspannung 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.


Histogramm zwei Gleichspannungs
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.
niederZeitReferenzSpannung
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.

Histogramm für eine Dreieckwellenform,
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

Download application-osx.zip Standalone simple arduinoscope for Mac OSX   Featured Aug 2009
494 KB 3991  
Download application-win32.zip Standalone simple arduinoscope for windows 32bit   Featured Aug 2009
418 KB 18911  
Download application-linux64.tar.gz Standalone simple arduinoscope for linux 64bit   Featured Aug 2009
448 KB 2170  
Download application.-linux32.tar.gz Standalone simple arduinoscope for linux 32bit   Featured Aug 2009
442 KB 3054  
Download arduino-arduinoscope.pde Arduino code for SimpleSerialArduinoscope   Featured Aug 2009
586 bytes 37471  
Download processing-arduinoscope.zip Processing library   Featured Aug 2009
65.2 KB 22809  
Download 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

  1. Flash Ihre Arduino mit der Firmware, die in der Zip-Datei kommt.
  2. Verwenden Sie die analogen Eingänge von # 0 bis # 3
    • beachten Sie, der Trigger überwacht nur den analogen Kanal  pin-A0.
  3. Starten Sie die App
  4. 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
// ODER
outputValue[n]=(char)127*sin((float)2*Pi*n/50)+127; // Sinus
// ODER
if(sin((float)2*Pi*n/50)>0) outputValue[n]=255; else outputValue[n]=0; // Rechteck
// ODER
if(((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 code1.88 KB
Arduino code as an include file2.92 KB
Processing code with zoom option2.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.

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

/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:
  1. Achten Sie darauf, die Erfassungssoftware (zB stimsyncArd), um Ihre Arduino / Teensy hochgeladen haben.
  2. 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).
  3. Sicherstellen, dass der Arduino / Teensy ist an den Computer angeschlossen.
  4. Starten Verarbeitung und Nutzung Datei / Öffnen, um die Datei zu öffnen osciProcessing.pde, dann wählen Sie Skizze / Run
  5. 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.
  6. Sie sollten nun ein Oszilloskop.
  7. 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.
  8. 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


G
rafische 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:schaltungen@schaltungen.at
ENDE








Comments