Feeds
Artikel
Kommentare
1

Dieser Blog soll über meine aktuellen und auch zukünftigen LED-Projekte berichten. Ich habe es mir zum Ziel gesetzt, so schnell wie möglich in unserem Haus mindestens 1000 und 1 LED zu verbauen.
In den einzelnen Artikeln werde ich nach und nach meine Ideen beschreiben und bestehende Projekte dokumentieren. Hin und wieder mal reinzuschauen lohnt sich also.

Viel Spaß beim Lesen.

Martin

Google Doodle Videos

Zu unterschiedlichen Ereignissen präsentiert Google auf der Startseite zur Suchmaschine immer wieder sogenannte Google Doodles. Dabei handelt es sich um einfache Bilder, oder aber auch um aufwendige interaktive Animationen. Diese Doodles gibt es nicht nur auf der deutschen Google Seite. Im Blog www.mamalein69.de oder im zugehörigen YouTube Kanal  wird über diese Doodles aus aller Welt berichtet. Dazu gibt es zu den Google Doodles auch jeweils ein Video, in dem das jeweilige Doodle gezeigt und beschrieben wird. So können auch die nicht deutschen Doodles bewundert werden.

An dieser Stelle möchte ich mein neustes LED Projekt vorstellen. Dabei handelt es sich um die Beleuchtung unserer Kellertreppe. Da die Treppe bisher sehr schlecht beleuchtet war, habe ich es als notwendig angesehen hier Abhilfe zu schaffen. Dabei sollte es sich aber nicht um eine einfache Beleuchtung handeln. Es sollte schon eine nette Spielerei mit einem Mikrocontroller und vielen LEDs sein. Jetzt ein paar Technische Daten und das Video zur fast fertigen Treppenbeleuchtung. Was noch fehlt sind die Gehäuse um die PIR-Sensoren, aber die sind inzwischen bestellt und werden bald nachgerüstet.

 

Technische Daten:

- 13 Stufen
- 1 ATmega328
- 1 TLC5940
- 615 SMD LEDs (kalt weiß) auf  ca. 10m LED Stripes
- 2 PIR Sensoren

Falls du die Schaltung nachbauen möchtest, dir aber Teile fehlen, frag mal bei mir an, ich habe noch einiges liegen. Platine kann ich leider nicht kostengünstig fertigen, da alles sehr aufwändig in Handarbeit geschieht.

 

Video:

UPDATE 25.02.2013: Inzwischen habe ich die Programmierung etwas verändert. Der deutlichste Unterschied zur ersten Version ist, dass jetzt alle Stufen gleichzeitig langsam dunkel werden, wenn die Treppe 20 Sekunden lang nicht benutzt wurde. Die wichtigste Verbesserung allerdings ist, dass die Treppe “merkt” wenn sie mehrmals durchlaufen wird. So kann es nicht passieren, dass sie dunkel wird, wenn eine zweite Person sie benutzt. Folgendes Video zeigt die neue Version:

Die Schaltung:

Schaltung der LED-Treppenbeleuchtung

Das Foto zur fertigen Schaltung:

Foto von der Oberseite der Platine

Bisher hatte ich meine Layouts mit dem Bügeleisen auf die Platinen übertragen. Dieses Verfahren hatte ich mir von Thomas Pfeifer seiner Homepage abgeschaut. Dabei hatte ich die besten Ergebnisse mit Laserdruckerfolien erzielt. Da sie durchsichtig sind, kann man beim Aufbügel recht gut sehen, an welchen Stellen der Toner noch nicht vollständig auf die Platine übertragen wurde. Allerdings ist dieses Verfahren recht mühselig und nicht immer mit Erfolg gekrönt. Oft wurden nicht alle Leiterbahnen komplett übertragen oder sie wurden durch zu hohen Druck mit dem Bügeleisen zu breit, so dass es zu Kurzschlüssen kam. Nacharbeiten vor und nach dem Ätzen waren die Folge.

Thomas zeigt auf seiner Homepage auch den Einsatz eines umgebauten Laminiergerätes, für das er eine Temparaturregelung entwickelt hat. Sein Videotutorial auf You Tube hat mich so sehr beeindruckt, dass ich mich dazu entschlossen hatte, ebenfalls so ein Gerät zu bauen. Bei Ebay habe ich sogar das gleiche Laminiergerät (Typ GENIE L-405 HC), welches Thomas verwendet, ersteigern können. Folgende Bilder zeigen meine Variante des Platinenlaminators.

Vorderseite

Vom Originalgerät blieb nur die Walzeneinheit mit der Heizung, der Schalter und die Unterschale vom Gehäuse übrig. Auf beiden Seiten habe ich jeweils ein Teil der Gehäuseschale entfernt, damit genug Platz zum einführen der Platinen vorhanden ist.

Rückseite

 

Heizregelung

 

Temperaturmessdiode

Zur Temperatormessung benutze ich, anders als Thomas, eine 1N4007 Diode, da ich gerade keine 1N4148 griffbereit hatte. Damit das Glasgehäuse der Diode nicht zerspringt, habe ich die Diode in ein Stück Schrumpfschlauch verpackt. Den hierdurch erforderlichen Temperaturabgleich habe ich wie folgt durchgeführt. Da ich über keinen Lötkolben verfügen, bei dem die Temperatur eingestellt werden kann, musste ich mir anders behelfen. Also suchte ich nach einem Thermometer mit einem möglichst hohen Maximalwert. Das einzige was ich bei uns im Haushalt fand, war lediglich ein digitales Fieberthermometer :-( . Das ein Fieberthermometer nicht Temperatoren über 100°C misst, war mir klar, aber dass schon nach 42°C Schluss ist, habe ich auch nicht erwartet. Muss wohl daran liegen, das Fieber jenseits der 42°C kein normaler Mensch überlebt. Aber egal, da ich nichts anderes hatte, musste es also damit gehen. Als Startwert nahm ich die Temperatur vom Aluprofil des Laminators im kalten Zustand (21,1°C, Raumtemperatur). Über die serielle Schnittstelle der Heizregelung entnahm ich hierfür den ADC-Wert von 279. Jetzt fehlte also nur noch ein höherer Messwert. Also ließ ich die Laminatorheizung sich aufheizen(was auch sonst? ;-)). Bei der Temperatur von 37°C ergab sich der ADC-Wert von 269. Beide Messwerte lagen zwar dicht bei einander, aber es reichte trotzdem für den Temperaturabgleich aus. Jetzt mussten nur noch die gemessenen Werte in das Programm von Thomas für den Mikroprozesser der Heizregelung in die Funktion convert2degree() eingetragen werden:

int convert2degree(int value) {
  //static const float c1=19.5;
  //static const float v1=275;  //ADC-Wert=264 @ 20°C
  //static const float c2=202;
  //static const float v2=154;  //ADC-Wert=165 @ 202°C

  static const float c1=21.1; // 21,1°C Raumtemperatur, Kaltzustand
  static const float v1=279; // ADC-Wert
  
  static const float c2=37; // 37°C Messwert
  static const float v2=269; // ADC-Wert
  float m=((c1-c2)/(v1-v2));
  return((int)((m*(float)value)+(-m*v1)+c1));
  //return((int)((-m*v1)+c1));
}

Jetzt noch den gewünschten Sollwert von ca. 180°C oben in den Definitionen eintragen:

#define F_CPU 8000000UL  // 8 MHz
#define SOLLWERT 180 //<= gibt die Solltemperatur (ADC-Wert) an. Ca. 175-180 °C
#define BAUD_RATE 9600

ACHTUNG: Bei dem eingetragen Wert von 180 handelt es sich um den ermittelten ADC-Wert, den man aus den Ausgaben über die serielle Schnittstelle der Heizungsregelung ermitteln kann. Nur zufälligerweise ergab sich hier ein Wert von 180 für die gewünschte Temperatur von 180°C.

Das Ergebnis des ersten Testlaufs kann sich auf anhieb sehen lassen, wie das Foto eines Probetransfers beweist. Bei den hellen Ablagerungen handelt es sich um Rückstände vom Reicheltkatalogpapier, welches ich nicht komplett abgelöst hatte. Für einen Probetransfer unwichtig.

Testergebnis

Im Arduino-Forum fand ich diesen Link auf eine druckbare Arduino Language Reference.

Update 02/2013: Leider funktioniert der Link nicht mehr. Folgender Link ist aber auch interessant:

http://www.ele.uri.edu/courses/ele205/Arduino%20-%20Reference.pdf

 

 

ATmega Retter

Ab und zu kommt es schon mal vor, dass man versehendlich ein fuse-Bit falsch setzt und schon hat man sich selber ausgesperrt. Der ATmega reagiert nicht mehr, egal was man auch versucht. Aber verloren ist er damit noch lange nicht. Mit einer einfachen Schaltung ist es möglich ihn wieder “ins Leben” zurück zu holen. In diesem Miniprojekt möchte ich diese Schaltung kurz vorstellen.    

    

Anwendung   

Die Anwendung der Schaltung ist genau so einfach, wie die Schaltung selbst:

Den “verfusten” ATmega in die dazu vorgesehene IC-Fassung richtigherum einstecken.  Es können alles zum ATmega8 pinkompatibele ATmega eingesetzt werden.  

Die ISP-Schnittstelle mit einem Programmer verbinden. Kann der verwendete Programmer die Schaltung selbst mit Spannung (5V) versorgen, ist es nicht nötig eine externe Spannungsversorgung (9V-12V) an den Versorgungspins der Schaltung anzuschließen. Andernfalls muss noch eine externe Spannungsquelle von 9V bis maximal 12V an den Versorgungspins der Schaltung angelegt werden. 

Danach kann mit z.B. AVRdude die fuse-Bit Einstellung durchgeführt werden. 

Nebeneffekt: Als nützlichen Nebeneffekt anzusehen ist, dass mit Hilfe der Schaltung in Verbindung mit einem Programmer der eingesetzte ATmega komplett programmiert werden kann. Das ist nützlich, wenn die Zielschaltung, in die der ATmega eingesetzt werden soll, keine eigene ISP-Schnittstelle besitzt. 

Üblicherweise wird der Mikrocontroller des Arduinos über die USB, bei älteren Versionen, über die serielle Schnittstelle beschrieben. Die Programmiersoftware (IDE) unterstützt dieses Vorgehen automatisch. Es genügt, wenn man unter Board aus dem Tools-Menü sein Arduino-Board einmal auswählt. Zukünftige Uploads werden dann über die konfigurierte Schnittstelle auf den Mikrocontroller des Arduinos übertragen. Dies ist ein recht konfortabler Weg, solange man mit seinen Schaltungen sich auf das Arduino-Board beschränkt. Benutzt man aber den Arduino nur für die Schaltungsentwicklung mit dem Ziel daraus eine eigene Platine mit eigenem Mikrocontroller herzustellen, so wäre es schon schön, wenn man den Mikrocontroller aus der resultierenden Schaltung nicht immer im Arduino-Board programmieren müsste, sonder über die ISP-Schnittstelle in der eigenen Schaltung.  Um dieses Ziel zu erreichen, genügt eine kleine Erweiterung in der Datei boards.txt aus der Arduino IDE. Sie ist in der Version 0018 im Programmordner unter Hardware->Arduino zu finden. Dort muss man die Einträge seines Boards wie folgt erweitern. Das hier gezeigte Beispiel bezieht sich auf das Duemilanove-Board:

atmega328.upload.using=[Objektbezeichnung des externen Writers aus der Datei programmers.txt]

Für ein anderes Board muss die Ergänzung an der entsprechenden Stelle in der boards.txt Datei erfolgen. Der Eintrag darf dann allerdings nicht mit “atmega328″ beginnen, sonder mit dem dort verwendeten Objektnamen (z.B. diecimila für das diecimila-Board).

Am Ende des neuen Eintrags folgt die Objektbezeichnung des verwendeten externen Programmers (Writer). Diesen Bezeichner findet man in der programmers.txt Datei welche neben der boards.txt Datei im gleichen Ordner liegt. In der programmers.txt Datei sind alle externe Writer aufgeführt, die vom avrdude Programm (wird von der Arduino IDE als Programmiersoftware benutzt) unterstützt werden.

Für das Duemilanove-Board und dem USBtinyISP Programmer, sähe die Erweiterung dann so aus (rote Zeile):

##############################################################
atmega328.name=Arduino Duemilanove or Nano w/ ATmega328
atmega328.upload.protocol=stk500
atmega328.upload.maximum_size=30720
atmega328.upload.speed=57600
atmega328.upload.using=usbtinyisp
atmega328.bootloader.low_fuses=0xFF
atmega328.bootloader.high_fuses=0xDA
atmega328.bootloader.extended_fuses=0x05
atmega328.bootloader.path=atmega
atmega328.bootloader.file=ATmegaBOOT_168_atmega328.hex
atmega328.bootloader.unlock_bits=0x3F
atmega328.bootloader.lock_bits=0x0F
atmega328.build.mcu=atmega328p
atmega328.build.f_cpu=16000000L
atmega328.build.core=arduino

Ganz wichtig hierbei ist, dass man nicht den eigentlichen Namen des Programmers einfügt, sonder dessen Objektbezeichner, wie er immer zu Beginn der Zeilen in der programmers.txt zu finden ist. Also nicht “USBtinyISP” sondern “usbtinyisp” in meinem Beispiel. Sollte der eigene externe Writer nicht in der Datei programmers.txt enthalten sein, so wäre zu prüfen, ob er nicht zu einem, der dort aufgeführten Geräte, kompatibel ist.

 Dieser Artikel berichtet über mein Bluetooth-Modul, das ich für die serielle Übertragung (RS232) von Daten zwischen PC und Mikrokontrollergeräten entwickelt habe. Herzstück des Moduls ist ein BTM-222 der Firma Rayson (http://www.rayson.com/btm220.html). Hierbei handelt es sich um ein sehr kompaktes und recht günstiges (ca. 13€) Bluetooth Class 1 Modul.            

Im Internet gibt es schon einige Bauanleitungen für das BTM-222, nur werden dort immer nur doppelseitige Platinen verwendet. Zur einfachen Herstellung habe ich mir daher ein einseitiges Layout erstellt (Die Eagle-Dateien liefer ich gern auf Anfrage).                        

 

Einseitges Layout für das Bluetooth-Modul

                

Bauteilbestückung

Platine direkt nach dem Ätzen

               

Bestückungsseite des Moduls. Das BTM-222 befindet sich auf der Lötseite der Platine

Die LEDs:  Grüne LED: Power-LED; Gelbe LED: Verbindung (blinken – keine Verbindung); rote LED: Datenübermittlung       

Die Anschlüsse: Über die seitlich herausgeführte Stiftleiste wird das Modul mit Spannung versorgt (+5V, GND). Außerdem liegen hier Rx und Tx der seriellen Schnittstelle an.  Nicht vergessen, Rx muss auf der Gegenstelle auf Tx liegen und Tx dort auf Rx (also gekreuzt)!                  

 ACHTUNG: Das Modul darf niemals direkt mit der RS232 Schnittstelle des PCs verbunden werden! Das Modul erwartet einen 5V TTL Pegel. Gewöhnliche RS232 Schnittstellen liefern einen +12V/-12V Pegel. Dieser würde das Modul zerstören! Soll das Modul am PC betrieben werden, z.B. um die  Grundkonfiguration des BTM-222 durchzuführen, so muss dies mit Hilfe eines s.g. Level-Shifter oder Pegelwandler erfolgen, oder über einen USB-RS232 Adapter. Ich persönlich ziehe den Adapter vor, da nicht jeder meiner PCs über eine serielle Schnittstelle verfügt. Die Bauanleitung zum USB-RS232 Adapter werde ich bald in einem neuen Artikel vorstellen.                      

           

Test und BTM-222 Konfiguration:          

Das BTM-222, wie es in seiner Grundeinstellung ausgeliefert wird, kann man nur bedingt  für seine Anforderungen verwenden. In seiner Grundeinstellung befindet es sich z.B. im Slave-Modus, es kann also selber keine anderen Bluetooth-Geräte finden. Außerdem ist als PIN-Code die “1234″ eingestellt. Weiter Parameter, wie z.B. die Baud Rate (von 4800bps bis zu 460.8 kbps) und dem Device Namen können ebenfalls mit AT-Befehlen eingestellt werden. Fast alle AT-Befehle können dem Datenblatt entnommen werden. Wenn ich hier “fast alle AT-Befehle” schreibe, dann bedeutet das, dass es noch mehr davon gibt, die im Datenblatt wohl vergessen wurden. Einer davon ist der Befehl “ATI1″. Mit diesem Befehl wird die aktuelle Konfigration abgerufen.               

Um die Konfiguration ändern zu können, muss Das Modul mit dem PC seriell verbunden werden (Aber niemals direkt! Siehe oben). Über ein Terminal-Programm wie z.B. das “HyperTerminal” von Windows, kann es dann über die AT-Befehle aus dem  Datenblatt des BTM-222  für den eingenen Einsatz konfiguriert werden.                 

 Meine Testkonfiguration lautet so:               

ATC=0, NONE FLOW CONTROL
ATD=0000-00-000000, NEVER SET BLUETOOTH ADDRESS
ATE=1, ECHO CHARACTERS
ATH=1, DISCOVERABLE
ATK=0, ONE STOP BIT
ATL=1, BAUD RATE is 9600
ATM=0, NONE PARITY_BIT
ATN=BTM-222, LOCAL NAME
ATO=0, ENABLE  AUTO CONNECTING
ATP=1234, PIN CODE
ATQ=0, SEND RESULT CODE
ATR=1, SLAVE ROLE
ATS=1, ENABLE AUTO-POWERDOWN OF RS232 DRIVER
ATX=1, ALWAYS CHECK ‘+++’               

Diese Konfiguration benutzte ich beim Versuch das erste Mal Daten zwischen dem PC und dem Bluetooth Modul auszutauschen. Der PC mit seinem Bluetooth-Dongel spielt dabei den Master, der die Verbindung aufbaut und das Bluetooth Modul den Slave (s.  Parameter ATR).     

Nun noch ein paar Worte zu meinem Testaufbau, über den ich die Konfiguration des BTM-222 durchgeführt und erste Daten zwischen PC und Bluetooth-Modul übertragen hatte:              

1) Anschluss des Bluetooth Moduls (als Slave) mit dem USB-RS232 Adapter an den USB Port des PCs. Dabei wird ein COM-Port (bei mir COM7) mit der Treiberinstallation des USB-RS232 Adapters  eingerichtet.              

2) Im HyperTerminal jetzt eine Verbindung auf COM7 (oder welcher Port bei euch eingerichtet wurde) mit der richtigen Baud-Rate (bei mir 9600. In der Grundeinstellung ist es die 19200, die anderen Werte so lassen) aufbauen.                

3) Jetzt kann mit dem Befehl “AT” geprüft werden ob alles ok ist. Als Antwort soll nämlich jetzt ein “OK” vom Bluetooth-Modul zurück kommen. Weiter Konfigurationsparameter können jetzt eingestellt werden.               

4) Über den PC  (Rechtsklick auf das Bluetooth-Ikon rechts unten) das BTM-222 suchen. Dabei den eigenen Hauptschlüssel “1234″ verwenden. Jetzt wird neue Hardware gefunden und zwei weiter COM-Ports eingerichtet. Ein eingehenden und ein ausgehenden Port (Bei mir COM12 und COM13).               

5) Weiteres HyperTerminal öffnen und auf den neuen ausgehenden Port (bei mirCOM13) verbinden. Jetzt sollte im ersten HyperTerminal “CONNECT” erscheinen und die gelbe LED auf dem Bluetooth-Modul auf Dauerleuchten umstellen. Jetzt steht die Verbindung! Tippt man nun einen Text in eins der HyperTerminals, so wird dieser im anderem HyperTerminal ausgegeben! Dabei blinkt jedes Mal die rote Daten-LED.           

Letztes Update: 23.09.2010 (Links eingefügt)

Hier möchte ich mein erstes LED-Projekt beschreiben. Dabei handelt es sich um die Beleuchtung einer Schranknische. Der Schrank ist eigentlich eine Vorwandinstallation aus, mit Rauputz verkleideten Fermacellplatten. Im Schrank befindet sich eine horizontal ausgerichtete Nische, die später als Galerie dienen soll. Die Galerie wird auf zwei Arten beleuchtet. Zum einem verwende ich drei per Funk dimmbare Halogenstrahler und zum anderen vier RGB LED-Strahler.

 

Die beiden ersten Bilder zeigen die Galerie mit den drei Halogenstrahlern.

Zwischen den Halogenstrahlern befinden sich die Einfassungen für vier RGB LED-Strahler.

Jeder der RGB LED-Strahler wird aus 12 rote, 12 grüne und 12 blaue 5mm Superflux LEDs bestehen. Die Bilder zeigen den ersten von mir angefertigten Strahler (halb bestückt).  

Da ich inzwischen die Lust daran verloren hatte, die LEDs auf Lochraster aufzulöten und zu verdrahten, habe ich mich kurzerhand dazu entschlossen, die restlichen Strahler auf selbst erstellten Platinen herzustellen.  Dazu verwendete ich die sog. Direkt-Toner-Methode. Wie dies genau funktioniert, beschreibt Thomas Pfeifer auf seiner Homepage sehr genau, danke Thomas!

 

 

 

update 04.05.2010: Die RGB LED-Strahler werden über einen Mikrokontroller (atmel ATmega328) vom zentralen PC aus per Bluetooth-Modul gesteuert. Dazu aber später mehr, wenn ich soweit bin.

 

Der Versuchsaufbau

Das Video zeigt den Versuchsaufbar mit 4 RGB LEDs jeweils in einem Tischtennisball. Die LEDs werden später durch die RGB Strahler ersetzt. Die Schaltung besteht aus einem Arduino, einem TLC5941 und vier 5mm RGB LEDs. Den Versuchsaufbau benötige ich zur Entwicklung der Software.

Über die Serielleschnittstelle werden die Farbeinstellungen vom PC aus gesteuert. Dazu habe ich mir ein kleines C# Testprogramm geschrieben (Quelltext für PC  folgt…).

Arduino-Code:

/*
Galeriebeleuchtung V1.0

 Definition of InputData: 126         LampNo  red         green           blue        126
 Description              Start Byte  Lamp    red Value   green Value     blue value  Stop Byte

 lampNo = 1= lamp1; 2= lamp2; 4=lamp3; 8=lamp4; 15= All lamps
*/
#include "Tlc5940.h"

// Global Variables
struct led{
  byte red;
  byte green;
  byte blue;
};

// Init lamps
led lampSet[] = {{0,0,0},{0,0,0},{0,0,0},{0,0,0}};

byte cmdMsg[6];
byte debug[4];

void setup()
{
   Tlc.init();
  Serial.begin(9600);    // Serielle Verbindung, 9600 baud

} 

void loop()
{
  // Check start byte
  byte cmd = getNextByte();
  if (cmd == 126) // '~' // Start Byte
  {
    byte byteIn = 0;
    byte i = 0;
    while (byteIn != 126) // wait for end byte
    {
      byteIn = getNextByte();

      debug[i] = byteIn;

      if (byteIn != 126)
      {
        cmdMsg[i] = byteIn;
        i++;
      }
    }
      Tlc.clear();
    setLamp(cmdMsg[0], cmdMsg[1], cmdMsg[2], cmdMsg[3]);
       Tlc.update(); 

    // Debugausgabe
    Serial.print("ACK- S: ");
    Serial.print(int(cmd));
    Serial.print(" Data:");
    for (int i=0; i<4; i++)
    {
      Serial.print(int(debug[i]));
      Serial.print(",");
    }
    Serial.print(" E: ");
    Serial.print(int(byteIn));
    Serial.print(" ");
    Serial.println(millis());
  }
  delay(5);

  cmd = 0; // RESET Für Debugzwecke
  for (int i=0; i<6; i++)   {     cmdMsg[i] = 0;   } } // Spinning Serial.read byte getNextByte(){   while (1){      if (Serial.available() > 0)
      return Serial.read();
  }
}

void setLamp(byte lampNo, byte red, byte green, byte blue)
{
    // Lampe 1
    if (lampNo & 1)
    {
      lampSet[0].red = red;
      lampSet[0].green = green;
      lampSet[0].blue = blue;
    }

    // Lampe2
    if (lampNo & 2)
    {
      lampSet[1].red = red;
      lampSet[1].green = green;
      lampSet[1].blue = blue;
    }

    // Lampe3
    if (lampNo & 4)
    {
      lampSet[2].red = red;
      lampSet[2].green = green;
      lampSet[2].blue = blue;
    }

    // Lampe4
    if (lampNo &8)
    {
      lampSet[3].red = red;
      lampSet[3].green = green;
      lampSet[3].blue = blue;
    }

    // All lamps
    if (lampNo == 15)
    {
      lampSet[0].red = red;
      lampSet[0].green = green;
      lampSet[0].blue = blue;

     lampSet[1].red = red;
      lampSet[1].green = green;
      lampSet[1].blue = blue;

      lampSet[2].red = red;
      lampSet[2].green = green;
      lampSet[2].blue = blue;

     lampSet[3].red = red;
      lampSet[3].green = green;
      lampSet[3].blue = blue;
    }

    // Set lamps
  Tlc.set(0, lampSet[0].red*16);
  Tlc.set(1, lampSet[0].green*16);
  Tlc.set(2, lampSet[0].blue*16);

  Tlc.set(3, lampSet[1].red*16);
  Tlc.set(4, lampSet[1].green*16);
  Tlc.set(5, lampSet[1].blue*16);

  Tlc.set(6, lampSet[2].red*16);
  Tlc.set(7, lampSet[2].green*16);
  Tlc.set(8, lampSet[2].blue*16);

  Tlc.set(9, lampSet[3].red*16);
  Tlc.set(10, lampSet[3].green*16);
  Tlc.set(11, lampSet[3].blue*16);
}

 

  

Die Schaltung:

Update 09.05.2010:Inzwischen habe ich die endgültige Schaltung entworfen und auch schon aufgebaut. Wie oben schon erwähnt, erflogt der Datenaustausch zwischen PC und dem ATmega per Bluetooth-Modul.  Dafür habe ich die serielle Schnittstelle auf eine 4-polige  Buchsenleiste gelegt, in die das Bluetooth-Modul gesteckt wird.

Den TLC5941 aus dem Testaufbau habe ich gegen einen TLC5940 ersetzt, da dieser pro Kanal 120 mA treiben kann, statt nur 80 mA. Damit gehe ich nicht an die Leistungsgrenzen des TLCs.

An jeden der 4 Ports wird jeweils ein RGB LED-Strahler angeschlossen. Die gesamte Schaltung wird von einem 12V Schaltnetzteil (PC Netzteil) mit Spannung versorgt.

Die Programmierung des ATmega habe ich durchgeführt, als er noch im Arduino steckte. Sie kann aber auch über die ISP Schnittstelle erfolgen, sofern man über einen entsprechenden Programmer verfügt. Für spätere Softwareupdates ist dies die komfortablere Lösung, weil man den ATmega nicht mehr aus der Schaltung ausbauen muss.

Mehr muss man eigentlich nicht zu der Schaltung sagen.

Schaltung des RGB LED-Strahler:

Jeder der4 RGB LED-Strahler besteht aus 12 rote, 12 grüne und 12 blaue Superflux LEDs. Dazu kommt noch pro Reihenschaltung ein Vorwiderstand für die Stromregelung an einer Eingangsspannung von 12V.  

 

Testlauf:

Der erste Testlauf in unserer Wohnzimmervitrine.

Aquariumregelung

UPDATE (08/2011): Ich bin gerade dabei diese Idee in die Realität umzusetzen. Wenn ich damit fertig bin, werde ich einen entsprechenden Artikel verfassen!

 

Meine Idee, wie ich den Arduino im Betrieb meines Aquariums einsetzen könnte, sieht wie folgt aus. Als erstes müsste der Arduino den Wasserstand in meinem Unterschankfilter kontrollieren. Dies ist absolut notwendig, damit die Filterpumpe nicht trocken läuft, wenn zu wenig Wasser in der Pumpenkammer enthalten ist. Zurzeit verwende ich einen einfachen Schwimmschalter. Dieser arbeitet allerdings nicht zuverlässig genug, so dass ich hier etwas präziseres benötige. Ich denke, dass wäre schon mal eine gute Aufgabe für den Arduino.
Als weitere Aufgabe wäre eine helligkeits- und zeitgesteuerte Beleuchtung ganz nett. Da mein Aquarium als Raumteiler mitten im Wohnzimmer steht, bekommt es eigentlich an hellen Tagen schon genug Licht, so dass es nicht notwendig ist, dass zusätzlich noch die Beleuchtung eingeschaltet wird. Da ich dies zurzeit noch mit einer einfachen Zeitschaltuhr erledige, wird die Beleuchtung eben immer zu festen Zeiten ein- bzw. ausgeschaltet. Zukünftig könnte der Arduino prüfen ob die Umgebungshelligkeit ausreichend ist, wenn der geplante Einschaltzeitpunkt erreicht ist, und dann entscheiden, ob die Beleuchtung schon eingeschaltet werden muss, oder erst später.

Ältere Artikel »