;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                 LCD-Routinen                            ;;
;;                 ============                            ;;
;;              (c)andreas-s@web.de                        ;;
;;                                                         ;;
;; bearbeitet von Johannes Fechner,                        ;;
;; https://www.mikrocontroller.net/user/show/emitterfolger ;;
;; * sämtliche veränderte Register außer SREG werden       ;;
;;   gerettet (einschließlich Parameter)                   ;;
;; * unbenutzte Pins am DB-Port werden nicht beeinflusst   ;;
;; * Anschluss von DB4..7 optional auch an Pins 4..7       ;;
;; * lcd_data und lcd_command zu lcd_write zusammengefasst ;;
;; * Busy-Flag-Abfrage (optional)                          ;;
;; Version 2022-12-06                                      ;;
;;                                                         ;;
;; 4-Bit-Interface                                         ;;
;; DB4..7, RS und E müssen ans selbe µC-Port               ;;
;;                                                         ;;
;; Register für Argumente: temp0, temp1                    ;;
;; (müssen im einbindenden Hauptprogramm                   ;;
;;  definiert werden.)                                     ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

; -------------- für Testzwecke ----------------
.ifndef temp0
.def temp0 = r20
.endif
.ifndef temp1
.def temp1 = r21
.endif
.ifndef XTAL
.equ XTAL = 4000000
.endif
; ----------------------------------------------

.def temp2 = r22
.def temp3 = r23

; Port für Datenbus DB4..DB7 festlegen
.equ LCD_DB_PORT = PORTD
.equ LCD_DB_DDR  = DDRD
.equ LCD_DB_PIN  = PIND
.equ LCD_DB_03   = 1 ; definieren, falls Anschluss von DB4..7 an Pins 0..3

; RS und E an gleichem Port wie die Daten DB4..DB7
.equ LCD_RS      = PD2
.equ LCD_E       = PD3

; Port und Pin für R/W festlegen (nur bei Benutzung des Busy-Flags erforderl.)
.equ LCD_RW_PORT = PORTB
.equ LCD_RW_DDR  = DDRB
.equ LCD_RW      = PB0
; .equ LCD_BUSY_FLAG = 1 ; definieren, falls statt Warteschleifen das Busy-Flag
                         ; abgefragt werden soll

; === Routine lcd_write ===
; Sendet ein Byte an das LCD.
; Datenbyte/Befehl muss in temp1 liegen.
; temp0 == 0: Befehl; temp0 == 1: Daten.
lcd_write:
        push  temp1
        push  temp2
        push  temp3
        mov   temp2, temp1           ; Original zur Verarbeitung kopieren
        ; Vorbereitung zum Ausgeben des oberen Nibbles
        andi  temp2, 0xF0            ; unteres Nibble löschen
.ifdef LCD_DB_03
        swap  temp2                  ; Nibbles vertauschen
.endif
        sbrc  temp0, 0               ; falls temp0.0 == 1,
          sbr   temp2, 1<<LCD_RS     ;   RS setzen
        ; nicht vom LCD benutzte Pins ausmaskieren und unverändert lassen
        in    temp3, LCD_DB_PORT
.ifdef LCD_DB_03
        andi  temp3, ~((1<<LCD_RS) | (1<<LCD_E) | 0x0F)
.else
        andi  temp3, ~(0xF0 | (1<<LCD_RS) | (1<<LCD_E))
.endif
        or    temp2, temp3
        ; warten, bis LCD bereit ist
.ifdef LCD_BUSY_FLAG
        rcall lcd_busy
.else
        rcall delay50us
.endif
        out   LCD_DB_PORT, temp2     ; ausgeben
        rcall lcd_enable             ; Enable-Routine aufrufen
        ; Vorbereitung zum Ausgeben des unteren Nibbles
        andi  temp1, 0x0F            ; oberes Nibble löschen
.ifndef LCD_DB_03
        swap  temp1
.endif
        sbrc  temp0, 0               ; falls temp0.0 == 1,
          sbr   temp1, 1<<LCD_RS     ;   RS setzen
        or    temp1, temp3
        out   LCD_DB_PORT, temp1     ; ausgeben
        rcall lcd_enable
        pop   temp3
        pop   temp2
        pop   temp1
        ret

; === Routine lcd_busy ===
; Wartet, bis Busy-Flag 0 ist
lcd_busy:
        push  temp1
        ; LCD-DB löschen, damit Pull-Ups deaktiviert bleiben
        in    temp1, LCD_DB_PORT
.ifdef LCD_DB_03
        andi  temp1, ~0x0F
.else
        andi  temp1, ~0xF0
.endif
        out   LCD_DB_PORT, temp1
        ; LCD-DB -> Eingänge
        in    temp1, LCD_DB_DDR
.ifdef LCD_DB_03
        andi  temp1, ~0x0F
.else
        andi  temp1, ~0xF0
.endif
        out   LCD_DB_DDR, temp1
        cbi   LCD_DB_PORT, LCD_RS    ; RS löschen
        sbi   LCD_RW_PORT, LCD_RW    ; R/W setzen
lcd_busy_loop:
        rcall delay5us               ; ein paar Takte warten
        sbi   LCD_DB_PORT, LCD_E     ; E setzen
        rcall delay5us               ; dem LCD-Controller etwas Zeit geben
        in    temp1, LCD_DB_PIN      ; oberes Nibble lesen (BF == DB7)
        cbi   LCD_DB_PORT, LCD_E     ; E löschen
        rcall delay5us               ; Pause bis zur nächsten Enable-Flanke
        rcall lcd_enable             ; zweites Nibble ignorieren;
                                     ; falls im 8-Bit-Modus während
                                     ; Initialisierung wird einfach eine
                                     ; BF:AC-Antwort ignoriert
        ; wiederholen, solange Busy-Flag high ist
.ifdef LCD_DB_03
        sbrc  temp1, 3
.else
        sbrc  temp1, 7
.endif
          rjmp  lcd_busy_loop
        ; LCD-Controller ist wieder bereit
        cbi   LCD_RW_PORT, LCD_RW    ; R/W wieder löschen
        ; LCD-DB -> wieder Ausgänge
        in    temp1, LCD_DB_DDR
.ifdef LCD_DB_03
        ori   temp1, 0x0F
.else
        ori   temp1, 0xF0
.endif
        out   LCD_DB_DDR, temp1
        pop   temp1
        ret

; === Routine lcd_enable ===
; Erzeugt einen High-Low-Puls am Enable-Pin
lcd_enable:
        sbi   LCD_DB_PORT, LCD_E       ; Enable high
        rcall delay5us
        cbi   LCD_DB_PORT, LCD_E       ; Enable wieder low
        ret

; === Routine delay5us ===
; ca. 5 µs Pause (nach E-Flanken bei BF-Abfrage)
delay5us:
        push temp1
        ldi  temp1, (XTAL * 5 / 3) / 1000000
delay5us_loop:
        dec  temp1
        brne delay5us_loop
        pop  temp1
        ret

; === Routine delay50us ===
; ca. 50 µs Pause (nach jeder Übertragung ohne BF-Abfrage)
delay50us:
        push temp1
        ldi  temp1, (XTAL * 50 / 3) / 1000000
delay50us_loop:
        dec  temp1
        brne delay50us_loop
        pop  temp1
        ret

; === Routine delay5ms ===
; Längere Pause von ca. 5 ms (nach manchen Befehlen ohne BF-Abfrage)
delay5ms:
        push temp1
        push temp2
        ldi  temp1, (XTAL * 5 / 607) / 1000
delay5ms_loop0:
        ldi  temp2, 0xC9
delay5ms_loop1:
        dec  temp2
        brne delay5ms_loop1
        dec  temp1
        brne delay5ms_loop0
        pop  temp2
        pop  temp1
        ret

; === Routine lcd_init ===
; LCD-Initialisierung: muss vor allen anderen LCD-Routinen aufgerufen werden
lcd_init:
        push  temp1
        push  temp3
        ; LCD-DB, -E, -RS -> Ausgänge
        in    temp1, LCD_DB_DDR
.ifdef LCD_DB_03
        ori   temp1, (1<<LCD_E) | (1<<LCD_RS) | 0x0F
.else
        ori   temp1, 0xF0 | (1<<LCD_E) | (1<<LCD_RS)
.endif
        out   LCD_DB_DDR, temp1
.ifdef LCD_BUSY_FLAG
        ; LCD-RW -> Ausgang
        in    temp1, LCD_RW_DDR
        ori   temp1, 1<<LCD_RW
        out   LCD_RW_DDR, temp1
.endif
        ; warten, bis LCD-Controller mit seiner Initialisierung fertig ist
.ifdef LCD_BUSY_FLAG
        rcall lcd_busy
.else
        ; ca. 100 ms warten
        ldi   temp3, 20
powerupwait:
        rcall delay5ms
        dec   temp3
        brne  powerupwait
.endif
        ; Initialisierung: der LCD-Controller soll 3mal hintereinander
        ; „0x3“ an DB4..7 sehen
.ifdef LCD_DB_03
        ldi   temp1, 0x03
.else
        ldi   temp1, 0x30
.endif
        ; nicht vom LCD benutzte Pins ausmaskieren und unverändert lassen
        in    temp3, LCD_DB_PORT
.ifdef LCD_DB_03
        andi  temp3, ~((1<<LCD_RS) | (1<<LCD_E) | 0x0F)
.else
        andi  temp3, ~(0xF0 | (1<<LCD_RS) | (1<<LCD_E))
.endif
        or    temp1, temp3
        out   LCD_DB_PORT, temp1
        rcall lcd_enable             ; 1
.ifdef LCD_BUSY_FLAG
        rcall lcd_busy
        rcall lcd_enable             ; 2
        rcall lcd_busy
        rcall lcd_enable             ; und 3!
        rcall lcd_busy
.else
        rcall delay5ms
        rcall lcd_enable             ; 2
        rcall delay5ms
        rcall lcd_enable             ; und 3!
        rcall delay5ms
.endif
        ; in den 4-Bit-Modus wechseln
.ifdef LCD_DB_03
        ldi   temp1, 0x02
.else
        ldi   temp1, 0x20
.endif
        or    temp1, temp3
        out   LCD_DB_PORT, temp1
        rcall lcd_enable
        ; nun kann die restliche Konfiguration erfolgen
        ldi   temp0, 0               ; es folgen Befehle
        ldi   temp1, 0b00101000      ; 4 Bit, 2 Zeilen, 5x7 Pixel
        rcall lcd_write
        ldi   temp1, 0b00001100      ; Display on, Cursor off
        rcall lcd_write
        ldi   temp1, 0b00000110      ; von links nach rechts, kein Shift
        rcall lcd_write
        ; Register wiederherstellen und zurück
        pop   temp3
        pop   temp1
        ret

; === Routine lcd_clear ===
; Sendet den Befehl zur Löschung des Displays
lcd_clear:
        push  temp0
        push  temp1
        ldi   temp0, 0
        ldi   temp1, 0b00000001      ; Display löschen
        rcall lcd_write
        pop   temp1
        pop   temp0
        ret

; === Routine lcd_home ===
; Cursor Home: setzt den Cursor nach oben links zurück
lcd_home:
        push  temp0
        push  temp1
        ldi   temp0, 0
        ldi   temp1, 0b00000010      ; Cursor Home
        rcall lcd_write
        pop   temp1
        pop   temp0
        ret

; === Routine lcd_flash_string ===
; Einen konstanten Text aus dem Flash-Speicher
; ausgeben. Der Text muss mit einer 0 terminiert sein.
; Z: Anfangsadresse des Textes
lcd_flash_string:
        push  temp0
        push  temp1
        ldi   temp0, 1               ; es folgen Daten
lcd_flash_string_1:
        lpm   temp1, Z+
        cpi   temp1, 0
        breq  lcd_flash_string_2
        rcall lcd_write
        rjmp  lcd_flash_string_1
lcd_flash_string_2:
        pop   temp1
        pop   temp0
        ret

; === Routine lcd_number ===
; Eine Zahl aus dem Register temp1 dezimal ausgeben
lcd_number:
        push  temp0
        push  temp1
        push  temp2
        push  temp3
        mov   temp2, temp1
        ; abzählen, wieviele Hunderter in der Zahl enthalten sind
        ldi   temp1, '0'
lcd_number_1:
        subi  temp2, 100
        brcs  lcd_number_2
        inc   temp1
        rjmp  lcd_number_1
lcd_number_2:
        ldi temp0, 1                 ; es folgen Daten
        rcall lcd_write              ; die Hunderterstelle ausgeben
        subi  temp2, -100            ; 100 wieder dazuzählen, da die
                                       ; vorherhgehende Schleife 100 zuviel
                                       ; abgezogen hat
        ; abzählen, wieviele Zehner in der Zahl enthalten sind
        ldi   temp1, '0'
lcd_number_3:
        subi  temp2, 10
        brcs  lcd_number_4
        inc   temp1
        rjmp  lcd_number_3
lcd_number_4:
        rcall lcd_write              ; die Zehnerstelle ausgeben
        subi  temp2, -10             ; 10 wieder dazuzählen, da die
                                       ; vorhergehende Schleife 10 zuviel
                                       ; abgezogen hat
        ; die übrig gebliebenen Einer noch ausgeben
        ldi   temp1, '0'
        add   temp1, temp2
        rcall lcd_write
        pop   temp3
        pop   temp2
        pop   temp1
        pop   temp0
        ret

; === Routine lcd_number_hex ===
; Eine Zahl aus dem Register temp1 hexadezimal ausgeben
lcd_number_hex:
        push  temp1
        swap  temp1
        andi  temp1, 0x0F
        rcall lcd_number_hex_digit

        pop   temp1
        push  temp1

        andi  temp1, 0x0F
        rcall lcd_number_hex_digit

        pop   temp1
        ret

lcd_number_hex_digit:
        push  temp0
        cpi   temp1, 10
        brlt  lcd_number_hex_digit_1
        subi  temp1, -('A' - '9' - 1)
lcd_number_hex_digit_1:
        subi  temp1, -'0'
        ldi   temp0, 1               ; es folgen Daten
        rcall lcd_write
        pop   temp0
        ret