Mikrocontroller.net - Benutzerbeiträge [de]

Platinensammler

2013-03-11T10:17:08Z

Mixer: /* FAQ */

== Einleitung & Generelles ==
Der Traum eines jeden Elektrotechnik-Hobbyisten ist wohl ein selbst entworfenes PCB. Oft scheitert eine saubere Realisierung jedoch an der Fertigung der Leiterplatte. Hobbymittel wie die Direkttonermethode führen oft nur zu unzureichend sauberen Ergebnissen, Doppelseitige Platinen sind nur schwer sauber zu realisieren. Eine vernünftige Ausrüstung zum Belichten ist teuer und so mancher Bastler hat auch schlicht und ergreifend nicht die Möglichkeit zum Umgang mit Entwicklern, Ätzmitteln, usw. Egal ob man nun die Platinen nicht fertigen kann oder möchte besteht immer die Möglichkeit diese bei den Platinenherstellern (professionell) produzieren zu lassen. Das ist allerdings oft mit nicht unerheblichen Kosten und einem Mindestnutzen verbunden, gerade wenn nur einzelne kleine Platinen bernötigt werden.

Aus diesem Grunde bietet Jakob Kleinen alias "jakobk" hier im Forum freundlicher Weise die Möglichkeit zur Mitbestellung an. Es werden fortlaufend Bestellungen gesammelt. Gefertigt wird immer, sobald ein Nutzen voll ist, daher lassen sich auch keine genauen Bestelltermine vorhersagen.

Der Preis wird abhängig von der genutzten, genauer gesagt von der im Nutzen benötigten Fläche, berechnet. Denn um die einzelnen Layouts vereinzeln zu können muss ein umlaufender 3mm Fräsgraben zur eigentlichen Leiterkartenkontur zugerechnet werden.

d.h. wenn eine Platine 3x2cm groß ist, wird eine Fläche 3,6cm x 2,6cm also 9,36cm² berechnet.

== Designregeln ==

===Kontur===
Die Platinenkontur kann beinahe beliebige Formen haben.

Allerdings sollte sie so beschaffen sein, dass sie mit einem 2mm Fräser herstellbar ist und sollte mit einer Strichstärke von 1 MIL oder 0,0254mm gezeichnet werden.

Darüber hinaus muss eine Platine mindestens eine Seitenlänge mit 10mm und darf keine Seitenlänge unter 5mm haben.

===Bohrungen===
Der kleinste verfügbare Bohrdurchmesser beträgt 0,3mm.

===Fräsungen===
Innerhalb der Leiterplatten können Fräsungen beliebiger Form eingebracht werden. Auch diese müssen mit einem 2mm-Fräser herstellbar sein. Daher sollte man diese in einer eigenen Lage mit einer Strichstärke von min. 2mm Zeichnen.

Wer z.B. für DC-Buchsen metalisierte Langlöcher haben möchte darf diese mit einem 1mm-Fräser zeichnen. Um die metalisierung zu erhalten muss innerhalb dieser Fräsung zusätzlich eine durchkontaktierte Bohrung platziert werden.

===Leiterbahnstärke===
Grundsätzlich sind Leiterbahnen ab 0,15mm machbar. Die Mindestabstände im Kupfer liegen ebenfalls bei 0,15mm.

===Abstand zwischen Kontur und Kupfer===
Zwischen Kupfer und Fräsungen sollte (außer natürlich den Stellen wo Kupfer angefräst werden soll) 0,2mm betragen und die Hersteller mögen Kupfer anfräsen wegen der höheren Belastung ihrerer Fräser nicht so gerne.

== Fertigungsparameter des Nutzen ==

Die im Rahmen der Platinensammlung bestellten Nutzen werden immer 2-lagig mit 35µ Kupfer, auf 1,55mm FR4, mit E-Test, HAL-Verzinnung (RoHS), Stoplack auf beiden Seiten und Bestückungsdruck auf der Oberseite bestellt.

Sofern nicht ausdrücklich anders gewünscht, werden in den Bestückungsdruck Gehäusekonturen und Referenzen übernommen.

Wer keinen Bestückungsdruck haben möchte, kann dies im Bestellformular vermerken. Dann löscht Jakob die entsprechende Lage aus dem Datensatz, der Preis bleibt jedoch der gleiche.

Um die Teillayots später identifizieren zu können bekommt jede Platine eine kleine Markierung (kleine 4-Stellige "7-Segmentanzeige")
[[Bild:ID_Skizze.png]]

Wer sich die Stelle selber aussuchen möchte muss eine Markierung an ensprechender Stelle platzieren und im Bestellformular die Position mit angeben.

Bei Layouts ohne ID-Feld wird eins an einer möglichst unauffälligen Stelle platziert (z.B. unterhalb eines ICs. Dann ist die ID bei bestückter Platine nicht mehr zu sehen)

Bevorzugt sollte das ID-Feld im Bestückungsdruck untergebracht werden, aber es kann auch im Stoplack oder im Kupfer liegen.

Für Eaglenutzer gibt es die Platzhalter hier:
http://www.mikrocontroller.net/attachment/138590/Platinensammler.lbr
in einer kleinen lib.

Wer nicht mit Eagle arbeitet muss sich ggf. bitte einen eigenen Platzhalter entsprechend der Skizze bauen.

== Preis ==
===Mindestmenge===
Unter Mindestmenge versteht sich die Anzahl der Platinen die man mindestens haben will/muss.
(Zusätzlich gibt es die Möglichkeit ggf. überproduzierte Platinen zu einen günstigeren Preis abzunehmen)

Der Preis für Platinen der Mindestmenge beträgt 0,30/cm².

Allergings kommt zur tatsächlichen Platinenfläche noch ein umlaufender Fräsgraben von 3mm.

Also kostet eine 3cm x 2cm große Platine:

A_Nutzen = (3cm + 0,6cm) x (2cm + 0,6cm)
A_Nutzen = 9,36cm²

Preis_m = A_Nutzen * 0,30€/cm²
Preis_m = 9,36cm² x 0,30€/cm²
Preis_m = 2,81€/Stk

Anmerkung:
Die genaue Kontur der Platine spielt für den Preis keine Rolle. Es wird immer das überdeckende Rechteck berechnet.

===Überproduzierte===
Die Flächenberechnung für abgenommene überproduzierte Platinen ist die Gleiche wie für die Mindestmenge. Allerdings liegt der cm²-Preis hier nur noch bei 0,10€/cm²

Also kosten die Überproduzierten der 3cm x 2cm Platine
Preis_ü = 9,36cm² x 0,10€/cm²
Preis_ü = 0,94€/Stk

Anmerkung:
i.d.R. kommen zweimal mehr Überproduzierte wie mindestens bestellt werden (sofern die mindestmenge bei 1-4 Stk liegt)

Es Besteht kein Abnahmezwang für die Überproduzierten. Ebenso muss man auch nicht alle Überproduzierten abnehmen.

===Verpackung und Versand===
Ich verschicke die Platinen im Luftpolsterumschlag als Briefe.

Die Verpackungs- und Versandkosten hängen entsprechend von Größe, Gewicht und Zielland ab.

Innerhalb von Deutschland liegen die meisten Sendungen zwischen 1,50€ und 2,50€ und innerhalb der EU und in die Schweiz liegen die Versandkosten zwischen 2,00€ und 4,50€.

== Zahlungsarten ==
Grundsätzlich lege ich den Platinen einfach eine Rechnung bei, die dann bitte Zeitnah zu begleichen ist.

Grade für Bestellungen aus dem Ausland kann es auf Grund von hohen Überweisungskosten auch interessant sein per Paypal zu bezahlen. Das ist auch kein Problem, aber dann müßt ihr das bitte im Bestellformular unter Anmerkungen angeben und die zusätzlichen Gebühren (0,35€/Zahlung + 1,9% des Rechnungswertes) kommen noch mit auf die Rechnung.

== Bestellablauf ==
Die geprüften Layoutdaten (*.dru File siehe Designregeln oder hier http://www.mikrocontroller.net/attachment/132705/platinensammler_02.dru ) schickt ihr dann bitte zusammen mit dem ausgefüllten Bestellformular ( http://www.mikrocontroller.net/attachment/132047/Bestellformular.txt ) an ''' platinensammler(at)gmail.com '''

Bitte beachtet, dass ich nur vollständige Bestellungspakete
berücksichten kann (auch die Wiederbesteller bitte). Außerdem solltet
ihr mir bitte keine "Schnellschüsse" mit "Schönheitsfehlern schicken,
die ihr dann noch drei mal bis zum Stichtag nachbessert.

Wenn sich jemand nicht sicher ist, ob sein Layout produzierbar ist,
schaue
ich gerne vorab unverbindlich drüber. Grade bei Layoutneulingen kann das
schon mal ganz nützlich sein, um grobe Fehler zu vermeiden und um ggf.
Unsicherheit entgegen zu wirken.

Sobald ich die Daten geprüft und in den Nutzen übernommen habe,
bestätige ich die Bestellung per Mail. In dieser Mail steht dann eure
Adresse sowie Anzahl, Größe und Kosten eurer Platinen. Wenn ich nichts
von euch höre gehe ich davon aus, dass ich eure Bestellung richtig
übernommen habe. (Auch wenn ich mich über eine kurze Bestätigung freue)

Ich sammle laufend Layouts und trage denn Füllstand hier in der Überischtstabelle (unten) ein.

Zusätzlich melde ich mich zwischendurch auch im Forum, wenn ich alle offenen Aufträge bearbeitet hab.

Wer bis dahin noch keine Auftragsbestätigung hat, sollte sich bei mir melden.

Sobald ein Nutzen voll ist, gebe ich ihn in die Fertigung und sammle direkt für den neuen Nutzn weiter.

Wenn ein produzierter Nutzen bei mir ist, drösel ich den auseinander, gebe die Teilbestellungen zusammen mit den Rechnungen in die Post.

== Dateiformate ==
Ihr könnt mir eure Layoutdaten in den folgenden Formaten mailen.
* Eagle brd-file
* KiCad brd-file
* RS-274-X (Extended Gerber) / Excellon

=== Gerberfiles===
Bei den Extended Gerber und Excellon Daten müssen eure Daten die folgenden Endungen für die Lagen zuordnung haben:
* Kontur - *.l00
* Stoplack Lötseite (Unten) - *.l02
* Kupfer Lötseite - *.l03
* Kupfer Bestückungsseite (Oben) - *.l06
* Stoplack Bestückungsseite - *.l07
* Bestückungsdruck Bestückungsseite - *.l08
* Fräsungen - *.mil

* durchkontaktierte Bohrungen - *.dk
* nicht durchkontaktierte Bohrungen - *.ndk

Außerdem müssen sie der folgenden Formatierung entsprechen:

Gerber
* Format : metric
* Integer Digits : 2
* Decimal Digits : 4
* Type : absolute
* Zero Suppressing: leading

Excellon
* Format : metric
* Integer Digits : 2
* Decimal Digits : 4
* Type : absolute
* Zero Suppressing: none

== FAQ ==
* Sind auch "buried vias", "blind vias" möglich? - es sind leider keine buried oder blind vias möglich

* Was ist mit dem Multilayernutzen? - Dazu hat sich seit der Ankündigung kein einziges Layout eingefunden. Daher wurde der wieder eingstampft.

* Lieferung in die Schweiz ist kein Problem (Siehe Verpackung und Versand)

Noch eine neue Frage? Dann schickt sie [http://www.mikrocontroller.net/user/show/JakobK mir.]

== Bestellungen ==
{| class="wikitable"
|-
! Nutzen !! Status !! Update
|-
| 2013-0001|| versand || 2013/03/09
|-
| 2013-0002|| versand || 2013/03/09
|-
| 2013-0003|| in Produktion || 2013/03/09
|-
| 2013-0004|| zu 65% gefüllt || 2013/03/11
|}

== Links ==
* http://www.mikrocontroller.net/topic/245590 (30ct)
* http://www.mikrocontroller.net/topic/273018 (60ct)
* http://www.mikrocontroller.net/topic/245595 (Feedback)
* http://www.mikrocontroller.net/topic/245594 (FAQ)
* http://www.mikrocontroller.net/topic/245594#2696432 (FAQ: EAGLE Hohlsteckerbuchsen)
* http://www.mikrocontroller.net/articles/Platinenhersteller
* http://www.platinensammler.de/

[[Kategorie:Platinen]]

STM32F10x Standard Peripherals Library

2013-03-05T09:39:07Z

Mixer: Neues Seitenlayout von ST

=Allgemeines=

Die ''STM32F10x Standard Peripherals Library'' ist eine umfangreiche komfortable C-Bibliothek, die den Zugriff auf alle Funktionen der '''STM32F10x''' Familie erlaubt. Dabei ist für die verschiedenen Peripheriekomponenten jeweils ein eigenes Modul verfügbar.

Die Bibliothek kann hier bei ST kostenlos heruntergeladen werden.
Dazu auf der [http://www.st.com/web/en/home.html ST-Webseite]:
* Oben den Punkt Support wählen
* Auf der linken Seite "Tools and Software" anklicken
* Nun links nochmals "Software" auswählen
* Danach den Unterpunkt "MCU Software" wählen
* Nun die richtige MCU-Familie, also "STM32 MCUs Software" selektieren
* Es erscheint eine Tabelle mit vielen Packages für die zahlreichen Demoboards und verschiedene Bibliotheken (USB, Ethernet, etc.)
* Die STM32F10x Standard Peripherals Library ist hier als "STSW-STM32054" bezeichnet
* Nach der Auswahl kann diese über den Download-Button in einem *.zip-Archiv heruntergeladen werden

Alternativ ist hier ein [http://www.st.com/st-web-ui/static/active/en/st_prod_software_internet/resource/technical/software/firmware/stsw-stm32054.zip Direktlink].
In dem Archiv ist die ‎STM32F10x Standard Peripherals Library. Zu jeder Peripherie gibt es diverse Beispiele und eine Beschreibung als CHM Datei "stm32f10x_stdperiph_lib_um.chm".

Bevor Ihr lange sucht, die USB-Schnittstelle ist nicht in der ''STM32F10x Standard Peripherals Library'' enthalten. Die hierfür verfügbare Firmware sowie Beispielcode befindet sich in der [[STM32_USB-FS-Device_Lib]]

===Hinweise===
Die notwendigen Informationen, um die Funktionen der Standard Peripherals Library zu verstehen, muss man sich leider aus verschiedenen Quellen zusammensuchen. Daher soll mit diesem Artikel versucht werden, deren Benutzung für die verschiedenen Peripheriekomponenten zu erläutern.

Leider beziehen sich die von ST gelieferten Beispiele sehr auf die von ST verfügbaren Evalboards und der Code wimmelt von #defines, so dass man sich erst mühsam durchhangeln muss um zu verstehen, was da eigentlich passiert. Dies geht zwar durch die gute Verlinkung in der Hilfsdatei ganz gut, erschwert aber den Einstieg unnötig.

In diesem Artikel soll daher die Anwendung ''bare bones'' ähnlich den Beispielen in den AVR Datenblättern erfolgen.
Wo nötig, werden die zum Verständnis relevanten Ausschnitte des Reference Manual [http://www.st.com/internet/com/TECHNICAL_RESOURCES/TECHNICAL_LITERATURE/REFERENCE_MANUAL/CD00171190.pdf RM0008] in den Artikel kopiert.

'''(Bevor hier die Copyright Discussion entbrennt: Das Landgericht München hat 1996 festgestellt, dass die Beschreibung von elektronischen Schaltungen nicht dem Urheberrecht unterliegen. Außerdem sollte ST sehr daran gelegen sein mehr Entwickler für Ihre µC zu begeistern.)'''

=== Dokumentationen ===

Um mit der Library zu arbeiten sind folgende Dokumentationen empfehlenswert:

* RM0008 Reference Manual zum STM32Fxxxx Controller
Beschreibung und Registerdoku der Peripherie (GPIO, Timer ...)
* PM0056 STM32F10xxx Cortex-M3 programming manual
Cortex-M3 eigene Peripherie (wichtig zb. NVIC)
* Datasheet des verwendeten µC Types (zb. STM32F103xC/D/E)
Pinout des µC und alternative Verwendbarkeit der PINs

Download from [[http://www.st.com/internet/mcu/class/1734.jsp Documents and files for STM32F family]]

=== Die ST Standard Peripheral Lib in CrossWorks ===
Aufgrund mehrfacher Anfragen, hier ein Archiv, das meine Arbeitsumgebung [[Bild:CrossWorks_StandardLib_Setup.zip]] mit zwei Crossworks Projekten (ARM_LED_TEST und ARM_USB_Test) enthält. Einfach alles in ein Verzeichnis entpacken und schon sollte es Laufen.

=== Einführungsbeispiel Blinking LED ===

Einführungsbeispiel [[STM32 LEDBlinken AtollicTrueStudio]]

=== Die Idee hinter der STM32 Standard Peripherals Library ===

So stellt sich ARM und ST-Microelectronics die Library vor.

[[Datei:Stm32_std_peripherial_library_idee.JPG]]

=Clocks - Der Herzschlag unseres Mikrocontrollers=

[[Datei:stm32_aufbau.jpg|thumb|Interner Aufbau eines [[STM32F103]]]]
Unser Mikrocontroller hat viele interne Takte. Diese müssen unbedingt konfiguriert werden. Dazu verwenden wir die RCC (Reset and Clock Control). Dazu gibt es Funktionen in der ST-Library. Welche Takte an welchen Bussen liegen, siehst du im Bild.

Die Controller verfügen über zwei getrennte Datenbusse für die langsameren Teile der Periphierie. Den APB1 und den APB2. Diese sind wiederum über Brücken am Systembus angeschlossen. Das wären in diesem Fall die AHB1 und AHB2. Man muss beachten, dass der APB1 "nur" mit maximal 36MHz getaktet werden darf, der APB2 hingegen mit 72MHz.

'''Wichtig!''' Alle unsere Peripherie Teile, die wir verwenden möchten, '''müssen mit einem Takt versorgt werden,''' bevor man sie verwenden kann. Bei Nichtbeachten führt dies häufig zu langer Fehlersuche.

Der [[STM32]] wird normalerweise mit einem Quarz von 4-16MHz versorgt. Aus diesem wird dann mittels der internen PLL der eigentliche Takt gebildet (bis 72MHz).
Jeder benötigte Takt wird vom Haupttakt abgeleitet. Die Controller verfügen auch über interne RC-Oszillatoren (typischerweise ein 8 MHz RC-Oszillator mit einer Genauigkeit von 1 % sowie einem 40 kHz RC-Oszillator). Zumindest der interne 8 MHz-Oszillator ist für die meisten Anwendungen genau genug. Für z.B. USB oder CAN mit Taktraten > 100 kbit/s ist er aber '''nicht''' genau genug. Der interne 40 kHz-Oszillator hingegen ist '''sehr''' ungenau (zwischen 30 und 60 kHz).

Hardwaretechnisch sollte darauf geachtet werden, dass bei Verwendung eines externen Quarzes dieser eine Frequenz von 8 MHz besitzt.
Die gesamten Defines in der Library beziehen sich darauf. Ansonsten ist eine Anpassung der PLL Multiplikatoren in der Datei "system_stm32f10x.c" nötig.

==Taktquelle auswählen==

Nach dem Reset wird automatisch '''immer''' der interne HSI-Takt genutzt, um einen definierten Zustand zu haben (also der interne 8 MHz RC-Oszillator). Das ist z.B. erforderlich, damit der integrierte Bootloader mit einer bekannten Frequenz versorgt wird (sofern dieser über die Boot-Pins überhaupt gewünscht ist).
Zum Glück gibt es ein automatisches Sicherheitsfeature, sodass man die aktuelle Taktquelle des Controllers nicht abschalten kann, da der Controller sonst einfach stehen bleiben würde!
===HSI - Highspeed Internal Oscillator===
Man kann den internen Oszillator nach dem Reset umkonfigurieren. [Hier fehlt noch etwas]

Zum Ein- und Ausschalten der HSI-Taktquelle verwendet man '''RCC_HSICmd()'''. Als Parameter werden entweder '''ENABLE''' oder '''DISABLE''' erwartet.
<c>
RCC_HSICmd(ENABLE); //Aktiviert den internen Highspeed Oszillator.
</c>

==Takte Reseten==
Nach dem Reset befindet sich die gesamte Taktkonfiguration in einem definierten Zustand. Macht man später irgendwelche Änderungen an der Taktkonfiguration kann es sinnvoll sein, vorher alle Takte auf ihre Standardwerte zurückzusetzen. Dies schafft wieder eine definierte zentrale Taktkonfiguration. Man muß sich nicht überlegen, wo man noch was zuvor eingestellt hat. Hat man allerdings schon z.B. irgendwelche Peripheriemodule konfiguriert, muß man natürlich aufpassen, welche Folgen die zentrale Taktänderung hier haben kann!
Nach '''RCC_DeInit()''' sind alle Takte resettet. Übergeben wird nichts!
<c>
RCC_DeInit(); //Setzt alle Takte auf deren Ursprungsszustand zurück.
</c>

===HSE - Highspeed External Oscillator (Quarz)===
Es kann auch eine externe Taktquelle ausgewählt werden. Um dem Controller dies mitzuteilen, gibt es die Funktion '''RCC_HSEConfig()'''. Als Parameter erwartet sie einen der folgenden Werte: '''RCC_HSE_OFF''', '''RCC_HSE_ON''' oder '''RCC_HSE_Bypass'''.

Die Ersten sind selbsterklärend. Wenn man der Funktion jedoch '''RCC_HSE_Bypass''' übergibt, so erwartet der Controller am OSC_IN Pin ein Taktsignal. Dieses darf bis zu 25MHz schnell sein und kann Rechteck, Sinus oder Dreieck Spannung mit einem Duty Cycle von 50% sein.
<c>
RCC_HSEConfig(RCC_HSE_ON); //Aktiviert den Externen Highspeed Oszillator (Quarz).
</c>

=GPIOS - Wie greife ich auf einzelne Pins zur Ein/Ausgabe zu=
===Grundlagen===

Unser Mikrocontroller hat ja einige Beinchen, diese können wir als Eingänge sowie als Ausgänge verwenden.
Dazu müssen wir unserem Käfer jedoch erst sagen welcher Pin was machen soll. Wie dies geht wird hier beschrieben.

Der STM32F10x verfügt zur Manipulation der IO-Pins über ein sehr raffiniertes Feature, das es erlaubt Bits für die IO-Pins zu setzen / löschen ohne vorher deren aktuellen Zustand auslesen zu müssen (üblicherweise Read-Modify-Write). Dadurch ist gewährleistet, dass beim Setzen/Löschen von Bits kein Interrupt dies stören kann.

'''Each of the general-purpose I/O ports has two 32-bit configuration registers (GPIOx_CRL, GPIOx_CRH), two 32-bit data registers (GPIOx_IDR, GPIOx_ODR), a 32-bit set/reset register (GPIOx_BSRR), a 16-bit reset register (GPIOx_BRR) and a 32-bit locking register (GPIOx_LCKR).'''

'''Each I/O port bit is freely programmable, however the I/O port registers have to be accessed as 32-bit words (half-word or byte accesses are not allowed). The purpose of the GPIOx_BSRR and GPIOx_BRR registers is to allow atomic read/modify accesses to any of the GPIO registers. This way, there is no risk that an IRQ occurs between the read and the modify access.'''

Auf die '''BRR''' und '''BSRR''' register greift man über die entsprechenden GPIO-Port zu.

Hierzu existieren in <c>\Libraries\CMSIS\CM3\DeviceSupport\ST\STM32F10x\stm32f10x.h</c> folgende Definition:

<c>
typedef struct
{
__IO uint32_t CRL;
__IO uint32_t CRH;
__IO uint32_t IDR;
__IO uint32_t ODR;
__IO uint32_t BSRR;
__IO uint32_t BRR;
__IO uint32_t LCKR;
} GPIO_TypeDef;
</c>

Pointer auf die entsprechenden GPIO-Ports sind hier ebenfalls definiert:

<c>
#define GPIOA ((GPIO_TypeDef *) GPIOA_BASE)
#define GPIOB ((GPIO_TypeDef *) GPIOB_BASE)
#define GPIOC ((GPIO_TypeDef *) GPIOC_BASE)
#define GPIOD ((GPIO_TypeDef *) GPIOD_BASE)
#define GPIOE ((GPIO_TypeDef *) GPIOE_BASE)
#define GPIOF ((GPIO_TypeDef *) GPIOF_BASE)
#define GPIOG ((GPIO_TypeDef *) GPIOG_BASE)
</c>
Welche GPIO-Ports tatsächlich verfügbar sind ist abhängig vom verwendeten Controller!

In stm32f10x_gpio.h sind darüber hinaus Definitionen für alle Pins vorhanden:

<c>
#define GPIO_Pin_0 ((uint16_t)0x0001) /*!< Pin 0 selected */
#define GPIO_Pin_1 ((uint16_t)0x0002) /*!< Pin 1 selected */
#define GPIO_Pin_2 ((uint16_t)0x0004) /*!< Pin 2 selected */
#define GPIO_Pin_3 ((uint16_t)0x0008) /*!< Pin 3 selected */
#define GPIO_Pin_4 ((uint16_t)0x0010) /*!< Pin 4 selected */
#define GPIO_Pin_5 ((uint16_t)0x0020) /*!< Pin 5 selected */
#define GPIO_Pin_6 ((uint16_t)0x0040) /*!< Pin 6 selected */
#define GPIO_Pin_7 ((uint16_t)0x0080) /*!< Pin 7 selected */
#define GPIO_Pin_8 ((uint16_t)0x0100) /*!< Pin 8 selected */
#define GPIO_Pin_9 ((uint16_t)0x0200) /*!< Pin 9 selected */
#define GPIO_Pin_10 ((uint16_t)0x0400) /*!< Pin 10 selected */
#define GPIO_Pin_11 ((uint16_t)0x0800) /*!< Pin 11 selected */
#define GPIO_Pin_12 ((uint16_t)0x1000) /*!< Pin 12 selected */
#define GPIO_Pin_13 ((uint16_t)0x2000) /*!< Pin 13 selected */
#define GPIO_Pin_14 ((uint16_t)0x4000) /*!< Pin 14 selected */
#define GPIO_Pin_15 ((uint16_t)0x8000) /*!< Pin 15 selected */
#define GPIO_Pin_All ((uint16_t)0xFFFF) /*!< All pins selected */
</c>

Will man also von Hand auf die Bits dieser Register zugreifen, so ist das denkbar einfach:
<c>
GPIOC->BSRR = GPIO_Pin_13;
</c>
setzt das Bit für Pin 13 im Port C.
<c>
GPIOC->BRR = GPIO_Pin_13;
</c>
oder
<c>
GPIOC->BSRR = GPIO_Pin_13 << 16;
</c>
löscht dieses Bit wieder. Mit
<c>
GPIOC->BSRR = (0x00F0 << 16) | ((data << 4) & 0x00F0);
</c>
kann man die Pins 4..7 auf einen beliebigen Wert setzen, ohne die übrigen Pins zu beeinflussen. Die oberen 16 Bits des geschriebenen Wertes definieren die betroffenen Pins, die unteren 16 Bits den Wert. In der ''Standard Peripheral Library'' ist keine Funktion enthalten, die diese Fähigkeit des Ports unterstützt.

Die äquivalente Operation über das ODR ist nicht atomar und somit in Verbindung mit Interrupts problematisch.

Die ''Standard Peripheral Library'' stellt für dies Zugriffe allerdings auch komfortablere und vor allem sprechendere Funktionen zur verfügen, die weiter unten erklärt werden.

===Initialisierung===

'''WICHTIG: Bevor man Pins eines GPIO-Ports benutzen kann, muss man die Clock des entsprechenden Ports mit der Funktion ''RCC_APB2PeriphClockCmd'' aktivieren , da diese nach einem Reset immer ausgeschaltet ist. Dies ist ein sehr beliebter Fehler beim Arbeiten mit Ports. Mehr dazu bei [[STM32F10x Standard Peripherals Library#Clocks - Der Herzschlag unseres Mikrocontroller|Clocks]]'''

Bevor man einen Pin benutzen kann, muss dieser Initialisiert werden.

Die Funktion '''GPIO_Init()''' ermöglicht es einen oder mehere Pins auf einmal zu konfigurieren. Hierzu muss eine struct ausgefüllt und GPIO_Init übergeben werden:

<c>
typedef struct
{
u16 GPIO_Pin;
GPIOSpeed_TypeDef GPIO_Speed;
GPIOMode_TypeDef GPIO_Mode;
}GPIO_InitTypeDef;
</c>

Definieren müssen wird dieses zuvor jedoch auch. Dies geschieht mit

<c>
GPIO_InitTypeDef GPIO_InitStructure;
</c>

Danach können wir bequem auf die einzelnen Einträge aus der Struct zugreifen.
Der nachfolgende Code zeigt eine Beispielkonfiguration.

<c>
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_All;
</c>
 
'''GPIO_Speed''' definiert die maximale Änderungsrate des Pins. Das ist aber keine harte Grenze, sondern verändert die Charakteristik des Pintreibers. Eine niedrigere Grenzfrequenz reduziert die Flankensteilheit und damit Leitungsreflexionen.
Mögliche Werte für GPIO_Speed
{| border="1" cellspacing="0" cellpadding="5" style="border-collapse:collapse;"
|''' Wert''' ||''' Bedeutung''
|-
| GPIO_Speed_2MHz || 2MHz / 125ns
|-
| GPIO_Speed_10MHz || 10MHz / 25ns
|-
| GPIO_Speed_50MHz || 30-50MHz / 5-12ns
|}

 
'''GPIO_Mode''' konfiguriert den Port oder den Port Pin.
Mögliche Werte für GPIO_Mode
{| border="1" cellspacing="0" cellpadding="5" style="border-collapse:collapse;"
|''' Wert''' ||''' Beschreibung'''
|-
| GPIO_Mode_Out_PP || Der Pin wird als Ausgang im Push Pull Modus konfiguriert. Dies bedeutet, der Ausgang kann sowohl positive als auch negative Ströme liefern
|-
| GPIO_Mode_Out_OD || Der Pin wird als Ausgang im Open Drain Modus konfiguriert.
|-
| GPIO_Mode_IN_FLOATING || Der Pin wird als Eingang im Floating modus konfiguriert. Dies bedeutet, das der Pin kein Niveau hat. Er "schwebt"
|-
| GPIO_Mode_AIN || Der Pin wird als analoger Eingang konfiguriert
|-
| GPIO_Mode_IPD || Der Pin wird als Eingang konfiguriert mit internem Pull Down Widerstand
|-
| GPIO_Mode_IPU || Der Pin wird als Eingang konfiguriert mit internem Pull Up Widerstand
|-
| GPIO_Mode_AF_OD || Der Pin wird mit Alternativer Funktion (SPI, I2C..) konfiguriert im Open Drain Modus
|-
| GPIO_Mode_AF_PP || Der Pin wird mit Alternativer Funktion (SPI, I2C..) konfiguriert im Push Pull Modus
|}
 

'''GPIO_Pin''' definiert den Pin welcher konfiguriert werden soll.

Um den zu konfigurierenden Pin anzugeben, genügt es '''GPIO_Pin_X''' zu schreiben.
Wobei "X" durch die entsprechende Pinnummer zu ersetzen ist.
 Es können auch mehrere Pins gleichzeitig konfiguriert werden.
Dazu wird einfach logische ODER verknüfung verwendet ( | )
Möchte man den gesamten Port konfigurieren, so genügt es wenn man '''GPIO_Pin_All''' angibt.

Hier ein Beispiel mit mehreren Pins

<c>
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1 | GPIO_Pin_7
</c>
 

'''GPIO_Init()'''

Nachdem wir nun alle relevanten Parameter gesetzt haben, müssen wir den Port nur noch mit '''GPIO_Init()''' initialisieren.

<c>
void GPIO_Init(GPIO_TypeDef* GPIOx, GPIO_InitTypeDef* GPIO_InitStruct)
</c>

''GPIOx'' ist der Pointer auf den den zu initialisierenden Port. Wobei x einfach mit dem entsprechenden Buchstaben zu ersetzen ist.

''GPIO_InitStruct'' ist der Pointer auf die soeben von uns ausgefüllte struct.

Ein Beispiel für GPIOA
<c>
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE); // Clock des Ports einschalten

GPIO_InitTypeDef GPIO_InitStructure;

GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1 | GPIO_Pin_7

GPIO_Init(GPIOA, &GPIO_InitStructure);
</c>

===Etwas auf den Port ausgeben===

Um etwas an einem GPIO auszugeben, gibt es drei Möglichkeiten (Funktionen).
Entweder man schreibt den gesamten Port oder nur ein einzelnes Bit.
Die STMs bieten eine Bitbanding-Funktion, die in [[ARM Bitbanding]] genauer erklärt ist.

'''Funktion 1'''

Die erste Funktion lautet '''GPIO_SetBits()''' und '''GPIO_ResetBits()'''
Erster Parameter ist der GPIO Port, der zweite ist der Pin oder eine Kombination daraus. Kombinationen sind wieder logisch zu verknüpfen mit ODER ( | )

<c>
GPIO_SetBits(GPIOA,GPIO_Pin_1 | GPIO_Pin_5); //Setzt die Bits 1 und 5 am GPIOA auf high

GPIO_ResetBits(GPIOA,GPIO_Pin_2 | GPIO_Pin_9); //Setzt die Bits 2 und 9 am GPIOA auf low
</c>

'''Funktion 2'''

Die zweite Funktion lautet '''GPIO_WriteBit()''' Diese Funktion kann sowohl einen oder mehrere Pins setzen als auch löschen. Erster Parameter ist der GPIO Port, der zweite ist der Pin oder eine Kombination daraus, und der dritte sagt aus, ob gesetzt oder gelöscht wird! Kombinationen sind auch hier logisch zu verknüpfen mit ODER ( | ).

<c>
GPIO_WriteBit(GPIOA, GPIO_Pin_1 | GPIO_Pin_5, Bit_SET); //Setzt die Bits 1 und 5 am GPIOA auf high

GPIO_WriteBit(GPIOA, GPIO_Pin_2 | GPIO_Pin_9, Bit_RESET); //Setzt die Bits 2 und 9 am GPIOA auf low
</c>

'''Funktion 3'''

Die dritte und somit letzte Funktion lautet '''GPIO_Write()'''. Diese Funktion beschreibt den gesamten Port! Erster Parameter ist der GPIO Port, der zweite ist der an dem Port auszugebende Wert. '''Wichtig!''' Hier wird der ganze Port mit einem 16 bit Wert beschrieben. Viel leserlicher als mit magic numbers im Hex-Format zu arbeiten, sind natürlich auch hier die defines: GPIO_Pin_1 | GPIO_Pin_5

<c>
GPIO_Write(GPIOA,0x0011); //Setzt die Bits 1 und 5 am GPIOA auf high
GPIO_Write(GPIOA, GPIO_Pin_1 | GPIO_Pin_5); // Geht natürlich auch und ist verständlicher

GPIO_ResetBits(GPIOA,0x0102); //Setzt die Bits 2 und 9 am GPIOA auf low
</c>

===Pin Sperren===

Der [[STM32]] bietet die Möglichkeit, einen Pin zu sperren. Ist ein Pin gesperrt, so kann dessen Zustand (High / Low) '''bis zu einem Reset''' nicht mehr geändert werden! Wie wir es nun gewohnt sind, hat ST dafür eine eigene Funktion geschrieben. Diese lautet '''GPIO_PinLockConfig()'''. Erster Parameter ist der Port, der zweite sind die Pins, welche man sperren möchte. Diese kann man wieder mit der ODER Verknüpfung kombinieren.

<c>
GPIO_PinLockConfig(GPIOA,GPIO_Pin_1 | GPIO_Pin_5); //Sperrt die Pins bis zu einem Reset
</c>

===Eingänge einlesen===

Um Daten in den [[STM32]] einzulesen, gibt es wieder ein paar ST Funktionen. Diese möchten wir hier vorstellen. Die dafür verwendbaren Funktionen sind: '''GPIO_ReadInputDataBit()''' sowie '''GPIO_ReadInputData()'''. Erster Parameter ist der Port, der zweite sind die Pins, die man einlesen möchte. Bei '''GPIO_ReadInputData()''' wird jedoch nur der Port übergeben, da diese Funktion den '''gesamten''' Port zurück liefert! Hier wird der tatsächliche logische Pegel am Pin eingelesen!

<c>
uint8_t ucStatus = 0;

ucStatus = GPIO_ReadInputDataBit(GPIOA,GPIO_Pin_5); //Speichert den Zustand von Pin5 am GPIOA in die 8-bit-Variable ucStatus
//(uint8_t ist die kleinstmögliche, eigenständige Variable für dieses eine Bit)
</c>

<c>
uint16_t uiPort = 0;

uiPort = GPIO_ReadInputData(GPIOA); //Speichert den Zustand von GPIOA in die 16-bit-Variable uiPort
</c>

===Ausgänge einlesen===

Man hat ja häufig das Problem, dass man gerne nachsehen möchte, was man denn gerade am Ausgang ausgibt. Dazu kann man den Ausgang wie ein Eingang einlesen. Die dafür verwendbaren Funktionen sind: '''GPIO_ReadOutputDataBit()''' sowie '''GPIO_ReadOutputData()'''. Erster Parameter ist der Port, der zweite sind die Pins, welche man auslesen möchte. Bei '''GPIO_ReadOutputData()''' wird jedoch nur der Port übergeben, da diese Funktion den '''gesamten''' Port zurück liefert!Hier wird '''nicht''' der tatsächliche logische Pegel am Pin eingelesen, sondern was im Ausgangsregister eingestellt wurde (also eigentlich anliegen sollte)! Diese beiden Werte können sich auf Grund externer Einflüsse aber unterscheiden!!!

<c>
uint8_t ucStatus = 0;

ucStatus = GPIO_ReadOutputDataBit(GPIOA,GPIO_Pin_5); //Speichert den Zustand von Pin5 am GPIOA in die 8-bit-Variable ucStatus
//(uint8_t ist die kleinstmögliche, eigenständige Variable für dieses eine Bit)
</c>

<c>
uint16_t uiPort = 0;

uiPort = GPIO_ReadOutputData(GPIOA); //Speichert den Zustand von GPIOA in die 16-bit-Variable uiPort
</c>

===Deinitialisieren von Ports===

Es gibt auch die Möglichkeit, den Port zu deinitialisieren. Dann wird er mit seinen Standardwerten konfiguriert. Die Funktion dazu lautet '''GPIO_DeInit()'''. Erster und einziger Parameter ist der Port, den man deinitialisieren möchte.

<c>
GPIO_DeInit(GPIOA); //Setzt den GPIOA auf seine Standardwerte zurück
</c>

= Weblinks, Foren, Communities =

* [http://www.mikrocontroller.net/topic/175840 Diskussion zum Artikel]
* [http://www.libopencm3.org libopencm3] -- Eine Open-Source Alternative (GPL, Version 3 oder höher) zur ST Library
* Artikel [[STM32]]

[[Kategorie:STM32]]

STM32F10x Standard Peripherals Library

2013-03-05T09:23:57Z

Mixer: Link war tot

=Allgemeines=

Die ''STM32F10x Standard Peripherals Library'' ist eine umfangreiche komfortable C-Bibliothek, die den Zugriff auf alle Funktionen der '''STM32F10x''' Familie erlaubt. Dabei ist für die verschiedenen Peripheriekomponenten jeweils ein eigenes Modul verfügbar.

Die Bibliothek kann hier bei ST kostenlos heruntergeladen werden.
Dazu auf der [http://www.st.com/internet/com/home/home.jsp ST-Webseite]:
* Unten unter Products "Micros and Memories" wählen,
* Unten erscheinen 4 Kästchen. Unter Products "Microcontrollers" auswählen,
* Links in dem grauen Kasten die passende Familie selektieren. Also "STM32 F1 Mainstream",
* Danach in den blauen Kasten auf "Resources" klicken,
* Nach Auswahl von "Firmware öffnet sich ein Fenster in den man die jeweils aktuellste Version finden kann.

Alternativ ist hier ein [http://www.st.com/st-web-ui/static/active/en/st_prod_software_internet/resource/technical/software/firmware/stsw-stm32054.zip Direktlink].
In dem Archiv ist die ‎STM32F10x Standard Peripherals Library. Zu jeder Peripherie gibt es diverse Beispiele und eine Beschreibung als CHM Datei "stm32f10x_stdperiph_lib_um.chm".

Bevor Ihr lange sucht, die USB-Schnittstelle ist nicht in der ''STM32F10x Standard Peripherals Library'' enthalten. Die hierfür verfügbare Firmware sowie Beispielcode befindet sich in der [[STM32_USB-FS-Device_Lib]]

===Hinweise===
Die notwendigen Informationen, um die Funktionen der Standard Peripherals Library zu verstehen, muss man sich leider aus verschiedenen Quellen zusammensuchen. Daher soll mit diesem Artikel versucht werden, deren Benutzung für die verschiedenen Peripheriekomponenten zu erläutern.

Leider beziehen sich die von ST gelieferten Beispiele sehr auf die von ST verfügbaren Evalboards und der Code wimmelt von #defines, so dass man sich erst mühsam durchhangeln muss um zu verstehen, was da eigentlich passiert. Dies geht zwar durch die gute Verlinkung in der Hilfsdatei ganz gut, erschwert aber den Einstieg unnötig.

In diesem Artikel soll daher die Anwendung ''bare bones'' ähnlich den Beispielen in den AVR Datenblättern erfolgen.
Wo nötig, werden die zum Verständnis relevanten Ausschnitte des Reference Manual [http://www.st.com/internet/com/TECHNICAL_RESOURCES/TECHNICAL_LITERATURE/REFERENCE_MANUAL/CD00171190.pdf RM0008] in den Artikel kopiert.

'''(Bevor hier die Copyright Discussion entbrennt: Das Landgericht München hat 1996 festgestellt, dass die Beschreibung von elektronischen Schaltungen nicht dem Urheberrecht unterliegen. Außerdem sollte ST sehr daran gelegen sein mehr Entwickler für Ihre µC zu begeistern.)'''

=== Dokumentationen ===

Um mit der Library zu arbeiten sind folgende Dokumentationen empfehlenswert:

* RM0008 Reference Manual zum STM32Fxxxx Controller
Beschreibung und Registerdoku der Peripherie (GPIO, Timer ...)
* PM0056 STM32F10xxx Cortex-M3 programming manual
Cortex-M3 eigene Peripherie (wichtig zb. NVIC)
* Datasheet des verwendeten µC Types (zb. STM32F103xC/D/E)
Pinout des µC und alternative Verwendbarkeit der PINs

Download from [[http://www.st.com/internet/mcu/class/1734.jsp Documents and files for STM32F family]]

=== Die ST Standard Peripheral Lib in CrossWorks ===
Aufgrund mehrfacher Anfragen, hier ein Archiv, das meine Arbeitsumgebung [[Bild:CrossWorks_StandardLib_Setup.zip]] mit zwei Crossworks Projekten (ARM_LED_TEST und ARM_USB_Test) enthält. Einfach alles in ein Verzeichnis entpacken und schon sollte es Laufen.

=== Einführungsbeispiel Blinking LED ===

Einführungsbeispiel [[STM32 LEDBlinken AtollicTrueStudio]]

=== Die Idee hinter der STM32 Standard Peripherals Library ===

So stellt sich ARM und ST-Microelectronics die Library vor.

[[Datei:Stm32_std_peripherial_library_idee.JPG]]

=Clocks - Der Herzschlag unseres Mikrocontrollers=

[[Datei:stm32_aufbau.jpg|thumb|Interner Aufbau eines [[STM32F103]]]]
Unser Mikrocontroller hat viele interne Takte. Diese müssen unbedingt konfiguriert werden. Dazu verwenden wir die RCC (Reset and Clock Control). Dazu gibt es Funktionen in der ST-Library. Welche Takte an welchen Bussen liegen, siehst du im Bild.

Die Controller verfügen über zwei getrennte Datenbusse für die langsameren Teile der Periphierie. Den APB1 und den APB2. Diese sind wiederum über Brücken am Systembus angeschlossen. Das wären in diesem Fall die AHB1 und AHB2. Man muss beachten, dass der APB1 "nur" mit maximal 36MHz getaktet werden darf, der APB2 hingegen mit 72MHz.

'''Wichtig!''' Alle unsere Peripherie Teile, die wir verwenden möchten, '''müssen mit einem Takt versorgt werden,''' bevor man sie verwenden kann. Bei Nichtbeachten führt dies häufig zu langer Fehlersuche.

Der [[STM32]] wird normalerweise mit einem Quarz von 4-16MHz versorgt. Aus diesem wird dann mittels der internen PLL der eigentliche Takt gebildet (bis 72MHz).
Jeder benötigte Takt wird vom Haupttakt abgeleitet. Die Controller verfügen auch über interne RC-Oszillatoren (typischerweise ein 8 MHz RC-Oszillator mit einer Genauigkeit von 1 % sowie einem 40 kHz RC-Oszillator). Zumindest der interne 8 MHz-Oszillator ist für die meisten Anwendungen genau genug. Für z.B. USB oder CAN mit Taktraten > 100 kbit/s ist er aber '''nicht''' genau genug. Der interne 40 kHz-Oszillator hingegen ist '''sehr''' ungenau (zwischen 30 und 60 kHz).

Hardwaretechnisch sollte darauf geachtet werden, dass bei Verwendung eines externen Quarzes dieser eine Frequenz von 8 MHz besitzt.
Die gesamten Defines in der Library beziehen sich darauf. Ansonsten ist eine Anpassung der PLL Multiplikatoren in der Datei "system_stm32f10x.c" nötig.

==Taktquelle auswählen==

Nach dem Reset wird automatisch '''immer''' der interne HSI-Takt genutzt, um einen definierten Zustand zu haben (also der interne 8 MHz RC-Oszillator). Das ist z.B. erforderlich, damit der integrierte Bootloader mit einer bekannten Frequenz versorgt wird (sofern dieser über die Boot-Pins überhaupt gewünscht ist).
Zum Glück gibt es ein automatisches Sicherheitsfeature, sodass man die aktuelle Taktquelle des Controllers nicht abschalten kann, da der Controller sonst einfach stehen bleiben würde!
===HSI - Highspeed Internal Oscillator===
Man kann den internen Oszillator nach dem Reset umkonfigurieren. [Hier fehlt noch etwas]

Zum Ein- und Ausschalten der HSI-Taktquelle verwendet man '''RCC_HSICmd()'''. Als Parameter werden entweder '''ENABLE''' oder '''DISABLE''' erwartet.
<c>
RCC_HSICmd(ENABLE); //Aktiviert den internen Highspeed Oszillator.
</c>

==Takte Reseten==
Nach dem Reset befindet sich die gesamte Taktkonfiguration in einem definierten Zustand. Macht man später irgendwelche Änderungen an der Taktkonfiguration kann es sinnvoll sein, vorher alle Takte auf ihre Standardwerte zurückzusetzen. Dies schafft wieder eine definierte zentrale Taktkonfiguration. Man muß sich nicht überlegen, wo man noch was zuvor eingestellt hat. Hat man allerdings schon z.B. irgendwelche Peripheriemodule konfiguriert, muß man natürlich aufpassen, welche Folgen die zentrale Taktänderung hier haben kann!
Nach '''RCC_DeInit()''' sind alle Takte resettet. Übergeben wird nichts!
<c>
RCC_DeInit(); //Setzt alle Takte auf deren Ursprungsszustand zurück.
</c>

===HSE - Highspeed External Oscillator (Quarz)===
Es kann auch eine externe Taktquelle ausgewählt werden. Um dem Controller dies mitzuteilen, gibt es die Funktion '''RCC_HSEConfig()'''. Als Parameter erwartet sie einen der folgenden Werte: '''RCC_HSE_OFF''', '''RCC_HSE_ON''' oder '''RCC_HSE_Bypass'''.

Die Ersten sind selbsterklärend. Wenn man der Funktion jedoch '''RCC_HSE_Bypass''' übergibt, so erwartet der Controller am OSC_IN Pin ein Taktsignal. Dieses darf bis zu 25MHz schnell sein und kann Rechteck, Sinus oder Dreieck Spannung mit einem Duty Cycle von 50% sein.
<c>
RCC_HSEConfig(RCC_HSE_ON); //Aktiviert den Externen Highspeed Oszillator (Quarz).
</c>

=GPIOS - Wie greife ich auf einzelne Pins zur Ein/Ausgabe zu=
===Grundlagen===

Unser Mikrocontroller hat ja einige Beinchen, diese können wir als Eingänge sowie als Ausgänge verwenden.
Dazu müssen wir unserem Käfer jedoch erst sagen welcher Pin was machen soll. Wie dies geht wird hier beschrieben.

Der STM32F10x verfügt zur Manipulation der IO-Pins über ein sehr raffiniertes Feature, das es erlaubt Bits für die IO-Pins zu setzen / löschen ohne vorher deren aktuellen Zustand auslesen zu müssen (üblicherweise Read-Modify-Write). Dadurch ist gewährleistet, dass beim Setzen/Löschen von Bits kein Interrupt dies stören kann.

'''Each of the general-purpose I/O ports has two 32-bit configuration registers (GPIOx_CRL, GPIOx_CRH), two 32-bit data registers (GPIOx_IDR, GPIOx_ODR), a 32-bit set/reset register (GPIOx_BSRR), a 16-bit reset register (GPIOx_BRR) and a 32-bit locking register (GPIOx_LCKR).'''

'''Each I/O port bit is freely programmable, however the I/O port registers have to be accessed as 32-bit words (half-word or byte accesses are not allowed). The purpose of the GPIOx_BSRR and GPIOx_BRR registers is to allow atomic read/modify accesses to any of the GPIO registers. This way, there is no risk that an IRQ occurs between the read and the modify access.'''

Auf die '''BRR''' und '''BSRR''' register greift man über die entsprechenden GPIO-Port zu.

Hierzu existieren in <c>\Libraries\CMSIS\CM3\DeviceSupport\ST\STM32F10x\stm32f10x.h</c> folgende Definition:

<c>
typedef struct
{
__IO uint32_t CRL;
__IO uint32_t CRH;
__IO uint32_t IDR;
__IO uint32_t ODR;
__IO uint32_t BSRR;
__IO uint32_t BRR;
__IO uint32_t LCKR;
} GPIO_TypeDef;
</c>

Pointer auf die entsprechenden GPIO-Ports sind hier ebenfalls definiert:

<c>
#define GPIOA ((GPIO_TypeDef *) GPIOA_BASE)
#define GPIOB ((GPIO_TypeDef *) GPIOB_BASE)
#define GPIOC ((GPIO_TypeDef *) GPIOC_BASE)
#define GPIOD ((GPIO_TypeDef *) GPIOD_BASE)
#define GPIOE ((GPIO_TypeDef *) GPIOE_BASE)
#define GPIOF ((GPIO_TypeDef *) GPIOF_BASE)
#define GPIOG ((GPIO_TypeDef *) GPIOG_BASE)
</c>
Welche GPIO-Ports tatsächlich verfügbar sind ist abhängig vom verwendeten Controller!

In stm32f10x_gpio.h sind darüber hinaus Definitionen für alle Pins vorhanden:

<c>
#define GPIO_Pin_0 ((uint16_t)0x0001) /*!< Pin 0 selected */
#define GPIO_Pin_1 ((uint16_t)0x0002) /*!< Pin 1 selected */
#define GPIO_Pin_2 ((uint16_t)0x0004) /*!< Pin 2 selected */
#define GPIO_Pin_3 ((uint16_t)0x0008) /*!< Pin 3 selected */
#define GPIO_Pin_4 ((uint16_t)0x0010) /*!< Pin 4 selected */
#define GPIO_Pin_5 ((uint16_t)0x0020) /*!< Pin 5 selected */
#define GPIO_Pin_6 ((uint16_t)0x0040) /*!< Pin 6 selected */
#define GPIO_Pin_7 ((uint16_t)0x0080) /*!< Pin 7 selected */
#define GPIO_Pin_8 ((uint16_t)0x0100) /*!< Pin 8 selected */
#define GPIO_Pin_9 ((uint16_t)0x0200) /*!< Pin 9 selected */
#define GPIO_Pin_10 ((uint16_t)0x0400) /*!< Pin 10 selected */
#define GPIO_Pin_11 ((uint16_t)0x0800) /*!< Pin 11 selected */
#define GPIO_Pin_12 ((uint16_t)0x1000) /*!< Pin 12 selected */
#define GPIO_Pin_13 ((uint16_t)0x2000) /*!< Pin 13 selected */
#define GPIO_Pin_14 ((uint16_t)0x4000) /*!< Pin 14 selected */
#define GPIO_Pin_15 ((uint16_t)0x8000) /*!< Pin 15 selected */
#define GPIO_Pin_All ((uint16_t)0xFFFF) /*!< All pins selected */
</c>

Will man also von Hand auf die Bits dieser Register zugreifen, so ist das denkbar einfach:
<c>
GPIOC->BSRR = GPIO_Pin_13;
</c>
setzt das Bit für Pin 13 im Port C.
<c>
GPIOC->BRR = GPIO_Pin_13;
</c>
oder
<c>
GPIOC->BSRR = GPIO_Pin_13 << 16;
</c>
löscht dieses Bit wieder. Mit
<c>
GPIOC->BSRR = (0x00F0 << 16) | ((data << 4) & 0x00F0);
</c>
kann man die Pins 4..7 auf einen beliebigen Wert setzen, ohne die übrigen Pins zu beeinflussen. Die oberen 16 Bits des geschriebenen Wertes definieren die betroffenen Pins, die unteren 16 Bits den Wert. In der ''Standard Peripheral Library'' ist keine Funktion enthalten, die diese Fähigkeit des Ports unterstützt.

Die äquivalente Operation über das ODR ist nicht atomar und somit in Verbindung mit Interrupts problematisch.

Die ''Standard Peripheral Library'' stellt für dies Zugriffe allerdings auch komfortablere und vor allem sprechendere Funktionen zur verfügen, die weiter unten erklärt werden.

===Initialisierung===

'''WICHTIG: Bevor man Pins eines GPIO-Ports benutzen kann, muss man die Clock des entsprechenden Ports mit der Funktion ''RCC_APB2PeriphClockCmd'' aktivieren , da diese nach einem Reset immer ausgeschaltet ist. Dies ist ein sehr beliebter Fehler beim Arbeiten mit Ports. Mehr dazu bei [[STM32F10x Standard Peripherals Library#Clocks - Der Herzschlag unseres Mikrocontroller|Clocks]]'''

Bevor man einen Pin benutzen kann, muss dieser Initialisiert werden.

Die Funktion '''GPIO_Init()''' ermöglicht es einen oder mehere Pins auf einmal zu konfigurieren. Hierzu muss eine struct ausgefüllt und GPIO_Init übergeben werden:

<c>
typedef struct
{
u16 GPIO_Pin;
GPIOSpeed_TypeDef GPIO_Speed;
GPIOMode_TypeDef GPIO_Mode;
}GPIO_InitTypeDef;
</c>

Definieren müssen wird dieses zuvor jedoch auch. Dies geschieht mit

<c>
GPIO_InitTypeDef GPIO_InitStructure;
</c>

Danach können wir bequem auf die einzelnen Einträge aus der Struct zugreifen.
Der nachfolgende Code zeigt eine Beispielkonfiguration.

<c>
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_All;
</c>
 
'''GPIO_Speed''' definiert die maximale Änderungsrate des Pins. Das ist aber keine harte Grenze, sondern verändert die Charakteristik des Pintreibers. Eine niedrigere Grenzfrequenz reduziert die Flankensteilheit und damit Leitungsreflexionen.
Mögliche Werte für GPIO_Speed
{| border="1" cellspacing="0" cellpadding="5" style="border-collapse:collapse;"
|''' Wert''' ||''' Bedeutung''
|-
| GPIO_Speed_2MHz || 2MHz / 125ns
|-
| GPIO_Speed_10MHz || 10MHz / 25ns
|-
| GPIO_Speed_50MHz || 30-50MHz / 5-12ns
|}

 
'''GPIO_Mode''' konfiguriert den Port oder den Port Pin.
Mögliche Werte für GPIO_Mode
{| border="1" cellspacing="0" cellpadding="5" style="border-collapse:collapse;"
|''' Wert''' ||''' Beschreibung'''
|-
| GPIO_Mode_Out_PP || Der Pin wird als Ausgang im Push Pull Modus konfiguriert. Dies bedeutet, der Ausgang kann sowohl positive als auch negative Ströme liefern
|-
| GPIO_Mode_Out_OD || Der Pin wird als Ausgang im Open Drain Modus konfiguriert.
|-
| GPIO_Mode_IN_FLOATING || Der Pin wird als Eingang im Floating modus konfiguriert. Dies bedeutet, das der Pin kein Niveau hat. Er "schwebt"
|-
| GPIO_Mode_AIN || Der Pin wird als analoger Eingang konfiguriert
|-
| GPIO_Mode_IPD || Der Pin wird als Eingang konfiguriert mit internem Pull Down Widerstand
|-
| GPIO_Mode_IPU || Der Pin wird als Eingang konfiguriert mit internem Pull Up Widerstand
|-
| GPIO_Mode_AF_OD || Der Pin wird mit Alternativer Funktion (SPI, I2C..) konfiguriert im Open Drain Modus
|-
| GPIO_Mode_AF_PP || Der Pin wird mit Alternativer Funktion (SPI, I2C..) konfiguriert im Push Pull Modus
|}
 

'''GPIO_Pin''' definiert den Pin welcher konfiguriert werden soll.

Um den zu konfigurierenden Pin anzugeben, genügt es '''GPIO_Pin_X''' zu schreiben.
Wobei "X" durch die entsprechende Pinnummer zu ersetzen ist.
 Es können auch mehrere Pins gleichzeitig konfiguriert werden.
Dazu wird einfach logische ODER verknüfung verwendet ( | )
Möchte man den gesamten Port konfigurieren, so genügt es wenn man '''GPIO_Pin_All''' angibt.

Hier ein Beispiel mit mehreren Pins

<c>
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1 | GPIO_Pin_7
</c>
 

'''GPIO_Init()'''

Nachdem wir nun alle relevanten Parameter gesetzt haben, müssen wir den Port nur noch mit '''GPIO_Init()''' initialisieren.

<c>
void GPIO_Init(GPIO_TypeDef* GPIOx, GPIO_InitTypeDef* GPIO_InitStruct)
</c>

''GPIOx'' ist der Pointer auf den den zu initialisierenden Port. Wobei x einfach mit dem entsprechenden Buchstaben zu ersetzen ist.

''GPIO_InitStruct'' ist der Pointer auf die soeben von uns ausgefüllte struct.

Ein Beispiel für GPIOA
<c>
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE); // Clock des Ports einschalten

GPIO_InitTypeDef GPIO_InitStructure;

GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1 | GPIO_Pin_7

GPIO_Init(GPIOA, &GPIO_InitStructure);
</c>

===Etwas auf den Port ausgeben===

Um etwas an einem GPIO auszugeben, gibt es drei Möglichkeiten (Funktionen).
Entweder man schreibt den gesamten Port oder nur ein einzelnes Bit.
Die STMs bieten eine Bitbanding-Funktion, die in [[ARM Bitbanding]] genauer erklärt ist.

'''Funktion 1'''

Die erste Funktion lautet '''GPIO_SetBits()''' und '''GPIO_ResetBits()'''
Erster Parameter ist der GPIO Port, der zweite ist der Pin oder eine Kombination daraus. Kombinationen sind wieder logisch zu verknüpfen mit ODER ( | )

<c>
GPIO_SetBits(GPIOA,GPIO_Pin_1 | GPIO_Pin_5); //Setzt die Bits 1 und 5 am GPIOA auf high

GPIO_ResetBits(GPIOA,GPIO_Pin_2 | GPIO_Pin_9); //Setzt die Bits 2 und 9 am GPIOA auf low
</c>

'''Funktion 2'''

Die zweite Funktion lautet '''GPIO_WriteBit()''' Diese Funktion kann sowohl einen oder mehrere Pins setzen als auch löschen. Erster Parameter ist der GPIO Port, der zweite ist der Pin oder eine Kombination daraus, und der dritte sagt aus, ob gesetzt oder gelöscht wird! Kombinationen sind auch hier logisch zu verknüpfen mit ODER ( | ).

<c>
GPIO_WriteBit(GPIOA, GPIO_Pin_1 | GPIO_Pin_5, Bit_SET); //Setzt die Bits 1 und 5 am GPIOA auf high

GPIO_WriteBit(GPIOA, GPIO_Pin_2 | GPIO_Pin_9, Bit_RESET); //Setzt die Bits 2 und 9 am GPIOA auf low
</c>

'''Funktion 3'''

Die dritte und somit letzte Funktion lautet '''GPIO_Write()'''. Diese Funktion beschreibt den gesamten Port! Erster Parameter ist der GPIO Port, der zweite ist der an dem Port auszugebende Wert. '''Wichtig!''' Hier wird der ganze Port mit einem 16 bit Wert beschrieben. Viel leserlicher als mit magic numbers im Hex-Format zu arbeiten, sind natürlich auch hier die defines: GPIO_Pin_1 | GPIO_Pin_5

<c>
GPIO_Write(GPIOA,0x0011); //Setzt die Bits 1 und 5 am GPIOA auf high
GPIO_Write(GPIOA, GPIO_Pin_1 | GPIO_Pin_5); // Geht natürlich auch und ist verständlicher

GPIO_ResetBits(GPIOA,0x0102); //Setzt die Bits 2 und 9 am GPIOA auf low
</c>

===Pin Sperren===

Der [[STM32]] bietet die Möglichkeit, einen Pin zu sperren. Ist ein Pin gesperrt, so kann dessen Zustand (High / Low) '''bis zu einem Reset''' nicht mehr geändert werden! Wie wir es nun gewohnt sind, hat ST dafür eine eigene Funktion geschrieben. Diese lautet '''GPIO_PinLockConfig()'''. Erster Parameter ist der Port, der zweite sind die Pins, welche man sperren möchte. Diese kann man wieder mit der ODER Verknüpfung kombinieren.

<c>
GPIO_PinLockConfig(GPIOA,GPIO_Pin_1 | GPIO_Pin_5); //Sperrt die Pins bis zu einem Reset
</c>

===Eingänge einlesen===

Um Daten in den [[STM32]] einzulesen, gibt es wieder ein paar ST Funktionen. Diese möchten wir hier vorstellen. Die dafür verwendbaren Funktionen sind: '''GPIO_ReadInputDataBit()''' sowie '''GPIO_ReadInputData()'''. Erster Parameter ist der Port, der zweite sind die Pins, die man einlesen möchte. Bei '''GPIO_ReadInputData()''' wird jedoch nur der Port übergeben, da diese Funktion den '''gesamten''' Port zurück liefert! Hier wird der tatsächliche logische Pegel am Pin eingelesen!

<c>
uint8_t ucStatus = 0;

ucStatus = GPIO_ReadInputDataBit(GPIOA,GPIO_Pin_5); //Speichert den Zustand von Pin5 am GPIOA in die 8-bit-Variable ucStatus
//(uint8_t ist die kleinstmögliche, eigenständige Variable für dieses eine Bit)
</c>

<c>
uint16_t uiPort = 0;

uiPort = GPIO_ReadInputData(GPIOA); //Speichert den Zustand von GPIOA in die 16-bit-Variable uiPort
</c>

===Ausgänge einlesen===

Man hat ja häufig das Problem, dass man gerne nachsehen möchte, was man denn gerade am Ausgang ausgibt. Dazu kann man den Ausgang wie ein Eingang einlesen. Die dafür verwendbaren Funktionen sind: '''GPIO_ReadOutputDataBit()''' sowie '''GPIO_ReadOutputData()'''. Erster Parameter ist der Port, der zweite sind die Pins, welche man auslesen möchte. Bei '''GPIO_ReadOutputData()''' wird jedoch nur der Port übergeben, da diese Funktion den '''gesamten''' Port zurück liefert!Hier wird '''nicht''' der tatsächliche logische Pegel am Pin eingelesen, sondern was im Ausgangsregister eingestellt wurde (also eigentlich anliegen sollte)! Diese beiden Werte können sich auf Grund externer Einflüsse aber unterscheiden!!!

<c>
uint8_t ucStatus = 0;

ucStatus = GPIO_ReadOutputDataBit(GPIOA,GPIO_Pin_5); //Speichert den Zustand von Pin5 am GPIOA in die 8-bit-Variable ucStatus
//(uint8_t ist die kleinstmögliche, eigenständige Variable für dieses eine Bit)
</c>

<c>
uint16_t uiPort = 0;

uiPort = GPIO_ReadOutputData(GPIOA); //Speichert den Zustand von GPIOA in die 16-bit-Variable uiPort
</c>

===Deinitialisieren von Ports===

Es gibt auch die Möglichkeit, den Port zu deinitialisieren. Dann wird er mit seinen Standardwerten konfiguriert. Die Funktion dazu lautet '''GPIO_DeInit()'''. Erster und einziger Parameter ist der Port, den man deinitialisieren möchte.

<c>
GPIO_DeInit(GPIOA); //Setzt den GPIOA auf seine Standardwerte zurück
</c>

= Weblinks, Foren, Communities =

* [http://www.mikrocontroller.net/topic/175840 Diskussion zum Artikel]
* [http://www.libopencm3.org libopencm3] -- Eine Open-Source Alternative (GPL, Version 3 oder höher) zur ST Library
* Artikel [[STM32]]

[[Kategorie:STM32]]

STM32

2013-02-15T19:40:57Z

Mixer:

STM32 ist ein Mikrocontroller-Familie von [http://www.st.com/mcu/inchtml-pages-stm32.html ST] mit einer 32-Bit [http://www.arm.com/products/processors/cortex-m/index.php ARM Cortex-M0/M3/M4] CPU. Diese Architektur ist speziell für den Einsatz in Microcontrollern neu entwickelt und löst damit die bisherigen ARM7-basierten Controller weitestgehend ab. Den STM32 gibt es von ST in unzähligen Varianten mit variabler Peripherie und verschiedenen Gehäusegrößen und -formen. Durch die geringe Chipfläche des Cores ist es ST möglich, eine 32 Bit-CPU für weniger als 1 € anzubieten.

[[Bild:stm32F103xc.png|thumb|right|340px|Blockdiagramm STM32F103xC/D/E]]

== STM32-Familien ==

Bisher gibt es sieben STM32-Familien:
* [http://www.st.com/internet/mcu/subclass/1588.jsp STM32F0]
** Cortex M0
** µC zum Einstieg
* [http://www.st.com/internet/mcu/subclass/1169.jsp STM32F1]
** Cortex M3
**Verschiedene Unterfamilien:
*** Connectivity line
*** Performance line
*** USB Access line
*** Access Line
*** Value line
* [http://www.st.com/internet/mcu/product/250173.jsp STM32F2]
** Cortex M3
** Wie die STM32F1 Serie, jedoch 120MHz, Camera-Interface, 32-Bit Timer, Crypto-Engine...
* [http://www.st.com/internet/mcu/subclass/1605.jsp STM32F3]
** Cortex M4
** DSP und FPU
** Fast 12-bit 5 MSPS and precise 16-bit sigma-delta ADCs
** Touch sensing controller (TSC)
* [http://www.st.com/internet/mcu/subclass/1521.jsp STM32F4]
** Cortex M4
** DSP und FPU
* [http://www.st.com/mcu/inchtml-pages-stm32l.html STM32L]
** Cortex M3
** Low Power
** mit LCD Treiber
* [http://www.st.com/mcu/inchtml-pages-stm32w.html STM32W]
** Cortex M3
** RF-MCU
[http://www.st.com/internet/mcu/class/1734.jsp Hier eine Übersicht zum Auswählen eines STM32Fxxx]

===Features===
* Cortex-M0 / Cortex-M3 / Cortex-M4 Kern
* 16KB ... 1MB [[Flash-ROM]]
* 4KB ... 192KB [[Speicher#SRAM|SRAM]]
* 4KB [[Speicher#EEPROM|EEPROM]] (STM32L)
* 512 one-time programmable Bytes(STM32F2/4)
* [[IC-Gehäuseformen | Gehäuse]] 36 ... 176 Pins als QFN, LQFP und BGA
* Derzeit sind über '''250''' STM32 Derivate/Varianten verfügbar
* Bis 72MHz CPU-Takt, bis 120MHz beim STM32F2xx, bis 168 MHz beim STM32F4xx, wobei eine spezielle prefetch-hardware bis 120/168 MHz eine Geschwindigkeit erzielen soll, die 0 Wait-States entspricht. Der CPU-Takt wird über einen Multiplikator aus dem internen RC-Takt oder einem externen Quarz-Takt abgeleitet.
* Externes Businterface (nur bei Gehäusen ab 100 Pin und nur bei STM32F4, STM32F2 und STM32F1 Performance line)
* LCD Treiber für 8x40 Punkte (nicht beim STM32F2xx)
* Spannungsbereich 1,65 ... 3,6V, nur eine Betriebsspannung nötig
* Temperaturbereich bis 125 °C
* Bis zu 140 IOs, viele davon [[Pegelwandler|5V-tolerant]]
* Interner, kalibrierter RC-Oszillator mit 8MHz (16MHz bei STM32F2/F4xx)
* Externer Quarz
* Real Time Clock mit eigenem Quarz und separater Stromversorgung
* Bis zu 16 [[Timer]], je Timer bis zu 4 IC/OC/PWM Ausgänge. Davon 2x Motion Control Timer (bei STM32F103xF/G)
* Systick Counter
* Bis zu 3 12-Bit [[AD-Wandler]] mit insgesamt 24 AD-Eingängen, integrierter [[Temperatursensor]], Referenzspannung Vrefint und VBatt Spannungsmessung (STM32F4xx)
* Bis zu 2 12-Bit [[DA-Wandler]]
* Bis zu 2 [[DMA]] Controller mit bis zu 12 Kanälen (16 beim STM32F2/4xx)
* Bis zu 2x [[I2C|I²C]]
* Bis zu 5x [[UART|USART]] mit LIN, IrDA und Modem Control (6 beim STM32F2/F4xx)
* Bis zu 3x [[SPI]]
* Bis zu 2x [[I2S|I²S]]
* Bis zu 2x [[CAN]]
* Unique device ID register (96 Bits)
* RNG - Random Number Generator (STM32F2/4xx)
* Cryptographic Processor (CRYP) (STM32F2/4xx)
* Hash Processor (HASH) (STM32F2/4xx)
* Kamera-Interface (DCMI) (STM32F2/4xx)
* [[USB]] 2.0 Full Speed / OTG
* [[USB]] 2.0 Hi Speed OTG mit extra PHY-Chip (STM32F2/4xx)
* SDIO Interface (z.B. SD-Card Reader)
* Ethernet
* Watchdog mit Window-Mode
* Jedes Peripheriemodul ist separat einschaltbar, wodurch sich erheblich [[Ultra low power|Strom sparen]] lässt
* [[JTAG]] und SWD (Serial Wire Debug) Interface
* Bis zu 6 Hardware-Breakpoints für Debuggen
* und vieles mehr . . .

== Struktur der Dokumentation: ==

Als Beispiel der Dokumentation soll stellvertretend der [http://www.st.com/mcu/devicedocs-STM32F103RC-110.html STM32F103RC] genannt werden. Die Seite von ST beinhaltet alle nötigen Informationen passend zu diesem Prozessor.

Diese Dokumente von ST beschreiben den Controller:

* [http://www.st.com/internet/com/TECHNICAL_RESOURCES/TECHNICAL_LITERATURE/DATASHEET/CD00191185.pdf Datasheet STM32F103xC/D/E]
* [http://www.st.com/internet/com/TECHNICAL_RESOURCES/TECHNICAL_LITERATURE/REFERENCE_MANUAL/CD00171190.pdf Reference Manual (RM0008)]
* [http://www.st.com/internet/com/TECHNICAL_RESOURCES/TECHNICAL_LITERATURE/PROGRAMMING_MANUAL/CD00228163.pdf Cortex-M3 Programming Manual]
* [http://www.st.com/stonline/products/literature/pm/13259.pdf Flash Programming Reference]

Im Datasheet sind die speziellen Eigenschaften einer bestimmten Modellreihe beschrieben und die exakten Daten und Pinouts aufgeführt. Die Peripheriemodule werden nur aufgeführt, nicht detailliert beschrieben. In der Referenz ist der gesamte Controller mit Peripheriemodulen im Detail beschrieben, gültig für eine STM32-Familie. Details zum Prozessorkern selbst und den nicht STM32-spezifischen mit dem Cortex-M3 Core assoziierten Modulen wie dem Interrupt-Controller und dem Systick-Timer findet man jedoch nicht dort, sondern im Cortex-M3 Manual. Wer nicht die ST Firmware-Library verwendet, der benötigt zusätzlich die Flash Programming Reference für die Betriebsart des Flash-ROMs, d.h. die frequenzabhängige Konfiguration der Waitstates. Hinzu kommen optionale Dokumente von ARM, die den [http://infocenter.arm.com/help/topic/com.arm.doc.ddi0337-/ Cortex-M3 Kern] / [http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.ddi0439c/index.html Cortex-M4 Kern] beschreiben. Hier gibt es den Opcode wenn man ihn in [http://infocenter.arm.com/help/topic/com.arm.doc.ddi0403-/ Assembler] programmieren möchte. Zusätzlich sollten auch die [http://www.st.com/stonline/products/literature/es/14732.pdf Errata Sheets] beachtet werden. Empfohlen sei auch die Appnote "[http://www.st.com/internet/com/TECHNICAL_RESOURCES/TECHNICAL_LITERATURE/APPLICATION_NOTE/CD00164185.pdf STM32F10xxx hardware development: getting started]".

== ‎STM32F10x Standard Peripherals Library ==

ST bietet eine umfangreiche Firmwarebibliothek, eine einzige Bibliothek für alle STM32 Derivate. Das ist der große Vorteil von ST (gibt es beispielsweise auf den Cortex-M3 Controllern von TI auch, ist teilweise in einem separaten ROM untergebracht). Einmal programmieren und in allen STM32 verwendbar. Alle Funktionen sind gekapselt in einfache Strukturen und Funktionsaufrufe. Somit muss man sich nicht selbst um die Peripherieregister kümmern. Diese Library und ihre Dokumentation setzen das grundlegende Verständnis der Funktion des jeweiligen Peripheriemoduls voraus, wie es die o.A. Referenz und diverse Appnotes vermitteln. Diese FW-Lib (Download von ST) ist ein MUSS für jeden, denn darin sind auch jede Menge Beispiele für alle Peripheriemodule.

Details siehe: [[‎STM32F10x Standard Peripherals Library]].

Mit [http://www.libopencm3.org/wiki/Main_Page libopencm3] ist derzeit auch eine Open-Source Alternative (GPL, Version 3 oder höher) zur ST Library in Entwicklung, die zukünftig auch Cortex-M3 Controller von anderen Herstellern unterstützen soll.

== CMSIS ==

Parallel zur Firmware-Library (FW-Lib) gibt es für die "Selbermacher" die CMSIS (ARM® '''C'''ortex™ '''M'''icrocontroller '''S'''oftware '''I'''nterface '''S'''tandard), die grundsätzlich nur den herstellerübergreifenden ARM-Core abdeckt. Hierzu gehört bei den Cortex-M4-Cores auch die DSP und Floating-Point Funktionalität. Weiterhin existieren eine Zahl von Helferfunktionen für den NVIC, den Sys-Tick-Counter, sowie eine SystemInit-Funktion, welche sich um die PLL kümmert.

Im Rahmen des CMSIS-Standards ([http://www.onARM.com www.onARM.com]) wurden die Headerdateien standardisiert, der Zugriff auf die Register erfolgt per '''Peripheral->Register'''. Die CMSIS C-Dateien bzw. Header enthalten auch Anpassungen für die verschiedenen Compiler. Die Portierung eines Real-Time-Betriebsystems sollte unter Verwendung der CMSIS, für Chips der verschiedenen Hersteller, stark vereinfacht möglich sein (z.B. einheitliche Adressen für Core-Hardware/Sys-Tick-Counter).

Die CMSIS ist im Download der FW-Lib enthalten. Die Compiler-Hersteller liefern eine jeweils zur ihrer Tool-Version passende bzw. geprüfte FW-Lib (incl. CMSIS) aus. Diese Libs können, gegenüber den Downloads beim Chip-Hersteller, auch ältere Version beinhalten.

== Debug- und Trace-Interface (CoreSight™ Debug and Trace Technologie)==

Übersicht über beide Funktionalitäten und den Schnittstellen:
http://www.keil.com/support/man/docs/ulink2/ulink2_cs_core_sight.htm

Die Coresight-Debug-Architektur ermöglicht ein nicht-invasives Debugging, d.h. es können während des Betriebes (meistens) ohne Beeinflussung des Prozessors Daten vom Speicher gelesen und in selbigen geschrieben werden.

=== Debugger Funktionen ===

Der Debugger-Teil besitzt drei Funktionen:
* Run Control: z.B. Programm-Start, Stopp und Einzel-Schritte.
* (Program) Break Points: Ein Programm hält an, wenn der Programm Counter eine bestimmte Programm-Adresse erreicht.
** Die maximale Anzahl der gleichzeitig möglichen Break Points ist begrenzt (z.B. 6 bei einem STM32).
** Die Anzahl der Break Points ist nahezu unbegrenzt, wenn ein Debugger über den Memory Access (s.u.) sogenannte Flash Break Points unterstützt. Dabei wird ein geladenes Programm im Flash umprogrammiert, um den Debugger anzuhalten. Diese Funktionalität ist meistens ein kostenpflichtiges Zusatz-Feature des Debugger-Herstellers.
** Beinhaltet keine Data Watch Funktionalität, welche im Trace-Teil (DWT) realisiert wird.
* Memory Access: Lesen und Schreiben von Speicheradressen.
** Diese Funktionalität beinhaltet keine direkte Flash-Programmierung. Der Programmiervorgang für einen Flash ist herstellerspezifisch und muss von dem verwendeten Debugger unterstützt werden.

=== Trace Funktionen ===
Die Trace-Funktionalität wird in drei Funktionen aufgeteilt:
* ETM (Embedded Trace Macrocell): Optional, nicht jede CPU besitzt diese Hardware (Kostenfaktor, Austattung).
* ITM (Instrumentation Trace Macrocell): Über diesen Kanal kann ein vereinfachtes Trace des Core ermöglicht werden, sowie "printf-ähnlich" Daten über den ITM Channel 0 geschickt und im Debugger ausgegeben werden.
* DWT (Data Watchpoint & Trace Unit):
** Data Watch: 4 Access-Break-Points ( z.B. der Debugger bleibt stehen, wenn das Programm auf einen Speicher zugreift oder der Wert einer Variablen einen bestimmten Wert annimmt).
** Trace Unit: Programmverlauf (durch Lesen des Program Counters) und Interrupt Aufrufe verfolgen, sowie Zeitmessungen.

Einige der Trace-Funktionalitäten können über die JTAG-Schnittstelle angesprochen werden. Die schnelle Trace-Funktionalität (mit 4 bit Parallel-Port) steht nur mit der erweiterten DEBUG + ETM Schnittstelle zur Verfügung. Im Gegensatz zum Debugger-Teil (Run Control, Break Points und Memory Access) werden Trace-Funktionen nicht von allen Debuggern unterstützt. Debugger mit der vollen Trace-Funktionalität kosten deutlich mehr.

* Beispiele für Trace-Port-Aktivierungen für verschiedene Hersteller: http://www.keil.com/support/man/docs/jlink/jlink_capture_tracedata.htm

Die Aktivierung des parallelen Trace-Ports erfordert, je nach CPU Hersteller, zusätzliche Debugger-Makros für die Aktivierung und Port-Freischaltung. Zusätzlich sind die Schnittstellenauswahl und Einstellung (Frequenzen) im Entwicklungs-Tool (IDE) wichtig, um erfolgreich den Programm-Verlauf "tracen" zu können.

=== Debug und Trace-Schnittstellen ===
Als Debug Interface stehen zwei Varianten zur Auswahl:
* [[JTAG]]: Dafür sind mindestens 6 Steuerleitungen nötig. Unterstützt Device Chaining: Mehrere verbundene Geräte können mit einem Debugger/Programmer gleichzeitig angesteuert werden.
* SWD (Serial Wire Debug): Hier mindestens 2 Steuerleitungen (3 mit SWO, zzgl GND und 3,3V). Die SWD Schnittstelle ist in der Regel schneller und kann auch Funktionen aus dem Trace-Teil beinhalten (z.B. ITM, dafür wird der SWO-Pin benötigt). Device Chaining ist mit dieser Schnittstelle nicht möglich.

Standard-JTAG Steckerbelegungen:
http://www.keil.com/support/man/docs/ulink2/ulink2_hw_connectors.htm

=== Der 10polige JTAG-Stecker von mmvisual ===
mmvisual hat mit dieser Steckerbelegung die Standard JTAG Schnittstelle erweitert:

Ich habe diesen Part in den Artikel [http://www.mikrocontroller.net/articles/JTAG#Der_10-Polige_JTAG_Stecker_von_mmvisual JTAG] verschoben.
Hinzu gekommen ist die Adapterplatine 10-Polig auf Standard JTAG 20 Polig mit TTL/V24 Wandler. [http://www.mikrocontroller.net/articles/JTAG#Die_Adapterplatine Siehe hier.]

== Bootmodi ==
Unterschiedliche Bootmodi lassen sich mittels der PINs BOOT0 und BOOT1 auswählen . Siehe Application Note [http://www.st.com/internet/com/TECHNICAL_RESOURCES/TECHNICAL_LITERATURE/APPLICATION_NOTE/CD00167594.pdf AN2606].

=== Boot from FLASH ===
Startadresse wird von 0x08000004 geladen
BOOT0 Lo
BOOT1 X

=== Boot from SRAM ===
PC Startadresse wird an 0x200001E0 direkt angesprungen.
BOOT0 Hi
BOOT1 Hi
Da der interne FLASH der stm32f1x laut Datenblatt nur für 1000 Schreibvorgänge ausgelegt ist, kann mittels BOOT0 (High) und BOOT1 (High) auch aus dem zuvor mit dem Debugger (JTAG/SWD) beschriebenen SRAM booten.
Hierbei gilt zu beachten:
VTOR auf die NVIC Tabelle im SRAM vor dem auslösen des ersten Interrupts remappen.

Um ein vergleichbares Startverhalten zum FLASH zu erreichen, empfiehlt es sich,
0xF1E0F85F an 0x200001E0 zu schreiben. Diese implizite Ausführung von "ldr.w pc,
[pc, #-0x01E0]" beim Start erzwingt ein laden der Startadresse von 0x20000004.

=== Boot from SYSMEM (RS232, CAN und USB) ===
PC Startadresse wird von 0x1FFFF004 geladen
BOOT0 Hi
BOOT1 Lo
Auch ohne JTAG lässt sich ein STM32 programmieren (Bootloader-Aktivierung). Dabei stehen, je nach CPU-Typ, verschiedene Möglichkeiten zur Verfügung:
* RS-232 (bisher alle STMs)
* USB (nur in bestimmten MCUs mit entsprechender Bootloader-Version und PIN-Anzahl, z.B. STM32F105/107)
* CAN (wie USB nur in bestimmten MCUs)

3 zusätzliche Verbindungen müssen auf dem Board gepatcht werden. Für einen Test geht es auch mit Tastern für RESET und BOOT0. 
RESET=RTS (L-aktiv) 
BOOT0=DTR (H-aktiv) 
BOOT1=LOW 

Details sind hier im Forum: [http://www.mikrocontroller.net/topic/141711 STM32 Programmiertool]

== Vorteile ==

'''Vorteile gegenüber ARM7:'''

* Interrupt-Controller jetzt Teil des Prozessors (als Core Peripheral), die Vector Table ist jetzt eine echte Vektortabelle, keine Sprungliste wie bei ARM7. Durch Automatismen zwischen Core und NVIC (auto register save r0..r3, lr, sp, pc) bei Interrupt Entry wird eine deutlich schnellere Ausführungszeit bei Interrupts erreicht. Der Interrupt Code muss sich nicht mehr selbst um die Sicherung der o.g. Register kümmern und eine besondere Konfiguration der Handler im Compiler entfällt. Sind vor Beendigung einer ISR (d.h. Rücksprung zum User Code) weitere Interrupts pending, so werden diese ausgeführt, ohne dass eine komplette pop-push-sequenz der Register notwendig ist. Schön beschrieben ist es hier im [http://www.st.com/mcu/files/mcu/1221142709.pdf Insider's Guide] unter 2.4.5 / Seite 20.
* Thumb-2 Befehlssatz, deutlich schneller als Thumb-1 und ebenso kompakt
* Weniger Pins für Debugging benötigt durch SWD
* Mehr Hardware Breakpoints machen debuggen einfacher
* Software ist einfacher weil die Umschaltung zwischen ARM Mode und Thumb Mode wegfällt

'''Vorteile gegenüber LPC1700 und LPC1300:'''

* Flexiblere Gehäuseformen mit mehr Peripherie bei kleinen Gehäusen
* FW-Lib für alle STM32 gleich, alle AppNotes/Demos beziehen sich auf diese eine FW-Lib was die Entwicklung der eigenen Applikation sehr beschleunigt.
* Genauerer und flexiblerer ADC, insbesondere gegenüber LPC1300
* Flexiblere Varianten der Peripherie >> bei weniger einen deutlichen Preisvorteil
* ab 0,85 EUR (Stand 2010) Allerdings gibts den LPC1100 mit Cortex-M0 schon ab 0,65 $!
'''Nachteil gegenüber LPC1700:'''
* STM32F1xx: nur 72 MHz statt 100 MHz (LPC1759: 120 MHz) Taktfrequenz; STM32F2xx hat diesen Nachteil nicht (ebenfalls 120MHz, STM32F4xx mit 168MHz) (Aber NXP hat schon 150MHz angekündigt)
* Der LPC1700 besitzt deutlich mehr Mechanismen, um die Auswirkung der Waitstates des Flash-ROMs auf Code- und Datenzugriffe zu reduzieren und das bedeutet mehr Performance bei gleicher Taktfrequenz. Beim STM32F2 entfällt dieser Nachteil wohl aufgrund des ART accelerators.
* Alle LPC1xxx haben 32 Bit Timer. Bei den STM32 haben das nur die STM32F2xx (2 Stück)
* I2S Einheit von ST hat keinen FIFO und im 24/32Bit Modus müssen 2x16Bit Halbwörter übertragen werden.
'''Vorteile gegenüber anderen "Kleinen" wie z.B. PIC, Atmel usw.'''
* nahezu gleicher Preis bei Hobby Anwendungen
* 32 Bit ohne Umwege in Assembler rechenbar
* bessere Peripherie
* ... und weitere 1000 Punkte ...

'''Nachteil für Hobby-Anwender'''

* Nicht direkt "Steckbrettauglich", da kein DIL Gehäuse verfügbar. Der ebay-Shop dipmicro führt jedoch sehr günstige Lötadapter für Umsetzung von LQFP48 auf DIP48. QFP64 in 0.5mm Pinabstand und nicht 0.8mm wie AVR

'''

== Hardware-Beschaltung ==

Der STM32 benötigt für den Betrieb nur (Minimalbeschaltung):

* VCC 2..3,3V (je nach Typ)
* AVCC 2..3,3V (sehr wichtig, der STM32 lässt sich ohne diese Spannung nicht programmieren)
* GND
* Reset Pin 100nF nach GND (ein Pull-Up Widerstand von ca. 40k ist intern vorhanden)
* Boot-Pins: Boot0 -> GND | Boot1 -> Egal ---> Mit der Konfiguration wird das Programm aus dem Flash ausgeführt.

ansonsten nur ein paar einzelne Cs 100nF an VCC/GND.

Um Programmieren zu können wird entweder noch die serielle Schnittstelle (Programmieren über den vorprogrammierten Bootloader) oder JTAG oder die SWD Schnittstelle benötigt.

== Programmierung ==

Als Programmieroberfläche kann eine kostenlose Struktur verwendet werden. Es ist für den Einsteiger schwierig herauszufinden welche Open-Source Programme man braucht damit es funktioniert, daher hier eine Zusammenstellung:

* [http://www.eclipse.org Eclipse]
* [http://www.yagarto.de Yagarto Tools] oder [http://www.codesourcery.com/sgpp/lite_edition.html Codesourcery Lite Edition] oder [https://launchpad.net/gcc-arm-embedded Launchpad]
* Programmieradapter OOCD, Turtelizer2 oder andere JTAG Programmieradapter
* Eclipse Plugin "GDB Hardware Debugging" mit [http://www.firefly-power.de/ARM/debugging.html OpenOCD server]
* [http://www.st.com/internet/com/software/ides_mcu.jsp#stm32 ST Liste: IDEs, Toolsets and Debug tools for MCUs]
* [http://netbeans.org/ Netbeans] mit [http://plugins.netbeans.org/plugin/37426/gdbserver GDBserver-Plugin] [http://openocd.sourceforge.net/ OpenOCD] und [https://launchpad.net/gcc-arm-embedded Launchpad]-Toolchain

* Zum Starten eine fertige Zusammenstellung: [http://www.mikrocontroller.net/topic/216554 Eclipse+codesourcery+st-link]

* [http://www.coocox.org/ Coocox Eclipse IDE] kostenlose IDE für STM32F0 / F1 / F4 Hilfreiche Infos gibt es im [http://www.mikrocontroller.net/topic/214719?goto=new#2228482 hier] und [http://www.mikrocontroller.net/topic/214719?goto=new#2229943 hier] Forum

* [http://www.mikrocontroller.net/topic/265600 STM32F4 mit Code::Blocks]

* [http://emide.org/ emIDE] kostenlose IDE die mit dem Segger J-LINK funktioniert.

Sehr nützlich für Linux-Anwender auch diese Seite: [http://fun-tech.se/stm32/index.php STM32/ARM Cortex-M3 HOWTO: Development under Ubuntu.]

===Folgende kommerzielle Umgebungen sind verfügbar===

* [http://www.keil.com/arm/mdk.asp Keil µVision] (Demo max. 32KB Code): Die sehr komfortable µVison IDE ist neben dem ARM Compiler per Menue auch für einen beliebigen GNU-Compiler konfigurierbar. Damit besteht das 32k-Limit nur noch für den integrierten Debugger / Simulator. µVison selbst kann kostenlos mit dem MDK-Evaluationkit heruntergeladen werden.
* [http://www.iar.com/en/Products/IAR-Embedded-Workbench/ IAR-Embedded-Workbench] (Demo max. 32KB Code)
* [http://www.isystem.com/products/itag winIDEAiTag] Keine Code Limitierung, GCC und Testwerkzeug beinhaltet. Läuft mit dem iTag Adapter.
* [http://www.raisonance.com Raisonance Ride7] (GCC Compiler, kostenlose Version auf Debugging von max. 32KB Code limitiert, keine Limitierung beim Complilieren)
* [http://www.atollic.com Atollic] (Lite Version (bis V2.3.0) ohne Code-Limit, auf GCC basierend. Die neueste Version ab V3 hat fast keine Beschränkungen mehr außer jetzt einen Code-Limit von 32kB. Außerdem werden jetzt die meisten ARM Familien unterstützt. )
* [http://www.coocox.org CoIDE] (Kostenlose GCC, Eclipse basierende IDE mit einem Code-Generator Tool)
* [http://www.rowley.co.uk/arm/ Rowley Crossworks] (Demo 30 Tage unbeschränkt, 150$ für nichtkommerzielle Nutzung, auf GCC basierend)
* [http://www.code-red-tech.com Code Red] (GCC basierend)

===Programmieradapter===
* SEGGER [http://www.segger.com J-LINK / J-TRACE] ARM7..11, Cortex-M0..4, Cortex A8..15, als [http://www.segger.com/cms/j-link-edu.html NonComercial] J-LINK-EDU für ca. 60,- zu haben, läuft in µVision, IAR, gdb, Keil, ...
* [https://www.olimex.com/Products/ARM/JTAG/ Olimex] ARM-USB-OCD (ca. 60.-, hat zusätzlich einen Spannungsausgen und einen COM Port)
* Keil [http://www.keil.com/ulinkme/ ULINK-ME], [http://www.keil.com/arm/ulink2/ ULINK2], [http://www.keil.com/arm/ulinkpro/ ULINK pro]
* [http://www.st.com/internet/evalboard/product/219866.jsp ST-LINK], [http://www.st.com/internet/evalboard/product/251168.jsp ST-LINK/V2]
*[http://www.st.com/internet/com/press_release/p3065.jsp STM32xx Discovery] jedes STM32 Discovery board hat einen ST-Link für Programmierung/Debugging per SWD on-board, welcher auch für eigene STM32 Target Hardware benutzt werden kann (ca. 12,- bis 19,-€, je nach Typ).
* [http://www.raisonance.com/~rlink-debugger-programmer__microcontrollers__tool~tool__T018:4cn9ziz4bnx6.html Raisonance RLink]
* [http://www.amontec.com Amontec]
* [http://www.hjtag.com H-JTAG] Personal Edition für ca. 60,- zu haben, läuft mit ADS, SDT, IAR, Vision und RVDS
* [http://www.isystem.com/products/itag iTag] für 50.- bei Amazon zu bestellen, oder als Eigenbau version (offenes Design) läuft mit der freien winIDEAiTag version (siehe oben)

Solch ein STM32FxDISCOVERY Demo-Board ist ideal für den Einstieg, da man kein extra [[JTAG]] Adapter kaufen muss. Das Board [http://www.st.com/internet/evalboard/product/252419.jsp STM32F4DISCOVERY] mit 12..15 EUR ist sehr günstig und hat einen leistungsfähigen STM32F407 Prozessor mit 168MHz und einen ST-LINK/V2 schon drauf. Zusammen mit der [http://www.coocox.org/ Coocox] Entwicklungsumgebung hat man einen günstigen Einstieg in die STM32 Welt.

In der Regel haben diese [[JTAG]] Adapter einen 20-Poligen Stecker, den man direkt auf die Demo-Boards, die auch einen 20-Poligen [[JTAG]]-Anschluss haben, einstecken kann. Die Pinbelegung ist genormt, siehe Artikel [[JTAG]].

Andere [[JTAG]] Adapter wie z.B. der ULink von Keil funktionieren nur mit dem Keil Compiler.

Zu erst sollte man sich die IDE heraus suchen mit der man Arbeiten mag, und dann darin den unterstützten JTAG Adapter.

Aus eigener Erfahrung kann ich den J-LINK von Segger sehr empfehlen, da er mit der meisten Software, auch GCC sehr gut und vor allem schnell (FLASH programmieren) funktioniert und enorm viele Prozessoren (ARM7/9/11, Cortex-M0..M4, Cortex-A8..15, uvm., viele Hersteller) unterstützt.

===Programmieradapter Open-Source===

* [https://www.olimex.com/Products/ARM/JTAG/ARM-JTAG-COOCOX/ ARM-JTAG-COOCOX], CoLinkEX Nachbau von Olimex, unterstützt JTAG sowie SWD
** [http://www.coocox.org/colinkEx.htm unterstützte uC]
** unterstütze IDEs: [http://www.keil.com/arm/mdk.asp Keil MDK-ARM 4.03] oder neuer, [http://www.iar.com/en/Products/IAR-Embedded-Workbench/ IAR Embedded Workbench 5.xx] oder neuer sowie die [http://www.coocox.org/CooCox_CoIDE.htm CooCox CoIDE]
* [http://www.oocdlink.com/ OOCDLink]
* [https://github.com/texane/stlink Stlink]
* [http://www.randomprojects.org/wiki/Floss-JTAG FLOSS-JTAG]
* [http://capitanio.org/mlink/ Linux Demo Code für die Discovery's ST-Link Programmierung]

Der Controller hat auch einen fest eingebauten Boot-Lader. Damit läßt er sich auch über eine gewöhnliche serielle Schnittstelle programmieren, ohne daß man einen JTAG-Adapter benötigt.

Tipps für Installation mit Eclipse können in [http://www.mikrocontroller.net/topic/214719 diesem Thread] gelesen werden.

=== Installation für STM32 (Linux) ===

==== Variante A ====

* Benötigte Hardware
** Ein Desktop PC oder Laptop mit Linux OS (openSuSE, Ubuntu, ...) alternativ: Ein Windows System mit Linux in einer virtuellen Maschine
** root Zugang zum Linux OS (superuser Passwort)
** GNU C Compiler
** Programmer ARM-USB-TINY-H (optimal) alternativ: OpenOCD kompatiblen Programmer
** Prototypboard Olimex STM32-P107 (optimal) alternativ: irgendein board mit STM32 uC und JTAG Port

* Download + Installation (in einem Terminal)
wget http://hlb-labor.de/cortexm3/install_ToolChain_STM32.sh
chmod +x install_ToolChain_STM32.sh
./install_ToolChain_STM32.sh

Die Installation sollte im Idealfall voll automatisch durchlaufen. Anschliessend wird ein Beispielprojekt mit Multitasking OS und LED-Heartbeat kompiliert und auf den uC programmiert.
Für andere Protoboards/ Programmer muss die ToolChain entsprechend der readme Anleitung umkonfiguriert werden.

Das Projekt kann im QtCreator (http://qt.nokia.com/) geöffnet und bearbeitet werden.

==== Variante B ====

Die Installation einer Toolchain (Make, Flash, Debug via JTAG, IDE) ist in folgendem Manual beschrieben:

"How-to manual - Installing a toolchain for Cortex-M3/STM32 on Ubuntu"

*http://www.seng.de/downloads/HowTo_ToolChain_STM32_Ubuntu.pdf
*http://www.seng.de/downloads/HowTo_ToolChain_STM32_Ubuntu.odt

Die Beschreibung im OpenOffice Format erlaubt die Weiterbearbeitung des Textes und das Entnehmen von Quelltexten ohne den Verlust von Formatierungen.

Verwendete Hardware:
*JTAG device
**Olimex “ARM-USB-OCD-H”, basierend auf FTDI “FT2232H”
*Microcontroller
**Olimex “STM32-H103” basierend auf STM32F103RBT6 mit 128KB Flash, 20KB RAM, 3xUART, ...
Die Toolchain sollte sich leicht an andere "FT2232" basierte JTAG Probes und "Cortex-M3" Derivate anpassen lassen.

Das Manual umfasst die Installation und Inbetriebnahme sowie Hinweise und Bug-fixes zu folgenden Komponenten:
*OpenOCD
*Serial bootloader
*Sourcery CodeBench Lite for ARM EABI
*STM32F10x standard peripheral library
*USB full-speed device library
*Project templates
*Makefiles
*Linker Sript
*Startup Code
*Doxygen
*Git
*Terminal emulation
*Eclipse IDE
*Links zu Datenblättern, Manuals und Toools

=== Installation für STM32 Eclipse(Windows) ===

Hier ist der Anfang des Artikels [[STM32 Eclipse Installation]], hier ist neueres beschrieben als hier aufgeführt. Wenn der Artikel fertig ist, dann wird dieser Teil gelöscht.

* Eclipse "Helios" installieren mit GNU ARM Eclipse Plug-in
Eclipse IDE for C/C++ Developers<ref>http://www.eclipse.org/downloads/packages/eclipse-ide-cc-developers/heliosr</ref> downloaden und installieren

* GNU ARM Eclipse Plug-in<ref>http://sourceforge.net/projects/gnuarmeclipse/</ref> runterladen und installieren. [http://sourceforge.net/apps/mediawiki/gnuarmeclipse/index.php?title=Main_Page Weitere Infos].

Wird CodeSourcery G++ Lite verwendet, so muss die PATH Variable angepasst
werden, damit das Plugin die CodeSourcery exe-Files findet<ref>für Discovery notwendig</ref>. Alternativ das eclipse von einem script aus starten und zuerst den PATH erweitern.

Soll das ST-LINK verwendet werden, so kann der Atollic ST-LINK GDBSERVER aus der Atollic free version genutzt werden. Mit dem gdbclient im Eclipse kann damit problemlos geflasht und gedebuggt werden (JTAG und SWD).

Neuere Versionen von OpenOCD können ebenfalls mit STLINK und STLINK2 Kontakt aufnehmen. Bei vorkompilierten OpenOCD-Packeten (z.B. die von Freddy Chopin) mit libusb-Support und installiertem Herstellertreiber von STM ist noch der libusb-Filtertreiber einzurichten (relativ einfach per libusb-win32 filter wizard GUI).

Die Startup- und Linkerscripts der Atollic free version können für ein Projekt in dieser Konstallation genutzt werden.

* Eclipse "Galileo" installation<ref>[http://www.eclipse.org/] → Downloads → "Eclipse IDE for C/C++ Developers (79 MB)</ref>. Und das Servicepack 1<ref>[http://www.eclipse.org/downloads/download.php?file=/technology/epp/downloads/release/galileo/SR1/eclipse-cpp-galileo-SR1-win32.zip Eclipse SR1]</ref>
Entpacken der Datei eclipse-cpp-galileo-SR1-win32.zip nach "C:\WinARM\" (Ordner neu erstellen)

* Eclipse PlugIn<ref>http://download.eclipse.org/tools/cdt/releases/galileo</ref> hinzufügen: Help → Install New Software... → "Eclipse C/C++ Development Tools" + "Eclipse C/C++ GDB Hardware Debugging" installieren

* Yagarto Tools<ref>[http://www.yagarto.de/] "Download (for Windows)" → "YAGARTO Tools" http://www.yagarto.de/download/yagarto/yagarto-tools-20091223-setup.exe Installieren, Auswahl Verzeichnis "C:\WinARM\yagarto-tools"</ref>

* CodeSourcery: Achtung! Die Menustruktur ändert sich durchaus mal, dann suchen gehen. http://www.codesourcery.com/ → Products → Sourcery G++ → Editions>Lite Edition → ARM → Downloads. Direkter Download<ref>[http://www.codesourcery.com/sgpp/lite/arm/portal/package6496/public/arm-none-eabi/arm-2010q1-188-arm-none-eabi.exe]</ref>. Installieren, Auswahl Verzeichnis "C:\WinARM\CodeSourcery"

* OpenOCD: Kompilierte Version für Windows<ref>[http://www.freddiechopin.info/] → Download → Software → OpenOCD</ref> installieren nach "C:\WinARM\OpenOCD_0_4_0" ist auch auf der Seite<ref>[http://yagarto.de/#ocd Yagarto.de]</ref> beschrieben. PS: Sollte der Olimex ARM-USB-OCD verwendet werden, dann darf nicht der Treiber von Olimex verwendet werden, sondern der vom OpenOCD Download<ref>[http://www.mikrocontroller.net/topic/173753#1668913]</ref>.

* ST Firmware: http://www.st.com → Auswahl CPU STM32F103xxx → "Firmware" "STM32F10x_StdPeriph_Lib"<ref>http://www.st.com/mcu/devicedocs-STM32F103RC-110.html</ref>. Das ZIP "stm32f10x_stdperiph_lib.zip" Entpacken nach "C:\WinARM\examples\stm32_FW3.4.0\

=== Installation für STM32 auf einem zweiten Rechner===

* Kopieren des Verzeichnisses C:\WinARM\ (Zuvor wurden aus diesem Grund alle Setup-Pakete nach C:\WinARM\... installiert)
* Die PATH-Variable in der Systemsteuerung mit den C:\WinARM\.... Verzeichnissen nachführen
* Fertig.

=== Installation für STM32 mit AtollicTrueStudio (+Demo) ===
* Installation + Demo: [[STM32 LEDBlinken AtollicTrueStudio]]

=== Installation für STM32 mit MDK-ARM Lite und Einstellungen STM32F0/F4-Discovery Board ===
* [https://www.keil.com/demo/eval/arm.htm KEIL MDK-ARM Download]
* [https://www.youtube.com/watch?v=RXOOxby5nns&list=PL6-W3FoUyb48WFI5PQv3SDJj2G1t2FonV&index=1 Installations Video STM32F4 Discovery Board]
* [https://www.youtube.com/watch?annotation_id=annotation_203294&feature=iv&index=4&list=PL6-W3FoUyb48WFI5PQv3SDJj2G1t2FonV&src_vid=sN4gDZ7H8gw&v=BeZcQjXxk9A Einstellungen STM32F0 Discovery Board Video]

== Demo-Projekte ==

* [[prog_bsp_timer_1_timer2|Programmbeispiel für die Verwendung von Timer2 zusammen mit dem Interrupt]]
* [http://www.firefly-power.de/ARM/printf.html Printf() debugging mit minimalem Aufwand]
* [[STM32_BLDC_Control_with_HALL_Sensor|Programmbeispiel für BLDC Motoransteuerung (Timer 1) mit HALLSensor (Timer 3)]]
* [[Cortex_M3_OCM3U]]
* Martin Thomas hat ein umfangreiches Projekt erstellt, in der die Eclipse Einstellungen enthalten sind:
** [http://www.siwawi.arubi.uni-kl.de/avr_projects/arm_projects/arm_memcards/index.html "ChaN's FAT-Module with STM32 SPI"]
* [[STM32 USB-FS-Device Lib]]
* Modellbau-Sender auf STM32-Basis mit vielen Treibern [http://www.rcos.eu www.rcos.eu]
* Ausführliches [https://github.com/jkerdels/stm32edu Einstiegs-Tutorial] in Codeform für das [http://www.st.com/internet/evalboard/product/252419.jsp STM32F4 discovery board]
* [http://www.redacom.ch/keillab/ Schweizer Gondelbahnsteuerung über Webserver auf ETT STM32F ARM KIT Board in Keil RTOS] mit Webcam
* Die [http://ethernut.svn.sourceforge.net/viewvc/ethernut/trunk/ Ethernut SVN Version] unterstützt inzwischen viele STM32 Typen, viele Devices und einige STM32 Demoboards

== Errata, Tipps und Tricks ==

* AD-Wandler PA0: Im Errata steht, dass hier Fehler in der Wandlung entstehen könnten, also einen anderen Pin verwenden.
* CAN-Bus PD0/PD1: Remap geht erst ab der 100-Pin-Version. Steht im RM0008 unter 9.3.3.: "CAN1 alternate function remapping". Alle Infos von RM0008 9.3.x sind interessant
* CAN und USB sind nur bei der "◦Connectivity-Line" gleichzeitig nutzbar. Siehe Datenblätter.
* Mit internem RC-Oszillator kann die CPU mit maximal 64MHz betrieben werden. Mit einem externen Quarz sind dann 72MHz möglich.
* Für USB Betrieb muss die CPU mit 48MHz oder 72MHz betrieben werden (bei STM32F1xx).
* Der Idle Interrupt vom Usart wird zwar ausgelöst, aber nicht vom entsprechenden Statusflag angezeigt
* Der DMA fängt beim aktivieren immer von vorn an zu zählen, auch wenn er nur kurz angehalten wurde
* STM32F2xx hat kein Flash Size Register, bei STM32F4xx ist zwar ein flash Size Register beschrieben, kollidiert aber in der Adresse mit einem anderen Register
* Derivate mit internem EEPROM und nur einer Speicherbank haben das "Feature" bei write/erase des Data-Flashes (EEPROM) einen kompletten stall der code execution zu verursachen (inkl. ISR's, DMA). Desgleichen bei write/erase des internen Flash (ISP-routinen, EEPROM-Emulation).
* Der I2C hat diverse Fehler, welche im Errata des jeweiligen Modells (z.B. [http://www.st.com/internet/com/TECHNICAL_RESOURCES/TECHNICAL_LITERATURE/ERRATA_SHEET/CD00238166.pdf STM32F105xx and STM32F107xx Errata sheet] ) zu finden sind. Workarounds hierzu finden sich in der Application Note [http://www.st.com/internet/com/TECHNICAL_RESOURCES/TECHNICAL_LITERATURE/APPLICATION_NOTE/CD00209826.pdf AN2824]
* [http://blog.frankvh.com/category/stm32/ weitere undokummentierte Features]

=== Tipps für Umsteiger von Atmel/PIC/8051 ===
* Prozessortakt hat unterschiedliche Taktquellen und eine PLL.
* Alle Peripheriemodule haben einen extra Clock, den man aktivieren muss.
* Wenn man z.B. einen UART benutzen möchte, so muss man den Clock vom UART, Alternate Function IO (AFIO) und dem GPIO-Port aktivieren.
* Ansonsten hat man nahezu doppelt so viele Möglichkeiten in den Peripheriemodulen.
* Interrupt-Flags müssen in der ISR selber gelöscht werden
* Forum zu [http://www.mikrocontroller.net/topic/175888 Interrupts vs. Events]

=== Tipp FPU von STM32F4xx nutzen ===
Es benötigt dafür 2 Dinge, zum einen muss die Compileroption gesetzt sein, zum anderen auch die FPU aktiviert werden:

Compileroption:

<code>COMMON_FLAGS += -mfloat-abi=hard -mfpu=fpv4-sp-d16</code>

Der Code für das Aktivieren der FPU:

<c>/*FPU settings*/
__asm volatile ("ldr r0, =0xE000ED88"); /* Enable CP10,CP11 */
__asm volatile ("ldr r1,[r0]");
__asm volatile ("orr r1,r1,#(0xF << 20)");
__asm volatile ("str r1,[r0]");
</c>

Ohne Inline-Assembler in C wie in system_stm32f4xx.c aus den Beispielen von ST-Microelectronics:
<c>
SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2)); /* set CP10 and CP11 Full Access */
</c>

Weiterhin sollte die Toolchain auch Laufzeitbibliotheken mit FPU-Unterstützung mitbringen (CodeBench lite wird ohne ausgeleifert, GCC for ARM embedded von launchpad.org mit).

Mehr dazu in diesem Thread: [http://www.mikrocontroller.net/topic/261021 Floating Pointing Unit STM32F4]

=== Errata vom STM32F4xx die nicht im Errata von ST stehen ===
* [http://www.mikrocontroller.net/topic/267439#2788478 Aktivieren von DMA], wenn mehr als 3 DMA Kanäle aktiviert werden, kann es sein dass die nicht alle korrekt bedient werden. Auch klappt der DMA mit dem FSMC nicht immer zuverlässig. [https://my.st.com/public/STe2ecommunities/mcu/Lists/cortex_mx_stm32/Flat.aspx?RootFolder=%2Fpublic%2FSTe2ecommunities%2Fmcu%2FLists%2Fcortex_mx_stm32%2FWarning%20limit%20simultaneous%20DMAs%20to%202&FolderCTID=0x01200200770978C69A1141439FE559EB459D7580009C4E14902C3CDE46A77F0FFD06506F5B&currentviews=811 siehe hier] [http://blog.frankvh.com/2012/01/13/stm32f2xx-stm32f4xx-dma-maximum-transactions/ und hier]
* [http://www.mikrocontroller.net/topic/260637#2700761 Nerviger Bug in "stm32f4xx.h"] Änderung Struktur GPIO_TypeDef
* [http://www.mikrocontroller.net/topic/261690#2714754 Batterie wird leer gezogen], nur bei manchen Chips mit Rev. A

== Bezugsquellen ==

=== Controller ===

Versandhäuser für Privatpersonen
* [http://www.reichelt.de/STM-Controller/2/index.html?;ACTION=2;LA=2;GROUPID=2950; Reichelt]
* [http://darisusgmbh.de/shop/index.php?cat=c2692_ARM-Cortex.html Darisus]
* [http://www.hbe-shop.de HBE (Farnell Programm für Private)]
* [http://www.sander-electronic.de/be00069.html Sander]
*[http://www.tme.eu/de/katalog/index.phtml#cleanParameters%3D1%26search%3DSTM32F10%26bf_szukaj%3D+ TME]
*[http://teske-electronics.de/index.php?cPath=3_9_53 Teske electronics]

Gewerblich liefern natürlich viele wie EBV, Mouser, Farnell, Digikey usw...

=== Evaluation Boards ===

* [http://shop.embedded-projects.net/index.php?module=artikel&action=gruppe&id=14 Im Shop von Embedded Projects]
* [http://www.watterott.com/de/Boards-Kits/ARM/ARM-Cortex-M3 Cortex M3 bei Watterott]
* [http://www.raisonance.com/~primer-starter-kits__microcontrollers__tool~tool__T018:4enfvamuxbtp.html Primer und Primer2 von Raisonance]
* [http://www.sander-electronic.de/es0028.html Sander Electronic]
* [http://www.mikrocontroller.net/articles/MP32F103-Stick:_Ein_Mini-Mikrocontroller-Board_mit_USB_und_bis_zu_4MB_Datenspeicher Artikel im Wiki, ARM mit USB und 4MB Speicher]
* [http://www.futurlec.com/STM32_Development_Board.shtml Futurlec Evalboard, ebenso Header-Board]
* [http://www.propox.com/products/t_174.html Propox, Header-Boards für 103R und 103V sowie Trägerplatine dafür]
* [http://www.mikrocontroller.net/articles/Cortex_M3_OCM3U Cortex M3 Artikel im Wiki]
* [http://olimex.com/dev/index.html STM32 bei Olimex]
* [http://de.farnell.com/jsp/displayProduct.jsp?sku=1824325&action=view&CMP=GRHS-1000962 STM32Discovery bei Farnell] Mikrocontroller Board (STM32F100RBT6B) mit onboard USB-Programming Interface für ca. 12,50€
* [http://www.de.rs-online.com/web/p/products/7458434/ STM32Discovery bei RS-Components] 12,65 € +MwSt.
* [http://www.segor.de/#Q=STM32 VL DISCOVERY] STM32 Discovery bei Segor
* [http://www.watterott.com/de/STM32F4Discovery STM32F4DISCOVERY] STM32F4 Cortex M4 Controller mit JTAG-Debugger auf der Platine bei Watterott für 16,66EUR.
* [http://www.steitec.net/ARM-Boards/ Steitec, STM32F103 Cortex M3 Board 34,80€]
* [http://www.mcu-raisonance.com/~open4-development-platform__microcontrollers__tool~tool__T018:g65gu6ghg2n.html/ Open 4 oder auch genannt Evo-Primer]
* [http://www.wayengineer.com/index.php?main_page=index&cPath=50_66&page=1&sort=3a WayEngineer]
* [http://thinkembedded.ch/ST-STMicroelectronics:::24.html Im Thinkembedded Shop] in der Schweiz / DiscoveryF4, div. ETT und Olimex Boarde ab 20,18 CHF / 16,15 EUR (inkl. MwSt.) zzgl. Versandkosten
* [http://shop.myavr.de/ARM-Produktlinie/STM32F4-Discovery.htm?sp=article.sp.php&artID=200072 Im myAVR Shop] DiscoveryF4 mit möglichem Zubehör 16,45 EUR (inkl. MwSt.) zzgl. Versandkosten
* [http://www.keil.com Keil Microcontollertechnik]
* [http://www.phytec.de Phytec]

== Weblinks, Foren, Communities, Tutorials ==

* [http://www.mikrocontroller.net/topic/173753 Diskussion zum Artikel]
* [http://www.mikrocontroller.net/forum/mikrocontroller-elektronik?filter=ARM*+STM32*+Cortex* Suche im Forum]
* [https://my.st.com/public/STe2ecommunities/mcu/Lists/ARM%20CortexM3%20STM32/AllItems.aspx Forum auf der ST Homepage]
* [http://www.stm32circle.com/hom/index.php STM32 Community]
*[http://joe-c.de/pages/posts/einstieg_mikrocontroller_stm32f103_101.php Einstieg: STM32board mit Kamera (deutsch)]
* [http://www.ebv.com/fileadmin/products/Press_Print/Brochures/Product_Brochures/EBV_Cortex%20Collection_V2.pdf Übersicht der Cortex Prozessoren und deren Hersteller (nicht nur ST, von EBV)]
* [http://www.mikrocontroller.net/topic/258652 Tutorial]
* [http://diller-technologies.de/stm32_wide.html STM32 Tutorial in Deutsch von Diller Technologies]
* [http://mySTM32.de STM32 C und C++ Tutorial in Deutsch ]

<references/>
[[Kategorie:ARM]]
[[Kategorie:STM32| ]]

Benutzer:Mixer

2011-03-19T12:44:23Z

Mixer: /* Interessen */

RFM12

2011-03-14T20:51:41Z

Mixer: /* SPI Interface */ Datenrate in MHz??

Beschreibung der Funkmodule RFM01, RFM02 und RFM12.

Benötigt werden in der Minimal-Version im FIFO-Modus nur die Anschlüsse nSEL, SDO, SDI und SCK, eben das komplette SPI-Interface. Der Zugriff auf das Sende- und Empfangs-FIFO ist per Software möglich, ebenso die Abfrage der Statusbits. Deshalb werden z. B. nIRQ und nFFS nicht unbedingt benötigt. nIRQ signalisiert unter anderem, dass das Modul bereit ist Daten zu empfangen. Wenn Daten empfangen wurden, kann dies über den FFIT-Pin abgefragt werden (falls die Füllschwelle eingestellt wurde). nFFS dient dazu das FIFO direkt anzusprechen (es ist quasi der Chipselect für das FIFO), davon wird in der Minimalversion aber kein Gebrauch gemacht. Der Pin muss daher auf high-Pegel gelegt werden!
An CLK kann eine Frequenz von 1MHz bis 10MHz eingestellt werden. Hiermit kann dann z. B. der Mikrocontroller versorgt werden.
Reset ist ein Open-Collector-Ausgang und gleichzeitig der Reset-Eingang. Er sollte daher entweder gar nicht, oder aber hochohmig angeschlossen werden.

Im FIFO-Mode kann das Modul konfiguriert werden mit dem Empfang zu warten, bis die Daten 0x2DD4 empfangen wurden. Sobald dieses Bitmuster empfangen wurde, werden Daten in das FIFO geschrieben, bis man das FIFO abschaltet und die Mustererkennung neu startet.

Als weitere Modi stehen unter anderem ein synchroner Modus zur Verfügung (no FIFO mode), in dem der Sender/Empfänger den Bittakt ausgibt, und synchron dazu die zu sendenden Daten einliest bzw. die empfangenen Daten ausgibt. Der SPI Bus ist trotzdem zur Initialisierung des Moduls notwendig.

== FAQ ==

=== Soll ich 433 oder 868 MHz nehmen? ===

Wähle das für deine Anwendung kleinere der beiden Übel: Bei 433 MHz sind i.d.R. mehr Störer unterwegs und bei 868 MHz sind die maximale Belegungsdauer bzw. das listen-before-talk (LBT) Verfahren gemäß [[Allgemeinzuteilung]] zu beachten. Siehe auch im Forum [http://www.mikrocontroller.net/topic/198559] und [http://www.mikrocontroller.net/topic/196693].

=== SPI Interface ===

* Maximale SPI Frequenz: 2,5MHz (10MHz Quarz / 4)

=== CLK-Ausgang bleibt bei 1 MHz ===

* Vor dem Umschalten (mit 0xC0E0) länger warten.

=== RFM12 empfängt ein paar Bytes, dann nur Müll ===

* Es wird zu langsam gesendet (TX FIFO underrun)
* Es wird zu langsam empfangen (RX FIFO overrun)

Die Status-Bits helfen hier beim Debuggen. SPI sollte auf maximaler Transferrate stehen.

=== RFM empfängt nur Müll ===

http://www.mikrocontroller.net/topic/73560#605528

Deine Module verhalten sich normal. Man muß mit den Gain- und AFC-Bits
eine ganze Weile spielen, bis die Module korrekt laufen (kommt auf die
Anwendung an). Fakt ist: der Empfänger empfängt ständig Datenmüll als
Rauschen. Wenn der FIFO durch die Präambel getriggert wird, sind die
Daten im FIFO ziemlich korrekt, wenn alles "gut" eingestellt ist. Der
FIFO sollte per Interrupt dann auch sofort abgeholt werden, da sonst das
nächste Byte das alte direkt überschreibt. Jeder zusammenhängende
Datensatz (mehrere Bytes an einem Stück) muß von einer Präambel
eingeleitet werden. Nach dem kompletten Einlesen eines Datensatzes muß
der FIFO abgeschaltet, wieder eingeschaltet und für den Empfang der
nächsten Präambel neu scharf gemacht werden.

=== RFM hängt sich auf ===

Wenn man die AFC nicht begrenzt, also keinen Wertebereich vorgibt, die eine maximale Abweichung korrigiert wird passiert es nach einer Weile, dass sich der Empfänger aufhängt, die Offsetbits im Status werden maximal und dann geht gar nichts mehr, er hängt fest.

edit: Leider bringt die Beschränkung der AFC auf Minimum bei mir keine Verbesserung. Zumindest ist obige Aussage nicht allgemein gültig.

Siehe auch
* Forenbeitrag [http://www.mikrocontroller.net/topic/82456#689660 RFM12: Erfahrungen ]

=== Kommunikation mit RFM funktioniert nur sporadisch ===

* Ist die Versorgungsspannung stabil? (evtl. Kondensator einbauen)

=== Interrupt nIRQ klappt nicht bei 868MHz ===

Wenn bei der Verwendung der 868er Module die üblichen Sourcen (dasLabor, etc) verwendet werden, müssen einige Änderungen gemacht werden, die sich leicht finden lassen. Ohne weiteres funktionierte der blockierende Empfang, der Interruptbetriebene (nIRQ) machte in mindestens einem Fall Probleme. Hier half die Anpassung des FIFO IT Level . In vorhandenen Sourcen ist 0xCA83 zu finden, eine Änderung auf 0xCAF3 hilft dabei.

----

== Register ==

Von https://www.mikrocontroller.net/attachment/24947/RFM12.txt

Dieses Dokument beschreibt die Nutzung des RFM12 TRX Moduls!

''' WICHTIG '''

Dieses Dokument wurde aus mehreren Quellen zusammengestellt, und kann Fehler enthalten!
Es können Abweichungen in Bezug auf RF01 / RF02 / RF12 / RFM01 / RFM02 und andere Module auftreten!
Es wurde das Datenblatt vom RFM12B und RF12 von www.hoperf.com als Basis genuzt. Zusätzlich wurden diese Informationen mit Hilfe von Forums-Nutzern (https://www.mikrocontroller.net/topic/71682) weiter vervollständigt!

''' WICHTIG '''

'''Hinweis:''' Die LNA-Eingangsimpedanz beträgt 250 Ohm, und muss beim Anschluss einer 50-Ohm-Antenne entsprechend angepasst werden, um das Rauschen zu minimieren! '' -- (Auf den Pollin-Modulen bereits vorhanden)''

=== Configuration Setting ===
Hex = 80 & xx
Bit-Syntax:
{| cellpadding="2" cellspacing="0" border="1"
!width="20%"| Byte ||width="40%"| 1 || 2
|-
!Bits
|{{8Bit|width=100%| 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 }}||{{8Bit|width=100%| el | ef | b1 | b0 | x3 | x2 | x1 | x0}}|}
el (TX FIFO) = Sendepuffer für Datentransfer nutzen (1 = An / 0 = Aus)
ef (RX FIFO) = Empfangspuffer für Datenspeicherung nutzen (1 = An / 0 = Aus)
b... = Zu nutzende Basisfrequenz (00=315MHz / 01=433MHz / 10=868MHz / 11=915MHz)
x... = Interner Clock des Chips kann durch verschieben einer Kondensator-Anpass-Stufe bestimmt werden.
0,5pF pro Schritt. Basis ist 8,5pF -> (0000=8,5 / 0001=9,0 / 0010=9,5 / ...)

=== Power-Management ===
Hex = 82 & xx
Bit-Syntax: 10000010 | er | ebb | et | es | ex | eb | ew | dc
er = Empfänger einschalten (1 = an / 0 = Aus)
ebb = ... (Synthesizer muss aktiv sein!) (1 = an / 0 = aus)
et = Sender einschalten (1 = an / 0 = Aus) (Wenn das TX-Register aktiv und mit Daten gefüllt ist/wurde,
werden diese Daten sofort gesendet) (1 = an / 0 = aus)
es = Schaltet den Synthesizer ein. (1 = an / 0 = aus)
ex = Schaltet den Quarz-Oszilator ein. (1 = an / 0 = aus)
eb = Vergleichbar mit BrownOutDetection -> Erkennt eine zu geringe Betriebsspannung und erzeugt einen Interrupt,
um einen drohenden Spannungsaufall anzukündigen (1 = An / 0 = Aus)
ew = Aktiviert den WakeUpTimer des Prozessors. (1 = an / 0 = aus)
dc = Deaktiviert die Ausgabe des SystemClocks auf dem CLK Pin am Chip (1 = Keine ClockAusgabe / 0 = Clock ausgeben)

=== PLL Setting ===
Hex = 198 + y
Bit-Syntax: 110011000 | ob1 | ob0 | lpx | ddy | ddit | bw1 | bw0
ob... = ... (00= 5 oder 10MHz [standard] / 01=3.3MHz / 1x=2.5MHz oder weniger)
lpx = Wählt den Low-Power-Mode für den Quarz-Oszilator aus. (0=1ms [620µA] / 1=2ms [460µA])
ddy = ...
ddi = Schaltet das Dithering in PLL-Schleife ab. (1=abgeschaltet / 0=eingeschaltet)
bw... = Wählt die Bandbreite des PLL-Signals aus. (00=86.2kbps [-107dBc/Hz] / 01=256kbps [-102dBc/Hz]) Bei 1MHz Offset Phasenrauschen.

=== LowBatt / µC Clock Control ===
Hex = c0 & xx
Bit-Syntax: 11000000 | d2 | d1 | d0 | v4 | v3 | v2 | v1 | v0
d... = Bestimmt den Teilungsfaktor für die Clockausgabe am CLK-Pin in Abhängigkeit des Internen SystemTakts.
(000=1 / 001=1.25 / 010=1.66 / 011=2 / 100=2.5 / 101=3.33 / 110=5 / 111=10)
v... = Bestimmt die Minimalspannung, ab der ein Interrupt durchgeführt werden
muss. (Ähnlich einer BrownOutDetection). Im Power-Managment muss das eb-Bit
aktiv sein, damit dies funktioniert.

=== Frequency-setting ===
Bestimmt den Offset der Sende- und Empfangsfrequenz. Dieser Offset wird auf das Basisband im Configuration Setting hinzu gerechnet.
Hex = a & xxx
Bit-Syntax:
{| cellpadding="2" cellspacing="0" border="1"
!width="20%"| Byte ||width="40%"| 1 || 2
|-
!Bits
|{{8Bit|width=100%| 1 | 0 | 1 | 0 | f11 | f10 | f9 | f8 }}||{{8Bit|width=100%| f7 | f6 | f5 | f4 | f3 | f2 | f1 | f0}}|}

f... = Bestimmt den Offsetwert der Frequenz.
Als Basis gilt das eingestellte Band im Configuration-Settings-Kommando

freq = 10 * C1 * (C2 + f/4000) [MHz]

{| cellspacing="0" border="1" style="text-align:center;"
! Band || C1 || C2
|-
| 315 || 1 || 31
|-
| 433 || 1 || 43
|-
| 868 || 2 || 43
|-
| 915 || 3 || 30
|}

=== Data-Rate ===
Hex = c6 & xx
Bit-Syntax: 11000110 | cs | r6 | r5 | r4 | r3 | r2 | r1 | r0
cs = Vorteiler, Faktor 8. Hiermit kann ein Vorteiler aktiviert werden,
der die errechnete Baudrate (r...) durch 8 teilt.
r... = Baudratenteilerfaktor

=== RX Control ===
Hex = 94 & xx
Bit-Syntax: 10010 | p20 | d1 | d2 | i2 | i1 | i0 | g1 | g0 | r2 | r1 | r0
p20 = Bestimmt die Funktion des Pin20 (nINT / VDI) am RFM12 Chip (1 = VDI-Ausgang / 0 = Interrupt-Eingang)
d... = (Valid Data Indicator). Definiert die Geschwindigkeit, mit der bestimmt wird, ob ein Signal korrekt ist, oder nicht.
(00=schnell / 01=mittel / 10=langsam / 11=immer an). Je nach eingestellter Variante werden
unterschiedliche Hardware- und Software-Kombinationen genuzt.
Fast: CR_Lock OR DQD ... Medium: CR_Lock AND ( DRSSI OR DQD ) ...
SLOW: R/S FlipFlop aus (SET) DRSSI OR DQD OR CR_Lock und (CLR) DRSSI AND DQD AND CR_Lock .
i... = Bestimmt die Bandbreite des Empfängers in KHz (KiloHertz).
(000=Reserviert / 001=400 / 010=340 / 011=270 / 100=200 / 101=134 / 110=67 / 111=Reserviert)
g... = (LNA-Gain) Verstärkungsfaktor des Rauscharmen-Eingangs-Signal-Verstärkers (LNA Low Noise Amplifier).
Werte in dBm (Dezibel [Grösse: Milliwatt]) Mögliche Werte sind: 0 / -6 / -14 / -20
r... = (DRSSI = Digital Received Signal Strength Indication) Minimale Empfangssignalfeldstärke.
6 dBm pro Schritt: (000=-103 / 001=-97 / 010=-91 / ...)

=== Synchron Pattern ===
Hex = ce & xx
Bit-Syntax: 11001110 | b7 | b6 | b5 | b4 | b3 | b2 | b1 | b0
b... = Legt den Wert fest, der als Synchronisations-Byte für die Datenfilterung verwendet werden soll.

=== Data Filter ===
Hex = c2 & xx
Bit-Syntax: 11000010 | al | ml | -unknow- (1) | s | -unknow- (1) | f2 | f1 | f0
al = Baudratenregenerator schaltet automatisch in den langsamen Modus,
sobald er einen Takt erkannt hat.
ml = schneller/langsamer Modus
-unknown- (1) = ??? (Standard = 1) (Auch im Datenblatt von IA4420 so beschrieben)
s = (DataFilter) Typ des Datenfilters (0=DigitalFilter / 1=AnalogFilter).
Bei Nutzung des Analog-Filters kann kein FIFO sowie kein ClockRecovery genuzt werden.
-unknown- (1) = ??? (Standard = 1) (Auch im Datenblatt von IA4420 so beschrieben)
f... = (DQD Threshold) Bestimmt den Schwellwert, ab dem ein Signal als gut empfunden wird,
und der Empfänger dieses weiterverarbeiten soll.
DQD (data quality detection) zählt die "Spikes" des ungefilterten Signals, und bestimmt darüber die Qualität der Daten.

=== FIFO und RESET-Mode ===
Hex = ca & xx
Bit-Syntax: 11001010 | f3 | f2 | f1 | f0 | sp | al | ff | dr
f... = (FIFO interrupt Level)
sp = (Sync-Pattern length) Legt die Länge des Synchron-Patterns fest
(0 = 2Byte / 1 = 1Byte)
al = (FIFO Fill Condition) Legt den Wert fest, ab dem das Füllen des FIFOs beginnt.
(0=Synchron / 1=Ständig). Bei Nutzung des Synchron-Modus, werden erst dann Daten in den FIFO geschrieben,
wenn eine definierte 8-Bit od. 16-Bit lange Datenfolge empfangen wurde (Standard ist Hex: 2dd4,
das LSB kann geändert werden und stellt das 8-Bit Synchron-Pattern dar).
ff = (FIFO Fill) Startet das Einlesen der empfangenen Daten in den FIFO-Puffer.
Wenn al (FIFO Fill Condition) auf synchron steht, dann startet das Setzen dieses Bits die Synchronisation-Bit-Erkennung.
dr = (Sens Reset Mode) Wenn dieses Bit auf 0 steht, wird bei einer Schwankung von 200mV auf
der VCC-Leitung (Spannungsversorgung des Chips), ein System-Reset ausgelöst.

=== Automatic Frequency Control ===
Hex = c4 & xx
Bit-Syntax: 11000100 | a1 | a0 | rl1 | rl0 | st | fi | oe | en
a... = Modus der AFC-Schaltung, 0=Auto off, 1=einmalig nach Einschalten, 2=Solange VDI low ist, 3=unabhängig von VDI
r... = (Range Limit) Frequenzraster (00=KeineBegrenzung / 01=+15 > -16 / 10=+7 > -8 / 11=+3 > -4)
st = Berechneten Offset-Wert übernehmen
fi = Genauer Berechnungsmodus (besser aber lansgamer)
oe = AFC-Offset freischalten
en = AFC-Berechnung aktivieren

=== TX Configuration Control ===
Hex = 98 & xx
Bit-Syntax: 1001100 | mp | m3 | m2 | m1 | m0 | -unknow- (0) | p2 | p1 | p0
mp = (Modulation Polarity) Bestimmt die Richtung der FSK-Erzeugung (invertiert das Spektrum).
m... = (fDeviation) Bestimmt den Frequenzabstand des High- und Low-Wertes bei der Ubertragung im FSK-Betrieb. Basis ist der mp-Wert.
-unknown- (0) = ??? (Standard = 0) (Auch im Datenblatt von IA4420 so beschrieben)
p... = Bestimmt die relative Ausgangsleistung des Senders anhand des dBm-Wertes (Dezibel [Grösse: Milliwat]) 3-dBm-Schritte.
(000=0 / 001=-3 / 010=-6 / ...). Der Wert steht im Zusammenhang mit der angeschlossenen Antennen-Impedanz.

=== Wake-Up Timer ===
Bestimmt die Zeitperiode der zyklischen Einschaltung des WakeUp-Timers
Hex = e & xxx
Bit-Syntax: 111 | R4 | R3 | R2 | R1 | R0 | M7 | M6 | M5 | M4 | M3 | M2 | M1 | M0
R = Exponent der Zeit
M = Zeit

=== Low Duty-Cycle ===

Bestimmt die maximale Sendezeit pro Stunde. Dies ist wichtig, um sich an gesetzliche Frequenzzuteilungsrichtlinien zu halten, die bestimmen, wie lang jemand mit einer definierten Sendeleistung auf einer bestimmten Frequenz (mit eventuell definierter Betriebsart [Modulationstyp]) senden darf.)

hex = 6400 + Bits
Bit-Syntax: 11001000 | d6 | d5 | d4 | d3 | d2 | d1 | d0 | en
d... = Einschaltdauer während der zyklischen Einschaltung
en = zyklische Einschaltung aktivieren

=== RX FIFO Read ===
Hex = b000
Bit-Syntax: 1011000000000000

Dieses Kommando löst die Rückgabe eines Datenbytes (synchron mit dem 8. Bit) aus. Es ist nötig, dass das ef-Bit (RX-FIFO) im Configuration Setting gesetzt wurde, um diese Funktion nutzen zu können!

=== TX Register Write ===
Dieses Kommando schreibt Daten in den TX-Puffer. Wenn der Sender aktiv ist, wird dieses sofort gesendet. el (TX-Register) muss im Configuration-Setting-Kommando aktiv sein.
Hex = b8 & xx
Bit-Syntax: 10111000 | DataByteToSend
DataByteToSend = Das Datenbyte, welches gesendet werden soll.

(Senden Funktioniert nur wenn zuvor der Status abgefragt wurde)

=== Status Read ===
Dieses Kommando löst die Rückgabe des Statusregisters aus, welches nach der ersten 0 im ersten Bit synchron übertragen wird.
Hex = 0000
Bit-Syntax: 0000000000000000<000>
Rückgabe-Syntax: x0 | x1 | x2 | x3 | x4 | x5 | x6 | x7 | x8 | x9 | x10 | x11 | x12 | x13 | x14 | x15 | x16 | x17 | x18
x0 -> x5 = Interrupt bits
x6 -> x15 = Status Bits
x16 -> x18 = FIFO
x0 = FFIT / RGIT (RGIT = TX-Register ist bereit neue Daten zu senden ... kann mit dem TX-Register gelöscht werden)
(FFIT = Die Anzahl der Datenbits im FIFO-Puffer hat das eingestellte Limit erreicht.
Kann mit einer der FIFO-Lesemethoden gelöscht werden)
x1 = POR (PowerOnReset)
x2 = FFOV / RGUR (RGUR = Der Datenstrom beim Senden ist abgerissen, da nicht schnell genug Daten nachgeladen wurden)
(FFOV = Der RX-FIFO ist übergelaufen)
x3 = WKUP
x4 = EXT (Externer IRq vom nINT-Pin)
x5 = LBD (Low Battery Detected)
x6 = FFEM (Der FIFO-Puffer ist leer/EMpty)
x7 = RSSI/ATS (ATS = )(RSSI = Die Signalstärke ist über dem eingestelltem Limit)
x8 = DQD
x9 = CRL
x10 = ATGL
x11 = OFFS_6 (sign of offset)
x12 = OFFS_3
x13 = OFFS_2
x14 = OFFS_1
x15 = OFFS_0
x16 = FO
x17 = FO+1
x18 = FO+2

== Einstellungen für maximale Reichweite ==

Für eine maximale Reichweite eignen sich folgende Einstellungen:
* Bitrate: 2k - 10kbit/s.
* Receiver Baseband Bandwidth: 134kHz
* RSSI Threshold: -97dBm
* LNA gain: 0dB. Falls in der Gegend Störer im gleichen Frequenzbereich sind, dann -6dB, ansonsten kann die Eingangsstufe übersteuern.
* FSK frequency deviation: +/-90kHz
* Output Power: 0dB

Und vor allem: Eine gute (Richt-) Antenne.

== Quarzfrequenz ändern==
Im Datenblatt wird die Verwendung eines 10 MHz-Quarzes empfohlen. Man darf die Frequenz aber nach oben und unten variieren, wie Messungen mit einem DDS-Generators anstelle des Quarzes zeigen: [[Media:PLL-Rastbereich_log.pdf|PLL-Einrast-Tabelle]]. Eine [[Media:RFM12Quarz.pdf|Tabelle: Quarzfrequenzen von 8,5-11 MHz]] zeigt die damit erreichbaren Frequenzen. Quarze für 3. oder auch 5.Oberton sollten auch auf ihrer Grundfrequenz verwendbar sein, dafür bieten sich u.a. CB-Funk- und 10m-Amateurbandquarze an.

Den Einfluß der vier unteren Bits im Configuration Setting Register und des mp-Bits (Modulations-Polarität?) auf die PLL-Frequenz zeigt diese [[Media:Varicap_RFM12.pdf|Kapazitäts-Tabelle]]. Pro Stufe sind es hier etwa 4 kHz, das kann je nach Quarz schwanken. Möglicherweise ist so auch Schmalband-FSK möglich, ohne Änderung des PLL-Teilers.

Was können wir damit anfangen? Neben dem regulären Einsatz auf den beiden zugelassenen Bändern 433 und 868 MHz sind das unter anderem (bitte weitere Ideen einfügen):

* Packet-Radio mit 9600 Baud im 70cm-Amateurband 430-440 MHz. Die einfachste Möglichkeit ist das Programm [http://www.baycom.org/~tom/ham/soundmodem/ Soundmodem], das für Windows und Linux existiert. Wer es komfortabler haben will findet [http://www.dj4uf.de/funktechnik/soundmodem/soundmodem.htm hier] eine Beschreibung wie Soundmodem mit den Programmen [http://www.flexnet.info/ Flexnet] und [http://www.paxon.de Paxon] zusammenarbeitet. Eine Karte der Packet-Radio-Digipeater im 70cm-Band kann man mittels [http://www.hammap.de Hammap] erstellen. Leider werden die Daten in den letzten Jahren nicht mehr sehr gepflegt, es dürften einige Karteileichen enthalten sein.

* Empfang der [http://www.adacom.org/projekte/funkruf/ POCSAG-Funkrufsender] am oberen Ende des Amateurbandes auf 439,9875 MHz 2-FSK mit 4kHz Hub und 1200 bit/s im POCSAG Radio Paging Code 1 [http://home.arcor.de/norbert_n/samsfaq/sams.txt (Liste der Sender, Stand 18.09.07)]. Zur Decodierung existieren mehrere Programme, aufbauend auf [http://www.baycom.org/~tom/ham/linux/multimon.html Multimon] die Weiterentwicklungen [http://www.monitor.mgrohmann.de/ Monitor] und [http://monitord.de/ MonitorD]. Im Prinzip könnte man damit auch die verschlüsselten Wettermeldungen auf 466,23 MHz mitschreiben, aber nicht decodieren.

* Empfang der [http://www.darc.de/vus/digital.html D-Star-Relais]. Das ist eine patentierte digitale Sprach- und Datenübertragung, deren Eigentümer dafür sorgt, dass kein käufliches oder Selbstbaufunkgerät ohne den "AMBE"-Modemchip D-Star senden und empfangen darf. Es gibt eine kleine Ausnahme, das [http://www.darc.de/vus/down/dstar_decode_v02a.zip Programm r00t's D-Star Decoder V0.2a] für die Soundkarte, das nur Rufzeichen und Datentelegramme der beteiligten Funkamateure darstellt.

* Panoramaempfänger (die Bezeichnung Spektrumanalysator wäre etwas übertrieben) unter Verwendung des analogen RSSI Ausgangs (Anschluß am Kondensator in der Ecke). Damit ließe sich z. B. auch die Bandbelegung im PMR-Bereich 446,0-446,2 MHz oder im Mobilfunkband um 900 MHz anzeigen.

* Pegelanzeige für Mobilfunksender. Im 900 MHz Mobilfunkbereich könnte man mit dem RSSI-Ausgang die umliegenden Funkmasten anpeilen und ihre Pegel anzeigen. Laut Datenblatt nur ein Anzeigeumfang von 35 dB, aber mit umschaltbarem Grundpegel.

* In Verbindung mit einem Frequenzumsetzer lassen sich weitere Frequenzbereiche erschließen, z. B. Packet-Radio im 23cm- (1240-1200 MHz) und 13cm- (2320-2450 MHz) Amateurband. Leider liegt die Zwischenfrequenz der Satellitentuner (479,5 MHz) schon am oberen Ende des PLL-VCO-Einrastbereiches. Damit wäre ein preiswerter Konverter für 23cm möglich, meistens schon mit I2C-Bus PLL.

* Local Oscillator für einen Empfänger. Mir den ca. 5 Milliwatt des RFM12 läßt sich ein [http://www.mini-circuits.com/products/fm_sm_main.html passiver Diodenringmischer] ansteuern. Damit kann man einen Überlagerungsempfänger oder -sender mit hoher erster Zwischenfrequenz bauen.

== Antennen-Anpaßnetzwerk==
[[Image:Antennenanpassung.png|thumb|right|400px|Antennen-Anpassnetzwerk im Datenblatt]]
Soll das RFM12 auf anderen Frequenzen betrieben werden, ist nur eine Änderung des Antennennetzwerks nötig. Das Datenblatt bietet knappe aber ausreichende Informationen. 

Zwischen Pin 12 und 13 liegt eine Spannungsquelle, die ihre maximale Sendeleistung in eine komplexe Last nach der Tabelle "Note4" abgibt. Das bedeutet, ihr Innenwiderstand ist konjugiert-komplex zu dieser Last, also dieselben Zahlenwerte, nur mit Minuszeichen vor dem "j". 

Das Anpassnetzwerk läßt sich auf zwei Bauteile reduzieren: von der Antenne ausgehend, die als reeller 50 Ohm- Widerstand angenommen wird, ist ein Kondensator in Reihe geschaltet. C8 und C9 (in der Tabelle C9 und C10 bezeichnet) liegen in Reihe und sind gleich groß, dürfen also in einem Kondensator mit der halben Kapazität zusammengefasst werden. Dann liegt noch L1 parallel zur Quelle, L3 hat mehr als den 20-fachen Wert und kann vernachlässigt werden.
Das ganze läßt sich im Smith-Diagramm gut darstellen.

[[Image:SmithDiagramm.png|thumb|right|400px|Anpassnetzwerk im Smith-Diagramm]]

Von der Antenne im Mittelpunkt ausgehend bewegen wir uns mit dem Serien-C Cs auf einem Kreisbogen nach unten (kapazitive Halbebene) auf den Punkt "Unendlich" rechts außen zu. Ungefähr senkrecht unter dem Zielpunkt, hier für 433 MHz gezeichnet, biegen wir ab auf eine Kreisbahn für die Parallelinduktivität Lp. Sie führt in die obere (induktive) Halbebene auf den Nullpunkt links zu. Der genaue Schnittpunkt beider Kreise kann "mit Zirkel und Lineal" oder einem der [http://www.mikrocontroller.net/articles/Schaltungssimulation#Hochfrequenztechnik Hochfrequenz-Berechnungsprogramme] ermittelt werden.

Die Kreise für Lp oder Cp sind im Smith-Diagramm nicht eingezeichnet , um die Übersicht zu wahren. Man könnte ein gespiegeltes Diagramm darüberlegen, aber stattdessen spiegelt man die Kurve am Diagramm-Mittelpunkt (dünne blaue Kurven). Am Rand kann man jetzt die auf 50 Ohm (bzw. 1/50Ohm für die gespiegelte Kurve) normierten Blindwiderstände ablesen. Für Cs lesen wir eine Differenz zwischen Start und Zielpunkt von etwa Xc=(3,2-0) * 50 Ohm ab, für Lp sind es (0,25 +0,32) = 0,57*(1/50 Ohm). Damit erhalten wir Cs=1/(2*Pi*f*Xc)=2,3 pF das war wie gesagt die halbe Kapazität der beiden hintereinandergeschalteten Kondensatoren, Tabellenwert ist 4,7pF und Lp=1/(2*Pi*f*0,57*(1/50))= 32,2 nH, der Tabellenwert ist 27nH.

[[Image:Antennenanpassung_RF12.png|thumb|right|400px|Anpassnetzwerk im Datenblatt zu RF12]]
[[Image:Smith-Diagramm-RF12.png|thumb|right|400px|Smith-Diagramm zum RF12]]
Im RF12 wird ein um zwei Bauteile (im Bild C2 und L1 genannt) erweitertes Netzwerk empfohlen, das macht man um eine breitbandigere Anpassung zu erreichen.

== Betriebsspannung==
Achtung nicht alle Module sind für 5V geeignet, alle Typen mit "B" am Ende sind nur für 3,3V. Man muß dann entweder den Mikrocontroller ebenfalls mit 3,3V betreiben, oder [http://www.mikrocontroller.net/articles/Pegelwandler Pegelwandler] verwenden.

== Messungen ==
Drei Messungen am RFM12 zeigen den Einfluß von Eingangpegel, Frequenzhub und Mittenfrequenz auf das Ausgangssignal, gemessen am Filterkondensator CFIL. Zwei weitere Kurven zeigen die ARSSI-Spannung (Anschluß am Kondensator in der Ecke) und die damit gemessene Filterkurve.
[[Image:RFM12_Eingangspegel.png|thumb|right|800px|Messungen am RFM12 Änderung des Eingangspegels]]
[[Image:RFM12_Frequenzhub.png|thumb|right|800px|Messungen am RFM12 Änderung des Frequenzhubs]]
[[Image:RFM12_Mittenfrequenz.png|thumb|right|800px|Messungen am RFM12 Änderung der Mittenfrequenz]]
[[Image:RFM12_ARSSI_und_Filterkurve.png|thumb|right|200px|Messungen am RFM12 ARSSI_und_Filterkurve]]

Was folgt aus diesen Messungen?
* Der ARRSI-Anschluß zeigt uns über mehr als 100 kHz ein Sendesignal an. Decodierbar ist es aber nur im Abstand von weniger als 5 kHz von der Mittenfrequenz. Ohne Abgleich von Sender und Empfänger ist also die AFC unverzichtbar.
* Das "Loch" in der Mitte der Durchlaßkurve stammt von dem im Datenblatt gezeigten Hochpass "> 7 kHz". Für ein unmoduliertes Sendesignal geht die ARSSI-Spannung fast auf den Rauschpegel herunter, hier wurde mit +/-15kHz moduliert.
* Damit läßt sich der Empfänger abgleichen. Man braucht dazu nur ein unmoduliertes Sendesignal auf der Sollfrequenz. Das kann ein mittels Frequenzzähler abgeglichenes zweites RFM12 sein. Der Empfängerquarz wird mit den 4 Bit für die Oszillatorkapazität genau auf dieses "Loch" der ARRSI-Spannung eingestellt.

Die AFC-Messdauer ist im Datenblatt nicht genannt, eine schnelle Abfrage des ATGL-Bit im Statusregister im "Auto-AFC" - Modus liefert minimale Pulsbreiten von ca. 250..270 µsec, entsprechend einer Messfolgefrequenz von 4 kHz - leider nicht ausreichend um 9600 Baud Schmalband-FM zu demodulieren. Im Auto-Modus werden zwei Messungen zusammengefasst, damit beträgt die Updaterate sogar nur 2 kHz. Weitere Messung : ab etwa +/-10 kHz Hub synchronisiert sich das ATGL-Bit auf der Mittenfrequenz mit einem bis zu 1,8...2 kHz FM-modulierten Signal.

Neue Idee: "Dithering und FM-Flankendemodulator": 
Wenn das Empfangssignal nicht weit genug FM-moduliert ist, müssen wir eben den Empfänger modulieren. Im Timer-Interrupt wird die Quarzkapazität oder die PLL z. B. mit 38,4 oder 76,8 kHz und mindestens +/-15kHz Hub umgeschaltet, sodaß bei Empfang eines unmodulierten Signals am CFIL-Ausgang ein symmetrisches Rechteck dieser Frequenz erscheint. Ist das Empfangssignal schmalbandig FM-moduliert, und man stimmt den Empfänger leicht daneben ab, so sollte das CFIL-Signal mit dieser Modulation PWM-moduliert sein. Ein Tiefpass filtert die Dithering-Frequenz weg und übrig bleibt (wenns funktioniert) die Modulation, vielleicht sogar analoger Sprechfunk...
Motto "Engineering is the art of making what you want from things you can get." (von http://www.dsprelated.com)

== Bezugsquellen ==
* [[Elektronikversender#csd-electronics|csd-electronics]]
* [[Elektronikversender#IT-WNS|IT-WNS]]
* [[Elektronikversender#Pollin_Electronic|Pollin Electronic]]

== Links ==

* [[AVR RFM12]]
* [[RFM12 Protokoll Stack]]
* [[RF_SOAP]]
* [[ Pollin_Funk-AVR-Evaluationsboard]]
* [http://www.mikrocontroller.net/topic/93801 Bezugsquellen]
* [http://www.das-labor.org/storage/LaborLib/rfm12/ Library zur Ansteuerung des RFM12]
* [http://www.compotron.com/daten/any/IA4420.pdf Datenblatt des Chipherstellers Integration IA4420.pdf]
* [https://www.silabs.com/Support%20Documents/TechnicalDocs/Si4420.pdf Silabs hat Integration im Juni 2008 gekauft, Chipbezeichnung jetzt Si4420]
Folgende Links sind mit Vorsicht zu genießen, da die Datenblätter teilweise fehlerbehaftet sind. Es empfiehlt sich, direkt mit dem Datenblatt des RF12 (das ist das IC auf dem Modul) zu arbeiten. Dieses ist so gut wie fehlerfrei.

* [http://www.hoperf.com/upfile/RF12.pdf Datenblatt des ICs RF12] (PDF)
* [http://www.hoperf.com/upfile/RFM12.pdf Datenblatt des Moduls RFM12] (PDF)
* [http://www.hoperf.com/upfile/RF12_code.pdf Programming Guide] (PDF)
* [http://www.hoperf.com/upfile/RF12TOOLS.pdf Demo Kit User Manual] (PDF)
* [http://www.pollin.de/shop/downloads/D810047S.ZIP Beispielprogramm von Pollin] (ZIP)

[[Kategorie:Bauteile]]
[[Kategorie:Funk]]

ModelSim

2011-02-11T13:07:28Z

Mixer: Leerzeichen eingefügt

=Beschreibung=
Modelsim ist eine mächtige Simulationsumgebung für [[Hardwarebeschreibungssprachen|HDL]]s. Diese erlaubt die taktsynchrone oder timinggenaue Simulation von digitalen Logikelementen. Anders, als reine Logiksimulatoren erlaubt Modelsim auch das Berechnen und Darstellen von Analogwerten, da Integer und Dezimaltypen intern als normale Variablen (Real) gehandhabt werden. Somit lassen sich auch analoge Modelle verwenden, wenn man sie zuvor in eine gerasterte digitale Darstellung (Signalbus oder Integer) überführt.

=Versionen=
==Kommerzielle Versionen ==
Derzeit werden folgende Versionen von ModelTech vertrieben:
* ModelSim SE (Special Edition)
* ModelSim LE (Linux Edition)
* ModelSim PE (Personal Editon)
* ModelSim Designer

SE ist dabei die leistungsfähigste Version und auch für Unix sowie 64bit-Systeme verfügbar. Die Linux Edition (LE) kann kein VHDL (nur Verilog HDL, 07/2008) und die Personal Edition arbeitet nur mit 40% der Geschwindigkeit von SE und enthält z. B. keinen Optimizer (vopt). Der Designer entspricht ungefähr der PE-Version und besitzt die Möglichkeit VHDL per Schaltplan zu erzeugen.

Vergleichen lassen sich die Versionen direkt auf der [http://www.model.com/products/products_comparison.asp ModelTech-Seite]. Zu Einschränkungen/ Geschwindigkeit der Xilinx Edition (XE) bzw. XE Starter siehe auch folgenden [http://www.mikrocontroller.net/topic/58551#454480 Forumsbeitrag].

==Freie Versionen ==
Eine kostenlose Simulationsumgebung für Xilinx Bausteine ist z. B. im ISE WebPack als ModelSim XE III Starter enthalten, das kostenlos bei [http://www.xilinx.com Xilinx] erhältlich ist. Sie simuliert bei mehr als 10000 Codezeilen nur noch mit geringerer Geschwindigkeit (siehe [http://www.xilinx.com/support/answers/8078.htm Xilinx-Answer Record]). Für die Alteraumgebung, gibt es mittlerweile ebenfalls eine kostenlose "Altera Web Edition".

=Tips und Tricks=
==Unter Modelsim XE Altera Bauteile simulieren==
Für die Simulation Altera-spezifischer Bausteine wie BRAM, DDR, IOs, PLL werden die Libraries von Altera benötigt, die eingebunden werden müssen.

Dazu die Modelsim Altera Version downloaden und installieren, das Verzeichnis Modelsim ae/altera nach modelsim xe/altera kopieren und die INI-Datei im Modelsim_xe verzeichnis folgendermassen erweitern:

[Library]
*std = $MODEL_TECH/../std
*ieee = $MODEL_TECH/../ieee
*verilog = $MODEL_TECH/../verilog
*vital2000 = $MODEL_TECH/../vital2000
*std_developerskit = $MODEL_TECH/../std_developerskit
*synopsys = $MODEL_TECH/../synopsys
*modelsim_lib = $MODEL_TECH/../modelsim_lib
*lpm = $MODEL_TECH/../altera/vhdl/220model
*alt_vtl = $MODEL_TECH/../altera/vhdl/alt_vtl
*altera_mf = $MODEL_TECH/../altera/vhdl/altera_mf
*altgxb = $MODEL_TECH/../altera/vhdl/altgxb
*cyclone = $MODEL_TECH/../altera/vhdl/cyclone
*sgate = $MODEL_TECH/../altera/vhdl/sgate

Modelsim_xe starten, die neu hinzugekommenen Libraries rekompilieren

==Farben==
===Schriftfarbe beim Waveform Print Postscript ändern===
Bsp Schwarz in der .ps Datei 0.5 0.5 0.5 durch 0.0 0.0 0.0 ersetzen.

===Waveform===
Viele wissen nicht, daß man sowohl den Namen als auch den Graphen eines Signales einfärben kann. (Eigenschaften). So wird die Darstellung erheblich verbessert.

==Simulation von Speicherinhalten von Quartus unter Modelsim==
Der Inhalt des Speichers muss im Intel hex Format vorliegen.
Falls dies nicht der Fall ist müssen folgende Schritte durchgeführt werden:
* Quartus öffnen
* Speicher Datei öffnen (mif)
* Datei/speichern unter..
** hex als Dateiendung wählen
* Hinweis: Dateiname und Endung immer klein schreiben!!!

Im Design muss noch die File Endung von mif in hex geändert werden.
* init_file => "prog.hex"

Hinweis:
Der Speicherinhalt kann unter View/debug/memory angeschaut werden.

==Crash==
Falls in der ''vish_stacktrace.vstf'' nach dem Crash sowas drin steht:
<pre>
Exception c0000005 has occurred at address 10229069. Traceback:
# 0 0x10229069: 'TkWinGetDrawableDC + 0x9'
# 1 0x1022918d: 'XCopyArea + 0x3d'
# 2 0x10275e25: 'Tk_CreatePhotoImageFormat + 0x2e25'
...
</pre>
dann könnte es am /3GB-Switch von Windows XP liegen (boot.ini).

[[Category:FPGA und Co]]

Bildergalerien

2010-12-22T18:09:35Z

Mixer: Klammer eingefügt

Hier sind die Bildergalerien einiger netter Threads aufgelistet.

*[http://www.mikrocontroller.net/topic/gallery/91350 Elektronikphotos]; [http://www.mikrocontroller.net/topic/91350]
*[http://www.mikrocontroller.net/topic/gallery/15027 Eure Basteltische]; [http://www.mikrocontroller.net/topic/15027]
*[http://www.mikrocontroller.net/topic/gallery/91509 Kätzchenthread, Vorsicht Nonsense]; [http://www.mikrocontroller.net/topic/91509]
*[http://www.mikrocontroller.net/topic/gallery/136702 Zeigt her eure Kunstwerke]; [http://www.mikrocontroller.net/topic/136702]
*[http://www.mikrocontroller.net/topic/gallery/114555 EAGLE 3D - zeigt eure Projekte]; [http://www.mikrocontroller.net/topic/114555]
*[http://www.mikrocontroller.net/topic/gallery/111726 Adapter, quick & dirty]; [http://www.mikrocontroller.net/topic/111726]
*[http://www.mikrocontroller.net/topic/gallery/156661 Brauche Hilfe beim Bau einer Uhr]; [http://www.mikrocontroller.net/topic/156661]
*[http://www.mikrocontroller.net/topic/gallery/75486 Früher waren Layouter noch Künstler]; [http://www.mikrocontroller.net/topic/75486]
[[Kategorie:Projekte]]

FPGA

2010-08-30T16:08:16Z

Mixer: /* I/O Anschlüsse */ Link zu Verilog eingefügt

FPGA ist die Abkürzung für "'''F'''ield '''P'''rogrammable '''G'''ate '''A'''rray".

== Aufbau ==

=== Grundelemente ===

Ein FPGA besteht, ähnlich wie ein [[CPLD]], aus vielen Logikelementen, hauptsächlich [[FlipFlop]]s (FF) und davor geschalteten Logikelementen. Diese Logikelemente sind entweder Verschaltungen verschiedener Logikgatter (Actel) oder aber kleine LUTs (LUT = Lookup-Table), die über elektronische "Schalter" entsprechend der vom Entwickler gewünschten Funktion miteinander verknüpft werden können.

Eine '''LUT''' kann eine beliebige kombinatorische Funktion (NAND, XOR, AND, Multiplexer etc.) aus den Eingangssignalen realisieren. Die Anzahl der Eingangssignale pro LUT ist vom FPGA abhängig und liegt meist zwischen 4 und 6. Für Funktionen die mehr Eingänge erfordern als eine einzige LUT besitzt (hohes Fan-In), werden mehrere LUTs direkt miteinander verschaltet. Die [[FlipFlop]]s dienen dazu, Signalwerte zwischenzuspeichern, um sie im nächsten Takt weiterverarbeiten zu können. Das Verhältnis zwischen der Anzahl der LUTs und der Anzahl der Flip-Flops ist meist 1:1. Aktuelle FPGAs bestehen aus bis zu einigen zehntausend Logikelementen.

Die logischen Schalter und Speicher sind in den meisten FPGAs durch [[Speicher#SRAM | SRAM]]-Speicherzellen realisiert, welche beim Bootprozess passend geladen werden. Das Laden dieser Konfigurationsdaten bzw. Verknüpfungsregeln geschieht dabei in der Regel aus einem speziellen [[Speicher#Flash | Flash-ROM]]-Baustein heraus. Es kann aber auch ein Mikrocontroller benutzt werden. Die meisten FPGAs bieten daher für diesen Konfigurationsvorgang mehrere Modi an (seriell, parallel, Master/Slave). Da die SRAM-Zellen ihren Inhalt beim Abschalten der Versorgungsspannung verlieren, muss ein SRAM-basierter FPGA bei jedem Einschalten neu konfiguriert werden. Daher benötigt ein solcher FPGA einige Millisekunden bis zur Betriebsbereitschaft.

Eine FPGA-Familie beinhaltet Typen mit unterschiedlicher Anzahl und Komplexität von Logikzellen. So enthält ein Spartan3-1000 ca. 2,5 mal so viel Logik (FF, LUTs) wie ein Spartan3-400.

FPGAs mit nichtflüchtigem Speicher basieren auf [[Speicher#EEPROM | EEPROM]]-, [[Speicher#Flash | Flash]]-Speicher (einige Familien von Lattice und Actel) oder AntiFuse- Technologie (Actel). Die sogenannten AntiFuse FPGAs sind nur einmalig programmierbar.

=== I/O Anschlüsse ===

FPGAs unterstützen als universal einsetzbare Digital-ICs eine Vielzahl von Signalstandards. Üblich sind verschiedene TTL-Pegel (5V, 3,3V, 2,5V), differentielle Signalstandards (LVDS, GTL) und im Hochpreisbereich serielle Hochgeschwindigkeitsstandards mit bis zu 4 Gbit/s. Oftmals sind weitere Eigenschaften wie Treiberstärke und Flankensteilheit für jeden benutzerdefinierbaren Anschluss (User-IO) einstellbar. Meist sind die Pins zu Bänken mit gleichem I/O Standard zusammengefasst. Innerhalb einer solchen Bank arbeiten alle Pins im gleichen I/O Standard und mit der selben I/O Spannung.

Ebenso können FPGA-interne Pull-Up und Pull-Down-Widerstände zugeschaltet werden, [[Wellenwiderstand | Terminierung]] wird ebenfalls unterstützt. Zudem befinden sich hinter vielen IO-Pads sog. [[Boundary_scan| Boundary Scan]] Zellen.

Das I/O Verhalten wird zusammen mit vielen anderen Parametern in einer Datei festgelegt (Xilinx *.ucf, Altera *.acf, Lattice *.lpf). Alternativ können diese auch als Syntheseoption im Kommentarfeld des [[Verilog]]/[[VHDL]] Codes mit angegeben werden.

[[Ausgangsstufen Logik-ICs | Tristatebuffer]] werden implizit über VHDL definiert, indem einem Ausgang zeitabhängig der Zustand "Z" zugewiesen wird. Alternativ kann er explizit als Komponente eingefügt werden.

Einige Pins übernehmen besondere Funktionen und sind somit vom Anwender nicht uneingeschränkt oder z.T. auch gar nicht nutzbar. Dazu zählen neben der [[JTAG]]-Schnittstelle z. B. die Pins zum Einlesen der Konfigurationsdaten.

Ferner sind einige wenige Pins (2 - 8) zum Einspeisen des Taktes für das Design vorgesehen. Für schnelle Schaltungen müssen diese reservierten Pins benutzt werden. Sie enthalten kein Eingangs-FF und wirken direkt auf Taktnetze / PLLs.

Die Hersteller bieten FPGAs mit gleicher Anzahl von Logikelementen in unterschiedlichen Gehäusen an. So kann der FPGA mit der passenden Anzahl von Pins eingesetzt werden. Das obere Ende markieren Chips mit über 1000 I/Os, die kleinsten bieten ca. 80 User-I/O. Oft werden nur [[IC-Geh%C3%A4useformen#BGA|BGA]] und [[IC-Geh%C3%A4useformen#QFP|QFP]] Gehäuse (bis ca. 240(?) Pins) angeboten.

=== Komplexe Funktionsblöcke ===

Neben den einfachen FlipFlops beinhalten FPGAs darüber hinaus komplexe Routing- und Speicherkonfigurationsoptionen innerhalb und außerhalb der logischen Elemente (LEs), die es gestatten, komplexe Schalt- und Rechenstrukturen aufzubauen. Für rechenintensive Designs, z. B. in der Signalverarbeitung, enthalten viele FPGAs '''Multiplizierer''' direkt auf dem Chip, die in einem einzigen Taktzyklus Multiplikationen durchführen können.

Ferner haben FPGAs oft einen von den LEs getrennt verfügbaren '''RAM'''-Bereich integriert, der sich in vielfältiger Weise ansprechen lässt. So können damit Single- oder Dualport-RAMs mit variabler Bitbreite erzeugt werden. Üblich sind mehrere (4 - 30) kleinere Dualport [[Speicher#BRAM | RAM-Blöcke]] von 4 - 16 kbit. Einige Familien besitzen einen größeren internen RAM, andere spezielle FIFO-Blöcke.

Zur Generierung spezieller Takte sind '''PLL'''s (Phase Locked Loop) auf dem FPGA integriert. Einige Hersteller setzen mit dem selben Ziel '''DLL'''s (Delay Locked Loop) ein. Mittels dieser Blöcke können aus einem Taktsignal weitere erzeugt werden. Typisch sind Taktverdopplung oder -vervielfachung. Ebenso kann der Takt geteilt werden oder ein Signal gleicher Frequenz, aber um eine halbe, viertel usw. Periode verschoben erzeugt werden. Typische Anwendungen sind die Ansteuerung von [[Speicher#DDR-RAM | DDR-RAMs]] oder die Kompensation von Laufzeitunterschieden zwischen Takt und mit diesem getakteten Steuersignalen. Meist sind 2 - 8 Taktnetzwerke und PLL/DLLs gleicher Anzahl integriert. Siehe auch [[Taktung FPGA/CPLD]].

=== CPU im FPGA ===

Programmierbare Prozessoren sind auch bei FPGA-Designs immer häufiger anzutreffen. CPUs sind zwar im Allgemeinen langsamer und weniger effizient, als eine vollständige Implementation aus Logik-Primitiven - aber bei komplexen Abläufen auch deutlich einfacher zu entwickeln. Insbesondere bei sequentiellen Aufgaben (Benutzerinterface, komplexe Steueraufgaben etc.) wird man gerne auf eine klassische CPU zurückgreifen.

Manche FPGAs integrieren dazu einen oder mehrere Prozessorkerne (z. B. [[AVR]] bei Atmels FPSLIC oder PowerPC bei Xilinx' Virtex) als ''HardCores'' auf einem IC.

Auf der anderen Seite gibt es auch [[FPGA Soft Core | SoftCores]] (z. B. ARM-Cortex-M1 bei IGLOO-FPGA von [http://www.actel.com ACTEL]), Prozessorkerne die als Quelltext oder als vorsynthetisierte Netzliste vorliegen. In Abhängigkeit von den zur Verfügung stehenden Ressourcen können diese ''SoftCores'' beliebig instanziiert werden. Es gibt eine Vielzahl verschiedener ''SoftCores''.

Teilweise kompatibel zu etablierten Prozessorarchitekturen (MIPS, SPARC, AVR), zum Teil optimiert auf die FPGAs einzelner Hersteller. Auch auf vergleichsweise
kleinen aktuellen FPGAs kann man problemlos eine 32bit-RISC-CPU integrieren.

Als Programmspeicher werden die FPGA-internen [[Speicher#BRAM | RAM-Blöcke]] oder externe [[Speicher]] (SDRAM, SRAM) genutzt. Für einige Prozessorkerne stehen Hochsprachen wie C, C++ etc. zur Verfügung, andere werden in Assembler programmiert.

== Eigenschaften ==

=== Geschwindigkeit ===

Die maximale „Geschwindigkeit“ eines FPGAs ist von der verwendeten Halbleitertechnologie (Prozess, Strukturgrößen), der internen Schaltungstopologie (Komplexität der LEs), Vorhandensein von harten Strukturen und vor allem vom Design abhängig. Dabei sind der sogenannte Datendurchsatz und die rein maximale Systemtaktfrequenz zu unterscheiden. Die erreichbare Taktfrequenz lässt sich ohne detaillierte Kenntnis des Designs nicht abschätzen, möglich sind je nach »Speed Grade« des ICs typischerweise Taktfrequenzen von 300-600 MHz für die Schaltgeschwindigkeit der reinen Logikelemente. Je nach der Anzahl und Komplexität der pro Takt durchzuführenden Operationen ergeben sich dann reale Systemtaktfrequenzen von meist 10-100 MHz für global operierende Einheiten und bis zu 300 MHz für schnelle lokale Module. Maßgeblich ist in wieweit das Design auf Fläche bzw. Geschwindigkeit hin optimiert und vom Tool synthetisiert wurde: Durch das Einbringen von zusätzlichen Registerstufen lassen sich z. B. zeitkritische Pfade entschärfen (Pipelining), sodass die Frequenz des Chips angehoben werden kann und somit der effektive Datendurchsatz erhöht wird, mit dem Nachteil der gesteigerten Latenz durch das Mehr an Takten. Der Datendurchsatz lässt sich darüber hinaus durch die Nutzung paralleler Architekturen verbessern.

Die Systemfrequenz kann-, muss aber nicht der Frequenz entsprechen, mit der Daten zyklisch eingetaktet und verarbeitet werden; zudem sind Schaltungsteile mit unterschiedlichen Taktfrequenzen zu unterscheiden: Mit einem Systemtakt von 20 MHz lassen sich z. B. 18-Bit AD-Wandler auslesen, die so z. B. alle 1 µs neue Daten liefern, die verarbeitet werden müssen. Bei der Nutzung von 5 solchen Wandlern, die sequentiell verarbeitet werden, lägen 5 MHz Datenfrequenz vor. Für andere Schaltungsteile, die z. B. asynchron an die Peripherie andocken, sowie reine »state machines« können Schaltungsteile auf der 2-4 fachen Frequenz betrieben werden.

Generell sind Fläche und Geschwindigkeit konkurrierende Größen, zwischen denen ein Optimum gefunden werden muss. Für die preiswerten FPGA-Serien wie Spartan (Xilinx) und Cyclone (Altera) sind aufgrund technologischer Randbedingungen etwa 10-30% weniger Taktgeschwindigkeit bei gleichem Design zu erwarten als bei den großen Brüdern der Virtex- (Xilinx) bzw. Stratix-Familie (Altera). Es muss mit mehr Verbrauch an Logikelementen und Taktzyklen gerechnet werden (weniger Routingreserven, geringere Zahl von LUT-Eingängen, langsamere Logikelemente). Dafür sind sie sehr preiswert.

Funktionstechnisch identische Chips werden oft in zwei oder mehr Geschwindigkeitsklassen (speed grades) angeboten, die sich meist durch Bauteilselektion bei der Produktion ergeben. Grob kann man ca. 5%-10% höhere Taktung zwischen zwei speed grades erwarten.

== Hersteller ==

Die größten Hersteller von FPGAs sind [http://www.altera.com Altera] und [http://www.xilinx.com Xilinx]. Weitere Hersteller sind [http://www.latticesemi.com/ Lattice], [http://www.actel.com Actel] und [http://www.atmel.com Atmel].

== Anwendung ==

Der Aufbau komplizierter, applikationsnaher Strukturen wird meist durch automatische Routing- und Synthesewerkzeuge erledigt, welche mit einer logischen, funktionellen Beschreibung der Architektur in einer Hardwarebeschreibungssprache wie z. B. VHDL "gefüttert" werden. Die Hardwarebeschreibung in [[VHDL]] gelingt ihrerseits z. B. mit VHDL-generierenden Werkzeugen, mittels derer zuvor Logikstrukturen, hardwarenahe Strukturen, Ablaufdiagramme und Zustandsautomaten formuliert wurden.

Durch die Standardisierung der Architektur einerseits und die Entkoppplung von applikationsorientierter Beschreibung sowie Chip- und Hersteller-spezifischer Synthese andererseits, wird die Hardware quasi als Software gebaut. Dies wiederum schafft alle Optionen der Wiederverwendung und Austausch von "Hardwareteilen". So stehen inzwischen komplett nutzbare Schaltungen wie serielle Bausteine, RAM-Controller und vieles mehr als Open Source zur Verfügung.

== Entwicklungsboards und Starterkits ==
=== Boards für Xilinx-FPGAs ===

{| border="1" class="sortable" id="fpgaevalboards"
|-
! Bezeichn.
! Preis (€)
! FPGA
! RAM (MByte)
! Flash (MByte)
! USB
! Ethernet
! RS-232
! µC
! Eingabe
! sonst.
|-
| [http://www.knjn.com/board_Xylo.html Xylo-L]
| 130
| XC3S500E
| -
| -
| 2.0
| 10base-T
| -
| LPC213x
| -
|
|-
| [http://www.xilinx.com/s3estarter Spartan3e Starter Kit]
| 180
| XC3S500E
| 64 MB DDR-SDRAM
| 16
| (JTAG)
| 10/100
| 2x
| -
| 4 Taster, 1 Drehgeber, 4 Schalter
| Coolrunner CPLD, LCD, 3-Bit VGA, PS/2
|-
| [http://www.digilentinc.com/Products/Detail.cfm?Nav1=Products&Nav2=Programmable&Prod=S3BOARD Digilent Spartan-3]
| 100
| XC3S200/400/1000
| 1
| -
| -
| -
| 1x
| -
| 4 Taster, 8 Schalter
| VGA, PS/2, 7seg
|-
| [[Digilent Nexys]]
| 100
| XC3S200/400/1000
| 16
| 4
| 2.0
| -
| -
| -
| 4 Taster, 8 Schalter
| 7seg, Programmierung & Stromversorgung über USB
|-
| [[Digilent Nexys 2]]
| 121
| XC3S500E/1200E
| 16
| 16
| 2.0
| -
| 1x
| Cypress FX2
| 4 Taster, 8 Schalter, 8 LEDs
| 4x7Seg, Programmierung & Stromversorgung über USB oder über Netzteil (5V-15V)
|-
| [http://www.uxibo.de Uxibo]
| 88
| XC2S200E
| -
| -
| 1.1
| -
| -
| -
| 4 Taster, 8 Schalter
| VGA I/O, Videomux, dual PS/2, 7seg, Buzzer, IOs auf Pinleisten, dual-channel FTDI2232C, 48 MHz + prog. Oszillator, Programmierung & Stromversorgung über USB
|-
| [http://www.fpgaz.com/wiki/doku.php?id=fpgaz:usbp:hw FPGAz USBP]
| $135
| XC3S400
| -
| -
| 2.0
| -
| -
| Cypress FX2
| 2 Taster
| 8 LEDs, I2C-EEPROM
|-
| [http://www.cesys.com/fpga/spartan/efm01_de.html EFM 01] Embedded FPGA Modul
| ~173,-
| XC3S500E
| -
| 4
| 2.0
| -
| -
| FX-2
| -
| 28 x 44mm, 50 I/O auf 2.54mm Stiftleiste, WIN und LINUX Treiber
|-
| [http://shop.trenz-electronic.de/catalog/product_info.php?products_id=456 Avnet Spartan 3A Evaluation Kit]
| 50
| XC3S400A
| -
| 16
| 2.0
| -
| -
| -
| -
| WIN und LINUX Treiber
|-
| [http://www.ct-lab.de FPGA-Karte aus dem c´t-Lab]
| 92
| XC3S400
| -
| SD-Kartenslot (Bitstream-File wird über µC ins FPGA geladen, Dateiauswahl via Systembus oder Panel oder fest einstellbar)
| via IFP-Karte und Systembus an µC
| via IFP-Karte und Systembus an µC
| via IFP-Karte und Systembus an µC
| ATmega644
| optionales Bedienpanel mit LCD-Display, Drehgeber und Taster
| Bestandteil des Laborsystems c´t-Lab der Zeitschrift c´t.
VGA-Buchse, SD-Kartenslot (u.a. auch zum Laden des FPGA). Preis für FPGA-Platine mit verlöteten SMD-Bauteilen und Teilesatz. Optionale Erweiterungskarten mit schnellen DACs, Eingangskomparator, SRAM, Echtzeituhr, PS/2, RS232 (am FPGA). Optionaler JTAG-Adapter.
http://www.ct-lab.de, http://www.segor.de, http://thoralt.ehecht.com/phpbb
|}

==== Raggedstone 1 - Spartan-3 Development PCI-Karte ====
* Spartan-3 FPGA FG456-Package
* 32 bit, 33 MHz, 3.3/5V PCI interface
* 4Mbit Flash Memory
* 16KBit serielles EEprom
* 4 x 7 Segment Anzeigen LED, abnehmbar
* LM75 Temperatursensor
* viele DIL-Header für eigene Erweiterungen, verschiedene werden auch durch Hersteller angeboten
* 2 Drucktaster
* Mit dem PCI-Interface kann bei entsprechender Programmierung des FPGA auf den PCI-Bus eines Hostrechners zugegriffen werden, Beispieldesign unter http://projects.varxec.net/raggedstone1
* Webseite: http://www.enterpoint.co.uk/moelbryn/raggedstone1.html
* Preis mit XC3S400 ca. €145,- (inkl MwSt.)
* Preis mit XC3S1500 ca. €255,- (inkl. MwSt.)

==== LiveDesign Evaluation Board von Altium ====
* Kompatibel mit den LiveDesign-fähigen Entwicklungstools von Altium
* Xilinx-Version direkt mit ISE Webpack nutzbar
* Xilinx XC3S1000-4FG456C, wahlweise aber auch mit Altera EP1C12F324C8 (s.u.)
* Mit Flachbandkabel für PC-Verbindung (Druckerport) sowie weiteren Kabeln und Verbindern
* Peripherie: LEDs, Dip-Schalter, 6-stellige Siebensegmentanzeige, Taster, Stereo-DAC, zwei 256K x 16 RAMs
* ''kein'' on-board Flash RAM für FPGA-Konfiguration, diese muss nach dem Einschalten neu geladen werden
* Ports: PS2-Maus & -Tastatur, RS232, VGA (512 Farben), 2x18 IO-Pins für allgemeine Zwecke
* Listenpreis $99,- Endpreis: ~150 Euro (inkl. MwSt. und Versand)

==== Trenz-Electronic ====
http://www.trenz-electronic.de/products.html
* Kleines FPGA Board mit ucLinux und Virtex-II PowerPC, optional: ucLinux und Microblaze Softprozessor im Spartan-3 FPGA
* Spartan-3 FPGA Mikromodul mit 200K bis 1000K Systemgattern
* Pal/Gal kompatible FPGA und CPLD Module

==== Simple-Solutions ====
http://www.simple-solutions.de/de/products/index.php
Mehrere Spartan3-FPGAs - Boards

==== CESYS ====
http://www.cesys.com

Cesys ist Entwickler und Hersteller von FPGA-boards mit Sitz in Deutschland.

* Verschiedene FPGA boards mit USB, PCI und PCIe Schnittstellen im Lieferprogramm
* Je nach Ausführung mit Spartan-2/3/3E/6, Virtex2/2PRO/4
* verschiedene Speicherkonfigurationen (SO-DIMM, SRAM, SDRAM, DDR2)
* Auftragsentwicklungen nach Kundenwunsch möglich

=== Boards für Altera-FPGAs ===
==== LiveDesign Evaluation Board von Altium ====
* Kompatibel mit den LiveDesign-fähigen Entwicklungstools von Altium
* * Wahlweise mit Altera EP1C12F324C8 oder Xilinx XC3S1000-4FG456C
* Mit Flachbandkabel für PC-Verbindung (Druckerport) sowie weiteren Kabeln und Verbindern
* Peripherie: LEDs, Dip-Schalter, 6-stellige Siebensegmentanzeige, Taster, Stereo-DAC, zwei 256K x 16 RAMs
* ''kein'' on-board Flash RAM für FPGA-Konfiguration, diese muss nach dem Einschalten neu geladen werden
* Ports: PS2-Maus & -Tastatur, RS232, VGA (512 Farben), 2x18 IO-Pins für allgemeine Zwecke
* Endpreis: ~150 Euro (inkl. MwSt. und Versand)

==== Terasic TREX C1 Multimedia Development Kit ====
* Altera EP1C6Q240C8 & EP1S Serial Configuration Device
* Built-in USB Blaster programming circuitry (JTAG and AS mode)
* 1 MiB Flash Memory & 8 MiB SDRAM (1M x 4 x 16)
* CF Card Socket, 16-bit CD-quality Audio DAC
* TV Encoder, VGA, RS-232, PS/2, and more
* Many reference designs and C++ applications
* [http://www.terasic.com.tw/cgi-bin/page/archive.pl?Language=English&CategoryNo=39&No=14 www.terasic.com.tw]
* fertiger Core eines CPC6128 (8-Bit Homecomputer von 1984) für dieses Board, inlusive Sourcecode (eigener Z80 in AHDL, mit 24MHz eingesetzt): [http://www.symbos.de/trex.htm http://www.symbos.de/trex.htm]
* Listenpreis $149,-

==== Altera Cyclone II 2C20 ====
* Altera Cyclone II EP2C20F484C7N FPGA mit 20000 LEs
* USB-BlasterTM download cable (integriert)
* EPCS4 serial configuration Flash
* 8-Mbyte SDRAM, 512-Kb SRAM, 4-Mbyte flash
* externer SMA - Clock-Eingang
* 24-bit Audio coder/decoder (CODEC)
* 10 Schalter, 4 Druckknöpfe inkl Reset
* 4St. 7-Segmentanzeigen, 10 rote LEDs + 8 grüne LEDs
* VGA, RS-232, and PS/2 Stecker
* Zwei 40-pin expansion ports + SD/MMC socket
* USB-Kabel, externes Steckernetztteil, CD-Rom
* Reference designs
* Qartus II Web Edition + NIOS II Web Edition
* http://www.altera.com/products/devkits/altera/kit-cyc2-2C20N.html
* Listenpreis $150,-

==== Hpe Mini AC II - Altera Cyclone board von Gleichmann Research ====
* Altera Cyclone II EP2C35 FPGA (speed grade 6)
* Mit reprogrammierbarem Flash zur automatischen FPGA-Konfiguration
* 25 pin SUB-D connector (parallel) für direktes FPGA-Programmieren
* RS232 (9 pin SUB-D)
* VGA (15 pin SUB-D) mit 64 möglichen Farben
* Ethernet 10/100 Mbit/s, full/half duplex
* 1 USB 2.0 compatible full-speed target connector
* 3 USB 2.0 compatible full-speed host connectors
* Santa Cruz connector mit 40 nutzbaren I/Os
* Audio interface (line-in and line-out) mit CODEC
* SODIMM144 Sockel für (SDRAM) 256MB
* SDRAM-Speichersockel mit nur 32-Bit angebunden, die Hälfte des Speichers bleibt nicht nutzbar
* 25 MHz oscillator
* Prototyping area, Lötfläche
* 8 LEDs, grün, blau, 3x4 key matrix, 4-bit DIP switch
* LCD connector, 2-character 7-segment display
* Single step Knopf und Reset Knopf
* Parallelportkabel für PC
* Beispieldesign, Testprogramme, Datenblätter
* LEON3-CPU Design inkl. Source Code, Quartus IDE, SnapGear Linux
* Je nach Ausführung des Flashs €399,- bis €499,-

==== Altera DE2 - Development and Education Board ====
* Altera Cyclone II 2C35 FPGA mit 35000 LEs
* Altera Serial Configuration devices (EPCS16) für Cyclone II 2C35
* USB Blaster board zur Programmierung und User API
* 8 MB SDRAM, 4 MB Flash Memory, 512KB SRAM
* SD Card Sockel, RS-232, Ethernet, 10-bit VGA, 24-bit Audio CODEC
* TV Decoder (NTSC/PAL), IrDA, USB (Host + Slave)
* Viele Besipiel mit Source Code wie TV, SD Music Player)
* [http://www.fh-wedel.de/fileadmin/mitarbeiter/bos/files/VHDL/VhdlEinfuehrung.pdf Kleines aber nettes Tutorial zum Altera DE2 Dev. Board]
* Listenpreis US $495,-

==== Cyclone III embedded Development Kit====
* Altera Cyclone III EP3C25 FPGA
* 640x480 LCD Display mit touch screen function
* MiniSD-Card Sockel
* Audio Interface ADC CODEC
* 10/100 Mbit Fast Ethernet Schnittstelle
* FPGA-Konfiguration über USB
* NIOS II EVAL Lizenz
* IP LIB Altera
* Listenpreis US $495,- über ALtera Webseite
* Bei EBV €349,- inkl. MwSt.

==== NanoBoard-NB1 von Altium ====
* kompatibel mit den LiveDesign-fähigen Entwicklungstools von Altium
* Unterstützt eine breite Palette von Ziel-FPGAs durch Aufsteckplatinen
* Altera Cyclone (EP1C12-Q240C7) Aufsteckplatine enthalten
* Xilinx Spartan IIE (XC2S300E-PQ208) im Lieferumfang enthalten
* Enthält Stromversorgung mit verschiedenen Steckern für unterschiedliche Konfigurationen
* Mit Flachbandkabel für PC-Verbindung sowie weiteren Kabeln und Verbindern
* NanoBoard-NB1 Reference-Handbuch zur Hardware
* Peripherie: LCD, LEDs, Dip-Schalter, Tastenblock, Summer, ADC/DAC, 256K x 8 RAM, 8 MiB Serial Flash RAM, on-board Serial Flash RAM für FPGA-Konfig.
* Ports: PS2-Maus & -Tastatur, RS232, CAN, VGA, I2C, IO Stecker für allg. Zwecke
* Upgradefähige NanoBoard Controller Firmware
* Stabiler NanoBard-Sockel
* Listenpreis €995,-

=== Boards für Lattice-FPGAs ===
==== www.hardware-design.de ====
* bietet verschiedene einfache Boards mit Lattice-Bausteinen an
* FPGA-Board mit XP2-17/XP2-8/XP2-5 -> 113,- bis 101,- Euro
* CPLD-Boards u.a. mit MachXO640 -> 89,- Euro

=== Debugging-Hilfen ===
Gerade beim [[Debugging]] größerer FPGA-Designs ist es oft notwendig, auf interne Signale und Busse zuzugreifen, die aus routing- oder Platzgründen nicht an Pins des FPGAs gelegt - und mit konventionellen Analysatoren beobachtet werden können. Nebst den einschlägigen Tools der Hersteller, welche Signal probing über JTAG gestatten (z. B. ChipsScope und SignalTap), werden in FPGAs oft mehr oder weniger komplexe [[Logic Analyzer]] integriert, welche die internen Signale in vielfältiger Weise aufzeichnen. Diese werden in Block-RAMs oder FIFOs gespeichert und durch externe Master ausgelesen. Hier kommen auf der Platine befindliche MCUs oder fremd zugreifende FPGAs / CPUs in Betracht, welche über unterschiedliche Kommunikationsverbindungen (seriell, parallel, LVDS) angeschlossen sind. Dazu werden in die FPGAs entsprechende Cores / Treiber eininstanziiert.

Nachfolgend einige Beispiele:

====Proprietärer serieller Logic Analyzer ====

Die einfachste Möglichkeit ist die direkte Instanziierung eines Blockrams als FIFO mit "breitem" Busanschluss: Linksseitig besitzt das FIFO eine Breite von z. B. 256 Bit (Xilinx-Rams lassen sich ohne weitere Umbeschaltung über den Wizzard mit bis zu 1024 Bits deklarieren und nutzen). Rechtsseitig einen 16- oder 32 Bit breiten Busanschluss für einen Prozessor bzw Parallelinterface oder einen 1 Bit breiten Anschluss für ein serielles streaming interface. Mit einem FiFo-enable können die zu sampelnden Zeiten (Busphasen) festgelegt werden, z. B. anhand eines Kriteriums wie die Erfüllung einer bestimmten mathematischen Bedingung, die man in VHDL formuliert, oder es wird einfach ein Trigger gesetzt. Solange das FiFo nicht voll ist, kann geschrieben werden, was durch die interne FiFo-Verwaltung selbst bereits komplett geregelt wird.

Beim einfachen seriellen Logic Analyzer benötigt man nur noch einen kleinen Core, der permanent das FiFo liest, und den seriellen Overhead (Startbit, Stoppbit, Parity und gfs CRC) hinzufügt. Mit einem einfach Pegelwandler kann so ein PC direkt angeschlossen werden.

Auch denkbar ist die Anbindung an ein fremdes FPGA-board mit viel Speicher über (LV-)DS-Kommunikation. In komplexeren Systemen wird ein CAN- oder USB-Core eingesetzt.

Wenn mittels des Kriteriums nur ganz bestimmte kritische Phasen herausgesampelt werden (z. B. das Auftauchen eines bestimmten Rechenfehlers im FPGA) und so das Datenaufkommen je Zeiteinheit über längere Zeit betrachtet eher gering ist, kann bei geeignetem Datendurchsatz in Echtzeit dauerhaft mitprotokolliert werden.

==== BusProbe, der Debugging Core von abaxor engineering ====
Mit der BusProbe kann der Entwickler den Signalfluss im FPGA-Design auch über einen längeren Zeitraum überwachen und am PC aufzeichnen. Der Core verarbeitet an jedem Eingang einen kompletten Bus.

Die Daten werden gemultiplext zum PC geschickt und dort per Software demultiplext. Im PC erfolgt auch die Auswertung mit beliebigen Analyse-Tools.

Gegenüber dem Betriebssystem verhält sich die BusProbe wie eine Festplatte, von der die Daten mit gewöhnlichen Zugriffen gelesen werden können.

* Streaming der Daten zum PC mit mehr als 20 MByte/s
* keine Treiber im PC da Nutzung von Standardschnittstellen (USB oder IDE)
* Hot-Plugging
* Visualisierung mit beliebigen Programmen
* geringer Logikaufwand

[http://www.abaxor.de/produkte.html abaxor.de-Webseite]

==== open source Logikanalysator von sump.org====
Ein einfacher, übersichtlicher Logikanalysator findet sich auf sump.org. Er liegt im Quelltext vor wird mit ins Design einsynthetisiert. Als Speicher dient wahlweise SRAM oder internes RAM. Es können 32 Kanäle mit 100 MHz (oder weniger) gesampelt werden. Die Bediensoftware läuft platformunabhängig unter Java und benötigt eine serielle Schnittstelle (auch über USB-seriell Wandler) zum Core.

[http://de.sump.org/projects/analyzer/ sump.org-Webseite]

== Siehe auch ==
* [[Hardwarebeschreibungssprachen]]
* [[Reset für FPGA/CPLD]]
* [[Taktung FPGA/CPLD]]
* Projekt [[Audio-DSP mit Spartan 3-FPGA]]

== Weblinks ==
* [http://www.fpga4fun.com/index.html FPGA4Fun] - FPGA-Projekte, größtenteils mit Altera und Verilog
* [http://video.google.com/videoplay?docid=-4969729965240981475 Ein Vortrag, auf Englisch: General Purpose, Low Power Supercomputing Using Reconfiguration Logic]
* http://www.opencores.org - FPGA-Projekte, Opensource, jeder kann seine Eigenen einstellen und an anderen mitarbeiten. U.a. gibt es verschiedene CPUs für FPGAs.
* [http://members.optushome.com.au/jekent/FPGA.htm John's FPGA Page]
* [http://www.embedded.com/columns/whatsnew/197003073 More about designing with embedded FPGAs] by Bernard Cole, Embedded.com

[[Category:FPGA und Co]]

AVR Softwarepool

2010-07-29T14:46:22Z

Mixer: /* DMX */ Programmiersprache ergänzt

Die interessantesten Softwareprojekte aus der Codesammlung...

(A) ... Projekt ist in '''Assembler''' 
(C) ... Projekt ist in '''C''' 
(B) ... Projekt ist in '''Bascom''' 
(PC) ... Projekt ist nicht für einen µC, sondern für den PC

==1-Wire==
* (C) [http://www.mikrocontroller.net/topic/14792 DS1820, DS18B20 in C]
* (A) [http://www.mikrocontroller.net/topic/6505 Mehrere DS1820/DS18B20 auslesen]
* (C) [http://www.mikrocontroller.net/topic/31408#536372 Mehrere DS1820/DS18B20/DS18S20/DS1822 über einen Webserver auslesbar]

==Akkulader==
* (A) [http://www.mikrocontroller.net/topic/72627#594587 Bleiakku-Lader 12/24V]
* (C) [http://www.mikrocontroller.net/topic/99803#866081 Glühwürmchen in Rotkohlglas gefangen]

==Bootloader==
* (A,C,PC) [http://www.mikrocontroller.net/topic/12181#79866 AVR Bootloader]
* (A, PC) [http://www.mikrocontroller.net/topic/146638#1364260 AVR Bootloader für GCC-Toolchain]
* (A,PC) [http://www.mikrocontroller.net/topic/95839 AVR Bootloader mit Verschlüsselung]
* (A) [http://www.mikrocontroller.net/topic/72308#591159 ATtiny45 Bootloader]
* (C) [http://www.mikrocontroller.net/topic/67047#538510 MMC/SD Bootloader für ATMega16]
* (C) [http://www.mikrocontroller.net/topic/56818#439359 SD/MMC Card Bootloader (passt in 2kb bootsection)]
* (C) [http://www.mikrocontroller.net/topic/61170#480765 boofa - Bootloader für AVR über UART (AVR109)]
* (C) [http://www.mikrocontroller.net/topic/53130#413058 Bootloader ATmega168]
* (C) [http://www.mikrocontroller.net/topic/73196#600293 UART Bootloader ATtiny13 - ATmega644]
* (C) [http://www.mikrocontroller.net/topic/99803#866081 Glühwürmchen in Rotkohlglas gefangen]
* (C) [http://www.mikrocontroller.net/topic/150816#1414460 UART Bootloader AtMega644P @ 20MHz] (Eclipse Projekt)

Siehe auch: [[Bootloader]]

==DCC==

(Digital Command Control, Standard zur digitalen Steuerung von Modelleisenbahnen)

* (A) [http://www.mikrocontroller.net/topic/31397#241300 DCC Decoder]

==DCF77==

(Zeitsignaldienst für funkgesteuerte Uhren auf der Langwellen-Frequenz 77,5 kHz)

* (A) [http://www.mikrocontroller.net/topic/38914#287867 DCF77 AVR-Assemblerbaustein ]
* (A) [http://www.mikrocontroller.net/topic/6500#41738 DCF77-Uhr mit ATTINY12]
* (A) [http://www.mikrocontroller.net/topic/31385#241104 DCF Digital Empfangsmodul - Korrelation - (Assembler)ATmega8 ]
* (C) [http://www.mikrocontroller.net/topic/25071#186286 DCF 77 ]
* (C) [http://www.mikrocontroller.net/topic/14788#101528 DCF-Uhr mit DotMatrix-Anzeige für avr-gcc]
* (C) [http://www.mikrocontroller.net/topic/12154#79501 PC DCF Timer ( PC Zeitschaltuhr)]
* (C) [http://www.mikrocontroller.net/topic/25116#187197 DCF 77 Uhr mit CodeVision ]
* (C) [http://www.mikrocontroller.net/topic/58769#456232 DCF77 Uhr in C mit ATtiny26]
* (C) [http://www.mikrocontroller.net/topic/48597#372164 DCF77 Uhr, zum X.ten Mal, jetzt mit SAF]
* (C,A) [http://www.mikrocontroller.net/topic/31408#536372 DCF77 mit beliebig gepoltem Eingangssignal innerhalb eines Webservers]
* (C) [http://www.mikrocontroller.net/topic/121049 DCF-Uhr, Sonnenstand, TWI-Port, Alarmfunktion für Atmega8]
* (A) [http://www.mikrocontroller.net/topic/151260#1419218 DCF77 Uhr 7 Segment LED ATmega8 Assembler]
* (C) [http://www.mikrocontroller.net/topic/168807#1614129 DCF-Uhr mit LCD in C]

== DRAM ==
* (A,C) [http://www.mikrocontroller.net/topic/25053#186085 2MB DRAM an AVR] und Anwendung als [http://www.mikrocontroller.net/topic/25053#186089 Audiorekorder]

==Drehgeber==
* (C) [http://www.mikrocontroller.net/topic/6526#41978 Drehgeber auslesen]

==DTMF==
* (A) [http://www.mikrocontroller.net/topic/92444#792954 DTMF dekodieren]

==DMX==

* (C) [http://www.mikrocontroller.net/topic/92350#new 20 Kanal Relaissteuerung per DMX]

==Entwicklungssysteme==
* (PC) [http://www.mikrocontroller.net/topic/74198#611404 AVR Code Wizard]
* (A) [http://www.mikrocontroller.net/topic/30110#230503 Multitasking kernel für ATtinys in ASM]
* (A) [http://www.mikrocontroller.net/topic/65156#521012 BASIC-Computer mit ATmega32]
* (A) [http://www.mikrocontroller.net/topic/64129#511368 AVR TinyBASIC Anpassung für ATmega8]
* (A) [http://www.mikrocontroller.net/topic/59189#460273 Mini-Computer mit BASIC]
* (A) [http://www.mikrocontroller.net/topic/55807 Forth System für ATmegas in Assembler]
* (A) [http://www.mikrocontroller.net/topic/94193 Forth-Computer mit ATmega32 und Videoausgabe] von Christian Berger
* (C) [http://www.mikrocontroller.net/topic/62500#493931 Fixpoint-Arithmetik in "C"]
* (C) [http://www.mikrocontroller.net/topic/85256#717037 64 Bit float Emulator in C, IEEE754 kompatibel]
* (A,C) [http://www.mikrocontroller.net/topic/92979#797957 AVR ATmega8TestBoard]
* (C) [http://www.mikrocontroller.net/topic/94468#812992 Gleitkomma-Bibliothek für AVR]

==FFT==

(Fast Fourier Transformation, "schnelle" Fouriertransformation)

* (A) [http://www.mikrocontroller.net/topic/25095#186536 FFT auf dem AVR]
* (A) [http://www.mikrocontroller.net/topic/25062#186225 128point FFT in ASM]
* (A) [http://www.mikrocontroller.net/topic/27001#203911 Schnelle FFT in Assembler]
* (C) [http://www.mikrocontroller.net/topic/131525#1191497 AVR-Lichtorgel per FFT MEGA8 32 644 ]

==Funksteckdosen==
* (C,A) [http://www.mikrocontroller.net/topic/31408#536372 Ansteuerung von Funksteckdosen mit einem Webserver]

==GPS==

(Global Positioning System, satellitengestütztes System zur weltweiten Positions- und Zeitbestimmung)

* (A) [http://www.mikrocontroller.net/topic/48544#371717 GPS - MOUSE - MINI- NAVIGATOR (Assembler) ATmega8]
* (C) [http://www.mikrocontroller.net/topic/72507#593252 GPS an mega8,88 oder 168]

==IR==
* siehe auch [[AVR Softwarepool#RC5|RC5]]
* (C) [http://www.mikrocontroller.net/topic/162119#1545798 IRMP - Infrared Multi Protocol Decoder]

==Kryptographie==
* (A,C) [http://www.mikrocontroller.net/topic/73468 Verschiedene kryptographische Funktionen]

==LANC==

(Steuerprotokoll für Video- und Digitalfotokameras, auch als Control-L bekannt)

* (C) [http://www.mikrocontroller.net/topic/40463#302754 Sony LANC Auswertung mit AVR] (Atmega 128 @ 16 MHz)

==LEDs und LED-Anzeigen==
* (C) [http://www.mikrocontroller.net/topic/76839#638278 Solarlicht Steuerung]
* (C) [http://www.mikrocontroller.net/topic/77863#648213 Taster + LED am selben Draht (4*)]
* (A) [http://www.mikrocontroller.net/topic/73776#606472 LED-Touch-Panel] (ARM)
* (A) [http://www.mikrocontroller.net/topic/74013#609097 RGB-Moodlight auf ATTiny2313 mit RC5-Fernbedienung]
* (C) [http://www.mikrocontroller.net/topic/54561#421940 HSV RGB Led Dimmer, C Code & Video & Doku]
* (A) [http://www.mikrocontroller.net/topic/67567#543492 Mini RGB Lichteffektgenerator mit Menü für Pic16F84]
* (C) [http://www.mikrocontroller.net/topic/48464#370871 Ansteuerung einer RGB LED (PWM)]
* (A) [http://www.mikrocontroller.net/topic/87149#737282 3x7 Segment und 1 I/O-Pin (Assembler)]
* (C) [http://www.mikrocontroller.net/topic/31370#240843 ADC mit Multiplexanzeige] (vier 7-Segmentanzeigen)
* (A) [http://www.mikrocontroller.net/topic/31388#241192 AVR-Lauflicht]
* (A) [http://www.mikrocontroller.net/topic/94746#815809 HSB->RGB Umrechnung rein in Assembler, auch für ATiny]
* (C) [http://www.mikrocontroller.net/topic/99803#866081 Glühwürmchen in Rotkohlglas gefangen]
* (A) [http://www.mikrocontroller.net/topic/110168 2x7-Segment an nur 3 Leitungen]
* (A) [[Ambilight in Hardware]]
* (A) [http://www.mikrocontroller.net/topic/145156#1346531 µCke Microcontroller Mücke (Atmel Tiny13)]
* (C) [http://www.mikrocontroller.net/topic/131525#1191497 AVR-Lichtorgel per FFT MEGA8 32 644 ]
* (B) [http://www.mikrocontroller.net/topic/182305 TLC5940 16-Kanal 12bit LED Treiber ansteuern und HighPower LEDs über MosFETs treiben]

==LCD und VFD==
* (C) [http://bluematrixi.bl.funpic.de/index.php/elektronik-avr/lcd-display-nokia3310 Bibliothek für Nokia 3310 Lcd Ansteuerung in "C" - sehr gut]
*(C,A)[http://www.mikrocontroller.net/articles/Ansteuerung_Handy_Displays Ansteuerung_Handy_Displays]
* (PC) [http://www.mikrocontroller.net/topic/53137#413137 Programm zum Erstellen eigener Schriftarten (LCD)]
* (PC) [http://www.mikrocontroller.net/topic/54860#423255 LCD Schriftarten ( Fonts in veschiedenen Größen )]
* (C) [http://www.mikrocontroller.net/topic/31403 The Siemens S65 132x176, 65536 color display with AVR]
* (C) [http://www.mikrocontroller.net/topic/48501#371218 LCD Ansteuerung im 4bit-Modus]
* (C) [http://www.mikrocontroller.net/topic/48456#370782 LCD Library T6963c]
* (C) [http://www.mikrocontroller.net/topic/76399#633680 "Bessere" T6963c Library]
* (C) [http://www.mikrocontroller.net/topic/25099#186569 LCD Controller für 640x480 LCD mit mega8515]
* (C) [http://www.mikrocontroller.net/topic/38923#287939 LCD Controller KS0073 Support im 4-Bit Mode]
* (A) [http://www.mikrocontroller.net/topic/79609#664268 KS0066U oder Ähnliche --- LCD Treiber]
* (C) [http://www.mikrocontroller.net/topic/81793#683135 Pollin E0855-2 SED1530-Treiber]
* (C) [http://www.mikrocontroller.net/topic/90449#772843 LCD über nur einen IO-Pin ansteuern]
* (C) [http://www.mikrocontroller.net/topic/120475 VFD Library (Vacuum Fluorescent Display Library)]
* (C) [http://www.mikrocontroller.net/topic/98321#851423 Grafikfähiger LCD Controller für 320x240 LCD mit 4 Graustufen]
* (C) [http://www.mikrocontroller.net/topic/140369 Menüsystem für beliebige schwarz-weiß LCDs bis 4096x4096 Pixeln und grafischem Editor]

==I2C==
* (C) [http://www.mikrocontroller.net/topic/98923#857451 Ultraschall Entfernungsmesser mit I2C, Eigenbau]
* (C) [http://www.mikrocontroller.net/topic/83871#new I2C-Master realisiert in Software, ohne TWI für alle ATMEGAs]
* (C) [http://www.mikrocontroller.net/topic/38919#new RS232 <-> TWI / I2C Interface für ATMega8 (ASM) inkl. Windows Software]
* (C) [http://www.mikrocontroller.net/topic/67698#544930 USI TWI Master]

==Messgeräte==
===Drehzahlmesser===
* (B) [http://www.mikrocontroller.net/topic/1518#8469 Drehzahlmesser 4 mal 7-Segment mit 90S2313]
* (C) [http://www.mikrocontroller.net/articles/Drehzahlmesser Drehzahlmesser mit 4 mal 7-Segment anzeigen mit Tiny2313, Wiki-Artikel]

===Entfernungsmesser===
* (C) [http://www.mikrocontroller.net/topic/98923#857451 Ultraschall Entfernungsmesser mit I2C, Eigenbau]
* (C) [http://www.mikrocontroller.net/topic/130834 3D Umgebungserfassung mit einem auf zwei Servors montiertem Sharp Distanzsensor, Eigenbau]

===Frequenzmesser===
* (A) [http://www.mikrocontroller.net/topic/62610#495030 Frequenzmesser bis 2Mhz -- mit AVR ATmega8]
* (C) [http://www.mikrocontroller.net/topic/48582#372072 Frequenzmessung]
* (C) [http://www.mikrocontroller.net/topic/62517#494146 Input Capture Pin (ICP) auslesen ( Frequenz messen)]
* (C) [http://www.mikrocontroller.net/topic/25144#187587 Frequenzmessung und Impulszählung über den Parallelport-IR]
* (A) [http://www.mikrocontroller.net/topic/31394#241251 einfacher 5 MHz Frequenzzähler (Assembler) ATmega8]
* (A) [http://www.mikrocontroller.net/topic/69021#558098 Multimeter]
* (C) [http://www.mikrocontroller.net/topic/173665#new sehr genauer Frequenzmesser Atmega8]

===Frequenzgenerator===
* (B) [http://www.mikrocontroller.net/topic/152966#1438488 Einstellbarer Frequenzgenerator für 0.12 Hz - 8 MHz mit Atmega 8 und Bascom ]

===Kompass===
* (A) [http://www.mikrocontroller.net/topic/100239#870281 KOMPASS KMZ10A KMZ10B ATmega8 Assembler]

===Messgeräte für elektronische Bauteile===
* (A) [http://www.mikrocontroller.net/topic/69021#558098 Multimeter]
* (A) [http://www.mikrocontroller.net/topic/60797#477026 LC-METER / LC-Messgerät ATmega8 Assembler]
* (A) [http://www.mikrocontroller.net/topic/60591#474873 Widerstandstester]
* (A) [http://www.mikrocontroller.net/topic/56770#438957 Ladungsmessgerät]
* (A) [http://www.mikrocontroller.net/topic/31386#241139 Transistortester]
* (C) [http://www.mikrocontroller.net/topic/131804#1194273 Transistortester]

===Spannungsmesser===
* (C) [http://www.mikrocontroller.net/topic/31370#240843 ADC mit Multiplexanzeige] - Voltmeter
* (A) [http://www.mikrocontroller.net/topic/69021#558098 Multimeter]

===Thermometer===
* (C) [http://www.mikrocontroller.net/topic/6516#41903 Zeit + Temperatur auf LCD mit AVR]
* (C) [http://www.mikrocontroller.net/topic/53127#413006 Thermometer mit LED & LM35]
* (C) [http://www.mikrocontroller.net/topic/31408#536372 Viele DS18x20-Thermometer in einem Webserver]

===Oszilloskop===
* (B) [http://www.mikrocontroller.net/topic/53129#413011 Einfaches Oszilloskop - Bascom]
* (A) [http://www.mikrocontroller.net/topic/48586#372093 Oszi- & Logikanalyser mit LCD]
* (A) [http://www.mikrocontroller.net/topic/31376#240880 einfaches DIGITAL- Oszilloskop (800 Datenpunkte) Assembler]
* (A) [http://www.mikrocontroller.net/topic/56616#437772 Einfaches "Oszilloskop"]

==MIDI==

(Musical Instrument Digital Interface, Datenübertragungsstandard für Musikinstrumente)

* (C) [http://www.mikrocontroller.net/topic/48542#371695 Mr.MidiPlayer - Spielt alle MIDI-Dateien von einer SD-Karte] (siehe auch: [[Midi_Rekorder_mit_MMC/SD-Karte]])
* (C) [http://www.mikrocontroller.net/topic/25035#185861 MIDI-Rekorder mit SD/MMC und AVR]
* (A) [http://www.mikrocontroller.net/topic/106512# Drum-Trigger mit MIDI-Ausgabe]
* (C) [http://www.mikrocontroller.net/topic/159760#1517791 Drum-Trigger mit USB-Midi-Ausgabe]

==MMC==

(Multimedia Card, digitales Flash-Speichermedium)

* (C) [http://www.mikrocontroller.net/topic/25056#186117 SourceCode MMC die Zweite]
* (C) [http://www.mikrocontroller.net/topic/48481#370950 MMC/SD-Karte mit FAT16 an AVR]
* (C) [http://www.mikrocontroller.net/topic/67047#538510 MMC/SD Bootloader füt ATMega16]
* (C) [http://www.mikrocontroller.net/topic/14800#102024 MMC/SD ansteuern mit AVR]
* (C) [http://www.mikrocontroller.net/topic/25035#185861 MIDI-Rekorder mit SD/MMC und AVR]
* (C) [http://www.mikrocontroller.net/articles/FAT32 MMC/SD - FAT16/32 Bibliothek für AVR mit Wiki]

==Netzgeräte==
* [http://www.mikrocontroller.net/topic/60786#476904 Labornetzgerät]
* [[RADLAB-PS1]] [http://www.mikrocontroller.net/topic/124858#1138781 Netzteil um LM317 mit Strombegrenzung und Anzeige!]

==Netzwerk==
* (C) [http://www.mikrocontroller.net/topic/87517#new Kleiner ENC28J60 µWebserver von SimonK]
* (C) [http://www.mikrocontroller.net/topic/82127#new Ulrich Radigs ENC28J60 mit leicht lötbaren/beschaffbaren Bauteilen]
* (C) [http://www.mikrocontroller.net/topic/131825 Dirk Broßwick Webserver auf ENC28j60 Basis mit einem ATmega2561, es gibt auch einen Port auf das AVR-NET IO]

==Parser==
* (C) [http://www.mikrocontroller.net/topic/64763#517245 Zwei Parser für numerische Ausdrücke]
* (C) [http://www.mikrocontroller.net/topic/76842#638283 uShell - ein universeller Parser für uCs]

==RFID==

(Radio Frequency Identification, Verfahren zur funkbasierten Identifizierung und Lokalisierung von Gegenständen)

* (C) [http://www.mikrocontroller.net/topic/68442#552128 USB RFID Tag Leser]

==RC - Fernsteuerungen/Servos==
* (C) [http://www.mikrocontroller.net/topic/48529#371582 RC Summen Signal erzeugen ]
==RC5==

(verbreitetes Datenübertragungsprotokoll für Infrarot-Fernbedienungen)

* (A) [http://www.mikrocontroller.net/topic/14789#101536 RC5 Sender auf einem Attiny11L]
* (C) [http://www.mikrocontroller.net/topic/74013#609097 RGB-Moodlight auf ATTiny2313 mit RC5-Fernbedienung]
* (C) [http://www.mikrocontroller.net/topic/12216#80856 Fernbedien RC5 Empfänger]
* (C) [http://www.mikrocontroller.net/topic/59235#460765 RC5 Sender selber bauen ???]

==Ringpuffer==
* (A) [http://www.mikrocontroller.net/topic/66789#536189 Ringpuffer AVR]
* (C) [http://www.mikrocontroller.net/topic/101472#882716 AVR-GCC: UART mit FIFO]

==SD==

(Secure Digital Memory Card; digitales Flash-Speichermedium)

* (C) [http://www.mikrocontroller.net/topic/48542#371695 Mr.MidiPlayer - Spielt alle MIDI-Dateien von einer SD-Karte] (siehe auch: [[Midi_Rekorder_mit_MMC/SD-Karte]])
* (C) [http://www.mikrocontroller.net/topic/25035#185861 MIDI-Rekorder mit SD/MMC und AVR]
* (C) [http://www.mikrocontroller.net/topic/68257#550336 Datenrekorder auf SD-Karte mit mega88]

==Sonstiges==

* (C) [http://www.mikrocontroller.net/topic/111783#994358 Sonnenstandberechnung mit Atmega 8]

==Spaßprojekte==
* (C) [http://www.mikrocontroller.net/topic/99803#866081 Glühwürmchen in Rotkohlglas gefangen]
* (C) [http://www.mikrocontroller.net/topic/119876#1083044 Miniprojekt: Lagerfeuer-LED (ATtiny25)]
* (C) [http://www.mikrocontroller.net/topic/120289#1087905 Klingel mit 100 Melodien - last minute Weihnachtsgeschenk]
* (A) [http://www.mikrocontroller.net/topic/145156#1346531 µCke Microcontroller Mücke (Atmel Tiny13)]
* (C) [http://www.mikrocontroller.net/topic/167528#1601077 Toastbrote zählen]

==Spiele==
* (C) [http://www.mikrocontroller.net/topic/48505#371259 Tetris auf dem AtMega8]
==Steuerungen==
* (C) [http://www.mikrocontroller.net/topic/123551 Aquarium Controller]

==Taster / Schalter==
===mechanisch===
* (A) [http://www.mikrocontroller.net/topic/6492#41625 Tasten entprellen - Bulletproof] (siehe auch: [[Entprellung]])
* (C) [http://www.mikrocontroller.net/topic/48465#370877 Universelle Tastenabfrage]
* (C) [http://www.mikrocontroller.net/topic/6491#41624 Tasten-Matrix entprellen]
* (C) [http://www.mikrocontroller.net/topic/64731#517001 Tastenmatrix auslesen über nur 2 Leitungen]
* (C) [http://www.mikrocontroller.net/topic/64743#517105 Tasten Entprellen für N00bs]
* (C) [http://www.mikrocontroller.net/topic/77863#648213 Taster + LED am selben Draht (4*)]
===kapazitiv===
* (C) [http://www.mikrocontroller.net/topic/38904 Sensor mit nur einer Kontaktfläche]
* (C) [http://www.mikrocontroller.net/topic/25045 Einfache Sensortaste]

==Tonerzeugung==
* (A) [http://www.mikrocontroller.net/topic/66945#537624 ATMEGA8 Soundgenerator/Synthesizer]
* (C) [http://www.mikrocontroller.net/topic/120289#1087905 Klingel mit 100 Melodien - last minute Weihnachtsgeschenk]
* (C) [http://www.mikrocontroller.net/topic/134362 RTTTL Melodiegenerator mit ATTINY85]
* (A) [http://www.mikrocontroller.net/topic/25051 Melodie ausgeben mit AVR ATTiny12]
* (A) [http://www.mikrocontroller.net/topic/145156#1346531 µCke Microcontroller Mücke (Atmel Tiny13)]

==TWI==
* (C) [http://www.mikrocontroller.net/topic/87597#742070 AVR TWI Master und Slave Funtionen in C]
* (A) [http://www.mikrocontroller.net/topic/31404#242081 TWI / I2C einf. MASTER SLAVE Beispiel(Assembler) ATmega8]

==USB==
* (C) [http://www.mikrocontroller.net/topic/75254#622120 USB Host Stack für Eingebettete Systeme (LGPL)]
* (C) [http://www.mikrocontroller.net/topic/68442#552128 USB RFID Tag Leser]
* (A,C) [http://www.mikrocontroller.net/topic/92979#797957 AVR ATmega8TestBoard]
* (C) [http://www.mikrocontroller.net/topic/90791#776280 Relaiskarte für den USB Port]
* (C) [http://www.mikrocontroller.net/topic/130381#1179352 USB-Stick am Mikrocontroller VNC1L]
* (C) [http://www.mikrocontroller.net/topic/155241 PDIUSBD12 Treiber und micro USB-Device stack]

==UART==
* (C) [http://www.mikrocontroller.net/topic/101472#882716 AVR-GCC: UART mit FIFO]
* (C) [http://www.mikrocontroller.net/topic/38928#287985 Software UART]
* (C) [http://www.mikrocontroller.net/topic/125651#1147436 Software UART mit FIFO]

==Video==
* (A) [http://www.mikrocontroller.net/topic/53140#413249 AVR ASCII Video Terminal - 40 x 25 - BAS Signal]
* (A) [http://www.mikrocontroller.net/topic/53139#413225 TV VIDEO BILD BAS Frequenzzähler DVM Atmega8 Assembler]
* (A) [http://www.electronicspit.com/video/ Videosignal in Farbe aus dem ATMega32]
* (A) [http://www.mikrocontroller.net/topic/25091#new VGA Testbildgenerator]
* (C) [http://www.mikrocontroller.net/topic/101429#882288 ATmega8 erzeugt Video in C!]

==Zeitgeber und Uhren==
* (A) [http://www.mikrocontroller.net/topic/12185#80055 Die genaue Sekunde / RTC]
* (A) [http://www.mikrocontroller.net/topic/74673#616226 LCD-Timer für Belichtungsgerät]
* (A) [http://www.mikrocontroller.net/topic/119859#1082804 DS1307 Assembler-Code]
* (C) [http://www.mikrocontroller.net/topic/31374#240878 AVR Library für RTC 12C887 in C]
* (C) [http://www.mikrocontroller.net/topic/25136#187534 RTC DS1302 in C]
* (C) [http://www.mikrocontroller.net/topic/25087#186454 RTC + Scheduler]
* (C) [http://www.mikrocontroller.net/topic/53131#413059 Jumbo-LED Uhr]
* (C) [http://www.mikrocontroller.net/topic/6516#41903 Zeit + Temperatur auf LCD mit AVR]
* (C) [http://www.mikrocontroller.net/topic/25069 Sekunden in Zeit/Datum umwandeln (mit Sommerzeit/Schaltjahren)]
* (B) [http://www.mikrocontroller.net/topic/48560#371911 BASCOM Uhr mit Butterfly]
* (C) [http://www.mikrocontroller.net/topic/48450#370765 Countdown timer für UV Belichter]
* (C) [http://www.mikrocontroller.net/topic/98885 Countdown Timer mit ATtiny2313]
* (C) [http://www.mikrocontroller.net/topic/12176#79672 Wartezeiten effektiv (Scheduler)]
* (C) [http://www.mikrocontroller.net/topic/31408#536372 Schaltuhr mit DCF77-Referenz in einem Webserver, Steuerung von Funksteckdosen]
* (C) [http://www.mikrocontroller.net/topic/100892#876549 Eieruhr mit ATtiny24V/ATtiny2313V]
* (B) [http://www.mikrocontroller.net/topic/151236 Zeitauslöser für Casio EX F1 mit Attiny2313]
* (A) [http://www.mikrocontroller.net/topic/151260#1419218 DCF77 Uhr 7 Segment LED ATmega8 Assembler]
* (C) [http://www.mikrocontroller.net/topic/177688# NIXIE Uhr mit vielen Funktionen in C mit ATTiny2313]

== Siehe auch ==

* [[AVR-Codesammlung Übersicht]]

[[Category:AVR| ]]
[[Kategorie:Forum]]

Spule

2010-05-04T13:32:37Z

Mixer: /* Berechnungsformeln für Spulen */

== Einleitung ==

Spulen sind Bauelemente, welche mittels Magnetfeld Energie speichern, übertragen oder umwandeln (transformieren) können. Sie bestehen prinzipiell aus einem isolierten Draht, welcher in bestimmter Weise auf einen magnetisch wirksamen Kern aufgewickelt wurde. Sie werden in nahezu unzähligen Varianten in der Elektronik eingesetzt, von winzigen SMD-Bauteilen bis zu haushohen Transformatoren.

== Vereinfachte Erklärung ==

Während man sich einen Kondensator wie eine Art Lager für Elektronen vorstellen kann, und einen Widerstand wie ein mehr oder weniger enges Rohr für einen Wasserfluß, ist eine Analogie aus dem täglichen Leben für eine Spule ein Schwungrad. Man hat eine Antriebskraft, mit der man eine Achse in Bewegung setzen möchten, aber auf dieser ist ein großes Schwungrad befestigt. Damit sich die Antriebskraft in der Bewegung der Achse bemerkbar machen kann, muss das Schwungrad mit in Bewegung gesetzt werden, was nur langsam, nach und nach möglich ist, und wenn es sich einmal dreht, möchte es nach dem Beenden der Einwirkung der Antriebskraft zunächst einmal in derselben Richtung weiterlaufen, es kann nicht sofort abgebremst werden, und wenn man versucht, das drehende Schwungrad zu blockieren, wird bei diesem plötzlichen Abbremsen eine gewaltige Kraft freigesetzt.

Eine Spule verhält sich ähnlich. Sie ist stets bestrebt, den Stromfluß aufrecht zu erhalten, sprich sie verzögert eine schnelle Änderung des Stromflusses. Soll der Strom ansteigen, muss zunächst ein Magnetfeld aufgebaut werden, das dauert je nach anliegender Spannung und Induktivität der Spule eine gewisse Zeit. Hier wird Energie gespeichert. Soll der Stromfluß abnehmen, muss das Magnetfeld erst abgebaut werden, hier wird Energie in den Stromkreis zurückgeführt.

Diese Eigenschaft ist sehr wichtig für [[Transformatoren und Spulen]] in Schaltnetzteilen, Filtern und vielen anderen Anwendungen. Das Maß, wieviel Magnetfeld bei einem bestimmten Strom in der Spule gespeichert werden kann, wird mit dem Begriff Induktivität ausgedrückt.

Manchmal ist eine Spule aber auch von Nachteil, wenn die nämlich ungewollt die schnelle Änderung des Stromflusses bremst. Das ist meist dann der Fall, wenn Bauteile zu lange Anschlussdrähte oder Zuleitungen haben. Hier spricht man von parasitärer Induktivität.

== Berechnungsformeln für Spulen ==

Eine wichtige Formel ist die zur Definition der Induktivität. Das ist der charakteristischste Parameter einer Spule.

<math>L=\frac{U \cdot t}{I}</math>

Diese Formel ist vor allem für die Beschreibung des elektrischen Verhaltens einer Spule mit bekannter Induktivität wichtig. Sie sagt aus, dass wenn man an eine Spule mit 1H eine Spannung von 1V für 1s anlegt, steigt der Strom um 1A (Rampenfunktion).

D.h. die Spule integriert (sammelt) eine an ihren Klemmen anliegende Spannung und baut damit ein Magnetfeld auf. Die Folge davon ist ein Stromfluß durch die Spule. Das ist das Gegenteil eines Kondensators. Dieser integriert (sammelt) einen an seinen Klemmen eingespeisten Strom und baut damit ein elektrisches Feld auf. Die Folge davon ist eine Spannung zwischen den Klemmen.

In praktischen Anwendungen wickelt man [http://de.wikipedia.org/wiki/Spule_%28Elektrotechnik%29 Spulen] meist auf fertige Spulenkörper mit zugehörigen Kernen. Die Induktivität berechnet sich aus

<math>L=A_L \cdot N^2</math>

Der <math>A_L</math>-Wert ist der Kehrwert des magnetischen Widerstands der Spule (Der Raum um den Drahtwickel) und beinhaltet sowohl die Geometrie als auch das Material des Kerns. Er wird im Datenblatt des Kerns angegeben, kann aber ggf. auch berechnet werden. Wichtig ist zu wissen, dass die Induktivität quadratisch von der Windungszahl abhängt, d.h. bei doppelter Windungszahl erhält man die vierfache Induktivität.

== Hinweise zur Spulenauswahl ==

=== Allgemeines ===

Vor allem bei Schaltreglern sind folgende Daten der Spulen wichtig:

* Induktivität
* Drahtwiderstand
* Maximaler Strom
* Sättigungsstrom

==== Induktivität ====

Die Induktivität gibt an, wie schnell sich der Strom bei einer anliegenden Spannung ändert. Üblicherweise berechnet man bei der Dimensionierung die minimale Spulengröße die notwendig ist, damit der Ripple des Stromes einen bestimmten Wert (typisch 50% des Ausgangsstroms bei einem StepDown) nicht überschreitet. Eine zu große Induktivität stört bei einem StepDown Regler meist nicht. Bei einem StepUp dagegen darf diese einen bestimmten Wert nicht überschreiten, damit der Regler die gewünschte Leistung liefern kann wie im StepUp Abschnitt beschrieben.
Die Induktivität ist nicht konstant, sondern ändert sich je nach vorhandenem Kern mehr oder weniger mit Frequenz oder Strom.
Vor allem Eisenpulverkerne weisen eine ausgeprägte Abhängigkeit der Induktivität von Frequenz und Strom ab.
Die Induktivität mit Nennstrom ist daher meist etwas geringer als die Induktivität ohne Stromfluss. Dies sollte bei der Spulendimensionierung beachtet werden.
Aufgrund der starken Stromabhängigkeit erfolgt die Angabe der Induktivität bei Spulen mit Eisenpulverkernen häufig auch bei Nennstrom. Ohne Strombelastung liegt die Induktivität etwa Faktor 1,2-2 darüber. Bei Spulen mit Ferittkern dagegen wird die Induktivität meist ohne Strombelastung spezifiziert.

==== Drahtwiderstand ====

Der Drahtwiderstand beeinflusst vor allem den Wirkungsgrad der Schaltung bzw. begrenzt den maximal zulässigen Effektivwert des Stromes der durch die Spule fließt. Vor allem bei StepUp Wandlern sollte man sich dem Einfluss des Spulenwiderstands bemerkbar sein: Möchte man z. B. aus 5V eine höhere Spannung erzeugen und verwendet eine Spule mit 2 Ohm die mit 0,5A angesteuert wird, dann fallen an dem Drahtwiderstand bereits 1Volt ab. Das entspricht 20% der Eingangsspannung!

==== Maximaler Strom ====

Der maximale Strom wird meist anhand der Erwärmung der Spule durch einen bestimmten Strom bestimmt. Oft ist dies der Punkt bei der sich die Spule um z. B. 40°C erwärmt. Häufig wird dies mit Gleichspannung gemessen oder bei einer niedrigen Frequenz deren Effektivwert angegeben wird. Bei Verwendung der Spule in einem Schaltregler reduziert sich dieser Wert daher um bis zu 50%, da einerseits der Sättigungsstrom beachtet werden muss und andererseits auch der Kern innerhalb der Spule sich auch erwärmt. Vor allem Eisenpulverkerne besitzen teilweise recht hohe Kernverluste, die bei einer üblichen Dimensionierung im gleichen Bereich wie die Verluste durch den Drahtwiderstand liegen.
Der Spitzenstrom darf diesen Stromwert allerdings übersteigen, solange der Effektivwert bzw. die Erwärmung im zulässigen Bereich liegt.

==== Sättigungsstrom ====

Der Sättigungsstrom ist fast schon das wichtigste Kriterium bei der Spulenauswahl, denn wenn dieser Wert zu gering ist, ist die Spule unbrauchbar für die Schaltung.
Wie bei den Induktivität schon geschrieben, ist diese mehr oder weniger abhängig vom Spulenstrom. Der Sättigungsstrom (der bei für Schaltnetzteilanwendungen gedachten Spulen immer angegeben ist), gibt meist den Strom an, bei dem die Induktivität um 10-40% gegenüber der Nenninduktivität gefallen ist. Erhöht man den Strom weiter, nimmt die Induktivität je nach Kernmaterial und mechanischem Aufbau schnell ab, eine Verringerung um den Faktor 10 ist keine Seltenheit.

Der Sättigungsstrom wird bei einem ordentlich dimensionierten Schaltregler nie überschritten werden, da die Strombegrenzung vorher anspricht. Bei einem schlechten Design spricht die Strombegrenzung dagegen erst durch den hohen Strom an, wenn die Spule in die Sättigung geht. Dies führt nur zu unnötigen Verlusten und sollte daher vermieden werden.

Für den MC34063 heißt dies konkret, dass der Strombegrenzungswiderstand Rsc auf einen Wert unterhalb des Sättigungsstromes dimensioniert werden muss!
Da die Induktivität einer Spule in der Sättigung minimal ist, kann diese auch keine weitere Energie speichern. Ein Großteil der in die Spule fließenden Energie wird daher im Drahtwiderstand in Wärme umgesetzt was den Wirkungsgrad stark reduziert und eventuell die Regelung des Schaltreglers durcheinander bringt.

Bei einer typischen, für Schaltnetzteile entworfenen Spule, liegt der Sättigungsstrom etwa Faktor 1,5-2 über dem Nennstrom. Dies erlaubt den Nennstrom voll auszunutzen, da der Stromripple bei der üblichen Spulendimensionierung bei etwa 50% des Nennstroms, der Spitzenstrom also bei etwa 1,5x Nennstrom liegt.

Der durch den Begrenzungswiderstand definierte Strom kann auch im Leerlauf ohne Last auftreten, geringe Last schützt also nicht vor Sättigung!

=== Ferritkern vs. Eisenpulverringkern ===

Der Großteil der Energie einer Spule wird nicht direkt im Kern, sondern in einem Luftspalt des Kerns gespeichert. Daher benötigt jede Spule für ein Schaltnetzteil, welche zur Energiespeicherung genutzt wird, einen mehr oder weniger großen Luftspalt. Je größer der Luftspalt, desto mehr Energie kann die Spule speichern, allerdings benötigt man mehr Windungen um eine bestimmte Induktivität zu erreichen. Das gilt für Sperrwandler sowie Speicherdrosseln in Flußwandlern. Echte Trafos, wie z. B. im Flusswandler, dürfen möglichst keinen Luftspalt besitzen.
Die in Übertragern oder stromkompensierten Drosseln eingesetzten Ferritringkerne besitzen kein Luftspalt. Daher können sie kaum Energie speichern, sind daher auch nicht für Speicherdrosseln oder Sperrwandler geeignet. Dafür erreichen diese mit wenigen Windungen schnell Induktivitäten im mH Bereich, wozu andere Spulen etliche 100 Windungen benötigen.
Eisenpulverringkerne gehen einen anderen Weg: Hier stellen die minimalen, mit Kunststoff gefüllten Zwischenräume zwischen den einzelnen Teilchen bereits den Luftspalt dar, weshalb hier kein zusätzlicher Luftspalt erforderlich ist.
Die hierfür verwendeten Materialien besitzen allerdings deutlich höhere Ummagnetisierungsverluste als Ferrit, weshalb Eisenpulverringkerne üblicherweise nur für niedrige Frequenzen eingesetzt werden. Das am weitesten verbreitete Material sind die gelb-weiß markierten Ringkerne mit dem Materialcode 26. Dieses zeichnet sich vor allem durch die niedrigen Kosten aus. Der Einsatzbereich liegt entweder in Entstördrosseln für Gleichstrom- oder 50Hz Anwendungen oder in Schaltnetzteilen bis 100kHz. Für höhere Frequenzen sind auch bessere, und natürlich teurere Materialien, erhältlich.
Dieser Spulentyp ist vor allem für Abwärtswandler sinnvoll, da Eisenpulverkerne kein Problem mit hohen DC Strömen, allerdings mit hohen AC Anteilen aufgrund der Kernverluste haben. Da der Stromripple bei diesem Wandlertyp meist kleiner als der DC Strom ist, sind beide Bedingungen erfüllt. Allerdings sollte man beachten, dass die Induktivität einer Eisenpulverringkernspule stark von der Frequenz, dem Strom und auch vom Alter abhängig ist! Je nach Temperatur altern Eisenpulverringkerne mehr oder weniger schnell und die Spule verliert dabei an Induktivität.
Die Dimensionierung einer Eisenpulverringkernspule ist alles andere als einfach, da hier sehr viele Faktoren beachtet werden müssen. Die Berechnung der Kernverluste ist auch aufwendig, einige Hersteller liefern dafür aber Formeln oder Berechnungsprogramme, so wie z. B. Micrometals:
[http://www.micrometals.com/software_index.html Berechnungsprogramm für Eisenpulverringkerne].
Vor allem Anfängern wird aber von der eigenen Dimensionierung von Eisenpulverringkernspulen abgeraten. Etliche Hersteller (wie z. B. Talema) haben fertige Ringkernspulen im Programm die bei verschiedenen Anbietern auch für Normalverbraucher erhältlich sind (z. B. bei elpro, DARISUS und vielen anderen).

=== Speicherspulen vs. Entstörspulen ===

Nicht selten machen vor allem Anfänger den Fehler die nächstbeste Spule mit einigermaßen passender Induktivität einzusetzen, ohne darauf zu achten, dass die Spule eigentlich als Entstörspule entwickelt wurde. Dies gilt vor allem für die Funkentstördrosseln der Baureihe MESC/MISC/77A die z. B. bei Reichelt erhältlich sind. Die Schaltungen funktionieren zwar einigermaßen, allerdings ist der Wirkungsgrad deutlich geringer als er es mit einer guten Spule wäre.
Dies liegt vor allem am Aufbau der Spule sowie deren vorhandenem Kern. Funkentstördrosseln sind dafür ausgelegt von einem niederfrequenten Strom durchflossen zu werden und eine, im Vergleich zum Nutzstrom niedrigen Störstrom abzublocken. Dadurch entstehen kaum Verluste im Kern, da das Magnetfeld konstant ist bzw. sich durch den niederfrequenten Strom nur sehr langsam ändert. Der Kern ist also nicht dafür ausgelegt verlustarm zu sein, bzw. es ist sogar erwünscht wenn er bei hohen Frequenzen gewisse Verluste aufweist, um Resonanzen innerhalb der Spule zu verhindern. Weiterhin kommt das Problem hinzu, dass aufgrund der hohen Länge der Spule die Feldlinien außerhalb der Spule den magnetischen Kreis schließen und sich so ein deutliches Magnetfeld um die Spule herum aufbaut, diese arbeitet quasi wie eine Ferittstabantenne und erzeugt beträchtliche EMV Störungen!
Speziell für Schaltnetzteile ausgelegte Spulen besitzen daher nicht selten einen entsprechenden mechanischen Aufbau um die Feldlinien möglichst innerhalb bzw. sehr nahe an der Spule zu halten um diese Störungen zu minimieren.

Besonders bei Spulen mit Eisenpulverringkernen sollte man genau nachschauen ob die Angaben für Entstöranwendungen oder für Schaltnetzteilanwendungen gelten: Hier wird oft die gleiche Spule je nach Verwendungszweck unterschiedlich spezifiziert. Dies liegt daran, dass man bei der Entstöranwendung eben kaum Verluste im Kern hat und somit aufgrund der geringeren Erwärmung der Draht von einem höheren Strom durchflossen werden kann, ohne dass er überhitzt.

=== Beispiele geeigneter Spulen für Schaltregler ===

[[Datei:Snt_spulen.jpg|thumb|250x250px|Verschiedene Spulen]]

Von links nach rechts:

*Speicherdrosseln: sehr gut geeignet
*Ringkernspulen: ja nach Anwendung gut bis sehr gut geeignet
*Widerstandsbauform, Trommelkern: für (sehr) kleine Leistungen geeignet
*Entstörspulen: schlecht geeignet
*Stromkompensierte Drosseln: absolut ungeeignet

Für kleinere Schaltregler in beliebiger Konfiguration (also StepUp, StepDown, invertierend) geeignete Spulen sind z. B. die L-PISxx Serien die z. B. bei Reichelt oder Conrad erhältlich sind, oder vergleichbare Spulen.
Aufgrund des Ferritkerns sind diese Spulen nahezu für alle üblichen Frequenzbereiche geeignet.
Für Stepdownregler unter 100kHz eignen sich auch Eisenpulverringkernspulen z. B. aus dem Material 26. Vor allem bei höheren Strömen sind diese oft deutlich günstiger als vergleichbare Spulen auf Ferritkern.

== Links ==

* [[Transformatoren und Spulen]]
* [[MC34063]]

== Weblinks ==

* [http://de.wikipedia.org/wiki/Induktivit%C3%A4t_%28Bauelement%29 Wikipedia: Induktivität]

[[Kategorie:Bauteile]]

Spule

2010-05-04T13:30:32Z

Mixer: /* Vereinfachte Erklärung */

== Einleitung ==

Spulen sind Bauelemente, welche mittels Magnetfeld Energie speichern, übertragen oder umwandeln (transformieren) können. Sie bestehen prinzipiell aus einem isolierten Draht, welcher in bestimmter Weise auf einen magnetisch wirksamen Kern aufgewickelt wurde. Sie werden in nahezu unzähligen Varianten in der Elektronik eingesetzt, von winzigen SMD-Bauteilen bis zu haushohen Transformatoren.

== Vereinfachte Erklärung ==

Während man sich einen Kondensator wie eine Art Lager für Elektronen vorstellen kann, und einen Widerstand wie ein mehr oder weniger enges Rohr für einen Wasserfluß, ist eine Analogie aus dem täglichen Leben für eine Spule ein Schwungrad. Man hat eine Antriebskraft, mit der man eine Achse in Bewegung setzen möchten, aber auf dieser ist ein großes Schwungrad befestigt. Damit sich die Antriebskraft in der Bewegung der Achse bemerkbar machen kann, muss das Schwungrad mit in Bewegung gesetzt werden, was nur langsam, nach und nach möglich ist, und wenn es sich einmal dreht, möchte es nach dem Beenden der Einwirkung der Antriebskraft zunächst einmal in derselben Richtung weiterlaufen, es kann nicht sofort abgebremst werden, und wenn man versucht, das drehende Schwungrad zu blockieren, wird bei diesem plötzlichen Abbremsen eine gewaltige Kraft freigesetzt.

Eine Spule verhält sich ähnlich. Sie ist stets bestrebt, den Stromfluß aufrecht zu erhalten, sprich sie verzögert eine schnelle Änderung des Stromflusses. Soll der Strom ansteigen, muss zunächst ein Magnetfeld aufgebaut werden, das dauert je nach anliegender Spannung und Induktivität der Spule eine gewisse Zeit. Hier wird Energie gespeichert. Soll der Stromfluß abnehmen, muss das Magnetfeld erst abgebaut werden, hier wird Energie in den Stromkreis zurückgeführt.

Diese Eigenschaft ist sehr wichtig für [[Transformatoren und Spulen]] in Schaltnetzteilen, Filtern und vielen anderen Anwendungen. Das Maß, wieviel Magnetfeld bei einem bestimmten Strom in der Spule gespeichert werden kann, wird mit dem Begriff Induktivität ausgedrückt.

Manchmal ist eine Spule aber auch von Nachteil, wenn die nämlich ungewollt die schnelle Änderung des Stromflusses bremst. Das ist meist dann der Fall, wenn Bauteile zu lange Anschlussdrähte oder Zuleitungen haben. Hier spricht man von parasitärer Induktivität.

== Berechnungsformeln für Spulen ==

Eine wichtige Formel ist die zur Definition der Induktivität. Das ist der charakteristischste Parameter einer Spule.

<math>L=\frac{U \cdot t}{I}</math>

Diese Formel ist vor allem für die Beschreibung des elektrischen Verhaltens einer Spule mit bekannter Induktivität wichtig. Sie sagt aus, dass wenn man an eine Spule mit 1H eine Spannung von 1V für 1s anlegt, steigt der Strom um 1A (Rampenfunktion).

D.h. die Spule integriert (sammelt) eine an ihren Klemmen anliegende Spannung und baut damit ein Magnetfeld auf. Die Folge davon ist ein Stromfluß durch die Spule. Das ist das Gegenteil eines Kondensators. Dieser integriert (sammelt) einen an seinen Klemmen eingespeisten Strom und baut damit ein elektrisches Feld auf. Die Folge davon ist eine Spannung zwischen den Klemmen.

In praktischen Anwendung wickelt man [http://de.wikipedia.org/wiki/Spule_%28Elektrotechnik%29 Spulen] meist auf fertige Spulenkörper mit zugehörigen Kernen. Die Induktivität berechnet sich aus

<math>L=A_L \cdot N^2</math>

Der <math>A_L</math>-Wert ist der Kehrwert des magnetischen Widerstands der Spule (Der Raum um den Drahtwickel) und beinhaltet sowohl die Geometrie als auch das Material des Kerns. Er wird im Datenblatt des Kerns angegeben, kann aber ggf. auch berechnet werden. Wichtig ist zu wissen, dass die Induktivität quadratisch von der Windungszahl abhängt, d.h. bei doppelter Windungszahl erhält man die vierfache Induktivität.

== Hinweise zur Spulenauswahl ==

=== Allgemeines ===

Vor allem bei Schaltreglern sind folgende Daten der Spulen wichtig:

* Induktivität
* Drahtwiderstand
* Maximaler Strom
* Sättigungsstrom

==== Induktivität ====

Die Induktivität gibt an, wie schnell sich der Strom bei einer anliegenden Spannung ändert. Üblicherweise berechnet man bei der Dimensionierung die minimale Spulengröße die notwendig ist, damit der Ripple des Stromes einen bestimmten Wert (typisch 50% des Ausgangsstroms bei einem StepDown) nicht überschreitet. Eine zu große Induktivität stört bei einem StepDown Regler meist nicht. Bei einem StepUp dagegen darf diese einen bestimmten Wert nicht überschreiten, damit der Regler die gewünschte Leistung liefern kann wie im StepUp Abschnitt beschrieben.
Die Induktivität ist nicht konstant, sondern ändert sich je nach vorhandenem Kern mehr oder weniger mit Frequenz oder Strom.
Vor allem Eisenpulverkerne weisen eine ausgeprägte Abhängigkeit der Induktivität von Frequenz und Strom ab.
Die Induktivität mit Nennstrom ist daher meist etwas geringer als die Induktivität ohne Stromfluss. Dies sollte bei der Spulendimensionierung beachtet werden.
Aufgrund der starken Stromabhängigkeit erfolgt die Angabe der Induktivität bei Spulen mit Eisenpulverkernen häufig auch bei Nennstrom. Ohne Strombelastung liegt die Induktivität etwa Faktor 1,2-2 darüber. Bei Spulen mit Ferittkern dagegen wird die Induktivität meist ohne Strombelastung spezifiziert.

==== Drahtwiderstand ====

Der Drahtwiderstand beeinflusst vor allem den Wirkungsgrad der Schaltung bzw. begrenzt den maximal zulässigen Effektivwert des Stromes der durch die Spule fließt. Vor allem bei StepUp Wandlern sollte man sich dem Einfluss des Spulenwiderstands bemerkbar sein: Möchte man z. B. aus 5V eine höhere Spannung erzeugen und verwendet eine Spule mit 2 Ohm die mit 0,5A angesteuert wird, dann fallen an dem Drahtwiderstand bereits 1Volt ab. Das entspricht 20% der Eingangsspannung!

==== Maximaler Strom ====

Der maximale Strom wird meist anhand der Erwärmung der Spule durch einen bestimmten Strom bestimmt. Oft ist dies der Punkt bei der sich die Spule um z. B. 40°C erwärmt. Häufig wird dies mit Gleichspannung gemessen oder bei einer niedrigen Frequenz deren Effektivwert angegeben wird. Bei Verwendung der Spule in einem Schaltregler reduziert sich dieser Wert daher um bis zu 50%, da einerseits der Sättigungsstrom beachtet werden muss und andererseits auch der Kern innerhalb der Spule sich auch erwärmt. Vor allem Eisenpulverkerne besitzen teilweise recht hohe Kernverluste, die bei einer üblichen Dimensionierung im gleichen Bereich wie die Verluste durch den Drahtwiderstand liegen.
Der Spitzenstrom darf diesen Stromwert allerdings übersteigen, solange der Effektivwert bzw. die Erwärmung im zulässigen Bereich liegt.

==== Sättigungsstrom ====

Der Sättigungsstrom ist fast schon das wichtigste Kriterium bei der Spulenauswahl, denn wenn dieser Wert zu gering ist, ist die Spule unbrauchbar für die Schaltung.
Wie bei den Induktivität schon geschrieben, ist diese mehr oder weniger abhängig vom Spulenstrom. Der Sättigungsstrom (der bei für Schaltnetzteilanwendungen gedachten Spulen immer angegeben ist), gibt meist den Strom an, bei dem die Induktivität um 10-40% gegenüber der Nenninduktivität gefallen ist. Erhöht man den Strom weiter, nimmt die Induktivität je nach Kernmaterial und mechanischem Aufbau schnell ab, eine Verringerung um den Faktor 10 ist keine Seltenheit.

Der Sättigungsstrom wird bei einem ordentlich dimensionierten Schaltregler nie überschritten werden, da die Strombegrenzung vorher anspricht. Bei einem schlechten Design spricht die Strombegrenzung dagegen erst durch den hohen Strom an, wenn die Spule in die Sättigung geht. Dies führt nur zu unnötigen Verlusten und sollte daher vermieden werden.

Für den MC34063 heißt dies konkret, dass der Strombegrenzungswiderstand Rsc auf einen Wert unterhalb des Sättigungsstromes dimensioniert werden muss!
Da die Induktivität einer Spule in der Sättigung minimal ist, kann diese auch keine weitere Energie speichern. Ein Großteil der in die Spule fließenden Energie wird daher im Drahtwiderstand in Wärme umgesetzt was den Wirkungsgrad stark reduziert und eventuell die Regelung des Schaltreglers durcheinander bringt.

Bei einer typischen, für Schaltnetzteile entworfenen Spule, liegt der Sättigungsstrom etwa Faktor 1,5-2 über dem Nennstrom. Dies erlaubt den Nennstrom voll auszunutzen, da der Stromripple bei der üblichen Spulendimensionierung bei etwa 50% des Nennstroms, der Spitzenstrom also bei etwa 1,5x Nennstrom liegt.

Der durch den Begrenzungswiderstand definierte Strom kann auch im Leerlauf ohne Last auftreten, geringe Last schützt also nicht vor Sättigung!

=== Ferritkern vs. Eisenpulverringkern ===

Der Großteil der Energie einer Spule wird nicht direkt im Kern, sondern in einem Luftspalt des Kerns gespeichert. Daher benötigt jede Spule für ein Schaltnetzteil, welche zur Energiespeicherung genutzt wird, einen mehr oder weniger großen Luftspalt. Je größer der Luftspalt, desto mehr Energie kann die Spule speichern, allerdings benötigt man mehr Windungen um eine bestimmte Induktivität zu erreichen. Das gilt für Sperrwandler sowie Speicherdrosseln in Flußwandlern. Echte Trafos, wie z. B. im Flusswandler, dürfen möglichst keinen Luftspalt besitzen.
Die in Übertragern oder stromkompensierten Drosseln eingesetzten Ferritringkerne besitzen kein Luftspalt. Daher können sie kaum Energie speichern, sind daher auch nicht für Speicherdrosseln oder Sperrwandler geeignet. Dafür erreichen diese mit wenigen Windungen schnell Induktivitäten im mH Bereich, wozu andere Spulen etliche 100 Windungen benötigen.
Eisenpulverringkerne gehen einen anderen Weg: Hier stellen die minimalen, mit Kunststoff gefüllten Zwischenräume zwischen den einzelnen Teilchen bereits den Luftspalt dar, weshalb hier kein zusätzlicher Luftspalt erforderlich ist.
Die hierfür verwendeten Materialien besitzen allerdings deutlich höhere Ummagnetisierungsverluste als Ferrit, weshalb Eisenpulverringkerne üblicherweise nur für niedrige Frequenzen eingesetzt werden. Das am weitesten verbreitete Material sind die gelb-weiß markierten Ringkerne mit dem Materialcode 26. Dieses zeichnet sich vor allem durch die niedrigen Kosten aus. Der Einsatzbereich liegt entweder in Entstördrosseln für Gleichstrom- oder 50Hz Anwendungen oder in Schaltnetzteilen bis 100kHz. Für höhere Frequenzen sind auch bessere, und natürlich teurere Materialien, erhältlich.
Dieser Spulentyp ist vor allem für Abwärtswandler sinnvoll, da Eisenpulverkerne kein Problem mit hohen DC Strömen, allerdings mit hohen AC Anteilen aufgrund der Kernverluste haben. Da der Stromripple bei diesem Wandlertyp meist kleiner als der DC Strom ist, sind beide Bedingungen erfüllt. Allerdings sollte man beachten, dass die Induktivität einer Eisenpulverringkernspule stark von der Frequenz, dem Strom und auch vom Alter abhängig ist! Je nach Temperatur altern Eisenpulverringkerne mehr oder weniger schnell und die Spule verliert dabei an Induktivität.
Die Dimensionierung einer Eisenpulverringkernspule ist alles andere als einfach, da hier sehr viele Faktoren beachtet werden müssen. Die Berechnung der Kernverluste ist auch aufwendig, einige Hersteller liefern dafür aber Formeln oder Berechnungsprogramme, so wie z. B. Micrometals:
[http://www.micrometals.com/software_index.html Berechnungsprogramm für Eisenpulverringkerne].
Vor allem Anfängern wird aber von der eigenen Dimensionierung von Eisenpulverringkernspulen abgeraten. Etliche Hersteller (wie z. B. Talema) haben fertige Ringkernspulen im Programm die bei verschiedenen Anbietern auch für Normalverbraucher erhältlich sind (z. B. bei elpro, DARISUS und vielen anderen).

=== Speicherspulen vs. Entstörspulen ===

Nicht selten machen vor allem Anfänger den Fehler die nächstbeste Spule mit einigermaßen passender Induktivität einzusetzen, ohne darauf zu achten, dass die Spule eigentlich als Entstörspule entwickelt wurde. Dies gilt vor allem für die Funkentstördrosseln der Baureihe MESC/MISC/77A die z. B. bei Reichelt erhältlich sind. Die Schaltungen funktionieren zwar einigermaßen, allerdings ist der Wirkungsgrad deutlich geringer als er es mit einer guten Spule wäre.
Dies liegt vor allem am Aufbau der Spule sowie deren vorhandenem Kern. Funkentstördrosseln sind dafür ausgelegt von einem niederfrequenten Strom durchflossen zu werden und eine, im Vergleich zum Nutzstrom niedrigen Störstrom abzublocken. Dadurch entstehen kaum Verluste im Kern, da das Magnetfeld konstant ist bzw. sich durch den niederfrequenten Strom nur sehr langsam ändert. Der Kern ist also nicht dafür ausgelegt verlustarm zu sein, bzw. es ist sogar erwünscht wenn er bei hohen Frequenzen gewisse Verluste aufweist, um Resonanzen innerhalb der Spule zu verhindern. Weiterhin kommt das Problem hinzu, dass aufgrund der hohen Länge der Spule die Feldlinien außerhalb der Spule den magnetischen Kreis schließen und sich so ein deutliches Magnetfeld um die Spule herum aufbaut, diese arbeitet quasi wie eine Ferittstabantenne und erzeugt beträchtliche EMV Störungen!
Speziell für Schaltnetzteile ausgelegte Spulen besitzen daher nicht selten einen entsprechenden mechanischen Aufbau um die Feldlinien möglichst innerhalb bzw. sehr nahe an der Spule zu halten um diese Störungen zu minimieren.

Besonders bei Spulen mit Eisenpulverringkernen sollte man genau nachschauen ob die Angaben für Entstöranwendungen oder für Schaltnetzteilanwendungen gelten: Hier wird oft die gleiche Spule je nach Verwendungszweck unterschiedlich spezifiziert. Dies liegt daran, dass man bei der Entstöranwendung eben kaum Verluste im Kern hat und somit aufgrund der geringeren Erwärmung der Draht von einem höheren Strom durchflossen werden kann, ohne dass er überhitzt.

=== Beispiele geeigneter Spulen für Schaltregler ===

[[Datei:Snt_spulen.jpg|thumb|250x250px|Verschiedene Spulen]]

Von links nach rechts:

*Speicherdrosseln: sehr gut geeignet
*Ringkernspulen: ja nach Anwendung gut bis sehr gut geeignet
*Widerstandsbauform, Trommelkern: für (sehr) kleine Leistungen geeignet
*Entstörspulen: schlecht geeignet
*Stromkompensierte Drosseln: absolut ungeeignet

Für kleinere Schaltregler in beliebiger Konfiguration (also StepUp, StepDown, invertierend) geeignete Spulen sind z. B. die L-PISxx Serien die z. B. bei Reichelt oder Conrad erhältlich sind, oder vergleichbare Spulen.
Aufgrund des Ferritkerns sind diese Spulen nahezu für alle üblichen Frequenzbereiche geeignet.
Für Stepdownregler unter 100kHz eignen sich auch Eisenpulverringkernspulen z. B. aus dem Material 26. Vor allem bei höheren Strömen sind diese oft deutlich günstiger als vergleichbare Spulen auf Ferritkern.

== Links ==

* [[Transformatoren und Spulen]]
* [[MC34063]]

== Weblinks ==

* [http://de.wikipedia.org/wiki/Induktivit%C3%A4t_%28Bauelement%29 Wikipedia: Induktivität]

[[Kategorie:Bauteile]]

Olimex AT91SAM7X256-Board SAM7-EX256

2009-10-07T05:00:27Z

Mixer: Rückgängig: Änderung 39720 von 69.226.219.33 (Diskussion) wurde rückgängig gemacht.

[http://shop.mikrocontroller.net/csc_article_details.php?saArticle%5BID%5D=80 Olimex AT91SAM7X256-Board (SAM7-EX256)]

[http://shop.mikrocontroller.net/csc_article_details.php?saArticle%5BID%5D=80 http://shop.mikrocontroller.net/images/sam7-ex256-small.jpg]

== Softwarevoraussetzungen ==

Die folgenden Anleitungen setzen das Vorhandensein einer [[ARM#Compiler|ARM-GCC-Toolchain]] voraus.

== Minimalbeispiel ==

Dieses einfache Beispielprojekt mit Makefile basiert auf dem GCC-Tutorial von Atmel. Enthalten ist kein OS, nur ein paar Funktionen für UART-Kommunikation.

Download: http://www.mikrocontroller.net/attachment/25724/Olimex_SAM7_EX256_StartupMinimal_2007.08.17.zip

== Installation von FreeRTOS ==

Merkmale von FreeRTOS:
* präemptives Multitasking
* Unterstützung für viele Prozessoren und Controller
* Demos für viele verschiedene Boards enthalten
* Beispiele für die Anbindung verschiedener IP-Stacks enthalten (lwIP, uIP)
* Codequalität der Demos durchwachsen

Funktionsumfang des Beispielprojekts:
* TCP/IP-Stack lwIP
* Webserver
* virtueller serieller Port über USB realisiert (CDC, Windows-Treiber enthalten)

Als Ausgangspunkt dient das Beispiel "lwIP_Demo_Rowley_ARM7" aus [http://www.freertos.org FreeRTOS] 4.4.0. Die für das Olimex-Board angepasste (und ein bisschen aufgeräumte) Version kann man [http://www.mikrocontroller.net/attachment/25551/lwIP_Demo_olimex.zip hier] herunterladen. Die Datei muss in den Demo-Ordner von FreeRTOS entpackt werden. Die Änderungen gegenüber der Originalversion sind in der Datei changes.txt dokumentiert.

Die IP-Adresse ist standardmäßig auf 192.168.0.111 gesetzt und lässt sich in der Datei BasicWEB.c ändern.

Kompiliert wird das Projekt wie üblich durch Eingabe von <code>make</code>.

== Installation von Ethernut ==

Ethernut bzw. Nut/OS ist ein Betriebssystem mit TCP/IP-Stack, das ursprünglich für AVR-Controller entwickelt wurde, später aber u.a. auf ARM portiert wurde.

Merkmale von Nut/OS:
* sehr sauberer und gut kommentierter Code
* Buildsystem mit Konfigurations-GUI; Vorteil: einfacher Einstieg, Nachteil: Gesamtsystem manchmal etwas undurchsichtig
* nur kooperatives Multitasking
* zielt hauptsächlich auf AVR ab, ARM-Unterstützung noch nicht weit fortgeschritten
* im Vergleich zu lwIP spartanischer IP-Stack

Funktionsumfang des Beispielprojekts:
* verschiedene Netzwerk-Beispielanwendungen (HTTP, FTP, DHCP)
* serieller Port

Getestet wurde diese Anleitung mit der Ethernut-Version 4.2.1.

Als Ausgangspunkt dient die Konfiguration at91sam7x-ek.conf. Für das Olimex-Board sind ein paar kleine Änderungen nötig.

=== PHY-Konfiguration ändern ===

Unter Architecture/ARM/AT91 EMAC Driver: [[Bild:olimex-sam7x-ethernut-phy-conf.png]]

=== PHY-Initialisierung patchen ===

In der Funktion EmacReset in der Datei at91_emac.c den Block mit dem Kommentar <code>/* For some unknown reason...</code> durch folgenden Code ersetzen:

<c>
/* PHY ID */
#define MII_DM9161_ID_H 0x0181
#define MII_DM9161_ID_L 0xb8a0

#define MII_AM79C875_ID_H 0x0022
#define MII_AM79C875_ID_L 0x5540

#define MII_MICREL_ID_H 0x0022
#define MII_MICREL_ID_L 0x1610

/* For some unknown reason it seems to be required to read the ID registers first. */
// Check for DM PHY (as used on the ATMEL EK)
if (phy_inw(NIC_PHY_ID1) != MII_DM9161_ID_H ||
(phy_inw(NIC_PHY_ID2) & 0xFFF0) != MII_DM9161_ID_L) {
// Check for MICREL PHY (as used on the Olimex SAM7-EX256)
if (phy_inw(NIC_PHY_ID1) != MII_MICREL_ID_H ||
(phy_inw(NIC_PHY_ID2) & 0xFFF0) != MII_MICREL_ID_L) {
outr(EMAC_NCR, inr(EMAC_NCR) & ~EMAC_MPE);
return -1;
}
}
</c>

=== Fehlende Definition ergänzen ===
Falls eine Fehlermeldung auftritt dass EMAC_PIO_SODR nicht definiert ist, folgenden Code in der Datei at91_emac.c vor <code>#ifdef PHY_PWRDN_BIT\n /* Disable PHY power down. */</code> einfügen:

<c>
#ifndef EMAC_PIO_SODR
#define EMAC_PIO_SODR PIOB_SODR
#endif
</c>

=== Ausprobieren ===

Wenn man das Beispielprogramm httpserv kompiliert (<code>make</code> eingeben) und in den Controller geladen hat sollte man über das UART (115.2 kBaud) die erfolgreiche Initialisierung bestätigt bekommen:
Nut/OS 4.2.1 HTTP Daemon...Configure eth0...OK
192.168.0.21 ready

Jetzt kann man die angezeigte IP-Adresse im Browser eingeben und sollte die Testseite zu sehen bekommen.

== Forum ==
* [http://www.mikrocontroller.net/topic/75721#new Diskussion zum Thema]

== Weblinks ==
* http://www.sparkfun.com/tutorial/Nokia%206100%20LCD%20Display%20Driver.pdf

[[Category:ARM-Boards]]

Wake-Up Light

2009-05-03T15:29:58Z

Mixer: /* Beschreibung */

Die Inspiration kam vom original Wak-Up Light von Philips.

[http://www.consumer.philips.com/consumer/de/de/consumer/cc/_categoryid_WAKEUP_LIGHT_CA_DE_CONSUMER/]

Der Preis dafür ist jedoch nicht gerade klein. Ich startete also ein eigenes Low-Cost Projekt mit (meiner Meinung nach) ein paar Verbesserungen.

= Einleitung =
Der Formumbeitrag für Fragen und Anregungen ist [[http://www.mikrocontroller.net/topic/136769#1249098 hier]]

Der Sinn des ganzen ist es, dass man nicht mehr durch einen grauenhaften Ton von einer Sekunde auf die andere aufwacht, sondern dass man durch das Licht lansgsam wach wird. Das ganze Basiert auf dem Hormon [http://de.wikipedia.org/wiki/Melatonin Melatonin|] diese wird unter anderem in den Augen Produziert sobald es dunkel wird und bewirkt, dass man müde wird und einschläft. Wird die Umgebung nun heller hören die Augen auf dieses Hormon zu produzieren und man wird dadurch wach.

15 Minuten vor der eingestellte Weckzeit fängt das Wake-Up Light an zu leuchten. In den ersten 10 Minuten wird es konstant alle 20 Sekunden eine Stufe heller. In den letzten 5 Minuten werden mit den 3 farbigen LEDs abwechslungsweise verschiedene Farben erzeugt. Und zum Schluss kommt dann doch noch ein akustische Weckruf.

Beim Design hab ich mich von einem Leuchtturm inspirieren lassen und das ganze dementsprechend ähnlich aufgebaut.

== Bilder ==
[[Bild:Leuchtturm.jpg|center|thumb|200px|Aufbau]]

Zu sehen ist der Print mit den beiden AA Batterien und dem Lithium Akku aus einem Nostalgischen Handy
Die Batterielaufzeit habe ich auf etwa 1 Jahr berechnet. Der Akku für die LEDs sollte ebenfalls mehrere Monate Halten
[[Bild:Innenaufbau.jpg|center|thumb|200px|Innenansicht]]

In der Mitte ist eine 10 mm weisse LED zu sehen. Aussen sind je 2 Blaue, Grüne und Gelbe LEDs. Eigentlich wollte ich RGB, habe aber die erfahrung gemacht, dass die roten LEDs zu intensiv waren und habe daher gelbe verwendet.
[[Bild:LEDs.jpg|center|thumb|200px|Ansicht von Oben auf die LES]]

Das Display Zeigt die Standardanzeige mit Wochentag, Datum, Zeit und Alarmeinstellung
[[Bild:DisplayStandardanzeige.jpg|center|thumb|200px|Standardanzeige]]

= Features =
* Menügesteuerte Bedienung mit nur 3 Tasten
* Batteriebetrieb
* Uhrzeit läuft bei Batteriewechsel weiter
* Der Alarm kann auf bestimmte Wochentage begrenzt werden

= Hardware =
== Prozessor ==
=== Schema ===
[[Bild:Prozessor.png|thumb|center|500px|Prozessor]]

=== Beschreibung ===
Als Prozessor wird ein Atmega88 verwendet. Dieser hat gegenüber dem Atmega8 zwei wesentliche Vorteile: Neuerer Generation daher pro Pin mehr Funktionen z.B. PinChangeInterrupt und eine Debugschnittstelle (DebugWire) damit man debuggen könnte, falls man ein JTAGICE mkII hätte :-(

Die 1k Widerstände am Programmierstecker sind, da die meisten Programmiergeräte mit 5V Pegel arbeiten, der Prozessor aber mit etwa 3V läuft.

Für die Zeit wird ein externer RTC verwendet, das hat 2 Vorteile: Man hat eine genaue Zeit inkl. Datum und Wochentag und der Prozessor kann in den Tiefschlaf gehen, wenn er nichts mehr zu tun hat. Er schaltet also alle Clocks ab, würde man einen 32 kHz Quarz verwenden, muss der Clock aktiv bleiben und der Prozessor bräuchte viel mehr Strom. Durch den Programmierbaren Clock Ausgang des RTC wird der Prozessor an einem Interrupt Eingang mit einem 1 Hz Signal versorgt. (Siehe dazu die verschiedenen Sleep Modi des Atmega88)

Mithilfe der beiden Spannungsteiler können die beiden Batteriespannungen gemessen werden.

Die vier SW_xxx Eingänge sind für die Taster

Der TxD Ausgang ist für Debugzwecke, wenn man wie ich keinen JTAGICE mkII hat um über DebugWire zu debuggen.

Am Buzzer Ausgang wird ein Signal Ausgegeben um einen Wechrufton zu erzeigen. Der Buzzer ist selbstoszillierend (Spannung --> Ton, keine Frequenz nötig).

Für die Hintergrundbeleuchtung und die 3 LEDs sind jeweils PWM Ausgänge vorgesehen, wobei die Hintergrundbeleuchtung noch nicht über PWM angesteuert wird.

== Ansteuerung ==
=== Schema ===
[[Bild:Ansteuerung.png|thumb|center|500px|Ansteuerung]]

=== Beschreibung ===
Als Display wird ein EA DOGM162 mit 2 x 16 Zeichen verwendet. Um nur wenige Prozessorpins zu belegen wird das LCD in SPI Modus angesteuert. Obwohl das LCD an den Hardware SPI-Pins angeschlossen ist wird eine Softwaremässige Übertragung verwendet um Strom zu sparen. Das LCD hat einen internen StepUp Wandler dessen Spannung per Software eingestellt werden kann, damit wird der Kontrast eingestellt.

Alle LEDs werden mit PWM Konstantstrom angesteuert. Die Spannung zwischen Emitter und GND ist immer 0.7V. Zusammen mit dem Emitterwiderstand gibt dies einen konstanten Strom durch die LEDs unabhängig von der Spannung der Batterie.

Alle Taster werden mit den internen PullUp Widerständen des AVRs gespiesen.

'''Schaltung für LED Konstantstrom'''
[[Bild:Konstantstrom.png|center|thumb|200px]]

= Software =
== Allgemein ==
Die Software läuft grösstenteils Interruptbasiert, das heisst sie macht erst etwas, wenn
man eine Taste drückt und so einen Interrupt auslöst. Zusätzlich hat sie vom externen
RTC noch einen 1s TimeTick. Das heisst, dass jede Sekunde ein Interrupt auftritt und der
TaskHandler und der Taskscheduler ausgeführt werden. Die restliche Zeit ist der
Prozessor im Tiefschlaf und verbrauch lediglich ein paar uA.

== TaskHandler ==
Dem Taskhandler kann man Funktionen zuweisen, bei denen man weiss, dass sie länger
dauern und nicht gerade jetzt auf der Stelle ausgeführt werden müssen. Ist vor allem in
den Interrupt Routinen vorteilhaft, da man diese wieder schnell verlässt und die
Zeitintensive Aufgaben später erledigt.

== TaskScheduler ==
Dem TaskScheduler kann man Aufgaben zuweisen, die man nach einer bestimmten Zeit
ausführen möchte. Z.B. sollte das Display 5 Sekunden Nachleuchten. Man kann dem
Scheduler jetzt also die Funktion BacklightOff() übergeben und angeben dass diese in 5
Sekunden ausgeführt werden soll. Drückt man in der Zwischenzeit eine Taste entfernt
man den Task einfach wieder und fügt in von neuem mit 5 Sekunden hinzu.

= Bedienung =
Die Bedienung ist menügesteuert und geschieht mit den 3 Tasten Up, OK, ESC. Folgende Einstellungen können vorgenommen werden:

* '''Alarm'''
** '''Ein/Aus''' Alarm komplett ausschalten oder an ausgewählen Tagen einschalten
** '''Zeit''' Alarmzeit einstellen
** '''Tage''' Wochentage an denen der Alarm eingeschaltet sein soll auswählen

* '''Einstellungen'''
** '''Datum einstellen''' Aktuelles Datum einstellen
** '''Zeit einstellen''' Aktuelle Uhrzeit einstellen
** '''Spannungen anzeigen''' Spannungen der Batterie und des Akku anzeigen

= Downloads =
== Hardware ==
Das Archiv enthält das Eagle Schema und ein PDF davon
{| border="1"
|-
!Version / Datum
!Bescheibung
!Link
|-
|1.0 / 13.04.2009
|Version 1.0
|[[http://www.mikrocontroller.net/articles/Bild:WakeUpLightHW_1_0.zip WakeUpLightHW_1_0.zip]]
|}

== Software ==
Die Datei enthalt die Einstellungen der FuseBit
[[http://www.mikrocontroller.net/articles/Bild:WakeUPLightFuses.pdf Einstellungen]]

Das Archiv enthält alle Source Dateien und eine fertig kompilierte HEX-Dateil. Die Software wurde mit AVR-GCC kompiliert.
{| border="1"
|-
!Version / Datum
!Bescheibung
!Link
|-
|1.0 / 02.05.2009
|Version 1.0
|[[http://www.mikrocontroller.net/articles/Bild:WakeUpLightSW_1_0.zip WakeUpLightSW_1_0.zip]]
|}

= Links =
[[LED-Fading]] 
[[Sleep Mode]] 
[[Ultra low power]]

Wake-Up Light

2009-05-03T15:28:58Z

Mixer: /* Beschreibung */

Die Inspiration kam vom original Wak-Up Light von Philips.

[http://www.consumer.philips.com/consumer/de/de/consumer/cc/_categoryid_WAKEUP_LIGHT_CA_DE_CONSUMER/]

Der Preis dafür ist jedoch nicht gerade klein. Ich startete also ein eigenes Low-Cost Projekt mit (meiner Meinung nach) ein paar Verbesserungen.

= Einleitung =
Der Formumbeitrag für Fragen und Anregungen ist [[http://www.mikrocontroller.net/topic/136769#1249098 hier]]

Der Sinn des ganzen ist es, dass man nicht mehr durch einen grauenhaften Ton von einer Sekunde auf die andere aufwacht, sondern dass man durch das Licht lansgsam wach wird. Das ganze Basiert auf dem Hormon [http://de.wikipedia.org/wiki/Melatonin Melatonin|] diese wird unter anderem in den Augen Produziert sobald es dunkel wird und bewirkt, dass man müde wird und einschläft. Wird die Umgebung nun heller hören die Augen auf dieses Hormon zu produzieren und man wird dadurch wach.

15 Minuten vor der eingestellte Weckzeit fängt das Wake-Up Light an zu leuchten. In den ersten 10 Minuten wird es konstant alle 20 Sekunden eine Stufe heller. In den letzten 5 Minuten werden mit den 3 farbigen LEDs abwechslungsweise verschiedene Farben erzeugt. Und zum Schluss kommt dann doch noch ein akustische Weckruf.

Beim Design hab ich mich von einem Leuchtturm inspirieren lassen und das ganze dementsprechend ähnlich aufgebaut.

== Bilder ==
[[Bild:Leuchtturm.jpg|center|thumb|200px|Aufbau]]

Zu sehen ist der Print mit den beiden AA Batterien und dem Lithium Akku aus einem Nostalgischen Handy
Die Batterielaufzeit habe ich auf etwa 1 Jahr berechnet. Der Akku für die LEDs sollte ebenfalls mehrere Monate Halten
[[Bild:Innenaufbau.jpg|center|thumb|200px|Innenansicht]]

In der Mitte ist eine 10 mm weisse LED zu sehen. Aussen sind je 2 Blaue, Grüne und Gelbe LEDs. Eigentlich wollte ich RGB, habe aber die erfahrung gemacht, dass die roten LEDs zu intensiv waren und habe daher gelbe verwendet.
[[Bild:LEDs.jpg|center|thumb|200px|Ansicht von Oben auf die LES]]

Das Display Zeigt die Standardanzeige mit Wochentag, Datum, Zeit und Alarmeinstellung
[[Bild:DisplayStandardanzeige.jpg|center|thumb|200px|Standardanzeige]]

= Features =
* Menügesteuerte Bedienung mit nur 3 Tasten
* Batteriebetrieb
* Uhrzeit läuft bei Batteriewechsel weiter
* Der Alarm kann auf bestimmte Wochentage begrenzt werden

= Hardware =
== Prozessor ==
=== Schema ===
[[Bild:Prozessor.png|thumb|center|500px|Prozessor]]

=== Beschreibung ===
Als Prozessor wird ein Atmega88 verwendet. Dieser hat gegenüber dem Atmega8 zwei wesentliche Vorteile: Neuerer Generation daher pro Pin mehr Funktionen z.B. PinChangeInterrupt und eine Debugschnittstelle (DebugWire) damit man debuggen könnte, falls man ein JTAGICE mkII hätte :-(

Die 1k Widerstände am Programmierstecker sind, da die meisten Programmiergeräte mit 5V Pegel arbeiten, der Prozessor aber mit etwa 3V läuft.

Für die Zeit wird ein externer RTC verwendet, das hat 2 Vorteile: Man hat eine genaue Zeit inkl. Datum und Wochentag und der Prozessor kann in den Tiefschlaf gehen, wenn er nichts mehr zu tun hat. Er schaltet also alle Clocks ab, würde man einen 32 kHz Quarz verwenden, muss der Clock aktiv bleiben und der Prozessor bräuchte viel mehr Strom. Durch den Programmierbaren Clock Ausgang des RTC wird der Prozessor an einem Interrupt Eingang mit einem 1 Hz Signal versorgt. (Siehe dazu die verschiedenen Sleep Modi des Atmega88)

Mithilfe der beiden Spannungsteiler können die beiden Batteriespannungen gemessen werden.

Die vier SW_xxx Eingänge sind für die Taster

Der TxD Ausgang ist für Debugzwecke, wenn man wie ich keinen JTAGICE mkII hat um über DebugWire zu debuggen.

Am Buzzer Ausgang wird ein Signal Ausgegeben um einen Wechrufton zu erzeigen. Der Buzzer ist selbstoszillierend (Spannung --> Ton, keine Frequenz nötig).

Für die Hintergrundbeleuchtung und die 3 LEDs sind jeweils PWM Ausgänge vorgesehen, wobei die Hintergrundbeleuchtung noch nicht über PWM angesteuert wird.

== Ansteuerung ==
=== Schema ===
[[Bild:Ansteuerung.png|thumb|center|500px|Ansteuerung]]

=== Beschreibung ===
Als Display wird ein EA DOGM162 mit 2 x 16 Zeichen verwendet. Um nur wenige Prozessorpins zu belegen wird das LCD in SPI Modus angesteuert. Obwohl das LCD an den Hardware SPI-Pins angeschlossen ist wird eine Softwaremässige Übertragung verwendet um Strom zu sparen. Das LCD hat einen internen StepUp Wandler dessen Spannung per Software eingestellt werden kann, damit wird der Kontrast eingestellt.

Alle LEDs werden mit PWM Konstantstrom angesteuert. Die Spannung zwischen Emitter und GND ist immer 0.7V. Zusammen mit dem Emitterwiderstnad gibt dies einen konstanten Strom durch die LEDs unabhängig von der Spannung der Batterie.

Alle Taster werden mit den internen PullUp Widerständen des AVRs gespiesen.

'''Schaltung für LED Konstantstrom'''
[[Bild:Konstantstrom.png|center|thumb|200px]]

= Software =
== Allgemein ==
Die Software läuft grösstenteils Interruptbasiert, das heisst sie macht erst etwas, wenn
man eine Taste drückt und so einen Interrupt auslöst. Zusätzlich hat sie vom externen
RTC noch einen 1s TimeTick. Das heisst, dass jede Sekunde ein Interrupt auftritt und der
TaskHandler und der Taskscheduler ausgeführt werden. Die restliche Zeit ist der
Prozessor im Tiefschlaf und verbrauch lediglich ein paar uA.

== TaskHandler ==
Dem Taskhandler kann man Funktionen zuweisen, bei denen man weiss, dass sie länger
dauern und nicht gerade jetzt auf der Stelle ausgeführt werden müssen. Ist vor allem in
den Interrupt Routinen vorteilhaft, da man diese wieder schnell verlässt und die
Zeitintensive Aufgaben später erledigt.

== TaskScheduler ==
Dem TaskScheduler kann man Aufgaben zuweisen, die man nach einer bestimmten Zeit
ausführen möchte. Z.B. sollte das Display 5 Sekunden Nachleuchten. Man kann dem
Scheduler jetzt also die Funktion BacklightOff() übergeben und angeben dass diese in 5
Sekunden ausgeführt werden soll. Drückt man in der Zwischenzeit eine Taste entfernt
man den Task einfach wieder und fügt in von neuem mit 5 Sekunden hinzu.

= Bedienung =
Die Bedienung ist menügesteuert und geschieht mit den 3 Tasten Up, OK, ESC. Folgende Einstellungen können vorgenommen werden:

* '''Alarm'''
** '''Ein/Aus''' Alarm komplett ausschalten oder an ausgewählen Tagen einschalten
** '''Zeit''' Alarmzeit einstellen
** '''Tage''' Wochentage an denen der Alarm eingeschaltet sein soll auswählen

* '''Einstellungen'''
** '''Datum einstellen''' Aktuelles Datum einstellen
** '''Zeit einstellen''' Aktuelle Uhrzeit einstellen
** '''Spannungen anzeigen''' Spannungen der Batterie und des Akku anzeigen

= Downloads =
== Hardware ==
Das Archiv enthält das Eagle Schema und ein PDF davon
{| border="1"
|-
!Version / Datum
!Bescheibung
!Link
|-
|1.0 / 13.04.2009
|Version 1.0
|[[http://www.mikrocontroller.net/articles/Bild:WakeUpLightHW_1_0.zip WakeUpLightHW_1_0.zip]]
|}

== Software ==
Die Datei enthalt die Einstellungen der FuseBit
[[http://www.mikrocontroller.net/articles/Bild:WakeUPLightFuses.pdf Einstellungen]]

Das Archiv enthält alle Source Dateien und eine fertig kompilierte HEX-Dateil. Die Software wurde mit AVR-GCC kompiliert.
{| border="1"
|-
!Version / Datum
!Bescheibung
!Link
|-
|1.0 / 02.05.2009
|Version 1.0
|[[http://www.mikrocontroller.net/articles/Bild:WakeUpLightSW_1_0.zip WakeUpLightSW_1_0.zip]]
|}

= Links =
[[LED-Fading]] 
[[Sleep Mode]] 
[[Ultra low power]]

Wake-Up Light

2009-05-03T15:26:54Z

Mixer: /* Einleitung */

Die Inspiration kam vom original Wak-Up Light von Philips.

[http://www.consumer.philips.com/consumer/de/de/consumer/cc/_categoryid_WAKEUP_LIGHT_CA_DE_CONSUMER/]

Der Preis dafür ist jedoch nicht gerade klein. Ich startete also ein eigenes Low-Cost Projekt mit (meiner Meinung nach) ein paar Verbesserungen.

= Einleitung =
Der Formumbeitrag für Fragen und Anregungen ist [[http://www.mikrocontroller.net/topic/136769#1249098 hier]]

Der Sinn des ganzen ist es, dass man nicht mehr durch einen grauenhaften Ton von einer Sekunde auf die andere aufwacht, sondern dass man durch das Licht lansgsam wach wird. Das ganze Basiert auf dem Hormon [http://de.wikipedia.org/wiki/Melatonin Melatonin|] diese wird unter anderem in den Augen Produziert sobald es dunkel wird und bewirkt, dass man müde wird und einschläft. Wird die Umgebung nun heller hören die Augen auf dieses Hormon zu produzieren und man wird dadurch wach.

15 Minuten vor der eingestellte Weckzeit fängt das Wake-Up Light an zu leuchten. In den ersten 10 Minuten wird es konstant alle 20 Sekunden eine Stufe heller. In den letzten 5 Minuten werden mit den 3 farbigen LEDs abwechslungsweise verschiedene Farben erzeugt. Und zum Schluss kommt dann doch noch ein akustische Weckruf.

Beim Design hab ich mich von einem Leuchtturm inspirieren lassen und das ganze dementsprechend ähnlich aufgebaut.

== Bilder ==
[[Bild:Leuchtturm.jpg|center|thumb|200px|Aufbau]]

Zu sehen ist der Print mit den beiden AA Batterien und dem Lithium Akku aus einem Nostalgischen Handy
Die Batterielaufzeit habe ich auf etwa 1 Jahr berechnet. Der Akku für die LEDs sollte ebenfalls mehrere Monate Halten
[[Bild:Innenaufbau.jpg|center|thumb|200px|Innenansicht]]

In der Mitte ist eine 10 mm weisse LED zu sehen. Aussen sind je 2 Blaue, Grüne und Gelbe LEDs. Eigentlich wollte ich RGB, habe aber die erfahrung gemacht, dass die roten LEDs zu intensiv waren und habe daher gelbe verwendet.
[[Bild:LEDs.jpg|center|thumb|200px|Ansicht von Oben auf die LES]]

Das Display Zeigt die Standardanzeige mit Wochentag, Datum, Zeit und Alarmeinstellung
[[Bild:DisplayStandardanzeige.jpg|center|thumb|200px|Standardanzeige]]

= Features =
* Menügesteuerte Bedienung mit nur 3 Tasten
* Batteriebetrieb
* Uhrzeit läuft bei Batteriewechsel weiter
* Der Alarm kann auf bestimmte Wochentage begrenzt werden

= Hardware =
== Prozessor ==
=== Schema ===
[[Bild:Prozessor.png|thumb|center|500px|Prozessor]]

=== Beschreibung ===
Als Prozessor wird ein Atmega88 verwendet. Dieser hat gegenüber dem Atmega8 zwei wesentliche Vorteile: Neuerer Generation daher pro Pin mehr Funktionen z.B. PinChangeInterrupt und eine Debugschnittstelle (DebugWire) damit man debuggen könnte, falls man ein JTAGICE mkII hättet :-(

Die 1k Widerstände am Programmierstecker sind, da die meisten Programmiergeräte mit 5V Pegel arbeiten, der Prozessor aber mit etwa 3V läuft.

Für die Zeit wird ein externer RTC verwendet, das hat 2 Vorteile: Man hat eine genaue Zeit inkl. Datum und Wochentag und der Prozessor kann in den Tiefschlaf gehen, wenn er nichts mehr zu tun hat. Er schaltet also alle Clocks ab, würde man einen 32 kHz Quarz verwenden, muss der Clock aktiv bleiben und der Prozessor bräuchte viel mehr Strom. Durch den Programmierbaren Clock Ausgang des RTC wird der Prozessor an einem Interrupt Eingang mit einem 1 Hz Signal versorgt. (Siehe dazu die verschiedenen Sleep Modi des Atmega88)

Mithilfe der Beiden Spannungsteiler können die beiden Batteriespannungen gemessen werden.

Die vier SW_xxx Eingänge sind für die Taster

Der TxD Ausgang ist für Debugzwecke, wenn man wie ich keinen JTAGICE mkII hat um über DebugWire zu debuggen.

Am Buzzer Ausgang wird ein Signal Ausgegeben um einen Wechrufton zu erzeigen. Der Buzzer ist selbstoszillierend (Spannung --> Ton, keine Frequenz nötig).

Für die Hintergrundbeleuchtung und die 3 LEDs sind jeweils PWM Ausgänge vorgesehen, wobei die Hintergrundbeleuchtung noch nicht über PWM angesteuert wird.

== Ansteuerung ==
=== Schema ===
[[Bild:Ansteuerung.png|thumb|center|500px|Ansteuerung]]

=== Beschreibung ===
Als Display wird ein EA DOGM162 mit 2 x 16 Zeichen verwendet. Um nur wenige Prozessorpins zu belegen wird das LCD in SPI Modus angesteuert. Obwohl das LCD an den Hardware SPI-Pins angeschlossen ist wird eine Softwaremässige Übertragung verwendet um Strom zu sparen. Das LCD hat einen internen StepUp Wandler dessen Spannung per Software eingestellt werden kann, damit wird der Kontrast eingestellt.

Alle LEDs werden mit PWM Konstantstrom angesteuert. Die Spannung zwischen Emitter und GND ist immer 0.7V. Zusammen mit dem Emitterwiderstnad gibt dies einen konstanten Strom durch die LEDs unabhängig von der Spannung der Batterie.

Alle Taster werden mit den internen PullUp Widerständen des AVRs gespiesen.

'''Schaltung für LED Konstantstrom'''
[[Bild:Konstantstrom.png|center|thumb|200px]]

= Software =
== Allgemein ==
Die Software läuft grösstenteils Interruptbasiert, das heisst sie macht erst etwas, wenn
man eine Taste drückt und so einen Interrupt auslöst. Zusätzlich hat sie vom externen
RTC noch einen 1s TimeTick. Das heisst, dass jede Sekunde ein Interrupt auftritt und der
TaskHandler und der Taskscheduler ausgeführt werden. Die restliche Zeit ist der
Prozessor im Tiefschlaf und verbrauch lediglich ein paar uA.

== TaskHandler ==
Dem Taskhandler kann man Funktionen zuweisen, bei denen man weiss, dass sie länger
dauern und nicht gerade jetzt auf der Stelle ausgeführt werden müssen. Ist vor allem in
den Interrupt Routinen vorteilhaft, da man diese wieder schnell verlässt und die
Zeitintensive Aufgaben später erledigt.

== TaskScheduler ==
Dem TaskScheduler kann man Aufgaben zuweisen, die man nach einer bestimmten Zeit
ausführen möchte. Z.B. sollte das Display 5 Sekunden Nachleuchten. Man kann dem
Scheduler jetzt also die Funktion BacklightOff() übergeben und angeben dass diese in 5
Sekunden ausgeführt werden soll. Drückt man in der Zwischenzeit eine Taste entfernt
man den Task einfach wieder und fügt in von neuem mit 5 Sekunden hinzu.

= Bedienung =
Die Bedienung ist menügesteuert und geschieht mit den 3 Tasten Up, OK, ESC. Folgende Einstellungen können vorgenommen werden:

* '''Alarm'''
** '''Ein/Aus''' Alarm komplett ausschalten oder an ausgewählen Tagen einschalten
** '''Zeit''' Alarmzeit einstellen
** '''Tage''' Wochentage an denen der Alarm eingeschaltet sein soll auswählen

* '''Einstellungen'''
** '''Datum einstellen''' Aktuelles Datum einstellen
** '''Zeit einstellen''' Aktuelle Uhrzeit einstellen
** '''Spannungen anzeigen''' Spannungen der Batterie und des Akku anzeigen

= Downloads =
== Hardware ==
Das Archiv enthält das Eagle Schema und ein PDF davon
{| border="1"
|-
!Version / Datum
!Bescheibung
!Link
|-
|1.0 / 13.04.2009
|Version 1.0
|[[http://www.mikrocontroller.net/articles/Bild:WakeUpLightHW_1_0.zip WakeUpLightHW_1_0.zip]]
|}

== Software ==
Die Datei enthalt die Einstellungen der FuseBit
[[http://www.mikrocontroller.net/articles/Bild:WakeUPLightFuses.pdf Einstellungen]]

Das Archiv enthält alle Source Dateien und eine fertig kompilierte HEX-Dateil. Die Software wurde mit AVR-GCC kompiliert.
{| border="1"
|-
!Version / Datum
!Bescheibung
!Link
|-
|1.0 / 02.05.2009
|Version 1.0
|[[http://www.mikrocontroller.net/articles/Bild:WakeUpLightSW_1_0.zip WakeUpLightSW_1_0.zip]]
|}

= Links =
[[LED-Fading]] 
[[Sleep Mode]] 
[[Ultra low power]]

Benutzer:Mixer

2009-02-13T17:09:39Z

Mixer:

=Interessen=

*AVR, bis jetzt nur ASM
*Elektronik allgemein
*Linux (Ubuntu)

Entscheidung Mikrocontroller

2009-02-12T18:02:11Z

Mixer: /* Debugging */

[[Category:Mikrocontroller]]
Die meisten Anfänger stellen sich die Frage, welchen [[Mikrocontroller]] sie verwenden sollen. Es gibt dutzende Hersteller, und jeder davon hat unzählige Varianten im Angebot. Stellt man die Frage in einem Diskussionsforum, dann bekommt man viele verschiedene (sich teilweise widersprechende) Antworten. Bei der Entscheidung sollten u.a. die unten stehenden Kriterien beachtet werden. Dieser Artikel ist primär für Hobbyisten gedacht, da im professionellen Einsatz oftmals völlig andere Kriterien beachtet werden müssen. Weitere vergleichende Informationen über verschiedene Controllerfamilien gibt der Artikel: [[AVR_PIC_51-Vergleich]]

== Verfügbarkeit ==
* Während man manche Mikrocontroller an jeder Straßenecke bekommt, sind andere nur in großen Stückzahlen und mit Gewerbenachweis erhältlich. Dazu einfach mal in die Kataloge der einschlägigen Privatkundenhändler schauen. Dabei auch darauf achten, dass der gewünschte Controller auch in der richtigen Bauform erhältlich ist (DIP, TQFP, MLF,usw.), s.u.
* Ab und zu kündigen Hersteller ein neues Modell an (und veröffentlichen das Datenblatt dazu), können aber erst ein Jahr später nennenswerte Stückzahlen liefern. Also den Controller nicht einfach anhand der Übersichten beim Hersteller aussuchen, sondern überprüfen, was die Händler auch wirklich liefern können.
* Lebenszyklus: Kein Modell wird ewig hergestellt, deswegen sollte man überprüfen, ob der Hersteller vielleicht schon angekündigt hat, dass er ein bestimmtes Modell nicht mehr herstellen will. Die Hersteller schreiben dann z.B. "Mature Product (Not Recommended for New Designs)". Für Neuentwicklungen oder den Einstieg sollte man folgende Modelle nicht verwenden:
** AVR AT90-Reihe,
** AVR ATMega 103(L), 161(L), 163(L), 323(L).
* Für alle abgekündigten AVR-Controller gibt es jedoch pin- und funktionskompatible Nachfolger. Daher kommt es nur in den seltensten Fällen zu Problemen. Probleme können nur entstehen wenn ein Programm nur in kompilierter Version zur Verfügung steht.
* Dagegen sind Mikrocontroller der [[8051|MCS51-Familie]] von Intel eher für langfristige Investitionen geeignet. Der 8051 wurde 1979 (!) als erstes Mitglied dieser Familie vorgestellt. Heute gibt es bereits hunderte von 8051-Derivaten von dutzenden von Halbleiterherstellern, zum Teil auch mit weiterentwickelten Prozessorkernen. Wird ein Derivat tatsächlich mal abgekündigt, findet man bei dieser Riesenauswahl meist leicht adäquaten Ersatz.

== Preis ==
Einerseits kann es lästig sein, wenn man durch die Verwendung eines kleineren Modells 2 Euro gespart hat und dann mit dessen Unzulänglichkeiten kämpft, andererseits ist ein versehentlich zerstörter Chip für 30 Euro ziemlich ärgerlich. Auch ist es oft ganz praktisch, wenn man einige Controller auf Vorrat hat.

Zum Preis eines einzelnen Mikrocontrollers kommen noch die Kosten für die Entwicklungswerkzeuge, wie [[Compiler]], Programmübertragung und Debugging hinzu (s.u. Programmiersprache und Programmübertragung).

== Bauformen ==
Neben den klassischen (bedrahteten) Bauformen setzt sich heutzutage [[SMD]] immer mehr durch. Manche Mikrocontroller sind nur noch in SMD-Bauformen erhältlich. Für SMD benutzt man üblicherweise geätzte Platinen oder Adapter/Sockel (die aber wieder extra kosten). Will man mit Lochrasterplatinen oder [[Breadboard]]s arbeiten, dann braucht man die klassischen Bauformen, z.B. PDIP. Zu beachten ist dabei, dass es PDIP oft nur bis DIP40 (also mit 40 Pins) gibt, d.h. einen Mikrocontroller mit 50 I/O-Pins kann es dann nur als SMD geben.

Viele Mikrocontroller sind in verschiedenen Bauformen verfügbar. Nur in SMD verfügbar sind:
* MSP430 (Die kleinen sind mittlerweile auch als DIP erhältlich)
* AVR ATMega 64, 128, 169

In der klassischen (wenn auch in der Anzahl der verfügbaren IO-Pins limitiert) PDIP Bauform gibt es unter anderem:
* AVR ATMega 8, 16, 32
* viele 8051-Derivate, z.B. Atmel 89S8252

== Spannung ==
Während früher die meisten Mikrocontroller und die gesamte Peripherie mit 5V liefen, so gibt es heute auch alle möglichen anderen Varianten. Zu beachten ist:
* Controller und Peripherie müssen zusammenpassen. Man kann nicht einfach (ohne weitere Vorkehrungen) ein 3,3V-RAM an einen 5V-Controller anschließen und umgekehrt.
* Manche Controller besitzen, obwohl sie intern mit einer anderen Spannung arbeiten, 5V-kompatible IO-Pins (Beispiel: [[LPC2000 Philips ARM7TDMI-Familie|LPC2100]]).
* Manche Controller brauchen zwei verschiedene Spannungen. Dies ist aber relativ selten, z.B. bei den [[LPC2000 Philips ARM7TDMI-Familie|LPC2100]].

* Billig-Netzteile liefern im Leerlauf manchmal deutlich mehr Spannung als angegeben, ein [[Spannungsregler]] (z.B. 78xx) ist also Pflicht!
* Bei Batterien und Akkus sinkt die Spannung ab, wenn sie leerer werden. Braucht der Controller z.B. mindestens 2,7V, dann wird man mit zwei 1,5V-Batterien nicht lange Freude haben (außer man benutzt spezielle Schaltregler).

== Stromverbrauch ==
Im Vergleich zu PC-Prozessoren (Pentium, Athlon usw.) brauchen Mikrocontroller relativ wenig Strom. Will man sie allerdings mit Batterien betreiben, dann wird der Stromverbrauch plötzlich doch wichtig. Die meisten Mikrocontroller besitzen hierfür Stromsparmodi, mit denen man den Controller teilweise abschalten kann. Für einen extrem geringen Stromverbrauch sind z.B. die [[MSP430]]-Controller optimiert.

Der Stromverbrauch hängt auch stark vom Takt und der Versorgungsspannung ab.

{| border=1 cellspacing=0
! Frequenz !! ATMega8 (2.7V) !! ATMega8 (5.0V) !! PIC16LF84A(2.0V) !! PIC16F84A (5.5V)
|-
! 32KHz
|62µA||80µA||45µA||-
|-
! 100KHz
|0,3mA||0,5mA||-||-
|-
!1MHz, 2MHz*
|1,5mA ||2,3mA||4mA||-
|-
!8MHz, 4MHz*
|5mA ||7/15mA**||-||4.5mA
|-
!16MHz, 20MHz*
| - ||20mA||-||20mA
|}

[*] Abweichende Taktangabe für PIC16*F84A, da hier keine entsprechenden Werte für die Frequenzen des ATmega8 im Datenblatt (PIC16F84A Data Sheet, Microchip 2001, 35007b.pdf) vorliegen.

[**] Angaben sind in der Folge Idle/Active (Quelle: Atmel, ATmega8/L, doc2486.pdf).

== Takt/Geschwindigkeit ==
Einerseits wünscht man sich oft einen möglichst schnellen Controller, insbesondere als Anfänger, wenn man effiziente Lösungen noch nicht so kennt, andererseits schlägt sich ein hoher Takt auch im Stromverbrauch und im Preis nieder. Man sollte sich dabei nicht von den hohen Taktraten der PC-Prozessoren irritieren lassen. Für viele Anwendungen reicht 1-MHz-Takt völlig aus.

Bei einem Geschwindigkeitsvergleich sollte man beachten, dass man nicht einfach den Takt vergleichen kann:
* Während manche Controller 12 Takte für einen Befehl brauchen (z.B. die Original-[[8051]]), kommen andere mit einem Takt pro Befehl aus (z.B. [[AVR]]).
* Manche Controller unterstützen gewisse Operationen hardwareseitig, die auf anderen Controllern in Software nachgebildet werden muss. Beispiele sind z.B. Multiplikation und Division. Wer in einer Hochsprache programmiert merkt davon nicht viel, da es dort die Befehle sowieso zur Verfügung stehen, aber sie brauchen auf einem Controller ohne Hardwareunterstützung eben deutlich länger.
* Die Datenbus- bzw. Registerbreite spielt eine wichtige Rolle, weil man z.B. für eine 16-Bit-Addition auf einer 8-Bit-CPU zwei Befehle und auf einer 16-Bit-CPU nur einen Befehl braucht.

== Speicher ==
Während früher oft nur die [[Register]] im Mikrocontroller waren, und der gesamte restliche Speicher extern angebunden werden musste, so sind heute die Speicher oft komplett im Mikrocontroller integriert. Das bedeutet aber teilweise auch, dass man sie nicht erweitern kann. Wichtig ist dabei u.a. die Größe des Programmspeichers (meist ein [[Flash-ROM]]) und das [[RAM#SRAM|SRAM]]. Fehlt letzteres, dann kann es mit der Compilerunterstützung schwierig werden.

Zu unterscheiden sind hier außerdem Controller in [[Von Neumann-Architektur|Von-Neumann-Architektur]] und [[Harvard-Architektur]]. Bei letzterer liegen Programmspeicher (ROM) und Datenspeicher (RAM) in getrennten Speicherbereichen; dies hat den Nachteil, dass für den Zugriff auf den Programmspeicher spezielle Befehle notwendig sind (was die Verwendung von im ROM abgelegten Daten in C-Compilern ziemlich umständlich macht), und dass man keine Programmteile direkt aus dem Datenspeicher ausführen kann.

== Onboard-Peripherie ==
Mikrocontroller haben meist eine ganze Menge Funktionen integriert, z.B. [[AD-Wandler]], [[I²C]]-Bus, [[SPI]], [[PWM]], [[RS-232]] usw. usf. Der Vorteil liegt darin, dass der Controller damit mehrere Dinge gleichzeitig machen kann. Dadurch steigt zum einen die Gesamtleistung des Controllers, zum anderen sind viele Dinge zeitkritisch, und die Programmierung ist deutlich einfacher, wenn man zehn zeitkritische Dinge gleichzeitig erledigen muss.

== Programmiersprachen ==
Den direktesten Zugriff auf die "Innereien" eines Prozessors hat man mit [[Assembler]]. Dies ist jedoch gleichzeitig - zumindest auf den ersten Blick - die "abschreckendste" Sprache, denn sie erfordert einen hohen Lernaufwand. Aufgrund stark unterschiedlicher Befehlssätze verschiedener Controllerfamilien ist das Gelernte nie 1-zu-1 übertragbar und meist nur direkt auf einen einzigen Prozessor oder allenfalls auf eine Familie "verwandter" Produkte anwendbar. Dennoch kann man sich mit einiger Erfahrung recht schnell in einen anderen Befehlssatz einarbeiten. In bestimmten Bereichen oder Teilen eines Projekts wird die Verwendung von Assembler dennoch unabdingbar sein. (Diese Teile mögen projektabhängig zwischen 100% oder auch nur deutlich unter 1% umfassen.)

Die Auswahl der richtigen Programmiersprache hängt auch stark vom geplanten Einsatzzweck ab. Ein Elektrotechnik-Student, der sich für sein späteres Berufsleben vorbereiten möchte, sollte sich mit C und Assembler befassen. Wer dagegen gar nicht vorhat sich allzu tief einzuarbeiten und sowieso schon Basic oder Pascal kann, der sollte zu diesen Sprachen greifen.

Für einige Controllerfamilien (z.B. AVR, ARM, MSP430) gibt es eine Portierung des kostenlosen [[GCC|GNU-C-Compilers]], wodurch C auch im Hobby-Bereich stark vertreten ist und es auch viele Programmierbeispiele dafür gibt.

== Programmübertragung ==
Irgendwie muss das Programm zum Mikrocontroller kommen. Früher war dazu in den meisten Fällen ein teures und umständlich zu handhabendes Programmiergerät notwendig, heute sind die meisten Mikrocontroller über eine spezielle ISP-Schnittstelle oder über das [[UART]] "In-System"-programmierbar. Controller mit integriertem [[Bootloader]] kann man mit der entsprechenden Software direkt über den seriellen Port eines PCs programmieren. Für Controller mit ISP- oder [[JTAG]]-Schnittstelle ([[AVR]], [[MSP430]]) benötigt man einen speziellen Programmieradapter, den man (meistens in verschiedenen Ausführungen) kaufen oder selber bauen kann.

== Debugging ==
Bei der Fehlerbeseitigung trennen sich Profi von Amateur und es kann richtig teuer werden. Genau hier haben die Hersteller von Mikrocontrollern und/oder Compilern eine Möglichkeit gefunden den Gelegenheitsprogrammierer abzuweisen und nur den zahlenden Profi vorzulassen.

Die preisgünstigste aber auch unkomfortabelste Art des Debuggings ist der Einbau von Testkode in das Programm. Dieser Testkode informiert den Programmierer über erreichte Programmpunkte und dabei aufgetretene Datenwerte. Die Ausgabe erfolgt per optisch/akustischer Anzeige oder serieller Schnittstelle. Der Nachteil dieser Methode liegt in ihrem Zeitaufwand. Für jedes Problem muss ein kurzes Stück Testkode erdacht und in das Programm eingefügt werden. Danach wird das Programm kompiliert/assembliert und in den Flashspeicher des Mikrocontrollers gebrannt. Zu guter Letzt muss das Programm von Begin an durchlaufen und mit etwas Glück liefert der Testkode Informationen über das Problem.

Deutlich effektiver ist die Fehlersuche mittels einer in die PC-Entwicklungsumgebung integrierten Debugger Software. Üblicherweise besteht diese Software aus mehreren Fenstern zur Anzeige folgender Informationen:

* Programm- und Datenspeicher des Mikrocontrollers.
* Arbeits- und Konfigurationsregister des Mikrocontrollers.
* Programm Quellkode in Hochsprache (z.B. C) und/oder Assembler.
* Werte von Programm Variablen.

Ausgehend vom Quellkode/Assembler-Fenster kann man den Programmlauf an beliebigen Stellen stoppen, das Programm zeilenweise abarbeiten, Variablen/Speicher/Register anzeigen und auch verändern. Diese Vorgänge werden bei modernen Debuggern mit wenigen Funktionstasten und Kontextmenü gesteuert.

Der Programmlauf kann in einem Software-Simulator oder direkt auf dem Mikrocontroller erfolgen. Leider können Simulatoren weder die Signale der Controller Umgebung noch Interrupts realistisch nachahmen. Hier hilft nur In-System Debugging direkt auf dem Zielsystem.

Für das In-System Debugging wird der Ziel-Mikrocontroller mit seiner In-Circuit Debugging Hardware benutzt. Diese integrierte Hardware kommuniziert über teils genormte Schnittstellen mit der Debugger Software auf dem PC. Als Verbindungsglied dient ein Kabel mit mehr oder weniger komplexer Elektronik. Diese Elektronik, das fehlende Wissen um ihre Funktion und die teils eingebaute Donglefunktion verhindern preisgünstigen Nachbau und machen ihren Hersteller sicher vor unautorisierter Benutzung der Entwicklungsumgebung.

Bei der Vielzahl von Controller- und Compiler-Herstellen ist es kaum möglich einen Überblick über die Debugger Hardware/Software zu geben. Hier nur einige Beispiele:

{| border="1"
|-
!Hersteller
!System
!Preis
|-
| Clone
| JTAG ICE (wenige ATmega Typen)
| ~ 35€
|-
| Atmel
| AVR Dragon (Debugging <= 32kB)
| ~ 55€
|-
| Atmel
| JTAG ICE MKII
| ~ 280€
|-
| Atmel
| AVR ONE!
| ~ 550€
|-
| Microchip
| MPLAB ICD 3
| ab 190€
|-
| Zilog
| USB Smart Kabel
| ~ 30$
|-
| Zilog
| Ethernet Smart Kabel
| ~ 70$
|}

Der JTAG ICE Clone kann nur ältere ATmega Controller debuggen:

* ATmega16, ATmega16L
* ATmega162, ATmega162L, ATmega162V
* ATmega165, ATmega165V
* ATmega169, ATmega169L, ATmega169V
* ATmega32, ATmega32L
* ATmega323, ATmega323L
* ATmega64, ATmega64L
* ATmega128, ATmega128L, AT90CAN128

Atmel [[AVR]] Dragon kann alle ATtiny, ATmega programmieren ist aber auf 32 kB debugbaren Programmcode begrenzt.

[[Zilog]] Produkte sind, ganz zu Unrecht, in Europa kaum bekannt oder erhältlich.

== Störfestigkeit ==
Eigentlich ein wichtiges Thema, andererseits findet man dazu nur sehr wenig Informationen. Bekannt ist beispielsweise, dass bei der [[AVR]]-Familie die ATmegas deutlich störfester sind als die alten AT90S.

== Unterstützung/Community ==
Gerade als Anfänger ist man oft auf die Hilfe anderer angewiesen. Da empfiehlt es sich, der Masse hinterherzulaufen und keine exotischen Typen zu verwenden. Im Bastlerbereich populäre Mikrocontroller-Familien sind die AVRs von Atmel und die PICs von Microchip. Für diese Architekturen gibt es z.B. im Forum dieser Internet-Seite gute und meist auch schnelle Hilfestellung bei Problemen.

ZNEO

2008-10-09T18:57:48Z

Mixer: zu Kategorie Mikrocontroller hinzugefügt

== Einleitung ==
Der Zilog ZNEO (Z16Fx) ist ein 16/32-Bit Mikrocontroller. Der interne Flash Speicher ist 16-Bit organisiert. Jeweils 32 Bit breit sind die 14+2 Arbeitsregister.

Durch 32 Bit Verarbeitungsbreite und Hardware MUL/DIV übersteigt die Leistung des ZNEO das sonst übliche 8-Bit Controller Niveau deutlich.
== Alleinstellungsmerkmal ==
Das unbeschränkte Zilog Entwicklungspaket mit integriertem Editor, C-Compiler, Assembler, In-System-Debugger sowie Programmier- und Debugging-Kabel ist für 30$ zu haben.

Auf den ersten Blick findet man das auch bei anderen Controller Familien. Beim zweiten Hinschauen fehlt aber entweder die Möglichkeit zum Debugging oder die Codegröße ist begrenzt.

Von Laien völlig unterschätzt, das Debugging. Damit verbringt man die meiste Zeit und deshalb ist es das Wichtigste am Programmieren.
Einen Controller ohne In-System Debugging zu programmieren ist so frustrierend und uneffizient wie das Arbeiten in Maschinensprache; Binärzahl für Binärzahl.

== Bauformen ==
Der ZNEO ist als 64-pin LQFP, 68-pin PLCC, 80-Pin QFP und 100-pin LQFP verfügbar. Die 80- und 100-poligen Versionen beinhalten, bis auf eine Ausnahme, ein paralleles Adress-/Daten-Interface zu externen Komponenten.

http://www.mikrocontroller.net/wikifiles/8/8f/ZilogZneoSmall.png

Für Prototyping und Hobby ist die sockelbare 68-pin PLCC Version (Z16F2810VH) mit 128kB Flash, 4kB RAM besonders interessant. Diese ist das Äquivalent der geometrisch kleineren 64-pin LQFP Version Z16F2810AG.

Hier eine optimierte Eagle Library mit den 64- und 68-Pin Bauformen: [http://www.mikrocontroller.net/wikifiles/6/63/ZilogZneoSmall.zip ZilogZneoSmall.zip]

== Eckdaten ==
Der Betriebsspannungsbereich ist 2,7-3,6V. Erwähnenswert ist dabei, dass alle rein digitalen IO Pins externe Spannung bis 5,5V vertragen.
Die intern erzeugte ADC Referenzspannung von 2V steht ab 3V Betriebsspannung zur Verfügung.

Getaktet wird der Controller vom internen Oszillator mit 5.5MHz oder 32kHz, internen Watchdog Timer oder externen Oszillator/Quarz/Resonator/RC-Glied. Die maximale Taktfrequenz ist 20MHz.

Standart Baugruppen sind drei 16-Bit Timer mit PWM, ein dedizierter 6x1/3x2-Kanal PWM Timer, zwei LIN-UART, Infrarot Encoder/Decoder, ESPI, I2C, Watchdog, 12-Kanal 10-Bit ADC, ein Komparator, ein OPV, 4-Kanal DMA, VBO und PO-Reset.

Der Adressraum des ZNEO ist linear und wird mit 24 Bit adressiert. Der C-Compiler reserviert (einstellbar) die untersten 32kB für „const“ Flash-Daten. Diese werden, Befehlsbreite sparend, mit 16 Bit Adresse angesprochen. Oberhalb des nachfolgenden Codebereichs werden Flash-Daten mit 24 Bit adressiert (far).

Die ZNEO Versionen ohne paralleles Interface haben alle 128kB Flash. Bei den übrigen findet man 128, 64 oder 32kB. Dem zur Seite stehen meist 4kB RAM.
Der Flash Speicher ist in 2kB Bänken organisiert die getrennt gelöscht werden können. Damit ist die Emulation des fehlenden EEPROM möglich.
Extern, via parallelem Interface, angebundener Flash Speicher kann wie interner Flash Speicher per Programmierkabel geladen werden.
== Entwicklungshardware ==
Als komplettes Paket empfiehlt sich das Zilog Contest Kit ZNEOCTK0100KIT, verfügbar bei Mouser.com, für 49,99$. Es besteht aus USB Smart Kabel, Universal-Netzteil und ZNEO Contest Board mit Z16F2811FI (128kByte Flash), I2C EEPROM (PCA8550), SPI Thermometer (DS1722) und Punktmatrix LED Display.

Ebenfalls 128kByte intern Flash bietet das Zilog Entwicklungs-Kit Z16F2800100ZCOG für 99,95$. Es basiert auf dem 100-Pin Z16F2811AL20SG, externem Flash 1Mx16, externem SRAM 256Kx16, 3 LEDs, RS232, irDA, USB Smart Kabel und Universal-Netzteil. Diese Karte kann allein stehend oder als Prozessor Modul für das modulare Entwicklungssystem ZGENPRP0100MDS genutzt werden.

Ein Entwicklungsboard kann man aber auch leicht selbst bauen. Notwendig sind eine Lochraster Karte, der Z16F2810VH im PLCC-68 Gehäuse, die passende Fassung für Lochraster, eine 3x2 Stiftleiste für den Anschluss des USB Smart Kabel und einige Kleinteile. Verdrahtet wird das Ganze mit 0,2-0,3mm Fädeldraht. Zur Stromversorgung reichen 4 Rundzellen

http://www.mikrocontroller.net/wikifiles/c/ca/Z16F2810VH_Basic.png

Zum Programmieren und Debuggen benutzt man das preisgünstigste USB Smart Kabel ZUSBSC00100ZACG für 29,95$ oder das ähnliche Ethernet Smart Kabel ZENETSC0100ZACG für 69,99$.
Die bei Kauf meist veraltete Firmware des Smart Kabel sollte auf den neuesten Stand gebracht werden. Aktuelle Firmware Versionen befindet sich, mit einer genauen Update Vorschrift, im Ordner des Zilog Development Systems ZDSII\bin\firmware.

http://www.mikrocontroller.net/wikifiles/8/85/ZilogSmartKabel.png

== Entwicklungssoftware ==
Das Zilog Developer Studio II (ZDS II) ist ein integriertes Entwicklungs- und Debug-Tool für Assembler und C. Zum Zeitpunkt dieser Niederschrift in der Version 4.11.1. Es ist kostenlos und ohne Beschränkungen.

Leider ist es ein lieblos entwickeltes Programm welches zum Absturz neigt. Besondern das Disassembler Fenster und die deaktivierbaren Variablen-Popups sind anfällig.
Trotzt dieser Kritikpunkte ist es gut zu bedienen und nach kurzer Zeit kann man produktiv damit arbeiten.

Das Help-System ist durch die vielen Controllerfamilien etwas unübersichtlich aber vollständig und hilfreich.

Die Hardware spezifische C-Header Datei enthält leider keine symbolischen Konstanten für die Bits der Konfigurations-Register des Controllers. Abhilfe schaffen nachfolgende C Dateien im ZIP: [http://www.mikrocontroller.net/wikifiles/b/bc/ZneoHeader_2008-10-09.zip ZneoHeader_2008-10-09.zip]

Das Flashen des Controllers erfolgt direkt aus ZDS II. 10kB brauchen 8 Sekunden. 100kB sind in 40 Sekunden geladen.

Im debugging Modus des Zielsystems kann man das Programm in getrennten Fenstern auf Hochsprach- und/oder Assembler-Ebene Schritt für Schritt abarbeiten und untersuchen. Der Einzelschritt-Betrieb reagiert relativ träge. Dafür bleibt der Debugger aber im Thread und springt nicht unkontrolliert zu Interrupts. 4 Breakpoints sind gleichzeitig möglich.

Bei Programm-Unterbrechung werden der Callstack, Speicherinhalt, die Arbeits- und Konfigurations-Register, alle lokalen Variablen der aktuellen Funktion und die gewünschten globalen Variablen angezeigt. Natürlich kann man alle diese Werte auch verändern; globale Variable sogar während des Programmlaufs.

Für die Produktion existiert ein separates und gutes Flash Programm SFP.
== Bezugsmöglichkeiten ==
* [http://www.digikey.com/ Digi-Key]
* [http://www.mouser.com/ Mouser Electronics]
== Dokumentation, Tools ==
* [http://www.zilog.com/ Zilog Incorporation]

[[Category:Mikrocontroller]]

ZNEO

2008-10-09T18:45:57Z

Mixer: /* Alleinstellungsmerkmal */

FPGA

2008-09-11T16:31:52Z

Mixer: /* Raggedstone 1 - Spartan-3 Development PCI-Karte */

FPGA ist die Abkürzung für "'''F'''ield '''P'''rogrammable '''G'''ate '''A'''rray".

== Aufbau ==

=== Grundelemente ===
Ein FPGA besteht, ähnlich wie ein [[CPLD]], aus vielen Logikelementen, hauptsächlich Flip-Flops (FF) und LUTs (LUT = Lookup-Table), die über elektronische "Schalter" entsprechend der vom Entwickler gewünschten Funktion miteinander verknüpft werden können.

Eine '''LUT''' kann eine beliebige kombinatorische Funktion (NAND, XOR, AND, Multiplexer etc.) aus den Eingangssignalen realisieren. Die Anzahl der Eingangssignale pro LUT ist vom FPGA abhängig und liegt meist zwischen 4 und 6. Für Funktionen, die mehr Eingänge erfordern, als eine einzige LUT besitzt (hohes Fan-In), werden mehrere LUTs direkt miteinander verschaltet. Die '''Flip-Flops''' dienen dazu, Signalwerte zwischenzuspeichern, um sie im nächsten Takt weiterverarbeiten zu können. Das Verhältnis zwischen der Anzahl der LUTs und der Anzahl der Flip-Flops ist meist 1:1. Aktuelle FPGAs bestehen aus bis zu einigen zehntausend Logikelementen.

Die logischen Schalter und Speicher sind in den meisten FPGAs durch SRAM-Speicherzellen realisiert, welche beim Bootprozess passend geladen werden. Das Laden dieser Konfigurationsdaten bzw. Verknüpfungsregeln geschieht dabei in der Regel aus einem speziellen Flash-ROM-Baustein heraus. Es kann aber auch ein Mikrocontroller benutzt werden. Die meisten (SRAM-basierten) FPGAs bieten daher für diesen Konfigurationsvorgang mehrere Modi (seriell, parallel, Master/Slave) an. Da die SRAM-Zellen ihren Inhalt beim Abschalten der Versorgungsspannung verlieren, muss ein SRAM-basierter FPGA bei jedem Einschalten neukonfiguriert werden. Daher benötigt ein solcher FPGA einige Millisekunden bis zur Betriebsbereitschaft.

Eine FPGA-Familie beinhaltet Typen mit unterschiedlicher Anzahl und Komplexität von Logikzellen. So enthält ein Spartan3-1000 ca. 2,5 mal mehr Logik (FF, LUTs) als ein Spartan3-400.

FPGAs mit nichtflüchtigem Speicher basieren auf EEPROM-, Flash- (einige Familien von Lattice) oder AntiFuse- (Actel) Technologie. Die sogenannten AntiFuse FPGAs sind einmalig programmierbar.

=== I/O Anschlüsse ===
FPGAs unterstützen als universal einsetzbare Digital-ICs eine Vielzahl von Signalstandards. Üblich sind verschiedene TTL-Pegel (5V, 3,3V, 2,5V), differentielle Signalstandards (LVDS, GTL) und im Hochpreisbereich serielle Standards bis zu 4 Gbps. Oftmals sind weitere Eigenschaften wie Treiberstärke und Flankensteilheit für jeden benutzerdefinierbaren Anschluss (User-IO) einstellbar. Meist sind die Pins zu Bänken mit gleichem I/O Standard zusammengefasst. Innerhalb einer solchen Bank arbeiten alle Pins im gleichen I/O Standard und mit der selben I/O Spannung (H-Pegel).

Ebenso können FPGA-interne Pull-Up und Pull-Down-Widerstände zugeschaltet werden, Terminierung wird ebenfalls unterstützt. Zudem befinden sich hinter vielen IO-Pads sog. [[boundary scan]] Zellen.

Das I/O Verhalten wird mit den IO-Constraints in einem setting-File (Xilinx *.ucf, Altera *.acf) festgelegt.

Einige Pins übernehmen besondere Funktionen und sind somit vom Anwender nicht uneingeschränkt oder z.T. auch gar nicht nutzbar. Darzu zählen neben der JTAg-Schnittstelle z.B. die Pins zum Einlesen der Konfigurationsdaten.

Ferner sind einige wenige Pins (2 - 8) zum Einspeisen des Taktes für das Design vorgesehen. Für schnelle Schaltung müssen diese reserviertern Pins benutzt werden.

Die Hersteller bieten FPGAs mit gleicher Anzahl von Logikelementen in unterschiedlichen Gehäusen an. So kann der FPGA mit der passenden Anzahl von Pins eingesetzt werden. Das obere Ende markieren Chips mit über 1000 I/Os, die kleinsten bieten ca. 80 User-I/O. Oft werden nur BGA und QFP Gehäuse (bis ca. 240(?) Pins) angeboten.

=== Komplexere Blöcke (Multiplizierer, RAM, PLL/DLL) ===
Neben den einfachen Flip-Flops beinhalten FPGAs darüber hinaus komplexe Routing- und Speicherkonfigurationsoptionen innerhalb und außerhalb der logischen Elemente (LEs), die es gestatten, komplexe Schalt- und Rechenstrukturen aufzubauen. Für rechenintensive Designs, z.B. in der Signalverarbeitung, enthalten viele FPGAs Multiplizierer direkt auf dem Chip, die in einem einzigen Taktzyklus Multiplikationen durchführen können.

Ferner haben FPGAs oft einen von den LEs getrennt verfügbaren RAM-Bereich integriert, der sich in vielfältiger Weise ansprechen lässt. So können damit Single- oder Dualport-RAMs mit variabler Bitbreite erzeugt werden. Üblich sind mehrere (4 - 30) kleinere Dualport RAM-Blöcke von 4 - 16 kbit. Einige Familien besitzen einen größeren internen RAM, andere spezielle FIFO-Blöcke.

Zur Generierung spezieller Takte sind PLL-Komponenten (phase locked loop) auf dem FPGA integriert. Einige Hersteller setzen mit dem selben Ziel DLL-Blöcke (delay locked loop) ein. Mittels dieser Blöcke können aus einem Taktsignal weitere erzeugt werden. Typisch sind Taktverdopplung oder -vervielfachung. Ebenso kann der Takt geteilt werden oder ein Signal gleicher Frequenz, aber um eine halbe, viertel usw. Periode verschoben erzeugt werden. Typische Anwendungen sind die Ansteuerung von DDR-RAMs oder die Kompensation von Laufzeitunterschieden zwischen Takt und mit diesem getakteten Steuersignalen. Meist sind 2 - 8 Taktnetzwerke und PLL/DLLs gleicher Anzahl integriert. Siehe auch [[Taktung FPGA/CPLD]].

=== CPU im FPGA ===

Programmierbare Prozessoren sind auch häufig bei FPGA Designs unverzichtbar. Diese sind zwar im Allgemeinen langsamer und weniger effizient als eine vollständige Implementation aus Logik-Primitiven -- aber auch deutlich
einfacher zu beherrschen. Insbesondere bei sequentiellen Aufgaben (Benutzerinterface, komplexe Steueraufgaben etc.) wird man gerne auf eine
klassische CPU zurückgreifen.

Manche FPGAs integrieren einem oder mehrere Prozessorkerne (z.B. [[AVR]] bei Atmels FPSLIC, PowerPC bei Xilinx' Virtex-4 oder ARM-Cortex-M1 bei IGLOO-FPGA von [http://www.actel.com actel]) als ''HardCores'' auf einem IC.

Auf der anderen Seite gibt es auch ''SoftCores'', Prozessorkerne die als Quelltext oder als vor-synthetisierte Netzliste vorliegen. In Abhänigkeit von den zur Verfügung stehenden Resourcen können diese ''SoftCores'' beliebig instantiiert werden. Es gibt eine Vielzahl verschiedener ''SoftCores'' --
Teilweise kompatibel zu etablierten Prozessorarchitekturen (MIPS, SPARC, AVR), zum Teil optimiert auf die FPGAs einzelner Hersteller. Auch auf vergleichsweise
kleine aktuelle FPGAs kann man problemlos eine 32bit-RISC-CPU integrieren.
Unter [[FPGA Soft Core]] findet man eine Liste einiger weit verbreiteter ''SoftCores''

Als Programmspeicher werden die FPGA-internen RAM-Blöcke oder externe Speicher-ICs (SDRAM, SRAM) genutzt. Für einige Prozessorkerne stehen Hochsprachen wie C, C++ etc. zur Verfügung, andere werden in Assembler programmiert.

== Eigenschaften ==
=== Geschwindigkeit ===
Die maximale „Geschwindigkeit“ eines FPGAs ist von der verwendeten Halbleitertechnologie (Prozess, Strukturgrößen), der internen Schaltungstopologie (Komplexität der LEs), Vorhandensein von harten Strukturen und vor allem vom Design abhängig. Dabei sind der sogenannte Datendurchsatz und die rein maximale Systemtaktfrequenz zu unterscheiden. Die erreichbare Taktfrequenz lässt sich ohne detaillierte Kenntnis des Designs nicht abschätzen, möglich sind je nach »Speed Grade« des ICs typischerweise Taktfrequenzen von 300-500 MHz für die Schaltgeschwindigkeit der reinen Logikelemente. Je nach der Anzahl und Komplexität der pro Takt durchzuführenden Operationen ergeben sich reale reale Systemtaktfrequenzen von meist 10-200 MHz. Maßgeblich ist, in wieweit das Design auf Fläche bzw. Geschwindigkeit hin optimiert und vom Tool synthetisiert wurde: Durch das Einbringen von zusätzlichen Registerstufen lassen sich z.B. zeitkritische Pfade entschärfen, sodass die Frequenz des Chips angehoben werden kann und der effektive Datendurchsatz trotz teilweise mehr CLKs zwischen Ein- und Ausgängen (Latenz) erhöht wird. Dieser lässt sich darüber hinaus durch die Nutzung paralleler Architekturen verbessern.

Die Systemfrequenz kann-, muss aber nicht der Frequenz entsprechen, mit der Daten zyklisch eingetaktet und verarbeitet werden; zudem sind Schaltungsteile mit unterschiedlichen Taktfrequenzen zu unterscheiden: Mit einem Systemtakt1 von 20 MHz lassen sich z.B. 18-Bit AD-Wandler auslesen, die so z.B. alle 1 µs neue Daten liefern, die verarbeitet werden müssen. Bei der Nutzung von 5 solchen Wandlern, die sequentiell verarbeitet werden, lägen 5 MHz Datenfrequenz vor. Für andere Schaltungsteile, die z.B. asynchron an die Peripherie andocken, sowie reine »state machines« können Schaltungsteile auf der 2-4 fachen Frequenz betrieben werden.

Generell sind Fläche und Geschwindigkeit konkurrierende Größen, zwischen denen ein Optimum gefunden werden muss. Für die preiswerten FPGA-Serien wie Spartan (Xilinx) und Cyclone (Altera) sind aufgrund technologischer Randbedingungen etwa 10-30% weniger Taktgeschwindigkeit bei gleichem Design zu erwarten, bzw. muss mit mehr Verbrauch an Logikelementen und Taktzyklen gerechnet werden (weniger Routingreserven, geringere Zahl von LUT-Eingängen, weniger hard-ressourcen).

Identische Chips werden oft in 2 oder mehr Geschwindigkeitsklassen angeboten, die sich meist durch Bauteilselektion bei der Produktion ergeben. Grob kann man ca. 5%-10% höhere Taktung zwischen zwei Speedgrades erwarten.

== Hersteller ==
Die größten Hersteller von FPGAs sind Altera und Xilinx. Weitere Hersteller sind Lattice, Actel und Atmel.

* [http://www.altera.com Altera]
* [http://www.xilinx.com Xilinx]
* [http://www.lattice.com Lattice]
* [http://www.actel.com Actel]

== Anwendung ==

Der Aufbau komplizierter, applikationsnaher Strukturen wird meist durch automatische Routing- und Synthesewerkzeuge erledigt, welche mit einer logischen, funktionellen Beschreibung der Architektur in einer Hardwarebeschreibungssprache wie z.B. VHDL "gefüttert" werden. Die Hardwarebeschreibung in VHDL gelingt ihrerseits z.B. mit VHDL-generierenden Werkzeugen, mittels derer zuvor Logikstrukturen, hardwarenahe Strukturen, Ablaufdiagramme und Zustandsautomaten formuliert wurden.

Durch die Standardisierung der Architektur einerseits und die Entkoppplung von applikationsorientierter Beschreibung sowie Chip- und Hersteller-spezifischer Synthese andererseits, wird die Hardware quasi als Software gebaut. Dies wiederum schafft alle Optionen der Wiederverwendung und Austausch von "Hardwareteilen". So stehen inzwischen komplett nutzbare Schaltungen wie serielle Bausteine, RAM-Controller und vieles mehr als Open Source zur Verfügung.

== Entwicklungsboards und Starterkits ==
=== Boards für Xilinx-FPGAs ===

{| border="1" class="sortable" id="fpgaevalboards"
|-
! Bezeichn.
! Preis (€)
! FPGA
! RAM (MByte)
! Flash (MByte)
! USB
! Ethernet
! RS-232
! µC
! Eingabe
! sonst.
|-
| [http://www.knjn.com/board_Xylo.html Xylo-L]
| 130
| XC3S500E
| -
| -
| 2.0
| 10base-T
| -
| LPC213x
| -
|
|-
| [http://www.xilinx.com/s3estarter Spartan3e Starter Kit]
| 180
| XC3S500E
| 64 MB DDR-SDRAM
| 16
| (JTAG)
| 10/100
| 2x
| -
| 4 Taster, 1 Drehgeber, 4 Schalter
| Coolrunner CPLD, LCD, 3-Bit VGA, PS/2
|-
| [http://www.digilentinc.com/Products/Detail.cfm?Nav1=Products&Nav2=Programmable&Prod=S3BOARD Digilent Spartan-3]
| 100
| XC3S200/400/1000
| 1
| -
| -
| -
| 1x
| -
| 4 Taster, 8 Schalter
| VGA, PS/2, 7seg
|-
| [[Digilent Nexys]]
| 100
| XC3S200/400/1000
| 16
| 4
| 2.0
| -
| -
| -
| 4 Taster, 8 Schalter
| 7seg, Programmierung & Stromversorgung über USB
|-
| [http://www.uxibo.de Uxibo]
| 88
| XC2S200E
| -
| -
| 1.1
| -
| -
| -
| 4 Taster, 8 Schalter
| VGA I/O, Videomux, dual PS/2, 7seg, Buzzer, IOs auf Pinleisten, dual-channel FTDI2232C, 48 MHz + prog. Oszillator, Programmierung & Stromversorgung über USB
|-
| [http://www.fpgaz.com/wiki/doku.php?id=fpgaz:usbp:hw FPGAz USBP]
| $135
| XC3S400
| -
| -
| 2.0
| -
| -
| Cypress FX2
| 2 Taster
| 8 LEDs, I2C-EEPROM
|-
| [http://www.cesys.com/fpga/spartan/efm01_de.html EFM 01] Embedded FPGA Modul
| 145,-
| XC3S500E
| -
| 4
| 2.0
| -
| -
| FX-2
| -
| 28 x 44mm, 50 I/O auf 2.54mm Stiftleiste, WIN und LINUX Treiber
|}

==== Raggedstone 1 - Spartan-3 Development PCI-Karte ====
* Spartan-3 FPGA FG456-Package
* 32 bit, 33 MHz, 3.3/5V PCI interface
* 4Mbit Flash Memory
* 16KBit serielles EEprom
* 4 x 7 Segment Anzeigen LED, abnehmbar
* LM75 Temperatursensor
* viele DIL-Header für eigene Erweiterungen, verschiedene werden auch durch Hersteller angeboten
* 2 Drucktaster
* Mit dem PCI-Interface kann bei entsprechender Programmierung des FPGA auf den PCI-Bus eines Hostrechners zugegriffen werden, Beispieldesign unter http://projects.varxec.net/raggedstone1
* Webseite: http://www.enterpoint.co.uk/moelbryn/raggedstone1.html
* Preis mit XC3S400 ca. €145,- (inkl MwSt.)
* Preis mit XC3S1500 ca. €255,- (inkl. MwSt.)

==== LiveDesign Evaluation Board von Altium ====
* Kompatibel mit den LiveDesign-fähigen Entwicklungstools von Altium
* Xilinx-Version direkt mit ISE Webpack nutzbar
* Xilinx XC3S1000-4FG456C, wahlweise aber auch mit Altera EP1C12F324C8 (s.u.)
* Mit Flachbandkabel für PC-Verbindung (Druckerport) sowie weiteren Kabeln und Verbindern
* Peripherie: LEDs, Dip-Schalter, 6-stellige Siebensegmentanzeige, Taster, Stereo-DAC, zwei 256K x 16 RAMs
* ''kein'' on-board Flash RAM für FPGA-Konfiguration, diese muss nach dem Einschalten neu geladen werden
* Ports: PS2-Maus & -Tastatur, RS232, VGA (512 Farben), 2x18 IO-Pins für allgemeine Zwecke
* Listenpreis $99,- Endpreis: ~150 Euro (inkl. MwSt. und Versand)

==== BurchED ====
http://www.burched.com/index.html
australischer Anbieter von Xilinx-Evaluationsboards
zur Zeit Webseite im Umbau

==== Trenz-Electronic ====
http://www.trenz-electronic.de/products.html
* Kleines FPGA Board mit ucLinux und Virtex-II PowerPC, optional: ucLinux und Microblaze Softprozessor im Spartan-3 FPGA
* Spartan-3 FPGA Mikromodul mit 200K bis 1000K Systemgattern
* Pal/Gal kompatible FPGA und CPLD Module

==== Simple-Solutions ====
http://www.simple-solutions.de/de/products/index.php
Mehrere Spartan3-FPGAs - Boards

==== CESYS ====
http://www.cesys.com

Cesys ist Entwickler und Hersteller von FPGA-boards mit Sitz in Deutschland.

* Verschiedene FPGA boards mit USB, PCI und PCIe Schnittstellen im Lieferprogramm
* Je nach Ausführung mit Spartan-2/3/3E, Virtex2/2PRO/4
* verschiedene Speicherkonfigurationen (SO-DIMM, SRAM, SDRAM, DDR2)

=== Boards für Altera-FPGAs ===
==== LiveDesign Evaluation Board von Altium ====
* Kompatibel mit den LiveDesign-fähigen Entwicklungstools von Altium
* * Wahlweise mit Altera EP1C12F324C8 oder Xilinx XC3S1000-4FG456C
* Mit Flachbandkabel für PC-Verbindung (Druckerport) sowie weiteren Kabeln und Verbindern
* Peripherie: LEDs, Dip-Schalter, 6-stellige Siebensegmentanzeige, Taster, Stereo-DAC, zwei 256K x 16 RAMs
* ''kein'' on-board Flash RAM für FPGA-Konfiguration, diese muss nach dem Einschalten neu geladen werden
* Ports: PS2-Maus & -Tastatur, RS232, VGA (512 Farben), 2x18 IO-Pins für allgemeine Zwecke
* Endpreis: ~150 Euro (inkl. MwSt. und Versand)

==== Terasic TREX C1 Multimedia Development Kit ====
* Altera EP1C6Q240C8 & EP1S Serial Configuration Device
* Built-in USB Blaster programming circuitry (JTAG and AS mode)
* 1 MiB Flash Memory & 8 MiB SDRAM (1M x 4 x 16)
* CF Card Socket, 16-bit CD-quality Audio DAC
* TV Encoder, VGA, RS-232, PS/2, and more
* Many reference designs and C++ applications
* [http://www.terasic.com.tw/cgi-bin/page/archive.pl?Language=English&CategoryNo=39&No=14 www.terasic.com.tw]
* fertiger Core eines CPC6128 (8-Bit Homecomputer von 1984) für dieses Board, inlusive Sourcecode (eigener Z80 in AHDL, mit 24MHz eingesetzt): [http://www.symbos.de/trex.htm http://www.symbos.de/trex.htm]
* Listenpreis $149,-

==== Altera Cyclone II 2C20 ====
* Altera Cyclone II EP2C20F484C7N FPGA mit 20000 LEs
* USB-BlasterTM download cable (integriert)
* EPCS4 serial configuration Flash
* 8-Mbyte SDRAM, 512-Kb SRAM, 4-Mbyte flash
* externer SMA - Clock-Eingang
* 24-bit Audio coder/decoder (CODEC)
* 10 Schalter, 4 Druckknöpfe inkl Reset
* 4St. 7-Segmentanzeigen, 10 rote LEDs + 8 grüne LEDs
* VGA, RS-232, and PS/2 Stecker
* Zwei 40-pin expansion ports + SD/MMC socket
* USB-Kabel, externes Steckernetztteil, CD-Rom
* Reference designs
* Qartus II Web Edition + NIOS II Web Edition
* http://www.altera.com/products/devkits/altera/kit-cyc2-2C20N.html
* Listenpreis $150,-

==== Hpe Mini AC II - Altera Cyclone board von Gleichmann Research ====
* Altera Cyclone II EP2C35 FPGA (speed grade 6)
* Mit reprogrammierbarem Flash zur automatischen FPGA-Konfiguration
* 25 pin SUB-D connector (parallel) für direktes FPGA-Programmieren
* RS232 (9 pin SUB-D)
* VGA (15 pin SUB-D) mit 64 möglichen Farben
* Ethernet 10/100 Mbit/s, full/half duplex
* 1 USB 2.0 compatible full-speed target connector
* 3 USB 2.0 compatible full-speed host connectors
* Santa Cruz connector mit 40 nutzbaren I/Os
* Audio interface (line-in and line-out) mit CODEC
* SODIMM144 Sockel für (SDRAM) 256MB
* SDRAM-Speichersockel mit nur 32-Bit angebunden, die Hälfte des Speichers bleibt nicht nutzbar
* 25 MHz oscillator
* Prototyping area, Lötfläche
* 8 LEDs, grün, blau, 3x4 key matrix, 4-bit DIP switch
* LCD connector, 2-character 7-segment display
* Single step Knopf und Reset Knopf
* Parallelportkabel für PC
* Beispieldesign, Testprogramme, Datenblätter
* LEON3-CPU Design inkl. Source Code, Quartus IDE, SnapGear Linux
* Je nach Ausführung des Flashs €399,- bis €499,-

==== Altera DE2 - Development and Education Board ====
* Altera Cyclone II 2C35 FPGA mit 35000 LEs
* Altera Serial Configuration devices (EPCS16) für Cyclone II 2C35
* USB Blaster board zur Programmierung und User API
* 8 MB SDRAM, 4 MB Flash Memory, 512KB SRAM
* SD Card Sockel, RS-232, Ethernet, 10-bit VGA, 24-bit Audio CODEC
* TV Decoder (NTSC/PAL), IrDA, USB (Host + Slave)
* Viele Besipiel mit Source Code wie TV, SD Music Player)
* [http://wwwab.fh-wedel.de/bause/handouts/vhdl/VhdlEinfuehrung.pdf Kleines aber nettes Tutorial zum Altera DE2 Dev. Board]
* Listenpreis US $495,-

==== Cyclone III embedded Development Kit====
* Altera Cyclone III EP3C25 FPGA
* 640x480 LCD Display mit touch screen function
* MiniSD-Card Sockel
* Audio Interface ADC CODEC
* 10/100 Mbit Fast Ethernet Schnittstelle
* FPGA-Konfiguration über USB
* NIOS II EVAL Lizenz
* IP LIB Altera
* Listenpreis US $495,- ueber ALtera Webseite
* Bei EBV €349,- inkl. MwSt.

==== Cyclone II EP2C35 Entwicklungsboard ====
* Altera Cyclone II EP2C35-F672C8 FPGA mit 33.216 LEs
* Insgesamt 172 I/Os exklusiv verfügbar
* Bis zu 256 MByte SDRAM (SODIMM Speichermodul, 64-Bit Busanbindung)
* 16 MByte Flash (16-Bit Busanbindung)
* MiniSD-Card Sockel
* 10/100 Mbit Fast Ethernet Schnittstellenkontroller
* USB 2.0 high speed (480 Mbit) Schnittstellenkontroller
* FPGA-Konfiguration über USB
* Abmessungen: 96mm x 68mm
* Kompatibel mit der frei verfügbaren Altera Entwicklungssoftware
* http://www.fpga-dev.de/index.php?site=ep2c35_beschreibung
* wird in regelmässigen Abständen für 169,- Euro über ebay vertrieben (einfach nach "altera cyclone" suchen)

==== NanoBoard-NB1 von Altium ====
* kompatibel mit den LiveDesign-fähigen Entwicklungstools von Altium
* Unterstützt eine breite Palette von Ziel-FPGAs durch Aufsteckplatinen
* Altera Cyclone (EP1C12-Q240C7) Aufsteckplatine enthalten
* Xilinx Spartan IIE (XC2S300E-PQ208) im Lieferumfang enthalten
* Enthält Stromversorgung mit verschiedenen Steckern für unterschiedliche Konfigurationen
* Mit Flachbandkabel für PC-Verbindung sowie weiteren Kabeln und Verbindern
* NanoBoard-NB1 Reference-Handbuch zur Hardware
* Peripherie: LCD, LEDs, Dip-Schalter, Tastenblock, Summer, ADC/DAC, 256K x 8 RAM, 8 MiB Serial Flash RAM, on-board Serial Flash RAM für FPGA-Konfig.
* Ports: PS2-Maus & -Tastatur, RS232, CAN, VGA, I2C, IO Stecker für allg. Zwecke
* Upgradefähige NanoBoard Controller Firmware
* Stabiler NanoBard-Sockel
* Listenpreis €995,-
=== Debugging-Hilfen ===
==== BusProbe, der Debugging Core von abaxor engineering ====
Gerade beim Debugging größerer FPGA-Designs ist es oft notwendig auf interne Signale und Busse zuzugreifen, ohne sie an Pins des FPGAs legen zu können.
Mit der BusProbe kann der Entwickler den Signalfluss im FPGA-Design auch über einen längeren Zeitraum überwachen und am PC aufzeichnen. Der Core verarbeitet an jedem Eingang einen kompletten Bus.

Die Daten werden gemultiplext zum PC geschickt und dort per Software demultiplext. Im PC erfolgt auch die Auswertung mit beliebigen Analyse-Tools.

Gegenüber dem Betriebssystem verhält sich die BusProbe wie eine Festplatte, von der die Daten mit gewöhnlichen Zugriffen gelesen werden können.

* Streaming der Daten zum PC mit mehr als 20 MByte/s
* keine Treiber im PC da Nutzung von Standardschnittstellen (USB oder IDE)
* Hot-Pluging
* Visualisierung mit beliebigen Programmen
* geringer Logikaufwand

[http://www.abaxor.de/produkte.html abaxor.de-Webseite]

==== open source Logikanalysator von sump.org====
Ein einfacher, übersichtlicher Logikanalysator findet sich auf sump.org. Er liegt im Quelltext vor wird mit ins Design einsynthetisiert. Als Speicher dient wahlweise SRAM oder intern RAM. Es können 32 Kanäle mit 100 MHz (oder weniger) gesampelt werden. Die Bediensoftware läuft platformunabhängig unter Java und benötigt eine serielle Schnittstelle (auch über USB-seriell Wandler) zum Core.

[http://de.sump.org/projects/analyzer/ sump.org-Webseite]

== Siehe auch ==
* [[Hardwarebeschreibungssprachen]]
* [[Reset für FPGA/CPLD]]
* [[Taktung FPGA/CPLD]]
* Projekt [[Audio-DSP mit Spartan 3-FPGA]]

== Weblinks ==
* [http://www.fpga4fun.com/index.html FPGA4Fun] - FPGA-Projekte, größtenteils mit Altera und Verilog
* [http://video.google.com/videoplay?docid=-4969729965240981475 Ein Vortrag, auf Englisch: General Purpose, Low Power Supercomputing Using Reconfiguration Logic]
* http://www.opencores.org - FPGA-Projekte, Opensource, jeder kann seine Eigen einstellen und an andere mitarbeiten. U.a. verschiede CPUs für FPGAs.
* http://members.optushome.com.au/jekent/FPGA.htm

[[Category:FPGA und Co]]

FPGA

2008-09-11T16:31:08Z

Mixer: /* Cyclone III embedded Development Kit */

FPGA ist die Abkürzung für "'''F'''ield '''P'''rogrammable '''G'''ate '''A'''rray".

== Aufbau ==

=== Grundelemente ===
Ein FPGA besteht, ähnlich wie ein [[CPLD]], aus vielen Logikelementen, hauptsächlich Flip-Flops (FF) und LUTs (LUT = Lookup-Table), die über elektronische "Schalter" entsprechend der vom Entwickler gewünschten Funktion miteinander verknüpft werden können.

Eine '''LUT''' kann eine beliebige kombinatorische Funktion (NAND, XOR, AND, Multiplexer etc.) aus den Eingangssignalen realisieren. Die Anzahl der Eingangssignale pro LUT ist vom FPGA abhängig und liegt meist zwischen 4 und 6. Für Funktionen, die mehr Eingänge erfordern, als eine einzige LUT besitzt (hohes Fan-In), werden mehrere LUTs direkt miteinander verschaltet. Die '''Flip-Flops''' dienen dazu, Signalwerte zwischenzuspeichern, um sie im nächsten Takt weiterverarbeiten zu können. Das Verhältnis zwischen der Anzahl der LUTs und der Anzahl der Flip-Flops ist meist 1:1. Aktuelle FPGAs bestehen aus bis zu einigen zehntausend Logikelementen.

Die logischen Schalter und Speicher sind in den meisten FPGAs durch SRAM-Speicherzellen realisiert, welche beim Bootprozess passend geladen werden. Das Laden dieser Konfigurationsdaten bzw. Verknüpfungsregeln geschieht dabei in der Regel aus einem speziellen Flash-ROM-Baustein heraus. Es kann aber auch ein Mikrocontroller benutzt werden. Die meisten (SRAM-basierten) FPGAs bieten daher für diesen Konfigurationsvorgang mehrere Modi (seriell, parallel, Master/Slave) an. Da die SRAM-Zellen ihren Inhalt beim Abschalten der Versorgungsspannung verlieren, muss ein SRAM-basierter FPGA bei jedem Einschalten neukonfiguriert werden. Daher benötigt ein solcher FPGA einige Millisekunden bis zur Betriebsbereitschaft.

Eine FPGA-Familie beinhaltet Typen mit unterschiedlicher Anzahl und Komplexität von Logikzellen. So enthält ein Spartan3-1000 ca. 2,5 mal mehr Logik (FF, LUTs) als ein Spartan3-400.

FPGAs mit nichtflüchtigem Speicher basieren auf EEPROM-, Flash- (einige Familien von Lattice) oder AntiFuse- (Actel) Technologie. Die sogenannten AntiFuse FPGAs sind einmalig programmierbar.

=== I/O Anschlüsse ===
FPGAs unterstützen als universal einsetzbare Digital-ICs eine Vielzahl von Signalstandards. Üblich sind verschiedene TTL-Pegel (5V, 3,3V, 2,5V), differentielle Signalstandards (LVDS, GTL) und im Hochpreisbereich serielle Standards bis zu 4 Gbps. Oftmals sind weitere Eigenschaften wie Treiberstärke und Flankensteilheit für jeden benutzerdefinierbaren Anschluss (User-IO) einstellbar. Meist sind die Pins zu Bänken mit gleichem I/O Standard zusammengefasst. Innerhalb einer solchen Bank arbeiten alle Pins im gleichen I/O Standard und mit der selben I/O Spannung (H-Pegel).

Ebenso können FPGA-interne Pull-Up und Pull-Down-Widerstände zugeschaltet werden, Terminierung wird ebenfalls unterstützt. Zudem befinden sich hinter vielen IO-Pads sog. [[boundary scan]] Zellen.

Das I/O Verhalten wird mit den IO-Constraints in einem setting-File (Xilinx *.ucf, Altera *.acf) festgelegt.

Einige Pins übernehmen besondere Funktionen und sind somit vom Anwender nicht uneingeschränkt oder z.T. auch gar nicht nutzbar. Darzu zählen neben der JTAg-Schnittstelle z.B. die Pins zum Einlesen der Konfigurationsdaten.

Ferner sind einige wenige Pins (2 - 8) zum Einspeisen des Taktes für das Design vorgesehen. Für schnelle Schaltung müssen diese reserviertern Pins benutzt werden.

Die Hersteller bieten FPGAs mit gleicher Anzahl von Logikelementen in unterschiedlichen Gehäusen an. So kann der FPGA mit der passenden Anzahl von Pins eingesetzt werden. Das obere Ende markieren Chips mit über 1000 I/Os, die kleinsten bieten ca. 80 User-I/O. Oft werden nur BGA und QFP Gehäuse (bis ca. 240(?) Pins) angeboten.

=== Komplexere Blöcke (Multiplizierer, RAM, PLL/DLL) ===
Neben den einfachen Flip-Flops beinhalten FPGAs darüber hinaus komplexe Routing- und Speicherkonfigurationsoptionen innerhalb und außerhalb der logischen Elemente (LEs), die es gestatten, komplexe Schalt- und Rechenstrukturen aufzubauen. Für rechenintensive Designs, z.B. in der Signalverarbeitung, enthalten viele FPGAs Multiplizierer direkt auf dem Chip, die in einem einzigen Taktzyklus Multiplikationen durchführen können.

Ferner haben FPGAs oft einen von den LEs getrennt verfügbaren RAM-Bereich integriert, der sich in vielfältiger Weise ansprechen lässt. So können damit Single- oder Dualport-RAMs mit variabler Bitbreite erzeugt werden. Üblich sind mehrere (4 - 30) kleinere Dualport RAM-Blöcke von 4 - 16 kbit. Einige Familien besitzen einen größeren internen RAM, andere spezielle FIFO-Blöcke.

Zur Generierung spezieller Takte sind PLL-Komponenten (phase locked loop) auf dem FPGA integriert. Einige Hersteller setzen mit dem selben Ziel DLL-Blöcke (delay locked loop) ein. Mittels dieser Blöcke können aus einem Taktsignal weitere erzeugt werden. Typisch sind Taktverdopplung oder -vervielfachung. Ebenso kann der Takt geteilt werden oder ein Signal gleicher Frequenz, aber um eine halbe, viertel usw. Periode verschoben erzeugt werden. Typische Anwendungen sind die Ansteuerung von DDR-RAMs oder die Kompensation von Laufzeitunterschieden zwischen Takt und mit diesem getakteten Steuersignalen. Meist sind 2 - 8 Taktnetzwerke und PLL/DLLs gleicher Anzahl integriert. Siehe auch [[Taktung FPGA/CPLD]].

=== CPU im FPGA ===

Programmierbare Prozessoren sind auch häufig bei FPGA Designs unverzichtbar. Diese sind zwar im Allgemeinen langsamer und weniger effizient als eine vollständige Implementation aus Logik-Primitiven -- aber auch deutlich
einfacher zu beherrschen. Insbesondere bei sequentiellen Aufgaben (Benutzerinterface, komplexe Steueraufgaben etc.) wird man gerne auf eine
klassische CPU zurückgreifen.

Manche FPGAs integrieren einem oder mehrere Prozessorkerne (z.B. [[AVR]] bei Atmels FPSLIC, PowerPC bei Xilinx' Virtex-4 oder ARM-Cortex-M1 bei IGLOO-FPGA von [http://www.actel.com actel]) als ''HardCores'' auf einem IC.

Auf der anderen Seite gibt es auch ''SoftCores'', Prozessorkerne die als Quelltext oder als vor-synthetisierte Netzliste vorliegen. In Abhänigkeit von den zur Verfügung stehenden Resourcen können diese ''SoftCores'' beliebig instantiiert werden. Es gibt eine Vielzahl verschiedener ''SoftCores'' --
Teilweise kompatibel zu etablierten Prozessorarchitekturen (MIPS, SPARC, AVR), zum Teil optimiert auf die FPGAs einzelner Hersteller. Auch auf vergleichsweise
kleine aktuelle FPGAs kann man problemlos eine 32bit-RISC-CPU integrieren.
Unter [[FPGA Soft Core]] findet man eine Liste einiger weit verbreiteter ''SoftCores''

Als Programmspeicher werden die FPGA-internen RAM-Blöcke oder externe Speicher-ICs (SDRAM, SRAM) genutzt. Für einige Prozessorkerne stehen Hochsprachen wie C, C++ etc. zur Verfügung, andere werden in Assembler programmiert.

== Eigenschaften ==
=== Geschwindigkeit ===
Die maximale „Geschwindigkeit“ eines FPGAs ist von der verwendeten Halbleitertechnologie (Prozess, Strukturgrößen), der internen Schaltungstopologie (Komplexität der LEs), Vorhandensein von harten Strukturen und vor allem vom Design abhängig. Dabei sind der sogenannte Datendurchsatz und die rein maximale Systemtaktfrequenz zu unterscheiden. Die erreichbare Taktfrequenz lässt sich ohne detaillierte Kenntnis des Designs nicht abschätzen, möglich sind je nach »Speed Grade« des ICs typischerweise Taktfrequenzen von 300-500 MHz für die Schaltgeschwindigkeit der reinen Logikelemente. Je nach der Anzahl und Komplexität der pro Takt durchzuführenden Operationen ergeben sich reale reale Systemtaktfrequenzen von meist 10-200 MHz. Maßgeblich ist, in wieweit das Design auf Fläche bzw. Geschwindigkeit hin optimiert und vom Tool synthetisiert wurde: Durch das Einbringen von zusätzlichen Registerstufen lassen sich z.B. zeitkritische Pfade entschärfen, sodass die Frequenz des Chips angehoben werden kann und der effektive Datendurchsatz trotz teilweise mehr CLKs zwischen Ein- und Ausgängen (Latenz) erhöht wird. Dieser lässt sich darüber hinaus durch die Nutzung paralleler Architekturen verbessern.

Die Systemfrequenz kann-, muss aber nicht der Frequenz entsprechen, mit der Daten zyklisch eingetaktet und verarbeitet werden; zudem sind Schaltungsteile mit unterschiedlichen Taktfrequenzen zu unterscheiden: Mit einem Systemtakt1 von 20 MHz lassen sich z.B. 18-Bit AD-Wandler auslesen, die so z.B. alle 1 µs neue Daten liefern, die verarbeitet werden müssen. Bei der Nutzung von 5 solchen Wandlern, die sequentiell verarbeitet werden, lägen 5 MHz Datenfrequenz vor. Für andere Schaltungsteile, die z.B. asynchron an die Peripherie andocken, sowie reine »state machines« können Schaltungsteile auf der 2-4 fachen Frequenz betrieben werden.

Generell sind Fläche und Geschwindigkeit konkurrierende Größen, zwischen denen ein Optimum gefunden werden muss. Für die preiswerten FPGA-Serien wie Spartan (Xilinx) und Cyclone (Altera) sind aufgrund technologischer Randbedingungen etwa 10-30% weniger Taktgeschwindigkeit bei gleichem Design zu erwarten, bzw. muss mit mehr Verbrauch an Logikelementen und Taktzyklen gerechnet werden (weniger Routingreserven, geringere Zahl von LUT-Eingängen, weniger hard-ressourcen).

Identische Chips werden oft in 2 oder mehr Geschwindigkeitsklassen angeboten, die sich meist durch Bauteilselektion bei der Produktion ergeben. Grob kann man ca. 5%-10% höhere Taktung zwischen zwei Speedgrades erwarten.

== Hersteller ==
Die größten Hersteller von FPGAs sind Altera und Xilinx. Weitere Hersteller sind Lattice, Actel und Atmel.

* [http://www.altera.com Altera]
* [http://www.xilinx.com Xilinx]
* [http://www.lattice.com Lattice]
* [http://www.actel.com Actel]

== Anwendung ==

Der Aufbau komplizierter, applikationsnaher Strukturen wird meist durch automatische Routing- und Synthesewerkzeuge erledigt, welche mit einer logischen, funktionellen Beschreibung der Architektur in einer Hardwarebeschreibungssprache wie z.B. VHDL "gefüttert" werden. Die Hardwarebeschreibung in VHDL gelingt ihrerseits z.B. mit VHDL-generierenden Werkzeugen, mittels derer zuvor Logikstrukturen, hardwarenahe Strukturen, Ablaufdiagramme und Zustandsautomaten formuliert wurden.

Durch die Standardisierung der Architektur einerseits und die Entkoppplung von applikationsorientierter Beschreibung sowie Chip- und Hersteller-spezifischer Synthese andererseits, wird die Hardware quasi als Software gebaut. Dies wiederum schafft alle Optionen der Wiederverwendung und Austausch von "Hardwareteilen". So stehen inzwischen komplett nutzbare Schaltungen wie serielle Bausteine, RAM-Controller und vieles mehr als Open Source zur Verfügung.

== Entwicklungsboards und Starterkits ==
=== Boards für Xilinx-FPGAs ===

{| border="1" class="sortable" id="fpgaevalboards"
|-
! Bezeichn.
! Preis (€)
! FPGA
! RAM (MByte)
! Flash (MByte)
! USB
! Ethernet
! RS-232
! µC
! Eingabe
! sonst.
|-
| [http://www.knjn.com/board_Xylo.html Xylo-L]
| 130
| XC3S500E
| -
| -
| 2.0
| 10base-T
| -
| LPC213x
| -
|
|-
| [http://www.xilinx.com/s3estarter Spartan3e Starter Kit]
| 180
| XC3S500E
| 64 MB DDR-SDRAM
| 16
| (JTAG)
| 10/100
| 2x
| -
| 4 Taster, 1 Drehgeber, 4 Schalter
| Coolrunner CPLD, LCD, 3-Bit VGA, PS/2
|-
| [http://www.digilentinc.com/Products/Detail.cfm?Nav1=Products&Nav2=Programmable&Prod=S3BOARD Digilent Spartan-3]
| 100
| XC3S200/400/1000
| 1
| -
| -
| -
| 1x
| -
| 4 Taster, 8 Schalter
| VGA, PS/2, 7seg
|-
| [[Digilent Nexys]]
| 100
| XC3S200/400/1000
| 16
| 4
| 2.0
| -
| -
| -
| 4 Taster, 8 Schalter
| 7seg, Programmierung & Stromversorgung über USB
|-
| [http://www.uxibo.de Uxibo]
| 88
| XC2S200E
| -
| -
| 1.1
| -
| -
| -
| 4 Taster, 8 Schalter
| VGA I/O, Videomux, dual PS/2, 7seg, Buzzer, IOs auf Pinleisten, dual-channel FTDI2232C, 48 MHz + prog. Oszillator, Programmierung & Stromversorgung über USB
|-
| [http://www.fpgaz.com/wiki/doku.php?id=fpgaz:usbp:hw FPGAz USBP]
| $135
| XC3S400
| -
| -
| 2.0
| -
| -
| Cypress FX2
| 2 Taster
| 8 LEDs, I2C-EEPROM
|-
| [http://www.cesys.com/fpga/spartan/efm01_de.html EFM 01] Embedded FPGA Modul
| 145,-
| XC3S500E
| -
| 4
| 2.0
| -
| -
| FX-2
| -
| 28 x 44mm, 50 I/O auf 2.54mm Stiftleiste, WIN und LINUX Treiber
|}

==== Raggedstone 1 - Spartan-3 Development PCI-Karte ====
* Spartan-3 FPGA FG456-Package
* 32 bit, 33 MHz, 3.3/5V PCI interface
* 4Mbit Flash Memory
* 16KBit serielles EEprom
* 4 x 7 Segment Anzeigen LED, abnehmbar
* LM75 Temperatursensor
* viele DIL-Header für eigene Erweiterungen, verschiedene werden auch durch Hersteller angeboten
* 2 Drucktaster
* Mit dem PCI-Interface kann bei entsprechender Programmierung des FPGA auf den PCI-Bus eines Hostrechners zugegriffen werden, Beispieldesign unter http://projects.varxec.net/raggedstone1
* Webseite: http://www.enterpoint.co.uk/moelbryn/raggedstone1.html
* Preis mit XC3S400 ca. €145,- (inkl MWST)
* Preis mit XC3S1500 ca. €255,- (inkl. MWST)

==== LiveDesign Evaluation Board von Altium ====
* Kompatibel mit den LiveDesign-fähigen Entwicklungstools von Altium
* Xilinx-Version direkt mit ISE Webpack nutzbar
* Xilinx XC3S1000-4FG456C, wahlweise aber auch mit Altera EP1C12F324C8 (s.u.)
* Mit Flachbandkabel für PC-Verbindung (Druckerport) sowie weiteren Kabeln und Verbindern
* Peripherie: LEDs, Dip-Schalter, 6-stellige Siebensegmentanzeige, Taster, Stereo-DAC, zwei 256K x 16 RAMs
* ''kein'' on-board Flash RAM für FPGA-Konfiguration, diese muss nach dem Einschalten neu geladen werden
* Ports: PS2-Maus & -Tastatur, RS232, VGA (512 Farben), 2x18 IO-Pins für allgemeine Zwecke
* Listenpreis $99,- Endpreis: ~150 Euro (inkl. MwSt. und Versand)

==== BurchED ====
http://www.burched.com/index.html
australischer Anbieter von Xilinx-Evaluationsboards
zur Zeit Webseite im Umbau

==== Trenz-Electronic ====
http://www.trenz-electronic.de/products.html
* Kleines FPGA Board mit ucLinux und Virtex-II PowerPC, optional: ucLinux und Microblaze Softprozessor im Spartan-3 FPGA
* Spartan-3 FPGA Mikromodul mit 200K bis 1000K Systemgattern
* Pal/Gal kompatible FPGA und CPLD Module

==== Simple-Solutions ====
http://www.simple-solutions.de/de/products/index.php
Mehrere Spartan3-FPGAs - Boards

==== CESYS ====
http://www.cesys.com

Cesys ist Entwickler und Hersteller von FPGA-boards mit Sitz in Deutschland.

* Verschiedene FPGA boards mit USB, PCI und PCIe Schnittstellen im Lieferprogramm
* Je nach Ausführung mit Spartan-2/3/3E, Virtex2/2PRO/4
* verschiedene Speicherkonfigurationen (SO-DIMM, SRAM, SDRAM, DDR2)

=== Boards für Altera-FPGAs ===
==== LiveDesign Evaluation Board von Altium ====
* Kompatibel mit den LiveDesign-fähigen Entwicklungstools von Altium
* * Wahlweise mit Altera EP1C12F324C8 oder Xilinx XC3S1000-4FG456C
* Mit Flachbandkabel für PC-Verbindung (Druckerport) sowie weiteren Kabeln und Verbindern
* Peripherie: LEDs, Dip-Schalter, 6-stellige Siebensegmentanzeige, Taster, Stereo-DAC, zwei 256K x 16 RAMs
* ''kein'' on-board Flash RAM für FPGA-Konfiguration, diese muss nach dem Einschalten neu geladen werden
* Ports: PS2-Maus & -Tastatur, RS232, VGA (512 Farben), 2x18 IO-Pins für allgemeine Zwecke
* Endpreis: ~150 Euro (inkl. MwSt. und Versand)

==== Terasic TREX C1 Multimedia Development Kit ====
* Altera EP1C6Q240C8 & EP1S Serial Configuration Device
* Built-in USB Blaster programming circuitry (JTAG and AS mode)
* 1 MiB Flash Memory & 8 MiB SDRAM (1M x 4 x 16)
* CF Card Socket, 16-bit CD-quality Audio DAC
* TV Encoder, VGA, RS-232, PS/2, and more
* Many reference designs and C++ applications
* [http://www.terasic.com.tw/cgi-bin/page/archive.pl?Language=English&CategoryNo=39&No=14 www.terasic.com.tw]
* fertiger Core eines CPC6128 (8-Bit Homecomputer von 1984) für dieses Board, inlusive Sourcecode (eigener Z80 in AHDL, mit 24MHz eingesetzt): [http://www.symbos.de/trex.htm http://www.symbos.de/trex.htm]
* Listenpreis $149,-

==== Altera Cyclone II 2C20 ====
* Altera Cyclone II EP2C20F484C7N FPGA mit 20000 LEs
* USB-BlasterTM download cable (integriert)
* EPCS4 serial configuration Flash
* 8-Mbyte SDRAM, 512-Kb SRAM, 4-Mbyte flash
* externer SMA - Clock-Eingang
* 24-bit Audio coder/decoder (CODEC)
* 10 Schalter, 4 Druckknöpfe inkl Reset
* 4St. 7-Segmentanzeigen, 10 rote LEDs + 8 grüne LEDs
* VGA, RS-232, and PS/2 Stecker
* Zwei 40-pin expansion ports + SD/MMC socket
* USB-Kabel, externes Steckernetztteil, CD-Rom
* Reference designs
* Qartus II Web Edition + NIOS II Web Edition
* http://www.altera.com/products/devkits/altera/kit-cyc2-2C20N.html
* Listenpreis $150,-

==== Hpe Mini AC II - Altera Cyclone board von Gleichmann Research ====
* Altera Cyclone II EP2C35 FPGA (speed grade 6)
* Mit reprogrammierbarem Flash zur automatischen FPGA-Konfiguration
* 25 pin SUB-D connector (parallel) für direktes FPGA-Programmieren
* RS232 (9 pin SUB-D)
* VGA (15 pin SUB-D) mit 64 möglichen Farben
* Ethernet 10/100 Mbit/s, full/half duplex
* 1 USB 2.0 compatible full-speed target connector
* 3 USB 2.0 compatible full-speed host connectors
* Santa Cruz connector mit 40 nutzbaren I/Os
* Audio interface (line-in and line-out) mit CODEC
* SODIMM144 Sockel für (SDRAM) 256MB
* SDRAM-Speichersockel mit nur 32-Bit angebunden, die Hälfte des Speichers bleibt nicht nutzbar
* 25 MHz oscillator
* Prototyping area, Lötfläche
* 8 LEDs, grün, blau, 3x4 key matrix, 4-bit DIP switch
* LCD connector, 2-character 7-segment display
* Single step Knopf und Reset Knopf
* Parallelportkabel für PC
* Beispieldesign, Testprogramme, Datenblätter
* LEON3-CPU Design inkl. Source Code, Quartus IDE, SnapGear Linux
* Je nach Ausführung des Flashs €399,- bis €499,-

==== Altera DE2 - Development and Education Board ====
* Altera Cyclone II 2C35 FPGA mit 35000 LEs
* Altera Serial Configuration devices (EPCS16) für Cyclone II 2C35
* USB Blaster board zur Programmierung und User API
* 8 MB SDRAM, 4 MB Flash Memory, 512KB SRAM
* SD Card Sockel, RS-232, Ethernet, 10-bit VGA, 24-bit Audio CODEC
* TV Decoder (NTSC/PAL), IrDA, USB (Host + Slave)
* Viele Besipiel mit Source Code wie TV, SD Music Player)
* [http://wwwab.fh-wedel.de/bause/handouts/vhdl/VhdlEinfuehrung.pdf Kleines aber nettes Tutorial zum Altera DE2 Dev. Board]
* Listenpreis US $495,-

==== Cyclone III embedded Development Kit====
* Altera Cyclone III EP3C25 FPGA
* 640x480 LCD Display mit touch screen function
* MiniSD-Card Sockel
* Audio Interface ADC CODEC
* 10/100 Mbit Fast Ethernet Schnittstelle
* FPGA-Konfiguration über USB
* NIOS II EVAL Lizenz
* IP LIB Altera
* Listenpreis US $495,- ueber ALtera Webseite
* Bei EBV €349,- inkl. MwSt.

==== Cyclone II EP2C35 Entwicklungsboard ====
* Altera Cyclone II EP2C35-F672C8 FPGA mit 33.216 LEs
* Insgesamt 172 I/Os exklusiv verfügbar
* Bis zu 256 MByte SDRAM (SODIMM Speichermodul, 64-Bit Busanbindung)
* 16 MByte Flash (16-Bit Busanbindung)
* MiniSD-Card Sockel
* 10/100 Mbit Fast Ethernet Schnittstellenkontroller
* USB 2.0 high speed (480 Mbit) Schnittstellenkontroller
* FPGA-Konfiguration über USB
* Abmessungen: 96mm x 68mm
* Kompatibel mit der frei verfügbaren Altera Entwicklungssoftware
* http://www.fpga-dev.de/index.php?site=ep2c35_beschreibung
* wird in regelmässigen Abständen für 169,- Euro über ebay vertrieben (einfach nach "altera cyclone" suchen)

==== NanoBoard-NB1 von Altium ====
* kompatibel mit den LiveDesign-fähigen Entwicklungstools von Altium
* Unterstützt eine breite Palette von Ziel-FPGAs durch Aufsteckplatinen
* Altera Cyclone (EP1C12-Q240C7) Aufsteckplatine enthalten
* Xilinx Spartan IIE (XC2S300E-PQ208) im Lieferumfang enthalten
* Enthält Stromversorgung mit verschiedenen Steckern für unterschiedliche Konfigurationen
* Mit Flachbandkabel für PC-Verbindung sowie weiteren Kabeln und Verbindern
* NanoBoard-NB1 Reference-Handbuch zur Hardware
* Peripherie: LCD, LEDs, Dip-Schalter, Tastenblock, Summer, ADC/DAC, 256K x 8 RAM, 8 MiB Serial Flash RAM, on-board Serial Flash RAM für FPGA-Konfig.
* Ports: PS2-Maus & -Tastatur, RS232, CAN, VGA, I2C, IO Stecker für allg. Zwecke
* Upgradefähige NanoBoard Controller Firmware
* Stabiler NanoBard-Sockel
* Listenpreis €995,-
=== Debugging-Hilfen ===
==== BusProbe, der Debugging Core von abaxor engineering ====
Gerade beim Debugging größerer FPGA-Designs ist es oft notwendig auf interne Signale und Busse zuzugreifen, ohne sie an Pins des FPGAs legen zu können.
Mit der BusProbe kann der Entwickler den Signalfluss im FPGA-Design auch über einen längeren Zeitraum überwachen und am PC aufzeichnen. Der Core verarbeitet an jedem Eingang einen kompletten Bus.

Die Daten werden gemultiplext zum PC geschickt und dort per Software demultiplext. Im PC erfolgt auch die Auswertung mit beliebigen Analyse-Tools.

Gegenüber dem Betriebssystem verhält sich die BusProbe wie eine Festplatte, von der die Daten mit gewöhnlichen Zugriffen gelesen werden können.

* Streaming der Daten zum PC mit mehr als 20 MByte/s
* keine Treiber im PC da Nutzung von Standardschnittstellen (USB oder IDE)
* Hot-Pluging
* Visualisierung mit beliebigen Programmen
* geringer Logikaufwand

[http://www.abaxor.de/produkte.html abaxor.de-Webseite]

==== open source Logikanalysator von sump.org====
Ein einfacher, übersichtlicher Logikanalysator findet sich auf sump.org. Er liegt im Quelltext vor wird mit ins Design einsynthetisiert. Als Speicher dient wahlweise SRAM oder intern RAM. Es können 32 Kanäle mit 100 MHz (oder weniger) gesampelt werden. Die Bediensoftware läuft platformunabhängig unter Java und benötigt eine serielle Schnittstelle (auch über USB-seriell Wandler) zum Core.

[http://de.sump.org/projects/analyzer/ sump.org-Webseite]

== Siehe auch ==
* [[Hardwarebeschreibungssprachen]]
* [[Reset für FPGA/CPLD]]
* [[Taktung FPGA/CPLD]]
* Projekt [[Audio-DSP mit Spartan 3-FPGA]]

== Weblinks ==
* [http://www.fpga4fun.com/index.html FPGA4Fun] - FPGA-Projekte, größtenteils mit Altera und Verilog
* [http://video.google.com/videoplay?docid=-4969729965240981475 Ein Vortrag, auf Englisch: General Purpose, Low Power Supercomputing Using Reconfiguration Logic]
* http://www.opencores.org - FPGA-Projekte, Opensource, jeder kann seine Eigen einstellen und an andere mitarbeiten. U.a. verschiede CPUs für FPGAs.
* http://members.optushome.com.au/jekent/FPGA.htm

[[Category:FPGA und Co]]

Optokoppler

2008-08-08T09:12:31Z

Mixer: Beschreibung

== Beschreibung ==

Optokoppler dienen zur Kopplung elektronischer Schaltungen mit Hilfe von Lichtenergie. In einem Optokoppler befindet sich ein Lichtsender ([[LED]]) und ein Lichtempfänger (z.B. Fototransistor), welche durch einen sehr kurzen Lichtleiter verbunden sind. Die elektrische (galvanische) Trennung zwischen Eingang / Ausgang ermöglicht Kopplung von Schaltungen sehr unterschiedlichen Spannungsniveaus. Das ist notwendig bei gefährlich hohen Spannungen, störverseuchten Umgebungen oder zur Verhinderung von Masseschleifen. Neben Optokopplern mit Fototransistoren als Lichtempfänger gibt es Typen mit Fotodioden oder Triacs. Typen mit Photodioden sind dabei wesentlich schneller als Transistor- und Triactypen. Ausserdem gibt es noch komplett integrierte Typen, welche ohne weitere Beschaltung wie ein normaler digitaler IC verwendet werden können.

Die meisten Optokoppler sind nur für digiale Signale nutzbar. Zur elektrischen Trennung von analogen Signalen eignen sich spezielle lineare Optokoppler. Diese haben meist zwei Photoempfänger, meist Photodioden. Eine Photodiode dient als [[Galvanische Trennung | galvanisch getrennter Ausgang]], die Zweite als Vergleichsausgang zur Kompensation von Drift- und Alterungseffekten. Durch diese lässt sich eine Regelung aufbauen die den LED-Strom proportional zur Helligkeit einstellt. Dadurch ist die Übertragungsfunktion des Optokopplers als linear anzusehen. Daher wird im Zusammenhang mit analogen Optokopplern häufig auch von linearen Optokopplern gesprochen.

== Standardtypen ==

Dies soll keine erschöpfende Auflistung aller möglichen Typen sein, sondern hobbyübliche Standardtypen zusammenfassen.

=== Typen mit Transistorausgang ===

* CNY17/x: 1-fach Koppler im DIL6-Gehäuse
* PC817-Serie: 1-,2-,3- und 4-fachTyp verfügbar, CTR: 50%, 80 kHz
* 6N135, 6N136: 1-fach Typ, DIL8, Highspeed 1 MBit/s
* 6N137: 1-fach Typ, DIL8, Highspeed 10 Mbit/s
* HCPL 2630: 2-fach Typ, DIL8, Highspeed 10 Mbit/s

=== Typen mit Triacausgang ===

* IL4218 TRIAC DRIVER OPTOCOUPLER
* MOC3020 6-Pin DIP Random-Phase Optoisolators Triac Driver Output

=== Lineare Optokoppler ===

* Agilent HCNR-200/201
* Vishay IL300

== Beispiele ==

* [[I2C-Schaltmodul]] mit Optokoppler MOC3040 zur galvanischen Trennung von [[I2C]]-[[Bus]] und 230 Volt Netzspannung.

[[Category:Bauteile]]

Servo

2008-08-05T12:09:44Z

Mixer: Ein kleiner Rechtschreibfehler

Der '''Servo''' ist unter die Aktuatoren einzuordnen und besteht aus
* Elektromotor mit Getriebe (Getriebemotor)
* Positions-Rückmelde Einrichtung (das Poti)
* elektronischen Steuerung und Regelung
Die Gehäuse und die Befestigungsmöglichkeiten sind quasi genormt, sodass man oft einen Servo probeweise durch einen anderen ersetzen kann. Derartige Servos sind im Modellbau seit langem im Gebrauch und daher ausgereift und in den Abmessungen kompakt. Sie sind auch günstig zu bekommen, etwa ab 5,- € bis über 100,- €. Die billigen sind oft langsamer und weniger präzise was den gewünschten anzufahrenden Winkel angeht. Auch kann bei minderwertigen Servos in manchen Positionen oder unter Last ein gewisses Zittern beobachtet werden. Einige Servos sind auch nicht besonders EMV - fest.

Im Modellbau werden damit Ruder von Flugzeugen oder Booten gesteuert. Die Servos haben meist einen aufgesetzten (austauschbaren) Hebelharm der einen Winkel von etwa 270 Grad durchlaufen kann. Sie können bestimmte Positionen in recht kurzer Zeit erreichen (<1 Sek bzw etwas darüber) und dank des integrierten Getriebes und der elektronischen Positionsüberwachung wird diese Position auch gehalten. Bei Stromlosigkeit allerdings können Servos bereits mit wenig Kraft gedreht werden, je nachdem welcher Widerstand durch das Getriebe aufgebracht werden kann.

Übliche Servos brauchen eine Versorgungsspannung von 5-6 V, sowie ein Ansteuersignal in etwa gleicher Höhe. Ein TTL Pegel oder µC-Output ist benutzbar. Die anzufahrende oder zu haltende Position wird durch die Impulsbreite des (normalerweise vom Fernsteuerempfänger bereitgestellten) Kanalimpulses bestimmt. Die Impulsbreite beträgt üblicherweise 1ms bis 2ms, wobei 1,5ms der Mittelstellung entspricht. Der Kanalimpuls wird etwa alle 20ms wiederholt. Die genauen Werte von Impulsabstand und Impulsbreite können von Hersteller zu Hersteller etwas variieren (0,8ms..2,2ms).

Die '''digitalen''' Servos haben eine höhere Stellgenauigkeit, ziehen auch meist mehr Strom, kosten aber mehr. (ab etwa 40,- €).

Sonderform: "Segelwinde", '''Windenservo'''. Diese Formen sind auf Kraftentwicklung hin ausgelegt. Der Abtriebskopf, der anstatt eines Hebels mit einer Scheibe bestückt wird, kann mehrere vollständige 360° Umdrehungen ausführen.

[[Category:Bauteile]]

Benutzer:Mixer

2008-02-27T16:42:55Z

Mixer:

=zur Person=

Komme aus Bayerisch-Schwaben nahe Augsburg

*Baujahr 1987
*Bayerischer Realschulabschluss 2004
*Facharbeiterprüfung Elektroniker für Betriebstechnik 2008
*zur Zeit in der Montage eines Energieversorgers tätig
*ab 09/2008 Berufsoberschule

=Interessen=
==Elektronik==
*AVR, bis jetzt nur ASM
*Elektronik allgemein
*Linux (Ubuntu)

==andere Interessen==
*Schießen, Gewehr und Pistole (aber nur mit Luft)
*aktiver Sport
*Fußball
*Formel 1

Benutzer:Mixer

2008-02-25T18:05:31Z

Mixer: erster Test

Hallo aus Bayern!