RGB Moodlight: Unterschied zwischen den Versionen

Aus Attraktor Wiki

Wechseln zu: Navigation, Suche
(Bauanleitung/ Bild)
K
 
(13 dazwischenliegende Versionen von 2 Benutzern werden nicht angezeigt)
Zeile 3: Zeile 3:
 
[[File:loetworkshop_blog.jpg|200px|thumb|right|Platinen für den Lötworkshop]]
 
[[File:loetworkshop_blog.jpg|200px|thumb|right|Platinen für den Lötworkshop]]
  
−
Für unseren ersten [https://wiki.attraktor.org/Termin:Loetworkshop1 Lötworkshop] im Attraktor hat Sebastian ein schickes RGB-Moodlight entworfen.
+
Fü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.
 
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.
Zeile 12: Zeile 12:
  
 
<pre>
 
<pre>
−
C1      0.33µF            
+
C1      0.33µF/ 0,47µF (je nach Bausatz)       
−
C2      0.1µF           
+
C2      0,1µF           
 
C3      100nF             
 
C3      100nF             
 
C4      22pF               
 
C4      22pF               
Zeile 19: Zeile 19:
 
CON1    Stiftleiste 1x5 Pin         
 
CON1    Stiftleiste 1x5 Pin         
 
G1      9V Batterie
 
G1      9V Batterie
−
BCON    9V Batterie Anschlussklemme mit XH2.54-2P Stecker
+
BCON    9V Batterie Anschlussklemme
−
BATTERIE XH2.54-2P Buchse   
+
 
IC1      ATTINY24/44/84A  
 
IC1      ATTINY24/44/84A  
 
Sockel  DIP-14 IC Sockel
 
Sockel  DIP-14 IC Sockel
Zeile 32: Zeile 31:
 
R5      10k Ohm               
 
R5      10k Ohm               
 
SW1      DIP-Switch 1-Pol
 
SW1      DIP-Switch 1-Pol
−
X1      Quarz 20Mhz HC49-U
+
X1      Quarz 20Mhz HC49-S
 
BRD      Moodlight Platine
 
BRD      Moodlight Platine
−
SCREW    M3-10 Schraube + Mutter
 
 
</pre>
 
</pre>
  
Zeile 54: Zeile 52:
 
==Programmierung==
 
==Programmierung==
  
−
Der Atmel '''ATtiny44''' Mikrocontroller, der auf dem Board verbaut ist, kann natürlich mit Entwicklungsumgebungen wie ATMEL Studio programmiert und geflasht werden. Allerdings ist auch die einfache Programmierung und das Bespielen mit der Arduino IDE möglich.
+
Der 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 in der Version 1.0.5r2, dem Arduino UNO als Programmieradapter und dem bekannten "Blink"-Sketch aus den Beispielprogrammen der IDE.
+
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 [http://arduino.cc/en/Main/Software aktuelle 1.0er-Version der Arduino IDE] herunter und installiert sie. Dann lädt man die Datei [http://highlowtech.org/?p=1695 attiny-master.zip] von dieser Seite (ein Projekt des MIT Medi Lab) herunter, entpackt sie und kopiert sie wie dort beschrieben.
+
Zunächst lädt man sich die [http://arduino.cc/en/Main/Software aktuelle Arduino IDE] herunter und installiert sie. Für die Integration des ATtiny44 folgt man den Anweisungen des [http://highlowtech.org/?p=1695 High-Low Tech Projekt des MIT Media Lab].
  
−
Da der ATtiny44 mit externem 8MHz Quarz wie bei uns auf dem Board verbaut dort nicht als Option vorhanden ist, müssen noch folgende Zeilen in der Datei "boards.txt" ergänzt werden:
+
Dann kann man sich mit Hilfe eines Arduino UNO einen Programmieradapter bauen:
−
 
+
−
attiny44-8e.name=ATtiny44 (external 8 MHz clock)<br>
+
−
attiny44-8e.bootloader.low_fuses=0xff<br>
+
−
attiny44-8e.bootloader.high_fuses=0xdf<br>
+
−
attiny44-8e.bootloader.extended_fuses=0xff<br>
+
−
attiny44-8e.upload.maximum_size=4096<br>
+
−
attiny44-8e.build.mcu=attiny44<br>
+
−
attiny44-8e.build.f_cpu=8000000L<br>
+
−
attiny44-8e.build.core=arduino:arduino<br>
+
−
attiny44-8e.build.variant=tiny14
+
  
 
<gallery>
 
<gallery>
Zeile 87: Zeile 75:
 
Die Pfostenbuchse kann an die 6-polige Stiftleiste am RGB-Moodlight-Board angesteckt werden (bitte Polung beachten!).
 
Die Pfostenbuchse kann an die 6-polige Stiftleiste am RGB-Moodlight-Board angesteckt werden (bitte Polung beachten!).
  
−
[[File:Arduino_IDE.png|300px|right|thumb]]
+
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).
−
 
+
−
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 -> ATtiny44 (external 8 MHz clock)" 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).
+
  
 
==Programmierbeispiel==
 
==Programmierbeispiel==
Zeile 133: Zeile 119:
 
  */  
 
  */  
  
−
#define F_CPU 8000000 // Prozessortakt
+
#define F_CPU 20000000 // Prozessortakt
 
#include <avr/io.h> // Pinzuweisungen
 
#include <avr/io.h> // Pinzuweisungen
 
#include <util/delay.h> // Wartefunktionen
 
#include <util/delay.h> // Wartefunktionen
Zeile 160: Zeile 146:
 
</pre>  
 
</pre>  
  
−
==Ich will das RGB-Moodlight unbedingt haben. Woher bekomme ich es?==
+
==RGB-Moodlight Sketch==
  
−
Der Bausatz ist ab sofort im Warenautomat im Attraktor zum Preis von 10 Euro erhältlich.
+
Der aktuelle Code auf dem RGB-Moodlight ist mit der Arduino IDE erstellt worden und sieht folgendermaßen aus:
  
−
[[File:Bausatz_Warenautomat.jpg|250px|center|thumb]]
+
<pre>
  
−
==Bisherige Lötworkshops==
+
/*
 +
  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);
 +
 +
  }
 +
 +
}
 +
 +
</pre>
 +
 +
==RGB-Moodlight Sketch mit mehr Farben==
 +
 +
Diesen 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:
 +
 +
<pre>
 +
 +
/*
 +
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);
 +
    }
 +
  }
 +
}
 +
 +
</pre>
 +
 +
==RGB-Moodlight Gas-Sensor Sketch==
 +
 +
<pre>
 +
/*
 +
  RGB-Moodlight Sketch mit angeschlossenem Gas-Sensor
 +
  Je nach Wert leuchtet die LED in Grün, Gelb, Rot oder blitzt dreimal
 +
  Infos zum Alkohol-Sensor MQ-3: https://www.pololu.com/file/0J310/MQ3.pdf
 +
  Infos zum VOC-Sensor MQ-135: https://www.olimex.com/Products/Components/Sensors/SNS-MQ135/resources/SNS-MQ135.pdf
 +
*/
 +
 +
// 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 abhängig vom gemessenen Wert
 +
  // analogValue 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);
 +
  }
 +
 +
}
 +
</pre>
 +
 +
==Bisherige Lötworkshops==
  
 
[[Termin:Loetworkshop1|Lötworkshop1]]
 
[[Termin:Loetworkshop1|Lötworkshop1]]

Aktuelle Version vom 3. April 2017, 05:34 Uhr

RGB Moodlight

Platinen für den Lötworkshop

Fü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 Bauteile

Bauteilliste

C1       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 Platinenhalter

  • BTListe wiki.jpg
  • Eagle BRD Image.png
  • Moodlight Schematic.png
  • Loetworkshop platinenhalter.jpg

Montage der Bauelemente

Bauteile auf der Platine

Programmierung

Der 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:

  • Arduino Programmieradapter 2.jpg
  • Arduino Programmieradapter 3.jpg
  • Arduino Programmieradapter 1.jpg

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

Programmierbeispiel

Nachfolgend 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 Sketch

Der 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 Farben

Diesen 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
  Infos zum Alkohol-Sensor MQ-3: https://www.pololu.com/file/0J310/MQ3.pdf
  Infos zum VOC-Sensor MQ-135: https://www.olimex.com/Products/Components/Sensors/SNS-MQ135/resources/SNS-MQ135.pdf
*/

// 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 abhängig vom gemessenen Wert
  // analogValue 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

Lötworkshop1
Lötworkshop2
Lötworkshop3

Von „https://wiki.attraktor.org/index.php?title=RGB_Moodlight&oldid=28418“
Diese Seite wurde zuletzt am 3. April 2017 um 05:34 Uhr geändert. Diese Seite wurde bisher 30.303 mal abgerufen.