STM32 Quadrature Encoder + Geschwindigkeit ?

Einfach A und B signal von Encoder anschliessen an die richtige timer 
pins, Timer configurieren und das soll functionieren. Der Timer counter 
entspricht dan genau die erfasste pulsen von Encoder.

Ja. Das Zählen geht. Aber für die Drehzahlerfassung brauche ich doch den 
Zeitpunkt der Flanken. Also zusätzlich InputCapture. Oder nicht ?

Na dann hab ich doch keine Auflösung mehr.
Wenn so ein Encoder bei max. Drehzahl vielleicht 3kHz hat (4-fach 
Auswertung).
Dann hätte ich in einer Regelung in der 1ms Task Drehzahlen von 0 bis 3 
Einheiten (bei vmax). Bei kleineren 0 oder 1.

JanK. schrieb:
> Na dann hab ich doch keine Auflösung mehr

Das Problem ist doch alt wie die Welt (der Elektronik). Wenn die 
Frequenz zu niedrig ist um zu zählen, schaltet man um auf 
Periodendauermessung.

Georg

>was du brauchst ist keine Encoder Auswertung
>sondern eine PWM-Input Messung

Ich will eine Lageregelung (unterlagerte Drehzahlregelung).
Dazu brauch ich den Encoder.
PWM ist immer 50%, da es ja 2 um 90% phasenverschobene Signale mit 50% 
Tastverhältnis sind.

>Das Problem ist doch alt wie die Welt (der Elektronik). Wenn die
>Frequenz zu niedrig ist um zu zählen, schaltet man um auf
>Periodendauermessung.
Ja. Will ich ja machen. Mit InputCapture.

Die Frage war, muss man dazu beim STM32 alle Signale auf 2 
unterschiedliche Timer mit jeweils 2 unterschiedlichen Pins legen ?

JanK. schrieb:
> muss man dazu beim STM32 alle Signale auf 2
> unterschiedliche Timer mit jeweils 2 unterschiedlichen Pins legen ?

Ich kenne den STM nicht. Aber wenn da ein Encoder drin ist, dann ist das 
nächste Problem, dass du den Encoder-Ausgang als Capture-Eingang 
brauchst. Ich weiss nicht ob man da dran kommt.

Georg

Hi,
> Um die Drehzahl zu erfassen brauche ich ja InputCapture.
eher nicht weil du beim Pendeln falsche Drehzahlen bekommen würdest.
Was du aber machen kannst ist beim Auftreten eines Inc im 
Quadraturencoder
einen Timer auslesen (fast wie Input-Capture)und beim Auftreten des 
nächsten Inc mit der selben Richtung die Diff bestimmen... müsste 
eigentlich gehen.

Viel Erfolg, Uwe

Also ich will die Quadratur-Dekodierung nicht im Interrupt machen.
Ich will nicht bei jedem Event ein Interrupt auslösen.

Sondern den Quadratur-Encoder vor sich hin zählen lassen und in jeder 
(1ms) Task auslesen. Dort findet auch die Regelung statt.
Gleichzeitig will ich die Zeit der letzten Flanke wissen (Input 
Capture).

Dann weiss ich, in der letzten Task stand der Zähler bei 3. Jetzt bei 5.
Bei 3 war der Zeitstempel noch 1000µs. Jetzt bei 5 steht er bei 1024µs.
Dann hat der Motor also eine Drehzahl von 2Steps/24µs*K.

>weil du beim Pendeln falsche Drehzahlen bekommen würdest.
Nein. warum ?

Man muss allerhöchstens nach dem lesen des InputCapture Wertes nochmals 
prüfen, ob sich inzwischen nicht die Position verändert hat, da man 
nicht beides gleichzeitig lesen kann.

Eine Drehzahl Erfassung mit einen update jeden ms ist wenig Sinnfoll : 
Drehzaehlen aendern sich nicht schlagartig jeden ms. Die Periodendauer 
messen ist auch nicht so genau : meistens ist die duty cycle nicht exact 
50%, und das versatz zwischen A/B spur ist auch nicht exact 90°. Damit 
hat men verschiedene Periodendauer bij gleiches Drehzahl ! Auch wen die 
Periode laenger ist als 1 ms, muss die Regelung die vorher gemessene 
Periode nutzen !
Einfachste Lösung : Nur jeden 25 oder 50 ms einen Update machen, oder 
hochauflosende Encoder nutzen (1024 Polungen/Umdrehung).
Uebrigens functioniert eine Positionsregelung nicht nur auf basis von 
Drehzahlregelung : da wird eine vergleich gemacht zwischen Ist und Soll 
Position, diesen Wert wird dan mit eine P-regelung auf die Motor 
gegeben.

>Drehzaehlen aendern sich nicht schlagartig jeden ms.
Also Servomotoren haben mechanische Zeitkonstanten von etwa 1ms.
Und DC Getriebemotoren liegen auch um 10ms Bereich.
>Die Periodendauer
>messen ist auch nicht so genau : meistens ist die duty cycle nicht exact
>50%, und das versatz zwischen A/B spur ist auch nicht exact 90°. Damit
>hat men verschiedene Periodendauer bij gleiches Drehzahl ! Auch wen die
>Periode laenger ist als 1 ms, muss die Regelung die vorher gemessene
>Periode nutzen !
Das stimmt. Aber die kann (während des Betriebes) gelernt werden. Mann 
muss für Phase 0,1,2 und 3 einen Korrekturwert hinterlegen.
>Uebrigens functioniert eine Positionsregelung ..
Ja. Ich wollte einen Kaskadenregler mit unterlagerter Drehzahlregelung 
machen.

meine Geschwindigkeitserfassung ist auch viel langsamer als 1mSec. Eine 
solche Beschleunigung halte ich vielleicht theoretisch für möglich. In 
der Praxis hat der Motor aber wahrscheinlich mechanische Massen zu 
bewegen ...

>In 1ms aus dem Stand auf 63% der Maximaldrehzahl?
>Hast du da mal einen Link auf ein Datenblatt?
Leider nicht. Es war in der Vorlesung "Servomotoren". Da hatten wir das 
Modell eines Servomotors und mussten den Regler dazu entwerfen.

Egal.
Da sich meine Frage hier nicht eindeutig beantworten ließ:
Ich hab alle Quadraturencodersignale jetzt doch noch auf einen 2. Input 
Capture Eingang gelegt. Morgen mach ich das Layout und wenn ich in 2-3 
Wochen dann die Software habe postes ich es hier nochmals. (Oder schreib 
einen Artikel.)

>Hast du da mal einen Link auf ein Datenblatt?
Zum Beispiel:
http://www.moog.com/literature/ICD/Moog-ServoMotors-MDSeries-Catalog-en.pdf

Aber das grundlegende Problem bleibt noch : wass machts du bei eine 
Periodedauer laenger dan 1 ms ? Auch das Regelinterval aendern ? Dan 
wird ihre Regelung auch langsamer ! In Praxis ist das auch so das sehr 
niedrige Drehzaehlen von ein DC-Getriebemotor sich nicht schon regelen 
lassen : Das Drehmoment wird dan abhangig von stand von die Achse 
(brushed motor). Damit hat man kein Lineaires Verband zwischen PWM-Wert 
und Drehmoment. Die besten Motoren sind dan diese mit eine Eisenlose 
Anker (Maxon, Faulhaber...).

Servus,
so wie ich das verstanden haben:
Kaskadenregelung, wobei nur ein Encodersignal vorhanden ist.

Nun gut, nur so nebenbei es gibt auch Tachogenerator fürn Motor. Das 
Problem ist die Zusatzkosten + wo kommt der Encoder hin.

Mit den Encoder misst man doch nur den Winkel. Dann gilt:
omega=d_pfi/dt. Hier schließt sich heraus, dass man nur eine 
Differenzenbildung machen muss und diese durch die Abtastzeit teilen.

WorstCase:
Motor hat mehrere Umdrehung gemacht wärend der Abtastzeit. Wie bestimmt 
man das?

Ich würde die Encoder Register auf volle 16bit setzen, dann kann sowas 
nicht passieren. Bei jeder Abtastung Differenz bilden und Register 
wieder Rücksetzen. Ganz einfach. Eventuell noch ein Tiefpass verpassen.

Eine andere Möglichkeit wäre: Viele Encoder geben ein zusätzliches 
Signal bei einer bestimmten Umdrehung, k.A etwa 90° oder bei voller 
Umdrehung. Ja, die könnte man mit einen Interrupt auch anzpfen. Ist aber 
meiner Meinung nach unnötig.

mfg

Ach ja, wenn die das KnowHow vorhanden ist, dann kann man Luenberger 
Beobachter anwenden. Steht ja in den Paper alles drin. Dadurch läuft der 
Motor schön geschmeidig. :P

Also beim PIC µC habe ich das über Timer und VELxCNT gemacht.
Das ist jetzt eine Berechnung für ein Motor mit Encoder 8192 Puls je 
Phase pro Umdrehung:

1

/********************************************************************************

2

* 1,831 ms Timer Interrupt, fuer Speed Berechnung

3

* 10000 Upm / 60 sekunden = 83,3333 Umdrehung/Sekunde

4

* 166,67 Umdrehung/Sekunde * 32768 schritte (8192pulse*4) = 5461442,56 Schritte pro Sekunde

5

* Interuppt: 1831µs = 5000UpM (max Motor) / 5461442,56 Schritte pro Sekunde

6

* 70000000 MIPS / 1000000µs * 1831µs = 128170 (0x1F4AA)

7

*********************************************************************************/

8

void __attribute__((__interrupt__,no_auto_psv)) _T7Interrupt(void)

9

{

10

  IFS3bits.T7IF = 0; //Clear Timer7 interrupt flag

11

12

  velocity_tmp = VEL1CNT;

13

14

  if (velocity_tmp<0)

15

  {velocity_positiv = velocity_tmp* (-1);}

16

  else

17

  {velocity_positiv = velocity_tmp;}

18

}

Hallo zusammen,
auch ich messe die Drehzahl mit einem Encoder.

Ich habe einen Timer (TIM1) der für die Erzeugung von PWM zuständig ist. 
Dieser ist in Center-Aligned-Mode konfiguriert. Bei jedem Überlauf bzw. 
wenn der max. Wert von 2047 erreicht wird, wird ein Interrupt ausgelöst. 
In der ISR wird der Zählerstand des Encoder-Timers abgespeichert (in der 
Variable zaehlerstand_neu). In einer zweiten Variable (zaehlerstand_alt) 
ist am Anfang eine 0 gespeichert. Als nächstes berechne ich die 
Differenz dieser zwei Variablen. Hiermit weiß ich, um wieviel 
Encoderschritte der Rotor sich bewegt hat. Da das ganze in einer ISR 
berechnet wird, weiß ich auch die Zeit. Ich habe also den Weg und die 
Zeit(die Sample Time), die zwei Sachen die man benötigt um eine 
Geschwindigkeit(Drehzahl) zu berechnen. Ich hier nicht viel zu viel 
erklären weil es dann zu viel wird. Hier mein Code:

1

void Encoder_TimerInit(void)

2

{

3

  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_AFIO, ENABLE);

4

5

  GPIO_InitTypeDef GPIO_InitStructure;

6

  GPIO_InitStructure.GPIO_Pin     = GPIO_Pin_4 | GPIO_Pin_5;

7

  GPIO_InitStructure.GPIO_Mode     = GPIO_Mode_IN_FLOATING;

8

  GPIO_InitStructure.GPIO_Speed     = GPIO_Speed_50MHz;

9

  GPIO_Init(GPIOB, &GPIO_InitStructure);

10

11

    GPIO_PinRemapConfig(GPIO_PartialRemap_TIM3, ENABLE); // siehe s.178 ReferenceManual

12

13

14

  // Timer-Peripherietakt aktivieren

15

  RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE);

16

17

  // Modus einstellen

18

  TIM_EncoderInterfaceConfig(TIM3, TIM_EncoderMode_TI12, TIM_ICPolarity_BothEdge, TIM_ICPolarity_BothEdge);

19

20

  // Maxwert setzen

21

  TIM_SetAutoreload(TIM3, 3999);

22

23

  // Timer aktivieren

24

  TIM_Cmd(TIM3, ENABLE);

25

26

  RCC_ClocksTypeDef  RCC_Takte;

27

  RCC_GetClocksFreq(&RCC_Takte);

28

29

  f_TIM1 = RCC_Takte.PCLK2_Frequency;

30

  f_T_CA = ((int64_t)(f_TIM1))/((int64_t)4094);

31

  x = ((((int64_t)4000)<<20))/((f_T_CA));

32

}

33

34

35

36

/*** Drehzahlberechnung *****************/

37

38

int16_t drehzahl(void)

39

{

40

  direction = (TIM3->CR1 & TIM_CR1_DIR)>>4;

41

42

  zaehlerstand_neu = TIM_GetCounter(TIM3);

43

44

  if (direction == 0)   /********************************** hochzählen **************/

45

  {

46

    if(zaehlerstand_neu >= zaehlerstand_alt)

47

    {

48

      ups = (int16_t)((((int64_t)(zaehlerstand_neu - zaehlerstand_alt)<<40)/x)>>20);

49

    }

50

    else

51

    {

52

      ups = (int16_t)((((int64_t)(zaehlerstand_neu + 4000 - zaehlerstand_alt)<<40)/x)>>20);

53

    }

54

  }

55

  else           /****************************** herunterzählen **************/

56

  {

57

    if(zaehlerstand_alt >= zaehlerstand_neu)

58

    {

59

      ups = (zaehlerstand_alt - zaehlerstand_neu)/4 ;

60

    }

61

    else

62

    {

63

      ups = (zaehlerstand_alt + 4000 - zaehlerstand_neu)/4 ;

64

    }

65

  }

66

67

68

  zaehlerstand_alt = zaehlerstand_neu;

69

70

71

  return ups;

72

}

Hinweise: Mein Encoder liefert mir 4000 Schritte pro Umdrehung. Die 
Auflösung der Drehzahl ist 2 und besser gehts leider nicht.

Gruß