Ein Mondlicht ist eine Lampe die eigenständig in einem sanften Verlauf ihre Farben wechselt, wobei die 3 Grundfarben Rot, Grün und Blau nach dem Zufallsprinzip gemischt werden. Die Lampe startet standardmäßig mit dem Farbwechsel. Wenn man dies nicht möchte und die Lampe gerade eine der eigenen Lieblingsfarben anzeigt, braucht man nur an der Lampe zu klopfen um den Farbwechsel anzuhalten. Ein weiteres klopfen setzt den Farbwechsel fort. Das erfolgreiche Umschalten zwischen Farbwechsel und einzelner Farbe wird ebenfalls durch einen Signalton angezeigt.

Ich werde in diesem Projekt einmal den Aufbau und die Programmierung direkt mit einem Arduino UNO und im zweiten Teil den Aufbau der Schaltung mit einem ATTiny84 erklären. Den ATtiny werde ich mit dem Arduino UNO als Programmer programmieren.

Übersicht der einzelnen Schritte

verbinden aller Bauteile mit einem Arduino UNO
Sketch für den Arduino UNO
verbinden des ATtiny84 mit dem Arduino UNO
verbinden aller Bauteile mit dem ATtiny84
einrichten des Arduino UNO als Programmer
programmieren des ATtiny84 mit dem Arduino UNO als Programmer

1 . Verbinden aller Bauteile mit einem Arduino UNO

Benötigte Bauteile

1 x Arduino UNO
1 x RGB LED
1 x Tilt-Sensor (Erschütterungssensor)
1 x Piezo (Tongeber)
1 x 220 Ohm Widerstand für den Tilt Sensor
3 x Widerstände für die RGB LED

Herstellen der Verbindung der einzelnen Bauteile mit dem Arduino UNO auf einem Breadboard.

2. Sketch zum testen auf dem Arduino UNO

Um das Sketch auf den Arduino zu brennen, wählen Sie in der Arduino IDE im Menü „Werkzeuge“ folgende Werte.

Platine: Arduino UNO
Programmer: AVRISP mkII

//Ab hier anpassen
const byte redPin   = 11;    // Digitaler PWM Pin für rot in RGB LED
const byte greenPin = 10;    // Digitaler PWM Pin für grün in RGB LED
const byte bluePin  = 9;     // Digitaler PWM Pin für blau in RGB LED
const byte piezoPin = 8;     // Digitaler Pin für den Piezo Sensor
const byte tiltPin  = 7;     // Digitaler Pin für den Tilt Sensor

int fadeSpeed = 20;          // Geschwindigkeit mit der die Farbe gewechselt wird
int ledState  = LOW;         // Aktueller Status der LED (LOW = an) beim einschalten

boolean fadeLEDColor = true; // true = LED Farbwechsel, false = kein Farbwechsel
boolean DEBUG = true;        // true = Seriellen Monitor verwenden

// Ab hier nichts mehr ändern
long randomNumber;           // Variable für den Zufallswert der LED Farbe
int redVal;                  // Wert für rote LED
int greenVal;                // Wert für grüne LED
int blueVal;                 // Wert für blaue LED
int tiltState;               // HIGH bei Erschütterung
int lastTiltState;           // für entprellen des Tilt Sensors



void setup () {
  if(DEBUG) Serial.begin(9600);

  pinMode (tiltPin, INPUT);
  
  pinMode (redPin, OUTPUT);
  pinMode (greenPin, OUTPUT);
  pinMode (bluePin, OUTPUT);

  digitalWrite(redPin, ledState);   // HIGH = LED aus weil gemeinsame Kathode
  digitalWrite(greenPin, ledState);
  digitalWrite(bluePin, ledState);

  randomSeed (analogRead (0)); // Initialisieren der random() Funktion mit einem Wert des nicht angeschlossenen analogen Port A0
}



void loop () {
  redVal = fadeLED(redPin, redVal);
  blueVal = fadeLED(bluePin, blueVal);
  greenVal = fadeLED(greenPin, greenVal);
}



// Farbe und Helligkeit der LED nach dem Zufallsprinzip ändern
int fadeLED (int pin, int ledBrightness) { 
  randomNumber = random (0,256);
  
  do {
    if(ledState == LOW) { // Wenn LED eingeschaltet ist
      fadeLEDColorTilt(); // Tilt-Sensor zum beenden und fortführen des Farbwechsels abfragen

      if(fadeLEDColor == true) { // und die LED-Farbe sich ändern soll
        if (ledBrightness < randomNumber) { // Farbe und Helligkeit der LED ständig anpassen
          ledBrightness++;
        } else {
          ledBrightness--;
        }
      }  
      analogWrite (pin, ledBrightness);
      delay (fadeSpeed);
    }
  } while (ledBrightness != randomNumber);
  return ledBrightness;
}



// Tilt-Sensor zum starten oder anhalten des Farbwechsels der LED abfragen
void fadeLEDColorTilt(void) {
  tiltState = digitalRead(tiltPin);

  if (tiltState != lastTiltState) {
    if (tiltState == HIGH) {
      if (fadeLEDColor == true) {
        fadeLEDColor = false;
        if (DEBUG) Serial.println("Fading Off");
      } else {
        fadeLEDColor = true;
        if (DEBUG) Serial.println("Fading On");
      }
      playTone();
    }
    lastTiltState = tiltState;
    delay(100);
  }
}



// Ton über Piezo ausgeben
void playTone() {
  if(fadeLEDColor) {
    tone(piezoPin, 440);
    delay(100);
    tone(piezoPin, 660);
    delay(100);
  } else {
    tone(piezoPin, 220);
    delay(100);
    tone(piezoPin, 330);
    delay(100);
  }
  noTone(piezoPin);
}

3. Verbinden des ATTiny84 mit dem Arduino UNO

Entfernen Sie jetzt alle Jumper Kabel außer GND und +5V vom Arduino.
Um das Sketch später mit dem Arduino UNO als Programmer auf den ATtiny84 brennen zu können, müssen wir als erstes die Verbindung von SCK, MISO, MOSI und RESET zwischen dem ATTiny84 und dem Arduino UNO herstellen. Verbinden Sie dazu einfach die Pins wie auf der folgenden Zeichnung zu sehen mit dem Arduino. Also Pin 8 am ATTiny84 mit Pin 12 am Arduino Uno usw.

4. Verbinden aller Bauteile mit dem ATTiny84

Benötigte Bauteile

1 x Arduino UNO
1 x ATtiny84
1 x RGB LED
1 x Tilt-Sensor (Erschütterungssensor)
1 x Piezo (Tongeber)
1 x 220 Ohm Widerstand für den Tilt Sensor
3 x Widerstände für die RGB LED

5. Einrichten des Arduino UNO als Programmer

Ganz Wichtig!
Um das Sketch auf den ATtiny84 brennen zu können, müssen wir erst ein spezielles Sketch auf den Arduino UNO brennen.
Gehen Sie dazu ins Menü und wählen Sie unter „Datei->Beispiele“ zuerst das Sketch „Arduino ISP„.

Vergewissern Sie sich nochmals, dass im Menü folgende Einstellungen gewählt wurden.

Werkzeuge->Platine: Arduino UNO
Werkzeuge->Programmer: AVRISP mkII

Brennen Sie anschließen das Sketch „Arduino ISP“ auf den Arduino UNO.

6. programmieren des ATtiny84 mit dem Arduino UNO als Programmer

Sketch für den ATTiny84

Beachten Sie hier bitte dass ich eine RGB LED mit gemeinsamer Kathode (Plus) verwende, weshalb ledState = HIGH bedeutet dass die LED aus und nicht an ist. Bei einer RGB LED mit gemeinsamer Anode (GND) muss dementsprechend LOW für aus und HIGH für ein angegeben werden. Für die Einbelegung habe ich folgende Zeichnung verwendet.

//Ab hier anpassen
const byte tiltPin  =   9;   // Digitaler Pin für den Tilt Sensor
const int redPin    =   8;   // Digitaler PWM Pin für rot in RGB LED
const int greenPin  =   7;   // Digitaler PWM Pin für grün in RGB LED
const int bluePin   =   6;   // Digitaler PWM Pin für blau in RGB LED
const byte piezoPin =  10;   // Digitaler Pin für den Piezo Sensor

int fadeSpeed  = 100;        // Geschwindigkeit mit der die Farbe gewechselt wird
int ledState   = LOW;        // Aktuelle Status der LED (wechselt bei Erschütterung) HIGH = aus

boolean fadeLEDColor = true; // true = LED Farbwechsel, false = kein Farbwechsel

//Ab hier nichts mehr ändern
long randomNumber;           // Variable für den Zufallswert für LED Farbe
int redVal;                  // Wert für rote LED
int greenVal;                // Wert für grüne LED
int blueVal;                 // Wert für blaue LED
int tiltState;               // HIGH bei Erschütterung
int lastTiltState;           // für entprellen des Tilt Sensors



void setup () {
  pinMode (tiltPin, INPUT);
  
  pinMode (redPin, OUTPUT);
  pinMode (greenPin, OUTPUT);
  pinMode (bluePin, OUTPUT);
  pinMode (piezoPin, OUTPUT);

  digitalWrite(redPin, ledState);
  digitalWrite(greenPin, ledState);
  digitalWrite(bluePin, ledState);

  randomSeed (analogRead (0));  // Initialisieren der random() Funktion mit einem Wert des nicht angeschlossenen analogen Port A0
}



void loop () {  
  redVal = fadeLED(redPin, redVal);
  blueVal = fadeLED(bluePin, blueVal);
  greenVal = fadeLED(greenPin, greenVal);
}



// Farbe und Helligkeit der LED nach dem Zufallsprinzip ändern
int fadeLED (int pin, int ledBrightness) { 
  randomNumber = random (0,256);
  
  do {    
    if(ledState == LOW) { // Wenn LED eingeschaltet ist
      fadeLEDColorTilt(); // Tilt-Sensor zum beenden und fortführen des Farbwechsels abfragen

      if(fadeLEDColor == true) { // und die LEDfarbe sich ändern soll
        if (ledBrightness < randomNumber) { // Farbe und Helligkeit der LED ständig anpassen
          ledBrightness++;
        } else {
          ledBrightness--;
        }
      }  
      analogWrite (pin, ledBrightness);
      delay (fadeSpeed);
    }    
  } while (ledBrightness != randomNumber);
  return ledBrightness;
}



// Tilt-Sensor zum starten oder anhalten des Farbwechsels der LED abfragen
void fadeLEDColorTilt(void) {
  tiltState = digitalRead(tiltPin);

  if (tiltState != lastTiltState) {
    if (tiltState == HIGH) {
      if (fadeLEDColor == true) {
        fadeLEDColor = false;
      } else {
        fadeLEDColor = true;
      }
      playTone();
      delay(2000);
    }
    lastTiltState = tiltState;
  }
}



// Ton über Piezo ausgeben
void playTone() {
  if(fadeLEDColor) {
    beep(piezoPin,440,400);
    delay(1000);
    beep(piezoPin,660,400);
    delay(1000);
  } else {
    beep(piezoPin,60,400);
    delay(1000);
    beep(piezoPin,40,400);
    delay(1000);
  }
}



void beep (int freq, long ms) {
  int x;   
  long delayVal = (long)(1000000/freq);
  long loopTime = (long)((ms*1000)/(delayVal*2));
  for (x=0;x<loopTime;x++)   
  {  
    digitalWrite(piezoPin,HIGH);
    delayMicroseconds(delayVal);
    digitalWrite(piezoPin,LOW);
    delayMicroseconds(delayAmount);
  }  
}

Gehen Sie nun erneut ins Menü und setzen Sie folgende Werte.

Platine: ATtiny
Prozessor: ATtiny84
Clock: 1MHz (internal)
Programmer: Arduino AS ISP

Wenn Sie die Unterstützung für den ATTiny 84 noch nicht installiert haben, lesen Sie am besten vorher den Beitrag ATtiny Support unter Arduino 1.6 installieren oder wenn Sie eine ältere Version der Arduino IDE verwenden lesen Sie diesen Beitrag Programmieren eines Attiny mit Arduino 1.0.1

Konnten Sie die genannten Einstellungen vornehmen, klicken Sie anschließend zum brennen des ATTiny84 bei gedrückter Umschalttaste auf den „Hochladen-Button“ (Hochladen mit Programmer).

Wenn alles geklappt hat, die Verkabelung richtig vorgenommen wurde und das Mondlicht mit Strom versorgt wird, sollte die LED nun anfangen zu leuchten und die Farbe zu wechseln. Klopfen Sie auf das Glas wird der Farbwechsel gestoppt bis Sie ein weiteres mal am Glas klopfen.

Sie können die komplette Schaltung nun auf einer Lochrasterplatine unterbringen oder sich eine Platine ätzen und das ganze am besten in einem Milchglas unterbringen. Ein wirklich stimmungsvolles Licht für laue Sommerabende auf der Terrasse. :-)

Ich hoffe Ihnen hat dieses Projekt gefallen.
Bei Fragen oder Anregungen können Sie gern die Kommentarfunktion nutzen.