i(r)Panel - Lasergravur

Hi,

Seit dem Sommer arbeite ich nun schon am i(r)Panel und habe es jetzt fast fertig. Die Idee dazu kam mir weil Pesi den Artikel über den IR-Reflexsensor geschrieben hat und von da an dachte ich mir dass man das Prinzip für die Ansteuerung einer Lampe nutzen kann. Quasi mit der Hand eine Geste vor der Lampe machen und diese wird dann heller bzw. dunkler. So ähnlich wie die Steuerung eines iPhone - daher also iPanel - nur das man nicht unbedingt draufgrapschen muss wg. Infrarotreflexsensor - daher i(r) Panel.

Angefangen hat es wie folgt:

Für den Außenrahmen habe ich 60mm breites und 4mm starkes eloxiertes Aluminium aus dem Bauhaus geholt und musste lange suchen bis ich kratzfreie 2m davon zusammen hatte. Zum Sägen habe ich dann eine Lade konstruiert die im wesentlichen aus einer Zaunlatte mit zwei Buchenholzleisten besteht, die verhindern dass beim Sägen etwas verrutscht. Ich habe das Werkstück auch noch zusätzlich angeschraubt so das ein Verrutschen in Längsrichtung verhindert wird. Die 45 Grad Winkel hatte ich vorher mit seehr viel Sorgfalt in die Buchenleisten geschnitten. Der Ganze Aufwand hat sich dann auch wirklich gelohnt:

Dann habe ich eine große glatte Holzplatte aus dem Baumarkt verwendet um die 4 Rahmenseiten gegen Verrutschen zu sicher:

Der Rahmen hat eine Kantenlänge von 52x52 cm. Der innere Rahmen wurde aus 50 cm langen 1x1cm starken Aluprofil gefertigt und ganz in der Mitte kommt nun eine 48x48cm 8mm Endlighten MR Plexiglasplatte zum liegen:

Die LEDs sind High CRI COB Module aus dem "Blauen Shop" mit 2700K und 92Ra. Davon sind je 4 Stück in Reihe geschalten rechts und links am inneren Rahmen befestigt. Alle Seiten des Englighten sind mit Reflexionsfolie gemäß meines Artikels Englighten++ beklebt, nur da wo die LEDs hineinleuchten sind ein paar cm freigelassen.

Ihr könnt schon die Bohrlöcher sehen in dene die Blechschrauben versenkt werden, die den inneren mit dem äußeren Rahmen verbinden. Die Blechschrauben habe ich dazu an den Spitzen abgeschnitten, da sie nur ca. 3.5mm in den 4mm starken Flachprofile des Außenrahmens versenkt werden können. Die Löcher im Flachprofil haben ich mit dem Dremel + Präzisionsbohrer gemacht. Die 3,5 mm haben ich mit schwarzem Edding auf den Bohrer markiert, so dass ich nicht zu tief bohre.

Damit das Endlighten nicht nach hinten herausfallen kann habe ich quer über die Ecken Alu-Flachprofil verschraubt. Unter den Eckstücken sitzt Moosgummi, der die 2mm die dem Endlighten zum Abschluss mit dem 1cm 4-Kant Alurahmen fehlen auffüllt.

Die Rückwand besteht aus einer Sterlingsilber Plexiglasplatte aus dem www.plexiglas-shop.de, die Halterungen für das Panel könnt Ihr auch schon sehen mit den Aussparungen für Platinenhalterungen und Anschlüssen.

Wer genau hingesehen hat wird auch bemerkt haben, dass das Endlighten graviert ist. Dies wurde mit einem Laser gemacht. Als Grundlage dienten Vektorgrafiken von www.shutterstock.de die ich zusammen mit meiner Tochter - für die das iPanel gemacht wird - ausgesucht und mit Hilfe von Inkskape arrangiert habe. Die Verwendung von Vektoren erlaubt es die Auflösungsfähigkeit des Lasers von 1/10mm voll auszunutzen. Hier ein paar Details zum Ergebnis:

So, ich hoffe hier seid neugierig geworden wie es weitergeht denn es gibt noch sehr viel zu berichten und das werde ich dann die nächsten Tage auch noch machen, aber fürs erste habe ich jetzt keine Zeit mehr.

lg Sol.

Hi,
nachdem ich gestern etwas frustriert war nachdem mein ganzer Text im Lokus verschwand werde ich es nocheinmal versuchen.
Also es geht jetzt um den IR Sensor. Ich verwende dafür alle 8 ADC Eingänge eine Atmega 8535. Diese werden per Transimpedanzverstärker mit dem Signal von 8 Fotodioden - BP 104 FS - versorgt. Das IR signal wird von 8 IR Emittern (SFH 4655) geliefert von denen je 4 über eine PIN des Atmega geschaltet werden können.

Als Basis für den Transimpedanzverstärker dient der LM 358 der 2 OP-AMP enthält, hiervon werden daher 4 Stück benötigt. Die Beschaltung erfolgt mit jeweils 1M Ohm und 0.5pf. Die 8 Messpunkte werden auf einer Platine über 16cm verteilt:

so das Ort und Bewegungen erfasst werden können.

Die Platinen mit dem Sensor wird dann mit einer Separaten Platine mit dem uC und der Leistungselektronik verbunden:


Über 2 kleine Aluwinkel und Schrauben wird die Sensorplatinen dann im inneren Rahmen befestigt und ist verdeckt, durch leichtes Schrägstellen können nun Objekte vor der Endlighten Scheibe erfasst werden:

Im inneren Rahmen benutze ich schwarzes Klebeband um damit die Reflexionen vom Plexi und Alurahmen zu verhindern. Und so sieht es dann aus, wenn beide Platinen verbaut im im inneren Rahmen versteckt sind:

Damit Ihr Euch einen Gesamteindruck vom inneren Rahmen verschaffen könnt hier nochmal die Gesamtansicht:

Der Wertebereich pro IR Messpunkt erstreckt sich von 0-746 wobei nach dem Einbau ein Grundlevel von 200~280 Durch Reflexionen aus dem Rahmen und der Scheibe anliegen. Zur uC Platinen zum Programm und zum Gesamtaufbau werde ich dann demnächst weiter berichten, wenn ich mich von meiner Magendarmgrippe wieder besser erholt habe.
lg Sol.

So, nun geht es wieder weiter...

Als Mikrocontroller verwende ich eine Atmega 8535 weil es dafür so einen netten Sockel gab, da hab ich mir das Anlöten der PINs gespart. Links auf dem Bild seht Ihr einen LCD Anschluss zum debuggen und rechts den ISP Anschluss. Dann kommt der DC Anschluss für 48 Volt und darüber ein RECOM Spannugswandler der daraus die 5V für den uC macht. Dann folgen 2 ZXLD1366 basierte KSQ diese sind auf eigenen Platinen aufgebaut mit mit der uC Platine verschraubt. GND, 48V und PWM werden über gewinkelte Stifte von der uC Platine an die KSQs geleitet.

Der ISP Programmierer und das LCD lassen sich nun so anschließen, das das System in seinem Testbed programmiert werden kann:

Dann habe ich das ganze zum Test auf einer Grundplatte befestigt, ganz so wie es später an der Wand aufgehägt wird. Hier seht Ihr die 48V Zuleitung unten am Rahmen:

Nun ist der Aufbau zum Testen/Programmieren Abgeschlossen und ich kann alles unter realistischen bedingungen Testen.

Damit später kein Staub eindringt und der Aufbau von der Seite nicht einsehbar ist fertige ich noch 3 Steitenblenden aus Holzleisten und diffuser Folie:

Und so sieht der fertige Testaufbau aus:

Nochmal von unten

und von Oben:

Das Programm werden ich dann beim nächsten mal beschreiben. Ich kann schon mal sagen, dass es sehr gut funktioniert obwohl es einige Schwierigkeiten und unvorhergesehene Problem gab.

lg Sol.

Hi,

Das Program ist nun fertig und hat sich nun seit ca. 1 Woche gut bewährt:

iPanel.zip

Die Zip Datei enthält den gesamten code plus die HEX Dateien. Im folgenden werde ich mal ein wenig das Programm dokumentieren und ein paar Besonderheiten herausstellen.

Als erstes beginne ich mal mit ein paar Spezialitäten bezüglich des Verhaltens der IR-LEDs. Diese werden wie schon bei Pesis Reflexsensor aus/an geschaltet um eine Differenzmessung zur Umgebung zu ermöglichen. Die IR LEDs werden über den PORTB an PIN0 und PIN1 geschaltet wobei 8mA fliessen - habe das an 0.1Ohm Widerständen jeweils in Reihe mit den 2x4 IR LEDs gemessen.

#define IR_LEDS_AN PORTB |= (1 << PB0) | (1 << PB1) ; _delay_us( 48 * 2 ) 
#define IR_LEDS_AUS PORTB &= ~((1 << PB0) | (1 << PB1)); _delay_us( 14 * 2 )

Es fällt auf dass nach dem Schalten jeweils unterschiedlich lange gewartet wird und das liegt daran, dass die LEDs erst nach 8-14 Mikrosekunden wirklich aus sind, fängt man füher mit der ADC Messung an, so misst man noch etwas Restlicht. Beim Einschalten dauert es auch 8-14 us bis die LEDs wirklich sicher an sind aber dann steigt die IR Intensität erstmal 20-30% über die normale Leuchtstärke der LEDs hinaus bis nach 30-48 us wieder normale Intensität herrscht. Dann habe ich die Werte nochmal verdoppelt, falls sich die LEDs noch irgendwie ändern z.Bsp. im Sommer bei 34 Grad oder so...

Gleich in der main() Funktion werden die wichtigsten Wertespeicher initialisiert.

uint16_t on [8] = {0,0,0,0,0,0,0,0}; // enthält die Werte aller 8 ADC mit IR Licht 
  uint16_t of [8] = {0,0,0,0,0,0,0,0}; // enthält die Wert aller 8 ADC ohne IR Licht 
  uint16_t ref[8] = {0,0,0,0,0,0,0,0}; // enthält die Differenz on - of 
  uint16_t dp [8] = {0,0,0,0,0,0,0,0};

Die Differenz (on - of) wird mit folgender Funktion berechnet

void abs_diff( uint16_t* dst, uint16_t* of, uint16_t* on ) 
{ 
  for( uint8_t i = 0; i < 8; ++i ) 
  { 
    if( on[i] > of[i] ) 
      dst[i] = on[i] - of[i]; 
    else 
      dst[i] = 0; 
  } 
}

Es wird hierbei angenommen, dass 'onÄ größer als 'of' sein MUSS , anderfalls wird das Resultat zu Null gesetzt.

Auf die Werte in 'ref' wird später immer wieder Bezug genommen, um festzustellen ob sich ein Objekt vor der Lampe bewegt. Daher wird 'ref' beim Starten der Lampe einmal berechnet:

// Errechne sensor reference ( Lampe aus: min pwm ) 
  ReadSensor( of, 2048 ); IR_LEDS_AN; 
  ReadSensor( on, 2048 ); IR_LEDS_AUS; 


  abs_diff( ref , of, on ); 
  OCR1A = 1023; 
  _delay_us( 128 ); 


  // Errechne sensor reference ( Lampe an: max pwm ) 
  IR_LEDS_AN; ReadSensor( on, 2048 ); 
  IR_LEDS_AUS; ReadSensor( of, 2048 ); 
  abs_diff( on, of, on ); 
  abs_diff( dp, ref, on );

Mit der Funktione ReadSensor ( on, 2048 ), werden beim Start alle 8 ADCs 2048 mal ausgelesen, addiert und gemittelt, dann wird der Wert für IR LED im Eingeschalteten Zustand ermittelt und die Differenz in 'ref' abgelegt. So und und nun kommt das SELTSAME die Lampe wird eingeschaltet mit 100% Licht an und das ganze wird nocheinmal gemacht - diesmal bei voller Leuchtstärke der normalen LEDs. Dann wird die Differenz temporär in 'on' zwischengespeichert - quasi 'ref' nocheinmal jedoch mit voller Beleuchtung. Jetzt wird in 'dp' - (d)rift p(wm) - die Differenz der beiden 'ref' Datensätze gespeichert. Das liegt daran, dass die Photodioden zwar nur auf IR Licht ansprechen das aber umso stärker je heller die normalen LEDs gerade Leuchten. Deshalb benutze ich den 'dp' Datensatz um die Sensorwerte später an den jeweiligen pwm Wert anzupassen. Da der Zusammenhang sich als linear herausgestellt hat ist dies einfach zu bewerkstelligen, die Funktion cps_pwm() übernimmt diese Aufgabe:

void cps_pwm( uint16_t* dst, uint16_t* dp ) 
{ 
  for( uint8_t i = 0; i < 8; ++i ) 
  { 
    uint16_t v = ( dp[i] * g_pwm ) / 1023; 
    dst[i] -= v; 
  } 
}

Die Werte in 'dp' sind übrigens äußerst individuell pro Photodiode und variieren bei meinen Exemplaren von 4-17.

Hier nun der rest, da ich 10.000 Zeichen pro Beitrag überschritten hatte

Der eine oder andere wird vielleicht denken das ich hier etwas pingelig bin aber mit Hilfe dieser Daten kann man - wie ich später zeigen werde - die Referenzdaten aktualisieren da es nun möglich ist unabhängig von der Leuchtstärke der Lampe sehr genau zu berechnen wie das Signal aussähe, wenn die Lampe nicht eingeschaltet wäre, unabhängig davon wie stark gerade gedimmt wird. Das ist erforderlich da sich im Laufe eines Tages die IR Lichtsituation ändert und der 'ref' Datensatz daher nachgeführt werden muss. Dies alles und die Berechnung des jeweiligen DIM Wertes über nimmt die Funktion SensorProbe():

// Hauptschleife 
while( TRUE ) 
{ 
  OCR1A = g_pwm; 
  SensorProbe( on, of, ref, dp, 160 ); 
}

Diese berechnet den neuen 'g_pwm' Wert abhängig von der Handposition vor der Lampe neu. Es passiert dabei nun folgendes:

// 
// Sensorwert berechnen 
// 
  IR_LEDS_AN; ReadSensor( on, avg ); 
  IR_LEDS_AUS; ReadSensor( of, avg ); 
  abs_diff( on, of, on ); 
  cps_pwm( on, dp );

Die Berechnung findet jetzt wie beim Einschalten der Lampe schon gehabt statt das Ergebnis wird jedoch noch um den 'dp' Faktor korrigiert und nun kommt das eigentliche 'Glanzstück' nämlich die Extraktion des tatsächlichen Signals aus den Daten:

// 
// differenz zur referenz berechnen 
// 
static uint32_t REF[8]; 
static uint32_t num = 0; 
char c = 'S'; 


abs_diff( r, ref, on ); 


  if( sig_plaus( r ) <= 6 ) 
  { 
    c = ' '; 
    if( num == 0 ) 
    { // initialisieren mit ref[] 
      for( uint8_t i = 0; i < 8; ++i ) 
      { 
        REF[i] = ref[i]; 
      } 
      num++; 
   } 
  // addieren von neuem ref 
  for( uint8_t i = 0; i < 8; ++i ) 
  { 
    REF[i] += on[i]; 
  } 
  num++; 
  // neuer Mittelwert 
  for( uint8_t i = 0; i < 8; ++i ) 
  { 
    ref[i] = REF[i] / num; 
  } 
  // overflow 
  if( num == 32 ) 
  { 
    for( uint8_t i = 0; i < 8; ++i ) 
    {  
      REF[i] >>= 1; 
    } 
    num = 16; 
  } 
}

Zuerst wird mit abs_diff(r, ref, on ) die Abweichung des Signals zur Referenz in 'r' berechnet r sollte überall Null sein, wenn kein Objekt vor der Lampe ist, da aber noch Störungen auftreten gibt es die Funktion sig_plaus( r ) die zwei Aufgaben hat, 1. Das Signal von unplausiblen Werten zu glätten und festzustellen ob ein Objekt vor der Lampe ist. Falls Keines vor der Lampe ist - sig_plaus( r ) < 6 - dann wird der Wert in 'r' zu 'REF' hinzuaddiert und 'num ' weitergezält. 'REF' Speicher nämlich die Summe der letzten 32 Messungen - ohne Objekt vor der Lampe -. Bei der 32. Messung wird dann der Wert von 'REF' nach 'ref' übertragen und zvor durch 32 dividiert und somit passt sich der Referenzwert über den Tagesverlauf der Lichtsituation an. Alle 'REF' Werte werden dann durch 2 geteilt und 'num' nun auf 16 gesetzt. Auf diese Weise werden kurzfristige Ausreisser abgedämpft, da nun mindestens immer eine Historie von 16-32 Werten in 'REF' abgebildet wird. Falls sig_plaus() übrigens kein Objekt erkennt wird 'c' auf ' ' gesetzt was soviel bedeutet wie - Kein Signal - und die Funktion wird dann beendet ohne 'g_pwm' zu ändern:

// 
// Dimmwert anpassen 
// 
  if( c != 'S' ) 
    return; // NO SIGNAL

So, nun ist es Zeit für einen kleinen Abstecher zu sig_plaus():

uint16_t sig_plaus( uint16_t* sig ) 
{ 
  uint16_t max = 0; 
  uint16_t p[8]; 
  p[0] = 2 * sig[ 1 ]; 
  p[7] = 2 * sig[ 6 ]; 
  for( uint8_t i = 1; i < 7; ++i ) 
  { 
    p[i] = sig[ i - 1 ] + sig[ i + 1 ]; 
  } 
  for( uint8_t i = 0; i < 8; ++i ) 
  { 
    if( sig[ i ] > p[ i ] ) sig[ i ] = p[ i ] / 2; 
    if( sig[ i ] > max ) max = sig[ i ]; 
  } 
  return max; 
}

Der Code beruht auf der Annahme, das es ein Fehler ist, wenn ADC(x) größer ist als die Summe seiner Beiden Nachbarn ist - man bedenke das man bestenfalls einen Finger vor die Lampe hält, meist sogar die ganze Hand. Deshalb werden Signalwerte die nicht plausibel sind durch das Mittel der Beiden Nachbarwerte ersetzt. Da ADC0 und 7 jedoch keine zwei Nachbar haben wird einfach 2*ADC1/6 verwendet. Gleichzeitig merkt sich die Funktion das stärkste Signal auf einem der ADC und liefert dieses als Ergebnis um später zu entscheiden ob ein Objekt vor der Lampe ist.

Zum guten Schluss die eigentliche Auswertung:

uint32_t vl = (r[0] + r[1] + r[2] + r[3]) >> 2; 
  uint32_t vr = (r[4] + r[5] + r[6] + r[7]) >> 2; 
  int8_t sub = (vl > vr) ? TRUE : FALSE; 
  uint32_t d = sub ? (vl - vr) : (vr - vl); 
  if( (vl + vr) >= 16 ) 
  { 
    int32_t pwm = g_pwm; 
    uint32_t m = d; 
    /**/ if( pwm < 32 ) m = 1; 
    else if( pwm < 64 ) m = 2; 
    else if( pwm < 128 ) m = 4; 
    else if( pwm < 256 ) m = 6; 
    else if( pwm > 768 ) m = 6; 
    else if( pwm > 896 ) m = 4; 
    else if( pwm > 960 ) m = 2; 
    else if( pwm > 992 ) m = 1; 
    /**/ if( d > m ) d = m; 
    else if( d > 8 ) d = 8; 
    if( sub ) 
    { 
      if( ( pwm -= d ) < 0 ) pwm = 0; 
    } 
    else 
    { 
      if( ( pwm += d ) > 1023 ) pwm = 1023; 
    } 
    g_pwm = pwm; 
  }

In 'vl' (links) und 'vr' (rechts) werden die entsprechenden Signale der beiden Sensorhälften summiert. Der Sensor fungiert hier als eine Art Lichtwaage mit zwei Schalen, wenn links überwiegt wird es dunkler und bei rechts heller und erst ab einer Schwelle von mindestens 16 (10cm Entfernung der Hand) spricht der Sensor überhaupt erst an. Der Betrag um den gedimmt wird errechnet sich aus der Differenz 'd' zwischen 'vl' und 'vr' wobei die Dimmung an den Randbereichen des Intervalles [0-1023] abgebremst wird (elseif(..) Konstrukt oben). Die Dimmung erfolgt also um so stärker, je näher die Hand über dem Sensor ist und je größer das Ungleichgewicht zwischen linker und rechter Hälfte des Sensors ist. Der maximale Dimmbetrag wird zusätzlich auf maximal 8 begrenzt.

Man kann die Lampe auf diese Weise schnell, genau und ausgewogen Dimmen.

So Ich hoffe ich war nicht zu unverständlich und der eine oder andere kann einen Nutzen aus all diesen Überlegungen Ziehen.

Schönes Wochenende noch..

Hi,

Zum Abschluss möchte ich noch die fertig installierte Lampe präsentieren:

Sekundärseitig habe ich nun noch einen Schalter eingebaut. Und nun noch einmal zu den Rahmendaten:

Von den LEDs habe ich 8 Stück a 2Reihen rechts und links verbaut die Lichtfarbe ist einfach Top und steht einer Glühbirne in nichts nach und die gute Farbwiedergabe erzeugt eine sehr angenehme Atmosphäre. Die ZXLD1366 KSQ sind auf 425 mA eingestellt und an den beiden LED-Strängen fallen dadurch knapp über 40V ab. Zum Verbrauch ab Steckdose:

• 100%: 36 Watt
• 0%: 0.5 Watt
• Sekundär aus: <= 0.2Watt

Beim Netzteil verwende ich das GS40A48 das laut Datenblatt 92.5% Wirkungsgrad erreicht und nach meinen Messungen im Standby <=0.2 Watt verbraucht.. Kein Wunder eigentlich, da es die Energy Star Level V Norm erfüllt. Im Dauerbetrieb mit 36Watt wird es nicht einmal handwarm. Meiner Ansicht nach eines der besten Netzteile überhaupt.

Vorher war die IKEA Mondlampe verbaut:

Die mit 2x25 Watt etwas mehr Leistung verbraten hat und außerdem weniger Licht machte und natülich nicht ganz so cool aussieht. Damit ist nun fast die letzte - nicht LED - Lampe aus unserem Haushalt verschwunden.

Die Platinen habe ich mit dem freien Programm KiCAD erstellt mit dem ich sehr zufrieden bin und das mit 1-2 Tagen Einarbeitung zu erlernen ist. Insgesamt hatte ich 3 Platinentypen damit erstellt die ich zum Abschluss nun auch noch verfügbar mache:

1) Die Hauptplatinen mit 2 freien Bereichen auf denen die ZXLD1366 KSQ aufgeschraubt werden:

ATMega8535.zip

2) Die ZXLD1366 KSQs, die bis zu 48V Eingangspannung abkönnen:

ZXLD1366-5.zip

3) Die Fotosensor Platine:

FotosensorT.zip

Das ist also das Ende von fast 6 Monaten Entwicklungszeit. Die Ideen die hierin umgesetzt wurden hätte ich ohne dieses Forum vermutlich niemals gehabt - daher ein Danke an alle die hier Posten und teils nicht unerhebliche Zeit und Mühe opfern.

lg Sol

Hi,

Vielen dank erstmal für den Zuspruch!

An ein Video hatte ich auch schon gedacht, und mal mit der Knipse von meinen Kindern rumprobiert - hab selbst nur eine SLR ohne Video Funktion. Heraus kam dabei ein 5MB große .mov Datei aber sowas kann man hier wohl nicht so ohne weiteres hochladen. Zudem gab es in regelmäßigen Abständen ein Flackern - wohl eine Art Schwebung zwischen PWM und Video Frequenz. Für Tipps bin ich aber offen, wie man das hier mit Video am besten machen kann.

FloW: Den LM358 habe ich nur genommen, weil er beim www.mikrocontroller.net im Beispiel angegeben war. Die 0,5pF (0603) KERKOS hatte ich von www.segor.de die waren auf meinem Testboard verbaut. In der Endversion hatte ich dann nur noch 0805 1pF Kerkos von Reichelt, die aber ebenso funktionieren. Im Mikrocontroller.net Artikel wir wird C1 als Kompensationskapazität bezeichent: Ist sie zu klein oder fehlt sie gar, schwingt der TIA.

Die Gravur hatte ca. 129,- gekostet und wurde von www.short-cut.de gemacht. Ich habe eine Menge Angebote eingeholt aus ganz DE aber nicht jeder konnte die Größe lasern. Preislich war es zwar nicht die unterste Kategorie aber das habe ich dadurch kompensiert, dass die auf meinem Weg zur Arbeit liegenund ich mir die Versandgeschichte gespart habe. Außerdem konnte ich mir so persönlich ein Bild machen und mit den Leuten reden - was ich neben den Kosten auch recht wichtig fand. Die Kosten einer Lasergravur richten sich im Wesentlichen nach der Größe der Fläche und dem Bedeckungsgrad.

tauruz: Das Netzteil kaufte ich bei rs-online aber beim nächsten mal werden ich es wohl eher bei elpro.org kaufen, die scheinen mir bessere Preise zu haben .

lg Sol.

Das betrifft die gesamte Produktgruppe (40Watt)

• entspricht Energy Star Level IV

Und das gilt für die 12..48V Versionen:

• entspricht Energy Star draft 2.0 Level V (12...48V)

lg. Sol