RGB MoodlightAus Attraktor WikiVersion vom 2. April 2017, 14:25 Uhr von Markus (Diskussion | Beiträge) InhaltsverzeichnisRGB MoodlightFür unsere Lötworkshops im Attraktor hat Sebastian ein schickes RGB-Moodlight entworfen. Die Bausätze sind mit einfach verlötbaren Bauteilen bestückt. Die Platine hat eine RGB-LED verbaut, die durch einen bereits programmierten ATtiny-Mikrocontroller (ATtiny44, pinkompatibel zu ATtiny24 und ATtiny84) angesteuert wird. Wer den Programmiercode modifizieren oder einige der nach außen geführten Ports nutzen möchte, kann dies mit der für Anfänger gut geeigneten Arduino-Oberfläche tun. Beschreibung der BauteileBauteillisteC1 0.33µF/ 0,47µF (je nach Bausatz) C2 0,1µF C3 100nF C4 22pF C5 22pF CON1 Stiftleiste 1x5 Pin G1 9V Batterie BCON 9V Batterie Anschlussklemme IC1 ATTINY24/44/84A Sockel DIP-14 IC Sockel IC2 7805 Linearregler (TO-220 Gehäuse) ISP Stiftleiste 2x3 Pin LED1 SuperFlux RGB LED (Gemeinsame Kathode) R1 150 Ohm R2 150 Ohm R3 150 Ohm R4 10k Ohm R5 10k Ohm SW1 DIP-Switch 1-Pol X1 Quarz 20Mhz HC49-S BRD Moodlight Platine Identifizierung der Bauteile, Eagle Layout und Schaltplan, fertiges Board mit PlatinenhalterMontage der BauelementeProgrammierungDer Atmel ATtiny44 Mikrocontroller, der auf dem Board verbaut ist, kann natürlich mit Entwicklungsumgebungen wie ATMEL Studio programmiert und geflasht (Fuses interner Oszillator: LOW: 0x62, HIGH: 0xDF, EXTENDED: 0xFF/ 20 MHz: LOW = 0xCE, HIGH = 0xDF, EXTENDED = 0xFF) werden. Allerdings ist auch die einfache Programmierung und das Bespielen mit der Arduino IDE möglich. Wie das funktioniert, zeigen wir anhand der Arduino IDE ab der Version 1.64, dem Arduino UNO als Programmieradapter und dem bekannten "Blink"-Sketch aus den Beispielprogrammen der IDE. Zunächst lädt man sich die aktuelle Arduino IDE herunter und installiert sie. Für die Integration des ATtiny44 folgt man den Anweisungen des High-Low Tech Projekt des MIT Media Lab. Dann kann man sich mit Hilfe eines Arduino UNO einen Programmieradapter bauen: Als nächstes muss der Arduino als Programmieradapter vorbereitet werden. Eine genaue Anleitung findet sich hier. Um nicht immer wieder die Drahtbrücken stecken zu müssen, kann man sich aus einer 6-poligen Pfostenbuchse wie dieser hier und einem passenden 6-poligen Kabel, bei dem man die Enden auf Stiftleisten lötet, ein Programmierkabel für wenig Geld selber bauen. Der 9V-Block sollte beim Programmieren nicht angeschlossen sein. Wenn man allerdings einen Programmieradapter wie den AVRISP MkII verwendet, braucht man eine externe Stormversorgung. Bitte also die Anleitungen für die Programmieradapter beachten. Die Pfostenbuchse kann an die 6-polige Stiftleiste am RGB-Moodlight-Board angesteckt werden (bitte Polung beachten!). Danach muss der Arduino UNO wie oben beschrieben als ISP-Adapter vorbereitet werden ("Datei -> Beispiele -> ArduinoISP" aufspielen) und beim Programmieren der Eintrag unter "Tools -> Board -> ATtiny24/44/84", -> "Prozessor: ATtiny44" und -> "Clock: External 20 MHz") ausgewählt werden. Dann testet man das ganze mit dem "Blink"-Sketch und lädt das Programm auf den ATtiny44 hoch. Bitte beachtet, dass ein Pin der angeschlossenen RGB-Led benutzt wird - also z.B. Pin 7 als led-Variable definiert wird (und nicht "13" wie in dem Beispiel-Sketch). ProgrammierbeispielNachfolgend ein Beispiel, um die blaue LED der RGB-LED aufblinken zu lassen. Dieser Sketch kann mit der Arduino IDE und den obigen Einstellungen auf den Mikrocontroller übertragen werden. /* Blink Schaltet eine LED für eine Sekunde an und für eine Sekunde wieder aus */ // An Pin 7/ PA6 ATtiny44 - entsprechend Arduino Pin 6 ist die blaue LED // An Pin 6/ PA7 ATtiny44 - entsprechend Arduino Pin 7 ist die rote LED // An Pin 5/ PB2 ATtiny44 - entsprechend Arduino Pin 8 ist die grüne LED // der RGB-LED angeschlossen // Wir benutzen die blaue LED int led = 6; // Im Setup wird die LED als Ausgang definiert void setup() { pinMode(led, OUTPUT); } // In der Programmschleife lassen wir die blaue LED blinken void loop() { digitalWrite(led, HIGH); // Anschalten der LED (HIGH = Betriebsspannung 5V) delay(1000); // Eine Sekunde warten digitalWrite(led, LOW); // Ausschalten der LED (LOW = 0V) delay(1000); // Eine Sekunde warten } Das ganze kann man natürlich auch in C programmieren und z.B. mit dem kostenlosen Atmel Studio und einem Programmer wie dem AVRISP MkII auf den Mikrocontroller überspielen. Der dem obigen Beispiel entsprechende Code würde dann so aussehen: /* * ATtiny44_blink.c * Blink * Schaltet eine LED für eine Sekunde an und für eine Sekunde wieder aus * Author: Markus */ #define F_CPU 20000000 // Prozessortakt #include <avr/io.h> // Pinzuweisungen #include <util/delay.h> // Wartefunktionen #define LED PA6 // LED wird im Code durch PA6 ersetzt int main(void) { // Dieser Teil entspricht der setup()-Funktion der Arduino IDE // Das Bit PA6 (dort ist die blaue LED der RGB LED angeschlossen) vom DDRA (Data Direction Register Port A) // wird auf 1 und damit als Ausgang gesetzt DDRA |= (1 << LED); while(1) // Endlosschleife - entspricht der loop()-Funktion der Arduino IDE { PORTA |= (1 << LED); // PA6 von PORT A wird auf 1 = HIGH = // Betriebsspannung 5V gesetzt => Anschalten der blauen LED _delay_ms(1000); // Eine Sekunde warten PORTA &= ~(1 << LED); // PA6 von PORT A wird auf 0 = LOW = 0V gesetzt // => blaue LED wird ausgeschaltet _delay_ms(1000); // Eine Sekunde warten } return(0); } RGB-Moodlight SketchDer aktuelle Code auf dem RGB-Moodlight ist mit der Arduino IDE erstellt worden und sieht folgendermaßen aus: /* Blink Je nach Stellung des Dip-Schalters gibt es bei: "0" ein rotes, dreifaches Blitzlicht der roten LED "1" Auf- und Abfaden der drei Farben (Rot, Grün, Blau) der RGB-LED */ // An Pin 7/ PA6 ATtiny44 - entsprechend Arduino Pin 6 ist die blaue LED // An Pin 6/ PA7 ATtiny44 - entsprechend Arduino Pin 7 ist die rote LED // An Pin 8/ PB2 ATtiny44 - entsprechend Arduino Pin 8 ist die grüne LED // der RGB-LED angeschlossen // An Pin 3/ PA3 ATtiny44 - entsprechend Arduino Pin 3 ist der Dip-Schalter angeschlossen // Wir definieren die Pins der LEDs und des Schalters byte ledBlau = 6; byte ledRot = 7; byte ledGruen = 8; byte inputPin = 3; // Im Setup werden die LEDs als Ausgang und der Schalter als Eingang definiert void setup() { pinMode(ledBlau, OUTPUT); pinMode(ledRot, OUTPUT); pinMode(ledGruen, OUTPUT); pinMode(inputPin, INPUT); } // In der Programmschleife lassen wir entsprechen der Schalterstellung entweder die // rote LED dreimal Blitzen bzw. die rote, grüne und blaue LED auf- und abfaden void loop() { if (digitalRead(inputPin) == 1) { // Blaue LED faden for (int fadeWert = 0 ; fadeWert <= 255; fadeWert += 5) { // Setzt den Wert (Bereich von 0 bis 255) analogWrite(ledBlau, fadeWert); // 10 Millisekunden warten, um den Dimmeffekt zu sehen delay(10); } // Ausfaden vom Maximum (255) bis zum Minimum (0) for (int fadeWert = 255 ; fadeWert >= 0; fadeWert -= 5) { // Setzt den Wert (Bereich von 0 bis 255) analogWrite(ledBlau, fadeWert); // 10 Millisekunden warten, um den Dimmeffekt zu sehen delay(10); } // Grüne LED faden for (int fadeWert = 0 ; fadeWert <= 255; fadeWert += 5) { // Setzt den Wert (Bereich von 0 bis 255) analogWrite(ledGruen, fadeWert); // 10 Millisekunden warten, um den Dimmeffekt zu sehen delay(10); } // Ausfaden vom Maximum (255) bis zum Minimum (0) for (int fadeWert = 255 ; fadeWert >= 0; fadeWert -= 5) { // Setzt den Wert (Bereich von 0 bis 255) analogWrite(ledGruen, fadeWert); // 10 Millisekunden warten, um den Dimmeffekt zu sehen delay(10); } // Rote LED faden for (int fadeWert = 0 ; fadeWert <= 255; fadeWert += 5) { // Setzt den Wert (Bereich von 0 bis 255) analogWrite(ledRot, fadeWert); // 10 Millisekunden warten, um den Dimmeffekt zu sehen delay(10); } // Ausfaden vom Maximum (255) bis zum Minimum (0) for (int fadeWert = 255 ; fadeWert >= 0; fadeWert -= 5) { // Setzt den Wert (Bereich von 0 bis 255) analogWrite(ledRot, fadeWert); // 10 Millisekunden warten, um den Dimmeffekt zu sehen delay(10); } } else { // Wir lassen die rote LED dreimal blitzen und warten dann 900 ms for (byte i = 0; i < 4 ; i++) { digitalWrite(ledRot, HIGH); delay(50); digitalWrite(ledRot, LOW); delay(50); } digitalWrite(ledRot, LOW); delay(900); } } RGB-Moodlight Sketch mit mehr FarbenDiesen Code hatten wir während des Workshops auf ein Moodlight geladen. Programmiert wurde dieser Code ebenfalls mit der Arduino IDE und sieht folgendermaßen aus: /* Vorlage http://www.instructables.com/id/ATtiny85-Mini-RGB-Mood-Light/?ALLSTEPS pinbelegung geändert, sensor-initialisierung und Schleife herauskommentiert */ // An Pin 7/ PA6 ATtiny44 - entsprechend Arduino Pin 6 ist die blaue LED // An Pin 6/ PA7 ATtiny44 - entsprechend Arduino Pin 7 ist die rote LED // An Pin 5/ PB2 ATtiny44 - entsprechend Arduino Pin 8 ist die grüne LED const int bluPin = 6; const int redPin = 7; const int grnPin = 8; void setup() { pinMode(redPin, OUTPUT); pinMode(grnPin, OUTPUT); pinMode(bluPin, OUTPUT); } void loop() { redtoyellow(); yellowtogreen(); greentocyan(); cyantoblue(); bluetomagenta(); magentatored(); } void redtoyellow() { digitalWrite(redPin, HIGH); digitalWrite(bluPin, LOW); // fade up green for(byte i=1; i<100; i++) { byte on = i; byte off = 100-on; for( byte a=0; a<100; a++ ) { digitalWrite(grnPin, HIGH); delayMicroseconds(on); digitalWrite(grnPin, LOW); delayMicroseconds(off); } } } void yellowtogreen() { digitalWrite(grnPin, HIGH); digitalWrite(bluPin, LOW); // fade down red for(byte i=1; i<100; i++) { byte on = 100-i; byte off = i; for( byte a=0; a<100; a++ ) { digitalWrite(redPin, HIGH); delayMicroseconds(on); digitalWrite(redPin, LOW); delayMicroseconds(off); } } } void greentocyan() { digitalWrite(grnPin, HIGH); digitalWrite(redPin, LOW); // fade up blue for(byte i=1; i<100; i++) { byte on = i; byte off = 100-on; for( byte a=0; a<100; a++ ) { digitalWrite(bluPin, HIGH); delayMicroseconds(on); digitalWrite(bluPin, LOW); delayMicroseconds(off); } } } void cyantoblue() { digitalWrite(bluPin, HIGH); digitalWrite(redPin, LOW); // fade down green for(byte i=1; i<100; i++) { byte on = 100-i; byte off = i; for( byte a=0; a<100; a++ ) { digitalWrite(grnPin, HIGH); delayMicroseconds(on); digitalWrite(grnPin, LOW); delayMicroseconds(off); } } } void bluetomagenta() { digitalWrite(bluPin, HIGH); digitalWrite(grnPin, LOW); // fade up red for(byte i=1; i<100; i++) { byte on = i; byte off = 100-on; for( byte a=0; a<100; a++ ) { digitalWrite(redPin, HIGH); delayMicroseconds(on); digitalWrite(redPin, LOW); delayMicroseconds(off); } } } void magentatored() { digitalWrite(redPin, HIGH); digitalWrite(grnPin, LOW); // fade down blue for(byte i=1; i<100; i++) { byte on = 100-i; byte off = i; for( byte a=0; a<100; a++ ) { digitalWrite(bluPin, HIGH); delayMicroseconds(on); digitalWrite(bluPin, LOW); delayMicroseconds(off); } } } RGB-Moodlight Gas-Sensor Sketch/* RGB-Moodlight Sketch mit angeschlossenem Gas-Sensor Je nach Wert leuchtet die LED in Grün, Gelb, Rot oder blitzt dreimal */ // An Pin 7/ PA6 vom ATtiny44 - entsprechend Arduino Pin 6 ist die blaue LED angeschlossen // An Pin 6/ PA7 vom ATtiny44 - entsprechend Arduino Pin 7 ist die rote LED angeschlossen // An Pin 5/ PB2 vom ATtiny44 - entsprechend Arduino Pin 8 ist die grüne LED angeschlossen // An Pin 11/ PA2 vom ATtiny44 - entsprechend Arduino Pin 2 ist der Gas-Sensor angeschlossen // Wir definieren die Pins der LEDs und des Gas-Sensors und setzen seinen initialen Wert auf 0 byte ledBlau = 6; byte ledRot = 7; byte ledGruen = 8; byte gasSensorAin = 2; int analogValue = 0; // Im Setup werden die LEDs als Ausgang definiert void setup() { pinMode(ledBlau, OUTPUT); pinMode(ledRot, OUTPUT); pinMode(ledGruen, OUTPUT); } // In der Programmschleife lassen wir abhängig vom Wert des // Gas-Sensors die entsprechende LED leuchten void loop() { analogValue = analogRead(gasSensorAin); // In drei verschiedenen Bedingungen lassen wir die jeweils // ausgewählte LED leuchten if ((analogValue > 0) and (analogValue <= 110)) { digitalWrite(ledRot, LOW); digitalWrite(ledBlau, LOW); digitalWrite(ledGruen, HIGH); } else if ((analogValue > 110) and (analogValue <= 150)) { digitalWrite(ledRot, HIGH); digitalWrite(ledBlau, LOW); digitalWrite(ledGruen, HIGH); } else if ((analogValue > 150) and (analogValue <= 190)) { digitalWrite(ledRot, HIGH); digitalWrite(ledBlau, LOW); digitalWrite(ledGruen, LOW); } else { // Bei einem höheren Wert lassen die rote LED dreimal blitzen und warten dann 900 ms for (byte i = 0; i < 4 ; i++) { digitalWrite(ledRot, HIGH); delay(50); digitalWrite(ledRot, LOW); delay(50); } digitalWrite(ledRot, LOW); delay(900); } } Bisherige Lötworkshops |