Någon som kan förklara integrerade delen på PID-regulator?

[Al_Bundy]

Hej!

Jag behöver ett praktiskt exempel hur I-delen i en PID regulator fungerar.
Mina frågor är: Måste jag dra integralen från 0 till t där t kan vara flera hundra sekunder?

Eller kan jag integrera en liten del av felvärdet?

[Icecap]

Sättet jag gör det på är att - med fasta intervaller - ta en viss del av felet och summera i integrationsvariabeln.

Detta betyder att när en PID-reglering är "i mål" är P-värdet 0, D likaså och allt output är I.

[Al_Bundy]

Okej!

Typ så här?



Hur menar du summera det i integrationsvariabeln?
Jag kan mäta vid en punkt och samtidigt ta ut en tid när jag mäter punkten. Då kan jag ta arean av denna stabel igenom att ta dåvarande felvärde gånger tiden mellan dåvarande felvärde och nuvarande felvärde. Hoppas jag har tänkt rätt för jag tänker räkna ut en areastabel.



Så allt jag behöver göra är att summera dessa stablar och dela dessa med 1/Ti ?
Kan en ATmega328 klara av detta?

[Icecap]

Jag är inte matematiker så det du dillrar om är jag inte med på. Min PID-styrning på pannan fungerar dock perfekt ändå.

Och jag har en variabel som jag adderar en procentdel av differensen till vid varje regleringstillfälle. Innehållet i variabeln står kvar och används bara för detta ändamål.

När jag har räknat ut P-resultatet (använder inte D) adderar jag P-resultatet med I-resultatet och jag har summa-resultatet.

Jag gör detta på en 16 bitars Fujitsu µC och jag känner mig mycket säker på att själv en ATmega klarar detta - förutsatt att programmet skrivs korrekt.

[Al_Bundy]

Okej.

Jo jag har tänkt ut en smart del jag också!

Kod: Markera allt

// globala
float e_before;
long T1; 

static int U_pump(float PHar, long *T2_point)
      {
        float e = PHbor - PHar;                                              // Wrong value
        byte Td = 5;                                                         // Td value 
        byte Ti = 3;                                                             // Ti value
        long T2 = *T2_point;                                                 // a pointer 
        int sumIntegral += e_before*(T2-T1);
        if (e <=0)
        {
          sumIntegral = 0;                                                 // nollställa när felvärde är 0 eller över 0.
        }
        double PH_voltage = K*(e + Td*(e-e_before)/(T2-T1) + (1/Ti)*sumIntegral);                 // PID-regulator 
        
        e_before = e;                                                        // save PHar as PHbefore for next loop
        T1 = T2;  
      }

[Al_Bundy]

Men jag förstår inte direkt teorin i just I-delen. När t.ex temperaturen sjunker så ökar felvärdet. Om börvärde är lika mycket som ärvärdet så är felvärdet e = 0. Men om ärvärdet ökar från börvärdet så ökar även e och då hade jag tänkt att då börjar man bygga och summera upp en area som man adderar i en variabel.

Men arean blir bara större och större hela tiden. Tänk om felvärdet e är 0.01 och den totala areasumman är 10000000000. Är det så att arean måste bli större och större och större för att eliminera detta felvärde på 0.01 ?

[Nerre]

Både P, I och D i en PID-regulator är ju FELET.

En P-reglering är ju felet gånger en konstant. Ju mer är-värdet närmar sig bör-värdet desto mindre blir felet och därmed blir styrsignalen mindre. Det innebär att är-värdet i princip aldrig kommer att uppnå bör-värdet.

Ett diskret exempel, BÖR-värdet är 10 och ÄR-värdet noll, P-konstanten är 0,5.

Felet är först 10, utsignalen blir 5, ÄR-värdet blir alltså 5
Felet är då 5, utsignalen blir 2,5, ÄR-värdet blir 7,5
Felet är då 2,5; utsignalen blir 1,25; ÄR-värdet blir 8,75
Felet är då 1,25; utsignalen blir 0,625; ÄR-värdet blir 9,375
osv

Med I-reglering så lägger vi på en del av integralen på utsignalen. Integralen är hela tiden baserad på summan av alla föregående fel.

Vi tar samma exempel, I-faktorn är 0,1.

Felet är först 10, P-delen blir 5 (0,5 * 10), integralen blir 10, I-delen blir 1 (10 * 0,1), utsignalen blir 6, ÄR-värdet blir 6
Felet är då 4, P-delen blir 2, integralen blir 14, I-delen blir 1,4 (14 *0,1), utsignalen blir 3,4; ÄR-värdet blir 9,4
Felet är då 0,6; P-delen blir 0,3; integralen blir 14,6; I-delen blir 1,46, utsignalen blir 1,76; ÄR-värdet blir 11,16 (ja, overshot! dåligt dimensionerad regulator)
Felet är då -1,16; P-delen blir -0,58; integralen blir 13,44; I-delen blir 1,34; utsignalen blir 0,76 (överslängen fortsätter lite, men eftersom P-delen nu är negativ så kommer också I-delen att minska.

Vid stabilt system så är felet noll, P-delen är noll och I-delen är noll.

D-reglering lägger man till för att dämpa överslängen.

[Al_Bundy]

Jag förstår bättre nu.

Men angående C++ programmeringen. Måste jag ha en global variabel eller kan jag sätta static int sumIntegral ?

För om en variabel är static så betyder väll att den ska komma igång värdet nästa gång funktionen anropas?

Kod: Markera allt

//globala

long T1:
float PHbor;
float e_before;

 static int U_pump(float PHar, long *T2_point)
      {
        float e = PHbor - PHar;                                              // The wrong value
        const byte Td = 5;                                                   // Td value 
        const byte Ti = 3;                                                   // Ti value
        long T2 = *T2_point;                                                 // a pointer 
        static int sumIntegral =+ e_before*(T2-T1);
        if (e <= 0)
        {
          sumIntegral = 0;                                                   // Reset when wrong value is 0 or less that 0
        }
        
        double PH_voltage = K*(e + Td*(e-e_before)/(T2-T1) + (1/Ti)*sumIntegral);                 // Lovely PID-regulator 
        
        e_before = e;                                                        // save e as e_before for next loop
        T1 = T2; 

[Nerre]

Du ska inte nolla I när felet är mindre än noll. Om regleringen bara reglerar åt ena hållet så kan det eventuellt fungera.

Poängen är att I-faktorn ska vara väldigt liten.

[Gimbal]

Sen behöver man normalt inte krångla till I -beräkningarna genom att räkna med bredden på "staplarna" för att få den verkliga arean. Eftersom bredden förhoppningsvis är konstant så kan man strunta i den, bara summera ihop felen direkt och justera istället konstanten för I.

Det är också närmast nödvändigt att lägga in gränser för I variabeln så den inte växer i väg långt ut i skogen, det är lätt hänt om felet är stort i början av regleringen, exempelvis.

[Icecap]

I min panna är I-faktorn (procentdelen om du vill) ung. 1/1500-del av P-faktorn. De exakta värden beror ju på regleringens hastighet, enheten som styrs svarshastighet osv.

[Al_Bundy]

Du ska inte nolla I när felet är mindre än noll. Om regleringen bara reglerar åt ena hållet så kan det eventuellt fungera.

Poängen är att I-faktorn ska vara väldigt liten.

Den ska reglera åt bara ett håll ja

Sen behöver man normalt inte krångla till I -beräkningarna genom att räkna med bredden på "staplarna" för att få den verkliga arean. Eftersom bredden förhoppningsvis är konstant så kan man strunta i den, bara summera ihop felen direkt och justera istället konstanten för I.

Det är också närmast nödvändigt att lägga in gränser för I variabeln så den inte växer i väg långt ut i skogen, det är lätt hänt om felet är stort i början av regleringen, exempelvis.

Men nu vet jag inte exakt bredden på staplarna.

Jo. Det var det jag tänkte. Men då nollar jag när felet är 0 eller mindre än noll. Det är mitt "gränsvärde".

I min panna är I-faktorn (procentdelen om du vill) ung. 1/1500-del av P-faktorn. De exakta värden beror ju på regleringens hastighet, enheten som styrs svarshastighet osv.

Aha? Svartbygge

Jag hajade inte direkt vad du menar. Har Ti något med det att göra?
Varför ens dela med Ti?

[SeniorLemuren]

Om du vill ha pid serverat på ett fat varsågod:

PID Theory.pdf

Om du vill veta mer:

Idiot Guide to PID Algorithm.pdf

[danei]

Du ska inte nolla i delen när felet är noll. Då förstör du regleringen helt.
Villkoret handlar om att tex. inte räkna upp itegralen om utsignalen är bottnad. Annars kan man få integrator uppvridning som kan medföra extrema fel regleringar.

[qx5]

Liten PID regulator i Perl som jag testade ett tidigare inlägg med..

Kod: Markera allt

for($in=0,$P=0.5, $I=0.05, $D=0.01, $B=10;  ;  $i++){
  $e=($B-$in);
  $eI+=$e*$I; $eP=$e*$P; $eD=$e*$D*($eD-$eD_last);
  $in+=$eP+$eI+$eD;
  printf("%02d  %.2f\n", $i, $in);

  $in_last=$in; $eD_last=$eD;
  }

$in - Värdet på signalen
$P - Proportionalitetskonstant
$I - Integrationskonstant
$D - Derivatakonstant
$B - Börvärde