; Digitaler Funktionsgenerator für Sinus, Rechteck, Dreieck und Sägezahn
;
; Copyright (C) 2003  Andreas Schwarz <andreas-s@web.de>
;
;   This program is free software; you can redistribute it and/or
;   modify it under the terms of the GNU General Public License
;   as published by the Free Software Foundation; either version 2
;   of the License, or (at your option) any later version.
;
;   This program is distributed in the hope that it will be useful,
;   but WITHOUT ANY WARRANTY; without even the implied warranty of
;   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;   GNU General Public License for more details.
;
;   You should have received a copy of the GNU General Public License
;   along with this program; if not, write to the Free Software
;   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
;
;
; =========================================================================
; dds-fast.asm - GENERATED by sim/make_variants.py from da-test.asm.
;
; Hoehere Abtastrate durch einen verzweigungsfreien Timer-Interrupt:
;
;   Original    17 Takte Rumpf + 4 Takte Eintritt = 21 von 25  -> 262144 Hz
;   hier        13 Takte Rumpf + 4 Takte Eintritt = 17 von 20  -> 327680 Hz
;
; 262144 Hz war die arithmetisch perfekte Rate: 6553600/25 = 2^18, also
; 2^24/2^18 = 64, und damit war die Frequenzanzeige ein simples *10/64 und
; STEP=32 exakt 0,5 Hz. Keine schnellere Rate am 6,5536-MHz-Quarz haelt beides
; exakt. Deshalb hier *25/128 (weiterhin exakt, aber 32 Bit noetig) und
; Schrittweiten von ~0,508 bzw. ~4,004 Hz.
; =========================================================================
;
; Änderungen:
;
; ??.05.02      - Anfang: einfache Ausgabe von Sinus-Funktionswerten mit fester Frequenz
; ??.??.02      - Phasenakkumulator
;               - Einstellung der Frequenz über Taster
;               - Anzeige von Frequenz und Signalform auf LCD
; 18.10.02      - Frequenzanzeige funktioniert korrekt
; 19.10.02      - Auswahl der Signalformen
;               - Signalformen Dreieck und Sägezahn hinzugefügt
; 15.12.02      - Delay-Funktionen verbessert (jetzt teilweise mit Timer statt Warteschleife)
; 29.01.03      - in der Frequenzanzeige wird nun eine Nachkommastelle angezeigt
;               - "Überlauf" der Frequenzeinstellungs-Variable nach unten hin
;                 tritt nicht mehr auf; nach oben hin immer noch (ist aber unkritisch)
;               - Umstellung von AT90S2333 auf ATmega8 (theoretisch bessere Sicherheit für
;                 EEPROM-Inhalt wegen funktionierender Brown-Out-Protection)
; 31.01.03      - feinere Frequenzeinstellung (in 0.5 Hz-Schritten)

.include "m8def.inc"

.listmac

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                 Konstanten                                  ;;
;;                 ==========                                  ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

.equ        COMPAREVALUE = 19             ; Zählerstand bei dem der Interrupt
                                          ; ausgelöst wird

.equ        KEY_UPF      = 3
.equ        KEY_UP       = 2
.equ        KEY_DOWN     = 1
.equ        KEY_DOWNF    = 0
.equ        KEY_WAVE     = 4

.equ        STEPF        = 205            ; starke Änderung der Phasenakk.-Schrittweite
.equ        STEP         = 26             ; schwache Änderung der Phasenakk.-Schrittweite

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;              Registerdefinitionen                           ;;
;;              ====================                           ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

.def        null         = R1             ; immer 0
.def        full         = R2             ; immer "voll" = 0xFF = 255 = 0b11111111

.def        sregsave     = R9             ; Zwischenspeicher für das Statusregister
                                          ; während der Interruptroutine

.def        temp1        = R16            ; Zwischenspeicher 1
.def        temp2        = R17            ; Zwischenspeicher 2
.def        temp3        = R18            ; Zwischenspeicher 3

.def        change1      = R3             ; Schrittweite, die durch den Phasenakkumulator
                                          ; zur Phasenposition addiert wird
                                          ; (24 Bit, auf 3 Register a 8 Bit aufgeteilt)
.def        change2      = R4 
.def        change3      = R5

.def        z1           = R28            ; Dieses Registertripel enthält die Phasenposition
.def        z2           = R29            ; zu der die Register changeX bei der Phasenakk.
.def        z3           = R30            ; addiert werden

.def        waveform     = R20            ; eingestellte Wellenform
                                          ; (Sinus, Rechteck, Dreieck oder Sägezahn)

; Register für die Binär nach Dezimal-Wandlung
.def        fbin0        = R6             ; binary value byte 0 (LSB)
.def        fbin1        = R7             ; binary value byte 1
.def        fbin2        = R21            ; binary value byte 2
.def        fbin3        = R22            ; binary value byte 3 (MSB)
.def        tBCD0        = R21            ; BCD value digits 1 and 0 (same as fbin2)
.def        tBCD1        = R22            ; BCD value digits 3 and 2 (same as fbin3)
.def        tBCD2        = R23            ; BCD value digits 4 and 5
.def        tBCD3        = R24            ; BCD value digits 6 and 7
.def        tBCD4        = R25            ; BCD value digits 8 and 9
.def        fbinL        = R26            ; binary value Low byte
.def        fbinH        = R27            ; binary value High byte

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                    Makros                                   ;;
;;                    ======                                   ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;Z-Pointer auf bestimmte Adresse setzen
.MACRO SetZPtr ;(Adresse)
        ldi ZL, LOW(@0)
        ldi ZH, HIGH(@0)
.ENDMACRO

;String aus dem EEPROM auf dem LCD anzeigen
.MACRO print ;(String-Adresse)
        push temp1
        ldi        temp1,@0
        rcall printstring
        pop temp1
.ENDMACRO

;LCD-Cursor an bestimmte Position setzen
.MACRO locate ;(Zeile,Spalte)
        push temp1
        ldi temp1, 0b10000000|(((@0)-1)<<6)|((@1)-1)
        rcall lcd_command
        pop temp1
.ENDMACRO

;bestimmte Anzahl ms warten
.MACRO waitms
        push temp1
        ldi temp1, @0*6
        rcall wms
        pop temp1
.ENDMACRO 

.MACRO wait10ms
        push temp1
        ldi temp1, @0*6
        rcall w10ms
        pop temp1
.ENDMACRO

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;             Interruptvektoren                               ;;
;;             =================                               ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

.org 0x000                                ; kommt ganz an den Anfang des Speichers
                                          ; (hier fängt die Programmausführung an!)
        rjmp RESET                        ; der Timer-Interrupt und die Tabellen werden
                                          ; übersprungen -> zum Hauptprogramm

.org OC1Aaddr                             ; Int.vektor für Timer 1 Compare Match

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;               Timer-Interrupt                               ;;
;;               ===============                               ;;
;;                                                             ;;
;; Dieser Programmteil wird exakt 256000 Mal pro Sekunde       ;;
;; durch den Timer aufgerufen. Das Hauptprogramm wird dazu     ;;
;; unterbrochen und anschließend fortgesetzt.                  ;;
;;                                                             ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

timer:
        in sregsave, SREG                 ; Statusregister sichern

; Alle vier Signalformen liegen jetzt als Tabelle im Flash, deshalb braucht
; dieser Interrupt keine Fallunterscheidung mehr: der Z-Pointer zeigt immer
; schon auf die richtige Tabelle. Das spart die vier Takte, die vorher fuer
; cpi/breq auf "waveform" draufgingen.

        lpm                               ; Funktionswert aus dem Speicher lesen
        add z1, change1                   ; Phasenakkumulator
        adc z2, change2
        adc z3, change3
        out PORTD, R0                     ; Wert an den Digital-Analog-Wandler ausgeben
        out SREG, sregsave                ; Statusregister wiederherstellen
        reti                              ; 13 Takte insgesamt (vorher 17)


;;;;;;;;;;
;;    Tabellen mit den Funktionswerten                         ;;
;;    ================================                         ;;
;;                                                             ;;
;; Für Sinus und Dreieck sind hier die vorausberechneten       ;;
;; Funktionswerte abgespeichert                                ;;
;;                                                             ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

.org 0x100
SINTABLE:
.db 0x80,0x82,0x85,0x88,0x8C,0x8F,0x92,0x95
.db 0x98,0x9B,0x9E,0xA1,0xA4,0xA7,0xAA,0xAD
.db 0xB0,0xB3,0xB6,0xB9,0xBB,0xBE,0xC1,0xC3
.db 0xC6,0xC9,0xCB,0xCE,0xD0,0xD3,0xD5,0xD7
.db 0xDA,0xDC,0xDE,0xE0,0xE2,0xE4,0xE6,0xE8
.db 0xE9,0xEB,0xED,0xEE,0xF0,0xF1,0xF3,0xF4
.db 0xF5,0xF6,0xF8,0xF9,0xF9,0xFA,0xFB,0xFC
.db 0xFD,0xFD,0xFE,0xFE,0xFE,0xFF,0xFF,0xFF
.db 0xFF,0xFF,0xFF,0xFF,0xFE,0xFE,0xFE,0xFD
.db 0xFD,0xFC,0xFB,0xFA,0xF9,0xF9,0xF8,0xF6
.db 0xF5,0xF4,0xF3,0xF1,0xF0,0xEE,0xED,0xEB
.db 0xE9,0xE8,0xE6,0xE4,0xE2,0xE0,0xDE,0xDC
.db 0xDA,0xD7,0xD5,0xD3,0xD0,0xCE,0xCB,0xC9
.db 0xC6,0xC3,0xC1,0xBE,0xBB,0xB9,0xB6,0xB3
.db 0xB0,0xAD,0xAA,0xA7,0xA4,0xA1,0x9E,0x9B
.db 0x98,0x95,0x92,0x8F,0x8C,0x88,0x85,0x82
.db 0x80,0x7D,0x7A,0x77,0x73,0x70,0x6D,0x6A
.db 0x67,0x64,0x61,0x5E,0x5B,0x58,0x55,0x52
.db 0x4F,0x4C,0x49,0x46,0x44,0x41,0x3E,0x3C
.db 0x39,0x36,0x34,0x31,0x2F,0x2C,0x2A,0x28
.db 0x25,0x23,0x21,0x1F,0x1D,0x1B,0x19,0x17
.db 0x16,0x14,0x12,0x11,0xF,0xE,0xC,0xB
.db 0xA,0x9,0x7,0x6,0x6,0x5,0x4,0x3
.db 0x2,0x2,0x1,0x1,0x1,0x0,0x0,0x0
.db 0x0,0x0,0x0,0x0,0x1,0x1,0x1,0x2
.db 0x2,0x3,0x4,0x5,0x6,0x6,0x7,0x9
.db 0xA,0xB,0xC,0xE,0xF,0x11,0x12,0x14
.db 0x16,0x17,0x19,0x1B,0x1D,0x1F,0x21,0x23
.db 0x25,0x28,0x2A,0x2C,0x2F,0x31,0x34,0x36
.db 0x39,0x3C,0x3E,0x41,0x44,0x46,0x49,0x4C
.db 0x4F,0x52,0x55,0x58,0x5B,0x5E,0x61,0x64
.db 0x67,0x6A,0x6D,0x70,0x73,0x77,0x7A,0x7D

TRIANGLETABLE:
.db 0x00,0x02,0x04,0x06,0x08,0x0a,0x0c,0x0e
.db 0x10,0x12,0x14,0x16,0x18,0x1a,0x1c,0x1e
.db 0x20,0x22,0x24,0x26,0x28,0x2a,0x2c,0x2e
.db 0x30,0x32,0x34,0x36,0x38,0x3a,0x3c,0x3e
.db 0x40,0x42,0x44,0x46,0x48,0x4a,0x4c,0x4e
.db 0x50,0x52,0x54,0x56,0x58,0x5a,0x5c,0x5e
.db 0x60,0x62,0x64,0x66,0x68,0x6a,0x6c,0x6e
.db 0x70,0x72,0x74,0x76,0x78,0x7a,0x7c,0x7e
.db 0x80,0x82,0x84,0x86,0x88,0x8a,0x8c,0x8e
.db 0x90,0x92,0x94,0x96,0x98,0x9a,0x9c,0x9e
.db 0xa0,0xa2,0xa4,0xa6,0xa8,0xaa,0xac,0xae
.db 0xb0,0xb2,0xb4,0xb6,0xb8,0xba,0xbc,0xbe
.db 0xc0,0xc2,0xc4,0xc6,0xc8,0xca,0xcc,0xce
.db 0xd0,0xd2,0xd4,0xd6,0xd8,0xda,0xdc,0xde
.db 0xe0,0xe2,0xe4,0xe6,0xe8,0xea,0xec,0xee
.db 0xf0,0xf2,0xf4,0xf6,0xf8,0xfa,0xfc,0xfe
.db 0xff,0xfd,0xfb,0xf9,0xf7,0xf5,0xf3,0xf1
.db 0xef,0xed,0xeb,0xe9,0xe7,0xe5,0xe3,0xe1
.db 0xdf,0xdd,0xdb,0xd9,0xd7,0xd5,0xd3,0xd1
.db 0xcf,0xcd,0xcb,0xc9,0xc7,0xc5,0xc3,0xc1
.db 0xbf,0xbd,0xbb,0xb9,0xb7,0xb5,0xb3,0xb1
.db 0xaf,0xad,0xab,0xa9,0xa7,0xa5,0xa3,0xa1
.db 0x9f,0x9d,0x9b,0x99,0x97,0x95,0x93,0x91
.db 0x8f,0x8d,0x8b,0x89,0x87,0x85,0x83,0x81
.db 0x7f,0x7d,0x7b,0x79,0x77,0x75,0x73,0x71
.db 0x6f,0x6d,0x6b,0x69,0x67,0x65,0x63,0x61
.db 0x5f,0x5d,0x5b,0x59,0x57,0x55,0x53,0x51
.db 0x4f,0x4d,0x4b,0x49,0x47,0x45,0x43,0x41
.db 0x3f,0x3d,0x3b,0x39,0x37,0x35,0x33,0x31
.db 0x2f,0x2d,0x2b,0x29,0x27,0x25,0x23,0x21
.db 0x1f,0x1d,0x1b,0x19,0x17,0x15,0x13,0x11
.db 0x0f,0x0d,0x0b,0x09,0x07,0x05,0x03,0x01

SQUARETABLE:                              ; Rechteck, vorher per cpi/brlo erzeugt
.db 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff
.db 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff
.db 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff
.db 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff
.db 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff
.db 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff
.db 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff
.db 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff
.db 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff
.db 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff
.db 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff
.db 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff
.db 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff
.db 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff
.db 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff
.db 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff
.db 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
.db 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
.db 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
.db 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
.db 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
.db 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
.db 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
.db 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
.db 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
.db 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
.db 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
.db 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
.db 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
.db 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
.db 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
.db 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00

SAWTOOTHTABLE:                              ; Saegezahn, vorher direkt aus z3
.db 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07
.db 0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f
.db 0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17
.db 0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f
.db 0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27
.db 0x28,0x29,0x2a,0x2b,0x2c,0x2d,0x2e,0x2f
.db 0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37
.db 0x38,0x39,0x3a,0x3b,0x3c,0x3d,0x3e,0x3f
.db 0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47
.db 0x48,0x49,0x4a,0x4b,0x4c,0x4d,0x4e,0x4f
.db 0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57
.db 0x58,0x59,0x5a,0x5b,0x5c,0x5d,0x5e,0x5f
.db 0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67
.db 0x68,0x69,0x6a,0x6b,0x6c,0x6d,0x6e,0x6f
.db 0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77
.db 0x78,0x79,0x7a,0x7b,0x7c,0x7d,0x7e,0x7f
.db 0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87
.db 0x88,0x89,0x8a,0x8b,0x8c,0x8d,0x8e,0x8f
.db 0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97
.db 0x98,0x99,0x9a,0x9b,0x9c,0x9d,0x9e,0x9f
.db 0xa0,0xa1,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7
.db 0xa8,0xa9,0xaa,0xab,0xac,0xad,0xae,0xaf
.db 0xb0,0xb1,0xb2,0xb3,0xb4,0xb5,0xb6,0xb7
.db 0xb8,0xb9,0xba,0xbb,0xbc,0xbd,0xbe,0xbf
.db 0xc0,0xc1,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7
.db 0xc8,0xc9,0xca,0xcb,0xcc,0xcd,0xce,0xcf
.db 0xd0,0xd1,0xd2,0xd3,0xd4,0xd5,0xd6,0xd7
.db 0xd8,0xd9,0xda,0xdb,0xdc,0xdd,0xde,0xdf
.db 0xe0,0xe1,0xe2,0xe3,0xe4,0xe5,0xe6,0xe7
.db 0xe8,0xe9,0xea,0xeb,0xec,0xed,0xee,0xef
.db 0xf0,0xf1,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7
.db 0xf8,0xf9,0xfa,0xfb,0xfc,0xfd,0xfe,0xff

ORGANTABLE:                              ; Orgel: additive Harmonische
.db 0x80,0x8c,0x98,0xa4,0xb0,0xbb,0xc5,0xce
.db 0xd7,0xdf,0xe6,0xec,0xf1,0xf5,0xf9,0xfb
.db 0xfd,0xfe,0xff,0xff,0xff,0xfe,0xfd,0xfc
.db 0xfb,0xfa,0xf8,0xf7,0xf6,0xf5,0xf4,0xf3
.db 0xf2,0xf1,0xf0,0xef,0xee,0xed,0xeb,0xea
.db 0xe8,0xe6,0xe4,0xe1,0xdf,0xdc,0xd9,0xd5
.db 0xd2,0xcf,0xcb,0xc8,0xc5,0xc2,0xbf,0xbc
.db 0xba,0xb8,0xb6,0xb4,0xb3,0xb2,0xb1,0xb0
.db 0xb0,0xaf,0xaf,0xaf,0xaf,0xae,0xae,0xae
.db 0xad,0xad,0xac,0xac,0xab,0xab,0xaa,0xa9
.db 0xa9,0xa9,0xa8,0xa8,0xa8,0xa8,0xa8,0xa9
.db 0xa9,0xaa,0xaa,0xab,0xab,0xac,0xac,0xac
.db 0xac,0xab,0xaa,0xa9,0xa8,0xa5,0xa3,0xa0
.db 0x9c,0x99,0x95,0x90,0x8c,0x88,0x83,0x7f
.db 0x7b,0x77,0x74,0x71,0x6e,0x6d,0x6c,0x6b
.db 0x6b,0x6c,0x6e,0x70,0x72,0x75,0x79,0x7c
.db 0x80,0x84,0x87,0x8b,0x8e,0x90,0x92,0x94
.db 0x95,0x95,0x94,0x93,0x92,0x8f,0x8c,0x89
.db 0x85,0x81,0x7d,0x78,0x74,0x70,0x6b,0x67
.db 0x64,0x60,0x5d,0x5b,0x58,0x57,0x56,0x55
.db 0x54,0x54,0x54,0x54,0x55,0x55,0x56,0x56
.db 0x57,0x57,0x58,0x58,0x58,0x58,0x58,0x57
.db 0x57,0x57,0x56,0x55,0x55,0x54,0x54,0x53
.db 0x53,0x52,0x52,0x52,0x51,0x51,0x51,0x51
.db 0x50,0x50,0x4f,0x4e,0x4d,0x4c,0x4a,0x48
.db 0x46,0x44,0x41,0x3e,0x3b,0x38,0x35,0x31
.db 0x2e,0x2b,0x27,0x24,0x21,0x1f,0x1c,0x1a
.db 0x18,0x16,0x15,0x13,0x12,0x11,0x10,0x0f
.db 0x0e,0x0d,0x0c,0x0b,0x0a,0x09,0x08,0x06
.db 0x05,0x04,0x03,0x02,0x01,0x01,0x01,0x02
.db 0x03,0x05,0x07,0x0b,0x0f,0x14,0x1a,0x21
.db 0x29,0x32,0x3b,0x45,0x50,0x5c,0x68,0x74

BELLTABLE:                              ; Glocke: weit gespreizte Partialtoene
.db 0x80,0x90,0xa0,0xaf,0xbd,0xc9,0xd4,0xdd
.db 0xe4,0xe9,0xed,0xef,0xf0,0xf0,0xef,0xee
.db 0xed,0xeb,0xeb,0xea,0xea,0xea,0xeb,0xec
.db 0xec,0xed,0xed,0xed,0xec,0xea,0xe8,0xe5
.db 0xe1,0xdd,0xd9,0xd4,0xd0,0xcc,0xc8,0xc5
.db 0xc3,0xc1,0xc0,0xc0,0xc0,0xc0,0xc1,0xc1
.db 0xc1,0xc0,0xbf,0xbc,0xb9,0xb5,0xb0,0xaa
.db 0xa4,0x9e,0x99,0x93,0x8f,0x8c,0x8b,0x8b
.db 0x8e,0x92,0x97,0x9e,0xa7,0xb1,0xbb,0xc6
.db 0xd0,0xda,0xe3,0xeb,0xf2,0xf8,0xfc,0xfe
.db 0xff,0xff,0xfe,0xfc,0xf9,0xf7,0xf4,0xf1
.db 0xef,0xec,0xeb,0xe9,0xe8,0xe6,0xe5,0xe3
.db 0xe1,0xdf,0xdc,0xd8,0xd4,0xd0,0xcb,0xc5
.db 0xc0,0xbc,0xb7,0xb4,0xb1,0xaf,0xae,0xae
.db 0xaf,0xb0,0xb2,0xb4,0xb6,0xb8,0xb9,0xb9
.db 0xb8,0xb6,0xb2,0xac,0xa5,0x9d,0x94,0x8a
.db 0x80,0x76,0x6c,0x63,0x5b,0x54,0x4e,0x4a
.db 0x48,0x47,0x47,0x48,0x4a,0x4c,0x4e,0x50
.db 0x51,0x52,0x52,0x51,0x4f,0x4c,0x49,0x44
.db 0x40,0x3b,0x35,0x30,0x2c,0x28,0x24,0x21
.db 0x1f,0x1d,0x1b,0x1a,0x18,0x17,0x15,0x14
.db 0x11,0x0f,0x0c,0x09,0x07,0x04,0x02,0x01
.db 0x01,0x02,0x04,0x08,0x0e,0x15,0x1d,0x26
.db 0x30,0x3a,0x45,0x4f,0x59,0x62,0x69,0x6e
.db 0x72,0x75,0x75,0x74,0x71,0x6d,0x67,0x62
.db 0x5c,0x56,0x50,0x4b,0x47,0x44,0x41,0x40
.db 0x3f,0x3f,0x3f,0x40,0x40,0x40,0x40,0x3f
.db 0x3d,0x3b,0x38,0x34,0x30,0x2c,0x27,0x23
.db 0x1f,0x1b,0x18,0x16,0x14,0x13,0x13,0x13
.db 0x14,0x14,0x15,0x16,0x16,0x16,0x15,0x15
.db 0x13,0x12,0x11,0x10,0x10,0x11,0x13,0x17
.db 0x1c,0x23,0x2c,0x37,0x43,0x51,0x60,0x70

PULSETABLE:                              ; Pulswelle mit 25% Tastverhaeltnis
.db 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff
.db 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff
.db 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff
.db 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff
.db 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff
.db 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff
.db 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff
.db 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff
.db 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
.db 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
.db 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
.db 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
.db 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
.db 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
.db 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
.db 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
.db 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
.db 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
.db 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
.db 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
.db 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
.db 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
.db 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
.db 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
.db 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
.db 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
.db 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
.db 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
.db 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
.db 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
.db 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
.db 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00

STAIRSTABLE:                              ; Treppe: 8 Stufen statt 256
.db 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
.db 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
.db 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
.db 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
.db 0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24
.db 0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24
.db 0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24
.db 0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24
.db 0x49,0x49,0x49,0x49,0x49,0x49,0x49,0x49
.db 0x49,0x49,0x49,0x49,0x49,0x49,0x49,0x49
.db 0x49,0x49,0x49,0x49,0x49,0x49,0x49,0x49
.db 0x49,0x49,0x49,0x49,0x49,0x49,0x49,0x49
.db 0x6d,0x6d,0x6d,0x6d,0x6d,0x6d,0x6d,0x6d
.db 0x6d,0x6d,0x6d,0x6d,0x6d,0x6d,0x6d,0x6d
.db 0x6d,0x6d,0x6d,0x6d,0x6d,0x6d,0x6d,0x6d
.db 0x6d,0x6d,0x6d,0x6d,0x6d,0x6d,0x6d,0x6d
.db 0x92,0x92,0x92,0x92,0x92,0x92,0x92,0x92
.db 0x92,0x92,0x92,0x92,0x92,0x92,0x92,0x92
.db 0x92,0x92,0x92,0x92,0x92,0x92,0x92,0x92
.db 0x92,0x92,0x92,0x92,0x92,0x92,0x92,0x92
.db 0xb6,0xb6,0xb6,0xb6,0xb6,0xb6,0xb6,0xb6
.db 0xb6,0xb6,0xb6,0xb6,0xb6,0xb6,0xb6,0xb6
.db 0xb6,0xb6,0xb6,0xb6,0xb6,0xb6,0xb6,0xb6
.db 0xb6,0xb6,0xb6,0xb6,0xb6,0xb6,0xb6,0xb6
.db 0xdb,0xdb,0xdb,0xdb,0xdb,0xdb,0xdb,0xdb
.db 0xdb,0xdb,0xdb,0xdb,0xdb,0xdb,0xdb,0xdb
.db 0xdb,0xdb,0xdb,0xdb,0xdb,0xdb,0xdb,0xdb
.db 0xdb,0xdb,0xdb,0xdb,0xdb,0xdb,0xdb,0xdb
.db 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff
.db 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff
.db 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff
.db 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;       Stringkonstanten (im EEPROM)                          ;;
;;       ============================                          ;;
;;                                                             ;;
;; Hier sind die Zeichenketten gespeichert, die auf dem LCD    ;;
;; angezeigt werden sollen; die Speicheradressen der           ;;
;; Strings dienen gleichzeitig als Konstanten zur              ;;
;; Festlegung der eingestellten Signalform.                    ;;
;;                                                             ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

.eseg

.org 0x01
t_sinus:
.db "Sinus    ",0
t_square:
.db "Rechteck ",0
t_triangle:
.db "Dreieck  ",0
t_sawtooth:
.db "Saegezahn",0
t_organ:
.db "Orgel    ",0
t_bell:
.db "Glocke   ",0
t_pulse:
.db "Puls 25% ",0
t_stairs:
.db "Treppe   ",0
t_hz:
.db " Hz",0

.cseg

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;              Initialisierung                                ;;
;;              ===============                                ;;
;;                                                             ;;
;; Hier wird der Prozessor initialisiert:                      ;;
;; Stackpointer, Ein-Ausgänge, Timerfrequenzen, ...            ;;
;;                                                             ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

RESET:
        ldi temp1, low(RAMEND)
        out SPL, temp1                    ; Stackpointer initialisieren
        ldi temp1, high(RAMEND)
        out SPH, temp1

        ldi temp1, 0x00
        out EEARH, temp1

        ldi temp1, 0xFF
        out DDRD, temp1                   ; Port D = Ausgang

        ldi temp1, 0x00
        out DDRC, temp1                   ; Port C = Eingang
        ldi temp1, 0xFF
        out PORTC, temp1                  ; interne Pullups für Port C aktivieren

        ldi temp1, 0xFF
        out DDRB, temp1                   ; Port B = Ausgang
        ldi temp1, 0x00
        out PORTB, temp1

        ldi temp1, 0x00                   ; Additionsregister mit 0x00FA00 vorbelegen
        mov change1, temp1                ; (0x00C800 = 51200, entspricht 1000 Hz bei 327680 Hz)
        ldi temp1, 0xC8
        mov change2, temp1
        ldi temp1, 0x00
        mov change3, temp1
        
        clr z1                            ; Phasenposition auf 0 setzen
        clr z2
        clr z3

        ldi waveform, t_sinus             ; Voreinstellung für Ausgangssignal: Sinus

        clr null
        clr full
        com full

        SetZPtr(SINTABLE*2)               ; Adresse der Sinus-Tabelle in den Z-Pointer laden

        ldi temp1, low(COMPAREVALUE)      ; Compare-Wert laden; bei einem Zählerstand von
                                          ; COMPAREVALUE wird der Timer-Interrupt aktiv
        out OCR1AL, temp1
        ldi temp1, high(COMPAREVALUE)
        out OCR1AH, temp1
        ldi temp1, (1<<WGM12)|(1<<CS10)   ; Timer 1 starten, Frequenz 6553600/1 Hz
        out TCCR1B, temp1

        ldi temp1, (1<<CS02)|(1<<CS00)    ; Timer 0 starten, Frequenz 6553600/1024 Hz
                                          ; (dient als Zeitgeber für die Verzögerungen
                                          ; bei der Tastenauswertung und LCD-Ansteuerung)
        out TCCR0, temp1        

        ldi temp1, 1<<OCIE1A              ; Timer 1 Compare-Interrupt aktivieren
        out TIMSK, temp1

        rcall lcd_init                    ; LCD initialisieren
        rcall lcd_clear                   ; LCD löschen

        rcall update                      ; Frequenzanzeige aktualisieren

        sei                               ; Interrupts global aktivieren

; Übergang in die ...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;              Hauptschleife                                  ;;
;;              =============                                  ;;
;;                                                             ;;
;; Endlosschleife, wird immer wieder wiederholt; wertet        ;;
;; Tastendrücke aus und aktualisiert die Anzeige; wird         ;;
;; automatisch 256000 Mal in der Sekunde  durch den            ;;
;; Timerinterrupt unterbrochen                                 ;;
;;                                                             ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

mainloop:
        sbic PINC, KEY_WAVE               ; Taste für Wellenform-Änderung gedrückt?
	
        rjmp skip1                        ; wenn nicht, dann zu skip1 springen
                                          ; andernfalls weiter
        
        cpi waveform, t_sinus             ; Sinus eingestellt?
        breq make_square                  ; wenn ja, dann zu make_square springen
        cpi waveform, t_square            ; Rechteck eingestellt?
        breq make_triangle                ; wenn ja, dann zu make_square springen
        cpi waveform, t_triangle          ; Dreieck eingestellt?
        breq make_sawtooth                ; wenn ja, dann zu make_saw springen
        cpi waveform, t_sawtooth          ; Sägezahn eingestellt?
        breq make_organ
        cpi waveform, t_organ
        breq make_bell
        cpi waveform, t_bell
        breq make_pulse
        cpi waveform, t_pulse
        breq make_stairs
        cpi waveform, t_stairs
        breq make_sinus
        
make_sinus:
        ldi waveform, t_sinus             ; Sinus auswählen
        SetZPtr(SINTABLE*2)
        rjmp ml_wtest_end                 ; zu ml_wtest_end springen
make_square:
        ldi waveform, t_square            ; Rechteck auswählen
        SetZPtr(SQUARETABLE*2)
        rjmp ml_wtest_end                 ; zu ml_wtest_end springen
make_triangle:
        ldi waveform, t_triangle          ; Dreieck auswählen
        SetZPtr(TRIANGLETABLE*2)
        rjmp ml_wtest_end                 ; zu ml_wtest_end springen
make_sawtooth:
        ldi waveform, t_sawtooth          ; Sägezahn auswählen
        SetZPtr(SAWTOOTHTABLE*2)
        rjmp ml_wtest_end                 ; zu ml_wtest_end springen
make_organ:
        ldi waveform, t_organ
        SetZPtr(ORGANTABLE*2)
        rjmp ml_wtest_end
make_bell:
        ldi waveform, t_bell
        SetZPtr(BELLTABLE*2)
        rjmp ml_wtest_end
make_pulse:
        ldi waveform, t_pulse
        SetZPtr(PULSETABLE*2)
        rjmp ml_wtest_end
make_stairs:
        ldi waveform, t_stairs
        SetZPtr(STAIRSTABLE*2)
        rjmp ml_wtest_end

ml_wtest_end:

        rcall update                      ; Anzeige aktualisieren
        wait10ms 30                       ; ca. 300 ms Pause
        
skip1:  sbic PINC, KEY_DOWNF              ; Taste -- gedrückt?
        rjmp skip2
        ldi temp1, low(STEPF)
        ldi temp2, high(STEPF)
        sub change1, temp1                ; Frequenz stark verringern
        sbc change2, temp2
        sbc change3, null
        brcc PC+2                         ; bei Überlauf....
        rcall set0                        ; ... Frequenz auf 0 setzten.
        rcall update                      ; Anzeige aktualisieren
        waitms 1                          ; ca. 1 ms Pause
        
skip2:  sbic PINC, KEY_UPF                ; Taste ++ gedrückt?
        rjmp skip3
        ldi temp1, low(STEPF)
        ldi temp2, high(STEPF)
        add change1, temp1                ; Frequenz stark erhöhen
        adc change2, temp2
        adc change3, null
        rcall update                      ; Anzeige aktualisieren
        waitms 1                          ; ca. 1 ms Pause

skip3:  sbic PINC, KEY_DOWN               ; Taste - gedrückt?
        rjmp skip4
        ldi temp1, STEP
        sub change1, temp1                ; Frequenz schwach verringern
        sbc change2, null
        sbc change3, null
        brcc PC+2                         ; bei Überlauf...
        rcall set0                        ; Frequenz auf 0 setzen.
        rcall update                      ; Anzeige aktualisieren
        wait10ms 22                       ; ca. 220 ms Pause
        
skip4:  sbic PINC, KEY_UP                 ; Taste + gedrückt?
        rjmp mainloop
        ldi temp1, STEP
        add change1, temp1                ; Frequenz schwach erhöhen
        adc change2, null
        adc change3, null
        rcall update                      ; Anzeige aktualisieren
        wait10ms 22                       ; ca. 220 ms Pause

        rjmp mainloop                     ; zurück zum Anfang der Hauptschleife springen

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;               Anzeige aktualisieren                         ;;
;;               =====================                         ;;
;;                                                             ;;
;; (Signalform anzeigen, Frequenz berechnen und anzeigen)      ;;
;;                                                             ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

update:
        locate(1,1)                       ; Signalform an Zeile 1, Pos. 1 ausgeben
        mov temp1, waveform
        rcall printstring
        locate(2,1)

        clr fbin0
        clr fbin1
        clr fbin2
        clr fbin3

                                          ; Additionswert des Phasenakk.
                                          ; mit 10 multiplizieren...
        ldi temp3, 25
update_multiplyloop:
        add fbin0, change1
        adc fbin1, change2
        adc fbin2, change3
        adc fbin3, null                   ; jetzt 32 Bit, sonst Ueberlauf ab 13 kHz
        dec temp3
        brne update_multiplyloop

                                          ; ...durch 64 teilen...
        ldi temp3, 7
update_divideloop:
        clc
        ror fbin3
        ror fbin2
        ror fbin1
        ror fbin0
        dec temp3
        brne update_divideloop
        
                                          ; ...in Dezimalziffern umwandeln... 
        rcall bin4BCD
        
                                          ; ...und auf dem LCD anzeigen:
        push tBCD0                        ; Ziffernpaare auf den Stack PUSHen
        push tBCD1
        push tBCD2
                                          ; und in der umgekehrten Reihenfolge wieder runter
                                          ; POPen (wäre auch eleganter gegangen, aber es
                                          ; funktioniert)
        pop temp1
        push temp1
        swap temp1
        andi temp1, 0x0F
        subi temp1, -0x30                 ; Ziffer in ASCII-Code umwandeln
        rcall lcd_data
        pop temp1
        andi temp1, 0x0F
        subi temp1, -0x30                 ; dito
        rcall lcd_data

        pop temp1
        push temp1
        swap temp1
        andi temp1, 0x0F
        subi temp1, -0x30
        rcall lcd_data
        pop temp1
        andi temp1, 0x0F
        subi temp1, -0x30
        rcall lcd_data
        
        pop temp1
        push temp1
        swap temp1
        andi temp1, 0x0F
        subi temp1, -0x30
        rcall lcd_data

        ldi temp1, ','                    ; das Komma vor der letzten Ziffer
        rcall lcd_data

        pop temp1
        andi temp1, 0x0F
        subi temp1, -0x30
        rcall lcd_data
        
        print(t_hz)                       ; nach dem Wert die Einheit " Hz" anzeigen
        
        ret

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;    Umrechnung binär nach dezimal                            ;;
;;    =============================                            ;;
;;                                                             ;;
;; (Quelle: http://mirror01.users.i.com.ua/~birua/math32.html) ;;
;;                                                             ;;
;; Funktionsprinzip:                                           ;;
;;   - umzurechnende Zahl durch 10000 teilen                   ;;
;;   - Ergebnis = höchste Stelle der Dezimalzahl               ;;
;;   - Rest durch 1000 teilen                                  ;;
;;   - Ergebnis = zweithöchste Stelle der Dezimalzahl          ;;
;;   - Rest durch 100 teilen                                   ;;
;;     ...                                                     ;;
;;                                                             ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Bin2BCD20:      mov     fbinL,fbin2       ; for compatibility with Math32
                mov     fbinH,fbin3
Bin2BCD16:      ldi     tBCD2,0xff        ; initialize digit 4
binBCD_4:       inc     tBCD2
                subi    fbinL,low(10000)  ; subiw fbin,10000
                sbci    fbinH,high(10000)
                brcc    binBCD_4
                ldi     tBCD1,0x9f        ; initialize digits 3 and 2
binBCD_3:       subi    tBCD1,0x10
                subi    fbinL,low(-1000)  ; subiw fbin,1000
                sbci    fbinH,high(-1000)
                brcs    binBCD_3
binBCD_2:       inc     tBCD1
                subi    fbinL,low(100)    ; subiw fbin,100
                sbci    fbinH,high(100)
                brcc    binBCD_2
                ldi     tBCD0,0xa0        ; initialize digits 1 and 0
binBCD_1:       subi    tBCD0,0x10
                subi    fbinL,-10         ; subiw fbin,10
                brcs    binBCD_1
                add     tBCD0,fbinL
binBCD_ret:     ret


Bin4BCD:        rcall   Bin2BCD20
                clr     tBCD3             ; initial highest bytes of result
                ldi     tBCD4,0xfe
binBCD_loop:    subi    tBCD0,-0x33       ; add 0x33 to digit 1 and 0
                sbrs    tBCD0,3           ; if bit 3 clear
                subi    tBCD0,0x03        ;       sub 3
                sbrs    tBCD0,7           ; if bit 7 clear
                subi    tBCD0,0x30        ;       sub $30
                subi    tBCD1,-0x33       ; add 0x33 to digit 3 and 2
                sbrs    tBCD1,3           ; if bit 3 clear
                subi    tBCD1,0x03        ;        sub 3
                sbrs    tBCD1,7           ; if bit 7 clear
                subi    tBCD1,0x30        ;       sub $30
                subi    tBCD2,-0x33       ; add 0x33 to digit 5 and 4
                sbrs    tBCD2,3           ; if bit 3 clear
                subi    tBCD2,0x03        ;       sub 3
                sbrs    tBCD2,7           ; if bit 7 clear
                subi    tBCD2,0x30        ;       sub $30
                lsl     fbin0
                rol     fbin1             ; shift lower word
                rol     tBCD0             ; through all bytes
                rol     tBCD1
                rol     tBCD2
                rol     tBCD3
                rol     tBCD4
                brmi    binBCD_loop       ; 7 shiftes w/o correction of MSD
                rol     fbinH             ; since Bin2BCD fbinH = 0xff
                brcc    binBCD_ret        ;   so as to do 16 shiftes in total
                subi    tBCD3,-0x33       ; add 0x33 to digit 7 and 6
                sbrs    tBCD3,3           ; if bit 3 clear
                subi    tBCD3,0x03        ;       sub 3
                sbrs    tBCD3,7           ; if bit 7 clear
                subi    tBCD3,0x30        ;       sub $30
                subi    tBCD4,-0x03       ; add 0x03 to digit 8 only
                sbrs    tBCD4,3           ; if bit 3 clear
                subi    tBCD4,0x03        ;       sub 3
                rjmp    binBCD_loop


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;             LCD-Ansteuerung                              ;;
;;             ===============                              ;;
;;                                                          ;;
;; Ein Standard-LCD mit HD44780-Controller ist an Port B    ;;
;; angeschlossen; die Ansteuerung beruht auf den            ;;
;; LCD-Routinen die ich Anfang 2002 anhand des Datenblatts  ;;
;; geschrieben habe                                         ;;
;;                                                          ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 

; Sendet einen im EEPROM gespeicherten Text an das LCD 
printstring:
        mov temp2, temp1
        out EEARL, temp2                  ; Adresse setzen
        sbi EECR, 0
nextchar:
        in temp1, EEDR
        push temp1
        push temp2
        rcall lcd_data
        pop temp2
        pop temp1
        inc temp2
        out EEARL, temp2
        sbi EECR, 0
        in temp1, EEDR
        tst temp1                         ; ist r0 gleich 0?
        brne nextchar                     ; wenn nicht 0, dann zurück zu nextchar
        ret

; sendet ein Datenbyte an das LCD
lcd_data:
        mov temp2, temp1                  ; "Sicherungskopie" für
                                          ; die Übertragung des 2.Nibbles
        swap temp1                        ; Vertauschen
        andi temp1, 0b00001111            ; oberes Nibble auf Null setzen
        sbr temp1, 1<<4                   ; entspricht 0b00010000
        out PORTB, temp1                  ; ausgeben
        rcall lcd_enable                  ; Enable-Routine aufrufen
                                          ; 2. Nibble, kein swap da es schon
                                          ; an der richtigen stelle ist
        andi temp2, 0b00001111            ; obere Hälfte auf Null setzen 
        sbr temp2, 1<<4                   ; entspricht 0b00010000
        out PORTB, temp2                  ; ausgeben
        rcall lcd_enable                  ; Enable-Routine aufrufen
        rcall delay50us                   ; Delay-Routine aufrufen
        ret                               ; zurück zum Hauptprogramm

; sendet einen Befehl an das LCD
lcd_command:                              ; wie lcd_data, nur ohne RS zu setzen
        mov temp2, temp1
        swap temp1
        andi temp1, 0b00001111
        out PORTB, temp1
        rcall lcd_enable
        andi temp2, 0b00001111
        out PORTB, temp2
        rcall lcd_enable
        rcall delay50us
        ret

; erzeugt den Enable-Puls
lcd_enable:
        sbi PORTB, 5                      ; Enable high
        nop                               ; 4 Taktzyklen warten
        nop
        nop
        nop
        cbi PORTB, 5                      ; Enable wieder low
        ret

; Pause nach jeder Übertragung
delay50us:                                ; ungefähr (SEHR ungefähr) 50us Pause
        ldi  temp1, $62
delay50us_:
        dec  temp1
        brne delay50us_
        ret

; Längere Pause für manche Befehle
delay5ms:                                 ; ~5ms Pause
        ldi  temp1, $31
WGLOOP0:ldi  temp2, $C9
WGLOOP1:dec  temp2
        brne WGLOOP1
        dec  temp1
        brne WGLOOP0
        ret                               ; wieder zurück

; Initialisierung des LCDs
lcd_init:
        ldi temp3,50
powerupwait:
        waitms 5
        dec temp3
        brne powerupwait
        ldi temp1, 0b00000011             ; muss 3mal hintereinander gesendet
        out PORTB, temp1                  ; werden zur Initialisierung
        rcall lcd_enable                  ; 1
        waitms 5
        rcall lcd_enable                  ; 2
        waitms 5
        rcall lcd_enable                  ; und 3
        waitms 5
        ldi temp1, 0b00000010             ; 4bit-Modus einstellen
        out PORTB, temp1
        rcall lcd_enable
        waitms 5
        ldi temp1, 0b00101000             ; noch was einstellen (Cursor, Shift, usw.)...
        rcall lcd_command
        ldi temp1, 0b00001100             ; ...
        rcall lcd_command
        ldi temp1, 0b00000100             ; fertig
        rcall lcd_command
        ret

; Display löschen
lcd_clear:
        ldi temp1, 0b00000001
        rcall lcd_command
        waitms 5
        ret

; Cursor zum Anfang
lcd_home:
        ldi temp1, 0b00000010
        rcall lcd_command
        waitms 5
        ret

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;         sonstige Funktionen                              ;;
;;         ===================                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

; Frequenz auf 0 setzen
set0:  clr change1
       clr change2
       clr change3
       ret

; x ms warten
wms:
        push temp2
        out TCNT0, null
wms_1:
        in temp2, TCNT0
        cp temp2, temp1
        brlo wms_1
        pop temp2
        ret

; x*10 ms warten
w10ms:
        push temp2
        ldi temp2, 10
w10ms_1:dec temp2
        rcall wms
        cpi temp2,0
        brne w10ms_1
        pop temp2
        ret