mikrocontroller.net

Forum: Mikrocontroller und Digitale Elektronik suche fertiger PID-regler


Autor: Tom (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
suche ein fertiges pid.c file! kennt ihr etwas, das man irgendwo 
herunterladen kann?

Autor: Starter (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Das wird dir höchstwahrscheinlich nicht viel bringen, kommt darauf an 
was für Eingangs- und Ausgangssignale du hast. PWM? Analog? Wieviel bit? 
AD/DA-Wandler per I²c, SPI, Parallel?

Mit der Berechnung der Stellgröße könnte ich aushelfen, den Rest musst 
du schon selbstanpassen.

In diesem Fall mit Resourcen 'geaast' (double-Variablen), Abtastung alle 
20ms
double PID_Berechnung (double x, double w)
{
e = w - x;  // Regelabweichung ermitteln
y = yalt + (Kp*e) + (I*ealt) + (D*ealt2);  // Reglergleichung
if (y > 1023)    // Stellgröße auf 0..1023 begrenzen (10 bit PWM)
 {
  y = 1023;
 }
if (y < 1)
 {
  y = 0;
 }
ealt2 = ealt;    // Regelabweichungs-Historie zuweisen
ealt = e;
yalt = y;    // Stellgrößen-Historie zuweisen
  
return y;    // Stellgröße zurückgeben
}
e => Regelabweichung
w => Sollwert
x => Istwert
y => Stellgröße
Kp => Proportionalverstärkung
I => Integralverstärkung
D => Differentialverstärkung

Der Schnipsel ist für die Ausgabe über 10-bit-PWM geschrieben und 
funktioniert prima.

Autor: Dieter Werner (dds5)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Wo ist denn beim D-Anteil die Differenz?

Es sollte m.E. heissen
ealt2 = e - ealt;    // Differenz der Regelabweichungen


Sonst wird der D-Anteil ja nicht 0 bei konstantem e.


EDIT

Und beim Integral ist ja eine Aufsummierung der delta e notwendig.

Autor: Starter (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
ealt und ealt2 werden mit den jeweiligen Differential- und 
Integralverstärkungen multipliziert, das Ganze bezieht sich jeweils nur 
auf die letzten zwei Messwerte.
Der D-Anteil ist auch niemals 0, nur wenn die Regelabweichung über 
längere Zeit genau null ist.

Autor: Dieter Werner (dds5)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Dann erklär mir doch bitte einmal wie der Term (D*ealt2) zu Null werden 
soll, da ealt2 ja immer die zweitletzte Regelabweichng ist.

Autor: Starter (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
D*ealt2 wird niemals null, nur wenn der Sollwert null ist. Wie soll denn 
ein Motor/Lüfter/Pumpe o.Ä. laufen, wenn keine Ansteuerung erfolgt? Eine 
gewisse Stellgröße braucht jedes Stellglied, um einen Sollwert zu 
halten.

Die Stellgröße y setzt sich ja aus den drei Anteilen zusammen.

Autor: Starter (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ach ja: die Quelle von dat janze:
http://www.roboternetz.de/wissen/index.php/Regelun...

Autor: Dieter Werner (dds5)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Danke für den Quellenhinweis, nur tauchen die dort genannten 
Rechenschritte

esum = esum + e
y = Kp * e + Ki  Ta  esum + Kd * (e – ealt)/Ta
ealt = e

nur bruchstückhaft und verstümmelt in dem Programm im ersten Post auf.

EDIT
Ich meinte natürlich im ersten Antwortpost.

Autor: Joerg K. (sirfrancisdrake)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Also vor geraumer Zeit habe ich hier ein wenig dazu erklärt. Habe die 
Beiträge oben kurz überflogen. Ich glaube auch, dass der Quelltext oben 
nicht ganz richtig ist. Also hier ersteinmal für die Interessierten...

Beitrag "Re: PID- Regler"

Autor: 2921 (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ich denke, wenn man das Thema PID Regler nicht gerafft hat, sollte man's 
eh seinlassen. Und wenn man's gerafft hat, sind die paar Zeilen in ein 
paar Minuten geschrieben.

Autor: Thomas (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Und ich denke, dass jeder einen PID-Regler einsetzen kann, ganz gleich 
ob er ihn verstanden hat oder nicht. Ist wie beim Autofahren, das kann 
auch jeder...

Autor: THM (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
@ Starter:
Ich habe mir elaubt, den Code vom obigen Antwortposting anzupassen:
double PID_Berechnung (double x, double w)
{
e = w - x;         // aktuelle Regelabweichung bestimmen
esum = esum + e;   // Summe der Regelabweichung aktualisieren
y = (Kp*e)+(I*Ta*esum)+(D*((e-ealt))/Ta);  // Reglergleichung
ealt = e;          // Regelabweichung für nächste Abtastung merken
if (y > 1023)      // Stellgröße auf 0..1023 begrenzen (10 bit PWM)
  {
    y = 1023;
  }
if (y < 1)
  {
    y = 0;
  }
return y;          // Stellgröße zurückgeben
}
mit
Ta = 0.02 (20ms)
Kp = 18
I  = 16
D  = 0.05

regelt mein Lüfter sauber, schnell und ruhig, ohne großes Zappeln der 
Stellgröße.
Ich bitte um Korrektur, falls ich auf die Schnelle was vergessen habe!

Autor: JÜrgen Grieshofer (Firma: 4CKnowLedge) (psicom) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Also wieso der Double Datentyp?

Braucht meiner Meinung nach einfach zu viel Rechenleistung!! Da ist man 
mit Int auch leicht bedient!


Ausserdem würde ich für den I-Anteil eine Anti-Windup Maßnahme setzen!

Autor: Dieter Werner (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Für die Regelung einer Lüfterdrehzahl kann man auf den D-Anteil locker 
verzichten, das brauchts nur bei dynamischen Vorgängen wie Positions- 
oder Lageregelung mit Motoren.

Autor: THM (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
@ JÜrgen G.:
Stimmt schon mit den doubles. Habe ich von oben übernommen, da es nicht 
auf die Rechenleistung ankommt (16MHz, mega32) kann ich die schon 
nehmen. Bei int muss man die Überläufe abfangen (vermeiden), da kommt 
dann auch noch Rechenleistung dazu.
Was meinst du mit Anti-Windup-Maßnahme? Kannst du das Beispiel damit 
ausstatten?

@ Dieter Werner:
Haste Recht. Ich habe grade einen Lüfter mit Reflexkoppler da gehabt, 
darum habe ich den benutzt. Den D-Anteil kann man problemlos weglassen.

Autor: THM (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
OK, hab selber mal gegoogelt. Wird wohl auf AWR (Anti-Windup-Reset) 
'rauslaufen. Werde mich mal dransetzen.
Hier noch ein recht übersichtlicher Link zum Thema:
http://www.energietechnik.fh-dortmund.de/personen/...

Autor: JÜrgen Grieshofer (Firma: 4CKnowLedge) (psicom) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Anti Windup meint eigentlich nur den I-Anteil "einfrieren" wenn er über 
die Aussteuerungsgrenzen des Reglers kommt.

Ich hab mir die Website durchgelesen -> kommt auf AWR hin!


Das Problem ohne AWR: Der I-Anteil integriert immer weiter auf, auch 
wenn der Regler auf Anschlag steht, bis das der Datentyp erschöpft ist. 
Wenn jetzt allerdings eine Änderung im System ist, muss der ganze 
I-Anteil wieder runter gerackert werden, bis das er überhaupt mal zu 
Aussteuerungsgrenze kommt und dann erst für den Ausgang wirksam zu 
sinken beginnt...

http://virtual.cvut.cz/dynlabmodules/ihtml/dynlabm...

kleine Demonstration was ohne WindUp-Maßnahme sein kann.



Bei dem obigen Source wurde zwar der gesamte Ausgang begrenzt allerdings 
der I-Anteil nicht "vereist" ^^

Autor: Nixvielwissen (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Wie sollte man dann den Sourcecode ändern, um den I-Anteil einzufrieren?

Autor: 2921 (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Na, sobald das Ausgangssignal, aka Stellgroesse, an das Limit kommt, 
wird nicht mehr weiter integriert.

Autor: JÜrgen Grieshofer (Firma: 4CKnowLedge) (psicom) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Nixvielwissen wrote:
> Wie sollte man dann den Sourcecode ändern, um den I-Anteil einzufrieren?


Schon mal C programmiert?

Autor: THM (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
double PID_Berechnung (double x, double w)
{
e = w - x;         // aktuelle Regelabweichung bestimmen
esum = esum + e;   // Summe der Regelabweichung aktualisieren
y = (Kp*e)+(I*Ta*esum)+(D*((e-ealt))/Ta);  // Reglergleichung
ealt = e;          // Regelabweichung für nächste Abtastung merken
if (y > 1023)      // Stellgröße auf 0..1023 begrenzen (10 bit PWM)
  {
    y = 1023;
    Itemp = I;         // I merken
    I = 0;             // nicht weiter integrieren
    return y;          // Stellgröße zurückgeben
}
  }
else
  {
    I = Itemp;
  }
if (y < 1)
  {
    y = 0;
    Itemp = I;         // I merken
    I = 0;             // nicht weiter integrieren
    return y;          // Stellgröße zurückgeben
}
  }
else
  {
    I = Itemp;
  }
return y;          // Stellgröße zurückgeben
}
Itemp muss zu Anfang natürlich mit dem Wert von I initialisiert werden.
Sollte das Problem beheben, oder?

Autor: THM (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Upps.. so natürlich nicht!
double PID_Berechnung (double x, double w)
{
e = w - x;         // aktuelle Regelabweichung bestimmen
esum = esum + e;   // Summe der Regelabweichung aktualisieren
y = (Kp*e)+(I*Ta*esum)+(D*((e-ealt))/Ta);  // Reglergleichung
ealt = e;          // Regelabweichung für nächste Abtastung merken
if (y > 1023)      // Stellgröße auf 0..1023 begrenzen (10 bit PWM)
  {
    y = 1023;
    I = 0;             // nicht weiter integrieren
    return y;          // Stellgröße zurückgeben
}
  }
else
  {
    I = Itemp;
  }
if (y < 1)
  {
    y = 0;
    I = 0;             // nicht weiter integrieren
    return y;          // Stellgröße zurückgeben
}
  }
else
  {
    I = Itemp;
  }
return y;          // Stellgröße zurückgeben
}
So wir deher 'n Schuh draus. ;)

Autor: THM (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
OK, hab's getestet. So geht's nicht. Werde weitertesten.

Autor: JÜrgen Grieshofer (Firma: 4CKnowLedge) (psicom) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Meine Meinung wär ja sowieso die einzelnen Elemente einzeln zu errechnen 
und dann zu addieren! So kann man sich die Einzelnen Begrenzungen besser 
ansehen & Maßnahmen setzen!



Ich such ma Quellcode... Vllt liegt irgendwo einer rum...


EDIT:

http://www.mstarlabs.com/apeng/techniques/pidsoftw.html

Hier ist der Algo in eine Klasse gepackt... ein wenig umschreiben und 
dann geht...

Autor: THM (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ok, ich habe hier die Aufintegration der Regelabweichung bei 
übersteuerten Stellglied eingefroren. Fonktioniert auch soweit ...
double PID_Berechnung (double x, double w)
{    
e = w - x;                  // aktuelle Regelabweichung bestimmen
if ((y <= 1023)&&(y >= 0))
  {
    esum = esum + e;        // Summe der Regelabweichung aktualisieren  
  }
y = (Kp*e)+(I*Ta*esum)+(D*((e-ealt))/Ta);  // Reglergleichung
ealt = e;                   // Regelabweichung für nächste Abtastung merken
if (y > 1023)               // Stellgröße auf 0..1023 begrenzen (10 bit PWM)
  {
    y = 1023;
  }
    if (y < 1)
  {
    y = 0;
  }
return y;
}
Die einzelnen Anteile getrennt zu berechnen ist sicher die bessere 
Lösung.

Autor: THM (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
So jetzt mal ein positives Ergebnis:
double PID_Berechnung (double x, double w)
{    
e = w - x;                  // aktuelle Regelabweichung bestimmen
if ((y < 1023)&&(y > 0))
  {
    esum = esum + e;        // Summe der Regelabweichung aktualisieren  
  }
y = (Kp*e)+(I*Ta*esum)+(D*((e-ealt))/Ta);  // Reglergleichung
ealt = e;                   // Regelabweichung für nächste Abtastung merken
if (y > 1023)               // Stellgröße auf 0..1023 begrenzen (10 bit PWM)
  {
    y = 1023;
  }
    if (y < 1)
  {
    y = 0;
  }
return y;
}
Hab's getestet, funktioniert prima! :)

Autor: JÜrgen Grieshofer (Firma: 4CKnowLedge) (psicom) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
unsigned int PID_Berechnung (double x, double w)
{
    
e = w - x;                  // aktuelle Regelabweichung bestimmen

if ((integ <= 1023)&&(integ >= 0))
  {
    esum+=e;        // Summe der Regelabweichung aktualisieren  
  }

prop = (Kp*e);   // Proportional Faktor
integ = (I*Ta*esum); // Integraler Anteil
diff = (D*((e-ealt))/Ta);   // Differenzieller Anteil
ealt = e;                   // Regelabweichung für nächste Abtastung merken
y = prop + integ + diff;    // Ausgangsstellgröße

if (y > 1023)               // Stellgröße auf 0..1023 begrenzen(10 bitPWM)
  {
    y = 1023;
  }
    if (y < 1)
  {
    y = 0;
  }
return y;              // unsigned int weil y nur zwischen 0 und 1023
}


So falls Fehler drinne sind melden ^^

Habs nur ein wenig leichter gemacht... In Bezug auf Aufteilung... Vllt 
optimier ich den Code auch noch ein wenig...

EDIT:
@THM: Wenn du wie e Begrenzung durch y machst, kann der I-Anteil nicht 
wirken, während der D-Anteil voll aufdreht... Deswegen NUR das integral 
begrenzen ^^

Autor: THM (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ich habe bei übersteuertem Stellglied nur esum eingefroren. Dadurch kann 
nicht mehr integriert werden. Die anderen Parameter bleiben davon 
unberührt.
Ich hab's auf meiner Hardware laufen, der Unterschied zu vorher ist 
Welten besser! :)

Autor: JÜrgen Grieshofer (Firma: 4CKnowLedge) (psicom) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
THM wrote:

> Ich hab's auf meiner Hardware laufen, der Unterschied zu vorher ist
> Welten besser! :)


Immer gern xP

WENN REGELEN dann RICHTIG ^_^


So aber nun zur Optimierung... Die Datentypen gefallen mir nicht 
wirklich... Ich hab doch nur einen 10bit AD-Wandler also zurück zu 
signed INT (16bit)

Autor: THM (Gast)
Datum:
Angehängte Dateien:

Bewertung
0 lesenswert
nicht lesenswert
>Die Datentypen gefallen mir nicht
Jo, mir auch nicht! ;) Das kommt als nächstes.

Zur Visualisierung mal den Unterschied des Regelverhaltens.
In diesem Bild OHNE anti-Windup.

Grün => Stellgröße
Rot => Sollwert (70 Hz)
Weiß => Istwert

Der Lüfter gibt eine Frequenz von 0 bis max 140 Hz zurück

Autor: THM (Gast)
Datum:
Angehängte Dateien:

Bewertung
0 lesenswert
nicht lesenswert
Und hier MIT anti-Windup.

Autor: THM (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Achso, zur Erklärung:
Ich ahbe den Lüfter für ca. 2s angehalten und wieder losgelassen. Im 
Bild mit anti-Windup sieht man, dass der 1. Überschwinger deutlich 
kleiner ist. Ohne Anti-Windup wird er umso größer, je länger ich den 
Lüfter anhalte.

Autor: JÜrgen Grieshofer (Firma: 4CKnowLedge) (psicom) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert

// W, X, Y in INT  - Eingänge mit Vorzeichen
// interne Variablen sollten dennoch in double gehalten werden (Gleitkommadarstellung)

unsigned int PID_Berechnung (signed int x, signed int w)
{
    
e = w - x;                  // aktuelle Regelabweichung bestimmen

if ((integ <= 1023)&&(integ >= 0))
  {
    esum+=e;        // Summe der Regelabweichung aktualisieren  
  }

prop = (Kp*e);   // Proportional Faktor
integ = (I*Ta*esum); // Integraler Anteil
diff = (D*((e-ealt))/Ta);   // Differenzieller Anteil
ealt = e;                   // Regelabweichung für nächste Abtastung merken
(unsigned int) y = prop + integ + diff;    // Ausgangsstellgröße

if (y > 1023)               // Stellgröße auf 0..1023 begrenzen(10 bitPWM)
  {
    y = 1023;
  }
    if (y < 1)
  {
    y = 0;
  }
return y;              // unsigned int weil y nur zwischen 0 und 1023
}


Autor: THM (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Sieht doch schon besser aus ;)
nur glaube ich dass
if ((integ <= 1023)&&(integ >= 0))
nicht funtioniert, da sonst die nachfolgende Begrenzung der Stellgöße 
diese Bedingung immer erfüllt.
Besser wäre
if ((integ < 1023)&&(integ > 0))
oder hast du's schon ausprobiert?

Autor: Sven (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> (unsigned int) y = prop + integ + diff;    // Ausgangsstellgröße

Sorry, müsste das nicht

y = (unsigned int)(prop + integ + diff);

heissen ?

Ich lerne gerne dazu....

Gruß Sven

Autor: JÜrgen Grieshofer (Firma: 4CKnowLedge) (psicom) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Sven wrote:
>> (unsigned int) y = prop + integ + diff;    // Ausgangsstellgröße
>
> Sorry, müsste das nicht
>
> y = (unsigned int)(prop + integ + diff);
>
> heissen ?
>
> Ich lerne gerne dazu....
>
> Gruß Sven


sorry... stimmt... wollen ja ANSI C proggen... geht nur in C++ !!!


@THM: Das stimmt schon so... Ich muss ja das ganze "Spektrum" vom 
I-Anteil ausnützen können... und ich fange mit 0 an -> also integ<=0


Ich probiere nicht aus, weil ich keinen µC grad bei der Hand hab -> muss 
ja so auch gehn ^^

Autor: THM (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
>Ich probiere nicht aus, weil ich keinen µC grad bei der Hand hab
Aber ich! :)

Mit größer-gleich geht's nicht. Mit größer schon.

Das Problem ist, wie erkenne ich ob der Ausgang übersteuert ist (z.B. 
1028) oder ob er bei genau 1023 ist. Das geht nur, wenn ich ein Bit 
abziehe. Darum der 'größer', bzw. 'kleiner'-Verleich anstatt >=, bzw <=.

Autor: JÜrgen Grieshofer (Firma: 4CKnowLedge) (psicom) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Wie iniitierst du denn das ganze?

integ muss 0 gesetzt werden sonst nimmt das einen bullsh** an...

Also es muss bei 0 genauso funktionieren deshalb ja integ<=0




Ja, also probiern hat seinen Wert ^^
Bin nich zuhause - also µC-los heul

Autor: THM (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
>Wie iniitierst du denn das ganze?
Kp = 18;
I = 12;
D = 0;
w = 50;
Den ganzen Rest mit 0.

Also esum ist ja das Element, das integriert wird. Wenn ich dieses 
einfriere, also den Wert bei überschreiten der Übersteuergrenze (0 und 
1023) halte (nicht 0 setzen!), dann bleibt esum außerhalb der 
Übersteuergrenzen auf einem konstanten Wert und der Regler 'fängt' sich 
bei Rückkehr in den Regelbereich an dem Punkt wieder, an dem das 
Stellglied übersteuert wurde. Von dort arbeitet er wieder korrekt.
Wenn du integ auf 0 setzt fängt das ganze furchtbar an zu schwingen, 
sobald einmal die Übersteuergrenze überschritten war.

Autor: JÜrgen Grieshofer (Firma: 4CKnowLedge) (psicom) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ok, d.h. wir belassen es bei den bisherigen Werten... Du hast ja nicht 
mal einen D-Anteil drinnen - hat das einen besonderen Grund?

Autor: THM (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Jo, den D-Anteil brauche ich beim Lüfter nicht, das macht nur die 
Stellgröße 'hibbelig'.

Autor: JÜrgen Grieshofer (Firma: 4CKnowLedge) (psicom) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Naja, D-Anteil kann das wahre Wunder bringen... Allerdings auch sehr 
gefährlich werden ^^


// W, X, Y in INT  - Eingänge mit Vorzeichen
// interne Variablen sollten dennoch in double gehalten werden (Gleitkommadarstellung)

unsigned int PID_Berechnung (signed int x, signed int w)
{
    
e = w - x;                  // aktuelle Regelabweichung bestimmen

if ((integ < 1023)&&(integ > 0))
  {
    esum+=e;        // Summe der Regelabweichung aktualisieren  
  }

prop = (Kp*e);   // Proportional Faktor
integ = (I*Ta*esum); // Integraler Anteil
diff = (D*((e-ealt))/Ta);   // Differenzieller Anteil
ealt = e;                   // Regelabweichung für nächste Abtastung merken
y = (unsigned int)(prop + integ + diff);    // Ausgangsstellgröße - casten auf unsigned int

if (y > 1023)               // Stellgröße auf 0..1023 begrenzen(10 bitPWM)
  {
    y = 1023;
  }
    if (y < 1)
  {
    y = 0;
  }
return y;              // unsigned int weil y nur zwischen 0 und 1023
}


So jetzt mal der fertige Regler... THM - bitte noch mal drübersehn... 
und dann ab in die Codesammlung ^^

Autor: THM (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
>und dann ab in die Codesammlung ^^

Da isser schon :-)

Autor: JÜrgen Grieshofer (Firma: 4CKnowLedge) (psicom) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ok schon gesehen ^^

Von Thomas sind dort auch ein paar SEHR interessante Aspekte bezüglich 
Optimierung gekommen...


Vllt teilen wir das ganze in PID_init und in PID_cyclic od. so... Damit 
man sich dann wirklich keine Sorgen machen muss und sonst noch was "dazu 
pfuschen"...

Autor: THM (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Gute Idee, lass' dich nicht aufhalten ! ;)

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.