Dauerkalender

Weihnachtsbeleuchtung
mit Arduino und PNP-Transistoren

Solange bei den elektronischen Experimenten darum geht, z.B. eine Leuchtdiode zum Leuchten zu bringen, werden viele Fragen, die durchaus beantwortet werden sollen, sehr oft erst gar nicht gestellt. Welcher Strom fließt durch die Bauelemente oder mit welcher Leistung haben wir hier zu tun?
In dem Versuch werden von Arduino zehn RGB-Leuchtdioden geschaltet. Jede RGB-Leuchtdiode besteht intern aus drei farbigen (Rot, Blau, Grün) einzelnen Leuchtdioden, die in einem Gehäuse untergebracht sind. Die gleichfarbigen Einzeldioden aller RGBs werden durch eine gemeinsame Leitung mit Strom versorgt. Damit haben wir in der Schaltung mit drei separaten Stromkreisen zu tun. Für jeden LED-Strang ist ein Arduino-Ausgang zuständig. Bereits in dieser Miniausführung werden 30 Leuchtdioden geschaltet.
Mit der Schaltung kann man einige interessante Lichtspiele veranstalten (wie z.B. Weihnachtsbeleuchtung, Fensterbeleuchtung, Werbelichter etc), vorrangig geht es hier jedoch um Spannung-, Strom- und Leistungsberechnung für einzelne Schaltungselemente. Bei mehreren Abnehmern kann die Stromaufnahme schnell ansteigen und die Leistungsfrage kann nicht mehr außer Acht gelassen werden.

Arduino Nano

Die aktuelle Farbe, die die RGB-Leuchtdioden liefern, werden von Arduino Nano via Zufall bestimmt. Sobald dies geschehen ist, wird der zuständige LED-Strang oder Stränge via PWM geschaltet. Mit den drei Potis werden die steigende und fallende Rampe bei Änderung der Helligkeit sowie die Helligkeit der Leuchtdioden bestimmt.

PNP Transistor BC640

Transistor BC640

Bei dem Transistor BC640 handelt es sich um einen Bipolar-Standard-Leistungstransistor. Die Ausführung des Transistors ist PNP (positiv-negativ-positiv). Die Anschlüsse des Bausteins sind Basis (B), Emitor (E) und Collector (C):

Schaltsymbol

Technische Daten BC640
Gehäuse: TO-92
Kanäle: 1 Kanal
Ausführung: PNP
Kollektor-Strom I(C): - 1A
Kollektor-Emitterspannung U(CEO): -80V
Leistung (max) P(TOT): 1 W
Transitfrequenz f(T): 100 MHz

Schaltplan

Schaltplan

Testschaltung

Testschaltung

Für das Beispiel legen wir fest, dass durch jede Leuchtdiode ein Strom von 10 mA fließen soll. Pro einen Kreis müssen wir dementsprechend mit 100 mA rechnen. Bei einer größeren Anzahl an LEDs würde der Strom dann weiter steigen.
Wenn wir jetzt einen beliebigen LED-Strang an einen Arduino-Ausgang anschließen und ihn einschalten, würde der kleine Mikrocontroller beschädigt werden. Mit 100 mA wäre der Ausgang ganz überfordert. Deswegen wird hier ein Transistor zwischengeschaltet, der die Leistungsaufgaben der Schaltung übernimmt und den Mikrocontroller von hohen Strömen abkoppelt. Der Transistor muss so gewählt werden, dass er problemlos den Strom von 100 mA schalten kann. Der Transistor BC640, der hier zum Einsatz kommt, verträgt Schaltströme bis zu 1 A.
Damit die Leuchtdioden nicht zerstört werden, benötigen sie einen Vorwiderstand. Bei 5 V Versorgungsspannung kann man seinen Wert schnell errechnen:
R = 5 V / 100 mA = 50 Ohm
Wenn wir jetzt einen Standardwiderstand mit 0,25 W Leistung für diese Aufgabe wählen, gibt es gleich Probleme. Die Leistung des Widerstandes muss mindestens
P = U * I = 5V * 100 mA = 0.5W betragen.
Ansonsten wird auch dieser Bauteil zerstört.
Wenn man keinen Widerstand mit der gewünschten Leistung zur Hand hat, können mehrere Widerstände parallel geschaltet werden. In diesem Fall kommen pro Strang drei 150 Ohm Widerstände zum Einsatz. Sie werden jeweils parallel geschaltet. Der Gesamtwiderstand, der jetzt 50 Ohm beträgt, kann aus dieser Formel abgeleitet werden:
1/Rgesamt = 1/R1 + 1/R2 + 1/R3
Jetzt fließ durch jeden Widerstand Strom in Höhe von
I = 5 V / 50 Ohm / 3 = 33 mA.
Die hier benötigte Leistung pro Widerstand beträgt demnach P = 33 mA * 5 V = 0,16 W. Damit sind wir auch hier im grünen Bereich.
An der Basis des Transistors wird ein Widerstand von 1 kOhm angeschlossen. Er bestimmt die Stärke des Stromes, der durch den Ausgang des Mikrocontrollers fließt. So beträgt er maximal
I = 5 V / 1000 Ohm = 5 mA.
In der Stärke ist er für den Mikrocontroller ungefährlich. Die Schaltung kann jetzt eingeschaltet werden.

Das Programm (Sketch)

int RGB_LEDs_BL = 3;                               // LED-Strang Blau am Pin Nr. D3
int RGB_LEDs_GN = 5;                               // LED-Strang Grün am Pin Nr. D5
int RGB_LEDs_RT = 6;                               // LED-Strang Rot am Pin Nr. D6
int Taste_Start = 2;                               // Taste Pin Nr. 2
int Pin_Zeit_AN = A0;                              // Poti Zeit_AN (steigende Rampe)
int Pin_Zeit_AUS = A1;                             // Poti Zeit_Aus (fallende Rampe)
int Pin_Helligkeit = A2;                           // Helligkeits-Einstellung

byte Zufallsfarbe;                                 // Aktuelle Farbe (7 Möglichkeiten)
int pwm;                                           // Aktueller PWM-Wert

void setup() {
  pinMode (Taste_Start, INPUT_PULLUP);             // Pin D2 als Eingang
}

void LEDs_AN () {                                  // Unterprogramm Ein/Aus
    if (bitRead(Zufallsfarbe,0) == 1) {            // Abfrage BIT 0 der Farbenzahl
        analogWrite (RGB_LEDs_BL, pwm);            // LEDs Blau Ein
        } else { 
        analogWrite (RGB_LEDs_BL, 255); }          // LEDs Blau Aus
    if (bitRead(Zufallsfarbe,1) == 1) {            // Abfrage BIT 1 der Farbenzahl
        analogWrite (RGB_LEDs_GN, pwm);            // LEDs Grün Ein
        } else { 
        analogWrite (RGB_LEDs_GN, 255); }          // LEDs Grün Aus
    if (bitRead(Zufallsfarbe,2) == 1) {            // Abfrage BIT 3 der Farbenzahl
        analogWrite (RGB_LEDs_RT, pwm);            // LEDs Rot Ein
        } else { 
        analogWrite (RGB_LEDs_RT, 255); }          // LEDs Rot Aus
}

void loop () {
  
    while (true) {
        Zufallsfarbe = random(1,8);                              // 7 mögliche Farbkombinationen
        int Zeit_AN = analogRead(Pin_Zeit_AN) / 20;              // Pausen bei heller werden
        int Zeit_AUS = analogRead(Pin_Zeit_AUS) / 20;            // Pausen bei dunkler werden
        int Helligkeit = 255 - (analogRead(Pin_Helligkeit) / 4); // Helligkeit

        if (digitalRead(Taste_Start) == LOW) {                   // Ablauf gestartet?
            for (pwm = 255; pwm > Helligkeit ; pwm--) {          // Helligkeit steigt
                LEDs_AN ();                                      // Aufruf Unterprogramm
                delay(Zeit_AN);                                  // Verzögerungszeit bei heller werden
            }            
            for (pwm = Helligkeit; pwm < 256; pwm++) {           // Helligkeit fällt
                LEDs_AN ();                                      // Aufruf Unterprogramm
                delay(Zeit_AUS);                                 // Verzögerungszeit bei dunkler werden
            } 
        }      
    }
}
// ********************************************************************************        

Kurzvideo

Kurzvideo

Weitere Themen: