Mikrocontroller.net - Benutzerbeiträge [de]

Lötkolben

2013-10-19T15:48:49Z

Quecksilber: /* Lötnadeln (ca. 5 bis 10 Watt) */

[[Category:Löten]]
Der Lötkolben ist das zur manuellen Erstellung von Lötverbindungen vorwiegend benutzte Werkzeug.

Da im professionellen Bereich sowie unter erfahrenen Elektronikern das entsprechende Know-How sicher vorhanden ist, wendet sich diese Seite in erster Linie an Hobbyisten und andere Einsteiger, etwa solche, die als ehemalige "reine" Software-Entwickler nun im hardwarenahen Bereich ihre ersten Schritte mit Mikrocontroller-Aufbauten machen möchten.

== Arten von Lötkolben ==

Um elektronische Schaltungen erfolgreich aufzubauen, sollte man zunächst wissen, welche Arten von Lötkolben es gibt, und wozu sie geeignet sind.

=== Lötnadeln (ca. 5 bis 10 Watt) ===

Diese "Miniatur-Lötkolben" sind nur für feinste Arbeiten, bei denen man oft auch eine Lupe einsetzen wird, sinnvoll. Beispiele dafür sind:
* Anlöten extrem dünner Drähte, z. B. solche aus der "Wire-Wrap"-Wickeltechnik;
* Korrektur- und Nachlötungen bei beengten Verhältnissen, z. B. an SMD-Bauteilen;
* Reparatur schmaler Leiterbahnen mit einem Haarriss (oder vorsorgliches Verzinnen beim Verdacht auf einen solchen).

Lötnadeln werden häufig mit Niederspannung versorgt (z. B. 12 Volt) und können daher mit Hilfe eines einstellbaren Netzteils auch mit etwas Unter- oder Übertemperatur betrieben werden. Generell sind sie aber eher ein Werkzeug für den "fortgeschrittenen" (Hobby-) Elektroniker und nicht so gut geeignet, um überhaupt erst einmal Übung im Löten zu bekommen.

Für den fortgeschrittenen Anwender mit einer guten Lötstation (Ersa i-Con, Weller PU81 oder vergleichbar) empfiehlt es sich nicht mehr, eine Lötnadel zu kaufen, die digital geregelten Lötkolben sind dem haushoch überlegen und haben auch die nötige Leistung, um an Platinen mit großen Masseflächen oder thermischer Abführung (klassisch: Mainboards) überhaupt noch löten zu können.
Durch die sehr guten Regelungen der aktuellen Digitalstationen und die kurzen Lötspitzen (z.B. Weller LC-Serie) ist auch der Wärmewiderstand zwischen Heizelement und Lötspitze kein Problem für kleine Löttargets, die trotzdem viel Wärme brauchen.

=== Feinlötkolben (ca. 15 bis 20 Watt) ===
Diese kleinen, leichten Lötkolben kommen zum Einsatz, wenn es um die Bestückung von Platinen oder das An- und Ablöten dünner Drähte und Litzen geht. Lediglich für das Herstellen von Verbindungen, über die später stärkere Ströme (im Bereich einiger Ampere) fließen sollen, also z. B. zum Auflöten einer Litze höheren Querschnitts auf eine größere Kupferfläche sind sie etwas schwach. Für Anfänger, die wenig Geld ausgeben wollen, sind Feinlötkolben am ehesten zu empfehlen.

Auch diese Art von Lötkolben gibt es für Niederspannung. Man braucht dann zwar zum Betrieb ein entsprechendes Netzteil, kann dafür aber (bei einstellbarer Ausgangsspannung des Netzteils) die Leistung des Lötkolbens innerhalb gewisser Grenzen variieren.

=== Elektronik-Universallötkolben (ca. 30 Watt) ===
Sie sind das "Standardwerkzeug" des Elektronikers, aber für alle, die hauptsächlich Schaltungsaufbauten im Bereich Mikrocontroller erstellen, fast schon unnötig groß. Ausgestattet mit unterschiedlichen Lötspitzen (siehe unten) sind Lötkolben dieser Klasse für viele Arbeiten geeignet, wenn auch meist etwas unhandlicher als Feinlötkolben.

Auszunehmen sind lediglich die oben unter "Lötnadel" beschriebenen Arbeiten - es sei denn man hat wirklich großes Geschick und eine sehr ruhige Hand. Am anderen Ende der Skala denkbarer Arbeiten wird man sich allenfalls für das zügige An- und Ablöten sehr dicker Drähte oder Litzen auf/von massiven Metallteilen manchmal mehr Leistungsreserve wünschen, kommt in der Regel aber auch mit einem 30 Watt Lötkolben zum Erfolg.

Da solche Lötkolben typischerweise an 230 Volt betrieben werden, erübrigt sich auch ein eigenes Netzteil (bzw. man kann die Spannung seines Labor-Netzteils stets für den Versuchsaufbau passend eingestellt lassen), auf der anderen Seite entfällt damit die Möglichkeit, die Leistung des Lötkolbens in einem gewissen Umfang zu variieren.

=== Temperaturgeregelte Lötkolben (ca. 60 Watt) ===
"Mehr" ist nicht immer automatisch "besser", und so ist eine höhere Leistung bei Lötkolben problematisch, weil der Lötkolben "im Leerlauf" oder bei kleineren Lötstellen zu heiß werden kann. Aus diesem Grund sollte man in der Leistungsklasse oberhalb 30 Watt besser gleich in einen temperaturgeregelten Lötkolben investieren. Zwar sind diese deutlich teurer als Lötkolben der ersten drei Kategorien, aber zerstörte Bauteile oder verdorbene Platinen verursachen auf Dauer noch höhere Kosten und sind auf jeden Fall ärgerlich.

Ein weiterer Vorteil der Investition in einen solchen Lötkolben ist, dass sich damit auch schon mal kleinere Reparaturarbeiten außerhalb des Elektronikbereichs durchführen lassen (etwa Spielzeug etc.).

Fuer den Einstieg reicht die "Analog 60" oder Weller "Temptronic" allemal:

Analog 60
+ Betrieb direkt aus dem soliden Blechkoffer heraus
+ heisse Lötspitze mit Zange problemlos wechselbar (ein Handgriff)
- Regelung teilweise hörbar (leises Klacken)

Weller Temptronic
+
- um eine heiße Loetspitze zu wechseln muss erst das Röhrchen vom Thermoelement entfernt werden und dann die Spitze. Vorsicht alles heiss

siehe: http://www.mikrocontroller.net/forum/read-1-369049.html#new

=== Große Lötkolben (über 60 Watt) ===
Diese sind in der Regel kein Werkzeug für den Elektroniker - es sei denn man denkt an das Verlöten von Metallgehäusen zur Abschirmung oder an das Löten von Akkus oder Solarzellen - und eher für allgemeine Reparaturen im Haushalt geeignet. Aber wenn man durch die Beschäftigung mit der Elektronik schon mal "das Löten gelernt hat", will man diese Fähigkeiten vielleicht auch anderweitig einsetzen...ij

== Arten von Lötspitzen ==
Bei den meisten Lötkolben kann die eigentliche Lötspitze ausgwechselt werden. Dies ist zum einen erforderlich, weil sich die Spitze im Lauf der Zeit abnutzt (was aber je nach Nutzungshäufigkeit des Lötkolbens und Materialqualität der Spitze Jahre dauern kann). Zum anderen wird man insbesondere bei stärkeren Lötkolben abhängig von der Arbeit, die man durchführen möchte, unterschiedlich geformte Spitzen benötigen.

=== Kegelförmig ===
Leicht kegelförmige Spitzen, die vorne in einer Halbkugel (Durchmesser meist unter 1 mm) auslaufen, eignen sich besonders für "beengte Verhältnisse", also nahe beieinander liegende Pins, geringen Leiterbahnabstand usw. Das Problem solcher Spitzen bei anderen Arbeiten ist, dass die Kontaktfläche zu den zu verlötenden Teilen recht gering ist. Da beim Löten - wie unter "[[Löten (praktisch)]]" ausgeführt - stets die zu verlötenden Teile und nicht das Lötzinn erwärmt werden sollte, kann das Herstellen größerer Lötverbindungen mit solchen Spitzen länger als nötig dauern. Die Folge können durch Hitze zerstörte Bauteile sein (wenn die Spitze so gehalten wurde, dass vor allem das Bauteil, nicht aber die Leiterbahn erwärmt wurde) oder sich ablösende Leiterbahnen (im umgekehrten Fall).

=== Breit und Flach ===
Mit diesen, etwa nach der Art eines Schraubendrehers (aka. "Schraubenzieher" - aber nicht nach DIN! :-)) geformten Lötspitzen lässt sich je nach dem, wie man sie ansetzt, ein größerer oder kleinerer Kontakt zu den zu verlötenden Teilen herstellen. Unter beengten Verhältnissen ist aber, selbst wenn man sie "hochkant" hält, die Gefahr gegeben, Lötzinn an Stellen zu verschmieren, wo es nicht hingehört und z. B. zu einem Kurzschluss führt.

=== Zylindrisch/Angeschrägt ===
Es ist sicher auch eine Geschmacks- und Übungssache, aber Spitzen, die eine zylindrische Grundform haben (Durchmesser etwa 1,5..2,5 mm) und vorne im Winkel von ca. 45 Grad angeschnitten sind, bieten eine überraschend große Bandbreite von Einsatzmöglichkeiten. Insbesondere für etwas "faule" und "ungeduldige" Naturen, die nicht dauernd zwischen den verschiedenen Lötspitzen ihres Lötkolbens wechseln wollen, sind solche Spitzen günstig. Aufgrund der Asymmetrie findet man ferner - etwas Übung vorausgesetzt - mit solchen Spitzen fast immer einen Ansatzpunkt, der es erlaubt, die beiden zu verlötenden Teile gleichmäßig schnell zu erwärmen. (Achtung: Gleichmäßig bedeutet hier vor allem, dass man ggf. das Teil mit der geringeren thermischen Masse, das sich also ''schneller'' erwärmen wird, auch nur mit der ''kleineren'' Fläche der Spitze in Kontakt bringen wird!)

=== Abgewinkelt vs. Gerade ===
Auch hier mag Erfahrung, Übung und Geschick eine Rolle spielen, aber im Bereich der (Fein-) Elektronik werden meist gerade Spitzen bevorzugt. Insbesondere beim Löten auf gedruckten Schaltungen erlaubt die "bleistiftähnliche" Haltung eines Lötkolbens mit gerader Spitze eine präzisere Positionierung.

=== Spezielle Spitzen ===
Für temperaturgeregelte Lötkolben gibt es als Sonderzubehör meist spezielle Lötspitzen zum Entlöten, z. B. solche, die sämtliche Pins eines ICs auf einmal erhitzen, oder Spitzen mit einer Bohrung im Inneren und einem aufgesetzten Gummiball, durch die man Lötzinn absaugen kann.

== Noch etwas "Theorie" ==
An dieser Stelle noch einmal kurz zum Einfluss von Leistung und Temperatur auf das Lötergebnis.

=== Einfluss der Leistung ===
Ein Lötkolben höherer Leistung ist vor allem dann angebracht, wenn größere Metallteile (z. B. großflächige Masse-Leiterbahnen) erwärmt werden müssen. Dass ein Lötkolben für eine bestimmte Arbeit "deutlich zu schwach" ist, merkt man daran, dass die Lötspitze nach dem ersten Aufsetzen kurz "anklebt", weil die große kalte Fläche das an der Spitze des Lötkolbens hängende, geschmolzene Lötzinn wieder fest werden lässt.

Bei ungeregelten Lötkolben wird hier zusätzlich die "thermische Masse" der Lötspitze ins Spiel kommen, d.h. mit einer massiven Spitze, die selbst sehr viel mehr Wärme speichert als die zu verlötenden Teile, wird sich dieser Effekt kaum einstellen, mit der dünnen Spitze einer sehr feinen Lötnadel schon eher. Bei einem Niederspannungslötkolben, den man über ein einstellbares Netzteil betreibt, kann man in diesem Fall über die Spannung die Leistung etwas erhöhen. Aber Achtung: Der Zusammenhang ist nicht linear, 10% mehr Spannung sind rund 21% mehr Leistung, 20% mehr Spannung rund 45% mehr Leistung(*1,*2).

=== Einfluss der Temperatur ===
Bekanntlich vertragen Halbleiterbauteile es nicht, wenn sie zu heiß werden. Das gilt nicht nur für die Wärme, die sie im laufenden Betrieb selbst entwickeln, sondern auch für die Erhitzung ihrer Anschlussdrähte oder -pins beim Löten.

Ein Fehlschluss wäre es nun aber anzunehmen, dass man durch eine geringere Temperatur des Lötkolbens dieser Gefahr vorbeugen könnte. Bis die über einen Draht oder Pin zugeführte Wärme das Innere des Bauteils erreicht (wo die hohe Temperatur ihre schädlichen Auswirkungen entfaltet), vergehen einige Sekunden. Braucht man aufgrund verringerter Temperatur nun für den gesamten Lötvorgang doppelt oder dreimal so lang, wird dies die Gefahr für das Halbleiterbauelement sogar erhöhen - ob die Lötspitze dann eine Temperatur 350 Grad oder "nur" 280 Grad hat, ändert nicht viel. Merke: Weniger die geringe Temperatur als ein zügiger Lötvorgang sollte das Ziel sein! (Allerdings wird sich bei zu hoher Temperatur das Flussmittel im Lötzinn möglicherweise verflüchtigen, ohne ausreichend Wirkung entfaltet zu haben!)

----
* 1: Wieviel Mehrleistung man dem Lötkolben zumuten darf, bevor er kaputt geht, ist schwer zu sagen. Der Autor dieser Zeilen verwendet seit über 30 Jahren für die meisten seiner Aufbauten einen Lötkolben von 12 Watt, der "offiziell" mit 6 Volt zu betreiben ist. Tatsächlich wird der Lötkolben aber je nach Bedarf mit 5, 6 oder 7 Volt betrieben, entsprechend einer Mehr- und Minderleistung von etwa 30%.

* 2: Obacht bei solchen Rechnungen: Das Heizelement eines Lötkolbens dürfte einen erheblichen positiven Temperaturkoeffizienten haben, der den Einfluss der Betriebsspannung auf die Leistung deutlich reduziert.

STM32F10x Standard Peripherals Library

2012-01-23T10:13:15Z

Quecksilber: /* Clocks - Der Herzschlag unseres Mikrocontroller */

=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 [http://www.st.com/internet/com/SOFTWARE_RESOURCES/SW_COMPONENT/FIRMWARE/stm32f10x_stdperiph_lib.zip download]. 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. Das raffinierte daran ist, dass nur Bits, die im '''BRR''' gesetzt sind, auch im Port verändert werden. Nicht gesetzte Bits wirken sich auf den tatsächlich Portzustand nicht aus.

<c>
GPIOC->BRR = GPIO_Pin_13;
</c>

Löscht das entprechende Bit wieder.

Die ''Standard Peripheral Library'' stellt für dies Zugriffe allerdings auch komfortable 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 Konfoguriert 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, welche hier nicht genauer erklärt werden soll.

'''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]
* [https://sourceforge.net/projects/libopenstm32/ libopenstm32] -- Eine Open-Source Alternative (GPL, Version 3 oder höher) zur ST Library
* Artikel [[STM32]]

[[Kategorie:STM32]]