AVR Arithmetik

2010-04-27T06:35:17Z

Stefan09: /* 32 Bit / 32 Bit */

Dieser Artikel beschäftigt sich mit 16- und 32-Bit Arithmetik auf [[AVR]]-Controllern. Für detailierte Ausführungen zur [[AVR-Tutorial: Arithmetik8|8-Bit Arithmetik auf AVR]] gibt es eine Seite im [[AVR-Tutorial]].

== Vergleich ==

===16 Bit ===
<avrasm>
;
; Vergleiche < r16, r17 > mit < r20, r21 >
;

cp r16, r20
cpc r17, r21
</avrasm>

===32 Bit ===
<avrasm>
;
; Vergleiche < r16, r17, r18, r19 > mit < r20, r21, r22, r23 >
;

cp r16, r20
cpc r17, r21
cpc r18, r22
cpc r19, r23
</avrasm>

==Addition==
===16 Bit + 16 Bit===
<avrasm>
;
; < r16, r17 > = < r16, r17 > + < r20, r21 >
;

add r16, r20
adc r17, r21
</avrasm>

===32 Bit + 32 Bit===
<avrasm>
;
; < r16, r17, r18, r19 > = < r16, r17, r18, r19 > + < r20, r21, r22, r23 >
;

add r16, r20
adc r17, r21
adc r18, r22
adc r19, r23
</avrasm>

==Subtraktion==
===16 Bit - 16 Bit===
<avrasm>
;
; < r16, r17 > = < r16, r17 > - < r20, r21 >
;

sub r16, r20
sbc r17, r21
</avrasm>

===32 Bit - 32 Bit===
<avrasm>
;
; < r16, r17, r18, r19 > = < r16, r17, r18, r19 > - < r20, r21, r22, r23 >
;

sub r16, r20
sbc r17, r21
sbc r18, r22
sbc r19, r23
</avrasm>

==Division==
===32 Bit / 32 Bit===

Ergebnis gerundet, und mit Restbildung.

<avrasm>
.def a0 = r16
.def a1 = r17
.def a2 = r18
.def a3 = r19

.def b0 = r20
.def b1 = r21
.def b2 = r22
.def b3 = r23

.def t0 = r24
.def t1 = r25
.def t2 = r26
.def t3 = r27
.def t4 = r28

;************************************************************************
;* *
;* unsigned rounded division 32 bit *
;* *
;************************************************************************

urdiv32:
mov t0, b0 ;T = B
mov t1, b1
mov t2, b2
mov t3, b3
lsr t3 ;B / 2
ror t2
ror t1
ror t0
add a0, t0 ;A = A + B / 2
adc a1, t1
adc a2, t2
adc a3, t3

;************************************************************************
;* *
;* unsigned division 32 bit *
;* *
;************************************************************************

; a3..0 = a3..0 / b3..0
; b3..0 = remainde

;cycle: max 684

udiv32:
clr t0
clr t1
clr t2
clr t3
ldi t4, 32
udi1: lsl a0
rol a1
rol a2
rol a3
rol t0
rol t1
rol t2
rol t3
cp t0, b0
cpc t1, b1
cpc t2, b2
cpc t3, b3
brcs udi2
sub t0, b0
sbc t1, b1
sbc t2, b2
sbc t3, b3
inc a0
udi2: dec t4
brne udi1
mov b0, t0
mov b1, t1
mov b2, t2
mov b3, t3
ret

</avrasm>

Eine Version, die je nach konkreten Zahlen Rechenzeit einspart

<avrasm>
.def a0 = r16
.def a1 = r17
.def a2 = r18
.def a3 = r19

.def b0 = r20
.def b1 = r21
.def b2 = r22
.def b3 = r23

.def t0 = r24
.def t1 = r25
.def t2 = r26
.def t3 = r27

;************************************************************************
;* *
;* unsigned rounded division 32 bit *
;* *
;************************************************************************

urdiv32:
mov t0, b0 ;T = B
mov t1, b1
mov t2, b2
mov t3, b3
lsr t3 ;B / 2
ror t2
ror t1
ror t0
add a0, t0 ;A = A + B / 2
adc a1, t1
adc a2, t2
adc a3, t3

;************************************************************************
;* *
;* unsigned division 32 bit *
;* *
;************************************************************************
;cycle: max 431 (63%) (684)

udiv32:
clr t1
tst b3
breq udi10
ldi t0, 8
udi1: lsl a0
rol a1
rol a2
rol a3
rol t1
cp a1, b0
cpc a2, b1
cpc a3, b2
cpc t1, b3
brcs udi2
sub a1, b0
sbc a2, b1
sbc a3, b2
sbc t1, b3
inc a0
udi2: dec t0
brne udi1
mov b0, a1
clr a1
mov b1, a2
clr a2
mov b2, a3
clr a3
mov b3, t1
ret

udi10: tst b2
breq udi20
ldi t0, 16
udi11: lsl a0
rol a1
rol a2
rol a3
rol t1
brcs udi12
cp a2, b0
cpc a3, b1
cpc t1, b2
brcs udi13
udi12: sub a2, b0
sbc a3, b1
sbc t1, b2
inc a0
udi13: dec t0
brne udi11
mov b0, a2
clr a2
mov b1, a3
clr a3
mov b2, t1
ret

udi20: tst b1
breq udi30
ldi t0, 24
udi21: lsl a0
rol a1
rol a2
rol a3
rol t1
brcs udi22
cp a3, b0
cpc t1, b1
brcs udi23
udi22: sub a3, b0
sbc t1, b1
inc a0
udi23: dec t0
brne udi21
mov b0, a3
clr a3
mov b1, t1
ret

udi30: ldi t0, 32
udi31: lsl a0
rol a1
rol a2
rol a3
rol t1
brcs udi32
cp t1, b0
brcs udi33
udi32: sub t1, b0
inc a0
udi33: dec t0
brne udi31
mov b0, t1 ;store remainder
ret
;------------------------------------------------------------------------

</avrasm>

==Multiplikation==
===32 Bit * 16 Bit===
<avrasm>
.def a0 = r16
.def a1 = r17
.def a2 = r18
.def a3 = r19

.def b0 = r20
.def b1 = r21
.def b2 = r22
.def b3 = r23

.def t0 = r24
.def t1 = r25
.def t2 = r26
.def t3 = r27
.def i0 = r28

;************************************************************************
;* *
;* unsigned multiplication 32 bit *
;* *
;************************************************************************
;cycle: max 245

umul32:
cpi a3, 0
cpc a3, a2
breq _umu1 ;one operand must be below 65536
mov t0, a0 ; swap A <-> B
mov a0, b0
mov b0, t0
mov t0, a1
mov a1, b1
mov b1, t0
mov b2, a2
mov b3, a3
clr a2
clr a3
; a3,2,1,0 = a1,0 * b3,2,1,0
_umu1: ldi i0, 16
clr t0
clr t1
ror a1
ror a0
_umu2: brcc _umu3
add a2, b0
adc a3, b1
adc t0, b2
adc t1, b3
_umu3: ror t1
ror t0
ror a3
ror a2
ror a1
ror a0
dec i0
brne _umu2
ret
;------------------------------------------------------------------------

</avrasm>

===24 Bit * 24 Bit===
<avrasm>
;**********************************************************************************************
;
; muls24x24_48:
; Signed Multiply von 2 24Bit breiten Zahlen mit 48Bit ergebnis
;
; x = a * b
; R21:R20:R19:R18:R17:R16 = R27:R26:R25 * R24:R23:R22
; hi lo hi lo hi lo
;
;**********************************************************************************************

muls24x24_48:
clr r2 ;Zero Register
muls r27,r24 ; (1) signed Multiply a(MSB) * b(MSB)
mov r21,r1
mov r20,r0

mul r26,r23 ; (2) unsigned
mov r18,r0
mov r19,r1

mul r25,r22 ; (3) unsigned multiply a(LSB) * b(LSB)
mov r17,r1
mov r16,r0

mul r26,r22 ;(4) unsigned
add r17,r0
adc r18,r1
adc r19,r2
adc r20,r2
adc r21,r2

mul r25,r23 ;(5) unsigned
add r17,r0
adc r18,r1
adc r19,r2
adc r20,r2
adc r21,r2

push r16
push r17

mov r16,r27
mulsu r16,r22 ;(6) unsigned * signed
sbc r20,r2
sbc r21,r2
add r18,r0
adc r19,r1
adc r20,r2
adc r21,r2

mulsu r16,r23 ;(7) unsigned * signed
sbc r21,r2
add r19,r0
adc r20,r1
adc r21,r2

mov r16,r24
mov r17,r25
mulsu r16,r17 ;(8) unsigned * signed
sbc r20,r2
sbc r21,r2
add r18,r0
adc r19,r1
adc r20,r2
adc r21,r2

mov r17,r26
mulsu r16,r17 ;(9) unsigned * signed
sbc r21,r2
add r19,r0
adc r20,r1
adc r21,r2

pop r17
pop r16
ret
</avrasm>

==Wurzel==
===sqrt (32 Bit)===

Dieser Algorithmus beruht auf dem Zusammenhang
:<math> n^2 = \sum_{k=1}^n (2k-1) = 1+3+5+\cdots+2n-1</math>
Er zählt, wie viele ungerade Zahlen vom Radikand abgezogen werden können, bevor dieser kleiner Null wird. Dementsprechend viele Schleifendurchläufe werden für die Wurzelberechnung benötigt; für die Quadratwurzel von 108 also zum Beispiel 10000 Stück.

<avrasm>
; WURZEL 32Bit
; 04/2006
; Bernhard.Erfurt@gmx.de

; ATmega8
.include "m8def.inc"

.def temp = R16 ; TEMP
.def temp1 = R17 ; TEMP1
.def temp2 = R18 ; TEMP2
.def temp3 = R19 ; TEMP3
.def temp4 = R20 ; TEMP4

;STACK initialisieren
ldi temp, HIGH(RAMEND)
out SPH, temp
ldi temp, LOW(RAMEND)
out SPL, temp

LOOP:

; TESTZAHLEN
ldi temp1, BYTE1(10000)
ldi temp2, BYTE2(10000)
ldi temp3, BYTE3(10000)
ldi temp4, BYTE4(10000)
; WURZEL berechnen
rcall WURZEL_32 ; INP: TEMP1...4 OUT: TEMP1...2
nop
rjmp LOOP

;#######################################################################
;
; INPUT temp1 (LOW)
; INPUT temp2
; INPUT temp3
; INPUT temp4 (HIGH)
;
; OUTPUT temp1 (LOW)
; OUTPUT temp2 (HIGH)
;
; Hilfsregister: R0,R1,R14,R15,R16,R21,R22,R23,R24
;
; rcall WURZEL_32 ; INP: TEMP1...4 OUT: TEMP1...2
;
WURZEL_32:
; HILFSREGISTER sichern (STACK)
push R0
push R1
push R14
push R15
push R16
push R21
push R22
push R23
push R24
; HILFSREGISTER initialisieren
ldi temp, 1
mov R14, temp ;= 1
ldi temp, 2
mov R15, temp ;= 2
clr temp
clr r0 ; ERGEBNIS
clr r1
ldi r21,1 ;= 1
clr r22
clr r23
clr r24

; Wurzel-Berechnung
WURZEL_32_w:
sub temp1,R21 ; SUBTRAKTION
sbc temp2,R22
sbc temp3,R23
sbc temp4,R24
brlo WURZEL_32_ww
add R0,R14 ; ADDITION +1(Ergebnis)
adc R1,temp
add R21,R15 ; ADDITION +2
adc R22,temp
adc R23,temp
adc R24,temp
rjmp WURZEL_32_w
WURZEL_32_ww:
mov temp1,r0 ; ERGEBNIS KOPIEREN
mov temp2,r1
; HILFSREGISTER wieder herstellen (STACK)
pop R24
pop R23
pop R22
pop R21
pop R16
pop R15
pop R14
pop R1
pop R0
ret
</avrasm>

=== avr-gcc Implementierung (32 Bit) ===
Quadratwurzel basierend auf einer Implementierung von Ruud v Gessel<ref>[http://members.chello.nl/j.beentjes3/Ruud/sqrt32avr.htm Ruud v Gessel: Quadratwurzeln]</ref>, die zusammen mit avr-gcc verwendet werden kann. Je nach Algorithmus wird das Ergebnis zum Nächsten gerundet oder abgerundet. Abrunden ist dann angesagt, wenn die Wurzel aus einer großen Eingabe wie <tt>0xffffffff</tt> zu ziehen ist, da bei Aufrunden hier das Ergebnis zu 0 überläuft.

Die maximale Ausführungszeit ist maximal 310 Ticks (inclusive CALL+RET):

sqrt32.h
<c>
#ifndef SQRT32_H
#define SQRT32_H
#include <stdint.h>

extern uint16_t sqrt32_round (uint32_t);
extern uint16_t sqrt32_floor (uint32_t);

#endif /* SQRT32_H */
</c>

C-Module, welche die Wurzel benötigen, includen einfach diesen Header. Das Assembler-Modul wird assembliert und zum Projekt hinzugelinkt.

==== Rundung zum Nächsten ====

<center>
{| {{Tabelle}}
|+ '''Ressourcen-Verbrauch, Rundung zum Nächsten'''
|-
|bgcolor="#ddffdd"| '''Flash''' || 82 Bytes
|-
|bgcolor="#ddffdd"| '''RAM''' || 2–3 Bytes dynamisch, 0 Bytes statisch
|-
|bgcolor="#ddffdd"| '''Laufzeit''' || 265–310 Ticks (inclusive Zeiten für CALL+RET)
|}
</center>

'''sqrt32.S''' (sqrt32_round)
{{Scrollbox|25em|
<avrasm>

;-----------------------------------------------------------
; Fast and short 32 bits AVR sqrt routine, avr-gcc ABI compliant
; R25:R24 = SQRT (R25:R24:R23:R22) rounded to the
; nearest integer (0.5 rounds up)
; Destroys R18-R19,R22-R23,R26-R27
; Cycles incl call & ret = 265-310
; Stack incl call = 2-3
;-----------------------------------------------------------
.text
.global sqrt32_round
.type sqrt32_round, @function

sqrt32_round:
ldi R19, 0xc0
clr R18 ; rotation mask in R19:R18
ldi R27, 0x40
sub R26, R26 ; developing sqrt in R27:R26, C=0
1: brcs 2f ; C --> Bit is always 1
cp R24, R26
cpc R25, R27 ; Does test value fit?
brcs 3f ; C --> nope, bit is 0
2: sub R24, R26
sbc R25, R27 ; Adjust argument for next bit
or R26, R18
or R27, R19 ; Set bit to 1
3: lsr R19
ror R18 ; Shift right mask, C --> end loop
eor R27, R19
eor R26, R18 ; Shift right only test bit in result
rol R22 ; Bit 0 only set if end of loop
rol R23
rol R24
rol R25 ; Shift left remaining argument (C used at 1:)
sbrs R22, 0 ; Skip if 15 bits developed
rjmp 1b ; Develop 15 bits of the sqrt
brcs 4f ; C--> Last bits always 1
cp R26, R24
cpc R27, R25 ; Test for last bit 1
brcc 5f ; NC --> bit is 0
4: sbc R23, R19 ; Subtract C (any value from 1 to 0x7f will do)
sbc R24, R26
sbc R25, R27 ; Update argument for test
inc R26 ; Last bit is 1
5: lsl R23 ; Only bit 7 matters
rol R24
rol R25 ; Remainder * 2 + C
brcs 6f ; C --> Always round up
cp R26, R24
cpc R27, R25 ; C decides rounding
6: adc R26, R19
adc R27, R19 ; Round up if C (R19=0)
mov R25, R27 ; return in R25:R24 for avr-gcc ABI compliance
mov R24, R26
ret

.size sqrt32_round, .-sqrt32_round
</avrasm>
}}

==== Abrunden ====

<center>
{| {{Tabelle}}
|+ '''Ressourcen-Verbrauch, Abrunden'''
|-
|bgcolor="#ddffdd"| '''Flash''' || 60 Bytes
|-
|bgcolor="#ddffdd"| '''RAM''' || 2–3 Bytes dynamisch, 0 Bytes statisch
|-
|bgcolor="#ddffdd"| '''Laufzeit''' || 260–300 Ticks (inclusive Zeiten für CALL+RET)
|}
</center>

'''sqrt32.S''' (sqrt32_floor)
{{Scrollbox|25em|
<avrasm>
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Fast and short 32 bits AVR sqrt routine, avr-gcc ABI compliant
; R25:R24 = SQRT (R25:R24:R23:R22)
; rounded down to integer
; Destroys R26,R27,R22,R23,R18,R19
; Cycles incl call & ret = 260-300
; Stack incl call = 2-3
.text
.global sqrt32_floor
.type sqrt32_floor, @function

sqrt32_floor:
ldi R19, 0xc0
clr R18 ; rotation mask in R19:R18
ldi R27, 0x40
sub R26, R26 ; developing sqrt in R27:R26, C=0
1: brcs 2f ; C --> Bit is always 1
cp R24, R26
cpc R25, R27 ; Does test value fit?
brcs 3f ; C --> nope, bit is 0
2: sub R24, R26
sbc R25, R27 ; Adjust argument for next bit
or R26, R18
or R27, R19 ; Set bit to 1
3: lsr R19
ror R18 ; Shift right mask, C --> end loop
eor R27, R19
eor R26, R18 ; Shift right only test bit in result
rol R22 ; Bit 0 only set if end of loop
rol R23
rol R24
rol R25 ; Shift left remaining argument (C used at 1:)
sbrs R22, 0 ; Skip if 15 bits developed
rjmp 1b ; Develop 15 bits of the sqrt

brcs 4f ; C--> Last bits always 1
lsl R23 ; Need bit 7 in C for cpc
cpc R26, R24
cpc R27, R25 ; After this C is last bit

4: adc R26, R19 ; Round up if C (R19=0)
mov R25, R27 ; return in R25:R24 as for avr-gcc ABI
mov R24, R26
ret

.size sqrt32_floor, .-sqrt32_floor
</avrasm>
}}

=== Schnelle Implementierung für große Operanden===
* http://www.mikrocontroller.net/topic/98432

==Binär zu BCD - Umwandlung==
Zur Ausgabe einer Binärzahl auf ein Textdisplay oder zur seriellen ASCII-Übertragung an den PC ist diese Umwandlung nötig. Sie ist ähnlich aufwendig wie eine Division, zum Beispiel für eine 32-Bit-Zahl etwa 500-900 Taktzyklen und 10 Register.
Mehrere Verfahren werden angeboten:
=== Division /10===
Für eine Division pro Dezimalstelle ist nur ein Unterprogramm nötig. Der Divisionsrest, engl. remainder, bildet unmittelbar die BCD-codierte Dezimalziffer, von rechts nach links fortschreitend. Zur Ausgabe von links nach rechts kann man die Ziffern auf dem Stack zwischenlagern (LIFO-Register last-in first-out)

Beispiele:
*[http://www.atmel.com/dyn/resources/prod_documents/doc0938.pdf AVR204: BCD Arithmetics, 8-Bit Binary to 2-digit BCD Conversion]

===Division /10000, /1000, /100, /10===
ähnlich dem vorigen, aber die BCD-Ziffern erscheinen sofort von links nach rechts.

Beispiele:
*[http://users.i.com.ua/~birua/math32.asm Bin2BCD == 16-bit Binary to BCD conversion in der Macrolibrary Math32 von Andre Birua]

===Addition von $33===
Hier wird die Binärzahl, mit der höchstwertigen Stelle voran, von rechts in die Ergebnisregister geschoben. Nach jedem Schiebevorgang wird eine Korrekturrechnung ausgeführt. Für 32 Bit bilden 4 Eingabe- und 5 Ausgaberegister ein 72 Bit Schieberegister, das 32 mal links geschoben wird.
Durch die Korrekturrechnung wird die Binärzahl zur gepackten (2 Stellen pro Byte) BCD-Zahl "aufgebläht".

Eine Erklärung des Algorithmus soll hier versucht werden:
Um die niederwertigste 4 Bit Binärziffer in BCD umzuwandeln, ist für $0...$9 keine Änderung nötig, für $A...$F wird "6" addiert. Diese Addition wird ersetzt durch eine Addition von "3" und anschließendes Linksschieben. Das führt man zunächst für beide Halbbytes gleichzeitig mit "subi Reg,-$33" aus. Anschließend werden die beiden Additionen einzeln für den Fall "0...9" rückgängig gemacht. Die Bits 4 und 7 des Registers dient dabei als BCD-Carry-Flag (Halbbyte-Übertrag). Das normale C-Flag wird durch die Additionen nicht beeinflußt, es dient nur dem Schiebevorgang.

Beispiele:
*[http://www.atmel.com/dyn/resources/prod_documents/doc0938.pdf AVR204: BCD Arithmetics 16 Bit Binary to 5-digit BCD conversion]
*[http://users.i.com.ua/~birua/math32.asm Bin4BCD == 32-bit Binary to BCD conversion in der Macrolibrary Math32 von Andre Birua]
*[http://www.xilinx.com/support/documentation/application_notes/xapp029.pdf Der gleiche serielle Algorithmus für Xilinx CPLDs]

===Tabelle===
Für kleine Zahlen kann die gesuchte BCD-Zahl auch aus einer Tabelle entnommen werden.
===Mischvarianten===
Eine Mischung mehrerer Verfahren wird z. B. von Andre Birua in der ersten Variante von "Bin4BCD" verwendet. Die oberen 16 Bit werden nach "Div/10000" vorbearbeitet und anschließend alle 32 Bit nach "Add $33".

===Tutorial===
*[http://www.cs.uiowa.edu/~jones/bcd/decimal.html Part of the Arithmetic Tutorial Collection by Douglas W. Jones]
enthält C-Code und PIC-Code für schnelle 16 Bit Wandlung, Hardware-Multiplizierer möglich - auch für FPGA interessant
*[http://www.mikrocontroller.net/articles/TTL74185 VHDL Nachbau des TTL 74185 6-Bit Binär-zu-BCD-Wandlers]
*[http://www.mikrocontroller.net/articles/Festkommaarithmetik Tutorial Festkommaarithmetik]
*[http://www.mikrocontroller.net/articles/AVR-Tutorial:_7-Segment-Anzeige Tutorial 7-Segment-Anzeige]

===Diskussionsbeiträge im Forum===
*[http://www.mikrocontroller.net/topic/85248 Binär-zu-BCD in VHDL]
*[http://www.mikrocontroller.net/topic/83884 ebenfalls VHDL]
*[http://www.mikrocontroller.net/topic/59851 32 Bit in C]
*[http://www.mikrocontroller.net/topic/64842 16 und 32 Bit C und AVR-Assembler]
*[http://www.mikrocontroller.net/topic/1501 Assembler für AVR-GCC bis 256 Bit]
*[http://www.mikrocontroller.net/topic/173633 2 hoch x , wenn x kein Integer ist]

== Sinus und Cosinus ==
→ siehe [[AVR Arithmetik/Sinus und Cosinus (CORDIC)]] 
→ siehe [[AVR Arithmetik/Sinus und Cosinus (Lineare Interpolation)]]

== Saturierung ==
→ siehe [[AVR Arithmetik/Saturierung]]

== Fußnoten ==
<references/>

== Weblinks==
* [http://www.azillionmonkeys.com/qed/sqroot.html Wurzelfunktion]
* [http://www.avrfreaks.net/index.php?name=PNphpBB2&file=printview&t=37150&start=40 Optimierte Division durch 10]
* [http://www.avrfreaks.net/index.php?name=PNphpBB2&file=printview&t=54192&start=20 Optimierte Division durch 3]
* [http://www.cs.uiowa.edu/~jones/bcd/divide.html Division durch reziproke Multiplikation, Tutorial]
* [http://users.i.com.ua/~birua/math32.html Math32: Some Useful Assembler Multibyte Maths Subroutines & Macrocalls] [http://avr-asm.tripod.com/math32x.html (oder hier)]
*[http://avr.15.forumer.com/a/computer-math-11/ AVR-Computer Math topics]
*[http://elm-chan.org/cc_e.html Elm-Chan's Bibliotheken u.a. Arithmetik]
* [http://www.embedded.com/design/opensource/217900224?printable=true Multiplication by a Fixed Point Constant], Embedded.com, 06/16/09
* [http://surfnet.dl.sourceforge.net/sourceforge/avrfix/avrfix.pdf M. Rosenblattl, A. Wolf: ''Fixed Point Library According to ISO/IEC Standard DTR 18037 for Atmel AVR Processors''] (pdf, engl., 133 S.)
* [http://www.open-std.org/JTC1/sc22/wg14/www/docs/n1005.pdf ISO/IEC DTR 18037] (pdf, engl., 101 S.) — Spezifikation einer Erweiterung von C99 zur Unterstützung von Embedded Systems

[[Category:AVR]]
[[Category:AVR-Tutorial]]
[[Category:AVR-Arithmetik| ]]

Mikrocontroller.net - Benutzerbeiträge [de]

AVR Arithmetik