Mikrocontroller.net - Benutzerbeiträge [de]

Digitalfilter mit ATmega

2014-01-19T16:39:37Z

46.128.38.250: Erklärung IIR korrigiert, Nachteil von Filtern höherer Ordnung korrigiert

Auch mit 8-Bit-Mikrocontrollern der ATmega-Reihe ist es möglich, einfache digitale Signalverarbeitungen auszuführen. Mittels kostenloser Mathematiksoftware ist die Berechnung eigener Filter möglich.

Viele von uns haben schon analoge Filterschaltungen aufgebaut, als passive LC-Filter oder aktive Filter mit Operationsverstärkern. Dank kostenloser Berechnungssoftware, wie z. B. [http://www.aade.com AADE], ist die Auswahl der Schaltung und Berechnung der Bauteilwerte kein Problem mehr. Die gleichen Filter in digitaler Technik zu erstellen gilt dagegen immer noch als kompliziert, obwohl sie in professionellen Schaltungen die Analogtechnik weitgehend verdrängt haben. Ihr großer Vorteil ist der fehlende Abgleich. Dank Quarzoszillator wird ein einmal berechneter Frequenzgang ohne Präzisionsbauteile reproduzierbar eingehalten.

Die Software ist im Grunde sehr einfach aufgebaut, besteht nur aus Schiebeoperationen, Additionen und einigen Multiplikationen. Die ATmega-Controller enthalten alle dazu nötigen Funktionen, einen A/D-Wandler, einen 8-Bit Multiplizierer und mehrere D/A-Wandler durch Pulsbreitenmodulation. Am Ausgang muß nur noch ein [http://www.mikrocontroller.net/articles/AVR_PWM#Tiefpassfilter-Berechnung einfacher Tiefpaß] die PWM-Frequenz wegfiltern. Die Programmbeispiele wurden auf Grundlage der [http://www.atmel.com/dyn/resources/prod_documents/doc2527.pdf Applikationsschrift AVR223] mit [http://atmel.com/avrstudio AVRStudio] entwickelt.

Am Ende der Programme befindet sich eine Koeffiziententabelle, deren Werte die Filtereigenschaften bestimmen. Um eigene Filter entwickeln zu können sollen dazu die Grundbegriffe sehr kurz erläutert und dann einfache „Kochrezepte“ vorgestellt werden.

===Ein IIR-Filter 6. Ordnung===
Als erstes wird ein Filter berechnet, das nur durch Änderung der Koeffizienten als Tiefpaß, Hochpaß, Bandpaß oder Bandsperre wirkt. Im Beispielprogramm soll es ein 1750 Hz Sperrfilter werden, das laute Ruftöne beim Zuhören auf Amateur-Relaisfunkstellen unterdrücken kann.
Dieser Filtertyp heißt „IIR“, ''infinite impulse response'', weil er nach Anregung mit einem Impuls theoretisch eine unendliche Impulsantwort liefert. Der verwendete Aufbau aus drei hintereinandergeschalteten Teilfiltern zweiter Ordnung ist als gutmütig bekannt. Diese ''kaskadierten'' Teilfilter nennt man „SOS“ ''second order sections'' oder auch ''biquad sections''. Der Aufbau mit einem einzigen Filter 6. Ordnung, wie er in der AVR223 von 2001 noch beschrieben ist, neigt auf Grund der endlichen Genauigkeit der Koeffizienten eher zum Schwingen.

===Software zur Koeffizientenberechnung===
Es gibt einige spezialisierte Programme, die aber nur eine kleine Anzahl von Digitalfilterkonfigurationen kennen, z. B. [http://www.nuhertz.com/filter/ FilterFree]. Wesentlich universeller sind umfangreiche Programmpakete für numerische Mathematik.
Neben dem kommerziellen [http://www.mathworks.de Matlab] das auch in einer eingeschränkten Studentenversion angeboten wird, und zu dem zahlreiche Literatur existiert, z. B. ISBN 9783486584271 , gibt es auch zwei kostenlose Nachahmer: [http://www.octave.org Octave] und [http://www.scilab.org Scilab]. Spezialitäten der digitalen Signalverarbeitung bilden nur einen kleinen Teil des Gesamtpakets, und die Hilfetexte dazu sind sehr knapp oder auch mal ein Jahrzehnt alt. Zum Glück sind beide Programme dem Vorbild so nahe, daß man vieles der Literatur zu Matlab entnehmen kann.
Die eigentliche Koeffizientenberechnung besteht meistens aus nur wenigen Textzeilen. Man gibt wie beim analogen Filter die gewünschten Durchlaß- und Sperrfrequenzen, die Filtercharakteristik und Ordnung ein. Auf eine grafische Benutzeroberfläche muß man allerdings verzichten. Immerhin können der Frequenzgang und andere Kurven grafisch ausgegeben werden.

===Transformationen und komplexe Zahlen===
Die mathematischen Grundbegriffe der Digitalfilterberechnung sollen hier nur stichwortartig erwähnt werden:

Von der ''Fourier-Transformation'' hat man schon mal gehört, ihre Bedeutung ist noch einigermaßen begreifbar. Von einem periodischen Signal x(t) wie es das Oszilloskop zeigt, also im ''Zeitbereich'', gelangt man über sie zur spektralen Darstellung x(f) im ''Frequenzbereich'' auf dem Spektrumanalysator.
Das ist aber nur die halbe Information, eigentlich gehört zu jeder Harmonischen außer der angezeigten Amplitude auch noch ihre Phasenlage.
x(f) ist also eine zweidimensionale Variable, Amplitude (Betrag) und Phase (Winkel) sind polare Koordinaten. Wenn wir zu kartesischen Koordinaten übergehen, und die x- Achse als ''reelle'', die y-Achse als ''imaginäre'' Achse bezeichnen, kommen wir zur komplexen Zahlendarstellung.
Für die Berechnung analoger Filter ist die ''Laplace-Transformation'' zuständig, für digitale Filter die nahe verwandte ''z-Transformation''. Im ersten Fall wird x(t) in ein X(s) transformiert, in unserem Fall, wie der Name schon sagt in ein X(z). Zur besseren Unterscheidung wird das X groß geschrieben. Auch hier rechnen wir mit komplexen Zahlen, wir befinden uns nach der Transformation in der komplexen ''z-Ebene''.

===Übertragungsfunktion und Koeffizienten===
Das Digitalfilter ist für uns zunächst ein schwarzer Kasten, in den ein Signal x(t) hineinläuft und als gefiltertes Signal y(t) wieder herauskommt. Die z-transformierten Signale heißen X(z) und Y(z). Der Quotient Y(z)/X(z) = H(z) wird ''Übertragungsfunktion'', engl. ''transfer function'' genannt. Für bestimmte Werte von z wird der Zähler oder Nenner der Übertragungsfunktion Null, diese heißen ''Nullstellen'' und ''Pole'' der Funktion. Diese Werte der komplexen Zahl z können im ''Pol/Nullstellendiagramm'' als Punkte in der z-Ebene dargestellt werden, das hilft beispielsweise bei der Untersuchung der ''Stabilität'' des Filters gegen Schwingneigung.

Die genannten Mathematikprogramme berechnen uns aus den gewünschten Filterdaten die Übertragungsfunktion. Im einfachsten Fall können wir daraus die Zahlenwerte direkt in die Filtersoftware als Koeffiziententabelle eintragen. Die Aufteilung in Teilfilter macht die Berechnung etwas umständlicher. Die einzelnen Übertragungsfunktionen werden multipliziert, also Y(z)/X(z) = H1(z)*H2(z)*H3(z). Wir müssen also H(z) in geeignete Faktoren zerlegen, auch dabei hilft uns die Mathematiksoftware.

===Octave und Scilab===
Am besten installieren wir gleich beide Softwarepakete. Beide bieten unterschiedliche Lösungswege zur Berechnung der gewünschten SOS-Teilfilter.
In Scilab werden Frequenzen als Bruchteile der Abtastfrequenz, engl. ''sample rate'' des Analog-Digitalwandlers angegeben. Der AD-Wandler im ATmega wird hier mit einer Taktfrequenz von 1/64 des Quarzoszillators betrieben und braucht pro Wandlung 13 Takte. Mit einem 15 MHz – Quarz ergibt sich also ein Abtastfrequenz von 15MHz/(64*13) = 18029 Hz. Octave rechnet mit Bruchteilen der halben Abtastfrequenz, auch ''Nyquist-Frequenz'' genannt.
Die Filterordnung bezieht sich in beiden Programmen auf Tief- und Hochpassfilter. Für Bandpässe und -sperren muß die Hälfte angegeben werden, hier also 3 statt 6.

Beginnen wir mit Scilab. Das kurze Programm in Bild 1 speichern wir als Textdatei z. B. unter „Sperrfilter1750Hz.sci“ ab, dann lädt es durch Anklicken direkt in den bunten Scilab-Editor und wird mit „Ausführen – in Scilab laden“ gestartet. Ein neues Fenster mit der Frequenzgangkurve öffnet sich und im Scilab-Hauptfenster stehen die Übertragungsfunktionen der drei Teilfilter, sowie die Gesamtverstärkung gain. Die Filterordnung kann nicht direkt vorgegeben werden, wir müssen die vier Grenzfrequenzen und die beiden Dämpfungswerte variieren bis genau drei SOS-Teilfilter herauskommen.
In Octave werden nur zwei Grenzfrequenzen verlangt, dafür können wir die Filterordnung vorgeben. Wieder wird eine Textdatei ausgeführt und liefert Übertragungsfunktionen für drei Teilfilter.

Einen Schönheitsfehler haben die berechneten Funktionen noch. In der Regelungstechnik und auch in Scilab/Octave wird mit positiven Exponenten von z gerechnet, die Literatur zur digitalen Signalverarbeitung benutzt dagegen negative. Wenn wir aber Zähler und Nenner jeder Teil-Übertragungsfunktion durch z2 teilen, ändert sie sich nicht und wir haben die Formel wie sie für digitale Filter üblich ist.

Jetzt können wir die Koeffizienten direkt aus den Übertragungsfunktionen ablesen. Wir müssen sie noch ''skalieren'', also mit einer geeigneten Zweierpotenz multiplizieren und zu einer ganzen Zahl auf/abrunden. Sie sollen hier zu einer 16 Bit-Zahl (Festkommadarstellung mit Vorzeichenbit) werden, also alle Koeffizienten im Bereich -32768...+32767 liegen.

===Frequenzgang maßgeschneidert===
Mit der Funktion '''yulewalk''' können wir auch kompliziertere Frequenzgangkurven erreichen. In Octave fehlt sie, drei ähnlich lautende Funktionen haben nichts mit Filtern zu tun. Die gewünschte Funktion wird mit Geradenstücken zwischen beliebigen Kurvenpunkten vorgegeben. Als Beispiel nehmen wir einen Bandpass für SSTV ''slow scan television'', der 1974 in der "CQ-DL" vorgestellt wurde. Synchronimpuls (1200 Hz) und Bildinformation (1500-2300 Hz) sollen durchgelassen, Störungen außerhalb dieser Bereiche unterdrückt werden.
Nach längerem Ausprobieren verschiedener Vorgabewerte und Reduktion der Abtastfrequenz auf die Hälfte ergibt sich eine gute Übereinstimmung mit dem Frequenzgang des Originals. Jetzt haben wir eine Übertragungsfunktion 6.Ordnung, die wieder in SOS-Teilfilter zerlegt werden muß. Diese Funktion '''tf2sos''' ''transfer function to second order sections'' fehlt in Scilab, deshalb übertragen wir die Zahlen aus Scilab nach Octave und erhalten so schließlich unsere Koeffizienten.

Es gibt noch weitere Verfahren, um "Wunschfrequenzgänge" zu berechnen: 
'''prony''' in Matlab ( in Scilab nicht vorhanden) [http://www.mikrocontroller.net/topic/244886#new hier im Forum erwähnt] - in ISBN 9780792395591 ab Seite 35 steht ein Matlab-m-file dazu,
und '''FDLS''' (frequency domain least square) von Greg Berchin:
[http://apollo.ee.columbia.edu/spm/external/tipsandtricks/files/TandT_Jan2007.zip Matlab-File und PDFs dazu],
[http://www.fpgacentral.com/group/dsp/nearest-iir-system-fir-84479/ Diskussion auf fpgacentral.com] [http://www2.units.it/ramponi/teaching/DSP/materiale/Ch5%28x%293e.pdf#page=29 Grundlagenartikel "Precise Filter Design"] Auch als Kapitel 7 in ISBN 9781118316917 oder ? ISBN 9781118278383 (2.Auflage 2012) oder ISBN 9780470131572 (2007) ab Seite 59 zu finden

===Von der Übertragungsfunktion zum Programm===

Unsere SOS-Teilfilter haben jetzt (je nach Vorzeichen der Exponenten) diese Übertragungsfunktion:

:<math>
H(z)=\frac{b_{2}\cdot z^{-2}+b_{1}\cdot z^{-1}+b_{0}}{a_{2}\cdot z^{-2}+a_{1}*z^{-1}+1} =
{\frac{b_{2}+b_{1}\cdot z+b_{0}\cdot z^{2}}{a_{2}+a_{1}\cdot z+z^{2}}}
</math>

Jetzt wird von z-Bereich wieder in den Zeitbereich rücktransformiert. Diese Funktion y(t)= f(x(t))und der dazugehörige Programmablauf wird üblicherweise in Form eines Blockdiagramms dargestellt:

[[Bild:IIR_Block.png]]

Wir sehen drei Blocktypen: ein Verzögerung um einen Sampletakt Δt, Addition mehrere Summanden, und Multiplikationen mit Konstanten, die aus der Übertragungsfunktion abgelesen werden. Spezielle Signalprozessoren enthalten übrigens für die beiden letzteren einen sogenannten MAC ''multiply-accumulate'' Befehl. Im Atmega-Programm wird es in einem Assembler-Macro namens SMAC32 durchgeführt.

===Literatur===
* Der wichtigste Artikel zur Signalverarbeitung mit Scilab ist [http://elm.eeng.dcu.ie/~ee317/Matlab_Clones/signal.pdf Signal.pdf (1,2MByte) von 1998]. Die dazugehörigen Programme sind etwas schwerer zu finden, hier habe ich sie daher zu [http://www.mikrocontroller.net/wikifiles/8/82/SignalFiles.pdf SignalFiles.pdf (980kB)] zusammengefasst.
* [http://www.scilab.org/publications/ Bücher zu Scilab] gibt es nur wenige, und diese gehen nicht auf das Thema Signalverarbeitung ein.
* Für Januar 2010 angekündigt: ISBN 3527407243 oder 9783527407248 ''Signals and Systems Using SCILAB'', Vorabinfo: [http://www.wiley-vch.de/img/news/Halbjahresvorschau_I_2008.pdf kurzer Verlagstext PDF Seite 33] und bei Google-books.
* ISBN 9781584502814 (2004) ''Digital signal processing fundamentals'' mit einem sehr kleinen Anhang "Scilab Tutorial", sehr oberflächlich
* ISBN 9780817640095 (1999) ''Engineering and scientific computing with Scilab'' mit einem Kapitel zu "Signal Processing", für den Einstieg in Scilab sehr zu empfehlen. Auch als unveränderter Nachdruck von 2007 noch neu erhältlich.

===Scilab-Berechnung mit eqiir===
<syntaxhighlight lang="c">
// Stopband-Filter für 1750 Hz, Samplerate =18029Hz
// Eckfrequenzen 1400Hz, 1700Hz, 1800 Hz, 2100Hz:
omega=[2*%pi*(1400/18029),2*%pi*(1700/18029),2*%pi*(1800/18029),2*%pi*(2100/18029)];
// Maximale Durchgangswelligkeit 0,5 dB
deltapass = (1-10**(-0.5/20)) ;
// minimale Sperrband-Dämpfung 50 dB
deltastop = 10**(-50/20);
// IIR-Filter berechnen, "stopband", "elliptic":
[sos,gain,zeroes,poles] = eqiir('sb','el',omega,deltapass,deltastop);
// Second order sections anzeigen:
sos
gain
//Frequenzgang berechnen und plotten:
zaehlerprodukt = prod(sos(2));
nennerprodukt = prod(sos(3));
frequenzgang = gain*abs(freq(zaehlerprodukt,nennerprodukt,exp(%i*(0:0.01:%pi))));
// frequenzgang = gain*abs(freq(zaehlerprodukt,nennerprodukt,exp(%i*(0:0.01:%pi))));
n = prod(size(frequenzgang));
//plot(20*log(frequenzgang(2:n))/log(10),(n*18029/(200*%pi)));
plot(20*log(frequenzgang (2:n))/log(10))

(Ergebnis:)
2 2 2
1 - 1.6219938z + z 1 - 1.6396794z + z 1 - 1.656616z + z
sos = -------------------------- * ------------------------ * -------------------------
2 2 2
0.9383702 - 1.5100165z + z 0.8466245 - 1.513936z + z 0.9485511 - 1.663563z + z

gain = 0.8683583
</syntaxhighlight>

===Messung des 1750 Hz-Sperrfilters===

Gemessen mit [http://www.sillanumsoft.org/ "Visual Analyzer"]:

[[Bild:1750HzNotch.png]]

===Frequenzgang-Planung mit Yulewalk===
Oben das Programm, weitgehend aus dem Hilfetext entnommen, in der Mitte der berechnete Frequenzgang - Messung liegt noch keine vor -, unten rechts die Vorgabe mit Geradenstücken, links die Übertragungsfunktion 6.Ordnung.

[[Bild:Yulewalk.png|Massgeschneiderter Frequenzgang mit yulewalk|640px]]

Die Koeffizienten heißen im Zähler von links nach rechts b6...b0 , im Nenner a6...a0, wobei a0 immer =1 ist.
Hier die Zerlegung in Teilfilter mit Octave:
<syntaxhighlight lang="c">
B=[0.1211431 0.0379961 -0.0272326 -0.0361440 -0.0041574 -0.0010921 -0.0894734 ];
A=[1 -1.7641816 2.7032943 -2.3805502 1.8419165 -0.8344276 0.2958684];
[sos,g] = tf2sos(B,A)
//
// octave.exe:2> B=[0.1211431 0.0379961 -0.0272326 -0.0361440 -0.0041574 -0.0010921 -0.0894734 ];
// octave.exe:3> A=[1 -1.7641816 2.7032943 -2.3805502 1.8419165 -0.8344276 0.2958684];
// octave.exe:4> [sos,g] = tf2sos(B,A)
// sos =
//
// 1.0000000 1.1503168 1.0001280 1.0000000 0.0596667 0.7154071
// 1.0000000 -0.8390889 0.7389315 1.0000000 -0.7453174 0.7120574
// 1.0000000 0.0024186 -0.9993911 1.0000000 -1.0785309 0.5808050
//
// g = 0.12114
</syntaxhighlight>
In drei Zeilen untereinander die drei Teilfilter-Koeffizienten, von links nach rechts b0, b1, b2, a0 (wieder=1), a1 und a2.

===Quelltext des ATmega48-Programms===
basierend auf AVR223, zerlegt in 3 SOS-Teilfilter, mit Überlaufbegrenzung
<syntaxhighlight lang="avrasm">
;***************************************************************************
;* Digital filter with ATmega48P 6th-order IIR, AVR223 application note *
;* 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 MltLo = r0 ; multiplier result
.def MltHi = 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 SOS filter
.equ x11 = 0
.equ x21 = 2
.equ y11 = 4
.equ y21 = 6
; 2nd SOS filter
.equ x12 = 8
.equ x22 = 10
.equ y12 = 12
.equ y22 = 14
; 3rd SOS filter
.equ x13 = 16
.equ x23 = 18
.equ y13 = 20
.equ y23 = 22
; 1st SOS filter
.equ b01 = 24
.equ b11 = 26
.equ b21 = 28
.equ a11 = 30
.equ a21 = 32
; 2nd SOS filter
.equ b02 = 34
.equ b12 = 36
.equ b22 = 38
.equ a12 = 40
.equ a22 = 42
; 3rd SOS filter
.equ b03 = 44
.equ b13 = 46
.equ b23 = 48
.equ a13 = 50
.equ a23 = 52
;*****************************************************
;* 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 ; Update low byte of node to prepare next filter run
std Y+@0+1,datah ; Update high byte of node to prepare next filter run
.ENDMACRO
.MACRO load_coef
ldd coefl,Y+@0 ; Load low byte of node
ldd coefh,Y+@0+1 ; Load high byte of node
.ENDMACRO
.MACRO mul_move_32
muls coefh,datah ; Signed multiply, coefficient high byte and data high byte
mov accu2,MltLo ; Copy result word into accumulator byte 2:3
mov accu3,MltHi ; Copy result word into accumulator byte 2:3
mul coefl,datal ; Unsigned multiply, coefficient low byte and data low byte
mov accu0,MltLo ; Copy result word into accumulator byte 2:3
mov accu1,MltHi ; 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,MltLo ; Add low byte of result to accumulator byte 1
adc accu2,MltHi ; 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,MltLo ; Add low byte of result to accumulator byte 1
adc accu2,MltHi ; Add with carry high byte of result to accumulator byte 2
adc accu3,Zero ; Add carry to accumulator byte 3
.ENDMACRO
.MACRO smac32
muls coefh,datah ; Signed multiply, coefficient high byte and data high byte
add accu2,MltLo ; Add low byte of result to accumulator byte 2
adc accu3,MltHi ; Add with carry high byte of result to accumulator byte 3
mul coefl,datal ; Unsigned multiply, coefficient low byte and data low byte
add accu0,MltLo ; Add low byte of result to accumulator byte 0
adc accu1,MltHi ; Add with carry high byte of result to accumulator byte 1
adc accu2,Zero ; Add carry to accumulator byte 2
adc accu3,Zero ; Add carry to accumulator byte 3
mulsu coefh,datal ; Signed-unsigned multiply, coefficient high byte and data low byte
sbc accu3,Zero ; Sign extention
add accu1,MltLo ; Add low byte of result to accumulator byte 1
adc accu2,MltHi ; 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,MltLo ; Add low byte of result to accumulator byte 1
adc accu2,MltHi ; Add with carry high byte of result to accumulator byte 2
adc accu3,Zero ; Add carry to accumulator byte 3
; ret
.ENDMACRO
.LISTMAC
;*************************************************************************
;* reset/interrupt-vectors:
;*************************************************************************
.cseg
rjmp Initial ; after RESET to main program
reti ; External Interrupt Request 0
reti ; External Interrupt Request 1
; reti ; External Interrupt Request 2 mega644
reti ; Pin Change Interrupt Request 0
reti ; Pin Change Interrupt Request 1
reti ; Pin Change Interrupt Request 2
; reti ; Pin Change Interrupt Request 3 mega644
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
; reti ; Analog Comparator mega644
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,30 ; count 15 * 16 Bit 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(DatTbl) ; load SRAM-Pointer for Interrupt routine
ldi YH,high(DatTbl) ;
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
;*************************************************************************
;* 1st SOS filter
;*************************************************************************
load_coef b21 ; b21*x1[t-2]
load_node x21 ;
mul_move_32 ;
load_coef b11 ; b11*x1[t-1]
load_node x11 ;
update_node x21 ;
smac32 ;
load_coef b01 ; b01*x1[t]
lds datal,ADCL ; Load new sample
lds datah,ADCH ; into data multiply register
dec datah ; convert 10 bit unsigned $03FF -> $01FF
dec datah ; to 16 Bit signed $0000 -> $FE00

lsl datal
rol datah
lsl datal
rol datah
lsl datal
rol datah
lsl datal
rol datah
lsl datal
rol datah
lsl datal
rol datah

update_node x11 ;
smac32 ;
load_coef a21 ; a21*y1[t-2]
load_node y21 ;
smac32 ;
load_coef a11 ; a11*y1[t-1]
load_node y11 ;
update_node y21 ;
smac32 ;
cpi accu3,$20 ; accu < $20000000 ?
brlo NoLimit1 ;
cpi accu3,-$20 ; accu >= -$20000000 ?
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^15
rol accu2 ;
rol accu3 ;
lsl accu1 ; Scaling to gain factor 2^16
rol accu2 ;
rol accu3 ;
Limit1:
std Y+y11,accu2 ; Updating y1[t-1] node to prepare next filter run
std Y+y11+1,accu3 ; and save it for following SOS filter
;*************************************************************************
;* 2nd SOS filter
;*************************************************************************
load_coef b22 ; b22*x2[t-2]
load_node x22 ;
mul_move_32 ;
load_coef b12 ; b12*x2[t-1]
load_node x12 ;
update_node x22 ;
smac32 ;
load_coef b02 ; b02*x2[t]
load_node y11 ; result of 1st SOS
update_node x12 ;
smac32 ;
load_coef a22 ; a22*y2[t-2]
load_node y22 ;
smac32 ;
load_coef a12 ; a12*y2[t-1]
load_node y12 ;
update_node y22 ;
smac32 ;
cpi accu3,$20 ; accu < $20000000 ?
brlo NoLimit2 ;
cpi accu3,-$20 ; accu >= -$20000000 ?
brsh NoLimit2 ;
clr accu2 ; accu2 = $00
cpi accu3,0 ;
brge PosLim2 ;
ldi accu3,$80 ; accu3 = $80
rjmp Limit2 ;
PosLim2:
ldi accu3,$7F ; accu3 = $7F
com accu2 ; accu2 = $FF
rjmp Limit2 ;
NoLimit2:
lsl accu1 ; Scaling to gain factor 2^15
rol accu2 ;
rol accu3 ;
lsl accu1 ; Scaling to gain factor 2^16
rol accu2 ;
rol accu3 ;
Limit2:
std Y+y12,accu2 ; Updating y2[t-1] node to prepare next filter run
std Y+y12+1,accu3 ; and save it for following SOS filter
;*************************************************************************
;* 3rd SOS filter
;*************************************************************************
load_coef b23 ; b23*x3[t-2]
load_node x23 ;
mul_move_32 ;
load_coef b13 ; b13*x3[t-1]
load_node x13 ;
update_node x23 ;
smac32 ;
load_coef b03 ; b03*x3[t]
load_node y12 ; result of 2nd SOS
update_node x13 ;
smac32 ;
load_coef a23 ; a23*y3[t-2]
load_node y23 ;
smac32 ;
load_coef a13 ; a13*y3[t-1]
load_node y13 ;
update_node y23 ;
smac32 ;
cpi accu3,$20 ; accu < $20000000 ?
brlo NoLimit3 ;
cpi accu3,-$20 ; accu >= -$20000000 ?
brsh NoLimit3 ;
clr accu2 ; accu2 = $00
cpi accu3,0 ;
brge PosLim3 ;
ldi accu3,$80 ; accu3 = $80
rjmp Limit3 ;
PosLim3:
ldi accu3,$7F ; accu3 = $7F
com accu2 ; accu2 = $FF
rjmp Limit3 ;
NoLimit3:
lsl accu1 ; Scaling to gain factor 2^15
rol accu2 ;
rol accu3 ;
lsl accu1 ; Scaling to gain factor 2^16
rol accu2 ;
rol accu3 ;
Limit3:
std Y+y13,accu2 ; Updating y3[t-1] node to prepare next filter run
std Y+y13+1,accu3 ;
;*************************************************************************
;* PWM - D/A-output
;*************************************************************************
subi accu3,$80 ; signed to unsigned $8000 ->$0000, $7FFF ->$FFFF
sts OCR1AH,Zero ;
sts OCR1AL,Tmp1 ; fast PWM 8 bit input signal to OCR1A
sts OCR1BH,Zero ;
sts OCR1BL,accu3 ; fast PWM 8 bit result to OCR1B
cbi PortD,0 ; just to measure INT-Time
out SREG,SavSrg ; restore status register
reti ;
;*************************************************************************
;* coefficient table in flash memory
;*************************************************************************
CoTblF:
/*
;1750 Hz Sperrfilter:
.dw 16384 ; b01 *16384 ( 1 )
.dw -26575 ; b11 *16384 (-1,6219938)
.dw 16384 ; b21 *16384 ( 1 )
.dw 24740 ; -a11 *16384 ( 1,5100165)
.dw -15374 ; -a21 *16384 (-0,9383702)

.dw 16384 ; b02 *16384 ( 1 )
.dw -26865 ; b12 *16384 (-1,6396794)
.dw 16384 ; b22 *16384 ( 1 )
.dw 24804 ; -a12 *16384 ( 1,5139300)
.dw -13871 ; -a22 *16384 (-0,8466245)

.dw 16384 ; b03 *16384 ( 1 )
.dw -27142 ; b13 *16384 (-1,6566160)
.dw 16384 ; b23 *16384 ( 1 )
.dw 27256 ; -a13 *16384 ( 1,6635630)
.dw -15541 ; -a23 *16384 (-0,9485511) */

;SSTV-Bandpass nach DJ6HP 015:
.dw 16384 ; b01 *16384 ( 1 )
.dw 18847 ; b11 *16384 ( 1.1503168)
.dw 16386 ; b21 *16384 ( 1.0001280)
.dw -978 ; -a11 *16384 (-0.0596667)
.dw -11721 ; -a21 *16384 (-0.7154071)

.dw 16384 ; b02 *16384 ( 1 )
.dw -13748 ; b12 *16384 (-0.8390889)
.dw 12107 ; b22 *16384 ( 0.7389315)
.dw 12211 ; -a12 *16384 ( 0.7453174
.dw -11666 ; -a22 *16384 (-0.7120574)
;
.dw 16384 ; b03 *16384 ( 1 )
.dw 40 ; b13 *16384 ( 0.0024186)
.dw -16374 ; b23 *16384 (-0.9993911)
.dw 17671 ; -a13 *16384 ( 1.0785309)
.dw -9516 ; -a23 *16384 (-0.5808050)

;*************************************************************************
;* data memory in SRAM
;*************************************************************************
.dseg
.org $0100
DatTbl:
.dw $0000 ; x11
.dw $0000 ; x21
.dw $0000 ; y11
.dw $0000 ; y21
;
.dw $0000 ; x12
.dw $0000 ; x22
.dw $0000 ; y12
.dw $0000 ; y22
;
.dw $0000 ; x13
.dw $0000 ; x23
.dw $0000 ; y13
.dw $0000 ; y23
;*************************************************************************
;* coefficient table in SRAM
;*************************************************************************
CoTblS:
.dw $0000 ; b01 *16384
.dw $0000 ; b11 *16384
.dw $0000 ; b21 *16384
.dw $0000 ; -a11 *16384
.dw $0000 ; -a21 *16384
;
.dw $0000 ; b02 *16384
.dw $0000 ; b12 *16384
.dw $0000 ; b22 *16384
.dw $0000 ; -a12 *16384
.dw $0000 ; -a22 *16384
;
.dw $0000 ; b03 *16384
.dw $0000 ; b13 *16384
.dw $0000 ; b23 *16384
.dw $0000 ; -a13 *16384
.dw $0000 ; -a23 *16384
;*************************************************************************
</syntaxhighlight>
[[Kategorie:AVR-Projekte]]
[[Category:DSP]]

Brushless-Controller für Modellbaumotoren

2013-12-30T18:09:17Z

46.128.38.250: /* Einsatz der BEMF */

== Einleitung ==

Im Internet gibt es einige grundlegende Informationen zur Funktionsweise und Ansteuerung von Brushless-Motoren (BLDC). Für die Entwicklung eines solchen Reglers findet man aber nur wenig richtig detaillierte Informationen und Erfahrungsberichte. In diesem Artikel sollen genau diese Lücken geschlossen werden. Es soll hier aber kein fertiges Produkt (Schaltplan + Layout + Software) angeboten werden. Viel mehr soll es die Eigenentwicklung unterstützen, Ideen und Erfahrungen anbieten.

An dieser Stelle weise ich noch darauf hin, dass man bei den [[#Weblinks]] noch einige sehr gute Informationen findet! Es gibt dort Hardware und Software, es lohnt sich die Links mal anzuschauen.

==== Um welche Motoren geht es genau? ====

Es geht hier um die sogenannten elektrisch kommutierten bürstenlosen Gleichstrommotoren (BLDC) aus dem Modellbaubereich.

Deren Eigenschaften sind:
* Haben drei Anschlüsse für die drei Phasen, ansonsten sind keine weiteren Anschlüsse vorhanden
* Werden in der Regel mit LiPo oder Nickel Akkus versorgt
* Leistung im Bereich von ca. 100W bis 2kW
* Spannungen im Bereich von ca. 7 bis 50V
* Ströme im Bereich von ca. 5 bis 120A

==== Um welche Motoren geht es hier nicht? ====

* Motoren mit Hallsensoren für die Rückmeldung
* Festplattenmotoren

Unter Umständen kann aber dieser Artikel auch für solche Motoren nützlich sein.

== Funktionsweise dieser Motoren ==

=== Ansteuerung ===

[[Datei:BLDC_Spannungs_Diagramm.png|thumb|right|250px|Ansteuerung der 3 Phasen]]

Grundsätzlich werden die 3 Phasen nacheinander bestromt, die Phasenspannungen wären also drei um 120° phasenverschobene Rechteckspannungen. Ein sinusförmiger Drehstrom ist nicht nötig, es genügen Rechteckspannungen. Mit einer Raumzeigermodulation könnte man die Stromaufnahme und die Geräuschentwicklung zwar noch verringern, macht die Ansteuerung aber einiges aufwändiger. Sogar die käuflichen Regler arbeiten nur mit Rechtecksignalen, zumindest die die ich kenne.

Dabei gibt es für jede Phase die Zustände „Low“, „High“ und „Floating“. Low bedeutet 0V (GND), High entspricht der Versorgungsspannung und Floating ist keines von beidem, die Phase „hängt in der Luft“. Bei „High“ wird aber noch der Mittelwert der Spannung per PWM eingestellt, über das Tastverhältnis wird schlussendlich die Drehzahl verändert! Dazu aber später mehr.

In der Grafik rechts kann man den Spannungsverlauf sehr gut erkennen. Das Diagramm zeigt aber nur den theoretischen Verlauf der Spannungen, wobei die gestrichelten Linien den Zustand "floating" symbolisieren. Dies kann man in einem Diagramm ja nicht wirklich darstellen, das ist einfach symbolisch gemeint. Interessanterweise sehen die Spannungen aufgrund der BEMF aber tatsächlich ziemlich ähnlich aus wie im Diagramm!

=== Die 6 Zustände ===

Wie man erkennen kann, werden 6 Zustände gebraucht, die sich dann immer wiederholen. Die Kommutierung ist also einfach ein Weiterschalten des Zustandes.
''Diese 6 Zustände sind nicht mit den drei Zuständen von oben (High, Low, Floating) zu verwechseln, das ist ein anderes Thema!''

In einer Tabelle dargestellt würde das folgendermassen aussehen:

{| class="wikitable"
! Zustand || Phase A || Phase B || Phase C || Stromfluss || Komparator-Eingänge
|-
| 1 || PWM || Floating || GND || A --> C || MITTEL <--> NULL_B
|-
| 2 || Floating || PWM || GND || B --> C || MITTEL <--> NULL_A
|-
| 3 || GND || PWM || Floating || B --> A || MITTEL <--> NULL_C
|-
| 4 || GND || Floating || PWM || C --> A || MITTEL <--> NULL_B
|-
| 5 || Floating || GND || PWM || C --> B || MITTEL <--> NULL_A
|-
| 6 || PWM || GND || Floating || A --> B || MITTEL <--> NULL_C
|}

Hinweise:
* Die Nummern in der ersten Spalte entsprechen genau den sechs Zuständen, die auch im obigen Diagramm nummeriert sind (Alle 6 Zustände zusammen bilden einen Zyklus, wie es auch im Diagramm dargestellt ist)
* Den Inhalt der letzten Spalte wird später noch erläutert. Die Bezeichnungen beziehen sich auf die [[#BEMF-Schaltung]].

=== Einsatz der BEMF ===
Das schaut bis jetzt eigentlich wie ein Synchronmotor oder Schrittmotor aus, was ein BLDC im Prinzip auch ist.

Wie schon erwähnt wurde, wird ein BLDC elektronisch kommutiert. Das heisst, die Kommutierung wird nicht einfach stur vorgegeben, sondern es wird immer Rücksicht auf die Ankerposition genommen. Dazu muss man allerdings wissen, wann man die Kommutierung genau auslösen soll.

Dieses Verfahren heißt Block-Kommutierung und ist ein Kompromiss aus (Regelungs-)Aufwand und Ergebnis:
Idealerweise werden die Ströme im Stator so eingeprägt, dass der Statorfluss dem Rotorfluss immer um 90° vorauseilt. Nur so wird das ideale Drehmoment erzeugt (siehe Literatur zur permanenterregten Synchronmaschine). Allerdings hat dieses Verfahren, auch Feldorientierte Regelung oder Vektor-Regelung genannt, den Nachteil, dass meistens teure Positionssensorik für den Rotor nowendig ist und auch die nötige Rechenleistung stark ansteigt. Die komplette Regelung muss für jede PWM-Periode gerechnet werden, damit sich der Aufwand lohnt.
BLDC-Motoren werden deshalb meist explizit so konstruiert, dass sich mit Block-Kommutierung ein konstantes Drehmoment einstellen kann. Der ideale Kommutierungszeitpunkt ist eigentlich ein Kommutierungswinkel, der Kommutierungszeitpunkt unter anderem deshalb drehzahlabhängig.

Zur Erreichung einer höheren Maximaldrehzahl kann das Rotorfeld durch das Statorfeld im sogenannten Feldschwäch-Betrieb geschwächt werden. Es ergeben sich Feldschwäch-(Blind)ströme im Bereich der Nennströme. Die Feldschwächung hat Einfluss auf den Kommutierungszeitpunkt.

Grundsätzlich kann auch ein BLDC nicht ohne Kenntnis der Lage des Rotors kommutiert werden. Und hier kommt die sogenannte Back Electromotive Force (BEMF) zum Einsatz. Von den drei Phasen liegt ja zu jedem Zeitpunkt genau eine Phase in der Luft wie man am Diagramm oben erkennen kann. Aufgrund des drehenden Magnetfeldes im Motor wird an dieser Phase nun eine Spannung induziert. Und genau diese induzierte Spannung gibt nun Auskunft darüber, in welchem Winkel sich der Anker befindet, und daraus kann man dann auch den Zeitpunkt der nächsten Kommutierung bestimmen.

Zusätzlich wird aber auch noch die Sternmittelpunktspannung der drei Phasen benötigt, welche aber leider nicht direkt zur Verfügung steht. Das ist aber kein Problem, mit drei Widerständen kann man sich die selber erzeugen (siehe [[#BEMF-Schaltung]]).

Jetzt sollten die BEMF-Spannungen die Sternmittelpunktspannung ständig kreuzen, was man dann mit einem Komparator erfassen kann. Und den Interrupt, den der Komparator auslöst, ist nun verantwortlich für die nächste Kommutierung.
Der Komparator wird natürlich nacheinander mit den drei Phasen gefüttert, es darf immer nur die Phase an den Komparator angeschlossen sein, die auch in der Luft hängt! In der Tabelle [[#Die 6 Zustände]] sieht man, welche zwei Spannungen der Komparator jeweils vergleichen muss.

Als Komparator kann man übrigens den integrierten nehmen, den es in den AVRs gibt. Diese (alle?) haben auch den benötigten Multiplexer, um zwischen den drei Analogquellen wählen zu können. Näheres dazu im Abschnitt [[#Software]].

== Hardware ==

=== Leistungsteil ===

==== Treiber ====

Um die drei notwendigen Zustände (''Low'', ''High'' und ''Floating'') für jede der drei Phasen realisieren zu können, werden drei Halbbrücken mit Mosfets benötigt. Hier gibt es dann auch schon mehrere Varianten, wie man das aufbauen kann. Grundsätzlich muss man sich mal überlegen ob fertige FET-Treiber oder diskrete Treiber verwendet werden sollen. Die FET-Treiber haben einige sehr schöne Vorteile, deshalb sollte man diese meiner Meinung nach bevorzugen.

Die Vorteile wären:

* Integrierter Kurzschlussschutz mit dead time, ein Softwarefehler kann die FETs nicht zerstören. Das kann in der Entwicklungsphase sehr von Vorteil sein :-)
* Die FETs können mit ordentlicher Geschwindigkeit geschaltet werden, und die Mikrocontroller-Ports werden trotzdem nicht stark belastet. So kann die Wärmeentwicklung der FETs noch etwas reduziert werden.
* Bei Treibern die mit nur einem Eingang zwischen Lowside und Highside Mosfets toggeln (z.B. IR2104), ist der sogenannte „aktiver Freilauf“ bereits in Hardware realisiert und ermöglicht so mit wenig Aufwand eine extrem niedrige Erwärmung der Mosfets. Das ermöglicht schon sehr grosse Ströme auch ohne Kühlkörper!
* Es können günstigere Mosfets verwendet werden, es müssen keine TTL-Kompatible FETs sein. Auch ist eine niedrige Gatekapazität nicht so von Bedeutung wie bei direkter Ansteuerung mit einem Mikrocontroller.
* Je nach dem welchen Treiber man verwendet, kann der Softwareaufwand und die Fehleranfälligkeit deutlich reduziert werden.

Nachteile von Treiber sind:

* Mehr Bauteile auf der Platine.
* Vermutlich insgesamt etwas teurer, auch wenn die FETs günstiger sind.
* Bei vielen Treibern ist eine Minimalspannung von ca. 10V notwendig, damit sie funktionieren. Bei einem fast leeren 3S LiPo Akku könnte das vielleicht schon kritisch werden. Auch darf z.B. beim IR2104 eine Spannung von 20V nicht überschritten werden. Daher kommt (ohne StepUp und StepDown Wandler) eigentlich fast nur noch ein 4S Akku in Frage. Möchte man einen grösseren Eingangsspannungsbereich haben muss man noch entsprechende Spannungsregler einbauen.

Ich persönlich habe es schon mit einem IR2104S probiert, dieser erscheint mir sehr geeignet für diese Aufgabe. Ich betreibe ihn mit einem 4S LiPo, damit läuft das Teil perfekt. Kann ich nur weiterempfehlen!

==== Beispielschaltung ====
[[Datei:BLDC_Leistungsteil_1.png|thumb|right|300px|Beispiel einer Halbbrücke inklusive Strommessung]]
Hier ein Beispiel, wie der Leistungsteil einer Phase aussehen könnte.

Für die exakte Beschaltung der Treiber muss man natürlich dessen Datenblatt studieren!

Hier sieht man auch gleich noch die Strommessung, die man natürlich nicht für jede Phase einzeln aufbauen muss. Man kann sie sogar ganz weglassen, sie könnte aber nützlich sein um eine Überlast des Motors erkennen zu können.

Der Widerstand R20 ist dazu da, dass auf dem Treiber das PWM-Signal liegt, sobald die Leitung „IN_A“ in der Luft hängt (uC Pin als Eingang definiert). So wird nur ein einziger PWM-Ausgang vom Mikrocontroller benötigt für alle drei Phasen, erfordert also kein Soft-PWM oder sonst irgend ein Murks. Diese Schaltung habe ich übrigens beim Mikrokopter-Projekt abgeschaut.

Übrigens muss an die Versorgung unbedingt noch ein grosser Elko gehängt werden, am besten möglichst nahe an die Mosfets (keine langen Leitungen zwischen Elko und Mosfets). Die erforderliche Kapazität hängt davon ab, wieviel Strom der Motor braucht. bei kleinen bis mittleren Motoren sollten so 220uF bis 680uF ausreichend sein.

=== BEMF-Schaltung ===

[[Datei:BLDC_BEMF_schaltung.png|thumb|right|300px|BEMF-Schaltung]]

Ein wichtiger Teil ist aber auch die BEMF-Schaltung. Dabei wird häufig die Schaltung vom Mikrokopter eingesetzt (siehe Schaltung rechts).

Die Schaltung besteht erstmal aus drei Spannungsteilern, die die Phasenspannungen auf ein Spannungsniveau heruntersetzen, das man auf die Mikrokontrollereingänge legen darf. Keramikkondensatoren glätten diese Spannungen, weil die aufgrund der PWM sonst sehr stark ausschlagen. Dann gehen diese drei Spannungen (''NULL_A'', ''NULL_B'' und ''NULL_C'') auf drei ADC-Eingänge des Mikrocontrollers.

Und dann sind da noch die drei Widerstände, die aus den Spannungen ''NULL_A'', ''NULL_B'' und ''NULL_C'' einen virtuellen Sternmittelpunkt bilden. Diese Mittelpunktspannung (''MITTEL'') kommt dann auf den Komparatoreingang ''AIN0'' vom AVR. Diese Spannung soll der Komparator später dann mit jeweils einer der Spannungen ''NULL_A'', ''NULL_B'' und ''NULL_C'' vergleichen um den Kommutierungszeitpunkt bestimmen zu können.

Man kann die Widerstands-/ und Kapazitätswerte auch noch anpassen. Bei höheren Eingangsspannungen muss man darauf achten, dass die Eingänge vom AVR keine zu hohe Spannung abkriegen! Ein Regler, den ich gekauft habe, hat einiges höhere Widerstandswerte und kommt sogar ohne Kondensatoren aus. Hier hat man also durchaus noch Spielraum um ein bisschen zu tüfteln, für den Anfang ist die abgebildete Schaltung aber bestens geeignet.

=== Mikrocontroller ===

Als Mikrocontroller sind viele Typen aus der AVR-Serie geeignet. Bei der BrushlessCtrl wird zum Beispiel ein ATMega168 eingesetzt. Mit diesem habe ich auch mal angefangen, der scheint wirklich gut geeignet zu sein. Es reicht aber auch ein ATMega88 wenn man nicht alle möglichen Protokolle und Ansteuerungsarten (I2C, SPI, PPM) gleichzeitig einbauen will.

Viele Regler verwenden auch einen AT90PWM, vorallem wenn mehrere PWM-Kanäle gebraucht werden.

Übrigens wird bei käuflichen Reglern extrem häufig ein ATMega8 eingesetzt! Wenn man nur Software entwickeln möchte kann man auch einen solchen Regler kaufen und das eigene Programm aufspielen. Bei den [[#Weblinks]] findet man dazu auch noch Informationen.

Um eine Raumzeigermodulation zu implementieren wird dann aber vermutlich schon ein 32-Bit Mikrocontroller nötig sein. Aber wie schon erwähnt ist für ein Modellbaumotor eine Raumzeigermodulation keinesfalls ein must-have.

== Software ==

Bei der Software kommt es jetzt natürlich sehr stark darauf an, wie die Hardware aufgebaut ist. Ich möchte hier aber nicht auf jede Variante eingehen, das gäbe viel zu viel Arbeit. Auch will ich ja keinen fertigen Code bereitstellen, sondern nur Hinweise und Tipps geben. Wer nicht selber programmieren will, der kann ja mal die Mikrokopter-Firmware herunterladen, die älteren Versionen davon gibt es auf der Mikrokopter-Seite zum downloaden.

Wichtig sind auf jeden Fall [[#Die 6 Zustände]]. Der Mikrocontroller muss die Phasen jeweils nacheinander so wie in der Tabelle ansteuern. Das ist soweit ja kein Problem, schwierig ist aber immer der richtige Zeitpunkt für die Kommutierung zu finden.

Falls man einen IR2104 oder einen ähnlichen Treiber verwendet, würde die Software ungefähr so aussehen:

* Beim Programmstart wird schonmal der PWM-Ausgang mit einem Timer aktiviert. Die Frequenz liegt normalerweise so im Bereich 12 bis 25kHz. Ich selber verwende 20kHz, da hört man dann auch dieses Pfeifen nicht mehr.
* Der Interrupt vom Analogkomparator muss aktiviert werden, um die Kommutierungszeitpunkte bestimmen zu können.
* Dann habe ich eine Funktion, welche den Zustand (1 bis 6) eins weiterschaltet und die Ausgänge entsprechend setzt. Dabei werden die Pins, die das PWM-Signal enthalten sollen, einfach als Eingang definiert, wie ich schonmal erwähnte.
* Wichtig ist ausserdem, dass bei jeder Kommutierung auch noch der richtige ADC-Kanal auf den Komparator geleitet wird per Multiplexer. Dieser Kanal wird bei jeder Kommutierung eins weitergeschaltet.
* Danach muss nur noch gewartet werden bis der Analogkomparator einen Interrupt auslöst. Sobald dies geschieht, wird die nächste Kommutierung per Timer (30° Verzögerung) ausgelöst, und das Spiel beginnt wieder von vorne.

Je nach Komplexität des BLDC Controllers und des damit verbundenen Programmieraufwands ist es aber auch möglich (wie von sehr vielen Nutzern implementiert) die Kommutierung direkt nach dem Analog-Komparator Interrupt auszulösen - d.h. mit 0° Verzögerung. In diesem Fall spricht man von Phasenvoreilender (phaseadvance) Ansteuerung. Der Motor kann dadurch eine höhere Maximaldrehzahl erreichen, jedoch mit geringerem Drehmoment - die Stromaufnahme ist höher und der Wirkungsgrad geringer (siehe [http://ww1.microchip.com/downloads/en/AppNotes/01083a.pdf AN1083, Seite 18]). Der Effekt ist ähnlich dem Feldschwächebetrieb einer Asynchronmaschine.

Die Drehzahl des Motors lässt sich jetzt ganz bequem ändern, indem man den Duty-Cycle des PWM-Signales verändert. Der Motor beschleunigt bzw. bremst dann von alleine. Übrigens ist es empfehlenswert, den Sollwert etwas zu "dämpfen", damit keine schlagartigen Änderungen des Duty-Cycles erfolgen können. Vor allem schlagartige Abbremsmanöver können starke Überspannungsspitzen hervorrufen, die den Regler zerstören können!

=== Anlauf ===

So, das war jetzt die Beschreibung für einen Motor, der bereits läuft. '''Bis''' der Motor allerdings mal dreht, muss man anders vorgehen, weil der stillstehende Motor ja keine Komparator-Interrupts auslöst, da keine BEMF vorhanden ist.

Daher muss man den Motor zuerst mit einem starren Drehfeld auf eine gewisse Drehzahl beschleunigen, wie bei einem Schrittmotor. Sobald eine genügend hohe Drehzahl erreicht wurde, kann man in den geregelten Betrieb schalten. Am besten schaltet man dazu einfach alle Phasen ab und aktiviert den Komparator. Sobald der erste Interrupt vom Komparator ausgelöst wird, werden die Phasen wieder eingeschaltet.

Der ganze Startvorgang ist aber schon eine Wissenschaft für sich. Es braucht (nach meiner Erfahrung) viel Zeit und Nerven, bis alles richtig funktioniert. Man kann aber am Anfang den Motor auch von Hand anwerfen, das geht viel einfacher als mit einer Zwangskommutierung. Ein Oszilloskop ist eigentlich auch absolut notwendig, um analysieren zu können was der Regler und die BEMF genau macht.

Ganz wichtig aber an dieser Stelle: '''Wenn der Motor mit einem starren Drehfeld angesteuert wird, sieht die BEMF alles andere als schön aus!''' Das liegt daran, dass der Motor bei jeder Kommutierung beschleunigt, und danach wieder abgebremst wird, der Motor läuft einfach nicht „rund“. Wenn ihr also irgendwas komisches auf dem Oszilloskop seht, ist das kein Fehler in eurer Schaltung, das ist normal bei Zwangskommutierung!

Wenn Ihr die BEMF auf dem Oszilloskop anschauen wollt, könnt Ihr entweder den Motor einfach von Hand drehen, oder ihr dreht den Motor mit Zwangskommutierung hoch, und schaltet dann alle Phasen ab (nicht auf GND, in der Luft hängend). Direkt nach dem Abschalten der Phasen sollte die BEMF einen relativ schönen Drehstrom zeigen (muss ich selbst noch kontrollieren ob das wirklich der Fall ist :-) )
Anmerkung JB: Gerade an einem Festplattenmotor getestet, bei Drehung von der Hand lassen bis zu 600mVss sinusförmig auf dem Oszilloskop blicken, Frequenz bis zu 20 Hz, muss sich umeinen mehrpoligen Motor Handeln, so schnell hab ich nicht gedreht ;)

Bis jetzt habe ich es mit dieser Variante aber noch nicht so richtig geschafft, einen brauchbaren Anlaufvorgang hinzukriegen. Ich glaube auch, dass gekaufte Regler das nicht so machen. Diese scheinen nur einen kräftigen Strom auf eine Phase zu geben, und werten dann die entstandene BEMF aus, aus der dann berechnet werden kann, welche Phase als nächstes bestromt werden muss. So richtig habe ich das aber noch nicht angeschaut, '''vielleicht weiss hier jemand besser Bescheid und könnte es hier beschreiben?'''

Das Prinzip eines Anlaufvorgangs eines sensorlosen BLDC ist folgendes:
- Man präge ein Feld ein, bei dem angenommen werden muss, dass der Motor diesem ab Stillstand auch folgt.
- Sobald diese Annahme durch Auftreten eines durch BEMF erzeugten Ereignisses bestätigt wird, kann in den geregelten Betrieb umgeschaltet werden.

Es ist mitunter Hilfreich zum Starten eine Delay-Tabelle zu verwenden, damit braucht man sich nicht durch eine feste Frequenz-Vorgabe selbst zu bremsen. Dauert evtl. etwas beim Einstellen,
soll aber laut Atmel-Application-Note für BLCD-Motoren funktionieren. Den Rotor vorher noch durch Bestromen einer Phase und danach warten in eine definierte Anfangsposition drehen.

=== Komparator ===

Wenn man sich für die Kommutierungs-Erkennung per Analogkomparator entscheidet, muss man noch ein sehr nützliches Feature von den AVRs kennen. Da man ja abwechslungsweise drei verschiedene Signale (BEMF_A...C) mit der Mittelpunktspannung vergleichen muss, aber nur ein einziger Analogkomparator vorhanden ist, muss man den sogenannten Analog-Multiplexer benutzen. Mit diesem in den AVRs integrierten Multiplexer kann man nun die Spannung am Pin "AIN0" mit einem beliebigen Analogeingang (ADC0...ADC7) vergleichen. Natürlich kann man nicht mehrere Kanäle gleichzeitig anwählen, da es nur einen einzigen Komparator gibt. Das ist für unsere Anwendung allerdings kein Problem, wir müssen immer nur eines der BEMF-Signale mit der Mittelpunktspannung vergleichen.

Näheres dazu und wie man den Multiplexer benutzt erfährt man im Datenblatt des verwendeten Mikrocontrollers. Der entsprechende Abschnitt heisst "Analog Comparator Multiplexed Input" (unter "Analog Comparator").

=== Schnittstellen ===

Man kann nun den Sollwert der Drehzahl wahlweise über einen PPM-Eingang, über [[UART]], [[SPI]], [[I2C]] oder mit einem Potentiometer vorgeben. Welche Ansteuerung man wählt hängt davon ab, wie und wo der Motor eingesetzt werden soll und ist deshalb jedem selber überlassen.

== Bildmaterial ==
=== Oszillogramme ===

[[Datei: BLDC_Oszillogramm_Phasen_PWM.png|300px]]

Die drei Phasen während dem geregelten Betrieb, die BEMF ist sehr schön zu erkennen (immer zwischen den Zuständen "PWM" und "LOW").

[[Datei: BLDC_Oszillogramm_Phasen_Vollgas.png|300px]]

So sehen die drei Phasen bei Vollgas aus (100% PWM). Die BEMF ist jetzt sogar so steil, dass sie die beiden Zustände ''Low'' und ''High'' mit einer fast perfekten Geraden verbindet!

[[Datei: BLDC_Oszillogramm_BEMF_richtig.png|300px]]

* Gelb: Phase A, BEMF sehr schön erkennbar
* Blau: Mittelpunktspannung
* Rot: BEMF von Phase A (nach der BEMF-Schaltung!)
* Grün: Komparator-Interrupts (steigende Flanke) Jeder dritte Interrupt gehört zur Phase A, die anderen Interrupts stammen von den anderen Phasen, die nicht auf dem Bild zu sehen sind.

[[Datei: BLDC_Oszillogramm_BEMF_falsch.png|300px]]

So kann z.B. die BEMF während der Zwangskommutierung aussehen. Dadurch werden auch zu viele Komparator-Interrupts (Grün, jede Flanke) ausgelöst. Kein schöner Anblick...

[[Datei: BLDC_Oszillogramm_Anlauf_1.png|300px]]

So sieht der Anlaufvorgang bei einem gekauften Regler aus. eine extrem kurze Geschichte im Vergleich mit meinen paar Umdrehungen mit Zwangskommutierung. Wer kennt das Geheimnis?
Sieht so aus als würde für eine kurze Zeit Strom eingeprägt um den Motor in eine definierte, stehende Position zu bringen. Danach wird weiter kummutiert, der Motor dreht an und es wird sofort ueber die BEMF kommutiert.

=== Layouts ===

Als Anregung, wie so ein Regler aussehen könnte (nur 40x26mm klein, inklusive Optokoppler, drei Treibern und drei schönen Stecker!):

[[Datei: BLDC_Eagle3d_top_1.jpg|300px]]

[[Datei: BLDC_Eagle3d_bot_1.jpg|300px]]

Der HCPL-0600 auf der Unterseite ist übrigens ein Optokoppler um das PPM-Eingangssignal galvanisch zu entkoppeln. Ist nicht zwingend nötig, war aber grad Platz da... :-)

== Siehe Auch ==
* [http://www.mikrocontroller.net/topic/248509 Diskussion zum Artikel]
* [[BLDC Demo Board]]
* [[Treiber]]
* [[Mosfet-Übersicht]]
* [[Leiterbahnbreite]] Unbedingt beachten bei grösseren Strömen!
* [[Kühlkörper]] Bei sehr hohen Strömen evtl. nötig

== Weblinks ==
* [http://www.atmel.com/Images/doc8012.pdf AppNote AVR444 von Atmel]
* [http://ww1.microchip.com/downloads/en/AppNotes/00885a.pdf BLDC Theorie(AN885 Microchip)]
* [http://www.mikrokopter.de/ucwiki/BrushlessCtrl BrushlessCtrl vom Mikrokopter]
* [http://svn.mikrokopter.de/listing.php?repname=BL-Ctrl& Software vom Mikrokopter Brushless-Regler]
* [http://home.versanet.de/~b-konze/ Die Seite von B. Konze, einer der Pioniere in diesem Bereich]
* [http://www.rcgroups.com/forums/showthread.php?t=1513678 Ein Thema auf rcgroups.com (Englisch) wo einige käuflichen Regler näher angeschaut wurden und eine eigene Firmware angeboten wird]
* [http://rmmx.gmxhome.de/bldchv/start.html Ein Regler-Projekt für etwas grössere Motoren]
* [http://www.fc00.de/quadrokopter_6_kw.htm Regler für sehr grosse Motoren]
* [http://ww1.microchip.com/downloads/en/AppNotes/01083a.pdf Appnote AN1083 von Microchip, sehr detailliert]
[[Kategorie:Motoren]]

Brushless-Controller für Modellbaumotoren

2012-05-19T12:02:40Z

46.128.38.250: /* Anlauf */

== Einleitung ==

Im Internet gibt es einige grundlegende Informationen zur Funktionsweise und Ansteuerung von Brushless-Motoren (BLDC). Für die Entwicklung eines solchen Reglers findet man aber nur wenig richtig detaillierte Informationen und Erfahrungsberichte. In diesem Artikel sollen genau diese Lücken geschlossen werden. Es soll hier aber kein fertiges Produkt (Schaltplan + Layout + Software) angeboten werden. Viel mehr soll es die Eigenentwicklung unterstützen, Ideen und Erfahrungen anbieten.

An dieser Stelle weise ich noch darauf hin, dass man bei den [[#Weblinks]] noch einige sehr gute Informationen findet! Es gibt dort Hardware und Software, es lohnt sich die Links mal anzuschauen.

==== Um welche Motoren geht es genau? ====

Es geht hier um die sogenannten elektrisch kommutierten bürstenlosen Gleichstrommotoren (BLDC) aus dem Modellbaubereich.

Deren Eigenschaften sind:
* Haben drei Anschlüsse für die drei Phasen, ansonsten sind keine weiteren Anschlüsse vorhanden
* Werden in der Regel mit LiPo Akkus versorgt
* Leistung im Bereich von ca. 100W bis 2kW
* Spannungen im Bereich von ca. 10 bis 50V
* Ströme im Bereich von ca. 5 bis 120A

==== Um welche Motoren geht es hier nicht? ====

* Motoren mit Hallsensoren für die Rückmeldung
* Festplattenmotoren

Unter Umständen kann aber dieser Artikel auch für solche Motoren nützlich sein.

== Funktionsweise dieser Motoren ==

=== Ansteuerung ===

[[Datei:BLDC_Spannungs_Diagramm.png|thumb|right|250px|Ansteuerung der 3 Phasen]]

Grundsätzlich werden die 3 Phasen nacheinander bestromt, die Phasenspannungen wären also drei um 120° phasenverschobene Rechteckspannungen. Ein sinusförmiger Drehstrom ist nicht nötig, es genügen Rechteckspannungen. Mit einer Raumzeigermodulation könnte man die Stromaufnahme und die Geräuschentwicklung zwar noch verringern, macht die Ansteuerung aber einiges aufwändiger. Sogar die käuflichen Regler arbeiten nur mit Rechtecksignalen, zumindest die die ich kenne.

Dabei gibt es für jede Phase die Zustände „Low“, „High“ und „Floating“. Low bedeutet 0V (GND), High entspricht der Versorgungsspannung und Floating ist keines von beidem, die Phase „hängt in der Luft“. Bei „High“ wird aber noch der Mittelwert der Spannung per PWM eingestellt, über das Tastverhältnis wird schlussendlich die Drehzahl verändert! Dazu aber später mehr.

In der Grafik rechts kann man den Spannungsverlauf sehr gut erkennen. Das Diagramm zeigt aber nur den theoretischen Verlauf der Spannungen, wobei die gestrichelten Linien den Zustand "floating" symbolisieren. Dies kann man in einem Diagramm ja nicht wirklich darstellen, das ist einfach symbolisch gemeint. Interessanterweise sehen die Spannungen aufgrund der BEMF aber tatsächlich ziemlich ähnlich aus wie im Diagramm!

=== Die 6 Zustände ===

Wie man erkennen kann, werden 6 Zustände gebraucht, die sich dann immer wiederholen. Die Kommutierung ist also einfach ein Weiterschalten des Zustandes.
''Diese 6 Zustände sind nicht mit den drei Zuständen von oben (High, Low, Floating) zu verwechseln, das ist ein anderes Thema!''

In einer Tabelle dargestellt würde das folgendermassen aussehen:

{| class="wikitable"
! Zustand || Phase A || Phase B || Phase C || Stromfluss || Komparator-Eingänge
|-
| 1 || PWM || Floating || GND || A --> C || MITTEL <--> NULL_B
|-
| 2 || Floating || PWM || GND || B --> C || MITTEL <--> NULL_A
|-
| 3 || GND || PWM || Floating || B --> A || MITTEL <--> NULL_C
|-
| 4 || GND || Floating || PWM || C --> A || MITTEL <--> NULL_B
|-
| 5 || Floating || GND || PWM || C --> B || MITTEL <--> NULL_A
|-
| 6 || PWM || GND || Floating || A --> B || MITTEL <--> NULL_C
|}

Hinweise:
* Die Nummern in der ersten Spalte entsprechen genau den sechs Zuständen, die auch im obigen Diagramm nummeriert sind (Alle 6 Zustände zusammen bilden einen Zyklus, wie es auch im Diagramm dargestellt ist)
* Den Inhalt der letzten Spalte wird später noch erläutert. Die Bezeichnungen beziehen sich auf die [[#BEMF-Schaltung]].

=== Einsatz der BEMF ===
Das schaut bis jetzt eigentlich wie ein Synchronmotor oder Schrittmotor aus, was ein BLDC im Prinzip auch ist.

Wie schon erwähnt wurde, wird ein BLDC elektronisch kommutiert. Das heisst, die Kommutierung wird nicht einfach stur vorgegeben, sondern es wird immer Rücksicht auf die Ankerposition genommen. Dazu muss man allerdings wissen, wann man die Kommutierung genau auslösen soll.

Dieses Verfahren heißt Block-Kommutierung und ist ein Kompromiss aus Aufwand und Ergebnis:
Idealerweise werden die Ströme im Stator so eingeprägt, dass der Statorfluss dem Rotorfluss immer um 90° vorauseilt. Nur so wir das ideale Drehmoment erzeugt (siehe Literatur zur permanenterregten Synchronmaschine). Allerdings hat dieses Verfahren, auch Feldorientierte Regelung oder Vektor-Regelung genannt, den Nachteil, dass meistens teure Positionssensorik für den Rotor nowendig ist und auch die nötige Rechenleistung stark ansteigt. Die komplette Regelung muss für jede PWM-Periode gerechnet werden, damit sich der Aufwand lohnt.
Im Fall der Block-Kommutierung ist der ideale Kommutierungszeitpunkt also der, bei dem das Stator-Feld dem Rotor-Feld im Mittel um 90 ° vorauseilt. Dieser ideale Kommutierungszeitpunkt ist wegen der als konstant angenommenen Rechenzeit für die Kommutierung drehzahlabhängig.

Zur Erreichung einer höheren Maximaldrehzahl kann das Rotorfeld durch das Statorfeld im sogenannten Feldschwäch-Betrieb geschwächt werden. Es ergeben sich Feldschwäch-(Blind)ströme im Bereich der Nennströme.

Grundsätzlich kann auch ein BLDC nicht ohne Kenntnis der Lage des Rotors kommutiert werden. Und hier kommt die sogenannte Back Electromotive Force (BEMF) zum Einsatz. Von den drei Phasen liegt ja zu jedem Zeitpunkt genau eine Phase in der Luft wie man am Diagramm oben erkennen kann. Aufgrund des drehenden Magnetfeldes im Motor wird an dieser Phase nun eine Spannung induziert. Und genau diese induzierte Spannung gibt nun Auskunft darüber, in welchem Winkel sich der Anker befindet, und daraus kann man dann auch den Zeitpunkt der nächsten Kommutierung bestimmen.

Zusätzlich wird aber auch noch die Sternmittelpunktspannung der drei Phasen benötigt, welche aber leider nicht direkt zur Verfügung steht. Das ist aber kein Problem, mit drei Widerständen kann man sich die selber erzeugen (siehe [[#BEMF-Schaltung]]).

Jetzt sollten die BEMF-Spannungen die Sternmittelpunktspannung ständig kreuzen, was man dann mit einem Komparator erfassen kann. Und den Interrupt, den der Komparator auslöst, ist nun verantwortlich für die nächste Kommutierung.
Der Komparator wird natürlich nacheinander mit den drei Phasen gefüttert, es darf immer nur die Phase an den Komparator angeschlossen sein, die auch in der Luft hängt! In der Tabelle [[#Die 6 Zustände]] sieht man, welche zwei Spannungen der Komparator jeweils vergleichen muss.

Als Komparator kann man übrigens den integrierten nehmen, den es in den AVRs gibt. Diese (alle?) haben auch den benötigten Multiplexer, um zwischen den drei Analogquellen wählen zu können. Näheres dazu im Abschnitt [[#Software]].

== Hardware ==

=== Leistungsteil ===

==== Treiber ====

Um die drei notwendigen Zustände (''Low'', ''High'' und ''Floating'') für jede der drei Phasen realisieren zu können, werden drei Halbbrücken mit Mosfets benötigt. Hier gibt es dann auch schon mehrere Varianten, wie man das aufbauen kann. Grundsätzlich muss man sich mal überlegen ob fertige FET-Treiber oder diskrete Treiber verwendet werden sollen. Die FET-Treiber haben einige sehr schöne Vorteile, deshalb sollte man diese meiner Meinung nach bevorzugen.

Die Vorteile wären:

* Integrierter Kurzschlussschutz mit dead time, ein Softwarefehler kann die FETs nicht zerstören. Das kann in der Entwicklungsphase sehr von Vorteil sein :-)
* Die FETs können mit ordentlicher Geschwindigkeit geschaltet werden, und die Mikrocontroller-Ports werden trotzdem nicht stark belastet. So kann die Wärmeentwicklung der FETs noch etwas reduziert werden.
* Bei Treibern die mit nur einem Eingang zwischen Lowside und Highside Mosfets toggeln (z.B. IR2104), ist der sogenannte „aktiver Freilauf“ bereits in Hardware realisiert und ermöglicht so mit wenig Aufwand eine extrem niedrige Erwärmung der Mosfets. Das ermöglicht schon sehr grosse Ströme auch ohne Kühlkörper!
* Es können günstigere Mosfets verwendet werden, es müssen keine TTL-Kompatible FETs sein. Auch ist eine niedrige Gatekapazität nicht so von Bedeutung wie bei direkter Ansteuerung mit einem Mikrocontroller.
* Je nach dem welchen Treiber man verwendet, kann der Softwareaufwand und die Fehleranfälligkeit deutlich reduziert werden.

Nachteile von Treiber sind:

* Mehr Bauteile auf der Platine.
* Vermutlich insgesamt etwas teurer, auch wenn die FETs günstiger sind.
* Bei vielen Treibern ist eine Minimalspannung von ca. 10V notwendig, damit sie funktionieren. Bei einem fast leeren 3S LiPo Akku könnte das vielleicht schon kritisch werden. Auch darf z.B. beim IR2104 eine Spannung von 20V nicht überschritten werden. Daher kommt (ohne StepUp und StepDown Wandler) eigentlich fast nur noch ein 4S Akku in Frage. Möchte man einen grösseren Eingangsspannungsbereich haben muss man noch entsprechende Spannungsregler einbauen.

Ich persönlich habe es schon mit einem IR2104S probiert, dieser erscheint mir sehr geeignet für diese Aufgabe. Ich betreibe ihn mit einem 4S LiPo, damit läuft das Teil perfekt. Kann ich nur weiterempfehlen!

==== Beispielschaltung ====
[[Datei:BLDC_Leistungsteil_1.png|thumb|right|300px|Beispiel einer Halbbrücke inklusive Strommessung]]
Hier ein Beispiel, wie der Leistungsteil einer Phase aussehen könnte.

Für die exakte Beschaltung der Treiber muss man natürlich dessen Datenblatt studieren!

Hier sieht man auch gleich noch die Strommessung, die man natürlich nicht für jede Phase einzeln aufbauen muss. Man kann sie sogar ganz weglassen, sie könnte aber nützlich sein um eine Überlast des Motores erkennen zu können.

Der Widerstand R20 ist dazu da, dass auf dem Treiber das PWM-Signal liegt, sobald die Leitung „IN_A“ in der Luft hängt (uC Pin als Eingang definiert). So wird nur ein einziger PWM-Ausgang vom Mikrocontroller benötigt für alle drei Phasen, erfordert also kein Soft-PWM oder sonst irgend ein Murks. Diese Schaltung habe ich übrigens beim Mikrokopter-Projekt abgeschaut.

Übrigens muss an die Versorgung unbedingt noch ein grosser Elko gehängt werden, am besten möglichst nahe an die Mosfets (keine langen Leitungen zwischen Elko und Mosfets). Die erforderliche Kapazität hängt davon ab, wieviel Strom der Motor braucht. bei kleinen bis mittleren Motoren sollten so 220uF bis 680uF ausreichend sein.

=== BEMF-Schaltung ===

[[Datei:BLDC_BEMF_schaltung.png|thumb|right|300px|BEMF-Schaltung]]

Ein wichtiger Teil ist aber auch die BEMF-Schaltung. Dabei wird häufig die Schaltung vom Mikrokopter eingesetzt (siehe Schaltung rechts).

Die Schaltung besteht erstmal aus drei Spannungsteilern, die die Phasenspannungen auf ein Spannungsniveau heruntersetzen, das man auf die Mikrokontrollereingänge legen darf. Keramikkondensatoren glätten diese Spannungen, weil die aufgrund der PWM sonst sehr stark ausschlagen. Dann gehen diese drei Spannungen (''NULL_A'', ''NULL_B'' und ''NULL_C'') auf drei ADC-Eingänge des Mikrocontrollers.

Und dann sind da noch die drei Widerstände, die aus den Spannungen ''NULL_A'', ''NULL_B'' und ''NULL_C'' einen virtuellen Sternmittelpunkt bilden. Diese Mittelpunktspannung (''MITTEL'') kommt dann auf den Komparatoreingang ''AIN0'' vom AVR. Diese Spannung soll der Komparator später dann mit jeweils einer der Spannungen ''NULL_A'', ''NULL_B'' und ''NULL_C'' vergleichen um den Kommutierungszeitpunkt bestimmen zu können.

Man kann die Widerstands-/ und Kapazitätswerte auch noch anpassen. Bei höheren Eingangsspannungen muss man darauf achten, dass die Eingänge vom AVR keine zu hohe Spannung abkriegen! Ein Regler, den ich gekauft habe, hat einiges höhere Widerstandswerte und kommt sogar ohne Kondensatoren aus. Hier hat man also durchaus noch Spielraum um ein bisschen zu tüfteln, für den Anfang ist die abgebildete Schaltung aber bestens geeignet.

=== Mikrocontroller ===

Als Mikrocontroller sind viele Typen aus der AVR-Serie geeignet. Bei der BrushlessCtrl wird zum Beispiel ein ATMega168 eingesetzt. Mit diesem habe ich auch mal angefangen, der scheint wirklich gut geeignet zu sein. Es reicht aber auch ein ATMega88 wenn man nicht alle möglichen Protokolle und Ansteuerungsarten (I2C, SPI, PPM) gleichzeitig einbauen will.

Viele Regler verwenden auch einen AT90PWM, vorallem wenn mehrere PWM-Kanäle gebraucht werden.

Übrigens wird bei käuflichen Reglern extrem häufig ein ATMega8 eingesetzt! Wenn man nur Software entwickeln möchte kann man auch einen solchen Regler kaufen und das eigene Programm aufspielen. Bei den [[#Weblinks]] findet man dazu auch noch Informationen.

Um eine Raumzeigermodulation zu implementieren wird dann aber vermutlich schon ein 32-Bit Mikrocontroller nötig sein. Aber wie schon erwähnt ist für ein Modellbaumotor eine Raumzeigermodulation keinesfalls ein must-have.

== Software ==

Bei der Software kommt es jetzt natürlich sehr stark darauf an, wie die Hardware aufgebaut ist. Ich möchte hier aber nicht auf jede Variante eingehen, das gäbe viel zu viel Arbeit. Auch will ich ja kein fertiger Code bereitstellen, sondern nur Hinweise und Tipps geben. Wer nicht selber programmieren will, der kann ja mal die Mikrokopter-Firmware herunterladen, die älteren Versionen davon gibt es auf der Mikrokopter-Seite zum downloaden.

Wichtig sind auf jeden Fall [[#Die 6 Zustände]]. Der Mikrocontroller muss die Phasen jeweils nacheinander so wie in der Tabelle ansteuern. Das ist soweit ja kein Problem, schwierig ist aber immer der richtige Zeitpunkt für die Kommutierung zu finden.

Falls man einen IR2104 oder einen ähnlichen Treiber verwendet, würde die Software ungefähr so aussehen:

* Beim Programmstart wird schonmal der PWM-Ausgang mit einem Timer aktiviert. Die Frequenz liegt normalerweise so im Bereich 12 bis 25kHz. Ich selber verwende 20kHz, da hört man dann auch dieses Pfeifen nicht mehr.
* Der Interrupt vom Analogkomparator muss aktiviert werden, um die Kommutierungszeitpunkte bestimmen zu können.
* Dann habe ich eine Funktion, welche den Zustand (1 bis 6) eins weiterschaltet und die Ausgänge entsprechend setzt. Dabei werden die Pins, die das PWM-Signal enthalten sollen, einfach als Eingang definiert, wie ich schonmal erwähnte.
* Wichtig ist ausserdem, dass bei jeder Kommutierung auch noch der richtige ADC-Kanal auf den Komparator geleitet wird per Multiplexer. Dieser Kanal wird bei jeder Kommutierung eins weitergeschaltet.
* Danach muss nur noch gewartet werden bis der Analogkomparator einen Interrupt auslöst. Sobald dies geschieht, wird die nächste Kommutierung ausgelöst, und das Spiel beginnt wieder von vorne.

Ich glaube aber, dass dies noch nicht die ganz richtige Art ist, wie man die Kommutierung auslöst. Ich denke, man müsste nach einem Interrupt eine gewisse Zeit warten (je nach Kommutierungswinkel oder wie das heisst) und erst kurz vor dem nächsten Interrupt die Kommutierung auslösen. Also quasi immer einen Zustand später. Dazu muss aber die Verzögerungszeit ständig ausgerechnet werden, damit die auch bei jeder Drehzahl stimmt. Ich habe es selber noch nicht so implementiert, kann daher nicht sagen ob das so dann richtig funktioniert. '''Falls hier jemand besser Bescheid weiss, wäre es cool wenn man das hier noch ergänzen könnte.'''

Laut Literatur liegt der optimale Kommutierungszeitpunkt 30° nach dem Nulldurchgang der Spannung am nicht beschalteten Eingang. Die naheliegendste Möglichkeit wäre also die Zeit, die bei der aktuellen Drehzahl für eine Umdrehung benötigt wird, durch zwölf zu dividieren und so lange bis zur Kommutierung zu warten.

Ausserdem scheint es auch Regler zu geben, die eine Kommutierung nicht mit dem Analogkomparator erfassen, sondern direkt mit ADC-Wandlungen. Dazu weiss ich aber leider auch nichts näheres, deshalb auch hier: '''Wenn jemand weiss, was es damit auf sich hat, bitte melden.'''

Die Drehzahl des Motores lässt sich jetzt ganz bequem ändern, indem man den Duty-Cycle des PWM-Signales verändert. Der Motor beschleunigt bzw. bremst dann von alleine.

=== Anlauf ===

So, das war jetzt die Beschreibung für einen Motor, der bereits läuft. '''Bis''' der Motor allerdings mal dreht, muss man anders vorgehen, weil der stillstehende Motor ja keine Komparator-Interrupts auslöst, da keine BEMF vorhanden ist.

Daher muss man den Motor zuerst mit einem starren Drehfeld auf eine gewisse Drehzahl beschleunigen, wie bei einem Schrittmotor. Sobald eine genügend hohe Drehzahl erreicht wurde, kann man in den geregelten Betrieb schalten. Am besten schaltet man dazu einfach alle Phasen ab und aktiviert den Komparator. Sobald der erste Interrupt vom Komparator ausgelöst wird, werden die Phasen wieder eingeschaltet.

Der ganze Startvorgang ist aber schon eine Wissenschaft für sich. Es braucht (nach meiner Erfahrung) viel Zeit und Nerven, bis alles richtig funktioniert. Man kann aber am Anfang den Motor auch von Hand anwerfen, das geht viel einfacher als mit einer Zwangskommutierung. Ein Oszilloskop ist eigentlich auch absolut notwendig, um analysieren zu können was der Regler und die BEMF genau macht.

Ganz wichtig aber an dieser Stelle: '''Wenn der Motor mit einem starren Drehfeld angesteuert wird, sieht die BEMF alles andere als schön aus!''' Das liegt daran, dass der Motor bei jeder Kommutierung beschleunigt, und danach wieder abgebremst wird, der Motor läuft einfach nicht „rund“. Wenn ihr also irgendwas komisches auf dem Oszilloskop seht, ist das kein Fehler in eurer Schaltung, das ist normal bei Zwangskommutierung!

Wenn Ihr die BEMF auf dem Oszilloskop anschauen wollt, könnt Ihr entweder den Motor einfach von Hand drehen, oder ihr dreht den Motor mit Zwangskommutierung hoch, und schaltet dann alle Phasen ab (nicht auf GND, in der Luft hängend). Direkt nach dem Abschalten der Phasen sollte die BEMF einen relativ schönen Drehstrom zeigen (muss ich selbst noch kontrollieren ob das wirklich der Fall ist :-) )

Bis jetzt habe ich es mit dieser Variante aber noch nicht so richtig geschafft, einen brauchbaren Anlaufvorgang hinzukriegen. Ich glaube auch, dass gekaufte Regler das nicht so machen. Diese scheinen nur einen kräftigen Strom auf eine Phase zu geben, und werten dann die entstandene BEMF aus, aus der dann berechnet werden kann, welche Phase als nächstes bestromt werden muss. So richtig habe ich das aber noch nicht angeschaut, '''vielleicht weiss hier jemand besser Bescheid und könnte es hier beschreiben?'''

Das Prinzip eines Anlaufvorgangs eines sensorlosen BLDC ist folgendes:
- Man präge ein Feld ein, bei dem angenommen werden muss, dass der Motor diesem ab Stillstand auch folgt.
- Sobald diese Annahme durch Auftreten eines durch BEMF erzeugten Ereignisses bestätigt wird, kann in den geregelten Betrieb umgeschaltet werden.

=== Schnittstellen ===

Man kann nun den Sollwert der Drehzahl wahlweise über einen PPM-Eingang, über UART, SPI oder I2C vorgeben. Das überlasse ich aber jedem selber, es kommt natürlich darauf an wo der Regler schlussendlich eingesetzt werden soll.

== Bildmaterial ==
=== Oszillogramme ===

[[Datei: BLDC_Oszillogramm_Phasen_PWM.png|300px]]

Die drei Phasen während dem geregelten Betrieb, die BEMF ist sehr schön zu erkennen (immer zwischen den Zuständen "PWM" und "LOW").

[[Datei: BLDC_Oszillogramm_Phasen_Vollgas.png|300px]]

So sehen die drei Phasen bei Vollgas aus (100% PWM). Die BEMF ist jetzt sogar so steil, dass man zwischen dieser Aufnahme und dem Diagramm oben ([[#Ansteuerung]]) eigentlich kein Unterschied mehr erkennen kann!

[[Datei: BLDC_Oszillogramm_BEMF_richtig.png|300px]]

* Gelb: Phase A, BEMF sehr schön erkennbar
* Blau: Mittelpunktspannung
* Rot: BEMF von Phase A (nach der BEMF-Schaltung!)
* Grün: Komparator-Interrupts (steigende Flanke) Jeder dritte Interrupt gehört zur Phase A, die anderen Interrupts stammen von den anderen Phasen, die nicht auf dem Bild zu sehen sind.

[[Datei: BLDC_Oszillogramm_BEMF_falsch.png|300px]]

So kann z.B. die BEMF während der Zwangskommutierung aussehen. Dadurch werden auch zu viele Komparator-Interrupts (Grün, jede Flanke) ausgelöst. Kein schöner Anblick...

[[Datei: BLDC_Oszillogramm_Anlauf_1.png|300px]]

So sieht der Anlaufvorgang bei einem gekauften Regler aus. eine extrem kurze Geschichte im Vergleich mit meinen paar Umdrehungen mit Zwangskommutierung. Wer kennt das Geheimnis?

=== Layouts ===

Als Anregung, wie so ein Regler aussehen könnte (nur 40x26mm klein, inklusive Optokoppler, drei Treibern und drei schönen Stecker!):

[[Datei: BLDC_Eagle3d_top_1.jpg|300px]]

[[Datei: BLDC_Eagle3d_bot_1.jpg|300px]]

Der HCPL-0600 auf der Unterseite ist übrigens ein Optokoppler um das PPM-Eingangssignal galvanisch zu entkoppeln. Ist nicht zwingend nötig, war aber grad Platz da... :-)

== Siehe Auch ==
* [http://www.mikrocontroller.net/topic/248509 Diskussion zum Artikel]
* [[BLDC Demo Board]]
* [[Treiber]]
* [[Mosfet-Übersicht]]
* [[Leiterbahnbreite]] Unbedingt beachten bei grösseren Strömen!
* [[Kühlkörper]] Bei sehr hohen Strömen evtl. nötig

== Weblinks ==
* [http://www.mikrokopter.de/ucwiki/BrushlessCtrl BrushlessCtrl vom Mikrokopter]
* [http://svn.mikrokopter.de/listing.php?repname=BL-Ctrl& Software vom Mikrokopter Brushless-Regler]
* [http://home.versanet.de/~b-konze/ Die Seite von B. Konze, einer der Pioniere in diesem Bereich]
* [http://www.rcgroups.com/forums/showthread.php?t=1513678 Ein Thema auf rcgroups.com (Englisch) wo einige käuflichen Regler näher angeschaut wurden und eine eigene Firmware angeboten wird]
* [http://rmmx.gmxhome.de/bldchv/start.html Ein Regler-Projekt für etwas grössere Motoren]
* [http://www.fc00.de/quadrokopter_6_kw.htm Regler für sehr grosse Motoren]
* [http://ww1.microchip.com/downloads/en/AppNotes/01083a.pdf Appnote AN1083 von Microchip, sehr detailliert]
* [http://www.atmel.com/Images/doc8012.pdf AppNote AVR444 von Atmel]

[[Kategorie:Motoren]]

Brushless-Controller für Modellbaumotoren

2012-05-19T11:57:29Z

46.128.38.250:

== Einleitung ==

Im Internet gibt es einige grundlegende Informationen zur Funktionsweise und Ansteuerung von Brushless-Motoren (BLDC). Für die Entwicklung eines solchen Reglers findet man aber nur wenig richtig detaillierte Informationen und Erfahrungsberichte. In diesem Artikel sollen genau diese Lücken geschlossen werden. Es soll hier aber kein fertiges Produkt (Schaltplan + Layout + Software) angeboten werden. Viel mehr soll es die Eigenentwicklung unterstützen, Ideen und Erfahrungen anbieten.

An dieser Stelle weise ich noch darauf hin, dass man bei den [[#Weblinks]] noch einige sehr gute Informationen findet! Es gibt dort Hardware und Software, es lohnt sich die Links mal anzuschauen.

==== Um welche Motoren geht es genau? ====

Es geht hier um die sogenannten elektrisch kommutierten bürstenlosen Gleichstrommotoren (BLDC) aus dem Modellbaubereich.

Deren Eigenschaften sind:
* Haben drei Anschlüsse für die drei Phasen, ansonsten sind keine weiteren Anschlüsse vorhanden
* Werden in der Regel mit LiPo Akkus versorgt
* Leistung im Bereich von ca. 100W bis 2kW
* Spannungen im Bereich von ca. 10 bis 50V
* Ströme im Bereich von ca. 5 bis 120A

==== Um welche Motoren geht es hier nicht? ====

* Motoren mit Hallsensoren für die Rückmeldung
* Festplattenmotoren

Unter Umständen kann aber dieser Artikel auch für solche Motoren nützlich sein.

== Funktionsweise dieser Motoren ==

=== Ansteuerung ===

[[Datei:BLDC_Spannungs_Diagramm.png|thumb|right|250px|Ansteuerung der 3 Phasen]]

Grundsätzlich werden die 3 Phasen nacheinander bestromt, die Phasenspannungen wären also drei um 120° phasenverschobene Rechteckspannungen. Ein sinusförmiger Drehstrom ist nicht nötig, es genügen Rechteckspannungen. Mit einer Raumzeigermodulation könnte man die Stromaufnahme und die Geräuschentwicklung zwar noch verringern, macht die Ansteuerung aber einiges aufwändiger. Sogar die käuflichen Regler arbeiten nur mit Rechtecksignalen, zumindest die die ich kenne.

Dabei gibt es für jede Phase die Zustände „Low“, „High“ und „Floating“. Low bedeutet 0V (GND), High entspricht der Versorgungsspannung und Floating ist keines von beidem, die Phase „hängt in der Luft“. Bei „High“ wird aber noch der Mittelwert der Spannung per PWM eingestellt, über das Tastverhältnis wird schlussendlich die Drehzahl verändert! Dazu aber später mehr.

In der Grafik rechts kann man den Spannungsverlauf sehr gut erkennen. Das Diagramm zeigt aber nur den theoretischen Verlauf der Spannungen, wobei die gestrichelten Linien den Zustand "floating" symbolisieren. Dies kann man in einem Diagramm ja nicht wirklich darstellen, das ist einfach symbolisch gemeint. Interessanterweise sehen die Spannungen aufgrund der BEMF aber tatsächlich ziemlich ähnlich aus wie im Diagramm!

=== Die 6 Zustände ===

Wie man erkennen kann, werden 6 Zustände gebraucht, die sich dann immer wiederholen. Die Kommutierung ist also einfach ein Weiterschalten des Zustandes.
''Diese 6 Zustände sind nicht mit den drei Zuständen von oben (High, Low, Floating) zu verwechseln, das ist ein anderes Thema!''

In einer Tabelle dargestellt würde das folgendermassen aussehen:

{| class="wikitable"
! Zustand || Phase A || Phase B || Phase C || Stromfluss || Komparator-Eingänge
|-
| 1 || PWM || Floating || GND || A --> C || MITTEL <--> NULL_B
|-
| 2 || Floating || PWM || GND || B --> C || MITTEL <--> NULL_A
|-
| 3 || GND || PWM || Floating || B --> A || MITTEL <--> NULL_C
|-
| 4 || GND || Floating || PWM || C --> A || MITTEL <--> NULL_B
|-
| 5 || Floating || GND || PWM || C --> B || MITTEL <--> NULL_A
|-
| 6 || PWM || GND || Floating || A --> B || MITTEL <--> NULL_C
|}

Hinweise:
* Die Nummern in der ersten Spalte entsprechen genau den sechs Zuständen, die auch im obigen Diagramm nummeriert sind (Alle 6 Zustände zusammen bilden einen Zyklus, wie es auch im Diagramm dargestellt ist)
* Den Inhalt der letzten Spalte wird später noch erläutert. Die Bezeichnungen beziehen sich auf die [[#BEMF-Schaltung]].

=== Einsatz der BEMF ===
Das schaut bis jetzt eigentlich wie ein Synchronmotor oder Schrittmotor aus, was ein BLDC im Prinzip auch ist.

Wie schon erwähnt wurde, wird ein BLDC elektronisch kommutiert. Das heisst, die Kommutierung wird nicht einfach stur vorgegeben, sondern es wird immer Rücksicht auf die Ankerposition genommen. Dazu muss man allerdings wissen, wann man die Kommutierung genau auslösen soll.

Dieses Verfahren heißt Block-Kommutierung und ist ein Kompromiss aus Aufwand und Ergebnis:
Idealerweise werden die Ströme im Stator so eingeprägt, dass der Statorfluss dem Rotorfluss immer um 90° vorauseilt. Nur so wir das ideale Drehmoment erzeugt (siehe Literatur zur permanenterregten Synchronmaschine). Allerdings hat dieses Verfahren, auch Feldorientierte Regelung oder Vektor-Regelung genannt, den Nachteil, dass meistens teure Positionssensorik für den Rotor nowendig ist und auch die nötige Rechenleistung stark ansteigt. Die komplette Regelung muss für jede PWM-Periode gerechnet werden, damit sich der Aufwand lohnt.
Im Fall der Block-Kommutierung ist der ideale Kommutierungszeitpunkt also der, bei dem das Stator-Feld dem Rotor-Feld im Mittel um 90 ° vorauseilt. Dieser ideale Kommutierungszeitpunkt ist wegen der als konstant angenommenen Rechenzeit für die Kommutierung drehzahlabhängig.

Zur Erreichung einer höheren Maximaldrehzahl kann das Rotorfeld durch das Statorfeld im sogenannten Feldschwäch-Betrieb geschwächt werden. Es ergeben sich Feldschwäch-(Blind)ströme im Bereich der Nennströme.

Grundsätzlich kann auch ein BLDC nicht ohne Kenntnis der Lage des Rotors kommutiert werden. Und hier kommt die sogenannte Back Electromotive Force (BEMF) zum Einsatz. Von den drei Phasen liegt ja zu jedem Zeitpunkt genau eine Phase in der Luft wie man am Diagramm oben erkennen kann. Aufgrund des drehenden Magnetfeldes im Motor wird an dieser Phase nun eine Spannung induziert. Und genau diese induzierte Spannung gibt nun Auskunft darüber, in welchem Winkel sich der Anker befindet, und daraus kann man dann auch den Zeitpunkt der nächsten Kommutierung bestimmen.

Zusätzlich wird aber auch noch die Sternmittelpunktspannung der drei Phasen benötigt, welche aber leider nicht direkt zur Verfügung steht. Das ist aber kein Problem, mit drei Widerständen kann man sich die selber erzeugen (siehe [[#BEMF-Schaltung]]).

Jetzt sollten die BEMF-Spannungen die Sternmittelpunktspannung ständig kreuzen, was man dann mit einem Komparator erfassen kann. Und den Interrupt, den der Komparator auslöst, ist nun verantwortlich für die nächste Kommutierung.
Der Komparator wird natürlich nacheinander mit den drei Phasen gefüttert, es darf immer nur die Phase an den Komparator angeschlossen sein, die auch in der Luft hängt! In der Tabelle [[#Die 6 Zustände]] sieht man, welche zwei Spannungen der Komparator jeweils vergleichen muss.

Als Komparator kann man übrigens den integrierten nehmen, den es in den AVRs gibt. Diese (alle?) haben auch den benötigten Multiplexer, um zwischen den drei Analogquellen wählen zu können. Näheres dazu im Abschnitt [[#Software]].

== Hardware ==

=== Leistungsteil ===

==== Treiber ====

Um die drei notwendigen Zustände (''Low'', ''High'' und ''Floating'') für jede der drei Phasen realisieren zu können, werden drei Halbbrücken mit Mosfets benötigt. Hier gibt es dann auch schon mehrere Varianten, wie man das aufbauen kann. Grundsätzlich muss man sich mal überlegen ob fertige FET-Treiber oder diskrete Treiber verwendet werden sollen. Die FET-Treiber haben einige sehr schöne Vorteile, deshalb sollte man diese meiner Meinung nach bevorzugen.

Die Vorteile wären:

* Integrierter Kurzschlussschutz mit dead time, ein Softwarefehler kann die FETs nicht zerstören. Das kann in der Entwicklungsphase sehr von Vorteil sein :-)
* Die FETs können mit ordentlicher Geschwindigkeit geschaltet werden, und die Mikrocontroller-Ports werden trotzdem nicht stark belastet. So kann die Wärmeentwicklung der FETs noch etwas reduziert werden.
* Bei Treibern die mit nur einem Eingang zwischen Lowside und Highside Mosfets toggeln (z.B. IR2104), ist der sogenannte „aktiver Freilauf“ bereits in Hardware realisiert und ermöglicht so mit wenig Aufwand eine extrem niedrige Erwärmung der Mosfets. Das ermöglicht schon sehr grosse Ströme auch ohne Kühlkörper!
* Es können günstigere Mosfets verwendet werden, es müssen keine TTL-Kompatible FETs sein. Auch ist eine niedrige Gatekapazität nicht so von Bedeutung wie bei direkter Ansteuerung mit einem Mikrocontroller.
* Je nach dem welchen Treiber man verwendet, kann der Softwareaufwand und die Fehleranfälligkeit deutlich reduziert werden.

Nachteile von Treiber sind:

* Mehr Bauteile auf der Platine.
* Vermutlich insgesamt etwas teurer, auch wenn die FETs günstiger sind.
* Bei vielen Treibern ist eine Minimalspannung von ca. 10V notwendig, damit sie funktionieren. Bei einem fast leeren 3S LiPo Akku könnte das vielleicht schon kritisch werden. Auch darf z.B. beim IR2104 eine Spannung von 20V nicht überschritten werden. Daher kommt (ohne StepUp und StepDown Wandler) eigentlich fast nur noch ein 4S Akku in Frage. Möchte man einen grösseren Eingangsspannungsbereich haben muss man noch entsprechende Spannungsregler einbauen.

Ich persönlich habe es schon mit einem IR2104S probiert, dieser erscheint mir sehr geeignet für diese Aufgabe. Ich betreibe ihn mit einem 4S LiPo, damit läuft das Teil perfekt. Kann ich nur weiterempfehlen!

==== Beispielschaltung ====
[[Datei:BLDC_Leistungsteil_1.png|thumb|right|300px|Beispiel einer Halbbrücke inklusive Strommessung]]
Hier ein Beispiel, wie der Leistungsteil einer Phase aussehen könnte.

Für die exakte Beschaltung der Treiber muss man natürlich dessen Datenblatt studieren!

Hier sieht man auch gleich noch die Strommessung, die man natürlich nicht für jede Phase einzeln aufbauen muss. Man kann sie sogar ganz weglassen, sie könnte aber nützlich sein um eine Überlast des Motores erkennen zu können.

Der Widerstand R20 ist dazu da, dass auf dem Treiber das PWM-Signal liegt, sobald die Leitung „IN_A“ in der Luft hängt (uC Pin als Eingang definiert). So wird nur ein einziger PWM-Ausgang vom Mikrocontroller benötigt für alle drei Phasen, erfordert also kein Soft-PWM oder sonst irgend ein Murks. Diese Schaltung habe ich übrigens beim Mikrokopter-Projekt abgeschaut.

Übrigens muss an die Versorgung unbedingt noch ein grosser Elko gehängt werden, am besten möglichst nahe an die Mosfets (keine langen Leitungen zwischen Elko und Mosfets). Die erforderliche Kapazität hängt davon ab, wieviel Strom der Motor braucht. bei kleinen bis mittleren Motoren sollten so 220uF bis 680uF ausreichend sein.

=== BEMF-Schaltung ===

[[Datei:BLDC_BEMF_schaltung.png|thumb|right|300px|BEMF-Schaltung]]

Ein wichtiger Teil ist aber auch die BEMF-Schaltung. Dabei wird häufig die Schaltung vom Mikrokopter eingesetzt (siehe Schaltung rechts).

Die Schaltung besteht erstmal aus drei Spannungsteilern, die die Phasenspannungen auf ein Spannungsniveau heruntersetzen, das man auf die Mikrokontrollereingänge legen darf. Keramikkondensatoren glätten diese Spannungen, weil die aufgrund der PWM sonst sehr stark ausschlagen. Dann gehen diese drei Spannungen (''NULL_A'', ''NULL_B'' und ''NULL_C'') auf drei ADC-Eingänge des Mikrocontrollers.

Und dann sind da noch die drei Widerstände, die aus den Spannungen ''NULL_A'', ''NULL_B'' und ''NULL_C'' einen virtuellen Sternmittelpunkt bilden. Diese Mittelpunktspannung (''MITTEL'') kommt dann auf den Komparatoreingang ''AIN0'' vom AVR. Diese Spannung soll der Komparator später dann mit jeweils einer der Spannungen ''NULL_A'', ''NULL_B'' und ''NULL_C'' vergleichen um den Kommutierungszeitpunkt bestimmen zu können.

Man kann die Widerstands-/ und Kapazitätswerte auch noch anpassen. Bei höheren Eingangsspannungen muss man darauf achten, dass die Eingänge vom AVR keine zu hohe Spannung abkriegen! Ein Regler, den ich gekauft habe, hat einiges höhere Widerstandswerte und kommt sogar ohne Kondensatoren aus. Hier hat man also durchaus noch Spielraum um ein bisschen zu tüfteln, für den Anfang ist die abgebildete Schaltung aber bestens geeignet.

=== Mikrocontroller ===

Als Mikrocontroller sind viele Typen aus der AVR-Serie geeignet. Bei der BrushlessCtrl wird zum Beispiel ein ATMega168 eingesetzt. Mit diesem habe ich auch mal angefangen, der scheint wirklich gut geeignet zu sein. Es reicht aber auch ein ATMega88 wenn man nicht alle möglichen Protokolle und Ansteuerungsarten (I2C, SPI, PPM) gleichzeitig einbauen will.

Viele Regler verwenden auch einen AT90PWM, vorallem wenn mehrere PWM-Kanäle gebraucht werden.

Übrigens wird bei käuflichen Reglern extrem häufig ein ATMega8 eingesetzt! Wenn man nur Software entwickeln möchte kann man auch einen solchen Regler kaufen und das eigene Programm aufspielen. Bei den [[#Weblinks]] findet man dazu auch noch Informationen.

Um eine Raumzeigermodulation zu implementieren wird dann aber vermutlich schon ein 32-Bit Mikrocontroller nötig sein. Aber wie schon erwähnt ist für ein Modellbaumotor eine Raumzeigermodulation keinesfalls ein must-have.

== Software ==

Bei der Software kommt es jetzt natürlich sehr stark darauf an, wie die Hardware aufgebaut ist. Ich möchte hier aber nicht auf jede Variante eingehen, das gäbe viel zu viel Arbeit. Auch will ich ja kein fertiger Code bereitstellen, sondern nur Hinweise und Tipps geben. Wer nicht selber programmieren will, der kann ja mal die Mikrokopter-Firmware herunterladen, die älteren Versionen davon gibt es auf der Mikrokopter-Seite zum downloaden.

Wichtig sind auf jeden Fall [[#Die 6 Zustände]]. Der Mikrocontroller muss die Phasen jeweils nacheinander so wie in der Tabelle ansteuern. Das ist soweit ja kein Problem, schwierig ist aber immer der richtige Zeitpunkt für die Kommutierung zu finden.

Falls man einen IR2104 oder einen ähnlichen Treiber verwendet, würde die Software ungefähr so aussehen:

* Beim Programmstart wird schonmal der PWM-Ausgang mit einem Timer aktiviert. Die Frequenz liegt normalerweise so im Bereich 12 bis 25kHz. Ich selber verwende 20kHz, da hört man dann auch dieses Pfeifen nicht mehr.
* Der Interrupt vom Analogkomparator muss aktiviert werden, um die Kommutierungszeitpunkte bestimmen zu können.
* Dann habe ich eine Funktion, welche den Zustand (1 bis 6) eins weiterschaltet und die Ausgänge entsprechend setzt. Dabei werden die Pins, die das PWM-Signal enthalten sollen, einfach als Eingang definiert, wie ich schonmal erwähnte.
* Wichtig ist ausserdem, dass bei jeder Kommutierung auch noch der richtige ADC-Kanal auf den Komparator geleitet wird per Multiplexer. Dieser Kanal wird bei jeder Kommutierung eins weitergeschaltet.
* Danach muss nur noch gewartet werden bis der Analogkomparator einen Interrupt auslöst. Sobald dies geschieht, wird die nächste Kommutierung ausgelöst, und das Spiel beginnt wieder von vorne.

Ich glaube aber, dass dies noch nicht die ganz richtige Art ist, wie man die Kommutierung auslöst. Ich denke, man müsste nach einem Interrupt eine gewisse Zeit warten (je nach Kommutierungswinkel oder wie das heisst) und erst kurz vor dem nächsten Interrupt die Kommutierung auslösen. Also quasi immer einen Zustand später. Dazu muss aber die Verzögerungszeit ständig ausgerechnet werden, damit die auch bei jeder Drehzahl stimmt. Ich habe es selber noch nicht so implementiert, kann daher nicht sagen ob das so dann richtig funktioniert. '''Falls hier jemand besser Bescheid weiss, wäre es cool wenn man das hier noch ergänzen könnte.'''

Laut Literatur liegt der optimale Kommutierungszeitpunkt 30° nach dem Nulldurchgang der Spannung am nicht beschalteten Eingang. Die naheliegendste Möglichkeit wäre also die Zeit, die bei der aktuellen Drehzahl für eine Umdrehung benötigt wird, durch zwölf zu dividieren und so lange bis zur Kommutierung zu warten.

Ausserdem scheint es auch Regler zu geben, die eine Kommutierung nicht mit dem Analogkomparator erfassen, sondern direkt mit ADC-Wandlungen. Dazu weiss ich aber leider auch nichts näheres, deshalb auch hier: '''Wenn jemand weiss, was es damit auf sich hat, bitte melden.'''

Die Drehzahl des Motores lässt sich jetzt ganz bequem ändern, indem man den Duty-Cycle des PWM-Signales verändert. Der Motor beschleunigt bzw. bremst dann von alleine.

=== Anlauf ===

So, das war jetzt die Beschreibung für einen Motor, der bereits läuft. '''Bis''' der Motor allerdings mal dreht, muss man anders vorgehen, weil der stillstehende Motor ja keine Komparator-Interrupts auslöst, da keine BEMF vorhanden ist.

Daher muss man den Motor zuerst mit einem starren Drehfeld auf eine gewisse Drehzahl beschleunigen, wie bei einem Schrittmotor. Sobald eine genügend hohe Drehzahl erreicht wurde, kann man in den geregelten Betrieb schalten. Am besten schaltet man dazu einfach alle Phasen ab und aktiviert den Komparator. Sobald der erste Interrupt vom Komparator ausgelöst wird, werden die Phasen wieder eingeschaltet.

Der ganze Startvorgang ist aber schon eine Wissenschaft für sich. Es braucht (nach meiner Erfahrung) viel Zeit und Nerven, bis alles richtig funktioniert. Man kann aber am Anfang den Motor auch von Hand anwerfen, das geht viel einfacher als mit einer Zwangskommutierung. Ein Oszilloskop ist eigentlich auch absolut notwendig, um analysieren zu können was der Regler und die BEMF genau macht.

Ganz wichtig aber an dieser Stelle: '''Wenn der Motor mit einem starren Drehfeld angesteuert wird, sieht die BEMF alles andere als schön aus!''' Das liegt daran, dass der Motor bei jeder Kommutierung beschleunigt, und danach wieder abgebremst wird, der Motor läuft einfach nicht „rund“. Wenn ihr also irgendwas komisches auf dem Oszilloskop seht, ist das kein Fehler in eurer Schaltung, das ist normal bei Zwangskommutierung!

Wenn Ihr die BEMF auf dem Oszilloskop anschauen wollt, könnt Ihr entweder den Motor einfach von Hand drehen, oder ihr dreht den Motor mit Zwangskommutierung hoch, und schaltet dann alle Phasen ab (nicht auf GND, in der Luft hängend). Direkt nach dem Abschalten der Phasen sollte die BEMF einen relativ schönen Drehstrom zeigen (muss ich selbst noch kontrollieren ob das wirklich der Fall ist :-) )

Bis jetzt habe ich es mit dieser Variante aber noch nicht so richtig geschafft, einen brauchbaren Anlaufvorgang hinzukriegen. Ich glaube auch, dass gekaufte Regler das nicht so machen. Diese scheinen nur einen kräftigen Strom auf eine Phase zu geben, und werten dann die entstandene BEMF aus, aus der dann berechnet werden kann, welche Phase als nächstes bestromt werden muss. So richtig habe ich das aber noch nicht angeschaut, '''vielleicht weiss hier jemand besser Bescheid und könnte es hier beschreiben?'''

=== Schnittstellen ===

Man kann nun den Sollwert der Drehzahl wahlweise über einen PPM-Eingang, über UART, SPI oder I2C vorgeben. Das überlasse ich aber jedem selber, es kommt natürlich darauf an wo der Regler schlussendlich eingesetzt werden soll.

== Bildmaterial ==
=== Oszillogramme ===

[[Datei: BLDC_Oszillogramm_Phasen_PWM.png|300px]]

Die drei Phasen während dem geregelten Betrieb, die BEMF ist sehr schön zu erkennen (immer zwischen den Zuständen "PWM" und "LOW").

[[Datei: BLDC_Oszillogramm_Phasen_Vollgas.png|300px]]

So sehen die drei Phasen bei Vollgas aus (100% PWM). Die BEMF ist jetzt sogar so steil, dass man zwischen dieser Aufnahme und dem Diagramm oben ([[#Ansteuerung]]) eigentlich kein Unterschied mehr erkennen kann!

[[Datei: BLDC_Oszillogramm_BEMF_richtig.png|300px]]

* Gelb: Phase A, BEMF sehr schön erkennbar
* Blau: Mittelpunktspannung
* Rot: BEMF von Phase A (nach der BEMF-Schaltung!)
* Grün: Komparator-Interrupts (steigende Flanke) Jeder dritte Interrupt gehört zur Phase A, die anderen Interrupts stammen von den anderen Phasen, die nicht auf dem Bild zu sehen sind.

[[Datei: BLDC_Oszillogramm_BEMF_falsch.png|300px]]

So kann z.B. die BEMF während der Zwangskommutierung aussehen. Dadurch werden auch zu viele Komparator-Interrupts (Grün, jede Flanke) ausgelöst. Kein schöner Anblick...

[[Datei: BLDC_Oszillogramm_Anlauf_1.png|300px]]

So sieht der Anlaufvorgang bei einem gekauften Regler aus. eine extrem kurze Geschichte im Vergleich mit meinen paar Umdrehungen mit Zwangskommutierung. Wer kennt das Geheimnis?

=== Layouts ===

Als Anregung, wie so ein Regler aussehen könnte (nur 40x26mm klein, inklusive Optokoppler, drei Treibern und drei schönen Stecker!):

[[Datei: BLDC_Eagle3d_top_1.jpg|300px]]

[[Datei: BLDC_Eagle3d_bot_1.jpg|300px]]

Der HCPL-0600 auf der Unterseite ist übrigens ein Optokoppler um das PPM-Eingangssignal galvanisch zu entkoppeln. Ist nicht zwingend nötig, war aber grad Platz da... :-)

== Siehe Auch ==
* [http://www.mikrocontroller.net/topic/248509 Diskussion zum Artikel]
* [[BLDC Demo Board]]
* [[Treiber]]
* [[Mosfet-Übersicht]]
* [[Leiterbahnbreite]] Unbedingt beachten bei grösseren Strömen!
* [[Kühlkörper]] Bei sehr hohen Strömen evtl. nötig

== Weblinks ==
* [http://www.mikrokopter.de/ucwiki/BrushlessCtrl BrushlessCtrl vom Mikrokopter]
* [http://svn.mikrokopter.de/listing.php?repname=BL-Ctrl& Software vom Mikrokopter Brushless-Regler]
* [http://home.versanet.de/~b-konze/ Die Seite von B. Konze, einer der Pioniere in diesem Bereich]
* [http://www.rcgroups.com/forums/showthread.php?t=1513678 Ein Thema auf rcgroups.com (Englisch) wo einige käuflichen Regler näher angeschaut wurden und eine eigene Firmware angeboten wird]
* [http://rmmx.gmxhome.de/bldchv/start.html Ein Regler-Projekt für etwas grössere Motoren]
* [http://www.fc00.de/quadrokopter_6_kw.htm Regler für sehr grosse Motoren]
* [http://ww1.microchip.com/downloads/en/AppNotes/01083a.pdf Appnote AN1083 von Microchip, sehr detailliert]
* [http://www.atmel.com/Images/doc8012.pdf AppNote AVR444 von Atmel]

[[Kategorie:Motoren]]

Diskussion:Platinenhersteller

2012-05-01T10:53:00Z

46.128.38.250: Neuer Abschnitt /* Vorschlag für "Deutschland sehr günstige" */

== Werbung ==

Kann das mal ein "Angemeldeter" entfernen?
http://www.mikrocontroller.net/wikisoftware/index.php?title=Platinenhersteller&diff=58254&oldid=prev

Siehe auch hier (da braucht es einen Moderator): http://www.mikrocontroller.net/wikisoftware/index.php?title=Benutzer:Aetzwerk&diff=58255&oldid=prev

Danke. (IP - 01.07.11)

Da die nur an gewerbliche Kunden liefern, ist das Angebot (mal von der Lobhudelei abgesehen) in dieser Liste wohl wirklich fehlplatziert.

== Diverses ==

kurzes lob/kritik und beschreibung der einzelnen firmen helfen weiter, siehe elektronik-versender
vielleicht aphabetische reihenfolge ?

Stimme ich voll zu. Interessant wäre allerdings auch eine Liste der Features, d.h. wie viele Layers, wie klein der Abstand sein darf etc.

== Bilex ==

ad bilex: Ohne jetzt jemandem was unterstellen zu wollen oder paranoid zu sein, aber es ist doch seltsam, wenn in einem deutschsprachigen Wiki die Lobeshymnen für diesen bulgarischen Hersteller ausgerechnet von einer bulgarischen IP-Adresse kommen.

Betreffend Bilex: Die letzten Änderungen, die vor allem Kritik an Bilex entfernt haben, wurden von einer IP-Adresse aus Bulgarien vorgenommen. Das erweckt natürlich einen Verdacht. Darum bitte ich das nachzuprüfen und zu korrigieren! Danke!

Zu Bilex: Meine zweimalige Kritik an Bilex wurde entfernt und durch Rechtfertigungen in schlechtem Deutsch ersetzt. Dies deutet ja daraufhin, wer sich hier ins rechte Licht setzt. Wenn ich erst alles extra bestellen muß (Beschichtung, Fräsung, Bohrungen) was eigentlich als selbstverständlich vorauszusetzen ist, bleibe ich lieber bei einem deutschen Hersteller und kann mich auf die Qualität verlassen. Diese Fehlversuche mit Bilex haben unserer Firma 4 Wochen Zeitverzug gekostet, da die gefertigten Leiterplatten nicht als Vorzeigeobjekt beim Kunden brauchbar waren.
----
Diese Änderungen wurden mit einer bulgarischen IP-Adresse vorgenommen. Noch Fragen?
--[[Benutzer:Andreas|Andreas]] 16:45, 5. M?2006 (CET)

== Vorschlag für "Deutschland sehr günstige" ==

Den Hersteller http://www.pcb-devboards.de hab ich nicht im Artikel gefunden, würde den aber gerne festhalten. Leider kann ich das nicht, weil der Artikel für nicht-angemeldete gesperrt ist?

Min Leiterbahnbreite/Abstand: 0,2 mm

Bohrungs-Durchmesser: 0.4 .. 5 mm, ab 5 mm wird gefräst, alle Bohrungen frei

Restring: min 0.254 mm

Platinen sind 2-Lagig und '''durchkontaktiert'''

Preis: 195 x 90 mm: 20 Euro

Ich bin nicht der Betreiber, finde das Angebot aber sehr günstig, weil alle Bohrungen enthalten sind und nicht zuletzt, weil die Platine durchkontaktiert ist!

Was meint Ihr?