Havesomepi

Impressum | Kontakt | Datenschutz

Mit Mikrocontrollern wie dem Ardiuno lassen sich analoge und digitale Daten auswerten und auch Geräte steuern. Mit diesen Zutaten ist es ein Leichtes, sich eine eigene Lichtorgel zu bauen. Ich habe dieses Projekt realisiert und schildere hier in mehreren Schritten, wie ich das gemacht habe.

Zusammenfassung

Ziel des Projektes ist es, eine Lichtorgel zu bauen, die an die heimische Stereoanlage, einen Computer oder das Smartphone angeschlossen werden kann. Das Einlesen der Audiodaten erfolgt über ein analoges Audiokabel (d.h. nicht über ein Mikrofon). Die Analyse der Daten erfolgt digital über eine Frequenzanalyse auf dem Arduino, es werden also keine Hochpass- oder Tiefpassfilter benötigt. Wir gehen in folgenden Schritten vor:

Audiosignale - eine kleine theoretische Einführung

Wenn Musik oder Sprache mit einem Mikrofon aufgezeichnet wird, dann wird der gemessene Schalldruck in eine Spannung umgewandelt. Diese Spannungen können wir über ein Audiokabel an andere Geräte (Lautsprecher, Speichermedien, etc.) weitergeben. Wenn man das Signal gegen die Zeit aufträgt, erhält man ein charakteristisches Amplitudenbild der Aufnahme:

Grafik Amplitude
Amplitudenbild des Liedes "sogno di volare" von Christopher Tin; Da es sich um Stereosound handelt, gibt es zwei Schwingungsbilder (Grafik wurde mit Hilfe von Audacity erzeugt)
Werden die Daten digital gespeichert (z.B. auf einer CD oder im mp3-Format), dann wird das Signal in regelmäßigen Zeitabständen gemessen und der jeweilige Spannungswert in eine Zahl umgewandelt. Diese Werte werden dann gespeichert. Die Menge der Messwerte hängt von den Zeitabständen zwischen zwei Messungen ab: Je kürzer dieser Zeitabstand, um so besser ist die Qualität der Aufnahme, aber um so größer ist auch die Menge an Daten, die man speichern muss. Der Kehrwert dieses Zeitabstands ist die sogenannte Abtastrate (Framerate) und liegt häufig bei 44,1kHz (d.h. man macht 44100 Messungen pro Sekunde).

Den Klinkestecker anzapfen

Es gibt verschiedene Arten von Klinkesteckern, je nach dem, welche Art von Signalen sie transportieren. Erkennen lässt sich der Typ am Stecker selbst, oder wenn man das Kabel aufschneidet: Ein Monostecker ist zweipolig und hat 2 Adern (Masse und Signal). Ein Stereostecker ist dreipolig und hat demnach auch 3 Adern (Masse, linkes Signal, rechtes Signal). Kopfhörer mit integriertem Mikrofon haben zusätzlich einen Pol (und eine weitere Ader) für den Audioeingang, d.h. es handelt sich meist um vierpolige Stecker (Stereo + Mikrofon).

Verschiedene Klinkestecker: links ein Monostecker, in der Mitte Stereo (aufgeschnitten), rechts Stereo mit Mikrofon; Beim Stereostecker sind die rote und weiße Ader die beiden Signalkanäle, der blanke Kupferdraht ist die Masse; da beim rechten Stecker das Mikrofon im Kabel integriert ist, unterscheiden sich die beiden Klinkestecker in Input und Output.

Raspberry Pi: Audio über GPIO anzapfen

Meine Lichtorgel hängt nicht an der Stereoanlage, sondern am Raspberry Pi. Dort läuft das Mediencenter Kodi, über das ich Musik höre und Filme schaue. Da dort der HDMI-Ausgang bereits am Fernseher hängt und der Klinkeausgang von der Stereoanlage belegt ist, habe ich nach einer anderen Lösung gesucht, um das Audiosignal auszulesen. Und diese Möglichkeit gibt es auch: Die GPIO-Pins.

Im Prinzip ist es ganz einfach: Mit den Befehlen 

gpio -g mode 12 ALT0
gpio -g mode 13 ALT0
kann man den linken und rechten Audiokanal über die Pins 12 und 13 ausgeben lassen. Können die Befehle nicht ausgeführt werden, so muss man zunächst wiringpi installieren. Bei einer gewöhnlichen Raspbian-Installation ist es tatsächlich so einfach. Mit openelec oder libreelec ist es schwieriger, da wiringpi nicht installiert ist und auch nicht auf normalem Wege installiert werden kann. Um es trotzdem verfügbar zu machen, kann man diesem Tutorial folgen. Die Kurzfassung lautet:

Damit sollte auch hier das System wie oben beschrieben funktionieren. Damit man den Audioausgang nicht bei jedem Start manuell aktivieren muss, empfiehlt es sich, hier ein Skript beim Bootvorgang starten zu lassen. Hierfür gibt es viele Möglichkeiten, aber wieder ist es bei vielen Kodi-Installationen schwieriger, da einige Möglichkeiten (z.B. crontab) nicht zur Verfügung stehen. Es ist aber möglich, eine autostart.sh-Datei anzulegen:

Das Audiosignal am Arduino auslesen

Will man das Audiosignal mit dem Arduino anzapfen, hat man zunächst ein Problem: Das Signal wechselt zwischen positiven und negativen Spannungen (meist ist das ein Wert zwischen -2V und +2V, doch die Stärke hängt vor allem von dem Gerät ab, auf dem die Musik abgespielt wird). Der Arduino kann nur Spannungen zwischen 0V und 5V lesen. Liest man dieses Signal ein, dann werden die negativen Werte abgeschnitten (d.h. die Daten gehen verloren) und die negativen Spannungen können das Gerät sogar beschädigen.

Um diesen Fehler zu beheben müssen wir zunächst ein Offset auf das Audiosignal addieren, so dass die Spannungen nur positive Werte annehmen. Wir können das mit der folgenden Schaltung realisieren:

Schaltplan für ein 2,5V Offset Man verbindet die Signalleitung einmal mit der 5V Spannungsversorgung am Arduino und mit dem GND-Pin am Arduino, jeweils mit einem hohen Vorwiderstand. Dazwischen befindet sich ein Kondensator.
Dieses verschobene Signal können wir mit verfügbaren Analogpins am Arduino einlesen. Die Masseader des Audiokabels muss mit dem GND-Pin des Arduinos verbunden werden. Bei Stereosound kann man, wenn man möchte, für beide signalführenden Adern die obige Schaltung verwenden und die Ergebnisse an unterschiedlichen Pins einlesen. Mit den Befehlen 
signal1=analogRead(A3);
signal2=analogRead(A4);
werden die beiden Signale in Variablen gespeichert (hier im Beispiel wurden die beiden Audiokanäle an die Pins A3 und A4 angeschlossen).

Der Arduino misst hier Spannungen, die (wie oben beschrieben) mit den Schalldrücken des Audiosignals korrespondieren. Die Stärke dieser Spannungen hängt von dem Gerät ab, das die Musik abspielt. Der Arduino überträgt die Spannung mit der Funktion analogRead in eine Zahl von 0 bis 1023, wobei der höchste Wert einer Spannung von 5V entsprechen sollte.

Natürlich muss man auch dem Arduino wieder verständlich machen, mit welcher Abtastrate er das Signal auslesen soll. Dafür braucht man eine Möglichkeit, Zeit zu messen. Die Funktion micros() kann das, indem sie die Zeit in Mikrosekunden abruft. Zunächst müssen wir einige Größen festlegen: 

int abtastrate=5000;  //Abtastrate=5000Hz
int zeitintervall;
int t;
int signal1;
int signal2;
void setup{
  zeitintervall = round(1000000*(1.0/abtastrate));
  pinMode(A3,INPUT);
  pinMode(A4,INPUT);
}
und verwenden dann an einer geeigneten Stelle in der loop folgenden code: 
for(int i=0;i<1000;i++){
  t = micros();
  signal1=analogRead(A3);
  signal2=analogRead(A4);
  //Hier kann man code ergänzen, um mit den Messwerten etwas zu berechnen
  while(micros() < (t + zeitintervall)){
    //Die while-Schleife ist dazu da, bis zur nächsten Messung abzuwarten
  }
}

Arduino Code

In diesem Blogeintrag wird der Arduino-Code Schritt für Schritt erläutert. Wer sich nur für die Kurzfassung interessiert, der findet hier eine Kurzbeschreibung des Projekts.

Frequenzen berechnen vs. Frequenzfilter

Die meisten Lichtorgeln funktionieren mit Frequenzfiltern, d.h. das Audiosignal wird durch elektrotechnische Bauteile in verschiedene Frequenzbereiche zerlegt, welche dann die Lampen steuern können.

In der hier vorgestellten Realisierung gehen wir anders vor: Wir ermitteln die Frequenzbereiche digital und steuern die Lampen über einen Mikrocontroller. Das hat Vor- und Nachteile:

Natürlich ist auch eine Kombination aus beiden Techniken denkbar.

(Schnelle) Fouriertransformation

Die Fouriertransformation ist ein mathematisches Werkzeug, mit dessen Hilfe man errechnen kann, welche Frequenzen in einem komplizierten Schwingungsmuster auftreten. Das lässt sich auch auf Audiosignale anwenden: wenn wir eine Audioaufnahme vorliegen haben, dann können wir berechnen, welche Frequenzen (also welche Tonhöhen) in der Aufnahme vorhanden sind.

Da wir nur eine begrenzte Fülle an Informationen über die Schwingung haben (nämlich endlich viele Messwerte, siehe oben), benutzen wir die sogenannte Diskrete Fouriertransformation bzw. die Fast Fourier Transform (FFT, eine schnellere Variante der Diskreten Fouriertransformation). Wenn wir die Audiodaten in die FFT reingeben, bekommen wir das Frequenzspektrum ausgegeben. Dabei müssen wir ein paar Besonderheiten beachten:

Die Auflösung des Frequenzspektrums wird besser, wenn die Audiodaten aus vielen Messwerten bestehen. Das liegt daran, dass das Frequenzspektrum aus ebensovielen Daten besteht, wie das verwendete Audiosignal. Wenn das Audiosignal nur von kurzer Dauer ist (entspricht wenigen Messwerten), dann wird auch das Spektrum nur durch wenige Messwerte dargestellt und hat eine schlechte Auflösung (siehe Abbildung).

gute und schlechte Frequenzauflösung
Frequenzspektrum des Kammertons a auf einer Violine. Links wurden von Audiosignal nur ca. 12000 Samples verwendet, rechts 10 mal so viele. Man erkennt, dass auf der rechten Seite mehr Zwischenwerte für das Spektrum berechnet wurden, während die linken Seite die Auflösung deutlich schlechter ist.

Andererseits wird natürlich auch die Rechenzeit größer, wenn wir sehr viele Messwerte aufnehmen. Gerade auf dem Arduino, der keine große Rechenleistung hat, spielt das eine wichtigte Rolle.

Die maximale Frequenz, die wir berechnen können, entspricht der Hälfte der Abstastrate. Wenn wir das Audiosignal mit einer Abtastrate von 5000 Hz aufzeichnen, können wir Frequenzen bis maximal 2500 Hz erkennen.

FFT auf dem Arduino

Es gibt vorgefertigte Bibliotheken, die den FFT-Algorithmus zur Verfügung stellen, d.h. wir müssen ihn nicht von Hand programmieren. Ich habe mich dabei an folgendem Tutorial orientiert: What Is FFT and How Can You Implement It on an Arduino?. Kurz zusammengefasst: In der Arduino-IDE Wählt man "Sketch->Include Library->Manage Libraries". Dann kann man nach dem Suchbegriff "fft" suchen und die Bibliothek "arduinoFFT" auswählen.

Im Dateikopf verwenden wir zunächst folgende Zeilen: 

#include "arduinoFFT.h"
#define SAMPLES 128             //Zweierpotenzen
#define ABTASTRATE 8000         //Hz
arduinoFFT FFT = arduinoFFT();
Mit diesen können wir einerseits die FFT-Bibliothek einbinden, zum anderen legen wir zwei wichtige Größen fest: SAMPLES (die Menge der Audiodaten, die pro Zeitschritt verwendet werden) und ABSTASTRATE (die Frequenz, mit der wir messen; 8000 bedeutet hier: 8000 Daten pro Sekunde). Für die Größe SAMPLES sollten Zweierpotenzen verwendet werden, also die Zahlen 2,4,8,16,32,64,...

Sampling

Die Daten müssen in vektorieller Form vorliegen. Dazu deklarieren wir die Variablen 

double vReal[SAMPLES];
double vImag[SAMPLES];
Später können wir mit folgendem Code die Audiodaten einlesen: 
zeitintervall = round(1000000*(1.0/ABTASTRATE));
for(int i=0; i < SAMPLES; i++)
{
  t = micros();
  vReal[i] = analogRead(kanal1);
  vImag[i] = 0;  
  while(micros() < (t + zeitintervall)){
    //Abwarten, bis zeitintervall vorbei
  }
}
Hier ist kanal1 die Nummer des Analogpins, über den wir die Daten einlesen. Die while-Schleife dient dazu, lange genug abzuwarten, um gemäß der Abtastrate die Daten einzulesen.

FFT

Nach dem Einlesen der Daten erfolgt die Fouriertransformation: 

FFT.Windowing(vReal, SAMPLES, FFT_WIN_TYP_HAMMING, FFT_FORWARD);
FFT.Compute(vReal, vImag, SAMPLES, FFT_FORWARD);
FFT.ComplexToMagnitude(vReal, vImag, SAMPLES);
Die Frequenzspektren sind jetzt in den Vektoren vReal und vImag hinterlegt (vReal beinhaltet die Intensitäten der Kosinusschwingungen, vImag die Intensitäten der Sinusschwingungen). Der Laufindex i der Vektoreinträge entspricht dabei einer Frequenz von i*ABTASTRATE/SAMPLES, wobei wir nur die erste Hälfte der Daten verwenden können (der Rest ist nur eine gespiegelte Kopie der ersten Hälfte). Um die Gesamtintensität der Frequenz zu erhalten, die zum Eintrag Nummer i gehört, müssen wir Kosinus- und Sinusanteil zusammenführen (wir bilden den Betrag der zugehörigen komplexen Zahl), d.h. 
f=sqrt(sq(vReal[i])+sq(vImag[i]));
Den Wert für i=0 verwenden wir gar nicht, denn er enthält nur Informationen über einen eventuellen Offset der Daten (den haben wir bewusst hinzugefügt, um das Audiosignal in einen bestimmten Voltbereich zu bringen). Für die Frequenzanalyse ist diese Information nutzlos.

Stereokanäle

Die meisten Geräte, die Musik abspielen, verfügen über eine Stereoausgabe. Wir haben daher zwei Audiokanäle zur Verfügung, die wir verwenden können. Es gibt verschiedene Möglichkeiten, damit umzugehen:

Bei der letzten Variante besteht z.B. die Möglichkeit, zwei Lichtorgeln gleichzeitig zu steuern, während die eine über Kanal1 und die andere über Kanal2 geregelt wird. Wir können folgendermaßen vorgehen:

Kanäle gleichzeitig einlesen

Wir können die beiden Kanäle gleichzeitig einlesen und brauchen dazu zwei zusätzliche Vektoren 

double wReal[SAMPLES];
double wImag[SAMPLES];
Beim Einlesen verwenden wir dann zusätzlich den Code 
  wReal[i] = analogRead(kanal2);
  wImag[i] = 0;
Beachte dabei: Die Arduino-Boards mit dem ATmega328-Prozessor haben nicht genug Arbeitsspeicher, um vier Vektoren der Länge 128 als Variablen zu deklarieren. Man muss dann entweder die Größe SAMPLES reduzieren (z.B. auf 64) oder man bearbeitet die Frequenzspektren nacheinander.

Kanäle nacheinander einlesen

Wenn die Frequenzspektren nacheinander bearbeitet werden, dann können wir die Größe SAMPLES voll ausnutzen, allerdings läuft dann der gesamte Algorithmus ein wenig länger und die beiden Kanäle schalten zeitlich leicht versetzt. Die grobe Idee für den Code sieht folgendermaßen aus: 

for(int i=0; i < SAMPLES; i++)
{
  t = micros();
  vReal[i] = analogRead(kanal1);
  vImag[i] = 0;  
  while(micros() < (t + zeitintervall)){
    //Abwarten, bis zeitintervall vorbei
  }
}
FFT.Windowing(vReal, SAMPLES, FFT_WIN_TYP_HAMMING, FFT_FORWARD);
FFT.Compute(vReal, vImag, SAMPLES, FFT_FORWARD);
FFT.ComplexToMagnitude(vReal, vImag, SAMPLES);

// Hier muss die Steuerung der ersten Lichtorgel ergänzt werden

for(int i=0; i < SAMPLES; i++)
{
  t = micros();
  vReal[i] = analogRead(kanal2);
  vImag[i] = 0;  
  while(micros() < (t + zeitintervall)){
    //Abwarten, bis zeitintervall vorbei
  }
}
FFT.Windowing(vReal, SAMPLES, FFT_WIN_TYP_HAMMING, FFT_FORWARD);
FFT.Compute(vReal, vImag, SAMPLES, FFT_FORWARD);
FFT.ComplexToMagnitude(vReal, vImag, SAMPLES);

// Hier muss die Steuerung der zweiten Lichtorgel ergänzt werden

LED steuern

Die Lampensteuerung ist Geschmackssache, daher sind hier viele verschiedene Umsetzungen denkbar. Ich schildere meine Herangehensweise:

Parameter wählen

Über die Wahl der entsprechenden Parameter (vor allem SAMPLES und ABTASTRATE) lässt sich diskutieren, und die Werte hängen natürlich davon ab, welche Anforderungen man an seine Lichtorgel stellt. Über folgende Dinge sollte man sich Gedanken machen:

Bildwechselfrequenz der Lichtorgel

Wie oft pro Sekunde werden die Lampen der Lichtorgel neu eingestellt? Das hängt davon ab, wie schnell der Algorithmus arbeitet. Die Gesamtzeit eines Durchlaufs dieses Algorithmus ist die Summe aus Aufnahmedauer und Rechenzeit. Die Aufnahmedauer entspricht SAMPLES/ABTASTRATE (in meinem Beispiel mal 2, da die beiden Kanäle nacheinander bearbeitet werden). Das sind für 8000 Hz und 128 Samples gerade 16 ms (für jeden Kanal). Die Rechenzeit wächst mit der Größe SAMPLES (und zwar superlinear, d.h. bei doppelt so vielen Messwerten ist die Rechenzeit MEHR als doppelt so lang). Die Rechenzeit liegt bei 128 Samples bei ca. 50 ms (pro Kanal).

Wer die Rechenzeit bei seinen Einstellungen testen will, der kann folgendermaßen vorgehen: Vor den Codeblock, der die FFT berechnet, schreibt man: 

zeit=micros();
Nach dem Codeblock schreibt man 
Serial.println(micros()-zeit);
Natürlich sollte man im Voraus bereits die Variable int zeit gesetzt und den seriellen Monitor aktiviert haben. Dann kann man sich die Rechenzeit (in Mikrosekunden!) auf dem seriellen Monitor betrachten.

Auflösung der Frequenzspektren

Bei der Frequenzauflösung spielen zwei Werte eine Rolle: Wie groß ist die maximale Frequenz, die wir berechnen können? Und wie gut ist die Auflösung in dem Bereich darunter? Verbessert man den einen Wert, so wird man zwangsläufig den anderen verschlechtern. Die maximale Frequenz ist ganz einfach die Hälfte der Abtastrate. Für die Auflösung gilt folgendes: Da wir den Bereich von 0 Hz bis ABTASTRATE mit einer Anzahl von Werten abdecken, der mit SAMPLES übereinstimmt, entspricht unsere Auflösung gerade ABTASTRATE/SAMPLES. Bei 128 Daten und 8000 Hz Abtastrate haben wir gerade einen Messwert für ein Intervall der Länge 62,5 Hz.

Eine Lichtorgel mit kleinen LED

Mit dem bisher erarbeiteten Wissen können wir problemlos eine Lichtorgel konstruieren, indem wir Leuchtdioden an den Pins des Arduino anbringen. Wichtig dabei ist, dass es Pins sind, die über eine Pulsweitenmodulation (PWM) angesteuert werden können, d.h. mit dem Befehl analogWrite.

Problematisch wird es, wenn die Lampen, die wir steuern wollen, größere Spannungen oder Stromstärken benötigen, die der Arduino nicht mehr schafft. In diesem Fall müssen wir eine externe Spannungsquelle verwenden, die durch den Arduino geschaltet werden können. Das ist z.B. mit einem Relais möglich. Dieses kann jedoch nur an- und aus schalten und reagiert recht langsam. Ein Transistor hingegen schaltet schneller und bietet uns die Möglichkeit, die LED zu dimmen, um Unterschiede in der Helligkeit zu erzeugen.

Eine Lichtorgel mit Transistoren und zusätzlichem Netzteil

In meinem Beispiel verwende ich die LEDBERG RGB Lichtleiste von IKEA. Diese wird mit einer Spannung von 24 V betrieben, was zu hoch für Arduino-Boards ist. Daher verwende ich ein separates 24 V Netzteil, um die Lichtleisten mit Strom zu versorgen.

Pins an der LEDBERG Lichtleiste

Die bunten LEDBERG Lichtleisten haben 4 Pins, die mit R, G, B und + bezeichnet werden. Der + Pin dient der Spannungsversorgung (24 V) für alle Farben gleichzeitig. Jede Farbe hat jedoch ihren eigenen Minuspol. Deswegen werden die Transistoren (mit denen wir die einzelnen Farben an und aus schalten) zwischen die Minuspole an der Lichtleiste und den Minuspol am Netzteil geschaltet.

Stromstärke, Leistung, Widerstand

Die Lichtleiste wird auf dem IKEA Onlineshop mit einer Leistung von 2 W beziffert. Da das Produkt normalerweise mit 3 Lichtleisten betrieben wird, ergibt das 666 mW pro Lichtleiste und 222 mW pro Lichtleiste und Farbe. Das sind bei 24 V eine Stromstärke von ca. 28 mA pro Lichtleiste und ca. 10 mA pro Lichtleiste und Farbe. Wie bereits erwähnt betreibe ich zwei Lichtorgeln gleichzeitig (eine pro Audiokanal) und habe jede mit jeweils 2 Leisten bestückt. Das ergibt ca. 20 mA pro Farbe (bei insgesamt 3 Farben pro Audiokanal, d.h. 6 Farben). Diese Werte brauchen wir später, um den passenden Transistor und einen geeigneten Vorwiderstand zu ermitteln.

Mit Transistoren arbeiten

Wie man einen Transistor als elektrischen Schalter verwendet, ist beispielsweise hier beschrieben. Das Grundprinzip besteht darin, dass man den Transistor mit Emitter und Kollektor in den Stromkreis einbaut und über die Basis eine Steuerspannung anlegt. Ist die Steuerspannung 0, so wird der Widerstand des Transistors sehr groß, so dass kein Strom fließen kann (der Transistor sperrt und hat den Zustand "ausgeschaltet"). Wenn eine Steuerspannung anliegt, wird der Widerstand des Transistors kleiner und es kann ein Strom fließen (der Transistor erhält den Zustand "eingeschaltet"). Die Basis wird dann mit den Ausgangspins am Arduino verbunden, genauso wie wenn man eine normale LED ansteuert.

Ich verwende Transistoren des Typs BC547 mit einem Vorwiderstand von 1000 Ω. Den Emitter verbinde ich mit der gemeinsamen Erde, den Kollektor mit jeweils einem Minuspol an der Lichtleiste.

Transistoren des Typs BC547. 3 Transistoren schalten eine Lichtorgel (je ein Transistor pro Farbkanal)

Vorüberlegungen zur fertigen Schaltung

 Die Schaltung meiner Lichtorgel habe ich so realisiert, dass sich die komplette Elektronik in einer hölzernen Box befindet. Ein- und Ausgehende Kabel braucht man natürlich für die Lichtleisten, die Stromversorgung (in meinem Fall 2 separate Stromversorgungen für Arduino und die Lichtleisten) und die Audiokabel. Im Idealfall ist auch der USB-Port am Arduino erreichbar, falls man eine andere Software aufspielen will.

Stromversorgung Arduino

Der Arduino benötigt eine 5V Spannungsquelle. Das kann man über den USB-Eingang realiseren, oder man nutzt den VIN-Pin am Arduino. Diese Lösung habe ich gewählt. Ich verbinde den VIN und einen GND-Pin am Arduino mit einem 5V und einem GND-Pin am Raspberry Pi (die Stromstärke, die ein Arduino Nano benötigt, liegt im Bereich dessen, was der Raspberry leisten kann: 25 mA sagt bspw. chip.de; Hinzu kommt der Stromverbrauch an den 6 Transistoren, der jedoch auch bei wenigen mA liegen dürfte). Natürlich kann man die Pins auch mit einer Batterie verbinden.

Gemeinsame Masseverbindung

Die verschiedenen Bauteile (in meinem Fall Raspberry Pi, Arduino, Transistoren, LED Lichtleisten) haben irgendwo einen Minuspol, und dieser sollte für alle Bauteile auf dem selben Potential liegen: Man sollte also die Bauteile alle über einen gemeinsamen Ground miteinander verbinden. In meiner Schaltung wird der Aruino über den Raspberry mit Strom versorgt.

Auf der linken Seite befindet sich der Output (Transistoren und die weißen Kabel der LED-Lichtleisten), auf der rechten Seite ist der Input (Klinkekabel und Offsetschaltung).

Schaltplan

Schaltplan der Lichtorgel (für Werte der Widerstände siehe unten).
Weitere Details des Schaltplans. Der Arduino wird über den Raspberry Pi mit Strom versorgt (daher existiert eine GND-Verbindung beider Geräte). LO 1 und LO 2 bezeichnen die beiden Lichtorgeln für den ersten und zweiten Kanal, jeweils mit drei Farben (R G B).

Die fertige Schaltung

Die fertige Schaltung. Eingehende Kabel sind die Spannungsversorgung der Lichtleisten (24 V, gelbes und schwarzes Kabel), die Spannungsversorgung des Arduino (5 V, rotes und schwarzes Kabel) und der Audioinput (Klinkestecker).