Resolverauswertung

[TNTBC (Gast)]

Hallo liebes Team,

ich habe ein Problem. Ich habe einen Servomotor und dafür eine 
Steuerelektronik entworfen. In dem Servomotor ist ein Resolver verbaut. 
Jetzt habe ich meine Steuerelektronik für eine Resolverperiode so 
Programmiert das bei einer Periode des Resolvers einmal das Drehfeld 
herum läuft. Jetzt kommt das Problem. Meine Maschine ist eine 6pol 
Maschine aber der Resolver hat nur 2pole. Also habe ich für jede 
Resolverperiode 3 Maschinenperioden! Jetzt stehe ich vor einer Mauer und 
weiß nicht wie ich aus einer Resolverperiode so eben mal 3 mache!!! Hat 
jemand eine Idee oder so etwas schon einmal gemacht?

Danke
Gruß TNTBC

[Ralf (Gast)]

Eine konkrete Lösung für Dich habe ich nicht, aber ich würde mal nach 
dem Stichwort PLL suchen.

http://www.elektronik-kompendium.de/public/schaerer/pll4046.htm


Benötigst Du so etwas nicht sowieso für eine Drehzahlregelung?..oder wie 
synchronisierst Du die beiden Drehfelder?

[Volker Z. (vza)]

TNTBC schrieb:
> Jetzt stehe ich vor einer Mauer und
> weiß nicht wie ich aus einer Resolverperiode so eben mal 3 mache!!!

Winkel_elektrich = (Winkel_resolver * 3) % 360

Dein Resolver ist für deinen Motor ungünstig.

Volker

[TNTBC (Gast)]

Hallo Ralf,

Ralf schrieb:
> Benötigst Du so etwas nicht sowieso für eine Drehzahlregelung?..oder wie
> synchronisierst Du die beiden Drehfelder?

Die Synchronisation erfolgt über das Resolversignal, da ich weiß in 
welchen Sektor des 6 Quadrantenstellers ich mich befinde! und die 
Berechnung der Tastverhältnisse gehen über ualpha und ubeta. Eine PLL 
gibt mir ja nur die Frequenz des Jeweiligen Trägersignals aus. Das hilft 
mir aber nicht weiter da ich dabei nicht weiß wie ich die Maschine jetzt 
anzusteuern habe! Das weitere Problem der PLL ist, dass die Maschine 
einmal gedreht haben muss um eine gültige Frequenz zu haben.

Ich habe eine Idee wie man es machen könnte wenn ich Sie rechnerische 
bewiesen haben werde ich sie mal Posten aber dennoch sammelt weitere 
Ideen

Danke dir Ralf

Gruß TNTBC

[TNTBC (Gast)]

Hallo Volker

Volker Zabe schrieb:
> Winkel_elektrich = (Winkel_resolver * 3) % 360

Die Variante kenne ich, allerdings müsste ich mir dann den Sinus und 
Cosinus des Winkels neu errechnen und der Sinus und Cosinus des 
Resolvers wären unbrauchbar! Oder?

Volker Zabe schrieb:
> Dein Resolver ist für deinen Motor ungünstig.

Japp, nur ist er fest verbaut von Werksseite aus!!!


Gruß TNTBC

[Volker Z. (vza)]

TNTBC schrieb:
> Die Variante kenne ich, allerdings müsste ich mir dann den Sinus und
> Cosinus des Winkels neu errechnen und der Sinus und Cosinus des
> Resolvers wären unbrauchbar! Oder?

Ja!
Aber wie willst Du aus einem Sin/Cos-Signal 18(=3*6) Umschaltpunkte 
generieren, ohne über den Winkel zu gehen?

Volker

[TNTBC (Gast)]

Volker Zabe schrieb:
> Aber wie willst Du aus einem Sin/Cos-Signal 18(=3*6) Umschaltpunkte
> generieren, ohne über den Winkel zu gehen?

Genau vor dem Problem stehe ich gerade. Ich will aber kein Arctan 
berechnen. Die Entscheidung der 6 Sektoren ging bis jetzt ganz gut ohne!
Wenn es jedoch eine schnelle Möglichkeit gibt den Arctan zu berechnen 
dann werde ich darauf eingehen müssen!!
Gruß TNTBC

[Volker Z. (vza)]

TNTBC schrieb:
> Die Entscheidung der 6 Sektoren ging bis jetzt ganz gut ohne!

Das interessiert mich jetzt aber brennend. Wie hast du aus den 8 
Segmenten des Sin/Cos-Signal (die man durch einfaches Vergleichen 
erhält) die 6 Umschaltpunkte generiert?

> Wenn es jedoch eine schnelle Möglichkeit gibt den Arctan zu berechnen
> dann werde ich darauf eingehen müssen!

Ja gibt es. Alles in Integer. Du teilst das Sin/Cos-Signal in 8 
Segmenten (wie oben beschrieben) auf, der Quotient bildet dann ein Index 
in einer Tabelle. Interpolieren brauchst du noch nicht einmal.

Anbei ein Beispiel für ein 3-Phasiges System.
Ist auch noch eine Wurzelberechnung drinnen.

Volker

[TNTBC (Gast)]

Volker Zabe schrieb:
> Das interessiert mich jetzt aber brennend. Wie hast du aus den 8
> Segmenten des Sin/Cos-Signal (die man durch einfaches Vergleichen
> erhält) die 6 Umschaltpunkte generiert?

Ich habe es aus einer Vorlesung von Prof. Hambrecht der Beuthochschule 
Berlin. Ich habe ihn angefragt sobald er seine Zustimmung gibt werde ich 
die Methode posten.

Volker Zabe schrieb:
> Ja gibt es. Alles in Integer. Du teilst das Sin/Cos-Signal in 8
> Segmenten (wie oben beschrieben) auf, der Quotient bildet dann ein Index
> in einer Tabelle. Interpolieren brauchst du noch nicht einmal.

Die Frage ist, wenn ich jetzt zwei int16_t werte habe die um Null sind 
und ich gebe es in deine Funktion ein, funktioniert diese dann auch? Und 
was ist mit Werten über 30°. Ich bin ehrlich ich verstehe nicht was du 
in der arctan Funktion machst!!! Kannst du das mal beschreiben?


Danke Gruß
TNTbc

[Volker Z. (vza)]

TNTBC schrieb:
> Kannst du das mal beschreiben?

Die Funktionen kannst du so nicht verwenden. Sie sind für ein 
Drei-Phasen-System (120°- Versatz) gedacht.

- Du musst die Tabelle neu berechnen.
- Kannst die Interpolation vernachlässigen [ atan30() ].
    (Du brauchst eine Auflösung von ca 10°, ich brauchte 0,01°)
    Bei dir könnte es wahrscheinlich reichen, wenn du den Sinus im 
ersten
    Segment als linear ansiehst.
- Die Aufteilung der Segmente neu schreiben (360° -> 90°)[ Cal_Winkel() 
].

Es ging ums Prinzip, wie man Winkelfunktionen mit Integer-Werten 
berechnen kann. Dies sollte keine Vorgefertigte / Null-Denke Lösung 
sein!

Drei-Phasen kann man (durch einfaches Vergleichen(siehe Cal_Winkel()) 
auf 12 Segmente aufteilen -> 30°.  Das geht bei dir nicht.

Volker

[TNTBC (Gast)]

Ok ich gebe es zu ich bin zu tum für den Code!!!!
Ich verstehe die Tabelle und den Ansatz nicht. Kannst du mir eine Seite 
oder irgendetwas geben um es besser zu verstehen??

Gruß TNTBC

[TNTBC (Gast)]

Hallo,

damit ich die Sache hier richtig beende!
hier meine Lösung für den atan2. Danke an die Seite 
http://www.dsprelated.com/showmessage/10922/1.php

Die Einheit benötigt laut Simulator:2388clk
Im definitionbereich 0 <= alpha < 180;

int16_t i_atan2(int16_t y, int16_t x)
  {
    int16_t result = 0;
    int16_t y2;

    if ((x | y) == 0)
      return 0;  /* give up */

    if (y < 0)  /* if we point downward */
    {
      result += -180;
      y = -y;
      x = -x;
    }
    if (x < 0)  /* if we point left */
    {
      result += 90;
      y2 = y;
      y = -x;
      x = y2;
    }
    if (y > x)  /* 45 degrees or beyond */
    {
      result += 45;
      y2 = y;
      y -= x;
      x += y2;
    }
    if (2 * y > x)  /* 26.565 degrees */
    {
      result += 26.565;
      y2 = y;
      y = 2 * y - x;
      x = 2 * x + y2;
    }
    if (4 * y > x)  /* 14.036 degrees */
    {
      result += 14.036;
      y2 = y;
      y = 4 * y - x;
      x = 4 * x + y2;
    }
    if (8 * y > x)  /* 7.125 degrees */
    {
      result += 7.125;
      y2 = y;
      y = 8 * y - x;
      x = 8 * x + y2;
    }

    /* linear interpolation of the remaining 64-ant */
    result += (57) * y / x;
    if(result != 0){
      if(result > 0)
      
      result++;
    }      
    return result;
  }

[Volker Z. (vza)]

TNTBC schrieb:
> Kannst du mir eine Seite
> oder irgendetwas geben um es besser zu verstehen?

Im Prinzip macht mein Code das Gleiche wie deiner. Aber viel feiner 
(mehr Nachkommastellen), die du aber nicht brauchst und auf 3-Phasen 
ausgelegt.

Durch die implizite Skalierung (Stichwort: Festpunkt-Arithmetik) ist der 
Code schlechter Nachtvollzierbar. Aber ich Versuchs mal:

# define MOVE1  0x10000
#define ANZAHL 13
#define INTERVALL 5041
const static t_stuetsstellen atan_table[ANZAHL] ={
                0,        2386
  ,        944754,        2198
  ,       2757006,        2019
  ,       5313604,        1850
  ,       8473691,        1693
  ,      12097609,        1549
  ,      16057864,        1418
  ,      20244280,        1300
  ,      24565367,        1192
  ,      28947482,        1096
  ,      33332900,        1009
  ,      37677470,         931
  ,      41948268,         860
};

unsigned short atan30(int U1,int U2)
{
   int index,flag;
   unsigned long teiler,res;

   teiler = (unsigned long)U1 * MOVE1 + (MOVE1/2);
   teiler /= U2;

   index = (int)(teiler/INTERVALL);
 
   res= atan_table[index].offset  + atan_table[index].faktor  * teiler;
   res /= MOVE1;

   return (unsigned short) (res);
}

Würde man den COS-Wert durch den SIN-Wert im Bereich 0-45° teilen ergäbe 
das ein Wertebereich von 0-1. Dies ist in Integer nicht darstellbar. 
Deshalb verschiebe ich den Bereich um 16 Bit (*0x10000).
Jetzt habe ich den Wertebereich von 0 bis 65535.

Jetzt muss ich den Wertebereich auf meine Stützstellen in der Tabelle 
aufteilen. Ich dividiere durch  5041 (65536/13), so erhalte ich ein 
Index von 0 bis 12. Eine höhere Anzahl an Stützstellen ergaben keine 
höhere Genauigkeit.

Damit hole ich mir den Stützstellenwert aus der Tabelle. Die 
Interpolation zwischen den Stützstellen ist etwas ungewöhnlich, Der 
Faktor ist nicht die Steigung zwischen den Stützstellen, sondern die 
Steigung von Null durch die Stützstelle. Erspart einige Rechnungen zur 
Laufzeit.

Die Werte in der Tabelle sind so berechnet, das sie mir meinen Winkel in 
0.01° mal 0x10000 ergeben. Das ergibt eine große Anzahl von 
Nachkommastellen bei den Rechnungen und damit einen kleinen 
Rundungsfehler. Des halb teile ich zum Schluss noch durch 0x10000.

Ich hoffe es ist damit etwas klarer.   Volker

[Volker Z. (vza)]

Nachtrag:

Hallo TNTBC,
deine gepostete Funktion rechnet im Bereich 22,2 bis 26.5° bis zu -9,5° 
Falsch. Auch liefert sie nie das Ergebnis 1°.

TNTBC schrieb:
> result += 26.565;
Du addierst eine double zu einem int16_t.
Welchen Sinn macht das denn? Schaltest du immer die Compiler-Warnung ab?

Annsonsten (wenn der Fehler gefunden wurde) eine nette kleine 
arctan-Funktion mit einem Fehler von +/- 1°.


Volker

[Volker Z. (vza)]

Hat mir ja keine Ruhe gelassen. Habe den Fehler gefunden und noch paar 
Kleinigkeiten geändert.

Der Vergleich mit 8*y>x hat mehr Fehler produziert, als Genauigkeit 
gebracht.
Eine Fixpoint Nachkommastelle und eine richtige Rundung brachten den 
Rest.

Der maximale Fehler liegt jetzt bei - 0,6° / +0,7°.

Im Anhang meine Testfunktion.

#define FP 2

short i_atan2(short sinw, short cosw)
{
   short result = 0;
   short temp;

   if ((cosw | sinw) == 0)
   {
      return 0;  /* give up */
   }

   if (sinw < 0)  /* 180 - 360 */
   {
      result = 180*FP;
      sinw = -sinw;
      cosw = -cosw;
   }
   if (cosw < 0)  /* 90 - 180 */
   {
      result += 90*FP;
      temp =  sinw;
      sinw = -cosw;
      cosw =  temp;
   }
   if (sinw > cosw)  /* 45 - 90 */
   {
      result += 45*FP;
      temp  = sinw;
      sinw -= cosw;
      cosw += temp;
   }
   if (2 * sinw > cosw)  /* 26.565 degrees - 45 */
   {
      result += (short)(26.565*FP);
      temp = sinw;
      sinw = 2 * sinw - cosw;
      cosw = 2 * cosw + temp;
   }
   if (4 * sinw > cosw)  /* 14.036 degrees - 26.565 */
   {
      result += (short)(14.036*FP);
      temp = sinw;
      sinw = 4 * sinw - cosw;
      cosw = 4 * cosw + temp;
   }

    /* linear interpolation of the remaining 64-ant */
    result += 57*FP * sinw / cosw;
    return (result+FP/2)/FP;
}