Drehencoder am PIC 16F628

[Bernd P. (bertron)]

Hallo,

ich möchte einen Drehencoder (mechanisch) mit einem PIC 16F628 
auswerten. Der Encoder hängt am PortA, am PortB hängen 8 LEDs, von denen 
jeweils eine leuchtet.
Erste Versuche habe ich mit einem Code von Sprut gemacht, aber der 
funktioniert leider nicht zuverlässig (einzelne LEDs werden 
übersprungen):
http://www.sprut.de/electronic/pic/programm/rotary2/rotary2.html

Hat jemand vielleicht schonmal den hier mehrfach erwähnten und wohl sehr 
zuverlässigen Code von Peter Dannegger für den PIC 16F628 umgeschrieben?

Bin dankbar für jede Hilfe.

Bernd

[Jens (Gast)]

Also ich würde mir überlegen, den Encoder vielleicht lieber an die 4 
Lower Bits des PORTB zu hängen, weil du dort einen Interrupt auslösen 
lassen kannst, wenn sich einer der RB0:3 (natürlich als Input 
konfiguriert) ändert. Das könnte das "Übersehen" von Impulsen 
reduzieren.

Aber im Allgemeinen sind Drehencoder nicht sooo nett, die überspringen 
gerne mal einen, daher solltest du das bei deiner Auswertung 
berücksichtigen; siehe dir dazu mal den Wiki-Artikel an: 
http://www.mikrocontroller.net/articles/Drehgeber

Gruß
Jens

[ich (Gast)]

Ich weiß nicht, ob meine Methode irgendwie verpöhnt ist, ich hab das 
folgender Maßen gemacht:
Diagramm: 
http://www.reichelt.de/index.html?;ACTION=7;LA=3;OPEN=0;INDEX=0;FILENAME=B400%252FSTEC11B.pdf;SID=323ulPNqwQASAAAEo2Sz4fedeedafe8a74e4bffc78de65e77b735 
, Seite 8 oben rechts.

Ich überprüfe nur einen der Beiden Eingänge auf eine steigende Flanke 
(z.B. Leitung A). Wenn im aktuellen Durchlauf der Eingang auf High ist 
und im vorherigem Durchlauf auf Low war (Variable zum speichern), dann 
überprüfe den 2. Eingang (Leitung B). Ist Dieser Low, wurde im UZS 
gedreht und wenn der Eingang High ist, wurde gegen den UZS gedreht. Nach 
einer Flanke muss lediglich x Millisekunden gewartet werden, um ein 
Prellen zu unterdrücken. Dabei könnte theoretisch fast eine halbe 
Periodendauer gewartet werden, was aber ansich unnötig ist.
Vorteil finde ich ist, dass man nur einen Eingang pollen und entprellen 
muss und das die Auswertung ziemlich Simpel ist. Nachteil weiß ich eben 
nicht, bei mir hats bisher sehr gut funktioniert. Man braucht nur einen 
Drehimpulsgeber, der soviele Impulse wie Rastungen hat, z.B. STEC11B09: 
Impulse: 20, Rastungen: 20. Sonst müsste man beide Flanken auswerten.

[ich (Gast)]

Ach und ..

Jens schrieb:
> Also ich würde mir überlegen, den Encoder vielleicht lieber an die 4
> Lower Bits des PORTB zu hängen...

Wieso 4? Die haben doch nur 3 Anschlüsse und einer davon ist Vdd bzw. 
Vss, oder?

Ich hab mir das immer so Vorgestellt, dass man 2 Kurzhubtaster hat, die 
in einer Platte eingelassen sind und dann rollt man mit einem großem 
Reifen oder großen Rolle einmal von links nach rechts und einmal von 
rechts nach links rüber. Da kann man dann die Richtung bestimmen, die 
Anschlüsse sind gleich und Taster prellen auch usw.

[Grübler (Gast)]

ich schrieb:
> Ich überprüfe nur einen der Beiden Eingänge auf eine steigende Flanke
> (z.B. Leitung A). Wenn im aktuellen Durchlauf.....

So mach ich das auch. Kontakt A frage ich im Zeittakt
von 1ms ab. 10-20ms ist für normale Tasten besser.
Bei Encodern bekommt man aber bei schnellem Drehen
Schwierigkeiten mit der Auswertung.

[Jens (Gast)]

ich schrieb:
> Wieso 4? Die haben doch nur 3 Anschlüsse und einer davon ist Vdd bzw.
> Vss, oder?

Es ging um den PORTB, der hat vier untere Bits, und die sind alle im 
Interrupt des PORTB-Wechsels drin, das meinte ich.

Gruß
Jens

[Bernd P. (bertron)]

Vielen Dank für Eure Antworten.
Leider bin ich blutiger Anfänger in Sachen Assemblerprogrammierung für 
PICs.
Ich habe jetzt den ganzen Vormittag verschiedenes ausprobiert, aber 
alles ohne Erfolg.
Hier nochmal der Code von Sprut - im Prinzip funktioniert der ja, nur 
nicht so zuverlässig. Hat jemand einen Tip, was man da ändern könnte 
oder vielleicht doch nicht einen anderen zuverlässigen ASM-Code für 
diese Aufgabe?

        list p=16f628
;**************************************************************
;*      Pinbelegung
;*      ----------------------------------      
;*      PORTA:  0 < rotary encoder - B Pin4
;*              1 < rotary encoder - A Pin5
;*              2 < H=zaehlen      L=schieben
;*              3 < H=invers       L=normal
;*              4 < H=einschrittig L=zweischrittig
;*              5 -
;*              6 -
;*              7 -
;*
;*      PORTB:  0 > LED
;*              1 > LED
;*              2 > LED
;*              3 > LED
;*              4 > LED
;*              5 > LED
;*              6 > LED
;*              7 > LED
;*      
;**************************************************************
;
;sprut (zero) Bredendiek 01/2003 .. 12/2008
;
; Rotary-Encoder mit LED Zeile
;
; Prozessor 16F628
;
; Prozessor-Takt 4 MHz intern
;
; Rotary Encoder am PortA 0 & 1
; LED-Zeile am PortB
;
;**************************************************************
; Includedatei für den 16F628 einbinden

        #include <P16f628.INC>

        ERRORLEVEL      -302            ; SUPPRESS BANK SELECTION MESSAGES


; Configuration festlegen:
; Power on Timer, kein Watchdog, interner 4-MHz-Oscillator, kein Brown out, kein LV-programming
        __CONFIG        _PWRTE_ON & _WDT_OFF & _INTRC_OSC_NOCLKOUT & _BODEN_OFF & _LVP_OFF

; Constanten festlegen
#define encoder PORTA
#define LED     PORTB

; Variable festlegen
temp    equ     0x20                    ; Arbeitsregister
counter equ     0x21                    ; Zählstand
alt     equ     0x22                    ; alte Rotor-Position
neu     equ     0x23                    ; aktuelle Rotorposition
puffer  equ     0x24                    ; Arbeitsregister

;**************************************************************
; Programmanfang

        org     0
        goto    init


;**************************************************************
; Tabelle zur Wandlung von Binär in 1-aus-8-Code
; look up table
lut
        addwf PCL, f
        retlw B'00000001' ; 0
        retlw B'00000010' ; 1
        retlw B'00000100' ; 2
        retlw B'00001000' ; 3
        retlw B'00010000' ; 4
        retlw B'00100000' ; 5
        retlw B'01000000' ; 6
        retlw B'10000000' ; 7

;**************************************************************
; Initialisierung *********************************************

init
        bsf     STATUS, RP0             ; Bank 1
        clrf    OPTION_REG
        movlw   B'00000000'             ; PortB alle outputs
        movwf   TRISB
        bcf     STATUS, RP0             ; Bank 0
        clrf    PORTB                   ; LEDs aus
        clrf    INTCON                  ; Interupt disable


; 16F628 alle Comparatoreingänge auf Digital umschalten
        BSF     CMCON, CM0
        BSF     CMCON, CM1
        BSF     CMCON, CM2

        clrf    counter
        movfw   encoder
        movwf   alt                     ; aktuelle encoder-Stellung lesen
        movlw   B'00000011'
        andwf   alt, f                  ; nur 2 LSB stehen lassen

;Hauptprogrammschleife
loop
        call    read_encoder            ; Rotary Encoder abfragen
        movfw   counter                 ; das Zaehlergebnis nach w

        btfsc   PORTA, 4                ; ein- oder zwei-schrittig?
        goto    einschritt              ; springen zu einschrittig
        ; Division des Zaehlerstandes durch 2
        movwf   puffer
        bcf     STATUS, C
        rrf     puffer, w               
einschritt

        btfsc   PORTA, 2                ; zaehlen oder schieben?
        goto    binaer                  ; springen zur Anzeige des 8-Bit-Zaehlergebnisses
        ; Anzeige einer von 8 LEDs
        andlw   B'00000111'             ; auf 0..7 begrenzen
        call    lut                     ; led-position holen
binaer

        btfss   PORTA, 3                ; normal oder invers?
        goto    normal                  ; springen mormalen Anzeige
        ; invertieren der Anzeige
        movwf   puffer
        comf    puffer, w               
normal
        movwf   LED                     ; Zählerstand anzeigen
        goto    loop


;**************************************************************
; Test des Encoders auf Verdrehung ****************************

read_encoder
        movfw   encoder
        movwf   neu                     ; aktuelle encoder-Stellung nach new
        movlw   B'00000011'     
        andwf   neu, f                  ; nur 2 LSB stehen lassen
        movfw   neu                     ; wurde der encoder bewegt?
        movwf   temp
        movfw   alt
        xorwf   temp, w                 ; ist neu = alt?
        bz      ende                    ; ja: nicht verdreht, also nichts tun
                                        ; nein: encoder verdreht, aber in welche Richtung?
                                        ; drehen wir mal Bit0 des alten werts zum Vergleich
                                        ;  nach links
        bcf     alt, 1
        clrc                            ; Carry-Flag löschen
        rlf     alt, f                  ; alten Encoder-Stand um 1 Stelle nach links drehen
        movfw   neu
        xorwf   alt, f                  ; falls xorf >1 ergibt, dann war es eine Rechtsdrehung
        bz      links                   ; links:  decrement counter
        decf    alt, f
        bz      links                   ; links:  decrement counter
rechts
        incf    counter, f              ; rechts:  increment counter
        goto    weiter
links
        decf    counter, f              ; links:  decrement counter
weiter
        movfw   neu
        movwf   alt                     ; neu für nächsten Vergleich als alt speichern
ende
        return

        end

[Jens (Gast)]

Also ich bin in Assembler wirklich nicht firm, und wenn du es auch nicht 
bist, dann gibt es zwei Möglichkeiten:

1. Du lernst Assembler. Dazu gehört es dann unausweichlich, den 
geposteten Code Befehl für Befehl durchzuackern, und das wird dir 
niemand abnehmen ;-)

2. Du programmierst in C (so mache ich das bis jetzt) wenn es um 
zeitunkritische Sachen geht.

Schaue mal ins Datenblatt des PIC16F628 und suche dir den Interrupt 
raus, der die Pins RB4:7 betrifft. Sorry, habe mich oben vertan, es sind 
nicht die Pins RB0:3. Der Interrupt heißt "PORTB Change Interrupt":

Zum Enablen musst du INTCON<4> setzen (RBIE = 1), und das Interrupt-Flag 
ist dann in INTCON<0>, es heißt RBIF. Denk dran, dass du noch global 
Interrupts enablen musst mit GIE = 1 bzw. gleichbedeutend INTCON<7> = 1.

Wenn du in Assembler programmierst, dann musst du aufs INTCON-Register 
zugreifen, in C kannst du direkt

GIE = 1;
RBIE = 1;

schreiben.

May the force be with you. ;-)

Gruß
Jens

[Bernd P. (bertron)]

Hi Jens,

Danke für Deine Hilfestellung. Ja, Du hast recht - Assembler lernen wäre 
das solideste. So ganz habe ich das auch noch nicht aufgegeben...
Aber ich habe die Sache jetzt auch endlich an's Laufen gebracht:
Mein encoder ist nicht zwei-  sondern vierschrittig. Habe jetzt einfach 
mal eine Division durch vier eingebaut und nun klappt es auch 
zufriedenstellend.
Auf den Sprut-Seiten findet sich auch ein weiterer, flexiblerer Code, 
der auch zweischrittige Encode unterstützt. Den habe ich dann einfach um 
die zusätzliche Division erweitert.

Bernd