Schritte vor und zurück zählen mit Inkrementalgeber

[Dog G. (dogger)]

Erst einmal Hallo
Bin ziemlich neu hier und habe bis jetzt immer direkt meine Antworten zu 
meinen Problemen gefunden !
Aber jetzt bin ich am verzweifeln !

Zu Thema:
Ich habe ein Tintenstrahldrucker so weit zerlegt das ich nur noch die 
Druckerkopfaufnahme und die Achse  auf der der Druckerkopf läuft, mit 
dem DC-Motor und den Zahnriemen.
Jetzt möchte ich den Druckerkopf auf der Achse  in meine Gewünschte 
Position bewegen ( die Position soll sich erst einmal mit einem Poti 
verändern lassen)
Um das erst einmal Technisch aufzubauen habe ich einen optischen 
Inkrementalgeber aus anderen teilen des Druckers und "Strichrasterband" 
mit gröberer Auflösung zur Position Erkennung eingebaut!

Zum Problem:
Ich schaffe es nicht die Position des Druckerkopfs genau auszulesen.
Er verzählt sich immer wieder und das schon nach der ersten links-rechts 
fahrt um 10-30 Schritte !

Ein paar Fakten:
-habe ein Arduino UNO Board mit einem ATmega328
-Der Inkrementalgeber liest mit großer Sicherheit jeden Impuls vom 
"Strichrasterband"
-Besonders langsame Fahrten 1m/h werden zum teil über Haupt nicht 
gezählt!
-Der Inkrementalgeber hat 2 digitale Ausgänge: Wenn ich eine Karte von 
links nach rechts durchzieh bleibt er auf A1=HIGH A2=LOW. Ziehe ich die 
Karte von rechts nach links bleibt er auf A1=LOW A2=HIGH.
-Ich habe sehr wenig Erfahrung in C/C++ und habe das meiste an 
Programmen mir zusammen gefummelt und verändert bis es läuft !

Mein Programm:
Ich weiß das hier vieles nicht gebraucht wird aber gehe jetzt einfach 
mal davon aus das Geschwindigkeit nicht mein Problem ist !
Wie gesagt das Programm gibt mir zwar einen Zählerstand wieder und 
erkennt auch die Richtung (zählt rauf und runter) aber lässt viele 
Schritte aus und das meist bei langsamen !

int Refahrt = LOW;
int fahrtR;
int fahrtL;
int soll;
int sollmax;
int sollmin;
int ES =6;
int reset;
int SensorL =3;
int SensorR =2;
int val;
int val0;
int SensorRst;
int SensorLst;
int StreckeR = 0;
const int LEDR =4;
const int LEDL =5;
 const int led = 9  ;
 const int led1 = 10  ; 
void setup(){
  pinMode(SensorR, INPUT);
  pinMode(SensorL, INPUT);
  pinMode(ES, INPUT);
  Serial.begin(9600);
 SensorRst = digitalRead(SensorR);
 SensorLst = digitalRead(SensorL);
  pinMode(LEDR, OUTPUT);
  pinMode(LEDL, OUTPUT);
   pinMode(led, OUTPUT);
   pinMode(led1, OUTPUT);
    
 
}
int sollAnalog ()
{
  int v;
  v = analogRead(A0);
  v -=500;
  v  /=4;
  return v;
}

void loop() {
  val = digitalRead(SensorR);  
  val0 = digitalRead(SensorL);
  digitalRead(ES);
  fahrtL = digitalRead(SensorR)== LOW & digitalRead(SensorL)== HIGH ;
  fahrtR = digitalRead(SensorR)== HIGH & digitalRead(SensorL)== LOW ;
  
if (val != SensorRst){
    if(fahrtR == LOW) {
      if(fahrtL == HIGH){
      StreckeR--;      
      }           
     }
     SensorRst = val ;
    }         
if (val0 != SensorLst){
    if( val0 == LOW) {
     if(fahrtR == HIGH){
      StreckeR++;
       
      }
     Serial.println(StreckeR);
     }
     SensorLst = val0 ;
  }

 
  
if (digitalRead(ES) == HIGH){ // Positionsangabe durch Enschalter reseten
  StreckeR = 0;
}
if (Refahrt == LOW){
  while(digitalRead(ES) == LOW ){
    analogWrite(led, 0);  // turn the LED on (HIGH is the voltage level)
    analogWrite(led1, 130);
  }
  Refahrt = HIGH;
}

 soll =  sollAnalog();
sollmin = soll - 1 ;
sollmax = soll + 1 ;
if (soll != StreckeR){
  if (sollmax <  StreckeR){
  analogWrite(led, 0);  // turn the LED on (HIGH is the voltage level)
  analogWrite(led1, 130);
 // fahrtR = LOW;
//  fahrtL = HIGH;
  }else {
    analogWrite(led1,0);
  }
  if (sollmin > StreckeR){
  analogWrite(led1, 0);    // turn the LED off by making the voltage LOW
  analogWrite(led, 130);
 // fahrtL = LOW;
 // fahrtR = HIGH;
  } else {
    analogWrite(led,0);}
                 // wait for a second
}

 // Schritt überwachung  
    if (val == HIGH) {     
    // turn LED on:    
    digitalWrite(LEDR, HIGH);  
  } 
  else {
    // turn LED off:
    digitalWrite(LEDR, LOW); 
  }
    if (val0 == HIGH) {     
    // turn LED on:    
    digitalWrite(LEDL, HIGH);  
  } 
  else {
    // turn LED off:
    digitalWrite(LEDL, LOW); 
  }
}

[Dog G. (dogger)]

Fallst jemand darauf stossen sollte !

Inkrementalgeber fuktionieren nur wenn die Scheibe oder das Band mit dem 
Strichcode genau auf den Inkrementalgeber abgestimmt ist.
Wird das raster grösser oder kleiner ist verzählt sich der 
Inkrementalgeber immer wieder und mann hat so Probleme wie ich oben !
Ansonsten fuktoniert der Code den ich oben geschrieben habe !

[skink (Gast)]

>Inkrementalgeber fuktionieren nur wenn die Scheibe oder das Band mit dem
>Strichcode genau auf den Inkrementalgeber abgestimmt ist.
Nein. Es liegt am Code.
Lies Dir mal den Artikel 
"http://www.mikrocontroller.net/articles/Drehgeber"; durch. Dort ist das 
Problem beschrieben.

Im Prinzip hast Du 4 Zustände: 00, 01, 11 und 10. Wanderst Du von einem 
der 4 Zustände nach rechts, musst Du hochzählen, wanderst Du nach links, 
runter.

[skink (Gast)]

So lässt sich übrigens einfach prüfen, ob der Code richtig ist:
Jeweils die eine und die andere Leitung trennen. Dreht man jetzt 
langsam, muss der Zähler immer eins hoch und dann wieder eins runter 
zählen. Also beispielsweise 70,71,70,71,70 ...
Zählt er weiter oder gar nicht, ist der Code falsch.

[Mike (Gast)]

skink schrieb:
> Nein. Es liegt am Code.
In diesem Fall schon, aber ...

> Im Prinzip hast Du 4 Zustände: 00, 01, 11 und 10. Wanderst Du von einem

i,A. muss der Strichcode breiter als der Geberabstand sein, damit 
sichergestellt ist, dass beim Bewegen alle vier Zustände der Reihe nach 
auftreten.

[Axel S. (a-za-z0-9)]

Wobei sich die Frage stellt, wozu man überhaupt einen zusätzlichen 
Encoder braucht. Der Schrittmotor liefert diese Information ja schon 
frei Haus.


XL

[Karl H. (kbuchegg)]

Und wenn der Schrittmotor aus irgendeinem Grund blockiert ist und nicht 
steppt, dann stimmt die Zählung nicht mehr.

[Dog G. (dogger)]

OK zugegeben ich weiss nicht mehr genau ob das Programm was da oben 
stehet noch richtig ist !

Aber ich kann sicher bestätigen das die Inkrementalgeber aus einem 
Drucker nur mit dem Strichcode laufen mit dem sie verbaut sind.

Ich habe ein größeren Strichcode gebastelt und er hat sich immer 
verzählt !

Das Programm was ich genutzt habe :

 
int B=2;
int A=3;
int Wert;

void setup (){
  attachInterrupt(0,CHAInt,CHANGE);        // Call Channel A of ENCODER Function while on CH1 Signal Changing
  pinMode(2,INPUT);
  pinMode(3,INPUT);
  digitalWrite(2,HIGH);
  digitalWrite(3,HIGH);
  Serial.begin(9600);
}

void loop(){

  // Hier kannst du dann mit der Variabeln Wert machen was du willst
Serial.println(Wert);
}

void CHAInt (){
  
  boolean Aread=false;
  boolean Bread=false;
  Aread=digitalRead(A);
  Bread=digitalRead(B);
  if (Aread==true && Bread==false||Aread==false && Bread==true){
    Wert--;
  }
  if (Aread==false && Bread==false ||Aread==true&& Bread==true){
    Wert++;
  }
}

[Fa. Rast und Ruh (Gast)]

Der Stichabstand vom Band muss zum Stichabstand der Maske passen die vor 
den Detektoren sitzt. Band und Maske haben eine Differenz im 
Stichabstand so das beim übereinanderlegen ein Interferenzmuster mit 
hellen und dunklen Stellen entsteht. An diesen Stellen sitzen die 
Phototransistoren.

[Josef D. (jogedua)]

Peter Hunsen schrieb:

> Ich habe ein größeren Strichcode gebastelt und er hat sich immer
> verzählt !

Das kann auch an anderen Unzulänglichkeiten liegen.

>
> Das Programm was ich genutzt habe :
>

>   // Hier kannst du dann mit der Variabeln Wert machen was du willst
> Serial.println(Wert);

Es muss aber sichergestellt werden, dass "Wert" nicht während der 
Benutzung in der ISR geändert wird (Stichwort ATOMIC).


>   if (Aread==true && Bread==false||Aread==false && Bread==true){
>     Wert--;
>   }
>   if (Aread==false && Bread==false ||Aread==true&& Bread==true){
>     Wert++;
>   }

Was passiert, wenn  die Interrupts so kurz hintereinander auftreten, 
dass einer nicht behandelt wird, weil die ISR noch nicht fertig ist 
(Stichwort: prellen)? Das Programm kann das so gar nicht feststellen.

Besser wäre es, statt der PinChange-Interrupts einen Timer-Interrupt zu 
benutzen und alle vier mögliche Zustände (s. weiter oben) auszuwerten.