Beleuchtung Dimmen nach Zeit

[Michi (Gast)]

Hi,

Wie kann ich das machen: Ich habe eine Beleuchtung mit PWM steuerbar. Es 
kann die Helligkeit mit 8 Bit also 0-255 eingestellt werden.

Jetzt soll die Beleuchtung immer in gleicher Zeit bis zur Dunkelheit 
gedimmt werden (Beispiel 5 sec.).

Wenn man alle 10 msec oder so eins abzieht, ist bei Helligkeit 100 ja 
doppelt so schnell dunkel wie bei Helligkeit 200. Wie kann man es so 
machen, dass es immer gleich lang dauert egal wie hell?

Danke für die Mithilfe!


Michi

[ängstlicher (Gast)]

Wert alle x ms mit einem konstanten Faktor <1 multiplizieren 
(zumindestens theoretisch).

[ängstlicher (Gast)]

Jetzt wo ich nochmal darüber nachgedacht habe: Kommando zurück, so geht 
es nicht. Sry.

Dann bleibt wohl nur ausrechnen wie viel man jeweils abziehen muss.

[dumdidum (Gast)]

Teile deinen Helligkeitswert durch die Zeit-Intervalle in denen du 
dimmen willst und dann zieh das Schritt für Schritt ab?

Oder habe ich gerade einen Denkfehler?


Also alle 100 ms dimmen auf 5s gesamt hieße: 50 Schritte

von 250 (Helligkeit) auf Null musst du eben dann 250 / 50 = 5 pro 100ms 
abziehen und von 100 auf Null musst du eben dann 100 / 50 = 2 pro 100ms 
abziehen ... nicht?

P.S.: Es ist spät, ich bin ziemlich fertig, kann sein, dass das grad 
großer Müll ist, aber für mich macht es im Moment gerade Sinn so...

[Karl H. (kbuchegg)]

dumdidum schrieb:

> von 250 (Helligkeit) auf Null musst du eben dann 250 / 50 = 5 pro 100ms
> abziehen und von 100 auf Null musst du eben dann 100 / 50 = 2 pro 100ms
> abziehen ... nicht?

Schon.
Das Problem kommt, wenn sich die Zahlen eben nicht so schön ausgehen.

Dann würd ich so vorgehen:
Prinzipiell genau gleich ausrechnen, nur dass ich dann mit dem Inkrement 
wieder zurückrechne und die 100ms korrigiere, so dass die Differenz 
minimal wird.

Oder aber man setzt einen Bresenham auf das Problem an.
Die eine Achse ist die Zeit, die andere Achse ist die 
Helligkeitsdifferenz.

[Nonlineares Wesen (Gast)]

Der Trick beim Dimmen, Lautstärke regeln etc.. ist, die nonlineare 
Wahrnehmung abzubilden. Wenn Du immer nur einen Wert abzählst, sieht es 
so aus, als würde es Anfangs langsam und dann immer schneller dunkel 
werden.
Deshalb ist es für das Empfinden angenehmer/natürlicher, wenn der Wert 
schrittweise mit einem Faktor 0 < x < 1 multipliziert wird, wobei die 0 
nur bei beliebig genauen reelen Zahlen nicht erreicht werden würde, in 
der Praxis aber definierbar schnell erreicht wird.
Ich denke, das ganze ist mit Integers abbildbar.

Schau einfach, nach wie vielen Schritten Du von einem Standardwert (z.B. 
1000) auf 0 kommst, wenn Du ihn immer wieder mit 1000 multiplizierst und 
durch 1024 teilst:

#include <stdio.h>

int main(int argc, char** argv)
{
        int i, n;
        i = 1000;
        for (n = 0; i > 0; ++n)
        {
                i *= 1000;
                i /= 1024;
                printf ("%d: %d\t", n, i);
        }
}

gibt aus:
0: 976  1: 953  2: 930  3: 908  4: 886
...
153: 4  154: 3  155: 2  156: 1  157: 0

Bei einem Standardwert von 1000 hast Du also 158 Schritte bis zur 0. Die 
kannst Du jedesmal live ausrechnen oder in einer Tabelle ablegen, ist 
Geschmackssache und eine Frage des freien Speichers.

Der Gag ist, dass Du das Abdimmen dadurch machst, dass Du den jeweiligen 
Wert errechnest:
Aktueller Wert = (Startwert * aktueller Faktor) / 1000

[Michi (Gast)]

Vielen Dank für die Tipps!

Ich wollte gar nicht erst fragen wegen nicht-linearem Ablauf usw. Linear 
erschien mir schon kompliziert genug. Aber mit den Informationen schaffe 
ich es nun, mir das Programm zurecht zu schreiben.

Ihr seid super!