Atmel Integer

5.2.1 Integer Arithmetik (8-Bit, 16-Bit, 32-Bit und 64-Bit) (in Arbeit)

5.2.1.1 8-Bit

5.2.1.2 16-Bit

5.2.1.3 32-Bit

5.2.1.4 64-Bit


Die Schreibweise erfolgt im binären, im dezimalen und im hexadezimalen System.

Binäre Zahlen werden durch ein % Zeichen gekennzeichnet.

Hexadezimale Zahlen werden durch ein $ Zeichen gekennzeichnet.

Dezimale Zahlen besitzen keine Kennung.

165 = $A5 = %10100101

Wird der Definitionsbereich einer Zahl über- oder unterschritten ist das Carry-Flag gesetzt.

5.2.1.1 8-Bit

Byte

7 6 5 4 3 2 1 0

Bit 0 aus einem Byte wird auch als LSB (Least Significant Bit) bezeichnet. Das Bit mit der kleinsten Wertigkeit. Bit 7 aus einem Byte wird auch als MSB (Most Significant Bit) bezeichnet. Das Bit mit der größten Wertigkeit. Die Zählweise ist von rechts nach links und von 0 bis 7. Daraus läßt sich gleich die Wertigkeit der einzelnen Bits berechnen:

Bit

Exponent

Wertigkeit

0

20

1

1

21

2

2

22

4

3

23

8

4

24

16

5

25

32

6

26

64

7

27

128

Download der 8-Bit Funktionen

5.2.1.1.1 Unsigned

Der Wertebereich besteht nur aus positiven Zahlen von 0 bis 255.

Hex Dez
$00 0
... ...
$7F 127
$80 128
... ...
$FF 255

5.2.1.1.1.1 Umwandlung

5.2.1.1.1.1.1 Integer nach String

  1. ;****************************************************************
  2. ; Byte (8 Bit) in HEX-String umwandeln
  3. ;  Input: X   = Pointer auf Stringanfang im SRAM
  4. ;         r16 = Byte
  5. ; Output: X   = Zeigt auf Stringende
  6. ;         r16 = 0
  7. ; Return: -
  8. ; Modify: -
  9. ;
  10. H1ToStr:   push  r16
  11.            swap  r16
  12.            rcall NibToChr
  13.            st    X+,r16
  14.            pop   r16
  15.            rcall NibToChr
  16.            st    X+,r16
  17.            ldi   r16,0x00
  18.            st    X,r16
  19.            ret

  1. ;****************************************************************
  2. ; Byte (8 Bit) in DEZ-String umwandeln
  3. ;  Input: X   = Pointer auf Stringanfang im SRAM
  4. ;         r16 = Byte
  5. ; Output: X   = Zeigt auf Stringende
  6. ;         r16 = 0
  7. ; Return: -
  8. ; Modify: -
  9. ;
  10. B1ToStr:   push  r17
  11.            mov   r17,r16
  12.            clr   r16        ;100er Zähler löschen
  13. B1ToStr1:  cpi   r17,100    ;ist Byte < 100 ?
  14.            brcs  B1ToStr2   ;ja
  15.            sbci  r17,100    ;nein
  16.            inc   r16        ;100er Zähler inkrementieren
  17.            rjmp  B1ToStr1   ;Wiederholen bis Byte < 100 ist
  18. B1ToStr2:  rcall NibToChr   ;100er in ASCII umwandeln
  19.            st    X+,r16     ;100er in den String schreiben
  20.            clr   r16        ;10er Zähler löschen
  21. B1ToStr3:  cpi   r17,10     ;ist Byte < 10 ?
  22.            brcs  B1ToStr4   ;ja
  23.            sbci  r17,10     ;nein
  24.            inc   r16        ;10er Zähler inkrementieren
  25.            rjmp  B1ToStr3   ;Widerholen bis Byte < 10 ist
  26. B1ToStr4:  rcall NibToChr   ;10er in ASCII umwandeln
  27.            st    X+,r16     ;10er in den String schreiben
  28.            mov   r16,r17    ;1er bleiben übrig
  29.            rcall NibToChr   ;1er in ASCII umwandeln
  30.            st    X+,r16     ;1er in den String schreiben
  31.            clr   r16
  32.            st    X,r16      ;String mit 0 abschliessen
  33.            pop   r17
  34.            ret

Der String enthält führende Nullen, $20 wird zu '032'.

5.2.1.1.1.1.2 String nach Integer

  1. ;****************************************************************
  2. ; 1 Byte (8 Bit) von HEX-String in Byte umwandeln
  3. ;  Input: X   = Pointer auf Stringanfang im SRAM
  4. ; Output: X   = Zeigt auf Stringende
  5. ;         r16 = Byte
  6. ; Return: -
  7. ; Modify: -
  8. ;
  9. StrToH1:   push  r17
  10.            ld    r16,X+
  11.            rcall ChrToNib
  12.            swap  r16
  13.            mov   r17,r16
  14.            ld    r16,X+
  15.            rcall ChrToNib
  16.            or    r16,r17
  17.            pop   r17
  18.            ret

5.2.1.1.1.1.3 8 nach 16 Bit

  1. ;****************************************************************
  2. ; 8 nach 16 Bit Konvertierung
  3. ;  Input: r16 = Byte
  4. ; Output: r16 = r16
  5. ;         r17 = 0
  6. ; Return: -
  7. ; Modify: -
  8. ;
  9. B1ToB2:    clr   r17
  10.            ret

5.2.1.1.1.2 Funktionen

5.2.1.1.1.2.1 ADD

Standard Befehl des ATmega

Daten für Atmega8:

  1. ;****************************************************************
  2. ; Addition zweier Zahlen
  3. ;  Input: r16 = Byte
  4. ;         r17 = Byte
  5. ; Output: r16 = r16 + r17
  6. ; Return: C   = 0 = kein Überlauf
  7. ;         C   = 1 = Das Ergebnis ist > 255
  8. ; Modify: -
  9. ;
  10. uadd1:     add  r16,r17
  11.            ret

5.2.1.1.1.2.2 SUB

Standard Befehl des ATmega

Daten für Atmega8:

  1. ;****************************************************************
  2. ; Subtraction zweier Zahlen
  3. ;  Input: r16 = Byte
  4. ;         r17 = Byte
  5. ; Output: r16 = r16 - r17
  6. ; Return: C   = 0 = kein Ünterlauf
  7. ;         C   = 1 = Das Ergebnis ist < 0
  8. ; Modify: -
  9. ;
  10. usub1:     sub   r16,r17
  11.            ret

5.2.1.1.1.2.3 MUL

Standard Befehl des ATmega

Daten für Atmega8:

  1. ;****************************************************************
  2. ; Multiplikation zweier Zahlen
  3. ;  Input: r16 = Multiplikant
  4. ;         r17 = Multiplikator
  5. ; Output: r16 = Product Low
  6. ;         r17 = Product High
  7. ; Return: C   = 0 = Das Ergebnis ist 1 Byte
  8. ;         C   = 1 = Das Ergebnis ist > 1 Byte
  9. ; Modify: -
  10. ;
  11. umul1:     push  r0
  12.            push  r1
  13.            mul   r16,r17
  14.            mov   r16,r0
  15.            mov   r17,r1
  16.            clc
  17.            tst   r17
  18.            breq  umul1a
  19.            sec
  20. umul1a:    pop   r1
  21.            pop   r0
  22.            ret

5.2.1.1.1.2.4 DIV

Daten für Atmega8:

  1. ;****************************************************************
  2. ; Vorzeichenlose Division 8Bit / 8Bit
  3. ;  Input: r16 = Divident
  4. ;         r17 = Divisor
  5. ; Output: r16 = Ergebnis
  6. ;         r17 = Rest
  7. ; Return: c   = 0 = Alles klar
  8. ;         c   = 1 = Divident < Divisor
  9. ; Modify: -
  10. ;
  11. ; Wenn Fehler dann keine Änderung von Divident und Divisor
  12. ;
  13. udiv1:     cp    r16,r17   ;Divident muß > Divisor sein
  14.            brcs  udiv1d
  15.            tst   r17       ;Divisor darf nicht 0 sein
  16.            breq  udiv1d
  17.            push  r18
  18.            push  r19
  19.            sub   r18,r18   ;clear remainder and carry
  20.            ldi   r19,9     ;init loop counter
  21. udiv1a:    rol   r16       ;shift left dividend
  22.            dec   r19       ;decrement counter
  23.            breq  udiv1c    ;if done
  24.            rol   r18       ;shift dividend into remainder
  25.            sub   r18,r17   ;remainder = remainder - divisor
  26.            brcc  udiv1b    ;if result negative
  27.            add   r18,r17   ; restore remainder
  28.            clc             ; clear c to be shifted into result
  29.            rjmp  udiv1a    ;else
  30. udiv1b:    sec             ; set carry to be shifted into result
  31.            rjmp  udiv1a
  32. udiv1c:    mov   r17,r18
  33.            pop   r19
  34.            pop   r18
  35.            clc
  36. udiv1d:    ret

5.2.1.1.2 Signed

Der Wertebereich besteht aus negativen und positiven Zahlen von -128 bis 127.

Hex Dez
$00 0
... ...
$7F 127
$80 -128
... ...
$FF -1

5.2.1.1.2.1 Umwandlung

5.2.1.1.2.1.1 Integer nach String

  1. ;****************************************************************
  2. ; Byte (8 Bit) in DEZ-String umwandeln
  3. ;  Input: X   = Pointer auf Stringanfang im SRAM
  4. ;         r16 = Byte
  5. ; Output: X   = Zeigt auf Stringende
  6. ;         r16 = 0
  7. ; Return: -
  8. ; Modify: -
  9. ;
  10. B1SToStr:  tst   r16       ;Byte testen
  11.            brpl  B1SToS1   ;ist positiv, also Ausgabe
  12.            neg   r16       ;in positive Zahl wandeln
  13.            brvc  B1SToS2   ;Byte ist < 128
  14.            ldi   r16,128   ;Byte war -128
  15. B1SToS2:   push  r16
  16.            ldi   r16,'-'   ;Vorzeichen ausgeben
  17.            st    X+,r16
  18.            pop   r16
  19. B1SToS1:   rcall B1SToStr  ;Byte in ASCII umwandeln
  20.            ret

Der String enthält führende Nullen, $20 wird zu '032'. Das Vorzeichen wird nur ausgegeben, wenn es negativ ist.

5.2.1.1.2.1.2 String nach Integer

  1. ;****************************************************************
  2. ; 1 Byte (8 Bit) von HEX-String in Byte umwandeln
  3. ;  Input: X   = Pointer auf Stringanfang im SRAM
  4. ; Output: X   = Zeigt auf Stringende
  5. ;         r16 = Byte
  6. ; Return: c   = 0 = Alles klar
  7. ;         c   = 1 = Byte ist < -128 oder > 127
  8. ; Modify: -
  9. ;
  10. StrToSH1:  push  r17
  11.            clr   r17        ;Vorzeichen ist positiv
  12.            ld    r16,X
  13.            cpi   r16,'-'
  14.            brne  StrToSH1a  ;ist tatsächlich positiv
  15.            neg   r17        ;negatives Vorzeichen merken
  16.            adiw  XH:XL,1    ;Vorzeichen aus String entfernen
  17. StrToSH1a: rcall StrToH1    ;String in Byte umwandeln
  18.            clc
  19.            tst   r17        ;Vorzeichen testen
  20.            breq  StrToSH1b  ;Zahl war positiv
  21.            cpi   r16,129    ;Gültige Zahl?
  22.            brlo  StrToSH1c  ;alles klar
  23.            sec              ;Byte ist < -128
  24.            rjmp  StrToSH1c
  25. StrToSH1b: cpi   r16,128    ;Gültige Zahl?
  26.            brlo  StrToSH1c  ;alles klar
  27.            sec              ;Byte ist > 127
  28. StrToSH1c: pop   r17
  29.            ret

5.2.1.1.2.1.3 8 nach 16 Bit

Daten für Atmega8:

  1. ;****************************************************************
  2. ; 8 nach 16 Bit Konvertierung
  3. ;  Input: r16 = Byte
  4. ; Output: r16 = r16
  5. ;         r17 = $00 wenn positiv, $FF wenn negativ
  6. ; Return: -
  7. ; Modify: -
  8. ;
  9. B1ToB2:    clr    r17
  10.            tst    r16
  11.            brpl   B1ToB2a
  12.            subi   r17,1
  13. B1ToB2a:   ret

5.2.1.1.2.2 Funktionen

5.2.1.1.2.2.1 ADD

Standard Befehl des ATmega

Daten für Atmega8:

  1. ;****************************************************************
  2. ; Addition zweier Zahlen
  3. ;  Input: r16 = Byte
  4. ;         r17 = Byte
  5. ; Output: r16 = r16 + r17
  6. ; Return: C   = 0 = alle klar
  7. ;         C   = 1 = Das Ergebnis ist > 127 oder < -128
  8. ; Modify: -
  9. ;
  10. sadd1:     add   r16,r17
  11.            clc
  12.            brvs  sadd1a
  13.            sec
  14. sadd1a:    ret

5.2.1.1.2.2.2 SUB

Standard Befehl des ATmega

Daten für Atmega8:

  1. ;****************************************************************
  2. ; Subtraction zweier Zahlen
  3. ;  Input: r16 = Byte
  4. ;         r17 = Byte
  5. ; Output: r16 = r16 - r17
  6. ; Return: C   = 0 = alles klar
  7. ;         C   = 1 = Das Ergebnis ist < -128
  8. ; Modify: -
  9. ;
  10. ssub1:     sub   r16,r17
  11.            clc
  12.            brvs  ssub1a
  13.            sec
  14. ssub1a:    ret

5.2.1.1.2.2.3 MUL

Standard Befehl des ATmega

Daten für Atmega8:

  1. ;****************************************************************
  2. ; Multiplikation zweier Zahlen
  3. ;  Input: r16 = Multiplikant
  4. ;         r17 = Multiplikator
  5. ; Output: r16 = Product Low
  6. ;         r17 = Product High
  7. ; Return: C   = 0 = Das Ergebnis ist 1 Byte
  8. ;         C   = 1 = Das Ergebnis ist 2 Byte
  9. ; Modify: -
  10. ;
  11. smul1:     push  r0
  12.            push  r1
  13.            muls  r16,r17
  14.            mov   r16,r0
  15.            mov   r17,r1
  16.            clc
  17.            tst   r17
  18.            breq  smul1a
  19.            cpi   r17,$FF
  20.            breq  smul1a
  21.            sec
  22. smul1a:    pop   r1
  23.            pop   r0
  24.            ret

5.2.1.1.2.2.4 DIV

Daten für Atmega8:

  1. ;****************************************************************
  2. ; Vorzeichbehaftete Division 8Bit / 8Bit
  3. ;  Input: r16 = Divident
  4. ;         r17 = Divisor
  5. ; Output: r16 = Ergebnis
  6. ;         r17 = Rest
  7. ; Return: c   = 0 = Alles klar
  8. ;         c   = 1 = Abs(Divident) < Abs(Divisor)
  9. ; Modify: -
  10. ;
  11. ; Wenn Fehler dann keine Änderung von Divident und Divisor
  12. ;
  13. sdiv1:     push  r18
  14.            clr   r18
  15.            tst   r16         ;wenn Divident negativ
  16.            brpl  sdiv1a
  17.            sbr   r18,1       ;dann Vorzeichen merken
  18.            neg   r16         ;und positiv machen
  19. sdiv1a:    tst   r17         ;wenn Divisor negativ
  20.            brpl  sdiv1b
  21.            sbr   r18,2       ;dann Vorzeichen merken
  22.            neg   r17         ;und positiv machen
  23. sdiv1b:    rcall udiv1       ;Vorzeichenlose Division
  24.            cpi   r18,0       ;waren beide Vorzeichen positiv ?
  25.            breq  sdiv1c      ;ja
  26.            cpi   r18,3       ;waren beide Vorzeichen negativ ?
  27.            breq  sdiv1c      ;ja
  28.            neg   r16         ;Ergebnis wird negativ, wenn
  29.            neg   r17         ;ein Vorzeichen negativ war
  30. sdiv1c:    pop   r18
  31.            ret

5.2.1.1.2.2.5 ABS

Daten für Atmega8:

  1. ;****************************************************************
  2. ; Absolutbildung
  3. ;  Input: r16 = Byte
  4. ; Output: r16 = Abs(r16)
  5. ; Return: C   = 0 = alle klar
  6. ;         C   = 1 = Das Ergebnis ist > 127
  7. ; Modify: -
  8. ;
  9. sabs1:     clc
  10.            tst   r16
  11.            brpl  sabs1a
  12.            neg   r16
  13.            brvc  sabs1a
  14.            sec
  15. sabs1a:    ret

5.2.1.2 16-Bit

Word

7 6 5 4 3 2 1 0 15 14 13 12 11 10 9 8

Byte 0

Byte 1

7 6 5 4 3 2 1 0 7 6 5 4 3 2 1 0

Bit 0 aus einem Byte wird auch als LSB (Least Significant Bit) bezeichnet. Das Bit mit der kleinsten Wertigkeit. Bit 15 aus einem Word wird auch als MSB (Most Significant Bit) bezeichnet. Das Bit mit der größten Wertigkeit. Die Zählweise der Bytes ist von links nach rechts und von 0 bis 15. Daraus läßt sich gleich die Wertigkeit der einzelnen Bits berechnen:

Bit

Exponent

Wertigkeit

0

20

1

1

21

2

2

22

4

3

23

8

4

24

16

5

25

32

6

26

64

7

27

128

8

28

256

9

29

512

10

210

1024

11

211

2048

12

212

4096

13

213

8192

14

214

16384

15

215

32768

5.2.1.2.1 Unsigned

Der Wertebereich besteht nur aus positiven Zahlen von 0 bis 65535.

Hex Dez
$0000 0
... ...
$7FFF 32767
$8000 32768
... ...
$FFFF 65535

5.2.1.2.1.1 Umwandlung

5.2.1.2.1.1.1 Integer nach String

  1. ;****************************************************************
  2. ; 2 Bytes (16 Bit) in HEX-String umwandeln
  3. ;  Input: X   = Pointer auf Stringanfang im SRAM
  4. ;         r16 = Low Byte
  5. ;         r17 = High Byte
  6. ; Output: X   = Zeigt auf Stringende
  7. ;         r16 = 0
  8. ;         r17 = 0
  9. ; Return: -
  10. ; Modify: -
  11. ;
  12. H2ToStr:   push  r16
  13.            push  r17
  14.            mov   r16,r17
  15.            swap  r16
  16.            rcall NibToChr
  17.            st    X+,r16
  18.            pop   r16
  19.            rcall NibToChr
  20.            st    X+,r16
  21.            pop   r16
  22.            push  r16
  23.            swap  r16
  24.            rcall NibToChr
  25.            st    X+,r16
  26.            pop   r16
  27.            rcall NibToChr
  28.            st    X+,r16
  29.            clr   r16
  30.            clr   r17
  31.            st    X,r16
  32.            ret

  1. ;****************************************************************
  2. ; 2 Bytes (16 Bit) in DEZ-String umwandeln
  3. ;  Input: X   = Pointer auf Stringanfang im SRAM
  4. ;         r16 = Low Byte
  5. ;         r17 = High Byte
  6. ; Output: X   = Zeigt auf Stringende
  7. ;         r16 = 0
  8. ;         r17 = 0
  9. ; Return: -
  10. ; Modify: -
  11. ;
  12. B2ToStrX:  cp    r18,r20
  13.            cpc   r17,r19
  14.            brcs  B2ToStrY
  15.            sbc   r18,r20
  16.            sbc   r17,r19
  17.            inc   r16
  18.            rjmp  B2ToStrX
  19. B2ToStrY:  rcall NibToChr
  20.            ret
  21. B2ToStr:   push  r18
  22.            push  r19
  23.            push  r20
  24.            mov   r18,r16
  25.            clr   r16            ;10000er Zähler löschen
  26.            ldi   r19,high(10000)
  27.            ldi   r20,low(10000)
  28.            rcall B2ToStrX
  29.            st    X+,r16         ;10000er in den String schreiben
  30.            clr   r16            ;1000er Zähler löschen
  31.            ldi   r19,high(1000)
  32.            ldi   r20,low(1000)
  33.            rcall B2ToStrX
  34.            st    X+,r16         ;1000er in den String schreiben
  35.            clr   r16            ;100er Zähler löschen
  36.            ldi   r19,high(100)
  37.            ldi   r20,low(100)
  38.            rcall B2ToStrX
  39.            st    X+,r16         ;100er in den String schreiben
  40.            clr   r16            ;10er Zähler löschen
  41.            ldi   r19,high(10)
  42.            ldi   r20,low(10)
  43.            rcall B2ToStrX
  44.            st    X+,r16         ;10er in den String schreiben
  45.            mov   r16,r18        ;1er bleiben übrig
  46.            rcall NibToChr       ;1er in ASCII umwandeln
  47.            st    X+,r16         ;1er in den String schreiben
  48.            clr   r16
  49.            clr   r17
  50.            st    X,r16          ;String mit 0 abschliessen
  51.            pop   r20
  52.            pop   r19
  53.            pop   r18
  54.            ret

5.2.1.2.1.1.2 String nach Integer

5.2.1.2.1.1.3 16 nach 32 Bit

  1. ;****************************************************************
  2. ; 16 nach 32 Bit Konvertierung
  3. ;  Input: r16 = Low Byte
  4. ;         r17 = High Byte
  5. ; Output: r16 = r16
  6. ;         r17 = r17
  7. ;         r18 = 0
  8. ;         r19 = 0
  9. ; Return: -
  10. ; Modify: -
  11. ;
  12. B2ToB4:    clr r18
  13.            clr r19
  14.            ret

5.2.1.2.1.2 Funktionen

5.2.1.2.1.2.1 ADD

Daten für Atmega8:

  1. ;****************************************************************
  2. ; Addition zweier Zahlen
  3. ;  Input: r16,r17 = Low,High Byte 1
  4. ;         r18,r18 = Low,High Byte 2
  5. ; Output: r16,r17 = r16,r17 + r18,r19
  6. ; Return: C       = 0 = kein Überlauf
  7. ;         C       = 1 = Das Ergebnis ist > 255
  8. ; Modify: -
  9. ;
  10. uadd2:     add   r16,r18
  11.            adc   r17,r19
  12.            ret

5.2.1.2.1.2.2 SUB

Daten für Atmega8:

  1. ;****************************************************************
  2. ; Addition zweier Zahlen
  3. ;  Input: r16,r17 = Low,High Byte 1
  4. ;         r18,r18 = Low,High Byte 2
  5. ; Output: r16,r17 = r16,r17 - r18,r19
  6. ; Return: C       = 0 = kein Unterlauf
  7. ;         C       = 1 = Das Ergebnis ist < 0
  8. ; Modify: -
  9. ;
  10. usub2:     sub   r16,r18
  11.            sbc   r17,r19
  12.            ret

5.2.1.2.1.2.3 MUL

Daten für Atmega8:

  1. ;****************************************************************
  2. ; Multiplikation zweier Zahlen
  3. ;  Input: r16,r17 = Low,High Multiplikant
  4. ;         r18,r19 = Low,High Multiplikator
  5. ; Output: r16,r17 = Low,High Product Low
  6. ;         r18,r19 = Low,High Product High
  7. ; Return: C       = 0 = Das Ergebnis ist 2 Byte
  8. ;         C       = 1 = Das Ergebnis ist > 2 Byte
  9. ; Modify: -
  10. ;                               r5  r4  r3  r2
  11. ; Beispiel: r17 r16 * r19 r18 = r19 r18 r17 r16
  12. ;           12  34  * 56  78  = 06  26  00  60
  13. ;           ----------------------------------
  14. ;           12      * 56      = 06  0C
  15. ;           12      *     78  =     08  70
  16. ;               34  * 56      =     11  78
  17. ;               34  *     78  =         18  60
  18. ;                               --------------
  19. ;                               06  26  00  60
  20. umul2:     push  r0
  21.            push  r1
  22.            push  r2
  23.            push  r3
  24.            push  r4
  25.            push  r5
  26.            mul   r17,r19
  27.            mov   r4,r0
  28.            mov   r5,r1
  29.            mul   r16,r18
  30.            mov   r2,r0
  31.            mov   r3,r1
  32.            mul   r16,r19
  33.            add   r3,r0
  34.            adc   r4,r1
  35.            mul   r17,r18
  36.            add   r3,r0
  37.            adc   r4,r1
  38.            mov   r16,r2
  39.            mov   r17,r3
  40.            mov   r18,r4
  41.            mov   r19,r5
  42.            clc
  43.            tst   r19
  44.            brne  umul2b       ;Fehler
  45.            tst   r18
  46.            breq  umul2a       ;kein Fehler
  47. umul2b:    sec
  48. umul2a:    pop   r5
  49.            pop   r4
  50.            pop   r3
  51.            pop   r2
  52.            pop   r1
  53.            pop   r0
  54.            ret

5.2.1.2.1.2.4 DIV

Daten für Atmega8:

  1. ;****************************************************************
  2. ; Vorzeichenlose Division 16Bit / 16Bit
  3. ;  Input: r16 = Divident Low Byte
  4. ;         r17 = Divident High Byte
  5. ;         r18 = Divisor Low Byte
  6. ;         r19 = Divisor High Byte
  7. ; Output: r16 = Ergebnis Low Byte
  8. ;         r17 = Ergebnis High Byte
  9. ;         r18 = Rest Low Byte
  10. ;         r19 = Rest High Byte
  11. ; Return: c = 0 = Alles klar
  12. ;         c = 1 = Fehler (Divident < Divisor) oder (Divisor = 0)
  13. ; Modify: -
  14. ;
  15. ; Wenn Fehler dann keine Änderung von Divident und Divisor
  16. ;
  17. udiv2:     cp    r17,r19   ;Divident muß > als Divisor sein
  18.            brcs  udiv2f
  19.            brne  udiv2a
  20.            cp    r16,r18
  21.            brcs  udiv2f
  22. udiv2a:    tst   r18       ;Divisor darf nicht 0 sein
  23.            brne  udiv2b
  24.            tst   r19
  25.            brne  udiv2b
  26.            sec
  27.            brcs  udiv2f
  28. udiv2b:    push  r20
  29.            push  r21
  30.            push  r22
  31.            clr   r21       ;clear remainder Low byte
  32.            sub   r22,r22   ;clear remainder High byte and carry
  33.            ldi   r20,17    ;init loop counter
  34. udiv2c:    rol   r16       ;shift left dividend
  35.            rol   r17
  36.            dec   r20       ;decrement counter
  37.            breq  udiv2e    ;if done
  38.            rol   r21       ;shift dividend into remainder
  39.            rol   r22
  40.            sub   r21,r18   ;remainder = remainder - divisor
  41.            sbc   r22,r19   ;
  42.            brcc  udiv2d    ;if result negative
  43.            add   r21,r18   ;  restore remainder
  44.            adc   r22,r19
  45.            clc             ;  clear c to be shifted into result
  46.            rjmp  udiv2c    ;else
  47. udiv2d:    sec             ;   set c to be shifted into result
  48.            rjmp  udiv2c
  49. udiv2e:    mov   r18,r21   ;Ergebnis umschichten
  50.            mov   r19,r22
  51.            pop   r22
  52.            pop   r21
  53.            pop   r20
  54. udiv2f:    ret

5.2.1.2.2 Signed

Der Wertebereich besteht nur aus Zahlen von -32768 bis 32767.

Hex Dez
$0000 0
... ...
$7FFF 32767
$8000 -32768
... ...
$FFFF -1

5.2.1.2.2.1 Umwandlung

5.2.1.2.2.1.1 Integer nach String

5.2.1.2.2.1.2 String nach Integer

5.2.1.2.2.1.3 8 nach 16 Bit

5.2.1.2.2.2 Funktionen

5.2.1.2.2.2.1 ADD

5.2.1.2.2.2.2 SUB

5.2.1.2.2.2.3 MUL

5.2.1.2.2.2.4 DIV

5.2.1.2.2.2.5 ABS

5.2.1.3 32-Bit

Doubleword

Byte 0

Byte 1

Byte 2

Byte 3

7 6 5 4 3 2 1 0 7 6 5 4 3 2 1 0 7 6 5 4 3 2 1 0 7 6 5 4 3 2 1 0

Bit 0 aus einem Byte wird auch als LSB (Least Significant Bit) bezeichnet. Das Bit mit der kleinsten Wertigkeit. Bit 31 aus einem Word wird auch als MSB (Most Significant Bit) bezeichnet. Das Bit mit der größten Wertigkeit. Die Zählweise ist von links nach rechts und von 0 bis 31. Daraus läßt sich gleich die Wertigkeit der einzelnen Bits berechnen:

Bit

Exponent

Wertigkeit

Bit

Exponent

Wertigkeit

0

20

1

16

216

65536

1

21

2

17

217

131072

2

22

4

18

218

262144

3

23

8

19

219

524288

4

24

16

20

220

1048576

5

25

32

21

221

2097152

6

26

64

22

222

4194304

7

27

128

23

223

8388608

8

28

256

24

224

16777216

9

29

512

25

225

33554432

10

210

1024

26

226

67108864

11

211

2048

27

227

134217728

12

212

4096

28

228

268435456

13

213

8192

29

229

536870912

14

214

16384

30

230

1073741824

15

215

32768

31

231

2147483648

5.2.1.3.1 Unsigned

Der Wertebereich besteht nur aus positiven Zahlen von 0 bis 4294967295.

Hex Dez
$00000000 0
... ...
$7FFFFFFF 2147483647
$80000000 2147483648
... ...
$FFFFFFFF 4294967295

5.2.1.3.1.1 Umwandlung

5.2.1.3.1.1.1 Integer nach String

  1. ;****************************************************************
  2. ; 4 Bytes (32 Bit) in HEX-String umwandeln
  3. ;  Input: X   = Pointer auf Stringanfang im SRAM
  4. ;         r16 = Low Byte
  5. ;         r17 =
  6. ;         r18 =
  7. ;         r19 = High Byte
  8. ; Output: X   = Zeigt auf Stringende
  9. ;         r16 = 0
  10. ;         r17 = 0
  11. ;         r18 = 0
  12. ;         r19 = 0
  13. ; Return: -
  14. ; Modify: -
  15. ;
  16. H4ToStr:   push  r16
  17.            push  r19
  18.            mov   r16,r19
  19.            swap  r16
  20.            rcall NibToChr
  21.            st    X+,r16
  22.            pop   r16
  23.            rcall NibToChr
  24.            st    X+,r16
  25.            push  r18
  26.            mov   r16,r18
  27.            swap  r16
  28.            rcall NibToChr
  29.            st    X+,r16
  30.            pop   r16
  31.            rcall NibToChr
  32.            st    X+,r16
  33.            push  r17
  34.            mov   r16,r17
  35.            swap  r16
  36.            rcall NibToChr
  37.            st    X+,r16
  38.            pop   r16
  39.            rcall NibToChr
  40.            st    X+,r16
  41.            pop   r16
  42.            push  r16
  43.            swap  r16
  44.            rcall NibToChr
  45.            st    X+,r16
  46.            pop   r16
  47.            rcall NibToChr
  48.            st    X+,r16
  49.            clr   r16
  50.            clr   r17
  51.            clr   r18
  52.            clr   r19
  53.            st    X,r16
  54.            ret

  1. ;****************************************************************
  2. ; 4 Bytes (32 Bit) in DEZ-String umwandeln
  3. ;  Input: X   = Pointer auf Stringanfang im SRAM
  4. ;         r16 = Low Byte
  5. ;         r17
  6. ;         r18
  7. ;         r19 = High Byte
  8. ; Output: X   = Zeigt auf Stringende
  9. ;         r16 = 0
  10. ;         r17 = 0
  11. ;         r18 = 0
  12. ;         r19 = 0
  13. ; Return: -
  14. ; Modify: -
  15. ;
  16. B4ToStrX:  cp    r16,r20
  17.            cpc   r17,r21
  18.            cpc   r18,r22
  19.            cpc   r19,r23
  20.            brcs  B4ToStrY
  21.            sbc   r16,r20
  22.            sbc   r17,r21
  23.            sbc   r18,r22
  24.            sbc   r19,r23
  25.            inc   r24
  26.            rjmp  B4ToStrX
  27. B4ToStrY:  push  r16
  28.            mov   r16,r24
  29.            rcall NibToChr
  30.            mov   r24,r16
  31.            pop   r16
  32.            ret
  33. B4ToStr:   push  r20
  34.            push  r21
  35.            push  r22
  36.            push  r23
  37.            push  r24
  38.            clr   r24        ;Zähler löschen
  39.            ldi   r20,0x00   ;Lade 1.000.000.000
  40.            ldi   r21,0xCA
  41.            ldi   r22,0x9A
  42.            ldi   r23,0x3B
  43.            rcall B4ToStrX
  44.            st    X+,r24     ;Zähler in String schreiben
  45.            clr   r24        ;Zähler löschen
  46.            ldi   r20,0x00   ;Lade 100.000.000
  47.            ldi   r21,0xE1
  48.            ldi   r22,0xF5
  49.            ldi   r23,0x05
  50.            rcall B4ToStrX
  51.            st    X+,r24     ;Zähler in String schreiben
  52.            clr   r24        ;Zähler löschen
  53.            ldi   r20,0x80   ;Lade 10.000.000
  54.            ldi   r21,0x96
  55.            ldi   r22,0x98
  56.            ldi   r23,0x00
  57.            rcall B4ToStrX
  58.            st    X+,r24     ;Zähler in String schreiben
  59.            clr   r24        ;Zähler löschen
  60.            ldi   r20,0x40   ;Lade 1.000.000
  61.            ldi   r21,0x42
  62.            ldi   r22,0x0F
  63.            ldi   r23,0x00
  64.            rcall B4ToStrX
  65.            st    X+,r24     ;Zähler in String schreiben
  66.            clr   r24        ;Zähler löschen
  67.            ldi   r20,0xA0   ;Lade 100.000
  68.            ldi   r21,0x86
  69.            ldi   r22,0x01
  70.            ldi   r23,0x00
  71.            rcall B4ToStrX
  72.            st    X+,r24     ;Zähler in String schreiben
  73.            clr   r24        ;Zähler löschen
  74.            ldi   r20,0x10   ;Lade 10.000
  75.            ldi   r21,0x27
  76.            ldi   r22,0x00
  77.            ldi   r23,0x00
  78.            rcall B4ToStrX
  79.            st    X+,r24     ;Zähler in String schreiben
  80.            clr   r24        ;Zähler löschen
  81.            ldi   r20,0xE8   ;Lade 1.000
  82.            ldi   r21,0x03
  83.            ldi   r22,0x00
  84.            ldi   r23,0x00
  85.            rcall B4ToStrX
  86.            st    X+,r24     ;Zähler in String schreiben
  87.            clr   r24        ;Zähler löschen
  88.            ldi   r20,0x64   ;Lade 100
  89.            ldi   r21,0x00
  90.            ldi   r22,0x00
  91.            ldi   r23,0x00
  92.            rcall B4ToStrX
  93.            st    X+,r24     ;Zähler in String schreiben
  94.            clr   r24        ;Zähler löschen
  95.            ldi   r20,0x0A   ;Lade 10
  96.            ldi   r21,0x00
  97.            ldi   r22,0x00
  98.            ldi   r23,0x00
  99.            rcall B4ToStrX
  100.            st    X+,r24     ;Zähler in String schreiben
  101.            rcall NibToChr   ;1er in ASCII umwandeln
  102.            st    X+,r16     ;1er in den String schreiben
  103.            clr   r16
  104.            clr   r17
  105.            clr   r18
  106.            clr   r19
  107.            st    X,r16      ;String mit 0 abschliessen
  108.            pop   r24
  109.            pop   r23
  110.            pop   r22
  111.            pop   r21
  112.            pop   r20
  113.            ret

5.2.1.3.1.1.2 String nach Integer

5.2.1.3.1.1.3 32 nach 64 Bit

  1. ;****************************************************************
  2. ; 16 nach 32 Bit Konvertierung
  3. ;  Input: r16 = Low Byte
  4. ;         r17 = Byte
  5. ;         r18 = Byte
  6. ;         r19 = High Byte
  7. ; Output: r16 = r16
  8. ;         r17 = r17
  9. ;         r18 = r18
  10. ;         r19 = r19
  11. ;         r20 = 0
  12. ;         r21 = 0
  13. ;         r22 = 0
  14. ;         r23 = 0
  15. ; Return: -
  16. ; Modify: -
  17. ;
  18. B4ToB8:    clr r20
  19.            clr r21
  20.            clr r22
  21.            clr r23
  22.            ret

5.2.1.3.1.2 Funktionen

5.2.1.3.1.2.1 ADD

5.2.1.3.1.2.2 SUB

5.2.1.3.1.2.3 MUL

  1. ;****************************************************************
  2. ; Multiplikation zweier Zahlen
  3. ;  Input: r16,r17,r18,r19 = Low .. High Multiplikant
  4. ;         r20,r21,r22,r23 = Low .. High Multiplikator
  5. ; Output: r16,r17,r18,r19 = Low .. High Product Low
  6. ;         r20,r21,r22,r23 = Low .. High Product High
  7. ; Return: C       = 0 = Das Ergebnis ist 4 Byte
  8. ;         C       = 1 = Das Ergebnis ist > 4 Byte
  9. ; Modify: -
  10. ;                                       r7 r6 r5 r4 r3 r2 r1 r0
  11. ; Beispiel: r19r18r17r16*r23r22r21r20 = r23r22r21r20r19r18r17r16
  12. ;           10 20 30 40 * 50 60 70 80 =
  13. ;           ----------------------------------------------------
  14. ;           10          * 50          = 05 00
  15. ;           10          *    60       =    06 00 
  16. ;           10          *       70    =       07 00   
  17. ;           10          *          80 =          08 00
  18. ;              20       * 50          =    0A 00
  19. ;              20       *    60       =       0C 00
  20. ;              20       *       70    =          0E 00
  21. ;              20       *          80 =             10 00
  22. ;                 30    * 50          =       0F 00
  23. ;                 30    *    60       =          12 00
  24. ;                 30    *       70    =             15 00
  25. ;                 30    *          80 =                18 00
  26. ;                    40 * 50          =          14 00
  27. ;                    40 *    60       =             18 00
  28. ;                    40 *       70    =                1C 00
  29. ;                    40 *          80 =                   20 00
  30. ;                                       -----------------------
  31. ;                                       05 10 22 3C 3D 34 20 00
  32. ;                              
  33. umul4:     push  r0
  34.            push  r1
  35.            push  r2
  36.            push  r3
  37.            push  r4
  38.            push  r5
  39.            pop   r5
  40.            pop   r4
  41.            pop   r3
  42.            pop   r2
  43.            pop   r1
  44.            pop   r0
  45.            ret

5.2.1.3.1.2.4 DIV

Daten für Atmega8:

  1. ;****************************************************************
  2. ; Vorzeichenlose Division 32Bit / 32Bit
  3. ;  Input: r16 = Divident Low Byte
  4. ;         r17 = Divident
  5. ;         r18 = Divident
  6. ;         r19 = Divident High Byte
  7. ;         r20 = Divisor Low Byte
  8. ;         r21 = Divisor
  9. ;         r22 = Divisor
  10. ;         r23 = Divisor High Byte
  11. ; Output: r16 = Ergebnis Low Byte
  12. ;         r17 = Ergebnis
  13. ;         r18 = Ergebnis
  14. ;         r19 = Ergebnis High Byte
  15. ;         r20 = Rest Low Byte
  16. ;         r21 = Rest
  17. ;         r22 = Rest
  18. ;         r23 = Rest High Byte
  19. ; Return: c   = 0 = Alles klar
  20. ;         c   = 1 = Fehler (Divident < Divisor) or (Divisor = 0)
  21. ; Modify: -
  22. ;
  23. ; Wenn Fehler dann keine Änderung von Divident oder Divisor
  24. ;
  25. udiv32:    cp    r19,r23    ;Divident muß > als Divisor sein
  26.            brcs  udiv32f
  27.            brne  udiv32a
  28.            cp    r18,r22
  29.            brcs  udiv32f
  30.            brne  udiv32a
  31.            cp    r17,r21
  32.            brcs  udiv32f
  33.            brne  udiv32a
  34.            cp    r16,r20
  35.            brcs  udiv32f
  36. udiv32a:   tst   r20        ;Divisor darf nicht 0 sein
  37.            brne  udiv32b
  38.            tst   r21
  39.            brne  udiv32b
  40.            tst   r22
  41.            brne  udiv32b
  42.            tst   r23
  43.            brne  udiv32b
  44.            sec
  45.            brcs  udiv32f
  46. udiv32b:   push  r24
  47.            push  r25
  48.            push  r26
  49.            push  r27
  50.            push  r28
  51.            clr   r25        ;clear remainder Low byte
  52.            clr   r26
  53.            clr   r27
  54.            sub   r28,r28    ;clear remainder High byte and carry
  55.            ldi   r24,33     ;init loop counter
  56. udiv32c:   rol   r16        ;shift left dividend
  57.            rol   r17
  58.            rol   r18
  59.            rol   r19
  60.            dec   r24        ;decrement counter
  61.            breq  udiv32e    ;if done
  62.            rol   r25        ;shift dividend into remainder
  63.            rol   r26
  64.            rol   r27
  65.            rol   r28
  66.            sub   r25,r20    ;remainder = remainder - divisor
  67.            sbc   r26,r21    ;
  68.            sbc   r27,r22
  69.            sbc   r28,r23
  70.            brcc  udiv32d    ;if result negative
  71.            add   r25,r20    ; restore remainder
  72.            adc   r26,r21
  73.            adc   r27,r22
  74.            adc   r28,r23
  75.            clc              ; clear c to be shifted into result
  76.            rjmp  udiv32c    ;else
  77. udiv32d:   sec              ; set c to be shifted into result
  78.            rjmp  udiv32c
  79. udiv32e:   mov   r20,r25    ;Ergebnis umschichten
  80.            mov   r21,r26
  81.            mov   r22,r27
  82.            mov   r23,r28
  83.            pop   r28
  84.            pop   r27
  85.            pop   r26
  86.            pop   r25
  87.            pop   r24
  88. udiv32f:   ret

5.2.1.3.2 Signed

Der Wertebereich besteht nur aus positiven Zahlen von -2147483648 bis 2147483647.

Hex Dez
$00000000 0
... ...
$7FFFFFFF 2147483647
$80000000 -2147483648
... ...
$FFFFFFFF -1

5.2.1.3.2.1 Umwandlung

5.2.1.3.2.1.1 Integer nach String

5.2.1.3.2.1.2 String nach Integer

5.2.1.3.2.1.3 32 nach 64 Bit

5.2.1.3.2.2 Funktionen

5.2.1.3.2.2.1 ADD

5.2.1.3.2.2.2 SUB

5.2.1.3.2.2.3 MUL

5.2.1.3.2.2.4 DIV

5.2.1.3.2.2.5 ABS

5.2.1.4 64-Bit

 

Byte 0 Byte 1 Byte 2 Byte 3 Byte 4 Byte 5 Byte 6 Byte 7
7 ... 0 7 ... 0 7 ... 0 7 ... 0 7 ... 0 7 ... 0 7 ... 0 7 ... 0

Bit 0 aus einem Byte wird auch als LSB (Least Significant Bit) bezeichnet. Das Bit mit der kleinsten Wertigkeit. Bit 31 aus einem Word wird auch als MSB (Most Significant Bit) bezeichnet. Das Bit mit der größten Wertigkeit. Die Zählweise ist von links nach rechts und von 0 bis 63. Daraus läßt sich gleich die Wertigkeit der einzelnen Bits berechnen:

Bit

Exponent

Wertigkeit

Bit

Exponent

Wertigkeit

0

20

1

32

232

4294967296

1

21

2

33

233

8589934592

2

22

4

34

234

17179869184

3

23

8

35

235

34359738368

4

24

16

36

236

68719476736

5

25

32

37

237

137438953472

6

26

64

38

238

274877906944

7

27

128

39

239

549755813888

8

28

256

40

240

1099511627776

9

29

512

41

241

2199023255552

10

210

1024

42

242

4398046511104

11

211

2048

43

243

8796093022208

12

212

4096

44

244

17592186044416

13

213

8192

45

245

35184372088832

14

214

16384

46

246

70368744177664

15

215

32768

47

247

140737488355328

16

216

65536

48

248

281474976710656

17

217

131072

49

249

562949953421312

18

218

262144

50

250

1125899906842624

19

219

524288

51

251

2251799813685248

20

220

1048576

52

252

4503599627370496

21

221

2097152

53

253

9007199254740992

22

222

4194304

54

254

18014398509481984

23

223

8388608

55

255

36028797018963968

24

224

16777216

56

256

72057594037927936

25

225

33554432

57

257

144115188075855872

26

226

67108864

58

258

288230376151711744

27

227

134217728

59

259

576460752303423488

28

228

268435456

60

260

1152921504606846976

29

229

536870912

61

261

2305843009213693952

30

230

1073741824

62

262

4611686018427387904

31

231

2147483648

63

263

9223372036854775808

5.2.1.4.1 Unsigned

Der Wertebereich besteht nur aus positiven Zahlen von 0 bis 18.446.744.073.709.551.615

Hex Dez
$0000000000000000 0
... ...
$7FFFFFFFFFFFFFFF 9223372036854775807
$8000000000000000 9223372036854775808
... ...
$FFFFFFFFFFFFFFFF 18446744073709551615

5.2.1.4.1.1 Umwandlung

5.2.1.4.1.1.1 Integer nach String

5.2.1.4.1.1.2 String nach Integer

5.2.1.4.1.2 Funktionen

5.2.1.4.1.2.1 ADD

5.2.1.4.1.2.2 SUB

5.2.1.4.1.2.3 MUL

5.2.1.4.1.2.4 DIV

5.2.1.4.2 Signed

5.2.1.4.2.1 Umwandlung

5.2.1.4.2.1.1 Integer nach String

5.2.1.4.2.1.2 String nach Integer

5.2.1.4.2.2 Funktionen

5.2.1.4.2.2.1 ADD

5.2.1.4.2.2.2 SUB

5.2.1.4.2.2.3 MUL

5.2.1.4.2.2.4 DIV

5.2.1.4.2.2.5 ABS