IQ Signal (Drehgeber) Auswertung

[oberallgeier]

... Ich lasse einen Timer laufen. Bei einer pos. Flanke speichere ich den Timerwert. Bei der nächsten pos. Flanke speichere ich wieder den timerwert und bilde die Differenz. Damit kann ich mir dann die Zeit berechnen ...

Genauso mache ich das auf (m)einem ATMEL mega168, 20 MHz, Gabellichtschranke am Motor, programmiert in C. Es funktioniert zumindest so gut, dass meine beiden deutlich unterschiedlichen Motoren mit dieser Messung und der Regelung sehr schön synchron laufen - bei gleichen Vorgaben.

... Das müsste so doch auch funktionieren oder hat das einen Nachteil? ...

Nachteil: bisher hatte ich die relative Ungenauigkeit des Zeitsignals als Nachteil angesehen. Meine Motoren drehen bis 750 Hz, ich bekomme bis 1500 Interrupts pro Sekunde und messe mit meinem internen Zeitsignal, das in Zeiteinheiten zu 50 µs vorliegt. Dabei treten bei den typischerweise gemessenen 20 Zeiteinheiten für eine halbe Umdrehung schon deutliche Rundungsfehler auf - denn das geht ja nur auf 5 % genau. In der Praxis hat der Gleichlauf der beiden Motoren gezeigt, dass die Regelung diese Rundungsfehler locker ausgleichen kann. Es sind ja wohl, genau genommen, keine Rundungsfehler, sondern Ungenauigkeiten, wobei der Fehlbetrag ja bei der nächsten Messung wieder ins Messergebnis aufgenommen wird (Ausnahme: Drehrichtungswechsel).

[jaepen]

mein motor hat ein festes getriebe, daher komm ich beim motor nur auch 60 Hz

[Endress]

Das ist mal wieder typisch, erst posten, dann suchen

Hätt ich auch die Suche bemühen können, dennoch vielen Dank Fred, werd ich mir am Wochenende zu eigen machen

[jaepen]

Hallo
Also hier ist mal meine selbst geschriebene Drehrichtungsauswertung.
Der Code sollte durch die Kommentare selbsterklärend sein.
Für Tipps und/oder Hinweise bin ich dankbar

////////////////////Richtungszustände
int d1=0;		 int d2=0;		int d3=0;		//Drehgeber 1....3, Vorwärts=1 Rückwärts=0
int encoder1 [4]={0,0,0,0};					//alte und neue Drehgebersignale
int encoder2 [4]={0,0,0,0};					//[0] Spur A neu    [1] Spur B neu
int encoder3 [4]={0,0,0,0};					//[2] Spur B alt    [3] Spur B alt
 
////////////////////////////////////////////////////////////////////////////////////////////////
   ////   MAIN   //////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////

void main(void){
   	Init_Device();								// Initialisierung des Devices

 		while(TRUE){ 

d1=drehrichtungsauswertung (encoder1,d1);	 	// Aufruf der Funktion zum auswerten der Drehrichtung
d2=drehrichtungsauswertung (encoder2,d2);   
d3=drehrichtungsauswertung (encoder3,d3); 
.
.....
........

int drehrichtungsauswertung (int *encoder,int r){

int neu=00;
int alt=00;

encoder[2]	= encoder[0];		//Speichern der alten Encoderzustände
encoder[3]	= encoder[1];

encoder[0]=A1;		  			//Einlesen der neuen Encoderzustände
encoder[1]=B1;	
  	
 if (encoder[0]==0 && encoder[1]==0) neu=00;		//Wandeln des neuen Zustandes in dez. Zahl
 if (encoder[0]==0 && encoder[1]==1) neu=01;
 if (encoder[0]==1 && encoder[1]==0) neu=10;
 if (encoder[0]==1 && encoder[1]==1) neu=11;

 if (encoder[2]==0 && encoder[3]==0) alt=00;		//Wandeln des alten Zustandes in dez. Zahl
 if (encoder[2]==0 && encoder[3]==1) alt=01;
 if (encoder[2]==1 && encoder[3]==0) alt=10;
 if (encoder[2]==1 && encoder[3]==1) alt=11;

	if (alt!=neu )		//Abfrage ob sich die Zustände des Drehgebers überhaupt geändert haben
	{
	    if (alt==00) {												// Welchen "alten" Zustand hatten wir
	     		switch (neu){									
		   			case 01 :{  r=1;  break;} 						//Je nach neuem Zustand vor oder rückwärts	
					case 10: {	r=0;  break;}  } }					//Je nach neuem Zustand vor oder rückwärts

		if (alt==01) {												// Welchen "alten" Zustand hatten wir
			     switch (neu){									
				    case 11 :{  r=1;  break;} 						//Je nach neuem Zustand vor oder rückwärts	
					case 00: {	r=0;  break;}  } }					//Je nach neuem Zustand vor oder rückwärts

		if (alt==10) {												// Welchen "alten" Zustand hatten wir
			     switch (neu){									
				    case 00 :{  r=1;  break;} 						//Je nach neuem Zustand vor oder rückwärts	
					case 11: {	r=0;  break;}  } }					//Je nach neuem Zustand vor oder rückwärts

		if (alt==11) {												// Welchen "alten" Zustand hatten wir
			     switch (neu){									
				    case 10 :{  r=1;  break;} 						//Je nach neuem Zustand vor oder rückwärts	
					case 01: {	r=0;  break;}  } }					//Je nach neuem Zustand vor oder rückwärts

 								//Mögliche Fehler werden nicht abgefragt. Treten diese auf, bleibt die alte Drehrichtung gespeichert
			}					// Klammer der if (alt!=neu ) Schleife

 
 return r;						// Die Drehrichtung wir zurück gegeben (r=1 Vorwärts, r=0 Rückwärts)
}					 			//	Ende Funktion "drehrichtungsauswertung"

[Endress]

Vielleicht täusche ich mich, aber kann man sich da nicht ettliches an Code sparen, wenn man die Interrupts benutzt ?

[Endress]

und weil wir gerade beim Thema sind:

Ich möchte nach folgender Manier einen Drehgeber auswerten:

void Timer1_ISR(void)
{
    PM_WertHoch=Timer_T1GetPM();                    
    Irq_GetCount(INT_TIM1CAPT);
    Ausgabe();
}

Interruptroutinen sind definiert:

void init(void)
{
   Irq_SetVect(INT_TIM1CAPT, Timer1_ISR);
}

void ausgabe(void)
{
   Msg_WriteWord(PW_WertHoch);
}

void main(void)
{
   while(1)
}

Ich hab den zweiten Timer ausgelassen, zur Veranschaulichung reicht einer. Eine Auswertung des Wertes kommt dann, wenn ich nen Wert bekomme....
A+ und B+ des Drehgebers liegen direkt auf PD6 und PE6, der Drehgeber wird mit 5 Volt gespeist.

Ich hab auch schon Testausgaben in die Interruptroutinen eingefügt, sie werden definitiv nicht angesprungen.
An den beiden Timern liegen die 5 Volt messbar an.

Was mach ich falsch ?

Danke und Gruss, Endress