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":n3ih9h9h schrieb:
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
)=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...
}
