www.mikrocontroller.net

Forum: Mikrocontroller und Digitale Elektronik ASM: Encoder auswerten


Autor: Axel H. (mf-futzi)
Datum:
Angehängte Dateien:

Bewertung
0 lesenswert
nicht lesenswert
Hallo an alle,

ich möchte in ASM meinen Encoder auswerten. Ich wollte das so machen, 
wie es Peter Dannegger hier im Forum beschrieben hat.
Beitrag "Drehgeber auslesen"

Ich habe zwar schon mehrfach seine Beschreibung duchgelesen und versucht 
aus seinem C-Code etwas herauszulesen. Aber an einer Stelle komme ich 
einfach nicht weiter.

Das habe ich bis jetzt gemacht:
Testboard mit ATMEGA 8, 2 Leds und 4-zeiliges LCD angeschlossen. Durch 
die Leds kann ich den Zustand der Encoder-Pins erkennen. Im LCD lasse 
ich mir den Dezimalwert (umgewandelter Gray-Code) der Pins anzeigen. 
Richtige Reihenfolge ist nun 0-1-2-3-0 bzw 0-3-2-1-0.
Ich verwende einen STEC11B03 Encoder von Reichelt mit Rastung. Rastung 
ist bei 0 und 2.

Mein Code im Timer-Interrupt (Codeausschnitt siehe Anhang).

Es wäre schön, wenn mir jemand sagen könnte, wie der Code nun weiter 
gehen muss.

Axel

Autor: sinusgeek (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hi Axel

Ich gehe davon aus, Du möchtest einen handbedienten rastenden 
mechanischen Drehgeber auswerten.

So wie Du angefangen hast, wird das nur Pfusch. Schau Dir mal Falks 
Artikel im Wiki an:
http://www.mikrocontroller.net/articles/Drehgeber

Um das umzusetzen, brauchst Du erstmal einen Timer, der Dir etwa alle 
1ms einen Interrupt auslöst. Ob nun die Drehgeberauswertung in der ISR 
erfolgt, oder durch einen Merker (Semaphore, Flag) synchronisiert wird, 
ist erstmal Nebensache, das entscheidet sich, wenn der Rest der Aufgaben 
des Programms bekannt ist.

Wenn Du dann (ohne Warteschleifen!) in der Lage bist, einen Job alle 1ms 
aufzurufen, dann kannst Du Dich um die eigentliche Drehgeberauswertung 
kümmern.

Dazu
- liest man den Zustand ein,
- maskiert alle anderen Bits aus,
- ORt den um 2 Bits verschobenen Zustand vom letzten mal dazu und
  erhält eine 4-Bit-Zahl.
- Man setzt den Z-Pointer (für LPM, also mit doppeltem Wert der Adresse)
  auf eine Tabelle mit 16 Einträgen, in der die Zählwerte (-1, 0, +1)
  der Zustandswechsel stehen,
- addiert den bereits ermittelten Zustandsmix als Offset dazu,
- pickt sich mit LPM den Zählwert (das Inkrement) aus der Tabelle
- und addiert diesen zum aktuellen Zählerstand.
Der aktuelle Zählerstand wird also um 1 vermindert (-1), um 1 erhöht 
(+1)oder bleibt gleich (0).

Ein Beispiel findest Du hier:
Beitrag "Kleiner Funktionsgenerator mit Tiny2313"

Der relevante Codeblock ist dieser:
drehgeber:          ;wertet Drehgeberbewegungen aus
 in wl,dgpin                ;Drehgeber-Port einlesen
 andi wl,dgneumsk           ;nur die benutzten Bits werten
 lsl dgalt                  ;altes Drehgeber-Bitmuster
 lsl dgalt                  ;nach oben schieben
 or dgalt,wl                ;neue Drehgeberbits einblenden
 andi dgalt,dgaltmsk        ;Index begrenzen (uralt löschen) 
 ldi zl,low(dgtab*2)        ;Tabelle mit
 ldi zh,high(dgtab*2)       ;Dregheber-Increment-Werten
 add zl,dgalt               ;Index addieren
 adc zh,null                ;evtl. Übertrag berücksichtigen
 lpm wl,z                   ;Inkrement-Wert holen (0, +1 oder -1)
 ;in wl steht das Drehgeber-Inkrement, das die Drehrichtung angibt
 tst wl                     ;wurde der Drehgeber gedreht?
 brne drehgeber00           ;ja...
 rjmp drehgeber_end         ;nein, weiter...
drehgeber00:        ;am Drehgeber wurde (wirklich) gedreht
 mov dgi,wl                 ;Drehgeber-Increment übernehmen
drehgeber0:         ;am Drehgeber wurde (virtuell) gedreht
 add dgz,dgi                ;Drehgeber-Increment aufaddieren
 ;... (hier war die Begrenzung des Zählumfangs und noch etwas mehr)
drehgeber_end:
 ret                        ;fertig, zurück...

dgtab:      ;Tabelle mit Drehgeber-Werten (alt-alt-neu-neu als Index)
                    ;aa nn,     aa nn
.db     0, 0        ;00 00,     00 01
.db     1, 0        ;00 10,     00 11
.db     0, 0        ;01 00,     01 01
.db     0,-1        ;01 10,     01 11
.db    -1, 0        ;10 00,     10 01
.db     0, 0        ;10 10,     10 11
.db     0, 1        ;11 00,     11 01
.db     0, 0        ;11 10,     11 11

Die Routine wird als Unterprogramm im festen Zeitraster von etwa 1ms 
aufgerufen, dieses Tempo reicht für handbetätigte rastende Drehgeber. Da 
es verschiedene Ausführungen von Drehgebern gibt, muss die Tabelle zum 
Drehgeber passen. Die Beispieltabelle passt zu den preiswerten 
Drehgebern von Pollin (die mit dem dicken Knopf).

Die Deklaration der verwendeten Konstanten und Registernamen findest Du 
im verlinkten Originalcode.

~

Autor: sinusgeek (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> - addiert den bereits ermittelten Zustandsmix als Offset dazu,

Hier ist natürlich Index gemeint und nicht Offset, sorry

~

Autor: Axel H. (mf-futzi)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo  sinusgeek,

danke erstmal für deine Antwort.
> So wie Du angefangen hast, wird das nur Pfusch.
Also wenn du das bezüglich des LCDs und der Leds meinst, das habe ich 
nur zur Überprüfung meiner Werte angeschlossen. Wenns funktioniert 
entferne ich das LCD und die LEDs wieder.

Ich hab schon eine sehr hohe Meinung von Peters Codes und Beiträgen. 
Deshalb hab ich in diese Richung angefangen.

Habe mir auch einige andere Beiträge über Encoder hier aus dem Forum 
ausgedruckt und angesehen. Leider hab ich absolut null Plan von C, kann 
das also nicht für mich in ASM umwandeln.
Werde mir aber erstmal deinen Code und den Beitrag von Falk zu Gemüte 
führen. Ich wollte aber auch verstehen wie's funktioniert und nicht 
einfach kopieren und einfügen.

Axel

Autor: Stefan B. (stefan) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Axel Hüser wrote:

> Das habe ich bis jetzt gemacht:
> Testboard mit ATMEGA 8, 2 Leds und 4-zeiliges LCD angeschlossen. Durch
> die Leds kann ich den Zustand der Encoder-Pins erkennen. Im LCD lasse
> ich mir den Dezimalwert (umgewandelter Gray-Code) der Pins anzeigen.
> Richtige Reihenfolge ist nun 0-1-2-3-0 bzw 0-3-2-1-0.

Da bist du doch schon sehr weit. Du kannst schon die Drehrichtung 
feststellen (aufsteigende oder absteigende Zahlenreihe) und bekommst 
beim Drehen sich ändernde Werte. Beides kannst du auswerten, um eine 
Variable und damit einen Ausgang am AVR o.ä. zu verändern. Was willst du 
denn mit dem Drehgeber beeinflussen?

Autor: spess53 (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hi

Noch was zu Gemüte führen:

TIMER0_COMPA:         push r24                   ; Timer0 CompareA
                      in r24,SREG                ; Aufruf 1ms Takt
                      push r24
                      push r25
                      push ZL
                      push ZH
                      in r24,PINB                ; Tasten
                      in r25,PINE                ; Drehgeber
                      com r24
                      com r25                    ; beide invertieren
                      swap r24                   ; Werte nach unteres 
Nibble
                      lsr r24                    ; nach Bit 2:0
                      andi r24,0b00111000        ; Rest ausblenden
                      swap r25                   ; werte nach oberes 
Nibbble
                      lsr r25                    ; nach Bit 5:3
                      andi r25,0b00000111        ; Rest Ausblenden
                      or r24,r25                 ; zusammensetzen
                      push r24                   ; Merken
                      in r25,GPIOR0              ; alter Wert
                      push r25                   ; Merken
                      out GPIOR0,r24             ; neuen Wert speichern
                      eor r25,r24                ; Änderungen?
                      and r25,r24                ; nur wenn Taste 
gedrückt
                      out GPIOR1,r25             ; Änderungen Speichern

                      lds ZL,ticksL
                      lds ZH,ticksH
                      adiw ZH:ZL,1
                      sts ticksH,ZH
                      sts ticksL,ZL
                                                 ; Encoder bearbeiten
                      pop r25                    ; alter Wert
                      pop r24                    ; neuer Wert
                      andi r24,0b00000011        ; nur Encoderbits
                      andi r25,0b00000011
                      lsl r25
                      lsl r25
                      or r24,r25                 ; als Adresse 
zusammensetzen
                      clr r25
                      ldi ZL, Low(steps<<1)
                      ldi ZH,High(steps<<1)
                      add ZL,r24
                      adc ZH,r25                 ; Tabellenadresse
                      lpm r25,Z                  ; Drehgeberwert
                      in r24,GPIOR2              ; alte Impulszahl
                      add r25,r24                ; + neue
                      out GPIOR2,r25             ; speichern

                      ser r24
                      sts ms_flag,r24            ; Flag setzen

                      lds r24,cd_flag            ; wenn cd_flag>0 kein
                      tst r24                    ; Count_down
                      brne TIMER0_COMPA10

                      lds r25,count_downH        ; Count Down
                      lds r24,count_downL
                      sbiw r25:r24,1
                      sts count_downH,r25
                      sts count_downL,r24
                      or r24,r25
                      brne TIMER0_COMPA10

                      lds ZL,cd_funcL            ; wird bei abgelaufenen
                      lds ZH,cd_funcH            ; count down ausgeführt
                      icall

                      ldi r24,1
                      sts cd_flag,r24


TIMER0_COMPA10:       pop ZH
                      pop ZL
                      pop r25
                      pop r24
                      out SREG,r24
                      pop r24
                      reti

steps:               .db 0 ,0 ,0 ,0
                     .db -1,0 ,0 ,1
                     .db 1 ,0 ,0,-1
                     .db 0 ,0 ,0 ,0


Ist etwas länger, weil noch einige andere Funktionen bearbeitet werden. 
Der Countdown stellt zum Beispiel einen veränderten Wert zurück, wenn 
innerhalb einer bestimmten Zeit der Taster des Encoders nicht gedrückt 
wird. Ist für einen ATMega1281. Als Speicher für alte Zustände dienen 
die GPIO-Register

MfG Spess

Autor: Axel H. (mf-futzi)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hi Stefan,

> Was willst du denn mit dem Drehgeber beeinflussen?

Ich will damit ein Menü im LCD steuern (= Zähler rauf oder 
runterzählen). D.h. mit Rechts- und Linksdrehen durchs Menü scrollen und 
mit dem Encoder-Taster den Menüpunkt aktivieren.



Axel

Autor: sinusgeek (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> > So wie Du angefangen hast, wird das nur Pfusch.

Dies bezog sich einzig und allein darauf, dass ich auf den ersten Blick 
weder Interrupt-Vektoren noch eine Timer-ISR gesehen habe. Dies ist aber 
nach der in Falks Wiki-Artikel beschriebenen Methode erforderlich. Auch 
das darin enthaltene C-Programm von Peter Dannegger arbeitet mit 
Timer-Interrupt. C kann ich nicht, Peters Programm wird aber auch nicht 
viel anders arbeiten als die oben von mir vorgestellte ASM-Routine, die 
übrigens auch nur eine ADM-Umsetzung dessen ist, was Falk hier in 
irgendeinem Thread mal in Worten (als Algorithmus) formuliert hatte.

~

Autor: Axel H. (mf-futzi)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo  sinusgeek,

> ...dass ich auf den ersten Blick weder Interrupt-Vektoren noch eine Timer-ISR 
gesehen habe.

Das ist in meinem Programm schon soweit alles pefekt vorhanden. Ich 
wollte mich hier im Forum nur auf die Drehgeber-Auswertung beschränken 
und nicht seitenweise Programm-Code in den Anhang stellen, der für mein 
Problem nicht direkt relevant ist.

Also konkret scheitert es im Moment daran, den alten Zustand mit dem 
neuen Zustand zu vergleichen, bzw wie/wann ich eine Zustandsänderung 
abspeichere.



Axel

Autor: sinusgeek (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> Das ist in meinem Programm schon soweit alles pefekt vorhanden.

Dann entschuldige bitte meine voreilige Äußerung.

Beide Drehgeberspuren (in Hardware) möglichst auf benachbarte Bits 
legen.  Vorteilhaft sind die Bits 0 und 1, oder auch 2 und 3 (dann muss 
man eben andersherum schieben). Andere Aufteilung geht auch, erfordert 
aber mehr Aufwand (Swap, lsl/lsr)

> Also konkret scheitert es im Moment daran, den alten Zustand mit dem
> neuen Zustand zu vergleichen,

Der Vergleich erfolgt dadurch, dass die zwei neuen Bits und die zwei 
alten Bits zu einem Nibble zusammengebastelt werden, das dann als Index 
auf das Array mit Inkrement-Werten genutzt wird...

Angenommen, die Spuren liegen an Bit 0 und 1. Dann müssen diese mit den 
(gemerkten) Bits der letzten Runde ergänzt werden, die dann in Position 
2 und 3 müssen. Somit hast Du eine 4-Bit-Zahl, die aus zwei neuen und 
zwei alten Bits besteht. Dies ist der Index auf das Array (Tabelle) im 
Flash. Für jede Bitkombination, die keinen oder beide Pegelwechsel 
enthält, wird in der Tabelle eine 0 eingetragen, denn diese sind 
Stillstand (keine Flanke) oder verboten (beide Flanken). Für jede 
einzelne Flanke, die durch Rechtsdrehung entsteht wird eine 1 
eingetragen. Für jede Flanke, die durch Linksdrehung entsteht, wird eine 
-1 (255) eingetragen. Da die Drehgeber unterschiedlich viele Flanken pro 
Rastung haben können, müssen bei einigen Typen einige Zählwerte 
zusätzlich auf 0 gesetzt werden.

> bzw wie/wann ich eine Zustandsänderung
> abspeichere.

Du brauchst eine Speicherzelle, in der Du den alten Zustand sicherst. 
Spess nahm dazu ein GPIOR (hat der Mega8 nicht), ich nahm ein Register, 
da noch welche frei waren. Das Register ermöglicht auch das einfache 
Verschieben der Bits (LSL/LSR). Wenn ich den letzten Status in diesem 
Register gespeichert habe, kann ich den neuen Status in ein Tempregister 
einlesen, die irrelevanten Bits durch AND(I) ausblenden, den gemerkten 
alten Zustand (im anderen Register) um zwei Bits nach links verschieben, 
die neuen Bits aus dem Tempregister mit OR dazu kopieren (Bit 0 und 1 
ist neuer Zustand, Bit 2 und 3 ist alter Zustand, Bit 4 und 5 ist uralt 
und wird gelöscht, Bit 6 und 7 wurde letztes mal schon gelöscht, als sie 
noch auf 4 und 5 waren) und mit AND(I) die unteren 4 Bits stehen lassen, 
also die oberen 4 Bits löschen. Die dabei entstehende Zahl ist 4 Bit 
breit (Werte 0..15) und enthält eine von 16 möglichen Konstellationen 
der Zustände alt-neu (sieha Absatz oben). Und nun wird einfach aus der 
LUT der Wert geholt, der dem Index entspricht. Der Index wird dabei 
nicht verändert und bleibt bis zur nächsten Runde gespeichert, in der er 
wieder um 2 Bits nach links geshiftet wird, wodurch Platz für die 2 
neuen Bits geschaffen wird.

Ich hoffe, dass diese (anders formulierte) Erklärung zum Verständnis 
beiträgt.

~

Autor: Axel H. (mf-futzi)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo  sinusgeek,

vielen Dank für die super ausfühliche Erklärung. Ich denke damit komme 
ich jetzt erstmal weiter.

Ich melde mich auf jedenfall nochmal, ob es geklappt hat. Hab ja noch 
ein paar Tage Urlaub ;-)


Axel

Autor: Axel H. (mf-futzi)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo,

ich habe nun erstmal die Encoder-Auswertung nach dem Prinzip von Peter 
Dannegger hinbekommen. In der Timer-ISR habe ich folgenden Code:

encoder:
  in     neu, TAS_Pin             ; Tastenport einlesen.
  andi   neu, (1<<Enc1)|(1<<Enc2) ; Nur Encoder-Pins berücksichtigen.

  ldi    temp1, 0b00000001        ; Wenn Bit1 gesetzt ist, Bit0
  sbrc   neu, 0b00000001          ; togglen. (=Gray-Code in Binär-
  eor    neu, temp1               ; Code ändern).

  cp     neu, last                ; Wenn neu und last gleich sind,
  breq   end_encoder              ; keine Änderung -> zum Ende,
                                  ; ansonsten hier weiter...

  sub    last, neu                ; Die Differenz zwischen 2 aufein-
                                  ; ander folgenden Codes ermitteln.

  andi   last, 0b00000010         ; Bit1 ausmaskieren und
  subi   last, 1                  ; 1 abziehen. Korrekte Ergebnisse:
  mov    temp1, last              ;  1 für Rechtsdrehen oder
                                  ; -1 (255) für Linksdrehen.

  andi   last, 0b00000001         ; Vom Ergebnis Bit0 ausmaskieren. Wenn
  tst    last                     ; Differenz 0 oder 2 ist (Bit0=0),
  breq   end_encoder              ; keine Änderung oder ungültig
                                  ; -> zum Ende springen.

  mov    encdir, temp1            ; Drehrichtung speichern.
  mov    last, neu                ; Neuer Zustand ist nun letzter
                                  ; Zustand
end_encoder:


Das Ergebnis dieser Routine ist die Drehrichtung 1 oder -1 (255). Ich 
speichere das Ergenis im Register encdir ab, und werte es im 
Hauptprogramm aus (ähnlich wie Tastenentprellung). Das hat den Vorteil, 
dass der Code im Timer-Interrupt sehr kurz bleibt und ich im 
Hauptprogramm die Möglichkeit habe, verschiedene Zählsprünge einstellen 
zu können (z.B.: 1,2,3,... oder 10, 20, 30,... oder a, b, c, ...). 
Funktioniert toll. Ich kann das im LCD überprüfen, in dem ich eine 
Variable rauf/runter zählen lasse.

Axel

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.