Post Reply
134 Beiträge • Seite 4 von 9
Beitragvon omega » 07 Jul 2015 17:35
Hi,

hier mal der PWM-Level live errechnet und der Tagsesablauf einfachst mit Delays nach Sabri.
setup() und loop() fehlen.
Daraus kann man auch eine C++-Klasse machen mit den ersten drei Konstanten als Parameter für den Konstruktor, damit das schön weggekapselt ist und die Details den Rest nicht stören.

Die Parameter zum Bestimmen des PWM-Levels werden absolut ermittelt und nicht über eine inkrementierte Variable: der Rundungsfehler wegen.

Hoch- und Runterdimmen brauchen jeweils eine eigene Funktion. Die beiden kann man sich dort ansehen: http://rechneronline.de/funktionsgraphen/ (der kann kein C).
Hoch: 1.0384 * (( 3.0^ (x * 3.0 - 3.0)) - 0.037)
Runter: 1.0384 * (3.0^ ((1.0 - x) * 3.0 - 3.0) - 0.037)

Grüße, Markus
Code #include <math.h>

#define dimDuration 60.0 // in minutes
#define dimIterations 4000 // in count
#define maxPWMLevel 255
#define PWMPin 10

uint8_t getPWMLevelUp( float time);
uint8_t getPWMLevelDown( float time);
float expFunc( float x);
float invExpFunc( float x);

void sampleDayDimmerForSabri()
{
   uint8_t pwmLevel;
   
   // fade in
   for( uint16_t i = 0; i < dimIterations; i++)
   {
      pwmLevel = getPWMLevelUp( dimDuration * i / dimIterations);
      analogWrite( PWMPin, maxPWMLevel - pwmLevel);
      delay( dimDuration * 60 * 1000 / dimIterations);
   }

   // 8 hours full throttle
   delay( 28800000);
   
   // fade out
   for( uint16_t i = 0; i < dimIterations; i++)
   {
      pwmLevel = getPWMLevelDown( dimDuration * i / dimIterations);
      analogWrite( PWMPin, maxPWMLevel - pwmLevel);
      delay( dimDuration * 60 * 1000 / dimIterations);
   }
   
   delay( 3600000); // don't restart immediately but switch me off
}

// time must be 0.0 when fading starts and must be
// dimDurataion when fading stops
uint8_t getPWMLevelUp( float time)
{
   float expVal = expFunc( time / dimDuration);
   
   return expVal * maxPWMLevel;
}

// time must be 0.0 when fading starts and must be
// dimDurataion when fading stops
uint8_t getPWMLevelDown( float time)
{
   float expVal = invExpFunc( time / dimDuration);
   
   return expVal * maxPWMLevel;
}

// x must be scaled between 0.0 and 1.0
// returns a value between 0.0 and 1.0 for 0.0 <= x <= 1.0 using
// an exponential function
float expFunc( float x)
{
   return 1.0384 * (pow( 3.0, x * 3.0 - 3.0) - 0.037);
}

// x must be scaled between 0.0 and 1.0
// returns a value between 1.0 and 0.0 for 0.0 <= x <= 1.0 using
// an exponential function
float invExpFunc( float x)
{
   return 1.0384 * (pow( 3.0, (1.0 - x) * 3.0 - 3.0) - 0.037);
}
Benutzeravatar
omega
Beiträge: 2274
Registriert: 12 Sep 2012 20:53
Wohnort: München
Bewertungen: 9 (100%)
Beitragvon sabrikara » 07 Jul 2015 19:52
Hi zusammen,

puuuuhhh. :sceptic:
Erst mal herzlichen Dank euch dreien für eure Nachrichten und Mühen.
Ich weiß gar nicht wo ich anfangen soll. Ich habe beide Lösungsvorschläge schon mal ins Programm geschrieben.
Bei der Lösung von Moritz gibt er mir folgende Fehler aus: 'n_PWM' was not declared in this scope.
Bevor ich aber die Codes ausprobiere, möchte ich versuchen zumindest ansatzweise zu verstehen was da passiert. Ich melde mich dann in drei Monaten oder so :wink:
Liebe Grüße
Sabri
Benutzeravatar
sabrikara
Beiträge: 509
Registriert: 25 Feb 2013 20:05
Wohnort: Essen
Bewertungen: 1 (100%)
Beitragvon omega » 07 Jul 2015 22:57
Hi Sabri,

sabrikara hat geschrieben:Bei der Lösung von Moritz gibt er mir folgende Fehler aus: 'n_PWM' was not declared in this scope.

in Moritz' Beitrag ist n_PWM mit
Code word n_PWM;

aber schon deklariert.
Der Datentyp "word" - ein unsigned int - stammt aus Arduino.h.

Grüße, Markus
Benutzeravatar
omega
Beiträge: 2274
Registriert: 12 Sep 2012 20:53
Wohnort: München
Bewertungen: 9 (100%)
Beitragvon sabrikara » 07 Jul 2015 23:16
Hi Markus,

ich hatte nur den ersten Code hinzugefügt, den ohne RTC bzw. halt nur den "Tabellen-Teil". Da Stand das nicht dabei.
Habs jetzt mal hinzugefügt. Fehlermeldung bleibt aus.
Danke.

Code  //60 min Sonnenuntergang
  for(int fadeValue = 0; fadeValue <= 255; fadeValue +=1)
  {
  word n_PWM;
  n_PWM = pgm_read_word(&pwmtable[fadeValue]);
  analogWrite(led, n_PWM);
  delay(14117);
Liebe Grüße
Sabri
Benutzeravatar
sabrikara
Beiträge: 509
Registriert: 25 Feb 2013 20:05
Wohnort: Essen
Bewertungen: 1 (100%)
Beitragvon omega » 08 Jul 2015 00:04
Hi Sabri,

sabrikara hat geschrieben:ich hatte nur den ersten Code hinzugefügt, den ohne RTC bzw. halt nur den "Tabellen-Teil". Da Stand das nicht dabei.

mußt halt noch ein bischen C lernen. Jeder hat mal angefangen. :wink:

Grüße, Markus
Benutzeravatar
omega
Beiträge: 2274
Registriert: 12 Sep 2012 20:53
Wohnort: München
Bewertungen: 9 (100%)
Beitragvon MajorMadness » 08 Jul 2015 08:16
Naja, ist nur grob zusammenkopiert gewesen aus dem Code was ich normalerweise bei der MiniControl Benutzt habe. Da kann mal passieren das ich ne deklaration vergesse oder ein alter Wert noch drin steht. Sry... ;)
sabrikara hat geschrieben:Bevor ich aber die Codes ausprobiere, möchte ich versuchen zumindest ansatzweise zu verstehen was da passiert. Ich melde mich dann in drei Monaten oder so :wink:

Ich versuch dir das mal ansatzweise zu erklären. Mit bisschen Nachschlagen müsstest du es dann verstehen:
Zuerst binde ich die libs ein die gebraucht werden:
#include <Wire.h>
#include <RTClib.h>
#include <avr/pgmspace.h>
#include <WString.h>
Dann deklariere ich ein Objekt für die Uhr:
RTC_DS1307 rtc;
Ich benutze die AVR lib progmem um ein Array in den Falsh speicher unter zu bringen anstelle vom Sram. Const bedeutet dabei das es Konstant ist, also nicht verwendert werden kann. Uint16_t ist der typ, unsinged integers mit 4bit speicher, zahlen zwischen 0 und 65536 (int hat -32768 bis 32767, uint8_t 0 bis 255 = byte):
PROGMEM const uint16_t pwmtable[256] = {
............
};
Dann kommt noch deine Led. Da pins zwischen 1 und 90 sind nehme ich byte, nicht int
byte led = 10;
Ein Struct, damit definiere ich einen eigenen typen, wie int. Vorteil: ein Struct kann mehrere Werte halten die über . angesprochen werden können, also LIGHT.time. Uint32_t = 0-4294967295.
typedef struct {
uint32_t time;
byte level;
} LIGHT;
Hier haben wir eine kleine Funktion die mir umrechnen ermöglicht: aus 3 Zahlen, stunde, minute, sekunde errechnet er die Sekunden. 10:24:40 sind dabei (((10*60)+24)*60)+40 (punkt vor strich gibt es nich :D )=37480
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;
}
Nun kommen wir zur Dimmung bzw Dimmzeiten. Ich habe ein Array, eine Liste, die ein anderes Array hält (Das ist damit mehrere Kanäle gedimmt werden können).
LIGHT ist der typ von oben, light_channels der name wie dein "led" und dann [1]<-eine Liste mit [8] acht werten vom typ LIGHT. { steht für die Liste, das zweite { ist der anfang von [1] und das dritte { sagt, dies ist das LIGHT. beide werte werden durch komma getrennt. Da i9ch die sekunden speichern will benutze ich die funktion von oben zum umrechnen: {get_ts(10, 24,4 0), 0} = {37480 , 0} = {um 10:24:40 , 0% Helligkeit}
// Licht Einstellungen immer paar aus Uhrzeit und % angabe. Je reihe Zahl von LIGHT_VALUES, so viele Reihen wie in LIGHT_CHANEL
LIGHT light_channels[1][8] = {
{{get_ts(0, 1, 0), 0}, {get_ts(10, 0, 0), 0}, {get_ts(11, 30, 0), 100}, {get_ts(19, 0, 0), 100}, {get_ts(20, 0, 0), 0}, {get_ts(21, 30, 0), 0}, {get_ts(23, 30, 0), 0}, {get_ts(23, 32, 0), 0}}
};
Dann das Setup ganz normal...
void setup () {
// declare pin 10 to be an output:
pinMode(led, OUTPUT);
Hier "Starte" ich meine Uhr. Sie wird initialisiert
rtc.begin();
Serial die ausgabe im Monitor...
Serial.begin(9600);
}
Loop wird immer aufgerufen so schnell es geht:
void loop() {
Dies ruft die Uhrzeit ab und speichert sie in verschiedene Variablen die ich später benutzen kann.
rtc.now();
Hier rufe ich die funktion auf die meine dimmung steuert:
setLight();
}
Die Funktion ist eigentlich nonsins. Sie ruft nur eine funktion auf um das Aktuelle PWM zu erhalten und übergibt das an funktion zum dimmen. Sie ist drin da normalerweise in eine rschleife (for) 16 Kanäle gedimmt werden.
void setLight() {
uint16_t c_PWM = PWM_Licht(0);
setLED(led , uint8_t(c_PWM));
}
Hier wird der eigentliche PWM wert geschrieben. Besonderheit ist das ich nicht nur analogWrite benutze sondern den pin An, Aus oder PWM setze.
void setLED(uint8_t channel, uint8_t Value) {

word n_PWM;
Hier wird der lineare wert in logorythmisch umgewandelt:
n_PWM = pgm_read_word(&pwmtable[Value]);
if (n_PWM <= 0) {
digitalWrite(led, LOW);
}
else if (n_PWM >= 255) {
digitalWrite(led, HIGH);
}
else {
analogWrite(led, n_PWM);
}
}
Jetzt wird es spaßig... hier errechne ich wie hell es sein muss:
int PWM_Licht(int lightIndex) {
Zuerst mal ein paar variablen die ich später brauche...
long Max, Min, pwm = 255;
float dimTime, f, p;
float pastSeconds;
uint32_t Start, Ende;
byte oMin, oMax;
Da ich in einer Liste 8 Werte habe (das array) und immer zwischen diesen dimme, suche ich mir zuerst raus wo ich mich grader befinde, also zwischen welchen beiden Zeiten. rtc.daystamp sind die sekunden die vergangen sind seit 0:00:00.
Zuerst der Fall wir befinden uns nach der letzten Zeit, oben 23:32:0 0
if (light_channels[lightIndex][7].time < rtc.daystamp ) {
Dann speichere ich mir wann die dimmung losgehen sollte und bis wann sie geht
Start = light_channels[lightIndex][7].time;
Ende = light_channels[lightIndex][0].time;
und speicher mir von welchem wert zu welchem gedimmt werden soll
oMin = light_channels[lightIndex][7].level;
oMax = light_channels[lightIndex][0].level;
zusätzlich errechne ich die sekunden von 23:32:00 bis jetzt (jetzt wäre 23:58 z.B.)
pastSeconds = rtc.daystamp - Start + 0.5;
und ich errechne wie Lange gedimmt werden soll, 23:32:00 bis 0:01: 0
dimTime = get_ts(24, 0, 0) - Start + Ende;

} else if (light_channels[lightIndex][0].time > rtc.daystamp) {
<-- die Zeile bedeutet es ist VOR der ersten dimmzeit, sonst quasi gleich...
Start = light_channels[lightIndex][7].time; // 22:00-> 79200
Ende = light_channels[lightIndex][0].time; // 4:00-> 1440
oMin = light_channels[lightIndex][7].level;
oMax = light_channels[lightIndex][0].level;

pastSeconds = get_ts(24, 0, 0) - Start + rtc.daystamp + 0.5;
dimTime = get_ts(24, 0, 0) - Start + Ende + 0.5;
} else {
Wenn wir nicht nach der letzten und nicht vor der ersten Zeit sind befinden wir uns irgendwo dazwischen, also z.b. 16:00 nachmittags.
int curIndex = 0;
Ich laufe alle zeiten durch und schau welche noch kleiner ist als grade im moment. 11:30:00 ist kleiner, 19:00:00 größer. Daher wird curIndex bis auf 2 erhöt, dann nicht mehr.
for (byte n = 0; n < 8; n++) {
if (light_channels[lightIndex][n].time < rtc.daystamp) {
curIndex = n;
}
}
Wir wissen also unser Start ist die 2 (dritte Zeit, wir fangen bei 0 an zu zählen), das Ende die 2+1=3. Also Start 11:30:00 und Ende 19:00:00.
Start = light_channels[lightIndex][curIndex].time;
Ende = light_channels[lightIndex][curIndex + 1].time;
Wir müssen von 100% nach 100% dimmen, scheiss beispiel... sagen wir Start Level 11:30 war 20%, Ende 19:00 100%
oMin = light_channels[lightIndex][curIndex].level;
oMax = light_channels[lightIndex][curIndex + 1].level;
dann schauen wir wieviele sekunden bereits seit 11:30 vergangen sind und wieviele Sekunden wir insgesamt dimmen müssen:
pastSeconds = rtc.daystamp - Start + 0.5;
dimTime = Ende - Start;
}
Nun rechnen wir das min/max
Min = (pwm - (pwm * oMin / 100)); 255-(255*20/100)=204
Max = (pwm - (pwm * oMax / 100)); 255-(255*100/100)=0
Wenn beide werte gleich sind können wir aufhören zu rechnen und geben einen davon zurück. (dimmung von 100-100%)
if (Min == Max) {
return Min;
}
Nun rechnen wir richtig los:
wir teilen die Zeitspanne in gleiche teile
f = dimTime / (Max - Min);
Von den teilen wir noch durch die gesamtspanne, wir wissen nun also wieviel wir erhöhen müssen
p = pastSeconds / f;
der PWM wert ist das minimum (20)+ die teile die errechnet wurden
pwm = Min + p;
Durch rundungen kann es passieren das der wert außerhalb von 0 und 255 liegt, daher ändern wir den notfalls.
if (pwm <= 0) {
pwm = 0;
} else if (pwm > 255) {
pwm = 255;
}
alles fertig, dann geben wir den wert zurück an die funktion setLight, diese ruft dann setLED auf und dimmt die Led so wie wir wollen.
return pwm; // Im Nofall ausschalten...
}
Beste Grüße Moritz
Meine Projekte zur Aquariensteuerung:
Bild www.aqua-grow.de
Benutzeravatar
MajorMadness
Beiträge: 1658
Registriert: 06 Aug 2012 10:44
Wohnort: 45145 Essen
Bewertungen: 10 (100%)
Beitragvon sabrikara » 08 Jul 2015 22:41
omega hat geschrieben:Hi Sabri,

sabrikara hat geschrieben:ich hatte nur den ersten Code hinzugefügt, den ohne RTC bzw. halt nur den "Tabellen-Teil". Da Stand das nicht dabei.

mußt halt noch ein bischen C lernen. Jeder hat mal angefangen. :wink:

Grüße, Markus


Hi Markus,

au ja, kommt auf die Liste mit den Dingern, die ich noch zu lernen hab. Die Liste wird immer länger, eventuell schaffe ich es im nächsten Leben die abzuarbeiten.


Hi Moritz,

Danke für deine Mühe.
Liebe Grüße
Sabri
Benutzeravatar
sabrikara
Beiträge: 509
Registriert: 25 Feb 2013 20:05
Wohnort: Essen
Bewertungen: 1 (100%)
Beitragvon sabrikara » 16 Jul 2015 15:38
Hi zusammen,

ich hab jetzt eure Codes doch schon ausprobiert ohne genau zu verstehen, was passiert.

Die Tabelle von Moritz musste ich allerdings etwas umschreiben.
Bei einem PWM-Wert von 0 ist es bei mir hell, bei 255 Dunkel. Zwischen 255 und 244 passiert gar nichts. Die Leds werden erst bei einem Wert von 244 leicht hell und werden dann je niedriger der Wert ist, desto heller. Also kann ich die Zwischenschritte einfach weg lassen. Die Tabelle muss dann bei mir so aufgebaut sein, dass die hohen Werte sich öfter wiederholen und die niedrigen Wert, wenn also die Lampe sehr hell ist und man eh kaum mehr unterschiede sieht, schneller durchläuft werden können. Also 0,1,2,3, ... 242,242,242,243,243,243,244,244,244,255 oder so.

Aber ich muss noch mal ran und hier und da noch probieren.

Markus, dien Sketch habe ich auch probiert allerdings es nicht geschafft ihn zum Laufen zu bringen. Hier ist sicherlich auch das Problem von oben schuld (255 = dunkel, 0 = hell)

Code // fade in
   for( uint16_t i = 0; i < dimIterations; i++)
   {
      pwmLevel = getPWMLevelUp( dimDuration * i / dimIterations);
      analogWrite( PWMPin, maxPWMLevel - pwmLevel);
      delay( dimDuration * 60 * 1000 / dimIterations);


Nur den "Weg" in der for- Schleife umzudrehen (i=0; i > ......., i-- ) reichte nicht. Dann habe ich erst mal aufgegeben aber setze mich demnächst noch mal ran. Muss einfach mal den Code richtig durchgehen und umkehren.


Genau wegen diesen Verwirrungen wäre es mir schon lieber, wenn ich den BUZ11 eventuell mit einem selbstleitendem Mosfet austauschen könnte. Robert hatte einen alternativen Mosfet vorgeschlagen. Der ist aber leider auch selbstsperrend. Oder geht das gar nicht, was mir vorschwebt?
Liebe Grüße
Sabri
Benutzeravatar
sabrikara
Beiträge: 509
Registriert: 25 Feb 2013 20:05
Wohnort: Essen
Bewertungen: 1 (100%)
Beitragvon Mandocello » 16 Jul 2015 23:30
Hi Sabri,

das mit dem selbstleitenden FET ist nicht so einfach, weil der zum sicheren Sperren ein Gatepotential unter Source (also unter Masse) benötigt. Das passt nicht zu Deinem PWM-Signal. Du kannst aber einen zweiten nFET dahinterhängen und das Signal nochmal invertieren. Der Drainwiderstand kann so um die 47kOhm betragen und den legst Du an die 12V-Hilfsspannung von Deinem LCM-40. Wie Robert schon geschrieben hat, tun es auch BS170 oder 2N7000 im kleinen TO-92-Gehäuse.

Viel Erfolg
Uwe

Dateianhänge

Mandocello
Beiträge: 257
Registriert: 05 Jun 2015 10:00
Bewertungen: 2 (100%)
Beitragvon omega » 17 Jul 2015 00:43
Hi Sabri,

sabrikara hat geschrieben:Markus, dien Sketch habe ich auch probiert allerdings es nicht geschafft ihn zum Laufen zu bringen. Hier ist sicherlich auch das Problem von oben schuld (255 = dunkel, 0 = hell)

Code // fade in
   for( uint16_t i = 0; i < dimIterations; i++)
   {
      pwmLevel = getPWMLevelUp( dimDuration * i / dimIterations);
      analogWrite( PWMPin, maxPWMLevel - pwmLevel);
      delay( dimDuration * 60 * 1000 / dimIterations);


Nur den "Weg" in der for- Schleife umzudrehen (i=0; i > ......., i-- ) reichte nicht. Dann habe ich erst mal aufgegeben aber setze mich demnächst noch mal ran. Muss einfach mal den Code richtig durchgehen und umkehren.

daran brauchst Du nichts zu ändern. Die Fade-In-Loop funktioniert (bis auf eine kleine Ausnahme*). Sie übergibt dem analogWrite Werte der folgenden Kurve:
Die Werte beginnen bei 255 (dunkel) und enden bei 1 (*fast ganz hell, müßte man tiefer drin noch fixen, vielleicht findest Du den Fehler allein).
Du kannst ja mal alle 10 Durchgänge einen Wert per Serial.println() auf Deinem Rechner ausgeben. Statt
Code analogWrite( PWMPin, maxPWMLevel - pwmLevel);

müßte es dazu lauten:
Code uint8_t resultingPWMLevel = maxPWMLevel - pwmLevel;

analogWrite( PWMPin, resultingPWMLevel);

if( i % 10 == 0)
    Serial.println( resultingPWMLevel);

Das ist Debuggen für Arme. Mach ich auch so, weil ich noch kein Atmel Studio nutze.

Hat Deine IDE evtl. keine Floating Point Library mitgelinkt und als pwmLevel purzeln nur lauter Nullen bzw. als resultingPWMLevel nur lauter 255en raus? Hab hier Eclipse als IDE, kann Dir diesbezüglich nicht helfen, wenn Du die Arduino IDE oder das Atmel Studio nutzt. Da wissen dann andere mehr.
Mit dem Atmel Studio läßt sich ein Sketch direkt auf dem Nano debuggen. Debuggen bedeutet u.a., ein Programm Befehl für Befehl auszuführen und dabei die Variablen zu beobachten.

Grüße, Markus
Benutzeravatar
omega
Beiträge: 2274
Registriert: 12 Sep 2012 20:53
Wohnort: München
Bewertungen: 9 (100%)
Beitragvon Mandocello » 17 Jul 2015 09:32
Guten Morgen Sabri,

... ich hab da was übersehen. Im Datenblatt vom LCM-40 steht (Seite 4, über der Dimm-Tabelle), dass man DIM- nicht mit -Vo (das ist ja quasi auch die Masse von der 12V Hilfsspannung) verbinden darf.

Also bitte NICHT die +12V vom LCM-40 verwenden.

Du kannst aber die +12V von der Arduino-Versorgung vor dem Regler abgreifen, das sollte dann funktionieren. Oder eben doch die Softwarelösung.

'tschuldigung für die Verwirrung.

Grüße
Uwe

Dateianhänge

Mandocello
Beiträge: 257
Registriert: 05 Jun 2015 10:00
Bewertungen: 2 (100%)
Beitragvon sabrikara » 23 Jul 2015 13:25
Hi zusammen,

Danke Uwe für die Infos.

omega hat geschrieben:Du kannst ja mal alle 10 Durchgänge einen Wert per Serial.println() auf Deinem Rechner ausgeben.


Markus, du bist mein Held. Ich hatte schon überlegt und einiges gelesen darüber, sich den Prozess im 2seriellen-Monitor" ausgeben zu lassen. War mir aber unschlüssig, ob das nicht doch ein größerer Aufwand ist und ich es eventuell nicht hinbekomme.
Danke, werde ich ausprobieren.
Liebe Grüße
Sabri
Benutzeravatar
sabrikara
Beiträge: 509
Registriert: 25 Feb 2013 20:05
Wohnort: Essen
Bewertungen: 1 (100%)
Beitragvon sabrikara » 30 Okt 2015 13:26
Hi zusammen,

ich habs übrigens nicht geschafft mir die Werte im SerialMonitor anzeigen zu lassen. Zumindest nicht mit dem Code von Markus. Irgendwas krieg ich da nicht hin. Aber ist auch nicht weiter schlimm. Diesen Code hab ich jetzt laufen und bisher reicht mir das auch so.

Code int led = 10;

#include <avr/pgmspace.h>

PROGMEM  const uint16_t pwmtable[256] = {
0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,41,42,43,44,45,46,47,48,49,50,52,53,54,55,56,58,59,60,61,63,66,67,69,70,72,73,75,76,78,80,82,83,85,87,89,91,93,95,97,99,102,104,106,109,111,113,116,118,121,124,127,129,132,135,138,141,144,147,151,154,157,161,165,168,172,176,180,184,188,192,196,200,205,209,214,215,216,217,218,219,219,220,220,220,221,221,221,222,222,222,223,223,223,224,224,224,225,225,225,226,226,226,227,227,227,228,228,228,229,229,229,230,230,230,231,231,231,232,232,232,233,233,233,234,234,234,235,235,235,235,236,236,236,236,236,237,237,237,237,237,237,238,238,238,238,238,238,238,239,239,239,239,239,239,239,239,240,240,240,240,240,240,240,240,240,241,241,241,241,241,241,241,241,241,241,242,242,242,242,242,242,242,242,242,242,242,242,243,243,243,243,243,243,243,243,243,243,243,243,243,244,244,244,244,244,244,244,244,244,244,244,244,244,244,244,255

};

void setup () {
  // declare pin 10 to be an output:
 pinMode(led, OUTPUT);
 Serial.begin(9600);
 Serial.println("start"); 
}
 
void loop (){
 
 
  //60 Min Sonnenaufgang
  for(int fadeValue = 255; fadeValue >= 0; fadeValue -=1)
  {
  word n_PWM; 
  n_PWM = pgm_read_word(&pwmtable[fadeValue]);
  analogWrite(led, n_PWM);
  Serial.println(n_PWM);
  delay(14117);
  }

delay(32400000); //8 Studen volles Licht

  //60 min Sonnenuntergang
  for(int fadeValue = 0; fadeValue <= 255; fadeValue +=1)
  {
  word n_PWM;
  n_PWM = pgm_read_word(&pwmtable[fadeValue]);
  analogWrite(led, n_PWM);
  delay(14117);
}

 delay(3600000);

}


Da das jetzt scheinbar läuft will ich nun doch noch bisschen mehr machen und erweitern.
Dafür muss ich erst mal die Uhr anlöten und den Code ändern. Aber das kommt später.
Jetzt hängen an der KSQ die der Arduino per PWM schaltet zwei Licht-Balken. Ein dritter soll dazu kommen. Mit eigenem Netzteil. Könnte ich also genauso aufbauen halt nur ein Licht-Balken dran.

Aber es wäre noch besser, wenn ich den Lichtbalken zumindest zweigeteilt ansteuern könnte. Zwei separate Netzteile will ich aber nicht.
Ich dachte hier könnte ich also statt so eine Meanwell KSQ zu nehmen, so kleine Mini-Dinger nehmen. Z.B. diese Buck-Dinger von Led tech. Beispielsweise hätte ich dann im Leuchtbalken zwei dieser Buck-Dinger integriert, welche mit PWM dimmbar sind. Würde also von meinen Ardunio noch zwei Ausgänge für PWM-Dimmen nehmen. Die Buck-Dinger sollen dann aber zusammen mit einem Stecker an die Stromdose gehen. Funktioniert das? War das überhaupt verständlich?

Danke für eure Hilfe.
Liebe Grüße
Sabri
Benutzeravatar
sabrikara
Beiträge: 509
Registriert: 25 Feb 2013 20:05
Wohnort: Essen
Bewertungen: 1 (100%)
Beitragvon Mandocello » 30 Okt 2015 17:35
Hallo Sabri,

um das Netzteil kommst Du nicht herum, die üblichen "Buck-Dinger" dürfen nicht direkt ans Netz. Allerdings brauchst Du eins mit Spannungsausgang. Gibt es z.B. auch von der gleichen Firma. Weil für Beleuchtungszwecke andere EMV-Normen (Störabstrahlung) gelten, als für Haushaltgeräte, gibt es auch mit Spannungsausgang spezielle für LEDs zugelassene Netzteile.

Ich habe weiter vorn gelesen, dass Du 15 LEDs in Reihe betreibst. Die Hälfte wäre also 8 bzw. 7. Dafür brauchst Du ein Netzteil mit 30V Ausgangsspannung. Oder Du betreibst nur jeweils 7 LEDs, dann reicht ein 24V-NT gerade so. Da hängst Du dann die zwei Buck-Dinger samt LEDs parallel an den Ausgang.

Am besten, Du postest mal die aktuellen Daten von dem zu halbierenden Lichtbalken (Typ und Anzahl der LEDs, gewünschter 100%-Betriebsstrom), dann kann man einen passenden Typ empfehlen.

Grüße
Uwe
Mandocello
Beiträge: 257
Registriert: 05 Jun 2015 10:00
Bewertungen: 2 (100%)
Beitragvon sabrikara » 30 Okt 2015 21:33
Hi Uwe,

das kling doch schon mal gut. Das ist genau das, was ich mir vorgestellt hatte. Ein Netzteil war mir schon klar, wichtig war halt keine weiteres. Zu dem bestehendes Netzteil, halt lediglich einen mehr.
Was ich genau verbauen will, weiß ich noch nicht. Ich hab hier noch ein paar warmweiße, ein oder zwei davon sollen halt zu erst angehen, dann kaltweiße auf dem selben Balken dazu – eventuell diese SmartArrays. Muss gar nicht so viel sein, drei vielleicht.
Und dann halt die anderen beiden Balken dazu dimmen.
Liebe Grüße
Sabri
Benutzeravatar
sabrikara
Beiträge: 509
Registriert: 25 Feb 2013 20:05
Wohnort: Essen
Bewertungen: 1 (100%)
134 Beiträge • Seite 4 von 9
Ähnliche Themen Antworten Zugriffe Letzter Beitrag
Arduino-Aquariumsteuerung?
von kos » 21 Jun 2012 18:32
13 8756 von Ortin Neuester Beitrag
29 Jun 2012 20:26
MeanWell Netzteil
Dateianhang von Diskus79 » 02 Aug 2015 13:31
6 463 von omega Neuester Beitrag
03 Aug 2015 23:24
Wie sind eure Erfahrungen mit 4er Relay für den Arduino
von Ingo79 » 31 Okt 2014 13:50
1 333 von Wuestenrose Neuester Beitrag
31 Okt 2014 15:25
Aquaduino - Arduino powered Aquarium Controller
von NatroN » 05 Jan 2015 15:47
11 2642 von Starmbi Neuester Beitrag
08 Mär 2016 21:34
LED dimmen ?
von Pardu » 30 Nov 2016 22:02
6 464 von Wuestenrose Neuester Beitrag
02 Dez 2016 08:05

Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 7 Gäste