PID Regler timing

[Lyroy (Gast)]

Hallo allerseits,
wie ist das mit dem PID Regler gemeint wenn man zwei Zeiten hat.

Zeit A / Frequenz mit der ich die Drehzahl lese und meine globale 
Variable update

Zeit B / Frequenz mit der ich den PID Regler antriggere und dies meine 
"iterations_time" darstellt

current_error = ref_speed - rpm;
          integration_sum = integration_sum + (current_error * iteration_time);
          duty = ( KP * current_error + 
                 KI * integration_sum + 
                 KD *((current_error -previous_error)/iteration_time));

Welche der beiden Frequenzen muss höher sein? Habe gerade hier einen 
blackout.
Ich versuche hier die Drehzahl eines Bürstenmotors zu regeln.

Zweite Frage (STM32 spezifisch):
Wenn ich beides in einer Callbackroutine anhandele, also die Timer für 
ZeitA und Zeit B, könnte ich mir da Probleme wegen Überholern/Blockeden 
einhandeln?
Nehmen wir an Timer1 alls 1ms und Timer2 alle 10.
Würde die Callback routine aufgerufen werden für Timer1 wenn Timer2 code 
noch läuft?

Vielen Dank für die Hilfe..brauche gerade ein paar kleine denkanstöße

void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *tim)
{    
  if(tim->Instance == TIM4) 
  {
    
//    enc_cnt = htim1.Instance->CNT - enc_cnt_old;
//    enc_cnt_old = htim1.Instance->CNT;
//    
//    rpm=0+((enc_cnt*20*60)/400);
      
//    rpm_tmp=rpm_tmp+((enc_cnt*100*60)/400);
//    counter_avg++;
//    
//    if(counter_avg==2)
//    {
//      rpm=rpm_tmp/2;
//      counter_avg=1;
//      rpm_tmp=0;
//    }
    res=1;
    
  }
  else if(tim->Instance == TIM5) 
  {

        
          current_error = ref_speed - rpm;
          integration_sum = integration_sum + (current_error * iteration_time);
          duty = ( KP * current_error + 
                 KI * integration_sum + 
                 KD *((current_error -previous_error)/iteration_time));
          

          if(duty<0)
          duty =duty*-1;  
          
          
          if((duty*12)>10000)
            duty=10000;
          else  
            duty=duty*12;
          htim3.Instance->CCR1 = duty;

          previous_error = current_error;
          res=0;
          
  }
  
}

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

Lyroy schrieb:
> Welche der beiden Frequenzen muss höher sein?

Da der PID Regler nur einmal alle 10ms gezündet wird, ist es auch nur 
alle 10ms nötig, ihm eine Ist-Drehzahl zu liefern. Du kannst zwar öfter 
Drehzahl messen, ist aber sinnlos.
Um Konflikte zu vermeiden, kannst du beide Tasks in einem Schwupps 
erledigen.

[Lyroy (Gast)]

Matthias S. schrieb:
> Da der PID Regler nur einmal alle 10ms gezündet wird, ist es auch nur
> alle 10ms nötig, ihm eine Ist-Drehzahl zu liefern. Du kannst zwar öfter
> Drehzahl messen, ist aber sinnlos.
> Um Konflikte zu vermeiden, kannst du beide Tasks in einem Schwupps
> erledigen.

Herzlichen Dank hierfür!

Habe es jetzt so kombiniert. Der PID wird alle 10ms gestartet. Demnach 
habe ich Iterationstime auf 0.01 gestellt. Nur so läuft der Duty auf 
Anschlag. Stelle ich aber die iterationtime auf 1, dann läuft der PID 
recht cool.
Woran liegt das? ich dahcte die Zeitkonstante wäre wichtig im algo

void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *tim)
{    
  if(tim->Instance == TIM4) 
  {
    
//    enc_cnt = htim1.Instance->CNT - enc_cnt_old;
//    enc_cnt_old = htim1.Instance->CNT;
//    
//    rpm=0+((enc_cnt*20*60)/400);
      
//    rpm_tmp=rpm_tmp+((enc_cnt*100*60)/400);
//    counter_avg++;
//    
//    if(counter_avg==2)
//    {
//      rpm=rpm_tmp/2;
//      counter_avg=1;
//      rpm_tmp=0;
//    }
    res=1;
    
  }
  else if(tim->Instance == TIM5) 
  {
    
          //enc_cnt = htim1.Instance->CNT - enc_cnt_old;
          enc_cnt = htim1.Instance->CNT;
          //enc_cnt_old = htim1.Instance->CNT;
          rpm=0+((enc_cnt*100*60)/400);
          htim1.Instance->CNT=0;

        
          current_error = ref_speed - rpm;
          integration_sum = integration_sum + (current_error * iteration_time);
          duty = ( KP * current_error + 
                 KI * integration_sum + 
                 KD *((current_error -previous_error)/iteration_time));
          

          if(duty<0)
          duty =duty*-1;  
          
          
          if((duty*12)>10000)
            duty=10000;
          else  
            duty=duty*12;
          htim3.Instance->CCR1 = duty;

          previous_error = current_error;
          res=0;
          
  }
  
}

[Lyroy (Gast)]

IchRegelDasSchon schrieb im Beitrag #6425078:
> Da fehlt der Anti-Wind Up Code für die Stellgrößenbeschränkung.
> Und sonst ist die Frage, wie du den PID-Regler überhaupt ausgelegt hast?
> Hast du in Simulink simuliert? Welche Zeitkonstante hat deine
> Regelstrecke?

Hab einen  DC Motor mit Encoder dran. der DC Motor wird mit PWM 
angesteuert. Den Encoder werte ich aus und rechne es in rpm um. 
Eingestellt habe ich durch ausprobieren im debugger mode.

Meinst Du mit Zeitkonstante wie oft der PIG angefeuert wird? Das sind 
alle 10ms
Was meinst Du mit Anti-Wind Up Code?

float ref_speed = 80;float duty =0;
float iteration_time =1;

float previous_error = 0;float current_error = 0;
float KP = 0.0001;float KI = 0.1002;float KD = 0.4;
float input = 0;float integration_sum = 0;

[Lyroy (Gast)]

IchRegelDasSchon schrieb im Beitrag #6425082:
> Lyroy schrieb:
>>           if(duty<0)
>>           duty =duty*-1;
>>
>>
>>           if((duty*12)>10000)
>>             duty=10000;
>>           else
>>             duty=duty*12;
>
> Das sieht auch sehr komisch aus. Das PWM Signal sollte gerade eine
> effektive Spannung ergeben, die der Regler rausgibt.
> Und was soll das sein? if(duty<0) duty =duty*-1;
> Bugfixing der übelsten Sorte?

ok, verstehe..Dem PID interessiert die Physik die dahinter ist nicht, 
stimmts?

So läuft es auch ziemlicg gut... Das mit der iteration_time=1 habe ich 
nicht verstanden. Wieso muss es 1 sein und nicht 0.01?

// refernce and pid related constants
float ref_speed = 80;float duty =0;
float iteration_time =1;

float previous_error = 0;float current_error = 0;
//float KP = 0.0001;float KI = 0.1002;float KD = 0.4;
float KP = 20;float KI = 2;float KD = 3;
float input = 0;float integration_sum = 0;

....

void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *tim)
{    
  if(tim->Instance == TIM4) 
  {
    res=1;
    
  }
  else if(tim->Instance == TIM5) 
  {
    
          //enc_cnt = htim1.Instance->CNT - enc_cnt_old;
          enc_cnt = htim1.Instance->CNT;
          //enc_cnt_old = htim1.Instance->CNT;
          rpm=0+((enc_cnt*100*60)/400);
          htim1.Instance->CNT=0;

        
          current_error = ref_speed - rpm;
          integration_sum = integration_sum + (current_error * iteration_time);
          duty = ( KP * current_error + 
                 KI * integration_sum + 
                 KD *((current_error -previous_error)/iteration_time));
          

//          if(duty<0)
//          duty =duty*-1;  
          
          
          if((duty)>10000)
            duty=10000;
          else  
            duty=duty;
          htim3.Instance->CCR1 = duty;

          previous_error = current_error;
          res=0;
          
  }
  
}

[M. K. (sylaina)]

Lyroy schrieb:
> Das mit der iteration_time=1 habe ich
> nicht verstanden. Wieso muss es 1 sein und nicht 0.01?

Also ich habs nur überflogen aber die Itteration-Time stellt wohl die 
Abtastzeit dar. Wenn du an TA schraubst hat das signifikanten Einfluss 
auf das Regler-Verhalten, das ist jetzt nicht grad ungewöhnlich. So 
gefühlt würde ich sagen wenn sich die Abtastzeit um den Faktor 100 
beschleunigt muss KI um den Faktor 100 runter und KD um den Faktor 100 
rauf. Am Besten aber simuliert man das mal durch, z.B. mit Matlab 
Simulink oder, wenn man Matlab nicht hat, mit SciLab (sehr guter 
Matlab/Simulink-Clon)

[Lyroy (Gast)]

M. K. schrieb:
> Lyroy schrieb:
>> Das mit der iteration_time=1 habe ich
>> nicht verstanden. Wieso muss es 1 sein und nicht 0.01?
>
> Also ich habs nur überflogen aber die Itteration-Time stellt wohl die
> Abtastzeit dar. Wenn du an TA schraubst hat das signifikanten Einfluss
> auf das Regler-Verhalten, das ist jetzt nicht grad ungewöhnlich. So
> gefühlt würde ich sagen wenn sich die Abtastzeit um den Faktor 100
> beschleunigt muss KI um den Faktor 100 runter und KD um den Faktor 100
> rauf. Am Besten aber simuliert man das mal durch, z.B. mit Matlab
> Simulink oder, wenn man Matlab nicht hat, mit SciLab (sehr guter
> Matlab/Simulink-Clon)

Das verstehe ich jetzt nicht. Ta muss doch der Zeit zwischen zwei 
Aufrufen der PID Funktion entsprechen, oder?
Oder meinst Du, das ich durch das modifizieren des TA, bei 
gleichbleibenden PID Parametern zufällig zum richtigen Ergebnis gekommen 
bin? Wenn ja,dann müsste mich doch wieder auf 0.01 zurück gehen und an 
der PID Werten hin und her drehen bis es passt.

[Kevin M. (arduinolover)]

Lyroy schrieb:
> Das verstehe ich jetzt nicht. Ta muss doch der Zeit zwischen zwei
> Aufrufen der PID Funktion entsprechen, oder?

Korrekt.

Lyroy schrieb:
> Oder meinst Du, das ich durch das modifizieren des TA, bei
> gleichbleibenden PID Parametern zufällig zum richtigen Ergebnis gekommen
> bin?

Ebenfalls korrekt -> typischer Fall von mehr Glück als Verstand ;)

Dein I und dein D Anteil hängen nunmal stark von von der Zeit ab. Schau 
dir doch einfach an was die beiden Mathematisch machen. Du kannst nicht 
einfach Verstärkungen wählen und die für alle möglichen Reglerfrequenzen 
nutzen.

Lyroy schrieb:
> Werten hin und her drehen bis es passt.
Es gibt genug einstellverfahren die du nutzen kannst um das etwas 
fundierter als nur mit raten zu machen. Bei Stromreglern nimmt man 
beispielsweise gerne das Betragsoptimum ansonsten gibt es noch das 
Verfahren mit der Wendetangente, uvm.

[Pandur S. (jetztnicht)]

Beim Poster kommt grad vieles zusammen.
- wenig theoretische Ahnung von Reglern
- wenig praktische Ahnung von Reglern
- wenig Ahnung von Mathe

[Lyroy (Gast)]

Pandur S. schrieb:
> Beim Poster kommt grad vieles zusammen.
> - wenig theoretische Ahnung von Reglern
> - wenig praktische Ahnung von Reglern
> - wenig Ahnung von Mathe

ohneee  ein Klugscheißer der den Sinn einer Community nicht verstanden 
hat.