Mikrocontroller.net - Benutzerbeiträge [de]

Hilbert-Transformator (Phasenschieber) mit ATmega

2015-10-15T09:46:49Z

134.169.116.89: muß => muss

Dieser Artikel ist eine Fortsetzung von [[Digitalfilter mit ATmega]] und behandelt ein spezielles Digitalfilter namens Hilbert-Transformator.

Neben den üblichen Filtern, Tiefpass, Hochpass, Bandpass und Bandsperre, gibt es einige weitere Typen. In der Literatur findet man u.a. noch den Allpass, Phasenschieber, Integrator und Differentiator.

===Der Hilbert-Transformator, ein Breitband-90-Grad-Phasenschieber===

In den Lehrbüchern wird er völlig zu Unrecht eher am Rande abgehandelt. Tatsächlich findet man ihn in allen Schaltungen zur Datenübertragung, zu Modulation oder Demodulation mit I/Q-Mischern, im „Software-defined radio“.

Auch ein Hilbert-Transformator kann mithilfe von Scilab berechnet werden. Allerdings gibt es keine fertige Software, man muss sich durch einige Literatur hindurchfressen, z. B. ISBN 0471619957 Sanjit Mitra, Handbook for DSP (1993), Kapitel „Special Filter Designs“ von [http://faculty.cua.edu/regalia/ Phillip Regalia].

GNU Octave stellt die Hilbert-Transformation und den Parks-McClellan-hilbert-FIR-Filterentwurf im [http://octave.sourceforge.net/signal/function/remez.html octave-forge Paket "signal"] zur Verfügung.

Eine Fundgrube sind die Matlab-Texte von Prof. Schüssler, die vorab 1998 zum zweiten Band seines Lehrbuchs auf seiner Webseite veröffentlicht wurden. Inzwischen ist der erste Band in der fünften Auflage erschienen [http://www.springer.com/engineering/signals/book/978-3-540-78250-6 ISBN 9783540782506] , der zweite Band ISBN 9783642011184 2010 erstmalig erschienen, [http://www.lms.lnt.de/forschung/veroeffentlichungen/buecher/dsv.shtml Software-Download hier] aber die Webseite ist nach seinem Tod 2007 abgeschaltet. Zum Glück gibt es das
[http://web.archive.org/web/20041206171820/www.nt.e-technik.uni-erlangen.de/~hws/dsv2programs/index.html Webarchiv], wo die Texte noch zu finden sind.

Zu dieser Zeit waren die Matlab-Programme noch nicht in „Toolboxen“ untergebracht, deren Funktion von außen nicht mehr sichtbar ist. Daher lassen sie sich relativ einfach in Scilab oder Octave übersetzen.

Vier Versionen von Hilbert-Transformatoren werden hier berechnet:
* FIR-Hilbert, aufwendig, aber streng linearphasig, der bekannteste Typ, da schon lange mit dem Matlab-Befehl remez / firpm und Parameter 'hilbert' berechenbar. Mit dem octave-forge Paket "signal" ist remez mit "hilbert" verfügbar. Scilab kennt diesen Parameter nicht.
* näherungsweise linearphasiger IIR-Hilbert, maximal flach,
* näherungsweise linearphasiger IIR-Hilbert, Tschebyscheff
* minimalphasiger IIR-Hilbert, kompakt, aber mit großen Gruppenlaufzeitschwankungen, eher für Audioanwendungen als Digitalsignale.

Im Artikel von Schüßler/Steffen (siehe unten) sind in zwei vergleichenden Beispielen die Gruppenlaufzeitschwankungen des maximal Flachen etwa halb so groß, des Minimalphasigen etwa fünf Mal so groß wie die Tschbyscheff-Version.

Zumindest der kompakte IIR-Hilbert lässt sich auch in einem ATmega unterbringen. Er besteht aus einer Verzögerung und zwei Allpässen, die wieder aus SOS-Teilfiltern aufgebaut sind. Pro Teilfilter gibt es nur einen Koeffizienten, sodass man mindestens acht Teilfilter verwenden kann.

===Ein Hilbert-Kochrezept (noch unvollständig)===

Folgen wir dem Zahlenbeispiel und Berechnungsweg im „Handbook for DSP“.

Zuerst berechnen wir einen elliptischen ''Halbband''-Tiefpass. Halbband besagt, dass die beiden Grenzfrequenzen symmetrisch zur halben Nyquist- Frequenz also 0,25 * Abtastfrequenz liegen, siehe Bild oben rechts. Die genauen Bedingungen lauten in der Schreibweise des Buches (''p''=passband, ''s''=stopband):
* Omegas + Omegap = Pi (auf Omegasample normierte Skala: Samplerate=2*Pi)
* (1-Delta1)2 +Delta22=1

Als Zahlenwerte werden Omegas = 0,55*Pi und Delta2=0,01 gewählt, und damit ein elliptischer IIR-Tiefpass 7.Ordnung berechnet.
Damit erhält er folgende Zahlenwerte der Pole:

0 0,436688 0,743707 0,927758

===Scilab-Berechnung des Halbbandfilters===

Mit Scilab erhalten wir nach einigem Ausprobieren praktisch dieselben Zahlenwerte, siehe Bild. Die Pole müssten für ein ideales Halbbandfilter genau auf der imaginären Achse liegen, der Realteil genau Null sein (Der Fehler kommt daher, dass die Angabe von fstop vom Programm nicht berücksichtigt wird, das Filter wäre überbestimmt).
Diese Zahlen werden noch quadriert (''konjugiert komplexe'' Pole zusammengefasst) und bilden schließlich die Koeffizienten des Hilbert-Transformators.

[[Bild:Halbbandfilter.png|Mit Scilab berechnetes Halbbandfilter 7.Ordnung|640px]]

Die Übertragungsfunktion des gesuchten Hilbert-Transformators soll wie bisher H(z) heißen. Zur Unterscheidung nennen wir die bis jetzt berechnete Tiefpassfunktion G(z).

Wieder wird sie in SOS-Teilfilter aufgeteilt. Hier allerdings in die Summe von zwei parallel geschalteten ''Allpass''-Funktionen A1 und A2 plus eine Verzögerung um einen Sampletakt, in der Übertragungsfunktion als „z-1“ ausgedrückt.

Ein Allpass läßt alle Signalfrequenzen mit unveränderter Amplitude durch, verändert nur die Phase. Seine SOS-Teilfunktion ist besonders einfach aufgebaut, zwei Koeffizienten sind Null, zwei sind gleich Eins und die beiden restlichen identisch. Damit benötigt man nur eine Multiplikation pro Teilfilter.

Die Tiefpass-Übertragungsfunktion erhält so die Form:

'''G(z) = ½ * ( A1 (z2) + z-1 * A2 (z2))'''

mit

<math>
A_{1}(z^{2})=\frac{z^{-2}+0,190696}{1+0,190696\ast z^{-2}}\ast
{\frac{z^{-2}+0,860735}{1+0,860735\ast z^{-2}}}
</math>

<math>
A_{2}(z^{2})=\frac{z^{-2}+0,553100}{1+0,553100\ast z^{-2}}
</math>

Wenn man die beiden Ausgänge nicht addiert, sondern subtrahiert, entsteht ein Hochpass gleicher Grenzfrequenz. Beides kombiniert ergibt eine digitale ''Frequenzweiche''.

Zum Übergang auf den Hilbert-Transformator ersetzen (''substituieren'') wir das z durch -jz und multiplizieren das ganze mit 2:

H(z)= 2*G(-jz)

'''H(z) = A1 (-z2) + j* z-1 * A2 (-z2)'''

mit

<math>
A_{1}(-z^{2})=\frac{z^{-2}-0,190696}{1-0,190696\ast z^{-2}}\ast
{\frac{z^{-2}-0,860735}{1-0,860735\ast z^{-2}}}
</math>

<math>
A_{2}(-z^{2})=\frac{z^{-2}-0,553100}{1-0,553100\ast z^{-2}}
</math>

Wie man sieht, ändern sich nur die Vorzeichen. Die Pole liegen aber im Pol-Nullstellendiagramm auf der reellen Achse.

Die Ausgänge der beiden Allpässe sind jetzt gegeneinander um 90 Grad phasenverschoben, und können auf einen I/Q-Modulator gegeben werden. Umgekehrt kann man auch die beiden Eingänge auftrennen, und zwei um 90 Grad versetzte Signale aus einem I/Q-Demodulator einspeisen und die Ausgangssignale addieren oder subtrahieren, je nach gewünschtem Seitenband.

[[Bild:Allpaesse.png]]

Und weil das so gut funktionierte, hier noch die Berechnung des Hilbert-Transformators [http://www.mikrocontroller.net/topic/92630#new von Olli Niemitalo] mit einem Halbband-Tiefpass 17.Ordnung, was zu acht SOS-Teilfiltern führt, dazu folgt unten ein ATmega48-Programm.

[[Bild:Halbbandfilter2.png|Halbbandfilter 17.Ordnung|640px]]

===Der näherungsweise linearphasige Hilbert-Transformator===

Er wird im Handbook for DSP auf zwei Seiten sehr kurz abgehandelt. Statt aus zwei Allpässen besteht er aus einem einzigen, im anderen Zweig wird das Signal nur zeitverzögert, was mit einem Ringpuffer wenig Rechenzeit kostet. Eine Zeitverzögerung ist sozusagen die einfachste Form eines Allpasses, damit ist diese Bauform ein Spezialfall der oben gezeigten. Aus Schüsslers Texten erfahren wir noch, dass das Halbband-Tiefpassfilter zur Berechnung hier Tschebyscheff-Charakter haben muß.

Das Zahlenbeispiel zitiert Regalia aus einer anderen Veröffentlichung [http://www.cs.tut.fi/~mr/MRJulk92.html (M. Renfors and T. Saramäki, A class of approximately linear phase digital filters composed of allpass subfilters 1986 ) ] Der Allpass hat neun Koeffizienten, die Zeitverzögerung beträgt 17 Sampletakte. Der Halbband-Tiefpass hat eine Sperrdämpfung von > 49 dB. Sein Frequenzgang und der Phasengang des berechneten Hilbert-Transformators sind als Bild gezeigt.

Zum Allpass gibt es noch folgende Zahlenwerte:

Pole location for A(z) 
z= -0.8699928078 
0.491194141 ± j0.183666529 
0.252724179 ± j0.463085544 
-0.109950894 ± j0.548611467 
-0.447326028 ± j0.356810323 

Das könnte also ebenfalls noch in einen ATmega passen.

===Hilbert ohne Multiplizierer===

Eine interessante Variante wird im Artikel [http://kondor.etf.bg.ac.yu/~lutovac/pdf/eusi98lm.pdf Design of multiplierless elliptic IIR halfband filters and Hilbert transformers] vorgestellt. Ähnlich wie im Cordic-Algorithmus für trigonometrische Funktionen werden Multiplikationen vermieden, durch geschickte Wahl der Koeffizienten als Zweierpotenzen.

Die beiden Allpässe des Zahlenbeispiels haben folgende Übertragungsfunktionen:

<math>\begin{align}
A_1(z^{-2})
&=\frac{z^{-2}-0{,}12109375}{1-0{,}12109375 \cdot z^{-2}}
\cdot\frac{z^{-2}-0{,}6640625}{1-0{,}6640625 \cdot z^{-2}} \\
&=\frac{z^{-2}-(\frac18 - \frac1{256})}{1-(\frac18 - \frac1{256}) \cdot z^{-2}}
\cdot\frac{z^{-2}-(\frac12 + \frac18 + \frac1{32} + \frac1{128})}{1-(\frac12 + \frac18 + \frac1{32} + \frac1{128})\cdot z^{-2}}\\
\end{align}</math>

<math>\begin{align}
A_2(z^{-2})\cdot{z^{-1}}
&=z^{-1}
\cdot\frac{z^{-2}-0{,}390625}{1-0{,}390625 \cdot z^{-2}}
\cdot\frac{z^{-2}-0{,}890625}{1-0{,}890625 \cdot z^{-2}}\\
&=z^{-1}
\cdot\frac{z^{-2}-(\frac14 + \frac18 + \frac1{64})}{1-(\frac14 + \frac18 + \frac1{64}) \cdot z^{-2}}
\cdot\frac{z^{-2}-(1 - \frac18 + \frac1{64})}{1-(1 - \frac18 + \frac1{64}) \cdot z^{-2}}
\end{align}</math>

===Weitere Literatur zu Hilbert===
* Schüssler / [http://www.lnt.de/LMS/staff/index.php?lang=de&function=1&person=5 Steffen] "Halfband Filters and Hilbert Transformers" Irgendwo im Web hatte ich den vollständigen Artikel als PDF gefunden, leider die Adresse nicht notiert, Google findet nur [http://www.springerlink.com/content/p5480n6p8t73t633/ kostenpflichtige Downloads].
* Dutta / Kumar [http://eprint.iitd.ac.in/dspace/bitstream/2074/1608/1/roydig1989.pdf On Digital Differentiators, Hilbert Transformers, and Half-Band Low-Pass Filters] dank Schrifterkennungsprogramm leicht lädiert
* Miroslav Lutovac / Ljiljana Milic [http://www.telfor.rs/telfor2000/radovi/7-10.pdf Half-band IIR Filter Design Using Matlab], [http://kondor.etf.bg.ac.yu/~lutovac/confer.htm weitere Artikel der Autoren]
* Göckler / Damjanovic [http://www.dsv.rub.de/imperia/md/content/public/wsr06_goecklerdamjanovic.pdf A Family of Efficient Complex Halfband Filters]

===ATmega-Programm Hilbert-Transformer ( fast fertig, schwingt leider)===
Da der Adressenbereich des ATmega nicht groß genug ist, wird die Tabelle im SRAM in zwei Hälften geteilt.
<syntaxhighlight lang="avrasm">
;***************************************************************************
;* Hilbert transformer with ATmega48P, 90 degree broadband phase shifter *
;* 15 MHz xtal, input ADC0, PWM-output OCR1a/b, test output PD0 *
;* Christoph Kessler 2008 db1uq_at_t-online_dot_de *
;***************************************************************************
.nolist
.include "m48pdef.inc"
.list
;***************************************************************************
;* register 0-15 (no "immediate"-operations possible):
;***************************************************************************
.def mult_l = r0 ; multiplier result
.def mult_h = r1 ; multiplier result
.def zero = r2 ; zero register (used to add carry flag)
.def savsrg = r3 ; save status register during interrupt routine
.def reg04 = r4 ; free
.def reg05 = r5 ; free
.def reg06 = r6 ; free
.def reg07 = r7 ; free
.def reg08 = r8 ; free
.def reg09 = r9 ; free
.def reg10 = r10 ; free
.def reg11 = r11 ; free
.def reg12 = r12 ; free
.def accu0 = r13 ; Accumulator - 32bit for Interrupt routine
.def accu1 = r14 ; Accumulator - 32bit for Interrupt routine
.def accu2 = r15 ; Accumulator - 32bit for Interrupt routine
;***************************************************************************
;* register 16-23 ("immediate"-operations possible):
;***************************************************************************
.def accu3 = r16 ; Accumulator - 32bit for Interrupt routine
.def reg17 = r17 ; free
.def reg18 = r18 ; free
.def reg19 = r19 ; free
.def datal = r20 ; Data samples mul register
.def datah = r21 ; for Interrupt routine
.def coefl = r22 ; Filter coefficient mul register
.def coefh = r23 ; for Interrupt routine
;***************************************************************************
;* register 24-31 (16Bit-registers)
;***************************************************************************
.def tmp1 = r24 ; general temporary register
.def tmp2 = r25 ; general temporary register
; XL = r26 ; free
; XH = r27 ; free
; YL = r28 ; used by Interrupt routine
; YH = r29 ; used by Interrupt routine
; ZL = r30 ; init routine only, free for main program
; ZH = r31 ; init routine only, free for main program
;*************************************************************************
;* constants :
;*************************************************************************
;1st table:
;"allpass"0:
.equ x10 = 0
; allpass 2:
.equ x12 = 2
.equ x22 = 4
.equ y02 = 6
.equ y12 = 8
.equ y22 = 10
; allpass 4:
.equ x14 = 12
.equ x24 = 14
.equ y04 = 16
.equ y14 = 18
.equ y24 = 20
; allpass 6:
.equ x16 = 22
.equ x26 = 24
.equ y06 = 26
.equ y16 = 28
.equ y26 = 30
; allpass 8:
.equ x18 = 32
.equ x28 = 34
.equ y08 = 36
.equ y18 = 38
.equ y28 = 40

.equ k2 = 42
.equ k4 = 44
.equ k6 = 46
.equ k8 = 48
;2nd table:
.equ k1 = 0
.equ k3 = 2
.equ k5 = 4
.equ k7 = 6
; allpass 1:
.equ x11 = 8
.equ x21 = 10
.equ y01 = 12
.equ y11 = 14
.equ y21 = 16
; allpass 3:
.equ x13 = 18
.equ x23 = 20
.equ y03 = 22
.equ y13 = 24
.equ y23 = 26
; allpass 5:
.equ x15 = 28
.equ x25 = 30
.equ y05 = 32
.equ y15 = 34
.equ y25 = 36
; allpass 7:
.equ x17 = 38
.equ x27 = 40
.equ y07 = 42
.equ y17 = 44
.equ y27 = 46
;*****************************************************
;* Macros
;*****************************************************
.MACRO load_node
ldd datal,Y+@0 ; Load low byte of node
ldd datah,Y+@0+1 ; Load high byte of node
.ENDMACRO
.MACRO update_node
std Y+@0,datal ; Store low byte of node
std Y+@0+1,datah ; Store high byte of node
.ENDMACRO
.MACRO add_node
ldd coefl,Y+@0 ; Load 2nd node low
ldd coefh,Y+@0+1 ; Load 2nd node high
add datal,coefl ; Add low bytes
adc datah,coefh ; Add with carry high bytes
.ENDMACRO
.MACRO mult_32
ldd coefl,Y+@0 ; Load low byte of coefficient
ldd coefh,Y+@0+1 ; Load high byte of coefficient
muls coefh,datah ; Signed multiply, coefficient high byte and data high byte
mov accu2,mult_l ; Copy result word into accumulator byte 2:3
mov accu3,mult_h ; Copy result word into accumulator byte 2:3
mul coefl,datal ; Unsigned multiply, coefficient low byte and data low byte
mov accu0,mult_l ; Copy result word into accumulator byte 2:3
mov accu1,mult_h ; Copy result word into accumulator byte 2:3
mulsu coefh,datal ; Signed-unsigned multiply, coefficient high byte and data low byte
sbc accu3,zero ; Sign extention
add accu1,mult_l ; Add low byte of result to accumulator byte 1
adc accu2,mult_h ; Add with carry high byte of result to accumulator byte 2
adc accu3,zero ; Add carry to accumulator byte 3
mulsu datah,coefl ; Signed-unsigned multiply, data high byte and coefficient low byte
sbc accu3,zero ; Sign extention
add accu1,mult_l ; Add low byte of result to accumulator byte 1
adc accu2,mult_h ; Add with carry high byte of result to accumulator byte 2
adc accu3,zero ; Add carry to accumulator byte 3
.ENDMACRO
.MACRO subtr_node
ldd datal,Y+@0 ; Load 2nd node low
ldd datah,Y+@0+1 ; Load 2nd node high
sub accu0,datal ; Subtract low byte
sbc accu1,datah ; Subtract with carry high byte
sbc accu2,zero ;
sbc accu3,zero ;
.ENDMACRO
.MACRO limit_store
cpi accu3,$40 ; accu < $40000000 ?
brlo NoLimit1 ;
cpi accu3,-$40 ; accu >= -$40000000 ?
brsh NoLimit1 ;
clr accu2 ; accu2 = $00
cpi accu3,0 ;
brge PosLim1 ;
ldi accu3,$80 ; accu3 = $80
rjmp Limit1 ;
PosLim1:
ldi accu3,$7F ; accu3 = $7F
com accu2 ; accu2 = $FF
rjmp Limit1 ;
NoLimit1:
lsl accu1 ; Scaling to gain factor 2^16
rol accu2 ;
rol accu3 ;
Limit1:
std Y+@0,accu2 ;
std Y+@0+1,accu3 ;
.ENDMACRO
.LISTMAC
;*************************************************************************
;* reset/interrupt-vectors:
;*************************************************************************
.cseg
rjmp Initial ; after RESET to main program
reti ; External Interrupt Request 0
reti ; External Interrupt Request 1
reti ; Pin Change Interrupt Request 0
reti ; Pin Change Interrupt Request 1
reti ; Pin Change Interrupt Request 2
reti ; Watchdog Time-out Interrupt
reti ; Timer/Counter2 Compare Match A
reti ; Timer/Counter2 Compare Match B
reti ; Timer/Counter2 Overflow
reti ; Timer/Counter1 Capture Event
reti ; Timer/Counter1 Compare Match A
reti ; Timer/Counter1 Compare Match B
reti ; Timer/Counter1 Overflow
reti ; Timer/Counter0 Compare Match A
reti ; Timer/Counter0 Compare Match B
reti ; Timer/Counter0 Overflow
reti ; SPI Serial Transfer Complete
reti ; USART0, Rx Complete
reti ; USART0 Data register Empty
reti ; USART0, Tx Complete
rjmp ADCint ; ADC Conversion Complete
reti ; EEPROM Ready
reti ; 2-wire Serial Interface
reti ; Store Program Memory Read
;*************************************************************************
;* after reset: initialise stack,ports
;*************************************************************************
Initial:
ldi tmp1,Low(RAMEND)
out SPL,tmp1 ;
ldi tmp1,High(RAMEND)
out SPH,tmp1 ; stack initialised
clr zero ; always zero
ldi tmp1,$FF ;
out PortB,tmp1 ; PortB = % 1111 1111
out PortC,zero ; PortC = % 0000 0000
out PortD,tmp1 ; PortD = % 1111 1111
out DDRB,tmp1 ; PortB direction = % 1111 1111
out DDRC,zero ; PortC direction = % 0000 0000
out DDRD,tmp1 ; PortD direction = % 1111 1111
ldi tmp1,$A1 ; pos. outputs, fast PWM 8Bit
sts TCCR1A,tmp1 ;
ldi tmp1,$09 ; fast PWM 8Bit, clk/1 (no prescaling)
sts TCCR1B,tmp1 ;
sts OCR1AH,zero ;
sts OCR1AL,zero ;
sts OCR1BH,zero ;
sts OCR1BL,zero ;
ldi tmp1,$40 ; Ref=Vcc, right-adj, ADC0=input
sts ADMUX,tmp1 ;
ldi tmp1,$EE ; Start,Auto, enable Int, Clk/64
; ldi tmp1,$EF ; Start,Auto, enable Int, Clk/128
sts ADCSRA,tmp1 ;
ldi tmp1,$00 ; free running
sts ADCSRB,tmp1 ;
ldi tmp1,$01 ; disable ADC0 dig.inp (optional)
sts DIDR0,tmp1 ;
ldi ZL,low(CoTblF<<1) ; move filter coefficents
ldi ZH,high(CoTblF<<1) ; from program-flash
ldi YL,low(CoTblS) ; to SRAM
ldi YH,high(CoTblS) ;
ldi tmp1,16 ; count 8 * 2-Byte coefficients
TbLoop:
lpm tmp2,Z+ ; fetch 1 byte from coefficient table
st Y+,tmp2 ; copy coefficient to Sram, increment Y
dec tmp1
brne TbLoop
ldi YL,low(DatTbl1) ; load SRAM-Pointer for Interrupt routine
ldi YH,high(DatTbl1) ;
sei ; enable interrupts

;*************************************************************************
;* Main program:
;*************************************************************************
Endless:
rjmp Endless ;

;*************************************************************************
;* ADC-Interrupt routine: compute filter and update PWM output
;*************************************************************************
ADCint:
sbi PortD,0 ; just to measure INT-Time
in savsrg,SREG ; save status register
;*************************************************************************

; allpass 2
load_node x10 ;
add_node y22 ; y22 +---+ y12 +---+
mult_32 k2 ; o--<-|1/z|<-o--|1/z|<---+
subtr_node x22 ; | +---+ +---+ |
limit_store y02 ; v |
load_node x12 ; x10 +---+ +---+ +---+ |
update_node x22 ; o-->| + |-->|*K2|--->| - |--->o--->
load_node x10 ; | +---+ +---+ + +---+ y02
update_node x12 ; | - A
lds datal,ADCL ; | +---+ +---+ |
lds datah,ADCH ; +----|1/z|--o->|1/z|->-o
dec datah ; | +---+ x12 +---+ x22
dec datah ; |
lsl datal ; +-----------+
rol datah ; +---+ |
lsl datal ; ADC >--|1/z|--+
rol datah ; +---+
lsl datal ;
rol datah ;
lsl datal ; convert 10 bit unsigned
rol datah ; to 15 Bit signed
lsl datal ; $03FF -> $01FF -> $3FE0
rol datah ; $0000 -> $FE00 -> $C000
lsl datal ;
rol datah ;
update_node x10 ; save new sample for 2nd allpass-chain
load_node y12 ;
update_node y22 ;
load_node y02 ;
update_node y12 ;

; allpass 4
add_node y24 ;
mult_32 k4 ; y24 +---+ y14 +---+
subtr_node x24 ; o--<-|1/z|<-o--|1/z|<---+
limit_store y04 ; | +---+ +---+ |
load_node x14 ; v |
update_node x24 ; y02 +---+ +---+ +---+ |
load_node y02 ; ->o-->| + |-->|*K4|--->| - |--->o--->
update_node x14 ; | +---+ +---+ + +---+ y04
load_node y14 ; | - A
update_node y24 ; | +---+ +---+ |
load_node y04 ; +----|1/z|--o->|1/z|->-o
update_node y14 ; +---+ x14 +---+ x24

; allpass 6
add_node y26 ;
mult_32 k6 ; y26 +---+ y16 +---+
subtr_node x26 ; o--<-|1/z|<-o--|1/z|<---+
limit_store y06 ; | +---+ +---+ |
load_node x16 ; v |
update_node x26 ; y04 +---+ +---+ +---+ |
load_node y04 ; ->o-->| + |-->|*K6|--->| - |--->o--->
update_node x16 ; | +---+ +---+ + +---+ y06
load_node y16 ; | - A
update_node y26 ; | +---+ +---+ |
load_node y06 ; +----|1/z|--o->|1/z|->-o
update_node y16 ; +---+ x16 +---+ x26

; allpass 8
add_node y28 ;
mult_32 k8 ; y28 +---+ y18 +---+
subtr_node x28 ; o--<-|1/z|<-o--|1/z|<---+
limit_store y08 ; | +---+ +---+ |
load_node x18 ; v |
update_node x28 ; y06 +---+ +---+ +---+ |
load_node y06 ; ->o-->| + |-->|*K8|--->| - |--->o--->
update_node x18 ; | +---+ +---+ + +---+ y08
load_node y18 ; | - A
update_node y28 ; | +---+ +---+ |
load_node y08 ; +----|1/z|--o->|1/z|->-o
update_node y18 ; +---+ x18 +---+ x28
load_node x10 ;
ldi YL,Low(DatTbl2) ;

; allpass 1
add_node y21 ;
mult_32 k1 ; y21 +---+ y11 +---+
subtr_node x21 ; o--<-|1/z|<-o--|1/z|<---+
limit_store y01 ; | +---+ +---+ |
load_node x11 ; v |
update_node x21 ; x10 +---+ +---+ +---+ |
load_node x10 ; ->o-->| + |-->|*K1|--->| - |--->o--->
update_node x11 ; | +---+ +---+ + +---+ y01
load_node y11 ; | - A
update_node y21 ; | +---+ +---+ |
load_node y01 ; +----|1/z|--o->|1/z|->-o
update_node y11 ; +---+ x11 +---+ x21

; allpass 3
add_node y23 ;
mult_32 k3 ; y23 +---+ y13 +---+
subtr_node x23 ; o--<-|1/z|<-o--|1/z|<---+
limit_store y03 ; | +---+ +---+ |
load_node x13 ; v |
update_node x23 ; y01 +---+ +---+ +---+ |
load_node y01 ; ->o-->| + |-->|*K3|--->| - |--->o--->
update_node x13 ; | +---+ +---+ + +---+ y03
load_node y13 ; | - A
update_node y23 ; | +---+ +---+ |
load_node y03 ; +----|1/z|--o->|1/z|->-o
update_node y13 ; +---+ x13 +---+ x23

; allpass 5
add_node y25 ;
mult_32 k5 ; y25 +---+ y15 +---+
subtr_node x25 ; o--<-|1/z|<-o--|1/z|<---+
limit_store y05 ; | +---+ +---+ |
load_node x15 ; v |
update_node x25 ; y03 +---+ +---+ +---+ |
load_node y03 ; ->o-->| + |-->|*K5|--->| - |--->o--->
update_node x15 ; | +---+ +---+ + +---+ y05
load_node y15 ; | - A
update_node y25 ; | +---+ +---+ |
load_node y05 ; +----|1/z|--o->|1/z|->-o
update_node y15 ; +---+ x15 +---+ x25

; allpass 7
add_node y27 ;
mult_32 k7 ; y27 +---+ y17 +---+
subtr_node x27 ; o--<-|1/z|<-o--|1/z|<---+
limit_store y07 ; | +---+ +---+ |
load_node x17 ; v |
update_node x27 ; y05 +---+ +---+ +---+ |
load_node y05 ; ->o-->| + |-->|*K7|--->| - |--->o--->
update_node x17 ; | +---+ +---+ + +---+ y07
load_node y17 ; | - A
update_node y27 ; | +---+ +---+ |
load_node y07 ; +----|1/z|--o->|1/z|->-o
update_node y17 ; +---+ x17 +---+ x27
;*************************************************************************
;* PWM - D/A-output
;*************************************************************************
; output y07 to PWM-DAC

;test: output y01
ldd accu3, Y+y01+1 ;
;
subi accu3,$80 ; signed to unsigned $8000 ->$0000, $7FFF ->$FFFF
sts OCR1AH,zero ;
sts OCR1AL,accu3 ; fast PWM 8 bit y07 output to OCR1A
ldi YL,Low(DatTbl1) ; back to 1st data table
; output y08 to PWM-DAC
; load_node y08 ; load y08

; test outpt y02
load_node y02 ; load y02
;
subi datah,$80 ; signed to unsigned $8000 ->$0000, $7FFF ->$FFFF
sts OCR1BH,zero ;
sts OCR1BL,accu3 ; fast PWM 8 bit y08 output to OCR1B
cbi PortD,0 ; just to measure INT-Time
out SREG,savsrg ; restore status register
reti ;
;*************************************************************************
;* coefficient table in flash memory
;*************************************************************************
CoTblF:
.dw 15709 ; k2 *32768 (0,4794008655888)
.dw 28712 ; k4 *32768 (0,8762184935393)
.dw 32001 ; k6 *32768 (0,9765975895082)
.dw 32686 ; k8 *32768 (0,9974992559356)
.dw 5301 ; k1 *32768 (0,1617584983677)
.dw 24020 ; k3 *32768 (0,7330289323415)
.dw 30977 ; k5 *32768 (0,9453497003291)
.dw 32460 ; k7 *32768 (0,9905991566845)

;*************************************************************************
;* data in SRAM
;*************************************************************************
.dseg
.org $0100
DatTbl1:
; "allpass" 0
.dw $0000 ; x10
; allpass 2
.dw $0000 ; x12
.dw $0000 ; x22
.dw $0000 ; y02
.dw $0000 ; y12
.dw $0000 ; y22
; allpass 4
.dw $0000 ; x14
.dw $0000 ; x24
.dw $0000 ; y04
.dw $0000 ; y14
.dw $0000 ; y24
; allpass 6
.dw $0000 ; x16
.dw $0000 ; x26
.dw $0000 ; y06
.dw $0000 ; y16
.dw $0000 ; y26
; allpass 8
.dw $0000 ; x18
.dw $0000 ; x28
.dw $0000 ; y08
.dw $0000 ; y18
.dw $0000 ; y28
CoTblS:
.dw $0000 ; k2
.dw $0000 ; k4
.dw $0000 ; k6
.dw $0000 ; k8
DatTbl2:
.dw $0000 ; k1
.dw $0000 ; k3
.dw $0000 ; k5
.dw $0000 ; k7
; allpass 1
.dw $0000 ; x11
.dw $0000 ; x21
.dw $0000 ; y01
.dw $0000 ; y11
.dw $0000 ; y21
; allpass 3
.dw $0000 ; x13
.dw $0000 ; x23
.dw $0000 ; y03
.dw $0000 ; y13
.dw $0000 ; y23
; allpass 5
.dw $0000 ; x15
.dw $0000 ; x25
.dw $0000 ; y05
.dw $0000 ; y15
.dw $0000 ; y25
; allpass 7
.dw $0000 ; x17
.dw $0000 ; x27
.dw $0000 ; y07
.dw $0000 ; y17
.dw $0000 ; y27
;*************************************************************************
</syntaxhighlight>
[[Kategorie:AVR-Projekte]]
[[Category:DSP]]

Hilbert-Transformator (Phasenschieber) mit ATmega

2015-10-15T09:44:33Z

134.169.116.89: Einige Rechtschreibkorrekturen

Dieser Artikel ist eine Fortsetzung von [[Digitalfilter mit ATmega]] und behandelt ein spezielles Digitalfilter namens Hilbert-Transformator.

Neben den üblichen Filtern, Tiefpass, Hochpass, Bandpass und Bandsperre, gibt es einige weitere Typen. In der Literatur findet man u.a. noch den Allpass, Phasenschieber, Integrator und Differentiator.

===Der Hilbert-Transformator, ein Breitband-90-Grad-Phasenschieber===

In den Lehrbüchern wird er völlig zu Unrecht eher am Rande abgehandelt. Tatsächlich findet man ihn in allen Schaltungen zur Datenübertragung, zu Modulation oder Demodulation mit I/Q-Mischern, im „Software-defined radio“.

Auch ein Hilbert-Transformator kann mithilfe von Scilab berechnet werden. Allerdings gibt es keine fertige Software, man muß sich durch einige Literatur hindurchfressen, z. B. ISBN 0471619957 Sanjit Mitra, Handbook for DSP (1993), Kapitel „Special Filter Designs“ von [http://faculty.cua.edu/regalia/ Phillip Regalia].

GNU Octave stellt die Hilbert-Transformation und den Parks-McClellan-hilbert-FIR-Filterentwurf im [http://octave.sourceforge.net/signal/function/remez.html octave-forge Paket "signal"] zur Verfügung.

Eine Fundgrube sind die Matlab-Texte von Prof. Schüssler, die vorab 1998 zum zweiten Band seines Lehrbuchs auf seiner Webseite veröffentlicht wurden. Inzwischen ist der erste Band in der fünften Auflage erschienen [http://www.springer.com/engineering/signals/book/978-3-540-78250-6 ISBN 9783540782506] , der zweite Band ISBN 9783642011184 2010 erstmalig erschienen, [http://www.lms.lnt.de/forschung/veroeffentlichungen/buecher/dsv.shtml Software-Download hier] aber die Webseite ist nach seinem Tod 2007 abgeschaltet. Zum Glück gibt es das
[http://web.archive.org/web/20041206171820/www.nt.e-technik.uni-erlangen.de/~hws/dsv2programs/index.html Webarchiv], wo die Texte noch zu finden sind.

Zu dieser Zeit waren die Matlab-Programme noch nicht in „Toolboxen“ untergebracht, deren Funktion von außen nicht mehr sichtbar ist. Daher lassen sie sich relativ einfach in Scilab oder Octave übersetzen.

Vier Versionen von Hilbert-Transformatoren werden hier berechnet:
* FIR-Hilbert, aufwendig, aber streng linearphasig, der bekannteste Typ, da schon lange mit dem Matlab-Befehl remez / firpm und Parameter 'hilbert' berechenbar. Mit dem octave-forge Paket "signal" ist remez mit "hilbert" verfügbar. Scilab kennt diesen Parameter nicht.
* näherungsweise linearphasiger IIR-Hilbert, maximal flach,
* näherungsweise linearphasiger IIR-Hilbert, Tschebyscheff
* minimalphasiger IIR-Hilbert, kompakt, aber mit großen Gruppenlaufzeitschwankungen, eher für Audioanwendungen als Digitalsignale.

Im Artikel von Schüßler/Steffen (siehe unten) sind in zwei vergleichenden Beispielen die Gruppenlaufzeitschwankungen des maximal Flachen etwa halb so groß, des Minimalphasigen etwa fünf Mal so groß wie die Tschbyscheff-Version.

Zumindest der kompakte IIR-Hilbert lässt sich auch in einem ATmega unterbringen. Er besteht aus einer Verzögerung und zwei Allpässen, die wieder aus SOS-Teilfiltern aufgebaut sind. Pro Teilfilter gibt es nur einen Koeffizienten, sodass man mindestens acht Teilfilter verwenden kann.

===Ein Hilbert-Kochrezept (noch unvollständig)===

Folgen wir dem Zahlenbeispiel und Berechnungsweg im „Handbook for DSP“.

Zuerst berechnen wir einen elliptischen ''Halbband''-Tiefpass. Halbband besagt, dass die beiden Grenzfrequenzen symmetrisch zur halben Nyquist- Frequenz also 0,25 * Abtastfrequenz liegen, siehe Bild oben rechts. Die genauen Bedingungen lauten in der Schreibweise des Buches (''p''=passband, ''s''=stopband):
* Omegas + Omegap = Pi (auf Omegasample normierte Skala: Samplerate=2*Pi)
* (1-Delta1)2 +Delta22=1

Als Zahlenwerte werden Omegas = 0,55*Pi und Delta2=0,01 gewählt, und damit ein elliptischer IIR-Tiefpass 7.Ordnung berechnet.
Damit erhält er folgende Zahlenwerte der Pole:

0 0,436688 0,743707 0,927758

===Scilab-Berechnung des Halbbandfilters===

Mit Scilab erhalten wir nach einigem Ausprobieren praktisch dieselben Zahlenwerte, siehe Bild. Die Pole müssten für ein ideales Halbbandfilter genau auf der imaginären Achse liegen, der Realteil genau Null sein (Der Fehler kommt daher, dass die Angabe von fstop vom Programm nicht berücksichtigt wird, das Filter wäre überbestimmt).
Diese Zahlen werden noch quadriert (''konjugiert komplexe'' Pole zusammengefasst) und bilden schließlich die Koeffizienten des Hilbert-Transformators.

[[Bild:Halbbandfilter.png|Mit Scilab berechnetes Halbbandfilter 7.Ordnung|640px]]

Die Übertragungsfunktion des gesuchten Hilbert-Transformators soll wie bisher H(z) heißen. Zur Unterscheidung nennen wir die bis jetzt berechnete Tiefpassfunktion G(z).

Wieder wird sie in SOS-Teilfilter aufgeteilt. Hier allerdings in die Summe von zwei parallel geschalteten ''Allpass''-Funktionen A1 und A2 plus eine Verzögerung um einen Sampletakt, in der Übertragungsfunktion als „z-1“ ausgedrückt.

Ein Allpass läßt alle Signalfrequenzen mit unveränderter Amplitude durch, verändert nur die Phase. Seine SOS-Teilfunktion ist besonders einfach aufgebaut, zwei Koeffizienten sind Null, zwei sind gleich Eins und die beiden restlichen identisch. Damit benötigt man nur eine Multiplikation pro Teilfilter.

Die Tiefpass-Übertragungsfunktion erhält so die Form:

'''G(z) = ½ * ( A1 (z2) + z-1 * A2 (z2))'''

mit

<math>
A_{1}(z^{2})=\frac{z^{-2}+0,190696}{1+0,190696\ast z^{-2}}\ast
{\frac{z^{-2}+0,860735}{1+0,860735\ast z^{-2}}}
</math>

<math>
A_{2}(z^{2})=\frac{z^{-2}+0,553100}{1+0,553100\ast z^{-2}}
</math>

Wenn man die beiden Ausgänge nicht addiert, sondern subtrahiert, entsteht ein Hochpass gleicher Grenzfrequenz. Beides kombiniert ergibt eine digitale ''Frequenzweiche''.

Zum Übergang auf den Hilbert-Transformator ersetzen (''substituieren'') wir das z durch -jz und multiplizieren das ganze mit 2:

H(z)= 2*G(-jz)

'''H(z) = A1 (-z2) + j* z-1 * A2 (-z2)'''

mit

<math>
A_{1}(-z^{2})=\frac{z^{-2}-0,190696}{1-0,190696\ast z^{-2}}\ast
{\frac{z^{-2}-0,860735}{1-0,860735\ast z^{-2}}}
</math>

<math>
A_{2}(-z^{2})=\frac{z^{-2}-0,553100}{1-0,553100\ast z^{-2}}
</math>

Wie man sieht, ändern sich nur die Vorzeichen. Die Pole liegen aber im Pol-Nullstellendiagramm auf der reellen Achse.

Die Ausgänge der beiden Allpässe sind jetzt gegeneinander um 90 Grad phasenverschoben, und können auf einen I/Q-Modulator gegeben werden. Umgekehrt kann man auch die beiden Eingänge auftrennen, und zwei um 90 Grad versetzte Signale aus einem I/Q-Demodulator einspeisen und die Ausgangssignale addieren oder subtrahieren, je nach gewünschtem Seitenband.

[[Bild:Allpaesse.png]]

Und weil das so gut funktionierte, hier noch die Berechnung des Hilbert-Transformators [http://www.mikrocontroller.net/topic/92630#new von Olli Niemitalo] mit einem Halbband-Tiefpass 17.Ordnung, was zu acht SOS-Teilfiltern führt, dazu folgt unten ein ATmega48-Programm.

[[Bild:Halbbandfilter2.png|Halbbandfilter 17.Ordnung|640px]]

===Der näherungsweise linearphasige Hilbert-Transformator===

Er wird im Handbook for DSP auf zwei Seiten sehr kurz abgehandelt. Statt aus zwei Allpässen besteht er aus einem einzigen, im anderen Zweig wird das Signal nur zeitverzögert, was mit einem Ringpuffer wenig Rechenzeit kostet. Eine Zeitverzögerung ist sozusagen die einfachste Form eines Allpasses, damit ist diese Bauform ein Spezialfall der oben gezeigten. Aus Schüsslers Texten erfahren wir noch, dass das Halbband-Tiefpassfilter zur Berechnung hier Tschebyscheff-Charakter haben muß.

Das Zahlenbeispiel zitiert Regalia aus einer anderen Veröffentlichung [http://www.cs.tut.fi/~mr/MRJulk92.html (M. Renfors and T. Saramäki, A class of approximately linear phase digital filters composed of allpass subfilters 1986 ) ] Der Allpass hat neun Koeffizienten, die Zeitverzögerung beträgt 17 Sampletakte. Der Halbband-Tiefpass hat eine Sperrdämpfung von > 49 dB. Sein Frequenzgang und der Phasengang des berechneten Hilbert-Transformators sind als Bild gezeigt.

Zum Allpass gibt es noch folgende Zahlenwerte:

Pole location for A(z) 
z= -0.8699928078 
0.491194141 ± j0.183666529 
0.252724179 ± j0.463085544 
-0.109950894 ± j0.548611467 
-0.447326028 ± j0.356810323 

Das könnte also ebenfalls noch in einen ATmega passen.

===Hilbert ohne Multiplizierer===

Eine interessante Variante wird im Artikel [http://kondor.etf.bg.ac.yu/~lutovac/pdf/eusi98lm.pdf Design of multiplierless elliptic IIR halfband filters and Hilbert transformers] vorgestellt. Ähnlich wie im Cordic-Algorithmus für trigonometrische Funktionen werden Multiplikationen vermieden, durch geschickte Wahl der Koeffizienten als Zweierpotenzen.

Die beiden Allpässe des Zahlenbeispiels haben folgende Übertragungsfunktionen:

<math>\begin{align}
A_1(z^{-2})
&=\frac{z^{-2}-0{,}12109375}{1-0{,}12109375 \cdot z^{-2}}
\cdot\frac{z^{-2}-0{,}6640625}{1-0{,}6640625 \cdot z^{-2}} \\
&=\frac{z^{-2}-(\frac18 - \frac1{256})}{1-(\frac18 - \frac1{256}) \cdot z^{-2}}
\cdot\frac{z^{-2}-(\frac12 + \frac18 + \frac1{32} + \frac1{128})}{1-(\frac12 + \frac18 + \frac1{32} + \frac1{128})\cdot z^{-2}}\\
\end{align}</math>

<math>\begin{align}
A_2(z^{-2})\cdot{z^{-1}}
&=z^{-1}
\cdot\frac{z^{-2}-0{,}390625}{1-0{,}390625 \cdot z^{-2}}
\cdot\frac{z^{-2}-0{,}890625}{1-0{,}890625 \cdot z^{-2}}\\
&=z^{-1}
\cdot\frac{z^{-2}-(\frac14 + \frac18 + \frac1{64})}{1-(\frac14 + \frac18 + \frac1{64}) \cdot z^{-2}}
\cdot\frac{z^{-2}-(1 - \frac18 + \frac1{64})}{1-(1 - \frac18 + \frac1{64}) \cdot z^{-2}}
\end{align}</math>

===Weitere Literatur zu Hilbert===
* Schüssler / [http://www.lnt.de/LMS/staff/index.php?lang=de&function=1&person=5 Steffen] "Halfband Filters and Hilbert Transformers" Irgendwo im Web hatte ich den vollständigen Artikel als PDF gefunden, leider die Adresse nicht notiert, Google findet nur [http://www.springerlink.com/content/p5480n6p8t73t633/ kostenpflichtige Downloads].
* Dutta / Kumar [http://eprint.iitd.ac.in/dspace/bitstream/2074/1608/1/roydig1989.pdf On Digital Differentiators, Hilbert Transformers, and Half-Band Low-Pass Filters] dank Schrifterkennungsprogramm leicht lädiert
* Miroslav Lutovac / Ljiljana Milic [http://www.telfor.rs/telfor2000/radovi/7-10.pdf Half-band IIR Filter Design Using Matlab], [http://kondor.etf.bg.ac.yu/~lutovac/confer.htm weitere Artikel der Autoren]
* Göckler / Damjanovic [http://www.dsv.rub.de/imperia/md/content/public/wsr06_goecklerdamjanovic.pdf A Family of Efficient Complex Halfband Filters]

===ATmega-Programm Hilbert-Transformer ( fast fertig, schwingt leider)===
Da der Adressenbereich des ATmega nicht groß genug ist, wird die Tabelle im SRAM in zwei Hälften geteilt.
<syntaxhighlight lang="avrasm">
;***************************************************************************
;* Hilbert transformer with ATmega48P, 90 degree broadband phase shifter *
;* 15 MHz xtal, input ADC0, PWM-output OCR1a/b, test output PD0 *
;* Christoph Kessler 2008 db1uq_at_t-online_dot_de *
;***************************************************************************
.nolist
.include "m48pdef.inc"
.list
;***************************************************************************
;* register 0-15 (no "immediate"-operations possible):
;***************************************************************************
.def mult_l = r0 ; multiplier result
.def mult_h = r1 ; multiplier result
.def zero = r2 ; zero register (used to add carry flag)
.def savsrg = r3 ; save status register during interrupt routine
.def reg04 = r4 ; free
.def reg05 = r5 ; free
.def reg06 = r6 ; free
.def reg07 = r7 ; free
.def reg08 = r8 ; free
.def reg09 = r9 ; free
.def reg10 = r10 ; free
.def reg11 = r11 ; free
.def reg12 = r12 ; free
.def accu0 = r13 ; Accumulator - 32bit for Interrupt routine
.def accu1 = r14 ; Accumulator - 32bit for Interrupt routine
.def accu2 = r15 ; Accumulator - 32bit for Interrupt routine
;***************************************************************************
;* register 16-23 ("immediate"-operations possible):
;***************************************************************************
.def accu3 = r16 ; Accumulator - 32bit for Interrupt routine
.def reg17 = r17 ; free
.def reg18 = r18 ; free
.def reg19 = r19 ; free
.def datal = r20 ; Data samples mul register
.def datah = r21 ; for Interrupt routine
.def coefl = r22 ; Filter coefficient mul register
.def coefh = r23 ; for Interrupt routine
;***************************************************************************
;* register 24-31 (16Bit-registers)
;***************************************************************************
.def tmp1 = r24 ; general temporary register
.def tmp2 = r25 ; general temporary register
; XL = r26 ; free
; XH = r27 ; free
; YL = r28 ; used by Interrupt routine
; YH = r29 ; used by Interrupt routine
; ZL = r30 ; init routine only, free for main program
; ZH = r31 ; init routine only, free for main program
;*************************************************************************
;* constants :
;*************************************************************************
;1st table:
;"allpass"0:
.equ x10 = 0
; allpass 2:
.equ x12 = 2
.equ x22 = 4
.equ y02 = 6
.equ y12 = 8
.equ y22 = 10
; allpass 4:
.equ x14 = 12
.equ x24 = 14
.equ y04 = 16
.equ y14 = 18
.equ y24 = 20
; allpass 6:
.equ x16 = 22
.equ x26 = 24
.equ y06 = 26
.equ y16 = 28
.equ y26 = 30
; allpass 8:
.equ x18 = 32
.equ x28 = 34
.equ y08 = 36
.equ y18 = 38
.equ y28 = 40

.equ k2 = 42
.equ k4 = 44
.equ k6 = 46
.equ k8 = 48
;2nd table:
.equ k1 = 0
.equ k3 = 2
.equ k5 = 4
.equ k7 = 6
; allpass 1:
.equ x11 = 8
.equ x21 = 10
.equ y01 = 12
.equ y11 = 14
.equ y21 = 16
; allpass 3:
.equ x13 = 18
.equ x23 = 20
.equ y03 = 22
.equ y13 = 24
.equ y23 = 26
; allpass 5:
.equ x15 = 28
.equ x25 = 30
.equ y05 = 32
.equ y15 = 34
.equ y25 = 36
; allpass 7:
.equ x17 = 38
.equ x27 = 40
.equ y07 = 42
.equ y17 = 44
.equ y27 = 46
;*****************************************************
;* Macros
;*****************************************************
.MACRO load_node
ldd datal,Y+@0 ; Load low byte of node
ldd datah,Y+@0+1 ; Load high byte of node
.ENDMACRO
.MACRO update_node
std Y+@0,datal ; Store low byte of node
std Y+@0+1,datah ; Store high byte of node
.ENDMACRO
.MACRO add_node
ldd coefl,Y+@0 ; Load 2nd node low
ldd coefh,Y+@0+1 ; Load 2nd node high
add datal,coefl ; Add low bytes
adc datah,coefh ; Add with carry high bytes
.ENDMACRO
.MACRO mult_32
ldd coefl,Y+@0 ; Load low byte of coefficient
ldd coefh,Y+@0+1 ; Load high byte of coefficient
muls coefh,datah ; Signed multiply, coefficient high byte and data high byte
mov accu2,mult_l ; Copy result word into accumulator byte 2:3
mov accu3,mult_h ; Copy result word into accumulator byte 2:3
mul coefl,datal ; Unsigned multiply, coefficient low byte and data low byte
mov accu0,mult_l ; Copy result word into accumulator byte 2:3
mov accu1,mult_h ; Copy result word into accumulator byte 2:3
mulsu coefh,datal ; Signed-unsigned multiply, coefficient high byte and data low byte
sbc accu3,zero ; Sign extention
add accu1,mult_l ; Add low byte of result to accumulator byte 1
adc accu2,mult_h ; Add with carry high byte of result to accumulator byte 2
adc accu3,zero ; Add carry to accumulator byte 3
mulsu datah,coefl ; Signed-unsigned multiply, data high byte and coefficient low byte
sbc accu3,zero ; Sign extention
add accu1,mult_l ; Add low byte of result to accumulator byte 1
adc accu2,mult_h ; Add with carry high byte of result to accumulator byte 2
adc accu3,zero ; Add carry to accumulator byte 3
.ENDMACRO
.MACRO subtr_node
ldd datal,Y+@0 ; Load 2nd node low
ldd datah,Y+@0+1 ; Load 2nd node high
sub accu0,datal ; Subtract low byte
sbc accu1,datah ; Subtract with carry high byte
sbc accu2,zero ;
sbc accu3,zero ;
.ENDMACRO
.MACRO limit_store
cpi accu3,$40 ; accu < $40000000 ?
brlo NoLimit1 ;
cpi accu3,-$40 ; accu >= -$40000000 ?
brsh NoLimit1 ;
clr accu2 ; accu2 = $00
cpi accu3,0 ;
brge PosLim1 ;
ldi accu3,$80 ; accu3 = $80
rjmp Limit1 ;
PosLim1:
ldi accu3,$7F ; accu3 = $7F
com accu2 ; accu2 = $FF
rjmp Limit1 ;
NoLimit1:
lsl accu1 ; Scaling to gain factor 2^16
rol accu2 ;
rol accu3 ;
Limit1:
std Y+@0,accu2 ;
std Y+@0+1,accu3 ;
.ENDMACRO
.LISTMAC
;*************************************************************************
;* reset/interrupt-vectors:
;*************************************************************************
.cseg
rjmp Initial ; after RESET to main program
reti ; External Interrupt Request 0
reti ; External Interrupt Request 1
reti ; Pin Change Interrupt Request 0
reti ; Pin Change Interrupt Request 1
reti ; Pin Change Interrupt Request 2
reti ; Watchdog Time-out Interrupt
reti ; Timer/Counter2 Compare Match A
reti ; Timer/Counter2 Compare Match B
reti ; Timer/Counter2 Overflow
reti ; Timer/Counter1 Capture Event
reti ; Timer/Counter1 Compare Match A
reti ; Timer/Counter1 Compare Match B
reti ; Timer/Counter1 Overflow
reti ; Timer/Counter0 Compare Match A
reti ; Timer/Counter0 Compare Match B
reti ; Timer/Counter0 Overflow
reti ; SPI Serial Transfer Complete
reti ; USART0, Rx Complete
reti ; USART0 Data register Empty
reti ; USART0, Tx Complete
rjmp ADCint ; ADC Conversion Complete
reti ; EEPROM Ready
reti ; 2-wire Serial Interface
reti ; Store Program Memory Read
;*************************************************************************
;* after reset: initialise stack,ports
;*************************************************************************
Initial:
ldi tmp1,Low(RAMEND)
out SPL,tmp1 ;
ldi tmp1,High(RAMEND)
out SPH,tmp1 ; stack initialised
clr zero ; always zero
ldi tmp1,$FF ;
out PortB,tmp1 ; PortB = % 1111 1111
out PortC,zero ; PortC = % 0000 0000
out PortD,tmp1 ; PortD = % 1111 1111
out DDRB,tmp1 ; PortB direction = % 1111 1111
out DDRC,zero ; PortC direction = % 0000 0000
out DDRD,tmp1 ; PortD direction = % 1111 1111
ldi tmp1,$A1 ; pos. outputs, fast PWM 8Bit
sts TCCR1A,tmp1 ;
ldi tmp1,$09 ; fast PWM 8Bit, clk/1 (no prescaling)
sts TCCR1B,tmp1 ;
sts OCR1AH,zero ;
sts OCR1AL,zero ;
sts OCR1BH,zero ;
sts OCR1BL,zero ;
ldi tmp1,$40 ; Ref=Vcc, right-adj, ADC0=input
sts ADMUX,tmp1 ;
ldi tmp1,$EE ; Start,Auto, enable Int, Clk/64
; ldi tmp1,$EF ; Start,Auto, enable Int, Clk/128
sts ADCSRA,tmp1 ;
ldi tmp1,$00 ; free running
sts ADCSRB,tmp1 ;
ldi tmp1,$01 ; disable ADC0 dig.inp (optional)
sts DIDR0,tmp1 ;
ldi ZL,low(CoTblF<<1) ; move filter coefficents
ldi ZH,high(CoTblF<<1) ; from program-flash
ldi YL,low(CoTblS) ; to SRAM
ldi YH,high(CoTblS) ;
ldi tmp1,16 ; count 8 * 2-Byte coefficients
TbLoop:
lpm tmp2,Z+ ; fetch 1 byte from coefficient table
st Y+,tmp2 ; copy coefficient to Sram, increment Y
dec tmp1
brne TbLoop
ldi YL,low(DatTbl1) ; load SRAM-Pointer for Interrupt routine
ldi YH,high(DatTbl1) ;
sei ; enable interrupts

;*************************************************************************
;* Main program:
;*************************************************************************
Endless:
rjmp Endless ;

;*************************************************************************
;* ADC-Interrupt routine: compute filter and update PWM output
;*************************************************************************
ADCint:
sbi PortD,0 ; just to measure INT-Time
in savsrg,SREG ; save status register
;*************************************************************************

; allpass 2
load_node x10 ;
add_node y22 ; y22 +---+ y12 +---+
mult_32 k2 ; o--<-|1/z|<-o--|1/z|<---+
subtr_node x22 ; | +---+ +---+ |
limit_store y02 ; v |
load_node x12 ; x10 +---+ +---+ +---+ |
update_node x22 ; o-->| + |-->|*K2|--->| - |--->o--->
load_node x10 ; | +---+ +---+ + +---+ y02
update_node x12 ; | - A
lds datal,ADCL ; | +---+ +---+ |
lds datah,ADCH ; +----|1/z|--o->|1/z|->-o
dec datah ; | +---+ x12 +---+ x22
dec datah ; |
lsl datal ; +-----------+
rol datah ; +---+ |
lsl datal ; ADC >--|1/z|--+
rol datah ; +---+
lsl datal ;
rol datah ;
lsl datal ; convert 10 bit unsigned
rol datah ; to 15 Bit signed
lsl datal ; $03FF -> $01FF -> $3FE0
rol datah ; $0000 -> $FE00 -> $C000
lsl datal ;
rol datah ;
update_node x10 ; save new sample for 2nd allpass-chain
load_node y12 ;
update_node y22 ;
load_node y02 ;
update_node y12 ;

; allpass 4
add_node y24 ;
mult_32 k4 ; y24 +---+ y14 +---+
subtr_node x24 ; o--<-|1/z|<-o--|1/z|<---+
limit_store y04 ; | +---+ +---+ |
load_node x14 ; v |
update_node x24 ; y02 +---+ +---+ +---+ |
load_node y02 ; ->o-->| + |-->|*K4|--->| - |--->o--->
update_node x14 ; | +---+ +---+ + +---+ y04
load_node y14 ; | - A
update_node y24 ; | +---+ +---+ |
load_node y04 ; +----|1/z|--o->|1/z|->-o
update_node y14 ; +---+ x14 +---+ x24

; allpass 6
add_node y26 ;
mult_32 k6 ; y26 +---+ y16 +---+
subtr_node x26 ; o--<-|1/z|<-o--|1/z|<---+
limit_store y06 ; | +---+ +---+ |
load_node x16 ; v |
update_node x26 ; y04 +---+ +---+ +---+ |
load_node y04 ; ->o-->| + |-->|*K6|--->| - |--->o--->
update_node x16 ; | +---+ +---+ + +---+ y06
load_node y16 ; | - A
update_node y26 ; | +---+ +---+ |
load_node y06 ; +----|1/z|--o->|1/z|->-o
update_node y16 ; +---+ x16 +---+ x26

; allpass 8
add_node y28 ;
mult_32 k8 ; y28 +---+ y18 +---+
subtr_node x28 ; o--<-|1/z|<-o--|1/z|<---+
limit_store y08 ; | +---+ +---+ |
load_node x18 ; v |
update_node x28 ; y06 +---+ +---+ +---+ |
load_node y06 ; ->o-->| + |-->|*K8|--->| - |--->o--->
update_node x18 ; | +---+ +---+ + +---+ y08
load_node y18 ; | - A
update_node y28 ; | +---+ +---+ |
load_node y08 ; +----|1/z|--o->|1/z|->-o
update_node y18 ; +---+ x18 +---+ x28
load_node x10 ;
ldi YL,Low(DatTbl2) ;

; allpass 1
add_node y21 ;
mult_32 k1 ; y21 +---+ y11 +---+
subtr_node x21 ; o--<-|1/z|<-o--|1/z|<---+
limit_store y01 ; | +---+ +---+ |
load_node x11 ; v |
update_node x21 ; x10 +---+ +---+ +---+ |
load_node x10 ; ->o-->| + |-->|*K1|--->| - |--->o--->
update_node x11 ; | +---+ +---+ + +---+ y01
load_node y11 ; | - A
update_node y21 ; | +---+ +---+ |
load_node y01 ; +----|1/z|--o->|1/z|->-o
update_node y11 ; +---+ x11 +---+ x21

; allpass 3
add_node y23 ;
mult_32 k3 ; y23 +---+ y13 +---+
subtr_node x23 ; o--<-|1/z|<-o--|1/z|<---+
limit_store y03 ; | +---+ +---+ |
load_node x13 ; v |
update_node x23 ; y01 +---+ +---+ +---+ |
load_node y01 ; ->o-->| + |-->|*K3|--->| - |--->o--->
update_node x13 ; | +---+ +---+ + +---+ y03
load_node y13 ; | - A
update_node y23 ; | +---+ +---+ |
load_node y03 ; +----|1/z|--o->|1/z|->-o
update_node y13 ; +---+ x13 +---+ x23

; allpass 5
add_node y25 ;
mult_32 k5 ; y25 +---+ y15 +---+
subtr_node x25 ; o--<-|1/z|<-o--|1/z|<---+
limit_store y05 ; | +---+ +---+ |
load_node x15 ; v |
update_node x25 ; y03 +---+ +---+ +---+ |
load_node y03 ; ->o-->| + |-->|*K5|--->| - |--->o--->
update_node x15 ; | +---+ +---+ + +---+ y05
load_node y15 ; | - A
update_node y25 ; | +---+ +---+ |
load_node y05 ; +----|1/z|--o->|1/z|->-o
update_node y15 ; +---+ x15 +---+ x25

; allpass 7
add_node y27 ;
mult_32 k7 ; y27 +---+ y17 +---+
subtr_node x27 ; o--<-|1/z|<-o--|1/z|<---+
limit_store y07 ; | +---+ +---+ |
load_node x17 ; v |
update_node x27 ; y05 +---+ +---+ +---+ |
load_node y05 ; ->o-->| + |-->|*K7|--->| - |--->o--->
update_node x17 ; | +---+ +---+ + +---+ y07
load_node y17 ; | - A
update_node y27 ; | +---+ +---+ |
load_node y07 ; +----|1/z|--o->|1/z|->-o
update_node y17 ; +---+ x17 +---+ x27
;*************************************************************************
;* PWM - D/A-output
;*************************************************************************
; output y07 to PWM-DAC

;test: output y01
ldd accu3, Y+y01+1 ;
;
subi accu3,$80 ; signed to unsigned $8000 ->$0000, $7FFF ->$FFFF
sts OCR1AH,zero ;
sts OCR1AL,accu3 ; fast PWM 8 bit y07 output to OCR1A
ldi YL,Low(DatTbl1) ; back to 1st data table
; output y08 to PWM-DAC
; load_node y08 ; load y08

; test outpt y02
load_node y02 ; load y02
;
subi datah,$80 ; signed to unsigned $8000 ->$0000, $7FFF ->$FFFF
sts OCR1BH,zero ;
sts OCR1BL,accu3 ; fast PWM 8 bit y08 output to OCR1B
cbi PortD,0 ; just to measure INT-Time
out SREG,savsrg ; restore status register
reti ;
;*************************************************************************
;* coefficient table in flash memory
;*************************************************************************
CoTblF:
.dw 15709 ; k2 *32768 (0,4794008655888)
.dw 28712 ; k4 *32768 (0,8762184935393)
.dw 32001 ; k6 *32768 (0,9765975895082)
.dw 32686 ; k8 *32768 (0,9974992559356)
.dw 5301 ; k1 *32768 (0,1617584983677)
.dw 24020 ; k3 *32768 (0,7330289323415)
.dw 30977 ; k5 *32768 (0,9453497003291)
.dw 32460 ; k7 *32768 (0,9905991566845)

;*************************************************************************
;* data in SRAM
;*************************************************************************
.dseg
.org $0100
DatTbl1:
; "allpass" 0
.dw $0000 ; x10
; allpass 2
.dw $0000 ; x12
.dw $0000 ; x22
.dw $0000 ; y02
.dw $0000 ; y12
.dw $0000 ; y22
; allpass 4
.dw $0000 ; x14
.dw $0000 ; x24
.dw $0000 ; y04
.dw $0000 ; y14
.dw $0000 ; y24
; allpass 6
.dw $0000 ; x16
.dw $0000 ; x26
.dw $0000 ; y06
.dw $0000 ; y16
.dw $0000 ; y26
; allpass 8
.dw $0000 ; x18
.dw $0000 ; x28
.dw $0000 ; y08
.dw $0000 ; y18
.dw $0000 ; y28
CoTblS:
.dw $0000 ; k2
.dw $0000 ; k4
.dw $0000 ; k6
.dw $0000 ; k8
DatTbl2:
.dw $0000 ; k1
.dw $0000 ; k3
.dw $0000 ; k5
.dw $0000 ; k7
; allpass 1
.dw $0000 ; x11
.dw $0000 ; x21
.dw $0000 ; y01
.dw $0000 ; y11
.dw $0000 ; y21
; allpass 3
.dw $0000 ; x13
.dw $0000 ; x23
.dw $0000 ; y03
.dw $0000 ; y13
.dw $0000 ; y23
; allpass 5
.dw $0000 ; x15
.dw $0000 ; x25
.dw $0000 ; y05
.dw $0000 ; y15
.dw $0000 ; y25
; allpass 7
.dw $0000 ; x17
.dw $0000 ; x27
.dw $0000 ; y07
.dw $0000 ; y17
.dw $0000 ; y27
;*************************************************************************
</syntaxhighlight>
[[Kategorie:AVR-Projekte]]
[[Category:DSP]]

SMD Löten

2010-03-13T21:26:41Z

134.169.116.89: /* Einlöten von SMD Bauteilen */ Tippfehler korr.

[[Category:Löten]]
== Einlöten von SMD-Bauteilen ==

Irgendwann ist man an dem Punkt angelangt, an dem man ein Bauteil braucht, das bloß in [[SMD]] verfügbar ist. [[TI]] zum Beispiel bietet seine [[MSP430]]-[[Mikrocontroller]] ausschließlich in [[SMD]] an. Das ist dann der Zeitpunkt an dem man sich fragt: "Wie lötet man sowas?" Nun, eigentlich ist es gar nicht so schwer, sobald man den richtigen Trick dabei mal raus hat.

=== Handlöten ===

==== Voraussetzungen ====

* Grundvoraussetzung ist ein Lötkolben mit entsprechender Lötspitze.
**Der Lötkolben sollte am besten der einer geregelten Lötstation sein. Die Einstellung der Lötstation sollte man halbwegs beherrschen. (Lötversuche an einer alten Platine sind in diesem Fall sehr hilfreich).
**Der Lötkolben sollte möglichst leicht und der vordere (heiße) Teil möglichst kurz sein. Je länger, desto mehr wird ein eventuelles Zittern der Hand verstärkt.
** Die Lötspitze sollte so dick sein, wie es noch gerade für die Aufgabe vertretbar ist. Nicht etwa die dünnste aufzutreibende Lötspitze. Was auf den ersten Blick widersprüchlich klingt (so dick wie es gerade noch geht), hat einen einfachen Grund: Die an der Spitze ankommende Wärme, die Wärmekapazität der Spitze und die Wärmeübertragung sind bei größeren Spitzen entsprechend besser. Daher geht das Löten mit einer größeren Spitze besser. Natürlich sollte man es nicht übertreiben, aber die 0,8-mm-Spitze ist häufig die falsche Wahl.
** Die Lötspitze sollte in einem guten bis erstklassigen Zustand sein.

* Außerdem braucht man noch Entlötlitze. Hier sollte man die dünnste nehmen, die man bekommen kann. Breiter als 1,5 mm sollte sie nicht sein, eher dünner. Hat man keine passende zur Hand oder herrscht Geldmangel, so lassen sich auch die feinen Litzen eines abisolierten, flexiblen Silikonkabels für diesen Zweck missbrauchen.

* Natürlich braucht man auch noch das Lötzinn, bestenfalls mit Flussmittel im Kern. 0,5 mm ist praktikabel, 0,23 mm ist bei kleinerem Pitch sehr zu empfehlen.

* Flüssiges Flussmittel in Stiftform mit eingebautem Pinsel oder Flussmittelgel aus der Spritze tun gute Dienste.

* Schließlich ist auch noch eine Leiterplatte (PCB) vonnöten. Hier hat man entweder die Möglichkeit, sich eine bei den verschiedenen PCB-Herstellern fertigen zu lassen oder sie selber zu belichten und zu ätzen. Besonders bei Chips mit kleinem Pin-Abstand hilft eine Lötstoppmaske und die Vorverzinnung der Pads; die kleine Menge Zinn, die bei industriell gefertigten Platinen auf den Pads ist, reicht völlig aus, man braucht dann kein oder nicht viel extra Lötzinn.

* Feine Pinzette. Billige tun es eher weniger.

* Eine Lupe. Diese dient in erster Linie zur Kontrolle. Löten ist unter einer einfachen Lupe eher unangenehm und ein Notbehelf, da die Perspektive verloren geht. Eine Lupenbrille (gute können recht teuer sein) oder ein Stereomikroskop (teuer bis sehr teuer) wäre zum Löten die bessere Wahl.

==== Löten von Widerständen, Kondensatoren und anderen 2-Pinnern ====

Es gibt diese Bauteile hauptsächlich in diesen Bauformen:
* 1206: Länge: 3,20 mm Breite: 1,60 mm (laufen langsam aus)
* 0805: Länge: 2,00 mm Breite: 1,25 mm
* 0603: Länge: 1,60 mm Breite: 0,80 mm (derzeit in der Industrie aktuell)
* 0402: Länge: 1,00 mm Breite: 0,50 mm (wird derzeit Standard in der Industrie)
* 0201: Länge: 0,50 mm Breite: 0,25 mm (Handy)
* 01005: Länge: 0,25 mm Breite: 0,13 mm (Handy)

Das Einlöten von 2-Pinnern ist sehr einfach. Es gibt eigentlich bloß einen kleinen Trick:

# Ein Pad auf der Leiterplatte verzinnen.
# Das Bauteil mit einer Pinzette in Endposition halten und leicht an beide Pads andrücken.
# Dabei das verzinnte Pad mit dem Lötkolben erwärmen. Das Bauteil ist nun einseitig eingelötet.
# Das zweite Pad normal löten.
# Anschließend evtl. das erste Pad nochmal kurz erhitzen.

Und schon hat man das Bauteil eingelötet.

Als Pinzette empfiehlt sich eine mit ca. 1 mm breiter Spitze, die als SMD-Pinzette (meist schwarz brüniert) ab ca. 10.- angeboten werden. Hier zu sparen lohnt nicht.

==== Lötpaste ====
ist eine Mischung aus Mg(OH)2 und Al2(Cl)3.

==== Löten von Bauteilen im SO-Package ====

Das Löten von Bauteilen im SO Package gestaltet sich fast genauso einfach wie das Löten von Widerständen:

# Ein Pad, das an einer Ecke des ICs liegt, verzinnen.
# Den IC platzieren.
# Den IC nach unten drücken.
# Das Pad erwärmen. Es ist möglich, dass der IC jetzt nicht richtig sitzt. Wenn das passiert ist, einfach nochmal das Zinn erwärmen und den IC verschieben bis er sitzt. Allerdings muss man dabei aufpassen, den IC nicht zu stark zu erwärmen.
# Das dem ersten gelöteten Pad diagonal gegenüberliegende Pad löten.
# Alle anderen Pads verlöten. Es ist nicht schlimm, wenn Zinnbrücken entstehen.
# Die Zinnbrücken mit Hilfe von Entlötlitze entfernen. Dazu hält man die Entlötlitze an die betroffenen Pads und erwärmt sie. Das Zinn geht dann automatisch auf die Entlötlitze und es gibt keine Brücken mehr.

==== Löten von (T)SSOPs und QFPs ====

War es bei Bauteilen im SO-Package mit einer ruhigen Hand noch möglich die Pins ohne Zinnbrücken zu verlöten, ist das bei TSSOPs nun praktisch nicht mehr möglich, da der Abstand der Pins einfach zu klein ist.

# Platzieren des Bauteils.
# Das Bauteil irgendwie fixieren (Pinzette oder vorsichtig mit dem Zeigefinger etc.) Tesafilm ist recht praktisch und lässt sich leicht wieder entfernen.
# Mit dem Lötkolben einen Tropfen Zinn aufnehmen (entfällt bei verzinnten Pads).
# Das Bauteil an zwei diagonal gegenüberliegenden Pins festlöten.
# Überprüfen, ob der Chip wirklich richtig auf der Platine liegt, jetzt sind Korrekturen noch möglich.
# Wenn man einen Stift mit flüssigem Flussmittel hat, auf der zu lötenden Seite damit einfach über alle Pins pinseln.
# Mit dem Lötkolben über die erste Seite des TSSOP fahren. Dabei spielt es keine Rolle, ob Brücken entstehen. Wenn man vorverzinnte Pads und Lötstopplack hat, entstehen normalerweise keine Brücken, da die Oberflächenspannung die geringe Menge Zinn an Pad und Pin sammelt, so dass es zu wenig Zinn für eine Brücke ist. Den Lötkolben mit einer Geschwindigkeit von ca. 1 - 2 Pins pro Sekunde vorwärts bewegen.
# Jetzt kann man das Bauteil loslassen, da es genügend fixiert ist.
# Mit dem Lötkolben über die andere(n) Seite(n) fahren.
# Mit Entlötlitze überflüssiges Zinn entfernen.
# Zum Abschluss kann man mit einer Lupe die Lötstellen überprüfen.

Bei QFPs ist das Verfahren gleich, außer dass man 4 Seiten bearbeiten muss.

Alternativ zur Entlötlitzentechnik gibt es auch Lötspitzen mit Hohlkehle.

# Zuerst das Bauteil an zwei diagonalen Pins mit Lötzinn fixieren und die Ausrichtung prüfen. Ob Lötbrücken entstehen, ist zu diesem Zeitpunkt nicht wichtig.
# Dann genügend Flussmittel über die zu lötenden Pins streichen.
# Die Hohlkehle mit wenig Lötzinn füllen und über eine Seite des ICs führen.
# Jetzt hat man an einigen Stellen (meist am Ende der Seite, die man gelötet hat) einige Lötbrücken.
# Die Hohlkehle von Lötzinn reinigen und mit leerer Hohlkehle über die Lötbrücken fahren. Vorher nochmal genug Flussmittel draufgeben.
# Meist sind schon nach dem ersten mal keine Brücken mehr vorhanden. Falls doch, nochmals mit Flussmittel benetzen und an den entsprechenden Stellen mit der Hohlkehlspitze Lötzinn entfernen.

Vorsicht! Flussmittel sind ätzend. Also nur bei eingeschalteter Lötdampfabsaugung arbeiten!

==== Der Trick mit der Entlötlitze ====

Bei kleinen SMD-Bauteilen kann es passieren, dass man beim Löten Zinnbrücken verursacht. Diese lassen sich recht einfach mittels Entlötlitze entfernen. Dabei sollte man direkt mit dem Ende der Litze entlöten und nicht der Mitte. Hilfreich kann bei wenig Platz auch ein schräges Anschneiden der Litze sein. Scharfe Schneidwerkzeuge, die ein Ausfransen der Litze verhindern, sind unverzichtbar (Tipp: SMD-Werkzeuge markieren, damit sie nicht versehentlich für grobe Arbeiten verwendet werden).

Es empfiehlt sich die Entlötlitze vorher leicht mit Flussmittel zu tränken, damit das Zinn besser aufgenommen werden kann.

Grundsätzlich sollte man beim Arbeiten mit Entlötlitze, ob an SMD- oder anderen Bauteilen, etwas Vorsicht walten lassen. Entlötlitze ist ein sehr guter Wärmeleiter. Daher kann man sich beim Entlöten, wenn man die Litze direkt mit den Fingern hält, böse verbrennen. Über 300° vom Lötkolben über die Litze zu den Fingern übertragen sind kein Pappenstiel. Leider kann das Führen der Litze mit einer Pinzette oder kleinen Flachzange gerade bei SMD-Bauteilen zu ungenau sein, so dass man verleitet wird, die Finger zu nehmen.

==== Trick 17 mit der Entlötlitze ====

Mit der "Invertierte-Entlötlitzen-Methode" kann man auch mechanisch empfindliche Pins auf sehr kleinem Raster '''verlöten''', indem man mit der Entlötlitze Lötzinn an das Pin/Pad-Paar zuführt. ([http://www.mikrocontroller.net/topic/94451#833286 Forumsbeitrag von Ulrich]).

=== Reflow-Techniken ===

Bei Reflow-Lötverfahren wird vor der Bestückung auf die Lötpunkte der Platine eine Lötpaste aufgetragen. Die Anschlüsse der zu lötenden Bauteile werden dann in diese Paste positioniert. Nach dieser Bestückung wird die Platine mit den Bauteilen erhitzt. Die Lötpaste schmilzt auf. Sind alle Lötpunkte aufgeschmolzen wird die Platine abgekühlt, das Lot erstarrt und die Bauteile sind verlötet.

Reflow-Techniken galten lange Zeit als zu aufwendig für Amateure. Dies änderte sich, nachdem sich gezeigt hat, dass auch etwas hemdsärmelige Methoden zum Ziel führen. Auch diese setzen etwas Aufwand voraus, daher sind sie im folgenden nur kurz beschrieben.

==== Lötpaste auftragen ====

In der industriellen Fertigung wird die Lötpaste zum Beispiel mittels einer Schablone aufgetragen. Eine Schablonenfertigung (Laser) ist für Einzelstücke zu aufwendig und zu teuer, daher bleibt die Lötpaste von Hand aufzutragen. Für diese Zwecke ist Lötpaste in Spritzen erhältlich. Die Preise für Lötpaste sind horrend. Mit ein bis zwei Euro pro Gramm(!) muss man rechnen. Allerdings benötigt man nur sehr geringe Mengen pro Platine und Lötpaste ist nicht unbegrenzt lagerbar. Es sollte eine "no clean"-Paste verwendet werden. "No clean" bedeutet, dass die Platine nicht von Flussmittelresten gereinigt werden muss.

Vor dem Auftragen der Paste ist die Platine zu säubern, und nochmal zu säubern, und nochmal ... Dann wird eine sehr kleine Menge der Paste auf jeden Lötpunkt aufgetragen.

==== Bauteile bestücken ====

Die Anschlüsse der Bauteile werden in die Lötpaste gesetzt. Bei bleihaltiger Lötpaste muss die Ausrichtung nicht 100% genau sein, da die Bauteile beim Schmelzen der Paste durch die Oberflächenspannung in Position gezogen werden. Bei bleifreier Lötpaste ist dieser Effekt kaum vorhanden. Daher müssen die Bauteile in diesem Fall genau ausgerichtet sein.

==== Umgebauter Pizzaofen ====

Als Standardmethode für Amateure scheint sich die Verwendung eines umgebauten Pizzaofen durchzusetzen. Ein Elektro-Pizzaofen/Miniofen für den Hausgebrauch für vielleicht 20€ bis 50€ wird mit einer Mikrocontroller-Temperatursteuerung versehen. Mit dieser Steuerung werden die gewünschten Heiz- und Abkühl-Temperaturkurven gesteuert. Beim Umbau ist Vorsicht zu walten lassen, da die Heizung und Temperaturregelung solcher Öfen mit Netzspannung erfolgt.

Aus Gesundheitsgründen sollte ein zum Reflow-Löten verwendeter Ofen nicht mehr für Nahrungsmittel verwendet werden.

==== Elektro-Pfanne ====

Statt eines mit einer Temperatursteuerung nachgerüsteten Pizzaofens wird gelegentlich einfach eine teflonbeschichtete Elektro-Pfanne verwendete. Elektro-Pfannen, manchmal auch Party-Pfannen genannt, sind in Deutschland eher selten in Haushalten zu finden. Es handelt sich dabei im Prinzip um eine Elektro-Heizplatte, die jedoch nicht flach, sondern deren Oberseite als Pfanne ausgeformt ist.

Zum Reflowlöten wird eine bestückte Platine in die kalte Pfanne gelegt, mit der Lötseite, also den Bauelementen nach oben. Die Pfanne wird aufgeheizt und dabei die Platine beobachtet, bis die Lötpaste an allen Lötpunkten aufgeschmolzen ist. Da eine Elektro-Pfanne nicht überall gleichmäßig heizt, wird gelegentlich vorsichtiges Schwenken der Platine in der Pfanne vorgeschlagen, um die Platine gleichmäßig zu erwärmen. Ist die Lötpaste überall aufgeschmolzen wird die Elektro-Pfanne abgestellt. Die Platine bleibt in der Pfanne und kühlt dort langsam mit der Pfanne aus.

Bei dieser Methode hat man keine Kontrolle über die Temperaturkurve. Selbige hängt nicht nur von der Bauart der Pfanne, sondern auch von der Umgebungstemperatur und der eigenen Reaktionszeit ab.

Aus Gesundheitsgründen sollte eine zum Reflow-Löten verwendete Elektro-Pfanne nicht mehr für Nahrungsmittel verwendet werden.

==== Heißluft ====

Die Geister scheiden sich daran, ob man mit Heißluft wirklich gut löten kann (beim Entlöten ist das anders). Viele bevorzugen noch den Lötkolben vor dem Heißluftgerät, andere haben mit Heißluftlöten keine Probleme.

Mit Heißluft lötet man eine Platine bereichsweise. Auf die Lötpads in einem Bereich werden kleine Mengen Lötpaste aufgetragen und die Bauteile aufgesetzt. Die Lötpaste wird dann mittels Heißluft erwärmt und geschmolzen. Dabei muss man sowohl aufpassen, dass Bauteile und Platine nicht überhitzt werden und dass man die in der Lötpaste sitzenden Bauteile nicht verschiebt oder sogar von der Platine bläst. Nebenbei muss man natürlich aufpassen, dass man sich nicht an der Heißluft verbrennt.

Entsprechende Heißluftgeräte (Hot-Air Stations, häufig auch Rework-Stations genannt), waren relativ teuer. Einige Marken sind mittlerweile jedoch für den Hobbyisten erschwinglich. Mit Übung lässt sich auch eine einfache Heißluft-Pistole verwenden. Allerdings ermöglichen deren Düsen kein sonderlich genaues Arbeiten.

==== Herdplatte ====

Mit etwas Erfahrung kann man auch sehr gut auf der Herdplatte löten. Die Herdplatte wird dabei rund eine halbe Stunde vorgeheizt, damit die Temperatur einigermaßen konstant bleibt. Mit etwas Lötzinn kann getestet werden, ob die Löttemperatur erreicht wurde. Die Herdplatte sollte nicht zu heiß eingestellt werden, damit der Lötstopplack sowie das Epoxyd nicht verheizt wird.
Die bestückte Platine wird mit einer Pinzette auf die Herdplatte gelegt. Schon nach kurzer Zeit sollte das Lötzinn anfangen zu schmelzen. Wenn alle Lötstellen verlötet sind, kann die Platine wieder heruntergenommen werden und abkühlen.

==== Kochtopf mit mehrschichtigem Boden ====

In vielen Küchen sind heute keine Gusseisenkochplatten mehr verbaut, sonder Glasskeramikkochfelder. Bei diesen darf die Platine nicht direkt beheizt werden, da diese schnell eine enorme Hitze erzeugen. Damit eine konstante Temperatur erhalten wird, kann ein Kochtopf mit einem mehrschichtigen Boden verwendet werden. Dazu wird die Platine in den Kochtopf gelegt und auf dem Glasskeramikkochfeld aufgeheizt. Ist die Lötpaste geschmolzen und alle Lötstellen verlötet, kann die Platte abgestellt und der Kochtopf zum Abkühlen zur Seite geschoben werden.

== Entlöten von SMD-Bauteilen ==

Leider halten ICs etc. nicht ewig und irgendwann muss jeder einmal SMD Bauteile wieder auslöten. Das Entlöten gestaltet sich im Grunde genauso einfach wie das Einlöten.

Es gibt zwei einfache Fälle: Entweder soll der Chip überleben oder die Platine. Der dritte Fall ist die erstrebenswerteste Methode: Chip und Platine überleben.

=== Die einfachste Methode ===

Die einfachste Methode ist ganz einfach den Lötkolben auf maximale Temperatur zu stellen und dann, mit etwas Lötzinn für besseren Wärmekontakt, auf die Mitte des auszulötenden ICs zu legen (mit der Spitze und dem Lötzinn darunter).

Der IC stirbt dabei durch die rund 400 Grad des Lötkolbens sicherlich den Hitzetod, aber durch die Wärmeleitung schmilzt an den Beinchen des ICs das Lötzinn nach rund einer Minute und man kann den IC mit einer Pinzette dann abheben. Hierzu sollte man alle paar Sekunden testweise anheben und den Lötkolben nur leicht aufdrücken, um so ganz sicher alle anderen Bauteile heil zu lassen.

Das auf der Platine verlaufene Lötzinn entfernt man, indem man mit der gereinigten Lötspitze (bei 200 Grad) über die nun geleerten Pads geht; Zubehör wie Entlötlitze ist überflüssig.

So kann man beispielsweise einen USB-RS232-Adapter in einen USB-UART-Adapter umwandeln ;-)

Getestet habe ich es bisher mit einem SD213 (28 Pins) und einem FT232 (32 Pins), aber etwas größere ICs, bis zum MSP430 mit 100 Pins, müssten auch möglich sein.
Durch Umdrehen der Platine sollten auch noch größere ICs so auslötbar sein (wobei man wegen der Schwerkraft dann die Pinzette einsparen kann), weil dann durch die Konvektion noch mehr Wärme übertragen wird.

=== Chip Quick-Methode ===
[http://www.chipquik.com/ Chip Quick] bietet ein Set an mit dem sich SMD-Bauteile sehr einfach und zerstoerungsfrei entloeten lassen.

Dabei wird auf die Beinchen reichlich Flussmittel aufgetragen. Dann eine große Menge speziellem Loetzinn aufgetragen, das eine sehr geringe Schmelztemperatur hat. Das verbindet sich mit dem Loetzinn und bleibt lange fluessig. Die Temperatur ist so gering, dass das Bauteil überlebt.
Wenn alle Beinchen in dem Loetzinn-Blob stehen, faellt das Bauteil fast von alleine ab.

Diese Methode wird in dem Make-Magazine Video gezeigt, das unten verlinkt ist.

Ich vermute, dass es sich bei der Chip Quick-Legierung um Wood'sches Metall (enthält Cadmium) oder wahrscheinlicher um die Rose-Legierung (Cadmiumfrei) handelt. Bei tmp-loettechnik.de bekommt man letzteres, allerdings nur als Barren. Mit dieser Legierung (Schmelzpunkt 98 °C) kann man auch Teile zur mechanischen Bearbeitung eingießen und im kochenden Wasser wieder befreien. "Flüssiger Schraubstock".

=== Die Zahnarztmethode ===

==== Benötigtes Werkzeug ====

* Lötkolben
* Lötzinn
* Ablöthebel
* Entlötlitze

==== Ablöthebel u.ä ====

Ein Ablöthebel oder verwandte Werkzeuge sehen so aus, als ob sie aus der Praxis eines Zahnarztes (Zahnsonde) oder der Werkstatt eines Zahntechnikers stammen. Dabei handelt es sich um Metallhaken, eventuell (in der einfachen, nicht medizinischen Ausführung) mit Plastikgriff. Es gibt sie in verschiedenen Formen und Größen.

Als Werkzeug zum Entlöten findet sich eine Form unter der bereits erwähnten Bezeichnung ''Ablöthebel'', ebenso findet man ähnliche Werkzeuge als Teil von sogenannten ''Platinen-Reinigungsbestecken'' (Beispiel Conrad Bestellnummer 588239). Im Englischen heißen entsprechende Werkzeuge ''soldering aid hook'' (Haken), ''soldering aid fork'' (Haken/Hebel mit gespaltener Klinge. Wenn als Hebel ausgeführt ein ''Ablöthebel''), oder ''soldering aid spike'', ''reamer'' oder ''probe'' (gebogene oder ungebogene Tastspitze).

Ein solcher Hebel oder Haken ist ein nützliches Werkzeug beim Auslöten von SMD Bauteilen. Vorsichtig eingesetzt kann er durchaus beim zerstörungsfreien Entlöten verwendet werden, zum Beispiel bei der Verwendung von [[#Heißluft|Heißluft]]. Im Folgenden wird allerdings eine zerstörende Methode beschrieben.

==== Der Entlötvorgang ====

Das Entlöten ist bei fast allen SMD-Bauteilen gleich, egal welcher Pinabstand und wie viele Pins. '''Achtung''', der IC geht dabei kaputt.

# Man bringt eine dicke Zinnwurst auf alle Pins auf.
# Erwärmen des Zinns mit dem Lötkolben.
# Ausheben der Pins mithilfe des Hebels oder Hakens. Hier kann man bei den Bauteilen mit kleinem Pinabstand gleichzeitig mehrere hochheben.
# Solange wiederholen, bis alles raus ist.
# Entfernen der Zinnreste mit Entlötlitze.

=== Die 2-Lötkolben-Methode ===

Diese Methode eignet sich für alle SMD-Bauteile mit 2 gelöteten Seiten: Widerstände, Kondensatoren, kurze ICs (z.B. 2x8 Pins). Bei den Widerständen und Kondensatoren ist alles klar. Von jeder Seite einen Lötkolben anhalten, das Bauteil löst sich ab und bleibt meist an einem der Kolben kleben, wo man es abschütteln kann. Bei ICs verzinnt man zunächst beide Pin-Reihen ordentlich, danach versucht man mit den Kolben das Zinn auf beiden Reihen und der gesamten Länge flüssig zu bekommen, evtl. muss man die Lötkolben dabei etwas bewegen. Ist das Zinn komplett flüssig, kann man das IC beiseite schieben. Das geht besonders gut bei Platinen mit Lötstopplack. Bei dieser Methode kann man die Bauteile in der Regel anschließend weiter verwenden, überflüssiges Zinn an den Pins mit Lötsauglitze entfernen.

=== Die Rohrstückmethode ===

Diese Methode eignet sich für ICs mit Pins an zwei Seiten (SO-Gehäuse). Chip und Platine haben Chancen zu überleben. Man nehme ein Stück Kupferrohr der passenden Länge und sägt es der Länge nach durch, so dass man zwei Halbschalen hat. Eine der Halbschalen befestigt man an einer alten Lötspitze, z.B. indem man ein Gewinde schneidet oder hartlötet. Nun kann man alle Pins gleichzeitig erwärmen und das IC abnehmen.

=== Die Kupferdraht-Haken-Methode ===

Die Methode funktioniert ähnlich wie die zuvor beschriebenen ''Rohrstückmethode''. Das Erstellen des Hilfsmittels ist wesentlich einfacher, allerdings ist es keine Dauerlösung. Die Methode eignet sich für kleine Bauteile (Widerstände, etc.) mit Pins an zwei Seiten.

Das Ende eines Stück blanken Kupferdrahts wird mittels einer kleinen Flachzange zu einem U-förmigen Haken abgebogen. Dabei wählt man die Lichte Weite des Hakens so, dass man mit zwei Seiten des Hakens die Pins des zu entlötenden Bauteils gleichzeitig erreichen kann. Das andere Ende des Kupferdrahts wickelt man mehrfach um die Spitze eines kalten(!) Lötkolbens. Das Ende mit dem Hacken sollte dabei nicht mehr als vielleicht 2 cm über die Lötkolbenspitze hinausreichen und der Draht wird so gebogen (gekröpft), dass man den Lötkolben bequem führen kann um den Haken flach am Bauteil anzulegen. Um Missverständnisse zu vermeiden, der Haken soll am Bauteil angelegt und nicht etwa in irgendeiner Weise unter das Bauteil geschoben werden.

Nun wird der Lötkolben und damit der Haken erhitzt. Ist die Hakenspitze heiß genug, legt man den Haken am Bauteil an. Sobald das Lötzinn an den Pins geschmolzen ist zieht man das Bauteil von den Pads. Bauteile haben dabei die Angewohnheit für immer auf dem Fußboden verloren zu gehen. Benötigt man das Teil noch, so sollte man etwas Vorsicht walten lassen.

=== Die dicke Kupferdrahtmethode ===

1,5 - 2,5 mm² Massivdraht so zurechtbiegen, dass er exakt und plan auf die Pins passt. Dann mit viel Zinn schnell verlöten. Das geht am besten mit zwei oder drei stärkeren Lötkolben und einer zweiten Person. Ich habe aber auch schon alleine mit 2 Kolben 160-Poler ausgelötet, ohne IC oder Platine zu beschädigen.

IC am besten mit einer Pinzette oder einem Vakuumsauger (z.B. Kontaklinsensauger für harte KL aus Silikon) abheben und noch im heißen Zustand den dicken Draht samt Zinn abklopfen. Danach das IC möglichst schonend (gleichmäßig und schnell) abkühlen, evtl. schon vor dem Löten einen kleinen Kühlkörper auf das IC legen / kleben.

Die Methode kombiniert sich gut mit der Bügeleisen- oder Ceranfeld-Vorwärm-Methode.

=== Der Trick mit dem Platinensicherungshalter ===

Speziell zum Auslöten von SO-ICs mit 2x4 Beinchen kann man den einzelnen Clip eines Platinensicherungshalters (Durchstecktechnik, für 5 x 20 mm Sicherungen) benutzen. Mit einer feinen Zange biegt man zunächst die sich nach außen öffnenden Enden des Clips etwas nach innen. Auf diese Weise entsteht eine Mini-Zange, die genauso breit ist wie die Beinreihe des IC und sich aufgrund ihrer Vorspannung am IC festhalten kann. Den modifizierten Clip klemmt man von oben über den IC und erhitzt seine Bodenplatte mit dem Lötkolben (16W). (Anstelle der oben beschrieben Zinn-Wurst-Methode bildet nun der Clip die Wärmebrücke, ähnlich der oben beschriebenen Rohrstückmethode) Der Clip wird mit einer Pinzette abgehoben und nimmt den IC mit.

Die Platine und der IC bleiben ganz.

=== Lötkolbeneinsätze ===

Für einige SMD-Bauformen gibt es Lötkolbeneinsätze, mit denen man alle Anschlüsse eines Bauteils gleichzeitig erhitzen kann. Allerdings sind diese relativ teuer, man braucht für jede Bauform einen eigenen Einsatz und es gibt IC-Bauformen, bei denen die Anschlüsse so angeordnet sind, dass man dafür keinen Einsatz bauen kann.

=== Zangenlötkolben ===

Ein Zangenlötkolben (auch engl. ''Tweezer'') genannt, ist ein Lötkolben, der zwei beheizte Spitzen besitzt, die ähnlich wie bei einer Pinzette verbunden sind, und der wie eine Pinzette bedient wird. Die Spitzen sind als flache, Einsätze gestaltet, die ggf. je nach Breite des auszulötenden Bauteils ausgetauscht werden können. Mit dem Zangenlötkolben kann man sehr einfach Anschlüsse von Bauteilen mit zwei gegenüberliegenden Anschlüssen (Widerstände, etc.) oder Anschlussreihen erhitzen und das Bauteil dann direkt mit dem Zangenlötkolben von der Platine nehmen. Es empfiehlt sich dabei, eine zusätzliche Pinzette zur Hand zu nehmen, um das Bauteil von der Platine zu heben, da teilweise maschinell bestückte SMD mit einem Klebepunkt auf der Platine fixiert werden.

Ein Nachteil beim Entlöten mit dem Zangenlötkolben ist, dass das entlötete Bauteil relativ lange erwärmt wird, da es mit der Zange abgehoben und dann weiter erwärmt wird, bis man es aus der Zange entfernt. Ein weiterer Nachteil ist, dass sich der Zangenlötkolben nur für zweireihige Bauteile eignet.

Der große Vorteil des Zangenlötkolbens ist die schnelle und einfache Funktion. Muss man mehrere Widerstände gleicher Bauform von einer Platine entfernen, kann dieses sogar ohne Absetzen in einem Durchgang geschehen. Die bereits entlöteten Widerstände behält man dabei einfach zwischen den Zangenbacken und schiebt sie mit dem nächsten Widerstand etwas nach hinten.

=== Kupferlackdraht ===

Eine weitere sehr elegante Möglichkeit um auch grössere SMD-ICs zerstörungsfei von einer Platine zu bekommen, ist die "Kupferlackdraht-Methode". Man benötigt lediglich etwas Kupferlackdraht (0,2 - 0,3 mm) und natürlich einen Lötkolben. Die einzige Bedingung ist, dass man den Kupferlackdraht auch unter den Pins bzw. dem Bauteilgehäuse durchfädeln kann.

==== Vorgehensweise ====

# Kupferlackdraht unter den Pins durchfädeln
# Jeden einzelnen Pin kurz mit dem Lötkolben leicht berühren und gleichzeitig den Kupferlackdraht zwischen Platine und Pin durchziehen
# Eventuell den Kupferlackdraht erneut unter den Pins durchfädeln und die Pins, bei denen der Kupferlackdraht beim Durchziehen "hängen bleibt", nochmals mit dem Lötkolben antippen

Es gibt aber auch dünnen Stahldraht (D=0,2 mm) für diesen Zweck zu kaufen.
Das Optimum ist dünnes Bandblech aus Edelstahl, ca 4 - 5 mm breit, ebenfalls etwa 0,2mm dick. Die in akustomagnetischen Warensicherungsetiketten enthaltenen Blechstreifen eignen sich gut. Auch einen Skalpellhalter mit Einmalklingen kann man hierfür verwenden. Die Spitze des Skalpells wird hinter dem Pin angesetzt (in der Lücke zwischen Pin und Gehäuse), nach unten und vorn gedrückt und der Pin mit dem Lötkolben erwärmt. Sobald das Lötzinn geschmolzen ist, rutscht das Skalpell zum nächsten Pin weiter. Hinterher müssen lediglich die Pins wieder geradegebogen werden.

=== Mechanisch abtrennen ===

==== Die Cuttermethode ====

Eine weitere Möglichkeit, ein SMD IC von einer Platine zu entfernen, ist es die Beinchen vor dem Entlöten zu durchtrennen. Dazu nimmt man ein Cuttermesser mit Abbrechklingen oder ein Bastelmesser mit auswechselbarer Skalpellklinge (z.B. X-Acto Klinge #16, #17 oder #19), setzt es so nah wie möglich am Gehäuse auf ein paar der IC-Beinchen auf und drückt gerade '''ohne Seitwärtsbewegung''' nach unten. Dies durchtrennt die Beine ohne darunterliegende Leiterbahnen zu verletzen. Ein wenig Gefühl ist dabei natürlich nötig. Üben auf einem alten PC Mainboard lohnt sich. Nachdem auf diese Weise alle Beine vom IC abgetrennt sind, kann man die auf der Platine verbliebenen Reste der Beinchen einfach mit dem Lötkolben "abwischen" und die Lötzinreste mit Entlötlitze entfernen. Die Wärmebelastung der Platine ist bei dieser Methode wesentlich geringer, allerdings besteht die latente Möglichkeit Leiterbahnen zu durchtrennen.

'''Anmerkung:''' Es hat sich dabei bewährt, vorher alle Pins mit einer relativ dicken Schicht Lötzinn zu verbinden. So werden abgerissene Leiterbahnen durch versehentliche Seitwärtsbewegungen verhindert. Es muss allerdings darauf geachtet werden, dass das Lötzinn nicht ganz bis ans Gehäuse reicht, da sonst das Schneiden nahezu unmöglich ist.

==== Die Mini-Trennscheiben-Methode ====

Man nehme eine sehr schnelle, kleine Handbohrmaschine (Proxxon, Dremel oder dergleichen), setze eine kleine Trennscheibe auf und flexe unter der Lupenbrille vorsichtig die Beinchen nahe dem Gehäuse ab. Das Gehäuse fällt irgendwann ab, die Beinchen werden mit einem Lötkolben weggewischt.

==== Die Abschlagmethode ====

Wenn man SMD ICs von einer Platine retten möchte, die Platine aber später in den Müll wandert, kann man das IC mit seinem Körper auch auf eine harte Kante legen (die Platine ist dabei mehr oder weniger senkrecht). Dann ein beherzter Schlag mit dem Handballen auf die Platinenkante und der Chip wird von der Platine abgerissen. Die Beinchen muss man nachher etwas richten, aber normalerweise funktioniert diese Methode sehr zuverlässig, besonders bei maschinell gelöteten Platinen. Diese Methode funktioniert sowohl mit SO-Gehäusen als auch mit radiergummigroßen DC/DC Wandlern.

==== Alternative: Die Stechbeitelmethode ====

Hier gilt das gleiche Prinzip wie bei der Abschlagmethode: Zuerst knicken die Beinchen ein und reißen dann von den Leiterbahnen ab. Sie lassen sich aber leicht zurückbiegen und das IC wird garantiert nicht überhitzt. Der Beitel sollte ca. 8 - 15 mm breit sein, ein alter, angeschliffener Schraubendreher mit großem Griff tut's auch. Dann die Platine flach vor sich auf den Tisch legen, das IC liegt senkrecht zur Tischkante. Den Beitel senkrecht zur Platine mit der flachen Seite an das IC anlegen, die linke Ecke der Schneide liegt dabei auf der Stirnseite in Höhe der Mittellinie, die rechte Ecke der Schneide wird als Widerlager in die Platine gepresst. Den Beitel dafür etwas nach rechts kippen, mit Gewicht fest in die Platine drücken und mit Gefühl im Uhrzeigersinn drehen. So wird das IC in Längsrichtung und parallel zur Platine weggehebelt. Die benötigte Kraft kann man sehr gut dimensionieren. Wenn man das raus hat, braucht man ca. 1 - 2 Sekunden pro IC.

=== Heißluft ===

Heißluft ist eigentlich das Mittel der Wahl für SMD-Entlöten. Heißluft erfordert etwas Übung, egal welche Methode man im Einzelfall anwendet. Das Arbeiten mit einer Speziell für die Elektronik gemachten Heißluftstation ist dabei am bequemsten, daher wird es zuerst genannt.

==== Heißluftstation / Hot-Air Station / Rework-Station ====

Heißluftgeräte waren früher relativ teuer. Einige Marken, meist chinesische Produkte, sind mittlerweile jedoch für den Hobbyisten erschwinglich (ab ca. 60 bis 70 Euro aufwärts, Stand 2009) und brauchbar, auch wenn es einen deutlichen Unterschied zwischen diesen Produkten und High-End-Geräten gibt. So sind die Handgriffe wesentlich unhandlicher und die Regelung ist ungenauer. Trotzdem kann man mit den einfachen Geräten vernünftig arbeiten.

Theoretisch sollte man zum Entlöten jeweils einen genau auf die Bauform des Bauteils passenden Heißluft-Einsatz verwenden. Nun gibt es allerdings sehr viele unterschiedliche Bauformen und je nach Station sind die Einsätze relativ teuer (ausgenommen vielleicht die für chinesische Produkte, die meist alle vergleichbare und bezahlbare 22 mm Einsätze haben). Daher ist es nicht unüblich, für viele Anwendungen einfach eine runde 5 mm Düse zu verwenden, wie sie normalerweise schon in der Grundausstattung einer Heißluftstation enthalten ist.
Die Pins eines Bauteils erhitzt man dann mit einer kreisförmige Bewegung aus ca. 2 cm Abstand. Dabei prüft man immer mal wieder mit einer Pinzette oder ähnlichem Werkzeug ob sich das Bauteil schon abheben lässt. Dabei sollte man das Werkzeug nicht ständig in den Luftstrom halten, da es dabei eventuell zu heiß werden kann.

An einer Heißluftstation gibt es zwei wichtige Einstellungen:
* Temperatur
* Luftstrom

Mit beiden Einstellungen muss man etwas üben. Zum Start kann man es mit ca. 400 Grad und ca. 20 l/min versuchen.

Neben dieser einfachen Methode (rumkreisen bis was geht), gibt es relativ aufwendige Verfahren beim Arbeiten mit Heißluft, zum Beispiel muss bei bestimmten Trägermaterialien die Platine vorgeheizt werden. Ohne entsprechende Schulung ist es schwer sich solche Methoden selber anzueignen.

==== Gaslötkolben mit Heißluftdüse ====

Man kaufe für ca €60 einen Gaslötkolben mit Heißluftdüse. Wenn man den Gaslötkolben mit Heißluftdüse auf volle Leistung stellt, soll dieser angeblich bis 600 Grad Warmluft abgeben, was mehr als genug zum Entlöten ist. Damit SMD Bauteil durch kreisförmige Bewegung rundherum an den Pins mit 2 cm Abstand gezielt erhitzen. Das dauert ca. 2 Minuten. Das Bauteil lässt sich dann abnehmen, wegschieben oder abschlagen. Teilweise werden wenige eng am Bauteil bestückte Blockkondensatoren ebenfalls ausgelötet.

Es lassen sich SMD's jeder Größe und Pinabstand ohne Beschädigung auslöten. Die ausgelöteten Bauteile lassen sich problemlos wieder verwenden. Die Platine mit Lötsauglitze und Aceton säubern und neues Bauteil drauf. Habe so während der Entwicklung FPGAS und Treiber IC's auf einer Platine schon bis zu fünf mal getauscht.

==== Heißluftpistole ====

Eine Heißluftpistole, wie man sie im Baumarkt zum Abbrennen alter Farbe u.ä. kaufen kann, kann gute Dienste beim SMD-Löten leisten. Empfehlenswert sind solche mit Temperaturregler, aber selbst die einfachsten Varianten (die in der Regel nur zwei Stufen haben, mit denen man sowohl die Gebläsegeschwindigkeit als auch die Heizleistung umschaltet) sind für viele Zwecke brauchbarer, als man auf den ersten Blick annehmen würde.

Einfach Platine einspannen und mit der Heißluftpistole langsam und gleichmäßig erwärmen. Dabei nicht zu heiß arbeiten, etwas mehr Zeit für die Arbeit schadet Platine und Bauteilen weniger, als mit zu großer Temperatur alles zu verbrennen. Wenn man vorsichtig arbeitet und den Punkt gut herausfindet, an dem sich das fragliche Bauteil ablösen lässt, taugt die Methode sogar für Reparaturlötungen, d.h. sowohl Platine als auch Bauteil bleiben dabei ganz. Damit ist die Methode auch durchaus geeignet, alten Elektronikschrott zu recyclen, um auf diese Weise preiswert zu einem Grundstock an diversen SMD-"Hühnerfutter" (Widerstände, Kondensatoren, oft auch Tantal-Elkos) sowie teilweise auch Standard-ICs (74xxx, LM358 u.ä.) zu gelangen.

Vermutlich lassen sich Pertinax-Platinen danach nicht mehr verwenden, aber diese haben bei den schmalen Leiterzugbreiten von SMD ohnehin kaum eine Überlebenschance. Besser gleich trotz des höheren Preises alles auf Epoxyd anfertigen -- gerade bei den hobbytypischen Einzelstücken ist andernfalls die verschwendete Arbeitszeit sehr viel ärgerlicher als der höhere Preis der Epoxyd-Platine.

'''Tipp:''' Die Platine mit einem Stück Alufolie so abdecken, dass nur das auszulötende Bauteil im Luftstrom ist (an der Stelle ein Loch in die Folie machen).

Falls das Überleben der Platine wirklich völlig egal ist, kann man auch die Rückseite der Platine mit der Heißluftpistole erhitzen, bis die Vorderseite so heiß ist, dass die SMD-Chips einfach abfallen. Zwei Vorteile ergeben sich aus diesem Verfahren für die Überlebenswahrscheinlichkeit der Bauteile:

* Der Temperaturgradient ist so gerichtet, dass die Beine des Chips die höchste Temperatur haben und nicht der Chip selbst, wenn man von oben auf das Gehäuse bläst
* Die, wenn auch geringe, Wärmeleitung der Platine sorgt für eine gleichmäßigere Temperaturverteilung auf der Vorderseite.

Von Nachteil allerdings ist, dass die Platine evtl. auf der Rückseite so heiß wird, dass sie anfängt, sich zu zersetzen. Das ist sicherlich nicht gesund und daher sollte man hier vorsichtig sein (langsam erhitzen, frische Luft).

Alternativ geht es auch mit der Heißluftdüse eines Gaslötkolbens (z.B. von Ersa). Dabei geht man zügig mit dem heißen Luftstrom über die Pins des ICs und erwärmt sie, bis sich das IC gewaltfrei abheben lässt. Richtig gemacht überleben IC und Platine.

=== Komplette Platine erhitzen ===

Wenn man alle Bauteile von einer Platine auf einmal ablösen möchet bietet es sich an, die gesamte Platine mit den Bauteile so weit zu erhitzen bis das Lot überall geschmolzen ist. Die Bauteile können dann mit einen Schlag von der Platine abgeschlagen werden.

==== Reflow-Ofen ====

Was zum Löten taugt, taugt auch zum Entlöten. Die Platine mit den Bauteilen wird im Reflow-Ofen erhitzt.

==== Backofen ====

Wie in Reflow-Ofen. Man sollte sich allerdings gut überlegen, ob man das in einem Ofen der noch für Nahrungsmittel verwendet wird, machen sollte.

==== Gasherdmethode ====

Auf einer einseitig bestückten SMD-Platine kann man Bauteil und Platine zerstörungsfrei wie folgt trennen: Von der großen Gasflamme die Abdeckung herunternehmen, diese Abdeckung z.B. mit Hilfe des Halters für kleine Töpfe über die kleine Gasflamme legen (natürlich geht das auch mit einem anderem Stück Metall, Hauptsache gerade) und dann mit der kleinen Gasflamme die Metallplatte/Abdeckung darüber erwärmen. Mit einem Stück Lötzinn probieren, ob es schon heiß genug ist (Lötzinn muss schmelzen, perlen und abtropfen).

Wenn ja: Flamme ausmachen, Platine mit der nicht bestückten Seite auf das heiße Metall drücken, ein paar Sekunden warten, bis die Wärme von unten durch die Platine gewandert ist, und das Bauteil mit einer Pinzette abnehmen. Getestet mit Epoxyd-Platine. Sie hat überlebt, nur etwas dunkel verfärbt. Es empfiehlt sich, mit einer unkritischen Platine etwas zu üben.

==== Bügeleisenmethode ====

Ein Bügeleisen umgekehrt in einen Schraubstock spannen, eventuell mit einem
Tuch am Griff vor Kratzern schützen und die Gleitfläche mit Alufolie abdecken - um Ärger mit der besseren Hälfte zu vermeiden ;-) Auf maximale Temperatur stellen (Leinen), Platine mit der nicht bestückten Seite auflegen und warten, bis das Lot flüssig wird. Bauteile mit einer Pinzette abheben. Platine nach und nach verschieben um alle Stellen zu erhitzen.

==== Ceran-Herd ====

Geht nur bei einseitig bestückten Platinen!

Ähnelt der Bügeleisen-Methode, ist wegen der IR-Strahlung besser.

Platine auf das Ceranfeld legen. Dann das Feld ca. alle 1 - 2 Sekunden ein- und ausschalten. Dabei das An-Intervall langsam erhöhen. Dies so lange durchführen, bis das Zinn geschmolzen ist. Nun die gewünschten Bauelemente verschieben oder abheben. Darauf achten, dass das Glas frei von Zinn und anderen Stoffen bleibt.

Achtung: Das Glas wird ungleichmäßig heiß, da die Heizwendeln lokal angeordnet sind.

Wichtig: die Platine ist über ihrer Glastemperatur, also biegsam. Die Platine einfach auf dem Ceran Herd auf eine kalte Platte legen und abkühlen lassen.

Eignet sich gut zum Vorwärmen auf ca. 100 - 150°C, auch bei beidseitig bestückten Boards, in Verbindung mit anderen Methoden (z.B. Heißluft).

Ähnliche Vorwärmplatten gibt es speziell für die Löttechnik.

=== Recycelte Chips wiederaufbereiten ===

* Zuerst müssen die Lötzinnreste entfernt werden.
In Alkohol gelöstes Kolophonium wirkt da Wunder. Einfach den Chip in dieses Flussmittel tauchen, welches man vorher z.B. auf einen kleinen Unterteller oder -tasse in kleinen Mengen vergossen hat.
* Dann mit sauberer Lötspitze an den Pins entlangziehen und das überflüssige Lötzinn an einem Schwamm oder Zellstoff (-Taschentuch) abstreifen.
* Verklebte Pins mittels dünner Lötspitze auseinanderbringen, auch ein Zahnstocher aus Holz leistet wertvolle Dienste.
* Bei Pins, die enger als 0,6 mm sind, hilft zusätzlich Entlötsauglitze. Anstelle von Entlötsauglitze kann auch ein dünnes, abisoliertes Litzenkabel (möglichst feindrahtig) dienen.
:Man sollte aber immer daran denken, dass die Gefahr des Ausfalls durch Überhitzung besteht.

Eine zweite Möglichkeit besteht darin das Lötzin "abzudremeln".

Dazu eine kleine rotierende Messingbürste in den Dremel (Multifunktions-Schleifer) und an den Pins von innen nach außen entlangziehen.

* Stahlbürsten sind mit Vorsicht zu genießen, weil sie einfach zu hart sind.
* Kunststoffbürsten hingegen können sich elektrostatisch aufladen!
* Eine "dritte Hand" oder Einspannvorrichtung erleichtert das Recyceln erheblich.

Eine weitere Dritte ist Graphit: Lötzinn und Bleistift sind von Natur aus Feinde. Warmmachen, und Zinn mit Bleistift "wegdrängeln".

Das Ausrichten und Geradebiegen der Pins überlasse ich den eigenen Fähigkeiten.

== Schlusswort ==

Man sollte nicht glauben, dass man jetzt sofort jegliches SMD einlöten kann, mal abgesehen von Widerständen. Alles benötigt eine gewisse Übung und es empfiehlt sich, erst mit den einfacheren SO-Packages anzufangen und einige TSSOPS einzulöten bevor man sich an TQFP oder ähnliches heranwagt. Außerdem sollte man sich für die ersten Versuche nicht unbedingt einen 10 Euro teuren Chip hernehmen. Wenn man aber nicht 2 linke Hände hat, sollten alle Packages beim zweiten oder dritten Lötversuch einigermaßen sauber eingelötet sein. Und besonders bei den TSSOPs und TQFPs sieht es dann fast wie Industriefertigung aus.

==== Kontrollieren von Lötstellen ====

Zur Kontrolle der gelöteten Bauteile sollte man, wie schon erwähnt, eine gute Lupe - besser noch Lupenleuchte - benutzen oder auch schon preiswert über diverse Internetauktionen zu ersteigernde "USB Mikroskope", die an einen PC oder Laptop angeschlossen werden können.

Das kann böse Überraschungen bei der Inbetriebnahme der gelöteten Platine vermeiden.

Unabdingbar ist immer eine gute Ausleuchtung des Arbeitsplatzes.

Auslöten kann man gut an defekten Platinen, z.B. aus Computern, üben.

Und ja keine Lötpaste essen!!!!
Dann wird alles gut :D

== Siehe auch ==

[[IC-Gehäuseformen#Adapterplatinen für SMD-ICs|Adapterplatinen für SMD-ICs]]

== Links ==

* [http://thomaspfeifer.net/ SMD löten/entlöten und Reflow Ofen Selbstbau (unter Trickkiste und AVR Projekte)]
* [http://www.youtube.com/watch?v=wQXhny3R7lk Professionelles SMD Löten leicht gemacht, engl. Youtube Video]
* [http://www.youtube.com/watch?v=3NN7UGWYmBY SMD Soldering without expensive tools, engl. Youtube Video]
* [http://iwenzo.de/wiki/Kategorie:SMD SMD Bauteilliste]
* [http://www.seattlerobotics.org/encoder/200006/oven_art.htm SMD-Löten im Toastofen] (englisch)
* [http://www.elv-downloads.de/downloads/journal/SMD-Anleitung.pdf SMD-Anleitung von ELV] praktische Tips (deutsch)
* [http://www.bimbel.de/artikel/artikel-17.html Bilder und kleine Anleitung]
* [http://www.ulrichradig.de/ SMD-ICs ein-/auslöten (unter Tipps&Tricks)]
* [http://www.gadgetpool.de/nuke/modules.php?name=News&file=article&sid=23 SMD-Löten für jedermann]
* [http://www.makezine.com/blog/archive/2007/01/soldering_tutor_1.html MAKE-Magazine Podcast Loet und Entloet-Tips]
* [http://www.circuitrework.com Circuit Technology Center] - Surgeon grade rework and repair, by the book and guaranteed. Deeplink: [http://www.circuitrework.com/guides/guides.shtml Guides]
*[http://www.martin-smt.de SMD Bearbeitungsgeräte - Reworksysteme]
*[http://www.fritsch-smt.de Bestückungsautomaten / Siebdruckgeräte]
*[http://www.sef.de Reflowlötanlagen]
*[http://iwenzo.de/wiki/Kategorie:SMD SMD Code Tabelle]
*[http://iwenzo.de/wiki/SMD_Widerstand_Codehilfe SMD Widerstände ablesen]
*[http://iwenzo.de/wiki/Kategorie:SMD-Geh%C3%A4use SMD Gehäuseformen]
*[http://iwenzo.de/wiki/SMD_Bauteile_l%C3%B6ten SMD Bauteile löten]

Rechnen in VHDL

2010-03-13T21:04:51Z

134.169.116.89: /* Schlecht: Direktes Rechnen mit std_logic_vector */ Tippfehler korr.

Um in VHDL synthetisierbare Berechnungen zu beschreiben gibt es verschiedene Möglichkeiten.

== Rechnen mit Ganzzahlen ==

=== Integer-Variablen ===

Eine Möglichkeit, die von den meisten Synthesetools unterstützt wird, ist das Rechnen im Integer-Bereich. Das heißt, entweder man arbeitet von Vornherein mit Integer-Signalen, oder man konvertiert einen std_logic_vector zu einem Integer und benutzt die ganz normalen Rechenoperatoren wie +, -, * usw.

Wichtig ist dabei, den Integertyp auf den Bereich zu begrenzen, der auch wirklich benötigt wird, sonst werden alle Berechnungen mit 32 Bit Wortlänge implementiert:
<vhdl>
variable x: integer range 0 to 100;
...
x := x + 1;
</vhdl>

Integer bieten sich für interne Berechnungen an, z. B. Zähler, die bei Erreichen eines bestimmten Zählerstandes einen Ausgang setzen; wenn man dagegen z. B. eine ALU implementiert, die mit externen Vektoren einer bestimmten Breite rechnen muss, ist es günstiger/bequemer direkt auf Basis von Vektoren zu rechnen.

=== Schlecht: Direktes Rechnen mit std_logic_vector ===

Die von vielen Synthesetools unterstützten, aber nicht IEEE-standardisierten Packages std_logic_unsigned und std_logic_signed erlauben es, direkt mit std_logic_vector zu rechnen. Je nachdem, ob das signed- oder unsigned-Package eingebunden wird, werden alle (!) Berechnungen als signed oder unsigned interpretiert - das ist natürlich unsauber. Trotzdem werden diese Packages noch häufig verwendet, obwohl es mit numeric_std gar nicht mehr nötig ist.

=== Besser: Rechnen mit numeric_std ===

Das Package numeric_std definiert zwei neue Typen '''signed''' und '''unsigned''' als Array von std_logic, und definiert für diese Typen alle gebräuchlichen Rechenoperatoren, auch zusammen mit Integern (x + 1):
<vhdl>
signal x: unsigned(7 downto 0); -- Zahlenbereich: 0 bis 2**8-1
signal y: signed(7 downto 0); -- Zahlenbereich: -2**7 bis 2**7-1
...
x <= x + 1;
y <= x + y;
</vhdl>

Nur bei der Zuweisung von Integern an unsigned/signed-Signale muss man von Hand konvertieren:
<vhdl>
x <= to_unsigned(2, x'length);
y <= to_signed(2, y'length);
</vhdl>

Der zweite Parameter gibt die Länge des Vektors an in den konvertiert werden soll.

Um von unsigned/signed zu Integer zu konvertieren gibt es die Funktion to_integer:
<vhdl>
i <= to_integer(x);
</vhdl>

=== Umsetzbare Operatoren ===

Egal ob man mit Integern oder unsigned/signed rechnet, die Software kann nur bestimmte Rechenoperationen in Hardware umsetzen. Schiebeoperationen, Additionen und Subtraktionen sind nie ein Problem, Multiplikationen werden in Multiplizierernetzwerke umgesetzt oder auf Hardwaremultiplizierer gemappt. Divisionen und Modulo-Operationen dagegen werden in der Regel nicht oder nur für Zweierpotenzen unterstützt (Xilinx ISE). Werden Divisionen benötigt muss man einen Divisionsalgorithmus von Hand implementieren oder einen entsprechenden IP-Core einbinden.

== Festkommazahlen (Fixed Point) ==

=== numeric_std und Skalierung von Hand ===

Natürlich ist es möglich numeric_std (signed, unsigned) oder Integer zu verwenden und die Skalierung entsprechend der gewünschten Zahleninterpretation von Hand durchzuführen. Wie das geht wird z.B. hier erklärt: http://www.acoustics.hut.fi/teaching/S-89.3510/2006/projektityo/FixedPointDSPDev.pdf

=== IEEE.Fixed_Pkg ===

Für die nächste Version von VHDL ist das Paket IEEE.Fixed_Pkg vorgesehen. Ähnlich wie bei numeric_std werden hier neue Typen definiert, '''ufixed''' (unsigned fixed point) und '''sfixed''' (signed fixed point). Die Anzahl der Vor- und Nachkommastellen wird bei der Signal-/Variablendeklaration angegeben.

<vhdl>
signal a, b : sfixed (7 downto -6); -- 14 Bit breit, 6 Nachkommastellen
</vhdl>

Der Vorteil ist, dass man sich die manuelle Skalierung sparen kann, und mit der Funktion resize einfach zwischen verschiedenen Zahlenformaten konvertieren kann.

* Download: http://www.vhdl.org/vhdl-200x/vhdl-200x-ft/packages/files.html
* Dokumentation: http://www.vhdl.org/vhdl-200x/vhdl-200x-ft/packages/Fixed_ug.pdf
* Angepasste Versionen für verschiedene Synthesetools: http://www.eda.org/fphdl/vhdl.html
* Hinweise zur Synthese mit Xilinx ISE: http://www.mikrocontroller.net/topic/75414#new

== Gleitkommazahlen (Floating Point) ==

Gleitkommazahlen haben den Vorteil, dass man große Dynamikbereiche abdecken kann, für die man mit Festkommazahlen riesige Bitlängen benötigen würde. Der Nachteil ist der höhere Rechenaufwand: für die Addition zweier Festkommazahlen reicht ein gewöhnlicher Addierer, bei Gleitkommazahlen sind dazu auch Multiplikationen nötig, wenn die beiden Zahlen verschiedene Exponenten haben. Bei der Realisierung in Hardware (FPGAs) bedeutet das dass mehr Fläche benötigt wird und die Taktrate sinkt (bzw. mehr Zyklen für einen Berechnungsschritt nötig sind).

Als erstes muss gesagt werden, dass VHDL sehr wohl Gleitkommazahlen unterstützt (Typ real), diese aber nicht ohne weiteres synthetisierbar sind. Man muss die Zahlen auf jeden Fall erst in eine std_logic-Darstellung bringen.

=== Rechnen "von Hand" bzw. mit FPU-Cores ===

Auch mit Gleitkommazahlen kann man natürlich "von Hand" arbeiten, indem man beliebige Vektoren in Mantisse und Exponent zerpflückt und diese getrennt verarbeitet. Für Rechnungen mit Gleitkommazahlen gibt es auch verschiedene fertige Cores, z.B. [http://www.opencores.org/projects.cgi/web/fpu100/overview FPU100 bei OpenCores], die Berechnungen in mehreren Zyklen durchführen.

=== IEEE.Float_Pkg ===

Analog zu IEEE.Fixed_Pkg gibt es ein entsprechendes Package für Floating Point. Der Nachteil gegenüber FPU-Cores ist, dass die Berechnungen in diesem Package rein kombinatorisch implementiert sind, das heißt keine getaktete Struktur vorgesehen ist. Auch wenn man die Ein- und Ausgänge einer Rechenoperation mit mehreren Takten verzögert schafft [[Xilinx ISE]] 9.2 es nicht daraus eine Pipelinestruktur zu synthetisieren. Die Folge: die Berechnungen werden sehr groß und sehr langsam. Das ließe sich sicher seitens der Hersteller beheben, aber angesichts der Tatsache, dass Float_Pkg mit vielen Tools noch nicht einmal kompilierbar ist, ist das wohl noch in weiter Ferne.

* Download: http://www.vhdl.org/vhdl-200x/vhdl-200x-ft/packages/files.html
* Dokumentation: http://www.vhdl.org/vhdl-200x/vhdl-200x-ft/packages/Float_ug.pdf
* Angepasste Versionen für verschiedene Synthesetools: http://www.eda.org/fphdl/vhdl.html

[[Category:FPGA und Co]]

Rechnen in VHDL

2010-03-13T21:03:20Z

134.169.116.89: /* Integer-Variablen */ Tippfehler korr.

Um in VHDL synthetisierbare Berechnungen zu beschreiben gibt es verschiedene Möglichkeiten.

== Rechnen mit Ganzzahlen ==

=== Integer-Variablen ===

Eine Möglichkeit, die von den meisten Synthesetools unterstützt wird, ist das Rechnen im Integer-Bereich. Das heißt, entweder man arbeitet von Vornherein mit Integer-Signalen, oder man konvertiert einen std_logic_vector zu einem Integer und benutzt die ganz normalen Rechenoperatoren wie +, -, * usw.

Wichtig ist dabei, den Integertyp auf den Bereich zu begrenzen, der auch wirklich benötigt wird, sonst werden alle Berechnungen mit 32 Bit Wortlänge implementiert:
<vhdl>
variable x: integer range 0 to 100;
...
x := x + 1;
</vhdl>

Integer bieten sich für interne Berechnungen an, z. B. Zähler, die bei Erreichen eines bestimmten Zählerstandes einen Ausgang setzen; wenn man dagegen z. B. eine ALU implementiert, die mit externen Vektoren einer bestimmten Breite rechnen muss, ist es günstiger/bequemer direkt auf Basis von Vektoren zu rechnen.

=== Schlecht: Direktes Rechnen mit std_logic_vector ===

Die von vielen Synthesetools unterstützten, aber nicht IEEE-standardisierten Packages std_logic_unsigned und std_logic_signed erlauben es, direkt mit std_logic_vector zu rechnen. Je nachdem ob das signed oder unsigned-Package eingebunden wird werden alle (!) Berechnungen als signed oder unsigned interpretiert - das ist natürlich unsauber. Trotzdem werden diese Packages noch häufig verwendet, obwohl es mit numeric_std gar nicht mehr nötig ist.

=== Besser: Rechnen mit numeric_std ===

Das Package numeric_std definiert zwei neue Typen '''signed''' und '''unsigned''' als Array von std_logic, und definiert für diese Typen alle gebräuchlichen Rechenoperatoren, auch zusammen mit Integern (x + 1):
<vhdl>
signal x: unsigned(7 downto 0); -- Zahlenbereich: 0 bis 2**8-1
signal y: signed(7 downto 0); -- Zahlenbereich: -2**7 bis 2**7-1
...
x <= x + 1;
y <= x + y;
</vhdl>

Nur bei der Zuweisung von Integern an unsigned/signed-Signale muss man von Hand konvertieren:
<vhdl>
x <= to_unsigned(2, x'length);
y <= to_signed(2, y'length);
</vhdl>

Der zweite Parameter gibt die Länge des Vektors an in den konvertiert werden soll.

Um von unsigned/signed zu Integer zu konvertieren gibt es die Funktion to_integer:
<vhdl>
i <= to_integer(x);
</vhdl>

=== Umsetzbare Operatoren ===

Egal ob man mit Integern oder unsigned/signed rechnet, die Software kann nur bestimmte Rechenoperationen in Hardware umsetzen. Schiebeoperationen, Additionen und Subtraktionen sind nie ein Problem, Multiplikationen werden in Multiplizierernetzwerke umgesetzt oder auf Hardwaremultiplizierer gemappt. Divisionen und Modulo-Operationen dagegen werden in der Regel nicht oder nur für Zweierpotenzen unterstützt (Xilinx ISE). Werden Divisionen benötigt muss man einen Divisionsalgorithmus von Hand implementieren oder einen entsprechenden IP-Core einbinden.

== Festkommazahlen (Fixed Point) ==

=== numeric_std und Skalierung von Hand ===

Natürlich ist es möglich numeric_std (signed, unsigned) oder Integer zu verwenden und die Skalierung entsprechend der gewünschten Zahleninterpretation von Hand durchzuführen. Wie das geht wird z.B. hier erklärt: http://www.acoustics.hut.fi/teaching/S-89.3510/2006/projektityo/FixedPointDSPDev.pdf

=== IEEE.Fixed_Pkg ===

Für die nächste Version von VHDL ist das Paket IEEE.Fixed_Pkg vorgesehen. Ähnlich wie bei numeric_std werden hier neue Typen definiert, '''ufixed''' (unsigned fixed point) und '''sfixed''' (signed fixed point). Die Anzahl der Vor- und Nachkommastellen wird bei der Signal-/Variablendeklaration angegeben.

<vhdl>
signal a, b : sfixed (7 downto -6); -- 14 Bit breit, 6 Nachkommastellen
</vhdl>

Der Vorteil ist, dass man sich die manuelle Skalierung sparen kann, und mit der Funktion resize einfach zwischen verschiedenen Zahlenformaten konvertieren kann.

* Download: http://www.vhdl.org/vhdl-200x/vhdl-200x-ft/packages/files.html
* Dokumentation: http://www.vhdl.org/vhdl-200x/vhdl-200x-ft/packages/Fixed_ug.pdf
* Angepasste Versionen für verschiedene Synthesetools: http://www.eda.org/fphdl/vhdl.html
* Hinweise zur Synthese mit Xilinx ISE: http://www.mikrocontroller.net/topic/75414#new

== Gleitkommazahlen (Floating Point) ==

Gleitkommazahlen haben den Vorteil, dass man große Dynamikbereiche abdecken kann, für die man mit Festkommazahlen riesige Bitlängen benötigen würde. Der Nachteil ist der höhere Rechenaufwand: für die Addition zweier Festkommazahlen reicht ein gewöhnlicher Addierer, bei Gleitkommazahlen sind dazu auch Multiplikationen nötig, wenn die beiden Zahlen verschiedene Exponenten haben. Bei der Realisierung in Hardware (FPGAs) bedeutet das dass mehr Fläche benötigt wird und die Taktrate sinkt (bzw. mehr Zyklen für einen Berechnungsschritt nötig sind).

Als erstes muss gesagt werden, dass VHDL sehr wohl Gleitkommazahlen unterstützt (Typ real), diese aber nicht ohne weiteres synthetisierbar sind. Man muss die Zahlen auf jeden Fall erst in eine std_logic-Darstellung bringen.

=== Rechnen "von Hand" bzw. mit FPU-Cores ===

Auch mit Gleitkommazahlen kann man natürlich "von Hand" arbeiten, indem man beliebige Vektoren in Mantisse und Exponent zerpflückt und diese getrennt verarbeitet. Für Rechnungen mit Gleitkommazahlen gibt es auch verschiedene fertige Cores, z.B. [http://www.opencores.org/projects.cgi/web/fpu100/overview FPU100 bei OpenCores], die Berechnungen in mehreren Zyklen durchführen.

=== IEEE.Float_Pkg ===

Analog zu IEEE.Fixed_Pkg gibt es ein entsprechendes Package für Floating Point. Der Nachteil gegenüber FPU-Cores ist, dass die Berechnungen in diesem Package rein kombinatorisch implementiert sind, das heißt keine getaktete Struktur vorgesehen ist. Auch wenn man die Ein- und Ausgänge einer Rechenoperation mit mehreren Takten verzögert schafft [[Xilinx ISE]] 9.2 es nicht daraus eine Pipelinestruktur zu synthetisieren. Die Folge: die Berechnungen werden sehr groß und sehr langsam. Das ließe sich sicher seitens der Hersteller beheben, aber angesichts der Tatsache, dass Float_Pkg mit vielen Tools noch nicht einmal kompilierbar ist, ist das wohl noch in weiter Ferne.

* Download: http://www.vhdl.org/vhdl-200x/vhdl-200x-ft/packages/files.html
* Dokumentation: http://www.vhdl.org/vhdl-200x/vhdl-200x-ft/packages/Float_ug.pdf
* Angepasste Versionen für verschiedene Synthesetools: http://www.eda.org/fphdl/vhdl.html

[[Category:FPGA und Co]]