Lichtregelung mithilfe von mikrocontroller aufbauen

[Patrick (Gast)]

Hallo Community,

bin erst seid kurzem auf dem Gebiet Mikrocontroller unterwegs und 
brauche Hilfe.


Zu meinem Problem:

Die Lichtregelung soll so funktionieren:

Sollwert (SW) soll vorgegeben werden. Ein analoger Lichtsensor erfasst 
das Licht einer LED-Beleuchtung. Ermittelt hiermit einen Istwert (ISTW). 
Durch bilden eines Zwischenwertes (e) soll dann die Soll-Ist-Abweichung 
errechnet werden. Dieser Wert wird dann mit dem Stellwert (Stellw) 
addiert und an die Beleuchtung gesendet.

----------------------------------------------------------
Mein Ansatz wäre wie folgt: ( in C geschrieben)

e = SW - ISTW;
Stellw = Stellw + e;

----------------------------------------------------------


MFG Patrick

[Wolfgang (Gast)]

Und was ist deine Frage?

Probier's einfach aus.

[Marc V. (Firma: Vescomp) (logarithmus)]

Patrick schrieb:
> e = SW - ISTW;
> Stellw = Stellw + e;

 Und die sind definiert als was ?

[Patrick (Gast)]

@Wolfgang: Probiert hab ich es, jedoch blieb mein Erfolg aus.

Mein Sensor hat einen Wertebereich von 0... 4095 und bringt mir auch 
Werte abhängig von der Helligkeit mit der er bestrahlt wird.

Sollwert geb ich als Fixwert (z.B. 2000) vor.



Wenn ich den Code in mein Hauptprogramm einfüge wird der Stellwert immer 
so groß wie der Sollwert, allerdings hat der Sensor (ISTW) gar keinen 
Einfluss.
D.h. wenn ich meine Hand zwischen Beleuchtung und Sensor halte verändert 
sich die Helligkeit der Beleuchtung nicht.


@Marc: Definiert sind alle als int-Zahlen.

[Patrick (Gast)]

Der analoge Sensor wird per AD-Wandlung zu einem Digitalwert ( 0 ... 
4095 ) gewandelt

[Der_Dicke82 (Gast)]

der ganze Code wäre da mal hilfreich ;-)

Gruß, Stefan

[c-hater (Gast)]

Patrick schrieb:

> Mein Ansatz wäre wie folgt: ( in C geschrieben)
>
> e = SW - ISTW;
> Stellw = Stellw + e;

Nun, da fehlt nur nuch eine Kleinigkeit, dann hast du erstmal einen 
klassischen P-Regler gebaut.

Wobei man diese Kleinigkeit auch implizit in der Generierung des ISTW 
verstecken kann. Bloß ist es sehr viel handlicher, das Verhalten der 
Regelung anpassen zu können, ohne jedesmal die Signalaufbereitung 
anfassen zu müssen. Deswegen besser diese Variante mit der bewußten 
Kleinigkeit:

> e = SW - ISTW;
> Stellw = Stellw + Kp * e;

Die hat dann nämlich noch den Vorteil, sie leicht zu einem vollständigen 
PID-Regler aufrüsten zu können.

[Martin S. (led_martin)]

@c-hater (Gast):

in den zitierten Codefetzen müsste man aber nicht Kp ergänzen, sondern 
Ki, mit Stellw = Stellw + e wird ja bei jedem Rechendurchlauf 
aufaddiert, das ist ein reiner I-Regler.

P-Regler sieht so aus: Stellw = Kp * e

(Vorrausgesetzt, Stellw wird nicht an anderer Stelle im Programm, bei 
jedem Durchlauf, auf einen festen Wert gesetzt.)

Mit freundlichem Gruß - Martin

[Zur Höxxxx mit Flanders (Gast)]

Patrick:

wie machst du denn die LED dunkler und heller? Mittels PWM?
Dann brauchst du einen Tiefpass, der die Helligkeit mittelt oder einen 
Sensor der schon Tiefpassverhalten hat.

[Patrick (Gast)]

Der Stellwert wird im Programm fest vorgegeben.

Der Tipp mit Stellwert = Stellwert + kp * e werde ich testen.

Das Licht wird über ein Schaltnetzteil raelisiert, da eine Regelung mit 
PWM zum schwingen neigt.


Danke schonmals für die Tipps :D echt top

[Karl H. (kbuchegg)]

Patrick schrieb:
> Der Stellwert wird im Programm fest vorgegeben.
>
> Der Tipp mit Stellwert = Stellwert + kp * e werde ich testen.
>
> Das Licht wird über ein Schaltnetzteil raelisiert, da eine Regelung mit
> PWM zum schwingen neigt.
>
>
> Danke schonmals für die Tipps :D echt top

Zeig mal dein Programm als ganzes.
Da liegt sicher noch mehr im argen.


Im übrigen kann man eine derartige Regelung, an die keine besonders 
hohen Ansprüche gestellt werden, auch nach dem Muster aufbauen:

  forever {
    wenn zu dunkel
      dann mach ein wenig heller

    wenn zu hell
      dann mach ein wenig dunkler
  }