; Library für Programme rund um die Keypad Ansteuerung
; Folgende definitionen müssen entweder im Hauptprogramm oder in dieser Library
; gemacht werden. Die Tastatur muss an einen Port angeschlossen sein.
;
;Keypad equ P1
;Key_row1 equ P1.3         ;Row equ  Zeile equ  waagerecht
;Key_row2 equ P1.2
;Key_row3 equ P1.1
;Key_row4 equ P1.0
;Key_col1 equ P1.6         ;col equ  Spalte = senkrecht
;Key_col2 equ P1.5
;Key_col3 equ P1.4
;Key_col4 equ P1.7  ;Dummyeintrag, damit gleiche Source verwendet werden kann
;Key_nokeyval equ  11110000B  ;Setzt alle Reihen auf "L"
;Key_numcol equ 3             ;Anzahl der Spalten

; Zuordnung der Returnwerte (in Hex), die zurückgegeben werden
;KeyTab .db 1,2,3           ;Tabelle je nach Keyboard Tastaturbelegung
;       .db 4,5,6
;       .db 7,8,9
;       .db 0aH,0,0BH       ;den Sonderzeichen * und # sind 0x0a und 0x0b
                            ;zugeordnet

;KeyASCIItab
;       .text "0123456789*#"
;Asciiwert in der Reihenfolge der Hexwert Zuordnung (hat nichts mit
;der Anordnung der Tasten zu tun!)
;
; In dieser Library habe ich eine vordefinition für 2 verschiedene Keypads
; eingebaut, die je nach bedarf auskommentiert werden können.
; Falls der Compiler   if Verzweigungen handhaben kann, kann natürlich auch
; damit umgeschaltet werden.
;
; Die definition ist so flexibel wie möglich gehalten, ohne das Programm
; allzu sehr aufzublähen


;Hier starten die Unterprogramme. Folgende Routinen sind enthalten:
;
; KEYread    Bei nicht gedrückter Taste return mit Carry=0
;            Bei gedrückter Taste wird der in KeyTab definierte Wert im Akku
;            zurückgegeben. Carry=1
; KEYascii   Wie KEYread, gibt aber den in KeyASCIItab definierten Character
;            im Akku zurück.
; KEYrelease Wartet so lange bis die Taste losgelassen wird, danach return.
;            Sorgt ausserdem für ein entprellen der Tasten
;

KEYread
       mov Keypad,#11111111B     ;Alle Bits gesetzt, Start
       mov A,#0                  ;Check Row1, nichts dazuaddieren
       clr Key_row1              ;Jetzt wird die erste Zeile "L"
       acall KEY_chk_col         ;Checkt ob Taste gedrückt ist
       setb Key_row1             ;falls keine Taste der letzten Reihe -> nächste
       mov A,#Key_numcol         ;Anzahl der Stellen pro Reihe dazuzählen
       clr Key_row2              ;z.B. bei numcol=3
       acall KEY_chk_col
       setb Key_row2
       mov A,#(2*Key_numcol)     ;Anzahl der Stellen pro Reihe dazuzählen
       clr Key_row3
       acall KEY_chk_col
       setb Key_row3
       mov A,#(3*Key_numcol)     ;Anzahl der Stellen pro Reihe dazuzählen
       clr Key_row4
       acall KEY_chk_col
  ; Falls die Tastatur weniger Reihen besitzt, die "überflüsseigen"
  ; Zeilen auskommentieren

      clr C                ;Carry = 0 Keine Taste gedrückt
      ret

KEY_chk_col                 ;bei weniger Reihen entsprechend
       jnb Key_col1,KEY_C1  ;Zeilen wegnehmen
       jnb Key_col2,KEY_C2
       jnb Key_col3,KEY_C3
       jnb Key_col4,KEY_C4
       ret
KEY_C1 add A,#0             ;1. Taste = Wert + 0
       sjmp KEY_End
KEY_C2 add A,#1             ;2. Taste = Wert + 1
       sjmp KEY_End
KEY_C3 add A,#2             ;usw.
       sjmp KEY_End
KEY_C4 add A,#3

KEY_End
       pop DPL           ;Dummy Register zum
       pop DPH           ;löschen der alten Rücksprungadresse aus Stack
       mov DPTR,#KeyTab  ;Einstellen der Tabelle
       movc A,@A+DPTR    ;Holen des entsprechenden Wertes
       setb C            ;Carry = 1 Taste wurde gedrückt
       ret               ;weil die letzte Rücksprungadresse gelöscht wurde
                         ;erfolgt Return zum aufrufenden Hauptprogramm !



KEYascii                 ;Wandelt den Tastaturcode in ASCII
       lcall KEYread     ;holt ganz normal den Hexwert der Taste
       jnc KEYascii_End  ;Carry=0 -> keine Taste gedrückt
       mov DPTR,#KeyASCIItab  ;Tabellenwert setzen
       movc A,@A+DPTR    ;hole passenden Wert aus der Tabelle
       setb C            ;Carry=1 -> Taste war gedrückt
KEYascii_End
       ret


KEYrelease               ;wartet bis Taste losgelassen
       push ACC          ;Akku sichern
       mov A,#Key_nokeyval
       mov Keypad,A      ;Alle Zeilen = "L"
KEY_pressed
       mov A,Keypad      ;Prüft ob Reihe auf "L" geht
       cjne A,#Key_nokeyval,KEY_pressed ;Warte bis Taste losgelassen
  ;Für hartnäckig prellende Tastaturen diese Verzögerungsschleife einbauen
  ;die Werte der Register kann eventuell angepasst werden
       mov A,R1   ;Sichern der Register R1 und R2
       push ACC
       mov A,R2
       push ACC
       mov R1,#0         ;setzen der Werte für die Verzögerungsdauer
Kwait1 mov R2,#0
Kwait2 nop
       nop
       djnz R2,Kwait2    ;Schleife zum Zeit totschlagen
       djnz R1,Kwait1
       pop ACC   ;Restore der Register R2 und R1
       mov R2,A
       pop ACC
       mov R1,A
  ;Ende der Verzögerungsschleife
       pop ACC
       ret

  if Tastatur=16
KeyTab db 0,1,2,3           ;Tabelle je nach Keyboard Tastaturbelegung
       db 4,5,6,7
       db 8,9,0aH,0bH
       db 0cH,0dH,0eH,0fH

KeyASCIItab
       ;Asciiwert in der Reihenfolge der Hexwert Zuordnung (hat nichts mit
       ;der Anordnung der Tasten zu tun!)
       db "0123456789ABCDEF"
  endif

  if Tastatur=12
KeyTab db 1,2,3           ;Tabelle je nach Keyboard Tastaturbelegung
       db 4,5,6
       db 7,8,9
       db 0aH,0,0BH       ;den Sonderzeichen * und # sind 0x0a und 0x0b
                           ;Zugeordnet

KeyASCIItab
       ;Asciiwert in der Reihenfolge der Hexwert Zuordnung (hat nichts mit
       ;der Anordnung der Tasten zu tun!)
       db "0123456789*#"
  endif