Digitaler Drehzahlregler

[Tobi (Gast)]

Hi,

ich habe einen PI-Regler am laufen, der auch einigermaßen funktioniert. 
Allerdings nicht so toll wie ich es mir vorstelle. Immer wieder kommt es 
zu schwingen des Regler, oder der Motor läuft nur kurz hoch und stoppt 
dann wieder. Meistens geht aber alles wie es soll. Nur die Überschwinger 
gefallen mir nicht. Reduziere ich aber die Regelverstärkung wird die 
Drehzahl nicht gut genug ausgeregelt.

Vielleicht hat der eine oder andere einen Optimierungsvorschlag?

In meinem Studienskript habe ich eine andere Regelgleichung als wie sie 
bei rn-wissen.de beschrieben wird... Wie sind eure Erfahrungen?

Zur Erklärung: Es wird ein AC-Universalmotor mittels Phasenanschnitt und 
direkter Drehzahlrückführung über eine Magnetscheibe und Hallsensor auf 
konstante Drehzahl geregelt.

Vorgabe ist die Dauer einer Motorumdrehung in Mikrosekunden. Stellgröße 
ist der Zündwinkel, also die Dauer vom Nulldurchgang bis zum Einschalten 
des Triacs.

Ich bin mir nicht ganz sicher, wie ich den Motorstart machen soll. Geht 
zwar einigemaßen, ist aber nicht sonderlich schön so.

Wie begrenzt man den I-Anteil am besten?

Grüße

/*---------------------------------------------------
ROUTINE Name : fire_time_calc

Description:  Calculates the value for Timer 1 as phase angle
Input/Output:  Set Speed (us of one motor turn)/None
Comments:
Execution Time: 80us
------------------------------------------------------------*/
void fire_time_calc (unsigned int set_speed)
{
  signed long temp;
  unsigned int speed_avg;
  signed int kp_temp;
  signed int ki_temp;

  speed_avg = Get_turn_time ();  //Get current speed in time per turn in us

    
if((speed_avg < 50000) && flags.stop == 0)
{
  flags.startup = 0;  // motor is turning  
}
else if(speed_avg >= 50000 && flags.stop == 0)
{
  flags.startup = 1; // <900rpm  
}
                
  kp_temp = 0 - Get_kp(set_speed);
  ki_temp = 0 - Get_ki(set_speed);


//----------------------------------
// firtime = KP * e - KP * (1-T/Tn) * e(t-1) + firetime (t-1) ->FH Skrip
//e = w - x;          //Vergleich
//esum = esum + e;        //Integration I-Anteil
//y = Kp*e + Ki*Ta*esum + Kd/Ta*(e – ealt);  //Reglergleichung
//ealt = e; //-> rn-wissen.de
//---------------------------

  if(flags.startup == 0 && flags.stop == 0) //normal operation
  {
    SpeedError =(signed long)set_speed - (signed long) speed_avg;      // Calculate Differenece Between Desired Speed and Actual Speed
      // if speederror <0 -> motorspeed is to slow
      // if speederror >0 -> motorspeed is to high

    if(kp>kp_temp) //soft start    
      kp--;
    else if (kp<kp_temp)
      kp++;
    else
      kp = kp_temp;

    SpeedProportional = SpeedError * kp/100;

    if(ki>ki_temp) //soft start    
      ki--; //negative
    else if(ki<ki_temp)
      ki++;
    else
      ki = ki_temp;

    esum = esum + SpeedError;

    if (esum < -200000) {esum = -200000;}          //Limit Integral part
    if (esum > 200000) {esum = 200000;}

    SpeedIntegral = esum*ki/10000;  // Translation from speed to fire_time incl. in KP + KI



temp = (SpeedProportional + SpeedIntegral);        // calculate time in which triac is fired (0 - negHW time)

temp = (signed long)(neg_halfwave-MAX_FIR_TIME) - temp;   //change to fireangle time (time in which no voltage at motor)  
    
    if(temp<MIN_FIR_TIME)    // CHECK FOR LOWER LIMIT OF FIRING TIME
        {
        fir_time = MIN_FIR_TIME; //limit to min fireangle ~0°       
        }
     else if(temp>(signed long)(neg_halfwave-MAX_FIR_TIME)) // slowest possibility
       {
         fir_time = neg_halfwave-MAX_FIR_TIME; //limit to max fireangle ~180°     
         }
    else
      fir_time = (unsigned int) temp; //normal operation

  }


if(flags.startup == 1 && flags.stop == 0)//open loop startup
  {
    if(fir_time<MIN_FIR_TIME)    // CHECK FOR LOWER LIMIT OF FIRING TIME
        {
       fir_time = MIN_FIR_TIME;
        }
    else
      {
      fir_time-= SOFTSTART_STEPS;
      }
  }
}


/*-----------------------------------------------------------------------------
ROUTINE Name : Get_ki

Description:  Calculates the ki Parameter in regard of setspeed and state
Input/Output:  setspeed/ki
Comments: 
Execution Time:
-----------------------------------------------------------------------------*/
unsigned int Get_ki (unsigned int set_n)
{
unsigned long param;

  if(set_n > 5800)
  {
    param = 96-(unsigned long)set_n*29/10000;
  }
  else
  {
    param = 284-(unsigned long)set_n*34/1000;
  }

return((unsigned int)param);
}
/*-----------------------------------------------------------------------------
ROUTINE Name : Get_kp

Description:  Calculates the kp Parameter in regard of setspeed and state
Input/Output:  setspeed/kp
Comments:     
yp = 1E-06x2 - 0,0086x + 25,381
Execution Time:
-----------------------------------------------------------------------------*/
unsigned int Get_kp (unsigned int set_n)
{
unsigned long param;

  if(set_n > 5800) 
  {
      param = 88-(unsigned long)set_n*58/10000;
  }
  else
  {    
      param = 420-(unsigned long)set_n*618/10000;
  }
return((unsigned int)param);
}

[Achim M. (minifloat)]

Tobi schrieb:
> Reduziere ich aber die Regelverstärkung wird die
> Drehzahl nicht gut genug ausgeregelt.

Das klingt eher nach P-Regler und bleibender Regelabweichung.

Tobi schrieb:
> Wie begrenzt man den I-Anteil am besten?
> [...]
> if (esum < -200000) {esum = -200000;}          //Limit Integral part
>     if (esum > 200000) {esum = 200000;}

Das ist schon mal eine gute Idee.


Hast du dein System schon mal mit einem Simulationsprogramm 
nachmodelliert?
Vielleicht bringt ein Zustandsregler mit Beobachter was, da hier mehr 
als ein Energiespeicher im System verbaut ist(Induktivität, rotierende 
Masse...)

Kannst du die Zündwinkelberechnung aus dem Reglerausgang nicht irgendwie 
ausgliedern? Würde das ganze übersichtlicher machen.

mfg mf

[Tobi (Gast)]

Simuliert hab ich den Regler noch nicht. Ich tu mich sehr schwer, die 
Regelstrecke theoretisch zu betrachten.

Klar, die Zündwinkelberechnung könnte man auslager. der Regler wäre nach 
der Addition von P und I Anteil zu ende.

Grüße

[Purzel H. (hacky)]

Allenfalls waere ein D-Teil hilfreich. Eine Simulation ist natuerlich 
hilfreich. Das spart Stunden.