Vektorregelung ohne Strommessung

[Bert S. (kautschuck)]

Hi,

Ich habe eine Vektorregelung (FOC) für einen brüstenlosen Motor 
implementiert und festgestellt, dass wenn ich die Phasenströme für den 
FOC Algorithmus einfach auf einen konstanten Wert setzte, es trotzdem 
hervorragend funktioniert, wenn nicht sogar noch besser (weniger torque 
ripple) als wenn ich die gemessenen Phasenströme in die Rechnung mit 
einbeziehe. Wenn ich ja das magnetische Feld kenne, dann kann ich ja 
mein Stator Feld immer 90° voraus haben, ohne dass ich die Amplitude 
wissen muss, solange ich nicht genau den Strom bestimmen will und somit 
genau das Drehmoment, oder? Hat eine FOC ohne Strommessung weitere 
Nachteile als nur die Unbestimmtheit des Drehmomentes und Strom?

[THOR (Gast)]

Du kennst den Lastwinkel deiner SyM nicht, daher kann die Durchrutschen.

[Bert S. (kautschuck)]

Wie meinst du das? Ich habe einen Encoder im System, somit kenne ich die 
absolute Position des Stators zum Rotor zu jeder Zeit und ein 
Durchrutschen sollte nicht möglich sein.

[Jonas B. (jibi)]

Moin,

wenn du es ganz genau wissen willst:

https://www.youtube.com/watch?v=fpTvZlnrsP0

Gruß J

[Pandur S. (jetztnicht)]

Mit Encoder ist es in der Tat viel einfacher. Die hohe Schule arbeitet 
aber aus Kostengruenden ohne Encoder, weiss also die Position nicht.

[Bert S. (kautschuck)]

Ich hab hier mal den FOC Code welchen ich verwende. Das ganze habe ich 
mehr oder weniger von hier:

http://www.st.com/content/ccc/resource/technical/document/application_note/06/30/4a/f2/c8/e3/48/e5/CD00116774.pdf/files/CD00116774.pdf/jcr:content/translations/en.CD00116774.pdf

Das ganze funktioniert ziemlich gut, aber eben bei höheren Strömen wird 
der torque ripple gross, aber nur wenn ich 
v_d_ref=k_p_foc*(i_d+i_d_ref*B) + k_i_foc*sum_i_d; und nicht v_d_ref=0 
setze.

void startFOC(float ia, float ib, float ic, float pos, float out , float v) {
  v_dc=v_dc_val;

  i_a=ia;
  i_b=ib;
  i_c=ic;


  /*i_a=0;//ia;
  i_b=0;//ib;
  i_c=0;//ic;*/


  theta=(pos*(float)MY_PI)/180.0f;

  i_q_ref=-out;
  i_d_ref=0;
  clarkTransformation();
  parkTransformation();
  currentControl();
  inverseParkTransformation();
  inverseClarkTransformation();
  calcCommutationDuration();
  sectorDetermination();
  setPeriods();
}

void calcCommutationDuration() {
  //PU- System to scale v_beta, v_alpha
  v_alpha=v_alpha/440;
  v_beta=v_beta/440;

  x_dur=v_dc*v_beta*SQRT_3;
  y_dur=(v_dc*v_beta*SQRT_3 + 3*v_dc*v_alpha)/2;
  z_dur=(v_dc*v_beta*SQRT_3- 3*v_dc*v_alpha)/2;
}

void inverseClarkTransformation() {
  v_a=v_beta;
  v_b=(SQRT_3*v_alpha - v_beta)/2;
  v_c=-(v_beta + SQRT_3*v_alpha)/2;
}

void clarkTransformation() {
  i_alpha=i_a;
  i_beta=(i_a + 2*i_b)/SQRT_3;
}

void inverseParkTransformation() {
  v_alpha= v_d_ref*cosf(theta) - v_q_ref*sinf(theta);
  v_beta= v_q_ref*cosf(theta) + v_d_ref*sinf(theta);
}

void parkTransformation() {
  i_d = i_alpha*cosf(theta) + i_beta*sinf(theta);
  i_q = -i_alpha*sinf(theta) + i_beta*cosf(theta);
}

void currentControl() {
  v_d_ref=k_p_foc*(i_d+i_d_ref*B) + k_i_foc*sum_i_d;
  v_q_ref=k_p_foc*(i_q+i_q_ref*B) + k_i_foc*sum_i_q;

  sum_i_d+=(i_d+i_d_ref)/SUM_W;
  sum_i_q+=(i_q+i_q_ref)/SUM_W;

  if(sum_i_d>integral_windup) {
    sum_i_d=integral_windup;
  } else if(sum_i_d<-integral_windup) {
    sum_i_d=-integral_windup;
  }

  if(sum_i_q>integral_windup) {
    sum_i_q=integral_windup;
  } else if(sum_i_q<-integral_windup) {
    sum_i_q=-integral_windup;
  }

}

void sectorDetermination() {
  if(v_a>0) {
    sector[0]=1;
  } else {
    sector[0]=0;
  }

  if(v_b>0) {
    sector[1]=1;
  } else {
    sector[1]=0;
  }

  if(v_c>0) {
    sector[2]=1;
  } else {
    sector[2]=0;
  }

  sector_is= sector[0]+2*sector[1]+4*sector[2];

  switch(sector_is) {
    case 1:
      period_t1=z_dur;
      period_t2=y_dur;
      break;
    case 2:
      period_t1=y_dur;
      period_t2=-x_dur;
      break;
    case 3:
      period_t1=-z_dur;
      period_t2=x_dur;
      break;
    case 4:
      period_t1=-x_dur;
      period_t2=z_dur;
      break;
    case 5:
      period_t1=x_dur;
      period_t2=-y_dur;
      break;
    case 6:
      period_t1=-y_dur;
      period_t2=-z_dur;
      break;
    default:
      break;
  }

  if((period_t1+period_t2) > period_t) {
    period_t1_sat=period_t1*(period_t)/(period_t1+period_t2);
    period_t2_sat=period_t2*(period_t)/(period_t1+period_t2);
  }

  if(period_t1_sat>0 && period_t1>period_t1_sat)
    period_t1=period_t1_sat;
  if(period_t1_sat<0 && period_t1<period_t1_sat)
    period_t1=period_t1_sat;
  if(period_t2_sat>0 && period_t2>period_t2_sat)
    period_t2=period_t2_sat;
  if(period_t2_sat<0 && period_t2<period_t2_sat)
    period_t2=period_t2_sat;

    period_a=(period_t+1 - period_t1 - period_t2)/2;
    period_b=period_a + period_t1;
    period_c=period_b + period_t2;
}

void setPeriods(void) {
  switch(sector_is) {
    case 1:
      TIM2->CCR1 = period_b;
      TIM2->CCR2 = period_a;
      TIM2->CCR3 = period_c;
      break;
    case 2:
      TIM2->CCR1 = period_a;
      TIM2->CCR2 = period_c;
      TIM2->CCR3 = period_b;
      break;
    case 3:
      TIM2->CCR1 = period_a;
      TIM2->CCR2 = period_b;
      TIM2->CCR3 = period_c;
      break;
    case 4:
      TIM2->CCR1 = period_c;
      TIM2->CCR2 = period_b;
      TIM2->CCR3 = period_a;
      break;
    case 5:
      TIM2->CCR1 = period_c;
      TIM2->CCR2 = period_a;
      TIM2->CCR3 = period_b;
      break;
    case 6:
      TIM2->CCR1 = period_b;
      TIM2->CCR2 = period_c;
      TIM2->CCR3 = period_a;
      break;
    default:
      break;
  }
}

[WS (Gast)]

Sapperlot W. schrieb:
> Mit Encoder ist es in der Tat viel einfacher. Die hohe Schule arbeitet
> aber aus Kostengruenden ohne Encoder, weiss also die Position nicht

Die ganz "hohe Schule" arbeitet auch ohne Decoder, wertet aber den 
Motorstrom aus und kennt damit dessen Position dennoch.:-)

[Bert S. (kautschuck)]

Es scheint mir so, als würde ich I_d irgendwie nicht wirklich ganz zu 
Null regeln, denn wenn ich einfach I_d=0 und I_d_ref=0 setzte, ist das 
Resultat viel besser. Aber ich kann mir nicht erklären, was genau die 
Ursache ist. Die Strommessung müsste eigentlich sehr exakt sein, da ich 
zwei AD8418 verwende.