Eigene Grafiken auf dem Oszilloskop mit R-2R-DAC darstellen

Das R-2R-DAC

Ein R-2R-Leiter-DAC ist eine der einfachsten Möglichkeiten, einen Digital-Analog-Wandler zu bauen. Er benötigt nur Widerstände in zwei Werten: R und 2R. Das Prinzip:

• R kann jeder Wert sein (z. B. 1 kΩ), solange alle „R“-Widerstände identisch sind.
• 2R ist doppelt so groß (z. B. 2 kΩ oder zwei 1-kΩ-Widerstände in Serie).
• Die Bitanzahl ergibt sich aus der Anzahl der 2R-Zweige. Hier: 8-Bit (PORTD) + 6-Bit (PORTB) am Arduino Uno/Nano.

Hinweis: Statt des R-2R-DACs kann auch ein DAC-IC (z. B. per SPI) verwendet werden; I2C ist für detaillierte Bilder zu langsam. Der R-2R liefert jedoch feinere Details.

Port-Manipulation

Für hohe Geschwindigkeit wird direkter Port-Zugriff genutzt (parallel). Der ATmega328P (Uno/Nano) bietet:

• PORTD (Digital 0–7): volle 8 Bit, lesbar/schreibbar
• PORTB (Digital 8–13): nur 6 Bit nutzbar (Bits 6/7 = Quarz)
• PORTC (Analog 0–5): nur 6 Bit nutzbar

Daher: 8-Bit-DAC an PORTD (X-Achse), 6-Bit-DAC an PORTB (Y-Achse).

Aufbau auf dem Steckbrett

Zwei R-2R-Leitern (hier mit 10-kΩ-Widerständen, 2R = zwei in Serie). Oszilloskop-Sonden an den DAC-Ausgängen (X, Y) und Masse. Saubere Verdrahtung ohne Lücken ist entscheidend.

Arduino-Code

Initialisierung der Datenrichtungsregister, Remapping der 8-Bit-Y-Werte auf 6 Bit (0–63), Ausgabe im Loop mit kurzer Verzögerung.

const byte FIGURE_DELAY = 1;      // µs zwischen Punkten
const int NUM_POINTS = 87;        // Anzahl XY-Punkte

byte x_points[NUM_POINTS] = {106,106,105,104,103,102,101,100,99,98,97,96,95,94,93,92,91,90,90,89,88,87,87,87,86,86,86,86,87,89,90,91,93,95,97,99,101,102,102,104,104,105,105,106,106,106,106,106,106,108,109,110,112,113,115,117,119,121,122,123,123,124,124,124,124,124,123,122,121,120,119,118,117,116,115,114,113,112,111,110,110,109,109,109,108,107,107};
byte y_points[NUM_POINTS] = {78,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,98,99,100,101,103,105,106,108,110,112,113,113,114,115,115,115,115,115,115,114,112,112,110,109,107,106,106,108,110,112,114,114,115,116,116,117,117,117,117,117,116,115,113,112,110,108,106,104,103,102,100,99,98,97,96,95,94,93,92,91,90,89,87,86,84,82,81,80,78};

void setup() {
  DDRD = B11111111;   // PORTD alle 8 Bit Output
  DDRB = B00111111;   // PORTB untere 6 Bit Output
  for (byte t = 0; t < NUM_POINTS; t++) {
    y_points[t] = map(y_points[t], 0, 255, 0, 63); // 8→6 Bit
  }
}

void loop() {
  for (byte t = 0; t < NUM_POINTS; t++) {
    PORTD = x_points[t];
    PORTB = y_points[t];
    delayMicroseconds(FIGURE_DELAY);
  }
}

Zeichen-Tool (Python/Tkinter)

Ein kleines Python-Skript (drawlog.py) öffnet ein 255×255-Pixel-Fenster. Per Mausklick und Ziehen werden Koordinaten aufgezeichnet. Beim Schließen des Fensters werden C-Arrays für x_points, y_points und NUM_POINTS auf stdout ausgegeben – per Umleitung in eine Datei speichern:

python drawlog.py > arduino_list.txt

Die generierten Arrays können direkt in den Arduino-Sketch kopiert werden.

Oszilloskop: X-Y-Modus

• Kanal 1: 8-Bit-DAC (PORTD) → X-Achse
• Kanal 2: 6-Bit-DAC (PORTB) → Y-Achse
• Oszilloskop auf X-Y-Modus stellen, Skalierung anpassen

Speicheroptimierung (Wichtig!)

Auf dem Uno begrenzt der RAM die Punktanzahl (~400). Tipps:

• Iterator t als int statt byte (bis 255 Punkte)
• Arrays als byte statt unsigned long deklarieren
• PROGMEM nutzen (Flash-Speicher): ermöglicht ~15.000 Punkte!

const int NUM_POINTS = ...;
const byte x_points[NUM_POINTS] PROGMEM = {...};
const byte y_points[NUM_POINTS] PROGMEM = {...};

void loop() {
  for (int t = 0; t < NUM_POINTS; t++) {
    PORTD = pgm_read_byte_near(x_points + t);
    PORTB = pgm_read_byte_near(y_points + t) >> 2; // 8→6 Bit
    delayMicroseconds(FIGURE_DELAY);
  }
}

Beispielbilder

Verschiedene Grafiken (Herz, Stern, Text) lassen sich so darstellen. Eigene Kreationen sind willkommen!

Schaltpläne