AtMega8 kleine Bibliothek

Hallo,

hier mal eine kleine Bibliothek für den AtMega8, womit ich schon seit etwas längerer Zeit arbeite,
damit man nicht bei jedem Projektstart sich elendig lange wieder alles aus dem Datenblatt zusammen suchen muss
und zügiger starten kann.

getestet mit:
SW AVRStudio4.19 Build 716
HW STK500

Includes sind folgende

ADC
AnalogComparator
EEprom
Externe Interrupts
UART um rs232 aufzubauen
TimerCounter T0-T2

Die origin.asm ist die Hauptdatei.

Viel Spaß beim probieren

origin.asm

Code:

---

;######################################
;# Projekt:                                                                                  #
;#                                                                                                  #
;#                                                                                                  #
;# Taktfrequenz des AVR: 4 MHz                                                          #             
;#                                                                                                  #
;# CS-SOFT                                                                                  #
;###########################################

.include "m8def.inc"        ;Atmega8

.def math1h        = r8
.def math1l        = r9
.def math2h        = R10
.def math2l        = r11
.def matherghh        = r12
.def mathergh        = r13
.def mathergl        = r14
.def mathergll        = r15

.def temp0 = r16        ;
.def temp1 = r17        ;
.def temp2 = r18
.def temp3 = r19        ;
.def temp4 = r20
.def cnt    = r21

.equ        ocr2s        =        $0063                        ;für T2
.equ        ocra1h        =        $0064                        ;;;;;
.equ        ocra1l        =        $0065                        ;;;;;;;; für T1 A channel
.equ        ocrb1h        =        $0066                        ;;;;;
.equ        ocrb1l        =        $0067                        ;;;;;;;; für T1 B channel
.equ        icr1xh        =        $0068                        ;;;;;
.equ        icr1xl        =        $0069                        ;;;;;;;; für T1 ICR
.equ        hadc        =        $006a                        ;adc
.equ        ladc        =        $006b                        ;adc
.equ        eep_adrh=        $006c                        ;eeprom
.equ        eep_adrl=        $006d                        ;eeprom

;***************************Einsprungadressen***********************
.cseg
.org $0000
        rjmp        stack
.org $0001                        ;1
        rjmp        INT_0
.org $0002                        ;2
        rjmp        INT_1
.org $0003                        ;3
        rjmp        INT_OC2
.org $0004                        ;4
        rjmp        INT_OVF2
.org $0005                        ;5
        rjmp        INT_ICP1
.org $0006                        ;6
        rjmp        INT_OC1A
.org $0007                        ;7
        rjmp        INT_OC1B
.org $0008                        ;8
        rjmp        INT_OVF1
.org $0009                        ;9
        rjmp        INT_OVF0

                reti                ;a keine SPI Routinen

.org $000b                        ;b
        rjmp        INT_URXC
.org $000c                        ;c
        rjmp        INT_UDRE
.org $000d                        ;d
        rjmp        INT_UTXC
.org $000e                        ;e
        rjmp        adc_rdy
.org $000f                        ;f
        rjmp        eeprom_rdy
.org $0010                        ;10
        rjmp        ac_int

                reti                ;11        keine 2wireRoutinen
                reti                ;12 keine SPMRoutinen

/* so könnten die einsprungmarken der INTS auch aussehen
INT0addr       
INT1addr       
OC2addr       
OVF2addr
ICP1addr       
OC1Aaddr
OC1Baddr
OVF1addr
OVF0addr
SPIaddr
URXCaddr
UDREaddr
UTXCaddr
ADCCaddr
ERDYaddr
ACIaddr
TWIaddr
SPMRaddr
*/
;***************************Init mit allem drumdran*****************
stack:        ldi                temp1,high(ramend)  ;Stackpointer festlegen
            out                sph, temp1
                ldi                temp1,low(ramend)  ;Stackpointer festlegen
        out                spl, temp1
                rcall                sram

                sbi                        portb,0                                ;pulls aktivieren nur wenn Taster genutzt werden sollen
                sbi                        portb,1
                sbi                        portb,2                                       
                sbi                        portb,3

        ;        rcall                INIT_ext_Int01
        ;        rcall                deak_int01       

        ;        rcall                mode0_t0_init
        ;        rcall                prescaler_T0_on

        ;        rcall                mode0_t1_init
        ;        rcall                prescaler_T1_on

        ;        rcall                mode0_t2_init
        ;        rcall                prescaler_T2_on

        ;        rcall                adc_header
       
        ;        rcall                eeprom_init                ;wenn ints bevorzugt werden       
        ;        rcall                adr_cnt
        ;        rcall                eeprom_write

        ;        rcall                AC_init
        ;        rcall                ac_change
                rcall                usart_init                ;wenn INT bevorzugt dann hier aktivieren und prog erweitern

start:        sbis                pinb,0
                rcall                tx                                ;senden TST auf Bildschirm
                sbis                pinb,1
                rcall                tx_db                        ;sende " TST " auf Bildschirm aus Datenbank
                sbis                pinb,2
                rcall                test_zahl                ;sende Zahl z.B. hex 99 auf Bildschirm !!!!!Keine HEX:DEZ Wandlung!!!!!!!!!!!!!!!!
                sbis                pinb,3
                rcall                rx                                ;warte auf Empfang von " "=$20 und schicke * zurück
                nop
                nop
                nop
                nop
                nop
                nop
                nop
                nop
                rjmp                start



;**********************Masterclr***************************************
sram:        clr                        temp0
                ldi                        yl,low(SRAM_START)
                ldi                        yh,high(SRAM_START)                        ;Masterclr des Sram's über
sram2:        st                        y+,temp0                                ;die indirekte Adressierung
                cpi                        yl,$70                                ;bis zur zelle x=$70 löschen
                brne                        sram2               
                ret


;*************************weitere*includedata***********************
.include "timercounter.asm"
.include "ext_ints.asm"
.include "uart_std.asm"
.include "adc_lst.asm"
.include "eeprom.asm"
.include "analogcomparator.asm"
.include "zeitschleifen.asm"
.include "mathe.asm"
;*************************ENDE**************************************

---

adc_lst.asm !!!!Änderung in start_convers!!!!!!!!!!!!!!!

Code:

---

/*
.equ        ADC_ddr                =        ddrc
.equ        ADC_Port                =        Portc
.equ        ADC_Pin                =        PinC
.equ        Chan0                =        0
.equ        Chan1                =        1
.equ        Chan2                =        2
.equ        Chan3                =        3
.equ        Chan4                =        4
.equ        Chan5                =        5
*/
;******************************adc_interrupt**********************
adc_rdy:
                in                        temp0,adcl                        ;wichtig erst low
                sts                        ladc,temp0
                in                        temp1,adch                ;dann high lesen sonst erg müll
                sts                        hadc,temp1
                reti

;***********************adc_header**************************
adc_header:
                rcall                adc_init
                rcall                start_convers_int        ;mit Interrupt
                ;rcall                start_convers                ;ohne Interrupt
                ret

;***********************adc_init*****************************
adc_init:
                ldi                        temp0,(0<<Chan5|0<<Chan4|0<<Chan3|0<<Chan2|0<<Chan1|0<<Chan0)
                out                        ADC_ddr,temp0
                ldi                        temp0,(0<<Chan5|0<<Chan4|0<<Chan3|0<<Chan2|0<<Chan1|0<<Chan0)
                out                        ADC_Pin,temp0
                in                        temp0,adcsra
                ori                        temp0,(1<<ADEN|0<<ADSC|0<<ADFR|0<<ADIE|1<<ADPS2|0<<ADPS1|1<<ADPS0)        ;       
                out                        adcsra,temp0
                in                        temp0,admux
                ori                        temp0,(0<<REFS1|0<<REFS0|0<<ADLAR|0<<MUX3|0<<MUX2|0<<MUX1|1<<MUX0)        ;AVCC with external capacitor at AREF pin
                out                        admux,temp0                                                                                                                        ;+ messkanal0 (PC0) eingang
                ret

;mit Interrupt
start_convers_int:
                in                        temp0,adcsra        ;wenn ADFR aktiv dann nur adc_read nötig für jeweiligen kanal
                ori                        temp0,(0<<ADEN|1<<ADSC|0<<ADFR|1<<ADIE|1<<ADPS2|0<<ADPS1|0<<ADPS0)        ;freigabe ADC Abtastrate zwischen 50Khz-200Khz Teiler=32 single mode
                out                        adcsra,temp0        ;
                sei
                ret

;ohne Interrupt dann abfrage auf das bits ADSC=1?????
start_convers:
                in                        temp0,adcsra
                ori                        temp0,(0<<ADEN|1<<ADSC|0<<ADFR|0<<ADIE|1<<ADPS2|0<<ADPS1|1<<ADPS0);freigabe der Messung       
                out                        adcsra,temp0
start_convers2:                                        ;;;
                sbic                        ADCSR,ADSC                ;;;;;; diese kleine routine braucht man nicht wenn man mit ints arbeitet
                rjmp                        start_convers2        ;;;
                in                        temp0,adcl                ;wichtig erst low
                in                        temp1,adch                ;dann high lesen sonst erg müll
                sts                        ladc,temp0
                sts                        hadc,temp1
                ret

---

analogcomparator.asm

Code:

---

;ACHTUNG man kann im simulator nicht mit PD6/7 simulieren geht nur
;wenn ACO händisch gesetzt wird ACO=1 wird auch ACI=1 um den int zu nutzen
;wenn man den int nicht nutzt ist die abfrage auf ACO

AC_init:
                ldi                        temp0,(0<<ACD|0<<ACBG|1<<ACIE|0<<ACIC|0<<ACIS1|0<<ACIS0)
                out                        ACSR,temp0       
                sei                                                ;
                ret

ac_change:
                sbis                        ACSR,ACO
                rjmp                        ac_change
                ret

ac_int:
                ;wird aufgerufen wenn pd6+/pd7- pegelunterschiede feststellen
                reti

---

eeprom.asm

Code:

---

;*************************************
eeprom_init:
                ldi                temp0,(1<<EERIE)
                out                EECR,temp0
                sei
                ret

eeprom_rdy:
                ;siehe eeprom_write ;** man kann in der wartezeit andere sachen erledigen
                ;bis der int kommt, um dann weitere daten an den eeprom zum schreiben zu senden
                ;nur bei eeprom schreiben möglich
                reti

;Adreessierung im eeprom
adr_cnt:lds                temp0,eep_adrl
                inc                temp0
                cpi                temp0,$ff
                breq        adr_cnt2
                sts                eep_adrl,temp0
                ret
adr_cnt2:
                clr                temp0
                sts                eep_adrl,temp0
                lds                temp0,eep_adrh
                inc                temp0
                sts                eep_adrh,temp0
                cpi                temp0,$02
                breq                error_eeprom
                ret
error_eeprom:
                ;voll
                ret

EEPROM_write:                               
                sbic                  EECR,EEWE                ;** falls eewe im eecr noch gesetzt
                rjmp                  EEPROM_write                ;** spring zu zurück
                lds                r18,eep_adrh
                out                EEARH, r18                ;highbyte der adr
                lds                r17,eep_adrl
                out                EEARL, r17                ;lowbyte der adr
                out                EEDR,r16                ;zu speichernder wert
                sbi                EECR,EEMWE                ;sperrt eeprom master write enable
                sbi                EECR,EEWE                ;setze EEWE um eeprom zu schreiben
                ret

EEPROM_read:                               
                sbic                  EECR,EEWE                ;falls eewe im eecr noch gesetzt
                rjmp                EEPROM_read                ;springe zurück
                lds                r18,eep_adrh
                out                EEARH, r18                ;highbyte der adr
                lds                r17,eep_adrl
                out                EEARL, r17                ;lowbyte der adr
                sbi                EECR,EERE                ;sperrt lesen des eeproms
                in                r16,EEDR                ;zu lesender wert
                ret

---

ext_ints.asm

Code:

---

;PD2/3 sind INT0/1
INIT_EXT_INT01:
                in                        temp0,MCUCR
                ori                        temp0,(1<<ISC11|1<<ISC10|1<<ISC01|1<<ISC00) ;hier INT0/1 auf steigende flanke siehe PDF KAP.13
                out                        MCUCR,temp0

                in                        temp0,GICR
                ori                        temp0,(1<<INT1|1<<INT0)                        ;beide INTs aktiv
                out                        GICR,temp0

                sei                        ;global int
                ret

deak_INT01:
                in                        temp0,GICR
                andi                        temp0,(0<<INT1|0<<INT0)                        ;beide INTs aktiv
                out                        GICR,temp0
                ret

INT_0:        ;hier steht das programm welches ausgeführt werden soll
                reti

INT_1:        ;hier steht das programm welches ausgeführt werden soll
                reti

---

timercounter.asm

Code:

---

;*****************************INIT-Mode 1 Timer0********************************************************************
mode0_t0_init:
                in                        temp1,TIMSK
                ori                        temp1,(1<<TOIE0)
                out                        TIMSK,temp1
                ldi                        temp1,$60
                out                        TCNT0,temp1
                ret

prescaler_T0_on:
                in                        temp0,TCCR0
                ori                        temp0,(0<<CS12|0<<CS11|1<<CS10) ;schmeißt den counter an
                out                        TCCR0,temp0
                sei
                ret

prescaler_T0_off:
                in                        temp0,TCCR0
                andi                        temp0,(0<<CS12|0<<CS11|0<<CS10) ;stoppt den counter an
                out                        TCCR0,temp0
                ret
       
INT_OVF0:        ;$0009
                ;Achtung T0 muss hier neu geladen werden und dann die eigene IDEE
                reti

;******************************Init-Modes des Timers1***************************************************************
mode0_T1_init:;NORMAL_MODE  OCR1A h:l,OCR1B h:l update ocrxH:L sofort oder im INT
                ;rcall                        A_ch_en                                                ;out aktivieren
                ;rcall                        B_ch_en                                                ;out aktivieren
                ;rcall                        A_ch_load                                        ;Zeitwert laden
                ;rcall                        B_ch_load                                        ;Zeitwert laden
                ldi                        temp0,(0<<ICNC1|0<<ICES1|0<<WGM13|0<<WGM12)        ;zum Toggeln COM1xA/B Einstellungen beachten!!!!!!!!!
                out                        TCCR1B,temp0       
                in                        temp0,TCCR1A
                ori                        temp0,(0<<COM1A1|0<<COM1A0|0<<COM1B1|0<<COM1B0|0<<WGM11|0<<WGM10)        ;zum Toggeln COM1xA/B Einstellungen beachten!!!!!!!!!
                out                        TCCR1A,temp0
                in                        temp0,TIMSK
                ori                        temp0,(0<<TICIE1|0<<OCIE1A|0<<OCIE1B|0<<TOIE1)        ;INT für ICP=off, OCIE1A=off, OCIE1B=off, OVFL=1
                out                        TIMSK,temp0                                               
                ret

mode1_T1_init:;8bit phase correct mode OCR1A h:l,OCR1B h:l update ocrxH:L on top oder im INT
                ;rcall                        A_ch_en                                                ;out aktivieren
                ;rcall                        B_ch_en                                                ;out aktivieren
                ;rcall                        A_ch_load                                        ;Zeitwert laden
                ;rcall                        B_ch_load                                        ;Zeitwert laden
                ldi                        temp0,(0<<WGM13|0<<WGM12)        ;zum Toggeln COM1xA/B Einstellungen beachten!!!!!!!!!
                out                        TCCR1B,temp0       
                in                        temp0,TCCR1A
                ori                        temp0,(1<<COM1A1|0<<COM1A0|1<<COM1B1|0<<COM1B0|0<<WGM11|1<<WGM10)        ;zum Toggeln COM1xA/B Einstellungen beachten!!!!!!!!!
                out                        TCCR1A,temp0
                in                        temp0,TIMSK
                ori                        temp0,(0<<TICIE1|1<<OCIE1A|1<<OCIE1B|0<<TOIE1)        ;INT für ICP=off, OCIE1A=off, OCIE1B=off, OVFL=1
                out                        TIMSK,temp0                                               
                ret

mode2_T1_init:;9bit phase correct mode OCR1A h:l,OCR1B h:l update ocrxH:L on top oder im INT
                ;rcall                        A_ch_en                                                ;out aktivieren
                ;rcall                        B_ch_en                                                ;out aktivieren
                ;rcall                        A_ch_load                                        ;Zeitwert laden
                ;rcall                        B_ch_load                                        ;Zeitwert laden
                ldi                        temp0,(0<<WGM13|0<<WGM12)        ;zum Toggeln COM1xA/B Einstellungen beachten!!!!!!!!!
                out                        TCCR1B,temp0       
                in                        temp0,TCCR1A
                ori                        temp0,(1<<COM1A1|0<<COM1A0|1<<COM1B1|0<<COM1B0|1<<WGM11|0<<WGM10)        ;zum Toggeln COM1xA/B Einstellungen beachten!!!!!!!!!
                out                        TCCR1A,temp0
                in                        temp0,TIMSK
                ori                        temp0,(0<<TICIE1|1<<OCIE1A|1<<OCIE1B|0<<TOIE1)        ;INT für ICP=off, OCIE1A=off, OCIE1B=off, OVFL=1
                out                        TIMSK,temp0                                               
                ret

mode3_T1_init:;10bit phase correct mode OCR1A h:l,OCR1B h:l update ocrxH:L on top oder im INT
                ;rcall                        A_ch_en                                                ;out aktivieren
                ;rcall                        B_ch_en                                                ;out aktivieren
                ;rcall                        A_ch_load                                        ;Zeitwert laden
                ;rcall                        B_ch_load                                        ;Zeitwert laden
                ldi                        temp0,(0<<WGM13|0<<WGM12)        ;zum Toggeln COM1xA/B Einstellungen beachten!!!!!!!!!
                out                        TCCR1B,temp0       
                in                        temp0,TCCR1A
                ori                        temp0,(1<<COM1A1|0<<COM1A0|1<<COM1B1|0<<COM1B0|1<<WGM11|1<<WGM10)        ;zum Toggeln COM1xA/B Einstellungen beachten!!!!!!!!!
                out                        TCCR1A,temp0
                in                        temp0,TIMSK
                ori                        temp0,(0<<TICIE1|1<<OCIE1A|1<<OCIE1B|0<<TOIE1)        ;INT für ICP=off, OCIE1A=off, OCIE1B=off, OVFL=1
                out                        TIMSK,temp0                                               
                ret

mode4_T1_init:;CTC mode OCR1A h:l,OCR1B h:l update ocrAH:L oder im INT
                ;rcall                        A_ch_en                                                ;out aktivieren
                ;rcall                        B_ch_en                                                ;out aktivieren
                ;rcall                        A_ch_load                                        ;Zeitwert laden
                ;rcall                        B_ch_load                                        ;Zeitwert laden
                ldi                        temp0,(0<<WGM13|1<<WGM12)        ;zum Toggeln COM1xA/B Einstellungen beachten!!!!!!!!!
                out                        TCCR1B,temp0       
                in                        temp0,TCCR1A
                ori                        temp0,(0<<COM1A1|0<<COM1A0|0<<COM1B1|0<<COM1B0|0<<WGM11|0<<WGM10)        ;zum Toggeln COM1xA/B Einstellungen beachten!!!!!!!!!
                out                        TCCR1A,temp0
                in                        temp0,TIMSK
                ori                        temp0,(0<<TICIE1|0<<OCIE1A|0<<OCIE1B|0<<TOIE1)        ;INT für ICP=off, OCIE1A=off, OCIE1B=off, OVFL=1
                out                        TIMSK,temp0                                               
                ret

mode5_T1_init:;FAST PWM 8bit OCR1A h:l,OCR1B h:l update ocrxH:L on bottom oder im INT
                ;rcall                        A_ch_en                                                ;out aktivieren
                ;rcall                        B_ch_en                                                ;out aktivieren
                ;rcall                        A_ch_load                                        ;Zeitwert laden
                ;rcall                        B_ch_load                                        ;Zeitwert laden
                ldi                        temp0,(0<<WGM13|1<<WGM12)        ;zum Toggeln COM1xA/B Einstellungen beachten!!!!!!!!!
                out                        TCCR1B,temp0       
                in                        temp0,TCCR1A
                ori                        temp0,(1<<COM1A1|0<<COM1A0|1<<COM1B1|0<<COM1B0|0<<WGM11|1<<WGM10)        ;zum Toggeln COM1xA/B Einstellungen beachten!!!!!!!!!
                out                        TCCR1A,temp0
                in                        temp0,TIMSK
                ori                        temp0,(0<<TICIE1|1<<OCIE1A|1<<OCIE1B|0<<TOIE1)        ;INT für ICP=off, OCIE1A=off, OCIE1B=off, OVFL=1
                out                        TIMSK,temp0                                               
                ret

mode6_T1_init:;FAST PWM 9bit OCR1A h:l,OCR1B h:l update ocrxH:L on bottom oder im INT
                ;rcall                        A_ch_en                                                ;out aktivieren
                ;rcall                        B_ch_en                                                ;out aktivieren
                ;rcall                        A_ch_load                                        ;Zeitwert laden
                ;rcall                        B_ch_load                                        ;Zeitwert laden
                ldi                        temp0,(0<<WGM13|1<<WGM12)        ;zum Toggeln COM1xA/B Einstellungen beachten!!!!!!!!!
                out                        TCCR1B,temp0       
                in                        temp0,TCCR1A
                ori                        temp0,(1<<COM1A1|0<<COM1A0|1<<COM1B1|0<<COM1B0|1<<WGM11|0<<WGM10)        ;zum Toggeln COM1xA/B Einstellungen beachten!!!!!!!!!
                out                        TCCR1A,temp0
                in                        temp0,TIMSK
                ori                        temp0,(0<<TICIE1|1<<OCIE1A|1<<OCIE1B|0<<TOIE1)        ;INT für ICP=off, OCIE1A=off, OCIE1B=off, OVFL=1
                out                        TIMSK,temp0                                               
                ret

mode7_T1_init:;FAST PWM 10bit OCR1A h:l,OCR1B h:l update ocrxH:L on bottom oder im INT
                ;rcall                        A_ch_en                                                ;out aktivieren
                ;rcall                        B_ch_en                                                ;out aktivieren
                ;rcall                        A_ch_load                                        ;Zeitwert laden
                ;rcall                        B_ch_load                                        ;Zeitwert laden
                ldi                        temp0,(0<<WGM13|1<<WGM12)        ;zum Toggeln COM1xA/B Einstellungen beachten!!!!!!!!!
                out                        TCCR1B,temp0       
                in                        temp0,TCCR1A
                ori                        temp0,(1<<COM1A1|0<<COM1A0|1<<COM1B1|0<<COM1B0|1<<WGM11|1<<WGM10)        ;zum Toggeln COM1xA/B Einstellungen beachten!!!!!!!!!
                out                        TCCR1A,temp0
                in                        temp0,TIMSK
                ori                        temp0,(0<<TICIE1|1<<OCIE1A|1<<OCIE1B|0<<TOIE1)        ;INT für ICP=off, OCIE1A=off, OCIE1B=off, OVFL=1
                out                        TIMSK,temp0                                               
                ret

mode8_T1_init:;PWM,PahseFrequenzyCorrect OCR1A h:l,ICRh:l update ocrxH:L on bottom oder im INT
                ;rcall                        A_ch_en                                                ;out aktivieren
                ;rcall                        B_ch_en                                                ;out aktivieren
                ;rcall                        A_ch_load                                        ;Zeitwert laden
                ;rcall                        B_ch_load                                        ;Zeitwert laden
                ldi                        temp0,(1<<ICES1|1<<WGM13|0<<WGM12)        ;zum Toggeln COM1xA/B Einstellungen beachten!!!!!!!!!
                out                        TCCR1B,temp0       
                in                        temp0,TCCR1A
                ori                        temp0,(1<<COM1A1|0<<COM1A0|1<<COM1B1|0<<COM1B0|0<<WGM11|0<<WGM10)        ;zum Toggeln COM1xA/B Einstellungen beachten!!!!!!!!!
                out                        TCCR1A,temp0
                in                        temp0,TIMSK
                ori                        temp0,(1<<TICIE1|0<<OCIE1A|0<<OCIE1B|0<<TOIE1)        ;INT für ICP=off, OCIE1A=off, OCIE1B=off, OVFL=1
                out                        TIMSK,temp0                                               
                ret

mode9_T1_init:;PWM,PahseFrequenzyCorrect OCR1A h:l,OCR1A h:l update ocrxH:L on bottom oder im INT
                ;rcall                        A_ch_en                                                ;out aktivieren
                ;rcall                        B_ch_en                                                ;out aktivieren
                ;rcall                        A_ch_load                                        ;Zeitwert laden
                ;rcall                        B_ch_load                                        ;Zeitwert laden
                ldi                        temp0,(1<<WGM13|0<<WGM12)        ;zum Toggeln COM1xA/B Einstellungen beachten!!!!!!!!!
                out                        TCCR1B,temp0       
                in                        temp0,TCCR1A
                ori                        temp0,(1<<COM1A1|0<<COM1A0|1<<COM1B1|0<<COM1B0|0<<WGM11|1<<WGM10)        ;zum Toggeln COM1xA/B Einstellungen beachten!!!!!!!!!
                out                        TCCR1A,temp0
                in                        temp0,TIMSK
                ori                        temp0,(0<<TICIE1|1<<OCIE1A|1<<OCIE1B|0<<TOIE1)        ;INT für ICP=off, OCIE1A=off, OCIE1B=off, OVFL=1
                out                        TIMSK,temp0                                               
                ret

mode10_T1_init:;PWM,PahseCorrect OCR1A h:l,ICRh:l update ocrxH:L on top oder im INT
                ;rcall                        A_ch_en                                                ;out aktivieren
                ;rcall                        B_ch_en                                                ;out aktivieren
                ;rcall                        A_ch_load                                        ;Zeitwert laden
                ;rcall                        B_ch_load                                        ;Zeitwert laden
                ldi                        temp0,(1<<WGM13|0<<WGM12)        ;zum Toggeln COM1xA/B Einstellungen beachten!!!!!!!!!
                out                        TCCR1B,temp0       
                in                        temp0,TCCR1A
                ori                        temp0,(1<<COM1A1|0<<COM1A0|1<<COM1B1|0<<COM1B0|1<<WGM11|0<<WGM10)        ;zum Toggeln COM1xA/B Einstellungen beachten!!!!!!!!!
                out                        TCCR1A,temp0
                in                        temp0,TIMSK
                ori                        temp0,(1<<TICIE1|0<<OCIE1A|0<<OCIE1B|0<<TOIE1)        ;INT für ICP=off, OCIE1A=off, OCIE1B=off, OVFL=1
                out                        TIMSK,temp0                                               
                ret

mode11_T1_init:;PWM,PahseCorrect OCR1A h:l,OCRah:l update ocrxH:L on top oder im INT
                ;rcall                        A_ch_en                                                ;out aktivieren
                ;rcall                        B_ch_en                                                ;out aktivieren
                ;rcall                        A_ch_load                                        ;Zeitwert laden
                ;rcall                        B_ch_load                                        ;Zeitwert laden
                ldi                        temp0,(1<<WGM13|0<<WGM12)        ;zum Toggeln COM1xA/B Einstellungen beachten!!!!!!!!!
                out                        TCCR1B,temp0       
                in                        temp0,TCCR1A
                ori                        temp0,(1<<COM1A1|0<<COM1A0|1<<COM1B1|0<<COM1B0|1<<WGM11|1<<WGM10)        ;zum Toggeln COM1xA/B Einstellungen beachten!!!!!!!!!
                out                        TCCR1A,temp0
                in                        temp0,TIMSK
                ori                        temp0,(0<<TICIE1|1<<OCIE1A|1<<OCIE1B|0<<TOIE1)        ;INT für ICP=off, OCIE1A=off, OCIE1B=off, OVFL=1
                out                        TIMSK,temp0                                               
                ret

mode12_T1_init:;CTC OCR1A h:l,ICRh:l update sofort oder im INT
                ;rcall                        A_ch_en                                                ;out aktivieren
                ;rcall                        B_ch_en                                                ;out aktivieren
                ;rcall                        A_ch_load                                        ;Zeitwert laden
                ;rcall                        B_ch_load                                        ;Zeitwert laden
                ldi                        temp0,(1<<WGM13|1<<WGM12)        ;zum Toggeln COM1xA/B Einstellungen beachten!!!!!!!!!
                out                        TCCR1B,temp0       
                in                        temp0,TCCR1A
                ori                        temp0,(0<<COM1A1|1<<COM1A0|0<<COM1B1|1<<COM1B0|0<<WGM11|0<<WGM10)        ;zum Toggeln COM1xA/B Einstellungen beachten!!!!!!!!!
                out                        TCCR1A,temp0
                in                        temp0,TIMSK
                ori                        temp0,(1<<TICIE1|0<<OCIE1A|0<<OCIE1B|0<<TOIE1)        ;INT für ICP=off, OCIE1A=off, OCIE1B=off, OVFL=1
                out                        TIMSK,temp0                                               
                ret

mode13_T1_init:;RESERVED not activated
        /*        ;rcall                        A_ch_en                                                ;out aktivieren
                ;rcall                        B_ch_en                                                ;out aktivieren
                ;rcall                        A_ch_load                                        ;Zeitwert laden
                ;rcall                        B_ch_load                                        ;Zeitwert laden
                ldi                        temp0,(1<<WGM13|1<<WGM12)        ;zum Toggeln COM1xA/B Einstellungen beachten!!!!!!!!!
                out                        TCCR1B,temp0       
                in                        temp0,TCCR1A
                ori                        temp0,(1<<COM1A1|0<<COM1A0|1<<COM1B1|0<<COM1B0|0<<WGM11|1<<WGM10)        ;zum Toggeln COM1xA/B Einstellungen beachten!!!!!!!!!
                out                        TCCR1A,temp0
                in                        temp0,TIMSK
                ori                        temp0,(0<<TICIE1|1<<OCIE1A|1<<OCIE1B|0<<TOIE1)        ;INT für ICP=off, OCIE1A=off, OCIE1B=off, OVFL=1
                out                        TIMSK,temp0                                               
        */        ret

mode14_T1_init:;FAST PWM OCR1A h:l,ICRh:l update ocrxH:L on bottom oder im INT
                ;rcall                        A_ch_en                                                ;out aktivieren
                ;rcall                        B_ch_en                                                ;out aktivieren
                ;rcall                        A_ch_load                                        ;Zeitwert laden
                ;rcall                        B_ch_load                                        ;Zeitwert laden
                ldi                        temp0,(1<<WGM13|1<<WGM12)        ;zum Toggeln COM1xA/B Einstellungen beachten!!!!!!!!!
                out                        TCCR1B,temp0       
                in                        temp0,TCCR1A
                ori                        temp0,(1<<COM1A1|0<<COM1A0|1<<COM1B1|0<<COM1B0|1<<WGM11|0<<WGM10)        ;zum Toggeln COM1xA/B Einstellungen beachten!!!!!!!!!
                out                        TCCR1A,temp0
                in                        temp0,TIMSK
                ori                        temp0,(1<<TICIE1|0<<OCIE1A|0<<OCIE1B|0<<TOIE1)        ;INT für ICP=off, OCIE1A=off, OCIE1B=off, OVFL=1
                out                        TIMSK,temp0                                               
                ret

mode15_T1_init:;FAST PWM OCR1A h:l,OCRah:l update ocrxH:L on bottom oder im INT
                ;rcall                        A_ch_en                                                ;out aktivieren
                ;rcall                        B_ch_en                                                ;out aktivieren
                ;rcall                        A_ch_load                                        ;Zeitwert laden
                ;rcall                        B_ch_load                                        ;Zeitwert laden
                ldi                        temp0,(1<<WGM13|1<<WGM12)        ;zum Toggeln COM1xA/B Einstellungen beachten!!!!!!!!!
                out                        TCCR1B,temp0       
                in                        temp0,TCCR1A
                ori                        temp0,(1<<COM1A1|0<<COM1A0|1<<COM1B1|0<<COM1B0|1<<WGM11|1<<WGM10)        ;zum Toggeln COM1xA/B Einstellungen beachten!!!!!!!!!
                out                        TCCR1A,temp0
                in                        temp0,TIMSK
                ori                        temp0,(0<<TICIE1|1<<OCIE1A|1<<OCIE1B|0<<TOIE1)        ;INT für ICP=off, OCIE1A=off, OCIE1B=off, OVFL=1
                out                        TIMSK,temp0                                               
                ret

prescaler_T1_on:
                in                        temp0,TCCR1B
                ori                        temp0,(1<<CS12|1<<CS11|1<<CS10) ;schmeißt den counter an
                out                        TCCR1B,temp0
                sei
                ret

prescaler_T1_off:
                in                        temp0,TCCR1B
                andi                        temp0,(0<<CS12|0<<CS11|0<<CS10) ;stoppt den counter an
                out                        TCCR1B,temp0
                ret

;**********Channel load
A_ch_load:
                ldi                        temp0,$9c                ;Toggeln oder Clr/Set aktiv muss OCR1Ah-Register beachtet werden um
                sts                        OCRa1h,temp0        ;____--- oder _------ zu erreichen
                out                        OCR1ah,temp0
                ldi                        temp0,$40                ;Toggeln oder Clr/Set aktiv muss OCR1Al-Register beachtet werden um
                sts                        OCRa1l,temp0        ;____--- oder _------ zu erreichen
                out                        OCR1al,temp0
                ret

A_ch_en:sbi                        ddrb,1                        ;output aktivieren wenn Toggeln am PINB1=OCR1A erwünscht
                ret

A_ch_dis:
                cbi                        ddrb,1                        ;output deaktivieren wenn Toggeln am PINB1=OCR1A erwünscht
                ret

B_ch_load:
                ldi                        temp0,$00                ;Toggeln oder Clr/Set aktiv muss OCR1Bh-Register beachtet werden um
                sts                        OCRb1h,temp0        ;____--- oder _------ zu erreichen
                out                        OCR1bh,temp0
                ldi                        temp0,$80                ;Toggeln oder Clr/Set aktiv muss OCR1Bl-Register beachtet werden um
                sts                        OCRb1l,temp0        ;____--- oder _------ zu erreichen
                out                        OCR1bh,temp0
                ret

B_ch_en:sbi                        ddrb,2                        ;output aktivieren wenn Toggeln am PINB1=OCR1A erwünscht
                ret

B_ch_dis:
                cbi                        ddrb,2                        ;output deaktivieren wenn Toggeln am PINB1=OCR1A erwünscht
                ret

T1_clr:       
                clr                        temp0
                out                        TCNT1h,temp0
                out                        TCNT1l,temp0
                ret

;**********ISR
INT_ICP1: ;$0005 Timer/Counter1 Capture Event
                ;ICRH:L wird vom Counter TVCNT1H:L bei Steigender/Fallender Flanke beschrieben
                reti

INT_OC1A: ;$0006 Timer/Counter1 Compare Match A
                set
                ;push                        temp0
                ;lds                        temp0,OCRa1h                ;Toggeln oder Clr/Set aktiv muss OCR1Ah-Register beachtet werden um
                ;out                        OCR1Ah,temp0        ;____--- oder _------ zu erreichen
                ;lds                        temp0,OCRa1l                ;Toggeln oder Clr/Set aktiv muss OCR1Al-Register beachtet werden um
                ;out                        OCR1Al,temp0        ;____--- oder _------ zu erreichen
                ;pop                        temp0
                reti

INT_OC1B: ;$0007 Timer/Counter1 Compare Match B
                push                        temp0
                lds                        temp0,OCRb1h                ;Toggeln oder Clr/Set aktiv muss OCR1Bh-Register beachtet werden um
                out                        OCR1Bh,temp0        ;____--- oder _------ zu erreichen
                lds                        temp0,OCRb1l                ;Toggeln oder Clr/Set aktiv muss OCR1Bl-Register beachtet werden um
                out                        OCR1Bl,temp0        ;____--- oder _------ zu erreichen
                pop                        temp0
                reti

INT_OVF1: ;$0008 Timer/Counter1 Overflow
                reti

;*******************************************************************************************************************
;******************************Init-Modes des Timers2***************************************************************
mode0_T2_init:;NORMAL_MODE  OCR2 update sofort oder im INT
                ;sbi                        ddrb,3                        ;output aktivieren wenn Toggeln am PINB3=OCR2 erwünscht
                ;ldi                        temp0,$80                ;Toggeln oder Clr/Set aktiv muss OCR2-Register beachtet werden um
                ;out                        OCR2,temp0                ;____--- oder _------ zu erreichen
                in                        temp0,TIMSK
                ori                        temp0,(0<<OCIE2|1<<TOIE2)        ;TimerOvfl-Int aktivieren
                out                        TIMSK,temp0
                ldi                        temp0,(0<<WGM21|0<<WGM20|0<<COM21|0<<COM20)        ;zum Toggeln COM2x Einstellungen beachten!!!!!!!!!
                out                        TCCR2,temp0                                                                        ;
                ret

mode1_T2_init:;PWM-PhaseCorrect kein toggeln möglich nur Clear/Set, bei erreichen TOP = OCR2 update
                sbi                        ddrb,3                        ;output aktivieren
                ldi                        temp0,$80                ;zum Clr/Set muss OCR2-Register beachtet werden um
                out                        OCR2,temp0                ;____--- oder _------ zu erreichen
                in                        temp0,TIMSK
                ori                        temp0,(0<<OCIE2|0<<TOIE2);OutputCompareInterrupt deaktiviert
                out                        TIMSK,temp0
                ldi                        temp0,(0<<WGM21|1<<WGM20|1<<COM21|0<<COM20)        ;zum Toggeln COM2x Einstellungen beachten!!!!!!!!!
                out                        TCCR2,temp0
                ret
               
mode2_T2_init:;CTC = nonPwm = toggeln möglich OCR2 update sofort oder im INT
                sbi                        ddrb,3                        ;output aktivieren
                ldi                        temp0,$13                ;Toggeln oder Clr/Set aktiv muss OCR2-Register beachtet werden um
                out                        OCR2,temp0                ;________-------- oder ____---- zu erreichen
                sts                        OCR2s,temp0
                in                        temp0,TIMSK
                ori                        temp0,(1<<OCIE2|0<<TOIE2);OutputCompareInterrupt deaktiviert                                       
                out                        TIMSK,temp0
                ldi                        temp0,(1<<WGM21|0<<WGM20|0<<COM21|1<<COM20)        ;zum Toggeln COM2x Einstellungen beachten!!!!!!!!!
                out                        TCCR2,temp0
                ret
               
mode3_T2_init:;FastPWM kein toggeln möglich nur Clear/Set, bei erreichen BOTTOM = OCR2 update
                sbi                        ddrb,3                        ;output aktivieren
                ldi                        temp0,$e0                ;zum Clr/Set muss OCR2-Register beachtet werden um
                out                        OCR2,temp0                ;____--- oder _------ zu erreichen               
                sts                        OCR2s,temp0
                in                        temp0,TIMSK
                ori                        temp0,(1<<OCIE2|0<<TOIE2);OutputCompareInterrupt deaktiviert
                out                        TIMSK,temp0
                ldi                        temp0,(1<<WGM21|1<<WGM20|1<<COM21|0<<COM20)        ;zum Toggeln COM2x Einstellungen beachten!!!!!!!!!
                out                        TCCR2,temp0
                ret

prescaler_T2_on:
                in                        temp0,TCCR2
                ori                        temp0,(1<<CS22|1<<CS21|0<<CS20) ;schmeißt den counter an
                out                        TCCR2,temp0
                sei
                ret

prescaler_T2_off:
                in                        temp0,TCCR2
                andi                        temp0,(0<<CS22|0<<CS21|0<<CS20) ;stoppt den counter an
                out                        TCCR2,temp0
                ret

T2_clr:        clr                        temp0
                out                        TCNT2,temp0
                ret

INT_OC2: ;$0003
                push                        temp1
                lds                        temp1,ocr2s
                out                        ocr2,temp1
                pop                        temp1
                reti

INT_OVF2: ;$0004
                reti

---

uart_std.asm

Code:

---

;************************Unterprogramme******************************
tx:                rcall                        wait150ms
                ldi                        temp1,'T'
                rcall                        data_transmit        ;sende T
                ldi                        temp1,'S'
                rcall                        data_transmit        ;sende S
                ldi                        temp1,'T'
                rcall                        data_transmit        ;sende T
                ret

tx_DB:        ldi                        zh,high(Out0_rs*2)
                ldi                        zl,low(Out0_rs*2)
                rcall                        txt_out_rs
                ret

rx:                rcall                        data_received        ;warte auf daten von PC
                cpi                        temp1,' '                ;vergleich auf Leerzeichen
                brne                        rx                                ;sonst wenn falsch warte weiter
                ldi                        temp1,'*'                ;
                rcall                        data_transmit        ;sende * als ack
                ret

;***********************Wandlung in ASCII*****************************
txt_out_rs:
                lpm                        temp1,z+                ;!!! muss der .db *2 genommen werden
                cpi                        temp1,$ff                ;Ende der Datenbank mit $ff gekennzeichnet
                breq                        txt_out_rs_end
                rcall                        data_transmit        ;z.b.: ldi ZH,high(out0*2)
                rjmp                        txt_out_rs
txt_out_rs_end:
                ret

out0_rs: .db " TST ",$ff

;************************Wandlung nur Zahl(0-9) nach ASCII**********************
test_zahl:
                ldi                        temp1,$99
                rcall                        zahl_out_rs
                ret

zahl_out_rs:
                push                        temp1                        ;sichern für 2ten teil
                andi                        temp1,$f0                ;
                swap                        temp1                        ;
                ori                        temp1,$30
                rcall                        data_transmit
                pop                        temp1                        ;2ter Teil
                andi                        temp1,$0f
                ori                        temp1,$30
                rcall                        data_transmit
                ret

;************************uart_init mit RX interrupt**********************
usart_init:
                ldi                        temp0,(0<<URSEL)
                out                        UCSRC,temp0
                clr                        temp0
                out                        UBRRH,temp0
                ldi                        temp0,$19                                        ;9600 Baud einstellen PDF S.133 table52
                out                        UBRRL,temp0

                rcall                        char_size8                                        ;8 zeichen, 1 stoppbit
               
                ldi                        temp0,(0<<U2X|0<<MPCM)                ;no DoubleSpeed, no MultiProzComMode
                out                        UCSRA,temp0
               
                sei
                ret

char_size5:
                ldi                        temp0,(1<<URSEL|0<<UMSEL|0<<UPM1|0<<UPM0|0<<USBS|0<<UCSZ1|0<<UCSZ0|0<<UCPOL) ;URSEL=1 UCSRC1 or UBRRH0,USBS=1 stoppbits1,
                out                        UCSRC,temp0       
                ldi                        temp0,(0<<RXCIE|0<<TXCIE|0<<UDRIE|1<<RXEN|1<<TXEN|0<<UCSZ2)        ;enable RX u TX  <=5bit(UCSZ2=0)
                out                        UCSRB,temp0        ;
                ret                                               
               
char_size6:
                ldi                        temp0,(1<<URSEL|0<<UMSEL|0<<UPM1|0<<UPM0|0<<USBS|0<<UCSZ1|1<<UCSZ0|0<<UCPOL) ;URSEL=1 UCSRC1 or UBRRH0,USBS=1 stoppbits1,
                out                          UCSRC,temp0       
                ldi                        temp0,(0<<RXCIE|0<<TXCIE|0<<UDRIE|1<<RXEN|1<<TXEN|0<<UCSZ2)        ;enable RX u TX  <=6bit(UCSZ2=0)
                out                        UCSRB,temp0       
                ret                                                                                               
                       
char_size7:
                ldi                        temp0,(1<<URSEL|0<<UMSEL|0<<UPM1|0<<UPM0|0<<USBS|1<<UCSZ1|0<<UCSZ0|0<<UCPOL) ;URSEL=1 UCSRC1 or UBRRH0,USBS=1 stoppbits1,
                out                        UCSRC,temp0               
                ldi                        temp0,(0<<RXCIE|0<<TXCIE|0<<UDRIE|1<<RXEN|1<<TXEN|0<<UCSZ2)        ;enable RX u TX  <=7bit(UCSZ2=0)
                out                        UCSRB,temp0        ;
                ret                                                                                       
               
char_size8:
                ldi                        temp0,(1<<URSEL|0<<UMSEL|0<<UPM1|0<<UPM0|0<<USBS|1<<UCSZ1|1<<UCSZ0|0<<UCPOL) ;URSEL=1 UCSRC1 or UBRRH0,USBS=1 stoppbits1,
                out                        UCSRC,temp0       
                ldi                        temp0,(0<<RXCIE|0<<TXCIE|0<<UDRIE|1<<RXEN|1<<TXEN|0<<UCSZ2)        ;enable RX u TX  <=7bit(UCSZ2=0)
                out                        UCSRB,temp0       
                ret                                       

char_size9:
                ldi                          temp0,(1<<URSEL|0<<UMSEL|0<<UPM1|0<<UPM0|0<<USBS|1<<UCSZ1|1<<UCSZ0|0<<UCPOL) ;URSEL=1 UCSRC1 or UBRRH0,USBS=1 stoppbits1,
                out                          UCSRC,temp0       
                ldi                          temp0,(0<<RXCIE|0<<TXCIE|0<<UDRIE|1<<RXEN|1<<TXEN|1<<UCSZ2)        ;enable RX u TX  <=9bit(UCSZ2=1)
                out                          UCSRB,temp0       
                ret                                                               

;************************uart_deinit********************************
usart_all_aus:
                clr                        temp0
                out                        UCSRB,temp0
                out                        UCSRC,temp0
                out                        UBRRL,temp0
                out                        UBRRH,temp0
                ret

usart_ofln:                                                                        ;wenn unterprogramme nicht
                clr                        temp0                                        ;gestört werden dürfen
                out                        UCSRB,temp0                                ;nur usart offline
                ret

;**********************daten_senden*********************************
INT_UTXC:
                ;siehe data_transmit;** man kann in der wartezeit andere sachen erledigen
                ;bis der int kommt im INT selbst könnte man ne art daten-lese-schleife implementieren
                ;um weitere daten zu senden die dann an temp1>>>UDR weitergegeben werden
                out                      UDR,temp1                        ; Put LSB data (r17) into buffer, tranceived data
                reti

data_transmit:
                sbis                    UCSRA,UDRE                        ;**
                rjmp                  data_transmit                ;**
                out                    UDR,temp1                        ; Put LSB data (r17) into buffer, tranceived data
                ret

;**********************daten_empfangen (polling)**********************
INT_URXC:
                in                        temp1,UDR                        ; Put data from buffer into r17, received Data
                ;siehe data_received;** man kann in der wartezeit andere sachen erledigen
                ;bis der int kommt im INT selbst könnte man ne art daten-schreib-schleife implementieren
                ;um weitere daten zu empfangen die dann an UDR>>>temp1 weitergegeben werden
                reti

data_received:
                sbis                  UCSRA,RXC                        ;**
                rjmp                        data_received                ;**
                in                        temp1,UDR                        ; Put data from buffer into r17, received Data
                ret

;********************DatenRegisterLeereInterrupt***********************
INT_UDRE:
                ;SOLANGE dieses register leer ist wird diese routine aufgerufen
                ;also eigentlich immer wenn UDR=0
                reti

---

zeitschleifen.asm

Code:

---

;************************zeitschleifen******************************************
wait1us:nop
        ret

wait6us:
        ldi            temp0,$06
wait6us1:
        dec            temp0
        brne                wait6us1
        ret           

wait9us:
        ldi            temp0,$0a       
wait9us1:
        dec            temp0
        brne                wait9us1
        ret

wait10us:
        ldi            temp0,$0c   
wait10us1:
        dec            temp0
        brne                wait10us1
        ret


wait25us:
        ldi            temp4,$20
wait25us1:       
        dec            temp4
        brne              wait25us1       
        ret

wait50us:
        ldi            temp4,$41
wait50us1:       
        dec            temp4
        brne            wait50us1       
        ret

wait55us:
        ldi            temp0,$41
wait55us1:
        dec            temp0
        brne                wait55us1
        ret

wait58us:
        ldi            temp4,$4c
wait58us1:   
        dec            temp4
        brne                wait58us1       
        ret

wait60us:
        ldi            temp0,$4e
wait60us1:
        dec            temp0
        brne                wait60us1
        ret

wait64us:
        ldi            temp0,$54
wait64us1:
        dec            temp0
        brne                wait64us1
        ret

wait70us:
        ldi            temp0,$5a
        nop
wait70us1:
        dec            temp0
        brne                wait70us1
        nop
        nop
        ret

wait100us:
        ldi            temp4,$83
wait100us1:
        dec            temp4
        brne                wait100us1
        ret       

wait500us:
        ldi            temp1,$03
wait500us1:
        ldi            temp0,$dd
wait500us2:
        dec            temp0
        brne                wait500us2
        dec            temp1
        brne                wait500us1
        ret

wait1ms:ldi            temp3,$06
wait1ms1:
        ldi            temp4,$df
wait1ms2:
        dec            temp4
        brne              wait1ms2
        dec            temp3
        brne              wait1ms1
        ret

wait10ms:ldi                temp3,$60
wait10ms1:
        ldi            temp4,$df
wait10ms2:
        dec            temp4
        brne                wait10ms2
        dec            temp3
        brne                wait10ms1
        ret

waitxms:  rcall                wait1ms
        dec            temp0
        brne                waitxms
        ret

wait150ms:
        ldi            temp0,$96
        rjmp          waitxms

wait750ms:
        ldi            temp1,$08
wait750ms1:
        ldi            temp2,$63
wait750ms2:
        rcall            wait1ms
        dec            temp2
        brne          wait750ms2
        dec            temp1
        brne          wait750ms1
        ret       

wait1s:    ldi            temp1,$0a
wait1s1:    ldi            temp2,$63
wait1s2:    rcall            wait1ms
        dec            temp2
        brne          wait1s2
        dec            temp1
        brne          wait1s1
        ret

---

mathe.asm

Code:

---

.def math1h    = r8
.def math1l    = r9
.def math2h    = R10
.def math2l    = r11
.def matherghh    = r12
.def mathergh    = r13
.def mathergl    = r14
.def mathergll    = r15
.def temp0        = r16
.def cnt        = r21

;**********SRAM
.equ    erg_k        =    $0060            ;erg_k wird bis zu 5 weiteren bytes genutzt sprich erg_k+5

                rcall                  load_math_word          ;hier werden die Zahlen aus dem SRAM geladen die +, -, x, / werden sollen
             
                rcall                  add_2_16bit                ;16bit + 16bit = 17bit nutzt 3Byte
                ;rcall                  sub_2_16bit                ;16bit - 16bit = <16bit
                ;rcall                  smul_2_16bit              ;16bit x 16bit = 32bit nutzt 4Byte für AVR's ohne mul-Befehl
                ;rcall                  hmul_2_16bit              ;16bit x 16bit = 32bit nutzt 4Byte für AVR's mit mul-Befehl
                ;rcall                  sdiv_2_16bit                ;16bit / 16bit = <16bit nur Software da kein DIV-Befehl vorhanden

              rcall                load_hex_dez          ;zu wandelnde Werte in in X und Z Pointer laden              z.B                      FF Hex = 255 Dez laden
              rcall                  hex_dez                      ;Werte stehen als Byte bereit ohne ASCII Convertierung  Wandlung  Byte      1  2  3  4  5
                                                                                                                                                                                        00 00 00 02 55 
*/

load_math_word:
        lds            temp0,$0070
        mov            math1h,temp0
        lds            temp0,$0071
        mov            math1l,temp0

        lds            temp0,$0072
        mov            math2h,temp0
        lds            temp0,$0073
        mov            math2l,temp0
        ret

;*********Addition 16bit + 16bit Vorzeichenlos
;math2h:math2l + math1h:math1l = matherhh:mathergh:mathergl:mathergll
;  r10:r11          r8:r9    =  r12  :  r13  :  r14   
add_2_16bit:
        rcall            clr_erg
        add            math2l,math1l        ;mathxl lowbytes adden
        adc            math2h,math1h        ;mathxlh highbytes adden + Carry
        brcc                add_2_16bit_2        ;wenn Carry gesetzt
        adc            mathergh,yl            ;dann ins 3te Ergbyte speichern quasi Überlauf
add_2_16bit_2:       
        mov            mathergl,math2h        ;in ergreg schubsen
        mov            mathergll,math2l
        ret

;*********Subtraktion 16bit - 16bit mit Vorzeichenanzeige
;math2h:math2l - math1h:math1l = matherhh:mathergh:mathergl:mathergll
;  r10:r11          r8:r9    =  r12  :  r13  :  r14  :  r15 
sub_2_16bit:
        ldi            yl,'+'
        sts            erg_k+5,yl            ;grundsätzlich erstmal plus
        rcall            clr_erg
        sub            math2l,math1l        ;mathxl lowbytes suben
        sbc            math2h,math1h        ;mathxlh highbytes suben - Carry
        brcc          sub_2_16bit_2        ;wenn Carry gesetzt
        sbc            mathergh,yl            ;dann ins 3te Ergbyte speichern quasi Unterlauf
        com            mathergh            ;da minus einerkomplement macht aus ff=00
        com            math2h                ;da minus einerkomplement macht aus ff=00
        neg            math2l                ;da minus zweierkomplement macht aus ff=01
        ldi            yl,'-'           
        sts            erg_k+5,yl            ;zeigt an, das dass ERG negativ ist
sub_2_16bit_2:       
        mov            mathergl,math2h        ;in ergreg schubsen
        mov            mathergll,math2l
        ret

;*********Multiplikation 16bit * 16bit Vorzeichenlos Software
;math1h:math1l * math2h:math2l = matherhh:mathergh:mathergl:mathergll
;    r8:r9          r10:r11    =  r12  :  r13  :  r14  :  r15
smul_2_16bit:
        rcall          clr_erg                ;löschen
        ldi            cnt,$10                ;16bit zum multiplzieren
smul_2_16bit2:
        lsl            mathergll            ;bei jedem Durchgang erg x 2
        rol            mathergl
        rol            mathergh
        rol            matherghh
       
        lsl            math1l                ;Multiplikant
        rol            math1h
        brcc          smul_2_16bit4        ;C = 0 ?
        rcall          smul_add_erg_16bit    ;wenn nicht dann addieren
smul_2_16bit4:
        dec            cnt                    ;bitcnt -1
        brne          smul_2_16bit2        ;sprung zu Label
        ret

smul_add_erg_16bit:
        add            mathergll,math2l    ;Multiplikator zum Zwischenergebniss
        adc            mathergl,math2h        ;dazuaddieren
        adc            mathergh,yl
        adc            matherghh,yl
        ret

;*********Multiplikation 16bit * 16bit Vorzeichenlos HARDWARE
;math2h:math2l * math1h:math1l = matherhh:mathergh:mathergl:mathergll
;  r10:r11          r8:r9    =  r12  :  r13  :  r14  :  r15
hmul_2_16bit:
        rcall          clr_erg                ;löschen
        mul            math1l,math2l        ;multiplizieren
        add            mathergll,r0        ;
        adc            mathergl,r1            ;Ergebnisse addieren
   
        mul            math1l,math2h        ;multiplizieren
        add            mathergl,r0
        adc            mathergh,r1            ;Ergebnisse addieren
                       
        mul            math1h,math2l        ;multiplizieren
        add            mathergl,r0
        adc            mathergh,r1            ;Ergebnisse addieren
        adc            matherghh,yh   
       
        mul            math1h,math2h        ;multiplizieren
        add            mathergh,r0
        adc            matherghh,r1        ;Ergebnisse addieren
   
        r et

;*********Division 16bit / 16bit Vorzeichenlos
;math1h:math1l / math2h:math2l = matherhh:mathergh:mathergl:mathergll
;    r8:r9          r10:r11    =  r12  :  r13  :  r14  :  r15
sdiv_2_16bit:
        rcall          clr_erg                ;Ergreg löschen
        cp            math2l,yl
        cpc            math2h,yh
        breq          sdiv_2_16bit4
        ldi            cnt,$10                ;bitcnt
        mov            yl,math1l            ;Divident in Y-Pointer schieben
        mov            yh,math1h            ;
sdiv_2_16bit1:
        lsl            yl                    ;pro Durchgang x2
        rol            yh                    ;links shiften
        rol            mathergll            ;Restbildung
        rol            mathergl            ;
        cp            mathergll,math2l    ;
        cpc            mathergl,math2h        ;
        brcs          sdiv_2_16bit3        ;Rest < DIVISOR
sdiv_2_16bit2:
        adiw          yh:yl,$01            ;Ergebniss +1
        sub            mathergll,math2l    ;
        sbc            mathergl,math2h        ;
sdiv_2_16bit3:
        dec            cnt
        brne          sdiv_2_16bit1
sdiv_2_16bit4:
        push          mathergl            ;wieder tauschen
        push          mathergll            ;das alles in den ErgRegs steht
        mov            mathergll,yl        ;
        mov            mathergl,yh            ;
        pop            yl                    ;hier steht der Rest diesen *10, dann wieder teilen = Kommastellen
        pop            yh                    ;oder Divident *10,100,1000 usw dann teilen Kommastellen vorgezogen
        ret

;original AtmelRoutine
div_2_16bit:
        rcall          clr_erg                ;ergreg löschen
        cp            math2l,yl
        cpc            math2h,yh            ;vergleich Divisor 
        breq          div_2_16bit6        ;= 0 sprung
        l di            cnt,$11   
        clc                               
div_2_16bit2:
        rol            math1l
        rol            math1h                ;DIVIDENT Teilender
        dec            cnt
        brne          div_2_16bit3       
        rjmp          div_2_16bit5
div_2_16bit3:
        rol            mathergll            ;RESTbildung
        rol            mathergl
        sub            mathergll,math2l    ;Erg minus DIVISOR Teiler
        sbc            mathergl,math2h        ;
        brcc          div_2_16bit4        ;
        add            mathergll,math2l    ;Erg + DIVISOR
        adc            mathergl,math2h        ;rückgängig machen
        clc                                ;Carry löschen
        rjmp          div_2_16bit2        ;sprung zu Label
div_2_16bit4:   
        sec                                ;Carry setzen
        rjmp          div_2_16bit2        ;sprung zu Label
div_2_16bit5:
        push          mathergl
        push                mathergll            ;Rest puschen
        mov            mathergll,math1l    ;alles so drehen
        mov            mathergl,math1h        ;das es in den ErgRegs steht
        pop            yl                    ;Rest popen
        pop            yh
div_2_16bit6:   
        ret

;***************Ergebnissregister löschen************
clr_erg:      clr            yl                    ;löschen
        clr            yh                   
        clr            matherghh
        clr            mathergh           
        clr            mathergl
        clr            mathergll
        ret
/*
;**********Wandlungsvorbereitung von HEX in DEZ******
load_hex_dez:
        mov            zh,matherghh        ;highhigh
        mov            zl,mathergh            ;highlow
        mov            xh,mathergl            ;high
        mov            xl,mathergll        ;low
        ret

hex_dez:  ;lds            zh                ;wenn ZH=ff>>LCD=42949967295
        ;lds            zl                ;wenn ZL=ff>>LCD=16777215      bei ZH=0
        ;lds            xh,                ;wenn XH=ff>>LCD=65535            bei ZH:ZL=0
        ;lds            xl,                ;wenn xl=ff>>LCD=255,            bei XH=0
        push          yl
        push          yh
        push          xl
        push          xh
        push                zl
        push            zh
        rcall            load_Ypontr            ;Speicherbereich laden         
            ldi                  cnt,$ff                ;
num_1000000000:                            ;Milliarden
        inc            cnt
                subi          xh, byte2(1000000000)
                sbci          zl, byte3(1000000000)
        sbci            zh,    byte4(1000000000)
                brcc          num_1000000000
                swap          cnt
        st            y,cnt   
            ldi              cnt,$0a
num_100000000:                            ;100Millionen
        dec            cnt                    ;+1
                subi            xh, byte2(-100000000)
                sbci          zl, byte3(-100000000)
        sbci          zh,    byte4(-100000000)
        brcs          num_100000000        ;ja
        ld            temp0,y
        or            cnt,temp0
        st            y+,cnt                ;fertig speichern
        ldi              cnt,$ff                ;
num_10000000:                            ;10Millionen
        inc              cnt
                subi          xl, byte1(10000000)
                sbci              xh, byte2(10000000)
        sbci          zl,    byte3(10000000)
                sbci            zh, 0
          brcc            num_10000000
              swap          cnt
            st            y,cnt     
          ldi              cnt,$0a
num_1000000:                            ;1Million
        dec            cnt                    ;+1
                subi          xl, byte1(-1000000)    ;
                sbci          xh, byte2(-1000000)    ;vergleich auf >1000000
                sbci          zl,    byte3(-1000000)
        brcs            num_1000000            ;ja
        ld            temp0,y
        or            cnt,temp0
        st            y+,cnt                ;fertig speichernn     
        ldi              cnt,$ff                ;
num_100000:                                ;100Tausend
        inc                  cnt
                subi          xl, byte1(100000)
                sbci              xh, byte2(100000)
        sbci          zl,    byte3(100000)
                brcc                  num_100000
              swap          cnt
        st            y,cnt   
            ldi              cnt,$0a
num_10000:                                ;10Tausend
        dec            cnt                    ;+1
                subi          xl, byte1(-10000)    ;
                sbci            xh, byte2(-10000)    ;vergleich auf >10000
                sbci                zl, byte3(-10000)
        brcs                  num_10000            ;ja
                ld            temp0,y
        or            cnt,temp0
        st            y+,cnt                ;fertig speichern     
        ldi              cnt,$ff               
num_1000:                                ;Tausender
        inc            cnt
                subi          xl, low(1000)
                sbci          xh, high(1000)
                brcc          num_1000
                swap        cnt
        st            y,cnt       
        ldi            cnt,$0a
num_100:  dec          cnt                    ;100
                subi          xl, low(-100)
                sbci          xh, high(-100)
                brcs          num_100
          ld            temp0,y
        or            cnt,temp0
        st            y+,cnt   
        ldi            cnt,$ff
num_10:    inc            cnt                    ;Zehner + Einer
                subi            xl, 10
                brcc            num_10
        subi          xl, -10
              swap        cnt
        or            cnt,xl
        st            y+,cnt
        pop            zh
        pop            zl
        pop            xh
        pop            xl
        pop            yh
        pop            yl
        ret

load_Ypontr:
        ldi            yh,high(erg_k)           
        ldi            yl,low(erg_k)        ;speicherpunkt laden
        ret
*/

---