Unterstützung für DIY Modul-Leuchten

[Marcel Häusler]

Hallo Community,

nach langer Abstinenz, möchte ich mir in meinen neuen Haus wieder meinem Aquaristik Hobby frönen.
Das neue Becken wird die Maße 250x70x60 haben.

Bevor das Becken jedoch bestellt wird, möchte ich mir eine passende Beleuchtung bauen.
Meine Idee war, ein modulares Beleuchtungskonzept. Hierbei sollen die einzelnen Module mittels TC420
gedimmt werden. Jedes Modul hat ein eigens Netzteil. Bei Ausfall einer Lampe ist nicht alles dunkel und
wenn ich mehr Licht benötige oder sich die Beckengröße ändert kann ich erweitern. Aktuell möchte ich
4 der Hängelampen mit je ca. 10000 Lumen über dem Becken platzieren. Eine Lampe besteht aus einem
gekantetem Edelstahl Lochblech mit innenseitig angebrachten Aluminium U-Profilen. Die LED's

2x 50cm Samsung LED Streifen 6500 K @1500mA
4x Cree XP-E2 Royal Blau @500mA - Farbanpassung
4x Cree XP-E2 Rot @500mA - Farbanpassung
2x Cree XP-G3 S5 @1500mA - Effekte

werden in den U-Profilen eingeklebt. Unterseitig wird eine Spritzschutzscheibe eingeschoben. Am Gehäuse
selbst werden noch 2x 40mm Lüfter saugend montiert.

Ich habe mal die jetzige Konfiguration skizziert und wäre über eure fachkundige Beratung sehr Dankbar.

Grüße aus Unterfranken
Marcel

Lampe-1

• Marcel Häusler
• 2 Februar 2019

 

[Wuestenrose]

Hallo Marcel,

ziemlich professionelle Planung, die Du da aufgelegt hast, sauber, sauber :thumbs:

2x 50cm Samsung LED Streifen 6500 K @1500mA

Ich sehe 2 × 2 pro Leuchte und habe damit auch die größten Bauchschmerzen. Die 4 Streifen nehmen bei 1,5 Ampere immerhin rund 120 Watt auf und ich befürchte, mit den Minilüftern kriegst Du die Wärme nicht weg.

Viele Grüße
Robert

 

[Marcel Häusler]

Vielen Dank für die Antwort.

Vielleicht hätte ich die Länge in der Skizze angeben sollen.Pro Lampe werden
nur 2 Streifen verbaut. Diese werden geteilt in 4x 25cm.
Das sollten dann 2x1,5*19,6=58,8 Watt sein.

Passen die ausgewählten KSQ und Netzteile? Oder liege ich hier daneben?

Mit freundlich Grüßen.

 

[Wuestenrose]

'N Abend Marcel...

Ich hab heute lange gerätselt. Reicht die Kühlung, reicht sie nicht :? ? Momentan tendiere ich zu "sie reicht".

Bei den LM301B-Streifen kannst Du davon ausgehen, daß pimaldaumen 40 % der zugeführten elektrischen Leistung als Wärme wieder weggehen, bei den Cree sind's eher 60 %. Die Erwärmung der von den Lüftern durchgesaugten Luft errechnet sich zu:

[tab=30]3 / Luftdurchsatz × Wärmeleistung = Erwärmung
(Luftdurchsatz in Kubikmetern pro Stunde, Wärmeleistung in Watt, Erwärmung in Grad)

Die Aluschienen werden natürlich wärmer als die Luft. Um wieviel, läßt sich über den Wärmeübergangskoeffizienten berechnen. Ich kenne die Maße der Aluschienen nicht, deshalb hab ich's gelassen. Das Gehäuse führt natürlich auch Wärme ab. Kann man mit dem Kühlblechrechner abschätzen. War mir auch zu aufwendig, ich kenne ja die Gehäusemaße nicht. Alles in allem denke ich aber, es reicht.

Die LEDs eines Strahlers nehmen, voll bestromt, um 80 Watt auf. Ein 4-Ampere-Netzteil, wie bspw.dieses hier, reicht deshalb auch schon, es brauchen keine 6 A zu sein. Die LDD-L sind ok.

HTH,
Robert

 

[Mandocello]

Hallo Marcel,

deine Leuchten werden so 25cm x 30cm groß? Bei dem Verhältnis Leistung zu Oberfläche könnte es immer noch recht warm werden. Aluminium leitet die Wärme 15x besser als Edelstahl. Ich würde bei den Profilen aufrüsten oder das ganze Gehäuse besser in die Kühlung einbeziehen, also aus Alu herstellen. Das kannst du bürsten oder beizen und eloxieren (lassen), das hat dann auch ein schönes und dauerhaftes Finish.

Die Lüfter an der Stirnseite werden in so einer flachen Anordnung nicht für eine gleichmäßige Kühlung sorgen. Auch hier wirkt ein Gehäuse aus Alu ausgleichend. In einem Gehäuse aus Lochblech gibt es erst recht keine ordentliche Luftführung. Ich würde die Lüfter gar nicht haben wollen und so bauen, dass es mit passiver Kühlung geht, also über die Oberfläche und mit einigen Öffnungen für Eigenkonvektion.

Bei so einem großen Projekt würde ich mir immer erstmal ein quick & dirty Testmuster bauen.

Viel Erfolg & Grüße
Uwe

 

[Wuestenrose]

Hallo Uwe,

guck mal in den verlinkten Kühlblechrechner. Zwischen Alu und Stahl ist jetzt nicht der riesige Unterschied, zumal die Aluschienen die Wärme ja gleichmäßig und nicht nur punktuell auf's Gehäuse verteilen.

Das mit dem Lochblech habe ich überlesen. Wenn die Lüfter was bewirken sollen, muß das Gehäuse bis auf Luftein- und -auslaß geschlossen sein. Ansonsten kann Marcel die Lüfter auch gleich ganz weglassen.


Viele Grüße
Robert

 

[Mandocello]

Hallo Robert,

den Rechner verwende ich auch oft und habe gerade nochmal herumprobiert. Das Verhältnis der Wärmeleitfähigkeiten von Edelstahl zu Baustahl zu Alu wie 15:30:230 gemäß Materialtabellen ist wohl unbestritten. Was mildert dieses krasse Verhältnis bei der Berechnung des Wärmewiderstandes so ab, dass sich zwei Bleche 100x100x2 aus Stahl und Alu im Wärmewiderstand nur um nichtmal 20% unterscheiden (sollen)?

Grüße
Uwe

 

[Marcel Häusler]

Vielen Dank für eure Meinungen und Ratschläge. Bitte weiter so!

Wenn ich eure Bedenken zur Wärmeabfuhr bzw. Wärmeerzeugung höre, glaube ich, es wird
besser sein die Lampen nochmals aufzuwerten. Es werde 2 Stk. zusätzliche LED Schienen mit
25cm verbaut. Das bedeutet je Lampe 6 Stk. der Samsung LED mit 25cm. Diese allerdings
nur noch mit 1000mA bestromt. Das sollte doch einiges bringen. Lumen bleiben im gesamten
gleich.

@ Robert :
Meine Intension mit dem Lochblech und den saugenden Lüftern. Dahinter steckte der
Gedanken die Luft im Gehäuse in Bewegung zu halten. Sprich mehr bewegt Luft um alle
verbauten Alu U-Schienen. Vielleicht bin ich aber auch auf dem Holzweg.

Viele Grüße
Marcel

 

[Marcel Häusler]

Hallo Mitleser,

Für meine geplante Beleuchtung sollten eigentlich 2 Stück TC420 zur Steuerung verwendet werden.
Nachdem ich mir die Teile mal genauer angesehen habe, bin ich nicht mehr so überzeugt. Ich möchte
gerne eine Tageslicht-Simulation. Das ist jedoch mit den TC420 nur unzufrieden umzusetzen. Die nur
minutengenaue Einstellmöglichkeiten sind einfach zu grob. Deshalb werden ich für die Ansteuerung
auf ein Arduino Nano zurückgreifen. Der Code für die Simulation steht soweit. Start und Länge der
Dimvorgänge je Kanal einstellbar. Nach Erreichen der Maximalbeleuchtung werden via Zufallsprinzip
einzelne Tageslichtkanäle (2 pro Hängeleuchte) kurz runter und wieder hoch gedimmt. Das soll im
Aquarium eine lokale Abdunklung zeigen, wie Wolken. Die Häufigkeit, Länge und Abdunklung ist
voreinstellbar. Bei erreichen einer fest eingestellter Zeit (später auch via Zufall) beginnt die Unwetter-
Simulation. Hierbei werden alle Kanäle auf die eingestellten Werte runter gedimmt. Sind die Werte
erreicht, werden zufällig die Kanäle, die als Blitz konfiguriert sind, ein und aus geschaltet. Nachdem
die Unwetterdauer überschritten ist, werden alle Kanäle, auf ihre Leuchtstärke vor dem Gewitter,
zurück gedimmt. Danach wieder Wolkensimulation bis Sonnenuntergang.

Wenn Interesse nach dem Code besteht dann melden.

Gruß Marcel

 

[cmon]

Hallo Marcel!

Immer her mit dem Code!

 

[Marcel Häusler]

Hier der aktuelle Code. Das Programm ist noch nicht auf einen 24 Stunden Betrieb umgeändert.
Läuft so nur zum Test auf dem Steckboard.

Tab structs.h:

#ifndef structs_h
#define structs_h

#include <WString.h>

typedef struct {
	int pin;  //Anschluß am PCA9685
	byte wrb; //Farbe der LED
	uint32_t starttime; //Beginn Dimmvorgang  für Sonnenaufganf
	uint32_t endtime; //Begin Dimmvorgang  für Sonnenuntergang
	int sunriselength;  //Länge des Dimmvorgang Sonnenaufgang in Minuten
	int sunsetlenght;   //Länge des Dimmvorgang Sonnenuntergang in Minuten
	byte status;
	unsigned long startmillis;
	float pos;
	float endpos;
	float freq;
}CHANAL;

uint32_t get_ts(uint8_t h, uint8_t m, uint8_t s){
	uint32_t t;
	t = h;
	t *= 60;
	t += m;
	t *= 60;
	t += s;
	return t;
}
#endif

Tab DS1307_Sub:

void setupClock(int hh,int mi,int dd,int mo,int yy){
  RTC.setRAM(0, (uint8_t *)&startAddr, sizeof(uint16_t));// Store startAddr in NV-RAM address 0x08

// Set new Time Value

  TimeIsSet = 0xffff;
  RTC.setRAM(54, (uint8_t *)&TimeIsSet, sizeof(uint16_t)); 


  RTC.getRAM(54, (uint8_t *)&TimeIsSet, sizeof(uint16_t));
  if (TimeIsSet != 0xaa55){
    RTC.stopClock();
       
    RTC.fillByYMD(yy,mo,dd);  // year,month,day
    RTC.fillByHMS(hh,mi,45);  //hour,min,sek
   
    RTC.setTime();
    TimeIsSet = 0xaa55;
    RTC.setRAM(54, (uint8_t *)&TimeIsSet, sizeof(uint16_t));
    RTC.startClock();
  }else{
    RTC.getTime();
    delay(1000);
  }

/*
   Control Register for SQW pin which can be used as an interrupt.
*/
  RTC.ctrl = 0x00;   // 0x00=disable SQW pin, 0x10=1Hz, 0x11=4096Hz, 0x12=8192Hz, 0x13=32768Hz
  RTC.setCTRL();

  uint8_t MESZ;

  MESZ = RTC.isMEZSummerTime();
}

String printTime()
{
  String sReturn;
 
 // sReturn = String(int(value));
    sReturn = "";
    RTC.getTime();
  if (RTC.hour < 10) {                    // correct hour if necessary
    sReturn += "0";
    sReturn += String(int(RTC.hour));
  }else{
    sReturn += String(int(RTC.hour));
  }
    sReturn += ":";
  if (RTC.minute < 10) {                  // correct minute if necessary
    sReturn += "0";
    sReturn += String(int(RTC.minute));
  }else{
    sReturn += String(int(RTC.minute));
  }
    sReturn += ":";
  if (RTC.second < 10) {                  // correct second if necessary
    sReturn += "0";
    sReturn += String(int(RTC.second));
  }else{
    sReturn += String(int(RTC.second));
  }

  return sReturn;
}

String printDate()
{
  String sReturn;
 
 // sReturn = String(int(value));
    sReturn = "";
    RTC.getTime();

//  Serial.print(" ");
  if (RTC.day < 10) {                    // correct date if necessary
    sReturn += "0";
    sReturn += String(int(RTC.day));

 //   Serial.print("0");
 //   Serial.print(RTC.day, DEC);
  }else{
    sReturn += String(int(RTC.day));
 //   Serial.print(RTC.day, DEC);
  }
//  Serial.print("-");
    sReturn += ".";
  if (RTC.month < 10) {                   // correct month if necessary
    sReturn += "0";
    sReturn += String(int(RTC.month));
 //   Serial.print("0");
 //   Serial.print(RTC.month, DEC);
  }else{
    sReturn += String(int(RTC.month));
 //   Serial.print(RTC.month, DEC);
  }
    sReturn += ".";
    sReturn += String(int(RTC.year));
   // sReturn += y.replace("20","");  // Year need not to be changed
 
  sReturn;

  return sReturn;
}


String printYYYY()
{
  String sReturn;
 
 // sReturn = String(int(value));
    sReturn = "";
    RTC.getTime();
    sReturn += String(int(RTC.year));
  sReturn;

  return sReturn;
}


String printDDMM()
{
  String sReturn;
 
 // sReturn = String(int(value));
    sReturn = "";
    RTC.getTime();

//  Serial.print(" ");
  if (RTC.day < 10) {                    // correct date if necessary
    sReturn += "0";
    sReturn += String(int(RTC.day));

 //   Serial.print("0");
 //   Serial.print(RTC.day, DEC);
  }else{
    sReturn += String(int(RTC.day));
 //   Serial.print(RTC.day, DEC);
  }
//  Serial.print("-");
    sReturn += ".";
  if (RTC.month < 10) {                   // correct month if necessary
    sReturn += "0";
    sReturn += String(int(RTC.month));
 //   Serial.print("0");
 //   Serial.print(RTC.month, DEC);
  }else{
    sReturn += String(int(RTC.month));
 //   Serial.print(RTC.month, DEC);
  }
 
  sReturn;

  return sReturn;
}

uint32_t get_ts(int h, int m, int s){

  uint32_t t;
  t = h;
  t *= 60;
  t += m;
  t *= 60;
  t += s;

  return t;
}

uint32_t TimeStamp(){
  uint32_t t;
  //RTC.getTime();
  t = RTC.hour;
  t *= 60;
  t += RTC.minute;
  t *= 60;
  t += RTC.second;
  return t;
}

Tab Programm:

#include <Timer.h>
#include <DS1307new.h>
#include "structs.h"
#include <Wire.h>
#include <math.h>
#include <Adafruit_PWMServoDriver.h>
Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver();

#define NIGHT 0  //FLAG Nacht
#define SUNRISE 1 //FLAG Sonnenaufgang
#define DAY 2 //FLAG Tag
#define SUNSET 3  //FLAG Sonnuntergang
#define THUNDER_ON 4  //FLAG Gewitter kommt
#define THUNDER_TIME 5  //FAG Zeit für Blitze
#define THUNDER_OFF 6 //FLAG Gewitter geht
#define CLOUD_ON 7  //FLAG Wolke kommt
#define CLOUD_OFF 8 //FLAG Wolke geht
#define OFF 9
#define DAYLIGHT 10 //FLAG Tageslicht
#define REDLIGHT 11 //FLAG Rotlicht
#define BLUELIGHT 12  //FLAG Blaulicht
#define LIGHTNING 13


#define LIGHTCHANALS 12 //Anzahl der Lichtkanäle
#define LIGHTNINGS 3  //Anzahl der Blitzkanäle
#define MAXBRIGHTNESS_DAYLIGHT 100  //Maximale Helligkeit in Prozent
#define MAXBRIGHTNESS_REDLIGHT 70  //Maximale Helligkeit in Prozent
#define MAXBRIGHTNESS_BLUELIGHT 70  //Maximale Helligkeit in Prozent
#define THUNDERBRIGHTNESS_DAYLIGTH 10 //Maximale Helligkeit bei Gewitter in Prozent
#define THUNDERBRIGHTNESS_REDLIGTH 10 //Maximale Helligkeit bei Gewitter in Prozent
#define THUNDERBRIGHTNESS_BLUELIGTH 10 //Maximale Helligkeit bei Gewitter in Prozent

#define CLOUD_SPEED 5  //Zeit für Dimmvorgang in Sek.
#define CLOUD_AMOUNT 30000 // max 65535 Bereich für Zufallszahl je kleiner um so häufiger
#define CLOUD_MAXBRIGHTNESS 30 //Maximale Wolkenhelligkeit in Prozent
#define THUNDER_SPEED 3 //Zeit für Dimmvorgang in Sek.
#define THUNDER_LENGTH 1 //Länge der Dunkelphase beim Gewitter in Min.

Timer t;
uint16_t startAddr = 0x0000;            // Start address to store in the NV-RAM Uhr
uint16_t lastAddr;                      // new address for storing in NV-RAM Uhr
uint16_t TimeIsSet = 0xaa55;
unsigned long last_calc = 0;

uint32_t thunder_start_time = get_ts(8, 2, 0);
byte thunder_status;
int lightnings[]={4,9,14};

CHANAL chanals[] = {  {0, DAYLIGHT,get_ts(8, 0, 10), get_ts(8, 5, 0), 1, 1, NIGHT, 0, 0, 0, 0},
                      {3, DAYLIGHT,get_ts(8, 0, 10), get_ts(8, 5, 0), 1, 1, NIGHT, 0, 0, 0, 0},
                      {5, DAYLIGHT,get_ts(8, 0, 10), get_ts(8, 5, 0), 1, 1, NIGHT, 0, 0, 0, 0},
                      {8, DAYLIGHT,get_ts(8, 0, 10), get_ts(8, 5, 0), 1, 1, NIGHT, 0, 0, 0, 0},
                      {10,DAYLIGHT,get_ts(8, 0,10), get_ts(8, 5, 0), 1, 1, NIGHT, 0, 0, 0, 0},
                      {13,DAYLIGHT,get_ts(8, 0,10), get_ts(8, 5, 0), 1, 1, NIGHT, 0, 0, 0, 0},
                      {2, REDLIGHT,get_ts(8, 0, 0), get_ts(8, 5, 10), 1, 1, NIGHT, 0, 0, 0, 0},
                      {7, REDLIGHT,get_ts(8, 0, 0), get_ts(8, 5, 10), 1, 1, NIGHT, 0, 0, 0, 0},
                      {12,REDLIGHT,get_ts(8, 0, 0), get_ts(8, 5, 10), 1, 1, NIGHT, 0, 0, 0, 0},
                      {1, BLUELIGHT,get_ts(8, 0, 10), get_ts(8, 5, 15), 1, 1, NIGHT, 0, 0, 0, 0},
                      {6, BLUELIGHT,get_ts(8, 0, 10), get_ts(8, 5, 15), 1, 1, NIGHT, 0, 0, 0, 0},
                      {11,BLUELIGHT,get_ts(8, 0, 10), get_ts(8, 5, 15), 1, 1, NIGHT, 0, 0, 0, 0}};



void setup() {
  Serial.begin(9600);
  randomSeed(analogRead(0));
  setupClock(7, 59, 20, 1, 2018);
  pwm.begin();
  pwm.setPWMFreq(1600);  // This is the maximum PWM frequency 
  // save I2C bitrate
  uint8_t twbrbackup = TWBR;
  // must be changed after calling Wire.begin() (inside pwm.begin())
  TWBR = 12; // upgrade to 400KHz!
  delay(3000);
  RTC.getTime();
  for (int i = 0; i < 48; i++) {
    pwm.setPWM(i, 0, 0);
  }
  thunder_status = NIGHT;
}


void loop()
{
  word w;
  RTC.getTime();
  t.update();
  if (millis() > last_calc)
  {
    last_calc = millis();
    for (int i = 0; i < LIGHTCHANALS; i++)
    {
      if (TimeStamp() >= chanals[i].starttime && TimeStamp() <= (chanals[i].endtime + get_ts(0, chanals[i].sunsetlenght, 0)))
      {
        switch (chanals[i].status)
        {
          case NIGHT:
            switch (chanals[i].wrb)
            {
              case DAYLIGHT:
                chanals[i].freq = float(4095 / 100.0 * MAXBRIGHTNESS_DAYLIGHT / 60000.0 / chanals[i].sunriselength);
                break;
              case REDLIGHT:
                chanals[i].freq = float(4095 / 100.0 * MAXBRIGHTNESS_REDLIGHT / 60000.0 / chanals[i].sunriselength);
                break;
              case BLUELIGHT:
                chanals[i].freq = float(4095 / 100.0 * MAXBRIGHTNESS_BLUELIGHT / 60000.0 / chanals[i].sunriselength);
                break;
            }
            chanals[i].status = SUNRISE;
            chanals[i].startmillis = last_calc;
            Serial.print(printTime());
            Serial.print("  PIN: ");
            Serial.print(chanals[i].pin);
            Serial.println(" AN");
            break;

          case SUNRISE:
            chanals[i].pos = chanals[i].freq * (last_calc - chanals[i].startmillis);
            switch (chanals[i].wrb)
            {
              case DAYLIGHT:
                if (chanals[i].pos >= float(4095 / 100.0 * MAXBRIGHTNESS_DAYLIGHT ))
                {
                  chanals[i].pos = float(4095 / 100.0 * MAXBRIGHTNESS_DAYLIGHT );
                  chanals[i].status = DAY;
                }
                break;
              case REDLIGHT:
                if (chanals[i].pos >= float(4095 / 100.0 * MAXBRIGHTNESS_REDLIGHT ))
                {
                  chanals[i].pos = float(4095 / 100.0 * MAXBRIGHTNESS_REDLIGHT );
                  chanals[i].status = DAY;
                }               
                break;
              case BLUELIGHT:
                if (chanals[i].pos >= float(4095 / 100.0 * MAXBRIGHTNESS_BLUELIGHT)) 
                {
                  chanals[i].pos = float(4095 / 100.0 * MAXBRIGHTNESS_BLUELIGHT );
                  chanals[i].status = DAY;
                }               
                break;
            }
            break;

          case DAY:
            w = random(0, CLOUD_AMOUNT);
            if (w < LIGHTCHANALS && chanals[i].wrb==DAYLIGHT) //Nur Kanäle mit Tageslicht
            {
            if (TimeStamp() <= (chanals[i].endtime + get_ts(0,0,CLOUD_SPEED)))
              {
              chanals[i].startmillis = last_calc;
              chanals[i].status = CLOUD_ON;                               //Status Wolke an
              chanals[i].endpos = chanals[i].pos;                       //Aktuelle Position zwischenspeichern
              chanals[i].freq = float((chanals[i].pos - (4095 / 100 * CLOUD_MAXBRIGHTNESS)) / 1000.0 / CLOUD_SPEED); //Frequenz berechnen für Dimmvorgang
              }
            }
            break;

          case CLOUD_ON:
            if (chanals[i].wrb==DAYLIGHT) //Nur Kanäle mit Tageslicht
            {
              chanals[i].pos = chanals[i].endpos - (chanals[i].freq * (last_calc - chanals[i].startmillis));
              if (chanals[i].pos <= float(4095 / 100 * CLOUD_MAXBRIGHTNESS))
              {
                chanals[i].pos = float(4095 / 100 * CLOUD_MAXBRIGHTNESS);
                chanals[i].status = CLOUD_OFF;
                chanals[i].startmillis = last_calc;
                chanals[i].freq = float(((4095 / 100.0 * MAXBRIGHTNESS_DAYLIGHT ) - chanals[i].pos) / 1000.0 / CLOUD_SPEED); //Frequenz berechnen für Dimmvorgang
                chanals[i].endpos = chanals[i].pos;
              }
            }
            break;

          case CLOUD_OFF:
            if (chanals[i].wrb==DAYLIGHT) //Nur Kanäle mit Tageslicht
            {
              chanals[i].pos = chanals[i].endpos + (chanals[i].freq * (last_calc - chanals[i].startmillis));
              if (chanals[i].pos >= float(4095 / 100.0 * MAXBRIGHTNESS_DAYLIGHT ))
              {
                chanals[i].pos = float(4095 / 100.0 * MAXBRIGHTNESS_DAYLIGHT );
                chanals[i].status = DAY;
              }
            }
            break;

          case SUNSET:
            chanals[i].pos = chanals[i].endpos - (chanals[i].freq * (last_calc - chanals[i].startmillis));
            if (chanals[i].pos <= 0.0)
            {
              chanals[i].pos = 0;
              chanals[i].status = OFF;
              Serial.print(printTime());
              Serial.print("  PIN: ");
              Serial.print(chanals[i].pin);
              Serial.println(" Aus");
            }
            break;

          case THUNDER_ON:
            switch (chanals[i].wrb)
            {
              case DAYLIGHT:
                chanals[i].pos = chanals[i].endpos - (chanals[i].freq * (last_calc - chanals[i].startmillis));
                if (chanals[i].pos <= (chanals[i].endpos / 100 * THUNDERBRIGHTNESS_DAYLIGTH))
                {
                  chanals[i].pos = (chanals[i].endpos / 100 * THUNDERBRIGHTNESS_DAYLIGTH);
                  chanals[i].status = THUNDER_TIME;
                  chanals[i].startmillis = last_calc;
                }                          
                break;
              case REDLIGHT:
                chanals[i].pos = chanals[i].endpos - (chanals[i].freq * (last_calc - chanals[i].startmillis));
                if (chanals[i].pos <= (chanals[i].endpos / 100 * THUNDERBRIGHTNESS_REDLIGTH))
                {
                  chanals[i].pos = (chanals[i].endpos / 100 * THUNDERBRIGHTNESS_REDLIGTH);
                  chanals[i].status = THUNDER_TIME;
                  chanals[i].startmillis = last_calc;
                }        
                break;
              case BLUELIGHT:
                chanals[i].pos = chanals[i].endpos - (chanals[i].freq * (last_calc - chanals[i].startmillis));
                if (chanals[i].pos <= (chanals[i].endpos / 100 * THUNDERBRIGHTNESS_BLUELIGTH))
                {
                  chanals[i].pos = (chanals[i].endpos / 100 * THUNDERBRIGHTNESS_BLUELIGTH);
                  chanals[i].status = THUNDER_TIME;
                  chanals[i].startmillis = last_calc;
                }    
                break;
            }
             break;

          case THUNDER_TIME:
            w=random(0, 1500);
            if (w<=2)
              {
                for (int j=95;j<=4095;j=j+500)
                {
                pwm.setPWM(lightnings[int(w)], 0, j);
                }
                pwm.setPWM(lightnings[int(w)], 0, 0);
              }


          
            if (last_calc >= (chanals[i].startmillis+(THUNDER_LENGTH*60000)))
            {
              switch (chanals[i].wrb)
              {
                case DAYLIGHT:
                  chanals[i].status = THUNDER_OFF;
                  chanals[i].startmillis = last_calc;
                  chanals[i].freq = float(((4095 / 100.0 * MAXBRIGHTNESS_DAYLIGHT) - chanals[i].pos) / 1000.0 / THUNDER_SPEED); //Frequenz berechnen für Dimmvorgang
                  chanals[i].endpos = chanals[i].pos;                        
                  break;
                case REDLIGHT:
                  chanals[i].status = THUNDER_OFF;
                  chanals[i].startmillis = last_calc;
                  chanals[i].freq = float(((4095 / 100.0 * MAXBRIGHTNESS_REDLIGHT) - chanals[i].pos) / 1000.0 / THUNDER_SPEED); //Frequenz berechnen für Dimmvorgang
                  chanals[i].endpos = chanals[i].pos; 
                
                  break;
                case BLUELIGHT:
                  chanals[i].status = THUNDER_OFF;
                  chanals[i].startmillis = last_calc;
                  chanals[i].freq = float(((4095 / 100.0 * MAXBRIGHTNESS_BLUELIGHT) - chanals[i].pos) / 1000.0 / THUNDER_SPEED); //Frequenz berechnen für Dimmvorgang
                  chanals[i].endpos = chanals[i].pos; 
                  break;
              }            
            }         
            break;
          case THUNDER_OFF:
                chanals[i].pos = chanals[i].endpos + (chanals[i].freq * (last_calc - chanals[i].startmillis));          
            switch (chanals[i].wrb)
            {
              case DAYLIGHT:
                if (chanals[i].pos >= float(4095 / 100.0 * MAXBRIGHTNESS_DAYLIGHT))
                {
                  chanals[i].pos = float(4095 / 100.0 * MAXBRIGHTNESS_DAYLIGHT);
                  chanals[i].status = DAY;
                }
                break;
              case REDLIGHT:
                if (chanals[i].pos >= float(4095 / 100.0 * MAXBRIGHTNESS_REDLIGHT))
                {
                  chanals[i].pos = float(4095 / 100.0 * MAXBRIGHTNESS_REDLIGHT);
                  chanals[i].status = DAY;
                }
              
                break;
              case BLUELIGHT:
                if (chanals[i].pos >= float(4095 / 100.0 * MAXBRIGHTNESS_BLUELIGHT))
                {
                  chanals[i].pos = float(4095 / 100.0 * MAXBRIGHTNESS_BLUELIGHT);
                  chanals[i].status = DAY;
                }
              
                break;
            }
             break;
        }
        if (TimeStamp() >= chanals[i].endtime && chanals[i].status != SUNSET && chanals[i].status != OFF)
        {
          chanals[i].status = SUNSET;
          chanals[i].startmillis = last_calc;
          chanals[i].freq = float(chanals[i].pos / 60000.0 / chanals[i].sunsetlenght);
          chanals[i].endpos = chanals[i].pos;
        }
        setpwm(chanals[i].pin, int(chanals[i].pos));
      }
    }

    if (TimeStamp() >= thunder_start_time && thunder_status == NIGHT)
    {
      thunder_status = THUNDER_ON;
      Serial.println("Gewitter an");
      for (int i = 0; i < LIGHTCHANALS; i++)
      {
        chanals[i].status = THUNDER_ON;
        chanals[i].startmillis = last_calc;
        chanals[i].endpos = chanals[i].pos;
        
        switch (chanals[i].wrb)
        {
          case DAYLIGHT:

            if (chanals[i].pos <= float(4095 / 100 * THUNDERBRIGHTNESS_DAYLIGTH))
            {
              chanals[i].freq=0.0;
            }
            if (chanals[i].pos > float(4095 / 100 * THUNDERBRIGHTNESS_DAYLIGTH))
            {
              chanals[i].freq=float((chanals[i].pos-(4095/100*THUNDERBRIGHTNESS_DAYLIGTH))/1000.0/THUNDER_SPEED);  //Frequenz berechnen für Dimmvorgang
            }
          break;

          case REDLIGHT:

            if (chanals[i].pos <= float(4095 / 100 * THUNDERBRIGHTNESS_REDLIGTH))
            {
              chanals[i].freq=0.0;
            }
            if (chanals[i].pos > float(4095 / 100 * THUNDERBRIGHTNESS_REDLIGTH))
            {
              chanals[i].freq=float((chanals[i].pos-(4095/100*THUNDERBRIGHTNESS_REDLIGTH))/1000.0/THUNDER_SPEED);  //Frequenz berechnen für Dimmvorgang
            }
          break;
          case BLUELIGHT:

            if (chanals[i].pos <= float(4095 / 100 * THUNDERBRIGHTNESS_BLUELIGTH))
            {
              chanals[i].freq=0.0;
            }
            if (chanals[i].pos > float(4095 / 100 * THUNDERBRIGHTNESS_BLUELIGTH))
            {
              chanals[i].freq=float((chanals[i].pos-(4095/100*THUNDERBRIGHTNESS_BLUELIGTH))/1000.0/THUNDER_SPEED);  //Frequenz berechnen für Dimmvorgang
            }
          break;        
        }        
      }
    }    
  }
}



void setpwm(int CH, int pos)
{
  pwm.setPWM(CH, 0, int(exp(sqrt(pos) * 0.144295) * 0.4));
}

 

[Marcel Häusler]

Hi,

das Lampenlayout wurde nochmal geringfügig geändert. Wie bereits geschrieben soll die
Ansteuerung nun über einen Arduino Nano erfolgen. Schaltbild wurde soweit abgeändert.

Nun meine Bitte an die erfahrenen LED-Erleuchter. Könntet ihr meinen Schaltbild mal
begutachten ob das so passt. (Netzteile Auswahl, GND Leitung, KSQ Auswahl)

Eine weitere Frage wäre da noch. Das Dimmen wird ja mit dem PCA9685 realisiert.
Ist generell was zu berücksichtigen bei der Kombination PCA9685 und MW KSQ's?

zBsp.
Wenn ich einen Dimkanal mittels Funktion auf 4095 also maximal setze, kommt dann
aus der KSQ auch die maximal Stromstärke?.

Grüße Marcel

Schaltbild-page-001

• Marcel Häusler
• 21 Februar 2019

 

[Wuestenrose]

Morgen…

Ich habe jetzt nicht alles kontrolliert, weder auf meinem Monitor, noch auf einem A4-Ausdruck sieht das besonders übersichtlich aus.

Ist generell was zu berücksichtigen bei der Kombination PCA9685 und MW KSQ's?

Konfiguriere die Ausgänge des PCA9685 auf Open Drain, nicht auf Totem Pole (OUTDRV = 0).

Wenn ich einen Dimkanal mittels Funktion auf 4095 also maximal setze, kommt dann
aus der KSQ auch die maximal Stromstärke?.

Wenn Du das Register INVRT des PCA9685 auf "1" setzt, ja.

Viele Grüße
Robert

 

[Marcel Häusler]

Danke Robert für die Auskunft.

Könntest du mir das nochmal leihenhaft erläutern. Also vielmehr was muss ich in meinem Programmcode hinzufügen bzw. ändern. Und was machen diese genannten Einstellungen.

Mit dem bestehenden Code leuchten die Test LED's auf dem Breadboard bei PWM 4095. Je kleiner der
PWM Wert je dunkler werden sie. Die Test LED'd beziehen ihren Strom aus dem Dim-Anschluß des PCA.

Gruß Marcel

 

[Wuestenrose]

Mahlzeit…

Könntest du mir das nochmal leihenhaft erläutern. Also vielmehr was muss ich in meinem Programmcode hinzufügen bzw. ändern.

Das kann ich Dir leider nicht sagen. Ich komme aus der Hardware-Ecke und kenne mich mit der Programmierung nicht aus. Die benötigten Befehle musst Du Dir aus dem Datenblatt des PCA9685 holen.

Mit dem bestehenden Code leuchten die Test LED's auf dem Breadboard bei PWM 4095. Je kleiner der
PWM Wert je dunkler werden sie. Die Test LED'd beziehen ihren Strom aus dem Dim-Anschluß des PCA.

Wie hast Du die LED angeschlossen? Vom einem der LED-Ausgänge des PCA9685 nach GND? Oder gemäß Fig. 15 auf Seite 29 des Datenblatts?

Viele Grüße
Robert